src/mesa/drivers/dri/mach64/mach64_ioctl.h

   1 /* $XFree86$ */ /* -*- mode: c; c-basic-offset: 3 -*- */
   2 /*
   3  * Copyright 2000 Gareth Hughes
   4  * All Rights Reserved.
   5  *
   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:
  12  *
  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
  15  * Software.
  16  *
  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.
  23  */
  24
  25 /*
  26  * Authors:
  27  *      Gareth Hughes <gareth@valinux.com>
  28  *      Leif Delgass <ldelgass@retinalburn.net>
  29  *      José Fonseca <j_r_fonseca@yahoo.co.uk>
  30  */
  31
  32 #ifndef __MACH64_IOCTL_H__
  33 #define __MACH64_IOCTL_H__
  34
  35 #ifdef GLX_DIRECT_RENDERING
  36
  37 #include "mach64_dri.h"
  38 #include "mach64_reg.h"
  39 #include "mach64_lock.h"
  40
  41 #include "xf86drm.h"
  42 #include "mach64_common.h"
  43
  44 #define MACH64_BUFFER_MAX_DWORDS        (MACH64_BUFFER_SIZE / sizeof(CARD32))
  45
  46
  47 extern drmBufPtr mach64GetBufferLocked( mach64ContextPtr mmesa );
  48 extern void mach64FlushVerticesLocked( mach64ContextPtr mmesa );
  49 extern void mach64FlushDMALocked( mach64ContextPtr mmesa );
  50 extern void mach64UploadHwStateLocked( mach64ContextPtr mmesa );
  51
  52 static __inline void *mach64AllocDmaLow( mach64ContextPtr mmesa, int bytes )
  53 {
  54    CARD32 *head;
  55
  56    if ( mmesa->vert_used + bytes > mmesa->vert_total ) {
  57       LOCK_HARDWARE( mmesa );
  58       mach64FlushVerticesLocked( mmesa );
  59       UNLOCK_HARDWARE( mmesa );
  60    }
  61
  62    head = (CARD32 *)((char *)mmesa->vert_buf + mmesa->vert_used);
  63    mmesa->vert_used += bytes;
  64
  65    return head;
  66 }
  67
  68 static __inline void *mach64AllocDmaLocked( mach64ContextPtr mmesa, int bytes )
  69 {
  70    CARD32 *head;
  71
  72    if ( mmesa->vert_used + bytes > mmesa->vert_total ) {
  73       mach64FlushVerticesLocked( mmesa );
  74    }
  75
  76    head = (CARD32 *)((char *)mmesa->vert_buf + mmesa->vert_used);
  77    mmesa->vert_used += bytes;
  78
  79    return head;
  80 }
  81
  82 extern void mach64FireBlitLocked( mach64ContextPtr mmesa, drmBufPtr buffer,
  83                                   GLint offset, GLint pitch, GLint format,
  84                                   GLint x, GLint y, GLint width, GLint height );
  85
  86 extern void mach64CopyBuffer( const __DRIdrawablePrivate *dPriv );
  87 #if ENABLE_PERF_BOXES
  88 extern void mach64PerformanceCounters( mach64ContextPtr mmesa );
  89 extern void mach64PerformanceBoxesLocked( mach64ContextPtr mmesa );
  90 #endif
  91 extern void mach64WaitForIdleLocked( mach64ContextPtr mmesa );
  92
  93
  94 extern void mach64DDInitIoctlFuncs( GLcontext *ctx );
  95
  96
  97 /* ================================================================
  98  * Helper macros:
  99  */
 100
 101 #define FLUSH_BATCH( mmesa )                                            \
 102 do {                                                                    \
 103    if ( MACH64_DEBUG & DEBUG_VERBOSE_IOCTL )                            \
 104       fprintf( stderr, "FLUSH_BATCH in %s\n", __FUNCTION__ );           \
 105    if ( mmesa->vert_used ) {                                            \
 106       mach64FlushVertices( mmesa );                                     \
 107    }                                                                    \
 108 } while (0)
 109
 110 /* According to a comment in ATIMach64Sync (atimach64.c) in the DDX:
 111  *
 112  * "For VTB's and later, the first CPU read of the framebuffer will return
 113  * zeroes [...] This appears to be due to some kind of engine
 114  * caching of framebuffer data I haven't found any way of disabling, or
 115  * otherwise circumventing."
 116  */
 117 #define FINISH_DMA_LOCKED( mmesa )                                      \
 118 do {                                                                    \
 119    CARD32 _tmp;                                                         \
 120    if ( MACH64_DEBUG & DEBUG_VERBOSE_IOCTL )                            \
 121       fprintf( stderr, "FINISH_DMA_LOCKED in %s\n", __FUNCTION__ );     \
 122    if ( mmesa->vert_used ) {                                            \
 123       mach64FlushVerticesLocked( mmesa );                               \
 124    }                                                                    \
 125    mach64WaitForIdleLocked( mmesa );                                    \
 126    /* pre-read framebuffer to counter caching problem */                \
 127    _tmp = *(volatile CARD32 *)mmesa->driScreen->pFB;                    \
 128 } while (0)
 129
 130 #define FLUSH_DMA_LOCKED( mmesa )                                       \
 131 do {                                                                    \
 132    if ( MACH64_DEBUG & DEBUG_VERBOSE_IOCTL )                            \
 133       fprintf( stderr, "FLUSH_DMA_LOCKED in %s\n", __FUNCTION__ );      \
 134    if ( mmesa->vert_used ) {                                            \
 135       mach64FlushVerticesLocked( mmesa );                               \
 136    }                                                                    \
 137    mach64FlushDMALocked( mmesa );                                       \
 138 } while (0)
 139
 140 #define mach64FlushVertices( mmesa )                                    \
 141 do {                                                                    \
 142    LOCK_HARDWARE( mmesa );                                              \
 143    mach64FlushVerticesLocked( mmesa );                                  \
 144    UNLOCK_HARDWARE( mmesa );                                            \
 145 } while (0)
 146
 147 #define mach64WaitForIdle( mmesa )              \
 148 do {                                            \
 149    LOCK_HARDWARE( mmesa );                      \
 150    mach64WaitForIdleLocked( mmesa );            \
 151    UNLOCK_HARDWARE( mmesa );                    \
 152 } while (0)
 153
 154
 155 #endif
 156 #endif /* __MACH64_IOCTL_H__ */