Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
c1017a4c | 2 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz> |
1da177e4 LT |
3 | * Copyright (c) by Takashi Iwai <tiwai@suse.de> |
4 | * Copyright (c) by Scott McNab <sdm@fractalgraphics.com.au> | |
5 | * | |
6 | * Trident 4DWave-NX memory page allocation (TLB area) | |
7 | * Trident chip can handle only 16MByte of the memory at the same time. | |
8 | * | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License as published by | |
12 | * the Free Software Foundation; either version 2 of the License, or | |
13 | * (at your option) any later version. | |
14 | * | |
15 | * This program is distributed in the hope that it will be useful, | |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | * GNU General Public License for more details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
21 | * along with this program; if not, write to the Free Software | |
22 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
23 | * | |
24 | */ | |
25 | ||
6cbbfe1c | 26 | #include <linux/io.h> |
1da177e4 LT |
27 | #include <linux/pci.h> |
28 | #include <linux/time.h> | |
62932df8 IM |
29 | #include <linux/mutex.h> |
30 | ||
1da177e4 | 31 | #include <sound/core.h> |
81fcb170 | 32 | #include "trident.h" |
1da177e4 LT |
33 | |
34 | /* page arguments of these two macros are Trident page (4096 bytes), not like | |
35 | * aligned pages in others | |
36 | */ | |
37 | #define __set_tlb_bus(trident,page,ptr,addr) \ | |
38 | do { (trident)->tlb.entries[page] = cpu_to_le32((addr) & ~(SNDRV_TRIDENT_PAGE_SIZE-1)); \ | |
39 | (trident)->tlb.shadow_entries[page] = (ptr); } while (0) | |
40 | #define __tlb_to_ptr(trident,page) \ | |
41 | (void*)((trident)->tlb.shadow_entries[page]) | |
42 | #define __tlb_to_addr(trident,page) \ | |
43 | (dma_addr_t)le32_to_cpu((trident->tlb.entries[page]) & ~(SNDRV_TRIDENT_PAGE_SIZE - 1)) | |
44 | ||
45 | #if PAGE_SIZE == 4096 | |
46 | /* page size == SNDRV_TRIDENT_PAGE_SIZE */ | |
47 | #define ALIGN_PAGE_SIZE PAGE_SIZE /* minimum page size for allocation */ | |
48 | #define MAX_ALIGN_PAGES SNDRV_TRIDENT_MAX_PAGES /* maxmium aligned pages */ | |
49 | /* fill TLB entrie(s) corresponding to page with ptr */ | |
50 | #define set_tlb_bus(trident,page,ptr,addr) __set_tlb_bus(trident,page,ptr,addr) | |
51 | /* fill TLB entrie(s) corresponding to page with silence pointer */ | |
52 | #define set_silent_tlb(trident,page) __set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr) | |
53 | /* get aligned page from offset address */ | |
54 | #define get_aligned_page(offset) ((offset) >> 12) | |
55 | /* get offset address from aligned page */ | |
56 | #define aligned_page_offset(page) ((page) << 12) | |
57 | /* get buffer address from aligned page */ | |
58 | #define page_to_ptr(trident,page) __tlb_to_ptr(trident, page) | |
59 | /* get PCI physical address from aligned page */ | |
60 | #define page_to_addr(trident,page) __tlb_to_addr(trident, page) | |
61 | ||
62 | #elif PAGE_SIZE == 8192 | |
63 | /* page size == SNDRV_TRIDENT_PAGE_SIZE x 2*/ | |
64 | #define ALIGN_PAGE_SIZE PAGE_SIZE | |
65 | #define MAX_ALIGN_PAGES (SNDRV_TRIDENT_MAX_PAGES / 2) | |
66 | #define get_aligned_page(offset) ((offset) >> 13) | |
67 | #define aligned_page_offset(page) ((page) << 13) | |
68 | #define page_to_ptr(trident,page) __tlb_to_ptr(trident, (page) << 1) | |
69 | #define page_to_addr(trident,page) __tlb_to_addr(trident, (page) << 1) | |
70 | ||
71 | /* fill TLB entries -- we need to fill two entries */ | |
bee1a5be TI |
72 | static inline void set_tlb_bus(struct snd_trident *trident, int page, |
73 | unsigned long ptr, dma_addr_t addr) | |
1da177e4 LT |
74 | { |
75 | page <<= 1; | |
76 | __set_tlb_bus(trident, page, ptr, addr); | |
77 | __set_tlb_bus(trident, page+1, ptr + SNDRV_TRIDENT_PAGE_SIZE, addr + SNDRV_TRIDENT_PAGE_SIZE); | |
78 | } | |
bee1a5be | 79 | static inline void set_silent_tlb(struct snd_trident *trident, int page) |
1da177e4 LT |
80 | { |
81 | page <<= 1; | |
82 | __set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr); | |
83 | __set_tlb_bus(trident, page+1, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr); | |
84 | } | |
85 | ||
86 | #else | |
87 | /* arbitrary size */ | |
88 | #define UNIT_PAGES (PAGE_SIZE / SNDRV_TRIDENT_PAGE_SIZE) | |
89 | #define ALIGN_PAGE_SIZE (SNDRV_TRIDENT_PAGE_SIZE * UNIT_PAGES) | |
90 | #define MAX_ALIGN_PAGES (SNDRV_TRIDENT_MAX_PAGES / UNIT_PAGES) | |
91 | /* Note: if alignment doesn't match to the maximum size, the last few blocks | |
92 | * become unusable. To use such blocks, you'll need to check the validity | |
93 | * of accessing page in set_tlb_bus and set_silent_tlb. search_empty() | |
94 | * should also check it, too. | |
95 | */ | |
96 | #define get_aligned_page(offset) ((offset) / ALIGN_PAGE_SIZE) | |
97 | #define aligned_page_offset(page) ((page) * ALIGN_PAGE_SIZE) | |
98 | #define page_to_ptr(trident,page) __tlb_to_ptr(trident, (page) * UNIT_PAGES) | |
99 | #define page_to_addr(trident,page) __tlb_to_addr(trident, (page) * UNIT_PAGES) | |
100 | ||
101 | /* fill TLB entries -- UNIT_PAGES entries must be filled */ | |
bee1a5be TI |
102 | static inline void set_tlb_bus(struct snd_trident *trident, int page, |
103 | unsigned long ptr, dma_addr_t addr) | |
1da177e4 LT |
104 | { |
105 | int i; | |
106 | page *= UNIT_PAGES; | |
107 | for (i = 0; i < UNIT_PAGES; i++, page++) { | |
108 | __set_tlb_bus(trident, page, ptr, addr); | |
109 | ptr += SNDRV_TRIDENT_PAGE_SIZE; | |
110 | addr += SNDRV_TRIDENT_PAGE_SIZE; | |
111 | } | |
112 | } | |
bee1a5be | 113 | static inline void set_silent_tlb(struct snd_trident *trident, int page) |
1da177e4 LT |
114 | { |
115 | int i; | |
116 | page *= UNIT_PAGES; | |
117 | for (i = 0; i < UNIT_PAGES; i++, page++) | |
118 | __set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr); | |
119 | } | |
120 | ||
121 | #endif /* PAGE_SIZE */ | |
122 | ||
123 | /* calculate buffer pointer from offset address */ | |
bee1a5be | 124 | static inline void *offset_ptr(struct snd_trident *trident, int offset) |
1da177e4 LT |
125 | { |
126 | char *ptr; | |
127 | ptr = page_to_ptr(trident, get_aligned_page(offset)); | |
128 | ptr += offset % ALIGN_PAGE_SIZE; | |
129 | return (void*)ptr; | |
130 | } | |
131 | ||
132 | /* first and last (aligned) pages of memory block */ | |
bee1a5be TI |
133 | #define firstpg(blk) (((struct snd_trident_memblk_arg *)snd_util_memblk_argptr(blk))->first_page) |
134 | #define lastpg(blk) (((struct snd_trident_memblk_arg *)snd_util_memblk_argptr(blk))->last_page) | |
1da177e4 LT |
135 | |
136 | /* | |
137 | * search empty pages which may contain given size | |
138 | */ | |
bee1a5be TI |
139 | static struct snd_util_memblk * |
140 | search_empty(struct snd_util_memhdr *hdr, int size) | |
1da177e4 | 141 | { |
e2ff8406 | 142 | struct snd_util_memblk *blk; |
1da177e4 LT |
143 | int page, psize; |
144 | struct list_head *p; | |
145 | ||
146 | psize = get_aligned_page(size + ALIGN_PAGE_SIZE -1); | |
1da177e4 LT |
147 | page = 0; |
148 | list_for_each(p, &hdr->block) { | |
bee1a5be | 149 | blk = list_entry(p, struct snd_util_memblk, list); |
1da177e4 LT |
150 | if (page + psize <= firstpg(blk)) |
151 | goto __found_pages; | |
152 | page = lastpg(blk) + 1; | |
153 | } | |
154 | if (page + psize > MAX_ALIGN_PAGES) | |
155 | return NULL; | |
156 | ||
157 | __found_pages: | |
158 | /* create a new memory block */ | |
159 | blk = __snd_util_memblk_new(hdr, psize * ALIGN_PAGE_SIZE, p->prev); | |
160 | if (blk == NULL) | |
161 | return NULL; | |
162 | blk->offset = aligned_page_offset(page); /* set aligned offset */ | |
163 | firstpg(blk) = page; | |
164 | lastpg(blk) = page + psize - 1; | |
165 | return blk; | |
166 | } | |
167 | ||
168 | ||
169 | /* | |
170 | * check if the given pointer is valid for pages | |
171 | */ | |
172 | static int is_valid_page(unsigned long ptr) | |
173 | { | |
174 | if (ptr & ~0x3fffffffUL) { | |
99b359ba | 175 | snd_printk(KERN_ERR "max memory size is 1GB!!\n"); |
1da177e4 LT |
176 | return 0; |
177 | } | |
178 | if (ptr & (SNDRV_TRIDENT_PAGE_SIZE-1)) { | |
99b359ba | 179 | snd_printk(KERN_ERR "page is not aligned\n"); |
1da177e4 LT |
180 | return 0; |
181 | } | |
182 | return 1; | |
183 | } | |
184 | ||
185 | /* | |
186 | * page allocation for DMA (Scatter-Gather version) | |
187 | */ | |
bee1a5be TI |
188 | static struct snd_util_memblk * |
189 | snd_trident_alloc_sg_pages(struct snd_trident *trident, | |
190 | struct snd_pcm_substream *substream) | |
1da177e4 | 191 | { |
bee1a5be TI |
192 | struct snd_util_memhdr *hdr; |
193 | struct snd_util_memblk *blk; | |
194 | struct snd_pcm_runtime *runtime = substream->runtime; | |
1da177e4 | 195 | int idx, page; |
1da177e4 | 196 | |
da3cec35 TI |
197 | if (snd_BUG_ON(runtime->dma_bytes <= 0 || |
198 | runtime->dma_bytes > SNDRV_TRIDENT_MAX_PAGES * | |
199 | SNDRV_TRIDENT_PAGE_SIZE)) | |
200 | return NULL; | |
1da177e4 | 201 | hdr = trident->tlb.memhdr; |
da3cec35 TI |
202 | if (snd_BUG_ON(!hdr)) |
203 | return NULL; | |
1da177e4 LT |
204 | |
205 | ||
206 | ||
62932df8 | 207 | mutex_lock(&hdr->block_mutex); |
1da177e4 LT |
208 | blk = search_empty(hdr, runtime->dma_bytes); |
209 | if (blk == NULL) { | |
62932df8 | 210 | mutex_unlock(&hdr->block_mutex); |
1da177e4 LT |
211 | return NULL; |
212 | } | |
1da177e4 LT |
213 | |
214 | /* set TLB entries */ | |
215 | idx = 0; | |
216 | for (page = firstpg(blk); page <= lastpg(blk); page++, idx++) { | |
77a23f26 TI |
217 | unsigned long ofs = idx << PAGE_SHIFT; |
218 | dma_addr_t addr = snd_pcm_sgbuf_get_addr(substream, ofs); | |
219 | unsigned long ptr = (unsigned long) | |
220 | snd_pcm_sgbuf_get_ptr(substream, ofs); | |
1da177e4 LT |
221 | if (! is_valid_page(addr)) { |
222 | __snd_util_mem_free(hdr, blk); | |
62932df8 | 223 | mutex_unlock(&hdr->block_mutex); |
1da177e4 LT |
224 | return NULL; |
225 | } | |
226 | set_tlb_bus(trident, page, ptr, addr); | |
227 | } | |
62932df8 | 228 | mutex_unlock(&hdr->block_mutex); |
1da177e4 LT |
229 | return blk; |
230 | } | |
231 | ||
232 | /* | |
233 | * page allocation for DMA (contiguous version) | |
234 | */ | |
bee1a5be TI |
235 | static struct snd_util_memblk * |
236 | snd_trident_alloc_cont_pages(struct snd_trident *trident, | |
237 | struct snd_pcm_substream *substream) | |
1da177e4 | 238 | { |
bee1a5be TI |
239 | struct snd_util_memhdr *hdr; |
240 | struct snd_util_memblk *blk; | |
1da177e4 | 241 | int page; |
bee1a5be | 242 | struct snd_pcm_runtime *runtime = substream->runtime; |
1da177e4 LT |
243 | dma_addr_t addr; |
244 | unsigned long ptr; | |
245 | ||
da3cec35 TI |
246 | if (snd_BUG_ON(runtime->dma_bytes <= 0 || |
247 | runtime->dma_bytes > SNDRV_TRIDENT_MAX_PAGES * | |
248 | SNDRV_TRIDENT_PAGE_SIZE)) | |
249 | return NULL; | |
1da177e4 | 250 | hdr = trident->tlb.memhdr; |
da3cec35 TI |
251 | if (snd_BUG_ON(!hdr)) |
252 | return NULL; | |
1da177e4 | 253 | |
62932df8 | 254 | mutex_lock(&hdr->block_mutex); |
1da177e4 LT |
255 | blk = search_empty(hdr, runtime->dma_bytes); |
256 | if (blk == NULL) { | |
62932df8 | 257 | mutex_unlock(&hdr->block_mutex); |
1da177e4 LT |
258 | return NULL; |
259 | } | |
260 | ||
261 | /* set TLB entries */ | |
262 | addr = runtime->dma_addr; | |
263 | ptr = (unsigned long)runtime->dma_area; | |
264 | for (page = firstpg(blk); page <= lastpg(blk); page++, | |
265 | ptr += SNDRV_TRIDENT_PAGE_SIZE, addr += SNDRV_TRIDENT_PAGE_SIZE) { | |
266 | if (! is_valid_page(addr)) { | |
267 | __snd_util_mem_free(hdr, blk); | |
62932df8 | 268 | mutex_unlock(&hdr->block_mutex); |
1da177e4 LT |
269 | return NULL; |
270 | } | |
271 | set_tlb_bus(trident, page, ptr, addr); | |
272 | } | |
62932df8 | 273 | mutex_unlock(&hdr->block_mutex); |
1da177e4 LT |
274 | return blk; |
275 | } | |
276 | ||
277 | /* | |
278 | * page allocation for DMA | |
279 | */ | |
bee1a5be TI |
280 | struct snd_util_memblk * |
281 | snd_trident_alloc_pages(struct snd_trident *trident, | |
282 | struct snd_pcm_substream *substream) | |
1da177e4 | 283 | { |
da3cec35 TI |
284 | if (snd_BUG_ON(!trident || !substream)) |
285 | return NULL; | |
1da177e4 LT |
286 | if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV_SG) |
287 | return snd_trident_alloc_sg_pages(trident, substream); | |
288 | else | |
289 | return snd_trident_alloc_cont_pages(trident, substream); | |
290 | } | |
291 | ||
292 | ||
293 | /* | |
294 | * release DMA buffer from page table | |
295 | */ | |
bee1a5be TI |
296 | int snd_trident_free_pages(struct snd_trident *trident, |
297 | struct snd_util_memblk *blk) | |
1da177e4 | 298 | { |
bee1a5be | 299 | struct snd_util_memhdr *hdr; |
1da177e4 LT |
300 | int page; |
301 | ||
da3cec35 TI |
302 | if (snd_BUG_ON(!trident || !blk)) |
303 | return -EINVAL; | |
1da177e4 LT |
304 | |
305 | hdr = trident->tlb.memhdr; | |
62932df8 | 306 | mutex_lock(&hdr->block_mutex); |
1da177e4 LT |
307 | /* reset TLB entries */ |
308 | for (page = firstpg(blk); page <= lastpg(blk); page++) | |
309 | set_silent_tlb(trident, page); | |
310 | /* free memory block */ | |
311 | __snd_util_mem_free(hdr, blk); | |
62932df8 | 312 | mutex_unlock(&hdr->block_mutex); |
1da177e4 LT |
313 | return 0; |
314 | } |