Changeset 366

Timestamp:

08/30/08 21:18:38 (3 months ago)

Author:

gentux2

Message:

Missed stuff in 1.0.4

Location:

GPL/branches/alsa-resync1/alsa-kernel

Files:

• core/memalloc.c (modified) (7 diffs)
• core/seq/seq_clientmgr.c (modified) (1 diff)
• include/sound/adriver.h (modified) (2 diffs)
• pci/ac97/ac97_pcm.c (modified) (1 diff)
• pci/cmipci.c (modified) (2 diffs)
• pci/intel8x0.c (modified) (3 diffs)

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

@@ -26 +26 @@
 #include <sound/info.h>
 #include <linux/proc_fs.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
 #include <sound/memalloc.h>
 #ifdef CONFIG_SBUS
@@ -66 +68 @@
 #define SNDRV_DMA_DEVICE_UNUSED (unsigned int)-1
 
-#ifdef CONFIG_PCI
+/*
+ *  Hacks
+ */
+
 #if defined(__i386__) || defined(__ppc__) || defined(__x86_64__)
-
 /*
  * A hack to allocate large buffers via dma_alloc_coherent()
@@ -121 +125 @@
 #define dma_free_coherent(dev,size,ptr,addr) pci_free_consistent((struct pci_dev *)(dev),size,ptr,addr)
 
-#endif /* CONFIG_PCI */
+/*
+ *
+ *  Generic memory allocators
+ *
+ */
+
+static long snd_allocated_pages; /* holding the number of allocated pages */
+
+static inline void inc_snd_pages(int order)
+{
+        snd_allocated_pages += 1 << order;
+}
+
+static inline void dec_snd_pages(int order)
+{
+        snd_allocated_pages -= 1 << order;
+}
+
+/**
+ * snd_malloc_pages - allocate pages with the given size
+ * @size: the size to allocate in bytes
+ * @gfp_flags: the allocation conditions, GFP_XXX
+ *
+ * Allocates the physically contiguous pages with the given size.
+ *
+ * Returns the pointer of the buffer, or NULL if no enoguh memory.
+ */
+void *snd_malloc_pages(size_t size, unsigned int dma_flags)
+{
+    int pg;
+    void *res;
+
+    snd_assert(size > 0, return NULL);
+    snd_assert(dma_flags != 0, return NULL);
+    pg = get_order(size);
+    if ((res = (void *) __get_free_pages(dma_flags, pg)) != NULL) {
+        inc_snd_pages(pg);
+    }
+    return res;
+}
+
+/**
+ * snd_malloc_pages_fallback - allocate pages with the given size with fallback
+ * @size: the requested size to allocate in bytes
+ * @gfp_flags: the allocation conditions, GFP_XXX
+ * @res_size: the pointer to store the size of buffer actually allocated
+ *
+ * Allocates the physically contiguous pages with the given request
+ * size.  When no space is left, this function reduces the size and
+ * tries to allocate again.  The size actually allocated is stored in
+ * res_size argument.
+ *
+ * Returns the pointer of the buffer, or NULL if no enoguh memory.
+ */            
+void *snd_malloc_pages_fallback(size_t size, unsigned int gfp_flags, size_t *res_size)
+{
+        void *res;
+
+        snd_assert(size > 0, return NULL);
+        snd_assert(res_size != NULL, return NULL);
+        do {
+                if ((res = snd_malloc_pages(size, gfp_flags)) != NULL) {
+                        *res_size = size;
+                        return res;
+                }
+                size >>= 1;
+        } while (size >= PAGE_SIZE);
+        return NULL;
+}
+
+/**
+ * snd_free_pages - release the pages
+ * @ptr: the buffer pointer to release
+ * @size: the allocated buffer size
+ *
+ * Releases the buffer allocated via snd_malloc_pages().
+ */
+void snd_free_pages(void *ptr, size_t size)
+{
+    int pg;
+    struct page *page, *last_page;
+
+    if (ptr == NULL)
+        return;
+    pg = get_order(size);
+    dec_snd_pages(pg);
+    free_pages((unsigned long) ptr, pg);
+}
+
+/*
+ *
+ *  Bus-specific memory allocators
+ *
+ */
 
 /* allocate the coherent DMA pages */
@@ -156 +253 @@
         dma_free_coherent(dev, PAGE_SIZE << pg, ptr, dma);
 }
+
+#ifdef CONFIG_SBUS
+
+static void *snd_malloc_sbus_pages(struct device *dev, size_t size,
+                            dma_addr_t *dma_addr)
+{
+        struct sbus_dev *sdev = (struct sbus_dev *)dev;
+        int pg;
+        void *res;
+
+        snd_assert(size > 0, return NULL);
+        snd_assert(dma_addr != NULL, return NULL);
+        pg = get_order(size);
+        res = sbus_alloc_consistent(sdev, PAGE_SIZE * (1 << pg), dma_addr);
+        if (res != NULL)
+            inc_snd_pages(pg);
+        return res;
+}
+
+static void *snd_malloc_sbus_pages_fallback(struct device *dev, size_t size,
+                                            dma_addr_t *dma_addr, size_t *res_size)
+{
+        void *res;
+
+        snd_assert(res_size != NULL, return NULL);
+        do {
+                if ((res = snd_malloc_sbus_pages(dev, size, dma_addr)) != NULL) {
+                        *res_size = size;
+                        return res;
+                }
+                size >>= 1;
+        } while (size >= PAGE_SIZE);
+        return NULL;
+}
+
+static void snd_free_sbus_pages(struct device *dev, size_t size,
+                                void *ptr, dma_addr_t dma_addr)
+{
+        int pg;
+
+        if (ptr == NULL)
+            return;
+        pg = get_order(size);
+        dec_snd_pages(pg);
+        sbus_free_consistent(sdev, PAGE_SIZE * (1 << pg), ptr, dma_addr);
+}
+
+#endif /* CONFIG_SBUS */
+
+/*
+ *
+ *  ALSA generic memory management
+ *
+ */
 
 #if ! defined(__arm__)
@@ -247 +398 @@
 }
 
+
 /**
  * snd_dma_free_pages - release the allocated buffer
@@ -353 +505 @@
 
 
-/*
- *
- *  Generic memory allocators
- *
- */
-
 /* Pure 2^n version of get_order */
 static inline int get_order(unsigned int size)
@@ -373 +519 @@
 }
 
-static long snd_allocated_pages; /* holding the number of allocated pages */
-
-static inline void inc_snd_pages(int order)
-{
-        snd_allocated_pages += 1 << order;
-}
-
-static inline void dec_snd_pages(int order)
-{
-        snd_allocated_pages -= 1 << order;
-}
-
-
-/**
- * snd_malloc_pages - allocate pages with the given size
- * @size: the size to allocate in bytes
- * @gfp_flags: the allocation conditions, GFP_XXX
- *
- * Allocates the physically contiguous pages with the given size.
- *
- * Returns the pointer of the buffer, or NULL if no enoguh memory.
- */
-void *snd_malloc_pages(size_t size, unsigned int dma_flags)
-{
-    int pg;
-    void *res;
-
-    snd_assert(size > 0, return NULL);
-    snd_assert(dma_flags != 0, return NULL);
-    pg = get_order(size);
-    if ((res = (void *) __get_free_pages(dma_flags, pg)) != NULL) {
-        inc_snd_pages(pg);
-    }
-    return res;
-}
-
-/**
- * snd_free_pages - release the pages
- * @ptr: the buffer pointer to release
- * @size: the allocated buffer size
- *
- * Releases the buffer allocated via snd_malloc_pages().
- */
-void snd_free_pages(void *ptr, size_t size)
-{
-    int pg;
-    struct page *page, *last_page;
-
-    if (ptr == NULL)
-        return;
-    pg = get_order(size);
-    dec_snd_pages(pg);
-    free_pages((unsigned long) ptr, pg);
-}
-
-#if defined(CONFIG_ISA) && ! defined(CONFIG_PCI)
-
-/**
- * snd_malloc_isa_pages - allocate pages for ISA bus with the given size
- * @size: the size to allocate in bytes
- * @dma_addr: the pointer to store the physical address of the buffer
- *
- * Allocates the physically contiguous pages with the given size for
- * ISA bus.
- *
- * Returns the pointer of the buffer, or NULL if no enoguh memory.
- */
-void *snd_malloc_isa_pages(size_t size, dma_addr_t *dma_addr)
-{
-        void *dma_area;
-        dma_area = snd_malloc_pages(size, GFP_ATOMIC|GFP_DMA);
-        *dma_addr = dma_area ? isa_virt_to_bus(dma_area) : 0UL;
-        return dma_area;
-}
-
-/**
- * snd_malloc_isa_pages_fallback - allocate pages with the given size with fallback for ISA bus
- * @size: the requested size to allocate in bytes
- * @dma_addr: the pointer to store the physical address of the buffer
- * @res_size: the pointer to store the size of buffer actually allocated
- *
- * Allocates the physically contiguous pages with the given request
- * size for PCI bus.  When no space is left, this function reduces the size and
- * tries to allocate again.  The size actually allocated is stored in
- * res_size argument.
- *
- * Returns the pointer of the buffer, or NULL if no enoguh memory.
- */
-void *snd_malloc_isa_pages_fallback(size_t size,
-                                    dma_addr_t *dma_addr,
-                                    size_t *res_size)
-{
-        void *dma_area;
-        dma_area = snd_malloc_pages_fallback(size, GFP_ATOMIC|GFP_DMA, res_size);
-        *dma_addr = dma_area ? isa_virt_to_bus(dma_area) : 0UL;
-        return dma_area;
-}
-
-#endif /* CONFIG_ISA && !CONFIG_PCI */
-
-#ifdef CONFIG_PCI
-
-/**
- * snd_malloc_pci_pages - allocate pages for PCI bus with the given size
- * @pci: the pci device pointer
- * @size: the size to allocate in bytes
- * @dma_addr: the pointer to store the physical address of the buffer
- *
- * Allocates the physically contiguous pages with the given size for
- * PCI bus.
- *
- * Returns the pointer of the buffer, or NULL if no enoguh memory.
- */
-void *snd_malloc_pci_pages(struct pci_dev *pci,
-                           size_t size,
-                           dma_addr_t *dmaaddr)
-{
-        int pg;
-        void *res;
-#ifdef DEBUG
-        dprintf(("snd_malloc_pci_pages. size = %d",size));
-#endif
-        snd_assert(size > 0, return NULL);
-        snd_assert(dmaaddr != NULL, return NULL);
-        for (pg = 0; PAGE_SIZE * (1 << pg) < size; pg++);
-        res = pci_alloc_consistent(pci, PAGE_SIZE * (1 << pg), dmaaddr);
-        if (res != NULL) {
-            inc_snd_pages(pg);
-        }
-        return res;
-}
-
-/**
- * snd_malloc_pci_pages_fallback - allocate pages with the given size with fallback for PCI bus
- * @pci: pci device pointer
- * @size: the requested size to allocate in bytes
- * @dma_addr: the pointer to store the physical address of the buffer
- * @res_size: the pointer to store the size of buffer actually allocated
- *
- * Allocates the physically contiguous pages with the given request
- * size for PCI bus.  When no space is left, this function reduces the size and
- * tries to allocate again.  The size actually allocated is stored in
- * res_size argument.
- *
- * Returns the pointer of the buffer, or NULL if no enoguh memory.
- */
-void *snd_malloc_pci_pages_fallback(struct pci_dev *pci, size_t size,
-                                    dma_addr_t *dmaaddr,
-                                    size_t *res_size)
-{
-        void *res;
-
-        snd_assert(res_size != NULL, return NULL);
-        do {
-                if ((res = snd_malloc_pci_pages(pci, size, dmaaddr)) != NULL) {
-                        *res_size = size;
-                        return res;
-                }
-                size >>= 1;
-        } while (size >= PAGE_SIZE);
-        return NULL;
-}
-
-/**
- * snd_free_pci_pages - release the pages
- * @pci: pci device pointer
- * @size: the allocated buffer size
- * @ptr: the buffer pointer to release
- * @dma_addr: the physical address of the buffer
- *
- * Releases the buffer allocated via snd_malloc_pci_pages().
- */
-void snd_free_pci_pages(struct pci_dev *pci, size_t size, void *ptr, dma_addr_t dmaaddr)
-{
-        int pg;
-        mem_map_t *page, *last_page;
-
-        if (ptr == NULL)
-                return;
-        for (pg = 0; PAGE_SIZE * (1 << pg) < size; pg++);
-        dec_snd_pages(pg);
-        pci_free_consistent(pci, PAGE_SIZE * (1 << pg), ptr, dmaaddr);
-}
-
-#if defined(__i386__)
-/*
- * on ix86, we allocate a page with GFP_KERNEL to assure the
- * allocation.  the code is almost same with kernel/i386/pci-dma.c but
- * it allocates only a single page and checks the validity of the
- * page address with the given pci dma mask.
- */
-
-/**
- * snd_malloc_pci_page - allocate a page in the valid pci dma mask
- * @pci: pci device pointer
- * @addrp: the pointer to store the physical address of the buffer
- *
- * Allocates a single page for the given PCI device and returns
- * the virtual address and stores the physical address on addrp.
- *
- * This function cannot be called from interrupt handlers or
- * within spinlocks.
- */
-void *snd_malloc_pci_page(struct pci_dev *pci, dma_addr_t *addrp)
-{
-        void *ptr;
-        dma_addr_t addr;
-        unsigned long mask;
-
-        mask = pci ? (unsigned long)pci->consistent_dma_mask : 0x00ffffffUL;
-        ptr = (void *)__get_free_page(GFP_KERNEL);
-        if (ptr) {
-                addr = virt_to_phys(ptr);
-                if (((unsigned long)addr + PAGE_SIZE - 1) & ~mask) {
-                        /* try to reallocate with the GFP_DMA */
-                        free_page((unsigned long)ptr);
-                        /* use GFP_ATOMIC for the DMA zone to avoid stall */
-                        ptr = (void *)__get_free_page(GFP_ATOMIC | GFP_DMA);
-                        if (ptr) /* ok, the address must be within lower 16MB... */
-                                addr = virt_to_phys(ptr);
-                        else
-                                addr = 0;
-                }
-        } else
-                addr = 0;
-        if (ptr) {
-                memset(ptr, 0, PAGE_SIZE);
-        }
-        *addrp = addr;
-        return ptr;
-}
-#else
-
-/* on other architectures, call snd_malloc_pci_pages() helper function
- * which uses pci_alloc_consistent().
- */
-void *snd_malloc_pci_page(struct pci_dev *pci, dma_addr_t *addrp)
-{
-        return snd_malloc_pci_pages(pci, PAGE_SIZE, addrp);
-}
-
-#endif
-
-#endif /* CONFIG_PCI */
-
-#ifdef CONFIG_SBUS
-
-/**
- * snd_malloc_sbus_pages - allocate pages for SBUS with the given size
- * @sdev: sbus device pointer
- * @size: the size to allocate in bytes
- * @dma_addr: the pointer to store the physical address of the buffer
- *
- * Allocates the physically contiguous pages with the given size for
- * SBUS.
- *
- * Returns the pointer of the buffer, or NULL if no enoguh memory.
- */
-void *snd_malloc_sbus_pages(struct sbus_dev *sdev,
-                            size_t size,
-                            dma_addr_t *dma_addr)
-{
-        int pg;
-        void *res;
-
-        snd_assert(size > 0, return NULL);
-        snd_assert(dma_addr != NULL, return NULL);
-        pg = get_order(size);
-        res = sbus_alloc_consistent(sdev, PAGE_SIZE * (1 << pg), dma_addr);
-        if (res != NULL)
-            inc_snd_pages(pg);
-        return res;
-}
-
-/**
- * snd_malloc_pci_pages_fallback - allocate pages with the given size with fallback for SBUS
- * @sdev: sbus device pointer
- * @size: the requested size to allocate in bytes
- * @dma_addr: the pointer to store the physical address of the buffer
- * @res_size: the pointer to store the size of buffer actually allocated
- *
- * Allocates the physically contiguous pages with the given request
- * size for SBUS.  When no space is left, this function reduces the size and
- * tries to allocate again.  The size actually allocated is stored in
- * res_size argument.
- *
- * Returns the pointer of the buffer, or NULL if no enoguh memory.
- */
-/**
- * snd_free_sbus_pages - release the pages
- * @sdev: sbus device pointer
- * @size: the allocated buffer size
- * @ptr: the buffer pointer to release
- * @dma_addr: the physical address of the buffer
- *
- * Releases the buffer allocated via snd_malloc_pci_pages().
- */
-void snd_free_sbus_pages(struct sbus_dev *sdev,
-                         size_t size,
-                         void *ptr,
-                         dma_addr_t dma_addr)
-{
-        int pg;
-
-        if (ptr == NULL)
-            return;
-        pg = get_order(size);
-        dec_snd_pages(pg);
-        sbus_free_consistent(sdev, PAGE_SIZE * (1 << pg), ptr, dma_addr);
-}
-
-#endif /* CONFIG_SBUS */
+
 
 /*

GPL/branches/alsa-resync1/alsa-kernel/core/seq/seq_clientmgr.c

@@ -567 +567 @@
 
 /*
- * expand a quoted event.
- */
-static int expand_quoted_event(snd_seq_event_t *event)
-{
-        snd_seq_event_t *quoted;
-
-        quoted = event->data.quote.event;
-        if (quoted == NULL) {
-                snd_printd("seq: quoted event is NULL\n");
-                return -EINVAL;
-        }
-
-        event->type = quoted->type;
-        event->tag = quoted->tag;
-        event->source = quoted->source;
-        /* don't use quoted destination */
-        event->data = quoted->data;
-        /* use quoted timestamp only if subscription/port didn't update it */
-        if (event->queue == SNDRV_SEQ_QUEUE_DIRECT) {
-                event->flags = quoted->flags;
-                event->queue = quoted->queue;
-                event->time = quoted->time;
-        } else {
-                event->flags = (event->flags & SNDRV_SEQ_TIME_STAMP_MASK)
-                        | (quoted->flags & ~SNDRV_SEQ_TIME_STAMP_MASK);
-        }
-        return 0;
-}
-
-/*
  * deliver an event to the specified destination.
  * if filter is non-zero, client filter bitmap is tested.

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

@@ -37 +37 @@
 #endif
 
-#ifdef ALSA_BUILD
+#if defined(ALSA_BUILD) && LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
 #if defined(CONFIG_MODVERSIONS) && !defined(__GENKSYMS__) && !defined(__DEPEND__)
 #define MODVERSIONS
@@ -47 +47 @@
 #undef _set_ver
 #endif
-#endif /* ALSA_BUILD */
+#endif /* ALSA_BUILD && KERNEL < 2.6.0 */
 
 #include <linux/module.h>

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

@@ -213 +213 @@
                 snd_ac97_update_bits_nolock(ac97, reg, mask, bits);
                 /* update the internal spdif bits */
-                sbits = ac97->spdif_status;
-                if (sbits & IEC958_AES0_PROFESSIONAL) {
-                        sbits &= ~IEC958_AES0_PRO_FS;
-                        switch (rate) {
-                        case 44100: sbits |= IEC958_AES0_PRO_FS_44100; break;
-                        case 48000: sbits |= IEC958_AES0_PRO_FS_48000; break;
-                        case 32000: sbits |= IEC958_AES0_PRO_FS_32000; break;
-                        }
-                } else {
-                        sbits &= ~(IEC958_AES3_CON_FS << 24);
-                        switch (rate) {
-                        case 44100: sbits |= IEC958_AES3_CON_FS_44100<<24; break;
-                        case 48000: sbits |= IEC958_AES3_CON_FS_48000<<24; break;
-                        case 32000: sbits |= IEC958_AES3_CON_FS_32000<<24; break;
-                        }
-                }
-                ac97->spdif_status = sbits;
-                /* update the internal spdif bits */
 #ifndef TARGET_OS2
                 spin_lock(&ac97->reg_lock);

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

@@ -2627 +2627 @@
  */
 
-static void snd_cmipci_proc_read(struct snd_info_entry *entry,
+#ifdef CONFIG_PROC_FS
+static void snd_cmipci_proc_read(struct snd_info_entry *entry, 
                                  struct snd_info_buffer *buffer)
 {
@@ -2649 +2650 @@
 {
     struct snd_info_entry *entry;
+
     if (! snd_card_proc_new(cm->card, "cmipci", &entry))
         snd_info_set_text_ops(entry, cm, 1024, snd_cmipci_proc_read);
 }
+#else /* !CONFIG_PROC_FS */
+static inline void snd_cmipci_proc_init(struct cmipci *cm) {}
+#endif
+
 
 static struct pci_device_id snd_cmipci_ids[] = {

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

@@ -42 +42 @@
 #define SNDRV_GET_ID
 #include <sound/initval.h>
+/* for 440MX workaround */
+#include <asm/pgtable.h>
+#include <asm/cacheflush.h>
 
 #define I810_DEBUG
@@ -82 +85 @@
 #else
 static int ac97_clock[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
+static int ac97_quirk[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = AC97_TUNE_DEFAULT};
 #endif
 #ifdef SUPPORT_JOYSTICK
@@ -865 +869 @@
             /* ack */
             iputdword(chip, chip->int_sta_reg, status);
-            /* FIXME: on some ICH5 board shows the same
-             *        problem.  So we return IRQ_HANDLED
-             *        in any cases.
-             * (or, maybe add a new module param to control this?)
-             */
-#if 0
-            if (chip->device_type != DEVICE_NFORCE)
-                status ^= igetdword(chip, chip->int_sta_reg);
-#endif
-        }
-        return IRQ_NONE/*RETVAL(status)*/;
+                        /* some Nforce[2] boards have problems when
+                           IRQ_NONE is returned here.
+                        */
+                        if (chip->device_type != DEVICE_NFORCE)
+                                status = 0;
+        }
+                spin_unlock(&chip->reg_lock);
+        return IRQ_RETVAL(status);
     }
 #ifdef TARGET_OS2