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 *
get_vm_block(struct ct_vm * vm,unsigned int size)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 virtual "
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_move(&entry->list, &vm->used);
56 vm->size -= size;
57 block = entry;
58 goto out;
59 }
60
61 block = kzalloc(sizeof(*block), GFP_KERNEL);
62 if (!block)
63 goto out;
64
65 block->addr = entry->addr;
66 block->size = size;
67 list_add(&block->list, &vm->used);
68 entry->addr += size;
69 entry->size -= size;
70 vm->size -= size;
71
72 out:
73 mutex_unlock(&vm->lock);
74 return block;
75 }
76
put_vm_block(struct ct_vm * vm,struct ct_vm_block * block)77 static void put_vm_block(struct ct_vm *vm, struct ct_vm_block *block)
78 {
79 struct ct_vm_block *entry, *pre_ent;
80 struct list_head *pos, *pre;
81
82 block->size = CT_PAGE_ALIGN(block->size);
83
84 mutex_lock(&vm->lock);
85 list_del(&block->list);
86 vm->size += block->size;
87
88 list_for_each(pos, &vm->unused) {
89 entry = list_entry(pos, struct ct_vm_block, list);
90 if (entry->addr >= (block->addr + block->size))
91 break; /* found a position */
92 }
93 if (pos == &vm->unused) {
94 list_add_tail(&block->list, &vm->unused);
95 entry = block;
96 } else {
97 if ((block->addr + block->size) == entry->addr) {
98 entry->addr = block->addr;
99 entry->size += block->size;
100 kfree(block);
101 } else {
102 __list_add(&block->list, pos->prev, pos);
103 entry = block;
104 }
105 }
106
107 pos = &entry->list;
108 pre = pos->prev;
109 while (pre != &vm->unused) {
110 entry = list_entry(pos, struct ct_vm_block, list);
111 pre_ent = list_entry(pre, struct ct_vm_block, list);
112 if ((pre_ent->addr + pre_ent->size) > entry->addr)
113 break;
114
115 pre_ent->size += entry->size;
116 list_del(pos);
117 kfree(entry);
118 pos = pre;
119 pre = pos->prev;
120 }
121 mutex_unlock(&vm->lock);
122 }
123
124 /* Map host addr (kmalloced/vmalloced) to device logical addr. */
125 static struct ct_vm_block *
ct_vm_map(struct ct_vm * vm,struct snd_pcm_substream * substream,int size)126 ct_vm_map(struct ct_vm *vm, struct snd_pcm_substream *substream, int size)
127 {
128 struct ct_vm_block *block;
129 unsigned int pte_start;
130 unsigned i, pages;
131 unsigned long *ptp;
132
133 block = get_vm_block(vm, size);
134 if (block == NULL) {
135 printk(KERN_ERR "ctxfi: No virtual memory block that is big "
136 "enough to allocate!\n");
137 return NULL;
138 }
139
140 ptp = (unsigned long *)vm->ptp[0].area;
141 pte_start = (block->addr >> CT_PAGE_SHIFT);
142 pages = block->size >> CT_PAGE_SHIFT;
143 for (i = 0; i < pages; i++) {
144 unsigned long addr;
145 addr = snd_pcm_sgbuf_get_addr(substream, i << CT_PAGE_SHIFT);
146 ptp[pte_start + i] = addr;
147 }
148
149 block->size = size;
150 return block;
151 }
152
ct_vm_unmap(struct ct_vm * vm,struct ct_vm_block * block)153 static void ct_vm_unmap(struct ct_vm *vm, struct ct_vm_block *block)
154 {
155 /* do unmapping */
156 put_vm_block(vm, block);
157 }
158
159 /* *
160 * return the host physical addr of the @index-th device
161 * page table page on success, or ~0UL on failure.
162 * The first returned ~0UL indicates the termination.
163 * */
164 static dma_addr_t
ct_get_ptp_phys(struct ct_vm * vm,int index)165 ct_get_ptp_phys(struct ct_vm *vm, int index)
166 {
167 dma_addr_t addr;
168
169 addr = (index >= CT_PTP_NUM) ? ~0UL : vm->ptp[index].addr;
170
171 return addr;
172 }
173
ct_vm_create(struct ct_vm ** rvm,struct pci_dev * pci)174 int ct_vm_create(struct ct_vm **rvm, struct pci_dev *pci)
175 {
176 struct ct_vm *vm;
177 struct ct_vm_block *block;
178 int i, err = 0;
179
180 *rvm = NULL;
181
182 vm = kzalloc(sizeof(*vm), GFP_KERNEL);
183 if (!vm)
184 return -ENOMEM;
185
186 mutex_init(&vm->lock);
187
188 /* Allocate page table pages */
189 for (i = 0; i < CT_PTP_NUM; i++) {
190 err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
191 snd_dma_pci_data(pci),
192 PAGE_SIZE, &vm->ptp[i]);
193 if (err < 0)
194 break;
195 }
196 if (err < 0) {
197 /* no page table pages are allocated */
198 ct_vm_destroy(vm);
199 return -ENOMEM;
200 }
201 vm->size = CT_ADDRS_PER_PAGE * i;
202 vm->map = ct_vm_map;
203 vm->unmap = ct_vm_unmap;
204 vm->get_ptp_phys = ct_get_ptp_phys;
205 INIT_LIST_HEAD(&vm->unused);
206 INIT_LIST_HEAD(&vm->used);
207 block = kzalloc(sizeof(*block), GFP_KERNEL);
208 if (NULL != block) {
209 block->addr = 0;
210 block->size = vm->size;
211 list_add(&block->list, &vm->unused);
212 }
213
214 *rvm = vm;
215 return 0;
216 }
217
218 /* The caller must ensure no mapping pages are being used
219 * by hardware before calling this function */
ct_vm_destroy(struct ct_vm * vm)220 void ct_vm_destroy(struct ct_vm *vm)
221 {
222 int i;
223 struct list_head *pos;
224 struct ct_vm_block *entry;
225
226 /* free used and unused list nodes */
227 while (!list_empty(&vm->used)) {
228 pos = vm->used.next;
229 list_del(pos);
230 entry = list_entry(pos, struct ct_vm_block, list);
231 kfree(entry);
232 }
233 while (!list_empty(&vm->unused)) {
234 pos = vm->unused.next;
235 list_del(pos);
236 entry = list_entry(pos, struct ct_vm_block, list);
237 kfree(entry);
238 }
239
240 /* free allocated page table pages */
241 for (i = 0; i < CT_PTP_NUM; i++)
242 snd_dma_free_pages(&vm->ptp[i]);
243
244 vm->size = 0;
245
246 kfree(vm);
247 }
248