1 /* $XFree86$ */ /* -*- mode: c; c-basic-offset: 3 -*- */
3 * Copyright 2000 Gareth Hughes
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice (including the next
14 * paragraph) shall be included in all copies or substantial portions of the
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * GARETH HUGHES BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * Gareth Hughes <gareth@valinux.com>
28 * Leif Delgass <ldelgass@retinalburn.net>
29 * José Fonseca <j_r_fonseca@yahoo.co.uk>
32 #include "mach64_context.h"
33 #include "mach64_state.h"
34 #include "mach64_ioctl.h"
35 #include "mach64_tex.h"
40 #include "swrast/swrast.h"
44 #define MACH64_TIMEOUT 10 /* the DRM already has a timeout, so keep this small */
47 /* =============================================================
48 * Hardware vertex buffer handling
51 /* Get a new VB from the pool of vertex buffers in AGP space.
53 drmBufPtr
mach64GetBufferLocked( mach64ContextPtr mmesa
)
55 int fd
= mmesa
->mach64Screen
->driScreen
->fd
;
63 dma
.context
= mmesa
->hHWContext
;
66 dma
.send_sizes
= NULL
;
68 dma
.request_count
= 1;
69 dma
.request_size
= MACH64_BUFFER_SIZE
;
70 dma
.request_list
= &index
;
71 dma
.request_sizes
= &size
;
72 dma
.granted_count
= 0;
74 while ( !buf
&& ( to
++ < MACH64_TIMEOUT
) ) {
75 ret
= drmDMA( fd
, &dma
);
78 buf
= &mmesa
->mach64Screen
->buffers
->list
[index
];
81 /* Bump the performance counter */
82 mmesa
->c_vertexBuffers
++;
89 drmCommandNone( fd
, DRM_MACH64_RESET
);
90 UNLOCK_HARDWARE( mmesa
);
91 fprintf( stderr
, "Error: Could not get new VB... exiting\n" );
98 void mach64FlushVerticesLocked( mach64ContextPtr mmesa
)
100 XF86DRIClipRectPtr pbox
= mmesa
->pClipRects
;
101 int nbox
= mmesa
->numClipRects
;
102 void *buffer
= mmesa
->vert_buf
;
103 int count
= mmesa
->vert_used
;
104 int prim
= mmesa
->hw_primitive
;
105 int fd
= mmesa
->driScreen
->fd
;
106 drmMach64Vertex vertex
;
109 mmesa
->num_verts
= 0;
110 mmesa
->vert_used
= 0;
115 if ( mmesa
->dirty
& ~MACH64_UPLOAD_CLIPRECTS
)
116 mach64EmitHwStateLocked( mmesa
);
121 if ( nbox
> MACH64_NR_SAREA_CLIPRECTS
)
122 mmesa
->dirty
|= MACH64_UPLOAD_CLIPRECTS
;
124 if ( !count
|| !(mmesa
->dirty
& MACH64_UPLOAD_CLIPRECTS
) ) {
125 /* FIXME: Is this really necessary */
127 mmesa
->sarea
->nbox
= 0;
129 mmesa
->sarea
->nbox
= nbox
;
135 ret
= drmCommandWrite( fd
, DRM_MACH64_VERTEX
, &vertex
, sizeof(drmMach64Vertex
) );
137 UNLOCK_HARDWARE( mmesa
);
138 fprintf( stderr
, "Error flushing vertex buffer: return = %d\n", ret
);
144 for ( i
= 0 ; i
< nbox
; ) {
145 int nr
= MIN2( i
+ MACH64_NR_SAREA_CLIPRECTS
, nbox
);
146 XF86DRIClipRectPtr b
= mmesa
->sarea
->boxes
;
149 mmesa
->sarea
->nbox
= nr
- i
;
150 for ( ; i
< nr
; i
++ ) {
154 /* Finished with the buffer?
160 mmesa
->sarea
->dirty
|= MACH64_UPLOAD_CLIPRECTS
;
165 vertex
.discard
= discard
;
166 ret
= drmCommandWrite( fd
, DRM_MACH64_VERTEX
, &vertex
, sizeof(drmMach64Vertex
) );
168 UNLOCK_HARDWARE( mmesa
);
169 fprintf( stderr
, "Error flushing vertex buffer: return = %d\n", ret
);
175 mmesa
->dirty
&= ~MACH64_UPLOAD_CLIPRECTS
;
178 /* ================================================================
182 void mach64FireBlitLocked( mach64ContextPtr mmesa
, drmBufPtr buffer
,
183 GLint offset
, GLint pitch
, GLint format
,
184 GLint x
, GLint y
, GLint width
, GLint height
)
189 blit
.idx
= buffer
->idx
;
190 blit
.offset
= offset
;
192 blit
.format
= format
;
196 blit
.height
= height
;
198 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_BLIT
,
199 &blit
, sizeof(drmMach64Blit
) );
202 UNLOCK_HARDWARE( mmesa
);
203 fprintf( stderr
, "DRM_MACH64_BLIT: return = %d\n", ret
);
209 /* ================================================================
210 * SwapBuffers with client-side throttling
212 static void delay( void ) {
213 /* Prevent an optimizing compiler from removing a spin loop */
216 /* Throttle the frame rate -- only allow MACH64_MAX_QUEUED_FRAMES
217 * pending swap buffers requests at a time.
219 * GH: We probably don't want a timeout here, as we can wait as
220 * long as we want for a frame to complete. If it never does, then
221 * the card has locked.
223 static int mach64WaitForFrameCompletion( mach64ContextPtr mmesa
)
225 int fd
= mmesa
->driFd
;
231 drmMach64GetParam gp
;
234 if ( mmesa
->sarea
->frames_queued
< MACH64_MAX_QUEUED_FRAMES
) {
238 if (MACH64_DEBUG
& DEBUG_NOWAIT
) {
242 gp
.param
= MACH64_PARAM_FRAMES_QUEUED
;
243 gp
.value
= &frames
; /* also copied into sarea->frames_queued by DRM */
245 ret
= drmCommandWriteRead( fd
, DRM_MACH64_GETPARAM
, &gp
, sizeof(gp
) );
248 UNLOCK_HARDWARE( mmesa
);
249 fprintf( stderr
, "DRM_MACH64_GETPARAM: return = %d\n", ret
);
253 /* Spin in place a bit so we aren't hammering the register */
256 for ( i
= 0 ; i
< 1024 ; i
++ ) {
265 /* Copy the back color buffer to the front color buffer.
267 void mach64CopyBuffer( const __DRIdrawablePrivate
*dPriv
)
269 mach64ContextPtr mmesa
;
271 XF86DRIClipRectPtr pbox
;
272 GLboolean missed_target
;
275 assert(dPriv
->driContextPriv
);
276 assert(dPriv
->driContextPriv
->driverPrivate
);
278 mmesa
= (mach64ContextPtr
) dPriv
->driContextPriv
->driverPrivate
;
280 if ( MACH64_DEBUG
& DEBUG_VERBOSE_API
) {
281 fprintf( stderr
, "\n********************************\n" );
282 fprintf( stderr
, "\n%s( %p )\n\n",
283 __FUNCTION__
, mmesa
->glCtx
);
287 /* Flush any outstanding vertex buffers */
288 FLUSH_BATCH( mmesa
);
290 LOCK_HARDWARE( mmesa
);
292 /* Throttle the frame rate -- only allow one pending swap buffers
295 if ( !mach64WaitForFrameCompletion( mmesa
) ) {
296 mmesa
->hardwareWentIdle
= 1;
298 mmesa
->hardwareWentIdle
= 0;
301 #if ENABLE_PERF_BOXES
302 if ( mmesa
->boxes
) {
303 mach64PerformanceBoxesLocked( mmesa
);
307 UNLOCK_HARDWARE( mmesa
);
308 driWaitForVBlank( dPriv
, &mmesa
->vbl_seq
, mmesa
->vblank_flags
, &missed_target
);
309 LOCK_HARDWARE( mmesa
);
311 /* use front buffer cliprects */
312 nbox
= dPriv
->numClipRects
;
313 pbox
= dPriv
->pClipRects
;
315 for ( i
= 0 ; i
< nbox
; ) {
316 GLint nr
= MIN2( i
+ MACH64_NR_SAREA_CLIPRECTS
, nbox
);
317 XF86DRIClipRectPtr b
= mmesa
->sarea
->boxes
;
320 for ( ; i
< nr
; i
++ ) {
324 mmesa
->sarea
->nbox
= n
;
326 ret
= drmCommandNone( mmesa
->driFd
, DRM_MACH64_SWAP
);
329 UNLOCK_HARDWARE( mmesa
);
330 fprintf( stderr
, "DRM_MACH64_SWAP: return = %d\n", ret
);
335 if ( MACH64_DEBUG
& DEBUG_ALWAYS_SYNC
) {
336 mach64WaitForIdleLocked( mmesa
);
339 UNLOCK_HARDWARE( mmesa
);
341 mmesa
->dirty
|= (MACH64_UPLOAD_CONTEXT
|
343 MACH64_UPLOAD_CLIPRECTS
);
345 #if ENABLE_PERF_BOXES
346 /* Log the performance counters if necessary */
347 mach64PerformanceCounters( mmesa
);
351 #if ENABLE_PERF_BOXES
352 /* ================================================================
353 * Performance monitoring
356 void mach64PerformanceCounters( mach64ContextPtr mmesa
)
359 if (MACH64_DEBUG
& DEBUG_VERBOSE_COUNT
) {
360 /* report performance counters */
361 fprintf( stderr
, "mach64CopyBuffer: vertexBuffers:%i drawWaits:%i clears:%i\n",
362 mmesa
->c_vertexBuffers
, mmesa
->c_drawWaits
, mmesa
->c_clears
);
365 mmesa
->c_vertexBuffers
= 0;
366 mmesa
->c_drawWaits
= 0;
369 if ( mmesa
->c_textureSwaps
|| mmesa
->c_textureBytes
|| mmesa
->c_agpTextureBytes
) {
370 if (MACH64_DEBUG
& DEBUG_VERBOSE_COUNT
) {
371 fprintf( stderr
, " textureSwaps:%i textureBytes:%i agpTextureBytes:%i\n",
372 mmesa
->c_textureSwaps
, mmesa
->c_textureBytes
, mmesa
->c_agpTextureBytes
);
374 mmesa
->c_textureSwaps
= 0;
375 mmesa
->c_textureBytes
= 0;
376 mmesa
->c_agpTextureBytes
= 0;
379 mmesa
->c_texsrc_agp
= 0;
380 mmesa
->c_texsrc_card
= 0;
382 if (MACH64_DEBUG
& DEBUG_VERBOSE_COUNT
)
383 fprintf( stderr
, "---------------------------------------------------------\n" );
387 void mach64PerformanceBoxesLocked( mach64ContextPtr mmesa
)
390 drmMach64Clear clear
;
394 GLint x1
, y1
, x2
, y2
;
395 XF86DRIClipRectPtr b
= mmesa
->sarea
->boxes
;
398 nbox
= mmesa
->sarea
->nbox
;
404 /* setup a single cliprect and call the clear ioctl for each box */
405 mmesa
->sarea
->nbox
= 1;
415 clear
.flags
= MACH64_BACK
;
416 clear
.clear_depth
= 0;
418 /* Red box if DDFinish was called to wait for rendering to complete */
419 if ( mmesa
->c_drawWaits
) {
420 color
= mach64PackColor( mmesa
->mach64Screen
->cpp
, 255, 0, 0, 0 );
426 clear
.clear_color
= color
;
428 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_CLEAR
,
429 &clear
, sizeof(drmMach64Clear
) );
432 UNLOCK_HARDWARE( mmesa
);
433 fprintf( stderr
, "DRM_MACH64_CLEAR: return = %d\n", ret
);
443 /* draw a green box if we had to wait for previous frame(s) to complete */
444 if ( !mmesa
->hardwareWentIdle
) {
445 color
= mach64PackColor( mmesa
->mach64Screen
->cpp
, 0, 255, 0, 0 );
451 clear
.clear_color
= color
;
453 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_CLEAR
,
454 &clear
, sizeof(drmMach64Clear
) );
457 UNLOCK_HARDWARE( mmesa
);
458 fprintf( stderr
, "DRM_MACH64_CLEAR: return = %d\n", ret
);
468 /* show approx. ratio of AGP/card textures used - Blue = AGP, Purple = Card */
469 if ( mmesa
->c_texsrc_agp
|| mmesa
->c_texsrc_card
) {
470 color
= mach64PackColor( mmesa
->mach64Screen
->cpp
, 0, 0, 255, 0 );
471 w
= ((GLfloat
)mmesa
->c_texsrc_agp
/ (GLfloat
)(mmesa
->c_texsrc_agp
+ mmesa
->c_texsrc_card
))*20;
480 clear
.clear_color
= color
;
482 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_CLEAR
,
483 &clear
, sizeof(drmMach64Clear
) );
486 UNLOCK_HARDWARE( mmesa
);
487 fprintf( stderr
, "DRM_MACH64_CLEAR: return = %d\n", ret
);
499 color
= mach64PackColor( mmesa
->mach64Screen
->cpp
, 255, 0, 255, 0 );
505 clear
.clear_color
= color
;
507 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_CLEAR
,
508 &clear
, sizeof(drmMach64Clear
) );
511 UNLOCK_HARDWARE( mmesa
);
512 fprintf( stderr
, "DRM_MACH64_CLEAR: return = %d\n", ret
);
523 /* Yellow box if we swapped textures */
524 if ( mmesa
->c_textureSwaps
) {
525 color
= mach64PackColor( mmesa
->mach64Screen
->cpp
, 255, 255, 0, 0 );
531 clear
.clear_color
= color
;
533 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_CLEAR
,
534 &clear
, sizeof(drmMach64Clear
) );
537 UNLOCK_HARDWARE( mmesa
);
538 fprintf( stderr
, "DRM_MACH64_CLEAR: return = %d\n", ret
);
549 /* Purple bar for card memory texture blits/uploads */
550 if ( mmesa
->c_textureBytes
) {
551 color
= mach64PackColor( mmesa
->mach64Screen
->cpp
, 255, 0, 255, 0 );
552 w
= mmesa
->c_textureBytes
/ 16384;
555 if (w
> (mmesa
->driDrawable
->w
- 44))
556 w
= mmesa
->driDrawable
->w
- 44;
564 clear
.clear_color
= color
;
566 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_CLEAR
,
567 &clear
, sizeof(drmMach64Clear
) );
570 UNLOCK_HARDWARE( mmesa
);
571 fprintf( stderr
, "DRM_MACH64_CLEAR: return = %d\n", ret
);
576 /* Blue bar for AGP memory texture blits/uploads */
577 if ( mmesa
->c_agpTextureBytes
) {
578 color
= mach64PackColor( mmesa
->mach64Screen
->cpp
, 0, 0, 255, 0 );
579 w
= mmesa
->c_agpTextureBytes
/ 16384;
582 if (w
> (mmesa
->driDrawable
->w
- 44))
583 w
= mmesa
->driDrawable
->w
- 44;
594 clear
.clear_color
= color
;
596 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_CLEAR
,
597 &clear
, sizeof(drmMach64Clear
) );
600 UNLOCK_HARDWARE( mmesa
);
601 fprintf( stderr
, "DRM_MACH64_CLEAR: return = %d\n", ret
);
606 /* Pink bar for number of vertex buffers used */
607 if ( mmesa
->c_vertexBuffers
) {
608 color
= mach64PackColor( mmesa
->mach64Screen
->cpp
, 196, 128, 128, 0 );
610 w
= mmesa
->c_vertexBuffers
;
611 if (w
> (mmesa
->driDrawable
->w
))
612 w
= mmesa
->driDrawable
->w
;
616 y
= mmesa
->drawY
+ 8;
626 clear
.clear_color
= color
;
628 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_CLEAR
,
629 &clear
, sizeof(drmMach64Clear
) );
632 UNLOCK_HARDWARE( mmesa
);
633 fprintf( stderr
, "DRM_MACH64_CLEAR: return = %d\n", ret
);
638 /* restore cliprects */
639 mmesa
->sarea
->nbox
= nbox
;
649 /* ================================================================
653 static void mach64DDClear( GLcontext
*ctx
, GLbitfield mask
, GLboolean all
,
654 GLint cx
, GLint cy
, GLint cw
, GLint ch
)
656 mach64ContextPtr mmesa
= MACH64_CONTEXT( ctx
);
657 __DRIdrawablePrivate
*dPriv
= mmesa
->driDrawable
;
658 drmMach64Clear clear
;
663 if ( MACH64_DEBUG
& DEBUG_VERBOSE_API
) {
664 fprintf( stderr
, "%s: all=%d %d,%d %dx%d\n",
665 __FUNCTION__
, all
, cx
, cy
, cw
, ch
);
668 #if ENABLE_PERF_BOXES
669 /* Bump the performance counter */
673 FLUSH_BATCH( mmesa
);
675 /* The only state changes we care about here are the RGBA colormask
676 * and scissor/clipping. We'll just update that state, if needed.
678 if ( mmesa
->new_state
& (MACH64_NEW_MASKS
| MACH64_NEW_CLIP
) ) {
679 const GLuint save_state
= mmesa
->new_state
;
680 mmesa
->new_state
&= (MACH64_NEW_MASKS
| MACH64_NEW_CLIP
);
681 mach64DDUpdateHWState( ctx
);
682 mmesa
->new_state
= save_state
& ~(MACH64_NEW_MASKS
| MACH64_NEW_CLIP
);
685 if ( mask
& DD_FRONT_LEFT_BIT
) {
686 flags
|= MACH64_FRONT
;
687 mask
&= ~DD_FRONT_LEFT_BIT
;
690 if ( mask
& DD_BACK_LEFT_BIT
) {
691 flags
|= MACH64_BACK
;
692 mask
&= ~DD_BACK_LEFT_BIT
;
695 if ( ( mask
& DD_DEPTH_BIT
) && ctx
->Depth
.Mask
) {
696 flags
|= MACH64_DEPTH
;
697 mask
&= ~DD_DEPTH_BIT
;
701 _swrast_Clear( ctx
, mask
, all
, cx
, cy
, cw
, ch
);
706 LOCK_HARDWARE( mmesa
);
708 /* This needs to be in the locked region, so updated drawable origin is used */
709 /* Flip top to bottom */
711 cy
= mmesa
->drawY
+ dPriv
->h
- cy
- ch
;
715 if ( mmesa
->dirty
& ~MACH64_UPLOAD_CLIPRECTS
) {
716 mach64EmitHwStateLocked( mmesa
);
719 for ( i
= 0 ; i
< mmesa
->numClipRects
; ) {
720 int nr
= MIN2( i
+ MACH64_NR_SAREA_CLIPRECTS
, mmesa
->numClipRects
);
721 XF86DRIClipRectPtr box
= mmesa
->pClipRects
;
722 XF86DRIClipRectPtr b
= mmesa
->sarea
->boxes
;
726 for ( ; i
< nr
; i
++ ) {
729 GLint w
= box
[i
].x2
- x
;
730 GLint h
= box
[i
].y2
- y
;
732 if ( x
< cx
) w
-= cx
- x
, x
= cx
;
733 if ( y
< cy
) h
-= cy
- y
, y
= cy
;
734 if ( x
+ w
> cx
+ cw
) w
= cx
+ cw
- x
;
735 if ( y
+ h
> cy
+ ch
) h
= cy
+ ch
- y
;
736 if ( w
<= 0 ) continue;
737 if ( h
<= 0 ) continue;
747 for ( ; i
< nr
; i
++ ) {
753 mmesa
->sarea
->nbox
= n
;
755 if ( MACH64_DEBUG
& DEBUG_VERBOSE_IOCTL
) {
757 "DRM_MACH64_CLEAR: flag 0x%x color %x depth %x nbox %d\n",
759 (GLuint
)mmesa
->ClearColor
,
760 (GLuint
)mmesa
->ClearDepth
,
761 mmesa
->sarea
->nbox
);
769 clear
.clear_color
= mmesa
->ClearColor
;
770 clear
.clear_depth
= mmesa
->ClearDepth
;
772 ret
= drmCommandWrite( mmesa
->driFd
, DRM_MACH64_CLEAR
,
773 &clear
, sizeof(drmMach64Clear
) );
776 UNLOCK_HARDWARE( mmesa
);
777 fprintf( stderr
, "DRM_MACH64_CLEAR: return = %d\n", ret
);
782 UNLOCK_HARDWARE( mmesa
);
784 mmesa
->dirty
|= (MACH64_UPLOAD_CONTEXT
|
786 MACH64_UPLOAD_CLIPRECTS
);
791 void mach64WaitForIdleLocked( mach64ContextPtr mmesa
)
793 int fd
= mmesa
->driFd
;
798 ret
= drmCommandNone( fd
, DRM_MACH64_IDLE
);
799 } while ( ( ret
== -EBUSY
) && ( to
++ < MACH64_TIMEOUT
) );
802 drmCommandNone( fd
, DRM_MACH64_RESET
);
803 UNLOCK_HARDWARE( mmesa
);
804 fprintf( stderr
, "Error: Mach64 timed out... exiting\n" );
809 /* Flush the DMA queue to the hardware */
810 void mach64FlushDMALocked( mach64ContextPtr mmesa
)
812 int fd
= mmesa
->driFd
;
815 ret
= drmCommandNone( fd
, DRM_MACH64_FLUSH
);
818 drmCommandNone( fd
, DRM_MACH64_RESET
);
819 UNLOCK_HARDWARE( mmesa
);
820 fprintf( stderr
, "Error flushing DMA... exiting\n" );
824 mmesa
->dirty
|= (MACH64_UPLOAD_CONTEXT
|
826 MACH64_UPLOAD_CLIPRECTS
);
830 /* For client-side state emits - currently unused */
831 void mach64UploadHwStateLocked( mach64ContextPtr mmesa
)
833 ATISAREAPrivPtr sarea
= mmesa
->sarea
;
835 mach64_context_regs_t
*regs
= &sarea
->ContextState
;
836 unsigned int dirty
= sarea
->dirty
;
837 CARD32 offset
= ((regs
->tex_size_pitch
& 0xf0) >> 2);
843 if ( dirty
& MACH64_UPLOAD_MISC
) {
844 DMAOUTREG( MACH64_DP_MIX
, regs
->dp_mix
);
845 DMAOUTREG( MACH64_DP_SRC
, regs
->dp_src
);
846 DMAOUTREG( MACH64_CLR_CMP_CNTL
, regs
->clr_cmp_cntl
);
847 DMAOUTREG( MACH64_GUI_TRAJ_CNTL
, regs
->gui_traj_cntl
);
848 DMAOUTREG( MACH64_SC_LEFT_RIGHT
, regs
->sc_left_right
);
849 DMAOUTREG( MACH64_SC_TOP_BOTTOM
, regs
->sc_top_bottom
);
850 sarea
->dirty
&= ~MACH64_UPLOAD_MISC
;
853 if ( dirty
& MACH64_UPLOAD_DST_OFF_PITCH
) {
854 DMAOUTREG( MACH64_DST_OFF_PITCH
, regs
->dst_off_pitch
);
855 sarea
->dirty
&= ~MACH64_UPLOAD_DST_OFF_PITCH
;
857 if ( dirty
& MACH64_UPLOAD_Z_OFF_PITCH
) {
858 DMAOUTREG( MACH64_Z_OFF_PITCH
, regs
->z_off_pitch
);
859 sarea
->dirty
&= ~MACH64_UPLOAD_Z_OFF_PITCH
;
861 if ( dirty
& MACH64_UPLOAD_Z_ALPHA_CNTL
) {
862 DMAOUTREG( MACH64_Z_CNTL
, regs
->z_cntl
);
863 DMAOUTREG( MACH64_ALPHA_TST_CNTL
, regs
->alpha_tst_cntl
);
864 sarea
->dirty
&= ~MACH64_UPLOAD_Z_ALPHA_CNTL
;
866 if ( dirty
& MACH64_UPLOAD_SCALE_3D_CNTL
) {
867 DMAOUTREG( MACH64_SCALE_3D_CNTL
, regs
->scale_3d_cntl
);
868 sarea
->dirty
&= ~MACH64_UPLOAD_SCALE_3D_CNTL
;
870 if ( dirty
& MACH64_UPLOAD_DP_FOG_CLR
) {
871 DMAOUTREG( MACH64_DP_FOG_CLR
, regs
->dp_fog_clr
);
872 sarea
->dirty
&= ~MACH64_UPLOAD_DP_FOG_CLR
;
874 if ( dirty
& MACH64_UPLOAD_DP_WRITE_MASK
) {
875 DMAOUTREG( MACH64_DP_WRITE_MASK
, regs
->dp_write_mask
);
876 sarea
->dirty
&= ~MACH64_UPLOAD_DP_WRITE_MASK
;
878 if ( dirty
& MACH64_UPLOAD_DP_PIX_WIDTH
) {
879 DMAOUTREG( MACH64_DP_PIX_WIDTH
, regs
->dp_pix_width
);
880 sarea
->dirty
&= ~MACH64_UPLOAD_DP_PIX_WIDTH
;
882 if ( dirty
& MACH64_UPLOAD_SETUP_CNTL
) {
883 DMAOUTREG( MACH64_SETUP_CNTL
, regs
->setup_cntl
);
884 sarea
->dirty
&= ~MACH64_UPLOAD_SETUP_CNTL
;
887 if ( dirty
& MACH64_UPLOAD_TEXTURE
) {
888 DMAOUTREG( MACH64_TEX_SIZE_PITCH
, regs
->tex_size_pitch
);
889 DMAOUTREG( MACH64_TEX_CNTL
, regs
->tex_cntl
);
890 DMAOUTREG( MACH64_SECONDARY_TEX_OFF
, regs
->secondary_tex_off
);
891 DMAOUTREG( MACH64_TEX_0_OFF
+ offset
, regs
->tex_offset
);
892 sarea
->dirty
&= ~MACH64_UPLOAD_TEXTURE
;
896 if ( dirty
& MACH64_UPLOAD_CLIPRECTS
) {
897 DMAOUTREG( MACH64_SC_LEFT_RIGHT
, regs
->sc_left_right
);
898 DMAOUTREG( MACH64_SC_TOP_BOTTOM
, regs
->sc_top_bottom
);
899 sarea
->dirty
&= ~MACH64_UPLOAD_CLIPRECTS
;
908 void mach64DDInitIoctlFuncs( GLcontext
*ctx
)
910 ctx
->Driver
.Clear
= mach64DDClear
;