-/* $XFree86$ */ /* -*- mode: c; c-basic-offset: 3 -*- */
+/* -*- mode: c; c-basic-offset: 3 -*- */
/*
* Copyright 2000 Gareth Hughes
* All Rights Reserved.
* Authors:
* Gareth Hughes <gareth@valinux.com>
* Leif Delgass <ldelgass@retinalburn.net>
- * José Fonseca <j_r_fonseca@yahoo.co.uk>
+ * Jos�Fonseca <j_r_fonseca@yahoo.co.uk>
*/
#include <errno.h>
#include "mach64_ioctl.h"
#include "mach64_tex.h"
-#include "imports.h"
-#include "macros.h"
+#include "main/imports.h"
+#include "main/macros.h"
#include "swrast/swrast.h"
void mach64FlushVerticesLocked( mach64ContextPtr mmesa )
{
- XF86DRIClipRectPtr pbox = mmesa->pClipRects;
+ drm_clip_rect_t *pbox = mmesa->pClipRects;
int nbox = mmesa->numClipRects;
void *buffer = mmesa->vert_buf;
int count = mmesa->vert_used;
int prim = mmesa->hw_primitive;
int fd = mmesa->driScreen->fd;
- drmMach64Vertex vertex;
- int i, ret;
+ drm_mach64_vertex_t vertex;
+ int i;
mmesa->num_verts = 0;
mmesa->vert_used = 0;
mmesa->dirty |= MACH64_UPLOAD_CLIPRECTS;
if ( !count || !(mmesa->dirty & MACH64_UPLOAD_CLIPRECTS) ) {
+ int to = 0;
+ int ret;
+
/* FIXME: Is this really necessary */
if ( nbox == 1 )
mmesa->sarea->nbox = 0;
vertex.buf = buffer;
vertex.used = count;
vertex.discard = 1;
- ret = drmCommandWrite( fd, DRM_MACH64_VERTEX, &vertex, sizeof(drmMach64Vertex) );
+ do {
+ ret = drmCommandWrite( fd, DRM_MACH64_VERTEX,
+ &vertex, sizeof(drm_mach64_vertex_t) );
+ } while ( ( ret == -EAGAIN ) && ( to++ < MACH64_TIMEOUT ) );
if ( ret ) {
UNLOCK_HARDWARE( mmesa );
fprintf( stderr, "Error flushing vertex buffer: return = %d\n", ret );
for ( i = 0 ; i < nbox ; ) {
int nr = MIN2( i + MACH64_NR_SAREA_CLIPRECTS, nbox );
- XF86DRIClipRectPtr b = mmesa->sarea->boxes;
+ drm_clip_rect_t *b = mmesa->sarea->boxes;
int discard = 0;
+ int to = 0;
+ int ret;
mmesa->sarea->nbox = nr - i;
for ( ; i < nr ; i++ ) {
vertex.buf = buffer;
vertex.used = count;
vertex.discard = discard;
- ret = drmCommandWrite( fd, DRM_MACH64_VERTEX, &vertex, sizeof(drmMach64Vertex) );
+ do {
+ ret = drmCommandWrite( fd, DRM_MACH64_VERTEX,
+ &vertex, sizeof(drm_mach64_vertex_t) );
+ } while ( ( ret == -EAGAIN ) && ( to++ < MACH64_TIMEOUT ) );
if ( ret ) {
UNLOCK_HARDWARE( mmesa );
fprintf( stderr, "Error flushing vertex buffer: return = %d\n", ret );
* Texture uploads
*/
-void mach64FireBlitLocked( mach64ContextPtr mmesa, drmBufPtr buffer,
+void mach64FireBlitLocked( mach64ContextPtr mmesa, void *buffer,
GLint offset, GLint pitch, GLint format,
GLint x, GLint y, GLint width, GLint height )
{
- drmMach64Blit blit;
- GLint ret;
+ drm_mach64_blit_t blit;
+ int to = 0;
+ int ret;
- blit.idx = buffer->idx;
+ blit.buf = buffer;
blit.offset = offset;
blit.pitch = pitch;
blit.format = format;
blit.width = width;
blit.height = height;
- ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_BLIT,
- &blit, sizeof(drmMach64Blit) );
+ do {
+ ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_BLIT,
+ &blit, sizeof(drm_mach64_blit_t) );
+ } while ( ( ret == -EAGAIN ) && ( to++ < MACH64_TIMEOUT ) );
if ( ret ) {
UNLOCK_HARDWARE( mmesa );
int frames;
while ( 1 ) {
- drmMach64GetParam gp;
+ drm_mach64_getparam_t gp;
int ret;
if ( mmesa->sarea->frames_queued < MACH64_MAX_QUEUED_FRAMES ) {
/* Copy the back color buffer to the front color buffer.
*/
-void mach64CopyBuffer( const __DRIdrawablePrivate *dPriv )
+void mach64CopyBuffer( __DRIdrawable *dPriv )
{
mach64ContextPtr mmesa;
GLint nbox, i, ret;
- XF86DRIClipRectPtr pbox;
+ drm_clip_rect_t *pbox;
GLboolean missed_target;
assert(dPriv);
#endif
UNLOCK_HARDWARE( mmesa );
- driWaitForVBlank( dPriv, &mmesa->vbl_seq, mmesa->vblank_flags, &missed_target );
+ driWaitForVBlank( dPriv, &missed_target );
LOCK_HARDWARE( mmesa );
/* use front buffer cliprects */
for ( i = 0 ; i < nbox ; ) {
GLint nr = MIN2( i + MACH64_NR_SAREA_CLIPRECTS , nbox );
- XF86DRIClipRectPtr b = mmesa->sarea->boxes;
+ drm_clip_rect_t *b = mmesa->sarea->boxes;
GLint n = 0;
for ( ; i < nr ; i++ ) {
void mach64PerformanceBoxesLocked( mach64ContextPtr mmesa )
{
GLint ret;
- drmMach64Clear clear;
+ drm_mach64_clear_t clear;
GLint x, y, w, h;
GLuint color;
GLint nbox;
GLint x1, y1, x2, y2;
- XF86DRIClipRectPtr b = mmesa->sarea->boxes;
+ drm_clip_rect_t *b = mmesa->sarea->boxes;
/* save cliprects */
nbox = mmesa->sarea->nbox;
clear.clear_color = color;
ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_CLEAR,
- &clear, sizeof(drmMach64Clear) );
+ &clear, sizeof(drm_mach64_clear_t) );
if (ret < 0) {
UNLOCK_HARDWARE( mmesa );
clear.clear_color = color;
ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_CLEAR,
- &clear, sizeof(drmMach64Clear) );
+ &clear, sizeof(drm_mach64_clear_t) );
if (ret < 0) {
UNLOCK_HARDWARE( mmesa );
clear.clear_color = color;
ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_CLEAR,
- &clear, sizeof(drmMach64Clear) );
+ &clear, sizeof(drm_mach64_clear_t) );
if (ret < 0) {
UNLOCK_HARDWARE( mmesa );
clear.clear_color = color;
ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_CLEAR,
- &clear, sizeof(drmMach64Clear) );
+ &clear, sizeof(drm_mach64_clear_t) );
if (ret < 0) {
UNLOCK_HARDWARE( mmesa );
clear.clear_color = color;
ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_CLEAR,
- &clear, sizeof(drmMach64Clear) );
+ &clear, sizeof(drm_mach64_clear_t) );
if (ret < 0) {
UNLOCK_HARDWARE( mmesa );
clear.clear_color = color;
ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_CLEAR,
- &clear, sizeof(drmMach64Clear) );
+ &clear, sizeof(drm_mach64_clear_t) );
if (ret < 0) {
UNLOCK_HARDWARE( mmesa );
clear.clear_color = color;
ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_CLEAR,
- &clear, sizeof(drmMach64Clear) );
+ &clear, sizeof(drm_mach64_clear_t) );
if (ret < 0) {
UNLOCK_HARDWARE( mmesa );
clear.clear_color = color;
ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_CLEAR,
- &clear, sizeof(drmMach64Clear) );
+ &clear, sizeof(drm_mach64_clear_t) );
if (ret < 0) {
UNLOCK_HARDWARE( mmesa );
* Buffer clear
*/
-static void mach64DDClear( GLcontext *ctx, GLbitfield mask, GLboolean all,
- GLint cx, GLint cy, GLint cw, GLint ch )
+static void mach64DDClear( struct gl_context *ctx, GLbitfield mask )
{
mach64ContextPtr mmesa = MACH64_CONTEXT( ctx );
- __DRIdrawablePrivate *dPriv = mmesa->driDrawable;
- drmMach64Clear clear;
+ __DRIdrawable *dPriv = mmesa->driDrawable;
+ drm_mach64_clear_t clear;
GLuint flags = 0;
GLint i;
GLint ret;
+ GLint cx, cy, cw, ch;
if ( MACH64_DEBUG & DEBUG_VERBOSE_API ) {
- fprintf( stderr, "%s: all=%d %d,%d %dx%d\n",
- __FUNCTION__, all, cx, cy, cw, ch );
+ fprintf( stderr, "mach64DDClear\n");
}
#if ENABLE_PERF_BOXES
mmesa->new_state = save_state & ~(MACH64_NEW_MASKS | MACH64_NEW_CLIP);
}
- if ( mask & DD_FRONT_LEFT_BIT ) {
+ if ( mask & BUFFER_BIT_FRONT_LEFT ) {
flags |= MACH64_FRONT;
- mask &= ~DD_FRONT_LEFT_BIT;
+ mask &= ~BUFFER_BIT_FRONT_LEFT;
}
- if ( mask & DD_BACK_LEFT_BIT ) {
+ if ( mask & BUFFER_BIT_BACK_LEFT ) {
flags |= MACH64_BACK;
- mask &= ~DD_BACK_LEFT_BIT;
+ mask &= ~BUFFER_BIT_BACK_LEFT;
}
- if ( ( mask & DD_DEPTH_BIT ) && ctx->Depth.Mask ) {
+ if ( ( mask & BUFFER_BIT_DEPTH ) && ctx->Depth.Mask ) {
flags |= MACH64_DEPTH;
- mask &= ~DD_DEPTH_BIT;
+ mask &= ~BUFFER_BIT_DEPTH;
}
if ( mask )
- _swrast_Clear( ctx, mask, all, cx, cy, cw, ch );
+ _swrast_Clear( ctx, mask );
if ( !flags )
return;
LOCK_HARDWARE( mmesa );
- /* This needs to be in the locked region, so updated drawable origin is used */
+ /* compute region after locking: */
+ cx = ctx->DrawBuffer->_Xmin;
+ cy = ctx->DrawBuffer->_Ymin;
+ cw = ctx->DrawBuffer->_Xmax - cx;
+ ch = ctx->DrawBuffer->_Ymax - cy;
+
/* Flip top to bottom */
cx += mmesa->drawX;
cy = mmesa->drawY + dPriv->h - cy - ch;
for ( i = 0 ; i < mmesa->numClipRects ; ) {
int nr = MIN2( i + MACH64_NR_SAREA_CLIPRECTS, mmesa->numClipRects );
- XF86DRIClipRectPtr box = mmesa->pClipRects;
- XF86DRIClipRectPtr b = mmesa->sarea->boxes;
+ drm_clip_rect_t *box = mmesa->pClipRects;
+ drm_clip_rect_t *b = mmesa->sarea->boxes;
GLint n = 0;
- if ( !all ) {
+ if (cw != dPriv->w || ch != dPriv->h) {
+ /* clear subregion */
for ( ; i < nr ; i++ ) {
GLint x = box[i].x1;
GLint y = box[i].y1;
n++;
}
} else {
+ /* clear whole window */
for ( ; i < nr ; i++ ) {
*b++ = box[i];
n++;
clear.clear_depth = mmesa->ClearDepth;
ret = drmCommandWrite( mmesa->driFd, DRM_MACH64_CLEAR,
- &clear, sizeof(drmMach64Clear) );
+ &clear, sizeof(drm_mach64_clear_t) );
if ( ret ) {
UNLOCK_HARDWARE( mmesa );
/* For client-side state emits - currently unused */
void mach64UploadHwStateLocked( mach64ContextPtr mmesa )
{
- ATISAREAPrivPtr sarea = mmesa->sarea;
+ drm_mach64_sarea_t *sarea = mmesa->sarea;
- mach64_context_regs_t *regs = &sarea->ContextState;
+ drm_mach64_context_regs_t *regs = &sarea->context_state;
unsigned int dirty = sarea->dirty;
CARD32 offset = ((regs->tex_size_pitch & 0xf0) >> 2);
projects / mesa.git / blobdiff