Changeset 246

Timestamp:

Aug 22, 2007, 5:33:25 AM (18 years ago)

Author:

Brendan Oakley

Message:

Merged to ALSA 0.9.3

Location:

GPL/branches/alsa-resync1/alsa-kernel

Files:

• core/info.c (modified) (1 diff)
• core/makefile.os2 (modified) (1 diff)
• core/pcm_native.c (modified) (1 diff)
• core/sound.c (modified) (1 diff)
• core/wrappers.c (modified) (1 diff)
• drivers/dummy.c (modified) (2 diffs)
• drivers/mtpav.c (modified) (4 diffs)
• include/sound/ad1848.h (modified) (2 diffs)
• include/sound/adriver.h (modified) (2 diffs)
• include/sound/ak4xxx-adda.h (added)
• include/sound/config.h (modified) (1 diff)
• include/sound/core.h (modified) (2 diffs)
• include/sound/cs4231.h (modified) (1 diff)
• include/sound/driver.h (modified) (1 diff)
• include/sound/es1688.h (modified) (2 diffs)
• include/sound/gus.h (modified) (2 diffs)
• include/sound/hdsp.h (added)
• include/sound/initval.h (modified) (1 diff)
• include/sound/isapnp.h (modified) (1 diff)
• include/sound/snd_wavefront.h (modified) (1 diff)
• include/sound/uda1341.h (modified) (3 diffs)
• include/sound/wavefront.h (modified) (1 diff)
• isa/ad1816a/ad1816a.c (modified) (8 diffs)
• isa/ad1816a/ad1816a_lib.c (modified) (2 diffs)
• isa/ad1848/ad1848_lib.c (modified) (2 diffs)
• isa/als100.c (modified) (10 diffs)
• isa/azt2320.c (modified) (13 diffs)
• isa/cmi8330.c (modified) (18 diffs)
• isa/cs423x/cs4231_lib.c (modified) (5 diffs)
• isa/cs423x/cs4236.c (modified) (20 diffs)
• isa/dt019x.c (modified) (10 diffs)
• isa/es1688/es1688_lib.c (modified) (2 diffs)
• isa/es18xx.c (modified) (29 diffs)
• isa/gus/gus_irq.c (modified) (2 diffs)
• isa/gus/gusmax.c (modified) (1 diff)
• isa/gus/interwave.c (modified) (24 diffs)
• isa/opl3sa2.c (modified) (19 diffs)
• isa/opti9xx/opti92x-ad1848.c (modified) (23 diffs)
• isa/sb/es968.c (modified) (7 diffs)
• isa/sb/sb16.c (modified) (22 diffs)
• isa/sb/sb16_main.c (modified) (2 diffs)
• isa/sb/sb8.c (modified) (4 diffs)
• isa/sb/sb8_main.c (modified) (2 diffs)
• isa/sb/sb8_midi.c (modified) (4 diffs)
• isa/sgalaxy.c (modified) (2 diffs)
• isa/wavefront/wavefront.c (modified) (26 diffs)
• isa/wavefront/wavefront_fx.c (modified) (2 diffs)
• isa/wavefront/wavefront_synth.c (modified) (4 diffs)
• pci/ice1712/ak4xxx.c (moved) (moved from GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ak4524.c ) (4 diffs)
• pci/ice1712/delta.c (modified) (16 diffs)
• pci/ice1712/ews.c (modified) (17 diffs)
• pci/ice1712/ice1712.c (modified) (20 diffs)
• pci/ice1712/ice1712.h (modified) (5 diffs)
• pci/ice1712/ice1724.c (modified) (19 diffs)
• pci/ice1712/makefile.os2 (modified) (1 diff)
• pci/ice1712/revo.c (modified) (6 diffs)
• pci/korg1212/korg1212.c (modified) (31 diffs)
• pci/rme96.c (modified) (3 diffs)
• pci/rme9652/hdsp.c (modified) (109 diffs)
• pci/rme9652/rme9652.c (modified) (7 diffs)
• pci/sonicvibes.c (modified) (2 diffs)
• pci/trident/trident_main.c (modified) (3 diffs)
• pci/ymfpci/ymfpci_main.c (modified) (1 diff)

GPL/branches/alsa-resync1/alsa-kernel/core/info.c

@@ -21 +21 @@
 
 #include <sound/driver.h>
+#include <linux/version.h>
 #include <linux/init.h>
 #include <linux/vmalloc.h>

GPL/branches/alsa-resync1/alsa-kernel/core/makefile.os2

@@ -32 +32 @@
 #
 #===================================================================
-FILE1    = sound.obj init.obj memory.obj memory_wrapper.obj memalloc.obj sgbuf.obj
+FILE1    = sound.obj init.obj memory.obj memalloc.obj sgbuf.obj
 FILE2    = control.obj device.obj misc.obj wrappers.obj 
 #FILE3    = sound_oss.obj info_oss.obj isadma.obj

GPL/branches/alsa-resync1/alsa-kernel/core/pcm_native.c

@@ -21 +21 @@
 
 #include <sound/driver.h>
+#include <linux/version.h>
 #include <linux/mm.h>
 #include <linux/file.h>

GPL/branches/alsa-resync1/alsa-kernel/core/sound.c

@@ -21 +21 @@
 
 #include <sound/driver.h>
+#include <linux/version.h>
 #include <linux/init.h>
 #include <linux/slab.h>

GPL/branches/alsa-resync1/alsa-kernel/core/wrappers.c

@@ -20 +20 @@
  */
 
-#include <linux/version.h>
 #include <linux/config.h>
 #include <linux/module.h>

GPL/branches/alsa-resync1/alsa-kernel/drivers/dummy.c

@@ -20 +20 @@
 
 #include <sound/driver.h>
+#include <linux/version.h>
 #include <linux/init.h>
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
@@ -59 +60 @@
 #define MAX_BUFFER_SIZE         (256 * 1024)
 #define USE_FORMATS             SNDRV_PCM_FMTBIT_S32_LE
-#define USE_CHANNELS_MIN        10
-#define USE_CHANNELS_MAX        10
+#define USE_CHANNELS_MIN        12
+#define USE_CHANNELS_MAX        12
 #define USE_PERIODS_MIN         1
 #define USE_PERIODS_MAX         1024

GPL/branches/alsa-resync1/alsa-kernel/drivers/mtpav.c

@@ -103 +103 @@
  *      defines
  */
-//#define USE_FAKE_MTP //       dont actually read/write to MTP device (for debugging without an actual unit) (does not work yet)
+//#define USE_FAKE_MTP //       don't actually read/write to MTP device (for debugging without an actual unit) (does not work yet)
 
 // parallel port usage masks
@@ -587 +587 @@
 }
 
-static void snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs)
-{
-        mtpav_t *mcard = snd_magic_cast(mtpav_t, dev_id, return);
+static irqreturn_t snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs)
+{
+        mtpav_t *mcard = snd_magic_cast(mtpav_t, dev_id, return IRQ_NONE);
 
         //printk("irqh()\n");
@@ -595 +595 @@
         snd_mtpav_read_bytes(mcard);
         spin_unlock(&mcard->spinlock);
+        return IRQ_HANDLED;
 }
 
@@ -765 +766 @@
                 goto __error;
 
-        err = snd_card_register(mtp_card->card);        // dont snd_card_register until AFTER all cards reources done!
+        err = snd_card_register(mtp_card->card);        // don't snd_card_register until AFTER all cards reources done!
 
         //printk("snd_card_register returned %d\n", err);

GPL/branches/alsa-resync1/alsa-kernel/include/sound/ad1848.h

@@ -24 +24 @@
 
 #include "pcm.h"
+#include <linux/interrupt.h>
 
 /* IO ports */
@@ -165 +166 @@
 const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction);
 int snd_ad1848_mixer(ad1848_t * chip);
-void snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 
 /* exported mixer stuffs */

GPL/branches/alsa-resync1/alsa-kernel/include/sound/adriver.h

@@ -22 +22 @@
  *
  */
+
+#include <linux/version.h>
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 2, 3)
@@ -213 +215 @@
 #endif
 
+/* pm_message_t type */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
+#include <linux/pm.h>
+#ifndef PMSG_FREEZE
+typedef u32 /* __bitwise */ pm_message_t;
+#define PMSG_FREEZE     3
+#define PMSG_SUSPEND    3
+#define PMSG_ON         0
+#endif
+#endif
 #ifndef PCI_D0
 #define PCI_D0     0

GPL/branches/alsa-resync1/alsa-kernel/include/sound/config.h

@@ -44 +44 @@
 #define EXPORT_SYMBOL(a)
 #define CONFIG_SOUND
-#define CONFIG_SND_VERSION      "0.0.1"
+#define CONFIG_SND_VERSION      "0.9.3"
 #define ATTRIBUTE_UNUSED
 

GPL/branches/alsa-resync1/alsa-kernel/include/sound/core.h

@@ -198 +198 @@
 #define snd_power_lock(card)            do { (void)(card); } while (0)
 #define snd_power_unlock(card)          do { (void)(card); } while (0)
-#define snd_power_wait(card)            do { (void)(card); } while (0)
-#define snd_power_get_state(card) SNDRV_CTL_POWER_D0
+static inline int snd_power_wait(snd_card_t *card, unsigned int state, struct file *file) { return 0; }
+#define snd_power_get_state(card)       SNDRV_CTL_POWER_D0
 #define snd_power_change_state(card, state)     do { (void)(card); } while (0)
 #define snd_card_set_pm_callback(card,suspend,resume,data) -EINVAL
@@ -501 +501 @@
 #define unlikely(x)     __builtin_expect((x),0)
 
-typedef u32 /*__bitwise*/ pm_message_t;
-
-#ifndef __devexit_p
-#define __devexit_p(x) x
-#endif
-
 #define printk_ratelimit()      1
 

GPL/branches/alsa-resync1/alsa-kernel/include/sound/cs4231.h

@@ -316 +316 @@
 void snd_cs4231_mce_down(cs4231_t *chip);
 
-void snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 
 const char *snd_cs4231_chip_id(cs4231_t *chip);

GPL/branches/alsa-resync1/alsa-kernel/include/sound/driver.h

@@ -28 +28 @@
 
 #include <linux/config.h>
-#include <linux/version.h>
 
 #define SNDRV_CARDS             8       /* number of supported soundcards - don't change - minor numbers */

GPL/branches/alsa-resync1/alsa-kernel/include/sound/es1688.h

@@ -25 +25 @@
 #include "control.h"
 #include "pcm.h"
+#include <linux/interrupt.h>
 
 #define ES1688_HW_AUTO          0x0000
@@ -110 +111 @@
 unsigned char snd_es1688_mixer_read(es1688_t *chip, unsigned char reg);
 
-void snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 
 int snd_es1688_create(snd_card_t * card,

GPL/branches/alsa-resync1/alsa-kernel/include/sound/gus.h

@@ -562 +562 @@
 
 #if 0
-extern void snd_gf1_lfo_effect_interrupt(snd_gus_card_t * gus, snd_gf1_voice_t * voice);
+extern irqreturn_t snd_gf1_lfo_effect_interrupt(snd_gus_card_t * gus, snd_gf1_voice_t * voice);
 #endif
 extern void snd_gf1_lfo_init(snd_gus_card_t * gus);
@@ -667 +667 @@
 /* gus_irq.c */
 
-void snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 #ifdef CONFIG_SND_DEBUG
 void snd_gus_irq_profile_init(snd_gus_card_t *gus);

GPL/branches/alsa-resync1/alsa-kernel/include/sound/initval.h

@@ -135 +135 @@
 #include <linux/interrupt.h>
 
-static void snd_legacy_empty_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
-{
+static irqreturn_t snd_legacy_empty_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
+{
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/include/sound/isapnp.h

@@ -22 +22 @@
 #ifndef LINUX_ISAPNP_H
 #define LINUX_ISAPNP_H
+
+#define ISAPNP_ALSA_LOCAL 1
 
 /*

GPL/branches/alsa-resync1/alsa-kernel/include/sound/snd_wavefront.h

@@ -99 +99 @@
 struct _snd_wavefront_card {
         snd_wavefront_t wavefront;
-#ifdef __ISAPNP__
-        struct isapnp_dev *wss;
-        struct isapnp_dev *ctrl;
-        struct isapnp_dev *mpu;
-        struct isapnp_dev *synth;
-#endif /* CONFIG_ISAPNP */
+#ifdef CONFIG_PNP
+        struct pnp_dev *wss;
+        struct pnp_dev *ctrl;
+        struct pnp_dev *mpu;
+        struct pnp_dev *synth;
+#endif /* CONFIG_PNP */
 };
 

GPL/branches/alsa-resync1/alsa-kernel/include/sound/uda1341.h

@@ -16 +16 @@
  */
 
-/* uda1341.h,v 1.4 2003/02/25 12:48:16 perex Exp */
+/* uda1341.h,v 1.5 2003/04/19 13:34:32 perex Exp */
 
 #define UDA1341_ALSA_NAME "snd-uda1341"
@@ -211 +211 @@
         CMD_AGC_TIME,
         CMD_AGC_LEVEL,
+#ifdef CONFIG_PM
+        CMD_SUSPEND,
+        CMD_RESUME,
+#endif
         CMD_LAST,
 };
@@ -222 +226 @@
 
 int __init snd_chip_uda1341_mixer_new(snd_card_t *card, struct l3_client **clnt);
-void __init snd_chip_uda1341_mixer_del(snd_card_t *card);
-
-#ifdef DEBUG_MODE
-#define DEBUG(format, args...)      do{printk(format, ##args);}while(0)
-#else
-#define DEBUG(format, args...)      /* nothing */
-#endif
-
-#ifdef DEBUG_FUNCTION_NAMES
-#define DEBUG_NAME(format, args...)     do{printk(format, ##args);}while(0)
-#else
-#define DEBUG_NAME(format, args...)     /* nothing */
-#endif
 
 /*

GPL/branches/alsa-resync1/alsa-kernel/include/sound/wavefront.h

@@ -688 +688 @@
 /* Allow direct user-space control over FX memory/coefficient data.
    In theory this could be used to download the FX microprogram,
-   but it would be a little slower, and involve some wierd code.
+   but it would be a little slower, and involve some weird code.
  */
 

GPL/branches/alsa-resync1/alsa-kernel/isa/ad1816a/ad1816a.c

@@ -23 +23 @@
 #include <linux/time.h>
 #include <linux/wait.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #define SNDRV_GET_ID
@@ -94 +90 @@
 
 struct snd_card_ad1816a {
-#ifdef __ISAPNP__
-        struct isapnp_dev *dev;
-        struct isapnp_dev *devmpu;
-#endif  /* __ISAPNP__ */
+        struct pnp_dev *dev;
+        struct pnp_dev *devmpu;
 };
 
-static snd_card_t *snd_ad1816a_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-
-static struct isapnp_card *snd_ad1816a_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_ad1816a_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-
-#define ISAPNP_AD1816A(_va, _vb, _vc, _device, _fa, _fb, _fc, _audio, _mpu401) \
-        { \
-                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID(_fa, _fb, _fc, _audio), \
-                         ISAPNP_DEVICE_ID(_fa, _fb, _fc, _mpu401), } \
-        }
-
-static struct isapnp_card_id snd_ad1816a_pnpids[] __devinitdata = {
+static struct pnp_card_device_id snd_ad1816a_pnpids[] __devinitdata = {
+        /* Analog Devices AD1815 */
+        { .id = "ADS7150", .devs = { { .id = "ADS7150" }, { .id = "ADS7151" } } },
+        /* Analog Devices AD1816A - added by Kenneth Platz <kxp@atl.hp.com> */
+        { .id = "ADS7181", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
+        /* Analog Devices AD1816A - Aztech/Newcom SC-16 3D */
+        { .id = "AZT1022", .devs = { { .id = "AZT1018" }, { .id = "AZT2002" } } },
+        /* Highscreen Sound-Boostar 16 3D - added by Stefan Behnel */
+        { .id = "LWC1061", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
         /* Highscreen Sound-Boostar 16 3D */
-        ISAPNP_AD1816A('M','D','K',0x1605,'A','D','S',0x7180,0x7181),
-        /* Highscreen Sound-Boostar 16 3D - added by Stefan Behnel */
-        ISAPNP_AD1816A('L','W','C',0x1061,'A','D','S',0x7180,0x7181),
-        /* Analog Devices AD1815 */
-        ISAPNP_AD1816A('A','D','S',0x7150,'A','D','S',0x7150,0x7151),
-        /* Analog Devices AD1816A - added by Kenneth Platz <kxp@atl.hp.com> */
-        ISAPNP_AD1816A('A','D','S',0x7181,'A','D','S',0x7180,0x7181),
+        { .id = "MDK1605", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
+        /* Shark Predator ISA - added by Ken Arromdee */
+        { .id = "SMM7180", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
+        /* Analog Devices AD1816A - Terratec AudioSystem EWS64S */
+        { .id = "TER1112", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
         /* Analog Devices AD1816A - Terratec Base 64 */
-        ISAPNP_AD1816A('T','E','R',0x1411,'A','D','S',0x7180,0x7181),
-        /* Analog Devices AD1816A - Terratec AudioSystem EWS64S */
-        ISAPNP_AD1816A('T','E','R',0x1112,'A','D','S',0x7180,0x7181),
-        /* Analog Devices AD1816A - Aztech/Newcom SC-16 3D */
-        ISAPNP_AD1816A('A','Z','T',0x1022,'A','Z','T',0x1018,0x2002),
-        /* Shark Predator ISA - added by Ken Arromdee */
-        ISAPNP_AD1816A('S','M','M',0x7180,'A','D','S',0x7180,0x7181),
-        { ISAPNP_CARD_END, }
+        { .id = "TER1411", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
+        /* end */
+        { .id = "" }
 };
 
-ISAPNP_CARD_TABLE(snd_ad1816a_pnpids);
-
-#endif  /* __ISAPNP__ */
+MODULE_DEVICE_TABLE(pnp_card, snd_ad1816a_pnpids);
+
 
 #define DRIVER_NAME     "snd-card-ad1816a"
 
 
-#ifdef __ISAPNP__
-static int __init snd_card_ad1816a_isapnp(int dev,
-                                          struct snd_card_ad1816a *acard)
-{
-        const struct isapnp_card_id *id = snd_ad1816a_isapnp_id[dev];
-        struct isapnp_card *card = snd_ad1816a_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-
-        acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (acard->dev->active) {
-                acard->dev = NULL;
+static int __devinit snd_card_ad1816a_pnp(int dev, struct snd_card_ad1816a *acard,
+                                          struct pnp_card_link *card,
+                                          const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
+        int err;
+
+        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (acard->dev == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
-        acard->devmpu = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
-        if (acard->devmpu->active) {
-                acard->dev = acard->devmpu = NULL;
+        acard->devmpu = pnp_request_card_device(card, id->devs[1].id, NULL);
+        if (acard->devmpu == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
 
         pdev = acard->dev;
-        if (pdev->prepare(pdev) < 0)
-                return -EAGAIN;
+        pnp_init_resource_table(cfg);
 
         if (port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[2], port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[2], port[dev], 16);
         if (fm_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[1], fm_port[dev], 4);
+                pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
         if (dma1[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma1[dev],
-                        1);
+                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
         if (dma2[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma2[dev],
-                        1);
+                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
-
-        if (pdev->activate(pdev) < 0) {
-                printk(KERN_ERR PFX "AUDIO isapnp configure failure\n");
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
+
+        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                printk(KERN_ERR PFX "AUDIO PnP configure failure\n");
+                kfree(cfg);
                 return -EBUSY;
         }
 
-        port[dev] = pdev->resource[2].start;
-        fm_port[dev] = pdev->resource[1].start;
-        dma1[dev] = pdev->dma_resource[0].start;
-        dma2[dev] = pdev->dma_resource[1].start;
-        irq[dev] = pdev->irq_resource[0].start;
+        port[dev] = pnp_port_start(pdev, 2);
+        fm_port[dev] = pnp_port_start(pdev, 1);
+        dma1[dev] = pnp_dma(pdev, 0);
+        dma2[dev] = pnp_dma(pdev, 1);
+        irq[dev] = pnp_irq(pdev, 0);
 
         pdev = acard->devmpu;
-        if (pdev == NULL || pdev->prepare(pdev) < 0) {
-                mpu_port[dev] = -1;
-                acard->devmpu = NULL;
-                return 0;
-        }
+        pnp_init_resource_table(cfg);
 
         if (mpu_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], mpu_port[dev],
-                        2);
+                pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
         if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev],
-                        1);
-
-        if (pdev->activate(pdev) < 0) {
-                /* not fatal error */
-                printk(KERN_ERR PFX "MPU-401 isapnp configure failure\n");
+                pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
+
+        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                printk(KERN_ERR PFX "MPU401 PnP configure failure\n");
                 mpu_port[dev] = -1;
                 acard->devmpu = NULL;
         } else {
-                mpu_port[dev] = pdev->resource[0].start;
-                mpu_irq[dev] = pdev->irq_resource[0].start;
-        }
-
+                mpu_port[dev] = pnp_port_start(pdev, 0);
+                mpu_irq[dev] = pnp_irq(pdev, 0);
+        }
+
+        kfree(cfg);
         return 0;
 }
 
-static void snd_card_ad1816a_deactivate(struct snd_card_ad1816a *acard)
-{
-        if (acard->dev) {
-                acard->dev->deactivate(acard->dev);
-                acard->dev = NULL;
-        }
-        if (acard->devmpu) {
-                acard->devmpu->deactivate(acard->devmpu);
-                acard->devmpu = NULL;
-        }
-}
-#endif  /* __ISAPNP__ */
-
-static void snd_card_ad1816a_free(snd_card_t *card)
-{
-        struct snd_card_ad1816a *acard = (struct snd_card_ad1816a *)card->private_data;
-
-        if (acard) {
-#ifdef __ISAPNP__
-                snd_card_ad1816a_deactivate(acard);
-#endif  /* __ISAPNP__ */
-        }
-}
-
-static int __init snd_card_ad1816a_probe(int dev)
+static int __devinit snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard,
+                                            const struct pnp_card_device_id *pid)
 {
         int error;
@@ -251 +206 @@
                 return -ENOMEM;
         acard = (struct snd_card_ad1816a *)card->private_data;
-        card->private_free = snd_card_ad1816a_free;
-
-#ifdef __ISAPNP__
-        if ((error = snd_card_ad1816a_isapnp(dev, acard))) {
-                snd_card_free(card);
-                return error;
-        }
-#else
-        printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
-        return -ENOSYS;
-#endif  /* __ISAPNP__ */
+
+        if ((error = snd_card_ad1816a_pnp(dev, acard, pcard, pid))) {
+                snd_card_free(card);
+                return error;
+        }
 
         if ((error = snd_ad1816a_create(card, port[dev],
@@ -315 +264 @@
                 return error;
         }
-        snd_ad1816a_cards[dev] = card;
+        pnp_set_card_drvdata(pcard, card);
         return 0;
 }
 
-#ifdef __ISAPNP__
-static int __init snd_ad1816a_isapnp_detect(struct isapnp_card *card,
-                                            const struct isapnp_card_id *id)
+static int __devinit snd_ad1816a_pnp_detect(struct pnp_card_link *card,
+                                            const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -329 +277 @@
                 if (!enable[dev])
                         continue;
-                snd_ad1816a_isapnp_cards[dev] = card;
-                snd_ad1816a_isapnp_id[dev] = id;
-                res = snd_card_ad1816a_probe(dev);
+                res = snd_card_ad1816a_probe(dev, card, id);
                 if (res < 0)
                         return res;
@@ -339 +285 @@
         return -ENODEV;
 }
-#endif
+
+static void __devexit snd_ad1816a_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver ad1816a_pnpc_driver = {
+        .flags          = PNP_DRIVER_RES_DISABLE,
+        .name           = "ad1816a",
+        .id_table       = snd_ad1816a_pnpids,
+        .probe          = snd_ad1816a_pnp_detect,
+        .remove         = __devexit_p(snd_ad1816a_pnp_remove),
+};
 
 static int __init alsa_card_ad1816a_init(void)
@@ -345 +306 @@
         int cards = 0;
 
-#ifdef __ISAPNP__
-        cards += isapnp_probe_cards(snd_ad1816a_pnpids, snd_ad1816a_isapnp_detect);
-#else
-        printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
-#endif
+        cards += pnp_register_card_driver(&ad1816a_pnpc_driver);
 #ifdef MODULE
-        if (!cards)
+        if (!cards) {
+                pnp_unregister_card_driver(&ad1816a_pnpc_driver);
                 printk(KERN_ERR "no AD1816A based soundcards found.\n");
+        }
 #endif  /* MODULE */
         return cards ? 0 : -ENODEV;
@@ -359 +318 @@
 static void __exit alsa_card_ad1816a_exit(void)
 {
-        int dev;
-
-        for (dev = 0; dev < SNDRV_CARDS; dev++)
-                snd_card_free(snd_ad1816a_cards[dev]);
+        pnp_unregister_card_driver(&ad1816a_pnpc_driver);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/ad1816a/ad1816a_lib.c

@@ -310 +310 @@
 
 
-static void snd_ad1816a_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        ad1816a_t *chip = snd_magic_cast(ad1816a_t, dev_id, return);
+static irqreturn_t snd_ad1816a_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        ad1816a_t *chip = snd_magic_cast(ad1816a_t, dev_id, return IRQ_NONE);
         unsigned char status;
 
@@ -331 +331 @@
         snd_ad1816a_out(chip, AD1816A_INTERRUPT_STATUS, 0x00);
         spin_unlock(&chip->lock);
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/ad1848/ad1848_lib.c

@@ -586 +586 @@
 }
 
-void snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        ad1848_t *chip = snd_magic_cast(ad1848_t, dev_id, return);
+irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        ad1848_t *chip = snd_magic_cast(ad1848_t, dev_id, return IRQ_NONE);
 
         if ((chip->mode & AD1848_MODE_PLAY) && chip->playback_substream &&
@@ -597 +597 @@
                 snd_pcm_period_elapsed(chip->capture_substream);
         outb(0, AD1848P(chip, STATUS)); /* clear global interrupt bit */
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/als100.c

@@ -25 +25 @@
 #include <linux/wait.h>
 #include <linux/time.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #define SNDRV_GET_ID
@@ -97 +93 @@
 
 struct snd_card_als100 {
-#ifdef __ISAPNP__
-        struct isapnp_dev *dev;
-        struct isapnp_dev *devmpu;
-        struct isapnp_dev *devopl;
-#endif  /* __ISAPNP__ */
+        int dev_no;
+        struct pnp_dev *dev;
+        struct pnp_dev *devmpu;
+        struct pnp_dev *devopl;
 };
 
-static snd_card_t *snd_als100_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-static struct isapnp_card *snd_als100_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_als100_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-
-#define ISAPNP_ALS100(_va, _vb, _vc, _device, _audio, _mpu401, _opl) \
-        { \
-                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID('@', '@', '@', _audio), \
-                         ISAPNP_DEVICE_ID('@', 'X', '@', _mpu401), \
-                         ISAPNP_DEVICE_ID('@', 'H', '@', _opl) } \
-        }
-
-static struct isapnp_card_id snd_als100_pnpids[] __devinitdata = {
+static struct pnp_card_device_id snd_als100_pnpids[] __devinitdata = {
         /* ALS100 - PRO16PNP */
-        ISAPNP_ALS100('A','L','S',0x0001,0x0001,0x0001,0x0001),
+        { .id = "ALS0001", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } } },
         /* ALS110 - MF1000 - Digimate 3D Sound */
-        ISAPNP_ALS100('A','L','S',0x0110,0x1001,0x1001,0x1001),
+        { .id = "ALS0110", .devs = { { "@@@1001" }, { "@X@1001" }, { "@H@1001" } } },
         /* ALS120 */
-        ISAPNP_ALS100('A','L','S',0x0120,0x2001,0x2001,0x2001),
+        { .id = "ALS0120", .devs = { { "@@@2001" }, { "@X@2001" }, { "@H@2001" } } },
         /* ALS200 */
-        ISAPNP_ALS100('A','L','S',0x0200,0x0020,0x0020,0x0001),
+        { .id = "ALS0200", .devs = { { "@@@0020" }, { "@X@0020" }, { "@H@0001" } } },
         /* RTL3000 */
-        ISAPNP_ALS100('R','T','L',0x3000,0x2001,0x2001,0x2001),
-        { ISAPNP_CARD_END, }
+        { .id = "RTL3000", .devs = { { "@@@2001" }, { "@X@2001" }, { "@H@2001" } } },
+        { .id = "", } /* end */
 };
 
-ISAPNP_CARD_TABLE(snd_als100_pnpids);
-
-#endif  /* __ISAPNP__ */
+MODULE_DEVICE_TABLE(pnp_card, snd_als100_pnpids);
 
 #define DRIVER_NAME     "snd-card-als100"
 
-
-#ifdef __ISAPNP__
-static int __init snd_card_als100_isapnp(int dev, struct snd_card_als100 *acard)
-{
-        const struct isapnp_card_id *id = snd_als100_isapnp_id[dev];
-        struct isapnp_card *card = snd_als100_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-
-        acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (acard->dev->active) {
-                acard->dev = NULL;
-                return -EBUSY;
-        }
-        acard->devmpu = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
-        if (acard->devmpu->active) {
-                acard->dev = acard->devmpu = NULL;
-                return -EBUSY;
-        }
-        acard->devopl = isapnp_find_dev(card, id->devs[2].vendor, id->devs[2].function, NULL);
-        if (acard->devopl->active) {
-                acard->dev = acard->devmpu = acard->devopl = NULL;
-                return -EBUSY;
-        }
+static int __devinit snd_card_als100_pnp(int dev, struct snd_card_als100 *acard,
+                                         struct pnp_card_link *card,
+                                         const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
+        int err;
+
+        if (!cfg)
+                return -ENOMEM;
+        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (acard->dev == NULL) {
+                kfree(cfg);
+                return -ENODEV;
+        }
+        acard->devmpu = pnp_request_card_device(card, id->devs[1].id, acard->dev);
+        acard->devopl = pnp_request_card_device(card, id->devs[2].id, acard->devmpu);
 
         pdev = acard->dev;
-        if (pdev->prepare(pdev)<0)
-                return -EAGAIN;
-
+
+        pnp_init_resource_table(cfg);
+
+        /* override resources */
         if (port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
         if (dma8[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma8[dev],
-                        1);
+                pnp_resource_change(&cfg->dma_resource[0], dma8[dev], 1);
         if (dma16[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma16[dev],
-                        1);
+                pnp_resource_change(&cfg->dma_resource[1], dma16[dev], 1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
-
-        if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR PFX "AUDIO isapnp configure failure\n");
-                return -EBUSY;
-        }
-
-        port[dev] = pdev->resource[0].start;
-        dma8[dev] = pdev->dma_resource[1].start;
-        dma16[dev] = pdev->dma_resource[0].start;
-        irq[dev] = pdev->irq_resource[0].start;
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
+        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n");
+                kfree(cfg);
+                return err;
+        }
+        port[dev] = pnp_port_start(pdev, 0);
+        dma8[dev] = pnp_dma(pdev, 1);
+        dma16[dev] = pnp_dma(pdev, 0);
+        irq[dev] = pnp_irq(pdev, 0);
 
         pdev = acard->devmpu;
-        if (pdev == NULL || pdev->prepare(pdev)<0) {
-                mpu_port[dev] = -1;
-                return 0;
-        }
-
+        if (pdev != NULL) {
+                pnp_init_resource_table(cfg);
         if (mpu_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], mpu_port[dev],
-                        2);
+                        pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
         if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev],
-                        1);
-
-        if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR PFX "MPU-401 isapnp configure failure\n");
-                mpu_port[dev] = -1;
-                acard->devmpu = NULL;
+                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
+                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
+                        snd_printk(KERN_ERR PFX "MPU401 the requested resources are invalid, using auto config\n");
+                err = pnp_activate_dev(pdev);
+                if (err < 0)
+                        goto __mpu_error;
+                mpu_port[dev] = pnp_port_start(pdev, 0);
+                mpu_irq[dev] = pnp_irq(pdev, 0);
         } else {
-                mpu_port[dev] = pdev->resource[0].start;
-                mpu_irq[dev] = pdev->irq_resource[0].start;
+             __mpu_error:
+                if (pdev) {
+                        pnp_release_card_device(pdev);
+                        snd_printk(KERN_ERR PFX "MPU401 pnp configure failure, skipping\n");
+                }
+                acard->devmpu = NULL;
+                mpu_port[dev] = -1;
         }
 
         pdev = acard->devopl;
-        if (pdev == NULL || pdev->prepare(pdev)<0) {
-                fm_port[dev] = -1;
-                return 0;
-        }
-
-        if (fm_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], fm_port[dev], 4);
-
-        if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR PFX "OPL isapnp configure failure\n");
-                fm_port[dev] = -1;
+        if (pdev != NULL) {
+                pnp_init_resource_table(cfg);
+                if (fm_port[dev] != SNDRV_AUTO_PORT)
+                        pnp_resource_change(&cfg->port_resource[0], fm_port[dev], 4);
+                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
+                        snd_printk(KERN_ERR PFX "OPL3 the requested resources are invalid, using auto config\n");
+                err = pnp_activate_dev(pdev);
+                if (err < 0)
+                        goto __fm_error;
+                fm_port[dev] = pnp_port_start(pdev, 0);
+        } else {
+              __fm_error:
+                if (pdev) {
+                        pnp_release_card_device(pdev);
+                        snd_printk(KERN_ERR PFX "OPL3 pnp configure failure, skipping\n");
+                }
                 acard->devopl = NULL;
-        } else {
-                fm_port[dev] = pdev->resource[0].start;
-        }
-
+                fm_port[dev] = -1;
+        }
+
+        kfree(cfg);
         return 0;
 }
 
-static void snd_card_als100_deactivate(struct snd_card_als100 *acard)
-{
-        if (acard->dev) {
-                acard->dev->deactivate(acard->dev);
-                acard->dev = NULL;
-        }
-        if (acard->devmpu) {
-                acard->devmpu->deactivate(acard->devmpu);
-                acard->devmpu = NULL;
-        }
-        if (acard->devopl) {
-                acard->devopl->deactivate(acard->devopl);
-                acard->devopl = NULL;
-        }
-}
-#endif  /* __ISAPNP__ */
-
-static void snd_card_als100_free(snd_card_t *card)
-{
-        struct snd_card_als100 *acard = (struct snd_card_als100 *)card->private_data;
-
-        if (acard) {
-#ifdef __ISAPNP__
-                snd_card_als100_deactivate(acard);
-#endif  /* __ISAPNP__ */
-        }
-}
-
-static int __init snd_card_als100_probe(int dev)
+static int __init snd_card_als100_probe(int dev,
+                                        struct pnp_card_link *pcard,
+                                        const struct pnp_card_device_id *pid)
 {
         int error;
@@ -269 +224 @@
                 return -ENOMEM;
         acard = (struct snd_card_als100 *)card->private_data;
-        card->private_free = snd_card_als100_free;
-
-#ifdef __ISAPNP__
-        if ((error = snd_card_als100_isapnp(dev, acard))) {
-                snd_card_free(card);
-                return error;
-        }
-#else
-        printk(KERN_ERR PFX "you have to enable PnP support ...\n");
-        snd_card_free(card);
-        return -ENOSYS;
-#endif  /* __ISAPNP__ */
+
+        if ((error = snd_card_als100_pnp(dev, acard, pcard, pid))) {
+                snd_card_free(card);
+                return error;
+        }
 
         if ((error = snd_sbdsp_create(card, port[dev],
@@ -307 +255 @@
                                         mpu_irq[dev], SA_INTERRUPT,
                                         NULL) < 0)
-                        printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
+                        snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
         }
 
@@ -314 +262 @@
                                     fm_port[dev], fm_port[dev] + 2,
                                     OPL3_HW_AUTO, 0, &opl3) < 0) {
-                        printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
+                        snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
                                 fm_port[dev], fm_port[dev] + 2);
                 } else {
@@ -337 +285 @@
                 return error;
         }
-        snd_als100_cards[dev] = card;
+        pnp_set_card_drvdata(pcard, card);
         return 0;
 }
 
-#ifdef __ISAPNP__
-static int __init snd_als100_isapnp_detect(struct isapnp_card *card,
-                                           const struct isapnp_card_id *id)
+static int __devinit snd_als100_pnp_detect(struct pnp_card_link *card,
+                                           const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -351 +298 @@
                 if (!enable[dev])
                         continue;
-                snd_als100_isapnp_cards[dev] = card;
-                snd_als100_isapnp_id[dev] = id;
-                res = snd_card_als100_probe(dev);
+                res = snd_card_als100_probe(dev, card, id);
                 if (res < 0)
                         return res;
@@ -361 +306 @@
         return -ENODEV;
 }
-#endif
+
+static void __devexit snd_als100_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver als100_pnpc_driver = {
+        .flags          = PNP_DRIVER_RES_DISABLE,
+        .name           = "als100",
+        .id_table       = snd_als100_pnpids,
+        .probe          = snd_als100_pnp_detect,
+        .remove         = __devexit_p(snd_als100_pnp_remove),
+};
 
 static int __init alsa_card_als100_init(void)
@@ -367 +327 @@
         int cards = 0;
 
-#ifdef __ISAPNP__
-        cards += isapnp_probe_cards(snd_als100_pnpids, snd_als100_isapnp_detect);
-#else
-        printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
-#endif
+        cards += pnp_register_card_driver(&als100_pnpc_driver);
 #ifdef MODULE
-        if (!cards)
-                printk(KERN_ERR "no ALS100 based soundcards found\n");
+        if (!cards) {
+                pnp_unregister_card_driver(&als100_pnpc_driver);
+                snd_printk(KERN_ERR "no ALS100 based soundcards found\n");
+        }
 #endif
         return cards ? 0 : -ENODEV;
@@ -381 +339 @@
 static void __exit alsa_card_als100_exit(void)
 {
-        int dev;
-
-        for (dev = 0; dev < SNDRV_CARDS; dev++)
-                snd_card_free(snd_als100_cards[dev]);
+        pnp_unregister_card_driver(&als100_pnpc_driver);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/azt2320.c

@@ -37 +37 @@
 #include <linux/time.h>
 #include <linux/wait.h>
+#include <linux/pnp.h>
 #include <sound/core.h>
 #define SNDRV_GET_ID
@@ -105 +106 @@
 
 struct snd_card_azt2320 {
-#ifdef __ISAPNP__
-        struct isapnp_dev *dev;
-        struct isapnp_dev *devmpu;
-#endif  /* __ISAPNP__ */
+#ifdef CONFIG_PNP
+        int dev_no;
+        struct pnp_dev *dev;
+        struct pnp_dev *devmpu;
+#endif  /* CONFIG_PNP */
 };
 
-static snd_card_t *snd_azt2320_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-
-static struct isapnp_card *snd_azt2320_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_azt2320_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-
-#define ISAPNP_AZT2320(_va, _vb, _vc, _device, _audio, _mpu401) \
-        { \
-                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
-                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _mpu401), } \
-        }
-
-static struct isapnp_card_id snd_azt2320_pnpids[] __devinitdata = {
+static struct pnp_card_device_id snd_azt2320_pnpids[] __devinitdata = {
         /* PRO16V */
-        ISAPNP_AZT2320('A','Z','T',0x1008,0x1008,0x2001),
+        { .id = "AZT1008", .devs = { { "AZT1008" }, { "AZT2001" }, } },
         /* Aztech Sound Galaxy 16 */
-        ISAPNP_AZT2320('A','Z','T',0x2320,0x0001,0x0002),
+        { .id = "AZT2320", .devs = { { "AZT0001" }, { "AZT0002" }, } },
         /* Packard Bell Sound III 336 AM/SP */
-        ISAPNP_AZT2320('A','Z','T',0x3000,0x1003,0x2001),
+        { .id = "AZT3000", .devs = { { "AZT1003" }, { "AZT2001" }, } },
         /* AT3300 */
-        ISAPNP_AZT2320('A','Z','T',0x3002,0x1004,0x2001),
+        { .id = "AZT3002", .devs = { { "AZT1004" }, { "AZT2001" }, } },
         /* --- */
-        ISAPNP_AZT2320('A','Z','T',0x3005,0x1003,0x2001),
+        { .id = "AZT3005", .devs = { { "AZT1003" }, { "AZT2001" }, } },
         /* --- */
-        ISAPNP_AZT2320('A','Z','T',0x3011,0x1003,0x2001),
-        { ISAPNP_CARD_END, }    /* end */
+        { .id = "AZT3011", .devs = { { "AZT1003" }, { "AZT2001" }, } },
+        { .id = "" }    /* end */
 };
 
-ISAPNP_CARD_TABLE(snd_azt2320_pnpids);
-
-#endif  /* __ISAPNP__ */
+MODULE_DEVICE_TABLE(pnp_card, snd_azt2320_pnpids);
 
 #define DRIVER_NAME     "snd-card-azt2320"
 
-
-#ifdef __ISAPNP__
-static int __init snd_card_azt2320_isapnp(int dev, struct snd_card_azt2320 *acard)
-{
-        const struct isapnp_card_id *id = snd_azt2320_isapnp_id[dev];
-        struct isapnp_card *card = snd_azt2320_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-
-        acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (acard->dev->active) {
-                acard->dev = NULL;
-                return -EBUSY;
-        }
-        acard->devmpu = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
-        if (acard->devmpu->active) {
-                acard->dev = acard->devmpu = NULL;
-                return -EBUSY;
-        }
+static int __devinit snd_card_azt2320_pnp(int dev, struct snd_card_azt2320 *acard,
+                                          struct pnp_card_link *card,
+                                          const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
+        int err;
+
+        if (!cfg)
+                return -ENOMEM;
+
+        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (acard->dev == NULL) {
+                kfree(cfg);
+                return -ENODEV;
+        }
+
+        acard->devmpu = pnp_request_card_device(card, id->devs[1].id, NULL);
 
         pdev = acard->dev;
-        if (pdev->prepare(pdev) < 0)
-                return -EAGAIN;
-
+        pnp_init_resource_table(cfg);
+
+        /* override resources */
         if (port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
         if (fm_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[1], fm_port[dev], 4);
+                pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
         if (wss_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[2], wss_port[dev],
-                        4);
+                pnp_resource_change(&cfg->port_resource[2], wss_port[dev], 4);
         if (dma1[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma1[dev],
-                        1);
+                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
         if (dma2[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma2[dev],
-                        1);
+                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
-
-        if (pdev->activate(pdev) < 0) {
-                printk(KERN_ERR PFX "AUDIO isapnp configure failure\n");
-                return -EBUSY;
-        }
-
-        port[dev] = pdev->resource[0].start;
-        fm_port[dev] = pdev->resource[1].start;
-        wss_port[dev] = pdev->resource[2].start;
-        dma1[dev] = pdev->dma_resource[0].start;
-        dma2[dev] = pdev->dma_resource[1].start;
-        irq[dev] = pdev->irq_resource[0].start;
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
+        if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
+                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
+
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n");
+                kfree(cfg);
+                return err;
+        }
+        port[dev] = pnp_port_start(pdev, 0);
+        fm_port[dev] = pnp_port_start(pdev, 1);
+        wss_port[dev] = pnp_port_start(pdev, 2);
+        dma1[dev] = pnp_dma(pdev, 0);
+        dma2[dev] = pnp_dma(pdev, 1);
+        irq[dev] = pnp_irq(pdev, 0);
 
         pdev = acard->devmpu;
-        if (pdev == NULL || pdev->prepare(pdev) < 0) {
-                mpu_port[dev] = -1;
-                return 0;
-        }
-
+        if (pdev != NULL) {
+                pnp_init_resource_table(cfg);
         if (mpu_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], mpu_port[dev],
-                        2);
+                        pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
         if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev],
-                        1);
-
-        if (pdev->activate(pdev) < 0) {
-                /* not fatal error */
-                printk(KERN_ERR PFX "MPU-401 isapnp configure failure\n");
-                mpu_port[dev] = -1;
-                acard->devmpu = NULL;
+                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
+                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
+                        snd_printk(KERN_ERR PFX "MPU401 the requested resources are invalid, using auto config\n");
+                err = pnp_activate_dev(pdev);
+                if (err < 0)
+                        goto __mpu_error;
+                mpu_port[dev] = pnp_port_start(pdev, 0);
+                mpu_irq[dev] = pnp_irq(pdev, 0);
         } else {
-                mpu_port[dev] = pdev->resource[0].start;
-                mpu_irq[dev] = pdev->irq_resource[0].start;
-        }
-
+             __mpu_error:
+                if (pdev) {
+                        pnp_release_card_device(pdev);
+                        snd_printk(KERN_ERR PFX "MPU401 pnp configure failure, skipping\n");
+                }
+                acard->devmpu = NULL;
+                mpu_port[dev] = -1;
+        }
+
+        kfree (cfg);
         return 0;
 }
 
-static void snd_card_azt2320_deactivate(struct snd_card_azt2320 *acard)
-{
-        if (acard->dev)
-                acard->dev->deactivate(acard->dev);
-        if (acard->devmpu)
-                acard->devmpu->deactivate(acard->devmpu);
-}
-#endif  /* __ISAPNP__ */
-
 /* same of snd_sbdsp_command by Jaroslav Kysela */
-static int __init snd_card_azt2320_command(unsigned long port, unsigned char val)
+static int __devinit snd_card_azt2320_command(unsigned long port, unsigned char val)
 {
         int i;
@@ -240 +219 @@
 
         limit = jiffies + HZ / 10;
-        for (i = 50000; i && (limit - jiffies) > 0; i--)
+        for (i = 50000; i && time_after(limit, jiffies); i--)
                 if (!(inb(port + 0x0c) & 0x80)) {
                         outb(val, port + 0x0c);
@@ -248 +227 @@
 }
 
-static int __init snd_card_azt2320_enable_wss(unsigned long port)
+static int __devinit snd_card_azt2320_enable_wss(unsigned long port)
 {
         int error;
@@ -261 +240 @@
 }
 
-static void snd_card_azt2320_free(snd_card_t *card)
-{
-        struct snd_card_azt2320 *acard = (struct snd_card_azt2320 *)card->private_data;
-
-        if (acard) {
-#ifdef __ISAPNP__
-                snd_card_azt2320_deactivate(acard);
-#endif  /* __ISAPNP__ */
-        }
-}
-
-static int __init snd_card_azt2320_probe(int dev)
+static int __devinit snd_card_azt2320_probe(int dev,
+                                            struct pnp_card_link *pcard,
+                                            const struct pnp_card_device_id *pid)
 {
         int error;
@@ -284 +254 @@
                 return -ENOMEM;
         acard = (struct snd_card_azt2320 *)card->private_data;
-        card->private_free = snd_card_azt2320_free;
-
-#ifdef __ISAPNP__
-        if ((error = snd_card_azt2320_isapnp(dev, acard))) {
-                snd_card_free(card);
-                return error;
-        }
-#endif  /* __ISAPNP__ */
+
+        if ((error = snd_card_azt2320_pnp(dev, acard, pcard, pid))) {
+                snd_card_free(card);
+                return error;
+        }
 
         if ((error = snd_card_azt2320_enable_wss(port[dev]))) {
@@ -325 +292 @@
                                 mpu_irq[dev], SA_INTERRUPT,
                                 NULL) < 0)
-                        printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n",
-                                mpu_port[dev]);
+                        snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
         }
 
@@ -333 +299 @@
                                     fm_port[dev], fm_port[dev] + 2,
                                     OPL3_HW_AUTO, 0, &opl3) < 0) {
-                        printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
+                        snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
                                 fm_port[dev], fm_port[dev] + 2);
                 } else {
@@ -356 +322 @@
                 return error;
         }
-        snd_azt2320_cards[dev] = card;
+        pnp_set_card_drvdata(pcard, card);
         return 0;
 }
 
-#ifdef __ISAPNP__
-static int __init snd_azt2320_isapnp_detect(struct isapnp_card *card,
-                                            const struct isapnp_card_id *id)
+static int __devinit snd_azt2320_pnp_detect(struct pnp_card_link *card,
+                                            const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -370 +335 @@
                 if (!enable[dev])
                         continue;
-                snd_azt2320_isapnp_cards[dev] = card;
-                snd_azt2320_isapnp_id[dev] = id;
-                res = snd_card_azt2320_probe(dev);
+                res = snd_card_azt2320_probe(dev, card, id);
                 if (res < 0)
                         return res;
@@ -380 +343 @@
         return -ENODEV;
 }
-#endif
+
+static void __devexit snd_azt2320_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver azt2320_pnpc_driver = {
+        .flags          = PNP_DRIVER_RES_DISABLE,
+        .name           = "azt2320",
+        .id_table       = snd_azt2320_pnpids,
+        .probe          = snd_azt2320_pnp_detect,
+        .remove         = __devexit_p(snd_azt2320_pnp_remove),
+};
 
 static int __init alsa_card_azt2320_init(void)
@@ -386 +364 @@
         int cards = 0;
 
-#ifdef __ISAPNP__
-        cards += isapnp_probe_cards(snd_azt2320_pnpids, snd_azt2320_isapnp_detect);
-#else
-        printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
-#endif
+        cards += pnp_register_card_driver(&azt2320_pnpc_driver);
 #ifdef MODULE
-        if (!cards)
-                printk(KERN_ERR "no AZT2320 based soundcards found\n");
+        if (!cards) {
+                pnp_unregister_card_driver(&azt2320_pnpc_driver);
+                snd_printk(KERN_ERR "no AZT2320 based soundcards found\n");
+        }
 #endif
         return cards ? 0 : -ENODEV;
@@ -400 +376 @@
 static void __exit alsa_card_azt2320_exit(void)
 {
-        int dev;
-
-        for (dev = 0; dev < SNDRV_CARDS; dev++)
-                snd_card_free(snd_azt2320_cards[dev]);
+        pnp_unregister_card_driver(&azt2320_pnpc_driver);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/cmi8330.c

@@ -47 +47 @@
 #include <linux/init.h>
 #include <linux/slab.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #include <sound/ad1848.h>
@@ -74 +70 @@
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 #ifdef TARGET_OS2
 static int isapnp[SNDRV_CARDS] = {REPEAT_SNDRV(1)};
@@ -98 +94 @@
 MODULE_PARM_DESC(enable, "Enable CMI8330 soundcard.");
 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
-MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
+MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
 MODULE_PARM_SYNTAX(isapnp, SNDRV_ISAPNP_DESC);
 #endif
@@ -161 +157 @@
 
 struct snd_cmi8330 {
-#ifdef __ISAPNP__
-        struct isapnp_dev *cap;
-        struct isapnp_dev *play;
+#ifdef CONFIG_PNP
+        struct pnp_dev *cap;
+        struct pnp_dev *play;
 #endif
         snd_card_t *card;
@@ -177 +173 @@
 };
 
-static snd_card_t *snd_cmi8330_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-
-static struct isapnp_card *snd_cmi8330_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_cmi8330_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-
-#define ISAPNP_CMI8330(_va, _vb, _vc, _device, _audio1, _audio2) \
-        { \
-                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID('@', '@', '@', _audio1), \
-                         ISAPNP_DEVICE_ID('@', 'X', '@', _audio2), } \
-        }
-
-static struct isapnp_card_id snd_cmi8330_pnpids[] __devinitdata =
-{
-        ISAPNP_CMI8330('C','M','I',0x0001,0x0001,0x0001),
-        { ISAPNP_CARD_END, }
+static snd_card_t *snd_cmi8330_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+
+#ifdef CONFIG_PNP
+
+static struct pnp_card_device_id snd_cmi8330_pnpids[] __devinitdata = {
+        { .id = "CMI0001", .devs = { { "@@@0001" }, { "@X@0001" } } },
+        { .id = "" }
 };
 
-ISAPNP_CARD_TABLE(snd_cmi8330_pnpids);
+MODULE_DEVICE_TABLE(pnp_card, snd_cmi8330_pnpids);
 
 #endif
@@ -263 +248 @@
 
 
-static int __init cmi8330_add_sb_mixers(sb_t *chip)
+static int __devinit cmi8330_add_sb_mixers(sb_t *chip)
 {
         int idx, err;
@@ -288 +273 @@
 #endif
 
-static int __init snd_cmi8330_mixer(snd_card_t *card, struct snd_cmi8330 *acard)
+static int __devinit snd_cmi8330_mixer(snd_card_t *card, struct snd_cmi8330 *acard)
 {
         unsigned int idx;
@@ -307 +292 @@
 }
 
-#ifdef __ISAPNP__
-static int __init snd_cmi8330_isapnp(int dev, struct snd_cmi8330 *acard)
-{
-        const struct isapnp_card_id *id = snd_cmi8330_isapnp_id[dev];
-        struct isapnp_card *card = snd_cmi8330_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-
-        acard->cap = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (acard->cap->active) {
-                acard->cap = NULL;
+#ifdef CONFIG_PNP
+static int __devinit snd_cmi8330_pnp(int dev, struct snd_cmi8330 *acard,
+                                     struct pnp_card_link *card,
+                                     const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table * cfg = kmalloc(GFP_ATOMIC, sizeof(struct pnp_resource_table));
+        int err;
+
+        acard->cap = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (acard->cap == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
-        acard->play = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
-        if (acard->play->active) {
-                acard->cap = acard->play = NULL;
+        acard->play = pnp_request_card_device(card, id->devs[1].id, NULL);
+        if (acard->play == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
 
         pdev = acard->cap;
-        if (pdev->prepare(pdev)<0)
-                return -EAGAIN;
+        pnp_init_resource_table(cfg);
         /* allocate AD1848 resources */
         if (wssport[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], wssport[dev], 8);
+                pnp_resource_change(&cfg->port_resource[0], wssport[dev], 8);
         if (wssdma[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], wssdma[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[0], wssdma[dev], 1);
         if (wssirq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], wssirq[dev], 1);
-
-        if (pdev->activate(pdev)<0) {
-                snd_printk("(AD1848) PnP configure failure\n");
+                pnp_resource_change(&cfg->irq_resource[0], wssirq[dev], 1);
+
+        err = pnp_manual_config_dev(pdev, cfg, 0);
+        if (err < 0)
+                snd_printk(KERN_ERR "CMI8330/C3D (AD1848) PnP manual resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR "CMI8330/C3D (AD1848) PnP configure failure\n");
+                kfree(cfg);
                 return -EBUSY;
         }
-        wssport[dev] = pdev->resource[0].start;
-        wssdma[dev] = pdev->dma_resource[0].start;
-        wssirq[dev] = pdev->irq_resource[0].start;
+        wssport[dev] = pnp_port_start(pdev, 0);
+        wssdma[dev] = pnp_dma(pdev, 0);
+        wssirq[dev] = pnp_irq(pdev, 0);
 
         /* allocate SB16 resources */
         pdev = acard->play;
-        if (pdev->prepare(pdev)<0) {
-                acard->cap->deactivate(acard->cap);
-                return -EAGAIN;
-        }
+        pnp_init_resource_table(cfg);
         if (sbport[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], sbport[dev], 16);
+                pnp_resource_change(&cfg->port_resource[0], sbport[dev], 16);
         if (sbdma8[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], sbdma8[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[0], sbdma8[dev], 1);
         if (sbdma16[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], sbdma16[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[1], sbdma16[dev], 1);
         if (sbirq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], sbirq[dev], 1);
-
-        if (pdev->activate(pdev)<0) {
-                snd_printk("CMI8330/C3D (SB16) PnP configure failure\n");
-                acard->cap->deactivate(acard->cap);
+                pnp_resource_change(&cfg->irq_resource[0], sbirq[dev], 1);
+
+        err = pnp_manual_config_dev(pdev, cfg, 0);
+        if (err < 0)
+                snd_printk(KERN_ERR "CMI8330/C3D (SB16) PnP manual resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR "CMI8330/C3D (SB16) PnP configure failure\n");
+                kfree(cfg);
                 return -EBUSY;
         }
-        sbport[dev] = pdev->resource[0].start;
-        sbdma8[dev] = pdev->dma_resource[0].start;
-        sbdma16[dev] = pdev->dma_resource[1].start;
-        sbirq[dev] = pdev->irq_resource[0].start;
-
+        sbport[dev] = pnp_port_start(pdev, 0);
+        sbdma8[dev] = pnp_dma(pdev, 0);
+        sbdma16[dev] = pnp_dma(pdev, 1);
+        sbirq[dev] = pnp_irq(pdev, 0);
+
+        kfree(cfg);
         return 0;
-}
-
-static void snd_cmi8330_deactivate(struct snd_cmi8330 *acard)
-{
-        if (acard->cap) {
-                acard->cap->deactivate(acard->cap);
-                acard->cap = NULL;
-        }
-        if (acard->play) {
-                acard->play->deactivate(acard->play);
-                acard->play = NULL;
-        }
 }
 #endif
@@ -429 +410 @@
 }
 
-static int __init snd_cmi8330_pcm(snd_card_t *card, struct snd_cmi8330 *chip)
+static int __devinit snd_cmi8330_pcm(snd_card_t *card, struct snd_cmi8330 *chip)
 {
         snd_pcm_t *pcm;
@@ -472 +453 @@
  */
 
-static void snd_cmi8330_free(snd_card_t *card)
-{
-        struct snd_cmi8330 *acard = (struct snd_cmi8330 *)card->private_data;
-
-        if (acard) {
-#ifdef __ISAPNP__
-                snd_cmi8330_deactivate(acard);
-#endif
-        }
-}
-
-static int __init snd_cmi8330_probe(int dev)
+static int __devinit snd_cmi8330_probe(int dev,
+                                       struct pnp_card_link *pcard,
+                                       const struct pnp_card_device_id *pid)
 {
         snd_card_t *card;
@@ -490 +462 @@
         int i, err;
 
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (!isapnp[dev]) {
 #endif
@@ -501 +473 @@
                         return -EINVAL;
                 }
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         }
 #endif
@@ -512 +484 @@
         acard = (struct snd_cmi8330 *)card->private_data;
         acard->card = card;
-        card->private_free = snd_cmi8330_free;
-
-#ifdef __ISAPNP__
-        if (isapnp[dev] && (err = snd_cmi8330_isapnp(dev, acard)) < 0) {
+
+#ifdef CONFIG_PNP
+        if (isapnp[dev] && (err = snd_cmi8330_pnp(dev, acard, pcard, pid)) < 0) {
                 snd_printk("PnP detection failed\n");
                 snd_card_free(card);
@@ -585 +556 @@
         }
 
-        snd_cmi8330_cards[dev] = card;
+        if (pcard)
+                pnp_set_card_drvdata(pcard, card);
+        else
+                snd_cmi8330_legacy[dev] = card;
         return 0;
 }
 
-static void __exit alsa_card_cmi8330_exit(void)
-{
-        int i;
-
-        for (i = 0; i < SNDRV_CARDS; i++)
-                snd_card_free(snd_cmi8330_cards[i]);
-}
-
-#ifdef __ISAPNP__
-static int __init snd_cmi8330_isapnp_detect(struct isapnp_card *card,
-                                            const struct isapnp_card_id *id)
+#ifdef CONFIG_PNP
+static int __devinit snd_cmi8330_pnp_detect(struct pnp_card_link *card,
+                                            const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -607 +573 @@
                 if (!enable[dev] || !isapnp[dev])
                         continue;
-                snd_cmi8330_isapnp_cards[dev] = card;
-                snd_cmi8330_isapnp_id[dev] = id;
-                res = snd_cmi8330_probe(dev);
+                res = snd_cmi8330_probe(dev, card, id);
                 if (res < 0)
                         return res;
@@ -617 +581 @@
         return -ENODEV;
 }
-#endif /* __ISAPNP__ */
+
+static void __devexit snd_cmi8330_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver cmi8330_pnpc_driver = {
+        .flags = PNP_DRIVER_RES_DISABLE,
+        .name = "cmi8330",
+        .id_table = snd_cmi8330_pnpids,
+        .probe = snd_cmi8330_pnp_detect,
+        .remove = __devexit_p(snd_cmi8330_pnp_remove),
+};
+#endif /* CONFIG_PNP */
 
 static int __init alsa_card_cmi8330_init(void)
@@ -626 +606 @@
                 if (!enable[dev])
                         continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                         continue;
 #endif
-                if (snd_cmi8330_probe(dev) >= 0)
+                if (snd_cmi8330_probe(dev, NULL, NULL) >= 0)
                         cards++;
         }
-#ifdef __ISAPNP__
-        cards += isapnp_probe_cards(snd_cmi8330_pnpids, snd_cmi8330_isapnp_detect);
+#ifdef CONFIG_PNP
+        cards += pnp_register_card_driver(&cmi8330_pnpc_driver);
 #endif
 
         if (!cards) {
+#ifdef CONFIG_PNP
+                pnp_unregister_card_driver(&cmi8330_pnpc_driver);
+#endif
 #ifdef MODULE
-                printk(KERN_ERR "CMI8330 not found or device busy\n");
+                snd_printk(KERN_ERR "CMI8330 not found or device busy\n");
 #endif
                 return -ENODEV;
         }
         return 0;
+}
+
+static void __exit alsa_card_cmi8330_exit(void)
+{
+        int i;
+
+#ifdef CONFIG_PNP
+        /* PnP cards first */
+        pnp_unregister_card_driver(&cmi8330_pnpc_driver);
+#endif
+        for (i = 0; i < SNDRV_CARDS; i++)
+                snd_card_free(snd_cmi8330_legacy[i]);
 }
 
@@ -675 +670 @@
                get_option(&str,&wssirq[nr_dev]) == 2 &&
                get_option(&str,&wssdma[nr_dev]) == 2);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (pnp != INT_MAX)
                 isapnp[nr_dev] = pnp;

GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4231_lib.c

@@ -449 +449 @@
         int result = 0;
         unsigned int what;
+        struct list_head *pos;
         snd_pcm_substream_t *s;
         int do_start;
@@ -468 +469 @@
 
         what = 0;
-        s = substream;
-                do {
+        snd_pcm_group_for_each(pos, substream) {
+                s = snd_pcm_group_substream_entry(pos);
                         if (s == chip->playback_substream) {
                                 what |= CS4231_PLAYBACK_ENABLE;
@@ -477 +478 @@
                                 snd_pcm_trigger_done(s, substream);
                         }
-                        s = s->link_next;
-                } while (s != substream);
+        }
                 spin_lock(&chip->reg_lock);
         if (do_start) {
@@ -968 +968 @@
 }
 
-void snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        cs4231_t *chip = snd_magic_cast(cs4231_t, dev_id, return);
+irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        cs4231_t *chip = snd_magic_cast(cs4231_t, dev_id, return IRQ_NONE);
         unsigned char status;
 
@@ -999 +999 @@
         snd_cs4231_outm(chip, CS4231_IRQ_STATUS, ~CS4231_ALL_IRQS | ~status, 0);
         spin_unlock(&chip->reg_lock);
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4236.c

@@ -23 +23 @@
 #include <linux/init.h>
 #include <linux/slab.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #include <sound/cs4231.h>
@@ -88 +84 @@
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 #ifdef TARGET_OS2
 static int isapnp[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
@@ -114 +110 @@
 MODULE_PARM_DESC(enable, "Enable " IDENT " soundcard.");
 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
 MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
@@ -149 +145 @@
 struct snd_card_cs4236 {
         struct resource *res_sb_port;
-#ifdef __ISAPNP__
-        struct isapnp_dev *wss;
-        struct isapnp_dev *ctrl;
-        struct isapnp_dev *mpu;
+#ifdef CONFIG_PNP
+        struct pnp_dev *wss;
+        struct pnp_dev *ctrl;
+        struct pnp_dev *mpu;
 #endif
 };
 
-static snd_card_t *snd_cs4236_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-
-static struct isapnp_card *snd_cs4236_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_cs4236_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
+static snd_card_t *snd_cs4236_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+
+#ifdef CONFIG_PNP
 
 #ifdef TARGET_OS2
@@ -209 +202 @@
 
 #ifdef CS4232
-static struct isapnp_card_id snd_card_pnpids[] __devinitdata = {
+static struct pnp_card_device_id snd_cs423x_pnpids[] __devinitdata = {
         /* Philips PCA70PS */
-        ISAPNP_CS4232_1('C','S','C',0x0d32,0x0000,0x0010,0xb006),
+        { .id = "CSC0d32", .devs = { { "CSC0000" }, { "CSC0010" }, { "PNPb006" } } },
         /* TerraTec Maestro 32/96 (CS4232) */
-        ISAPNP_CS4232('C','S','C',0x1a32,0x0000,0x0010,0x0003),
+        { .id = "CSC1a32", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* HP Omnibook 5500 onboard */
-        ISAPNP_CS4232('C','S','C',0x4232,0x0000,0x0002,0x0003),
+        { .id = "CSC4232", .devs = { { "CSC0000" }, { "CSC0002" }, { "CSC0003" } } },
         /* Unnamed CS4236 card (Made in Taiwan) */
-        ISAPNP_CS4232('C','S','C',0x4236,0x0000,0x0010,0x0003),
+        { .id = "CSC4236", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Turtle Beach TBS-2000 (CS4232) */
-        ISAPNP_CS4232('C','S','C',0x7532,0x0000,0x0010,0xb006),
+        { .id = "CSC7532", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSCb006" } } },
         /* Turtle Beach Tropez Plus (CS4232) */
-        ISAPNP_CS4232_1('C','S','C',0x7632,0x0000,0x0010,0xb006),
+        { .id = "CSC7632", .devs = { { "CSC0000" }, { "CSC0010" }, { "PNPb006" } } },
         /* SIC CrystalWave 32 (CS4232) */
-        ISAPNP_CS4232('C','S','C',0xf032,0x0000,0x0010,0x0003),
+        { .id = "CSCf032", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* --- */
-        { ISAPNP_CARD_END, }    /* end */
+        { .id = "" }    /* end */
 };
 #else /* CS4236 */
-static struct isapnp_card_id snd_card_pnpids[] __devinitdata = {
+static struct pnp_card_device_id snd_cs423x_pnpids[] __devinitdata = {
         /* Intel Marlin Spike Motherboard - CS4235 */
-        ISAPNP_CS4232('C','S','C',0x0225,0x0000,0x0010,0x0003),
+        { .id = "CSC0225", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Intel Marlin Spike Motherboard (#2) - CS4235 */
-        ISAPNP_CS4232('C','S','C',0x0225,0x0100,0x0110,0x0103),
+        { .id = "CSC0225", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
         /* Genius Sound Maker 3DJ - CS4237B */
-        ISAPNP_CS4232('C','S','C',0x0437,0x0000,0x0010,0x0003),
+        { .id = "CSC0437", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Digital PC 5000 Onboard - CS4236B */
-        ISAPNP_CS4232_WOMPU('C','S','C',0x0735,0x0000,0x0010),
+        { .id = "CSC0735", .devs = { { "CSC0000" }, { "CSC0010" } } },
         /* some uknown CS4236B */
-        ISAPNP_CS4232('C','S','C',0x0b35,0x0000,0x0010,0x0003),
+        { .id = "CSC0b35", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Intel PR440FX Onboard sound */
-        ISAPNP_CS4232('C','S','C',0x0b36,0x0000,0x0010,0x0003),
+        { .id = "CSC0b36", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* CS4235 on mainboard without MPU */
-        ISAPNP_CS4232_WOMPU('C','S','C',0x1425,0x0100,0x0110),
+        { .id = "CSC1425", .devs = { { "CSC0100" }, { "CSC0110" } } },
         /* Gateway E1000 Onboard CS4236B */
-        ISAPNP_CS4232('C','S','C',0x1335,0x0000,0x0010,0x0003),
+        { .id = "CSC1335", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* HP 6330 Onboard sound */
-        ISAPNP_CS4232('C','S','C',0x1525,0x0100,0x0110,0x0103),
+        { .id = "CSC1525", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
         /* Crystal Computer TidalWave128 */
-        ISAPNP_CS4232('C','S','C',0x1e37,0x0000,0x0010,0x0003),
+        { .id = "CSC1e37", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* ACER AW37 - CS4235 */
-        ISAPNP_CS4232('C','S','C',0x4236,0x0000,0x0010,0x0003),
+        { .id = "CSC4236", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* build-in soundcard in EliteGroup P5TX-LA motherboard - CS4237B */
-        ISAPNP_CS4232('C','S','C',0x4237,0x0000,0x0010,0x0003),
+        { .id = "CSC4237", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Crystal 3D - CS4237B */
-        ISAPNP_CS4232('C','S','C',0x4336,0x0000,0x0010,0x0003),
+        { .id = "CSC4336", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Typhoon Soundsystem PnP - CS4236B */
-        ISAPNP_CS4232('C','S','C',0x4536,0x0000,0x0010,0x0003),
+        { .id = "CSC4536", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Crystal CX4235-XQ3 EP - CS4235 */
-        ISAPNP_CS4232('C','S','C',0x4625,0x0100,0x0110,0x0103),
+        { .id = "CSC4625", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
+        /* Crystal Semiconductors CS4237B */
+        { .id = "CSC4637", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
+        /* NewClear 3D - CX4237B-XQ3 */
+        { .id = "CSC4837", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
+        /* Dell Optiplex GX1 - CS4236B */
+        { .id = "CSC6835", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
+        /* Dell P410 motherboard - CS4236B */
+        { .id = "CSC6835", .devs = { { "CSC0000" }, { "CSC0010" } } },
+        /* Dell Workstation 400 Onboard - CS4236B */
+        { .id = "CSC6836", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
+        /* Turtle Beach Malibu - CS4237B */
+        { .id = "CSC7537", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
+        /* CS4235 - onboard */
+        { .id = "CSC8025", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
+        /* IBM Aptiva 2137 E24 Onboard - CS4237B */
+        { .id = "CSC8037", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
+        /* IBM IntelliStation M Pro motherboard */
+        { .id = "CSCc835", .devs = { { "CSC0000" }, { "CSC0010" } } },
+        /* Guillemot MaxiSound 16 PnP - CS4236B */
+        { .id = "CSC9836", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
+        /* Gallant SC-70P */
+        { .id = "CSC9837", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* TerraTec AudioSystem EWS64XL - CS4236B */
-        ISAPNP_CS4232('C','S','C',0xa836,0xa800,0xa810,0xa803),
+        { .id = "CSCa836", .devs = { { "CSCa800" }, { "CSCa810" }, { "CSCa803" } } },
         /* TerraTec AudioSystem EWS64XL - CS4236B */
-        ISAPNP_CS4232_WOMPU('C','S','C',0xa836,0xa800,0xa810),
-        /* Crystal Semiconductors CS4237B */
-        ISAPNP_CS4232('C','S','C',0x4637,0x0000,0x0010,0x0003),
-        /* NewClear 3D - CX4237B-XQ3 */
-        ISAPNP_CS4232('C','S','C',0x4837,0x0000,0x0010,0x0003),
-        /* Dell Optiplex GX1 - CS4236B */
-        ISAPNP_CS4232('C','S','C',0x6835,0x0000,0x0010,0x0003),
-        /* Dell P410 motherboard - CS4236B */
-        ISAPNP_CS4232_WOMPU('C','S','C',0x6835,0x0000,0x0010),
-        /* Dell Workstation 400 Onboard - CS4236B */
-        ISAPNP_CS4232('C','S','C',0x6836,0x0000,0x0010,0x0003),
-        /* Turtle Beach Malibu - CS4237B */
-        ISAPNP_CS4232('C','S','C',0x7537,0x0000,0x0010,0x0003),
-        /* CS4235 - onboard */
-        ISAPNP_CS4232('C','S','C',0x8025,0x0100,0x0110,0x0103),
+        { .id = "CSCa836", .devs = { { "CSCa800" }, { "CSCa810" } } },
+        /* ACER AW37/Pro - CS4235 */
+        { .id = "CSCd925", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
+        /* ACER AW35/Pro - CS4237B */
+        { .id = "CSCd937", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
+        /* CS4235 without MPU401 */
+        { .id = "CSCe825", .devs = { { "CSC0100" }, { "CSC0110" } } },
+        /* IBM IntelliStation M Pro 6898 11U - CS4236B */
+        { .id = "CSCe835", .devs = { { "CSC0000" }, { "CSC0010" } } },
         /* IBM PC 300PL Onboard - CS4236B */
-        ISAPNP_CS4232_WOMPU('C','S','C',0xe836,0x0000,0x0010),
-        /* IBM Aptiva 2137 E24 Onboard - CS4237B */
-        ISAPNP_CS4232('C','S','C',0x8037,0x0000,0x0010,0x0003),
-        /* IBM IntelliStation M Pro motherboard */
-        ISAPNP_CS4232_WOMPU('C','S','C',0xc835,0x0000,0x0010),
-        /* Guillemot MaxiSound 16 PnP - CS4236B */
-        ISAPNP_CS4232('C','S','C',0x9836,0x0000,0x0010,0x0003),
-        /* Gallant SC-70P */
-        ISAPNP_CS4232('C','S','C',0x9837,0x0000,0x0010,0x0003),
-        /* ACER AW37/Pro - CS4235 */
-        ISAPNP_CS4232('C','S','C',0xd925,0x0000,0x0010,0x0003),
-        /* ACER AW35/Pro - CS4237B */
-        ISAPNP_CS4232('C','S','C',0xd937,0x0000,0x0010,0x0003),
-        /* CS4235 without MPU401 */
-        ISAPNP_CS4232_WOMPU('C','S','C',0xe825,0x0100,0x0110),
-        /* IBM IntelliStation M Pro 6898 11U - CS4236B */
-        ISAPNP_CS4232_WOMPU('C','S','C',0xe835,0x0000,0x0010),
+        { .id = "CSCe836", .devs = { { "CSC0000" }, { "CSC0010" } } },
         /* Some noname CS4236 based card */
-        ISAPNP_CS4232('C','S','C',0xe936,0x0000,0x0010,0x0003),
+        { .id = "CSCe936", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* CS4236B */
-        ISAPNP_CS4232('C','S','C',0xf235,0x0000,0x0010,0x0003),
+        { .id = "CSCf235", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* CS4236B */
-        ISAPNP_CS4232('C','S','C',0xf238,0x0000,0x0010,0x0003),
+        { .id = "CSCf238", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* --- */
-        { ISAPNP_CARD_END, }    /* end */
+        { .id = "" }    /* end */
 };
 #endif
 
-ISAPNP_CARD_TABLE(snd_card_pnpids);
-
-static int __init snd_card_cs4236_isapnp(int dev, struct snd_card_cs4236 *acard)
-{
-        const struct isapnp_card_id *id = snd_cs4236_isapnp_id[dev];
-        struct isapnp_card *card = snd_cs4236_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-        
-        acard->wss = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (acard->wss->active) {
-                acard->wss = NULL;
+MODULE_DEVICE_TABLE(pnp_card, snd_cs423x_pnpids);
+
+static int __devinit snd_card_cs4236_pnp(int dev, struct snd_card_cs4236 *acard,
+                                         struct pnp_card_link *card,
+                                         const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
+        int err;
+
+        acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (acard->wss == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
-        acard->ctrl = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
-        if (acard->ctrl->active) {
-                acard->wss = acard->ctrl = NULL;
+        acard->ctrl = pnp_request_card_device(card, id->devs[1].id, NULL);
+        if (acard->ctrl == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
-        if (id->devs[2].vendor && id->devs[2].function) {
-                acard->mpu = isapnp_find_dev(card, id->devs[2].vendor, id->devs[2].function, NULL);
-                if (acard->mpu->active) {
-                        acard->wss = acard->ctrl = acard->mpu = NULL;
+        if (id->devs[2].id[0]) {
+                acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL);
+                if (acard->mpu == NULL) {
+                        kfree(cfg);
                         return -EBUSY;
                 }
@@ -334 +329 @@
         /* WSS initialization */
         pdev = acard->wss;
-        if (pdev->prepare(pdev) < 0)
-                return -EAGAIN;
+        pnp_init_resource_table(cfg);
         if (port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], port[dev], 4);
+                pnp_resource_change(&cfg->port_resource[0], port[dev], 4);
         if (fm_port[dev] != SNDRV_AUTO_PORT && fm_port[dev] >= 0)
-                isapnp_resource_change(&pdev->resource[1], fm_port[dev], 4);
+                pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
         if (sb_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[2], sb_port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[2], sb_port[dev], 16);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
         if (dma1[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma1[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
         if (dma2[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma2[dev] < 0 ? 4 : dma2[dev], 1);
-        if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR IDENT " isapnp configure failed for WSS (out of resources?)\n");
+                pnp_resource_change(&cfg->dma_resource[1], dma2[dev] < 0 ? 4 : dma2[dev], 1);
+        err = pnp_manual_config_dev(pdev, cfg, 0);
+        if (err < 0)
+                snd_printk(KERN_ERR IDENT " WSS PnP manual resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                kfree(cfg);
+                printk(KERN_ERR IDENT " WSS PnP configure failed for WSS (out of resources?)\n");
                 return -EBUSY;
         }
-        port[dev] = pdev->resource[0].start;
+        port[dev] = pnp_port_start(pdev, 0);
         if (fm_port[dev] >= 0)
-                fm_port[dev] = pdev->resource[1].start;
-        sb_port[dev] = pdev->resource[2].start;
-        irq[dev] = pdev->irq_resource[0].start;
-        dma1[dev] = pdev->dma_resource[0].start;
-        dma2[dev] = pdev->dma_resource[1].start == 4 ? -1 : (int)pdev->dma_resource[1].start;
+                fm_port[dev] = pnp_port_start(pdev, 1);
+        sb_port[dev] = pnp_port_start(pdev, 2);
+        irq[dev] = pnp_irq(pdev, 0);
+        dma1[dev] = pnp_dma(pdev, 0);
+        dma2[dev] = pnp_dma(pdev, 1) == 4 ? -1 : (int)pnp_dma(pdev, 1);
         snd_printdd("isapnp WSS: wss port=0x%lx, fm port=0x%lx, sb port=0x%lx\n",
                         port[dev], fm_port[dev], sb_port[dev]);
@@ -366 +365 @@
         if (acard->ctrl && cport[dev] >= 0) {
         pdev = acard->ctrl;
-        if (pdev->prepare(pdev) < 0) {
-                acard->wss->deactivate(acard->wss);
-                return -EAGAIN;
-        }
+                pnp_init_resource_table(cfg);
                 if (cport[dev] != SNDRV_AUTO_PORT)
-                        isapnp_resource_change(&pdev->resource[0], cport[dev], 8);
-        if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR IDENT " isapnp configure failed for control (out of resources?)\n");
-                acard->wss->deactivate(acard->wss);
+                        pnp_resource_change(&cfg->port_resource[0], cport[dev], 8);
+                err = pnp_manual_config_dev(pdev, cfg, 0);
+                if (err < 0)
+                        snd_printk(KERN_ERR IDENT " CTRL PnP manual resources are invalid, using auto config\n");
+                err = pnp_activate_dev(pdev);
+                if (err < 0) {
+                        kfree(cfg);
+                        printk(KERN_ERR IDENT " CTRL PnP configure failed for WSS (out of resources?)\n");
                 return -EBUSY;
         }
-                cport[dev] = pdev->resource[0].start;
+                cport[dev] = pnp_port_start(pdev, 0);
                 snd_printdd("isapnp CTRL: control port=0x%lx\n", cport[dev]);
         }
@@ -383 +383 @@
         if (acard->mpu && mpu_port[dev] >= 0) {
                 pdev = acard->mpu;
-                if (pdev->prepare(pdev) < 0) {
-                        acard->wss->deactivate(acard->wss);
-                        acard->ctrl->deactivate(acard->ctrl);
-                        return -EAGAIN;
-                }
+                pnp_init_resource_table(cfg);
                 if (mpu_port[dev] != SNDRV_AUTO_PORT)
-                        isapnp_resource_change(&pdev->resource[0], mpu_port[dev], 2);
+                        pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
                 if (mpu_irq[dev] != SNDRV_AUTO_IRQ && mpu_irq[dev] >= 0)
-                        isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev], 1);
-                if (pdev->activate(pdev)<0) {
+                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
+                err = pnp_manual_config_dev(pdev, cfg, 0);
+                if (err < 0)
+                        snd_printk(KERN_ERR IDENT " MPU401 PnP manual resources are invalid, using auto config\n");
+                err = pnp_activate_dev(pdev);
+                if (err < 0) {
+                        kfree(cfg);
+                        printk(KERN_ERR IDENT " MPU401 PnP configure failed for WSS (out of resources?)\n");
                         mpu_port[dev] = SNDRV_AUTO_PORT;
                         mpu_irq[dev] = SNDRV_AUTO_IRQ;
-                        printk(KERN_ERR IDENT " isapnp configure failed for MPU (out of resources?)\n");
                 } else {
-                        mpu_port[dev] = pdev->resource[0].start;
-                        if ((pdev->irq_resource[0].flags & IORESOURCE_IRQ) &&
-                            mpu_irq[dev] >= 0) {
-                                mpu_irq[dev] = pdev->irq_resource[0].start;
+                        mpu_port[dev] = pnp_port_start(pdev, 0);
+                        if (pnp_irq_valid(pdev, 0) && pnp_irq(pdev, 0) >= 0) {
+                                mpu_irq[dev] = pnp_irq(pdev, 0);
                         } else {
                                 mpu_irq[dev] = -1;      /* disable interrupt */
@@ -407 +407 @@
                 snd_printdd("isapnp MPU: port=0x%lx, irq=%i\n", mpu_port[dev], mpu_irq[dev]);
         }
+        kfree(cfg);
         return 0;
 }
-
-static void snd_card_cs4236_deactivate(struct snd_card_cs4236 *acard)
-{
-        if (acard->wss) {
-                acard->wss->deactivate(acard->wss);
-                acard->wss = NULL;
-        }
-        if (acard->ctrl) {
-                acard->ctrl->deactivate(acard->ctrl);
-                acard->ctrl = NULL;
-        }
-        if (acard->mpu) {
-                acard->mpu->deactivate(acard->mpu);
-                acard->mpu = NULL;
-        }
-}
 #endif
 
@@ -432 +417 @@
 
         if (acard) {
-#ifdef __ISAPNP__
-                snd_card_cs4236_deactivate(acard);
-#endif
                 if (acard->res_sb_port) {
                         release_resource(acard->res_sb_port);
@@ -442 +424 @@
 }
 
-static int __init snd_card_cs4236_probe(int dev)
+static int __devinit snd_card_cs423x_probe(int dev, struct pnp_card_link *pcard,
+                                           const struct pnp_card_device_id *pid)
 {
         snd_card_t *card;
@@ -451 +434 @@
         int err;
 
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (!isapnp[dev]) {
 #endif
@@ -462 +445 @@
                         return -EINVAL;
                 }
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         }
 #endif
@@ -471 +454 @@
         acard = (struct snd_card_cs4236 *)card->private_data;
         card->private_free = snd_card_cs4236_free;
-#ifdef __ISAPNP__
-        if (isapnp[dev] && (err = snd_card_cs4236_isapnp(dev, acard))<0) {
+#ifdef CONFIG_PNP
+        if (isapnp[dev] && (err = snd_card_cs4236_pnp(dev, acard, pcard, pid))<0) {
                 printk(KERN_ERR "isapnp detection failed and probing for " IDENT " is not supported\n");
                 snd_card_free(card);
@@ -574 +557 @@
                 return err;
         }
-        snd_cs4236_cards[dev] = card;
+        if (pcard)
+                pnp_set_card_drvdata(pcard, card);
+        else
+                snd_cs4236_legacy[dev] = card;
         return 0;
 }
 
-#ifdef __ISAPNP__
-static int __init snd_cs4236_isapnp_detect(struct isapnp_card *card,
-                                           const struct isapnp_card_id *id)
+#ifdef CONFIG_PNP
+static int __devinit snd_cs423x_pnp_detect(struct pnp_card_link *card,
+                                           const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -588 +574 @@
                 if (!enable[dev])
                         continue;
-                snd_cs4236_isapnp_cards[dev] = card;
-                snd_cs4236_isapnp_id[dev] = id;
-                res = snd_card_cs4236_probe(dev);
+                res = snd_card_cs423x_probe(dev, card, id);
                 if (res < 0)
                         return res;
@@ -598 +582 @@
         return -ENODEV;
 }
-#endif /* __ISAPNP__ */
+
+static void __devexit snd_cs423x_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+        
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+                        
+static struct pnp_card_driver cs423x_pnpc_driver = {
+        .flags = PNP_DRIVER_RES_DISABLE,
+        .name = "cs423x",
+        .id_table = snd_cs423x_pnpids,
+        .probe = snd_cs423x_pnp_detect,
+        .remove = __devexit_p(snd_cs423x_pnp_remove),
+};
+#endif /* CONFIG_PNP */
 
 static int __init alsa_card_cs423x_init(void)
@@ -607 +607 @@
                 if (!enable[dev])
                         continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                         continue;
 #endif
-                if (snd_card_cs4236_probe(dev) >= 0)
+                if (snd_card_cs423x_probe(dev, NULL, NULL) >= 0)
                         cards++;
         }
-#ifdef __ISAPNP__
-        cards += isapnp_probe_cards(snd_card_pnpids, snd_cs4236_isapnp_detect);
+#ifdef CONFIG_PNP
+        cards += pnp_register_card_driver(&cs423x_pnpc_driver);
 #endif
         if (!cards) {
+#ifdef CONFIG_PNP
+                pnp_unregister_card_driver(&cs423x_pnpc_driver);
+#endif
 #ifdef MODULE
                 printk(KERN_ERR IDENT " soundcard not found or device busy\n");
@@ -630 +633 @@
         int idx;
 
+#ifdef CONFIG_PNP
+        /* PnP cards first */
+        pnp_unregister_card_driver(&cs423x_pnpc_driver);
+#endif
         for (idx = 0; idx < SNDRV_CARDS; idx++)
-                snd_card_free(snd_cs4236_cards[idx]);
+                snd_card_free(snd_cs4236_legacy[idx]);
 }
 
@@ -666 +673 @@
                get_option(&str,&dma1[nr_dev]) == 2 &&
                get_option(&str,&dma2[nr_dev]) == 2);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (pnp != INT_MAX)
                 isapnp[nr_dev] = pnp;

GPL/branches/alsa-resync1/alsa-kernel/isa/dt019x.c

@@ -26 +26 @@
 #include <linux/sched.h>
 #include <linux/wait.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #define SNDRV_GET_ID
@@ -88 +84 @@
 
 struct snd_card_dt019x {
-#ifdef __ISAPNP__
-        struct isapnp_dev *dev;
-        struct isapnp_dev *devmpu;
-        struct isapnp_dev *devopl;
-#endif  /* __ISAPNP__ */
+        struct pnp_dev *dev;
+        struct pnp_dev *devmpu;
+        struct pnp_dev *devopl;
 };
 
-static snd_card_t *snd_dt019x_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-static struct isapnp_card *snd_dt019x_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_dt019x_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-
-static struct isapnp_card_id snd_dt019x_pnpids[] __devinitdata = {
+static struct pnp_card_device_id snd_dt019x_pnpids[] __devinitdata = {
         /* DT197A30 */
-        {
-                ISAPNP_CARD_ID('R','W','B',0x1688),
-                .devs = { ISAPNP_DEVICE_ID('@','@','@',0x0001),
-                        ISAPNP_DEVICE_ID('@','X','@',0x0001),
-                        ISAPNP_DEVICE_ID('@','H','@',0x0001) }
-        },
+        { .id = "RWB1688", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" }, } },
         /* DT0196 / ALS-007 */
-        {
-                ISAPNP_CARD_ID('A','L','S',0x0007),
-                .devs = { ISAPNP_DEVICE_ID('@','@','@',0x0001),
-                        ISAPNP_DEVICE_ID('@','X','@',0x0001),
-                        ISAPNP_DEVICE_ID('@','H','@',0x0001) }
-        },
-        { ISAPNP_CARD_END, }
+        { .id = "ALS0007", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" }, } },
+        { .id = "",  }
 };
 
-ISAPNP_CARD_TABLE(snd_dt019x_pnpids);
-
-#endif  /* __ISAPNP__ */
+MODULE_DEVICE_TABLE(pnp_card, snd_dt019x_pnpids);
+
 
 #define DRIVER_NAME     "snd-card-dt019x"
 
 
-#ifdef __ISAPNP__
-static int __init snd_card_dt019x_isapnp(int dev, struct snd_card_dt019x *acard)
-{
-        const struct isapnp_card_id *id = snd_dt019x_isapnp_id[dev];
-        struct isapnp_card *card = snd_dt019x_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-
-        acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (acard->dev->active) {
-                acard->dev = NULL;
-                return -EBUSY;
-        }
-        acard->devmpu = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
-        if (acard->devmpu->active) {
-                acard->dev = acard->devmpu = NULL;
-                return -EBUSY;
-        }
-        acard->devopl = isapnp_find_dev(card, id->devs[2].vendor, id->devs[2].function, NULL);
-        if (acard->devopl->active) {
-                acard->dev = acard->devmpu = acard->devopl = NULL;
-                return -EBUSY;
-        }
+static int __devinit snd_card_dt019x_pnp(int dev, struct snd_card_dt019x *acard,
+                                         struct pnp_card_link *card,
+                                         const struct pnp_card_device_id *pid)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
+        int err;
+
+        if (!cfg)
+                return -ENOMEM;
+
+        acard->dev = pnp_request_card_device(card, pid->devs[0].id, NULL);
+        if (acard->dev == NULL) {
+                kfree (cfg);
+                return -ENODEV;
+        }
+        acard->devmpu = pnp_request_card_device(card, pid->devs[1].id, NULL);
+        acard->devopl = pnp_request_card_device(card, pid->devs[2].id, NULL);
 
         pdev = acard->dev;
-        if (!pdev || pdev->prepare(pdev)<0)
-                return -EAGAIN;
+        pnp_init_resource_table(cfg);
 
         if (port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
         if (dma8[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma8[dev],
+                pnp_resource_change(&cfg->dma_resource[0], dma8[dev],
                         1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
-
-        if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR PFX "DT-019X AUDIO isapnp configure failure\n");
-                return -EBUSY;
-        }
-        port[dev] = pdev->resource[0].start;
-        dma8[dev] = pdev->dma_resource[0].start;
-        irq[dev] = pdev->irq_resource[0].start;
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
+
+        if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
+                snd_printk(KERN_ERR PFX "DT-019X AUDIO the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR PFX "DT-019X AUDIO pnp configure failure\n");
+                kfree(cfg);
+                return err;
+        }
+
+        port[dev] = pnp_port_start(pdev, 0);
+        dma8[dev] = pnp_dma(pdev, 0);
+        irq[dev] = pnp_irq(pdev, 0);
         snd_printdd("dt019x: found audio interface: port=0x%lx, irq=0x%lx, dma=0x%lx\n",
                         port[dev],irq[dev],dma8[dev]);
 
         pdev = acard->devmpu;
-        if (!pdev || pdev->prepare(pdev)<0) 
-                return 0;
-
-        if (mpu_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], mpu_port[dev],
-                        2);
-        if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev],
-                        1);
-
-        if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR PFX "DT-019X MPU-401 isapnp configure failure\n");
-                mpu_port[dev] = -1;
-                acard->devmpu = NULL;
-        } else {
-                mpu_port[dev] = pdev->resource[0].start;
-                mpu_irq[dev] = pdev->irq_resource[0].start;
+
+        if (pdev != NULL) {
+                pnp_init_resource_table(cfg);
+                if (mpu_port[dev] != SNDRV_AUTO_PORT)
+                        pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
+                if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
+                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
+                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
+                        snd_printk(KERN_ERR PFX "DT-019X MPU401 the requested resources are invalid, using auto config\n");
+                err = pnp_activate_dev(pdev);
+                if (err < 0)
+                        goto __mpu_error;
+                mpu_port[dev] = pnp_port_start(pdev, 0);
+                mpu_irq[dev] = pnp_irq(pdev, 0);
                 snd_printdd("dt019x: found MPU-401: port=0x%lx, irq=0x%lx\n",
                                 mpu_port[dev],mpu_irq[dev]);
+        } else {
+                __mpu_error:
+                if (pdev) {
+                        pnp_release_card_device(pdev);
+                        snd_printk(KERN_ERR PFX "DT-019X MPU401 pnp configure failure, skipping\n");
+                }
+                acard->devmpu = NULL;
+                mpu_port[dev] = -1;
         }
 
         pdev = acard->devopl;
-        if (!pdev || pdev->prepare(pdev)<0)
-                return 0;
-
-        if (fm_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], fm_port[dev], 4);
-
-        if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR PFX "DT-019X OPL3 isapnp configure failure\n");
+        if (pdev != NULL) {
+                pnp_init_resource_table(cfg);
+                if (fm_port[dev] != SNDRV_AUTO_PORT)
+                        pnp_resource_change(&cfg->port_resource[0], fm_port[dev], 4);
+                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
+                        snd_printk(KERN_ERR PFX "DT-019X OPL3 the requested resources are invalid, using auto config\n");
+                err = pnp_activate_dev(pdev);
+                if (err < 0)
+                        goto __fm_error;
+                fm_port[dev] = pnp_port_start(pdev, 0);
+                snd_printdd("dt019x: found OPL3 synth: port=0x%lx\n",fm_port[dev]);
+        } else {
+                __fm_error:
+                if (pdev) {
+                        pnp_release_card_device(pdev);
+                        snd_printk(KERN_ERR PFX "DT-019X OPL3 pnp configure failure, skipping\n");
+                }
+                acard->devopl = NULL;
                 fm_port[dev] = -1;
-                acard->devopl = NULL;
-        } else {
-                fm_port[dev] = pdev->resource[0].start;
-                snd_printdd("dt019x: found OPL3 synth: port=0x%lx\n",fm_port[dev]);
-        }
-
+        }
+
+        kfree(cfg);
         return 0;
 }
 
-static void snd_card_dt019x_deactivate(struct snd_card_dt019x *acard)
-{
-        if (acard->dev) {
-                acard->dev->deactivate(acard->dev);
-                acard->dev = NULL;
-        }
-        if (acard->devmpu) {
-                acard->devmpu->deactivate(acard->devmpu);
-                acard->devmpu = NULL;
-        }
-        if (acard->devopl) {
-                acard->devopl->deactivate(acard->devopl);
-                acard->devopl = NULL;
-        }
-}
-#endif  /* __ISAPNP__ */
-
-static void snd_card_dt019x_free(snd_card_t *card)
-{
-        struct snd_card_dt019x *acard = (struct snd_card_dt019x *)card->private_data;
-
-        if (acard != NULL) {
-#ifdef __ISAPNP__
-                snd_card_dt019x_deactivate(acard);
-#endif  /* __ISAPNP__ */
-        }
-}
-
-static int __init snd_card_dt019x_probe(int dev)
+static int __devinit snd_card_dt019x_probe(int dev, struct pnp_card_link *pcard, const struct pnp_card_device_id *pid)
 {
         int error;
@@ -252 +213 @@
                 return -ENOMEM;
         acard = (struct snd_card_dt019x *)card->private_data;
-        card->private_free = snd_card_dt019x_free;
-
-#ifdef __ISAPNP__
-        if ((error = snd_card_dt019x_isapnp(dev, acard))) {
-                snd_card_free(card);
-                return error;
-        }
-#else
-        printk(KERN_ERR PFX "you have to enable PnP support ...\n");
-        snd_card_free(card);
-        return -ENOSYS;
-#endif  /* __ISAPNP__ */
+
+        if ((error = snd_card_dt019x_pnp(dev, acard, pcard, pid))) {
+                snd_card_free(card);
+                return error;
+        }
 
         if ((error = snd_sbdsp_create(card, port[dev],
@@ -293 +247 @@
                                         SA_INTERRUPT,
                                         NULL) < 0)
-                        printk(KERN_ERR PFX "no MPU-401 device at 0x%lx ?\n",
-                                mpu_port[dev]);
+                        snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx ?\n", mpu_port[dev]);
         }
 
@@ -302 +255 @@
                                     fm_port[dev] + 2,
                                     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);
+                        snd_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, 0, 1)) < 0) {
@@ -325 +278 @@
                 return error;
         }
-        snd_dt019x_cards[dev] = card;
+        pnp_set_card_drvdata(pcard, card);
         return 0;
 }
 
-#ifdef __ISAPNP__
-static int __init snd_dt019x_isapnp_detect(struct isapnp_card *card,
-                                            const struct isapnp_card_id *id)
+static int __devinit snd_dt019x_pnp_probe(struct pnp_card_link *card,
+                                          const struct pnp_card_device_id *pid)
 {
         static int dev;
@@ -339 +291 @@
                 if (!enable[dev])
                         continue;
-                snd_dt019x_isapnp_cards[dev] = card;
-                snd_dt019x_isapnp_id[dev] = id;
-                res = snd_card_dt019x_probe(dev);
+                res = snd_card_dt019x_probe(dev, card, pid);
                 if (res < 0)
                         return res;
@@ -349 +299 @@
         return -ENODEV;
 }
-#endif /* __ISAPNP__ */
+
+static void __devexit snd_dt019x_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver dt019x_pnpc_driver = {
+        .flags          = PNP_DRIVER_RES_DISABLE,
+        .name           = "dt019x",
+        .id_table       = snd_dt019x_pnpids,
+        .probe          = snd_dt019x_pnp_probe,
+        .remove         = __devexit_p(snd_dt019x_pnp_remove),
+};
 
 static int __init alsa_card_dt019x_init(void)
@@ -355 +319 @@
         int cards = 0;
 
-#ifdef __ISAPNP__
-        cards += isapnp_probe_cards(snd_dt019x_pnpids, snd_dt019x_isapnp_detect);
-#else
-        printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
-#endif
+        cards += pnp_register_card_driver(&dt019x_pnpc_driver);
+
 #ifdef MODULE
         if (!cards)
-                printk(KERN_ERR "no DT-019X / ALS-007 based soundcards found\n");
+                snd_printk(KERN_ERR "no DT-019X / ALS-007 based soundcards found\n");
 #endif
         return cards ? 0 : -ENODEV;
@@ -369 +330 @@
 static void __exit alsa_card_dt019x_exit(void)
 {
-        int dev;
-
-        for (dev = 0; dev < SNDRV_CARDS; dev++)
-                snd_card_free(snd_dt019x_cards[dev]);
+        pnp_unregister_card_driver(&dt019x_pnpc_driver);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/es1688/es1688_lib.c

@@ -483 +483 @@
 }
 
-void snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        es1688_t *chip = snd_magic_cast(es1688_t, dev_id, return);
+irqreturn_t snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        es1688_t *chip = snd_magic_cast(es1688_t, dev_id, return IRQ_NONE);
 
         if (chip->trigger_value == 0x05)        /* ok.. playback is active */
@@ -493 +493 @@
 
         inb(ES1688P(chip, DATA_AVAIL)); /* ack interrupt */
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/es18xx.c

@@ -71 +71 @@
 #include <linux/pm.h>
 #include <linux/slab.h>
-#ifndef LINUX_ISAPNP_H
+#include <linux/pnp.h>
 #include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
 #include <sound/core.h>
 #include <sound/control.h>
@@ -731 +728 @@
 }
 
-static void snd_es18xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        es18xx_t *chip = snd_magic_cast(es18xx_t, dev_id, return);
+static irqreturn_t snd_es18xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        es18xx_t *chip = snd_magic_cast(es18xx_t, dev_id, return IRQ_NONE);
         unsigned char status;
-
 
         if (chip->caps & ES18XX_CONTROL) {
@@ -791 +787 @@
                 snd_es18xx_mixer_write(chip, 0x66, 0x00);
         }
-
+        return IRQ_HANDLED;
 }
 
@@ -1264 +1260 @@
 
 #if 0
-static int __init snd_es18xx_config_read(es18xx_t *chip, unsigned char reg)
+static int __devinit snd_es18xx_config_read(es18xx_t *chip, unsigned char reg)
 {
         int data;
@@ -1276 +1272 @@
 #endif
 
-static void __init snd_es18xx_config_write(es18xx_t *chip, 
+static void __devinit snd_es18xx_config_write(es18xx_t *chip, 
                                            unsigned char reg, unsigned char data)
 {
@@ -1288 +1284 @@
 }
 
-static int __init snd_es18xx_initialize(es18xx_t *chip)
+static int __devinit snd_es18xx_initialize(es18xx_t *chip)
 {
         int mask = 0;
@@ -1437 +1433 @@
 }
 
-static int __init snd_es18xx_identify(es18xx_t *chip)
+static int __devinit snd_es18xx_identify(es18xx_t *chip)
 {
         int hi,lo;
@@ -1501 +1497 @@
 }
 
-static int __init snd_es18xx_probe(es18xx_t *chip)
+static int __devinit snd_es18xx_probe(es18xx_t *chip)
 {
         if (snd_es18xx_identify(chip) < 0) {
-                printk(KERN_ERR PFX "[0x%lx] ESS chip not found\n", chip->port);
+                snd_printk(KERN_ERR PFX "[0x%lx] ESS chip not found\n", chip->port);
                 return -ENODEV;
         }
@@ -1570 +1566 @@
 }
 
-int __init snd_es18xx_pcm(es18xx_t *chip, int device, snd_pcm_t ** rpcm)
+int __devinit snd_es18xx_pcm(es18xx_t *chip, int device, snd_pcm_t ** rpcm)
 {
         snd_pcm_t *pcm;
@@ -1715 +1711 @@
 }
 
-static int __init snd_es18xx_new_device(snd_card_t * card,
+static int __devinit snd_es18xx_new_device(snd_card_t * card,
                                         unsigned long port,
                                         unsigned long mpu_port,
@@ -1747 +1743 @@
         if ((chip->res_port = request_region(port, 16, "ES18xx")) == NULL) {
                 snd_es18xx_free(chip);
-                printk(KERN_ERR PFX "unable to grap ports 0x%lx-0x%lx\n", port, port + 16 - 1);
+                snd_printk(KERN_ERR PFX "unable to grap ports 0x%lx-0x%lx\n", port, port + 16 - 1);
                 return -EBUSY;
         }
@@ -1753 +1749 @@
         if (request_irq(irq, snd_es18xx_interrupt, SA_INTERRUPT, "ES18xx", (void *) chip)) {
                 snd_es18xx_free(chip);
-                printk(KERN_ERR PFX "unable to grap IRQ %d\n", irq);
+                snd_printk(KERN_ERR PFX "unable to grap IRQ %d\n", irq);
                 return -EBUSY;
         }
@@ -1760 +1756 @@
         if (request_dma(dma1, "ES18xx DMA 1")) {
                 snd_es18xx_free(chip);
-                printk(KERN_ERR PFX "unable to grap DMA1 %d\n", dma1);
+                snd_printk(KERN_ERR PFX "unable to grap DMA1 %d\n", dma1);
                 return -EBUSY;
         }
@@ -1767 +1763 @@
         if (dma2 != dma1 && request_dma(dma2, "ES18xx DMA 2")) {
                 snd_es18xx_free(chip);
-                printk(KERN_ERR PFX "unable to grap DMA2 %d\n", dma2);
+                snd_printk(KERN_ERR PFX "unable to grap DMA2 %d\n", dma2);
                 return -EBUSY;
         }
@@ -1784 +1780 @@
 }
 
-static int __init snd_es18xx_mixer(es18xx_t *chip)
+static int __devinit snd_es18xx_mixer(es18xx_t *chip)
 {
         snd_card_t *card;
@@ -1887 +1883 @@
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 #ifdef TARGET_OS2
 static int isapnp[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
@@ -1895 +1891 @@
 #endif
 static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* 0x220,0x240,0x260,0x280 */
-#ifndef __ISAPNP__
+#ifndef CONFIG_PNP
 #ifdef TARGET_OS2
 static long mpu_port[SNDRV_CARDS] = {-1,-1,-1,-1,-1,-1,-1,-1};
@@ -1917 +1913 @@
 MODULE_PARM_DESC(enable, "Enable ES18xx soundcard.");
 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
-MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
+MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
 MODULE_PARM_SYNTAX(isapnp, SNDRV_ISAPNP_DESC);
 #endif
@@ -1942 +1938 @@
 
 struct snd_audiodrive {
-#ifdef __ISAPNP__
-        struct isapnp_dev *dev;
-        struct isapnp_dev *devc;
+#ifdef CONFIG_PNP
+        struct pnp_dev *dev;
+        struct pnp_dev *devc;
 #endif
 };
 
-static snd_card_t *snd_audiodrive_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-
-static struct isapnp_card *snd_audiodrive_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_audiodrive_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-
-#define ISAPNP_ES18XX(_va, _vb, _vc, _device, _audio, _control) \
-        { \
-                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
-                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _control) } \
-        }
-
-static struct isapnp_card_id snd_audiodrive_pnpids[] __devinitdata = {
+static snd_card_t *snd_audiodrive_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+
+#ifdef CONFIG_PNP
+
+static struct pnp_card_device_id snd_audiodrive_pnpids[] __devinitdata = {
         /* ESS 1868 (integrated on Compaq dual P-Pro motherboard and Genius 18PnP 3D) */
-        ISAPNP_ES18XX('E','S','S',0x1868,0x1868,0x0000),
+        { .id = "ESS1868", .devs = { { "ESS1868" }, { "ESS0000" } } },
         /* ESS 1868 (integrated on Maxisound Cards) */
-        ISAPNP_ES18XX('E','S','S',0x1868,0x8601,0x8600),
+        { .id = "ESS1868", .devs = { { "ESS8601" }, { "ESS8600" } } },
         /* ESS 1868 (integrated on Maxisound Cards) */
-        ISAPNP_ES18XX('E','S','S',0x1868,0x8611,0x8610),
+        { .id = "ESS1868", .devs = { { "ESS8611" }, { "ESS8610" } } },
         /* ESS ES1869 Plug and Play AudioDrive */
-        ISAPNP_ES18XX('E','S','S',0x0003,0x1869,0x0006),
+        { .id = "ESS0003", .devs = { { "ESS1869" }, { "ESS0006" } } },
         /* ESS 1869 */
-        ISAPNP_ES18XX('E','S','S',0x1869,0x1869,0x0006),
+        { .id = "ESS1869", .devs = { { "ESS1869" }, { "ESS0006" } } },
         /* ESS 1878 */
-        ISAPNP_ES18XX('E','S','S',0x1878,0x1878,0x0004),
+        { .id = "ESS1878", .devs = { { "ESS1878" }, { "ESS0004" } } },
         /* ESS 1879 */
-        ISAPNP_ES18XX('E','S','S',0x1879,0x1879,0x0009),
+        { .id = "ESS1879", .devs = { { "ESS1879" }, { "ESS0009" } } },
         /* --- */
-        { ISAPNP_CARD_END, } /* end */
+        { .id = "" } /* end */
 };
 
-ISAPNP_CARD_TABLE(snd_audiodrive_pnpids);
-
-static int __init snd_audiodrive_isapnp(int dev, struct snd_audiodrive *acard)
-{
-        const struct isapnp_card_id *id = snd_audiodrive_isapnp_id[dev];
-        struct isapnp_card *card = snd_audiodrive_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-
-        acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (acard->dev->active) {
-                acard->dev = NULL;
+MODULE_DEVICE_TABLE(pnp_card, snd_audiodrive_pnpids);
+
+static int __devinit snd_audiodrive_pnp(int dev, struct snd_audiodrive *acard,
+                                        struct pnp_card_link *card,
+                                        const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table * cfg = kmalloc(GFP_ATOMIC, sizeof(struct pnp_resource_table));
+        int err;
+
+        if (!cfg)
+                return -ENOMEM;
+        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (acard->dev == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
-        acard->devc = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
-        if (acard->devc->active) {
-                acard->dev = acard->devc = NULL;
+        acard->devc = pnp_request_card_device(card, id->devs[1].id, NULL);
+        if (acard->devc == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
         /* Control port initialization */
-        if (acard->devc->prepare(acard->devc)<0)
+        err = pnp_activate_dev(acard->devc);
+        if (err < 0) {
+                snd_printk(KERN_ERR PFX "PnP control configure failure (out of resources?)\n");
                 return -EAGAIN;
-        if (acard->devc->activate(acard->devc)<0) {
-                printk(KERN_ERR PFX "isapnp control configure failure (out of resources?)\n");
-                return -EAGAIN;
-        }
-        snd_printdd("isapnp: port=0x%lx\n", acard->devc->resource[0].start);
+        }
+        snd_printdd("pnp: port=0x%lx\n", pnp_port_start(acard->devc, 0));
         /* PnP initialization */
         pdev = acard->dev;
-        if (pdev->prepare(pdev)<0) {
-                acard->devc->deactivate(acard->devc);
-                return -EAGAIN;
-        }
+        pnp_init_resource_table(cfg);
         if (port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
         if (fm_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[1], fm_port[dev], 4);
+                pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
         if (mpu_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[2], mpu_port[dev], 2);
+                pnp_resource_change(&cfg->port_resource[2], mpu_port[dev], 2);
         if (dma1[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma1[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
         if (dma2[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma2[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
-        if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR PFX "isapnp configure failure (out of resources?)\n");
-                acard->devc->deactivate(acard->devc);
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
+        err = pnp_manual_config_dev(pdev, cfg, 0);
+        if (err < 0)
+                snd_printk(KERN_ERR PFX "PnP manual resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR PFX "PnP configure failure (out of resources?)\n");
+                kfree(cfg);
                 return -EBUSY;
         }
         /* ok. hack using Vendor-Defined Card-Level registers */
         /* skip csn and logdev initialization - already done in isapnp_configure */
-        isapnp_cfg_begin(pdev->bus->number, pdev->devfn);
-        isapnp_write_byte(0x27, pdev->irq_resource[0].start);   /* Hardware Volume IRQ Number */
+        if (pnp_device_is_isapnp(pdev)) {
+                isapnp_cfg_begin(isapnp_card_number(pdev), isapnp_csn_number(pdev));
+                isapnp_write_byte(0x27, pnp_irq(pdev, 0));      /* Hardware Volume IRQ Number */
         if (mpu_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_write_byte(0x28, pdev->irq);             /* MPU-401 IRQ Number */
-        isapnp_write_byte(0x72, pdev->irq_resource[0].start);   /* second IRQ */
+                        isapnp_write_byte(0x28, pnp_irq(pdev, 0)); /* MPU-401 IRQ Number */
+                isapnp_write_byte(0x72, pnp_irq(pdev, 0));      /* second IRQ */
         isapnp_cfg_end();
-        port[dev] = pdev->resource[0].start;
-        fm_port[dev] = pdev->resource[1].start;
-        mpu_port[dev] = pdev->resource[2].start;
-        dma1[dev] = pdev->dma_resource[0].start;
-        dma2[dev] = pdev->dma_resource[1].start;
-        irq[dev] = pdev->irq_resource[0].start;
-        snd_printdd("isapnp ES18xx: port=0x%lx, fm port=0x%lx, mpu port=0x%lx\n", port[dev], fm_port[dev], mpu_port[dev]);
-        snd_printdd("isapnp ES18xx: dma1=%i, dma2=%i, irq=%i\n", dma1[dev], dma2[dev], irq[dev]);
-        return 0;
-}
-
-static void snd_audiodrive_deactivate(struct snd_audiodrive *acard)
-{
-        if (acard->devc) {
-                acard->devc->deactivate(acard->devc);
-                acard->devc = NULL;
-        }
-        if (acard->dev) {
-                acard->dev->deactivate(acard->dev);
-                acard->dev = NULL;
-        }
-}
-#endif /* __ISAPNP__ */
-
-static void snd_audiodrive_free(snd_card_t *card)
-{
-        struct snd_audiodrive *acard = (struct snd_audiodrive *)card->private_data;
-
-        if (acard) {
-#ifdef __ISAPNP__
-                snd_audiodrive_deactivate(acard);
-#endif
-        }
-}
-
-static int __init snd_audiodrive_probe(int dev)
+        } else {
+                snd_printk(KERN_ERR PFX "unable to install ISA PnP hack, expect malfunction\n");
+        }
+        port[dev] = pnp_port_start(pdev, 0);
+        fm_port[dev] = pnp_port_start(pdev, 1);
+        mpu_port[dev] = pnp_port_start(pdev, 2);
+        dma1[dev] = pnp_dma(pdev, 0);
+        dma2[dev] = pnp_dma(pdev, 1);
+        irq[dev] = pnp_irq(pdev, 0);
+        snd_printdd("PnP ES18xx: port=0x%lx, fm port=0x%lx, mpu port=0x%lx\n", port[dev], fm_port[dev], mpu_port[dev]);
+        snd_printdd("PnP ES18xx: dma1=%i, dma2=%i, irq=%i\n", dma1[dev], dma2[dev], irq[dev]);
+        kfree(cfg);
+        return 0;
+}
+#endif /* CONFIG_PNP_ */
+
+static int __devinit snd_audiodrive_probe(int dev, struct pnp_card_link *pcard,
+                                          const struct pnp_card_device_id *pid)
 {
         static int possible_irqs[] = {5, 9, 10, 7, 11, 12, -1};
@@ -2090 +2063 @@
                 return -ENOMEM;
         acard = (struct snd_audiodrive *)card->private_data;
-        card->private_free = snd_audiodrive_free;
-#ifdef __ISAPNP__
-        if (isapnp[dev] && (err = snd_audiodrive_isapnp(dev, acard)) < 0) {
+#ifdef CONFIG_PNP
+        if (isapnp[dev] && (err = snd_audiodrive_pnp(dev, acard, pcard, pid)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -2143 +2115 @@
         if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
         if (snd_opl3_create(card, chip->fm_port, chip->fm_port + 2, OPL3_HW_OPL3, 0, &opl3) < 0) {
-                        printk(KERN_ERR PFX "opl3 not detected at 0x%lx\n", chip->fm_port);
+                        snd_printk(KERN_ERR PFX "opl3 not detected at 0x%lx\n", chip->fm_port);
         } else {
                 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
@@ -2189 +2161 @@
                 return err;
         }
-        snd_audiodrive_cards[dev] = card;
-        return 0;
-}
-
-static int __init snd_audiodrive_probe_legacy_port(unsigned long xport)
+        if (pcard)
+                pnp_set_card_drvdata(pcard, card);
+        else
+                snd_audiodrive_legacy[dev] = card;
+        return 0;
+}
+
+static int __devinit snd_audiodrive_probe_legacy_port(unsigned long xport)
 {
         static int dev;
@@ -2201 +2176 @@
                 if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT)
                         continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                         continue;
 #endif
                 port[dev] = xport;
-                res = snd_audiodrive_probe(dev);
+                res = snd_audiodrive_probe(dev, NULL, NULL);
                 if (res < 0)
                         port[dev] = SNDRV_AUTO_PORT;
@@ -2215 +2190 @@
 
 
-#ifdef __ISAPNP__
-static int __init snd_audiodrive_isapnp_detect(struct isapnp_card *card,
-                                               const struct isapnp_card_id *id)
+#ifdef CONFIG_PNP
+static int __devinit snd_audiodrive_pnp_detect(struct pnp_card_link *card,
+                                               const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -2225 +2200 @@
                 if (!enable[dev] || !isapnp[dev])
                         continue;
-                snd_audiodrive_isapnp_cards[dev] = card;
-                snd_audiodrive_isapnp_id[dev] = id;
-                res = snd_audiodrive_probe(dev);
+                res = snd_audiodrive_probe(dev, card, id);
                 if (res < 0)
                         return res;
@@ -2236 +2209 @@
         return -ENODEV;
 }
-#endif /* __ISAPNP__ */
+
+static void __devexit snd_audiodrive_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver es18xx_pnpc_driver = {
+        .flags = PNP_DRIVER_RES_DISABLE,
+        .name = "es18xx",
+        .id_table = snd_audiodrive_pnpids,
+        .probe = snd_audiodrive_pnp_detect,
+        .remove = __devexit_p(snd_audiodrive_pnp_remove),
+};
+#endif /* CONFIG_PNP */
 
 static int __init alsa_card_es18xx_init(void)
@@ -2247 +2236 @@
                 if (!enable[dev] || port[dev] == SNDRV_AUTO_PORT)
                         continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                         continue;
 #endif
-                if (snd_audiodrive_probe(dev) >= 0)
+                if (snd_audiodrive_probe(dev, NULL, NULL) >= 0)
                         cards++;
         }
         /* legacy auto configured cards */
         cards += snd_legacy_auto_probe(possible_ports, snd_audiodrive_probe_legacy_port);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         /* ISA PnP cards at last */
-        cards += isapnp_probe_cards(snd_audiodrive_pnpids, snd_audiodrive_isapnp_detect);
+        cards += pnp_register_card_driver(&es18xx_pnpc_driver);
 #endif
         if(!cards) {
+#ifdef CONFIG_PNP
+                pnp_unregister_card_driver(&es18xx_pnpc_driver);
+#endif
 #ifdef MODULE
-                printk(KERN_ERR "ESS AudioDrive ES18xx soundcard not found or device busy\n");
+                snd_printk(KERN_ERR "ESS AudioDrive ES18xx soundcard not found or device busy\n");
 #endif
                 return -ENODEV;
@@ -2273 +2265 @@
         int idx;
 
+#ifdef CONFIG_PNP
+        /* PnP cards first */
+        pnp_unregister_card_driver(&es18xx_pnpc_driver);
+#endif
         for(idx = 0; idx < SNDRV_CARDS; idx++)
-                snd_card_free(snd_audiodrive_cards[idx]);
+                snd_card_free(snd_audiodrive_legacy[idx]);
 }
 
 module_init(alsa_card_es18xx_init)
 module_exit(alsa_card_es18xx_exit)
+
 
 #ifndef MODULE
@@ -2303 +2300 @@
                get_option(&str,&dma1[nr_dev]) == 2 &&
                get_option(&str,&dma2[nr_dev]) == 2);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (pnp != INT_MAX)
                 isapnp[nr_dev] = pnp;

GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gus_irq.c

@@ -31 +31 @@
 #endif
 
-void snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
-        snd_gus_card_t * gus = snd_magic_cast(snd_gus_card_t, dev_id, return);
+        snd_gus_card_t * gus = snd_magic_cast(snd_gus_card_t, dev_id, return IRQ_NONE);
         unsigned char status;
         int loop = 100;
-        
-      __again:
+        int handled = 0;
+
+__again:
         status = inb(gus->gf1.reg_irqstat);
         if (status == 0)
-                return;
+                return IRQ_RETVAL(handled);
+        handled = 1;
         // snd_printk("IRQ: status = 0x%x\n", status);
         if (status & 0x02) {
@@ -102 +104 @@
         if (--loop > 0)
                 goto __again;
+        return IRQ_NONE;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gusmax.c

@@ -137 +137 @@
 }
 
-static void snd_gusmax_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_gusmax_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         struct snd_gusmax *maxcard = (struct snd_gusmax *) dev_id;
         int loop, max = 5;
+        int handled = 0;
 
         do {
                 loop = 0;
                 if (inb(maxcard->gus_status_reg)) {
+                        handled = 1;
                         snd_gus_interrupt(irq, maxcard->gus, regs);
                         loop++;
                 }
                 if (inb(maxcard->pcm_status_reg) & 0x01) { /* IRQ bit is set? */
+                        handled = 1;
                         snd_cs4231_interrupt(irq, maxcard->cs4231, regs);
                         loop++;
                 }
         } while (loop && --max > 0);
+        return IRQ_RETVAL(handled);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/gus/interwave.c

@@ -28 +28 @@
 #include <linux/init.h>
 #include <linux/slab.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #include <sound/gus.h>
@@ -63 +59 @@
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 #ifdef TARGET_OS2
 static int isapnp[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
@@ -143 +139 @@
         unsigned short gus_status_reg;
         unsigned short pcm_status_reg;
-#ifdef __ISAPNP__
-        struct isapnp_dev *dev;
-#ifdef SNDRV_STB
-        struct isapnp_dev *devtc;
+#ifdef CONFIG_PNP
+        struct pnp_dev *dev;
+#ifdef SNDRV_STB
+        struct pnp_dev *devtc;
 #endif
 #endif
 };
 
-static snd_card_t *snd_interwave_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-
-static struct isapnp_card *snd_interwave_isapnp_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_interwave_isapnp_id[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#define ISAPNP_INTERWAVE(_va, _vb, _vc, _device, _audio) \
-        { \
-                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), } \
-        }
-#define ISAPNP_INTERWAVE_STB(_va, _vb, _vc, _device, _audio, _tone) \
-        { \
-                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
-                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _tone), } \
-        }
-
-static struct isapnp_card_id snd_interwave_pnpids[] __devinitdata = {
+static snd_card_t *snd_interwave_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+
+#ifdef CONFIG_PNP
+
+static struct pnp_card_device_id snd_interwave_pnpids[] __devinitdata = {
 #ifndef SNDRV_STB
         /* Gravis UltraSound Plug & Play */
-        ISAPNP_INTERWAVE('G','R','V',0x0001,0x0000),
+        { .id = "GRV0001", .devs = { { .id = "GRV0000" } } },
         /* STB SoundRage32 */
-        ISAPNP_INTERWAVE('S','T','B',0x011a,0x0010),
+        { .id = "STB011a", .devs = { { .id = "STB0010" } } },
         /* MED3210 */
-        ISAPNP_INTERWAVE('D','X','P',0x3201,0x0010),
+        { .id = "DXP3201", .devs = { { .id = "DXP0010" } } },
         /* Dynasonic Pro */
         /* This device also have CDC1117:DynaSonix Pro Audio Effects Processor */
-        ISAPNP_INTERWAVE('C','D','C',0x1111,0x1112),
+        { .id = "CDC1111", .devs = { { .id = "CDC1112" } } },
         /* Panasonic PCA761AW Audio Card */
-        ISAPNP_INTERWAVE('A','D','V',0x55ff,0x0010),
+        { .id = "ADV55ff", .devs = { { .id = "ADV0010" } } },
 #else
         /* InterWave STB with TEA6330T */
-        ISAPNP_INTERWAVE_STB('A','D','V',0x550a,0x0010,0x0015),
-#endif
-        { ISAPNP_CARD_END, }
+        { .id = "ADV550a", .devs = { { .id = "ADV0010" }, { .id = "ADV0015" } } },
+#endif
+        { .id = "" }
 };
 
-ISAPNP_CARD_TABLE(snd_interwave_pnpids);
-
-#endif /* __ISAPNP__ */
+MODULE_DEVICE_TABLE(pnp_card, snd_interwave_pnpids);
+
+#endif /* CONFIG_PNP */
 
 
@@ -239 +220 @@
 };
 
-static int __init snd_interwave_detect_stb(struct snd_interwave *iwcard,
-                                           snd_gus_card_t * gus, int dev,
-                                           snd_i2c_bus_t **rbus)
+static int __devinit snd_interwave_detect_stb(struct snd_interwave *iwcard,
+                                              snd_gus_card_t * gus, int dev,
+                                              snd_i2c_bus_t **rbus)
 {
         unsigned long port;
@@ -279 +260 @@
 #endif
 
-static int __init snd_interwave_detect(struct snd_interwave *iwcard,
-                                       snd_gus_card_t * gus,
-                                       int dev
-#ifdef SNDRV_STB
-                                       , snd_i2c_bus_t **rbus
-#endif
-                                       )
+static int __devinit snd_interwave_detect(struct snd_interwave *iwcard,
+                                          snd_gus_card_t * gus,
+                                          int dev
+#ifdef SNDRV_STB
+                                          , snd_i2c_bus_t **rbus
+#endif
+                                          )
 {
         unsigned long flags;
@@ -344 +325 @@
 }
 
-static void snd_interwave_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_interwave_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         struct snd_interwave *iwcard = (struct snd_interwave *) dev_id;
         int loop, max = 5;
+        int handled = 0;
 
         do {
                 loop = 0;
                 if (inb(iwcard->gus_status_reg)) {
+                        handled = 1;
                         snd_gus_interrupt(irq, iwcard->gus, regs);
                         loop++;
                 }
                 if (inb(iwcard->pcm_status_reg) & 0x01) {       /* IRQ bit is set? */
+                        handled = 1;
                         snd_cs4231_interrupt(irq, iwcard->cs4231, regs);
                         loop++;
                 }
         } while (loop && --max > 0);
-}
-
-static void __init snd_interwave_reset(snd_gus_card_t * gus)
+        return IRQ_RETVAL(handled);
+}
+
+static void __devinit snd_interwave_reset(snd_gus_card_t * gus)
 {
         snd_gf1_write8(gus, SNDRV_GF1_GB_RESET, 0x00);
@@ -370 +355 @@
 }
 
-static void __init snd_interwave_bank_sizes(snd_gus_card_t * gus, int *sizes)
+static void __devinit snd_interwave_bank_sizes(snd_gus_card_t * gus, int *sizes)
 {
         unsigned int idx;
@@ -419 +404 @@
 };
 
-static void __init snd_interwave_detect_memory(snd_gus_card_t * gus)
+static void __devinit snd_interwave_detect_memory(snd_gus_card_t * gus)
 {
         static unsigned int lmc[13] =
@@ -522 +507 @@
 }
 
-static void __init snd_interwave_init(int dev, snd_gus_card_t * gus)
+static void __devinit snd_interwave_init(int dev, snd_gus_card_t * gus)
 {
         unsigned long flags;
@@ -553 +538 @@
 };
 
-static int __init snd_interwave_mixer(cs4231_t *chip)
+static int __devinit snd_interwave_mixer(cs4231_t *chip)
 {
         snd_card_t *card = chip->card;
@@ -601 +586 @@
 }
 
-#ifdef __ISAPNP__
-
-static int __init snd_interwave_isapnp(int dev, struct snd_interwave *iwcard)
-{
-        const struct isapnp_card_id *id = snd_interwave_isapnp_id[dev];
-        struct isapnp_card *card = snd_interwave_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-
-        iwcard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (iwcard->dev->active) {
-                iwcard->dev = NULL;
+#ifdef CONFIG_PNP
+
+static int __devinit snd_interwave_pnp(int dev, struct snd_interwave *iwcard,
+                                       struct pnp_card_link *card,
+                                       const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
+        int err;
+
+        iwcard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (iwcard->dev == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
 #ifdef SNDRV_STB
-        iwcard->devtc = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
-        if (iwcard->devtc->active) {
-                iwcard->dev = iwcard->devtc = NULL;
+        iwcard->devtc = pnp_request_card_device(card, id->devs[1].id, NULL);
+        if (iwcard->devtc == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
@@ -623 +610 @@
         /* Synth & Codec initialization */
         pdev = iwcard->dev;
-        if (pdev->prepare(pdev)<0)
-                return -EAGAIN;
+        pnp_init_resource_table(cfg);
         if (port[dev] != SNDRV_AUTO_PORT) {
-                isapnp_resource_change(&pdev->resource[0], port[dev], 16);
-                isapnp_resource_change(&pdev->resource[1], port[dev] + 0x100, 12);
-                isapnp_resource_change(&pdev->resource[2], port[dev] + 0x10c, 4);
+                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[1], port[dev] + 0x100, 12);
+                pnp_resource_change(&cfg->port_resource[2], port[dev] + 0x10c, 4);
         }
         if (dma1[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma1[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
         if (dma2[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma2[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
         if (dma2[dev] < 0)
-                isapnp_resource_change(&pdev->dma_resource[1], 4, 1);
+                pnp_resource_change(&cfg->dma_resource[1], 4, 1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
-        if (pdev->activate(pdev)<0) {
-                snd_printk("isapnp configure failure (out of resources?)\n");
-                return -EBUSY;
-        }
-        if (pdev->resource[0].start + 0x100 != pdev->resource[1].start ||
-            pdev->resource[0].start + 0x10c != pdev->resource[2].start) {
-                snd_printk("isapnp configure failure (wrong ports)\n");
-                pdev->deactivate(pdev);
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
+        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                snd_printk(KERN_ERR "InterWave - Synth - the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                kfree(cfg);
+                snd_printk(KERN_ERR "InterWave PnP configure failure (out of resources?)\n");
+                return err;
+        }
+        if (pnp_port_start(pdev, 0) + 0x100 != pnp_port_start(pdev, 1) ||
+            pnp_port_start(pdev, 0) + 0x10c != pnp_port_start(pdev, 2)) {
+                kfree(cfg);
+                snd_printk(KERN_ERR "PnP configure failure (wrong ports)\n");
                 return -ENOENT;
         }
-        port[dev] = pdev->resource[0].start;
-        dma1[dev] = pdev->dma_resource[0].start;
+        port[dev] = pnp_port_start(pdev, 0);
+        dma1[dev] = pnp_dma(pdev, 1);
         if (dma2[dev] >= 0)
-                dma2[dev] = pdev->dma_resource[1].start;
-        irq[dev] = pdev->irq_resource[0].start;
+                dma2[dev] = pnp_dma(pdev, 1);
+        irq[dev] = pnp_irq(pdev, 0);
         snd_printdd("isapnp IW: sb port=0x%lx, gf1 port=0x%lx, codec port=0x%lx\n",
-                                pdev->resource[0].start,
-                                pdev->resource[1].start,
-                                pdev->resource[2].start);
+                                pnp_port_start(pdev, 0),
+                                pnp_port_start(pdev, 1),
+                                pnp_port_start(pdev, 2));
         snd_printdd("isapnp IW: dma1=%i, dma2=%i, irq=%i\n", dma1[dev], dma2[dev], irq[dev]);
 #ifdef SNDRV_STB
         /* Tone Control initialization */
         pdev = iwcard->devtc;
-        if (pdev->prepare(pdev)<0) {
-                iwcard->dev->deactivate(iwcard->dev);
-                return -EAGAIN;
-        }
+        pnp_init_resource_table(cfg);
         if (port_tc[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], port_tc[dev], 1);
-        if (pdev->activate(pdev)<0) {
-                snd_printk("Tone Control isapnp configure failure (out of resources?)\n");
-                iwcard->dev->deactivate(iwcard->dev);
-                return -EBUSY;
-        }
-        port_tc[dev] = pdev->resource[0].start;
+                pnp_resource_change(&cfg->port_resource[0], port_tc[dev], 1);
+        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                snd_printk(KERN_ERR "InterWave - ToneControl - the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                kfree(cfg);
+                snd_printk(KERN_ERR "InterWave ToneControl PnP configure failure (out of resources?)\n");
+                return err;
+        }
+        port_tc[dev] = pnp_port_start(pdev, 0);
         snd_printdd("isapnp IW: tone control port=0x%lx\n", port_tc[dev]);
 #endif
+        kfree(cfg);
         return 0;
 }
-
-static void snd_interwave_deactivate(struct snd_interwave *iwcard)
-{
-        if (iwcard->dev) {
-                iwcard->dev->deactivate(iwcard->dev);
-                iwcard->dev = NULL;
-        }
-#ifdef SNDRV_STB
-        if (iwcard->devtc) {
-                iwcard->devtc->deactivate(iwcard->devtc);
-                iwcard->devtc = NULL;
-        }
-#endif
-}
-
-#endif /* __ISAPNP__ */
+#endif /* CONFIG_PNP */
 
 static void snd_interwave_free(snd_card_t *card)
@@ -700 +676 @@
         if (iwcard == NULL)
                 return;
-#ifdef __ISAPNP__
-        snd_interwave_deactivate(iwcard);
-#endif
 #ifdef SNDRV_STB
         if (iwcard->i2c_res) {
@@ -713 +686 @@
 }
 
-static int __init snd_interwave_probe(int dev)
+static int __devinit snd_interwave_probe(int dev, struct pnp_card_link *pcard,
+                                         const struct pnp_card_device_id *pid)
 {
         static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1};
@@ -737 +711 @@
         iwcard->irq = -1;
         card->private_free = snd_interwave_free;
-#ifdef __ISAPNP__
-        if (isapnp[dev] && snd_interwave_isapnp(dev, iwcard)) {
+#ifdef CONFIG_PNP
+        if (isapnp[dev] && snd_interwave_pnp(dev, iwcard, pcard, pid)) {
                 snd_card_free(card);
                 return -ENODEV;
@@ -892 +866 @@
         iwcard->cs4231 = cs4231;
         iwcard->gus = gus;
-        snd_interwave_cards[dev++] = card;
+        if (pcard)
+                pnp_set_card_drvdata(pcard, card);
+        else
+                snd_interwave_legacy[dev++] = card;
         return 0;
 }
 
-static int __init snd_interwave_probe_legacy_port(unsigned long xport)
+static int __devinit snd_interwave_probe_legacy_port(unsigned long xport)
 {
         static int dev;
@@ -904 +881 @@
                 if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT)
                         continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                         continue;
 #endif
                 port[dev] = xport;
-                res = snd_interwave_probe(dev);
+                res = snd_interwave_probe(dev, NULL, NULL);
                 if (res < 0)
                         port[dev] = SNDRV_AUTO_PORT;
@@ -917 +894 @@
 }
 
-#ifdef __ISAPNP__
-
-static int __init snd_interwave_isapnp_detect(struct isapnp_card *card,
-                                              const struct isapnp_card_id *id)
+#ifdef CONFIG_PNP
+
+static int __devinit snd_interwave_pnp_detect(struct pnp_card_link *card,
+                                           const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -928 +905 @@
                 if (!enable[dev] || !isapnp[dev])
                         continue;
-                snd_interwave_isapnp_cards[dev] = card;
-                snd_interwave_isapnp_id[dev] = id;
-                res = snd_interwave_probe(dev);
+                res = snd_interwave_probe(dev, card, id);
                 if (res < 0)
                         return res;
@@ -940 +915 @@
 }
 
-#endif /* __ISAPNP__ */
+static void __devexit snd_interwave_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver interwave_pnpc_driver = {
+        .flags = PNP_DRIVER_RES_DISABLE,
+        .name = "interwave",
+        .id_table = snd_interwave_pnpids,
+        .probe = snd_interwave_pnp_detect,
+        .remove = __devexit_p(snd_interwave_pnp_remove),
+};
+
+#endif /* CONFIG_PNP */
 
 static int __init alsa_card_interwave_init(void)
@@ -951 +942 @@
                 if (!enable[dev] || port[dev] == SNDRV_AUTO_PORT)
                         continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                         continue;
 #endif
-                if (!snd_interwave_probe(dev)) {
+                if (!snd_interwave_probe(dev, NULL, NULL)) {
                         cards++;
                         continue;
@@ -965 +956 @@
         /* legacy auto configured cards */
         cards += snd_legacy_auto_probe(possible_ports, snd_interwave_probe_legacy_port);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         /* ISA PnP cards */
-        cards += isapnp_probe_cards(snd_interwave_pnpids, snd_interwave_isapnp_detect);
+        cards += pnp_register_card_driver(&interwave_pnpc_driver);
 #endif
 
         if (!cards) {
+#ifdef CONFIG_PNP
+                pnp_unregister_card_driver(&interwave_pnpc_driver);
+#endif
 #ifdef MODULE
                 printk(KERN_ERR "InterWave soundcard not found or device busy\n");
@@ -983 +977 @@
         int dev;
 
+#ifdef CONFIG_PNP
+        /* PnP cards first */
+        pnp_unregister_card_driver(&interwave_pnpc_driver);
+#endif
         for (dev = 0; dev < SNDRV_CARDS; dev++)
-                snd_card_free(snd_interwave_cards[dev]);
+                snd_card_free(snd_interwave_legacy[dev]);
 }
 
@@ -1020 +1018 @@
                get_option(&str,&pcm_channels[nr_dev]) == 2 &&
                get_option(&str,&effect[nr_dev]) == 2);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (pnp != INT_MAX)
                 isapnp[nr_dev] = pnp;

GPL/branches/alsa-resync1/alsa-kernel/isa/opl3sa2.c

@@ -25 +25 @@
 #include <linux/pm.h>
 #include <linux/slab.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #include <sound/cs4231.h>
@@ -52 +48 @@
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 #ifdef TARGET_OS2
 static int isapnp[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
@@ -82 +78 @@
 MODULE_PARM_DESC(enable, "Enable OPL3-SA soundcard.");
 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
-MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
+MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
 MODULE_PARM_SYNTAX(isapnp, SNDRV_ISAPNP_DESC);
 #endif
@@ -156 +152 @@
         snd_rawmidi_t *rmidi;
         cs4231_t *cs4231;
-#ifdef __ISAPNP__
-        struct isapnp_dev *dev;
+#ifdef CONFIG_PNP
+        struct pnp_dev *dev;
 #endif
         unsigned char ctlregs[0x20];
@@ -170 +166 @@
 };
 
-static snd_card_t *snd_opl3sa2_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-
-static struct isapnp_card *snd_opl3sa2_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_opl3sa2_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-
-#ifdef TARGET_OS2
-#define ISAPNP_OPL3SA2(_va, _vb, _vc, _device, _function) \
-        { \
-                0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                { ISAPNP_DEVICE_ID(_va, _vb, _vc, _function), } \
-        }
-#else
-#define ISAPNP_OPL3SA2(_va, _vb, _vc, _device, _function) \
-        { \
-                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _function), } \
-        }
-#endif
-
-static struct isapnp_card_id snd_opl3sa2_pnpids[] __devinitdata = {
+static snd_card_t *snd_opl3sa2_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+
+#ifdef CONFIG_PNP
+
+static struct pnp_card_device_id snd_opl3sa2_pnpids[] __devinitdata = {
         /* Yamaha YMF719E-S (Genius Sound Maker 3DX) */
-        ISAPNP_OPL3SA2('Y','M','H',0x0020,0x0021),
+        { .id = "YMH0020", .devs = { { "YMH0021" } } },
         /* Yamaha OPL3-SA3 (integrated on Intel's Pentium II AL440LX motherboard) */
-        ISAPNP_OPL3SA2('Y','M','H',0x0030,0x0021),
+        { .id = "YMH0030", .devs = { { "YMH0021" } } },
         /* Yamaha OPL3-SA2 */
-        ISAPNP_OPL3SA2('Y','M','H',0x0800,0x0021),
+        { .id = "YMH0800", .devs = { { "YMH0021" } } },
         /* NeoMagic MagicWave 3DX */
-        ISAPNP_OPL3SA2('N','M','X',0x2200,0x2210),
+        { .id = "NMX2200", .devs = { { "YMH2210" } } },
         /* --- */
-        { ISAPNP_CARD_END, }    /* end */
+        { .id = "" }    /* end */
 };
 
-ISAPNP_CARD_TABLE(snd_opl3sa2_pnpids);
-
-#endif /* __ISAPNP__ */
+MODULE_DEVICE_TABLE(pnp_card, snd_opl3sa2_pnpids);
+
+#endif /* CONFIG_PNP */
 
 
@@ -327 +306 @@
 }
 
-static int snd_opl3sa2_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_opl3sa2_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         unsigned short status;
         opl3sa2_t *chip = dev_id;
+        int handled = 0;
 
         if (chip == NULL || chip->card == NULL)
-                return 0;
+                return IRQ_NONE;
 
         status = snd_opl3sa2_read(chip, OPL3SA2_IRQ_STATUS);
 
-        if (status & 0x20)
+        if (status & 0x20) {
+                handled = 1;
                 snd_opl3_interrupt(chip->synth);
-
-        if ((status & 0x10) && chip->rmidi != NULL)
+        }
+
+        if ((status & 0x10) && chip->rmidi != NULL) {
+                handled = 1;
                 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
-
-        if (status & 0x07)      /* TI,CI,PI */
+        }
+
+        if (status & 0x07) {    /* TI,CI,PI */
+                handled = 1;
                 snd_cs4231_interrupt(irq, chip->cs4231, regs);
+        }
 
         if (status & 0x40) { /* hardware volume change */
+                handled = 1;
                 /* reading from Master Lch register at 0x07 clears this bit */
                 snd_opl3sa2_read(chip, OPL3SA2_MASTER_RIGHT);
@@ -355 +342 @@
                 }
         }
-        return 0;
+        return IRQ_RETVAL(handled);
 }
 
@@ -605 +592 @@
 #endif /* CONFIG_PM */
 
-#ifdef __ISAPNP__
-static int __init snd_opl3sa2_isapnp(int dev, opl3sa2_t *chip)
-{
-        const struct isapnp_card_id *id = snd_opl3sa2_isapnp_id[dev];
-        struct isapnp_card *card = snd_opl3sa2_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-
-        chip->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (chip->dev->active) {
-                chip->dev = NULL;
+#ifdef CONFIG_PNP
+static int __init snd_opl3sa2_pnp(int dev, opl3sa2_t *chip,
+                                  struct pnp_card_link *card,
+                                  const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
+        int err;
+
+        if (!cfg)
+                return -ENOMEM;
+        pdev = chip->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (chip->dev == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
         /* PnP initialization */
-        pdev = chip->dev;
-        if (pdev->prepare(pdev)<0)
-                return -EAGAIN;
+        pnp_init_resource_table(cfg);
         if (sb_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], sb_port[dev], 16);
-        if (wss_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[1], wss_port[dev], 8);
+                pnp_resource_change(&cfg->port_resource[0], sb_port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[1], wss_port[dev], 8);
         if (fm_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[2], fm_port[dev], 4);
+                pnp_resource_change(&cfg->port_resource[2], fm_port[dev], 4);
         if (midi_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[3], midi_port[dev], 2);
+                pnp_resource_change(&cfg->port_resource[3], midi_port[dev], 2);
         if (port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[4], port[dev], 2);
+                pnp_resource_change(&cfg->port_resource[4], port[dev], 2);
         if (dma1[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma1[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
         if (dma2[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma2[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
-        if (pdev->activate(pdev)<0) {
-                snd_printk("isapnp configure failure (out of resources?)\n");
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
+        err = pnp_manual_config_dev(pdev, cfg, 0);
+        if (err < 0)
+                snd_printk(KERN_ERR "PnP manual resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                kfree(cfg);
+                snd_printk(KERN_ERR "PnP configure failure (out of resources?)\n");
                 return -EBUSY;
         }
-        sb_port[dev] = pdev->resource[0].start;
-        wss_port[dev] = pdev->resource[1].start;
-        fm_port[dev] = pdev->resource[2].start;
-        midi_port[dev] = pdev->resource[3].start;
-        port[dev] = pdev->resource[4].start;
-        dma1[dev] = pdev->dma_resource[0].start;
-        dma2[dev] = pdev->dma_resource[1].start;
-        irq[dev] = pdev->irq_resource[0].start;
-        snd_printdd("isapnp OPL3-SA: sb port=0x%lx, wss port=0x%lx, fm port=0x%lx, midi port=0x%lx\n",
+        sb_port[dev] = pnp_port_start(pdev, 0);
+        wss_port[dev] = pnp_port_start(pdev, 1);
+        fm_port[dev] = pnp_port_start(pdev, 2);
+        midi_port[dev] = pnp_port_start(pdev, 3);
+        port[dev] = pnp_port_start(pdev, 4);
+        dma1[dev] = pnp_dma(pdev, 0);
+        dma2[dev] = pnp_dma(pdev, 1);
+        irq[dev] = pnp_irq(pdev, 0);
+        snd_printdd("PnP OPL3-SA: sb port=0x%lx, wss port=0x%lx, fm port=0x%lx, midi port=0x%lx\n",
                 sb_port[dev], wss_port[dev], fm_port[dev], midi_port[dev]);
-        snd_printdd("isapnp OPL3-SA: control port=0x%lx, dma1=%i, dma2=%i, irq=%i\n",
+        snd_printdd("PnP OPL3-SA: control port=0x%lx, dma1=%i, dma2=%i, irq=%i\n",
                 port[dev], dma1[dev], dma2[dev], irq[dev]);
-        return 0;
-}
-
-static void snd_opl3sa2_deactivate(opl3sa2_t *chip)
-{
-        if (chip->dev) {
-                chip->dev->deactivate(chip->dev);
-                chip->dev = NULL;
-        }
-}
-#endif /* __ISAPNP__ */
+        kfree(cfg);
+        return 0;
+}
+#endif /* CONFIG_PNP */
 
 static int snd_opl3sa2_free(opl3sa2_t *chip)
 {
-#ifdef __ISAPNP__
-        snd_opl3sa2_deactivate(chip);
-#endif
 #ifdef CONFIG_PM
         if (chip->pm_dev)
@@ -690 +673 @@
 }
 
-static int __init snd_opl3sa2_probe(int dev)
+static int __devinit snd_opl3sa2_probe(int dev,
+                                       struct pnp_card_link *pcard,
+                                       const struct pnp_card_device_id *pid)
 {
         int xirq, xdma1, xdma2;
@@ -702 +687 @@
         int err;
 
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (!isapnp[dev]) {
 #endif
@@ -721 +706 @@
                         return -EINVAL;
                 }
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         }
 #endif
@@ -737 +722 @@
         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0)
                 goto __error;
-#ifdef __ISAPNP__
-        if (isapnp[dev] && (err = snd_opl3sa2_isapnp(dev, chip)) < 0)
+#ifdef CONFIG_PNP
+        if (isapnp[dev] && (err = snd_opl3sa2_pnp(dev, chip, pcard, pid)) < 0)
                 goto __error;
 #endif
@@ -807 +792 @@
                 goto __error;
 
-        snd_opl3sa2_cards[dev] = card;
+        if (pcard)
+                pnp_set_card_drvdata(pcard, card);
+        else
+                snd_opl3sa2_legacy[dev] = card;
         return 0;
 
@@ -815 +803 @@
 }
 
-#ifdef __ISAPNP__
-static int __init snd_opl3sa2_isapnp_detect(struct isapnp_card *card,
-                                            const struct isapnp_card_id *id)
+#ifdef CONFIG_PNP
+static int __devinit snd_opl3sa2_pnp_detect(struct pnp_card_link *card,
+                                            const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -823 +811 @@
 
         for ( ; dev < SNDRV_CARDS; dev++) {
-                if (!enable[dev])
+                if (!enable[dev] && !isapnp[dev])
                         continue;
-                snd_opl3sa2_isapnp_cards[dev] = card;
-                snd_opl3sa2_isapnp_id[dev] = id;
-                res = snd_opl3sa2_probe(dev);
+                res = snd_opl3sa2_probe(dev, card, id);
                 if (res < 0)
                         return res;
@@ -835 +821 @@
         return -ENODEV;
 }
-#endif /* __ISAPNP__ */
+
+static void __devexit snd_opl3sa2_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+        
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver opl3sa2_pnpc_driver = {
+        .flags = PNP_DRIVER_RES_DISABLE,
+        .name = "opl3sa2",
+        .id_table = snd_opl3sa2_pnpids,
+        .probe = snd_opl3sa2_pnp_detect,
+        .remove = __devexit_p(snd_opl3sa2_pnp_remove),
+};
+#endif /* CONFIG_PNP */
 
 static int __init alsa_card_opl3sa2_init(void)
@@ -844 +846 @@
                 if (!enable[dev])
                         continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                         continue;
 #endif
-                if (snd_opl3sa2_probe(dev) >= 0)
+                if (snd_opl3sa2_probe(dev, NULL, NULL) >= 0)
                         cards++;
         }
-#ifdef __ISAPNP__
-        cards += isapnp_probe_cards(snd_opl3sa2_pnpids, snd_opl3sa2_isapnp_detect);
+#ifdef CONFIG_PNP
+        cards += pnp_register_card_driver(&opl3sa2_pnpc_driver);
 #endif
         if (!cards) {
 #ifdef MODULE
-                printk(KERN_ERR "Yamaha OPL3-SA soundcard not found or device busy\n");
+                snd_printk(KERN_ERR "Yamaha OPL3-SA soundcard not found or device busy\n");
+#endif
+#ifdef CONFIG_PNP
+                pnp_unregister_card_driver(&opl3sa2_pnpc_driver);
 #endif
                 return -ENODEV;
@@ -867 +872 @@
         int idx;
 
+#ifdef CONFIG_PNP
+        /* PnP cards first */
+        pnp_unregister_card_driver(&opl3sa2_pnpc_driver);
+#endif
         for (idx = 0; idx < SNDRV_CARDS; idx++)
-                snd_card_free(snd_opl3sa2_cards[idx]);
+                snd_card_free(snd_opl3sa2_legacy[idx]);
 }
 
@@ -901 +910 @@
                get_option(&str,&dma2[nr_dev]) == 2 &&
                get_option(&str,&opl3sa3_ymode[nr_dev]) == 2);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (pnp != INT_MAX)
                 isapnp[nr_dev] = pnp;

GPL/branches/alsa-resync1/alsa-kernel/isa/opti9xx/opti92x-ad1848.c

@@ -30 +30 @@
 #include <linux/init.h>
 #include <linux/slab.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #ifdef CS4231
@@ -48 +44 @@
 #include <sound/mpu401.h>
 #include <sound/opl3.h>
+#ifdef USE_OPL4
+#ifndef OPTi93X
+#include "opl4.h" /* <sound/opl4.h> */
+#endif
+#endif
 #define SNDRV_LEGACY_FIND_FREE_IRQ
 #define SNDRV_LEGACY_FIND_FREE_DMA
@@ -268 +269 @@
         int mpu_irq;
 
-#if defined(OPTi93X)
-        opti93x_t *opti93x;
-#elif defined(CS4231)
-        cs4231_t *cs4231;
-#else
-        ad1848_t *ad1848;
-#endif  /* AD1848 */
-        snd_rawmidi_t *rmidi;
-#ifdef __ISAPNP__
-        struct isapnp_dev *dev;
-        struct isapnp_dev *devmpu;
-#endif  /* __ISAPNP__ */
+#ifdef CONFIG_PNP
+        struct pnp_dev *dev;
+        struct pnp_dev *devmpu;
+#endif  /* CONFIG_PNP */
 };
 
-static snd_card_t *snd_opti9xx_card = SNDRV_DEFAULT_PTR1;
-
-#ifdef __ISAPNP__
+static int snd_opti9xx_first_hit = 1;
+static snd_card_t *snd_opti9xx_legacy = SNDRV_DEFAULT_PTR1;
+
+#ifdef CONFIG_PNP
 
 #define ISAPNP_OPTI9XX(_va, _vb, _vc, _device, _fa, _fb, _fc, _audio, _mpu401) \
@@ -293 +287 @@
         }
 
-static struct isapnp_card_id snd_card_opti9xx_pnpids[] = {
+static struct pnp_card_device_id snd_opti9xx_pnpids[] = {
 #ifndef OPTi93X
         /* OPTi 82C924 */
-        ISAPNP_OPTI9XX('O','P','T',0x0924,'O','P','T',0x0000,0x0002),
+        { .id = "OPT0924", .devs = { { "OPT0000" }, { "OPT0002" } }, .driver_data = 0x0924 },
         /* OPTi 82C925 */
-        ISAPNP_OPTI9XX('O','P','T',0x0925,'O','P','T',0x9250,0x0002),
+        { .id = "OPT0925", .devs = { { "OPT9250" }, { "OPT0002" } }, .driver_data = 0x0925 },
 #else
         /* OPTi 82C931/3 */
-        ISAPNP_OPTI9XX('O','P','T',0x0931,'O','P','T',0x9310,0x0002),
+        { .id = "OPT0931", .devs = { { "OPT9310" }, { "OPT0002" } }, .driver_data = 0x0931 },
 #endif  /* OPTi93X */
-        { ISAPNP_CARD_END, }
+        { .id = "" }
 };
 
-ISAPNP_CARD_TABLE(snd_card_opti9xx_pnpids);
-
-#endif  /* __ISAPNP__ */
+MODULE_DEVICE_TABLE(pnp_card, snd_opti9xx_pnpids);
+
+#endif  /* CONFIG_PNP */
 
 #ifdef OPTi93X
@@ -334 +328 @@
 }
 
-static int __init snd_opti9xx_init(opti9xx_t *chip, unsigned short hardware)
+static int __devinit snd_opti9xx_init(opti9xx_t *chip, unsigned short hardware)
 {
         static int opti9xx_mc_size[] = {7, 7, 10, 10, 2, 2, 2};
@@ -479 +473 @@
 
 
-static int __init snd_opti9xx_configure(opti9xx_t *chip)
+static int __devinit snd_opti9xx_configure(opti9xx_t *chip)
 {
         unsigned char wss_base_bits;
@@ -976 +970 @@
         {
                 unsigned int what = 0;
-                snd_pcm_substream_t *s = substream;
-                do {
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == chip->playback_substream) {
                                 what |= OPTi93X_PLAYBACK_ENABLE;
@@ -985 +981 @@
                                 snd_pcm_trigger_done(s, substream);
                         }
-                        s = s->link_next;
-                } while (s != substream);
+                }
                 spin_lock(&chip->lock);
                 if (cmd == SNDRV_PCM_TRIGGER_START) {
@@ -1132 +1127 @@
 }
 
-void snd_opti93x_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        opti93x_t *codec = snd_magic_cast(opti93x_t, dev_id, return);
+irqreturn_t snd_opti93x_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        opti93x_t *codec = snd_magic_cast(opti93x_t, dev_id, return IRQ_NONE);
         unsigned char status;
 
@@ -1145 +1140 @@
         }
         outb(0x00, OPTi93X_PORT(codec, STATUS));
+        return IRQ_HANDLED;
 }
 
@@ -1670 +1666 @@
 #endif /* OPTi93X */
 
-static int __init snd_card_opti9xx_detect(snd_card_t *card, opti9xx_t *chip)
+static int __devinit snd_card_opti9xx_detect(snd_card_t *card, opti9xx_t *chip)
 {
         int i, err;
@@ -1716 +1712 @@
 }
 
-#ifdef __ISAPNP__
-static int __init snd_card_opti9xx_isapnp(opti9xx_t *chip)
-{
-        struct isapnp_dev *pdev = NULL;
-        const struct isapnp_card_id *pid = snd_card_opti9xx_pnpids-1;
-        static struct isapnp_card *card = NULL;
-
-      __again:
-        while (1) {
-                pid++;
-                if (pid->card_vendor == 0)
-                        return -ENODEV;
-                if ((card = isapnp_find_card(pid->card_vendor, pid->card_device, card)))
-                        break;
-        }
-        if (card == NULL)
-                return -ENODEV;
-
-        chip->dev = isapnp_find_dev(card, pid->devs[0].vendor, pid->devs[0].function, NULL);
-        if (chip->dev == NULL)
-                goto __again;
-
-        chip->devmpu = isapnp_find_dev(card, pid->devs[1].vendor, pid->devs[1].function, NULL);
+#ifdef CONFIG_PNP
+static int __devinit snd_card_opti9xx_pnp(opti9xx_t *chip, struct pnp_card_link *card,
+                                          const struct pnp_card_device_id *pid)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
+        int err;
+
+        chip->dev = pnp_request_card_device(card, pid->devs[0].id, NULL);
+        if (chip->dev == NULL) {
+                kfree(cfg);
+                return -EBUSY;
+        }
+        chip->devmpu = pnp_request_card_device(card, pid->devs[1].id, NULL);
 
         pdev = chip->dev;
-        if (pdev->prepare(pdev) < 0)
-                return -EAGAIN;
+        pnp_init_resource_table(cfg);
 
 #ifdef OPTi93X
         if (port != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], port + 4, 4);
+                pnp_resource_change(&cfg->port_resource[0], port + 4, 4);
 #else
-        if ((pid->card_device != ISAPNP_DEVICE(0x0924)) && (port != SNDRV_AUTO_PORT))
-                isapnp_resource_change(&pdev->resource[1], port, 4);
+        if (pid->driver_data != 0x0924 && port != SNDRV_AUTO_PORT)
+                pnp_resource_change(&cfg->port_resource[1], port, 4);
 #endif  /* OPTi93X */
         if (irq != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq, 1);
+                pnp_resource_change(&cfg->irq_resource[0], irq, 1);
         if (dma1 != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma1, 1);
+                pnp_resource_change(&cfg->dma_resource[0], dma1, 1);
 #if defined(CS4231) || defined(OPTi93X)
         if (dma2 != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma2, 1);
+                pnp_resource_change(&cfg->dma_resource[1], dma2, 1);
 #endif  /* CS4231 || OPTi93X */
         if (fm_port != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[1], fm_port, 4);
-
-        if (pdev->activate(pdev) < 0) {
-                snd_printk("AUDIO isapnp configure failure\n");
-                return -EBUSY;
+                pnp_resource_change(&cfg->port_resource[1], fm_port, 4);
+
+        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                snd_printk(KERN_ERR "AUDIO the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR "AUDIO pnp configure failure\n");
+                kfree(cfg);
+                return err;
         }
 
 #ifdef OPTi93X
-        port = pdev->resource[0].start - 4;
-        fm_port = pdev->resource[1].start;
+        port = pnp_port_start(pdev, 0) - 4;
+        fm_port = pnp_port_start(pdev, 1);
 #else
-        if (pid->card_device != ISAPNP_DEVICE(0x0924))
-                port = pdev->resource[1].start;
-        fm_port = pdev->resource[2].start;
+        if (pid->driver_data != 0x0924)
+                port = pnp_port_start(pdev, 1);
+        fm_port = pnp_port_start(pdev, 2);
 #endif  /* OPTi93X */
-        irq = pdev->irq_resource[0].start;
-        dma1 = pdev->dma_resource[0].start;
+        irq = pnp_irq(pdev, 0);
+        dma1 = pnp_dma(pdev, 0);
 #if defined(CS4231) || defined(OPTi93X)
-        dma2 = pdev->dma_resource[1].start;
+        dma2 = pnp_dma(pdev, 1);
 #endif  /* CS4231 || OPTi93X */
 
         pdev = chip->devmpu;
-        if (pdev == NULL || pdev->prepare(pdev) < 0) {
-                mpu_port = -1;
-                chip->devmpu = NULL;
-                return pid->card_device;
-        }
-
-        if (mpu_port != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], mpu_port, 2);
-        if (mpu_irq != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], mpu_irq, 1);
-
-        if (pdev->activate(pdev) < 0) {
-                snd_printk("MPU-401 isapnp configure failure\n");
-                mpu_port = -1;
-                chip->devmpu = NULL;
-        } else {
-                mpu_port = pdev->resource[0].start;
-                mpu_irq = pdev->irq_resource[0].start;
-        }
-        return pid->card_device;
-}
-
-static void snd_card_opti9xx_deactivate(opti9xx_t *chip)
-{
-        if (chip->dev)
-                chip->dev->deactivate(chip->dev);
-        if (chip->devmpu)
-                chip->devmpu->deactivate(chip->devmpu);
-}
-#endif  /* __ISAPNP__ */
+        if (pdev) {
+                pnp_init_resource_table(cfg);
+
+                if (mpu_port != SNDRV_AUTO_PORT)
+                        pnp_resource_change(&cfg->port_resource[0], mpu_port, 2);
+                if (mpu_irq != SNDRV_AUTO_IRQ)
+                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq, 1);
+
+                if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                        snd_printk(KERN_ERR "AUDIO the requested resources are invalid, using auto config\n");
+                err = pnp_activate_dev(pdev);
+                if (err < 0) {
+                        snd_printk(KERN_ERR "AUDIO pnp configure failure\n");
+                        mpu_port = -1;
+                        chip->devmpu = NULL;
+                } else {
+                        mpu_port = pnp_port_start(pdev, 0);
+                        mpu_irq = pnp_irq(pdev, 0);
+                }
+        }
+        kfree(cfg);
+        return pid->driver_data;
+}
+#endif  /* CONFIG_PNP */
 
 #if 0
-static int __init snd_card_opti9xx_resources(struct snd_card_opti9xx *chip,
-                                             snd_card_t *card)
+static int __devinit snd_card_opti9xx_resources(struct snd_card_opti9xx *chip,
+                                                snd_card_t *card)
 {
         int error, i, pnp = 0;
 
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         pnp = chip->dev != NULL;
-#endif  /* __ISAPNP__ */
+#endif  /* CONFIG_PNP */
 
 #ifndef OPTi93X
@@ -1915 +1899 @@
         
         if (chip) {
-#ifdef __ISAPNP__
-                snd_card_opti9xx_deactivate(chip);
-#endif  /* __ISAPNP__ */
                 if (chip->res_mc_base) {
                         release_resource(chip->res_mc_base);
@@ -1925 +1906 @@
 }
 
-static int __init snd_card_opti9xx_probe(void)
+static int __devinit snd_card_opti9xx_probe(struct pnp_card_link *pcard,
+                                            const struct pnp_card_device_id *pid)
 {
         static long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1};
@@ -1953 +1935 @@
         snd_rawmidi_t *rmidi;
         snd_hwdep_t *synth;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         int hw;
-#endif  /* __ISAPNP__ */
-
+#endif  /* CONFIG_PNP */
+
+        if (pcard && !snd_opti9xx_first_hit)
+                return -EBUSY;
         if (!(card = snd_card_new(index, id, THIS_MODULE,
                                   sizeof(opti9xx_t))))
@@ -1963 +1947 @@
         chip = (opti9xx_t *)card->private_data;
 
-#ifdef __ISAPNP__
-        if (isapnp && (hw = snd_card_opti9xx_isapnp(chip)) > 0) {
+#ifdef CONFIG_PNP
+        if (isapnp && pcard && (hw = snd_card_opti9xx_pnp(chip, pcard, pid)) > 0) {
                 switch (hw) {
-                case ISAPNP_DEVICE(0x0924):
+                case 0x0924:
                         hw = OPTi9XX_HW_82C924;
                         break;
-                case ISAPNP_DEVICE(0x0925):
+                case 0x0925:
                         hw = OPTi9XX_HW_82C925;
                         break;
-                case ISAPNP_DEVICE(0x0931):
+                case 0x0931:
                         hw = OPTi9XX_HW_82C931;
                         break;
@@ -1987 +1971 @@
                         chip->mc_base -= 0x80;
         } else {
-#endif  /* __ISAPNP__ */
+#endif  /* CONFIG_PNP */
                 if ((error = snd_card_opti9xx_detect(card, chip)) < 0) {
                         snd_card_free(card);
                         return error;
                 }
-#ifdef __ISAPNP__
-        }
-#endif  /* __ISAPNP__ */
+#ifdef CONFIG_PNP
+        }
+#endif  /* CONFIG_PNP */
 
         if ((chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL) {
@@ -2011 +1995 @@
 #endif
 
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (!isapnp) {
 #endif
@@ -2059 +2043 @@
 #endif
 
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         }
 #endif
@@ -2128 +2112 @@
 
         if (chip->fm_port > 0) {
-                opl3_t *opl3;
-                if (snd_opl3_create(card,
-                                    chip->fm_port,
-                                    chip->fm_port + 2,
-                                    OPL3_HW_AUTO, 0, &opl3) < 0) {
+                opl3_t *opl3 = NULL;
+#ifdef USE_OPL4
+#ifndef OPTi93X
+                if (chip->hardware == OPTi9XX_HW_82C928 ||
+                    chip->hardware == OPTi9XX_HW_82C929 ||
+                    chip->hardware == OPTi9XX_HW_82C924) {
+                        opl4_t *opl4;
+                        /* assume we have an OPL4 */
+                        snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2),
+                                               0x20, 0x20);
+                        if (snd_opl4_create(card,
+                                            chip->fm_port,
+                                            chip->fm_port - 8,
+                                            2, &opl3, &opl4) < 0) {
+                                /* no luck, use OPL3 instead */
+                                snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2),
+                                                       0x00, 0x20);
+                        }
+                }
+#endif  /* !OPTi93X */
+#endif
+                if (!opl3 && snd_opl3_create(card,
+                                             chip->fm_port,
+                                             chip->fm_port + 2,
+                                             OPL3_HW_AUTO, 0, &opl3) < 0) {
                         snd_printk("no OPL device at 0x%lx-0x%lx\n",
-                                chip->fm_port, chip->fm_port + 4 - 1);
-                } else {
+                                   chip->fm_port, chip->fm_port + 4 - 1);
+                }
+                if (opl3) {
                         if ((error = snd_opl3_timer_new(opl3,
 #ifdef CS4231
@@ -2167 +2172 @@
                 return error;
         }
-        snd_opti9xx_card = card;
+        snd_opti9xx_first_hit = 0;
+        if (pcard)
+                pnp_set_card_drvdata(pcard, card);
+        else
+                snd_opti9xx_legacy = card;
         return 0;
 }
 
+#ifdef CONFIG_PNP
+static void __devexit snd_opti9xx_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+        snd_opti9xx_first_hit = 0;
+}
+
+static struct pnp_card_driver opti9xx_pnpc_driver = {
+        .flags          = PNP_DRIVER_RES_DISABLE,
+        .name           = "opti9xx",
+        .id_table       = snd_opti9xx_pnpids,
+        .probe          = snd_card_opti9xx_probe,
+        .remove         = __devexit_p(snd_opti9xx_pnp_remove),
+};
+#endif
+
 static int __init alsa_card_opti9xx_init(void)
 {
-        int error;
-
-        if ((error = snd_card_opti9xx_probe())) {
+        int cards, error;
+
+        cards = pnp_register_card_driver(&opti9xx_pnpc_driver);
+        if (cards == 0 && (error = snd_card_opti9xx_probe(NULL, NULL)) < 0) {
+#ifdef CONFIG_PNP
+                pnp_unregister_card_driver(&opti9xx_pnpc_driver);
+#endif
 #ifdef MODULE
 #ifdef OPTi93X
@@ -2190 +2222 @@
 static void __exit alsa_card_opti9xx_exit(void)
 {
-        if (snd_opti9xx_card)
-                snd_card_free(snd_opti9xx_card);
+#ifdef CONFIG_PNP
+        pnp_unregister_card_driver(&opti9xx_pnpc_driver);
+#endif
+        if (snd_opti9xx_legacy)
+                snd_card_free(snd_opti9xx_legacy);
 }
 
@@ -2224 +2259 @@
 #endif
                );
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (pnp != INT_MAX)
                 isapnp = pnp;

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/es968.c

@@ -24 +24 @@
 #include <linux/init.h>
 #include <linux/time.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #define SNDRV_GET_ID
@@ -35 +31 @@
 
 #define chip_t sb_t
+
+#define PFX "es968: "
 
 MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
@@ -69 +67 @@
 
 struct snd_card_es968 {
-#ifdef __ISAPNP__
-    struct isapnp_dev *dev;
-#endif  /* __ISAPNP__ */
+        struct pnp_dev *dev;
 };
 
-static snd_card_t *snd_es968_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-static struct isapnp_card *snd_es968_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_es968_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
-
-static struct isapnp_card_id snd_es968_pnpids[] __devinitdata = {
-    {
-        ISAPNP_CARD_ID('E','S','S',0x0968),
-                .devs = { ISAPNP_DEVICE_ID('E','S','S',0x0968), }
-    },
-    { ISAPNP_CARD_END, }
+static struct pnp_card_device_id snd_es968_pnpids[] __devinitdata = {
+        { .id = "ESS0968", .devs = { { "@@@0968" }, } },
+        { .id = "", } /* end */
 };
 
-ISAPNP_CARD_TABLE(snd_es968_pnpids);
-
-#endif  /* __ISAPNP__ */
+MODULE_DEVICE_TABLE(pnp_card, snd_es968_pnpids);
 
 #define DRIVER_NAME     "snd-card-es968"
 
-
-static void snd_card_es968_interrupt(int irq, void *dev_id,
+static irqreturn_t snd_card_es968_interrupt(int irq, void *dev_id,
                                      struct pt_regs *regs)
 {
-        sb_t *chip = snd_magic_cast(sb_t, dev_id, return);
+        sb_t *chip = snd_magic_cast(sb_t, dev_id, return IRQ_NONE);
 
     if (chip->open & SB_OPEN_PCM) {
-        snd_sb8dsp_interrupt(chip);
+                return snd_sb8dsp_interrupt(chip);
     } else {
-        snd_sb8dsp_midi_interrupt(chip);
-    }
-}
-
-#ifdef __ISAPNP__
-static int __init snd_card_es968_isapnp(int dev, struct snd_card_es968 *acard)
-{
-    const struct isapnp_card_id *id = snd_es968_isapnp_id[dev];
-    struct isapnp_card *card = snd_es968_isapnp_cards[dev];
-    struct isapnp_dev *pdev;
-
-    acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-    if (acard->dev->active) {
-        acard->dev = NULL;
-        return -EBUSY;
+                return snd_sb8dsp_midi_interrupt(chip);
+        }
+}
+
+static int __devinit snd_card_es968_pnp(int dev, struct snd_card_es968 *acard,
+                                        struct pnp_card_link *card,
+                                        const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
+        int err;
+        if (!cfg)
+                return -ENOMEM;
+        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (acard->dev == NULL) {
+                kfree(cfg);
+                return -ENODEV;
     }
 
     pdev = acard->dev;
-    if (pdev->prepare(pdev)<0)
-        return -EAGAIN;
-
+
+        pnp_init_resource_table(cfg);
+
+        /* override resources */
         if (port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
         if (dma8[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma8[dev],
-                               1);
+                pnp_resource_change(&cfg->dma_resource[0], dma8[dev], 1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
-
-    if (pdev->activate(pdev)<0) {
-        snd_printk("AUDIO isapnp configure failure\n");
-        return -EBUSY;
-    }
-
-        port[dev] = pdev->resource[0].start;
-        dma8[dev] = pdev->dma_resource[0].start;
-        irq[dev] = pdev->irq_resource[0].start;
-
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
+        if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
+                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n");
+                return err;
+        }
+        port[dev] = pnp_port_start(pdev, 0);
+        dma8[dev] = pnp_dma(pdev, 1);
+        irq[dev] = pnp_irq(pdev, 0);
+
+        kfree(cfg);
     return 0;
 }
 
-static void snd_card_es968_deactivate(struct snd_card_es968 *acard)
-{
-    if (acard->dev) {
-        acard->dev->deactivate(acard->dev);
-        acard->dev = NULL;
-    }
-}
-#endif  /* __ISAPNP__ */
-
-static void snd_card_es968_free(snd_card_t *card)
-{
-    struct snd_card_es968 *acard = (struct snd_card_es968 *)card->private_data;
-
-    if (acard) {
-#ifdef __ISAPNP__
-        snd_card_es968_deactivate(acard);
-#endif  /* __ISAPNP__ */
-    }
-}
-
-static int __init snd_card_es968_probe(int dev)
+static int __init snd_card_es968_probe(int dev,
+                                        struct pnp_card_link *pcard,
+                                        const struct pnp_card_device_id *pid)
 {
     int error;
@@ -175 +145 @@
         return -ENOMEM;
     acard = (struct snd_card_es968 *)card->private_data;
-    card->private_free = snd_card_es968_free;
-
-#ifdef __ISAPNP__
-    if ((error = snd_card_es968_isapnp(dev, acard))) {
-        snd_card_free(card);
-        return error;
-    }
-#else
-    snd_printk("you have to enable PnP support ...\n");
-    snd_card_free(card);
-    return -ENOSYS;
-#endif  /* __ISAPNP__ */
+        if ((error = snd_card_es968_pnp(dev, acard, pcard, pid))) {
+                snd_card_free(card);
+                return error;
+        }
 
         if ((error = snd_sbdsp_create(card, port[dev],
@@ -222 +184 @@
         return error;
     }
-    snd_es968_cards[dev] = card;
+        pnp_set_card_drvdata(pcard, card);
     return 0;
 }
 
-#ifdef __ISAPNP__
-static int __init snd_es968_isapnp_detect(struct isapnp_card *card,
-                                          const struct isapnp_card_id *id)
+static int __devinit snd_es968_pnp_detect(struct pnp_card_link *card,
+                                          const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -236 +197 @@
                 if (!enable[dev])
             continue;
-        snd_es968_isapnp_cards[dev] = card;
-        snd_es968_isapnp_id[dev] = id;
-        res = snd_card_es968_probe(dev);
+                res = snd_card_es968_probe(dev, card, id);
         if (res < 0)
             return res;
@@ -246 +205 @@
     return -ENODEV;
 }
-#endif /* __ISAPNP__ */
+
+static void __devexit snd_es968_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver es968_pnpc_driver = {
+        .flags          = PNP_DRIVER_RES_DISABLE,
+        .name           = "es968",
+        .id_table       = snd_es968_pnpids,
+        .probe          = snd_es968_pnp_detect,
+        .remove         = __devexit_p(snd_es968_pnp_remove),
+};
 
 static int __init alsa_card_es968_init(void)
 {
-    int cards = 0;
-
-#ifdef __ISAPNP__
-    cards += isapnp_probe_cards(snd_es968_pnpids, snd_es968_isapnp_detect);
-#else
-    snd_printk("you have to enable ISA PnP support.\n");
+        int res = pnp_register_card_driver(&es968_pnpc_driver);
+        if (res == 0)
+        {
+                pnp_unregister_card_driver(&es968_pnpc_driver);
+#ifdef MODULE
+                snd_printk(KERN_ERR "no ES968 based soundcards found\n");
 #endif
-#ifdef MODULE
-    if (!cards)
-        snd_printk("no ES968 based soundcards found\n");
-#endif
-    return cards ? 0 : -ENODEV;
+        }
+        return res < 0 ? res : 0;
 }
 
 static void __exit alsa_card_es968_exit(void)
 {
-    int dev;
-
-    for (dev = 0; dev < SNDRV_CARDS; dev++)
-        snd_card_free(snd_es968_cards[dev]);
+        pnp_unregister_card_driver(&es968_pnpc_driver);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb16.c

@@ -24 +24 @@
 #include <linux/init.h>
 #include <linux/slab.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #include <sound/sb.h>
@@ -78 +74 @@
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 #ifdef TARGET_OS2
 static int isapnp[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
@@ -125 +121 @@
 MODULE_PARM_DESC(enable, "Enable SoundBlaster 16 soundcard.");
 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
-MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
+MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
 MODULE_PARM_SYNTAX(isapnp, SNDRV_ISAPNP_DESC);
 #endif
@@ -167 +163 @@
 #endif
 
-struct snd_sb16 {
+struct snd_card_sb16 {
     struct resource *fm_res;    /* used to block FM i/o region for legacy cards */
-#ifdef __ISAPNP__
-    struct isapnp_dev *dev;
-#ifdef SNDRV_SBAWE_EMU8000
-    struct isapnp_dev *devwt;
+#ifdef CONFIG_PNP
+        int dev_no;
+        struct pnp_dev *dev;
+#ifdef SNDRV_SBAWE_EMU8000
+        struct pnp_dev *devwt;
 #endif
 #endif
 };
 
-static snd_card_t *snd_sb16_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-
-static struct isapnp_card *snd_sb16_isapnp_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_sb16_isapnp_id[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef TARGET_OS2
-#define ISAPNP_SB16(_va, _vb, _vc, _device, _audio) \
-    { \
-    0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-    { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), } \
-    }
-#define ISAPNP_SBAWE(_va, _vb, _vc, _device, _audio, _awe) \
-    { \
-    0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-    { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
-    ISAPNP_DEVICE_ID(_va, _vb, _vc, _awe), } \
-    }
-#else
-#define ISAPNP_SB16(_va, _vb, _vc, _device, _audio) \
-    { \
-    ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), } \
-    }
-#define ISAPNP_SBAWE(_va, _vb, _vc, _device, _audio, _awe) \
-    { \
-    ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
-                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
-    ISAPNP_DEVICE_ID(_va, _vb, _vc, _awe), } \
-    }
-#endif
-
-static struct isapnp_card_id snd_sb16_pnpids[] __devinitdata = {
+static snd_card_t *snd_sb16_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+
+static struct pnp_card_device_id snd_sb16_pnpids[] __devinitdata = {
 #ifndef SNDRV_SBAWE
     /* Sound Blaster 16 PnP */
-    ISAPNP_SB16('C','T','L',0x0024,0x0031),
+        { .id = "CTL0024", .devs = { { "CTL0031" } } },
         /* Sound Blaster 16 PnP */
-        ISAPNP_SB16('C','T','L',0x0025,0x0031),
-    /* Sound Blaster 16 PnP */
-    ISAPNP_SB16('C','T','L',0x0026,0x0031),
-    /* Sound Blaster 16 PnP */
-    ISAPNP_SB16('C','T','L',0x0027,0x0031),
-    /* Sound Blaster 16 PnP */
-    ISAPNP_SB16('C','T','L',0x0028,0x0031),
-    /* Sound Blaster 16 PnP */
-    ISAPNP_SB16('C','T','L',0x0029,0x0031),
-    /* Sound Blaster 16 PnP */
-    ISAPNP_SB16('C','T','L',0x002a,0x0031),
+        { .id = "CTL0025", .devs = { { "CTL0031" } } },
+        /* Sound Blaster 16 PnP */
+        { .id = "CTL0026", .devs = { { "CTL0031" } } },
+        /* Sound Blaster 16 PnP */
+        { .id = "CTL0027", .devs = { { "CTL0031" } } },
+        /* Sound Blaster 16 PnP */
+        { .id = "CTL0028", .devs = { { "CTL0031" } } },
+        /* Sound Blaster 16 PnP */
+        { .id = "CTL0029", .devs = { { "CTL0031" } } },
+        /* Sound Blaster 16 PnP */
+        { .id = "CTL002a", .devs = { { "CTL0031" } } },
     /* Sound Blaster 16 PnP */
     /* Note: This card has also a CTL0051:StereoEnhance device!!! */
-    ISAPNP_SB16('C','T','L',0x002b,0x0031),
-    /* Sound Blaster 16 PnP */
-        ISAPNP_SB16('C','T','L',0x002c,0x0031), 
+        { .id = "CTL002b", .devs = { { "CTL0031" } } },
+        /* Sound Blaster 16 PnP */
+        { .id = "CTL002c", .devs = { { "CTL0031" } } },
     /* Sound Blaster Vibra16S */
-    ISAPNP_SB16('C','T','L',0x0051,0x0001),
+        { .id = "CTL0051", .devs = { { "CTL0001" } } },
     /* Sound Blaster Vibra16C */
-    ISAPNP_SB16('C','T','L',0x0070,0x0001),
+        { .id = "CTL0070", .devs = { { "CTL0001" } } },
     /* Sound Blaster Vibra16CL - added by ctm@ardi.com */
-    ISAPNP_SB16('C','T','L',0x0080,0x0041),
+        { .id = "CTL0080", .devs = { { "CTL0041" } } },
         /* Sound Blaster 16 'value' PnP. It says model ct4130 on the pcb, */
         /* but ct4131 on a sticker on the board.. */
-        ISAPNP_SB16('C','T','L',0x0086,0x0041),
+        { .id = "CTL0086", .devs = { { "CTL0041" } } },
     /* Sound Blaster Vibra16X */
-    ISAPNP_SB16('C','T','L',0x00f0,0x0043),
+        { .id = "CTL00f0", .devs = { { "CTL0043" } } },
 #else  /* SNDRV_SBAWE defined */
     /* Sound Blaster AWE 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x0035,0x0031,0x0021),
-    /* Sound Blaster AWE 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x0039,0x0031,0x0021),
-    /* Sound Blaster AWE 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x0042,0x0031,0x0021),
-    /* Sound Blaster AWE 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x0043,0x0031,0x0021),
+        { .id = "CTL0035", .devs = { { "CTL0031" }, { "CTL0021" } } },
+        /* Sound Blaster AWE 32 PnP */
+        { .id = "CTL0039", .devs = { { "CTL0031" }, { "CTL0021" } } },
+        /* Sound Blaster AWE 32 PnP */
+        { .id = "CTL0042", .devs = { { "CTL0031" }, { "CTL0021" } } },
+        /* Sound Blaster AWE 32 PnP */
+        { .id = "CTL0043", .devs = { { "CTL0031" }, { "CTL0021" } } },
     /* Sound Blaster AWE 32 PnP */
     /* Note: This card has also a CTL0051:StereoEnhance device!!! */
-    ISAPNP_SBAWE('C','T','L',0x0044,0x0031,0x0021),
+        { .id = "CTL0044", .devs = { { "CTL0031" }, { "CTL0021" } } },
     /* Sound Blaster AWE 32 PnP */
     /* Note: This card has also a CTL0051:StereoEnhance device!!! */
-    ISAPNP_SBAWE('C','T','L',0x0045,0x0031,0x0021),
-        /* Sound Blaster AWE 32 PnP */
-        ISAPNP_SBAWE('C','T','L',0x0046,0x0031,0x0021),
-    /* Sound Blaster AWE 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x0047,0x0031,0x0021),
-    /* Sound Blaster AWE 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x0048,0x0031,0x0021),
-    /* Sound Blaster AWE 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x0054,0x0031,0x0021),
-    /* Sound Blaster AWE 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x009a,0x0041,0x0021),
-    /* Sound Blaster AWE 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x009c,0x0041,0x0021),
+        { .id = "CTL0045", .devs = { { "CTL0031" }, { "CTL0021" } } },
+        /* Sound Blaster AWE 32 PnP */
+        { .id = "CTL0046", .devs = { { "CTL0031" }, { "CTL0021" } } },
+        /* Sound Blaster AWE 32 PnP */
+        { .id = "CTL0047", .devs = { { "CTL0031" }, { "CTL0021" } } },
+        /* Sound Blaster AWE 32 PnP */
+        { .id = "CTL0048", .devs = { { "CTL0031" }, { "CTL0021" } } },
+        /* Sound Blaster AWE 32 PnP */
+        { .id = "CTL0054", .devs = { { "CTL0031" }, { "CTL0021" } } },
+        /* Sound Blaster AWE 32 PnP */
+        { .id = "CTL009a", .devs = { { "CTL0041" }, { "CTL0021" } } },
+        /* Sound Blaster AWE 32 PnP */
+        { .id = "CTL009c", .devs = { { "CTL0041" }, { "CTL0021" } } },
     /* Sound Blaster 32 PnP */
-    ISAPNP_SBAWE('C','T','L',0x009f,0x0041,0x0021),
+        { .id = "CTL009f", .devs = { { "CTL0041" }, { "CTL0021" } } },
     /* Sound Blaster AWE 64 PnP */
-    ISAPNP_SBAWE('C','T','L',0x009d,0x0042,0x0022),
+        { .id = "CTL009d", .devs = { { "CTL0042" }, { "CTL0022" } } },
     /* Sound Blaster AWE 64 PnP Gold */
-    ISAPNP_SBAWE('C','T','L',0x009e,0x0044,0x0023),
+        { .id = "CTL009e", .devs = { { "CTL0044" }, { "CTL0023" } } },
     /* Sound Blaster AWE 64 PnP Gold */
-    ISAPNP_SBAWE('C','T','L',0x00b2,0x0044,0x0023),
+        { .id = "CTL00b2", .devs = { { "CTL0044" }, { "CTL0023" } } },
     /* Sound Blaster AWE 64 PnP */
-    ISAPNP_SBAWE('C','T','L',0x00c1,0x0042,0x0022),
+        { .id = "CTL00c1", .devs = { { "CTL0042" }, { "CTL0022" } } },
     /* Sound Blaster AWE 64 PnP */
-    ISAPNP_SBAWE('C','T','L',0x00c3,0x0045,0x0022),
+        { .id = "CTL00c3", .devs = { { "CTL0045" }, { "CTL0022" } } },
     /* Sound Blaster AWE 64 PnP */
-    ISAPNP_SBAWE('C','T','L',0x00c5,0x0045,0x0022),
+        { .id = "CTL00c5", .devs = { { "CTL0045" }, { "CTL0022" } } },
     /* Sound Blaster AWE 64 PnP */
-    ISAPNP_SBAWE('C','T','L',0x00c7,0x0045,0x0022),
+        { .id = "CTL00c7", .devs = { { "CTL0045" }, { "CTL0022" } } },
     /* Sound Blaster AWE 64 PnP */
-    ISAPNP_SBAWE('C','T','L',0x00e4,0x0045,0x0022),
+        { .id = "CTL00e4", .devs = { { "CTL0045" }, { "CTL0022" } } },
         /* Sound Blaster AWE 64 PnP */
-        ISAPNP_SBAWE('C','T','L',0x00e9,0x0045,0x0022),
+        { .id = "CTL00e9", .devs = { { "CTL0045" }, { "CTL0022" } } },
     /* Sound Blaster 16 PnP (AWE) */
-    ISAPNP_SBAWE('C','T','L',0x00ed,0x0041,0x0070),
+        { .id = "CTL00ed", .devs = { { "CTL0041" }, { "CTL0070" } } },
     /* Generic entries */
-    ISAPNP_SBAWE('C','T','L',ISAPNP_ANY_ID,0x0031,0x0021),
-    ISAPNP_SBAWE('C','T','L',ISAPNP_ANY_ID,0x0041,0x0021),
-    ISAPNP_SBAWE('C','T','L',ISAPNP_ANY_ID,0x0042,0x0022),
-    ISAPNP_SBAWE('C','T','L',ISAPNP_ANY_ID,0x0044,0x0023),
-    ISAPNP_SBAWE('C','T','L',ISAPNP_ANY_ID,0x0045,0x0022),
+        { .id = "CTLXXXX" , .devs = { { "CTL0031" }, { "CTL0021" } } },
+        { .id = "CTLXXXX" , .devs = { { "CTL0041" }, { "CTL0021" } } },
+        { .id = "CTLXXXX" , .devs = { { "CTL0042" }, { "CTL0022" } } },
+        { .id = "CTLXXXX" , .devs = { { "CTL0044" }, { "CTL0023" } } },
+        { .id = "CTLXXXX" , .devs = { { "CTL0045" }, { "CTL0022" } } },
 #endif /* SNDRV_SBAWE */
-    { ISAPNP_CARD_END, }
+        { .id = "", }
 };
 
-ISAPNP_CARD_TABLE(snd_sb16_pnpids);
-
-static int __init snd_sb16_isapnp(int dev, struct snd_sb16 *acard)
+MODULE_DEVICE_TABLE(pnp_card, snd_sb16_pnpids);
+
+#ifdef SNDRV_SBAWE_EMU8000
+#define DRIVER_NAME     "snd-card-sbawe"
+#else
+#define DRIVER_NAME     "snd-card-sb16"
+#endif
+
+static int __devinit snd_card_sb16_pnp(int dev, struct snd_card_sb16 *acard,
+                                       struct pnp_card_link *card,
+                                       const struct pnp_card_device_id *id)
 {
-    const struct isapnp_card_id *id = snd_sb16_isapnp_id[dev];
-    struct isapnp_card *card = snd_sb16_isapnp_cards[dev];
-    struct isapnp_dev *pdev;
-
-    acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-    if (acard->dev->active) {
-        acard->dev = NULL;
-        return -EBUSY;
-    }
-#ifdef SNDRV_SBAWE_EMU8000
-    acard->devwt = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
-    if (acard->devwt->active) {
-        acard->dev = acard->devwt = NULL;
-        return -EBUSY;
-    }
-#endif  
+        struct pnp_dev *pdev;
+        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
+        int err;
+
+        if (!cfg) 
+                return -ENOMEM; 
+        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (acard->dev == NULL) { 
+                kfree(cfg); 
+                return -ENODEV; 
+        } 
+#ifdef SNDRV_SBAWE_EMU8000
+        acard->devwt = pnp_request_card_device(card, id->devs[1].id, acard->dev);
+#endif
     /* Audio initialization */
     pdev = acard->dev;
-    if (pdev->prepare(pdev) < 0)
-        return -EAGAIN;
+
+        pnp_init_resource_table(cfg); 
+         
+        /* override resources */ 
+
         if (port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
         if (mpu_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[1], mpu_port[dev], 2);
+                pnp_resource_change(&cfg->port_resource[1], mpu_port[dev], 2);
         if (fm_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[2], fm_port[dev], 4);
+                pnp_resource_change(&cfg->port_resource[2], fm_port[dev], 4);
         if (dma8[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma8[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[0], dma8[dev], 1);
         if (dma16[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma16[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[1], dma16[dev], 1);
         if (irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
-    if (pdev->activate(pdev) < 0) {
-                printk(KERN_ERR PFX "isapnp configure failure (out of resources?)\n");
-        return -EBUSY;
-    }
-        port[dev] = pdev->resource[0].start;
-        mpu_port[dev] = pdev->resource[1].start;
-        fm_port[dev] = pdev->resource[2].start;
-        dma8[dev] = pdev->dma_resource[0].start;
-        dma16[dev] = pdev->dma_resource[1].start;
-        irq[dev] = pdev->irq_resource[0].start;
-    snd_printdd("isapnp SB16: port=0x%lx, mpu port=0x%lx, fm port=0x%lx\n",
+                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
+        if (pnp_manual_config_dev(pdev, cfg, 0) < 0) 
+                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n"); 
+        err = pnp_activate_dev(pdev); 
+        if (err < 0) { 
+                snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n"); 
+                kfree(cfg);
+                return err; 
+        } 
+        port[dev] = pnp_port_start(pdev, 0);
+        mpu_port[dev] = pnp_port_start(pdev, 1);
+        fm_port[dev] = pnp_port_start(pdev, 2);
+        dma8[dev] = pnp_dma(pdev, 0);
+        dma16[dev] = pnp_dma(pdev, 1);
+        irq[dev] = pnp_irq(pdev, 0);
+        snd_printdd("pnp SB16: port=0x%lx, mpu port=0x%lx, fm port=0x%lx\n",
                         port[dev], mpu_port[dev], fm_port[dev]);
-    snd_printdd("isapnp SB16: dma1=%i, dma2=%i, irq=%i\n",
+        snd_printdd("pnp SB16: dma1=%i, dma2=%i, irq=%i\n",
                         dma8[dev], dma16[dev], irq[dev]);
 #ifdef SNDRV_SBAWE_EMU8000
     /* WaveTable initialization */
     pdev = acard->devwt;
-    if (pdev->prepare(pdev)<0) {
-        acard->dev->deactivate(acard->dev);
-        return -EAGAIN;
-    }
+        if (pdev != NULL) {
+                pnp_init_resource_table(cfg); 
+         
+                /* override resources */ 
+
         if (awe_port[dev] != SNDRV_AUTO_PORT) {
-                isapnp_resource_change(&pdev->resource[0], awe_port[dev], 4);
-                isapnp_resource_change(&pdev->resource[1], awe_port[dev] + 0x400, 4);
-                isapnp_resource_change(&pdev->resource[2], awe_port[dev] + 0x800, 4);
+                        pnp_resource_change(&cfg->port_resource[0], awe_port[dev], 4);
+                        pnp_resource_change(&cfg->port_resource[1], awe_port[dev] + 0x400, 4);
+                        pnp_resource_change(&cfg->port_resource[2], awe_port[dev] + 0x800, 4);
+                }
+                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0) 
+                        snd_printk(KERN_ERR PFX "WaveTable the requested resources are invalid, using auto config\n"); 
+                err = pnp_activate_dev(pdev); 
+                if (err < 0) { 
+                        goto __wt_error; 
+                } 
+                awe_port[dev] = pnp_port_start(pdev, 0);
+                snd_printdd("pnp SB16: wavetable port=0x%lx\n", pnp_port_start(pdev, 0));
+        } else {
+__wt_error:
+                if (pdev) {
+                        pnp_release_card_device(pdev);
+                        snd_printk(KERN_ERR PFX "WaveTable pnp configure failure\n");
+                }
+        acard->devwt = NULL;
+                awe_port[dev] = -1;
         }
-    if (pdev->activate(pdev)<0) {
-                printk(KERN_ERR PFX "WaveTable isapnp configure failure (out of resources?)\n");
-                acard->dev->deactivate(acard->dev);             
-        return -EBUSY;
-    }
-        awe_port[dev] = pdev->resource[0].start;
-    snd_printdd("isapnp SB16: wavetable port=0x%lx\n", pdev->resource[0].start);
-#endif
-    return 0;
+#endif
+        kfree(cfg);
+        return 0;
 }
 
-static void snd_sb16_deactivate(struct snd_sb16 *acard)
-{
-    if (acard->dev) {
-        acard->dev->deactivate(acard->dev);
-        acard->dev = NULL;
-    }
-#ifdef SNDRV_SBAWE_EMU8000
-    if (acard->devwt) {
-        acard->devwt->deactivate(acard->devwt);
-        acard->devwt = NULL;
-    }
-#endif
-}
-
-#endif /* __ISAPNP__ */
-
-static void snd_sb16_free(snd_card_t *card)
-{
-    struct snd_sb16 *acard = (struct snd_sb16 *)card->private_data;
-
-    if (acard == NULL)
-        return;
-        if (acard->fm_res) {
-        release_resource(acard->fm_res);
-                kfree_nocheck(acard->fm_res);
-        }
-#ifdef __ISAPNP__
-    snd_sb16_deactivate(acard);
-#endif
-}
-
-static int __init snd_sb16_probe(int dev)
+static int __init snd_sb16_probe(int dev,
+                                 struct pnp_card_link *pcard,
+                                 const struct pnp_card_device_id *pid)
 {
     static int possible_irqs[] = {5, 9, 10, 7, -1};
@@ -413 +375 @@
     sb_t *chip;
     snd_card_t *card;
-    struct snd_sb16 *acard;
+        struct snd_card_sb16 *acard;
     opl3_t *opl3;
     snd_hwdep_t *synth = NULL;
@@ -423 +385 @@
 
         card = snd_card_new(index[dev], id[dev], THIS_MODULE,
-                        sizeof(struct snd_sb16));
+                            sizeof(struct snd_card_sb16));
     if (card == NULL)
         return -ENOMEM;
-    acard = (struct snd_sb16 *) card->private_data;
-    card->private_free = snd_sb16_free;
-#ifdef __ISAPNP__
-        if (isapnp[dev] && snd_sb16_isapnp(dev, acard) < 0) {
-        snd_card_free(card);
-        return -EBUSY;
-    }
-#endif
+        acard = (struct snd_card_sb16 *) card->private_data;
+        if (isapnp[dev]) {
+                if ((err = snd_card_sb16_pnp(dev, acard, pcard, pid))) {
+                        snd_card_free(card);
+                        return err;
+                }
+        }
 
         xirq = irq[dev];
         xdma8 = dma8[dev];
         xdma16 = dma16[dev];
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (!isapnp[dev]) {
 #endif
@@ -444 +405 @@
                 if ((xirq = snd_legacy_find_free_irq(possible_irqs)) < 0) {
                 snd_card_free(card);
-                        printk(KERN_ERR PFX "unable to find a free IRQ\n");
+                        snd_printk(KERN_ERR PFX "unable to find a free IRQ\n");
                 return -EBUSY;
             }
@@ -451 +412 @@
                 if ((xdma8 = snd_legacy_find_free_dma(possible_dmas8)) < 0) {
                 snd_card_free(card);
-                        printk(KERN_ERR PFX "unable to find a free 8-bit DMA\n");
+                        snd_printk(KERN_ERR PFX "unable to find a free 8-bit DMA\n");
                 return -EBUSY;
             }
@@ -458 +419 @@
                 if ((xdma16 = snd_legacy_find_free_dma(possible_dmas16)) < 0) {
                 snd_card_free(card);
-                        printk(KERN_ERR PFX "unable to find a free 16-bit DMA\n");
+                        snd_printk(KERN_ERR PFX "unable to find a free 16-bit DMA\n");
                 return -EBUSY;
             }
@@ -470 +431 @@
         awe_port[dev] = port[dev] + 0x400;
 #endif
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
     }
 #endif
@@ -491 +452 @@
     }
         chip->mpu_port = mpu_port[dev];
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (!isapnp[dev] && (err = snd_sb16dsp_configure(chip)) < 0) {
 #else
@@ -518 +479 @@
                                     OPL3_HW_OPL3, fm_port[dev] == port[dev],
                                 &opl3) < 0) {
-                        printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
+                        snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
                                    fm_port[dev], fm_port[dev] + 2);
             } else {
@@ -546 +507 @@
                 chip->hardware = SB_HW_16CSP;
             } else {
-                        printk(KERN_INFO PFX "warning - CSP chip not detected on soundcard #%i\n", dev + 1);
+                        snd_printk(KERN_INFO PFX "warning - CSP chip not detected on soundcard #%i\n", dev + 1);
             }
         }
@@ -554 +515 @@
                 if (snd_emu8000_new(card, 1, awe_port[dev],
                                     seq_ports[dev], NULL) < 0) {
-                        printk(KERN_ERR PFX "fatal error - EMU-8000 synthesizer not detected at 0x%lx\n", awe_port[dev]);
+                        snd_printk(KERN_ERR PFX "fatal error - EMU-8000 synthesizer not detected at 0x%lx\n", awe_port[dev]);
                 snd_card_free(card);
                 return -ENXIO;
@@ -587 +548 @@
             return err;
         }
-        snd_sb16_cards[dev] = card;
+        if (pcard)
+                pnp_set_card_drvdata(pcard, card);
+        else
+                snd_sb16_legacy[dev] = card;
         return 0;
     }
@@ -599 +563 @@
                 if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT)
                 continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                 continue;
 #endif
                 port[dev] = xport;
-            res = snd_sb16_probe(dev);
+                res = snd_sb16_probe(dev, NULL, NULL);
             if (res < 0)
                         port[dev] = SNDRV_AUTO_PORT;
@@ -612 +576 @@
     }
 
-#ifdef __ISAPNP__
-
-    static int __init snd_sb16_isapnp_detect(struct isapnp_card *card,
-                                             const struct isapnp_card_id *id)
+#ifdef CONFIG_PNP
+
+static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *card,
+                                         const struct pnp_card_device_id *id)
     {
         static int dev;
@@ -623 +587 @@
                 if (!enable[dev] || !isapnp[dev])
                 continue;
-            snd_sb16_isapnp_cards[dev] = card;
-            snd_sb16_isapnp_id[dev] = id;
-            res = snd_sb16_probe(dev);
+                res = snd_sb16_probe(dev, card, id);
             if (res < 0)
                 return res;
@@ -635 +597 @@
     }
 
-#endif /* __ISAPNP__ */
+static void __devexit snd_sb16_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver sb16_pnpc_driver = {
+        .flags = PNP_DRIVER_RES_DISABLE,
+        .name = "sb16",
+        .id_table = snd_sb16_pnpids,
+        .probe = snd_sb16_pnp_detect,
+        .remove = __devexit_p(snd_sb16_pnp_remove),
+};
+
+#endif /* CONFIG_PNP */
 
     static int __init alsa_card_sb16_init(void)
@@ -646 +624 @@
                 if (!enable[dev] || port[dev] == SNDRV_AUTO_PORT)
                 continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                 continue;
 #endif
-            if (!snd_sb16_probe(dev)) {
+                if (!snd_sb16_probe(dev, NULL, NULL)) {
                 cards++;
                 continue;
             }
 #ifdef MODULE
-                printk(KERN_ERR "Sound Blaster 16+ soundcard #%i not found at 0x%lx or device busy\n", dev, port[dev]);
-#endif                  
+                snd_printk(KERN_ERR "Sound Blaster 16+ soundcard #%i not found at 0x%lx or device busy\n", dev, port[dev]);
+#endif
         }
         /* legacy auto configured cards */
         cards += snd_legacy_auto_probe(possible_ports, snd_sb16_probe_legacy_port);
-#ifdef __ISAPNP__
-        /* ISA PnP cards at last */
-        cards += isapnp_probe_cards(snd_sb16_pnpids, snd_sb16_isapnp_detect);
+#ifdef CONFIG_PNP
+        /* PnP cards at last */
+        cards += pnp_register_card_driver(&sb16_pnpc_driver);
 #endif
 
         if (!cards) {
+#ifdef CONFIG_PNP
+                pnp_unregister_card_driver(&sb16_pnpc_driver);
+#endif
 #ifdef MODULE
-                printk(KERN_ERR "Sound Blaster 16 soundcard not found or device busy\n");
-#ifdef SNDRV_SBAWE_EMU8000
-                printk(KERN_ERR "In case, if you have non-AWE card, try snd-sb16 module\n");
-#else
-                printk(KERN_ERR "In case, if you have AWE card, try snd-sbawe module\n");
+                snd_printk(KERN_ERR "Sound Blaster 16 soundcard not found or device busy\n");
+#ifdef SNDRV_SBAWE_EMU8000
+                snd_printk(KERN_ERR "In case, if you have non-AWE card, try snd-sb16 module\n");
+#else
+                snd_printk(KERN_ERR "In case, if you have AWE card, try snd-sbawe module\n");
 #endif
 #endif
@@ -683 +664 @@
         int dev;
 
+#ifdef CONFIG_PNP
+        /* PnP cards first */
+        pnp_unregister_card_driver(&sb16_pnpc_driver);
+#endif
         for (dev = 0; dev < SNDRV_CARDS; dev++)
-            snd_card_free(snd_sb16_cards[dev]);
+                snd_card_free(snd_sb16_legacy[dev]);
     }
 
@@ -727 +712 @@
 #endif
               );
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (pnp != INT_MAX)
                 isapnp[nr_dev] = pnp;

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb16_main.c

@@ -394 +394 @@
 }
 
-void snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
     sb_t *chip = dev_id;
@@ -439 +439 @@
         spin_unlock(&chip->reg_lock);
     }
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb8.c

@@ -71 +71 @@
 static snd_card_t *snd_sb8_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
 
-static void snd_sb8_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        sb_t *chip = snd_magic_cast(sb_t, dev_id, return);
+static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        sb_t *chip = snd_magic_cast(sb_t, dev_id, return IRQ_NONE);
 
     if (chip->open & SB_OPEN_PCM) {
-        snd_sb8dsp_interrupt(chip);
+                return snd_sb8dsp_interrupt(chip);
     } else {
-        snd_sb8dsp_midi_interrupt(chip);
+                return snd_sb8dsp_midi_interrupt(chip);
     }
 }
@@ -144 +144 @@
                                    OPL3_HW_AUTO, 1,
                                    &opl3)) < 0) {
-                        printk(KERN_ERR "sb8: no OPL device at 0x%lx\n", chip->port + 8);
+                        snd_printk(KERN_ERR "sb8: no OPL device at 0x%lx\n", chip->port + 8);
         }
     } else {
@@ -150 +150 @@
                                    OPL3_HW_AUTO, 1,
                                    &opl3)) < 0) {
-                        printk(KERN_ERR "sb8: no OPL device at 0x%lx-0x%lx\n",
+                        snd_printk(KERN_ERR "sb8: no OPL device at 0x%lx-0x%lx\n",
                        chip->port, chip->port + 2);
         }
@@ -211 +211 @@
     if (!cards) {
 #ifdef MODULE
-                printk(KERN_ERR "Sound Blaster soundcard not found or device busy\n");
+                snd_printk(KERN_ERR "Sound Blaster soundcard not found or device busy\n");
 #endif
         return -ENODEV;

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb8_main.c

@@ -332 +332 @@
 }
 
-void snd_sb8dsp_interrupt(sb_t *chip)
+irqreturn_t snd_sb8dsp_interrupt(sb_t *chip)
 {
     snd_pcm_substream_t *substream;
@@ -357 +357 @@
         break;
     }
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb8_midi.c

@@ -34 +34 @@
 */
 
-void snd_sb8dsp_midi_interrupt(sb_t * chip)
+irqreturn_t snd_sb8dsp_midi_interrupt(sb_t * chip)
 {
     snd_rawmidi_t *rmidi;
@@ -42 +42 @@
     if (chip == NULL || (rmidi = chip->rmidi) == NULL) {
         inb(SBP(chip, READ));   /* ack interrupt */
-        return;
+                return IRQ_NONE;
     }
     while (max-- > 0) {
@@ -54 +54 @@
         }
     }
+        return IRQ_HANDLED;
 }
 
@@ -206 +207 @@
     if (up) {
         if (!(chip->open & SB_OPEN_MIDI_TRIGGER)) {
+                        init_timer(&chip->midi_timer);
             chip->midi_timer.function = snd_sb8dsp_midi_output_timer;
             chip->midi_timer.data = (unsigned long) substream;

GPL/branches/alsa-resync1/alsa-kernel/isa/sgalaxy.c

@@ -113 +113 @@
 }
 
-static void snd_sgalaxy_dummy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
+static irqreturn_t snd_sgalaxy_dummy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        return IRQ_NONE;
 }
 
@@ -307 +308 @@
         if (!cards) {
 #ifdef MODULE
-                printk(KERN_ERR "Sound Galaxy soundcard not found or device busy\n");
+                snd_printk(KERN_ERR "Sound Galaxy soundcard not found or device busy\n");
 #endif
                 return -ENODEV;

GPL/branches/alsa-resync1/alsa-kernel/isa/wavefront/wavefront.c

@@ -22 +22 @@
 #include <sound/driver.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/slab.h>
-#ifndef LINUX_ISAPNP_H
-#include <linux/isapnp.h>
-#define isapnp_card pci_bus
-#define isapnp_dev pci_dev
-#endif
+#include <linux/pnp.h>
 #include <sound/core.h>
 #define SNDRV_GET_ID
@@ -66 +63 @@
 MODULE_PARM_DESC(enable, "Enable WaveFront soundcard.");
 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
 MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
 MODULE_PARM_DESC(isapnp, "ISA PnP detection for WaveFront soundcards.");
@@ -102 +99 @@
 MODULE_PARM_SYNTAX(use_cs4232_midi, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC);
 
-static snd_card_t *snd_wavefront_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-#ifdef __ISAPNP__
-
-static struct isapnp_card *snd_wavefront_isapnp_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-static const struct isapnp_card_id *snd_wavefront_isapnp_id[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-static struct isapnp_card_id snd_wavefront_pnpids[] __devinitdata = {
-        {
-                ISAPNP_CARD_ID('C','S','C',0x7532),     /* Tropez */
-                .devs = { ISAPNP_DEVICE_ID('C','S','C',0x0000), /* WSS */
-                        ISAPNP_DEVICE_ID('C','S','C',0x0010),   /* CTRL */
-                        ISAPNP_DEVICE_ID('P','n','P',0xb006),   /* MPU */
-                        ISAPNP_DEVICE_ID('C','S','C',000004), }, /* SYNTH */
-        },
-        {
-                ISAPNP_CARD_ID('C','S','C',0x7632),     /* Tropez+ */
-                .devs = { ISAPNP_DEVICE_ID('C','S','C',0x0000), /* WSS */
-                        ISAPNP_DEVICE_ID('C','S','C',0x0010),   /* CTRL */
-                        ISAPNP_DEVICE_ID('P','n','P',0xb006),   /* MPU */
-                        ISAPNP_DEVICE_ID('C','S','C',000004), }, /* SYNTH */
-        },
-        { ISAPNP_CARD_END, }
+static snd_card_t *snd_wavefront_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+
+#ifdef CONFIG_PNP
+
+static struct pnp_card_device_id snd_wavefront_pnpids[] __devinitdata = {
+        /* Tropez */
+        { .id = "CSC7532", .devs = { { "CSC0000" }, { "CSC0010" }, { "PnPb006" }, { "CSC0004" } } },
+        /* Tropez+ */
+        { .id = "CSC7632", .devs = { { "CSC0000" }, { "CSC0010" }, { "PnPb006" }, { "CSC0004" } } },
+        { .id = "" }
 };
 
-ISAPNP_CARD_TABLE(snd_wavefront_pnpids);
-
-static int __init
-snd_wavefront_isapnp (int dev, snd_wavefront_card_t *acard)
-{
-        const struct isapnp_card_id *id = snd_wavefront_isapnp_id[dev];
-        struct isapnp_card *card = snd_wavefront_isapnp_cards[dev];
-        struct isapnp_dev *pdev;
-        int tmp;
+MODULE_DEVICE_TABLE(pnp_card, snd_wavefront_pnpids);
+
+static int __devinit
+snd_wavefront_pnp (int dev, snd_wavefront_card_t *acard, struct pnp_card_link *card,
+                   const struct pnp_card_device_id *id)
+{
+        struct pnp_dev *pdev;
+        struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
+        int err;
+
+        if (!cfg)
+                return -ENOMEM;
         
         /* Check for each logical device. */
@@ -141 +128 @@
         /* CS4232 chip (aka "windows sound system") is logical device 0 */
 
-        acard->wss = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
-        if (acard->wss->active) {
-                acard->wss = NULL;
+        acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (acard->wss == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
@@ -159 +146 @@
 
         if (use_cs4232_midi[dev]) {
-                acard->mpu = isapnp_find_dev(card, id->devs[2].vendor, id->devs[2].function, NULL);
-                if (acard->mpu->active) {
-                        acard->wss = acard->synth = acard->mpu = NULL;
+                acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL);
+                if (acard->mpu == NULL) {
+                        kfree(cfg);
                         return -EBUSY;
                 }
@@ -168 +155 @@
         /* The ICS2115 synth is logical device 4 */
 
-        acard->synth = isapnp_find_dev(card, id->devs[3].vendor, id->devs[3].function, NULL);
-        if (acard->synth->active) {
-                acard->wss = acard->synth = NULL;
+        acard->synth = pnp_request_card_device(card, id->devs[3].id, NULL);
+        if (acard->synth == NULL) {
+                kfree(cfg);
                 return -EBUSY;
         }
@@ -178 +165 @@
         pdev = acard->wss;
 
-        if ((tmp = pdev->prepare (pdev)) < 0) {
-                if (tmp == -EBUSY) {
-                        snd_printk ("ISA PnP configuration appears to have "
-                                    "been done. Restart the isapnp module.\n");
-                        return 0;
-                }
-                snd_printk ("isapnp WSS preparation failed\n");
-                return -EAGAIN;
-        }
+        pnp_init_resource_table(cfg);
 
         /* An interesting note from the Tropez+ FAQ:
@@ -201 +180 @@
 
         if (cs4232_pcm_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[0], cs4232_pcm_port[dev], 4);
         if (fm_port[dev] != SNDRV_AUTO_PORT)
-                isapnp_resource_change(&pdev->resource[1], fm_port[dev], 4);
+                pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
         if (dma1[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[0], dma1[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
         if (dma2[dev] != SNDRV_AUTO_DMA)
-                isapnp_resource_change(&pdev->dma_resource[1], dma2[dev], 1);
+                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
         if (cs4232_pcm_irq[dev] != SNDRV_AUTO_IRQ)
-                isapnp_resource_change(&pdev->irq_resource[0], cs4232_pcm_irq[dev], 1);
-
-        if (pdev->activate(pdev)<0) {
-                snd_printk ("isapnp WSS activation failed\n");
-                return -EBUSY;
-        }
-
-        cs4232_pcm_port[dev] = pdev->resource[0].start;
-        fm_port[dev] = pdev->resource[1].start;
-        dma1[dev] = pdev->dma_resource[0].start;
-        dma2[dev] = pdev->dma_resource[1].start;
-        cs4232_pcm_irq[dev] = pdev->irq_resource[0].start;
+                pnp_resource_change(&cfg->irq_resource[0], cs4232_pcm_irq[dev], 1);
+
+        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                snd_printk(KERN_ERR "PnP WSS the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR "PnP WSS pnp configure failure\n");
+                kfree(cfg);
+                return err;
+        }
+
+        cs4232_pcm_port[dev] = pnp_port_start(pdev, 0);
+        fm_port[dev] = pnp_port_start(pdev, 1);
+        dma1[dev] = pnp_dma(pdev, 0);
+        dma2[dev] = pnp_dma(pdev, 1);
+        cs4232_pcm_irq[dev] = pnp_irq(pdev, 0);
 
         /* Synth initialization */
@@ -226 +208 @@
                 pdev = acard->synth;
 
-        if ((tmp = pdev->prepare(pdev))<0) {
-                if (tmp == -EBUSY) {
-                        snd_printk ("ISA PnP configuration appears to have "
-                                    "been done. Restart the isapnp module.\n");
-                }
-                        acard->wss->deactivate(acard->wss);
-                        snd_printk ("ICS2115 synth preparation failed\n");
-                        return -EAGAIN;
-                }
+        pnp_init_resource_table(cfg);
+
         if (ics2115_port[dev] != SNDRV_AUTO_PORT) {
-                isapnp_resource_change(&pdev->resource[0], ics2115_port[dev], 16);
+                pnp_resource_change(&cfg->port_resource[0], ics2115_port[dev], 16);
         }
                 
         if (ics2115_port[dev] != SNDRV_AUTO_IRQ) {
-                isapnp_resource_change(&pdev->irq_resource[0], ics2115_irq[dev], 1);
-        }
-
-                if (pdev->activate(pdev)<0) {
-                snd_printk("isapnp activation for ICS2115 failed\n");
-                        acard->wss->deactivate(acard->wss);
-                        return -EBUSY;
-                }
-                
-        ics2115_port[dev] = pdev->resource[0].start;
-        ics2115_irq[dev] = pdev->irq_resource[0].start;
+                pnp_resource_change(&cfg->irq_resource[0], ics2115_irq[dev], 1);
+        }
+
+        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                snd_printk(KERN_ERR "PnP ICS2115 the requested resources are invalid, using auto config\n");
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR "PnP ICS2115 pnp configure failure\n");
+                kfree(cfg);
+                return err;
+        }
+
+        ics2115_port[dev] = pnp_port_start(pdev, 0);
+        ics2115_irq[dev] = pnp_irq(pdev, 0);
 
         /* CS4232 MPU initialization. Configure this only if
@@ -261 +239 @@
                 pdev = acard->mpu;
 
-                if (pdev->prepare(pdev)<0) {
-                        acard->wss->deactivate(acard->wss);
-                        if (acard->synth)
-                                acard->synth->deactivate(acard->synth);
-                        snd_printk ("CS4232 MPU preparation failed\n");
-                        return -EAGAIN;
-                }
+                pnp_init_resource_table(cfg);
 
                 if (cs4232_mpu_port[dev] != SNDRV_AUTO_PORT)
-                        isapnp_resource_change(&pdev->resource[0], cs4232_mpu_port[dev], 2);
+                        pnp_resource_change(&cfg->port_resource[0], cs4232_mpu_port[dev], 2);
                 if (cs4232_mpu_irq[dev] != SNDRV_AUTO_IRQ)
-                        isapnp_resource_change(&pdev->resource[0], cs4232_mpu_irq[dev], 1);
-
-                if (pdev->activate(pdev)<0) {
-                        snd_printk("isapnp CS4232 MPU activation failed\n");
+                        pnp_resource_change(&cfg->port_resource[0], cs4232_mpu_irq[dev], 1);
+
+                if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
+                        snd_printk(KERN_ERR "PnP MPU401 the requested resources are invalid, using auto config\n");
+                err = pnp_activate_dev(pdev);
+                if (err < 0) {
+                        snd_printk(KERN_ERR "PnP MPU401 pnp configure failure\n");
                         cs4232_mpu_port[dev] = SNDRV_AUTO_PORT;
                 } else {
-                        cs4232_mpu_port[dev] = pdev->resource[0].start;
-                        cs4232_mpu_irq[dev] = pdev->irq_resource[0].start;
+                        cs4232_mpu_port[dev] = pnp_port_start(pdev, 0);
+                        cs4232_mpu_irq[dev] = pnp_irq(pdev, 0);
                 }
 
@@ -296 +271 @@
                     ics2115_irq[dev]);
 
+        kfree(cfg);
         return 0;
 }
 
-static void 
-snd_wavefront_deactivate (snd_wavefront_card_t *acard)
-{
-        snd_printk ("deactivating PnP devices\n");
-        if (acard->wss) {
-                acard->wss->deactivate(acard->wss);
-                acard->wss = NULL;
-        }
-        if (acard->ctrl) {
-                acard->ctrl->deactivate(acard->ctrl);
-                acard->ctrl = NULL;
-        }
-        if (acard->mpu) {
-                acard->mpu->deactivate(acard->mpu);
-                acard->mpu = NULL;
-        }
-        if (acard->synth) {
-                acard->synth->deactivate(acard->synth);
-                acard->synth = NULL;
-        }
-}
-
-#endif /* __ISAPNP__ */
-
-static void snd_wavefront_ics2115_interrupt(int irq, 
+#endif /* CONFIG_PNP */
+
+static irqreturn_t snd_wavefront_ics2115_interrupt(int irq, 
                                             void *dev_id, 
                                             struct pt_regs *regs)
@@ -332 +286 @@
 
         if (acard == NULL) 
-                return;
+                return IRQ_NONE;
 
         if (acard->wavefront.interrupts_are_midi) {
@@ -339 +293 @@
                 snd_wavefront_internal_interrupt (acard);
         }
-}
-
-snd_hwdep_t * __init
+        return IRQ_HANDLED;
+}
+
+snd_hwdep_t * __devinit
 snd_wavefront_new_synth (snd_card_t *card,
                          int hw_dev,
@@ -367 +322 @@
 }
 
-snd_hwdep_t * __init
+snd_hwdep_t * __devinit
 snd_wavefront_new_fx (snd_card_t *card,
                       int hw_dev,
@@ -394 +349 @@
 static snd_wavefront_mpu_id external_id = external_mpu;
 
-snd_rawmidi_t * __init
+snd_rawmidi_t * __devinit
 snd_wavefront_new_midi (snd_card_t *card,
                         int midi_dev,
@@ -441 +396 @@
         
         if (acard) {
-#ifdef __ISAPNP__
-                snd_wavefront_deactivate(acard);
-#endif
                 if (acard->wavefront.res_base != NULL) {
                         release_resource(acard->wavefront.res_base);
@@ -453 +405 @@
 }
 
-static int __init
-snd_wavefront_probe (int dev)
+static int __devinit
+snd_wavefront_probe (int dev, struct pnp_card_link *pcard,
+                     const struct pnp_card_device_id *pid)
 {
         snd_card_t *card;
@@ -472 +425 @@
                 ics2115_port[dev] = SNDRV_AUTO_PORT;
 
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         if (!isapnp[dev]) {
 #endif
@@ -483 +436 @@
                         return -ENODEV;
                 }
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
         }
 #endif
@@ -502 +455 @@
         card->private_free = snd_wavefront_free;
 
-#ifdef __ISAPNP__
-        if (isapnp[dev] && snd_wavefront_isapnp (dev, acard) < 0) {
+#ifdef CONFIG_PNP
+        if (isapnp[dev] && snd_wavefront_pnp (dev, acard, pcard, pid) < 0) {
                 if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) {
                         snd_printk ("isapnp detection failed\n");
@@ -510 +463 @@
                 }
         }
-#endif /* __ISAPNP__ */
+#endif /* CONFIG_PNP */
 
         /* --------- PCM --------------- */
@@ -694 +647 @@
                 return err;
         }
-        snd_wavefront_cards[dev] = card;
+        if (pcard)
+                pnp_set_card_drvdata(pcard, card);
+        else
+                snd_wavefront_legacy[dev] = card;
         return 0;
 }       
 
-#ifdef __ISAPNP__
-
-static int __init snd_wavefront_isapnp_detect(struct isapnp_card *card,
-                                              const struct isapnp_card_id *id)
+#ifdef CONFIG_PNP
+
+static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *card,
+                                              const struct pnp_card_device_id *id)
 {
         static int dev;
@@ -709 +665 @@
                 if (!enable[dev] || !isapnp[dev])
                         continue;
-                snd_wavefront_isapnp_cards[dev] = card;
-                snd_wavefront_isapnp_id[dev] = id;
-                res = snd_wavefront_probe(dev);
+                res = snd_wavefront_probe(dev, card, id);
                 if (res < 0)
                         return res;
@@ -721 +675 @@
 }
 
-#endif /* __ISAPNP__ */
+static void __devexit snd_wavefront_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+}
+
+static struct pnp_card_driver wavefront_pnpc_driver = {
+        .flags          = PNP_DRIVER_RES_DISABLE,
+        .name           = "wavefront",
+        .id_table       = snd_wavefront_pnpids,
+        .probe          = snd_wavefront_pnp_detect,
+        .remove         = __devexit_p(snd_wavefront_pnp_remove),
+};
+
+#endif /* CONFIG_PNP */
 
 static int __init alsa_card_wavefront_init(void)
@@ -730 +700 @@
                 if (!enable[dev])
                         continue;
-#ifdef __ISAPNP__
+#ifdef CONFIG_PNP
                 if (isapnp[dev])
                         continue;
 #endif
-                if (snd_wavefront_probe(dev) >= 0)
+                if (snd_wavefront_probe(dev, NULL, NULL) >= 0)
                         cards++;
         }
-#ifdef __ISAPNP__
-        cards += isapnp_probe_cards(snd_wavefront_pnpids, snd_wavefront_isapnp_detect);
+#ifdef CONFIG_PNP
+        cards += pnp_register_card_driver(&wavefront_pnpc_driver);
 #endif
         if (!cards) {
+#ifdef CONFIG_PNP
+                pnp_unregister_card_driver(&wavefront_pnpc_driver);
+#endif
 #ifdef MODULE
                 printk (KERN_ERR "No WaveFront cards found or devices busy\n");
@@ -753 +726 @@
         int idx;
 
+#ifdef CONFIG_PNP
+        pnp_unregister_card_driver(&wavefront_pnpc_driver);
+#endif
         for (idx = 0; idx < SNDRV_CARDS; idx++)
-                snd_card_free(snd_wavefront_cards[idx]);
+                snd_card_free(snd_wavefront_legacy[idx]);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/isa/wavefront/wavefront_fx.c

@@ -228 +228 @@
    utility was run with I/O tracing in DOSEMU enabled, and a reconstruction
    of the port I/O done, using the Yamaha faxback document as a guide
-   to add more logic to the code. Its really pretty wierd.
+   to add more logic to the code. Its really pretty weird.
 
    There was an alternative approach of just dumping the whole I/O
@@ -693 +693 @@
 }
 
-/* wierd stuff, derived from port I/O tracing with dosemu */
+/* weird stuff, derived from port I/O tracing with dosemu */
 
 static unsigned char page_zero[] __initdata = {

GPL/branches/alsa-resync1/alsa-kernel/isa/wavefront/wavefront_synth.c

@@ -520 +520 @@
 WaveFront data munging   
 
-Things here are wierd. All data written to the board cannot 
+Things here are weird. All data written to the board cannot 
 have its most significant bit set. Any data item with values 
 potentially > 0x7F (127) must be split across multiple bytes.
@@ -529 +529 @@
 efficient approach to handling both cases seems to be to use 2
 different functions for munging and 2 for de-munging. This avoids
-wierd casting and worrying about bit-level offsets.
+weird casting and worrying about bit-level offsets.
 
 **********************************************************************/
@@ -909 +909 @@
         if (header->size) {
 
-                /* XXX its a debatable point whether or not RDONLY semantics
+                /* XXX it's a debatable point whether or not RDONLY semantics
                    on the ROM samples should cover just the sample data or
                    the sample header. For now, it only covers the sample data,
@@ -1037 +1037 @@
                              shptr, 4);
         
-        /* This one is truly wierd. What kind of wierdo decided that in
+        /* This one is truly weird. What kind of weirdo decided that in
            a system dominated by 16 and 32 bit integers, they would use
            a just 12 bits ?

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ak4xxx.c

@@ -30 +30 @@
 #include "ice1712.h"
 
+static void snd_ice1712_akm4xxx_lock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
+
+        snd_ice1712_save_gpio_status(ice);
+}
+
+static void snd_ice1712_akm4xxx_unlock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
+
+        snd_ice1712_restore_gpio_status(ice);
+}
 
 /*
  * write AK4xxx register
  */
-void snd_ice1712_akm4xxx_write(akm4xxx_t *ak, int chip,
-                              unsigned char addr, unsigned char data)
+static void snd_ice1712_akm4xxx_write(akm4xxx_t *ak, int chip,
+                                      unsigned char addr, unsigned char data)
 {
         unsigned int tmp;
         int idx;
         unsigned int addrdata;
-        ice1712_t *ice = ak->chip;
+        struct snd_ak4xxx_private *priv = (void *)ak->private_value[0];
+        ice1712_t *ice = ak->private_data[0];
 
         snd_assert(chip >= 0 && chip < 4, return);
 
-        if (ak->ops.start) {
-                if (ak->ops.start(ak, chip) < 0)
-                        return;
-        } else
-                snd_ice1712_save_gpio_status(ice);
-
         tmp = snd_ice1712_gpio_read(ice);
-        tmp |= ak->add_flags;
-        tmp &= ~ak->mask_flags;
-        if (ak->cs_mask == ak->cs_addr) {
-                if (ak->cif) {
-                        tmp |= ak->cs_mask; /* start without chip select */
+        tmp |= priv->add_flags;
+        tmp &= ~priv->mask_flags;
+        if (priv->cs_mask == priv->cs_addr) {
+                if (priv->cif) {
+                        tmp |= priv->cs_mask; /* start without chip select */
                 }  else {
-                        tmp &= ~ak->cs_mask; /* chip select low */
+                        tmp &= ~priv->cs_mask; /* chip select low */
                         snd_ice1712_gpio_write(ice, tmp);
                         udelay(1);
@@ -63 +71 @@
         } else {
                 /* doesn't handle cf=1 yet */
-                tmp &= ~ak->cs_mask;
-                tmp |= ak->cs_addr;
+                tmp &= ~priv->cs_mask;
+                tmp |= priv->cs_addr;
                 snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
@@ -70 +78 @@
 
         /* build I2C address + data byte */
-        addrdata = (ak->caddr << 6) | 0x20 | (addr & 0x1f);
+        addrdata = (priv->caddr << 6) | 0x20 | (addr & 0x1f);
         addrdata = (addrdata << 8) | data;
         for (idx = 15; idx >= 0; idx--) {
                 /* drop clock */
-                tmp &= ~ak->clk_mask;
+                tmp &= ~priv->clk_mask;
                 snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
                 /* set data */
                 if (addrdata & (1 << idx))
-                        tmp |= ak->data_mask;
+                        tmp |= priv->data_mask;
                 else
-                        tmp &= ~ak->data_mask;
+                        tmp &= ~priv->data_mask;
                 snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
                 /* raise clock */
-                tmp |= ak->clk_mask;
+                tmp |= priv->clk_mask;
                 snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
@@ -101 +109 @@
         }
         
-        if (ak->cs_mask == ak->cs_addr) {
-                if (ak->cif) {
+        if (priv->cs_mask == priv->cs_addr) {
+                if (priv->cif) {
                         /* assert a cs pulse to trigger */
-                        tmp &= ~ak->cs_mask;
+                        tmp &= ~priv->cs_mask;
                         snd_ice1712_gpio_write(ice, tmp);
                         udelay(1);
                 }
-                tmp |= ak->cs_mask; /* chip select high to trigger */
+                tmp |= priv->cs_mask; /* chip select high to trigger */
         } else {
-                tmp &= ~ak->cs_mask;
-                tmp |= ak->cs_none; /* deselect address */
+                tmp &= ~priv->cs_mask;
+                tmp |= priv->cs_none; /* deselect address */
         }
         snd_ice1712_gpio_write(ice, tmp);
         udelay(1);
-
-        if (ak->ops.stop)
-                ak->ops.stop(ak);
-        else
-                snd_ice1712_restore_gpio_status(ice);
 }
-
-/*
- * reset the AKM codecs
- * @state: 1 = reset codec, 0 = restore the registers
- *
- * assert the reset operation and restores the register values to the chips.
- */
-void snd_ice1712_akm4xxx_reset(akm4xxx_t *ak, int state)
-{
-        unsigned int chip;
-        unsigned char reg;
-        
-        switch (ak->type) {
-        case SND_AK4524:
-        case SND_AK4528:
-                for (chip = 0; chip < ak->num_dacs/2; chip++) {
-                        snd_ice1712_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03);
-                        if (state)
-                                continue;
-                        /* DAC volumes */
-                        for (reg = 0x04; reg < (ak->type == SND_AK4528 ? 0x06 : 0x08); reg++)
-                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->images[chip][reg]);
-                        if (ak->type == SND_AK4528)
-                                continue;
-                        /* IPGA */
-                        for (reg = 0x04; reg < 0x06; reg++)
-                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->ipga_gain[chip][reg-4]);
-                }
-                break;
-        case SND_AK4529:
-                /* FIXME: needed for ak4529? */
-                break;
-        case SND_AK4355:
-                snd_ice1712_akm4xxx_write(ak, 0, 0x01, state ? 0x02 : 0x01);
-                if (state)
-                        return;
-                for (reg = 0x00; reg < 0x0a; reg++)
-                        if (reg != 0x01)
-                                snd_ice1712_akm4xxx_write(ak, 0, reg, ak->images[0][reg]);
-                break;
-        case SND_AK4381:
-                for (chip = 0; chip < ak->num_dacs/2; chip++) {
-                        snd_ice1712_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f);
-                        if (state)
-                                continue;
-                        for (reg = 0x01; reg < 0x05; reg++)
-                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->images[chip][reg]);
-                }
-                break;
-        }
-}
-
-/*
- * initialize all the ak4xxx chips
- */
-static void __devinit snd_ice1712_akm4xxx_init_chip(akm4xxx_t *ak)
-{
-        static unsigned char inits_ak4524[] = {
-                0x00, 0x07, /* 0: all power up */
-                0x01, 0x00, /* 1: ADC/DAC reset */
-                0x02, 0x60, /* 2: 24bit I2S */
-                0x03, 0x19, /* 3: deemphasis off */
-                0x01, 0x03, /* 1: ADC/DAC enable */
-                0x04, 0x00, /* 4: ADC left muted */
-                0x05, 0x00, /* 5: ADC right muted */
-                0x04, 0x80, /* 4: ADC IPGA gain 0dB */
-                0x05, 0x80, /* 5: ADC IPGA gain 0dB */
-                0x06, 0x00, /* 6: DAC left muted */
-                0x07, 0x00, /* 7: DAC right muted */
-                0xff, 0xff
-        };
-        static unsigned char inits_ak4528[] = {
-                0x00, 0x07, /* 0: all power up */
-                0x01, 0x00, /* 1: ADC/DAC reset */
-                0x02, 0x60, /* 2: 24bit I2S */
-                0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */
-                0x01, 0x03, /* 1: ADC/DAC enable */
-                0x04, 0x00, /* 4: ADC left muted */
-                0x05, 0x00, /* 5: ADC right muted */
-                0xff, 0xff
-        };
-        static unsigned char inits_ak4529[] = {
-                0x09, 0x01, /* 9: ATS=0, RSTN=1 */
-                0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
-                0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
-                0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
-                0x02, 0xff, /* 2: LOUT1 muted */
-                0x03, 0xff, /* 3: ROUT1 muted */
-                0x04, 0xff, /* 4: LOUT2 muted */
-                0x05, 0xff, /* 5: ROUT2 muted */
-                0x06, 0xff, /* 6: LOUT3 muted */
-                0x07, 0xff, /* 7: ROUT3 muted */
-                0x0b, 0xff, /* B: LOUT4 muted */
-                0x0c, 0xff, /* C: ROUT4 muted */
-                0x08, 0x55, /* 8: deemphasis all off */
-                0xff, 0xff
-        };
-        static unsigned char inits_ak4355[] = {
-                0x01, 0x02, /* 1: reset and soft-mute */
-                0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect, disable DZF, sharp roll-off, RSTN#=0 */
-                // 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */
-                0x02, 0x2e,
-                0x03, 0x01, /* 3: de-emphasis off */
-                0x04, 0x00, /* 4: LOUT1 volume muted */
-                0x05, 0x00, /* 5: ROUT1 volume muted */
-                0x06, 0x00, /* 6: LOUT2 volume muted */
-                0x07, 0x00, /* 7: ROUT2 volume muted */
-                0x08, 0x00, /* 8: LOUT3 volume muted */
-                0x09, 0x00, /* 9: ROUT3 volume muted */
-                0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
-                0x01, 0x01, /* 1: un-reset, unmute */
-                0xff, 0xff
-        };
-        static unsigned char inits_ak4381[] = {
-                0x00, 0x0c, /* 0: mode3(i2s), disable auto-clock detect */
-                // 0x01, 0x02, /* 1: de-emphasis off, normal speed, sharp roll-off, DZF off */
-                0x01, 0x12,
-                0x02, 0x00, /* 2: DZF disabled */
-                0x03, 0x00, /* 3: LATT 0 */
-                0x04, 0x00, /* 4: RATT 0 */
-                0x00, 0x0f, /* 0: power-up, un-reset */
-                0xff, 0xff
-        };
-
-        int chip, num_chips;
-        unsigned char *ptr, reg, data, *inits;
-
-        switch (ak->type) {
-        case SND_AK4524:
-                inits = inits_ak4524;
-                num_chips = ak->num_dacs / 2;
-                break;
-        case SND_AK4528:
-                inits = inits_ak4528;
-                num_chips = ak->num_dacs / 2;
-                break;
-        case SND_AK4529:
-                inits = inits_ak4529;
-                num_chips = 1;
-                break;
-        case SND_AK4355:
-                inits = inits_ak4355;
-                num_chips = 1;
-                break;
-        case SND_AK4381:
-                inits = inits_ak4381;
-                num_chips = ak->num_dacs / 2;
-                break;
-        default:
-                snd_BUG();
-                return;
-        }
-
-        for (chip = 0; chip < num_chips; chip++) {
-                ptr = inits;
-                while (*ptr != 0xff) {
-                        reg = *ptr++;
-                        data = *ptr++;
-                        snd_ice1712_akm4xxx_write(ak, chip, reg, data);
-                }
-        }
-}
-
 
 /*
  * initialize the akm4xxx_t record with the template
  */
-void snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *temp, ice1712_t *ice)
+int __devinit snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *temp,
+                                       const struct snd_ak4xxx_private *_priv, ice1712_t *ice)
 {
+        struct snd_ak4xxx_private *priv;
+
+        priv = kmalloc(sizeof(*priv), GFP_KERNEL);
+        if (priv == NULL)
+                return -ENOMEM;
         *ak = *temp;
-        ak->chip = ice;
-        snd_ice1712_akm4xxx_init_chip(ak);
-}
-
-
-#define AK_GET_CHIP(val)                (((val) >> 8) & 0xff)
-#define AK_GET_ADDR(val)                ((val) & 0xff)
-#define AK_GET_SHIFT(val)               (((val) >> 16) & 0x7f)
-#define AK_GET_INVERT(val)              (((val) >> 23) & 1)
-#define AK_GET_MASK(val)                (((val) >> 24) & 0xff)
-#define AK_COMPOSE(chip,addr,shift,mask) (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24))
-#define AK_INVERT                       (1<<23)
-
-static int snd_ice1712_akm4xxx_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
-
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = mask;
+        ak->card = ice->card;
+        *priv = *_priv;
+        ak->private_value[0] = (unsigned long)priv;
+        ak->private_data[0] = ice;
+        if (ak->ops.lock == NULL)
+                ak->ops.lock = snd_ice1712_akm4xxx_lock;
+        if (ak->ops.unlock == NULL)
+                ak->ops.unlock = snd_ice1712_akm4xxx_unlock;
+        if (ak->ops.write == NULL)
+                ak->ops.write = snd_ice1712_akm4xxx_write;
+        snd_akm4xxx_init(ak);
         return 0;
 }
 
-static int snd_ice1712_akm4xxx_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+void __devexit snd_ice1712_akm4xxx_free(ice1712_t *ice)
 {
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        int invert = AK_GET_INVERT(kcontrol->private_value);
-        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
-        unsigned char val = ak->images[chip][addr];
-        
-        ucontrol->value.integer.value[0] = invert ? mask - val : val;
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        int invert = AK_GET_INVERT(kcontrol->private_value);
-        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
-        unsigned char nval = ucontrol->value.integer.value[0] % (mask+1);
-        int change;
-
-        if (invert)
-                nval = mask - nval;
-        change = ak->images[chip][addr] != nval;
-        if (change)
-                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
-        return change;
-}
-
-static int snd_ice1712_akm4xxx_ipga_gain_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = 36;
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_ipga_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        ucontrol->value.integer.value[0] = ak->ipga_gain[chip][addr-4] & 0x7f;
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_ipga_gain_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        unsigned char nval = (ucontrol->value.integer.value[0] % 37) | 0x80;
-        int change = ak->ipga_gain[chip][addr] != nval;
-        if (change)
-                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
-        return change;
-}
-
-static int snd_ice1712_akm4xxx_deemphasis_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
-{
-        static char *texts[4] = {
-                "44.1kHz", "Off", "48kHz", "32kHz",
-        };
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-        uinfo->count = 1;
-        uinfo->value.enumerated.items = 4;
-        if (uinfo->value.enumerated.item >= 4)
-                uinfo->value.enumerated.item = 3;
-        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_deemphasis_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        int shift = AK_GET_SHIFT(kcontrol->private_value);
-        ucontrol->value.enumerated.item[0] = (ak->images[chip][addr] >> shift) & 3;
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_deemphasis_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        int shift = AK_GET_SHIFT(kcontrol->private_value);
-        unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
-        int change;
-        
-        nval = (nval << shift) | (ak->images[chip][addr] & ~(3 << shift));
-        change = ak->images[chip][addr] != nval;
-        if (change)
-                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
-        return change;
+        unsigned int akidx;
+        if (ice->akm == NULL)
+                return;
+        for (akidx = 0; akidx < ice->akm_codecs; akidx++) {
+                akm4xxx_t *ak = &ice->akm[akidx];
+                if (ak->private_value[0])
+                        kfree((void *)ak->private_value[0]);
+        }
+        kfree(ice->akm);
 }
 
 /*
- * build AK4524 controls
+ * build AK4xxx controls
  */
-
 int __devinit snd_ice1712_akm4xxx_build_controls(ice1712_t *ice)
 {
-        unsigned int idx;
+        unsigned int akidx;
         int err;
-        unsigned int akidx;
 
         for (akidx = 0; akidx < ice->akm_codecs; akidx++) {
                 akm4xxx_t *ak = &ice->akm[akidx];
-                for (idx = 0; idx < ak->num_dacs; ++idx) {
-                        snd_kcontrol_t ctl;
-                        memset(&ctl, 0, sizeof(ctl));
-                        strcpy(ctl.id.name, "DAC Volume");
-                        ctl.id.index = idx + ak->idx_offset * 2;
-                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_akm4xxx_volume_info;
-                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_akm4xxx_volume_get;
-                        ctl.put = snd_ice1712_akm4xxx_volume_put;
-                        switch (ak->type) {
-                        case SND_AK4524:
-                                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127); /* register 6 & 7 */
-                                break;
-                        case SND_AK4528:
-                                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127); /* register 4 & 5 */
-                                break;
-                        case SND_AK4529: {
-                                int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb; /* registers 2-7 and b,c */
-                                ctl.private_value = AK_COMPOSE(0, val, 0, 255) | AK_INVERT;
-                                break;
-                        }
-                        case SND_AK4355:
-                                ctl.private_value = AK_COMPOSE(0, idx + 4, 0, 255); /* register 4-9, chip #0 only */
-                                break;
-                        case SND_AK4381:
-                                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255); /* register 3 & 4 */
-                                break;
-                        default:
-                                return -EINVAL;
-                        }
-                        ctl.private_data = ak;
-                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
-                                return err;
-                }
-                for (idx = 0; idx < ak->num_adcs && ak->type == SND_AK4524; ++idx) {
-                        snd_kcontrol_t ctl;
-                        memset(&ctl, 0, sizeof(ctl));
-                        strcpy(ctl.id.name, "ADC Volume");
-                        ctl.id.index = idx;
-                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_akm4xxx_volume_info;
-                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_akm4xxx_volume_get;
-                        ctl.put = snd_ice1712_akm4xxx_volume_put;
-                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127); /* register 4 & 5 */
-                        ctl.private_data = ak;
-                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
-                                return err;
-                        memset(&ctl, 0, sizeof(ctl));
-                        strcpy(ctl.id.name, "IPGA Analog Capture Volume");
-                        ctl.id.index = idx;
-                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_akm4xxx_ipga_gain_info;
-                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_akm4xxx_ipga_gain_get;
-                        ctl.put = snd_ice1712_akm4xxx_ipga_gain_put;
-                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 0); /* register 4 & 5 */
-                        ctl.private_data = ak;
-                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
-                                return err;
-                }
-                for (idx = 0; idx < ak->num_dacs/2; idx++) {
-                        snd_kcontrol_t ctl;
-                        memset(&ctl, 0, sizeof(ctl));
-                        strcpy(ctl.id.name, "Deemphasis");
-                        ctl.id.index = idx + ak->idx_offset;
-                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_akm4xxx_deemphasis_info;
-                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_akm4xxx_deemphasis_get;
-                        ctl.put = snd_ice1712_akm4xxx_deemphasis_put;
-                        switch (ak->type) {
-                        case SND_AK4524:
-                        case SND_AK4528:
-                                ctl.private_value = AK_COMPOSE(idx, 3, 0, 0); /* register 3 */
-                                break;
-                        case SND_AK4529: {
-                                int shift = idx == 3 ? 6 : (2 - idx) * 2;
-                                ctl.private_value = AK_COMPOSE(0, 8, shift, 0); /* register 8 with shift */
-                                break;
-                        }
-                        case SND_AK4355:
-                                ctl.private_value = AK_COMPOSE(idx, 3, 0, 0);
-                                break;
-                        case SND_AK4381:
-                                ctl.private_value = AK_COMPOSE(idx, 1, 1, 0);
-                                break;
-                        }
-                        ctl.private_data = ak;
-                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
-                                return err;
-                }
+                err = snd_akm4xxx_build_controls(ak);
+                if (err < 0)
+                        return err;
         }
         return 0;
 }
-
-

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/delta.c

@@ -233 +233 @@
  * AK4524 on Delta 44 and 66 to choose the chip mask
  */
-static int delta_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        snd_ice1712_save_gpio_status(ak->chip);
-        ak->cs_mask =
-        ak->cs_addr = chip == 0 ? ICE1712_DELTA_CODEC_CHIP_A :
-                                  ICE1712_DELTA_CODEC_CHIP_B;
-        return 0;
+static void delta_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        struct snd_ak4xxx_private *priv = (void *)ak->private_value[0];
+        ice1712_t *ice = ak->private_data[0];
+
+        snd_ice1712_save_gpio_status(ice);
+        priv->cs_mask =
+        priv->cs_addr = chip == 0 ? ICE1712_DELTA_CODEC_CHIP_A :
+                                    ICE1712_DELTA_CODEC_CHIP_B;
 }
 
@@ -245 +247 @@
  * AK4524 on Delta1010LT to choose the chip address
  */
-static int delta1010lt_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        snd_ice1712_save_gpio_status(ak->chip);
-        ak->cs_mask = ICE1712_DELTA_1010LT_CS;
-        ak->cs_addr = chip << 4;
-        return 0;
+static void delta1010lt_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        struct snd_ak4xxx_private *priv = (void *)ak->private_value[0];
+        ice1712_t *ice = ak->private_data[0];
+
+        snd_ice1712_save_gpio_status(ice);
+        priv->cs_mask = ICE1712_DELTA_1010LT_CS;
+        priv->cs_addr = chip << 4;
 }
 
@@ -259 +263 @@
 {
         unsigned char tmp, tmp2;
-        ice1712_t *ice = ak->chip;
+        ice1712_t *ice = ak->private_data[0];
 
         if (rate == 0)  /* no hint - S/PDIF input is master, simply return */
@@ -276 +280 @@
 
         /* do it again */
-        snd_ice1712_akm4xxx_reset(ak, 1);
+        snd_akm4xxx_reset(ak, 1);
         down(&ice->gpio_mutex);
         tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ~ICE1712_DELTA_DFS;
@@ -283 +287 @@
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
         up(&ice->gpio_mutex);
-        snd_ice1712_akm4xxx_reset(ak, 0);
+        snd_akm4xxx_reset(ak, 0);
 }
 
@@ -331 +335 @@
         .num_adcs = 2,
         .num_dacs = 2,
+        .ops = {
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_audiophile_priv __devinitdata = {
         .caddr = 2,
         .cif = 0,
@@ -340 +350 @@
         .add_flags = ICE1712_DELTA_AP_CS_DIGITAL,
         .mask_flags = 0,
-        .ops = {
-                .set_rate_val = delta_ak4524_set_rate_val
-        }
 };
 
@@ -349 +356 @@
         .num_adcs = 2,
         .num_dacs = 8,
+        .ops = {
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_delta410_priv __devinitdata = {
         .caddr = 0,
         .cif = 0,
@@ -358 +371 @@
         .add_flags = ICE1712_DELTA_AP_CS_DIGITAL,
         .mask_flags = 0,
-        .ops = {
-                .set_rate_val = delta_ak4524_set_rate_val
-        }
 };
 
@@ -367 +377 @@
         .num_adcs = 8,
         .num_dacs = 8,
+        .ops = {
+                .lock = delta1010lt_ak4524_lock,
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_delta1010lt_priv __devinitdata = {
         .caddr = 2,
         .cif = 0, /* the default level of the CIF pin from AK4524 */
@@ -376 +393 @@
         .add_flags = 0,
         .mask_flags = 0,
-        .ops = {
-                .start = delta1010lt_ak4524_start,
-                .set_rate_val = delta_ak4524_set_rate_val
-        }
 };
 
@@ -386 +399 @@
         .num_adcs = 4,
         .num_dacs = 4,
+        .ops = {
+                .lock = delta_ak4524_lock,
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_delta44_priv __devinitdata = {
         .caddr = 2,
         .cif = 0, /* the default level of the CIF pin from AK4524 */
@@ -395 +415 @@
         .add_flags = 0,
         .mask_flags = 0,
-        .ops = {
-                .start = delta_ak4524_start,
-                .set_rate_val = delta_ak4524_set_rate_val
-        }
 };
 
@@ -467 +483 @@
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_AUDIOPHILE:
-                snd_ice1712_akm4xxx_init(ak, &akm_audiophile, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_audiophile, &akm_audiophile_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA410:
-                snd_ice1712_akm4xxx_init(ak, &akm_delta410, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_delta410, &akm_delta410_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA1010LT:
-                snd_ice1712_akm4xxx_init(ak, &akm_delta1010lt, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_delta1010lt, &akm_delta1010lt_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA66:
         case ICE1712_SUBDEVICE_DELTA44:
-                snd_ice1712_akm4xxx_init(ak, &akm_delta44, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_delta44, &akm_delta44_priv, ice);
                 break;
         default:
@@ -484 +500 @@
         }
 
-        return 0;
+        return err;
 }
 
@@ -535 +551 @@
         case ICE1712_SUBDEVICE_DELTADIO2496:
         case ICE1712_SUBDEVICE_DELTA66:
-        case ICE1712_SUBDEVICE_AUDIOPHILE:
-        case ICE1712_SUBDEVICE_DELTA410:
-        case ICE1712_SUBDEVICE_DELTA1010LT:
                 err = snd_ice1712_spdif_build_controls(ice);
                 if (err < 0)

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ews.c

@@ -156 +156 @@
 
 /* start callback for EWS88MT, needs to select a certain chip mask */
-static int ews88mt_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        ice1712_t *ice = ak->chip;
+static void ews88mt_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
         unsigned char tmp;
         /* assert AK4524 CS */
         if (snd_ice1712_ews88mt_chip_select(ice, ~(1 << chip) & 0x0f) < 0)
-                return -EINVAL;
+                snd_printk(KERN_ERR "fatal error (ews88mt chip select)\n");
         snd_ice1712_save_gpio_status(ice);
         tmp = ICE1712_EWS88_SERIAL_DATA |
@@ -170 +170 @@
                           ice->gpio.direction | tmp);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
-        return 0;
 }
 
 /* stop callback for EWS88MT, needs to deselect chip mask */
-static void ews88mt_ak4524_stop(akm4xxx_t *ak)
-{
-        ice1712_t *ice = ak->chip;
+static void ews88mt_ak4524_unlock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
         snd_ice1712_restore_gpio_status(ice);
         udelay(1);
@@ -183 +182 @@
 
 /* start callback for EWX24/96 */
-static int ewx2496_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        ice1712_t *ice = ak->chip;
+static void ewx2496_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
         unsigned char tmp;
         snd_ice1712_save_gpio_status(ice);
@@ -195 +194 @@
                           ice->gpio.direction | tmp);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
-        return 0;
 }
 
 /* start callback for DMX 6fire */
-static int dmx6fire_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        ice1712_t *ice = ak->chip;
+static void dmx6fire_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        struct snd_ak4xxx_private *priv = (void *)ak->private_value[0];
+        ice1712_t *ice = ak->private_data[0];
         unsigned char tmp;
         snd_ice1712_save_gpio_status(ice);
-        tmp = ak->cs_mask = ak->cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
+        tmp = priv->cs_mask = priv->cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
         tmp |= ICE1712_6FIRE_SERIAL_DATA |
                 ICE1712_6FIRE_SERIAL_CLOCK |
@@ -211 +210 @@
                           ice->gpio.direction | tmp);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
-        return 0;
-}
-
+}
 
 /*
@@ -329 +326 @@
         .num_dacs = 8,
         .type = SND_AK4524,
+        .ops = {
+                .lock = ews88mt_ak4524_lock,
+                .unlock = ews88mt_ak4524_unlock
+        }
+};
+
+static struct snd_ak4xxx_private akm_ews88mt_priv __devinitdata = {
         .caddr = 2,
         .cif = 1, /* CIF high */
@@ -338 +342 @@
         .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
         .mask_flags = 0,
-        .ops = {
-                .start = ews88mt_ak4524_start,
-                .stop = ews88mt_ak4524_stop
-        }
 };
 
@@ -348 +348 @@
         .num_dacs = 2,
         .type = SND_AK4524,
+        .ops = {
+                .lock = ewx2496_ak4524_lock
+        }
+};
+
+static struct snd_ak4xxx_private akm_ewx2496_priv __devinitdata = {
         .caddr = 2,
         .cif = 1, /* CIF high */
@@ -357 +363 @@
         .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
         .mask_flags = 0,
-        .ops = {
-                .start = ewx2496_ak4524_start
-        }
 };
 
@@ -366 +369 @@
         .num_dacs = 6,
         .type = SND_AK4524,
+        .ops = {
+                .lock = dmx6fire_ak4524_lock
+        }
+};
+
+static struct snd_ak4xxx_private akm_6fire_priv __devinitdata = {
         .caddr = 2,
         .cif = 1, /* CIF high */
@@ -375 +384 @@
         .add_flags = ICE1712_6FIRE_RW, /* set rw bit high */
         .mask_flags = 0,
-        .ops = {
-                .start = dmx6fire_ak4524_start
-        }
-};
-
+};
 
 /*
@@ -480 +485 @@
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88MT_NEW:
-                snd_ice1712_akm4xxx_init(ak, &akm_ews88mt, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_ews88mt, &akm_ews88mt_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_EWX2496:
-                snd_ice1712_akm4xxx_init(ak, &akm_ewx2496, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_ewx2496, &akm_ewx2496_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DMX6FIRE:
-                snd_ice1712_akm4xxx_init(ak, &akm_6fire, ice);
-                break;
-        }
-
-        return 0;
+                err = snd_ice1712_akm4xxx_init(ak, &akm_6fire, &akm_6fire_priv, ice);
+                break;
+        default:
+                err = 0;
+        }
+
+        return err;
 }
 
@@ -603 +610 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int channel = kcontrol->id.index;
+        int channel = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned char data;
 
@@ -622 +629 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int channel = kcontrol->id.index;
+        int channel = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned char data, ndata;
 
@@ -646 +653 @@
         .get = snd_ice1712_ews88mt_input_sense_get,
         .put = snd_ice1712_ews88mt_input_sense_put,
+        .count = 8,
 };
 
@@ -895 +903 @@
         unsigned int idx;
         int err;
-        snd_kcontrol_t *kctl;
         
-        /* all terratec cards have spdif */
-        err = snd_ice1712_spdif_build_controls(ice);
-        if (err < 0)
-                return err;
+        /* all terratec cards have spdif, but cs8427 module builds it's own controls */
+        if (ice->cs8427 == NULL) {
+                err = snd_ice1712_spdif_build_controls(ice);
+                if (err < 0)
+                        return err;
+        }
 
         /* ak4524 controls */
@@ -925 +934 @@
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88MT_NEW:
-                for (idx = 0; idx < 8; idx++) {
-                        kctl = snd_ctl_new1(&snd_ice1712_ews88mt_input_sense, ice);
-                        kctl->id.index = idx;
-                        err = snd_ctl_add(ice->card, kctl);
-                        if (err < 0)
-                                return err;
-                }
+                err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88mt_input_sense, ice));
+                if (err < 0)
+                        return err;
                 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88mt_output_sense, ice));
                 if (err < 0)

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1712.c

@@ -119 +119 @@
 
 /*
+ *  AK4xxx stuff
+ */
+
+#include "ak4xxx.c"
+
+/*
  *  Basic I/O
  */
@@ -399 +405 @@
  */
 
-static void snd_ice1712_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return);
+static irqreturn_t snd_ice1712_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return IRQ_NONE);
         unsigned char status;
+        int handled = 0;
 
         while (1) {
@@ -408 +415 @@
                 if (status == 0)
                         break;
+                handled = 1;
                 if (status & ICE1712_IRQ_MPU1) {
                         if (ice->rmidi[0])
@@ -463 +471 @@
                 }
         }
+        return IRQ_RETVAL(handled);
 }
 
@@ -963 +972 @@
                 unsigned int what = 0;
                 unsigned int old;
-                snd_pcm_substream_t *s = substream;
-
-                do {
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
+
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == ice->playback_pro_substream) {
                                 what |= ICE1712_PLAYBACK_START;
@@ -973 +984 @@
                                 snd_pcm_trigger_done(s, substream);
                         }
-                        s = s->link_next;
-                } while (s != substream);
+                }
                 spin_lock(&ice->reg_lock);
                 old = inl(ICEMT(ice, PLAYBACK_CONTROL));
@@ -1297 +1307 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int index = kcontrol->private_value;
+        int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value;
         
         spin_lock_irq(&ice->reg_lock);
@@ -1309 +1319 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int index = kcontrol->private_value;
+        int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value;
         unsigned int nval, change;
 
@@ -1335 +1345 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int index = kcontrol->private_value;
+        int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value;
         
         spin_lock_irq(&ice->reg_lock);
@@ -1347 +1357 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int index = kcontrol->private_value;
+        int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value;
         unsigned int nval, change;
 
@@ -1362 +1372 @@
 
 
+static snd_kcontrol_new_t snd_ice1712_multi_ctrls[] __devinitdata = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Multi Playback Switch",
+                .info = snd_ice1712_pro_mixer_switch_info,
+                .get = snd_ice1712_pro_mixer_switch_get,
+                .put = snd_ice1712_pro_mixer_switch_put,
+                .private_value = 0,
+                .count = 10,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Multi Playback Volume",
+                .info = snd_ice1712_pro_mixer_volume_info,
+                .get = snd_ice1712_pro_mixer_volume_get,
+                .put = snd_ice1712_pro_mixer_volume_put,
+                .private_value = 0,
+                .count = 10,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Multi Capture Switch",
+                .info = snd_ice1712_pro_mixer_switch_info,
+                .get = snd_ice1712_pro_mixer_switch_get,
+                .put = snd_ice1712_pro_mixer_switch_put,
+                .private_value = 10,
+                .count = 10,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Multi Capture Volume",
+                .info = snd_ice1712_pro_mixer_volume_info,
+                .get = snd_ice1712_pro_mixer_volume_get,
+                .put = snd_ice1712_pro_mixer_volume_put,
+                .private_value = 10,
+                .count = 10,
+        },
+};
+
 static int __devinit snd_ice1712_build_pro_mixer(ice1712_t *ice)
 {
         snd_card_t * card = ice->card;
-        snd_kcontrol_t ctl;
-        int idx, err;
-
-        /* PCM playback */
-        for (idx = 0; idx < 10; idx++) {
-                memset(&ctl, 0, sizeof(ctl));
-                strcpy(ctl.id.name, "Multi Playback Switch");
-                ctl.id.index = idx;
-                ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                ctl.info = snd_ice1712_pro_mixer_switch_info;
-                ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                ctl.get = snd_ice1712_pro_mixer_switch_get;
-                ctl.put = snd_ice1712_pro_mixer_switch_put;
-                ctl.private_value = idx;
-                ctl.private_data = ice;
-                if ((err = snd_ctl_add(card, snd_ctl_new(&ctl))) < 0)
-                        return err;
-                memset(&ctl, 0, sizeof(ctl));
-                strcpy(ctl.id.name, "Multi Playback Volume");
-                ctl.id.index = idx;
-                ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                ctl.info = snd_ice1712_pro_mixer_volume_info;
-                ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                ctl.get = snd_ice1712_pro_mixer_volume_get;
-                ctl.put = snd_ice1712_pro_mixer_volume_put;
-                ctl.private_value = idx;
-                ctl.private_data = ice;
-                if ((err = snd_ctl_add(card, snd_ctl_new(&ctl))) < 0)
-                        return err;
-        }
-
-        /* PCM capture */
-        for (idx = 0; idx < 10; idx++) {
-                memset(&ctl, 0, sizeof(ctl));
-                strcpy(ctl.id.name, "Multi Capture Switch");
-                ctl.id.index = idx;
-                ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                ctl.info = snd_ice1712_pro_mixer_switch_info;
-                ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                ctl.get = snd_ice1712_pro_mixer_switch_get;
-                ctl.put = snd_ice1712_pro_mixer_switch_put;
-                ctl.private_value = idx + 10;
-                ctl.private_data = ice;
-                if ((err = snd_ctl_add(card, snd_ctl_new(&ctl))) < 0)
-                        return err;
-                memset(&ctl, 0, sizeof(ctl));
-                strcpy(ctl.id.name, "Multi Capture Volume");
-                ctl.id.index = idx;
-                ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                ctl.info = snd_ice1712_pro_mixer_volume_info;
-                ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                ctl.get = snd_ice1712_pro_mixer_volume_get;
-                ctl.put = snd_ice1712_pro_mixer_volume_put;
-                ctl.private_value = idx + 10;
-                ctl.private_data = ice;
-                if ((err = snd_ctl_add(card, snd_ctl_new(&ctl))) < 0)
+        unsigned int idx;
+        int err;
+
+        /* multi-channel mixer */
+        for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_multi_ctrls); idx++) {
+                err = snd_ctl_add(card, snd_ctl_new1(&snd_ice1712_multi_ctrls[idx], ice));
+                if (err < 0)
                         return err;
         }
@@ -1909 +1909 @@
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = kcontrol->id.index < 2 ? 12 : 11;
+        uinfo->value.enumerated.items = snd_ctl_get_ioffidx(kcontrol, &uinfo->id) < 2 ? 12 : 11;
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
@@ -1919 +1919 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned int val, cval;
 
@@ -1945 +1945 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         int change, shift;
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned int val, old_val, nval;
         
@@ -1993 +1993 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned int val, cval;
         val = inw(ICEMT(ice, ROUTE_SPDOUT));
@@ -2013 +2013 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         int change, shift;
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned int val, old_val, nval;
         
@@ -2061 +2061 @@
         .get = snd_ice1712_pro_route_spdif_get,
         .put = snd_ice1712_pro_route_spdif_put,
+        .count = 2,
 };
 
@@ -2247 +2248 @@
 static int __devinit snd_ice1712_build_controls(ice1712_t *ice)
 {
-        unsigned int idx;
-        snd_kcontrol_t *kctl;
         int err;
 
@@ -2265 +2264 @@
                 return err;
 
-        for (idx = 0; idx < ice->num_total_dacs; idx++) {
-                kctl = snd_ctl_new1(&snd_ice1712_mixer_pro_analog_route, ice);
-                if (kctl == NULL)
-                        return -ENOMEM;
-                kctl->id.index = idx;
-                err = snd_ctl_add(ice->card, kctl);
+        if (ice->num_total_dacs > 0) {
+                snd_kcontrol_new_t tmp = snd_ice1712_mixer_pro_analog_route;
+                tmp.count = ice->num_total_dacs;
+                err = snd_ctl_add(ice->card, snd_ctl_new1(&tmp, ice));
                 if (err < 0)
                         return err;
         }
 
-        for (idx = 0; idx < 2; idx++) {
-                kctl = snd_ctl_new1(&snd_ice1712_mixer_pro_spdif_route, ice);
-                if (kctl == NULL)
-                        return -ENOMEM;
-                kctl->id.index = idx;
-                err = snd_ctl_add(ice->card, kctl);
-                if (err < 0)
-                        return err;
-        }
+        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_pro_spdif_route, ice));
+        if (err < 0)
+                return err;
 
         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_pro_volume_rate, ice));
@@ -2324 +2315 @@
                 kfree_nocheck(ice->res_profi_port);
         }
-        if (ice->akm)
-                kfree(ice->akm);
+        snd_ice1712_akm4xxx_free(ice);
         snd_magic_kfree(ice);
         return 0;

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1712.h

@@ -27 +27 @@
 #include <sound/rawmidi.h>
 #include <sound/i2c.h>
+#include <sound/ak4xxx-adda.h>
 #include <sound/pcm.h>
 
@@ -215 +216 @@
 
 typedef struct _snd_ice1712 ice1712_t;
-typedef struct snd_ak4xxx akm4xxx_t;
 
 typedef struct {
@@ -255 +255 @@
 
 
-struct snd_ak4xxx {
-        unsigned int num_adcs;          /* AK4524 or AK4528 ADCs */
-        unsigned int num_dacs;          /* AK4524 or AK4528 DACs */
-        unsigned char images[4][16];    /* saved register image */
-        unsigned char ipga_gain[4][2];  /* saved register image for IPGA (AK4528) */
-        ice1712_t *chip;
-        /* template should fill the following fields */
-        unsigned int idx_offset;        /* control index offset */
-        enum {
-                SND_AK4524, SND_AK4528, SND_AK4529, SND_AK4355, SND_AK4381
-        } type;
+struct snd_ak4xxx_private {
         unsigned int cif: 1;            /* CIF mode */
         unsigned char caddr;            /* C0 and C1 bits */
@@ -276 +266 @@
         unsigned int mask_flags;        /* total mask bits */
         struct snd_akm4xxx_ops {
-                int (*start)(akm4xxx_t *ak, int chip);
-                void (*stop)(akm4xxx_t *ak);
                 void (*set_rate_val)(akm4xxx_t *ak, unsigned int rate);
         } ops;
@@ -440 +428 @@
 int snd_ice1712_spdif_build_controls(ice1712_t *ice);
 
-void snd_ice1712_akm4xxx_write(akm4xxx_t *ice, int chip, unsigned char addr, unsigned char data);
-void snd_ice1712_akm4xxx_reset(akm4xxx_t *ice, int state);
-void snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *template, ice1712_t *ice);
+int snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *template, const struct snd_ak4xxx_private *priv, ice1712_t *ice);
+void snd_ice1712_akm4xxx_free(ice1712_t *ice);
 int snd_ice1712_akm4xxx_build_controls(ice1712_t *ice);
 

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1724.c

@@ -89 +89 @@
 
 /*
+ *  AK4xxx stuff
+ */
+
+#include "ak4xxx.c"
+
+/*
  *  Basic I/O
  */
@@ -195 +201 @@
  */
 
-static void snd_vt1724_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return);
+static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return IRQ_NONE);
         unsigned char status;
+        int handled = 0;
 
         while (1) {
@@ -204 +211 @@
                 if (status == 0)
                         break;
-                
+
+                handled = 1;            
                 /*  these should probably be separated at some point, 
                         but as we don't currently have MPU support on the board I will leave it */
@@ -243 +251 @@
                 }
         }
+        return IRQ_RETVAL(handled);
 }
 
@@ -282 +291 @@
         unsigned int what;
         unsigned int old;
+        struct list_head *pos;
         snd_pcm_substream_t *s;
 
@@ -288 +298 @@
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                 what = 0;
-                s = substream;
-                do {
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == ice->playback_pro_substream)
                                 what |= VT1724_PDMA0_PAUSE;
@@ -298 +308 @@
                         else if (s == ice->capture_con_substream)
                                 what |= VT1724_RDMA1_PAUSE;
-                        s = s->link_next;
-                } while (s != substream);
+                }
                 spin_lock(&ice->reg_lock);
                 old = inl(ICEMT1724(ice, DMA_PAUSE));
@@ -314 +323 @@
                 what = 0;
                 s = substream;
-                do {
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == ice->playback_pro_substream) {
                                 what |= VT1724_PDMA0_START;
@@ -328 +338 @@
                                 snd_pcm_trigger_done(s, substream);
                         }
-                        s = s->link_next;
-                } while (s != substream);
+                }
                 spin_lock(&ice->reg_lock);
                 old = inl(ICEMT1724(ice, DMA_CONTROL));
@@ -1295 +1304 @@
 }
 
-static snd_kcontrol_new_t snd_vt1724_pro_internal_clock = __devinitdata {
+static snd_kcontrol_new_t snd_vt1724_pro_internal_clock __devinitdata = {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         .name = "Multi Track Internal Clock",
@@ -1450 +1459 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         ucontrol->value.enumerated.item[0] = get_route_val(ice, analog_route_shift(idx));
         return 0;
@@ -1458 +1467 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         return put_route_val(ice, ucontrol->value.enumerated.item[0],
                              analog_route_shift(idx));
@@ -1466 +1475 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         ucontrol->value.enumerated.item[0] = get_route_val(ice, digital_route_shift(idx));
         return 0;
@@ -1474 +1483 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         return put_route_val(ice, ucontrol->value.enumerated.item[0],
                              digital_route_shift(idx));
@@ -1493 +1502 @@
         .get = snd_vt1724_pro_route_spdif_get,
         .put = snd_vt1724_pro_route_spdif_put,
+        .count = 2,
 };
 
@@ -1603 +1613 @@
 {
         int err;
-        unsigned int idx;
         snd_kcontrol_t *kctl;
 
         snd_assert(ice->pcm != NULL, return -EIO);
 
-        for (idx = 0; idx < 2; idx++) {
-                kctl = snd_ctl_new1(&snd_vt1724_mixer_pro_spdif_route, ice);
-                if (kctl == NULL)
-                        return -ENOMEM;
-                kctl->id.index = idx;
-                err = snd_ctl_add(ice->card, kctl);
-                if (err < 0)
-                        return err;
-        }
+        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_mixer_pro_spdif_route, ice));
+        if (err < 0)
+                return err;
 
         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_spdif_switch, ice));
@@ -1647 +1650 @@
 static int __devinit snd_vt1724_build_controls(ice1712_t *ice)
 {
-        unsigned int idx;
-        snd_kcontrol_t *kctl;
         int err;
 
@@ -1665 +1666 @@
                 return err;
 
-        for (idx = 0; idx < ice->num_total_dacs; idx++) {
-                kctl = snd_ctl_new1(&snd_vt1724_mixer_pro_analog_route, ice);
-                if (kctl == NULL)
-                        return -ENOMEM;
-                kctl->id.index = idx;
-                err = snd_ctl_add(ice->card, kctl);
+        if (ice->num_total_dacs > 0) {
+                snd_kcontrol_new_t tmp = snd_vt1724_mixer_pro_analog_route;
+                tmp.count = ice->num_total_dacs;
+                err = snd_ctl_add(ice->card, snd_ctl_new1(&tmp, ice));
                 if (err < 0)
                         return err;
@@ -1703 +1702 @@
                 kfree_nocheck(ice->res_profi_port);
         }
-        if (ice->akm)
-                kfree(ice->akm);
+        snd_ice1712_akm4xxx_free(ice);
         snd_magic_kfree(ice);
         return 0;

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/makefile.os2

@@ -13 +13 @@
 #
 #===================================================================
-FILE1    = ak4524.obj delta.obj ews.obj hoontech.obj ice1712.obj
+FILE1    = ak4xxx.obj delta.obj ews.obj hoontech.obj ice1712.obj
 FILE2    = ice1724.obj revo.obj
 FILE3    = 

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/revo.c

@@ -66 +66 @@
 
         /* reset DFS */
-        snd_ice1712_akm4xxx_reset(ak, 1);
+        snd_akm4xxx_reset(ak, 1);
         tmp = ak->images[0][reg];
         tmp &= ~(0x03 << shift);
         tmp |= dfs << shift;
-        snd_ice1712_akm4xxx_write(ak, 0, reg, tmp);
-        snd_ice1712_akm4xxx_reset(ak, 0);
+        snd_akm4xxx_write(ak, 0, reg, tmp);
+        snd_akm4xxx_reset(ak, 0);
 }
 
@@ -81 +81 @@
         .type = SND_AK4381,
         .num_dacs = 2,
+        .ops = {
+                .set_rate_val = revo_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_revo_front_priv __devinitdata = {
         .caddr = 1,
         .cif = 0,
@@ -90 +96 @@
         .add_flags = VT1724_REVO_CCLK, /* high at init */
         .mask_flags = 0,
-        .ops = {
-                .set_rate_val = revo_set_rate_val
-        }
 };
 
@@ -99 +102 @@
         .idx_offset = 1,
         .num_dacs = 6,
+        .ops = {
+                .set_rate_val = revo_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_revo_surround_priv __devinitdata = {
         .caddr = 3,
         .cif = 0,
@@ -108 +117 @@
         .add_flags = VT1724_REVO_CCLK, /* high at init */
         .mask_flags = 0,
-        .ops = {
-                .set_rate_val = revo_set_rate_val
-        }
 };
 
@@ -134 +140 @@
         switch (ice->eeprom.subvendor) {
         case VT1724_SUBDEVICE_REVOLUTION71:
-                snd_ice1712_akm4xxx_init(ak, &akm_revo_front, ice);
-                snd_ice1712_akm4xxx_init(ak + 1, &akm_revo_surround, ice);
+                snd_ice1712_akm4xxx_init(ak, &akm_revo_front, &akm_revo_front_priv, ice);
+                snd_ice1712_akm4xxx_init(ak + 1, &akm_revo_surround, &akm_revo_surround_priv, ice);
                 /* unmute all codecs */
                 snd_ice1712_gpio_write_bits(ice, VT1724_REVO_MUTE, VT1724_REVO_MUTE);

GPL/branches/alsa-resync1/alsa-kernel/pci/korg1212/korg1212.c

@@ -150 +150 @@
 #define MAILBOX2_OFFSET      0x48       // location of mailbox 2 relative to base address
 #define MAILBOX3_OFFSET      0x4c       // location of mailbox 3 relative to base address
-#define OUT_DOORBELL_OFFSET  0x60       // location of PCI to local doorbell "
-#define IN_DOORBELL_OFFSET   0x64       // location of local to PCI doorbell "
-#define STATUS_REG_OFFSET    0x68       // location of interrupt control/status register "
+#define OUT_DOORBELL_OFFSET  0x60       // location of PCI to local doorbell
+#define IN_DOORBELL_OFFSET   0x64       // location of local to PCI doorbell
+#define STATUS_REG_OFFSET    0x68       // location of interrupt control/status register
 #define PCI_CONTROL_OFFSET   0x6c       // location of the EEPROM, PCI, User I/O, init control
                                         //    register
@@ -330 +330 @@
 
         spinlock_t    lock;
+        struct semaphore open_mutex;
+
+        struct timer_list timer;        /* timer callback for checking ack of stop request */
+        int stop_pending_cnt;           /* counter for stop pending check */
 
         wait_queue_head_t wait;
@@ -603 +607 @@
 }
 
-static void snd_korg1212_WaitForCardStopAck(korg1212_t *korg1212)
-{
-        u32 endtime = jiffies + 2 * HZ;
-
-#if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck.in [%s] %lu %lu\n", stateName[korg1212->cardState], jiffies, korg1212->inIRQ);
-#endif
-
-        if (korg1212->inIRQ)
-                return;
-
-        do {
+/* spinlock already held */
+static void snd_korg1212_SendStop(korg1212_t *korg1212)
+{
+        if (! korg1212->stop_pending_cnt) {
+                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
+                /* program the timer */
+                korg1212->stop_pending_cnt = HZ;
+                korg1212->timer.expires = jiffies + 1;
+                add_timer(&korg1212->timer);
+        }
+}
+
+static void snd_korg1212_SendStopAndWait(korg1212_t *korg1212)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&korg1212->lock, flags);
+        snd_korg1212_SendStop(korg1212);
+        spin_unlock_irqrestore(&korg1212->lock, flags);
+        sleep_on_timeout(&korg1212->wait, (HZ * 3) / 2);
+}
+
+/* timer callback for checking the ack of stop request */
+static void snd_korg1212_timer_func(unsigned long data)
+{
+        korg1212_t *korg1212 = snd_magic_cast(korg1212_t, (void*)data, return);
+        
+        spin_lock(&korg1212->lock);
                 if (readl(&korg1212->sharedBufferPtr->cardCommand) == 0) {
-#if K1212_DEBUG_LEVEL > 0
-                        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck.out [%s] %lu %lu\n", stateName[korg1212->cardState], jiffies, korg1212->inIRQ);
-#endif
-                        return;
+                /* ack'ed */
+                korg1212->stop_pending_cnt = 0;
+                wake_up(&korg1212->wait);
+#if K1212_DEBUG_LEVEL > 1
+                K1212_DEBUG_PRINTK("K1212_DEBUG: Stop ack'ed [%s]\n", stateName[korg1212->cardState]);
+#endif
+        } else {
+                if (--korg1212->stop_pending_cnt > 0) {
+                        /* reprogram timer */
+                        korg1212->timer.expires = jiffies + 1;
+                        add_timer(&korg1212->timer);
+                } else {
+                        snd_printd("korg1212_timer_func timeout\n");
+        writel(0, &korg1212->sharedBufferPtr->cardCommand);
+                        wake_up(&korg1212->wait);
+#if K1212_DEBUG_LEVEL > 0
+                        K1212_DEBUG_PRINTK("K1212_DEBUG: Stop timeout [%s]\n", stateName[korg1212->cardState]);
+#endif
                 }
-                if (!korg1212->inIRQ)
-                        schedule();
-        } while (time_before(jiffies, endtime));
-
-#if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck.out TO [%s] %lu %lu\n", stateName[korg1212->cardState], jiffies, korg1212->inIRQ);
-#endif
-        writel(0, &korg1212->sharedBufferPtr->cardCommand);
+        }
+        spin_unlock(&korg1212->lock);
 }
 
 static void snd_korg1212_TurnOnIdleMonitor(korg1212_t *korg1212)
 {
+        unsigned long flags;
+
         udelay(INTERCOMMAND_DELAY);
+        spin_lock_irqsave(&korg1212->lock, flags);
         korg1212->idleMonitorOn = 1;
         rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
                         K1212_MODE_MonitorOn, 0, 0, 0);
+        spin_unlock_irqrestore(&korg1212->lock, flags);
 }
 
@@ -642 +673 @@
 {
         if (korg1212->idleMonitorOn) {
-                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
-                snd_korg1212_WaitForCardStopAck(korg1212);
+                snd_korg1212_SendStopAndWait(korg1212);
                 korg1212->idleMonitorOn = 0;
         }
 }
 
-static void snd_korg1212_setCardState(korg1212_t * korg1212, CardState csState)
-{
-        switch (csState) {
-                case K1212_STATE_READY:
-                        snd_korg1212_TurnOnIdleMonitor(korg1212);
-                        break;
-
-                case K1212_STATE_OPEN:
-                        snd_korg1212_TurnOffIdleMonitor(korg1212);
-                        break;
-
-                default:
-                        break;
-        }
-
+static inline void snd_korg1212_setCardState(korg1212_t * korg1212, CardState csState)
+{
         korg1212->cardState = csState;
 }
@@ -671 +688 @@
         K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n", stateName[korg1212->cardState], korg1212->opencnt);
 #endif
-        if (korg1212->opencnt++ == 0)
+        down(&korg1212->open_mutex);
+        if (korg1212->opencnt++ == 0) {
+                snd_korg1212_TurnOffIdleMonitor(korg1212);
         snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
+        }
+
+        up(&korg1212->open_mutex);
         return 1;
 }
@@ -682 +704 @@
 #endif
 
-        if (--(korg1212->opencnt))
+        down(&korg1212->open_mutex);
+        if (--(korg1212->opencnt)) {
+                up(&korg1212->open_mutex);
                 return 0;
+        }
 
         if (korg1212->cardState == K1212_STATE_SETUP) {
@@ -692 +717 @@
 #endif
 
-                if (rc != K1212_CMDRET_Success)
+                if (rc != K1212_CMDRET_Success) {
+                        up(&korg1212->open_mutex);
                         return 0;
+                }
         } else if (korg1212->cardState > K1212_STATE_SETUP) {
-                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
-                snd_korg1212_WaitForCardStopAck(korg1212);
-        }
-
-        if (korg1212->cardState > K1212_STATE_READY)
+                snd_korg1212_SendStopAndWait(korg1212);
+        }
+
+        if (korg1212->cardState > K1212_STATE_READY) {
+                snd_korg1212_TurnOnIdleMonitor(korg1212);
                 snd_korg1212_setCardState(korg1212, K1212_STATE_READY);
-
+        }
+
+        up(&korg1212->open_mutex);
         return 0;
 }
 
+/* spinlock already held */
 static int snd_korg1212_SetupForPlay(korg1212_t * korg1212)
 {
@@ -727 +757 @@
 }
 
+/* spinlock already held */
 static int snd_korg1212_TriggerPlay(korg1212_t * korg1212)
 {
@@ -749 +780 @@
 }
 
+/* spinlock already held */
 static int snd_korg1212_StopPlay(korg1212_t * korg1212)
 {
@@ -760 +792 @@
         korg1212->setcnt = 0;
 
-        if (korg1212->cardState != K1212_STATE_ERRORSTOP) {
-                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
-                snd_korg1212_WaitForCardStopAck(korg1212);
-        }
+        if (korg1212->cardState != K1212_STATE_ERRORSTOP)
+                snd_korg1212_SendStop(korg1212);
+
         snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
         return 0;
@@ -790 +821 @@
                                 return 0;
                         } else {
-                                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
-                                snd_korg1212_WaitForCardStopAck(korg1212);
+                                snd_korg1212_SendStopAndWait(korg1212);
                                 snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
                         }
@@ -885 +915 @@
                                    //  the card's eeprom control register.
         u16       count;
+        unsigned long flags;
 
 #if K1212_DEBUG_LEVEL > 0
@@ -901 +932 @@
         // ----------------------------------------------------------------------------
         if (korg1212->cardState == K1212_STATE_MONITOR || korg1212->idleMonitorOn) {
-                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
                 monModeSet = 1;
-                snd_korg1212_WaitForCardStopAck(korg1212);
+                snd_korg1212_SendStopAndWait(korg1212);
         } else
                 monModeSet = 0;
+
+        spin_lock_irqsave(&korg1212->lock, flags);
 
         // ----------------------------------------------------------------------------
@@ -1017 +1049 @@
         }
 
+        spin_unlock_irqrestore(&korg1212->lock, flags);
+
         return 1;
 }
@@ -1090 +1124 @@
 #endif
 
+        snd_korg1212_TurnOnIdleMonitor(korg1212);
         snd_korg1212_setCardState(korg1212, K1212_STATE_READY);
 
@@ -1096 +1131 @@
 #endif
 
-        wake_up_interruptible(&korg1212->wait);
-}
-
-static void snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+        snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_COMPLETE);
+}
+
+static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         u32 doorbellValue;
-        korg1212_t *korg1212 = snd_magic_cast(korg1212_t, dev_id, return);
+        korg1212_t *korg1212 = snd_magic_cast(korg1212_t, dev_id, return IRQ_NONE);
 
         if(irq != korg1212->irq)
-                return;
+                return IRQ_NONE;
 
         doorbellValue = readl(korg1212->inDoorbellPtr);
 
         if (!doorbellValue)
-                return;
+                return IRQ_HANDLED;
+
+        spin_lock(&korg1212->lock);
 
         writel(doorbellValue, korg1212->inDoorbellPtr);
@@ -1124 +1161 @@
                         K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DNLD count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]);
 #endif
-                        if (korg1212->cardState == K1212_STATE_DSP_IN_PROCESS) {
-                                        snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_COMPLETE);
-                                        snd_korg1212_OnDSPDownloadComplete(korg1212);
-                        }
+                        if (korg1212->cardState == K1212_STATE_DSP_IN_PROCESS)
+                                wake_up(&korg1212->wait);
                         break;
 
@@ -1167 +1202 @@
 
                                 if (korg1212->capture_substream) {
+                                        spin_unlock(&korg1212->lock);
                                         snd_pcm_period_elapsed(korg1212->capture_substream);
+                                        spin_lock(&korg1212->lock);
                                 }
 
                                 if (korg1212->playback_substream) {
+                                        spin_unlock(&korg1212->lock);
                                         snd_pcm_period_elapsed(korg1212->playback_substream);
+                                        spin_lock(&korg1212->lock);
                                 }
                         }
@@ -1178 +1217 @@
 
         korg1212->inIRQ--;
+
+        spin_unlock(&korg1212->lock);
+        return IRQ_HANDLED;
 }
 
@@ -1206 +1248 @@
 #endif
 
-        interruptible_sleep_on_timeout(&korg1212->wait, HZ * 4);
+        if (! sleep_on_timeout(&korg1212->wait, HZ * 4))
+                return -EBUSY; /* timeout */
+
+        snd_korg1212_OnDSPDownloadComplete(korg1212);
 
         return 0;
@@ -1364 +1409 @@
         snd_pcm_set_sync(substream);    // ???
 
-        spin_lock_irqsave(&korg1212->lock, flags);
-
         snd_korg1212_OpenCard(korg1212);
 
+        runtime->hw = snd_korg1212_playback_info;
         runtime->dma_area = (char *) korg1212->playDataBufsPtr;
         runtime->dma_bytes = K1212_BUF_SIZE;
+
+        spin_lock_irqsave(&korg1212->lock, flags);
 
         korg1212->playback_substream = substream;
@@ -1394 +1440 @@
         snd_pcm_set_sync(substream);    // ???
 
-        spin_lock_irqsave(&korg1212->lock, flags);
-
         snd_korg1212_OpenCard(korg1212);
 
@@ -1402 +1446 @@
         runtime->dma_bytes = K1212_BUF_SIZE;
 
+        spin_lock_irqsave(&korg1212->lock, flags);
+
         korg1212->capture_substream = substream;
         korg1212->periodsize = K1212_PERIODS;
@@ -1428 +1474 @@
         korg1212->periodsize = 0;
 
-        snd_korg1212_CloseCard(korg1212);
-
         spin_unlock_irqrestore(&korg1212->lock, flags);
+
+        snd_korg1212_CloseCard(korg1212);
         return 0;
 }
@@ -1448 +1494 @@
         korg1212->periodsize = 0;
 
-        snd_korg1212_CloseCard(korg1212);
-
         spin_unlock_irqrestore(&korg1212->lock, flags);
+
+        snd_korg1212_CloseCard(korg1212);
         return 0;
 }
@@ -1508 +1554 @@
 {
         korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
-        unsigned long flags;
         int rc;
 
@@ -1515 +1560 @@
 #endif
 
-        spin_lock_irqsave(&korg1212->lock, flags);
+        spin_lock(&korg1212->lock);
+
+        /* FIXME: we should wait for ack! */
+        if (korg1212->stop_pending_cnt > 0) {
+#if K1212_DEBUG_LEVEL > 0
+                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare - Stop is pending... [%s]\n", stateName[korg1212->cardState]);
+#endif
+                spin_unlock(&korg1212->lock);
+                return -EAGAIN;
+                /*
+                writel(0, &korg1212->sharedBufferPtr->cardCommand);
+                del_timer(&korg1212->timer);
+                korg1212->stop_pending_cnt = 0;
+                */
+        }
 
         rc = snd_korg1212_SetupForPlay(korg1212);
+
         korg1212->currentBuffer = 0;
 
-        spin_unlock_irqrestore(&korg1212->lock, flags);
+        spin_unlock(&korg1212->lock);
 
         return rc ? -EINVAL : 0;
@@ -1535 +1595 @@
 #endif
 
+        spin_lock(&korg1212->lock);
         switch (cmd) {
                 case SNDRV_PCM_TRIGGER_START:
@@ -1566 +1627 @@
                         break;
         }
+        spin_unlock(&korg1212->lock);
         return rc ? -EINVAL : 0;
 }
@@ -1894 +1956 @@
         }
 
+        spin_unlock_irqrestore(&korg1212->lock, flags);
+
         if (change)
                 snd_korg1212_WriteADCSensitivity(korg1212);
-
-        spin_unlock_irqrestore(&korg1212->lock, flags);
 
         return change;
@@ -2151 +2213 @@
         init_waitqueue_head(&korg1212->wait);
         spin_lock_init(&korg1212->lock);
+        init_MUTEX(&korg1212->open_mutex);
+        init_timer(&korg1212->timer);
+        korg1212->timer.function = snd_korg1212_timer_func;
+        korg1212->timer.data = (unsigned long)korg1212;
 
         korg1212->irq = -1;

GPL/branches/alsa-resync1/alsa-kernel/pci/rme96.c

@@ -1154 +1154 @@
 }
 
-static void
+static irqreturn_t
 snd_rme96_interrupt(int irq,
                     void *dev_id,
@@ -1166 +1166 @@
               (rme96->rcreg & RME96_RCR_IRQ_2)))
         {
-                return;
+                return IRQ_NONE;
         }
         
@@ -1179 +1179 @@
                 writel(0, rme96->iobase + RME96_IO_CONFIRM_REC_IRQ);
         }
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/hdsp.c

@@ -3 +3 @@
  *
  *      Copyright (c) 2002  Paul Davis
+ *                          Marcus Andersson
+ *                          Thomas Charbonnel
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -21 +23 @@
 
 #include <sound/driver.h>
-#include <asm/io.h>
-#include <asm/byteorder.h>
 #include <linux/delay.h>
-#include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
+
 #include <sound/core.h>
 #include <sound/control.h>
@@ -33 +34 @@
 #include <sound/asoundef.h>
 #include <sound/rawmidi.h>
+#include <sound/hwdep.h>
 #define SNDRV_GET_ID
 #include <sound/initval.h>
-
-#include "multiface_firmware.dat"
-#include "digiface_firmware.dat"
+#include <sound/hdsp.h>
+
+#include <asm/byteorder.h>
+#include <asm/current.h>
+#include <asm/io.h>
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
@@ -44 +48 @@
 static int precise_ptr[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0 }; /* Enable precise pointer */
 static int line_outs_monitor[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0}; /* Send all inputs/playback to line outs */
-static int force_firmware[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0}; /* Force firmware reload */
 
 MODULE_PARM(index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
@@ -61 +64 @@
 MODULE_PARM_DESC(line_outs_monitor, "Send all input and playback streams to line outs by default.");
 MODULE_PARM_SYNTAX(line_outs_monitor, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC);
-MODULE_PARM(force_firmware,"1-" __MODULE_STRING(SNDRV_CARDS) "i");
-MODULE_PARM_DESC(force_firmware, "Force a reload of the I/O box firmware");
-MODULE_PARM_SYNTAX(force_firmware, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC);
-MODULE_AUTHOR("Paul Davis <pbd@op.net>");
+MODULE_AUTHOR("Paul Davis <paul@linuxaudiosystems.com>, Marcus Andersson, Thomas Charbonnel <thomas@undata.org>");
 MODULE_DESCRIPTION("RME Hammerfall DSP");
 MODULE_LICENSE("GPL");
 MODULE_CLASSES("{sound}");
-MODULE_DEVICES("{{RME,Hammerfall-DSP}}");
-
-typedef enum {
-        Digiface,
-        Multiface
-} HDSP_Type;
+MODULE_DEVICES("{{RME Hammerfall-DSP},"
+                "{RME HDSP-9652}}");
 
 #define HDSP_MAX_CHANNELS        26
@@ -79 +75 @@
 #define DIGIFACE_DS_CHANNELS     14
 #define MULTIFACE_SS_CHANNELS    18
-#define MULTIFACE_DS_CHANNELS    10
+#define MULTIFACE_DS_CHANNELS    14
 
 /* Write registers. These are defined as byte-offsets from the iobase value.
@@ -119 +115 @@
 #define HDSP_playbackPeakLevel  4096  /* 26 * 32 bit values */
 #define HDSP_inputPeakLevel     4224  /* 26 * 32 bit values */
-#define HDSP_outputPeakLevel    4100  /* 26 * 32 bit values */
+#define HDSP_outputPeakLevel    4352  /* (26+2) * 32 bit values */
 #define HDSP_playbackRmsLevel   4612  /* 26 * 64 bit values */
-#define HDSP_inputRmsLevel      4884  /* 26 * 64 bit values */
+#define HDSP_inputRmsLevel      4868  /* 26 * 64 bit values */
 
 #define HDSP_IO_EXTENT     5192
@@ -144 +140 @@
 /* Control Register bits */
 
-#define HDSP_Start                (1<<0)  // start engine
-#define HDSP_Latency0             (1<<1)  // buffer size = 2^n where n is defined by Latency{2,1,0}
-#define HDSP_Latency1             (1<<2)  // [ see above ]
-#define HDSP_Latency2             (1<<3)  // ] see above ]
-#define HDSP_ClockModeMaster      (1<<4)  // 1=Master, 0=Slave/Autosync
-#define HDSP_AudioInterruptEnable (1<<5)  // what do you think ?
-#define HDSP_Frequency0           (1<<6)  // 0=44.1kHz/88.2kHz 1=48kHz/96kHz
-#define HDSP_Frequency1           (1<<7)  // 0=32kHz/64kHz
-#define HDSP_DoubleSpeed          (1<<8)  // 0=normal speed, 1=double speed
-#define HDSP_SPDIFProfessional    (1<<9)  // 0=consumer, 1=professional
-#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_Start                (1<<0)  /* start engine */
+#define HDSP_Latency0             (1<<1)  /* buffer size = 2^n where n is defined by Latency{2,1,0} */
+#define HDSP_Latency1             (1<<2)  /* [ see above ] */
+#define HDSP_Latency2             (1<<3)  /* ] see above ] */
+#define HDSP_ClockModeMaster      (1<<4)  /* 1=Master, 0=Slave/Autosync */
+#define HDSP_AudioInterruptEnable (1<<5)  /* what do you think ? */
+#define HDSP_Frequency0           (1<<6)  /* 0=44.1kHz/88.2kHz 1=48kHz/96kHz */
+#define HDSP_Frequency1           (1<<7)  /* 0=32kHz/64kHz */
+#define HDSP_DoubleSpeed          (1<<8)  /* 0=normal speed, 1=double speed */
+#define HDSP_SPDIFProfessional    (1<<9)  /* 0=consumer, 1=professional */
+#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) 
@@ -182 +178 @@
 #define HDSP_SyncRef_ADAT_SYNC  (HDSP_SyncRef0|HDSP_SyncRef2)
 
-/* Preferred sync source choices - used by "sync_pref" control switch */
-
-#define HDSP_SYNC_FROM_SELF      0
-#define HDSP_SYNC_FROM_WORD      1
-#define HDSP_SYNC_FROM_ADAT_SYNC 2
-#define HDSP_SYNC_FROM_SPDIF     3
-#define HDSP_SYNC_FROM_ADAT1     4
-#define HDSP_SYNC_FROM_ADAT2     5
-#define HDSP_SYNC_FROM_ADAT3     6
+/* Sample Clock Sources */
+
+#define HDSP_CLOCK_SOURCE_AUTOSYNC         0
+#define HDSP_CLOCK_SOURCE_INTERNAL_32KHZ   1
+#define HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ 2
+#define HDSP_CLOCK_SOURCE_INTERNAL_48KHZ   3
+#define HDSP_CLOCK_SOURCE_INTERNAL_64KHZ   4
+#define HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ 5
+#define HDSP_CLOCK_SOURCE_INTERNAL_96KHZ   6
+
+/* Preferred sync reference choices - used by "pref_sync_ref" control switch */
+
+#define HDSP_SYNC_FROM_WORD      0
+#define HDSP_SYNC_FROM_ADAT_SYNC 1
+#define HDSP_SYNC_FROM_SPDIF     2
+#define HDSP_SYNC_FROM_ADAT1     3
+#define HDSP_SYNC_FROM_ADAT2     4
+#define HDSP_SYNC_FROM_ADAT3     5
+
+/* SyncCheck status */
+
+#define HDSP_SYNC_CHECK_NO_LOCK 0
+#define HDSP_SYNC_CHECK_LOCK    1
+#define HDSP_SYNC_CHECK_SYNC    2
+
+/* AutoSync references - used by "autosync_ref" control switch */
+
+#define HDSP_AUTOSYNC_FROM_WORD      0
+#define HDSP_AUTOSYNC_FROM_ADAT_SYNC 1
+#define HDSP_AUTOSYNC_FROM_SPDIF     2
+#define HDSP_AUTOSYNC_FROM_NONE      3
+#define HDSP_AUTOSYNC_FROM_ADAT1     4
+#define HDSP_AUTOSYNC_FROM_ADAT2     5
+#define HDSP_AUTOSYNC_FROM_ADAT3     6
 
 /* Possible sources of S/PDIF input */
@@ -238 +259 @@
 #define HDSP_spdifFrequencyMask    (HDSP_spdifFrequency0|HDSP_spdifFrequency1|HDSP_spdifFrequency2)
 
-#define HDSP_spdifFrequency32KHz   (HDSP_spdifFrequency0|HDSP_spdifFrequency1|HDSP_spdifFrequency2)
-#define HDSP_spdifFrequency44_1KHz (HDSP_spdifFrequency2|HDSP_spdifFrequency1)
-#define HDSP_spdifFrequency48KHz   (HDSP_spdifFrequency0|HDSP_spdifFrequency2)
-
-#define HDSP_spdifFrequency64KHz    0
-#define HDSP_spdifFrequency88_2KHz (HDSP_spdifFrequency2)
-#define HDSP_spdifFrequency96KHz   (HDSP_spdifFrequency0|HDSP_spdifFrequency1)
+#define HDSP_spdifFrequency32KHz   (HDSP_spdifFrequency0)
+#define HDSP_spdifFrequency44_1KHz (HDSP_spdifFrequency1)
+#define HDSP_spdifFrequency48KHz   (HDSP_spdifFrequency0|HDSP_spdifFrequency1)
+
+#define HDSP_spdifFrequency64KHz   (HDSP_spdifFrequency2)
+#define HDSP_spdifFrequency88_2KHz (HDSP_spdifFrequency0|HDSP_spdifFrequency2)
+#define HDSP_spdifFrequency96KHz   (HDSP_spdifFrequency2|HDSP_spdifFrequency1)
 
 /* Status2 Register bits */
@@ -278 +299 @@
 #define HDSP_SelSyncRef_ADAT_SYNC  (HDSP_SelSyncRef0|HDSP_SelSyncRef2)
 
-/* FIFO wait times, defined in terms of loops on readl() */
-
-#define HDSP_LONG_WAIT   40000
-#define HDSP_SHORT_WAIT  100
-
-/* Computing addresses for adjusting gains */
-
-#define INPUT_TO_OUTPUT_KEY(in,out)     ((64 * (out)) + (in))
-#define PLAYBACK_TO_OUTPUT_KEY(chn,out) ((64 * (out)) + 32 + (chn))
+/* Card state flags */
+
+#define HDSP_InitializationComplete  (1<<0)
+#define HDSP_FirmwareLoaded          (1<<1)
+#define HDSP_FirmwareCached          (1<<2)
+
+/* FIFO wait times, defined in terms of 1/10ths of msecs */
+
+#define HDSP_LONG_WAIT   5000
+#define HDSP_SHORT_WAIT  30
+
 #define UNITY_GAIN                       32768
 #define MINUS_INFINITY_GAIN              0
@@ -314 +337 @@
 #define HDSP_DMA_AREA_KILOBYTES (HDSP_DMA_AREA_BYTES/1024)
 
-#define HDSP_MATRIX_MIXER_SIZE 2048
-
-typedef struct _hdsp      hdsp_t;
-typedef struct _hdsp_midi hdsp_midi_t;
+typedef struct _hdsp          hdsp_t;
+typedef struct _hdsp_midi     hdsp_midi_t;
 
 struct _hdsp_midi {
@@ -328 +349 @@
     struct timer_list        timer;
     spinlock_t               lock;
+    int                      pending;
 };
 
 struct _hdsp {
-        spinlock_t lock;
-        snd_pcm_substream_t *capture_substream;
-        snd_pcm_substream_t *playback_substream;
-        hdsp_midi_t midi[2];
-        int precise_ptr;
-        u32 control_register;            /* cached value */
-        u32 creg_spdif;
-        u32 creg_spdif_stream;
-        char *card_name;                 /* digiface/multiface */
-        HDSP_Type type;                  /* ditto, but for code use */
-        size_t period_bytes;             /* guess what this is */
-        unsigned char ds_channels;
-        unsigned char ss_channels;       /* different for multiface/digiface */
-        void *capture_buffer_unaligned;  /* original buffer addresses */
-        void *playback_buffer_unaligned; /* original buffer addresses */
-        unsigned char *capture_buffer;   /* suitably aligned address */
-        unsigned char *playback_buffer;  /* suitably aligned address */
-        dma_addr_t capture_buffer_addr;
-        dma_addr_t playback_buffer_addr;
-        pid_t capture_pid;
-        pid_t playback_pid;
-        int running;
-        int passthru;                   /* non-zero if doing pass-thru */
-        int last_spdif_sample_rate;     /* so that we can catch externally ... */
-        int last_adat_sample_rate;      /* ... induced rate changes            */
-        char *channel_map;
-        int dev;
-        int irq;
-        unsigned long port;
-        struct resource *res_port;
-        unsigned long iobase;
-        snd_card_t *card;
-        snd_pcm_t *pcm;
-        struct pci_dev *pci;
-        snd_info_entry_t *proc_entry;
-        snd_kcontrol_t *spdif_ctl;
-        unsigned short mixer_matrix[HDSP_MATRIX_MIXER_SIZE];
+        spinlock_t            lock;
+        snd_pcm_substream_t  *capture_substream;
+        snd_pcm_substream_t  *playback_substream;
+        hdsp_midi_t           midi[2];
+        struct tasklet_struct midi_tasklet;
+        int                   precise_ptr;
+        u32                   control_register;          /* cached value */
+        u32                   creg_spdif;
+        u32                   creg_spdif_stream;
+        char                 *card_name;                    /* digiface/multiface */
+        HDSP_IO_Type          io_type;               /* ditto, but for code use */
+        unsigned short        firmware_rev;
+        unsigned short        state;                 /* stores state bits */
+        u32                   firmware_cache[24413]; /* this helps recover from accidental iobox power failure */
+        size_t                period_bytes;         /* guess what this is */
+        unsigned char         ds_channels;
+        unsigned char         ss_channels;          /* different for multiface/digiface */
+        void                 *capture_buffer_unaligned;  /* original buffer addresses */
+        void                 *playback_buffer_unaligned; /* original buffer addresses */
+        unsigned char        *capture_buffer;       /* suitably aligned address */
+        unsigned char        *playback_buffer;      /* suitably aligned address */
+        dma_addr_t            capture_buffer_addr;
+        dma_addr_t            playback_buffer_addr;
+        pid_t                 capture_pid;
+        pid_t                 playback_pid;
+        int                   running;
+        int                   passthru;              /* non-zero if doing pass-thru */
+        int                   last_spdif_sample_rate;/* for information reporting */
+        int                   last_external_sample_rate;
+        int                   last_internal_sample_rate;
+        int                   system_sample_rate;
+        char                 *channel_map;
+        int                   dev;
+        int                   irq;
+        unsigned long         port;
+        struct resource      *res_port;
+        unsigned long         iobase;
+        snd_card_t           *card;
+        snd_pcm_t            *pcm;
+        snd_hwdep_t          *hwdep;
+        struct pci_dev       *pci;
+        snd_kcontrol_t       *spdif_ctl;
+        snd_kcontrol_t       *playback_mixer_ctls[HDSP_MAX_CHANNELS];
+        unsigned short        mixer_matrix[HDSP_MATRIX_MIXER_SIZE];
 };
 
@@ -384 +413 @@
 
 static char channel_map_mf_ss[HDSP_MAX_CHANNELS] = { /* Multiface */
-        /* ADAT 0 */
+        /* Analog */
         0, 1, 2, 3, 4, 5, 6, 7, 
         /* ADAT 2 */
@@ -410 +439 @@
 
 static struct pci_device_id snd_hdsp_ids[] __devinitdata = {
-        {PCI_VENDOR_ID_XILINX,
-         PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP, 
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,}, /* RME Hammerfall-DSP */
-        {0,}
+        {
+                .vendor = PCI_VENDOR_ID_XILINX,
+                .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP, 
+                .subvendor = PCI_ANY_ID,
+                .subdevice = PCI_ANY_ID,
+        }, /* RME Hammerfall-DSP */
+        { 0, },
 };
 
 MODULE_DEVICE_TABLE(pci, snd_hdsp_ids);
 
+/* prototypes */
+static int __devinit snd_hdsp_create_alsa_devices(snd_card_t *card, hdsp_t *hdsp);
+static int __devinit snd_hdsp_create_pcm(snd_card_t *card, hdsp_t *hdsp);
+static inline int snd_hdsp_initialize_input_enable (hdsp_t *hdsp);
+static inline void snd_hdsp_initialize_midi_flush (hdsp_t *hdsp);
+static inline void snd_hdsp_initialize_channels (hdsp_t *hdsp);
+static inline int hdsp_fifo_wait(hdsp_t *hdsp, int count, int timeout);
+static int hdsp_update_simple_mixer_controls(hdsp_t *hdsp);
+static int hdsp_autosync_ref(hdsp_t *hdsp);
+static int snd_hdsp_set_defaults(hdsp_t *hdsp);
+
+static inline int hdsp_is_9652 (hdsp_t *hdsp)
+{
+        switch (hdsp->firmware_rev) {
+        case 0x64:
+        case 0x65:
+        case 0x68:
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+static inline int hdsp_playback_to_output_key (hdsp_t *hdsp, int in, int out)
+{
+        switch (hdsp->firmware_rev) {
+        case 0xa:
+                return (64 * out) + (32 + (in));
+        default:
+                return (52 * out) + (26 + (in));
+        }
+}
+
+static inline int hdsp_input_to_output_key (hdsp_t *hdsp, int in, int out)
+{
+        switch (hdsp->firmware_rev) {
+        case 0xa:
+                return (64 * out) + in;
+        default:
+                return (52 * out) + in;
+        }
+}
+
 static inline void hdsp_write(hdsp_t *hdsp, int reg, int val)
 {
@@ -426 +501 @@
 {
         return readl (hdsp->iobase + reg);
-}
-
-static inline unsigned long long hdsp_read64 (hdsp_t *hdsp, int reg)
-{
-        unsigned long long val;
-        val = hdsp_read(hdsp, reg);
-        val = (val<<32)|hdsp_read(hdsp, reg + 4);
-
-        return val;
 }
 
@@ -441 +507 @@
         if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_ConfigError) {
                 snd_printk ("Hammerfall-DSP: no Digiface or Multiface connected!\n");
+                hdsp->state &= ~HDSP_FirmwareLoaded;
                 return -EIO;
         }
         return 0;
 }
+
+static int snd_hdsp_load_firmware_from_cache(hdsp_t *hdsp) {
+
+        int i;
+        unsigned long flags;
+
+        if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
+                
+                snd_printk ("loading firmware\n");
+
+                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_PROGRAM);
+                hdsp_write (hdsp, HDSP_fifoData, 0);
+                
+                if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
+                        snd_printk ("timeout waiting for download preparation\n");
+                        return -EIO;
+                }
+                
+                hdsp_write (hdsp, HDSP_jtagReg, 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)) {
+                                snd_printk ("timeout during firmware loading\n");
+                                return -EIO;
+                        }
+                }
+                
+                if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
+                        snd_printk ("timeout at end of firmware loading\n");
+                        return -EIO;
+                }
+
+                hdsp_write (hdsp, HDSP_jtagReg, 0);
+                snd_printk ("finished firmware loading\n");
+                
+                if ((1000 / HZ) < 3000) {
+                        set_current_state(TASK_UNINTERRUPTIBLE);
+                        schedule_timeout((3000 * HZ + 999) / 1000);
+                } else {
+                        mdelay(3000);
+                }
+        }
+        if (hdsp->state & HDSP_InitializationComplete) {
+                snd_printk("firmware loaded from cache, restoring defaults\n");
+                spin_lock_irqsave(&hdsp->lock, flags);
+                snd_hdsp_set_defaults(hdsp);
+                spin_unlock_irqrestore(&hdsp->lock, flags); 
+        }
+        
+        hdsp->state |= HDSP_FirmwareLoaded;
+
+        return 0;
+}
+
+static inline int hdsp_get_iobox_version (hdsp_t *hdsp)
+{
+        int err;
+        
+        if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if ((err = snd_hdsp_initialize_input_enable(hdsp)) < 0) {
+                return err;
+        }
+                
+        if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
+        
+                hdsp_write (hdsp, HDSP_jtagReg, HDSP_PROGRAM);
+                hdsp_write (hdsp, HDSP_fifoData, 0);
+                if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT) < 0) {
+                        return -EIO;
+                }
+
+                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
+                hdsp_write (hdsp, HDSP_fifoData, 0);
+
+                if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT)) {
+                        hdsp->io_type = Multiface;
+                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_VERSION_BIT);
+                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
+                        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) {
+                        hdsp->io_type = Multiface;
+                } else {
+                        hdsp->io_type = Digiface;
+                }
+        }
+        return 0;
+}
+
+
+static inline int hdsp_check_for_firmware (hdsp_t *hdsp)
+{
+        if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
+                snd_printk("firmware not present.\n");
+                hdsp->state &= ~HDSP_FirmwareLoaded;
+                return -EIO;
+        }
+        return 0;
+}
+
 
 static inline int hdsp_fifo_wait(hdsp_t *hdsp, int count, int timeout)
@@ -454 +629 @@
         */
         
-        for (i = 0; i < timeout; i++)
+        for (i = 0; i < timeout; i++) {
+
                 if ((int)(hdsp_read (hdsp, HDSP_fifoStatus) & 0xff) <= count)
                         return 0;
+
+                /* not very friendly, but we only do this during a firmware
+                   load and changing the mixer, so we just put up with it.
+                */
+
+                udelay (100);
+        }
 
         snd_printk ("wait for FIFO status <= %d failed after %d iterations\n",
@@ -475 +658 @@
         unsigned int ad;
 
-        if (addr >= HDSP_MATRIX_MIXER_SIZE)
-                return -1;
-
-        ad = data + addr * 65536;
-
-        if (hdsp_fifo_wait(hdsp, 127, HDSP_LONG_WAIT)) {
-                return -1;
-        }
-        hdsp_write (hdsp, HDSP_fifoData, ad);
-        hdsp->mixer_matrix[addr] = data;
+        if (hdsp_is_9652 (hdsp)) {
+
+                if ((ad = addr/2) < 676) {
+
+                        /* from martin björnsen:
+
+                           "You can only write dwords to the
+                           mixer memory which contain two
+                           mixer values in the low and high
+                           word. So if you want to change
+                           value 0 you have to read value 1
+                           from the cache and write both to
+                           the first dword in the mixer
+                           memory."
+                        */
+
+                        hdsp->mixer_matrix[addr] = data;
+                        hdsp_write (hdsp, 1024 + ad, 
+                                    (hdsp->mixer_matrix[(addr&0x7fe)+1] << 16) + 
+                                    hdsp->mixer_matrix[addr&0x7fe]);
+                        return 0;
+                } else {
+                        return -1;
+                }
+                
+
+        } else {
+                if (addr >= HDSP_MATRIX_MIXER_SIZE)
+                        return -1;
+                
+                ad = (addr << 16) + data;
+                
+                if (hdsp_fifo_wait(hdsp, 127, HDSP_LONG_WAIT)) {
+                        return -1;
+                }
+
+                hdsp_write (hdsp, HDSP_fifoData, ad);
+                hdsp->mixer_matrix[addr] = data;
+
+        }
 
         return 0;
@@ -503 +716 @@
 }
 
-static inline int hdsp_system_sample_rate (hdsp_t *hdsp)
+static inline int hdsp_external_sample_rate (hdsp_t *hdsp)
 {
         unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register);
@@ -515 +728 @@
         case HDSP_systemFrequency88_2: return 88200;
         case HDSP_systemFrequency96:   return 96000;
-        default:                       return 0;
+        default:
+                return 0;
         }
 }
@@ -527 +741 @@
                 return 0;
         }
-
+        
         switch (rate_bits) {
         case HDSP_spdifFrequency32KHz: return 32000;
@@ -536 +750 @@
         case HDSP_spdifFrequency96KHz: return 96000;
         default:
-                snd_printk ("unknown frequency status; bits = 0x%x, status = 0x%x", rate_bits, status);
+                snd_printk ("unknown spdif frequency status; bits = 0x%x, status = 0x%x\n", rate_bits, status);
                 return 0;
         }
@@ -565 +779 @@
 static inline void hdsp_reset_hw_pointer(hdsp_t *hdsp)
 {
-#if 0
-        /* reset the hw pointer to zero. We do this by writing to 8
-           registers, each of which is a 32bit wide register, and set
-           them all to zero. 
-        */
-
-        for (i = 0; i < 8; ++i) {
-                hdsp_write(hdsp, i, 0);
-                udelay(10);
-        }
-#endif
+        hdsp_write (hdsp, HDSP_resetPointer, 0);
 }
 
@@ -620 +824 @@
 }
 
-static int hdsp_set_rate(hdsp_t *hdsp, int rate)
+static int hdsp_set_rate(hdsp_t *hdsp, int rate, int called_internally)
 {
         int reject_if_open = 0;
         int current_rate;
-
-        if (!(hdsp->control_register & HDSP_ClockModeMaster)) {
-                snd_printk ("device is not running as a clock master: cannot set sample rate.\n");
-                return -1;
-        }
+        int rate_bits;
+
+        if (!(hdsp->control_register & HDSP_ClockModeMaster)) { 
+                if (called_internally) {
+                        /* request from ctl or card initialization */
+                        snd_printk("device is not running as a clock master: cannot set sample rate.\n");
+                        return -1;
+                } 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("Detected ADAT in double speed mode\n");
+                        } else if (rate != external_freq) {
+                                snd_printk("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
@@ -638 +859 @@
            Note that a similar but essentially insoluble problem
            exists for externally-driven rate changes. All we can do
-           is to flag rate changes in the read/write routines.
-         */
+           is to flag rate changes in the read/write routines.  */
 
         spin_lock_irq(&hdsp->lock);
-        current_rate = hdsp_system_sample_rate(hdsp);
 
         switch (rate) {
@@ -649 +868 @@
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency32KHz;
+                rate_bits = HDSP_Frequency32KHz;
                 break;
         case 44100:
@@ -655 +874 @@
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency44_1KHz;
+                rate_bits = HDSP_Frequency44_1KHz;
                 break;
         case 48000:
@@ -661 +880 @@
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency48KHz;
+                rate_bits = HDSP_Frequency48KHz;
                 break;
         case 64000:
-                if (current_rate < 48000) {
+                if (current_rate <= 48000) {
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency64KHz;
+                rate_bits = HDSP_Frequency64KHz;
                 break;
         case 88200:
-                if (current_rate < 48000) {
+                if (current_rate <= 48000) {
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency88_2KHz;
+                rate_bits = HDSP_Frequency88_2KHz;
                 break;
         case 96000:
-                if (current_rate < 48000) {
+                if (current_rate <= 48000) {
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency96KHz;
+                rate_bits = HDSP_Frequency96KHz;
                 break;
         default:
+                spin_unlock_irq(&hdsp->lock);
                 return -EINVAL;
         }
@@ -694 +914 @@
 
         hdsp->control_register &= ~HDSP_FrequencyMask;
-        hdsp->control_register |= rate;
+        hdsp->control_register |= rate_bits;
         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
 
@@ -700 +920 @@
                 hdsp->channel_map = channel_map_ds;
         } else {
-                switch (hdsp->type) {
+                switch (hdsp->io_type) {
                 case Multiface:
                         hdsp->channel_map = channel_map_mf_ss;
@@ -707 +927 @@
                         hdsp->channel_map = channel_map_df_ss;
                         break;
-                }
+                default:
+                        /* should never happen */
+                        break;
+                }
+        }
+        
+        hdsp->system_sample_rate = rate;
+        
+        if (reject_if_open) {
+                hdsp_update_simple_mixer_controls (hdsp);
         }
 
@@ -727 +956 @@
                 if (enable) {
                         for (i = 0; i < 26; i++) {
-                                hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY(i,i), UNITY_GAIN);
+                                hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,i,i), UNITY_GAIN);
                         }
                 } else {
                         for (i = 0; i < 26; i++) {
-                                hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY(i,i), MINUS_INFINITY_GAIN);
+                                hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,i,i), MINUS_INFINITY_GAIN);
                         }
                 }
@@ -742 +971 @@
                 mapped_channel = hdsp->channel_map[channel];
 
+                snd_assert(mapped_channel > -1, return);
+
                 if (enable) {
-                        hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY(channel,channel), UNITY_GAIN);
+                        hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,mapped_channel,mapped_channel), UNITY_GAIN);
                 } else {
-                        hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY(channel,channel), MINUS_INFINITY_GAIN);
+                        hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,mapped_channel,mapped_channel), MINUS_INFINITY_GAIN);
                 }
         }
@@ -809 +1040 @@
 static inline int snd_hdsp_midi_output_possible (hdsp_t *hdsp, int id)
 {
+        int fifo_bytes_used;
+
         if (id) {
-                return (hdsp_read(hdsp, HDSP_midiStatusOut1) & 0xff) < 128;
+                fifo_bytes_used = hdsp_read(hdsp, HDSP_midiStatusOut1) & 0xff;
         } else {
-                return (hdsp_read(hdsp, HDSP_midiStatusOut0) & 0xff)< 128;
+                fifo_bytes_used = hdsp_read(hdsp, HDSP_midiStatusOut0) & 0xff;
+        }
+
+        if (fifo_bytes_used < 128) {
+                return  128 - fifo_bytes_used;
+        } else {
+                return 0;
         }
 }
@@ -827 +1066 @@
         unsigned long flags;
         int n_pending;
-        int clear_timer = 0;
         int to_write;
         int i;
@@ -835 +1073 @@
                 
         spin_lock_irqsave (&hmidi->lock, flags);
-
         if (hmidi->output) {
                 if (!snd_rawmidi_transmit_empty (hmidi->output)) {
@@ -845 +1082 @@
                                         for (i = 0; i < to_write; ++i) 
                                                 snd_hdsp_midi_write_byte (hmidi->hdsp, hmidi->id, buf[i]);
-                                } else {
-                                        clear_timer = 1;
                                 }
                         }
-                } else {
-                        clear_timer = 1;
-                }
-
-                if (clear_timer && hmidi->istimer && --hmidi->istimer <= 0) {
-                        del_timer(&hmidi->timer);
-                } 
-        }
-
+                }
+        }
         spin_unlock_irqrestore (&hmidi->lock, flags);
         return 0;
@@ -870 +1098 @@
 
         spin_lock_irqsave (&hmidi->lock, flags);
-
         if ((n_pending = snd_hdsp_midi_input_available (hmidi->hdsp, hmidi->id)) > 0) {
                 if (hmidi->input) {
@@ -888 +1115 @@
                         }
                 }
-        } 
+        }
+        hmidi->pending = 0;
+        if (hmidi->id) {
+                hmidi->hdsp->control_register |= HDSP_Midi1InterruptEnable;
+        } else {
+                hmidi->hdsp->control_register |= HDSP_Midi0InterruptEnable;
+        }
+        hdsp_write(hmidi->hdsp, HDSP_controlRegister, hmidi->hdsp->control_register);
         spin_unlock_irqrestore (&hmidi->lock, flags);
         return snd_hdsp_midi_output_write (hmidi);
@@ -963 +1197 @@
         }
         spin_unlock_irqrestore (&hmidi->lock, flags);
+        if (up)
+                snd_hdsp_midi_output_write(hmidi);
 }
 
@@ -1046 +1282 @@
         hdsp->midi[id].hdsp = hdsp;
         hdsp->midi[id].istimer = 0;
+        hdsp->midi[id].pending = 0;
         spin_lock_init (&hdsp->midi[id].lock);
 
@@ -1168 +1405 @@
 
 #define HDSP_SPDIF_IN(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_PCM,  \
+  .name = xname, \
+  .index = xindex, \
   .info = snd_hdsp_info_spdif_in, \
-  .get = snd_hdsp_get_spdif_in, .put = snd_hdsp_put_spdif_in }
+  .get = snd_hdsp_get_spdif_in, \
+  .put = snd_hdsp_put_spdif_in }
 
 static unsigned int hdsp_spdif_in(hdsp_t *hdsp)
@@ -1201 +1441 @@
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
-        
-        spin_lock_irqsave(&hdsp->lock, flags);
+        
         ucontrol->value.enumerated.item[0] = hdsp_spdif_in(hdsp);
-        spin_unlock_irqrestore(&hdsp->lock, flags);
         return 0;
 }
@@ -1228 +1465 @@
 
 #define HDSP_SPDIF_OUT(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
-  .info = snd_hdsp_info_spdif_out, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
+  .info = snd_hdsp_info_spdif_bits, \
   .get = snd_hdsp_get_spdif_out, .put = snd_hdsp_put_spdif_out }
 
@@ -1248 +1485 @@
 }
 
-static int snd_hdsp_info_spdif_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_hdsp_info_spdif_bits(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
@@ -1260 +1497 @@
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
-        
-        spin_lock_irqsave(&hdsp->lock, flags);
+        
         ucontrol->value.integer.value[0] = hdsp_spdif_out(hdsp);
-        spin_unlock_irqrestore(&hdsp->lock, flags);
         return 0;
 }
@@ -1285 +1519 @@
 }
 
-#define HDSP_SYNC_PREF(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
-  .info = snd_hdsp_info_sync_pref, \
-  .get = snd_hdsp_get_sync_pref, .put = snd_hdsp_put_sync_pref }
-
-static int hdsp_sync_pref(hdsp_t *hdsp)
+#define HDSP_SPDIF_PROFESSIONAL(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
+  .info = snd_hdsp_info_spdif_bits, \
+  .get = snd_hdsp_get_spdif_professional, .put = snd_hdsp_put_spdif_professional }
+
+static int hdsp_spdif_professional(hdsp_t *hdsp)
+{
+        return (hdsp->control_register & HDSP_SPDIFProfessional) ? 1 : 0;
+}
+
+static int hdsp_set_spdif_professional(hdsp_t *hdsp, int val)
+{
+        if (val) {
+                hdsp->control_register |= HDSP_SPDIFProfessional;
+        } else {
+                hdsp->control_register &= ~HDSP_SPDIFProfessional;
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_get_spdif_professional(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.integer.value[0] = hdsp_spdif_professional(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_spdif_professional(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        unsigned int val;
+        
+        if (!snd_hdsp_use_is_exclusive(hdsp))
+                return -EBUSY;
+        val = ucontrol->value.integer.value[0] & 1;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        change = (int)val != hdsp_spdif_professional(hdsp);
+        hdsp_set_spdif_professional(hdsp, val);
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_SPDIF_EMPHASIS(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
+  .info = snd_hdsp_info_spdif_bits, \
+  .get = snd_hdsp_get_spdif_emphasis, .put = snd_hdsp_put_spdif_emphasis }
+
+static int hdsp_spdif_emphasis(hdsp_t *hdsp)
+{
+        return (hdsp->control_register & HDSP_SPDIFEmphasis) ? 1 : 0;
+}
+
+static int hdsp_set_spdif_emphasis(hdsp_t *hdsp, int val)
+{
+        if (val) {
+                hdsp->control_register |= HDSP_SPDIFEmphasis;
+        } else {
+                hdsp->control_register &= ~HDSP_SPDIFEmphasis;
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_get_spdif_emphasis(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.integer.value[0] = hdsp_spdif_emphasis(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_spdif_emphasis(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        unsigned int val;
+        
+        if (!snd_hdsp_use_is_exclusive(hdsp))
+                return -EBUSY;
+        val = ucontrol->value.integer.value[0] & 1;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        change = (int)val != hdsp_spdif_emphasis(hdsp);
+        hdsp_set_spdif_emphasis(hdsp, val);
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_SPDIF_NON_AUDIO(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
+  .info = snd_hdsp_info_spdif_bits, \
+  .get = snd_hdsp_get_spdif_nonaudio, .put = snd_hdsp_put_spdif_nonaudio }
+
+static int hdsp_spdif_nonaudio(hdsp_t *hdsp)
+{
+        return (hdsp->control_register & HDSP_SPDIFNonAudio) ? 1 : 0;
+}
+
+static int hdsp_set_spdif_nonaudio(hdsp_t *hdsp, int val)
+{
+        if (val) {
+                hdsp->control_register |= HDSP_SPDIFNonAudio;
+        } else {
+                hdsp->control_register &= ~HDSP_SPDIFNonAudio;
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_get_spdif_nonaudio(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.integer.value[0] = hdsp_spdif_nonaudio(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_spdif_nonaudio(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        unsigned int val;
+        
+        if (!snd_hdsp_use_is_exclusive(hdsp))
+                return -EBUSY;
+        val = ucontrol->value.integer.value[0] & 1;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        change = (int)val != hdsp_spdif_nonaudio(hdsp);
+        hdsp_set_spdif_nonaudio(hdsp, val);
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_SPDIF_SAMPLE_RATE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_spdif_sample_rate, \
+  .get = snd_hdsp_get_spdif_sample_rate \
+}
+
+static int snd_hdsp_info_spdif_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None"};
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        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]);
+        return 0;
+}
+
+static int snd_hdsp_get_spdif_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        switch (hdsp_spdif_sample_rate(hdsp)) {
+        case 32000:
+                ucontrol->value.enumerated.item[0] = 0;
+                break;
+        case 44100:
+                ucontrol->value.enumerated.item[0] = 1;
+                break;
+        case 48000:
+                ucontrol->value.enumerated.item[0] = 2;
+                break;
+        case 64000:
+                ucontrol->value.enumerated.item[0] = 3;
+                break;
+        case 88200:
+                ucontrol->value.enumerated.item[0] = 4;
+                break;
+        case 96000:
+                ucontrol->value.enumerated.item[0] = 5;
+                break;
+        default:
+                ucontrol->value.enumerated.item[0] = 6;         
+        }
+        return 0;
+}
+
+#define HDSP_SYSTEM_SAMPLE_RATE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_system_sample_rate, \
+  .get = snd_hdsp_get_system_sample_rate \
+}
+
+static int snd_hdsp_info_system_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        return 0;
+}
+
+static int snd_hdsp_get_system_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp->system_sample_rate;
+        return 0;
+}
+
+#define HDSP_AUTOSYNC_SAMPLE_RATE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_autosync_sample_rate, \
+  .get = snd_hdsp_get_autosync_sample_rate \
+}
+
+static int snd_hdsp_info_autosync_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None"};  
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        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]);
+        return 0;
+}
+
+static int snd_hdsp_get_autosync_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        switch (hdsp_external_sample_rate(hdsp)) {
+        case 32000:
+                ucontrol->value.enumerated.item[0] = 0;
+                break;
+        case 44100:
+                ucontrol->value.enumerated.item[0] = 1;
+                break;
+        case 48000:
+                ucontrol->value.enumerated.item[0] = 2;
+                break;
+        case 64000:
+                ucontrol->value.enumerated.item[0] = 3;
+                break;
+        case 88200:
+                ucontrol->value.enumerated.item[0] = 4;
+                break;
+        case 96000:
+                ucontrol->value.enumerated.item[0] = 5;
+                break;
+        default:
+                ucontrol->value.enumerated.item[0] = 6;         
+        }
+        return 0;
+}
+
+#define HDSP_SYSTEM_CLOCK_MODE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_system_clock_mode, \
+  .get = snd_hdsp_get_system_clock_mode \
+}
+
+static int hdsp_system_clock_mode(hdsp_t *hdsp)
+{
+        if (hdsp->control_register & HDSP_ClockModeMaster) {
+                return 0;
+        } else if (hdsp_external_sample_rate(hdsp) != hdsp->system_sample_rate) {
+                        return 0;
+        }
+        return 1;
+}
+
+static int snd_hdsp_info_system_clock_mode(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"Master", "Slave" };
+        
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 2;
+        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]);
+        return 0;
+}
+
+static int snd_hdsp_get_system_clock_mode(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_system_clock_mode(hdsp);
+        return 0;
+}
+
+#define HDSP_CLOCK_SOURCE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdsp_info_clock_source, \
+  .get = snd_hdsp_get_clock_source, \
+  .put = snd_hdsp_put_clock_source \
+}
+
+static int hdsp_clock_source(hdsp_t *hdsp)
+{
+        if (hdsp->control_register & HDSP_ClockModeMaster) {
+                switch (hdsp->system_sample_rate) {
+                case 32000:
+                        return 1;
+                case 44100:
+                        return 2;
+                case 48000:
+                        return 3;
+                case 64000:
+                        return 4;
+                case 88200:
+                        return 5;
+                case 96000:
+                        return 6;
+                default:
+                        return 3;       
+                }
+        } else {
+                return 0;
+        }
+}
+
+static int hdsp_set_clock_source(hdsp_t *hdsp, int mode)
+{
+        int rate;
+        switch (mode) {
+        case HDSP_CLOCK_SOURCE_AUTOSYNC:
+                if (hdsp_external_sample_rate(hdsp) != 0) {
+                    hdsp->control_register &= ~HDSP_ClockModeMaster;            
+                    hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+                    return 0;
+                }
+                return -1;
+        case HDSP_CLOCK_SOURCE_INTERNAL_32KHZ:
+                rate = 32000;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ:
+                rate = 44100;
+                break;      
+        case HDSP_CLOCK_SOURCE_INTERNAL_48KHZ:
+                rate = 48000;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_64KHZ:
+                rate = 64000;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ:
+                rate = 88200;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_96KHZ:
+                rate = 96000;
+                break;
+        default:
+                rate = 48000;
+        }
+        hdsp->control_register |= HDSP_ClockModeMaster;
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        hdsp_set_rate(hdsp, rate, 1);
+        return 0;
+}
+
+static int snd_hdsp_info_clock_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        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" };
+        
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        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]);
+        return 0;
+}
+
+static int snd_hdsp_get_clock_source(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_clock_source(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_clock_source(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        int val;
+        
+        if (!snd_hdsp_use_is_exclusive(hdsp))
+                return -EBUSY;
+        val = ucontrol->value.enumerated.item[0];
+        if (val < 0) val = 0;
+        if (val > 6) val = 6;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        if (val != hdsp_clock_source(hdsp)) {
+                change = (hdsp_set_clock_source(hdsp, val) == 0) ? 1 : 0;
+        } else {
+                change = 0;
+        }
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_PREF_SYNC_REF(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdsp_info_pref_sync_ref, \
+  .get = snd_hdsp_get_pref_sync_ref, \
+  .put = snd_hdsp_put_pref_sync_ref \
+}
+
+static int hdsp_pref_sync_ref(hdsp_t *hdsp)
 {
         /* Notice that this looks at the requested sync source,
            not the one actually in use.
         */
-        
-        if (hdsp->control_register & HDSP_ClockModeMaster) {
-                return HDSP_SYNC_FROM_SELF;
-        }
 
         switch (hdsp->control_register & HDSP_SyncRefMask) {
@@ -1314 +1964 @@
                 return HDSP_SYNC_FROM_ADAT_SYNC;
         default:
-                return HDSP_SYNC_FROM_SELF;
-        }
-        return 0;
-}
-
-static int hdsp_set_sync_pref(hdsp_t *hdsp, int pref)
+                return HDSP_SYNC_FROM_WORD;
+        }
+        return 0;
+}
+
+static int hdsp_set_pref_sync_ref(hdsp_t *hdsp, int pref)
 {
         hdsp->control_register &= ~HDSP_SyncRefMask;
         switch (pref) {
         case HDSP_SYNC_FROM_ADAT1:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register &= ~HDSP_SyncRefMask; /* clear SyncRef bits */
                 break;
         case HDSP_SYNC_FROM_ADAT2:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_ADAT2;
                 break;
         case HDSP_SYNC_FROM_ADAT3:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_ADAT3;
                 break;
         case HDSP_SYNC_FROM_SPDIF:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_SPDIF;
                 break;
         case HDSP_SYNC_FROM_WORD:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_WORD;
                 break;
         case HDSP_SYNC_FROM_ADAT_SYNC:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_ADAT_SYNC;
-                break;
-        case HDSP_SYNC_FROM_SELF:
-                hdsp->control_register |= HDSP_ClockModeMaster;
                 break;
         default:
@@ -1357 +1998 @@
 }
 
-static int snd_hdsp_info_sync_pref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        static char *texts[] = {"Internal", "Word", "ADAT Sync", "IEC958", "ADAT1", "ADAT2", "ADAT3" };
+static int snd_hdsp_info_pref_sync_ref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"Word", "ADAT Sync", "IEC958", "ADAT1", "ADAT2", "ADAT3" };
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
         
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = (hdsp->type == Digiface) ? 7 : 6;
+        uinfo->value.enumerated.items = (hdsp->io_type == Digiface) ? 6 : 4;
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
@@ -1371 +2012 @@
 }
 
-static int snd_hdsp_get_sync_pref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_hdsp_get_pref_sync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
-        
-        spin_lock_irqsave(&hdsp->lock, flags);
-        ucontrol->value.enumerated.item[0] = hdsp_sync_pref(hdsp);
-        spin_unlock_irqrestore(&hdsp->lock, flags);
-        return 0;
-}
-
-static int snd_hdsp_put_sync_pref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+        
+        ucontrol->value.enumerated.item[0] = hdsp_pref_sync_ref(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_pref_sync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
@@ -1391 +2029 @@
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
-        max = hdsp->ss_channels == (hdsp->type == Digiface) ? 7 : 6;
+        max = (hdsp->io_type == Digiface) ? 6 : 4;
         val = ucontrol->value.enumerated.item[0] % max;
         spin_lock_irqsave(&hdsp->lock, flags);
-        change = (int)val != hdsp_sync_pref(hdsp);
-        hdsp_set_sync_pref(hdsp, val);
+        change = (int)val != hdsp_pref_sync_ref(hdsp);
+        hdsp_set_pref_sync_ref(hdsp, val);
         spin_unlock_irqrestore(&hdsp->lock, flags);
         return change;
 }
 
+#define HDSP_AUTOSYNC_REF(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_autosync_ref, \
+  .get = snd_hdsp_get_autosync_ref, \
+}
+
+static int hdsp_autosync_ref(hdsp_t *hdsp)
+{
+        /* This looks at the autosync selected sync reference */
+        unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register);
+
+        switch (status2 & HDSP_SelSyncRefMask) {
+        case HDSP_SelSyncRef_WORD:
+                return HDSP_AUTOSYNC_FROM_WORD;
+        case HDSP_SelSyncRef_ADAT_SYNC:
+                return HDSP_AUTOSYNC_FROM_ADAT_SYNC;
+        case HDSP_SelSyncRef_SPDIF:
+                return HDSP_AUTOSYNC_FROM_SPDIF;
+        case HDSP_SelSyncRefMask:
+                return HDSP_AUTOSYNC_FROM_NONE; 
+        case HDSP_SelSyncRef_ADAT1:
+                return HDSP_AUTOSYNC_FROM_ADAT1;
+        case HDSP_SelSyncRef_ADAT2:
+                return HDSP_AUTOSYNC_FROM_ADAT2;
+        case HDSP_SelSyncRef_ADAT3:
+                return HDSP_AUTOSYNC_FROM_ADAT3;
+        default:
+                return HDSP_AUTOSYNC_FROM_WORD;
+        }
+        return 0;
+}
+
+static int snd_hdsp_info_autosync_ref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * 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;
+        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]);
+        return 0;
+}
+
+static int snd_hdsp_get_autosync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_pref_sync_ref(hdsp);
+        return 0;
+}
+
 #define HDSP_PASSTHRU(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .info = snd_hdsp_info_passthru, \
   .put = snd_hdsp_put_passthru, \
-  .get = snd_hdsp_get_passthru }
+  .get = snd_hdsp_get_passthru \
+}
 
 static int snd_hdsp_info_passthru(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo)
@@ -1447 +2144 @@
 
 #define HDSP_LINE_OUT(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .info = snd_hdsp_info_line_out, \
-  .get = snd_hdsp_get_line_out, .put = snd_hdsp_put_line_out }
+  .get = snd_hdsp_get_line_out, \
+  .put = snd_hdsp_put_line_out \
+}
 
 static int hdsp_line_out(hdsp_t *hdsp)
@@ -1505 +2206 @@
 
 #define HDSP_MIXER(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
+                 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
   .info = snd_hdsp_info_mixer, \
-  .get = snd_hdsp_get_mixer, .put = snd_hdsp_put_mixer }
+  .get = snd_hdsp_get_mixer, \
+  .put = snd_hdsp_put_mixer \
+}
 
 static int snd_hdsp_info_mixer(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
@@ -1531 +2238 @@
 
         if (source > 25) {
-                addr = PLAYBACK_TO_OUTPUT_KEY(source-26,destination);
+                addr = hdsp_playback_to_output_key(hdsp,source-26,destination);
         } else {
-                addr = INPUT_TO_OUTPUT_KEY(source, destination);
+                addr = hdsp_input_to_output_key(hdsp,source, destination);
         }
         
         spin_lock_irqsave(&hdsp->lock, flags);
-        ucontrol->value.integer.value[0] = hdsp_read_gain (hdsp, addr);
+        ucontrol->value.integer.value[2] = hdsp_read_gain (hdsp, addr);
         spin_unlock_irqrestore(&hdsp->lock, flags);
         return 0;
@@ -1559 +2266 @@
 
         if (source > 25) {
-                addr = PLAYBACK_TO_OUTPUT_KEY(source-26, destination);
+                addr = hdsp_playback_to_output_key(hdsp,source-26, destination);
         } else {
-                addr = INPUT_TO_OUTPUT_KEY(source, destination);
+                addr = hdsp_input_to_output_key(hdsp,source, destination);
         }
 
@@ -1584 +2291 @@
                  SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
   .info = snd_hdsp_info_playback_mixer, \
-  .get = snd_hdsp_get_playback_mixer, .put = snd_hdsp_put_playback_mixer }
+  .get = snd_hdsp_get_playback_mixer, \
+  .put = snd_hdsp_put_playback_mixer \
+}
 
 static int snd_hdsp_info_playback_mixer(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
@@ -1601 +2310 @@
         unsigned long flags;
         int addr;
-        int chn;
-
-        chn = ucontrol->id.index - 1;
-        addr = PLAYBACK_TO_OUTPUT_KEY(chn, chn);
+        int channel;
+        int mapped_channel;
+
+        channel = ucontrol->id.index - 1;
+
+        snd_assert(channel >= 0 || channel < HDSP_MAX_CHANNELS, return -EINVAL);
+        
+        if ((mapped_channel = hdsp->channel_map[channel]) < 0) {
+                return -EINVAL;
+        }
+
+        addr = hdsp_playback_to_output_key(hdsp,mapped_channel, mapped_channel);
 
         spin_lock_irqsave(&hdsp->lock, flags);
@@ -1618 +2335 @@
         int change;
         int addr;
-        int chn;
+        int channel;
+        int mapped_channel;
         int gain;
 
@@ -1624 +2342 @@
                 return -EBUSY;
         
-        chn = ucontrol->id.index - 1;
-        addr = PLAYBACK_TO_OUTPUT_KEY(chn, chn);
+        channel = ucontrol->id.index - 1;
+
+        snd_assert(channel >= 0 || channel < HDSP_MAX_CHANNELS, return -EINVAL);
+        
+        if ((mapped_channel = hdsp->channel_map[channel]) < 0) {
+                return -EINVAL;
+        }
+
+        addr = hdsp_playback_to_output_key(hdsp,mapped_channel, mapped_channel);
         gain = ucontrol->value.integer.value[0];
 
@@ -1637 +2362 @@
 }
 
-#define HDSP_PEAK_PLAYBACK \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+#define HDSP_WC_SYNC_CHECK(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_peak_playback, \
-  .get = snd_hdsp_get_peak_playback \
-}
-
-static int snd_hdsp_info_peak_playback(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 2;
-        return 0;
-}
-
-static int snd_hdsp_get_peak_playback(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+  .info = snd_hdsp_info_sync_check, \
+  .get = snd_hdsp_get_wc_sync_check \
+}
+
+static int snd_hdsp_info_sync_check(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"No Lock", "Lock", "Sync" };    
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 3;
+        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]);
+        return 0;
+}
+
+static int hdsp_wc_sync_check(hdsp_t *hdsp)
+{
+        int status2 = hdsp_read(hdsp, HDSP_status2Register);
+        if (status2 & HDSP_wc_lock) {
+                if (status2 & HDSP_wc_sync) {
+                        return 2;
+                } else {
+                         return 1;
+                }
+        } else {                
+                return 0;
+        }
+        return 0;
+}
+
+static int snd_hdsp_get_wc_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned int peakval = hdsp_read (hdsp, HDSP_playbackPeakLevel + (4 * (ucontrol->id.index-1)));
-        ucontrol->value.integer.value[0] = peakval & 0xffffff00;  /* peak */
-        ucontrol->value.integer.value[1] = peakval & 0xf;         /* overs */
-        return 0;
-}
-
-#define HDSP_PEAK_INPUT \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+
+        ucontrol->value.enumerated.item[0] = hdsp_wc_sync_check(hdsp);
+        return 0;
+}
+
+#define HDSP_SPDIF_SYNC_CHECK(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_peak_input, \
-  .get = snd_hdsp_get_peak_input \
-}
-
-static int snd_hdsp_info_peak_input(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 2;
-        return 0;
-}
-
-static int snd_hdsp_get_peak_input(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+  .info = snd_hdsp_info_sync_check, \
+  .get = snd_hdsp_get_spdif_sync_check \
+}
+
+static int hdsp_spdif_sync_check(hdsp_t *hdsp)
+{
+        int status = hdsp_read(hdsp, HDSP_statusRegister);
+        if (status & HDSP_SPDIFErrorFlag) {
+                return 0;
+        } else {        
+                if (status & HDSP_SPDIFSync) {
+                        return 2;
+                } else {
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+static int snd_hdsp_get_spdif_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned int peakval = hdsp_read (hdsp, HDSP_inputPeakLevel + (4 * (ucontrol->id.index-1)));
-        ucontrol->value.integer.value[0] = peakval & 0xffffff00;  /* peak */
-        ucontrol->value.integer.value[1] = peakval & 0xf;         /* overs */
-        return 0;
-}
-
-#define HDSP_PEAK_OUTPUT \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+
+        ucontrol->value.enumerated.item[0] = hdsp_spdif_sync_check(hdsp);
+        return 0;
+}
+
+#define HDSP_ADATSYNC_SYNC_CHECK(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_peak_output, \
-  .get = snd_hdsp_get_peak_output \
-}
-
-static int snd_hdsp_info_peak_output(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 2;
-        return 0;
-}
-
-static int snd_hdsp_get_peak_output(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+  .info = snd_hdsp_info_sync_check, \
+  .get = snd_hdsp_get_adatsync_sync_check \
+}
+
+static int hdsp_adatsync_sync_check(hdsp_t *hdsp)
+{
+        int status = hdsp_read(hdsp, HDSP_statusRegister);
+        if (status & HDSP_TimecodeLock) {
+                if (status & HDSP_TimecodeSync) {
+                        return 2;
+                } else {
+                        return 1;
+                }
+        } else {
+                return 0;
+        }
+}       
+
+static int snd_hdsp_get_adatsync_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned int peakval = hdsp_read (hdsp, HDSP_outputPeakLevel + (4 * (ucontrol->id.index-1)));
-        ucontrol->value.integer.value[0] = peakval & 0xffffff00;  /* peak */
-        ucontrol->value.integer.value[1] = peakval & 0xf;         /* overs */
-        return 0;
-}
-
-#define HDSP_RMS_INPUT \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+
+        ucontrol->value.enumerated.item[0] = hdsp_adatsync_sync_check(hdsp);
+        return 0;
+}
+
+#define HDSP_ADAT_SYNC_CHECK \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_rms_input, \
-  .get = snd_hdsp_get_rms_input \
-}
-
-static int snd_hdsp_info_rms_input(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER64;
-        uinfo->count = 1;
-        return 0;
-}
-
-static int snd_hdsp_get_rms_input(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
-{
+  .info = snd_hdsp_info_sync_check, \
+  .get = snd_hdsp_get_adat_sync_check \
+}
+
+static int hdsp_adat_sync_check(hdsp_t *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;               
+                }
+        } else {
+                return 0;
+        }               
+} 
+
+static int snd_hdsp_get_adat_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        int offset;
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        ucontrol->value.integer64.value[0] = hdsp_read64 (hdsp, HDSP_inputRmsLevel + (8 * (ucontrol->id.index-1)));
-        return 0;
-}
-
-#define HDSP_RMS_PLAYBACK \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
-  .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_rms_playback, \
-  .get = snd_hdsp_get_rms_playback \
-}
-
-static int snd_hdsp_info_rms_playback(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER64;
-        uinfo->count = 1;
-        return 0;
-}
-
-static int snd_hdsp_get_rms_playback(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
-{
-        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        ucontrol->value.integer64.value[0] = hdsp_read64 (hdsp, HDSP_playbackRmsLevel + (8 * (ucontrol->id.index-1)));
+
+        offset = ucontrol->id.index - 1;
+        snd_assert(offset >= 0 || offset < ((hdsp->io_type == Digiface) ? 3 : 1), return -EINVAL);
+        ucontrol->value.enumerated.item[0] = hdsp_adat_sync_check(hdsp, offset);
         return 0;
 }
@@ -1771 +2525 @@
         .get =          snd_hdsp_control_spdif_mask_get,
         .private_value = IEC958_AES0_NONAUDIO |
-                        IEC958_AES0_PROFESSIONAL |
-                        IEC958_AES0_CON_EMPHASIS,                                                                                             
+                         IEC958_AES0_PROFESSIONAL |
+                         IEC958_AES0_CON_EMPHASIS,                                                                                            
 },
 {
@@ -1781 +2535 @@
         .get =          snd_hdsp_control_spdif_mask_get,
         .private_value = IEC958_AES0_NONAUDIO |
-                        IEC958_AES0_PROFESSIONAL |
-                        IEC958_AES0_PRO_EMPHASIS,
+                         IEC958_AES0_PROFESSIONAL |
+                         IEC958_AES0_PRO_EMPHASIS,
 },
 HDSP_MIXER("Mixer", 0),
 HDSP_SPDIF_IN("IEC958 Input Connector", 0),
 HDSP_SPDIF_OUT("IEC958 Output also on ADAT1", 0),
-HDSP_SYNC_PREF("Preferred Sync Source", 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 */ 
+HDSP_CLOCK_SOURCE("Sample Clock Source", 0),
+HDSP_SYSTEM_CLOCK_MODE("System Clock Mode", 0),
+HDSP_PREF_SYNC_REF("Preferred Sync Reference", 0),
+HDSP_AUTOSYNC_REF("AutoSync Reference", 0),
+HDSP_SPDIF_SAMPLE_RATE("SPDIF Sample Rate", 0),
+HDSP_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
+/* 'External Rate' complies with the alsa control naming scheme */
+HDSP_AUTOSYNC_SAMPLE_RATE("External Rate", 0),
+HDSP_WC_SYNC_CHECK("Word Clock Lock Status", 0),
+HDSP_SPDIF_SYNC_CHECK("SPDIF Lock Status", 0),
+HDSP_ADATSYNC_SYNC_CHECK("ADAT Sync Lock Status", 0),
 HDSP_PASSTHRU("Passthru", 0),
 HDSP_LINE_OUT("Line Out", 0),
@@ -1795 +2563 @@
 
 static snd_kcontrol_new_t snd_hdsp_playback_mixer = HDSP_PLAYBACK_MIXER;
-static snd_kcontrol_new_t snd_hdsp_input_peak = HDSP_PEAK_INPUT;
-static snd_kcontrol_new_t snd_hdsp_output_peak = HDSP_PEAK_OUTPUT;
-static snd_kcontrol_new_t snd_hdsp_playback_peak = HDSP_PEAK_PLAYBACK;
-static snd_kcontrol_new_t snd_hdsp_input_rms = HDSP_RMS_INPUT;
-static snd_kcontrol_new_t snd_hdsp_playback_rms = HDSP_RMS_PLAYBACK;
+static snd_kcontrol_new_t snd_hdsp_adat_sync_check = HDSP_ADAT_SYNC_CHECK;
+
+
+static int hdsp_update_simple_mixer_controls(hdsp_t *hdsp)
+{
+    int i;
+
+    for (i = hdsp->ds_channels; i < hdsp->ss_channels; ++i) {
+            if (hdsp->system_sample_rate > 48000) {
+                    hdsp->playback_mixer_ctls[i]->vd[0].access = SNDRV_CTL_ELEM_ACCESS_INACTIVE |
+                                                            SNDRV_CTL_ELEM_ACCESS_READ |
+                                                             SNDRV_CTL_ELEM_ACCESS_VOLATILE;
+            } else {
+                    hdsp->playback_mixer_ctls[i]->vd[0].access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                                                             SNDRV_CTL_ELEM_ACCESS_VOLATILE;
+            }
+            snd_ctl_notify(hdsp->card, SNDRV_CTL_EVENT_MASK_VALUE | 
+                            SNDRV_CTL_EVENT_MASK_INFO, &hdsp->playback_mixer_ctls[i]->id);
+    }
+
+    return 0;
+}
+
 
 int snd_hdsp_create_controls(snd_card_t *card, hdsp_t *hdsp)
@@ -1814 +2600 @@
         }
 
-        if (hdsp->type == Digiface) {
+        snd_hdsp_playback_mixer.name = "Chn";
+        snd_hdsp_adat_sync_check.name = "ADAT Lock Status";
+
+        if (hdsp->io_type == Digiface) {
                 limit = DIGIFACE_SS_CHANNELS;
         } else {
                 limit = MULTIFACE_SS_CHANNELS;
         }
-
+        
         /* The index values are one greater than the channel ID so that alsamixer
            will display them correctly. We want to use the index for fast lookup
@@ -1826 +2615 @@
         */
 
-        snd_hdsp_playback_mixer.name = "Chn";
-        snd_hdsp_input_peak.name = "Input Peak";
-        snd_hdsp_output_peak.name = "Output Peak";
-        snd_hdsp_playback_peak.name = "Playback Peak";
-        snd_hdsp_playback_rms.name = "Playback RMS";
-        snd_hdsp_input_rms.name = "Input RMS";
-
         for (idx = 0; idx < limit; ++idx) {
                 snd_hdsp_playback_mixer.index = idx+1;
@@ -1838 +2620 @@
                         return err;
                 }
-                snd_hdsp_input_peak.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_input_peak, hdsp)))) {
-                        return err;
-                }
-                snd_hdsp_output_peak.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_output_peak, hdsp)))) {
-                        return err;
-                }
-                snd_hdsp_playback_peak.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_playback_peak, hdsp)))) {
-                        return err;
-                }
-                snd_hdsp_playback_rms.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_playback_rms, hdsp)))) {
-                        return err;
-                }
-                snd_hdsp_input_rms.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_input_rms, hdsp)))) {
-                        return err;
+                hdsp->playback_mixer_ctls[idx] = kctl;
+        }
+        
+        /* ADAT SyncCheck status */
+        snd_hdsp_adat_sync_check.index = 1;
+        if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_adat_sync_check, hdsp)))) {
+                return err;
+        }       
+        if (hdsp->io_type == Digiface) {
+                for (idx = 1; idx < 3; ++idx) {
+                        snd_hdsp_adat_sync_check.index = idx+1;
+                        if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_adat_sync_check, hdsp)))) {
+                                return err;
+                        }
                 }
         }
@@ -1873 +2650 @@
         unsigned int status;
         unsigned int status2;
-        char *requested_sync_ref;
+        char *pref_sync_ref;
+        char *autosync_ref;
+        char *system_clock_mode;
+        char *clock_source;
         int x;
 
         if (hdsp_check_for_iobox (hdsp)) {
+                snd_iprintf(buffer, "No I/O box connected.\nPlease connect one and upload firmware.\n");
                 return;
         }
 
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_iprintf(buffer, "Firmware loading from cache failed, please upload manually.\n");
+                                return;
+                        }
+                } else {
+                        snd_iprintf(buffer, "No firmware loaded nor cached, please upload firmware.\n");
+                        return;
+                }
+        }
+        
         status = hdsp_read(hdsp, HDSP_statusRegister);
         status2 = hdsp_read(hdsp, HDSP_status2Register);
@@ -1902 +2695 @@
         x = 1 << (6 + hdsp_decode_latency(hdsp->control_register & HDSP_LatencyMask));
 
-        snd_iprintf(buffer, "Latency: %d samples (2 periods of %lu bytes)\n", x, (unsigned long) hdsp->period_bytes);
+        snd_iprintf(buffer, "Buffer Size (Latency): %d samples (2 periods of %lu bytes)\n", x, (unsigned long) hdsp->period_bytes);
         snd_iprintf(buffer, "Hardware pointer (frames): %ld\n", hdsp_hw_pointer(hdsp));
         snd_iprintf(buffer, "Passthru: %s\n", hdsp->passthru ? "yes" : "no");
@@ -1909 +2702 @@
         snd_iprintf(buffer, "Firmware version: %d\n", (status2&HDSP_version0)|(status2&HDSP_version1)<<1|(status2&HDSP_version2)<<2);
 
-        switch (hdsp_sync_pref (hdsp)) {
+        snd_iprintf(buffer, "\n");
+
+
+        switch (hdsp_clock_source(hdsp)) {
+        case HDSP_CLOCK_SOURCE_AUTOSYNC:
+                clock_source = "AutoSync";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_32KHZ:
+                clock_source = "Internal 32 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ:
+                clock_source = "Internal 44.1 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_48KHZ:
+                clock_source = "Internal 48 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_64KHZ:
+                clock_source = "Internal 64 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ:
+                clock_source = "Internal 88.2 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_96KHZ:
+                clock_source = "Internal 96 kHz";
+                break;
+        default:
+                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:
-                requested_sync_ref = "Word";
+                pref_sync_ref = "Word Clock";
                 break;
         case HDSP_SYNC_FROM_ADAT_SYNC:
-                requested_sync_ref = "ADAT Sync";
+                pref_sync_ref = "ADAT Sync";
                 break;
         case HDSP_SYNC_FROM_SPDIF:
-                requested_sync_ref = "SPDIF";
+                pref_sync_ref = "SPDIF";
                 break;
         case HDSP_SYNC_FROM_ADAT1:
-                requested_sync_ref = "ADAT1";
+                pref_sync_ref = "ADAT1";
                 break;
         case HDSP_SYNC_FROM_ADAT2:
-                requested_sync_ref = "ADAT2";
+                pref_sync_ref = "ADAT2";
                 break;
         case HDSP_SYNC_FROM_ADAT3:
-                requested_sync_ref = "ADAT3";
-                break;
-        case HDSP_SYNC_FROM_SELF:
+                pref_sync_ref = "ADAT3";
+                break;
         default:
-                requested_sync_ref = "Master";
-                break;
-        }
-
-        if ((hdsp->control_register & HDSP_ClockModeMaster)) {
-                snd_iprintf (buffer, "Sync reference: %s/Master (chosen)\n", requested_sync_ref);
-        } else if (hdsp_system_sample_rate(hdsp) == 0) {
-                snd_iprintf (buffer, "Sync reference: %s/Master (forced)\n", requested_sync_ref);
-        } else {
-                switch (status2 & HDSP_SelSyncRefMask) {
-                case HDSP_SelSyncRef_ADAT1:
-                        snd_iprintf (buffer, "Sync reference: %s/ADAT1\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_ADAT2:
-                        snd_iprintf (buffer, "Sync reference: %s/ADAT2\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_ADAT3:
-                        snd_iprintf (buffer, "Sync reference: %s/ADAT3\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_SPDIF:
-                        snd_iprintf (buffer, "Sync reference: %s/SPDIF\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_WORD:
-                        snd_iprintf (buffer, "Sync reference: %s/WORD\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_ADAT_SYNC:
-                        snd_iprintf (buffer, "Sync reference: %s/ADAT Sync\n", requested_sync_ref);
-                        break;
-                default:
-                        snd_iprintf (buffer, "Sync reference: %s/Master (fallback)\n", requested_sync_ref);
-                        break;
-                }
-        }
-        snd_iprintf (buffer, "Sample rate: %d\n", hdsp_system_sample_rate(hdsp));
-
+                pref_sync_ref = "Word Clock";
+                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";
+                break;
+        case HDSP_AUTOSYNC_FROM_ADAT_SYNC:
+                autosync_ref = "ADAT Sync";
+                break;
+        case HDSP_AUTOSYNC_FROM_SPDIF:
+                autosync_ref = "SPDIF";
+                break;
+        case HDSP_AUTOSYNC_FROM_NONE:
+                autosync_ref = "None";
+                break;  
+        case HDSP_AUTOSYNC_FROM_ADAT1:
+                autosync_ref = "ADAT1";
+                break;
+        case HDSP_AUTOSYNC_FROM_ADAT2:
+                autosync_ref = "ADAT2";
+                break;
+        case HDSP_AUTOSYNC_FROM_ADAT3:
+                autosync_ref = "ADAT3";
+                break;
+        default:
+                autosync_ref = "---";
+                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, "\n");
 
@@ -2005 +2837 @@
                 snd_iprintf(buffer, "IEC958 NonAudio: off\n");
         }
-
-        snd_iprintf(buffer, "\n");
-
         if ((x = hdsp_spdif_sample_rate (hdsp)) != 0) {
                 snd_iprintf (buffer, "IEC958 sample rate: %d\n", x);
@@ -2024 +2853 @@
         }
 
-        x = status & HDSP_Sync1;
-        if (status & HDSP_Lock1) {
-                snd_iprintf(buffer, "ADAT2: %s\n", x ? "Sync" : "Lock");
-        } else {
-                snd_iprintf(buffer, "ADAT2: No Lock\n");
-        }
-
-        if (hdsp->type == Digiface) {
+        switch (hdsp->io_type) {
+        case Digiface:
+                x = status & HDSP_Sync1;
+                if (status & HDSP_Lock1) {
+                        snd_iprintf(buffer, "ADAT2: %s\n", x ? "Sync" : "Lock");
+                } else {
+                        snd_iprintf(buffer, "ADAT2: No Lock\n");
+                }
                 x = status & HDSP_Sync2;
                 if (status & HDSP_Lock2) {
@@ -2038 +2867 @@
                         snd_iprintf(buffer, "ADAT3: No Lock\n");
                 }
+        default:
+                /* relax */
+                break;
+        }
+
+        x = status & HDSP_SPDIFSync;
+        if (status & HDSP_SPDIFErrorFlag) {
+                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");
+        } else {
+                snd_iprintf(buffer, "ADAT Sync: No Lock\n");
         }
 
@@ -2054 +2907 @@
         snd_info_entry_t *entry;
 
-        if ((entry = snd_info_create_card_entry(hdsp->card, "hdsp", hdsp->card->proc_root)) !=
-            NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = hdsp;
-                entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 256;
-                entry->c.text.read = snd_hdsp_proc_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        hdsp->proc_entry = entry;
-}
-
-static void snd_hdsp_proc_done(hdsp_t *hdsp)
-{
-        if (hdsp->proc_entry) {
-                snd_info_unregister(hdsp->proc_entry);
-                hdsp->proc_entry = NULL;
-        }
+        if (! snd_card_proc_new(hdsp->card, "hdsp", &entry))
+                snd_info_set_text_ops(entry, hdsp, snd_hdsp_proc_read);
 }
 
@@ -2159 +2993 @@
 }
 
-static void snd_hdsp_set_defaults(hdsp_t *hdsp)
+static int snd_hdsp_set_defaults(hdsp_t *hdsp)
 {
         unsigned int i;
@@ -2192 +3026 @@
         }
 
-        for (i = 0; i < 2048; i++)
-                hdsp_write_gain (hdsp, i, MINUS_INFINITY_GAIN);
-
-        if (line_outs_monitor[hdsp->dev]) {
+        for (i = 0; i < (hdsp_is_9652(hdsp) ? 1352 : HDSP_MATRIX_MIXER_SIZE); i++) {
+                if (hdsp_write_gain (hdsp, i, MINUS_INFINITY_GAIN)) {
+                        return -EIO;
+                }
+        }
+        
+        if (!hdsp_is_9652(hdsp) && line_outs_monitor[hdsp->dev]) {
                 
                 snd_printk ("sending all inputs and playback streams to line outs.\n");
@@ -2205 +3042 @@
                 for (i = 0; i < HDSP_MAX_CHANNELS; i++) {
                         if (i & 1) { 
-                                hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY (i, 26), UNITY_GAIN);
-                                hdsp_write_gain (hdsp, PLAYBACK_TO_OUTPUT_KEY (i, 26), UNITY_GAIN);
+                                if (hdsp_write_gain (hdsp, hdsp_input_to_output_key (hdsp, i, 26), UNITY_GAIN) ||
+                                    hdsp_write_gain (hdsp, hdsp_playback_to_output_key (hdsp, i, 26), UNITY_GAIN)) {
+                                    return -EIO;
+                                }    
                         } else {
-                                hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY (i, 27), UNITY_GAIN);
-                                hdsp_write_gain (hdsp, PLAYBACK_TO_OUTPUT_KEY (i, 27), UNITY_GAIN);
+                                if (hdsp_write_gain (hdsp, hdsp_input_to_output_key (hdsp, i, 27), UNITY_GAIN) ||
+                                    hdsp_write_gain (hdsp, hdsp_playback_to_output_key (hdsp, i, 27), UNITY_GAIN)) {
+                                    return -EIO;
+                                }
                         }
                 }
@@ -2219 +3060 @@
          */
 
-        hdsp_set_rate(hdsp, 48000);
-}
-
-void snd_hdsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+        hdsp_set_rate(hdsp, 48000, 1);
+
+        return 0;
+}
+
+void hdsp_midi_tasklet(unsigned long arg)
+{
+        hdsp_t *hdsp = (hdsp_t *)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, struct pt_regs *regs)
 {
         hdsp_t *hdsp = (hdsp_t *) dev_id;
@@ -2231 +3086 @@
         unsigned int midi0status;
         unsigned int midi1status;
-
+        int schedule = 0;
+        
         status = hdsp_read(hdsp, HDSP_statusRegister);
 
@@ -2239 +3095 @@
 
         if (!audio && !midi0 && !midi1) {
-                return;
+                return IRQ_NONE;
         }
 
@@ -2246 +3102 @@
         midi0status = hdsp_read (hdsp, HDSP_midiStatusIn0) & 0xff;
         midi1status = hdsp_read (hdsp, HDSP_midiStatusIn1) & 0xff;
-
+        
         if (audio) {
                 if (hdsp->capture_substream) {
@@ -2256 +3112 @@
                 }
         }
-
-        /* note: snd_hdsp_midi_input_read() calls output_write() because
-           output is not interrupt-driven ...
-        */
-
-        if (midi0status)
-                snd_hdsp_midi_input_read (&hdsp->midi[0]);
-        if (midi1status)
-                snd_hdsp_midi_input_read (&hdsp->midi[1]);
+        
+        if (midi0 && midi0status) {
+                /* we disable interrupts for this input until processing is done */
+                hdsp->control_register &= ~HDSP_Midi0InterruptEnable;
+                hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+                hdsp->midi[0].pending = 1;
+                schedule = 1;
+        }
+        if (midi1 && midi1status) {
+                /* we disable interrupts for this input until processing is done */
+                hdsp->control_register &= ~HDSP_Midi1InterruptEnable;
+                hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+                hdsp->midi[1].pending = 1;
+                schedule = 1;
+        }
+        if (schedule)
+            tasklet_hi_schedule(&hdsp->midi_tasklet);
+        return IRQ_HANDLED;
 }
 
@@ -2303 +3168 @@
         channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
         snd_assert(channel_buf != NULL, return -EIO);
-        if (copy_from_user(channel_buf + pos * 4, src, count * 4))
-                return -EFAULT;
+        copy_from_user(channel_buf + pos * 4, src, count * 4);
         return count;
 }
@@ -2318 +3182 @@
         channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
         snd_assert(channel_buf != NULL, return -EIO);
-        if (copy_to_user(dst, channel_buf + pos * 4, count * 4))
-                return -EFAULT;
+        copy_to_user(dst, channel_buf + pos * 4, count * 4);
         return count;
 }
@@ -2349 +3212 @@
                 runtime->status->hw_ptr = 0;
         if (other) {
-                snd_pcm_substream_t *s = substream;
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
                 snd_pcm_runtime_t *oruntime = other->runtime;
-                do {
-                        s = s->link_next;
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == other) {
                                 oruntime->status->hw_ptr = runtime->status->hw_ptr;
                                 break;
                         }
-                } while (s != substream);
+                }
         }
         return 0;
@@ -2371 +3235 @@
 
         if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
                 return -EIO;
         }
@@ -2393 +3268 @@
                  */
 
-                if ((int)params_rate(params) != hdsp_system_sample_rate(hdsp)) {
+                if (params_rate(params) != hdsp->system_sample_rate) {
                         spin_unlock_irq(&hdsp->lock);
                         _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
@@ -2417 +3292 @@
          */
 
-        if ((err = hdsp_set_rate(hdsp, params_rate(params))) < 0) {
+        if ((err = hdsp_set_rate(hdsp, params_rate(params), 0)) < 0) {
                 _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
                 return err;
@@ -2434 +3309 @@
 {
         hdsp_t *hdsp = _snd_pcm_substream_chip(substream);
-        int chn;
+        int mapped_channel;
 
         snd_assert(info->channel < HDSP_MAX_CHANNELS, return -EINVAL);
 
-        if ((chn = hdsp->channel_map[info->channel]) < 0) {
+        if ((mapped_channel = hdsp->channel_map[info->channel]) < 0) {
                 return -EINVAL;
         }
 
-        info->offset = chn * HDSP_CHANNEL_BUFFER_BYTES;
+        info->offset = mapped_channel * HDSP_CHANNEL_BUFFER_BYTES;
         info->first = 0;
         info->step = 32;
@@ -2475 +3350 @@
         
         if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
                 return -EIO;
         }
@@ -2498 +3384 @@
 
         if (other) {
-                snd_pcm_substream_t *s = substream;
-                do {
-                        s = s->link_next;
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == other) {
                                 snd_pcm_trigger_done(s, substream);
@@ -2509 +3396 @@
                                 goto _ok;
                         }
-                } while (s != substream);
+                }
                 if (cmd == SNDRV_PCM_TRIGGER_START) {
                         if (!(running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) &&
@@ -2541 +3428 @@
 
         if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
                 return -EIO;
         }
@@ -2567 +3465 @@
         .rate_min =             32000,
         .rate_max =             96000,
-        .channels_min =         10,
+        .channels_min =         14,
         .channels_max =         HDSP_MAX_CHANNELS,
         .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
-        .period_bytes_min =     (64 * 4) *10,
+        .period_bytes_min =     (64 * 4) * 10,
         .period_bytes_max =     (8192 * 4) * HDSP_MAX_CHANNELS,
         .periods_min =          2,
         .periods_max =          2,
-        .fifo_size =            0,
+        .fifo_size =            0
 };
 
@@ -2592 +3490 @@
         .rate_min =             32000,
         .rate_max =             96000,
-        .channels_min =         10,
+        .channels_min =         14,
         .channels_max =         HDSP_MAX_CHANNELS,
         .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
@@ -2599 +3497 @@
         .periods_min =          2,
         .periods_max =          2,
-        .fifo_size =            0,
+        .fifo_size =            0
 };
 
@@ -2679 +3577 @@
         }
 
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
+                return -EIO;
+        }
+
         spin_lock_irqsave(&hdsp->lock, flags);
 
@@ -2710 +3619 @@
 
         hdsp->creg_spdif_stream = hdsp->creg_spdif;
-        hdsp->spdif_ctl->access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        hdsp->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
         snd_ctl_notify(hdsp->card, SNDRV_CTL_EVENT_MASK_VALUE |
                        SNDRV_CTL_EVENT_MASK_INFO, &hdsp->spdif_ctl->id);
@@ -2728 +3637 @@
         spin_unlock_irqrestore(&hdsp->lock, flags);
 
-        hdsp->spdif_ctl->access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        hdsp->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
         snd_ctl_notify(hdsp->card, SNDRV_CTL_EVENT_MASK_VALUE |
                        SNDRV_CTL_EVENT_MASK_INFO, &hdsp->spdif_ctl->id);
@@ -2742 +3651 @@
 
         if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
                 return -EIO;
         }
@@ -2791 +3711 @@
 }
 
+static int snd_hdsp_hwdep_dummy_op(snd_hwdep_t *hw, struct file *file)
+{
+    /* we have nothing to initialize but the call is required */
+    return 0;
+}
+
+
+static int snd_hdsp_hwdep_ioctl(snd_hwdep_t *hw, struct file *file, unsigned int cmd, unsigned long arg)
+{
+        hdsp_t *hdsp = (hdsp_t *)hw->private_data;      
+        hdsp_peak_rms_t *peak_rms;
+        hdsp_firmware_t *firmware;
+        hdsp_mixer_t    *mixer;
+        hdsp_config_info_t info;
+        hdsp_version_t hdsp_version;
+        int i;
+        int err;
+        unsigned long flags;
+        
+        switch (cmd) {
+        case SNDRV_HDSP_IOCTL_GET_PEAK_RMS:
+                if (!(hdsp->state & HDSP_FirmwareLoaded)) {
+                        snd_printk("firmware needs to be uploaded to the card.\n");     
+                        return -EINVAL;
+                }
+                peak_rms = (hdsp_peak_rms_t *)arg;
+                if (copy_to_user_fromio((void *)peak_rms->playback_peaks, hdsp->iobase+HDSP_playbackPeakLevel, 26*4) != 0) {
+                        return -EFAULT;
+                }
+                if (copy_to_user_fromio((void *)peak_rms->input_peaks, hdsp->iobase+HDSP_inputPeakLevel, 26*4) != 0) {
+                        return -EFAULT;
+                }
+                if (copy_to_user_fromio((void *)peak_rms->output_peaks, hdsp->iobase+HDSP_outputPeakLevel, 28*4) != 0) {
+                        return -EFAULT;
+                }
+                if (copy_to_user_fromio((void *)peak_rms->playback_rms, hdsp->iobase+HDSP_playbackRmsLevel, 26*8) != 0) {
+                        return -EFAULT;
+                }
+                if (copy_to_user_fromio((void *)peak_rms->input_rms, hdsp->iobase+HDSP_inputRmsLevel, 26*8) != 0) {
+                        return -EFAULT;
+                }
+                break;
+        case SNDRV_HDSP_IOCTL_GET_CONFIG_INFO:
+                if (!(hdsp->state & HDSP_FirmwareLoaded)) {
+                        snd_printk("Firmware needs to be uploaded to the card.\n");     
+                        return -EINVAL;
+                }
+                spin_lock_irqsave(&hdsp->lock, flags);
+                info.pref_sync_ref = (unsigned char)hdsp_pref_sync_ref(hdsp);
+                info.wordclock_sync_check = (unsigned char)hdsp_wc_sync_check(hdsp);
+                info.adatsync_sync_check = (unsigned char)hdsp_adatsync_sync_check(hdsp);
+                info.spdif_sync_check = (unsigned char)hdsp_spdif_sync_check(hdsp);
+                for (i = 0; i < ((hdsp->io_type != Multiface) ? 3 : 1); ++i) {
+                        info.adat_sync_check[i] = (unsigned char)hdsp_adat_sync_check(hdsp, i);
+                }
+                info.spdif_in = (unsigned char)hdsp_spdif_in(hdsp);
+                info.spdif_out = (unsigned char)hdsp_spdif_out(hdsp);
+                info.spdif_professional = (unsigned char)hdsp_spdif_professional(hdsp);
+                info.spdif_emphasis = (unsigned char)hdsp_spdif_emphasis(hdsp);
+                info.spdif_nonaudio = (unsigned char)hdsp_spdif_nonaudio(hdsp);
+                info.spdif_sample_rate = hdsp_spdif_sample_rate(hdsp);
+                info.system_sample_rate = hdsp->system_sample_rate;
+                info.autosync_sample_rate = hdsp_external_sample_rate(hdsp);
+                info.system_clock_mode = (unsigned char)hdsp_system_clock_mode(hdsp);
+                info.clock_source = (unsigned char)hdsp_clock_source(hdsp);
+                info.autosync_ref = (unsigned char)hdsp_autosync_ref(hdsp);
+                info.line_out = (unsigned char)hdsp_line_out(hdsp);
+                info.passthru = (unsigned char)hdsp->passthru;
+                spin_unlock_irqrestore(&hdsp->lock, flags);
+                if (copy_to_user((void *)arg, &info, sizeof(info)))
+                        return -EFAULT;
+                break;
+        case SNDRV_HDSP_IOCTL_GET_VERSION:
+                if (hdsp_is_9652(hdsp)) return -EINVAL;
+                if (hdsp->io_type == Undefined) {
+                        if ((err = hdsp_get_iobox_version(hdsp)) < 0) {
+                                return err;
+                        }
+                }
+                hdsp_version.io_type = hdsp->io_type;
+                hdsp_version.firmware_rev = hdsp->firmware_rev;
+                if ((err = copy_to_user((void *)arg, &hdsp_version, sizeof(hdsp_version)))) {
+                        return -EFAULT;
+                }
+                break;
+        case SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE:
+                if (hdsp_is_9652(hdsp)) return -EINVAL;
+                /* SNDRV_HDSP_IOCTL_GET_VERSION must have been called */
+                if (hdsp->io_type == Undefined) return -EINVAL;
+
+                snd_printk("initializing firmware upload\n");
+                firmware = (hdsp_firmware_t *)arg;
+
+                if (hdsp_check_for_iobox (hdsp)) {
+                        return -EIO;
+                }
+
+                if (copy_from_user(hdsp->firmware_cache, firmware->firmware_data, sizeof(unsigned long)*24413) != 0) {
+                        return -EFAULT;
+                }
+                
+                hdsp->state |= HDSP_FirmwareCached;
+
+                if ((err = snd_hdsp_load_firmware_from_cache(hdsp)) < 0) {
+                        return err;
+                }
+                
+                
+                if (!(hdsp->state & HDSP_InitializationComplete)) {
+                        snd_hdsp_initialize_channels(hdsp);
+                
+                        snd_hdsp_initialize_midi_flush(hdsp);
+            
+                        if ((err = snd_hdsp_create_alsa_devices(hdsp->card, hdsp)) < 0) {
+                                snd_printk("error creating alsa devices\n");
+                            return err;
+                        }
+                }
+                break;
+        case SNDRV_HDSP_IOCTL_GET_MIXER:
+                mixer = (hdsp_mixer_t *)arg;
+                if (copy_to_user(mixer->matrix, hdsp->mixer_matrix, sizeof(unsigned short)*HDSP_MATRIX_MIXER_SIZE))
+                        return -EFAULT;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
 static snd_pcm_ops_t snd_hdsp_playback_ops = {
         .open =         snd_hdsp_playback_open,
@@ -2814 +3864 @@
 };
 
+static int __devinit snd_hdsp_create_hwdep(snd_card_t *card,
+                                           hdsp_t *hdsp)
+{
+        snd_hwdep_t *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;
+}
+
 static int __devinit snd_hdsp_create_pcm(snd_card_t *card,
                                          hdsp_t *hdsp)
@@ -2835 +3905 @@
 }
 
-static int __devinit snd_hdsp_initialize_firmware (hdsp_t *hdsp)
+static inline int snd_hdsp_initialize_input_enable (hdsp_t *hdsp)
 {
         int i;
-        u32 *firmware_ptr;
-
-        if (hdsp_check_for_iobox (hdsp)) {
-                return -EIO;
-        }
-
+        
         if (hdsp_fifo_wait (hdsp, 0, 100)) {
                 return -EIO;
         }
         
-        /* enable all channels */
-
         for (i = 0; i < HDSP_MAX_CHANNELS; ++i) {
                 hdsp_write (hdsp, HDSP_inputEnable + (4 * i), 1);
                 hdsp_write (hdsp, HDSP_outputEnable + (4 * i), 1);
         }
-
-        if (force_firmware[hdsp->dev] || (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
-
-                snd_printk ("loading firmware\n");
-
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_PROGRAM);
-                hdsp_write (hdsp, HDSP_fifoData, 0);
-                if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT) < 0) {
-                        snd_printk ("timeout waiting for firmware setup\n");
-                        return -EIO;
-                }
-
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
-                hdsp_write (hdsp, HDSP_fifoData, 0);
-
-                if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT)) {
-                        hdsp->type = Multiface;
-                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_VERSION_BIT);
-                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
-                        hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT);
-                } else {
-                        hdsp->type = Digiface;
-                } 
-
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_PROGRAM);
-                hdsp_write (hdsp, HDSP_fifoData, 0);
-                
-                if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
-                        snd_printk ("timeout waiting for download preparation\n");
-                        return -EIO;
-                }
-                
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
-                
-                if (hdsp->type == Digiface) {
-                        firmware_ptr = (u32 *) digiface_firmware;
-                } else {
-                        firmware_ptr = (u32 *) multiface_firmware;
-                }
-                
-                for (i = 0; i < 24413; ++i) {
-                        hdsp_write(hdsp, HDSP_fifoData, firmware_ptr[i]);
-                        if (hdsp_fifo_wait (hdsp, 127, HDSP_LONG_WAIT)) {
-                                snd_printk ("timeout during firmware loading\n");
-                                return -EIO;
-                        }
-                }
-                
-                if (hdsp_fifo_wait (hdsp, 3, HDSP_LONG_WAIT)) {
-                        snd_printk ("timeout at end of firmware loading\n");
-                        return -EIO;
-                }
-
-        } else {
-
-                /* firmware already loaded, but we need to know what type
-                   of I/O box is connected.
-                */
-
-                if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1) {
-                        hdsp->type = Multiface;
-                } else {
-                        hdsp->type = Digiface;
-                }
-        }
-
-        if (hdsp->type == Digiface) {
-                snd_printk ("I/O Box is a Digiface\n");
-                hdsp->card_name = "RME Hammerfall DSP (Digiface)";
+        
+        return 0;
+}
+
+static inline void snd_hdsp_initialize_channels(hdsp_t *hdsp)
+{
+        if (hdsp->io_type == Digiface) {
+                hdsp->card_name = "RME Hammerfall DSP + Digiface";
                 hdsp->ss_channels = DIGIFACE_SS_CHANNELS;
                 hdsp->ds_channels = DIGIFACE_DS_CHANNELS;
         } else {
-                snd_printk ("I/O Box is a Multiface\n");
-                hdsp->card_name = "RME Hammerfall DSP (Multiface)";
+                hdsp->card_name = "RME Hammerfall DSP + Multiface";
                 hdsp->ss_channels = MULTIFACE_SS_CHANNELS;
                 hdsp->ds_channels = MULTIFACE_DS_CHANNELS;
         }
-        
+}
+
+static inline void snd_hdsp_initialize_midi_flush (hdsp_t *hdsp)
+{
         snd_hdsp_flush_midi_input (hdsp, 0);
         snd_hdsp_flush_midi_input (hdsp, 1);
@@ -2938 +3942 @@
         hdsp_write(hdsp, HDSP_jtagReg, HDSP_BIGENDIAN_MODE);
 #endif
-
+}
+
+static int __devinit snd_hdsp_create_alsa_devices(snd_card_t *card, hdsp_t *hdsp)
+{
+        int err;
+        
+        if ((err = snd_hdsp_create_pcm(card, hdsp)) < 0) {
+                return err;
+        }
+        
+        if ((err = snd_hdsp_create_midi(card, hdsp, 0)) < 0) {
+                return err;
+        }
+
+        if ((err = snd_hdsp_create_midi(card, hdsp, 1)) < 0) {
+                return err;
+        }
+
+        if ((err = snd_hdsp_create_controls(card, hdsp)) < 0) {
+                return err;
+        }
+
+        snd_hdsp_proc_init(hdsp);
+
+        hdsp->last_spdif_sample_rate = -1;
+        hdsp->system_sample_rate = -1;
+        hdsp->last_external_sample_rate = -1;
+        hdsp->last_internal_sample_rate = -1;
+        hdsp->playback_pid = -1;
+        hdsp->capture_pid = -1;
+        hdsp->capture_substream = NULL;
+        hdsp->playback_substream = NULL;
+
+        if ((err = snd_hdsp_set_defaults(hdsp)) < 0) {
+                return err;
+        }
+        
+        hdsp_update_simple_mixer_controls(hdsp);
+        
+        if (!(hdsp->state & HDSP_InitializationComplete)) {
+                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("error registering card\n");
+                        return err;
+                }
+                hdsp->state |= HDSP_InitializationComplete;
+        }
+        
         return 0;
 }
@@ -2948 +4001 @@
         struct pci_dev *pci = hdsp->pci;
         int err;
-        unsigned short rev;
+        int i;
 
         hdsp->irq = -1;
+        hdsp->state = 0;
         hdsp->midi[0].rmidi = 0;
         hdsp->midi[1].rmidi = 0;
@@ -2961 +4015 @@
         hdsp->iobase = 0;
         hdsp->res_port = 0;
+        hdsp->io_type = Undefined;
+        for (i = 0; i < HDSP_MAX_CHANNELS; ++i)
+                hdsp->playback_mixer_ctls[i] = 0;
 
         hdsp->card = card;
@@ -2966 +4023 @@
         spin_lock_init(&hdsp->lock);
 
-        pci_read_config_word(hdsp->pci, PCI_CLASS_REVISION, &rev);
+        tasklet_init(&hdsp->midi_tasklet, hdsp_midi_tasklet, (unsigned long)hdsp);
+        
+        pci_read_config_word(hdsp->pci, PCI_CLASS_REVISION, &hdsp->firmware_rev);
         strcpy(card->driver, "H-DSP");
         strcpy(card->mixername, "Xilinx FPGA");
         
-        switch (rev & 0xff) {
+        switch (hdsp->firmware_rev & 0xff) {
         case 0xa:
         case 0xb:
+                hdsp->card_name = "RME Hammerfall DSP";
+                break;
         case 0x64:
-                /* hdsp_initialize_firmware() will reset this */
-                hdsp->card_name = "RME Hammerfall DSP";
-                break;
-
+        case 0x65:
+        case 0x68:
+                hdsp->card_name = "RME HDSP 9652";
+                break;
         default:
                 return -ENODEV;
@@ -3010 +4071 @@
                 return err;
         }
-
-        if ((err = snd_hdsp_initialize_firmware(hdsp)) < 0) {
+        
+        if (hdsp_is_9652(hdsp)) {
+                
+                if ((err = snd_hdsp_initialize_input_enable(hdsp)) != 0) {
+                        return err;
+                }
+
+                hdsp->io_type = Digiface;               
+        
+                hdsp->ss_channels = DIGIFACE_SS_CHANNELS;
+                hdsp->ds_channels = DIGIFACE_DS_CHANNELS;
+        
+                snd_hdsp_initialize_midi_flush(hdsp);
+        
+                if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
+                        return err;
+                }
+
+        } else {
+        
+                if (hdsp_check_for_iobox (hdsp)) {
+                        /* no iobox connected, we defer initialization */
+                        snd_printk("card initialization pending : waiting for firmware\n");
+                        if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
+                                return err;
+                        }
+                        return 0;
+                }
+
+                if ((err = snd_hdsp_initialize_input_enable(hdsp)) != 0) {
+                        return err;
+                }
+                
+                if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
+                        snd_printk("card initialization pending : waiting for firmware\n");
+                        if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
+                                return err;
+                        }
+                return 0;
+                } 
+                
+                snd_printk("Firmware already loaded, initializing card.\n");
+
+                if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1) {
+                        hdsp->io_type = Multiface;
+                } else {
+                        hdsp->io_type = Digiface;
+                }
+                
+                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;     
+        
+        if ((err = snd_hdsp_create_alsa_devices(card, hdsp)) < 0) {
                 return err;
         }
-
-        if ((err = snd_hdsp_create_pcm(card, hdsp)) < 0) {
-                return err;
-        }
-
-        if ((err = snd_hdsp_create_midi(card, hdsp, 0)) < 0) {
-                return err;
-        }
-
-        if ((err = snd_hdsp_create_midi(card, hdsp, 1)) < 0) {
-                return err;
-        }
-
-        if ((err = snd_hdsp_create_controls(card, hdsp)) < 0) {
-                return err;
-        }
-
-        snd_hdsp_proc_init(hdsp);
-
-        hdsp->last_spdif_sample_rate = -1;
-        hdsp->last_adat_sample_rate = -1;
-        hdsp->playback_pid = -1;
-        hdsp->capture_pid = -1;
-        hdsp->capture_substream = NULL;
-        hdsp->playback_substream = NULL;
-
-        snd_hdsp_set_defaults(hdsp);
-
-        return 0;
+        
+        return 0;       
 }
 
 static int snd_hdsp_free(hdsp_t *hdsp)
 {
-        /* stop the audio, and cancel all interrupts */
-        hdsp->control_register &= ~(HDSP_Start|HDSP_AudioInterruptEnable|HDSP_Midi0InterruptEnable|HDSP_Midi1InterruptEnable);
-        hdsp_write (hdsp, HDSP_controlRegister, hdsp->control_register);
+        if (hdsp->res_port) {
+                /* stop the audio, and cancel all interrupts */
+                hdsp->control_register &= ~(HDSP_Start|HDSP_AudioInterruptEnable|HDSP_Midi0InterruptEnable|HDSP_Midi1InterruptEnable);
+                hdsp_write (hdsp, HDSP_controlRegister, hdsp->control_register);
+        }
 
         if (hdsp->irq >= 0)
                 free_irq(hdsp->irq, (void *)hdsp);
 
-        snd_hdsp_proc_done(hdsp);
         snd_hdsp_free_buffers(hdsp);
         
@@ -3124 +4219 @@
 
 static struct pci_driver driver = {
-        .name = "RME Hammerfall DSP",
+        .name =     "RME Hammerfall DSP",
         .id_table = snd_hdsp_ids,
-        .probe = snd_hdsp_probe,
+        .probe =    snd_hdsp_probe,
         .remove = __devexit_p(snd_hdsp_remove),
 };

GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/rme9652.c

@@ -1947 +1947 @@
 }
 
-void snd_rme9652_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_rme9652_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         rme9652_t *rme9652 = (rme9652_t *) dev_id;
 
         if (!(rme9652_read(rme9652, RME9652_status_register) & RME9652_IRQ)) {
-                return;
+                return IRQ_NONE;
         }
 
@@ -1964 +1964 @@
                 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
         }
+        return IRQ_HANDLED;
 }
 
@@ -2054 +2055 @@
                 runtime->status->hw_ptr = 0;
         if (other) {
-                snd_pcm_substream_t *s = substream;
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
                 snd_pcm_runtime_t *oruntime = other->runtime;
-                do {
-                        s = s->link_next;
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == other) {
                                 oruntime->status->hw_ptr = runtime->status->hw_ptr;
                                 break;
                         }
-                } while (s != substream);
+                }
         }
         return 0;
@@ -2200 +2202 @@
 
         if (other) {
-                snd_pcm_substream_t *s = substream;
-                do {
-                        s = s->link_next;
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == other) {
                                 snd_pcm_trigger_done(s, substream);
@@ -2211 +2214 @@
                                 goto _ok;
                         }
-                } while (s != substream);
+                }
                 if (cmd == SNDRV_PCM_TRIGGER_START) {
                         if (!(running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) &&
@@ -2405 +2408 @@
 
         rme9652->creg_spdif_stream = rme9652->creg_spdif;
-        rme9652->spdif_ctl->access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        rme9652->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
         snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
                        SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);
@@ -2423 +2426 @@
         spin_unlock_irqrestore(&rme9652->lock, flags);
 
-        rme9652->spdif_ctl->access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        rme9652->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
         snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
                        SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);

GPL/branches/alsa-resync1/alsa-kernel/pci/sonicvibes.c

@@ -602 +602 @@
 }
 
-static void snd_sonicvibes_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        sonicvibes_t *sonic = snd_magic_cast(sonicvibes_t, dev_id, return);
+static irqreturn_t snd_sonicvibes_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        sonicvibes_t *sonic = snd_magic_cast(sonicvibes_t, dev_id, return IRQ_NONE);
         unsigned char status;
 
         status = inb(SV_REG(sonic, STATUS));
         if (!(status & (SV_DMAA_IRQ | SV_DMAC_IRQ | SV_MIDI_IRQ)))
-                return;
+                return IRQ_NONE;
         if (status == 0xff) {   /* failure */
                 outb(sonic->irqmask = ~0, SV_REG(sonic, IRQMASK));
                 snd_printk("IRQ failure - interrupts disabled!!\n");
-                return;
+                return IRQ_HANDLED;
         }
         if (sonic->pcm) {
@@ -660 +660 @@
                 snd_ctl_notify(sonic->card, SNDRV_CTL_EVENT_MASK_VALUE, &sonic->master_volume->id);
         }
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/pci/trident/trident_main.c

@@ -2715 +2715 @@
         .name =         "PCM Front Playback Volume",
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
+        .count =        32,
         .info =         snd_trident_pcm_vol_control_info,
         .get =          snd_trident_pcm_vol_control_get,
@@ -2776 +2777 @@
         .name =         "PCM Pan Playback Control",
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
+        .count =        32,
         .info =         snd_trident_pcm_pan_control_info,
         .get =          snd_trident_pcm_pan_control_get,
@@ -2829 +2831 @@
         .name =         "PCM Reverb Playback Volume",
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
+        .count =        32,
         .info =         snd_trident_pcm_rvol_control_info,
         .get =          snd_trident_pcm_rvol_control_get,

GPL/branches/alsa-resync1/alsa-kernel/pci/ymfpci/ymfpci_main.c

@@ -1368 +1368 @@
 {
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
-        .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
-        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
         .info =         snd_ymfpci_spdif_stream_info,
         .get =          snd_ymfpci_spdif_stream_get,