1 /**************************************************************************
3 Copyright (C) 2004 Nicolai Haehnle.
4 Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
6 The Weather Channel (TM) funded Tungsten Graphics to develop the
7 initial release of the Radeon 8500 driver under the XFree86 license.
8 This notice must be preserved.
12 Permission is hereby granted, free of charge, to any person obtaining a
13 copy of this software and associated documentation files (the "Software"),
14 to deal in the Software without restriction, including without limitation
15 on the rights to use, copy, modify, merge, publish, distribute, sub
16 license, and/or sell copies of the Software, and to permit persons to whom
17 the Software is furnished to do so, subject to the following conditions:
19 The above copyright notice and this permission notice (including the next
20 paragraph) shall be included in all copies or substantial portions of the
23 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
26 ATI, VA LINUX SYSTEMS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
27 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
28 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
29 USE OR OTHER DEALINGS IN THE SOFTWARE.
31 **************************************************************************/
34 #include "radeon_common.h"
35 #include "main/simple_list.h"
37 #if defined(USE_X86_ASM)
38 #define COPY_DWORDS( dst, src, nr ) \
41 __asm__ __volatile__( "rep ; movsl" \
42 : "=%c" (__tmp), "=D" (dst), "=S" (__tmp) \
48 #define COPY_DWORDS( dst, src, nr ) \
51 for ( j = 0 ; j < nr ; j++ ) \
52 dst[j] = ((int *)src)[j]; \
57 void radeonEmitVec4(uint32_t *out
, const GLvoid
* data
, int stride
, int count
)
61 if (RADEON_DEBUG
& DEBUG_VERTS
)
62 fprintf(stderr
, "%s count %d stride %d out %p data %p\n",
63 __FUNCTION__
, count
, stride
, (void *)out
, (void *)data
);
66 COPY_DWORDS(out
, data
, count
);
68 for (i
= 0; i
< count
; i
++) {
69 out
[0] = *(int *)data
;
75 void radeonEmitVec8(uint32_t *out
, const GLvoid
* data
, int stride
, int count
)
79 if (RADEON_DEBUG
& DEBUG_VERTS
)
80 fprintf(stderr
, "%s count %d stride %d out %p data %p\n",
81 __FUNCTION__
, count
, stride
, (void *)out
, (void *)data
);
84 COPY_DWORDS(out
, data
, count
* 2);
86 for (i
= 0; i
< count
; i
++) {
87 out
[0] = *(int *)data
;
88 out
[1] = *(int *)(data
+ 4);
94 void radeonEmitVec12(uint32_t *out
, const GLvoid
* data
, int stride
, int count
)
98 if (RADEON_DEBUG
& DEBUG_VERTS
)
99 fprintf(stderr
, "%s count %d stride %d out %p data %p\n",
100 __FUNCTION__
, count
, stride
, (void *)out
, (void *)data
);
103 COPY_DWORDS(out
, data
, count
* 3);
106 for (i
= 0; i
< count
; i
++) {
107 out
[0] = *(int *)data
;
108 out
[1] = *(int *)(data
+ 4);
109 out
[2] = *(int *)(data
+ 8);
115 void radeonEmitVec16(uint32_t *out
, const GLvoid
* data
, int stride
, int count
)
119 if (RADEON_DEBUG
& DEBUG_VERTS
)
120 fprintf(stderr
, "%s count %d stride %d out %p data %p\n",
121 __FUNCTION__
, count
, stride
, (void *)out
, (void *)data
);
124 COPY_DWORDS(out
, data
, count
* 4);
126 for (i
= 0; i
< count
; i
++) {
127 out
[0] = *(int *)data
;
128 out
[1] = *(int *)(data
+ 4);
129 out
[2] = *(int *)(data
+ 8);
130 out
[3] = *(int *)(data
+ 12);
136 void rcommon_emit_vector(GLcontext
* ctx
, struct radeon_aos
*aos
,
137 const GLvoid
* data
, int size
, int stride
, int count
)
139 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
143 radeonAllocDmaRegion(rmesa
, &aos
->bo
, &aos
->offset
, size
* 4, 32);
147 radeonAllocDmaRegion(rmesa
, &aos
->bo
, &aos
->offset
, size
* count
* 4, 32);
151 aos
->components
= size
;
154 out
= (uint32_t*)((char*)aos
->bo
->ptr
+ aos
->offset
);
156 case 1: radeonEmitVec4(out
, data
, stride
, count
); break;
157 case 2: radeonEmitVec8(out
, data
, stride
, count
); break;
158 case 3: radeonEmitVec12(out
, data
, stride
, count
); break;
159 case 4: radeonEmitVec16(out
, data
, stride
, count
); break;
166 void radeon_init_dma(radeonContextPtr rmesa
)
168 make_empty_list(&rmesa
->dma
.free
);
169 make_empty_list(&rmesa
->dma
.wait
);
170 make_empty_list(&rmesa
->dma
.reserved
);
171 rmesa
->dma
.minimum_size
= MAX_DMA_BUF_SZ
;
174 void radeonRefillCurrentDmaRegion(radeonContextPtr rmesa
, int size
)
176 struct radeon_dma_bo
*dma_bo
= NULL
;
177 /* we set minimum sizes to at least requested size
178 aligned to next 16 bytes. */
179 if (size
> rmesa
->dma
.minimum_size
)
180 rmesa
->dma
.minimum_size
= (size
+ 15) & (~15);
182 if (RADEON_DEBUG
& (DEBUG_IOCTL
| DEBUG_DMA
))
183 fprintf(stderr
, "%s\n", __FUNCTION__
);
185 if (rmesa
->dma
.flush
) {
186 rmesa
->dma
.flush(rmesa
->glCtx
);
189 /* unmap old reserved bo */
190 if (!is_empty_list(&rmesa
->dma
.reserved
))
191 radeon_bo_unmap(first_elem(&rmesa
->dma
.reserved
)->bo
);
193 if (is_empty_list(&rmesa
->dma
.free
)
194 || last_elem(&rmesa
->dma
.free
)->bo
->size
< size
) {
195 dma_bo
= CALLOC_STRUCT(radeon_dma_bo
);
199 dma_bo
->bo
= radeon_bo_open(rmesa
->radeonScreen
->bom
,
200 0, rmesa
->dma
.minimum_size
, 4,
201 RADEON_GEM_DOMAIN_GTT
, 0);
204 rcommonFlushCmdBuf(rmesa
, __FUNCTION__
);
207 insert_at_head(&rmesa
->dma
.reserved
, dma_bo
);
209 /* We push and pop buffers from end of list so we can keep
210 counter on unused buffers for later freeing them from
212 dma_bo
= last_elem(&rmesa
->dma
.free
);
213 assert(dma_bo
->bo
->cref
== 1);
214 remove_from_list(dma_bo
);
215 insert_at_head(&rmesa
->dma
.reserved
, dma_bo
);
218 rmesa
->dma
.current_used
= 0;
219 rmesa
->dma
.current_vertexptr
= 0;
221 if (radeon_cs_space_check_with_bo(rmesa
->cmdbuf
.cs
,
222 first_elem(&rmesa
->dma
.reserved
)->bo
,
223 RADEON_GEM_DOMAIN_GTT
, 0))
224 fprintf(stderr
,"failure to revalidate BOs - badness\n");
226 if (is_empty_list(&rmesa
->dma
.reserved
)) {
227 /* Cmd buff have been flushed in radeon_revalidate_bos */
231 radeon_bo_map(first_elem(&rmesa
->dma
.reserved
)->bo
, 1);
234 /* Allocates a region from rmesa->dma.current. If there isn't enough
235 * space in current, grab a new buffer (and discard what was left of current)
237 void radeonAllocDmaRegion(radeonContextPtr rmesa
,
238 struct radeon_bo
**pbo
, int *poffset
,
239 int bytes
, int alignment
)
241 if (RADEON_DEBUG
& DEBUG_IOCTL
)
242 fprintf(stderr
, "%s %d\n", __FUNCTION__
, bytes
);
244 if (rmesa
->dma
.flush
)
245 rmesa
->dma
.flush(rmesa
->glCtx
);
247 assert(rmesa
->dma
.current_used
== rmesa
->dma
.current_vertexptr
);
250 rmesa
->dma
.current_used
= (rmesa
->dma
.current_used
+ alignment
) & ~alignment
;
252 if (is_empty_list(&rmesa
->dma
.reserved
)
253 || rmesa
->dma
.current_used
+ bytes
> first_elem(&rmesa
->dma
.reserved
)->bo
->size
)
254 radeonRefillCurrentDmaRegion(rmesa
, bytes
);
256 *poffset
= rmesa
->dma
.current_used
;
257 *pbo
= first_elem(&rmesa
->dma
.reserved
)->bo
;
260 /* Always align to at least 16 bytes */
261 rmesa
->dma
.current_used
= (rmesa
->dma
.current_used
+ bytes
+ 15) & ~15;
262 rmesa
->dma
.current_vertexptr
= rmesa
->dma
.current_used
;
264 assert(rmesa
->dma
.current_used
<= first_elem(&rmesa
->dma
.reserved
)->bo
->size
);
267 void radeonFreeDmaRegions(radeonContextPtr rmesa
)
269 struct radeon_dma_bo
*dma_bo
= CALLOC_STRUCT(radeon_dma_bo
);
270 struct radeon_dma_bo
*temp
;
271 if (RADEON_DEBUG
& DEBUG_DMA
)
272 fprintf(stderr
, "%s\n", __FUNCTION__
);
274 foreach_s(dma_bo
, temp
, &rmesa
->dma
.free
) {
275 remove_from_list(dma_bo
);
276 radeon_bo_unref(dma_bo
->bo
);
280 foreach_s(dma_bo
, temp
, &rmesa
->dma
.wait
) {
281 remove_from_list(dma_bo
);
282 radeon_bo_unref(dma_bo
->bo
);
286 foreach_s(dma_bo
, temp
, &rmesa
->dma
.reserved
) {
287 remove_from_list(dma_bo
);
288 radeon_bo_unmap(dma_bo
->bo
);
289 radeon_bo_unref(dma_bo
->bo
);
294 void radeonReturnDmaRegion(radeonContextPtr rmesa
, int return_bytes
)
296 if (is_empty_list(&rmesa
->dma
.reserved
))
299 if (RADEON_DEBUG
& DEBUG_IOCTL
)
300 fprintf(stderr
, "%s %d\n", __FUNCTION__
, return_bytes
);
301 rmesa
->dma
.current_used
-= return_bytes
;
302 rmesa
->dma
.current_vertexptr
= rmesa
->dma
.current_used
;
305 static int radeon_bo_is_idle(struct radeon_bo
* bo
)
308 int ret
= radeon_bo_is_busy(bo
, &domain
);
309 if (ret
== -EINVAL
) {
310 WARN_ONCE("Your libdrm or kernel doesn't have support for busy query.\n"
311 "This may cause small performance drop for you.\n");
313 return ret
!= -EBUSY
;
316 void radeonReleaseDmaRegions(radeonContextPtr rmesa
)
318 struct radeon_dma_bo
*dma_bo
;
319 struct radeon_dma_bo
*temp
;
320 const int expire_at
= ++rmesa
->dma
.free
.expire_counter
+ DMA_BO_FREE_TIME
;
321 const int time
= rmesa
->dma
.free
.expire_counter
;
323 if (RADEON_DEBUG
& DEBUG_DMA
) {
327 foreach(dma_bo
, &rmesa
->dma
.free
)
330 foreach(dma_bo
, &rmesa
->dma
.wait
)
333 foreach(dma_bo
, &rmesa
->dma
.reserved
)
336 fprintf(stderr
, "%s: free %zu, wait %zu, reserved %zu, minimum_size: %zu\n",
337 __FUNCTION__
, free
, wait
, reserved
, rmesa
->dma
.minimum_size
);
340 if (!rmesa
->radeonScreen
->driScreen
->dri2
.enabled
) {
341 /* request updated cs processing information from kernel */
342 legacy_track_pending(rmesa
->radeonScreen
->bom
, 0);
344 /* move waiting bos to free list.
345 wait list provides gpu time to handle data before reuse */
346 foreach_s(dma_bo
, temp
, &rmesa
->dma
.wait
) {
347 if (dma_bo
->expire_counter
== time
) {
348 WARN_ONCE("Leaking dma buffer object!\n");
349 radeon_bo_unref(dma_bo
->bo
);
350 remove_from_list(dma_bo
);
354 /* free objects that are too small to be used because of large request */
355 if (dma_bo
->bo
->size
< rmesa
->dma
.minimum_size
) {
356 radeon_bo_unref(dma_bo
->bo
);
357 remove_from_list(dma_bo
);
361 if (!radeon_bo_is_idle(dma_bo
->bo
))
363 remove_from_list(dma_bo
);
364 dma_bo
->expire_counter
= expire_at
;
365 insert_at_tail(&rmesa
->dma
.free
, dma_bo
);
368 /* unmap the last dma region */
369 if (!is_empty_list(&rmesa
->dma
.reserved
))
370 radeon_bo_unmap(first_elem(&rmesa
->dma
.reserved
)->bo
);
371 /* move reserved to wait list */
372 foreach_s(dma_bo
, temp
, &rmesa
->dma
.reserved
) {
373 /* free objects that are too small to be used because of large request */
374 if (dma_bo
->bo
->size
< rmesa
->dma
.minimum_size
) {
375 radeon_bo_unref(dma_bo
->bo
);
376 remove_from_list(dma_bo
);
380 remove_from_list(dma_bo
);
381 dma_bo
->expire_counter
= expire_at
;
382 insert_at_tail(&rmesa
->dma
.wait
, dma_bo
);
385 /* free bos that have been unused for some time */
386 foreach_s(dma_bo
, temp
, &rmesa
->dma
.free
) {
387 if (dma_bo
->expire_counter
!= time
)
389 remove_from_list(dma_bo
);
390 radeon_bo_unref(dma_bo
->bo
);
397 /* Flush vertices in the current dma region.
399 void rcommon_flush_last_swtcl_prim( GLcontext
*ctx
)
401 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
402 struct radeon_dma
*dma
= &rmesa
->dma
;
405 if (RADEON_DEBUG
& DEBUG_IOCTL
)
406 fprintf(stderr
, "%s\n", __FUNCTION__
);
409 if (!is_empty_list(&dma
->reserved
)) {
410 GLuint current_offset
= dma
->current_used
;
412 assert (dma
->current_used
+
413 rmesa
->swtcl
.numverts
* rmesa
->swtcl
.vertex_size
* 4 ==
414 dma
->current_vertexptr
);
416 if (dma
->current_used
!= dma
->current_vertexptr
) {
417 dma
->current_used
= dma
->current_vertexptr
;
419 rmesa
->vtbl
.swtcl_flush(ctx
, current_offset
);
421 rmesa
->swtcl
.numverts
= 0;
424 /* Alloc space in the current dma region.
427 rcommonAllocDmaLowVerts( radeonContextPtr rmesa
, int nverts
, int vsize
)
429 GLuint bytes
= vsize
* nverts
;
431 if (RADEON_DEBUG
& DEBUG_IOCTL
)
432 fprintf(stderr
, "%s\n", __FUNCTION__
);
433 if (is_empty_list(&rmesa
->dma
.reserved
)
434 || rmesa
->dma
.current_vertexptr
+ bytes
> first_elem(&rmesa
->dma
.reserved
)->bo
->size
) {
435 radeonRefillCurrentDmaRegion(rmesa
, bytes
);
438 if (!rmesa
->dma
.flush
) {
439 /* if cmdbuf flushed DMA restart */
440 rmesa
->glCtx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
441 rmesa
->dma
.flush
= rcommon_flush_last_swtcl_prim
;
444 ASSERT( vsize
== rmesa
->swtcl
.vertex_size
* 4 );
445 ASSERT( rmesa
->dma
.flush
== rcommon_flush_last_swtcl_prim
);
446 ASSERT( rmesa
->dma
.current_used
+
447 rmesa
->swtcl
.numverts
* rmesa
->swtcl
.vertex_size
* 4 ==
448 rmesa
->dma
.current_vertexptr
);
450 head
= (first_elem(&rmesa
->dma
.reserved
)->bo
->ptr
+ rmesa
->dma
.current_vertexptr
);
451 rmesa
->dma
.current_vertexptr
+= bytes
;
452 rmesa
->swtcl
.numverts
+= nverts
;
456 void radeonReleaseArrays( GLcontext
*ctx
, GLuint newinputs
)
458 radeonContextPtr radeon
= RADEON_CONTEXT( ctx
);
460 if (RADEON_DEBUG
& DEBUG_IOCTL
)
461 fprintf(stderr
, "%s\n", __FUNCTION__
);
463 if (radeon
->dma
.flush
) {
464 radeon
->dma
.flush(radeon
->glCtx
);
466 for (i
= 0; i
< radeon
->tcl
.aos_count
; i
++) {
467 if (radeon
->tcl
.aos
[i
].bo
) {
468 radeon_bo_unref(radeon
->tcl
.aos
[i
].bo
);
469 radeon
->tcl
.aos
[i
].bo
= NULL
;