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