ALSA: ctxfi - Remove PAGE_SIZE limitation
authorTakashi Iwai <tiwai@suse.de>
Tue, 2 Jun 2009 13:04:29 +0000 (15:04 +0200)
committerTakashi Iwai <tiwai@suse.de>
Tue, 2 Jun 2009 13:54:46 +0000 (15:54 +0200)
Remove the limitation of PAGE_SIZE to be 4k by defining the own
page size and macros for 4k.  8kb page size could be natively supported,
but it's disabled right now for simplicity.

Also, clean up using upper_32_bits() macro.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
sound/pci/Kconfig
sound/pci/ctxfi/cthw20k1.c
sound/pci/ctxfi/cthw20k2.c
sound/pci/ctxfi/ctvmem.c
sound/pci/ctxfi/ctvmem.h

index 2d7fef5df0178b85655145b922e10d8414aaa1e8..3a7640feaf92b6162c4a7d803b4bad653e7cd67b 100644 (file)
@@ -277,7 +277,6 @@ config SND_CS5535AUDIO
 
 config SND_CTXFI
        tristate "Creative Sound Blaster X-Fi"
 
 config SND_CTXFI
        tristate "Creative Sound Blaster X-Fi"
-       depends on X86
        select SND_PCM
        help
          If you want to use soundcards based on Creative Sound Blastr X-Fi
        select SND_PCM
        help
          If you want to use soundcards based on Creative Sound Blastr X-Fi
index 44283bd7b2df3e6ff4818108e52bac7296e6ae71..b7b8e6f41d0d9050fc3042753970a8cbe1ce1bfa 100644 (file)
@@ -1249,18 +1249,14 @@ static int hw_trn_init(struct hw *hw, const struct trn_conf *info)
        }
 
        trnctl = 0x13;  /* 32-bit, 4k-size page */
        }
 
        trnctl = 0x13;  /* 32-bit, 4k-size page */
-#if BITS_PER_LONG == 64
-       ptp_phys_low = info->vm_pgt_phys & ((1UL<<32)-1);
-       ptp_phys_high = (info->vm_pgt_phys>>32) & ((1UL<<32)-1);
-       trnctl |= (1<<2);
-#elif BITS_PER_LONG == 32
-       ptp_phys_low = info->vm_pgt_phys & (~0UL);
-       ptp_phys_high = 0;
-#else
-#      error "Unknown BITS_PER_LONG!"
-#endif
+       ptp_phys_low = (u32)info->vm_pgt_phys;
+       ptp_phys_high = upper_32_bits(info->vm_pgt_phys);
+       if (sizeof(void *) == 8) /* 64bit address */
+               trnctl |= (1 << 2);
+#if 0 /* Only 4k h/w pages for simplicitiy */
 #if PAGE_SIZE == 8192
        trnctl |= (1<<5);
 #if PAGE_SIZE == 8192
        trnctl |= (1<<5);
+#endif
 #endif
        hw_write_20kx(hw, PTPALX, ptp_phys_low);
        hw_write_20kx(hw, PTPAHX, ptp_phys_high);
 #endif
        hw_write_20kx(hw, PTPALX, ptp_phys_low);
        hw_write_20kx(hw, PTPAHX, ptp_phys_high);
index 7c24c2ca96bdc8c8c8ab24ee52e23b27f9546424..349728765f2c6068e4dbe39521d29cf49c41c8e1 100644 (file)
@@ -1203,19 +1203,10 @@ static int hw_trn_init(struct hw *hw, const struct trn_conf *info)
        }
 
        vmctl = 0x80000C0F;  /* 32-bit, 4k-size page */
        }
 
        vmctl = 0x80000C0F;  /* 32-bit, 4k-size page */
-#if BITS_PER_LONG == 64
-       ptp_phys_low = info->vm_pgt_phys & ((1UL<<32)-1);
-       ptp_phys_high = (info->vm_pgt_phys>>32) & ((1UL<<32)-1);
-       vmctl |= (3<<8);
-#elif BITS_PER_LONG == 32
-       ptp_phys_low = info->vm_pgt_phys & (~0UL);
-       ptp_phys_high = 0;
-#else
-#      error "Unknown BITS_PER_LONG!"
-#endif
-#if PAGE_SIZE == 8192
-#      error "Don't support 8k-page!"
-#endif
+       ptp_phys_low = (u32)info->vm_pgt_phys;
+       ptp_phys_high = upper_32_bits(info->vm_pgt_phys);
+       if (sizeof(void *) == 8) /* 64bit address */
+               vmctl |= (3 << 8);
        /* Write page table physical address to all PTPAL registers */
        for (i = 0; i < 64; i++) {
                hw_write_20kx(hw, VMEM_PTPAL+(16*i), ptp_phys_low);
        /* Write page table physical address to all PTPAL registers */
        for (i = 0; i < 64; i++) {
                hw_write_20kx(hw, VMEM_PTPAL+(16*i), ptp_phys_low);
index 363b67e3a9e7e814260ecd7163e876a394db418c..74a03623d047ae2b51b8e17c5dc3daec77a05ad4 100644 (file)
 #include "ctvmem.h"
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include "ctvmem.h"
 #include <linux/slab.h>
 #include <linux/mm.h>
-#include <asm/page.h>  /* for PAGE_SIZE macro definition */
 #include <linux/io.h>
 #include <asm/pgtable.h>
 
 #include <linux/io.h>
 #include <asm/pgtable.h>
 
-#define CT_PTES_PER_PAGE (PAGE_SIZE / sizeof(void *))
-#define CT_ADDRS_PER_PAGE (CT_PTES_PER_PAGE * PAGE_SIZE)
+#define CT_PTES_PER_PAGE (CT_PAGE_SIZE / sizeof(void *))
+#define CT_ADDRS_PER_PAGE (CT_PTES_PER_PAGE * CT_PAGE_SIZE)
 
 /* *
  * Find or create vm block based on requested @size.
 
 /* *
  * Find or create vm block based on requested @size.
@@ -138,24 +137,24 @@ ct_vm_map(struct ct_vm *vm, void *host_addr, int size)
                return NULL;
        }
 
                return NULL;
        }
 
-       start_phys = (virt_to_phys(host_addr) & PAGE_MASK);
-       pages = (PAGE_ALIGN(virt_to_phys(host_addr) + size)
-                       - start_phys) >> PAGE_SHIFT;
+       start_phys = (virt_to_phys(host_addr) & CT_PAGE_MASK);
+       pages = (CT_PAGE_ALIGN(virt_to_phys(host_addr) + size)
+                       - start_phys) >> CT_PAGE_SHIFT;
 
        ptp = vm->ptp[0];
 
 
        ptp = vm->ptp[0];
 
-       block = get_vm_block(vm, (pages << PAGE_SHIFT));
+       block = get_vm_block(vm, (pages << CT_PAGE_SHIFT));
        if (block == NULL) {
                printk(KERN_ERR "ctxfi: No virtual memory block that is big "
                                  "enough to allocate!\n");
                return NULL;
        }
 
        if (block == NULL) {
                printk(KERN_ERR "ctxfi: No virtual memory block that is big "
                                  "enough to allocate!\n");
                return NULL;
        }
 
-       pte_start = (block->addr >> PAGE_SHIFT);
+       pte_start = (block->addr >> CT_PAGE_SHIFT);
        for (i = 0; i < pages; i++)
        for (i = 0; i < pages; i++)
-               ptp[pte_start+i] = start_phys + (i << PAGE_SHIFT);
+               ptp[pte_start+i] = start_phys + (i << CT_PAGE_SHIFT);
 
 
-       block->addr += (virt_to_phys(host_addr) & (~PAGE_MASK));
+       block->addr += (virt_to_phys(host_addr) & (~CT_PAGE_MASK));
        block->size = size;
 
        return block;
        block->size = size;
 
        return block;
@@ -164,9 +163,9 @@ ct_vm_map(struct ct_vm *vm, void *host_addr, int size)
 static void ct_vm_unmap(struct ct_vm *vm, struct ct_vm_block *block)
 {
        /* do unmapping */
 static void ct_vm_unmap(struct ct_vm *vm, struct ct_vm_block *block)
 {
        /* do unmapping */
-       block->size = ((block->addr + block->size + PAGE_SIZE - 1)
-                       & PAGE_MASK) - (block->addr & PAGE_MASK);
-       block->addr &= PAGE_MASK;
+       block->size = ((block->addr + block->size + CT_PAGE_SIZE - 1)
+                       & CT_PAGE_MASK) - (block->addr & CT_PAGE_MASK);
+       block->addr &= CT_PAGE_MASK;
        put_vm_block(vm, block);
 }
 
        put_vm_block(vm, block);
 }
 
index 618952efa5b369b3f29d1fd90edd443806e04fe8..17d2d37a9ea71c7dd53a46a6bec121168ffab130 100644 (file)
 #include <linux/mutex.h>
 #include <linux/list.h>
 
 #include <linux/mutex.h>
 #include <linux/list.h>
 
+/* The chip can handle the page table of 4k pages
+ * (emu20k1 can handle even 8k pages, but we don't use it right now)
+ */
+#define CT_PAGE_SIZE   4096
+#define CT_PAGE_SHIFT  12
+#define CT_PAGE_MASK   (~(PAGE_SIZE - 1))
+#define CT_PAGE_ALIGN(addr)    ALIGN(addr, CT_PAGE_SIZE)
+
 struct ct_vm_block {
        unsigned int addr;      /* starting logical addr of this block */
        unsigned int size;      /* size of this device virtual mem block */
 struct ct_vm_block {
        unsigned int addr;      /* starting logical addr of this block */
        unsigned int size;      /* size of this device virtual mem block */