1 /** 2 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved. 3 * 4 * This source file is released under GPL v2 license (no other versions). 5 * See the COPYING file included in the main directory of this source 6 * distribution for the license terms and conditions. 7 * 8 * @File ctvmem.c 9 * 10 * @Brief 11 * This file contains the implementation of virtual memory management object 12 * for card device. 13 * 14 * @Author Liu Chun 15 * @Date Apr 1 2008 16 */ 17 18 #include "ctvmem.h" 19 #include <linux/slab.h> 20 #include <linux/mm.h> 21 #include <linux/io.h> 22 #include <sound/pcm.h> 23 24 #define CT_PTES_PER_PAGE (CT_PAGE_SIZE / sizeof(void *)) 25 #define CT_ADDRS_PER_PAGE (CT_PTES_PER_PAGE * CT_PAGE_SIZE) 26 27 /* * 28 * Find or create vm block based on requested @size. 29 * @size must be page aligned. 30 * */ 31 static struct ct_vm_block * 32 get_vm_block(struct ct_vm *vm, unsigned int size) 33 { 34 struct ct_vm_block *block = NULL, *entry; 35 struct list_head *pos; 36 37 size = CT_PAGE_ALIGN(size); 38 if (size > vm->size) { 39 printk(KERN_ERR "ctxfi: Fail! No sufficient device virtural " 40 "memory space available!\n"); 41 return NULL; 42 } 43 44 mutex_lock(&vm->lock); 45 list_for_each(pos, &vm->unused) { 46 entry = list_entry(pos, struct ct_vm_block, list); 47 if (entry->size >= size) 48 break; /* found a block that is big enough */ 49 } 50 if (pos == &vm->unused) 51 goto out; 52 53 if (entry->size == size) { 54 /* Move the vm node from unused list to used list directly */ 55 list_del(&entry->list); 56 list_add(&entry->list, &vm->used); 57 vm->size -= size; 58 block = entry; 59 goto out; 60 } 61 62 block = kzalloc(sizeof(*block), GFP_KERNEL); 63 if (!block) 64 goto out; 65 66 block->addr = entry->addr; 67 block->size = size; 68 list_add(&block->list, &vm->used); 69 entry->addr += size; 70 entry->size -= size; 71 vm->size -= size; 72 73 out: 74 mutex_unlock(&vm->lock); 75 return block; 76 } 77 78 static void put_vm_block(struct ct_vm *vm, struct ct_vm_block *block) 79 { 80 struct ct_vm_block *entry, *pre_ent; 81 struct list_head *pos, *pre; 82 83 block->size = CT_PAGE_ALIGN(block->size); 84 85 mutex_lock(&vm->lock); 86 list_del(&block->list); 87 vm->size += block->size; 88 89 list_for_each(pos, &vm->unused) { 90 entry = list_entry(pos, struct ct_vm_block, list); 91 if (entry->addr >= (block->addr + block->size)) 92 break; /* found a position */ 93 } 94 if (pos == &vm->unused) { 95 list_add_tail(&block->list, &vm->unused); 96 entry = block; 97 } else { 98 if ((block->addr + block->size) == entry->addr) { 99 entry->addr = block->addr; 100 entry->size += block->size; 101 kfree(block); 102 } else { 103 __list_add(&block->list, pos->prev, pos); 104 entry = block; 105 } 106 } 107 108 pos = &entry->list; 109 pre = pos->prev; 110 while (pre != &vm->unused) { 111 entry = list_entry(pos, struct ct_vm_block, list); 112 pre_ent = list_entry(pre, struct ct_vm_block, list); 113 if ((pre_ent->addr + pre_ent->size) > entry->addr) 114 break; 115 116 pre_ent->size += entry->size; 117 list_del(pos); 118 kfree(entry); 119 pos = pre; 120 pre = pos->prev; 121 } 122 mutex_unlock(&vm->lock); 123 } 124 125 /* Map host addr (kmalloced/vmalloced) to device logical addr. */ 126 static struct ct_vm_block * 127 ct_vm_map(struct ct_vm *vm, struct snd_pcm_substream *substream, int size) 128 { 129 struct ct_vm_block *block; 130 unsigned int pte_start; 131 unsigned i, pages; 132 unsigned long *ptp; 133 134 block = get_vm_block(vm, size); 135 if (block == NULL) { 136 printk(KERN_ERR "ctxfi: No virtual memory block that is big " 137 "enough to allocate!\n"); 138 return NULL; 139 } 140 141 ptp = (unsigned long *)vm->ptp[0].area; 142 pte_start = (block->addr >> CT_PAGE_SHIFT); 143 pages = block->size >> CT_PAGE_SHIFT; 144 for (i = 0; i < pages; i++) { 145 unsigned long addr; 146 addr = snd_pcm_sgbuf_get_addr(substream, i << CT_PAGE_SHIFT); 147 ptp[pte_start + i] = addr; 148 } 149 150 block->size = size; 151 return block; 152 } 153 154 static void ct_vm_unmap(struct ct_vm *vm, struct ct_vm_block *block) 155 { 156 /* do unmapping */ 157 put_vm_block(vm, block); 158 } 159 160 /* * 161 * return the host physical addr of the @index-th device 162 * page table page on success, or ~0UL on failure. 163 * The first returned ~0UL indicates the termination. 164 * */ 165 static dma_addr_t 166 ct_get_ptp_phys(struct ct_vm *vm, int index) 167 { 168 dma_addr_t addr; 169 170 addr = (index >= CT_PTP_NUM) ? ~0UL : vm->ptp[index].addr; 171 172 return addr; 173 } 174 175 int ct_vm_create(struct ct_vm **rvm, struct pci_dev *pci) 176 { 177 struct ct_vm *vm; 178 struct ct_vm_block *block; 179 int i, err = 0; 180 181 *rvm = NULL; 182 183 vm = kzalloc(sizeof(*vm), GFP_KERNEL); 184 if (!vm) 185 return -ENOMEM; 186 187 mutex_init(&vm->lock); 188 189 /* Allocate page table pages */ 190 for (i = 0; i < CT_PTP_NUM; i++) { 191 err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, 192 snd_dma_pci_data(pci), 193 PAGE_SIZE, &vm->ptp[i]); 194 if (err < 0) 195 break; 196 } 197 if (err < 0) { 198 /* no page table pages are allocated */ 199 ct_vm_destroy(vm); 200 return -ENOMEM; 201 } 202 vm->size = CT_ADDRS_PER_PAGE * i; 203 vm->map = ct_vm_map; 204 vm->unmap = ct_vm_unmap; 205 vm->get_ptp_phys = ct_get_ptp_phys; 206 INIT_LIST_HEAD(&vm->unused); 207 INIT_LIST_HEAD(&vm->used); 208 block = kzalloc(sizeof(*block), GFP_KERNEL); 209 if (NULL != block) { 210 block->addr = 0; 211 block->size = vm->size; 212 list_add(&block->list, &vm->unused); 213 } 214 215 *rvm = vm; 216 return 0; 217 } 218 219 /* The caller must ensure no mapping pages are being used 220 * by hardware before calling this function */ 221 void ct_vm_destroy(struct ct_vm *vm) 222 { 223 int i; 224 struct list_head *pos; 225 struct ct_vm_block *entry; 226 227 /* free used and unused list nodes */ 228 while (!list_empty(&vm->used)) { 229 pos = vm->used.next; 230 list_del(pos); 231 entry = list_entry(pos, struct ct_vm_block, list); 232 kfree(entry); 233 } 234 while (!list_empty(&vm->unused)) { 235 pos = vm->unused.next; 236 list_del(pos); 237 entry = list_entry(pos, struct ct_vm_block, list); 238 kfree(entry); 239 } 240 241 /* free allocated page table pages */ 242 for (i = 0; i < CT_PTP_NUM; i++) 243 snd_dma_free_pages(&vm->ptp[i]); 244 245 vm->size = 0; 246 247 kfree(vm); 248 } 249