Changeset 348 for GPL/branches/alsa-resync1/alsa-kernel

Timestamp:

Apr 21, 2008, 2:52:19 AM (17 years ago)

Author:

Brendan Oakley

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) {
+                if (res->data.irq.number_of_interrupts > 0) {
+#ifdef CONFIG_IA64
+                        resources->irq = acpi_register_irq(res->data.irq.interrupts[0],
+                                                           res->data.irq.active_high_low,
+                                                           res->data.irq.edge_level);
+#else
+                        resources->irq = res->data.irq.interrupts[0];
+#endif
+                }
+        } else if (res->id == ACPI_RSTYPE_IO) {
+                if (res->data.io.range_length >= 2) {
+                        resources->port = res->data.io.min_base_address;
+                }
+        }
+        return AE_OK;
+}
+
+static int __devinit snd_mpu401_acpi_pnp(int dev, struct acpi_device *device)
+{
+        struct mpu401_resources res;
+        acpi_status status;
+
+        res.port = SNDRV_AUTO_PORT;
+        res.irq = SNDRV_AUTO_IRQ;
+        status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
+                                     snd_mpu401_acpi_resource, &res);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+        if (res.port == SNDRV_AUTO_PORT || res.irq == SNDRV_AUTO_IRQ) {
+                snd_printk(KERN_ERR "no port or irq in %s _CRS\n",
+                           acpi_device_bid(device));
+                return -ENODEV;
+        }
+        port[dev] = res.port;
+        irq[dev] = res.irq;
+        return 0;
+}
+
+#endif /* USE_ACPI_PNP */
+
+static int __devinit snd_card_mpu401_probe(int dev, struct acpi_device *device)
 {
         snd_card_t *card;
         int err;
 
+#ifdef USE_ACPI_PNP
+        if (!device) {
+#endif
         if (port[dev] == SNDRV_AUTO_PORT) {
-                snd_printk("specify port\n");
+                        snd_printk(KERN_ERR "specify port\n");
                 return -EINVAL;
         }
         if (irq[dev] == SNDRV_AUTO_IRQ) {
-                snd_printk("specify or disable IRQ port\n");
+                        snd_printk(KERN_ERR "specify or disable IRQ port\n");
                 return -EINVAL;
         }
+#ifdef USE_ACPI_PNP
+        }
+#endif
+
+#ifdef USE_ACPI_PNP
+        if (device && (err = snd_mpu401_acpi_pnp(dev, device)) < 0)
+                return err;
+#endif
 
         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
         if (card == NULL)
                 return -ENOMEM;
-        if (snd_mpu401_uart_new(card, 0,
-#ifdef CONFIG_X86_PC9800
-                                pc98ii[dev] ? MPU401_HW_PC98II :
-#endif
-                                MPU401_HW_MPU401,
-                                port[dev], 0,
-                                irq[dev], irq[dev] >= 0 ? SA_INTERRUPT : 0, NULL) < 0) {
-                printk(KERN_ERR "MPU401 not detected at 0x%lx\n", port[dev]);
-                snd_card_free(card);
-                return -ENODEV;
-        }
         strcpy(card->driver, "MPU-401 UART");
         strcpy(card->shortname, card->driver);
@@ -104 +181 @@
                 strcat(card->longname, "polled");
         }
+#ifdef USE_ACPI_PNP
+        if (device) {
+                strcat(card->longname, ", bus id ");
+                strlcat(card->longname, acpi_device_bid(device), sizeof(card->longname));
+        }
+#endif
+        if (snd_mpu401_uart_new(card, 0,
+#ifdef CONFIG_X86_PC9800
+                                pc98ii[dev] ? MPU401_HW_PC98II :
+#endif
+                                MPU401_HW_MPU401,
+                                port[dev], 0,
+                                irq[dev], irq[dev] >= 0 ? SA_INTERRUPT : 0, NULL) < 0) {
+                printk(KERN_ERR "MPU401 not detected at 0x%lx\n", port[dev]);
+                snd_card_free(card);
+                return -ENODEV;
+        }
         if ((err = snd_card_register(card)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        snd_mpu401_cards[dev] = card;
+#ifdef USE_ACPI_PNP
+        if (device)
+                acpi_driver_data(device) = card;
+        else
+#endif
+                snd_mpu401_legacy_cards[dev] = card;
+        ++cards;
         return 0;
 }
 
+#ifdef USE_ACPI_PNP
+
+static int __devinit snd_mpu401_acpi_add(struct acpi_device *device)
+{
+        static int dev;
+        int err;
+
+        for ( ; dev < SNDRV_CARDS; ++dev) {
+                if (!enable[dev] || !acpipnp[dev])
+                        continue;
+                err = snd_card_mpu401_probe(dev, device);
+                if (err < 0)
+                        return err;
+                ++dev;
+                return 0;
+        }
+        return -ENODEV;
+}
+
+static int __devexit snd_mpu401_acpi_remove(struct acpi_device *device,
+                                            int type)
+{
+        snd_card_t *card;
+
+        if (!device)
+                return -EINVAL;
+        card = (snd_card_t *)acpi_driver_data(device);
+        if (!card)
+                return -EINVAL;
+
+        snd_card_disconnect(card);
+        snd_card_free_in_thread(card);
+        acpi_driver_data(device) = NULL;
+        return 0;
+}
+
+static struct acpi_driver snd_mpu401_acpi_driver = {
+        .name = "MPU-401 Driver",
+        .class = "mpu401",
+        .ids = "PNPB006",
+        .ops = {
+                .add = snd_mpu401_acpi_add,
+                .remove = __devexit_p(snd_mpu401_acpi_remove),
+        },
+};
+
+#endif /* USE_ACPI_PNP */
+
 static int __init alsa_card_mpu401_init(void)
 {
-        int dev, cards = 0;
-
+        int dev;
+
+#ifdef USE_ACPI_PNP
+        if (acpi_bus_register_driver(&snd_mpu401_acpi_driver) >= 0)
+                acpi_driver_registered = 1;
+#endif
         for (dev = 0; dev < SNDRV_CARDS; dev++) {
                 if (!enable[dev])
                         continue;
-                if (snd_card_mpu401_probe(dev) >= 0)
-                        cards++;
+#ifdef USE_ACPI_PNP
+                if (acpipnp[dev] && acpi_driver_registered)
+                        continue;
+#endif
+                snd_card_mpu401_probe(dev, NULL);
         }
         if (!cards) {
@@ -126 +281 @@
                 printk(KERN_ERR "MPU-401 device not found or device busy\n");
 #endif
+#ifdef USE_ACPI_PNP
+                if (acpi_driver_registered)
+                        acpi_bus_unregister_driver(&snd_mpu401_acpi_driver);
+#endif
                 return -ENODEV;
         }
@@ -135 +294 @@
         int idx;
 
+#ifdef USE_ACPI_PNP
+        if (acpi_driver_registered)
+                acpi_bus_unregister_driver(&snd_mpu401_acpi_driver);
+#endif
         for (idx = 0; idx < SNDRV_CARDS; idx++)
-                snd_card_free(snd_mpu401_cards[idx]);
+                snd_card_free(snd_mpu401_legacy_cards[idx]);
 }
 
@@ -144 +307 @@
 #ifndef MODULE
 
-/* format is: snd-mpu401=enable,index,id,port,irq */
+/* format is: snd-mpu401=enable,index,id,acpipnp[,pc98ii],port,irq */
 
 static int __init alsa_card_mpu401_setup(char *str)
 {
         static unsigned __initdata nr_dev = 0;
+        int __attribute__ ((__unused__)) pnp = INT_MAX;
 
         if (nr_dev >= SNDRV_CARDS)
@@ -155 +319 @@
                get_option(&str,&index[nr_dev]) == 2 &&
                get_id(&str,&id[nr_dev]) == 2 &&
+               get_option(&str,&pnp) == 2 &&
 #ifdef CONFIG_X86_PC9800
                get_option(&str,&pc98ii[nr_dev]) == 2 &&
@@ -160 +325 @@
                get_option_long(&str,&port[nr_dev]) == 2 &&
                get_option(&str,&irq[nr_dev]) == 2);
+#ifdef USE_ACPI_PNP
+        if (pnp != INT_MAX)
+                acpipnp[nr_dev] = pnp;
+#endif
         nr_dev++;
         return 1;

GPL/branches/alsa-resync1/alsa-kernel/drivers/serial-u16550.c

@@ -352 +352 @@
 
     /* Do some vague tests for the presence of the uart */
-        if (io_base == 0) {
+        if (io_base == 0 || io_base == SNDRV_AUTO_PORT) {
         return -ENODEV; /* Not configured */
         }
@@ -830 +830 @@
         }
 
-    if (irq >= 0) {
+        if (irq >= 0 && irq != SNDRV_AUTO_IRQ) {
         if (request_irq(irq, snd_uart16550_interrupt,
                         SA_INTERRUPT, "Serial MIDI", (void *) uart)) {
-            uart->irq = -1;
             snd_printk("irq %d busy. Using Polling.\n", irq);
         } else {

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

@@ -58 +58 @@
 #endif
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
 #ifndef TARGET_OS2
 #include <linux/compiler.h>
@@ -65 +66 @@
 #endif
 
-#ifdef CONFIG_PCI
+/* for compat layer */
 #include <linux/pci.h>
-#endif
 
 #ifndef __iomem
@@ -181 +181 @@
 #endif
 
-#if !defined CONFIG_HAVE_STRLCPY && !defined TARGET_OS2
+#endif /* < 2.6.0 */
+
+#ifndef TARGET_OS2
+#ifndef CONFIG_HAVE_STRLCPY
 size_t snd_compat_strlcpy(char *dest, const char *src, size_t size);
 #define strlcpy(dest, src, size) snd_compat_strlcpy(dest, src, size)
@@ -188 +191 @@
 #endif
 
-#if !defined CONFIG_HAVE_SNPRINTF && !defined TARGET_OS2
+#ifndef CONFIG_HAVE_SNPRINTF
 #include <stdarg.h>
 int snd_compat_snprintf(char * buf, size_t size, const char * fmt, ...);
@@ -196 +199 @@
 #endif
 
-#ifndef TARGET_OS2
 #ifndef CONFIG_HAVE_SCNPRINTF
 #define scnprintf(buf,size,fmt,args...) snprintf(buf,size,fmt,##args)
@@ -332 +334 @@
 #endif
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
+#define snd_dma_pci_data(pci)   ((struct device *)(pci))
+#define snd_dma_isa_data()      NULL
+#define snd_dma_sbus_data(sbus) ((struct device *)(sbus))
+#define snd_dma_continuous_data(x)      ((struct device *)(unsigned long)(x))
+#endif
+
 /* pm_message_t type */
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)

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

@@ -10 +10 @@
 #include <linux/pagemap.h>
 #include <linux/ioport.h>
+
+#ifndef likely
+#if __GNUC__ == 2 && __GNUC_MINOR__ < 96
+#define __builtin_expect(x, expected_value) (x)
+#endif
+#define likely(x)       __builtin_expect((x),1)
+#define unlikely(x)     __builtin_expect((x),0)
+#endif
 
 #if defined(SND_NEED_USB_WRAPPER) && (defined(CONFIG_USB) || defined(CONFIG_USB_MODULE))
@@ -220 +228 @@
 int snd_compat_release_resource(struct resource *resource);
 
-#if 0
-//#ifdef CONFIG_PCI
+/* these functions are used for ISA buffer allocation, too, so they stay
+ * outside of CONFIG_PCI
+ */
+#define pci_alloc_consistent snd_pci_compat_alloc_consistent
+#define pci_free_consistent snd_pci_compat_free_consistent
+void *snd_pci_compat_alloc_consistent(struct pci_dev *, long, dma_addr_t *);
+void snd_pci_compat_free_consistent(struct pci_dev *, long, void *, dma_addr_t);
+
+#ifdef CONFIG_PCI
 
 /* New-style probing supporting hot-pluggable devices */
@@ -242 +257 @@
 //#define pci_set_power_state snd_pci_compat_set_power_state
 
-#define pci_alloc_consistent snd_pci_compat_alloc_consistent
-#define pci_free_consistent snd_pci_compat_free_consistent
 #define pci_dma_supported snd_pci_compat_dma_supported
 
@@ -308 +321 @@
 void snd_pci_compat_disable_device(struct pci_dev *dev);
 int snd_pci_compat_find_capability(struct pci_dev *dev, int cap);
-void *snd_pci_compat_alloc_consistent(struct pci_dev *, long, dma_addr_t *);
-void snd_pci_compat_free_consistent(struct pci_dev *, long, void *, dma_addr_t);
 int snd_pci_compat_dma_supported(struct pci_dev *, dma_addr_t mask);
 unsigned long snd_pci_compat_get_dma_mask(struct pci_dev *);
@@ -477 +488 @@
         unsigned long name[((bits)+BITS_PER_LONG-1)/BITS_PER_LONG]
 #endif
-#ifndef __user
-#define __user
-#endif
 
 /**

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

@@ -279 +279 @@
 void *snd_kcalloc(size_t size, int flags);
 char *snd_kmalloc_strdup(const char *string, int flags);
-void *snd_malloc_pages(unsigned long size, unsigned int dma_flags);
-void *snd_malloc_pages_fallback(unsigned long size, unsigned int dma_flags, unsigned long *res_size);
 int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size_t count);
 int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count);

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

@@ -25 +25 @@
 #define __SOUND_MEMALLOC_H
 
-#include <linux/pci.h>
-#ifdef CONFIG_SBUS
-#include <asm/sbus.h>
-#endif
+struct device;
 
 #if 0
@@ -62 +59 @@
 #define SNDRV_DMA_TYPE_DEV              2       /* generic device continuous */
 #define SNDRV_DMA_TYPE_DEV_SG           3       /* generic device SG-buffer */
-#ifdef TARGET_OS2 // Provide old types until 1.0.4
-#define SNDRV_DMA_TYPE_ISA              2       /* ISA continuous */
-#define SNDRV_DMA_TYPE_PCI              3       /* PCI continuous */
-#endif /* TARGET_OS2 */
 #define SNDRV_DMA_TYPE_SBUS             4       /* SBUS continuous */
-#define SNDRV_DMA_TYPE_PCI_SG           5       /* PCI SG-buffer */
-
-#ifdef CONFIG_PCI
-#if 0
-/*
- * 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_PCI;
-        dev->dev.pci = pci;
-        dev->id = id;
-}
-#endif
-#endif
 
 #define __GFP_NOWARN    0
@@ -97 +74 @@
 };
 
-/* allocate/release a buffer */
-int snd_dma_alloc_pages(int type, struct device *dev, size_t size,
-                        struct snd_dma_buffer *dmab);
-int snd_dma_alloc_pages_fallback(int type, struct device *dev, size_t size,
-                                 struct snd_dma_buffer *dmab);
-void snd_dma_free_pages(struct snd_dma_buffer *dmab);
-
-/* buffer-preservation managements */
-#define snd_dma_pci_buf_id(pci) (((unsigned int)(pci)->vendor << 16) | (pci)->device)
-size_t snd_dma_get_reserved_buf(struct snd_dma_buffer *dmab, unsigned int id);
-int snd_dma_reserve_buf(struct snd_dma_buffer *dmab, unsigned int id);
-
 /*
- * Generic memory allocators
- */
-
-/*
- * continuous pages
- */
-void *snd_malloc_pages(unsigned long size, unsigned int gfp_flags);
-void snd_free_pages(void *ptr, unsigned long  size);
-
-#ifdef CONFIG_PCI
-/*
- * PCI continuous pages
- */
-void *snd_malloc_pci_pages(struct pci_dev *pci, size_t size, dma_addr_t *dma_addr);
-void *snd_malloc_pci_pages_fallback(struct pci_dev *pci, size_t size, dma_addr_t *dma_addr, size_t *res_size);
-void snd_free_pci_pages(struct pci_dev *pci, size_t size, void *ptr, dma_addr_t dma_addr);
-/* one page allocation */
-void *snd_malloc_pci_page(struct pci_dev *pci, dma_addr_t *dma_addr);
-#define snd_free_pci_page(pci,ptr,addr) snd_free_pci_pages(pci,PAGE_SIZE,ptr,addr)
-#endif
-
-#ifdef CONFIG_SBUS
-/*
- * SBUS continuous pages
- */
-void *snd_malloc_sbus_pages(struct sbus_dev *sdev, size_t size, dma_addr_t *dma_addr);
-void *snd_malloc_sbus_pages_fallback(struct sbus_dev *sdev, size_t size, dma_addr_t *dma_addr, size_t *res_size);
-void snd_free_sbus_pages(struct sbus_dev *sdev, size_t size, void *ptr, dma_addr_t dma_addr);
-#endif
-
-#ifdef CONFIG_ISA
-/*
- * ISA continuous pages
- */
-void *snd_malloc_isa_pages(size_t size, dma_addr_t *dma_addr);
-void *snd_malloc_isa_pages_fallback(size_t size, dma_addr_t *dma_addr, size_t *res_size);
-void snd_free_isa_pages(size_t size, void *ptr, dma_addr_t addr);
-#ifdef CONFIG_PCI
-#define snd_malloc_isa_pages(size, dma_addr) snd_malloc_pci_pages(NULL, size, dma_addr)
-#define snd_malloc_isa_pages_fallback(size, dma_addr, res_size) snd_malloc_pci_pages_fallback(NULL, size, dma_addr, res_size)
-#define snd_free_isa_pages(size, ptr, dma_addr) snd_free_pci_pages(NULL, size, ptr, dma_addr)
-#else /* !CONFIG_PCI */
-#define snd_free_isa_pages(size, ptr, dma_addr) snd_free_pages(ptr, size)
-#endif /* CONFIG_PCI */
-#endif /* CONFIG_ISA */
-
-#ifdef CONFIG_PCI
-/*
- * Scatter-Gather PCI pages
+ * Scatter-Gather generic device pages
  */
 struct snd_sg_page {
@@ -171 +88 @@
         struct snd_sg_page *table;      /* address table */
         struct page **page_table;       /* page table (for vmap/vunmap) */
-        struct pci_dev *pci;
+        struct snd_dma_device dev;
 };
 
@@ -189 +106 @@
         return sgbuf->table[offset >> PAGE_SHIFT].addr + offset % PAGE_SIZE;
 }
-#endif /* CONFIG_PCI */
+
+
+/* allocate/release a buffer */
+int snd_dma_alloc_pages(int type, struct device *dev, size_t size,
+                        struct snd_dma_buffer *dmab);
+int snd_dma_alloc_pages_fallback(int type, struct device *dev, size_t size,
+                                 struct snd_dma_buffer *dmab);
+void snd_dma_free_pages(struct snd_dma_buffer *dmab);
+
+/* buffer-preservation managements */
+#define snd_dma_pci_buf_id(pci) (((unsigned int)(pci)->vendor << 16) | (pci)->device)
+size_t snd_dma_get_reserved_buf(struct snd_dma_buffer *dmab, unsigned int id);
+int snd_dma_reserve_buf(struct snd_dma_buffer *dmab, unsigned int id);
+
+/* basic memory allocation functions */
+void *snd_malloc_pages(size_t size, unsigned int gfp_flags);
+void *snd_malloc_pages_fallback(size_t size, unsigned int gfp_flags, size_t *res_size);
+void snd_free_pages(void *ptr, size_t size);
 
 #endif /* __SOUND_MEMALLOC_H */
+

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

@@ -1 +1 @@
 /* include/version.h.  Generated by configure.  */
-#define CONFIG_SND_VERSION "1.0.3"
+#define CONFIG_SND_VERSION "1.0.4"
 #define CONFIG_SND_DATE ""

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

@@ -685 +685 @@
         snd_ad1816a_init(chip);
 
-        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
 
         chip->pcm = pcm;

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

@@ -1044 +1044 @@
         strcpy(pcm->name, snd_ad1848_chip_id(chip));
 
-        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, chip->dma > 3 ? 128*1024 : 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024, chip->dma > 3 ? 128*1024 : 64*1024);
 
         chip->pcm = pcm;

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

@@ -443 +443 @@
         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &chip->streams[SNDRV_PCM_STREAM_CAPTURE].ops);
 
-        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, 128*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024, 128*1024);
         chip->pcm = pcm;
 

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

@@ -1654 +1654 @@
 
 #ifdef LEGACY_SUPPORT
-        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
 #else
 #  ifdef EBUS_SUPPORT
         if (chip->ebus_flag) {
-                snd_pcm_lib_preallocate_pci_pages_for_all(chip->dev_u.pdev, pcm,
+                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_PCI,
+                                                      chip->dev_u.pdev,
                                                           64*1024, 128*1024);
         } else {
 #  endif
 #  ifdef SBUS_SUPPORT
-                snd_pcm_lib_preallocate_sbus_pages_for_all(chip->dev_u.sdev, pcm,
+                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_SBUS,
+                                                      chip->dev_u.sdev,
                                                            64*1024, 128*1024);
 #  endif

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

@@ -144 +144 @@
         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",
+        snd_printdd("dt019x: found audio interface: port=0x%lx, irq=0x%x, dma=0x%x\n",
                         port[dev],irq[dev],dma8[dev]);
 
@@ -165 +165 @@
                 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",
+                snd_printdd("dt019x: found MPU-401: port=0x%lx, irq=0x%x\n",
                                 mpu_port[dev],mpu_irq[dev]);
         } else {
@@ -323 +323 @@
 
 #ifdef MODULE
-        if (!cards)
+        if (!cards) {
+                pnp_unregister_card_driver(&dt019x_pnpc_driver);
                 snd_printk(KERN_ERR "no DT-019X / ALS-007 based soundcards found\n");
+        }
 #endif
         return cards ? 0 : -ENODEV;

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

@@ -187 +187 @@
 {
         static unsigned long possible_ports[] = {0x220, 0x240, 0x260, -1};
-        int dev, cards = 0;
+        int dev, cards = 0, i;
 
         for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) {
@@ -195 +195 @@
                         cards++;
         }
-        cards += snd_legacy_auto_probe(possible_ports, snd_audiodrive_legacy_auto_probe);
+        i = snd_legacy_auto_probe(possible_ports, snd_audiodrive_legacy_auto_probe);
+        if (i > 0)
+                cards += i;
+
         if (!cards) {
 #ifdef MODULE

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

@@ -753 +753 @@
         chip->pcm = pcm;
 
-        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024, 64*1024);
 
         if (rpcm)

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

@@ -1599 +1599 @@
         chip->pcm = pcm;
 
-        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024,
+                                              chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
 
         if (rpcm)
@@ -2237 +2240 @@
 {
         static unsigned long possible_ports[] = {0x220, 0x240, 0x260, 0x280, -1};
-        int dev, cards = 0;
+        int dev, cards = 0, i;
 
         /* legacy non-auto cards at first */
@@ -2251 +2254 @@
         }
         /* legacy auto configured cards */
-        cards += snd_legacy_auto_probe(possible_ports, snd_audiodrive_probe_legacy_port);
+        i = snd_legacy_auto_probe(possible_ports, snd_audiodrive_probe_legacy_port);
+        if (i > 0)
+                cards += i;
+
 #ifdef CONFIG_PNP
         /* ISA PnP cards at last */
-        cards += pnp_register_card_driver(&es18xx_pnpc_driver);
+        i = pnp_register_card_driver(&es18xx_pnpc_driver);
+        if (i > 0)
+                cards += i;
+
 #endif
         if(!cards) {

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

@@ -875 +875 @@
 
         for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
-                snd_pcm_lib_preallocate_isa_pages(substream, 64*1024, gus->gf1.dma1 > 3 ? 128*1024 : 64*1024);
+                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024, gus->gf1.dma1 > 3 ? 128*1024 : 64*1024);
         
         pcm->info_flags = 0;
@@ -883 +885 @@
                 if (gus->gf1.dma2 == gus->gf1.dma1)
                         pcm->info_flags |= SNDRV_PCM_INFO_HALF_DUPLEX;
-                snd_pcm_lib_preallocate_isa_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, 64*1024, gus->gf1.dma2 > 3 ? 128*1024 : 64*1024);
+                snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
+                                              SNDRV_DMA_TYPE_DEV, snd_dma_isa_data(),
+                                              64*1024, gus->gf1.dma2 > 3 ? 128*1024 : 64*1024);
         }
         strcpy(pcm->name, pcm->id);

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

@@ -246 +246 @@
 {
         static unsigned long possible_ports[] = {0x220, 0x230, 0x240, 0x250, 0x260, -1};
-        int dev, cards;
+        int dev, cards, i;
 
         for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) {
@@ -254 +254 @@
                         cards++;
         }
-        cards += snd_legacy_auto_probe(possible_ports, snd_gusclassic_legacy_auto_probe);
+        i = snd_legacy_auto_probe(possible_ports, snd_gusclassic_legacy_auto_probe);
+        if (i > 0)
+                cards += i;
+
         if (!cards) {
 #ifdef MODULE

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

@@ -233 +233 @@
         if (xgf1_irq == SNDRV_AUTO_IRQ) {
                 if ((xgf1_irq = snd_legacy_find_free_irq(possible_gf1_irqs)) < 0) {
-                        snd_card_free(card);
                         snd_printk("unable to find a free IRQ for GF1\n");
-                        return -EBUSY;
+                        err = -EBUSY;
+                        goto out;
                 }
         }
@@ -241 +241 @@
         if (xess_irq == SNDRV_AUTO_IRQ) {
                 if ((xess_irq = snd_legacy_find_free_irq(possible_ess_irqs)) < 0) {
-                        snd_card_free(card);
                         snd_printk("unable to find a free IRQ for ES1688\n");
-                        return -EBUSY;
+                        err = -EBUSY;
+                        goto out;
                 }
         }
@@ -254 +254 @@
         if (xgf1_dma == SNDRV_AUTO_DMA) {
                 if ((xgf1_dma = snd_legacy_find_free_dma(possible_gf1_dmas)) < 0) {
-                        snd_card_free(card);
                         snd_printk("unable to find a free DMA for GF1\n");
-                        return -EBUSY;
+                        err = -EBUSY;
+                        goto out;
                 }
         }
@@ -262 +262 @@
         if (xess_dma == SNDRV_AUTO_DMA) {
                 if ((xess_dma = snd_legacy_find_free_dma(possible_ess_dmas)) < 0) {
-                        snd_card_free(card);
                         snd_printk("unable to find a free DMA for ES1688\n");
-                        return -EBUSY;
+                        err = -EBUSY;
+                        goto out;
                 }
         }
@@ -270 +270 @@
         if ((err = snd_es1688_create(card, port[dev], mpu_port[dev],
                                      xess_irq, xmpu_irq, xess_dma,
-                                     ES1688_HW_1688, &es1688)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
+                                     ES1688_HW_1688, &es1688)) < 0)
+                goto out;
         if (gf1_port[dev] < 0)
                 gf1_port[dev] = port[dev] + 0x20;
@@ -283 +281 @@
                                   0, channels[dev],
                                   pcm_channels[dev], 0,
-                                  &gus)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
-        if ((err = snd_gusextreme_detect(dev, card, gus, es1688)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
+                                  &gus)) < 0)
+                goto out;
+
+        if ((err = snd_gusextreme_detect(dev, card, gus, es1688)) < 0)
+                goto out;
+
         snd_gusextreme_init(dev, gus);
-        if ((err = snd_gus_initialize(gus)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
+        if ((err = snd_gus_initialize(gus)) < 0)
+                goto out;
+
         if (!gus->ess_flag) {
                 snd_printdd("GUS Extreme soundcard was not detected at 0x%lx\n", gus->gf1.port);
-                snd_card_free(card);
-                return -ENODEV;
-        }
-        if ((err = snd_es1688_pcm(es1688, 0, NULL)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
-        if ((err = snd_es1688_mixer(es1688)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
+                err = -ENODEV;
+                goto out;
+        }
+        if ((err = snd_es1688_pcm(es1688, 0, NULL)) < 0)
+                goto out;
+
+        if ((err = snd_es1688_mixer(es1688)) < 0)
+                goto out;
+
         snd_component_add(card, "ES1688");
         if (pcm_channels[dev] > 0) {
-                if ((err = snd_gf1_pcm_new(gus, 1, 1, NULL)) < 0) {
-                        snd_card_free(card);
-                        return err;
-                }
-        }
-        if ((err = snd_gf1_new_mixer(gus)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
-        if ((err = snd_gusextreme_mixer(es1688)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
+                if ((err = snd_gf1_pcm_new(gus, 1, 1, NULL)) < 0)
+                        goto out;
+                }
+        if ((err = snd_gf1_new_mixer(gus)) < 0)
+                goto out;
+
+        if ((err = snd_gusextreme_mixer(es1688)) < 0)
+                goto out;
 
         if (snd_opl3_create(card, es1688->port, es1688->port + 2,
@@ -329 +317 @@
                 printk(KERN_ERR "gusextreme: opl3 not detected at 0x%lx\n", es1688->port);
         } else {
-                if ((err = snd_opl3_hwdep_new(opl3, 0, 2, NULL)) < 0) {
-                        snd_card_free(card);
-                        return err;
-                }
-        }
-
-        if (es1688->mpu_port >= 0x300) {
-                if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_ES1688,
+                if ((err = snd_opl3_hwdep_new(opl3, 0, 2, NULL)) < 0)
+                        goto out;
+                }
+
+        if (es1688->mpu_port >= 0x300 &&
+            (err = snd_mpu401_uart_new(card, 0, MPU401_HW_ES1688,
                                                es1688->mpu_port, 0,
                                                xmpu_irq,
                                                SA_INTERRUPT,
-                                               NULL)) < 0) {
-                        snd_card_free(card);
-                        return err;
-                }
-        }
+                                               NULL)) < 0)
+                goto out;
 
         sprintf(card->longname, "Gravis UltraSound Extreme at 0x%lx, irq %i&%i, dma %i&%i",
                 es1688->port, xgf1_irq, xess_irq, xgf1_dma, xess_dma);
-        if ((err = snd_card_register(card)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
+        if ((err = snd_card_register(card)) < 0)
+                goto out;
+
         snd_gusextreme_cards[dev] = card;
         return 0;
+
+      out:
+        snd_card_free(card);
+        return err;
 }
 
@@ -376 +362 @@
 {
         static unsigned long possible_ports[] = {0x220, 0x240, 0x260, -1};
-        int dev, cards;
+        int dev, cards, i;
 
         for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev] > 0; dev++) {
@@ -384 +370 @@
                         cards++;
         }
-        cards += snd_legacy_auto_probe(possible_ports, snd_gusextreme_legacy_auto_probe);
+        i = snd_legacy_auto_probe(possible_ports, snd_gusextreme_legacy_auto_probe);
+        if (i > 0)
+                cards += i;
+
         if (!cards) {
 #ifdef MODULE

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

@@ -386 +386 @@
 {
         static unsigned long possible_ports[] = {0x220, 0x230, 0x240, 0x250, 0x260, -1};
-        int dev, cards;
+        int dev, cards, i;
 
         for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev] > 0; dev++) {
@@ -394 +394 @@
                         cards++;
         }
-        cards += snd_legacy_auto_probe(possible_ports, snd_gusmax_legacy_auto_probe);
+        i = snd_legacy_auto_probe(possible_ports, snd_gusmax_legacy_auto_probe);
+        if (i > 0)
+                cards += i;
+
         if (!cards) {
 #ifdef MODULE

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

@@ -942 +942 @@
 static int __init alsa_card_interwave_init(void)
 {
-        int cards = 0;
+        int cards = 0, i;
         static long possible_ports[] = {0x210, 0x220, 0x230, 0x240, 0x250, 0x260, -1};
         int dev;
@@ -962 +962 @@
         }
         /* legacy auto configured cards */
-        cards += snd_legacy_auto_probe(possible_ports, snd_interwave_probe_legacy_port);
+        i = snd_legacy_auto_probe(possible_ports, snd_interwave_probe_legacy_port);
+        if (i > 0)
+                cards += i;
 #ifdef CONFIG_PNP
         /* ISA PnP cards */
-        cards += pnp_register_card_driver(&interwave_pnpc_driver);
+        i = pnp_register_card_driver(&interwave_pnpc_driver);
+        if (i > 0)
+                cards += i;
 #endif
 

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

@@ -312 +312 @@
 {
         while (*port_table != -1) {
-                if (!check_region(*port_table, size))
+                struct resource *res;
+                if ((res = request_region(*port_table, size, "ALSA test")) != NULL) {
+                        release_resource(res);
+                        kfree_nocheck(res);
                         return *port_table;
+                }
                 port_table++;
         }
@@ -1400 +1404 @@
         strcpy(pcm->name, snd_opti93x_chip_id(codec));
 
-        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, codec->dma1 > 3 || codec->dma2 > 3 ? 128*1024 : 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024, codec->dma1 > 3 || codec->dma2 > 3 ? 128*1024 : 64*1024);
 
         codec->pcm = pcm;
@@ -1673 +1679 @@
                         return err;
 
-                if (check_region(chip->mc_base, chip->mc_base_size))
+                if ((chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL)
                         continue;
 
@@ -1680 +1686 @@
                         if (value == snd_opti9xx_read(chip, OPTi9XX_MC_REG(1)))
                                 return 1;
+
+                release_resource(chip->res_mc_base);
+                kfree_nocheck(chip->res_mc_base);
+                chip->res_mc_base = NULL;
+
         }
 #else   /* OPTi93X */
@@ -1689 +1700 @@
                         return err;
 
-                if (check_region(chip->mc_base, chip->mc_base_size))
+                if ((chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL)
                         continue;
 
@@ -1702 +1713 @@
                 if (snd_opti9xx_read(chip, OPTi9XX_MC_REG(7)) == 0xff - value)
                         return 1;
+
+                release_resource(chip->res_mc_base);
+                kfree_nocheck(chip->res_mc_base);
+                chip->res_mc_base = NULL;
         }
 #endif  /* OPTi93X */
@@ -1985 +2000 @@
 #endif  /* CONFIG_PNP */
 
-        if ((chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL) {
+        if (! chip->res_mc_base &&
+            (chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL) {
                 snd_card_free(card);
                 return -ENOMEM;

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

@@ -226 +226 @@
 static int __init alsa_card_es968_init(void)
 {
-        int res = pnp_register_card_driver(&es968_pnpc_driver);
-        if (res == 0)
-        {
+        int cards = pnp_register_card_driver(&es968_pnpc_driver);
+#ifdef MODULE
+        if (cards == 0) {
                 pnp_unregister_card_driver(&es968_pnpc_driver);
-#ifdef MODULE
                 snd_printk(KERN_ERR "no ES968 based soundcards found\n");
+        }
 #endif
-        }
-        return res < 0 ? res : 0;
+        return cards ? 0 : -ENODEV;
 }
 

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

@@ -644 +644 @@
     static int __init alsa_card_sb16_init(void)
     {
-        int dev, cards = 0;
+        int dev, cards = 0, i;
         static unsigned long possible_ports[] = {0x220, 0x240, 0x260, 0x280, -1};
 
@@ -664 +664 @@
         }
         /* legacy auto configured cards */
-        cards += snd_legacy_auto_probe(possible_ports, snd_sb16_probe_legacy_port);
+        i = snd_legacy_auto_probe(possible_ports, snd_sb16_probe_legacy_port);
+        if (i > 0)
+                cards += i;
+
 #ifdef CONFIG_PNP
         /* PnP cards at last */
-        cards += pnp_register_card_driver(&sb16_pnpc_driver);
+        i = pnp_register_card_driver(&sb16_pnpc_driver);
+        if (i >0)
+                cards += i;
 #endif
 

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

@@ -882 +882 @@
                 pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
 
-        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, 128*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024, 128*1024);
 
     if (rpcm)

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

@@ -200 +200 @@
 {
     static unsigned long possible_ports[] = {0x220, 0x240, 0x260, -1};
-    int dev, cards;
+        int dev, cards, i;
 
         for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) {
@@ -208 +208 @@
             cards++;
     }
-    cards += snd_legacy_auto_probe(possible_ports, snd_card_sb8_legacy_auto_probe);
+        i = snd_legacy_auto_probe(possible_ports, snd_card_sb8_legacy_auto_probe);
+        if (i > 0)
+                cards += i;
+
     if (!cards) {
 #ifdef MODULE

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

@@ -536 +536 @@
     snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb8_capture_ops);
 
-        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_isa_data(),
+                                              64*1024, 64*1024);
 
     if (rpcm)

GPL/branches/alsa-resync1/alsa-kernel/pci/ac97/ac97_patch.c

@@ -2161 +2161 @@
         unsigned short misc;
 
+        patch_ad1881(ac97);
         ac97->build_ops = &patch_ad1985_build_ops;
         misc = snd_ac97_read(ac97, AC97_AD_MISC);

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

@@ -101 +101 @@
 static struct pci_device_id snd_emu10k1_ids[] = {
     { 0x1102, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },        /* EMU10K1 */
+#if 0 /* FIXME: not working! */
         { 0x1102, 0x0006, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },    /* Dell OEM version (EMU10K1) */
+#endif
     { 0x1102, 0x0004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },        /* Audigy */
     { 0x1102, 0x0008, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },    /* Audigy 2 Value SB0400 */

GPL/branches/alsa-resync1/alsa-kernel/pci/emu10k1/emu10k1_callback.c

@@ -428 +428 @@
                 /* invalidate maps */
                 temp = ((unsigned int)hw->silent_page.addr << 1) | MAP_PTI_MASK;
-//              temp = ((unsigned int)hw->silent_page_dmaaddr << 1) | MAP_PTI_MASK;
                 snd_emu10k1_ptr_write(hw, MAPA, ch, temp);
                 snd_emu10k1_ptr_write(hw, MAPB, ch, temp);

GPL/branches/alsa-resync1/alsa-kernel/pci/emu10k1/emufx.c

@@ -30 +30 @@
 
 #include <sound/driver.h>
+#include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/slab.h>

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

@@ -410 +410 @@
         unsigned int i;
 
-        if (ice->eeprom.subvendor == VT1724_SUBDEVICE_AUREON51_SKY)
+        if (ice->eeprom.subvendor == VT1724_SUBDEVICE_AUREON51_SKY) {
                 ice->num_total_dacs = 6;
-        else
+                ice->num_total_adcs = 6;
+        } else {
                 ice->num_total_dacs = 8;
+                ice->num_total_adcs = 8;
+        }
 
         /* to remeber the register values */

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

@@ -91 +91 @@
                 break;
         case ICE1712_SUBDEVICE_AUDIOPHILE:
+        case ICE1712_SUBDEVICE_DELTA410:
                 tmp |= ICE1712_DELTA_AP_CCLK | ICE1712_DELTA_AP_CS_CODEC;
                 tmp &= ~ICE1712_DELTA_AP_CS_DIGITAL;
@@ -113 +114 @@
                 break;
         case ICE1712_SUBDEVICE_AUDIOPHILE:
+        case ICE1712_SUBDEVICE_DELTA410:
                 tmp |= ICE1712_DELTA_AP_CS_DIGITAL;
                 break;
@@ -512 +514 @@
         case ICE1712_SUBDEVICE_AUDIOPHILE:
                 ice->num_total_dacs = 2;
+                ice->num_total_adcs = 2;
                 break;
         case ICE1712_SUBDEVICE_DELTA410:
                 ice->num_total_dacs = 8;
+                ice->num_total_adcs = 2;
                 break;
         case ICE1712_SUBDEVICE_DELTA44:
         case ICE1712_SUBDEVICE_DELTA66:
                 ice->num_total_dacs = ice->omni ? 8 : 4;
+                ice->num_total_adcs = ice->omni ? 8 : 4;
                 break;
         case ICE1712_SUBDEVICE_DELTA1010:
         case ICE1712_SUBDEVICE_DELTA1010LT:
                 ice->num_total_dacs = 8;
+                ice->num_total_adcs = 8;
                 break;
         case ICE1712_SUBDEVICE_VX442:
                 ice->num_total_dacs = 4;
+                ice->num_total_adcs = 4;
                 break;
         }

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

@@ -407 +407 @@
         case ICE1712_SUBDEVICE_EWX2496:
                 ice->num_total_dacs = 2;
+                ice->num_total_adcs = 2;
                 break;  
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88MT_NEW:
                 ice->num_total_dacs = 8;
+                ice->num_total_adcs = 8;
                 break;
         case ICE1712_SUBDEVICE_EWS88D:
@@ -416 +418 @@
         case ICE1712_SUBDEVICE_DMX6FIRE:
                 ice->num_total_dacs = 6;
+                ice->num_total_adcs = 6;
                 break;
         }

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

@@ -154 +154 @@
 
         ice->num_total_dacs = 8;
+        ice->num_total_adcs = 8;
 
         ice->hoontech_boxbits[0] = 

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

@@ -83 +83 @@
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;              /* Enable this card */
 static int omni[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 0};   /* Delta44 & 66 Omni I/O support */
+static int cs8427_timeout[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 500}; /* CS8427 S/PDIF transciever reset timeout value in msec */
 
 MODULE_PARM(index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
@@ -96 +97 @@
 MODULE_PARM_DESC(omni, "Enable Midiman M-Audio Delta Omni I/O support.");
 MODULE_PARM_SYNTAX(omni, SNDRV_ENABLED "," SNDRV_ENABLE_DESC);
+MODULE_PARM(cs8427_timeout, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
+MODULE_PARM_DESC(cs8427_timeout, "Define reset timeout for cs8427 chip in msec resolution.");
+MODULE_PARM_SYNTAX(cs8427_timeout, SNDRV_ENABLED ", allows:{{1,1000}},default=500,skill:advanced");
 
 #ifndef PCI_VENDOR_ID_ICE
@@ -387 +391 @@
         int err;
 
-        if ((err = snd_cs8427_create(ice->i2c, addr, &ice->cs8427)) < 0) {
+        if ((err = snd_cs8427_create(ice->i2c, addr,
+                                     (ice->cs8427_timeout * HZ) / 1000,
+                                     &ice->cs8427)) < 0) {
                 snd_printk("CS8427 initialization failed\n");
                 return err;
@@ -887 +893 @@
         ice->pcm = pcm;
 
-        snd_pcm_lib_preallocate_pci_pages_for_all(ice->pci, pcm, 64*1024, 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(ice->pci), 64*1024, 64*1024);
 
         if (rpcm)
@@ -923 +930 @@
         ice->pcm_ds = pcm;
 
-        snd_pcm_lib_preallocate_pci_pages_for_all(ice->pci, pcm, 64*1024, 128*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(ice->pci), 64*1024, 128*1024);
 
         if (rpcm)
@@ -1270 +1278 @@
         strcpy(pcm->name, "ICE1712 multi");
 
-        snd_pcm_lib_preallocate_pci_pages_for_all(ice->pci, pcm, 256*1024, 256*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(ice->pci), 256*1024, 256*1024);
 
         ice->pcm_pro = pcm;
@@ -1382 +1391 @@
 
 
-static snd_kcontrol_new_t snd_ice1712_multi_ctrls[] __devinitdata = {
+static snd_kcontrol_new_t snd_ice1712_multi_playback_ctrls[] __devinitdata = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1401 +1410 @@
                 .count = 10,
         },
-        {
+};
+
+static snd_kcontrol_new_t snd_ice1712_multi_capture_analog_switch __devinitdata = {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Multi Capture Switch",
+        .name = "H/W 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,
-        },
-        {
+};
+
+static snd_kcontrol_new_t snd_ice1712_multi_capture_spdif_switch __devinitdata = {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Multi Capture Volume",
+        .name = "IEC958 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 = 18,
+        .count = 2,
+};
+
+static snd_kcontrol_new_t snd_ice1712_multi_capture_analog_volume __devinitdata = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "H/W 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 snd_kcontrol_new_t snd_ice1712_multi_capture_spdif_volume __devinitdata = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "IEC958 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 = 18,
+        .count = 2,
 };
 
@@ -1428 +1457 @@
 
         /* 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));
+        for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_multi_playback_ctrls); idx++) {
+                err = snd_ctl_add(card, snd_ctl_new1(&snd_ice1712_multi_playback_ctrls[idx], ice));
                 if (err < 0)
                         return err;
         }
         
+        if (ice->num_total_adcs > 0) {
+                snd_kcontrol_new_t tmp = snd_ice1712_multi_capture_analog_switch;
+                tmp.count = ice->num_total_adcs;
+                err = snd_ctl_add(card, snd_ctl_new1(&tmp, ice));
+                if (err < 0)
+                        return err;
+        }
+
+        err = snd_ctl_add(card, snd_ctl_new1(&snd_ice1712_multi_capture_spdif_switch, ice));
+        if (err < 0)
+                return err;
+
+        if (ice->num_total_adcs > 0) {
+                snd_kcontrol_new_t tmp = snd_ice1712_multi_capture_analog_volume;
+                tmp.count = ice->num_total_adcs;
+                err = snd_ctl_add(card, snd_ctl_new1(&tmp, ice));
+                if (err < 0)
+                        return err;
+        }
+
+        err = snd_ctl_add(card, snd_ctl_new1(&snd_ice1712_multi_capture_spdif_volume, ice));
+        if (err < 0)
+                return err;
+
         /* initialize volumes */
-        for (idx = 0; idx < 20; idx++) {
+        for (idx = 0; idx < 10; idx++) {
                 ice->pro_volumes[idx] = 0x80008000;     /* mute */
                 snd_ice1712_update_volume(ice, idx);
         }
+        for (idx = 10; idx < 10 + ice->num_total_adcs; idx++) {
+                ice->pro_volumes[idx] = 0x80008000;     /* mute */
+                snd_ice1712_update_volume(ice, idx);
+        }
+        for (idx = 18; idx < 20; idx++) {
+                ice->pro_volumes[idx] = 0x80008000;     /* mute */
+                snd_ice1712_update_volume(ice, idx);
+        }
         return 0;
 }
@@ -1451 +1512 @@
 {
         int err;
+        ac97_t ac97;
+        ac97_bus_t bus, *pbus;
 
         if (ice_has_con_ac97(ice)) {
-                ac97_bus_t bus, *pbus;
-                ac97_t ac97;
                 memset(&bus, 0, sizeof(bus));
                 bus.write = snd_ice1712_ac97_write;
@@ -1473 +1534 @@
 
         if (! (ice->eeprom.data[ICE_EEP1_ACLINK] & ICE1712_CFG_PRO_I2S)) {
-                ac97_bus_t bus, *pbus;
-                ac97_t ac97;
                 memset(&bus, 0, sizeof(bus));
                 bus.write = snd_ice1712_pro_ac97_write;
@@ -2350 +2409 @@
                                      struct pci_dev *pci,
                                      int omni,
+                                        int cs8427_timeout,
                                      ice1712_t ** r_ice1712)
 {
@@ -2374 +2434 @@
                 return -ENOMEM;
         ice->omni = omni ? 1 : 0;
+        if (cs8427_timeout < 1)
+                cs8427_timeout = 1;
+        else if (cs8427_timeout > 1000)
+                cs8427_timeout = 1000;
+        ice->cs8427_timeout = cs8427_timeout;
         spin_lock_init(&ice->reg_lock);
         init_MUTEX(&ice->gpio_mutex);
@@ -2493 +2558 @@
         strcpy(card->shortname, "ICEnsemble ICE1712");
         
-        if ((err = snd_ice1712_create(card, pci, omni[dev], &ice)) < 0) {
+        if ((err = snd_ice1712_create(card, pci, omni[dev], cs8427_timeout[dev], &ice)) < 0) {
                 snd_card_free(card);
                 return err;

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

@@ -331 +331 @@
         unsigned int vt1724: 1;
         unsigned int num_total_dacs;    /* total DACs */
+        unsigned int num_total_adcs;    /* total ADCs */
         unsigned char hoontech_boxbits[4];
         unsigned int hoontech_config;
@@ -346 +347 @@
         snd_i2c_device_t *cs8404;       /* CS8404A I2C device */
         snd_i2c_device_t *cs8427;       /* CS8427 I2C device */
+        unsigned int cs8427_timeout;    /* CS8427 reset timeout in HZ/100 */
         snd_i2c_device_t *i2cdevs[2];   /* additional i2c devices */
         

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

@@ -757 +757 @@
         strcpy(pcm->name, "ICE1724");
 
-        snd_pcm_lib_preallocate_pci_pages_for_all(ice->pci, pcm, 256*1024, 256*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(ice->pci), 256*1024, 256*1024);
 
         ice->pcm_pro = pcm;
@@ -911 +912 @@
         strcpy(pcm->name, "ICE1724 IEC958");
 
-        snd_pcm_lib_preallocate_pci_pages_for_all(ice->pci, pcm, 64*1024, 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(ice->pci), 64*1024, 64*1024);
 
         ice->pcm = pcm;
@@ -1032 +1034 @@
         strcpy(pcm->name, "ICE1724 Surround PCM");
 
-        snd_pcm_lib_preallocate_pci_pages_for_all(ice->pci, pcm, 64*1024, 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(ice->pci), 64*1024, 64*1024);
 
         ice->pcm_ds = pcm;

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

@@ -129 +129 @@
         case VT1724_SUBDEVICE_REVOLUTION71:
                 ice->num_total_dacs = 8;
+                ice->num_total_adcs = 4;
                 break;
         default:

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

@@ -108 +108 @@
 MODULE_PARM(ac97_quirk, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
 MODULE_PARM_DESC(ac97_quirk, "AC'97 workaround for strange hardware.");
-MODULE_PARM_SYNTAX(ac97_quirk, SNDRV_ENABLED ",allows:{{-1,3}},dialog:list,default:-1");
+MODULE_PARM_SYNTAX(ac97_quirk, SNDRV_ENABLED ",allows:{{-1,4}},dialog:list,default:-1");
 #ifdef SUPPORT_JOYSTICK
 MODULE_PARM(joystick, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
@@ -862 +862 @@
 
     if ((status & chip->int_sta_mask) == 0) {
-        static int err_count = 10;
         if (status) {
             /* ack */
@@ -2982 +2981 @@
         /* workaround for 440MX */
         if (chip->fix_nocache)
-                fill_nocache(chip->bdbars, chip->bdbars_count * sizeof(u32) * ICH_MAX_FRAGS * 2, 1);
+                fill_nocache(chip->bdbars.area, chip->bdbars.bytes, 1);
     int_sta_masks = 0;
     for (i = 0; i < chip->bdbars_count; i++) {
@@ -3237 +3236 @@
     pci_read_config_word(pci, 0xe6, &val);
 #ifdef SUPPORT_JOYSTICK
+        val &= ~0x100;
     if (joystick[dev]) {
         if (! request_region(ich_gameport.io, 8, "ICH gameport")) {
@@ -3249 +3249 @@
 #endif
 #ifdef SUPPORT_MIDI
+        val &= ~0x20;
     if (mpu_port[dev] > 0) {
         if (mpu_port[dev] == 0x300 || mpu_port[dev] == 0x330) {

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

@@ -348 +348 @@
         struct resource *res_iomem2;
 
+        struct snd_dma_device dma_dev;
+
+        struct snd_dma_buffer dma_dsp;
+        struct snd_dma_buffer dma_play;
+        struct snd_dma_buffer dma_rec;
+        struct snd_dma_buffer dma_shared;
+
         u32 dspCodeSize;
-        u32 dspMemPhy;          // DSP memory block handle (Physical Address)
-        void * dspMemPtr;       //            block memory (Virtual Address)
 
         u32 DataBufsSize;
@@ -358 +363 @@
 
         KorgSharedBuffer * sharedBufferPtr;
+
         u32 RecDataPhy;
         u32 PlayDataPhy;
@@ -1239 +1245 @@
         snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_IN_PROCESS);
 
-        memcpy(korg1212->dspMemPtr, dspCode, korg1212->dspCodeSize);
+        memcpy(korg1212->dma_dsp.area, dspCode, korg1212->dspCodeSize);
 
         rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_StartDSPDownload,
-                                     UpperWordSwap(korg1212->dspMemPhy),
+                                     UpperWordSwap(korg1212->dma_dsp.addr),
                                      0, 0, 0);
 
@@ -2135 +2141 @@
         // free up memory resources used for the DSP download.
         // ----------------------------------------------------
-        if (korg1212->dspMemPtr) {
-                snd_free_pci_pages(korg1212->pci, korg1212->dspCodeSize,
-                                   korg1212->dspMemPtr, (dma_addr_t)korg1212->dspMemPhy);
-                korg1212->dspMemPhy = 0;
-                korg1212->dspMemPtr = 0;
-                korg1212->dspCodeSize = 0;
+        if (korg1212->dma_dsp.area) {
+                snd_dma_free_pages(&korg1212->dma_dev, &korg1212->dma_dsp);
+                korg1212->dma_dsp.area = NULL;
         }
 
@@ -2148 +2151 @@
         // free up memory resources used for the Play/Rec Buffers
         // ------------------------------------------------------
-        if (korg1212->playDataBufsPtr) {
-                snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
-                                   korg1212->playDataBufsPtr, (dma_addr_t)korg1212->PlayDataPhy);
-                korg1212->PlayDataPhy = 0;
-                korg1212->playDataBufsPtr = NULL;
-        }
-
-        if (korg1212->recordDataBufsPtr) {
-                snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
-                                   korg1212->recordDataBufsPtr, (dma_addr_t)korg1212->RecDataPhy);
-                korg1212->RecDataPhy = 0;
-                korg1212->recordDataBufsPtr = NULL;
+        if (korg1212->dma_play.area) {
+                snd_dma_free_pages(&korg1212->dma_dev, &korg1212->dma_play);
+                korg1212->dma_play.area = NULL;
+        }
+
+        if (korg1212->dma_rec.area) {
+                snd_dma_free_pages(&korg1212->dma_dev, &korg1212->dma_rec);
+                korg1212->dma_rec.area = NULL;
         }
 
@@ -2167 +2166 @@
         // free up memory resources used for the Shared Buffers
         // ----------------------------------------------------
-        if (korg1212->sharedBufferPtr) {
-                snd_free_pci_pages(korg1212->pci, (u32) sizeof(KorgSharedBuffer),
-                                   korg1212->sharedBufferPtr, (dma_addr_t)korg1212->sharedBufferPhy);
-                korg1212->sharedBufferPhy = 0;
-                korg1212->sharedBufferPtr = NULL;
+        if (korg1212->dma_shared.area) {
+                snd_dma_free_pages(&korg1212->dma_dev, &korg1212->dma_shared);
+                korg1212->dma_shared.area = NULL;
         }
         
@@ -2194 +2191 @@
         unsigned int i;
         unsigned ioport_size, iomem_size, iomem2_size;
-        dma_addr_t phys_addr;
         korg1212_t * korg1212;
 
@@ -2333 +2329 @@
 #endif
 
-        korg1212->sharedBufferPtr = (KorgSharedBuffer *) snd_malloc_pci_pages(korg1212->pci, sizeof(KorgSharedBuffer), &phys_addr);
-        korg1212->sharedBufferPhy = (unsigned long)phys_addr;
-
-        if (korg1212->sharedBufferPtr == NULL) {
+        memset(&korg1212->dma_dev, 0, sizeof(korg1212->dma_dev));
+        korg1212->dma_dev.type = SNDRV_DMA_TYPE_DEV;
+        korg1212->dma_dev.dev = snd_dma_pci_data(korg1212->pci);
+
+        if (snd_dma_alloc_pages(&korg1212->dma_dev, sizeof(KorgSharedBuffer), &korg1212->dma_shared) < 0) {
                 snd_printk(KERN_ERR "can not allocate shared buffer memory (%Zd bytes)\n", sizeof(KorgSharedBuffer));
                 return -ENOMEM;
         }
+        korg1212->sharedBufferPtr = (KorgSharedBuffer *)korg1212->dma_shared.area;
+        korg1212->sharedBufferPhy = korg1212->dma_shared.addr;
 
 #if K1212_DEBUG_LEVEL > 0
@@ -2349 +2348 @@
         korg1212->DataBufsSize = sizeof(KorgAudioBuffer) * kNumBuffers;
 
-        korg1212->playDataBufsPtr = (KorgAudioBuffer *) snd_malloc_pci_pages(korg1212->pci, korg1212->DataBufsSize, &phys_addr);
-        korg1212->PlayDataPhy = (u32)phys_addr;
-
-        if (korg1212->playDataBufsPtr == NULL) {
+        if (snd_dma_alloc_pages(&korg1212->dma_dev, korg1212->DataBufsSize, &korg1212->dma_play) < 0) {
                 snd_printk(KERN_ERR "can not allocate play data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
                 return -ENOMEM;
         }
+        korg1212->playDataBufsPtr = (KorgAudioBuffer *)korg1212->dma_play.area;
+        korg1212->PlayDataPhy = korg1212->dma_play.addr;
 
 #if K1212_DEBUG_LEVEL > 0
@@ -2362 +2360 @@
 #endif
 
-        korg1212->recordDataBufsPtr = (KorgAudioBuffer *) snd_malloc_pci_pages(korg1212->pci, korg1212->DataBufsSize, &phys_addr);
-        korg1212->RecDataPhy = (u32)phys_addr;
-
-        if (korg1212->recordDataBufsPtr == NULL) {
+        if (snd_dma_alloc_pages(&korg1212->dma_dev, korg1212->DataBufsSize, &korg1212->dma_rec) < 0) {
                 snd_printk(KERN_ERR "can not allocate record data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
                 return -ENOMEM;
         }
+        korg1212->recordDataBufsPtr = (KorgAudioBuffer *)korg1212->dma_rec.area;
+        korg1212->RecDataPhy = korg1212->dma_rec.addr;
 
 #if K1212_DEBUG_LEVEL > 0
         K1212_DEBUG_PRINTK("K1212_DEBUG: Record Data Area = 0x%p (0x%08x), %d bytes\n",
-                korg1212->recordDataBufsPtr, korg1212->RecDataPhy, korg1212->DataBufsSize);
+                korg1212->recordDataBufsPtr, korg1212->RecDataBufsPhy, korg1212->DataBufsSize);
 #endif
 
@@ -2393 +2390 @@
                 offsetof(KorgSharedBuffer, AdatTimeCode);
 
-        korg1212->dspMemPtr = snd_malloc_pci_pages(korg1212->pci, korg1212->dspCodeSize, &phys_addr);
-        korg1212->dspMemPhy = (u32)phys_addr;
-
-        if (korg1212->dspMemPtr == NULL) {
+        if (snd_dma_alloc_pages(&korg1212->dma_dev, korg1212->dspCodeSize, &korg1212->dma_dsp) < 0) {
                 snd_printk(KERN_ERR "can not allocate dsp code memory (%d bytes)\n", korg1212->dspCodeSize);
                 return -ENOMEM;
@@ -2403 +2397 @@
 #if K1212_DEBUG_LEVEL > 0
         K1212_DEBUG_PRINTK("K1212_DEBUG: DSP Code area = 0x%p (0x%08x) %d bytes [%s]\n",
-                   korg1212->dspMemPtr, korg1212->dspMemPhy, korg1212->dspCodeSize,
+                   korg1212->dma_dsp.area, korg1212->dma_dsp.addr, korg1212->dspCodeSize,
                    stateName[korg1212->cardState]);
 #endif
@@ -2426 +2420 @@
                "RoutingTablePhy = %08x L[%08x]\n"
                "AdatTimeCodePhy = %08x L[%08x]\n",
-               korg1212->dspMemPhy,       UpperWordSwap(korg1212->dspMemPhy),
+               korg1212->dma_dsp.addr,    UpperWordSwap(korg1212->dma_dsp.addr),
                korg1212->PlayDataPhy,     LowerWordSwap(korg1212->PlayDataPhy),
                korg1212->RecDataPhy,      LowerWordSwap(korg1212->RecDataPhy),

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

@@ -1719 +1719 @@
         rme96->spdif_pcm->info_flags = 0;
 
-        snd_pcm_lib_preallocate_pages_for_all(rme96->spdif_pcm, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE, GFP_KERNEL);
+        snd_pcm_lib_preallocate_pages_for_all(rme96->spdif_pcm,
+                                              SNDRV_DMA_TYPE_CONTINUOUS,
+                                              snd_dma_continuous_data(GFP_KERNEL),
+                                              RME96_BUFFER_SIZE,
+                                              RME96_BUFFER_SIZE);
 
         /* set up ALSA pcm device for ADAT */
@@ -1739 +1743 @@
                 rme96->adat_pcm->info_flags = 0;
 
-                snd_pcm_lib_preallocate_pages_for_all(rme96->adat_pcm, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE, GFP_KERNEL);
+                snd_pcm_lib_preallocate_pages_for_all(rme96->adat_pcm,
+                                                      SNDRV_DMA_TYPE_CONTINUOUS,
+                                                      snd_dma_continuous_data(GFP_KERNEL),
+                                                      RME96_BUFFER_SIZE,
+                                                      RME96_BUFFER_SIZE);
         }
 

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

@@ -570 +570 @@
         struct snd_dma_buffer dmbuf;
 
-        snd_dma_device_pci(&pdev, pci, capture);
+        memset(&pdev, 0, sizeof(pdev));
+        pdev.type = SNDRV_DMA_TYPE_DEV;
+        pdev.dev = snd_dma_pci_data(pci);
+        pdev.id = capture;
         dmbuf.bytes = 0;
         if (! snd_dma_get_reserved(&pdev, &dmbuf)) {
@@ -583 +586 @@
 static void snd_hammerfall_free_buffer(struct pci_dev *pci, size_t size, void *ptr, dma_addr_t addr, int capture)
 {
-        struct snd_dma_device dev;
-        snd_dma_device_pci(&dev, pci, capture);
-        snd_dma_free_reserved(&dev);
+        struct snd_dma_device pdev;
+
+        memset(&pdev, 0, sizeof(pdev));
+        pdev.type = SNDRV_DMA_TYPE_DEV;
+        pdev.dev = snd_dma_pci_data(pci);
+        pdev.id = capture;
+        snd_dma_free_reserved(&pdev);
 }
 

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

@@ -315 +315 @@
         struct snd_dma_buffer dmbuf;
 
-        snd_dma_device_pci(&pdev, pci, capture);
+        memset(&pdev, 0, sizeof(pdev));
+        pdev.type = SNDRV_DMA_TYPE_DEV;
+        pdev.dev = snd_dma_pci_data(pci);
+        pdev.id = capture;
         dmbuf.bytes = 0;
         if (! snd_dma_get_reserved(&pdev, &dmbuf)) {
@@ -328 +331 @@
 static void snd_hammerfall_free_buffer(struct pci_dev *pci, size_t size, void *ptr, dma_addr_t addr, int capture)
 {
-        struct snd_dma_device dev;
-        snd_dma_device_pci(&dev, pci, capture);
-        snd_dma_free_reserved(&dev);
+        struct snd_dma_device pdev;
+
+        memset(&pdev, 0, sizeof(pdev));
+        pdev.type = SNDRV_DMA_TYPE_DEV;
+        pdev.dev = snd_dma_pci_data(pci);
+        pdev.id = capture;
+        snd_dma_free_reserved(&pdev);
 }
 

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

@@ -891 +891 @@
         sonic->pcm = pcm;
 
-        snd_pcm_lib_preallocate_pci_pages_for_all(sonic->pci, pcm, 64*1024, 128*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(sonic->pci), 64*1024, 128*1024);
 
         if (rpcm)

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

@@ -3580 +3580 @@
     }
     trident->irq = pci->irq;
+
+        memset(&trident->dma_dev, 0, sizeof(trident->dma_dev));
+        trident->dma_dev.type = SNDRV_DMA_TYPE_DEV;
+        trident->dma_dev.dev = snd_dma_pci_data(pci);
 
     /* allocate 16k-aligned TLB for NX cards */

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

@@ -80 +80 @@
     __set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr);
     __set_tlb_bus(trident, page+1, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr);
-//      __set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page, trident->tlb.silent_page_dmaaddr);
-//      __set_tlb_bus(trident, page+1, (unsigned long)trident->tlb.silent_page, trident->tlb.silent_page_dmaaddr);
 }
 
@@ -116 +114 @@
         for (i = 0; i < UNIT_PAGES; i++, page++)
             __set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr);
-            //    __set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page, trident->tlb.silent_page_dmaaddr);
 }