2 * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
3 * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sub license,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
19 * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
30 #include "main/mtypes.h"
31 #include "main/macros.h"
33 #include "main/context.h"
34 #include "main/colormac.h"
36 #include "swrast/swrast.h"
38 #include "savagecontext.h"
39 #include "savageioctl.h"
40 #include "savage_bci.h"
41 #include "savagestate.h"
42 #include "savagespan.h"
45 #include <sys/ioctl.h>
46 #include <sys/timeb.h>
48 #define DEPTH_SCALE_16 ((1<<16)-1)
49 #define DEPTH_SCALE_24 ((1<<24)-1)
52 void savageGetDMABuffer( savageContextPtr imesa
)
60 assert (imesa
->savageScreen
->bufs
);
62 if (SAVAGE_DEBUG
& DEBUG_DMA
)
63 fprintf(stderr
, "Getting dma buffer\n");
65 dma
.context
= imesa
->hHWContext
;
68 dma
.send_sizes
= NULL
;
70 dma
.request_count
= 1;
71 dma
.request_size
= imesa
->bufferSize
;
72 dma
.request_list
= &idx
;
73 dma
.request_sizes
= &size
;
74 dma
.granted_count
= 0;
77 if (SAVAGE_DEBUG
& DEBUG_DMA
)
78 fprintf(stderr
, "drmDMA (get) ctx %d count %d size 0x%x\n",
79 dma
.context
, dma
.request_count
,
83 retcode
= drmDMA(imesa
->driFd
, &dma
);
85 if (SAVAGE_DEBUG
& DEBUG_DMA
)
86 fprintf(stderr
, "retcode %d sz %d idx %d count %d\n",
93 dma
.request_sizes
[0] &&
97 if (SAVAGE_DEBUG
& DEBUG_DMA
)
98 fprintf(stderr
, "\n\nflush");
101 buf
= &(imesa
->savageScreen
->bufs
->list
[idx
]);
103 if (SAVAGE_DEBUG
& DEBUG_DMA
)
105 "drmDMA (get) returns size[0] 0x%x idx[0] %d\n"
106 "dma_buffer now: buf idx: %d size: %d used: %d addr %p\n",
107 dma
.request_sizes
[0], dma
.request_list
[0],
108 buf
->idx
, buf
->total
,
109 buf
->used
, buf
->address
);
111 imesa
->dmaVtxBuf
.total
= buf
->total
/ 4;
112 imesa
->dmaVtxBuf
.used
= 0;
113 imesa
->dmaVtxBuf
.flushed
= 0;
114 imesa
->dmaVtxBuf
.idx
= buf
->idx
;
115 imesa
->dmaVtxBuf
.buf
= (uint32_t *)buf
->address
;
117 if (SAVAGE_DEBUG
& DEBUG_DMA
)
118 fprintf(stderr
, "finished getbuffer\n");
122 /* Still keeping this around because it demonstrates page flipping and
123 * automatic z-clear. */
124 static void savage_BCI_clear(GLcontext
*ctx
, drm_savage_clear_t
*pclear
)
126 savageContextPtr imesa
= SAVAGE_CONTEXT(ctx
);
127 int nbox
= imesa
->sarea
->nbox
;
128 drm_clip_rect_t
*pbox
= imesa
->sarea
->boxes
;
132 if (nbox
> SAVAGE_NR_SAREA_CLIPRECTS
)
133 nbox
= SAVAGE_NR_SAREA_CLIPRECTS
;
135 for (i
= 0 ; i
< nbox
; i
++, pbox
++) {
136 unsigned int x
= pbox
->x1
;
137 unsigned int y
= pbox
->y1
;
138 unsigned int width
= pbox
->x2
- x
;
139 unsigned int height
= pbox
->y2
- y
;
142 if (pbox
->x1
> pbox
->x2
||
143 pbox
->y1
> pbox
->y2
||
144 pbox
->x2
> imesa
->savageScreen
->width
||
145 pbox
->y2
> imesa
->savageScreen
->height
)
148 if ( pclear
->flags
& SAVAGE_FRONT
) {
149 bciptr
= savageDMAAlloc (imesa
, 8);
150 WRITE_CMD((bciptr
) , 0x4BCC8C00,uint32_t);
151 WRITE_CMD((bciptr
) , imesa
->savageScreen
->frontOffset
,uint32_t);
152 WRITE_CMD((bciptr
) , imesa
->savageScreen
->frontBitmapDesc
,uint32_t);
153 WRITE_CMD((bciptr
) , pclear
->clear_color
,uint32_t);
154 WRITE_CMD((bciptr
) , (y
<<16) | x
,uint32_t);
155 WRITE_CMD((bciptr
) , (height
<< 16) | width
,uint32_t);
156 savageDMACommit (imesa
, bciptr
);
158 if ( pclear
->flags
& SAVAGE_BACK
) {
159 bciptr
= savageDMAAlloc (imesa
, 8);
160 WRITE_CMD((bciptr
) , 0x4BCC8C00,uint32_t);
161 WRITE_CMD((bciptr
) , imesa
->savageScreen
->backOffset
,uint32_t);
162 WRITE_CMD((bciptr
) , imesa
->savageScreen
->backBitmapDesc
,uint32_t);
163 WRITE_CMD((bciptr
) , pclear
->clear_color
,uint32_t);
164 WRITE_CMD((bciptr
) , (y
<<16) | x
,uint32_t);
165 WRITE_CMD((bciptr
) , (height
<< 16) | width
,uint32_t);
166 savageDMACommit (imesa
, bciptr
);
169 if ( pclear
->flags
& (SAVAGE_DEPTH
|SAVAGE_STENCIL
) ) {
170 uint32_t writeMask
= 0x0;
171 if(imesa
->hw_stencil
)
173 if(pclear
->flags
& SAVAGE_STENCIL
)
176 writeMask
|= 0xFF000000;
178 if(pclear
->flags
& SAVAGE_DEPTH
)
180 writeMask
|= 0x00FFFFFF;
183 if(imesa
->IsFullScreen
&& imesa
->NotFirstFrame
&&
184 imesa
->savageScreen
->chipset
>= S3_SAVAGE4
)
186 imesa
->regs
.s4
.zBufCtrl
.ni
.autoZEnable
= GL_TRUE
;
187 imesa
->regs
.s4
.zBufCtrl
.ni
.frameID
=
188 ~imesa
->regs
.s4
.zBufCtrl
.ni
.frameID
;
190 imesa
->dirty
|= SAVAGE_UPLOAD_GLOBAL
;
194 if(imesa
->IsFullScreen
)
195 imesa
->NotFirstFrame
= GL_TRUE
;
197 if(imesa
->hw_stencil
)
199 bciptr
= savageDMAAlloc (imesa
, 10);
200 if(writeMask
!= 0xFFFFFFFF)
202 WRITE_CMD((bciptr
) , 0x960100D7,uint32_t);
203 WRITE_CMD((bciptr
) , writeMask
,uint32_t);
208 bciptr
= savageDMAAlloc (imesa
, 6);
211 WRITE_CMD((bciptr
) , 0x4BCC8C00,uint32_t);
212 WRITE_CMD((bciptr
) , imesa
->savageScreen
->depthOffset
,uint32_t);
213 WRITE_CMD((bciptr
) , imesa
->savageScreen
->depthBitmapDesc
,uint32_t);
214 WRITE_CMD((bciptr
) , pclear
->clear_depth
,uint32_t);
215 WRITE_CMD((bciptr
) , (y
<<16) | x
,uint32_t);
216 WRITE_CMD((bciptr
) , (height
<< 16) | width
,uint32_t);
217 if(imesa
->hw_stencil
)
219 if(writeMask
!= 0xFFFFFFFF)
221 WRITE_CMD((bciptr
) , 0x960100D7,uint32_t);
222 WRITE_CMD((bciptr
) , 0xFFFFFFFF,uint32_t);
225 savageDMACommit (imesa
, bciptr
);
229 /* FK: Make sure that the clear stuff is emitted. Otherwise a
230 software fallback may get overwritten by a delayed clear. */
231 savageDMAFlush (imesa
);
234 static void savage_BCI_swap(savageContextPtr imesa
)
236 int nbox
= imesa
->sarea
->nbox
;
237 drm_clip_rect_t
*pbox
= imesa
->sarea
->boxes
;
239 volatile uint32_t *bciptr
;
241 if (nbox
> SAVAGE_NR_SAREA_CLIPRECTS
)
242 nbox
= SAVAGE_NR_SAREA_CLIPRECTS
;
243 savageDMAFlush (imesa
);
245 if(imesa
->IsFullScreen
)
248 tmp0
= imesa
->savageScreen
->frontOffset
;
249 imesa
->savageScreen
->frontOffset
= imesa
->savageScreen
->backOffset
;
250 imesa
->savageScreen
->backOffset
= tmp0
;
252 if(imesa
->toggle
== TARGET_BACK
)
253 imesa
->toggle
= TARGET_FRONT
;
255 imesa
->toggle
= TARGET_BACK
;
257 driFlipRenderbuffers(imesa
->glCtx
->DrawBuffer
,
258 imesa
->toggle
!= TARGET_FRONT
);
260 imesa
->regs
.s4
.destCtrl
.ni
.offset
= imesa
->savageScreen
->backOffset
>>11;
261 imesa
->dirty
|= SAVAGE_UPLOAD_GLOBAL
;
262 bciptr
= SAVAGE_GET_BCI_POINTER(imesa
,3);
263 *(bciptr
) = 0x960100B0;
264 *(bciptr
) = (imesa
->savageScreen
->frontOffset
);
265 *(bciptr
) = 0xA0000000;
269 { /* Use bitblt copy from back to front buffer*/
271 for (i
= 0 ; i
< nbox
; i
++, pbox
++)
273 unsigned int w
= pbox
->x2
- pbox
->x1
;
274 unsigned int h
= pbox
->y2
- pbox
->y1
;
276 if (pbox
->x1
> pbox
->x2
||
277 pbox
->y1
> pbox
->y2
||
278 pbox
->x2
> imesa
->savageScreen
->width
||
279 pbox
->y2
> imesa
->savageScreen
->height
)
282 bciptr
= SAVAGE_GET_BCI_POINTER(imesa
,6);
284 *(bciptr
) = 0x4BCC00C0;
286 *(bciptr
) = imesa
->savageScreen
->backOffset
;
287 *(bciptr
) = imesa
->savageScreen
->backBitmapDesc
;
288 *(bciptr
) = (pbox
->y1
<<16) | pbox
->x1
; /*x0, y0*/
289 *(bciptr
) = (pbox
->y1
<<16) | pbox
->x1
;
290 *(bciptr
) = (h
<< 16) | w
;
298 static GLboolean
intersect_rect( drm_clip_rect_t
*out
,
299 const drm_clip_rect_t
*a
,
300 const drm_clip_rect_t
*b
)
303 if (b
->x1
> out
->x1
) out
->x1
= b
->x1
;
304 if (b
->y1
> out
->y1
) out
->y1
= b
->y1
;
305 if (b
->x2
< out
->x2
) out
->x2
= b
->x2
;
306 if (b
->y2
< out
->y2
) out
->y2
= b
->y2
;
308 return ((out
->x1
< out
->x2
) && (out
->y1
< out
->y2
));
312 static GLuint
savageIntersectClipRects(drm_clip_rect_t
*dest
,
313 const drm_clip_rect_t
*src
,
315 const drm_clip_rect_t
*clip
)
319 for (i
= 0, ndest
= 0; i
< nsrc
; ++i
, ++src
) {
320 if (intersect_rect(dest
, src
, clip
)) {
330 static void savageDDClear( GLcontext
*ctx
, GLbitfield mask
)
332 savageContextPtr imesa
= SAVAGE_CONTEXT( ctx
);
333 GLuint colorMask
, depthMask
, clearColor
, clearDepth
, flags
;
334 GLint cx
= ctx
->DrawBuffer
->_Xmin
;
335 GLint cy
= ctx
->DrawBuffer
->_Ymin
;
336 GLint cw
= ctx
->DrawBuffer
->_Xmax
- cx
;
337 GLint ch
= ctx
->DrawBuffer
->_Ymax
- cy
;
339 /* XXX FIX ME: the cx,cy,cw,ch vars are currently ignored! */
341 if (SAVAGE_DEBUG
& DEBUG_VERBOSE_MSG
)
342 fprintf (stderr
, "%s\n", __FUNCTION__
);
344 clearColor
= imesa
->ClearColor
;
345 if (imesa
->float_depth
) {
346 if (imesa
->savageScreen
->zpp
== 2)
347 clearDepth
= savageEncodeFloat16(1.0 - ctx
->Depth
.Clear
);
349 clearDepth
= savageEncodeFloat24(1.0 - ctx
->Depth
.Clear
);
351 if (imesa
->savageScreen
->zpp
== 2)
352 clearDepth
= (GLuint
) ((1.0 - ctx
->Depth
.Clear
) * DEPTH_SCALE_16
);
354 clearDepth
= (GLuint
) ((1.0 - ctx
->Depth
.Clear
) * DEPTH_SCALE_24
);
359 switch (imesa
->savageScreen
->cpp
) {
361 colorMask
= PACK_COLOR_565(ctx
->Color
.ColorMask
[0],
362 ctx
->Color
.ColorMask
[1],
363 ctx
->Color
.ColorMask
[2]);
366 colorMask
= PACK_COLOR_8888(ctx
->Color
.ColorMask
[3],
367 ctx
->Color
.ColorMask
[2],
368 ctx
->Color
.ColorMask
[1],
369 ctx
->Color
.ColorMask
[0]);
375 if (mask
& BUFFER_BIT_FRONT_LEFT
) {
376 flags
|= SAVAGE_FRONT
;
377 mask
&= ~BUFFER_BIT_FRONT_LEFT
;
380 if (mask
& BUFFER_BIT_BACK_LEFT
) {
381 flags
|= SAVAGE_BACK
;
382 mask
&= ~BUFFER_BIT_BACK_LEFT
;
385 if ((mask
& BUFFER_BIT_DEPTH
) && ctx
->Depth
.Mask
) {
386 flags
|= SAVAGE_DEPTH
;
388 (imesa
->savageScreen
->zpp
== 2) ? 0xffffffff : 0x00ffffff;
389 mask
&= ~BUFFER_BIT_DEPTH
;
392 if((mask
& BUFFER_BIT_STENCIL
) && imesa
->hw_stencil
)
394 flags
|= SAVAGE_DEPTH
;
395 depthMask
|= 0xff000000;
396 mask
&= ~BUFFER_BIT_STENCIL
;
399 savageFlushVertices(imesa
);
402 GLboolean depthCleared
= GL_FALSE
;
403 if (flags
& (SAVAGE_FRONT
|SAVAGE_BACK
)) {
404 drm_savage_cmd_header_t
*cmd
;
405 cmd
= savageAllocCmdBuf(imesa
, sizeof(drm_savage_cmd_header_t
));
406 cmd
[0].clear0
.cmd
= SAVAGE_CMD_CLEAR
;
407 if ((flags
& SAVAGE_DEPTH
) &&
408 clearDepth
== clearColor
&& depthMask
== colorMask
) {
409 cmd
[0].clear0
.flags
= flags
;
410 depthCleared
= GL_TRUE
;
412 cmd
[0].clear0
.flags
= flags
& (SAVAGE_FRONT
|SAVAGE_BACK
);
413 cmd
[1].clear1
.mask
= colorMask
;
414 cmd
[1].clear1
.value
= clearColor
;
417 if ((flags
& SAVAGE_DEPTH
) && !depthCleared
) {
418 drm_savage_cmd_header_t
*cmd
;
419 cmd
= savageAllocCmdBuf(imesa
, sizeof(drm_savage_cmd_header_t
));
420 cmd
[0].clear0
.cmd
= SAVAGE_CMD_CLEAR
;
421 cmd
[0].clear0
.flags
= SAVAGE_DEPTH
;
422 cmd
[1].clear1
.mask
= depthMask
;
423 cmd
[1].clear1
.value
= clearDepth
;
428 _swrast_Clear( ctx
, mask
);
432 * Copy the back buffer to the front buffer.
434 void savageSwapBuffers( __DRIdrawablePrivate
*dPriv
)
436 savageContextPtr imesa
;
438 if (SAVAGE_DEBUG
& DEBUG_VERBOSE_MSG
)
439 fprintf (stderr
, "%s\n================================\n", __FUNCTION__
);
442 assert(dPriv
->driContextPriv
);
443 assert(dPriv
->driContextPriv
->driverPrivate
);
445 imesa
= (savageContextPtr
) dPriv
->driContextPriv
->driverPrivate
;
447 _mesa_notifySwapBuffers( imesa
->glCtx
);
451 if (imesa
->sync_frames
)
452 imesa
->lastSwap
= savageEmitEvent( imesa
, 0 );
454 if (imesa
->lastSwap
!= 0)
455 savageWaitEvent( imesa
, imesa
->lastSwap
);
458 drm_savage_cmd_header_t
*cmd
= savageAllocCmdBuf(imesa
, 0);
459 cmd
->cmd
.cmd
= SAVAGE_CMD_SWAP
;
460 imesa
->inSwap
= GL_TRUE
; /* ignore scissors in savageFlushCmdBuf */
461 savageFlushCmdBuf(imesa
, GL_FALSE
);
462 imesa
->inSwap
= GL_FALSE
;
465 if (!imesa
->sync_frames
)
466 /* don't sync, but limit the lag to one frame. */
467 imesa
->lastSwap
= savageEmitEvent( imesa
, 0 );
470 unsigned int savageEmitEventLocked( savageContextPtr imesa
, unsigned int flags
)
472 drm_savage_event_emit_t event
;
476 ret
= drmCommandWriteRead( imesa
->driFd
, DRM_SAVAGE_BCI_EVENT_EMIT
,
477 &event
, sizeof(event
) );
479 fprintf (stderr
, "emit event returned %d\n", ret
);
484 unsigned int savageEmitEvent( savageContextPtr imesa
, unsigned int flags
)
487 LOCK_HARDWARE( imesa
);
488 ret
= savageEmitEventLocked( imesa
, flags
);
489 UNLOCK_HARDWARE( imesa
);
494 void savageWaitEvent( savageContextPtr imesa
, unsigned int count
)
496 drm_savage_event_wait_t event
;
500 ret
= drmCommandWriteRead( imesa
->driFd
, DRM_SAVAGE_BCI_EVENT_WAIT
,
501 &event
, sizeof(event
) );
503 fprintf (stderr
, "wait event returned %d\n", ret
);
509 void savageFlushVertices( savageContextPtr imesa
)
511 struct savage_vtxbuf_t
*buffer
= imesa
->vtxBuf
;
513 if (SAVAGE_DEBUG
& DEBUG_VERBOSE_MSG
)
514 fprintf (stderr
, "%s\n", __FUNCTION__
);
519 if (buffer
->used
> buffer
->flushed
) {
520 drm_savage_cmd_header_t
*cmd
;
521 /* State must be updated "per primitive" because hardware
522 * culling must be disabled for unfilled primitives, points
524 savageEmitChangedState (imesa
);
525 cmd
= savageAllocCmdBuf(imesa
, 0);
526 cmd
->prim
.cmd
= buffer
== &imesa
->dmaVtxBuf
?
527 SAVAGE_CMD_DMA_PRIM
: SAVAGE_CMD_VB_PRIM
;
528 cmd
->prim
.prim
= imesa
->HwPrim
;
529 cmd
->prim
.skip
= imesa
->skip
;
530 cmd
->prim
.start
= buffer
->flushed
/ imesa
->HwVertexSize
;
531 cmd
->prim
.count
= buffer
->used
/ imesa
->HwVertexSize
- cmd
->prim
.start
;
532 buffer
->flushed
= buffer
->used
;
536 void savageFlushCmdBufLocked( savageContextPtr imesa
, GLboolean discard
)
538 __DRIdrawablePrivate
*dPriv
= imesa
->driDrawable
;
540 if (!imesa
->dmaVtxBuf
.total
)
543 /* complete indexed drawing commands */
544 savageFlushElts(imesa
);
546 if (imesa
->cmdBuf
.write
!= imesa
->cmdBuf
.start
|| discard
) {
547 drm_savage_cmdbuf_t cmdbuf
;
548 drm_savage_cmd_header_t
*start
;
551 /* If we lost the context we must restore the initial state (at
552 * the start of the command buffer). */
553 if (imesa
->lostContext
) {
554 start
= imesa
->cmdBuf
.base
;
555 imesa
->lostContext
= GL_FALSE
;
557 start
= imesa
->cmdBuf
.start
;
559 if ((SAVAGE_DEBUG
& DEBUG_DMA
) && discard
)
560 fprintf (stderr
, "Discarding DMA buffer, used=%u\n",
561 imesa
->dmaVtxBuf
.used
);
563 cmdbuf
.dma_idx
= imesa
->dmaVtxBuf
.idx
;
564 cmdbuf
.discard
= discard
;
565 cmdbuf
.vb_addr
= imesa
->clientVtxBuf
.buf
;
566 cmdbuf
.vb_size
= imesa
->clientVtxBuf
.total
*4;
567 cmdbuf
.vb_stride
= imesa
->HwVertexSize
;
568 cmdbuf
.cmd_addr
= start
;
569 cmdbuf
.size
= (imesa
->cmdBuf
.write
- start
);
570 if (!imesa
->inSwap
&& imesa
->scissor
.enabled
) {
571 drm_clip_rect_t
*box
= dPriv
->pClipRects
, *ibox
;
572 drm_clip_rect_t scissor
;
573 GLuint nbox
= dPriv
->numClipRects
, nibox
;
574 /* transform and clip scissor to viewport */
575 scissor
.x1
= MAX2(imesa
->scissor
.x
, 0) + dPriv
->x
;
576 scissor
.y1
= MAX2(dPriv
->h
- imesa
->scissor
.y
- imesa
->scissor
.h
,
578 scissor
.x2
= MIN2(imesa
->scissor
.x
+ imesa
->scissor
.w
,
579 dPriv
->w
) + dPriv
->x
;
580 scissor
.y2
= MIN2(dPriv
->h
- imesa
->scissor
.y
,
581 dPriv
->h
) + dPriv
->y
;
582 /* intersect cliprects with scissor */
583 ibox
= malloc(dPriv
->numClipRects
*sizeof(drm_clip_rect_t
));
585 fprintf(stderr
, "Out of memory.\n");
588 nibox
= savageIntersectClipRects(ibox
, box
, nbox
, &scissor
);
590 cmdbuf
.box_addr
= ibox
;
592 cmdbuf
.nbox
= dPriv
->numClipRects
;
593 cmdbuf
.box_addr
= dPriv
->pClipRects
;
596 ret
= drmCommandWrite( imesa
->driFd
, DRM_SAVAGE_BCI_CMDBUF
,
597 &cmdbuf
, sizeof(cmdbuf
) );
599 fprintf (stderr
, "cmdbuf ioctl returned %d\n", ret
);
603 if (cmdbuf
.box_addr
!= dPriv
->pClipRects
) {
604 free(cmdbuf
.box_addr
);
607 /* Save the current state at the start of the command buffer. That
608 * state will only be emitted, if the context was lost since the
609 * last command buffer. */
610 imesa
->cmdBuf
.write
= imesa
->cmdBuf
.base
;
611 savageEmitOldState(imesa
);
612 imesa
->cmdBuf
.start
= imesa
->cmdBuf
.write
;
616 assert (!savageHaveIndexedVerts(imesa
));
617 imesa
->dmaVtxBuf
.total
= 0;
618 imesa
->dmaVtxBuf
.used
= 0;
619 imesa
->dmaVtxBuf
.flushed
= 0;
621 if (!savageHaveIndexedVerts(imesa
)) {
622 imesa
->clientVtxBuf
.used
= 0;
623 imesa
->clientVtxBuf
.flushed
= 0;
628 void savageFlushCmdBuf( savageContextPtr imesa
, GLboolean discard
)
630 if (SAVAGE_DEBUG
& DEBUG_VERBOSE_MSG
)
631 fprintf (stderr
, "%s\n", __FUNCTION__
);
632 LOCK_HARDWARE(imesa
);
633 savageFlushCmdBufLocked (imesa
, discard
);
634 UNLOCK_HARDWARE(imesa
);
638 static void savageDDFlush( GLcontext
*ctx
)
640 savageContextPtr imesa
= SAVAGE_CONTEXT(ctx
);
641 if (SAVAGE_DEBUG
& DEBUG_VERBOSE_MSG
)
642 fprintf (stderr
, "%s\n", __FUNCTION__
);
643 savageFlushVertices (imesa
);
644 savageFlushCmdBuf(imesa
, GL_FALSE
);
647 static void savageDDFinish( GLcontext
*ctx
)
649 savageContextPtr imesa
= SAVAGE_CONTEXT(ctx
);
650 if (SAVAGE_DEBUG
& DEBUG_VERBOSE_MSG
)
651 fprintf (stderr
, "%s\n", __FUNCTION__
);
652 savageFlushVertices (imesa
);
653 savageFlushCmdBuf(imesa
, GL_FALSE
);
654 WAIT_IDLE_EMPTY(imesa
);
657 void savageDDInitIoctlFuncs( GLcontext
*ctx
)
659 ctx
->Driver
.Clear
= savageDDClear
;
660 ctx
->Driver
.Flush
= savageDDFlush
;
661 ctx
->Driver
.Finish
= savageDDFinish
;