Merge branch 'fix/pcm-jiffies-check' into fix/asoc

271 files changed, 12461 insertions, 8971 deletions

diff --git a/sound/Kconfig b/sound/Kconfig
index 200aca1faa71..1eceb85287c5 100644
--- a/sound/Kconfig
+++ b/sound/Kconfig
@@ -60,6 +60,8 @@ source "sound/aoa/Kconfig"
 
 source "sound/arm/Kconfig"
 
+source "sound/atmel/Kconfig"
+
 source "sound/spi/Kconfig"
 
 source "sound/mips/Kconfig"
diff --git a/sound/Makefile b/sound/Makefile
index c76d70716fa5..ec467decfa79 100644
--- a/sound/Makefile
+++ b/sound/Makefile
@@ -6,7 +6,7 @@ obj-$(CONFIG_SOUND_PRIME) += sound_firmware.o
 obj-$(CONFIG_SOUND_PRIME) += oss/
 obj-$(CONFIG_DMASOUND) += oss/
 obj-$(CONFIG_SND) += core/ i2c/ drivers/ isa/ pci/ ppc/ arm/ sh/ synth/ usb/ \
-        sparc/ spi/ parisc/ pcmcia/ mips/ soc/
+        sparc/ spi/ parisc/ pcmcia/ mips/ soc/ atmel/
 obj-$(CONFIG_SND_AOA) += aoa/
 
 # This one must be compilable even if sound is configured out
diff --git a/sound/aoa/aoa-gpio.h b/sound/aoa/aoa-gpio.h
index ee64f5de8966..6065b0344e23 100644
--- a/sound/aoa/aoa-gpio.h
+++ b/sound/aoa/aoa-gpio.h
@@ -34,10 +34,12 @@ struct gpio_methods {
         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);
+        void (*set_master)(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);
+        int (*get_master)(struct gpio_runtime *rt);
 
         void (*set_hw_reset)(struct gpio_runtime *rt, int on);
 
diff --git a/sound/aoa/codecs/onyx.c b/sound/aoa/codecs/onyx.c
index 15500b9d2da0..84bb07d39a7f 100644
--- a/sound/aoa/codecs/onyx.c
+++ b/sound/aoa/codecs/onyx.c
@@ -47,7 +47,7 @@ MODULE_DESCRIPTION("pcm3052 (onyx) codec driver for snd-aoa");
 struct onyx {
         /* cache registers 65 to 80, they are write-only! */
         u8                      cache[16];
-        struct i2c_client       i2c;
+        struct i2c_client       *i2c;
         struct aoa_codec        codec;
         u32                     initialised:1,
                                 spdif_locked:1,
@@ -72,7 +72,7 @@ static int onyx_read_register(struct onyx *onyx, u8 reg, u8 *value)
                 *value = onyx->cache[reg-FIRSTREGISTER];
                 return 0;
         }
-        v = i2c_smbus_read_byte_data(&onyx->i2c, reg);
+        v = i2c_smbus_read_byte_data(onyx->i2c, reg);
         if (v < 0)
                 return -1;
         *value = (u8)v;
@@ -84,7 +84,7 @@ static int onyx_write_register(struct onyx *onyx, u8 reg, u8 value)
 {
         int result;
 
-        result = i2c_smbus_write_byte_data(&onyx->i2c, reg, value);
+        result = i2c_smbus_write_byte_data(onyx->i2c, reg, value);
         if (!result)
                 onyx->cache[reg-FIRSTREGISTER] = value;
         return result;
@@ -996,12 +996,45 @@ static void onyx_exit_codec(struct aoa_codec *codec)
         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 i2c_board_info info;
+        struct i2c_client *client;
+
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "aoa_codec_onyx", I2C_NAME_SIZE);
+        info.addr = addr;
+        info.platform_data = node;
+        client = i2c_new_device(adapter, &info);
+        if (!client)
+                return -ENODEV;
+
+        /*
+         * We know the driver is already loaded, so the device should be
+         * already bound. If not it means binding failed, which suggests
+         * the device doesn't really exist and should be deleted.
+         * Ideally this would be replaced by better checks _before_
+         * instantiating the device.
+         */
+        if (!client->driver) {
+                i2c_unregister_device(client);
+                return -ENODEV;
+        }
+
+        /*
+         * Let i2c-core delete that device on driver removal.
+         * This is safe because i2c-core holds the core_lock mutex for us.
+         */
+        list_add_tail(&client->detected, &client->driver->clients);
+        return 0;
+}
+
+static int onyx_i2c_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id)
+{
+        struct device_node *node = client->dev.platform_data;
         struct onyx *onyx;
         u8 dummy;
 
@@ -1011,20 +1044,12 @@ static int onyx_create(struct i2c_adapter *adapter,
                 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);
-
-        if (i2c_attach_client(&onyx->i2c)) {
-                printk(KERN_ERR PFX "failed to attach to i2c\n");
-                goto fail;
-        }
+        onyx->i2c = client;
+        i2c_set_clientdata(client, onyx);
 
         /* 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;
         }
@@ -1036,14 +1061,14 @@ static int onyx_create(struct i2c_adapter *adapter,
         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:
+        i2c_set_clientdata(client, NULL);
         kfree(onyx);
-        return -EINVAL;
+        return -ENODEV;
 }
 
 static int onyx_i2c_attach(struct i2c_adapter *adapter)
@@ -1080,28 +1105,33 @@ static int onyx_i2c_attach(struct i2c_adapter *adapter)
         return onyx_create(adapter, NULL, 0x47);
 }
 
-static int onyx_i2c_detach(struct i2c_client *client)
+static int onyx_i2c_remove(struct i2c_client *client)
 {
-        struct onyx *onyx = container_of(client, struct onyx, i2c);
-        int err;
+        struct onyx *onyx = i2c_get_clientdata(client);
 
-        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);
+        i2c_set_clientdata(client, onyx);
         kfree(onyx);
         return 0;
 }
 
+static const struct i2c_device_id onyx_i2c_id[] = {
+        { "aoa_codec_onyx", 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,
+        .probe = onyx_i2c_probe,
+        .remove = onyx_i2c_remove,
+        .id_table = onyx_i2c_id,
 };
 
 static int __init onyx_init(void)
diff --git a/sound/aoa/codecs/tas.c b/sound/aoa/codecs/tas.c
index 008e0f85097d..f0ebc971c686 100644
--- a/sound/aoa/codecs/tas.c
+++ b/sound/aoa/codecs/tas.c
@@ -82,7 +82,7 @@ MODULE_DESCRIPTION("tas codec driver for snd-aoa");
 
 struct tas {
         struct aoa_codec        codec;
-        struct i2c_client       i2c;
+        struct i2c_client       *i2c;
         u32                     mute_l:1, mute_r:1 ,
                                 controls_created:1 ,
                                 drc_enabled:1,
@@ -108,9 +108,9 @@ static struct tas *codec_to_tas(struct aoa_codec *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);
+                return i2c_smbus_write_byte_data(tas->i2c, reg, *data);
         else
-                return i2c_smbus_write_i2c_block_data(&tas->i2c, reg, len, data);
+                return i2c_smbus_write_i2c_block_data(tas->i2c, reg, len, data);
 }
 
 static void tas3004_set_drc(struct tas *tas)
@@ -882,12 +882,34 @@ static void tas_exit_codec(struct aoa_codec *codec)
 }
 
 
-static struct i2c_driver tas_driver;
-
 static int tas_create(struct i2c_adapter *adapter,
                        struct device_node *node,
                        int addr)
 {
+        struct i2c_board_info info;
+        struct i2c_client *client;
+
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "aoa_codec_tas", I2C_NAME_SIZE);
+        info.addr = addr;
+        info.platform_data = node;
+
+        client = i2c_new_device(adapter, &info);
+        if (!client)
+                return -ENODEV;
+
+        /*
+         * Let i2c-core delete that device on driver removal.
+         * This is safe because i2c-core holds the core_lock mutex for us.
+         */
+        list_add_tail(&client->detected, &client->driver->clients);
+        return 0;
+}
+
+static int tas_i2c_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct device_node *node = client->dev.platform_data;
         struct tas *tas;
 
         tas = kzalloc(sizeof(struct tas), GFP_KERNEL);
@@ -896,17 +918,11 @@ static int tas_create(struct i2c_adapter *adapter,
                 return -ENOMEM;
 
         mutex_init(&tas->mtx);
-        tas->i2c.driver = &tas_driver;
-        tas->i2c.adapter = adapter;
-        tas->i2c.addr = addr;
+        tas->i2c = client;
+        i2c_set_clientdata(client, tas);
+
         /* seems that half is a saner default */
         tas->drc_range = TAS3004_DRC_MAX / 2;
-        strlcpy(tas->i2c.name, "tas audio codec", I2C_NAME_SIZE);
-
-        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);
         tas->codec.owner = THIS_MODULE;
@@ -915,14 +931,12 @@ static int tas_create(struct i2c_adapter *adapter,
         tas->codec.node = of_node_get(node);
 
         if (aoa_codec_register(&tas->codec)) {
-                goto detach;
+                goto fail;
         }
         printk(KERN_DEBUG
                "snd-aoa-codec-tas: tas found, addr 0x%02x on %s\n",
-               addr, node->full_name);
+               (unsigned int)client->addr, node->full_name);
         return 0;
- detach:
-        i2c_detach_client(&tas->i2c);
  fail:
         mutex_destroy(&tas->mtx);
         kfree(tas);
@@ -970,14 +984,11 @@ static int tas_i2c_attach(struct i2c_adapter *adapter)
         return -ENODEV;
 }
 
-static int tas_i2c_detach(struct i2c_client *client)
+static int tas_i2c_remove(struct i2c_client *client)
 {
-        struct tas *tas = container_of(client, struct tas, i2c);
-        int err;
+        struct tas *tas = i2c_get_clientdata(client);
         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);
 
@@ -989,13 +1000,20 @@ static int tas_i2c_detach(struct i2c_client *client)
         return 0;
 }
 
+static const struct i2c_device_id tas_i2c_id[] = {
+        { "aoa_codec_tas", 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,
+        .probe = tas_i2c_probe,
+        .remove = tas_i2c_remove,
+        .id_table = tas_i2c_id,
 };
 
 static int __init tas_init(void)
diff --git a/sound/aoa/core/gpio-feature.c b/sound/aoa/core/gpio-feature.c
index c93ad5dec66b..de8e03afa97b 100644
--- a/sound/aoa/core/gpio-feature.c
+++ b/sound/aoa/core/gpio-feature.c
@@ -14,7 +14,7 @@
 #include <linux/interrupt.h>
 #include "../aoa.h"
 
-/* TODO: these are 20 global variables
+/* TODO: these are lots of global variables
  * that aren't used on most machines...
  * Move them into a dynamically allocated
  * structure and use that.
@@ -23,6 +23,7 @@
 /* these are the GPIO numbers (register addresses as offsets into
  * the GPIO space) */
 static int headphone_mute_gpio;
+static int master_mute_gpio;
 static int amp_mute_gpio;
 static int lineout_mute_gpio;
 static int hw_reset_gpio;
@@ -32,6 +33,7 @@ static int linein_detect_gpio;
 
 /* see the SWITCH_GPIO macro */
 static int headphone_mute_gpio_activestate;
+static int master_mute_gpio_activestate;
 static int amp_mute_gpio_activestate;
 static int lineout_mute_gpio_activestate;
 static int hw_reset_gpio_activestate;
@@ -156,6 +158,7 @@ static int ftr_gpio_get_##name(struct gpio_runtime *rt)		\
 FTR_GPIO(headphone, 0);
 FTR_GPIO(amp, 1);
 FTR_GPIO(lineout, 2);
+FTR_GPIO(master, 3);
 
 static void ftr_gpio_set_hw_reset(struct gpio_runtime *rt, int on)
 {
@@ -172,6 +175,8 @@ static void ftr_gpio_set_hw_reset(struct gpio_runtime *rt, int on)
                           hw_reset_gpio, v);
 }
 
+static struct gpio_methods methods;
+
 static void ftr_gpio_all_amps_off(struct gpio_runtime *rt)
 {
         int saved;
@@ -181,6 +186,8 @@ static void ftr_gpio_all_amps_off(struct gpio_runtime *rt)
         ftr_gpio_set_headphone(rt, 0);
         ftr_gpio_set_amp(rt, 0);
         ftr_gpio_set_lineout(rt, 0);
+        if (methods.set_master)
+                ftr_gpio_set_master(rt, 0);
         rt->implementation_private = saved;
 }
 
@@ -193,6 +200,8 @@ static void ftr_gpio_all_amps_restore(struct gpio_runtime *rt)
         ftr_gpio_set_headphone(rt, (s>>0)&1);
         ftr_gpio_set_amp(rt, (s>>1)&1);
         ftr_gpio_set_lineout(rt, (s>>2)&1);
+        if (methods.set_master)
+                ftr_gpio_set_master(rt, (s>>3)&1);
 }
 
 static void ftr_handle_notify(struct work_struct *work)
@@ -231,6 +240,12 @@ static void ftr_gpio_init(struct gpio_runtime *rt)
         get_gpio("hw-reset", "audio-hw-reset",
                  &hw_reset_gpio,
                  &hw_reset_gpio_activestate);
+        if (get_gpio("master-mute", NULL,
+                     &master_mute_gpio,
+                     &master_mute_gpio_activestate)) {
+                methods.set_master = ftr_gpio_set_master;
+                methods.get_master = ftr_gpio_get_master;
+        }
 
         headphone_detect_node = get_gpio("headphone-detect", NULL,
                                          &headphone_detect_gpio,
diff --git a/sound/aoa/fabrics/layout.c b/sound/aoa/fabrics/layout.c
index ad60f5d10e82..fbf5c933baa4 100644
--- a/sound/aoa/fabrics/layout.c
+++ b/sound/aoa/fabrics/layout.c
@@ -1,16 +1,14 @@
 /*
- * Apple Onboard Audio driver -- layout fabric
+ * Apple Onboard Audio driver -- layout/machine id fabric
  *
- * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2006-2008 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.
- *
+ * This fabric module looks for sound codecs based on the
+ * layout-id or device-id property in the device tree.
  */
-
 #include <asm/prom.h>
 #include <linux/list.h>
 #include <linux/module.h>
@@ -63,7 +61,7 @@ struct codec_connect_info {
 #define LAYOUT_FLAG_COMBO_LINEOUT_SPDIF (1<<0)
 
 struct layout {
-        unsigned int layout_id;
+        unsigned int layout_id, device_id;
         struct codec_connect_info codecs[MAX_CODECS_PER_BUS];
         int flags;
 
@@ -111,6 +109,10 @@ MODULE_ALIAS("sound-layout-96");
 MODULE_ALIAS("sound-layout-98");
 MODULE_ALIAS("sound-layout-100");
 
+MODULE_ALIAS("aoa-device-id-14");
+MODULE_ALIAS("aoa-device-id-22");
+MODULE_ALIAS("aoa-device-id-35");
+
 /* onyx with all but microphone connected */
 static struct codec_connection onyx_connections_nomic[] = {
         {
@@ -518,6 +520,27 @@ static struct layout layouts[] = {
                 .connections = onyx_connections_noheadphones,
           },
         },
+        /* PowerMac3,4 */
+        { .device_id = 14,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_noline,
+          },
+        },
+        /* PowerMac3,6 */
+        { .device_id = 22,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_all,
+          },
+        },
+        /* PowerBook5,2 */
+        { .device_id = 35,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_all,
+          },
+        },
         {}
 };
 
@@ -526,7 +549,7 @@ static struct layout *find_layout_by_id(unsigned int id)
         struct layout *l;
 
         l = layouts;
-        while (l->layout_id) {
+        while (l->codecs[0].name) {
                 if (l->layout_id == id)
                         return l;
                 l++;
@@ -534,6 +557,19 @@ static struct layout *find_layout_by_id(unsigned int id)
         return NULL;
 }
 
+static struct layout *find_layout_by_device(unsigned int id)
+{
+        struct layout *l;
+
+        l = layouts;
+        while (l->codecs[0].name) {
+                if (l->device_id == id)
+                        return l;
+                l++;
+        }
+        return NULL;
+}
+
 static void use_layout(struct layout *l)
 {
         int i;
@@ -564,6 +600,7 @@ struct layout_dev {
         struct snd_kcontrol *headphone_ctrl;
         struct snd_kcontrol *lineout_ctrl;
         struct snd_kcontrol *speaker_ctrl;
+        struct snd_kcontrol *master_ctrl;
         struct snd_kcontrol *headphone_detected_ctrl;
         struct snd_kcontrol *lineout_detected_ctrl;
 
@@ -615,6 +652,7 @@ static struct snd_kcontrol_new n##_ctl = {				\
 AMP_CONTROL(headphone, "Headphone Switch");
 AMP_CONTROL(speakers, "Speakers Switch");
 AMP_CONTROL(lineout, "Line-Out Switch");
+AMP_CONTROL(master, "Master Switch");
 
 static int detect_choice_get(struct snd_kcontrol *kcontrol,
                              struct snd_ctl_elem_value *ucontrol)
@@ -855,6 +893,11 @@ static void layout_attached_codec(struct aoa_codec *codec)
         lineout = codec->gpio->methods->get_detect(codec->gpio,
                                                    AOA_NOTIFY_LINE_OUT);
 
+        if (codec->gpio->methods->set_master) {
+                ctl = snd_ctl_new1(&master_ctl, codec->gpio);
+                ldev->master_ctrl = ctl;
+                aoa_snd_ctl_add(ctl);
+        }
         while (cc->connected) {
                 if (cc->connected & CC_SPEAKERS) {
                         if (headphones <= 0 && lineout <= 0)
@@ -938,8 +981,8 @@ static struct aoa_fabric layout_fabric = {
 static int aoa_fabric_layout_probe(struct soundbus_dev *sdev)
 {
         struct device_node *sound = NULL;
-        const unsigned int *layout_id;
-        struct layout *layout;
+        const unsigned int *id;
+        struct layout *layout = NULL;
         struct layout_dev *ldev = NULL;
         int err;
 
@@ -952,15 +995,18 @@ static int aoa_fabric_layout_probe(struct soundbus_dev *sdev)
                 if (sound->type && strcasecmp(sound->type, "soundchip") == 0)
                         break;
         }
-        if (!sound) return -ENODEV;
+        if (!sound)
+                return -ENODEV;
 
-        layout_id = of_get_property(sound, "layout-id", NULL);
-        if (!layout_id)
-                goto outnodev;
-        printk(KERN_INFO "snd-aoa-fabric-layout: found bus with layout %d\n",
-               *layout_id);
+        id = of_get_property(sound, "layout-id", NULL);
+        if (id) {
+                layout = find_layout_by_id(*id);
+        } else {
+                id = of_get_property(sound, "device-id", NULL);
+                if (id)
+                        layout = find_layout_by_device(*id);
+        }
 
-        layout = find_layout_by_id(*layout_id);
         if (!layout) {
                 printk(KERN_ERR "snd-aoa-fabric-layout: unknown layout\n");
                 goto outnodev;
@@ -976,6 +1022,7 @@ static int aoa_fabric_layout_probe(struct soundbus_dev *sdev)
         ldev->layout = layout;
         ldev->gpio.node = sound->parent;
         switch (layout->layout_id) {
+        case 0:  /* anything with device_id, not layout_id */
         case 41: /* that unknown machine no one seems to have */
         case 51: /* PowerBook5,4 */
         case 58: /* Mac Mini */
diff --git a/sound/aoa/soundbus/i2sbus/core.c b/sound/aoa/soundbus/i2sbus/core.c
index be468edf3ecb..418c84c99d69 100644
--- a/sound/aoa/soundbus/i2sbus/core.c
+++ b/sound/aoa/soundbus/i2sbus/core.c
@@ -1,7 +1,7 @@
 /*
  * i2sbus driver
  *
- * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2006-2008 Johannes Berg <johannes@sipsolutions.net>
  *
  * GPL v2, can be found in COPYING.
  */
@@ -186,13 +186,25 @@ static int i2sbus_add_dev(struct macio_dev *macio,
                 }
         }
         if (i == 1) {
-                const u32 *layout_id =
-                        of_get_property(sound, "layout-id", NULL);
-                if (layout_id) {
-                        layout = *layout_id;
+                const u32 *id = of_get_property(sound, "layout-id", NULL);
+
+                if (id) {
+                        layout = *id;
                         snprintf(dev->sound.modalias, 32,
                                  "sound-layout-%d", layout);
                         ok = 1;
+                } else {
+                        id = of_get_property(sound, "device-id", NULL);
+                        /*
+                         * We probably cannot handle all device-id machines,
+                         * so restrict to those we do handle for now.
+                         */
+                        if (id && (*id == 22 || *id == 14 || *id == 35)) {
+                                snprintf(dev->sound.modalias, 32,
+                                         "aoa-device-id-%d", *id);
+                                ok = 1;
+                                layout = -1;
+                        }
                 }
         }
         /* for the time being, until we can handle non-layout-id
diff --git a/sound/arm/Kconfig b/sound/arm/Kconfig
index f8e6de48d816..885683a3b0bd 100644
--- a/sound/arm/Kconfig
+++ b/sound/arm/Kconfig
@@ -11,17 +11,6 @@ menuconfig SND_ARM
 
 if SND_ARM
 
-config SND_SA11XX_UDA1341
-        tristate "SA11xx UDA1341TS driver (iPaq H3600)"
-        depends on ARCH_SA1100 && L3
-        select SND_PCM
-        help
-          Say Y here if you have a Compaq iPaq H3x00 handheld computer
-          and want to use its Philips UDA 1341 audio chip.
-
-          To compile this driver as a module, choose M here: the module
-          will be called snd-sa11xx-uda1341.
-
 config SND_ARMAACI
         tristate "ARM PrimeCell PL041 AC Link support"
         depends on ARM_AMBA
diff --git a/sound/arm/Makefile b/sound/arm/Makefile
index 2054de11de8a..5a549ed6c8aa 100644
--- a/sound/arm/Makefile
+++ b/sound/arm/Makefile
@@ -2,9 +2,6 @@
 # Makefile for ALSA
 #
 
-obj-$(CONFIG_SND_SA11XX_UDA1341) += snd-sa11xx-uda1341.o 
-snd-sa11xx-uda1341-objs         := sa11xx-uda1341.o
-
 obj-$(CONFIG_SND_ARMAACI)       += snd-aaci.o
 snd-aaci-objs                   := aaci.o devdma.o
 
diff --git a/sound/arm/aaci.c b/sound/arm/aaci.c
index 7d39aac9ec14..7fbd68fab944 100644
--- a/sound/arm/aaci.c
+++ b/sound/arm/aaci.c
@@ -90,7 +90,7 @@ static void aaci_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
          */
         do {
                 v = readl(aaci->base + AACI_SLFR);
-        } while ((v & (SLFR_1TXB|SLFR_2TXB)) && timeout--);
+        } while ((v & (SLFR_1TXB|SLFR_2TXB)) && --timeout);
 
         if (!timeout)
                 dev_err(&aaci->dev->dev,
@@ -126,7 +126,7 @@ static unsigned short aaci_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
          */
         do {
                 v = readl(aaci->base + AACI_SLFR);
-        } while ((v & SLFR_1TXB) && timeout--);
+        } while ((v & SLFR_1TXB) && --timeout);
 
         if (!timeout) {
                 dev_err(&aaci->dev->dev, "timeout on slot 1 TX busy\n");
@@ -147,7 +147,7 @@ static unsigned short aaci_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
         do {
                 cond_resched();
                 v = readl(aaci->base + AACI_SLFR) & (SLFR_1RXV|SLFR_2RXV);
-        } while ((v != (SLFR_1RXV|SLFR_2RXV)) && timeout--);
+        } while ((v != (SLFR_1RXV|SLFR_2RXV)) && --timeout);
 
         if (!timeout) {
                 dev_err(&aaci->dev->dev, "timeout on RX valid\n");
diff --git a/sound/arm/pxa2xx-ac97-lib.c b/sound/arm/pxa2xx-ac97-lib.c
index 71bef45e9d31..a2c12d105c9a 100644
--- a/sound/arm/pxa2xx-ac97-lib.c
+++ b/sound/arm/pxa2xx-ac97-lib.c
@@ -21,7 +21,6 @@
 #include <sound/pxa2xx-lib.h>
 
 #include <asm/irq.h>
-#include <mach/hardware.h>
 #include <mach/regs-ac97.h>
 #include <mach/pxa2xx-gpio.h>
 #include <mach/audio.h>
@@ -365,7 +364,7 @@ EXPORT_SYMBOL_GPL(pxa2xx_ac97_hw_resume);
 int __devinit pxa2xx_ac97_hw_probe(struct platform_device *dev)
 {
         int ret;
-        struct pxa2xx_ac97_platform_data *pdata = dev->dev.platform_data;
+        pxa2xx_audio_ops_t *pdata = dev->dev.platform_data;
 
         if (pdata) {
                 switch (pdata->reset_gpio) {
diff --git a/sound/arm/pxa2xx-ac97.c b/sound/arm/pxa2xx-ac97.c
index 7ed100c80a5f..c570ebd9d177 100644
--- a/sound/arm/pxa2xx-ac97.c
+++ b/sound/arm/pxa2xx-ac97.c
@@ -20,8 +20,6 @@
 #include <sound/initval.h>
 #include <sound/pxa2xx-lib.h>
 
-#include <mach/hardware.h>
-#include <mach/pxa-regs.h>
 #include <mach/regs-ac97.h>
 #include <mach/audio.h>
 
diff --git a/sound/arm/pxa2xx-pcm-lib.c b/sound/arm/pxa2xx-pcm-lib.c
index 75a0d746fb60..108b643229ba 100644
--- a/sound/arm/pxa2xx-pcm-lib.c
+++ b/sound/arm/pxa2xx-pcm-lib.c
@@ -12,8 +12,7 @@
 #include <sound/pcm_params.h>
 #include <sound/pxa2xx-lib.h>
 
-#include <asm/dma.h>
-#include <mach/pxa-regs.h>
+#include <mach/dma.h>
 
 #include "pxa2xx-pcm.h"
 
diff --git a/sound/arm/sa11xx-uda1341.c b/sound/arm/sa11xx-uda1341.c
deleted file mode 100644
index 51d708c31e65..000000000000
--- a/sound/arm/sa11xx-uda1341.c
+++ /dev/null
@@ -1,984 +0,0 @@
-/*
- *  Driver for Philips UDA1341TS on Compaq iPAQ H3600 soundcard
- *  Copyright (C) 2002 Tomas Kasparek <tomas.kasparek@seznam.cz>
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License.
- * 
- * History:
- *
- * 2002-03-13   Tomas Kasparek  initial release - based on h3600-uda1341.c from OSS
- * 2002-03-20   Tomas Kasparek  playback over ALSA is working
- * 2002-03-28   Tomas Kasparek  playback over OSS emulation is working
- * 2002-03-29   Tomas Kasparek  basic capture is working (native ALSA)
- * 2002-03-29   Tomas Kasparek  capture is working (OSS emulation)
- * 2002-04-04   Tomas Kasparek  better rates handling (allow non-standard rates)
- * 2003-02-14   Brian Avery     fixed full duplex mode, other updates
- * 2003-02-20   Tomas Kasparek  merged updates by Brian (except HAL)
- * 2003-04-19   Jaroslav Kysela recoded DMA stuff to follow 2.4.18rmk3-hh24 kernel
- *                              working suspend and resume
- * 2003-04-28   Tomas Kasparek  updated work by Jaroslav to compile it under 2.5.x again
- *                              merged HAL layer (patches from Brian)
- */
-
-/***************************************************************************************************
-*
-* To understand what Alsa Drivers should be doing look at "Writing an Alsa Driver" by Takashi Iwai
-* available in the Alsa doc section on the website              
-* 
-* A few notes to make things clearer. The UDA1341 is hooked up to Serial port 4 on the SA1100.
-* We are using  SSP mode to talk to the UDA1341. The UDA1341 bit & wordselect clocks are generated
-* by this UART. Unfortunately, the clock only runs if the transmit buffer has something in it.
-* So, if we are just recording, we feed the transmit DMA stream a bunch of 0x0000 so that the
-* transmit buffer is full and the clock keeps going. The zeroes come from FLUSH_BASE_PHYS which
-* is a mem loc that always decodes to 0's w/ no off chip access.
-*
-* Some alsa terminology:
-*       frame => num_channels * sample_size  e.g stereo 16 bit is 2 * 16 = 32 bytes
-*       period => the least number of bytes that will generate an interrupt e.g. we have a 1024 byte
-*             buffer and 4 periods in the runtime structure this means we'll get an int every 256
-*             bytes or 4 times per buffer.
-*             A number of the sizes are in frames rather than bytes, use frames_to_bytes and
-*             bytes_to_frames to convert.  The easiest way to tell the units is to look at the
-*             type i.e. runtime-> buffer_size is in frames and its type is snd_pcm_uframes_t
-*             
-*       Notes about the pointer fxn:
-*       The pointer fxn needs to return the offset into the dma buffer in frames.
-*       Interrupts must be blocked before calling the dma_get_pos fxn to avoid race with interrupts.
-*
-*       Notes about pause/resume
-*       Implementing this would be complicated so it's skipped.  The problem case is:
-*       A full duplex connection is going, then play is paused. At this point you need to start xmitting
-*       0's to keep the record active which means you cant just freeze the dma and resume it later you'd
-*       need to save off the dma info, and restore it properly on a resume.  Yeach!
-*
-*       Notes about transfer methods:
-*       The async write calls fail.  I probably need to implement something else to support them?
-* 
-***************************************************************************************************/
-
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/init.h>
-#include <linux/err.h>
-#include <linux/platform_device.h>
-#include <linux/errno.h>
-#include <linux/ioctl.h>
-#include <linux/delay.h>
-#include <linux/slab.h>
-
-#ifdef CONFIG_PM
-#include <linux/pm.h>
-#endif
-
-#include <mach/hardware.h>
-#include <mach/h3600.h>
-#include <asm/mach-types.h>
-#include <asm/dma.h>
-
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/initval.h>
-
-#include <linux/l3/l3.h>
-
-#undef DEBUG_MODE
-#undef DEBUG_FUNCTION_NAMES
-#include <sound/uda1341.h>
-
-/*
- * FIXME: Is this enough as autodetection of 2.4.X-rmkY-hhZ kernels?
- * We use DMA stuff from 2.4.18-rmk3-hh24 here to be able to compile this
- * module for Familiar 0.6.1
- */
-
-/* {{{ Type definitions */
-
-MODULE_AUTHOR("Tomas Kasparek <tomas.kasparek@seznam.cz>");
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("SA1100/SA1111 + UDA1341TS driver for ALSA");
-MODULE_SUPPORTED_DEVICE("{{UDA1341,iPAQ H3600 UDA1341TS}}");
-
-static char *id;        /* ID for this card */
-
-module_param(id, charp, 0444);
-MODULE_PARM_DESC(id, "ID string for SA1100/SA1111 + UDA1341TS soundcard.");
-
-struct audio_stream {
-        char *id;               /* identification string */
-        int stream_id;          /* numeric identification */    
-        dma_device_t dma_dev;   /* device identifier for DMA */
-#ifdef HH_VERSION
-        dmach_t dmach;          /* dma channel identification */
-#else
-        dma_regs_t *dma_regs;   /* points to our DMA registers */
-#endif
-        unsigned int active:1;  /* we are using this stream for transfer now */
-        int period;             /* current transfer period */
-        int periods;            /* current count of periods registerd in the DMA engine */
-        int tx_spin;            /* are we recoding - flag used to do DMA trans. for sync */
-        unsigned int old_offset;
-        spinlock_t dma_lock;    /* for locking in DMA operations (see dma-sa1100.c in the kernel) */
-        struct snd_pcm_substream *stream;
-};
-
-struct sa11xx_uda1341 {
-        struct snd_card *card;
-        struct l3_client *uda1341;
-        struct snd_pcm *pcm;
-        long samplerate;
-        struct audio_stream s[2];       /* playback & capture */
-};
-
-static unsigned int rates[] = {
-        8000,  10666, 10985, 14647,
-        16000, 21970, 22050, 24000,
-        29400, 32000, 44100, 48000,
-};
-
-static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
-        .count  = ARRAY_SIZE(rates),
-        .list   = rates,
-        .mask   = 0,
-};
-
-static struct platform_device *device;
-
-/* }}} */
-
-/* {{{ Clock and sample rate stuff */
-
-/*
- * Stop-gap solution until rest of hh.org HAL stuff is merged.
- */
-#define GPIO_H3600_CLK_SET0             GPIO_GPIO (12)
-#define GPIO_H3600_CLK_SET1             GPIO_GPIO (13)
-
-#ifdef CONFIG_SA1100_H3XXX
-#define clr_sa11xx_uda1341_egpio(x)     clr_h3600_egpio(x)
-#define set_sa11xx_uda1341_egpio(x)     set_h3600_egpio(x)
-#else
-#error This driver could serve H3x00 handhelds only!
-#endif
-
-static void sa11xx_uda1341_set_audio_clock(long val)
-{
-        switch (val) {
-        case 24000: case 32000: case 48000:     /* 00: 12.288 MHz */
-                GPCR = GPIO_H3600_CLK_SET0 | GPIO_H3600_CLK_SET1;
-                break;
-
-        case 22050: case 29400: case 44100:     /* 01: 11.2896 MHz */
-                GPSR = GPIO_H3600_CLK_SET0;
-                GPCR = GPIO_H3600_CLK_SET1;
-                break;
-
-        case 8000: case 10666: case 16000:      /* 10: 4.096 MHz */
-                GPCR = GPIO_H3600_CLK_SET0;
-                GPSR = GPIO_H3600_CLK_SET1;
-                break;
-
-        case 10985: case 14647: case 21970:     /* 11: 5.6245 MHz */
-                GPSR = GPIO_H3600_CLK_SET0 | GPIO_H3600_CLK_SET1;
-                break;
-        }
-}
-
-static void sa11xx_uda1341_set_samplerate(struct sa11xx_uda1341 *sa11xx_uda1341, long rate)
-{
-        int clk_div = 0;
-        int clk=0;
-
-        /* We don't want to mess with clocks when frames are in flight */
-        Ser4SSCR0 &= ~SSCR0_SSE;
-        /* wait for any frame to complete */
-        udelay(125);
-
-        /*
-         * We have the following clock sources:
-         * 4.096 MHz, 5.6245 MHz, 11.2896 MHz, 12.288 MHz
-         * Those can be divided either by 256, 384 or 512.
-         * This makes up 12 combinations for the following samplerates...
-         */
-        if (rate >= 48000)
-                rate = 48000;
-        else if (rate >= 44100)
-                rate = 44100;
-        else if (rate >= 32000)
-                rate = 32000;
-        else if (rate >= 29400)
-                rate = 29400;
-        else if (rate >= 24000)
-                rate = 24000;
-        else if (rate >= 22050)
-                rate = 22050;
-        else if (rate >= 21970)
-                rate = 21970;
-        else if (rate >= 16000)
-                rate = 16000;
-        else if (rate >= 14647)
-                rate = 14647;
-        else if (rate >= 10985)
-                rate = 10985;
-        else if (rate >= 10666)
-                rate = 10666;
-        else
-                rate = 8000;
-
-        /* Set the external clock generator */
-        
-        sa11xx_uda1341_set_audio_clock(rate);
-
-        /* Select the clock divisor */
-        switch (rate) {
-        case 8000:
-        case 10985:
-        case 22050:
-        case 24000:
-                clk = F512;
-                clk_div = SSCR0_SerClkDiv(16);
-                break;
-        case 16000:
-        case 21970:
-        case 44100:
-        case 48000:
-                clk = F256;
-                clk_div = SSCR0_SerClkDiv(8);
-                break;
-        case 10666:
-        case 14647:
-        case 29400:
-        case 32000:
-                clk = F384;
-                clk_div = SSCR0_SerClkDiv(12);
-                break;
-        }
-
-        /* FMT setting should be moved away when other FMTs are added (FIXME) */
-        l3_command(sa11xx_uda1341->uda1341, CMD_FORMAT, (void *)LSB16);
-        
-        l3_command(sa11xx_uda1341->uda1341, CMD_FS, (void *)clk);        
-        Ser4SSCR0 = (Ser4SSCR0 & ~0xff00) + clk_div + SSCR0_SSE;
-        sa11xx_uda1341->samplerate = rate;
-}
-
-/* }}} */
-
-/* {{{ HW init and shutdown */
-
-static void sa11xx_uda1341_audio_init(struct sa11xx_uda1341 *sa11xx_uda1341)
-{
-        unsigned long flags;
-
-        /* Setup DMA stuff */
-        sa11xx_uda1341->s[SNDRV_PCM_STREAM_PLAYBACK].id = "UDA1341 out";
-        sa11xx_uda1341->s[SNDRV_PCM_STREAM_PLAYBACK].stream_id = SNDRV_PCM_STREAM_PLAYBACK;
-        sa11xx_uda1341->s[SNDRV_PCM_STREAM_PLAYBACK].dma_dev = DMA_Ser4SSPWr;
-
-        sa11xx_uda1341->s[SNDRV_PCM_STREAM_CAPTURE].id = "UDA1341 in";
-        sa11xx_uda1341->s[SNDRV_PCM_STREAM_CAPTURE].stream_id = SNDRV_PCM_STREAM_CAPTURE;
-        sa11xx_uda1341->s[SNDRV_PCM_STREAM_CAPTURE].dma_dev = DMA_Ser4SSPRd;
-
-        /* Initialize the UDA1341 internal state */
-       
-        /* Setup the uarts */
-        local_irq_save(flags);
-        GAFR |= (GPIO_SSP_CLK);
-        GPDR &= ~(GPIO_SSP_CLK);
-        Ser4SSCR0 = 0;
-        Ser4SSCR0 = SSCR0_DataSize(16) + SSCR0_TI + SSCR0_SerClkDiv(8);
-        Ser4SSCR1 = SSCR1_SClkIactL + SSCR1_SClk1P + SSCR1_ExtClk;
-        Ser4SSCR0 |= SSCR0_SSE;
-        local_irq_restore(flags);
-
-        /* Enable the audio power */
-
-        clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_CODEC_NRESET);
-        set_sa11xx_uda1341_egpio(IPAQ_EGPIO_AUDIO_ON);
-        set_sa11xx_uda1341_egpio(IPAQ_EGPIO_QMUTE);
- 
-        /* Wait for the UDA1341 to wake up */
-        mdelay(1); //FIXME - was removed by Perex - Why?
-
-        /* Initialize the UDA1341 internal state */
-        l3_open(sa11xx_uda1341->uda1341);
-        
-        /* external clock configuration (after l3_open - regs must be initialized */
-        sa11xx_uda1341_set_samplerate(sa11xx_uda1341, sa11xx_uda1341->samplerate);
-
-        /* Wait for the UDA1341 to wake up */
-        set_sa11xx_uda1341_egpio(IPAQ_EGPIO_CODEC_NRESET);
-        mdelay(1);      
-
-        /* make the left and right channels unswapped (flip the WS latch) */
-        Ser4SSDR = 0;
-
-        clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_QMUTE);
-}
-
-static void sa11xx_uda1341_audio_shutdown(struct sa11xx_uda1341 *sa11xx_uda1341)
-{
-        /* mute on */
-        set_sa11xx_uda1341_egpio(IPAQ_EGPIO_QMUTE);
-        
-        /* disable the audio power and all signals leading to the audio chip */
-        l3_close(sa11xx_uda1341->uda1341);
-        Ser4SSCR0 = 0;
-        clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_CODEC_NRESET);
-
-        /* power off and mute off */
-        /* FIXME - is muting off necesary??? */
-
-        clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_AUDIO_ON);
-        clr_sa11xx_uda1341_egpio(IPAQ_EGPIO_QMUTE);
-}
-
-/* }}} */
-
-/* {{{ DMA staff */
-
-/*
- * these are the address and sizes used to fill the xmit buffer
- * so we can get a clock in record only mode
- */
-#define FORCE_CLOCK_ADDR                (dma_addr_t)FLUSH_BASE_PHYS
-#define FORCE_CLOCK_SIZE                4096 // was 2048
-
-// FIXME Why this value exactly - wrote comment
-#define DMA_BUF_SIZE    8176    /* <= MAX_DMA_SIZE from asm/arch-sa1100/dma.h */
-
-#ifdef HH_VERSION
-
-static int audio_dma_request(struct audio_stream *s, void (*callback)(void *, int))
-{
-        int ret;
-
-        ret = sa1100_request_dma(&s->dmach, s->id, s->dma_dev);
-        if (ret < 0) {
-                printk(KERN_ERR "unable to grab audio dma 0x%x\n", s->dma_dev);
-                return ret;
-        }
-        sa1100_dma_set_callback(s->dmach, callback);
-        return 0;
-}
-
-static inline void audio_dma_free(struct audio_stream *s)
-{
-        sa1100_free_dma(s->dmach);
-        s->dmach = -1;
-}
-
-#else
-
-static int audio_dma_request(struct audio_stream *s, void (*callback)(void *))
-{
-        int ret;
-
-        ret = sa1100_request_dma(s->dma_dev, s->id, callback, s, &s->dma_regs);
-        if (ret < 0)
-                printk(KERN_ERR "unable to grab audio dma 0x%x\n", s->dma_dev);
-        return ret;
-}
-
-static void audio_dma_free(struct audio_stream *s)
-{
-        sa1100_free_dma(s->dma_regs);
-        s->dma_regs = 0;
-}
-
-#endif
-
-static u_int audio_get_dma_pos(struct audio_stream *s)
-{
-        struct snd_pcm_substream *substream = s->stream;
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        unsigned int offset;
-        unsigned long flags;
-        dma_addr_t addr;
-        
-        // this must be called w/ interrupts locked out see dma-sa1100.c in the kernel
-        spin_lock_irqsave(&s->dma_lock, flags);
-#ifdef HH_VERSION       
-        sa1100_dma_get_current(s->dmach, NULL, &addr);
-#else
-        addr = sa1100_get_dma_pos((s)->dma_regs);
-#endif
-        offset = addr - runtime->dma_addr;
-        spin_unlock_irqrestore(&s->dma_lock, flags);
-        
-        offset = bytes_to_frames(runtime,offset);
-        if (offset >= runtime->buffer_size)
-                offset = 0;
-
-        return offset;
-}
-
-/*
- * this stops the dma and clears the dma ptrs
- */
-static void audio_stop_dma(struct audio_stream *s)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&s->dma_lock, flags); 
-        s->active = 0;
-        s->period = 0;
-        /* this stops the dma channel and clears the buffer ptrs */
-#ifdef HH_VERSION
-        sa1100_dma_flush_all(s->dmach);
-#else
-        sa1100_clear_dma(s->dma_regs);  
-#endif
-        spin_unlock_irqrestore(&s->dma_lock, flags);
-}
-
-static void audio_process_dma(struct audio_stream *s)
-{
-        struct snd_pcm_substream *substream = s->stream;
-        struct snd_pcm_runtime *runtime;
-        unsigned int dma_size;          
-        unsigned int offset;
-        int ret;
-                
-        /* we are requested to process synchronization DMA transfer */
-        if (s->tx_spin) {
-                if (snd_BUG_ON(s->stream_id != SNDRV_PCM_STREAM_PLAYBACK))
-                        return;
-                /* fill the xmit dma buffers and return */
-#ifdef HH_VERSION
-                sa1100_dma_set_spin(s->dmach, FORCE_CLOCK_ADDR, FORCE_CLOCK_SIZE);
-#else
-                while (1) {
-                        ret = sa1100_start_dma(s->dma_regs, FORCE_CLOCK_ADDR, FORCE_CLOCK_SIZE);
-                        if (ret)
-                                return;   
-                }
-#endif
-                return;
-        }
-
-        /* must be set here - only valid for running streams, not for forced_clock dma fills  */
-        runtime = substream->runtime;
-        while (s->active && s->periods < runtime->periods) {
-                dma_size = frames_to_bytes(runtime, runtime->period_size);
-                if (s->old_offset) {
-                        /* a little trick, we need resume from old position */
-                        offset = frames_to_bytes(runtime, s->old_offset - 1);
-                        s->old_offset = 0;
-                        s->periods = 0;
-                        s->period = offset / dma_size;
-                        offset %= dma_size;
-                        dma_size = dma_size - offset;
-                        if (!dma_size)
-                                continue;               /* special case */
-                } else {
-                        offset = dma_size * s->period;
-                        snd_BUG_ON(dma_size > DMA_BUF_SIZE);
-                }
-#ifdef HH_VERSION
-                ret = sa1100_dma_queue_buffer(s->dmach, s, runtime->dma_addr + offset, dma_size);
-                if (ret)
-                        return; //FIXME
-#else
-                ret = sa1100_start_dma((s)->dma_regs, runtime->dma_addr + offset, dma_size);
-                if (ret) {
-                        printk(KERN_ERR "audio_process_dma: cannot queue DMA buffer (%i)\n", ret);
-                        return;
-                }
-#endif
-
-                s->period++;
-                s->period %= runtime->periods;
-                s->periods++;
-        }
-}
-
-#ifdef HH_VERSION
-static void audio_dma_callback(void *data, int size)
-#else
-static void audio_dma_callback(void *data)
-#endif
-{
-        struct audio_stream *s = data;
-        
-        /* 
-         * If we are getting a callback for an active stream then we inform
-         * the PCM middle layer we've finished a period
-         */
-        if (s->active)
-                snd_pcm_period_elapsed(s->stream);
-
-        spin_lock(&s->dma_lock);
-        if (!s->tx_spin && s->periods > 0)
-                s->periods--;
-        audio_process_dma(s);
-        spin_unlock(&s->dma_lock);
-}
-
-/* }}} */
-
-/* {{{ PCM setting */
-
-/* {{{ trigger & timer */
-
-static int snd_sa11xx_uda1341_trigger(struct snd_pcm_substream *substream, int cmd)
-{
-        struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream);
-        int stream_id = substream->pstr->stream;
-        struct audio_stream *s = &chip->s[stream_id];
-        struct audio_stream *s1 = &chip->s[stream_id ^ 1];
-        int err = 0;
-
-        /* note local interrupts are already disabled in the midlevel code */
-        spin_lock(&s->dma_lock);
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-                /* now we need to make sure a record only stream has a clock */
-                if (stream_id == SNDRV_PCM_STREAM_CAPTURE && !s1->active) {
-                        /* we need to force fill the xmit DMA with zeros */
-                        s1->tx_spin = 1;
-                        audio_process_dma(s1);
-                }
-                /* this case is when you were recording then you turn on a
-                 * playback stream so we stop (also clears it) the dma first,
-                 * clear the sync flag and then we let it turned on
-                 */             
-                else {
-                        s->tx_spin = 0;
-                }
-
-                /* requested stream startup */
-                s->active = 1;
-                audio_process_dma(s);
-                break;
-        case SNDRV_PCM_TRIGGER_STOP:
-                /* requested stream shutdown */
-                audio_stop_dma(s);
-                
-                /*
-                 * now we need to make sure a record only stream has a clock
-                 * so if we're stopping a playback with an active capture
-                 * we need to turn the 0 fill dma on for the xmit side
-                 */
-                if (stream_id == SNDRV_PCM_STREAM_PLAYBACK && s1->active) {
-                        /* we need to force fill the xmit DMA with zeros */
-                        s->tx_spin = 1;
-                        audio_process_dma(s);
-                }
-                /*
-                 * we killed a capture only stream, so we should also kill
-                 * the zero fill transmit
-                 */
-                else {
-                        if (s1->tx_spin) {
-                                s1->tx_spin = 0;
-                                audio_stop_dma(s1);
-                        }
-                }
-                
-                break;
-        case SNDRV_PCM_TRIGGER_SUSPEND:
-                s->active = 0;
-#ifdef HH_VERSION               
-                sa1100_dma_stop(s->dmach);
-#else
-                //FIXME - DMA API
-#endif          
-                s->old_offset = audio_get_dma_pos(s) + 1;
-#ifdef HH_VERSION               
-                sa1100_dma_flush_all(s->dmach);
-#else
-                //FIXME - DMA API
-#endif          
-                s->periods = 0;
-                break;
-        case SNDRV_PCM_TRIGGER_RESUME:
-                s->active = 1;
-                s->tx_spin = 0;
-                audio_process_dma(s);
-                if (stream_id == SNDRV_PCM_STREAM_CAPTURE && !s1->active) {
-                        s1->tx_spin = 1;
-                        audio_process_dma(s1);
-                }
-                break;
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-#ifdef HH_VERSION               
-                sa1100_dma_stop(s->dmach);
-#else
-                //FIXME - DMA API
-#endif
-                s->active = 0;
-                if (stream_id == SNDRV_PCM_STREAM_PLAYBACK) {
-                        if (s1->active) {
-                                s->tx_spin = 1;
-                                s->old_offset = audio_get_dma_pos(s) + 1;
-#ifdef HH_VERSION                               
-                                sa1100_dma_flush_all(s->dmach);
-#else
-                                //FIXME - DMA API
-#endif                          
-                                audio_process_dma(s);
-                        }
-                } else {
-                        if (s1->tx_spin) {
-                                s1->tx_spin = 0;
-#ifdef HH_VERSION                               
-                                sa1100_dma_flush_all(s1->dmach);
-#else
-                                //FIXME - DMA API
-#endif                          
-                        }
-                }
-                break;
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                s->active = 1;
-                if (s->old_offset) {
-                        s->tx_spin = 0;
-                        audio_process_dma(s);
-                        break;
-                }
-                if (stream_id == SNDRV_PCM_STREAM_CAPTURE && !s1->active) {
-                        s1->tx_spin = 1;
-                        audio_process_dma(s1);
-                }
-#ifdef HH_VERSION               
-                sa1100_dma_resume(s->dmach);
-#else
-                //FIXME - DMA API
-#endif
-                break;
-        default:
-                err = -EINVAL;
-                break;
-        }
-        spin_unlock(&s->dma_lock);      
-        return err;
-}
-
-static int snd_sa11xx_uda1341_prepare(struct snd_pcm_substream *substream)
-{
-        struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream);
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct audio_stream *s = &chip->s[substream->pstr->stream];
-        
-        /* set requested samplerate */
-        sa11xx_uda1341_set_samplerate(chip, runtime->rate);
-
-        /* set requestd format when available */
-        /* set FMT here !!! FIXME */
-
-        s->period = 0;
-        s->periods = 0;
-        
-        return 0;
-}
-
-static snd_pcm_uframes_t snd_sa11xx_uda1341_pointer(struct snd_pcm_substream *substream)
-{
-        struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream);
-        return audio_get_dma_pos(&chip->s[substream->pstr->stream]);
-}
-
-/* }}} */
-
-static struct snd_pcm_hardware snd_sa11xx_uda1341_capture =
-{
-        .info                   = (SNDRV_PCM_INFO_INTERLEAVED |
-                                   SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                                   SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
-                                   SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME),
-        .formats                = SNDRV_PCM_FMTBIT_S16_LE,
-        .rates                  = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |\
-                                   SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000 |\
-                                   SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
-                                   SNDRV_PCM_RATE_KNOT),
-        .rate_min               = 8000,
-        .rate_max               = 48000,
-        .channels_min           = 2,
-        .channels_max           = 2,
-        .buffer_bytes_max       = 64*1024,
-        .period_bytes_min       = 64,
-        .period_bytes_max       = DMA_BUF_SIZE,
-        .periods_min            = 2,
-        .periods_max            = 255,
-        .fifo_size              = 0,
-};
-
-static struct snd_pcm_hardware snd_sa11xx_uda1341_playback =
-{
-        .info                   = (SNDRV_PCM_INFO_INTERLEAVED |
-                                   SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                                   SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
-                                   SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME),
-        .formats                = SNDRV_PCM_FMTBIT_S16_LE,
-        .rates                  = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |\
-                                   SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000 |\
-                                   SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
-                                   SNDRV_PCM_RATE_KNOT),
-        .rate_min               = 8000,
-        .rate_max               = 48000,
-        .channels_min           = 2,
-        .channels_max           = 2,
-        .buffer_bytes_max       = 64*1024,
-        .period_bytes_min       = 64,
-        .period_bytes_max       = DMA_BUF_SIZE,
-        .periods_min            = 2,
-        .periods_max            = 255,
-        .fifo_size              = 0,
-};
-
-static int snd_card_sa11xx_uda1341_open(struct snd_pcm_substream *substream)
-{
-        struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream);
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        int stream_id = substream->pstr->stream;
-        int err;
-
-        chip->s[stream_id].stream = substream;
-
-        if (stream_id == SNDRV_PCM_STREAM_PLAYBACK)
-                runtime->hw = snd_sa11xx_uda1341_playback;
-        else
-                runtime->hw = snd_sa11xx_uda1341_capture;
-        if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
-                return err;
-        if ((err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates)) < 0)
-                return err;
-        
-        return 0;
-}
-
-static int snd_card_sa11xx_uda1341_close(struct snd_pcm_substream *substream)
-{
-        struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream);
-
-        chip->s[substream->pstr->stream].stream = NULL;
-        return 0;
-}
-
-/* {{{ HW params & free */
-
-static int snd_sa11xx_uda1341_hw_params(struct snd_pcm_substream *substream,
-                                        struct snd_pcm_hw_params *hw_params)
-{
-        
-        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
-}
-
-static int snd_sa11xx_uda1341_hw_free(struct snd_pcm_substream *substream)
-{
-        return snd_pcm_lib_free_pages(substream);
-}
-
-/* }}} */
-
-static struct snd_pcm_ops snd_card_sa11xx_uda1341_playback_ops = {
-        .open                   = snd_card_sa11xx_uda1341_open,
-        .close                  = snd_card_sa11xx_uda1341_close,
-        .ioctl                  = snd_pcm_lib_ioctl,
-        .hw_params              = snd_sa11xx_uda1341_hw_params,
-        .hw_free                = snd_sa11xx_uda1341_hw_free,
-        .prepare                = snd_sa11xx_uda1341_prepare,
-        .trigger                = snd_sa11xx_uda1341_trigger,
-        .pointer                = snd_sa11xx_uda1341_pointer,
-};
-
-static struct snd_pcm_ops snd_card_sa11xx_uda1341_capture_ops = {
-        .open                   = snd_card_sa11xx_uda1341_open,
-        .close                  = snd_card_sa11xx_uda1341_close,
-        .ioctl                  = snd_pcm_lib_ioctl,
-        .hw_params              = snd_sa11xx_uda1341_hw_params,
-        .hw_free                = snd_sa11xx_uda1341_hw_free,
-        .prepare                = snd_sa11xx_uda1341_prepare,
-        .trigger                = snd_sa11xx_uda1341_trigger,
-        .pointer                = snd_sa11xx_uda1341_pointer,
-};
-
-static int __init snd_card_sa11xx_uda1341_pcm(struct sa11xx_uda1341 *sa11xx_uda1341, int device)
-{
-        struct snd_pcm *pcm;
-        int err;
-
-        if ((err = snd_pcm_new(sa11xx_uda1341->card, "UDA1341 PCM", device, 1, 1, &pcm)) < 0)
-                return err;
-
-        /*
-         * this sets up our initial buffers and sets the dma_type to isa.
-         * isa works but I'm not sure why (or if) it's the right choice
-         * this may be too large, trying it for now
-         */
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 
-                                              snd_dma_isa_data(),
-                                              64*1024, 64*1024);
-
-        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_sa11xx_uda1341_playback_ops);
-        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_sa11xx_uda1341_capture_ops);
-        pcm->private_data = sa11xx_uda1341;
-        pcm->info_flags = 0;
-        strcpy(pcm->name, "UDA1341 PCM");
-
-        sa11xx_uda1341_audio_init(sa11xx_uda1341);
-
-        /* setup DMA controller */
-        audio_dma_request(&sa11xx_uda1341->s[SNDRV_PCM_STREAM_PLAYBACK], audio_dma_callback);
-        audio_dma_request(&sa11xx_uda1341->s[SNDRV_PCM_STREAM_CAPTURE], audio_dma_callback);
-
-        sa11xx_uda1341->pcm = pcm;
-
-        return 0;
-}
-
-/* }}} */
-
-/* {{{ module init & exit */
-
-#ifdef CONFIG_PM
-
-static int snd_sa11xx_uda1341_suspend(struct platform_device *devptr,
-                                      pm_message_t state)
-{
-        struct snd_card *card = platform_get_drvdata(devptr);
-        struct sa11xx_uda1341 *chip = card->private_data;
-
-        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
-#ifdef HH_VERSION
-        sa1100_dma_sleep(chip->s[SNDRV_PCM_STREAM_PLAYBACK].dmach);
-        sa1100_dma_sleep(chip->s[SNDRV_PCM_STREAM_CAPTURE].dmach);
-#else
-        //FIXME
-#endif
-        l3_command(chip->uda1341, CMD_SUSPEND, NULL);
-        sa11xx_uda1341_audio_shutdown(chip);
-
-        return 0;
-}
-
-static int snd_sa11xx_uda1341_resume(struct platform_device *devptr)
-{
-        struct snd_card *card = platform_get_drvdata(devptr);
-        struct sa11xx_uda1341 *chip = card->private_data;
-
-        sa11xx_uda1341_audio_init(chip);
-        l3_command(chip->uda1341, CMD_RESUME, NULL);
-#ifdef HH_VERSION       
-        sa1100_dma_wakeup(chip->s[SNDRV_PCM_STREAM_PLAYBACK].dmach);
-        sa1100_dma_wakeup(chip->s[SNDRV_PCM_STREAM_CAPTURE].dmach);
-#else
-        //FIXME
-#endif
-        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
-        return 0;
-}
-#endif /* COMFIG_PM */
-
-void snd_sa11xx_uda1341_free(struct snd_card *card)
-{
-        struct sa11xx_uda1341 *chip = card->private_data;
-
-        audio_dma_free(&chip->s[SNDRV_PCM_STREAM_PLAYBACK]);
-        audio_dma_free(&chip->s[SNDRV_PCM_STREAM_CAPTURE]);
-}
-
-static int __devinit sa11xx_uda1341_probe(struct platform_device *devptr)
-{
-        int err;
-        struct snd_card *card;
-        struct sa11xx_uda1341 *chip;
-
-        /* register the soundcard */
-        err = snd_card_create(-1, id, THIS_MODULE,
-                              sizeof(struct sa11xx_uda1341), &card);
-        if (err < 0)
-                return err;
-
-        chip = card->private_data;
-        spin_lock_init(&chip->s[0].dma_lock);
-        spin_lock_init(&chip->s[1].dma_lock);
-
-        card->private_free = snd_sa11xx_uda1341_free;
-        chip->card = card;
-        chip->samplerate = AUDIO_RATE_DEFAULT;
-
-        // mixer
-        if ((err = snd_chip_uda1341_mixer_new(card, &chip->uda1341)))
-                goto nodev;
-
-        // PCM
-        if ((err = snd_card_sa11xx_uda1341_pcm(chip, 0)) < 0)
-                goto nodev;
-        
-        strcpy(card->driver, "UDA1341");
-        strcpy(card->shortname, "H3600 UDA1341TS");
-        sprintf(card->longname, "Compaq iPAQ H3600 with Philips UDA1341TS");
-        
-        snd_card_set_dev(card, &devptr->dev);
-
-        if ((err = snd_card_register(card)) == 0) {
-                printk( KERN_INFO "iPAQ audio support initialized\n" );
-                platform_set_drvdata(devptr, card);
-                return 0;
-        }
-        
- nodev:
-        snd_card_free(card);
-        return err;
-}
-
-static int __devexit sa11xx_uda1341_remove(struct platform_device *devptr)
-{
-        snd_card_free(platform_get_drvdata(devptr));
-        platform_set_drvdata(devptr, NULL);
-        return 0;
-}
-
-#define SA11XX_UDA1341_DRIVER   "sa11xx_uda1341"
-
-static struct platform_driver sa11xx_uda1341_driver = {
-        .probe          = sa11xx_uda1341_probe,
-        .remove         = __devexit_p(sa11xx_uda1341_remove),
-#ifdef CONFIG_PM
-        .suspend        = snd_sa11xx_uda1341_suspend,
-        .resume         = snd_sa11xx_uda1341_resume,
-#endif
-        .driver         = {
-                .name   = SA11XX_UDA1341_DRIVER,
-        },
-};
-
-static int __init sa11xx_uda1341_init(void)
-{
-        int err;
-
-        if (!machine_is_h3xxx())
-                return -ENODEV;
-        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)) {
-                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)
-{
-        platform_device_unregister(device);
-        platform_driver_unregister(&sa11xx_uda1341_driver);
-}
-
-module_init(sa11xx_uda1341_init);
-module_exit(sa11xx_uda1341_exit);
-
-/* }}} */
-
-/*
- * Local variables:
- * indent-tabs-mode: t
- * End:
- */
diff --git a/sound/atmel/Kconfig b/sound/atmel/Kconfig
new file mode 100644
index 000000000000..6c228a91940d
--- /dev/null
+++ b/sound/atmel/Kconfig
@@ -0,0 +1,19 @@
+menu "Atmel devices (AVR32 and AT91)"
+        depends on AVR32 || ARCH_AT91
+
+config SND_ATMEL_ABDAC
+        tristate "Atmel Audio Bitstream DAC (ABDAC) driver"
+        select SND_PCM
+        depends on DW_DMAC && AVR32
+        help
+          ALSA sound driver for the Atmel Audio Bitstream DAC (ABDAC).
+
+config SND_ATMEL_AC97C
+        tristate "Atmel AC97 Controller (AC97C) driver"
+        select SND_PCM
+        select SND_AC97_CODEC
+        depends on DW_DMAC && AVR32
+        help
+          ALSA sound driver for the Atmel AC97 controller.
+
+endmenu
diff --git a/sound/atmel/Makefile b/sound/atmel/Makefile
new file mode 100644
index 000000000000..219dcfac6086
--- /dev/null
+++ b/sound/atmel/Makefile
@@ -0,0 +1,5 @@
+snd-atmel-abdac-objs            := abdac.o
+snd-atmel-ac97c-objs            := ac97c.o
+
+obj-$(CONFIG_SND_ATMEL_ABDAC)   += snd-atmel-abdac.o
+obj-$(CONFIG_SND_ATMEL_AC97C)   += snd-atmel-ac97c.o
diff --git a/sound/atmel/abdac.c b/sound/atmel/abdac.c
new file mode 100644
index 000000000000..f2f41c854221
--- /dev/null
+++ b/sound/atmel/abdac.c
@@ -0,0 +1,602 @@
+/*
+ * Driver for the Atmel on-chip Audio Bitstream DAC (ABDAC)
+ *
+ * Copyright (C) 2006-2009 Atmel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+#include <linux/clk.h>
+#include <linux/bitmap.h>
+#include <linux/dw_dmac.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/atmel-abdac.h>
+
+/* DAC register offsets */
+#define DAC_DATA                                0x0000
+#define DAC_CTRL                                0x0008
+#define DAC_INT_MASK                            0x000c
+#define DAC_INT_EN                              0x0010
+#define DAC_INT_DIS                             0x0014
+#define DAC_INT_CLR                             0x0018
+#define DAC_INT_STATUS                          0x001c
+
+/* Bitfields in CTRL */
+#define DAC_SWAP_OFFSET                         30
+#define DAC_SWAP_SIZE                           1
+#define DAC_EN_OFFSET                           31
+#define DAC_EN_SIZE                             1
+
+/* Bitfields in INT_MASK/INT_EN/INT_DIS/INT_STATUS/INT_CLR */
+#define DAC_UNDERRUN_OFFSET                     28
+#define DAC_UNDERRUN_SIZE                       1
+#define DAC_TX_READY_OFFSET                     29
+#define DAC_TX_READY_SIZE                       1
+
+/* Bit manipulation macros */
+#define DAC_BIT(name)                                   \
+        (1 << DAC_##name##_OFFSET)
+#define DAC_BF(name, value)                             \
+        (((value) & ((1 << DAC_##name##_SIZE) - 1))     \
+         << DAC_##name##_OFFSET)
+#define DAC_BFEXT(name, value)                          \
+        (((value) >> DAC_##name##_OFFSET)               \
+         & ((1 << DAC_##name##_SIZE) - 1))
+#define DAC_BFINS(name, value, old)                     \
+        (((old) & ~(((1 << DAC_##name##_SIZE) - 1)      \
+                    << DAC_##name##_OFFSET))            \
+         | DAC_BF(name, value))
+
+/* Register access macros */
+#define dac_readl(port, reg)                            \
+        __raw_readl((port)->regs + DAC_##reg)
+#define dac_writel(port, reg, value)                    \
+        __raw_writel((value), (port)->regs + DAC_##reg)
+
+/*
+ * ABDAC supports a maximum of 6 different rates from a generic clock. The
+ * generic clock has a power of two divider, which gives 6 steps from 192 kHz
+ * to 5112 Hz.
+ */
+#define MAX_NUM_RATES   6
+/* ALSA seems to use rates between 192000 Hz and 5112 Hz. */
+#define RATE_MAX        192000
+#define RATE_MIN        5112
+
+enum {
+        DMA_READY = 0,
+};
+
+struct atmel_abdac_dma {
+        struct dma_chan         *chan;
+        struct dw_cyclic_desc   *cdesc;
+};
+
+struct atmel_abdac {
+        struct clk                              *pclk;
+        struct clk                              *sample_clk;
+        struct platform_device                  *pdev;
+        struct atmel_abdac_dma                  dma;
+
+        struct snd_pcm_hw_constraint_list       constraints_rates;
+        struct snd_pcm_substream                *substream;
+        struct snd_card                         *card;
+        struct snd_pcm                          *pcm;
+
+        void __iomem                            *regs;
+        unsigned long                           flags;
+        unsigned int                            rates[MAX_NUM_RATES];
+        unsigned int                            rates_num;
+        int                                     irq;
+};
+
+#define get_dac(card) ((struct atmel_abdac *)(card)->private_data)
+
+/* This function is called by the DMA driver. */
+static void atmel_abdac_dma_period_done(void *arg)
+{
+        struct atmel_abdac *dac = arg;
+        snd_pcm_period_elapsed(dac->substream);
+}
+
+static int atmel_abdac_prepare_dma(struct atmel_abdac *dac,
+                struct snd_pcm_substream *substream,
+                enum dma_data_direction direction)
+{
+        struct dma_chan                 *chan = dac->dma.chan;
+        struct dw_cyclic_desc           *cdesc;
+        struct snd_pcm_runtime          *runtime = substream->runtime;
+        unsigned long                   buffer_len, period_len;
+
+        /*
+         * We don't do DMA on "complex" transfers, i.e. with
+         * non-halfword-aligned buffers or lengths.
+         */
+        if (runtime->dma_addr & 1 || runtime->buffer_size & 1) {
+                dev_dbg(&dac->pdev->dev, "too complex transfer\n");
+                return -EINVAL;
+        }
+
+        buffer_len = frames_to_bytes(runtime, runtime->buffer_size);
+        period_len = frames_to_bytes(runtime, runtime->period_size);
+
+        cdesc = dw_dma_cyclic_prep(chan, runtime->dma_addr, buffer_len,
+                        period_len, DMA_TO_DEVICE);
+        if (IS_ERR(cdesc)) {
+                dev_dbg(&dac->pdev->dev, "could not prepare cyclic DMA\n");
+                return PTR_ERR(cdesc);
+        }
+
+        cdesc->period_callback = atmel_abdac_dma_period_done;
+        cdesc->period_callback_param = dac;
+
+        dac->dma.cdesc = cdesc;
+
+        set_bit(DMA_READY, &dac->flags);
+
+        return 0;
+}
+
+static struct snd_pcm_hardware atmel_abdac_hw = {
+        .info                   = (SNDRV_PCM_INFO_MMAP
+                                  | SNDRV_PCM_INFO_MMAP_VALID
+                                  | SNDRV_PCM_INFO_INTERLEAVED
+                                  | SNDRV_PCM_INFO_BLOCK_TRANSFER
+                                  | SNDRV_PCM_INFO_RESUME
+                                  | SNDRV_PCM_INFO_PAUSE),
+        .formats                = (SNDRV_PCM_FMTBIT_S16_BE),
+        .rates                  = (SNDRV_PCM_RATE_KNOT),
+        .rate_min               = RATE_MIN,
+        .rate_max               = RATE_MAX,
+        .channels_min           = 2,
+        .channels_max           = 2,
+        .buffer_bytes_max       = 64 * 4096,
+        .period_bytes_min       = 4096,
+        .period_bytes_max       = 4096,
+        .periods_min            = 6,
+        .periods_max            = 64,
+};
+
+static int atmel_abdac_open(struct snd_pcm_substream *substream)
+{
+        struct atmel_abdac *dac = snd_pcm_substream_chip(substream);
+
+        dac->substream = substream;
+        atmel_abdac_hw.rate_max = dac->rates[dac->rates_num - 1];
+        atmel_abdac_hw.rate_min = dac->rates[0];
+        substream->runtime->hw = atmel_abdac_hw;
+
+        return snd_pcm_hw_constraint_list(substream->runtime, 0,
+                        SNDRV_PCM_HW_PARAM_RATE, &dac->constraints_rates);
+}
+
+static int atmel_abdac_close(struct snd_pcm_substream *substream)
+{
+        struct atmel_abdac *dac = snd_pcm_substream_chip(substream);
+        dac->substream = NULL;
+        return 0;
+}
+
+static int atmel_abdac_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *hw_params)
+{
+        struct atmel_abdac *dac = snd_pcm_substream_chip(substream);
+        int retval;
+
+        retval = snd_pcm_lib_malloc_pages(substream,
+                        params_buffer_bytes(hw_params));
+        if (retval < 0)
+                return retval;
+        /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */
+        if (retval == 1)
+                if (test_and_clear_bit(DMA_READY, &dac->flags))
+                        dw_dma_cyclic_free(dac->dma.chan);
+
+        return retval;
+}
+
+static int atmel_abdac_hw_free(struct snd_pcm_substream *substream)
+{
+        struct atmel_abdac *dac = snd_pcm_substream_chip(substream);
+        if (test_and_clear_bit(DMA_READY, &dac->flags))
+                dw_dma_cyclic_free(dac->dma.chan);
+        return snd_pcm_lib_free_pages(substream);
+}
+
+static int atmel_abdac_prepare(struct snd_pcm_substream *substream)
+{
+        struct atmel_abdac *dac = snd_pcm_substream_chip(substream);
+        int retval;
+
+        retval = clk_set_rate(dac->sample_clk, 256 * substream->runtime->rate);
+        if (retval)
+                return retval;
+
+        if (!test_bit(DMA_READY, &dac->flags))
+                retval = atmel_abdac_prepare_dma(dac, substream, DMA_TO_DEVICE);
+
+        return retval;
+}
+
+static int atmel_abdac_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct atmel_abdac *dac = snd_pcm_substream_chip(substream);
+        int retval = 0;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
+        case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
+        case SNDRV_PCM_TRIGGER_START:
+                clk_enable(dac->sample_clk);
+                retval = dw_dma_cyclic_start(dac->dma.chan);
+                if (retval)
+                        goto out;
+                dac_writel(dac, CTRL, DAC_BIT(EN));
+                break;
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
+        case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
+        case SNDRV_PCM_TRIGGER_STOP:
+                dw_dma_cyclic_stop(dac->dma.chan);
+                dac_writel(dac, DATA, 0);
+                dac_writel(dac, CTRL, 0);
+                clk_disable(dac->sample_clk);
+                break;
+        default:
+                retval = -EINVAL;
+                break;
+        }
+out:
+        return retval;
+}
+
+static snd_pcm_uframes_t
+atmel_abdac_pointer(struct snd_pcm_substream *substream)
+{
+        struct atmel_abdac      *dac = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime  *runtime = substream->runtime;
+        snd_pcm_uframes_t       frames;
+        unsigned long           bytes;
+
+        bytes = dw_dma_get_src_addr(dac->dma.chan);
+        bytes -= runtime->dma_addr;
+
+        frames = bytes_to_frames(runtime, bytes);
+        if (frames >= runtime->buffer_size)
+                frames -= runtime->buffer_size;
+
+        return frames;
+}
+
+static irqreturn_t abdac_interrupt(int irq, void *dev_id)
+{
+        struct atmel_abdac *dac = dev_id;
+        u32 status;
+
+        status = dac_readl(dac, INT_STATUS);
+        if (status & DAC_BIT(UNDERRUN)) {
+                dev_err(&dac->pdev->dev, "underrun detected\n");
+                dac_writel(dac, INT_CLR, DAC_BIT(UNDERRUN));
+        } else {
+                dev_err(&dac->pdev->dev, "spurious interrupt (status=0x%x)\n",
+                        status);
+                dac_writel(dac, INT_CLR, status);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static struct snd_pcm_ops atmel_abdac_ops = {
+        .open           = atmel_abdac_open,
+        .close          = atmel_abdac_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = atmel_abdac_hw_params,
+        .hw_free        = atmel_abdac_hw_free,
+        .prepare        = atmel_abdac_prepare,
+        .trigger        = atmel_abdac_trigger,
+        .pointer        = atmel_abdac_pointer,
+};
+
+static int __devinit atmel_abdac_pcm_new(struct atmel_abdac *dac)
+{
+        struct snd_pcm_hardware hw = atmel_abdac_hw;
+        struct snd_pcm *pcm;
+        int retval;
+
+        retval = snd_pcm_new(dac->card, dac->card->shortname,
+                        dac->pdev->id, 1, 0, &pcm);
+        if (retval)
+                return retval;
+
+        strcpy(pcm->name, dac->card->shortname);
+        pcm->private_data = dac;
+        pcm->info_flags = 0;
+        dac->pcm = pcm;
+
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &atmel_abdac_ops);
+
+        retval = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                        &dac->pdev->dev, hw.periods_min * hw.period_bytes_min,
+                        hw.buffer_bytes_max);
+
+        return retval;
+}
+
+static bool filter(struct dma_chan *chan, void *slave)
+{
+        struct dw_dma_slave *dws = slave;
+
+        if (dws->dma_dev == chan->device->dev) {
+                chan->private = dws;
+                return true;
+        } else
+                return false;
+}
+
+static int set_sample_rates(struct atmel_abdac *dac)
+{
+        long new_rate = RATE_MAX;
+        int retval = -EINVAL;
+        int index = 0;
+
+        /* we start at 192 kHz and work our way down to 5112 Hz */
+        while (new_rate >= RATE_MIN && index < (MAX_NUM_RATES + 1)) {
+                new_rate = clk_round_rate(dac->sample_clk, 256 * new_rate);
+                if (new_rate < 0)
+                        break;
+                /* make sure we are below the ABDAC clock */
+                if (new_rate <= clk_get_rate(dac->pclk)) {
+                        dac->rates[index] = new_rate / 256;
+                        index++;
+                }
+                /* divide by 256 and then by two to get next rate */
+                new_rate /= 256 * 2;
+        }
+
+        if (index) {
+                int i;
+
+                /* reverse array, smallest go first */
+                for (i = 0; i < (index / 2); i++) {
+                        unsigned int tmp = dac->rates[index - 1 - i];
+                        dac->rates[index - 1 - i] = dac->rates[i];
+                        dac->rates[i] = tmp;
+                }
+
+                dac->constraints_rates.count = index;
+                dac->constraints_rates.list = dac->rates;
+                dac->constraints_rates.mask = 0;
+                dac->rates_num = index;
+
+                retval = 0;
+        }
+
+        return retval;
+}
+
+static int __devinit atmel_abdac_probe(struct platform_device *pdev)
+{
+        struct snd_card         *card;
+        struct atmel_abdac      *dac;
+        struct resource         *regs;
+        struct atmel_abdac_pdata        *pdata;
+        struct clk              *pclk;
+        struct clk              *sample_clk;
+        int                     retval;
+        int                     irq;
+
+        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!regs) {
+                dev_dbg(&pdev->dev, "no memory resource\n");
+                return -ENXIO;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_dbg(&pdev->dev, "could not get IRQ number\n");
+                return irq;
+        }
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_dbg(&pdev->dev, "no platform data\n");
+                return -ENXIO;
+        }
+
+        pclk = clk_get(&pdev->dev, "pclk");
+        if (IS_ERR(pclk)) {
+                dev_dbg(&pdev->dev, "no peripheral clock\n");
+                return PTR_ERR(pclk);
+        }
+        sample_clk = clk_get(&pdev->dev, "sample_clk");
+        if (IS_ERR(pclk)) {
+                dev_dbg(&pdev->dev, "no sample clock\n");
+                retval = PTR_ERR(pclk);
+                goto out_put_pclk;
+        }
+        clk_enable(pclk);
+
+        retval = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
+                        THIS_MODULE, sizeof(struct atmel_abdac), &card);
+        if (retval) {
+                dev_dbg(&pdev->dev, "could not create sound card device\n");
+                goto out_put_sample_clk;
+        }
+
+        dac = get_dac(card);
+
+        dac->irq = irq;
+        dac->card = card;
+        dac->pclk = pclk;
+        dac->sample_clk = sample_clk;
+        dac->pdev = pdev;
+
+        retval = set_sample_rates(dac);
+        if (retval < 0) {
+                dev_dbg(&pdev->dev, "could not set supported rates\n");
+                goto out_free_card;
+        }
+
+        dac->regs = ioremap(regs->start, regs->end - regs->start + 1);
+        if (!dac->regs) {
+                dev_dbg(&pdev->dev, "could not remap register memory\n");
+                goto out_free_card;
+        }
+
+        /* make sure the DAC is silent and disabled */
+        dac_writel(dac, DATA, 0);
+        dac_writel(dac, CTRL, 0);
+
+        retval = request_irq(irq, abdac_interrupt, 0, "abdac", dac);
+        if (retval) {
+                dev_dbg(&pdev->dev, "could not request irq\n");
+                goto out_unmap_regs;
+        }
+
+        snd_card_set_dev(card, &pdev->dev);
+
+        if (pdata->dws.dma_dev) {
+                struct dw_dma_slave *dws = &pdata->dws;
+                dma_cap_mask_t mask;
+
+                dws->tx_reg = regs->start + DAC_DATA;
+
+                dma_cap_zero(mask);
+                dma_cap_set(DMA_SLAVE, mask);
+
+                dac->dma.chan = dma_request_channel(mask, filter, dws);
+        }
+        if (!pdata->dws.dma_dev || !dac->dma.chan) {
+                dev_dbg(&pdev->dev, "DMA not available\n");
+                retval = -ENODEV;
+                goto out_unset_card_dev;
+        }
+
+        strcpy(card->driver, "Atmel ABDAC");
+        strcpy(card->shortname, "Atmel ABDAC");
+        sprintf(card->longname, "Atmel Audio Bitstream DAC");
+
+        retval = atmel_abdac_pcm_new(dac);
+        if (retval) {
+                dev_dbg(&pdev->dev, "could not register ABDAC pcm device\n");
+                goto out_release_dma;
+        }
+
+        retval = snd_card_register(card);
+        if (retval) {
+                dev_dbg(&pdev->dev, "could not register sound card\n");
+                goto out_release_dma;
+        }
+
+        platform_set_drvdata(pdev, card);
+
+        dev_info(&pdev->dev, "Atmel ABDAC at 0x%p using %s\n",
+                        dac->regs, dev_name(&dac->dma.chan->dev->device));
+
+        return retval;
+
+out_release_dma:
+        dma_release_channel(dac->dma.chan);
+        dac->dma.chan = NULL;
+out_unset_card_dev:
+        snd_card_set_dev(card, NULL);
+        free_irq(irq, dac);
+out_unmap_regs:
+        iounmap(dac->regs);
+out_free_card:
+        snd_card_free(card);
+out_put_sample_clk:
+        clk_put(sample_clk);
+        clk_disable(pclk);
+out_put_pclk:
+        clk_put(pclk);
+        return retval;
+}
+
+#ifdef CONFIG_PM
+static int atmel_abdac_suspend(struct platform_device *pdev, pm_message_t msg)
+{
+        struct snd_card *card = platform_get_drvdata(pdev);
+        struct atmel_abdac *dac = card->private_data;
+
+        dw_dma_cyclic_stop(dac->dma.chan);
+        clk_disable(dac->sample_clk);
+        clk_disable(dac->pclk);
+
+        return 0;
+}
+
+static int atmel_abdac_resume(struct platform_device *pdev)
+{
+        struct snd_card *card = platform_get_drvdata(pdev);
+        struct atmel_abdac *dac = card->private_data;
+
+        clk_enable(dac->pclk);
+        clk_enable(dac->sample_clk);
+        if (test_bit(DMA_READY, &dac->flags))
+                dw_dma_cyclic_start(dac->dma.chan);
+
+        return 0;
+}
+#else
+#define atmel_abdac_suspend NULL
+#define atmel_abdac_resume NULL
+#endif
+
+static int __devexit atmel_abdac_remove(struct platform_device *pdev)
+{
+        struct snd_card *card = platform_get_drvdata(pdev);
+        struct atmel_abdac *dac = get_dac(card);
+
+        clk_put(dac->sample_clk);
+        clk_disable(dac->pclk);
+        clk_put(dac->pclk);
+
+        dma_release_channel(dac->dma.chan);
+        dac->dma.chan = NULL;
+        snd_card_set_dev(card, NULL);
+        iounmap(dac->regs);
+        free_irq(dac->irq, dac);
+        snd_card_free(card);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver atmel_abdac_driver = {
+        .remove         = __devexit_p(atmel_abdac_remove),
+        .driver         = {
+                .name   = "atmel_abdac",
+        },
+        .suspend        = atmel_abdac_suspend,
+        .resume         = atmel_abdac_resume,
+};
+
+static int __init atmel_abdac_init(void)
+{
+        return platform_driver_probe(&atmel_abdac_driver,
+                        atmel_abdac_probe);
+}
+module_init(atmel_abdac_init);
+
+static void __exit atmel_abdac_exit(void)
+{
+        platform_driver_unregister(&atmel_abdac_driver);
+}
+module_exit(atmel_abdac_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Driver for Atmel Audio Bitstream DAC (ABDAC)");
+MODULE_AUTHOR("Hans-Christian Egtvedt <hans-christian.egtvedt@atmel.com>");
diff --git a/sound/atmel/ac97c.c b/sound/atmel/ac97c.c
new file mode 100644
index 000000000000..0c0f8771656a
--- /dev/null
+++ b/sound/atmel/ac97c.c
@@ -0,0 +1,1022 @@
+/*
+ * Driver for Atmel AC97C
+ *
+ * Copyright (C) 2005-2009 Atmel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/bitmap.h>
+#include <linux/device.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/gpio.h>
+#include <linux/io.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/ac97_codec.h>
+#include <sound/atmel-ac97c.h>
+#include <sound/memalloc.h>
+
+#include <linux/dw_dmac.h>
+
+#include "ac97c.h"
+
+enum {
+        DMA_TX_READY = 0,
+        DMA_RX_READY,
+        DMA_TX_CHAN_PRESENT,
+        DMA_RX_CHAN_PRESENT,
+};
+
+/* Serialize access to opened variable */
+static DEFINE_MUTEX(opened_mutex);
+
+struct atmel_ac97c_dma {
+        struct dma_chan                 *rx_chan;
+        struct dma_chan                 *tx_chan;
+};
+
+struct atmel_ac97c {
+        struct clk                      *pclk;
+        struct platform_device          *pdev;
+        struct atmel_ac97c_dma          dma;
+
+        struct snd_pcm_substream        *playback_substream;
+        struct snd_pcm_substream        *capture_substream;
+        struct snd_card                 *card;
+        struct snd_pcm                  *pcm;
+        struct snd_ac97                 *ac97;
+        struct snd_ac97_bus             *ac97_bus;
+
+        u64                             cur_format;
+        unsigned int                    cur_rate;
+        unsigned long                   flags;
+        /* Serialize access to opened variable */
+        spinlock_t                      lock;
+        void __iomem                    *regs;
+        int                             irq;
+        int                             opened;
+        int                             reset_pin;
+};
+
+#define get_chip(card) ((struct atmel_ac97c *)(card)->private_data)
+
+#define ac97c_writel(chip, reg, val)                    \
+        __raw_writel((val), (chip)->regs + AC97C_##reg)
+#define ac97c_readl(chip, reg)                          \
+        __raw_readl((chip)->regs + AC97C_##reg)
+
+/* This function is called by the DMA driver. */
+static void atmel_ac97c_dma_playback_period_done(void *arg)
+{
+        struct atmel_ac97c *chip = arg;
+        snd_pcm_period_elapsed(chip->playback_substream);
+}
+
+static void atmel_ac97c_dma_capture_period_done(void *arg)
+{
+        struct atmel_ac97c *chip = arg;
+        snd_pcm_period_elapsed(chip->capture_substream);
+}
+
+static int atmel_ac97c_prepare_dma(struct atmel_ac97c *chip,
+                struct snd_pcm_substream *substream,
+                enum dma_data_direction direction)
+{
+        struct dma_chan                 *chan;
+        struct dw_cyclic_desc           *cdesc;
+        struct snd_pcm_runtime          *runtime = substream->runtime;
+        unsigned long                   buffer_len, period_len;
+
+        /*
+         * We don't do DMA on "complex" transfers, i.e. with
+         * non-halfword-aligned buffers or lengths.
+         */
+        if (runtime->dma_addr & 1 || runtime->buffer_size & 1) {
+                dev_dbg(&chip->pdev->dev, "too complex transfer\n");
+                return -EINVAL;
+        }
+
+        if (direction == DMA_TO_DEVICE)
+                chan = chip->dma.tx_chan;
+        else
+                chan = chip->dma.rx_chan;
+
+        buffer_len = frames_to_bytes(runtime, runtime->buffer_size);
+        period_len = frames_to_bytes(runtime, runtime->period_size);
+
+        cdesc = dw_dma_cyclic_prep(chan, runtime->dma_addr, buffer_len,
+                        period_len, direction);
+        if (IS_ERR(cdesc)) {
+                dev_dbg(&chip->pdev->dev, "could not prepare cyclic DMA\n");
+                return PTR_ERR(cdesc);
+        }
+
+        if (direction == DMA_TO_DEVICE) {
+                cdesc->period_callback = atmel_ac97c_dma_playback_period_done;
+                set_bit(DMA_TX_READY, &chip->flags);
+        } else {
+                cdesc->period_callback = atmel_ac97c_dma_capture_period_done;
+                set_bit(DMA_RX_READY, &chip->flags);
+        }
+
+        cdesc->period_callback_param = chip;
+
+        return 0;
+}
+
+static struct snd_pcm_hardware atmel_ac97c_hw = {
+        .info                   = (SNDRV_PCM_INFO_MMAP
+                                  | SNDRV_PCM_INFO_MMAP_VALID
+                                  | SNDRV_PCM_INFO_INTERLEAVED
+                                  | SNDRV_PCM_INFO_BLOCK_TRANSFER
+                                  | SNDRV_PCM_INFO_JOINT_DUPLEX
+                                  | SNDRV_PCM_INFO_RESUME
+                                  | SNDRV_PCM_INFO_PAUSE),
+        .formats                = (SNDRV_PCM_FMTBIT_S16_BE
+                                  | SNDRV_PCM_FMTBIT_S16_LE),
+        .rates                  = (SNDRV_PCM_RATE_CONTINUOUS),
+        .rate_min               = 4000,
+        .rate_max               = 48000,
+        .channels_min           = 1,
+        .channels_max           = 2,
+        .buffer_bytes_max       = 2 * 2 * 64 * 2048,
+        .period_bytes_min       = 4096,
+        .period_bytes_max       = 4096,
+        .periods_min            = 6,
+        .periods_max            = 64,
+};
+
+static int atmel_ac97c_playback_open(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+
+        mutex_lock(&opened_mutex);
+        chip->opened++;
+        runtime->hw = atmel_ac97c_hw;
+        if (chip->cur_rate) {
+                runtime->hw.rate_min = chip->cur_rate;
+                runtime->hw.rate_max = chip->cur_rate;
+        }
+        if (chip->cur_format)
+                runtime->hw.formats = (1ULL << chip->cur_format);
+        mutex_unlock(&opened_mutex);
+        chip->playback_substream = substream;
+        return 0;
+}
+
+static int atmel_ac97c_capture_open(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+
+        mutex_lock(&opened_mutex);
+        chip->opened++;
+        runtime->hw = atmel_ac97c_hw;
+        if (chip->cur_rate) {
+                runtime->hw.rate_min = chip->cur_rate;
+                runtime->hw.rate_max = chip->cur_rate;
+        }
+        if (chip->cur_format)
+                runtime->hw.formats = (1ULL << chip->cur_format);
+        mutex_unlock(&opened_mutex);
+        chip->capture_substream = substream;
+        return 0;
+}
+
+static int atmel_ac97c_playback_close(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+
+        mutex_lock(&opened_mutex);
+        chip->opened--;
+        if (!chip->opened) {
+                chip->cur_rate = 0;
+                chip->cur_format = 0;
+        }
+        mutex_unlock(&opened_mutex);
+
+        chip->playback_substream = NULL;
+
+        return 0;
+}
+
+static int atmel_ac97c_capture_close(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+
+        mutex_lock(&opened_mutex);
+        chip->opened--;
+        if (!chip->opened) {
+                chip->cur_rate = 0;
+                chip->cur_format = 0;
+        }
+        mutex_unlock(&opened_mutex);
+
+        chip->capture_substream = NULL;
+
+        return 0;
+}
+
+static int atmel_ac97c_playback_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *hw_params)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        int retval;
+
+        retval = snd_pcm_lib_malloc_pages(substream,
+                                        params_buffer_bytes(hw_params));
+        if (retval < 0)
+                return retval;
+        /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */
+        if (retval == 1)
+                if (test_and_clear_bit(DMA_TX_READY, &chip->flags))
+                        dw_dma_cyclic_free(chip->dma.tx_chan);
+
+        /* Set restrictions to params. */
+        mutex_lock(&opened_mutex);
+        chip->cur_rate = params_rate(hw_params);
+        chip->cur_format = params_format(hw_params);
+        mutex_unlock(&opened_mutex);
+
+        return retval;
+}
+
+static int atmel_ac97c_capture_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *hw_params)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        int retval;
+
+        retval = snd_pcm_lib_malloc_pages(substream,
+                                        params_buffer_bytes(hw_params));
+        if (retval < 0)
+                return retval;
+        /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */
+        if (retval == 1)
+                if (test_and_clear_bit(DMA_RX_READY, &chip->flags))
+                        dw_dma_cyclic_free(chip->dma.rx_chan);
+
+        /* Set restrictions to params. */
+        mutex_lock(&opened_mutex);
+        chip->cur_rate = params_rate(hw_params);
+        chip->cur_format = params_format(hw_params);
+        mutex_unlock(&opened_mutex);
+
+        return retval;
+}
+
+static int atmel_ac97c_playback_hw_free(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        if (test_and_clear_bit(DMA_TX_READY, &chip->flags))
+                dw_dma_cyclic_free(chip->dma.tx_chan);
+        return snd_pcm_lib_free_pages(substream);
+}
+
+static int atmel_ac97c_capture_hw_free(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        if (test_and_clear_bit(DMA_RX_READY, &chip->flags))
+                dw_dma_cyclic_free(chip->dma.rx_chan);
+        return snd_pcm_lib_free_pages(substream);
+}
+
+static int atmel_ac97c_playback_prepare(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        unsigned long word = ac97c_readl(chip, OCA);
+        int retval;
+
+        word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
+
+        /* assign channels to AC97C channel A */
+        switch (runtime->channels) {
+        case 1:
+                word |= AC97C_CH_ASSIGN(PCM_LEFT, A);
+                break;
+        case 2:
+                word |= AC97C_CH_ASSIGN(PCM_LEFT, A)
+                        | AC97C_CH_ASSIGN(PCM_RIGHT, A);
+                break;
+        default:
+                /* TODO: support more than two channels */
+                return -EINVAL;
+        }
+        ac97c_writel(chip, OCA, word);
+
+        /* configure sample format and size */
+        word = AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
+
+        switch (runtime->format) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                word |= AC97C_CMR_CEM_LITTLE;
+                break;
+        case SNDRV_PCM_FORMAT_S16_BE: /* fall through */
+                word &= ~(AC97C_CMR_CEM_LITTLE);
+                break;
+        default:
+                word = ac97c_readl(chip, OCA);
+                word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
+                ac97c_writel(chip, OCA, word);
+                return -EINVAL;
+        }
+
+        /* Enable underrun interrupt on channel A */
+        word |= AC97C_CSR_UNRUN;
+
+        ac97c_writel(chip, CAMR, word);
+
+        /* Enable channel A event interrupt */
+        word = ac97c_readl(chip, IMR);
+        word |= AC97C_SR_CAEVT;
+        ac97c_writel(chip, IER, word);
+
+        /* set variable rate if needed */
+        if (runtime->rate != 48000) {
+                word = ac97c_readl(chip, MR);
+                word |= AC97C_MR_VRA;
+                ac97c_writel(chip, MR, word);
+        } else {
+                word = ac97c_readl(chip, MR);
+                word &= ~(AC97C_MR_VRA);
+                ac97c_writel(chip, MR, word);
+        }
+
+        retval = snd_ac97_set_rate(chip->ac97, AC97_PCM_FRONT_DAC_RATE,
+                        runtime->rate);
+        if (retval)
+                dev_dbg(&chip->pdev->dev, "could not set rate %d Hz\n",
+                                runtime->rate);
+
+        if (!test_bit(DMA_TX_READY, &chip->flags))
+                retval = atmel_ac97c_prepare_dma(chip, substream,
+                                DMA_TO_DEVICE);
+
+        return retval;
+}
+
+static int atmel_ac97c_capture_prepare(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        unsigned long word = ac97c_readl(chip, ICA);
+        int retval;
+
+        word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
+
+        /* assign channels to AC97C channel A */
+        switch (runtime->channels) {
+        case 1:
+                word |= AC97C_CH_ASSIGN(PCM_LEFT, A);
+                break;
+        case 2:
+                word |= AC97C_CH_ASSIGN(PCM_LEFT, A)
+                        | AC97C_CH_ASSIGN(PCM_RIGHT, A);
+                break;
+        default:
+                /* TODO: support more than two channels */
+                return -EINVAL;
+        }
+        ac97c_writel(chip, ICA, word);
+
+        /* configure sample format and size */
+        word = AC97C_CMR_DMAEN | AC97C_CMR_SIZE_16;
+
+        switch (runtime->format) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                word |= AC97C_CMR_CEM_LITTLE;
+                break;
+        case SNDRV_PCM_FORMAT_S16_BE: /* fall through */
+                word &= ~(AC97C_CMR_CEM_LITTLE);
+                break;
+        default:
+                word = ac97c_readl(chip, ICA);
+                word &= ~(AC97C_CH_MASK(PCM_LEFT) | AC97C_CH_MASK(PCM_RIGHT));
+                ac97c_writel(chip, ICA, word);
+                return -EINVAL;
+        }
+
+        /* Enable overrun interrupt on channel A */
+        word |= AC97C_CSR_OVRUN;
+
+        ac97c_writel(chip, CAMR, word);
+
+        /* Enable channel A event interrupt */
+        word = ac97c_readl(chip, IMR);
+        word |= AC97C_SR_CAEVT;
+        ac97c_writel(chip, IER, word);
+
+        /* set variable rate if needed */
+        if (runtime->rate != 48000) {
+                word = ac97c_readl(chip, MR);
+                word |= AC97C_MR_VRA;
+                ac97c_writel(chip, MR, word);
+        } else {
+                word = ac97c_readl(chip, MR);
+                word &= ~(AC97C_MR_VRA);
+                ac97c_writel(chip, MR, word);
+        }
+
+        retval = snd_ac97_set_rate(chip->ac97, AC97_PCM_LR_ADC_RATE,
+                        runtime->rate);
+        if (retval)
+                dev_dbg(&chip->pdev->dev, "could not set rate %d Hz\n",
+                                runtime->rate);
+
+        if (!test_bit(DMA_RX_READY, &chip->flags))
+                retval = atmel_ac97c_prepare_dma(chip, substream,
+                                DMA_FROM_DEVICE);
+
+        return retval;
+}
+
+static int
+atmel_ac97c_playback_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        unsigned long camr;
+        int retval = 0;
+
+        camr = ac97c_readl(chip, CAMR);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
+        case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
+        case SNDRV_PCM_TRIGGER_START:
+                retval = dw_dma_cyclic_start(chip->dma.tx_chan);
+                if (retval)
+                        goto out;
+                camr |= AC97C_CMR_CENA;
+                break;
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
+        case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
+        case SNDRV_PCM_TRIGGER_STOP:
+                dw_dma_cyclic_stop(chip->dma.tx_chan);
+                if (chip->opened <= 1)
+                        camr &= ~AC97C_CMR_CENA;
+                break;
+        default:
+                retval = -EINVAL;
+                goto out;
+        }
+
+        ac97c_writel(chip, CAMR, camr);
+out:
+        return retval;
+}
+
+static int
+atmel_ac97c_capture_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct atmel_ac97c *chip = snd_pcm_substream_chip(substream);
+        unsigned long camr;
+        int retval = 0;
+
+        camr = ac97c_readl(chip, CAMR);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
+        case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
+        case SNDRV_PCM_TRIGGER_START:
+                retval = dw_dma_cyclic_start(chip->dma.rx_chan);
+                if (retval)
+                        goto out;
+                camr |= AC97C_CMR_CENA;
+                break;
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
+        case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
+        case SNDRV_PCM_TRIGGER_STOP:
+                dw_dma_cyclic_stop(chip->dma.rx_chan);
+                if (chip->opened <= 1)
+                        camr &= ~AC97C_CMR_CENA;
+                break;
+        default:
+                retval = -EINVAL;
+                break;
+        }
+
+        ac97c_writel(chip, CAMR, camr);
+out:
+        return retval;
+}
+
+static snd_pcm_uframes_t
+atmel_ac97c_playback_pointer(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c      *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime  *runtime = substream->runtime;
+        snd_pcm_uframes_t       frames;
+        unsigned long           bytes;
+
+        bytes = dw_dma_get_src_addr(chip->dma.tx_chan);
+        bytes -= runtime->dma_addr;
+
+        frames = bytes_to_frames(runtime, bytes);
+        if (frames >= runtime->buffer_size)
+                frames -= runtime->buffer_size;
+        return frames;
+}
+
+static snd_pcm_uframes_t
+atmel_ac97c_capture_pointer(struct snd_pcm_substream *substream)
+{
+        struct atmel_ac97c      *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime  *runtime = substream->runtime;
+        snd_pcm_uframes_t       frames;
+        unsigned long           bytes;
+
+        bytes = dw_dma_get_dst_addr(chip->dma.rx_chan);
+        bytes -= runtime->dma_addr;
+
+        frames = bytes_to_frames(runtime, bytes);
+        if (frames >= runtime->buffer_size)
+                frames -= runtime->buffer_size;
+        return frames;
+}
+
+static struct snd_pcm_ops atmel_ac97_playback_ops = {
+        .open           = atmel_ac97c_playback_open,
+        .close          = atmel_ac97c_playback_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = atmel_ac97c_playback_hw_params,
+        .hw_free        = atmel_ac97c_playback_hw_free,
+        .prepare        = atmel_ac97c_playback_prepare,
+        .trigger        = atmel_ac97c_playback_trigger,
+        .pointer        = atmel_ac97c_playback_pointer,
+};
+
+static struct snd_pcm_ops atmel_ac97_capture_ops = {
+        .open           = atmel_ac97c_capture_open,
+        .close          = atmel_ac97c_capture_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = atmel_ac97c_capture_hw_params,
+        .hw_free        = atmel_ac97c_capture_hw_free,
+        .prepare        = atmel_ac97c_capture_prepare,
+        .trigger        = atmel_ac97c_capture_trigger,
+        .pointer        = atmel_ac97c_capture_pointer,
+};
+
+static irqreturn_t atmel_ac97c_interrupt(int irq, void *dev)
+{
+        struct atmel_ac97c      *chip  = (struct atmel_ac97c *)dev;
+        irqreturn_t             retval = IRQ_NONE;
+        u32                     sr     = ac97c_readl(chip, SR);
+        u32                     casr   = ac97c_readl(chip, CASR);
+        u32                     cosr   = ac97c_readl(chip, COSR);
+
+        if (sr & AC97C_SR_CAEVT) {
+                dev_info(&chip->pdev->dev, "channel A event%s%s%s%s%s%s\n",
+                                casr & AC97C_CSR_OVRUN   ? " OVRUN"   : "",
+                                casr & AC97C_CSR_RXRDY   ? " RXRDY"   : "",
+                                casr & AC97C_CSR_UNRUN   ? " UNRUN"   : "",
+                                casr & AC97C_CSR_TXEMPTY ? " TXEMPTY" : "",
+                                casr & AC97C_CSR_TXRDY   ? " TXRDY"   : "",
+                                !casr                    ? " NONE"    : "");
+                retval = IRQ_HANDLED;
+        }
+
+        if (sr & AC97C_SR_COEVT) {
+                dev_info(&chip->pdev->dev, "codec channel event%s%s%s%s%s\n",
+                                cosr & AC97C_CSR_OVRUN   ? " OVRUN"   : "",
+                                cosr & AC97C_CSR_RXRDY   ? " RXRDY"   : "",
+                                cosr & AC97C_CSR_TXEMPTY ? " TXEMPTY" : "",
+                                cosr & AC97C_CSR_TXRDY   ? " TXRDY"   : "",
+                                !cosr                    ? " NONE"    : "");
+                retval = IRQ_HANDLED;
+        }
+
+        if (retval == IRQ_NONE) {
+                dev_err(&chip->pdev->dev, "spurious interrupt sr 0x%08x "
+                                "casr 0x%08x cosr 0x%08x\n", sr, casr, cosr);
+        }
+
+        return retval;
+}
+
+static int __devinit atmel_ac97c_pcm_new(struct atmel_ac97c *chip)
+{
+        struct snd_pcm          *pcm;
+        struct snd_pcm_hardware hw = atmel_ac97c_hw;
+        int                     capture, playback, retval;
+
+        capture = test_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
+        playback = test_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
+
+        retval = snd_pcm_new(chip->card, chip->card->shortname,
+                        chip->pdev->id, playback, capture, &pcm);
+        if (retval)
+                return retval;
+
+        if (capture)
+                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
+                                &atmel_ac97_capture_ops);
+        if (playback)
+                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                &atmel_ac97_playback_ops);
+
+        retval = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                        &chip->pdev->dev, hw.periods_min * hw.period_bytes_min,
+                        hw.buffer_bytes_max);
+        if (retval)
+                return retval;
+
+        pcm->private_data = chip;
+        pcm->info_flags = 0;
+        strcpy(pcm->name, chip->card->shortname);
+        chip->pcm = pcm;
+
+        return 0;
+}
+
+static int atmel_ac97c_mixer_new(struct atmel_ac97c *chip)
+{
+        struct snd_ac97_template template;
+        memset(&template, 0, sizeof(template));
+        template.private_data = chip;
+        return snd_ac97_mixer(chip->ac97_bus, &template, &chip->ac97);
+}
+
+static void atmel_ac97c_write(struct snd_ac97 *ac97, unsigned short reg,
+                unsigned short val)
+{
+        struct atmel_ac97c *chip = get_chip(ac97);
+        unsigned long word;
+        int timeout = 40;
+
+        word = (reg & 0x7f) << 16 | val;
+
+        do {
+                if (ac97c_readl(chip, COSR) & AC97C_CSR_TXRDY) {
+                        ac97c_writel(chip, COTHR, word);
+                        return;
+                }
+                udelay(1);
+        } while (--timeout);
+
+        dev_dbg(&chip->pdev->dev, "codec write timeout\n");
+}
+
+static unsigned short atmel_ac97c_read(struct snd_ac97 *ac97,
+                unsigned short reg)
+{
+        struct atmel_ac97c *chip = get_chip(ac97);
+        unsigned long word;
+        int timeout = 40;
+        int write = 10;
+
+        word = (0x80 | (reg & 0x7f)) << 16;
+
+        if ((ac97c_readl(chip, COSR) & AC97C_CSR_RXRDY) != 0)
+                ac97c_readl(chip, CORHR);
+
+retry_write:
+        timeout = 40;
+
+        do {
+                if ((ac97c_readl(chip, COSR) & AC97C_CSR_TXRDY) != 0) {
+                        ac97c_writel(chip, COTHR, word);
+                        goto read_reg;
+                }
+                udelay(10);
+        } while (--timeout);
+
+        if (!--write)
+                goto timed_out;
+        goto retry_write;
+
+read_reg:
+        do {
+                if ((ac97c_readl(chip, COSR) & AC97C_CSR_RXRDY) != 0) {
+                        unsigned short val = ac97c_readl(chip, CORHR);
+                        return val;
+                }
+                udelay(10);
+        } while (--timeout);
+
+        if (!--write)
+                goto timed_out;
+        goto retry_write;
+
+timed_out:
+        dev_dbg(&chip->pdev->dev, "codec read timeout\n");
+        return 0xffff;
+}
+
+static bool filter(struct dma_chan *chan, void *slave)
+{
+        struct dw_dma_slave *dws = slave;
+
+        if (dws->dma_dev == chan->device->dev) {
+                chan->private = dws;
+                return true;
+        } else
+                return false;
+}
+
+static void atmel_ac97c_reset(struct atmel_ac97c *chip)
+{
+        ac97c_writel(chip, MR,   0);
+        ac97c_writel(chip, MR,   AC97C_MR_ENA);
+        ac97c_writel(chip, CAMR, 0);
+        ac97c_writel(chip, COMR, 0);
+
+        if (gpio_is_valid(chip->reset_pin)) {
+                gpio_set_value(chip->reset_pin, 0);
+                /* AC97 v2.2 specifications says minimum 1 us. */
+                udelay(2);
+                gpio_set_value(chip->reset_pin, 1);
+        }
+}
+
+static int __devinit atmel_ac97c_probe(struct platform_device *pdev)
+{
+        struct snd_card                 *card;
+        struct atmel_ac97c              *chip;
+        struct resource                 *regs;
+        struct ac97c_platform_data      *pdata;
+        struct clk                      *pclk;
+        static struct snd_ac97_bus_ops  ops = {
+                .write  = atmel_ac97c_write,
+                .read   = atmel_ac97c_read,
+        };
+        int                             retval;
+        int                             irq;
+
+        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!regs) {
+                dev_dbg(&pdev->dev, "no memory resource\n");
+                return -ENXIO;
+        }
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_dbg(&pdev->dev, "no platform data\n");
+                return -ENXIO;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_dbg(&pdev->dev, "could not get irq\n");
+                return -ENXIO;
+        }
+
+        pclk = clk_get(&pdev->dev, "pclk");
+        if (IS_ERR(pclk)) {
+                dev_dbg(&pdev->dev, "no peripheral clock\n");
+                return PTR_ERR(pclk);
+        }
+        clk_enable(pclk);
+
+        retval = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
+                        THIS_MODULE, sizeof(struct atmel_ac97c), &card);
+        if (retval) {
+                dev_dbg(&pdev->dev, "could not create sound card device\n");
+                goto err_snd_card_new;
+        }
+
+        chip = get_chip(card);
+
+        retval = request_irq(irq, atmel_ac97c_interrupt, 0, "AC97C", chip);
+        if (retval) {
+                dev_dbg(&pdev->dev, "unable to request irq %d\n", irq);
+                goto err_request_irq;
+        }
+        chip->irq = irq;
+
+        spin_lock_init(&chip->lock);
+
+        strcpy(card->driver, "Atmel AC97C");
+        strcpy(card->shortname, "Atmel AC97C");
+        sprintf(card->longname, "Atmel AC97 controller");
+
+        chip->card = card;
+        chip->pclk = pclk;
+        chip->pdev = pdev;
+        chip->regs = ioremap(regs->start, regs->end - regs->start + 1);
+
+        if (!chip->regs) {
+                dev_dbg(&pdev->dev, "could not remap register memory\n");
+                goto err_ioremap;
+        }
+
+        if (gpio_is_valid(pdata->reset_pin)) {
+                if (gpio_request(pdata->reset_pin, "reset_pin")) {
+                        dev_dbg(&pdev->dev, "reset pin not available\n");
+                        chip->reset_pin = -ENODEV;
+                } else {
+                        gpio_direction_output(pdata->reset_pin, 1);
+                        chip->reset_pin = pdata->reset_pin;
+                }
+        }
+
+        snd_card_set_dev(card, &pdev->dev);
+
+        atmel_ac97c_reset(chip);
+
+        /* Enable overrun interrupt from codec channel */
+        ac97c_writel(chip, COMR, AC97C_CSR_OVRUN);
+        ac97c_writel(chip, IER, ac97c_readl(chip, IMR) | AC97C_SR_COEVT);
+
+        retval = snd_ac97_bus(card, 0, &ops, chip, &chip->ac97_bus);
+        if (retval) {
+                dev_dbg(&pdev->dev, "could not register on ac97 bus\n");
+                goto err_ac97_bus;
+        }
+
+        retval = atmel_ac97c_mixer_new(chip);
+        if (retval) {
+                dev_dbg(&pdev->dev, "could not register ac97 mixer\n");
+                goto err_ac97_bus;
+        }
+
+        if (pdata->rx_dws.dma_dev) {
+                struct dw_dma_slave *dws = &pdata->rx_dws;
+                dma_cap_mask_t mask;
+
+                dws->rx_reg = regs->start + AC97C_CARHR + 2;
+
+                dma_cap_zero(mask);
+                dma_cap_set(DMA_SLAVE, mask);
+
+                chip->dma.rx_chan = dma_request_channel(mask, filter, dws);
+
+                dev_info(&chip->pdev->dev, "using %s for DMA RX\n",
+                                dev_name(&chip->dma.rx_chan->dev->device));
+                set_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
+        }
+
+        if (pdata->tx_dws.dma_dev) {
+                struct dw_dma_slave *dws = &pdata->tx_dws;
+                dma_cap_mask_t mask;
+
+                dws->tx_reg = regs->start + AC97C_CATHR + 2;
+
+                dma_cap_zero(mask);
+                dma_cap_set(DMA_SLAVE, mask);
+
+                chip->dma.tx_chan = dma_request_channel(mask, filter, dws);
+
+                dev_info(&chip->pdev->dev, "using %s for DMA TX\n",
+                                dev_name(&chip->dma.tx_chan->dev->device));
+                set_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
+        }
+
+        if (!test_bit(DMA_RX_CHAN_PRESENT, &chip->flags) &&
+                        !test_bit(DMA_TX_CHAN_PRESENT, &chip->flags)) {
+                dev_dbg(&pdev->dev, "DMA not available\n");
+                retval = -ENODEV;
+                goto err_dma;
+        }
+
+        retval = atmel_ac97c_pcm_new(chip);
+        if (retval) {
+                dev_dbg(&pdev->dev, "could not register ac97 pcm device\n");
+                goto err_dma;
+        }
+
+        retval = snd_card_register(card);
+        if (retval) {
+                dev_dbg(&pdev->dev, "could not register sound card\n");
+                goto err_dma;
+        }
+
+        platform_set_drvdata(pdev, card);
+
+        dev_info(&pdev->dev, "Atmel AC97 controller at 0x%p\n",
+                        chip->regs);
+
+        return 0;
+
+err_dma:
+        if (test_bit(DMA_RX_CHAN_PRESENT, &chip->flags))
+                dma_release_channel(chip->dma.rx_chan);
+        if (test_bit(DMA_TX_CHAN_PRESENT, &chip->flags))
+                dma_release_channel(chip->dma.tx_chan);
+        clear_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
+        clear_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
+        chip->dma.rx_chan = NULL;
+        chip->dma.tx_chan = NULL;
+err_ac97_bus:
+        snd_card_set_dev(card, NULL);
+
+        if (gpio_is_valid(chip->reset_pin))
+                gpio_free(chip->reset_pin);
+
+        iounmap(chip->regs);
+err_ioremap:
+        free_irq(irq, chip);
+err_request_irq:
+        snd_card_free(card);
+err_snd_card_new:
+        clk_disable(pclk);
+        clk_put(pclk);
+        return retval;
+}
+
+#ifdef CONFIG_PM
+static int atmel_ac97c_suspend(struct platform_device *pdev, pm_message_t msg)
+{
+        struct snd_card *card = platform_get_drvdata(pdev);
+        struct atmel_ac97c *chip = card->private_data;
+
+        if (test_bit(DMA_RX_READY, &chip->flags))
+                dw_dma_cyclic_stop(chip->dma.rx_chan);
+        if (test_bit(DMA_TX_READY, &chip->flags))
+                dw_dma_cyclic_stop(chip->dma.tx_chan);
+        clk_disable(chip->pclk);
+
+        return 0;
+}
+
+static int atmel_ac97c_resume(struct platform_device *pdev)
+{
+        struct snd_card *card = platform_get_drvdata(pdev);
+        struct atmel_ac97c *chip = card->private_data;
+
+        clk_enable(chip->pclk);
+        if (test_bit(DMA_RX_READY, &chip->flags))
+                dw_dma_cyclic_start(chip->dma.rx_chan);
+        if (test_bit(DMA_TX_READY, &chip->flags))
+                dw_dma_cyclic_start(chip->dma.tx_chan);
+
+        return 0;
+}
+#else
+#define atmel_ac97c_suspend NULL
+#define atmel_ac97c_resume NULL
+#endif
+
+static int __devexit atmel_ac97c_remove(struct platform_device *pdev)
+{
+        struct snd_card *card = platform_get_drvdata(pdev);
+        struct atmel_ac97c *chip = get_chip(card);
+
+        if (gpio_is_valid(chip->reset_pin))
+                gpio_free(chip->reset_pin);
+
+        ac97c_writel(chip, CAMR, 0);
+        ac97c_writel(chip, COMR, 0);
+        ac97c_writel(chip, MR,   0);
+
+        clk_disable(chip->pclk);
+        clk_put(chip->pclk);
+        iounmap(chip->regs);
+        free_irq(chip->irq, chip);
+
+        if (test_bit(DMA_RX_CHAN_PRESENT, &chip->flags))
+                dma_release_channel(chip->dma.rx_chan);
+        if (test_bit(DMA_TX_CHAN_PRESENT, &chip->flags))
+                dma_release_channel(chip->dma.tx_chan);
+        clear_bit(DMA_RX_CHAN_PRESENT, &chip->flags);
+        clear_bit(DMA_TX_CHAN_PRESENT, &chip->flags);
+        chip->dma.rx_chan = NULL;
+        chip->dma.tx_chan = NULL;
+
+        snd_card_set_dev(card, NULL);
+        snd_card_free(card);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver atmel_ac97c_driver = {
+        .remove         = __devexit_p(atmel_ac97c_remove),
+        .driver         = {
+                .name   = "atmel_ac97c",
+        },
+        .suspend        = atmel_ac97c_suspend,
+        .resume         = atmel_ac97c_resume,
+};
+
+static int __init atmel_ac97c_init(void)
+{
+        return platform_driver_probe(&atmel_ac97c_driver,
+                        atmel_ac97c_probe);
+}
+module_init(atmel_ac97c_init);
+
+static void __exit atmel_ac97c_exit(void)
+{
+        platform_driver_unregister(&atmel_ac97c_driver);
+}
+module_exit(atmel_ac97c_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Driver for Atmel AC97 controller");
+MODULE_AUTHOR("Hans-Christian Egtvedt <hans-christian.egtvedt@atmel.com>");
diff --git a/sound/atmel/ac97c.h b/sound/atmel/ac97c.h
new file mode 100644
index 000000000000..ecbba5021c80
--- /dev/null
+++ b/sound/atmel/ac97c.h
@@ -0,0 +1,73 @@
+/*
+ * Register definitions for Atmel AC97C
+ *
+ * Copyright (C) 2005-2009 Atmel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ */
+#ifndef __SOUND_ATMEL_AC97C_H
+#define __SOUND_ATMEL_AC97C_H
+
+#define AC97C_MR                0x08
+#define AC97C_ICA               0x10
+#define AC97C_OCA               0x14
+#define AC97C_CARHR             0x20
+#define AC97C_CATHR             0x24
+#define AC97C_CASR              0x28
+#define AC97C_CAMR              0x2c
+#define AC97C_CORHR             0x40
+#define AC97C_COTHR             0x44
+#define AC97C_COSR              0x48
+#define AC97C_COMR              0x4c
+#define AC97C_SR                0x50
+#define AC97C_IER               0x54
+#define AC97C_IDR               0x58
+#define AC97C_IMR               0x5c
+#define AC97C_VERSION           0xfc
+
+#define AC97C_CATPR             PDC_TPR
+#define AC97C_CATCR             PDC_TCR
+#define AC97C_CATNPR            PDC_TNPR
+#define AC97C_CATNCR            PDC_TNCR
+#define AC97C_CARPR             PDC_RPR
+#define AC97C_CARCR             PDC_RCR
+#define AC97C_CARNPR            PDC_RNPR
+#define AC97C_CARNCR            PDC_RNCR
+#define AC97C_PTCR              PDC_PTCR
+
+#define AC97C_MR_ENA            (1 << 0)
+#define AC97C_MR_WRST           (1 << 1)
+#define AC97C_MR_VRA            (1 << 2)
+
+#define AC97C_CSR_TXRDY         (1 << 0)
+#define AC97C_CSR_TXEMPTY       (1 << 1)
+#define AC97C_CSR_UNRUN         (1 << 2)
+#define AC97C_CSR_RXRDY         (1 << 4)
+#define AC97C_CSR_OVRUN         (1 << 5)
+#define AC97C_CSR_ENDTX         (1 << 10)
+#define AC97C_CSR_ENDRX         (1 << 14)
+
+#define AC97C_CMR_SIZE_20       (0 << 16)
+#define AC97C_CMR_SIZE_18       (1 << 16)
+#define AC97C_CMR_SIZE_16       (2 << 16)
+#define AC97C_CMR_SIZE_10       (3 << 16)
+#define AC97C_CMR_CEM_LITTLE    (1 << 18)
+#define AC97C_CMR_CEM_BIG       (0 << 18)
+#define AC97C_CMR_CENA          (1 << 21)
+#define AC97C_CMR_DMAEN         (1 << 22)
+
+#define AC97C_SR_CAEVT          (1 << 3)
+#define AC97C_SR_COEVT          (1 << 2)
+#define AC97C_SR_WKUP           (1 << 1)
+#define AC97C_SR_SOF            (1 << 0)
+
+#define AC97C_CH_MASK(slot)                                             \
+        (0x7 << (3 * (AC97_SLOT_##slot - 3)))
+#define AC97C_CH_ASSIGN(slot, channel)                                  \
+        (AC97C_CHANNEL_##channel << (3 * (AC97_SLOT_##slot - 3)))
+#define AC97C_CHANNEL_NONE      0x0
+#define AC97C_CHANNEL_A         0x1
+
+#endif /* __SOUND_ATMEL_AC97C_H */
diff --git a/sound/core/control.c b/sound/core/control.c
index 636b3b52ef8b..17b8d47a5cd0 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -723,14 +723,11 @@ static int snd_ctl_elem_read_user(struct snd_card *card,
 {
         struct snd_ctl_elem_value *control;
         int result;
-        
-        control = kmalloc(sizeof(*control), GFP_KERNEL);
-        if (control == NULL)
-                return -ENOMEM; 
-        if (copy_from_user(control, _control, sizeof(*control))) {
-                kfree(control);
-                return -EFAULT;
-        }
+
+        control = memdup_user(_control, sizeof(*control));
+        if (IS_ERR(control))
+                return PTR_ERR(control);
+
         snd_power_lock(card);
         result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
         if (result >= 0)
@@ -784,13 +781,10 @@ static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
         struct snd_card *card;
         int result;
 
-        control = kmalloc(sizeof(*control), GFP_KERNEL);
-        if (control == NULL)
-                return -ENOMEM; 
-        if (copy_from_user(control, _control, sizeof(*control))) {
-                kfree(control);
-                return -EFAULT;
-        }
+        control = memdup_user(_control, sizeof(*control));
+        if (IS_ERR(control))
+                return PTR_ERR(control);
+
         card = file->card;
         snd_power_lock(card);
         result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
@@ -916,13 +910,10 @@ static int snd_ctl_elem_user_tlv(struct snd_kcontrol *kcontrol,
         if (op_flag > 0) {
                 if (size > 1024 * 128)  /* sane value */
                         return -EINVAL;
-                new_data = kmalloc(size, GFP_KERNEL);
-                if (new_data == NULL)
-                        return -ENOMEM;
-                if (copy_from_user(new_data, tlv, size)) {
-                        kfree(new_data);
-                        return -EFAULT;
-                }
+
+                new_data = memdup_user(tlv, size);
+                if (IS_ERR(new_data))
+                        return PTR_ERR(new_data);
                 change = ue->tlv_data_size != size;
                 if (!change)
                         change = memcmp(ue->tlv_data, new_data, size);
@@ -1373,12 +1364,9 @@ EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
 static int snd_ctl_fasync(int fd, struct file * file, int on)
 {
         struct snd_ctl_file *ctl;
-        int err;
+
         ctl = file->private_data;
-        err = fasync_helper(fd, file, on, &ctl->fasync);
-        if (err < 0)
-                return err;
-        return 0;
+        return fasync_helper(fd, file, on, &ctl->fasync);
 }
 
 /*
diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c
index 195cafc5a553..a70ee7f1ed98 100644
--- a/sound/core/hwdep.c
+++ b/sound/core/hwdep.c
@@ -99,9 +99,6 @@ static int snd_hwdep_open(struct inode *inode, struct file * file)
         if (hw == NULL)
                 return -ENODEV;
 
-        if (!hw->ops.open)
-                return -ENXIO;
-
         if (!try_module_get(hw->card->module))
                 return -EFAULT;
 
@@ -113,6 +110,10 @@ static int snd_hwdep_open(struct inode *inode, struct file * file)
                         err = -EBUSY;
                         break;
                 }
+                if (!hw->ops.open) {
+                        err = 0;
+                        break;
+                }
                 err = hw->ops.open(hw, file);
                 if (err >= 0)
                         break;
@@ -151,7 +152,7 @@ static int snd_hwdep_open(struct inode *inode, struct file * file)
 
 static int snd_hwdep_release(struct inode *inode, struct file * file)
 {
-        int err = -ENXIO;
+        int err = 0;
         struct snd_hwdep *hw = file->private_data;
         struct module *mod = hw->card->module;
 
diff --git a/sound/core/info.c b/sound/core/info.c
index 70fa87189f36..35df614f6c55 100644
--- a/sound/core/info.c
+++ b/sound/core/info.c
@@ -154,11 +154,6 @@ EXPORT_SYMBOL(snd_seq_root);
 struct snd_info_entry *snd_oss_root;
 #endif
 
-static inline void snd_info_entry_prepare(struct proc_dir_entry *de)
-{
-        de->owner = THIS_MODULE;
-}
-
 static void snd_remove_proc_entry(struct proc_dir_entry *parent,
                                   struct proc_dir_entry *de)
 {
@@ -522,32 +517,11 @@ static const struct file_operations snd_info_entry_operations =
         .release =              snd_info_entry_release,
 };
 
-/**
- * snd_create_proc_entry - create a procfs entry
- * @name: the name of the proc file
- * @mode: the file permission bits, S_Ixxx
- * @parent: the parent proc-directory entry
- *
- * Creates a new proc file entry with the given name and permission
- * on the given directory.
- *
- * Returns the pointer of new instance or NULL on failure.
- */
-static struct proc_dir_entry *snd_create_proc_entry(const char *name, mode_t mode,
-                                                    struct proc_dir_entry *parent)
-{
-        struct proc_dir_entry *p;
-        p = create_proc_entry(name, mode, parent);
-        if (p)
-                snd_info_entry_prepare(p);
-        return p;
-}
-
 int __init snd_info_init(void)
 {
         struct proc_dir_entry *p;
 
-        p = snd_create_proc_entry("asound", S_IFDIR | S_IRUGO | S_IXUGO, NULL);
+        p = create_proc_entry("asound", S_IFDIR | S_IRUGO | S_IXUGO, NULL);
         if (p == NULL)
                 return -ENOMEM;
         snd_proc_root = p;
@@ -974,12 +948,11 @@ int snd_info_register(struct snd_info_entry * entry)
                 return -ENXIO;
         root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
         mutex_lock(&info_mutex);
-        p = snd_create_proc_entry(entry->name, entry->mode, root);
+        p = create_proc_entry(entry->name, entry->mode, root);
         if (!p) {
                 mutex_unlock(&info_mutex);
                 return -ENOMEM;
         }
-        p->owner = entry->module;
         if (!S_ISDIR(entry->mode))
                 p->proc_fops = &snd_info_entry_operations;
         p->size = entry->size;
diff --git a/sound/core/init.c b/sound/core/init.c
index dc4b80c7f311..fd56afe846ed 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -208,6 +208,7 @@ int snd_card_create(int idx, const char *xid,
         INIT_LIST_HEAD(&card->controls);
         INIT_LIST_HEAD(&card->ctl_files);
         spin_lock_init(&card->files_lock);
+        INIT_LIST_HEAD(&card->files_list);
         init_waitqueue_head(&card->shutdown_sleep);
 #ifdef CONFIG_PM
         mutex_init(&card->power_lock);
@@ -274,6 +275,7 @@ static int snd_disconnect_release(struct inode *inode, struct file *file)
         list_for_each_entry(_df, &shutdown_files, shutdown_list) {
                 if (_df->file == file) {
                         df = _df;
+                        list_del_init(&df->shutdown_list);
                         break;
                 }
         }
@@ -362,8 +364,7 @@ int snd_card_disconnect(struct snd_card *card)
         /* phase 2: replace file->f_op with special dummy operations */
         
         spin_lock(&card->files_lock);
-        mfile = card->files;
-        while (mfile) {
+        list_for_each_entry(mfile, &card->files_list, list) {
                 file = mfile->file;
 
                 /* it's critical part, use endless loop */
@@ -376,8 +377,6 @@ int snd_card_disconnect(struct snd_card *card)
 
                 mfile->file->f_op = &snd_shutdown_f_ops;
                 fops_get(mfile->file->f_op);
-                
-                mfile = mfile->next;
         }
         spin_unlock(&card->files_lock); 
 
@@ -457,7 +456,7 @@ int snd_card_free_when_closed(struct snd_card *card)
                 return ret;
 
         spin_lock(&card->files_lock);
-        if (card->files == NULL)
+        if (list_empty(&card->files_list))
                 free_now = 1;
         else
                 card->free_on_last_close = 1;
@@ -477,7 +476,7 @@ int snd_card_free(struct snd_card *card)
                 return ret;
 
         /* wait, until all devices are ready for the free operation */
-        wait_event(card->shutdown_sleep, card->files == NULL);
+        wait_event(card->shutdown_sleep, list_empty(&card->files_list));
         snd_card_do_free(card);
         return 0;
 }
@@ -824,15 +823,13 @@ int snd_card_file_add(struct snd_card *card, struct file *file)
                 return -ENOMEM;
         mfile->file = file;
         mfile->disconnected_f_op = NULL;
-        mfile->next = NULL;
         spin_lock(&card->files_lock);
         if (card->shutdown) {
                 spin_unlock(&card->files_lock);
                 kfree(mfile);
                 return -ENODEV;
         }
-        mfile->next = card->files;
-        card->files = mfile;
+        list_add(&mfile->list, &card->files_list);
         spin_unlock(&card->files_lock);
         return 0;
 }
@@ -854,29 +851,20 @@ EXPORT_SYMBOL(snd_card_file_add);
  */
 int snd_card_file_remove(struct snd_card *card, struct file *file)
 {
-        struct snd_monitor_file *mfile, *pfile = NULL;
+        struct snd_monitor_file *mfile, *found = NULL;
         int last_close = 0;
 
         spin_lock(&card->files_lock);
-        mfile = card->files;
-        while (mfile) {
+        list_for_each_entry(mfile, &card->files_list, list) {
                 if (mfile->file == file) {
-                        if (pfile)
-                                pfile->next = mfile->next;
-                        else
-                                card->files = mfile->next;
+                        list_del(&mfile->list);
+                        if (mfile->disconnected_f_op)
+                                fops_put(mfile->disconnected_f_op);
+                        found = mfile;
                         break;
                 }
-                pfile = mfile;
-                mfile = mfile->next;
-        }
-        if (mfile && mfile->disconnected_f_op) {
-                fops_put(mfile->disconnected_f_op);
-                spin_lock(&shutdown_lock);
-                list_del(&mfile->shutdown_list);
-                spin_unlock(&shutdown_lock);
         }
-        if (card->files == NULL)
+        if (list_empty(&card->files_list))
                 last_close = 1;
         spin_unlock(&card->files_lock);
         if (last_close) {
@@ -884,11 +872,11 @@ int snd_card_file_remove(struct snd_card *card, struct file *file)
                 if (card->free_on_last_close)
                         snd_card_do_free(card);
         }
-        if (!mfile) {
+        if (!found) {
                 snd_printk(KERN_ERR "ALSA card file remove problem (%p)\n", file);
                 return -ENOENT;
         }
-        kfree(mfile);
+        kfree(found);
         return 0;
 }
 
diff --git a/sound/core/jack.c b/sound/core/jack.c
index dd4a12dc09aa..d54d1a05fe65 100644
--- a/sound/core/jack.c
+++ b/sound/core/jack.c
@@ -23,10 +23,21 @@
 #include <sound/jack.h>
 #include <sound/core.h>
 
+static int jack_types[] = {
+        SW_HEADPHONE_INSERT,
+        SW_MICROPHONE_INSERT,
+        SW_LINEOUT_INSERT,
+        SW_JACK_PHYSICAL_INSERT,
+        SW_VIDEOOUT_INSERT,
+};
+
 static int snd_jack_dev_free(struct snd_device *device)
 {
         struct snd_jack *jack = device->device_data;
 
+        if (jack->private_free)
+                jack->private_free(jack);
+
         /* If the input device is registered with the input subsystem
          * then we need to use a different deallocator. */
         if (jack->registered)
@@ -47,7 +58,7 @@ static int snd_jack_dev_register(struct snd_device *device)
         int err;
 
         snprintf(jack->name, sizeof(jack->name), "%s %s",
-                 card->longname, jack->id);
+                 card->shortname, jack->id);
         jack->input_dev->name = jack->name;
 
         /* Default to the sound card device. */
@@ -79,6 +90,7 @@ int snd_jack_new(struct snd_card *card, const char *id, int type,
 {
         struct snd_jack *jack;
         int err;
+        int i;
         static struct snd_device_ops ops = {
                 .dev_free = snd_jack_dev_free,
                 .dev_register = snd_jack_dev_register,
@@ -100,18 +112,10 @@ int snd_jack_new(struct snd_card *card, const char *id, int type,
 
         jack->type = type;
 
-        if (type & SND_JACK_HEADPHONE)
-                input_set_capability(jack->input_dev, EV_SW,
-                                     SW_HEADPHONE_INSERT);
-        if (type & SND_JACK_LINEOUT)
-                input_set_capability(jack->input_dev, EV_SW,
-                                     SW_LINEOUT_INSERT);
-        if (type & SND_JACK_MICROPHONE)
-                input_set_capability(jack->input_dev, EV_SW,
-                                     SW_MICROPHONE_INSERT);
-        if (type & SND_JACK_MECHANICAL)
-                input_set_capability(jack->input_dev, EV_SW,
-                                     SW_JACK_PHYSICAL_INSERT);
+        for (i = 0; i < ARRAY_SIZE(jack_types); i++)
+                if (type & (1 << i))
+                        input_set_capability(jack->input_dev, EV_SW,
+                                             jack_types[i]);
 
         err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
         if (err < 0)
@@ -154,21 +158,17 @@ EXPORT_SYMBOL(snd_jack_set_parent);
  */
 void snd_jack_report(struct snd_jack *jack, int status)
 {
+        int i;
+
         if (!jack)
                 return;
 
-        if (jack->type & SND_JACK_HEADPHONE)
-                input_report_switch(jack->input_dev, SW_HEADPHONE_INSERT,
-                                    status & SND_JACK_HEADPHONE);
-        if (jack->type & SND_JACK_LINEOUT)
-                input_report_switch(jack->input_dev, SW_LINEOUT_INSERT,
-                                    status & SND_JACK_LINEOUT);
-        if (jack->type & SND_JACK_MICROPHONE)
-                input_report_switch(jack->input_dev, SW_MICROPHONE_INSERT,
-                                    status & SND_JACK_MICROPHONE);
-        if (jack->type & SND_JACK_MECHANICAL)
-                input_report_switch(jack->input_dev, SW_JACK_PHYSICAL_INSERT,
-                                    status & SND_JACK_MECHANICAL);
+        for (i = 0; i < ARRAY_SIZE(jack_types); i++) {
+                int testbit = 1 << i;
+                if (jack->type & testbit)
+                        input_report_switch(jack->input_dev, jack_types[i],
+                                            status & testbit);
+        }
 
         input_sync(jack->input_dev);
 }
diff --git a/sound/core/misc.c b/sound/core/misc.c
index 38524f615d94..a9710e0c97af 100644
--- a/sound/core/misc.c
+++ b/sound/core/misc.c
@@ -95,12 +95,14 @@ snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list)
 {
         const struct snd_pci_quirk *q;
 
-        for (q = list; q->subvendor; q++)
-                if (q->subvendor == pci->subsystem_vendor &&
-                    (!q->subdevice || q->subdevice == pci->subsystem_device))
+        for (q = list; q->subvendor; q++) {
+                if (q->subvendor != pci->subsystem_vendor)
+                        continue;
+                if (!q->subdevice ||
+                    (pci->subsystem_device & q->subdevice_mask) == q->subdevice)
                         return q;
+        }
         return NULL;
 }
-
 EXPORT_SYMBOL(snd_pci_quirk_lookup);
 #endif
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index 4690b8b5681f..5dcd8a526970 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -692,6 +692,9 @@ static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer,
                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right);
                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_CVOLUME)
                         snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CVOLUME], left, right);
+        } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CVOLUME) {
+                snd_mixer_oss_put_volume1_vol(fmixer, pslot,
+                        slot->numid[SNDRV_MIXER_OSS_ITEM_CVOLUME], left, right);
         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GVOLUME) {
                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GVOLUME], left, right);
         } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GLOBAL) {
@@ -700,19 +703,27 @@ static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer,
         if (left || right) {
                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH)
                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
+                if (slot->present & SNDRV_MIXER_OSS_PRESENT_CSWITCH)
+                        snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], left, right, 0);
                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH)
                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE)
                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
+                if (slot->present & SNDRV_MIXER_OSS_PRESENT_CROUTE)
+                        snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], left, right, 1);
                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE)
                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
         } else {
                 if (slot->present & SNDRV_MIXER_OSS_PRESENT_PSWITCH) {
                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PSWITCH], left, right, 0);
+                } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CSWITCH) {
+                        snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], left, right, 0);
                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GSWITCH) {
                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GSWITCH], left, right, 0);
                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_PROUTE) {
                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PROUTE], left, right, 1);
+                } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_CROUTE) {
+                        snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], left, right, 1);
                 } else if (slot->present & SNDRV_MIXER_OSS_PRESENT_GROUTE) {
                         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_GROUTE], left, right, 1);
                 }
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index e17836680f49..dda000b9684c 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -1160,9 +1160,11 @@ snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const
                     runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
                         if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
-                                printk("pcm_oss: write: recovering from XRUN\n");
+                                printk(KERN_DEBUG "pcm_oss: write: "
+                                       "recovering from XRUN\n");
                         else
-                                printk("pcm_oss: write: recovering from SUSPEND\n");
+                                printk(KERN_DEBUG "pcm_oss: write: "
+                                       "recovering from SUSPEND\n");
 #endif
                         ret = snd_pcm_oss_prepare(substream);
                         if (ret < 0)
@@ -1196,9 +1198,11 @@ snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *p
                     runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
                         if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
-                                printk("pcm_oss: read: recovering from XRUN\n");
+                                printk(KERN_DEBUG "pcm_oss: read: "
+                                       "recovering from XRUN\n");
                         else
-                                printk("pcm_oss: read: recovering from SUSPEND\n");
+                                printk(KERN_DEBUG "pcm_oss: read: "
+                                       "recovering from SUSPEND\n");
 #endif
                         ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
                         if (ret < 0)
@@ -1242,9 +1246,11 @@ snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void
                     runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
                         if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
-                                printk("pcm_oss: writev: recovering from XRUN\n");
+                                printk(KERN_DEBUG "pcm_oss: writev: "
+                                       "recovering from XRUN\n");
                         else
-                                printk("pcm_oss: writev: recovering from SUSPEND\n");
+                                printk(KERN_DEBUG "pcm_oss: writev: "
+                                       "recovering from SUSPEND\n");
 #endif
                         ret = snd_pcm_oss_prepare(substream);
                         if (ret < 0)
@@ -1278,9 +1284,11 @@ snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void *
                     runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
                         if (runtime->status->state == SNDRV_PCM_STATE_XRUN)
-                                printk("pcm_oss: readv: recovering from XRUN\n");
+                                printk(KERN_DEBUG "pcm_oss: readv: "
+                                       "recovering from XRUN\n");
                         else
-                                printk("pcm_oss: readv: recovering from SUSPEND\n");
+                                printk(KERN_DEBUG "pcm_oss: readv: "
+                                       "recovering from SUSPEND\n");
 #endif
                         ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
                         if (ret < 0)
@@ -1533,7 +1541,7 @@ static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size)
         init_waitqueue_entry(&wait, current);
         add_wait_queue(&runtime->sleep, &wait);
 #ifdef OSS_DEBUG
-        printk("sync1: size = %li\n", size);
+        printk(KERN_DEBUG "sync1: size = %li\n", size);
 #endif
         while (1) {
                 result = snd_pcm_oss_write2(substream, runtime->oss.buffer, size, 1);
@@ -1590,7 +1598,7 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                 mutex_lock(&runtime->oss.params_lock);
                 if (runtime->oss.buffer_used > 0) {
 #ifdef OSS_DEBUG
-                        printk("sync: buffer_used\n");
+                        printk(KERN_DEBUG "sync: buffer_used\n");
 #endif
                         size = (8 * (runtime->oss.period_bytes - runtime->oss.buffer_used) + 7) / width;
                         snd_pcm_format_set_silence(format,
@@ -1603,7 +1611,7 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                         }
                 } else if (runtime->oss.period_ptr > 0) {
 #ifdef OSS_DEBUG
-                        printk("sync: period_ptr\n");
+                        printk(KERN_DEBUG "sync: period_ptr\n");
 #endif
                         size = runtime->oss.period_bytes - runtime->oss.period_ptr;
                         snd_pcm_format_set_silence(format,
@@ -1767,7 +1775,7 @@ static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
                        AFMT_S8 | AFMT_U16_LE |
                        AFMT_U16_BE |
                         AFMT_S32_LE | AFMT_S32_BE |
-                        AFMT_S24_LE | AFMT_S24_LE |
+                        AFMT_S24_LE | AFMT_S24_BE |
                         AFMT_S24_PACKED;
         params = kmalloc(sizeof(*params), GFP_KERNEL);
         if (!params)
@@ -1895,7 +1903,9 @@ static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file *pcm_oss_file, unsig
 
 static int snd_pcm_oss_nonblock(struct file * file)
 {
+        spin_lock(&file->f_lock);
         file->f_flags |= O_NONBLOCK;
+        spin_unlock(&file->f_lock);
         return 0;
 }
 
@@ -1952,7 +1962,7 @@ static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int tr
         int err, cmd;
 
 #ifdef OSS_DEBUG
-        printk("pcm_oss: trigger = 0x%x\n", trigger);
+        printk(KERN_DEBUG "pcm_oss: trigger = 0x%x\n", trigger);
 #endif
         
         psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
@@ -2170,7 +2180,9 @@ static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stre
         }
 
 #ifdef OSS_DEBUG
-        printk("pcm_oss: space: bytes = %i, fragments = %i, fragstotal = %i, fragsize = %i\n", info.bytes, info.fragments, info.fragstotal, info.fragsize);
+        printk(KERN_DEBUG "pcm_oss: space: bytes = %i, fragments = %i, "
+               "fragstotal = %i, fragsize = %i\n",
+               info.bytes, info.fragments, info.fragstotal, info.fragsize);
 #endif
         if (copy_to_user(_info, &info, sizeof(info)))
                 return -EFAULT;
@@ -2473,7 +2485,7 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long
         if (((cmd >> 8) & 0xff) != 'P')
                 return -EINVAL;
 #ifdef OSS_DEBUG
-        printk("pcm_oss: ioctl = 0x%x\n", cmd);
+        printk(KERN_DEBUG "pcm_oss: ioctl = 0x%x\n", cmd);
 #endif
         switch (cmd) {
         case SNDCTL_DSP_RESET:
@@ -2627,7 +2639,8 @@ static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t coun
 #else
         {
                 ssize_t res = snd_pcm_oss_read1(substream, buf, count);
-                printk("pcm_oss: read %li bytes (returned %li bytes)\n", (long)count, (long)res);
+                printk(KERN_DEBUG "pcm_oss: read %li bytes "
+                       "(returned %li bytes)\n", (long)count, (long)res);
                 return res;
         }
 #endif
@@ -2646,7 +2659,8 @@ static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size
         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);
+        printk(KERN_DEBUG "pcm_oss: write %li bytes (wrote %li bytes)\n",
+               (long)count, (long)result);
 #endif
         return result;
 }
@@ -2720,7 +2734,7 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area)
         int err;
 
 #ifdef OSS_DEBUG
-        printk("pcm_oss: mmap begin\n");
+        printk(KERN_DEBUG "pcm_oss: mmap begin\n");
 #endif
         pcm_oss_file = file->private_data;
         switch ((area->vm_flags & (VM_READ | VM_WRITE))) {
@@ -2770,7 +2784,8 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area)
         runtime->silence_threshold = 0;
         runtime->silence_size = 0;
 #ifdef OSS_DEBUG
-        printk("pcm_oss: mmap ok, bytes = 0x%x\n", runtime->oss.mmap_bytes);
+        printk(KERN_DEBUG "pcm_oss: mmap ok, bytes = 0x%x\n",
+               runtime->oss.mmap_bytes);
 #endif
         /* In mmap mode we never stop */
         runtime->stop_threshold = runtime->boundary;
@@ -2872,7 +2887,7 @@ static void snd_pcm_oss_proc_write(struct snd_info_entry *entry,
                         setup = kmalloc(sizeof(*setup), GFP_KERNEL);
                         if (! setup) {
                                 buffer->error = -ENOMEM;
-                                mutex_lock(&pstr->oss.setup_mutex);
+                                mutex_unlock(&pstr->oss.setup_mutex);
                                 return;
                         }
                         if (pstr->oss.setup_list == NULL)
@@ -2886,7 +2901,7 @@ static void snd_pcm_oss_proc_write(struct snd_info_entry *entry,
                         if (! template.task_name) {
                                 kfree(setup);
                                 buffer->error = -ENOMEM;
-                                mutex_lock(&pstr->oss.setup_mutex);
+                                mutex_unlock(&pstr->oss.setup_mutex);
                                 return;
                         }
                 }
diff --git a/sound/core/oss/pcm_plugin.h b/sound/core/oss/pcm_plugin.h
index ca2f4c39be46..b9afab603711 100644
--- a/sound/core/oss/pcm_plugin.h
+++ b/sound/core/oss/pcm_plugin.h
@@ -176,9 +176,9 @@ static inline int snd_pcm_plug_slave_format(int format, struct snd_mask *format_
 #endif
 
 #ifdef PLUGIN_DEBUG
-#define pdprintf( fmt, args... ) printk( "plugin: " fmt, ##args)
+#define pdprintf(fmt, args...) printk(KERN_DEBUG "plugin: " fmt, ##args)
 #else
-#define pdprintf( fmt, args... ) 
+#define pdprintf(fmt, args...)
 #endif
 
 #endif                          /* __PCM_PLUGIN_H */
diff --git a/sound/core/oss/rate.c b/sound/core/oss/rate.c
index a466443c4a26..2fa9299a440d 100644
--- a/sound/core/oss/rate.c
+++ b/sound/core/oss/rate.c
@@ -157,7 +157,7 @@ static void resample_shrink(struct snd_pcm_plugin *plugin,
                 while (dst_frames1 > 0) {
                         S1 = S2;
                         if (src_frames1-- > 0) {
-                                S1 = *src;
+                                S2 = *src;
                                 src += src_step;
                         }
                         if (pos & ~R_MASK) {
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index 192a433a2403..145931a9ff30 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -667,7 +667,6 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
                 spin_lock_init(&substream->self_group.lock);
                 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;
         }
@@ -692,7 +691,7 @@ EXPORT_SYMBOL(snd_pcm_new_stream);
  *
  * Returns zero if successful, or a negative error code on failure.
  */
-int snd_pcm_new(struct snd_card *card, char *id, int device,
+int snd_pcm_new(struct snd_card *card, const char *id, int device,
                 int playback_count, int capture_count,
                 struct snd_pcm ** rpcm)
 {
diff --git a/sound/core/pcm_compat.c b/sound/core/pcm_compat.c
index 36d7a5998234..08bfed594a83 100644
--- a/sound/core/pcm_compat.c
+++ b/sound/core/pcm_compat.c
@@ -232,14 +232,11 @@ static int snd_pcm_ioctl_hw_params_compat(struct snd_pcm_substream *substream,
         if (! (runtime = substream->runtime))
                 return -ENOTTY;
 
-        data = kmalloc(sizeof(*data), GFP_KERNEL);
-        if (data == NULL)
-                return -ENOMEM;
         /* only fifo_size is different, so just copy all */
-        if (copy_from_user(data, data32, sizeof(*data32))) {
-                err = -EFAULT;
-                goto error;
-        }
+        data = memdup_user(data32, sizeof(*data32));
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+
         if (refine)
                 err = snd_pcm_hw_refine(substream, data);
         else
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 921691080f35..a2a792c18c40 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -125,23 +125,32 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram
         }
 }
 
+#ifdef CONFIG_SND_PCM_XRUN_DEBUG
+#define xrun_debug(substream)   ((substream)->pstr->xrun_debug)
+#else
+#define xrun_debug(substream)   0
+#endif
+
+#define dump_stack_on_xrun(substream) do {      \
+                if (xrun_debug(substream) > 1)  \
+                        dump_stack();           \
+        } while (0)
+
 static void xrun(struct snd_pcm_substream *substream)
 {
         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
-#ifdef CONFIG_SND_PCM_XRUN_DEBUG
-        if (substream->pstr->xrun_debug) {
+        if (xrun_debug(substream)) {
                 snd_printd(KERN_DEBUG "XRUN: pcmC%dD%d%c\n",
                            substream->pcm->card->number,
                            substream->pcm->device,
                            substream->stream ? 'c' : 'p');
-                if (substream->pstr->xrun_debug > 1)
-                        dump_stack();
+                dump_stack_on_xrun(substream);
         }
-#endif
 }
 
-static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream,
-                                                          struct snd_pcm_runtime *runtime)
+static snd_pcm_uframes_t
+snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream,
+                          struct snd_pcm_runtime *runtime)
 {
         snd_pcm_uframes_t pos;
 
@@ -150,17 +159,21 @@ static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substre
         pos = substream->ops->pointer(substream);
         if (pos == SNDRV_PCM_POS_XRUN)
                 return pos; /* XRUN */
-#ifdef CONFIG_SND_DEBUG
         if (pos >= runtime->buffer_size) {
-                snd_printk(KERN_ERR  "BUG: stream = %i, pos = 0x%lx, buffer size = 0x%lx, period size = 0x%lx\n", substream->stream, pos, runtime->buffer_size, runtime->period_size);
+                if (printk_ratelimit()) {
+                        snd_printd(KERN_ERR  "BUG: stream = %i, pos = 0x%lx, "
+                                   "buffer size = 0x%lx, period size = 0x%lx\n",
+                                   substream->stream, pos, runtime->buffer_size,
+                                   runtime->period_size);
+                }
+                pos = 0;
         }
-#endif
         pos -= pos % runtime->min_align;
         return pos;
 }
 
-static inline int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream,
-                                             struct snd_pcm_runtime *runtime)
+static int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream,
+                                      struct snd_pcm_runtime *runtime)
 {
         snd_pcm_uframes_t avail;
 
@@ -182,48 +195,108 @@ static inline int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream
         return 0;
 }
 
-static inline int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
+#define hw_ptr_error(substream, fmt, args...)                           \
+        do {                                                            \
+                if (xrun_debug(substream)) {                            \
+                        if (printk_ratelimit()) {                       \
+                                snd_printd("PCM: " fmt, ##args);        \
+                        }                                               \
+                        dump_stack_on_xrun(substream);                  \
+                }                                                       \
+        } while (0)
+
+static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t pos;
-        snd_pcm_uframes_t new_hw_ptr, hw_ptr_interrupt;
-        snd_pcm_sframes_t delta;
+        snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_ptr_interrupt, hw_base;
+        snd_pcm_sframes_t hdelta, delta;
+        unsigned long jdelta;
 
+        old_hw_ptr = runtime->status->hw_ptr;
         pos = snd_pcm_update_hw_ptr_pos(substream, runtime);
         if (pos == SNDRV_PCM_POS_XRUN) {
                 xrun(substream);
                 return -EPIPE;
         }
-        if (runtime->period_size == runtime->buffer_size)
-                goto __next_buf;
-        new_hw_ptr = runtime->hw_ptr_base + pos;
+        hw_base = runtime->hw_ptr_base;
+        new_hw_ptr = hw_base + pos;
         hw_ptr_interrupt = runtime->hw_ptr_interrupt + runtime->period_size;
-
-        delta = hw_ptr_interrupt - new_hw_ptr;
-        if (delta > 0) {
-                if ((snd_pcm_uframes_t)delta < runtime->buffer_size / 2) {
-#ifdef CONFIG_SND_PCM_XRUN_DEBUG
-                        if (runtime->periods > 1 && substream->pstr->xrun_debug) {
-                                snd_printd(KERN_ERR "Unexpected hw_pointer value [1] (stream = %i, delta: -%ld, max jitter = %ld): wrong interrupt acknowledge?\n", substream->stream, (long) delta, runtime->buffer_size / 2);
-                                if (substream->pstr->xrun_debug > 1)
-                                        dump_stack();
-                        }
-#endif
-                        return 0;
+        delta = new_hw_ptr - hw_ptr_interrupt;
+        if (hw_ptr_interrupt >= runtime->boundary) {
+                hw_ptr_interrupt -= runtime->boundary;
+                if (hw_base < runtime->boundary / 2)
+                        /* hw_base was already lapped; recalc delta */
+                        delta = new_hw_ptr - hw_ptr_interrupt;
+        }
+        if (delta < 0) {
+                delta += runtime->buffer_size;
+                if (delta < 0) {
+                        hw_ptr_error(substream, 
+                                     "Unexpected hw_pointer value "
+                                     "(stream=%i, pos=%ld, intr_ptr=%ld)\n",
+                                     substream->stream, (long)pos,
+                                     (long)hw_ptr_interrupt);
+                        /* rebase to interrupt position */
+                        hw_base = new_hw_ptr = hw_ptr_interrupt;
+                        /* align hw_base to buffer_size */
+                        hw_base -= hw_base % runtime->buffer_size;
+                        delta = 0;
+                } else {
+                        hw_base += runtime->buffer_size;
+                        if (hw_base >= runtime->boundary)
+                                hw_base = 0;
+                        new_hw_ptr = hw_base + pos;
                 }
-              __next_buf:
-                runtime->hw_ptr_base += runtime->buffer_size;
-                if (runtime->hw_ptr_base == runtime->boundary)
-                        runtime->hw_ptr_base = 0;
-                new_hw_ptr = runtime->hw_ptr_base + pos;
         }
-
+        /* Skip the jiffies check for hardwares with BATCH flag.
+         * Such hardware usually just increases the position at each IRQ,
+         * thus it can't give any strange position.
+         */
+        if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
+                goto no_jiffies_check;
+        hdelta = new_hw_ptr - old_hw_ptr;
+        jdelta = jiffies - runtime->hw_ptr_jiffies;
+        if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
+                delta = jdelta /
+                        (((runtime->period_size * HZ) / runtime->rate)
+                                                                + HZ/100);
+                hw_ptr_error(substream,
+                             "hw_ptr skipping! [Q] "
+                             "(pos=%ld, delta=%ld, period=%ld, "
+                             "jdelta=%lu/%lu/%lu)\n",
+                             (long)pos, (long)hdelta,
+                             (long)runtime->period_size, jdelta,
+                             ((hdelta * HZ) / runtime->rate), delta);
+                hw_ptr_interrupt = runtime->hw_ptr_interrupt +
+                                   runtime->period_size * delta;
+                if (hw_ptr_interrupt >= runtime->boundary)
+                        hw_ptr_interrupt -= runtime->boundary;
+                /* rebase to interrupt position */
+                hw_base = new_hw_ptr = hw_ptr_interrupt;
+                /* align hw_base to buffer_size */
+                hw_base -= hw_base % runtime->buffer_size;
+                delta = 0;
+        }
+ no_jiffies_check:
+        if (delta > runtime->period_size + runtime->period_size / 2) {
+                hw_ptr_error(substream,
+                             "Lost interrupts? "
+                             "(stream=%i, delta=%ld, intr_ptr=%ld)\n",
+                             substream->stream, (long)delta,
+                             (long)hw_ptr_interrupt);
+                /* rebase hw_ptr_interrupt */
+                hw_ptr_interrupt =
+                        new_hw_ptr - new_hw_ptr % runtime->period_size;
+        }
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
                 snd_pcm_playback_silence(substream, new_hw_ptr);
 
+        runtime->hw_ptr_base = hw_base;
         runtime->status->hw_ptr = new_hw_ptr;
-        runtime->hw_ptr_interrupt = new_hw_ptr - new_hw_ptr % runtime->period_size;
+        runtime->hw_ptr_jiffies = jiffies;
+        runtime->hw_ptr_interrupt = hw_ptr_interrupt;
 
         return snd_pcm_update_hw_ptr_post(substream, runtime);
 }
@@ -233,8 +306,9 @@ int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t pos;
-        snd_pcm_uframes_t old_hw_ptr, new_hw_ptr;
+        snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
         snd_pcm_sframes_t delta;
+        unsigned long jdelta;
 
         old_hw_ptr = runtime->status->hw_ptr;
         pos = snd_pcm_update_hw_ptr_pos(substream, runtime);
@@ -242,30 +316,42 @@ int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
                 xrun(substream);
                 return -EPIPE;
         }
-        new_hw_ptr = runtime->hw_ptr_base + pos;
-
-        delta = old_hw_ptr - new_hw_ptr;
-        if (delta > 0) {
-                if ((snd_pcm_uframes_t)delta < runtime->buffer_size / 2) {
-#ifdef CONFIG_SND_PCM_XRUN_DEBUG
-                        if (runtime->periods > 2 && substream->pstr->xrun_debug) {
-                                snd_printd(KERN_ERR "Unexpected hw_pointer value [2] (stream = %i, delta: -%ld, max jitter = %ld): wrong interrupt acknowledge?\n", substream->stream, (long) delta, runtime->buffer_size / 2);
-                                if (substream->pstr->xrun_debug > 1)
-                                        dump_stack();
-                        }
-#endif
+        hw_base = runtime->hw_ptr_base;
+        new_hw_ptr = hw_base + pos;
+
+        delta = new_hw_ptr - old_hw_ptr;
+        jdelta = jiffies - runtime->hw_ptr_jiffies;
+        if (delta < 0) {
+                delta += runtime->buffer_size;
+                if (delta < 0) {
+                        hw_ptr_error(substream, 
+                                     "Unexpected hw_pointer value [2] "
+                                     "(stream=%i, pos=%ld, old_ptr=%ld, jdelta=%li)\n",
+                                     substream->stream, (long)pos,
+                                     (long)old_hw_ptr, jdelta);
                         return 0;
                 }
-                runtime->hw_ptr_base += runtime->buffer_size;
-                if (runtime->hw_ptr_base == runtime->boundary)
-                        runtime->hw_ptr_base = 0;
-                new_hw_ptr = runtime->hw_ptr_base + pos;
+                hw_base += runtime->buffer_size;
+                if (hw_base >= runtime->boundary)
+                        hw_base = 0;
+                new_hw_ptr = hw_base + pos;
+        }
+        if (((delta * HZ) / runtime->rate) > jdelta + HZ/100) {
+                hw_ptr_error(substream,
+                             "hw_ptr skipping! "
+                             "(pos=%ld, delta=%ld, period=%ld, jdelta=%lu/%lu)\n",
+                             (long)pos, (long)delta,
+                             (long)runtime->period_size, jdelta,
+                             ((delta * HZ) / runtime->rate));
+                return 0;
         }
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
                 snd_pcm_playback_silence(substream, new_hw_ptr);
 
+        runtime->hw_ptr_base = hw_base;
         runtime->status->hw_ptr = new_hw_ptr;
+        runtime->hw_ptr_jiffies = jiffies;
 
         return snd_pcm_update_hw_ptr_post(substream, runtime);
 }
@@ -1392,6 +1478,7 @@ static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
                 runtime->status->hw_ptr %= runtime->buffer_size;
         else
                 runtime->status->hw_ptr = 0;
+        runtime->hw_ptr_jiffies = jiffies;
         snd_pcm_stream_unlock_irqrestore(substream, flags);
         return 0;
 }
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index a789efc9df39..fc6f98e257df 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -186,7 +186,7 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
                 if (!(params->rmask & (1 << k)))
                         continue;
 #ifdef RULES_DEBUG
-                printk("%s = ", snd_pcm_hw_param_names[k]);
+                printk(KERN_DEBUG "%s = ", snd_pcm_hw_param_names[k]);
                 printk("%04x%04x%04x%04x -> ", m->bits[3], m->bits[2], m->bits[1], m->bits[0]);
 #endif
                 changed = snd_mask_refine(m, constrs_mask(constrs, k));
@@ -206,7 +206,7 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
                 if (!(params->rmask & (1 << k)))
                         continue;
 #ifdef RULES_DEBUG
-                printk("%s = ", snd_pcm_hw_param_names[k]);
+                printk(KERN_DEBUG "%s = ", snd_pcm_hw_param_names[k]);
                 if (i->empty)
                         printk("empty");
                 else
@@ -251,7 +251,7 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
                         if (!doit)
                                 continue;
 #ifdef RULES_DEBUG
-                        printk("Rule %d [%p]: ", k, r->func);
+                        printk(KERN_DEBUG "Rule %d [%p]: ", k, r->func);
                         if (r->var >= 0) {
                                 printk("%s = ", snd_pcm_hw_param_names[r->var]);
                                 if (hw_is_mask(r->var)) {
@@ -327,21 +327,16 @@ static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params;
         int err;
 
-        params = kmalloc(sizeof(*params), GFP_KERNEL);
-        if (!params) {
-                err = -ENOMEM;
-                goto out;
-        }
-        if (copy_from_user(params, _params, sizeof(*params))) {
-                err = -EFAULT;
-                goto out;
-        }
+        params = memdup_user(_params, sizeof(*params));
+        if (IS_ERR(params))
+                return PTR_ERR(params);
+
         err = snd_pcm_hw_refine(substream, params);
         if (copy_to_user(_params, params, sizeof(*params))) {
                 if (!err)
                         err = -EFAULT;
         }
-out:
+
         kfree(params);
         return err;
 }
@@ -465,21 +460,16 @@ static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params;
         int err;
 
-        params = kmalloc(sizeof(*params), GFP_KERNEL);
-        if (!params) {
-                err = -ENOMEM;
-                goto out;
-        }
-        if (copy_from_user(params, _params, sizeof(*params))) {
-                err = -EFAULT;
-                goto out;
-        }
+        params = memdup_user(_params, sizeof(*params));
+        if (IS_ERR(params))
+                return PTR_ERR(params);
+
         err = snd_pcm_hw_params(substream, params);
         if (copy_to_user(_params, params, sizeof(*params))) {
                 if (!err)
                         err = -EFAULT;
         }
-out:
+
         kfree(params);
         return err;
 }
@@ -2593,13 +2583,11 @@ static int snd_pcm_playback_ioctl1(struct file *file,
                         return -EFAULT;
                 if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
                         return -EFAULT;
-                bufs = kmalloc(sizeof(void *) * runtime->channels, GFP_KERNEL);
-                if (bufs == NULL)
-                        return -ENOMEM;
-                if (copy_from_user(bufs, xfern.bufs, sizeof(void *) * runtime->channels)) {
-                        kfree(bufs);
-                        return -EFAULT;
-                }
+
+                bufs = memdup_user(xfern.bufs,
+                                   sizeof(void *) * runtime->channels);
+                if (IS_ERR(bufs))
+                        return PTR_ERR(bufs);
                 result = snd_pcm_lib_writev(substream, bufs, xfern.frames);
                 kfree(bufs);
                 __put_user(result, &_xfern->result);
@@ -2675,13 +2663,11 @@ static int snd_pcm_capture_ioctl1(struct file *file,
                         return -EFAULT;
                 if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
                         return -EFAULT;
-                bufs = kmalloc(sizeof(void *) * runtime->channels, GFP_KERNEL);
-                if (bufs == NULL)
-                        return -ENOMEM;
-                if (copy_from_user(bufs, xfern.bufs, sizeof(void *) * runtime->channels)) {
-                        kfree(bufs);
-                        return -EFAULT;
-                }
+
+                bufs = memdup_user(xfern.bufs,
+                                   sizeof(void *) * runtime->channels);
+                if (IS_ERR(bufs))
+                        return PTR_ERR(bufs);
                 result = snd_pcm_lib_readv(substream, bufs, xfern.frames);
                 kfree(bufs);
                 __put_user(result, &_xfern->result);
@@ -3246,9 +3232,7 @@ static int snd_pcm_fasync(int fd, struct file * file, int on)
         err = fasync_helper(fd, file, on, &runtime->fasync);
 out:
         unlock_kernel();
-        if (err < 0)
-                return err;
-        return 0;
+        return err;
 }
 
 /*
@@ -3314,18 +3298,12 @@ static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
         int err;
 
         params = kmalloc(sizeof(*params), GFP_KERNEL);
-        if (!params) {
-                err = -ENOMEM;
-                goto out;
-        }
-        oparams = kmalloc(sizeof(*oparams), GFP_KERNEL);
-        if (!oparams) {
-                err = -ENOMEM;
-                goto out;
-        }
+        if (!params)
+                return -ENOMEM;
 
-        if (copy_from_user(oparams, _oparams, sizeof(*oparams))) {
-                err = -EFAULT;
+        oparams = memdup_user(_oparams, sizeof(*oparams));
+        if (IS_ERR(oparams)) {
+                err = PTR_ERR(oparams);
                 goto out;
         }
         snd_pcm_hw_convert_from_old_params(params, oparams);
@@ -3335,9 +3313,10 @@ static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
                 if (!err)
                         err = -EFAULT;
         }
+
+        kfree(oparams);
 out:
         kfree(params);
-        kfree(oparams);
         return err;
 }
 
@@ -3349,17 +3328,12 @@ static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
         int err;
 
         params = kmalloc(sizeof(*params), GFP_KERNEL);
-        if (!params) {
-                err = -ENOMEM;
-                goto out;
-        }
-        oparams = kmalloc(sizeof(*oparams), GFP_KERNEL);
-        if (!oparams) {
-                err = -ENOMEM;
-                goto out;
-        }
-        if (copy_from_user(oparams, _oparams, sizeof(*oparams))) {
-                err = -EFAULT;
+        if (!params)
+                return -ENOMEM;
+
+        oparams = memdup_user(_oparams, sizeof(*oparams));
+        if (IS_ERR(oparams)) {
+                err = PTR_ERR(oparams);
                 goto out;
         }
         snd_pcm_hw_convert_from_old_params(params, oparams);
@@ -3369,9 +3343,10 @@ static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
                 if (!err)
                         err = -EFAULT;
         }
+
+        kfree(oparams);
 out:
         kfree(params);
-        kfree(oparams);
         return err;
 }
 #endif /* CONFIG_SND_SUPPORT_OLD_API */
diff --git a/sound/core/pcm_timer.c b/sound/core/pcm_timer.c
index 2c89c04f2916..ca8068b63d6c 100644
--- a/sound/core/pcm_timer.c
+++ b/sound/core/pcm_timer.c
@@ -85,25 +85,19 @@ static unsigned long snd_pcm_timer_resolution(struct snd_timer * timer)
 
 static int snd_pcm_timer_start(struct snd_timer * timer)
 {
-        unsigned long flags;
         struct snd_pcm_substream *substream;
         
         substream = snd_timer_chip(timer);
-        spin_lock_irqsave(&substream->timer_lock, flags);
         substream->timer_running = 1;
-        spin_unlock_irqrestore(&substream->timer_lock, flags);
         return 0;
 }
 
 static int snd_pcm_timer_stop(struct snd_timer * timer)
 {
-        unsigned long flags;
         struct snd_pcm_substream *substream;
         
         substream = snd_timer_chip(timer);
-        spin_lock_irqsave(&substream->timer_lock, flags);
         substream->timer_running = 0;
-        spin_unlock_irqrestore(&substream->timer_lock, flags);
         return 0;
 }
 
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index 002777ba336a..473247c8e6d3 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -224,156 +224,143 @@ int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream)
         return 0;
 }
 
-int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice,
-                            int mode, struct snd_rawmidi_file * rfile)
+/* look for an available substream for the given stream direction;
+ * if a specific subdevice is given, try to assign it
+ */
+static int assign_substream(struct snd_rawmidi *rmidi, int subdevice,
+                            int stream, int mode,
+                            struct snd_rawmidi_substream **sub_ret)
+{
+        struct snd_rawmidi_substream *substream;
+        struct snd_rawmidi_str *s = &rmidi->streams[stream];
+        static unsigned int info_flags[2] = {
+                [SNDRV_RAWMIDI_STREAM_OUTPUT] = SNDRV_RAWMIDI_INFO_OUTPUT,
+                [SNDRV_RAWMIDI_STREAM_INPUT] = SNDRV_RAWMIDI_INFO_INPUT,
+        };
+
+        if (!(rmidi->info_flags & info_flags[stream]))
+                return -ENXIO;
+        if (subdevice >= 0 && subdevice >= s->substream_count)
+                return -ENODEV;
+        if (s->substream_opened >= s->substream_count)
+                return -EAGAIN;
+
+        list_for_each_entry(substream, &s->substreams, list) {
+                if (substream->opened) {
+                        if (stream == SNDRV_RAWMIDI_STREAM_INPUT ||
+                            !(mode & SNDRV_RAWMIDI_LFLG_APPEND))
+                                continue;
+                }
+                if (subdevice < 0 || subdevice == substream->number) {
+                        *sub_ret = substream;
+                        return 0;
+                }
+        }
+        return -EAGAIN;
+}
+
+/* open and do ref-counting for the given substream */
+static int open_substream(struct snd_rawmidi *rmidi,
+                          struct snd_rawmidi_substream *substream,
+                          int mode)
+{
+        int err;
+
+        err = snd_rawmidi_runtime_create(substream);
+        if (err < 0)
+                return err;
+        err = substream->ops->open(substream);
+        if (err < 0)
+                return err;
+        substream->opened = 1;
+        if (substream->use_count++ == 0)
+                substream->active_sensing = 1;
+        if (mode & SNDRV_RAWMIDI_LFLG_APPEND)
+                substream->append = 1;
+        rmidi->streams[substream->stream].substream_opened++;
+        return 0;
+}
+
+static void close_substream(struct snd_rawmidi *rmidi,
+                            struct snd_rawmidi_substream *substream,
+                            int cleanup);
+
+static int rawmidi_open_priv(struct snd_rawmidi *rmidi, int subdevice, int mode,
+                             struct snd_rawmidi_file *rfile)
 {
-        struct snd_rawmidi *rmidi;
-        struct list_head *list1, *list2;
         struct snd_rawmidi_substream *sinput = NULL, *soutput = NULL;
-        struct snd_rawmidi_runtime *input = NULL, *output = NULL;
         int err;
 
-        if (rfile)
-                rfile->input = rfile->output = NULL;
-        mutex_lock(&register_mutex);
-        rmidi = snd_rawmidi_search(card, device);
-        mutex_unlock(&register_mutex);
-        if (rmidi == NULL) {
-                err = -ENODEV;
-                goto __error1;
-        }
-        if (!try_module_get(rmidi->card->module)) {
-                err = -EFAULT;
-                goto __error1;
-        }
-        if (!(mode & SNDRV_RAWMIDI_LFLG_NOOPENLOCK))
-                mutex_lock(&rmidi->open_mutex);
+        rfile->input = rfile->output = NULL;
         if (mode & SNDRV_RAWMIDI_LFLG_INPUT) {
-                if (!(rmidi->info_flags & SNDRV_RAWMIDI_INFO_INPUT)) {
-                        err = -ENXIO;
-                        goto __error;
-                }
-                if (subdevice >= 0 && (unsigned int)subdevice >= rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_count) {
-                        err = -ENODEV;
-                        goto __error;
-                }
-                if (rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_opened >=
-                    rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_count) {
-                        err = -EAGAIN;
+                err = assign_substream(rmidi, subdevice,
+                                       SNDRV_RAWMIDI_STREAM_INPUT,
+                                       mode, &sinput);
+                if (err < 0)
                         goto __error;
-                }
         }
         if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) {
-                if (!(rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT)) {
-                        err = -ENXIO;
-                        goto __error;
-                }
-                if (subdevice >= 0 && (unsigned int)subdevice >= rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_count) {
-                        err = -ENODEV;
-                        goto __error;
-                }
-                if (rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_opened >=
-                    rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_count) {
-                        err = -EAGAIN;
+                err = assign_substream(rmidi, subdevice,
+                                       SNDRV_RAWMIDI_STREAM_OUTPUT,
+                                       mode, &soutput);
+                if (err < 0)
                         goto __error;
-                }
-        }
-        list1 = rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams.next;
-        while (1) {
-                if (list1 == &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) {
-                        sinput = NULL;
-                        if (mode & SNDRV_RAWMIDI_LFLG_INPUT) {
-                                err = -EAGAIN;
-                                goto __error;
-                        }
-                        break;
-                }
-                sinput = list_entry(list1, struct snd_rawmidi_substream, list);
-                if ((mode & SNDRV_RAWMIDI_LFLG_INPUT) && sinput->opened)
-                        goto __nexti;
-                if (subdevice < 0 || (subdevice >= 0 && subdevice == sinput->number))
-                        break;
-              __nexti:
-                list1 = list1->next;
         }
-        list2 = rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams.next;
-        while (1) {
-                if (list2 == &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) {
-                        soutput = NULL;
-                        if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) {
-                                err = -EAGAIN;
-                                goto __error;
-                        }
-                        break;
-                }
-                soutput = list_entry(list2, struct snd_rawmidi_substream, list);
-                if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) {
-                        if (mode & SNDRV_RAWMIDI_LFLG_APPEND) {
-                                if (soutput->opened && !soutput->append)
-                                        goto __nexto;
-                        } else {
-                                if (soutput->opened)
-                                        goto __nexto;
-                        }
-                }
-                if (subdevice < 0 || (subdevice >= 0 && subdevice == soutput->number))
-                        break;
-              __nexto:
-                list2 = list2->next;
-        }
-        if (mode & SNDRV_RAWMIDI_LFLG_INPUT) {
-                if ((err = snd_rawmidi_runtime_create(sinput)) < 0)
-                        goto __error;
-                input = sinput->runtime;
-                if ((err = sinput->ops->open(sinput)) < 0)
+
+        if (sinput) {
+                err = open_substream(rmidi, sinput, mode);
+                if (err < 0)
                         goto __error;
-                sinput->opened = 1;
-                rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_opened++;
-        } else {
-                sinput = NULL;
         }
-        if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) {
-                if (soutput->opened)
-                        goto __skip_output;
-                if ((err = snd_rawmidi_runtime_create(soutput)) < 0) {
-                        if (mode & SNDRV_RAWMIDI_LFLG_INPUT)
-                                sinput->ops->close(sinput);
-                        goto __error;
-                }
-                output = soutput->runtime;
-                if ((err = soutput->ops->open(soutput)) < 0) {
-                        if (mode & SNDRV_RAWMIDI_LFLG_INPUT)
-                                sinput->ops->close(sinput);
+        if (soutput) {
+                err = open_substream(rmidi, soutput, mode);
+                if (err < 0) {
+                        if (sinput)
+                                close_substream(rmidi, sinput, 0);
                         goto __error;
                 }
-              __skip_output:
-                soutput->opened = 1;
-                if (mode & SNDRV_RAWMIDI_LFLG_APPEND)
-                        soutput->append = 1;
-                if (soutput->use_count++ == 0)
-                        soutput->active_sensing = 1;
-                rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_opened++;
-        } else {
-                soutput = NULL;
-        }
-        if (!(mode & SNDRV_RAWMIDI_LFLG_NOOPENLOCK))
-                mutex_unlock(&rmidi->open_mutex);
-        if (rfile) {
-                rfile->rmidi = rmidi;
-                rfile->input = sinput;
-                rfile->output = soutput;
         }
+
+        rfile->rmidi = rmidi;
+        rfile->input = sinput;
+        rfile->output = soutput;
         return 0;
 
       __error:
-        if (input != NULL)
+        if (sinput && sinput->runtime)
                 snd_rawmidi_runtime_free(sinput);
-        if (output != NULL)
+        if (soutput && soutput->runtime)
                 snd_rawmidi_runtime_free(soutput);
-        module_put(rmidi->card->module);
-        if (!(mode & SNDRV_RAWMIDI_LFLG_NOOPENLOCK))
-                mutex_unlock(&rmidi->open_mutex);
-      __error1:
+        return err;
+}
+
+/* called from sound/core/seq/seq_midi.c */
+int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice,
+                            int mode, struct snd_rawmidi_file * rfile)
+{
+        struct snd_rawmidi *rmidi;
+        int err;
+
+        if (snd_BUG_ON(!rfile))
+                return -EINVAL;
+
+        mutex_lock(&register_mutex);
+        rmidi = snd_rawmidi_search(card, device);
+        if (rmidi == NULL) {
+                mutex_unlock(&register_mutex);
+                return -ENODEV;
+        }
+        if (!try_module_get(rmidi->card->module)) {
+                mutex_unlock(&register_mutex);
+                return -ENXIO;
+        }
+        mutex_unlock(&register_mutex);
+
+        mutex_lock(&rmidi->open_mutex);
+        err = rawmidi_open_priv(rmidi, subdevice, mode, rfile);
+        mutex_unlock(&rmidi->open_mutex);
+        if (err < 0)
+                module_put(rmidi->card->module);
         return err;
 }
 
@@ -385,10 +372,13 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file)
         unsigned short fflags;
         int err;
         struct snd_rawmidi *rmidi;
-        struct snd_rawmidi_file *rawmidi_file;
+        struct snd_rawmidi_file *rawmidi_file = NULL;
         wait_queue_t wait;
         struct snd_ctl_file *kctl;
 
+        if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK)) 
+                return -EINVAL;         /* invalid combination */
+
         if (maj == snd_major) {
                 rmidi = snd_lookup_minor_data(iminor(inode),
                                               SNDRV_DEVICE_TYPE_RAWMIDI);
@@ -402,24 +392,25 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file)
 
         if (rmidi == NULL)
                 return -ENODEV;
-        if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK)) 
-                return -EINVAL;         /* invalid combination */
+
+        if (!try_module_get(rmidi->card->module))
+                return -ENXIO;
+
+        mutex_lock(&rmidi->open_mutex);
         card = rmidi->card;
         err = snd_card_file_add(card, file);
         if (err < 0)
-                return -ENODEV;
+                goto __error_card;
         fflags = snd_rawmidi_file_flags(file);
         if ((file->f_flags & O_APPEND) || maj == SOUND_MAJOR) /* OSS emul? */
                 fflags |= SNDRV_RAWMIDI_LFLG_APPEND;
-        fflags |= SNDRV_RAWMIDI_LFLG_NOOPENLOCK;
         rawmidi_file = kmalloc(sizeof(*rawmidi_file), GFP_KERNEL);
         if (rawmidi_file == NULL) {
-                snd_card_file_remove(card, file);
-                return -ENOMEM;
+                err = -ENOMEM;
+                goto __error;
         }
         init_waitqueue_entry(&wait, current);
         add_wait_queue(&rmidi->open_wait, &wait);
-        mutex_lock(&rmidi->open_mutex);
         while (1) {
                 subdevice = -1;
                 read_lock(&card->ctl_files_rwlock);
@@ -431,8 +422,7 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file)
                         }
                 }
                 read_unlock(&card->ctl_files_rwlock);
-                err = snd_rawmidi_kernel_open(rmidi->card, rmidi->device,
-                                              subdevice, fflags, rawmidi_file);
+                err = rawmidi_open_priv(rmidi, subdevice, fflags, rawmidi_file);
                 if (err >= 0)
                         break;
                 if (err == -EAGAIN) {
@@ -451,67 +441,89 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file)
                         break;
                 }
         }
+        remove_wait_queue(&rmidi->open_wait, &wait);
+        if (err < 0) {
+                kfree(rawmidi_file);
+                goto __error;
+        }
 #ifdef CONFIG_SND_OSSEMUL
         if (rawmidi_file->input && rawmidi_file->input->runtime)
                 rawmidi_file->input->runtime->oss = (maj == SOUND_MAJOR);
         if (rawmidi_file->output && rawmidi_file->output->runtime)
                 rawmidi_file->output->runtime->oss = (maj == SOUND_MAJOR);
 #endif
-        remove_wait_queue(&rmidi->open_wait, &wait);
-        if (err >= 0) {
-                file->private_data = rawmidi_file;
-        } else {
-                snd_card_file_remove(card, file);
-                kfree(rawmidi_file);
-        }
+        file->private_data = rawmidi_file;
+        mutex_unlock(&rmidi->open_mutex);
+        return 0;
+
+ __error:
+        snd_card_file_remove(card, file);
+ __error_card:
         mutex_unlock(&rmidi->open_mutex);
+        module_put(rmidi->card->module);
         return err;
 }
 
-int snd_rawmidi_kernel_release(struct snd_rawmidi_file * rfile)
+static void close_substream(struct snd_rawmidi *rmidi,
+                            struct snd_rawmidi_substream *substream,
+                            int cleanup)
 {
-        struct snd_rawmidi *rmidi;
-        struct snd_rawmidi_substream *substream;
-        struct snd_rawmidi_runtime *runtime;
+        rmidi->streams[substream->stream].substream_opened--;
+        if (--substream->use_count)
+                return;
 
-        if (snd_BUG_ON(!rfile))
-                return -ENXIO;
-        rmidi = rfile->rmidi;
-        mutex_lock(&rmidi->open_mutex);
-        if (rfile->input != NULL) {
-                substream = rfile->input;
-                rfile->input = NULL;
-                runtime = substream->runtime;
-                snd_rawmidi_input_trigger(substream, 0);
-                substream->ops->close(substream);
-                if (runtime->private_free != NULL)
-                        runtime->private_free(substream);
-                snd_rawmidi_runtime_free(substream);
-                substream->opened = 0;
-                rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_opened--;
-        }
-        if (rfile->output != NULL) {
-                substream = rfile->output;
-                rfile->output = NULL;
-                if (--substream->use_count == 0) {
-                        runtime = substream->runtime;
+        if (cleanup) {
+                if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT)
+                        snd_rawmidi_input_trigger(substream, 0);
+                else {
                         if (substream->active_sensing) {
                                 unsigned char buf = 0xfe;
-                                /* sending single active sensing message to shut the device up */
+                                /* sending single active sensing message
+                                 * to shut the device up
+                                 */
                                 snd_rawmidi_kernel_write(substream, &buf, 1);
                         }
                         if (snd_rawmidi_drain_output(substream) == -ERESTARTSYS)
                                 snd_rawmidi_output_trigger(substream, 0);
-                        substream->ops->close(substream);
-                        if (runtime->private_free != NULL)
-                                runtime->private_free(substream);
-                        snd_rawmidi_runtime_free(substream);
-                        substream->opened = 0;
-                        substream->append = 0;
                 }
-                rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_opened--;
         }
+        substream->ops->close(substream);
+        if (substream->runtime->private_free)
+                substream->runtime->private_free(substream);
+        snd_rawmidi_runtime_free(substream);
+        substream->opened = 0;
+        substream->append = 0;
+}
+
+static void rawmidi_release_priv(struct snd_rawmidi_file *rfile)
+{
+        struct snd_rawmidi *rmidi;
+
+        rmidi = rfile->rmidi;
+        mutex_lock(&rmidi->open_mutex);
+        if (rfile->input) {
+                close_substream(rmidi, rfile->input, 1);
+                rfile->input = NULL;
+        }
+        if (rfile->output) {
+                close_substream(rmidi, rfile->output, 1);
+                rfile->output = NULL;
+        }
+        rfile->rmidi = NULL;
         mutex_unlock(&rmidi->open_mutex);
+        wake_up(&rmidi->open_wait);
+}
+
+/* called from sound/core/seq/seq_midi.c */
+int snd_rawmidi_kernel_release(struct snd_rawmidi_file *rfile)
+{
+        struct snd_rawmidi *rmidi;
+
+        if (snd_BUG_ON(!rfile))
+                return -ENXIO;
+        
+        rmidi = rfile->rmidi;
+        rawmidi_release_priv(rfile);
         module_put(rmidi->card->module);
         return 0;
 }
@@ -520,15 +532,14 @@ static int snd_rawmidi_release(struct inode *inode, struct file *file)
 {
         struct snd_rawmidi_file *rfile;
         struct snd_rawmidi *rmidi;
-        int err;
 
         rfile = file->private_data;
-        err = snd_rawmidi_kernel_release(rfile);
         rmidi = rfile->rmidi;
-        wake_up(&rmidi->open_wait);
+        rawmidi_release_priv(rfile);
         kfree(rfile);
         snd_card_file_remove(rmidi->card, file);
-        return err;
+        module_put(rmidi->card->module);
+        return 0;
 }
 
 static int snd_rawmidi_info(struct snd_rawmidi_substream *substream,
diff --git a/sound/core/seq/oss/seq_oss_device.h b/sound/core/seq/oss/seq_oss_device.h
index bf8d2b4cb15e..c0154a959d55 100644
--- a/sound/core/seq/oss/seq_oss_device.h
+++ b/sound/core/seq/oss/seq_oss_device.h
@@ -181,7 +181,7 @@ char *enabled_str(int bool);
 /* for debug */
 #ifdef SNDRV_SEQ_OSS_DEBUG
 extern int seq_oss_debug;
-#define debug_printk(x) do { if (seq_oss_debug > 0) snd_printk x; } while (0)
+#define debug_printk(x) do { if (seq_oss_debug > 0) snd_printd x; } while (0)
 #else
 #define debug_printk(x) /**/
 #endif
diff --git a/sound/core/seq/seq_compat.c b/sound/core/seq/seq_compat.c
index 38693f47c262..c956fe462569 100644
--- a/sound/core/seq/seq_compat.c
+++ b/sound/core/seq/seq_compat.c
@@ -48,12 +48,11 @@ static int snd_seq_call_port_info_ioctl(struct snd_seq_client *client, unsigned
         struct snd_seq_port_info *data;
         mm_segment_t fs;
 
-        data = kmalloc(sizeof(*data), GFP_KERNEL);
-        if (! data)
-                return -ENOMEM;
+        data = memdup_user(data32, sizeof(*data32));
+        if (IS_ERR(data))
+                return PTR_ERR(data);
 
-        if (copy_from_user(data, data32, sizeof(*data32)) ||
-            get_user(data->flags, &data32->flags) ||
+        if (get_user(data->flags, &data32->flags) ||
             get_user(data->time_queue, &data32->time_queue))
                 goto error;
         data->kernel = NULL;
diff --git a/sound/core/seq/seq_prioq.c b/sound/core/seq/seq_prioq.c
index 0101a8b99b73..29896ab23403 100644
--- a/sound/core/seq/seq_prioq.c
+++ b/sound/core/seq/seq_prioq.c
@@ -321,7 +321,8 @@ void snd_seq_prioq_leave(struct snd_seq_prioq * f, int client, int timestamp)
                         freeprev = cell;
                 } else {
 #if 0
-                        printk("type = %i, source = %i, dest = %i, client = %i\n",
+                        printk(KERN_DEBUG "type = %i, source = %i, dest = %i, "
+                               "client = %i\n",
                                 cell->event.type,
                                 cell->event.source.client,
                                 cell->event.dest.client,
diff --git a/sound/core/sgbuf.c b/sound/core/sgbuf.c
index d4564edd61d7..4e7ec2b49873 100644
--- a/sound/core/sgbuf.c
+++ b/sound/core/sgbuf.c
@@ -38,6 +38,10 @@ int snd_free_sgbuf_pages(struct snd_dma_buffer *dmab)
         if (! sgbuf)
                 return -EINVAL;
 
+        if (dmab->area)
+                vunmap(dmab->area);
+        dmab->area = NULL;
+
         tmpb.dev.type = SNDRV_DMA_TYPE_DEV;
         tmpb.dev.dev = sgbuf->dev;
         for (i = 0; i < sgbuf->pages; i++) {
@@ -48,9 +52,6 @@ int snd_free_sgbuf_pages(struct snd_dma_buffer *dmab)
                 tmpb.bytes = (sgbuf->table[i].addr & ~PAGE_MASK) << PAGE_SHIFT;
                 snd_dma_free_pages(&tmpb);
         }
-        if (dmab->area)
-                vunmap(dmab->area);
-        dmab->area = NULL;
 
         kfree(sgbuf->table);
         kfree(sgbuf->page_table);
diff --git a/sound/core/timer.c b/sound/core/timer.c
index 796532081e81..8f8b17ac074d 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -1395,13 +1395,10 @@ static int snd_timer_user_ginfo(struct file *file,
         struct list_head *p;
         int err = 0;
 
-        ginfo = kmalloc(sizeof(*ginfo), GFP_KERNEL);
-        if (! ginfo)
-                return -ENOMEM;
-        if (copy_from_user(ginfo, _ginfo, sizeof(*ginfo))) {
-                kfree(ginfo);
-                return -EFAULT;
-        }
+        ginfo = memdup_user(_ginfo, sizeof(*ginfo));
+        if (IS_ERR(ginfo))
+                return PTR_ERR(ginfo);
+
         tid = ginfo->tid;
         memset(ginfo, 0, sizeof(*ginfo));
         ginfo->tid = tid;
@@ -1825,13 +1822,9 @@ static long snd_timer_user_ioctl(struct file *file, unsigned int cmd,
 static int snd_timer_user_fasync(int fd, struct file * file, int on)
 {
         struct snd_timer_user *tu;
-        int err;
 
         tu = file->private_data;
-        err = fasync_helper(fd, file, on, &tu->fasync);
-        if (err < 0)
-                return err;
-        return 0;
+        return fasync_helper(fd, file, on, &tu->fasync);
 }
 
 static ssize_t snd_timer_user_read(struct file *file, char __user *buffer,
diff --git a/sound/core/vmaster.c b/sound/core/vmaster.c
index 4cc57f902e2c..257624bd1997 100644
--- a/sound/core/vmaster.c
+++ b/sound/core/vmaster.c
@@ -50,18 +50,38 @@ struct link_slave {
         struct link_master *master;
         struct link_ctl_info info;
         int vals[2];            /* current values */
+        unsigned int flags;
         struct snd_kcontrol slave; /* the copy of original control entry */
 };
 
+static int slave_update(struct link_slave *slave)
+{
+        struct snd_ctl_elem_value *uctl;
+        int err, ch;
+
+        uctl = kmalloc(sizeof(*uctl), GFP_KERNEL);
+        if (!uctl)
+                return -ENOMEM;
+        uctl->id = slave->slave.id;
+        err = slave->slave.get(&slave->slave, uctl);
+        for (ch = 0; ch < slave->info.count; ch++)
+                slave->vals[ch] = uctl->value.integer.value[ch];
+        kfree(uctl);
+        return 0;
+}
+
 /* get the slave ctl info and save the initial values */
 static int slave_init(struct link_slave *slave)
 {
         struct snd_ctl_elem_info *uinfo;
-        struct snd_ctl_elem_value *uctl;
-        int err, ch;
+        int err;
 
-        if (slave->info.count)
-                return 0; /* already initialized */
+        if (slave->info.count) {
+                /* already initialized */
+                if (slave->flags & SND_CTL_SLAVE_NEED_UPDATE)
+                        return slave_update(slave);
+                return 0;
+        }
 
         uinfo = kmalloc(sizeof(*uinfo), GFP_KERNEL);
         if (!uinfo)
@@ -85,15 +105,7 @@ static int slave_init(struct link_slave *slave)
         slave->info.max_val = uinfo->value.integer.max;
         kfree(uinfo);
 
-        uctl = kmalloc(sizeof(*uctl), GFP_KERNEL);
-        if (!uctl)
-                return -ENOMEM;
-        uctl->id = slave->slave.id;
-        err = slave->slave.get(&slave->slave, uctl);
-        for (ch = 0; ch < slave->info.count; ch++)
-                slave->vals[ch] = uctl->value.integer.value[ch];
-        kfree(uctl);
-        return 0;
+        return slave_update(slave);
 }
 
 /* initialize master volume */
@@ -229,7 +241,8 @@ static void slave_free(struct snd_kcontrol *kcontrol)
  * - logarithmic volume control (dB level), no linear volume
  * - master can only attenuate the volume, no gain
  */
-int snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave)
+int _snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave,
+                       unsigned int flags)
 {
         struct link_master *master_link = snd_kcontrol_chip(master);
         struct link_slave *srec;
@@ -241,6 +254,7 @@ int snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave)
         srec->slave = *slave;
         memcpy(srec->slave.vd, slave->vd, slave->count * sizeof(*slave->vd));
         srec->master = master_link;
+        srec->flags = flags;
 
         /* override callbacks */
         slave->info = slave_info;
@@ -254,8 +268,7 @@ int snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave)
         list_add_tail(&srec->list, &master_link->slaves);
         return 0;
 }
-
-EXPORT_SYMBOL(snd_ctl_add_slave);
+EXPORT_SYMBOL(_snd_ctl_add_slave);
 
 /*
  * ctl callbacks for master controls
@@ -327,8 +340,20 @@ static void master_free(struct snd_kcontrol *kcontrol)
 }
 
 
-/*
- * Create a virtual master control with the given name
+/**
+ * snd_ctl_make_virtual_master - Create a virtual master control
+ * @name: name string of the control element to create
+ * @tlv: optional TLV int array for dB information
+ *
+ * Creates a virtual matster control with the given name string.
+ * Returns the created control element, or NULL for errors (ENOMEM).
+ *
+ * After creating a vmaster element, you can add the slave controls
+ * via snd_ctl_add_slave() or snd_ctl_add_slave_uncached().
+ *
+ * The optional argument @tlv can be used to specify the TLV information
+ * for dB scale of the master control.  It should be a single element
+ * with #SNDRV_CTL_TLVT_DB_SCALE type, and should be the max 0dB.
  */
 struct snd_kcontrol *snd_ctl_make_virtual_master(char *name,
                                                  const unsigned int *tlv)
@@ -367,5 +392,4 @@ struct snd_kcontrol *snd_ctl_make_virtual_master(char *name,
 
         return kctl;
 }
-
 EXPORT_SYMBOL(snd_ctl_make_virtual_master);
diff --git a/sound/drivers/Kconfig b/sound/drivers/Kconfig
index 0bcf14640fde..84714a65e5c8 100644
--- a/sound/drivers/Kconfig
+++ b/sound/drivers/Kconfig
@@ -33,7 +33,7 @@ if SND_DRIVERS
 
 config SND_PCSP
         tristate "PC-Speaker support (READ HELP!)"
-        depends on PCSPKR_PLATFORM && X86_PC && HIGH_RES_TIMERS
+        depends on PCSPKR_PLATFORM && X86 && HIGH_RES_TIMERS
         depends on INPUT
         depends on EXPERIMENTAL
         select SND_PCM
diff --git a/sound/drivers/mtpav.c b/sound/drivers/mtpav.c
index c3e9833dcfd9..2f8f295d6b0c 100644
--- a/sound/drivers/mtpav.c
+++ b/sound/drivers/mtpav.c
@@ -303,8 +303,10 @@ static void snd_mtpav_output_port_write(struct mtpav *mtp_card,
 
                 snd_mtpav_send_byte(mtp_card, 0xf5);
                 snd_mtpav_send_byte(mtp_card, portp->hwport);
-                //snd_printk("new outport: 0x%x\n", (unsigned int) portp->hwport);
-
+                /*
+                snd_printk(KERN_DEBUG "new outport: 0x%x\n",
+                           (unsigned int) portp->hwport);
+                */
                 if (!(outbyte & 0x80) && portp->running_status)
                         snd_mtpav_send_byte(mtp_card, portp->running_status);
         }
@@ -540,7 +542,7 @@ static void snd_mtpav_read_bytes(struct mtpav *mcrd)
 
         u8 sbyt = snd_mtpav_getreg(mcrd, SREG);
 
-        //printk("snd_mtpav_read_bytes() sbyt: 0x%x\n", sbyt);
+        /* printk(KERN_DEBUG "snd_mtpav_read_bytes() sbyt: 0x%x\n", sbyt); */
 
         if (!(sbyt & SIGS_BYTE))
                 return;
@@ -585,12 +587,12 @@ static irqreturn_t snd_mtpav_irqh(int irq, void *dev_id)
 static int __devinit snd_mtpav_get_ISA(struct mtpav * mcard)
 {
         if ((mcard->res_port = request_region(port, 3, "MotuMTPAV MIDI")) == NULL) {
-                snd_printk("MTVAP port 0x%lx is busy\n", port);
+                snd_printk(KERN_ERR "MTVAP port 0x%lx is busy\n", port);
                 return -EBUSY;
         }
         mcard->port = port;
         if (request_irq(irq, snd_mtpav_irqh, IRQF_DISABLED, "MOTU MTPAV", mcard)) {
-                snd_printk("MTVAP IRQ %d busy\n", irq);
+                snd_printk(KERN_ERR "MTVAP IRQ %d busy\n", irq);
                 return -EBUSY;
         }
         mcard->irq = irq;
@@ -706,7 +708,6 @@ static int __devinit snd_mtpav_probe(struct platform_device *dev)
         mtp_card->card = card;
         mtp_card->irq = -1;
         mtp_card->share_irq = 0;
-        mtp_card->inmidiport = 0xffffffff;
         mtp_card->inmidistate = 0;
         mtp_card->outmidihwport = 0xffffffff;
         init_timer(&mtp_card->timer);
@@ -719,6 +720,8 @@ static int __devinit snd_mtpav_probe(struct platform_device *dev)
         if (err < 0)
                 goto __error;
 
+        mtp_card->inmidiport = mtp_card->num_ports + MTPAV_PIDX_BROADCAST;
+
         err = snd_mtpav_get_ISA(mtp_card);
         if (err < 0)
                 goto __error;
diff --git a/sound/drivers/mts64.c b/sound/drivers/mts64.c
index 33d9db782e07..9284829bf927 100644
--- a/sound/drivers/mts64.c
+++ b/sound/drivers/mts64.c
@@ -1015,7 +1015,7 @@ static int __devinit snd_mts64_probe(struct platform_device *pdev)
                 goto __err;
         }
 
-        snd_printk("ESI Miditerminal 4140 on 0x%lx\n", p->base);
+        snd_printk(KERN_INFO "ESI Miditerminal 4140 on 0x%lx\n", p->base);
         return 0;
 
 __err:
diff --git a/sound/drivers/opl3/opl3_lib.c b/sound/drivers/opl3/opl3_lib.c
index 780582340fef..6e31e46ca393 100644
--- a/sound/drivers/opl3/opl3_lib.c
+++ b/sound/drivers/opl3/opl3_lib.c
@@ -302,7 +302,7 @@ void snd_opl3_interrupt(struct snd_hwdep * hw)
         opl3 = hw->private_data;
         status = inb(opl3->l_port);
 #if 0
-        snd_printk("AdLib IRQ status = 0x%x\n", status);
+        snd_printk(KERN_DEBUG "AdLib IRQ status = 0x%x\n", status);
 #endif
         if (!(status & 0x80))
                 return;
diff --git a/sound/drivers/opl3/opl3_midi.c b/sound/drivers/opl3/opl3_midi.c
index 16feafa2c51e..6e7d09ae0e82 100644
--- a/sound/drivers/opl3/opl3_midi.c
+++ b/sound/drivers/opl3/opl3_midi.c
@@ -125,7 +125,7 @@ static void debug_alloc(struct snd_opl3 *opl3, char *s, int voice) {
         int i;
         char *str = "x.24";
 
-        printk("time %.5i: %s [%.2i]: ", opl3->use_time, s, voice);
+        printk(KERN_DEBUG "time %.5i: %s [%.2i]: ", opl3->use_time, s, voice);
         for (i = 0; i < opl3->max_voices; i++)
                 printk("%c", *(str + opl3->voices[i].state + 1));
         printk("\n");
@@ -218,7 +218,7 @@ static int opl3_get_voice(struct snd_opl3 *opl3, int instr_4op,
         for (i = 0; i < END; i++) {
                 if (best[i].voice >= 0) {
 #ifdef DEBUG_ALLOC
-                        printk("%s %iop allocation on voice %i\n",
+                        printk(KERN_DEBUG "%s %iop allocation on voice %i\n",
                                alloc_type[i], instr_4op ? 4 : 2,
                                best[i].voice);
 #endif
@@ -317,7 +317,7 @@ void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan)
         opl3 = p;
 
 #ifdef DEBUG_MIDI
-        snd_printk("Note on, ch %i, inst %i, note %i, vel %i\n",
+        snd_printk(KERN_DEBUG "Note on, ch %i, inst %i, note %i, vel %i\n",
                    chan->number, chan->midi_program, note, vel);
 #endif
 
@@ -372,7 +372,7 @@ void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan)
                 return;
         }
 #ifdef DEBUG_MIDI
-        snd_printk("  --> OPL%i instrument: %s\n",
+        snd_printk(KERN_DEBUG "  --> OPL%i instrument: %s\n",
                    instr_4op ? 3 : 2, patch->name);
 #endif
         /* in SYNTH mode, application takes care of voices */
@@ -431,7 +431,7 @@ void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan)
         }
 
 #ifdef DEBUG_MIDI
-        snd_printk("  --> setting OPL3 connection: 0x%x\n",
+        snd_printk(KERN_DEBUG "  --> setting OPL3 connection: 0x%x\n",
                    opl3->connection_reg);
 #endif
         /*
@@ -466,7 +466,7 @@ void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan)
         /* Program the FM voice characteristics */
         for (i = 0; i < (instr_4op ? 4 : 2); i++) {
 #ifdef DEBUG_MIDI
-                snd_printk("  --> programming operator %i\n", i);
+                snd_printk(KERN_DEBUG "  --> programming operator %i\n", i);
 #endif
                 op_offset = snd_opl3_regmap[voice_offset][i];
 
@@ -546,7 +546,7 @@ void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan)
         blocknum |= OPL3_KEYON_BIT;
 
 #ifdef DEBUG_MIDI
-        snd_printk("  --> trigger voice %i\n", voice);
+        snd_printk(KERN_DEBUG "  --> trigger voice %i\n", voice);
 #endif
         /* Set OPL3 KEYON_BLOCK register of requested voice */ 
         opl3_reg = reg_side | (OPL3_REG_KEYON_BLOCK + voice_offset);
@@ -602,7 +602,7 @@ void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan)
                         prg = extra_prg - 1;
                 }
 #ifdef DEBUG_MIDI
-                snd_printk(" *** allocating extra program\n");
+                snd_printk(KERN_DEBUG " *** allocating extra program\n");
 #endif
                 goto __extra_prg;
         }
@@ -633,7 +633,7 @@ static void snd_opl3_kill_voice(struct snd_opl3 *opl3, int voice)
 
         /* kill voice */
 #ifdef DEBUG_MIDI
-        snd_printk("  --> kill voice %i\n", voice);
+        snd_printk(KERN_DEBUG "  --> kill voice %i\n", voice);
 #endif
         opl3_reg = reg_side | (OPL3_REG_KEYON_BLOCK + voice_offset);
         /* clear Key ON bit */
@@ -670,7 +670,7 @@ void snd_opl3_note_off(void *p, int note, int vel, struct snd_midi_channel *chan
         opl3 = p;
 
 #ifdef DEBUG_MIDI
-        snd_printk("Note off, ch %i, inst %i, note %i\n",
+        snd_printk(KERN_DEBUG "Note off, ch %i, inst %i, note %i\n",
                    chan->number, chan->midi_program, note);
 #endif
 
@@ -709,7 +709,7 @@ void snd_opl3_key_press(void *p, int note, int vel, struct snd_midi_channel *cha
 
         opl3 = p;
 #ifdef DEBUG_MIDI
-        snd_printk("Key pressure, ch#: %i, inst#: %i\n",
+        snd_printk(KERN_DEBUG "Key pressure, ch#: %i, inst#: %i\n",
                    chan->number, chan->midi_program);
 #endif
 }
@@ -723,7 +723,7 @@ void snd_opl3_terminate_note(void *p, int note, struct snd_midi_channel *chan)
 
         opl3 = p;
 #ifdef DEBUG_MIDI
-        snd_printk("Terminate note, ch#: %i, inst#: %i\n",
+        snd_printk(KERN_DEBUG "Terminate note, ch#: %i, inst#: %i\n",
                    chan->number, chan->midi_program);
 #endif
 }
@@ -812,7 +812,7 @@ void snd_opl3_control(void *p, int type, struct snd_midi_channel *chan)
 
         opl3 = p;
 #ifdef DEBUG_MIDI
-        snd_printk("Controller, TYPE = %i, ch#: %i, inst#: %i\n",
+        snd_printk(KERN_DEBUG "Controller, TYPE = %i, ch#: %i, inst#: %i\n",
                    type, chan->number, chan->midi_program);
 #endif
 
@@ -849,7 +849,7 @@ void snd_opl3_nrpn(void *p, struct snd_midi_channel *chan,
 
         opl3 = p;
 #ifdef DEBUG_MIDI
-        snd_printk("NRPN, ch#: %i, inst#: %i\n",
+        snd_printk(KERN_DEBUG "NRPN, ch#: %i, inst#: %i\n",
                    chan->number, chan->midi_program);
 #endif
 }
@@ -864,6 +864,6 @@ void snd_opl3_sysex(void *p, unsigned char *buf, int len,
 
         opl3 = p;
 #ifdef DEBUG_MIDI
-        snd_printk("SYSEX\n");
+        snd_printk(KERN_DEBUG "SYSEX\n");
 #endif
 }
diff --git a/sound/drivers/opl3/opl3_oss.c b/sound/drivers/opl3/opl3_oss.c
index 9a2271dc046a..a54b1dc5cc78 100644
--- a/sound/drivers/opl3/opl3_oss.c
+++ b/sound/drivers/opl3/opl3_oss.c
@@ -220,14 +220,14 @@ static int snd_opl3_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format,
                 return -EINVAL;
 
         if (count < (int)sizeof(sbi)) {
-                snd_printk("FM Error: Patch record too short\n");
+                snd_printk(KERN_ERR "FM Error: Patch record too short\n");
                 return -EINVAL;
         }
         if (copy_from_user(&sbi, buf, sizeof(sbi)))
                 return -EFAULT;
 
         if (sbi.channel < 0 || sbi.channel >= SBFM_MAXINSTR) {
-                snd_printk("FM Error: Invalid instrument number %d\n",
+                snd_printk(KERN_ERR "FM Error: Invalid instrument number %d\n",
                            sbi.channel);
                 return -EINVAL;
         }
@@ -254,7 +254,9 @@ static int snd_opl3_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd,
         opl3 = arg->private_data;
         switch (cmd) {
                 case SNDCTL_FM_LOAD_INSTR:
-                        snd_printk("OPL3: Obsolete ioctl(SNDCTL_FM_LOAD_INSTR) used. Fix the program.\n");
+                        snd_printk(KERN_ERR "OPL3: "
+                                   "Obsolete ioctl(SNDCTL_FM_LOAD_INSTR) used. "
+                                   "Fix the program.\n");
                         return -EINVAL;
 
                 case SNDCTL_SYNTH_MEMAVL:
diff --git a/sound/drivers/opl3/opl3_synth.c b/sound/drivers/opl3/opl3_synth.c
index 962bb9c8b9c8..6d57b6441dec 100644
--- a/sound/drivers/opl3/opl3_synth.c
+++ b/sound/drivers/opl3/opl3_synth.c
@@ -168,7 +168,7 @@ int snd_opl3_ioctl(struct snd_hwdep * hw, struct file *file,
 
 #ifdef CONFIG_SND_DEBUG
         default:
-                snd_printk("unknown IOCTL: 0x%x\n", cmd);
+                snd_printk(KERN_WARNING "unknown IOCTL: 0x%x\n", cmd);
 #endif
         }
         return -ENOTTY;
diff --git a/sound/drivers/pcsp/pcsp.c b/sound/drivers/pcsp/pcsp.c
index aa2ae07a76d5..b60cef257b58 100644
--- a/sound/drivers/pcsp/pcsp.c
+++ b/sound/drivers/pcsp/pcsp.c
@@ -57,7 +57,7 @@ static int __devinit snd_pcsp_create(struct snd_card *card)
         else
                 min_div = MAX_DIV;
 #if PCSP_DEBUG
-        printk("PCSP: lpj=%li, min_div=%i, res=%li\n",
+        printk(KERN_DEBUG "PCSP: lpj=%li, min_div=%i, res=%li\n",
                loops_per_jiffy, min_div, tp.tv_nsec);
 #endif
 
diff --git a/sound/drivers/serial-u16550.c b/sound/drivers/serial-u16550.c
index 891d081e4825..b2b6d50c9425 100644
--- a/sound/drivers/serial-u16550.c
+++ b/sound/drivers/serial-u16550.c
@@ -241,7 +241,8 @@ static void snd_uart16550_io_loop(struct snd_uart16550 * uart)
                         snd_rawmidi_receive(uart->midi_input[substream], &c, 1);
 
                 if (status & UART_LSR_OE)
-                        snd_printk("%s: Overrun on device at 0x%lx\n",
+                        snd_printk(KERN_WARNING
+                                   "%s: Overrun on device at 0x%lx\n",
                                uart->rmidi->name, uart->base);
         }
 
@@ -636,7 +637,8 @@ static int snd_uart16550_output_byte(struct snd_uart16550 *uart,
                 }
         } else {
                 if (!snd_uart16550_write_buffer(uart, midi_byte)) {
-                        snd_printk("%s: Buffer overrun on device at 0x%lx\n",
+                        snd_printk(KERN_WARNING
+                                   "%s: Buffer overrun on device at 0x%lx\n",
                                    uart->rmidi->name, uart->base);
                         return 0;
                 }
@@ -815,7 +817,8 @@ static int __devinit snd_uart16550_create(struct snd_card *card,
         if (irq >= 0 && irq != SNDRV_AUTO_IRQ) {
                 if (request_irq(irq, snd_uart16550_interrupt,
                                 IRQF_DISABLED, "Serial MIDI", uart)) {
-                        snd_printk("irq %d busy. Using Polling.\n", irq);
+                        snd_printk(KERN_WARNING
+                                   "irq %d busy. Using Polling.\n", irq);
                 } else {
                         uart->irq = irq;
                 }
@@ -919,19 +922,22 @@ static int __devinit snd_serial_probe(struct platform_device *devptr)
         case SNDRV_SERIAL_GENERIC:
                 break;
         default:
-                snd_printk("Adaptor type is out of range 0-%d (%d)\n",
+                snd_printk(KERN_ERR
+                           "Adaptor type is out of range 0-%d (%d)\n",
                            SNDRV_SERIAL_MAX_ADAPTOR, adaptor[dev]);
                 return -ENODEV;
         }
 
         if (outs[dev] < 1 || outs[dev] > SNDRV_SERIAL_MAX_OUTS) {
-                snd_printk("Count of outputs is out of range 1-%d (%d)\n",
+                snd_printk(KERN_ERR
+                           "Count of outputs is out of range 1-%d (%d)\n",
                            SNDRV_SERIAL_MAX_OUTS, outs[dev]);
                 return -ENODEV;
         }
 
         if (ins[dev] < 1 || ins[dev] > SNDRV_SERIAL_MAX_INS) {
-                snd_printk("Count of inputs is out of range 1-%d (%d)\n",
+                snd_printk(KERN_ERR
+                           "Count of inputs is out of range 1-%d (%d)\n",
                            SNDRV_SERIAL_MAX_INS, ins[dev]);
                 return -ENODEV;
         }
diff --git a/sound/drivers/virmidi.c b/sound/drivers/virmidi.c
index 6f48711818f3..0e631c3221e3 100644
--- a/sound/drivers/virmidi.c
+++ b/sound/drivers/virmidi.c
@@ -98,7 +98,9 @@ static int __devinit snd_virmidi_probe(struct platform_device *devptr)
         vmidi->card = card;
 
         if (midi_devs[dev] > MAX_MIDI_DEVICES) {
-                snd_printk("too much midi devices for virmidi %d: force to use %d\n", dev, MAX_MIDI_DEVICES);
+                snd_printk(KERN_WARNING
+                           "too much midi devices for virmidi %d: "
+                           "force to use %d\n", dev, MAX_MIDI_DEVICES);
                 midi_devs[dev] = MAX_MIDI_DEVICES;
         }
         for (idx = 0; idx < midi_devs[dev]; idx++) {
diff --git a/sound/drivers/vx/vx_core.c b/sound/drivers/vx/vx_core.c
index 14e3354be43a..19c6e376c7c7 100644
--- a/sound/drivers/vx/vx_core.c
+++ b/sound/drivers/vx/vx_core.c
@@ -688,7 +688,8 @@ int snd_vx_dsp_load(struct vx_core *chip, const struct firmware *dsp)
                 image = dsp->data + i;
                 /* Wait DSP ready for a new read */
                 if ((err = vx_wait_isr_bit(chip, ISR_TX_EMPTY)) < 0) {
-                        printk("dsp loading error at position %d\n", i);
+                        printk(KERN_ERR
+                               "dsp loading error at position %d\n", i);
                         return err;
                 }
                 cptr = image;
diff --git a/sound/drivers/vx/vx_hwdep.c b/sound/drivers/vx/vx_hwdep.c
index 8d6362e2d4c9..46df8817c18f 100644
--- a/sound/drivers/vx/vx_hwdep.c
+++ b/sound/drivers/vx/vx_hwdep.c
@@ -119,16 +119,6 @@ void snd_vx_free_firmware(struct vx_core *chip)
 
 #else /* old style firmware loading */
 
-static int vx_hwdep_open(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
-static int vx_hwdep_release(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
 static int vx_hwdep_dsp_status(struct snd_hwdep *hw,
                                struct snd_hwdep_dsp_status *info)
 {
@@ -243,8 +233,6 @@ int snd_vx_setup_firmware(struct vx_core *chip)
 
         hw->iface = SNDRV_HWDEP_IFACE_VX;
         hw->private_data = chip;
-        hw->ops.open = vx_hwdep_open;
-        hw->ops.release = vx_hwdep_release;
         hw->ops.dsp_status = vx_hwdep_dsp_status;
         hw->ops.dsp_load = vx_hwdep_dsp_load;
         hw->exclusive = 1;
diff --git a/sound/drivers/vx/vx_uer.c b/sound/drivers/vx/vx_uer.c
index 0e1ba9b47904..b0560fec6bba 100644
--- a/sound/drivers/vx/vx_uer.c
+++ b/sound/drivers/vx/vx_uer.c
@@ -103,7 +103,7 @@ static void vx_write_one_cbit(struct vx_core *chip, int index, int val)
  * returns the frequency of UER, or 0 if not sync,
  * or a negative error code.
  */
-static int vx_read_uer_status(struct vx_core *chip, int *mode)
+static int vx_read_uer_status(struct vx_core *chip, unsigned int *mode)
 {
         int val, freq;
 
diff --git a/sound/i2c/Makefile b/sound/i2c/Makefile
index 37970666a453..36879bf88700 100644
--- a/sound/i2c/Makefile
+++ b/sound/i2c/Makefile
@@ -7,8 +7,6 @@ snd-i2c-objs := i2c.o
 snd-cs8427-objs := cs8427.o
 snd-tea6330t-objs := tea6330t.o
 
-obj-$(CONFIG_L3) += l3/
-
 obj-$(CONFIG_SND) += other/
 
 # Toplevel Module Dependency
diff --git a/sound/i2c/l3/Makefile b/sound/i2c/l3/Makefile
deleted file mode 100644
index 49455b8dcc04..000000000000
--- a/sound/i2c/l3/Makefile
+++ /dev/null
@@ -1,8 +0,0 @@
-#
-# Makefile for ALSA
-#
-
-snd-uda1341-objs := uda1341.o
-
-# Module Dependency
-obj-$(CONFIG_SND_SA11XX_UDA1341) += snd-uda1341.o
diff --git a/sound/i2c/l3/uda1341.c b/sound/i2c/l3/uda1341.c
deleted file mode 100644
index 9840eb43648d..000000000000
--- a/sound/i2c/l3/uda1341.c
+++ /dev/null
@@ -1,935 +0,0 @@
-/*
- * Philips UDA1341 mixer device driver
- * Copyright (c) 2002 Tomas Kasparek <tomas.kasparek@seznam.cz>
- *
- * Portions are Copyright (C) 2000 Lernout & Hauspie Speech Products, N.V.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License.
- *
- * History:
- *
- * 2002-03-13   Tomas Kasparek  initial release - based on uda1341.c from OSS
- * 2002-03-28   Tomas Kasparek  basic mixer is working (volume, bass, treble)
- * 2002-03-30   Tomas Kasparek  proc filesystem support, complete mixer and DSP
- *                              features support
- * 2002-04-12   Tomas Kasparek  proc interface update, code cleanup
- * 2002-05-12   Tomas Kasparek  another code cleanup
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/types.h>
-#include <linux/slab.h>
-#include <linux/errno.h>
-#include <linux/ioctl.h>
-
-#include <asm/uaccess.h>
-
-#include <sound/core.h>
-#include <sound/control.h>
-#include <sound/initval.h>
-#include <sound/info.h>
-
-#include <linux/l3/l3.h>
-
-#include <sound/uda1341.h>
-
-/* {{{ HW regs definition */
-
-#define STAT0                   0x00
-#define STAT1                   0x80
-#define STAT_MASK               0x80
-
-#define DATA0_0                 0x00
-#define DATA0_1                 0x40
-#define DATA0_2                 0x80
-#define DATA_MASK               0xc0
-
-#define IS_DATA0(x)     ((x) >= data0_0 && (x) <= data0_2)
-#define IS_DATA1(x)     ((x) == data1)
-#define IS_STATUS(x)    ((x) == stat0 || (x) == stat1)
-#define IS_EXTEND(x)   ((x) >= ext0 && (x) <= ext6)
-
-/* }}} */
-
-
-static const char *peak_names[] = {
-        "before",
-        "after",
-};
-
-static const char *filter_names[] = {
-        "flat",
-        "min",
-        "min",
-        "max",
-};
-
-static const char *mixer_names[] = {
-        "double differential",
-        "input channel 1 (line in)",
-        "input channel 2 (microphone)",
-        "digital mixer",
-};
-
-static const char *deemp_names[] = {
-        "none",
-        "32 kHz",
-        "44.1 kHz",
-        "48 kHz",        
-};
-
-enum uda1341_regs_names {
-        stat0,
-        stat1,
-        data0_0,
-        data0_1,
-        data0_2,
-        data1,
-        ext0,
-        ext1,
-        ext2,
-        empty,
-        ext4,
-        ext5,
-        ext6,
-        uda1341_reg_last,
-};
-
-static const char *uda1341_reg_names[] = {
-        "stat 0 ",
-        "stat 1 ",
-        "data 00",
-        "data 01",
-        "data 02",
-        "data 1 ",
-        "ext 0",
-        "ext 1",
-        "ext 2",
-        "empty",
-        "ext 4",
-        "ext 5",
-        "ext 6",
-};
-
-static const int uda1341_enum_items[] = {
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        2, //peak - before/after
-        4, //deemp - none/32/44.1/48
-        0,
-        4, //filter - flat/min/min/max
-        0, 0, 0,
-        4, //mixer - differ/line/mic/mixer
-        0, 0, 0, 0, 0,
-};
-
-static const char ** uda1341_enum_names[] = {
-        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-        peak_names, //peak - before/after
-        deemp_names, //deemp - none/32/44.1/48
-        NULL,
-        filter_names, //filter - flat/min/min/max
-        NULL, NULL, NULL,
-        mixer_names, //mixer - differ/line/mic/mixer
-        NULL, NULL, NULL, NULL, NULL,
-};
-
-typedef int uda1341_cfg[CMD_LAST];
-
-struct uda1341 {
-        int (*write) (struct l3_client *uda1341, unsigned short reg, unsigned short val);
-        int (*read) (struct l3_client *uda1341, unsigned short reg);        
-        unsigned char regs[uda1341_reg_last];
-        int active;
-        spinlock_t reg_lock;
-        struct snd_card *card;
-        uda1341_cfg cfg;
-#ifdef CONFIG_PM
-        unsigned char suspend_regs[uda1341_reg_last];
-        uda1341_cfg suspend_cfg;
-#endif
-};
-
-/* transfer 8bit integer into string with binary representation */
-static void int2str_bin8(uint8_t val, char *buf)
-{
-        const int size = sizeof(val) * 8;
-        int i;
-
-        for (i= 0; i < size; i++){
-                *(buf++) = (val >> (size - 1)) ? '1' : '0';
-                val <<= 1;
-        }
-        *buf = '\0'; //end the string with zero
-}
-
-/* {{{ HW manipulation routines */
-
-static int snd_uda1341_codec_write(struct l3_client *clnt, unsigned short reg, unsigned short val)
-{
-        struct uda1341 *uda = clnt->driver_data;
-        unsigned char buf[2] = { 0xc0, 0xe0 }; // for EXT addressing
-        int err = 0;
-
-        uda->regs[reg] = val;
-
-        if (uda->active) {
-                if (IS_DATA0(reg)) {
-                        err = l3_write(clnt, UDA1341_DATA0, (const unsigned char *)&val, 1);
-                } else if (IS_DATA1(reg)) {
-                        err = l3_write(clnt, UDA1341_DATA1, (const unsigned char *)&val, 1);
-                } else if (IS_STATUS(reg)) {
-                        err = l3_write(clnt, UDA1341_STATUS, (const unsigned char *)&val, 1);
-                } else if (IS_EXTEND(reg)) {
-                        buf[0] |= (reg - ext0) & 0x7;   //EXT address
-                        buf[1] |= val;                  //EXT data
-                        err = l3_write(clnt, UDA1341_DATA0, (const unsigned char *)buf, 2);
-                }
-        } else
-                printk(KERN_ERR "UDA1341 codec not active!\n");
-        return err;
-}
-
-static int snd_uda1341_codec_read(struct l3_client *clnt, unsigned short reg)
-{
-        unsigned char val;
-        int err;
-
-        err = l3_read(clnt, reg, &val, 1);
-        if (err == 1)
-                // use just 6bits - the rest is address of the reg
-                return val & 63;
-        return err < 0 ? err : -EIO;
-}
-
-static inline int snd_uda1341_valid_reg(struct l3_client *clnt, unsigned short reg)
-{
-        return reg < uda1341_reg_last;
-}
-
-static int snd_uda1341_update_bits(struct l3_client *clnt, unsigned short reg,
-                                   unsigned short mask, unsigned short shift,
-                                   unsigned short value, int flush)
-{
-        int change;
-        unsigned short old, new;
-        struct uda1341 *uda = clnt->driver_data;
-
-#if 0
-        printk(KERN_DEBUG "update_bits: reg: %s mask: %d shift: %d val: %d\n",
-               uda1341_reg_names[reg], mask, shift, value);
-#endif
-        
-        if (!snd_uda1341_valid_reg(clnt, reg))
-                return -EINVAL;
-        spin_lock(&uda->reg_lock);
-        old = uda->regs[reg];
-        new = (old & ~(mask << shift)) | (value << shift);
-        change = old != new;
-        if (change) {
-                if (flush) uda->write(clnt, reg, new);
-                uda->regs[reg] = new;
-        }
-        spin_unlock(&uda->reg_lock);
-        return change;
-}
-
-static int snd_uda1341_cfg_write(struct l3_client *clnt, unsigned short what,
-                                 unsigned short value, int flush)
-{
-        struct uda1341 *uda = clnt->driver_data;
-        int ret = 0;
-#ifdef CONFIG_PM
-        int reg;
-#endif
-
-#if 0
-        printk(KERN_DEBUG "cfg_write what: %d value: %d\n", what, value);
-#endif
-
-        uda->cfg[what] = value;
-        
-        switch(what) {
-        case CMD_RESET:
-                ret = snd_uda1341_update_bits(clnt, data0_2, 1, 2, 1, flush);   // MUTE
-                ret = snd_uda1341_update_bits(clnt, stat0, 1, 6, 1, flush);     // RESET
-                ret = snd_uda1341_update_bits(clnt, stat0, 1, 6, 0, flush);     // RESTORE
-                uda->cfg[CMD_RESET]=0;
-                break;
-        case CMD_FS:
-                ret = snd_uda1341_update_bits(clnt, stat0, 3, 4, value, flush);
-                break;
-        case CMD_FORMAT:
-                ret = snd_uda1341_update_bits(clnt, stat0, 7, 1, value, flush);
-                break;
-        case CMD_OGAIN:
-                ret = snd_uda1341_update_bits(clnt, stat1, 1, 6, value, flush);
-                break;
-        case CMD_IGAIN:
-                ret = snd_uda1341_update_bits(clnt, stat1, 1, 5, value, flush);
-                break;
-        case CMD_DAC:
-                ret = snd_uda1341_update_bits(clnt, stat1, 1, 0, value, flush);
-                break;
-        case CMD_ADC:
-                ret = snd_uda1341_update_bits(clnt, stat1, 1, 1, value, flush);
-                break;
-        case CMD_VOLUME:
-                ret = snd_uda1341_update_bits(clnt, data0_0, 63, 0, value, flush);
-                break;
-        case CMD_BASS:
-                ret = snd_uda1341_update_bits(clnt, data0_1, 15, 2, value, flush);
-                break;
-        case CMD_TREBBLE:
-                ret = snd_uda1341_update_bits(clnt, data0_1, 3, 0, value, flush);
-                break;
-        case CMD_PEAK:
-                ret = snd_uda1341_update_bits(clnt, data0_2, 1, 5, value, flush);
-                break;
-        case CMD_DEEMP:
-                ret = snd_uda1341_update_bits(clnt, data0_2, 3, 3, value, flush);
-                break;
-        case CMD_MUTE:
-                ret = snd_uda1341_update_bits(clnt, data0_2, 1, 2, value, flush);
-                break;
-        case CMD_FILTER:
-                ret = snd_uda1341_update_bits(clnt, data0_2, 3, 0, value, flush);
-                break;
-        case CMD_CH1:
-                ret = snd_uda1341_update_bits(clnt, ext0, 31, 0, value, flush);
-                break;
-        case CMD_CH2:
-                ret = snd_uda1341_update_bits(clnt, ext1, 31, 0, value, flush);
-                break;
-        case CMD_MIC:
-                ret = snd_uda1341_update_bits(clnt, ext2, 7, 2, value, flush);
-                break;
-        case CMD_MIXER:
-                ret = snd_uda1341_update_bits(clnt, ext2, 3, 0, value, flush);
-                break;
-        case CMD_AGC:
-                ret = snd_uda1341_update_bits(clnt, ext4, 1, 4, value, flush);
-                break;
-        case CMD_IG:
-                ret = snd_uda1341_update_bits(clnt, ext4, 3, 0, value & 0x3, flush);
-                ret = snd_uda1341_update_bits(clnt, ext5, 31, 0, value >> 2, flush);
-                break;
-        case CMD_AGC_TIME:
-                ret = snd_uda1341_update_bits(clnt, ext6, 7, 2, value, flush);
-                break;
-        case CMD_AGC_LEVEL:
-                ret = snd_uda1341_update_bits(clnt, ext6, 3, 0, value, flush);
-                break;
-#ifdef CONFIG_PM                
-        case CMD_SUSPEND:
-                for (reg = stat0; reg < uda1341_reg_last; reg++)
-                        uda->suspend_regs[reg] = uda->regs[reg];
-                for (reg = 0; reg < CMD_LAST; reg++)
-                        uda->suspend_cfg[reg] = uda->cfg[reg];
-                break;
-        case CMD_RESUME:
-                for (reg = stat0; reg < uda1341_reg_last; reg++)
-                        snd_uda1341_codec_write(clnt, reg, uda->suspend_regs[reg]);
-                for (reg = 0; reg < CMD_LAST; reg++)
-                        uda->cfg[reg] = uda->suspend_cfg[reg];
-                break;
-#endif
-        default:
-                ret = -EINVAL;
-                break;
-        }
-                
-        if (!uda->active)
-                printk(KERN_ERR "UDA1341 codec not active!\n");                
-        return ret;
-}
-
-/* }}} */
-
-/* {{{ Proc interface */
-#ifdef CONFIG_PROC_FS
-
-static const char *format_names[] = {
-        "I2S-bus",
-        "LSB 16bits",
-        "LSB 18bits",
-        "LSB 20bits",
-        "MSB",
-        "in LSB 16bits/out MSB",
-        "in LSB 18bits/out MSB",
-        "in LSB 20bits/out MSB",        
-};
-
-static const char *fs_names[] = {
-        "512*fs",
-        "384*fs",
-        "256*fs",
-        "Unused - bad value!",
-};
-
-static const char* bass_values[][16] = {
-        {"0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB",
-         "0 dB", "0 dB", "0 dB", "0 dB", "undefined", }, //flat
-        {"0 dB", "2 dB", "4 dB", "6 dB", "8 dB", "10 dB", "12 dB", "14 dB", "16 dB", "18 dB", "18 dB",
-         "18 dB", "18 dB", "18 dB", "18 dB", "undefined",}, // min
-        {"0 dB", "2 dB", "4 dB", "6 dB", "8 dB", "10 dB", "12 dB", "14 dB", "16 dB", "18 dB", "18 dB",
-         "18 dB", "18 dB", "18 dB", "18 dB", "undefined",}, // min
-        {"0 dB", "2 dB", "4 dB", "6 dB", "8 dB", "10 dB", "12 dB", "14 dB", "16 dB", "18 dB", "20 dB",
-         "22 dB", "24 dB", "24 dB", "24 dB", "undefined",}, // max
-};
-
-static const char *mic_sens_value[] = {
-        "-3 dB", "0 dB", "3 dB", "9 dB", "15 dB", "21 dB", "27 dB", "not used",
-};
-
-static const unsigned short AGC_atime[] = {
-        11, 16, 11, 16, 21, 11, 16, 21,
-};
-
-static const unsigned short AGC_dtime[] = {
-        100, 100, 200, 200, 200, 400, 400, 400,
-};
-
-static const char *AGC_level[] = {
-        "-9.0", "-11.5", "-15.0", "-17.5",
-};
-
-static const char *ig_small_value[] = {
-        "-3.0", "-2.5", "-2.0", "-1.5", "-1.0", "-0.5",
-};
-
-/*
- * this was computed as peak_value[i] = pow((63-i)*1.42,1.013)
- *
- * UDA1341 datasheet on page 21: Peak value (dB) = (Peak level - 63.5)*5*log2
- * There is an table with these values [level]=value: [3]=-90.31, [7]=-84.29
- * [61]=-2.78, [62] = -1.48, [63] = 0.0
- * I tried to compute it, but using but even using logarithm with base either 10 or 2
- * i was'n able to get values in the table from the formula. So I constructed another
- * formula (see above) to interpolate the values as good as possible. If there is some
- * mistake, please contact me on tomas.kasparek@seznam.cz. Thanks.
- * UDA1341TS datasheet is available at:
- *   http://www-us9.semiconductors.com/acrobat/datasheets/UDA1341TS_3.pdf 
- */
-static const char *peak_value[] = {
-        "-INF dB", "N.A.", "N.A", "90.31 dB", "N.A.", "N.A.", "N.A.", "-84.29 dB",
-        "-82.65 dB", "-81.13 dB", "-79.61 dB", "-78.09 dB", "-76.57 dB", "-75.05 dB", "-73.53 dB",
-        "-72.01 dB", "-70.49 dB", "-68.97 dB", "-67.45 dB", "-65.93 dB", "-64.41 dB", "-62.90 dB",
-        "-61.38 dB", "-59.86 dB", "-58.35 dB", "-56.83 dB", "-55.32 dB", "-53.80 dB", "-52.29 dB",
-        "-50.78 dB", "-49.26 dB", "-47.75 dB", "-46.24 dB", "-44.73 dB", "-43.22 dB", "-41.71 dB",
-        "-40.20 dB", "-38.69 dB", "-37.19 dB", "-35.68 dB", "-34.17 dB", "-32.67 dB", "-31.17 dB",
-        "-29.66 dB", "-28.16 dB", "-26.66 dB", "-25.16 dB", "-23.66 dB", "-22.16 dB", "-20.67 dB",
-        "-19.17 dB", "-17.68 dB", "-16.19 dB", "-14.70 dB", "-13.21 dB", "-11.72 dB", "-10.24 dB",
-        "-8.76 dB", "-7.28 dB", "-5.81 dB", "-4.34 dB", "-2.88 dB", "-1.43 dB", "0.00 dB",
-};
-
-static void snd_uda1341_proc_read(struct snd_info_entry *entry, 
-                                  struct snd_info_buffer *buffer)
-{
-        struct l3_client *clnt = entry->private_data;
-        struct uda1341 *uda = clnt->driver_data;
-        int peak;
-
-        peak = snd_uda1341_codec_read(clnt, UDA1341_DATA1);
-        if (peak < 0)
-                peak = 0;
-        
-        snd_iprintf(buffer, "%s\n\n", uda->card->longname);
-
-        // for information about computed values see UDA1341TS datasheet pages 15 - 21
-        snd_iprintf(buffer, "DAC power           : %s\n", uda->cfg[CMD_DAC] ? "on" : "off");
-        snd_iprintf(buffer, "ADC power           : %s\n", uda->cfg[CMD_ADC] ? "on" : "off");
-        snd_iprintf(buffer, "Clock frequency     : %s\n", fs_names[uda->cfg[CMD_FS]]);
-        snd_iprintf(buffer, "Data format         : %s\n\n", format_names[uda->cfg[CMD_FORMAT]]);
-
-        snd_iprintf(buffer, "Filter mode         : %s\n", filter_names[uda->cfg[CMD_FILTER]]);
-        snd_iprintf(buffer, "Mixer mode          : %s\n", mixer_names[uda->cfg[CMD_MIXER]]);
-        snd_iprintf(buffer, "De-emphasis         : %s\n", deemp_names[uda->cfg[CMD_DEEMP]]);    
-        snd_iprintf(buffer, "Peak detection pos. : %s\n", uda->cfg[CMD_PEAK] ? "after" : "before");
-        snd_iprintf(buffer, "Peak value          : %s\n\n", peak_value[peak]);          
-        
-        snd_iprintf(buffer, "Automatic Gain Ctrl : %s\n", uda->cfg[CMD_AGC] ? "on" : "off");
-        snd_iprintf(buffer, "AGC attack time     : %d ms\n", AGC_atime[uda->cfg[CMD_AGC_TIME]]);
-        snd_iprintf(buffer, "AGC decay time      : %d ms\n", AGC_dtime[uda->cfg[CMD_AGC_TIME]]);
-        snd_iprintf(buffer, "AGC output level    : %s dB\n\n", AGC_level[uda->cfg[CMD_AGC_LEVEL]]);
-
-        snd_iprintf(buffer, "Mute                : %s\n", uda->cfg[CMD_MUTE] ? "on" : "off");
-
-        if (uda->cfg[CMD_VOLUME] == 0)
-                snd_iprintf(buffer, "Volume              : 0 dB\n");
-        else if (uda->cfg[CMD_VOLUME] < 62)
-                snd_iprintf(buffer, "Volume              : %d dB\n", -1*uda->cfg[CMD_VOLUME] +1);
-        else
-                snd_iprintf(buffer, "Volume              : -INF dB\n");
-        snd_iprintf(buffer, "Bass                : %s\n", bass_values[uda->cfg[CMD_FILTER]][uda->cfg[CMD_BASS]]);
-        snd_iprintf(buffer, "Trebble             : %d dB\n", uda->cfg[CMD_FILTER] ? 2*uda->cfg[CMD_TREBBLE] : 0);
-        snd_iprintf(buffer, "Input Gain (6dB)    : %s\n", uda->cfg[CMD_IGAIN] ? "on" : "off");
-        snd_iprintf(buffer, "Output Gain (6dB)   : %s\n", uda->cfg[CMD_OGAIN] ? "on" : "off");
-        snd_iprintf(buffer, "Mic sensitivity     : %s\n", mic_sens_value[uda->cfg[CMD_MIC]]);
-
-        
-        if(uda->cfg[CMD_CH1] < 31)
-                snd_iprintf(buffer, "Mixer gain channel 1: -%d.%c dB\n",
-                            ((uda->cfg[CMD_CH1] >> 1) * 3) + (uda->cfg[CMD_CH1] & 1),
-                            uda->cfg[CMD_CH1] & 1 ? '5' : '0');
-        else
-                snd_iprintf(buffer, "Mixer gain channel 1: -INF dB\n");
-        if(uda->cfg[CMD_CH2] < 31)
-                snd_iprintf(buffer, "Mixer gain channel 2: -%d.%c dB\n",
-                            ((uda->cfg[CMD_CH2] >> 1) * 3) + (uda->cfg[CMD_CH2] & 1),
-                            uda->cfg[CMD_CH2] & 1 ? '5' : '0');
-        else
-                snd_iprintf(buffer, "Mixer gain channel 2: -INF dB\n");
-
-        if(uda->cfg[CMD_IG] > 5)
-                snd_iprintf(buffer, "Input Amp. Gain ch 2: %d.%c dB\n",
-                            (uda->cfg[CMD_IG] >> 1) -3, uda->cfg[CMD_IG] & 1 ? '5' : '0');
-        else
-                snd_iprintf(buffer, "Input Amp. Gain ch 2: %s dB\n",  ig_small_value[uda->cfg[CMD_IG]]);
-}
-
-static void snd_uda1341_proc_regs_read(struct snd_info_entry *entry, 
-                                       struct snd_info_buffer *buffer)
-{
-        struct l3_client *clnt = entry->private_data;
-        struct uda1341 *uda = clnt->driver_data;                
-        int reg;
-        char buf[12];
-
-        for (reg = 0; reg < uda1341_reg_last; reg ++) {
-                if (reg == empty)
-                        continue;
-                int2str_bin8(uda->regs[reg], buf);
-                snd_iprintf(buffer, "%s = %s\n", uda1341_reg_names[reg], buf);
-        }
-
-        int2str_bin8(snd_uda1341_codec_read(clnt, UDA1341_DATA1), buf);
-        snd_iprintf(buffer, "DATA1 = %s\n", buf);
-}
-#endif /* CONFIG_PROC_FS */
-
-static void __devinit snd_uda1341_proc_init(struct snd_card *card, struct l3_client *clnt)
-{
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(card, "uda1341", &entry))
-                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, snd_uda1341_proc_regs_read);
-}
-
-/* }}} */
-
-/* {{{ Mixer controls setting */
-
-/* {{{ UDA1341 single functions */
-
-#define UDA1341_SINGLE(xname, where, reg, shift, mask, invert) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_uda1341_info_single, \
-  .get = snd_uda1341_get_single, .put = snd_uda1341_put_single, \
-  .private_value = where | (reg << 5) | (shift << 9) | (mask << 12) | (invert << 18) \
-}
-
-static int snd_uda1341_info_single(struct snd_kcontrol *kcontrol,
-                                   struct snd_ctl_elem_info *uinfo)
-{
-        int mask = (kcontrol->private_value >> 12) & 63;
-
-        uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = mask;
-        return 0;
-}
-
-static int snd_uda1341_get_single(struct snd_kcontrol *kcontrol,
-                                  struct snd_ctl_elem_value *ucontrol)
-{
-        struct l3_client *clnt = snd_kcontrol_chip(kcontrol);
-        struct uda1341 *uda = clnt->driver_data;
-        int where = kcontrol->private_value & 31;        
-        int mask = (kcontrol->private_value >> 12) & 63;
-        int invert = (kcontrol->private_value >> 18) & 1;
-        
-        ucontrol->value.integer.value[0] = uda->cfg[where];
-        if (invert)
-                ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
-
-        return 0;
-}
-
-static int snd_uda1341_put_single(struct snd_kcontrol *kcontrol,
-                                  struct snd_ctl_elem_value *ucontrol)
-{
-        struct l3_client *clnt = snd_kcontrol_chip(kcontrol);
-        struct uda1341 *uda = clnt->driver_data;
-        int where = kcontrol->private_value & 31;        
-        int reg = (kcontrol->private_value >> 5) & 15;
-        int shift = (kcontrol->private_value >> 9) & 7;
-        int mask = (kcontrol->private_value >> 12) & 63;
-        int invert = (kcontrol->private_value >> 18) & 1;
-        unsigned short val;
-
-        val = (ucontrol->value.integer.value[0] & mask);
-        if (invert)
-                val = mask - val;
-
-        uda->cfg[where] = val;
-        return snd_uda1341_update_bits(clnt, reg, mask, shift, val, FLUSH);
-}
-
-/* }}} */
-
-/* {{{ UDA1341 enum functions */
-
-#define UDA1341_ENUM(xname, where, reg, shift, mask, invert) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_uda1341_info_enum, \
-  .get = snd_uda1341_get_enum, .put = snd_uda1341_put_enum, \
-  .private_value = where | (reg << 5) | (shift << 9) | (mask << 12) | (invert << 18) \
-}
-
-static int snd_uda1341_info_enum(struct snd_kcontrol *kcontrol,
-                                 struct snd_ctl_elem_info *uinfo)
-{
-        int where = kcontrol->private_value & 31;
-        const char **texts;
-        
-        // this register we don't handle this way
-        if (!uda1341_enum_items[where])
-                return -EINVAL;
-
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-        uinfo->count = 1;
-        uinfo->value.enumerated.items = uda1341_enum_items[where];
-
-        if (uinfo->value.enumerated.item >= uda1341_enum_items[where])
-                uinfo->value.enumerated.item = uda1341_enum_items[where] - 1;
-
-        texts = uda1341_enum_names[where];
-        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
-        return 0;
-}
-
-static int snd_uda1341_get_enum(struct snd_kcontrol *kcontrol,
-                                struct snd_ctl_elem_value *ucontrol)
-{
-        struct l3_client *clnt = snd_kcontrol_chip(kcontrol);
-        struct uda1341 *uda = clnt->driver_data;
-        int where = kcontrol->private_value & 31;        
-        
-        ucontrol->value.enumerated.item[0] = uda->cfg[where];   
-        return 0;
-}
-
-static int snd_uda1341_put_enum(struct snd_kcontrol *kcontrol,
-                                struct snd_ctl_elem_value *ucontrol)
-{
-        struct l3_client *clnt = snd_kcontrol_chip(kcontrol);
-        struct uda1341 *uda = clnt->driver_data;
-        int where = kcontrol->private_value & 31;        
-        int reg = (kcontrol->private_value >> 5) & 15;
-        int shift = (kcontrol->private_value >> 9) & 7;
-        int mask = (kcontrol->private_value >> 12) & 63;
-
-        uda->cfg[where] = (ucontrol->value.enumerated.item[0] & mask);
-        
-        return snd_uda1341_update_bits(clnt, reg, mask, shift, uda->cfg[where], FLUSH);
-}
-
-/* }}} */
-
-/* {{{ UDA1341 2regs functions */
-
-#define UDA1341_2REGS(xname, where, reg_1, reg_2, shift_1, shift_2, mask_1, mask_2, invert) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), .info = snd_uda1341_info_2regs, \
-  .get = snd_uda1341_get_2regs, .put = snd_uda1341_put_2regs, \
-  .private_value = where | (reg_1 << 5) | (reg_2 << 9) | (shift_1 << 13) | (shift_2 << 16) | \
-                         (mask_1 << 19) | (mask_2 << 25) | (invert << 31) \
-}
-
-
-static int snd_uda1341_info_2regs(struct snd_kcontrol *kcontrol,
-                                  struct snd_ctl_elem_info *uinfo)
-{
-        int mask_1 = (kcontrol->private_value >> 19) & 63;
-        int mask_2 = (kcontrol->private_value >> 25) & 63;
-        int mask;
-        
-        mask = (mask_2 + 1) * (mask_1 + 1) - 1;
-        uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = mask;
-        return 0;
-}
-
-static int snd_uda1341_get_2regs(struct snd_kcontrol *kcontrol,
-                                 struct snd_ctl_elem_value *ucontrol)
-{
-        struct l3_client *clnt = snd_kcontrol_chip(kcontrol);
-        struct uda1341 *uda = clnt->driver_data;
-        int where = kcontrol->private_value & 31;
-        int mask_1 = (kcontrol->private_value >> 19) & 63;
-        int mask_2 = (kcontrol->private_value >> 25) & 63;        
-        int invert = (kcontrol->private_value >> 31) & 1;
-        int mask;
-
-        mask = (mask_2 + 1) * (mask_1 + 1) - 1;
-
-        ucontrol->value.integer.value[0] = uda->cfg[where];
-        if (invert)
-                ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
-        return 0;
-}
-
-static int snd_uda1341_put_2regs(struct snd_kcontrol *kcontrol,
-                                 struct snd_ctl_elem_value *ucontrol)
-{
-        struct l3_client *clnt = snd_kcontrol_chip(kcontrol);
-        struct uda1341 *uda = clnt->driver_data;        
-        int where = kcontrol->private_value & 31;        
-        int reg_1 = (kcontrol->private_value >> 5) & 15;
-        int reg_2 = (kcontrol->private_value >> 9) & 15;        
-        int shift_1 = (kcontrol->private_value >> 13) & 7;
-        int shift_2 = (kcontrol->private_value >> 16) & 7;
-        int mask_1 = (kcontrol->private_value >> 19) & 63;
-        int mask_2 = (kcontrol->private_value >> 25) & 63;        
-        int invert = (kcontrol->private_value >> 31) & 1;
-        int mask;
-        unsigned short val1, val2, val;
-
-        val = ucontrol->value.integer.value[0];
-         
-        mask = (mask_2 + 1) * (mask_1 + 1) - 1;
-
-        val1 = val & mask_1;
-        val2 = (val / (mask_1 + 1)) & mask_2;        
-
-        if (invert) {
-                val1 = mask_1 - val1;
-                val2 = mask_2 - val2;
-        }
-
-        uda->cfg[where] = invert ? mask - val : val;
-        
-        //FIXME - return value
-        snd_uda1341_update_bits(clnt, reg_1, mask_1, shift_1, val1, FLUSH);
-        return snd_uda1341_update_bits(clnt, reg_2, mask_2, shift_2, val2, FLUSH);
-}
-
-/* }}} */
-  
-static struct snd_kcontrol_new snd_uda1341_controls[] = {
-        UDA1341_SINGLE("Master Playback Switch", CMD_MUTE, data0_2, 2, 1, 1),
-        UDA1341_SINGLE("Master Playback Volume", CMD_VOLUME, data0_0, 0, 63, 1),
-
-        UDA1341_SINGLE("Bass Playback Volume", CMD_BASS, data0_1, 2, 15, 0),
-        UDA1341_SINGLE("Treble Playback Volume", CMD_TREBBLE, data0_1, 0, 3, 0),
-
-        UDA1341_SINGLE("Input Gain Switch", CMD_IGAIN, stat1, 5, 1, 0),
-        UDA1341_SINGLE("Output Gain Switch", CMD_OGAIN, stat1, 6, 1, 0),
-
-        UDA1341_SINGLE("Mixer Gain Channel 1 Volume", CMD_CH1, ext0, 0, 31, 1),
-        UDA1341_SINGLE("Mixer Gain Channel 2 Volume", CMD_CH2, ext1, 0, 31, 1),
-
-        UDA1341_SINGLE("Mic Sensitivity Volume", CMD_MIC, ext2, 2, 7, 0),
-
-        UDA1341_SINGLE("AGC Output Level", CMD_AGC_LEVEL, ext6, 0, 3, 0),
-        UDA1341_SINGLE("AGC Time Constant", CMD_AGC_TIME, ext6, 2, 7, 0),
-        UDA1341_SINGLE("AGC Time Constant Switch", CMD_AGC, ext4, 4, 1, 0),
-
-        UDA1341_SINGLE("DAC Power", CMD_DAC, stat1, 0, 1, 0),
-        UDA1341_SINGLE("ADC Power", CMD_ADC, stat1, 1, 1, 0),
-
-        UDA1341_ENUM("Peak detection", CMD_PEAK, data0_2, 5, 1, 0),
-        UDA1341_ENUM("De-emphasis", CMD_DEEMP, data0_2, 3, 3, 0),
-        UDA1341_ENUM("Mixer mode", CMD_MIXER, ext2, 0, 3, 0),
-        UDA1341_ENUM("Filter mode", CMD_FILTER, data0_2, 0, 3, 0),
-
-        UDA1341_2REGS("Gain Input Amplifier Gain (channel 2)", CMD_IG, ext4, ext5, 0, 0, 3, 31, 0),
-};
-
-static void uda1341_free(struct l3_client *clnt)
-{
-        l3_detach_client(clnt); // calls kfree for driver_data (struct uda1341)
-        kfree(clnt);
-}
-
-static int uda1341_dev_free(struct snd_device *device)
-{
-        struct l3_client *clnt = device->device_data;
-        uda1341_free(clnt);
-        return 0;
-}
-
-int __init snd_chip_uda1341_mixer_new(struct snd_card *card, struct l3_client **clntp)
-{
-        static struct snd_device_ops ops = {
-                .dev_free =     uda1341_dev_free,
-        };
-        struct l3_client *clnt;
-        int idx, err;
-
-        if (snd_BUG_ON(!card))
-                return -EINVAL;
-
-        clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
-        if (clnt == NULL)
-                return -ENOMEM;
-         
-        if ((err = l3_attach_client(clnt, "l3-bit-sa1100-gpio", UDA1341_ALSA_NAME))) {
-                kfree(clnt);
-                return err;
-        }
-
-        for (idx = 0; idx < ARRAY_SIZE(snd_uda1341_controls); idx++) {
-                if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_uda1341_controls[idx], clnt))) < 0) {
-                        uda1341_free(clnt);
-                        return err;
-                }
-        }
-
-        if ((err = snd_device_new(card, SNDRV_DEV_CODEC, clnt, &ops)) < 0) {
-                uda1341_free(clnt);
-                return err;
-        }
-
-        *clntp = clnt;
-        strcpy(card->mixername, "UDA1341TS Mixer");
-        ((struct uda1341 *)clnt->driver_data)->card = card;
-        
-        snd_uda1341_proc_init(card, clnt);
-        
-        return 0;
-}
-
-/* }}} */
-
-/* {{{ L3 operations */
-
-static int uda1341_attach(struct l3_client *clnt)
-{
-        struct uda1341 *uda;
-
-        uda = kzalloc(sizeof(*uda), 0, GFP_KERNEL);
-        if (!uda)
-                return -ENOMEM;
-
-        /* init fixed parts of my copy of registers */
-        uda->regs[stat0]   = STAT0;
-        uda->regs[stat1]   = STAT1;
-
-        uda->regs[data0_0] = DATA0_0;
-        uda->regs[data0_1] = DATA0_1;
-        uda->regs[data0_2] = DATA0_2;
-
-        uda->write = snd_uda1341_codec_write;
-        uda->read = snd_uda1341_codec_read;
-  
-        spin_lock_init(&uda->reg_lock);
-        
-        clnt->driver_data = uda;
-        return 0;
-}
-
-static void uda1341_detach(struct l3_client *clnt)
-{
-        kfree(clnt->driver_data);
-}
-
-static int
-uda1341_command(struct l3_client *clnt, int cmd, void *arg)
-{
-        if (cmd != CMD_READ_REG)
-                return snd_uda1341_cfg_write(clnt, cmd, (int) arg, FLUSH);
-
-        return snd_uda1341_codec_read(clnt, (int) arg);
-}
-
-static int uda1341_open(struct l3_client *clnt)
-{
-        struct uda1341 *uda = clnt->driver_data;
-
-        uda->active = 1;
-
-        /* init default configuration */
-        snd_uda1341_cfg_write(clnt, CMD_RESET, 0, REGS_ONLY);
-        snd_uda1341_cfg_write(clnt, CMD_FS, F256, FLUSH);       // unknown state after reset
-        snd_uda1341_cfg_write(clnt, CMD_FORMAT, LSB16, FLUSH);  // unknown state after reset
-        snd_uda1341_cfg_write(clnt, CMD_OGAIN, ON, FLUSH);      // default off after reset
-        snd_uda1341_cfg_write(clnt, CMD_IGAIN, ON, FLUSH);      // default off after reset
-        snd_uda1341_cfg_write(clnt, CMD_DAC, ON, FLUSH);        // ??? default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_ADC, ON, FLUSH);        // ??? default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_VOLUME, 20, FLUSH);     // default 0dB after reset
-        snd_uda1341_cfg_write(clnt, CMD_BASS, 0, REGS_ONLY);    // default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_TREBBLE, 0, REGS_ONLY); // default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_PEAK, AFTER, REGS_ONLY);// default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_DEEMP, NONE, REGS_ONLY);// default value after reset
-        //at this moment should be QMUTED by h3600_audio_init
-        snd_uda1341_cfg_write(clnt, CMD_MUTE, OFF, REGS_ONLY);  // default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_FILTER, MAX, FLUSH);    // defaul flat after reset
-        snd_uda1341_cfg_write(clnt, CMD_CH1, 31, FLUSH);        // default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_CH2, 4, FLUSH);         // default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_MIC, 4, FLUSH);         // default 0dB after reset
-        snd_uda1341_cfg_write(clnt, CMD_MIXER, MIXER, FLUSH);   // default doub.dif.mode          
-        snd_uda1341_cfg_write(clnt, CMD_AGC, OFF, FLUSH);       // default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_IG, 0, FLUSH);          // unknown state after reset
-        snd_uda1341_cfg_write(clnt, CMD_AGC_TIME, 0, FLUSH);    // default value after reset
-        snd_uda1341_cfg_write(clnt, CMD_AGC_LEVEL, 0, FLUSH);   // default value after reset
-
-        return 0;
-}
-
-static void uda1341_close(struct l3_client *clnt)
-{
-        struct uda1341 *uda = clnt->driver_data;
-
-        uda->active = 0;
-}
-
-/* }}} */
-
-/* {{{ Module and L3 initialization */
-
-static struct l3_ops uda1341_ops = {
-        .open =         uda1341_open,
-        .command =      uda1341_command,
-        .close =        uda1341_close,
-};
-
-static struct l3_driver uda1341_driver = {
-        .name =         UDA1341_ALSA_NAME,
-        .attach_client = uda1341_attach,
-        .detach_client = uda1341_detach,
-        .ops =          &uda1341_ops,
-        .owner =        THIS_MODULE,
-};
-
-static int __init uda1341_init(void)
-{
-        return l3_add_driver(&uda1341_driver);
-}
-
-static void __exit uda1341_exit(void)
-{
-        l3_del_driver(&uda1341_driver);
-}
-
-module_init(uda1341_init);
-module_exit(uda1341_exit);
-
-MODULE_AUTHOR("Tomas Kasparek <tomas.kasparek@seznam.cz>");
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Philips UDA1341 CODEC driver for ALSA");
-MODULE_SUPPORTED_DEVICE("{{UDA1341,UDA1341TS}}");
-
-EXPORT_SYMBOL(snd_chip_uda1341_mixer_new);
-
-/* }}} */
-
-/*
- * Local variables:
- * indent-tabs-mode: t
- * End:
- */
diff --git a/sound/i2c/other/tea575x-tuner.c b/sound/i2c/other/tea575x-tuner.c
index 9d98a6658ac9..d31c373e076d 100644
--- a/sound/i2c/other/tea575x-tuner.c
+++ b/sound/i2c/other/tea575x-tuner.c
@@ -24,6 +24,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
+#include <linux/version.h>
 #include <sound/core.h>
 #include <sound/tea575x-tuner.h>
 
@@ -31,6 +32,13 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_DESCRIPTION("Routines for control of TEA5757/5759 Philips AM/FM radio tuner chips");
 MODULE_LICENSE("GPL");
 
+static int radio_nr = -1;
+module_param(radio_nr, int, 0);
+
+#define RADIO_VERSION KERNEL_VERSION(0, 0, 2)
+#define FREQ_LO          (87 * 16000)
+#define FREQ_HI         (108 * 16000)
+
 /*
  * definitions
  */
@@ -53,6 +61,17 @@ MODULE_LICENSE("GPL");
 #define TEA575X_BIT_DUMMY       (1<<15)         /* buffer */
 #define TEA575X_BIT_FREQ_MASK   0x7fff
 
+static struct v4l2_queryctrl radio_qctrl[] = {
+        {
+                .id            = V4L2_CID_AUDIO_MUTE,
+                .name          = "Mute",
+                .minimum       = 0,
+                .maximum       = 1,
+                .default_value = 1,
+                .type          = V4L2_CTRL_TYPE_BOOLEAN,
+        }
+};
+
 /*
  * lowlevel part
  */
@@ -84,94 +103,146 @@ static void snd_tea575x_set_freq(struct snd_tea575x *tea)
  * Linux Video interface
  */
 
-static long snd_tea575x_ioctl(struct file *file,
-                             unsigned int cmd, unsigned long data)
+static int vidioc_querycap(struct file *file, void  *priv,
+                                        struct v4l2_capability *v)
 {
         struct snd_tea575x *tea = video_drvdata(file);
-        void __user *arg = (void __user *)data;
-
-        switch(cmd) {
-                case VIDIOCGCAP:
-                {
-                        struct video_capability v;
-                        v.type = VID_TYPE_TUNER;
-                        v.channels = 1;
-                        v.audios = 1;
-                        /* No we don't do pictures */
-                        v.maxwidth = 0;
-                        v.maxheight = 0;
-                        v.minwidth = 0;
-                        v.minheight = 0;
-                        strcpy(v.name, tea->tea5759 ? "TEA5759" : "TEA5757");
-                        if (copy_to_user(arg,&v,sizeof(v)))
-                                return -EFAULT;
-                        return 0;
-                }
-                case VIDIOCGTUNER:
-                {
-                        struct video_tuner v;
-                        if (copy_from_user(&v, arg,sizeof(v))!=0)
-                                return -EFAULT;
-                        if (v.tuner)    /* Only 1 tuner */
-                                return -EINVAL;
-                        v.rangelow = (87*16000);
-                        v.rangehigh = (108*16000);
-                        v.flags = VIDEO_TUNER_LOW;
-                        v.mode = VIDEO_MODE_AUTO;
-                        strcpy(v.name, "FM");
-                        v.signal = 0xFFFF;
-                        if (copy_to_user(arg, &v, sizeof(v)))
-                                return -EFAULT;
-                        return 0;
-                }
-                case VIDIOCSTUNER:
-                {
-                        struct video_tuner v;
-                        if(copy_from_user(&v, arg, sizeof(v)))
-                                return -EFAULT;
-                        if(v.tuner!=0)
-                                return -EINVAL;
-                        /* Only 1 tuner so no setting needed ! */
+
+        strcpy(v->card, tea->tea5759 ? "TEA5759" : "TEA5757");
+        strlcpy(v->driver, "tea575x-tuner", sizeof(v->driver));
+        strlcpy(v->card, "Maestro Radio", sizeof(v->card));
+        sprintf(v->bus_info, "PCI");
+        v->version = RADIO_VERSION;
+        v->capabilities = V4L2_CAP_TUNER;
+        return 0;
+}
+
+static int vidioc_g_tuner(struct file *file, void *priv,
+                                        struct v4l2_tuner *v)
+{
+        if (v->index > 0)
+                return -EINVAL;
+
+        strcpy(v->name, "FM");
+        v->type = V4L2_TUNER_RADIO;
+        v->rangelow = FREQ_LO;
+        v->rangehigh = FREQ_HI;
+        v->rxsubchans = V4L2_TUNER_SUB_MONO|V4L2_TUNER_SUB_STEREO;
+        v->capability = V4L2_TUNER_CAP_LOW;
+        v->audmode = V4L2_TUNER_MODE_MONO;
+        v->signal = 0xffff;
+        return 0;
+}
+
+static int vidioc_s_tuner(struct file *file, void *priv,
+                                        struct v4l2_tuner *v)
+{
+        if (v->index > 0)
+                return -EINVAL;
+        return 0;
+}
+
+static int vidioc_g_frequency(struct file *file, void *priv,
+                                        struct v4l2_frequency *f)
+{
+        struct snd_tea575x *tea = video_drvdata(file);
+
+        f->type = V4L2_TUNER_RADIO;
+        f->frequency = tea->freq;
+        return 0;
+}
+
+static int vidioc_s_frequency(struct file *file, void *priv,
+                                        struct v4l2_frequency *f)
+{
+        struct snd_tea575x *tea = video_drvdata(file);
+
+        if (f->frequency < FREQ_LO || f->frequency > FREQ_HI)
+                return -EINVAL;
+
+        tea->freq = f->frequency;
+
+        snd_tea575x_set_freq(tea);
+
+        return 0;
+}
+
+static int vidioc_g_audio(struct file *file, void *priv,
+                                        struct v4l2_audio *a)
+{
+        if (a->index > 1)
+                return -EINVAL;
+
+        strcpy(a->name, "Radio");
+        a->capability = V4L2_AUDCAP_STEREO;
+        return 0;
+}
+
+static int vidioc_s_audio(struct file *file, void *priv,
+                                        struct v4l2_audio *a)
+{
+        if (a->index != 0)
+                return -EINVAL;
+        return 0;
+}
+
+static int vidioc_queryctrl(struct file *file, void *priv,
+                                        struct v4l2_queryctrl *qc)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(radio_qctrl); i++) {
+                if (qc->id && qc->id == radio_qctrl[i].id) {
+                        memcpy(qc, &(radio_qctrl[i]),
+                                                sizeof(*qc));
                         return 0;
                 }
-                case VIDIOCGFREQ:
-                        if(copy_to_user(arg, &tea->freq, sizeof(tea->freq)))
-                                return -EFAULT;
-                        return 0;
-                case VIDIOCSFREQ:
-                        if(copy_from_user(&tea->freq, arg, sizeof(tea->freq)))
-                                return -EFAULT;
-                        snd_tea575x_set_freq(tea);
-                        return 0;
-                case VIDIOCGAUDIO:
-                {
-                        struct video_audio v;
-                        memset(&v, 0, sizeof(v));
-                        strcpy(v.name, "Radio");
-                        if(copy_to_user(arg,&v, sizeof(v)))
-                                return -EFAULT;
+        }
+        return -EINVAL;
+}
+
+static int vidioc_g_ctrl(struct file *file, void *priv,
+                                        struct v4l2_control *ctrl)
+{
+        struct snd_tea575x *tea = video_drvdata(file);
+
+        switch (ctrl->id) {
+        case V4L2_CID_AUDIO_MUTE:
+                if (tea->ops->mute) {
+                        ctrl->value = tea->mute;
                         return 0;
                 }
-                case VIDIOCSAUDIO:
-                {
-                        struct video_audio v;
-                        if(copy_from_user(&v, arg, sizeof(v)))
-                                return -EFAULT;
-                        if (tea->ops->mute)
-                                tea->ops->mute(tea,
-                                               (v.flags &
-                                                VIDEO_AUDIO_MUTE) ? 1 : 0);
-                        if(v.audio)
-                                return -EINVAL;
+        }
+        return -EINVAL;
+}
+
+static int vidioc_s_ctrl(struct file *file, void *priv,
+                                        struct v4l2_control *ctrl)
+{
+        struct snd_tea575x *tea = video_drvdata(file);
+
+        switch (ctrl->id) {
+        case V4L2_CID_AUDIO_MUTE:
+                if (tea->ops->mute) {
+                        tea->ops->mute(tea, ctrl->value);
+                        tea->mute = 1;
                         return 0;
                 }
-                default:
-                        return -ENOIOCTLCMD;
         }
+        return -EINVAL;
+}
+
+static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
+{
+        *i = 0;
+        return 0;
 }
 
-static void snd_tea575x_release(struct video_device *vfd)
+static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
 {
+        if (i != 0)
+                return -EINVAL;
+        return 0;
 }
 
 static int snd_tea575x_exclusive_open(struct file *file)
@@ -189,50 +260,91 @@ static int snd_tea575x_exclusive_release(struct file *file)
         return 0;
 }
 
+static const struct v4l2_file_operations tea575x_fops = {
+        .owner          = THIS_MODULE,
+        .open           = snd_tea575x_exclusive_open,
+        .release        = snd_tea575x_exclusive_release,
+        .ioctl          = video_ioctl2,
+};
+
+static const struct v4l2_ioctl_ops tea575x_ioctl_ops = {
+        .vidioc_querycap    = vidioc_querycap,
+        .vidioc_g_tuner     = vidioc_g_tuner,
+        .vidioc_s_tuner     = vidioc_s_tuner,
+        .vidioc_g_audio     = vidioc_g_audio,
+        .vidioc_s_audio     = vidioc_s_audio,
+        .vidioc_g_input     = vidioc_g_input,
+        .vidioc_s_input     = vidioc_s_input,
+        .vidioc_g_frequency = vidioc_g_frequency,
+        .vidioc_s_frequency = vidioc_s_frequency,
+        .vidioc_queryctrl   = vidioc_queryctrl,
+        .vidioc_g_ctrl      = vidioc_g_ctrl,
+        .vidioc_s_ctrl      = vidioc_s_ctrl,
+};
+
+static struct video_device tea575x_radio = {
+        .name           = "tea575x-tuner",
+        .fops           = &tea575x_fops,
+        .ioctl_ops      = &tea575x_ioctl_ops,
+        .release        = video_device_release,
+};
+
 /*
  * initialize all the tea575x chips
  */
 void snd_tea575x_init(struct snd_tea575x *tea)
 {
+        int retval;
         unsigned int val;
+        struct video_device *tea575x_radio_inst;
 
         val = tea->ops->read(tea);
         if (val == 0x1ffffff || val == 0) {
-                snd_printk(KERN_ERR "Cannot find TEA575x chip\n");
+                snd_printk(KERN_ERR
+                           "tea575x-tuner: Cannot find TEA575x chip\n");
                 return;
         }
 
-        memset(&tea->vd, 0, sizeof(tea->vd));
-        strcpy(tea->vd.name, tea->tea5759 ? "TEA5759 radio" : "TEA5757 radio");
-        tea->vd.release = snd_tea575x_release;
-        video_set_drvdata(&tea->vd, tea);
-        tea->vd.fops = &tea->fops;
         tea->in_use = 0;
-        tea->fops.owner = tea->card->module;
-        tea->fops.open = snd_tea575x_exclusive_open;
-        tea->fops.release = snd_tea575x_exclusive_release;
-        tea->fops.ioctl = snd_tea575x_ioctl;
-        if (video_register_device(&tea->vd, VFL_TYPE_RADIO, tea->dev_nr - 1) < 0) {
-                snd_printk(KERN_ERR "unable to register tea575x tuner\n");
+        tea->val = TEA575X_BIT_BAND_FM | TEA575X_BIT_SEARCH_10_40;
+        tea->freq = 90500 * 16;         /* 90.5Mhz default */
+
+        tea575x_radio_inst = video_device_alloc();
+        if (tea575x_radio_inst == NULL) {
+                printk(KERN_ERR "tea575x-tuner: not enough memory\n");
                 return;
         }
-        tea->vd_registered = 1;
 
-        tea->val = TEA575X_BIT_BAND_FM | TEA575X_BIT_SEARCH_10_40;
-        tea->freq = 90500 * 16;         /* 90.5Mhz default */
+        memcpy(tea575x_radio_inst, &tea575x_radio, sizeof(tea575x_radio));
+
+        strcpy(tea575x_radio.name, tea->tea5759 ?
+                                   "TEA5759 radio" : "TEA5757 radio");
+
+        video_set_drvdata(tea575x_radio_inst, tea);
+
+        retval = video_register_device(tea575x_radio_inst,
+                                       VFL_TYPE_RADIO, radio_nr);
+        if (retval) {
+                printk(KERN_ERR "tea575x-tuner: can't register video device!\n");
+                kfree(tea575x_radio_inst);
+                return;
+        }
 
         snd_tea575x_set_freq(tea);
 
         /* mute on init */
-        if (tea->ops->mute)
+        if (tea->ops->mute) {
                 tea->ops->mute(tea, 1);
+                tea->mute = 1;
+        }
+        tea->vd = tea575x_radio_inst;
 }
 
 void snd_tea575x_exit(struct snd_tea575x *tea)
 {
-        if (tea->vd_registered) {
-                video_unregister_device(&tea->vd);
-                tea->vd_registered = 0;
+        if (tea->vd) {
+                video_unregister_device(tea->vd);
+                tea->vd = NULL;
         }
 }
 
diff --git a/sound/isa/Kconfig b/sound/isa/Kconfig
index ce0aa044e274..c6942a4de99b 100644
--- a/sound/isa/Kconfig
+++ b/sound/isa/Kconfig
@@ -56,8 +56,8 @@ config SND_AD1848
           Say Y here to include support for AD1848 (Analog Devices) or
           CS4248 (Cirrus Logic - Crystal Semiconductors) chips.
           
-          For newer chips from Cirrus Logic, use the CS4231, CS4232 or
-          CS4236+ drivers.
+          For newer chips from Cirrus Logic, use the CS4231 or CS4232+
+          drivers.
 
           To compile this driver as a module, choose M here: the module
           will be called snd-ad1848.
@@ -94,6 +94,8 @@ config SND_CMI8330
         tristate "C-Media CMI8330"
         select SND_WSS_LIB
         select SND_SB16_DSP
+        select SND_OPL3_LIB
+        select SND_MPU401_UART
         help
           Say Y here to include support for soundcards based on the
           C-Media CMI8330 chip.
@@ -112,26 +114,15 @@ config SND_CS4231
           To compile this driver as a module, choose M here: the module
           will be called snd-cs4231.
 
-config SND_CS4232
-        tristate "Generic Cirrus Logic CS4232 driver"
-        select SND_OPL3_LIB
-        select SND_MPU401_UART
-        select SND_WSS_LIB
-        help
-          Say Y here to include support for CS4232 chips from Cirrus
-          Logic - Crystal Semiconductors.
-
-          To compile this driver as a module, choose M here: the module
-          will be called snd-cs4232.
-
 config SND_CS4236
-        tristate "Generic Cirrus Logic CS4236+ driver"
+        tristate "Generic Cirrus Logic CS4232/CS4236+ driver"
         select SND_OPL3_LIB
         select SND_MPU401_UART
         select SND_WSS_LIB
         help
-          Say Y to include support for CS4235,CS4236,CS4237B,CS4238B,
-          CS4239 chips from Cirrus Logic - Crystal Semiconductors.
+          Say Y to include support for CS4232,CS4235,CS4236,CS4237B,
+          CS4238B,CS4239 chips from Cirrus Logic - Crystal
+          Semiconductors.
 
           To compile this driver as a module, choose M here: the module
           will be called snd-cs4236.
@@ -377,14 +368,17 @@ config SND_SGALAXY
           will be called snd-sgalaxy.
 
 config SND_SSCAPE
-        tristate "Ensoniq SoundScape PnP driver"
+        tristate "Ensoniq SoundScape driver"
         select SND_HWDEP
         select SND_MPU401_UART
         select SND_WSS_LIB
         help
-          Say Y here to include support for Ensoniq SoundScape PnP
+          Say Y here to include support for Ensoniq SoundScape 
           soundcards.
 
+          The PCM audio is supported on SoundScape Classic, Elite, PnP
+          and VIVO cards. The MIDI support is very experimental.
+
           To compile this driver as a module, choose M here: the module
           will be called snd-sscape.
 
@@ -401,15 +395,36 @@ config SND_WAVEFRONT
           To compile this driver as a module, choose M here: the module
           will be called snd-wavefront.
 
-config SND_WAVEFRONT_FIRMWARE_IN_KERNEL
-        bool "In-kernel firmware for Wavefront"
-        depends on SND_WAVEFRONT
-        default y
+config SND_MSND_PINNACLE
+        tristate "Turtle Beach MultiSound Pinnacle/Fiji driver"
+        depends on X86 && EXPERIMENTAL
+        select FW_LOADER
+        select SND_MPU401_UART
+        select SND_PCM
+        help
+          Say Y to include support for Turtle Beach MultiSound Pinnacle/
+          Fiji soundcards.
+
+          To compile this driver as a module, choose M here: the module
+          will be called snd-msnd-pinnacle.
+
+config SND_MSND_CLASSIC
+        tristate "Support for Turtle Beach MultiSound Classic, Tahiti, Monterey"
+        depends on X86 && EXPERIMENTAL
+        select FW_LOADER
+        select SND_MPU401_UART
+        select SND_PCM
         help
-          Say Y here to include the static firmware for FX DSP built in
-          the kernel for the Wavefront driver.  If you choose N here,
-          you need to install the firmware files from the
-          alsa-firmware package.
+          Say M here if you have a Turtle Beach MultiSound Classic, Tahiti or
+          Monterey (not for the Pinnacle or Fiji).
+
+          See <file:Documentation/sound/oss/MultiSound> for important information
+          about this driver.  Note that it has been discontinued, but the
+          Voyetra Turtle Beach knowledge base entry for it is still available
+          at <http://www.turtlebeach.com/site/kb_ftp/790.asp>.
+
+          To compile this driver as a module, choose M here: the module
+          will be called snd-msnd-classic.
 
 endif   # SND_ISA
 
diff --git a/sound/isa/Makefile b/sound/isa/Makefile
index 63af13d901a5..b906b9a1a81e 100644
--- a/sound/isa/Makefile
+++ b/sound/isa/Makefile
@@ -26,5 +26,5 @@ obj-$(CONFIG_SND_SC6000) += snd-sc6000.o
 obj-$(CONFIG_SND_SGALAXY) += snd-sgalaxy.o
 obj-$(CONFIG_SND_SSCAPE) += snd-sscape.o
 
-obj-$(CONFIG_SND) += ad1816a/ ad1848/ cs423x/ es1688/ gus/ opti9xx/ \
+obj-$(CONFIG_SND) += ad1816a/ ad1848/ cs423x/ es1688/ gus/ msnd/ opti9xx/ \
                      sb/ wavefront/ wss/
diff --git a/sound/isa/ad1816a/ad1816a.c b/sound/isa/ad1816a/ad1816a.c
index 9660e598232c..bbcbf92a8ebe 100644
--- a/sound/isa/ad1816a/ad1816a.c
+++ b/sound/isa/ad1816a/ad1816a.c
@@ -156,6 +156,7 @@ static int __devinit snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard
         struct snd_card_ad1816a *acard;
         struct snd_ad1816a *chip;
         struct snd_opl3 *opl3;
+        struct snd_timer *timer;
 
         error = snd_card_create(index[dev], id[dev], THIS_MODULE,
                                 sizeof(struct snd_card_ad1816a), &card);
@@ -195,6 +196,12 @@ static int __devinit snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard
                 return error;
         }
 
+        error = snd_ad1816a_timer(chip, 0, &timer);
+        if (error < 0) {
+                snd_card_free(card);
+                return error;
+        }
+
         if (mpu_port[dev] > 0) {
                 if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
                                         mpu_port[dev], 0, mpu_irq[dev], IRQF_DISABLED,
@@ -208,11 +215,8 @@ static int __devinit snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard
                                     OPL3_HW_AUTO, 0, &opl3) < 0) {
                         printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx.\n", fm_port[dev], fm_port[dev] + 2);
                 } else {
-                        if ((error = snd_opl3_timer_new(opl3, 1, 2)) < 0) {
-                                snd_card_free(card);
-                                return error;
-                        }
-                        if ((error = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
+                        error = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
+                        if (error < 0) {
                                 snd_card_free(card);
                                 return error;
                         }
diff --git a/sound/isa/ad1816a/ad1816a_lib.c b/sound/isa/ad1816a/ad1816a_lib.c
index 3bfca7c59baf..05aef8b97e96 100644
--- a/sound/isa/ad1816a/ad1816a_lib.c
+++ b/sound/isa/ad1816a/ad1816a_lib.c
@@ -37,7 +37,7 @@ static inline int snd_ad1816a_busy_wait(struct snd_ad1816a *chip)
                 if (inb(AD1816A_REG(AD1816A_CHIP_STATUS)) & AD1816A_READY)
                         return 0;
 
-        snd_printk("chip busy.\n");
+        snd_printk(KERN_WARNING "chip busy.\n");
         return -EBUSY;
 }
 
@@ -196,7 +196,7 @@ static int snd_ad1816a_trigger(struct snd_ad1816a *chip, unsigned char what,
                 spin_unlock(&chip->lock);
                 break;
         default:
-                snd_printk("invalid trigger mode 0x%x.\n", what);
+                snd_printk(KERN_WARNING "invalid trigger mode 0x%x.\n", what);
                 error = -EINVAL;
         }
 
@@ -377,7 +377,6 @@ static struct snd_pcm_hardware snd_ad1816a_capture = {
         .fifo_size =            0,
 };
 
-#if 0 /* not used now */
 static int snd_ad1816a_timer_close(struct snd_timer *timer)
 {
         struct snd_ad1816a *chip = snd_timer_chip(timer);
@@ -442,8 +441,6 @@ static struct snd_timer_hardware snd_ad1816a_timer_table = {
         .start =        snd_ad1816a_timer_start,
         .stop =         snd_ad1816a_timer_stop,
 };
-#endif /* not used now */
-
 
 static int snd_ad1816a_playback_open(struct snd_pcm_substream *substream)
 {
@@ -568,7 +565,7 @@ static const char __devinit *snd_ad1816a_chip_id(struct snd_ad1816a *chip)
         case AD1816A_HW_AD1815: return "AD1815";
         case AD1816A_HW_AD18MAX10: return "AD18max10";
         default:
-                snd_printk("Unknown chip version %d:%d.\n",
+                snd_printk(KERN_WARNING "Unknown chip version %d:%d.\n",
                         chip->version, chip->hardware);
                 return "AD1816A - unknown";
         }
@@ -687,7 +684,6 @@ int __devinit snd_ad1816a_pcm(struct snd_ad1816a *chip, int device, struct snd_p
         return 0;
 }
 
-#if 0 /* not used now */
 int __devinit snd_ad1816a_timer(struct snd_ad1816a *chip, int device, struct snd_timer **rtimer)
 {
         struct snd_timer *timer;
@@ -709,7 +705,6 @@ int __devinit snd_ad1816a_timer(struct snd_ad1816a *chip, int device, struct snd
                 *rtimer = timer;
         return 0;
 }
-#endif /* not used now */
 
 /*
  *
diff --git a/sound/isa/cmi8330.c b/sound/isa/cmi8330.c
index 24e60902f8ca..de83608719ea 100644
--- a/sound/isa/cmi8330.c
+++ b/sound/isa/cmi8330.c
@@ -31,11 +31,11 @@
  *  To quickly load the module,
  *
  *  modprobe -a snd-cmi8330 sbport=0x220 sbirq=5 sbdma8=1
- *    sbdma16=5 wssport=0x530 wssirq=11 wssdma=0
+ *    sbdma16=5 wssport=0x530 wssirq=11 wssdma=0 fmport=0x388
  *
  *  This card has two mixers and two PCM devices.  I've cheesed it such
  *  that recording and playback can be done through the same device.
- *  The driver "magically" routes the capturing to the AD1848 codec,
+ *  The driver "magically" routes the capturing to the CMI8330 codec,
  *  and playback to the SB16 codec.  This allows for full-duplex mode
  *  to some extent.
  *  The utilities in alsa-utils are aware of both devices, so passing
@@ -51,6 +51,8 @@
 #include <linux/moduleparam.h>
 #include <sound/core.h>
 #include <sound/wss.h>
+#include <sound/opl3.h>
+#include <sound/mpu401.h>
 #include <sound/sb.h>
 #include <sound/initval.h>
 
@@ -79,6 +81,9 @@ static int sbdma16[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
 static long wssport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 static int wssirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
 static int wssdma[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
+static long fmport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static long mpuport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static int mpuirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for CMI8330 soundcard.");
@@ -107,6 +112,12 @@ MODULE_PARM_DESC(wssirq, "IRQ # for CMI8330 WSS driver.");
 module_param_array(wssdma, int, NULL, 0444);
 MODULE_PARM_DESC(wssdma, "DMA for CMI8330 WSS driver.");
 
+module_param_array(fmport, long, NULL, 0444);
+MODULE_PARM_DESC(fmport, "FM port # for CMI8330 driver.");
+module_param_array(mpuport, long, NULL, 0444);
+MODULE_PARM_DESC(mpuport, "MPU-401 port # for CMI8330 driver.");
+module_param_array(mpuirq, int, NULL, 0444);
+MODULE_PARM_DESC(mpuirq, "IRQ # for CMI8330 MPU-401 port.");
 #ifdef CONFIG_PNP
 static int isa_registered;
 static int pnp_registered;
@@ -149,6 +160,7 @@ struct snd_cmi8330 {
 #ifdef CONFIG_PNP
         struct pnp_dev *cap;
         struct pnp_dev *play;
+        struct pnp_dev *mpu;
 #endif
         struct snd_card *card;
         struct snd_wss *wss;
@@ -165,7 +177,7 @@ struct snd_cmi8330 {
 #ifdef CONFIG_PNP
 
 static struct pnp_card_device_id snd_cmi8330_pnpids[] = {
-        { .id = "CMI0001", .devs = { { "@@@0001" }, { "@X@0001" } } },
+        { .id = "CMI0001", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } } },
         { .id = "" }
 };
 
@@ -219,8 +231,10 @@ WSS_SINGLE("3D Control - Switch", 0,
                 CMI8330_RMUX3D, 5, 1, 1),
 WSS_SINGLE("PC Speaker Playback Volume", 0,
                 CMI8330_OUTPUTVOL, 3, 3, 0),
-WSS_SINGLE("FM Playback Switch", 0,
-                CMI8330_RECMUX, 3, 1, 1),
+WSS_DOUBLE("FM Playback Switch", 0,
+                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
+WSS_DOUBLE("FM Playback Volume", 0,
+                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1),
 WSS_SINGLE(SNDRV_CTL_NAME_IEC958("Input ", CAPTURE, SWITCH), 0,
                 CMI8330_RMUX3D, 7, 1, 1),
 WSS_SINGLE(SNDRV_CTL_NAME_IEC958("Input ", PLAYBACK, SWITCH), 0,
@@ -323,16 +337,21 @@ static int __devinit snd_cmi8330_pnp(int dev, struct snd_cmi8330 *acard,
         if (acard->play == NULL)
                 return -EBUSY;
 
+        acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL);
+        if (acard->play == NULL)
+                return -EBUSY;
+
         pdev = acard->cap;
 
         err = pnp_activate_dev(pdev);
         if (err < 0) {
-                snd_printk(KERN_ERR "CMI8330/C3D (AD1848) PnP configure failure\n");
+                snd_printk(KERN_ERR "CMI8330/C3D PnP configure failure\n");
                 return -EBUSY;
         }
         wssport[dev] = pnp_port_start(pdev, 0);
         wssdma[dev] = pnp_dma(pdev, 0);
         wssirq[dev] = pnp_irq(pdev, 0);
+        fmport[dev] = pnp_port_start(pdev, 1);
 
         /* allocate SB16 resources */
         pdev = acard->play;
@@ -347,6 +366,17 @@ static int __devinit snd_cmi8330_pnp(int dev, struct snd_cmi8330 *acard,
         sbdma16[dev] = pnp_dma(pdev, 1);
         sbirq[dev] = pnp_irq(pdev, 0);
 
+        /* allocate MPU-401 resources */
+        pdev = acard->mpu;
+
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR
+                           "CMI8330/C3D (MPU-401) PnP configure failure\n");
+                return -EBUSY;
+        }
+        mpuport[dev] = pnp_port_start(pdev, 0);
+        mpuirq[dev] = pnp_irq(pdev, 0);
         return 0;
 }
 #endif
@@ -489,6 +519,7 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev)
 {
         struct snd_cmi8330 *acard;
         int i, err;
+        struct snd_opl3 *opl3;
 
         acard = card->private_data;
         err = snd_wss_create(card, wssport[dev] + 4, -1,
@@ -496,11 +527,11 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev)
                              wssdma[dev], -1,
                              WSS_HW_DETECT, 0, &acard->wss);
         if (err < 0) {
-                snd_printk(KERN_ERR PFX "(AD1848) device busy??\n");
+                snd_printk(KERN_ERR PFX "(CMI8330) device busy??\n");
                 return err;
         }
         if (acard->wss->hardware != WSS_HW_CMI8330) {
-                snd_printk(KERN_ERR PFX "(AD1848) not found during probe\n");
+                snd_printk(KERN_ERR PFX "(CMI8330) not found during probe\n");
                 return -ENODEV;
         }
 
@@ -532,6 +563,27 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev)
                 snd_printk(KERN_ERR PFX "failed to create pcms\n");
                 return err;
         }
+        if (fmport[dev] != SNDRV_AUTO_PORT) {
+                if (snd_opl3_create(card,
+                                    fmport[dev], fmport[dev] + 2,
+                                    OPL3_HW_AUTO, 0, &opl3) < 0) {
+                        snd_printk(KERN_ERR PFX
+                                   "no OPL device at 0x%lx-0x%lx ?\n",
+                                   fmport[dev], fmport[dev] + 2);
+                } else {
+                        err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
+                        if (err < 0)
+                                return err;
+                }
+        }
+
+        if (mpuport[dev] != SNDRV_AUTO_PORT) {
+                if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
+                                        mpuport[dev], 0, mpuirq[dev],
+                                        IRQF_DISABLED, NULL) < 0)
+                        printk(KERN_ERR PFX "no MPU-401 device at 0x%lx.\n",
+                                mpuport[dev]);
+        }
 
         strcpy(card->driver, "CMI8330/C3D");
         strcpy(card->shortname, "C-Media CMI8330/C3D");
diff --git a/sound/isa/cs423x/Makefile b/sound/isa/cs423x/Makefile
index 5870ca21ab59..6d397e8d54ac 100644
--- a/sound/isa/cs423x/Makefile
+++ b/sound/isa/cs423x/Makefile
@@ -3,13 +3,11 @@
 # Copyright (c) 2001 by Jaroslav Kysela <perex@perex.cz>
 #
 
-snd-cs4236-lib-objs := cs4236_lib.o
 snd-cs4231-objs := cs4231.o
-snd-cs4232-objs := cs4232.o
-snd-cs4236-objs := cs4236.o
+snd-cs4236-objs := cs4236.o cs4236_lib.o
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_CS4231) += snd-cs4231.o
-obj-$(CONFIG_SND_CS4232) += snd-cs4232.o
-obj-$(CONFIG_SND_CS4236) += snd-cs4236.o snd-cs4236-lib.o
+obj-$(CONFIG_SND_CS4236) += snd-cs4236.o
+
 
diff --git a/sound/isa/cs423x/cs4232.c b/sound/isa/cs423x/cs4232.c
deleted file mode 100644
index 9fad2e6c0c2c..000000000000
--- a/sound/isa/cs423x/cs4232.c
+++ /dev/null
@@ -1,2 +0,0 @@
-#define CS4232
-#include "cs4236.c"
diff --git a/sound/isa/cs423x/cs4236.c b/sound/isa/cs423x/cs4236.c
index f7845986f467..a076a6ce8071 100644
--- a/sound/isa/cs423x/cs4236.c
+++ b/sound/isa/cs423x/cs4236.c
@@ -33,17 +33,14 @@
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_LICENSE("GPL");
-#ifdef CS4232
-MODULE_DESCRIPTION("Cirrus Logic CS4232");
+MODULE_DESCRIPTION("Cirrus Logic CS4232-9");
 MODULE_SUPPORTED_DEVICE("{{Turtle Beach,TBS-2000},"
                 "{Turtle Beach,Tropez Plus},"
                 "{SIC CrystalWave 32},"
                 "{Hewlett Packard,Omnibook 5500},"
                 "{TerraTec,Maestro 32/96},"
-                "{Philips,PCA70PS}}");
-#else
-MODULE_DESCRIPTION("Cirrus Logic CS4235-9");
-MODULE_SUPPORTED_DEVICE("{{Crystal Semiconductors,CS4235},"
+                "{Philips,PCA70PS}},"
+                "{{Crystal Semiconductors,CS4235},"
                 "{Crystal Semiconductors,CS4236},"
                 "{Crystal Semiconductors,CS4237},"
                 "{Crystal Semiconductors,CS4238},"
@@ -70,15 +67,11 @@ MODULE_SUPPORTED_DEVICE("{{Crystal Semiconductors,CS4235},"
                 "{Typhoon Soundsystem,CS4236B},"
                 "{Turtle Beach,Malibu},"
                 "{Unknown,Digital PC 5000 Onboard}}");
-#endif
 
-#ifdef CS4232
-#define IDENT "CS4232"
-#define DEV_NAME "cs4232"
-#else
-#define IDENT "CS4236+"
-#define DEV_NAME "cs4236"
-#endif
+MODULE_ALIAS("snd_cs4232");
+
+#define IDENT "CS4232+"
+#define DEV_NAME "cs4232+"
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
@@ -128,9 +121,7 @@ MODULE_PARM_DESC(dma2, "DMA2 # for " IDENT " driver.");
 #ifdef CONFIG_PNP
 static int isa_registered;
 static int pnpc_registered;
-#ifdef CS4232
 static int pnp_registered;
-#endif
 #endif /* CONFIG_PNP */
 
 struct snd_card_cs4236 {
@@ -145,11 +136,10 @@ struct snd_card_cs4236 {
 
 #ifdef CONFIG_PNP
 
-#ifdef CS4232
 /*
  * PNP BIOS
  */
-static const struct pnp_device_id snd_cs4232_pnpbiosids[] = {
+static const struct pnp_device_id snd_cs423x_pnpbiosids[] = {
         { .id = "CSC0100" },
         { .id = "CSC0000" },
         /* Guillemot Turtlebeach something appears to be cs4232 compatible
@@ -157,10 +147,8 @@ static const struct pnp_device_id snd_cs4232_pnpbiosids[] = {
         { .id = "GIM0100" },
         { .id = "" }
 };
-MODULE_DEVICE_TABLE(pnp, snd_cs4232_pnpbiosids);
-#endif /* CS4232 */
+MODULE_DEVICE_TABLE(pnp, snd_cs423x_pnpbiosids);
 
-#ifdef CS4232
 #define CS423X_ISAPNP_DRIVER    "cs4232_isapnp"
 static struct pnp_card_device_id snd_cs423x_pnpids[] = {
         /* Philips PCA70PS */
@@ -179,12 +167,6 @@ static struct pnp_card_device_id snd_cs423x_pnpids[] = {
         { .id = "CSCf032", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Netfinity 3000 on-board soundcard */
         { .id = "CSCe825", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC010f" } } },
-        /* --- */
-        { .id = "" }    /* end */
-};
-#else /* CS4236 */
-#define CS423X_ISAPNP_DRIVER    "cs4236_isapnp"
-static struct pnp_card_device_id snd_cs423x_pnpids[] = {
         /* Intel Marlin Spike Motherboard - CS4235 */
         { .id = "CSC0225", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Intel Marlin Spike Motherboard (#2) - CS4235 */
@@ -266,7 +248,6 @@ static struct pnp_card_device_id snd_cs423x_pnpids[] = {
         /* --- */
         { .id = "" }    /* end */
 };
-#endif
 
 MODULE_DEVICE_TABLE(pnp_card, snd_cs423x_pnpids);
 
@@ -323,17 +304,19 @@ static int __devinit snd_cs423x_pnp_init_mpu(int dev, struct pnp_dev *pdev)
         return 0;
 }
 
-#ifdef CS4232
-static int __devinit snd_card_cs4232_pnp(int dev, struct snd_card_cs4236 *acard,
-                                         struct pnp_dev *pdev)
+static int __devinit snd_card_cs423x_pnp(int dev, struct snd_card_cs4236 *acard,
+                                         struct pnp_dev *pdev,
+                                         struct pnp_dev *cdev)
 {
         acard->wss = pdev;
         if (snd_cs423x_pnp_init_wss(dev, acard->wss) < 0)
                 return -EBUSY;
-        cport[dev] = -1;
+        if (cdev)
+                cport[dev] = pnp_port_start(cdev, 0);
+        else
+                cport[dev] = -1;
         return 0;
 }
-#endif
 
 static int __devinit snd_card_cs423x_pnpc(int dev, struct snd_card_cs4236 *acard,
                                           struct pnp_card_link *card,
@@ -411,40 +394,39 @@ static int __devinit snd_cs423x_probe(struct snd_card *card, int dev)
                         return -EBUSY;
                 }
 
-#ifdef CS4232
         err = snd_wss_create(card, port[dev], cport[dev],
                              irq[dev],
                              dma1[dev], dma2[dev],
-                             WSS_HW_DETECT, 0, &chip);
-        if (err < 0)
-                return err;
-        acard->chip = chip;
-
-        err = snd_wss_pcm(chip, 0, &pcm);
-        if (err < 0)
-                return err;
-
-        err = snd_wss_mixer(chip);
+                             WSS_HW_DETECT3, 0, &chip);
         if (err < 0)
                 return err;
-
-#else /* CS4236 */
-        err = snd_cs4236_create(card,
-                                port[dev], cport[dev],
-                                irq[dev], dma1[dev], dma2[dev],
-                                WSS_HW_DETECT, 0, &chip);
-        if (err < 0)
-                return err;
-        acard->chip = chip;
-
-        err = snd_cs4236_pcm(chip, 0, &pcm);
-        if (err < 0)
-                return err;
-
-        err = snd_cs4236_mixer(chip);
-        if (err < 0)
-                return err;
-#endif
+        if (chip->hardware & WSS_HW_CS4236B_MASK) {
+                snd_wss_free(chip);
+                err = snd_cs4236_create(card,
+                                        port[dev], cport[dev],
+                                        irq[dev], dma1[dev], dma2[dev],
+                                        WSS_HW_DETECT, 0, &chip);
+                if (err < 0)
+                        return err;
+                acard->chip = chip;
+
+                err = snd_cs4236_pcm(chip, 0, &pcm);
+                if (err < 0)
+                        return err;
+
+                err = snd_cs4236_mixer(chip);
+                if (err < 0)
+                        return err;
+        } else {
+                acard->chip = chip;
+                err = snd_wss_pcm(chip, 0, &pcm);
+                if (err < 0)
+                        return err;
+
+                err = snd_wss_mixer(chip);
+                if (err < 0)
+                        return err;
+        }
         strcpy(card->driver, pcm->name);
         strcpy(card->shortname, pcm->name);
         sprintf(card->longname, "%s at 0x%lx, irq %i, dma %i",
@@ -579,13 +561,14 @@ static struct isa_driver cs423x_isa_driver = {
 
 
 #ifdef CONFIG_PNP
-#ifdef CS4232
-static int __devinit snd_cs4232_pnpbios_detect(struct pnp_dev *pdev,
+static int __devinit snd_cs423x_pnpbios_detect(struct pnp_dev *pdev,
                                                const struct pnp_device_id *id)
 {
         static int dev;
         int err;
         struct snd_card *card;
+        struct pnp_dev *cdev;
+        char cid[PNP_ID_LEN];
 
         if (pnp_device_is_isapnp(pdev))
                 return -ENOENT; /* we have another procedure - card */
@@ -596,10 +579,19 @@ static int __devinit snd_cs4232_pnpbios_detect(struct pnp_dev *pdev,
         if (dev >= SNDRV_CARDS)
                 return -ENODEV;
 
+        /* prepare second id */
+        strcpy(cid, pdev->id[0].id);
+        cid[5] = '1';
+        cdev = NULL;
+        list_for_each_entry(cdev, &(pdev->protocol->devices), protocol_list) {
+                if (!strcmp(cdev->id[0].id, cid))
+                        break;
+        }
         err = snd_cs423x_card_new(dev, &card);
         if (err < 0)
                 return err;
-        if ((err = snd_card_cs4232_pnp(dev, card->private_data, pdev)) < 0) {
+        err = snd_card_cs423x_pnp(dev, card->private_data, pdev, cdev);
+        if (err < 0) {
                 printk(KERN_ERR "PnP BIOS detection failed for " IDENT "\n");
                 snd_card_free(card);
                 return err;
@@ -614,35 +606,34 @@ static int __devinit snd_cs4232_pnpbios_detect(struct pnp_dev *pdev,
         return 0;
 }
 
-static void __devexit snd_cs4232_pnp_remove(struct pnp_dev * pdev)
+static void __devexit snd_cs423x_pnp_remove(struct pnp_dev *pdev)
 {
         snd_card_free(pnp_get_drvdata(pdev));
         pnp_set_drvdata(pdev, NULL);
 }
 
 #ifdef CONFIG_PM
-static int snd_cs4232_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
+static int snd_cs423x_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
 {
         return snd_cs423x_suspend(pnp_get_drvdata(pdev));
 }
 
-static int snd_cs4232_pnp_resume(struct pnp_dev *pdev)
+static int snd_cs423x_pnp_resume(struct pnp_dev *pdev)
 {
         return snd_cs423x_resume(pnp_get_drvdata(pdev));
 }
 #endif
 
-static struct pnp_driver cs4232_pnp_driver = {
-        .name = "cs4232-pnpbios",
-        .id_table = snd_cs4232_pnpbiosids,
-        .probe = snd_cs4232_pnpbios_detect,
-        .remove = __devexit_p(snd_cs4232_pnp_remove),
+static struct pnp_driver cs423x_pnp_driver = {
+        .name = "cs423x-pnpbios",
+        .id_table = snd_cs423x_pnpbiosids,
+        .probe = snd_cs423x_pnpbios_detect,
+        .remove = __devexit_p(snd_cs423x_pnp_remove),
 #ifdef CONFIG_PM
-        .suspend        = snd_cs4232_pnp_suspend,
-        .resume         = snd_cs4232_pnp_resume,
+        .suspend        = snd_cs423x_pnp_suspend,
+        .resume         = snd_cs423x_pnp_resume,
 #endif
 };
-#endif /* CS4232 */
 
 static int __devinit snd_cs423x_pnpc_detect(struct pnp_card_link *pcard,
                                             const struct pnp_card_device_id *pid)
@@ -716,18 +707,14 @@ static int __init alsa_card_cs423x_init(void)
 #ifdef CONFIG_PNP
         if (!err)
                 isa_registered = 1;
-#ifdef CS4232
-        err = pnp_register_driver(&cs4232_pnp_driver);
+        err = pnp_register_driver(&cs423x_pnp_driver);
         if (!err)
                 pnp_registered = 1;
-#endif
         err = pnp_register_card_driver(&cs423x_pnpc_driver);
         if (!err)
                 pnpc_registered = 1;
-#ifdef CS4232
         if (pnp_registered)
                 err = 0;
-#endif
         if (isa_registered)
                 err = 0;
 #endif
@@ -739,10 +726,8 @@ static void __exit alsa_card_cs423x_exit(void)
 #ifdef CONFIG_PNP
         if (pnpc_registered)
                 pnp_unregister_card_driver(&cs423x_pnpc_driver);
-#ifdef CS4232
         if (pnp_registered)
-                pnp_unregister_driver(&cs4232_pnp_driver);
-#endif
+                pnp_unregister_driver(&cs423x_pnp_driver);
         if (isa_registered)
 #endif
                 isa_unregister_driver(&cs423x_isa_driver);
diff --git a/sound/isa/cs423x/cs4236_lib.c b/sound/isa/cs423x/cs4236_lib.c
index 6a85fdc53b60..38835f31298b 100644
--- a/sound/isa/cs423x/cs4236_lib.c
+++ b/sound/isa/cs423x/cs4236_lib.c
@@ -88,10 +88,6 @@
 #include <sound/wss.h>
 #include <sound/asoundef.h>
 
-MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
-MODULE_DESCRIPTION("Routines for control of CS4235/4236B/4237B/4238B/4239 chips");
-MODULE_LICENSE("GPL");
-
 /*
  *
  */
@@ -286,7 +282,8 @@ int snd_cs4236_create(struct snd_card *card,
         if (hardware == WSS_HW_DETECT)
                 hardware = WSS_HW_DETECT3;
         if (cport < 0x100) {
-                snd_printk("please, specify control port for CS4236+ chips\n");
+                snd_printk(KERN_ERR "please, specify control port "
+                           "for CS4236+ chips\n");
                 return -ENODEV;
         }
         err = snd_wss_create(card, port, cport,
@@ -295,7 +292,8 @@ int snd_cs4236_create(struct snd_card *card,
                 return err;
 
         if (!(chip->hardware & WSS_HW_CS4236B_MASK)) {
-                snd_printk("CS4236+: MODE3 and extended registers not available, hardware=0x%x\n",chip->hardware);
+                snd_printk(KERN_ERR "CS4236+: MODE3 and extended registers "
+                           "not available, hardware=0x%x\n", chip->hardware);
                 snd_device_free(card, chip);
                 return -ENODEV;
         }
@@ -303,16 +301,19 @@ int snd_cs4236_create(struct snd_card *card,
         {
                 int idx;
                 for (idx = 0; idx < 8; idx++)
-                        snd_printk("CD%i = 0x%x\n", idx, inb(chip->cport + idx));
+                        snd_printk(KERN_DEBUG "CD%i = 0x%x\n",
+                                   idx, inb(chip->cport + idx));
                 for (idx = 0; idx < 9; idx++)
-                        snd_printk("C%i = 0x%x\n", idx, snd_cs4236_ctrl_in(chip, idx));
+                        snd_printk(KERN_DEBUG "C%i = 0x%x\n",
+                                   idx, snd_cs4236_ctrl_in(chip, idx));
         }
 #endif
         ver1 = snd_cs4236_ctrl_in(chip, 1);
         ver2 = snd_cs4236_ext_in(chip, CS4236_VERSION);
         snd_printdd("CS4236: [0x%lx] C1 (version) = 0x%x, ext = 0x%x\n", cport, ver1, ver2);
         if (ver1 != ver2) {
-                snd_printk("CS4236+ chip detected, but control port 0x%lx is not valid\n", cport);
+                snd_printk(KERN_ERR "CS4236+ chip detected, but "
+                           "control port 0x%lx is not valid\n", cport);
                 snd_device_free(card, chip);
                 return -ENODEV;
         }
@@ -883,7 +884,8 @@ static int snd_cs4236_get_iec958_switch(struct snd_kcontrol *kcontrol, struct sn
         spin_lock_irqsave(&chip->reg_lock, flags);
         ucontrol->value.integer.value[0] = chip->image[CS4231_ALT_FEATURE_1] & 0x02 ? 1 : 0;
 #if 0
-        printk("get valid: ALT = 0x%x, C3 = 0x%x, C4 = 0x%x, C5 = 0x%x, C6 = 0x%x, C8 = 0x%x\n",
+        printk(KERN_DEBUG "get valid: ALT = 0x%x, C3 = 0x%x, C4 = 0x%x, "
+               "C5 = 0x%x, C6 = 0x%x, C8 = 0x%x\n",
                         snd_wss_in(chip, CS4231_ALT_FEATURE_1),
                         snd_cs4236_ctrl_in(chip, 3),
                         snd_cs4236_ctrl_in(chip, 4),
@@ -920,7 +922,8 @@ static int snd_cs4236_put_iec958_switch(struct snd_kcontrol *kcontrol, struct sn
         mutex_unlock(&chip->mce_mutex);
 
 #if 0
-        printk("set valid: ALT = 0x%x, C3 = 0x%x, C4 = 0x%x, C5 = 0x%x, C6 = 0x%x, C8 = 0x%x\n",
+        printk(KERN_DEBUG "set valid: ALT = 0x%x, C3 = 0x%x, C4 = 0x%x, "
+               "C5 = 0x%x, C6 = 0x%x, C8 = 0x%x\n",
                         snd_wss_in(chip, CS4231_ALT_FEATURE_1),
                         snd_cs4236_ctrl_in(chip, 3),
                         snd_cs4236_ctrl_in(chip, 4),
@@ -1015,23 +1018,3 @@ int snd_cs4236_mixer(struct snd_wss *chip)
         }
         return 0;
 }
-
-EXPORT_SYMBOL(snd_cs4236_create);
-EXPORT_SYMBOL(snd_cs4236_pcm);
-EXPORT_SYMBOL(snd_cs4236_mixer);
-
-/*
- *  INIT part
- */
-
-static int __init alsa_cs4236_init(void)
-{
-        return 0;
-}
-
-static void __exit alsa_cs4236_exit(void)
-{
-}
-
-module_init(alsa_cs4236_init)
-module_exit(alsa_cs4236_exit)
diff --git a/sound/isa/es1688/es1688.c b/sound/isa/es1688/es1688.c
index d746750410ea..442b081cafb7 100644
--- a/sound/isa/es1688/es1688.c
+++ b/sound/isa/es1688/es1688.c
@@ -49,6 +49,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;  /* Enable this card */
 static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* 0x220,0x240,0x260 */
+static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;  /* Usually 0x388 */
 static long mpu_port[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = -1};
 static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* 5,7,9,10 */
 static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;    /* 5,7,9,10 */
@@ -65,6 +66,8 @@ MODULE_PARM_DESC(port, "Port # for " CRD_NAME " driver.");
 module_param_array(mpu_port, long, NULL, 0444);
 MODULE_PARM_DESC(mpu_port, "MPU-401 port # for " CRD_NAME " driver.");
 module_param_array(irq, int, NULL, 0444);
+module_param_array(fm_port, long, NULL, 0444);
+MODULE_PARM_DESC(fm_port, "FM port # for ES1688 driver.");
 MODULE_PARM_DESC(irq, "IRQ # for " CRD_NAME " driver.");
 module_param_array(mpu_irq, int, NULL, 0444);
 MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ # for " CRD_NAME " driver.");
@@ -143,13 +146,19 @@ static int __devinit snd_es1688_probe(struct device *dev, unsigned int n)
         sprintf(card->longname, "%s at 0x%lx, irq %i, dma %i", pcm->name,
                 chip->port, chip->irq, chip->dma8);
 
-        if (snd_opl3_create(card, chip->port, chip->port + 2,
-                        OPL3_HW_OPL3, 0, &opl3) < 0)
-                dev_warn(dev, "opl3 not detected at 0x%lx\n", chip->port);
-        else {
-                error = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
-                if (error < 0)
-                        goto out;
+        if (fm_port[n] == SNDRV_AUTO_PORT)
+                fm_port[n] = port[n];   /* share the same port */
+
+        if (fm_port[n] > 0) {
+                if (snd_opl3_create(card, fm_port[n], fm_port[n] + 2,
+                                OPL3_HW_OPL3, 0, &opl3) < 0)
+                        dev_warn(dev,
+                                 "opl3 not detected at 0x%lx\n", fm_port[n]);
+                else {
+                        error = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
+                        if (error < 0)
+                                goto out;
+                }
         }
 
         if (mpu_irq[n] >= 0 && mpu_irq[n] != SNDRV_AUTO_IRQ &&
diff --git a/sound/isa/es1688/es1688_lib.c b/sound/isa/es1688/es1688_lib.c
index 4fbb508a817f..4c6e14f87f2d 100644
--- a/sound/isa/es1688/es1688_lib.c
+++ b/sound/isa/es1688/es1688_lib.c
@@ -45,7 +45,7 @@ static int snd_es1688_dsp_command(struct snd_es1688 *chip, unsigned char val)
                         return 1;
                 }
 #ifdef CONFIG_SND_DEBUG
-        printk("snd_es1688_dsp_command: timeout (0x%x)\n", val);
+        printk(KERN_DEBUG "snd_es1688_dsp_command: timeout (0x%x)\n", val);
 #endif
         return 0;
 }
@@ -167,13 +167,16 @@ static int snd_es1688_probe(struct snd_es1688 *chip)
         hw = ES1688_HW_AUTO;
         switch (chip->version & 0xfff0) {
         case 0x4880:
-                snd_printk("[0x%lx] ESS: AudioDrive ES488 detected, but driver is in another place\n", chip->port);
+                snd_printk(KERN_ERR "[0x%lx] ESS: AudioDrive ES488 detected, "
+                           "but driver is in another place\n", chip->port);
                 return -ENODEV;
         case 0x6880:
                 hw = (chip->version & 0x0f) >= 8 ? ES1688_HW_1688 : ES1688_HW_688;
                 break;
         default:
-                snd_printk("[0x%lx] ESS: unknown AudioDrive chip with version 0x%x (Jazz16 soundcard?)\n", chip->port, chip->version);
+                snd_printk(KERN_ERR "[0x%lx] ESS: unknown AudioDrive chip "
+                           "with version 0x%x (Jazz16 soundcard?)\n",
+                           chip->port, chip->version);
                 return -ENODEV;
         }
 
@@ -223,7 +226,7 @@ static int snd_es1688_init(struct snd_es1688 * chip, int enable)
                 }
         }
 #if 0
-        snd_printk("mpu cfg = 0x%x\n", cfg);
+        snd_printk(KERN_DEBUG "mpu cfg = 0x%x\n", cfg);
 #endif
         spin_lock_irqsave(&chip->reg_lock, flags);
         snd_es1688_mixer_write(chip, 0x40, cfg);
@@ -237,7 +240,9 @@ static int snd_es1688_init(struct snd_es1688 * chip, int enable)
                 cfg = 0xf0;     /* enable only DMA counter interrupt */
                 irq_bits = irqs[chip->irq & 0x0f];
                 if (irq_bits < 0) {
-                        snd_printk("[0x%lx] ESS: bad IRQ %d for ES1688 chip!!\n", chip->port, chip->irq);
+                        snd_printk(KERN_ERR "[0x%lx] ESS: bad IRQ %d "
+                                   "for ES1688 chip!!\n",
+                                   chip->port, chip->irq);
 #if 0
                         irq_bits = 0;
                         cfg = 0x10;
@@ -250,7 +255,8 @@ static int snd_es1688_init(struct snd_es1688 * chip, int enable)
                 cfg = 0xf0;     /* extended mode DMA enable */
                 dma = chip->dma8;
                 if (dma > 3 || dma == 2) {
-                        snd_printk("[0x%lx] ESS: bad DMA channel %d for ES1688 chip!!\n", chip->port, dma);
+                        snd_printk(KERN_ERR "[0x%lx] ESS: bad DMA channel %d "
+                                   "for ES1688 chip!!\n", chip->port, dma);
 #if 0
                         dma_bits = 0;
                         cfg = 0x00;     /* disable all DMA */
@@ -341,8 +347,9 @@ static int snd_es1688_trigger(struct snd_es1688 *chip, int cmd, unsigned char va
                 return -EINVAL; /* something is wrong */
         }
 #if 0
-        printk("trigger: val = 0x%x, value = 0x%x\n", val, value);
-        printk("trigger: pointer = 0x%x\n", snd_dma_pointer(chip->dma8, chip->dma_size));
+        printk(KERN_DEBUG "trigger: val = 0x%x, value = 0x%x\n", val, value);
+        printk(KERN_DEBUG "trigger: pointer = 0x%x\n",
+               snd_dma_pointer(chip->dma8, chip->dma_size));
 #endif
         snd_es1688_write(chip, 0xb8, (val & 0xf0) | value);
         spin_unlock(&chip->reg_lock);
diff --git a/sound/isa/gus/gus_dma.c b/sound/isa/gus/gus_dma.c
index f45f6116c77a..36c27c832360 100644
--- a/sound/isa/gus/gus_dma.c
+++ b/sound/isa/gus/gus_dma.c
@@ -45,7 +45,8 @@ static void snd_gf1_dma_program(struct snd_gus_card * gus,
         unsigned char dma_cmd;
         unsigned int address_high;
 
-        // snd_printk("dma_transfer: addr=0x%x, buf=0x%lx, count=0x%x\n", addr, (long) buf, count);
+        snd_printdd("dma_transfer: addr=0x%x, buf=0x%lx, count=0x%x\n",
+                    addr, buf_addr, count);
 
         if (gus->gf1.dma1 > 3) {
                 if (gus->gf1.enh_mode) {
@@ -77,7 +78,8 @@ static void snd_gf1_dma_program(struct snd_gus_card * gus,
         snd_gf1_dma_ack(gus);
         snd_dma_program(gus->gf1.dma1, buf_addr, count, dma_cmd & SNDRV_GF1_DMA_READ ? DMA_MODE_READ : DMA_MODE_WRITE);
 #if 0
-        snd_printk("address = 0x%x, count = 0x%x, dma_cmd = 0x%x\n", address << 1, count, dma_cmd);
+        snd_printk(KERN_DEBUG "address = 0x%x, count = 0x%x, dma_cmd = 0x%x\n",
+                   address << 1, count, dma_cmd);
 #endif
         spin_lock_irqsave(&gus->reg_lock, flags);
         if (gus->gf1.enh_mode) {
@@ -142,7 +144,9 @@ static void snd_gf1_dma_interrupt(struct snd_gus_card * gus)
         snd_gf1_dma_program(gus, block->addr, block->buf_addr, block->count, (unsigned short) block->cmd);
         kfree(block);
 #if 0
-        printk("program dma (IRQ) - addr = 0x%x, buffer = 0x%lx, count = 0x%x, cmd = 0x%x\n", addr, (long) buffer, count, cmd);
+        snd_printd(KERN_DEBUG "program dma (IRQ) - "
+                   "addr = 0x%x, buffer = 0x%lx, count = 0x%x, cmd = 0x%x\n",
+                   block->addr, block->buf_addr, block->count, block->cmd);
 #endif
 }
 
@@ -203,13 +207,16 @@ int snd_gf1_dma_transfer_block(struct snd_gus_card * gus,
         }
         *block = *__block;
         block->next = NULL;
-#if 0
-        printk("addr = 0x%x, buffer = 0x%lx, count = 0x%x, cmd = 0x%x\n", block->addr, (long) block->buffer, block->count, block->cmd);
-#endif
-#if 0
-        printk("gus->gf1.dma_data_pcm_last = 0x%lx\n", (long)gus->gf1.dma_data_pcm_last);
-        printk("gus->gf1.dma_data_pcm = 0x%lx\n", (long)gus->gf1.dma_data_pcm);
-#endif
+
+        snd_printdd("addr = 0x%x, buffer = 0x%lx, count = 0x%x, cmd = 0x%x\n",
+                    block->addr, (long) block->buffer, block->count,
+                    block->cmd);
+
+        snd_printdd("gus->gf1.dma_data_pcm_last = 0x%lx\n",
+                    (long)gus->gf1.dma_data_pcm_last);
+        snd_printdd("gus->gf1.dma_data_pcm = 0x%lx\n",
+                    (long)gus->gf1.dma_data_pcm);
+
         spin_lock_irqsave(&gus->dma_lock, flags);
         if (synth) {
                 if (gus->gf1.dma_data_synth_last) {
diff --git a/sound/isa/gus/gus_irq.c b/sound/isa/gus/gus_irq.c
index 041894ddd014..2055aff71b50 100644
--- a/sound/isa/gus/gus_irq.c
+++ b/sound/isa/gus/gus_irq.c
@@ -41,7 +41,7 @@ __again:
         if (status == 0)
                 return IRQ_RETVAL(handled);
         handled = 1;
-        // snd_printk("IRQ: status = 0x%x\n", status);
+        /* snd_printk(KERN_DEBUG "IRQ: status = 0x%x\n", status); */
         if (status & 0x02) {
                 STAT_ADD(gus->gf1.interrupt_stat_midi_in);
                 if (gus->gf1.interrupt_handler_midi_in)
@@ -65,7 +65,9 @@ __again:
                                 continue;       /* multi request */
                         already |= _current_;   /* mark request */
 #if 0
-                        printk("voice = %i, voice_status = 0x%x, voice_verify = %i\n", voice, voice_status, inb(GUSP(gus, GF1PAGE)));
+                        printk(KERN_DEBUG "voice = %i, voice_status = 0x%x, "
+                               "voice_verify = %i\n",
+                               voice, voice_status, inb(GUSP(gus, GF1PAGE)));
 #endif
                         pvoice = &gus->gf1.voices[voice]; 
                         if (pvoice->use) {
diff --git a/sound/isa/gus/gus_pcm.c b/sound/isa/gus/gus_pcm.c
index 38510aeb21c6..edb11eefdfe3 100644
--- a/sound/isa/gus/gus_pcm.c
+++ b/sound/isa/gus/gus_pcm.c
@@ -82,7 +82,10 @@ static int snd_gf1_pcm_block_change(struct snd_pcm_substream *substream,
 
         count += offset & 31;
         offset &= ~31;
-        // snd_printk("block change - offset = 0x%x, count = 0x%x\n", offset, count);
+        /*
+        snd_printk(KERN_DEBUG "block change - offset = 0x%x, count = 0x%x\n",
+                   offset, count);
+        */
         memset(&block, 0, sizeof(block));
         block.cmd = SNDRV_GF1_DMA_IRQ;
         if (snd_pcm_format_unsigned(runtime->format))
@@ -135,7 +138,11 @@ static void snd_gf1_pcm_trigger_up(struct snd_pcm_substream *substream)
                 curr = begin + (pcmp->bpos * pcmp->block_size) / runtime->channels;
                 end = curr + (pcmp->block_size / runtime->channels);
                 end -= snd_pcm_format_width(runtime->format) == 16 ? 2 : 1;
-                // snd_printk("init: curr=0x%x, begin=0x%x, end=0x%x, ctrl=0x%x, ramp=0x%x, rate=0x%x\n", curr, begin, end, voice_ctrl, ramp_ctrl, rate);
+                /*
+                snd_printk(KERN_DEBUG "init: curr=0x%x, begin=0x%x, end=0x%x, "
+                           "ctrl=0x%x, ramp=0x%x, rate=0x%x\n",
+                           curr, begin, end, voice_ctrl, ramp_ctrl, rate);
+                */
                 pan = runtime->channels == 2 ? (!voice ? 1 : 14) : 8;
                 vol = !voice ? gus->gf1.pcm_volume_level_left : gus->gf1.pcm_volume_level_right;
                 spin_lock_irqsave(&gus->reg_lock, flags);
@@ -205,9 +212,11 @@ static void snd_gf1_pcm_interrupt_wave(struct snd_gus_card * gus,
         ramp_ctrl = (snd_gf1_read8(gus, SNDRV_GF1_VB_VOLUME_CONTROL) & ~0xa4) | 0x03;
 #if 0
         snd_gf1_select_voice(gus, pvoice->number);
-        printk("position = 0x%x\n", (snd_gf1_read_addr(gus, SNDRV_GF1_VA_CURRENT, voice_ctrl & 4) >> 4));
+        printk(KERN_DEBUG "position = 0x%x\n",
+               (snd_gf1_read_addr(gus, SNDRV_GF1_VA_CURRENT, voice_ctrl & 4) >> 4));
         snd_gf1_select_voice(gus, pcmp->pvoices[1]->number);
-        printk("position = 0x%x\n", (snd_gf1_read_addr(gus, SNDRV_GF1_VA_CURRENT, voice_ctrl & 4) >> 4));
+        printk(KERN_DEBUG "position = 0x%x\n",
+               (snd_gf1_read_addr(gus, SNDRV_GF1_VA_CURRENT, voice_ctrl & 4) >> 4));
         snd_gf1_select_voice(gus, pvoice->number);
 #endif
         pcmp->bpos++;
@@ -299,7 +308,11 @@ static int snd_gf1_pcm_poke_block(struct snd_gus_card *gus, unsigned char *buf,
         unsigned int len;
         unsigned long flags;
 
-        // printk("poke block; buf = 0x%x, pos = %i, count = %i, port = 0x%x\n", (int)buf, pos, count, gus->gf1.port);
+        /*
+        printk(KERN_DEBUG
+               "poke block; buf = 0x%x, pos = %i, count = %i, port = 0x%x\n",
+               (int)buf, pos, count, gus->gf1.port);
+        */
         while (count > 0) {
                 len = count;
                 if (len > 512)          /* limit, to allow IRQ */
@@ -680,7 +693,8 @@ static int snd_gf1_pcm_playback_open(struct snd_pcm_substream *substream)
         runtime->private_free = snd_gf1_pcm_playback_free;
 
 #if 0
-        printk("playback.buffer = 0x%lx, gf1.pcm_buffer = 0x%lx\n", (long) pcm->playback.buffer, (long) gus->gf1.pcm_buffer);
+        printk(KERN_DEBUG "playback.buffer = 0x%lx, gf1.pcm_buffer = 0x%lx\n",
+               (long) pcm->playback.buffer, (long) gus->gf1.pcm_buffer);
 #endif
         if ((err = snd_gf1_dma_init(gus)) < 0)
                 return err;
diff --git a/sound/isa/gus/gus_uart.c b/sound/isa/gus/gus_uart.c
index f0af3f79b08b..21cc42e4c4be 100644
--- a/sound/isa/gus/gus_uart.c
+++ b/sound/isa/gus/gus_uart.c
@@ -129,8 +129,14 @@ static int snd_gf1_uart_input_open(struct snd_rawmidi_substream *substream)
         }
         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
 #if 0
-        snd_printk("read init - enable = %i, cmd = 0x%x, stat = 0x%x\n", gus->uart_enable, gus->gf1.uart_cmd, snd_gf1_uart_stat(gus));
-        snd_printk("[0x%x] reg (ctrl/status) = 0x%x, reg (data) = 0x%x (page = 0x%x)\n", gus->gf1.port + 0x100, inb(gus->gf1.port + 0x100), inb(gus->gf1.port + 0x101), inb(gus->gf1.port + 0x102));
+        snd_printk(KERN_DEBUG
+                   "read init - enable = %i, cmd = 0x%x, stat = 0x%x\n",
+                   gus->uart_enable, gus->gf1.uart_cmd, snd_gf1_uart_stat(gus));
+        snd_printk(KERN_DEBUG
+                   "[0x%x] reg (ctrl/status) = 0x%x, reg (data) = 0x%x "
+                   "(page = 0x%x)\n",
+                   gus->gf1.port + 0x100, inb(gus->gf1.port + 0x100),
+                   inb(gus->gf1.port + 0x101), inb(gus->gf1.port + 0x102));
 #endif
         return 0;
 }
diff --git a/sound/isa/gus/interwave.c b/sound/isa/gus/interwave.c
index 50e429a120da..534a6eced2b8 100644
--- a/sound/isa/gus/interwave.c
+++ b/sound/isa/gus/interwave.c
@@ -170,7 +170,7 @@ static void snd_interwave_i2c_setlines(struct snd_i2c_bus *bus, int ctrl, int da
         unsigned long port = bus->private_value;
 
 #if 0
-        printk("i2c_setlines - 0x%lx <- %i,%i\n", port, ctrl, data);
+        printk(KERN_DEBUG "i2c_setlines - 0x%lx <- %i,%i\n", port, ctrl, data);
 #endif
         outb((data << 1) | ctrl, port);
         udelay(10);
@@ -183,7 +183,7 @@ static int snd_interwave_i2c_getclockline(struct snd_i2c_bus *bus)
 
         res = inb(port) & 1;
 #if 0
-        printk("i2c_getclockline - 0x%lx -> %i\n", port, res);
+        printk(KERN_DEBUG "i2c_getclockline - 0x%lx -> %i\n", port, res);
 #endif
         return res;
 }
@@ -197,7 +197,7 @@ static int snd_interwave_i2c_getdataline(struct snd_i2c_bus *bus, int ack)
                 udelay(10);
         res = (inb(port) & 2) >> 1;
 #if 0
-        printk("i2c_getdataline - 0x%lx -> %i\n", port, res);
+        printk(KERN_DEBUG "i2c_getdataline - 0x%lx -> %i\n", port, res);
 #endif
         return res;
 }
@@ -342,7 +342,8 @@ static void __devinit snd_interwave_bank_sizes(struct snd_gus_card * gus, int *s
                         snd_gf1_poke(gus, local, d);
                         snd_gf1_poke(gus, local + 1, d + 1);
 #if 0
-                        printk("d = 0x%x, local = 0x%x, local + 1 = 0x%x, idx << 22 = 0x%x\n",
+                        printk(KERN_DEBUG "d = 0x%x, local = 0x%x, "
+                               "local + 1 = 0x%x, idx << 22 = 0x%x\n",
                                d,
                                snd_gf1_peek(gus, local),
                                snd_gf1_peek(gus, local + 1),
@@ -356,7 +357,8 @@ static void __devinit snd_interwave_bank_sizes(struct snd_gus_card * gus, int *s
                 }
         }
 #if 0
-        printk("sizes: %i %i %i %i\n", sizes[0], sizes[1], sizes[2], sizes[3]);
+        printk(KERN_DEBUG "sizes: %i %i %i %i\n",
+               sizes[0], sizes[1], sizes[2], sizes[3]);
 #endif
 }
 
@@ -410,12 +412,12 @@ static void __devinit snd_interwave_detect_memory(struct snd_gus_card * gus)
                 lmct = (psizes[3] << 24) | (psizes[2] << 16) |
                     (psizes[1] << 8) | psizes[0];
 #if 0
-                printk("lmct = 0x%08x\n", lmct);
+                printk(KERN_DEBUG "lmct = 0x%08x\n", lmct);
 #endif
                 for (i = 0; i < ARRAY_SIZE(lmc); i++)
                         if (lmct == lmc[i]) {
 #if 0
-                                printk("found !!! %i\n", i);
+                                printk(KERN_DEBUG "found !!! %i\n", i);
 #endif
                                 snd_gf1_write16(gus, SNDRV_GF1_GW_MEMORY_CONFIG, (snd_gf1_look16(gus, SNDRV_GF1_GW_MEMORY_CONFIG) & 0xfff0) | i);
                                 snd_interwave_bank_sizes(gus, psizes);
diff --git a/sound/isa/msnd/Makefile b/sound/isa/msnd/Makefile
new file mode 100644
index 000000000000..2171c0aa2f62
--- /dev/null
+++ b/sound/isa/msnd/Makefile
@@ -0,0 +1,9 @@
+
+snd-msnd-lib-objs := msnd.o msnd_midi.o msnd_pinnacle_mixer.o
+snd-msnd-pinnacle-objs := msnd_pinnacle.o
+snd-msnd-classic-objs := msnd_classic.o
+
+# Toplevel Module Dependency
+obj-$(CONFIG_SND_MSND_PINNACLE) += snd-msnd-pinnacle.o snd-msnd-lib.o
+obj-$(CONFIG_SND_MSND_CLASSIC) += snd-msnd-classic.o snd-msnd-lib.o
+
diff --git a/sound/isa/msnd/msnd.c b/sound/isa/msnd/msnd.c
new file mode 100644
index 000000000000..3a1526ae1729
--- /dev/null
+++ b/sound/isa/msnd/msnd.c
@@ -0,0 +1,707 @@
+/*********************************************************************
+ *
+ * 2002/06/30 Karsten Wiese:
+ *      removed kernel-version dependencies.
+ *      ripped from linux kernel 2.4.18 (OSS Implementation) by me.
+ *      In the OSS Version, this file is compiled to a separate MODULE,
+ *      that is used by the pinnacle and the classic driver.
+ *      since there is no classic driver for alsa yet (i dont have a classic
+ *      & writing one blindfold is difficult) this file's object is statically
+ *      linked into the pinnacle-driver-module for now. look for the string
+ *              "uncomment this to make this a module again"
+ *      to do guess what.
+ *
+ * the following is a copy of the 2.4.18 OSS FREE file-heading comment:
+ *
+ * msnd.c - Driver Base
+ *
+ * Turtle Beach MultiSound Sound Card Driver for Linux
+ *
+ * Copyright (C) 1998 Andrew Veliath
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ ********************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/fs.h>
+#include <linux/delay.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+
+#include "msnd.h"
+
+#define LOGNAME                 "msnd"
+
+
+void snd_msnd_init_queue(void *base, int start, int size)
+{
+        writew(PCTODSP_BASED(start), base + JQS_wStart);
+        writew(PCTODSP_OFFSET(size) - 1, base + JQS_wSize);
+        writew(0, base + JQS_wHead);
+        writew(0, base + JQS_wTail);
+}
+EXPORT_SYMBOL(snd_msnd_init_queue);
+
+static int snd_msnd_wait_TXDE(struct snd_msnd *dev)
+{
+        unsigned int io = dev->io;
+        int timeout = 1000;
+
+        while (timeout-- > 0)
+                if (inb(io + HP_ISR) & HPISR_TXDE)
+                        return 0;
+
+        return -EIO;
+}
+
+static int snd_msnd_wait_HC0(struct snd_msnd *dev)
+{
+        unsigned int io = dev->io;
+        int timeout = 1000;
+
+        while (timeout-- > 0)
+                if (!(inb(io + HP_CVR) & HPCVR_HC))
+                        return 0;
+
+        return -EIO;
+}
+
+int snd_msnd_send_dsp_cmd(struct snd_msnd *dev, u8 cmd)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->lock, flags);
+        if (snd_msnd_wait_HC0(dev) == 0) {
+                outb(cmd, dev->io + HP_CVR);
+                spin_unlock_irqrestore(&dev->lock, flags);
+                return 0;
+        }
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        snd_printd(KERN_ERR LOGNAME ": Send DSP command timeout\n");
+
+        return -EIO;
+}
+EXPORT_SYMBOL(snd_msnd_send_dsp_cmd);
+
+int snd_msnd_send_word(struct snd_msnd *dev, unsigned char high,
+                   unsigned char mid, unsigned char low)
+{
+        unsigned int io = dev->io;
+
+        if (snd_msnd_wait_TXDE(dev) == 0) {
+                outb(high, io + HP_TXH);
+                outb(mid, io + HP_TXM);
+                outb(low, io + HP_TXL);
+                return 0;
+        }
+
+        snd_printd(KERN_ERR LOGNAME ": Send host word timeout\n");
+
+        return -EIO;
+}
+EXPORT_SYMBOL(snd_msnd_send_word);
+
+int snd_msnd_upload_host(struct snd_msnd *dev, const u8 *bin, int len)
+{
+        int i;
+
+        if (len % 3 != 0) {
+                snd_printk(KERN_ERR LOGNAME
+                           ": Upload host data not multiple of 3!\n");
+                return -EINVAL;
+        }
+
+        for (i = 0; i < len; i += 3)
+                if (snd_msnd_send_word(dev, bin[i], bin[i + 1], bin[i + 2]))
+                        return -EIO;
+
+        inb(dev->io + HP_RXL);
+        inb(dev->io + HP_CVR);
+
+        return 0;
+}
+EXPORT_SYMBOL(snd_msnd_upload_host);
+
+int snd_msnd_enable_irq(struct snd_msnd *dev)
+{
+        unsigned long flags;
+
+        if (dev->irq_ref++)
+                return 0;
+
+        snd_printdd(LOGNAME ": Enabling IRQ\n");
+
+        spin_lock_irqsave(&dev->lock, flags);
+        if (snd_msnd_wait_TXDE(dev) == 0) {
+                outb(inb(dev->io + HP_ICR) | HPICR_TREQ, dev->io + HP_ICR);
+                if (dev->type == msndClassic)
+                        outb(dev->irqid, dev->io + HP_IRQM);
+
+                outb(inb(dev->io + HP_ICR) & ~HPICR_TREQ, dev->io + HP_ICR);
+                outb(inb(dev->io + HP_ICR) | HPICR_RREQ, dev->io + HP_ICR);
+                enable_irq(dev->irq);
+                snd_msnd_init_queue(dev->DSPQ, dev->dspq_data_buff,
+                                    dev->dspq_buff_size);
+                spin_unlock_irqrestore(&dev->lock, flags);
+                return 0;
+        }
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        snd_printd(KERN_ERR LOGNAME ": Enable IRQ failed\n");
+
+        return -EIO;
+}
+EXPORT_SYMBOL(snd_msnd_enable_irq);
+
+int snd_msnd_disable_irq(struct snd_msnd *dev)
+{
+        unsigned long flags;
+
+        if (--dev->irq_ref > 0)
+                return 0;
+
+        if (dev->irq_ref < 0)
+                snd_printd(KERN_WARNING LOGNAME ": IRQ ref count is %d\n",
+                           dev->irq_ref);
+
+        snd_printdd(LOGNAME ": Disabling IRQ\n");
+
+        spin_lock_irqsave(&dev->lock, flags);
+        if (snd_msnd_wait_TXDE(dev) == 0) {
+                outb(inb(dev->io + HP_ICR) & ~HPICR_RREQ, dev->io + HP_ICR);
+                if (dev->type == msndClassic)
+                        outb(HPIRQ_NONE, dev->io + HP_IRQM);
+                disable_irq(dev->irq);
+                spin_unlock_irqrestore(&dev->lock, flags);
+                return 0;
+        }
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        snd_printd(KERN_ERR LOGNAME ": Disable IRQ failed\n");
+
+        return -EIO;
+}
+EXPORT_SYMBOL(snd_msnd_disable_irq);
+
+static inline long get_play_delay_jiffies(struct snd_msnd *chip, long size)
+{
+        long tmp = (size * HZ * chip->play_sample_size) / 8;
+        return tmp / (chip->play_sample_rate * chip->play_channels);
+}
+
+static void snd_msnd_dsp_write_flush(struct snd_msnd *chip)
+{
+        if (!(chip->mode & FMODE_WRITE) || !test_bit(F_WRITING, &chip->flags))
+                return;
+        set_bit(F_WRITEFLUSH, &chip->flags);
+/*      interruptible_sleep_on_timeout(
+                &chip->writeflush,
+                get_play_delay_jiffies(&chip, chip->DAPF.len));*/
+        clear_bit(F_WRITEFLUSH, &chip->flags);
+        if (!signal_pending(current))
+                schedule_timeout_interruptible(
+                        get_play_delay_jiffies(chip, chip->play_period_bytes));
+        clear_bit(F_WRITING, &chip->flags);
+}
+
+void snd_msnd_dsp_halt(struct snd_msnd *chip, struct file *file)
+{
+        if ((file ? file->f_mode : chip->mode) & FMODE_READ) {
+                clear_bit(F_READING, &chip->flags);
+                snd_msnd_send_dsp_cmd(chip, HDEX_RECORD_STOP);
+                snd_msnd_disable_irq(chip);
+                if (file) {
+                        snd_printd(KERN_INFO LOGNAME
+                                   ": Stopping read for %p\n", file);
+                        chip->mode &= ~FMODE_READ;
+                }
+                clear_bit(F_AUDIO_READ_INUSE, &chip->flags);
+        }
+        if ((file ? file->f_mode : chip->mode) & FMODE_WRITE) {
+                if (test_bit(F_WRITING, &chip->flags)) {
+                        snd_msnd_dsp_write_flush(chip);
+                        snd_msnd_send_dsp_cmd(chip, HDEX_PLAY_STOP);
+                }
+                snd_msnd_disable_irq(chip);
+                if (file) {
+                        snd_printd(KERN_INFO
+                                   LOGNAME ": Stopping write for %p\n", file);
+                        chip->mode &= ~FMODE_WRITE;
+                }
+                clear_bit(F_AUDIO_WRITE_INUSE, &chip->flags);
+        }
+}
+EXPORT_SYMBOL(snd_msnd_dsp_halt);
+
+
+int snd_msnd_DARQ(struct snd_msnd *chip, int bank)
+{
+        int /*size, n,*/ timeout = 3;
+        u16 wTmp;
+        /* void *DAQD; */
+
+        /* Increment the tail and check for queue wrap */
+        wTmp = readw(chip->DARQ + JQS_wTail) + PCTODSP_OFFSET(DAQDS__size);
+        if (wTmp > readw(chip->DARQ + JQS_wSize))
+                wTmp = 0;
+        while (wTmp == readw(chip->DARQ + JQS_wHead) && timeout--)
+                udelay(1);
+
+        if (chip->capturePeriods == 2) {
+                void *pDAQ = chip->mappedbase + DARQ_DATA_BUFF +
+                             bank * DAQDS__size + DAQDS_wStart;
+                unsigned short offset = 0x3000 + chip->capturePeriodBytes;
+
+                if (readw(pDAQ) != PCTODSP_BASED(0x3000))
+                        offset = 0x3000;
+                writew(PCTODSP_BASED(offset), pDAQ);
+        }
+
+        writew(wTmp, chip->DARQ + JQS_wTail);
+
+#if 0
+        /* Get our digital audio queue struct */
+        DAQD = bank * DAQDS__size + chip->mappedbase + DARQ_DATA_BUFF;
+
+        /* Get length of data */
+        size = readw(DAQD + DAQDS_wSize);
+
+        /* Read data from the head (unprotected bank 1 access okay
+           since this is only called inside an interrupt) */
+        outb(HPBLKSEL_1, chip->io + HP_BLKS);
+        n = msnd_fifo_write(&chip->DARF,
+                            (char *)(chip->base + bank * DAR_BUFF_SIZE),
+                            size, 0);
+        if (n <= 0) {
+                outb(HPBLKSEL_0, chip->io + HP_BLKS);
+                return n;
+        }
+        outb(HPBLKSEL_0, chip->io + HP_BLKS);
+#endif
+
+        return 1;
+}
+EXPORT_SYMBOL(snd_msnd_DARQ);
+
+int snd_msnd_DAPQ(struct snd_msnd *chip, int start)
+{
+        u16     DAPQ_tail;
+        int     protect = start, nbanks = 0;
+        void    *DAQD;
+        static int play_banks_submitted;
+        /* unsigned long flags;
+        spin_lock_irqsave(&chip->lock, flags); not necessary */
+
+        DAPQ_tail = readw(chip->DAPQ + JQS_wTail);
+        while (DAPQ_tail != readw(chip->DAPQ + JQS_wHead) || start) {
+                int bank_num = DAPQ_tail / PCTODSP_OFFSET(DAQDS__size);
+
+                if (start) {
+                        start = 0;
+                        play_banks_submitted = 0;
+                }
+
+                /* Get our digital audio queue struct */
+                DAQD = bank_num * DAQDS__size + chip->mappedbase +
+                        DAPQ_DATA_BUFF;
+
+                /* Write size of this bank */
+                writew(chip->play_period_bytes, DAQD + DAQDS_wSize);
+                if (play_banks_submitted < 3)
+                        ++play_banks_submitted;
+                else if (chip->playPeriods == 2) {
+                        unsigned short offset = chip->play_period_bytes;
+
+                        if (readw(DAQD + DAQDS_wStart) != PCTODSP_BASED(0x0))
+                                offset = 0;
+
+                        writew(PCTODSP_BASED(offset), DAQD + DAQDS_wStart);
+                }
+                ++nbanks;
+
+                /* Then advance the tail */
+                /*
+                if (protect)
+                        snd_printd(KERN_INFO "B %X %lX\n",
+                                   bank_num, xtime.tv_usec);
+                */
+
+                DAPQ_tail = (++bank_num % 3) * PCTODSP_OFFSET(DAQDS__size);
+                writew(DAPQ_tail, chip->DAPQ + JQS_wTail);
+                /* Tell the DSP to play the bank */
+                snd_msnd_send_dsp_cmd(chip, HDEX_PLAY_START);
+                if (protect)
+                        if (2 == bank_num)
+                                break;
+        }
+        /*
+        if (protect)
+                snd_printd(KERN_INFO "%lX\n", xtime.tv_usec);
+        */
+        /* spin_unlock_irqrestore(&chip->lock, flags); not necessary */
+        return nbanks;
+}
+EXPORT_SYMBOL(snd_msnd_DAPQ);
+
+static void snd_msnd_play_reset_queue(struct snd_msnd *chip,
+                                      unsigned int pcm_periods,
+                                      unsigned int pcm_count)
+{
+        int     n;
+        void    *pDAQ = chip->mappedbase + DAPQ_DATA_BUFF;
+
+        chip->last_playbank = -1;
+        chip->playLimit = pcm_count * (pcm_periods - 1);
+        chip->playPeriods = pcm_periods;
+        writew(PCTODSP_OFFSET(0 * DAQDS__size), chip->DAPQ + JQS_wHead);
+        writew(PCTODSP_OFFSET(0 * DAQDS__size), chip->DAPQ + JQS_wTail);
+
+        chip->play_period_bytes = pcm_count;
+
+        for (n = 0; n < pcm_periods; ++n, pDAQ += DAQDS__size) {
+                writew(PCTODSP_BASED((u32)(pcm_count * n)),
+                        pDAQ + DAQDS_wStart);
+                writew(0, pDAQ + DAQDS_wSize);
+                writew(1, pDAQ + DAQDS_wFormat);
+                writew(chip->play_sample_size, pDAQ + DAQDS_wSampleSize);
+                writew(chip->play_channels, pDAQ + DAQDS_wChannels);
+                writew(chip->play_sample_rate, pDAQ + DAQDS_wSampleRate);
+                writew(HIMT_PLAY_DONE * 0x100 + n, pDAQ + DAQDS_wIntMsg);
+                writew(n, pDAQ + DAQDS_wFlags);
+        }
+}
+
+static void snd_msnd_capture_reset_queue(struct snd_msnd *chip,
+                                         unsigned int pcm_periods,
+                                         unsigned int pcm_count)
+{
+        int             n;
+        void            *pDAQ;
+        /* unsigned long        flags; */
+
+        /* snd_msnd_init_queue(chip->DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE); */
+
+        chip->last_recbank = 2;
+        chip->captureLimit = pcm_count * (pcm_periods - 1);
+        chip->capturePeriods = pcm_periods;
+        writew(PCTODSP_OFFSET(0 * DAQDS__size), chip->DARQ + JQS_wHead);
+        writew(PCTODSP_OFFSET(chip->last_recbank * DAQDS__size),
+                chip->DARQ + JQS_wTail);
+
+#if 0 /* Critical section: bank 1 access. this is how the OSS driver does it:*/
+        spin_lock_irqsave(&chip->lock, flags);
+        outb(HPBLKSEL_1, chip->io + HP_BLKS);
+        memset_io(chip->mappedbase, 0, DAR_BUFF_SIZE * 3);
+        outb(HPBLKSEL_0, chip->io + HP_BLKS);
+        spin_unlock_irqrestore(&chip->lock, flags);
+#endif
+
+        chip->capturePeriodBytes = pcm_count;
+        snd_printdd("snd_msnd_capture_reset_queue() %i\n", pcm_count);
+
+        pDAQ = chip->mappedbase + DARQ_DATA_BUFF;
+
+        for (n = 0; n < pcm_periods; ++n, pDAQ += DAQDS__size) {
+                u32 tmp = pcm_count * n;
+
+                writew(PCTODSP_BASED(tmp + 0x3000), pDAQ + DAQDS_wStart);
+                writew(pcm_count, pDAQ + DAQDS_wSize);
+                writew(1, pDAQ + DAQDS_wFormat);
+                writew(chip->capture_sample_size, pDAQ + DAQDS_wSampleSize);
+                writew(chip->capture_channels, pDAQ + DAQDS_wChannels);
+                writew(chip->capture_sample_rate, pDAQ + DAQDS_wSampleRate);
+                writew(HIMT_RECORD_DONE * 0x100 + n, pDAQ + DAQDS_wIntMsg);
+                writew(n, pDAQ + DAQDS_wFlags);
+        }
+}
+
+static struct snd_pcm_hardware snd_msnd_playback = {
+        .info =                 SNDRV_PCM_INFO_MMAP |
+                                SNDRV_PCM_INFO_INTERLEAVED |
+                                SNDRV_PCM_INFO_MMAP_VALID |
+                                SNDRV_PCM_INFO_BATCH,
+        .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
+        .rates =                SNDRV_PCM_RATE_8000_48000,
+        .rate_min =             8000,
+        .rate_max =             48000,
+        .channels_min =         1,
+        .channels_max =         2,
+        .buffer_bytes_max =     0x3000,
+        .period_bytes_min =     0x40,
+        .period_bytes_max =     0x1800,
+        .periods_min =          2,
+        .periods_max =          3,
+        .fifo_size =            0,
+};
+
+static struct snd_pcm_hardware snd_msnd_capture = {
+        .info =                 SNDRV_PCM_INFO_MMAP |
+                                SNDRV_PCM_INFO_INTERLEAVED |
+                                SNDRV_PCM_INFO_MMAP_VALID |
+                                SNDRV_PCM_INFO_BATCH,
+        .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
+        .rates =                SNDRV_PCM_RATE_8000_48000,
+        .rate_min =             8000,
+        .rate_max =             48000,
+        .channels_min =         1,
+        .channels_max =         2,
+        .buffer_bytes_max =     0x3000,
+        .period_bytes_min =     0x40,
+        .period_bytes_max =     0x1800,
+        .periods_min =          2,
+        .periods_max =          3,
+        .fifo_size =            0,
+};
+
+
+static int snd_msnd_playback_open(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+
+        set_bit(F_AUDIO_WRITE_INUSE, &chip->flags);
+        clear_bit(F_WRITING, &chip->flags);
+        snd_msnd_enable_irq(chip);
+
+        runtime->dma_area = chip->mappedbase;
+        runtime->dma_bytes = 0x3000;
+
+        chip->playback_substream = substream;
+        runtime->hw = snd_msnd_playback;
+        return 0;
+}
+
+static int snd_msnd_playback_close(struct snd_pcm_substream *substream)
+{
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+
+        snd_msnd_disable_irq(chip);
+        clear_bit(F_AUDIO_WRITE_INUSE, &chip->flags);
+        return 0;
+}
+
+
+static int snd_msnd_playback_hw_params(struct snd_pcm_substream *substream,
+                                        struct snd_pcm_hw_params *params)
+{
+        int     i;
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+        void    *pDAQ = chip->mappedbase + DAPQ_DATA_BUFF;
+
+        chip->play_sample_size = snd_pcm_format_width(params_format(params));
+        chip->play_channels = params_channels(params);
+        chip->play_sample_rate = params_rate(params);
+
+        for (i = 0; i < 3; ++i, pDAQ += DAQDS__size) {
+                writew(chip->play_sample_size, pDAQ + DAQDS_wSampleSize);
+                writew(chip->play_channels, pDAQ + DAQDS_wChannels);
+                writew(chip->play_sample_rate, pDAQ + DAQDS_wSampleRate);
+        }
+        /* dont do this here:
+         * snd_msnd_calibrate_adc(chip->play_sample_rate);
+         */
+
+        return 0;
+}
+
+static int snd_msnd_playback_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+        unsigned int pcm_size = snd_pcm_lib_buffer_bytes(substream);
+        unsigned int pcm_count = snd_pcm_lib_period_bytes(substream);
+        unsigned int pcm_periods = pcm_size / pcm_count;
+
+        snd_msnd_play_reset_queue(chip, pcm_periods, pcm_count);
+        chip->playDMAPos = 0;
+        return 0;
+}
+
+static int snd_msnd_playback_trigger(struct snd_pcm_substream *substream,
+                                     int cmd)
+{
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+        int     result = 0;
+
+        if (cmd == SNDRV_PCM_TRIGGER_START) {
+                snd_printdd("snd_msnd_playback_trigger(START)\n");
+                chip->banksPlayed = 0;
+                set_bit(F_WRITING, &chip->flags);
+                snd_msnd_DAPQ(chip, 1);
+        } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
+                snd_printdd("snd_msnd_playback_trigger(STop)\n");
+                /* interrupt diagnostic, comment this out later */
+                clear_bit(F_WRITING, &chip->flags);
+                snd_msnd_send_dsp_cmd(chip, HDEX_PLAY_STOP);
+        } else {
+                snd_printd(KERN_ERR "snd_msnd_playback_trigger(?????)\n");
+                result = -EINVAL;
+        }
+
+        snd_printdd("snd_msnd_playback_trigger() ENDE\n");
+        return result;
+}
+
+static snd_pcm_uframes_t
+snd_msnd_playback_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+
+        return bytes_to_frames(substream->runtime, chip->playDMAPos);
+}
+
+
+static struct snd_pcm_ops snd_msnd_playback_ops = {
+        .open =         snd_msnd_playback_open,
+        .close =        snd_msnd_playback_close,
+        .ioctl =        snd_pcm_lib_ioctl,
+        .hw_params =    snd_msnd_playback_hw_params,
+        .prepare =      snd_msnd_playback_prepare,
+        .trigger =      snd_msnd_playback_trigger,
+        .pointer =      snd_msnd_playback_pointer,
+};
+
+static int snd_msnd_capture_open(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+
+        set_bit(F_AUDIO_READ_INUSE, &chip->flags);
+        snd_msnd_enable_irq(chip);
+        runtime->dma_area = chip->mappedbase + 0x3000;
+        runtime->dma_bytes = 0x3000;
+        memset(runtime->dma_area, 0, runtime->dma_bytes);
+        chip->capture_substream = substream;
+        runtime->hw = snd_msnd_capture;
+        return 0;
+}
+
+static int snd_msnd_capture_close(struct snd_pcm_substream *substream)
+{
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+
+        snd_msnd_disable_irq(chip);
+        clear_bit(F_AUDIO_READ_INUSE, &chip->flags);
+        return 0;
+}
+
+static int snd_msnd_capture_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+        unsigned int pcm_size = snd_pcm_lib_buffer_bytes(substream);
+        unsigned int pcm_count = snd_pcm_lib_period_bytes(substream);
+        unsigned int pcm_periods = pcm_size / pcm_count;
+
+        snd_msnd_capture_reset_queue(chip, pcm_periods, pcm_count);
+        chip->captureDMAPos = 0;
+        return 0;
+}
+
+static int snd_msnd_capture_trigger(struct snd_pcm_substream *substream,
+                                    int cmd)
+{
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+
+        if (cmd == SNDRV_PCM_TRIGGER_START) {
+                chip->last_recbank = -1;
+                set_bit(F_READING, &chip->flags);
+                if (snd_msnd_send_dsp_cmd(chip, HDEX_RECORD_START) == 0)
+                        return 0;
+
+                clear_bit(F_READING, &chip->flags);
+        } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
+                clear_bit(F_READING, &chip->flags);
+                snd_msnd_send_dsp_cmd(chip, HDEX_RECORD_STOP);
+                return 0;
+        }
+        return -EINVAL;
+}
+
+
+static snd_pcm_uframes_t
+snd_msnd_capture_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+
+        return bytes_to_frames(runtime, chip->captureDMAPos);
+}
+
+
+static int snd_msnd_capture_hw_params(struct snd_pcm_substream *substream,
+                                        struct snd_pcm_hw_params *params)
+{
+        int             i;
+        struct snd_msnd *chip = snd_pcm_substream_chip(substream);
+        void            *pDAQ = chip->mappedbase + DARQ_DATA_BUFF;
+
+        chip->capture_sample_size = snd_pcm_format_width(params_format(params));
+        chip->capture_channels = params_channels(params);
+        chip->capture_sample_rate = params_rate(params);
+
+        for (i = 0; i < 3; ++i, pDAQ += DAQDS__size) {
+                writew(chip->capture_sample_size, pDAQ + DAQDS_wSampleSize);
+                writew(chip->capture_channels, pDAQ + DAQDS_wChannels);
+                writew(chip->capture_sample_rate, pDAQ + DAQDS_wSampleRate);
+        }
+        return 0;
+}
+
+
+static struct snd_pcm_ops snd_msnd_capture_ops = {
+        .open =         snd_msnd_capture_open,
+        .close =        snd_msnd_capture_close,
+        .ioctl =        snd_pcm_lib_ioctl,
+        .hw_params =    snd_msnd_capture_hw_params,
+        .prepare =      snd_msnd_capture_prepare,
+        .trigger =      snd_msnd_capture_trigger,
+        .pointer =      snd_msnd_capture_pointer,
+};
+
+
+int snd_msnd_pcm(struct snd_card *card, int device,
+                        struct snd_pcm **rpcm)
+{
+        struct snd_msnd *chip = card->private_data;
+        struct snd_pcm  *pcm;
+        int err;
+
+        err = snd_pcm_new(card, "MSNDPINNACLE", device, 1, 1, &pcm);
+        if (err < 0)
+                return err;
+
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_msnd_playback_ops);
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_msnd_capture_ops);
+
+        pcm->private_data = chip;
+        strcpy(pcm->name, "Hurricane");
+
+
+        if (rpcm)
+                *rpcm = pcm;
+        return 0;
+}
+EXPORT_SYMBOL(snd_msnd_pcm);
+
+MODULE_DESCRIPTION("Common routines for Turtle Beach Multisound drivers");
+MODULE_LICENSE("GPL");
+
diff --git a/sound/isa/msnd/msnd.h b/sound/isa/msnd/msnd.h
new file mode 100644
index 000000000000..3773e242b58e
--- /dev/null
+++ b/sound/isa/msnd/msnd.h
@@ -0,0 +1,308 @@
+/*********************************************************************
+ *
+ * msnd.h
+ *
+ * Turtle Beach MultiSound Sound Card Driver for Linux
+ *
+ * Some parts of this header file were derived from the Turtle Beach
+ * MultiSound Driver Development Kit.
+ *
+ * Copyright (C) 1998 Andrew Veliath
+ * Copyright (C) 1993 Turtle Beach Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ ********************************************************************/
+#ifndef __MSND_H
+#define __MSND_H
+
+#define DEFSAMPLERATE           44100
+#define DEFSAMPLESIZE           SNDRV_PCM_FORMAT_S16
+#define DEFCHANNELS             1
+
+#define SRAM_BANK_SIZE          0x8000
+#define SRAM_CNTL_START         0x7F00
+#define SMA_STRUCT_START        0x7F40
+
+#define DSP_BASE_ADDR           0x4000
+#define DSP_BANK_BASE           0x4000
+
+#define AGND                    0x01
+#define SIGNAL                  0x02
+
+#define EXT_DSP_BIT_DCAL        0x0001
+#define EXT_DSP_BIT_MIDI_CON    0x0002
+
+#define BUFFSIZE                0x8000
+#define HOSTQ_SIZE              0x40
+
+#define DAP_BUFF_SIZE           0x2400
+
+#define DAPQ_STRUCT_SIZE        0x10
+#define DARQ_STRUCT_SIZE        0x10
+#define DAPQ_BUFF_SIZE          (3 * 0x10)
+#define DARQ_BUFF_SIZE          (3 * 0x10)
+#define MODQ_BUFF_SIZE          0x400
+
+#define DAPQ_DATA_BUFF          0x6C00
+#define DARQ_DATA_BUFF          0x6C30
+#define MODQ_DATA_BUFF          0x6C60
+#define MIDQ_DATA_BUFF          0x7060
+
+#define DAPQ_OFFSET             SRAM_CNTL_START
+#define DARQ_OFFSET             (SRAM_CNTL_START + 0x08)
+#define MODQ_OFFSET             (SRAM_CNTL_START + 0x10)
+#define MIDQ_OFFSET             (SRAM_CNTL_START + 0x18)
+#define DSPQ_OFFSET             (SRAM_CNTL_START + 0x20)
+
+#define HP_ICR                  0x00
+#define HP_CVR                  0x01
+#define HP_ISR                  0x02
+#define HP_IVR                  0x03
+#define HP_NU                   0x04
+#define HP_INFO                 0x04
+#define HP_TXH                  0x05
+#define HP_RXH                  0x05
+#define HP_TXM                  0x06
+#define HP_RXM                  0x06
+#define HP_TXL                  0x07
+#define HP_RXL                  0x07
+
+#define HP_ICR_DEF              0x00
+#define HP_CVR_DEF              0x12
+#define HP_ISR_DEF              0x06
+#define HP_IVR_DEF              0x0f
+#define HP_NU_DEF               0x00
+
+#define HP_IRQM                 0x09
+
+#define HPR_BLRC                0x08
+#define HPR_SPR1                0x09
+#define HPR_SPR2                0x0A
+#define HPR_TCL0                0x0B
+#define HPR_TCL1                0x0C
+#define HPR_TCL2                0x0D
+#define HPR_TCL3                0x0E
+#define HPR_TCL4                0x0F
+
+#define HPICR_INIT              0x80
+#define HPICR_HM1               0x40
+#define HPICR_HM0               0x20
+#define HPICR_HF1               0x10
+#define HPICR_HF0               0x08
+#define HPICR_TREQ              0x02
+#define HPICR_RREQ              0x01
+
+#define HPCVR_HC                0x80
+
+#define HPISR_HREQ              0x80
+#define HPISR_DMA               0x40
+#define HPISR_HF3               0x10
+#define HPISR_HF2               0x08
+#define HPISR_TRDY              0x04
+#define HPISR_TXDE              0x02
+#define HPISR_RXDF              0x01
+
+#define HPIO_290                0
+#define HPIO_260                1
+#define HPIO_250                2
+#define HPIO_240                3
+#define HPIO_230                4
+#define HPIO_220                5
+#define HPIO_210                6
+#define HPIO_3E0                7
+
+#define HPMEM_NONE              0
+#define HPMEM_B000              1
+#define HPMEM_C800              2
+#define HPMEM_D000              3
+#define HPMEM_D400              4
+#define HPMEM_D800              5
+#define HPMEM_E000              6
+#define HPMEM_E800              7
+
+#define HPIRQ_NONE              0
+#define HPIRQ_5                 1
+#define HPIRQ_7                 2
+#define HPIRQ_9                 3
+#define HPIRQ_10                4
+#define HPIRQ_11                5
+#define HPIRQ_12                6
+#define HPIRQ_15                7
+
+#define HIMT_PLAY_DONE          0x00
+#define HIMT_RECORD_DONE        0x01
+#define HIMT_MIDI_EOS           0x02
+#define HIMT_MIDI_OUT           0x03
+
+#define HIMT_MIDI_IN_UCHAR      0x0E
+#define HIMT_DSP                0x0F
+
+#define HDEX_BASE               0x92
+#define HDEX_PLAY_START         (0 + HDEX_BASE)
+#define HDEX_PLAY_STOP          (1 + HDEX_BASE)
+#define HDEX_PLAY_PAUSE         (2 + HDEX_BASE)
+#define HDEX_PLAY_RESUME        (3 + HDEX_BASE)
+#define HDEX_RECORD_START       (4 + HDEX_BASE)
+#define HDEX_RECORD_STOP        (5 + HDEX_BASE)
+#define HDEX_MIDI_IN_START      (6 + HDEX_BASE)
+#define HDEX_MIDI_IN_STOP       (7 + HDEX_BASE)
+#define HDEX_MIDI_OUT_START     (8 + HDEX_BASE)
+#define HDEX_MIDI_OUT_STOP      (9 + HDEX_BASE)
+#define HDEX_AUX_REQ            (10 + HDEX_BASE)
+
+#define HDEXAR_CLEAR_PEAKS      1
+#define HDEXAR_IN_SET_POTS      2
+#define HDEXAR_AUX_SET_POTS     3
+#define HDEXAR_CAL_A_TO_D       4
+#define HDEXAR_RD_EXT_DSP_BITS  5
+
+/* Pinnacle only HDEXAR defs */
+#define HDEXAR_SET_ANA_IN       0
+#define HDEXAR_SET_SYNTH_IN     4
+#define HDEXAR_READ_DAT_IN      5
+#define HDEXAR_MIC_SET_POTS     6
+#define HDEXAR_SET_DAT_IN       7
+
+#define HDEXAR_SET_SYNTH_48     8
+#define HDEXAR_SET_SYNTH_44     9
+
+#define HIWORD(l)               ((u16)((((u32)(l)) >> 16) & 0xFFFF))
+#define LOWORD(l)               ((u16)(u32)(l))
+#define HIBYTE(w)               ((u8)(((u16)(w) >> 8) & 0xFF))
+#define LOBYTE(w)               ((u8)(w))
+#define MAKELONG(low, hi)       ((long)(((u16)(low))|(((u32)((u16)(hi)))<<16)))
+#define MAKEWORD(low, hi)       ((u16)(((u8)(low))|(((u16)((u8)(hi)))<<8)))
+
+#define PCTODSP_OFFSET(w)       (u16)((w)/2)
+#define PCTODSP_BASED(w)        (u16)(((w)/2) + DSP_BASE_ADDR)
+#define DSPTOPC_BASED(w)        (((w) - DSP_BASE_ADDR) * 2)
+
+#ifdef SLOWIO
+#  undef outb
+#  undef inb
+#  define outb                  outb_p
+#  define inb                   inb_p
+#endif
+
+/* JobQueueStruct */
+#define JQS_wStart              0x00
+#define JQS_wSize               0x02
+#define JQS_wHead               0x04
+#define JQS_wTail               0x06
+#define JQS__size               0x08
+
+/* DAQueueDataStruct */
+#define DAQDS_wStart            0x00
+#define DAQDS_wSize             0x02
+#define DAQDS_wFormat           0x04
+#define DAQDS_wSampleSize       0x06
+#define DAQDS_wChannels         0x08
+#define DAQDS_wSampleRate       0x0A
+#define DAQDS_wIntMsg           0x0C
+#define DAQDS_wFlags            0x0E
+#define DAQDS__size             0x10
+
+#include <sound/pcm.h>
+
+struct snd_msnd {
+        void __iomem            *mappedbase;
+        int                     play_period_bytes;
+        int                     playLimit;
+        int                     playPeriods;
+        int                     playDMAPos;
+        int                     banksPlayed;
+        int                     captureDMAPos;
+        int                     capturePeriodBytes;
+        int                     captureLimit;
+        int                     capturePeriods;
+        struct snd_card         *card;
+        void                    *msndmidi_mpu;
+        struct snd_rawmidi      *rmidi;
+
+        /* Hardware resources */
+        long io;
+        int memid, irqid;
+        int irq, irq_ref;
+        unsigned long base;
+
+        /* Motorola 56k DSP SMA */
+        void __iomem    *SMA;
+        void __iomem    *DAPQ;
+        void __iomem    *DARQ;
+        void __iomem    *MODQ;
+        void __iomem    *MIDQ;
+        void __iomem    *DSPQ;
+        int dspq_data_buff, dspq_buff_size;
+
+        /* State variables */
+        enum { msndClassic, msndPinnacle } type;
+        mode_t mode;
+        unsigned long flags;
+#define F_RESETTING                     0
+#define F_HAVEDIGITAL                   1
+#define F_AUDIO_WRITE_INUSE             2
+#define F_WRITING                       3
+#define F_WRITEBLOCK                    4
+#define F_WRITEFLUSH                    5
+#define F_AUDIO_READ_INUSE              6
+#define F_READING                       7
+#define F_READBLOCK                     8
+#define F_EXT_MIDI_INUSE                9
+#define F_HDR_MIDI_INUSE                10
+#define F_DISABLE_WRITE_NDELAY          11
+        spinlock_t lock;
+        spinlock_t mixer_lock;
+        int nresets;
+        unsigned recsrc;
+#define LEVEL_ENTRIES 32
+        int left_levels[LEVEL_ENTRIES];
+        int right_levels[LEVEL_ENTRIES];
+        int calibrate_signal;
+        int play_sample_size, play_sample_rate, play_channels;
+        int play_ndelay;
+        int capture_sample_size, capture_sample_rate, capture_channels;
+        int capture_ndelay;
+        u8 bCurrentMidiPatch;
+
+        int last_playbank, last_recbank;
+        struct snd_pcm_substream *playback_substream;
+        struct snd_pcm_substream *capture_substream;
+
+};
+
+void snd_msnd_init_queue(void *base, int start, int size);
+
+int snd_msnd_send_dsp_cmd(struct snd_msnd *chip, u8 cmd);
+int snd_msnd_send_word(struct snd_msnd *chip,
+                           unsigned char high,
+                           unsigned char mid,
+                           unsigned char low);
+int snd_msnd_upload_host(struct snd_msnd *chip,
+                             const u8 *bin, int len);
+int snd_msnd_enable_irq(struct snd_msnd *chip);
+int snd_msnd_disable_irq(struct snd_msnd *chip);
+void snd_msnd_dsp_halt(struct snd_msnd *chip, struct file *file);
+int snd_msnd_DAPQ(struct snd_msnd *chip, int start);
+int snd_msnd_DARQ(struct snd_msnd *chip, int start);
+int snd_msnd_pcm(struct snd_card *card, int device, struct snd_pcm **rpcm);
+
+int snd_msndmidi_new(struct snd_card *card, int device);
+void snd_msndmidi_input_read(void *mpu);
+
+void snd_msndmix_setup(struct snd_msnd *chip);
+int __devinit snd_msndmix_new(struct snd_card *card);
+int snd_msndmix_force_recsrc(struct snd_msnd *chip, int recsrc);
+#endif /* __MSND_H */
diff --git a/sound/isa/msnd/msnd_classic.c b/sound/isa/msnd/msnd_classic.c
new file mode 100644
index 000000000000..3b23a096fa4e
--- /dev/null
+++ b/sound/isa/msnd/msnd_classic.c
@@ -0,0 +1,3 @@
+/* The work is in msnd_pinnacle.c, just define MSND_CLASSIC before it. */
+#define MSND_CLASSIC
+#include "msnd_pinnacle.c"
diff --git a/sound/isa/msnd/msnd_classic.h b/sound/isa/msnd/msnd_classic.h
new file mode 100644
index 000000000000..f18d5fa5baf4
--- /dev/null
+++ b/sound/isa/msnd/msnd_classic.h
@@ -0,0 +1,129 @@
+/*********************************************************************
+ *
+ * msnd_classic.h
+ *
+ * Turtle Beach MultiSound Sound Card Driver for Linux
+ *
+ * Some parts of this header file were derived from the Turtle Beach
+ * MultiSound Driver Development Kit.
+ *
+ * Copyright (C) 1998 Andrew Veliath
+ * Copyright (C) 1993 Turtle Beach Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ ********************************************************************/
+#ifndef __MSND_CLASSIC_H
+#define __MSND_CLASSIC_H
+
+#define DSP_NUMIO                               0x10
+
+#define HP_MEMM                                 0x08
+
+#define HP_BITM                                 0x0E
+#define HP_WAIT                                 0x0D
+#define HP_DSPR                                 0x0A
+#define HP_PROR                                 0x0B
+#define HP_BLKS                                 0x0C
+
+#define HPPRORESET_OFF                          0
+#define HPPRORESET_ON                           1
+
+#define HPDSPRESET_OFF                          0
+#define HPDSPRESET_ON                           1
+
+#define HPBLKSEL_0                              0
+#define HPBLKSEL_1                              1
+
+#define HPWAITSTATE_0                           0
+#define HPWAITSTATE_1                           1
+
+#define HPBITMODE_16                            0
+#define HPBITMODE_8                             1
+
+#define HIDSP_INT_PLAY_UNDER                    0x00
+#define HIDSP_INT_RECORD_OVER                   0x01
+#define HIDSP_INPUT_CLIPPING                    0x02
+#define HIDSP_MIDI_IN_OVER                      0x10
+#define HIDSP_MIDI_OVERRUN_ERR  0x13
+
+#define TIME_PRO_RESET_DONE                     0x028A
+#define TIME_PRO_SYSEX                          0x0040
+#define TIME_PRO_RESET                          0x0032
+
+#define DAR_BUFF_SIZE                           0x2000
+
+#define MIDQ_BUFF_SIZE                          0x200
+#define DSPQ_BUFF_SIZE                          0x40
+
+#define DSPQ_DATA_BUFF                          0x7260
+
+#define MOP_SYNTH                               0x10
+#define MOP_EXTOUT                              0x32
+#define MOP_EXTTHRU                             0x02
+#define MOP_OUTMASK                             0x01
+
+#define MIP_EXTIN                               0x01
+#define MIP_SYNTH                               0x00
+#define MIP_INMASK                              0x32
+
+/* Classic SMA Common Data */
+#define SMA_wCurrPlayBytes                      0x0000
+#define SMA_wCurrRecordBytes                    0x0002
+#define SMA_wCurrPlayVolLeft                    0x0004
+#define SMA_wCurrPlayVolRight                   0x0006
+#define SMA_wCurrInVolLeft                      0x0008
+#define SMA_wCurrInVolRight                     0x000a
+#define SMA_wUser_3                             0x000c
+#define SMA_wUser_4                             0x000e
+#define SMA_dwUser_5                            0x0010
+#define SMA_dwUser_6                            0x0014
+#define SMA_wUser_7                             0x0018
+#define SMA_wReserved_A                         0x001a
+#define SMA_wReserved_B                         0x001c
+#define SMA_wReserved_C                         0x001e
+#define SMA_wReserved_D                         0x0020
+#define SMA_wReserved_E                         0x0022
+#define SMA_wReserved_F                         0x0024
+#define SMA_wReserved_G                         0x0026
+#define SMA_wReserved_H                         0x0028
+#define SMA_wCurrDSPStatusFlags                 0x002a
+#define SMA_wCurrHostStatusFlags                0x002c
+#define SMA_wCurrInputTagBits                   0x002e
+#define SMA_wCurrLeftPeak                       0x0030
+#define SMA_wCurrRightPeak                      0x0032
+#define SMA_wExtDSPbits                         0x0034
+#define SMA_bExtHostbits                        0x0036
+#define SMA_bBoardLevel                         0x0037
+#define SMA_bInPotPosRight                      0x0038
+#define SMA_bInPotPosLeft                       0x0039
+#define SMA_bAuxPotPosRight                     0x003a
+#define SMA_bAuxPotPosLeft                      0x003b
+#define SMA_wCurrMastVolLeft                    0x003c
+#define SMA_wCurrMastVolRight                   0x003e
+#define SMA_bUser_12                            0x0040
+#define SMA_bUser_13                            0x0041
+#define SMA_wUser_14                            0x0042
+#define SMA_wUser_15                            0x0044
+#define SMA_wCalFreqAtoD                        0x0046
+#define SMA_wUser_16                            0x0048
+#define SMA_wUser_17                            0x004a
+#define SMA__size                               0x004c
+
+#define INITCODEFILE            "turtlebeach/msndinit.bin"
+#define PERMCODEFILE            "turtlebeach/msndperm.bin"
+#define LONGNAME                "MultiSound (Classic/Monterey/Tahiti)"
+
+#endif /* __MSND_CLASSIC_H */
diff --git a/sound/isa/msnd/msnd_midi.c b/sound/isa/msnd/msnd_midi.c
new file mode 100644
index 000000000000..cb9aa4c4edd0
--- /dev/null
+++ b/sound/isa/msnd/msnd_midi.c
@@ -0,0 +1,180 @@
+/*
+ *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *  Copyright (c) 2009 by Krzysztof Helt
+ *  Routines for control of MPU-401 in UART mode
+ *
+ *  MPU-401 supports UART mode which is not capable generate transmit
+ *  interrupts thus output is done via polling. Also, if irq < 0, then
+ *  input is done also via polling. Do not expect good performance.
+ *
+ *
+ *   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/io.h>
+#include <linux/delay.h>
+#include <linux/ioport.h>
+#include <linux/errno.h>
+#include <sound/core.h>
+#include <sound/rawmidi.h>
+
+#include "msnd.h"
+
+#define MSNDMIDI_MODE_BIT_INPUT         0
+#define MSNDMIDI_MODE_BIT_OUTPUT                1
+#define MSNDMIDI_MODE_BIT_INPUT_TRIGGER 2
+#define MSNDMIDI_MODE_BIT_OUTPUT_TRIGGER        3
+
+struct snd_msndmidi {
+        struct snd_msnd *dev;
+
+        unsigned long mode;             /* MSNDMIDI_MODE_XXXX */
+
+        struct snd_rawmidi_substream *substream_input;
+
+        spinlock_t input_lock;
+};
+
+/*
+ * input/output open/close - protected by open_mutex in rawmidi.c
+ */
+static int snd_msndmidi_input_open(struct snd_rawmidi_substream *substream)
+{
+        struct snd_msndmidi *mpu;
+
+        snd_printdd("snd_msndmidi_input_open()\n");
+
+        mpu = substream->rmidi->private_data;
+
+        mpu->substream_input = substream;
+
+        snd_msnd_enable_irq(mpu->dev);
+
+        snd_msnd_send_dsp_cmd(mpu->dev, HDEX_MIDI_IN_START);
+        set_bit(MSNDMIDI_MODE_BIT_INPUT, &mpu->mode);
+        return 0;
+}
+
+static int snd_msndmidi_input_close(struct snd_rawmidi_substream *substream)
+{
+        struct snd_msndmidi *mpu;
+
+        mpu = substream->rmidi->private_data;
+        snd_msnd_send_dsp_cmd(mpu->dev, HDEX_MIDI_IN_STOP);
+        clear_bit(MSNDMIDI_MODE_BIT_INPUT, &mpu->mode);
+        mpu->substream_input = NULL;
+        snd_msnd_disable_irq(mpu->dev);
+        return 0;
+}
+
+static void snd_msndmidi_input_drop(struct snd_msndmidi *mpu)
+{
+        u16 tail;
+
+        tail = readw(mpu->dev->MIDQ + JQS_wTail);
+        writew(tail, mpu->dev->MIDQ + JQS_wHead);
+}
+
+/*
+ * trigger input
+ */
+static void snd_msndmidi_input_trigger(struct snd_rawmidi_substream *substream,
+                                        int up)
+{
+        unsigned long flags;
+        struct snd_msndmidi *mpu;
+
+        snd_printdd("snd_msndmidi_input_trigger(, %i)\n", up);
+
+        mpu = substream->rmidi->private_data;
+        spin_lock_irqsave(&mpu->input_lock, flags);
+        if (up) {
+                if (!test_and_set_bit(MSNDMIDI_MODE_BIT_INPUT_TRIGGER,
+                                      &mpu->mode))
+                        snd_msndmidi_input_drop(mpu);
+        } else {
+                clear_bit(MSNDMIDI_MODE_BIT_INPUT_TRIGGER, &mpu->mode);
+        }
+        spin_unlock_irqrestore(&mpu->input_lock, flags);
+        if (up)
+                snd_msndmidi_input_read(mpu);
+}
+
+void snd_msndmidi_input_read(void *mpuv)
+{
+        unsigned long flags;
+        struct snd_msndmidi *mpu = mpuv;
+        void *pwMIDQData = mpu->dev->mappedbase + MIDQ_DATA_BUFF;
+
+        spin_lock_irqsave(&mpu->input_lock, flags);
+        while (readw(mpu->dev->MIDQ + JQS_wTail) !=
+               readw(mpu->dev->MIDQ + JQS_wHead)) {
+                u16 wTmp, val;
+                val = readw(pwMIDQData + 2 * readw(mpu->dev->MIDQ + JQS_wHead));
+
+                        if (test_bit(MSNDMIDI_MODE_BIT_INPUT_TRIGGER,
+                                     &mpu->mode))
+                                snd_rawmidi_receive(mpu->substream_input,
+                                                    (unsigned char *)&val, 1);
+
+                wTmp = readw(mpu->dev->MIDQ + JQS_wHead) + 1;
+                if (wTmp > readw(mpu->dev->MIDQ + JQS_wSize))
+                        writew(0,  mpu->dev->MIDQ + JQS_wHead);
+                else
+                        writew(wTmp,  mpu->dev->MIDQ + JQS_wHead);
+        }
+        spin_unlock_irqrestore(&mpu->input_lock, flags);
+}
+EXPORT_SYMBOL(snd_msndmidi_input_read);
+
+static struct snd_rawmidi_ops snd_msndmidi_input = {
+        .open =         snd_msndmidi_input_open,
+        .close =        snd_msndmidi_input_close,
+        .trigger =      snd_msndmidi_input_trigger,
+};
+
+static void snd_msndmidi_free(struct snd_rawmidi *rmidi)
+{
+        struct snd_msndmidi *mpu = rmidi->private_data;
+        kfree(mpu);
+}
+
+int snd_msndmidi_new(struct snd_card *card, int device)
+{
+        struct snd_msnd *chip = card->private_data;
+        struct snd_msndmidi *mpu;
+        struct snd_rawmidi *rmidi;
+        int err;
+
+        err = snd_rawmidi_new(card, "MSND-MIDI", device, 1, 1, &rmidi);
+        if (err < 0)
+                return err;
+        mpu = kcalloc(1, sizeof(*mpu), GFP_KERNEL);
+        if (mpu == NULL) {
+                snd_device_free(card, rmidi);
+                return -ENOMEM;
+        }
+        mpu->dev = chip;
+        chip->msndmidi_mpu = mpu;
+        rmidi->private_data = mpu;
+        rmidi->private_free = snd_msndmidi_free;
+        spin_lock_init(&mpu->input_lock);
+        strcpy(rmidi->name, "MSND MIDI");
+        snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
+                            &snd_msndmidi_input);
+        rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
+        return 0;
+}
diff --git a/sound/isa/msnd/msnd_pinnacle.c b/sound/isa/msnd/msnd_pinnacle.c
new file mode 100644
index 000000000000..60b6abd71612
--- /dev/null
+++ b/sound/isa/msnd/msnd_pinnacle.c
@@ -0,0 +1,1238 @@
+/*********************************************************************
+ *
+ * Linux multisound pinnacle/fiji driver for ALSA.
+ *
+ * 2002/06/30 Karsten Wiese:
+ *      for now this is only used to build a pinnacle / fiji driver.
+ *      the OSS parent of this code is designed to also support
+ *      the multisound classic via the file msnd_classic.c.
+ *      to make it easier for some brave heart to implemt classic
+ *      support in alsa, i left all the MSND_CLASSIC tokens in this file.
+ *      but for now this untested & undone.
+ *
+ *
+ * ripped from linux kernel 2.4.18 by Karsten Wiese.
+ *
+ * the following is a copy of the 2.4.18 OSS FREE file-heading comment:
+ *
+ * Turtle Beach MultiSound Sound Card Driver for Linux
+ * msnd_pinnacle.c / msnd_classic.c
+ *
+ * -- If MSND_CLASSIC is defined:
+ *
+ *     -> driver for Turtle Beach Classic/Monterey/Tahiti
+ *
+ * -- Else
+ *
+ *     -> driver for Turtle Beach Pinnacle/Fiji
+ *
+ * 12-3-2000  Modified IO port validation  Steve Sycamore
+ *
+ * Copyright (C) 1998 Andrew Veliath
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ ********************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/ioport.h>
+#include <linux/firmware.h>
+#include <linux/isa.h>
+#include <linux/isapnp.h>
+#include <linux/irq.h>
+#include <linux/io.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/asound.h>
+#include <sound/pcm.h>
+#include <sound/mpu401.h>
+
+#ifdef MSND_CLASSIC
+# ifndef __alpha__
+#  define SLOWIO
+# endif
+#endif
+#include "msnd.h"
+#ifdef MSND_CLASSIC
+#  include "msnd_classic.h"
+#  define LOGNAME                       "msnd_classic"
+#else
+#  include "msnd_pinnacle.h"
+#  define LOGNAME                       "snd_msnd_pinnacle"
+#endif
+
+static void __devinit set_default_audio_parameters(struct snd_msnd *chip)
+{
+        chip->play_sample_size = DEFSAMPLESIZE;
+        chip->play_sample_rate = DEFSAMPLERATE;
+        chip->play_channels = DEFCHANNELS;
+        chip->capture_sample_size = DEFSAMPLESIZE;
+        chip->capture_sample_rate = DEFSAMPLERATE;
+        chip->capture_channels = DEFCHANNELS;
+}
+
+static void snd_msnd_eval_dsp_msg(struct snd_msnd *chip, u16 wMessage)
+{
+        switch (HIBYTE(wMessage)) {
+        case HIMT_PLAY_DONE: {
+                if (chip->banksPlayed < 3)
+                        snd_printdd("%08X: HIMT_PLAY_DONE: %i\n",
+                                (unsigned)jiffies, LOBYTE(wMessage));
+
+                if (chip->last_playbank == LOBYTE(wMessage)) {
+                        snd_printdd("chip.last_playbank == LOBYTE(wMessage)\n");
+                        break;
+                }
+                chip->banksPlayed++;
+
+                if (test_bit(F_WRITING, &chip->flags))
+                        snd_msnd_DAPQ(chip, 0);
+
+                chip->last_playbank = LOBYTE(wMessage);
+                chip->playDMAPos += chip->play_period_bytes;
+                if (chip->playDMAPos > chip->playLimit)
+                        chip->playDMAPos = 0;
+                snd_pcm_period_elapsed(chip->playback_substream);
+
+                break;
+        }
+        case HIMT_RECORD_DONE:
+                if (chip->last_recbank == LOBYTE(wMessage))
+                        break;
+                chip->last_recbank = LOBYTE(wMessage);
+                chip->captureDMAPos += chip->capturePeriodBytes;
+                if (chip->captureDMAPos > (chip->captureLimit))
+                        chip->captureDMAPos = 0;
+
+                if (test_bit(F_READING, &chip->flags))
+                        snd_msnd_DARQ(chip, chip->last_recbank);
+
+                snd_pcm_period_elapsed(chip->capture_substream);
+                break;
+
+        case HIMT_DSP:
+                switch (LOBYTE(wMessage)) {
+#ifndef MSND_CLASSIC
+                case HIDSP_PLAY_UNDER:
+#endif
+                case HIDSP_INT_PLAY_UNDER:
+                        snd_printd(KERN_WARNING LOGNAME ": Play underflow %i\n",
+                                chip->banksPlayed);
+                        if (chip->banksPlayed > 2)
+                                clear_bit(F_WRITING, &chip->flags);
+                        break;
+
+                case HIDSP_INT_RECORD_OVER:
+                        snd_printd(KERN_WARNING LOGNAME ": Record overflow\n");
+                        clear_bit(F_READING, &chip->flags);
+                        break;
+
+                default:
+                        snd_printd(KERN_WARNING LOGNAME
+                                   ": DSP message %d 0x%02x\n",
+                                   LOBYTE(wMessage), LOBYTE(wMessage));
+                        break;
+                }
+                break;
+
+        case HIMT_MIDI_IN_UCHAR:
+                if (chip->msndmidi_mpu)
+                        snd_msndmidi_input_read(chip->msndmidi_mpu);
+                break;
+
+        default:
+                snd_printd(KERN_WARNING LOGNAME ": HIMT message %d 0x%02x\n",
+                           HIBYTE(wMessage), HIBYTE(wMessage));
+                break;
+        }
+}
+
+static irqreturn_t snd_msnd_interrupt(int irq, void *dev_id)
+{
+        struct snd_msnd *chip = dev_id;
+        void *pwDSPQData = chip->mappedbase + DSPQ_DATA_BUFF;
+
+        /* Send ack to DSP */
+        /* inb(chip->io + HP_RXL); */
+
+        /* Evaluate queued DSP messages */
+        while (readw(chip->DSPQ + JQS_wTail) != readw(chip->DSPQ + JQS_wHead)) {
+                u16 wTmp;
+
+                snd_msnd_eval_dsp_msg(chip,
+                        readw(pwDSPQData + 2 * readw(chip->DSPQ + JQS_wHead)));
+
+                wTmp = readw(chip->DSPQ + JQS_wHead) + 1;
+                if (wTmp > readw(chip->DSPQ + JQS_wSize))
+                        writew(0, chip->DSPQ + JQS_wHead);
+                else
+                        writew(wTmp, chip->DSPQ + JQS_wHead);
+        }
+        /* Send ack to DSP */
+        inb(chip->io + HP_RXL);
+        return IRQ_HANDLED;
+}
+
+
+static int snd_msnd_reset_dsp(long io, unsigned char *info)
+{
+        int timeout = 100;
+
+        outb(HPDSPRESET_ON, io + HP_DSPR);
+        msleep(1);
+#ifndef MSND_CLASSIC
+        if (info)
+                *info = inb(io + HP_INFO);
+#endif
+        outb(HPDSPRESET_OFF, io + HP_DSPR);
+        msleep(1);
+        while (timeout-- > 0) {
+                if (inb(io + HP_CVR) == HP_CVR_DEF)
+                        return 0;
+                msleep(1);
+        }
+        snd_printk(KERN_ERR LOGNAME ": Cannot reset DSP\n");
+
+        return -EIO;
+}
+
+static int __devinit snd_msnd_probe(struct snd_card *card)
+{
+        struct snd_msnd *chip = card->private_data;
+        unsigned char info;
+#ifndef MSND_CLASSIC
+        char *xv, *rev = NULL;
+        char *pin = "TB Pinnacle", *fiji = "TB Fiji";
+        char *pinfiji = "TB Pinnacle/Fiji";
+#endif
+
+        if (!request_region(chip->io, DSP_NUMIO, "probing")) {
+                snd_printk(KERN_ERR LOGNAME ": I/O port conflict\n");
+                return -ENODEV;
+        }
+
+        if (snd_msnd_reset_dsp(chip->io, &info) < 0) {
+                release_region(chip->io, DSP_NUMIO);
+                return -ENODEV;
+        }
+
+#ifdef MSND_CLASSIC
+        strcpy(card->shortname, "Classic/Tahiti/Monterey");
+        strcpy(card->longname, "Turtle Beach Multisound");
+        printk(KERN_INFO LOGNAME ": %s, "
+               "I/O 0x%lx-0x%lx, IRQ %d, memory mapped to 0x%lX-0x%lX\n",
+               card->shortname,
+               chip->io, chip->io + DSP_NUMIO - 1,
+               chip->irq,
+               chip->base, chip->base + 0x7fff);
+#else
+        switch (info >> 4) {
+        case 0xf:
+                xv = "<= 1.15";
+                break;
+        case 0x1:
+                xv = "1.18/1.2";
+                break;
+        case 0x2:
+                xv = "1.3";
+                break;
+        case 0x3:
+                xv = "1.4";
+                break;
+        default:
+                xv = "unknown";
+                break;
+        }
+
+        switch (info & 0x7) {
+        case 0x0:
+                rev = "I";
+                strcpy(card->shortname, pin);
+                break;
+        case 0x1:
+                rev = "F";
+                strcpy(card->shortname, pin);
+                break;
+        case 0x2:
+                rev = "G";
+                strcpy(card->shortname, pin);
+                break;
+        case 0x3:
+                rev = "H";
+                strcpy(card->shortname, pin);
+                break;
+        case 0x4:
+                rev = "E";
+                strcpy(card->shortname, fiji);
+                break;
+        case 0x5:
+                rev = "C";
+                strcpy(card->shortname, fiji);
+                break;
+        case 0x6:
+                rev = "D";
+                strcpy(card->shortname, fiji);
+                break;
+        case 0x7:
+                rev = "A-B (Fiji) or A-E (Pinnacle)";
+                strcpy(card->shortname, pinfiji);
+                break;
+        }
+        strcpy(card->longname, "Turtle Beach Multisound Pinnacle");
+        printk(KERN_INFO LOGNAME ": %s revision %s, Xilinx version %s, "
+               "I/O 0x%lx-0x%lx, IRQ %d, memory mapped to 0x%lX-0x%lX\n",
+               card->shortname,
+               rev, xv,
+               chip->io, chip->io + DSP_NUMIO - 1,
+               chip->irq,
+               chip->base, chip->base + 0x7fff);
+#endif
+
+        release_region(chip->io, DSP_NUMIO);
+        return 0;
+}
+
+static int snd_msnd_init_sma(struct snd_msnd *chip)
+{
+        static int initted;
+        u16 mastVolLeft, mastVolRight;
+        unsigned long flags;
+
+#ifdef MSND_CLASSIC
+        outb(chip->memid, chip->io + HP_MEMM);
+#endif
+        outb(HPBLKSEL_0, chip->io + HP_BLKS);
+        /* Motorola 56k shared memory base */
+        chip->SMA = chip->mappedbase + SMA_STRUCT_START;
+
+        if (initted) {
+                mastVolLeft = readw(chip->SMA + SMA_wCurrMastVolLeft);
+                mastVolRight = readw(chip->SMA + SMA_wCurrMastVolRight);
+        } else
+                mastVolLeft = mastVolRight = 0;
+        memset_io(chip->mappedbase, 0, 0x8000);
+
+        /* Critical section: bank 1 access */
+        spin_lock_irqsave(&chip->lock, flags);
+        outb(HPBLKSEL_1, chip->io + HP_BLKS);
+        memset_io(chip->mappedbase, 0, 0x8000);
+        outb(HPBLKSEL_0, chip->io + HP_BLKS);
+        spin_unlock_irqrestore(&chip->lock, flags);
+
+        /* Digital audio play queue */
+        chip->DAPQ = chip->mappedbase + DAPQ_OFFSET;
+        snd_msnd_init_queue(chip->DAPQ, DAPQ_DATA_BUFF, DAPQ_BUFF_SIZE);
+
+        /* Digital audio record queue */
+        chip->DARQ = chip->mappedbase + DARQ_OFFSET;
+        snd_msnd_init_queue(chip->DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE);
+
+        /* MIDI out queue */
+        chip->MODQ = chip->mappedbase + MODQ_OFFSET;
+        snd_msnd_init_queue(chip->MODQ, MODQ_DATA_BUFF, MODQ_BUFF_SIZE);
+
+        /* MIDI in queue */
+        chip->MIDQ = chip->mappedbase + MIDQ_OFFSET;
+        snd_msnd_init_queue(chip->MIDQ, MIDQ_DATA_BUFF, MIDQ_BUFF_SIZE);
+
+        /* DSP -> host message queue */
+        chip->DSPQ = chip->mappedbase + DSPQ_OFFSET;
+        snd_msnd_init_queue(chip->DSPQ, DSPQ_DATA_BUFF, DSPQ_BUFF_SIZE);
+
+        /* Setup some DSP values */
+#ifndef MSND_CLASSIC
+        writew(1, chip->SMA + SMA_wCurrPlayFormat);
+        writew(chip->play_sample_size, chip->SMA + SMA_wCurrPlaySampleSize);
+        writew(chip->play_channels, chip->SMA + SMA_wCurrPlayChannels);
+        writew(chip->play_sample_rate, chip->SMA + SMA_wCurrPlaySampleRate);
+#endif
+        writew(chip->play_sample_rate, chip->SMA + SMA_wCalFreqAtoD);
+        writew(mastVolLeft, chip->SMA + SMA_wCurrMastVolLeft);
+        writew(mastVolRight, chip->SMA + SMA_wCurrMastVolRight);
+#ifndef MSND_CLASSIC
+        writel(0x00010000, chip->SMA + SMA_dwCurrPlayPitch);
+        writel(0x00000001, chip->SMA + SMA_dwCurrPlayRate);
+#endif
+        writew(0x303, chip->SMA + SMA_wCurrInputTagBits);
+
+        initted = 1;
+
+        return 0;
+}
+
+
+static int upload_dsp_code(struct snd_card *card)
+{
+        struct snd_msnd *chip = card->private_data;
+        const struct firmware *init_fw = NULL, *perm_fw = NULL;
+        int err;
+
+        outb(HPBLKSEL_0, chip->io + HP_BLKS);
+
+        err = request_firmware(&init_fw, INITCODEFILE, card->dev);
+        if (err < 0) {
+                printk(KERN_ERR LOGNAME ": Error loading " INITCODEFILE);
+                goto cleanup1;
+        }
+        err = request_firmware(&perm_fw, PERMCODEFILE, card->dev);
+        if (err < 0) {
+                printk(KERN_ERR LOGNAME ": Error loading " PERMCODEFILE);
+                goto cleanup;
+        }
+
+        memcpy_toio(chip->mappedbase, perm_fw->data, perm_fw->size);
+        if (snd_msnd_upload_host(chip, init_fw->data, init_fw->size) < 0) {
+                printk(KERN_WARNING LOGNAME ": Error uploading to DSP\n");
+                err = -ENODEV;
+                goto cleanup;
+        }
+        printk(KERN_INFO LOGNAME ": DSP firmware uploaded\n");
+        err = 0;
+
+cleanup:
+        release_firmware(perm_fw);
+cleanup1:
+        release_firmware(init_fw);
+        return err;
+}
+
+#ifdef MSND_CLASSIC
+static void reset_proteus(struct snd_msnd *chip)
+{
+        outb(HPPRORESET_ON, chip->io + HP_PROR);
+        msleep(TIME_PRO_RESET);
+        outb(HPPRORESET_OFF, chip->io + HP_PROR);
+        msleep(TIME_PRO_RESET_DONE);
+}
+#endif
+
+static int snd_msnd_initialize(struct snd_card *card)
+{
+        struct snd_msnd *chip = card->private_data;
+        int err, timeout;
+
+#ifdef MSND_CLASSIC
+        outb(HPWAITSTATE_0, chip->io + HP_WAIT);
+        outb(HPBITMODE_16, chip->io + HP_BITM);
+
+        reset_proteus(chip);
+#endif
+        err = snd_msnd_init_sma(chip);
+        if (err < 0) {
+                printk(KERN_WARNING LOGNAME ": Cannot initialize SMA\n");
+                return err;
+        }
+
+        err = snd_msnd_reset_dsp(chip->io, NULL);
+        if (err < 0)
+                return err;
+
+        err = upload_dsp_code(card);
+        if (err < 0) {
+                printk(KERN_WARNING LOGNAME ": Cannot upload DSP code\n");
+                return err;
+        }
+
+        timeout = 200;
+
+        while (readw(chip->mappedbase)) {
+                msleep(1);
+                if (!timeout--) {
+                        snd_printd(KERN_ERR LOGNAME ": DSP reset timeout\n");
+                        return -EIO;
+                }
+        }
+
+        snd_msndmix_setup(chip);
+        return 0;
+}
+
+static int snd_msnd_dsp_full_reset(struct snd_card *card)
+{
+        struct snd_msnd *chip = card->private_data;
+        int rv;
+
+        if (test_bit(F_RESETTING, &chip->flags) || ++chip->nresets > 10)
+                return 0;
+
+        set_bit(F_RESETTING, &chip->flags);
+        snd_msnd_dsp_halt(chip, NULL);  /* Unconditionally halt */
+
+        rv = snd_msnd_initialize(card);
+        if (rv)
+                printk(KERN_WARNING LOGNAME ": DSP reset failed\n");
+        snd_msndmix_force_recsrc(chip, 0);
+        clear_bit(F_RESETTING, &chip->flags);
+        return rv;
+}
+
+static int snd_msnd_dev_free(struct snd_device *device)
+{
+        snd_printdd("snd_msnd_chip_free()\n");
+        return 0;
+}
+
+static int snd_msnd_send_dsp_cmd_chk(struct snd_msnd *chip, u8 cmd)
+{
+        if (snd_msnd_send_dsp_cmd(chip, cmd) == 0)
+                return 0;
+        snd_msnd_dsp_full_reset(chip->card);
+        return snd_msnd_send_dsp_cmd(chip, cmd);
+}
+
+static int __devinit snd_msnd_calibrate_adc(struct snd_msnd *chip, u16 srate)
+{
+        snd_printdd("snd_msnd_calibrate_adc(%i)\n", srate);
+        writew(srate, chip->SMA + SMA_wCalFreqAtoD);
+        if (chip->calibrate_signal == 0)
+                writew(readw(chip->SMA + SMA_wCurrHostStatusFlags)
+                       | 0x0001, chip->SMA + SMA_wCurrHostStatusFlags);
+        else
+                writew(readw(chip->SMA + SMA_wCurrHostStatusFlags)
+                       & ~0x0001, chip->SMA + SMA_wCurrHostStatusFlags);
+        if (snd_msnd_send_word(chip, 0, 0, HDEXAR_CAL_A_TO_D) == 0 &&
+            snd_msnd_send_dsp_cmd_chk(chip, HDEX_AUX_REQ) == 0) {
+                schedule_timeout_interruptible(msecs_to_jiffies(333));
+                return 0;
+        }
+        printk(KERN_WARNING LOGNAME ": ADC calibration failed\n");
+        return -EIO;
+}
+
+/*
+ * ALSA callback function, called when attempting to open the MIDI device.
+ */
+static int snd_msnd_mpu401_open(struct snd_mpu401 *mpu)
+{
+        snd_msnd_enable_irq(mpu->private_data);
+        snd_msnd_send_dsp_cmd(mpu->private_data, HDEX_MIDI_IN_START);
+        return 0;
+}
+
+static void snd_msnd_mpu401_close(struct snd_mpu401 *mpu)
+{
+        snd_msnd_send_dsp_cmd(mpu->private_data, HDEX_MIDI_IN_STOP);
+        snd_msnd_disable_irq(mpu->private_data);
+}
+
+static long mpu_io[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
+
+static int __devinit snd_msnd_attach(struct snd_card *card)
+{
+        struct snd_msnd *chip = card->private_data;
+        int err;
+        static struct snd_device_ops ops = {
+                .dev_free =      snd_msnd_dev_free,
+                };
+
+        err = request_irq(chip->irq, snd_msnd_interrupt, 0, card->shortname,
+                          chip);
+        if (err < 0) {
+                printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", chip->irq);
+                return err;
+        }
+        request_region(chip->io, DSP_NUMIO, card->shortname);
+
+        if (!request_mem_region(chip->base, BUFFSIZE, card->shortname)) {
+                printk(KERN_ERR LOGNAME
+                        ": unable to grab memory region 0x%lx-0x%lx\n",
+                        chip->base, chip->base + BUFFSIZE - 1);
+                release_region(chip->io, DSP_NUMIO);
+                free_irq(chip->irq, chip);
+                return -EBUSY;
+        }
+        chip->mappedbase = ioremap_nocache(chip->base, 0x8000);
+        if (!chip->mappedbase) {
+                printk(KERN_ERR LOGNAME
+                        ": unable to map memory region 0x%lx-0x%lx\n",
+                        chip->base, chip->base + BUFFSIZE - 1);
+                err = -EIO;
+                goto err_release_region;
+        }
+
+        err = snd_msnd_dsp_full_reset(card);
+        if (err < 0)
+                goto err_release_region;
+
+        /* Register device */
+        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
+        if (err < 0)
+                goto err_release_region;
+
+        err = snd_msnd_pcm(card, 0, NULL);
+        if (err < 0) {
+                printk(KERN_ERR LOGNAME ": error creating new PCM device\n");
+                goto err_release_region;
+        }
+
+        err = snd_msndmix_new(card);
+        if (err < 0) {
+                printk(KERN_ERR LOGNAME ": error creating new Mixer device\n");
+                goto err_release_region;
+        }
+
+
+        if (mpu_io[0] != SNDRV_AUTO_PORT) {
+                struct snd_mpu401 *mpu;
+
+                err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
+                                          mpu_io[0],
+                                          MPU401_MODE_INPUT |
+                                          MPU401_MODE_OUTPUT,
+                                          mpu_irq[0], IRQF_DISABLED,
+                                          &chip->rmidi);
+                if (err < 0) {
+                        printk(KERN_ERR LOGNAME
+                                ": error creating new Midi device\n");
+                        goto err_release_region;
+                }
+                mpu = chip->rmidi->private_data;
+
+                mpu->open_input = snd_msnd_mpu401_open;
+                mpu->close_input = snd_msnd_mpu401_close;
+                mpu->private_data = chip;
+        }
+
+        disable_irq(chip->irq);
+        snd_msnd_calibrate_adc(chip, chip->play_sample_rate);
+        snd_msndmix_force_recsrc(chip, 0);
+
+        err = snd_card_register(card);
+        if (err < 0)
+                goto err_release_region;
+
+        return 0;
+
+err_release_region:
+        if (chip->mappedbase)
+                iounmap(chip->mappedbase);
+        release_mem_region(chip->base, BUFFSIZE);
+        release_region(chip->io, DSP_NUMIO);
+        free_irq(chip->irq, chip);
+        return err;
+}
+
+
+static void __devexit snd_msnd_unload(struct snd_card *card)
+{
+        struct snd_msnd *chip = card->private_data;
+
+        iounmap(chip->mappedbase);
+        release_mem_region(chip->base, BUFFSIZE);
+        release_region(chip->io, DSP_NUMIO);
+        free_irq(chip->irq, chip);
+        snd_card_free(card);
+}
+
+#ifndef MSND_CLASSIC
+
+/* Pinnacle/Fiji Logical Device Configuration */
+
+static int __devinit snd_msnd_write_cfg(int cfg, int reg, int value)
+{
+        outb(reg, cfg);
+        outb(value, cfg + 1);
+        if (value != inb(cfg + 1)) {
+                printk(KERN_ERR LOGNAME ": snd_msnd_write_cfg: I/O error\n");
+                return -EIO;
+        }
+        return 0;
+}
+
+static int __devinit snd_msnd_write_cfg_io0(int cfg, int num, u16 io)
+{
+        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
+                return -EIO;
+        if (snd_msnd_write_cfg(cfg, IREG_IO0_BASEHI, HIBYTE(io)))
+                return -EIO;
+        if (snd_msnd_write_cfg(cfg, IREG_IO0_BASELO, LOBYTE(io)))
+                return -EIO;
+        return 0;
+}
+
+static int __devinit snd_msnd_write_cfg_io1(int cfg, int num, u16 io)
+{
+        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
+                return -EIO;
+        if (snd_msnd_write_cfg(cfg, IREG_IO1_BASEHI, HIBYTE(io)))
+                return -EIO;
+        if (snd_msnd_write_cfg(cfg, IREG_IO1_BASELO, LOBYTE(io)))
+                return -EIO;
+        return 0;
+}
+
+static int __devinit snd_msnd_write_cfg_irq(int cfg, int num, u16 irq)
+{
+        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
+                return -EIO;
+        if (snd_msnd_write_cfg(cfg, IREG_IRQ_NUMBER, LOBYTE(irq)))
+                return -EIO;
+        if (snd_msnd_write_cfg(cfg, IREG_IRQ_TYPE, IRQTYPE_EDGE))
+                return -EIO;
+        return 0;
+}
+
+static int __devinit snd_msnd_write_cfg_mem(int cfg, int num, int mem)
+{
+        u16 wmem;
+
+        mem >>= 8;
+        wmem = (u16)(mem & 0xfff);
+        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
+                return -EIO;
+        if (snd_msnd_write_cfg(cfg, IREG_MEMBASEHI, HIBYTE(wmem)))
+                return -EIO;
+        if (snd_msnd_write_cfg(cfg, IREG_MEMBASELO, LOBYTE(wmem)))
+                return -EIO;
+        if (wmem && snd_msnd_write_cfg(cfg, IREG_MEMCONTROL,
+                                       MEMTYPE_HIADDR | MEMTYPE_16BIT))
+                return -EIO;
+        return 0;
+}
+
+static int __devinit snd_msnd_activate_logical(int cfg, int num)
+{
+        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
+                return -EIO;
+        if (snd_msnd_write_cfg(cfg, IREG_ACTIVATE, LD_ACTIVATE))
+                return -EIO;
+        return 0;
+}
+
+static int __devinit snd_msnd_write_cfg_logical(int cfg, int num, u16 io0,
+                                                u16 io1, u16 irq, int mem)
+{
+        if (snd_msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
+                return -EIO;
+        if (snd_msnd_write_cfg_io0(cfg, num, io0))
+                return -EIO;
+        if (snd_msnd_write_cfg_io1(cfg, num, io1))
+                return -EIO;
+        if (snd_msnd_write_cfg_irq(cfg, num, irq))
+                return -EIO;
+        if (snd_msnd_write_cfg_mem(cfg, num, mem))
+                return -EIO;
+        if (snd_msnd_activate_logical(cfg, num))
+                return -EIO;
+        return 0;
+}
+
+static int __devinit snd_msnd_pinnacle_cfg_reset(int cfg)
+{
+        int i;
+
+        /* Reset devices if told to */
+        printk(KERN_INFO LOGNAME ": Resetting all devices\n");
+        for (i = 0; i < 4; ++i)
+                if (snd_msnd_write_cfg_logical(cfg, i, 0, 0, 0, 0))
+                        return -EIO;
+
+        return 0;
+}
+#endif
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
+
+module_param_array(index, int, NULL, S_IRUGO);
+MODULE_PARM_DESC(index, "Index value for msnd_pinnacle soundcard.");
+module_param_array(id, charp, NULL, S_IRUGO);
+MODULE_PARM_DESC(id, "ID string for msnd_pinnacle soundcard.");
+
+static long io[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
+static long mem[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+
+static long cfg[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+
+#ifndef MSND_CLASSIC
+/* Extra Peripheral Configuration (Default: Disable) */
+static long ide_io0[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static long ide_io1[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static int ide_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
+
+static long joystick_io[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+/* If we have the digital daugherboard... */
+static int digital[SNDRV_CARDS];
+
+/* Extra Peripheral Configuration */
+static int reset[SNDRV_CARDS];
+#endif
+
+static int write_ndelay[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 1 };
+
+static int calibrate_signal;
+
+#ifdef CONFIG_PNP
+static int isapnp[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
+module_param_array(isapnp, bool, NULL, 0444);
+MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
+#define has_isapnp(x) isapnp[x]
+#else
+#define has_isapnp(x) 0
+#endif
+
+MODULE_AUTHOR("Karsten Wiese <annabellesgarden@yahoo.de>");
+MODULE_DESCRIPTION("Turtle Beach " LONGNAME " Linux Driver");
+MODULE_LICENSE("GPL");
+MODULE_FIRMWARE(INITCODEFILE);
+MODULE_FIRMWARE(PERMCODEFILE);
+
+module_param_array(io, long, NULL, S_IRUGO);
+MODULE_PARM_DESC(io, "IO port #");
+module_param_array(irq, int, NULL, S_IRUGO);
+module_param_array(mem, long, NULL, S_IRUGO);
+module_param_array(write_ndelay, int, NULL, S_IRUGO);
+module_param(calibrate_signal, int, S_IRUGO);
+#ifndef MSND_CLASSIC
+module_param_array(digital, int, NULL, S_IRUGO);
+module_param_array(cfg, long, NULL, S_IRUGO);
+module_param_array(reset, int, 0, S_IRUGO);
+module_param_array(mpu_io, long, NULL, S_IRUGO);
+module_param_array(mpu_irq, int, NULL, S_IRUGO);
+module_param_array(ide_io0, long, NULL, S_IRUGO);
+module_param_array(ide_io1, long, NULL, S_IRUGO);
+module_param_array(ide_irq, int, NULL, S_IRUGO);
+module_param_array(joystick_io, long, NULL, S_IRUGO);
+#endif
+
+
+static int __devinit snd_msnd_isa_match(struct device *pdev, unsigned int i)
+{
+        if (io[i] == SNDRV_AUTO_PORT)
+                return 0;
+
+        if (irq[i] == SNDRV_AUTO_PORT || mem[i] == SNDRV_AUTO_PORT) {
+                printk(KERN_WARNING LOGNAME ": io, irq and mem must be set\n");
+                return 0;
+        }
+
+#ifdef MSND_CLASSIC
+        if (!(io[i] == 0x290 ||
+              io[i] == 0x260 ||
+              io[i] == 0x250 ||
+              io[i] == 0x240 ||
+              io[i] == 0x230 ||
+              io[i] == 0x220 ||
+              io[i] == 0x210 ||
+              io[i] == 0x3e0)) {
+                printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must be set "
+                        " to 0x210, 0x220, 0x230, 0x240, 0x250, 0x260, 0x290, "
+                        "or 0x3E0\n");
+                return 0;
+        }
+#else
+        if (io[i] < 0x100 || io[i] > 0x3e0 || (io[i] % 0x10) != 0) {
+                printk(KERN_ERR LOGNAME
+                        ": \"io\" - DSP I/O base must within the range 0x100 "
+                        "to 0x3E0 and must be evenly divisible by 0x10\n");
+                return 0;
+        }
+#endif /* MSND_CLASSIC */
+
+        if (!(irq[i] == 5 ||
+              irq[i] == 7 ||
+              irq[i] == 9 ||
+              irq[i] == 10 ||
+              irq[i] == 11 ||
+              irq[i] == 12)) {
+                printk(KERN_ERR LOGNAME
+                        ": \"irq\" - must be set to 5, 7, 9, 10, 11 or 12\n");
+                return 0;
+        }
+
+        if (!(mem[i] == 0xb0000 ||
+              mem[i] == 0xc8000 ||
+              mem[i] == 0xd0000 ||
+              mem[i] == 0xd8000 ||
+              mem[i] == 0xe0000 ||
+              mem[i] == 0xe8000)) {
+                printk(KERN_ERR LOGNAME ": \"mem\" - must be set to "
+                       "0xb0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000 or "
+                       "0xe8000\n");
+                return 0;
+        }
+
+#ifndef MSND_CLASSIC
+        if (cfg[i] == SNDRV_AUTO_PORT) {
+                printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
+        } else if (cfg[i] != 0x250 && cfg[i] != 0x260 && cfg[i] != 0x270) {
+                printk(KERN_INFO LOGNAME
+                        ": Config port must be 0x250, 0x260 or 0x270 "
+                        "(or unspecified for PnP mode)\n");
+                return 0;
+        }
+#endif /* MSND_CLASSIC */
+
+        return 1;
+}
+
+static int __devinit snd_msnd_isa_probe(struct device *pdev, unsigned int idx)
+{
+        int err;
+        struct snd_card *card;
+        struct snd_msnd *chip;
+
+        if (has_isapnp(idx) || cfg[idx] == SNDRV_AUTO_PORT) {
+                printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
+                return -ENODEV;
+        }
+
+        err = snd_card_create(index[idx], id[idx], THIS_MODULE,
+                              sizeof(struct snd_msnd), &card);
+        if (err < 0)
+                return err;
+
+        snd_card_set_dev(card, pdev);
+        chip = card->private_data;
+        chip->card = card;
+
+#ifdef MSND_CLASSIC
+        switch (irq[idx]) {
+        case 5:
+                chip->irqid = HPIRQ_5; break;
+        case 7:
+                chip->irqid = HPIRQ_7; break;
+        case 9:
+                chip->irqid = HPIRQ_9; break;
+        case 10:
+                chip->irqid = HPIRQ_10; break;
+        case 11:
+                chip->irqid = HPIRQ_11; break;
+        case 12:
+                chip->irqid = HPIRQ_12; break;
+        }
+
+        switch (mem[idx]) {
+        case 0xb0000:
+                chip->memid = HPMEM_B000; break;
+        case 0xc8000:
+                chip->memid = HPMEM_C800; break;
+        case 0xd0000:
+                chip->memid = HPMEM_D000; break;
+        case 0xd8000:
+                chip->memid = HPMEM_D800; break;
+        case 0xe0000:
+                chip->memid = HPMEM_E000; break;
+        case 0xe8000:
+                chip->memid = HPMEM_E800; break;
+        }
+#else
+        printk(KERN_INFO LOGNAME ": Non-PnP mode: configuring at port 0x%lx\n",
+                        cfg[idx]);
+
+        if (!request_region(cfg[idx], 2, "Pinnacle/Fiji Config")) {
+                printk(KERN_ERR LOGNAME ": Config port 0x%lx conflict\n",
+                           cfg[idx]);
+                snd_card_free(card);
+                return -EIO;
+        }
+        if (reset[idx])
+                if (snd_msnd_pinnacle_cfg_reset(cfg[idx])) {
+                        err = -EIO;
+                        goto cfg_error;
+                }
+
+        /* DSP */
+        err = snd_msnd_write_cfg_logical(cfg[idx], 0,
+                                         io[idx], 0,
+                                         irq[idx], mem[idx]);
+
+        if (err)
+                goto cfg_error;
+
+        /* The following are Pinnacle specific */
+
+        /* MPU */
+        if (mpu_io[idx] != SNDRV_AUTO_PORT
+            && mpu_irq[idx] != SNDRV_AUTO_IRQ) {
+                printk(KERN_INFO LOGNAME
+                       ": Configuring MPU to I/O 0x%lx IRQ %d\n",
+                       mpu_io[idx], mpu_irq[idx]);
+                err = snd_msnd_write_cfg_logical(cfg[idx], 1,
+                                                 mpu_io[idx], 0,
+                                                 mpu_irq[idx], 0);
+
+                if (err)
+                        goto cfg_error;
+        }
+
+        /* IDE */
+        if (ide_io0[idx] != SNDRV_AUTO_PORT
+            && ide_io1[idx] != SNDRV_AUTO_PORT
+            && ide_irq[idx] != SNDRV_AUTO_IRQ) {
+                printk(KERN_INFO LOGNAME
+                       ": Configuring IDE to I/O 0x%lx, 0x%lx IRQ %d\n",
+                       ide_io0[idx], ide_io1[idx], ide_irq[idx]);
+                err = snd_msnd_write_cfg_logical(cfg[idx], 2,
+                                                 ide_io0[idx], ide_io1[idx],
+                                                 ide_irq[idx], 0);
+
+                if (err)
+                        goto cfg_error;
+        }
+
+        /* Joystick */
+        if (joystick_io[idx] != SNDRV_AUTO_PORT) {
+                printk(KERN_INFO LOGNAME
+                       ": Configuring joystick to I/O 0x%lx\n",
+                       joystick_io[idx]);
+                err = snd_msnd_write_cfg_logical(cfg[idx], 3,
+                                                 joystick_io[idx], 0,
+                                                 0, 0);
+
+                if (err)
+                        goto cfg_error;
+        }
+        release_region(cfg[idx], 2);
+
+#endif /* MSND_CLASSIC */
+
+        set_default_audio_parameters(chip);
+#ifdef MSND_CLASSIC
+        chip->type = msndClassic;
+#else
+        chip->type = msndPinnacle;
+#endif
+        chip->io = io[idx];
+        chip->irq = irq[idx];
+        chip->base = mem[idx];
+
+        chip->calibrate_signal = calibrate_signal ? 1 : 0;
+        chip->recsrc = 0;
+        chip->dspq_data_buff = DSPQ_DATA_BUFF;
+        chip->dspq_buff_size = DSPQ_BUFF_SIZE;
+        if (write_ndelay[idx])
+                clear_bit(F_DISABLE_WRITE_NDELAY, &chip->flags);
+        else
+                set_bit(F_DISABLE_WRITE_NDELAY, &chip->flags);
+#ifndef MSND_CLASSIC
+        if (digital[idx])
+                set_bit(F_HAVEDIGITAL, &chip->flags);
+#endif
+        spin_lock_init(&chip->lock);
+        err = snd_msnd_probe(card);
+        if (err < 0) {
+                printk(KERN_ERR LOGNAME ": Probe failed\n");
+                snd_card_free(card);
+                return err;
+        }
+
+        err = snd_msnd_attach(card);
+        if (err < 0) {
+                printk(KERN_ERR LOGNAME ": Attach failed\n");
+                snd_card_free(card);
+                return err;
+        }
+        dev_set_drvdata(pdev, card);
+
+        return 0;
+
+#ifndef MSND_CLASSIC
+cfg_error:
+        release_region(cfg[idx], 2);
+        snd_card_free(card);
+        return err;
+#endif
+}
+
+static int __devexit snd_msnd_isa_remove(struct device *pdev, unsigned int dev)
+{
+        snd_msnd_unload(dev_get_drvdata(pdev));
+        dev_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+#define DEV_NAME "msnd-pinnacle"
+
+static struct isa_driver snd_msnd_driver = {
+        .match          = snd_msnd_isa_match,
+        .probe          = snd_msnd_isa_probe,
+        .remove         = __devexit_p(snd_msnd_isa_remove),
+        /* FIXME: suspend, resume */
+        .driver         = {
+                .name   = DEV_NAME
+        },
+};
+
+#ifdef CONFIG_PNP
+static int __devinit snd_msnd_pnp_detect(struct pnp_card_link *pcard,
+                                         const struct pnp_card_device_id *pid)
+{
+        static int idx;
+        struct pnp_dev *pnp_dev;
+        struct pnp_dev *mpu_dev;
+        struct snd_card *card;
+        struct snd_msnd *chip;
+        int ret;
+
+        for ( ; idx < SNDRV_CARDS; idx++) {
+                if (has_isapnp(idx))
+                        break;
+        }
+        if (idx >= SNDRV_CARDS)
+                return -ENODEV;
+
+        /*
+         * Check that we still have room for another sound card ...
+         */
+        pnp_dev = pnp_request_card_device(pcard, pid->devs[0].id, NULL);
+        if (!pnp_dev)
+                return -ENODEV;
+
+        mpu_dev = pnp_request_card_device(pcard, pid->devs[1].id, NULL);
+        if (!mpu_dev)
+                return -ENODEV;
+
+        if (!pnp_is_active(pnp_dev) && pnp_activate_dev(pnp_dev) < 0) {
+                printk(KERN_INFO "msnd_pinnacle: device is inactive\n");
+                return -EBUSY;
+        }
+
+        if (!pnp_is_active(mpu_dev) && pnp_activate_dev(mpu_dev) < 0) {
+                printk(KERN_INFO "msnd_pinnacle: MPU device is inactive\n");
+                return -EBUSY;
+        }
+
+        /*
+         * Create a new ALSA sound card entry, in anticipation
+         * of detecting our hardware ...
+         */
+        ret = snd_card_create(index[idx], id[idx], THIS_MODULE,
+                              sizeof(struct snd_msnd), &card);
+        if (ret < 0)
+                return ret;
+
+        chip = card->private_data;
+        chip->card = card;
+        snd_card_set_dev(card, &pcard->card->dev);
+
+        /*
+         * Read the correct parameters off the ISA PnP bus ...
+         */
+        io[idx] = pnp_port_start(pnp_dev, 0);
+        irq[idx] = pnp_irq(pnp_dev, 0);
+        mem[idx] = pnp_mem_start(pnp_dev, 0);
+        mpu_io[idx] = pnp_port_start(mpu_dev, 0);
+        mpu_irq[idx] = pnp_irq(mpu_dev, 0);
+
+        set_default_audio_parameters(chip);
+#ifdef MSND_CLASSIC
+        chip->type = msndClassic;
+#else
+        chip->type = msndPinnacle;
+#endif
+        chip->io = io[idx];
+        chip->irq = irq[idx];
+        chip->base = mem[idx];
+
+        chip->calibrate_signal = calibrate_signal ? 1 : 0;
+        chip->recsrc = 0;
+        chip->dspq_data_buff = DSPQ_DATA_BUFF;
+        chip->dspq_buff_size = DSPQ_BUFF_SIZE;
+        if (write_ndelay[idx])
+                clear_bit(F_DISABLE_WRITE_NDELAY, &chip->flags);
+        else
+                set_bit(F_DISABLE_WRITE_NDELAY, &chip->flags);
+#ifndef MSND_CLASSIC
+        if (digital[idx])
+                set_bit(F_HAVEDIGITAL, &chip->flags);
+#endif
+        spin_lock_init(&chip->lock);
+        ret = snd_msnd_probe(card);
+        if (ret < 0) {
+                printk(KERN_ERR LOGNAME ": Probe failed\n");
+                goto _release_card;
+        }
+
+        ret = snd_msnd_attach(card);
+        if (ret < 0) {
+                printk(KERN_ERR LOGNAME ": Attach failed\n");
+                goto _release_card;
+        }
+
+        pnp_set_card_drvdata(pcard, card);
+        ++idx;
+        return 0;
+
+_release_card:
+        snd_card_free(card);
+        return ret;
+}
+
+static void __devexit snd_msnd_pnp_remove(struct pnp_card_link *pcard)
+{
+        snd_msnd_unload(pnp_get_card_drvdata(pcard));
+        pnp_set_card_drvdata(pcard, NULL);
+}
+
+static int isa_registered;
+static int pnp_registered;
+
+static struct pnp_card_device_id msnd_pnpids[] = {
+        /* Pinnacle PnP */
+        { .id = "BVJ0440", .devs = { { "TBS0000" }, { "TBS0001" } } },
+        { .id = "" }    /* end */
+};
+
+MODULE_DEVICE_TABLE(pnp_card, msnd_pnpids);
+
+static struct pnp_card_driver msnd_pnpc_driver = {
+        .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
+        .name = "msnd_pinnacle",
+        .id_table = msnd_pnpids,
+        .probe = snd_msnd_pnp_detect,
+        .remove = __devexit_p(snd_msnd_pnp_remove),
+};
+#endif /* CONFIG_PNP */
+
+static int __init snd_msnd_init(void)
+{
+        int err;
+
+        err = isa_register_driver(&snd_msnd_driver, SNDRV_CARDS);
+#ifdef CONFIG_PNP
+        if (!err)
+                isa_registered = 1;
+
+        err = pnp_register_card_driver(&msnd_pnpc_driver);
+        if (!err)
+                pnp_registered = 1;
+
+        if (isa_registered)
+                err = 0;
+#endif
+        return err;
+}
+
+static void __exit snd_msnd_exit(void)
+{
+#ifdef CONFIG_PNP
+        if (pnp_registered)
+                pnp_unregister_card_driver(&msnd_pnpc_driver);
+        if (isa_registered)
+#endif
+                isa_unregister_driver(&snd_msnd_driver);
+}
+
+module_init(snd_msnd_init);
+module_exit(snd_msnd_exit);
+
diff --git a/sound/isa/msnd/msnd_pinnacle.h b/sound/isa/msnd/msnd_pinnacle.h
new file mode 100644
index 000000000000..48318d1ee340
--- /dev/null
+++ b/sound/isa/msnd/msnd_pinnacle.h
@@ -0,0 +1,181 @@
+/*********************************************************************
+ *
+ * msnd_pinnacle.h
+ *
+ * Turtle Beach MultiSound Sound Card Driver for Linux
+ *
+ * Some parts of this header file were derived from the Turtle Beach
+ * MultiSound Driver Development Kit.
+ *
+ * Copyright (C) 1998 Andrew Veliath
+ * Copyright (C) 1993 Turtle Beach Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ ********************************************************************/
+#ifndef __MSND_PINNACLE_H
+#define __MSND_PINNACLE_H
+
+#define DSP_NUMIO                               0x08
+
+#define IREG_LOGDEVICE                          0x07
+#define IREG_ACTIVATE                           0x30
+#define LD_ACTIVATE                             0x01
+#define LD_DISACTIVATE                          0x00
+#define IREG_EECONTROL                          0x3F
+#define IREG_MEMBASEHI                          0x40
+#define IREG_MEMBASELO                          0x41
+#define IREG_MEMCONTROL                         0x42
+#define IREG_MEMRANGEHI                         0x43
+#define IREG_MEMRANGELO                         0x44
+#define MEMTYPE_8BIT                            0x00
+#define MEMTYPE_16BIT                           0x02
+#define MEMTYPE_RANGE                           0x00
+#define MEMTYPE_HIADDR                          0x01
+#define IREG_IO0_BASEHI                         0x60
+#define IREG_IO0_BASELO                         0x61
+#define IREG_IO1_BASEHI                         0x62
+#define IREG_IO1_BASELO                         0x63
+#define IREG_IRQ_NUMBER                         0x70
+#define IREG_IRQ_TYPE                           0x71
+#define IRQTYPE_HIGH                            0x02
+#define IRQTYPE_LOW                             0x00
+#define IRQTYPE_LEVEL                           0x01
+#define IRQTYPE_EDGE                            0x00
+
+#define HP_DSPR                                 0x04
+#define HP_BLKS                                 0x04
+
+#define HPDSPRESET_OFF                          2
+#define HPDSPRESET_ON                           0
+
+#define HPBLKSEL_0                              2
+#define HPBLKSEL_1                              3
+
+#define HIMT_DAT_OFF                            0x03
+
+#define HIDSP_PLAY_UNDER                        0x00
+#define HIDSP_INT_PLAY_UNDER                    0x01
+#define HIDSP_SSI_TX_UNDER                      0x02
+#define HIDSP_RECQ_OVERFLOW                     0x08
+#define HIDSP_INT_RECORD_OVER                   0x09
+#define HIDSP_SSI_RX_OVERFLOW                   0x0a
+
+#define HIDSP_MIDI_IN_OVER                      0x10
+
+#define HIDSP_MIDI_FRAME_ERR                    0x11
+#define HIDSP_MIDI_PARITY_ERR                   0x12
+#define HIDSP_MIDI_OVERRUN_ERR                  0x13
+
+#define HIDSP_INPUT_CLIPPING                    0x20
+#define HIDSP_MIX_CLIPPING                      0x30
+#define HIDSP_DAT_IN_OFF                        0x21
+
+#define TIME_PRO_RESET_DONE                     0x028A
+#define TIME_PRO_SYSEX                          0x001E
+#define TIME_PRO_RESET                          0x0032
+
+#define DAR_BUFF_SIZE                           0x1000
+
+#define MIDQ_BUFF_SIZE                          0x800
+#define DSPQ_BUFF_SIZE                          0x5A0
+
+#define DSPQ_DATA_BUFF                          0x7860
+
+#define MOP_WAVEHDR                             0
+#define MOP_EXTOUT                              1
+#define MOP_HWINIT                              0xfe
+#define MOP_NONE                                0xff
+#define MOP_MAX                                 1
+
+#define MIP_EXTIN                               0
+#define MIP_WAVEHDR                             1
+#define MIP_HWINIT                              0xfe
+#define MIP_MAX                                 1
+
+/* Pinnacle/Fiji SMA Common Data */
+#define SMA_wCurrPlayBytes                      0x0000
+#define SMA_wCurrRecordBytes                    0x0002
+#define SMA_wCurrPlayVolLeft                    0x0004
+#define SMA_wCurrPlayVolRight                   0x0006
+#define SMA_wCurrInVolLeft                      0x0008
+#define SMA_wCurrInVolRight                     0x000a
+#define SMA_wCurrMHdrVolLeft                    0x000c
+#define SMA_wCurrMHdrVolRight                   0x000e
+#define SMA_dwCurrPlayPitch                     0x0010
+#define SMA_dwCurrPlayRate                      0x0014
+#define SMA_wCurrMIDIIOPatch                    0x0018
+#define SMA_wCurrPlayFormat                     0x001a
+#define SMA_wCurrPlaySampleSize                 0x001c
+#define SMA_wCurrPlayChannels                   0x001e
+#define SMA_wCurrPlaySampleRate                 0x0020
+#define SMA_wCurrRecordFormat                   0x0022
+#define SMA_wCurrRecordSampleSize               0x0024
+#define SMA_wCurrRecordChannels                 0x0026
+#define SMA_wCurrRecordSampleRate               0x0028
+#define SMA_wCurrDSPStatusFlags                 0x002a
+#define SMA_wCurrHostStatusFlags                0x002c
+#define SMA_wCurrInputTagBits                   0x002e
+#define SMA_wCurrLeftPeak                       0x0030
+#define SMA_wCurrRightPeak                      0x0032
+#define SMA_bMicPotPosLeft                      0x0034
+#define SMA_bMicPotPosRight                     0x0035
+#define SMA_bMicPotMaxLeft                      0x0036
+#define SMA_bMicPotMaxRight                     0x0037
+#define SMA_bInPotPosLeft                       0x0038
+#define SMA_bInPotPosRight                      0x0039
+#define SMA_bAuxPotPosLeft                      0x003a
+#define SMA_bAuxPotPosRight                     0x003b
+#define SMA_bInPotMaxLeft                       0x003c
+#define SMA_bInPotMaxRight                      0x003d
+#define SMA_bAuxPotMaxLeft                      0x003e
+#define SMA_bAuxPotMaxRight                     0x003f
+#define SMA_bInPotMaxMethod                     0x0040
+#define SMA_bAuxPotMaxMethod                    0x0041
+#define SMA_wCurrMastVolLeft                    0x0042
+#define SMA_wCurrMastVolRight                   0x0044
+#define SMA_wCalFreqAtoD                        0x0046
+#define SMA_wCurrAuxVolLeft                     0x0048
+#define SMA_wCurrAuxVolRight                    0x004a
+#define SMA_wCurrPlay1VolLeft                   0x004c
+#define SMA_wCurrPlay1VolRight                  0x004e
+#define SMA_wCurrPlay2VolLeft                   0x0050
+#define SMA_wCurrPlay2VolRight                  0x0052
+#define SMA_wCurrPlay3VolLeft                   0x0054
+#define SMA_wCurrPlay3VolRight                  0x0056
+#define SMA_wCurrPlay4VolLeft                   0x0058
+#define SMA_wCurrPlay4VolRight                  0x005a
+#define SMA_wCurrPlay1PeakLeft                  0x005c
+#define SMA_wCurrPlay1PeakRight                 0x005e
+#define SMA_wCurrPlay2PeakLeft                  0x0060
+#define SMA_wCurrPlay2PeakRight                 0x0062
+#define SMA_wCurrPlay3PeakLeft                  0x0064
+#define SMA_wCurrPlay3PeakRight                 0x0066
+#define SMA_wCurrPlay4PeakLeft                  0x0068
+#define SMA_wCurrPlay4PeakRight                 0x006a
+#define SMA_wCurrPlayPeakLeft                   0x006c
+#define SMA_wCurrPlayPeakRight                  0x006e
+#define SMA_wCurrDATSR                          0x0070
+#define SMA_wCurrDATRXCHNL                      0x0072
+#define SMA_wCurrDATTXCHNL                      0x0074
+#define SMA_wCurrDATRXRate                      0x0076
+#define SMA_dwDSPPlayCount                      0x0078
+#define SMA__size                               0x007c
+
+#define INITCODEFILE            "turtlebeach/pndspini.bin"
+#define PERMCODEFILE            "turtlebeach/pndsperm.bin"
+#define LONGNAME                "MultiSound (Pinnacle/Fiji)"
+
+#endif /* __MSND_PINNACLE_H */
diff --git a/sound/isa/msnd/msnd_pinnacle_mixer.c b/sound/isa/msnd/msnd_pinnacle_mixer.c
new file mode 100644
index 000000000000..494058a1a502
--- /dev/null
+++ b/sound/isa/msnd/msnd_pinnacle_mixer.c
@@ -0,0 +1,343 @@
+/***************************************************************************
+                          msnd_pinnacle_mixer.c  -  description
+                             -------------------
+    begin               : Fre Jun 7 2002
+    copyright           : (C) 2002 by karsten wiese
+    email               : annabellesgarden@yahoo.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include <linux/io.h>
+
+#include <sound/core.h>
+#include <sound/control.h>
+#include "msnd.h"
+#include "msnd_pinnacle.h"
+
+
+#define MSND_MIXER_VOLUME       0
+#define MSND_MIXER_PCM          1
+#define MSND_MIXER_AUX          2       /* Input source 1  (aux1) */
+#define MSND_MIXER_IMIX         3       /*  Recording monitor  */
+#define MSND_MIXER_SYNTH        4
+#define MSND_MIXER_SPEAKER      5
+#define MSND_MIXER_LINE         6
+#define MSND_MIXER_MIC          7
+#define MSND_MIXER_RECLEV       11      /* Recording level */
+#define MSND_MIXER_IGAIN        12      /* Input gain */
+#define MSND_MIXER_OGAIN        13      /* Output gain */
+#define MSND_MIXER_DIGITAL      17      /* Digital (input) 1 */
+
+/*      Device mask bits        */
+
+#define MSND_MASK_VOLUME        (1 << MSND_MIXER_VOLUME)
+#define MSND_MASK_SYNTH         (1 << MSND_MIXER_SYNTH)
+#define MSND_MASK_PCM           (1 << MSND_MIXER_PCM)
+#define MSND_MASK_SPEAKER       (1 << MSND_MIXER_SPEAKER)
+#define MSND_MASK_LINE          (1 << MSND_MIXER_LINE)
+#define MSND_MASK_MIC           (1 << MSND_MIXER_MIC)
+#define MSND_MASK_IMIX          (1 << MSND_MIXER_IMIX)
+#define MSND_MASK_RECLEV        (1 << MSND_MIXER_RECLEV)
+#define MSND_MASK_IGAIN         (1 << MSND_MIXER_IGAIN)
+#define MSND_MASK_OGAIN         (1 << MSND_MIXER_OGAIN)
+#define MSND_MASK_AUX           (1 << MSND_MIXER_AUX)
+#define MSND_MASK_DIGITAL       (1 << MSND_MIXER_DIGITAL)
+
+static int snd_msndmix_info_mux(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[3] = {
+                "Analog", "MASS", "SPDIF",
+        };
+        struct snd_msnd *chip = snd_kcontrol_chip(kcontrol);
+        unsigned items = test_bit(F_HAVEDIGITAL, &chip->flags) ? 3 : 2;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = items;
+        if (uinfo->value.enumerated.item >= items)
+                uinfo->value.enumerated.item = items - 1;
+        strcpy(uinfo->value.enumerated.name,
+                texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int snd_msndmix_get_mux(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_msnd *chip = snd_kcontrol_chip(kcontrol);
+        /* MSND_MASK_IMIX is the default */
+        ucontrol->value.enumerated.item[0] = 0;
+
+        if (chip->recsrc & MSND_MASK_SYNTH) {
+                ucontrol->value.enumerated.item[0] = 1;
+        } else if ((chip->recsrc & MSND_MASK_DIGITAL) &&
+                 test_bit(F_HAVEDIGITAL, &chip->flags)) {
+                ucontrol->value.enumerated.item[0] = 2;
+        }
+
+
+        return 0;
+}
+
+static int snd_msndmix_set_mux(struct snd_msnd *chip, int val)
+{
+        unsigned newrecsrc;
+        int change;
+        unsigned char msndbyte;
+
+        switch (val) {
+        case 0:
+                newrecsrc = MSND_MASK_IMIX;
+                msndbyte = HDEXAR_SET_ANA_IN;
+                break;
+        case 1:
+                newrecsrc = MSND_MASK_SYNTH;
+                msndbyte = HDEXAR_SET_SYNTH_IN;
+                break;
+        case 2:
+                newrecsrc = MSND_MASK_DIGITAL;
+                msndbyte = HDEXAR_SET_DAT_IN;
+                break;
+        default:
+                return -EINVAL;
+        }
+        change  = newrecsrc != chip->recsrc;
+        if (change) {
+                change = 0;
+                if (!snd_msnd_send_word(chip, 0, 0, msndbyte))
+                        if (!snd_msnd_send_dsp_cmd(chip, HDEX_AUX_REQ)) {
+                                chip->recsrc = newrecsrc;
+                                change = 1;
+                        }
+        }
+        return change;
+}
+
+static int snd_msndmix_put_mux(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_msnd *msnd = snd_kcontrol_chip(kcontrol);
+        return snd_msndmix_set_mux(msnd, ucontrol->value.enumerated.item[0]);
+}
+
+
+static int snd_msndmix_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 = 100;
+        return 0;
+}
+
+static int snd_msndmix_volume_get(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_msnd *msnd = snd_kcontrol_chip(kcontrol);
+        int addr = kcontrol->private_value;
+        unsigned long flags;
+
+        spin_lock_irqsave(&msnd->mixer_lock, flags);
+        ucontrol->value.integer.value[0] = msnd->left_levels[addr] * 100;
+        ucontrol->value.integer.value[0] /= 0xFFFF;
+        ucontrol->value.integer.value[1] = msnd->right_levels[addr] * 100;
+        ucontrol->value.integer.value[1] /= 0xFFFF;
+        spin_unlock_irqrestore(&msnd->mixer_lock, flags);
+        return 0;
+}
+
+#define update_volm(a, b)                                               \
+        do {                                                            \
+                writew((dev->left_levels[a] >> 1) *                     \
+                       readw(dev->SMA + SMA_wCurrMastVolLeft) / 0xffff, \
+                       dev->SMA + SMA_##b##Left);                       \
+                writew((dev->right_levels[a] >> 1)  *                   \
+                       readw(dev->SMA + SMA_wCurrMastVolRight) / 0xffff, \
+                       dev->SMA + SMA_##b##Right);                      \
+        } while (0);
+
+#define update_potm(d, s, ar)                                           \
+        do {                                                            \
+                writeb((dev->left_levels[d] >> 8) *                     \
+                       readw(dev->SMA + SMA_wCurrMastVolLeft) / 0xffff, \
+                       dev->SMA + SMA_##s##Left);                       \
+                writeb((dev->right_levels[d] >> 8) *                    \
+                       readw(dev->SMA + SMA_wCurrMastVolRight) / 0xffff, \
+                       dev->SMA + SMA_##s##Right);                      \
+                if (snd_msnd_send_word(dev, 0, 0, ar) == 0)             \
+                        snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);       \
+        } while (0);
+
+#define update_pot(d, s, ar)                                            \
+        do {                                                            \
+                writeb(dev->left_levels[d] >> 8,                        \
+                       dev->SMA + SMA_##s##Left);                       \
+                writeb(dev->right_levels[d] >> 8,                       \
+                       dev->SMA + SMA_##s##Right);                      \
+                if (snd_msnd_send_word(dev, 0, 0, ar) == 0)             \
+                        snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);       \
+        } while (0);
+
+
+static int snd_msndmix_set(struct snd_msnd *dev, int d, int left, int right)
+{
+        int bLeft, bRight;
+        int wLeft, wRight;
+        int updatemaster = 0;
+
+        if (d >= LEVEL_ENTRIES)
+                return -EINVAL;
+
+        bLeft = left * 0xff / 100;
+        wLeft = left * 0xffff / 100;
+
+        bRight = right * 0xff / 100;
+        wRight = right * 0xffff / 100;
+
+        dev->left_levels[d] = wLeft;
+        dev->right_levels[d] = wRight;
+
+        switch (d) {
+                /* master volume unscaled controls */
+        case MSND_MIXER_LINE:                   /* line pot control */
+                /* scaled by IMIX in digital mix */
+                writeb(bLeft, dev->SMA + SMA_bInPotPosLeft);
+                writeb(bRight, dev->SMA + SMA_bInPotPosRight);
+                if (snd_msnd_send_word(dev, 0, 0, HDEXAR_IN_SET_POTS) == 0)
+                        snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);
+                break;
+        case MSND_MIXER_MIC:                    /* mic pot control */
+                if (dev->type == msndClassic)
+                        return -EINVAL;
+                /* scaled by IMIX in digital mix */
+                writeb(bLeft, dev->SMA + SMA_bMicPotPosLeft);
+                writeb(bRight, dev->SMA + SMA_bMicPotPosRight);
+                if (snd_msnd_send_word(dev, 0, 0, HDEXAR_MIC_SET_POTS) == 0)
+                        snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);
+                break;
+        case MSND_MIXER_VOLUME:         /* master volume */
+                writew(wLeft, dev->SMA + SMA_wCurrMastVolLeft);
+                writew(wRight, dev->SMA + SMA_wCurrMastVolRight);
+                /* fall through */
+
+        case MSND_MIXER_AUX:                    /* aux pot control */
+                /* scaled by master volume */
+                /* fall through */
+
+                /* digital controls */
+        case MSND_MIXER_SYNTH:                  /* synth vol (dsp mix) */
+        case MSND_MIXER_PCM:                    /* pcm vol (dsp mix) */
+        case MSND_MIXER_IMIX:                   /* input monitor (dsp mix) */
+                /* scaled by master volume */
+                updatemaster = 1;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        if (updatemaster) {
+                /* update master volume scaled controls */
+                update_volm(MSND_MIXER_PCM, wCurrPlayVol);
+                update_volm(MSND_MIXER_IMIX, wCurrInVol);
+                if (dev->type == msndPinnacle)
+                        update_volm(MSND_MIXER_SYNTH, wCurrMHdrVol);
+                update_potm(MSND_MIXER_AUX, bAuxPotPos, HDEXAR_AUX_SET_POTS);
+        }
+
+        return 0;
+}
+
+static int snd_msndmix_volume_put(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_msnd *msnd = snd_kcontrol_chip(kcontrol);
+        int change, addr = kcontrol->private_value;
+        int left, right;
+        unsigned long flags;
+
+        left = ucontrol->value.integer.value[0] % 101;
+        right = ucontrol->value.integer.value[1] % 101;
+        spin_lock_irqsave(&msnd->mixer_lock, flags);
+        change = msnd->left_levels[addr] != left
+                || msnd->right_levels[addr] != right;
+        snd_msndmix_set(msnd, addr, left, right);
+        spin_unlock_irqrestore(&msnd->mixer_lock, flags);
+        return change;
+}
+
+
+#define DUMMY_VOLUME(xname, xindex, addr) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
+  .info = snd_msndmix_volume_info, \
+  .get = snd_msndmix_volume_get, .put = snd_msndmix_volume_put, \
+  .private_value = addr }
+
+
+static struct snd_kcontrol_new snd_msnd_controls[] = {
+DUMMY_VOLUME("Master Volume", 0, MSND_MIXER_VOLUME),
+DUMMY_VOLUME("PCM Volume", 0, MSND_MIXER_PCM),
+DUMMY_VOLUME("Aux Volume", 0, MSND_MIXER_AUX),
+DUMMY_VOLUME("Line Volume", 0, MSND_MIXER_LINE),
+DUMMY_VOLUME("Mic Volume", 0, MSND_MIXER_MIC),
+DUMMY_VOLUME("Monitor", 0, MSND_MIXER_IMIX),
+{
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Capture Source",
+        .info = snd_msndmix_info_mux,
+        .get = snd_msndmix_get_mux,
+        .put = snd_msndmix_put_mux,
+}
+};
+
+
+int __devinit snd_msndmix_new(struct snd_card *card)
+{
+        struct snd_msnd *chip = card->private_data;
+        unsigned int idx;
+        int err;
+
+        if (snd_BUG_ON(!chip))
+                return -EINVAL;
+        spin_lock_init(&chip->mixer_lock);
+        strcpy(card->mixername, "MSND Pinnacle Mixer");
+
+        for (idx = 0; idx < ARRAY_SIZE(snd_msnd_controls); idx++)
+                err = snd_ctl_add(card,
+                                  snd_ctl_new1(snd_msnd_controls + idx, chip));
+                if (err < 0)
+                        return err;
+
+        return 0;
+}
+EXPORT_SYMBOL(snd_msndmix_new);
+
+void snd_msndmix_setup(struct snd_msnd *dev)
+{
+        update_pot(MSND_MIXER_LINE, bInPotPos, HDEXAR_IN_SET_POTS);
+        update_potm(MSND_MIXER_AUX, bAuxPotPos, HDEXAR_AUX_SET_POTS);
+        update_volm(MSND_MIXER_PCM, wCurrPlayVol);
+        update_volm(MSND_MIXER_IMIX, wCurrInVol);
+        if (dev->type == msndPinnacle) {
+                update_pot(MSND_MIXER_MIC, bMicPotPos, HDEXAR_MIC_SET_POTS);
+                update_volm(MSND_MIXER_SYNTH, wCurrMHdrVol);
+        }
+}
+EXPORT_SYMBOL(snd_msndmix_setup);
+
+int snd_msndmix_force_recsrc(struct snd_msnd *dev, int recsrc)
+{
+        dev->recsrc = -1;
+        return snd_msndmix_set_mux(dev, recsrc);
+}
+EXPORT_SYMBOL(snd_msndmix_force_recsrc);
diff --git a/sound/isa/opl3sa2.c b/sound/isa/opl3sa2.c
index 645491a53023..0481a55334b9 100644
--- a/sound/isa/opl3sa2.c
+++ b/sound/isa/opl3sa2.c
@@ -179,12 +179,13 @@ static unsigned char __snd_opl3sa2_read(struct snd_opl3sa2 *chip, unsigned char
         unsigned char result;
 #if 0
         outb(0x1d, port);       /* password */
-        printk("read [0x%lx] = 0x%x\n", port, inb(port));
+        printk(KERN_DEBUG "read [0x%lx] = 0x%x\n", port, inb(port));
 #endif
         outb(reg, chip->port);  /* register */
         result = inb(chip->port + 1);
 #if 0
-        printk("read [0x%lx] = 0x%x [0x%x]\n", port, result, inb(port));
+        printk(KERN_DEBUG "read [0x%lx] = 0x%x [0x%x]\n",
+               port, result, inb(port));
 #endif
         return result;
 }
@@ -233,7 +234,10 @@ static int __devinit snd_opl3sa2_detect(struct snd_card *card)
                 snd_printk(KERN_ERR PFX "can't grab port 0x%lx\n", port);
                 return -EBUSY;
         }
-        // snd_printk("REG 0A = 0x%x\n", snd_opl3sa2_read(chip, 0x0a));
+        /*
+        snd_printk(KERN_DEBUG "REG 0A = 0x%x\n",
+                   snd_opl3sa2_read(chip, 0x0a));
+        */
         chip->version = 0;
         tmp = snd_opl3sa2_read(chip, OPL3SA2_MISC);
         if (tmp == 0xff) {
@@ -477,6 +481,7 @@ OPL3SA2_DOUBLE_TLV("Master Playback Volume", 0, 0x07, 0x08, 0, 0, 15, 1,
 OPL3SA2_SINGLE("Mic Playback Switch", 0, 0x09, 7, 1, 1),
 OPL3SA2_SINGLE_TLV("Mic Playback Volume", 0, 0x09, 0, 31, 1,
                    db_scale_5bit_12db_max),
+OPL3SA2_SINGLE("ZV Port Switch", 0, 0x02, 0, 1, 0),
 };
 
 static struct snd_kcontrol_new snd_opl3sa2_tone_controls[] = {
@@ -550,21 +555,27 @@ static int __devinit snd_opl3sa2_mixer(struct snd_card *card)
 #ifdef CONFIG_PM
 static int snd_opl3sa2_suspend(struct snd_card *card, pm_message_t state)
 {
-        struct snd_opl3sa2 *chip = card->private_data;
+        if (card) {
+                struct snd_opl3sa2 *chip = card->private_data;
 
-        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        chip->wss->suspend(chip->wss);
-        /* power down */
-        snd_opl3sa2_write(chip, OPL3SA2_PM_CTRL, OPL3SA2_PM_D3);
+                snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
+                chip->wss->suspend(chip->wss);
+                /* power down */
+                snd_opl3sa2_write(chip, OPL3SA2_PM_CTRL, OPL3SA2_PM_D3);
+        }
 
         return 0;
 }
 
 static int snd_opl3sa2_resume(struct snd_card *card)
 {
-        struct snd_opl3sa2 *chip = card->private_data;
+        struct snd_opl3sa2 *chip;
         int i;
 
+        if (!card)
+                return 0;
+
+        chip = card->private_data;
         /* power up */
         snd_opl3sa2_write(chip, OPL3SA2_PM_CTRL, OPL3SA2_PM_D0);
 
@@ -613,7 +624,7 @@ static void snd_opl3sa2_free(struct snd_card *card)
 {
         struct snd_opl3sa2 *chip = card->private_data;
         if (chip->irq >= 0)
-                free_irq(chip->irq, (void *)chip);
+                free_irq(chip->irq, card);
         release_and_free_resource(chip->res_port);
 }
 
@@ -628,7 +639,7 @@ static int snd_opl3sa2_card_new(int dev, struct snd_card **cardp)
         if (err < 0)
                 return err;
         strcpy(card->driver, "OPL3SA2");
-        strcpy(card->shortname, "Yamaha OPL3-SA2");
+        strcpy(card->shortname, "Yamaha OPL3-SA");
         chip = card->private_data;
         spin_lock_init(&chip->reg_lock);
         chip->irq = -1;
diff --git a/sound/isa/opti9xx/opti92x-ad1848.c b/sound/isa/opti9xx/opti92x-ad1848.c
index cd6e60a6a4ea..5cd555325b9d 100644
--- a/sound/isa/opti9xx/opti92x-ad1848.c
+++ b/sound/isa/opti9xx/opti92x-ad1848.c
@@ -252,7 +252,7 @@ static int __devinit snd_opti9xx_init(struct snd_opti9xx *chip,
 #endif  /* OPTi93X */
 
         default:
-                snd_printk("chip %d not supported\n", hardware);
+                snd_printk(KERN_ERR "chip %d not supported\n", hardware);
                 return -ENODEV;
         }
         return 0;
@@ -294,7 +294,7 @@ static unsigned char snd_opti9xx_read(struct snd_opti9xx *chip,
 #endif  /* OPTi93X */
 
         default:
-                snd_printk("chip %d not supported\n", chip->hardware);
+                snd_printk(KERN_ERR "chip %d not supported\n", chip->hardware);
         }
 
         spin_unlock_irqrestore(&chip->lock, flags);
@@ -336,7 +336,7 @@ static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg,
 #endif  /* OPTi93X */
 
         default:
-                snd_printk("chip %d not supported\n", chip->hardware);
+                snd_printk(KERN_ERR "chip %d not supported\n", chip->hardware);
         }
 
         spin_unlock_irqrestore(&chip->lock, flags);
@@ -412,7 +412,7 @@ static int __devinit snd_opti9xx_configure(struct snd_opti9xx *chip)
 #endif  /* OPTi93X */
 
         default:
-                snd_printk("chip %d not supported\n", chip->hardware);
+                snd_printk(KERN_ERR "chip %d not supported\n", chip->hardware);
                 return -EINVAL;
         }
 
@@ -430,7 +430,8 @@ static int __devinit snd_opti9xx_configure(struct snd_opti9xx *chip)
                 wss_base_bits = 0x02;
                 break;
         default:
-                snd_printk("WSS port 0x%lx not valid\n", chip->wss_base);
+                snd_printk(KERN_WARNING "WSS port 0x%lx not valid\n",
+                           chip->wss_base);
                 goto __skip_base;
         }
         snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(1), wss_base_bits << 4, 0x30);
@@ -455,7 +456,7 @@ __skip_base:
                 irq_bits = 0x04;
                 break;
         default:
-                snd_printk("WSS irq # %d not valid\n", chip->irq);
+                snd_printk(KERN_WARNING "WSS irq # %d not valid\n", chip->irq);
                 goto __skip_resources;
         }
 
@@ -470,13 +471,14 @@ __skip_base:
                 dma_bits = 0x03;
                 break;
         default:
-                snd_printk("WSS dma1 # %d not valid\n", chip->dma1);
+                snd_printk(KERN_WARNING "WSS dma1 # %d not valid\n",
+                           chip->dma1);
                 goto __skip_resources;
         }
 
 #if defined(CS4231) || defined(OPTi93X)
         if (chip->dma1 == chip->dma2) {
-                snd_printk("don't want to share dmas\n");
+                snd_printk(KERN_ERR "don't want to share dmas\n");
                 return -EBUSY;
         }
 
@@ -485,7 +487,8 @@ __skip_base:
         case 1:
                 break;
         default:
-                snd_printk("WSS dma2 # %d not valid\n", chip->dma2);
+                snd_printk(KERN_WARNING "WSS dma2 # %d not valid\n",
+                           chip->dma2);
                 goto __skip_resources;
         }
         dma_bits |= 0x04;
@@ -516,7 +519,8 @@ __skip_resources:
                         mpu_port_bits = 0x00;
                         break;
                 default:
-                        snd_printk("MPU-401 port 0x%lx not valid\n",
+                        snd_printk(KERN_WARNING
+                                   "MPU-401 port 0x%lx not valid\n",
                                 chip->mpu_port);
                         goto __skip_mpu;
                 }
@@ -535,7 +539,7 @@ __skip_resources:
                         mpu_irq_bits = 0x01;
                         break;
                 default:
-                        snd_printk("MPU-401 irq # %d not valid\n",
+                        snd_printk(KERN_WARNING "MPU-401 irq # %d not valid\n",
                                 chip->mpu_irq);
                         goto __skip_mpu;
                 }
@@ -726,7 +730,7 @@ static int __devinit snd_opti9xx_probe(struct snd_card *card)
         if (chip->wss_base == SNDRV_AUTO_PORT) {
                 chip->wss_base = snd_legacy_find_free_ioport(possible_ports, 4);
                 if (chip->wss_base < 0) {
-                        snd_printk("unable to find a free WSS port\n");
+                        snd_printk(KERN_ERR "unable to find a free WSS port\n");
                         return -EBUSY;
                 }
         }
@@ -815,14 +819,8 @@ static int __devinit snd_opti9xx_probe(struct snd_card *card)
                                    chip->fm_port, chip->fm_port + 4 - 1);
                 }
                 if (opl3) {
-#ifdef CS4231
-                        const int t1dev = 1;
-#else
-                        const int t1dev = 0;
-#endif
-                        if ((error = snd_opl3_timer_new(opl3, t1dev, t1dev+1)) < 0)
-                                return error;
-                        if ((error = snd_opl3_hwdep_new(opl3, 0, 1, &synth)) < 0)
+                        error = snd_opl3_hwdep_new(opl3, 0, 1, &synth);
+                        if (error < 0)
                                 return error;
                 }
         }
@@ -900,7 +898,7 @@ static int __devinit snd_opti9xx_isa_probe(struct device *devptr,
 #if defined(CS4231) || defined(OPTi93X)
         if (dma2 == SNDRV_AUTO_DMA) {
                 if ((dma2 = snd_legacy_find_free_dma(possible_dma2s[dma1 % 4])) < 0) {
-                        snd_printk("unable to find a free DMA2\n");
+                        snd_printk(KERN_ERR "unable to find a free DMA2\n");
                         return -EBUSY;
                 }
         }
diff --git a/sound/isa/sb/sb16_csp.c b/sound/isa/sb/sb16_csp.c
index 49037d074c71..bdc8dde4e4a2 100644
--- a/sound/isa/sb/sb16_csp.c
+++ b/sound/isa/sb/sb16_csp.c
@@ -684,15 +684,16 @@ static int snd_sb_csp_load(struct snd_sb_csp * p, const unsigned char *buf, int
  
 static int snd_sb_csp_load_user(struct snd_sb_csp * p, const unsigned char __user *buf, int size, int load_flags)
 {
-        int err = -ENOMEM;
-        unsigned char *kbuf = kmalloc(size, GFP_KERNEL);
-        if (kbuf) {
-                if (copy_from_user(kbuf, buf, size))
-                        err = -EFAULT;
-                else
-                        err = snd_sb_csp_load(p, kbuf, size, load_flags);
-                kfree(kbuf);
-        }
+        int err;
+        unsigned char *kbuf;
+
+        kbuf = memdup_user(buf, size);
+        if (IS_ERR(kbuf))
+                return PTR_ERR(kbuf);
+
+        err = snd_sb_csp_load(p, kbuf, size, load_flags);
+
+        kfree(kbuf);
         return err;
 }
 
diff --git a/sound/isa/sb/sb_mixer.c b/sound/isa/sb/sb_mixer.c
index 406a431af91e..475220bbcc96 100644
--- a/sound/isa/sb/sb_mixer.c
+++ b/sound/isa/sb/sb_mixer.c
@@ -182,7 +182,7 @@ static int snd_sbmixer_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_
 
 static int snd_dt019x_input_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
-        static char *texts[5] = {
+        static const char *texts[5] = {
                 "CD", "Mic", "Line", "Synth", "Master"
         };
 
@@ -269,12 +269,73 @@ static int snd_dt019x_input_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl
 }
 
 /*
+ * ALS4000 mono recording control switch
+ */
+
+static int snd_als4k_mono_capture_route_info(struct snd_kcontrol *kcontrol,
+                                             struct snd_ctl_elem_info *uinfo)
+{
+        static const char *texts[3] = {
+                "L chan only", "R chan only", "L ch/2 + R ch/2"
+        };
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 3;
+        if (uinfo->value.enumerated.item > 2)
+                uinfo->value.enumerated.item = 2;
+        strcpy(uinfo->value.enumerated.name,
+               texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int snd_als4k_mono_capture_route_get(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        unsigned char oval;
+
+        spin_lock_irqsave(&sb->mixer_lock, flags);
+        oval = snd_sbmixer_read(sb, SB_ALS4000_MONO_IO_CTRL);
+        spin_unlock_irqrestore(&sb->mixer_lock, flags);
+        oval >>= 6;
+        if (oval > 2)
+                oval = 2;
+
+        ucontrol->value.enumerated.item[0] = oval;
+        return 0;
+}
+
+static int snd_als4k_mono_capture_route_put(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_sb *sb = snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        unsigned char nval, oval;
+
+        if (ucontrol->value.enumerated.item[0] > 2)
+                return -EINVAL;
+        spin_lock_irqsave(&sb->mixer_lock, flags);
+        oval = snd_sbmixer_read(sb, SB_ALS4000_MONO_IO_CTRL);
+
+        nval = (oval & ~(3 << 6))
+             | (ucontrol->value.enumerated.item[0] << 6);
+        change = nval != oval;
+        if (change)
+                snd_sbmixer_write(sb, SB_ALS4000_MONO_IO_CTRL, nval);
+        spin_unlock_irqrestore(&sb->mixer_lock, flags);
+        return change;
+}
+
+/*
  * SBPRO input multiplexer
  */
 
 static int snd_sb8mixer_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
-        static char *texts[3] = {
+        static const char *texts[3] = {
                 "Mic", "CD", "Line"
         };
 
@@ -442,6 +503,12 @@ int snd_sbmixer_add_ctl(struct snd_sb *chip, const char *name, int index, int ty
                         .get = snd_dt019x_input_sw_get,
                         .put = snd_dt019x_input_sw_put,
                 },
+                [SB_MIX_MONO_CAPTURE_ALS4K] = {
+                        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                        .info = snd_als4k_mono_capture_route_info,
+                        .get = snd_als4k_mono_capture_route_get,
+                        .put = snd_als4k_mono_capture_route_put,
+                },
         };
         struct snd_kcontrol *ctl;
         int err;
@@ -636,6 +703,8 @@ static struct sbmix_elem snd_dt019x_ctl_capture_source =
         };
 
 static struct sbmix_elem *snd_dt019x_controls[] = {
+        /* ALS4000 below has some parts which we might be lacking,
+         * e.g. snd_als4000_ctl_mono_playback_switch - check it! */
         &snd_dt019x_ctl_master_play_vol,
         &snd_dt019x_ctl_pcm_play_vol,
         &snd_dt019x_ctl_synth_play_vol,
@@ -666,18 +735,21 @@ static unsigned char snd_dt019x_init_values[][2] = {
 /*
  * ALS4000 specific mixer elements
  */
-/* FIXME: SB_ALS4000_MONO_IO_CTRL needs output select ctrl! */
 static struct sbmix_elem snd_als4000_ctl_master_mono_playback_switch =
         SB_SINGLE("Master Mono Playback Switch", SB_ALS4000_MONO_IO_CTRL, 5, 1);
-static struct sbmix_elem snd_als4000_ctl_master_mono_capture_route =
-        SB_SINGLE("Master Mono Capture Route", SB_ALS4000_MONO_IO_CTRL, 6, 0x03);
-/* FIXME: mono playback switch also available on DT019X? */
+static struct sbmix_elem snd_als4k_ctl_master_mono_capture_route = {
+                .name = "Master Mono Capture Route",
+                .type = SB_MIX_MONO_CAPTURE_ALS4K
+        };
 static struct sbmix_elem snd_als4000_ctl_mono_playback_switch =
         SB_SINGLE("Mono Playback Switch", SB_DT019X_OUTPUT_SW2, 0, 1);
 static struct sbmix_elem snd_als4000_ctl_mic_20db_boost =
         SB_SINGLE("Mic Boost (+20dB)", SB_ALS4000_MIC_IN_GAIN, 0, 0x03);
-static struct sbmix_elem snd_als4000_ctl_mixer_loopback =
-        SB_SINGLE("Analog Loopback", SB_ALS4000_MIC_IN_GAIN, 7, 0x01);
+static struct sbmix_elem snd_als4000_ctl_mixer_analog_loopback =
+        SB_SINGLE("Analog Loopback Switch", SB_ALS4000_MIC_IN_GAIN, 7, 0x01);
+static struct sbmix_elem snd_als4000_ctl_mixer_digital_loopback =
+        SB_SINGLE("Digital Loopback Switch",
+                  SB_ALS4000_CR3_CONFIGURATION, 7, 0x01);
 /* FIXME: functionality of 3D controls might be swapped, I didn't find
  * a description of how to identify what is supposed to be what */
 static struct sbmix_elem snd_als4000_3d_control_switch =
@@ -694,6 +766,9 @@ static struct sbmix_elem snd_als4000_3d_control_delay =
         SB_SINGLE("3D Control - Wide", SB_ALS4000_3D_TIME_DELAY, 0, 0x0f);
 static struct sbmix_elem snd_als4000_3d_control_poweroff_switch =
         SB_SINGLE("3D PowerOff Switch", SB_ALS4000_3D_TIME_DELAY, 4, 0x01);
+static struct sbmix_elem snd_als4000_ctl_3db_freq_control_switch =
+        SB_SINGLE("Master Playback 8kHz / 20kHz LPF Switch",
+                  SB_ALS4000_FMDAC, 5, 0x01);
 #ifdef NOT_AVAILABLE
 static struct sbmix_elem snd_als4000_ctl_fmdac =
         SB_SINGLE("FMDAC Switch (Option ?)", SB_ALS4000_FMDAC, 0, 0x01);
@@ -702,35 +777,37 @@ static struct sbmix_elem snd_als4000_ctl_qsound =
 #endif
 
 static struct sbmix_elem *snd_als4000_controls[] = {
-        &snd_sb16_ctl_master_play_vol,
-        &snd_dt019x_ctl_pcm_play_switch,
-        &snd_sb16_ctl_pcm_play_vol,
-        &snd_sb16_ctl_synth_capture_route,
-        &snd_dt019x_ctl_synth_play_switch,
-        &snd_sb16_ctl_synth_play_vol,
-        &snd_sb16_ctl_cd_capture_route,
-        &snd_sb16_ctl_cd_play_switch,
-        &snd_sb16_ctl_cd_play_vol,
-        &snd_sb16_ctl_line_capture_route,
-        &snd_sb16_ctl_line_play_switch,
-        &snd_sb16_ctl_line_play_vol,
-        &snd_sb16_ctl_mic_capture_route,
-        &snd_als4000_ctl_mic_20db_boost,
-        &snd_sb16_ctl_auto_mic_gain,
-        &snd_sb16_ctl_mic_play_switch,
-        &snd_sb16_ctl_mic_play_vol,
-        &snd_sb16_ctl_pc_speaker_vol,
-        &snd_sb16_ctl_capture_vol,
-        &snd_sb16_ctl_play_vol,
-        &snd_als4000_ctl_master_mono_playback_switch,
-        &snd_als4000_ctl_master_mono_capture_route,
-        &snd_als4000_ctl_mono_playback_switch,
-        &snd_als4000_ctl_mixer_loopback,
-        &snd_als4000_3d_control_switch,
-        &snd_als4000_3d_control_ratio,
-        &snd_als4000_3d_control_freq,
-        &snd_als4000_3d_control_delay,
-        &snd_als4000_3d_control_poweroff_switch,
+                                                /* ALS4000a.PDF regs page */
+        &snd_sb16_ctl_master_play_vol,          /* MX30/31 12 */
+        &snd_dt019x_ctl_pcm_play_switch,        /* MX4C    16 */
+        &snd_sb16_ctl_pcm_play_vol,             /* MX32/33 12 */
+        &snd_sb16_ctl_synth_capture_route,      /* MX3D/3E 14 */
+        &snd_dt019x_ctl_synth_play_switch,      /* MX4C    16 */
+        &snd_sb16_ctl_synth_play_vol,           /* MX34/35 12/13 */
+        &snd_sb16_ctl_cd_capture_route,         /* MX3D/3E 14 */
+        &snd_sb16_ctl_cd_play_switch,           /* MX3C    14 */
+        &snd_sb16_ctl_cd_play_vol,              /* MX36/37 13 */
+        &snd_sb16_ctl_line_capture_route,       /* MX3D/3E 14 */
+        &snd_sb16_ctl_line_play_switch,         /* MX3C    14 */
+        &snd_sb16_ctl_line_play_vol,            /* MX38/39 13 */
+        &snd_sb16_ctl_mic_capture_route,        /* MX3D/3E 14 */
+        &snd_als4000_ctl_mic_20db_boost,        /* MX4D    16 */
+        &snd_sb16_ctl_mic_play_switch,          /* MX3C    14 */
+        &snd_sb16_ctl_mic_play_vol,             /* MX3A    13 */
+        &snd_sb16_ctl_pc_speaker_vol,           /* MX3B    14 */
+        &snd_sb16_ctl_capture_vol,              /* MX3F/40 15 */
+        &snd_sb16_ctl_play_vol,                 /* MX41/42 15 */
+        &snd_als4000_ctl_master_mono_playback_switch, /* MX4C 16 */
+        &snd_als4k_ctl_master_mono_capture_route, /* MX4B  16 */
+        &snd_als4000_ctl_mono_playback_switch,  /* MX4C    16 */
+        &snd_als4000_ctl_mixer_analog_loopback, /* MX4D    16 */
+        &snd_als4000_ctl_mixer_digital_loopback, /* CR3    21 */
+        &snd_als4000_3d_control_switch,          /* MX50   17 */
+        &snd_als4000_3d_control_ratio,           /* MX50   17 */
+        &snd_als4000_3d_control_freq,            /* MX50   17 */
+        &snd_als4000_3d_control_delay,           /* MX51   18 */
+        &snd_als4000_3d_control_poweroff_switch,        /* MX51    18 */
+        &snd_als4000_ctl_3db_freq_control_switch,       /* MX4F    17 */
 #ifdef NOT_AVAILABLE
         &snd_als4000_ctl_fmdac,
         &snd_als4000_ctl_qsound,
@@ -905,13 +982,14 @@ static unsigned char dt019x_saved_regs[] = {
 };
 
 static unsigned char als4000_saved_regs[] = {
+        /* please verify in dsheet whether regs to be added
+           are actually real H/W or just dummy */
         SB_DSP4_MASTER_DEV, SB_DSP4_MASTER_DEV + 1,
         SB_DSP4_OUTPUT_SW,
         SB_DSP4_PCM_DEV, SB_DSP4_PCM_DEV + 1,
         SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT,
         SB_DSP4_SYNTH_DEV, SB_DSP4_SYNTH_DEV + 1,
         SB_DSP4_CD_DEV, SB_DSP4_CD_DEV + 1,
-        SB_DSP4_MIC_AGC,
         SB_DSP4_MIC_DEV,
         SB_DSP4_SPEAKER_DEV,
         SB_DSP4_IGAIN_DEV, SB_DSP4_IGAIN_DEV + 1,
@@ -919,8 +997,10 @@ static unsigned char als4000_saved_regs[] = {
         SB_DT019X_OUTPUT_SW2,
         SB_ALS4000_MONO_IO_CTRL,
         SB_ALS4000_MIC_IN_GAIN,
+        SB_ALS4000_FMDAC,
         SB_ALS4000_3D_SND_FX,
         SB_ALS4000_3D_TIME_DELAY,
+        SB_ALS4000_CR3_CONFIGURATION,
 };
 
 static void save_mixer(struct snd_sb *chip, unsigned char *regs, int num_regs)
diff --git a/sound/isa/sc6000.c b/sound/isa/sc6000.c
index 7a1470376c6d..782010608ef4 100644
--- a/sound/isa/sc6000.c
+++ b/sound/isa/sc6000.c
@@ -576,10 +576,6 @@ static int __devinit snd_sc6000_probe(struct device *devptr, unsigned int dev)
                 snd_printk(KERN_ERR PFX "no OPL device at 0x%x-0x%x ?\n",
                            0x388, 0x388 + 2);
         } else {
-                err = snd_opl3_timer_new(opl3, 0, 1);
-                if (err < 0)
-                        goto err_unmap2;
-
                 err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
                 if (err < 0)
                         goto err_unmap2;
diff --git a/sound/isa/sscape.c b/sound/isa/sscape.c
index 4025fb558c50..66187122377c 100644
--- a/sound/isa/sscape.c
+++ b/sound/isa/sscape.c
@@ -89,9 +89,6 @@ MODULE_DEVICE_TABLE(pnp_card, sscape_pnpids);
 #endif
 
 
-#define MPU401_IO(i)     ((i) + 0)
-#define MIDI_DATA_IO(i)  ((i) + 0)
-#define MIDI_CTRL_IO(i)  ((i) + 1)
 #define HOST_CTRL_IO(i)  ((i) + 2)
 #define HOST_DATA_IO(i)  ((i) + 3)
 #define ODIE_ADDR_IO(i)  ((i) + 4)
@@ -129,9 +126,6 @@ enum GA_REG {
 #define DMA_8BIT  0x80
 
 
-#define AD1845_FREQ_SEL_MSB    0x16
-#define AD1845_FREQ_SEL_LSB    0x17
-
 enum card_type {
         SSCAPE,
         SSCAPE_PNP,
@@ -141,8 +135,6 @@ enum card_type {
 struct soundscape {
         spinlock_t lock;
         unsigned io_base;
-        unsigned wss_base;
-        int codec_type;
         int ic_type;
         enum card_type type;
         struct resource *io_res;
@@ -330,7 +322,7 @@ static int host_write_ctrl_unsafe(unsigned io_base, unsigned char data,
  */
 static inline int verify_mpu401(const struct snd_mpu401 * mpu)
 {
-        return ((inb(MIDI_CTRL_IO(mpu->port)) & 0xc0) == 0x80);
+        return ((inb(MPU401C(mpu)) & 0xc0) == 0x80);
 }
 
 /*
@@ -338,7 +330,7 @@ static inline int verify_mpu401(const struct snd_mpu401 * mpu)
  */
 static inline void initialise_mpu401(const struct snd_mpu401 * mpu)
 {
-        outb(0, MIDI_DATA_IO(mpu->port));
+        outb(0, MPU401D(mpu));
 }
 
 /*
@@ -396,20 +388,20 @@ static int sscape_wait_dma_unsafe(unsigned io_base, enum GA_REG reg, unsigned ti
  */
 static int obp_startup_ack(struct soundscape *s, unsigned timeout)
 {
-        while (timeout != 0) {
+        unsigned long end_time = jiffies + msecs_to_jiffies(timeout);
+
+        do {
                 unsigned long flags;
                 unsigned char x;
 
-                schedule_timeout_uninterruptible(1);
-
                 spin_lock_irqsave(&s->lock, flags);
                 x = inb(HOST_DATA_IO(s->io_base));
                 spin_unlock_irqrestore(&s->lock, flags);
                 if ((x & 0xfe) == 0xfe)
                         return 1;
 
-                --timeout;
-        } /* while */
+                msleep(10);
+        } while (time_before(jiffies, end_time));
 
         return 0;
 }
@@ -423,20 +415,20 @@ static int obp_startup_ack(struct soundscape *s, unsigned timeout)
  */
 static int host_startup_ack(struct soundscape *s, unsigned timeout)
 {
-        while (timeout != 0) {
+        unsigned long end_time = jiffies + msecs_to_jiffies(timeout);
+
+        do {
                 unsigned long flags;
                 unsigned char x;
 
-                schedule_timeout_uninterruptible(1);
-
                 spin_lock_irqsave(&s->lock, flags);
                 x = inb(HOST_DATA_IO(s->io_base));
                 spin_unlock_irqrestore(&s->lock, flags);
                 if (x == 0xfe)
                         return 1;
 
-                --timeout;
-        } /* while */
+                msleep(10);
+        } while (time_before(jiffies, end_time));
 
         return 0;
 }
@@ -532,10 +524,10 @@ static int upload_dma_data(struct soundscape *s,
          * give it 5 seconds (max) ...
          */
         ret = 0;
-        if (!obp_startup_ack(s, 5)) {
+        if (!obp_startup_ack(s, 5000)) {
                 snd_printk(KERN_ERR "sscape: No response from on-board processor after upload\n");
                 ret = -EAGAIN;
-        } else if (!host_startup_ack(s, 5)) {
+        } else if (!host_startup_ack(s, 5000)) {
                 snd_printk(KERN_ERR "sscape: SoundScape failed to initialise\n");
                 ret = -EAGAIN;
         }
@@ -732,13 +724,7 @@ static int sscape_midi_get(struct snd_kcontrol *kctl,
         unsigned long flags;
 
         spin_lock_irqsave(&s->lock, flags);
-        set_host_mode_unsafe(s->io_base);
-
-        if (host_write_ctrl_unsafe(s->io_base, CMD_GET_MIDI_VOL, 100)) {
-                uctl->value.integer.value[0] = host_read_ctrl_unsafe(s->io_base, 100);
-        }
-
-        set_midi_mode_unsafe(s->io_base);
+        uctl->value.integer.value[0] = s->midi_vol;
         spin_unlock_irqrestore(&s->lock, flags);
         return 0;
 }
@@ -773,6 +759,7 @@ static int sscape_midi_put(struct snd_kcontrol *kctl,
         change = (host_write_ctrl_unsafe(s->io_base, CMD_SET_MIDI_VOL, 100)
                   && host_write_ctrl_unsafe(s->io_base, ((unsigned char) uctl->value.integer. value[0]) & 127, 100)
                   && host_write_ctrl_unsafe(s->io_base, CMD_XXX_MIDI_VOL, 100));
+        s->midi_vol = (unsigned char) uctl->value.integer.value[0] & 127;
       __skip_change:
 
         /*
@@ -815,12 +802,11 @@ static unsigned __devinit get_irq_config(int irq)
  * Perform certain arcane port-checks to see whether there
  * is a SoundScape board lurking behind the given ports.
  */
-static int __devinit detect_sscape(struct soundscape *s)
+static int __devinit detect_sscape(struct soundscape *s, long wss_io)
 {
         unsigned long flags;
         unsigned d;
         int retval = 0;
-        int codec = s->wss_base;
 
         spin_lock_irqsave(&s->lock, flags);
 
@@ -836,13 +822,11 @@ static int __devinit detect_sscape(struct soundscape *s)
         if ((d & 0x80) != 0)
                 goto _done;
 
-        if (d == 0) {
-                s->codec_type = 1;
+        if (d == 0)
                 s->ic_type = IC_ODIE;
-        } else if ((d & 0x60) != 0) {
-                s->codec_type = 2;
+        else if ((d & 0x60) != 0)
                 s->ic_type = IC_OPUS;
-        } else
+        else
                 goto _done;
 
         outb(0xfa, ODIE_ADDR_IO(s->io_base));
@@ -862,10 +846,10 @@ static int __devinit detect_sscape(struct soundscape *s)
         sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0);
 
         if (s->type == SSCAPE_VIVO)
-                codec += 4;
+                wss_io += 4;
         /* wait for WSS codec */
         for (d = 0; d < 500; d++) {
-                if ((inb(codec) & 0x80) == 0)
+                if ((inb(wss_io) & 0x80) == 0)
                         break;
                 spin_unlock_irqrestore(&s->lock, flags);
                 msleep(1);
@@ -955,82 +939,6 @@ static int __devinit create_mpu401(struct snd_card *card, int devnum, unsigned l
 
 
 /*
- * Override for the CS4231 playback format function.
- * The AD1845 has much simpler format and rate selection.
- */
-static void ad1845_playback_format(struct snd_wss *chip,
-                                   struct snd_pcm_hw_params *params,
-                                   unsigned char format)
-{
-        unsigned long flags;
-        unsigned rate = params_rate(params);
-
-        /*
-         * The AD1845 can't handle sample frequencies
-         * outside of 4 kHZ to 50 kHZ
-         */
-        if (rate > 50000)
-                rate = 50000;
-        else if (rate < 4000)
-                rate = 4000;
-
-        spin_lock_irqsave(&chip->reg_lock, flags);
-
-        /*
-         * Program the AD1845 correctly for the playback stream.
-         * Note that we do NOT need to toggle the MCE bit because
-         * the PLAYBACK_ENABLE bit of the Interface Configuration
-         * register is set.
-         * 
-         * NOTE: We seem to need to write to the MSB before the LSB
-         *       to get the correct sample frequency.
-         */
-        snd_wss_out(chip, CS4231_PLAYBK_FORMAT, (format & 0xf0));
-        snd_wss_out(chip, AD1845_FREQ_SEL_MSB, (unsigned char) (rate >> 8));
-        snd_wss_out(chip, AD1845_FREQ_SEL_LSB, (unsigned char) rate);
-
-        spin_unlock_irqrestore(&chip->reg_lock, flags);
-}
-
-/*
- * Override for the CS4231 capture format function. 
- * The AD1845 has much simpler format and rate selection.
- */
-static void ad1845_capture_format(struct snd_wss *chip,
-                                  struct snd_pcm_hw_params *params,
-                                  unsigned char format)
-{
-        unsigned long flags;
-        unsigned rate = params_rate(params);
-
-        /*
-         * The AD1845 can't handle sample frequencies 
-         * outside of 4 kHZ to 50 kHZ
-         */
-        if (rate > 50000)
-                rate = 50000;
-        else if (rate < 4000)
-                rate = 4000;
-
-        spin_lock_irqsave(&chip->reg_lock, flags);
-
-        /*
-         * Program the AD1845 correctly for the playback stream.
-         * Note that we do NOT need to toggle the MCE bit because
-         * the CAPTURE_ENABLE bit of the Interface Configuration
-         * register is set.
-         *
-         * NOTE: We seem to need to write to the MSB before the LSB
-         *       to get the correct sample frequency.
-         */
-        snd_wss_out(chip, CS4231_REC_FORMAT, (format & 0xf0));
-        snd_wss_out(chip, AD1845_FREQ_SEL_MSB, (unsigned char) (rate >> 8));
-        snd_wss_out(chip, AD1845_FREQ_SEL_LSB, (unsigned char) rate);
-
-        spin_unlock_irqrestore(&chip->reg_lock, flags);
-}
-
-/*
  * Create an AD1845 PCM subdevice on the SoundScape. The AD1845
  * is very much like a CS4231, with a few extra bits. We will
  * try to support at least some of the extra bits by overriding
@@ -1055,11 +963,6 @@ static int __devinit create_ad1845(struct snd_card *card, unsigned port,
                 unsigned long flags;
                 struct snd_pcm *pcm;
 
-#define AD1845_FREQ_SEL_ENABLE  0x08
-
-#define AD1845_PWR_DOWN_CTRL   0x1b
-#define AD1845_CRYS_CLOCK_SEL  0x1d
-
 /*
  * It turns out that the PLAYBACK_ENABLE bit is set
  * by the lowlevel driver ...
@@ -1074,7 +977,6 @@ static int __devinit create_ad1845(struct snd_card *card, unsigned port,
  */
 
                 if (sscape->type != SSCAPE_VIVO) {
-                        int val;
                         /*
                          * The input clock frequency on the SoundScape must
                          * be 14.31818 MHz, because we must set this register
@@ -1082,22 +984,10 @@ static int __devinit create_ad1845(struct snd_card *card, unsigned port,
                          */
                         snd_wss_mce_up(chip);
                         spin_lock_irqsave(&chip->reg_lock, flags);
-                        snd_wss_out(chip, AD1845_CRYS_CLOCK_SEL, 0x20);
+                        snd_wss_out(chip, AD1845_CLOCK, 0x20);
                         spin_unlock_irqrestore(&chip->reg_lock, flags);
                         snd_wss_mce_down(chip);
 
-                        /*
-                         * More custom configuration:
-                         * a) select "mode 2" and provide a current drive of 8mA
-                         * b) enable frequency selection (for capture/playback)
-                         */
-                        spin_lock_irqsave(&chip->reg_lock, flags);
-                        snd_wss_out(chip, CS4231_MISC_INFO,
-                                    CS4231_MODE2 | 0x10);
-                        val = snd_wss_in(chip, AD1845_PWR_DOWN_CTRL);
-                        snd_wss_out(chip, AD1845_PWR_DOWN_CTRL,
-                                    val | AD1845_FREQ_SEL_ENABLE);
-                        spin_unlock_irqrestore(&chip->reg_lock, flags);
                 }
 
                 err = snd_wss_pcm(chip, 0, &pcm);
@@ -1113,11 +1003,13 @@ static int __devinit create_ad1845(struct snd_card *card, unsigned port,
                                             "for AD1845 chip\n");
                         goto _error;
                 }
-                err = snd_wss_timer(chip, 0, NULL);
-                if (err < 0) {
-                        snd_printk(KERN_ERR "sscape: No timer device "
-                                            "for AD1845 chip\n");
-                        goto _error;
+                if (chip->hardware != WSS_HW_AD1848) {
+                        err = snd_wss_timer(chip, 0, NULL);
+                        if (err < 0) {
+                                snd_printk(KERN_ERR "sscape: No timer device "
+                                                    "for AD1845 chip\n");
+                                goto _error;
+                        }
                 }
 
                 if (sscape->type != SSCAPE_VIVO) {
@@ -1128,8 +1020,6 @@ static int __devinit create_ad1845(struct snd_card *card, unsigned port,
                                                     "MIDI mixer control\n");
                                 goto _error;
                         }
-                        chip->set_playback_format = ad1845_playback_format;
-                        chip->set_capture_format = ad1845_capture_format;
                 }
 
                 strcpy(card->driver, "SoundScape");
@@ -1157,7 +1047,6 @@ static int __devinit create_sscape(int dev, struct snd_card *card)
         unsigned dma_cfg;
         unsigned irq_cfg;
         unsigned mpu_irq_cfg;
-        unsigned xport;
         struct resource *io_res;
         struct resource *wss_res;
         unsigned long flags;
@@ -1177,15 +1066,15 @@ static int __devinit create_sscape(int dev, struct snd_card *card)
                 printk(KERN_ERR "sscape: Invalid IRQ %d\n", mpu_irq[dev]);
                 return -ENXIO;
         }
-        xport = port[dev];
 
         /*
          * Grab IO ports that we will need to probe so that we
          * can detect and control this hardware ...
          */
-        io_res = request_region(xport, 8, "SoundScape");
+        io_res = request_region(port[dev], 8, "SoundScape");
         if (!io_res) {
-                snd_printk(KERN_ERR "sscape: can't grab port 0x%x\n", xport);
+                snd_printk(KERN_ERR
+                           "sscape: can't grab port 0x%lx\n", port[dev]);
                 return -EBUSY;
         }
         wss_res = NULL;
@@ -1212,10 +1101,9 @@ static int __devinit create_sscape(int dev, struct snd_card *card)
         spin_lock_init(&sscape->fwlock);
         sscape->io_res = io_res;
         sscape->wss_res = wss_res;
-        sscape->io_base = xport;
-        sscape->wss_base = wss_port[dev];
+        sscape->io_base = port[dev];
 
-        if (!detect_sscape(sscape)) {
+        if (!detect_sscape(sscape, wss_port[dev])) {
                 printk(KERN_ERR "sscape: hardware not detected at 0x%x\n", sscape->io_base);
                 err = -ENODEV;
                 goto _release_dma;
@@ -1288,12 +1176,11 @@ static int __devinit create_sscape(int dev, struct snd_card *card)
         }
 #define MIDI_DEVNUM  0
         if (sscape->type != SSCAPE_VIVO) {
-                err = create_mpu401(card, MIDI_DEVNUM,
-                                    MPU401_IO(xport), mpu_irq[dev]);
+                err = create_mpu401(card, MIDI_DEVNUM, port[dev], mpu_irq[dev]);
                 if (err < 0) {
                         printk(KERN_ERR "sscape: Failed to create "
-                                        "MPU-401 device at 0x%x\n",
-                                        MPU401_IO(xport));
+                                        "MPU-401 device at 0x%lx\n",
+                                        port[dev]);
                         goto _release_dma;
                 }
 
diff --git a/sound/isa/wavefront/wavefront.c b/sound/isa/wavefront/wavefront.c
index 95898b2b7b58..a34ae7b1f7d0 100644
--- a/sound/isa/wavefront/wavefront.c
+++ b/sound/isa/wavefront/wavefront.c
@@ -553,11 +553,11 @@ static int __devinit snd_wavefront_isa_match(struct device *pdev,
                 return 0;
 #endif
         if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) {
-                snd_printk("specify CS4232 port\n");
+                snd_printk(KERN_ERR "specify CS4232 port\n");
                 return 0;
         }
         if (ics2115_port[dev] == SNDRV_AUTO_PORT) {
-                snd_printk("specify ICS2115 port\n");
+                snd_printk(KERN_ERR "specify ICS2115 port\n");
                 return 0;
         }
         return 1;
diff --git a/sound/isa/wavefront/wavefront_fx.c b/sound/isa/wavefront/wavefront_fx.c
index dfc449a2194e..2bb1cee09255 100644
--- a/sound/isa/wavefront/wavefront_fx.c
+++ b/sound/isa/wavefront/wavefront_fx.c
@@ -34,14 +34,6 @@
 
 #define WAIT_IDLE       0xff
 
-#ifdef CONFIG_SND_WAVEFRONT_FIRMWARE_IN_KERNEL
-#include "yss225.c"
-static const struct firmware yss225_registers_firmware = {
-        .data = (u8 *)yss225_registers,
-        .size = sizeof yss225_registers
-};
-#endif
-
 static int
 wavefront_fx_idle (snd_wavefront_t *dev)
 
@@ -210,15 +202,11 @@ snd_wavefront_fx_ioctl (struct snd_hwdep *sdev, struct file *file,
                                             "> 512 bytes to FX\n");
                                 return -EIO;
                         }
-                        page_data = kmalloc(r.data[2] * sizeof(short), GFP_KERNEL);
-                        if (!page_data)
-                                return -ENOMEM;
-                        if (copy_from_user (page_data,
-                                            (unsigned char __user *) r.data[3],
-                                            r.data[2] * sizeof(short))) {
-                                kfree(page_data);
-                                return -EFAULT;
-                        }
+                        page_data = memdup_user((unsigned char __user *)
+                                                r.data[3],
+                                                r.data[2] * sizeof(short));
+                        if (IS_ERR(page_data))
+                                return PTR_ERR(page_data);
                         pd = page_data;
                 }
 
@@ -260,16 +248,12 @@ snd_wavefront_fx_start (snd_wavefront_t *dev)
         if (dev->fx_initialized)
                 return 0;
 
-#ifdef CONFIG_SND_WAVEFRONT_FIRMWARE_IN_KERNEL
-        firmware = &yss225_registers_firmware;
-#else
         err = request_firmware(&firmware, "yamaha/yss225_registers.bin",
                                dev->card->dev);
         if (err < 0) {
                 err = -1;
                 goto out;
         }
-#endif
 
         for (i = 0; i + 1 < firmware->size; i += 2) {
                 if (firmware->data[i] >= 8 && firmware->data[i] < 16) {
@@ -292,12 +276,8 @@ snd_wavefront_fx_start (snd_wavefront_t *dev)
         err = 0;
 
 out:
-#ifndef CONFIG_SND_WAVEFRONT_FIRMWARE_IN_KERNEL
         release_firmware(firmware);
-#endif
         return err;
 }
 
-#ifndef CONFIG_SND_WAVEFRONT_FIRMWARE_IN_KERNEL
 MODULE_FIRMWARE("yamaha/yss225_registers.bin");
-#endif
diff --git a/sound/isa/wavefront/wavefront_synth.c b/sound/isa/wavefront/wavefront_synth.c
index 4c410820a994..5d4ff48c4345 100644
--- a/sound/isa/wavefront/wavefront_synth.c
+++ b/sound/isa/wavefront/wavefront_synth.c
@@ -633,7 +633,7 @@ wavefront_get_sample_status (snd_wavefront_t *dev, int assume_rom)
                 wbuf[1] = i >> 7;
 
                 if (snd_wavefront_cmd (dev, WFC_IDENTIFY_SAMPLE_TYPE, rbuf, wbuf)) {
-                        snd_printk("cannot identify sample "
+                        snd_printk(KERN_WARNING "cannot identify sample "
                                    "type of slot %d\n", i);
                         dev->sample_status[i] = WF_ST_EMPTY;
                         continue;
@@ -1664,12 +1664,11 @@ snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file,
                 break;
 
         case WFCTL_WFCMD:
-                wc = kmalloc(sizeof(*wc), GFP_KERNEL);
-                if (! wc)
-                        return -ENOMEM;
-                if (copy_from_user (wc, argp, sizeof (*wc)))
-                        err = -EFAULT;
-                else if (wavefront_synth_control (acard, wc) < 0)
+                wc = memdup_user(argp, sizeof(*wc));
+                if (IS_ERR(wc))
+                        return PTR_ERR(wc);
+
+                if (wavefront_synth_control (acard, wc) < 0)
                         err = -EIO;
                 else if (copy_to_user (argp, wc, sizeof (*wc)))
                         err = -EFAULT;
diff --git a/sound/isa/wavefront/yss225.c b/sound/isa/wavefront/yss225.c
deleted file mode 100644
index 9f6be3ff8ecf..000000000000
--- a/sound/isa/wavefront/yss225.c
+++ /dev/null
@@ -1,2739 +0,0 @@
-/*
- *  Copyright (c) 1998-2002 by Paul Davis <pbd@op.net>
- *
- *  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
- */
-
-/* weird stuff, derived from port I/O tracing with dosemu */
-
-static const struct {
-        unsigned char addr;
-        unsigned char data;
-} yss225_registers[] __devinitdata = {
-/* Set all bits for all channels on the MOD unit to zero */
-{ WAIT_IDLE }, { 0xe, 0x10 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x11 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x12 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x13 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x14 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x15 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x16 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x17 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x18 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x19 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x20 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x21 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x22 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x23 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x24 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x25 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x26 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x27 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x28 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x29 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x30 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x31 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x32 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x33 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x34 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x35 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x36 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x37 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x38 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x39 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x40 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x41 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x42 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x43 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x44 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x45 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x46 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x47 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x48 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x49 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x50 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x51 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x52 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x53 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x54 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x55 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x56 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x57 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x58 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x59 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x60 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x61 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x62 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x63 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x64 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x65 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x66 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x67 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x68 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x69 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x70 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x71 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x72 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x73 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x74 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x75 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x76 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x77 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x78 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x79 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x80 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x81 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x82 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x83 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x84 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x85 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x86 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x87 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x88 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x89 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x90 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x91 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x92 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x93 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x94 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x95 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x96 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x97 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x98 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x99 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xaa }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xab }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xac }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xad }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xae }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xaf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xba }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbe }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xca }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xce }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xda }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xde }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xea }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xeb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xec }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xed }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xee }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xef }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfa }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfe }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xff }, { 0xf, 0x00 },
-
-/* XXX But why do this twice? */
-{ WAIT_IDLE }, { 0xe, 0x10 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x11 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x12 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x13 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x14 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x15 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x16 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x17 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x18 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x19 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x20 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x21 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x22 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x23 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x24 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x25 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x26 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x27 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x28 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x29 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x30 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x31 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x32 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x33 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x34 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x35 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x36 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x37 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x38 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x39 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x40 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x41 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x42 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x43 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x44 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x45 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x46 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x47 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x48 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x49 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x50 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x51 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x52 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x53 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x54 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x55 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x56 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x57 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x58 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x59 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x60 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x61 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x62 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x63 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x64 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x65 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x66 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x67 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x68 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x69 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x70 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x71 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x72 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x73 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x74 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x75 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x76 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x77 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x78 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x79 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x80 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x81 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x82 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x83 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x84 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x85 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x86 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x87 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x88 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x89 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x90 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x91 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x92 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x93 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x94 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x95 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x96 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x97 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x98 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x99 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xaa }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xab }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xac }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xad }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xae }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xaf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xba }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbe }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xca }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xce }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xda }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xde }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xea }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xeb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xec }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xed }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xee }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xef }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfa }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfe }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xff }, { 0xf, 0x00 },
-
-/* mute on */
-{ WAIT_IDLE }, { 0x8, 0x02 },
-
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x44 }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x42 }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x43 }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x7c }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x7e }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x46 }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x49 }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x47 }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x4a }, { 0xd, 0x00 }, { 0xc, 0x00 },
-
-/* either because of stupidity by TB's programmers, or because it
-   actually does something, rezero the MOD page. */
-{ WAIT_IDLE }, { 0xe, 0x10 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x11 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x12 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x13 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x14 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x15 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x16 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x17 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x18 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x19 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x1f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x20 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x21 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x22 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x23 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x24 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x25 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x26 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x27 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x28 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x29 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x2f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x30 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x31 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x32 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x33 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x34 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x35 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x36 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x37 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x38 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x39 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x3f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x40 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x41 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x42 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x43 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x44 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x45 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x46 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x47 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x48 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x49 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x4f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x50 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x51 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x52 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x53 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x54 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x55 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x56 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x57 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x58 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x59 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x5f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x60 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x61 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x62 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x63 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x64 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x65 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x66 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x67 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x68 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x69 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x6f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x70 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x71 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x72 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x73 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x74 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x75 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x76 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x77 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x78 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x79 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x7f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x80 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x81 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x82 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x83 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x84 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x85 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x86 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x87 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x88 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x89 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x8f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x90 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x91 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x92 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x93 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x94 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x95 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x96 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x97 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x98 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x99 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9a }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9b }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9c }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9d }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9e }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0x9f }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xa9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xaa }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xab }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xac }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xad }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xae }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xaf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xb9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xba }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbe }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xbf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xc9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xca }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xce }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xcf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xd9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xda }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xde }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xdf }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xe9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xea }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xeb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xec }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xed }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xee }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xef }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf0 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf1 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf2 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf3 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf4 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf5 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf6 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf7 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf8 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xf9 }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfa }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfb }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfc }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfd }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xfe }, { 0xf, 0x00 },
-{ WAIT_IDLE }, { 0xe, 0xff }, { 0xf, 0x00 },
-
-/* load page zero */
-{ 0x9, 0x05 }, { 0xb, 0x00 }, { 0xa, 0x00 },
-
-{ 0xd, 0x01 }, { 0xc, 0x7c }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1e }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0xf5 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x11 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x32 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x13 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x14 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x76 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x80 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x18 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x19 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0x1a }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0x17 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0x80 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x10 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0xa0 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0xd1 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0xf2 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x13 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0xf4 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xe0 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x15 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x16 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x17 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x50 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x71 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x92 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x80 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0xb3 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0xa0 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0xd4 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x80 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0xf5 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x70 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0xa0 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x11 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x16 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x10 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x17 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1b }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1d }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xdf }, { WAIT_IDLE },
-
-/* Now load page one */
-{ 0x9, 0x05 }, { 0xb, 0x01 }, { 0xa, 0x00 },
-
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x19 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1f }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0xd8 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x19 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x18 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0xfa }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1a }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x80 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xfb }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xa0 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1b }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xd7 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xf7 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1c }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0x3c }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0x3f }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0xdf }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0x5d }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0x7d }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0x9e }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0xbe }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x03 }, { 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1b }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xdb }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xdb }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xe0 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xfb }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xfb }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1b }, { WAIT_IDLE },
-
-{ 0x9, 0x05 }, { 0xb, 0x02 }, { 0xa, 0x00 },
-
-{ 0xc, 0xc4 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x25 }, { WAIT_IDLE },
-{ 0xc, 0x01 }, { WAIT_IDLE },
-{ 0xc, 0x06 }, { WAIT_IDLE },
-{ 0xc, 0xc4 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x25 }, { WAIT_IDLE },
-{ 0xc, 0x01 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x04 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x04 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x05 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x44 }, { WAIT_IDLE },
-
-{ 0x9, 0x05 }, { 0xb, 0x03 }, { 0xa, 0x00 },
-
-{ 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x47 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x06 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x80 }, { WAIT_IDLE },
-{ 0xc, 0x80 }, { WAIT_IDLE },
-{ 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x70 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x42 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x42 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x42 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x42 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x40 }, { WAIT_IDLE },
-
-{ 0x9, 0x05 }, { 0xb, 0x04 }, { 0xa, 0x00 },
-
-{ 0xc, 0x63 }, { WAIT_IDLE },
-{ 0xc, 0x03 }, { WAIT_IDLE },
-{ 0xc, 0x26 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x2c }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x24 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x2e }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x01 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x22 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x22 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x22 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x62 }, { WAIT_IDLE },
-{ 0xc, 0x02 }, { WAIT_IDLE },
-{ 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xc, 0x01 }, { WAIT_IDLE },
-{ 0xc, 0x21 }, { WAIT_IDLE },
-{ 0xc, 0x01 }, { WAIT_IDLE },
-
-/* Load memory area (page six) */
-{ 0x9, 0x01 }, { 0xb, 0x06 },
-
-{ 0xa, 0x00 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x02 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x04 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x06 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x08 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x0a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x0c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x0e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x10 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x12 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x14 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x16 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x18 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x1a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x1c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x1e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x20 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x22 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x24 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x26 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x28 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x2a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x2c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x2e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x30 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x32 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x34 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x36 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x38 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x3a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x3c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x3e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x40 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x42 }, { 0xd, 0x03 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x44 }, { 0xd, 0x01 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x46 }, { 0xd, 0x0a }, { 0xc, 0x21 }, { WAIT_IDLE },
-{ 0xa, 0x48 }, { 0xd, 0x0d }, { 0xc, 0x23 }, { WAIT_IDLE },
-{ 0xa, 0x4a }, { 0xd, 0x23 }, { 0xc, 0x1b }, { WAIT_IDLE },
-{ 0xa, 0x4c }, { 0xd, 0x37 }, { 0xc, 0x8f }, { WAIT_IDLE },
-{ 0xa, 0x4e }, { 0xd, 0x45 }, { 0xc, 0x77 }, { WAIT_IDLE },
-{ 0xa, 0x50 }, { 0xd, 0x52 }, { 0xc, 0xe2 }, { WAIT_IDLE },
-{ 0xa, 0x52 }, { 0xd, 0x1c }, { 0xc, 0x92 }, { WAIT_IDLE },
-{ 0xa, 0x54 }, { 0xd, 0x1c }, { 0xc, 0x52 }, { WAIT_IDLE },
-{ 0xa, 0x56 }, { 0xd, 0x07 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x58 }, { 0xd, 0x2f }, { 0xc, 0xc6 }, { WAIT_IDLE },
-{ 0xa, 0x5a }, { 0xd, 0x0b }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x5c }, { 0xd, 0x30 }, { 0xc, 0x06 }, { WAIT_IDLE },
-{ 0xa, 0x5e }, { 0xd, 0x17 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x60 }, { 0xd, 0x3d }, { 0xc, 0xda }, { WAIT_IDLE },
-{ 0xa, 0x62 }, { 0xd, 0x29 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x64 }, { 0xd, 0x3e }, { 0xc, 0x41 }, { WAIT_IDLE },
-{ 0xa, 0x66 }, { 0xd, 0x39 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x68 }, { 0xd, 0x4c }, { 0xc, 0x48 }, { WAIT_IDLE },
-{ 0xa, 0x6a }, { 0xd, 0x49 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x6c }, { 0xd, 0x4c }, { 0xc, 0x6c }, { WAIT_IDLE },
-{ 0xa, 0x6e }, { 0xd, 0x11 }, { 0xc, 0xd2 }, { WAIT_IDLE },
-{ 0xa, 0x70 }, { 0xd, 0x16 }, { 0xc, 0x0c }, { WAIT_IDLE },
-{ 0xa, 0x72 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x74 }, { 0xd, 0x00 }, { 0xc, 0x80 }, { WAIT_IDLE },
-{ 0xa, 0x76 }, { 0xd, 0x0f }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x78 }, { 0xd, 0x00 }, { 0xc, 0x80 }, { WAIT_IDLE },
-{ 0xa, 0x7a }, { 0xd, 0x13 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x7c }, { 0xd, 0x80 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x7e }, { 0xd, 0x80 }, { 0xc, 0x80 }, { WAIT_IDLE },
-
-{ 0x9, 0x05 }, { 0xb, 0x07 }, { 0xa, 0x00 },
-
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x08 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x08 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x08 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x08 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0xe9 }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0x8c }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0x8c }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x1a }, { 0xc, 0x75 }, { WAIT_IDLE },
-{ 0xd, 0x0d }, { 0xc, 0x8b }, { WAIT_IDLE },
-{ 0xd, 0x04 }, { 0xc, 0xe9 }, { WAIT_IDLE },
-{ 0xd, 0x0b }, { 0xc, 0x16 }, { WAIT_IDLE },
-{ 0xd, 0x1a }, { 0xc, 0x38 }, { WAIT_IDLE },
-{ 0xd, 0x0d }, { 0xc, 0xc8 }, { WAIT_IDLE },
-{ 0xd, 0x04 }, { 0xc, 0x6f }, { WAIT_IDLE },
-{ 0xd, 0x0b }, { 0xc, 0x91 }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x8f }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0x62 }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0x62 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x7b }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0x97 }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0x97 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x52 }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0xf6 }, { WAIT_IDLE },
-{ 0xd, 0x06 }, { 0xc, 0xf6 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x19 }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x55 }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x55 }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x55 }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x55 }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x55 }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x55 }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x55 }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x55 }, { WAIT_IDLE },
-{ 0xd, 0x14 }, { 0xc, 0xda }, { WAIT_IDLE },
-{ 0xd, 0x0d }, { 0xc, 0x93 }, { WAIT_IDLE },
-{ 0xd, 0x04 }, { 0xc, 0xda }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x93 }, { WAIT_IDLE },
-{ 0xd, 0x14 }, { 0xc, 0xda }, { WAIT_IDLE },
-{ 0xd, 0x0d }, { 0xc, 0x93 }, { WAIT_IDLE },
-{ 0xd, 0x04 }, { 0xc, 0xda }, { WAIT_IDLE },
-{ 0xd, 0x05 }, { 0xc, 0x93 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-
-/* Now setup the MOD area. */
-{ 0xe, 0x01 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x02 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x03 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x04 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x05 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x06 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x07 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x08 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x09 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0a }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0b }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0c }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0d }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0e }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0f }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-
-{ 0xe, 0xb0 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb1 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb2 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb3 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb4 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb5 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb6 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb7 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb8 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb9 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xba }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xbb }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xbc }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xbd }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xbe }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xbf }, { 0xf, 0x20 }, { WAIT_IDLE },
-
-{ 0xe, 0xf0 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf1 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf2 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf3 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf4 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf5 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf6 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf7 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf8 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf9 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xfa }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xfb }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xfc }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xfd }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xfe }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xff }, { 0xf, 0x20 }, { WAIT_IDLE },
-
-{ 0xe, 0x10 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x11 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x12 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x13 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x14 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x15 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x16 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x17 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x18 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x19 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x1a }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x1b }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x1c }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x1d }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x1e }, { 0xf, 0x40 }, { WAIT_IDLE },
-{ 0xe, 0x1f }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x20 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x21 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x22 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x23 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x24 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x25 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x26 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x27 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x28 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x29 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x2a }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x2b }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x2c }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x2d }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x2e }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x2f }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x30 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x31 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x32 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x33 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x34 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x35 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x36 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x37 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x38 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x39 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x3a }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x3b }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x3c }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x3d }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x3e }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x3f }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0x40 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x41 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x42 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x43 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x44 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x45 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x46 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x47 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x48 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x49 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x4a }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x4b }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x4c }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x4d }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x4e }, { 0xf, 0x0e }, { WAIT_IDLE },
-{ 0xe, 0x4f }, { 0xf, 0x0e }, { WAIT_IDLE },
-{ 0xe, 0x50 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x51 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x52 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x53 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x54 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x55 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x56 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x57 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x58 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x59 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x5a }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x5b }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x5c }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x5d }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x5e }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x5f }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x60 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x61 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x62 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x63 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x64 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x65 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x66 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x67 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x68 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x69 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x6a }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x6b }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x6c }, { 0xf, 0x40 }, { WAIT_IDLE },
-{ 0xe, 0x6d }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x6e }, { 0xf, 0x40 }, { WAIT_IDLE },
-{ 0xe, 0x6f }, { 0xf, 0x40 }, { WAIT_IDLE },
-{ 0xe, 0x70 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x71 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x72 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x73 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x74 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x75 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x76 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x77 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x78 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x79 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x7a }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x7b }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x7c }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x7d }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x7e }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x7f }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x80 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x81 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x82 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x83 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x84 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x85 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x86 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x87 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x88 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x89 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x8a }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x8b }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x8c }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x8d }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x8e }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x8f }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x90 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x91 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x92 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x93 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x94 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x95 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x96 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x97 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x98 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x99 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x9a }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x9b }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x9c }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x9d }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x9e }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x9f }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa0 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa1 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa2 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa3 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa4 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa5 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa6 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa7 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa8 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa9 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xaa }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xab }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xac }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xad }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xae }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xaf }, { 0xf, 0x00 }, { WAIT_IDLE },
-
-{ 0xe, 0xc0 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc1 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc2 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc3 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc4 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc5 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc6 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc7 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc8 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc9 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xca }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xcb }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xcc }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xcd }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xce }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xcf }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd0 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd1 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd2 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd3 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd4 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd5 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd6 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd7 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd8 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd9 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xda }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xdb }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xdc }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xdd }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xde }, { 0xf, 0x10 }, { WAIT_IDLE },
-{ 0xe, 0xdf }, { 0xf, 0x10 }, { WAIT_IDLE },
-{ 0xe, 0xe0 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe1 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe2 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe3 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe4 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe5 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe6 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe7 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe8 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe9 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xea }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xeb }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xec }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xed }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xee }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xef }, { 0xf, 0x00 }, { WAIT_IDLE },
-
-{ 0xe, 0x01 }, { 0xf, 0x00 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x01 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x02 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x03 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x04 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x05 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x06 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x07 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x08 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x09 }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0a }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0b }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0c }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0d }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0e }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x0f }, { 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-
-/* mute on */
-{ 0x8, 0x02 },
-
-/* Now set the coefficients and so forth for the programs above */
-{ 0xb, 0x07 }, { 0xa, 0x46 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x49 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x00 }, { 0xa, 0x4b }, { 0xd, 0x03 }, { 0xc, 0x11 }, { WAIT_IDLE },
-{ 0xb, 0x00 }, { 0xa, 0x4d }, { 0xd, 0x01 }, { 0xc, 0x32 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x46 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x49 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x40 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x41 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x01 }, { 0xa, 0x40 }, { 0xd, 0x02 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xb, 0x01 }, { 0xa, 0x41 }, { 0xd, 0x02 }, { 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x40 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x41 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x47 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x4a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x00 }, { 0xa, 0x47 }, { 0xd, 0x01 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x00 }, { 0xa, 0x4a }, { 0xd, 0x01 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x47 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x4a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x7c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x7e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x00 }, { 0xa, 0x00 }, { 0xd, 0x01 }, { 0xc, 0x1c }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x7c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x7e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x44 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x00 }, { 0xa, 0x44 }, { 0xd, 0x01 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x44 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x42 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x43 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x00 }, { 0xa, 0x42 }, { 0xd, 0x01 }, { 0xc, 0x1a }, { WAIT_IDLE },
-{ 0xb, 0x00 }, { 0xa, 0x43 }, { 0xd, 0x01 }, { 0xc, 0x20 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x42 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x43 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x40 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x41 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x01 }, { 0xa, 0x40 }, { 0xd, 0x02 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xb, 0x01 }, { 0xa, 0x41 }, { 0xd, 0x02 }, { 0xc, 0x60 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x40 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x41 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x44 }, { 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x42 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x43 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x40 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x41 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x51 }, { 0xd, 0x06 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x50 }, { 0xd, 0x06 }, { 0xc, 0x40 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x4f }, { 0xd, 0x03 }, { 0xc, 0x81 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x53 }, { 0xd, 0x1a }, { 0xc, 0x76 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x54 }, { 0xd, 0x0d }, { 0xc, 0x8b }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x55 }, { 0xd, 0x04 }, { 0xc, 0xe9 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x56 }, { 0xd, 0x0b }, { 0xc, 0x17 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x57 }, { 0xd, 0x1a }, { 0xc, 0x38 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x58 }, { 0xd, 0x0d }, { 0xc, 0xc9 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x59 }, { 0xd, 0x04 }, { 0xc, 0x6f }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x5a }, { 0xd, 0x0b }, { 0xc, 0x91 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x73 }, { 0xd, 0x14 }, { 0xc, 0xda }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x74 }, { 0xd, 0x0d }, { 0xc, 0x93 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x75 }, { 0xd, 0x04 }, { 0xc, 0xd9 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x76 }, { 0xd, 0x05 }, { 0xc, 0x93 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x77 }, { 0xd, 0x14 }, { 0xc, 0xda }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x78 }, { 0xd, 0x0d }, { 0xc, 0x93 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x79 }, { 0xd, 0x04 }, { 0xc, 0xd9 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x7a }, { 0xd, 0x05 }, { 0xc, 0x93 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x5e }, { 0xd, 0x03 }, { 0xc, 0x68 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x5c }, { 0xd, 0x04 }, { 0xc, 0x31 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x5d }, { 0xd, 0x04 }, { 0xc, 0x31 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x62 }, { 0xd, 0x03 }, { 0xc, 0x52 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x60 }, { 0xd, 0x04 }, { 0xc, 0x76 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x61 }, { 0xd, 0x04 }, { 0xc, 0x76 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x66 }, { 0xd, 0x03 }, { 0xc, 0x2e }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x64 }, { 0xd, 0x04 }, { 0xc, 0xda }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x65 }, { 0xd, 0x04 }, { 0xc, 0xda }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x6a }, { 0xd, 0x02 }, { 0xc, 0xf6 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x68 }, { 0xd, 0x05 }, { 0xc, 0x62 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x69 }, { 0xd, 0x05 }, { 0xc, 0x62 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x46 }, { 0xd, 0x0a }, { 0xc, 0x22 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x48 }, { 0xd, 0x0d }, { 0xc, 0x24 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x6e }, { 0xd, 0x11 }, { 0xc, 0xd3 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x70 }, { 0xd, 0x15 }, { 0xc, 0xcb }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x52 }, { 0xd, 0x20 }, { 0xc, 0x93 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x54 }, { 0xd, 0x20 }, { 0xc, 0x54 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x4a }, { 0xd, 0x27 }, { 0xc, 0x1d }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x58 }, { 0xd, 0x2f }, { 0xc, 0xc8 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x5c }, { 0xd, 0x30 }, { 0xc, 0x07 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x4c }, { 0xd, 0x37 }, { 0xc, 0x90 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x60 }, { 0xd, 0x3d }, { 0xc, 0xdb }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x64 }, { 0xd, 0x3e }, { 0xc, 0x42 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x4e }, { 0xd, 0x45 }, { 0xc, 0x78 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x68 }, { 0xd, 0x4c }, { 0xc, 0x48 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x6c }, { 0xd, 0x4c }, { 0xc, 0x6c }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x50 }, { 0xd, 0x52 }, { 0xc, 0xe2 }, { WAIT_IDLE },
-{ 0xb, 0x06 }, { 0xa, 0x42 }, { 0xd, 0x02 }, { 0xc, 0xba }, { WAIT_IDLE },
-
-/* Some settings (?) */
-{ WAIT_IDLE }, { 0xe, 0x1e }, { 0xf, 0x14 },
-{ WAIT_IDLE }, { 0xe, 0xde }, { 0xf, 0x20 },
-{ WAIT_IDLE }, { 0xe, 0xdf }, { 0xf, 0x20 },
-
-/* some more coefficients */
-{ WAIT_IDLE }, { 0xb, 0x06 }, { 0xa, 0x78 }, { 0xd, 0x00 }, { 0xc, 0x40 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x03 }, { 0xd, 0x0f }, { 0xc, 0xff },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x0b }, { 0xd, 0x0f }, { 0xc, 0xff },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x02 }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x0a }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x46 }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ WAIT_IDLE }, { 0xb, 0x07 }, { 0xa, 0x49 }, { 0xd, 0x00 }, { 0xc, 0x00 },
-
-/* Now, for some strange reason, lets reload every page
-   and all the coefficients over again. I have *NO* idea
-   why this is done. I do know that no sound is produced
-   is this phase is omitted. */
-{ 0x9, 0x05 }, { 0xb, 0x00 }, { 0xa, 0x10 },
-
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x02 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-
-{ 0x9, 0x05 }, { 0xb, 0x01 }, { 0xa, 0x10 },
-
-{ 0xd, 0x01 }, { 0xc, 0xc0 }, { WAIT_IDLE },
-{ 0xd, 0x01 }, { 0xc, 0xfa }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x1a }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-
-{ WAIT_IDLE }, { WAIT_IDLE },
-
-{ 0x9, 0x05 }, { 0xb, 0x02 }, { 0xa, 0x10 },
-
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x46 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-
-{ 0x9, 0x05 }, { 0xb, 0x03 }, { 0xa, 0x10 },
-
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-
-{ 0x9, 0x05 }, { 0xb, 0x04 }, { 0xa, 0x10 },
-
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xc, 0x00 }, { WAIT_IDLE },
-
-/* Page six v.2 */
-{ 0x9, 0x01 }, { 0xb, 0x06 },
-
-{ 0xa, 0x10 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x12 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x14 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x16 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x18 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x1a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x1c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x1e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x20 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x22 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x24 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x26 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x28 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x2a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x2c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x2e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x30 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x32 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x34 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x36 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x38 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x3a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x3c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xa, 0x3e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-
-{ 0x9, 0x05 }, { 0xb, 0x07 }, { 0xa, 0x10 },
-
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-
-{ 0xe, 0x01 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x02 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x03 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x04 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x05 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x06 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x07 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xb0 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb1 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb2 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb3 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb4 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb5 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb6 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xb7 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf0 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf1 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf2 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf3 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf4 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf5 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf6 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0xf7 }, { 0xf, 0x20 }, { WAIT_IDLE },
-{ 0xe, 0x10 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x11 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x12 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x13 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x14 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x15 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x16 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x17 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x20 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x21 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x22 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x23 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x24 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x25 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x26 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x27 }, { 0xf, 0xff }, { WAIT_IDLE },
-{ 0xe, 0x30 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x31 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x32 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x33 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x34 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x35 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x36 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x37 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x40 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x41 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x42 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x43 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x44 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x45 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x46 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x47 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x50 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x51 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x52 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x53 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x54 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x55 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x56 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x57 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x60 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x61 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x62 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x63 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x64 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x65 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x66 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x67 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x70 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x71 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x72 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x73 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x74 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x75 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x76 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x77 }, { 0xf, 0xc0 }, { WAIT_IDLE },
-{ 0xe, 0x80 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x81 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x82 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x83 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x84 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x85 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x86 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x87 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x90 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x91 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x92 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x93 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x94 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x95 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x96 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x97 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa0 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa1 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa2 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa3 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa4 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa5 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa6 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xa7 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc0 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc1 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc2 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc3 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc4 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc5 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc6 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xc7 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd0 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd1 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd2 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd3 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd4 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd5 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd6 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xd7 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe0 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe1 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe2 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe3 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe4 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe5 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe6 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0xe7 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x00 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x02 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x03 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x04 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x05 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x06 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-{ 0xe, 0x01 }, { 0xf, 0x07 }, { WAIT_IDLE },
-{ 0xe, 0x02 }, { 0xf, 0x01 }, { WAIT_IDLE },
-
-{ 0xb, 0x07 }, { 0xa, 0x46 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x49 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x45 }, { 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x48 }, { 0xd, 0x0f }, { 0xc, 0xff }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x7b }, { 0xd, 0x04 }, { 0xc, 0xcc }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x7d }, { 0xd, 0x04 }, { 0xc, 0xcc }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x7c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x7e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x46 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x49 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x47 }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x4a }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x00 }, { 0xc, 0x00 }, { WAIT_IDLE },
-
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x00 }, { 0xc, 0x00 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x00 }, { 0xc, 0x28 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x00 }, { 0xc, 0x28 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x00 }, { 0xc, 0x51 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x00 }, { 0xc, 0x51 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x00 }, { 0xc, 0x7a },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x00 }, { 0xc, 0x7a },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x00 }, { 0xc, 0xa3 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x00 }, { 0xc, 0xa3 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x00 }, { 0xc, 0xcc },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x00 }, { 0xc, 0xcc },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x00 }, { 0xc, 0xf5 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x00 }, { 0xc, 0xf5 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x01 }, { 0xc, 0x1e },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x01 }, { 0xc, 0x1e },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x01 }, { 0xc, 0x47 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x01 }, { 0xc, 0x47 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x01 }, { 0xc, 0x70 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x01 }, { 0xc, 0x70 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x01 }, { 0xc, 0x99 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x01 }, { 0xc, 0x99 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x01 }, { 0xc, 0xc2 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x01 }, { 0xc, 0xc2 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x01 }, { 0xc, 0xeb },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x01 }, { 0xc, 0xeb },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x02 }, { 0xc, 0x14 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x02 }, { 0xc, 0x14 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x02 }, { 0xc, 0x3d },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x02 }, { 0xc, 0x3d },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x02 }, { 0xc, 0x66 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x02 }, { 0xc, 0x66 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x02 }, { 0xc, 0x8f },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x02 }, { 0xc, 0x8f },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x02 }, { 0xc, 0xb8 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x02 }, { 0xc, 0xb8 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x02 }, { 0xc, 0xe1 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x02 }, { 0xc, 0xe1 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x03 }, { 0xc, 0x0a },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x03 }, { 0xc, 0x0a },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x03 }, { 0xc, 0x33 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x03 }, { 0xc, 0x33 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x03 }, { 0xc, 0x5c },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x03 }, { 0xc, 0x5c },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x03 }, { 0xc, 0x85 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x03 }, { 0xc, 0x85 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x03 }, { 0xc, 0xae },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x03 }, { 0xc, 0xae },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x03 }, { 0xc, 0xd7 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x03 }, { 0xc, 0xd7 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x04 }, { 0xc, 0x00 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x04 }, { 0xc, 0x00 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x04 }, { 0xc, 0x28 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x04 }, { 0xc, 0x28 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x04 }, { 0xc, 0x51 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x04 }, { 0xc, 0x51 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x04 }, { 0xc, 0x7a },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x04 }, { 0xc, 0x7a },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x04 }, { 0xc, 0xa3 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x04 }, { 0xc, 0xa3 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x04 }, { 0xc, 0xcc },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x04 }, { 0xc, 0xcc },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x04 }, { 0xc, 0xf5 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x04 }, { 0xc, 0xf5 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x05 }, { 0xc, 0x1e },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x05 }, { 0xc, 0x1e },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x05 }, { 0xc, 0x47 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x05 }, { 0xc, 0x47 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x05 }, { 0xc, 0x70 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x05 }, { 0xc, 0x70 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x05 }, { 0xc, 0x99 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x05 }, { 0xc, 0x99 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x05 }, { 0xc, 0xc2 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x05 }, { 0xc, 0xc2 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x05 }, { 0xc, 0xeb },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x05 }, { 0xc, 0xeb },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x06 }, { 0xc, 0x14 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x06 }, { 0xc, 0x14 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x06 }, { 0xc, 0x3d },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x06 }, { 0xc, 0x3d },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x06 }, { 0xc, 0x66 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x06 }, { 0xc, 0x66 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x06 }, { 0xc, 0x8f },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x06 }, { 0xc, 0x8f },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x06 }, { 0xc, 0xb8 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x06 }, { 0xc, 0xb8 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x06 }, { 0xc, 0xe1 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x06 }, { 0xc, 0xe1 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x07 }, { 0xc, 0x0a },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x07 }, { 0xc, 0x0a },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x07 }, { 0xc, 0x33 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x07 }, { 0xc, 0x33 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x07 }, { 0xc, 0x5c },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x07 }, { 0xc, 0x5c },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x07 }, { 0xc, 0x85 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x07 }, { 0xc, 0x85 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x07 }, { 0xc, 0xae },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x07 }, { 0xc, 0xae },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x07 }, { 0xc, 0xd7 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x07 }, { 0xc, 0xd7 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x08 }, { 0xc, 0x00 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x08 }, { 0xc, 0x00 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x08 }, { 0xc, 0x28 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x08 }, { 0xc, 0x28 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x08 }, { 0xc, 0x51 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x08 }, { 0xc, 0x51 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x08 }, { 0xc, 0x7a },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x08 }, { 0xc, 0x7a },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x08 }, { 0xc, 0xa3 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x08 }, { 0xc, 0xa3 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x08 }, { 0xc, 0xcc },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x08 }, { 0xc, 0xcc },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x08 }, { 0xc, 0xf5 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x08 }, { 0xc, 0xf5 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x09 }, { 0xc, 0x1e },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x09 }, { 0xc, 0x1e },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x09 }, { 0xc, 0x47 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x09 }, { 0xc, 0x47 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x09 }, { 0xc, 0x70 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x09 }, { 0xc, 0x70 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x09 }, { 0xc, 0x99 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x09 }, { 0xc, 0x99 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x09 }, { 0xc, 0xc2 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x09 }, { 0xc, 0xc2 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x09 }, { 0xc, 0xeb },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x09 }, { 0xc, 0xeb },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0a }, { 0xc, 0x14 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0a }, { 0xc, 0x14 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0a }, { 0xc, 0x3d },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0a }, { 0xc, 0x3d },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0a }, { 0xc, 0x66 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0a }, { 0xc, 0x66 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0a }, { 0xc, 0x8f },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0a }, { 0xc, 0x8f },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0a }, { 0xc, 0xb8 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0a }, { 0xc, 0xb8 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0a }, { 0xc, 0xe1 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0a }, { 0xc, 0xe1 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0b }, { 0xc, 0x0a },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0b }, { 0xc, 0x0a },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0b }, { 0xc, 0x33 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0b }, { 0xc, 0x33 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0b }, { 0xc, 0x5c },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0b }, { 0xc, 0x5c },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0b }, { 0xc, 0x85 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0b }, { 0xc, 0x85 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0b }, { 0xc, 0xae },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0b }, { 0xc, 0xae },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0b }, { 0xc, 0xd7 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0b }, { 0xc, 0xd7 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0c }, { 0xc, 0x00 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0c }, { 0xc, 0x00 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0c }, { 0xc, 0x28 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0c }, { 0xc, 0x28 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0c }, { 0xc, 0x51 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0c }, { 0xc, 0x51 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0c }, { 0xc, 0x7a },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0c }, { 0xc, 0x7a },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0c }, { 0xc, 0xa3 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0c }, { 0xc, 0xa3 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0c }, { 0xc, 0xcc },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0c }, { 0xc, 0xcc },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0c }, { 0xc, 0xf5 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0c }, { 0xc, 0xf5 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0d }, { 0xc, 0x1e },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0d }, { 0xc, 0x1e },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0d }, { 0xc, 0x47 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0d }, { 0xc, 0x47 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0d }, { 0xc, 0x70 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0d }, { 0xc, 0x70 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0d }, { 0xc, 0x99 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0d }, { 0xc, 0x99 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0d }, { 0xc, 0xc2 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0d }, { 0xc, 0xc2 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0d }, { 0xc, 0xeb },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0d }, { 0xc, 0xeb },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0e }, { 0xc, 0x14 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0e }, { 0xc, 0x14 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0e }, { 0xc, 0x3d },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0e }, { 0xc, 0x3d },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0e }, { 0xc, 0x66 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0e }, { 0xc, 0x66 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0e }, { 0xc, 0x8f },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0e }, { 0xc, 0x8f },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0e }, { 0xc, 0xb8 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0e }, { 0xc, 0xb8 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0e }, { 0xc, 0xe1 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0e }, { 0xc, 0xe1 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0f }, { 0xc, 0x0a },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0f }, { 0xc, 0x0a },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0f }, { 0xc, 0x33 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0f }, { 0xc, 0x33 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0f }, { 0xc, 0x5c },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0f }, { 0xc, 0x5c },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0f }, { 0xc, 0x85 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0f }, { 0xc, 0x85 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0f }, { 0xc, 0xae },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0f }, { 0xc, 0xae },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0f }, { 0xc, 0xd7 },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0f }, { 0xc, 0xd7 },
-{ 0xb, 0x07 }, { 0xa, 0x4c }, { 0xd, 0x0f }, { 0xc, 0xff },
-{ 0xb, 0x07 }, { 0xa, 0x4e }, { 0xd, 0x0f }, { 0xc, 0xff },
-
-/* mute off */
-{ 0x8, 0x00 }, { WAIT_IDLE }
-};
diff --git a/sound/isa/wss/wss_lib.c b/sound/isa/wss/wss_lib.c
index 3d6c5f2838af..5d2ba1b749ab 100644
--- a/sound/isa/wss/wss_lib.c
+++ b/sound/isa/wss/wss_lib.c
@@ -181,25 +181,6 @@ static void snd_wss_wait(struct snd_wss *chip)
                 udelay(100);
 }
 
-static void snd_wss_outm(struct snd_wss *chip, unsigned char reg,
-                            unsigned char mask, unsigned char value)
-{
-        unsigned char tmp = (chip->image[reg] & mask) | value;
-
-        snd_wss_wait(chip);
-#ifdef CONFIG_SND_DEBUG
-        if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
-                snd_printk("outm: auto calibration time out - reg = 0x%x, value = 0x%x\n", reg, value);
-#endif
-        chip->image[reg] = tmp;
-        if (!chip->calibrate_mute) {
-                wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
-                wmb();
-                wss_outb(chip, CS4231P(REG), tmp);
-                mb();
-        }
-}
-
 static void snd_wss_dout(struct snd_wss *chip, unsigned char reg,
                          unsigned char value)
 {
@@ -219,7 +200,8 @@ void snd_wss_out(struct snd_wss *chip, unsigned char reg, unsigned char value)
         snd_wss_wait(chip);
 #ifdef CONFIG_SND_DEBUG
         if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
-                snd_printk("out: auto calibration time out - reg = 0x%x, value = 0x%x\n", reg, value);
+                snd_printk(KERN_DEBUG "out: auto calibration time out "
+                           "- reg = 0x%x, value = 0x%x\n", reg, value);
 #endif
         wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
         wss_outb(chip, CS4231P(REG), value);
@@ -235,7 +217,8 @@ unsigned char snd_wss_in(struct snd_wss *chip, unsigned char reg)
         snd_wss_wait(chip);
 #ifdef CONFIG_SND_DEBUG
         if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
-                snd_printk("in: auto calibration time out - reg = 0x%x\n", reg);
+                snd_printk(KERN_DEBUG "in: auto calibration time out "
+                           "- reg = 0x%x\n", reg);
 #endif
         wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
         mb();
@@ -252,7 +235,7 @@ void snd_cs4236_ext_out(struct snd_wss *chip, unsigned char reg,
         wss_outb(chip, CS4231P(REG), val);
         chip->eimage[CS4236_REG(reg)] = val;
 #if 0
-        printk("ext out : reg = 0x%x, val = 0x%x\n", reg, val);
+        printk(KERN_DEBUG "ext out : reg = 0x%x, val = 0x%x\n", reg, val);
 #endif
 }
 EXPORT_SYMBOL(snd_cs4236_ext_out);
@@ -268,7 +251,8 @@ unsigned char snd_cs4236_ext_in(struct snd_wss *chip, unsigned char reg)
         {
                 unsigned char res;
                 res = wss_inb(chip, CS4231P(REG));
-                printk("ext in : reg = 0x%x, val = 0x%x\n", reg, res);
+                printk(KERN_DEBUG "ext in : reg = 0x%x, val = 0x%x\n",
+                       reg, res);
                 return res;
         }
 #endif
@@ -394,13 +378,16 @@ void snd_wss_mce_up(struct snd_wss *chip)
         snd_wss_wait(chip);
 #ifdef CONFIG_SND_DEBUG
         if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
-                snd_printk("mce_up - auto calibration time out (0)\n");
+                snd_printk(KERN_DEBUG
+                           "mce_up - auto calibration time out (0)\n");
 #endif
         spin_lock_irqsave(&chip->reg_lock, flags);
         chip->mce_bit |= CS4231_MCE;
         timeout = wss_inb(chip, CS4231P(REGSEL));
         if (timeout == 0x80)
-                snd_printk("mce_up [0x%lx]: serious init problem - codec still busy\n", chip->port);
+                snd_printk(KERN_DEBUG "mce_up [0x%lx]: "
+                           "serious init problem - codec still busy\n",
+                           chip->port);
         if (!(timeout & CS4231_MCE))
                 wss_outb(chip, CS4231P(REGSEL),
                          chip->mce_bit | (timeout & 0x1f));
@@ -419,7 +406,9 @@ void snd_wss_mce_down(struct snd_wss *chip)
 
 #ifdef CONFIG_SND_DEBUG
         if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
-                snd_printk("mce_down [0x%lx] - auto calibration time out (0)\n", (long)CS4231P(REGSEL));
+                snd_printk(KERN_DEBUG "mce_down [0x%lx] - "
+                           "auto calibration time out (0)\n",
+                           (long)CS4231P(REGSEL));
 #endif
         spin_lock_irqsave(&chip->reg_lock, flags);
         chip->mce_bit &= ~CS4231_MCE;
@@ -427,7 +416,9 @@ void snd_wss_mce_down(struct snd_wss *chip)
         wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
         spin_unlock_irqrestore(&chip->reg_lock, flags);
         if (timeout == 0x80)
-                snd_printk("mce_down [0x%lx]: serious init problem - codec still busy\n", chip->port);
+                snd_printk(KERN_DEBUG "mce_down [0x%lx]: "
+                           "serious init problem - codec still busy\n",
+                           chip->port);
         if ((timeout & CS4231_MCE) == 0 || !(chip->hardware & hw_mask))
                 return;
 
@@ -565,7 +556,7 @@ static unsigned char snd_wss_get_format(struct snd_wss *chip,
         if (channels > 1)
                 rformat |= CS4231_STEREO;
 #if 0
-        snd_printk("get_format: 0x%x (mode=0x%x)\n", format, mode);
+        snd_printk(KERN_DEBUG "get_format: 0x%x (mode=0x%x)\n", format, mode);
 #endif
         return rformat;
 }
@@ -587,7 +578,15 @@ static void snd_wss_calibrate_mute(struct snd_wss *chip, int mute)
                              chip->image[CS4231_RIGHT_INPUT]);
                 snd_wss_dout(chip, CS4231_LOOPBACK,
                              chip->image[CS4231_LOOPBACK]);
+        } else {
+                snd_wss_dout(chip, CS4231_LEFT_INPUT,
+                             0);
+                snd_wss_dout(chip, CS4231_RIGHT_INPUT,
+                             0);
+                snd_wss_dout(chip, CS4231_LOOPBACK,
+                             0xfd);
         }
+
         snd_wss_dout(chip, CS4231_AUX1_LEFT_INPUT,
                      mute | chip->image[CS4231_AUX1_LEFT_INPUT]);
         snd_wss_dout(chip, CS4231_AUX1_RIGHT_INPUT,
@@ -630,7 +629,6 @@ static void snd_wss_playback_format(struct snd_wss *chip,
         int full_calib = 1;
 
         mutex_lock(&chip->mce_mutex);
-        snd_wss_calibrate_mute(chip, 1);
         if (chip->hardware == WSS_HW_CS4231A ||
             (chip->hardware & WSS_HW_CS4232_MASK)) {
                 spin_lock_irqsave(&chip->reg_lock, flags);
@@ -646,6 +644,24 @@ static void snd_wss_playback_format(struct snd_wss *chip,
                         full_calib = 0;
                 }
                 spin_unlock_irqrestore(&chip->reg_lock, flags);
+        } else if (chip->hardware == WSS_HW_AD1845) {
+                unsigned rate = params_rate(params);
+
+                /*
+                 * Program the AD1845 correctly for the playback stream.
+                 * Note that we do NOT need to toggle the MCE bit because
+                 * the PLAYBACK_ENABLE bit of the Interface Configuration
+                 * register is set.
+                 *
+                 * NOTE: We seem to need to write to the MSB before the LSB
+                 *       to get the correct sample frequency.
+                 */
+                spin_lock_irqsave(&chip->reg_lock, flags);
+                snd_wss_out(chip, CS4231_PLAYBK_FORMAT, (pdfr & 0xf0));
+                snd_wss_out(chip, AD1845_UPR_FREQ_SEL, (rate >> 8) & 0xff);
+                snd_wss_out(chip, AD1845_LWR_FREQ_SEL, rate & 0xff);
+                full_calib = 0;
+                spin_unlock_irqrestore(&chip->reg_lock, flags);
         }
         if (full_calib) {
                 snd_wss_mce_up(chip);
@@ -663,7 +679,6 @@ static void snd_wss_playback_format(struct snd_wss *chip,
                         udelay(100);    /* this seems to help */
                 snd_wss_mce_down(chip);
         }
-        snd_wss_calibrate_mute(chip, 0);
         mutex_unlock(&chip->mce_mutex);
 }
 
@@ -675,7 +690,6 @@ static void snd_wss_capture_format(struct snd_wss *chip,
         int full_calib = 1;
 
         mutex_lock(&chip->mce_mutex);
-        snd_wss_calibrate_mute(chip, 1);
         if (chip->hardware == WSS_HW_CS4231A ||
             (chip->hardware & WSS_HW_CS4232_MASK)) {
                 spin_lock_irqsave(&chip->reg_lock, flags);
@@ -690,6 +704,24 @@ static void snd_wss_capture_format(struct snd_wss *chip,
                         full_calib = 0;
                 }
                 spin_unlock_irqrestore(&chip->reg_lock, flags);
+        } else if (chip->hardware == WSS_HW_AD1845) {
+                unsigned rate = params_rate(params);
+
+                /*
+                 * Program the AD1845 correctly for the capture stream.
+                 * Note that we do NOT need to toggle the MCE bit because
+                 * the PLAYBACK_ENABLE bit of the Interface Configuration
+                 * register is set.
+                 *
+                 * NOTE: We seem to need to write to the MSB before the LSB
+                 *       to get the correct sample frequency.
+                 */
+                spin_lock_irqsave(&chip->reg_lock, flags);
+                snd_wss_out(chip, CS4231_REC_FORMAT, (cdfr & 0xf0));
+                snd_wss_out(chip, AD1845_UPR_FREQ_SEL, (rate >> 8) & 0xff);
+                snd_wss_out(chip, AD1845_LWR_FREQ_SEL, rate & 0xff);
+                full_calib = 0;
+                spin_unlock_irqrestore(&chip->reg_lock, flags);
         }
         if (full_calib) {
                 snd_wss_mce_up(chip);
@@ -714,7 +746,6 @@ static void snd_wss_capture_format(struct snd_wss *chip,
                 spin_unlock_irqrestore(&chip->reg_lock, flags);
                 snd_wss_mce_down(chip);
         }
-        snd_wss_calibrate_mute(chip, 0);
         mutex_unlock(&chip->mce_mutex);
 }
 
@@ -771,10 +802,11 @@ static void snd_wss_init(struct snd_wss *chip)
 {
         unsigned long flags;
 
+        snd_wss_calibrate_mute(chip, 1);
         snd_wss_mce_down(chip);
 
 #ifdef SNDRV_DEBUG_MCE
-        snd_printk("init: (1)\n");
+        snd_printk(KERN_DEBUG "init: (1)\n");
 #endif
         snd_wss_mce_up(chip);
         spin_lock_irqsave(&chip->reg_lock, flags);
@@ -789,18 +821,20 @@ static void snd_wss_init(struct snd_wss *chip)
         snd_wss_mce_down(chip);
 
 #ifdef SNDRV_DEBUG_MCE
-        snd_printk("init: (2)\n");
+        snd_printk(KERN_DEBUG "init: (2)\n");
 #endif
 
         snd_wss_mce_up(chip);
         spin_lock_irqsave(&chip->reg_lock, flags);
+        chip->image[CS4231_IFACE_CTRL] &= ~CS4231_AUTOCALIB;
+        snd_wss_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
         snd_wss_out(chip,
                     CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1]);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
         snd_wss_mce_down(chip);
 
 #ifdef SNDRV_DEBUG_MCE
-        snd_printk("init: (3) - afei = 0x%x\n",
+        snd_printk(KERN_DEBUG "init: (3) - afei = 0x%x\n",
                    chip->image[CS4231_ALT_FEATURE_1]);
 #endif
 
@@ -817,7 +851,7 @@ static void snd_wss_init(struct snd_wss *chip)
         snd_wss_mce_down(chip);
 
 #ifdef SNDRV_DEBUG_MCE
-        snd_printk("init: (4)\n");
+        snd_printk(KERN_DEBUG "init: (4)\n");
 #endif
 
         snd_wss_mce_up(chip);
@@ -827,9 +861,10 @@ static void snd_wss_init(struct snd_wss *chip)
                             chip->image[CS4231_REC_FORMAT]);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
         snd_wss_mce_down(chip);
+        snd_wss_calibrate_mute(chip, 0);
 
 #ifdef SNDRV_DEBUG_MCE
-        snd_printk("init: (5)\n");
+        snd_printk(KERN_DEBUG "init: (5)\n");
 #endif
 }
 
@@ -885,8 +920,6 @@ static void snd_wss_close(struct snd_wss *chip, unsigned int mode)
                 mutex_unlock(&chip->open_mutex);
                 return;
         }
-        snd_wss_calibrate_mute(chip, 1);
-
         /* disable IRQ */
         spin_lock_irqsave(&chip->reg_lock, flags);
         if (!(chip->hardware & WSS_HW_AD1848_MASK))
@@ -919,8 +952,6 @@ static void snd_wss_close(struct snd_wss *chip, unsigned int mode)
         wss_outb(chip, CS4231P(STATUS), 0);     /* clear IRQ */
         spin_unlock_irqrestore(&chip->reg_lock, flags);
 
-        snd_wss_calibrate_mute(chip, 0);
-
         chip->mode = 0;
         mutex_unlock(&chip->open_mutex);
 }
@@ -1113,7 +1144,7 @@ irqreturn_t snd_wss_interrupt(int irq, void *dev_id)
         if (chip->hardware & WSS_HW_AD1848_MASK)
                 wss_outb(chip, CS4231P(STATUS), 0);
         else
-                snd_wss_outm(chip, CS4231_IRQ_STATUS, status, 0);
+                snd_wss_out(chip, CS4231_IRQ_STATUS, status);
         spin_unlock(&chip->reg_lock);
         return IRQ_HANDLED;
 }
@@ -1278,7 +1309,8 @@ static int snd_wss_probe(struct snd_wss *chip)
                 } else if (rev == 0x03) {
                         chip->hardware = WSS_HW_CS4236B;
                 } else {
-                        snd_printk("unknown CS chip with version 0x%x\n", rev);
+                        snd_printk(KERN_ERR
+                                   "unknown CS chip with version 0x%x\n", rev);
                         return -ENODEV;         /* unknown CS4231 chip? */
                 }
         }
@@ -1314,6 +1346,10 @@ static int snd_wss_probe(struct snd_wss *chip)
                 chip->image[CS4231_ALT_FEATURE_2] =
                         chip->hardware == WSS_HW_INTERWAVE ? 0xc2 : 0x01;
         }
+        /* enable fine grained frequency selection */
+        if (chip->hardware == WSS_HW_AD1845)
+                chip->image[AD1845_PWR_DOWN] = 8;
+
         ptr = (unsigned char *) &chip->image;
         regnum = (chip->hardware & WSS_HW_AD1848_MASK) ? 16 : 32;
         snd_wss_mce_down(chip);
@@ -1342,7 +1378,10 @@ static int snd_wss_probe(struct snd_wss *chip)
                                 case 6:
                                         break;
                                 default:
-                                        snd_printk("unknown CS4235 chip (enhanced version = 0x%x)\n", id);
+                                        snd_printk(KERN_WARNING
+                                                "unknown CS4235 chip "
+                                                "(enhanced version = 0x%x)\n",
+                                                id);
                                 }
                         } else if ((id & 0x1f) == 0x0b) {       /* CS4236/B */
                                 switch (id >> 5) {
@@ -1353,7 +1392,10 @@ static int snd_wss_probe(struct snd_wss *chip)
                                         chip->hardware = WSS_HW_CS4236B;
                                         break;
                                 default:
-                                        snd_printk("unknown CS4236 chip (enhanced version = 0x%x)\n", id);
+                                        snd_printk(KERN_WARNING
+                                                "unknown CS4236 chip "
+                                                "(enhanced version = 0x%x)\n",
+                                                id);
                                 }
                         } else if ((id & 0x1f) == 0x08) {       /* CS4237B */
                                 chip->hardware = WSS_HW_CS4237B;
@@ -1364,7 +1406,10 @@ static int snd_wss_probe(struct snd_wss *chip)
                                 case 7:
                                         break;
                                 default:
-                                        snd_printk("unknown CS4237B chip (enhanced version = 0x%x)\n", id);
+                                        snd_printk(KERN_WARNING
+                                                "unknown CS4237B chip "
+                                                "(enhanced version = 0x%x)\n",
+                                                id);
                                 }
                         } else if ((id & 0x1f) == 0x09) {       /* CS4238B */
                                 chip->hardware = WSS_HW_CS4238B;
@@ -1374,7 +1419,10 @@ static int snd_wss_probe(struct snd_wss *chip)
                                 case 7:
                                         break;
                                 default:
-                                        snd_printk("unknown CS4238B chip (enhanced version = 0x%x)\n", id);
+                                        snd_printk(KERN_WARNING
+                                                "unknown CS4238B chip "
+                                                "(enhanced version = 0x%x)\n",
+                                                id);
                                 }
                         } else if ((id & 0x1f) == 0x1e) {       /* CS4239 */
                                 chip->hardware = WSS_HW_CS4239;
@@ -1384,10 +1432,15 @@ static int snd_wss_probe(struct snd_wss *chip)
                                 case 6:
                                         break;
                                 default:
-                                        snd_printk("unknown CS4239 chip (enhanced version = 0x%x)\n", id);
+                                        snd_printk(KERN_WARNING
+                                                "unknown CS4239 chip "
+                                                "(enhanced version = 0x%x)\n",
+                                                id);
                                 }
                         } else {
-                                snd_printk("unknown CS4236/CS423xB chip (enhanced version = 0x%x)\n", id);
+                                snd_printk(KERN_WARNING
+                                           "unknown CS4236/CS423xB chip "
+                                           "(enhanced version = 0x%x)\n", id);
                         }
                 }
         }
@@ -1618,7 +1671,8 @@ static void snd_wss_resume(struct snd_wss *chip)
         wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
         spin_unlock_irqrestore(&chip->reg_lock, flags);
         if (timeout == 0x80)
-                snd_printk("down [0x%lx]: serious init problem - codec still busy\n", chip->port);
+                snd_printk(KERN_ERR "down [0x%lx]: serious init problem "
+                           "- codec still busy\n", chip->port);
         if ((timeout & CS4231_MCE) == 0 ||
             !(chip->hardware & (WSS_HW_CS4231_MASK | WSS_HW_CS4232_MASK))) {
                 return;
@@ -1628,7 +1682,7 @@ static void snd_wss_resume(struct snd_wss *chip)
 }
 #endif /* CONFIG_PM */
 
-static int snd_wss_free(struct snd_wss *chip)
+int snd_wss_free(struct snd_wss *chip)
 {
         release_and_free_resource(chip->res_port);
         release_and_free_resource(chip->res_cport);
@@ -1651,6 +1705,7 @@ static int snd_wss_free(struct snd_wss *chip)
         kfree(chip);
         return 0;
 }
+EXPORT_SYMBOL(snd_wss_free);
 
 static int snd_wss_dev_free(struct snd_device *device)
 {
@@ -1820,7 +1875,8 @@ int snd_wss_create(struct snd_card *card,
 #if 0
         if (chip->hardware & WSS_HW_CS4232_MASK) {
                 if (chip->res_cport == NULL)
-                        snd_printk("CS4232 control port features are not accessible\n");
+                        snd_printk(KERN_ERR "CS4232 control port features are "
+                                   "not accessible\n");
         }
 #endif
 
diff --git a/sound/mips/au1x00.c b/sound/mips/au1x00.c
index 99e1391b2eb4..3e763d6a5d67 100644
--- a/sound/mips/au1x00.c
+++ b/sound/mips/au1x00.c
@@ -679,7 +679,7 @@ au1000_init(void)
                 return err;
         }
 
-        printk( KERN_INFO "ALSA AC97: Driver Initialized\n" );
+        printk(KERN_INFO "ALSA AC97: Driver Initialized\n");
         au1000_card = card;
         return 0;
 }
diff --git a/sound/oss/ad1848.c b/sound/oss/ad1848.c
index 7cf9913a47b2..d12bd98a37ba 100644
--- a/sound/oss/ad1848.c
+++ b/sound/oss/ad1848.c
@@ -280,7 +280,7 @@ static void wait_for_calibration(ad1848_info * devc)
         while (timeout > 0 && (ad_read(devc, 11) & 0x20))
                 timeout--;
         if (ad_read(devc, 11) & 0x20)
-                if ( (devc->model != MD_1845) || (devc->model != MD_1845_SSCAPE))
+                if ((devc->model != MD_1845) && (devc->model != MD_1845_SSCAPE))
                         printk(KERN_WARNING "ad1848: Auto calibration timed out(3).\n");
 }
 
@@ -2107,7 +2107,7 @@ int ad1848_control(int cmd, int arg)
         switch (cmd)
         {
                 case AD1848_SET_XTAL:   /* Change clock frequency of AD1845 (only ) */
-                        if (devc->model != MD_1845 || devc->model != MD_1845_SSCAPE)
+                        if (devc->model != MD_1845 && devc->model != MD_1845_SSCAPE)
                                 return -EINVAL;
                         spin_lock_irqsave(&devc->lock,flags);
                         ad_enter_MCE(devc);
diff --git a/sound/oss/au1550_ac97.c b/sound/oss/au1550_ac97.c
index 81e1f443d094..4191acccbcdb 100644
--- a/sound/oss/au1550_ac97.c
+++ b/sound/oss/au1550_ac97.c
@@ -1627,7 +1627,9 @@ au1550_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                                     sizeof(abinfo)) ? -EFAULT : 0;
 
         case SNDCTL_DSP_NONBLOCK:
+                spin_lock(&file->f_lock);
                 file->f_flags |= O_NONBLOCK;
+                spin_unlock(&file->f_lock);
                 return 0;
 
         case SNDCTL_DSP_GETODELAY:
diff --git a/sound/oss/audio.c b/sound/oss/audio.c
index 89bd27a5e865..b69c05b7ea7b 100644
--- a/sound/oss/audio.c
+++ b/sound/oss/audio.c
@@ -433,7 +433,9 @@ int audio_ioctl(int dev, struct file *file, unsigned int cmd, void __user *arg)
                         return dma_ioctl(dev, cmd, arg);
                 
                 case SNDCTL_DSP_NONBLOCK:
+                        spin_lock(&file->f_lock);
                         file->f_flags |= O_NONBLOCK;
+                        spin_unlock(&file->f_lock);
                         return 0;
 
                 case SNDCTL_DSP_GETCAPS:
diff --git a/sound/oss/dmabuf.c b/sound/oss/dmabuf.c
index 1e90d769b62e..1bfcf7e88546 100644
--- a/sound/oss/dmabuf.c
+++ b/sound/oss/dmabuf.c
@@ -439,7 +439,7 @@ int DMAbuf_sync(int dev)
                         DMAbuf_launch_output(dev, dmap);
                 adev->dmap_out->flags |= DMA_SYNCING;
                 adev->dmap_out->underrun_count = 0;
-                while (!signal_pending(current) && n++ <= adev->dmap_out->nbufs && 
+                while (!signal_pending(current) && n++ < adev->dmap_out->nbufs &&
                        adev->dmap_out->qlen && adev->dmap_out->underrun_count == 0) {
                         long t = dmabuf_timeout(dmap);
                         spin_unlock_irqrestore(&dmap->lock,flags);
diff --git a/sound/oss/dmasound/dmasound_atari.c b/sound/oss/dmasound/dmasound_atari.c
index 57d9f154c88b..1f4774123064 100644
--- a/sound/oss/dmasound/dmasound_atari.c
+++ b/sound/oss/dmasound/dmasound_atari.c
@@ -847,23 +847,23 @@ static int __init AtaIrqInit(void)
            of events. So all we need to keep the music playing is
            to provide the sound hardware with new data upon
            an interrupt from timer A. */
-        mfp.tim_ct_a = 0;       /* ++roman: Stop timer before programming! */
-        mfp.tim_dt_a = 1;       /* Cause interrupt after first event. */
-        mfp.tim_ct_a = 8;       /* Turn on event counting. */
+        st_mfp.tim_ct_a = 0;    /* ++roman: Stop timer before programming! */
+        st_mfp.tim_dt_a = 1;    /* Cause interrupt after first event. */
+        st_mfp.tim_ct_a = 8;    /* Turn on event counting. */
         /* Register interrupt handler. */
         if (request_irq(IRQ_MFP_TIMA, AtaInterrupt, IRQ_TYPE_SLOW, "DMA sound",
                         AtaInterrupt))
                 return 0;
-        mfp.int_en_a |= 0x20;   /* Turn interrupt on. */
-        mfp.int_mk_a |= 0x20;
+        st_mfp.int_en_a |= 0x20;        /* Turn interrupt on. */
+        st_mfp.int_mk_a |= 0x20;
         return 1;
 }
 
 #ifdef MODULE
 static void AtaIrqCleanUp(void)
 {
-        mfp.tim_ct_a = 0;       /* stop timer */
-        mfp.int_en_a &= ~0x20;  /* turn interrupt off */
+        st_mfp.tim_ct_a = 0;            /* stop timer */
+        st_mfp.int_en_a &= ~0x20;       /* turn interrupt off */
         free_irq(IRQ_MFP_TIMA, AtaInterrupt);
 }
 #endif /* MODULE */
@@ -1524,7 +1524,7 @@ static SETTINGS def_soft = {
         .speed  = 8000
 } ;
 
-static MACHINE machTT = {
+static __initdata MACHINE machTT = {
         .name           = "Atari",
         .name2          = "TT",
         .owner          = THIS_MODULE,
@@ -1553,7 +1553,7 @@ static MACHINE machTT = {
         .capabilities   =  DSP_CAP_BATCH        /* As per SNDCTL_DSP_GETCAPS */
 };
 
-static MACHINE machFalcon = {
+static __initdata MACHINE machFalcon = {
         .name           = "Atari",
         .name2          = "FALCON",
         .dma_alloc      = AtaAlloc,
@@ -1599,7 +1599,7 @@ static int __init dmasound_atari_init(void)
                 is_falcon = 0;
             } else
                 return -ENODEV;
-            if ((mfp.int_en_a & mfp.int_mk_a & 0x20) == 0)
+            if ((st_mfp.int_en_a & st_mfp.int_mk_a & 0x20) == 0)
                 return dmasound_init();
             else {
                 printk("DMA sound driver: Timer A interrupt already in use\n");
diff --git a/sound/oss/pas2_card.c b/sound/oss/pas2_card.c
index 25f3a22c52ee..7f377ec3486d 100644
--- a/sound/oss/pas2_card.c
+++ b/sound/oss/pas2_card.c
@@ -156,9 +156,7 @@ static int __init config_pas_hw(struct address_info *hw_config)
                                                  * 0x80
                                                  */ , 0xB88);
 
-        pas_write(0x80
-                  | joystick?0x40:0
-                  ,0xF388);
+        pas_write(0x80 | (joystick ? 0x40 : 0), 0xF388);
 
         if (pas_irq < 0 || pas_irq > 15)
         {
diff --git a/sound/oss/pss.c b/sound/oss/pss.c
index 16ed06950dc1..83f5ee236b12 100644
--- a/sound/oss/pss.c
+++ b/sound/oss/pss.c
@@ -46,7 +46,7 @@
  *          load the driver as it did in previous versions.
  * 04-07-1999: Anthony Barbachan <barbcode@xmen.cis.fordham.edu>
  *          Added module parameter pss_firmware to allow the user to tell 
- *          the driver where the fireware file is located.  The default 
+ *          the driver where the firmware file is located.  The default 
  *          setting is the previous hardcoded setting "/etc/sound/pss_synth".
  * 00-03-03: Christoph Hellwig <chhellwig@infradead.org>
  *          Adapted to module_init/module_exit
@@ -457,10 +457,9 @@ static void pss_mixer_reset(pss_confdata *devc)
         }
 }
 
-static int set_volume_mono(unsigned __user *p, int *aleft)
+static int set_volume_mono(unsigned __user *p, unsigned int *aleft)
 {
-        int left;
-        unsigned volume;
+        unsigned int left, volume;
         if (get_user(volume, p))
                 return -EFAULT;
         
@@ -471,10 +470,11 @@ static int set_volume_mono(unsigned __user *p, int *aleft)
         return 0;
 }
 
-static int set_volume_stereo(unsigned __user *p, int *aleft, int *aright)
+static int set_volume_stereo(unsigned __user *p,
+                             unsigned int *aleft,
+                             unsigned int *aright)
 {
-        int left, right;
-        unsigned volume;
+        unsigned int left, right, volume;
         if (get_user(volume, p))
                 return -EFAULT;
 
diff --git a/sound/oss/sequencer.c b/sound/oss/sequencer.c
index 5c215f787ca9..c79874696bec 100644
--- a/sound/oss/sequencer.c
+++ b/sound/oss/sequencer.c
@@ -212,7 +212,6 @@ int sequencer_write(int dev, struct file *file, const char __user *buf, int coun
 {
         unsigned char event_rec[EV_SZ], ev_code;
         int p = 0, c, ev_size;
-        int err;
         int mode = translate_mode(file);
 
         dev = dev >> 4;
@@ -285,7 +284,7 @@ int sequencer_write(int dev, struct file *file, const char __user *buf, int coun
                 {
                         if (!midi_opened[event_rec[2]])
                         {
-                                int mode;
+                                int err, mode;
                                 int dev = event_rec[2];
 
                                 if (dev >= max_mididev || midi_devs[dev]==NULL)
diff --git a/sound/oss/sh_dac_audio.c b/sound/oss/sh_dac_audio.c
index e5d423994918..78cfb66e4c59 100644
--- a/sound/oss/sh_dac_audio.c
+++ b/sound/oss/sh_dac_audio.c
@@ -135,7 +135,9 @@ static int dac_audio_ioctl(struct inode *inode, struct file *file,
                 return put_user(AFMT_U8, (int *)arg);
 
         case SNDCTL_DSP_NONBLOCK:
+                spin_lock(&file->f_lock);
                 file->f_flags |= O_NONBLOCK;
+                spin_unlock(&file->f_lock);
                 return 0;
 
         case SNDCTL_DSP_GETCAPS:
diff --git a/sound/oss/swarm_cs4297a.c b/sound/oss/swarm_cs4297a.c
index 41562ecde5bb..1edab7b4ea83 100644
--- a/sound/oss/swarm_cs4297a.c
+++ b/sound/oss/swarm_cs4297a.c
@@ -2200,7 +2200,9 @@ static int cs4297a_ioctl(struct inode *inode, struct file *file,
                                     sizeof(abinfo)) ? -EFAULT : 0;
 
         case SNDCTL_DSP_NONBLOCK:
+                spin_lock(&file->f_lock);
                 file->f_flags |= O_NONBLOCK;
+                spin_unlock(&file->f_lock);
                 return 0;
 
         case SNDCTL_DSP_GETODELAY:
diff --git a/sound/oss/vwsnd.c b/sound/oss/vwsnd.c
index 78b8acc7c3b9..187f72750e8f 100644
--- a/sound/oss/vwsnd.c
+++ b/sound/oss/vwsnd.c
@@ -2673,7 +2673,9 @@ static int vwsnd_audio_do_ioctl(struct inode *inode,
 
         case SNDCTL_DSP_NONBLOCK:       /* _SIO  ('P',14) */
                 DBGX("SNDCTL_DSP_NONBLOCK\n");
+                spin_lock(&file->f_lock);
                 file->f_flags |= O_NONBLOCK;
+                spin_unlock(&file->f_lock);
                 return 0;
 
         case SNDCTL_DSP_RESET:          /* _SIO  ('P', 0) */
diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig
index 6e3a1848447c..93422e3a3f0c 100644
--- a/sound/pci/Kconfig
+++ b/sound/pci/Kconfig
@@ -400,6 +400,26 @@ config SND_INDIGODJ
           To compile this driver as a module, choose M here: the module
           will be called snd-indigodj
 
+config SND_INDIGOIOX
+        tristate "(Echoaudio) Indigo IOx"
+        select FW_LOADER
+        select SND_PCM
+        help
+          Say 'Y' or 'M' to include support for Echoaudio Indigo IOx.
+
+          To compile this driver as a module, choose M here: the module
+          will be called snd-indigoiox
+
+config SND_INDIGODJX
+        tristate "(Echoaudio) Indigo DJx"
+        select FW_LOADER
+        select SND_PCM
+        help
+          Say 'Y' or 'M' to include support for Echoaudio Indigo DJx.
+
+          To compile this driver as a module, choose M here: the module
+          will be called snd-indigodjx
+
 config SND_EMU10K1
         tristate "Emu10k1 (SB Live!, Audigy, E-mu APS)"
         select FW_LOADER
@@ -487,7 +507,7 @@ config SND_FM801
 config SND_FM801_TEA575X_BOOL
         bool "ForteMedia FM801 + TEA5757 tuner"
         depends on SND_FM801
-        depends on VIDEO_V4L1=y || VIDEO_V4L1=SND_FM801
+        depends on VIDEO_V4L2=y || VIDEO_V4L2=SND_FM801
         help
           Say Y here to include support for soundcards based on the ForteMedia
           FM801 chip with a TEA5757 tuner connected to GPIO1-3 pins (Media
@@ -744,8 +764,9 @@ config SND_VIRTUOSO
         select SND_OXYGEN_LIB
         help
           Say Y here to include support for sound cards based on the
-          Asus AV100/AV200 chips, i.e., Xonar D1, DX, D2, D2X and
-          HDAV1.3 (Deluxe).
+          Asus AV100/AV200 chips, i.e., Xonar D1, DX, D2, D2X, and
+          Essence STX.
+          Support for the HDAV1.3 (Deluxe) is very experimental.
 
           To compile this driver as a module, choose M here: the module
           will be called snd-virtuoso.
diff --git a/sound/pci/ac97/ac97_codec.c b/sound/pci/ac97/ac97_codec.c
index e2b843b4f9d0..78288dbfc17a 100644
--- a/sound/pci/ac97/ac97_codec.c
+++ b/sound/pci/ac97/ac97_codec.c
@@ -143,6 +143,7 @@ static const struct ac97_codec_id snd_ac97_codec_ids[] = {
 { 0x43525970, 0xfffffff8, "CS4202",             NULL,           NULL },
 { 0x43585421, 0xffffffff, "HSD11246",           NULL,           NULL }, // SmartMC II
 { 0x43585428, 0xfffffff8, "Cx20468",            patch_conexant, NULL }, // SmartAMC fixme: the mask might be different
+{ 0x43585430, 0xffffffff, "Cx20468-31",         patch_conexant, NULL },
 { 0x43585431, 0xffffffff, "Cx20551",           patch_cx20551,  NULL },
 { 0x44543031, 0xfffffff0, "DT0398",             NULL,           NULL },
 { 0x454d4328, 0xffffffff, "EM28028",            NULL,           NULL },  // same as TR28028?
@@ -383,7 +384,7 @@ int snd_ac97_update_bits(struct snd_ac97 *ac97, unsigned short reg, unsigned sho
 
 EXPORT_SYMBOL(snd_ac97_update_bits);
 
-/* no lock version - see snd_ac97_updat_bits() */
+/* no lock version - see snd_ac97_update_bits() */
 int snd_ac97_update_bits_nolock(struct snd_ac97 *ac97, unsigned short reg,
                                 unsigned short mask, unsigned short value)
 {
@@ -1643,7 +1644,10 @@ static int snd_ac97_modem_build(struct snd_card *card, struct snd_ac97 * ac97)
 {
         int err, idx;
 
-        //printk("AC97_GPIO_CFG = %x\n",snd_ac97_read(ac97,AC97_GPIO_CFG));
+        /*
+        printk(KERN_DEBUG "AC97_GPIO_CFG = %x\n",
+               snd_ac97_read(ac97,AC97_GPIO_CFG));
+        */
         snd_ac97_write(ac97, AC97_GPIO_CFG, 0xffff & ~(AC97_GPIO_LINE1_OH));
         snd_ac97_write(ac97, AC97_GPIO_POLARITY, 0xffff & ~(AC97_GPIO_LINE1_OH));
         snd_ac97_write(ac97, AC97_GPIO_STICKY, 0xffff);
@@ -2118,7 +2122,7 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
                 }
                 /* nothing should be in powerdown mode */
                 snd_ac97_write_cache(ac97, AC97_GENERAL_PURPOSE, 0);
-                end_time = jiffies + msecs_to_jiffies(100);
+                end_time = jiffies + msecs_to_jiffies(120);
                 do {
                         if ((snd_ac97_read(ac97, AC97_POWERDOWN) & 0x0f) == 0x0f)
                                 goto __ready_ok;
diff --git a/sound/pci/ac97/ac97_proc.c b/sound/pci/ac97/ac97_proc.c
index 060ea59d5f02..73b17d526c8b 100644
--- a/sound/pci/ac97/ac97_proc.c
+++ b/sound/pci/ac97/ac97_proc.c
@@ -125,6 +125,8 @@ static void snd_ac97_proc_read_main(struct snd_ac97 *ac97, struct snd_info_buffe
         snd_iprintf(buffer, "PCI Subsys Device: 0x%04x\n\n",
                     ac97->subsystem_device);
 
+        snd_iprintf(buffer, "Flags: %x\n", ac97->flags);
+
         if ((ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_23) {
                 val = snd_ac97_read(ac97, AC97_INT_PAGING);
                 snd_ac97_update_bits(ac97, AC97_INT_PAGING,
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index d1f242bd0ac5..8f5098f92c37 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -909,8 +909,8 @@ snd_ad1889_create(struct snd_card *card,
                 return err;
 
         /* check PCI availability (32bit DMA) */
-        if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                 printk(KERN_ERR PFX "error setting 32-bit DMA mask.\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/ak4531_codec.c b/sound/pci/ak4531_codec.c
index 0f819ddb3ebf..fd135e3d8a84 100644
--- a/sound/pci/ak4531_codec.c
+++ b/sound/pci/ak4531_codec.c
@@ -51,7 +51,8 @@ static void snd_ak4531_dump(struct snd_ak4531 *ak4531)
         int idx;
         
         for (idx = 0; idx < 0x19; idx++)
-                printk("ak4531 0x%x: 0x%x\n", idx, ak4531->regs[idx]);
+                printk(KERN_DEBUG "ak4531 0x%x: 0x%x\n",
+                       idx, ak4531->regs[idx]);
 }
 
 #endif
diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
index b36c551da566..c551006e2920 100644
--- a/sound/pci/ali5451/ali5451.c
+++ b/sound/pci/ali5451/ali5451.c
@@ -2142,7 +2142,7 @@ static int __devinit snd_ali_resources(struct snd_ali *codec)
 {
         int err;
 
-        snd_ali_printk("resouces allocation ...\n");
+        snd_ali_printk("resources allocation ...\n");
         err = pci_request_regions(codec->pci, "ALI 5451");
         if (err < 0)
                 return err;
@@ -2154,7 +2154,7 @@ static int __devinit snd_ali_resources(struct snd_ali *codec)
                 return -EBUSY;
         }
         codec->irq = codec->pci->irq;
-        snd_ali_printk("resouces allocated.\n");
+        snd_ali_printk("resources allocated.\n");
         return 0;
 }
 static int snd_ali_dev_free(struct snd_device *device)
@@ -2186,8 +2186,8 @@ static int __devinit snd_ali_create(struct snd_card *card,
         if (err < 0)
                 return err;
         /* check, if we can restrict PCI DMA transfers to 31 bits */
-        if (pci_set_dma_mask(pci, DMA_31BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_31BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(31)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(31)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support "
                            "31bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
diff --git a/sound/pci/als300.c b/sound/pci/als300.c
index f557c155db48..3aa35af7ca91 100644
--- a/sound/pci/als300.c
+++ b/sound/pci/als300.c
@@ -91,7 +91,7 @@
 #define DEBUG_PLAY_REC  0
 
 #if DEBUG_CALLS
-#define snd_als300_dbgcalls(format, args...) printk(format, ##args)
+#define snd_als300_dbgcalls(format, args...) printk(KERN_DEBUG format, ##args)
 #define snd_als300_dbgcallenter() printk(KERN_ERR "--> %s\n", __func__)
 #define snd_als300_dbgcallleave() printk(KERN_ERR "<-- %s\n", __func__)
 #else
@@ -689,8 +689,8 @@ static int __devinit snd_als300_create(struct snd_card *card,
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
 
-        if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
-                pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
+                pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
                 printk(KERN_ERR "error setting 28bit DMA mask\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index 542a0c65a92c..3dbacde1a5af 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -872,8 +872,8 @@ static int __devinit snd_card_als4000_probe(struct pci_dev *pci,
                 return err;
         }
         /* check, if we can restrict PCI DMA transfers to 24 bits */
-        if (pci_set_dma_mask(pci, DMA_24BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_24BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index 9ce8548c03e4..71515ddb4593 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -1393,6 +1393,12 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = {
                 .name = "HP nx6125",
                 .type = AC97_TUNE_MUTE_LED
         },
+        {
+                .subvendor = 0x103c,
+                .subdevice = 0x3091,
+                .name = "unknown HP",
+                .type = AC97_TUNE_MUTE_LED
+        },
         { } /* terminator */
 };
 
diff --git a/sound/pci/au88x0/au88x0.c b/sound/pci/au88x0/au88x0.c
index 9ec122383eef..7b72c88e449d 100644
--- a/sound/pci/au88x0/au88x0.c
+++ b/sound/pci/au88x0/au88x0.c
@@ -151,8 +151,8 @@ snd_vortex_create(struct snd_card *card, struct pci_dev *pci, vortex_t ** rchip)
         // check PCI availability (DMA).
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
-        if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                 printk(KERN_ERR "error to set DMA mask\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/au88x0/au88x0_a3d.c b/sound/pci/au88x0/au88x0_a3d.c
index 649849e540d3..f4aa8ff6f5f9 100644
--- a/sound/pci/au88x0/au88x0_a3d.c
+++ b/sound/pci/au88x0/au88x0_a3d.c
@@ -462,9 +462,10 @@ static void a3dsrc_ZeroSliceIO(a3dsrc_t * a)
 /* Reset Single A3D source. */
 static void a3dsrc_ZeroState(a3dsrc_t * a)
 {
-
-        //printk("vortex: ZeroState slice: %d, source %d\n", a->slice, a->source);
-
+        /*
+        printk(KERN_DEBUG "vortex: ZeroState slice: %d, source %d\n",
+               a->slice, a->source);
+        */
         a3dsrc_SetAtmosState(a, 0, 0, 0, 0);
         a3dsrc_SetHrtfState(a, A3dHrirZeros, A3dHrirZeros);
         a3dsrc_SetItdDline(a, A3dItdDlineZeros);
diff --git a/sound/pci/au88x0/au88x0_core.c b/sound/pci/au88x0/au88x0_core.c
index b070e5714514..3906f5afe27a 100644
--- a/sound/pci/au88x0/au88x0_core.c
+++ b/sound/pci/au88x0/au88x0_core.c
@@ -1135,7 +1135,10 @@ vortex_adbdma_setbuffers(vortex_t * vortex, int adbdma,
                         snd_pcm_sgbuf_get_addr(dma->substream, 0));
                 break;
         }
-        //printk("vortex: cfg0 = 0x%x\nvortex: cfg1=0x%x\n", dma->cfg0, dma->cfg1);
+        /*
+        printk(KERN_DEBUG "vortex: cfg0 = 0x%x\nvortex: cfg1=0x%x\n",
+               dma->cfg0, dma->cfg1);
+        */
         hwwrite(vortex->mmio, VORTEX_ADBDMA_BUFCFG0 + (adbdma << 3), dma->cfg0);
         hwwrite(vortex->mmio, VORTEX_ADBDMA_BUFCFG1 + (adbdma << 3), dma->cfg1);
 
@@ -1959,7 +1962,7 @@ vortex_connect_codecplay(vortex_t * vortex, int en, unsigned char mixers[])
                                           ADB_CODECOUT(0 + 4));
                 vortex_connection_mix_adb(vortex, en, 0x11, mixers[3],
                                           ADB_CODECOUT(1 + 4));
-                //printk("SDAC detected ");
+                /* printk(KERN_DEBUG "SDAC detected "); */
         }
 #else
         // Use plain direct output to codec.
@@ -2013,7 +2016,11 @@ vortex_adb_checkinout(vortex_t * vortex, int resmap[], int out, int restype)
                                         resmap[restype] |= (1 << i);
                                 else
                                         vortex->dma_adb[i].resources[restype] |= (1 << i);
-                                //printk("vortex: ResManager: type %d out %d\n", restype, i);
+                                /*
+                                printk(KERN_DEBUG
+                                       "vortex: ResManager: type %d out %d\n",
+                                       restype, i);
+                                */
                                 return i;
                         }
                 }
@@ -2024,7 +2031,11 @@ vortex_adb_checkinout(vortex_t * vortex, int resmap[], int out, int restype)
                 for (i = 0; i < qty; i++) {
                         if (resmap[restype] & (1 << i)) {
                                 resmap[restype] &= ~(1 << i);
-                                //printk("vortex: ResManager: type %d in %d\n",restype, i);
+                                /*
+                                printk(KERN_DEBUG
+                                       "vortex: ResManager: type %d in %d\n",
+                                       restype, i);
+                                */
                                 return i;
                         }
                 }
@@ -2789,7 +2800,7 @@ vortex_translateformat(vortex_t * vortex, char bits, char nch, int encod)
 {
         int a, this_194;
 
-        if ((bits != 8) || (bits != 16))
+        if ((bits != 8) && (bits != 16))
                 return -1;
 
         switch (encod) {
diff --git a/sound/pci/au88x0/au88x0_synth.c b/sound/pci/au88x0/au88x0_synth.c
index 978b856f5621..2805e34bd41d 100644
--- a/sound/pci/au88x0/au88x0_synth.c
+++ b/sound/pci/au88x0/au88x0_synth.c
@@ -213,38 +213,59 @@ vortex_wt_SetReg(vortex_t * vortex, unsigned char reg, int wt,
         switch (reg) {
                 /* Voice specific parameters */
         case 0:         /* running */
-                //printk("vortex: WT SetReg(0x%x) = 0x%08x\n", WT_RUN(wt), (int)val);
+                /*
+                printk(KERN_DEBUG "vortex: WT SetReg(0x%x) = 0x%08x\n",
+                       WT_RUN(wt), (int)val);
+                */
                 hwwrite(vortex->mmio, WT_RUN(wt), val);
                 return 0xc;
                 break;
         case 1:         /* param 0 */
-                //printk("vortex: WT SetReg(0x%x) = 0x%08x\n", WT_PARM(wt,0), (int)val);
+                /*
+                printk(KERN_DEBUG "vortex: WT SetReg(0x%x) = 0x%08x\n",
+                       WT_PARM(wt,0), (int)val);
+                */
                 hwwrite(vortex->mmio, WT_PARM(wt, 0), val);
                 return 0xc;
                 break;
         case 2:         /* param 1 */
-                //printk("vortex: WT SetReg(0x%x) = 0x%08x\n", WT_PARM(wt,1), (int)val);
+                /*
+                printk(KERN_DEBUG "vortex: WT SetReg(0x%x) = 0x%08x\n",
+                       WT_PARM(wt,1), (int)val);
+                */
                 hwwrite(vortex->mmio, WT_PARM(wt, 1), val);
                 return 0xc;
                 break;
         case 3:         /* param 2 */
-                //printk("vortex: WT SetReg(0x%x) = 0x%08x\n", WT_PARM(wt,2), (int)val);
+                /*
+                printk(KERN_DEBUG "vortex: WT SetReg(0x%x) = 0x%08x\n",
+                       WT_PARM(wt,2), (int)val);
+                */
                 hwwrite(vortex->mmio, WT_PARM(wt, 2), val);
                 return 0xc;
                 break;
         case 4:         /* param 3 */
-                //printk("vortex: WT SetReg(0x%x) = 0x%08x\n", WT_PARM(wt,3), (int)val);
+                /*
+                printk(KERN_DEBUG "vortex: WT SetReg(0x%x) = 0x%08x\n",
+                       WT_PARM(wt,3), (int)val);
+                */
                 hwwrite(vortex->mmio, WT_PARM(wt, 3), val);
                 return 0xc;
                 break;
         case 6:         /* mute */
-                //printk("vortex: WT SetReg(0x%x) = 0x%08x\n", WT_MUTE(wt), (int)val);
+                /*
+                printk(KERN_DEBUG "vortex: WT SetReg(0x%x) = 0x%08x\n",
+                       WT_MUTE(wt), (int)val);
+                */
                 hwwrite(vortex->mmio, WT_MUTE(wt), val);
                 return 0xc;
                 break;
         case 0xb:
                 {               /* delay */
-                        //printk("vortex: WT SetReg(0x%x) = 0x%08x\n", WT_DELAY(wt,0), (int)val);
+                        /*
+                        printk(KERN_DEBUG "vortex: WT SetReg(0x%x) = 0x%08x\n",
+                               WT_DELAY(wt,0), (int)val);
+                        */
                         hwwrite(vortex->mmio, WT_DELAY(wt, 3), val);
                         hwwrite(vortex->mmio, WT_DELAY(wt, 2), val);
                         hwwrite(vortex->mmio, WT_DELAY(wt, 1), val);
@@ -272,7 +293,9 @@ vortex_wt_SetReg(vortex_t * vortex, unsigned char reg, int wt,
                 return 0;
                 break;
         }
-        //printk("vortex: WT SetReg(0x%x) = 0x%08x\n", ecx, (int)val);
+        /*
+        printk(KERN_DEBUG "vortex: WT SetReg(0x%x) = 0x%08x\n", ecx, (int)val);
+        */
         hwwrite(vortex->mmio, ecx, val);
         return 1;
 }
diff --git a/sound/pci/aw2/aw2-alsa.c b/sound/pci/aw2/aw2-alsa.c
index eefcbf648ee1..4d34bb0d99d3 100644
--- a/sound/pci/aw2/aw2-alsa.c
+++ b/sound/pci/aw2/aw2-alsa.c
@@ -165,7 +165,7 @@ module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "Enable Audiowerk2 soundcard.");
 
 static struct pci_device_id snd_aw2_ids[] = {
-        {PCI_VENDOR_ID_SAA7146, PCI_DEVICE_ID_SAA7146, PCI_ANY_ID, PCI_ANY_ID,
+        {PCI_VENDOR_ID_SAA7146, PCI_DEVICE_ID_SAA7146, 0, 0,
          0, 0, 0},
         {0}
 };
@@ -279,8 +279,8 @@ static int __devinit snd_aw2_create(struct snd_card *card,
         pci_set_master(pci);
 
         /* check PCI availability (32bit DMA) */
-        if ((pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0) ||
-            (pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0)) {
+        if ((pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) ||
+            (pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0)) {
                 printk(KERN_ERR "aw2: Impossible to set 32bit mask DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index 1df96e76c483..f290bc56178f 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -211,25 +211,25 @@ MODULE_SUPPORTED_DEVICE("{{Aztech,AZF3328}}");
 #endif
 
 #if DEBUG_MIXER
-#define snd_azf3328_dbgmixer(format, args...) printk(format, ##args)
+#define snd_azf3328_dbgmixer(format, args...) printk(KERN_DEBUG format, ##args)
 #else
 #define snd_azf3328_dbgmixer(format, args...)
 #endif
 
 #if DEBUG_PLAY_REC
-#define snd_azf3328_dbgplay(format, args...) printk(KERN_ERR format, ##args)
+#define snd_azf3328_dbgplay(format, args...) printk(KERN_DEBUG format, ##args)
 #else
 #define snd_azf3328_dbgplay(format, args...)
 #endif
 
 #if DEBUG_MISC
-#define snd_azf3328_dbgtimer(format, args...) printk(KERN_ERR format, ##args)
+#define snd_azf3328_dbgtimer(format, args...) printk(KERN_DEBUG format, ##args)
 #else
 #define snd_azf3328_dbgtimer(format, args...)
 #endif
 
 #if DEBUG_GAME
-#define snd_azf3328_dbggame(format, args...) printk(KERN_ERR format, ##args)
+#define snd_azf3328_dbggame(format, args...) printk(KERN_DEBUG format, ##args)
 #else
 #define snd_azf3328_dbggame(format, args...)
 #endif
@@ -2125,8 +2125,8 @@ snd_azf3328_create(struct snd_card *card,
         chip->irq = -1;
 
         /* check if we can restrict PCI DMA transfers to 24 bits */
-        if (pci_set_dma_mask(pci, DMA_24BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_24BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support "
                                         "24bit PCI busmaster DMA\n"
                 );
diff --git a/sound/pci/bt87x.c b/sound/pci/bt87x.c
index a299340519df..ce3f2e90f4d7 100644
--- a/sound/pci/bt87x.c
+++ b/sound/pci/bt87x.c
@@ -349,7 +349,8 @@ static struct snd_pcm_hardware snd_bt87x_digital_hw = {
         .info = SNDRV_PCM_INFO_MMAP |
                 SNDRV_PCM_INFO_INTERLEAVED |
                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                SNDRV_PCM_INFO_MMAP_VALID,
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_BATCH,
         .formats = SNDRV_PCM_FMTBIT_S16_LE,
         .rates = 0, /* set at runtime */
         .channels_min = 2,
@@ -365,7 +366,8 @@ static struct snd_pcm_hardware snd_bt87x_analog_hw = {
         .info = SNDRV_PCM_INFO_MMAP |
                 SNDRV_PCM_INFO_INTERLEAVED |
                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                SNDRV_PCM_INFO_MMAP_VALID,
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_BATCH,
         .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
         .rates = SNDRV_PCM_RATE_KNOT,
         .rate_min = ANALOG_CLOCK / CLOCK_DIV_MAX,
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index b116456e7707..bfac30f7929f 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -255,6 +255,14 @@ static struct snd_ca0106_details ca0106_chip_details[] = {
            .gpio_type = 2,
            .i2c_adc = 1,
            .spi_dac = 1 } ,
+        /* Giga-byte GA-G1975X mobo
+         * Novell bnc#395807
+         */
+        /* FIXME: the GPIO and I2C setting aren't tested well */
+        { .serial = 0x1458a006,
+          .name = "Giga-byte GA-G1975X",
+          .gpio_type = 1,
+          .i2c_adc = 1 },
          /* Shuttle XPC SD31P which has an onboard Creative Labs
           * Sound Blaster Live! 24-bit EAX
           * high-definition 7.1 audio processor".
@@ -404,7 +412,9 @@ 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);
+        /*
+        snd_printk(KERN_DEBUG "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); */
 
@@ -422,7 +432,7 @@ int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
                 /* Wait till the transaction ends */
                 while (1) {
                         status = snd_ca0106_ptr_read(emu, I2C_A, 0);
-                        //snd_printk("I2C:status=0x%x\n", status);
+                        /*snd_printk(KERN_DEBUG "I2C:status=0x%x\n", status);*/
                         timeout++;
                         if ((status & I2C_A_ADC_START) == 0)
                                 break;
@@ -521,7 +531,10 @@ static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substr
         channel->number = channel_id;
 
         channel->use = 1;
-        //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
+        /*
+        printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
+               channel_id, chip, channel);
+        */
         //channel->interrupt = snd_ca0106_pcm_channel_interrupt;
         channel->epcm = epcm;
         if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
@@ -614,7 +627,10 @@ static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substre
         channel->number = channel_id;
 
         channel->use = 1;
-        //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
+        /*
+        printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
+               channel_id, chip, channel);
+        */
         //channel->interrupt = snd_ca0106_pcm_channel_interrupt;
         channel->epcm = epcm;
         if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
@@ -705,9 +721,20 @@ static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream)
         u32 reg71;
         int i;
         
-        //snd_printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, periods=%u, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, runtime->periods, frames_to_bytes(runtime, 1));
-        //snd_printk("dma_addr=%x, dma_area=%p, table_base=%p\n",runtime->dma_addr, runtime->dma_area, table_base);
-        //snd_printk("dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
+#if 0 /* debug */
+        snd_printk(KERN_DEBUG
+                   "prepare:channel_number=%d, rate=%d, format=0x%x, "
+                   "channels=%d, buffer_size=%ld, period_size=%ld, "
+                   "periods=%u, frames_to_bytes=%d\n",
+                   channel, runtime->rate, runtime->format,
+                   runtime->channels, runtime->buffer_size,
+                   runtime->period_size, runtime->periods,
+                   frames_to_bytes(runtime, 1));
+        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
+                   runtime->dma_addr, runtime->dma_area, table_base);
+        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
+                   emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
+#endif /* debug */
         /* Rate can be set per channel. */
         /* reg40 control host to fifo */
         /* reg71 controls DAC rate. */
@@ -799,9 +826,20 @@ static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
         u32 reg71_set = 0;
         u32 reg71;
         
-        //snd_printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, periods=%u, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, runtime->periods, frames_to_bytes(runtime, 1));
-        //snd_printk("dma_addr=%x, dma_area=%p, table_base=%p\n",runtime->dma_addr, runtime->dma_area, table_base);
-        //snd_printk("dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
+#if 0 /* debug */
+        snd_printk(KERN_DEBUG
+                   "prepare:channel_number=%d, rate=%d, format=0x%x, "
+                   "channels=%d, buffer_size=%ld, period_size=%ld, "
+                   "periods=%u, frames_to_bytes=%d\n",
+                   channel, runtime->rate, runtime->format,
+                   runtime->channels, runtime->buffer_size,
+                   runtime->period_size, runtime->periods,
+                   frames_to_bytes(runtime, 1));
+        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
+                   runtime->dma_addr, runtime->dma_area, table_base);
+        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
+                   emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
+#endif /* debug */
         /* reg71 controls ADC rate. */
         switch (runtime->rate) {
         case 44100:
@@ -846,7 +884,14 @@ static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
         }
 
 
-        //printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size,  frames_to_bytes(runtime, 1));
+        /*
+        printk(KERN_DEBUG
+               "prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, "
+               "buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",
+               channel, runtime->rate, runtime->format, runtime->channels,
+               runtime->buffer_size, runtime->period_size,
+               frames_to_bytes(runtime, 1));
+        */
         snd_ca0106_ptr_write(emu, 0x13, channel, 0);
         snd_ca0106_ptr_write(emu, CAPTURE_DMA_ADDR, channel, runtime->dma_addr);
         snd_ca0106_ptr_write(emu, CAPTURE_BUFFER_SIZE, channel, frames_to_bytes(runtime, runtime->buffer_size)<<16); // buffer size in bytes
@@ -888,13 +933,13 @@ static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream,
                 runtime = s->runtime;
                 epcm = runtime->private_data;
                 channel = epcm->channel_id;
-                /* snd_printk("channel=%d\n",channel); */
+                /* snd_printk(KERN_DEBUG "channel=%d\n", channel); */
                 epcm->running = running;
                 basic |= (0x1 << channel);
                 extended |= (0x10 << channel);
                 snd_pcm_trigger_done(s, substream);
         }
-        /* snd_printk("basic=0x%x, extended=0x%x\n",basic, extended); */
+        /* snd_printk(KERN_DEBUG "basic=0x%x, extended=0x%x\n",basic, extended); */
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
@@ -972,8 +1017,13 @@ snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream)
         ptr=ptr2;
         if (ptr >= runtime->buffer_size)
                 ptr -= runtime->buffer_size;
-        //printk("ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", ptr1, ptr2, ptr, (int)runtime->buffer_size, (int)runtime->period_size, (int)runtime->frame_bits, (int)runtime->rate);
-
+        /*
+        printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
+               "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
+               ptr1, ptr2, ptr, (int)runtime->buffer_size,
+               (int)runtime->period_size, (int)runtime->frame_bits,
+               (int)runtime->rate);
+        */
         return ptr;
 }
 
@@ -995,8 +1045,13 @@ snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream)
         ptr=ptr2;
         if (ptr >= runtime->buffer_size)
                 ptr -= runtime->buffer_size;
-        //printk("ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", ptr1, ptr2, ptr, (int)runtime->buffer_size, (int)runtime->period_size, (int)runtime->frame_bits, (int)runtime->rate);
-
+        /*
+        printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
+               "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
+               ptr1, ptr2, ptr, (int)runtime->buffer_size,
+               (int)runtime->period_size, (int)runtime->frame_bits,
+               (int)runtime->rate);
+        */
         return ptr;
 }
 
@@ -1181,8 +1236,12 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id)
                 return IRQ_NONE;
 
         stat76 = snd_ca0106_ptr_read(chip, EXTENDED_INT, 0);
-        //snd_printk("interrupt status = 0x%08x, stat76=0x%08x\n", status, stat76);
-        //snd_printk("ptr=0x%08x\n",snd_ca0106_ptr_read(chip, PLAYBACK_POINTER, 0));
+        /*
+        snd_printk(KERN_DEBUG "interrupt status = 0x%08x, stat76=0x%08x\n",
+                   status, stat76);
+        snd_printk(KERN_DEBUG "ptr=0x%08x\n",
+                   snd_ca0106_ptr_read(chip, PLAYBACK_POINTER, 0));
+        */
         mask = 0x11; /* 0x1 for one half, 0x10 for the other half period. */
         for(i = 0; i < 4; i++) {
                 pchannel = &(chip->playback_channels[i]);
@@ -1470,7 +1529,7 @@ static void ca0106_init_chip(struct snd_ca0106 *chip, int resume)
                 int size, n;
 
                 size = ARRAY_SIZE(i2c_adc_init);
-                /* snd_printk("I2C:array size=0x%x\n", size); */
+                /* snd_printk(KERN_DEBUG "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]);
@@ -1530,8 +1589,8 @@ static int __devinit snd_ca0106_create(int dev, struct snd_card *card,
         err = pci_enable_device(pci);
         if (err < 0)
                 return err;
-        if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                 printk(KERN_ERR "error to set 32bit mask DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index c7899c32aba1..449fe02f666e 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -3014,7 +3014,7 @@ static int __devinit snd_cmipci_create(struct snd_card *card, struct pci_dev *pc
                 .dev_free =     snd_cmipci_dev_free,
         };
         unsigned int val;
-        long iomidi;
+        long iomidi = 0;
         int integrated_midi = 0;
         char modelstr[16];
         int pcm_index, pcm_spdif_index;
diff --git a/sound/pci/cs4281.c b/sound/pci/cs4281.c
index b9b07f464631..f6286f84a221 100644
--- a/sound/pci/cs4281.c
+++ b/sound/pci/cs4281.c
@@ -834,7 +834,11 @@ static snd_pcm_uframes_t snd_cs4281_pointer(struct snd_pcm_substream *substream)
         struct cs4281_dma *dma = runtime->private_data;
         struct cs4281 *chip = snd_pcm_substream_chip(substream);
 
-        // printk("DCC = 0x%x, buffer_size = 0x%x, jiffies = %li\n", snd_cs4281_peekBA0(chip, dma->regDCC), runtime->buffer_size, jiffies);
+        /*
+        printk(KERN_DEBUG "DCC = 0x%x, buffer_size = 0x%x, jiffies = %li\n",
+               snd_cs4281_peekBA0(chip, dma->regDCC), runtime->buffer_size,
+               jiffies);
+        */
         return runtime->buffer_size -
                snd_cs4281_peekBA0(chip, dma->regDCC) - 1;
 }
diff --git a/sound/pci/cs46xx/cs46xx_lib.c b/sound/pci/cs46xx/cs46xx_lib.c
index 8ab07aa63652..1be96ead4244 100644
--- a/sound/pci/cs46xx/cs46xx_lib.c
+++ b/sound/pci/cs46xx/cs46xx_lib.c
@@ -194,7 +194,7 @@ static unsigned short snd_cs46xx_codec_read(struct snd_cs46xx *chip,
          *  ACSDA = Status Data Register = 474h
          */
 #if 0
-        printk("e) reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n", reg,
+        printk(KERN_DEBUG "e) reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n", reg,
                         snd_cs46xx_peekBA0(chip, BA0_ACSDA),
                         snd_cs46xx_peekBA0(chip, BA0_ACCAD));
 #endif
@@ -428,8 +428,8 @@ static int cs46xx_wait_for_fifo(struct snd_cs46xx * chip,int retry_timeout)
         }
   
         if(status & SERBST_WBSY) {
-                snd_printk( KERN_ERR "cs46xx: failure waiting for FIFO command to complete\n");
-
+                snd_printk(KERN_ERR "cs46xx: failure waiting for "
+                           "FIFO command to complete\n");
                 return -EINVAL;
         }
 
diff --git a/sound/pci/cs46xx/cs46xx_lib.h b/sound/pci/cs46xx/cs46xx_lib.h
index 018a7de56017..4eb55aa33612 100644
--- a/sound/pci/cs46xx/cs46xx_lib.h
+++ b/sound/pci/cs46xx/cs46xx_lib.h
@@ -62,7 +62,11 @@ static inline void snd_cs46xx_poke(struct snd_cs46xx *chip, unsigned long reg, u
         unsigned int bank = reg >> 16;
         unsigned int offset = reg & 0xffff;
 
-        /*if (bank == 0) printk("snd_cs46xx_poke: %04X - %08X\n",reg >> 2,val); */
+        /*
+        if (bank == 0)
+                printk(KERN_DEBUG "snd_cs46xx_poke: %04X - %08X\n",
+                       reg >> 2,val);
+        */
         writel(val, chip->region.idx[bank+1].remap_addr + offset);
 }
 
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
index ac1d72e0a1e4..05f56e04849b 100644
--- a/sound/pci/cs5535audio/cs5535audio.c
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -285,8 +285,8 @@ static int __devinit snd_cs5535audio_create(struct snd_card *card,
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
 
-        if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                 printk(KERN_WARNING "unable to get 32bit dma\n");
                 err = -ENXIO;
                 goto pcifail;
@@ -312,7 +312,7 @@ static int __devinit snd_cs5535audio_create(struct snd_card *card,
 
         if (request_irq(pci->irq, snd_cs5535audio_interrupt,
                         IRQF_SHARED, "CS5535 Audio", cs5535au)) {
-                snd_printk("unable to grab IRQ %d\n", pci->irq);
+                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                 err = -EBUSY;
                 goto sndfail;
         }
diff --git a/sound/pci/echoaudio/Makefile b/sound/pci/echoaudio/Makefile
index 7b576aeb3f8d..1361de77e0cd 100644
--- a/sound/pci/echoaudio/Makefile
+++ b/sound/pci/echoaudio/Makefile
@@ -15,6 +15,8 @@ snd-echo3g-objs := echo3g.o
 snd-indigo-objs := indigo.o
 snd-indigoio-objs := indigoio.o
 snd-indigodj-objs := indigodj.o
+snd-indigoiox-objs := indigoiox.o
+snd-indigodjx-objs := indigodjx.o
 
 obj-$(CONFIG_SND_DARLA20) += snd-darla20.o
 obj-$(CONFIG_SND_GINA20) += snd-gina20.o
@@ -28,3 +30,5 @@ obj-$(CONFIG_SND_ECHO3G) += snd-echo3g.o
 obj-$(CONFIG_SND_INDIGO) += snd-indigo.o
 obj-$(CONFIG_SND_INDIGOIO) += snd-indigoio.o
 obj-$(CONFIG_SND_INDIGODJ) += snd-indigodj.o
+obj-$(CONFIG_SND_INDIGOIOX) += snd-indigoiox.o
+obj-$(CONFIG_SND_INDIGODJX) += snd-indigodjx.o
diff --git a/sound/pci/echoaudio/echo3g_dsp.c b/sound/pci/echoaudio/echo3g_dsp.c
index 417e25add82b..57967e580571 100644
--- a/sound/pci/echoaudio/echo3g_dsp.c
+++ b/sound/pci/echoaudio/echo3g_dsp.c
@@ -56,7 +56,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         }
 
         chip->comm_page->e3g_frq_register =
-                __constant_cpu_to_le32((E3G_MAGIC_NUMBER / 48000) - 2);
+                cpu_to_le32((E3G_MAGIC_NUMBER / 48000) - 2);
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index 9d015a76eb69..da2065cd2c0d 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -950,6 +950,8 @@ static int __devinit snd_echo_new_pcm(struct echoaudio *chip)
         Control interface
 ******************************************************************************/
 
+#ifndef ECHOCARD_HAS_VMIXER
+
 /******************* PCM output volume *******************/
 static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
                                      struct snd_ctl_elem_info *uinfo)
@@ -1001,18 +1003,6 @@ static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
         return changed;
 }
 
-#ifdef ECHOCARD_HAS_VMIXER
-/* On Vmixer cards this one controls the line-out volume */
-static struct snd_kcontrol_new snd_echo_line_output_gain __devinitdata = {
-        .name = "Line Playback Volume",
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
-        .info = snd_echo_output_gain_info,
-        .get = snd_echo_output_gain_get,
-        .put = snd_echo_output_gain_put,
-        .tlv = {.p = db_scale_output_gain},
-};
-#else
 static struct snd_kcontrol_new snd_echo_pcm_output_gain __devinitdata = {
         .name = "PCM Playback Volume",
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1022,6 +1012,7 @@ static struct snd_kcontrol_new snd_echo_pcm_output_gain __devinitdata = {
         .put = snd_echo_output_gain_put,
         .tlv = {.p = db_scale_output_gain},
 };
+
 #endif
 
 
@@ -2037,8 +2028,6 @@ static int __devinit snd_echo_probe(struct pci_dev *pci,
 
 #ifdef ECHOCARD_HAS_VMIXER
         snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
-        if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_output_gain, chip))) < 0)
-                goto ctl_error;
         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
                 goto ctl_error;
 #else
diff --git a/sound/pci/echoaudio/echoaudio.h b/sound/pci/echoaudio/echoaudio.h
index 1c88e051abf2..f9490ae36c2e 100644
--- a/sound/pci/echoaudio/echoaudio.h
+++ b/sound/pci/echoaudio/echoaudio.h
@@ -189,6 +189,9 @@
 #define INDIGO                  0x0090
 #define INDIGO_IO               0x00a0
 #define INDIGO_DJ               0x00b0
+#define DC8                     0x00c0
+#define INDIGO_IOX              0x00d0
+#define INDIGO_DJX              0x00e0
 #define ECHO3G                  0x0100
 
 
diff --git a/sound/pci/echoaudio/echoaudio_3g.c b/sound/pci/echoaudio/echoaudio_3g.c
index c3736bbd819e..e32a74897921 100644
--- a/sound/pci/echoaudio/echoaudio_3g.c
+++ b/sound/pci/echoaudio/echoaudio_3g.c
@@ -40,8 +40,7 @@ static int check_asic_status(struct echoaudio *chip)
         if (wait_handshake(chip))
                 return -EIO;
 
-        chip->comm_page->ext_box_status =
-                __constant_cpu_to_le32(E3G_ASIC_NOT_LOADED);
+        chip->comm_page->ext_box_status = cpu_to_le32(E3G_ASIC_NOT_LOADED);
         chip->asic_loaded = FALSE;
         clear_handshake(chip);
         send_vector(chip, DSP_VC_TEST_ASIC);
diff --git a/sound/pci/echoaudio/echoaudio_dsp.c b/sound/pci/echoaudio/echoaudio_dsp.c
index be0e18192de3..4df51ef5e095 100644
--- a/sound/pci/echoaudio/echoaudio_dsp.c
+++ b/sound/pci/echoaudio/echoaudio_dsp.c
@@ -926,11 +926,11 @@ static int init_dsp_comm_page(struct echoaudio *chip)
 
         /* Init the comm page */
         chip->comm_page->comm_size =
-                __constant_cpu_to_le32(sizeof(struct comm_page));
+                cpu_to_le32(sizeof(struct comm_page));
         chip->comm_page->handshake = 0xffffffff;
         chip->comm_page->midi_out_free_count =
-                __constant_cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE);
-        chip->comm_page->sample_rate = __constant_cpu_to_le32(44100);
+                cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE);
+        chip->comm_page->sample_rate = cpu_to_le32(44100);
         chip->sample_rate = 44100;
 
         /* Set line levels so we don't blast any inputs on startup */
diff --git a/sound/pci/echoaudio/echoaudio_dsp.h b/sound/pci/echoaudio/echoaudio_dsp.h
index e352f3ae292c..cb7d75a0a503 100644
--- a/sound/pci/echoaudio/echoaudio_dsp.h
+++ b/sound/pci/echoaudio/echoaudio_dsp.h
@@ -576,8 +576,13 @@ SET_LAYLA24_FREQUENCY_REG command.
 #define E3G_ASIC_NOT_LOADED             0xffff
 #define E3G_BOX_TYPE_MASK               0xf0
 
-#define EXT_3GBOX_NC                    0x01
-#define EXT_3GBOX_NOT_SET               0x02
+/* Indigo express control register values */
+#define INDIGO_EXPRESS_32000            0x02
+#define INDIGO_EXPRESS_44100            0x01
+#define INDIGO_EXPRESS_48000            0x00
+#define INDIGO_EXPRESS_DOUBLE_SPEED     0x10
+#define INDIGO_EXPRESS_QUAD_SPEED       0x04
+#define INDIGO_EXPRESS_CLOCK_MASK       0x17
 
 
 /*
diff --git a/sound/pci/echoaudio/gina20_dsp.c b/sound/pci/echoaudio/gina20_dsp.c
index db6c952e9d7f..3f1e7475faea 100644
--- a/sound/pci/echoaudio/gina20_dsp.c
+++ b/sound/pci/echoaudio/gina20_dsp.c
@@ -208,10 +208,10 @@ static int set_professional_spdif(struct echoaudio *chip, char prof)
         DE_ACT(("set_professional_spdif %d\n", prof));
         if (prof)
                 chip->comm_page->flags |=
-                        __constant_cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
+                        cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
         else
                 chip->comm_page->flags &=
-                        ~__constant_cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
+                        ~cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
         chip->professional_spdif = prof;
         return update_flags(chip);
 }
diff --git a/sound/pci/echoaudio/indigo_dsp.c b/sound/pci/echoaudio/indigo_dsp.c
index f05e39f7aad9..0b2cd9c86277 100644
--- a/sound/pci/echoaudio/indigo_dsp.c
+++ b/sound/pci/echoaudio/indigo_dsp.c
@@ -63,18 +63,6 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         if ((err = init_line_levels(chip)) < 0)
                 return err;
 
-        /* Default routing of the virtual channels: all vchannels are routed
-        to the stereo output */
-        set_vmixer_gain(chip, 0, 0, 0);
-        set_vmixer_gain(chip, 1, 1, 0);
-        set_vmixer_gain(chip, 0, 2, 0);
-        set_vmixer_gain(chip, 1, 3, 0);
-        set_vmixer_gain(chip, 0, 4, 0);
-        set_vmixer_gain(chip, 1, 5, 0);
-        set_vmixer_gain(chip, 0, 6, 0);
-        set_vmixer_gain(chip, 1, 7, 0);
-        err = update_vmixer_level(chip);
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
diff --git a/sound/pci/echoaudio/indigo_express_dsp.c b/sound/pci/echoaudio/indigo_express_dsp.c
new file mode 100644
index 000000000000..9ab625e15652
--- /dev/null
+++ b/sound/pci/echoaudio/indigo_express_dsp.c
@@ -0,0 +1,119 @@
+/************************************************************************
+
+This file is part of Echo Digital Audio's generic driver library.
+Copyright Echo Digital Audio Corporation (c) 1998 - 2005
+All rights reserved
+www.echoaudio.com
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+*************************************************************************
+
+ Translation from C++ and adaptation for use in ALSA-Driver
+ were made by Giuliano Pochini <pochini@shiny.it>
+
+*************************************************************************/
+
+static int set_sample_rate(struct echoaudio *chip, u32 rate)
+{
+        u32 clock, control_reg, old_control_reg;
+
+        if (wait_handshake(chip))
+                return -EIO;
+
+        old_control_reg = le32_to_cpu(chip->comm_page->control_register);
+        control_reg = old_control_reg & ~INDIGO_EXPRESS_CLOCK_MASK;
+
+        switch (rate) {
+        case 32000:
+                clock = INDIGO_EXPRESS_32000;
+                break;
+        case 44100:
+                clock = INDIGO_EXPRESS_44100;
+                break;
+        case 48000:
+                clock = INDIGO_EXPRESS_48000;
+                break;
+        case 64000:
+                clock = INDIGO_EXPRESS_32000|INDIGO_EXPRESS_DOUBLE_SPEED;
+                break;
+        case 88200:
+                clock = INDIGO_EXPRESS_44100|INDIGO_EXPRESS_DOUBLE_SPEED;
+                break;
+        case 96000:
+                clock = INDIGO_EXPRESS_48000|INDIGO_EXPRESS_DOUBLE_SPEED;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        control_reg |= clock;
+        if (control_reg != old_control_reg) {
+                chip->comm_page->control_register = cpu_to_le32(control_reg);
+                chip->sample_rate = rate;
+                clear_handshake(chip);
+                return send_vector(chip, DSP_VC_UPDATE_CLOCKS);
+        }
+        return 0;
+}
+
+
+
+/* This function routes the sound from a virtual channel to a real output */
+static int set_vmixer_gain(struct echoaudio *chip, u16 output, u16 pipe,
+                           int gain)
+{
+        int index;
+
+        if (snd_BUG_ON(pipe >= num_pipes_out(chip) ||
+                       output >= num_busses_out(chip)))
+                return -EINVAL;
+
+        if (wait_handshake(chip))
+                return -EIO;
+
+        chip->vmixer_gain[output][pipe] = gain;
+        index = output * num_pipes_out(chip) + pipe;
+        chip->comm_page->vmixer[index] = gain;
+
+        DE_ACT(("set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain));
+        return 0;
+}
+
+
+
+/* Tell the DSP to read and update virtual mixer levels in comm page. */
+static int update_vmixer_level(struct echoaudio *chip)
+{
+        if (wait_handshake(chip))
+                return -EIO;
+        clear_handshake(chip);
+        return send_vector(chip, DSP_VC_SET_VMIXER_GAIN);
+}
+
+
+
+static u32 detect_input_clocks(const struct echoaudio *chip)
+{
+        return ECHO_CLOCK_BIT_INTERNAL;
+}
+
+
+
+/* The IndigoIO has no ASIC. Just do nothing */
+static int load_asic(struct echoaudio *chip)
+{
+        return 0;
+}
diff --git a/sound/pci/echoaudio/indigodj_dsp.c b/sound/pci/echoaudio/indigodj_dsp.c
index 90730a5ecb42..08392916691e 100644
--- a/sound/pci/echoaudio/indigodj_dsp.c
+++ b/sound/pci/echoaudio/indigodj_dsp.c
@@ -63,18 +63,6 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         if ((err = init_line_levels(chip)) < 0)
                 return err;
 
-        /* Default routing of the virtual channels: vchannels 0-3 and
-        vchannels 4-7 are routed to real channels 0-4 */
-        set_vmixer_gain(chip, 0, 0, 0);
-        set_vmixer_gain(chip, 1, 1, 0);
-        set_vmixer_gain(chip, 2, 2, 0);
-        set_vmixer_gain(chip, 3, 3, 0);
-        set_vmixer_gain(chip, 0, 4, 0);
-        set_vmixer_gain(chip, 1, 5, 0);
-        set_vmixer_gain(chip, 2, 6, 0);
-        set_vmixer_gain(chip, 3, 7, 0);
-        err = update_vmixer_level(chip);
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
diff --git a/sound/pci/echoaudio/indigodjx.c b/sound/pci/echoaudio/indigodjx.c
new file mode 100644
index 000000000000..3482ef69f491
--- /dev/null
+++ b/sound/pci/echoaudio/indigodjx.c
@@ -0,0 +1,107 @@
+/*
+ *  ALSA driver for Echoaudio soundcards.
+ *  Copyright (C) 2009 Giuliano Pochini <pochini@shiny.it>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  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.
+ */
+
+#define INDIGO_FAMILY
+#define ECHOCARD_INDIGO_DJX
+#define ECHOCARD_NAME "Indigo DJx"
+#define ECHOCARD_HAS_SUPER_INTERLEAVE
+#define ECHOCARD_HAS_VMIXER
+#define ECHOCARD_HAS_STEREO_BIG_ENDIAN32
+
+/* Pipe indexes */
+#define PX_ANALOG_OUT   0       /* 8 */
+#define PX_DIGITAL_OUT  8       /* 0 */
+#define PX_ANALOG_IN    8       /* 0 */
+#define PX_DIGITAL_IN   8       /* 0 */
+#define PX_NUM          8
+
+/* Bus indexes */
+#define BX_ANALOG_OUT   0       /* 4 */
+#define BX_DIGITAL_OUT  4       /* 0 */
+#define BX_ANALOG_IN    4       /* 0 */
+#define BX_DIGITAL_IN   4       /* 0 */
+#define BX_NUM          4
+
+
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/slab.h>
+#include <linux/moduleparam.h>
+#include <linux/firmware.h>
+#include <linux/io.h>
+#include <sound/core.h>
+#include <sound/info.h>
+#include <sound/control.h>
+#include <sound/tlv.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/asoundef.h>
+#include <sound/initval.h>
+#include <asm/atomic.h>
+#include "echoaudio.h"
+
+MODULE_FIRMWARE("ea/loader_dsp.fw");
+MODULE_FIRMWARE("ea/indigo_djx_dsp.fw");
+
+#define FW_361_LOADER           0
+#define FW_INDIGO_DJX_DSP       1
+
+static const struct firmware card_fw[] = {
+        {0, "loader_dsp.fw"},
+        {0, "indigo_djx_dsp.fw"}
+};
+
+static struct pci_device_id snd_echo_ids[] = {
+        {0x1057, 0x3410, 0xECC0, 0x00E0, 0, 0, 0},      /* Indigo DJx*/
+        {0,}
+};
+
+static struct snd_pcm_hardware pcm_hardware_skel = {
+        .info = SNDRV_PCM_INFO_MMAP |
+                SNDRV_PCM_INFO_INTERLEAVED |
+                SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_PAUSE |
+                SNDRV_PCM_INFO_SYNC_START,
+        .formats =      SNDRV_PCM_FMTBIT_U8 |
+                        SNDRV_PCM_FMTBIT_S16_LE |
+                        SNDRV_PCM_FMTBIT_S24_3LE |
+                        SNDRV_PCM_FMTBIT_S32_LE |
+                        SNDRV_PCM_FMTBIT_S32_BE,
+        .rates =        SNDRV_PCM_RATE_32000 |
+                        SNDRV_PCM_RATE_44100 |
+                        SNDRV_PCM_RATE_48000 |
+                        SNDRV_PCM_RATE_88200 |
+                        SNDRV_PCM_RATE_96000,
+        .rate_min = 32000,
+        .rate_max = 96000,
+        .channels_min = 1,
+        .channels_max = 4,
+        .buffer_bytes_max = 262144,
+        .period_bytes_min = 32,
+        .period_bytes_max = 131072,
+        .periods_min = 2,
+        .periods_max = 220,
+};
+
+#include "indigodjx_dsp.c"
+#include "indigo_express_dsp.c"
+#include "echoaudio_dsp.c"
+#include "echoaudio.c"
diff --git a/sound/pci/echoaudio/indigodjx_dsp.c b/sound/pci/echoaudio/indigodjx_dsp.c
new file mode 100644
index 000000000000..f591fc2ed960
--- /dev/null
+++ b/sound/pci/echoaudio/indigodjx_dsp.c
@@ -0,0 +1,68 @@
+/************************************************************************
+
+This file is part of Echo Digital Audio's generic driver library.
+Copyright Echo Digital Audio Corporation (c) 1998 - 2005
+All rights reserved
+www.echoaudio.com
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+*************************************************************************
+
+ Translation from C++ and adaptation for use in ALSA-Driver
+ were made by Giuliano Pochini <pochini@shiny.it>
+
+*************************************************************************/
+
+static int update_vmixer_level(struct echoaudio *chip);
+static int set_vmixer_gain(struct echoaudio *chip, u16 output,
+                           u16 pipe, int gain);
+
+
+static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
+{
+        int err;
+
+        DE_INIT(("init_hw() - Indigo DJx\n"));
+        if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_DJX))
+                return -ENODEV;
+
+        err = init_dsp_comm_page(chip);
+        if (err < 0) {
+                DE_INIT(("init_hw - could not initialize DSP comm page\n"));
+                return err;
+        }
+
+        chip->device_id = device_id;
+        chip->subdevice_id = subdevice_id;
+        chip->bad_board = TRUE;
+        chip->dsp_code_to_load = &card_fw[FW_INDIGO_DJX_DSP];
+        /* Since this card has no ASIC, mark it as loaded so everything
+           works OK */
+        chip->asic_loaded = TRUE;
+        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL;
+
+        err = load_firmware(chip);
+        if (err < 0)
+                return err;
+        chip->bad_board = FALSE;
+
+        err = init_line_levels(chip);
+        if (err < 0)
+                return err;
+
+        DE_INIT(("init_hw done\n"));
+        return err;
+}
diff --git a/sound/pci/echoaudio/indigoio_dsp.c b/sound/pci/echoaudio/indigoio_dsp.c
index a7e09ec21079..0604c8a85223 100644
--- a/sound/pci/echoaudio/indigoio_dsp.c
+++ b/sound/pci/echoaudio/indigoio_dsp.c
@@ -63,18 +63,6 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         if ((err = init_line_levels(chip)) < 0)
                 return err;
 
-        /* Default routing of the virtual channels: all vchannels are routed
-        to the stereo output */
-        set_vmixer_gain(chip, 0, 0, 0);
-        set_vmixer_gain(chip, 1, 1, 0);
-        set_vmixer_gain(chip, 0, 2, 0);
-        set_vmixer_gain(chip, 1, 3, 0);
-        set_vmixer_gain(chip, 0, 4, 0);
-        set_vmixer_gain(chip, 1, 5, 0);
-        set_vmixer_gain(chip, 0, 6, 0);
-        set_vmixer_gain(chip, 1, 7, 0);
-        err = update_vmixer_level(chip);
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
diff --git a/sound/pci/echoaudio/indigoiox.c b/sound/pci/echoaudio/indigoiox.c
new file mode 100644
index 000000000000..aebee27a40ff
--- /dev/null
+++ b/sound/pci/echoaudio/indigoiox.c
@@ -0,0 +1,109 @@
+/*
+ *  ALSA driver for Echoaudio soundcards.
+ *  Copyright (C) 2009 Giuliano Pochini <pochini@shiny.it>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  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.
+ */
+
+#define INDIGO_FAMILY
+#define ECHOCARD_INDIGO_IOX
+#define ECHOCARD_NAME "Indigo IOx"
+#define ECHOCARD_HAS_MONITOR
+#define ECHOCARD_HAS_SUPER_INTERLEAVE
+#define ECHOCARD_HAS_VMIXER
+#define ECHOCARD_HAS_STEREO_BIG_ENDIAN32
+
+/* Pipe indexes */
+#define PX_ANALOG_OUT   0       /* 8 */
+#define PX_DIGITAL_OUT  8       /* 0 */
+#define PX_ANALOG_IN    8       /* 2 */
+#define PX_DIGITAL_IN   10      /* 0 */
+#define PX_NUM          10
+
+/* Bus indexes */
+#define BX_ANALOG_OUT   0       /* 2 */
+#define BX_DIGITAL_OUT  2       /* 0 */
+#define BX_ANALOG_IN    2       /* 2 */
+#define BX_DIGITAL_IN   4       /* 0 */
+#define BX_NUM          4
+
+
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/slab.h>
+#include <linux/moduleparam.h>
+#include <linux/firmware.h>
+#include <linux/io.h>
+#include <sound/core.h>
+#include <sound/info.h>
+#include <sound/control.h>
+#include <sound/tlv.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/asoundef.h>
+#include <sound/initval.h>
+#include <asm/atomic.h>
+#include "echoaudio.h"
+
+MODULE_FIRMWARE("ea/loader_dsp.fw");
+MODULE_FIRMWARE("ea/indigo_iox_dsp.fw");
+
+#define FW_361_LOADER           0
+#define FW_INDIGO_IOX_DSP       1
+
+static const struct firmware card_fw[] = {
+        {0, "loader_dsp.fw"},
+        {0, "indigo_iox_dsp.fw"}
+};
+
+static struct pci_device_id snd_echo_ids[] = {
+        {0x1057, 0x3410, 0xECC0, 0x00D0, 0, 0, 0},      /* Indigo IOx */
+        {0,}
+};
+
+static struct snd_pcm_hardware pcm_hardware_skel = {
+        .info = SNDRV_PCM_INFO_MMAP |
+                SNDRV_PCM_INFO_INTERLEAVED |
+                SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_PAUSE |
+                SNDRV_PCM_INFO_SYNC_START,
+        .formats =      SNDRV_PCM_FMTBIT_U8 |
+                        SNDRV_PCM_FMTBIT_S16_LE |
+                        SNDRV_PCM_FMTBIT_S24_3LE |
+                        SNDRV_PCM_FMTBIT_S32_LE |
+                        SNDRV_PCM_FMTBIT_S32_BE,
+        .rates =        SNDRV_PCM_RATE_32000 |
+                        SNDRV_PCM_RATE_44100 |
+                        SNDRV_PCM_RATE_48000 |
+                        SNDRV_PCM_RATE_88200 |
+                        SNDRV_PCM_RATE_96000,
+        .rate_min = 32000,
+        .rate_max = 96000,
+        .channels_min = 1,
+        .channels_max = 8,
+        .buffer_bytes_max = 262144,
+        .period_bytes_min = 32,
+        .period_bytes_max = 131072,
+        .periods_min = 2,
+        .periods_max = 220,
+};
+
+#include "indigoiox_dsp.c"
+#include "indigo_express_dsp.c"
+#include "echoaudio_dsp.c"
+#include "echoaudio.c"
+
diff --git a/sound/pci/echoaudio/indigoiox_dsp.c b/sound/pci/echoaudio/indigoiox_dsp.c
new file mode 100644
index 000000000000..f357521c79e6
--- /dev/null
+++ b/sound/pci/echoaudio/indigoiox_dsp.c
@@ -0,0 +1,68 @@
+/************************************************************************
+
+This file is part of Echo Digital Audio's generic driver library.
+Copyright Echo Digital Audio Corporation (c) 1998 - 2005
+All rights reserved
+www.echoaudio.com
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+*************************************************************************
+
+ Translation from C++ and adaptation for use in ALSA-Driver
+ were made by Giuliano Pochini <pochini@shiny.it>
+
+*************************************************************************/
+
+static int update_vmixer_level(struct echoaudio *chip);
+static int set_vmixer_gain(struct echoaudio *chip, u16 output,
+                           u16 pipe, int gain);
+
+
+static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
+{
+        int err;
+
+        DE_INIT(("init_hw() - Indigo IOx\n"));
+        if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_IOX))
+                return -ENODEV;
+
+        err = init_dsp_comm_page(chip);
+        if (err < 0) {
+                DE_INIT(("init_hw - could not initialize DSP comm page\n"));
+                return err;
+        }
+
+        chip->device_id = device_id;
+        chip->subdevice_id = subdevice_id;
+        chip->bad_board = TRUE;
+        chip->dsp_code_to_load = &card_fw[FW_INDIGO_IOX_DSP];
+        /* Since this card has no ASIC, mark it as loaded so everything
+           works OK */
+        chip->asic_loaded = TRUE;
+        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL;
+
+        err = load_firmware(chip);
+        if (err < 0)
+                return err;
+        chip->bad_board = FALSE;
+
+        err = init_line_levels(chip);
+        if (err < 0)
+                return err;
+
+        DE_INIT(("init_hw done\n"));
+        return err;
+}
diff --git a/sound/pci/echoaudio/layla20_dsp.c b/sound/pci/echoaudio/layla20_dsp.c
index ede75c6ca0fb..83750e9fd7b4 100644
--- a/sound/pci/echoaudio/layla20_dsp.c
+++ b/sound/pci/echoaudio/layla20_dsp.c
@@ -284,10 +284,10 @@ static int set_professional_spdif(struct echoaudio *chip, char prof)
         DE_ACT(("set_professional_spdif %d\n", prof));
         if (prof)
                 chip->comm_page->flags |=
-                        __constant_cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
+                        cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
         else
                 chip->comm_page->flags &=
-                        ~__constant_cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
+                        ~cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
         chip->professional_spdif = prof;
         return update_flags(chip);
 }
diff --git a/sound/pci/echoaudio/mia_dsp.c b/sound/pci/echoaudio/mia_dsp.c
index 227386602f9b..551405114cbc 100644
--- a/sound/pci/echoaudio/mia_dsp.c
+++ b/sound/pci/echoaudio/mia_dsp.c
@@ -69,18 +69,6 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         if ((err = init_line_levels(chip)))
                 return err;
 
-        /* Default routing of the virtual channels: vchannels 0-3 go to analog
-        outputs and vchannels 4-7 go to S/PDIF outputs */
-        set_vmixer_gain(chip, 0, 0, 0);
-        set_vmixer_gain(chip, 1, 1, 0);
-        set_vmixer_gain(chip, 0, 2, 0);
-        set_vmixer_gain(chip, 1, 3, 0);
-        set_vmixer_gain(chip, 2, 4, 0);
-        set_vmixer_gain(chip, 3, 5, 0);
-        set_vmixer_gain(chip, 2, 6, 0);
-        set_vmixer_gain(chip, 3, 7, 0);
-        err = update_vmixer_level(chip);
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
@@ -222,10 +210,10 @@ static int set_professional_spdif(struct echoaudio *chip, char prof)
         DE_ACT(("set_professional_spdif %d\n", prof));
         if (prof)
                 chip->comm_page->flags |=
-                        __constant_cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
+                        cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
         else
                 chip->comm_page->flags &=
-                        ~__constant_cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
+                        ~cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
         chip->professional_spdif = prof;
         return update_flags(chip);
 }
diff --git a/sound/pci/echoaudio/midi.c b/sound/pci/echoaudio/midi.c
index 77bf2a83d997..a953d142cb4b 100644
--- a/sound/pci/echoaudio/midi.c
+++ b/sound/pci/echoaudio/midi.c
@@ -44,10 +44,10 @@ static int enable_midi_input(struct echoaudio *chip, char enable)
         if (enable) {
                 chip->mtc_state = MIDI_IN_STATE_NORMAL;
                 chip->comm_page->flags |=
-                        __constant_cpu_to_le32(DSP_FLAG_MIDI_INPUT);
+                        cpu_to_le32(DSP_FLAG_MIDI_INPUT);
         } else
                 chip->comm_page->flags &=
-                        ~__constant_cpu_to_le32(DSP_FLAG_MIDI_INPUT);
+                        ~cpu_to_le32(DSP_FLAG_MIDI_INPUT);
 
         clear_handshake(chip);
         return send_vector(chip, DSP_VC_UPDATE_FLAGS);
diff --git a/sound/pci/emu10k1/emu10k1_callback.c b/sound/pci/emu10k1/emu10k1_callback.c
index 0e649dcdbf64..7ef949d99a50 100644
--- a/sound/pci/emu10k1/emu10k1_callback.c
+++ b/sound/pci/emu10k1/emu10k1_callback.c
@@ -103,7 +103,10 @@ snd_emu10k1_synth_get_voice(struct snd_emu10k1 *hw)
                         int ch;
                         vp = &emu->voices[best[i].voice];
                         if ((ch = vp->ch) < 0) {
-                                //printk("synth_get_voice: ch < 0 (%d) ??", i);
+                                /*
+                                printk(KERN_WARNING
+                                       "synth_get_voice: ch < 0 (%d) ??", i);
+                                */
                                 continue;
                         }
                         vp->emu->num_voices--;
@@ -335,7 +338,7 @@ start_voice(struct snd_emux_voice *vp)
                 return -EINVAL;
         emem->map_locked++;
         if (snd_emu10k1_memblk_map(hw, emem) < 0) {
-                // printk("emu: cannot map!\n");
+                /* printk(KERN_ERR "emu: cannot map!\n"); */
                 return -ENOMEM;
         }
         mapped_offset = snd_emu10k1_memblk_offset(emem) >> 1;
diff --git a/sound/pci/emu10k1/emu10k1_main.c b/sound/pci/emu10k1/emu10k1_main.c
index 7958006a1d66..f18bd6207c50 100644
--- a/sound/pci/emu10k1/emu10k1_main.c
+++ b/sound/pci/emu10k1/emu10k1_main.c
@@ -711,8 +711,7 @@ static int snd_emu1010_load_firmware(struct snd_emu10k1 *emu, const char *filena
 static int emu1010_firmware_thread(void *data)
 {
         struct snd_emu10k1 *emu = data;
-        int tmp, tmp2;
-        int reg;
+        u32 tmp, tmp2, reg;
         int err;
 
         for (;;) {
@@ -758,7 +757,8 @@ static int emu1010_firmware_thread(void *data)
                         snd_printk(KERN_INFO "emu1010: Audio Dock Firmware loaded\n");
                         snd_emu1010_fpga_read(emu, EMU_DOCK_MAJOR_REV, &tmp);
                         snd_emu1010_fpga_read(emu, EMU_DOCK_MINOR_REV, &tmp2);
-                        snd_printk("Audio Dock ver:%d.%d\n", tmp, tmp2);
+                        snd_printk(KERN_INFO "Audio Dock ver: %u.%u\n",
+                                   tmp, tmp2);
                         /* Sync clocking between 1010 and Dock */
                         /* Allow DLL to settle */
                         msleep(10);
@@ -804,8 +804,7 @@ static int emu1010_firmware_thread(void *data)
 static int snd_emu10k1_emu1010_init(struct snd_emu10k1 *emu)
 {
         unsigned int i;
-        int tmp, tmp2;
-        int reg;
+        u32 tmp, tmp2, reg;
         int err;
         const char *filename = NULL;
 
@@ -887,7 +886,7 @@ static int snd_emu10k1_emu1010_init(struct snd_emu10k1 *emu)
         snd_printk(KERN_INFO "emu1010: Hana Firmware loaded\n");
         snd_emu1010_fpga_read(emu, EMU_HANA_MAJOR_REV, &tmp);
         snd_emu1010_fpga_read(emu, EMU_HANA_MINOR_REV, &tmp2);
-        snd_printk("emu1010: Hana version: %d.%d\n", tmp, tmp2);
+        snd_printk(KERN_INFO "emu1010: Hana version: %u.%u\n", tmp, tmp2);
         /* Enable 48Volt power to Audio Dock */
         snd_emu1010_fpga_write(emu, EMU_HANA_DOCK_PWR, EMU_HANA_DOCK_PWR_ON);
 
@@ -1528,6 +1527,7 @@ static struct snd_emu_chip_details emu_chip_details[] = {
          .ca0151_chip = 1,
          .spk71 = 1,
          .spdif_bug = 1,
+         .invert_shared_spdif = 1,      /* digital/analog switch swapped */
          .ac97_chip = 1} ,
         {.vendor = 0x1102, .device = 0x0004, .subsystem = 0x10021102,
          .driver = "Audigy2", .name = "SB Audigy 2 Platinum [SB0240P]",
diff --git a/sound/pci/emu10k1/emu10k1x.c b/sound/pci/emu10k1/emu10k1x.c
index 31542adc6b7e..1970f0e70f37 100644
--- a/sound/pci/emu10k1/emu10k1x.c
+++ b/sound/pci/emu10k1/emu10k1x.c
@@ -897,8 +897,8 @@ static int __devinit snd_emu10k1x_create(struct snd_card *card,
 
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
-        if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
                 snd_printk(KERN_ERR "error to set 28bit mask DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/emu10k1/emufx.c b/sound/pci/emu10k1/emufx.c
index 7dba08f0ab8e..4b302d86f5f2 100644
--- a/sound/pci/emu10k1/emufx.c
+++ b/sound/pci/emu10k1/emufx.c
@@ -1519,7 +1519,7 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input))
         /* A_PUT_STEREO_OUTPUT(A_EXTOUT_FRONT_L, A_EXTOUT_FRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); */
         if (emu->card_capabilities->emu_model) {
                 /* EMU1010 Outputs from PCM Front, Rear, Center, LFE, Side */
-                snd_printk("EMU outputs on\n");
+                snd_printk(KERN_INFO "EMU outputs on\n");
                 for (z = 0; z < 8; z++) {
                         if (emu->card_capabilities->ca0108_chip) {
                                 A_OP(icode, &ptr, iACC3, A3_EMU32OUT(z), A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_C_00000000, A_C_00000000);
@@ -1567,7 +1567,7 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input))
 
         if (emu->card_capabilities->emu_model) {
                 if (emu->card_capabilities->ca0108_chip) {
-                        snd_printk("EMU2 inputs on\n");
+                        snd_printk(KERN_INFO "EMU2 inputs on\n");
                         for (z = 0; z < 0x10; z++) {
                                 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, 
                                                                         bit_shifter16,
@@ -1575,10 +1575,13 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input))
                                                                         A_FXBUS2(z*2) );
                         }
                 } else {
-                        snd_printk("EMU inputs on\n");
+                        snd_printk(KERN_INFO "EMU inputs on\n");
                         /* Capture 16 (originally 8) channels of S32_LE sound */
 
-                        /* printk("emufx.c: gpr=0x%x, tmp=0x%x\n",gpr, tmp); */
+                        /*
+                        printk(KERN_DEBUG "emufx.c: gpr=0x%x, tmp=0x%x\n",
+                               gpr, tmp);
+                        */
                         /* For the EMU1010: How to get 32bit values from the DSP. High 16bits into L, low 16bits into R. */
                         /* A_P16VIN(0) is delayed by one sample,
                          * so all other A_P16VIN channels will need to also be delayed
@@ -2490,24 +2493,17 @@ static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, un
         case SNDRV_EMU10K1_IOCTL_CODE_POKE:
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
-                icode = kmalloc(sizeof(*icode), GFP_KERNEL);
-                if (icode == NULL)
-                        return -ENOMEM;
-                if (copy_from_user(icode, argp, sizeof(*icode))) {
-                        kfree(icode);
-                        return -EFAULT;
-                }
+
+                icode = memdup_user(argp, sizeof(*icode));
+                if (IS_ERR(icode))
+                        return PTR_ERR(icode);
                 res = snd_emu10k1_icode_poke(emu, icode);
                 kfree(icode);
                 return res;
         case SNDRV_EMU10K1_IOCTL_CODE_PEEK:
-                icode = kmalloc(sizeof(*icode), GFP_KERNEL);
-                if (icode == NULL)
-                        return -ENOMEM;
-                if (copy_from_user(icode, argp, sizeof(*icode))) {
-                        kfree(icode);
-                        return -EFAULT;
-                }
+                icode = memdup_user(argp, sizeof(*icode));
+                if (IS_ERR(icode))
+                        return PTR_ERR(icode);
                 res = snd_emu10k1_icode_peek(emu, icode);
                 if (res == 0 && copy_to_user(argp, icode, sizeof(*icode))) {
                         kfree(icode);
@@ -2516,24 +2512,16 @@ static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, un
                 kfree(icode);
                 return res;
         case SNDRV_EMU10K1_IOCTL_PCM_POKE:
-                ipcm = kmalloc(sizeof(*ipcm), GFP_KERNEL);
-                if (ipcm == NULL)
-                        return -ENOMEM;
-                if (copy_from_user(ipcm, argp, sizeof(*ipcm))) {
-                        kfree(ipcm);
-                        return -EFAULT;
-                }
+                ipcm = memdup_user(argp, sizeof(*ipcm));
+                if (IS_ERR(ipcm))
+                        return PTR_ERR(ipcm);
                 res = snd_emu10k1_ipcm_poke(emu, ipcm);
                 kfree(ipcm);
                 return res;
         case SNDRV_EMU10K1_IOCTL_PCM_PEEK:
-                ipcm = kzalloc(sizeof(*ipcm), GFP_KERNEL);
-                if (ipcm == NULL)
-                        return -ENOMEM;
-                if (copy_from_user(ipcm, argp, sizeof(*ipcm))) {
-                        kfree(ipcm);
-                        return -EFAULT;
-                }
+                ipcm = memdup_user(argp, sizeof(*ipcm));
+                if (IS_ERR(ipcm))
+                        return PTR_ERR(ipcm);
                 res = snd_emu10k1_ipcm_peek(emu, ipcm);
                 if (res == 0 && copy_to_user(argp, ipcm, sizeof(*ipcm))) {
                         kfree(ipcm);
diff --git a/sound/pci/emu10k1/emupcm.c b/sound/pci/emu10k1/emupcm.c
index cf9276ddad42..78f62fd404c2 100644
--- a/sound/pci/emu10k1/emupcm.c
+++ b/sound/pci/emu10k1/emupcm.c
@@ -44,7 +44,7 @@ static void snd_emu10k1_pcm_interrupt(struct snd_emu10k1 *emu,
         if (epcm->substream == NULL)
                 return;
 #if 0
-        printk("IRQ: position = 0x%x, period = 0x%x, size = 0x%x\n",
+        printk(KERN_DEBUG "IRQ: position = 0x%x, period = 0x%x, size = 0x%x\n",
                         epcm->substream->runtime->hw->pointer(emu, epcm->substream),
                         snd_pcm_lib_period_bytes(epcm->substream),
                         snd_pcm_lib_buffer_bytes(epcm->substream));
@@ -146,7 +146,11 @@ static int snd_emu10k1_pcm_channel_alloc(struct snd_emu10k1_pcm * epcm, int voic
                                               1,
                                               &epcm->extra);
                 if (err < 0) {
-                        /* printk("pcm_channel_alloc: failed extra: voices=%d, frame=%d\n", voices, frame); */
+                        /*
+                        printk(KERN_DEBUG "pcm_channel_alloc: "
+                               "failed extra: voices=%d, frame=%d\n",
+                               voices, frame);
+                        */
                         for (i = 0; i < voices; i++) {
                                 snd_emu10k1_voice_free(epcm->emu, epcm->voices[i]);
                                 epcm->voices[i] = NULL;
@@ -737,7 +741,10 @@ static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream,
         struct snd_emu10k1_pcm_mixer *mix;
         int result = 0;
 
-        /* printk("trigger - emu10k1 = 0x%x, cmd = %i, pointer = %i\n", (int)emu, cmd, substream->ops->pointer(substream)); */
+        /*
+        printk(KERN_DEBUG "trigger - emu10k1 = 0x%x, cmd = %i, pointer = %i\n",
+               (int)emu, cmd, substream->ops->pointer(substream))
+        */
         spin_lock(&emu->reg_lock);
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
@@ -786,7 +793,10 @@ static int snd_emu10k1_capture_trigger(struct snd_pcm_substream *substream,
                 /* hmm this should cause full and half full interrupt to be raised? */
                 outl(epcm->capture_ipr, emu->port + IPR);
                 snd_emu10k1_intr_enable(emu, epcm->capture_inte);
-                /* printk("adccr = 0x%x, adcbs = 0x%x\n", epcm->adccr, epcm->adcbs); */
+                /*
+                printk(KERN_DEBUG "adccr = 0x%x, adcbs = 0x%x\n",
+                       epcm->adccr, epcm->adcbs);
+                */
                 switch (epcm->type) {
                 case CAPTURE_AC97ADC:
                         snd_emu10k1_ptr_write(emu, ADCCR, 0, epcm->capture_cr_val);
@@ -857,7 +867,11 @@ static snd_pcm_uframes_t snd_emu10k1_playback_pointer(struct snd_pcm_substream *
                         ptr -= runtime->buffer_size;
         }
 #endif
-        /* printk("ptr = 0x%x, buffer_size = 0x%x, period_size = 0x%x\n", ptr, runtime->buffer_size, runtime->period_size); */
+        /*
+        printk(KERN_DEBUG
+               "ptr = 0x%x, buffer_size = 0x%x, period_size = 0x%x\n",
+               ptr, runtime->buffer_size, runtime->period_size);
+        */
         return ptr;
 }
 
@@ -1546,7 +1560,11 @@ static void snd_emu10k1_fx8010_playback_tram_poke1(unsigned short *dst_left,
                                                    unsigned int count,
                                                    unsigned int tram_shift)
 {
-        /* printk("tram_poke1: dst_left = 0x%p, dst_right = 0x%p, src = 0x%p, count = 0x%x\n", dst_left, dst_right, src, count); */
+        /*
+        printk(KERN_DEBUG "tram_poke1: dst_left = 0x%p, dst_right = 0x%p, "
+               "src = 0x%p, count = 0x%x\n",
+               dst_left, dst_right, src, count);
+        */
         if ((tram_shift & 1) == 0) {
                 while (count--) {
                         *dst_left-- = *src++;
@@ -1623,7 +1641,12 @@ static int snd_emu10k1_fx8010_playback_prepare(struct snd_pcm_substream *substre
         struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number];
         unsigned int i;
         
-        /* printk("prepare: etram_pages = 0x%p, dma_area = 0x%x, buffer_size = 0x%x (0x%x)\n", emu->fx8010.etram_pages, runtime->dma_area, runtime->buffer_size, runtime->buffer_size << 2); */
+        /*
+        printk(KERN_DEBUG "prepare: etram_pages = 0x%p, dma_area = 0x%x, "
+               "buffer_size = 0x%x (0x%x)\n",
+               emu->fx8010.etram_pages, runtime->dma_area,
+               runtime->buffer_size, runtime->buffer_size << 2);
+        */
         memset(&pcm->pcm_rec, 0, sizeof(pcm->pcm_rec));
         pcm->pcm_rec.hw_buffer_size = pcm->buffer_size * 2; /* byte size */
         pcm->pcm_rec.sw_buffer_size = snd_pcm_lib_buffer_bytes(substream);
diff --git a/sound/pci/emu10k1/io.c b/sound/pci/emu10k1/io.c
index b5a802bdeb7c..c1a5aa15af8f 100644
--- a/sound/pci/emu10k1/io.c
+++ b/sound/pci/emu10k1/io.c
@@ -226,7 +226,9 @@ int snd_emu10k1_i2c_write(struct snd_emu10k1 *emu,
                                 break;
 
                         if (timeout > 1000) {
-                                snd_printk("emu10k1:I2C:timeout status=0x%x\n", status);
+                                snd_printk(KERN_WARNING
+                                           "emu10k1:I2C:timeout status=0x%x\n",
+                                           status);
                                 break;
                         }
                 }
@@ -488,7 +490,7 @@ void snd_emu10k1_wait(struct snd_emu10k1 *emu, unsigned int wait)
                         if (newtime != curtime)
                                 break;
                 }
-                if (count >= 16384)
+                if (count > 16384)
                         break;
                 curtime = newtime;
         }
diff --git a/sound/pci/emu10k1/p16v.c b/sound/pci/emu10k1/p16v.c
index 749a21b6bd06..e617acaf10e3 100644
--- a/sound/pci/emu10k1/p16v.c
+++ b/sound/pci/emu10k1/p16v.c
@@ -168,7 +168,7 @@ static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime *runtime)
         struct snd_emu10k1_pcm *epcm = runtime->private_data;
   
         if (epcm) {
-                //snd_printk("epcm free: %p\n", epcm);
+                /* snd_printk(KERN_DEBUG "epcm free: %p\n", epcm); */
                 kfree(epcm);
         }
 }
@@ -183,14 +183,16 @@ static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream *substrea
         int err;
 
         epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
-        //snd_printk("epcm kcalloc: %p\n", epcm);
+        /* snd_printk(KERN_DEBUG "epcm kcalloc: %p\n", epcm); */
 
         if (epcm == NULL)
                 return -ENOMEM;
         epcm->emu = emu;
         epcm->substream = substream;
-        //snd_printk("epcm device=%d, channel_id=%d\n", substream->pcm->device, channel_id);
-  
+        /*
+        snd_printk(KERN_DEBUG "epcm device=%d, channel_id=%d\n",
+                   substream->pcm->device, channel_id);
+        */
         runtime->private_data = epcm;
         runtime->private_free = snd_p16v_pcm_free_substream;
   
@@ -200,10 +202,15 @@ static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream *substrea
         channel->number = channel_id;
 
         channel->use=1;
-        //snd_printk("p16v: open channel_id=%d, channel=%p, use=0x%x\n", channel_id, channel, channel->use);
-        //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
-        //channel->interrupt = snd_p16v_pcm_channel_interrupt;
-        channel->epcm=epcm;
+#if 0 /* debug */
+        snd_printk(KERN_DEBUG
+                   "p16v: open channel_id=%d, channel=%p, use=0x%x\n",
+                   channel_id, channel, channel->use);
+        printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
+               channel_id, chip, channel);
+#endif /* debug */
+        /* channel->interrupt = snd_p16v_pcm_channel_interrupt; */
+        channel->epcm = epcm;
         if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
                 return err;
 
@@ -224,14 +231,16 @@ static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream *substream
         int err;
 
         epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
-        //snd_printk("epcm kcalloc: %p\n", epcm);
+        /* snd_printk(KERN_DEBUG "epcm kcalloc: %p\n", epcm); */
 
         if (epcm == NULL)
                 return -ENOMEM;
         epcm->emu = emu;
         epcm->substream = substream;
-        //snd_printk("epcm device=%d, channel_id=%d\n", substream->pcm->device, channel_id);
-
+        /*
+        snd_printk(KERN_DEBUG "epcm device=%d, channel_id=%d\n",
+                   substream->pcm->device, channel_id);
+        */
         runtime->private_data = epcm;
         runtime->private_free = snd_p16v_pcm_free_substream;
   
@@ -241,10 +250,15 @@ static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream *substream
         channel->number = channel_id;
 
         channel->use=1;
-        //snd_printk("p16v: open channel_id=%d, channel=%p, use=0x%x\n", channel_id, channel, channel->use);
-        //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
-        //channel->interrupt = snd_p16v_pcm_channel_interrupt;
-        channel->epcm=epcm;
+#if 0 /* debug */
+        snd_printk(KERN_DEBUG
+                   "p16v: open channel_id=%d, channel=%p, use=0x%x\n",
+                   channel_id, channel, channel->use);
+        printk(KERN_DEBUG "open:channel_id=%d, chip=%p, channel=%p\n",
+               channel_id, chip, channel);
+#endif /* debug */
+        /* channel->interrupt = snd_p16v_pcm_channel_interrupt; */
+        channel->epcm = epcm;
         if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
                 return err;
 
@@ -334,9 +348,19 @@ static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream *substream)
         int i;
         u32 tmp;
         
-        //snd_printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, periods=%u, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, runtime->periods, frames_to_bytes(runtime, 1));
-        //snd_printk("dma_addr=%x, dma_area=%p, table_base=%p\n",runtime->dma_addr, runtime->dma_area, table_base);
-        //snd_printk("dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",emu->p16v_buffer.addr, emu->p16v_buffer.area, emu->p16v_buffer.bytes);
+#if 0 /* debug */
+        snd_printk(KERN_DEBUG "prepare:channel_number=%d, rate=%d, "
+                   "format=0x%x, channels=%d, buffer_size=%ld, "
+                   "period_size=%ld, periods=%u, frames_to_bytes=%d\n",
+                   channel, runtime->rate, runtime->format, runtime->channels,
+                   runtime->buffer_size, runtime->period_size,
+                   runtime->periods, frames_to_bytes(runtime, 1));
+        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
+                   runtime->dma_addr, runtime->dma_area, table_base);
+        snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
+                   emu->p16v_buffer.addr, emu->p16v_buffer.area,
+                   emu->p16v_buffer.bytes);
+#endif /* debug */
         tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, channel);
         switch (runtime->rate) {
         case 44100:
@@ -379,7 +403,15 @@ static int snd_p16v_pcm_prepare_capture(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         int channel = substream->pcm->device - emu->p16v_device_offset;
         u32 tmp;
-        //printk("prepare capture:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size,  frames_to_bytes(runtime, 1));
+
+        /*
+        printk(KERN_DEBUG "prepare capture:channel_number=%d, rate=%d, "
+               "format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, "
+               "frames_to_bytes=%d\n",
+               channel, runtime->rate, runtime->format, runtime->channels,
+               runtime->buffer_size, runtime->period_size,
+               frames_to_bytes(runtime, 1));
+        */
         tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, channel);
         switch (runtime->rate) {
         case 44100:
@@ -459,13 +491,13 @@ static int snd_p16v_pcm_trigger_playback(struct snd_pcm_substream *substream,
                 runtime = s->runtime;
                 epcm = runtime->private_data;
                 channel = substream->pcm->device-emu->p16v_device_offset;
-                //snd_printk("p16v channel=%d\n",channel);
+                /* snd_printk(KERN_DEBUG "p16v channel=%d\n", channel); */
                 epcm->running = running;
                 basic |= (0x1<<channel);
                 inte |= (INTE2_PLAYBACK_CH_0_LOOP<<channel);
                 snd_pcm_trigger_done(s, substream);
         }
-        //snd_printk("basic=0x%x, inte=0x%x\n",basic, inte);
+        /* snd_printk(KERN_DEBUG "basic=0x%x, inte=0x%x\n", basic, inte); */
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
@@ -558,8 +590,13 @@ snd_p16v_pcm_pointer_capture(struct snd_pcm_substream *substream)
                 ptr -= runtime->buffer_size;
                 printk(KERN_WARNING "buffer capture limited!\n");
         }
-        //printk("ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", ptr1, ptr2, ptr, (int)runtime->buffer_size, (int)runtime->period_size, (int)runtime->frame_bits, (int)runtime->rate);
-
+        /*
+        printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
+               "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
+               ptr1, ptr2, ptr, (int)runtime->buffer_size,
+               (int)runtime->period_size, (int)runtime->frame_bits,
+               (int)runtime->rate);
+        */
         return ptr;
 }
 
@@ -592,7 +629,10 @@ int snd_p16v_free(struct snd_emu10k1 *chip)
         // release the data
         if (chip->p16v_buffer.area) {
                 snd_dma_free_pages(&chip->p16v_buffer);
-                //snd_printk("period lables free: %p\n", &chip->p16v_buffer);
+                /*
+                snd_printk(KERN_DEBUG "period lables free: %p\n",
+                           &chip->p16v_buffer);
+                */
         }
         return 0;
 }
@@ -604,7 +644,7 @@ int __devinit snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm *
         int err;
         int capture=1;
   
-        //snd_printk("snd_p16v_pcm called. device=%d\n", device);
+        /* snd_printk("KERN_DEBUG snd_p16v_pcm called. device=%d\n", device); */
         emu->p16v_device_offset = device;
         if (rpcm)
                 *rpcm = NULL;
@@ -631,7 +671,10 @@ int __devinit snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm *
                                                          snd_dma_pci_data(emu->pci), 
                                                          ((65536 - 64) * 8), ((65536 - 64) * 8))) < 0) 
                         return err;
-                //snd_printk("preallocate playback substream: err=%d\n", err);
+                /*
+                snd_printk(KERN_DEBUG
+                           "preallocate playback substream: err=%d\n", err);
+                */
         }
 
         for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; 
@@ -642,7 +685,10 @@ int __devinit snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm *
                                                    snd_dma_pci_data(emu->pci), 
                                                    65536 - 64, 65536 - 64)) < 0)
                         return err;
-                //snd_printk("preallocate capture substream: err=%d\n", err);
+                /*
+                snd_printk(KERN_DEBUG
+                           "preallocate capture substream: err=%d\n", err);
+                */
         }
   
         if (rpcm)
diff --git a/sound/pci/emu10k1/voice.c b/sound/pci/emu10k1/voice.c
index d7300a1aa262..20b8da250bd0 100644
--- a/sound/pci/emu10k1/voice.c
+++ b/sound/pci/emu10k1/voice.c
@@ -53,7 +53,10 @@ static int voice_alloc(struct snd_emu10k1 *emu, int type, int number,
         *rvoice = NULL;
         first_voice = last_voice = 0;
         for (i = emu->next_free_voice, j = 0; j < NUM_G ; i += number, j += number) {
-                // printk("i %d j %d next free %d!\n", i, j, emu->next_free_voice);
+                /*
+                printk(KERN_DEBUG "i %d j %d next free %d!\n",
+                       i, j, emu->next_free_voice);
+                */
                 i %= NUM_G;
 
                 /* stereo voices must be even/odd */
@@ -71,7 +74,7 @@ static int voice_alloc(struct snd_emu10k1 *emu, int type, int number,
                         }
                 }
                 if (!skip) {
-                        // printk("allocated voice %d\n", i);
+                        /* printk(KERN_DEBUG "allocated voice %d\n", i); */
                         first_voice = i;
                         last_voice = (i + number) % NUM_G;
                         emu->next_free_voice = last_voice;
@@ -84,7 +87,10 @@ static int voice_alloc(struct snd_emu10k1 *emu, int type, int number,
         
         for (i = 0; i < number; i++) {
                 voice = &emu->voices[(first_voice + i) % NUM_G];
-                // printk("voice alloc - %i, %i of %i\n", voice->number, idx-first_voice+1, number);
+                /*
+                printk(kERN_DEBUG "voice alloc - %i, %i of %i\n",
+                       voice->number, idx-first_voice+1, number);
+                */
                 voice->use = 1;
                 switch (type) {
                 case EMU10K1_PCM:
diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c
index e00614cbceff..18f4d1e98c46 100644
--- a/sound/pci/ens1370.c
+++ b/sound/pci/ens1370.c
@@ -584,7 +584,8 @@ static void snd_es1370_codec_write(struct snd_ak4531 *ak4531,
         unsigned long end_time = jiffies + HZ / 10;
 
 #if 0
-        printk("CODEC WRITE: reg = 0x%x, val = 0x%x (0x%x), creg = 0x%x\n",
+        printk(KERN_DEBUG
+               "CODEC WRITE: reg = 0x%x, val = 0x%x (0x%x), creg = 0x%x\n",
                reg, val, ES_1370_CODEC_WRITE(reg, val), ES_REG(ensoniq, 1370_CODEC));
 #endif
         do {
diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c
index 34a78afc26d0..fbd2ac09aa34 100644
--- a/sound/pci/es1938.c
+++ b/sound/pci/es1938.c
@@ -1608,8 +1608,8 @@ static int __devinit snd_es1938_create(struct snd_card *card,
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
         /* check, if we can restrict PCI DMA transfers to 24 bits */
-        if (pci_set_dma_mask(pci, DMA_24BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_24BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
@@ -1673,18 +1673,22 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id)
 
         status = inb(SLIO_REG(chip, IRQCONTROL));
 #if 0
-        printk("Es1938debug - interrupt status: =0x%x\n", status);
+        printk(KERN_DEBUG "Es1938debug - interrupt status: =0x%x\n", status);
 #endif
         
         /* AUDIO 1 */
         if (status & 0x10) {
 #if 0
-                printk("Es1938debug - AUDIO channel 1 interrupt\n");
-                printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
+                printk(KERN_DEBUG
+                       "Es1938debug - AUDIO channel 1 interrupt\n");
+                printk(KERN_DEBUG
+                       "Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
                        inw(SLDM_REG(chip, DMACOUNT)));
-                printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
+                printk(KERN_DEBUG
+                       "Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
                        inl(SLDM_REG(chip, DMAADDR)));
-                printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
+                printk(KERN_DEBUG
+                       "Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
                        inl(SLDM_REG(chip, DMASTATUS)));
 #endif
                 /* clear irq */
@@ -1699,10 +1703,13 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id)
         /* AUDIO 2 */
         if (status & 0x20) {
 #if 0
-                printk("Es1938debug - AUDIO channel 2 interrupt\n");
-                printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
+                printk(KERN_DEBUG
+                       "Es1938debug - AUDIO channel 2 interrupt\n");
+                printk(KERN_DEBUG
+                       "Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
                        inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
-                printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
+                printk(KERN_DEBUG
+                       "Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
                        inl(SLIO_REG(chip, AUDIO2DMAADDR)));
 
 #endif
diff --git a/sound/pci/es1968.c b/sound/pci/es1968.c
index dc97e8116141..a11f453a6b6d 100644
--- a/sound/pci/es1968.c
+++ b/sound/pci/es1968.c
@@ -2539,8 +2539,8 @@ static int __devinit snd_es1968_create(struct snd_card *card,
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
         /* check, if we can restrict PCI DMA transfers to 28 bits */
-        if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/hda/hda_beep.c b/sound/pci/hda/hda_beep.c
index 960fd7970384..4de5bacd3929 100644
--- a/sound/pci/hda/hda_beep.c
+++ b/sound/pci/hda/hda_beep.c
@@ -138,6 +138,7 @@ void snd_hda_detach_beep_device(struct hda_codec *codec)
 
                 input_unregister_device(beep->dev);
                 kfree(beep);
+                codec->beep = NULL;
         }
 }
 EXPORT_SYMBOL_HDA(snd_hda_detach_beep_device);
diff --git a/sound/pci/hda/hda_beep.h b/sound/pci/hda/hda_beep.h
index b9679f081cae..51bf6a5daf39 100644
--- a/sound/pci/hda/hda_beep.h
+++ b/sound/pci/hda/hda_beep.h
@@ -39,7 +39,7 @@ struct hda_beep {
 int snd_hda_attach_beep_device(struct hda_codec *codec, int nid);
 void snd_hda_detach_beep_device(struct hda_codec *codec);
 #else
-#define snd_hda_attach_beep_device(...)
+#define snd_hda_attach_beep_device(...)         0
 #define snd_hda_detach_beep_device(...)
 #endif
 #endif
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 3c596da2b9b5..8820faf6c9d8 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -487,7 +487,6 @@ int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
 {
         struct hda_bus *bus;
         int err;
-        char qname[8];
         static struct snd_device_ops dev_ops = {
                 .dev_register = snd_hda_bus_dev_register,
                 .dev_free = snd_hda_bus_dev_free,
@@ -517,10 +516,12 @@ int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
         mutex_init(&bus->cmd_mutex);
         INIT_LIST_HEAD(&bus->codec_list);
 
-        snprintf(qname, sizeof(qname), "hda%d", card->number);
-        bus->workq = create_workqueue(qname);
+        snprintf(bus->workq_name, sizeof(bus->workq_name),
+                 "hd-audio%d", card->number);
+        bus->workq = create_singlethread_workqueue(bus->workq_name);
         if (!bus->workq) {
-                snd_printk(KERN_ERR "cannot create workqueue %s\n", qname);
+                snd_printk(KERN_ERR "cannot create workqueue %s\n",
+                           bus->workq_name);
                 kfree(bus);
                 return -ENOMEM;
         }
@@ -641,19 +642,21 @@ static int get_codec_name(struct hda_codec *codec)
  */
 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
 {
-        int i, total_nodes;
+        int i, total_nodes, function_id;
         hda_nid_t nid;
 
         total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
         for (i = 0; i < total_nodes; i++, nid++) {
-                unsigned int func;
-                func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
-                switch (func & 0xff) {
+                function_id = snd_hda_param_read(codec, nid,
+                                                AC_PAR_FUNCTION_TYPE) & 0xff;
+                switch (function_id) {
                 case AC_GRP_AUDIO_FUNCTION:
                         codec->afg = nid;
+                        codec->function_id = function_id;
                         break;
                 case AC_GRP_MODEM_FUNCTION:
                         codec->mfg = nid;
+                        codec->function_id = function_id;
                         break;
                 default:
                         break;
@@ -681,11 +684,140 @@ static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
         return 0;
 }
 
+/* read all pin default configurations and save codec->init_pins */
+static int read_pin_defaults(struct hda_codec *codec)
+{
+        int i;
+        hda_nid_t nid = codec->start_nid;
+
+        for (i = 0; i < codec->num_nodes; i++, nid++) {
+                struct hda_pincfg *pin;
+                unsigned int wcaps = get_wcaps(codec, nid);
+                unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
+                                AC_WCAP_TYPE_SHIFT;
+                if (wid_type != AC_WID_PIN)
+                        continue;
+                pin = snd_array_new(&codec->init_pins);
+                if (!pin)
+                        return -ENOMEM;
+                pin->nid = nid;
+                pin->cfg = snd_hda_codec_read(codec, nid, 0,
+                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
+        }
+        return 0;
+}
+
+/* look up the given pin config list and return the item matching with NID */
+static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
+                                         struct snd_array *array,
+                                         hda_nid_t nid)
+{
+        int i;
+        for (i = 0; i < array->used; i++) {
+                struct hda_pincfg *pin = snd_array_elem(array, i);
+                if (pin->nid == nid)
+                        return pin;
+        }
+        return NULL;
+}
+
+/* write a config value for the given NID */
+static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
+                       unsigned int cfg)
+{
+        int i;
+        for (i = 0; i < 4; i++) {
+                snd_hda_codec_write(codec, nid, 0,
+                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
+                                    cfg & 0xff);
+                cfg >>= 8;
+        }
+}
+
+/* set the current pin config value for the given NID.
+ * the value is cached, and read via snd_hda_codec_get_pincfg()
+ */
+int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
+                       hda_nid_t nid, unsigned int cfg)
+{
+        struct hda_pincfg *pin;
+        unsigned int oldcfg;
+
+        oldcfg = snd_hda_codec_get_pincfg(codec, nid);
+        pin = look_up_pincfg(codec, list, nid);
+        if (!pin) {
+                pin = snd_array_new(list);
+                if (!pin)
+                        return -ENOMEM;
+                pin->nid = nid;
+        }
+        pin->cfg = cfg;
+
+        /* change only when needed; e.g. if the pincfg is already present
+         * in user_pins[], don't write it
+         */
+        cfg = snd_hda_codec_get_pincfg(codec, nid);
+        if (oldcfg != cfg)
+                set_pincfg(codec, nid, cfg);
+        return 0;
+}
+
+int snd_hda_codec_set_pincfg(struct hda_codec *codec,
+                             hda_nid_t nid, unsigned int cfg)
+{
+        return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
+}
+EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
+
+/* get the current pin config value of the given pin NID */
+unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct hda_pincfg *pin;
+
+#ifdef CONFIG_SND_HDA_HWDEP
+        pin = look_up_pincfg(codec, &codec->user_pins, nid);
+        if (pin)
+                return pin->cfg;
+#endif
+        pin = look_up_pincfg(codec, &codec->driver_pins, nid);
+        if (pin)
+                return pin->cfg;
+        pin = look_up_pincfg(codec, &codec->init_pins, nid);
+        if (pin)
+                return pin->cfg;
+        return 0;
+}
+EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
+
+/* restore all current pin configs */
+static void restore_pincfgs(struct hda_codec *codec)
+{
+        int i;
+        for (i = 0; i < codec->init_pins.used; i++) {
+                struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
+                set_pincfg(codec, pin->nid,
+                           snd_hda_codec_get_pincfg(codec, pin->nid));
+        }
+}
 
 static void init_hda_cache(struct hda_cache_rec *cache,
                            unsigned int record_size);
 static void free_hda_cache(struct hda_cache_rec *cache);
 
+/* restore the initial pin cfgs and release all pincfg lists */
+static void restore_init_pincfgs(struct hda_codec *codec)
+{
+        /* first free driver_pins and user_pins, then call restore_pincfg
+         * so that only the values in init_pins are restored
+         */
+        snd_array_free(&codec->driver_pins);
+#ifdef CONFIG_SND_HDA_HWDEP
+        snd_array_free(&codec->user_pins);
+#endif
+        restore_pincfgs(codec);
+        snd_array_free(&codec->init_pins);
+}
+
 /*
  * codec destructor
  */
@@ -693,6 +825,7 @@ static void snd_hda_codec_free(struct hda_codec *codec)
 {
         if (!codec)
                 return;
+        restore_init_pincfgs(codec);
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         cancel_delayed_work(&codec->power_work);
         flush_workqueue(codec->bus->workq);
@@ -711,6 +844,9 @@ static void snd_hda_codec_free(struct hda_codec *codec)
         kfree(codec);
 }
 
+static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
+                                unsigned int power_state);
+
 /**
  * snd_hda_codec_new - create a HDA codec
  * @bus: the bus to assign
@@ -750,6 +886,8 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr
         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
         snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
+        snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
+        snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
         if (codec->bus->modelname) {
                 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
                 if (!codec->modelname) {
@@ -786,15 +924,18 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr
         setup_fg_nodes(codec);
         if (!codec->afg && !codec->mfg) {
                 snd_printdd("hda_codec: no AFG or MFG node found\n");
-                snd_hda_codec_free(codec);
-                return -ENODEV;
+                err = -ENODEV;
+                goto error;
         }
 
-        if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
+        err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
+        if (err < 0) {
                 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
-                snd_hda_codec_free(codec);
-                return -ENOMEM;
+                goto error;
         }
+        err = read_pin_defaults(codec);
+        if (err < 0)
+                goto error;
 
         if (!codec->subsystem_id) {
                 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
@@ -805,12 +946,15 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr
         if (bus->modelname)
                 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
 
+        /* power-up all before initialization */
+        hda_set_power_state(codec,
+                            codec->afg ? codec->afg : codec->mfg,
+                            AC_PWRST_D0);
+
         if (do_init) {
                 err = snd_hda_codec_configure(codec);
-                if (err < 0) {
-                        snd_hda_codec_free(codec);
-                        return err;
-                }
+                if (err < 0)
+                        goto error;
         }
         snd_hda_codec_proc_new(codec);
 
@@ -823,6 +967,10 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr
         if (codecp)
                 *codecp = codec;
         return 0;
+
+ error:
+        snd_hda_codec_free(codec);
+        return err;
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
 
@@ -906,6 +1054,7 @@ EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
 
 /* FIXME: more better hash key? */
 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
+#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
 #define INFO_AMP_CAPS   (1<<0)
 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
 
@@ -996,6 +1145,21 @@ int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
 }
 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
 
+u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct hda_amp_info *info;
+
+        info = get_alloc_amp_hash(codec, HDA_HASH_PINCAP_KEY(nid));
+        if (!info)
+                return 0;
+        if (!info->head.val) {
+                info->amp_caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
+                info->head.val |= INFO_AMP_CAPS;
+        }
+        return info->amp_caps;
+}
+EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
+
 /*
  * read the current volume to info
  * if the cache exists, read the cache value.
@@ -1119,6 +1283,7 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
         u16 nid = get_amp_nid(kcontrol);
         u8 chs = get_amp_channels(kcontrol);
         int dir = get_amp_direction(kcontrol);
+        unsigned int ofs = get_amp_offset(kcontrol);
         u32 caps;
 
         caps = query_amp_caps(codec, nid, dir);
@@ -1130,6 +1295,8 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
                        kcontrol->id.name);
                 return -EINVAL;
         }
+        if (ofs < caps)
+                caps -= ofs;
         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
         uinfo->count = chs == 3 ? 2 : 1;
         uinfo->value.integer.min = 0;
@@ -1138,6 +1305,32 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
 
+
+static inline unsigned int
+read_amp_value(struct hda_codec *codec, hda_nid_t nid,
+               int ch, int dir, int idx, unsigned int ofs)
+{
+        unsigned int val;
+        val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
+        val &= HDA_AMP_VOLMASK;
+        if (val >= ofs)
+                val -= ofs;
+        else
+                val = 0;
+        return val;
+}
+
+static inline int
+update_amp_value(struct hda_codec *codec, hda_nid_t nid,
+                 int ch, int dir, int idx, unsigned int ofs,
+                 unsigned int val)
+{
+        if (val > 0)
+                val += ofs;
+        return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
+                                        HDA_AMP_VOLMASK, val);
+}
+
 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
                                  struct snd_ctl_elem_value *ucontrol)
 {
@@ -1146,14 +1339,13 @@ int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
         int chs = get_amp_channels(kcontrol);
         int dir = get_amp_direction(kcontrol);
         int idx = get_amp_index(kcontrol);
+        unsigned int ofs = get_amp_offset(kcontrol);
         long *valp = ucontrol->value.integer.value;
 
         if (chs & 1)
-                *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
-                        & HDA_AMP_VOLMASK;
+                *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
         if (chs & 2)
-                *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
-                        & HDA_AMP_VOLMASK;
+                *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
         return 0;
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
@@ -1166,18 +1358,17 @@ int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
         int chs = get_amp_channels(kcontrol);
         int dir = get_amp_direction(kcontrol);
         int idx = get_amp_index(kcontrol);
+        unsigned int ofs = get_amp_offset(kcontrol);
         long *valp = ucontrol->value.integer.value;
         int change = 0;
 
         snd_hda_power_up(codec);
         if (chs & 1) {
-                change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
-                                                  0x7f, *valp);
+                change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
                 valp++;
         }
         if (chs & 2)
-                change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
-                                                   0x7f, *valp);
+                change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
         snd_hda_power_down(codec);
         return change;
 }
@@ -1189,6 +1380,7 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         hda_nid_t nid = get_amp_nid(kcontrol);
         int dir = get_amp_direction(kcontrol);
+        unsigned int ofs = get_amp_offset(kcontrol);
         u32 caps, val1, val2;
 
         if (size < 4 * sizeof(unsigned int))
@@ -1197,6 +1389,7 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
         val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
         val2 = (val2 + 1) * 25;
         val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
+        val1 += ofs;
         val1 = ((int)val1) * ((int)val2);
         if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
                 return -EFAULT;
@@ -1267,7 +1460,6 @@ int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
 }
 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
 
-#ifdef CONFIG_SND_HDA_RECONFIG
 /* Clear all controls assigned to the given codec */
 void snd_hda_ctls_clear(struct hda_codec *codec)
 {
@@ -1278,9 +1470,52 @@ void snd_hda_ctls_clear(struct hda_codec *codec)
         snd_array_free(&codec->mixers);
 }
 
-void snd_hda_codec_reset(struct hda_codec *codec)
+/* pseudo device locking
+ * toggle card->shutdown to allow/disallow the device access (as a hack)
+ */
+static int hda_lock_devices(struct snd_card *card)
 {
-        int i;
+        spin_lock(&card->files_lock);
+        if (card->shutdown) {
+                spin_unlock(&card->files_lock);
+                return -EINVAL;
+        }
+        card->shutdown = 1;
+        spin_unlock(&card->files_lock);
+        return 0;
+}
+
+static void hda_unlock_devices(struct snd_card *card)
+{
+        spin_lock(&card->files_lock);
+        card->shutdown = 0;
+        spin_unlock(&card->files_lock);
+}
+
+int snd_hda_codec_reset(struct hda_codec *codec)
+{
+        struct snd_card *card = codec->bus->card;
+        int i, pcm;
+
+        if (hda_lock_devices(card) < 0)
+                return -EBUSY;
+        /* check whether the codec isn't used by any mixer or PCM streams */
+        if (!list_empty(&card->ctl_files)) {
+                hda_unlock_devices(card);
+                return -EBUSY;
+        }
+        for (pcm = 0; pcm < codec->num_pcms; pcm++) {
+                struct hda_pcm *cpcm = &codec->pcm_info[pcm];
+                if (!cpcm->pcm)
+                        continue;
+                if (cpcm->pcm->streams[0].substream_opened ||
+                    cpcm->pcm->streams[1].substream_opened) {
+                        hda_unlock_devices(card);
+                        return -EBUSY;
+                }
+        }
+
+        /* OK, let it free */
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         cancel_delayed_work(&codec->power_work);
@@ -1290,8 +1525,7 @@ void snd_hda_codec_reset(struct hda_codec *codec)
         /* relase PCMs */
         for (i = 0; i < codec->num_pcms; i++) {
                 if (codec->pcm_info[i].pcm) {
-                        snd_device_free(codec->bus->card,
-                                        codec->pcm_info[i].pcm);
+                        snd_device_free(card, codec->pcm_info[i].pcm);
                         clear_bit(codec->pcm_info[i].device,
                                   codec->bus->pcm_dev_bits);
                 }
@@ -1304,13 +1538,22 @@ void snd_hda_codec_reset(struct hda_codec *codec)
         free_hda_cache(&codec->cmd_cache);
         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
+        /* free only driver_pins so that init_pins + user_pins are restored */
+        snd_array_free(&codec->driver_pins);
+        restore_pincfgs(codec);
         codec->num_pcms = 0;
         codec->pcm_info = NULL;
         codec->preset = NULL;
+        memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
+        codec->slave_dig_outs = NULL;
+        codec->spdif_status_reset = 0;
         module_put(codec->owner);
         codec->owner = NULL;
+
+        /* allow device access again */
+        hda_unlock_devices(card);
+        return 0;
 }
-#endif /* CONFIG_SND_HDA_RECONFIG */
 
 /* create a virtual master control and add slaves */
 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
@@ -1335,15 +1578,20 @@ int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
         
         for (s = slaves; *s; s++) {
                 struct snd_kcontrol *sctl;
-
-                sctl = snd_hda_find_mixer_ctl(codec, *s);
-                if (!sctl) {
-                        snd_printdd("Cannot find slave %s, skipped\n", *s);
-                        continue;
+                int i = 0;
+                for (;;) {
+                        sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
+                        if (!sctl) {
+                                if (!i)
+                                        snd_printdd("Cannot find slave %s, "
+                                                    "skipped\n", *s);
+                                break;
+                        }
+                        err = snd_ctl_add_slave(kctl, sctl);
+                        if (err < 0)
+                                return err;
+                        i++;
                 }
-                err = snd_ctl_add_slave(kctl, sctl);
-                if (err < 0)
-                        return err;
         }
         return 0;
 }
@@ -1954,6 +2202,8 @@ int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
         }
         for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
                 kctl = snd_ctl_new1(dig_mix, codec);
+                if (!kctl)
+                        return -ENOMEM;
                 kctl->private_value = nid;
                 err = snd_hda_ctl_add(codec, kctl);
                 if (err < 0)
@@ -2002,7 +2252,11 @@ int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
         err = bus->ops.command(bus, res);
         if (!err) {
                 struct hda_cache_head *c;
-                u32 key = build_cmd_cache_key(nid, verb);
+                u32 key;
+                /* parm may contain the verb stuff for get/set amp */
+                verb = verb | (parm >> 8);
+                parm &= 0xff;
+                key = build_cmd_cache_key(nid, verb);
                 c = get_alloc_hash(&codec->cmd_cache, key);
                 if (c)
                         c->val = parm;
@@ -2073,8 +2327,7 @@ static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
                                  * don't power down the widget if it controls
                                  * eapd and EAPD_BTLENABLE is set.
                                  */
-                                pincap = snd_hda_param_read(codec, nid,
-                                                            AC_PAR_PIN_CAP);
+                                pincap = snd_hda_query_pin_caps(codec, nid);
                                 if (pincap & AC_PINCAP_EAPD) {
                                         int eapd = snd_hda_codec_read(codec,
                                                 nid, 0,
@@ -2143,6 +2396,7 @@ static void hda_call_codec_resume(struct hda_codec *codec)
         hda_set_power_state(codec,
                             codec->afg ? codec->afg : codec->mfg,
                             AC_PWRST_D0);
+        restore_pincfgs(codec); /* restore all current pin configs */
         hda_exec_init_verbs(codec);
         if (codec->patch_ops.resume)
                 codec->patch_ops.resume(codec);
@@ -2170,8 +2424,16 @@ int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
 
         list_for_each_entry(codec, &bus->codec_list, list) {
                 int err = snd_hda_codec_build_controls(codec);
-                if (err < 0)
-                        return err;
+                if (err < 0) {
+                        printk(KERN_ERR "hda_codec: cannot build controls"
+                               "for #%d (error %d)\n", codec->addr, err); 
+                        err = snd_hda_codec_reset(codec);
+                        if (err < 0) {
+                                printk(KERN_ERR
+                                       "hda_codec: cannot revert codec\n");
+                                return err;
+                        }
+                }
         }
         return 0;
 }
@@ -2180,19 +2442,12 @@ EXPORT_SYMBOL_HDA(snd_hda_build_controls);
 int snd_hda_codec_build_controls(struct hda_codec *codec)
 {
         int err = 0;
-        /* fake as if already powered-on */
-        hda_keep_power_on(codec);
-        /* then fire up */
-        hda_set_power_state(codec,
-                            codec->afg ? codec->afg : codec->mfg,
-                            AC_PWRST_D0);
         hda_exec_init_verbs(codec);
         /* continue to initialize... */
         if (codec->patch_ops.init)
                 err = codec->patch_ops.init(codec);
         if (!err && codec->patch_ops.build_controls)
                 err = codec->patch_ops.build_controls(codec);
-        snd_hda_power_down(codec);
         if (err < 0)
                 return err;
         return 0;
@@ -2305,12 +2560,11 @@ EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
 {
-        int i;
-        unsigned int val, streams;
+        unsigned int i, val, wcaps;
 
         val = 0;
-        if (nid != codec->afg &&
-            (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
+        wcaps = get_wcaps(codec, nid);
+        if (nid != codec->afg && (wcaps & AC_WCAP_FORMAT_OVRD)) {
                 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
                 if (val == -1)
                         return -EIO;
@@ -2324,15 +2578,20 @@ static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
                         if (val & (1 << i))
                                 rates |= rate_bits[i].alsa_bits;
                 }
+                if (rates == 0) {
+                        snd_printk(KERN_ERR "hda_codec: rates == 0 "
+                                   "(nid=0x%x, val=0x%x, ovrd=%i)\n",
+                                        nid, val,
+                                        (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
+                        return -EIO;
+                }
                 *ratesp = rates;
         }
 
         if (formatsp || bpsp) {
                 u64 formats = 0;
-                unsigned int bps;
-                unsigned int wcaps;
+                unsigned int streams, bps;
 
-                wcaps = get_wcaps(codec, nid);
                 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
                 if (streams == -1)
                         return -EIO;
@@ -2385,6 +2644,15 @@ static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
                         formats |= SNDRV_PCM_FMTBIT_U8;
                         bps = 8;
                 }
+                if (formats == 0) {
+                        snd_printk(KERN_ERR "hda_codec: formats == 0 "
+                                   "(nid=0x%x, val=0x%x, ovrd=%i, "
+                                   "streams=0x%x)\n",
+                                        nid, val,
+                                        (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
+                                        streams);
+                        return -EIO;
+                }
                 if (formatsp)
                         *formatsp = formats;
                 if (bpsp)
@@ -2500,12 +2768,16 @@ static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
 static int set_pcm_default_values(struct hda_codec *codec,
                                   struct hda_pcm_stream *info)
 {
+        int err;
+
         /* query support PCM information from the given NID */
         if (info->nid && (!info->rates || !info->formats)) {
-                snd_hda_query_supported_pcm(codec, info->nid,
+                err = snd_hda_query_supported_pcm(codec, info->nid,
                                 info->rates ? NULL : &info->rates,
                                 info->formats ? NULL : &info->formats,
                                 info->maxbps ? NULL : &info->maxbps);
+                if (err < 0)
+                        return err;
         }
         if (info->ops.open == NULL)
                 info->ops.open = hda_pcm_default_open_close;
@@ -2548,13 +2820,10 @@ static int get_empty_pcm_device(struct hda_bus *bus, int type)
                 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
                         dev = audio_idx[i];
                         if (!test_bit(dev, bus->pcm_dev_bits))
-                                break;
+                                goto ok;
                 }
-                if (i >= ARRAY_SIZE(audio_idx)) {
-                        snd_printk(KERN_WARNING "Too many audio devices\n");
-                        return -EAGAIN;
-                }
-                break;
+                snd_printk(KERN_WARNING "Too many audio devices\n");
+                return -EAGAIN;
         case HDA_PCM_TYPE_SPDIF:
         case HDA_PCM_TYPE_HDMI:
         case HDA_PCM_TYPE_MODEM:
@@ -2569,6 +2838,7 @@ static int get_empty_pcm_device(struct hda_bus *bus, int type)
                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
                 return -EINVAL;
         }
+ ok:
         set_bit(dev, bus->pcm_dev_bits);
         return dev;
 }
@@ -2605,24 +2875,36 @@ int snd_hda_codec_build_pcms(struct hda_codec *codec)
                 if (!codec->patch_ops.build_pcms)
                         return 0;
                 err = codec->patch_ops.build_pcms(codec);
-                if (err < 0)
-                        return err;
+                if (err < 0) {
+                        printk(KERN_ERR "hda_codec: cannot build PCMs"
+                               "for #%d (error %d)\n", codec->addr, err); 
+                        err = snd_hda_codec_reset(codec);
+                        if (err < 0) {
+                                printk(KERN_ERR
+                                       "hda_codec: cannot revert codec\n");
+                                return err;
+                        }
+                }
         }
         for (pcm = 0; pcm < codec->num_pcms; pcm++) {
                 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
                 int dev;
 
                 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
-                        return 0; /* no substreams assigned */
+                        continue; /* no substreams assigned */
 
                 if (!cpcm->pcm) {
                         dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
                         if (dev < 0)
-                                return 0;
+                                continue; /* no fatal error */
                         cpcm->device = dev;
                         err = snd_hda_attach_pcm(codec, cpcm);
-                        if (err < 0)
-                                return err;
+                        if (err < 0) {
+                                printk(KERN_ERR "hda_codec: cannot attach "
+                                       "PCM stream %d for codec #%d\n",
+                                       dev, codec->addr);
+                                continue; /* no fatal error */
+                        }
                 }
         }
         return 0;
@@ -2724,6 +3006,67 @@ int snd_hda_check_board_config(struct hda_codec *codec,
 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
 
 /**
+ * snd_hda_check_board_codec_sid_config - compare the current codec
+                                          subsystem ID with the
+                                          config table
+
+           This is important for Gateway notebooks with SB450 HDA Audio
+           where the vendor ID of the PCI device is:
+                ATI Technologies Inc SB450 HDA Audio [1002:437b]
+           and the vendor/subvendor are found only at the codec.
+
+ * @codec: the HDA codec
+ * @num_configs: number of config enums
+ * @models: array of model name strings
+ * @tbl: configuration table, terminated by null entries
+ *
+ * Compares the modelname or PCI subsystem id of the current codec with the
+ * given configuration table.  If a matching entry is found, returns its
+ * config value (supposed to be 0 or positive).
+ *
+ * If no entries are matching, the function returns a negative value.
+ */
+int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
+                               int num_configs, const char **models,
+                               const struct snd_pci_quirk *tbl)
+{
+        const struct snd_pci_quirk *q;
+
+        /* Search for codec ID */
+        for (q = tbl; q->subvendor; q++) {
+                unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
+
+                if (vendorid == codec->subsystem_id)
+                        break;
+        }
+
+        if (!q->subvendor)
+                return -1;
+
+        tbl = q;
+
+        if (tbl->value >= 0 && tbl->value < num_configs) {
+#ifdef CONFIG_SND_DEBUG_DETECT
+                char tmp[10];
+                const char *model = NULL;
+                if (models)
+                        model = models[tbl->value];
+                if (!model) {
+                        sprintf(tmp, "#%d", tbl->value);
+                        model = tmp;
+                }
+                snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
+                            "for config %x:%x (%s)\n",
+                            model, tbl->subvendor, tbl->subdevice,
+                            (tbl->name ? tbl->name : "Unknown device"));
+#endif
+                return tbl->value;
+        }
+        return -1;
+}
+EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
+
+/**
  * snd_hda_add_new_ctls - create controls from the array
  * @codec: the HDA codec
  * @knew: the array of struct snd_kcontrol_new
@@ -2815,7 +3158,7 @@ void snd_hda_power_down(struct hda_codec *codec)
                 return;
         if (power_save(codec)) {
                 codec->power_transition = 1; /* avoid reentrance */
-                schedule_delayed_work(&codec->power_work,
+                queue_delayed_work(codec->bus->workq, &codec->power_work,
                                 msecs_to_jiffies(power_save(codec) * 1000));
         }
 }
@@ -3026,6 +3369,16 @@ int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
 
+int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
+                                  struct hda_multi_out *mout)
+{
+        mutex_lock(&codec->spdif_mutex);
+        cleanup_dig_out_stream(codec, mout->dig_out_nid);
+        mutex_unlock(&codec->spdif_mutex);
+        return 0;
+}
+EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
+
 /*
  * release the digital out
  */
@@ -3252,8 +3605,7 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
                 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
                         continue;
 
-                def_conf = snd_hda_codec_read(codec, nid, 0,
-                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
+                def_conf = snd_hda_codec_get_pincfg(codec, nid);
                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
                         continue;
                 loc = get_defcfg_location(def_conf);
@@ -3329,10 +3681,22 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
                         cfg->input_pins[AUTO_PIN_AUX] = nid;
                         break;
                 case AC_JACK_SPDIF_OUT:
-                        cfg->dig_out_pin = nid;
+                case AC_JACK_DIG_OTHER_OUT:
+                        if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
+                                continue;
+                        cfg->dig_out_pins[cfg->dig_outs] = nid;
+                        cfg->dig_out_type[cfg->dig_outs] =
+                                (loc == AC_JACK_LOC_HDMI) ?
+                                HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
+                        cfg->dig_outs++;
                         break;
                 case AC_JACK_SPDIF_IN:
+                case AC_JACK_DIG_OTHER_IN:
                         cfg->dig_in_pin = nid;
+                        if (loc == AC_JACK_LOC_HDMI)
+                                cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
+                        else
+                                cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
                         break;
                 }
         }
@@ -3438,6 +3802,9 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
                    cfg->hp_pins[1], cfg->hp_pins[2],
                    cfg->hp_pins[3], cfg->hp_pins[4]);
         snd_printd("   mono: mono_out=0x%x\n", cfg->mono_out_pin);
+        if (cfg->dig_outs)
+                snd_printd("   dig-out=0x%x/0x%x\n",
+                           cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
         snd_printd("   inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
                    " cd=0x%x, aux=0x%x\n",
                    cfg->input_pins[AUTO_PIN_MIC],
@@ -3446,6 +3813,8 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
                    cfg->input_pins[AUTO_PIN_FRONT_LINE],
                    cfg->input_pins[AUTO_PIN_CD],
                    cfg->input_pins[AUTO_PIN_AUX]);
+        if (cfg->dig_in_pin)
+                snd_printd("   dig-in=0x%x\n", cfg->dig_in_pin);
 
         return 0;
 }
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index 5810ef588402..2fdecf4b0eb6 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -614,6 +614,7 @@ struct hda_bus {
 
         /* unsolicited event queue */
         struct hda_bus_unsolicited *unsol;
+        char workq_name[16];
         struct workqueue_struct *workq; /* common workqueue for codecs */
 
         /* assigned PCMs */
@@ -738,6 +739,7 @@ struct hda_codec {
         hda_nid_t mfg;  /* MFG node id */
 
         /* ids */
+        u32 function_id;
         u32 vendor_id;
         u32 subsystem_id;
         u32 revision_id;
@@ -777,11 +779,14 @@ struct hda_codec {
         unsigned short spdif_ctls;      /* SPDIF control bits */
         unsigned int spdif_in_enable;   /* SPDIF input enable? */
         hda_nid_t *slave_dig_outs; /* optional digital out slave widgets */
+        struct snd_array init_pins;     /* initial (BIOS) pin configurations */
+        struct snd_array driver_pins;   /* pin configs set by codec parser */
 
 #ifdef CONFIG_SND_HDA_HWDEP
         struct snd_hwdep *hwdep;        /* assigned hwdep device */
         struct snd_array init_verbs;    /* additional init verbs */
         struct snd_array hints;         /* additional hints */
+        struct snd_array user_pins;     /* default pin configs to override */
 #endif
 
         /* misc flags */
@@ -789,6 +794,9 @@ struct hda_codec {
                                              * status change
                                              * (e.g. Realtek codecs)
                                              */
+        unsigned int pin_amp_workaround:1; /* pin out-amp takes index
+                                            * (e.g. Conexant codecs)
+                                            */
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         unsigned int power_on :1;       /* current (global) power-state */
         unsigned int power_transition :1; /* power-state in transition */
@@ -854,6 +862,18 @@ void snd_hda_codec_resume_cache(struct hda_codec *codec);
 #define snd_hda_sequence_write_cache    snd_hda_sequence_write
 #endif
 
+/* the struct for codec->pin_configs */
+struct hda_pincfg {
+        hda_nid_t nid;
+        unsigned int cfg;
+};
+
+unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid);
+int snd_hda_codec_set_pincfg(struct hda_codec *codec, hda_nid_t nid,
+                             unsigned int cfg);
+int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
+                       hda_nid_t nid, unsigned int cfg); /* for hwdep */
+
 /*
  * Mixer
  */
diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c
index 65745e96dc70..1d5797a96682 100644
--- a/sound/pci/hda/hda_generic.c
+++ b/sound/pci/hda/hda_generic.c
@@ -144,9 +144,9 @@ static int add_new_node(struct hda_codec *codec, struct hda_gspec *spec, hda_nid
         node->type = (node->wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 
         if (node->type == AC_WID_PIN) {
-                node->pin_caps = snd_hda_param_read(codec, node->nid, AC_PAR_PIN_CAP);
+                node->pin_caps = snd_hda_query_pin_caps(codec, node->nid);
                 node->pin_ctl = snd_hda_codec_read(codec, node->nid, 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
-                node->def_cfg = snd_hda_codec_read(codec, node->nid, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
+                node->def_cfg = snd_hda_codec_get_pincfg(codec, node->nid);
         }
 
         if (node->wid_caps & AC_WCAP_OUT_AMP) {
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index 300ab407cf42..1c57505c2874 100644
--- a/sound/pci/hda/hda_hwdep.c
+++ b/sound/pci/hda/hda_hwdep.c
@@ -30,6 +30,12 @@
 #include <sound/hda_hwdep.h>
 #include <sound/minors.h>
 
+/* hint string pair */
+struct hda_hint {
+        const char *key;
+        const char *val;        /* contained in the same alloc as key */
+};
+
 /*
  * write/read an out-of-bound verb
  */
@@ -99,16 +105,17 @@ static int hda_hwdep_open(struct snd_hwdep *hw, struct file *file)
 
 static void clear_hwdep_elements(struct hda_codec *codec)
 {
-        char **head;
         int i;
 
         /* clear init verbs */
         snd_array_free(&codec->init_verbs);
         /* clear hints */
-        head = codec->hints.list;
-        for (i = 0; i < codec->hints.used; i++, head++)
-                kfree(*head);
+        for (i = 0; i < codec->hints.used; i++) {
+                struct hda_hint *hint = snd_array_elem(&codec->hints, i);
+                kfree(hint->key); /* we don't need to free hint->val */
+        }
         snd_array_free(&codec->hints);
+        snd_array_free(&codec->user_pins);
 }
 
 static void hwdep_free(struct snd_hwdep *hwdep)
@@ -140,7 +147,8 @@ int /*__devinit*/ snd_hda_create_hwdep(struct hda_codec *codec)
 #endif
 
         snd_array_init(&codec->init_verbs, sizeof(struct hda_verb), 32);
-        snd_array_init(&codec->hints, sizeof(char *), 32);
+        snd_array_init(&codec->hints, sizeof(struct hda_hint), 32);
+        snd_array_init(&codec->user_pins, sizeof(struct hda_pincfg), 16);
 
         return 0;
 }
@@ -153,7 +161,13 @@ int /*__devinit*/ snd_hda_create_hwdep(struct hda_codec *codec)
 
 static int clear_codec(struct hda_codec *codec)
 {
-        snd_hda_codec_reset(codec);
+        int err;
+
+        err = snd_hda_codec_reset(codec);
+        if (err < 0) {
+                snd_printk(KERN_ERR "The codec is being used, can't free.\n");
+                return err;
+        }
         clear_hwdep_elements(codec);
         return 0;
 }
@@ -162,20 +176,29 @@ static int reconfig_codec(struct hda_codec *codec)
 {
         int err;
 
+        snd_hda_power_up(codec);
         snd_printk(KERN_INFO "hda-codec: reconfiguring\n");
-        snd_hda_codec_reset(codec);
+        err = snd_hda_codec_reset(codec);
+        if (err < 0) {
+                snd_printk(KERN_ERR
+                           "The codec is being used, can't reconfigure.\n");
+                goto error;
+        }
         err = snd_hda_codec_configure(codec);
         if (err < 0)
-                return err;
+                goto error;
         /* rebuild PCMs */
         err = snd_hda_codec_build_pcms(codec);
         if (err < 0)
-                return err;
+                goto error;
         /* rebuild mixers */
         err = snd_hda_codec_build_controls(codec);
         if (err < 0)
-                return err;
-        return 0;
+                goto error;
+        err = snd_card_register(codec->bus->card);
+ error:
+        snd_hda_power_down(codec);
+        return err;
 }
 
 /*
@@ -271,47 +294,195 @@ static ssize_t type##_store(struct device *dev,			\
 CODEC_ACTION_STORE(reconfig);
 CODEC_ACTION_STORE(clear);
 
+static ssize_t init_verbs_show(struct device *dev,
+                               struct device_attribute *attr,
+                               char *buf)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        int i, len = 0;
+        for (i = 0; i < codec->init_verbs.used; i++) {
+                struct hda_verb *v = snd_array_elem(&codec->init_verbs, i);
+                len += snprintf(buf + len, PAGE_SIZE - len,
+                                "0x%02x 0x%03x 0x%04x\n",
+                                v->nid, v->verb, v->param);
+        }
+        return len;
+}
+
 static ssize_t init_verbs_store(struct device *dev,
                                 struct device_attribute *attr,
                                 const char *buf, size_t count)
 {
         struct snd_hwdep *hwdep = dev_get_drvdata(dev);
         struct hda_codec *codec = hwdep->private_data;
-        char *p;
-        struct hda_verb verb, *v;
+        struct hda_verb *v;
+        int nid, verb, param;
 
-        verb.nid = simple_strtoul(buf, &p, 0);
-        verb.verb = simple_strtoul(p, &p, 0);
-        verb.param = simple_strtoul(p, &p, 0);
-        if (!verb.nid || !verb.verb || !verb.param)
+        if (sscanf(buf, "%i %i %i", &nid, &verb, &param) != 3)
+                return -EINVAL;
+        if (!nid || !verb)
                 return -EINVAL;
         v = snd_array_new(&codec->init_verbs);
         if (!v)
                 return -ENOMEM;
-        *v = verb;
+        v->nid = nid;
+        v->verb = verb;
+        v->param = param;
         return count;
 }
 
+static ssize_t hints_show(struct device *dev,
+                          struct device_attribute *attr,
+                          char *buf)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        int i, len = 0;
+        for (i = 0; i < codec->hints.used; i++) {
+                struct hda_hint *hint = snd_array_elem(&codec->hints, i);
+                len += snprintf(buf + len, PAGE_SIZE - len,
+                                "%s = %s\n", hint->key, hint->val);
+        }
+        return len;
+}
+
+static struct hda_hint *get_hint(struct hda_codec *codec, const char *key)
+{
+        int i;
+
+        for (i = 0; i < codec->hints.used; i++) {
+                struct hda_hint *hint = snd_array_elem(&codec->hints, i);
+                if (!strcmp(hint->key, key))
+                        return hint;
+        }
+        return NULL;
+}
+
+static void remove_trail_spaces(char *str)
+{
+        char *p;
+        if (!*str)
+                return;
+        p = str + strlen(str) - 1;
+        for (; isspace(*p); p--) {
+                *p = 0;
+                if (p == str)
+                        return;
+        }
+}
+
+#define MAX_HINTS       1024
+
 static ssize_t hints_store(struct device *dev,
                            struct device_attribute *attr,
                            const char *buf, size_t count)
 {
         struct snd_hwdep *hwdep = dev_get_drvdata(dev);
         struct hda_codec *codec = hwdep->private_data;
-        char *p;
-        char **hint;
+        char *key, *val;
+        struct hda_hint *hint;
 
-        if (!*buf || isspace(*buf) || *buf == '#' || *buf == '\n')
+        while (isspace(*buf))
+                buf++;
+        if (!*buf || *buf == '#' || *buf == '\n')
                 return count;
-        p = kstrndup_noeol(buf, 1024);
-        if (!p)
+        if (*buf == '=')
+                return -EINVAL;
+        key = kstrndup_noeol(buf, 1024);
+        if (!key)
                 return -ENOMEM;
-        hint = snd_array_new(&codec->hints);
+        /* extract key and val */
+        val = strchr(key, '=');
+        if (!val) {
+                kfree(key);
+                return -EINVAL;
+        }
+        *val++ = 0;
+        while (isspace(*val))
+                val++;
+        remove_trail_spaces(key);
+        remove_trail_spaces(val);
+        hint = get_hint(codec, key);
+        if (hint) {
+                /* replace */
+                kfree(hint->key);
+                hint->key = key;
+                hint->val = val;
+                return count;
+        }
+        /* allocate a new hint entry */
+        if (codec->hints.used >= MAX_HINTS)
+                hint = NULL;
+        else
+                hint = snd_array_new(&codec->hints);
         if (!hint) {
-                kfree(p);
+                kfree(key);
                 return -ENOMEM;
         }
-        *hint = p;
+        hint->key = key;
+        hint->val = val;
+        return count;
+}
+
+static ssize_t pin_configs_show(struct hda_codec *codec,
+                                struct snd_array *list,
+                                char *buf)
+{
+        int i, len = 0;
+        for (i = 0; i < list->used; i++) {
+                struct hda_pincfg *pin = snd_array_elem(list, i);
+                len += sprintf(buf + len, "0x%02x 0x%08x\n",
+                               pin->nid, pin->cfg);
+        }
+        return len;
+}
+
+static ssize_t init_pin_configs_show(struct device *dev,
+                                     struct device_attribute *attr,
+                                     char *buf)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        return pin_configs_show(codec, &codec->init_pins, buf);
+}
+
+static ssize_t user_pin_configs_show(struct device *dev,
+                                     struct device_attribute *attr,
+                                     char *buf)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        return pin_configs_show(codec, &codec->user_pins, buf);
+}
+
+static ssize_t driver_pin_configs_show(struct device *dev,
+                                       struct device_attribute *attr,
+                                       char *buf)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        return pin_configs_show(codec, &codec->driver_pins, buf);
+}
+
+#define MAX_PIN_CONFIGS         32
+
+static ssize_t user_pin_configs_store(struct device *dev,
+                                      struct device_attribute *attr,
+                                      const char *buf, size_t count)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        int nid, cfg;
+        int err;
+
+        if (sscanf(buf, "%i %i", &nid, &cfg) != 2)
+                return -EINVAL;
+        if (!nid)
+                return -EINVAL;
+        err = snd_hda_add_pincfg(codec, &codec->user_pins, nid, cfg);
+        if (err < 0)
+                return err;
         return count;
 }
 
@@ -330,8 +501,11 @@ static struct device_attribute codec_attrs[] = {
         CODEC_ATTR_RO(mfg),
         CODEC_ATTR_RW(name),
         CODEC_ATTR_RW(modelname),
-        CODEC_ATTR_WO(init_verbs),
-        CODEC_ATTR_WO(hints),
+        CODEC_ATTR_RW(init_verbs),
+        CODEC_ATTR_RW(hints),
+        CODEC_ATTR_RO(init_pin_configs),
+        CODEC_ATTR_RW(user_pin_configs),
+        CODEC_ATTR_RO(driver_pin_configs),
         CODEC_ATTR_WO(reconfig),
         CODEC_ATTR_WO(clear),
 };
@@ -350,4 +524,29 @@ int snd_hda_hwdep_add_sysfs(struct hda_codec *codec)
         return 0;
 }
 
+/*
+ * Look for hint string
+ */
+const char *snd_hda_get_hint(struct hda_codec *codec, const char *key)
+{
+        struct hda_hint *hint = get_hint(codec, key);
+        return hint ? hint->val : NULL;
+}
+EXPORT_SYMBOL_HDA(snd_hda_get_hint);
+
+int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
+{
+        const char *p = snd_hda_get_hint(codec, key);
+        if (!p || !*p)
+                return -ENOENT;
+        switch (toupper(*p)) {
+        case 'T': /* true */
+        case 'Y': /* yes */
+        case '1':
+                return 1;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_HDA(snd_hda_get_bool_hint);
+
 #endif /* CONFIG_SND_HDA_RECONFIG */
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index f9603443f086..21e99cfa8c49 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -312,6 +312,8 @@ struct azx_dev {
         unsigned int period_bytes; /* size of the period in bytes */
         unsigned int frags;     /* number for period in the play buffer */
         unsigned int fifo_size; /* FIFO size */
+        unsigned long start_jiffies;    /* start + minimum jiffies */
+        unsigned long min_jiffies;      /* minimum jiffies before position is valid */
 
         void __iomem *sd_addr;  /* stream descriptor pointer */
 
@@ -330,7 +332,7 @@ struct azx_dev {
         unsigned int opened :1;
         unsigned int running :1;
         unsigned int irq_pending :1;
-        unsigned int irq_ignore :1;
+        unsigned int start_flag: 1;     /* stream full start flag */
         /*
          * For VIA:
          *  A flag to ensure DMA position is 0
@@ -381,6 +383,7 @@ struct azx {
 
         /* HD codec */
         unsigned short codec_mask;
+        int  codec_probe_mask; /* copied from probe_mask option */
         struct hda_bus *bus;
 
         /* CORB/RIRB */
@@ -858,13 +861,18 @@ static void azx_stream_start(struct azx *chip, struct azx_dev *azx_dev)
                       SD_CTL_DMA_START | SD_INT_MASK);
 }
 
-/* stop a stream */
-static void azx_stream_stop(struct azx *chip, struct azx_dev *azx_dev)
+/* stop DMA */
+static void azx_stream_clear(struct azx *chip, struct azx_dev *azx_dev)
 {
-        /* stop DMA */
         azx_sd_writeb(azx_dev, SD_CTL, azx_sd_readb(azx_dev, SD_CTL) &
                       ~(SD_CTL_DMA_START | SD_INT_MASK));
         azx_sd_writeb(azx_dev, SD_STS, SD_INT_MASK); /* to be sure */
+}
+
+/* stop a stream */
+static void azx_stream_stop(struct azx *chip, struct azx_dev *azx_dev)
+{
+        azx_stream_clear(chip, azx_dev);
         /* disable SIE */
         azx_writeb(chip, INTCTL,
                    azx_readb(chip, INTCTL) & ~(1 << azx_dev->index));
@@ -969,7 +977,7 @@ static irqreturn_t azx_interrupt(int irq, void *dev_id)
         struct azx *chip = dev_id;
         struct azx_dev *azx_dev;
         u32 status;
-        int i;
+        int i, ok;
 
         spin_lock(&chip->reg_lock);
 
@@ -985,18 +993,14 @@ static irqreturn_t azx_interrupt(int irq, void *dev_id)
                         azx_sd_writeb(azx_dev, SD_STS, SD_INT_MASK);
                         if (!azx_dev->substream || !azx_dev->running)
                                 continue;
-                        /* ignore the first dummy IRQ (due to pos_adj) */
-                        if (azx_dev->irq_ignore) {
-                                azx_dev->irq_ignore = 0;
-                                continue;
-                        }
                         /* check whether this IRQ is really acceptable */
-                        if (azx_position_ok(chip, azx_dev)) {
+                        ok = azx_position_ok(chip, azx_dev);
+                        if (ok == 1) {
                                 azx_dev->irq_pending = 0;
                                 spin_unlock(&chip->reg_lock);
                                 snd_pcm_period_elapsed(azx_dev->substream);
                                 spin_lock(&chip->reg_lock);
-                        } else if (chip->bus && chip->bus->workq) {
+                        } else if (ok == 0 && chip->bus && chip->bus->workq) {
                                 /* bogus IRQ, process it later */
                                 azx_dev->irq_pending = 1;
                                 queue_work(chip->bus->workq,
@@ -1075,15 +1079,13 @@ static int azx_setup_periods(struct azx *chip,
         azx_sd_writel(azx_dev, SD_BDLPL, 0);
         azx_sd_writel(azx_dev, SD_BDLPU, 0);
 
-        period_bytes = snd_pcm_lib_period_bytes(substream);
-        azx_dev->period_bytes = period_bytes;
+        period_bytes = azx_dev->period_bytes;
         periods = azx_dev->bufsize / period_bytes;
 
         /* program the initial BDL entries */
         bdl = (u32 *)azx_dev->bdl.area;
         ofs = 0;
         azx_dev->frags = 0;
-        azx_dev->irq_ignore = 0;
         pos_adj = bdl_pos_adj[chip->dev_index];
         if (pos_adj > 0) {
                 struct snd_pcm_runtime *runtime = substream->runtime;
@@ -1104,7 +1106,6 @@ static int azx_setup_periods(struct azx *chip,
                                          &bdl, ofs, pos_adj, 1);
                         if (ofs < 0)
                                 goto error;
-                        azx_dev->irq_ignore = 1;
                 }
         } else
                 pos_adj = 0;
@@ -1123,24 +1124,17 @@ static int azx_setup_periods(struct azx *chip,
  error:
         snd_printk(KERN_ERR "Too many BDL entries: buffer=%d, period=%d\n",
                    azx_dev->bufsize, period_bytes);
-        /* reset */
-        azx_sd_writel(azx_dev, SD_BDLPL, 0);
-        azx_sd_writel(azx_dev, SD_BDLPU, 0);
         return -EINVAL;
 }
 
-/*
- * set up the SD for streaming
- */
-static int azx_setup_controller(struct azx *chip, struct azx_dev *azx_dev)
+/* reset stream */
+static void azx_stream_reset(struct azx *chip, struct azx_dev *azx_dev)
 {
         unsigned char val;
         int timeout;
 
-        /* make sure the run bit is zero for SD */
-        azx_sd_writeb(azx_dev, SD_CTL, azx_sd_readb(azx_dev, SD_CTL) &
-                      ~SD_CTL_DMA_START);
-        /* reset stream */
+        azx_stream_clear(chip, azx_dev);
+
         azx_sd_writeb(azx_dev, SD_CTL, azx_sd_readb(azx_dev, SD_CTL) |
                       SD_CTL_STREAM_RESET);
         udelay(3);
@@ -1158,6 +1152,17 @@ static int azx_setup_controller(struct azx *chip, struct azx_dev *azx_dev)
                --timeout)
                 ;
 
+        /* reset first position - may not be synced with hw at this time */
+        *azx_dev->posbuf = 0;
+}
+
+/*
+ * set up the SD for streaming
+ */
+static int azx_setup_controller(struct azx *chip, struct azx_dev *azx_dev)
+{
+        /* make sure the run bit is zero for SD */
+        azx_stream_clear(chip, azx_dev);
         /* program the stream_tag */
         azx_sd_writel(azx_dev, SD_CTL,
                       (azx_sd_readl(azx_dev, SD_CTL) & ~SD_CTL_STREAM_TAG_MASK)|
@@ -1228,7 +1233,6 @@ static unsigned int azx_max_codecs[AZX_NUM_DRIVERS] __devinitdata = {
 };
 
 static int __devinit azx_codec_create(struct azx *chip, const char *model,
-                                      unsigned int codec_probe_mask,
                                       int no_init)
 {
         struct hda_bus_template bus_temp;
@@ -1261,7 +1265,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model,
 
         /* First try to probe all given codec slots */
         for (c = 0; c < max_slots; c++) {
-                if ((chip->codec_mask & (1 << c)) & codec_probe_mask) {
+                if ((chip->codec_mask & (1 << c)) & chip->codec_probe_mask) {
                         if (probe_codec(chip, c) < 0) {
                                 /* Some BIOSen give you wrong codec addresses
                                  * that don't exist
@@ -1285,7 +1289,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model,
 
         /* Then create codec instances */
         for (c = 0; c < max_slots; c++) {
-                if ((chip->codec_mask & (1 << c)) & codec_probe_mask) {
+                if ((chip->codec_mask & (1 << c)) & chip->codec_probe_mask) {
                         struct hda_codec *codec;
                         err = snd_hda_codec_new(chip->bus, c, !no_init, &codec);
                         if (err < 0)
@@ -1403,6 +1407,7 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
         runtime->private_data = azx_dev;
         snd_pcm_set_sync(substream);
         mutex_unlock(&chip->open_mutex);
+
         return 0;
 }
 
@@ -1429,6 +1434,11 @@ static int azx_pcm_close(struct snd_pcm_substream *substream)
 static int azx_pcm_hw_params(struct snd_pcm_substream *substream,
                              struct snd_pcm_hw_params *hw_params)
 {
+        struct azx_dev *azx_dev = get_azx_dev(substream);
+
+        azx_dev->bufsize = 0;
+        azx_dev->period_bytes = 0;
+        azx_dev->format_val = 0;
         return snd_pcm_lib_malloc_pages(substream,
                                         params_buffer_bytes(hw_params));
 }
@@ -1443,6 +1453,9 @@ static int azx_pcm_hw_free(struct snd_pcm_substream *substream)
         azx_sd_writel(azx_dev, SD_BDLPL, 0);
         azx_sd_writel(azx_dev, SD_BDLPU, 0);
         azx_sd_writel(azx_dev, SD_CTL, 0);
+        azx_dev->bufsize = 0;
+        azx_dev->period_bytes = 0;
+        azx_dev->format_val = 0;
 
         hinfo->ops.cleanup(hinfo, apcm->codec, substream);
 
@@ -1456,23 +1469,40 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream)
         struct azx_dev *azx_dev = get_azx_dev(substream);
         struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream];
         struct snd_pcm_runtime *runtime = substream->runtime;
+        unsigned int bufsize, period_bytes, format_val;
+        int err;
 
-        azx_dev->bufsize = snd_pcm_lib_buffer_bytes(substream);
-        azx_dev->format_val = snd_hda_calc_stream_format(runtime->rate,
-                                                         runtime->channels,
-                                                         runtime->format,
-                                                         hinfo->maxbps);
-        if (!azx_dev->format_val) {
+        azx_stream_reset(chip, azx_dev);
+        format_val = snd_hda_calc_stream_format(runtime->rate,
+                                                runtime->channels,
+                                                runtime->format,
+                                                hinfo->maxbps);
+        if (!format_val) {
                 snd_printk(KERN_ERR SFX
                            "invalid format_val, rate=%d, ch=%d, format=%d\n",
                            runtime->rate, runtime->channels, runtime->format);
                 return -EINVAL;
         }
 
+        bufsize = snd_pcm_lib_buffer_bytes(substream);
+        period_bytes = snd_pcm_lib_period_bytes(substream);
+
         snd_printdd("azx_pcm_prepare: bufsize=0x%x, format=0x%x\n",
-                    azx_dev->bufsize, azx_dev->format_val);
-        if (azx_setup_periods(chip, substream, azx_dev) < 0)
-                return -EINVAL;
+                    bufsize, format_val);
+
+        if (bufsize != azx_dev->bufsize ||
+            period_bytes != azx_dev->period_bytes ||
+            format_val != azx_dev->format_val) {
+                azx_dev->bufsize = bufsize;
+                azx_dev->period_bytes = period_bytes;
+                azx_dev->format_val = format_val;
+                err = azx_setup_periods(chip, substream, azx_dev);
+                if (err < 0)
+                        return err;
+        }
+
+        azx_dev->min_jiffies = (runtime->period_size * HZ) /
+                                                (runtime->rate * 2);
         azx_setup_controller(chip, azx_dev);
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                 azx_dev->fifo_size = azx_sd_readw(azx_dev, SD_FIFOSIZE) + 1;
@@ -1489,13 +1519,14 @@ static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         struct azx *chip = apcm->chip;
         struct azx_dev *azx_dev;
         struct snd_pcm_substream *s;
-        int start, nsync = 0, sbits = 0;
+        int rstart = 0, start, nsync = 0, sbits = 0;
         int nwait, timeout;
 
         switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                rstart = 1;
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
         case SNDRV_PCM_TRIGGER_RESUME:
-        case SNDRV_PCM_TRIGGER_START:
                 start = 1;
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
@@ -1525,6 +1556,10 @@ static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 if (s->pcm->card != substream->pcm->card)
                         continue;
                 azx_dev = get_azx_dev(s);
+                if (rstart) {
+                        azx_dev->start_flag = 1;
+                        azx_dev->start_jiffies = jiffies + azx_dev->min_jiffies;
+                }
                 if (start)
                         azx_stream_start(chip, azx_dev);
                 else
@@ -1674,6 +1709,11 @@ static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev)
 {
         unsigned int pos;
 
+        if (azx_dev->start_flag &&
+            time_before_eq(jiffies, azx_dev->start_jiffies))
+                return -1;      /* bogus (too early) interrupt */
+        azx_dev->start_flag = 0;
+
         pos = azx_get_position(chip, azx_dev);
         if (chip->position_fix == POS_FIX_AUTO) {
                 if (!pos) {
@@ -1947,16 +1987,13 @@ static int azx_suspend(struct pci_dev *pci, pm_message_t state)
         return 0;
 }
 
-static int azx_resume_early(struct pci_dev *pci)
-{
-        return pci_restore_state(pci);
-}
-
 static int azx_resume(struct pci_dev *pci)
 {
         struct snd_card *card = pci_get_drvdata(pci);
         struct azx *chip = card->private_data;
 
+        pci_set_power_state(pci, PCI_D0);
+        pci_restore_state(pci);
         if (pci_enable_device(pci) < 0) {
                 printk(KERN_ERR "hda-intel: pci_enable_device failed, "
                        "disabling device\n");
@@ -2062,26 +2099,31 @@ static int __devinit check_position_fix(struct azx *chip, int fix)
 {
         const struct snd_pci_quirk *q;
 
-        /* Check VIA HD Audio Controller exist */
-        if (chip->pci->vendor == PCI_VENDOR_ID_VIA &&
-            chip->pci->device == VIA_HDAC_DEVICE_ID) {
+        switch (fix) {
+        case POS_FIX_LPIB:
+        case POS_FIX_POSBUF:
+                return fix;
+        }
+
+        /* Check VIA/ATI HD Audio Controller exist */
+        switch (chip->driver_type) {
+        case AZX_DRIVER_VIA:
+        case AZX_DRIVER_ATI:
                 chip->via_dmapos_patch = 1;
                 /* Use link position directly, avoid any transfer problem. */
                 return POS_FIX_LPIB;
         }
         chip->via_dmapos_patch = 0;
 
-        if (fix == POS_FIX_AUTO) {
-                q = snd_pci_quirk_lookup(chip->pci, position_fix_list);
-                if (q) {
-                        printk(KERN_INFO
-                                    "hda_intel: position_fix set to %d "
-                                    "for device %04x:%04x\n",
-                                    q->value, q->subvendor, q->subdevice);
-                        return q->value;
-                }
+        q = snd_pci_quirk_lookup(chip->pci, position_fix_list);
+        if (q) {
+                printk(KERN_INFO
+                       "hda_intel: position_fix set to %d "
+                       "for device %04x:%04x\n",
+                       q->value, q->subvendor, q->subdevice);
+                return q->value;
         }
-        return fix;
+        return POS_FIX_AUTO;
 }
 
 /*
@@ -2098,23 +2140,36 @@ static struct snd_pci_quirk probe_mask_list[] __devinitdata = {
         SND_PCI_QUIRK(0x1028, 0x20ac, "Dell Studio Desktop", 0x01),
         /* including bogus ALC268 in slot#2 that conflicts with ALC888 */
         SND_PCI_QUIRK(0x17c0, 0x4085, "Medion MD96630", 0x01),
+        /* forced codec slots */
+        SND_PCI_QUIRK(0x1046, 0x1262, "ASUS W5F", 0x103),
         {}
 };
 
+#define AZX_FORCE_CODEC_MASK    0x100
+
 static void __devinit check_probe_mask(struct azx *chip, int dev)
 {
         const struct snd_pci_quirk *q;
 
-        if (probe_mask[dev] == -1) {
+        chip->codec_probe_mask = probe_mask[dev];
+        if (chip->codec_probe_mask == -1) {
                 q = snd_pci_quirk_lookup(chip->pci, probe_mask_list);
                 if (q) {
                         printk(KERN_INFO
                                "hda_intel: probe_mask set to 0x%x "
                                "for device %04x:%04x\n",
                                q->value, q->subvendor, q->subdevice);
-                        probe_mask[dev] = q->value;
+                        chip->codec_probe_mask = q->value;
                 }
         }
+
+        /* check forced option */
+        if (chip->codec_probe_mask != -1 &&
+            (chip->codec_probe_mask & AZX_FORCE_CODEC_MASK)) {
+                chip->codec_mask = chip->codec_probe_mask & 0xff;
+                printk(KERN_INFO "hda_intel: codec_mask forced to 0x%x\n",
+                       chip->codec_mask);
+        }
 }
 
 
@@ -2211,9 +2266,17 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
         gcap = azx_readw(chip, GCAP);
         snd_printdd("chipset global capabilities = 0x%x\n", gcap);
 
+        /* ATI chips seems buggy about 64bit DMA addresses */
+        if (chip->driver_type == AZX_DRIVER_ATI)
+                gcap &= ~0x01;
+
         /* allow 64bit DMA address if supported by H/W */
-        if ((gcap & 0x01) && !pci_set_dma_mask(pci, DMA_64BIT_MASK))
-                pci_set_consistent_dma_mask(pci, DMA_64BIT_MASK);
+        if ((gcap & 0x01) && !pci_set_dma_mask(pci, DMA_BIT_MASK(64)))
+                pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(64));
+        else {
+                pci_set_dma_mask(pci, DMA_BIT_MASK(32));
+                pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32));
+        }
 
         /* read number of streams from GCAP register instead of using
          * hardcoded value
@@ -2347,8 +2410,7 @@ static int __devinit azx_probe(struct pci_dev *pci,
         card->private_data = chip;
 
         /* create codec instances */
-        err = azx_codec_create(chip, model[dev], probe_mask[dev],
-                               probe_only[dev]);
+        err = azx_codec_create(chip, model[dev], probe_only[dev]);
         if (err < 0)
                 goto out_free;
 
@@ -2445,10 +2507,10 @@ static struct pci_device_id azx_ids[] = {
         { PCI_DEVICE(0x10de, 0x0ac1), .driver_data = AZX_DRIVER_NVIDIA },
         { PCI_DEVICE(0x10de, 0x0ac2), .driver_data = AZX_DRIVER_NVIDIA },
         { PCI_DEVICE(0x10de, 0x0ac3), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0bd4), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0bd5), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0bd6), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0bd7), .driver_data = AZX_DRIVER_NVIDIA },
+        { PCI_DEVICE(0x10de, 0x0d94), .driver_data = AZX_DRIVER_NVIDIA },
+        { PCI_DEVICE(0x10de, 0x0d95), .driver_data = AZX_DRIVER_NVIDIA },
+        { PCI_DEVICE(0x10de, 0x0d96), .driver_data = AZX_DRIVER_NVIDIA },
+        { PCI_DEVICE(0x10de, 0x0d97), .driver_data = AZX_DRIVER_NVIDIA },
         /* Teradici */
         { PCI_DEVICE(0x6549, 0x1200), .driver_data = AZX_DRIVER_TERA },
         /* AMD Generic, PCI class code and Vendor ID for HD Audio */
@@ -2468,7 +2530,6 @@ static struct pci_driver driver = {
         .remove = __devexit_p(azx_remove),
 #ifdef CONFIG_PM
         .suspend = azx_suspend,
-        .resume_early = azx_resume_early,
         .resume = azx_resume,
 #endif
 };
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 6f2fe0f9fdd8..83349013b4df 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -26,8 +26,10 @@
 /*
  * for mixer controls
  */
+#define HDA_COMPOSE_AMP_VAL_OFS(nid,chs,idx,dir,ofs)            \
+        ((nid) | ((chs)<<16) | ((dir)<<18) | ((idx)<<19) | ((ofs)<<23))
 #define HDA_COMPOSE_AMP_VAL(nid,chs,idx,dir) \
-        ((nid) | ((chs)<<16) | ((dir)<<18) | ((idx)<<19))
+        HDA_COMPOSE_AMP_VAL_OFS(nid, chs, idx, dir, 0)
 /* mono volume with index (index=0,1,...) (channel=1,2) */
 #define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx,  \
@@ -96,7 +98,7 @@ struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
                                             const char *name);
 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
                         unsigned int *tlv, const char **slaves);
-void snd_hda_codec_reset(struct hda_codec *codec);
+int snd_hda_codec_reset(struct hda_codec *codec);
 int snd_hda_codec_configure(struct hda_codec *codec);
 
 /* amp value bits */
@@ -134,7 +136,7 @@ extern struct hda_ctl_ops snd_hda_bind_sw;	/* for bind-switch */
 
 struct hda_bind_ctls {
         struct hda_ctl_ops *ops;
-        long values[];
+        unsigned long values[];
 };
 
 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
@@ -227,6 +229,7 @@ struct hda_multi_out {
         hda_nid_t hp_nid;       /* optional DAC for HP, 0 when not exists */
         hda_nid_t extra_out_nid[3];     /* optional DACs, 0 when not exists */
         hda_nid_t dig_out_nid;  /* digital out audio widget */
+        hda_nid_t *slave_dig_outs;
         int max_channels;       /* currently supported analog channels */
         int dig_out_used;       /* current usage of digital out (HDA_DIG_XXX) */
         int no_share_stream;    /* don't share a stream with multiple pins */
@@ -251,6 +254,8 @@ int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
                                   unsigned int stream_tag,
                                   unsigned int format,
                                   struct snd_pcm_substream *substream);
+int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
+                                  struct hda_multi_out *mout);
 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
                                   struct hda_multi_out *mout,
                                   struct snd_pcm_substream *substream,
@@ -296,6 +301,9 @@ void snd_print_pcm_bits(int pcm, char *buf, int buflen);
 int snd_hda_check_board_config(struct hda_codec *codec, int num_configs,
                                const char **modelnames,
                                const struct snd_pci_quirk *pci_list);
+int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
+                               int num_configs, const char **models,
+                               const struct snd_pci_quirk *tbl);
 int snd_hda_add_new_ctls(struct hda_codec *codec,
                          struct snd_kcontrol_new *knew);
 
@@ -349,9 +357,12 @@ struct auto_pin_cfg {
         int line_out_type;      /* AUTO_PIN_XXX_OUT */
         hda_nid_t hp_pins[AUTO_CFG_MAX_OUTS];
         hda_nid_t input_pins[AUTO_PIN_LAST];
-        hda_nid_t dig_out_pin;
+        int dig_outs;
+        hda_nid_t dig_out_pins[2];
         hda_nid_t dig_in_pin;
         hda_nid_t mono_out_pin;
+        int dig_out_type[2]; /* HDA_PCM_TYPE_XXX */
+        int dig_in_type; /* HDA_PCM_TYPE_XXX */
 };
 
 #define get_defcfg_connect(cfg) \
@@ -400,6 +411,7 @@ static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid)
 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction);
 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
                               unsigned int caps);
+u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid);
 
 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl);
 void snd_hda_ctls_clear(struct hda_codec *codec);
@@ -422,6 +434,23 @@ static inline int snd_hda_hwdep_add_sysfs(struct hda_codec *codec)
 }
 #endif
 
+#ifdef CONFIG_SND_HDA_RECONFIG
+const char *snd_hda_get_hint(struct hda_codec *codec, const char *key);
+int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key);
+#else
+static inline
+const char *snd_hda_get_hint(struct hda_codec *codec, const char *key)
+{
+        return NULL;
+}
+
+static inline
+int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
+{
+        return -ENOENT;
+}
+#endif
+
 /*
  * power-management
  */
@@ -453,6 +482,7 @@ int snd_hda_check_amp_list_power(struct hda_codec *codec,
 #define get_amp_channels(kc)    (((kc)->private_value >> 16) & 0x3)
 #define get_amp_direction(kc)   (((kc)->private_value >> 18) & 0x1)
 #define get_amp_index(kc)       (((kc)->private_value >> 19) & 0xf)
+#define get_amp_offset(kc)      (((kc)->private_value >> 23) & 0x3f)
 
 /*
  * CEA Short Audio Descriptor data
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c
index 7ca66d654148..93d7499350c6 100644
--- a/sound/pci/hda/hda_proc.c
+++ b/sound/pci/hda/hda_proc.c
@@ -399,7 +399,10 @@ static void print_conn_list(struct snd_info_buffer *buffer,
 {
         int c, curr = -1;
 
-        if (conn_len > 1 && wid_type != AC_WID_AUD_MIX)
+        if (conn_len > 1 &&
+            wid_type != AC_WID_AUD_MIX &&
+            wid_type != AC_WID_VOL_KNB &&
+            wid_type != AC_WID_POWER)
                 curr = snd_hda_codec_read(codec, nid, 0,
                                           AC_VERB_GET_CONNECT_SEL, 0);
         snd_iprintf(buffer, "  Connection: %d\n", conn_len);
@@ -466,8 +469,9 @@ static void print_codec_info(struct snd_info_entry *entry,
         snd_iprintf(buffer, "Codec: %s\n",
                     codec->name ? codec->name : "Not Set");
         snd_iprintf(buffer, "Address: %d\n", codec->addr);
-        snd_iprintf(buffer, "Vendor Id: 0x%x\n", codec->vendor_id);
-        snd_iprintf(buffer, "Subsystem Id: 0x%x\n", codec->subsystem_id);
+        snd_iprintf(buffer, "Function Id: 0x%x\n", codec->function_id);
+        snd_iprintf(buffer, "Vendor Id: 0x%08x\n", codec->vendor_id);
+        snd_iprintf(buffer, "Subsystem Id: 0x%08x\n", codec->subsystem_id);
         snd_iprintf(buffer, "Revision Id: 0x%x\n", codec->revision_id);
 
         if (codec->mfg)
@@ -553,8 +557,14 @@ static void print_codec_info(struct snd_info_entry *entry,
                         snd_iprintf(buffer, "  Amp-Out caps: ");
                         print_amp_caps(buffer, codec, nid, HDA_OUTPUT);
                         snd_iprintf(buffer, "  Amp-Out vals: ");
-                        print_amp_vals(buffer, codec, nid, HDA_OUTPUT,
-                                       wid_caps & AC_WCAP_STEREO, 1);
+                        if (wid_type == AC_WID_PIN &&
+                            codec->pin_amp_workaround)
+                                print_amp_vals(buffer, codec, nid, HDA_OUTPUT,
+                                               wid_caps & AC_WCAP_STEREO,
+                                               conn_len);
+                        else
+                                print_amp_vals(buffer, codec, nid, HDA_OUTPUT,
+                                               wid_caps & AC_WCAP_STEREO, 1);
                 }
 
                 switch (wid_type) {
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index 2e7371ec2e23..84cc49ca9148 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -27,11 +27,12 @@
 #include <sound/core.h>
 #include "hda_codec.h"
 #include "hda_local.h"
+#include "hda_beep.h"
 
 struct ad198x_spec {
         struct snd_kcontrol_new *mixers[5];
         int num_mixers;
-
+        unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
         const struct hda_verb *init_verbs[5];   /* initialization verbs
                                                  * don't forget NULL termination!
                                                  */
@@ -154,6 +155,16 @@ static const char *ad_slave_sws[] = {
 
 static void ad198x_free_kctls(struct hda_codec *codec);
 
+/* additional beep mixers; the actual parameters are overwritten at build */
+static struct snd_kcontrol_new ad_beep_mixer[] = {
+        HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_OUTPUT),
+        { } /* end */
+};
+
+#define set_beep_amp(spec, nid, idx, dir) \
+        ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */
+
 static int ad198x_build_controls(struct hda_codec *codec)
 {
         struct ad198x_spec *spec = codec->spec;
@@ -181,6 +192,21 @@ static int ad198x_build_controls(struct hda_codec *codec)
                         return err;
         }
 
+        /* create beep controls if needed */
+        if (spec->beep_amp) {
+                struct snd_kcontrol_new *knew;
+                for (knew = ad_beep_mixer; knew->name; knew++) {
+                        struct snd_kcontrol *kctl;
+                        kctl = snd_ctl_new1(knew, codec);
+                        if (!kctl)
+                                return -ENOMEM;
+                        kctl->private_value = spec->beep_amp;
+                        err = snd_hda_ctl_add(codec, kctl);
+                        if (err < 0)
+                                return err;
+                }
+        }
+
         /* if we have no master control, let's create it */
         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
                 unsigned int vmaster_tlv[4];
@@ -275,6 +301,14 @@ static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
                                              format, substream);
 }
 
+static int ad198x_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                           struct hda_codec *codec,
+                                           struct snd_pcm_substream *substream)
+{
+        struct ad198x_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
+}
+
 /*
  * Analog capture
  */
@@ -333,7 +367,8 @@ static struct hda_pcm_stream ad198x_pcm_digital_playback = {
         .ops = {
                 .open = ad198x_dig_playback_pcm_open,
                 .close = ad198x_dig_playback_pcm_close,
-                .prepare = ad198x_dig_playback_pcm_prepare
+                .prepare = ad198x_dig_playback_pcm_prepare,
+                .cleanup = ad198x_dig_playback_pcm_cleanup
         },
 };
 
@@ -397,7 +432,8 @@ static void ad198x_free(struct hda_codec *codec)
                 return;
 
         ad198x_free_kctls(codec);
-        kfree(codec->spec);
+        kfree(spec);
+        snd_hda_detach_beep_device(codec);
 }
 
 static struct hda_codec_ops ad198x_patch_ops = {
@@ -536,8 +572,6 @@ static struct snd_kcontrol_new ad1986a_mixers[] = {
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
@@ -601,8 +635,7 @@ static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
-        /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
-           HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
+        /* 
            HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
            HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
@@ -800,8 +833,6 @@ static struct snd_kcontrol_new ad1986a_laptop_automute_mixers[] = {
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x18, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x18, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
         {
@@ -993,10 +1024,8 @@ static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
         SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
         SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
-        SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_SAMSUNG),
-        SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_SAMSUNG),
-        SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_SAMSUNG),
         SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
+        SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_SAMSUNG),
         SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
         SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
         SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
@@ -1018,15 +1047,14 @@ static struct hda_amp_list ad1986a_loopbacks[] = {
 
 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
 {
-        unsigned int conf = snd_hda_codec_read(codec, nid, 0,
-                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
+        unsigned int conf = snd_hda_codec_get_pincfg(codec, nid);
         return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
 }
 
 static int patch_ad1986a(struct hda_codec *codec)
 {
         struct ad198x_spec *spec;
-        int board_config;
+        int err, board_config;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -1034,6 +1062,13 @@ static int patch_ad1986a(struct hda_codec *codec)
 
         codec->spec = spec;
 
+        err = snd_hda_attach_beep_device(codec, 0x19);
+        if (err < 0) {
+                ad198x_free(codec);
+                return err;
+        }
+        set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);
+
         spec->multiout.max_channels = 6;
         spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
         spec->multiout.dac_nids = ad1986a_dac_nids;
@@ -1213,8 +1248,6 @@ static struct snd_kcontrol_new ad1983_mixers[] = {
         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x10, 1, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x10, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
@@ -1285,6 +1318,7 @@ static struct hda_amp_list ad1983_loopbacks[] = {
 static int patch_ad1983(struct hda_codec *codec)
 {
         struct ad198x_spec *spec;
+        int err;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -1292,6 +1326,13 @@ static int patch_ad1983(struct hda_codec *codec)
 
         codec->spec = spec;
 
+        err = snd_hda_attach_beep_device(codec, 0x10);
+        if (err < 0) {
+                ad198x_free(codec);
+                return err;
+        }
+        set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
+
         spec->multiout.max_channels = 2;
         spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
         spec->multiout.dac_nids = ad1983_dac_nids;
@@ -1361,8 +1402,6 @@ static struct snd_kcontrol_new ad1981_mixers[] = {
         HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 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_MONO("PC Speaker Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x0d, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
@@ -1407,8 +1446,8 @@ static struct hda_verb ad1981_init_verbs[] = {
         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
         /* Mic boost: 0dB */
-        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         /* Record selector: Front mic */
         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
@@ -1673,10 +1712,10 @@ static struct snd_pci_quirk ad1981_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
         SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),
         /* All HP models */
-        SND_PCI_QUIRK(0x103c, 0, "HP nx", AD1981_HP),
+        SND_PCI_QUIRK_VENDOR(0x103c, "HP nx", AD1981_HP),
         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
         /* Lenovo Thinkpad T60/X60/Z6xx */
-        SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1981_THINKPAD),
+        SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1981_THINKPAD),
         /* HP nx6320 (reversed SSID, H/W bug) */
         SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
         {}
@@ -1685,7 +1724,7 @@ static struct snd_pci_quirk ad1981_cfg_tbl[] = {
 static int patch_ad1981(struct hda_codec *codec)
 {
         struct ad198x_spec *spec;
-        int board_config;
+        int err, board_config;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -1693,6 +1732,13 @@ static int patch_ad1981(struct hda_codec *codec)
 
         codec->spec = spec;
 
+        err = snd_hda_attach_beep_device(codec, 0x10);
+        if (err < 0) {
+                ad198x_free(codec);
+                return err;
+        }
+        set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);
+
         spec->multiout.max_channels = 2;
         spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
         spec->multiout.dac_nids = ad1981_dac_nids;
@@ -1885,8 +1931,8 @@ static hda_nid_t ad1988_capsrc_nids[3] = {
 #define AD1988_SPDIF_OUT_HDMI   0x0b
 #define AD1988_SPDIF_IN         0x07
 
-static hda_nid_t ad1989b_slave_dig_outs[2] = {
-        AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI
+static hda_nid_t ad1989b_slave_dig_outs[] = {
+        AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI, 0
 };
 
 static struct hda_input_mux ad1988_6stack_capture_source = {
@@ -1979,9 +2025,6 @@ static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
 
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
-
         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
 
@@ -2025,9 +2068,6 @@ static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
 
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
-
         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
 
@@ -2057,9 +2097,6 @@ static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
 
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
-
         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
 
@@ -2288,10 +2325,6 @@ static struct hda_verb ad1988_capture_init_verbs[] = {
         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
-        /* ADCs; muted */
-        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 
         { }
 };
@@ -2399,10 +2432,6 @@ static struct hda_verb ad1988_3stack_init_verbs[] = {
         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
-        /* ADCs; muted */
-        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
         /* Analog Mix output amp */
         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
         { }
@@ -2474,10 +2503,6 @@ static struct hda_verb ad1988_laptop_init_verbs[] = {
         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
-        /* ADCs; muted */
-        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
         /* Analog Mix output amp */
         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
         { }
@@ -2881,7 +2906,7 @@ static int ad1988_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = AD1988_SPDIF_IN;
@@ -2931,7 +2956,7 @@ static struct snd_pci_quirk ad1988_cfg_tbl[] = {
 static int patch_ad1988(struct hda_codec *codec)
 {
         struct ad198x_spec *spec;
-        int board_config;
+        int err, board_config;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -2951,7 +2976,7 @@ static int patch_ad1988(struct hda_codec *codec)
 
         if (board_config == AD1988_AUTO) {
                 /* automatic parse from the BIOS config */
-                int err = ad1988_parse_auto_config(codec);
+                err = ad1988_parse_auto_config(codec);
                 if (err < 0) {
                         ad198x_free(codec);
                         return err;
@@ -2961,6 +2986,13 @@ static int patch_ad1988(struct hda_codec *codec)
                 }
         }
 
+        err = snd_hda_attach_beep_device(codec, 0x10);
+        if (err < 0) {
+                ad198x_free(codec);
+                return err;
+        }
+        set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
+
         switch (board_config) {
         case AD1988_6STACK:
         case AD1988_6STACK_DIG:
@@ -3117,12 +3149,6 @@ static struct snd_kcontrol_new ad1884_base_mixers[] = {
         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
-        /*
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
-        HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Digital Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
-        */
         HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
@@ -3195,10 +3221,10 @@ static struct hda_verb ad1884_init_verbs[] = {
         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
         /* Port-B (front mic) pin */
         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         /* Port-C (rear mic) pin */
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         /* Analog mixer; mute as default */
         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
@@ -3230,8 +3256,8 @@ static const char *ad1884_slave_vols[] = {
         "Mic Playback Volume",
         "CD Playback Volume",
         "Internal Mic Playback Volume",
-        "Docking Mic Playback Volume"
-        "Beep Playback Volume",
+        "Docking Mic Playback Volume",
+        /* "Beep Playback Volume", */
         "IEC958 Playback Volume",
         NULL
 };
@@ -3239,6 +3265,7 @@ static const char *ad1884_slave_vols[] = {
 static int patch_ad1884(struct hda_codec *codec)
 {
         struct ad198x_spec *spec;
+        int err;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -3246,6 +3273,13 @@ static int patch_ad1884(struct hda_codec *codec)
 
         codec->spec = spec;
 
+        err = snd_hda_attach_beep_device(codec, 0x10);
+        if (err < 0) {
+                ad198x_free(codec);
+                return err;
+        }
+        set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
+
         spec->multiout.max_channels = 2;
         spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
         spec->multiout.dac_nids = ad1884_dac_nids;
@@ -3312,8 +3346,6 @@ static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
         HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
@@ -3349,7 +3381,7 @@ static struct hda_verb ad1984_thinkpad_init_verbs[] = {
         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
         /* docking mic boost */
-        {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
         /* Analog mixer - docking mic; mute as default */
         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
         /* enable EAPD bit */
@@ -3370,10 +3402,6 @@ static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
         HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
         HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
-        /*
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
-        */
         HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
@@ -3459,7 +3487,7 @@ static const char *ad1984_models[AD1984_MODELS] = {
 
 static struct snd_pci_quirk ad1984_cfg_tbl[] = {
         /* Lenovo Thinkpad T61/X61 */
-        SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1984_THINKPAD),
+        SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD),
         SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
         {}
 };
@@ -3552,8 +3580,6 @@ static struct snd_kcontrol_new ad1884a_base_mixers[] = {
         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
@@ -3613,10 +3639,10 @@ static struct hda_verb ad1884a_init_verbs[] = {
         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
         /* Port-B (front mic) pin */
         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         /* Port-C (rear line-in) pin */
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         /* Port-E (rear mic) pin */
         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
@@ -3686,8 +3712,6 @@ static struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT),
@@ -3715,8 +3739,6 @@ static struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
         HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x15, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
@@ -3795,6 +3817,49 @@ static struct hda_verb ad1884a_laptop_verbs[] = {
         { } /* end */
 };
 
+static struct hda_verb ad1884a_mobile_verbs[] = {
+        /* DACs; unmute as default */
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
+        /* Port-A (HP) mixer - route only from analog mixer */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        /* Port-A pin */
+        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Port-A (HP) pin - always unmuted */
+        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Port-B (mic jack) pin */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
+        /* Port-C (int mic) pin */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
+        /* Port-F (int speaker) mixer - route only from analog mixer */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        /* Port-F pin */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Analog mixer; mute as default */
+        {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
+        /* Analog Mix output amp */
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* capture sources */
+        /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* unsolicited event for pin-sense */
+        {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
+        { } /* end */
+};
+
 /*
  * Thinkpad X300
  * 0x11 - HP
@@ -3827,8 +3892,6 @@ static struct snd_kcontrol_new ad1984a_thinkpad_mixers[] = {
         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
@@ -3902,9 +3965,9 @@ static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
         SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP),
         SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
-        SND_PCI_QUIRK(0x103c, 0x30e6, "HP 6730b", AD1884A_LAPTOP),
-        SND_PCI_QUIRK(0x103c, 0x30e7, "HP EliteBook 8530p", AD1884A_LAPTOP),
-        SND_PCI_QUIRK(0x103c, 0x3614, "HP 6730s", AD1884A_LAPTOP),
+        SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x3070, "HP", AD1884A_MOBILE),
+        SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30e0, "HP laptop", AD1884A_LAPTOP),
+        SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3600, "HP laptop", AD1884A_LAPTOP),
         SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
         {}
 };
@@ -3912,7 +3975,7 @@ static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
 static int patch_ad1884a(struct hda_codec *codec)
 {
         struct ad198x_spec *spec;
-        int board_config;
+        int err, board_config;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -3920,6 +3983,13 @@ static int patch_ad1884a(struct hda_codec *codec)
 
         codec->spec = spec;
 
+        err = snd_hda_attach_beep_device(codec, 0x10);
+        if (err < 0) {
+                ad198x_free(codec);
+                return err;
+        }
+        set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
+
         spec->multiout.max_channels = 2;
         spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids);
         spec->multiout.dac_nids = ad1884a_dac_nids;
@@ -3950,13 +4020,29 @@ static int patch_ad1884a(struct hda_codec *codec)
                 spec->input_mux = &ad1884a_laptop_capture_source;
                 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
                 codec->patch_ops.init = ad1884a_hp_init;
+                /* set the upper-limit for mixer amp to 0dB for avoiding the
+                 * possible damage by overloading
+                 */
+                snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
+                                          (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
+                                          (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
+                                          (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
+                                          (1 << AC_AMPCAP_MUTE_SHIFT));
                 break;
         case AD1884A_MOBILE:
                 spec->mixers[0] = ad1884a_mobile_mixers;
-                spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
+                spec->init_verbs[0] = ad1884a_mobile_verbs;
                 spec->multiout.dig_out_nid = 0;
                 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
                 codec->patch_ops.init = ad1884a_hp_init;
+                /* set the upper-limit for mixer amp to 0dB for avoiding the
+                 * possible damage by overloading
+                 */
+                snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
+                                          (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
+                                          (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
+                                          (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
+                                          (1 << AC_AMPCAP_MUTE_SHIFT));
                 break;
         case AD1884A_THINKPAD:
                 spec->mixers[0] = ad1984a_thinkpad_mixers;
@@ -4074,8 +4160,6 @@ static struct snd_kcontrol_new ad1882_loopback_mixers[] = {
         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x07, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x07, HDA_INPUT),
         { } /* end */
 };
 
@@ -4088,8 +4172,6 @@ static struct snd_kcontrol_new ad1882a_loopback_mixers[] = {
         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x07, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x07, HDA_INPUT),
         HDA_CODEC_VOLUME("Digital Mic Boost", 0x1f, 0x0, HDA_INPUT),
         { } /* end */
 };
@@ -4248,7 +4330,7 @@ static const char *ad1882_models[AD1986A_MODELS] = {
 static int patch_ad1882(struct hda_codec *codec)
 {
         struct ad198x_spec *spec;
-        int board_config;
+        int err, board_config;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -4256,6 +4338,13 @@ static int patch_ad1882(struct hda_codec *codec)
 
         codec->spec = spec;
 
+        err = snd_hda_attach_beep_device(codec, 0x10);
+        if (err < 0) {
+                ad198x_free(codec);
+                return err;
+        }
+        set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
+
         spec->multiout.max_channels = 6;
         spec->multiout.num_dacs = 3;
         spec->multiout.dac_nids = ad1882_dac_nids;
diff --git a/sound/pci/hda/patch_cmedia.c b/sound/pci/hda/patch_cmedia.c
index f3ebe837f2d5..c921264bbd71 100644
--- a/sound/pci/hda/patch_cmedia.c
+++ b/sound/pci/hda/patch_cmedia.c
@@ -680,13 +680,13 @@ static int patch_cmi9880(struct hda_codec *codec)
                 struct auto_pin_cfg cfg;
 
                 /* collect pin default configuration */
-                port_e = snd_hda_codec_read(codec, 0x0f, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
-                port_f = snd_hda_codec_read(codec, 0x10, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
+                port_e = snd_hda_codec_get_pincfg(codec, 0x0f);
+                port_f = snd_hda_codec_get_pincfg(codec, 0x10);
                 spec->front_panel = 1;
                 if (get_defcfg_connect(port_e) == AC_JACK_PORT_NONE ||
                     get_defcfg_connect(port_f) == AC_JACK_PORT_NONE) {
-                        port_g = snd_hda_codec_read(codec, 0x1f, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
-                        port_h = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
+                        port_g = snd_hda_codec_get_pincfg(codec, 0x1f);
+                        port_h = snd_hda_codec_get_pincfg(codec, 0x20);
                         spec->channel_modes = cmi9880_channel_modes;
                         /* no front panel */
                         if (get_defcfg_connect(port_g) == AC_JACK_PORT_NONE ||
@@ -703,8 +703,8 @@ static int patch_cmi9880(struct hda_codec *codec)
                         spec->multiout.max_channels = cmi9880_channel_modes[0].channels;
                 } else {
                         spec->input_mux = &cmi9880_basic_mux;
-                        port_spdifi = snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
-                        port_spdifo = snd_hda_codec_read(codec, 0x12, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
+                        port_spdifi = snd_hda_codec_get_pincfg(codec, 0x13);
+                        port_spdifo = snd_hda_codec_get_pincfg(codec, 0x12);
                         if (get_defcfg_connect(port_spdifo) != AC_JACK_PORT_NONE)
                                 spec->multiout.dig_out_nid = CMI_DIG_OUT_NID;
                         if (get_defcfg_connect(port_spdifi) != AC_JACK_PORT_NONE)
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index 75de40aaab0a..56ce19e68cb5 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -58,6 +58,7 @@ struct conexant_spec {
 
         struct snd_kcontrol_new *mixers[5];
         int num_mixers;
+        hda_nid_t vmaster_nid;
 
         const struct hda_verb *init_verbs[5];   /* initialization verbs
                                                  * don't forget NULL
@@ -72,6 +73,7 @@ struct conexant_spec {
                                          */
         unsigned int cur_eapd;
         unsigned int hp_present;
+        unsigned int no_auto_mic;
         unsigned int need_dac_fix;
 
         /* capture */
@@ -347,12 +349,21 @@ static int conexant_mux_enum_put(struct snd_kcontrol *kcontrol,
                                      &spec->cur_mux[adc_idx]);
 }
 
+#ifdef CONFIG_SND_JACK
+static void conexant_free_jack_priv(struct snd_jack *jack)
+{
+        struct conexant_jack *jacks = jack->private_data;
+        jacks->nid = 0;
+        jacks->jack = NULL;
+}
+
 static int conexant_add_jack(struct hda_codec *codec,
                 hda_nid_t nid, int type)
 {
         struct conexant_spec *spec;
         struct conexant_jack *jack;
         const char *name;
+        int err;
 
         spec = codec->spec;
         snd_array_init(&spec->jacks, sizeof(*jack), 32);
@@ -365,7 +376,12 @@ static int conexant_add_jack(struct hda_codec *codec,
         jack->nid = nid;
         jack->type = type;
 
-        return snd_jack_new(codec->bus->card, name, type, &jack->jack);
+        err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
+        if (err < 0)
+                return err;
+        jack->jack->private_data = jack;
+        jack->jack->private_free = conexant_free_jack_priv;
+        return 0;
 }
 
 static void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid)
@@ -394,7 +410,6 @@ static void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid)
 
 static int conexant_init_jacks(struct hda_codec *codec)
 {
-#ifdef CONFIG_SND_JACK
         struct conexant_spec *spec = codec->spec;
         int i;
 
@@ -422,10 +437,19 @@ static int conexant_init_jacks(struct hda_codec *codec)
                         ++hv;
                 }
         }
-#endif
         return 0;
 
 }
+#else
+static inline void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid)
+{
+}
+
+static inline int conexant_init_jacks(struct hda_codec *codec)
+{
+        return 0;
+}
+#endif
 
 static int conexant_init(struct hda_codec *codec)
 {
@@ -444,14 +468,39 @@ static void conexant_free(struct hda_codec *codec)
         if (spec->jacks.list) {
                 struct conexant_jack *jacks = spec->jacks.list;
                 int i;
-                for (i = 0; i < spec->jacks.used; i++)
-                        snd_device_free(codec->bus->card, &jacks[i].jack);
+                for (i = 0; i < spec->jacks.used; i++, jacks++) {
+                        if (jacks->jack)
+                                snd_device_free(codec->bus->card, jacks->jack);
+                }
                 snd_array_free(&spec->jacks);
         }
 #endif
         kfree(codec->spec);
 }
 
+static struct snd_kcontrol_new cxt_capture_mixers[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .info = conexant_mux_enum_info,
+                .get = conexant_mux_enum_get,
+                .put = conexant_mux_enum_put
+        },
+        {}
+};
+
+static const char *slave_vols[] = {
+        "Headphone Playback Volume",
+        "Speaker Playback Volume",
+        NULL
+};
+
+static const char *slave_sws[] = {
+        "Headphone Playback Switch",
+        "Speaker Playback Switch",
+        NULL
+};
+
 static int conexant_build_controls(struct hda_codec *codec)
 {
         struct conexant_spec *spec = codec->spec;
@@ -479,6 +528,32 @@ static int conexant_build_controls(struct hda_codec *codec)
                 if (err < 0)
                         return err;
         }
+
+        /* if we have no master control, let's create it */
+        if (spec->vmaster_nid &&
+            !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
+                unsigned int vmaster_tlv[4];
+                snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
+                                        HDA_OUTPUT, vmaster_tlv);
+                err = snd_hda_add_vmaster(codec, "Master Playback Volume",
+                                          vmaster_tlv, slave_vols);
+                if (err < 0)
+                        return err;
+        }
+        if (spec->vmaster_nid &&
+            !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
+                err = snd_hda_add_vmaster(codec, "Master Playback Switch",
+                                          NULL, slave_sws);
+                if (err < 0)
+                        return err;
+        }
+
+        if (spec->input_mux) {
+                err = snd_hda_add_new_ctls(codec, cxt_capture_mixers);
+                if (err < 0)
+                        return err;
+        }
+
         return 0;
 }
 
@@ -710,13 +785,6 @@ static void cxt5045_hp_unsol_event(struct hda_codec *codec,
 }
 
 static struct snd_kcontrol_new cxt5045_mixers[] = {
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Capture Source",
-                .info = conexant_mux_enum_info,
-                .get = conexant_mux_enum_get,
-                .put = conexant_mux_enum_put
-        },
         HDA_CODEC_VOLUME("Int Mic Capture Volume", 0x1a, 0x01, HDA_INPUT),
         HDA_CODEC_MUTE("Int Mic Capture Switch", 0x1a, 0x01, HDA_INPUT),
         HDA_CODEC_VOLUME("Ext Mic Capture Volume", 0x1a, 0x02, HDA_INPUT),
@@ -750,13 +818,6 @@ static struct snd_kcontrol_new cxt5045_benq_mixers[] = {
 };
 
 static struct snd_kcontrol_new cxt5045_mixers_hp530[] = {
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Capture Source",
-                .info = conexant_mux_enum_info,
-                .get = conexant_mux_enum_get,
-                .put = conexant_mux_enum_put
-        },
         HDA_CODEC_VOLUME("Int Mic Capture Volume", 0x1a, 0x02, HDA_INPUT),
         HDA_CODEC_MUTE("Int Mic Capture Switch", 0x1a, 0x02, HDA_INPUT),
         HDA_CODEC_VOLUME("Ext Mic Capture Volume", 0x1a, 0x01, HDA_INPUT),
@@ -993,15 +1054,9 @@ static const char *cxt5045_models[CXT5045_MODELS] = {
 };
 
 static struct snd_pci_quirk cxt5045_cfg_tbl[] = {
-        SND_PCI_QUIRK(0x103c, 0x30a5, "HP", CXT5045_LAPTOP_HPSENSE),
-        SND_PCI_QUIRK(0x103c, 0x30b2, "HP DV Series", CXT5045_LAPTOP_HPSENSE),
-        SND_PCI_QUIRK(0x103c, 0x30b5, "HP DV2120", CXT5045_LAPTOP_HPSENSE),
-        SND_PCI_QUIRK(0x103c, 0x30b7, "HP DV6000Z", CXT5045_LAPTOP_HPSENSE),
-        SND_PCI_QUIRK(0x103c, 0x30bb, "HP DV8000", CXT5045_LAPTOP_HPSENSE),
-        SND_PCI_QUIRK(0x103c, 0x30cd, "HP DV Series", CXT5045_LAPTOP_HPSENSE),
-        SND_PCI_QUIRK(0x103c, 0x30cf, "HP DV9533EG", CXT5045_LAPTOP_HPSENSE),
         SND_PCI_QUIRK(0x103c, 0x30d5, "HP 530", CXT5045_LAPTOP_HP530),
-        SND_PCI_QUIRK(0x103c, 0x30d9, "HP Spartan", CXT5045_LAPTOP_HPSENSE),
+        SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP DV Series",
+                           CXT5045_LAPTOP_HPSENSE),
         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P105", CXT5045_LAPTOP_MICSENSE),
         SND_PCI_QUIRK(0x152d, 0x0753, "Benq R55E", CXT5045_BENQ),
         SND_PCI_QUIRK(0x1734, 0x10ad, "Fujitsu Si1520", CXT5045_LAPTOP_MICSENSE),
@@ -1011,8 +1066,8 @@ static struct snd_pci_quirk cxt5045_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1509, 0x1e40, "FIC", CXT5045_LAPTOP_HPMICSENSE),
         SND_PCI_QUIRK(0x1509, 0x2f05, "FIC", CXT5045_LAPTOP_HPMICSENSE),
         SND_PCI_QUIRK(0x1509, 0x2f06, "FIC", CXT5045_LAPTOP_HPMICSENSE),
-        SND_PCI_QUIRK(0x1631, 0xc106, "Packard Bell", CXT5045_LAPTOP_HPMICSENSE),
-        SND_PCI_QUIRK(0x1631, 0xc107, "Packard Bell", CXT5045_LAPTOP_HPMICSENSE),
+        SND_PCI_QUIRK_MASK(0x1631, 0xff00, 0xc100, "Packard Bell",
+                           CXT5045_LAPTOP_HPMICSENSE),
         SND_PCI_QUIRK(0x8086, 0x2111, "Conexant Reference board", CXT5045_LAPTOP_HPSENSE),
         {}
 };
@@ -1026,6 +1081,7 @@ static int patch_cxt5045(struct hda_codec *codec)
         if (!spec)
                 return -ENOMEM;
         codec->spec = spec;
+        codec->pin_amp_workaround = 1;
 
         spec->multiout.max_channels = 2;
         spec->multiout.num_dacs = ARRAY_SIZE(cxt5045_dac_nids);
@@ -1125,7 +1181,7 @@ static int patch_cxt5045(struct hda_codec *codec)
 /* Conexant 5047 specific */
 #define CXT5047_SPDIF_OUT       0x11
 
-static hda_nid_t cxt5047_dac_nids[2] = { 0x10, 0x1c };
+static hda_nid_t cxt5047_dac_nids[1] = { 0x10 }; /* 0x1c */
 static hda_nid_t cxt5047_adc_nids[1] = { 0x12 };
 static hda_nid_t cxt5047_capsrc_nids[1] = { 0x1a };
 
@@ -1133,20 +1189,6 @@ static struct hda_channel_mode cxt5047_modes[1] = {
         { 2, NULL },
 };
 
-static struct hda_input_mux cxt5047_capture_source = {
-        .num_items = 1,
-        .items = {
-                { "Mic", 0x2 },
-        }
-};
-
-static struct hda_input_mux cxt5047_hp_capture_source = {
-        .num_items = 1,
-        .items = {
-                { "ExtMic", 0x2 },
-        }
-};
-
 static struct hda_input_mux cxt5047_toshiba_capture_source = {
         .num_items = 2,
         .items = {
@@ -1170,7 +1212,11 @@ static int cxt5047_hp_master_sw_put(struct snd_kcontrol *kcontrol,
          * the headphone jack
          */
         bits = (!spec->hp_present && spec->cur_eapd) ? 0 : HDA_AMP_MUTE;
-        snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0,
+        /* NOTE: Conexat codec needs the index for *OUTPUT* amp of
+         * pin widgets unlike other codecs.  In this case, we need to
+         * set index 0x01 for the volume from the mixer amp 0x19.
+         */
+        snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0x01,
                                  HDA_AMP_MUTE, bits);
         bits = spec->cur_eapd ? 0 : HDA_AMP_MUTE;
         snd_hda_codec_amp_stereo(codec, 0x13, HDA_OUTPUT, 0,
@@ -1178,16 +1224,6 @@ static int cxt5047_hp_master_sw_put(struct snd_kcontrol *kcontrol,
         return 1;
 }
 
-/* bind volumes of both NID 0x13 (Headphones) and 0x1d (Speakers) */
-static struct hda_bind_ctls cxt5047_bind_master_vol = {
-        .ops = &snd_hda_bind_vol,
-        .values = {
-                HDA_COMPOSE_AMP_VAL(0x13, 3, 0, HDA_OUTPUT),
-                HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
-                0
-        },
-};
-
 /* mute internal speaker if HP is plugged */
 static void cxt5047_hp_automute(struct hda_codec *codec)
 {
@@ -1198,27 +1234,8 @@ static void cxt5047_hp_automute(struct hda_codec *codec)
                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 
         bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-        /* Mute/Unmute PCM 2 for good measure - some systems need this */
-        snd_hda_codec_amp_stereo(codec, 0x1c, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-/* mute internal speaker if HP is plugged */
-static void cxt5047_hp2_automute(struct hda_codec *codec)
-{
-        struct conexant_spec *spec = codec->spec;
-        unsigned int bits;
-
-        spec->hp_present = snd_hda_codec_read(codec, 0x13, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-
-        bits = spec->hp_present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-        /* Mute/Unmute PCM 2 for good measure - some systems need this */
-        snd_hda_codec_amp_stereo(codec, 0x1c, HDA_OUTPUT, 0,
+        /* See the note in cxt5047_hp_master_sw_put */
+        snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0x01,
                                  HDA_AMP_MUTE, bits);
 }
 
@@ -1259,55 +1276,14 @@ static void cxt5047_hp_unsol_event(struct hda_codec *codec,
         }
 }
 
-/* unsolicited event for HP jack sensing - non-EAPD systems */
-static void cxt5047_hp2_unsol_event(struct hda_codec *codec,
-                                  unsigned int res)
-{
-        res >>= 26;
-        switch (res) {
-        case CONEXANT_HP_EVENT:
-                cxt5047_hp2_automute(codec);
-                break;
-        case CONEXANT_MIC_EVENT:
-                cxt5047_hp_automic(codec);
-                break;
-        }
-}
-
-static struct snd_kcontrol_new cxt5047_mixers[] = {
-        HDA_CODEC_VOLUME("Mic Bypass Capture Volume", 0x19, 0x02, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Bypass Capture Switch", 0x19, 0x02, HDA_INPUT),
-        HDA_CODEC_VOLUME("Mic Gain Volume", 0x1a, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Mic Gain Switch", 0x1a, 0x0, HDA_OUTPUT),
+static struct snd_kcontrol_new cxt5047_base_mixers[] = {
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x19, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x19, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x1a, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x03, HDA_INPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x03, HDA_INPUT),
         HDA_CODEC_VOLUME("PCM Volume", 0x10, 0x00, HDA_OUTPUT),
         HDA_CODEC_MUTE("PCM Switch", 0x10, 0x00, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("PCM-2 Volume", 0x1c, 0x00, HDA_OUTPUT),
-        HDA_CODEC_MUTE("PCM-2 Switch", 0x1c, 0x00, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x00, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Speaker Playback Switch", 0x1d, 0x00, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x13, 0x00, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Headphone Playback Switch", 0x13, 0x00, HDA_OUTPUT),
-
-        {}
-};
-
-static struct snd_kcontrol_new cxt5047_toshiba_mixers[] = {
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Capture Source",
-                .info = conexant_mux_enum_info,
-                .get = conexant_mux_enum_get,
-                .put = conexant_mux_enum_put
-        },
-        HDA_CODEC_VOLUME("Mic Bypass Capture Volume", 0x19, 0x02, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Bypass Capture Switch", 0x19, 0x02, HDA_INPUT),
-        HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x03, HDA_INPUT),
-        HDA_CODEC_MUTE("Capture Switch", 0x12, 0x03, HDA_INPUT),
-        HDA_CODEC_VOLUME("PCM Volume", 0x10, 0x00, HDA_OUTPUT),
-        HDA_CODEC_MUTE("PCM Switch", 0x10, 0x00, HDA_OUTPUT),
-        HDA_BIND_VOL("Master Playback Volume", &cxt5047_bind_master_vol),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
@@ -1320,29 +1296,15 @@ static struct snd_kcontrol_new cxt5047_toshiba_mixers[] = {
         {}
 };
 
-static struct snd_kcontrol_new cxt5047_hp_mixers[] = {
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Capture Source",
-                .info = conexant_mux_enum_info,
-                .get = conexant_mux_enum_get,
-                .put = conexant_mux_enum_put
-        },
-        HDA_CODEC_VOLUME("Mic Bypass Capture Volume", 0x19, 0x02, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Bypass Capture Switch", 0x19,0x02,HDA_INPUT),
-        HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x03, HDA_INPUT),
-        HDA_CODEC_MUTE("Capture Switch", 0x12, 0x03, HDA_INPUT),
-        HDA_CODEC_VOLUME("PCM Volume", 0x10, 0x00, HDA_OUTPUT),
-        HDA_CODEC_MUTE("PCM Switch", 0x10, 0x00, HDA_OUTPUT),
+static struct snd_kcontrol_new cxt5047_hp_spk_mixers[] = {
+        /* See the note in cxt5047_hp_master_sw_put */
+        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x01, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x13, 0x00, HDA_OUTPUT),
+        {}
+};
+
+static struct snd_kcontrol_new cxt5047_hp_only_mixers[] = {
         HDA_CODEC_VOLUME("Master Playback Volume", 0x13, 0x00, HDA_OUTPUT),
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Master Playback Switch",
-                .info = cxt_eapd_info,
-                .get = cxt_eapd_get,
-                .put = cxt5047_hp_master_sw_put,
-                .private_value = 0x13,
-        },
         { } /* end */
 };
 
@@ -1353,8 +1315,8 @@ static struct hda_verb cxt5047_init_verbs[] = {
         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_50 },
         /* HP, Speaker  */
         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
-        {0x13, AC_VERB_SET_CONNECT_SEL,0x1},
-        {0x1d, AC_VERB_SET_CONNECT_SEL,0x0},
+        {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, /* mixer(0x19) */
+        {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mixer(0x19) */
         /* Record selector: Mic */
         {0x12, AC_VERB_SET_CONNECT_SEL,0x03},
         {0x19, AC_VERB_SET_AMP_GAIN_MUTE,
@@ -1374,30 +1336,7 @@ static struct hda_verb cxt5047_init_verbs[] = {
 
 /* configuration for Toshiba Laptops */
 static struct hda_verb cxt5047_toshiba_init_verbs[] = {
-        {0x13, AC_VERB_SET_EAPD_BTLENABLE, 0x0 }, /* default on */
-        /* pin sensing on HP and Mic jacks */
-        {0x13, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
-        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
-        /* Speaker routing */
-        {0x1d, AC_VERB_SET_CONNECT_SEL,0x1},
-        {}
-};
-
-/* configuration for HP Laptops */
-static struct hda_verb cxt5047_hp_init_verbs[] = {
-        /* pin sensing on HP jack */
-        {0x13, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
-        /* 0x13 is actually shared by both HP and speaker;
-         * setting the connection to 0 (=0x19) makes the master volume control
-         * working mysteriouslly...
-         */
-        {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
-        /* Record selector: Ext Mic */
-        {0x12, AC_VERB_SET_CONNECT_SEL,0x03},
-        {0x19, AC_VERB_SET_AMP_GAIN_MUTE,
-         AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
-        /* Speaker routing */
-        {0x1d, AC_VERB_SET_CONNECT_SEL,0x1},
+        {0x13, AC_VERB_SET_EAPD_BTLENABLE, 0x0}, /* default off */
         {}
 };
 
@@ -1562,10 +1501,9 @@ static const char *cxt5047_models[CXT5047_MODELS] = {
 };
 
 static struct snd_pci_quirk cxt5047_cfg_tbl[] = {
-        SND_PCI_QUIRK(0x103c, 0x30a0, "HP DV1000", CXT5047_LAPTOP),
         SND_PCI_QUIRK(0x103c, 0x30a5, "HP DV5200T/DV8000T", CXT5047_LAPTOP_HP),
-        SND_PCI_QUIRK(0x103c, 0x30b2, "HP DV2000T/DV3000T", CXT5047_LAPTOP),
-        SND_PCI_QUIRK(0x103c, 0x30b5, "HP DV2000Z", CXT5047_LAPTOP),
+        SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP DV Series",
+                           CXT5047_LAPTOP),
         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P100", CXT5047_LAPTOP_EAPD),
         {}
 };
@@ -1579,6 +1517,7 @@ static int patch_cxt5047(struct hda_codec *codec)
         if (!spec)
                 return -ENOMEM;
         codec->spec = spec;
+        codec->pin_amp_workaround = 1;
 
         spec->multiout.max_channels = 2;
         spec->multiout.num_dacs = ARRAY_SIZE(cxt5047_dac_nids);
@@ -1587,9 +1526,8 @@ static int patch_cxt5047(struct hda_codec *codec)
         spec->num_adc_nids = 1;
         spec->adc_nids = cxt5047_adc_nids;
         spec->capsrc_nids = cxt5047_capsrc_nids;
-        spec->input_mux = &cxt5047_capture_source;
         spec->num_mixers = 1;
-        spec->mixers[0] = cxt5047_mixers;
+        spec->mixers[0] = cxt5047_base_mixers;
         spec->num_init_verbs = 1;
         spec->init_verbs[0] = cxt5047_init_verbs;
         spec->spdif_route = 0;
@@ -1603,21 +1541,22 @@ static int patch_cxt5047(struct hda_codec *codec)
                                                   cxt5047_cfg_tbl);
         switch (board_config) {
         case CXT5047_LAPTOP:
-                codec->patch_ops.unsol_event = cxt5047_hp2_unsol_event;
+                spec->num_mixers = 2;
+                spec->mixers[1] = cxt5047_hp_spk_mixers;
+                codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
                 break;
         case CXT5047_LAPTOP_HP:
-                spec->input_mux = &cxt5047_hp_capture_source;
-                spec->num_init_verbs = 2;
-                spec->init_verbs[1] = cxt5047_hp_init_verbs;
-                spec->mixers[0] = cxt5047_hp_mixers;
+                spec->num_mixers = 2;
+                spec->mixers[1] = cxt5047_hp_only_mixers;
                 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
                 codec->patch_ops.init = cxt5047_hp_init;
                 break;
         case CXT5047_LAPTOP_EAPD:
                 spec->input_mux = &cxt5047_toshiba_capture_source;
+                spec->num_mixers = 2;
+                spec->mixers[1] = cxt5047_hp_spk_mixers;
                 spec->num_init_verbs = 2;
                 spec->init_verbs[1] = cxt5047_toshiba_init_verbs;
-                spec->mixers[0] = cxt5047_toshiba_mixers;
                 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
                 break;
 #ifdef CONFIG_SND_DEBUG
@@ -1628,6 +1567,7 @@ static int patch_cxt5047(struct hda_codec *codec)
                 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
 #endif  
         }
+        spec->vmaster_nid = 0x13;
         return 0;
 }
 
@@ -1663,8 +1603,11 @@ static int cxt5051_hp_master_sw_put(struct snd_kcontrol *kcontrol,
 /* toggle input of built-in and mic jack appropriately */
 static void cxt5051_portb_automic(struct hda_codec *codec)
 {
+        struct conexant_spec *spec = codec->spec;
         unsigned int present;
 
+        if (spec->no_auto_mic)
+                return;
         present = snd_hda_codec_read(codec, 0x17, 0,
                                      AC_VERB_GET_PIN_SENSE, 0) &
                 AC_PINSENSE_PRESENCE;
@@ -1680,6 +1623,8 @@ static void cxt5051_portc_automic(struct hda_codec *codec)
         unsigned int present;
         hda_nid_t new_adc;
 
+        if (spec->no_auto_mic)
+                return;
         present = snd_hda_codec_read(codec, 0x18, 0,
                                      AC_VERB_GET_PIN_SENSE, 0) &
                 AC_PINSENSE_PRESENCE;
@@ -1766,6 +1711,22 @@ static struct snd_kcontrol_new cxt5051_hp_mixers[] = {
         {}
 };
 
+static struct snd_kcontrol_new cxt5051_hp_dv6736_mixers[] = {
+        HDA_CODEC_VOLUME("Mic Volume", 0x14, 0x00, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Switch", 0x14, 0x00, HDA_INPUT),
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Switch",
+                .info = cxt_eapd_info,
+                .get = cxt_eapd_get,
+                .put = cxt5051_hp_master_sw_put,
+                .private_value = 0x1a,
+        },
+
+        {}
+};
+
 static struct hda_verb cxt5051_init_verbs[] = {
         /* Line in, Mic */
         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
@@ -1796,6 +1757,66 @@ static struct hda_verb cxt5051_init_verbs[] = {
         { } /* end */
 };
 
+static struct hda_verb cxt5051_hp_dv6736_init_verbs[] = {
+        /* Line in, Mic */
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
+        {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
+        /* SPK  */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* HP, Amp  */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* DAC1 */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Record selector: Int mic */
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x1},
+        /* SPDIF route: PCM */
+        {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
+        /* EAPD */
+        {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
+        {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
+        {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTB_EVENT},
+        { } /* end */
+};
+
+static struct hda_verb cxt5051_lenovo_x200_init_verbs[] = {
+        /* Line in, Mic */
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
+        /* SPK  */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* HP, Amp  */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* Docking HP */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x19, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* DAC1 */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Record selector: Int mic */
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
+        /* SPDIF route: PCM */
+        {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
+        /* EAPD */
+        {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
+        {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
+        {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTB_EVENT},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTC_EVENT},
+        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
+        { } /* end */
+};
+
 /* initialize jack-sensing, too */
 static int cxt5051_init(struct hda_codec *codec)
 {
@@ -1813,18 +1834,24 @@ static int cxt5051_init(struct hda_codec *codec)
 enum {
         CXT5051_LAPTOP,  /* Laptops w/ EAPD support */
         CXT5051_HP,     /* no docking */
+        CXT5051_HP_DV6736,      /* HP without mic switch */
+        CXT5051_LENOVO_X200,    /* Lenovo X200 laptop */
         CXT5051_MODELS
 };
 
 static const char *cxt5051_models[CXT5051_MODELS] = {
         [CXT5051_LAPTOP]        = "laptop",
         [CXT5051_HP]            = "hp",
+        [CXT5051_HP_DV6736]     = "hp-dv6736",
+        [CXT5051_LENOVO_X200]   = "lenovo-x200",
 };
 
 static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x103c, 0x30cf, "HP DV6736", CXT5051_HP_DV6736),
         SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board",
                       CXT5051_LAPTOP),
         SND_PCI_QUIRK(0x14f1, 0x5051, "HP Spartan 1.1", CXT5051_HP),
+        SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo X200", CXT5051_LENOVO_X200),
         {}
 };
 
@@ -1837,6 +1864,7 @@ static int patch_cxt5051(struct hda_codec *codec)
         if (!spec)
                 return -ENOMEM;
         codec->spec = spec;
+        codec->pin_amp_workaround = 1;
 
         codec->patch_ops = conexant_patch_ops;
         codec->patch_ops.init = cxt5051_init;
@@ -1857,17 +1885,22 @@ static int patch_cxt5051(struct hda_codec *codec)
         spec->cur_adc = 0;
         spec->cur_adc_idx = 0;
 
+        codec->patch_ops.unsol_event = cxt5051_hp_unsol_event;
+
         board_config = snd_hda_check_board_config(codec, CXT5051_MODELS,
                                                   cxt5051_models,
                                                   cxt5051_cfg_tbl);
         switch (board_config) {
         case CXT5051_HP:
-                codec->patch_ops.unsol_event = cxt5051_hp_unsol_event;
                 spec->mixers[0] = cxt5051_hp_mixers;
                 break;
-        default:
-        case CXT5051_LAPTOP:
-                codec->patch_ops.unsol_event = cxt5051_hp_unsol_event;
+        case CXT5051_HP_DV6736:
+                spec->init_verbs[0] = cxt5051_hp_dv6736_init_verbs;
+                spec->mixers[0] = cxt5051_hp_dv6736_mixers;
+                spec->no_auto_mic = 1;
+                break;
+        case CXT5051_LENOVO_X200:
+                spec->init_verbs[0] = cxt5051_lenovo_x200_init_verbs;
                 break;
         }
 
diff --git a/sound/pci/hda/patch_intelhdmi.c b/sound/pci/hda/patch_intelhdmi.c
index 3564f4e4b74c..fcc77fec4487 100644
--- a/sound/pci/hda/patch_intelhdmi.c
+++ b/sound/pci/hda/patch_intelhdmi.c
@@ -49,11 +49,6 @@ static struct hda_verb pinout_enable_verb[] = {
         {} /* terminator */
 };
 
-static struct hda_verb pinout_disable_verb[] = {
-        {PIN_NID, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00},
-        {}
-};
-
 static struct hda_verb unsolicited_response_verb[] = {
         {PIN_NID, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN |
                                                   INTEL_HDMI_EVENT_TAG},
@@ -248,10 +243,6 @@ static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t nid,
 
 static void hdmi_enable_output(struct hda_codec *codec)
 {
-        /* Enable Audio InfoFrame Transmission */
-        hdmi_set_dip_index(codec, PIN_NID, 0x0, 0x0);
-        snd_hda_codec_write(codec, PIN_NID, 0, AC_VERB_SET_HDMI_DIP_XMIT,
-                                                AC_DIPXMIT_BEST);
         /* Unmute */
         if (get_wcaps(codec, PIN_NID) & AC_WCAP_OUT_AMP)
                 snd_hda_codec_write(codec, PIN_NID, 0,
@@ -260,17 +251,24 @@ static void hdmi_enable_output(struct hda_codec *codec)
         snd_hda_sequence_write(codec, pinout_enable_verb);
 }
 
-static void hdmi_disable_output(struct hda_codec *codec)
+/*
+ * Enable Audio InfoFrame Transmission
+ */
+static void hdmi_start_infoframe_trans(struct hda_codec *codec)
 {
-        snd_hda_sequence_write(codec, pinout_disable_verb);
-        if (get_wcaps(codec, PIN_NID) & AC_WCAP_OUT_AMP)
-                snd_hda_codec_write(codec, PIN_NID, 0,
-                                AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
+        hdmi_set_dip_index(codec, PIN_NID, 0x0, 0x0);
+        snd_hda_codec_write(codec, PIN_NID, 0, AC_VERB_SET_HDMI_DIP_XMIT,
+                                                AC_DIPXMIT_BEST);
+}
 
-        /*
-         * FIXME: noises may arise when playing music after reloading the
-         * kernel module, until the next X restart or monitor repower.
-         */
+/*
+ * Disable Audio InfoFrame Transmission
+ */
+static void hdmi_stop_infoframe_trans(struct hda_codec *codec)
+{
+        hdmi_set_dip_index(codec, PIN_NID, 0x0, 0x0);
+        snd_hda_codec_write(codec, PIN_NID, 0, AC_VERB_SET_HDMI_DIP_XMIT,
+                                                AC_DIPXMIT_DISABLE);
 }
 
 static int hdmi_get_channel_count(struct hda_codec *codec)
@@ -368,11 +366,16 @@ static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
                                         struct hdmi_audio_infoframe *ai)
 {
         u8 *params = (u8 *)ai;
+        u8 sum = 0;
         int i;
 
         hdmi_debug_dip_size(codec);
         hdmi_clear_dip_buffers(codec); /* be paranoid */
 
+        for (i = 0; i < sizeof(ai); i++)
+                sum += params[i];
+        ai->checksum = - sum;
+
         hdmi_set_dip_index(codec, PIN_NID, 0x0, 0x0);
         for (i = 0; i < sizeof(ai); i++)
                 hdmi_write_dip_byte(codec, PIN_NID, params[i]);
@@ -419,14 +422,18 @@ static int hdmi_setup_channel_allocation(struct hda_codec *codec,
         /*
          * CA defaults to 0 for basic stereo audio
          */
-        if (!eld->eld_ver)
-                return 0;
-        if (!eld->spk_alloc)
-                return 0;
         if (channels <= 2)
                 return 0;
 
         /*
+         * HDMI sink's ELD info cannot always be retrieved for now, e.g.
+         * in console or for audio devices. Assume the highest speakers
+         * configuration, to _not_ prohibit multi-channel audio playback.
+         */
+        if (!eld->spk_alloc)
+                eld->spk_alloc = 0xffff;
+
+        /*
          * expand ELD's speaker allocation mask
          *
          * ELD tells the speaker mask in a compact(paired) form,
@@ -485,6 +492,7 @@ static void hdmi_setup_audio_infoframe(struct hda_codec *codec,
         hdmi_setup_channel_mapping(codec, &ai);
 
         hdmi_fill_audio_infoframe(codec, &ai);
+        hdmi_start_infoframe_trans(codec);
 }
 
 
@@ -562,7 +570,7 @@ static int intel_hdmi_playback_pcm_close(struct hda_pcm_stream *hinfo,
 {
         struct intel_hdmi_spec *spec = codec->spec;
 
-        hdmi_disable_output(codec);
+        hdmi_stop_infoframe_trans(codec);
 
         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 }
@@ -582,8 +590,6 @@ static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 
         hdmi_setup_audio_infoframe(codec, substream);
 
-        hdmi_enable_output(codec);
-
         return 0;
 }
 
@@ -628,8 +634,7 @@ static int intel_hdmi_build_controls(struct hda_codec *codec)
 
 static int intel_hdmi_init(struct hda_codec *codec)
 {
-        /* disable audio output as early as possible */
-        hdmi_disable_output(codec);
+        hdmi_enable_output(codec);
 
         snd_hda_sequence_write(codec, unsolicited_response_verb);
 
@@ -679,6 +684,7 @@ static struct hda_codec_preset snd_hda_preset_intelhdmi[] = {
         { .id = 0x80862801, .name = "G45 DEVBLC", .patch = patch_intel_hdmi },
         { .id = 0x80862802, .name = "G45 DEVCTG", .patch = patch_intel_hdmi },
         { .id = 0x80862803, .name = "G45 DEVELK", .patch = patch_intel_hdmi },
+        { .id = 0x80862804, .name = "G45 DEVIBX", .patch = patch_intel_hdmi },
         { .id = 0x10951392, .name = "SiI1392 HDMI",     .patch = patch_intel_hdmi },
         {} /* terminator */
 };
@@ -687,6 +693,7 @@ MODULE_ALIAS("snd-hda-codec-id:808629fb");
 MODULE_ALIAS("snd-hda-codec-id:80862801");
 MODULE_ALIAS("snd-hda-codec-id:80862802");
 MODULE_ALIAS("snd-hda-codec-id:80862803");
+MODULE_ALIAS("snd-hda-codec-id:80862804");
 MODULE_ALIAS("snd-hda-codec-id:10951392");
 
 MODULE_LICENSE("GPL");
diff --git a/sound/pci/hda/patch_nvhdmi.c b/sound/pci/hda/patch_nvhdmi.c
index 96952a37d884..d57d8132a06e 100644
--- a/sound/pci/hda/patch_nvhdmi.c
+++ b/sound/pci/hda/patch_nvhdmi.c
@@ -160,6 +160,7 @@ static int patch_nvhdmi(struct hda_codec *codec)
  */
 static struct hda_codec_preset snd_hda_preset_nvhdmi[] = {
         { .id = 0x10de0002, .name = "MCP78 HDMI", .patch = patch_nvhdmi },
+        { .id = 0x10de0006, .name = "MCP78 HDMI", .patch = patch_nvhdmi },
         { .id = 0x10de0007, .name = "MCP7A HDMI", .patch = patch_nvhdmi },
         { .id = 0x10de0067, .name = "MCP67 HDMI", .patch = patch_nvhdmi },
         { .id = 0x10de8001, .name = "MCP73 HDMI", .patch = patch_nvhdmi },
@@ -167,6 +168,7 @@ static struct hda_codec_preset snd_hda_preset_nvhdmi[] = {
 };
 
 MODULE_ALIAS("snd-hda-codec-id:10de0002");
+MODULE_ALIAS("snd-hda-codec-id:10de0006");
 MODULE_ALIAS("snd-hda-codec-id:10de0007");
 MODULE_ALIAS("snd-hda-codec-id:10de0067");
 MODULE_ALIAS("snd-hda-codec-id:10de8001");
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index ea4c88fe05c4..b8a0d3e79272 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -30,6 +30,7 @@
 #include <sound/core.h>
 #include "hda_codec.h"
 #include "hda_local.h"
+#include "hda_beep.h"
 
 #define ALC880_FRONT_EVENT              0x01
 #define ALC880_DCVOL_EVENT              0x02
@@ -77,6 +78,7 @@ enum {
         ALC260_ACER,
         ALC260_WILL,
         ALC260_REPLACER_672V,
+        ALC260_FAVORIT100,
 #ifdef CONFIG_SND_DEBUG
         ALC260_TEST,
 #endif
@@ -103,6 +105,7 @@ enum {
         ALC262_NEC,
         ALC262_TOSHIBA_S06,
         ALC262_TOSHIBA_RX1,
+        ALC262_TYAN,
         ALC262_AUTO,
         ALC262_MODEL_LAST /* last tag */
 };
@@ -185,6 +188,8 @@ enum {
         ALC663_ASUS_MODE4,
         ALC663_ASUS_MODE5,
         ALC663_ASUS_MODE6,
+        ALC272_DELL,
+        ALC272_DELL_ZM1,
         ALC662_AUTO,
         ALC662_MODEL_LAST,
 };
@@ -238,6 +243,13 @@ enum {
         ALC883_MODEL_LAST,
 };
 
+/* styles of capture selection */
+enum {
+        CAPT_MUX = 0,   /* only mux based */
+        CAPT_MIX,       /* only mixer based */
+        CAPT_1MUX_MIX,  /* first mux and other mixers */
+};
+
 /* for GPIO Poll */
 #define GPIO_MASK       0x03
 
@@ -246,6 +258,7 @@ struct alc_spec {
         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
         unsigned int num_mixers;
         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
+        unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 
         const struct hda_verb *init_verbs[5];   /* initialization verbs
                                                  * don't forget NULL
@@ -269,13 +282,15 @@ struct alc_spec {
                                          * dig_out_nid and hp_nid are optional
                                          */
         hda_nid_t alt_dac_nid;
+        hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
+        int dig_out_type;
 
         /* capture */
         unsigned int num_adc_nids;
         hda_nid_t *adc_nids;
         hda_nid_t *capsrc_nids;
         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
-        unsigned char is_mix_capture;   /* matrix-style capture (non-mux) */
+        int capture_style;              /* capture style (CAPT_*) */
 
         /* capture source */
         unsigned int num_mux_defs;
@@ -293,7 +308,7 @@ struct alc_spec {
         /* dynamic controls, init_verbs and input_mux */
         struct auto_pin_cfg autocfg;
         struct snd_array kctls;
-        struct hda_input_mux private_imux;
+        struct hda_input_mux private_imux[3];
         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 
         /* hooks */
@@ -305,6 +320,9 @@ struct alc_spec {
         unsigned int jack_present: 1;
         unsigned int master_sw: 1;
 
+        /* other flags */
+        unsigned int no_analog :1; /* digital I/O only */
+
         /* for virtual master */
         hda_nid_t vmaster_nid;
 #ifdef CONFIG_SND_HDA_POWER_SAVE
@@ -314,13 +332,6 @@ struct alc_spec {
         /* for PLL fix */
         hda_nid_t pll_nid;
         unsigned int pll_coef_idx, pll_coef_bit;
-
-#ifdef SND_HDA_NEEDS_RESUME
-#define ALC_MAX_PINS    16
-        unsigned int num_pins;
-        hda_nid_t pin_nids[ALC_MAX_PINS];
-        unsigned int pin_cfgs[ALC_MAX_PINS];
-#endif
 };
 
 /*
@@ -336,6 +347,7 @@ struct alc_config_preset {
         hda_nid_t *dac_nids;
         hda_nid_t dig_out_nid;          /* optional */
         hda_nid_t hp_nid;               /* optional */
+        hda_nid_t *slave_dig_outs;
         unsigned int num_adc_nids;
         hda_nid_t *adc_nids;
         hda_nid_t *capsrc_nids;
@@ -392,7 +404,8 @@ static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
         imux = &spec->input_mux[mux_idx];
 
-        if (spec->is_mix_capture) {
+        if (spec->capture_style &&
+            !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
                 /* Matrix-mixer style (e.g. ALC882) */
                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
                 unsigned int i, idx;
@@ -750,6 +763,24 @@ static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 #endif   /* CONFIG_SND_DEBUG */
 
 /*
+ * set up the input pin config (depending on the given auto-pin type)
+ */
+static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
+                              int auto_pin_type)
+{
+        unsigned int val = PIN_IN;
+
+        if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
+                unsigned int pincap;
+                pincap = snd_hda_query_pin_caps(codec, nid);
+                pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
+                if (pincap & AC_PINCAP_VREF_80)
+                        val = PIN_VREF80;
+        }
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
+}
+
+/*
  */
 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 {
@@ -810,6 +841,7 @@ static void setup_preset(struct alc_spec *spec,
         spec->multiout.num_dacs = preset->num_dacs;
         spec->multiout.dac_nids = preset->dac_nids;
         spec->multiout.dig_out_nid = preset->dig_out_nid;
+        spec->multiout.slave_dig_outs = preset->slave_dig_outs;
         spec->multiout.hp_nid = preset->hp_nid;
 
         spec->num_mux_defs = preset->num_mux_defs;
@@ -921,7 +953,7 @@ static void alc_mic_automute(struct hda_codec *codec)
                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 }
 #else
-#define alc_mic_automute(codec) /* NOP */
+#define alc_mic_automute(codec) do {} while(0) /* NOP */
 #endif /* disabled */
 
 /* unsolicited event for HP jack sensing */
@@ -952,7 +984,7 @@ static void alc888_coef_init(struct hda_codec *codec)
         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
-        if ((tmp & 0xf0) == 2)
+        if ((tmp & 0xf0) == 0x20)
                 /* alc888S-VC */
                 snd_hda_codec_read(codec, 0x20, 0,
                                    AC_VERB_SET_PROC_COEF, 0x830);
@@ -991,8 +1023,7 @@ static void alc_subsystem_id(struct hda_codec *codec,
         nid = 0x1d;
         if (codec->vendor_id == 0x10ec0260)
                 nid = 0x17;
-        ass = snd_hda_codec_read(codec, nid, 0,
-                                 AC_VERB_GET_CONFIG_DEFAULT, 0);
+        ass = snd_hda_codec_get_pincfg(codec, nid);
         if (!(ass & 1) && !(ass & 0x100000))
                 return;
         if ((ass >> 30) != 1)   /* no physical connection */
@@ -1037,6 +1068,7 @@ do_sku:
                 case 0x10ec0267:
                 case 0x10ec0268:
                 case 0x10ec0269:
+                case 0x10ec0272:
                 case 0x10ec0660:
                 case 0x10ec0662:
                 case 0x10ec0663:
@@ -1065,6 +1097,7 @@ do_sku:
                 case 0x10ec0882:
                 case 0x10ec0883:
                 case 0x10ec0885:
+                case 0x10ec0887:
                 case 0x10ec0889:
                         snd_hda_codec_write(codec, 0x20, 0,
                                             AC_VERB_SET_COEF_INDEX, 7);
@@ -1164,16 +1197,8 @@ static void alc_fix_pincfg(struct hda_codec *codec,
                 return;
 
         cfg = pinfix[quirk->value];
-        for (; cfg->nid; cfg++) {
-                int i;
-                u32 val = cfg->val;
-                for (i = 0; i < 4; i++) {
-                        snd_hda_codec_write(codec, cfg->nid, 0,
-                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
-                                    val & 0xff);
-                        val >>= 8;
-                }
-        }
+        for (; cfg->nid; cfg++)
+                snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
 }
 
 /*
@@ -1373,8 +1398,6 @@ static struct snd_kcontrol_new alc888_base_mixer[] = {
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
         { } /* end */
 };
 
@@ -1481,8 +1504,6 @@ static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, 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_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1576,8 +1597,7 @@ static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
                                      snd_hda_mixer_amp_switch_put);
 }
 
-#define DEFINE_CAPMIX(num) \
-static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
+#define _DEFINE_CAPMIX(num) \
         { \
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
                 .name = "Capture Switch", \
@@ -1598,7 +1618,9 @@ static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
                 .get = alc_cap_vol_get, \
                 .put = alc_cap_vol_put, \
                 .tlv = { .c = alc_cap_vol_tlv }, \
-        }, \
+        }
+
+#define _DEFINE_CAPSRC(num) \
         { \
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
                 /* .name = "Capture Source", */ \
@@ -1607,15 +1629,28 @@ static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
                 .info = alc_mux_enum_info, \
                 .get = alc_mux_enum_get, \
                 .put = alc_mux_enum_put, \
-        }, \
-        { } /* end */ \
+        }
+
+#define DEFINE_CAPMIX(num) \
+static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
+        _DEFINE_CAPMIX(num),                                  \
+        _DEFINE_CAPSRC(num),                                  \
+        { } /* end */                                         \
+}
+
+#define DEFINE_CAPMIX_NOSRC(num) \
+static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
+        _DEFINE_CAPMIX(num),                                        \
+        { } /* end */                                               \
 }
 
 /* up to three ADCs */
 DEFINE_CAPMIX(1);
 DEFINE_CAPMIX(2);
 DEFINE_CAPMIX(3);
-
+DEFINE_CAPMIX_NOSRC(1);
+DEFINE_CAPMIX_NOSRC(2);
+DEFINE_CAPMIX_NOSRC(3);
 
 /*
  * ALC880 5-stack model
@@ -1704,8 +1739,6 @@ static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         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),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Channel Mode",
@@ -1882,13 +1915,6 @@ static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
         { } /* end */
 };
 
-/* additional mixers to alc880_asus_mixer */
-static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-        { } /* end */
-};
-
 /* TCL S700 */
 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
@@ -1921,8 +1947,6 @@ static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         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),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Channel Mode",
@@ -1997,6 +2021,13 @@ static const char *alc_slave_sws[] = {
 
 static void alc_free_kctls(struct hda_codec *codec);
 
+/* additional beep mixers; the actual parameters are overwritten at build */
+static struct snd_kcontrol_new alc_beep_mixer[] = {
+        HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
+        { } /* end */
+};
+
 static int alc_build_controls(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
@@ -2018,11 +2049,13 @@ static int alc_build_controls(struct hda_codec *codec)
                                                     spec->multiout.dig_out_nid);
                 if (err < 0)
                         return err;
-                err = snd_hda_create_spdif_share_sw(codec,
-                                                    &spec->multiout);
-                if (err < 0)
-                        return err;
-                spec->multiout.share_spdif = 1;
+                if (!spec->no_analog) {
+                        err = snd_hda_create_spdif_share_sw(codec,
+                                                            &spec->multiout);
+                        if (err < 0)
+                                return err;
+                        spec->multiout.share_spdif = 1;
+                }
         }
         if (spec->dig_in_nid) {
                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
@@ -2030,8 +2063,24 @@ static int alc_build_controls(struct hda_codec *codec)
                         return err;
         }
 
+        /* create beep controls if needed */
+        if (spec->beep_amp) {
+                struct snd_kcontrol_new *knew;
+                for (knew = alc_beep_mixer; knew->name; knew++) {
+                        struct snd_kcontrol *kctl;
+                        kctl = snd_ctl_new1(knew, codec);
+                        if (!kctl)
+                                return -ENOMEM;
+                        kctl->private_value = spec->beep_amp;
+                        err = snd_hda_ctl_add(codec, kctl);
+                        if (err < 0)
+                                return err;
+                }
+        }
+
         /* if we have no master control, let's create it */
-        if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
+        if (!spec->no_analog &&
+            !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
                 unsigned int vmaster_tlv[4];
                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
                                         HDA_OUTPUT, vmaster_tlv);
@@ -2040,7 +2089,8 @@ static int alc_build_controls(struct hda_codec *codec)
                 if (err < 0)
                         return err;
         }
-        if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
+        if (!spec->no_analog &&
+            !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
                                           NULL, alc_slave_sws);
                 if (err < 0)
@@ -2949,6 +2999,14 @@ static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
                                              stream_tag, format, substream);
 }
 
+static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                           struct hda_codec *codec,
+                                           struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
+}
+
 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
                                          struct hda_codec *codec,
                                          struct snd_pcm_substream *substream)
@@ -3032,7 +3090,8 @@ static struct hda_pcm_stream alc880_pcm_digital_playback = {
         .ops = {
                 .open = alc880_dig_playback_pcm_open,
                 .close = alc880_dig_playback_pcm_close,
-                .prepare = alc880_dig_playback_pcm_prepare
+                .prepare = alc880_dig_playback_pcm_prepare,
+                .cleanup = alc880_dig_playback_pcm_cleanup
         },
 };
 
@@ -3059,6 +3118,9 @@ static int alc_build_pcms(struct hda_codec *codec)
         codec->num_pcms = 1;
         codec->pcm_info = info;
 
+        if (spec->no_analog)
+                goto skip_analog;
+
         info->name = spec->stream_name_analog;
         if (spec->stream_analog_playback) {
                 if (snd_BUG_ON(!spec->multiout.dac_nids))
@@ -3082,12 +3144,17 @@ static int alc_build_pcms(struct hda_codec *codec)
                 }
         }
 
+ skip_analog:
         /* SPDIF for stream index #1 */
         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
                 codec->num_pcms = 2;
+                codec->slave_dig_outs = spec->multiout.slave_dig_outs;
                 info = spec->pcm_rec + 1;
                 info->name = spec->stream_name_digital;
-                info->pcm_type = HDA_PCM_TYPE_SPDIF;
+                if (spec->dig_out_type)
+                        info->pcm_type = spec->dig_out_type;
+                else
+                        info->pcm_type = HDA_PCM_TYPE_SPDIF;
                 if (spec->multiout.dig_out_nid &&
                     spec->stream_digital_playback) {
                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
@@ -3102,6 +3169,9 @@ static int alc_build_pcms(struct hda_codec *codec)
                 codec->spdif_status_reset = 1;
         }
 
+        if (spec->no_analog)
+                return 0;
+
         /* If the use of more than one ADC is requested for the current
          * model, configure a second analog capture-only PCM.
          */
@@ -3160,65 +3230,17 @@ static void alc_free(struct hda_codec *codec)
 
         alc_free_kctls(codec);
         kfree(spec);
-        codec->spec = NULL; /* to be sure */
+        snd_hda_detach_beep_device(codec);
 }
 
 #ifdef SND_HDA_NEEDS_RESUME
-static void store_pin_configs(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        hda_nid_t nid, end_nid;
-
-        end_nid = codec->start_nid + codec->num_nodes;
-        for (nid = codec->start_nid; nid < end_nid; nid++) {
-                unsigned int wid_caps = get_wcaps(codec, nid);
-                unsigned int wid_type =
-                        (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
-                if (wid_type != AC_WID_PIN)
-                        continue;
-                if (spec->num_pins >= ARRAY_SIZE(spec->pin_nids))
-                        break;
-                spec->pin_nids[spec->num_pins] = nid;
-                spec->pin_cfgs[spec->num_pins] =
-                        snd_hda_codec_read(codec, nid, 0,
-                                           AC_VERB_GET_CONFIG_DEFAULT, 0);
-                spec->num_pins++;
-        }
-}
-
-static void resume_pin_configs(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        int i;
-
-        for (i = 0; i < spec->num_pins; i++) {
-                hda_nid_t pin_nid = spec->pin_nids[i];
-                unsigned int pin_config = spec->pin_cfgs[i];
-                snd_hda_codec_write(codec, pin_nid, 0,
-                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
-                                    pin_config & 0x000000ff);
-                snd_hda_codec_write(codec, pin_nid, 0,
-                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
-                                    (pin_config & 0x0000ff00) >> 8);
-                snd_hda_codec_write(codec, pin_nid, 0,
-                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
-                                    (pin_config & 0x00ff0000) >> 16);
-                snd_hda_codec_write(codec, pin_nid, 0,
-                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
-                                    pin_config >> 24);
-        }
-}
-
 static int alc_resume(struct hda_codec *codec)
 {
-        resume_pin_configs(codec);
         codec->patch_ops.init(codec);
         snd_hda_codec_resume_amp(codec);
         snd_hda_codec_resume_cache(codec);
         return 0;
 }
-#else
-#define store_pin_configs(codec)
 #endif
 
 /*
@@ -3557,7 +3579,7 @@ static struct snd_pci_quirk alc880_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
-        SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
+        SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
@@ -3600,7 +3622,8 @@ static struct snd_pci_quirk alc880_cfg_tbl[] = {
         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
-        SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
+        /* default Intel */
+        SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
         {}
@@ -3780,7 +3803,7 @@ static struct alc_config_preset alc880_presets[] = {
                 .input_mux = &alc880_capture_source,
         },
         [ALC880_UNIWILL_DIG] = {
-                .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
+                .mixers = { alc880_asus_mixer },
                 .init_verbs = { alc880_volume_init_verbs,
                                 alc880_pin_asus_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
@@ -3818,8 +3841,7 @@ static struct alc_config_preset alc880_presets[] = {
                 .init_hook = alc880_uniwill_p53_hp_automute,
         },
         [ALC880_FUJITSU] = {
-                .mixers = { alc880_fujitsu_mixer,
-                            alc880_pcbeep_mixer, },
+                .mixers = { alc880_fujitsu_mixer },
                 .init_verbs = { alc880_volume_init_verbs,
                                 alc880_uniwill_p53_init_verbs,
                                 alc880_beep_init_verbs },
@@ -4112,7 +4134,7 @@ static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
                                                 const struct auto_pin_cfg *cfg)
 {
-        struct hda_input_mux *imux = &spec->private_imux;
+        struct hda_input_mux *imux = &spec->private_imux[0];
         int i, err, idx;
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
@@ -4200,11 +4222,9 @@ static void alc880_auto_init_analog_input(struct hda_codec *codec)
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
                 if (alc880_is_input_pin(nid)) {
-                        snd_hda_codec_write(codec, nid, 0,
-                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                            i <= AUTO_PIN_FRONT_MIC ?
-                                            PIN_VREF80 : PIN_IN);
-                        if (nid != ALC880_PIN_CD_NID)
+                        alc_set_input_pin(codec, nid, i);
+                        if (nid != ALC880_PIN_CD_NID &&
+                            (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
                                 snd_hda_codec_write(codec, nid, 0,
                                                     AC_VERB_SET_AMP_GAIN_MUTE,
                                                     AMP_OUT_MUTE);
@@ -4219,7 +4239,7 @@ static void alc880_auto_init_analog_input(struct hda_codec *codec)
 static int alc880_parse_auto_config(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        int err;
+        int i, err;
         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
 
         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
@@ -4250,8 +4270,23 @@ static int alc880_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
-                spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
+        /* check multiple SPDIF-out (for recent codecs) */
+        for (i = 0; i < spec->autocfg.dig_outs; i++) {
+                hda_nid_t dig_nid;
+                err = snd_hda_get_connections(codec,
+                                              spec->autocfg.dig_out_pins[i],
+                                              &dig_nid, 1);
+                if (err < 0)
+                        continue;
+                if (!i)
+                        spec->multiout.dig_out_nid = dig_nid;
+                else {
+                        spec->multiout.slave_dig_outs = spec->slave_dig_outs;
+                        spec->slave_dig_outs[i - 1] = dig_nid;
+                        if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
+                                break;
+                }
+        }
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = ALC880_DIGIN_NID;
 
@@ -4261,9 +4296,8 @@ static int alc880_parse_auto_config(struct hda_codec *codec)
         add_verb(spec, alc880_volume_init_verbs);
 
         spec->num_mux_defs = 1;
-        spec->input_mux = &spec->private_imux;
+        spec->input_mux = &spec->private_imux[0];
 
-        store_pin_configs(codec);
         return 1;
 }
 
@@ -4278,21 +4312,33 @@ static void alc880_auto_init(struct hda_codec *codec)
                 alc_inithook(codec);
 }
 
-/*
- * OK, here we have finally the patch for ALC880
- */
-
 static void set_capture_mixer(struct alc_spec *spec)
 {
-        static struct snd_kcontrol_new *caps[3] = {
-                alc_capture_mixer1,
-                alc_capture_mixer2,
-                alc_capture_mixer3,
+        static struct snd_kcontrol_new *caps[2][3] = {
+                { alc_capture_mixer_nosrc1,
+                  alc_capture_mixer_nosrc2,
+                  alc_capture_mixer_nosrc3 },
+                { alc_capture_mixer1,
+                  alc_capture_mixer2,
+                  alc_capture_mixer3 },
         };
-        if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3)
-                spec->cap_mixer = caps[spec->num_adc_nids - 1];
+        if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
+                int mux;
+                if (spec->input_mux && spec->input_mux->num_items > 1)
+                        mux = 1;
+                else
+                        mux = 0;
+                spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
+        }
 }
 
+#define set_beep_amp(spec, nid, idx, dir) \
+        ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
+
+/*
+ * OK, here we have finally the patch for ALC880
+ */
+
 static int patch_alc880(struct hda_codec *codec)
 {
         struct alc_spec *spec;
@@ -4328,6 +4374,12 @@ static int patch_alc880(struct hda_codec *codec)
                 }
         }
 
+        err = snd_hda_attach_beep_device(codec, 0x1);
+        if (err < 0) {
+                alc_free(codec);
+                return err;
+        }
+
         if (board_config != ALC880_AUTO)
                 setup_preset(spec, &alc880_presets[board_config]);
 
@@ -4354,6 +4406,7 @@ static int patch_alc880(struct hda_codec *codec)
                 }
         }
         set_capture_mixer(spec);
+        set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
         spec->vmaster_nid = 0x0c;
 
@@ -4461,6 +4514,26 @@ static struct hda_input_mux alc260_acer_capture_sources[2] = {
                 },
         },
 };
+
+/* Maxdata Favorit 100XS */
+static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
+        {
+                .num_items = 2,
+                .items = {
+                        { "Line/Mic", 0x0 },
+                        { "CD", 0x4 },
+                },
+        },
+        {
+                .num_items = 3,
+                .items = {
+                        { "Line/Mic", 0x0 },
+                        { "CD", 0x4 },
+                        { "Mixer", 0x5 },
+                },
+        },
+};
+
 /*
  * This is just place-holder, so there's something for alc_build_pcms to look
  * at when it calculates the maximum number of channels. ALC260 has no mixer
@@ -4503,12 +4576,6 @@ static struct snd_kcontrol_new alc260_input_mixer[] = {
         { } /* end */
 };
 
-static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
-        { } /* end */
-};
-
 /* update HP, line and mono out pins according to the master switch */
 static void alc260_hp_master_update(struct hda_codec *codec,
                                     hda_nid_t hp, hda_nid_t line,
@@ -4700,8 +4767,6 @@ static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
         { } /* end */
@@ -4746,8 +4811,18 @@ static struct snd_kcontrol_new alc260_acer_mixer[] = {
         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
+        { } /* end */
+};
+
+/* Maxdata Favorit 100XS: one output and one input (0x12) jack
+ */
+static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
+        ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
+        HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
+        ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
         { } /* end */
 };
 
@@ -4765,8 +4840,6 @@ static struct snd_kcontrol_new alc260_will_mixer[] = {
         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
         { } /* end */
 };
 
@@ -5124,6 +5197,89 @@ static struct hda_verb alc260_acer_init_verbs[] = {
         { }
 };
 
+/* Initialisation sequence for Maxdata Favorit 100XS
+ * (adapted from Acer init verbs).
+ */
+static struct hda_verb alc260_favorit100_init_verbs[] = {
+        /* GPIO 0 enables the output jack.
+         * Turn this on and rely on the standard mute
+         * methods whenever the user wants to turn these outputs off.
+         */
+        {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
+        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
+        {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
+        /* Line/Mic input jack is connected to Mic1 pin */
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
+        /* Ensure all other unused pins are disabled and muted. */
+        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        /* Disable digital (SPDIF) pins */
+        {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
+        {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
+
+        /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
+         * bus when acting as outputs.
+         */
+        {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
+
+        /* Start with output sum widgets muted and their output gains at min */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+
+        /* Unmute Line-out pin widget amp left and right
+         * (no equiv mixer ctrl)
+         */
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Unmute Mic1 and Line1 pin widget input buffers since they start as
+         * inputs. If the pin mode is changed by the user the pin mode control
+         * will take care of enabling the pin's input/output buffers as needed.
+         * Therefore there's no need to enable the input buffer at this
+         * stage.
+         */
+        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Mute capture amp left and right */
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        /* Set ADC connection select to match default mixer setting - mic
+         * (on mic1 pin)
+         */
+        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Do similar with the second ADC: mute capture input amp and
+         * set ADC connection to mic to match ALSA's default state.
+         */
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Mute all inputs to mixer widget (even unconnected ones) */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
+
+        { }
+};
+
 static struct hda_verb alc260_will_verbs[] = {
         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
@@ -5270,8 +5426,6 @@ static struct snd_kcontrol_new alc260_test_mixer[] = {
         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
@@ -5469,7 +5623,7 @@ static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
                                                 const struct auto_pin_cfg *cfg)
 {
-        struct hda_input_mux *imux = &spec->private_imux;
+        struct hda_input_mux *imux = &spec->private_imux[0];
         int i, err, idx;
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
@@ -5544,11 +5698,9 @@ static void alc260_auto_init_analog_input(struct hda_codec *codec)
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
                 if (nid >= 0x12) {
-                        snd_hda_codec_write(codec, nid, 0,
-                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                            i <= AUTO_PIN_FRONT_MIC ?
-                                            PIN_VREF80 : PIN_IN);
-                        if (nid != ALC260_PIN_CD_NID)
+                        alc_set_input_pin(codec, nid, i);
+                        if (nid != ALC260_PIN_CD_NID &&
+                            (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
                                 snd_hda_codec_write(codec, nid, 0,
                                                     AC_VERB_SET_AMP_GAIN_MUTE,
                                                     AMP_OUT_MUTE);
@@ -5621,7 +5773,7 @@ static int alc260_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
@@ -5629,9 +5781,8 @@ static int alc260_parse_auto_config(struct hda_codec *codec)
         add_verb(spec, alc260_volume_init_verbs);
 
         spec->num_mux_defs = 1;
-        spec->input_mux = &spec->private_imux;
+        spec->input_mux = &spec->private_imux[0];
 
-        store_pin_configs(codec);
         return 1;
 }
 
@@ -5668,6 +5819,7 @@ static const char *alc260_models[ALC260_MODEL_LAST] = {
         [ALC260_ACER]           = "acer",
         [ALC260_WILL]           = "will",
         [ALC260_REPLACER_672V]  = "replacer",
+        [ALC260_FAVORIT100]     = "favorit100",
 #ifdef CONFIG_SND_DEBUG
         [ALC260_TEST]           = "test",
 #endif
@@ -5677,6 +5829,7 @@ static const char *alc260_models[ALC260_MODEL_LAST] = {
 static struct snd_pci_quirk alc260_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
+        SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
@@ -5699,8 +5852,7 @@ static struct snd_pci_quirk alc260_cfg_tbl[] = {
 static struct alc_config_preset alc260_presets[] = {
         [ALC260_BASIC] = {
                 .mixers = { alc260_base_output_mixer,
-                            alc260_input_mixer,
-                            alc260_pc_beep_mixer },
+                            alc260_input_mixer },
                 .init_verbs = { alc260_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
                 .dac_nids = alc260_dac_nids,
@@ -5779,6 +5931,18 @@ static struct alc_config_preset alc260_presets[] = {
                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
                 .input_mux = alc260_acer_capture_sources,
         },
+        [ALC260_FAVORIT100] = {
+                .mixers = { alc260_favorit100_mixer },
+                .init_verbs = { alc260_favorit100_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
+                .dac_nids = alc260_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
+                .adc_nids = alc260_dual_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc260_modes),
+                .channel_mode = alc260_modes,
+                .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
+                .input_mux = alc260_favorit100_capture_sources,
+        },
         [ALC260_WILL] = {
                 .mixers = { alc260_will_mixer },
                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
@@ -5855,6 +6019,12 @@ static int patch_alc260(struct hda_codec *codec)
                 }
         }
 
+        err = snd_hda_attach_beep_device(codec, 0x1);
+        if (err < 0) {
+                alc_free(codec);
+                return err;
+        }
+
         if (board_config != ALC260_AUTO)
                 setup_preset(spec, &alc260_presets[board_config]);
 
@@ -5880,6 +6050,7 @@ static int patch_alc260(struct hda_codec *codec)
                 }
         }
         set_capture_mixer(spec);
+        set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
 
         spec->vmaster_nid = 0x08;
 
@@ -6051,8 +6222,6 @@ static struct snd_kcontrol_new alc882_base_mixer[] = {
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
         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),
         { } /* end */
 };
 
@@ -6079,8 +6248,6 @@ static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
         { } /* end */
 };
 
@@ -6132,8 +6299,6 @@ static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
         { } /* end */
 };
 
@@ -6242,8 +6407,10 @@ static struct snd_kcontrol_new alc882_macpro_mixer[] = {
         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
+        /* FIXME: this looks suspicious...
         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        */
         { } /* end */
 };
 
@@ -6875,19 +7042,9 @@ static void alc882_auto_init_analog_input(struct hda_codec *codec)
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
-                unsigned int vref;
                 if (!nid)
                         continue;
-                vref = PIN_IN;
-                if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
-                        unsigned int pincap;
-                        pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
-                        if ((pincap >> AC_PINCAP_VREF_SHIFT) &
-                            AC_PINCAP_VREF_80)
-                                vref = PIN_VREF80;
-                }
-                snd_hda_codec_write(codec, nid, 0,
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
+                alc_set_input_pin(codec, nid, AUTO_PIN_FRONT_MIC /*i*/);
                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
                         snd_hda_codec_write(codec, nid, 0,
                                             AC_VERB_SET_AMP_GAIN_MUTE,
@@ -6898,18 +7055,21 @@ static void alc882_auto_init_analog_input(struct hda_codec *codec)
 static void alc882_auto_init_input_src(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        const struct hda_input_mux *imux = spec->input_mux;
         int c;
 
         for (c = 0; c < spec->num_adc_nids; c++) {
                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
                 hda_nid_t nid = spec->capsrc_nids[c];
+                unsigned int mux_idx;
+                const struct hda_input_mux *imux;
                 int conns, mute, idx, item;
 
                 conns = snd_hda_get_connections(codec, nid, conn_list,
                                                 ARRAY_SIZE(conn_list));
                 if (conns < 0)
                         continue;
+                mux_idx = c >= spec->num_mux_defs ? 0 : c;
+                imux = &spec->input_mux[mux_idx];
                 for (idx = 0; idx < conns; idx++) {
                         /* if the current connection is the selected one,
                          * unmute it as default - otherwise mute it
@@ -6922,8 +7082,20 @@ static void alc882_auto_init_input_src(struct hda_codec *codec)
                                         break;
                                 }
                         }
-                        snd_hda_codec_write(codec, nid, 0,
-                                            AC_VERB_SET_AMP_GAIN_MUTE, mute);
+                        /* check if we have a selector or mixer
+                         * we could check for the widget type instead, but
+                         * just check for Amp-In presence (in case of mixer
+                         * without amp-in there is something wrong, this
+                         * function shouldn't be used or capsrc nid is wrong)
+                         */
+                        if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
+                                snd_hda_codec_write(codec, nid, 0,
+                                                    AC_VERB_SET_AMP_GAIN_MUTE,
+                                                    mute);
+                        else if (mute != AMP_IN_MUTE(idx))
+                                snd_hda_codec_write(codec, nid, 0,
+                                                    AC_VERB_SET_CONNECT_SEL,
+                                                    idx);
                 }
         }
 }
@@ -7012,12 +7184,15 @@ static int patch_alc882(struct hda_codec *codec)
                         break;
                 case 0x106b1000: /* iMac 24 */
                 case 0x106b2800: /* AppleTV */
+                case 0x106b3e00: /* iMac 24 Aluminium */
                         board_config = ALC885_IMAC24;
                         break;
+                case 0x106b00a0: /* MacBookPro3,1 - Another revision */
                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
                 case 0x106b00a4: /* MacbookPro4,1 */
                 case 0x106b2c00: /* Macbook Pro rev3 */
                 case 0x106b3600: /* Macbook 3.1 */
+                case 0x106b3800: /* MacbookPro4,1 - latter revision */
                         board_config = ALC885_MBP3;
                         break;
                 default:
@@ -7049,6 +7224,12 @@ static int patch_alc882(struct hda_codec *codec)
                 }
         }
 
+        err = snd_hda_attach_beep_device(codec, 0x1);
+        if (err < 0) {
+                alc_free(codec);
+                return err;
+        }
+
         if (board_config != ALC882_AUTO)
                 setup_preset(spec, &alc882_presets[board_config]);
 
@@ -7069,7 +7250,7 @@ static int patch_alc882(struct hda_codec *codec)
         spec->stream_digital_playback = &alc882_pcm_digital_playback;
         spec->stream_digital_capture = &alc882_pcm_digital_capture;
 
-        spec->is_mix_capture = 1; /* matrix-style capture */
+        spec->capture_style = CAPT_MIX; /* matrix-style capture */
         if (!spec->adc_nids && spec->input_mux) {
                 /* check whether NID 0x07 is valid */
                 unsigned int wcap = get_wcaps(codec, 0x07);
@@ -7086,6 +7267,7 @@ static int patch_alc882(struct hda_codec *codec)
                 }
         }
         set_capture_mixer(spec);
+        set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
         spec->vmaster_nid = 0x0c;
 
@@ -7137,10 +7319,14 @@ static hda_nid_t alc883_adc_nids_rev[2] = {
         0x09, 0x08
 };
 
+#define alc889_adc_nids         alc880_adc_nids
+
 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
 
 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
 
+#define alc889_capsrc_nids      alc882_capsrc_nids
+
 /* input MUX */
 /* FIXME: should be a matrix-type input source selection */
 
@@ -7358,8 +7544,6 @@ static struct snd_kcontrol_new alc883_base_mixer[] = {
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
         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),
         { } /* end */
 };
 
@@ -7422,8 +7606,6 @@ static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
         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),
         { } /* end */
 };
 
@@ -7447,8 +7629,6 @@ static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
         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),
         { } /* end */
 };
 
@@ -7473,8 +7653,6 @@ static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
         { } /* end */
 };
 
@@ -7498,8 +7676,6 @@ static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
         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),
         { } /* end */
 };
 
@@ -7907,36 +8083,83 @@ static struct hda_verb alc888_lenovo_sky_verbs[] = {
         { } /* end */
 };
 
+static struct hda_verb alc888_6st_dell_verbs[] = {
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        { }
+};
+
+static void alc888_3st_hp_front_automute(struct hda_codec *codec)
+{
+        unsigned int present, bits;
+
+        present = snd_hda_codec_read(codec, 0x1b, 0,
+                        AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        bits = present ? HDA_AMP_MUTE : 0;
+        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, bits);
+        snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, bits);
+        snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, bits);
+}
+
+static void alc888_3st_hp_unsol_event(struct hda_codec *codec,
+                                      unsigned int res)
+{
+        switch (res >> 26) {
+        case ALC880_HP_EVENT:
+                alc888_3st_hp_front_automute(codec);
+                break;
+        }
+}
+
 static struct hda_verb alc888_3st_hp_verbs[] = {
         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
-        { }
-};
-
-static struct hda_verb alc888_6st_dell_verbs[] = {
         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        { }
+        { } /* end */
 };
 
+/*
+ * 2ch mode
+ */
 static struct hda_verb alc888_3st_hp_2ch_init[] = {
         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
-        { }
+        { } /* end */
+};
+
+/*
+ * 4ch mode
+ */
+static struct hda_verb alc888_3st_hp_4ch_init[] = {
+        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
+        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
+        { } /* end */
 };
 
+/*
+ * 6ch mode
+ */
 static struct hda_verb alc888_3st_hp_6ch_init[] = {
         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-        { }
+        { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
+        { } /* end */
 };
 
-static struct hda_channel_mode alc888_3st_hp_modes[2] = {
+static struct hda_channel_mode alc888_3st_hp_modes[3] = {
         { 2, alc888_3st_hp_2ch_init },
+        { 4, alc888_3st_hp_4ch_init },
         { 6, alc888_3st_hp_6ch_init },
 };
 
@@ -8197,7 +8420,7 @@ static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
 {
         switch (res >> 26) {
         case ALC880_HP_EVENT:
-                printk("hp_event\n");
+                /* printk(KERN_DEBUG "hp_event\n"); */
                 alc888_6st_dell_front_automute(codec);
                 break;
         }
@@ -8456,6 +8679,7 @@ static struct snd_pci_quirk alc883_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
+        SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
@@ -8463,21 +8687,29 @@ static struct snd_pci_quirk alc883_cfg_tbl[] = {
                 ALC888_ACER_ASPIRE_4930G),
         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
                 ALC888_ACER_ASPIRE_4930G),
+        SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
+        SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
                 ALC888_ACER_ASPIRE_4930G),
-        SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
+        SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
+                ALC888_ACER_ASPIRE_4930G),
+        /* default Acer */
+        SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER),
         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
+        SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
+        SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
@@ -8509,11 +8741,12 @@ static struct snd_pci_quirk alc883_cfg_tbl[] = {
         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
-        SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
+        SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
-        SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
-        SND_PCI_QUIRK(0x1734, 0x113d, "Fujitsu AMILO Xa3530",
+        SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
+                      ALC883_FUJITSU_PI2515),
+        SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
                 ALC888_FUJITSU_XA3530),
         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
@@ -8526,11 +8759,20 @@ static struct snd_pci_quirk alc883_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
+        SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
         {}
 };
 
+static hda_nid_t alc883_slave_dig_outs[] = {
+        ALC1200_DIGOUT_NID, 0,
+};
+
+static hda_nid_t alc1200_slave_dig_outs[] = {
+        ALC883_DIGOUT_NID, 0,
+};
+
 static struct alc_config_preset alc883_presets[] = {
         [ALC883_3ST_2ch_DIG] = {
                 .mixers = { alc883_3ST_2ch_mixer },
@@ -8572,6 +8814,7 @@ static struct alc_config_preset alc883_presets[] = {
                 .dac_nids = alc883_dac_nids,
                 .dig_out_nid = ALC883_DIGOUT_NID,
                 .dig_in_nid = ALC883_DIGIN_NID,
+                .slave_dig_outs = alc883_slave_dig_outs,
                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
                 .channel_mode = alc883_3ST_6ch_intel_modes,
                 .need_dac_fix = 1,
@@ -8766,6 +9009,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc888_3st_hp_modes,
                 .need_dac_fix = 1,
                 .input_mux = &alc883_capture_source,
+                .unsol_event = alc888_3st_hp_unsol_event,
+                .init_hook = alc888_3st_hp_front_automute,
         },
         [ALC888_6ST_DELL] = {
                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
@@ -8871,6 +9116,7 @@ static struct alc_config_preset alc883_presets[] = {
                 .dac_nids = alc883_dac_nids,
                 .dig_out_nid = ALC1200_DIGOUT_NID,
                 .dig_in_nid = ALC883_DIGIN_NID,
+                .slave_dig_outs = alc1200_slave_dig_outs,
                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
                 .channel_mode = alc883_sixstack_modes,
                 .input_mux = &alc883_capture_source,
@@ -8938,11 +9184,9 @@ static void alc883_auto_init_analog_input(struct hda_codec *codec)
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
                 if (alc883_is_input_pin(nid)) {
-                        snd_hda_codec_write(codec, nid, 0,
-                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                            (i <= AUTO_PIN_FRONT_MIC ?
-                                             PIN_VREF80 : PIN_IN));
-                        if (nid != ALC883_PIN_CD_NID)
+                        alc_set_input_pin(codec, nid, i);
+                        if (nid != ALC883_PIN_CD_NID &&
+                            (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
                                 snd_hda_codec_write(codec, nid, 0,
                                                     AC_VERB_SET_AMP_GAIN_MUTE,
                                                     AMP_OUT_MUTE);
@@ -8957,6 +9201,8 @@ static int alc883_parse_auto_config(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
         int err = alc880_parse_auto_config(codec);
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        int i;
 
         if (err < 0)
                 return err;
@@ -8970,6 +9216,26 @@ static int alc883_parse_auto_config(struct hda_codec *codec)
         /* hack - override the init verbs */
         spec->init_verbs[0] = alc883_auto_init_verbs;
 
+        /* setup input_mux for ALC889 */
+        if (codec->vendor_id == 0x10ec0889) {
+                /* digital-mic input pin is excluded in alc880_auto_create..()
+                 * because it's under 0x18
+                 */
+                if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
+                    cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
+                        struct hda_input_mux *imux = &spec->private_imux[0];
+                        for (i = 1; i < 3; i++)
+                                memcpy(&spec->private_imux[i],
+                                       &spec->private_imux[0],
+                                       sizeof(spec->private_imux[0]));
+                        imux->items[imux->num_items].label = "Int DMic";
+                        imux->items[imux->num_items].index = 0x0b;
+                        imux->num_items++;
+                        spec->num_mux_defs = 3;
+                        spec->input_mux = spec->private_imux;
+                }
+        }
+
         return 1; /* config found */
 }
 
@@ -9021,6 +9287,12 @@ static int patch_alc883(struct hda_codec *codec)
                 }
         }
 
+        err = snd_hda_attach_beep_device(codec, 0x1);
+        if (err < 0) {
+                alc_free(codec);
+                return err;
+        }
+
         if (board_config != ALC883_AUTO)
                 setup_preset(spec, &alc883_presets[board_config]);
 
@@ -9033,14 +9305,36 @@ static int patch_alc883(struct hda_codec *codec)
                         spec->stream_name_analog = "ALC888 Analog";
                         spec->stream_name_digital = "ALC888 Digital";
                 }
+                if (!spec->num_adc_nids) {
+                        spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
+                        spec->adc_nids = alc883_adc_nids;
+                }
+                if (!spec->capsrc_nids)
+                        spec->capsrc_nids = alc883_capsrc_nids;
+                spec->capture_style = CAPT_MIX; /* matrix-style capture */
                 break;
         case 0x10ec0889:
                 spec->stream_name_analog = "ALC889 Analog";
                 spec->stream_name_digital = "ALC889 Digital";
+                if (!spec->num_adc_nids) {
+                        spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
+                        spec->adc_nids = alc889_adc_nids;
+                }
+                if (!spec->capsrc_nids)
+                        spec->capsrc_nids = alc889_capsrc_nids;
+                spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
+                                                        capture */
                 break;
         default:
                 spec->stream_name_analog = "ALC883 Analog";
                 spec->stream_name_digital = "ALC883 Digital";
+                if (!spec->num_adc_nids) {
+                        spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
+                        spec->adc_nids = alc883_adc_nids;
+                }
+                if (!spec->capsrc_nids)
+                        spec->capsrc_nids = alc883_capsrc_nids;
+                spec->capture_style = CAPT_MIX; /* matrix-style capture */
                 break;
         }
 
@@ -9051,15 +9345,9 @@ static int patch_alc883(struct hda_codec *codec)
         spec->stream_digital_playback = &alc883_pcm_digital_playback;
         spec->stream_digital_capture = &alc883_pcm_digital_capture;
 
-        if (!spec->num_adc_nids) {
-                spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
-                spec->adc_nids = alc883_adc_nids;
-        }
-        if (!spec->capsrc_nids)
-                spec->capsrc_nids = alc883_capsrc_nids;
-        spec->is_mix_capture = 1; /* matrix-style capture */
         if (!spec->cap_mixer)
                 set_capture_mixer(spec);
+        set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
         spec->vmaster_nid = 0x0c;
 
@@ -9112,8 +9400,6 @@ static struct snd_kcontrol_new alc262_base_mixer[] = {
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
-        /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
-           HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
@@ -9134,8 +9420,6 @@ static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
-        /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
-           HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
         { } /* end */
@@ -9244,8 +9528,6 @@ static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
         { } /* end */
@@ -9274,8 +9556,6 @@ static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
         { } /* end */
 };
 
@@ -9423,6 +9703,67 @@ static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
         { } /* end */
 };
 
+static struct snd_kcontrol_new alc262_tyan_mixer[] = {
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
+        HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
+        { } /* end */
+};
+
+static struct hda_verb alc262_tyan_verbs[] = {
+        /* Headphone automute */
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* P11 AUX_IN, white 4-pin connector */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
+        {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
+        {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
+
+        {}
+};
+
+/* unsolicited event for HP jack sensing */
+static void alc262_tyan_automute(struct hda_codec *codec)
+{
+        unsigned int mute;
+        unsigned int present;
+
+        snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
+        present = snd_hda_codec_read(codec, 0x1b, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0);
+        present = (present & 0x80000000) != 0;
+        if (present) {
+                /* mute line output on ATX panel */
+                snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
+                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
+        } else {
+                /* unmute line output if necessary */
+                mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
+                snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
+                                         HDA_AMP_MUTE, mute);
+        }
+}
+
+static void alc262_tyan_unsol_event(struct hda_codec *codec,
+                                       unsigned int res)
+{
+        if ((res >> 26) != ALC880_HP_EVENT)
+                return;
+        alc262_tyan_automute(codec);
+}
+
 #define alc262_capture_mixer            alc882_capture_mixer
 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
 
@@ -9889,8 +10230,6 @@ static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
         },
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
@@ -10462,8 +10801,14 @@ static int alc262_parse_auto_config(struct hda_codec *codec)
                                            alc262_ignore);
         if (err < 0)
                 return err;
-        if (!spec->autocfg.line_outs)
+        if (!spec->autocfg.line_outs) {
+                if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
+                        spec->multiout.max_channels = 2;
+                        spec->no_analog = 1;
+                        goto dig_only;
+                }
                 return 0; /* can't find valid BIOS pin config */
+        }
         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -10473,8 +10818,11 @@ static int alc262_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+ dig_only:
+        if (spec->autocfg.dig_outs) {
                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
+                spec->dig_out_type = spec->autocfg.dig_out_type[0];
+        }
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = ALC262_DIGIN_NID;
 
@@ -10483,13 +10831,12 @@ static int alc262_parse_auto_config(struct hda_codec *codec)
 
         add_verb(spec, alc262_volume_init_verbs);
         spec->num_mux_defs = 1;
-        spec->input_mux = &spec->private_imux;
+        spec->input_mux = &spec->private_imux[0];
 
         err = alc_auto_add_mic_boost(codec);
         if (err < 0)
                 return err;
 
-        store_pin_configs(codec);
         return 1;
 }
 
@@ -10531,20 +10878,19 @@ static const char *alc262_models[ALC262_MODEL_LAST] = {
         [ALC262_ULTRA]          = "ultra",
         [ALC262_LENOVO_3000]    = "lenovo-3000",
         [ALC262_NEC]            = "nec",
+        [ALC262_TYAN]           = "tyan",
         [ALC262_AUTO]           = "auto",
 };
 
 static struct snd_pci_quirk alc262_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
-        SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
-        SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
-        SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
-        SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
-        SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
-        SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
-        SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
-        SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
+        SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
+                           ALC262_HP_BPC),
+        SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
+                           ALC262_HP_BPC),
+        SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
+                           ALC262_HP_BPC),
         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
@@ -10562,17 +10908,18 @@ static struct snd_pci_quirk alc262_cfg_tbl[] = {
         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
-        SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
-        SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
-        SND_PCI_QUIRK(0x104d, 0x9033, "Sony VAIO VGN-SR19XN",
-                      ALC262_SONY_ASSAMD),
+        SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
+        SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
+                           ALC262_SONY_ASSAMD),
         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
                       ALC262_TOSHIBA_RX1),
         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
-        SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
-        SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
+        SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
+        SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
+                           ALC262_ULTRA),
+        SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
@@ -10788,6 +11135,19 @@ static struct alc_config_preset alc262_presets[] = {
                 .unsol_event = alc262_hippo_unsol_event,
                 .init_hook = alc262_hippo_automute,
         },
+        [ALC262_TYAN] = {
+                .mixers = { alc262_tyan_mixer },
+                .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
+                .num_dacs = ARRAY_SIZE(alc262_dac_nids),
+                .dac_nids = alc262_dac_nids,
+                .hp_nid = 0x02,
+                .dig_out_nid = ALC262_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc262_modes),
+                .channel_mode = alc262_modes,
+                .input_mux = &alc262_capture_source,
+                .unsol_event = alc262_tyan_unsol_event,
+                .init_hook = alc262_tyan_automute,
+        },
 };
 
 static int patch_alc262(struct hda_codec *codec)
@@ -10840,6 +11200,14 @@ static int patch_alc262(struct hda_codec *codec)
                 }
         }
 
+        if (!spec->no_analog) {
+                err = snd_hda_attach_beep_device(codec, 0x1);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                }
+        }
+
         if (board_config != ALC262_AUTO)
                 setup_preset(spec, &alc262_presets[board_config]);
 
@@ -10851,7 +11219,7 @@ static int patch_alc262(struct hda_codec *codec)
         spec->stream_digital_playback = &alc262_pcm_digital_playback;
         spec->stream_digital_capture = &alc262_pcm_digital_capture;
 
-        spec->is_mix_capture = 1;
+        spec->capture_style = CAPT_MIX;
         if (!spec->adc_nids && spec->input_mux) {
                 /* check whether NID 0x07 is valid */
                 unsigned int wcap = get_wcaps(codec, 0x07);
@@ -10868,8 +11236,10 @@ static int patch_alc262(struct hda_codec *codec)
                         spec->capsrc_nids = alc262_capsrc_nids;
                 }
         }
-        if (!spec->cap_mixer)
+        if (!spec->cap_mixer && !spec->no_analog)
                 set_capture_mixer(spec);
+        if (!spec->no_analog)
+                set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
         spec->vmaster_nid = 0x0c;
 
@@ -11249,19 +11619,13 @@ static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
 static struct hda_verb alc268_base_init_verbs[] = {
         /* Unmute DAC0-1 and set vol = 0 */
         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 
         /*
          * Set up output mixers (0x0c - 0x0e)
          */
         /* set vol=0 to output mixers */
         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
 
         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
@@ -11280,9 +11644,7 @@ static struct hda_verb alc268_base_init_verbs[] = {
         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 
         /* set PCBEEP vol = 0, mute connections */
         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
@@ -11304,10 +11666,8 @@ static struct hda_verb alc268_base_init_verbs[] = {
  */
 static struct hda_verb alc268_volume_init_verbs[] = {
         /* set output DAC */
-        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 
         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
@@ -11315,16 +11675,12 @@ static struct hda_verb alc268_volume_init_verbs[] = {
         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 
-        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 
         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 
         /* set PCBEEP vol = 0, mute connections */
         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
@@ -11523,7 +11879,7 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
                                                 const struct auto_pin_cfg *cfg)
 {
-        struct hda_input_mux *imux = &spec->private_imux;
+        struct hda_input_mux *imux = &spec->private_imux[0];
         int i, idx1;
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
@@ -11617,9 +11973,14 @@ static int alc268_parse_auto_config(struct hda_codec *codec)
                                            alc268_ignore);
         if (err < 0)
                 return err;
-        if (!spec->autocfg.line_outs)
+        if (!spec->autocfg.line_outs) {
+                if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
+                        spec->multiout.max_channels = 2;
+                        spec->no_analog = 1;
+                        goto dig_only;
+                }
                 return 0; /* can't find valid BIOS pin config */
-
+        }
         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -11629,25 +11990,26 @@ static int alc268_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = 2;
 
+ dig_only:
         /* digital only support output */
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs) {
                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
-
+                spec->dig_out_type = spec->autocfg.dig_out_type[0];
+        }
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
 
-        if (spec->autocfg.speaker_pins[0] != 0x1d)
+        if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
                 add_mixer(spec, alc268_beep_mixer);
 
         add_verb(spec, alc268_volume_init_verbs);
         spec->num_mux_defs = 1;
-        spec->input_mux = &spec->private_imux;
+        spec->input_mux = &spec->private_imux[0];
 
         err = alc_auto_add_mic_boost(codec);
         if (err < 0)
                 return err;
 
-        store_pin_configs(codec);
         return 1;
 }
 
@@ -11709,7 +12071,7 @@ static struct snd_pci_quirk alc268_cfg_tbl[] = {
 
 static struct alc_config_preset alc268_presets[] = {
         [ALC267_QUANTA_IL1] = {
-                .mixers = { alc267_quanta_il1_mixer },
+                .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
                                 alc267_quanta_il1_verbs },
                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
@@ -11791,7 +12153,8 @@ static struct alc_config_preset alc268_presets[] = {
         },
         [ALC268_ACER_ASPIRE_ONE] = {
                 .mixers = { alc268_acer_aspire_one_mixer,
-                                alc268_capture_alt_mixer },
+                            alc268_beep_mixer,
+                            alc268_capture_alt_mixer },
                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
                                 alc268_acer_aspire_one_verbs },
                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
@@ -11860,7 +12223,7 @@ static int patch_alc268(struct hda_codec *codec)
 {
         struct alc_spec *spec;
         int board_config;
-        int err;
+        int i, has_beep, err;
 
         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -11909,15 +12272,30 @@ static int patch_alc268(struct hda_codec *codec)
 
         spec->stream_digital_playback = &alc268_pcm_digital_playback;
 
-        if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
-                /* override the amp caps for beep generator */
-                snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
+        has_beep = 0;
+        for (i = 0; i < spec->num_mixers; i++) {
+                if (spec->mixers[i] == alc268_beep_mixer) {
+                        has_beep = 1;
+                        break;
+                }
+        }
+
+        if (has_beep) {
+                err = snd_hda_attach_beep_device(codec, 0x1);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                }
+                if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
+                        /* override the amp caps for beep generator */
+                        snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
                                           (0 << AC_AMPCAP_MUTE_SHIFT));
+        }
 
-        if (!spec->adc_nids && spec->input_mux) {
+        if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
                 /* check whether NID 0x07 is valid */
                 unsigned int wcap = get_wcaps(codec, 0x07);
                 int i;
@@ -11998,8 +12376,6 @@ static struct snd_kcontrol_new alc269_base_mixer[] = {
         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
@@ -12026,8 +12402,6 @@ static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x04, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x04, HDA_INPUT),
         { }
 };
 
@@ -12051,8 +12425,6 @@ static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x04, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x04, HDA_INPUT),
         { }
 };
 
@@ -12089,13 +12461,6 @@ static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
         { } /* end */
 };
 
-/* beep control */
-static struct snd_kcontrol_new alc269_beep_mixer[] = {
-        HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
-        { } /* end */
-};
-
 static struct hda_verb alc269_quanta_fl1_verbs[] = {
         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
@@ -12495,7 +12860,7 @@ static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
          */
         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
-                struct hda_input_mux *imux = &spec->private_imux;
+                struct hda_input_mux *imux = &spec->private_imux[0];
                 imux->items[imux->num_items].label = "Int Mic";
                 imux->items[imux->num_items].index = 0x05;
                 imux->num_items++;
@@ -12513,13 +12878,34 @@ static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
 
+static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 8,
+        .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
+        /* NID is set in alc_build_pcms */
+        .ops = {
+                .open = alc880_playback_pcm_open,
+                .prepare = alc880_playback_pcm_prepare,
+                .cleanup = alc880_playback_pcm_cleanup
+        },
+};
+
+static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
+        /* NID is set in alc_build_pcms */
+};
+
 /*
  * BIOS auto configuration
  */
 static int alc269_parse_auto_config(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        int i, err;
+        int err;
         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
 
         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
@@ -12536,22 +12922,15 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
 
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
 
-        /* create a beep mixer control if the pin 0x1d isn't assigned */
-        for (i = 0; i < ARRAY_SIZE(spec->autocfg.input_pins); i++)
-                if (spec->autocfg.input_pins[i] == 0x1d)
-                        break;
-        if (i >= ARRAY_SIZE(spec->autocfg.input_pins))
-                add_mixer(spec, alc269_beep_mixer);
-
         add_verb(spec, alc269_init_verbs);
         spec->num_mux_defs = 1;
-        spec->input_mux = &spec->private_imux;
+        spec->input_mux = &spec->private_imux[0];
         /* set default input source */
         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
                                   0, AC_VERB_SET_CONNECT_SEL,
@@ -12561,10 +12940,9 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
         if (err < 0)
                 return err;
 
-        if (!spec->cap_mixer)
+        if (!spec->cap_mixer && !spec->no_analog)
                 set_capture_mixer(spec);
 
-        store_pin_configs(codec);
         return 1;
 }
 
@@ -12600,10 +12978,17 @@ static struct snd_pci_quirk alc269_cfg_tbl[] = {
         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
                       ALC269_ASUS_EEEPC_P703),
+        SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
+        SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
+        SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
+        SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
+        SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
+        SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
                       ALC269_ASUS_EEEPC_P901),
         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
                       ALC269_ASUS_EEEPC_P901),
+        SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
         {}
@@ -12661,7 +13046,7 @@ static struct alc_config_preset alc269_presets[] = {
                 .init_hook = alc269_eeepc_dmic_inithook,
         },
         [ALC269_FUJITSU] = {
-                .mixers = { alc269_fujitsu_mixer, alc269_beep_mixer },
+                .mixers = { alc269_fujitsu_mixer },
                 .cap_mixer = alc269_epc_capture_mixer,
                 .init_verbs = { alc269_init_verbs,
                                 alc269_eeepc_dmic_init_verbs },
@@ -12726,13 +13111,26 @@ static int patch_alc269(struct hda_codec *codec)
                 }
         }
 
+        err = snd_hda_attach_beep_device(codec, 0x1);
+        if (err < 0) {
+                alc_free(codec);
+                return err;
+        }
+
         if (board_config != ALC269_AUTO)
                 setup_preset(spec, &alc269_presets[board_config]);
 
         spec->stream_name_analog = "ALC269 Analog";
-        spec->stream_analog_playback = &alc269_pcm_analog_playback;
-        spec->stream_analog_capture = &alc269_pcm_analog_capture;
-
+        if (codec->subsystem_id == 0x17aa3bf8) {
+                /* Due to a hardware problem on Lenovo Ideadpad, we need to
+                 * fix the sample rate of analog I/O to 44.1kHz
+                 */
+                spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
+                spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
+        } else {
+                spec->stream_analog_playback = &alc269_pcm_analog_playback;
+                spec->stream_analog_capture = &alc269_pcm_analog_capture;
+        }
         spec->stream_name_digital = "ALC269 Digital";
         spec->stream_digital_playback = &alc269_pcm_digital_playback;
         spec->stream_digital_capture = &alc269_pcm_digital_capture;
@@ -12742,6 +13140,7 @@ static int patch_alc269(struct hda_codec *codec)
         spec->capsrc_nids = alc269_capsrc_nids;
         if (!spec->cap_mixer)
                 set_capture_mixer(spec);
+        set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
 
         codec->patch_ops = alc_patch_ops;
         if (board_config == ALC269_AUTO)
@@ -12992,8 +13391,6 @@ static struct snd_kcontrol_new alc861_asus_mixer[] = {
 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
         { }
 };
 
@@ -13467,7 +13864,7 @@ static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
                                                 const struct auto_pin_cfg *cfg)
 {
-        struct hda_input_mux *imux = &spec->private_imux;
+        struct hda_input_mux *imux = &spec->private_imux[0];
         int i, err, idx, idx1;
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
@@ -13554,12 +13951,8 @@ static void alc861_auto_init_analog_input(struct hda_codec *codec)
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
-                if (nid >= 0x0c && nid <= 0x11) {
-                        snd_hda_codec_write(codec, nid, 0,
-                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                            i <= AUTO_PIN_FRONT_MIC ?
-                                            PIN_VREF80 : PIN_IN);
-                }
+                if (nid >= 0x0c && nid <= 0x11)
+                        alc_set_input_pin(codec, nid, i);
         }
 }
 
@@ -13595,7 +13988,7 @@ static int alc861_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
 
         if (spec->kctls.list)
@@ -13604,13 +13997,12 @@ static int alc861_parse_auto_config(struct hda_codec *codec)
         add_verb(spec, alc861_auto_init_verbs);
 
         spec->num_mux_defs = 1;
-        spec->input_mux = &spec->private_imux;
+        spec->input_mux = &spec->private_imux[0];
 
         spec->adc_nids = alc861_adc_nids;
         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
         set_capture_mixer(spec);
 
-        store_pin_configs(codec);
         return 1;
 }
 
@@ -13819,6 +14211,12 @@ static int patch_alc861(struct hda_codec *codec)
                 }
         }
 
+        err = snd_hda_attach_beep_device(codec, 0x23);
+        if (err < 0) {
+                alc_free(codec);
+                return err;
+        }
+
         if (board_config != ALC861_AUTO)
                 setup_preset(spec, &alc861_presets[board_config]);
 
@@ -13830,6 +14228,8 @@ static int patch_alc861(struct hda_codec *codec)
         spec->stream_digital_playback = &alc861_pcm_digital_playback;
         spec->stream_digital_capture = &alc861_pcm_digital_capture;
 
+        set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
+
         spec->vmaster_nid = 0x03;
 
         codec->patch_ops = alc_patch_ops;
@@ -13986,9 +14386,6 @@ static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-
         { } /* end */
 };
 
@@ -14012,9 +14409,6 @@ static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-
         { } /* end */
 };
 
@@ -14053,8 +14447,6 @@ static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT),
         { } /* end */
 };
 
@@ -14365,9 +14757,7 @@ static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
-        SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
-        SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
-        SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO),
+        SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
         {}
 };
@@ -14529,11 +14919,9 @@ static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
                 if (alc861vd_is_input_pin(nid)) {
-                        snd_hda_codec_write(codec, nid, 0,
-                                        AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                        i <= AUTO_PIN_FRONT_MIC ?
-                                                        PIN_VREF80 : PIN_IN);
-                        if (nid != ALC861VD_PIN_CD_NID)
+                        alc_set_input_pin(codec, nid, i);
+                        if (nid != ALC861VD_PIN_CD_NID &&
+                            (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
                                 snd_hda_codec_write(codec, nid, 0,
                                                 AC_VERB_SET_AMP_GAIN_MUTE,
                                                 AMP_OUT_MUTE);
@@ -14699,7 +15087,7 @@ static int alc861vd_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
 
         if (spec->kctls.list)
@@ -14708,13 +15096,12 @@ static int alc861vd_parse_auto_config(struct hda_codec *codec)
         add_verb(spec, alc861vd_volume_init_verbs);
 
         spec->num_mux_defs = 1;
-        spec->input_mux = &spec->private_imux;
+        spec->input_mux = &spec->private_imux[0];
 
         err = alc_auto_add_mic_boost(codec);
         if (err < 0)
                 return err;
 
-        store_pin_configs(codec);
         return 1;
 }
 
@@ -14765,6 +15152,12 @@ static int patch_alc861vd(struct hda_codec *codec)
                 }
         }
 
+        err = snd_hda_attach_beep_device(codec, 0x23);
+        if (err < 0) {
+                alc_free(codec);
+                return err;
+        }
+
         if (board_config != ALC861VD_AUTO)
                 setup_preset(spec, &alc861vd_presets[board_config]);
 
@@ -14787,9 +15180,10 @@ static int patch_alc861vd(struct hda_codec *codec)
         spec->adc_nids = alc861vd_adc_nids;
         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
         spec->capsrc_nids = alc861vd_capsrc_nids;
-        spec->is_mix_capture = 1;
+        spec->capture_style = CAPT_MIX;
 
         set_capture_mixer(spec);
+        set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
         spec->vmaster_nid = 0x02;
 
@@ -14825,12 +15219,23 @@ static hda_nid_t alc662_dac_nids[4] = {
         0x02, 0x03, 0x04
 };
 
+static hda_nid_t alc272_dac_nids[2] = {
+        0x02, 0x03
+};
+
 static hda_nid_t alc662_adc_nids[1] = {
         /* ADC1-2 */
         0x09,
 };
 
+static hda_nid_t alc272_adc_nids[1] = {
+        /* ADC1-2 */
+        0x08,
+};
+
 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
+static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
+
 
 /* input MUX */
 /* FIXME: should be a matrix-type input source selection */
@@ -14978,8 +15383,6 @@ static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         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),
         { } /* end */
 };
 
@@ -15001,8 +15404,6 @@ static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
         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),
         { } /* end */
 };
 
@@ -15260,14 +15661,7 @@ static struct hda_verb alc662_init_verbs[] = {
         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
         /* Input mixer */
         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
 
         /* always trun on EAPD */
         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
@@ -15462,12 +15856,48 @@ static struct hda_verb alc662_ecs_init_verbs[] = {
         {}
 };
 
+static struct hda_verb alc272_dell_zm1_init_verbs[] = {
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
+        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {}
+};
+
+static struct hda_verb alc272_dell_init_verbs[] = {
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
+        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {}
+};
+
 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
         { } /* end */
 };
 
+static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        { } /* end */
+};
+
 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
 {
         unsigned int present;
@@ -15978,56 +16408,68 @@ static const char *alc662_models[ALC662_MODEL_LAST] = {
 };
 
 static struct snd_pci_quirk alc662_cfg_tbl[] = {
-        SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
-        SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
-        SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
-        SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
-        SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
-        SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
-        SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
+        SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
+        SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
-        SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
-        SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
-        SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
+        SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
-        SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
-        SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
-        SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
-        SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
-        SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
+        SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
+        SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
+        SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
+        SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
-        SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
-        SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
+        SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
+        SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
-        SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
-        SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
-        SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
-        SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
+        /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
-        SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
-        SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
-        SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
+        SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
+        SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
+        /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
+        SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
+        SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
-        SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
-        SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
-        SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
-        SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
+        SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
+        SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
+        SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
+        SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
                       ALC662_3ST_6ch_DIG),
-        SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
-        SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
-        SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
                       ALC662_3ST_6ch_DIG),
         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
+        SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
+        SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
                                         ALC662_3ST_6ch_DIG),
-        SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13),
-        SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13),
-        SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13),
+        SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
+                           ALC663_ASUS_H13),
         {}
 };
 
@@ -16260,6 +16702,36 @@ static struct alc_config_preset alc662_presets[] = {
                 .unsol_event = alc663_mode6_unsol_event,
                 .init_hook = alc663_mode6_inithook,
         },
+        [ALC272_DELL] = {
+                .mixers = { alc663_m51va_mixer },
+                .cap_mixer = alc272_auto_capture_mixer,
+                .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc272_dac_nids),
+                .dac_nids = alc662_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
+                .adc_nids = alc272_adc_nids,
+                .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
+                .capsrc_nids = alc272_capsrc_nids,
+                .channel_mode = alc662_3ST_2ch_modes,
+                .input_mux = &alc663_m51va_capture_source,
+                .unsol_event = alc663_m51va_unsol_event,
+                .init_hook = alc663_m51va_inithook,
+        },
+        [ALC272_DELL_ZM1] = {
+                .mixers = { alc663_m51va_mixer },
+                .cap_mixer = alc662_auto_capture_mixer,
+                .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc272_dac_nids),
+                .dac_nids = alc662_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
+                .adc_nids = alc662_adc_nids,
+                .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
+                .capsrc_nids = alc662_capsrc_nids,
+                .channel_mode = alc662_3ST_2ch_modes,
+                .input_mux = &alc663_m51va_capture_source,
+                .unsol_event = alc663_m51va_unsol_event,
+                .init_hook = alc663_m51va_inithook,
+        },
 };
 
 
@@ -16347,7 +16819,7 @@ static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
 
         if (alc880_is_fixed_pin(pin)) {
                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
-                /* printk("DAC nid=%x\n",nid); */
+                /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
                 /* specify the DAC as the extra output */
                 if (!spec->multiout.hp_nid)
                         spec->multiout.hp_nid = nid;
@@ -16377,26 +16849,58 @@ static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
         return 0;
 }
 
+/* return the index of the src widget from the connection list of the nid.
+ * return -1 if not found
+ */
+static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
+                                hda_nid_t src)
+{
+        hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
+        int i, conns;
+
+        conns = snd_hda_get_connections(codec, nid, conn_list,
+                                        ARRAY_SIZE(conn_list));
+        if (conns < 0)
+                return -1;
+        for (i = 0; i < conns; i++)
+                if (conn_list[i] == src)
+                        return i;
+        return -1;
+}
+
+static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
+{
+        unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
+        return (pincap & AC_PINCAP_IN) != 0;
+}
+
 /* create playback/capture controls for input pins */
-static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
+static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
                                                 const struct auto_pin_cfg *cfg)
 {
-        struct hda_input_mux *imux = &spec->private_imux;
+        struct alc_spec *spec = codec->spec;
+        struct hda_input_mux *imux = &spec->private_imux[0];
         int i, err, idx;
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
-                if (alc880_is_input_pin(cfg->input_pins[i])) {
-                        idx = alc880_input_pin_idx(cfg->input_pins[i]);
-                        err = new_analog_input(spec, cfg->input_pins[i],
-                                               auto_pin_cfg_labels[i],
-                                               idx, 0x0b);
-                        if (err < 0)
-                                return err;
-                        imux->items[imux->num_items].label =
-                                auto_pin_cfg_labels[i];
-                        imux->items[imux->num_items].index =
-                                alc880_input_pin_idx(cfg->input_pins[i]);
-                        imux->num_items++;
+                if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
+                        idx = alc662_input_pin_idx(codec, 0x0b,
+                                                   cfg->input_pins[i]);
+                        if (idx >= 0) {
+                                err = new_analog_input(spec, cfg->input_pins[i],
+                                                       auto_pin_cfg_labels[i],
+                                                       idx, 0x0b);
+                                if (err < 0)
+                                        return err;
+                        }
+                        idx = alc662_input_pin_idx(codec, 0x22,
+                                                   cfg->input_pins[i]);
+                        if (idx >= 0) {
+                                imux->items[imux->num_items].label =
+                                        auto_pin_cfg_labels[i];
+                                imux->items[imux->num_items].index = idx;
+                                imux->num_items++;
+                        }
                 }
         }
         return 0;
@@ -16446,7 +16950,6 @@ static void alc662_auto_init_hp_out(struct hda_codec *codec)
                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
 }
 
-#define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
 
 static void alc662_auto_init_analog_input(struct hda_codec *codec)
@@ -16456,12 +16959,10 @@ static void alc662_auto_init_analog_input(struct hda_codec *codec)
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
-                if (alc662_is_input_pin(nid)) {
-                        snd_hda_codec_write(codec, nid, 0,
-                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                            (i <= AUTO_PIN_FRONT_MIC ?
-                                             PIN_VREF80 : PIN_IN));
-                        if (nid != ALC662_PIN_CD_NID)
+                if (alc662_is_input_pin(codec, nid)) {
+                        alc_set_input_pin(codec, nid, i);
+                        if (nid != ALC662_PIN_CD_NID &&
+                            (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
                                 snd_hda_codec_write(codec, nid, 0,
                                                     AC_VERB_SET_AMP_GAIN_MUTE,
                                                     AMP_OUT_MUTE);
@@ -16499,20 +17000,20 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
                                            "Headphone");
         if (err < 0)
                 return err;
-        err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
 
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
 
         spec->num_mux_defs = 1;
-        spec->input_mux = &spec->private_imux;
+        spec->input_mux = &spec->private_imux[0];
 
         add_verb(spec, alc662_auto_init_verbs);
         if (codec->vendor_id == 0x10ec0663)
@@ -16522,7 +17023,6 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
         if (err < 0)
                 return err;
 
-        store_pin_configs(codec);
         return 1;
 }
 
@@ -16574,6 +17074,12 @@ static int patch_alc662(struct hda_codec *codec)
                 }
         }
 
+        err = snd_hda_attach_beep_device(codec, 0x1);
+        if (err < 0) {
+                alc_free(codec);
+                return err;
+        }
+
         if (board_config != ALC662_AUTO)
                 setup_preset(spec, &alc662_presets[board_config]);
 
@@ -16597,10 +17103,14 @@ static int patch_alc662(struct hda_codec *codec)
         spec->adc_nids = alc662_adc_nids;
         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
         spec->capsrc_nids = alc662_capsrc_nids;
-        spec->is_mix_capture = 1;
+        spec->capture_style = CAPT_MIX;
 
         if (!spec->cap_mixer)
                 set_capture_mixer(spec);
+        if (codec->vendor_id == 0x10ec0662)
+                set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
+        else
+                set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
 
         spec->vmaster_nid = 0x02;
 
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 35b83dc6e19e..917bc5d3ac2c 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -43,6 +43,7 @@ enum {
 };
 
 enum {
+        STAC_AUTO,
         STAC_REF,
         STAC_9200_OQO,
         STAC_9200_DELL_D21,
@@ -55,20 +56,24 @@ enum {
         STAC_9200_DELL_M25,
         STAC_9200_DELL_M26,
         STAC_9200_DELL_M27,
-        STAC_9200_GATEWAY,
+        STAC_9200_M4,
+        STAC_9200_M4_2,
         STAC_9200_PANASONIC,
         STAC_9200_MODELS
 };
 
 enum {
+        STAC_9205_AUTO,
         STAC_9205_REF,
         STAC_9205_DELL_M42,
         STAC_9205_DELL_M43,
         STAC_9205_DELL_M44,
+        STAC_9205_EAPD,
         STAC_9205_MODELS
 };
 
 enum {
+        STAC_92HD73XX_AUTO,
         STAC_92HD73XX_NO_JD, /* no jack-detection */
         STAC_92HD73XX_REF,
         STAC_DELL_M6_AMIC,
@@ -79,28 +84,40 @@ enum {
 };
 
 enum {
+        STAC_92HD83XXX_AUTO,
         STAC_92HD83XXX_REF,
+        STAC_92HD83XXX_PWR_REF,
+        STAC_DELL_S14,
         STAC_92HD83XXX_MODELS
 };
 
 enum {
+        STAC_92HD71BXX_AUTO,
         STAC_92HD71BXX_REF,
         STAC_DELL_M4_1,
         STAC_DELL_M4_2,
         STAC_DELL_M4_3,
         STAC_HP_M4,
+        STAC_HP_DV5,
+        STAC_HP_HDX,
         STAC_92HD71BXX_MODELS
 };
 
 enum {
+        STAC_925x_AUTO,
         STAC_925x_REF,
+        STAC_M1,
+        STAC_M1_2,
+        STAC_M2,
         STAC_M2_2,
-        STAC_MA6,
-        STAC_PA6,
+        STAC_M3,
+        STAC_M5,
+        STAC_M6,
         STAC_925x_MODELS
 };
 
 enum {
+        STAC_922X_AUTO,
         STAC_D945_REF,
         STAC_D945GTP3,
         STAC_D945GTP5,
@@ -128,6 +145,7 @@ enum {
 };
 
 enum {
+        STAC_927X_AUTO,
         STAC_D965_REF_NO_JD, /* no jack-detection */
         STAC_D965_REF,
         STAC_D965_3ST,
@@ -137,6 +155,12 @@ enum {
         STAC_927X_MODELS
 };
 
+enum {
+        STAC_9872_AUTO,
+        STAC_9872_VAIO,
+        STAC_9872_MODELS
+};
+
 struct sigmatel_event {
         hda_nid_t nid;
         unsigned char type;
@@ -160,6 +184,7 @@ struct sigmatel_spec {
         unsigned int alt_switch: 1;
         unsigned int hp_detect: 1;
         unsigned int spdif_mute: 1;
+        unsigned int check_volume_offset:1;
 
         /* gpio lines */
         unsigned int eapd_mask;
@@ -172,6 +197,7 @@ struct sigmatel_spec {
         unsigned int stream_delay;
 
         /* analog loopback */
+        struct snd_kcontrol_new *aloopback_ctl;
         unsigned char aloopback_mask;
         unsigned char aloopback_shift;
 
@@ -196,6 +222,8 @@ struct sigmatel_spec {
         hda_nid_t hp_dacs[5];
         hda_nid_t speaker_dacs[5];
 
+        int volume_offset;
+
         /* capture */
         hda_nid_t *adc_nids;
         unsigned int num_adcs;
@@ -217,7 +245,6 @@ struct sigmatel_spec {
         /* pin widgets */
         hda_nid_t *pin_nids;
         unsigned int num_pins;
-        unsigned int *pin_configs;
 
         /* codec specific stuff */
         struct hda_verb *init;
@@ -328,7 +355,11 @@ static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
 };
 
 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
-        0x03, 0x0c, 0x10, 0x40,
+        0x03, 0x0c, 0x20, 0x40,
+};
+
+static hda_nid_t stac92hd83xxx_amp_nids[1] = {
+        0xc,
 };
 
 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
@@ -389,6 +420,10 @@ static hda_nid_t stac922x_mux_nids[2] = {
         0x12, 0x13,
 };
 
+static hda_nid_t stac927x_slave_dig_outs[2] = {
+        0x1f, 0,
+};
+
 static hda_nid_t stac927x_adc_nids[3] = {
         0x07, 0x08, 0x09
 };
@@ -461,15 +496,21 @@ static hda_nid_t stac92hd73xx_pin_nids[13] = {
         0x14, 0x22, 0x23
 };
 
-static hda_nid_t stac92hd83xxx_pin_nids[14] = {
+static hda_nid_t stac92hd83xxx_pin_nids[10] = {
         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
-        0x0f, 0x10, 0x11, 0x12, 0x13,
-        0x1d, 0x1e, 0x1f, 0x20
+        0x0f, 0x10, 0x11, 0x1f, 0x20,
 };
-static hda_nid_t stac92hd71bxx_pin_nids[11] = {
+
+#define STAC92HD71BXX_NUM_PINS 13
+static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
+        0x0a, 0x0b, 0x0c, 0x0d, 0x00,
+        0x00, 0x14, 0x18, 0x19, 0x1e,
+        0x1f, 0x20, 0x27
+};
+static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
         0x0f, 0x14, 0x18, 0x19, 0x1e,
-        0x1f,
+        0x1f, 0x20, 0x27
 };
 
 static hda_nid_t stac927x_pin_nids[14] = {
@@ -831,13 +872,9 @@ static struct hda_verb stac92hd73xx_10ch_core_init[] = {
 };
 
 static struct hda_verb stac92hd83xxx_core_init[] = {
-        /* start of config #1 */
-        { 0xe, AC_VERB_SET_CONNECT_SEL, 0x3},
-
-        /* start of config #2 */
-        { 0xa, AC_VERB_SET_CONNECT_SEL, 0x0},
-        { 0xb, AC_VERB_SET_CONNECT_SEL, 0x0},
-        { 0xd, AC_VERB_SET_CONNECT_SEL, 0x1},
+        { 0xa, AC_VERB_SET_CONNECT_SEL, 0x1},
+        { 0xb, AC_VERB_SET_CONNECT_SEL, 0x1},
+        { 0xd, AC_VERB_SET_CONNECT_SEL, 0x0},
 
         /* power state controls amps */
         { 0x01, AC_VERB_SET_EAPD, 1 << 2},
@@ -847,26 +884,25 @@ static struct hda_verb stac92hd83xxx_core_init[] = {
 static struct hda_verb stac92hd71bxx_core_init[] = {
         /* set master volume and direct control */
         { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-        /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
-        { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         {}
 };
 
-#define HD_DISABLE_PORTF 2
+#define HD_DISABLE_PORTF 1
 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
         /* start of config #1 */
 
         /* connect port 0f to audio mixer */
         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
-        /* unmute right and left channels for node 0x0f */
-        { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         /* start of config #2 */
 
         /* set master volume and direct control */
         { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-        /* unmute right and left channels for nodes 0x0a, 0xd */
+        {}
+};
+
+static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
+        /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
+        { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         {}
@@ -875,6 +911,8 @@ static struct hda_verb stac92hd71bxx_analog_core_init[] = {
 static struct hda_verb stac925x_core_init[] = {
         /* set dac0mux for dac converter */
         { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* mute the master volume */
+        { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
         {}
 };
 
@@ -945,16 +983,6 @@ static struct hda_verb stac9205_core_init[] = {
                 .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
         }
 
-#define STAC_INPUT_SOURCE(cnt) \
-        { \
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
-                .name = "Input Source", \
-                .count = cnt, \
-                .info = stac92xx_mux_enum_info, \
-                .get = stac92xx_mux_enum_get, \
-                .put = stac92xx_mux_enum_put, \
-        }
-
 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
         { \
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
@@ -969,7 +997,6 @@ static struct hda_verb stac9205_core_init[] = {
 static struct snd_kcontrol_new stac9200_mixer[] = {
         HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
-        STAC_INPUT_SOURCE(1),
         HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
         { } /* end */
@@ -994,8 +1021,6 @@ static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
         HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
         HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
 
-        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
-
         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
 
@@ -1005,9 +1030,22 @@ static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
         { } /* end */
 };
 
-static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
+static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
+        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
+        {}
+};
+
+static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
+        {}
+};
+
+static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
+        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
+        {}
+};
 
+static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
 
@@ -1032,8 +1070,6 @@ static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
 };
 
 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
-        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
-
         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
 
@@ -1085,9 +1121,6 @@ static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
 };
 
 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
-        STAC_INPUT_SOURCE(2),
-        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
-
         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
 
@@ -1113,10 +1146,11 @@ static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
         { } /* end */
 };
 
-static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
-        STAC_INPUT_SOURCE(2),
-        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
+static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
+        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
+};
 
+static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
 
@@ -1126,16 +1160,14 @@ static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
 };
 
 static struct snd_kcontrol_new stac925x_mixer[] = {
-        STAC_INPUT_SOURCE(1),
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
         { } /* end */
 };
 
 static struct snd_kcontrol_new stac9205_mixer[] = {
-        STAC_INPUT_SOURCE(2),
-        STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
-
         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
 
@@ -1144,9 +1176,13 @@ static struct snd_kcontrol_new stac9205_mixer[] = {
         { } /* end */
 };
 
+static struct snd_kcontrol_new stac9205_loopback[] = {
+        STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
+        {}
+};
+
 /* This needs to be generated dynamically based on sequence */
 static struct snd_kcontrol_new stac922x_mixer[] = {
-        STAC_INPUT_SOURCE(2),
         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
 
@@ -1157,9 +1193,6 @@ static struct snd_kcontrol_new stac922x_mixer[] = {
 
 
 static struct snd_kcontrol_new stac927x_mixer[] = {
-        STAC_INPUT_SOURCE(3),
-        STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
-
         HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
 
@@ -1171,6 +1204,11 @@ static struct snd_kcontrol_new stac927x_mixer[] = {
         { } /* end */
 };
 
+static struct snd_kcontrol_new stac927x_loopback[] = {
+        STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
+        {}
+};
+
 static struct snd_kcontrol_new stac_dmux_mixer = {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         .name = "Digital Input Source",
@@ -1196,10 +1234,7 @@ static const char *slave_vols[] = {
         "LFE Playback Volume",
         "Side Playback Volume",
         "Headphone Playback Volume",
-        "Headphone Playback Volume",
         "Speaker Playback Volume",
-        "External Speaker Playback Volume",
-        "Speaker2 Playback Volume",
         NULL
 };
 
@@ -1210,10 +1245,7 @@ static const char *slave_sws[] = {
         "LFE Playback Switch",
         "Side Playback Switch",
         "Headphone Playback Switch",
-        "Headphone Playback Switch",
         "Speaker Playback Switch",
-        "External Speaker Playback Switch",
-        "Speaker2 Playback Switch",
         "IEC958 Playback Switch",
         NULL
 };
@@ -1283,6 +1315,8 @@ static int stac92xx_build_controls(struct hda_codec *codec)
                 unsigned int vmaster_tlv[4];
                 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
                                         HDA_OUTPUT, vmaster_tlv);
+                /* correct volume offset */
+                vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
                                           vmaster_tlv, slave_vols);
                 if (err < 0)
@@ -1295,6 +1329,13 @@ static int stac92xx_build_controls(struct hda_codec *codec)
                         return err;
         }
 
+        if (spec->aloopback_ctl &&
+            snd_hda_get_bool_hint(codec, "loopback") == 1) {
+                err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
+                if (err < 0)
+                        return err;
+        }
+
         stac92xx_free_kctls(codec); /* no longer needed */
 
         /* create jack input elements */
@@ -1334,7 +1375,16 @@ static unsigned int ref9200_pin_configs[8] = {
         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
 };
 
-/* 
+static unsigned int gateway9200_m4_pin_configs[8] = {
+        0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
+        0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
+};
+static unsigned int gateway9200_m4_2_pin_configs[8] = {
+        0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
+        0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
+};
+
+/*
     STAC 9200 pin configs for
     102801A8
     102801DE
@@ -1464,10 +1514,13 @@ static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
         [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
         [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
         [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
+        [STAC_9200_M4] = gateway9200_m4_pin_configs,
+        [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
         [STAC_9200_PANASONIC] = ref9200_pin_configs,
 };
 
 static const char *stac9200_models[STAC_9200_MODELS] = {
+        [STAC_AUTO] = "auto",
         [STAC_REF] = "ref",
         [STAC_9200_OQO] = "oqo",
         [STAC_9200_DELL_D21] = "dell-d21",
@@ -1480,7 +1533,8 @@ static const char *stac9200_models[STAC_9200_MODELS] = {
         [STAC_9200_DELL_M25] = "dell-m25",
         [STAC_9200_DELL_M26] = "dell-m26",
         [STAC_9200_DELL_M27] = "dell-m27",
-        [STAC_9200_GATEWAY] = "gateway",
+        [STAC_9200_M4] = "gateway-m4",
+        [STAC_9200_M4_2] = "gateway-m4-2",
         [STAC_9200_PANASONIC] = "panasonic",
 };
 
@@ -1488,6 +1542,8 @@ static struct snd_pci_quirk stac9200_cfg_tbl[] = {
         /* SigmaTel reference board */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
                       "DFI LanParty", STAC_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
+                      "DFI LanParty", STAC_REF),
         /* Dell laptops have BIOS problem */
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
                       "unknown Dell", STAC_9200_DELL_D21),
@@ -1550,11 +1606,9 @@ static struct snd_pci_quirk stac9200_cfg_tbl[] = {
         /* Panasonic */
         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
         /* Gateway machines needs EAPD to be set on resume */
-        SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
-        SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
-                      STAC_9200_GATEWAY),
-        SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
-                      STAC_9200_GATEWAY),
+        SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
+        SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
+        SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
         /* OQO Mobile */
         SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
         {} /* terminator */
@@ -1565,44 +1619,87 @@ static unsigned int ref925x_pin_configs[8] = {
         0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
 };
 
-static unsigned int stac925x_MA6_pin_configs[8] = {
-        0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
-        0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
+static unsigned int stac925xM1_pin_configs[8] = {
+        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
+        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
 };
 
-static unsigned int stac925x_PA6_pin_configs[8] = {
-        0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
-        0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
+static unsigned int stac925xM1_2_pin_configs[8] = {
+        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
+        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
+};
+
+static unsigned int stac925xM2_pin_configs[8] = {
+        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
+        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
 };
 
 static unsigned int stac925xM2_2_pin_configs[8] = {
-        0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
-        0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
+        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
+        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
+};
+
+static unsigned int stac925xM3_pin_configs[8] = {
+        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
+        0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
+};
+
+static unsigned int stac925xM5_pin_configs[8] = {
+        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
+        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
+};
+
+static unsigned int stac925xM6_pin_configs[8] = {
+        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
+        0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
 };
 
 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
         [STAC_REF] = ref925x_pin_configs,
+        [STAC_M1] = stac925xM1_pin_configs,
+        [STAC_M1_2] = stac925xM1_2_pin_configs,
+        [STAC_M2] = stac925xM2_pin_configs,
         [STAC_M2_2] = stac925xM2_2_pin_configs,
-        [STAC_MA6] = stac925x_MA6_pin_configs,
-        [STAC_PA6] = stac925x_PA6_pin_configs,
+        [STAC_M3] = stac925xM3_pin_configs,
+        [STAC_M5] = stac925xM5_pin_configs,
+        [STAC_M6] = stac925xM6_pin_configs,
 };
 
 static const char *stac925x_models[STAC_925x_MODELS] = {
+        [STAC_925x_AUTO] = "auto",
         [STAC_REF] = "ref",
+        [STAC_M1] = "m1",
+        [STAC_M1_2] = "m1-2",
+        [STAC_M2] = "m2",
         [STAC_M2_2] = "m2-2",
-        [STAC_MA6] = "m6",
-        [STAC_PA6] = "pa6",
+        [STAC_M3] = "m3",
+        [STAC_M5] = "m5",
+        [STAC_M6] = "m6",
+};
+
+static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
+        SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
+        SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
+        SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
+        SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
+        /* Not sure about the brand name for those */
+        SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
+        SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
+        SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
+        SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
+        {} /* terminator */
 };
 
 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
         /* SigmaTel reference board */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
         SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
-        SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
-        SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
-        SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
-        SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
-        SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
+
+        /* Default table for unknown ID */
+        SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
+
         {} /* terminator */
 };
 
@@ -1629,6 +1726,7 @@ static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
 };
 
 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
+        [STAC_92HD73XX_AUTO] = "auto",
         [STAC_92HD73XX_NO_JD] = "no-jd",
         [STAC_92HD73XX_REF] = "ref",
         [STAC_DELL_M6_AMIC] = "dell-m6-amic",
@@ -1641,6 +1739,8 @@ static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
         /* SigmaTel reference board */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
                                 "DFI LanParty", STAC_92HD73XX_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
+                                "DFI LanParty", STAC_92HD73XX_REF),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
                                 "Dell Studio 1535", STAC_DELL_M6_DMIC),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
@@ -1664,50 +1764,68 @@ static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
         {} /* terminator */
 };
 
-static unsigned int ref92hd83xxx_pin_configs[14] = {
+static unsigned int ref92hd83xxx_pin_configs[10] = {
         0x02214030, 0x02211010, 0x02a19020, 0x02170130,
         0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
-        0x40f000f0, 0x40f000f0, 0x40f000f0, 0x40f000f0,
         0x01451160, 0x98560170,
 };
 
+static unsigned int dell_s14_pin_configs[10] = {
+        0x02214030, 0x02211010, 0x02a19020, 0x01014050,
+        0x40f000f0, 0x01819040, 0x40f000f0, 0x90a60160,
+        0x40f000f0, 0x40f000f0,
+};
+
 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
         [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
+        [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
+        [STAC_DELL_S14] = dell_s14_pin_configs,
 };
 
 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
+        [STAC_92HD83XXX_AUTO] = "auto",
         [STAC_92HD83XXX_REF] = "ref",
+        [STAC_92HD83XXX_PWR_REF] = "mic-ref",
+        [STAC_DELL_S14] = "dell-s14",
 };
 
 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
         /* SigmaTel reference board */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
-                      "DFI LanParty", STAC_92HD71BXX_REF),
+                      "DFI LanParty", STAC_92HD83XXX_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
+                      "DFI LanParty", STAC_92HD83XXX_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
+                      "unknown Dell", STAC_DELL_S14),
         {} /* terminator */
 };
 
-static unsigned int ref92hd71bxx_pin_configs[11] = {
+static unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
         0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
         0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
-        0x90a000f0, 0x01452050, 0x01452050,
+        0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
+        0x00000000
 };
 
-static unsigned int dell_m4_1_pin_configs[11] = {
+static unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
         0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
         0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
-        0x40f000f0, 0x4f0000f0, 0x4f0000f0,
+        0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
+        0x00000000
 };
 
-static unsigned int dell_m4_2_pin_configs[11] = {
+static unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
         0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
         0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
-        0x40f000f0, 0x044413b0, 0x044413b0,
+        0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
+        0x00000000
 };
 
-static unsigned int dell_m4_3_pin_configs[11] = {
+static unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
         0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
         0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
-        0x40f000f0, 0x044413b0, 0x044413b0,
+        0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
+        0x00000000
 };
 
 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
@@ -1716,28 +1834,39 @@ static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
         [STAC_DELL_M4_2]        = dell_m4_2_pin_configs,
         [STAC_DELL_M4_3]        = dell_m4_3_pin_configs,
         [STAC_HP_M4]            = NULL,
+        [STAC_HP_DV5]           = NULL,
+        [STAC_HP_HDX]           = NULL,
 };
 
 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
+        [STAC_92HD71BXX_AUTO] = "auto",
         [STAC_92HD71BXX_REF] = "ref",
         [STAC_DELL_M4_1] = "dell-m4-1",
         [STAC_DELL_M4_2] = "dell-m4-2",
         [STAC_DELL_M4_3] = "dell-m4-3",
         [STAC_HP_M4] = "hp-m4",
+        [STAC_HP_DV5] = "hp-dv5",
+        [STAC_HP_HDX] = "hp-hdx",
 };
 
 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
         /* SigmaTel reference board */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
                       "DFI LanParty", STAC_92HD71BXX_REF),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f2,
-                      "HP dv5", STAC_HP_M4),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f4,
-                      "HP dv7", STAC_HP_M4),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fc,
-                      "HP dv7", STAC_HP_M4),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
+                      "DFI LanParty", STAC_92HD71BXX_REF),
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
+                      "HP", STAC_HP_DV5),
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
+                      "HP dv4-7", STAC_HP_DV5),
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
+                      "HP dv4-7", STAC_HP_DV5),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
+                      "HP HDX", STAC_HP_HDX),  /* HDX18 */
         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
-                                "unknown HP", STAC_HP_M4),
+                      "HP mini 1000", STAC_HP_M4),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
+                      "HP HDX", STAC_HP_HDX),  /* HDX16 */
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
                                 "unknown Dell", STAC_DELL_M4_1),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
@@ -1889,6 +2018,7 @@ static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
 };
 
 static const char *stac922x_models[STAC_922X_MODELS] = {
+        [STAC_922X_AUTO] = "auto",
         [STAC_D945_REF] = "ref",
         [STAC_D945GTP5] = "5stack",
         [STAC_D945GTP3] = "3stack",
@@ -1916,6 +2046,8 @@ static struct snd_pci_quirk stac922x_cfg_tbl[] = {
         /* SigmaTel reference board */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
                       "DFI LanParty", STAC_D945_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
+                      "DFI LanParty", STAC_D945_REF),
         /* Intel 945G based systems */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
                       "Intel D945G", STAC_D945GTP3),
@@ -1969,6 +2101,9 @@ static struct snd_pci_quirk stac922x_cfg_tbl[] = {
                       "Intel D945P", STAC_D945GTP3),
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
                       "Intel D945P", STAC_D945GTP5),
+        /* other intel */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
+                      "Intel D945", STAC_D945_REF),
         /* other systems  */
         /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
         SND_PCI_QUIRK(0x8384, 0x7680,
@@ -1993,31 +2128,7 @@ static struct snd_pci_quirk stac922x_cfg_tbl[] = {
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
                       "Dell XPS M1210", STAC_922X_DELL_M82),
         /* ECS/PC Chips boards */
-        SND_PCI_QUIRK(0x1019, 0x2144,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2608,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2633,
-                      "ECS/PC chips P17G/1333", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2811,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2812,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2813,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2814,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2815,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2816,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2817,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2818,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2819,
-                      "ECS/PC chips", STAC_ECS_202),
-        SND_PCI_QUIRK(0x1019, 0x2820,
+        SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
                       "ECS/PC chips", STAC_ECS_202),
         {} /* terminator */
 };
@@ -2060,6 +2171,7 @@ static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
 };
 
 static const char *stac927x_models[STAC_927X_MODELS] = {
+        [STAC_927X_AUTO]        = "auto",
         [STAC_D965_REF_NO_JD]   = "ref-no-jd",
         [STAC_D965_REF]         = "ref",
         [STAC_D965_3ST]         = "3stack",
@@ -2072,26 +2184,16 @@ static struct snd_pci_quirk stac927x_cfg_tbl[] = {
         /* SigmaTel reference board */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
                       "DFI LanParty", STAC_D965_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
+                      "DFI LanParty", STAC_D965_REF),
          /* Intel 946 based systems */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
         /* 965 based 3 stack systems */
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
+                           "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
+                           "Intel D965", STAC_D965_3ST),
         /* Dell 3 stack systems */
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
@@ -2107,15 +2209,10 @@ static struct snd_pci_quirk stac927x_cfg_tbl[] = {
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
         /* 965 based 5 stack systems */
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
+                           "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
+                           "Intel D965", STAC_D965_5ST),
         {} /* terminator */
 };
 
@@ -2168,19 +2265,25 @@ static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
         [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
         [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
         [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
+        [STAC_9205_EAPD] = NULL,
 };
 
 static const char *stac9205_models[STAC_9205_MODELS] = {
+        [STAC_9205_AUTO] = "auto",
         [STAC_9205_REF] = "ref",
         [STAC_9205_DELL_M42] = "dell-m42",
         [STAC_9205_DELL_M43] = "dell-m43",
         [STAC_9205_DELL_M44] = "dell-m44",
+        [STAC_9205_EAPD] = "eapd",
 };
 
 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
         /* SigmaTel reference board */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
                       "DFI LanParty", STAC_9205_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
+                      "DFI LanParty", STAC_9205_REF),
+        /* Dell */
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
                       "unknown Dell", STAC_9205_DELL_M42),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
@@ -2211,101 +2314,24 @@ static struct snd_pci_quirk stac9205_cfg_tbl[] = {
                       "Dell Inspiron", STAC_9205_DELL_M44),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
                       "Dell Vostro 1500", STAC_9205_DELL_M42),
+        /* Gateway */
+        SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
         {} /* terminator */
 };
 
-static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
+static void stac92xx_set_config_regs(struct hda_codec *codec,
+                                     unsigned int *pincfgs)
 {
         int i;
         struct sigmatel_spec *spec = codec->spec;
-        
-        kfree(spec->pin_configs);
-        spec->pin_configs = kcalloc(spec->num_pins, sizeof(*spec->pin_configs),
-                                    GFP_KERNEL);
-        if (!spec->pin_configs)
-                return -ENOMEM;
-        
-        for (i = 0; i < spec->num_pins; i++) {
-                hda_nid_t nid = spec->pin_nids[i];
-                unsigned int pin_cfg;
-                
-                pin_cfg = snd_hda_codec_read(codec, nid, 0, 
-                        AC_VERB_GET_CONFIG_DEFAULT, 0x00);      
-                snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
-                                        nid, pin_cfg);
-                spec->pin_configs[i] = pin_cfg;
-        }
-        
-        return 0;
-}
 
-static void stac92xx_set_config_reg(struct hda_codec *codec,
-                                    hda_nid_t pin_nid, unsigned int pin_config)
-{
-        int i;
-        snd_hda_codec_write(codec, pin_nid, 0,
-                            AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
-                            pin_config & 0x000000ff);
-        snd_hda_codec_write(codec, pin_nid, 0,
-                            AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
-                            (pin_config & 0x0000ff00) >> 8);
-        snd_hda_codec_write(codec, pin_nid, 0,
-                            AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
-                            (pin_config & 0x00ff0000) >> 16);
-        snd_hda_codec_write(codec, pin_nid, 0,
-                            AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
-                            pin_config >> 24);
-        i = snd_hda_codec_read(codec, pin_nid, 0,
-                               AC_VERB_GET_CONFIG_DEFAULT,
-                               0x00);   
-        snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
-                    pin_nid, i);
-}
-
-static void stac92xx_set_config_regs(struct hda_codec *codec)
-{
-        int i;
-        struct sigmatel_spec *spec = codec->spec;
-
-        if (!spec->pin_configs)
-                return;
+        if (!pincfgs)
+                return;
 
         for (i = 0; i < spec->num_pins; i++)
-                stac92xx_set_config_reg(codec, spec->pin_nids[i],
-                                        spec->pin_configs[i]);
-}
-
-static int stac_save_pin_cfgs(struct hda_codec *codec, unsigned int *pins)
-{
-        struct sigmatel_spec *spec = codec->spec;
-
-        if (!pins)
-                return stac92xx_save_bios_config_regs(codec);
-
-        kfree(spec->pin_configs);
-        spec->pin_configs = kmemdup(pins,
-                                    spec->num_pins * sizeof(*pins),
-                                    GFP_KERNEL);
-        if (!spec->pin_configs)
-                return -ENOMEM;
-
-        stac92xx_set_config_regs(codec);
-        return 0;
-}
-
-static void stac_change_pin_config(struct hda_codec *codec, hda_nid_t nid,
-                                   unsigned int cfg)
-{
-        struct sigmatel_spec *spec = codec->spec;
-        int i;
-
-        for (i = 0; i < spec->num_pins; i++) {
-                if (spec->pin_nids[i] == nid) {
-                        spec->pin_configs[i] = cfg;
-                        stac92xx_set_config_reg(codec, nid, cfg);
-                        break;
-                }
-        }
+                if (spec->pin_nids[i] && pincfgs[i])
+                        snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
+                                                 pincfgs[i]);
 }
 
 /*
@@ -2370,6 +2396,14 @@ static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
                                              stream_tag, format, substream);
 }
 
+static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                        struct hda_codec *codec,
+                                        struct snd_pcm_substream *substream)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
+}
+
 
 /*
  * Analog capture callbacks
@@ -2414,7 +2448,8 @@ static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
         .ops = {
                 .open = stac92xx_dig_playback_pcm_open,
                 .close = stac92xx_dig_playback_pcm_close,
-                .prepare = stac92xx_dig_playback_pcm_prepare
+                .prepare = stac92xx_dig_playback_pcm_prepare,
+                .cleanup = stac92xx_dig_playback_pcm_cleanup
         },
 };
 
@@ -2469,6 +2504,8 @@ static int stac92xx_build_pcms(struct hda_codec *codec)
 
         info->name = "STAC92xx Analog";
         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
+        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
+                spec->multiout.dac_nids[0];
         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
@@ -2484,7 +2521,7 @@ static int stac92xx_build_pcms(struct hda_codec *codec)
                 codec->num_pcms++;
                 info++;
                 info->name = "STAC92xx Digital";
-                info->pcm_type = HDA_PCM_TYPE_SPDIF;
+                info->pcm_type = spec->autocfg.dig_out_type[0];
                 if (spec->multiout.dig_out_nid) {
                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
@@ -2500,8 +2537,7 @@ static int stac92xx_build_pcms(struct hda_codec *codec)
 
 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
 {
-        unsigned int pincap = snd_hda_param_read(codec, nid,
-                                                 AC_PAR_PIN_CAP);
+        unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
         if (pincap & AC_PINCAP_VREF_100)
                 return AC_PINCTL_VREF_100;
@@ -2676,22 +2712,37 @@ static struct snd_kcontrol_new stac92xx_control_templates[] = {
 };
 
 /* add dynamic controls */
-static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
-                                     struct snd_kcontrol_new *ktemp,
-                                     int idx, const char *name,
-                                     unsigned long val)
+static struct snd_kcontrol_new *
+stac_control_new(struct sigmatel_spec *spec,
+                 struct snd_kcontrol_new *ktemp,
+                 const char *name)
 {
         struct snd_kcontrol_new *knew;
 
         snd_array_init(&spec->kctls, sizeof(*knew), 32);
         knew = snd_array_new(&spec->kctls);
         if (!knew)
-                return -ENOMEM;
+                return NULL;
         *knew = *ktemp;
-        knew->index = idx;
         knew->name = kstrdup(name, GFP_KERNEL);
-        if (!knew->name)
+        if (!knew->name) {
+                /* roolback */
+                memset(knew, 0, sizeof(*knew));
+                spec->kctls.alloced--;
+                return NULL;
+        }
+        return knew;
+}
+
+static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
+                                     struct snd_kcontrol_new *ktemp,
+                                     int idx, const char *name,
+                                     unsigned long val)
+{
+        struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name);
+        if (!knew)
                 return -ENOMEM;
+        knew->index = idx;
         knew->private_value = val;
         return 0;
 }
@@ -2713,6 +2764,29 @@ static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
         return stac92xx_add_control_idx(spec, type, 0, name, val);
 }
 
+static struct snd_kcontrol_new stac_input_src_temp = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Input Source",
+        .info = stac92xx_mux_enum_info,
+        .get = stac92xx_mux_enum_get,
+        .put = stac92xx_mux_enum_put,
+};
+
+static int stac92xx_add_input_source(struct sigmatel_spec *spec)
+{
+        struct snd_kcontrol_new *knew;
+        struct hda_input_mux *imux = &spec->private_imux;
+
+        if (!spec->num_adcs || imux->num_items <= 1)
+                return 0; /* no need for input source control */
+        knew = stac_control_new(spec, &stac_input_src_temp,
+                                stac_input_src_temp.name);
+        if (!knew)
+                return -ENOMEM;
+        knew->count = spec->num_adcs;
+        return 0;
+}
+
 /* check whether the line-input can be used as line-out */
 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
 {
@@ -2724,7 +2798,7 @@ static hda_nid_t check_line_out_switch(struct hda_codec *codec)
         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
                 return 0;
         nid = cfg->input_pins[AUTO_PIN_LINE];
-        pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
+        pincap = snd_hda_query_pin_caps(codec, nid);
         if (pincap & AC_PINCAP_OUT)
                 return nid;
         return 0;
@@ -2743,12 +2817,11 @@ static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
         mic_pin = AUTO_PIN_MIC;
         for (;;) {
                 hda_nid_t nid = cfg->input_pins[mic_pin];
-                def_conf = snd_hda_codec_read(codec, nid, 0,
-                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
+                def_conf = snd_hda_codec_get_pincfg(codec, nid);
                 /* some laptops have an internal analog microphone
                  * which can't be used as a output */
                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
-                        pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
+                        pincap = snd_hda_query_pin_caps(codec, nid);
                         if (pincap & AC_PINCAP_OUT)
                                 return nid;
                 }
@@ -2796,8 +2869,7 @@ static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
         conn_len = snd_hda_get_connections(codec, nid, conn,
                                            HDA_MAX_CONNECTIONS);
         for (j = 0; j < conn_len; j++) {
-                wcaps = snd_hda_param_read(codec, conn[j],
-                                           AC_PAR_AUDIO_WIDGET_CAP);
+                wcaps = get_wcaps(codec, conn[j]);
                 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
                 /* we check only analog outputs */
                 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
@@ -2812,6 +2884,16 @@ static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
                         return conn[j];
                 }
         }
+        /* if all DACs are already assigned, connect to the primary DAC */
+        if (conn_len > 1) {
+                for (j = 0; j < conn_len; j++) {
+                        if (conn[j] == spec->multiout.dac_nids[0]) {
+                                snd_hda_codec_write_cache(codec, nid, 0,
+                                                  AC_VERB_SET_CONNECT_SEL, j);
+                                break;
+                        }
+                }
+        }
         return 0;
 }
 
@@ -2852,6 +2934,26 @@ static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
                 add_spec_dacs(spec, dac);
         }
 
+        for (i = 0; i < cfg->hp_outs; i++) {
+                nid = cfg->hp_pins[i];
+                dac = get_unassigned_dac(codec, nid);
+                if (dac) {
+                        if (!spec->multiout.hp_nid)
+                                spec->multiout.hp_nid = dac;
+                        else
+                                add_spec_extra_dacs(spec, dac);
+                }
+                spec->hp_dacs[i] = dac;
+        }
+
+        for (i = 0; i < cfg->speaker_outs; i++) {
+                nid = cfg->speaker_pins[i];
+                dac = get_unassigned_dac(codec, nid);
+                if (dac)
+                        add_spec_extra_dacs(spec, dac);
+                spec->speaker_dacs[i] = dac;
+        }
+
         /* add line-in as output */
         nid = check_line_out_switch(codec);
         if (nid) {
@@ -2879,26 +2981,6 @@ static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
                 }
         }
 
-        for (i = 0; i < cfg->hp_outs; i++) {
-                nid = cfg->hp_pins[i];
-                dac = get_unassigned_dac(codec, nid);
-                if (dac) {
-                        if (!spec->multiout.hp_nid)
-                                spec->multiout.hp_nid = dac;
-                        else
-                                add_spec_extra_dacs(spec, dac);
-                }
-                spec->hp_dacs[i] = dac;
-        }
-
-        for (i = 0; i < cfg->speaker_outs; i++) {
-                nid = cfg->speaker_pins[i];
-                dac = get_unassigned_dac(codec, nid);
-                if (dac)
-                        add_spec_extra_dacs(spec, dac);
-                spec->speaker_dacs[i] = dac;
-        }
-
         snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
                    spec->multiout.num_dacs,
                    spec->multiout.dac_nids[0],
@@ -2911,24 +2993,47 @@ static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
 }
 
 /* create volume control/switch for the given prefx type */
-static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
+static int create_controls_idx(struct hda_codec *codec, const char *pfx,
+                               int idx, hda_nid_t nid, int chs)
 {
+        struct sigmatel_spec *spec = codec->spec;
         char name[32];
         int err;
 
+        if (!spec->check_volume_offset) {
+                unsigned int caps, step, nums, db_scale;
+                caps = query_amp_caps(codec, nid, HDA_OUTPUT);
+                step = (caps & AC_AMPCAP_STEP_SIZE) >>
+                        AC_AMPCAP_STEP_SIZE_SHIFT;
+                step = (step + 1) * 25; /* in .01dB unit */
+                nums = (caps & AC_AMPCAP_NUM_STEPS) >>
+                        AC_AMPCAP_NUM_STEPS_SHIFT;
+                db_scale = nums * step;
+                /* if dB scale is over -64dB, and finer enough,
+                 * let's reduce it to half
+                 */
+                if (db_scale > 6400 && nums >= 0x1f)
+                        spec->volume_offset = nums / 2;
+                spec->check_volume_offset = 1;
+        }
+
         sprintf(name, "%s Playback Volume", pfx);
-        err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
-                                   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
+        err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
+                HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
+                                        spec->volume_offset));
         if (err < 0)
                 return err;
         sprintf(name, "%s Playback Switch", pfx);
-        err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
+        err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
         if (err < 0)
                 return err;
         return 0;
 }
 
+#define create_controls(codec, pfx, nid, chs) \
+        create_controls_idx(codec, pfx, 0, nid, chs)
+
 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
 {
         if (spec->multiout.num_dacs > 4) {
@@ -2954,40 +3059,37 @@ static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
         return 1;
 }
 
-static int is_unique_dac(struct sigmatel_spec *spec, hda_nid_t nid)
-{
-        int i;
-
-        if (spec->autocfg.line_outs != 1)
-                return 0;
-        if (spec->multiout.hp_nid == nid)
-                return 0;
-        for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
-                if (spec->multiout.extra_out_nid[i] == nid)
-                        return 0;
-        return 1;
-}
-
-/* add playback controls from the parsed DAC table */
-static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
-                                               const struct auto_pin_cfg *cfg)
+/* Create output controls
+ * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
+ */
+static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
+                                 const hda_nid_t *pins,
+                                 const hda_nid_t *dac_nids,
+                                 int type)
 {
         struct sigmatel_spec *spec = codec->spec;
         static const char *chname[4] = {
                 "Front", "Surround", NULL /*CLFE*/, "Side"
         };
-        hda_nid_t nid = 0;
+        hda_nid_t nid;
         int i, err;
         unsigned int wid_caps;
 
-        for (i = 0; i < cfg->line_outs && spec->multiout.dac_nids[i]; i++) {
-                nid = spec->multiout.dac_nids[i];
-                if (i == 2) {
+        for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
+                if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
+                        wid_caps = get_wcaps(codec, pins[i]);
+                        if (wid_caps & AC_WCAP_UNSOL_CAP)
+                                spec->hp_detect = 1;
+                }
+                nid = dac_nids[i];
+                if (!nid)
+                        continue;
+                if (type != AUTO_PIN_HP_OUT && i == 2) {
                         /* Center/LFE */
-                        err = create_controls(spec, "Center", nid, 1);
+                        err = create_controls(codec, "Center", nid, 1);
                         if (err < 0)
                                 return err;
-                        err = create_controls(spec, "LFE", nid, 2);
+                        err = create_controls(codec, "LFE", nid, 2);
                         if (err < 0)
                                 return err;
 
@@ -3003,23 +3105,42 @@ static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
                         }
 
                 } else {
-                        const char *name = chname[i];
-                        /* if it's a single DAC, assign a better name */
-                        if (!i && is_unique_dac(spec, nid)) {
-                                switch (cfg->line_out_type) {
-                                case AUTO_PIN_HP_OUT:
-                                        name = "Headphone";
-                                        break;
-                                case AUTO_PIN_SPEAKER_OUT:
-                                        name = "Speaker";
-                                        break;
-                                }
+                        const char *name;
+                        int idx;
+                        switch (type) {
+                        case AUTO_PIN_HP_OUT:
+                                name = "Headphone";
+                                idx = i;
+                                break;
+                        case AUTO_PIN_SPEAKER_OUT:
+                                name = "Speaker";
+                                idx = i;
+                                break;
+                        default:
+                                name = chname[i];
+                                idx = 0;
+                                break;
                         }
-                        err = create_controls(spec, name, nid, 3);
+                        err = create_controls_idx(codec, name, idx, nid, 3);
                         if (err < 0)
                                 return err;
                 }
         }
+        return 0;
+}
+
+/* add playback controls from the parsed DAC table */
+static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
+                                               const struct auto_pin_cfg *cfg)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        int err;
+
+        err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
+                                    spec->multiout.dac_nids,
+                                    cfg->line_out_type);
+        if (err < 0)
+                return err;
 
         if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
                 err = stac92xx_add_control(spec,
@@ -3054,40 +3175,18 @@ static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
                                         struct auto_pin_cfg *cfg)
 {
         struct sigmatel_spec *spec = codec->spec;
-        hda_nid_t nid;
-        int i, err, nums;
+        int err;
+
+        err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
+                                    spec->hp_dacs, AUTO_PIN_HP_OUT);
+        if (err < 0)
+                return err;
+
+        err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
+                                    spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
+        if (err < 0)
+                return err;
 
-        nums = 0;
-        for (i = 0; i < cfg->hp_outs; i++) {
-                static const char *pfxs[] = {
-                        "Headphone", "Headphone2", "Headphone3",
-                };
-                unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
-                if (wid_caps & AC_WCAP_UNSOL_CAP)
-                        spec->hp_detect = 1;
-                if (nums >= ARRAY_SIZE(pfxs))
-                        continue;
-                nid = spec->hp_dacs[i];
-                if (!nid)
-                        continue;
-                err = create_controls(spec, pfxs[nums++], nid, 3);
-                if (err < 0)
-                        return err;
-        }
-        nums = 0;
-        for (i = 0; i < cfg->speaker_outs; i++) {
-                static const char *pfxs[] = {
-                        "Speaker", "External Speaker", "Speaker2",
-                };
-                if (nums >= ARRAY_SIZE(pfxs))
-                        continue;
-                nid = spec->speaker_dacs[i];
-                if (!nid)
-                        continue;
-                err = create_controls(spec, pfxs[nums++], nid, 3);
-                if (err < 0)
-                        return err;
-        }
         return 0;
 }
 
@@ -3296,11 +3395,7 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
                 unsigned int wcaps;
                 unsigned int def_conf;
 
-                def_conf = snd_hda_codec_read(codec,
-                                              spec->dmic_nids[i],
-                                              0,
-                                              AC_VERB_GET_CONFIG_DEFAULT,
-                                              0);
+                def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
                         continue;
 
@@ -3424,6 +3519,7 @@ static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
 {
         struct sigmatel_spec *spec = codec->spec;
+        int hp_swap = 0;
         int err;
 
         if ((err = snd_hda_parse_pin_def_config(codec,
@@ -3451,6 +3547,7 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                 spec->autocfg.line_outs = spec->autocfg.hp_outs;
                 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
                 spec->autocfg.hp_outs = 0;
+                hp_swap = 1;
         }
         if (spec->autocfg.mono_out_pin) {
                 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
@@ -3506,13 +3603,12 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                 err = stac92xx_auto_fill_dac_nids(codec);
                 if (err < 0)
                         return err;
+                err = stac92xx_auto_create_multi_out_ctls(codec,
+                                                          &spec->autocfg);
+                if (err < 0)
+                        return err;
         }
 
-        err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
-
-        if (err < 0)
-                return err;
-
         /* setup analog beep controls */
         if (spec->anabeep_nid > 0) {
                 err = stac92xx_auto_create_beep_ctls(codec,
@@ -3545,12 +3641,19 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
 #endif
 
         err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
-
         if (err < 0)
                 return err;
 
-        err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
+        /* All output parsing done, now restore the swapped hp pins */
+        if (hp_swap) {
+                memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
+                       sizeof(spec->autocfg.hp_pins));
+                spec->autocfg.hp_outs = spec->autocfg.line_outs;
+                spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
+                spec->autocfg.line_outs = 0;
+        }
 
+        err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
 
@@ -3579,11 +3682,15 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                         return err;
         }
 
+        err = stac92xx_add_input_source(spec);
+        if (err < 0)
+                return err;
+
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
         if (spec->multiout.max_channels > 2)
                 spec->surr_switch = 1;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = dig_out;
         if (dig_in && spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = dig_in;
@@ -3646,9 +3753,7 @@ static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
                 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
                         hda_nid_t pin = spec->autocfg.line_out_pins[i];
                         unsigned int defcfg;
-                        defcfg = snd_hda_codec_read(codec, pin, 0,
-                                                 AC_VERB_GET_CONFIG_DEFAULT,
-                                                 0x00);
+                        defcfg = snd_hda_codec_get_pincfg(codec, pin);
                         if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
                                 unsigned int wcaps = get_wcaps(codec, pin);
                                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
@@ -3661,7 +3766,7 @@ static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
         }
 
         if (lfe_pin) {
-                err = create_controls(spec, "LFE", lfe_pin, 1);
+                err = create_controls(codec, "LFE", lfe_pin, 1);
                 if (err < 0)
                         return err;
         }
@@ -3692,7 +3797,11 @@ static int stac9200_parse_auto_config(struct hda_codec *codec)
                         return err;
         }
 
-        if (spec->autocfg.dig_out_pin)
+        err = stac92xx_add_input_source(spec);
+        if (err < 0)
+                return err;
+
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = 0x05;
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = 0x04;
@@ -3742,16 +3851,25 @@ static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
                            AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
 }
 
+#ifdef CONFIG_SND_JACK
+static void stac92xx_free_jack_priv(struct snd_jack *jack)
+{
+        struct sigmatel_jack *jacks = jack->private_data;
+        jacks->nid = 0;
+        jacks->jack = NULL;
+}
+#endif
+
 static int stac92xx_add_jack(struct hda_codec *codec,
                 hda_nid_t nid, int type)
 {
 #ifdef CONFIG_SND_JACK
         struct sigmatel_spec *spec = codec->spec;
         struct sigmatel_jack *jack;
-        int def_conf = snd_hda_codec_read(codec, nid,
-                        0, AC_VERB_GET_CONFIG_DEFAULT, 0);
+        int def_conf = snd_hda_codec_get_pincfg(codec, nid);
         int connectivity = get_defcfg_connect(def_conf);
         char name[32];
+        int err;
 
         if (connectivity && connectivity != AC_JACK_PORT_FIXED)
                 return 0;
@@ -3768,10 +3886,15 @@ static int stac92xx_add_jack(struct hda_codec *codec,
                 snd_hda_get_jack_connectivity(def_conf),
                 snd_hda_get_jack_location(def_conf));
 
-        return snd_jack_new(codec->bus->card, name, type, &jack->jack);
-#else
-        return 0;
+        err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
+        if (err < 0) {
+                jack->nid = 0;
+                return err;
+        }
+        jack->jack->private_data = jack;
+        jack->jack->private_free = stac92xx_free_jack_priv;
 #endif
+        return 0;
 }
 
 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
@@ -3864,6 +3987,36 @@ static void stac92xx_power_down(struct hda_codec *codec)
 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
                                   int enable);
 
+/* override some hints from the hwdep entry */
+static void stac_store_hints(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        const char *p;
+        int val;
+
+        val = snd_hda_get_bool_hint(codec, "hp_detect");
+        if (val >= 0)
+                spec->hp_detect = val;
+        p = snd_hda_get_hint(codec, "gpio_mask");
+        if (p) {
+                spec->gpio_mask = simple_strtoul(p, NULL, 0);
+                spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
+                        spec->gpio_mask;
+        }
+        p = snd_hda_get_hint(codec, "gpio_dir");
+        if (p)
+                spec->gpio_dir = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
+        p = snd_hda_get_hint(codec, "gpio_data");
+        if (p)
+                spec->gpio_data = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
+        p = snd_hda_get_hint(codec, "eapd_mask");
+        if (p)
+                spec->eapd_mask = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
+        val = snd_hda_get_bool_hint(codec, "eapd_switch");
+        if (val >= 0)
+                spec->eapd_switch = val;
+}
+
 static int stac92xx_init(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec = codec->spec;
@@ -3880,6 +4033,9 @@ static int stac92xx_init(struct hda_codec *codec)
                                 spec->adc_nids[i], 0,
                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 
+        /* override some hints */
+        stac_store_hints(codec);
+
         /* set up GPIO */
         gpio = spec->gpio_data;
         /* turn on EAPD statically when spec->eapd_switch isn't set.
@@ -3929,8 +4085,7 @@ static int stac92xx_init(struct hda_codec *codec)
                                                                  pinctl);
                                 }
                         }
-                        conf = snd_hda_codec_read(codec, nid, 0,
-                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
+                        conf = snd_hda_codec_get_pincfg(codec, nid);
                         if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
                                 enable_pin_detect(codec, nid,
                                                   STAC_INSERT_EVENT);
@@ -3942,8 +4097,8 @@ static int stac92xx_init(struct hda_codec *codec)
         for (i = 0; i < spec->num_dmics; i++)
                 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
                                         AC_PINCTL_IN_EN);
-        if (cfg->dig_out_pin)
-                stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
+        if (cfg->dig_out_pins[0])
+                stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
                                          AC_PINCTL_OUT_EN);
         if (cfg->dig_in_pin)
                 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
@@ -3971,8 +4126,7 @@ static int stac92xx_init(struct hda_codec *codec)
                         stac_toggle_power_map(codec, nid, 1);
                         continue;
                 }
-                def_conf = snd_hda_codec_read(codec, nid, 0,
-                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
+                def_conf = snd_hda_codec_get_pincfg(codec, nid);
                 def_conf = get_defcfg_connect(def_conf);
                 /* skip any ports that don't have jacks since presence
                  * detection is useless */
@@ -3999,8 +4153,10 @@ static void stac92xx_free_jacks(struct hda_codec *codec)
         if (!codec->bus->shutdown && spec->jacks.list) {
                 struct sigmatel_jack *jacks = spec->jacks.list;
                 int i;
-                for (i = 0; i < spec->jacks.used; i++)
-                        snd_device_free(codec->bus->card, &jacks[i].jack);
+                for (i = 0; i < spec->jacks.used; i++, jacks++) {
+                        if (jacks->jack)
+                                snd_device_free(codec->bus->card, jacks->jack);
+                }
         }
         snd_array_free(&spec->jacks);
 #endif
@@ -4026,7 +4182,6 @@ static void stac92xx_free(struct hda_codec *codec)
         if (! spec)
                 return;
 
-        kfree(spec->pin_configs);
         stac92xx_free_jacks(codec);
         snd_array_free(&spec->events);
 
@@ -4037,7 +4192,9 @@ static void stac92xx_free(struct hda_codec *codec)
 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
                                 unsigned int flag)
 {
-        unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
+        unsigned int old_ctl, pin_ctl;
+
+        pin_ctl = snd_hda_codec_read(codec, nid,
                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
 
         if (pin_ctl & AC_PINCTL_IN_EN) {
@@ -4051,14 +4208,17 @@ static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
                         return;
         }
 
+        old_ctl = pin_ctl;
         /* if setting pin direction bits, clear the current
            direction bits first */
         if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
                 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
         
-        snd_hda_codec_write_cache(codec, nid, 0,
-                        AC_VERB_SET_PIN_WIDGET_CONTROL,
-                        pin_ctl | flag);
+        pin_ctl |= flag;
+        if (old_ctl != pin_ctl)
+                snd_hda_codec_write_cache(codec, nid, 0,
+                                          AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                          pin_ctl);
 }
 
 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
@@ -4066,9 +4226,10 @@ static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
 {
         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
-        snd_hda_codec_write_cache(codec, nid, 0,
-                        AC_VERB_SET_PIN_WIDGET_CONTROL,
-                        pin_ctl & ~flag);
+        if (pin_ctl & flag)
+                snd_hda_codec_write_cache(codec, nid, 0,
+                                          AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                          pin_ctl & ~flag);
 }
 
 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
@@ -4163,8 +4324,19 @@ static void stac92xx_hp_detect(struct hda_codec *codec)
                         continue;
                 if (presence)
                         stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
+#if 0 /* FIXME */
+/* Resetting the pinctl like below may lead to (a sort of) regressions
+ * on some devices since they use the HP pin actually for line/speaker
+ * outs although the default pin config shows a different pin (that is
+ * wrong and useless).
+ *
+ * So, it's basically a problem of default pin configs, likely a BIOS issue.
+ * But, disabling the code below just works around it, and I'm too tired of
+ * bug reports with such devices... 
+ */
                 else
                         stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
+#endif /* FIXME */
         }
 } 
 
@@ -4258,6 +4430,24 @@ static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
                 if (spec->num_pwrs > 0)
                         stac92xx_pin_sense(codec, event->nid);
                 stac92xx_report_jack(codec, event->nid);
+
+                switch (codec->subsystem_id) {
+                case 0x103c308f:
+                        if (event->nid == 0xb) {
+                                int pin = AC_PINCTL_IN_EN;
+
+                                if (get_pin_presence(codec, 0xa)
+                                                && get_pin_presence(codec, 0xb))
+                                        pin |= AC_PINCTL_VREF_80;
+                                if (!get_pin_presence(codec, 0xb))
+                                        pin |= AC_PINCTL_VREF_80;
+
+                                /* toggle VREF state based on mic + hp pin
+                                 * status
+                                 */
+                                stac92xx_auto_set_pinctl(codec, 0x0a, pin);
+                        }
+                }
                 break;
         case STAC_VREF_EVENT:
                 data = snd_hda_codec_read(codec, codec->afg, 0,
@@ -4320,7 +4510,6 @@ static int stac92xx_resume(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec = codec->spec;
 
-        stac92xx_set_config_regs(codec);
         stac92xx_init(codec);
         snd_hda_codec_resume_amp(codec);
         snd_hda_codec_resume_cache(codec);
@@ -4331,6 +4520,37 @@ static int stac92xx_resume(struct hda_codec *codec)
         return 0;
 }
 
+
+/*
+ * using power check for controlling mute led of HP HDX notebooks
+ * check for mute state only on Speakers (nid = 0x10)
+ *
+ * For this feature CONFIG_SND_HDA_POWER_SAVE is needed, otherwise
+ * the LED is NOT working properly !
+ */
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+static int stac92xx_hp_hdx_check_power_status(struct hda_codec *codec,
+                                              hda_nid_t nid)
+{
+        struct sigmatel_spec *spec = codec->spec;
+
+        if (nid == 0x10) {
+                if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
+                    HDA_AMP_MUTE)
+                        spec->gpio_data &= ~0x08;  /* orange */
+                else
+                        spec->gpio_data |= 0x08;   /* white */
+
+                stac_gpio_set(codec, spec->gpio_mask,
+                              spec->gpio_dir,
+                              spec->gpio_data);
+        }
+
+        return 0;
+}
+#endif
+
 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
 {
         struct sigmatel_spec *spec = codec->spec;
@@ -4369,16 +4589,11 @@ static int patch_stac9200(struct hda_codec *codec)
         spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
                                                         stac9200_models,
                                                         stac9200_cfg_tbl);
-        if (spec->board_config < 0) {
+        if (spec->board_config < 0)
                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
-                err = stac92xx_save_bios_config_regs(codec);
-        } else
-                err = stac_save_pin_cfgs(codec,
+        else
+                stac92xx_set_config_regs(codec,
                                          stac9200_brd_tbl[spec->board_config]);
-        if (err < 0) {
-                stac92xx_free(codec);
-                return err;
-        }
 
         spec->multiout.max_channels = 2;
         spec->multiout.num_dacs = 1;
@@ -4390,7 +4605,8 @@ static int patch_stac9200(struct hda_codec *codec)
         spec->num_adcs = 1;
         spec->num_pwrs = 0;
 
-        if (spec->board_config == STAC_9200_GATEWAY ||
+        if (spec->board_config == STAC_9200_M4 ||
+            spec->board_config == STAC_9200_M4_2 ||
             spec->board_config == STAC_9200_OQO)
                 spec->init = stac9200_eapd_init;
         else
@@ -4408,6 +4624,12 @@ static int patch_stac9200(struct hda_codec *codec)
                 return err;
         }
 
+        /* CF-74 has no headphone detection, and the driver should *NOT*
+         * do detection and HP/speaker toggle because the hardware does it.
+         */
+        if (spec->board_config == STAC_9200_PANASONIC)
+                spec->hp_detect = 0;
+
         codec->patch_ops = stac92xx_patch_ops;
 
         return 0;
@@ -4425,21 +4647,26 @@ static int patch_stac925x(struct hda_codec *codec)
         codec->spec = spec;
         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
         spec->pin_nids = stac925x_pin_nids;
-        spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
+
+        /* Check first for codec ID */
+        spec->board_config = snd_hda_check_board_codec_sid_config(codec,
+                                                        STAC_925x_MODELS,
+                                                        stac925x_models,
+                                                        stac925x_codec_id_cfg_tbl);
+
+        /* Now checks for PCI ID, if codec ID is not found */
+        if (spec->board_config < 0)
+                spec->board_config = snd_hda_check_board_config(codec,
+                                                        STAC_925x_MODELS,
                                                         stac925x_models,
                                                         stac925x_cfg_tbl);
  again:
-        if (spec->board_config < 0) {
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x," 
+        if (spec->board_config < 0)
+                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
                                       "using BIOS defaults\n");
-                err = stac92xx_save_bios_config_regs(codec);
-        } else
-                err = stac_save_pin_cfgs(codec,
+        else
+                stac92xx_set_config_regs(codec,
                                          stac925x_brd_tbl[spec->board_config]);
-        if (err < 0) {
-                stac92xx_free(codec);
-                return err;
-        }
 
         spec->multiout.max_channels = 2;
         spec->multiout.num_dacs = 1;
@@ -4517,17 +4744,12 @@ static int patch_stac92hd73xx(struct hda_codec *codec)
                                                         stac92hd73xx_models,
                                                         stac92hd73xx_cfg_tbl);
 again:
-        if (spec->board_config < 0) {
+        if (spec->board_config < 0)
                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
                         " STAC92HD73XX, using BIOS defaults\n");
-                err = stac92xx_save_bios_config_regs(codec);
-        } else
-                err = stac_save_pin_cfgs(codec,
+        else
+                stac92xx_set_config_regs(codec,
                                 stac92hd73xx_brd_tbl[spec->board_config]);
-        if (err < 0) {
-                stac92xx_free(codec);
-                return err;
-        }
 
         num_dacs = snd_hda_get_connections(codec, 0x0a,
                         conn, STAC92HD73_DAC_COUNT + 2) - 1;
@@ -4541,14 +4763,18 @@ again:
         case 0x3: /* 6 Channel */
                 spec->mixer = stac92hd73xx_6ch_mixer;
                 spec->init = stac92hd73xx_6ch_core_init;
+                spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
                 break;
         case 0x4: /* 8 Channel */
                 spec->mixer = stac92hd73xx_8ch_mixer;
                 spec->init = stac92hd73xx_8ch_core_init;
+                spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
                 break;
         case 0x5: /* 10 Channel */
                 spec->mixer = stac92hd73xx_10ch_mixer;
                 spec->init = stac92hd73xx_10ch_core_init;
+                spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
+                break;
         }
         spec->multiout.dac_nids = spec->dac_nids;
 
@@ -4587,18 +4813,18 @@ again:
                         spec->init = dell_m6_core_init;
                 switch (spec->board_config) {
                 case STAC_DELL_M6_AMIC: /* Analog Mics */
-                        stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
+                        snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
                         spec->num_dmics = 0;
                         spec->private_dimux.num_items = 1;
                         break;
                 case STAC_DELL_M6_DMIC: /* Digital Mics */
-                        stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
+                        snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
                         spec->num_dmics = 1;
                         spec->private_dimux.num_items = 2;
                         break;
                 case STAC_DELL_M6_BOTH: /* Both */
-                        stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
-                        stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
+                        snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
+                        snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
                         spec->num_dmics = 1;
                         spec->private_dimux.num_items = 2;
                         break;
@@ -4658,7 +4884,10 @@ static struct hda_input_mux stac92hd83xxx_dmux = {
 static int patch_stac92hd83xxx(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec;
+        hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
         int err;
+        int num_dacs;
+        hda_nid_t nid;
 
         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -4672,23 +4901,17 @@ static int patch_stac92hd83xxx(struct hda_codec *codec)
         spec->dmux_nids = stac92hd83xxx_dmux_nids;
         spec->adc_nids = stac92hd83xxx_adc_nids;
         spec->pwr_nids = stac92hd83xxx_pwr_nids;
+        spec->amp_nids = stac92hd83xxx_amp_nids;
         spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
         spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
         spec->multiout.dac_nids = spec->dac_nids;
 
         spec->init = stac92hd83xxx_core_init;
-        switch (codec->vendor_id) {
-        case 0x111d7605:
-                break;
-        default:
-                spec->num_pwrs--;
-                spec->init++; /* switch to config #2 */
-        }
-
         spec->mixer = stac92hd83xxx_mixer;
         spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
         spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
         spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
+        spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
         spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
         spec->dinput_mux = &stac92hd83xxx_dmux;
         spec->pin_nids = stac92hd83xxx_pin_nids;
@@ -4697,16 +4920,21 @@ static int patch_stac92hd83xxx(struct hda_codec *codec)
                                                         stac92hd83xxx_models,
                                                         stac92hd83xxx_cfg_tbl);
 again:
-        if (spec->board_config < 0) {
+        if (spec->board_config < 0)
                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
                         " STAC92HD83XXX, using BIOS defaults\n");
-                err = stac92xx_save_bios_config_regs(codec);
-        } else
-                err = stac_save_pin_cfgs(codec,
+        else
+                stac92xx_set_config_regs(codec,
                                 stac92hd83xxx_brd_tbl[spec->board_config]);
-        if (err < 0) {
-                stac92xx_free(codec);
-                return err;
+
+        switch (codec->vendor_id) {
+        case 0x111d7604:
+        case 0x111d7605:
+        case 0x111d76d5:
+                if (spec->board_config == STAC_92HD83XXX_PWR_REF)
+                        break;
+                spec->num_pwrs = 0;
+                break;
         }
 
         err = stac92xx_parse_auto_config(codec, 0x1d, 0);
@@ -4725,6 +4953,23 @@ again:
                 return err;
         }
 
+        switch (spec->board_config) {
+        case STAC_DELL_S14:
+                nid = 0xf;
+                break;
+        default:
+                nid = 0xe;
+                break;
+        }
+
+        num_dacs = snd_hda_get_connections(codec, nid,
+                                conn, STAC92HD83_DAC_COUNT + 1) - 1;
+
+        /* set port X to select the last DAC
+         */
+        snd_hda_codec_write_cache(codec, nid, 0,
+                        AC_VERB_SET_CONNECT_SEL, num_dacs);
+
         codec->patch_ops = stac92xx_patch_ops;
 
         codec->proc_widget_hook = stac92hd_proc_hook;
@@ -4732,7 +4977,16 @@ again:
         return 0;
 }
 
-static struct hda_input_mux stac92hd71bxx_dmux = {
+static struct hda_input_mux stac92hd71bxx_dmux_nomixer = {
+        .num_items = 3,
+        .items = {
+                { "Analog Inputs", 0x00 },
+                { "Digital Mic 1", 0x02 },
+                { "Digital Mic 2", 0x03 },
+        }
+};
+
+static struct hda_input_mux stac92hd71bxx_dmux_amixer = {
         .num_items = 4,
         .items = {
                 { "Analog Inputs", 0x00 },
@@ -4742,10 +4996,67 @@ static struct hda_input_mux stac92hd71bxx_dmux = {
         }
 };
 
+/* get the pin connection (fixed, none, etc) */
+static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        unsigned int cfg;
+
+        cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
+        return get_defcfg_connect(cfg);
+}
+
+static int stac92hd71bxx_connected_ports(struct hda_codec *codec,
+                                         hda_nid_t *nids, int num_nids)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        int idx, num;
+        unsigned int def_conf;
+
+        for (num = 0; num < num_nids; num++) {
+                for (idx = 0; idx < spec->num_pins; idx++)
+                        if (spec->pin_nids[idx] == nids[num])
+                                break;
+                if (idx >= spec->num_pins)
+                        break;
+                def_conf = stac_get_defcfg_connect(codec, idx);
+                if (def_conf == AC_JACK_PORT_NONE)
+                        break;
+        }
+        return num;
+}
+
+static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
+                                          hda_nid_t dig0pin)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        int idx;
+
+        for (idx = 0; idx < spec->num_pins; idx++)
+                if (spec->pin_nids[idx] == dig0pin)
+                        break;
+        if ((idx + 2) >= spec->num_pins)
+                return 0;
+
+        /* dig1pin case */
+        if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
+                return 2;
+
+        /* dig0pin + dig2pin case */
+        if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
+                return 2;
+        if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
+                return 1;
+        else
+                return 0;
+}
+
 static int patch_stac92hd71bxx(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec;
+        struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
         int err = 0;
+        unsigned int ndmic_nids = 0;
 
         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -4753,27 +5064,32 @@ static int patch_stac92hd71bxx(struct hda_codec *codec)
 
         codec->spec = spec;
         codec->patch_ops = stac92xx_patch_ops;
-        spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
+        spec->num_pins = STAC92HD71BXX_NUM_PINS;
+        switch (codec->vendor_id) {
+        case 0x111d76b6:
+        case 0x111d76b7:
+                spec->pin_nids = stac92hd71bxx_pin_nids_4port;
+                break;
+        case 0x111d7603:
+        case 0x111d7608:
+                /* On 92HD75Bx 0x27 isn't a pin nid */
+                spec->num_pins--;
+                /* fallthrough */
+        default:
+                spec->pin_nids = stac92hd71bxx_pin_nids_6port;
+        }
         spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
-        spec->pin_nids = stac92hd71bxx_pin_nids;
-        memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
-                        sizeof(stac92hd71bxx_dmux));
         spec->board_config = snd_hda_check_board_config(codec,
                                                         STAC_92HD71BXX_MODELS,
                                                         stac92hd71bxx_models,
                                                         stac92hd71bxx_cfg_tbl);
 again:
-        if (spec->board_config < 0) {
+        if (spec->board_config < 0)
                 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
                         " STAC92HD71BXX, using BIOS defaults\n");
-                err = stac92xx_save_bios_config_regs(codec);
-        } else
-                err = stac_save_pin_cfgs(codec,
+        else
+                stac92xx_set_config_regs(codec,
                                 stac92hd71bxx_brd_tbl[spec->board_config]);
-        if (err < 0) {
-                stac92xx_free(codec);
-                return err;
-        }
 
         if (spec->board_config > STAC_92HD71BXX_REF) {
                 /* GPIO0 = EAPD */
@@ -4782,16 +5098,34 @@ again:
                 spec->gpio_data = 0x01;
         }
 
+        spec->dmic_nids = stac92hd71bxx_dmic_nids;
+        spec->dmux_nids = stac92hd71bxx_dmux_nids;
+
         switch (codec->vendor_id) {
         case 0x111d76b6: /* 4 Port without Analog Mixer */
         case 0x111d76b7:
+                unmute_init++;
+                /* fallthru */
         case 0x111d76b4: /* 6 Port without Analog Mixer */
         case 0x111d76b5:
+                memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_nomixer,
+                       sizeof(stac92hd71bxx_dmux_nomixer));
                 spec->mixer = stac92hd71bxx_mixer;
                 spec->init = stac92hd71bxx_core_init;
                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
+                spec->num_dmics = stac92hd71bxx_connected_ports(codec,
+                                        stac92hd71bxx_dmic_nids,
+                                        STAC92HD71BXX_NUM_DMICS);
+                if (spec->num_dmics) {
+                        spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
+                        spec->dinput_mux = &spec->private_dimux;
+                        ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
+                }
                 break;
         case 0x111d7608: /* 5 Port with Analog Mixer */
+                memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
+                       sizeof(stac92hd71bxx_dmux_amixer));
+                spec->private_dimux.num_items--;
                 switch (spec->board_config) {
                 case STAC_HP_M4:
                         /* Enable VREF power saving on GPIO1 detect */
@@ -4818,7 +5152,15 @@ again:
 
                 /* disable VSW */
                 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
-                stac_change_pin_config(codec, 0xf, 0x40f000f0);
+                unmute_init++;
+                snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
+                snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
+                stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0;
+                spec->num_dmics = stac92hd71bxx_connected_ports(codec,
+                                        stac92hd71bxx_dmic_nids,
+                                        STAC92HD71BXX_NUM_DMICS - 1);
+                spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
+                ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 2;
                 break;
         case 0x111d7603: /* 6 Port with Analog Mixer */
                 if ((codec->revision_id & 0xf) == 1)
@@ -4828,12 +5170,23 @@ again:
                 spec->num_pwrs = 0;
                 /* fallthru */
         default:
+                memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
+                       sizeof(stac92hd71bxx_dmux_amixer));
                 spec->dinput_mux = &spec->private_dimux;
                 spec->mixer = stac92hd71bxx_analog_mixer;
                 spec->init = stac92hd71bxx_analog_core_init;
                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
+                spec->num_dmics = stac92hd71bxx_connected_ports(codec,
+                                        stac92hd71bxx_dmic_nids,
+                                        STAC92HD71BXX_NUM_DMICS);
+                spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
+                ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
         }
 
+        if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
+                snd_hda_sequence_write_cache(codec, unmute_init);
+
+        spec->aloopback_ctl = stac92hd71bxx_loopback;
         spec->aloopback_mask = 0x50;
         spec->aloopback_shift = 0;
 
@@ -4841,18 +5194,17 @@ again:
         spec->digbeep_nid = 0x26;
         spec->mux_nids = stac92hd71bxx_mux_nids;
         spec->adc_nids = stac92hd71bxx_adc_nids;
-        spec->dmic_nids = stac92hd71bxx_dmic_nids;
-        spec->dmux_nids = stac92hd71bxx_dmux_nids;
         spec->smux_nids = stac92hd71bxx_smux_nids;
         spec->pwr_nids = stac92hd71bxx_pwr_nids;
 
         spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
         spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
+        spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
 
         switch (spec->board_config) {
         case STAC_HP_M4:
                 /* enable internal microphone */
-                stac_change_pin_config(codec, 0x0e, 0x01813040);
+                snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
                 stac92xx_auto_set_pinctl(codec, 0x0e,
                         AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
                 /* fallthru */
@@ -4865,21 +5217,38 @@ again:
         case STAC_DELL_M4_3:
                 spec->num_dmics = 1;
                 spec->num_smuxes = 0;
-                spec->num_dmuxes = 0;
+                spec->num_dmuxes = 1;
+                break;
+        case STAC_HP_DV5:
+                snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
+                stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
+                break;
+        case STAC_HP_HDX:
+                spec->num_dmics = 1;
+                spec->num_dmuxes = 1;
+                spec->num_smuxes = 1;
+                /*
+                 * For controlling MUTE LED on HP HDX16/HDX18 notebooks,
+                 * the CONFIG_SND_HDA_POWER_SAVE is needed to be set.
+                 */
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+                /* orange/white mute led on GPIO3, orange=0, white=1 */
+                spec->gpio_mask |= 0x08;
+                spec->gpio_dir  |= 0x08;
+                spec->gpio_data |= 0x08;  /* set to white */
+
+                /* register check_power_status callback. */
+                codec->patch_ops.check_power_status =
+                    stac92xx_hp_hdx_check_power_status;
+#endif  
                 break;
-        default:
-                spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
-                spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
-                spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
         };
 
         spec->multiout.dac_nids = spec->dac_nids;
         if (spec->dinput_mux)
-                spec->private_dimux.num_items +=
-                        spec->num_dmics -
-                                (ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
+                spec->private_dimux.num_items += spec->num_dmics - ndmic_nids;
 
-        err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
+        err = stac92xx_parse_auto_config(codec, 0x21, 0);
         if (!err) {
                 if (spec->board_config < 0) {
                         printk(KERN_WARNING "hda_codec: No auto-config is "
@@ -4954,17 +5323,12 @@ static int patch_stac922x(struct hda_codec *codec)
         }
 
  again:
-        if (spec->board_config < 0) {
+        if (spec->board_config < 0)
                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
                         "using BIOS defaults\n");
-                err = stac92xx_save_bios_config_regs(codec);
-        } else
-                err = stac_save_pin_cfgs(codec,
+        else
+                stac92xx_set_config_regs(codec,
                                 stac922x_brd_tbl[spec->board_config]);
-        if (err < 0) {
-                stac92xx_free(codec);
-                return err;
-        }
 
         spec->adc_nids = stac922x_adc_nids;
         spec->mux_nids = stac922x_mux_nids;
@@ -5015,24 +5379,19 @@ static int patch_stac927x(struct hda_codec *codec)
                 return -ENOMEM;
 
         codec->spec = spec;
+        codec->slave_dig_outs = stac927x_slave_dig_outs;
         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
         spec->pin_nids = stac927x_pin_nids;
         spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
                                                         stac927x_models,
                                                         stac927x_cfg_tbl);
  again:
-        if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
-                if (spec->board_config < 0)
-                        snd_printdd(KERN_INFO "hda_codec: Unknown model for"
-                                    "STAC927x, using BIOS defaults\n");
-                err = stac92xx_save_bios_config_regs(codec);
-        } else
-                err = stac_save_pin_cfgs(codec,
+        if (spec->board_config < 0)
+                snd_printdd(KERN_INFO "hda_codec: Unknown model for"
+                            "STAC927x, using BIOS defaults\n");
+        else
+                stac92xx_set_config_regs(codec,
                                 stac927x_brd_tbl[spec->board_config]);
-        if (err < 0) {
-                stac92xx_free(codec);
-                return err;
-        }
 
         spec->digbeep_nid = 0x23;
         spec->adc_nids = stac927x_adc_nids;
@@ -5061,15 +5420,15 @@ static int patch_stac927x(struct hda_codec *codec)
                 case 0x10280209:
                 case 0x1028022e:
                         /* correct the device field to SPDIF out */
-                        stac_change_pin_config(codec, 0x21, 0x01442070);
+                        snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
                         break;
                 };
                 /* configure the analog microphone on some laptops */
-                stac_change_pin_config(codec, 0x0c, 0x90a79130);
+                snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
                 /* correct the front output jack as a hp out */
-                stac_change_pin_config(codec, 0x0f, 0x0227011f);
+                snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
                 /* correct the front input jack as a mic */
-                stac_change_pin_config(codec, 0x0e, 0x02a79130);
+                snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
                 /* fallthru */
         case STAC_DELL_3ST:
                 /* GPIO2 High = Enable EAPD */
@@ -5096,6 +5455,7 @@ static int patch_stac927x(struct hda_codec *codec)
         }
 
         spec->num_pwrs = 0;
+        spec->aloopback_ctl = stac927x_loopback;
         spec->aloopback_mask = 0x40;
         spec->aloopback_shift = 0;
         spec->eapd_switch = 1;
@@ -5154,16 +5514,11 @@ static int patch_stac9205(struct hda_codec *codec)
                                                         stac9205_models,
                                                         stac9205_cfg_tbl);
  again:
-        if (spec->board_config < 0) {
+        if (spec->board_config < 0)
                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
-                err = stac92xx_save_bios_config_regs(codec);
-        } else
-                err = stac_save_pin_cfgs(codec,
+        else
+                stac92xx_set_config_regs(codec,
                                          stac9205_brd_tbl[spec->board_config]);
-        if (err < 0) {
-                stac92xx_free(codec);
-                return err;
-        }
 
         spec->digbeep_nid = 0x23;
         spec->adc_nids = stac9205_adc_nids;
@@ -5180,17 +5535,20 @@ static int patch_stac9205(struct hda_codec *codec)
 
         spec->init = stac9205_core_init;
         spec->mixer = stac9205_mixer;
+        spec->aloopback_ctl = stac9205_loopback;
 
         spec->aloopback_mask = 0x40;
         spec->aloopback_shift = 0;
-        spec->eapd_switch = 1;
+        /* Turn on/off EAPD per HP plugging */
+        if (spec->board_config != STAC_9205_EAPD)
+                spec->eapd_switch = 1;
         spec->multiout.dac_nids = spec->dac_nids;
         
         switch (spec->board_config){
         case STAC_9205_DELL_M43:
                 /* Enable SPDIF in/out */
-                stac_change_pin_config(codec, 0x1f, 0x01441030);
-                stac_change_pin_config(codec, 0x20, 0x1c410030);
+                snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
+                snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
 
                 /* Enable unsol response for GPIO4/Dock HP connection */
                 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
@@ -5247,223 +5605,87 @@ static int patch_stac9205(struct hda_codec *codec)
  * STAC9872 hack
  */
 
-/* static config for Sony VAIO FE550G and Sony VAIO AR */
-static hda_nid_t vaio_dacs[] = { 0x2 };
-#define VAIO_HP_DAC     0x5
-static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
-static hda_nid_t vaio_mux_nids[] = { 0x15 };
-
-static struct hda_input_mux vaio_mux = {
-        .num_items = 3,
-        .items = {
-                /* { "HP", 0x0 }, */
-                { "Mic Jack", 0x1 },
-                { "Internal Mic", 0x2 },
-                { "PCM", 0x3 },
-        }
-};
-
-static struct hda_verb vaio_init[] = {
-        {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
-        {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
-        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
-        {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
-        {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
-        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
+static struct hda_verb stac9872_core_init[] = {
         {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
-        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
-        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
-        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
-        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
         {}
 };
 
-static struct hda_verb vaio_ar_init[] = {
-        {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
-        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
-        {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
-        {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
-/*      {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
-        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
-        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
-        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
-/*      {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
-        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
-        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
-        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
-        {}
-};
-
-static struct snd_kcontrol_new vaio_mixer[] = {
-        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
-        /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
+static struct snd_kcontrol_new stac9872_mixer[] = {
         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Capture Source",
-                .count = 1,
-                .info = stac92xx_mux_enum_info,
-                .get = stac92xx_mux_enum_get,
-                .put = stac92xx_mux_enum_put,
-        },
-        {}
+        { } /* end */
 };
 
-static struct snd_kcontrol_new vaio_ar_mixer[] = {
-        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
-        /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
-        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
-        /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Capture Source",
-                .count = 1,
-                .info = stac92xx_mux_enum_info,
-                .get = stac92xx_mux_enum_get,
-                .put = stac92xx_mux_enum_put,
-        },
-        {}
+static hda_nid_t stac9872_pin_nids[] = {
+        0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+        0x11, 0x13, 0x14,
 };
 
-static struct hda_codec_ops stac9872_patch_ops = {
-        .build_controls = stac92xx_build_controls,
-        .build_pcms = stac92xx_build_pcms,
-        .init = stac92xx_init,
-        .free = stac92xx_free,
-#ifdef SND_HDA_NEEDS_RESUME
-        .resume = stac92xx_resume,
-#endif
+static hda_nid_t stac9872_adc_nids[] = {
+        0x8 /*,0x6*/
 };
 
-static int stac9872_vaio_init(struct hda_codec *codec)
-{
-        int err;
-
-        err = stac92xx_init(codec);
-        if (err < 0)
-                return err;
-        if (codec->patch_ops.unsol_event)
-                codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
-        return 0;
-}
-
-static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
-{
-        if (get_pin_presence(codec, 0x0a)) {
-                stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
-                stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
-        } else {
-                stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
-                stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
-        }
-} 
-
-static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
-{
-        switch (res >> 26) {
-        case STAC_HP_EVENT:
-                stac9872_vaio_hp_detect(codec, res);
-                break;
-        }
-}
-
-static struct hda_codec_ops stac9872_vaio_patch_ops = {
-        .build_controls = stac92xx_build_controls,
-        .build_pcms = stac92xx_build_pcms,
-        .init = stac9872_vaio_init,
-        .free = stac92xx_free,
-        .unsol_event = stac9872_vaio_unsol_event,
-#ifdef CONFIG_PM
-        .resume = stac92xx_resume,
-#endif
+static hda_nid_t stac9872_mux_nids[] = {
+        0x15
 };
 
-enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
-       CXD9872RD_VAIO,
-       /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
-       STAC9872AK_VAIO, 
-       /* Unknown. id=0x83847661 and subsys=0x104D1200. */
-       STAC9872K_VAIO,
-       /* AR Series. id=0x83847664 and subsys=104D1300 */
-       CXD9872AKD_VAIO,
-       STAC_9872_MODELS,
+static unsigned int stac9872_vaio_pin_configs[9] = {
+        0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
+        0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
+        0x90a7013e
 };
 
 static const char *stac9872_models[STAC_9872_MODELS] = {
-        [CXD9872RD_VAIO]        = "vaio",
-        [CXD9872AKD_VAIO]       = "vaio-ar",
+        [STAC_9872_AUTO] = "auto",
+        [STAC_9872_VAIO] = "vaio",
+};
+
+static unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
+        [STAC_9872_VAIO] = stac9872_vaio_pin_configs,
 };
 
 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
-        SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
-        SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
-        SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
-        SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
-        {}
+        {} /* terminator */
 };
 
 static int patch_stac9872(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec;
-        int board_config;
+        int err;
 
-        board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
-                                                  stac9872_models,
-                                                  stac9872_cfg_tbl);
-        if (board_config < 0)
-                /* unknown config, let generic-parser do its job... */
-                return snd_hda_parse_generic_codec(codec);
-        
         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
                 return -ENOMEM;
-
         codec->spec = spec;
-        switch (board_config) {
-        case CXD9872RD_VAIO:
-        case STAC9872AK_VAIO:
-        case STAC9872K_VAIO:
-                spec->mixer = vaio_mixer;
-                spec->init = vaio_init;
-                spec->multiout.max_channels = 2;
-                spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
-                spec->multiout.dac_nids = vaio_dacs;
-                spec->multiout.hp_nid = VAIO_HP_DAC;
-                spec->num_adcs = ARRAY_SIZE(vaio_adcs);
-                spec->adc_nids = vaio_adcs;
-                spec->num_pwrs = 0;
-                spec->input_mux = &vaio_mux;
-                spec->mux_nids = vaio_mux_nids;
-                codec->patch_ops = stac9872_vaio_patch_ops;
-                break;
-        
-        case CXD9872AKD_VAIO:
-                spec->mixer = vaio_ar_mixer;
-                spec->init = vaio_ar_init;
-                spec->multiout.max_channels = 2;
-                spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
-                spec->multiout.dac_nids = vaio_dacs;
-                spec->multiout.hp_nid = VAIO_HP_DAC;
-                spec->num_adcs = ARRAY_SIZE(vaio_adcs);
-                spec->num_pwrs = 0;
-                spec->adc_nids = vaio_adcs;
-                spec->input_mux = &vaio_mux;
-                spec->mux_nids = vaio_mux_nids;
-                codec->patch_ops = stac9872_patch_ops;
-                break;
-        }
 
+        spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
+                                                        stac9872_models,
+                                                        stac9872_cfg_tbl);
+        if (spec->board_config < 0)
+                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9872, "
+                            "using BIOS defaults\n");
+        else
+                stac92xx_set_config_regs(codec,
+                                         stac9872_brd_tbl[spec->board_config]);
+
+        spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
+        spec->pin_nids = stac9872_pin_nids;
+        spec->multiout.dac_nids = spec->dac_nids;
+        spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
+        spec->adc_nids = stac9872_adc_nids;
+        spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
+        spec->mux_nids = stac9872_mux_nids;
+        spec->mixer = stac9872_mixer;
+        spec->init = stac9872_core_init;
+
+        err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
+        if (err < 0) {
+                stac92xx_free(codec);
+                return -EINVAL;
+        }
+        spec->input_mux = &spec->private_imux;
+        codec->patch_ops = stac92xx_patch_ops;
         return 0;
 }
 
@@ -5521,6 +5743,7 @@ static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
         { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
         { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
         { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
         { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
         { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
         { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c
index c761394cbe84..b25a5cc637d6 100644
--- a/sound/pci/hda/patch_via.c
+++ b/sound/pci/hda/patch_via.c
@@ -1308,16 +1308,13 @@ static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
         unsigned int def_conf;
         unsigned char seqassoc;
 
-        def_conf = snd_hda_codec_read(codec, nid, 0,
-                                      AC_VERB_GET_CONFIG_DEFAULT, 0);
+        def_conf = snd_hda_codec_get_pincfg(codec, nid);
         seqassoc = (unsigned char) get_defcfg_association(def_conf);
         seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
         if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) {
                 if (seqassoc == 0xff) {
                         def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
-                        snd_hda_codec_write(codec, nid, 0,
-                                            AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
-                                            def_conf >> 24);
+                        snd_hda_codec_set_pincfg(codec, nid, def_conf);
                 }
         }
 
@@ -1354,7 +1351,7 @@ static int vt1708_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID;
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = VT1708_DIGIN_NID;
@@ -1827,7 +1824,7 @@ static int vt1709_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID;
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = VT1709_DIGIN_NID;
@@ -2371,7 +2368,7 @@ static int vt1708B_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID;
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = VT1708B_DIGIN_NID;
@@ -2836,7 +2833,7 @@ static int vt1708S_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = VT1708S_DIGOUT_NID;
 
         spec->extra_dig_out_nid = 0x15;
@@ -3155,7 +3152,7 @@ static int vt1702_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_out_pin)
+        if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = VT1702_DIGOUT_NID;
 
         spec->extra_dig_out_nid = 0x1B;
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c
index bab1c700f497..0d0cdbdb4486 100644
--- a/sound/pci/ice1712/ice1712.c
+++ b/sound/pci/ice1712/ice1712.c
@@ -458,7 +458,7 @@ static irqreturn_t snd_ice1712_interrupt(int irq, void *dev_id)
                         u16 pbkstatus;
                         struct snd_pcm_substream *substream;
                         pbkstatus = inw(ICEDS(ice, INTSTAT));
-                        /* printk("pbkstatus = 0x%x\n", pbkstatus); */
+                        /* printk(KERN_DEBUG "pbkstatus = 0x%x\n", pbkstatus); */
                         for (idx = 0; idx < 6; idx++) {
                                 if ((pbkstatus & (3 << (idx * 2))) == 0)
                                         continue;
@@ -2533,8 +2533,8 @@ static int __devinit snd_ice1712_create(struct snd_card *card,
         if (err < 0)
                 return err;
         /* check, if we can restrict PCI DMA transfers to 28 bits */
-        if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c
index 7ff36d3f0f44..128510e77a78 100644
--- a/sound/pci/ice1712/ice1724.c
+++ b/sound/pci/ice1712/ice1724.c
@@ -241,6 +241,8 @@ get_rawmidi_substream(struct snd_ice1712 *ice, unsigned int stream)
                                 struct snd_rawmidi_substream, list);
 }
 
+static void enable_midi_irq(struct snd_ice1712 *ice, u8 flag, int enable);
+
 static void vt1724_midi_write(struct snd_ice1712 *ice)
 {
         struct snd_rawmidi_substream *s;
@@ -254,6 +256,11 @@ static void vt1724_midi_write(struct snd_ice1712 *ice)
                 for (i = 0; i < count; ++i)
                         outb(buffer[i], ICEREG1724(ice, MPU_DATA));
         }
+        /* mask irq when all bytes have been transmitted.
+         * enabled again in output_trigger when the new data comes in.
+         */
+        enable_midi_irq(ice, VT1724_IRQ_MPU_TX,
+                        !snd_rawmidi_transmit_empty(s));
 }
 
 static void vt1724_midi_read(struct snd_ice1712 *ice)
@@ -272,31 +279,34 @@ static void vt1724_midi_read(struct snd_ice1712 *ice)
         }
 }
 
-static void vt1724_enable_midi_irq(struct snd_rawmidi_substream *substream,
-                                   u8 flag, int enable)
+/* call with ice->reg_lock */
+static void enable_midi_irq(struct snd_ice1712 *ice, u8 flag, int enable)
 {
-        struct snd_ice1712 *ice = substream->rmidi->private_data;
-        u8 mask;
-
-        spin_lock_irq(&ice->reg_lock);
-        mask = inb(ICEREG1724(ice, IRQMASK));
+        u8 mask = inb(ICEREG1724(ice, IRQMASK));
         if (enable)
                 mask &= ~flag;
         else
                 mask |= flag;
         outb(mask, ICEREG1724(ice, IRQMASK));
+}
+
+static void vt1724_enable_midi_irq(struct snd_rawmidi_substream *substream,
+                                   u8 flag, int enable)
+{
+        struct snd_ice1712 *ice = substream->rmidi->private_data;
+
+        spin_lock_irq(&ice->reg_lock);
+        enable_midi_irq(ice, flag, enable);
         spin_unlock_irq(&ice->reg_lock);
 }
 
 static int vt1724_midi_output_open(struct snd_rawmidi_substream *s)
 {
-        vt1724_enable_midi_irq(s, VT1724_IRQ_MPU_TX, 1);
         return 0;
 }
 
 static int vt1724_midi_output_close(struct snd_rawmidi_substream *s)
 {
-        vt1724_enable_midi_irq(s, VT1724_IRQ_MPU_TX, 0);
         return 0;
 }
 
@@ -311,6 +321,7 @@ static void vt1724_midi_output_trigger(struct snd_rawmidi_substream *s, int up)
                 vt1724_midi_write(ice);
         } else {
                 ice->midi_output = 0;
+                enable_midi_irq(ice, VT1724_IRQ_MPU_TX, 0);
         }
         spin_unlock_irqrestore(&ice->reg_lock, flags);
 }
@@ -320,6 +331,7 @@ static void vt1724_midi_output_drain(struct snd_rawmidi_substream *s)
         struct snd_ice1712 *ice = s->rmidi->private_data;
         unsigned long timeout;
 
+        vt1724_enable_midi_irq(s, VT1724_IRQ_MPU_TX, 0);
         /* 32 bytes should be transmitted in less than about 12 ms */
         timeout = jiffies + msecs_to_jiffies(15);
         do {
@@ -389,24 +401,24 @@ static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id)
                 status &= status_mask;
                 if (status == 0)
                         break;
+                spin_lock(&ice->reg_lock);
                 if (++timeout > 10) {
                         status = inb(ICEREG1724(ice, IRQSTAT));
                         printk(KERN_ERR "ice1724: Too long irq loop, "
                                "status = 0x%x\n", status);
                         if (status & VT1724_IRQ_MPU_TX) {
                                 printk(KERN_ERR "ice1724: Disabling MPU_TX\n");
-                                outb(inb(ICEREG1724(ice, IRQMASK)) |
-                                     VT1724_IRQ_MPU_TX,
-                                     ICEREG1724(ice, IRQMASK));
+                                enable_midi_irq(ice, VT1724_IRQ_MPU_TX, 0);
                         }
+                        spin_unlock(&ice->reg_lock);
                         break;
                 }
                 handled = 1;
                 if (status & VT1724_IRQ_MPU_TX) {
-                        spin_lock(&ice->reg_lock);
                         if (ice->midi_output)
                                 vt1724_midi_write(ice);
-                        spin_unlock(&ice->reg_lock);
+                        else
+                                enable_midi_irq(ice, VT1724_IRQ_MPU_TX, 0);
                         /* Due to mysterical reasons, MPU_TX is always
                          * generated (and can't be cleared) when a PCM
                          * playback is going.  So let's ignore at the
@@ -415,15 +427,14 @@ static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id)
                         status_mask &= ~VT1724_IRQ_MPU_TX;
                 }
                 if (status & VT1724_IRQ_MPU_RX) {
-                        spin_lock(&ice->reg_lock);
                         if (ice->midi_input)
                                 vt1724_midi_read(ice);
                         else
                                 vt1724_midi_clear_rx(ice);
-                        spin_unlock(&ice->reg_lock);
                 }
                 /* ack MPU irq */
                 outb(status, ICEREG1724(ice, IRQSTAT));
+                spin_unlock(&ice->reg_lock);
                 if (status & VT1724_IRQ_MTPCM) {
                         /*
                          * Multi-track PCM
@@ -745,7 +756,14 @@ static int snd_vt1724_playback_pro_prepare(struct snd_pcm_substream *substream)
 
         spin_unlock_irq(&ice->reg_lock);
 
-        /* printk("pro prepare: ch = %d, addr = 0x%x, buffer = 0x%x, period = 0x%x\n", substream->runtime->channels, (unsigned int)substream->runtime->dma_addr, snd_pcm_lib_buffer_bytes(substream), snd_pcm_lib_period_bytes(substream)); */
+        /*
+        printk(KERN_DEBUG "pro prepare: ch = %d, addr = 0x%x, "
+               "buffer = 0x%x, period = 0x%x\n",
+               substream->runtime->channels,
+               (unsigned int)substream->runtime->dma_addr,
+               snd_pcm_lib_buffer_bytes(substream),
+               snd_pcm_lib_period_bytes(substream));
+        */
         return 0;
 }
 
@@ -2122,7 +2140,9 @@ unsigned char snd_vt1724_read_i2c(struct snd_ice1712 *ice,
         wait_i2c_busy(ice);
         val = inb(ICEREG1724(ice, I2C_DATA));
         mutex_unlock(&ice->i2c_mutex);
-        /* printk("i2c_read: [0x%x,0x%x] = 0x%x\n", dev, addr, val); */
+        /*
+        printk(KERN_DEBUG "i2c_read: [0x%x,0x%x] = 0x%x\n", dev, addr, val);
+        */
         return val;
 }
 
@@ -2131,7 +2151,9 @@ void snd_vt1724_write_i2c(struct snd_ice1712 *ice,
 {
         mutex_lock(&ice->i2c_mutex);
         wait_i2c_busy(ice);
-        /* printk("i2c_write: [0x%x,0x%x] = 0x%x\n", dev, addr, data); */
+        /*
+        printk(KERN_DEBUG "i2c_write: [0x%x,0x%x] = 0x%x\n", dev, addr, data);
+        */
         outb(addr, ICEREG1724(ice, I2C_BYTE_ADDR));
         outb(data, ICEREG1724(ice, I2C_DATA));
         outb(dev | VT1724_I2C_WRITE, ICEREG1724(ice, I2C_DEV_ADDR));
diff --git a/sound/pci/ice1712/juli.c b/sound/pci/ice1712/juli.c
index c51659b9caf6..fd948bfd9aef 100644
--- a/sound/pci/ice1712/juli.c
+++ b/sound/pci/ice1712/juli.c
@@ -345,8 +345,9 @@ static int juli_mute_put(struct snd_kcontrol *kcontrol,
                         new_gpio =  old_gpio &
                                 ~((unsigned int) kcontrol->private_value);
         }
-        /* printk("JULI - mute/unmute: control_value: 0x%x, old_gpio: 0x%x, \
-                new_gpio 0x%x\n",
+        /* printk(KERN_DEBUG
+                "JULI - mute/unmute: control_value: 0x%x, old_gpio: 0x%x, "
+                "new_gpio 0x%x\n",
                 (unsigned int)ucontrol->value.integer.value[0], old_gpio,
                 new_gpio); */
         if (old_gpio != new_gpio) {
diff --git a/sound/pci/ice1712/prodigy192.c b/sound/pci/ice1712/prodigy192.c
index 48d3679292a7..2a8e5cd8f2d8 100644
--- a/sound/pci/ice1712/prodigy192.c
+++ b/sound/pci/ice1712/prodigy192.c
@@ -133,8 +133,10 @@ static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e
                 idx  = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + STAC946X_LF_VOLUME;
         /* due to possible conflicts with stac9460_set_rate_val, mutexing */
         mutex_lock(&spec->mute_mutex);
-        /*printk("Mute put: reg 0x%02x, ctrl value: 0x%02x\n", idx,
-                ucontrol->value.integer.value[0]);*/
+        /*
+        printk(KERN_DEBUG "Mute put: reg 0x%02x, ctrl value: 0x%02x\n", idx,
+               ucontrol->value.integer.value[0]);
+        */
         change = stac9460_dac_mute(ice, idx, ucontrol->value.integer.value[0]);
         mutex_unlock(&spec->mute_mutex);
         return change;
@@ -185,7 +187,10 @@ static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el
         change = (ovol != nvol);
         if (change) {
                 ovol =  (0x7f - nvol) | (tmp & 0x80);
-                /*printk("DAC Volume: reg 0x%02x: 0x%02x\n", idx, ovol);*/
+                /*
+                printk(KERN_DEBUG "DAC Volume: reg 0x%02x: 0x%02x\n",
+                       idx, ovol);
+                */
                 stac9460_put(ice, idx, (0x7f - nvol) | (tmp & 0x80));
         }
         return change;
@@ -344,7 +349,7 @@ static void stac9460_set_rate_val(struct snd_ice1712 *ice, unsigned int rate)
         for (idx = 0; idx < 7 ; ++idx)
                 changed[idx] = stac9460_dac_mute(ice,
                                 STAC946X_MASTER_VOLUME + idx, 0);
-        /*printk("Rate change: %d, new MC: 0x%02x\n", rate, new);*/
+        /*printk(KERN_DEBUG "Rate change: %d, new MC: 0x%02x\n", rate, new);*/
         stac9460_put(ice, STAC946X_MASTER_CLOCKING, new);
         udelay(10);
         /* unmuting - only originally unmuted dacs -
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index 671ff65db029..173bebf9f51d 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -355,6 +355,9 @@ struct ichdev {
         unsigned int fragsize1;
         unsigned int position;
         unsigned int pos_shift;
+        unsigned int last_pos;
+        unsigned long last_pos_jiffies;
+        unsigned int jiffy_to_bytes;
         int frags;
         int lvi;
         int lvi_frag;
@@ -617,7 +620,7 @@ static int snd_intel8x0_ali_codec_semaphore(struct intel8x0 *chip)
         int time = 100;
         if (chip->buggy_semaphore)
                 return 0; /* just ignore ... */
-        while (time-- && (igetdword(chip, ICHREG(ALI_CAS)) & ALI_CAS_SEM_BUSY))
+        while (--time && (igetdword(chip, ICHREG(ALI_CAS)) & ALI_CAS_SEM_BUSY))
                 udelay(1);
         if (! time && ! chip->in_ac97_init)
                 snd_printk(KERN_WARNING "ali_codec_semaphore timeout\n");
@@ -689,7 +692,7 @@ static void snd_intel8x0_setup_periods(struct intel8x0 *chip, struct ichdev *ich
                         bdbar[idx + 1] = cpu_to_le32(0x80000000 | /* interrupt on completion */
                                                      ichdev->fragsize >> ichdev->pos_shift);
 #if 0
-                        printk("bdbar[%i] = 0x%x [0x%x]\n",
+                        printk(KERN_DEBUG "bdbar[%i] = 0x%x [0x%x]\n",
                                idx + 0, bdbar[idx + 0], bdbar[idx + 1]);
 #endif
                 }
@@ -701,8 +704,10 @@ static void snd_intel8x0_setup_periods(struct intel8x0 *chip, struct ichdev *ich
         ichdev->lvi_frag = ICH_REG_LVI_MASK % ichdev->frags;
         ichdev->position = 0;
 #if 0
-        printk("lvi_frag = %i, frags = %i, period_size = 0x%x, period_size1 = 0x%x\n",
-                        ichdev->lvi_frag, ichdev->frags, ichdev->fragsize, ichdev->fragsize1);
+        printk(KERN_DEBUG "lvi_frag = %i, frags = %i, period_size = 0x%x, "
+               "period_size1 = 0x%x\n",
+               ichdev->lvi_frag, ichdev->frags, ichdev->fragsize,
+               ichdev->fragsize1);
 #endif
         /* clear interrupts */
         iputbyte(chip, port + ichdev->roff_sr, ICH_FIFOE | ICH_BCIS | ICH_LVBCI);
@@ -768,7 +773,8 @@ static inline void snd_intel8x0_update(struct intel8x0 *chip, struct ichdev *ich
                 ichdev->lvi_frag %= ichdev->frags;
                 ichdev->bdbar[ichdev->lvi * 2] = cpu_to_le32(ichdev->physbuf + ichdev->lvi_frag * ichdev->fragsize1);
 #if 0
-        printk("new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, all = 0x%x, 0x%x\n",
+        printk(KERN_DEBUG "new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, "
+               "all = 0x%x, 0x%x\n",
                ichdev->lvi * 2, ichdev->bdbar[ichdev->lvi * 2],
                ichdev->bdbar[ichdev->lvi * 2 + 1], inb(ICH_REG_OFF_PIV + port),
                inl(port + 4), inb(port + ICH_REG_OFF_CR));
@@ -835,7 +841,10 @@ static int snd_intel8x0_pcm_trigger(struct snd_pcm_substream *substream, int cmd
                 ichdev->suspended = 0;
                 /* fallthru */
         case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                 val = ICH_IOCE | ICH_STARTBM;
+                ichdev->last_pos = ichdev->position;
+                ichdev->last_pos_jiffies = jiffies;
                 break;
         case SNDRV_PCM_TRIGGER_SUSPEND:
                 ichdev->suspended = 1;
@@ -846,9 +855,6 @@ static int snd_intel8x0_pcm_trigger(struct snd_pcm_substream *substream, int cmd
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 val = ICH_IOCE;
                 break;
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                val = ICH_IOCE | ICH_STARTBM;
-                break;
         default:
                 return -EINVAL;
         }
@@ -1042,6 +1048,7 @@ static int snd_intel8x0_pcm_prepare(struct snd_pcm_substream *substream)
                         ichdev->pos_shift = (runtime->sample_bits > 16) ? 2 : 1;
         }
         snd_intel8x0_setup_periods(chip, ichdev);
+        ichdev->jiffy_to_bytes = (runtime->rate * 4 * ichdev->pos_shift) / HZ;
         return 0;
 }
 
@@ -1050,7 +1057,7 @@ static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(struct snd_pcm_substream *subs
         struct intel8x0 *chip = snd_pcm_substream_chip(substream);
         struct ichdev *ichdev = get_ichdev(substream);
         size_t ptr1, ptr;
-        int civ, timeout = 100;
+        int civ, timeout = 10;
         unsigned int position;
 
         spin_lock(&chip->reg_lock);
@@ -1066,9 +1073,19 @@ static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(struct snd_pcm_substream *subs
                     ptr1 == igetword(chip, ichdev->reg_offset + ichdev->roff_picb))
                         break;
         } while (timeout--);
-        ptr1 <<= ichdev->pos_shift;
-        ptr = ichdev->fragsize1 - ptr1;
-        ptr += position;
+        if (ptr1 != 0) {
+                ptr1 <<= ichdev->pos_shift;
+                ptr = ichdev->fragsize1 - ptr1;
+                ptr += position;
+                ichdev->last_pos = ptr;
+                ichdev->last_pos_jiffies = jiffies;
+        } else {
+                ptr1 = jiffies - ichdev->last_pos_jiffies;
+                if (ptr1)
+                        ptr1 -= 1;
+                ptr = ichdev->last_pos + ptr1 * ichdev->jiffy_to_bytes;
+                ptr %= ichdev->size;
+        }
         spin_unlock(&chip->reg_lock);
         if (ptr >= ichdev->size)
                 return 0;
@@ -1837,6 +1854,12 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = {
         },
         {
                 .subvendor = 0x1028,
+                .subdevice = 0x016a,
+                .name = "Dell Inspiron 8600",   /* STAC9750/51 */
+                .type = AC97_TUNE_HP_ONLY
+        },
+        {
+                .subvendor = 0x1028,
                 .subdevice = 0x0186,
                 .name = "Dell Latitude D810", /* cf. Malone #41015 */
                 .type = AC97_TUNE_HP_MUTE_LED
@@ -1879,12 +1902,6 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = {
         },
         {
                 .subvendor = 0x103c,
-                .subdevice = 0x0934,
-                .name = "HP nx8220",
-                .type = AC97_TUNE_MUTE_LED
-        },
-        {
-                .subvendor = 0x103c,
                 .subdevice = 0x129d,
                 .name = "HP xw8000",
                 .type = AC97_TUNE_HP_ONLY
@@ -2287,23 +2304,23 @@ static void do_ali_reset(struct intel8x0 *chip)
         iputdword(chip, ICHREG(ALI_INTERRUPTSR), 0x00000000);
 }
 
-static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing)
-{
-        unsigned long end_time;
-        unsigned int cnt, status, nstatus;
-        
-        /* put logic to right state */
-        /* first clear status bits */
-        status = ICH_RCS | ICH_MCINT | ICH_POINT | ICH_PIINT;
-        if (chip->device_type == DEVICE_NFORCE)
-                status |= ICH_NVSPINT;
-        cnt = igetdword(chip, ICHREG(GLOB_STA));
-        iputdword(chip, ICHREG(GLOB_STA), cnt & status);
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+static struct snd_pci_quirk ich_chip_reset_mode[] = {
+        SND_PCI_QUIRK(0x1014, 0x051f, "Thinkpad R32", 1),
+        { } /* end */
+};
 
+static int snd_intel8x0_ich_chip_cold_reset(struct intel8x0 *chip)
+{
+        unsigned int cnt;
         /* ACLink on, 2 channels */
+
+        if (snd_pci_quirk_lookup(chip->pci, ich_chip_reset_mode))
+                return -EIO;
+
         cnt = igetdword(chip, ICHREG(GLOB_CNT));
         cnt &= ~(ICH_ACLINK | ICH_PCM_246_MASK);
-#ifdef CONFIG_SND_AC97_POWER_SAVE
+
         /* do cold reset - the full ac97 powerdown may leave the controller
          * in a warm state but actually it cannot communicate with the codec.
          */
@@ -2312,22 +2329,58 @@ static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing)
         udelay(10);
         iputdword(chip, ICHREG(GLOB_CNT), cnt | ICH_AC97COLD);
         msleep(1);
+        return 0;
+}
+#define snd_intel8x0_ich_chip_can_cold_reset(chip) \
+        (!snd_pci_quirk_lookup(chip->pci, ich_chip_reset_mode))
 #else
+#define snd_intel8x0_ich_chip_cold_reset(chip)  0
+#define snd_intel8x0_ich_chip_can_cold_reset(chip) (0)
+#endif
+
+static int snd_intel8x0_ich_chip_reset(struct intel8x0 *chip)
+{
+        unsigned long end_time;
+        unsigned int cnt;
+        /* ACLink on, 2 channels */
+        cnt = igetdword(chip, ICHREG(GLOB_CNT));
+        cnt &= ~(ICH_ACLINK | ICH_PCM_246_MASK);
         /* finish cold or do warm reset */
         cnt |= (cnt & ICH_AC97COLD) == 0 ? ICH_AC97COLD : ICH_AC97WARM;
         iputdword(chip, ICHREG(GLOB_CNT), cnt);
         end_time = (jiffies + (HZ / 4)) + 1;
         do {
                 if ((igetdword(chip, ICHREG(GLOB_CNT)) & ICH_AC97WARM) == 0)
-                        goto __ok;
+                        return 0;
                 schedule_timeout_uninterruptible(1);
         } while (time_after_eq(end_time, jiffies));
         snd_printk(KERN_ERR "AC'97 warm reset still in progress? [0x%x]\n",
                    igetdword(chip, ICHREG(GLOB_CNT)));
         return -EIO;
+}
+
+static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing)
+{
+        unsigned long end_time;
+        unsigned int status, nstatus;
+        unsigned int cnt;
+        int err;
+
+        /* put logic to right state */
+        /* first clear status bits */
+        status = ICH_RCS | ICH_MCINT | ICH_POINT | ICH_PIINT;
+        if (chip->device_type == DEVICE_NFORCE)
+                status |= ICH_NVSPINT;
+        cnt = igetdword(chip, ICHREG(GLOB_STA));
+        iputdword(chip, ICHREG(GLOB_STA), cnt & status);
+
+        if (snd_intel8x0_ich_chip_can_cold_reset(chip))
+                err = snd_intel8x0_ich_chip_cold_reset(chip);
+        else
+                err = snd_intel8x0_ich_chip_reset(chip);
+        if (err < 0)
+                return err;
 
-      __ok:
-#endif
         if (probing) {
                 /* wait for any codec ready status.
                  * Once it becomes ready it should remain ready
@@ -2622,12 +2675,14 @@ static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip)
         struct snd_pcm_substream *subs;
         struct ichdev *ichdev;
         unsigned long port;
-        unsigned long pos, t;
-        struct timeval start_time, stop_time;
+        unsigned long pos, pos1, t;
+        int civ, timeout = 1000, attempt = 1;
+        struct timespec start_time, stop_time;
 
         if (chip->ac97_bus->clock != 48000)
                 return; /* specified in module option */
 
+      __again:
         subs = chip->pcm[0]->streams[0].substream;
         if (! subs || subs->dma_buffer.bytes < INTEL8X0_TESTBUF_SIZE) {
                 snd_printk(KERN_WARNING "no playback buffer allocated - aborting measure ac97 clock\n");
@@ -2635,7 +2690,7 @@ static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip)
         }
         ichdev = &chip->ichd[ICHD_PCMOUT];
         ichdev->physbuf = subs->dma_buffer.addr;
-        ichdev->size = chip->ichd[ICHD_PCMOUT].fragsize = INTEL8X0_TESTBUF_SIZE;
+        ichdev->size = ichdev->fragsize = INTEL8X0_TESTBUF_SIZE;
         ichdev->substream = NULL; /* don't process interrupts */
 
         /* set rate */
@@ -2654,16 +2709,31 @@ static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip)
                 iputbyte(chip, port + ICH_REG_OFF_CR, ICH_IOCE);
                 iputdword(chip, ICHREG(ALI_DMACR), 1 << ichdev->ali_slot);
         }
-        do_gettimeofday(&start_time);
+        do_posix_clock_monotonic_gettime(&start_time);
         spin_unlock_irq(&chip->reg_lock);
         msleep(50);
         spin_lock_irq(&chip->reg_lock);
         /* check the position */
-        pos = ichdev->fragsize1;
-        pos -= igetword(chip, ichdev->reg_offset + ichdev->roff_picb) << ichdev->pos_shift;
-        pos += ichdev->position;
+        do {
+                civ = igetbyte(chip, ichdev->reg_offset + ICH_REG_OFF_CIV);
+                pos1 = igetword(chip, ichdev->reg_offset + ichdev->roff_picb);
+                if (pos1 == 0) {
+                        udelay(10);
+                        continue;
+                }
+                if (civ == igetbyte(chip, ichdev->reg_offset + ICH_REG_OFF_CIV) &&
+                    pos1 == igetword(chip, ichdev->reg_offset + ichdev->roff_picb))
+                        break;
+        } while (timeout--);
+        if (pos1 == 0) {        /* oops, this value is not reliable */
+                pos = 0;
+        } else {
+                pos = ichdev->fragsize1;
+                pos -= pos1 << ichdev->pos_shift;
+                pos += ichdev->position;
+        }
         chip->in_measurement = 0;
-        do_gettimeofday(&stop_time);
+        do_posix_clock_monotonic_gettime(&stop_time);
         /* stop */
         if (chip->device_type == DEVICE_ALI) {
                 iputdword(chip, ICHREG(ALI_DMACR), 1 << (ichdev->ali_slot + 16));
@@ -2678,22 +2748,42 @@ static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip)
         iputbyte(chip, port + ICH_REG_OFF_CR, ICH_RESETREGS);
         spin_unlock_irq(&chip->reg_lock);
 
+        if (pos == 0) {
+                snd_printk(KERN_ERR "intel8x0: measure - unreliable DMA position..\n");
+              __retry:
+                if (attempt < 3) {
+                        msleep(300);
+                        attempt++;
+                        goto __again;
+                }
+                goto __end;
+        }
+
+        pos /= 4;
         t = stop_time.tv_sec - start_time.tv_sec;
         t *= 1000000;
-        t += stop_time.tv_usec - start_time.tv_usec;
-        printk(KERN_INFO "%s: measured %lu usecs\n", __func__, t);
+        t += (stop_time.tv_nsec - start_time.tv_nsec) / 1000;
+        printk(KERN_INFO "%s: measured %lu usecs (%lu samples)\n", __func__, t, pos);
         if (t == 0) {
-                snd_printk(KERN_ERR "?? calculation error..\n");
-                return;
+                snd_printk(KERN_ERR "intel8x0: ?? calculation error..\n");
+                goto __retry;
         }
-        pos = (pos / 4) * 1000;
+        pos *= 1000;
         pos = (pos / t) * 1000 + ((pos % t) * 1000) / t;
-        if (pos < 40000 || pos >= 60000) 
+        if (pos < 40000 || pos >= 60000) {
                 /* abnormal value. hw problem? */
                 printk(KERN_INFO "intel8x0: measured clock %ld rejected\n", pos);
+                goto __retry;
+        } else if (pos > 40500 && pos < 41500)
+                /* first exception - 41000Hz reference clock */
+                chip->ac97_bus->clock = 41000;
+        else if (pos > 43600 && pos < 44600)
+                /* second exception - 44100HZ reference clock */
+                chip->ac97_bus->clock = 44100;
         else if (pos < 47500 || pos > 48500)
                 /* not 48000Hz, tuning the clock.. */
                 chip->ac97_bus->clock = (chip->ac97_bus->clock * 48000) / pos;
+      __end:
         printk(KERN_INFO "intel8x0: clocking to %d\n", chip->ac97_bus->clock);
         snd_ac97_update_power(chip->ac97[0], AC97_PCM_FRONT_DAC_RATE, 0);
 }
diff --git a/sound/pci/intel8x0m.c b/sound/pci/intel8x0m.c
index 33a843c19316..6ec0fc50d6be 100644
--- a/sound/pci/intel8x0m.c
+++ b/sound/pci/intel8x0m.c
@@ -411,7 +411,10 @@ static void snd_intel8x0_setup_periods(struct intel8x0m *chip, struct ichdev *ic
                         bdbar[idx + 0] = cpu_to_le32(ichdev->physbuf + (((idx >> 1) * ichdev->fragsize) % ichdev->size));
                         bdbar[idx + 1] = cpu_to_le32(0x80000000 | /* interrupt on completion */
                                                      ichdev->fragsize >> chip->pcm_pos_shift);
-                        // printk("bdbar[%i] = 0x%x [0x%x]\n", idx + 0, bdbar[idx + 0], bdbar[idx + 1]);
+                        /*
+                        printk(KERN_DEBUG "bdbar[%i] = 0x%x [0x%x]\n",
+                               idx + 0, bdbar[idx + 0], bdbar[idx + 1]);
+                        */
                 }
                 ichdev->frags = ichdev->size / ichdev->fragsize;
         }
@@ -421,8 +424,10 @@ static void snd_intel8x0_setup_periods(struct intel8x0m *chip, struct ichdev *ic
         ichdev->lvi_frag = ICH_REG_LVI_MASK % ichdev->frags;
         ichdev->position = 0;
 #if 0
-        printk("lvi_frag = %i, frags = %i, period_size = 0x%x, period_size1 = 0x%x\n",
-                        ichdev->lvi_frag, ichdev->frags, ichdev->fragsize, ichdev->fragsize1);
+        printk(KERN_DEBUG "lvi_frag = %i, frags = %i, period_size = 0x%x, "
+               "period_size1 = 0x%x\n",
+               ichdev->lvi_frag, ichdev->frags, ichdev->fragsize,
+               ichdev->fragsize1);
 #endif
         /* clear interrupts */
         iputbyte(chip, port + ichdev->roff_sr, ICH_FIFOE | ICH_BCIS | ICH_LVBCI);
@@ -465,7 +470,8 @@ static inline void snd_intel8x0_update(struct intel8x0m *chip, struct ichdev *ic
                                                              ichdev->lvi_frag *
                                                              ichdev->fragsize1);
 #if 0
-                printk("new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, all = 0x%x, 0x%x\n",
+                printk(KERN_DEBUG "new: bdbar[%i] = 0x%x [0x%x], "
+                       "prefetch = %i, all = 0x%x, 0x%x\n",
                        ichdev->lvi * 2, ichdev->bdbar[ichdev->lvi * 2],
                        ichdev->bdbar[ichdev->lvi * 2 + 1], inb(ICH_REG_OFF_PIV + port),
                        inl(port + 4), inb(port + ICH_REG_OFF_CR));
diff --git a/sound/pci/korg1212/korg1212.c b/sound/pci/korg1212/korg1212.c
index 8b79969034be..7cc38a11e997 100644
--- a/sound/pci/korg1212/korg1212.c
+++ b/sound/pci/korg1212/korg1212.c
@@ -1238,7 +1238,8 @@ static struct snd_pcm_hardware snd_korg1212_playback_info =
 {
         .info =              (SNDRV_PCM_INFO_MMAP |
                               SNDRV_PCM_INFO_MMAP_VALID |
-                              SNDRV_PCM_INFO_INTERLEAVED),
+                              SNDRV_PCM_INFO_INTERLEAVED |
+                              SNDRV_PCM_INFO_BATCH),
         .formats =            SNDRV_PCM_FMTBIT_S16_LE,
         .rates =              (SNDRV_PCM_RATE_44100 |
                               SNDRV_PCM_RATE_48000),
@@ -1258,7 +1259,8 @@ static struct snd_pcm_hardware snd_korg1212_capture_info =
 {
         .info =              (SNDRV_PCM_INFO_MMAP |
                               SNDRV_PCM_INFO_MMAP_VALID |
-                              SNDRV_PCM_INFO_INTERLEAVED),
+                              SNDRV_PCM_INFO_INTERLEAVED |
+                              SNDRV_PCM_INFO_BATCH),
         .formats =            SNDRV_PCM_FMTBIT_S16_LE,
         .rates =              (SNDRV_PCM_RATE_44100 |
                               SNDRV_PCM_RATE_48000),
diff --git a/sound/pci/maestro3.c b/sound/pci/maestro3.c
index 70141548f251..75283fbb4b3f 100644
--- a/sound/pci/maestro3.c
+++ b/sound/pci/maestro3.c
@@ -2530,8 +2530,8 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci,
                 return -EIO;
 
         /* check, if we can restrict PCI DMA transfers to 28 bits */
-        if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(28)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(28)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support 28bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c
index bfc19e36c4b6..82bc5b9e7629 100644
--- a/sound/pci/mixart/mixart.c
+++ b/sound/pci/mixart/mixart.c
@@ -607,6 +607,7 @@ static int snd_mixart_hw_params(struct snd_pcm_substream *subs,
         /* set the format to the board */
         err = mixart_set_format(stream, format);
         if(err < 0) {
+                mutex_unlock(&mgr->setup_mutex);
                 return err;
         }
 
@@ -1290,7 +1291,7 @@ static int __devinit snd_mixart_probe(struct pci_dev *pci,
         pci_set_master(pci);
 
         /* check if we can restrict PCI DMA transfers to 32 bits */
-        if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support 32bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/mixart/mixart_hwdep.c b/sound/pci/mixart/mixart_hwdep.c
index 3782b52bc0e8..4cf4cd8c939c 100644
--- a/sound/pci/mixart/mixart_hwdep.c
+++ b/sound/pci/mixart/mixart_hwdep.c
@@ -345,8 +345,8 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
         status_daught = readl_be( MIXART_MEM( mgr,MIXART_PSEUDOREG_DXLX_STATUS_OFFSET ));
 
         /* motherboard xilinx status 5 will say that the board is performing a reset */
-        if( status_xilinx == 5 ) {
-                snd_printk( KERN_ERR "miXart is resetting !\n");
+        if (status_xilinx == 5) {
+                snd_printk(KERN_ERR "miXart is resetting !\n");
                 return -EAGAIN; /* try again later */
         }
 
@@ -354,13 +354,14 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
         case MIXART_MOTHERBOARD_XLX_INDEX:
 
                 /* xilinx already loaded ? */ 
-                if( status_xilinx == 4 ) {
-                        snd_printk( KERN_DEBUG "xilinx is already loaded !\n");
+                if (status_xilinx == 4) {
+                        snd_printk(KERN_DEBUG "xilinx is already loaded !\n");
                         return 0;
                 }
                 /* the status should be 0 == "idle" */
-                if( status_xilinx != 0 ) {
-                        snd_printk( KERN_ERR "xilinx load error ! status = %d\n", status_xilinx);
+                if (status_xilinx != 0) {
+                        snd_printk(KERN_ERR "xilinx load error ! status = %d\n",
+                                   status_xilinx);
                         return -EIO; /* modprob -r may help ? */
                 }
 
@@ -389,21 +390,23 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
 
         case MIXART_MOTHERBOARD_ELF_INDEX:
 
-                if( status_elf == 4 ) {
-                        snd_printk( KERN_DEBUG "elf file already loaded !\n");
+                if (status_elf == 4) {
+                        snd_printk(KERN_DEBUG "elf file already loaded !\n");
                         return 0;
                 }
 
                 /* the status should be 0 == "idle" */
-                if( status_elf != 0 ) {
-                        snd_printk( KERN_ERR "elf load error ! status = %d\n", status_elf);
+                if (status_elf != 0) {
+                        snd_printk(KERN_ERR "elf load error ! status = %d\n",
+                                   status_elf);
                         return -EIO; /* modprob -r may help ? */
                 }
 
                 /* wait for xilinx status == 4 */
                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_MXLX_STATUS_OFFSET, 1, 4, 500); /* 5sec */
                 if (err < 0) {
-                        snd_printk( KERN_ERR "xilinx was not loaded or could not be started\n");
+                        snd_printk(KERN_ERR "xilinx was not loaded or "
+                                   "could not be started\n");
                         return err;
                 }
 
@@ -424,7 +427,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
                 /* wait for elf status == 4 */
                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_ELF_STATUS_OFFSET, 1, 4, 300); /* 3sec */
                 if (err < 0) {
-                        snd_printk( KERN_ERR "elf could not be started\n");
+                        snd_printk(KERN_ERR "elf could not be started\n");
                         return err;
                 }
 
@@ -437,15 +440,16 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
         default:
 
                 /* elf and xilinx should be loaded */
-                if( (status_elf != 4) || (status_xilinx != 4) ) {
-                        printk( KERN_ERR "xilinx or elf not successfully loaded\n");
+                if (status_elf != 4 || status_xilinx != 4) {
+                        printk(KERN_ERR "xilinx or elf not "
+                               "successfully loaded\n");
                         return -EIO; /* modprob -r may help ? */
                 }
 
                 /* wait for daughter detection != 0 */
                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DBRD_PRESENCE_OFFSET, 0, 0, 30); /* 300msec */
                 if (err < 0) {
-                        snd_printk( KERN_ERR "error starting elf file\n");
+                        snd_printk(KERN_ERR "error starting elf file\n");
                         return err;
                 }
 
@@ -460,8 +464,9 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
                         return -EINVAL;
 
                 /* daughter should be idle */
-                if( status_daught != 0 ) {
-                        printk( KERN_ERR "daughter load error ! status = %d\n", status_daught);
+                if (status_daught != 0) {
+                        printk(KERN_ERR "daughter load error ! status = %d\n",
+                               status_daught);
                         return -EIO; /* modprob -r may help ? */
                 }
  
@@ -480,7 +485,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
                 /* wait for status == 2 */
                 err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET, 1, 2, 30); /* 300msec */
                 if (err < 0) {
-                        snd_printk( KERN_ERR "daughter board load error\n");
+                        snd_printk(KERN_ERR "daughter board load error\n");
                         return err;
                 }
 
@@ -502,7 +507,8 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
         /* wait for daughter status == 3 */
         err = mixart_wait_nice_for_register_value( mgr, MIXART_PSEUDOREG_DXLX_STATUS_OFFSET, 1, 3, 300); /* 3sec */
         if (err < 0) {
-                snd_printk( KERN_ERR "daughter board could not be initialised\n");
+                snd_printk(KERN_ERR
+                           "daughter board could not be initialised\n");
                 return err;
         }
 
@@ -512,7 +518,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw
         /* first communication with embedded */
         err = mixart_first_init(mgr);
         if (err < 0) {
-                snd_printk( KERN_ERR "miXart could not be set up\n");
+                snd_printk(KERN_ERR "miXart could not be set up\n");
                 return err;
         }
 
@@ -581,16 +587,6 @@ MODULE_FIRMWARE("mixart/miXart8AES.xlx");
 /* miXart hwdep interface id string */
 #define SND_MIXART_HWDEP_ID       "miXart Loader"
 
-static int mixart_hwdep_open(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
-static int mixart_hwdep_release(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
 static int mixart_hwdep_dsp_status(struct snd_hwdep *hw,
                                    struct snd_hwdep_dsp_status *info)
 {
@@ -643,8 +639,6 @@ int snd_mixart_setup_firmware(struct mixart_mgr *mgr)
 
         hw->iface = SNDRV_HWDEP_IFACE_MIXART;
         hw->private_data = mgr;
-        hw->ops.open = mixart_hwdep_open;
-        hw->ops.release = mixart_hwdep_release;
         hw->ops.dsp_status = mixart_hwdep_dsp_status;
         hw->ops.dsp_load = mixart_hwdep_dsp_load;
         hw->exclusive = 1;
diff --git a/sound/pci/oxygen/hifier.c b/sound/pci/oxygen/hifier.c
index 1ab833f843eb..84ef13183419 100644
--- a/sound/pci/oxygen/hifier.c
+++ b/sound/pci/oxygen/hifier.c
@@ -45,6 +45,7 @@ MODULE_PARM_DESC(enable, "enable card");
 static struct pci_device_id hifier_ids[] __devinitdata = {
         { OXYGEN_PCI_SUBID(0x14c3, 0x1710) },
         { OXYGEN_PCI_SUBID(0x14c3, 0x1711) },
+        { OXYGEN_PCI_SUBID_BROKEN_EEPROM },
         { }
 };
 MODULE_DEVICE_TABLE(pci, hifier_ids);
@@ -151,7 +152,6 @@ static const struct oxygen_model model_hifier = {
         .shortname = "C-Media CMI8787",
         .longname = "C-Media Oxygen HD Audio",
         .chip = "CMI8788",
-        .owner = THIS_MODULE,
         .init = hifier_init,
         .control_filter = hifier_control_filter,
         .cleanup = hifier_cleanup,
@@ -173,6 +173,13 @@ static const struct oxygen_model model_hifier = {
         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 };
 
+static int __devinit get_hifier_model(struct oxygen *chip,
+                                      const struct pci_device_id *id)
+{
+        chip->model = model_hifier;
+        return 0;
+}
+
 static int __devinit hifier_probe(struct pci_dev *pci,
                                   const struct pci_device_id *pci_id)
 {
@@ -185,7 +192,8 @@ static int __devinit hifier_probe(struct pci_dev *pci,
                 ++dev;
                 return -ENOENT;
         }
-        err = oxygen_pci_probe(pci, index[dev], id[dev], &model_hifier, 0);
+        err = oxygen_pci_probe(pci, index[dev], id[dev], THIS_MODULE,
+                               hifier_ids, get_hifier_model);
         if (err >= 0)
                 ++dev;
         return err;
diff --git a/sound/pci/oxygen/oxygen.c b/sound/pci/oxygen/oxygen.c
index de999c6d6dd3..72db4c39007f 100644
--- a/sound/pci/oxygen/oxygen.c
+++ b/sound/pci/oxygen/oxygen.c
@@ -1,5 +1,5 @@
 /*
- * C-Media CMI8788 driver for C-Media's reference design and for the X-Meridian
+ * C-Media CMI8788 driver for C-Media's reference design and similar models
  *
  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
  *
@@ -26,6 +26,7 @@
  *
  * GPIO 0 -> DFS0 of AK5385
  * GPIO 1 -> DFS1 of AK5385
+ * GPIO 8 -> enable headphone amplifier on HT-Omega models
  */
 
 #include <linux/delay.h>
@@ -61,7 +62,8 @@ MODULE_PARM_DESC(enable, "enable card");
 enum {
         MODEL_CMEDIA_REF,       /* C-Media's reference design */
         MODEL_MERIDIAN,         /* AuzenTech X-Meridian */
-        MODEL_HALO,             /* HT-Omega Claro halo */
+        MODEL_CLARO,            /* HT-Omega Claro */
+        MODEL_CLARO_HALO,       /* HT-Omega Claro halo */
 };
 
 static struct pci_device_id oxygen_ids[] __devinitdata = {
@@ -74,8 +76,8 @@ static struct pci_device_id oxygen_ids[] __devinitdata = {
         { OXYGEN_PCI_SUBID(0x147a, 0xa017), .driver_data = MODEL_CMEDIA_REF },
         { OXYGEN_PCI_SUBID(0x1a58, 0x0910), .driver_data = MODEL_CMEDIA_REF },
         { OXYGEN_PCI_SUBID(0x415a, 0x5431), .driver_data = MODEL_MERIDIAN },
-        { OXYGEN_PCI_SUBID(0x7284, 0x9761), .driver_data = MODEL_CMEDIA_REF },
-        { OXYGEN_PCI_SUBID(0x7284, 0x9781), .driver_data = MODEL_HALO },
+        { OXYGEN_PCI_SUBID(0x7284, 0x9761), .driver_data = MODEL_CLARO },
+        { OXYGEN_PCI_SUBID(0x7284, 0x9781), .driver_data = MODEL_CLARO_HALO },
         { }
 };
 MODULE_DEVICE_TABLE(pci, oxygen_ids);
@@ -86,6 +88,8 @@ MODULE_DEVICE_TABLE(pci, oxygen_ids);
 #define GPIO_AK5385_DFS_DOUBLE  0x0001
 #define GPIO_AK5385_DFS_QUAD    0x0002
 
+#define GPIO_CLARO_HP           0x0100
+
 struct generic_data {
         u8 ak4396_ctl2;
         u16 saved_wm8785_registers[2];
@@ -196,10 +200,46 @@ static void meridian_init(struct oxygen *chip)
         ak5385_init(chip);
 }
 
+static void claro_enable_hp(struct oxygen *chip)
+{
+        msleep(300);
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_CLARO_HP);
+        oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, GPIO_CLARO_HP);
+}
+
+static void claro_init(struct oxygen *chip)
+{
+        ak4396_init(chip);
+        wm8785_init(chip);
+        claro_enable_hp(chip);
+}
+
+static void claro_halo_init(struct oxygen *chip)
+{
+        ak4396_init(chip);
+        ak5385_init(chip);
+        claro_enable_hp(chip);
+}
+
 static void generic_cleanup(struct oxygen *chip)
 {
 }
 
+static void claro_disable_hp(struct oxygen *chip)
+{
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_CLARO_HP);
+}
+
+static void claro_cleanup(struct oxygen *chip)
+{
+        claro_disable_hp(chip);
+}
+
+static void claro_suspend(struct oxygen *chip)
+{
+        claro_disable_hp(chip);
+}
+
 static void generic_resume(struct oxygen *chip)
 {
         ak4396_registers_init(chip);
@@ -211,6 +251,12 @@ static void meridian_resume(struct oxygen *chip)
         ak4396_registers_init(chip);
 }
 
+static void claro_resume(struct oxygen *chip)
+{
+        ak4396_registers_init(chip);
+        claro_enable_hp(chip);
+}
+
 static void set_ak4396_params(struct oxygen *chip,
                               struct snd_pcm_hw_params *params)
 {
@@ -293,30 +339,10 @@ static void set_ak5385_params(struct oxygen *chip,
 
 static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0);
 
-static int generic_probe(struct oxygen *chip, unsigned long driver_data)
-{
-        if (driver_data == MODEL_MERIDIAN) {
-                chip->model.init = meridian_init;
-                chip->model.resume = meridian_resume;
-                chip->model.set_adc_params = set_ak5385_params;
-                chip->model.device_config = PLAYBACK_0_TO_I2S |
-                                            PLAYBACK_1_TO_SPDIF |
-                                            CAPTURE_0_FROM_I2S_2 |
-                                            CAPTURE_1_FROM_SPDIF;
-        }
-        if (driver_data == MODEL_MERIDIAN || driver_data == MODEL_HALO) {
-                chip->model.misc_flags = OXYGEN_MISC_MIDI;
-                chip->model.device_config |= MIDI_OUTPUT | MIDI_INPUT;
-        }
-        return 0;
-}
-
 static const struct oxygen_model model_generic = {
         .shortname = "C-Media CMI8788",
         .longname = "C-Media Oxygen HD Audio",
         .chip = "CMI8788",
-        .owner = THIS_MODULE,
-        .probe = generic_probe,
         .init = generic_init,
         .cleanup = generic_cleanup,
         .resume = generic_resume,
@@ -341,6 +367,42 @@ static const struct oxygen_model model_generic = {
         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 };
 
+static int __devinit get_oxygen_model(struct oxygen *chip,
+                                      const struct pci_device_id *id)
+{
+        chip->model = model_generic;
+        switch (id->driver_data) {
+        case MODEL_MERIDIAN:
+                chip->model.init = meridian_init;
+                chip->model.resume = meridian_resume;
+                chip->model.set_adc_params = set_ak5385_params;
+                chip->model.device_config = PLAYBACK_0_TO_I2S |
+                                            PLAYBACK_1_TO_SPDIF |
+                                            CAPTURE_0_FROM_I2S_2 |
+                                            CAPTURE_1_FROM_SPDIF;
+                break;
+        case MODEL_CLARO:
+                chip->model.init = claro_init;
+                chip->model.cleanup = claro_cleanup;
+                chip->model.suspend = claro_suspend;
+                chip->model.resume = claro_resume;
+                break;
+        case MODEL_CLARO_HALO:
+                chip->model.init = claro_halo_init;
+                chip->model.cleanup = claro_cleanup;
+                chip->model.suspend = claro_suspend;
+                chip->model.resume = claro_resume;
+                chip->model.set_adc_params = set_ak5385_params;
+                break;
+        }
+        if (id->driver_data == MODEL_MERIDIAN ||
+            id->driver_data == MODEL_CLARO_HALO) {
+                chip->model.misc_flags = OXYGEN_MISC_MIDI;
+                chip->model.device_config |= MIDI_OUTPUT | MIDI_INPUT;
+        }
+        return 0;
+}
+
 static int __devinit generic_oxygen_probe(struct pci_dev *pci,
                                           const struct pci_device_id *pci_id)
 {
@@ -353,8 +415,8 @@ static int __devinit generic_oxygen_probe(struct pci_dev *pci,
                 ++dev;
                 return -ENOENT;
         }
-        err = oxygen_pci_probe(pci, index[dev], id[dev],
-                               &model_generic, pci_id->driver_data);
+        err = oxygen_pci_probe(pci, index[dev], id[dev], THIS_MODULE,
+                               oxygen_ids, get_oxygen_model);
         if (err >= 0)
                 ++dev;
         return err;
diff --git a/sound/pci/oxygen/oxygen.h b/sound/pci/oxygen/oxygen.h
index 19107c6307e5..bd615dbffadb 100644
--- a/sound/pci/oxygen/oxygen.h
+++ b/sound/pci/oxygen/oxygen.h
@@ -18,6 +18,8 @@
 
 #define OXYGEN_IO_SIZE  0x100
 
+#define OXYGEN_EEPROM_ID        0x434d  /* "CM" */
+
 /* model-specific configuration of outputs/inputs */
 #define PLAYBACK_0_TO_I2S       0x0001
      /* PLAYBACK_0_TO_AC97_0            not implemented */
@@ -49,7 +51,13 @@ enum {
         .subvendor = sv, \
         .subdevice = sd
 
+#define BROKEN_EEPROM_DRIVER_DATA ((unsigned long)-1)
+#define OXYGEN_PCI_SUBID_BROKEN_EEPROM \
+        OXYGEN_PCI_SUBID(PCI_VENDOR_ID_CMEDIA, 0x8788), \
+        .driver_data = BROKEN_EEPROM_DRIVER_DATA
+
 struct pci_dev;
+struct pci_device_id;
 struct snd_card;
 struct snd_pcm_substream;
 struct snd_pcm_hardware;
@@ -62,8 +70,6 @@ struct oxygen_model {
         const char *shortname;
         const char *longname;
         const char *chip;
-        struct module *owner;
-        int (*probe)(struct oxygen *chip, unsigned long driver_data);
         void (*init)(struct oxygen *chip);
         int (*control_filter)(struct snd_kcontrol_new *template);
         int (*mixer_init)(struct oxygen *chip);
@@ -83,6 +89,7 @@ struct oxygen_model {
         void (*ac97_switch)(struct oxygen *chip,
                             unsigned int reg, unsigned int mute);
         const unsigned int *dac_tlv;
+        unsigned long private_data;
         size_t model_data_size;
         unsigned int device_config;
         u8 dac_channels;
@@ -134,8 +141,12 @@ struct oxygen {
 /* oxygen_lib.c */
 
 int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,
-                     const struct oxygen_model *model,
-                     unsigned long driver_data);
+                     struct module *owner,
+                     const struct pci_device_id *ids,
+                     int (*get_model)(struct oxygen *chip,
+                                      const struct pci_device_id *id
+                                     )
+                    );
 void oxygen_pci_remove(struct pci_dev *pci);
 #ifdef CONFIG_PM
 int oxygen_pci_suspend(struct pci_dev *pci, pm_message_t state);
@@ -180,6 +191,9 @@ void oxygen_write_i2c(struct oxygen *chip, u8 device, u8 map, u8 data);
 void oxygen_reset_uart(struct oxygen *chip);
 void oxygen_write_uart(struct oxygen *chip, u8 data);
 
+u16 oxygen_read_eeprom(struct oxygen *chip, unsigned int index);
+void oxygen_write_eeprom(struct oxygen *chip, unsigned int index, u16 value);
+
 static inline void oxygen_set_bits8(struct oxygen *chip,
                                     unsigned int reg, u8 value)
 {
diff --git a/sound/pci/oxygen/oxygen_io.c b/sound/pci/oxygen/oxygen_io.c
index 3126c4b403dd..c1eb923f2ac9 100644
--- a/sound/pci/oxygen/oxygen_io.c
+++ b/sound/pci/oxygen/oxygen_io.c
@@ -254,3 +254,34 @@ void oxygen_write_uart(struct oxygen *chip, u8 data)
         _write_uart(chip, 0, data);
 }
 EXPORT_SYMBOL(oxygen_write_uart);
+
+u16 oxygen_read_eeprom(struct oxygen *chip, unsigned int index)
+{
+        unsigned int timeout;
+
+        oxygen_write8(chip, OXYGEN_EEPROM_CONTROL,
+                      index | OXYGEN_EEPROM_DIR_READ);
+        for (timeout = 0; timeout < 100; ++timeout) {
+                udelay(1);
+                if (!(oxygen_read8(chip, OXYGEN_EEPROM_STATUS)
+                      & OXYGEN_EEPROM_BUSY))
+                        break;
+        }
+        return oxygen_read16(chip, OXYGEN_EEPROM_DATA);
+}
+
+void oxygen_write_eeprom(struct oxygen *chip, unsigned int index, u16 value)
+{
+        unsigned int timeout;
+
+        oxygen_write16(chip, OXYGEN_EEPROM_DATA, value);
+        oxygen_write8(chip, OXYGEN_EEPROM_CONTROL,
+                      index | OXYGEN_EEPROM_DIR_WRITE);
+        for (timeout = 0; timeout < 10; ++timeout) {
+                msleep(1);
+                if (!(oxygen_read8(chip, OXYGEN_EEPROM_STATUS)
+                      & OXYGEN_EEPROM_BUSY))
+                        return;
+        }
+        snd_printk(KERN_ERR "EEPROM write timeout\n");
+}
diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c
index 9c81e0b05113..312251d39696 100644
--- a/sound/pci/oxygen/oxygen_lib.c
+++ b/sound/pci/oxygen/oxygen_lib.c
@@ -34,6 +34,7 @@ MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
 MODULE_DESCRIPTION("C-Media CMI8788 helper library");
 MODULE_LICENSE("GPL v2");
 
+#define DRIVER "oxygen"
 
 static inline int oxygen_uart_input_ready(struct oxygen *chip)
 {
@@ -243,6 +244,62 @@ static void oxygen_proc_init(struct oxygen *chip)
 #define oxygen_proc_init(chip)
 #endif
 
+static const struct pci_device_id *
+oxygen_search_pci_id(struct oxygen *chip, const struct pci_device_id ids[])
+{
+        u16 subdevice;
+
+        /*
+         * Make sure the EEPROM pins are available, i.e., not used for SPI.
+         * (This function is called before we initialize or use SPI.)
+         */
+        oxygen_clear_bits8(chip, OXYGEN_FUNCTION,
+                           OXYGEN_FUNCTION_ENABLE_SPI_4_5);
+        /*
+         * Read the subsystem device ID directly from the EEPROM, because the
+         * chip didn't if the first EEPROM word was overwritten.
+         */
+        subdevice = oxygen_read_eeprom(chip, 2);
+        /*
+         * We use only the subsystem device ID for searching because it is
+         * unique even without the subsystem vendor ID, which may have been
+         * overwritten in the EEPROM.
+         */
+        for (; ids->vendor; ++ids)
+                if (ids->subdevice == subdevice &&
+                    ids->driver_data != BROKEN_EEPROM_DRIVER_DATA)
+                        return ids;
+        return NULL;
+}
+
+static void oxygen_restore_eeprom(struct oxygen *chip,
+                                  const struct pci_device_id *id)
+{
+        if (oxygen_read_eeprom(chip, 0) != OXYGEN_EEPROM_ID) {
+                /*
+                 * This function gets called only when a known card model has
+                 * been detected, i.e., we know there is a valid subsystem
+                 * product ID at index 2 in the EEPROM.  Therefore, we have
+                 * been able to deduce the correct subsystem vendor ID, and
+                 * this is enough information to restore the original EEPROM
+                 * contents.
+                 */
+                oxygen_write_eeprom(chip, 1, id->subvendor);
+                oxygen_write_eeprom(chip, 0, OXYGEN_EEPROM_ID);
+
+                oxygen_set_bits8(chip, OXYGEN_MISC,
+                                 OXYGEN_MISC_WRITE_PCI_SUBID);
+                pci_write_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID,
+                                      id->subvendor);
+                pci_write_config_word(chip->pci, PCI_SUBSYSTEM_ID,
+                                      id->subdevice);
+                oxygen_clear_bits8(chip, OXYGEN_MISC,
+                                   OXYGEN_MISC_WRITE_PCI_SUBID);
+
+                snd_printk(KERN_INFO "EEPROM ID restored\n");
+        }
+}
+
 static void oxygen_init(struct oxygen *chip)
 {
         unsigned int i;
@@ -446,21 +503,26 @@ static void oxygen_card_free(struct snd_card *card)
                 free_irq(chip->irq, chip);
         flush_scheduled_work();
         chip->model.cleanup(chip);
+        kfree(chip->model_data);
         mutex_destroy(&chip->mutex);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
 }
 
 int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,
-                     const struct oxygen_model *model,
-                     unsigned long driver_data)
+                     struct module *owner,
+                     const struct pci_device_id *ids,
+                     int (*get_model)(struct oxygen *chip,
+                                      const struct pci_device_id *id
+                                     )
+                    )
 {
         struct snd_card *card;
         struct oxygen *chip;
+        const struct pci_device_id *pci_id;
         int err;
 
-        err = snd_card_create(index, id, model->owner,
-                              sizeof(*chip) + model->model_data_size, &card);
+        err = snd_card_create(index, id, owner, sizeof(*chip), &card);
         if (err < 0)
                 return err;
 
@@ -468,8 +530,6 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,
         chip->card = card;
         chip->pci = pci;
         chip->irq = -1;
-        chip->model = *model;
-        chip->model_data = chip + 1;
         spin_lock_init(&chip->reg_lock);
         mutex_init(&chip->mutex);
         INIT_WORK(&chip->spdif_input_bits_work,
@@ -481,7 +541,7 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,
         if (err < 0)
                 goto err_card;
 
-        err = pci_request_regions(pci, model->chip);
+        err = pci_request_regions(pci, DRIVER);
         if (err < 0) {
                 snd_printk(KERN_ERR "cannot reserve PCI resources\n");
                 goto err_pci_enable;
@@ -495,20 +555,34 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,
         }
         chip->addr = pci_resource_start(pci, 0);
 
+        pci_id = oxygen_search_pci_id(chip, ids);
+        if (!pci_id) {
+                err = -ENODEV;
+                goto err_pci_regions;
+        }
+        oxygen_restore_eeprom(chip, pci_id);
+        err = get_model(chip, pci_id);
+        if (err < 0)
+                goto err_pci_regions;
+
+        if (chip->model.model_data_size) {
+                chip->model_data = kzalloc(chip->model.model_data_size,
+                                           GFP_KERNEL);
+                if (!chip->model_data) {
+                        err = -ENOMEM;
+                        goto err_pci_regions;
+                }
+        }
+
         pci_set_master(pci);
         snd_card_set_dev(card, &pci->dev);
         card->private_free = oxygen_card_free;
 
-        if (chip->model.probe) {
-                err = chip->model.probe(chip, driver_data);
-                if (err < 0)
-                        goto err_card;
-        }
         oxygen_init(chip);
         chip->model.init(chip);
 
         err = request_irq(pci->irq, oxygen_interrupt, IRQF_SHARED,
-                          chip->model.chip, chip);
+                          DRIVER, chip);
         if (err < 0) {
                 snd_printk(KERN_ERR "cannot grab interrupt %d\n", pci->irq);
                 goto err_card;
diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c
index 98c6a8c65d81..bc5ce11c8b14 100644
--- a/sound/pci/oxygen/virtuoso.c
+++ b/sound/pci/oxygen/virtuoso.c
@@ -112,6 +112,34 @@
  * CS4362A: AD0 <- 0
  */
 
+/*
+ * Xonar Essence STX
+ * -----------------
+ *
+ * CMI8788:
+ *
+ * I²C <-> PCM1792A
+ *
+ * GPI 0 <- external power present
+ *
+ * GPIO 0 -> enable output to speakers
+ * GPIO 1 -> route HP to front panel (0) or rear jack (1)
+ * GPIO 2 -> M0 of CS5381
+ * GPIO 3 -> M1 of CS5381
+ * GPIO 7 -> route output to speaker jacks (0) or HP (1)
+ * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
+ *
+ * PCM1792A:
+ *
+ * AD0 <- 0
+ *
+ * H6 daughterboard
+ * ----------------
+ *
+ * GPIO 4 <- 0
+ * GPIO 5 <- 0
+ */
+
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/mutex.h>
@@ -152,6 +180,7 @@ enum {
         MODEL_DX,
         MODEL_HDAV,     /* without daughterboard */
         MODEL_HDAV_H6,  /* with H6 daughterboard */
+        MODEL_STX,
 };
 
 static struct pci_device_id xonar_ids[] __devinitdata = {
@@ -160,6 +189,8 @@ static struct pci_device_id xonar_ids[] __devinitdata = {
         { OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data = MODEL_D2X },
         { OXYGEN_PCI_SUBID(0x1043, 0x8314), .driver_data = MODEL_HDAV },
         { OXYGEN_PCI_SUBID(0x1043, 0x834f), .driver_data = MODEL_D1 },
+        { OXYGEN_PCI_SUBID(0x1043, 0x835c), .driver_data = MODEL_STX },
+        { OXYGEN_PCI_SUBID_BROKEN_EEPROM },
         { }
 };
 MODULE_DEVICE_TABLE(pci, xonar_ids);
@@ -183,12 +214,14 @@ MODULE_DEVICE_TABLE(pci, xonar_ids);
 #define GPIO_HDAV_DB_H6         0x0000
 #define GPIO_HDAV_DB_XX         0x0020
 
+#define GPIO_ST_HP_REAR         0x0002
+#define GPIO_ST_HP              0x0080
+
 #define I2C_DEVICE_PCM1796(i)   (0x98 + ((i) << 1))     /* 10011, ADx=i, /W=0 */
 #define I2C_DEVICE_CS4398       0x9e    /* 10011, AD1=1, AD0=1, /W=0 */
 #define I2C_DEVICE_CS4362A      0x30    /* 001100, AD0=0, /W=0 */
 
 struct xonar_data {
-        unsigned int model;
         unsigned int anti_pop_delay;
         unsigned int dacs;
         u16 output_enable_bit;
@@ -334,15 +367,9 @@ static void xonar_d2_init(struct oxygen *chip)
         struct xonar_data *data = chip->model_data;
 
         data->anti_pop_delay = 300;
+        data->dacs = 4;
         data->output_enable_bit = GPIO_D2_OUTPUT_ENABLE;
         data->pcm1796_oversampling = PCM1796_OS_64;
-        if (data->model == MODEL_D2X) {
-                data->ext_power_reg = OXYGEN_GPIO_DATA;
-                data->ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK;
-                data->ext_power_bit = GPIO_D2X_EXT_POWER;
-                oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL,
-                                    GPIO_D2X_EXT_POWER);
-        }
 
         pcm1796_init(chip);
 
@@ -355,6 +382,18 @@ static void xonar_d2_init(struct oxygen *chip)
         snd_component_add(chip->card, "CS5381");
 }
 
+static void xonar_d2x_init(struct oxygen *chip)
+{
+        struct xonar_data *data = chip->model_data;
+
+        data->ext_power_reg = OXYGEN_GPIO_DATA;
+        data->ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK;
+        data->ext_power_bit = GPIO_D2X_EXT_POWER;
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER);
+
+        xonar_d2_init(chip);
+}
+
 static void update_cs4362a_volumes(struct oxygen *chip)
 {
         u8 mute;
@@ -422,11 +461,6 @@ static void xonar_d1_init(struct oxygen *chip)
         data->cs4398_fm = CS4398_FM_SINGLE | CS4398_DEM_NONE | CS4398_DIF_LJUST;
         data->cs4362a_fm = CS4362A_FM_SINGLE |
                 CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L;
-        if (data->model == MODEL_DX) {
-                data->ext_power_reg = OXYGEN_GPI_DATA;
-                data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
-                data->ext_power_bit = GPI_DX_EXT_POWER;
-        }
 
         oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
                        OXYGEN_2WIRE_LENGTH_8 |
@@ -447,6 +481,17 @@ static void xonar_d1_init(struct oxygen *chip)
         snd_component_add(chip->card, "CS5361");
 }
 
+static void xonar_dx_init(struct oxygen *chip)
+{
+        struct xonar_data *data = chip->model_data;
+
+        data->ext_power_reg = OXYGEN_GPI_DATA;
+        data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
+        data->ext_power_bit = GPI_DX_EXT_POWER;
+
+        xonar_d1_init(chip);
+}
+
 static void xonar_hdav_init(struct oxygen *chip)
 {
         struct xonar_data *data = chip->model_data;
@@ -458,6 +503,7 @@ static void xonar_hdav_init(struct oxygen *chip)
                        OXYGEN_2WIRE_SPEED_FAST);
 
         data->anti_pop_delay = 100;
+        data->dacs = chip->model.private_data == MODEL_HDAV_H6 ? 4 : 1;
         data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE;
         data->ext_power_reg = OXYGEN_GPI_DATA;
         data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
@@ -484,6 +530,36 @@ static void xonar_hdav_init(struct oxygen *chip)
         snd_component_add(chip->card, "CS5381");
 }
 
+static void xonar_stx_init(struct oxygen *chip)
+{
+        struct xonar_data *data = chip->model_data;
+
+        oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
+                       OXYGEN_2WIRE_LENGTH_8 |
+                       OXYGEN_2WIRE_INTERRUPT_MASK |
+                       OXYGEN_2WIRE_SPEED_FAST);
+
+        data->anti_pop_delay = 100;
+        data->dacs = 1;
+        data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE;
+        data->ext_power_reg = OXYGEN_GPI_DATA;
+        data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
+        data->ext_power_bit = GPI_DX_EXT_POWER;
+        data->pcm1796_oversampling = PCM1796_OS_64;
+
+        pcm1796_init(chip);
+
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
+                          GPIO_DX_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
+                            GPIO_DX_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
+
+        xonar_common_init(chip);
+
+        snd_component_add(chip->card, "PCM1792A");
+        snd_component_add(chip->card, "CS5381");
+}
+
 static void xonar_disable_output(struct oxygen *chip)
 {
         struct xonar_data *data = chip->model_data;
@@ -511,6 +587,11 @@ static void xonar_hdav_cleanup(struct oxygen *chip)
         xonar_disable_output(chip);
 }
 
+static void xonar_st_cleanup(struct oxygen *chip)
+{
+        xonar_disable_output(chip);
+}
+
 static void xonar_d2_suspend(struct oxygen *chip)
 {
         xonar_d2_cleanup(chip);
@@ -527,6 +608,11 @@ static void xonar_hdav_suspend(struct oxygen *chip)
         msleep(2);
 }
 
+static void xonar_st_suspend(struct oxygen *chip)
+{
+        xonar_st_cleanup(chip);
+}
+
 static void xonar_d2_resume(struct oxygen *chip)
 {
         pcm1796_init(chip);
@@ -554,6 +640,12 @@ static void xonar_hdav_resume(struct oxygen *chip)
         xonar_enable_output(chip);
 }
 
+static void xonar_st_resume(struct oxygen *chip)
+{
+        pcm1796_init(chip);
+        xonar_enable_output(chip);
+}
+
 static void xonar_hdav_pcm_hardware_filter(unsigned int channel,
                                            struct snd_pcm_hardware *hardware)
 {
@@ -676,7 +768,7 @@ static void xonar_hdav_uart_input(struct oxygen *chip)
         if (chip->uart_input_count >= 2 &&
             chip->uart_input[chip->uart_input_count - 2] == 'O' &&
             chip->uart_input[chip->uart_input_count - 1] == 'K') {
-                printk(KERN_DEBUG "message from Xonar HDAV HDMI chip received:");
+                printk(KERN_DEBUG "message from Xonar HDAV HDMI chip received:\n");
                 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET,
                                      chip->uart_input, chip->uart_input_count);
                 chip->uart_input_count = 0;
@@ -733,6 +825,72 @@ static const struct snd_kcontrol_new front_panel_switch = {
         .private_value = GPIO_DX_FRONT_PANEL,
 };
 
+static int st_output_switch_info(struct snd_kcontrol *ctl,
+                                 struct snd_ctl_elem_info *info)
+{
+        static const char *const names[3] = {
+                "Speakers", "Headphones", "FP Headphones"
+        };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 3;
+        if (info->value.enumerated.item >= 3)
+                info->value.enumerated.item = 2;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int st_output_switch_get(struct snd_kcontrol *ctl,
+                                struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        u16 gpio;
+
+        gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
+        if (!(gpio & GPIO_ST_HP))
+                value->value.enumerated.item[0] = 0;
+        else if (gpio & GPIO_ST_HP_REAR)
+                value->value.enumerated.item[0] = 1;
+        else
+                value->value.enumerated.item[0] = 2;
+        return 0;
+}
+
+
+static int st_output_switch_put(struct snd_kcontrol *ctl,
+                                struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        u16 gpio_old, gpio;
+
+        mutex_lock(&chip->mutex);
+        gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
+        gpio = gpio_old;
+        switch (value->value.enumerated.item[0]) {
+        case 0:
+                gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR);
+                break;
+        case 1:
+                gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR;
+                break;
+        case 2:
+                gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR;
+                break;
+        }
+        oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
+        mutex_unlock(&chip->mutex);
+        return gpio != gpio_old;
+}
+
+static const struct snd_kcontrol_new st_output_switch = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Analog Output",
+        .info = st_output_switch_info,
+        .get = st_output_switch_get,
+        .put = st_output_switch_put,
+};
+
 static void xonar_line_mic_ac97_switch(struct oxygen *chip,
                                        unsigned int reg, unsigned int mute)
 {
@@ -745,8 +903,8 @@ static void xonar_line_mic_ac97_switch(struct oxygen *chip,
         }
 }
 
-static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -12000, 50, 0);
-static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -12700, 100, 0);
+static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0);
+static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -6000, 100, 0);
 
 static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
 {
@@ -763,6 +921,15 @@ static int xonar_d1_control_filter(struct snd_kcontrol_new *template)
         return 0;
 }
 
+static int xonar_st_control_filter(struct snd_kcontrol_new *template)
+{
+        if (!strncmp(template->name, "CD Capture ", 11))
+                return 1; /* no CD input */
+        if (!strcmp(template->name, "Stereo Upmixing"))
+                return 1; /* stereo only - we don't need upmixing */
+        return 0;
+}
+
 static int xonar_d2_mixer_init(struct oxygen *chip)
 {
         return snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
@@ -773,51 +940,14 @@ static int xonar_d1_mixer_init(struct oxygen *chip)
         return snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip));
 }
 
-static int xonar_model_probe(struct oxygen *chip, unsigned long driver_data)
+static int xonar_st_mixer_init(struct oxygen *chip)
 {
-        static const char *const names[] = {
-                [MODEL_D1]      = "Xonar D1",
-                [MODEL_DX]      = "Xonar DX",
-                [MODEL_D2]      = "Xonar D2",
-                [MODEL_D2X]     = "Xonar D2X",
-                [MODEL_HDAV]    = "Xonar HDAV1.3",
-                [MODEL_HDAV_H6] = "Xonar HDAV1.3+H6",
-        };
-        static const u8 dacs[] = {
-                [MODEL_D1]      = 2,
-                [MODEL_DX]      = 2,
-                [MODEL_D2]      = 4,
-                [MODEL_D2X]     = 4,
-                [MODEL_HDAV]    = 1,
-                [MODEL_HDAV_H6] = 4,
-        };
-        struct xonar_data *data = chip->model_data;
-
-        data->model = driver_data;
-        if (data->model == MODEL_HDAV) {
-                oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL,
-                                    GPIO_HDAV_DB_MASK);
-                switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) &
-                        GPIO_HDAV_DB_MASK) {
-                case GPIO_HDAV_DB_H6:
-                        data->model = MODEL_HDAV_H6;
-                        break;
-                case GPIO_HDAV_DB_XX:
-                        snd_printk(KERN_ERR "unknown daughterboard\n");
-                        return -ENODEV;
-                }
-        }
-
-        data->dacs = dacs[data->model];
-        chip->model.shortname = names[data->model];
-        return 0;
+        return snd_ctl_add(chip->card, snd_ctl_new1(&st_output_switch, chip));
 }
 
 static const struct oxygen_model model_xonar_d2 = {
         .longname = "Asus Virtuoso 200",
         .chip = "AV200",
-        .owner = THIS_MODULE,
-        .probe = xonar_model_probe,
         .init = xonar_d2_init,
         .control_filter = xonar_d2_control_filter,
         .mixer_init = xonar_d2_mixer_init,
@@ -837,8 +967,8 @@ static const struct oxygen_model model_xonar_d2 = {
                          MIDI_OUTPUT |
                          MIDI_INPUT,
         .dac_channels = 8,
-        .dac_volume_min = 0x0f,
-        .dac_volume_max = 0xff,
+        .dac_volume_min = 255 - 2*60,
+        .dac_volume_max = 255,
         .misc_flags = OXYGEN_MISC_MIDI,
         .function_flags = OXYGEN_FUNCTION_SPI |
                           OXYGEN_FUNCTION_ENABLE_SPI_4_5,
@@ -849,8 +979,6 @@ static const struct oxygen_model model_xonar_d2 = {
 static const struct oxygen_model model_xonar_d1 = {
         .longname = "Asus Virtuoso 100",
         .chip = "AV200",
-        .owner = THIS_MODULE,
-        .probe = xonar_model_probe,
         .init = xonar_d1_init,
         .control_filter = xonar_d1_control_filter,
         .mixer_init = xonar_d1_mixer_init,
@@ -868,7 +996,7 @@ static const struct oxygen_model model_xonar_d1 = {
                          PLAYBACK_1_TO_SPDIF |
                          CAPTURE_0_FROM_I2S_2,
         .dac_channels = 8,
-        .dac_volume_min = 0,
+        .dac_volume_min = 127 - 60,
         .dac_volume_max = 127,
         .function_flags = OXYGEN_FUNCTION_2WIRE,
         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
@@ -878,8 +1006,6 @@ static const struct oxygen_model model_xonar_d1 = {
 static const struct oxygen_model model_xonar_hdav = {
         .longname = "Asus Virtuoso 200",
         .chip = "AV200",
-        .owner = THIS_MODULE,
-        .probe = xonar_model_probe,
         .init = xonar_hdav_init,
         .cleanup = xonar_hdav_cleanup,
         .suspend = xonar_hdav_suspend,
@@ -897,15 +1023,43 @@ static const struct oxygen_model model_xonar_hdav = {
                          PLAYBACK_1_TO_SPDIF |
                          CAPTURE_0_FROM_I2S_2,
         .dac_channels = 8,
-        .dac_volume_min = 0x0f,
-        .dac_volume_max = 0xff,
+        .dac_volume_min = 255 - 2*60,
+        .dac_volume_max = 255,
+        .misc_flags = OXYGEN_MISC_MIDI,
         .function_flags = OXYGEN_FUNCTION_2WIRE,
         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 };
 
-static int __devinit xonar_probe(struct pci_dev *pci,
-                                 const struct pci_device_id *pci_id)
+static const struct oxygen_model model_xonar_st = {
+        .longname = "Asus Virtuoso 100",
+        .chip = "AV200",
+        .init = xonar_stx_init,
+        .control_filter = xonar_st_control_filter,
+        .mixer_init = xonar_st_mixer_init,
+        .cleanup = xonar_st_cleanup,
+        .suspend = xonar_st_suspend,
+        .resume = xonar_st_resume,
+        .set_dac_params = set_pcm1796_params,
+        .set_adc_params = set_cs53x1_params,
+        .update_dac_volume = update_pcm1796_volume,
+        .update_dac_mute = update_pcm1796_mute,
+        .ac97_switch = xonar_line_mic_ac97_switch,
+        .dac_tlv = pcm1796_db_scale,
+        .model_data_size = sizeof(struct xonar_data),
+        .device_config = PLAYBACK_0_TO_I2S |
+                         PLAYBACK_1_TO_SPDIF |
+                         CAPTURE_0_FROM_I2S_2,
+        .dac_channels = 2,
+        .dac_volume_min = 255 - 2*60,
+        .dac_volume_max = 255,
+        .function_flags = OXYGEN_FUNCTION_2WIRE,
+        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+};
+
+static int __devinit get_xonar_model(struct oxygen *chip,
+                                     const struct pci_device_id *id)
 {
         static const struct oxygen_model *const models[] = {
                 [MODEL_D1]      = &model_xonar_d1,
@@ -913,7 +1067,57 @@ static int __devinit xonar_probe(struct pci_dev *pci,
                 [MODEL_D2]      = &model_xonar_d2,
                 [MODEL_D2X]     = &model_xonar_d2,
                 [MODEL_HDAV]    = &model_xonar_hdav,
+                [MODEL_STX]     = &model_xonar_st,
         };
+        static const char *const names[] = {
+                [MODEL_D1]      = "Xonar D1",
+                [MODEL_DX]      = "Xonar DX",
+                [MODEL_D2]      = "Xonar D2",
+                [MODEL_D2X]     = "Xonar D2X",
+                [MODEL_HDAV]    = "Xonar HDAV1.3",
+                [MODEL_HDAV_H6] = "Xonar HDAV1.3+H6",
+                [MODEL_STX]     = "Xonar Essence STX",
+        };
+        unsigned int model = id->driver_data;
+
+        if (model >= ARRAY_SIZE(models) || !models[model])
+                return -EINVAL;
+        chip->model = *models[model];
+
+        switch (model) {
+        case MODEL_D2X:
+                chip->model.init = xonar_d2x_init;
+                break;
+        case MODEL_DX:
+                chip->model.init = xonar_dx_init;
+                break;
+        case MODEL_HDAV:
+                oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL,
+                                    GPIO_HDAV_DB_MASK);
+                switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) &
+                        GPIO_HDAV_DB_MASK) {
+                case GPIO_HDAV_DB_H6:
+                        model = MODEL_HDAV_H6;
+                        break;
+                case GPIO_HDAV_DB_XX:
+                        snd_printk(KERN_ERR "unknown daughterboard\n");
+                        return -ENODEV;
+                }
+                break;
+        case MODEL_STX:
+                oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL,
+                                    GPIO_HDAV_DB_MASK);
+                break;
+        }
+
+        chip->model.shortname = names[model];
+        chip->model.private_data = model;
+        return 0;
+}
+
+static int __devinit xonar_probe(struct pci_dev *pci,
+                                 const struct pci_device_id *pci_id)
+{
         static int dev;
         int err;
 
@@ -923,10 +1127,8 @@ static int __devinit xonar_probe(struct pci_dev *pci,
                 ++dev;
                 return -ENOENT;
         }
-        BUG_ON(pci_id->driver_data >= ARRAY_SIZE(models));
-        err = oxygen_pci_probe(pci, index[dev], id[dev],
-                               models[pci_id->driver_data],
-                               pci_id->driver_data);
+        err = oxygen_pci_probe(pci, index[dev], id[dev], THIS_MODULE,
+                               xonar_ids, get_xonar_model);
         if (err >= 0)
                 ++dev;
         return err;
diff --git a/sound/pci/pcxhr/pcxhr.c b/sound/pci/pcxhr/pcxhr.c
index 7f95459c8b1f..833e9c7b27c7 100644
--- a/sound/pci/pcxhr/pcxhr.c
+++ b/sound/pci/pcxhr/pcxhr.c
@@ -1334,6 +1334,40 @@ static void pcxhr_proc_sync(struct snd_info_entry *entry,
         snd_iprintf(buffer, "\n");
 }
 
+static void pcxhr_proc_gpio_read(struct snd_info_entry *entry,
+                                 struct snd_info_buffer *buffer)
+{
+        struct snd_pcxhr *chip = entry->private_data;
+        struct pcxhr_mgr *mgr = chip->mgr;
+        /* commands available when embedded DSP is running */
+        if (mgr->dsp_loaded & (1 << PCXHR_FIRMWARE_DSP_MAIN_INDEX)) {
+                /* gpio ports on stereo boards only available */
+                int value = 0;
+                hr222_read_gpio(mgr, 1, &value);        /* GPI */
+                snd_iprintf(buffer, "GPI: 0x%x\n", value);
+                hr222_read_gpio(mgr, 0, &value);        /* GP0 */
+                snd_iprintf(buffer, "GPO: 0x%x\n", value);
+        } else
+                snd_iprintf(buffer, "no firmware loaded\n");
+        snd_iprintf(buffer, "\n");
+}
+static void pcxhr_proc_gpo_write(struct snd_info_entry *entry,
+                                 struct snd_info_buffer *buffer)
+{
+        struct snd_pcxhr *chip = entry->private_data;
+        struct pcxhr_mgr *mgr = chip->mgr;
+        char line[64];
+        int value;
+        /* commands available when embedded DSP is running */
+        if (!(mgr->dsp_loaded & (1 << PCXHR_FIRMWARE_DSP_MAIN_INDEX)))
+                return;
+        while (!snd_info_get_line(buffer, line, sizeof(line))) {
+                if (sscanf(line, "GPO: 0x%x", &value) != 1)
+                        continue;
+                hr222_write_gpo(mgr, value);    /* GP0 */
+        }
+}
+
 static void __devinit pcxhr_proc_init(struct snd_pcxhr *chip)
 {
         struct snd_info_entry *entry;
@@ -1342,6 +1376,13 @@ static void __devinit pcxhr_proc_init(struct snd_pcxhr *chip)
                 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, pcxhr_proc_sync);
+        /* gpio available on stereo sound cards only */
+        if (chip->mgr->is_hr_stereo &&
+            !snd_card_proc_new(chip->card, "gpio", &entry)) {
+                snd_info_set_text_ops(entry, chip, pcxhr_proc_gpio_read);
+                entry->c.text.write = pcxhr_proc_gpo_write;
+                entry->mode |= S_IWUSR;
+        }
 }
 /* end of proc interface */
 
@@ -1408,7 +1449,7 @@ static int __devinit pcxhr_probe(struct pci_dev *pci,
         pci_set_master(pci);
 
         /* check if we can restrict PCI DMA transfers to 32 bits */
-        if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support "
                            "32bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
diff --git a/sound/pci/pcxhr/pcxhr.h b/sound/pci/pcxhr/pcxhr.h
index 84131a916c92..bda776c49884 100644
--- a/sound/pci/pcxhr/pcxhr.h
+++ b/sound/pci/pcxhr/pcxhr.h
@@ -27,8 +27,8 @@
 #include <linux/mutex.h>
 #include <sound/pcm.h>
 
-#define PCXHR_DRIVER_VERSION            0x000905        /* 0.9.5 */
-#define PCXHR_DRIVER_VERSION_STRING     "0.9.5"         /* 0.9.5 */
+#define PCXHR_DRIVER_VERSION            0x000906        /* 0.9.6 */
+#define PCXHR_DRIVER_VERSION_STRING     "0.9.6"         /* 0.9.6 */
 
 
 #define PCXHR_MAX_CARDS         6
@@ -97,12 +97,12 @@ struct pcxhr_mgr {
         int capture_chips;
         int fw_file_set;
         int firmware_num;
-        int is_hr_stereo:1;
-        int board_has_aes1:1;   /* if 1 board has AES1 plug and SRC */
-        int board_has_analog:1; /* if 0 the board is digital only */
-        int board_has_mic:1;    /* if 1 the board has microphone input */
-        int board_aes_in_192k:1;/* if 1 the aes input plugs do support 192kHz */
-        int mono_capture:1;     /* if 1 the board does mono capture */
+        unsigned int is_hr_stereo:1;
+        unsigned int board_has_aes1:1;  /* if 1 board has AES1 plug and SRC */
+        unsigned int board_has_analog:1; /* if 0 the board is digital only */
+        unsigned int board_has_mic:1; /* if 1 the board has microphone input */
+        unsigned int board_aes_in_192k:1;/* if 1 the aes input plugs do support 192kHz */
+        unsigned int mono_capture:1; /* if 1 the board does mono capture */
 
         struct snd_dma_buffer hostport;
 
@@ -124,6 +124,7 @@ struct pcxhr_mgr {
 
         unsigned char xlx_cfg;          /* copy of PCXHR_XLX_CFG register */
         unsigned char xlx_selmic;       /* copy of PCXHR_XLX_SELMIC register */
+        unsigned char dsp_reset;        /* copy of PCXHR_DSP_RESET register */
 };
 
 
diff --git a/sound/pci/pcxhr/pcxhr_core.h b/sound/pci/pcxhr/pcxhr_core.h
index bbbd66d13a64..be0173796cdb 100644
--- a/sound/pci/pcxhr/pcxhr_core.h
+++ b/sound/pci/pcxhr/pcxhr_core.h
@@ -1,7 +1,7 @@
 /*
  * Driver for Digigram pcxhr compatible soundcards
  *
- * low level interface with interrupt ans message handling
+ * low level interface with interrupt and message handling
  *
  * Copyright (c) 2004 by Digigram <alsa@digigram.com>
  *
diff --git a/sound/pci/pcxhr/pcxhr_hwdep.c b/sound/pci/pcxhr/pcxhr_hwdep.c
index 592743a298b0..17cb1233a903 100644
--- a/sound/pci/pcxhr/pcxhr_hwdep.c
+++ b/sound/pci/pcxhr/pcxhr_hwdep.c
@@ -471,16 +471,6 @@ static int pcxhr_hwdep_dsp_load(struct snd_hwdep *hw,
         return 0;
 }
 
-static int pcxhr_hwdep_open(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
-static int pcxhr_hwdep_release(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
 int pcxhr_setup_firmware(struct pcxhr_mgr *mgr)
 {
         int err;
@@ -495,8 +485,6 @@ int pcxhr_setup_firmware(struct pcxhr_mgr *mgr)
 
         hw->iface = SNDRV_HWDEP_IFACE_PCXHR;
         hw->private_data = mgr;
-        hw->ops.open = pcxhr_hwdep_open;
-        hw->ops.release = pcxhr_hwdep_release;
         hw->ops.dsp_status = pcxhr_hwdep_dsp_status;
         hw->ops.dsp_load = pcxhr_hwdep_dsp_load;
         hw->exclusive = 1;
diff --git a/sound/pci/pcxhr/pcxhr_mix22.c b/sound/pci/pcxhr/pcxhr_mix22.c
index ff019126b672..1cb82c0a9cb3 100644
--- a/sound/pci/pcxhr/pcxhr_mix22.c
+++ b/sound/pci/pcxhr/pcxhr_mix22.c
@@ -53,6 +53,8 @@
 #define PCXHR_DSP_RESET_DSP     0x01
 #define PCXHR_DSP_RESET_MUTE    0x02
 #define PCXHR_DSP_RESET_CODEC   0x08
+#define PCXHR_DSP_RESET_GPO_OFFSET      5
+#define PCXHR_DSP_RESET_GPO_MASK        0x60
 
 /* values for PCHR_XLX_CFG register */
 #define PCXHR_CFG_SYNCDSP_MASK          0x80
@@ -81,6 +83,8 @@
 /* values for PCHR_XLX_STATUS register - READ */
 #define PCXHR_STAT_SRC_LOCK             0x01
 #define PCXHR_STAT_LEVEL_IN             0x02
+#define PCXHR_STAT_GPI_OFFSET           2
+#define PCXHR_STAT_GPI_MASK             0x0C
 #define PCXHR_STAT_MIC_CAPS             0x10
 /* values for PCHR_XLX_STATUS register - WRITE */
 #define PCXHR_STAT_FREQ_SYNC_MASK       0x01
@@ -291,10 +295,11 @@ int hr222_sub_init(struct pcxhr_mgr *mgr)
         PCXHR_OUTPB(mgr, PCXHR_DSP_RESET,
                     PCXHR_DSP_RESET_DSP);
         msleep(5);
-        PCXHR_OUTPB(mgr, PCXHR_DSP_RESET,
-                    PCXHR_DSP_RESET_DSP  |
-                    PCXHR_DSP_RESET_MUTE |
-                    PCXHR_DSP_RESET_CODEC);
+        mgr->dsp_reset = PCXHR_DSP_RESET_DSP  |
+                         PCXHR_DSP_RESET_MUTE |
+                         PCXHR_DSP_RESET_CODEC;
+        PCXHR_OUTPB(mgr, PCXHR_DSP_RESET, mgr->dsp_reset);
+        /* hr222_write_gpo(mgr, 0); does the same */
         msleep(5);
 
         /* config AKM */
@@ -496,6 +501,33 @@ int hr222_get_external_clock(struct pcxhr_mgr *mgr,
 }
 
 
+int hr222_read_gpio(struct pcxhr_mgr *mgr, int is_gpi, int *value)
+{
+        if (is_gpi) {
+                unsigned char reg = PCXHR_INPB(mgr, PCXHR_XLX_STATUS);
+                *value = (int)(reg & PCXHR_STAT_GPI_MASK) >>
+                              PCXHR_STAT_GPI_OFFSET;
+        } else {
+                *value = (int)(mgr->dsp_reset & PCXHR_DSP_RESET_GPO_MASK) >>
+                         PCXHR_DSP_RESET_GPO_OFFSET;
+        }
+        return 0;
+}
+
+
+int hr222_write_gpo(struct pcxhr_mgr *mgr, int value)
+{
+        unsigned char reg = mgr->dsp_reset & ~PCXHR_DSP_RESET_GPO_MASK;
+
+        reg |= (unsigned char)(value << PCXHR_DSP_RESET_GPO_OFFSET) &
+               PCXHR_DSP_RESET_GPO_MASK;
+
+        PCXHR_OUTPB(mgr, PCXHR_DSP_RESET, reg);
+        mgr->dsp_reset = reg;
+        return 0;
+}
+
+
 int hr222_update_analog_audio_level(struct snd_pcxhr *chip,
                                     int is_capture, int channel)
 {
diff --git a/sound/pci/pcxhr/pcxhr_mix22.h b/sound/pci/pcxhr/pcxhr_mix22.h
index 6b318b2f0100..5a37a0007e8f 100644
--- a/sound/pci/pcxhr/pcxhr_mix22.h
+++ b/sound/pci/pcxhr/pcxhr_mix22.h
@@ -32,6 +32,9 @@ int hr222_get_external_clock(struct pcxhr_mgr *mgr,
                              enum pcxhr_clock_type clock_type,
                              int *sample_rate);
 
+int hr222_read_gpio(struct pcxhr_mgr *mgr, int is_gpi, int *value);
+int hr222_write_gpo(struct pcxhr_mgr *mgr, int value);
+
 #define HR222_LINE_PLAYBACK_LEVEL_MIN           0       /* -25.5 dB */
 #define HR222_LINE_PLAYBACK_ZERO_LEVEL          51      /* 0.0 dB */
 #define HR222_LINE_PLAYBACK_LEVEL_MAX           99      /* +24.0 dB */
diff --git a/sound/pci/pcxhr/pcxhr_mixer.c b/sound/pci/pcxhr/pcxhr_mixer.c
index 2436e374586f..fec049344621 100644
--- a/sound/pci/pcxhr/pcxhr_mixer.c
+++ b/sound/pci/pcxhr/pcxhr_mixer.c
@@ -789,11 +789,15 @@ static int pcxhr_clock_type_put(struct snd_kcontrol *kcontrol,
         if (mgr->use_clock_type != ucontrol->value.enumerated.item[0]) {
                 mutex_lock(&mgr->setup_mutex);
                 mgr->use_clock_type = ucontrol->value.enumerated.item[0];
-                if (mgr->use_clock_type)
+                rate = 0;
+                if (mgr->use_clock_type != PCXHR_CLOCK_TYPE_INTERNAL) {
                         pcxhr_get_external_clock(mgr, mgr->use_clock_type,
                                                  &rate);
-                else
+                } else {
                         rate = mgr->sample_rate;
+                        if (!rate)
+                                rate = 48000;
+                }
                 if (rate) {
                         pcxhr_set_clock(mgr, rate);
                         if (mgr->sample_rate)
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index 05b3f795a168..314e73531bd1 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -113,7 +113,7 @@ MODULE_FIRMWARE("digiface_firmware_rev11.bin");
 
 /* the meters are regular i/o-mapped registers, but offset
    considerably from the rest. the peak registers are reset
-   when read; the least-significant 4 bits are full-scale counters; 
+   when read; the least-significant 4 bits are full-scale counters;
    the actual peak value is in the most-significant 24 bits.
 */
 
@@ -131,7 +131,7 @@ MODULE_FIRMWARE("digiface_firmware_rev11.bin");
    26*3 values are read in ss mode
    14*3 in ds mode, with no gap between values
 */
-#define HDSP_9652_peakBase      7164    
+#define HDSP_9652_peakBase      7164
 #define HDSP_9652_rmsBase       4096
 
 /* c.f. the hdsp_9632_meters_t struct */
@@ -173,12 +173,12 @@ MODULE_FIRMWARE("digiface_firmware_rev11.bin");
 #define HDSP_SPDIFEmphasis        (1<<10) /* 0=none, 1=on */
 #define HDSP_SPDIFNonAudio        (1<<11) /* 0=off, 1=on */
 #define HDSP_SPDIFOpticalOut      (1<<12) /* 1=use 1st ADAT connector for SPDIF, 0=do not */
-#define HDSP_SyncRef2             (1<<13) 
-#define HDSP_SPDIFInputSelect0    (1<<14) 
-#define HDSP_SPDIFInputSelect1    (1<<15) 
-#define HDSP_SyncRef0             (1<<16) 
+#define HDSP_SyncRef2             (1<<13)
+#define HDSP_SPDIFInputSelect0    (1<<14)
+#define HDSP_SPDIFInputSelect1    (1<<15)
+#define HDSP_SyncRef0             (1<<16)
 #define HDSP_SyncRef1             (1<<17)
-#define HDSP_AnalogExtensionBoard (1<<18) /* For H9632 cards */ 
+#define HDSP_AnalogExtensionBoard (1<<18) /* For H9632 cards */
 #define HDSP_XLRBreakoutCable     (1<<20) /* For H9632 cards */
 #define HDSP_Midi0InterruptEnable (1<<22)
 #define HDSP_Midi1InterruptEnable (1<<23)
@@ -314,7 +314,7 @@ MODULE_FIRMWARE("digiface_firmware_rev11.bin");
 #define HDSP_TimecodeSync       (1<<27)
 #define HDSP_AEBO               (1<<28) /* H9632 specific Analog Extension Boards */
 #define HDSP_AEBI               (1<<29) /* 0 = present, 1 = absent */
-#define HDSP_midi0IRQPending    (1<<30) 
+#define HDSP_midi0IRQPending    (1<<30)
 #define HDSP_midi1IRQPending    (1<<31)
 
 #define HDSP_spdifFrequencyMask    (HDSP_spdifFrequency0|HDSP_spdifFrequency1|HDSP_spdifFrequency2)
@@ -391,7 +391,7 @@ MODULE_FIRMWARE("digiface_firmware_rev11.bin");
 #define HDSP_CHANNEL_BUFFER_BYTES    (4*HDSP_CHANNEL_BUFFER_SAMPLES)
 
 /* the size of the area we need to allocate for DMA transfers. the
-   size is the same regardless of the number of channels - the 
+   size is the same regardless of the number of channels - the
    Multiface still uses the same memory area.
 
    Note that we allocate 1 more channel than is apparently needed
@@ -460,7 +460,7 @@ struct hdsp {
         unsigned char         qs_in_channels;        /* quad speed mode for H9632 */
         unsigned char         ds_in_channels;
         unsigned char         ss_in_channels;       /* different for multiface/digiface */
-        unsigned char         qs_out_channels;      
+        unsigned char         qs_out_channels;
         unsigned char         ds_out_channels;
         unsigned char         ss_out_channels;
 
@@ -502,9 +502,9 @@ static char channel_map_df_ss[HDSP_MAX_CHANNELS] = {
 
 static char channel_map_mf_ss[HDSP_MAX_CHANNELS] = { /* Multiface */
         /* Analog */
-        0, 1, 2, 3, 4, 5, 6, 7, 
+        0, 1, 2, 3, 4, 5, 6, 7,
         /* ADAT 2 */
-        16, 17, 18, 19, 20, 21, 22, 23, 
+        16, 17, 18, 19, 20, 21, 22, 23,
         /* SPDIF */
         24, 25,
         -1, -1, -1, -1, -1, -1, -1, -1
@@ -525,11 +525,11 @@ static char channel_map_H9632_ss[HDSP_MAX_CHANNELS] = {
         /* SPDIF */
         8, 9,
         /* Analog */
-        10, 11, 
+        10, 11,
         /* AO4S-192 and AI4S-192 extension boards */
         12, 13, 14, 15,
         /* others don't exist */
-        -1, -1, -1, -1, -1, -1, -1, -1, 
+        -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1
 };
 
@@ -539,7 +539,7 @@ static char channel_map_H9632_ds[HDSP_MAX_CHANNELS] = {
         /* SPDIF */
         8, 9,
         /* Analog */
-        10, 11, 
+        10, 11,
         /* AO4S-192 and AI4S-192 extension boards */
         12, 13, 14, 15,
         /* others don't exist */
@@ -587,7 +587,7 @@ static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_d
 static struct pci_device_id snd_hdsp_ids[] = {
         {
                 .vendor = PCI_VENDOR_ID_XILINX,
-                .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP, 
+                .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP,
                 .subvendor = PCI_ANY_ID,
                 .subdevice = PCI_ANY_ID,
         }, /* RME Hammerfall-DSP */
@@ -653,7 +653,6 @@ static unsigned int hdsp_read(struct hdsp *hdsp, int reg)
 
 static int hdsp_check_for_iobox (struct hdsp *hdsp)
 {
-
         if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return 0;
         if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_ConfigError) {
                 snd_printk ("Hammerfall-DSP: no Digiface or Multiface connected!\n");
@@ -661,7 +660,29 @@ static int hdsp_check_for_iobox (struct hdsp *hdsp)
                 return -EIO;
         }
         return 0;
+}
 
+static int hdsp_wait_for_iobox(struct hdsp *hdsp, unsigned int loops,
+                               unsigned int delay)
+{
+        unsigned int i;
+
+        if (hdsp->io_type == H9652 || hdsp->io_type == H9632)
+                return 0;
+
+        for (i = 0; i != loops; ++i) {
+                if (hdsp_read(hdsp, HDSP_statusRegister) & HDSP_ConfigError)
+                        msleep(delay);
+                else {
+                        snd_printd("Hammerfall-DSP: iobox found after %ums!\n",
+                                   i * delay);
+                        return 0;
+                }
+        }
+
+        snd_printk("Hammerfall-DSP: no Digiface or Multiface connected!\n");
+        hdsp->state &= ~HDSP_FirmwareLoaded;
+        return -EIO;
 }
 
 static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) {
@@ -670,19 +691,19 @@ static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) {
         unsigned long flags;
 
         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
-                
+
                 snd_printk ("Hammerfall-DSP: loading firmware\n");
 
                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_PROGRAM);
                 hdsp_write (hdsp, HDSP_fifoData, 0);
-                
+
                 if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
                         snd_printk ("Hammerfall-DSP: timeout waiting for download preparation\n");
                         return -EIO;
                 }
-                
+
                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_S_LOAD);
-                
+
                 for (i = 0; i < 24413; ++i) {
                         hdsp_write(hdsp, HDSP_fifoData, hdsp->firmware_cache[i]);
                         if (hdsp_fifo_wait (hdsp, 127, HDSP_LONG_WAIT)) {
@@ -692,7 +713,7 @@ static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) {
                 }
 
                 ssleep(3);
-                
+
                 if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
                         snd_printk ("Hammerfall-DSP: timeout at end of firmware loading\n");
                         return -EIO;
@@ -705,15 +726,15 @@ static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) {
 #endif
                 hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
                 snd_printk ("Hammerfall-DSP: finished firmware loading\n");
-                
+
         }
         if (hdsp->state & HDSP_InitializationComplete) {
                 snd_printk(KERN_INFO "Hammerfall-DSP: firmware loaded from cache, restoring defaults\n");
                 spin_lock_irqsave(&hdsp->lock, flags);
                 snd_hdsp_set_defaults(hdsp);
-                spin_unlock_irqrestore(&hdsp->lock, flags); 
+                spin_unlock_irqrestore(&hdsp->lock, flags);
         }
-        
+
         hdsp->state |= HDSP_FirmwareLoaded;
 
         return 0;
@@ -722,7 +743,7 @@ static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) {
 static int hdsp_get_iobox_version (struct hdsp *hdsp)
 {
         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
-        
+
                 hdsp_write (hdsp, HDSP_control2Reg, HDSP_PROGRAM);
                 hdsp_write (hdsp, HDSP_fifoData, 0);
                 if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT) < 0)
@@ -738,7 +759,7 @@ static int hdsp_get_iobox_version (struct hdsp *hdsp)
                         hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT);
                 } else {
                         hdsp->io_type = Digiface;
-                } 
+                }
         } else {
                 /* firmware was already loaded, get iobox type */
                 if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1)
@@ -786,13 +807,13 @@ static int hdsp_check_for_firmware (struct hdsp *hdsp, int load_on_demand)
 
 
 static int hdsp_fifo_wait(struct hdsp *hdsp, int count, int timeout)
-{    
+{
         int i;
 
         /* the fifoStatus registers reports on how many words
            are available in the command FIFO.
         */
-        
+
         for (i = 0; i < timeout; i++) {
 
                 if ((int)(hdsp_read (hdsp, HDSP_fifoStatus) & 0xff) <= count)
@@ -824,11 +845,11 @@ static int hdsp_write_gain(struct hdsp *hdsp, unsigned int addr, unsigned short
 
         if (addr >= HDSP_MATRIX_MIXER_SIZE)
                 return -1;
-        
+
         if (hdsp->io_type == H9652 || hdsp->io_type == H9632) {
 
                 /* from martin bjornsen:
-                   
+
                    "You can only write dwords to the
                    mixer memory which contain two
                    mixer values in the low and high
@@ -847,7 +868,7 @@ static int hdsp_write_gain(struct hdsp *hdsp, unsigned int addr, unsigned short
 
                 hdsp->mixer_matrix[addr] = data;
 
-                
+
                 /* `addr' addresses a 16-bit wide address, but
                    the address space accessed via hdsp_write
                    uses byte offsets. put another way, addr
@@ -856,17 +877,17 @@ static int hdsp_write_gain(struct hdsp *hdsp, unsigned int addr, unsigned short
                    to access 0 to 2703 ...
                 */
                 ad = addr/2;
-        
-                hdsp_write (hdsp, 4096 + (ad*4), 
-                            (hdsp->mixer_matrix[(addr&0x7fe)+1] << 16) + 
+
+                hdsp_write (hdsp, 4096 + (ad*4),
+                            (hdsp->mixer_matrix[(addr&0x7fe)+1] << 16) +
                             hdsp->mixer_matrix[addr&0x7fe]);
-                
+
                 return 0;
 
         } else {
 
                 ad = (addr << 16) + data;
-                
+
                 if (hdsp_fifo_wait(hdsp, 127, HDSP_LONG_WAIT))
                         return -1;
 
@@ -902,7 +923,7 @@ static int hdsp_spdif_sample_rate(struct hdsp *hdsp)
 
         if (status & HDSP_SPDIFErrorFlag)
                 return 0;
-        
+
         switch (rate_bits) {
         case HDSP_spdifFrequency32KHz: return 32000;
         case HDSP_spdifFrequency44_1KHz: return 44100;
@@ -910,13 +931,13 @@ static int hdsp_spdif_sample_rate(struct hdsp *hdsp)
         case HDSP_spdifFrequency64KHz: return 64000;
         case HDSP_spdifFrequency88_2KHz: return 88200;
         case HDSP_spdifFrequency96KHz: return 96000;
-        case HDSP_spdifFrequency128KHz: 
+        case HDSP_spdifFrequency128KHz:
                 if (hdsp->io_type == H9632) return 128000;
                 break;
-        case HDSP_spdifFrequency176_4KHz: 
+        case HDSP_spdifFrequency176_4KHz:
                 if (hdsp->io_type == H9632) return 176400;
                 break;
-        case HDSP_spdifFrequency192KHz: 
+        case HDSP_spdifFrequency192KHz:
                 if (hdsp->io_type == H9632) return 192000;
                 break;
         default:
@@ -1027,7 +1048,7 @@ static void hdsp_set_dds_value(struct hdsp *hdsp, int rate)
 {
         u64 n;
         u32 r;
-        
+
         if (rate >= 112000)
                 rate /= 4;
         else if (rate >= 56000)
@@ -1053,35 +1074,35 @@ static int hdsp_set_rate(struct hdsp *hdsp, int rate, int called_internally)
            there is no need for it (e.g. during module
            initialization).
         */
-        
-        if (!(hdsp->control_register & HDSP_ClockModeMaster)) { 
+
+        if (!(hdsp->control_register & HDSP_ClockModeMaster)) {
                 if (called_internally) {
                         /* request from ctl or card initialization */
                         snd_printk(KERN_ERR "Hammerfall-DSP: device is not running as a clock master: cannot set sample rate.\n");
                         return -1;
-                } else {                
+                } else {
                         /* hw_param request while in AutoSync mode */
                         int external_freq = hdsp_external_sample_rate(hdsp);
                         int spdif_freq = hdsp_spdif_sample_rate(hdsp);
-                
+
                         if ((spdif_freq == external_freq*2) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1))
                                 snd_printk(KERN_INFO "Hammerfall-DSP: Detected ADAT in double speed mode\n");
                         else if (hdsp->io_type == H9632 && (spdif_freq == external_freq*4) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1))
-                                snd_printk(KERN_INFO "Hammerfall-DSP: Detected ADAT in quad speed mode\n");                     
+                                snd_printk(KERN_INFO "Hammerfall-DSP: Detected ADAT in quad speed mode\n");
                         else if (rate != external_freq) {
                                 snd_printk(KERN_INFO "Hammerfall-DSP: No AutoSync source for requested rate\n");
                                 return -1;
-                        }               
-                }       
+                        }
+                }
         }
 
         current_rate = hdsp->system_sample_rate;
 
         /* Changing from a "single speed" to a "double speed" rate is
            not allowed if any substreams are open. This is because
-           such a change causes a shift in the location of 
+           such a change causes a shift in the location of
            the DMA buffers and a reduction in the number of available
-           buffers. 
+           buffers.
 
            Note that a similar but essentially insoluble problem
            exists for externally-driven rate changes. All we can do
@@ -1089,7 +1110,7 @@ static int hdsp_set_rate(struct hdsp *hdsp, int rate, int called_internally)
 
         if (rate > 96000 && hdsp->io_type != H9632)
                 return -EINVAL;
-        
+
         switch (rate) {
         case 32000:
                 if (current_rate > 48000)
@@ -1179,7 +1200,7 @@ static int hdsp_set_rate(struct hdsp *hdsp, int rate, int called_internally)
                         break;
                 }
         }
-        
+
         hdsp->system_sample_rate = rate;
 
         return 0;
@@ -1245,16 +1266,16 @@ static int snd_hdsp_midi_output_write (struct hdsp_midi *hmidi)
         unsigned char buf[128];
 
         /* Output is not interrupt driven */
-                
+
         spin_lock_irqsave (&hmidi->lock, flags);
         if (hmidi->output) {
                 if (!snd_rawmidi_transmit_empty (hmidi->output)) {
                         if ((n_pending = snd_hdsp_midi_output_possible (hmidi->hdsp, hmidi->id)) > 0) {
                                 if (n_pending > (int)sizeof (buf))
                                         n_pending = sizeof (buf);
-                                
+
                                 if ((to_write = snd_rawmidi_transmit (hmidi->output, buf, n_pending)) > 0) {
-                                        for (i = 0; i < to_write; ++i) 
+                                        for (i = 0; i < to_write; ++i)
                                                 snd_hdsp_midi_write_byte (hmidi->hdsp, hmidi->id, buf[i]);
                                 }
                         }
@@ -1325,14 +1346,14 @@ static void snd_hdsp_midi_output_timer(unsigned long data)
 {
         struct hdsp_midi *hmidi = (struct hdsp_midi *) data;
         unsigned long flags;
-        
+
         snd_hdsp_midi_output_write(hmidi);
         spin_lock_irqsave (&hmidi->lock, flags);
 
         /* this does not bump hmidi->istimer, because the
            kernel automatically removed the timer when it
            expired, and we are now adding it back, thus
-           leaving istimer wherever it was set before.  
+           leaving istimer wherever it was set before.
         */
 
         if (hmidi->istimer) {
@@ -1501,7 +1522,7 @@ static int snd_hdsp_control_spdif_info(struct snd_kcontrol *kcontrol, struct snd
 static int snd_hdsp_control_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         snd_hdsp_convert_to_aes(&ucontrol->value.iec958, hdsp->creg_spdif);
         return 0;
 }
@@ -1511,7 +1532,7 @@ static int snd_hdsp_control_spdif_put(struct snd_kcontrol *kcontrol, struct snd_
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         u32 val;
-        
+
         val = snd_hdsp_convert_from_aes(&ucontrol->value.iec958);
         spin_lock_irq(&hdsp->lock);
         change = val != hdsp->creg_spdif;
@@ -1530,7 +1551,7 @@ static int snd_hdsp_control_spdif_stream_info(struct snd_kcontrol *kcontrol, str
 static int snd_hdsp_control_spdif_stream_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         snd_hdsp_convert_to_aes(&ucontrol->value.iec958, hdsp->creg_spdif_stream);
         return 0;
 }
@@ -1540,7 +1561,7 @@ static int snd_hdsp_control_spdif_stream_put(struct snd_kcontrol *kcontrol, stru
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         u32 val;
-        
+
         val = snd_hdsp_convert_from_aes(&ucontrol->value.iec958);
         spin_lock_irq(&hdsp->lock);
         change = val != hdsp->creg_spdif_stream;
@@ -1602,7 +1623,7 @@ static int snd_hdsp_info_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_
 static int snd_hdsp_get_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_spdif_in(hdsp);
         return 0;
 }
@@ -1612,7 +1633,7 @@ static int snd_hdsp_put_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         unsigned int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.enumerated.item[0] % ((hdsp->io_type == H9632) ? 4 : 3);
@@ -1649,7 +1670,7 @@ static int hdsp_set_spdif_output(struct hdsp *hdsp, int out)
 static int snd_hdsp_get_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.integer.value[0] = hdsp_spdif_out(hdsp);
         return 0;
 }
@@ -1659,7 +1680,7 @@ static int snd_hdsp_put_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         unsigned int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.integer.value[0] & 1;
@@ -1693,7 +1714,7 @@ static int hdsp_set_spdif_professional(struct hdsp *hdsp, int val)
 static int snd_hdsp_get_spdif_professional(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.integer.value[0] = hdsp_spdif_professional(hdsp);
         return 0;
 }
@@ -1703,7 +1724,7 @@ static int snd_hdsp_put_spdif_professional(struct snd_kcontrol *kcontrol, struct
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         unsigned int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.integer.value[0] & 1;
@@ -1737,7 +1758,7 @@ static int hdsp_set_spdif_emphasis(struct hdsp *hdsp, int val)
 static int snd_hdsp_get_spdif_emphasis(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.integer.value[0] = hdsp_spdif_emphasis(hdsp);
         return 0;
 }
@@ -1747,7 +1768,7 @@ static int snd_hdsp_put_spdif_emphasis(struct snd_kcontrol *kcontrol, struct snd
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         unsigned int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.integer.value[0] & 1;
@@ -1781,7 +1802,7 @@ static int hdsp_set_spdif_nonaudio(struct hdsp *hdsp, int val)
 static int snd_hdsp_get_spdif_nonaudio(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.integer.value[0] = hdsp_spdif_nonaudio(hdsp);
         return 0;
 }
@@ -1791,7 +1812,7 @@ static int snd_hdsp_put_spdif_nonaudio(struct snd_kcontrol *kcontrol, struct snd
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         unsigned int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.integer.value[0] & 1;
@@ -1828,7 +1849,7 @@ static int snd_hdsp_info_spdif_sample_rate(struct snd_kcontrol *kcontrol, struct
 static int snd_hdsp_get_spdif_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         switch (hdsp_spdif_sample_rate(hdsp)) {
         case 32000:
                 ucontrol->value.enumerated.item[0] = 0;
@@ -1858,7 +1879,7 @@ static int snd_hdsp_get_spdif_sample_rate(struct snd_kcontrol *kcontrol, struct
                 ucontrol->value.enumerated.item[0] = 9;
                 break;
         default:
-                ucontrol->value.enumerated.item[0] = 6;         
+                ucontrol->value.enumerated.item[0] = 6;
         }
         return 0;
 }
@@ -1882,7 +1903,7 @@ static int snd_hdsp_info_system_sample_rate(struct snd_kcontrol *kcontrol, struc
 static int snd_hdsp_get_system_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp->system_sample_rate;
         return 0;
 }
@@ -1899,7 +1920,7 @@ static int snd_hdsp_get_system_sample_rate(struct snd_kcontrol *kcontrol, struct
 static int snd_hdsp_info_autosync_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"};    
+        static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"};
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
         uinfo->value.enumerated.items = (hdsp->io_type == H9632) ? 10 : 7 ;
@@ -1912,7 +1933,7 @@ static int snd_hdsp_info_autosync_sample_rate(struct snd_kcontrol *kcontrol, str
 static int snd_hdsp_get_autosync_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         switch (hdsp_external_sample_rate(hdsp)) {
         case 32000:
                 ucontrol->value.enumerated.item[0] = 0;
@@ -1940,9 +1961,9 @@ static int snd_hdsp_get_autosync_sample_rate(struct snd_kcontrol *kcontrol, stru
                 break;
         case 192000:
                 ucontrol->value.enumerated.item[0] = 9;
-                break;  
+                break;
         default:
-                ucontrol->value.enumerated.item[0] = 6;         
+                ucontrol->value.enumerated.item[0] = 6;
         }
         return 0;
 }
@@ -1968,7 +1989,7 @@ static int hdsp_system_clock_mode(struct hdsp *hdsp)
 static int snd_hdsp_info_system_clock_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
         static char *texts[] = {"Master", "Slave" };
-        
+
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
         uinfo->value.enumerated.items = 2;
@@ -1981,7 +2002,7 @@ static int snd_hdsp_info_system_clock_mode(struct snd_kcontrol *kcontrol, struct
 static int snd_hdsp_get_system_clock_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_system_clock_mode(hdsp);
         return 0;
 }
@@ -2018,7 +2039,7 @@ static int hdsp_clock_source(struct hdsp *hdsp)
                 case 192000:
                         return 9;
                 default:
-                        return 3;       
+                        return 3;
                 }
         } else {
                 return 0;
@@ -2032,7 +2053,7 @@ static int hdsp_set_clock_source(struct hdsp *hdsp, int mode)
         case HDSP_CLOCK_SOURCE_AUTOSYNC:
                 if (hdsp_external_sample_rate(hdsp) != 0) {
                     if (!hdsp_set_rate(hdsp, hdsp_external_sample_rate(hdsp), 1)) {
-                        hdsp->control_register &= ~HDSP_ClockModeMaster;                
+                        hdsp->control_register &= ~HDSP_ClockModeMaster;
                         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
                         return 0;
                     }
@@ -2043,7 +2064,7 @@ static int hdsp_set_clock_source(struct hdsp *hdsp, int mode)
                 break;
         case HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ:
                 rate = 44100;
-                break;      
+                break;
         case HDSP_CLOCK_SOURCE_INTERNAL_48KHZ:
                 rate = 48000;
                 break;
@@ -2078,13 +2099,13 @@ static int snd_hdsp_info_clock_source(struct snd_kcontrol *kcontrol, struct snd_
 {
         static char *texts[] = {"AutoSync", "Internal 32.0 kHz", "Internal 44.1 kHz", "Internal 48.0 kHz", "Internal 64.0 kHz", "Internal 88.2 kHz", "Internal 96.0 kHz", "Internal 128 kHz", "Internal 176.4 kHz", "Internal 192.0 KHz" };
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
         if (hdsp->io_type == H9632)
             uinfo->value.enumerated.items = 10;
         else
-            uinfo->value.enumerated.items = 7;  
+            uinfo->value.enumerated.items = 7;
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
@@ -2094,7 +2115,7 @@ static int snd_hdsp_info_clock_source(struct snd_kcontrol *kcontrol, struct snd_
 static int snd_hdsp_get_clock_source(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_clock_source(hdsp);
         return 0;
 }
@@ -2104,7 +2125,7 @@ static int snd_hdsp_put_clock_source(struct snd_kcontrol *kcontrol, struct snd_c
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.enumerated.item[0];
@@ -2130,7 +2151,7 @@ static int snd_hdsp_put_clock_source(struct snd_kcontrol *kcontrol, struct snd_c
 static int snd_hdsp_get_clock_source_lock(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.integer.value[0] = hdsp->clock_source_locked;
         return 0;
 }
@@ -2165,7 +2186,7 @@ static int hdsp_da_gain(struct hdsp *hdsp)
         case HDSP_DAGainMinus10dBV:
                 return 2;
         default:
-                return 1;       
+                return 1;
         }
 }
 
@@ -2180,8 +2201,8 @@ static int hdsp_set_da_gain(struct hdsp *hdsp, int mode)
                 hdsp->control_register |= HDSP_DAGainPlus4dBu;
                 break;
         case 2:
-                hdsp->control_register |= HDSP_DAGainMinus10dBV;                
-                break;      
+                hdsp->control_register |= HDSP_DAGainMinus10dBV;
+                break;
         default:
                 return -1;
 
@@ -2193,7 +2214,7 @@ static int hdsp_set_da_gain(struct hdsp *hdsp, int mode)
 static int snd_hdsp_info_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
         static char *texts[] = {"Hi Gain", "+4 dBu", "-10 dbV"};
-        
+
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
         uinfo->value.enumerated.items = 3;
@@ -2206,7 +2227,7 @@ static int snd_hdsp_info_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_e
 static int snd_hdsp_get_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_da_gain(hdsp);
         return 0;
 }
@@ -2216,7 +2237,7 @@ static int snd_hdsp_put_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_el
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.enumerated.item[0];
@@ -2250,7 +2271,7 @@ static int hdsp_ad_gain(struct hdsp *hdsp)
         case HDSP_ADGainLowGain:
                 return 2;
         default:
-                return 1;       
+                return 1;
         }
 }
 
@@ -2262,11 +2283,11 @@ static int hdsp_set_ad_gain(struct hdsp *hdsp, int mode)
                 hdsp->control_register |= HDSP_ADGainMinus10dBV;
                 break;
         case 1:
-                hdsp->control_register |= HDSP_ADGainPlus4dBu;          
+                hdsp->control_register |= HDSP_ADGainPlus4dBu;
                 break;
         case 2:
-                hdsp->control_register |= HDSP_ADGainLowGain;           
-                break;      
+                hdsp->control_register |= HDSP_ADGainLowGain;
+                break;
         default:
                 return -1;
 
@@ -2278,7 +2299,7 @@ static int hdsp_set_ad_gain(struct hdsp *hdsp, int mode)
 static int snd_hdsp_info_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
         static char *texts[] = {"-10 dBV", "+4 dBu", "Lo Gain"};
-        
+
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
         uinfo->value.enumerated.items = 3;
@@ -2291,7 +2312,7 @@ static int snd_hdsp_info_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_e
 static int snd_hdsp_get_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_ad_gain(hdsp);
         return 0;
 }
@@ -2301,7 +2322,7 @@ static int snd_hdsp_put_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_el
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.enumerated.item[0];
@@ -2335,7 +2356,7 @@ static int hdsp_phone_gain(struct hdsp *hdsp)
         case HDSP_PhoneGainMinus12dB:
                 return 2;
         default:
-                return 0;       
+                return 0;
         }
 }
 
@@ -2347,11 +2368,11 @@ static int hdsp_set_phone_gain(struct hdsp *hdsp, int mode)
                 hdsp->control_register |= HDSP_PhoneGain0dB;
                 break;
         case 1:
-                hdsp->control_register |= HDSP_PhoneGainMinus6dB;               
+                hdsp->control_register |= HDSP_PhoneGainMinus6dB;
                 break;
         case 2:
-                hdsp->control_register |= HDSP_PhoneGainMinus12dB;              
-                break;      
+                hdsp->control_register |= HDSP_PhoneGainMinus12dB;
+                break;
         default:
                 return -1;
 
@@ -2363,7 +2384,7 @@ static int hdsp_set_phone_gain(struct hdsp *hdsp, int mode)
 static int snd_hdsp_info_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
         static char *texts[] = {"0 dB", "-6 dB", "-12 dB"};
-        
+
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
         uinfo->value.enumerated.items = 3;
@@ -2376,7 +2397,7 @@ static int snd_hdsp_info_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ct
 static int snd_hdsp_get_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_phone_gain(hdsp);
         return 0;
 }
@@ -2386,7 +2407,7 @@ static int snd_hdsp_put_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.enumerated.item[0];
@@ -2432,7 +2453,7 @@ static int hdsp_set_xlr_breakout_cable(struct hdsp *hdsp, int mode)
 static int snd_hdsp_get_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_xlr_breakout_cable(hdsp);
         return 0;
 }
@@ -2442,7 +2463,7 @@ static int snd_hdsp_put_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struct
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.integer.value[0] & 1;
@@ -2488,7 +2509,7 @@ static int hdsp_set_aeb(struct hdsp *hdsp, int mode)
 static int snd_hdsp_get_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_aeb(hdsp);
         return 0;
 }
@@ -2498,7 +2519,7 @@ static int snd_hdsp_put_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.integer.value[0] & 1;
@@ -2576,7 +2597,7 @@ static int snd_hdsp_info_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd
 {
         static char *texts[] = {"Word", "IEC958", "ADAT1", "ADAT Sync", "ADAT2", "ADAT3" };
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
 
@@ -2595,7 +2616,7 @@ static int snd_hdsp_info_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd
                 uinfo->value.enumerated.items = 0;
                 break;
         }
-                
+
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
@@ -2605,7 +2626,7 @@ static int snd_hdsp_info_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd
 static int snd_hdsp_get_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_pref_sync_ref(hdsp);
         return 0;
 }
@@ -2615,7 +2636,7 @@ static int snd_hdsp_put_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd_
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change, max;
         unsigned int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
 
@@ -2664,7 +2685,7 @@ static int hdsp_autosync_ref(struct hdsp *hdsp)
         case HDSP_SelSyncRef_SPDIF:
                 return HDSP_AUTOSYNC_FROM_SPDIF;
         case HDSP_SelSyncRefMask:
-                return HDSP_AUTOSYNC_FROM_NONE; 
+                return HDSP_AUTOSYNC_FROM_NONE;
         case HDSP_SelSyncRef_ADAT1:
                 return HDSP_AUTOSYNC_FROM_ADAT1;
         case HDSP_SelSyncRef_ADAT2:
@@ -2680,7 +2701,7 @@ static int hdsp_autosync_ref(struct hdsp *hdsp)
 static int snd_hdsp_info_autosync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
         static char *texts[] = {"Word", "ADAT Sync", "IEC958", "None", "ADAT1", "ADAT2", "ADAT3" };
-        
+
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
         uinfo->value.enumerated.items = 7;
@@ -2693,7 +2714,7 @@ static int snd_hdsp_info_autosync_ref(struct snd_kcontrol *kcontrol, struct snd_
 static int snd_hdsp_get_autosync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_autosync_ref(hdsp);
         return 0;
 }
@@ -2727,7 +2748,7 @@ static int hdsp_set_line_output(struct hdsp *hdsp, int out)
 static int snd_hdsp_get_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         spin_lock_irq(&hdsp->lock);
         ucontrol->value.integer.value[0] = hdsp_line_out(hdsp);
         spin_unlock_irq(&hdsp->lock);
@@ -2739,7 +2760,7 @@ static int snd_hdsp_put_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         unsigned int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.integer.value[0] & 1;
@@ -2773,7 +2794,7 @@ static int hdsp_set_precise_pointer(struct hdsp *hdsp, int precise)
 static int snd_hdsp_get_precise_pointer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         spin_lock_irq(&hdsp->lock);
         ucontrol->value.integer.value[0] = hdsp->precise_ptr;
         spin_unlock_irq(&hdsp->lock);
@@ -2785,7 +2806,7 @@ static int snd_hdsp_put_precise_pointer(struct snd_kcontrol *kcontrol, struct sn
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         unsigned int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.integer.value[0] & 1;
@@ -2819,7 +2840,7 @@ static int hdsp_set_use_midi_tasklet(struct hdsp *hdsp, int use_tasklet)
 static int snd_hdsp_get_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         spin_lock_irq(&hdsp->lock);
         ucontrol->value.integer.value[0] = hdsp->use_midi_tasklet;
         spin_unlock_irq(&hdsp->lock);
@@ -2831,7 +2852,7 @@ static int snd_hdsp_put_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct s
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         unsigned int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.integer.value[0] & 1;
@@ -2873,12 +2894,12 @@ static int snd_hdsp_get_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem
 
         source = ucontrol->value.integer.value[0];
         destination = ucontrol->value.integer.value[1];
-        
+
         if (source >= hdsp->max_channels)
                 addr = hdsp_playback_to_output_key(hdsp,source-hdsp->max_channels,destination);
         else
                 addr = hdsp_input_to_output_key(hdsp,source, destination);
-        
+
         spin_lock_irq(&hdsp->lock);
         ucontrol->value.integer.value[2] = hdsp_read_gain (hdsp, addr);
         spin_unlock_irq(&hdsp->lock);
@@ -2926,7 +2947,7 @@ static int snd_hdsp_put_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem
 
 static int snd_hdsp_info_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
-        static char *texts[] = {"No Lock", "Lock", "Sync" };    
+        static char *texts[] = {"No Lock", "Lock", "Sync" };
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
         uinfo->value.enumerated.items = 3;
@@ -2971,7 +2992,7 @@ static int hdsp_spdif_sync_check(struct hdsp *hdsp)
         int status = hdsp_read(hdsp, HDSP_statusRegister);
         if (status & HDSP_SPDIFErrorFlag)
                 return 0;
-        else {  
+        else {
                 if (status & HDSP_SPDIFSync)
                         return 2;
                 else
@@ -3007,7 +3028,7 @@ static int hdsp_adatsync_sync_check(struct hdsp *hdsp)
                         return 1;
         } else
                 return 0;
-}       
+}
 
 static int snd_hdsp_get_adatsync_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
@@ -3025,17 +3046,17 @@ static int snd_hdsp_get_adatsync_sync_check(struct snd_kcontrol *kcontrol, struc
 }
 
 static int hdsp_adat_sync_check(struct hdsp *hdsp, int idx)
-{       
+{
         int status = hdsp_read(hdsp, HDSP_statusRegister);
-        
+
         if (status & (HDSP_Lock0>>idx)) {
                 if (status & (HDSP_Sync0>>idx))
                         return 2;
                 else
-                        return 1;               
+                        return 1;
         } else
                 return 0;
-} 
+}
 
 static int snd_hdsp_get_adat_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
@@ -3053,7 +3074,7 @@ static int snd_hdsp_get_adat_sync_check(struct snd_kcontrol *kcontrol, struct sn
                 break;
         case Multiface:
         case H9632:
-                if (offset >= 1) 
+                if (offset >= 1)
                         return -EINVAL;
                 break;
         default:
@@ -3115,7 +3136,7 @@ static int snd_hdsp_info_dds_offset(struct snd_kcontrol *kcontrol, struct snd_ct
 static int snd_hdsp_get_dds_offset(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
-        
+
         ucontrol->value.enumerated.item[0] = hdsp_dds_offset(hdsp);
         return 0;
 }
@@ -3125,7 +3146,7 @@ static int snd_hdsp_put_dds_offset(struct snd_kcontrol *kcontrol, struct snd_ctl
         struct hdsp *hdsp = snd_kcontrol_chip(kcontrol);
         int change;
         int val;
-        
+
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
         val = ucontrol->value.enumerated.item[0];
@@ -3170,7 +3191,7 @@ static struct snd_kcontrol_new snd_hdsp_controls[] = {
         .get =          snd_hdsp_control_spdif_mask_get,
         .private_value = IEC958_AES0_NONAUDIO |
                          IEC958_AES0_PROFESSIONAL |
-                         IEC958_AES0_CON_EMPHASIS,                                                                                            
+                         IEC958_AES0_CON_EMPHASIS,
 },
 {
         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
@@ -3188,7 +3209,7 @@ HDSP_SPDIF_OUT("IEC958 Output also on ADAT1", 0),
 HDSP_SPDIF_PROFESSIONAL("IEC958 Professional Bit", 0),
 HDSP_SPDIF_EMPHASIS("IEC958 Emphasis Bit", 0),
 HDSP_SPDIF_NON_AUDIO("IEC958 Non-audio Bit", 0),
-/* 'Sample Clock Source' complies with the alsa control naming scheme */ 
+/* 'Sample Clock Source' complies with the alsa control naming scheme */
 HDSP_CLOCK_SOURCE("Sample Clock Source", 0),
 {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -3240,7 +3261,7 @@ static int snd_hdsp_create_controls(struct snd_card *card, struct hdsp *hdsp)
                                 return err;
                 }
         }
-        
+
         /* DA, AD and Phone gain and XLR breakout cable controls for H9632 cards */
         if (hdsp->io_type == H9632) {
                 for (idx = 0; idx < ARRAY_SIZE(snd_hdsp_9632_controls); idx++) {
@@ -3259,7 +3280,7 @@ static int snd_hdsp_create_controls(struct snd_card *card, struct hdsp *hdsp)
 }
 
 /*------------------------------------------------------------
-   /proc interface 
+   /proc interface
  ------------------------------------------------------------*/
 
 static void
@@ -3298,7 +3319,7 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                         }
                 }
         }
-        
+
         status = hdsp_read(hdsp, HDSP_statusRegister);
         status2 = hdsp_read(hdsp, HDSP_status2Register);
 
@@ -3362,17 +3383,17 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                 break;
                 case HDSP_CLOCK_SOURCE_INTERNAL_192KHZ:
                 clock_source = "Internal 192 kHz";
-                break;  
+                break;
         default:
-                clock_source = "Error";         
+                clock_source = "Error";
         }
         snd_iprintf (buffer, "Sample Clock Source: %s\n", clock_source);
-                        
+
         if (hdsp_system_clock_mode(hdsp))
                 system_clock_mode = "Slave";
         else
                 system_clock_mode = "Master";
-        
+
         switch (hdsp_pref_sync_ref (hdsp)) {
         case HDSP_SYNC_FROM_WORD:
                 pref_sync_ref = "Word Clock";
@@ -3397,7 +3418,7 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                 break;
         }
         snd_iprintf (buffer, "Preferred Sync Reference: %s\n", pref_sync_ref);
-        
+
         switch (hdsp_autosync_ref (hdsp)) {
         case HDSP_AUTOSYNC_FROM_WORD:
                 autosync_ref = "Word Clock";
@@ -3410,7 +3431,7 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                 break;
         case HDSP_AUTOSYNC_FROM_NONE:
                 autosync_ref = "None";
-                break;  
+                break;
         case HDSP_AUTOSYNC_FROM_ADAT1:
                 autosync_ref = "ADAT1";
                 break;
@@ -3425,14 +3446,14 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                 break;
         }
         snd_iprintf (buffer, "AutoSync Reference: %s\n", autosync_ref);
-        
+
         snd_iprintf (buffer, "AutoSync Frequency: %d\n", hdsp_external_sample_rate(hdsp));
-        
+
         snd_iprintf (buffer, "System Clock Mode: %s\n", system_clock_mode);
 
         snd_iprintf (buffer, "System Clock Frequency: %d\n", hdsp->system_sample_rate);
         snd_iprintf (buffer, "System Clock Locked: %s\n", hdsp->clock_source_locked ? "Yes" : "No");
-                
+
         snd_iprintf(buffer, "\n");
 
         switch (hdsp_spdif_in(hdsp)) {
@@ -3452,7 +3473,7 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                 snd_iprintf(buffer, "IEC958 input: ???\n");
                 break;
         }
-        
+
         if (hdsp->control_register & HDSP_SPDIFOpticalOut)
                 snd_iprintf(buffer, "IEC958 output: Coaxial & ADAT1\n");
         else
@@ -3510,13 +3531,13 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                 snd_iprintf (buffer, "SPDIF: No Lock\n");
         else
                 snd_iprintf (buffer, "SPDIF: %s\n", x ? "Sync" : "Lock");
-        
+
         x = status2 & HDSP_wc_sync;
         if (status2 & HDSP_wc_lock)
                 snd_iprintf (buffer, "Word Clock: %s\n", x ? "Sync" : "Lock");
         else
                 snd_iprintf (buffer, "Word Clock: No Lock\n");
-        
+
         x = status & HDSP_TimecodeSync;
         if (status & HDSP_TimecodeLock)
                 snd_iprintf(buffer, "ADAT Sync: %s\n", x ? "Sync" : "Lock");
@@ -3524,11 +3545,11 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                 snd_iprintf(buffer, "ADAT Sync: No Lock\n");
 
         snd_iprintf(buffer, "\n");
-        
+
         /* Informations about H9632 specific controls */
         if (hdsp->io_type == H9632) {
                 char *tmp;
-        
+
                 switch (hdsp_ad_gain(hdsp)) {
                 case 0:
                         tmp = "-10 dBV";
@@ -3554,7 +3575,7 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                         break;
                 }
                 snd_iprintf(buffer, "DA Gain : %s\n", tmp);
-                
+
                 switch (hdsp_phone_gain(hdsp)) {
                 case 0:
                         tmp = "0 dB";
@@ -3568,8 +3589,8 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                 }
                 snd_iprintf(buffer, "Phones Gain : %s\n", tmp);
 
-                snd_iprintf(buffer, "XLR Breakout Cable : %s\n", hdsp_xlr_breakout_cable(hdsp) ? "yes" : "no"); 
-                
+                snd_iprintf(buffer, "XLR Breakout Cable : %s\n", hdsp_xlr_breakout_cable(hdsp) ? "yes" : "no");
+
                 if (hdsp->control_register & HDSP_AnalogExtensionBoard)
                         snd_iprintf(buffer, "AEB : on (ADAT1 internal)\n");
                 else
@@ -3632,18 +3653,18 @@ static int snd_hdsp_set_defaults(struct hdsp *hdsp)
 
         /* set defaults:
 
-           SPDIF Input via Coax 
+           SPDIF Input via Coax
            Master clock mode
            maximum latency (7 => 2^7 = 8192 samples, 64Kbyte buffer,
                             which implies 2 4096 sample, 32Kbyte periods).
-           Enable line out.                         
+           Enable line out.
          */
 
-        hdsp->control_register = HDSP_ClockModeMaster | 
-                                 HDSP_SPDIFInputCoaxial | 
-                                 hdsp_encode_latency(7) | 
+        hdsp->control_register = HDSP_ClockModeMaster |
+                                 HDSP_SPDIFInputCoaxial |
+                                 hdsp_encode_latency(7) |
                                  HDSP_LineOut;
-        
+
 
         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
 
@@ -3661,7 +3682,7 @@ static int snd_hdsp_set_defaults(struct hdsp *hdsp)
         hdsp_compute_period_size(hdsp);
 
         /* silence everything */
-        
+
         for (i = 0; i < HDSP_MATRIX_MIXER_SIZE; ++i)
                 hdsp->mixer_matrix[i] = MINUS_INFINITY_GAIN;
 
@@ -3669,7 +3690,7 @@ static int snd_hdsp_set_defaults(struct hdsp *hdsp)
                 if (hdsp_write_gain (hdsp, i, MINUS_INFINITY_GAIN))
                         return -EIO;
         }
-        
+
         /* H9632 specific defaults */
         if (hdsp->io_type == H9632) {
                 hdsp->control_register |= (HDSP_DAGainPlus4dBu | HDSP_ADGainPlus4dBu | HDSP_PhoneGain0dB);
@@ -3687,12 +3708,12 @@ static int snd_hdsp_set_defaults(struct hdsp *hdsp)
 static void hdsp_midi_tasklet(unsigned long arg)
 {
         struct hdsp *hdsp = (struct hdsp *)arg;
-        
+
         if (hdsp->midi[0].pending)
                 snd_hdsp_midi_input_read (&hdsp->midi[0]);
         if (hdsp->midi[1].pending)
                 snd_hdsp_midi_input_read (&hdsp->midi[1]);
-} 
+}
 
 static irqreturn_t snd_hdsp_interrupt(int irq, void *dev_id)
 {
@@ -3704,7 +3725,7 @@ static irqreturn_t snd_hdsp_interrupt(int irq, void *dev_id)
         unsigned int midi0status;
         unsigned int midi1status;
         int schedule = 0;
-        
+
         status = hdsp_read(hdsp, HDSP_statusRegister);
 
         audio = status & HDSP_audioIRQPending;
@@ -3718,15 +3739,18 @@ static irqreturn_t snd_hdsp_interrupt(int irq, void *dev_id)
 
         midi0status = hdsp_read (hdsp, HDSP_midiStatusIn0) & 0xff;
         midi1status = hdsp_read (hdsp, HDSP_midiStatusIn1) & 0xff;
-        
+
+        if (!(hdsp->state & HDSP_InitializationComplete))
+                return IRQ_HANDLED;
+
         if (audio) {
                 if (hdsp->capture_substream)
                         snd_pcm_period_elapsed(hdsp->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
-                
+
                 if (hdsp->playback_substream)
                         snd_pcm_period_elapsed(hdsp->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
         }
-        
+
         if (midi0 && midi0status) {
                 if (hdsp->use_midi_tasklet) {
                         /* we disable interrupts for this input until processing is done */
@@ -3769,10 +3793,10 @@ static char *hdsp_channel_buffer_location(struct hdsp *hdsp,
 
         if (snd_BUG_ON(channel < 0 || channel >= hdsp->max_channels))
                 return NULL;
-        
+
         if ((mapped_channel = hdsp->channel_map[channel]) < 0)
                 return NULL;
-        
+
         if (stream == SNDRV_PCM_STREAM_CAPTURE)
                 return hdsp->capture_buffer + (mapped_channel * HDSP_CHANNEL_BUFFER_BYTES);
         else
@@ -3965,7 +3989,7 @@ static int snd_hdsp_trigger(struct snd_pcm_substream *substream, int cmd)
         struct hdsp *hdsp = snd_pcm_substream_chip(substream);
         struct snd_pcm_substream *other;
         int running;
-        
+
         if (hdsp_check_for_iobox (hdsp))
                 return -EIO;
 
@@ -4059,10 +4083,10 @@ static struct snd_pcm_hardware snd_hdsp_playback_subinfo =
         .formats =              SNDRV_PCM_FMTBIT_S32_LE,
 #endif
         .rates =                (SNDRV_PCM_RATE_32000 |
-                                 SNDRV_PCM_RATE_44100 | 
-                                 SNDRV_PCM_RATE_48000 | 
-                                 SNDRV_PCM_RATE_64000 | 
-                                 SNDRV_PCM_RATE_88200 | 
+                                 SNDRV_PCM_RATE_44100 |
+                                 SNDRV_PCM_RATE_48000 |
+                                 SNDRV_PCM_RATE_64000 |
+                                 SNDRV_PCM_RATE_88200 |
                                  SNDRV_PCM_RATE_96000),
         .rate_min =             32000,
         .rate_max =             96000,
@@ -4088,10 +4112,10 @@ static struct snd_pcm_hardware snd_hdsp_capture_subinfo =
         .formats =              SNDRV_PCM_FMTBIT_S32_LE,
 #endif
         .rates =                (SNDRV_PCM_RATE_32000 |
-                                 SNDRV_PCM_RATE_44100 | 
-                                 SNDRV_PCM_RATE_48000 | 
-                                 SNDRV_PCM_RATE_64000 | 
-                                 SNDRV_PCM_RATE_88200 | 
+                                 SNDRV_PCM_RATE_44100 |
+                                 SNDRV_PCM_RATE_48000 |
+                                 SNDRV_PCM_RATE_64000 |
+                                 SNDRV_PCM_RATE_88200 |
                                  SNDRV_PCM_RATE_96000),
         .rate_min =             32000,
         .rate_max =             96000,
@@ -4170,7 +4194,7 @@ static int snd_hdsp_hw_rule_in_channels_rate(struct snd_pcm_hw_params *params,
                         .max = hdsp->qs_in_channels,
                         .integer = 1,
                 };
-                return snd_interval_refine(c, &t);      
+                return snd_interval_refine(c, &t);
         } else if (r->min > 48000 && r->max <= 96000) {
                 struct snd_interval t = {
                         .min = hdsp->ds_in_channels,
@@ -4201,7 +4225,7 @@ static int snd_hdsp_hw_rule_out_channels_rate(struct snd_pcm_hw_params *params,
                         .max = hdsp->qs_out_channels,
                         .integer = 1,
                 };
-                return snd_interval_refine(c, &t);      
+                return snd_interval_refine(c, &t);
         } else if (r->min > 48000 && r->max <= 96000) {
                 struct snd_interval t = {
                         .min = hdsp->ds_out_channels,
@@ -4318,8 +4342,8 @@ static int snd_hdsp_playback_open(struct snd_pcm_substream *substream)
         if (hdsp->io_type == H9632) {
                 runtime->hw.channels_min = hdsp->qs_out_channels;
                 runtime->hw.channels_max = hdsp->ss_out_channels;
-        }       
-        
+        }
+
         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
                              snd_hdsp_hw_rule_out_channels, hdsp,
                              SNDRV_PCM_HW_PARAM_CHANNELS, -1);
@@ -4413,13 +4437,6 @@ static int snd_hdsp_capture_release(struct snd_pcm_substream *substream)
         return 0;
 }
 
-static int snd_hdsp_hwdep_dummy_op(struct snd_hwdep *hw, struct file *file)
-{
-        /* we have nothing to initialize but the call is required */
-        return 0;
-}
-
-
 /* helper functions for copying meter values */
 static inline int copy_u32_le(void __user *dest, void __iomem *src)
 {
@@ -4536,7 +4553,7 @@ static int hdsp_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rm
                                 hdsp->iobase + HDSP_playbackRmsLevel + i * 8 + 4,
                                 hdsp->iobase + HDSP_playbackRmsLevel + i * 8))
                         return -EFAULT;
-                if (copy_u64_le(&peak_rms->input_rms[i], 
+                if (copy_u64_le(&peak_rms->input_rms[i],
                                 hdsp->iobase + HDSP_inputRmsLevel + i * 8 + 4,
                                 hdsp->iobase + HDSP_inputRmsLevel + i * 8))
                         return -EFAULT;
@@ -4546,7 +4563,7 @@ static int hdsp_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rm
 
 static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct hdsp *hdsp = (struct hdsp *)hw->private_data;    
+        struct hdsp *hdsp = (struct hdsp *)hw->private_data;
         void __user *argp = (void __user *)arg;
         int err;
 
@@ -4580,7 +4597,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne
                 struct hdsp_config_info info;
                 unsigned long flags;
                 int i;
-                
+
                 err = hdsp_check_for_iobox(hdsp);
                 if (err < 0)
                         return err;
@@ -4614,7 +4631,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne
                         info.ad_gain = (unsigned char)hdsp_ad_gain(hdsp);
                         info.phone_gain = (unsigned char)hdsp_phone_gain(hdsp);
                         info.xlr_breakout_cable = (unsigned char)hdsp_xlr_breakout_cable(hdsp);
-                
+
                 }
                 if (hdsp->io_type == H9632 || hdsp->io_type == H9652)
                         info.analog_extension_board = (unsigned char)hdsp_aeb(hdsp);
@@ -4625,7 +4642,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne
         }
         case SNDRV_HDSP_IOCTL_GET_9632_AEB: {
                 struct hdsp_9632_aeb h9632_aeb;
-                
+
                 if (hdsp->io_type != H9632) return -EINVAL;
                 h9632_aeb.aebi = hdsp->ss_in_channels - H9632_SS_CHANNELS;
                 h9632_aeb.aebo = hdsp->ss_out_channels - H9632_SS_CHANNELS;
@@ -4636,7 +4653,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne
         case SNDRV_HDSP_IOCTL_GET_VERSION: {
                 struct hdsp_version hdsp_version;
                 int err;
-                
+
                 if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return -EINVAL;
                 if (hdsp->io_type == Undefined) {
                         if ((err = hdsp_get_iobox_version(hdsp)) < 0)
@@ -4652,7 +4669,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne
                 struct hdsp_firmware __user *firmware;
                 u32 __user *firmware_data;
                 int err;
-                
+
                 if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return -EINVAL;
                 /* SNDRV_HDSP_IOCTL_GET_VERSION must have been called */
                 if (hdsp->io_type == Undefined) return -EINVAL;
@@ -4665,25 +4682,25 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne
 
                 if (get_user(firmware_data, &firmware->firmware_data))
                         return -EFAULT;
-                
+
                 if (hdsp_check_for_iobox (hdsp))
                         return -EIO;
 
                 if (copy_from_user(hdsp->firmware_cache, firmware_data, sizeof(hdsp->firmware_cache)) != 0)
                         return -EFAULT;
-                
+
                 hdsp->state |= HDSP_FirmwareCached;
 
                 if ((err = snd_hdsp_load_firmware_from_cache(hdsp)) < 0)
                         return err;
-                
+
                 if (!(hdsp->state & HDSP_InitializationComplete)) {
                         if ((err = snd_hdsp_enable_io(hdsp)) < 0)
                                 return err;
-                        
-                        snd_hdsp_initialize_channels(hdsp);             
+
+                        snd_hdsp_initialize_channels(hdsp);
                         snd_hdsp_initialize_midi_flush(hdsp);
-            
+
                         if ((err = snd_hdsp_create_alsa_devices(hdsp->card, hdsp)) < 0) {
                                 snd_printk(KERN_ERR "Hammerfall-DSP: error creating alsa devices\n");
                                 return err;
@@ -4730,18 +4747,16 @@ static int snd_hdsp_create_hwdep(struct snd_card *card, struct hdsp *hdsp)
 {
         struct snd_hwdep *hw;
         int err;
-        
+
         if ((err = snd_hwdep_new(card, "HDSP hwdep", 0, &hw)) < 0)
                 return err;
-                
+
         hdsp->hwdep = hw;
         hw->private_data = hdsp;
         strcpy(hw->name, "HDSP hwdep interface");
 
-        hw->ops.open = snd_hdsp_hwdep_dummy_op;
         hw->ops.ioctl = snd_hdsp_hwdep_ioctl;
-        hw->ops.release = snd_hdsp_hwdep_dummy_op;
-                
+
         return 0;
 }
 
@@ -4774,24 +4789,24 @@ static void snd_hdsp_9652_enable_mixer (struct hdsp *hdsp)
 static int snd_hdsp_enable_io (struct hdsp *hdsp)
 {
         int i;
-        
+
         if (hdsp_fifo_wait (hdsp, 0, 100)) {
                 snd_printk(KERN_ERR "Hammerfall-DSP: enable_io fifo_wait failed\n");
                 return -EIO;
         }
-        
+
         for (i = 0; i < hdsp->max_channels; ++i) {
                 hdsp_write (hdsp, HDSP_inputEnable + (4 * i), 1);
                 hdsp_write (hdsp, HDSP_outputEnable + (4 * i), 1);
         }
-        
+
         return 0;
 }
 
 static void snd_hdsp_initialize_channels(struct hdsp *hdsp)
 {
         int status, aebi_channels, aebo_channels;
-        
+
         switch (hdsp->io_type) {
         case Digiface:
                 hdsp->card_name = "RME Hammerfall DSP + Digiface";
@@ -4804,7 +4819,7 @@ static void snd_hdsp_initialize_channels(struct hdsp *hdsp)
                 hdsp->ss_in_channels = hdsp->ss_out_channels = H9652_SS_CHANNELS;
                 hdsp->ds_in_channels = hdsp->ds_out_channels = H9652_DS_CHANNELS;
                 break;
-        
+
         case H9632:
                 status = hdsp_read(hdsp, HDSP_statusRegister);
                 /* HDSP_AEBx bits are low when AEB are connected */
@@ -4824,7 +4839,7 @@ static void snd_hdsp_initialize_channels(struct hdsp *hdsp)
                 hdsp->ss_in_channels = hdsp->ss_out_channels = MULTIFACE_SS_CHANNELS;
                 hdsp->ds_in_channels = hdsp->ds_out_channels = MULTIFACE_DS_CHANNELS;
                 break;
-                
+
         default:
                 /* should never get here */
                 break;
@@ -4840,12 +4855,12 @@ static void snd_hdsp_initialize_midi_flush (struct hdsp *hdsp)
 static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp)
 {
         int err;
-        
+
         if ((err = snd_hdsp_create_pcm(card, hdsp)) < 0) {
                 snd_printk(KERN_ERR "Hammerfall-DSP: Error creating pcm interface\n");
                 return err;
         }
-        
+
 
         if ((err = snd_hdsp_create_midi(card, hdsp, 0)) < 0) {
                 snd_printk(KERN_ERR "Hammerfall-DSP: Error creating first midi interface\n");
@@ -4876,19 +4891,19 @@ static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp
                 snd_printk(KERN_ERR "Hammerfall-DSP: Error setting default values\n");
                 return err;
         }
-        
+
         if (!(hdsp->state & HDSP_InitializationComplete)) {
                 strcpy(card->shortname, "Hammerfall DSP");
-                sprintf(card->longname, "%s at 0x%lx, irq %d", hdsp->card_name, 
+                sprintf(card->longname, "%s at 0x%lx, irq %d", hdsp->card_name,
                         hdsp->port, hdsp->irq);
-            
+
                 if ((err = snd_card_register(card)) < 0) {
                         snd_printk(KERN_ERR "Hammerfall-DSP: error registering card\n");
                         return err;
                 }
                 hdsp->state |= HDSP_InitializationComplete;
         }
-        
+
         return 0;
 }
 
@@ -4899,7 +4914,7 @@ static int hdsp_request_fw_loader(struct hdsp *hdsp)
         const char *fwfile;
         const struct firmware *fw;
         int err;
-                
+
         if (hdsp->io_type == H9652 || hdsp->io_type == H9632)
                 return 0;
         if (hdsp->io_type == Undefined) {
@@ -4908,7 +4923,7 @@ static int hdsp_request_fw_loader(struct hdsp *hdsp)
                 if (hdsp->io_type == H9652 || hdsp->io_type == H9632)
                         return 0;
         }
-        
+
         /* caution: max length of firmware filename is 30! */
         switch (hdsp->io_type) {
         case Multiface:
@@ -4942,12 +4957,12 @@ static int hdsp_request_fw_loader(struct hdsp *hdsp)
         memcpy(hdsp->firmware_cache, fw->data, sizeof(hdsp->firmware_cache));
 
         release_firmware(fw);
-                
+
         hdsp->state |= HDSP_FirmwareCached;
 
         if ((err = snd_hdsp_load_firmware_from_cache(hdsp)) < 0)
                 return err;
-                
+
         if (!(hdsp->state & HDSP_InitializationComplete)) {
                 if ((err = snd_hdsp_enable_io(hdsp)) < 0)
                         return err;
@@ -4994,14 +5009,14 @@ static int __devinit snd_hdsp_create(struct snd_card *card,
         hdsp->max_channels = 26;
 
         hdsp->card = card;
-        
+
         spin_lock_init(&hdsp->lock);
 
         tasklet_init(&hdsp->midi_tasklet, hdsp_midi_tasklet, (unsigned long)hdsp);
-        
+
         pci_read_config_word(hdsp->pci, PCI_CLASS_REVISION, &hdsp->firmware_rev);
         hdsp->firmware_rev &= 0xff;
-        
+
         /* From Martin Bjoernsen :
             "It is important that the card's latency timer register in
             the PCI configuration space is set to a value much larger
@@ -5010,7 +5025,7 @@ static int __devinit snd_hdsp_create(struct snd_card *card,
             to its maximum 255 to avoid problems with some computers."
         */
         pci_write_config_byte(hdsp->pci, PCI_LATENCY_TIMER, 0xFF);
-        
+
         strcpy(card->driver, "H-DSP");
         strcpy(card->mixername, "Xilinx FPGA");
 
@@ -5024,7 +5039,7 @@ static int __devinit snd_hdsp_create(struct snd_card *card,
         } else {
                 hdsp->card_name = "RME HDSP 9632";
                 hdsp->max_channels = 16;
-                is_9632 = 1;    
+                is_9632 = 1;
         }
 
         if ((err = pci_enable_device(pci)) < 0)
@@ -5053,12 +5068,12 @@ static int __devinit snd_hdsp_create(struct snd_card *card,
 
         if ((err = snd_hdsp_initialize_memory(hdsp)) < 0)
                 return err;
-        
+
         if (!is_9652 && !is_9632) {
-                /* we wait 2 seconds to let freshly inserted cardbus cards do their hardware init */
-                ssleep(2);
+                /* we wait a maximum of 10 seconds to let freshly
+                 * inserted cardbus cards do their hardware init */
+                err = hdsp_wait_for_iobox(hdsp, 1000, 10);
 
-                err = hdsp_check_for_iobox(hdsp);
                 if (err < 0)
                         return err;
 
@@ -5080,35 +5095,35 @@ static int __devinit snd_hdsp_create(struct snd_card *card,
                                 return err;
                         return 0;
                 } else {
-                        snd_printk(KERN_INFO "Hammerfall-DSP: Firmware already present, initializing card.\n");     
+                        snd_printk(KERN_INFO "Hammerfall-DSP: Firmware already present, initializing card.\n");
                         if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1)
                                 hdsp->io_type = Multiface;
-                        else 
+                        else
                                 hdsp->io_type = Digiface;
                 }
         }
-        
+
         if ((err = snd_hdsp_enable_io(hdsp)) != 0)
                 return err;
-        
+
         if (is_9652)
                 hdsp->io_type = H9652;
-        
+
         if (is_9632)
                 hdsp->io_type = H9632;
 
         if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0)
                 return err;
-        
+
         snd_hdsp_initialize_channels(hdsp);
         snd_hdsp_initialize_midi_flush(hdsp);
 
-        hdsp->state |= HDSP_FirmwareLoaded;     
+        hdsp->state |= HDSP_FirmwareLoaded;
 
         if ((err = snd_hdsp_create_alsa_devices(card, hdsp)) < 0)
                 return err;
 
-        return 0;       
+        return 0;
 }
 
 static int snd_hdsp_free(struct hdsp *hdsp)
@@ -5124,13 +5139,13 @@ static int snd_hdsp_free(struct hdsp *hdsp)
                 free_irq(hdsp->irq, (void *)hdsp);
 
         snd_hdsp_free_buffers(hdsp);
-        
+
         if (hdsp->iobase)
                 iounmap(hdsp->iobase);
 
         if (hdsp->port)
                 pci_release_regions(hdsp->pci);
-                
+
         pci_disable_device(hdsp->pci);
         return 0;
 }
@@ -5175,7 +5190,7 @@ static int __devinit snd_hdsp_probe(struct pci_dev *pci,
         }
 
         strcpy(card->shortname, "Hammerfall DSP");
-        sprintf(card->longname, "%s at 0x%lx, irq %d", hdsp->card_name, 
+        sprintf(card->longname, "%s at 0x%lx, irq %d", hdsp->card_name,
                 hdsp->port, hdsp->irq);
 
         if ((err = snd_card_register(card)) < 0) {
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index d4b4e0d0fee8..bac2dc0c5d85 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -4100,13 +4100,6 @@ static int snd_hdspm_capture_release(struct snd_pcm_substream *substream)
         return 0;
 }
 
-static int snd_hdspm_hwdep_dummy_op(struct snd_hwdep * hw, struct file *file)
-{
-        /* we have nothing to initialize but the call is required */
-        return 0;
-}
-
-
 static int snd_hdspm_hwdep_ioctl(struct snd_hwdep * hw, struct file *file,
                                  unsigned int cmd, unsigned long arg)
 {
@@ -4213,9 +4206,7 @@ static int __devinit snd_hdspm_create_hwdep(struct snd_card *card,
         hw->private_data = hdspm;
         strcpy(hw->name, "HDSPM hwdep interface");
 
-        hw->ops.open = snd_hdspm_hwdep_dummy_op;
         hw->ops.ioctl = snd_hdspm_hwdep_ioctl;
-        hw->ops.release = snd_hdspm_hwdep_dummy_op;
 
         return 0;
 }
diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c
index baf6d8e3dabc..1a5ff0611072 100644
--- a/sound/pci/sis7019.c
+++ b/sound/pci/sis7019.c
@@ -1300,7 +1300,7 @@ static int __devinit sis_chip_create(struct snd_card *card,
         if (rc)
                 goto error_out;
 
-        if (pci_set_dma_mask(pci, DMA_30BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(30)) < 0) {
                 printk(KERN_ERR "sis7019: architecture does not support "
                                         "30-bit PCI busmaster DMA");
                 goto error_out_enabled;
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index c5601b0ad7cc..7dc60ad4772e 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -273,7 +273,8 @@ static inline void snd_sonicvibes_setdmaa(struct sonicvibes * sonic,
         outl(count, sonic->dmaa_port + SV_DMA_COUNT0);
         outb(0x18, sonic->dmaa_port + SV_DMA_MODE);
 #if 0
-        printk("program dmaa: addr = 0x%x, paddr = 0x%x\n", addr, inl(sonic->dmaa_port + SV_DMA_ADDR0));
+        printk(KERN_DEBUG "program dmaa: addr = 0x%x, paddr = 0x%x\n",
+               addr, inl(sonic->dmaa_port + SV_DMA_ADDR0));
 #endif
 }
 
@@ -288,7 +289,8 @@ static inline void snd_sonicvibes_setdmac(struct sonicvibes * sonic,
         outl(count, sonic->dmac_port + SV_DMA_COUNT0);
         outb(0x14, sonic->dmac_port + SV_DMA_MODE);
 #if 0
-        printk("program dmac: addr = 0x%x, paddr = 0x%x\n", addr, inl(sonic->dmac_port + SV_DMA_ADDR0));
+        printk(KERN_DEBUG "program dmac: addr = 0x%x, paddr = 0x%x\n",
+               addr, inl(sonic->dmac_port + SV_DMA_ADDR0));
 #endif
 }
 
@@ -355,71 +357,104 @@ static unsigned char snd_sonicvibes_in(struct sonicvibes * sonic, unsigned char
 #if 0
 static void snd_sonicvibes_debug(struct sonicvibes * sonic)
 {
-        printk("SV REGS:          INDEX = 0x%02x  ", inb(SV_REG(sonic, INDEX)));
+        printk(KERN_DEBUG
+               "SV REGS:          INDEX = 0x%02x  ", inb(SV_REG(sonic, INDEX)));
         printk("                 STATUS = 0x%02x\n", inb(SV_REG(sonic, STATUS)));
-        printk("  0x00: left input      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x00));
+        printk(KERN_DEBUG
+               "  0x00: left input      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x00));
         printk("  0x20: synth rate low  = 0x%02x\n", snd_sonicvibes_in(sonic, 0x20));
-        printk("  0x01: right input     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x01));
+        printk(KERN_DEBUG
+               "  0x01: right input     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x01));
         printk("  0x21: synth rate high = 0x%02x\n", snd_sonicvibes_in(sonic, 0x21));
-        printk("  0x02: left AUX1       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x02));
+        printk(KERN_DEBUG
+               "  0x02: left AUX1       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x02));
         printk("  0x22: ADC clock       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x22));
-        printk("  0x03: right AUX1      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x03));
+        printk(KERN_DEBUG
+               "  0x03: right AUX1      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x03));
         printk("  0x23: ADC alt rate    = 0x%02x\n", snd_sonicvibes_in(sonic, 0x23));
-        printk("  0x04: left CD         = 0x%02x  ", snd_sonicvibes_in(sonic, 0x04));
+        printk(KERN_DEBUG
+               "  0x04: left CD         = 0x%02x  ", snd_sonicvibes_in(sonic, 0x04));
         printk("  0x24: ADC pll M       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x24));
-        printk("  0x05: right CD        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x05));
+        printk(KERN_DEBUG
+               "  0x05: right CD        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x05));
         printk("  0x25: ADC pll N       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x25));
-        printk("  0x06: left line       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x06));
+        printk(KERN_DEBUG
+               "  0x06: left line       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x06));
         printk("  0x26: Synth pll M     = 0x%02x\n", snd_sonicvibes_in(sonic, 0x26));
-        printk("  0x07: right line      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x07));
+        printk(KERN_DEBUG
+               "  0x07: right line      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x07));
         printk("  0x27: Synth pll N     = 0x%02x\n", snd_sonicvibes_in(sonic, 0x27));
-        printk("  0x08: MIC             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x08));
+        printk(KERN_DEBUG
+               "  0x08: MIC             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x08));
         printk("  0x28: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x28));
-        printk("  0x09: Game port       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x09));
+        printk(KERN_DEBUG
+               "  0x09: Game port       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x09));
         printk("  0x29: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x29));
-        printk("  0x0a: left synth      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0a));
+        printk(KERN_DEBUG
+               "  0x0a: left synth      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0a));
         printk("  0x2a: MPU401          = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2a));
-        printk("  0x0b: right synth     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0b));
+        printk(KERN_DEBUG
+               "  0x0b: right synth     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0b));
         printk("  0x2b: drive ctrl      = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2b));
-        printk("  0x0c: left AUX2       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0c));
+        printk(KERN_DEBUG
+               "  0x0c: left AUX2       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0c));
         printk("  0x2c: SRS space       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2c));
-        printk("  0x0d: right AUX2      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0d));
+        printk(KERN_DEBUG
+               "  0x0d: right AUX2      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0d));
         printk("  0x2d: SRS center      = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2d));
-        printk("  0x0e: left analog     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0e));
+        printk(KERN_DEBUG
+               "  0x0e: left analog     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0e));
         printk("  0x2e: wave source     = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2e));
-        printk("  0x0f: right analog    = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0f));
+        printk(KERN_DEBUG
+               "  0x0f: right analog    = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0f));
         printk("  0x2f: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2f));
-        printk("  0x10: left PCM        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x10));
+        printk(KERN_DEBUG
+               "  0x10: left PCM        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x10));
         printk("  0x30: analog power    = 0x%02x\n", snd_sonicvibes_in(sonic, 0x30));
-        printk("  0x11: right PCM       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x11));
+        printk(KERN_DEBUG
+               "  0x11: right PCM       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x11));
         printk("  0x31: analog power    = 0x%02x\n", snd_sonicvibes_in(sonic, 0x31));
-        printk("  0x12: DMA data format = 0x%02x  ", snd_sonicvibes_in(sonic, 0x12));
+        printk(KERN_DEBUG
+               "  0x12: DMA data format = 0x%02x  ", snd_sonicvibes_in(sonic, 0x12));
         printk("  0x32: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x32));
-        printk("  0x13: P/C enable      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x13));
+        printk(KERN_DEBUG
+               "  0x13: P/C enable      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x13));
         printk("  0x33: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x33));
-        printk("  0x14: U/D button      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x14));
+        printk(KERN_DEBUG
+               "  0x14: U/D button      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x14));
         printk("  0x34: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x34));
-        printk("  0x15: revision        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x15));
+        printk(KERN_DEBUG
+               "  0x15: revision        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x15));
         printk("  0x35: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x35));
-        printk("  0x16: ADC output ctrl = 0x%02x  ", snd_sonicvibes_in(sonic, 0x16));
+        printk(KERN_DEBUG
+               "  0x16: ADC output ctrl = 0x%02x  ", snd_sonicvibes_in(sonic, 0x16));
         printk("  0x36: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x36));
-        printk("  0x17: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x17));
+        printk(KERN_DEBUG
+               "  0x17: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x17));
         printk("  0x37: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x37));
-        printk("  0x18: DMA A upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x18));
+        printk(KERN_DEBUG
+               "  0x18: DMA A upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x18));
         printk("  0x38: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x38));
-        printk("  0x19: DMA A lower cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x19));
+        printk(KERN_DEBUG
+               "  0x19: DMA A lower cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x19));
         printk("  0x39: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x39));
-        printk("  0x1a: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1a));
+        printk(KERN_DEBUG
+               "  0x1a: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1a));
         printk("  0x3a: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3a));
-        printk("  0x1b: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1b));
+        printk(KERN_DEBUG
+               "  0x1b: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1b));
         printk("  0x3b: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3b));
-        printk("  0x1c: DMA C upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1c));
+        printk(KERN_DEBUG
+               "  0x1c: DMA C upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1c));
         printk("  0x3c: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3c));
-        printk("  0x1d: DMA C upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1d));
+        printk(KERN_DEBUG
+               "  0x1d: DMA C upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1d));
         printk("  0x3d: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3d));
-        printk("  0x1e: PCM rate low    = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1e));
+        printk(KERN_DEBUG
+               "  0x1e: PCM rate low    = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1e));
         printk("  0x3e: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3e));
-        printk("  0x1f: PCM rate high   = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1f));
+        printk(KERN_DEBUG
+               "  0x1f: PCM rate high   = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1f));
         printk("  0x3f: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3f));
 }
 
@@ -476,8 +511,8 @@ static void snd_sonicvibes_pll(unsigned int rate,
         *res_m = m;
         *res_n = n;
 #if 0
-        printk("metric = %i, xm = %i, xn = %i\n", metric, xm, xn);
-        printk("pll: m = 0x%x, r = 0x%x, n = 0x%x\n", reg, m, r, n);
+        printk(KERN_DEBUG "metric = %i, xm = %i, xn = %i\n", metric, xm, xn);
+        printk(KERN_DEBUG "pll: m = 0x%x, r = 0x%x, n = 0x%x\n", reg, m, r, n);
 #endif
 }
 
@@ -1229,8 +1264,8 @@ static int __devinit snd_sonicvibes_create(struct snd_card *card,
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
         /* check, if we can restrict PCI DMA transfers to 24 bits */
-        if (pci_set_dma_mask(pci, DMA_24BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_24BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/trident/trident_main.c b/sound/pci/trident/trident_main.c
index c612b435ca2b..6d943f6f6b70 100644
--- a/sound/pci/trident/trident_main.c
+++ b/sound/pci/trident/trident_main.c
@@ -68,40 +68,40 @@ static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice)
 {
         unsigned int val, tmp;
 
-        printk("Trident voice %i:\n", voice);
+        printk(KERN_DEBUG "Trident voice %i:\n", voice);
         outb(voice, TRID_REG(trident, T4D_LFO_GC_CIR));
         val = inl(TRID_REG(trident, CH_LBA));
-        printk("LBA: 0x%x\n", val);
+        printk(KERN_DEBUG "LBA: 0x%x\n", val);
         val = inl(TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
-        printk("GVSel: %i\n", val >> 31);
-        printk("Pan: 0x%x\n", (val >> 24) & 0x7f);
-        printk("Vol: 0x%x\n", (val >> 16) & 0xff);
-        printk("CTRL: 0x%x\n", (val >> 12) & 0x0f);
-        printk("EC: 0x%x\n", val & 0x0fff);
+        printk(KERN_DEBUG "GVSel: %i\n", val >> 31);
+        printk(KERN_DEBUG "Pan: 0x%x\n", (val >> 24) & 0x7f);
+        printk(KERN_DEBUG "Vol: 0x%x\n", (val >> 16) & 0xff);
+        printk(KERN_DEBUG "CTRL: 0x%x\n", (val >> 12) & 0x0f);
+        printk(KERN_DEBUG "EC: 0x%x\n", val & 0x0fff);
         if (trident->device != TRIDENT_DEVICE_ID_NX) {
                 val = inl(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS));
-                printk("CSO: 0x%x\n", val >> 16);
+                printk(KERN_DEBUG "CSO: 0x%x\n", val >> 16);
                 printk("Alpha: 0x%x\n", (val >> 4) & 0x0fff);
-                printk("FMS: 0x%x\n", val & 0x0f);
+                printk(KERN_DEBUG "FMS: 0x%x\n", val & 0x0f);
                 val = inl(TRID_REG(trident, CH_DX_ESO_DELTA));
-                printk("ESO: 0x%x\n", val >> 16);
-                printk("Delta: 0x%x\n", val & 0xffff);
+                printk(KERN_DEBUG "ESO: 0x%x\n", val >> 16);
+                printk(KERN_DEBUG "Delta: 0x%x\n", val & 0xffff);
                 val = inl(TRID_REG(trident, CH_DX_FMC_RVOL_CVOL));
         } else {                // TRIDENT_DEVICE_ID_NX
                 val = inl(TRID_REG(trident, CH_NX_DELTA_CSO));
                 tmp = (val >> 24) & 0xff;
-                printk("CSO: 0x%x\n", val & 0x00ffffff);
+                printk(KERN_DEBUG "CSO: 0x%x\n", val & 0x00ffffff);
                 val = inl(TRID_REG(trident, CH_NX_DELTA_ESO));
                 tmp |= (val >> 16) & 0xff00;
-                printk("Delta: 0x%x\n", tmp);
-                printk("ESO: 0x%x\n", val & 0x00ffffff);
+                printk(KERN_DEBUG "Delta: 0x%x\n", tmp);
+                printk(KERN_DEBUG "ESO: 0x%x\n", val & 0x00ffffff);
                 val = inl(TRID_REG(trident, CH_NX_ALPHA_FMS_FMC_RVOL_CVOL));
-                printk("Alpha: 0x%x\n", val >> 20);
-                printk("FMS: 0x%x\n", (val >> 16) & 0x0f);
+                printk(KERN_DEBUG "Alpha: 0x%x\n", val >> 20);
+                printk(KERN_DEBUG "FMS: 0x%x\n", (val >> 16) & 0x0f);
         }
-        printk("FMC: 0x%x\n", (val >> 14) & 3);
-        printk("RVol: 0x%x\n", (val >> 7) & 0x7f);
-        printk("CVol: 0x%x\n", val & 0x7f);
+        printk(KERN_DEBUG "FMC: 0x%x\n", (val >> 14) & 3);
+        printk(KERN_DEBUG "RVol: 0x%x\n", (val >> 7) & 0x7f);
+        printk(KERN_DEBUG "CVol: 0x%x\n", val & 0x7f);
 }
 #endif
 
@@ -496,12 +496,17 @@ void snd_trident_write_voice_regs(struct snd_trident * trident,
         outl(regs[4], TRID_REG(trident, CH_START + 16));
 
 #if 0
-        printk("written %i channel:\n", voice->number);
-        printk("  regs[0] = 0x%x/0x%x\n", regs[0], inl(TRID_REG(trident, CH_START + 0)));
-        printk("  regs[1] = 0x%x/0x%x\n", regs[1], inl(TRID_REG(trident, CH_START + 4)));
-        printk("  regs[2] = 0x%x/0x%x\n", regs[2], inl(TRID_REG(trident, CH_START + 8)));
-        printk("  regs[3] = 0x%x/0x%x\n", regs[3], inl(TRID_REG(trident, CH_START + 12)));
-        printk("  regs[4] = 0x%x/0x%x\n", regs[4], inl(TRID_REG(trident, CH_START + 16)));
+        printk(KERN_DEBUG "written %i channel:\n", voice->number);
+        printk(KERN_DEBUG "  regs[0] = 0x%x/0x%x\n",
+               regs[0], inl(TRID_REG(trident, CH_START + 0)));
+        printk(KERN_DEBUG "  regs[1] = 0x%x/0x%x\n",
+               regs[1], inl(TRID_REG(trident, CH_START + 4)));
+        printk(KERN_DEBUG "  regs[2] = 0x%x/0x%x\n",
+               regs[2], inl(TRID_REG(trident, CH_START + 8)));
+        printk(KERN_DEBUG "  regs[3] = 0x%x/0x%x\n",
+               regs[3], inl(TRID_REG(trident, CH_START + 12)));
+        printk(KERN_DEBUG "  regs[4] = 0x%x/0x%x\n",
+               regs[4], inl(TRID_REG(trident, CH_START + 16)));
 #endif
 }
 
@@ -583,7 +588,7 @@ static void snd_trident_write_vol_reg(struct snd_trident * trident,
                 outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
                 break;
         case TRIDENT_DEVICE_ID_SI7018:
-                // printk("voice->Vol = 0x%x\n", voice->Vol);
+                /* printk(KERN_DEBUG "voice->Vol = 0x%x\n", voice->Vol); */
                 outw((voice->CTRL << 12) | voice->Vol,
                      TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
                 break;
@@ -3554,8 +3559,8 @@ int __devinit snd_trident_create(struct snd_card *card,
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
         /* check, if we can restrict PCI DMA transfers to 30 bits */
-        if (pci_set_dma_mask(pci, DMA_30BIT_MASK) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_30BIT_MASK) < 0) {
+        if (pci_set_dma_mask(pci, DMA_BIT_MASK(30)) < 0 ||
+            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(30)) < 0) {
                 snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index d8705547dae1..809b233dd4a3 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -466,7 +466,10 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
                                         flag = VIA_TBL_BIT_FLAG; /* period boundary */
                         } else
                                 flag = 0; /* period continues to the next */
-                        // printk("via: tbl %d: at %d  size %d (rest %d)\n", idx, ofs, r, rest);
+                        /*
+                        printk(KERN_DEBUG "via: tbl %d: at %d  size %d "
+                               "(rest %d)\n", idx, ofs, r, rest);
+                        */
                         ((u32 *)dev->table.area)[(idx<<1) + 1] = cpu_to_le32(r | flag);
                         dev->idx_table[idx].offset = ofs;
                         dev->idx_table[idx].size = r;
@@ -2360,14 +2363,14 @@ static struct snd_pci_quirk dxs_whitelist[] __devinitdata = {
         SND_PCI_QUIRK(0x1019, 0x0996, "ESC Mobo", VIA_DXS_48K),
         SND_PCI_QUIRK(0x1019, 0x0a81, "ECS K7VTA3 v8.0", VIA_DXS_NO_VRA),
         SND_PCI_QUIRK(0x1019, 0x0a85, "ECS L7VMM2", VIA_DXS_NO_VRA),
-        SND_PCI_QUIRK(0x1019, 0, "ESC K8", VIA_DXS_SRC),
+        SND_PCI_QUIRK_VENDOR(0x1019, "ESC K8", VIA_DXS_SRC),
         SND_PCI_QUIRK(0x1019, 0xaa01, "ESC K8T890-A", VIA_DXS_SRC),
         SND_PCI_QUIRK(0x1025, 0x0033, "Acer Inspire 1353LM", VIA_DXS_NO_VRA),
         SND_PCI_QUIRK(0x1025, 0x0046, "Acer Aspire 1524 WLMi", VIA_DXS_SRC),
-        SND_PCI_QUIRK(0x1043, 0, "ASUS A7/A8", VIA_DXS_NO_VRA),
-        SND_PCI_QUIRK(0x1071, 0, "Diverse Notebook", VIA_DXS_NO_VRA),
+        SND_PCI_QUIRK_VENDOR(0x1043, "ASUS A7/A8", VIA_DXS_NO_VRA),
+        SND_PCI_QUIRK_VENDOR(0x1071, "Diverse Notebook", VIA_DXS_NO_VRA),
         SND_PCI_QUIRK(0x10cf, 0x118e, "FSC Laptop", VIA_DXS_ENABLE),
-        SND_PCI_QUIRK(0x1106, 0, "ASRock", VIA_DXS_SRC),
+        SND_PCI_QUIRK_VENDOR(0x1106, "ASRock", VIA_DXS_SRC),
         SND_PCI_QUIRK(0x1297, 0xa231, "Shuttle AK31v2", VIA_DXS_SRC),
         SND_PCI_QUIRK(0x1297, 0xa232, "Shuttle", VIA_DXS_SRC),
         SND_PCI_QUIRK(0x1297, 0xc160, "Shuttle Sk41G", VIA_DXS_SRC),
@@ -2375,7 +2378,7 @@ static struct snd_pci_quirk dxs_whitelist[] __devinitdata = {
         SND_PCI_QUIRK(0x1462, 0x3800, "MSI KT266", VIA_DXS_ENABLE),
         SND_PCI_QUIRK(0x1462, 0x7120, "MSI KT4V", VIA_DXS_ENABLE),
         SND_PCI_QUIRK(0x1462, 0x7142, "MSI K8MM-V", VIA_DXS_ENABLE),
-        SND_PCI_QUIRK(0x1462, 0, "MSI Mobo", VIA_DXS_SRC),
+        SND_PCI_QUIRK_VENDOR(0x1462, "MSI Mobo", VIA_DXS_SRC),
         SND_PCI_QUIRK(0x147b, 0x1401, "ABIT KD7(-RAID)", VIA_DXS_ENABLE),
         SND_PCI_QUIRK(0x147b, 0x1411, "ABIT VA-20", VIA_DXS_ENABLE),
         SND_PCI_QUIRK(0x147b, 0x1413, "ABIT KV8 Pro", VIA_DXS_ENABLE),
@@ -2389,11 +2392,11 @@ static struct snd_pci_quirk dxs_whitelist[] __devinitdata = {
         SND_PCI_QUIRK(0x161f, 0x2032, "m680x machines", VIA_DXS_48K),
         SND_PCI_QUIRK(0x1631, 0xe004, "PB EasyNote 3174", VIA_DXS_ENABLE),
         SND_PCI_QUIRK(0x1695, 0x3005, "EPoX EP-8K9A", VIA_DXS_ENABLE),
-        SND_PCI_QUIRK(0x1695, 0, "EPoX mobo", VIA_DXS_SRC),
-        SND_PCI_QUIRK(0x16f3, 0, "Jetway K8", VIA_DXS_SRC),
-        SND_PCI_QUIRK(0x1734, 0, "FSC Laptop", VIA_DXS_SRC),
+        SND_PCI_QUIRK_VENDOR(0x1695, "EPoX mobo", VIA_DXS_SRC),
+        SND_PCI_QUIRK_VENDOR(0x16f3, "Jetway K8", VIA_DXS_SRC),
+        SND_PCI_QUIRK_VENDOR(0x1734, "FSC Laptop", VIA_DXS_SRC),
         SND_PCI_QUIRK(0x1849, 0x3059, "ASRock K7VM2", VIA_DXS_NO_VRA),
-        SND_PCI_QUIRK(0x1849, 0, "ASRock mobo", VIA_DXS_SRC),
+        SND_PCI_QUIRK_VENDOR(0x1849, "ASRock mobo", VIA_DXS_SRC),
         SND_PCI_QUIRK(0x1919, 0x200a, "Soltek SL-K8",  VIA_DXS_NO_VRA),
         SND_PCI_QUIRK(0x4005, 0x4710, "MSI K7T266", VIA_DXS_SRC),
         { } /* terminator */
diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c
index c086b762c150..0d54e3503c1e 100644
--- a/sound/pci/via82xx_modem.c
+++ b/sound/pci/via82xx_modem.c
@@ -328,7 +328,10 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
                                         flag = VIA_TBL_BIT_FLAG; /* period boundary */
                         } else
                                 flag = 0; /* period continues to the next */
-                        // printk("via: tbl %d: at %d  size %d (rest %d)\n", idx, ofs, r, rest);
+                        /*
+                        printk(KERN_DEBUG "via: tbl %d: at %d  size %d "
+                               "(rest %d)\n", idx, ofs, r, rest);
+                        */
                         ((u32 *)dev->table.area)[(idx<<1) + 1] = cpu_to_le32(r | flag);
                         dev->idx_table[idx].offset = ofs;
                         dev->idx_table[idx].size = r;
diff --git a/sound/pci/vx222/vx222_ops.c b/sound/pci/vx222/vx222_ops.c
index 7e87f398ff0b..c0efe4491116 100644
--- a/sound/pci/vx222/vx222_ops.c
+++ b/sound/pci/vx222/vx222_ops.c
@@ -107,7 +107,9 @@ static unsigned char vx2_inb(struct vx_core *chip, int offset)
 static void vx2_outb(struct vx_core *chip, int offset, unsigned char val)
 {
         outb(val, vx2_reg_addr(chip, offset));
-        //printk("outb: %x -> %x\n", val, vx2_reg_addr(chip, offset));
+        /*
+        printk(KERN_DEBUG "outb: %x -> %x\n", val, vx2_reg_addr(chip, offset));
+        */
 }
 
 /**
@@ -126,7 +128,9 @@ static unsigned int vx2_inl(struct vx_core *chip, int offset)
  */
 static void vx2_outl(struct vx_core *chip, int offset, unsigned int val)
 {
-        // printk("outl: %x -> %x\n", val, vx2_reg_addr(chip, offset));
+        /*
+        printk(KERN_DEBUG "outl: %x -> %x\n", val, vx2_reg_addr(chip, offset));
+        */
         outl(val, vx2_reg_addr(chip, offset));
 }
 
diff --git a/sound/pci/ymfpci/ymfpci_main.c b/sound/pci/ymfpci/ymfpci_main.c
index 90d0d62bd0b4..2f0925236a1b 100644
--- a/sound/pci/ymfpci/ymfpci_main.c
+++ b/sound/pci/ymfpci/ymfpci_main.c
@@ -318,7 +318,12 @@ static void snd_ymfpci_pcm_interrupt(struct snd_ymfpci *chip, struct snd_ymfpci_
                 ypcm->period_pos += delta;
                 ypcm->last_pos = pos;
                 if (ypcm->period_pos >= ypcm->period_size) {
-                        // printk("done - active_bank = 0x%x, start = 0x%x\n", chip->active_bank, voice->bank[chip->active_bank].start);
+                        /*
+                        printk(KERN_DEBUG
+                               "done - active_bank = 0x%x, start = 0x%x\n",
+                               chip->active_bank,
+                               voice->bank[chip->active_bank].start);
+                        */
                         ypcm->period_pos %= ypcm->period_size;
                         spin_unlock(&chip->reg_lock);
                         snd_pcm_period_elapsed(ypcm->substream);
@@ -366,7 +371,12 @@ static void snd_ymfpci_pcm_capture_interrupt(struct snd_pcm_substream *substream
                 ypcm->last_pos = pos;
                 if (ypcm->period_pos >= ypcm->period_size) {
                         ypcm->period_pos %= ypcm->period_size;
-                        // printk("done - active_bank = 0x%x, start = 0x%x\n", chip->active_bank, voice->bank[chip->active_bank].start);
+                        /*
+                        printk(KERN_DEBUG
+                               "done - active_bank = 0x%x, start = 0x%x\n",
+                               chip->active_bank,
+                               voice->bank[chip->active_bank].start);
+                        */
                         spin_unlock(&chip->reg_lock);
                         snd_pcm_period_elapsed(substream);
                         spin_lock(&chip->reg_lock);
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf_core.c b/sound/pcmcia/pdaudiocf/pdaudiocf_core.c
index dfa40b0ed86d..5d2afa0b0ce4 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf_core.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf_core.c
@@ -82,14 +82,21 @@ static void pdacf_ak4117_write(void *private_data, unsigned char reg, unsigned c
 #if 0
 void pdacf_dump(struct snd_pdacf *chip)
 {
-        printk("PDAUDIOCF DUMP (0x%lx):\n", chip->port);
-        printk("WPD         : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_WDP));
-        printk("RDP         : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_RDP));
-        printk("TCR         : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_TCR));
-        printk("SCR         : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_SCR));
-        printk("ISR         : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_ISR));
-        printk("IER         : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_IER));
-        printk("AK_IFR      : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_AK_IFR));
+        printk(KERN_DEBUG "PDAUDIOCF DUMP (0x%lx):\n", chip->port);
+        printk(KERN_DEBUG "WPD         : 0x%x\n",
+               inw(chip->port + PDAUDIOCF_REG_WDP));
+        printk(KERN_DEBUG "RDP         : 0x%x\n",
+               inw(chip->port + PDAUDIOCF_REG_RDP));
+        printk(KERN_DEBUG "TCR         : 0x%x\n",
+               inw(chip->port + PDAUDIOCF_REG_TCR));
+        printk(KERN_DEBUG "SCR         : 0x%x\n",
+               inw(chip->port + PDAUDIOCF_REG_SCR));
+        printk(KERN_DEBUG "ISR         : 0x%x\n",
+               inw(chip->port + PDAUDIOCF_REG_ISR));
+        printk(KERN_DEBUG "IER         : 0x%x\n",
+               inw(chip->port + PDAUDIOCF_REG_IER));
+        printk(KERN_DEBUG "AK_IFR      : 0x%x\n",
+               inw(chip->port + PDAUDIOCF_REG_AK_IFR));
 }
 #endif
 
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf_irq.c b/sound/pcmcia/pdaudiocf/pdaudiocf_irq.c
index ea903c8e90dd..dcd32201bc8c 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf_irq.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf_irq.c
@@ -269,7 +269,7 @@ void pdacf_tasklet(unsigned long private_data)
 
         rdp = inw(chip->port + PDAUDIOCF_REG_RDP);
         wdp = inw(chip->port + PDAUDIOCF_REG_WDP);
-        // printk("TASKLET: rdp = %x, wdp = %x\n", rdp, wdp);
+        /* printk(KERN_DEBUG "TASKLET: rdp = %x, wdp = %x\n", rdp, wdp); */
         size = wdp - rdp;
         if (size < 0)
                 size += 0x10000;
@@ -321,5 +321,5 @@ void pdacf_tasklet(unsigned long private_data)
                 spin_lock(&chip->reg_lock);
         }
         spin_unlock(&chip->reg_lock);
-        // printk("TASKLET: end\n");
+        /* printk(KERN_DEBUG "TASKLET: end\n"); */
 }
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c b/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
index 01066c95580e..d057e6489643 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
@@ -240,7 +240,8 @@ static int pdacf_pcm_prepare(struct snd_pcm_substream *subs)
 static struct snd_pcm_hardware pdacf_pcm_capture_hw = {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                  SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME |
-                                 SNDRV_PCM_INFO_MMAP_VALID),
+                                 SNDRV_PCM_INFO_MMAP_VALID |
+                                 SNDRV_PCM_INFO_BATCH),
         .formats =              SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |
                                 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE |
                                 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
diff --git a/sound/ppc/Kconfig b/sound/ppc/Kconfig
index 777de2b17178..bd2338ab2ced 100644
--- a/sound/ppc/Kconfig
+++ b/sound/ppc/Kconfig
@@ -13,6 +13,7 @@ config SND_POWERMAC
         tristate "PowerMac (AWACS, DACA, Burgundy, Tumbler, Keywest)"
         depends on I2C && INPUT && PPC_PMAC
         select SND_PCM
+        select SND_VMASTER
         help
           Say Y here to include support for the integrated sound device.
 
diff --git a/sound/ppc/awacs.c b/sound/ppc/awacs.c
index 7bd33e6552ab..80df9b1f651e 100644
--- a/sound/ppc/awacs.c
+++ b/sound/ppc/awacs.c
@@ -608,9 +608,12 @@ static struct snd_kcontrol_new snd_pmac_screamer_mixers_beige[] __initdata = {
         AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_LINE, 0),
 };
 
-static struct snd_kcontrol_new snd_pmac_screamer_mixers_imac[] __initdata = {
+static struct snd_kcontrol_new snd_pmac_screamer_mixers_lo[] __initdata = {
         AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
-        AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
+};
+
+static struct snd_kcontrol_new snd_pmac_screamer_mixers_imac[] __initdata = {
+        AWACS_VOLUME("Play-through Playback Volume", 5, 6, 1),
         AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
 };
 
@@ -627,6 +630,10 @@ static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac7500[] __initdata = {
         AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
 };
 
+static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac5500[] __initdata = {
+        AWACS_VOLUME("Headphone Playback Volume", 2, 6, 1),
+};
+
 static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac[] __initdata = {
         AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
         AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
@@ -645,12 +652,19 @@ static struct snd_kcontrol_new snd_pmac_screamer_mixers2[] __initdata = {
         AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
 };
 
+static struct snd_kcontrol_new snd_pmac_awacs_mixers2_pmac5500[] __initdata = {
+        AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
+};
+
 static struct snd_kcontrol_new snd_pmac_awacs_master_sw __initdata =
 AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
 
 static struct snd_kcontrol_new snd_pmac_awacs_master_sw_imac __initdata =
 AWACS_SWITCH("Line out Playback Switch", 1, SHIFT_HDMUTE, 1);
 
+static struct snd_kcontrol_new snd_pmac_awacs_master_sw_pmac5500 __initdata =
+AWACS_SWITCH("Headphone Playback Switch", 1, SHIFT_HDMUTE, 1);
+
 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __initdata = {
         AWACS_SWITCH("Mic Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
 };
@@ -766,12 +780,16 @@ static void snd_pmac_awacs_resume(struct snd_pmac *chip)
 }
 #endif /* CONFIG_PM */
 
-#define IS_PM7500 (machine_is_compatible("AAPL,7500"))
+#define IS_PM7500 (machine_is_compatible("AAPL,7500") \
+                || machine_is_compatible("AAPL,8500") \
+                || machine_is_compatible("AAPL,9500"))
+#define IS_PM5500 (machine_is_compatible("AAPL,e411"))
 #define IS_BEIGE (machine_is_compatible("AAPL,Gossamer"))
 #define IS_IMAC1 (machine_is_compatible("PowerMac2,1"))
 #define IS_IMAC2 (machine_is_compatible("PowerMac2,2") \
                 || machine_is_compatible("PowerMac4,1"))
 #define IS_G4AGP (machine_is_compatible("PowerMac3,1"))
+#define IS_LOMBARD (machine_is_compatible("PowerBook1,1"))
 
 static int imac1, imac2;
 
@@ -858,10 +876,14 @@ int __init
 snd_pmac_awacs_init(struct snd_pmac *chip)
 {
         int pm7500 = IS_PM7500;
+        int pm5500 = IS_PM5500;
         int beige = IS_BEIGE;
         int g4agp = IS_G4AGP;
+        int lombard = IS_LOMBARD;
         int imac;
         int err, vol;
+        struct snd_kcontrol *vmaster_sw, *vmaster_vol;
+        struct snd_kcontrol *master_vol, *speaker_vol;
 
         imac1 = IS_IMAC1;
         imac2 = IS_IMAC2;
@@ -915,7 +937,7 @@ snd_pmac_awacs_init(struct snd_pmac *chip)
                 /* set headphone-jack detection bit */
                 switch (chip->model) {
                 case PMAC_AWACS:
-                        chip->hp_stat_mask = pm7500 ? MASK_HDPCONN
+                        chip->hp_stat_mask = pm7500 || pm5500 ? MASK_HDPCONN
                                 : MASK_LOCONN;
                         break;
                 case PMAC_SCREAMER:
@@ -954,7 +976,7 @@ snd_pmac_awacs_init(struct snd_pmac *chip)
                 return err;
         if (beige || g4agp)
                 ;
-        else if (chip->model == PMAC_SCREAMER)
+        else if (chip->model == PMAC_SCREAMER || pm5500)
                 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
                                    snd_pmac_screamer_mixers2);
         else if (!pm7500)
@@ -962,19 +984,35 @@ snd_pmac_awacs_init(struct snd_pmac *chip)
                                    snd_pmac_awacs_mixers2);
         if (err < 0)
                 return err;
+        if (pm5500) {
+                err = build_mixers(chip,
+                                   ARRAY_SIZE(snd_pmac_awacs_mixers2_pmac5500),
+                                   snd_pmac_awacs_mixers2_pmac5500);
+                if (err < 0)
+                        return err;
+        }
         if (pm7500)
                 err = build_mixers(chip,
                                    ARRAY_SIZE(snd_pmac_awacs_mixers_pmac7500),
                                    snd_pmac_awacs_mixers_pmac7500);
+        else if (pm5500)
+                err = snd_ctl_add(chip->card,
+                    (master_vol = snd_ctl_new1(snd_pmac_awacs_mixers_pmac5500,
+                                                chip)));
         else if (beige)
                 err = build_mixers(chip,
                                    ARRAY_SIZE(snd_pmac_screamer_mixers_beige),
                                    snd_pmac_screamer_mixers_beige);
-        else if (imac)
+        else if (imac || lombard) {
+                err = snd_ctl_add(chip->card,
+                    (master_vol = snd_ctl_new1(snd_pmac_screamer_mixers_lo,
+                                                chip)));
+                if (err < 0)
+                        return err;
                 err = build_mixers(chip,
                                    ARRAY_SIZE(snd_pmac_screamer_mixers_imac),
                                    snd_pmac_screamer_mixers_imac);
-        else if (g4agp)
+        } else if (g4agp)
                 err = build_mixers(chip,
                                    ARRAY_SIZE(snd_pmac_screamer_mixers_g4agp),
                                    snd_pmac_screamer_mixers_g4agp);
@@ -984,8 +1022,10 @@ snd_pmac_awacs_init(struct snd_pmac *chip)
                                    snd_pmac_awacs_mixers_pmac);
         if (err < 0)
                 return err;
-        chip->master_sw_ctl = snd_ctl_new1((pm7500 || imac || g4agp)
+        chip->master_sw_ctl = snd_ctl_new1((pm7500 || imac || g4agp || lombard)
                         ? &snd_pmac_awacs_master_sw_imac
+                        : pm5500
+                        ? &snd_pmac_awacs_master_sw_pmac5500
                         : &snd_pmac_awacs_master_sw, chip);
         err = snd_ctl_add(chip->card, chip->master_sw_ctl);
         if (err < 0)
@@ -1017,8 +1057,9 @@ snd_pmac_awacs_init(struct snd_pmac *chip)
 #endif /* PMAC_AMP_AVAIL */
         {
                 /* route A = headphone, route C = speaker */
-                err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_speaker_vol),
-                                        snd_pmac_awacs_speaker_vol);
+                err = snd_ctl_add(chip->card,
+                    (speaker_vol = snd_ctl_new1(snd_pmac_awacs_speaker_vol,
+                                                chip)));
                 if (err < 0)
                         return err;
                 chip->speaker_sw_ctl = snd_ctl_new1(imac1
@@ -1031,6 +1072,33 @@ snd_pmac_awacs_init(struct snd_pmac *chip)
                         return err;
         }
 
+        if (pm5500 || imac || lombard) {
+                vmaster_sw = snd_ctl_make_virtual_master(
+                        "Master Playback Switch", (unsigned int *) NULL);
+                err = snd_ctl_add_slave_uncached(vmaster_sw,
+                                                 chip->master_sw_ctl);
+                if (err < 0)
+                        return err;
+                err = snd_ctl_add_slave_uncached(vmaster_sw,
+                                                  chip->speaker_sw_ctl);
+                if (err < 0)
+                        return err;
+                err = snd_ctl_add(chip->card, vmaster_sw);
+                if (err < 0)
+                        return err;
+                vmaster_vol = snd_ctl_make_virtual_master(
+                        "Master Playback Volume", (unsigned int *) NULL);
+                err = snd_ctl_add_slave(vmaster_vol, master_vol);
+                if (err < 0)
+                        return err;
+                err = snd_ctl_add_slave(vmaster_vol, speaker_vol);
+                if (err < 0)
+                        return err;
+                err = snd_ctl_add(chip->card, vmaster_vol);
+                if (err < 0)
+                        return err;
+        }
+
         if (beige || g4agp)
                 err = build_mixers(chip,
                                 ARRAY_SIZE(snd_pmac_screamer_mic_boost_beige),
diff --git a/sound/ppc/burgundy.c b/sound/ppc/burgundy.c
index f860d39af36b..45a76297c38d 100644
--- a/sound/ppc/burgundy.c
+++ b/sound/ppc/burgundy.c
@@ -35,7 +35,7 @@ snd_pmac_burgundy_busy_wait(struct snd_pmac *chip)
         int timeout = 50;
         while ((in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) && timeout--)
                 udelay(1);
-        if (! timeout)
+        if (timeout < 0)
                 printk(KERN_DEBUG "burgundy_busy_wait: timeout\n");
 }
 
diff --git a/sound/ppc/daca.c b/sound/ppc/daca.c
index 8a5b29031933..f8d478c2da62 100644
--- a/sound/ppc/daca.c
+++ b/sound/ppc/daca.c
@@ -82,7 +82,7 @@ static int daca_set_volume(struct pmac_daca *mix)
         data[1] |= mix->deemphasis ? 0x40 : 0;
         if (i2c_smbus_write_block_data(mix->i2c.client, DACA_REG_AVOL,
                                        2, data) < 0) {
-                snd_printk("failed to set volume \n");
+                snd_printk(KERN_ERR "failed to set volume \n");
                 return -EINVAL;
         }
         return 0;
diff --git a/sound/ppc/keywest.c b/sound/ppc/keywest.c
index 6ff99ed77516..a5afb2682e7f 100644
--- a/sound/ppc/keywest.c
+++ b/sound/ppc/keywest.c
@@ -33,26 +33,25 @@
 static struct pmac_keywest *keywest_ctx;
 
 
-static int keywest_attach_adapter(struct i2c_adapter *adapter);
-static int keywest_detach_client(struct i2c_client *client);
-
-struct i2c_driver keywest_driver = {  
-        .driver = {
-                .name = "PMac Keywest Audio",
-        },
-        .attach_adapter = &keywest_attach_adapter,
-        .detach_client = &keywest_detach_client,
-};
-
-
 #ifndef i2c_device_name
 #define i2c_device_name(x)      ((x)->name)
 #endif
 
+static int keywest_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        i2c_set_clientdata(client, keywest_ctx);
+        return 0;
+}
+
+/*
+ * This is kind of a hack, best would be to turn powermac to fixed i2c
+ * bus numbers and declare the sound device as part of platform
+ * initialization
+ */
 static int keywest_attach_adapter(struct i2c_adapter *adapter)
 {
-        int err;
-        struct i2c_client *new_client;
+        struct i2c_board_info info;
 
         if (! keywest_ctx)
                 return -EINVAL;
@@ -60,46 +59,47 @@ static int keywest_attach_adapter(struct i2c_adapter *adapter)
         if (strncmp(i2c_device_name(adapter), "mac-io", 6))
                 return 0; /* ignored */
 
-        new_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
-        if (! new_client)
-                return -ENOMEM;
-
-        new_client->addr = keywest_ctx->addr;
-        i2c_set_clientdata(new_client, keywest_ctx);
-        new_client->adapter = adapter;
-        new_client->driver = &keywest_driver;
-        new_client->flags = 0;
-
-        strcpy(i2c_device_name(new_client), keywest_ctx->name);
-        keywest_ctx->client = new_client;
+        memset(&info, 0, sizeof(struct i2c_board_info));
+        strlcpy(info.type, "keywest", I2C_NAME_SIZE);
+        info.addr = keywest_ctx->addr;
+        keywest_ctx->client = i2c_new_device(adapter, &info);
         
-        /* Tell the i2c layer a new client has arrived */
-        if (i2c_attach_client(new_client)) {
-                snd_printk(KERN_ERR "tumbler: cannot attach i2c client\n");
-                err = -ENODEV;
-                goto __err;
-        }
-
+        /*
+         * Let i2c-core delete that device on driver removal.
+         * This is safe because i2c-core holds the core_lock mutex for us.
+         */
+        list_add_tail(&keywest_ctx->client->detected,
+                      &keywest_ctx->client->driver->clients);
         return 0;
-
- __err:
-        kfree(new_client);
-        keywest_ctx->client = NULL;
-        return err;
 }
 
-static int keywest_detach_client(struct i2c_client *client)
+static int keywest_remove(struct i2c_client *client)
 {
+        i2c_set_clientdata(client, NULL);
         if (! keywest_ctx)
                 return 0;
         if (client == keywest_ctx->client)
                 keywest_ctx->client = NULL;
 
-        i2c_detach_client(client);
-        kfree(client);
         return 0;
 }
 
+
+static const struct i2c_device_id keywest_i2c_id[] = {
+        { "keywest", 0 },
+        { }
+};
+
+struct i2c_driver keywest_driver = {
+        .driver = {
+                .name = "PMac Keywest Audio",
+        },
+        .attach_adapter = keywest_attach_adapter,
+        .probe = keywest_probe,
+        .remove = keywest_remove,
+        .id_table = keywest_i2c_id,
+};
+
 /* exported */
 void snd_pmac_keywest_cleanup(struct pmac_keywest *i2c)
 {
diff --git a/sound/ppc/pmac.c b/sound/ppc/pmac.c
index af76ee862d27..9b4e9c316695 100644
--- a/sound/ppc/pmac.c
+++ b/sound/ppc/pmac.c
@@ -299,7 +299,7 @@ static int snd_pmac_pcm_trigger(struct snd_pmac *chip, struct pmac_stream *rec,
         case SNDRV_PCM_TRIGGER_SUSPEND:
                 spin_lock(&chip->reg_lock);
                 rec->running = 0;
-                /*printk("stopped!!\n");*/
+                /*printk(KERN_DEBUG "stopped!!\n");*/
                 snd_pmac_dma_stop(rec);
                 for (i = 0, cp = rec->cmd.cmds; i < rec->nperiods; i++, cp++)
                         out_le16(&cp->command, DBDMA_STOP);
@@ -334,7 +334,7 @@ static snd_pcm_uframes_t snd_pmac_pcm_pointer(struct snd_pmac *chip,
         }
 #endif
         count += rec->cur_period * rec->period_size;
-        /*printk("pointer=%d\n", count);*/
+        /*printk(KERN_DEBUG "pointer=%d\n", count);*/
         return bytes_to_frames(subs->runtime, count);
 }
 
@@ -486,7 +486,7 @@ static void snd_pmac_pcm_update(struct snd_pmac *chip, struct pmac_stream *rec)
                         if (! (stat & ACTIVE))
                                 break;
 
-                        /*printk("update frag %d\n", rec->cur_period);*/
+                        /*printk(KERN_DEBUG "update frag %d\n", rec->cur_period);*/
                         st_le16(&cp->xfer_status, 0);
                         st_le16(&cp->req_count, rec->period_size);
                         /*st_le16(&cp->res_count, 0);*/
@@ -806,7 +806,7 @@ snd_pmac_ctrl_intr(int irq, void *devid)
         struct snd_pmac *chip = devid;
         int ctrl = in_le32(&chip->awacs->control);
 
-        /*printk("pmac: control interrupt.. 0x%x\n", ctrl);*/
+        /*printk(KERN_DEBUG "pmac: control interrupt.. 0x%x\n", ctrl);*/
         if (ctrl & MASK_PORTCHG) {
                 /* do something when headphone is plugged/unplugged? */
                 if (chip->update_automute)
@@ -1033,7 +1033,8 @@ static int __init snd_pmac_detect(struct snd_pmac *chip)
         }
         if (of_device_is_compatible(sound, "tumbler")) {
                 chip->model = PMAC_TUMBLER;
-                chip->can_capture = machine_is_compatible("PowerMac4,2");
+                chip->can_capture = machine_is_compatible("PowerMac4,2")
+                                || machine_is_compatible("PowerBook4,1");
                 chip->can_duplex = 0;
                 // chip->can_byte_swap = 0; /* FIXME: check this */
                 chip->num_freqs = ARRAY_SIZE(tumbler_freqs);
diff --git a/sound/ppc/powermac.c b/sound/ppc/powermac.c
index 2e18ed0ea899..a2b69b8cff43 100644
--- a/sound/ppc/powermac.c
+++ b/sound/ppc/powermac.c
@@ -51,7 +51,7 @@ static struct platform_device *device;
 /*
  */
 
-static int __init snd_pmac_probe(struct platform_device *devptr)
+static int __devinit snd_pmac_probe(struct platform_device *devptr)
 {
         struct snd_card *card;
         struct snd_pmac *chip;
@@ -110,7 +110,7 @@ static int __init snd_pmac_probe(struct platform_device *devptr)
                         goto __error;
                 break;
         default:
-                snd_printk("unsupported hardware %d\n", chip->model);
+                snd_printk(KERN_ERR "unsupported hardware %d\n", chip->model);
                 err = -EINVAL;
                 goto __error;
         }
diff --git a/sound/ppc/snd_ps3.c b/sound/ppc/snd_ps3.c
index ef2c3f417175..f361c26506aa 100644
--- a/sound/ppc/snd_ps3.c
+++ b/sound/ppc/snd_ps3.c
@@ -477,7 +477,7 @@ static int snd_ps3_pcm_prepare(struct snd_pcm_substream *substream)
                 card->dma_start_bus_addr[SND_PS3_CH_R] =
                         runtime->dma_addr + (runtime->dma_bytes / 2);
 
-                pr_debug("%s: vaddr=%p bus=%#lx\n", __func__,
+                pr_debug("%s: vaddr=%p bus=%#llx\n", __func__,
                          card->dma_start_vaddr[SND_PS3_CH_L],
                          card->dma_start_bus_addr[SND_PS3_CH_L]);
 
@@ -1028,7 +1028,7 @@ static int __init snd_ps3_driver_probe(struct ps3_system_bus_device *dev)
                 pr_info("%s: nullbuffer alloc failed\n", __func__);
                 goto clean_preallocate;
         }
-        pr_debug("%s: null vaddr=%p dma=%#lx\n", __func__,
+        pr_debug("%s: null vaddr=%p dma=%#llx\n", __func__,
                  the_card.null_buffer_start_vaddr,
                  the_card.null_buffer_start_dma_addr);
         /* set default sample rate/word width */
diff --git a/sound/ppc/tumbler.c b/sound/ppc/tumbler.c
index 3eb223385416..40222fcc0878 100644
--- a/sound/ppc/tumbler.c
+++ b/sound/ppc/tumbler.c
@@ -41,7 +41,7 @@
 #undef DEBUG
 
 #ifdef DEBUG
-#define DBG(fmt...) printk(fmt)
+#define DBG(fmt...) printk(KERN_DEBUG fmt)
 #else
 #define DBG(fmt...)
 #endif
@@ -240,7 +240,7 @@ static int tumbler_set_master_volume(struct pmac_tumbler *mix)
   
         if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_VOL, 6,
                                            block) < 0) {
-                snd_printk("failed to set volume \n");
+                snd_printk(KERN_ERR "failed to set volume \n");
                 return -EINVAL;
         }
         return 0;
@@ -350,7 +350,7 @@ static int tumbler_set_drc(struct pmac_tumbler *mix)
 
         if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
                                            2, val) < 0) {
-                snd_printk("failed to set DRC\n");
+                snd_printk(KERN_ERR "failed to set DRC\n");
                 return -EINVAL;
         }
         return 0;
@@ -386,7 +386,7 @@ static int snapper_set_drc(struct pmac_tumbler *mix)
 
         if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
                                            6, val) < 0) {
-                snd_printk("failed to set DRC\n");
+                snd_printk(KERN_ERR "failed to set DRC\n");
                 return -EINVAL;
         }
         return 0;
@@ -506,7 +506,8 @@ static int tumbler_set_mono_volume(struct pmac_tumbler *mix,
                 block[i] = (vol >> ((info->bytes - i - 1) * 8)) & 0xff;
         if (i2c_smbus_write_i2c_block_data(mix->i2c.client, info->reg,
                                            info->bytes, block) < 0) {
-                snd_printk("failed to set mono volume %d\n", info->index);
+                snd_printk(KERN_ERR "failed to set mono volume %d\n",
+                           info->index);
                 return -EINVAL;
         }
         return 0;
@@ -643,7 +644,7 @@ static int snapper_set_mix_vol1(struct pmac_tumbler *mix, int idx, int ch, int r
         }
         if (i2c_smbus_write_i2c_block_data(mix->i2c.client, reg,
                                            9, block) < 0) {
-                snd_printk("failed to set mono volume %d\n", reg);
+                snd_printk(KERN_ERR "failed to set mono volume %d\n", reg);
                 return -EINVAL;
         }
         return 0;
diff --git a/sound/sh/Kconfig b/sound/sh/Kconfig
index cfc143985802..aed0f90c3919 100644
--- a/sound/sh/Kconfig
+++ b/sound/sh/Kconfig
@@ -15,6 +15,7 @@ config SND_AICA
         tristate "Dreamcast Yamaha AICA sound"
         depends on SH_DREAMCAST
         select SND_PCM
+        select G2_DMA
         help
           ALSA Sound driver for the SEGA Dreamcast console.
 
diff --git a/sound/sh/aica.c b/sound/sh/aica.c
index f551233c5a08..583a3693df75 100644
--- a/sound/sh/aica.c
+++ b/sound/sh/aica.c
@@ -565,7 +565,7 @@ static int load_aica_firmware(void)
         err = request_firmware(&fw_entry, "aica_firmware.bin", &pd->dev);
         if (unlikely(err))
                 return err;
-        /* write firware into memory */
+        /* write firmware into memory */
         spu_disable();
         spu_memload(0, fw_entry->data, fw_entry->size);
         spu_enable();
diff --git a/sound/soc/au1x/dbdma2.c b/sound/soc/au1x/dbdma2.c
index 30490a259148..594c6c5b7838 100644
--- a/sound/soc/au1x/dbdma2.c
+++ b/sound/soc/au1x/dbdma2.c
@@ -82,7 +82,7 @@ static struct au1xpsc_audio_dmadata *au1xpsc_audio_pcmdma[2];
 /* PCM hardware DMA capabilities - platform specific */
 static const struct snd_pcm_hardware au1xpsc_pcm_hardware = {
         .info             = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
-                            SNDRV_PCM_INFO_INTERLEAVED,
+                            SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BATCH,
         .formats          = AU1XPSC_PCM_FMTS,
         .period_bytes_min = AU1XPSC_PERIOD_MIN_BYTES,
         .period_bytes_max = 4096 * 1024 - 1,
diff --git a/sound/soc/blackfin/Kconfig b/sound/soc/blackfin/Kconfig
index 0a2f8f9eff53..811596f4c092 100644
--- a/sound/soc/blackfin/Kconfig
+++ b/sound/soc/blackfin/Kconfig
@@ -42,7 +42,7 @@ config SND_BF5XX_AC97
           You will also need to select the audio interfaces to support below.
 
           Note:
-          AC97 codecs which do not implment the slot-16 mode will not function
+          AC97 codecs which do not implement the slot-16 mode will not function
           properly with this driver. This driver is known to work with the
           Analog Devices line of AC97 codecs.
 
diff --git a/sound/soc/blackfin/bf5xx-ac97-pcm.c b/sound/soc/blackfin/bf5xx-ac97-pcm.c
index 8cfed1a5dcbe..cf0dfb7ca221 100644
--- a/sound/soc/blackfin/bf5xx-ac97-pcm.c
+++ b/sound/soc/blackfin/bf5xx-ac97-pcm.c
@@ -413,7 +413,7 @@ static void bf5xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
                 sport_done(sport_handle);
 }
 
-static u64 bf5xx_pcm_dmamask = DMA_32BIT_MASK;
+static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32);
 
 int bf5xx_pcm_ac97_new(struct snd_card *card, struct snd_soc_dai *dai,
         struct snd_pcm *pcm)
@@ -424,7 +424,7 @@ int bf5xx_pcm_ac97_new(struct snd_card *card, struct snd_soc_dai *dai,
         if (!card->dev->dma_mask)
                 card->dev->dma_mask = &bf5xx_pcm_dmamask;
         if (!card->dev->coherent_dma_mask)
-                card->dev->coherent_dma_mask = DMA_32BIT_MASK;
+                card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
 
         if (dai->playback.channels_min) {
                 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
diff --git a/sound/soc/blackfin/bf5xx-i2s-pcm.c b/sound/soc/blackfin/bf5xx-i2s-pcm.c
index 1318c4f627b7..62fbb8459569 100644
--- a/sound/soc/blackfin/bf5xx-i2s-pcm.c
+++ b/sound/soc/blackfin/bf5xx-i2s-pcm.c
@@ -245,7 +245,7 @@ static void bf5xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
                 sport_done(sport_handle);
 }
 
-static u64 bf5xx_pcm_dmamask = DMA_32BIT_MASK;
+static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32);
 
 int bf5xx_pcm_i2s_new(struct snd_card *card, struct snd_soc_dai *dai,
         struct snd_pcm *pcm)
@@ -256,7 +256,7 @@ int bf5xx_pcm_i2s_new(struct snd_card *card, struct snd_soc_dai *dai,
         if (!card->dev->dma_mask)
                 card->dev->dma_mask = &bf5xx_pcm_dmamask;
         if (!card->dev->coherent_dma_mask)
-                card->dev->coherent_dma_mask = DMA_32BIT_MASK;
+                card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
 
         if (dai->playback.channels_min) {
                 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
diff --git a/sound/soc/fsl/mpc5200_psc_i2s.c b/sound/soc/fsl/mpc5200_psc_i2s.c
index 3aa729df27b5..1111c710118a 100644
--- a/sound/soc/fsl/mpc5200_psc_i2s.c
+++ b/sound/soc/fsl/mpc5200_psc_i2s.c
@@ -504,7 +504,8 @@ static struct snd_soc_dai psc_i2s_dai_template = {
 
 static const struct snd_pcm_hardware psc_i2s_pcm_hardware = {
         .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
-                SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER,
+                SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                SNDRV_PCM_INFO_BATCH,
         .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE |
                    SNDRV_PCM_FMTBIT_S24_BE | SNDRV_PCM_FMTBIT_S32_BE,
         .rate_min = 8000,
diff --git a/sound/soc/omap/omap-pcm.c b/sound/soc/omap/omap-pcm.c
index b078ed537bc3..07cf7f46b584 100644
--- a/sound/soc/omap/omap-pcm.c
+++ b/sound/soc/omap/omap-pcm.c
@@ -328,7 +328,7 @@ int omap_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
         if (!card->dev->dma_mask)
                 card->dev->dma_mask = &omap_pcm_dmamask;
         if (!card->dev->coherent_dma_mask)
-                card->dev->coherent_dma_mask = DMA_32BIT_MASK;
+                card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
 
         if (dai->playback.channels_min) {
                 ret = omap_pcm_preallocate_dma_buffer(pcm,
diff --git a/sound/soc/pxa/corgi.c b/sound/soc/pxa/corgi.c
index 02263e5d8f03..d5be2b30cda5 100644
--- a/sound/soc/pxa/corgi.c
+++ b/sound/soc/pxa/corgi.c
@@ -26,8 +26,6 @@
 #include <sound/soc-dapm.h>
 
 #include <asm/mach-types.h>
-#include <mach/pxa-regs.h>
-#include <mach/hardware.h>
 #include <mach/corgi.h>
 #include <mach/audio.h>
 
diff --git a/sound/soc/pxa/em-x270.c b/sound/soc/pxa/em-x270.c
index fe4a729ea648..949be9c2a01b 100644
--- a/sound/soc/pxa/em-x270.c
+++ b/sound/soc/pxa/em-x270.c
@@ -29,8 +29,6 @@
 #include <sound/soc-dapm.h>
 
 #include <asm/mach-types.h>
-#include <mach/pxa-regs.h>
-#include <mach/hardware.h>
 #include <mach/audio.h>
 
 #include "../codecs/wm9712.h"
diff --git a/sound/soc/pxa/palm27x.c b/sound/soc/pxa/palm27x.c
index 48a73f64500b..44fcc4e01e08 100644
--- a/sound/soc/pxa/palm27x.c
+++ b/sound/soc/pxa/palm27x.c
@@ -200,7 +200,7 @@ static struct snd_soc_device palm27x_snd_devdata = {
 
 static struct platform_device *palm27x_snd_device;
 
-static int __init palm27x_asoc_init(void)
+static int palm27x_asoc_probe(struct platform_device *pdev)
 {
         int ret;
 
@@ -208,6 +208,10 @@ static int __init palm27x_asoc_init(void)
                 machine_is_palmld()))
                 return -ENODEV;
 
+        if (pdev->dev.platform_data)
+                palm27x_ep_gpio = ((struct palm27x_asoc_info *)
+                        (pdev->dev.platform_data))->jack_gpio;
+
         ret = gpio_request(palm27x_ep_gpio, "Headphone Jack");
         if (ret)
                 return ret;
@@ -245,16 +249,31 @@ err_alloc:
         return ret;
 }
 
-static void __exit palm27x_asoc_exit(void)
+static int __devexit palm27x_asoc_remove(struct platform_device *pdev)
 {
         free_irq(gpio_to_irq(palm27x_ep_gpio), NULL);
         gpio_free(palm27x_ep_gpio);
         platform_device_unregister(palm27x_snd_device);
+        return 0;
 }
 
-void __init palm27x_asoc_set_pdata(struct palm27x_asoc_info *data)
+static struct platform_driver palm27x_wm9712_driver = {
+        .probe          = palm27x_asoc_probe,
+        .remove         = __devexit_p(palm27x_asoc_remove),
+        .driver         = {
+                .name           = "palm27x-asoc",
+                .owner          = THIS_MODULE,
+        },
+};
+
+static int __init palm27x_asoc_init(void)
+{
+        return platform_driver_register(&palm27x_wm9712_driver);
+}
+
+static void __exit palm27x_asoc_exit(void)
 {
-        palm27x_ep_gpio = data->jack_gpio;
+        platform_driver_unregister(&palm27x_wm9712_driver);
 }
 
 module_init(palm27x_asoc_init);
diff --git a/sound/soc/pxa/poodle.c b/sound/soc/pxa/poodle.c
index ef7c6c8dc8f1..a51058f66747 100644
--- a/sound/soc/pxa/poodle.c
+++ b/sound/soc/pxa/poodle.c
@@ -27,8 +27,6 @@
 
 #include <asm/mach-types.h>
 #include <asm/hardware/locomo.h>
-#include <mach/pxa-regs.h>
-#include <mach/hardware.h>
 #include <mach/poodle.h>
 #include <mach/audio.h>
 
diff --git a/sound/soc/pxa/pxa-ssp.c b/sound/soc/pxa/pxa-ssp.c
index 74ff69e3ce34..286be31545df 100644
--- a/sound/soc/pxa/pxa-ssp.c
+++ b/sound/soc/pxa/pxa-ssp.c
@@ -30,7 +30,7 @@
 #include <sound/pxa2xx-lib.h>
 
 #include <mach/hardware.h>
-#include <mach/pxa-regs.h>
+#include <mach/dma.h>
 #include <mach/regs-ssp.h>
 #include <mach/audio.h>
 #include <mach/ssp.h>
diff --git a/sound/soc/pxa/pxa2xx-ac97.c b/sound/soc/pxa/pxa2xx-ac97.c
index 01c21c6cdbbc..d9c94d71fa61 100644
--- a/sound/soc/pxa/pxa2xx-ac97.c
+++ b/sound/soc/pxa/pxa2xx-ac97.c
@@ -20,8 +20,8 @@
 #include <sound/pxa2xx-lib.h>
 
 #include <mach/hardware.h>
-#include <mach/pxa-regs.h>
 #include <mach/regs-ac97.h>
+#include <mach/dma.h>
 
 #include "pxa2xx-pcm.h"
 #include "pxa2xx-ac97.h"
diff --git a/sound/soc/pxa/pxa2xx-i2s.c b/sound/soc/pxa/pxa2xx-i2s.c
index e6c24408c5f9..2f4b6e489b78 100644
--- a/sound/soc/pxa/pxa2xx-i2s.c
+++ b/sound/soc/pxa/pxa2xx-i2s.c
@@ -24,7 +24,7 @@
 #include <sound/pxa2xx-lib.h>
 
 #include <mach/hardware.h>
-#include <mach/pxa-regs.h>
+#include <mach/dma.h>
 #include <mach/audio.h>
 
 #include "pxa2xx-pcm.h"
diff --git a/sound/soc/pxa/pxa2xx-pcm.c b/sound/soc/pxa/pxa2xx-pcm.c
index 53b9fb127a6d..d38e39575f51 100644
--- a/sound/soc/pxa/pxa2xx-pcm.c
+++ b/sound/soc/pxa/pxa2xx-pcm.c
@@ -81,7 +81,7 @@ static struct snd_pcm_ops pxa2xx_pcm_ops = {
         .mmap           = pxa2xx_pcm_mmap,
 };
 
-static u64 pxa2xx_pcm_dmamask = DMA_32BIT_MASK;
+static u64 pxa2xx_pcm_dmamask = DMA_BIT_MASK(32);
 
 static int pxa2xx_soc_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
         struct snd_pcm *pcm)
@@ -91,7 +91,7 @@ static int pxa2xx_soc_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
         if (!card->dev->dma_mask)
                 card->dev->dma_mask = &pxa2xx_pcm_dmamask;
         if (!card->dev->coherent_dma_mask)
-                card->dev->coherent_dma_mask = DMA_32BIT_MASK;
+                card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
 
         if (dai->playback.channels_min) {
                 ret = pxa2xx_pcm_preallocate_dma_buffer(pcm,
diff --git a/sound/soc/pxa/spitz.c b/sound/soc/pxa/spitz.c
index 6ca9f53080c6..c4cd2acaacb4 100644
--- a/sound/soc/pxa/spitz.c
+++ b/sound/soc/pxa/spitz.c
@@ -26,8 +26,6 @@
 #include <sound/soc-dapm.h>
 
 #include <asm/mach-types.h>
-#include <mach/pxa-regs.h>
-#include <mach/hardware.h>
 #include <mach/spitz.h>
 #include "../codecs/wm8750.h"
 #include "pxa2xx-pcm.h"
diff --git a/sound/soc/pxa/tosa.c b/sound/soc/pxa/tosa.c
index fc781374b1bf..dbbd3e9d1637 100644
--- a/sound/soc/pxa/tosa.c
+++ b/sound/soc/pxa/tosa.c
@@ -30,8 +30,6 @@
 
 #include <asm/mach-types.h>
 #include <mach/tosa.h>
-#include <mach/pxa-regs.h>
-#include <mach/hardware.h>
 #include <mach/audio.h>
 
 #include "../codecs/wm9712.h"
diff --git a/sound/soc/s3c24xx/s3c24xx-pcm.c b/sound/soc/s3c24xx/s3c24xx-pcm.c
index a9d68fa2b34a..169ddad31575 100644
--- a/sound/soc/s3c24xx/s3c24xx-pcm.c
+++ b/sound/soc/s3c24xx/s3c24xx-pcm.c
@@ -419,7 +419,7 @@ static void s3c24xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
         }
 }
 
-static u64 s3c24xx_pcm_dmamask = DMA_32BIT_MASK;
+static u64 s3c24xx_pcm_dmamask = DMA_BIT_MASK(32);
 
 static int s3c24xx_pcm_new(struct snd_card *card,
         struct snd_soc_dai *dai, struct snd_pcm *pcm)
diff --git a/sound/soc/sh/dma-sh7760.c b/sound/soc/sh/dma-sh7760.c
index 0dad3a0bb920..baddb1242c71 100644
--- a/sound/soc/sh/dma-sh7760.c
+++ b/sound/soc/sh/dma-sh7760.c
@@ -103,7 +103,8 @@ static struct snd_pcm_hardware camelot_pcm_hardware = {
         .info = (SNDRV_PCM_INFO_MMAP |
                 SNDRV_PCM_INFO_INTERLEAVED |
                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                SNDRV_PCM_INFO_MMAP_VALID),
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_BATCH),
         .formats =      DMABRG_FMTS,
         .rates =        DMABRG_RATES,
         .rate_min =             8000,
diff --git a/sound/sparc/amd7930.c b/sound/sparc/amd7930.c
index ba38912614b4..574af56ba8a6 100644
--- a/sound/sparc/amd7930.c
+++ b/sound/sparc/amd7930.c
@@ -954,7 +954,8 @@ static int __devinit snd_amd7930_create(struct snd_card *card,
         amd->regs = of_ioremap(&op->resource[0], 0,
                                resource_size(&op->resource[0]), "amd7930");
         if (!amd->regs) {
-                snd_printk("amd7930-%d: Unable to map chip registers.\n", dev);
+                snd_printk(KERN_ERR
+                           "amd7930-%d: Unable to map chip registers.\n", dev);
                 return -EIO;
         }
 
@@ -962,7 +963,7 @@ static int __devinit snd_amd7930_create(struct snd_card *card,
 
         if (request_irq(irq, snd_amd7930_interrupt,
                         IRQF_DISABLED | IRQF_SHARED, "amd7930", amd)) {
-                snd_printk("amd7930-%d: Unable to grab IRQ %d\n",
+                snd_printk(KERN_ERR "amd7930-%d: Unable to grab IRQ %d\n",
                            dev, irq);
                 snd_amd7930_free(amd);
                 return -EBUSY;
diff --git a/sound/sparc/cs4231.c b/sound/sparc/cs4231.c
index 7d93fa705ccf..8d13d933087d 100644
--- a/sound/sparc/cs4231.c
+++ b/sound/sparc/cs4231.c
@@ -703,7 +703,7 @@ static int snd_cs4231_timer_stop(struct snd_timer *timer)
         return 0;
 }
 
-static void __init snd_cs4231_init(struct snd_cs4231 *chip)
+static void __devinit snd_cs4231_init(struct snd_cs4231 *chip)
 {
         unsigned long flags;
 
@@ -1020,7 +1020,7 @@ static snd_pcm_uframes_t snd_cs4231_capture_pointer(
         return bytes_to_frames(substream->runtime, ptr);
 }
 
-static int __init snd_cs4231_probe(struct snd_cs4231 *chip)
+static int __devinit snd_cs4231_probe(struct snd_cs4231 *chip)
 {
         unsigned long flags;
         int i;
@@ -1219,7 +1219,7 @@ static struct snd_pcm_ops snd_cs4231_capture_ops = {
         .pointer        =       snd_cs4231_capture_pointer,
 };
 
-static int __init snd_cs4231_pcm(struct snd_card *card)
+static int __devinit snd_cs4231_pcm(struct snd_card *card)
 {
         struct snd_cs4231 *chip = card->private_data;
         struct snd_pcm *pcm;
@@ -1248,7 +1248,7 @@ static int __init snd_cs4231_pcm(struct snd_card *card)
         return 0;
 }
 
-static int __init snd_cs4231_timer(struct snd_card *card)
+static int __devinit snd_cs4231_timer(struct snd_card *card)
 {
         struct snd_cs4231 *chip = card->private_data;
         struct snd_timer *timer;
@@ -1499,7 +1499,7 @@ static int snd_cs4231_put_double(struct snd_kcontrol *kcontrol,
   .private_value = (left_reg) | ((right_reg) << 8) | ((shift_left) << 16) | \
                    ((shift_right) << 19) | ((mask) << 24) | ((invert) << 22) }
 
-static struct snd_kcontrol_new snd_cs4231_controls[] __initdata = {
+static struct snd_kcontrol_new snd_cs4231_controls[] __devinitdata = {
 CS4231_DOUBLE("PCM Playback Switch", 0, CS4231_LEFT_OUTPUT,
                 CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
 CS4231_DOUBLE("PCM Playback Volume", 0, CS4231_LEFT_OUTPUT,
@@ -1538,7 +1538,7 @@ CS4231_SINGLE("Line Out Switch", 0, CS4231_PIN_CTRL, 6, 1, 1),
 CS4231_SINGLE("Headphone Out Switch", 0, CS4231_PIN_CTRL, 7, 1, 1)
 };
 
-static int __init snd_cs4231_mixer(struct snd_card *card)
+static int __devinit snd_cs4231_mixer(struct snd_card *card)
 {
         struct snd_cs4231 *chip = card->private_data;
         int err, idx;
@@ -1559,7 +1559,7 @@ static int __init snd_cs4231_mixer(struct snd_card *card)
 
 static int dev;
 
-static int __init cs4231_attach_begin(struct snd_card **rcard)
+static int __devinit cs4231_attach_begin(struct snd_card **rcard)
 {
         struct snd_card *card;
         struct snd_cs4231 *chip;
@@ -1590,7 +1590,7 @@ static int __init cs4231_attach_begin(struct snd_card **rcard)
         return 0;
 }
 
-static int __init cs4231_attach_finish(struct snd_card *card)
+static int __devinit cs4231_attach_finish(struct snd_card *card)
 {
         struct snd_cs4231 *chip = card->private_data;
         int err;
@@ -1794,9 +1794,9 @@ static struct snd_device_ops snd_cs4231_sbus_dev_ops = {
         .dev_free       =       snd_cs4231_sbus_dev_free,
 };
 
-static int __init snd_cs4231_sbus_create(struct snd_card *card,
-                                         struct of_device *op,
-                                         int dev)
+static int __devinit snd_cs4231_sbus_create(struct snd_card *card,
+                                            struct of_device *op,
+                                            int dev)
 {
         struct snd_cs4231 *chip = card->private_data;
         int err;
@@ -1960,9 +1960,9 @@ static struct snd_device_ops snd_cs4231_ebus_dev_ops = {
         .dev_free       =       snd_cs4231_ebus_dev_free,
 };
 
-static int __init snd_cs4231_ebus_create(struct snd_card *card,
-                                         struct of_device *op,
-                                         int dev)
+static int __devinit snd_cs4231_ebus_create(struct snd_card *card,
+                                            struct of_device *op,
+                                            int dev)
 {
         struct snd_cs4231 *chip = card->private_data;
         int err;
diff --git a/sound/sparc/dbri.c b/sound/sparc/dbri.c
index af95ff1e126c..1d2e51b3f918 100644
--- a/sound/sparc/dbri.c
+++ b/sound/sparc/dbri.c
@@ -1975,7 +1975,8 @@ static struct snd_pcm_hardware snd_dbri_pcm_hw = {
         .info           = SNDRV_PCM_INFO_MMAP |
                           SNDRV_PCM_INFO_INTERLEAVED |
                           SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                          SNDRV_PCM_INFO_MMAP_VALID,
+                          SNDRV_PCM_INFO_MMAP_VALID |
+                          SNDRV_PCM_INFO_BATCH,
         .formats        = SNDRV_PCM_FMTBIT_MU_LAW |
                           SNDRV_PCM_FMTBIT_A_LAW |
                           SNDRV_PCM_FMTBIT_U8 |
diff --git a/sound/synth/emux/emux_hwdep.c b/sound/synth/emux/emux_hwdep.c
index 0a5391436add..ff0b2a8fd25b 100644
--- a/sound/synth/emux/emux_hwdep.c
+++ b/sound/synth/emux/emux_hwdep.c
@@ -24,25 +24,6 @@
 #include <asm/uaccess.h>
 #include "emux_voice.h"
 
-/*
- * open the hwdep device
- */
-static int
-snd_emux_hwdep_open(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
-
-/*
- * close the device
- */
-static int
-snd_emux_hwdep_release(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
 
 #define TMP_CLIENT_ID   0x1001
 
@@ -146,8 +127,6 @@ snd_emux_init_hwdep(struct snd_emux *emu)
         emu->hwdep = hw;
         strcpy(hw->name, SNDRV_EMUX_HWDEP_NAME);
         hw->iface = SNDRV_HWDEP_IFACE_EMUX_WAVETABLE;
-        hw->ops.open = snd_emux_hwdep_open;
-        hw->ops.release = snd_emux_hwdep_release;
         hw->ops.ioctl = snd_emux_hwdep_ioctl;
         hw->exclusive = 1;
         hw->private_data = emu;
diff --git a/sound/synth/emux/emux_oss.c b/sound/synth/emux/emux_oss.c
index 5c47b6c09264..87e42206c4ef 100644
--- a/sound/synth/emux/emux_oss.c
+++ b/sound/synth/emux/emux_oss.c
@@ -132,7 +132,7 @@ snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure)
         p = snd_emux_create_port(emu, tmpname, 32,
                                  1, &callback);
         if (p == NULL) {
-                snd_printk("can't create port\n");
+                snd_printk(KERN_ERR "can't create port\n");
                 snd_emux_dec_count(emu);
                 mutex_unlock(&emu->register_mutex);
                 return -ENOMEM;
diff --git a/sound/synth/emux/emux_seq.c b/sound/synth/emux/emux_seq.c
index 335aa2ce2574..ca5f7effb4df 100644
--- a/sound/synth/emux/emux_seq.c
+++ b/sound/synth/emux/emux_seq.c
@@ -74,15 +74,15 @@ snd_emux_init_seq(struct snd_emux *emu, struct snd_card *card, int index)
         emu->client = snd_seq_create_kernel_client(card, index,
                                                    "%s WaveTable", emu->name);
         if (emu->client < 0) {
-                snd_printk("can't create client\n");
+                snd_printk(KERN_ERR "can't create client\n");
                 return -ENODEV;
         }
 
         if (emu->num_ports < 0) {
-                snd_printk("seqports must be greater than zero\n");
+                snd_printk(KERN_WARNING "seqports must be greater than zero\n");
                 emu->num_ports = 1;
         } else if (emu->num_ports >= SNDRV_EMUX_MAX_PORTS) {
-                snd_printk("too many ports."
+                snd_printk(KERN_WARNING "too many ports."
                            "limited max. ports %d\n", SNDRV_EMUX_MAX_PORTS);
                 emu->num_ports = SNDRV_EMUX_MAX_PORTS;
         }
@@ -100,7 +100,7 @@ snd_emux_init_seq(struct snd_emux *emu, struct snd_card *card, int index)
                 p = snd_emux_create_port(emu, tmpname, MIDI_CHANNELS,
                                          0, &pinfo);
                 if (p == NULL) {
-                        snd_printk("can't create port\n");
+                        snd_printk(KERN_ERR "can't create port\n");
                         return -ENOMEM;
                 }
 
@@ -147,12 +147,12 @@ snd_emux_create_port(struct snd_emux *emu, char *name,
 
         /* Allocate structures for this channel */
         if ((p = kzalloc(sizeof(*p), GFP_KERNEL)) == NULL) {
-                snd_printk("no memory\n");
+                snd_printk(KERN_ERR "no memory\n");
                 return NULL;
         }
         p->chset.channels = kcalloc(max_channels, sizeof(struct snd_midi_channel), GFP_KERNEL);
         if (p->chset.channels == NULL) {
-                snd_printk("no memory\n");
+                snd_printk(KERN_ERR "no memory\n");
                 kfree(p);
                 return NULL;
         }
@@ -376,12 +376,12 @@ int snd_emux_init_virmidi(struct snd_emux *emu, struct snd_card *card)
                         goto __error;
                 }
                 emu->vmidi[i] = rmidi;
-                //snd_printk("virmidi %d ok\n", i);
+                /* snd_printk(KERN_DEBUG "virmidi %d ok\n", i); */
         }
         return 0;
 
 __error:
-        //snd_printk("error init..\n");
+        /* snd_printk(KERN_DEBUG "error init..\n"); */
         snd_emux_delete_virmidi(emu);
         return -ENOMEM;
 }
diff --git a/sound/synth/emux/emux_synth.c b/sound/synth/emux/emux_synth.c
index 2cc6f6f79065..3e921b386fd5 100644
--- a/sound/synth/emux/emux_synth.c
+++ b/sound/synth/emux/emux_synth.c
@@ -956,7 +956,8 @@ void snd_emux_lock_voice(struct snd_emux *emu, int voice)
         if (emu->voices[voice].state == SNDRV_EMUX_ST_OFF)
                 emu->voices[voice].state = SNDRV_EMUX_ST_LOCKED;
         else
-                snd_printk("invalid voice for lock %d (state = %x)\n",
+                snd_printk(KERN_WARNING
+                           "invalid voice for lock %d (state = %x)\n",
                            voice, emu->voices[voice].state);
         spin_unlock_irqrestore(&emu->voice_lock, flags);
 }
@@ -973,7 +974,8 @@ void snd_emux_unlock_voice(struct snd_emux *emu, int voice)
         if (emu->voices[voice].state == SNDRV_EMUX_ST_LOCKED)
                 emu->voices[voice].state = SNDRV_EMUX_ST_OFF;
         else
-                snd_printk("invalid voice for unlock %d (state = %x)\n",
+                snd_printk(KERN_WARNING
+                           "invalid voice for unlock %d (state = %x)\n",
                            voice, emu->voices[voice].state);
         spin_unlock_irqrestore(&emu->voice_lock, flags);
 }
diff --git a/sound/synth/emux/soundfont.c b/sound/synth/emux/soundfont.c
index 36d53bd317ed..63c8f45c0c22 100644
--- a/sound/synth/emux/soundfont.c
+++ b/sound/synth/emux/soundfont.c
@@ -133,7 +133,7 @@ snd_soundfont_load(struct snd_sf_list *sflist, const void __user *data,
         int  rc;
 
         if (count < (long)sizeof(patch)) {
-                snd_printk("patch record too small %ld\n", count);
+                snd_printk(KERN_ERR "patch record too small %ld\n", count);
                 return -EINVAL;
         }
         if (copy_from_user(&patch, data, sizeof(patch)))
@@ -143,15 +143,16 @@ snd_soundfont_load(struct snd_sf_list *sflist, const void __user *data,
         data += sizeof(patch);
 
         if (patch.key != SNDRV_OSS_SOUNDFONT_PATCH) {
-                snd_printk("'The wrong kind of patch' %x\n", patch.key);
+                snd_printk(KERN_ERR "The wrong kind of patch %x\n", patch.key);
                 return -EINVAL;
         }
         if (count < patch.len) {
-                snd_printk("Patch too short %ld, need %d\n", count, patch.len);
+                snd_printk(KERN_ERR "Patch too short %ld, need %d\n",
+                           count, patch.len);
                 return -EINVAL;
         }
         if (patch.len < 0) {
-                snd_printk("poor length %d\n", patch.len);
+                snd_printk(KERN_ERR "poor length %d\n", patch.len);
                 return -EINVAL;
         }
 
@@ -195,7 +196,8 @@ snd_soundfont_load(struct snd_sf_list *sflist, const void __user *data,
         case SNDRV_SFNT_REMOVE_INFO:
                 /* patch must be opened */
                 if (!sflist->currsf) {
-                        snd_printk("soundfont: remove_info: patch not opened\n");
+                        snd_printk(KERN_ERR "soundfont: remove_info: "
+                                   "patch not opened\n");
                         rc = -EINVAL;
                 } else {
                         int bank, instr;
@@ -531,7 +533,7 @@ load_info(struct snd_sf_list *sflist, const void __user *data, long count)
                 return -EINVAL;
 
         if (count < (long)sizeof(hdr)) {
-                printk("Soundfont error: invalid patch zone length\n");
+                printk(KERN_ERR "Soundfont error: invalid patch zone length\n");
                 return -EINVAL;
         }
         if (copy_from_user((char*)&hdr, data, sizeof(hdr)))
@@ -541,12 +543,14 @@ load_info(struct snd_sf_list *sflist, const void __user *data, long count)
         count -= sizeof(hdr);
 
         if (hdr.nvoices <= 0 || hdr.nvoices >= 100) {
-                printk("Soundfont error: Illegal voice number %d\n", hdr.nvoices);
+                printk(KERN_ERR "Soundfont error: Illegal voice number %d\n",
+                       hdr.nvoices);
                 return -EINVAL;
         }
 
         if (count < (long)sizeof(struct soundfont_voice_info) * hdr.nvoices) {
-                printk("Soundfont Error: patch length(%ld) is smaller than nvoices(%d)\n",
+                printk(KERN_ERR "Soundfont Error: "
+                       "patch length(%ld) is smaller than nvoices(%d)\n",
                        count, hdr.nvoices);
                 return -EINVAL;
         }
@@ -952,7 +956,7 @@ load_guspatch(struct snd_sf_list *sflist, const char __user *data,
         int rc;
 
         if (count < (long)sizeof(patch)) {
-                snd_printk("patch record too small %ld\n", count);
+                snd_printk(KERN_ERR "patch record too small %ld\n", count);
                 return -EINVAL;
         }
         if (copy_from_user(&patch, data, sizeof(patch)))
@@ -1034,7 +1038,8 @@ load_guspatch(struct snd_sf_list *sflist, const char __user *data,
         /* panning position; -128 - 127 => 0-127 */
         zone->v.pan = (patch.panning + 128) / 2;
 #if 0
-        snd_printk("gus: basefrq=%d (ofs=%d) root=%d,tune=%d, range:%d-%d\n",
+        snd_printk(KERN_DEBUG
+                   "gus: basefrq=%d (ofs=%d) root=%d,tune=%d, range:%d-%d\n",
                    (int)patch.base_freq, zone->v.rate_offset,
                    zone->v.root, zone->v.tune, zone->v.low, zone->v.high);
 #endif
@@ -1068,7 +1073,8 @@ load_guspatch(struct snd_sf_list *sflist, const char __user *data,
                 zone->v.parm.volrelease = 0x8000 | snd_sf_calc_parm_decay(release);
                 zone->v.attenuation = calc_gus_attenuation(patch.env_offset[0]);
 #if 0
-                snd_printk("gus: atkhld=%x, dcysus=%x, volrel=%x, att=%d\n",
+                snd_printk(KERN_DEBUG
+                           "gus: atkhld=%x, dcysus=%x, volrel=%x, att=%d\n",
                            zone->v.parm.volatkhld,
                            zone->v.parm.voldcysus,
                            zone->v.parm.volrelease,
diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig
index 4f0eac9bff1e..523aec188ccf 100644
--- a/sound/usb/Kconfig
+++ b/sound/usb/Kconfig
@@ -48,7 +48,10 @@ config SND_USB_CAIAQ
             * Native Instruments Kore Controller
             * Native Instruments Kore Controller 2
             * Native Instruments Audio Kontrol 1
+            * Native Instruments Audio 4 DJ
             * Native Instruments Audio 8 DJ
+            * Native Instruments Guitar Rig Session I/O
+            * Native Instruments Guitar Rig mobile
 
            To compile this driver as a module, choose M here: the module
            will be called snd-usb-caiaq.
diff --git a/sound/usb/caiaq/Makefile b/sound/usb/caiaq/Makefile
index 23dadd5a11cd..388999653aaa 100644
--- a/sound/usb/caiaq/Makefile
+++ b/sound/usb/caiaq/Makefile
@@ -1,4 +1,4 @@
-snd-usb-caiaq-y := caiaq-device.o caiaq-audio.o caiaq-midi.o caiaq-control.o
-snd-usb-caiaq-$(CONFIG_SND_USB_CAIAQ_INPUT) += caiaq-input.o
+snd-usb-caiaq-y := device.o audio.o midi.o control.o
+snd-usb-caiaq-$(CONFIG_SND_USB_CAIAQ_INPUT) += input.o
 
 obj-$(CONFIG_SND_USB_CAIAQ) += snd-usb-caiaq.o
diff --git a/sound/usb/caiaq/caiaq-audio.c b/sound/usb/caiaq/audio.c
index b3a603325835..b13ce767ac72 100644
--- a/sound/usb/caiaq/caiaq-audio.c
+++ b/sound/usb/caiaq/audio.c
@@ -16,20 +16,14 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */
 
+#include <linux/spinlock.h>
 #include <linux/init.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/interrupt.h>
 #include <linux/usb.h>
-#include <linux/spinlock.h>
 #include <sound/core.h>
-#include <sound/initval.h>
 #include <sound/pcm.h>
-#include <sound/rawmidi.h>
-#include <linux/input.h>
 
-#include "caiaq-device.h"
-#include "caiaq-audio.h"
+#include "device.h"
+#include "audio.h"
 
 #define N_URBS                  32
 #define CLOCK_DRIFT_TOLERANCE   5
@@ -114,6 +108,7 @@ static int stream_start(struct snd_usb_caiaqdev *dev)
         dev->output_panic = 0;
         dev->first_packet = 1;
         dev->streaming = 1;
+        dev->warned = 0;
 
         for (i = 0; i < N_URBS; i++) {
                 ret = usb_submit_urb(dev->data_urbs_in[i], GFP_ATOMIC);
@@ -200,11 +195,14 @@ static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream)
 
         debug("%s(%p)\n", __func__, substream);
         
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                dev->period_out_count[index] = BYTES_PER_SAMPLE + 1;
                 dev->audio_out_buf_pos[index] = BYTES_PER_SAMPLE + 1;
-        else
+        } else {
+                dev->period_in_count[index] = BYTES_PER_SAMPLE;
                 dev->audio_in_buf_pos[index] = BYTES_PER_SAMPLE;
-        
+        }
+
         if (dev->streaming)
                 return 0;
         
@@ -305,8 +303,7 @@ static void check_for_elapsed_periods(struct snd_usb_caiaqdev *dev,
                 if (!sub)
                         continue;
 
-                pb = frames_to_bytes(sub->runtime, 
-                                     sub->runtime->period_size);
+                pb = snd_pcm_lib_period_bytes(sub);
                 cnt = (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
                                         &dev->period_out_count[stream] :
                                         &dev->period_in_count[stream];
@@ -376,6 +373,9 @@ static void read_in_urb_mode2(struct snd_usb_caiaqdev *dev,
 
                 for (stream = 0; stream < dev->n_streams; stream++, i++) {
                         sub = dev->sub_capture[stream];
+                        if (dev->input_panic)
+                                usb_buf[i] = 0;
+
                         if (sub) {
                                 struct snd_pcm_runtime *rt = sub->runtime;
                                 char *audio_buf = rt->dma_area;
@@ -397,6 +397,9 @@ static void read_in_urb(struct snd_usb_caiaqdev *dev,
         if (!dev->streaming)
                 return;
 
+        if (iso->actual_length < dev->bpp)
+                return;
+
         switch (dev->spec.data_alignment) {
         case 0:
                 read_in_urb_mode0(dev, urb, iso);
@@ -406,10 +409,11 @@ static void read_in_urb(struct snd_usb_caiaqdev *dev,
                 break;
         }
 
-        if (dev->input_panic || dev->output_panic) {
+        if ((dev->input_panic || dev->output_panic) && !dev->warned) {
                 debug("streaming error detected %s %s\n", 
                                 dev->input_panic ? "(input)" : "",
                                 dev->output_panic ? "(output)" : "");
+                dev->warned = 1;
         }
 }
 
@@ -638,9 +642,10 @@ int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev *dev)
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_SESSIONIO):
-                dev->samplerates |= SNDRV_PCM_RATE_88200;
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_GUITARRIGMOBILE):
                 dev->samplerates |= SNDRV_PCM_RATE_192000;
-                break;
+                /* fall thru */
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
                 dev->samplerates |= SNDRV_PCM_RATE_88200;
                 break;
diff --git a/sound/usb/caiaq/caiaq-audio.h b/sound/usb/caiaq/audio.h
index 8ab1f8d9529e..8ab1f8d9529e 100644
--- a/sound/usb/caiaq/caiaq-audio.h
+++ b/sound/usb/caiaq/audio.h
diff --git a/sound/usb/caiaq/caiaq-control.c b/sound/usb/caiaq/control.c
index ccd763dd7167..537102ba6b9d 100644
--- a/sound/usb/caiaq/caiaq-control.c
+++ b/sound/usb/caiaq/control.c
@@ -18,17 +18,13 @@
  */
 
 #include <linux/init.h>
-#include <linux/interrupt.h>
 #include <linux/usb.h>
+#include <sound/control.h>
 #include <sound/core.h>
-#include <sound/initval.h>
 #include <sound/pcm.h>
-#include <sound/rawmidi.h>
-#include <sound/control.h>
-#include <linux/input.h>
 
-#include "caiaq-device.h"
-#include "caiaq-control.h"
+#include "device.h"
+#include "control.h"
 
 #define CNT_INTVAL 0x10000
 
@@ -39,12 +35,12 @@ static int control_info(struct snd_kcontrol *kcontrol,
         struct snd_usb_caiaqdev *dev = caiaqdev(chip->card);
         int pos = kcontrol->private_value;
         int is_intval = pos & CNT_INTVAL;
+        unsigned int id = dev->chip.usb_id;
 
         uinfo->count = 1;
         pos &= ~CNT_INTVAL;
 
-        if (dev->chip.usb_id ==
-                USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ)
+        if (id == USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ)
                 && (pos == 0)) {
                 /* current input mode of A8DJ */
                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
@@ -53,6 +49,15 @@ static int control_info(struct snd_kcontrol *kcontrol,
                 return 0;
         }
 
+        if (id == USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ)
+                && (pos == 0)) {
+                /* current input mode of A4DJ */
+                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+                uinfo->value.integer.min = 0;
+                uinfo->value.integer.max = 1;
+                return 0;
+        }
+
         if (is_intval) {
                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
                 uinfo->value.integer.min = 0;
@@ -73,6 +78,14 @@ static int control_get(struct snd_kcontrol *kcontrol,
         struct snd_usb_caiaqdev *dev = caiaqdev(chip->card);
         int pos = kcontrol->private_value;
 
+        if (dev->chip.usb_id ==
+                USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ)) {
+                /* A4DJ has only one control */
+                /* do not expose hardware input mode 0 */
+                ucontrol->value.integer.value[0] = dev->control_state[0] - 1;
+                return 0;
+        }
+
         if (pos & CNT_INTVAL)
                 ucontrol->value.integer.value[0]
                         = dev->control_state[pos & ~CNT_INTVAL];
@@ -90,10 +103,20 @@ static int control_put(struct snd_kcontrol *kcontrol,
         struct snd_usb_caiaqdev *dev = caiaqdev(chip->card);
         int pos = kcontrol->private_value;
 
+        if (dev->chip.usb_id ==
+                USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ)) {
+                /* A4DJ has only one control */
+                /* do not expose hardware input mode 0 */
+                dev->control_state[0] = ucontrol->value.integer.value[0] + 1;
+                snd_usb_caiaq_send_command(dev, EP1_CMD_WRITE_IO,
+                                dev->control_state, sizeof(dev->control_state));
+                return 1;
+        }
+
         if (pos & CNT_INTVAL) {
                 dev->control_state[pos & ~CNT_INTVAL]
                         = ucontrol->value.integer.value[0];
-                snd_usb_caiaq_send_command(dev, EP1_CMD_DIMM_LEDS,
+                snd_usb_caiaq_send_command(dev, EP1_CMD_WRITE_IO,
                                 dev->control_state, sizeof(dev->control_state));
         } else {
                 if (ucontrol->value.integer.value[0])
@@ -243,10 +266,13 @@ static struct caiaq_controller a8dj_controller[] = {
         { "GND lift for TC Vinyl mode",         24 + 0          },
         { "GND lift for TC CD/Line mode",       24 + 1          },
         { "GND lift for phono mode",            24 + 2          },
-        { "GND lift for TC Vinyl mode",         24 + 3          },
         { "Software lock",                      40              }
 };
 
+static struct caiaq_controller a4dj_controller[] = {
+        { "Current input mode", 0 | CNT_INTVAL  }
+};
+
 static int __devinit add_controls(struct caiaq_controller *c, int num,
                                   struct snd_usb_caiaqdev *dev)
 {
@@ -295,6 +321,10 @@ int __devinit snd_usb_caiaq_control_init(struct snd_usb_caiaqdev *dev)
                 ret = add_controls(a8dj_controller,
                         ARRAY_SIZE(a8dj_controller), dev);
                 break;
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
+                ret = add_controls(a4dj_controller,
+                        ARRAY_SIZE(a4dj_controller), dev);
+                break;
         }
 
         return ret;
diff --git a/sound/usb/caiaq/caiaq-control.h b/sound/usb/caiaq/control.h
index 2e7ab1aa4fb3..2e7ab1aa4fb3 100644
--- a/sound/usb/caiaq/caiaq-control.h
+++ b/sound/usb/caiaq/control.h
diff --git a/sound/usb/caiaq/caiaq-device.c b/sound/usb/caiaq/device.c
index 09aed2363cc9..515de1cd2a3e 100644
--- a/sound/usb/caiaq/caiaq-device.c
+++ b/sound/usb/caiaq/device.c
@@ -19,38 +19,33 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */
 
-#include <linux/init.h>
-#include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/init.h>
 #include <linux/usb.h>
-#include <linux/input.h>
-#include <linux/spinlock.h>
-#include <sound/core.h>
 #include <sound/initval.h>
+#include <sound/core.h>
 #include <sound/pcm.h>
-#include <sound/rawmidi.h>
-#include <sound/control.h>
-
-#include "caiaq-device.h"
-#include "caiaq-audio.h"
-#include "caiaq-midi.h"
-#include "caiaq-control.h"
 
-#ifdef CONFIG_SND_USB_CAIAQ_INPUT
-#include "caiaq-input.h"
-#endif
+#include "device.h"
+#include "audio.h"
+#include "midi.h"
+#include "control.h"
+#include "input.h"
 
 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
-MODULE_DESCRIPTION("caiaq USB audio, version 1.3.10");
+MODULE_DESCRIPTION("caiaq USB audio, version 1.3.14");
 MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("{{Native Instruments, RigKontrol2},"
                          "{Native Instruments, RigKontrol3},"
                          "{Native Instruments, Kore Controller},"
                          "{Native Instruments, Kore Controller 2},"
                          "{Native Instruments, Audio Kontrol 1},"
+                         "{Native Instruments, Audio 4 DJ},"
                          "{Native Instruments, Audio 8 DJ},"
-                         "{Native Instruments, Session I/O}}");
+                         "{Native Instruments, Session I/O},"
+                         "{Native Instruments, GuitarRig mobile}");
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */
 static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */
@@ -116,6 +111,16 @@ static struct usb_device_id snd_usb_id_table[] = {
                 .idVendor =     USB_VID_NATIVEINSTRUMENTS,
                 .idProduct =    USB_PID_SESSIONIO
         },
+        {
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     USB_VID_NATIVEINSTRUMENTS,
+                .idProduct =    USB_PID_GUITARRIGMOBILE
+        },
+        {
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     USB_VID_NATIVEINSTRUMENTS,
+                .idProduct =    USB_PID_AUDIO4DJ
+        },
         { /* terminator */ }
 };
 
@@ -239,6 +244,8 @@ int snd_usb_caiaq_set_audio_params (struct snd_usb_caiaqdev *dev,
                 
         if (dev->audio_parm_answer != 1) 
                 debug("unable to set the device's audio params\n");
+        else
+                dev->bpp = bpp;
 
         return dev->audio_parm_answer == 1 ? 0 : -EINVAL;
 }
@@ -300,6 +307,12 @@ static void __devinit setup_card(struct snd_usb_caiaqdev *dev)
                 }
 
                 break;
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
+                /* Audio 4 DJ - default input mode to phono */
+                dev->control_state[0] = 2;
+                snd_usb_caiaq_send_command(dev, EP1_CMD_WRITE_IO,
+                        dev->control_state, 1);
+                break;
         }
         
         if (dev->spec.num_analog_audio_out +
diff --git a/sound/usb/caiaq/caiaq-device.h b/sound/usb/caiaq/device.h
index ab56e738c5fc..4cce1ad7493d 100644
--- a/sound/usb/caiaq/caiaq-device.h
+++ b/sound/usb/caiaq/device.h
@@ -10,8 +10,10 @@
 #define USB_PID_KORECONTROLLER  0x4711
 #define USB_PID_KORECONTROLLER2 0x4712
 #define USB_PID_AK1             0x0815
+#define USB_PID_AUDIO4DJ        0x0839
 #define USB_PID_AUDIO8DJ        0x1978
 #define USB_PID_SESSIONIO       0x1915
+#define USB_PID_GUITARRIGMOBILE 0x0d8d
 
 #define EP1_BUFSIZE 64
 #define CAIAQ_USB_STR_LEN 0xff
@@ -87,9 +89,9 @@ struct snd_usb_caiaqdev {
         int audio_out_buf_pos[MAX_STREAMS];
         int period_in_count[MAX_STREAMS];
         int period_out_count[MAX_STREAMS];
-        int input_panic, output_panic;
+        int input_panic, output_panic, warned;
         char *audio_in_buf, *audio_out_buf;
-        unsigned int samplerates;
+        unsigned int samplerates, bpp;
 
         struct snd_pcm_substream *sub_playback[MAX_STREAMS];
         struct snd_pcm_substream *sub_capture[MAX_STREAMS];
diff --git a/sound/usb/caiaq/caiaq-input.c b/sound/usb/caiaq/input.c
index f743847a5e5a..a48d309bd94c 100644
--- a/sound/usb/caiaq/caiaq-input.c
+++ b/sound/usb/caiaq/input.c
@@ -17,17 +17,12 @@
 */
 
 #include <linux/init.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/input.h>
 #include <linux/usb.h>
 #include <linux/usb/input.h>
-#include <linux/spinlock.h>
-#include <sound/core.h>
-#include <sound/rawmidi.h>
 #include <sound/pcm.h>
-#include "caiaq-device.h"
-#include "caiaq-input.h"
+
+#include "device.h"
+#include "input.h"
 
 static unsigned short keycode_ak1[] =  { KEY_C, KEY_B, KEY_A };
 static unsigned short keycode_rk2[] =  { KEY_1, KEY_2, KEY_3, KEY_4,
diff --git a/sound/usb/caiaq/caiaq-input.h b/sound/usb/caiaq/input.h
index ced535577864..ced535577864 100644
--- a/sound/usb/caiaq/caiaq-input.h
+++ b/sound/usb/caiaq/input.h
diff --git a/sound/usb/caiaq/caiaq-midi.c b/sound/usb/caiaq/midi.c
index f19fd360c936..8fa8cd88d763 100644
--- a/sound/usb/caiaq/caiaq-midi.c
+++ b/sound/usb/caiaq/midi.c
@@ -16,20 +16,13 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */
 
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/interrupt.h>
 #include <linux/usb.h>
-#include <linux/input.h>
-#include <linux/spinlock.h>
-#include <sound/core.h>
 #include <sound/rawmidi.h>
+#include <sound/core.h>
 #include <sound/pcm.h>
 
-#include "caiaq-device.h"
-#include "caiaq-midi.h"
-
+#include "device.h"
+#include "midi.h"
 
 static int snd_usb_caiaq_midi_input_open(struct snd_rawmidi_substream *substream)
 {
diff --git a/sound/usb/caiaq/caiaq-midi.h b/sound/usb/caiaq/midi.h
index 9d16db027fc3..9d16db027fc3 100644
--- a/sound/usb/caiaq/caiaq-midi.h
+++ b/sound/usb/caiaq/midi.h
diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index eec32e1a3020..823296d7d578 100644
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -107,7 +107,7 @@ MODULE_PARM_DESC(ignore_ctl_error,
 #define MAX_PACKS_HS    (MAX_PACKS * 8) /* in high speed mode */
 #define MAX_URBS        8
 #define SYNC_URBS       4       /* always four urbs for sync */
-#define MIN_PACKS_URB   1       /* minimum 1 packet per urb */
+#define MAX_QUEUE       24      /* try not to exceed this queue length, in ms */
 
 struct audioformat {
         struct list_head list;
@@ -121,6 +121,7 @@ struct audioformat {
         unsigned char attributes;       /* corresponding attributes of cs endpoint */
         unsigned char endpoint;         /* endpoint */
         unsigned char ep_attr;          /* endpoint attributes */
+        unsigned char datainterval;     /* log_2 of data packet interval */
         unsigned int maxpacksize;       /* max. packet size */
         unsigned int rates;             /* rate bitmasks */
         unsigned int rate_min, rate_max;        /* min/max rates */
@@ -170,7 +171,6 @@ struct snd_usb_substream {
         unsigned int curframesize;      /* current packet size in frames (for capture) */
         unsigned int fill_max: 1;       /* fill max packet size always */
         unsigned int fmt_type;          /* USB audio format type (1-3) */
-        unsigned int packs_per_ms;      /* packets per millisecond (for playback) */
 
         unsigned int running: 1;        /* running status */
 
@@ -525,7 +525,7 @@ static int snd_usb_audio_next_packet_size(struct snd_usb_substream *subs)
 /*
  * Prepare urb for streaming before playback starts or when paused.
  *
- * We don't have any data, so we send a frame of silence.
+ * We don't have any data, so we send silence.
  */
 static int prepare_nodata_playback_urb(struct snd_usb_substream *subs,
                                        struct snd_pcm_runtime *runtime,
@@ -537,13 +537,13 @@ static int prepare_nodata_playback_urb(struct snd_usb_substream *subs,
 
         offs = 0;
         urb->dev = ctx->subs->dev;
-        urb->number_of_packets = subs->packs_per_ms;
-        for (i = 0; i < subs->packs_per_ms; ++i) {
+        for (i = 0; i < ctx->packets; ++i) {
                 counts = snd_usb_audio_next_packet_size(subs);
                 urb->iso_frame_desc[i].offset = offs * stride;
                 urb->iso_frame_desc[i].length = counts * stride;
                 offs += counts;
         }
+        urb->number_of_packets = ctx->packets;
         urb->transfer_buffer_length = offs * stride;
         memset(urb->transfer_buffer,
                subs->cur_audiofmt->format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0,
@@ -607,9 +607,7 @@ static int prepare_playback_urb(struct snd_usb_substream *subs,
                                 break;
                         }
                 }
-                /* finish at the frame boundary at/after the period boundary */
-                if (period_elapsed &&
-                    (i & (subs->packs_per_ms - 1)) == subs->packs_per_ms - 1)
+                if (period_elapsed) /* finish at the period boundary */
                         break;
         }
         if (subs->hwptr_done + offs > runtime->buffer_size) {
@@ -1034,9 +1032,9 @@ static void release_substream_urbs(struct snd_usb_substream *subs, int force)
 static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int period_bytes,
                                unsigned int rate, unsigned int frame_bits)
 {
-        unsigned int maxsize, n, i;
+        unsigned int maxsize, i;
         int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
-        unsigned int npacks[MAX_URBS], urb_packs, total_packs, packs_per_ms;
+        unsigned int urb_packs, total_packs, packs_per_ms;
 
         /* calculate the frequency in 16.16 format */
         if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
@@ -1067,11 +1065,9 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri
                 packs_per_ms = 8 >> subs->datainterval;
         else
                 packs_per_ms = 1;
-        subs->packs_per_ms = packs_per_ms;
 
         if (is_playback) {
-                urb_packs = nrpacks;
-                urb_packs = max(urb_packs, (unsigned int)MIN_PACKS_URB);
+                urb_packs = max(nrpacks, 1);
                 urb_packs = min(urb_packs, (unsigned int)MAX_PACKS);
         } else
                 urb_packs = 1;
@@ -1079,7 +1075,7 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri
 
         /* decide how many packets to be used */
         if (is_playback) {
-                unsigned int minsize;
+                unsigned int minsize, maxpacks;
                 /* determine how small a packet can be */
                 minsize = (subs->freqn >> (16 - subs->datainterval))
                           * (frame_bits >> 3);
@@ -1088,13 +1084,17 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri
                         minsize -= minsize >> 3;
                 minsize = max(minsize, 1u);
                 total_packs = (period_bytes + minsize - 1) / minsize;
-                /* round up to multiple of packs_per_ms */
-                total_packs = (total_packs + packs_per_ms - 1)
-                                & ~(packs_per_ms - 1);
                 /* we need at least two URBs for queueing */
-                if (total_packs < 2 * MIN_PACKS_URB * packs_per_ms)
-                        total_packs = 2 * MIN_PACKS_URB * packs_per_ms;
+                if (total_packs < 2) {
+                        total_packs = 2;
+                } else {
+                        /* and we don't want too long a queue either */
+                        maxpacks = max(MAX_QUEUE * packs_per_ms, urb_packs * 2);
+                        total_packs = min(total_packs, maxpacks);
+                }
         } else {
+                while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
+                        urb_packs >>= 1;
                 total_packs = MAX_URBS * urb_packs;
         }
         subs->nurbs = (total_packs + urb_packs - 1) / urb_packs;
@@ -1102,31 +1102,11 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri
                 /* too much... */
                 subs->nurbs = MAX_URBS;
                 total_packs = MAX_URBS * urb_packs;
-        }
-        n = total_packs;
-        for (i = 0; i < subs->nurbs; i++) {
-                npacks[i] = n > urb_packs ? urb_packs : n;
-                n -= urb_packs;
-        }
-        if (subs->nurbs <= 1) {
+        } else if (subs->nurbs < 2) {
                 /* too little - we need at least two packets
                  * to ensure contiguous playback/capture
                  */
                 subs->nurbs = 2;
-                npacks[0] = (total_packs + 1) / 2;
-                npacks[1] = total_packs - npacks[0];
-        } else if (npacks[subs->nurbs-1] < MIN_PACKS_URB * packs_per_ms) {
-                /* the last packet is too small.. */
-                if (subs->nurbs > 2) {
-                        /* merge to the first one */
-                        npacks[0] += npacks[subs->nurbs - 1];
-                        subs->nurbs--;
-                } else {
-                        /* divide to two */
-                        subs->nurbs = 2;
-                        npacks[0] = (total_packs + 1) / 2;
-                        npacks[1] = total_packs - npacks[0];
-                }
         }
 
         /* allocate and initialize data urbs */
@@ -1134,7 +1114,8 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri
                 struct snd_urb_ctx *u = &subs->dataurb[i];
                 u->index = i;
                 u->subs = subs;
-                u->packets = npacks[i];
+                u->packets = (i + 1) * total_packs / subs->nurbs
+                        - i * total_packs / subs->nurbs;
                 u->buffer_size = maxsize * u->packets;
                 if (subs->fmt_type == USB_FORMAT_TYPE_II)
                         u->packets++; /* for transfer delimiter */
@@ -1292,14 +1273,14 @@ static int init_usb_sample_rate(struct usb_device *dev, int iface,
                 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
-                        snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep 0x%x\n",
+                        snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep %#x\n",
                                    dev->devnum, iface, fmt->altsetting, rate, ep);
                         return err;
                 }
                 if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR,
                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
-                        snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep 0x%x\n",
+                        snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep %#x\n",
                                    dev->devnum, iface, fmt->altsetting, ep);
                         return 0; /* some devices don't support reading */
                 }
@@ -1365,12 +1346,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
                 subs->datapipe = usb_sndisocpipe(dev, ep);
         else
                 subs->datapipe = usb_rcvisocpipe(dev, ep);
-        if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH &&
-            get_endpoint(alts, 0)->bInterval >= 1 &&
-            get_endpoint(alts, 0)->bInterval <= 4)
-                subs->datainterval = get_endpoint(alts, 0)->bInterval - 1;
-        else
-                subs->datainterval = 0;
+        subs->datainterval = fmt->datainterval;
         subs->syncpipe = subs->syncinterval = 0;
         subs->maxpacksize = fmt->maxpacksize;
         subs->fill_max = 0;
@@ -1431,9 +1407,11 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
         subs->cur_audiofmt = fmt;
 
 #if 0
-        printk("setting done: format = %d, rate = %d..%d, channels = %d\n",
+        printk(KERN_DEBUG
+               "setting done: format = %d, rate = %d..%d, channels = %d\n",
                fmt->format, fmt->rate_min, fmt->rate_max, fmt->channels);
-        printk("  datapipe = 0x%0x, syncpipe = 0x%0x\n",
+        printk(KERN_DEBUG
+               "  datapipe = 0x%0x, syncpipe = 0x%0x\n",
                subs->datapipe, subs->syncpipe);
 #endif
 
@@ -1468,7 +1446,7 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
         channels = params_channels(hw_params);
         fmt = find_format(subs, format, rate, channels);
         if (!fmt) {
-                snd_printd(KERN_DEBUG "cannot set format: format = 0x%x, rate = %d, channels = %d\n",
+                snd_printd(KERN_DEBUG "cannot set format: format = %#x, rate = %d, channels = %d\n",
                            format, rate, channels);
                 return -EINVAL;
         }
@@ -1581,11 +1559,15 @@ static struct snd_pcm_hardware snd_usb_hardware =
 #define hwc_debug(fmt, args...) /**/
 #endif
 
-static int hw_check_valid_format(struct snd_pcm_hw_params *params, struct audioformat *fp)
+static int hw_check_valid_format(struct snd_usb_substream *subs,
+                                 struct snd_pcm_hw_params *params,
+                                 struct audioformat *fp)
 {
         struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
         struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
         struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+        struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
+        unsigned int ptime;
 
         /* check the format */
         if (!snd_mask_test(fmts, fp->format)) {
@@ -1606,6 +1588,14 @@ static int hw_check_valid_format(struct snd_pcm_hw_params *params, struct audiof
                 hwc_debug("   > check: rate_max %d < min %d\n", fp->rate_max, it->min);
                 return 0;
         }
+        /* check whether the period time is >= the data packet interval */
+        if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH) {
+                ptime = 125 * (1 << fp->datainterval);
+                if (ptime > pt->max || (ptime == pt->max && pt->openmax)) {
+                        hwc_debug("   > check: ptime %u > max %u\n", ptime, pt->max);
+                        return 0;
+                }
+        }
         return 1;
 }
 
@@ -1624,7 +1614,7 @@ static int hw_rule_rate(struct snd_pcm_hw_params *params,
         list_for_each(p, &subs->fmt_list) {
                 struct audioformat *fp;
                 fp = list_entry(p, struct audioformat, list);
-                if (!hw_check_valid_format(params, fp))
+                if (!hw_check_valid_format(subs, params, fp))
                         continue;
                 if (changed++) {
                         if (rmin > fp->rate_min)
@@ -1678,7 +1668,7 @@ static int hw_rule_channels(struct snd_pcm_hw_params *params,
         list_for_each(p, &subs->fmt_list) {
                 struct audioformat *fp;
                 fp = list_entry(p, struct audioformat, list);
-                if (!hw_check_valid_format(params, fp))
+                if (!hw_check_valid_format(subs, params, fp))
                         continue;
                 if (changed++) {
                         if (rmin > fp->channels)
@@ -1731,7 +1721,7 @@ static int hw_rule_format(struct snd_pcm_hw_params *params,
         list_for_each(p, &subs->fmt_list) {
                 struct audioformat *fp;
                 fp = list_entry(p, struct audioformat, list);
-                if (!hw_check_valid_format(params, fp))
+                if (!hw_check_valid_format(subs, params, fp))
                         continue;
                 fbits |= (1ULL << fp->format);
         }
@@ -1749,95 +1739,42 @@ static int hw_rule_format(struct snd_pcm_hw_params *params,
         return changed;
 }
 
-#define MAX_MASK        64
-
-/*
- * check whether the registered audio formats need special hw-constraints
- */
-static int check_hw_params_convention(struct snd_usb_substream *subs)
+static int hw_rule_period_time(struct snd_pcm_hw_params *params,
+                               struct snd_pcm_hw_rule *rule)
 {
-        int i;
-        u32 *channels;
-        u32 *rates;
-        u32 cmaster, rmaster;
-        u32 rate_min = 0, rate_max = 0;
-        struct list_head *p;
-        int err = 1;
-
-        channels = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
-        rates = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
-        if (!channels || !rates) {
-                err = -ENOMEM;
-                goto __out;
-        }
+        struct snd_usb_substream *subs = rule->private;
+        struct audioformat *fp;
+        struct snd_interval *it;
+        unsigned char min_datainterval;
+        unsigned int pmin;
+        int changed;
 
-        list_for_each(p, &subs->fmt_list) {
-                struct audioformat *f;
-                f = list_entry(p, struct audioformat, list);
-                /* unconventional channels? */
-                if (f->channels > 32)
-                        goto __out;
-                /* continuous rate min/max matches? */
-                if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
-                        if (rate_min && f->rate_min != rate_min)
-                                goto __out;
-                        if (rate_max && f->rate_max != rate_max)
-                                goto __out;
-                        rate_min = f->rate_min;
-                        rate_max = f->rate_max;
-                }
-                /* combination of continuous rates and fixed rates? */
-                if (rates[f->format] & SNDRV_PCM_RATE_CONTINUOUS) {
-                        if (f->rates != rates[f->format])
-                                goto __out;
-                }
-                if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
-                        if (rates[f->format] && rates[f->format] != f->rates)
-                                goto __out;
-                }
-                channels[f->format] |= (1 << f->channels);
-                rates[f->format] |= f->rates;
-                /* needs knot? */
-                if (f->rates & SNDRV_PCM_RATE_KNOT)
-                        goto __out;
-        }
-        /* check whether channels and rates match for all formats */
-        cmaster = rmaster = 0;
-        for (i = 0; i < MAX_MASK; i++) {
-                if (cmaster != channels[i] && cmaster && channels[i])
-                        goto __out;
-                if (rmaster != rates[i] && rmaster && rates[i])
-                        goto __out;
-                if (channels[i])
-                        cmaster = channels[i];
-                if (rates[i])
-                        rmaster = rates[i];
-        }
-        /* check whether channels match for all distinct rates */
-        memset(channels, 0, MAX_MASK * sizeof(u32));
-        list_for_each(p, &subs->fmt_list) {
-                struct audioformat *f;
-                f = list_entry(p, struct audioformat, list);
-                if (f->rates & SNDRV_PCM_RATE_CONTINUOUS)
+        it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
+        hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max);
+        min_datainterval = 0xff;
+        list_for_each_entry(fp, &subs->fmt_list, list) {
+                if (!hw_check_valid_format(subs, params, fp))
                         continue;
-                for (i = 0; i < 32; i++) {
-                        if (f->rates & (1 << i))
-                                channels[i] |= (1 << f->channels);
-                }
+                min_datainterval = min(min_datainterval, fp->datainterval);
+        }
+        if (min_datainterval == 0xff) {
+                hwc_debug("  --> get emtpy\n");
+                it->empty = 1;
+                return -EINVAL;
         }
-        cmaster = 0;
-        for (i = 0; i < 32; i++) {
-                if (cmaster != channels[i] && cmaster && channels[i])
-                        goto __out;
-                if (channels[i])
-                        cmaster = channels[i];
+        pmin = 125 * (1 << min_datainterval);
+        changed = 0;
+        if (it->min < pmin) {
+                it->min = pmin;
+                it->openmin = 0;
+                changed = 1;
         }
-        err = 0;
-
- __out:
-        kfree(channels);
-        kfree(rates);
-        return err;
+        if (snd_interval_checkempty(it)) {
+                it->empty = 1;
+                return -EINVAL;
+        }
+        hwc_debug("  --> (%u,%u) (changed = %d)\n", it->min, it->max, changed);
+        return changed;
 }
 
 /*
@@ -1885,6 +1822,8 @@ static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime,
 static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
 {
         struct list_head *p;
+        unsigned int pt, ptmin;
+        int param_period_time_if_needed;
         int err;
 
         runtime->hw.formats = subs->formats;
@@ -1894,6 +1833,7 @@ static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substre
         runtime->hw.channels_min = 256;
         runtime->hw.channels_max = 0;
         runtime->hw.rates = 0;
+        ptmin = UINT_MAX;
         /* check min/max rates and channels */
         list_for_each(p, &subs->fmt_list) {
                 struct audioformat *fp;
@@ -1912,42 +1852,54 @@ static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substre
                         runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
                                 fp->frame_size;
                 }
+                pt = 125 * (1 << fp->datainterval);
+                ptmin = min(ptmin, pt);
         }
 
-        /* set the period time minimum 1ms */
-        /* FIXME: high-speed mode allows 125us minimum period, but many parts
-         * in the current code assume the 1ms period.
-         */
+        param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME;
+        if (snd_usb_get_speed(subs->dev) != USB_SPEED_HIGH)
+                /* full speed devices have fixed data packet interval */
+                ptmin = 1000;
+        if (ptmin == 1000)
+                /* if period time doesn't go below 1 ms, no rules needed */
+                param_period_time_if_needed = -1;
         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
-                                     1000 * MIN_PACKS_URB,
-                                     /*(nrpacks * MAX_URBS) * 1000*/ UINT_MAX);
-
-        err = check_hw_params_convention(subs);
-        if (err < 0)
+                                     ptmin, UINT_MAX);
+
+        if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
+                                       hw_rule_rate, subs,
+                                       SNDRV_PCM_HW_PARAM_FORMAT,
+                                       SNDRV_PCM_HW_PARAM_CHANNELS,
+                                       param_period_time_if_needed,
+                                       -1)) < 0)
                 return err;
-        else if (err) {
-                hwc_debug("setting extra hw constraints...\n");
-                if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
-                                               hw_rule_rate, subs,
-                                               SNDRV_PCM_HW_PARAM_FORMAT,
-                                               SNDRV_PCM_HW_PARAM_CHANNELS,
-                                               -1)) < 0)
-                        return err;
-                if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
-                                               hw_rule_channels, subs,
-                                               SNDRV_PCM_HW_PARAM_FORMAT,
-                                               SNDRV_PCM_HW_PARAM_RATE,
-                                               -1)) < 0)
-                        return err;
-                if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
-                                               hw_rule_format, subs,
-                                               SNDRV_PCM_HW_PARAM_RATE,
-                                               SNDRV_PCM_HW_PARAM_CHANNELS,
-                                               -1)) < 0)
-                        return err;
-                if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0)
+        if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
+                                       hw_rule_channels, subs,
+                                       SNDRV_PCM_HW_PARAM_FORMAT,
+                                       SNDRV_PCM_HW_PARAM_RATE,
+                                       param_period_time_if_needed,
+                                       -1)) < 0)
+                return err;
+        if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
+                                       hw_rule_format, subs,
+                                       SNDRV_PCM_HW_PARAM_RATE,
+                                       SNDRV_PCM_HW_PARAM_CHANNELS,
+                                       param_period_time_if_needed,
+                                       -1)) < 0)
+                return err;
+        if (param_period_time_if_needed >= 0) {
+                err = snd_pcm_hw_rule_add(runtime, 0,
+                                          SNDRV_PCM_HW_PARAM_PERIOD_TIME,
+                                          hw_rule_period_time, subs,
+                                          SNDRV_PCM_HW_PARAM_FORMAT,
+                                          SNDRV_PCM_HW_PARAM_CHANNELS,
+                                          SNDRV_PCM_HW_PARAM_RATE,
+                                          -1);
+                if (err < 0)
                         return err;
         }
+        if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0)
+                return err;
         return 0;
 }
 
@@ -2160,7 +2112,8 @@ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct s
                 fp = list_entry(p, struct audioformat, list);
                 snd_iprintf(buffer, "  Interface %d\n", fp->iface);
                 snd_iprintf(buffer, "    Altset %d\n", fp->altsetting);
-                snd_iprintf(buffer, "    Format: 0x%x\n", fp->format);
+                snd_iprintf(buffer, "    Format: %#x (%d bits)\n",
+                            fp->format, snd_pcm_format_width(fp->format));
                 snd_iprintf(buffer, "    Channels: %d\n", fp->channels);
                 snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
                             fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
@@ -2179,8 +2132,11 @@ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct s
                         }
                         snd_iprintf(buffer, "\n");
                 }
+                if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
+                        snd_iprintf(buffer, "    Data packet interval: %d us\n",
+                                    125 * (1 << fp->datainterval));
                 // snd_iprintf(buffer, "    Max Packet Size = %d\n", fp->maxpacksize);
-                // snd_iprintf(buffer, "    EP Attribute = 0x%x\n", fp->attributes);
+                // snd_iprintf(buffer, "    EP Attribute = %#x\n", fp->attributes);
         }
 }
 
@@ -2524,7 +2480,6 @@ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioform
                  * build the rate table and bitmap flags
                  */
                 int r, idx;
-                unsigned int nonzero_rates = 0;
 
                 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
                 if (fp->rate_table == NULL) {
@@ -2532,24 +2487,27 @@ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioform
                         return -1;
                 }
 
-                fp->nr_rates = nr_rates;
-                fp->rate_min = fp->rate_max = combine_triple(&fmt[8]);
+                fp->nr_rates = 0;
+                fp->rate_min = fp->rate_max = 0;
                 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
                         unsigned int rate = combine_triple(&fmt[idx]);
+                        if (!rate)
+                                continue;
                         /* C-Media CM6501 mislabels its 96 kHz altsetting */
                         if (rate == 48000 && nr_rates == 1 &&
-                            chip->usb_id == USB_ID(0x0d8c, 0x0201) &&
+                            (chip->usb_id == USB_ID(0x0d8c, 0x0201) ||
+                             chip->usb_id == USB_ID(0x0d8c, 0x0102)) &&
                             fp->altsetting == 5 && fp->maxpacksize == 392)
                                 rate = 96000;
-                        fp->rate_table[r] = rate;
-                        nonzero_rates |= rate;
-                        if (rate < fp->rate_min)
+                        fp->rate_table[fp->nr_rates] = rate;
+                        if (!fp->rate_min || rate < fp->rate_min)
                                 fp->rate_min = rate;
-                        else if (rate > fp->rate_max)
+                        if (!fp->rate_max || rate > fp->rate_max)
                                 fp->rate_max = rate;
                         fp->rates |= snd_pcm_rate_to_rate_bit(rate);
+                        fp->nr_rates++;
                 }
-                if (!nonzero_rates) {
+                if (!fp->nr_rates) {
                         hwc_debug("All rates were zero. Skipping format!\n");
                         return -1;
                 }
@@ -2619,7 +2577,7 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat
                 fp->format = SNDRV_PCM_FORMAT_MPEG;
                 break;
         default:
-                snd_printd(KERN_INFO "%d:%u:%d : unknown format tag 0x%x is detected.  processed as MPEG.\n",
+                snd_printd(KERN_INFO "%d:%u:%d : unknown format tag %#x is detected.  processed as MPEG.\n",
                            chip->dev->devnum, fp->iface, fp->altsetting, format);
                 fp->format = SNDRV_PCM_FORMAT_MPEG;
                 break;
@@ -2670,6 +2628,17 @@ static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp
         return 0;
 }
 
+static unsigned char parse_datainterval(struct snd_usb_audio *chip,
+                                        struct usb_host_interface *alts)
+{
+        if (snd_usb_get_speed(chip->dev) == USB_SPEED_HIGH &&
+            get_endpoint(alts, 0)->bInterval >= 1 &&
+            get_endpoint(alts, 0)->bInterval <= 4)
+                return get_endpoint(alts, 0)->bInterval - 1;
+        else
+                return 0;
+}
+
 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
                                          int iface, int altno);
 static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
@@ -2775,6 +2744,7 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 fp->altset_idx = i;
                 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
                 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
+                fp->datainterval = parse_datainterval(chip, alts);
                 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
                 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
                         fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
@@ -2817,7 +2787,7 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                         continue;
                 }
 
-                snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint 0x%x\n", dev->devnum, iface_no, altno, fp->endpoint);
+                snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint %#x\n", dev->devnum, iface_no, altno, fp->endpoint);
                 err = add_audio_endpoint(chip, stream, fp);
                 if (err < 0) {
                         kfree(fp->rate_table);
@@ -2966,6 +2936,8 @@ static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
                 return -EINVAL;
         }
         alts = &iface->altsetting[fp->altset_idx];
+        fp->datainterval = parse_datainterval(chip, alts);
+        fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
         usb_set_interface(chip->dev, fp->iface, 0);
         init_usb_pitch(chip->dev, fp->iface, alts, fp);
         init_usb_sample_rate(chip->dev, fp->iface, alts, fp, fp->rate_max);
@@ -3059,6 +3031,7 @@ static int create_uaxx_quirk(struct snd_usb_audio *chip,
         fp->iface = altsd->bInterfaceNumber;
         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
+        fp->datainterval = 0;
         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
 
         switch (fp->maxpacksize) {
@@ -3126,6 +3099,7 @@ static int create_ua1000_quirk(struct snd_usb_audio *chip,
         fp->iface = altsd->bInterfaceNumber;
         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
+        fp->datainterval = parse_datainterval(chip, alts);
         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
         fp->rate_max = fp->rate_min = combine_triple(&alts->extra[8]);
 
@@ -3178,6 +3152,7 @@ static int create_ua101_quirk(struct snd_usb_audio *chip,
         fp->iface = altsd->bInterfaceNumber;
         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
+        fp->datainterval = parse_datainterval(chip, alts);
         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
         fp->rate_max = fp->rate_min = combine_triple(&alts->extra[15]);
 
@@ -3763,7 +3738,7 @@ static int usb_audio_resume(struct usb_interface *intf)
 
 static int __init snd_usb_audio_init(void)
 {
-        if (nrpacks < MIN_PACKS_URB || nrpacks > MAX_PACKS) {
+        if (nrpacks < 1 || nrpacks > MAX_PACKS) {
                 printk(KERN_WARNING "invalid nrpacks value.\n");
                 return -EINVAL;
         }
diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c
index 320641ab5be7..26bad373fe65 100644
--- a/sound/usb/usbmidi.c
+++ b/sound/usb/usbmidi.c
@@ -1625,6 +1625,7 @@ static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi* umidi,
         }
 
         ep_info.out_ep = get_endpoint(hostif, 2)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+        ep_info.out_interval = 0;
         ep_info.out_cables = endpoint->out_cables & 0x5555;
         err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]);
         if (err < 0)
diff --git a/sound/usb/usbmixer.c b/sound/usb/usbmixer.c
index 00397c8a765b..ecb58e7a6245 100644
--- a/sound/usb/usbmixer.c
+++ b/sound/usb/usbmixer.c
@@ -66,6 +66,7 @@ static const struct rc_config {
         { USB_ID(0x041e, 0x3000), 0, 1, 2, 1,  18, 0x0013 }, /* Extigy       */
         { USB_ID(0x041e, 0x3020), 2, 1, 6, 6,  18, 0x0013 }, /* Audigy 2 NX  */
         { USB_ID(0x041e, 0x3040), 2, 2, 6, 6,  2,  0x6e91 }, /* Live! 24-bit */
+        { USB_ID(0x041e, 0x3048), 2, 2, 6, 6,  2,  0x6e91 }, /* Toshiba SB0500 */
 };
 
 struct usb_mixer_interface {
@@ -78,7 +79,6 @@ struct usb_mixer_interface {
 
         /* Sound Blaster remote control stuff */
         const struct rc_config *rc_cfg;
-        unsigned long rc_hwdep_open;
         u32 rc_code;
         wait_queue_head_t rc_waitq;
         struct urb *rc_urb;
@@ -110,6 +110,8 @@ struct mixer_build {
         const struct usbmix_selector_map *selector_map;
 };
 
+#define MAX_CHANNELS    10      /* max logical channels */
+
 struct usb_mixer_elem_info {
         struct usb_mixer_interface *mixer;
         struct usb_mixer_elem_info *next_id_elem; /* list of controls with same id */
@@ -120,6 +122,8 @@ struct usb_mixer_elem_info {
         int channels;
         int val_type;
         int min, max, res;
+        int cached;
+        int cache_val[MAX_CHANNELS];
         u8 initialized;
 };
 
@@ -181,8 +185,6 @@ enum {
         USB_PROC_DCR_RELEASE = 6,
 };
 
-#define MAX_CHANNELS    10      /* max logical channels */
-
 
 /*
  * manual mapping of mixer names
@@ -219,7 +221,10 @@ static int check_ignored_ctl(struct mixer_build *state, int unitid, int control)
         for (p = state->map; p->id; p++) {
                 if (p->id == unitid && ! p->name &&
                     (! control || ! p->control || control == p->control)) {
-                        // printk("ignored control %d:%d\n", unitid, control);
+                        /*
+                        printk(KERN_DEBUG "ignored control %d:%d\n",
+                               unitid, control);
+                        */
                         return 1;
                 }
         }
@@ -376,11 +381,35 @@ static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *
 }
 
 /* channel = 0: master, 1 = first channel */
-static inline int get_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int *value)
+static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval,
+                                  int channel, int *value)
 {
         return get_ctl_value(cval, GET_CUR, (cval->control << 8) | channel, value);
 }
 
+static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
+                             int channel, int index, int *value)
+{
+        int err;
+
+        if (cval->cached & (1 << channel)) {
+                *value = cval->cache_val[index];
+                return 0;
+        }
+        err = get_cur_mix_raw(cval, channel, value);
+        if (err < 0) {
+                if (!cval->mixer->ignore_ctl_error)
+                        snd_printd(KERN_ERR "cannot get current value for "
+                                   "control %d ch %d: err = %d\n",
+                                   cval->control, channel, err);
+                return err;
+        }
+        cval->cached |= 1 << channel;
+        cval->cache_val[index] = *value;
+        return 0;
+}
+
+
 /*
  * set a mixer value
  */
@@ -412,9 +441,17 @@ static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int v
         return set_ctl_value(cval, SET_CUR, validx, value);
 }
 
-static inline int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int value)
+static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
+                             int index, int value)
 {
-        return set_ctl_value(cval, SET_CUR, (cval->control << 8) | channel, value);
+        int err;
+        err = set_ctl_value(cval, SET_CUR, (cval->control << 8) | channel,
+                            value);
+        if (err < 0)
+                return err;
+        cval->cached |= 1 << channel;
+        cval->cache_val[index] = value;
+        return 0;
 }
 
 /*
@@ -718,7 +755,7 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
                 if (cval->min + cval->res < cval->max) {
                         int last_valid_res = cval->res;
                         int saved, test, check;
-                        get_cur_mix_value(cval, minchn, &saved);
+                        get_cur_mix_raw(cval, minchn, &saved);
                         for (;;) {
                                 test = saved;
                                 if (test < cval->max)
@@ -726,8 +763,8 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
                                 else
                                         test -= cval->res;
                                 if (test < cval->min || test > cval->max ||
-                                    set_cur_mix_value(cval, minchn, test) ||
-                                    get_cur_mix_value(cval, minchn, &check)) {
+                                    set_cur_mix_value(cval, minchn, 0, test) ||
+                                    get_cur_mix_raw(cval, minchn, &check)) {
                                         cval->res = last_valid_res;
                                         break;
                                 }
@@ -735,7 +772,7 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
                                         break;
                                 cval->res *= 2;
                         }
-                        set_cur_mix_value(cval, minchn, saved);
+                        set_cur_mix_value(cval, minchn, 0, saved);
                 }
 
                 cval->initialized = 1;
@@ -775,35 +812,25 @@ static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         struct usb_mixer_elem_info *cval = kcontrol->private_data;
         int c, cnt, val, err;
 
+        ucontrol->value.integer.value[0] = cval->min;
         if (cval->cmask) {
                 cnt = 0;
                 for (c = 0; c < MAX_CHANNELS; c++) {
-                        if (cval->cmask & (1 << c)) {
-                                err = get_cur_mix_value(cval, c + 1, &val);
-                                if (err < 0) {
-                                        if (cval->mixer->ignore_ctl_error) {
-                                                ucontrol->value.integer.value[0] = cval->min;
-                                                return 0;
-                                        }
-                                        snd_printd(KERN_ERR "cannot get current value for control %d ch %d: err = %d\n", cval->control, c + 1, err);
-                                        return err;
-                                }
-                                val = get_relative_value(cval, val);
-                                ucontrol->value.integer.value[cnt] = val;
-                                cnt++;
-                        }
+                        if (!(cval->cmask & (1 << c)))
+                                continue;
+                        err = get_cur_mix_value(cval, c + 1, cnt, &val);
+                        if (err < 0)
+                                return cval->mixer->ignore_ctl_error ? 0 : err;
+                        val = get_relative_value(cval, val);
+                        ucontrol->value.integer.value[cnt] = val;
+                        cnt++;
                 }
+                return 0;
         } else {
                 /* master channel */
-                err = get_cur_mix_value(cval, 0, &val);
-                if (err < 0) {
-                        if (cval->mixer->ignore_ctl_error) {
-                                ucontrol->value.integer.value[0] = cval->min;
-                                return 0;
-                        }
-                        snd_printd(KERN_ERR "cannot get current value for control %d master ch: err = %d\n", cval->control, err);
-                        return err;
-                }
+                err = get_cur_mix_value(cval, 0, 0, &val);
+                if (err < 0)
+                        return cval->mixer->ignore_ctl_error ? 0 : err;
                 val = get_relative_value(cval, val);
                 ucontrol->value.integer.value[0] = val;
         }
@@ -820,34 +847,28 @@ static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         if (cval->cmask) {
                 cnt = 0;
                 for (c = 0; c < MAX_CHANNELS; c++) {
-                        if (cval->cmask & (1 << c)) {
-                                err = get_cur_mix_value(cval, c + 1, &oval);
-                                if (err < 0) {
-                                        if (cval->mixer->ignore_ctl_error)
-                                                return 0;
-                                        return err;
-                                }
-                                val = ucontrol->value.integer.value[cnt];
-                                val = get_abs_value(cval, val);
-                                if (oval != val) {
-                                        set_cur_mix_value(cval, c + 1, val);
-                                        changed = 1;
-                                }
-                                get_cur_mix_value(cval, c + 1, &val);
-                                cnt++;
+                        if (!(cval->cmask & (1 << c)))
+                                continue;
+                        err = get_cur_mix_value(cval, c + 1, cnt, &oval);
+                        if (err < 0)
+                                return cval->mixer->ignore_ctl_error ? 0 : err;
+                        val = ucontrol->value.integer.value[cnt];
+                        val = get_abs_value(cval, val);
+                        if (oval != val) {
+                                set_cur_mix_value(cval, c + 1, cnt, val);
+                                changed = 1;
                         }
+                        cnt++;
                 }
         } else {
                 /* master channel */
-                err = get_cur_mix_value(cval, 0, &oval);
-                if (err < 0 && cval->mixer->ignore_ctl_error)
-                        return 0;
+                err = get_cur_mix_value(cval, 0, 0, &oval);
                 if (err < 0)
-                        return err;
+                        return cval->mixer->ignore_ctl_error ? 0 : err;
                 val = ucontrol->value.integer.value[0];
                 val = get_abs_value(cval, val);
                 if (val != oval) {
-                        set_cur_mix_value(cval, 0, val);
+                        set_cur_mix_value(cval, 0, 0, val);
                         changed = 1;
                 }
         }
@@ -1706,7 +1727,8 @@ static void snd_usb_mixer_memory_change(struct usb_mixer_interface *mixer,
                 break;
         /* live24ext: 4 = line-in jack */
         case 3: /* hp-out jack (may actuate Mute) */
-                if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040))
+                if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
+                    mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
                         snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
                 break;
         default:
@@ -1797,24 +1819,6 @@ static void snd_usb_soundblaster_remote_complete(struct urb *urb)
         wake_up(&mixer->rc_waitq);
 }
 
-static int snd_usb_sbrc_hwdep_open(struct snd_hwdep *hw, struct file *file)
-{
-        struct usb_mixer_interface *mixer = hw->private_data;
-
-        if (test_and_set_bit(0, &mixer->rc_hwdep_open))
-                return -EBUSY;
-        return 0;
-}
-
-static int snd_usb_sbrc_hwdep_release(struct snd_hwdep *hw, struct file *file)
-{
-        struct usb_mixer_interface *mixer = hw->private_data;
-
-        clear_bit(0, &mixer->rc_hwdep_open);
-        smp_mb__after_clear_bit();
-        return 0;
-}
-
 static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
                                      long count, loff_t *offset)
 {
@@ -1867,9 +1871,8 @@ static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
         hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
         hwdep->private_data = mixer;
         hwdep->ops.read = snd_usb_sbrc_hwdep_read;
-        hwdep->ops.open = snd_usb_sbrc_hwdep_open;
-        hwdep->ops.release = snd_usb_sbrc_hwdep_release;
         hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
+        hwdep->exclusive = 1;
 
         mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!mixer->rc_urb)
@@ -1956,8 +1959,9 @@ static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
         int i, err;
 
         for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
-                if (i > 1 &&  /* Live24ext has 2 LEDs only */
-                        mixer->chip->usb_id == USB_ID(0x041e, 0x3040))
+                if (i > 1 && /* Live24ext has 2 LEDs only */
+                        (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
+                         mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
                         break; 
                 err = snd_ctl_add(mixer->chip->card,
                                   snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
@@ -1994,7 +1998,8 @@ static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
         snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
         if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
                 jacks = jacks_audigy2nx;
-        else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040))
+        else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
+                 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
                 jacks = jacks_live24ext;
         else
                 return;
@@ -2044,7 +2049,8 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
                 goto _error;
 
         if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020) ||
-            mixer->chip->usb_id == USB_ID(0x041e, 0x3040)) {
+            mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
+            mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) {
                 struct snd_info_entry *entry;
 
                 if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
diff --git a/sound/usb/usbmixer_maps.c b/sound/usb/usbmixer_maps.c
index d755be0ad811..3e5d66cf1f5a 100644
--- a/sound/usb/usbmixer_maps.c
+++ b/sound/usb/usbmixer_maps.c
@@ -261,6 +261,22 @@ static struct usbmix_name_map aureon_51_2_map[] = {
         {} /* terminator */
 };
 
+static struct usbmix_name_map scratch_live_map[] = {
+        /* 1: IT Line 1 (USB streaming) */
+        /* 2: OT Line 1 (Speaker) */
+        /* 3: IT Line 1 (Line connector) */
+        { 4, "Line 1 In" }, /* FU */
+        /* 5: OT Line 1 (USB streaming) */
+        /* 6: IT Line 2 (USB streaming) */
+        /* 7: OT Line 2 (Speaker) */
+        /* 8: IT Line 2 (Line connector) */
+        { 9, "Line 2 In" }, /* FU */
+        /* 10: OT Line 2 (USB streaming) */
+        /* 11: IT Mic (Line connector) */
+        /* 12: OT Mic (USB streaming) */
+        { 0 } /* terminator */
+};
+
 /*
  * Control map entries
  */
@@ -285,6 +301,11 @@ static struct usbmix_ctl_map usbmix_ctl_maps[] = {
                 .map = live24ext_map,
         },
         {
+                .id = USB_ID(0x041e, 0x3048),
+                .map = audigy2nx_map,
+                .selector_map = audigy2nx_selectors,
+        },
+        {
                 /* Hercules DJ Console (Windows Edition) */
                 .id = USB_ID(0x06f8, 0xb000),
                 .ignore_ctl_error = 1,
@@ -311,6 +332,11 @@ static struct usbmix_ctl_map usbmix_ctl_maps[] = {
                 .id = USB_ID(0x0ccd, 0x0028),
                 .map = aureon_51_2_map,
         },
+        {
+                .id = USB_ID(0x13e5, 0x0001),
+                .map = scratch_live_map,
+                .ignore_ctl_error = 1,
+        },
         { 0 } /* terminator */
 };
 
diff --git a/sound/usb/usbquirks.h b/sound/usb/usbquirks.h
index 92115755d98e..647ef5029651 100644
--- a/sound/usb/usbquirks.h
+++ b/sound/usb/usbquirks.h
@@ -39,6 +39,16 @@
         .idProduct = prod, \
         .bInterfaceClass = USB_CLASS_VENDOR_SPEC
 
+/* Creative/Toshiba Multimedia Center SB-0500 */
+{
+        USB_DEVICE(0x041e, 0x3048),
+        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
+                .vendor_name = "Toshiba",
+                .product_name = "SB-0500",
+                .ifnum = QUIRK_NO_INTERFACE
+        }
+},
+
 /* Creative/E-Mu devices */
 {
         USB_DEVICE(0x041e, 0x3010),
@@ -128,6 +138,14 @@
         .bInterfaceClass = USB_CLASS_AUDIO,
         .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
 },
+{
+        USB_DEVICE(0x046d, 0x0990),
+        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
+                .vendor_name = "Logitech, Inc.",
+                .product_name = "QuickCam Pro 9000",
+                .ifnum = QUIRK_NO_INTERFACE
+        }
+},
 
 /*
  * Yamaha devices
diff --git a/sound/usb/usx2y/us122l.c b/sound/usb/usx2y/us122l.c
index 98276aafefe6..a5aae9d67f31 100644
--- a/sound/usb/usx2y/us122l.c
+++ b/sound/usb/usx2y/us122l.c
@@ -349,14 +349,10 @@ static int usb_stream_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
         if (cmd != SNDRV_USB_STREAM_IOCTL_SET_PARAMS)
                 return -ENOTTY;
 
-        cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
-        if (!cfg)
-                return -ENOMEM;
+        cfg = memdup_user((void *)arg, sizeof(*cfg));
+        if (IS_ERR(cfg))
+                return PTR_ERR(cfg);
 
-        if (copy_from_user(cfg, (void *)arg, sizeof(*cfg))) {
-                err = -EFAULT;
-                goto free;
-        }
         if (cfg->version != USB_STREAM_INTERFACE_VERSION) {
                 err = -ENXIO;
                 goto free;
@@ -478,6 +474,14 @@ static bool us122l_create_card(struct snd_card *card)
         return true;
 }
 
+static void snd_us122l_free(struct snd_card *card)
+{
+        struct us122l   *us122l = US122L(card);
+        int             index = us122l->chip.index;
+        if (index >= 0  &&  index < SNDRV_CARDS)
+                snd_us122l_card_used[index] = 0;
+}
+
 static int usx2y_create_card(struct usb_device *device, struct snd_card **cardp)
 {
         int             dev;
@@ -494,7 +498,7 @@ static int usx2y_create_card(struct usb_device *device, struct snd_card **cardp)
         if (err < 0)
                 return err;
         snd_us122l_card_used[US122L(card)->chip.index = dev] = 1;
-
+        card->private_free = snd_us122l_free;
         US122L(card)->chip.dev = device;
         US122L(card)->chip.card = card;
         mutex_init(&US122L(card)->mutex);
@@ -588,7 +592,7 @@ static void snd_us122l_disconnect(struct usb_interface *intf)
         }
 
         usb_put_intf(intf);
-        usb_put_dev(US122L(card)->chip.dev);
+        usb_put_dev(us122l->chip.dev);
 
         while (atomic_read(&us122l->mmap_count))
                 msleep(500);
diff --git a/sound/usb/usx2y/usX2Yhwdep.c b/sound/usb/usx2y/usX2Yhwdep.c
index 1558a5c4094f..f3d8f71265dd 100644
--- a/sound/usb/usx2y/usX2Yhwdep.c
+++ b/sound/usb/usx2y/usX2Yhwdep.c
@@ -30,9 +30,6 @@
 #include "usbusx2y.h"
 #include "usX2Yhwdep.h"
 
-int usX2Y_hwdep_pcm_new(struct snd_card *card);
-
-
 static int snd_us428ctls_vm_fault(struct vm_area_struct *area,
                                   struct vm_fault *vmf)
 {
@@ -106,16 +103,6 @@ static unsigned int snd_us428ctls_poll(struct snd_hwdep *hw, struct file *file,
 }
 
 
-static int snd_usX2Y_hwdep_open(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
-static int snd_usX2Y_hwdep_release(struct snd_hwdep *hw, struct file *file)
-{
-        return 0;
-}
-
 static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw,
                                       struct snd_hwdep_dsp_status *info)
 {
@@ -216,13 +203,12 @@ static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw,
 
         if (access_ok(VERIFY_READ, dsp->image, dsp->length)) {
                 struct usb_device* dev = priv->chip.dev;
-                char *buf = kmalloc(dsp->length, GFP_KERNEL);
-                if (!buf)
-                        return -ENOMEM;
-                if (copy_from_user(buf, dsp->image, dsp->length)) {
-                        kfree(buf);
-                        return -EFAULT;
-                }
+                char *buf;
+
+                buf = memdup_user(dsp->image, dsp->length);
+                if (IS_ERR(buf))
+                        return PTR_ERR(buf);
+
                 err = usb_set_interface(dev, 0, 1);
                 if (err)
                         snd_printk(KERN_ERR "usb_set_interface error \n");
@@ -267,8 +253,6 @@ int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device)
 
         hw->iface = SNDRV_HWDEP_IFACE_USX2Y;
         hw->private_data = usX2Y(card);
-        hw->ops.open = snd_usX2Y_hwdep_open;
-        hw->ops.release = snd_usX2Y_hwdep_release;
         hw->ops.dsp_status = snd_usX2Y_hwdep_dsp_status;
         hw->ops.dsp_load = snd_usX2Y_hwdep_dsp_load;
         hw->ops.mmap = snd_us428ctls_mmap;
diff --git a/sound/usb/usx2y/usb_stream.c b/sound/usb/usx2y/usb_stream.c
index 70b96355ca4c..12ae0340adc0 100644
--- a/sound/usb/usx2y/usb_stream.c
+++ b/sound/usb/usx2y/usb_stream.c
@@ -33,32 +33,26 @@ static unsigned usb_stream_next_packet_size(struct usb_stream_kernel *sk)
 static void playback_prep_freqn(struct usb_stream_kernel *sk, struct urb *urb)
 {
         struct usb_stream *s = sk->s;
-        unsigned l = 0;
-        int pack;
-
-        urb->iso_frame_desc[0].offset = 0;
-        urb->iso_frame_desc[0].length = usb_stream_next_packet_size(sk);
-        sk->out_phase = sk->out_phase_peeked;
-        urb->transfer_buffer_length = urb->iso_frame_desc[0].length;
-
-        for (pack = 1; pack < sk->n_o_ps; pack++) {
-                l = usb_stream_next_packet_size(sk);
-                if (s->idle_outsize + urb->transfer_buffer_length + l >
-                    s->period_size)
+        int pack, lb = 0;
+
+        for (pack = 0; pack < sk->n_o_ps; pack++) {
+                int l = usb_stream_next_packet_size(sk);
+                if (s->idle_outsize + lb + l > s->period_size)
                         goto check;
 
                 sk->out_phase = sk->out_phase_peeked;
-                urb->iso_frame_desc[pack].offset = urb->transfer_buffer_length;
+                urb->iso_frame_desc[pack].offset = lb;
                 urb->iso_frame_desc[pack].length = l;
-                urb->transfer_buffer_length += l;
+                lb += l;
         }
-        snd_printdd(KERN_DEBUG "%i\n", urb->transfer_buffer_length);
+        snd_printdd(KERN_DEBUG "%i\n", lb);
 
 check:
         urb->number_of_packets = pack;
-        s->idle_outsize += urb->transfer_buffer_length - s->period_size;
+        urb->transfer_buffer_length = lb;
+        s->idle_outsize += lb - s->period_size;
         snd_printdd(KERN_DEBUG "idle=%i ul=%i ps=%i\n", s->idle_outsize,
-                    urb->transfer_buffer_length, s->period_size);
+                    lb, s->period_size);
 }
 
 static void init_pipe_urbs(struct usb_stream_kernel *sk, unsigned use_packsize,
@@ -282,21 +276,20 @@ static int usb_stream_prepare_playback(struct usb_stream_kernel *sk,
         struct usb_stream *s = sk->s;
         struct urb *io;
         struct usb_iso_packet_descriptor *id, *od;
-        int p, l = 0;
+        int p = 0, lb = 0, l = 0;
 
         io = sk->idle_outurb;
         od = io->iso_frame_desc;
-        io->transfer_buffer_length = 0;
 
-        for (p = 0; s->sync_packet < 0; ++p, ++s->sync_packet) {
+        for (; s->sync_packet < 0; ++p, ++s->sync_packet) {
                 struct urb *ii = sk->completed_inurb;
                 id = ii->iso_frame_desc +
                         ii->number_of_packets + s->sync_packet;
                 l = id->actual_length;
 
                 od[p].length = l;
-                od[p].offset = io->transfer_buffer_length;
-                io->transfer_buffer_length += l;
+                od[p].offset = lb;
+                lb += l;
         }
 
         for (;
@@ -304,38 +297,38 @@ static int usb_stream_prepare_playback(struct usb_stream_kernel *sk,
              ++p, ++s->sync_packet) {
                 l = inurb->iso_frame_desc[s->sync_packet].actual_length;
 
-                if (s->idle_outsize + io->transfer_buffer_length + l >
-                    s->period_size)
+                if (s->idle_outsize + lb + l > s->period_size)
                         goto check_ok;
 
                 od[p].length = l;
-                od[p].offset = io->transfer_buffer_length;
-                io->transfer_buffer_length += l;
+                od[p].offset = lb;
+                lb += l;
         }
 
 check_ok:
         s->sync_packet -= inurb->number_of_packets;
-        if (s->sync_packet < -2 || s->sync_packet > 0) {
+        if (unlikely(s->sync_packet < -2 || s->sync_packet > 0)) {
                 snd_printk(KERN_WARNING "invalid sync_packet = %i;"
                            " p=%i nop=%i %i %x %x %x > %x\n",
                            s->sync_packet, p, inurb->number_of_packets,
-                           s->idle_outsize + io->transfer_buffer_length + l,
-                           s->idle_outsize, io->transfer_buffer_length,  l,
+                           s->idle_outsize + lb + l,
+                           s->idle_outsize, lb,  l,
                            s->period_size);
                 return -1;
         }
-        if (io->transfer_buffer_length % s->cfg.frame_size) {
+        if (unlikely(lb % s->cfg.frame_size)) {
                 snd_printk(KERN_WARNING"invalid outsize = %i\n",
-                           io->transfer_buffer_length);
+                           lb);
                 return -1;
         }
-        s->idle_outsize += io->transfer_buffer_length - s->period_size;
+        s->idle_outsize += lb - s->period_size;
         io->number_of_packets = p;
-        if (s->idle_outsize > 0) {
-                snd_printk(KERN_WARNING "idle=%i\n", s->idle_outsize);
-                return -1;
-        }
-        return 0;
+        io->transfer_buffer_length = lb;
+        if (s->idle_outsize <= 0)
+                return 0;
+
+        snd_printk(KERN_WARNING "idle=%i\n", s->idle_outsize);
+        return -1;
 }
 
 static void prepare_inurb(int number_of_packets, struct urb *iu)
@@ -557,7 +550,7 @@ static void stream_start(struct usb_stream_kernel *sk,
                 s->idle_insize -= max_diff - max_diff_0;
                 s->idle_insize += urb_size - s->period_size;
                 if (s->idle_insize < 0) {
-                        snd_printk("%i %i %i\n",
+                        snd_printk(KERN_WARNING "%i %i %i\n",
                                    s->idle_insize, urb_size, s->period_size);
                         return;
                 } else if (s->idle_insize == 0) {
diff --git a/sound/usb/usx2y/usbusx2y.c b/sound/usb/usx2y/usbusx2y.c
index af8b84954054..5ce0da23ee96 100644
--- a/sound/usb/usx2y/usbusx2y.c
+++ b/sound/usb/usx2y/usbusx2y.c
@@ -227,9 +227,9 @@ static void i_usX2Y_In04Int(struct urb *urb)
         
         if (usX2Y->US04) {
                 if (0 == usX2Y->US04->submitted)
-                        do
+                        do {
                                 err = usb_submit_urb(usX2Y->US04->urb[usX2Y->US04->submitted++], GFP_ATOMIC);
-                        while (!err && usX2Y->US04->submitted < usX2Y->US04->len);
+                        } while (!err && usX2Y->US04->submitted < usX2Y->US04->len);
         } else
                 if (us428ctls && us428ctls->p4outLast >= 0 && us428ctls->p4outLast < N_us428_p4out_BUFS) {
                         if (us428ctls->p4outLast != us428ctls->p4outSent) {
diff --git a/sound/usb/usx2y/usbusx2yaudio.c b/sound/usb/usx2y/usbusx2yaudio.c
index 9a608fa85155..dd1ab6177840 100644
--- a/sound/usb/usx2y/usbusx2yaudio.c
+++ b/sound/usb/usx2y/usbusx2yaudio.c
@@ -870,7 +870,8 @@ static struct snd_pcm_hardware snd_usX2Y_2c =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                                 SNDRV_PCM_INFO_MMAP_VALID),
+                                 SNDRV_PCM_INFO_MMAP_VALID |
+                                 SNDRV_PCM_INFO_BATCH),
         .formats =                 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
         .rates =                   SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
         .rate_min =                44100,
diff --git a/sound/usb/usx2y/usx2yhwdeppcm.h b/sound/usb/usx2y/usx2yhwdeppcm.h
index c3382fdc386b..9c4fb84b2aa0 100644
--- a/sound/usb/usx2y/usx2yhwdeppcm.h
+++ b/sound/usb/usx2y/usx2yhwdeppcm.h
@@ -18,3 +18,5 @@ struct snd_usX2Y_hwdep_pcm_shm {
         volatile unsigned captured_iso_frames;
         int capture_iso_start;
 };
+
+int usX2Y_hwdep_pcm_new(struct snd_card *card);