363b67e3a9e7e814260ecd7163e876a394db418c
[linux-2.6.git] / sound / pci / ctxfi / ctvmem.c
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 <asm/page.h>   /* for PAGE_SIZE macro definition */
22 #include <linux/io.h>
23 #include <asm/pgtable.h>
24
25 #define CT_PTES_PER_PAGE (PAGE_SIZE / sizeof(void *))
26 #define CT_ADDRS_PER_PAGE (CT_PTES_PER_PAGE * PAGE_SIZE)
27
28 /* *
29  * Find or create vm block based on requested @size.
30  * @size must be page aligned.
31  * */
32 static struct ct_vm_block *
33 get_vm_block(struct ct_vm *vm, unsigned int size)
34 {
35         struct ct_vm_block *block = NULL, *entry = NULL;
36         struct list_head *pos = NULL;
37
38         mutex_lock(&vm->lock);
39         list_for_each(pos, &vm->unused) {
40                 entry = list_entry(pos, struct ct_vm_block, list);
41                 if (entry->size >= size)
42                         break; /* found a block that is big enough */
43         }
44         if (pos == &vm->unused)
45                 goto out;
46
47         if (entry->size == size) {
48                 /* Move the vm node from unused list to used list directly */
49                 list_del(&entry->list);
50                 list_add(&entry->list, &vm->used);
51                 vm->size -= size;
52                 block = entry;
53                 goto out;
54         }
55
56         block = kzalloc(sizeof(*block), GFP_KERNEL);
57         if (NULL == block)
58                 goto out;
59
60         block->addr = entry->addr;
61         block->size = size;
62         list_add(&block->list, &vm->used);
63         entry->addr += size;
64         entry->size -= size;
65         vm->size -= size;
66
67  out:
68         mutex_unlock(&vm->lock);
69         return block;
70 }
71
72 static void put_vm_block(struct ct_vm *vm, struct ct_vm_block *block)
73 {
74         struct ct_vm_block *entry = NULL, *pre_ent = NULL;
75         struct list_head *pos = NULL, *pre = NULL;
76
77         mutex_lock(&vm->lock);
78         list_del(&block->list);
79         vm->size += block->size;
80
81         list_for_each(pos, &vm->unused) {
82                 entry = list_entry(pos, struct ct_vm_block, list);
83                 if (entry->addr >= (block->addr + block->size))
84                         break; /* found a position */
85         }
86         if (pos == &vm->unused) {
87                 list_add_tail(&block->list, &vm->unused);
88                 entry = block;
89         } else {
90                 if ((block->addr + block->size) == entry->addr) {
91                         entry->addr = block->addr;
92                         entry->size += block->size;
93                         kfree(block);
94                 } else {
95                         __list_add(&block->list, pos->prev, pos);
96                         entry = block;
97                 }
98         }
99
100         pos = &entry->list;
101         pre = pos->prev;
102         while (pre != &vm->unused) {
103                 entry = list_entry(pos, struct ct_vm_block, list);
104                 pre_ent = list_entry(pre, struct ct_vm_block, list);
105                 if ((pre_ent->addr + pre_ent->size) > entry->addr)
106                         break;
107
108                 pre_ent->size += entry->size;
109                 list_del(pos);
110                 kfree(entry);
111                 pos = pre;
112                 pre = pos->prev;
113         }
114         mutex_unlock(&vm->lock);
115 }
116
117 /* Map host addr (kmalloced/vmalloced) to device logical addr. */
118 static struct ct_vm_block *
119 ct_vm_map(struct ct_vm *vm, void *host_addr, int size)
120 {
121         struct ct_vm_block *block = NULL;
122         unsigned long pte_start;
123         unsigned long i;
124         unsigned long pages;
125         unsigned long start_phys;
126         unsigned long *ptp;
127
128         /* do mapping */
129         if ((unsigned long)host_addr >= VMALLOC_START) {
130                 printk(KERN_ERR "ctxfi: "
131                        "Fail! Not support vmalloced addr now!\n");
132                 return NULL;
133         }
134
135         if (size > vm->size) {
136                 printk(KERN_ERR "ctxfi: Fail! No sufficient device virtural "
137                                   "memory space available!\n");
138                 return NULL;
139         }
140
141         start_phys = (virt_to_phys(host_addr) & PAGE_MASK);
142         pages = (PAGE_ALIGN(virt_to_phys(host_addr) + size)
143                         - start_phys) >> PAGE_SHIFT;
144
145         ptp = vm->ptp[0];
146
147         block = get_vm_block(vm, (pages << PAGE_SHIFT));
148         if (block == NULL) {
149                 printk(KERN_ERR "ctxfi: No virtual memory block that is big "
150                                   "enough to allocate!\n");
151                 return NULL;
152         }
153
154         pte_start = (block->addr >> PAGE_SHIFT);
155         for (i = 0; i < pages; i++)
156                 ptp[pte_start+i] = start_phys + (i << PAGE_SHIFT);
157
158         block->addr += (virt_to_phys(host_addr) & (~PAGE_MASK));
159         block->size = size;
160
161         return block;
162 }
163
164 static void ct_vm_unmap(struct ct_vm *vm, struct ct_vm_block *block)
165 {
166         /* do unmapping */
167         block->size = ((block->addr + block->size + PAGE_SIZE - 1)
168                         & PAGE_MASK) - (block->addr & PAGE_MASK);
169         block->addr &= PAGE_MASK;
170         put_vm_block(vm, block);
171 }
172
173 /* *
174  * return the host (kmalloced) addr of the @index-th device
175  * page talbe page on success, or NULL on failure.
176  * The first returned NULL indicates the termination.
177  * */
178 static void *
179 ct_get_ptp_virt(struct ct_vm *vm, int index)
180 {
181         void *addr;
182
183         addr = (index >= CT_PTP_NUM) ? NULL : vm->ptp[index];
184
185         return addr;
186 }
187
188 int ct_vm_create(struct ct_vm **rvm)
189 {
190         struct ct_vm *vm;
191         struct ct_vm_block *block;
192         int i;
193
194         *rvm = NULL;
195
196         vm = kzalloc(sizeof(*vm), GFP_KERNEL);
197         if (NULL == vm)
198                 return -ENOMEM;
199
200         mutex_init(&vm->lock);
201
202         /* Allocate page table pages */
203         for (i = 0; i < CT_PTP_NUM; i++) {
204                 vm->ptp[i] = kmalloc(PAGE_SIZE, GFP_KERNEL);
205                 if (NULL == vm->ptp[i])
206                         break;
207         }
208         if (!i) {
209                 /* no page table pages are allocated */
210                 kfree(vm);
211                 return -ENOMEM;
212         }
213         vm->size = CT_ADDRS_PER_PAGE * i;
214         /* Initialise remaining ptps */
215         for (; i < CT_PTP_NUM; i++)
216                 vm->ptp[i] = NULL;
217
218         vm->map = ct_vm_map;
219         vm->unmap = ct_vm_unmap;
220         vm->get_ptp_virt = ct_get_ptp_virt;
221         INIT_LIST_HEAD(&vm->unused);
222         INIT_LIST_HEAD(&vm->used);
223         block = kzalloc(sizeof(*block), GFP_KERNEL);
224         if (NULL != block) {
225                 block->addr = 0;
226                 block->size = vm->size;
227                 list_add(&block->list, &vm->unused);
228         }
229
230         *rvm = vm;
231         return 0;
232 }
233
234 /* The caller must ensure no mapping pages are being used
235  * by hardware before calling this function */
236 void ct_vm_destroy(struct ct_vm *vm)
237 {
238         int i;
239         struct list_head *pos = NULL;
240         struct ct_vm_block *entry = NULL;
241
242         /* free used and unused list nodes */
243         while (!list_empty(&vm->used)) {
244                 pos = vm->used.next;
245                 list_del(pos);
246                 entry = list_entry(pos, struct ct_vm_block, list);
247                 kfree(entry);
248         }
249         while (!list_empty(&vm->unused)) {
250                 pos = vm->unused.next;
251                 list_del(pos);
252                 entry = list_entry(pos, struct ct_vm_block, list);
253                 kfree(entry);
254         }
255
256         /* free allocated page table pages */
257         for (i = 0; i < CT_PTP_NUM; i++)
258                 kfree(vm->ptp[i]);
259
260         vm->size = 0;
261
262         kfree(vm);
263 }