Attachment 5693 Details for Bug 6877 – RENDER support for mach64 - try 3

[patch] RENDER support for mach64 - try 3

mach64-render-3.patch (text/plain), 37.04 KB, created by George - on 2006-05-20 08:44:35 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: George -

Created: 2006-05-20 08:44:35 UTC

Size: 37.04 KB

patch

obsolete

>diff --git a/src/atimach64accel.c b/src/atimach64accel.c
>index 150fe4a..524a28c 100644
>--- a/src/atimach64accel.c
>+++ b/src/atimach64accel.c
>@@ -130,17 +130,14 @@ (
>     }
> }
> 
>-static __inline__ void TestRegisterCachingDP
>+static __inline__ void
>+TestRegisterCachingDP
> (
>     ScrnInfoPtr pScreenInfo
> )
> {
>     ATIPtr pATI = ATIPTR(pScreenInfo);
> 
>-    /*
>-     * For debugging purposes, attempt to verify that each cached register
>-     * should actually be cached.
>-     */
>     TestRegisterCaching(SRC_CNTL);
> 
>     TestRegisterCaching(HOST_CNTL);
>@@ -178,63 +175,61 @@ (
>     TestRegisterCaching(CLR_CMP_CNTL);
> }
> 
>-static __inline__ void TestRegisterCachingXV
>+static __inline__ void
>+TestRegisterCachingXV
> (
>     ScrnInfoPtr pScreenInfo
> )
> {
>     ATIPtr pATI = ATIPTR(pScreenInfo);
> 
>-    if (pATI->Block1Base)
>-    {
>-        TestRegisterCaching(OVERLAY_Y_X_START);
>-        TestRegisterCaching(OVERLAY_Y_X_END);
>+    TestRegisterCaching(OVERLAY_Y_X_START);
>+    TestRegisterCaching(OVERLAY_Y_X_END);
> 
>-        TestRegisterCaching(OVERLAY_GRAPHICS_KEY_CLR);
>-        TestRegisterCaching(OVERLAY_GRAPHICS_KEY_MSK);
>+    TestRegisterCaching(OVERLAY_GRAPHICS_KEY_CLR);
>+    TestRegisterCaching(OVERLAY_GRAPHICS_KEY_MSK);
> 
>-        TestRegisterCaching(OVERLAY_KEY_CNTL);
>+    TestRegisterCaching(OVERLAY_KEY_CNTL);
> 
>-        TestRegisterCaching(OVERLAY_SCALE_INC);
>-        TestRegisterCaching(OVERLAY_SCALE_CNTL);
>+    TestRegisterCaching(OVERLAY_SCALE_INC);
>+    TestRegisterCaching(OVERLAY_SCALE_CNTL);
> 
>-        TestRegisterCaching(SCALER_HEIGHT_WIDTH);
>+    TestRegisterCaching(SCALER_HEIGHT_WIDTH);
> 
>-        TestRegisterCaching(SCALER_TEST);
>+    TestRegisterCaching(SCALER_TEST);
> 
>-        TestRegisterCaching(VIDEO_FORMAT);
>+    TestRegisterCaching(VIDEO_FORMAT);
> 
>-        if (pATI->Chip < ATI_CHIP_264VTB)
>-        {
>-            TestRegisterCaching(BUF0_OFFSET);
>-            TestRegisterCaching(BUF0_PITCH);
>-            TestRegisterCaching(BUF1_OFFSET);
>-            TestRegisterCaching(BUF1_PITCH);
>-        }
>-        else
>-        {
>-            TestRegisterCaching(SCALER_BUF0_OFFSET);
>-            TestRegisterCaching(SCALER_BUF1_OFFSET);
>-            TestRegisterCaching(SCALER_BUF_PITCH);
>+    if (pATI->Chip < ATI_CHIP_264VTB)
>+    {
>+        TestRegisterCaching(BUF0_OFFSET);
>+        TestRegisterCaching(BUF0_PITCH);
>+        TestRegisterCaching(BUF1_OFFSET);
>+        TestRegisterCaching(BUF1_PITCH);
>+    }
>+    else
>+    {
>+        TestRegisterCaching(SCALER_BUF0_OFFSET);
>+        TestRegisterCaching(SCALER_BUF1_OFFSET);
>+        TestRegisterCaching(SCALER_BUF_PITCH);
> 
>-            TestRegisterCaching(OVERLAY_EXCLUSIVE_HORZ);
>-            TestRegisterCaching(OVERLAY_EXCLUSIVE_VERT);
>+        TestRegisterCaching(OVERLAY_EXCLUSIVE_HORZ);
>+        TestRegisterCaching(OVERLAY_EXCLUSIVE_VERT);
> 
>-            if (pATI->Chip >= ATI_CHIP_264GTPRO)
>-            {
>-                TestRegisterCaching(SCALER_COLOUR_CNTL);
>-
>-                TestRegisterCaching(SCALER_H_COEFF0);
>-                TestRegisterCaching(SCALER_H_COEFF1);
>-                TestRegisterCaching(SCALER_H_COEFF2);
>-                TestRegisterCaching(SCALER_H_COEFF3);
>-                TestRegisterCaching(SCALER_H_COEFF4);
>-
>-                TestRegisterCaching(SCALER_BUF0_OFFSET_U);
>-                TestRegisterCaching(SCALER_BUF0_OFFSET_V);
>-                TestRegisterCaching(SCALER_BUF1_OFFSET_U);
>-                TestRegisterCaching(SCALER_BUF1_OFFSET_V);
>-            }
>+        if (pATI->Chip >= ATI_CHIP_264GTPRO)
>+        {
>+            TestRegisterCaching(SCALER_COLOUR_CNTL);
>+
>+            TestRegisterCaching(SCALER_H_COEFF0);
>+            TestRegisterCaching(SCALER_H_COEFF1);
>+            TestRegisterCaching(SCALER_H_COEFF2);
>+            TestRegisterCaching(SCALER_H_COEFF3);
>+            TestRegisterCaching(SCALER_H_COEFF4);
>+
>+            TestRegisterCaching(SCALER_BUF0_OFFSET_U);
>+            TestRegisterCaching(SCALER_BUF0_OFFSET_V);
>+            TestRegisterCaching(SCALER_BUF1_OFFSET_U);
>+            TestRegisterCaching(SCALER_BUF1_OFFSET_V);
>         }
>     }
> }
>@@ -330,7 +325,10 @@ #ifdef XF86DRI_DEVEL
>             TestRegisterCaching(CLR_CMP_CLR);
>             TestRegisterCaching(CLR_CMP_MSK);
> 
>-            TestRegisterCachingXV(pScreenInfo);
>+            if (pATI->Block1Base)
>+            {
>+                TestRegisterCachingXV(pScreenInfo);
>+            }
> 	}
> 	pATI->NeedDRISync = FALSE;
> 
>@@ -343,14 +341,23 @@ #endif /* XF86DRI_DEVEL */
>       
>       if (pATI->OptionMMIOCache && pATI->OptionTestMMIOCache)
>       {
>+        /*
>+         * For debugging purposes, attempt to verify that each cached register
>+         * should actually be cached.
>+         */
>         TestRegisterCachingDP(pScreenInfo);
>-        TestRegisterCachingXV(pScreenInfo);
>+
>+        if (pATI->Block1Base)
>+        {
>+            TestRegisterCachingXV(pScreenInfo);
>+        }
>       }
>     }
> 
> #ifdef USE_EXA
>     /* EXA sets pEXA->needsSync to FALSE on its own */
> #endif
>+
> #ifdef USE_XAA
>     if (pATI->pXAAInfo)
>       pATI->pXAAInfo->NeedToSync = FALSE;
>@@ -370,21 +377,25 @@ #endif
>      * DRI uses this trick and needs updating.
>      */
> 
>-     if (pATI->Chip >= ATI_CHIP_264VTB)
>-     {
>-         /*
>-          * Flush the read-back cache (by turning on INVALIDATE_RB_CACHE),
>-          * otherwise the host might get stale data when reading through the
>-          * aperture.
>-          */
>-         outr(MEM_BUF_CNTL, pATI->NewHW.mem_buf_cntl);
>-     }
>-  
>-     if (pATI->OptionMMIOCache && pATI->OptionTestMMIOCache)
>-     {
>-         TestRegisterCachingDP(pScreenInfo);
>-         TestRegisterCachingXV(pScreenInfo);
>-     }
>+    if (pATI->Chip >= ATI_CHIP_264VTB)
>+    {
>+        /*
>+         * Flush the read-back cache (by turning on INVALIDATE_RB_CACHE),
>+         * otherwise the host might get stale data when reading through the
>+         * aperture.
>+         */
>+        outr(MEM_BUF_CNTL, pATI->NewHW.mem_buf_cntl);
>+    }
>+ 
>+    if (pATI->OptionMMIOCache && pATI->OptionTestMMIOCache)
>+    {
>+        TestRegisterCachingDP(pScreenInfo);
>+
>+        if (pATI->Block1Base)
>+        {
>+            TestRegisterCachingXV(pScreenInfo);
>+        }
>+    }
> }
> 
> #ifdef USE_XAA
>diff --git a/src/atimach64exa.c b/src/atimach64exa.c
>index 8ba3e09..72e438c 100644
>--- a/src/atimach64exa.c
>+++ b/src/atimach64exa.c
>@@ -56,6 +56,8 @@ #ifdef HAVE_CONFIG_H
> #include "config.h"
> #endif
> 
>+#include <string.h>
>+
> #include "ati.h"
> #include "atichip.h"
> #include "atidri.h"
>@@ -383,7 +385,63 @@ (
> }
> 
> static void Mach64DoneSolid(PixmapPtr pPixmap) { }
>+
>+/*
>+ * Memcpy-based UTS.
>+ */
>+static Bool
>+Mach64UploadToScreen(PixmapPtr pDst, int x, int y, int w, int h,
>+    char *src, int src_pitch)
>+{
>+    char  *dst        = pDst->devPrivate.ptr;
>+    int    dst_pitch  = exaGetPixmapPitch(pDst);
>+
>+    int bpp    = pDst->drawable.bitsPerPixel;
>+    int cpp    = (bpp + 7) / 8;
>+    int wBytes = w * cpp;
>+
>+    exaWaitSync(pDst->drawable.pScreen);
>+
>+    dst += (x * cpp) + (y * dst_pitch);
> 
>+    while (h--) {
>+        memcpy(dst, src, wBytes);
>+        src += src_pitch;
>+        dst += dst_pitch;
>+    }
>+
>+    return TRUE;
>+}
>+
>+/*
>+ * Memcpy-based DFS.
>+ */
>+static Bool
>+Mach64DownloadFromScreen(PixmapPtr pSrc, int x, int y, int w, int h,
>+    char *dst, int dst_pitch)
>+{
>+    char  *src        = pSrc->devPrivate.ptr;
>+    int    src_pitch  = exaGetPixmapPitch(pSrc);
>+
>+    int bpp    = pSrc->drawable.bitsPerPixel;
>+    int cpp    = (bpp + 7) / 8;
>+    int wBytes = w * cpp;
>+
>+    exaWaitSync(pSrc->drawable.pScreen);
>+
>+    src += (x * cpp) + (y * src_pitch);
>+
>+    while (h--) {
>+        memcpy(dst, src, wBytes);
>+        src += src_pitch;
>+        dst += dst_pitch;
>+    }
>+
>+    return TRUE;
>+}
>+
>+#include "atimach64render.c"
>+
> /* Compute log base 2 of val. */
> static __inline__ int Mach64Log2(int val)
> {
>@@ -571,8 +629,10 @@ #ifdef XF86DRI_DEVEL
>     }
> #endif /* XF86DRI_DEVEL */
> 
>-    /* FIXME: set to 64 if that helps for hostdata blits or textures */
>-    /* FIXME: must be multiple of 8 pixels; 32 is ok for 16bpp, 32bpp */
>+    /* FIXME:
>+     * Pitch must be multiple of 8 pixels, 32 is ok for 16bpp, 32bpp.
>+     * What is the requirement for textures ?
>+     */
>     pExa->pixmapOffsetAlign = 32;
>     pExa->pixmapPitchAlign = 32;
> 
>@@ -589,8 +649,7 @@ Bool ATIMach64ExaInit(ScreenPtr pScreen)
>     ExaDriverPtr pExa;
> 
>     /* FIXME: which chips support EXA ? */
>-    if (pATI->Chip < ATI_CHIP_264CT)
>-    {
>+    if (pATI->Chip < ATI_CHIP_264CT) {
>         xf86DrvMsg(pScreenInfo->scrnIndex, X_ERROR,
>             "EXA is not supported for ATI chips earlier than "
>             "the ATI Mach64.\n");
>@@ -617,6 +676,23 @@ Bool ATIMach64ExaInit(ScreenPtr pScreen)
>     pExa->PrepareCopy = Mach64PrepareCopy;
>     pExa->Copy = Mach64Copy;
>     pExa->DoneCopy = Mach64DoneCopy;
>+
>+    /* UTS/DFS hooks are beneficial for EXA, even memcpy-based */
>+    pExa->UploadToScreen = Mach64UploadToScreen;
>+    pExa->DownloadFromScreen = Mach64DownloadFromScreen;
>+
>+#if 1
>+    /* FIXME: which chips support RENDER ? */
>+    if (pATI->Chip >= ATI_CHIP_264GTPRO) {
>+	/* 3D Rage Pro does not support NPOT (non_power_of_two) textures */
>+	pExa->flags |= EXA_OFFSCREEN_ALIGN_POT;
>+
>+	pExa->CheckComposite = Mach64CheckComposite;
>+	pExa->PrepareComposite = Mach64PrepareComposite;
>+	pExa->Composite = Mach64Composite;
>+	pExa->DoneComposite = Mach64DoneComposite;
>+    }
>+#endif
> 
>     if (!exaDriverInit(pScreen, pATI->pExa)) {
> 	xfree(pATI->pExa);
>diff --git a/src/atimach64render.c b/src/atimach64render.c
>new file mode 100644
>index 0000000..280cc5a
>--- /dev/null
>+++ b/src/atimach64render.c
>@@ -0,0 +1,844 @@
>+
>+/*
>+ * Based on:
>+ *	the mach64 DRI and DRM drivers (Gareth Hughes, Leif Delgass)
>+ *	the ati/r128 kdrive driver (Eric Anholt, Anders Carlsson)
>+ *	the via xfree86 driver (Thomas Hellstrom)
>+ *
>+ * Author:
>+ * 	George Fufutos
>+ */
>+
>+/*
>+ * Interesting cases for RENDER acceleration:
>+ *
>+ * cursor  	: ARGB8888 (24x24)   Over
>+ * 		  RGB565
>+ *
>+ * glyph	: A8       (9x10)    Add
>+ * 		  A8       (420x13)
>+ * glyph set	: ARGB8888 (1x1 R)   In
>+ * 		  A8       (420x13)  Over
>+ * 		  RGB565
>+ *
>+ * shadow 	: ARGB8888 (1x1 R)   In
>+ * 		  A8       (670x362) Over
>+ * 		  RGB565
>+ * translucent	: RGB565   (652x344) In
>+ * 		  A8       (1x1 R)   Over
>+ * 		  RGB565
>+ *
>+ * In all interesting cases: mask is "A8" and one of src/mask is "1x1 R".
>+ *
>+ * According to atiregs.h, SCALE_3D_CNTL (and TEX_0_OFF) appear in GT, thus 
>+ * chips as old as GT (but not VT, VTB) should be capable of RENDER accelera-
>+ * tion, albeit with two passes when compositing with a mask.
>+ *
>+ * None of the 8bpp mach64 formats expands the 8bit value to the alpha channel 
>+ * during texture mapping, RGB8 appears to expand to (I,I,I,0). This makes 
>+ * GTPRO multitexturing unsuitable for emulating the IN operation. Moreover, 
>+ * it seems that GT/GTPRO has a muxltiplexer instead of a blender for computing 
>+ * the final alpha channel which forbids destinations with an alpha channel and 
>+ * makes it impossible to convert "ARGB8888 IN A8" to "A8 IN_REV ARGB8888" for
>+ * two-pass compositing.
>+ *
>+ * A texture unit combines the fragment color (VERTEX_?_ARGB) coming in from 
>+ * triangle rasterization with the texel from the texture according to the
>+ * texture environment (TEX_LIGHT_FCN_). "1x1 R" textures may come in as frag-
>+ * ment colors, eliminating the need for multitexturing in the interesting
>+ * cases (probably, this is the via optimization).
>+ */
>+
>+#include <string.h>
>+#include <stdio.h>
>+
>+/*
>+ * Helper functions copied from exa and via.
>+ */
>+
>+static void
>+Mach64ExaCompositePictDesc(PicturePtr pict, char *string, int n)
>+{
>+    char format[20];
>+    char size[20];
>+
>+    if (!pict) {
>+	snprintf(string, n, "None");
>+	return;
>+    }
>+
>+    switch (pict->format) {
>+    case PICT_x8r8g8b8:
>+	snprintf(format, 20, "RGB8888 ");
>+	break;
>+    case PICT_x8b8g8r8:
>+	snprintf(format, 20, "BGR8888 ");
>+	break;
>+    case PICT_a8r8g8b8:
>+	snprintf(format, 20, "ARGB8888");
>+	break;
>+    case PICT_a8b8g8r8:
>+	snprintf(format, 20, "ABGR8888");
>+	break;
>+    case PICT_r5g6b5:
>+	snprintf(format, 20, "RGB565  ");
>+	break;
>+    case PICT_x1r5g5b5:
>+	snprintf(format, 20, "RGB555  ");
>+	break;
>+    case PICT_a8:
>+	snprintf(format, 20, "A8      ");
>+	break;
>+    case PICT_a1:
>+	snprintf(format, 20, "A1      ");
>+	break;
>+    default:
>+	snprintf(format, 20, "0x%x", (int)pict->format);
>+	break;
>+    }
>+
>+    snprintf(size, 20, "%dx%d%s%s",
>+	pict->pDrawable->width,
>+	pict->pDrawable->height,
>+	pict->repeat ? " R" : "",
>+	pict->componentAlpha ? " C" : ""
>+    );
>+
>+    snprintf(string, n, "%-10p: fmt %s (%s)", (void *)pict->pDrawable, format, size);
>+}
>+
>+static void
>+Mach64ExaPrintComposite(CARD8 op,
>+    PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, char *string)
>+{
>+    char sop[20];
>+    char srcdesc[40], maskdesc[40], dstdesc[40];
>+
>+    switch (op) {
>+    case PictOpSrc:
>+	sprintf(sop, "Src");
>+	break;
>+    case PictOpOver:
>+	sprintf(sop, "Over");
>+	break;
>+    case PictOpInReverse:
>+	sprintf(sop, "InR");
>+	break;
>+    case PictOpOutReverse:
>+	sprintf(sop, "OutR");
>+	break;
>+    case PictOpAdd:
>+	sprintf(sop, "Add");
>+	break;
>+    default:
>+	sprintf(sop, "0x%x", (int)op);
>+	break;
>+    }
>+
>+    Mach64ExaCompositePictDesc(pSrc, srcdesc, 40);
>+    Mach64ExaCompositePictDesc(pMask, maskdesc, 40);
>+    Mach64ExaCompositePictDesc(pDst, dstdesc, 40);
>+
>+    sprintf(string, "op %s, \n"
>+	"                src  %s\n"
>+	"                mask %s\n"
>+	"                dst  %s\n", sop, srcdesc, maskdesc, dstdesc);
>+}
>+
>+static __inline__ CARD32
>+viaBitExpandHelper(CARD32 component, CARD32 bits)
>+{
>+    CARD32 tmp, mask;
>+
>+    mask = (1 << (8 - bits)) - 1;
>+    tmp = component << (8 - bits);
>+    return ((component & 1) ? tmp | mask : tmp);
>+}
>+
>+static __inline__ void
>+Mach64PixelARGB(PixmapPtr pPixmap, CARD32 format, CARD32 *argb)
>+{
>+    CARD32 pixel;
>+    CARD8  comp;
>+    int    bits, shift;
>+
>+    /* exaGetPixmapFirstPixel() */
>+
>+    /* Ensure that texture drawing has completed. */
>+    exaWaitSync(pPixmap->drawable.pScreen);
>+
>+    switch (pPixmap->drawable.bitsPerPixel) {
>+    case 32:
>+	pixel = *(CARD32 *)(pPixmap->devPrivate.ptr);
>+	break;
>+    case 16:
>+	pixel = *(CARD16 *)(pPixmap->devPrivate.ptr);
>+	break;
>+    default:
>+	pixel = *(CARD8 *)(pPixmap->devPrivate.ptr);
>+	break;
>+    }
>+
>+    /* exaGetRGBAFromPixel()/viaPixelARGB8888() */
>+
>+    switch (PICT_FORMAT_TYPE(format)) {
>+    case PICT_TYPE_A:
>+	shift = 0;
>+	bits = PICT_FORMAT_A(format);
>+	comp = (pixel >> shift) & ((1 << bits) - 1);
>+	comp = viaBitExpandHelper(comp, bits);
>+	*argb = comp << 24;
>+	break;
>+    case PICT_TYPE_ARGB:
>+	shift = 0;
>+	bits = PICT_FORMAT_B(format);
>+	comp = (pixel >> shift) & ((1 << bits) - 1);
>+	comp = viaBitExpandHelper(comp, bits);
>+	*argb = comp;
>+
>+	shift += bits;
>+	bits = PICT_FORMAT_G(format);
>+	comp = (pixel >> shift) & ((1 << bits) - 1);
>+	comp = viaBitExpandHelper(comp, bits);
>+	*argb |= comp << 8;
>+
>+	shift += bits;
>+	bits = PICT_FORMAT_R(format);
>+	comp = (pixel >> shift) & ((1 << bits) - 1);
>+	comp = viaBitExpandHelper(comp, bits);
>+	*argb |= comp << 16;
>+
>+	shift += bits;
>+	bits = PICT_FORMAT_A(format);
>+	if (bits) {
>+	    comp = (pixel >> shift) & ((1 << bits) - 1);
>+	    comp = viaBitExpandHelper(comp, bits);
>+	} else {
>+	    comp = 0xff;
>+	}
>+	*argb |= comp << 24;
>+	break;
>+    case PICT_TYPE_ABGR:
>+	break;
>+    default:
>+	break;
>+    }
>+}
>+
>+/*
>+ * RENDER acceleration for mach64
>+ */
>+
>+/* FIXME: move to pATI. */
>+typedef struct {
>+    CARD32	dp_mix;
>+    CARD32	dp_src;
>+    CARD32	dp_write_mask;
>+    CARD32	dp_pix_width;
>+    CARD32	dst_pitch_offset;
>+
>+    CARD32	scale_3d_cntl;
>+    CARD32	tex_cntl;
>+    CARD32	tex_size_pitch;
>+    CARD32	tex_offset;
>+
>+    int		tex_width;	/* src/mask texture width (pixels) */
>+    int		tex_height;	/* src/mask texture height (pixels) */
>+
>+    Bool	frag_src;	/* solid src uses fragment color */
>+    Bool	frag_mask;	/* solid mask uses fragment color */
>+    CARD32	frag_color;	/* solid src/mask color */
>+
>+    Bool	color_alpha;	/* the alpha value is contained in the color
>+				   channels instead of the alpha channel */
>+} Mach64TexState;
>+
>+static Mach64TexState _m3d;
>+static Mach64TexState *m3d = &_m3d;
>+
>+typedef struct {
>+    Bool supported;
>+    CARD32 scale_3d_cntl;
>+} Mach64BlendOp;
>+
>+static Mach64BlendOp Mach64BlendOps[] = {
>+    /* Clear */
>+    {1, MACH64_ALPHA_BLEND_SRC_ZERO        | MACH64_ALPHA_BLEND_DST_ZERO},
>+    /* Src */
>+    {1, MACH64_ALPHA_BLEND_SRC_ONE         | MACH64_ALPHA_BLEND_DST_ZERO},
>+    /* Dst */
>+    {1, MACH64_ALPHA_BLEND_SRC_ZERO        | MACH64_ALPHA_BLEND_DST_ONE},
>+    /* Over */
>+    {1, MACH64_ALPHA_BLEND_SRC_ONE         | MACH64_ALPHA_BLEND_DST_INVSRCALPHA},
>+    /* OverReverse */
>+    {1, MACH64_ALPHA_BLEND_SRC_INVDSTALPHA | MACH64_ALPHA_BLEND_DST_ONE},
>+    /* In */
>+    {1, MACH64_ALPHA_BLEND_SRC_DSTALPHA    | MACH64_ALPHA_BLEND_DST_ZERO},
>+    /* InReverse */
>+    {1, MACH64_ALPHA_BLEND_SRC_ZERO        | MACH64_ALPHA_BLEND_DST_SRCALPHA},
>+    /* Out */
>+    {1, MACH64_ALPHA_BLEND_SRC_INVDSTALPHA | MACH64_ALPHA_BLEND_DST_ZERO},
>+    /* OutReverse */
>+    {1, MACH64_ALPHA_BLEND_SRC_ZERO        | MACH64_ALPHA_BLEND_DST_INVSRCALPHA},
>+    /* Atop */
>+    {0, MACH64_ALPHA_BLEND_SRC_DSTALPHA    | MACH64_ALPHA_BLEND_DST_INVSRCALPHA},
>+    /* AtopReverse */
>+    {0, MACH64_ALPHA_BLEND_SRC_INVDSTALPHA | MACH64_ALPHA_BLEND_DST_SRCALPHA},
>+    /* Xor */
>+    {1, MACH64_ALPHA_BLEND_SRC_INVDSTALPHA | MACH64_ALPHA_BLEND_DST_INVSRCALPHA},
>+    /* Add */
>+    {1, MACH64_ALPHA_BLEND_SRC_ONE         | MACH64_ALPHA_BLEND_DST_ONE}
>+};
>+
>+#define MACH64_NR_BLEND_OPS \
>+    (sizeof(Mach64BlendOps) / sizeof(Mach64BlendOps[0]))
>+
>+typedef struct {
>+    CARD32 pictFormat;
>+    CARD32 dstFormat;
>+    CARD32 texFormat;
>+} Mach64TexFormat;
>+
>+static Mach64TexFormat Mach64TexFormats[] = {
>+    {PICT_a8r8g8b8, 0,                        MACH64_DATATYPE_ARGB8888},
>+    {PICT_x8r8g8b8, MACH64_DATATYPE_ARGB8888, MACH64_DATATYPE_ARGB8888},
>+    {PICT_a1r5g5b5, 0,                        MACH64_DATATYPE_ARGB1555},
>+    {PICT_x1r5g5b5, MACH64_DATATYPE_ARGB1555, MACH64_DATATYPE_ARGB1555},
>+    {PICT_r5g6b5,   MACH64_DATATYPE_RGB565,   MACH64_DATATYPE_RGB565  },
>+    {PICT_a8,       MACH64_DATATYPE_RGB8,     MACH64_DATATYPE_RGB8    }
>+};
>+
>+#define MACH64_NR_TEX_FORMATS \
>+    (sizeof(Mach64TexFormats) / sizeof(Mach64TexFormats[0]))
>+
>+static Bool
>+Mach64GetOrder(int val, int *shift)
>+{
>+    *shift = 0;
>+
>+    while (val > (1 << *shift))
>+        (*shift)++;
>+
>+    return (val == (1 << *shift));
>+}
>+
>+static Bool
>+Mach64CheckTexture(PicturePtr pPict)
>+{
>+    int w = pPict->pDrawable->width;
>+    int h = pPict->pDrawable->height;
>+    int l2w, l2h, level, i;
>+
>+    for (i = 0; i < MACH64_NR_TEX_FORMATS; i++) {
>+	if (Mach64TexFormats[i].pictFormat == pPict->format)
>+	    break;
>+    }
>+
>+    if (i == MACH64_NR_TEX_FORMATS)
>+	MACH64_FALLBACK(("Unsupported picture format 0x%x\n",
>+			(int)pPict->format));
>+
>+    /* l2w equals l2p (pitch) for all interesting cases (w >= 32) */
>+    Mach64GetOrder(w, &l2w);
>+    Mach64GetOrder(h, &l2h);
>+
>+    level = (l2w > l2h) ? l2w : l2h;
>+
>+    if (level > 10)
>+	MACH64_FALLBACK(("Picture w/h too large (%dx%d)\n", w, h));
>+
>+    return TRUE;
>+}
>+
>+Bool
>+Mach64CheckComposite
>+(
>+    int        op,
>+    PicturePtr pSrcPicture,
>+    PicturePtr pMaskPicture,
>+    PicturePtr pDstPicture
>+)
>+{
>+    Bool mask_solid, src_solid, op_comp;
>+
>+    if (op >= MACH64_NR_BLEND_OPS || !Mach64BlendOps[op].supported)
>+	return FALSE;
>+
>+    if (!Mach64CheckTexture(pSrcPicture))
>+	return FALSE;
>+
>+    if (pMaskPicture && !Mach64CheckTexture(pMaskPicture))
>+	return FALSE;
>+
>+    if (!Mach64CheckTexture(pDstPicture))
>+	return FALSE;
>+
>+    /* Check combinations of src/dst formats. */
>+
>+    if (pDstPicture->format == PICT_a8) {
>+	if (pMaskPicture || pSrcPicture->format != PICT_a8 || op != PictOpAdd)
>+	    MACH64_FALLBACK(("A8 dst with mask or non-A8 src.\n"));
>+    }
>+
>+    if (pDstPicture->format != PICT_a8) {
>+	if (pSrcPicture->format == PICT_a8)
>+	    MACH64_FALLBACK(("A8 src with non-A8 dst.\n"));
>+
>+	if (PICT_FORMAT_A(pDstPicture->format))
>+	    MACH64_FALLBACK(("Destination with alpha channel.\n"));
>+    }
>+
>+    /* Check that one of src/mask can come in as the fragment color. */
>+
>+    mask_solid = pMaskPicture &&
>+		 pMaskPicture->pDrawable->width == 1 &&
>+		 pMaskPicture->pDrawable->height == 1 &&
>+		 pMaskPicture->repeat;
>+
>+    src_solid = pSrcPicture &&
>+		pSrcPicture->pDrawable->width == 1 &&
>+		pSrcPicture->pDrawable->height == 1 &&
>+		pSrcPicture->repeat;
>+
>+    op_comp = op == PictOpAdd ||
>+	      op == PictOpInReverse ||
>+	      op == PictOpOutReverse;
>+
>+    if (mask_solid && src_solid)
>+	MACH64_FALLBACK(("Bad one-pixel IN composite operation.\n"));
>+
>+    if (pMaskPicture && !mask_solid && !src_solid)
>+	MACH64_FALLBACK(("Multitexturing required.\n"));
>+
>+    if (pMaskPicture && !mask_solid && !op_comp)
>+	MACH64_FALLBACK(("Operation unsupported with non-solid masks.\n"));
>+
>+    if (pMaskPicture && !pMaskPicture->componentAlpha) {
>+	if (pMaskPicture->format != PICT_a8)
>+	    MACH64_FALLBACK(("Non-A8 mask.\n"));
>+    }
>+
>+    /* FIXME:
>+     * Component-alpha passes rendercheck but I cannot actually test it due to
>+     * lack of an LCD display.
>+     */
>+    if (pMaskPicture && pMaskPicture->componentAlpha) {
>+	if (pMaskPicture->format != PICT_a8r8g8b8 || !src_solid || !op_comp)
>+	    MACH64_FALLBACK(("Component-alpha mask.\n"));
>+    }
>+
>+    /* Transforms */
>+
>+    if (pSrcPicture->transform)
>+	MACH64_FALLBACK(("transform\n"));
>+
>+    if (pMaskPicture && pMaskPicture->transform)
>+	MACH64_FALLBACK(("transform\n"));
>+
>+    return TRUE;
>+}
>+
>+static Bool
>+Mach64PrepareMask
>+(
>+    int        op,
>+    PicturePtr pSrcPicture,
>+    PicturePtr pMaskPicture,
>+    PixmapPtr  pSrc,
>+    PixmapPtr  pMask
>+)
>+{
>+    Bool mask_solid, src_solid;
>+    CARD32 argb = 0;
>+
>+    m3d->frag_src = FALSE;
>+    m3d->frag_mask = FALSE;
>+    m3d->frag_color = 0xffffffff;
>+
>+    m3d->color_alpha = FALSE;
>+
>+    if (!pMaskPicture)
>+	return TRUE;
>+
>+    mask_solid = pMaskPicture &&
>+		 pMaskPicture->pDrawable->width == 1 &&
>+		 pMaskPicture->pDrawable->height == 1 &&
>+		 pMaskPicture->repeat;
>+
>+    src_solid = pSrcPicture &&
>+		pSrcPicture->pDrawable->width == 1 &&
>+		pSrcPicture->pDrawable->height == 1 &&
>+		pSrcPicture->repeat;
>+
>+    if (mask_solid) {
>+	Mach64PixelARGB(pMask, pMaskPicture->format, &argb);
>+	argb >>= 24;
>+	argb &= 0xff;
>+
>+	m3d->frag_mask = TRUE;
>+	m3d->frag_color = (argb << 24) | (argb << 16) | (argb << 8) | argb;
>+	return TRUE;
>+    }
>+
>+    if (src_solid) {
>+	/* We can only handle cases where either the src color (e.g. ADD) or
>+	 * the src alpha (e.g. IN_REV, OUT_REV) is used but not both. 
>+	 *
>+	 * (ARGB8888 IN A8) OVER RGB565 is implemented as:
>+	 * (ARGB8888 IN A8) ADD ((ARGB8888 IN A8) OUT_REV RGB565).
>+	 */
>+	if (op == PictOpInReverse || op == PictOpOutReverse) {
>+	    Mach64PixelARGB(pSrc, pSrcPicture->format, &argb);
>+	    argb >>= 24;
>+	    argb &= 0xff;
>+
>+	    m3d->frag_src = TRUE;
>+	    m3d->frag_color = (argb << 24) | (argb << 16) | (argb << 8) | argb;
>+	    m3d->color_alpha = TRUE;
>+	    return TRUE;
>+	}
>+
>+	if (op == PictOpAdd) {
>+	    Mach64PixelARGB(pSrc, pSrcPicture->format, &argb);
>+
>+	    m3d->frag_src = TRUE;
>+	    m3d->frag_color = argb;
>+	    return TRUE;
>+	}
>+    }
>+
>+    return FALSE;
>+}
>+
>+static void __inline__ Mach64BlendCntl(int op)
>+{
>+    m3d->scale_3d_cntl |= MACH64_SCALE_PIX_EXPAND_DYNAMIC_RANGE |
>+			  MACH64_SCALE_DITHER_2D_TABLE |
>+			  MACH64_DITHER_INIT_RESET;
>+
>+    m3d->scale_3d_cntl |= Mach64BlendOps[op].scale_3d_cntl;
>+
>+    if (m3d->color_alpha) {
>+	/* A8 uses RGB8 which expands to (I,I,I,0). Thus, we use the color 
>+	 * channels instead of the alpha channel as the alpha factor. We also
>+	 * use the color channels for ARGB8888 masks with component-alpha.
>+	 */
>+	CARD32 Ad = m3d->scale_3d_cntl & MACH64_ALPHA_BLEND_DST_MASK;
>+
>+	/* InReverse */
>+	if (Ad == MACH64_ALPHA_BLEND_DST_SRCALPHA) {
>+	    m3d->scale_3d_cntl &= ~MACH64_ALPHA_BLEND_DST_MASK;
>+	    m3d->scale_3d_cntl |=  MACH64_ALPHA_BLEND_DST_SRCCOLOR;
>+	}
>+
>+	/* OutReverse */
>+	if (Ad == MACH64_ALPHA_BLEND_DST_INVSRCALPHA) {
>+	    m3d->scale_3d_cntl &= ~MACH64_ALPHA_BLEND_DST_MASK;
>+	    m3d->scale_3d_cntl |=  MACH64_ALPHA_BLEND_DST_INVSRCCOLOR;
>+	}
>+    }
>+
>+    /* Can't color mask and blend at the same time */
>+    m3d->dp_write_mask = 0xffffffff;
>+
>+    /* Can't fog and blend at the same time */
>+    m3d->scale_3d_cntl |= MACH64_ALPHA_FOG_EN_ALPHA;
>+
>+    /* Enable texture mapping mode */
>+    m3d->scale_3d_cntl |= MACH64_SCALE_3D_FCN_TEXTURE;
>+    m3d->scale_3d_cntl |= MACH64_MIP_MAP_DISABLE;
>+
>+    /* Setup the texture environment */
>+    m3d->scale_3d_cntl |= MACH64_TEX_LIGHT_FCN_MODULATE;
>+
>+    /* Initialize texture unit */
>+    m3d->tex_cntl |= MACH64_TEX_ST_DIRECT | 
>+		     MACH64_TEX_SRC_LOCAL |
>+		     MACH64_TEX_UNCOMPRESSED |
>+		     MACH64_TEX_CACHE_FLUSH |
>+		     MACH64_TEX_CACHE_SIZE_4K;
>+}
>+
>+static Bool
>+Mach64PrepareTexture(PicturePtr pPict, PixmapPtr pPix)
>+{
>+    ScrnInfoPtr pScreenInfo = xf86Screens[pPix->drawable.pScreen->myNum];
>+    ATIPtr pATI = ATIPTR(pScreenInfo);
>+
>+    CARD32 texFormat;
>+
>+    int w = pPict->pDrawable->width;
>+    int h = pPict->pDrawable->height;
>+    int l2w, l2h, l2p, level, pitch, pitchAlign, cpp, i;
>+
>+    /* Prepare picture format */
>+    for (i = 0; i < MACH64_NR_TEX_FORMATS; i++) {
>+	if (Mach64TexFormats[i].pictFormat == pPict->format)
>+	    break;
>+    }
>+    texFormat = Mach64TexFormats[i].texFormat;
>+
>+    /* Prepare picture size */
>+    cpp = PICT_FORMAT_BPP(pPict->format) / 8;
>+    pitch = exaGetPixmapPitch(pPix) / cpp;
>+    pitchAlign = pATI->pExa->pixmapPitchAlign;
>+
>+    Mach64GetOrder(w, &l2w);
>+    Mach64GetOrder(h, &l2h);
>+    Mach64GetOrder(pitch, &l2p);
>+
>+    if ((pitch & (pitch - 1)) != 0)
>+	MACH64_FALLBACK(("Error: NPOT pitch 0x%x unsupported\n", pitch));
>+
>+    if (w >= pitchAlign && l2w != l2p)
>+	MACH64_FALLBACK(("Error: width 0x%x != pitch 0x%x\n", w, pitch));
>+
>+    if (pPict->repeat && w == 1 && h == 1)
>+	l2p = 0;
>+    else if (pPict->repeat)
>+	MACH64_FALLBACK(("Repeat not supported for w,h != 1,1\n"));
>+
>+    l2w = l2p;
>+
>+    level = (l2w > l2h) ? l2w : l2h;
>+
>+    m3d->tex_width = (1 << l2w);
>+    m3d->tex_height = (1 << l2h);
>+
>+    /* Update hw state */
>+    m3d->dp_pix_width |= SetBits(texFormat, DP_SCALE_PIX_WIDTH);
>+
>+    m3d->tex_size_pitch = (l2w   << 0) |
>+			  (level << 4) |
>+			  (l2h   << 8);
>+
>+    m3d->tex_offset = exaGetPixmapOffset(pPix);
>+
>+    if (PICT_FORMAT_A(pPict->format))
>+	m3d->scale_3d_cntl |= MACH64_TEX_MAP_AEN;
>+    
>+    switch (pPict->filter) {
>+    case PictFilterNearest:
>+	m3d->scale_3d_cntl |= MACH64_TEX_BLEND_FCN_NEAREST;
>+	break;
>+    case PictFilterBilinear:
>+	m3d->scale_3d_cntl |= MACH64_TEX_BLEND_FCN_LINEAR;
>+	m3d->scale_3d_cntl |= MACH64_BILINEAR_TEX_EN;
>+	break;
>+    default:
>+	MACH64_FALLBACK(("Bad filter 0x%x\n", pPict->filter));
>+    }
>+
>+    return TRUE;
>+}
>+
>+Bool
>+Mach64PrepareComposite
>+(
>+    int        op,
>+    PicturePtr pSrcPicture,
>+    PicturePtr pMaskPicture,
>+    PicturePtr pDstPicture,
>+    PixmapPtr  pSrc,
>+    PixmapPtr  pMask,
>+    PixmapPtr  pDst
>+)
>+{
>+    ScrnInfoPtr pScreenInfo = xf86Screens[pDst->drawable.pScreen->myNum];
>+    ATIPtr pATI = ATIPTR(pScreenInfo);
>+
>+    CARD32 dstFormat;
>+    int offset, i;
>+
>+#if 0
>+    char compdesc[240];
>+    int w = pSrcPicture->pDrawable->width;
>+    int h = pSrcPicture->pDrawable->height;
>+#endif
>+
>+    ATIDRISync(pScreenInfo);
>+
>+    m3d->dp_mix = SetBits(MIX_SRC, DP_BKGD_MIX) |
>+		  SetBits(MIX_SRC, DP_FRGD_MIX);
>+
>+    m3d->dp_src = SetBits(SRC_SCALER_3D, DP_BKGD_SRC) |
>+		  SetBits(SRC_SCALER_3D, DP_FRGD_SRC) |
>+		  DP_MONO_SRC_ALLONES;
>+
>+    Mach64GetPixmapOffsetPitch(pDst, &m3d->dst_pitch_offset);
>+
>+    m3d->scale_3d_cntl = 0;
>+    m3d->tex_cntl = 0;
>+
>+    if (!Mach64PrepareMask(op, pSrcPicture, pMaskPicture, pSrc, pMask))
>+	return FALSE;
>+
>+#if 0
>+    /* BUGZILLA: EXA/smart with unaccelerated composite for glyphs.
>+     *
>+     * Returning FALSE in Prepare (later) instead of Check (earlier) results 
>+     * in uploads of glyph pixmaps only and performance similar to exa/greedy. 
>+     * Otherwise, it moves the firefox pixmap in and out of offscreen memory.
>+     */
>+    if (pMaskPicture && !m3d->frag_mask)
>+	return FALSE;
>+#endif
>+
>+    Mach64BlendCntl(op);
>+
>+    for (i = 0; i < MACH64_NR_TEX_FORMATS; i++) {
>+	if (Mach64TexFormats[i].pictFormat == pDstPicture->format)
>+	    break;
>+    }
>+    dstFormat = Mach64TexFormats[i].dstFormat;
>+
>+    m3d->dp_pix_width = SetBits(dstFormat, DP_DST_PIX_WIDTH) |
>+			SetBits(dstFormat, DP_SRC_PIX_WIDTH) |
>+			SetBits(dstFormat, DP_HOST_PIX_WIDTH);
>+
>+    if (!m3d->frag_src) {
>+	if (!Mach64PrepareTexture(pSrcPicture, pSrc))
>+	    return FALSE;
>+    }
>+
>+    if (pMaskPicture && !m3d->frag_mask) {
>+	if (!Mach64PrepareTexture(pMaskPicture, pMask))
>+	    return FALSE;
>+    }
>+
>+    /* Extract texture level from TEX_SIZE_PITCH and shift appropriately for
>+     * addition to TEX_0_OFF.
>+     */
>+    offset = (m3d->tex_size_pitch & 0xf0) >> 2;
>+
>+    /* Emit hw state */
>+    ATIMach64WaitForFIFO(pATI, 12);
>+    outf(DP_SRC, m3d->dp_src);
>+    outf(DP_MIX, m3d->dp_mix);
>+
>+    outf(CLR_CMP_CNTL, CLR_CMP_FN_FALSE);
>+    outf(DST_CNTL, DST_X_DIR | DST_Y_DIR);
>+    outf(DST_OFF_PITCH, m3d->dst_pitch_offset);
>+
>+    outf(SCALE_3D_CNTL, m3d->scale_3d_cntl);
>+    outf(DP_WRITE_MASK, m3d->dp_write_mask);
>+    outf(DP_PIX_WIDTH, m3d->dp_pix_width);
>+
>+    outf(ALPHA_TST_CNTL, 0);
>+    outf(SETUP_CNTL, 0);
>+
>+    outf(TEX_SIZE_PITCH, m3d->tex_size_pitch);
>+    outf(TEX_CNTL, m3d->tex_cntl);
>+    outf(TEX_0_OFF + offset, m3d->tex_offset);
>+
>+#if 0
>+    if (w != 24 && h != 24) { /* cursor */
>+    Mach64ExaPrintComposite(op, pSrcPicture, pMaskPicture, pDstPicture, compdesc);
>+    ErrorF("Prep : %s", compdesc);
>+    }
>+#endif
>+
>+    return TRUE;
>+}
>+
>+typedef struct {
>+    float s0;		/* normalized texture coords */
>+    float t0;
>+    float x;		/* quarter-pixels */
>+    float y;
>+    CARD32 argb;	/* fragment color */
>+} Mach64Vertex;
>+
>+#define VTX_SET(_v, _col, _dstX, _dstY, _srcX, _srcY)		\
>+do {								\
>+    _v.s0 = ((float)(_srcX) + 0.0) / m3d->tex_width;		\
>+    _v.t0 = ((float)(_srcY) + 0.0) / m3d->tex_height;		\
>+    _v.x  = ((float)(_dstX) * 4.0 + 0.0);			\
>+    _v.y  = ((float)(_dstY) * 4.0 + 0.0);			\
>+    _v.argb = _col;						\
>+} while (0)
>+
>+#define FVAL(_fval) (*(CARD32 *)&(_fval))
>+
>+#define VTX_OUT(_v, n)						\
>+do {								\
>+    float w = 1.0;						\
>+    CARD32 z = 0xffff << 15;					\
>+    CARD32 x_y = ((CARD16)_v.x << 16) |				\
>+		 ((CARD16)_v.y & 0xffff);			\
>+								\
>+    ATIMach64WaitForFIFO(pATI, 6);				\
>+    outf(VERTEX_##n##_S, FVAL(_v.s0));				\
>+    outf(VERTEX_##n##_T, FVAL(_v.t0));				\
>+    outf(VERTEX_##n##_W, FVAL(w));   				\
>+								\
>+    outf(VERTEX_##n##_Z, z);					\
>+    outf(VERTEX_##n##_ARGB, _v.argb);				\
>+    outf(VERTEX_##n##_X_Y, x_y);				\
>+} while (0)
>+
>+void
>+Mach64Composite
>+(
>+    PixmapPtr pDst,
>+    int       srcX,
>+    int       srcY,
>+    int       maskX,
>+    int       maskY,
>+    int       dstX,
>+    int       dstY,
>+    int       w,
>+    int       h
>+)
>+{
>+    ScrnInfoPtr pScreenInfo = xf86Screens[pDst->drawable.pScreen->myNum];
>+    ATIPtr pATI = ATIPTR(pScreenInfo);
>+
>+    Mach64Vertex v0, v1, v2, v3;
>+    float ooa;
>+    CARD32 col;
>+
>+    ATIDRISync(pScreenInfo);
>+
>+    /* Disable clipping if it gets in the way */
>+    ATIMach64ValidateClip(pATI, dstX, dstX + w - 1, dstY, dstY + h - 1);
>+
>+    /* Handle solid textures which come in as fragment color */
>+    col = m3d->frag_color;
>+    if (m3d->frag_src) {
>+	srcX = maskX;
>+	srcY = maskY;
>+    }
>+
>+    /* Create vertices in clock-wise order */
>+    VTX_SET(v0, col, dstX,     dstY,     srcX,     srcY);
>+    VTX_SET(v1, col, dstX + w, dstY,     srcX + w, srcY);
>+    VTX_SET(v2, col, dstX + w, dstY + h, srcX + w, srcY + h);
>+    VTX_SET(v3, col, dstX,     dstY + h, srcX,     srcY + h);
>+
>+    /* Setup upper triangle (v0, v1, v3) */
>+    VTX_OUT(v0, 1);
>+    VTX_OUT(v1, 2);
>+    VTX_OUT(v3, 3);
>+
>+    ooa = 1.0 / (w * h);
>+    outf(ONE_OVER_AREA, FVAL(ooa));
>+
>+    /* Setup lower triangle (v2, v1, v3) */
>+    VTX_OUT(v2, 1);
>+
>+    ooa = -ooa;
>+    outf(ONE_OVER_AREA, FVAL(ooa));
>+}
>+
>+void
>+Mach64DoneComposite(PixmapPtr pDst)
>+{
>+    ScrnInfoPtr pScreenInfo = xf86Screens[pDst->drawable.pScreen->myNum];
>+    ATIPtr pATI = ATIPTR(pScreenInfo);
>+
>+    ATIDRISync(pScreenInfo);
>+
>+    outf(ALPHA_TST_CNTL, 0);
>+    outf(SCALE_3D_CNTL, 0);
>+}
>diff --git a/src/atiregs.h b/src/atiregs.h
>index 102347b..03df3f6 100644
>--- a/src/atiregs.h
>+++ b/src/atiregs.h
>@@ -2751,4 +2751,127 @@ #define OVERLAY_MIX_EQUAL		0x05u
> /*	?				0x06u */
> /*	?				0x07u */
> 
>+/* 3D Engine for render acceleration (from Mach64 DRI driver) */
>+
>+/* SCALE_3D_CNTL */
>+#define MACH64_SCALE_PIX_EXPAND_ZERO_EXTEND	(0 << 0)
>+#define MACH64_SCALE_PIX_EXPAND_DYNAMIC_RANGE	(1 << 0)
>+#define MACH64_SCALE_DITHER_ERROR_DIFFUSE	(0 << 1)
>+#define MACH64_SCALE_DITHER_2D_TABLE		(1 << 1)
>+#define MACH64_DITHER_EN			(1 << 2)
>+#define MACH64_DITHER_INIT_CURRENT		(O << 3)
>+#define MACH64_DITHER_INIT_RESET		(1 << 3)
>+#define MACH64_ROUND_EN				(1 << 4)
>+
>+#define MACH64_TEX_CACHE_DIS			(1 << 5)
>+
>+#define MACH64_SCALE_3D_FCN_MASK		(3 << 6)
>+#define MACH64_SCALE_3D_FCN_NOP			(0 << 6)
>+#define MACH64_SCALE_3D_FCN_SCALE		(1 << 6)
>+#define MACH64_SCALE_3D_FCN_TEXTURE		(2 << 6)
>+#define MACH64_SCALE_3D_FCN_SHADE		(3 << 6)
>+#define MACH64_TEXTURE_DISABLE			(1 << 6)
>+
>+#define MACH64_EDGE_ANTI_ALIAS			(1 << 8)
>+#define MACH64_TEX_CACHE_SPLIT			(1 << 9)
>+#define MACH64_APPLE_YUV_MODE			(1 << 10)
>+
>+#define MACH64_ALPHA_FOG_EN_MASK		(3 << 11)
>+#define MACH64_ALPHA_FOG_DIS			(0 << 11)
>+#define MACH64_ALPHA_FOG_EN_ALPHA		(1 << 11)
>+#define MACH64_ALPHA_FOG_EN_FOG			(2 << 11)
>+
>+#define MACH64_ALPHA_BLEND_SAT			(1 << 13)
>+#define MACH64_RED_DITHER_MAX			(1 << 14)
>+#define MACH64_SIGNED_DST_CLAMP			(1 << 15)
>+
>+#define MACH64_ALPHA_BLEND_SRC_MASK		(7 << 16)
>+#define MACH64_ALPHA_BLEND_SRC_ZERO		(0 << 16)
>+#define MACH64_ALPHA_BLEND_SRC_ONE		(1 << 16)
>+#define MACH64_ALPHA_BLEND_SRC_DSTCOLOR		(2 << 16)
>+#define MACH64_ALPHA_BLEND_SRC_INVDSTCOLOR	(3 << 16)
>+#define MACH64_ALPHA_BLEND_SRC_SRCALPHA		(4 << 16)
>+#define MACH64_ALPHA_BLEND_SRC_INVSRCALPHA	(5 << 16)
>+#define MACH64_ALPHA_BLEND_SRC_DSTALPHA		(6 << 16)
>+#define MACH64_ALPHA_BLEND_SRC_INVDSTALPHA	(7 << 16)
>+#define MACH64_ALPHA_BLEND_DST_MASK		(7 << 19)
>+#define MACH64_ALPHA_BLEND_DST_ZERO		(0 << 19)
>+#define MACH64_ALPHA_BLEND_DST_ONE		(1 << 19)
>+#define MACH64_ALPHA_BLEND_DST_SRCCOLOR		(2 << 19)
>+#define MACH64_ALPHA_BLEND_DST_INVSRCCOLOR	(3 << 19)
>+#define MACH64_ALPHA_BLEND_DST_SRCALPHA		(4 << 19)
>+#define MACH64_ALPHA_BLEND_DST_INVSRCALPHA	(5 << 19)
>+#define MACH64_ALPHA_BLEND_DST_DSTALPHA		(6 << 19)
>+#define MACH64_ALPHA_BLEND_DST_INVDSTALPHA	(7 << 19)
>+
>+#define MACH64_TEX_LIGHT_FCN_MASK		(3 << 22)
>+#define MACH64_TEX_LIGHT_FCN_REPLACE		(0 << 22)
>+#define MACH64_TEX_LIGHT_FCN_MODULATE		(1 << 22)
>+#define MACH64_TEX_LIGHT_FCN_ALPHA_DECAL	(2 << 22)
>+
>+#define MACH64_MIP_MAP_DISABLE			(1 << 24)
>+
>+#define MACH64_BILINEAR_TEX_EN			(1 << 25)
>+#define MACH64_TEX_BLEND_FCN_MASK		(3 << 26)
>+#define MACH64_TEX_BLEND_FCN_NEAREST		(0 << 26)
>+#define MACH64_TEX_BLEND_FCN_LINEAR		(2 << 26)
>+#define MACH64_TEX_BLEND_FCN_TRILINEAR		(3 << 26)
>+
>+#define MACH64_TEX_AMASK_AEN			(1 << 28)
>+#define MACH64_TEX_AMASK_BLEND_EDGE		(1 << 29)
>+#define MACH64_TEX_MAP_AEN			(1 << 30)
>+#define MACH64_SRC_3D_HOST_FIFO			(1 << 31)
>+
>+/* TEX_CNTL */
>+#define MACH64_LOD_BIAS_SHIFT			0
>+#define MACH64_LOD_BIAS_MASK			(0xf << 0)
>+#define MACH64_COMP_FACTOR_SHIFT		4
>+#define MACH64_COMP_FACTOR_MASK			(0xf << 4)
>+
>+#define MACH64_TEXTURE_COMPOSITE		(1 << 8)
>+
>+#define MACH64_COMP_COMBINE_BLEND		(0 << 9)
>+#define MACH64_COMP_COMBINE_MODULATE		(1 << 9)
>+#define MACH64_COMP_BLEND_NEAREST		(0 << 11)
>+#define MACH64_COMP_BLEND_BILINEAR		(1 << 11)
>+#define MACH64_COMP_FILTER_NEAREST		(0 << 12)
>+#define MACH64_COMP_FILTER_BILINEAR		(1 << 12)
>+#define MACH64_COMP_ALPHA			(1 << 13)
>+
>+#define MACH64_TEXTURE_TILING			(1 << 14)
>+#define MACH64_COMPOSITE_TEX_TILING		(1 << 15)
>+#define MACH64_TEX_COLLISION_DISABLE		(1 << 16)
>+
>+#define MACH64_TEXTURE_CLAMP_S			(1 << 17)
>+#define MACH64_TEXTURE_CLAMP_T			(1 << 18)
>+#define MACH64_TEX_ST_MULT_W			(0 << 19)
>+#define MACH64_TEX_ST_DIRECT			(1 << 19)
>+#define MACH64_TEX_SRC_LOCAL			(0 << 20)
>+#define MACH64_TEX_SRC_AGP			(1 << 20)
>+#define MACH64_TEX_UNCOMPRESSED			(0 << 21)
>+#define MACH64_TEX_VQ_COMPRESSED		(1 << 21)
>+#define MACH64_COMP_TEX_UNCOMPRESSED		(0 << 22)
>+#define MACH64_COMP_TEX_VQ_COMPRESSED		(1 << 22)
>+#define MACH64_TEX_CACHE_FLUSH			(1 << 23)
>+#define MACH64_SEC_TEX_CLAMP_S			(1 << 24)
>+#define MACH64_SEC_TEX_CLAMP_T			(1 << 25)
>+#define MACH64_TEX_WRAP_S			(1 << 28)
>+#define MACH64_TEX_WRAP_T			(1 << 29)
>+#define MACH64_TEX_CACHE_SIZE_4K		(1 << 30)
>+#define MACH64_TEX_CACHE_SIZE_2K		(1 << 30)
>+#define MACH64_SECONDARY_STW			(1 << 31)
>+
>+/* DP_PIX_WIDTH (superset of PIX_WIDTH_?BPP) */
>+#define MACH64_DATATYPE_CI8                             2
>+#define MACH64_DATATYPE_ARGB1555                        3
>+#define MACH64_DATATYPE_RGB565                          4
>+#define MACH64_DATATYPE_ARGB8888                        6
>+#define MACH64_DATATYPE_RGB332                          7
>+#define MACH64_DATATYPE_Y8                              8
>+#define MACH64_DATATYPE_RGB8                            9
>+#define MACH64_DATATYPE_VYUY422                         11
>+#define MACH64_DATATYPE_YVYU422                         12
>+#define MACH64_DATATYPE_AYUV444                         14
>+#define MACH64_DATATYPE_ARGB4444                        15
>+
> #endif /* ___ATIREGS_H___ */

Actions: View | Splinter Review

Attachments on bug 6877: 5587 | 5633 | 5652 | 5653 | 5693 | 5714 | 5715 | 5909 | 6192 | 6506 | 6515

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.