Changeset 348

Timestamp:

04/21/08 02:52:19 (7 months ago)

Author:

gentux2

Message:

alsa-resync1 branch merged to ALSA 1.0.4

Location:

GPL/branches/alsa-resync1/alsa-kernel

Files:

• core/init.c (modified) (2 diffs)
• core/memalloc.c (modified) (8 diffs)
• core/pcm.c (modified) (1 diff)
• core/pcm_lib.c (modified) (4 diffs)
• core/sgbuf.c (modified) (7 diffs)
• drivers/dummy.c (modified) (2 diffs)
• drivers/mpu401/mpu401.c (modified) (11 diffs)
• drivers/serial-u16550.c (modified) (2 diffs)
• include/sound/adriver.h (modified) (6 diffs)
• include/sound/compat_22.h (modified) (5 diffs)
• include/sound/core.h (modified) (1 diff)
• include/sound/memalloc.h (modified) (5 diffs)
• include/sound/version.h (modified) (1 diff)
• isa/ad1816a/ad1816a_lib.c (modified) (1 diff)
• isa/ad1848/ad1848_lib.c (modified) (1 diff)
• isa/cmi8330.c (modified) (1 diff)
• isa/cs423x/cs4231_lib.c (modified) (1 diff)
• isa/dt019x.c (modified) (3 diffs)
• isa/es1688/es1688.c (modified) (2 diffs)
• isa/es1688/es1688_lib.c (modified) (1 diff)
• isa/es18xx.c (modified) (3 diffs)
• isa/gus/gus_pcm.c (modified) (2 diffs)
• isa/gus/gusclassic.c (modified) (2 diffs)
• isa/gus/gusextreme.c (modified) (9 diffs)
• isa/gus/gusmax.c (modified) (2 diffs)
• isa/gus/interwave.c (modified) (2 diffs)
• isa/opti9xx/opti92x-ad1848.c (modified) (7 diffs)
• isa/sb/es968.c (modified) (1 diff)
• isa/sb/sb16.c (modified) (2 diffs)
• isa/sb/sb16_main.c (modified) (1 diff)
• isa/sb/sb8.c (modified) (2 diffs)
• isa/sb/sb8_main.c (modified) (1 diff)
• pci/ac97/ac97_patch.c (modified) (1 diff)
• pci/emu10k1/emu10k1.c (modified) (1 diff)
• pci/emu10k1/emu10k1_callback.c (modified) (1 diff)
• pci/emu10k1/emufx.c (modified) (1 diff)
• pci/ice1712/aureon.c (modified) (1 diff)
• pci/ice1712/delta.c (modified) (3 diffs)
• pci/ice1712/ews.c (modified) (2 diffs)
• pci/ice1712/hoontech.c (modified) (1 diff)
• pci/ice1712/ice1712.c (modified) (14 diffs)
• pci/ice1712/ice1712.h (modified) (2 diffs)
• pci/ice1712/ice1724.c (modified) (3 diffs)
• pci/ice1712/revo.c (modified) (1 diff)
• pci/intel8x0.c (modified) (5 diffs)
• pci/korg1212/korg1212.c (modified) (13 diffs)
• pci/rme96.c (modified) (2 diffs)
• pci/rme9652/hdsp.c (modified) (2 diffs)
• pci/rme9652/rme9652.c (modified) (2 diffs)
• pci/sonicvibes.c (modified) (1 diff)
• pci/trident/trident_main.c (modified) (1 diff)
• pci/trident/trident_memory.c (modified) (2 diffs)

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

@@ -86 +86 @@
                 strlcpy(card->id, xid, sizeof(card->id));
         }
+        err = 0;
         write_lock(&snd_card_rwlock);
         if (idx < 0) {
@@ -101 +102 @@
         } else if (idx < snd_ecards_limit) {
                 if (snd_cards_lock & (1 << idx))
-                        idx = -1;       /* invalid */
+                        err = -ENODEV;  /* invalid */
         } else if (idx < SNDRV_CARDS)
                 snd_ecards_limit = idx + 1; /* increase the limit */
         else
-                idx = -1;
-        if (idx < 0) {
+                err = -ENODEV;
+        if (idx < 0 || err < 0) {
                 write_unlock(&snd_card_rwlock);
-                if (idx >= snd_ecards_limit)
-                        snd_printk(KERN_ERR "card %i is out of range (0-%i)\n", idx, snd_ecards_limit-1);
+                snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i)\n", idx, snd_ecards_limit - 1);
                 goto __error;
         }

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

@@ -27 +27 @@
 #include <linux/proc_fs.h>
 #include <sound/memalloc.h>
+#ifdef CONFIG_SBUS
+#include <asm/sbus.h>
+#endif
 
 
@@ -65 +68 @@
 #ifdef CONFIG_PCI
 #if defined(__i386__) || defined(__ppc__) || defined(__x86_64__)
-#define HACK_PCI_ALLOC_CONSISTENT
-
-/*
- * A hack to allocate large buffers via pci_alloc_consistent()
- *
- * since pci_alloc_consistent always tries GFP_DMA when the requested
+
+/*
+ * A hack to allocate large buffers via dma_alloc_coherent()
+ *
+ * since dma_alloc_coherent always tries GFP_DMA when the requested
  * pci memory region is below 32bit, it happens quite often that even
  * 2 order of pages cannot be allocated.
@@ -78 +80 @@
  * with the requested region, then realloate with the original dma_mask
  * again.
- */
-
-static void *snd_pci_hack_alloc_consistent(struct pci_dev *hwdev, size_t size,
-                                    dma_addr_t *dma_handle)
+ *
+ * Really, we want to move this type of thing into dma_alloc_coherent()
+ * so dma_mask doesn't have to be messed with.
+ */
+
+static void *snd_dma_hack_alloc_coherent(struct device *dev, size_t size,
+                                         dma_addr_t *dma_handle, int flags)
 {
         void *ret;
-        u64 dma_mask, cdma_mask;
-        unsigned long mask;
-
-        if (hwdev == NULL)
-                return pci_alloc_consistent(hwdev, size, dma_handle);
-        dma_mask = hwdev->dma_mask;
-        cdma_mask = hwdev->consistent_dma_mask;
-        mask = (unsigned long)dma_mask && (unsigned long)cdma_mask;
-        hwdev->dma_mask = 0xffffffff; /* do without masking */
-        hwdev->consistent_dma_mask = 0xffffffff; /* do without masking */
-        ret = pci_alloc_consistent(hwdev, size, dma_handle);
-        hwdev->dma_mask = dma_mask; /* restore */
-        hwdev->consistent_dma_mask = cdma_mask; /* restore */
+        u64 dma_mask;
+
+        if (dev == NULL || !dev->dma_mask)
+                return dma_alloc_coherent(dev, size, dma_handle, flags);
+        dma_mask = *dev->dma_mask;
+        *dev->dma_mask = 0xffffffff;    /* do without masking */
+        ret = dma_alloc_coherent(dev, size, dma_handle, flags);
+        *dev->dma_mask = dma_mask;      /* restore */
         if (ret) {
                 /* obtained address is out of range? */
-                if (((unsigned long)*dma_handle + size - 1) & ~mask) {
+                if (((unsigned long)*dma_handle + size - 1) & ~dma_mask) {
                         /* reallocate with the proper mask */
-                        pci_free_consistent(hwdev, size, ret, *dma_handle);
-                        ret = pci_alloc_consistent(hwdev, size, dma_handle);
+                        dma_free_coherent(dev, size, ret, *dma_handle);
+                        ret = dma_alloc_coherent(dev, size, dma_handle, flags);
                 }
         } else {
                 /* wish to success now with the proper mask... */
-                if (mask != 0xffffffffUL)
-                        ret = pci_alloc_consistent(hwdev, size, dma_handle);
+                if (dma_mask != 0xffffffffUL)
+                        ret = dma_alloc_coherent(dev, size, dma_handle, flags);
         }
         return ret;
 }
 
-/* redefine pci_alloc_consistent for some architectures */
-#undef pci_alloc_consistent
-#define pci_alloc_consistent snd_pci_hack_alloc_consistent
+/* redefine dma_alloc_coherent for some architectures */
+#undef dma_alloc_coherent
+#define dma_alloc_coherent snd_dma_hack_alloc_coherent
 
 #endif /* arch */
@@ -395 +395 @@
  * Returns the pointer of the buffer, or NULL if no enoguh memory.
  */
-void *snd_malloc_pages(unsigned long size, unsigned int dma_flags)
+void *snd_malloc_pages(size_t size, unsigned int dma_flags)
 {
     int pg;
@@ -416 +416 @@
  * Releases the buffer allocated via snd_malloc_pages().
  */
-void snd_free_pages(void *ptr, unsigned long size)
+void snd_free_pages(void *ptr, size_t size)
 {
     int pg;
@@ -721 +721 @@
         {0 }, /* terminator */
 };
+
+/*
+ * compose a snd_dma_device struct for the PCI device
+ */
+static inline void snd_dma_device_pci(struct snd_dma_device *dev, struct pci_dev *pci, unsigned int id)
+{
+        memset(dev, 0, sizeof(*dev));
+        dev->type = SNDRV_DMA_TYPE_DEV;
+        dev->dev = snd_dma_pci_data(pci);
+        dev->id = id;
+}
 
 static void __init preallocate_cards(void)
@@ -846 +857 @@
  */
 EXPORT_SYMBOL(snd_dma_alloc_pages);
+EXPORT_SYMBOL(snd_dma_alloc_pages_fallback);
 EXPORT_SYMBOL(snd_dma_free_pages);
+
 EXPORT_SYMBOL(snd_dma_get_reserved);
 EXPORT_SYMBOL(snd_dma_free_reserved);
@@ -854 +867 @@
 EXPORT_SYMBOL(snd_malloc_pages_fallback);
 EXPORT_SYMBOL(snd_free_pages);
-#if defined(CONFIG_ISA) && ! defined(CONFIG_PCI)
-EXPORT_SYMBOL(snd_malloc_isa_pages);
-EXPORT_SYMBOL(snd_malloc_isa_pages_fallback);
-#endif
-#ifdef CONFIG_PCI
-EXPORT_SYMBOL(snd_malloc_pci_pages);
-EXPORT_SYMBOL(snd_malloc_pci_pages_fallback);
-EXPORT_SYMBOL(snd_malloc_pci_page);
-EXPORT_SYMBOL(snd_free_pci_pages);
-EXPORT_SYMBOL(snd_malloc_sgbuf_pages);
-EXPORT_SYMBOL(snd_free_sgbuf_pages);
-#endif
-#ifdef CONFIG_SBUS
-EXPORT_SYMBOL(snd_malloc_sbus_pages);
-EXPORT_SYMBOL(snd_malloc_sbus_pages_fallback);
-EXPORT_SYMBOL(snd_free_sbus_pages);
-#endif
-

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

@@ -406 +406 @@
     char line[64];
     if (!snd_info_get_line(buffer, line, sizeof(line)))
-        pstr->xrun_debug = !!simple_strtoul(line, NULL, 10);
+                pstr->xrun_debug = simple_strtoul(line, NULL, 10);
 }
 #endif

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

@@ -188 +188 @@
                                    substream->pcm->device,
                                    substream->stream ? 'c' : 'p');
+                        if (substream->pstr->xrun_debug > 1)
                         dump_stack();
                 }
@@ -219 +220 @@
         if ((snd_pcm_uframes_t)delta < runtime->buffer_size / 2) {
 #ifdef CONFIG_SND_DEBUG
-            if (runtime->periods > 1)
+                        if (runtime->periods > 1 && substream->pstr->xrun_debug) {
                 snd_printd(KERN_ERR "Unexpected hw_pointer value [1] (stream = %i, delta: -%ld, max jitter = %ld): wrong interrupt acknowledge?\n", substream->stream, (long) delta, runtime->buffer_size / 2);
+                                if (substream->pstr->xrun_debug > 1)
+                                        dump_stack();
+                        }
 #endif
             return 0;
@@ -261 +265 @@
         if ((snd_pcm_uframes_t)delta < runtime->buffer_size / 2) {
 #ifdef CONFIG_SND_DEBUG
-            if (runtime->periods > 2)
+                        if (runtime->periods > 2 && substream->pstr->xrun_debug) {
                 snd_printd(KERN_ERR "Unexpected hw_pointer value [2] (stream = %i, delta: -%ld, max jitter = %ld): wrong interrupt acknowledge?\n", substream->stream, (long) delta, runtime->buffer_size / 2);
+                                if (substream->pstr->xrun_debug > 1)
+                                        dump_stack();
+                        }
 #endif
             return 0;
@@ -2689 +2696 @@
 EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages);
 EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages_for_all);
+EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
 EXPORT_SYMBOL(snd_pcm_lib_malloc_pages);
 EXPORT_SYMBOL(snd_pcm_lib_free_pages);
-#ifdef CONFIG_ISA
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_isa_pages);
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_isa_pages_for_all);
-#endif
-#ifdef CONFIG_PCI
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_pci_pages);
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_pci_pages_for_all);
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_sg_pages);
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_sg_pages_for_all);
-EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
-#endif
-#ifdef CONFIG_SBUS
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_sbus_pages);
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_sbus_pages_for_all);
-#endif

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

@@ -20 +20 @@
  */
 
+#include <linux/config.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/vmalloc.h>
 #ifdef TARGET_OS2
-#include <sound/driver.h>
-#include <sound/core.h>
 #include <sound/info.h>
 #endif /* TARGET_OS2 */
@@ -31 +33 @@
 #define sgbuf_align_table(tbl)  ((((tbl) + SGBUF_TBL_ALIGN - 1) / SGBUF_TBL_ALIGN) * SGBUF_TBL_ALIGN)
 
-/*
- * shrink to the given pages.
- * free the unused pages
- */
-static void sgbuf_shrink(struct snd_sg_buf *sgbuf, int pages)
+int snd_free_sgbuf_pages(struct snd_dma_buffer *dmab)
 {
-        snd_assert(sgbuf, return);
-        if (! sgbuf->table)
-                return;
-        while (sgbuf->pages > pages) {
-                sgbuf->pages--;
-                snd_free_pci_pages(sgbuf->pci, PAGE_SIZE,
-                                   sgbuf->table[sgbuf->pages].buf,
-                                   sgbuf->table[sgbuf->pages].addr);
-        }
+        struct snd_sg_buf *sgbuf = dmab->private_data;
+        struct snd_dma_buffer tmpb;
+        int i;
+
+        if (! sgbuf)
+                return -EINVAL;
+
+        for (i = 0; i < sgbuf->pages; i++) {
+                tmpb.area = sgbuf->table[i].buf;
+                tmpb.addr = sgbuf->table[i].addr;
+                tmpb.bytes = PAGE_SIZE;
+                snd_dma_free_pages(&tmpb);
+        }
+#ifndef TARGET_OS2
+        if (dmab->area)
+                vunmap(dmab->area);
+#endif
+        dmab->area = NULL;
+
+        if (sgbuf->table)
+                kfree(sgbuf->table);
+        if (sgbuf->page_table)
+                kfree(sgbuf->page_table);
+        kfree(sgbuf);
+        dmab->private_data = NULL;
+        
+        return 0;
 }
 
-/**
- * snd_malloc_sgbuf_pages - allocate the pages for the PCI SG buffer
- * @pci: the pci device pointer
- * @size: the requested buffer size in bytes
- * @dmab: the buffer record to store
- *
- * Initializes the SG-buffer table and allocates the buffer pages
- * for the given size.
- * The pages are mapped to the virtually continuous memory.
- *
- * This function is usually called from the middle-level functions such as
- * snd_pcm_lib_malloc_pages().
- *
- * Returns the mapped virtual address of the buffer if allocation was
- * successful, or NULL at error.
- */
-void *snd_malloc_sgbuf_pages(struct pci_dev *pci,
-                             size_t size,
-                             struct snd_dma_buffer *dmab,
+void *snd_malloc_sgbuf_pages(const struct snd_dma_device *dev,
+                             size_t size, struct snd_dma_buffer *dmab,
                              size_t *res_size)
 {
         struct snd_sg_buf *sgbuf;
-        unsigned int pages;
-        void *ptr;
-        dma_addr_t addr;
+        unsigned int i, pages;
+        struct snd_dma_buffer tmpb;
 
 #ifdef DEBUG
@@ -89 +87 @@
         }
         memset(sgbuf, 0, sizeof(*sgbuf));
-        sgbuf->pci = pci;
+        sgbuf->dev = *dev;
+        sgbuf->dev.type = SNDRV_DMA_TYPE_DEV;
         pages = snd_sgbuf_aligned_pages(size);
         sgbuf->tblsize = sgbuf_align_table(pages);
@@ -98 +97 @@
             dprintf(("snd_malloc_sgbuf_pages failed: error allocating sgbuf->table"));
 #endif
-            return NULL;
+                goto _failed;
         }
         memset(sgbuf->table, 0, sizeof(*sgbuf->table) * sgbuf->tblsize);
@@ -107 +106 @@
             dprintf(("snd_malloc_sgbuf_pages failed: error allocating sgbuf->page_table"));
 #endif
-            return NULL;
+                goto _failed;
         }
         memset(sgbuf->page_table, 0, sizeof(*sgbuf->page_table) * sgbuf->tblsize);
@@ -114 +113 @@
             dprintf(("allocating %d pages",pages));
 #endif
-            ptr = snd_malloc_pci_pages(sgbuf->pci, size, &addr);
-            if (! ptr)
-                goto _failed;
 
             /* allocate each page */
-            while (sgbuf->pages < pages) {
-                mem_map_t *page;
-
-                sgbuf->table[sgbuf->pages].buf = (char*)ptr + PAGE_SIZE*sgbuf->pages;
-                sgbuf->table[sgbuf->pages].addr = addr + PAGE_SIZE*sgbuf->pages;
-                page = (mem_map_t *)virt_to_page((int)sgbuf->table[sgbuf->pages].buf);
-                sgbuf->page_table[sgbuf->pages] = page;
-                SetPageReserved(page);
+        for (i = 0; i < pages; i++) {
+                if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,sgbuf->dev.dev, PAGE_SIZE, &tmpb) < 0) {
+                        if (res_size == NULL)
+                                goto _failed;
+                        *res_size = size = sgbuf->pages * PAGE_SIZE;
+                        break;
+                }
+                sgbuf->table[i].buf = tmpb.area;
+                sgbuf->table[i].addr = tmpb.addr;
+                sgbuf->page_table[i] = virt_to_page(tmpb.area);
                 sgbuf->pages++;
             }
 
-            memset(ptr,0,size);
-
-            dmab->area = ptr;
             sgbuf->size = size;
+#ifndef TARGET_OS2
+        dmab->area = vmap(sgbuf->page_table, sgbuf->pages, VM_MAP, PAGE_KERNEL);
+#else
+        dmab->area = NULL;
+#endif
+        if (! dmab->area)
+                goto _failed;
             return dmab->area;
 
@@ -144 +146 @@
         return NULL;
 }
-
-
-/**
- * snd_free_sgbuf_pages - free the sg buffer
- * @dmab: buffer record
- *
- * Releases the pages and the SG-buffer table.
- *
- * This function is called usually from the middle-level function
- * such as snd_pcm_lib_free_pages().
- *
- * Returns zero if successful, or a negative error code on failure.
- */
-int snd_free_sgbuf_pages(struct snd_dma_buffer *dmab)
-{
-        struct snd_sg_buf *sgbuf = dmab->private_data;
-
-        sgbuf_shrink(sgbuf, 0);
-        if (sgbuf->table)
-                kfree(sgbuf->table);
-        sgbuf->table = NULL;
-        if (sgbuf->page_table)
-                kfree(sgbuf->page_table);
-        kfree(sgbuf);
-        dmab->private_data = NULL;
-        
-        return 0;
-}
-
-

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

@@ -358 +358 @@
     if (dpcm == NULL)
         return -ENOMEM;
-    if ((runtime->dma_area = snd_malloc_pages_fallback(MAX_BUFFER_SIZE, GFP_KERNEL, (unsigned long *) &runtime->dma_bytes)) == NULL) {
+    if ((runtime->dma_area = snd_malloc_pages_fallback(MAX_BUFFER_SIZE, GFP_KERNEL, &runtime->dma_bytes)) == NULL) {
         kfree(dpcm);
         return -ENOMEM;
@@ -393 +393 @@
     if (dpcm == NULL)
         return -ENOMEM;
-    if ((runtime->dma_area = snd_malloc_pages_fallback(MAX_BUFFER_SIZE, GFP_KERNEL, (unsigned long *) &runtime->dma_bytes)) == NULL) {
+    if ((runtime->dma_area = snd_malloc_pages_fallback(MAX_BUFFER_SIZE, GFP_KERNEL, &runtime->dma_bytes)) == NULL) {
         kfree(dpcm);
         return -ENOMEM;

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

@@ -2 +2 @@
  *  Driver for generic MPU-401 boards (UART mode only)
  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
+ *
+ *  ACPI PnP Copyright (c) 2004 by Clemens Ladisch <clemens@ladisch.de>
+ *  based on 8250_acpi.c
+ *  Copyright (c) 2002-2003 Matthew Wilcox for Hewlett-Packard
+ *  Copyright (C) 2004 Hewlett-Packard Co
+ *       Bjorn Helgaas <bjorn.helgaas@hp.com>
  *
  *
@@ -22 +28 @@
 #include <sound/driver.h>
 #include <linux/init.h>
-#include <linux/wait.h>
-#include <linux/sched.h>
-#include <linux/slab.h>
+#ifdef CONFIG_ACPI_BUS
+#include <acpi/acpi_bus.h>
+#endif
 #include <sound/core.h>
 #include <sound/mpu401.h>
 #define SNDRV_GET_ID
 #include <sound/initval.h>
-#include <linux/delay.h>
+
+#ifdef CONFIG_ACPI_BUS
+#define USE_ACPI_PNP
+#endif
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
@@ -39 +48 @@
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;  /* Enable this card */
+#ifdef USE_ACPI_PNP
+static int acpipnp[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 1 };
+#endif
 static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* MPU-401 port number */
 static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* MPU-401 IRQ */
@@ -54 +66 @@
 MODULE_PARM_DESC(enable, "Enable MPU-401 device.");
 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
+#ifdef USE_ACPI_PNP
+MODULE_PARM(acpipnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
+MODULE_PARM_DESC(acpipnp, "ACPI PnP detection for MPU-401 device.");
+MODULE_PARM_SYNTAX(acpipnp, SNDRV_ENABLED "," SNDRV_BOOLEAN_TRUE_DESC);
+#endif
 MODULE_PARM(port, "1-" __MODULE_STRING(SNDRV_CARDS) "l");
 MODULE_PARM_DESC(port, "Port # for MPU-401 device.");
@@ -66 +83 @@
 #endif
 
-static snd_card_t *snd_mpu401_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-
-static int __init snd_card_mpu401_probe(int dev)
+#ifndef CONFIG_ACPI_BUS
+struct acpi_device;
+#endif
+
+static snd_card_t *snd_mpu401_legacy_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
+static int cards;
+
+#ifdef USE_ACPI_PNP
+
+static int acpi_driver_registered;
+
+struct mpu401_resources {
+        unsigned long port;
+        int irq;
+};
+
+static acpi_status __devinit snd_mpu401_acpi_resource(struct acpi_resource *res,
+                                                      void *data)
+{
+        struct mpu401_resources *resources = (struct mpu401_resources *)data;
+
+        if (res->id == ACPI_RSTYPE_IRQ) {