Bug#246782: [davem@redhat.com: Fw: Re: Kernel 2.6.x breaks X on blade 100]
Here's the patch. Dave tested a build that included it and things
worked.
--
Debian - http://www.debian.org/
Linux 1394 - http://www.linux1394.org/
Subversion - http://subversion.tigris.org/
WatchGuard - http://www.watchguard.com/
diff -urN xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/Imakefile xc/programs/Xserver/hw/xfree86/drivers/sunffb/Imakefile
--- xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/Imakefile 2002-09-16 14:06:01.000000000 -0400
+++ xc/programs/Xserver/hw/xfree86/drivers/sunffb/Imakefile 2004-06-10 23:38:50.706539152 -0400
@@ -77,11 +77,13 @@
INCLUDES = -I. -I$(XF86COMSRC) -I$(XF86OSSRC) \
-I$(SERVERSRC)/mfb -I$(SERVERSRC)/mi \
-I$(SERVERSRC)/Xext -I$(SERVERSRC)/cfb \
- -I$(SERVERSRC)/dbe \
+ -I$(SERVERSRC)/dbe -I$(SERVERSRC)/fb \
+ -I$(SERVERSRC)/render \
-I$(XF86SRC)/xf8_32wid \
-I$(XF86SRC)/ramdac \
-I$(XF86SRC)/ddc \
-I$(XF86SRC)/i2c \
+ -I$(XF86SRC)/xaa \
-I$(FONTINCSRC) -I$(SERVERSRC)/include -I$(XINCLUDESRC) \
-I$(EXTINCSRC) \
$(DRIINCLUDES)
diff -urN xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb.h xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb.h
--- xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb.h 2002-12-05 21:44:03.000000000 -0500
+++ xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb.h 2004-06-10 23:38:50.709538696 -0400
@@ -33,6 +33,7 @@
#include "xf86_OSproc.h"
#include "xf86_ansic.h"
#include "xf86RamDac.h"
+#include "xaa.h"
#include "Xmd.h"
#include "gcstruct.h"
#include "windowstr.h"
@@ -188,6 +189,19 @@
unsigned char has_z_buffer;
unsigned char has_double_buffer;
+ /* XAA related info */
+ XAAInfoRecPtr pXAAInfo;
+ unsigned int xaa_fbc;
+ unsigned int xaa_wid;
+ unsigned int xaa_planemask;
+ unsigned int xaa_linepat;
+ int xaa_xdir, xaa_ydir, xaa_rop;
+ unsigned char *xaa_scanline_buffers[2];
+ int xaa_scanline_x, xaa_scanline_y, xaa_scanline_w;
+ unsigned char *xaa_tex;
+ int xaa_tex_pitch, xaa_tex_width, xaa_tex_height;
+ unsigned int xaa_tex_color;
+
enum ffb_resolution ffb_res;
BoxRec ClippedBoxBuf[64];
xRectangle Pf_Fixups[4];
diff -urN xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_accel.c xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_accel.c
--- xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_accel.c 2001-03-03 17:41:34.000000000 -0500
+++ xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_accel.c 2004-06-10 23:38:50.738534288 -0400
@@ -30,22 +30,9 @@
#include "pixmapstr.h"
#include "regionstr.h"
#include "mistruct.h"
-#include "fontstruct.h"
-#include "dixfontstr.h"
-#define PSZ 8
-#include "cfb.h"
-#undef PSZ
-#include "cfb32.h"
-#include "mibstore.h"
-#include "mifillarc.h"
-#include "miwideline.h"
#include "miline.h"
-#include "fastblt.h"
-#include "mergerop.h"
-#include "migc.h"
-#include "mi.h"
-
-#include "cfb8_32wid.h"
+#include "fb.h"
+#include "xaa.h"
#include "ffb.h"
#include "ffb_fifo.h"
@@ -69,690 +56,776 @@
/*XXX*/ { 0x00c0, 0x0a00, 0x04, 0x08, 0x08, 0x50 }, /* Portrait: 1280 x 2048 XXX */
};
-static Bool
-CreatorCreateWindow (WindowPtr pWin)
+void
+CreatorVtChange (ScreenPtr pScreen, int enter)
{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- FFBPtr pFfb = GET_FFB_FROM_SCREEN(pScreen);
- CreatorPrivWinPtr pFfbPrivWin;
- unsigned int fbc;
- int depth = (pWin->drawable.depth == 8) ? 8 : 24;
- int i, visual, visclass;
+ FFBPtr pFfb = GET_FFB_FROM_SCREEN (pScreen);
+ ffb_fbcPtr ffb = pFfb->regs;
- if (depth == 8) {
- if (!cfbCreateWindow (pWin))
- return FALSE;
- } else {
- if (!cfb32CreateWindow (pWin))
- return FALSE;
- }
+ pFfb->rp_active = 1;
+ FFBWait(pFfb, ffb);
+ pFfb->fifo_cache = -1;
+ pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED |
+ FFB_FBC_RB_A | FFB_FBC_SB_BOTH| FFB_FBC_XE_OFF |
+ FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_MASK);
+ pFfb->ppc_cache = (FFB_PPC_FW_DISABLE |
+ FFB_PPC_VCE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST |
+ FFB_PPC_XS_CONST | FFB_PPC_YS_CONST | FFB_PPC_ZS_CONST|
+ FFB_PPC_DCE_DISABLE | FFB_PPC_ABE_DISABLE | FFB_PPC_TBE_OPAQUE);
- pFfbPrivWin = xalloc(sizeof(CreatorPrivWinRec));
- if (!pFfbPrivWin)
- return FALSE;
+ pFfb->pmask_cache = ~0;
+ pFfb->rop_cache = FFB_ROP_EDIT_BIT;
+ pFfb->drawop_cache = FFB_DRAWOP_RECTANGLE;
+ pFfb->fg_cache = pFfb->bg_cache = 0;
+ pFfb->fontw_cache = 32;
+ pFfb->fontinc_cache = (1 << 16) | 0;
+ pFfb->laststipple = NULL;
+ FFBFifo(pFfb, 9);
+ ffb->fbc = pFfb->fbc_cache;
+ ffb->ppc = pFfb->ppc_cache;
+ ffb->pmask = pFfb->pmask_cache;
+ ffb->rop = pFfb->rop_cache;
+ ffb->drawop = pFfb->drawop_cache;
+ ffb->fg = pFfb->fg_cache;
+ ffb->bg = pFfb->bg_cache;
+ ffb->fontw = pFfb->fontw_cache;
+ ffb->fontinc = pFfb->fontinc_cache;
+ pFfb->rp_active = 1;
+ FFBWait(pFfb, ffb);
- fbc = FFB_FBC_WB_A | FFB_FBC_WM_COMBINED | FFB_FBC_RB_A;
- fbc |= FFB_FBC_WE_FORCEON;
- fbc |= FFB_FBC_SB_BOTH;
- fbc |= FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF;
- if (depth == 8)
- fbc |= (FFB_FBC_RE_MASK | FFB_FBC_GE_OFF | FFB_FBC_BE_OFF);
- else
- fbc |= FFB_FBC_RGBE_MASK;
- fbc |= FFB_FBC_XE_ON;
- pFfbPrivWin->fbc_base = fbc;
-
- visual = wVisual(pWin);
- visclass = 0;
- for (i = 0; i < pScreen->numVisuals; i++) {
- if (pScreen->visuals[i].vid == visual) {
- visclass = pScreen->visuals[i].class;
- break;
- }
- }
+ /* Fixup the FBC/PPC caches to deal with actually using
+ * a WID for every ROP.
+ */
+ pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED |
+ FFB_FBC_RB_A | FFB_FBC_SB_BOTH | FFB_FBC_XE_ON |
+ FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_ON);
+ pFfb->ppc_cache &= ~FFB_PPC_XS_MASK;
+ pFfb->ppc_cache |= FFB_PPC_XS_WID;
+ pFfb->wid_cache = (enter ? pFfb->xaa_wid : 0xff);
+ FFBFifo(pFfb, 11);
+ ffb->fbc = pFfb->fbc_cache;
+ ffb->ppc = FFB_PPC_XS_WID;
+ ffb->wid = pFfb->wid_cache;
+ ffb->xpmask = 0xff;
+ ffb->xclip = FFB_XCLIP_TEST_ALWAYS;
+ ffb->cmp = 0x80808080;
+ ffb->matchab = 0x80808080;
+ ffb->magnab = 0x80808080;
+ ffb->blendc = (FFB_BLENDC_FORCE_ONE |
+ FFB_BLENDC_DF_ONE_M_A |
+ FFB_BLENDC_SF_A);
+ ffb->blendc1 = 0;
+ ffb->blendc2 = 0;
+ pFfb->rp_active = 1;
+ FFBWait(pFfb, ffb);
- pFfbPrivWin->wid = FFBWidAlloc(pFfb, visclass, wColormap(pWin), TRUE);
- if (pFfbPrivWin->wid == (unsigned int) -1) {
- xfree(pFfbPrivWin);
- return FALSE;
- }
- FFBLOG(("CreatorCreateWindow: pWin %p depth %d wid %x fbc_base %x\n",
- pWin, depth, pFfbPrivWin->wid, pFfbPrivWin->fbc_base));
+ if (enter) {
+ pFfb->drawop_cache = FFB_DRAWOP_RECTANGLE;
- pFfbPrivWin->Stipple = NULL;
- CreatorSetWindowPrivate(pWin, pFfbPrivWin);
+ FFBFifo(pFfb, 5);
+ ffb->drawop = pFfb->drawop_cache;
+ FFB_WRITE64(&ffb->by, 0, 0);
+ FFB_WRITE64_2(&ffb->bh, pFfb->psdp->height, pFfb->psdp->width);
+ pFfb->rp_active = 1;
+ FFBWait(pFfb, ffb);
- return TRUE;
+ SET_SYNC_FLAG(pFfb->pXAAInfo);
+ }
}
-static Bool
-CreatorDestroyWindow (WindowPtr pWin)
+#ifdef DEBUG_FFB
+FILE *FDEBUG_FD = NULL;
+#endif
+
+#define FFB_ATTR_SFB_VAR_XAA(__fpriv, __pmask, __alu) \
+do { unsigned int __ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_VAR | FFB_PPC_XS_WID; \
+ unsigned int __ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK; \
+ unsigned int __rop = (FFB_ROP_EDIT_BIT | (__alu))|(FFB_ROP_NEW<<8); \
+ unsigned int __fbc = (__fpriv)->xaa_fbc; \
+ unsigned int __wid = (__fpriv)->xaa_wid; \
+ if (((__fpriv)->ppc_cache & __ppc_mask) != __ppc || \
+ (__fpriv)->fbc_cache != __fbc || \
+ (__fpriv)->wid_cache != __wid || \
+ (__fpriv)->rop_cache != __rop || \
+ (__fpriv)->pmask_cache != (__pmask)) \
+ __FFB_Attr_SFB_VAR(__fpriv, __ppc, __ppc_mask, __fbc, \
+ __wid, __rop, (__pmask)); \
+} while(0)
+
+#define FFB_ATTR_VSCROLL_XAA(__fpriv, __pmask) \
+do { unsigned int __rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
+ unsigned int __fbc = (__fpriv)->xaa_fbc; \
+ if ((__fpriv)->fbc_cache != __fbc || \
+ (__fpriv)->rop_cache != __rop || \
+ (__fpriv)->pmask_cache != (__pmask) || \
+ (__fpriv)->drawop_cache != FFB_DRAWOP_VSCROLL) { \
+ ffb_fbcPtr __ffb = (__fpriv)->regs; \
+ (__fpriv)->fbc_cache = __fbc; \
+ (__fpriv)->rop_cache = __rop; \
+ (__fpriv)->pmask_cache = (__pmask); \
+ (__fpriv)->drawop_cache = FFB_DRAWOP_VSCROLL; \
+ (__fpriv)->rp_active = 1; \
+ FFBFifo(__fpriv, 4); \
+ (__ffb)->fbc = __fbc; \
+ (__ffb)->rop = __rop; \
+ (__ffb)->pmask = (__pmask); \
+ (__ffb)->drawop = FFB_DRAWOP_VSCROLL; \
+ } \
+} while(0)
+
+static CARD32 FFBAlphaTextureFormats[2] = { PICT_a8, 0 };
+static CARD32 FFBTextureFormats[2] = { PICT_a8b8g8r8, 0 };
+
+static void FFB_SetupTextureAttrs(FFBPtr pFfb)
{
- FFBPtr pFfb = GET_FFB_FROM_SCREEN(pWin->drawable.pScreen);
- CreatorPrivWinPtr pFfbPrivWin;
- int depth = (pWin->drawable.depth == 8) ? 8 : 24;
-
- FFBLOG(("CreatorDestroyWindow: pWin %p depth %d\n", pWin, depth));
- pFfbPrivWin = CreatorGetWindowPrivate(pWin);
- if (pFfbPrivWin->Stipple)
- xfree(pFfbPrivWin->Stipple);
- FFBWidFree(pFfb, pFfbPrivWin->wid);
- xfree(pFfbPrivWin);
+ ffb_fbcPtr ffb = pFfb->regs;
+ unsigned int ppc = FFB_PPC_APE_DISABLE | FFB_PPC_CS_VAR | FFB_PPC_XS_VAR;
+ unsigned int ppc_mask = FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK;
+ unsigned int rop = FFB_ROP_NEW | (FFB_ROP_NEW << 8);
+ unsigned int fbc = pFfb->xaa_fbc;
+ unsigned int wid = pFfb->xaa_wid;
+
+ ppc |= FFB_PPC_ABE_ENABLE;
+ ppc_mask |= FFB_PPC_ABE_MASK;
+
+ if ((pFfb->ppc_cache & ppc_mask) != ppc ||
+ pFfb->fbc_cache != fbc ||
+ pFfb->wid_cache != wid ||
+ pFfb->rop_cache != rop ||
+ pFfb->pmask_cache != 0xffffffff)
+ __FFB_Attr_SFB_VAR(pFfb, ppc, ppc_mask, fbc,
+ wid, rop, 0xffffffff);
+ FFBWait(pFfb, ffb);
- if (depth == 8)
- return cfbDestroyWindow (pWin);
- else
- return cfb32DestroyWindow (pWin);
}
-extern CreatorStipplePtr FFB_tmpStipple;
+static Bool FFB_SetupForCPUToScreenAlphaTexture(ScrnInfoPtr pScrn, int op,
+ CARD16 red, CARD16 green, CARD16 blue,
+ CARD16 alpha, int alphaType,
+ CARD8 *alphaPtr, int alphaPitch,
+ int width, int height, int flags)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
-static int
-CreatorChangeWindowAttributes (WindowPtr pWin, Mask mask)
+ FFBLOG(("FFB_SetupForCPUToScreenAlphaTexture: "
+ "argb[%04x:%04x:%04x:%04x] alpha[T(%x):P(%d)] "
+ "wh[%d:%d] flgs[%x]\n",
+ alpha, red, green, blue,
+ alphaType, alphaPitch,
+ width, height, flags));
+
+ FFB_SetupTextureAttrs(pFfb);
+
+ pFfb->xaa_tex = (unsigned char *) alphaPtr;
+ pFfb->xaa_tex_pitch = alphaPitch;
+ pFfb->xaa_tex_width = width;
+ pFfb->xaa_tex_height = height;
+ pFfb->xaa_tex_color = (/*((alpha >> 8) << 24) |*/
+ ((blue >> 8) << 16) |
+ ((green >> 8) << 8) |
+ ((red >> 8) << 0));
+ return TRUE;
+}
+
+static void FFB_SubsequentCPUToScreenAlphaTexture(ScrnInfoPtr pScrn,
+ int dstx, int dsty,
+ int srcx, int srcy,
+ int width, int height)
{
- FFBPtr pFfb = GET_FFB_FROM_SCREEN(pWin->drawable.pScreen);
- CreatorPrivWinPtr pFfbPrivWin;
- CreatorStipplePtr stipple;
- Mask index;
- WindowPtr pBgWin;
- register cfbPrivWin *pPrivWin;
- int width, depth;
-
- FFBLOG(("CreatorChangeWindowAttributes: WIN(%p) mask(%08x)\n", pWin, mask));
- pPrivWin = (cfbPrivWin *)(pWin->devPrivates[cfbWindowPrivateIndex].ptr);
- pFfbPrivWin = CreatorGetWindowPrivate(pWin);
- depth = pWin->drawable.depth;
-
- /*
- * When background state changes from ParentRelative and
- * we had previously rotated the fast border pixmap to match
- * the parent relative origin, rerotate to match window
- */
- if (mask & (CWBackPixmap | CWBackPixel) &&
- pWin->backgroundState != ParentRelative &&
- pPrivWin->fastBorder &&
- (pPrivWin->oldRotate.x != pWin->drawable.x ||
- pPrivWin->oldRotate.y != pWin->drawable.y)) {
- if (depth == 8) {
- cfbXRotatePixmap(pPrivWin->pRotatedBorder,
- pWin->drawable.x - pPrivWin->oldRotate.x);
- cfbYRotatePixmap(pPrivWin->pRotatedBorder,
- pWin->drawable.y - pPrivWin->oldRotate.y);
- } else {
- cfb32XRotatePixmap(pPrivWin->pRotatedBorder,
- pWin->drawable.x - pPrivWin->oldRotate.x);
- cfb32YRotatePixmap(pPrivWin->pRotatedBorder,
- pWin->drawable.y - pPrivWin->oldRotate.y);
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ unsigned char *dst_base, *alpha_base, *sfb32;
+ unsigned int pixel_base;
+ int psz_shift = 2;
+
+ FFBLOG(("FFB_SubsequentCPUToScreenAlphaTexture: "
+ "dst[%d:%d] src[%d:%d] wh[%d:%d]\n",
+ dstx, dsty, srcx, srcy, width, height));
+
+ sfb32 = (unsigned char *) pFfb->sfb32;
+ dst_base = sfb32 + (dsty * (2048 << psz_shift)) + (dstx << psz_shift);
+ alpha_base = pFfb->xaa_tex;
+ alpha_base += srcx;
+ if (srcy)
+ alpha_base += (srcy * pFfb->xaa_tex_pitch);
+ pixel_base = pFfb->xaa_tex_color;
+ while (height--) {
+ unsigned int *dst = (unsigned int *) dst_base;
+ unsigned char *alpha = alpha_base;
+ int w = width;
+
+ while (w--) {
+ (*dst) = (((unsigned int)*alpha << 24) | pixel_base);
+ dst++;
+ alpha++;
}
- pPrivWin->oldRotate.x = pWin->drawable.x;
- pPrivWin->oldRotate.y = pWin->drawable.y;
+ dst_base += (2048 << psz_shift);
+ alpha_base += pFfb->xaa_tex_pitch;
}
- while (mask) {
- index = lowbit(mask);
- mask &= ~index;
- switch (index) {
- case CWBackPixmap:
- stipple = pFfbPrivWin->Stipple;
- if (pWin->backgroundState == None ||
- pWin->backgroundState == ParentRelative) {
- pPrivWin->fastBackground = FALSE;
- if (stipple) {
- xfree (stipple);
- pFfbPrivWin->Stipple = NULL;
- }
- /* Rotate border to match parent origin */
- if (pWin->backgroundState == ParentRelative &&
- pPrivWin->pRotatedBorder) {
- for (pBgWin = pWin->parent;
- pBgWin->backgroundState == ParentRelative;
- pBgWin = pBgWin->parent);
- if (depth == 8) {
- cfbXRotatePixmap(pPrivWin->pRotatedBorder,
- pBgWin->drawable.x - pPrivWin->oldRotate.x);
- cfbYRotatePixmap(pPrivWin->pRotatedBorder,
- pBgWin->drawable.y - pPrivWin->oldRotate.y);
- } else {
- cfb32XRotatePixmap(pPrivWin->pRotatedBorder,
- pBgWin->drawable.x - pPrivWin->oldRotate.x);
- cfb32YRotatePixmap(pPrivWin->pRotatedBorder,
- pBgWin->drawable.y - pPrivWin->oldRotate.y);
- }
- pPrivWin->oldRotate.x = pBgWin->drawable.x;
- pPrivWin->oldRotate.y = pBgWin->drawable.y;
- }
- break;
- }
- if (!stipple) {
- if (!FFB_tmpStipple)
- FFB_tmpStipple = (CreatorStipplePtr)
- xalloc (sizeof *FFB_tmpStipple);
- stipple = FFB_tmpStipple;
- }
- if (stipple) {
- int ph = FFB_FFPARMS(pFfb).pagefill_height;
+}
- if (CreatorCheckTile (pWin->background.pixmap, stipple,
- ((DrawablePtr)pWin)->x & 31,
- ((DrawablePtr)pWin)->y & 31, ph)) {
- stipple->alu = GXcopy;
- pPrivWin->fastBackground = FALSE;
- if (stipple == FFB_tmpStipple) {
- pFfbPrivWin->Stipple = stipple;
- FFB_tmpStipple = 0;
- }
- break;
- }
- }
- if ((stipple = pFfbPrivWin->Stipple) != NULL) {
- xfree (stipple);
- pFfbPrivWin->Stipple = NULL;
- }
- if (((width = (pWin->background.pixmap->drawable.width *
- pWin->background.pixmap->drawable.bitsPerPixel)) <= 32) &&
- !(width & (width - 1))) {
- if (depth == 8) {
- cfbCopyRotatePixmap(pWin->background.pixmap,
- &pPrivWin->pRotatedBackground,
- pWin->drawable.x,
- pWin->drawable.y);
- } else {
- cfb32CopyRotatePixmap(pWin->background.pixmap,
- &pPrivWin->pRotatedBackground,
- pWin->drawable.x,
- pWin->drawable.y);
- }
- if (pPrivWin->pRotatedBackground) {
- pPrivWin->fastBackground = TRUE;
- pPrivWin->oldRotate.x = pWin->drawable.x;
- pPrivWin->oldRotate.y = pWin->drawable.y;
- } else
- pPrivWin->fastBackground = FALSE;
- break;
- }
- pPrivWin->fastBackground = FALSE;
- break;
+static Bool FFB_SetupForCPUToScreenTexture(ScrnInfoPtr pScrn, int op,
+ int texType,
+ CARD8 *texPtr, int texPitch,
+ int width, int height, int flags)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+
+ FFBLOG(("FFB_SetupForCPUToScreenTexture: "
+ "TEX[T(%x):P(%d)] "
+ "wh[%d:%d] flgs[%x]\n",
+ texType, texPitch,
+ width, height, flags));
+
+ FFB_SetupTextureAttrs(pFfb);
+
+ pFfb->xaa_tex = (unsigned char *) texPtr;
+ pFfb->xaa_tex_pitch = texPitch;
+ pFfb->xaa_tex_width = width;
+ pFfb->xaa_tex_height = height;
+
+ return TRUE;
+}
+
+static void FFB_SubsequentCPUToScreenTexture(ScrnInfoPtr pScrn,
+ int dstx, int dsty,
+ int srcx, int srcy,
+ int width, int height)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ unsigned char *dst_base, *sfb32;
+ unsigned int *tex_base;
+ int psz_shift = 2;
+
+ FFBLOG(("FFB_SubsequentCPUToScreenAlphaTexture: "
+ "dst[%d:%d] src[%d:%d] wh[%d:%d]\n",
+ dstx, dsty, srcx, srcy, width, height));
+
+ sfb32 = (unsigned char *) pFfb->sfb32;
+ dst_base = sfb32 + (dsty * (2048 << psz_shift)) + (dstx << psz_shift);
+ tex_base = (unsigned int *) pFfb->xaa_tex;
+ tex_base += srcx;
+ if (srcy)
+ tex_base += (srcy * pFfb->xaa_tex_pitch);
+ while (height--) {
+ unsigned int *dst = (unsigned int *) dst_base;
+ unsigned int *tex = tex_base;
+ int w = width;
- case CWBackPixel:
- pPrivWin->fastBackground = FALSE;
- break;
-
- case CWBorderPixmap:
- /* don't bother with accelerator for border tiles (just lazy) */
- if (((width = (pWin->border.pixmap->drawable.width *
- pWin->border.pixmap->drawable.bitsPerPixel)) <= 32) &&
- !(width & (width - 1))) {
- for (pBgWin = pWin;
- pBgWin->backgroundState == ParentRelative;
- pBgWin = pBgWin->parent)
- ;
- if (depth == 8) {
- cfbCopyRotatePixmap(pWin->border.pixmap,
- &pPrivWin->pRotatedBorder,
- pBgWin->drawable.x,
- pBgWin->drawable.y);
- } else {
- cfb32CopyRotatePixmap(pWin->border.pixmap,
- &pPrivWin->pRotatedBorder,
- pBgWin->drawable.x,
- pBgWin->drawable.y);
- }
- if (pPrivWin->pRotatedBorder) {
- pPrivWin->fastBorder = TRUE;
- pPrivWin->oldRotate.x = pBgWin->drawable.x;
- pPrivWin->oldRotate.y = pBgWin->drawable.y;
- } else
- pPrivWin->fastBorder = FALSE;
- } else
- pPrivWin->fastBorder = FALSE;
- break;
-
- case CWBorderPixel:
- pPrivWin->fastBorder = FALSE;
- break;
+ while (w--) {
+ (*dst) = *tex;
+
+ dst++;
+ tex++;
}
+ dst_base += (2048 << psz_shift);
+ tex_base += pFfb->xaa_tex_pitch;
}
- return (TRUE);
}
-static void
-CreatorPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what)
+static void FFB_WritePixmap(ScrnInfoPtr pScrn,
+ int x, int y, int w, int h,
+ unsigned char *src,
+ int srcwidth,
+ int rop,
+ unsigned int planemask,
+ int trans, int bpp, int depth)
{
- FFBPtr pFfb = GET_FFB_FROM_SCREEN (pWin->drawable.pScreen);
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
ffb_fbcPtr ffb = pFfb->regs;
- register cfbPrivWin *pPrivWin;
- CreatorPrivWinPtr pFfbPrivWin;
- CreatorStipplePtr stipple;
- WindowPtr pBgWin;
- int depth = pWin->drawable.depth;
-
- if (pFfb->vtSema)
- return;
-
- FFBLOG(("CreatorPaintWindow: WIN(%p) what(%d)\n", pWin, what));
- pPrivWin = cfbGetWindowPrivate(pWin);
- pFfbPrivWin = CreatorGetWindowPrivate(pWin);
- switch (what) {
- case PW_BACKGROUND:
- stipple = pFfbPrivWin->Stipple;
- switch (pWin->backgroundState) {
- case None:
- return;
- case ParentRelative:
- do {
- pWin = pWin->parent;
- } while (pWin->backgroundState == ParentRelative);
- (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion, what);
- return;
- case BackgroundPixmap:
- if (stipple) {
- CreatorFillBoxStipple ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- stipple);
- return;
- }
- FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
- FFBWait(pFfb, ffb);
- if (pPrivWin->fastBackground) {
- if (depth == 8) {
- cfbFillBoxTile32 ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pPrivWin->pRotatedBackground);
- } else {
- cfb32FillBoxTile32 ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pPrivWin->pRotatedBackground);
- }
- } else {
- if (depth == 8) {
- cfbFillBoxTileOdd ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pWin->background.pixmap,
- (int) pWin->drawable.x,
- (int) pWin->drawable.y);
- } else {
- cfb32FillBoxTileOdd ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pWin->background.pixmap,
- (int) pWin->drawable.x,
- (int) pWin->drawable.y);
- }
- }
- return;
- case BackgroundPixel:
- CreatorFillBoxSolid ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pWin->background.pixel);
- return;
- }
- break;
- case PW_BORDER:
- if (pWin->borderIsPixel) {
- CreatorFillBoxSolid ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pWin->border.pixel);
- return;
- }
- FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
- FFBWait(pFfb, ffb);
- if (pPrivWin->fastBorder) {
- if (depth == 8) {
- cfbFillBoxTile32 ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pPrivWin->pRotatedBorder);
- } else {
- cfb32FillBoxTile32 ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pPrivWin->pRotatedBorder);
- }
+ unsigned char *dst, *sfb32;
+ int psz_shift = 2;
+
+ FFBLOG(("FFB_WritePixmap: "
+ "x[%d] y[%d] w[%d] h[%d] srcw[%d] rop[%d] pmask[%x] "
+ "trans[%d] bpp[%d] depth[%d]\n",
+ x, y, w, h, srcwidth, rop, planemask,
+ trans, bpp, depth));
+
+ FFB_ATTR_SFB_VAR_XAA(pFfb, planemask, rop);
+ FFBWait(pFfb, ffb);
+
+ sfb32 = (unsigned char *) pFfb->sfb32;
+ dst = sfb32 + (y * (2048 << psz_shift)) + (x << psz_shift);
+ VISmoveImageLR(src, dst, w << psz_shift, h,
+ srcwidth, (2048 << psz_shift));
+}
+
+static void FFB_SetupForMono8x8PatternFill(ScrnInfoPtr pScrn,
+ int pat_word1, int pat_word2,
+ int fg, int bg, int rop,
+ unsigned int planemask)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+ unsigned int ppc, ppc_mask, fbc;
+ int i;
+
+ FFBLOG(("FFB_SetupForMono8x8PatternFill: "
+ "pat[%08x:%08x] fg[%x] bg[%x] rop[%d] pmask[%x]\n",
+ pat_word1, pat_word2,
+ fg, bg, rop, planemask));
+
+ ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_ENABLE | FFB_PPC_CS_CONST;
+ if (bg < 0)
+ ppc |= FFB_PPC_TBE_TRANSPARENT;
+ else
+ ppc |= FFB_PPC_TBE_OPAQUE;
+ ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK |
+ FFB_PPC_TBE_MASK | FFB_PPC_CS_MASK;
+ fbc = pFfb->xaa_fbc;
+ rop = (rop | FFB_ROP_EDIT_BIT) | (FFB_ROP_NEW << 8);
+
+ FFB_ATTR_RAW(pFfb, ppc, ppc_mask, planemask, rop,
+ FFB_DRAWOP_RECTANGLE, fg, fbc, pFfb->xaa_wid);
+ if (bg >= 0)
+ FFB_WRITE_BG(pFfb, ffb, bg);
+
+ FFBFifo(pFfb, 32);
+ for (i = 0; i < 32; i += 2) {
+ CARD32 val1, val2;
+ int shift = (24 - ((i % 4) * 8));
+
+ if ((i % 8) < 4) {
+ val1 = (pat_word1 >> shift) & 0xff;
+ val2 = (pat_word1 >> (shift + 8)) & 0xff;
} else {
- for (pBgWin = pWin;
- pBgWin->backgroundState == ParentRelative;
- pBgWin = pBgWin->parent)
- ;
-
- if (depth == 8) {
- cfbFillBoxTileOdd ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pWin->border.pixmap,
- (int) pBgWin->drawable.x,
- (int) pBgWin->drawable.y);
- } else {
- cfb32FillBoxTileOdd ((DrawablePtr)pWin,
- (int)REGION_NUM_RECTS(pRegion),
- REGION_RECTS(pRegion),
- pWin->border.pixmap,
- (int) pBgWin->drawable.x,
- (int) pBgWin->drawable.y);
- }
+ val1 = (pat_word2 >> shift) & 0xff;
+ val2 = (pat_word2 >> (shift + 8)) & 0xff;
}
- return;
+ val1 |= (val1 << 8) | (val1 << 16) | (val1 << 24);
+ val2 |= (val2 << 8) | (val2 << 16) | (val2 << 24);
+ FFB_WRITE64(&ffb->pattern[i], val1, val2);
}
+ pFfb->rp_active = 1;
}
-static void
-CreatorCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
+static void FFB_SubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
+ int pat_word1, int pat_word2,
+ int x, int y, int w, int h)
{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- FFBPtr pFfb = GET_FFB_FROM_SCREEN (pScreen);
- DDXPointPtr pptSrc;
- DDXPointPtr ppt;
- RegionRec rgnDst;
- BoxPtr pbox;
- int dx, dy;
- int i, nbox;
- WindowPtr pwinRoot;
-
- if (pFfb->vtSema)
- return;
-
- FFBLOG(("CreatorCopyWindow: WIN(%p)\n", pWin));
-
- REGION_INIT(pScreen, &rgnDst, NullBox, 0);
-
- dx = ptOldOrg.x - pWin->drawable.x;
- dy = ptOldOrg.y - pWin->drawable.y;
- REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);
- REGION_INTERSECT(pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
-
- pbox = REGION_RECTS(&rgnDst);
- nbox = REGION_NUM_RECTS(&rgnDst);
- if(!(pptSrc = (DDXPointPtr )ALLOCATE_LOCAL(nbox * sizeof(DDXPointRec))))
- return;
-
- ppt = pptSrc;
- for (i = nbox; --i >= 0; ppt++, pbox++) {
- ppt->x = pbox->x1 + dx;
- ppt->y = pbox->y1 + dy;
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+
+ FFBLOG(("FFB_SubsequentMono8x8PatternFillRect: "
+ "x[%d] y[%d] w[%d] h[%d]\n", x, y, w, h));
+
+ FFBFifo(pFfb, 4);
+ FFB_WRITE64(&ffb->by, y, x);
+ FFB_WRITE64_2(&ffb->bh, h, w);
+}
+
+static void FFB_SetupForScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int fg, int bg,
+ int rop,
+ unsigned int planemask)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+ unsigned int ppc, ppc_mask, fbc;
+
+ FFBLOG(("FFB_SetupForScanlineCPUToScreenColorExpandFill: "
+ "fg[%x] bg[%x] rop[%d] pmask[%x]\n",
+ fg, bg, rop, planemask));
+
+ ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST;
+ if (bg < 0)
+ ppc |= FFB_PPC_TBE_TRANSPARENT;
+ else
+ ppc |= FFB_PPC_TBE_OPAQUE;
+ ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK |
+ FFB_PPC_TBE_MASK | FFB_PPC_CS_MASK;
+ fbc = pFfb->xaa_fbc;
+ rop = (rop | FFB_ROP_EDIT_BIT) | (FFB_ROP_NEW << 8);
+
+ if ((pFfb->ppc_cache & ppc_mask) != ppc ||
+ pFfb->fg_cache != fg ||
+ pFfb->fbc_cache != fbc ||
+ pFfb->rop_cache != rop ||
+ pFfb->pmask_cache != planemask ||
+ pFfb->fontinc_cache != ((0<<16) | 32) ||
+ (bg >= 0 && pFfb->bg_cache != bg)) {
+ pFfb->ppc_cache &= ~ppc_mask;
+ pFfb->ppc_cache |= ppc;
+ pFfb->fg_cache = fg;
+ pFfb->fbc_cache = fbc;
+ pFfb->rop_cache = rop;
+ pFfb->pmask_cache = planemask;
+ pFfb->fontinc_cache = ((0<<16) | 32);
+ if (bg >= 0)
+ pFfb->bg_cache = bg;
+ FFBFifo(pFfb, (bg >= 0 ? 7 : 6));
+ ffb->ppc = ppc;
+ ffb->fg = fg;
+ ffb->fbc = fbc;
+ ffb->rop = rop;
+ ffb->pmask = planemask;
+ ffb->fontinc = ((0 << 16) | 32);
+ if(bg >= 0)
+ ffb->bg = bg;
}
+ pFfb->rp_active = 1;
+}
- /* XXX Optimize this later to only gcopy/vcopy the 8bpp+WID plane
- * XXX when possible. -DaveM
- */
+static void FFB_SubsequentScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int x, int y, int w, int h,
+ int skipleft)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
- pwinRoot = WindowTable[pScreen->myNum];
+ FFBLOG(("FFB_SubsequentCPUToScreenColorExpandFill: "
+ "x[%d] y[%d] w[%d] h[%d] skipleft[%d]\n",
+ x, y, w, h, skipleft));
+
+ pFfb->xaa_scanline_x = x;
+ pFfb->xaa_scanline_y = y;
+ pFfb->xaa_scanline_w = w;
+}
- if (!pFfb->disable_vscroll && (!dx && dy)) {
- FFBPtr pFfb = GET_FFB_FROM_SCREEN(pScreen);
+static void FFB_SubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+ CARD32 *bits = (CARD32 *) pFfb->xaa_scanline_buffers[bufno];
+ int w;
- FFB_ATTR_VSCROLL_WINCOPY(pFfb);
- CreatorDoVertBitblt ((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
- GXcopy, &rgnDst, pptSrc, ~0L);
- } else {
- FFBPtr pFfb = GET_FFB_FROM_SCREEN(pScreen);
- ffb_fbcPtr ffb = pFfb->regs;
+ FFBFifo(pFfb, 1);
+ ffb->fontxy = ((pFfb->xaa_scanline_y << 16) | pFfb->xaa_scanline_x);
- FFB_ATTR_SFB_VAR_WINCOPY(pFfb);
- FFBWait(pFfb, ffb);
- CreatorDoBitblt ((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
- GXcopy, &rgnDst, pptSrc, ~0L);
+ w = pFfb->xaa_scanline_w;
+ if (w >= 32) {
+ FFB_WRITE_FONTW(pFfb, ffb, 32);
+ FFBFifo(pFfb, (w / 32));
+ do {
+ ffb->font = *bits++;
+ w -= 32;
+ } while (w >= 32);
}
- DEALLOCATE_LOCAL(pptSrc);
- REGION_UNINIT(pScreen, &rgnDst);
+ if (w > 0) {
+ FFB_WRITE_FONTW(pFfb, ffb, w);
+ FFBFifo(pFfb, 1);
+ ffb->font = *bits++;
+ }
+
+ pFfb->xaa_scanline_y++;
}
-static void
-CreatorSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg, WindowPtr pWin)
-{
- ScreenPtr pScreen = pPixmap->drawable.pScreen;
- FFBPtr pFfb = GET_FFB_FROM_SCREEN(pScreen);
- cfb8_32WidScreenPtr pScreenPriv =
- CFB8_32WID_GET_SCREEN_PRIVATE(pScreen);
- ffb_fbcPtr ffb = pFfb->regs;
- register DDXPointPtr pPt;
- DDXPointPtr pPtsInit;
- register BoxPtr pBox;
- register int i;
- PixmapPtr pScrPix;
-
- if (pFfb->vtSema)
- return;
-
- FFBLOG(("CreatorSaveAreas: WIN(%p)\n", pWin));
- i = REGION_NUM_RECTS(prgnSave);
- pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i * sizeof(DDXPointRec));
- if (!pPtsInit)
- return;
-
- pBox = REGION_RECTS(prgnSave);
- pPt = pPtsInit;
- while (--i >= 0) {
- pPt->x = pBox->x1 + xorg;
- pPt->y = pBox->y1 + yorg;
- pPt++;
- pBox++;
- }
+static void FFB_SetupForDashedLine(ScrnInfoPtr pScrn,
+ int fg, int bg, int rop,
+ unsigned int planemask,
+ int length, unsigned char *pattern)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ CARD32 *pat_ptr = (CARD32 *)pattern;
+ unsigned int ppc, ppc_mask, fbc;
+
+ FFBLOG(("FFB_SetupForDashedLine: "
+ "fg[%x] bg[%x] rop[%d] pmask[%x] patlen[%d] pat[%x]\n",
+ fg, bg, rop, planemask, length, *pat_ptr));
+
+ pFfb->xaa_planemask = planemask;
+ pFfb->xaa_rop = rop;
+ pFfb->xaa_linepat =
+ (*pat_ptr << FFB_LPAT_PATTERN_SHIFT) |
+ (1 << FFB_LPAT_SCALEVAL_SHIFT) |
+ ((length & 0xf) << FFB_LPAT_PATLEN_SHIFT);
+
+ fbc = pFfb->xaa_fbc;
+ ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST | FFB_PPC_XS_WID;
+ ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK;
+
+ FFB_ATTR_RAW(pFfb, ppc, ppc_mask, planemask,
+ (FFB_ROP_EDIT_BIT | rop) | (FFB_ROP_NEW << 8),
+ FFB_DRAWOP_BRLINEOPEN, fg, fbc, pFfb->xaa_wid);
+ pFfb->rp_active = 1;
+}
- if (pWin->drawable.bitsPerPixel == 8)
- pScrPix = (PixmapPtr) pScreenPriv->pix8;
- else
- pScrPix = (PixmapPtr) pScreenPriv->pix32;
+static void FFB_SubsequentDashedTwoPointLine( ScrnInfoPtr pScrn,
+ int x1, int y1,
+ int x2, int y2,
+ int flags, int phase)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+ unsigned int linepat = pFfb->xaa_linepat;
+ unsigned int drawop;
- /* SRC is the framebuffer, DST is a pixmap. The SFB_VAR attributes may
- * seem silly, but they are needed even in this case to handle
- * double-buffered windows properly.
- */
- FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
- FFBWait(pFfb, ffb);
- CreatorDoBitblt((DrawablePtr) pScrPix, (DrawablePtr)pPixmap,
- GXcopy, prgnSave, pPtsInit, ~0L);
+ FFBLOG(("FFB_SubsequentDashedTwoPointLine: "
+ "x1[%d] y1[%d] x2[%d] y2[%d] flgs[%x] phase[%d]\n",
+ x1, y2, x2, y2, flags, phase));
+
+ linepat |= (phase & 0xf) << FFB_LPAT_PATPTR_SHIFT;
+
+ drawop = (flags & OMIT_LAST) ?
+ FFB_DRAWOP_BRLINEOPEN : FFB_DRAWOP_BRLINECAP;
+ FFB_WRITE_DRAWOP(pFfb, ffb, drawop);
+
+ if (pFfb->has_brline_bug) {
+ FFBFifo(pFfb, 6);
+ ffb->ppc = 0;
+ } else
+ FFBFifo(pFfb, 5);
+ ffb->lpat = linepat;
+ FFB_WRITE64(&ffb->by, y1, x1);
+ FFB_WRITE64_2(&ffb->bh, y2, x2);
+}
+
+static void FFB_SetupForSolidLine(ScrnInfoPtr pScrn,
+ int color, int rop, unsigned int planemask)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+ unsigned int ppc, ppc_mask, fbc;
- DEALLOCATE_LOCAL (pPtsInit);
+ FFBLOG(("FFB_SetupForSolidLine: "
+ "color[%d] rop[%d] pmask[%x]\n",
+ color, rop, planemask));
+
+ pFfb->xaa_planemask = planemask;
+ pFfb->xaa_rop = rop;
+
+ fbc = pFfb->xaa_fbc;
+ ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST | FFB_PPC_XS_WID;
+ ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK;
+
+ FFB_ATTR_RAW(pFfb, ppc, ppc_mask, planemask,
+ (FFB_ROP_EDIT_BIT | rop) | (FFB_ROP_NEW << 8),
+ FFB_DRAWOP_BRLINEOPEN, color, fbc, pFfb->xaa_wid);
+ FFBFifo(pFfb, 1);
+ ffb->lpat = 0;
+ pFfb->rp_active = 1;
}
-static void
-CreatorRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg, int yorg, WindowPtr pWin)
+static void FFB_SubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
+ int x1, int y1,
+ int x2, int y2,
+ int flags)
{
- FFBPtr pFfb;
- ffb_fbcPtr ffb;
- register DDXPointPtr pPt;
- DDXPointPtr pPtsInit;
- register BoxPtr pBox;
- register int i;
- ScreenPtr pScreen = pPixmap->drawable.pScreen;
- cfb8_32WidScreenPtr pScreenPriv =
- CFB8_32WID_GET_SCREEN_PRIVATE(pScreen);
- PixmapPtr pScrPix;
-
- pFfb = GET_FFB_FROM_SCREEN(pScreen);
- if (pFfb->vtSema)
- return;
-
- FFBLOG(("CreatorRestoreAreas: WIN(%p)\n", pWin));
- i = REGION_NUM_RECTS(prgnRestore);
- pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i*sizeof(DDXPointRec));
- if (!pPtsInit)
- return;
-
- pBox = REGION_RECTS(prgnRestore);
- pPt = pPtsInit;
- while (--i >= 0) {
- pPt->x = pBox->x1 - xorg;
- pPt->y = pBox->y1 - yorg;
- pPt++;
- pBox++;
- }
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+ int drawop;
- if (pWin->drawable.bitsPerPixel == 8)
- pScrPix = (PixmapPtr) pScreenPriv->pix8;
- else
- pScrPix = (PixmapPtr) pScreenPriv->pix32;
+ FFBLOG(("FFB_SubsequentSolidTwoPointLine: "
+ "x1[%d] y1[%d] x2[%d] y2[%d] flags[%d]\n",
+ x1, y1, x2, y2, flags));
+
+ drawop = (flags & OMIT_LAST) ?
+ FFB_DRAWOP_BRLINEOPEN : FFB_DRAWOP_BRLINECAP;
+ FFB_WRITE_DRAWOP(pFfb, ffb, drawop);
+
+ if (pFfb->has_brline_bug) {
+ FFBFifo(pFfb, 5);
+ ffb->ppc = 0;
+ } else
+ FFBFifo(pFfb, 4);
+ FFB_WRITE64(&ffb->by, y1, x1);
+ FFB_WRITE64_2(&ffb->bh, y2, x2);
+}
- pFfb = GET_FFB_FROM_SCREEN(pScreen);
- ffb = pFfb->regs;
+void FFB_SetupForSolidFill(ScrnInfoPtr pScrn,
+ int color, int rop, unsigned int planemask)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ unsigned int ppc, ppc_mask, fbc;
- /* SRC is a pixmap, DST is the framebuffer */
- FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
- FFBWait(pFfb, ffb);
- CreatorDoBitblt((DrawablePtr)pPixmap, (DrawablePtr) pScrPix,
- GXcopy, prgnRestore, pPtsInit, ~0L);
+ FFBLOG(("FFB_SetupForSolidFill: "
+ "color[%d] rop[%d] pmask[%u]\n",
+ color, rop, planemask));
+
+ pFfb->xaa_planemask = planemask;
+ pFfb->xaa_rop = rop;
+
+ fbc = pFfb->xaa_fbc;
+ if (pFfb->ffb_res == ffb_res_high)
+ fbc |= FFB_FBC_WB_B;
+ ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST | FFB_PPC_XS_WID;
+ ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK;
+
+ FFB_ATTR_RAW(pFfb, ppc, ppc_mask, planemask,
+ (FFB_ROP_EDIT_BIT | rop) | (FFB_ROP_NEW << 8),
+ FFB_DRAWOP_RECTANGLE, color, fbc, pFfb->xaa_wid);
+ pFfb->rp_active = 1;
+}
+
+void FFB_SubsequentSolidFillRect(ScrnInfoPtr pScrn,
+ int x, int y,
+ int w, int h)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+
+ FFBLOG(("FFB_SubsequentSolidFillRect: "
+ "x[%d] y[%d] w[%d] h[%d]\n", x, y, w, h));
- DEALLOCATE_LOCAL (pPtsInit);
+ FFBFifo(pFfb, 4);
+ FFB_WRITE64(&ffb->by, y, x);
+ FFB_WRITE64_2(&ffb->bh, h, w);
}
-static void
-CreatorGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h, unsigned int format, unsigned long planeMask, char* pdstLine)
+static void FFB_ScreenToScreenBitBlt(ScrnInfoPtr pScrn,
+ int nbox,
+ DDXPointPtr pptSrc,
+ BoxPtr pbox,
+ int xdir, int ydir,
+ int rop, unsigned int planemask)
{
- BoxRec box;
- DDXPointRec ptSrc;
- RegionRec rgnDst;
- ScreenPtr pScreen;
- PixmapPtr pPixmap;
-
- FFBLOG(("CreatorGetImage: s[%08x:%08x] wh[%08x:%08x]\n", sx, sy, w, h));
- if ((w == 0) || (h == 0))
- return;
- if (pDrawable->bitsPerPixel == 1) {
- mfbGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
- return;
- }
- pScreen = pDrawable->pScreen;
- /*
- * XFree86 DDX empties the root borderClip when the VT is
- * switched away; this checks for that case
- */
- if (!cfbDrawableEnabled (pDrawable))
- return;
- if(format == ZPixmap) {
- FFBPtr pFfb = GET_FFB_FROM_SCREEN (pScreen);
- ffb_fbcPtr ffb = pFfb->regs;
-
- /* We have to have the full planemask. */
- if (pDrawable->type == DRAWABLE_WINDOW) {
- WindowPtr pWin = (WindowPtr) pDrawable;
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+ int use_vscroll;
- FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
- FFBWait(pFfb, ffb);
+ FFBLOG(("FFB_ScreenToScreenBitBlt: "
+ "nbox[%d] xdir[%d] ydir[%d] rop[%d] pmask[%x]\n",
+ nbox, xdir, ydir, rop, planemask));
+
+ use_vscroll = 0;
+ if (!pFfb->disable_vscroll &&
+ rop == GXcopy) {
+ int i;
+
+ for (i = 0; i < nbox; i++)
+ if (pptSrc[i].x != pbox[i].x1 ||
+ pptSrc[i].y == pbox[i].y1)
+ break;
+ if (i == nbox) {
+ /* If/When double buffer extension is re-enabled
+ * check buffers here.
+ */
+ use_vscroll = 1;
}
+ }
+ if (use_vscroll) {
+ FFB_ATTR_VSCROLL_XAA(pFfb, planemask);
+ while (nbox--) {
+ FFBFifo(pFfb, 7);
+ ffb->drawop = FFB_DRAWOP_VSCROLL;
+ FFB_WRITE64(&ffb->by, pptSrc->y, pptSrc->x);
+ FFB_WRITE64_2(&ffb->dy, pbox->y1, pbox->x1);
+ FFB_WRITE64_3(&ffb->bh, (pbox->y2 - pbox->y1),
+ (pbox->x2 - pbox->x1));
- if (pDrawable->bitsPerPixel == 8) {
- if((planeMask & 0x000000ff) != 0x000000ff) {
- cfbGetImage(pDrawable, sx, sy, w, h,
- format, planeMask, pdstLine);
- return;
- }
- } else {
- if((planeMask & 0x00ffffff) != 0x00ffffff) {
- cfb32GetImage(pDrawable, sx, sy, w, h,
- format, planeMask, pdstLine);
- return;
- }
+ pbox++;
+ pptSrc++;
}
+ pFfb->rp_active = 1;
+ SET_SYNC_FLAG(pFfb->pXAAInfo);
+ } else {
+ unsigned char *sfb32 = (unsigned char *) pFfb->sfb32;
+ int psz_shift = 2;
- /* SRC is the framebuffer, DST is a pixmap */
- if (pDrawable->type == DRAWABLE_WINDOW && w == 1 && h == 1) {
- /* Benchmarks do this make sure the acceleration hardware
- * has completed all of it's operations, therefore I feel
- * it is not cheating to special case this because if
- * anything it gives the benchmarks more accurate results.
- */
- if (pDrawable->bitsPerPixel == 32) {
- unsigned char *sfb = (unsigned char *)pFfb->sfb32;
- unsigned int *dstPixel = (unsigned int *)pdstLine;
- unsigned int tmp;
-
- tmp = *((unsigned int *)(sfb +
- ((sy + pDrawable->y) << 13) +
- ((sx + pDrawable->x) << 2)));
- *dstPixel = (tmp & 0x00ffffff);
- } else {
- unsigned char *sfb = (unsigned char *)pFfb->sfb8r;
- unsigned char *dstPixel = (unsigned char *)pdstLine;
-
- *dstPixel = *((unsigned char *)(sfb +
- ((sy + pDrawable->y) << 11) +
- ((sx + pDrawable->x) << 0)));
+ FFB_ATTR_SFB_VAR_XAA(pFfb, planemask, rop);
+ if (pFfb->use_blkread_prefetch) {
+ unsigned int bit;
+
+ if (xdir < 0)
+ bit = FFB_MER_EDRA;
+ else
+ bit = FFB_MER_EIRA;
+ FFBFifo(pFfb, 1);
+ ffb->mer = bit;
+ pFfb->rp_active = 1;
+ }
+ FFBWait(pFfb, ffb);
+
+ while (nbox--) {
+ unsigned char *src, *dst;
+ int x1, y1, x2, y2;
+ int width, height;
+ int sdkind;
+
+ x1 = pptSrc->x;
+ y1 = pptSrc->y;
+ x2 = pbox->x1;
+ y2 = pbox->y1;
+ width = (pbox->x2 - pbox->x1);
+ height = (pbox->y2 - pbox->y1);
+
+ src = sfb32 + (y1 * (2048 << psz_shift))
+ + (x1 << psz_shift);
+ dst = sfb32 + (y2 * (2048 << psz_shift))
+ + (x2 << psz_shift);
+ sdkind = (2048 << psz_shift);
+
+ if (ydir < 0) {
+ src += ((height - 1) * (2048 << psz_shift));
+ dst += ((height - 1) * (2048 << psz_shift));
+ sdkind = -sdkind;
}
- return;
+ width <<= psz_shift;
+ if (xdir < 0)
+ VISmoveImageRL(src, dst, width, height,
+ sdkind, sdkind);
+ else
+ VISmoveImageLR(src, dst, width, height,
+ sdkind, sdkind);
+ pbox++;
+ pptSrc++;
}
- pPixmap = GetScratchPixmapHeader(pScreen, w, h,
- pDrawable->depth, pDrawable->bitsPerPixel,
- PixmapBytePad(w,pDrawable->depth), (pointer)pdstLine);
- if (!pPixmap)
- return;
- ptSrc.x = sx + pDrawable->x;
- ptSrc.y = sy + pDrawable->y;
- box.x1 = 0;
- box.y1 = 0;
- box.x2 = w;
- box.y2 = h;
- REGION_INIT(pScreen, &rgnDst, &box, 1);
- CreatorDoBitblt(pDrawable, (DrawablePtr)pPixmap, GXcopy, &rgnDst,
- &ptSrc, planeMask);
- REGION_UNINIT(pScreen, &rgnDst);
- FreeScratchPixmapHeader(pPixmap);
- } else
- miGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
+ if (pFfb->use_blkread_prefetch) {
+ FFBFifo(pFfb, 1);
+ ffb->mer = FFB_MER_DRA;
+ pFfb->rp_active = 1;
+ FFBWait(pFfb, ffb);
+ }
+ }
}
-extern void
-CreatorGetSpans(DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
- int *pwidth, int nspans, char *pchardstStart);
-
-void
-CreatorVtChange (ScreenPtr pScreen, int enter)
+void FFB_SetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
+ int xdir, int ydir, int rop,
+ unsigned int planemask,
+ int trans_color)
{
- FFBPtr pFfb = GET_FFB_FROM_SCREEN (pScreen);
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
ffb_fbcPtr ffb = pFfb->regs;
- pFfb->rp_active = 1;
- FFBWait(pFfb, ffb);
- pFfb->fifo_cache = -1;
- pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED |
- FFB_FBC_RB_A | FFB_FBC_SB_BOTH| FFB_FBC_XE_OFF |
- FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_MASK);
- pFfb->ppc_cache = (FFB_PPC_FW_DISABLE |
- FFB_PPC_VCE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST |
- FFB_PPC_XS_CONST | FFB_PPC_YS_CONST | FFB_PPC_ZS_CONST|
- FFB_PPC_DCE_DISABLE | FFB_PPC_ABE_DISABLE | FFB_PPC_TBE_OPAQUE);
-
- pFfb->pmask_cache = ~0;
- pFfb->rop_cache = FFB_ROP_EDIT_BIT;
- pFfb->drawop_cache = FFB_DRAWOP_RECTANGLE;
- pFfb->fg_cache = pFfb->bg_cache = 0;
- pFfb->fontw_cache = 32;
- pFfb->fontinc_cache = (1 << 16) | 0;
- pFfb->laststipple = NULL;
- FFBFifo(pFfb, 9);
- ffb->fbc = pFfb->fbc_cache;
- ffb->ppc = pFfb->ppc_cache;
- ffb->pmask = pFfb->pmask_cache;
- ffb->rop = pFfb->rop_cache;
- ffb->drawop = pFfb->drawop_cache;
- ffb->fg = pFfb->fg_cache;
- ffb->bg = pFfb->bg_cache;
- ffb->fontw = pFfb->fontw_cache;
- ffb->fontinc = pFfb->fontinc_cache;
- pFfb->rp_active = 1;
+ FFBLOG(("FFB_SetupForScreenToScreenCopy: "
+ "xdir[%d] ydir[%d] rop[%d] pmask[%x] tcolor[%d]\n",
+ xdir, ydir, rop, planemask, trans_color));
+
+ pFfb->xaa_planemask = planemask;
+ pFfb->xaa_xdir = xdir;
+ pFfb->xaa_ydir = ydir;
+ pFfb->xaa_rop = rop;
+ FFB_ATTR_SFB_VAR_XAA(pFfb, planemask, rop);
FFBWait(pFfb, ffb);
+}
- /* Fixup the FBC/PPC caches to deal with actually using
- * a WID for every ROP.
- */
- pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED |
- FFB_FBC_RB_A | FFB_FBC_SB_BOTH | FFB_FBC_XE_ON |
- FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_ON);
- pFfb->ppc_cache &= ~FFB_PPC_XS_MASK;
- pFfb->ppc_cache |= FFB_PPC_XS_WID;
- pFfb->wid_cache = 0xff;
- FFBFifo(pFfb, 8);
- ffb->fbc = pFfb->fbc_cache;
- ffb->ppc = FFB_PPC_XS_WID;
- ffb->wid = pFfb->wid_cache;
- ffb->xpmask = 0xff;
- ffb->xclip = FFB_XCLIP_TEST_ALWAYS;
- ffb->cmp = 0x80808080;
- ffb->matchab = 0x80808080;
- ffb->magnab = 0x80808080;
+void FFB_SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn,
+ int x1, int y1,
+ int x2, int y2,
+ int width, int height)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ unsigned char *src, *dst, *sfb32;
+ int psz_shift = 2;
+ int sdkind;
+
+ FFBLOG(("FFB_SubsequentScreenToScreenCopy: "
+ "x1[%d] y1[%d] x2[%d] y2[%u] w[%d] h[%d]\n",
+ x1, y1, x2, y2, width, height));
+
+ sfb32 = (unsigned char *) pFfb->sfb32;
+ src = sfb32 + (y1 * (2048 << psz_shift)) + (x1 << psz_shift);
+ dst = sfb32 + (y2 * (2048 << psz_shift)) + (x2 << psz_shift);
+ sdkind = (2048 << psz_shift);
+
+ if (pFfb->xaa_ydir < 0) {
+ src += ((height - 1) * (2048 << psz_shift));
+ dst += ((height - 1) * (2048 << psz_shift));
+ sdkind = -sdkind;
+ }
+
+ width <<= psz_shift;
+ if (pFfb->xaa_xdir < 0)
+ VISmoveImageRL(src, dst, width, height, sdkind, sdkind);
+ else
+ VISmoveImageLR(src, dst, width, height, sdkind, sdkind);
+}
+
+static void FFB_Sync(ScrnInfoPtr pScrn)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ffb_fbcPtr ffb = pFfb->regs;
+
+ FFB_ATTR_SFB_VAR_XAA(pFfb, 0xffffffff, GXcopy);
FFBWait(pFfb, ffb);
}
@@ -771,36 +844,15 @@
}
}
-static Bool
-CreatorPositionWindow(WindowPtr pWin, int x, int y)
-{
- if (pWin->drawable.bitsPerPixel == 8)
- return cfbPositionWindow(pWin, x, y);
- else
- return cfb32PositionWindow(pWin, x, y);
-}
-
-extern Bool CreatorCreateGC (GCPtr pGC);
-
-#ifdef DEBUG_FFB
-FILE *FDEBUG_FD = NULL;
-#endif
-
-BSFuncRec CreatorBSFuncRec = {
- CreatorSaveAreas,
- CreatorRestoreAreas,
- (BackingStoreSetClipmaskRgnProcPtr) 0,
- (BackingStoreGetImagePixmapProcPtr) 0,
- (BackingStoreGetSpansPixmapProcPtr) 0,
-};
-
-Bool FFBAccelInit (ScreenPtr pScreen, FFBPtr pFfb)
+Bool FFBAccelInit(ScreenPtr pScreen, FFBPtr pFfb)
{
- ffb_fbcPtr ffb;
+ XAAInfoRecPtr infoRec;
+ ffb_fbcPtr ffb = pFfb->regs;
if (serverGeneration != CreatorGeneration) {
CreatorScreenPrivateIndex = AllocateScreenPrivateIndex ();
- if (CreatorScreenPrivateIndex == -1) return FALSE;
+ if (CreatorScreenPrivateIndex == -1)
+ return FALSE;
CreatorGCPrivateIndex = AllocateGCPrivateIndex ();
CreatorWindowPrivateIndex = AllocateWindowPrivateIndex ();
CreatorGeneration = serverGeneration;
@@ -810,32 +862,132 @@
return FALSE;
if (!AllocateWindowPrivate(pScreen, CreatorWindowPrivateIndex, 0))
return FALSE;
+
pScreen->devPrivates[CreatorScreenPrivateIndex].ptr = pFfb;
- pFfb->fifo_cache = 0;
- ffb = pFfb->regs;
+ pFfb->xaa_fbc = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED | FFB_FBC_RB_A |
+ FFB_FBC_WE_FORCEON |
+ FFB_FBC_SB_BOTH |
+ FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF |
+ FFB_FBC_RGBE_MASK |
+ FFB_FBC_XE_ON);
+ pFfb->xaa_wid = FFBWidAlloc(pFfb, TrueColor, 0, TRUE);
+ if (pFfb->xaa_wid == (unsigned int) -1)
+ return FALSE;
- /* Replace various screen functions. */
- pScreen->CreateGC = CreatorCreateGC;
- pScreen->CreateWindow = CreatorCreateWindow;
- pScreen->DestroyWindow = CreatorDestroyWindow;
- pScreen->PositionWindow = CreatorPositionWindow;
- pScreen->ChangeWindowAttributes = CreatorChangeWindowAttributes;
- pScreen->PaintWindowBackground = CreatorPaintWindow;
- pScreen->PaintWindowBorder = CreatorPaintWindow;
- pScreen->GetSpans = CreatorGetSpans;
- pScreen->CopyWindow = CreatorCopyWindow;
- pScreen->GetImage = CreatorGetImage;
- pScreen->BackingStoreFuncs = CreatorBSFuncRec;
+ pFfb->pXAAInfo = infoRec = XAACreateInfoRec();
+ if (!infoRec) {
+ FFBWidFree(pFfb, pFfb->xaa_wid);
+ return FALSE;
+ }
- /* cfb8_32wid took over this to init the WID plane,
- * and with how our code works that is not necessary.
- */
- pScreen->WindowExposures = miWindowExposures;
+ pFfb->xaa_scanline_buffers[0] = xalloc(2048 * 4);
+ if (!pFfb->xaa_scanline_buffers[0]) {
+ XAADestroyInfoRec(infoRec);
+ return FALSE;
+ }
- /* Set FFB line-bias for clipping. */
+ pFfb->xaa_scanline_buffers[1] = xalloc(2048 * 4);
+ if (!pFfb->xaa_scanline_buffers[1]) {
+ xfree(pFfb->xaa_scanline_buffers[0]);
+ XAADestroyInfoRec(infoRec);
+ return FALSE;
+ }
+
+ infoRec->Sync = FFB_Sync;
+
+ /* Use VIS and VSCROLL for screen to screen copies. */
+ infoRec->ScreenToScreenCopyFlags = NO_TRANSPARENCY;
+ infoRec->SetupForScreenToScreenCopy =
+ FFB_SetupForScreenToScreenCopy;
+ infoRec->SubsequentScreenToScreenCopy =
+ FFB_SubsequentScreenToScreenCopy;
+
+ /* In order to optimize VSCROLL and prefetching properly we
+ * have to use our own mid-layer routine.
+ */
+ infoRec->ScreenToScreenBitBltFlags = NO_TRANSPARENCY;
+ infoRec->ScreenToScreenBitBlt =
+ FFB_ScreenToScreenBitBlt;
+
+ infoRec->SolidFillFlags = 0;
+ infoRec->SetupForSolidFill =
+ FFB_SetupForSolidFill;
+ infoRec->SubsequentSolidFillRect =
+ FFB_SubsequentSolidFillRect;
+
+ infoRec->SolidLineFlags = 0;
+ infoRec->SetupForSolidLine =
+ FFB_SetupForSolidLine;
+ infoRec->SubsequentSolidTwoPointLine =
+ FFB_SubsequentSolidTwoPointLine;
miSetZeroLineBias(pScreen, OCTANT3 | OCTANT4 | OCTANT6 | OCTANT1);
+ infoRec->DashedLineFlags = (TRANSPARENCY_ONLY |
+ LINE_PATTERN_LSBFIRST_LSBJUSTIFIED);
+ infoRec->DashPatternMaxLength = 16;
+ infoRec->SetupForDashedLine =
+ FFB_SetupForDashedLine;
+ infoRec->SubsequentDashedTwoPointLine =
+ FFB_SubsequentDashedTwoPointLine;
+
+ /* We cannot use the non-scanline color expansion mechanism on FFB
+ * for two reasons:
+ *
+ * 1) A render pass can only render 32-pixels wide on FFB, XAA expects
+ * that arbitrary widths are possible per render pass.
+ *
+ * 2) The FFB accelerator FIFO is only 100 or so words deep, and
+ * XAA gives no way to limit the number of words it writes into
+ * the ColorExpandBase register per rendering pass.
+ */
+ infoRec->ScanlineColorExpandBuffers = pFfb->xaa_scanline_buffers;
+ infoRec->NumScanlineColorExpandBuffers = 2;
+ infoRec->ScanlineCPUToScreenColorExpandFillFlags =
+ CPU_TRANSFER_PAD_DWORD |
+ SCANLINE_PAD_DWORD |
+ CPU_TRANSFER_BASE_FIXED |
+ BIT_ORDER_IN_BYTE_LSBFIRST;
+ infoRec->SetupForScanlineCPUToScreenColorExpandFill =
+ FFB_SetupForScanlineCPUToScreenColorExpandFill;
+ infoRec->SubsequentScanlineCPUToScreenColorExpandFill =
+ FFB_SubsequentScanlineCPUToScreenColorExpandFill;
+ infoRec->SubsequentColorExpandScanline =
+ FFB_SubsequentColorExpandScanline;
+
+ infoRec->Mono8x8PatternFillFlags =
+ HARDWARE_PATTERN_PROGRAMMED_BITS |
+ HARDWARE_PATTERN_SCREEN_ORIGIN |
+ BIT_ORDER_IN_BYTE_LSBFIRST;
+ infoRec->SetupForMono8x8PatternFill =
+ FFB_SetupForMono8x8PatternFill;
+ infoRec->SubsequentMono8x8PatternFillRect =
+ FFB_SubsequentMono8x8PatternFillRect;
+
+ /* Use VIS for pixmap writes. */
+ infoRec->WritePixmap = FFB_WritePixmap;
+
+ /* RENDER optimizations. */
+ infoRec->CPUToScreenAlphaTextureFlags =
+ XAA_RENDER_NO_TILE |
+ XAA_RENDER_NO_SRC_ALPHA;
+ infoRec->CPUToScreenAlphaTextureFormats = FFBAlphaTextureFormats;
+ infoRec->SetupForCPUToScreenAlphaTexture =
+ FFB_SetupForCPUToScreenAlphaTexture;
+ infoRec->SubsequentCPUToScreenAlphaTexture =
+ FFB_SubsequentCPUToScreenAlphaTexture;
+
+ infoRec->CPUToScreenTextureFlags =
+ XAA_RENDER_NO_TILE |
+ XAA_RENDER_NO_SRC_ALPHA;
+ infoRec->CPUToScreenTextureFormats = FFBTextureFormats;
+ infoRec->SetupForCPUToScreenTexture =
+ FFB_SetupForCPUToScreenTexture;
+ infoRec->SubsequentCPUToScreenTexture =
+ FFB_SubsequentCPUToScreenTexture;
+
+ pFfb->fifo_cache = 0;
+
FFB_DEBUG_init();
FDEBUG((FDEBUG_FD,
"FFB: cfg0(%08x) cfg1(%08x) cfg2(%08x) cfg3(%08x) ppcfg(%08x)\n",
@@ -904,26 +1056,31 @@
pFfb->ppc_cache = (FFB_PPC_FW_DISABLE |
FFB_PPC_VCE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST |
- FFB_PPC_XS_CONST | FFB_PPC_YS_CONST | FFB_PPC_ZS_CONST |
+ FFB_PPC_XS_WID | FFB_PPC_YS_CONST | FFB_PPC_ZS_CONST |
FFB_PPC_DCE_DISABLE | FFB_PPC_ABE_DISABLE | FFB_PPC_TBE_OPAQUE);
-
+ pFfb->wid_cache = pFfb->xaa_wid;
pFfb->pmask_cache = ~0;
- pFfb->rop_cache = (FFB_ROP_ZERO | (FFB_ROP_NEW << 8));
+ pFfb->rop_cache = (FFB_ROP_NEW | (FFB_ROP_NEW << 8));
pFfb->drawop_cache = FFB_DRAWOP_RECTANGLE;
pFfb->fg_cache = pFfb->bg_cache = 0;
pFfb->fontw_cache = 32;
pFfb->fontinc_cache = (1 << 16) | 0;
- pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED |
- FFB_FBC_RB_A | FFB_FBC_SB_BOTH | FFB_FBC_XE_OFF |
- FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_MASK);
+ pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED | FFB_FBC_RB_A |
+ FFB_FBC_WE_FORCEON |
+ FFB_FBC_SB_BOTH |
+ FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF |
+ FFB_FBC_RGBE_OFF |
+ FFB_FBC_XE_ON);
pFfb->laststipple = NULL;
/* We will now clear the screen: we'll draw a rectangle covering all the
* viewscreen, using a 'blackness' ROP.
*/
- FFBFifo(pFfb, 13);
+ FFBFifo(pFfb, 22);
ffb->fbc = pFfb->fbc_cache;
ffb->ppc = pFfb->ppc_cache;
+ ffb->wid = pFfb->wid_cache;
+ ffb->xpmask = 0xff;
ffb->pmask = pFfb->pmask_cache;
ffb->rop = pFfb->rop_cache;
ffb->drawop = pFfb->drawop_cache;
@@ -931,31 +1088,32 @@
ffb->bg = pFfb->bg_cache;
ffb->fontw = pFfb->fontw_cache;
ffb->fontinc = pFfb->fontinc_cache;
+ ffb->xclip = FFB_XCLIP_TEST_ALWAYS;
+ ffb->cmp = 0x80808080;
+ ffb->matchab = 0x80808080;
+ ffb->magnab = 0x80808080;
+ ffb->blendc = (FFB_BLENDC_FORCE_ONE |
+ FFB_BLENDC_DF_ONE_M_A |
+ FFB_BLENDC_SF_A);
+ ffb->blendc1 = 0;
+ ffb->blendc2 = 0;
FFB_WRITE64(&ffb->by, 0, 0);
FFB_WRITE64_2(&ffb->bh, pFfb->psdp->height, pFfb->psdp->width);
pFfb->rp_active = 1;
FFBWait(pFfb, ffb);
- /* Fixup the FBC/PPC caches to deal with actually using
- * a WID for every ROP.
- */
- pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED |
- FFB_FBC_RB_A | FFB_FBC_SB_BOTH | FFB_FBC_XE_ON |
- FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_ON);
- pFfb->ppc_cache &= ~FFB_PPC_XS_MASK;
- pFfb->ppc_cache |= FFB_PPC_XS_WID;
- pFfb->wid_cache = 0xff;
- FFBFifo(pFfb, 8);
- ffb->fbc = pFfb->fbc_cache;
- ffb->ppc = FFB_PPC_XS_WID;
- ffb->wid = pFfb->wid_cache;
- ffb->xpmask = 0xff;
- ffb->xclip = FFB_XCLIP_TEST_ALWAYS;
- ffb->cmp = 0x80808080;
- ffb->matchab = 0x80808080;
- ffb->magnab = 0x80808080;
+ FFB_ATTR_SFB_VAR_XAA(pFfb, 0xffffffff, GXcopy);
FFBWait(pFfb, ffb);
+ if (!XAAInit(pScreen, infoRec)) {
+ XAADestroyInfoRec(infoRec);
+ xfree(pFfb->xaa_scanline_buffers[0]);
+ xfree(pFfb->xaa_scanline_buffers[1]);
+ pFfb->pXAAInfo = NULL;
+ FFBWidFree(pFfb, pFfb->xaa_wid);
+ return FALSE;
+ }
+
/* Success */
return TRUE;
}
diff -urN xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_bcopy.c xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_bcopy.c
--- xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_bcopy.c 2000-05-23 00:47:44.000000000 -0400
+++ xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_bcopy.c 2004-06-10 23:38:50.742533680 -0400
@@ -382,7 +382,6 @@
if (use_prefetch) {
FFBFifo(pFfb, 1);
pFfb->regs->mer = FFB_MER_EDRA;
- pFfb->regs->mer = FFB_MER_EIRA;
pFfb->rp_active = 1;
}
VISmoveImageRL ((psrcBase +
diff -urN xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_dga.c xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_dga.c
--- xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_dga.c 2000-10-17 12:53:17.000000000 -0400
+++ xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_dga.c 2004-06-10 23:38:50.746533072 -0400
@@ -35,30 +35,16 @@
#include "ffb_stip.h"
#include "ffb_loops.h"
-static Bool FFB_OpenFramebuffer(ScrnInfoPtr pScrn, char **name, unsigned char **mem,
- int *size, int *offset, int *extra);
-static void FFB_CloseFramebuffer(ScrnInfoPtr pScrn);
-static Bool FFB_SetMode(ScrnInfoPtr pScrn, DGAModePtr pMode);
-static void FFB_SetViewport(ScrnInfoPtr pScrn, int x, int y, int flags);
-static int FFB_GetViewport(ScrnInfoPtr pScrn);
-static void FFB_Flush(ScrnInfoPtr pScrn);
-
-/* Have to disable all this stuff for now until I figure out where
- * we should get the WID values from... ho hum... -DaveM
- */
-#if 0
-static void FFB_FillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned long color);
-
-#ifdef USE_VIS
-static void FFB_BlitRect(ScrnInfoPtr pScrn, int srcx, int srcy, int w, int h,
- int dstx, int dsty);
-#else
-#define FFB_BlitRect NULL
-#endif
-#else
-#define FFB_FillRect NULL
-#define FFB_BlitRect NULL
-#endif
+static Bool FFB_OpenFramebuffer(ScrnInfoPtr, char **, unsigned char **,
+ int *, int *, int *);
+static void FFB_CloseFramebuffer(ScrnInfoPtr);
+static Bool FFB_SetMode(ScrnInfoPtr, DGAModePtr);
+static void FFB_SetViewport(ScrnInfoPtr, int, int, int);
+static int FFB_GetViewport(ScrnInfoPtr);
+static void FFB_Flush(ScrnInfoPtr);
+static void FFB_FillRect(ScrnInfoPtr, int, int, int, int, unsigned long);
+static void FFB_BlitRect(ScrnInfoPtr, int, int, int, int,
+ int, int);
static DGAFunctionRec FFB_DGAFuncs = {
FFB_OpenFramebuffer,
@@ -93,10 +79,7 @@
/* Hmmm, what does concurrent access really mean? -DaveM */
mode->flags = (DGA_CONCURRENT_ACCESS | DGA_PIXMAP_AVAILABLE | DGA_FILL_RECT);
-
-#ifdef USE_VIS
mode->flags |= DGA_BLIT_RECT;
-#endif
mode->imageWidth = 2048;
mode->imageHeight = 2048;
@@ -195,86 +178,31 @@
FFBWait(pFfb, ffb);
}
-#if 0
-
-extern void CreatorFillBoxSolid (DrawablePtr pDrawable, int nBox,
- BoxPtr pBox, unsigned long pixel);
+extern void FFB_SetupForSolidFill(ScrnInfoPtr, int, int, unsigned int);
+extern void FFB_SubsequentSolidFillRect(ScrnInfoPtr, int, int, int, int);
static void FFB_FillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned long color)
{
- DrawableRec draw;
- BoxRec box;
-
- draw.pScreen = pScrn->pScreen;
- box.x1 = x;
- box.y1 = y;
- box.x2 = x + w;
- box.y2 = y + h;
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
- CreatorFillBoxSolid(&draw, 1, &box, color);
+ FFB_SetupForSolidFill(pScrn, color, GXcopy, ~0);
+ FFB_SubsequentSolidFillRect(pScrn, x, y, w, h);
+ SET_SYNC_FLAG(pFfb->pXAAInfo);
}
-#ifdef USE_VIS
-extern void VISmoveImageLR(unsigned char *, unsigned char *, long, long, long, long);
-extern void VISmoveImageRL(unsigned char *, unsigned char *, long, long, long, long);
+extern void FFB_SetupForScreenToScreenCopy(ScrnInfoPtr, int, int, int,
+ unsigned int, int);
+extern void FFB_SubsequentScreenToScreenCopy(ScrnInfoPtr, int, int,
+ int, int, int, int);
static void FFB_BlitRect(ScrnInfoPtr pScrn, int srcx, int srcy,
int w, int h, int dstx, int dsty)
{
FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
- ffb_fbcPtr ffb = pFfb->regs;
-
- if (!pFfb->disable_vscroll &&
- dstx == srcx &&
- dsty != dsty) {
- FFB_WRITE_ATTRIBUTES_VSCROLL(pFfb, 0x00ffffff);
- FFBFifo(pFfb, 7);
- ffb->drawop = FFB_DRAWOP_VSCROLL;
- FFB_WRITE64(&ffb->by, srcy, srcx);
- FFB_WRITE64_2(&ffb->dy, dsty, dstx);
- FFB_WRITE64_3(&ffb->bh, h, w);
- pFfb->rp_active = 1;
- } else {
- unsigned char *base = (unsigned char *)pFfb->fb;
- int use_prefetch = pFfb->use_blkread_prefetch;
+ int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
+ int ydir = (srcy < dsty) ? -1 : 1;
- FFB_WRITE_ATTRIBUTES_SFB_VAR(pFfb, 0x00ffffff, GXcopy);
- FFBWait(pFfb, ffb);
- if (use_prefetch) {
- FFBFifo(pFfb, 1);
- ffb->mer = FFB_MER_EIRA;
- pFfb->rp_active = 1;
- FFBWait(pFfb, ffb);
- }
- if (srcx < dstx) {
- VISmoveImageRL((base +
- ((srcy + h - 1) * (2048 * 4)) +
- (srcx * (32 / 8))),
- (base +
- ((dsty + h - 1) * (2048 * 4)) +
- (dstx * (32 / 8))),
- (w * (32 / 8)),
- h,
- -(2048 * 4), - (2048 * 4));
- } else {
- VISmoveImageLR((base +
- ((srcy + h - 1) * (2048 * 4)) +
- (srcx * (32 / 8))),
- (base +
- ((dsty + h - 1) * (2048 * 4)) +
- (dstx * (32 / 8))),
- (w * (32 / 8)),
- h,
- -(2048 * 4), - (2048 * 4));
- }
- if (use_prefetch) {
- FFBFifo(pFfb, 1);
- ffb->mer = FFB_MER_DRA;
- pFfb->rp_active = 1;
- FFBWait(pFfb, pFfb->regs);
- }
- }
+ FFB_SetupForScreenToScreenCopy(pScrn, xdir, ydir, GXcopy, ~0, -1);
+ FFB_SubsequentScreenToScreenCopy(pScrn, srcx, srcy, dstx,dsty, w, h);
+ SET_SYNC_FLAG(pFfb->pXAAInfo);
}
-#endif
-
-#endif
diff -urN xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_driver.c xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_driver.c
--- xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_driver.c 2002-12-05 21:44:04.000000000 -0500
+++ xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_driver.c 2004-06-10 23:38:50.768529728 -0400
@@ -29,12 +29,7 @@
#include "mipointer.h"
#include "mibstore.h"
#include "micmap.h"
-
-#define PSZ 8
-#include "cfb.h"
-#undef PSZ
-#include "cfb32.h"
-#include "cfb8_32wid.h"
+#include "fb.h"
#include "xf86cmap.h"
@@ -50,6 +45,7 @@
static void FFBLeaveVT(int scrnIndex, int flags);
static Bool FFBCloseScreen(int scrnIndex, ScreenPtr pScreen);
static Bool FFBSaveScreen(ScreenPtr pScreen, int mode);
+static void FFBDPMSSet(ScrnInfoPtr pScrn, int mode, int flags);
/* Required if the driver supports mode switching */
static Bool FFBSwitchMode(int scrnIndex, DisplayModePtr mode, int flags);
@@ -416,12 +412,12 @@
return FALSE;
}
- if (xf86LoadSubModule(pScrn, "cfb32") == NULL) {
+ if (xf86LoadSubModule(pScrn, "fb") == NULL) {
FFBFreeRec(pScrn);
return FALSE;
}
- if (xf86LoadSubModule(pScrn, "cfb") == NULL) {
+ if (xf86LoadSubModule(pScrn, "xaa") == NULL) {
FFBFreeRec(pScrn);
return FALSE;
}
@@ -570,8 +566,6 @@
pFfb->has_z_buffer = 0;
}
if (sbits & (1 << 0)) {
- ErrorF("Double-buffered.\n");
-
/* This state really means to the driver that the double
* buffers are available for hw accelerate Dbe. When the
* FFB is in high-resolution mode, the buffers are combined
@@ -581,86 +575,17 @@
if ((ffb->fbcfg0 & FFB_FBCFG0_RES_MASK) != FFB_FBCFG0_RES_HIGH)
pFfb->has_double_buffer = 1;
else
- pFfb->has_double_buffer = 1;
+ pFfb->has_double_buffer = 0;
} else {
- ErrorF("Single-buffered.\n");
pFfb->has_double_buffer = 0;
}
+ if (pFfb->has_double_buffer)
+ ErrorF("Double-buffered.\n");
+ else
+ ErrorF("Single-buffered.\n");
}
}
-static unsigned long CreatorUnaccelGeneration = 0;
-static int CreatorUnaccelWindowPrivateIndex;
-
-#define CreatorUnaccelGetWid(w) \
- ((w)->devPrivates[CreatorUnaccelWindowPrivateIndex].val)
-#define CreatorUnaccelSetWid(w,wid) \
- (((w)->devPrivates[CreatorUnaccelWindowPrivateIndex].val) = (wid))
-
-static unsigned int
-CreatorWidGet(WindowPtr pWin)
-{
- return CreatorUnaccelGetWid(pWin);
-}
-
-static Bool
-CreatorWidAlloc(WindowPtr pWin)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
- FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
- unsigned int wid;
- int i, visual, visclass;
-
- visual = wVisual(pWin);
- visclass = 0;
- for (i = 0; i < pScreen->numVisuals; i++) {
- if (pScreen->visuals[i].vid == visual) {
- visclass = pScreen->visuals[i].class;
- break;
- }
- }
-
- wid = FFBWidAlloc(pFfb, visclass, wColormap(pWin), TRUE);
- if (wid == (unsigned int) -1)
- return FALSE;
-
- CreatorUnaccelSetWid(pWin, wid);
-
- return TRUE;
-}
-
-static void
-CreatorWidFree(WindowPtr pWin)
-{
- ScrnInfoPtr pScrn = xf86Screens[pWin->drawable.pScreen->myNum];
- FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
- unsigned int wid = CreatorUnaccelGetWid(pWin);
-
- FFBWidFree(pFfb, wid);
-}
-
-static cfb8_32WidOps CreatorUnaccelWidOps = {
- CreatorWidGet,
- CreatorWidAlloc,
- CreatorWidFree,
- NULL,
- NULL
-};
-
-static Bool
-CreatorUnaccelWidInit(ScreenPtr pScreen)
-{
- if (serverGeneration != CreatorUnaccelGeneration) {
- CreatorUnaccelWindowPrivateIndex =
- AllocateWindowPrivateIndex();
- if (CreatorUnaccelWindowPrivateIndex == -1)
- return FALSE;
- }
-
- return TRUE;
-}
-
/* Mandatory */
/* This gets called at the start of each server generation */
@@ -674,10 +599,6 @@
unsigned int afb_fem;
VisualPtr visual;
- /* Add in our Dbe hook. */
- if (!FFBDbePreInit(pScreen))
- return FALSE;
-
/*
* First get the ScrnInfoRec
*/
@@ -797,11 +718,6 @@
/* Darken the screen for aesthetic reasons and set the viewport */
FFBSaveScreen(pScreen, SCREEN_SAVER_ON);
- if (pFfb->NoAccel == TRUE) {
- if (!CreatorUnaccelWidInit(pScreen))
- return FALSE;
- }
-
/*
* The next step is to setup the screen's visuals, and initialise the
* framebuffer code. In cases where the framebuffer's default
@@ -817,14 +733,14 @@
miClearVisualTypes();
/* Setup the visuals we support. */
- if (!miSetVisualTypes(24, TrueColorMask | DirectColorMask,
+ if (!miSetVisualTypes(24, TrueColorMask,
pScrn->rgbBits, TrueColor))
return FALSE;
- if (!miSetVisualTypes(8, PseudoColorMask | GrayScaleMask | StaticGrayMask,
- pScrn->rgbBits, PseudoColor))
- return FALSE;
-#ifdef XF86DRI
+ if (!miSetPixmapDepths())
+ return FALSE;
+
+#if 0 /*def XF86DRI*/
if (pFfb->ffb_type != afb_m3 && pFfb->ffb_type != afb_m6 &&
pFfb->NoAccel == FALSE) {
pFfb->dri_enabled = FFBDRIScreenInit(pScreen);
@@ -843,30 +759,14 @@
* Call the framebuffer layer's ScreenInit function, and fill in other
* pScreen fields.
*/
- if (pFfb->NoAccel == TRUE) {
- ret = cfb8_32WidScreenInit(pScreen, pFfb->dfb24, pFfb->dfb8r, pFfb->dfb8x,
- pScrn->virtualX, pScrn->virtualY,
- pScrn->xDpi, pScrn->yDpi,
- 2048, 2048, 2048, 8,
- &CreatorUnaccelWidOps);
- } else {
- /* Use smart framebuffer aperture for cfb8/cfb32. */
- ret = cfb8_32WidScreenInit(pScreen, pFfb->sfb32, pFfb->sfb8r, pFfb->dfb8x,
- pScrn->virtualX, pScrn->virtualY,
- pScrn->xDpi, pScrn->yDpi,
- 2048, 2048, 2048, 8,
- &CreatorUnaccelWidOps);
- }
+ ret = fbScreenInit(pScreen, (pFfb->NoAccel ? pFfb->dfb24 : pFfb->sfb32),
+ pScrn->virtualX, pScrn->virtualY,
+ pScrn->xDpi, pScrn->yDpi,
+ 2048, 32);
if (!ret)
return FALSE;
- miInitializeBackingStore(pScreen);
- xf86SetBackingStore(pScreen);
- xf86SetSilkenMouse(pScreen);
-
- xf86SetBlackWhitePixels(pScreen);
-
if (pScrn->bitsPerPixel > 8) {
/* Fixup RGB ordering */
visual = pScreen->visuals + pScreen->numVisuals;
@@ -882,12 +782,24 @@
}
}
+ if (!fbPictureInit(pScreen, NULL, 0) &&
+ (serverGeneration == 1))
+ xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+ "RENDER extension initialisation failed.\n");
+
+ xf86SetBlackWhitePixels(pScreen);
+
if (!pFfb->NoAccel) {
if (!FFBAccelInit(pScreen, pFfb))
return FALSE;
xf86Msg(X_INFO, "%s: Using acceleration\n", pFfb->psdp->device);
}
+
+ miInitializeBackingStore(pScreen);
+ xf86SetBackingStore(pScreen);
+ xf86SetSilkenMouse(pScreen);
+
/* Initialise cursor functions */
miDCInitialize (pScreen, xf86GetPointerScreenFuncs());
@@ -912,9 +824,6 @@
*/
if (!xf86HandleColormaps(pScreen, 256, 8,
FFBDacLoadPalette, NULL,
-#if 0
- CMAP_PALETTED_TRUECOLOR |
-#endif
CMAP_LOAD_EVEN_IF_OFFSCREEN |
CMAP_RELOAD_ON_MODE_SWITCH))
return FALSE;
@@ -923,9 +832,9 @@
if (!pFfb->NoAccel)
FFB_InitDGA(pScreen);
-#ifdef XF86DRI
+#if 0 /*def XF86DRI*/
if (pFfb->dri_enabled) {
- /* Now that mi, cfb, drm and others have done their thing,
+ /* Now that mi, fb, drm and others have done their thing,
* complete the DRI setup.
*/
pFfb->dri_enabled = FFBDRIFinishScreenInit(pScreen);
@@ -938,6 +847,8 @@
}
#endif
+ xf86DPMSInit(pScreen, FFBDPMSSet, 0);
+
pFfb->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = FFBCloseScreen;
pScreen->SaveScreen = FFBSaveScreen;
@@ -1034,34 +945,34 @@
static Bool
FFBCloseScreen(int scrnIndex, ScreenPtr pScreen)
{
- ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
- FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+ ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
-#ifdef XF86DRI
- if (pFfb->dri_enabled)
- FFBDRICloseScreen(pScreen);
+#if 0 /*def XF86DRI*/
+ if (pFfb->dri_enabled)
+ FFBDRICloseScreen(pScreen);
#endif
- /* Restore kernel ramdac state before we unmap registers. */
- FFBDacFini(pFfb);
+ /* Restore kernel ramdac state before we unmap registers. */
+ FFBDacFini(pFfb);
- pScrn->vtSema = FALSE;
+ pScrn->vtSema = FALSE;
- xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb24, 0x1000000);
- xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8r, 0x400000);
- xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8x, 0x400000);
- xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb32, 0x1000000);
- xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8r, 0x400000);
- xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8x, 0x400000);
- xf86UnmapSbusMem(pFfb->psdp, pFfb->regs, 16384);
- xf86UnmapSbusMem(pFfb->psdp, pFfb->dac, 8192);
- xf86UnmapSbusMem(pFfb->psdp, (void *)pFfb->strapping_bits, 8192);
+ xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb24, 0x1000000);
+ xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8r, 0x400000);
+ xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8x, 0x400000);
+ xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb32, 0x1000000);
+ xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8r, 0x400000);
+ xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8x, 0x400000);
+ xf86UnmapSbusMem(pFfb->psdp, pFfb->regs, 16384);
+ xf86UnmapSbusMem(pFfb->psdp, pFfb->dac, 8192);
+ xf86UnmapSbusMem(pFfb->psdp, (void *)pFfb->strapping_bits, 8192);
- if (pFfb->HWCursor)
- xf86SbusHideOsHwCursor (pFfb->psdp);
+ if (pFfb->HWCursor)
+ xf86SbusHideOsHwCursor (pFfb->psdp);
- pScreen->CloseScreen = pFfb->CloseScreen;
- return (*pScreen->CloseScreen)(scrnIndex, pScreen);
+ pScreen->CloseScreen = pFfb->CloseScreen;
+ return (*pScreen->CloseScreen)(scrnIndex, pScreen);
}
@@ -1071,7 +982,7 @@
static void
FFBFreeScreen(int scrnIndex, int flags)
{
- FFBFreeRec(xf86Screens[scrnIndex]);
+ FFBFreeRec(xf86Screens[scrnIndex]);
}
@@ -1081,10 +992,10 @@
static int
FFBValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
{
- if (mode->Flags & V_INTERLACE)
- return(MODE_BAD);
+ if (mode->Flags & V_INTERLACE)
+ return MODE_BAD;
- return(MODE_OK);
+ return MODE_OK;
}
/* Do screen blanking */
@@ -1102,6 +1013,14 @@
return FFBDacSaveScreen(GET_FFB_FROM_SCREEN(pScreen), mode);
}
+static void
+FFBDPMSSet(ScrnInfoPtr pScrn, int mode, int flags)
+{
+ FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+
+ FFBDacDPMSMode(pFfb, mode, 0);
+}
+
/*
* This is the implementation of the Sync() function.
*/
diff -urN xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_rcache.h xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_rcache.h
--- xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_rcache.h 2000-05-23 00:47:45.000000000 -0400
+++ xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_rcache.h 2004-06-10 23:38:50.762530640 -0400
@@ -41,13 +41,13 @@
* a nice idea...
*/
#define FFB_WRITE_PPC(__fpriv, __ffb, __val, __chg_mask) \
-do { unsigned int oldval = (__fpriv)->ppc_cache; \
+do { unsigned int __oldval = (__fpriv)->ppc_cache; \
unsigned int __t; \
- __t = (oldval & (__chg_mask)) ^ (__val); \
+ __t = (__oldval & (__chg_mask)) ^ (__val); \
if (__t) { \
- unsigned int newval = oldval & ~(__chg_mask); \
- newval |= (__val); \
- (__fpriv)->ppc_cache = newval; \
+ unsigned int __newval = __oldval & ~(__chg_mask); \
+ __newval |= (__val); \
+ (__fpriv)->ppc_cache = __newval; \
FFBFifo((__fpriv), 1); \
(__ffb)->ppc = (__val); \
} \
@@ -178,22 +178,22 @@
#define FFB_ATTR_FFWIN(__fpriv, __pwin, __ppc, __pixel) \
do { CreatorPrivWinPtr __winpriv = CreatorGetWindowPrivate(__pwin); \
unsigned int ___ppc = (__ppc) | FFB_PPC_XS_WID; \
- unsigned int fbc = (__winpriv)->fbc_base; \
- unsigned int rop = (FFB_ROP_NEW|(FFB_ROP_NEW<<8)); \
+ unsigned int __fbc = (__winpriv)->fbc_base; \
+ unsigned int __rop = (FFB_ROP_NEW|(FFB_ROP_NEW<<8)); \
if((__fpriv)->has_double_buffer) { \
- fbc &= ~FFB_FBC_WB_MASK; \
- fbc |= FFB_FBC_WB_AB; \
+ __fbc &= ~FFB_FBC_WB_MASK; \
+ __fbc |= FFB_FBC_WB_AB; \
} \
- fbc &= ~(FFB_FBC_XE_MASK | FFB_FBC_RGBE_MASK); \
- fbc |= FFB_FBC_XE_ON | FFB_FBC_RGBE_ON; \
+ __fbc &= ~(FFB_FBC_XE_MASK | FFB_FBC_RGBE_MASK); \
+ __fbc |= FFB_FBC_XE_ON | FFB_FBC_RGBE_ON; \
if (pFfb->ffb_res == ffb_res_high) \
- fbc |= FFB_FBC_WB_B; \
+ __fbc |= FFB_FBC_WB_B; \
if ((((__fpriv)->ppc_cache & FFB_PPC_WINMASK) != (___ppc))|| \
((__fpriv)->pmask_cache != 0x00ffffff) || \
- ((__fpriv)->rop_cache!= rop) || \
+ ((__fpriv)->rop_cache!= __rop) || \
((__fpriv)->drawop_cache != FFB_DRAWOP_FASTFILL) || \
((__fpriv)->fg_cache != (__pixel)) || \
- ((__fpriv)->fbc_cache != fbc) || \
+ ((__fpriv)->fbc_cache != __fbc) || \
((__fpriv)->wid_cache != ((__winpriv)->wid))) \
__FFB_Attr_FastfillWin(__fpriv, __pwin, ___ppc, __pixel);\
} while (0)
@@ -215,29 +215,29 @@
FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_ON)
#define FFB_ATTR_SFB_VAR_WINCOPY(__fpriv) \
-do { unsigned int ppc = FFB_PPC_WINCOPY; \
- unsigned int ppc_mask = FFB_PPC_WINCOPY_MASK; \
- unsigned int rop = FFB_ROP_NEW|(FFB_ROP_NEW<<8); \
- unsigned int fbc = FFB_FBC_WINCOPY; \
+do { unsigned int __ppc = FFB_PPC_WINCOPY; \
+ unsigned int __ppc_mask = FFB_PPC_WINCOPY_MASK; \
+ unsigned int __rop = FFB_ROP_NEW|(FFB_ROP_NEW<<8); \
+ unsigned int __fbc = FFB_FBC_WINCOPY; \
if((__fpriv)->has_double_buffer) { \
- fbc &= ~FFB_FBC_WB_MASK; \
- fbc |= FFB_FBC_WB_AB; \
+ __fbc &= ~FFB_FBC_WB_MASK; \
+ __fbc |= FFB_FBC_WB_AB; \
} \
- if (((__fpriv)->ppc_cache & ppc_mask) != ppc || \
- (__fpriv)->fbc_cache != fbc || \
- (__fpriv)->rop_cache != rop || \
+ if (((__fpriv)->ppc_cache & __ppc_mask) != __ppc || \
+ (__fpriv)->fbc_cache != __fbc || \
+ (__fpriv)->rop_cache != __rop || \
(__fpriv)->pmask_cache != 0xffffffff) { \
ffb_fbcPtr __ffb = (__fpriv)->regs; \
- (__fpriv)->ppc_cache &= ~ppc_mask; \
- (__fpriv)->ppc_cache |= ppc; \
- (__fpriv)->fbc_cache = fbc; \
- (__fpriv)->rop_cache = rop; \
+ (__fpriv)->ppc_cache &= ~__ppc_mask; \
+ (__fpriv)->ppc_cache |= __ppc; \
+ (__fpriv)->fbc_cache = __fbc; \
+ (__fpriv)->rop_cache = __rop; \
(__fpriv)->pmask_cache = 0xffffffff; \
(__fpriv)->rp_active = 1; \
FFBFifo(__fpriv, 4); \
- (__ffb)->ppc = ppc; \
- (__ffb)->fbc = fbc; \
- (__ffb)->rop = rop; \
+ (__ffb)->ppc = __ppc; \
+ (__ffb)->fbc = __fbc; \
+ (__ffb)->rop = __rop; \
(__ffb)->pmask = 0xffffffff; \
(__fpriv)->rp_active = 1; \
} \
@@ -247,21 +247,21 @@
unsigned int wid, unsigned int rop, unsigned int pmask);
#define FFB_ATTR_SFB_VAR_WIN(__fpriv, __pmask, __alu, __pwin) \
-do { unsigned int ppc = FFB_PPC_APE_DISABLE | FFB_PPC_CS_VAR | FFB_PPC_XS_WID; \
- unsigned int ppc_mask = FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK; \
- unsigned int rop = (FFB_ROP_EDIT_BIT | (__alu))|(FFB_ROP_NEW<<8); \
- unsigned int fbc = FFB_FBC_WIN(__pwin); \
+do { unsigned int __ppc = FFB_PPC_APE_DISABLE | FFB_PPC_CS_VAR | FFB_PPC_XS_WID; \
+ unsigned int __ppc_mask = FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK; \
+ unsigned int __rop = (FFB_ROP_EDIT_BIT | (__alu))|(FFB_ROP_NEW<<8); \
+ unsigned int __fbc = FFB_FBC_WIN(__pwin); \
if((__fpriv)->has_double_buffer) { \
- fbc &= ~FFB_FBC_WB_MASK; \
- fbc |= FFB_FBC_WB_AB; \
+ __fbc &= ~FFB_FBC_WB_MASK; \
+ __fbc |= FFB_FBC_WB_AB; \
} \
- if(((__fpriv)->ppc_cache & ppc_mask) != ppc || \
- (__fpriv)->fbc_cache != fbc || \
+ if(((__fpriv)->ppc_cache & __ppc_mask) != __ppc || \
+ (__fpriv)->fbc_cache != __fbc || \
(__fpriv)->wid_cache != FFB_WID_WIN(__pwin) || \
- (__fpriv)->rop_cache != rop || \
+ (__fpriv)->rop_cache != __rop || \
(__fpriv)->pmask_cache != (__pmask)) \
- __FFB_Attr_SFB_VAR(__fpriv, ppc, ppc_mask, fbc, \
- FFB_WID_WIN(__pwin), rop, (__pmask)); \
+ __FFB_Attr_SFB_VAR(__fpriv, __ppc, __ppc_mask, __fbc, \
+ FFB_WID_WIN(__pwin), __rop, (__pmask)); \
} while(0)
/* VSCROLL Attributes:
@@ -277,25 +277,25 @@
* PMASK) all options allowed
*/
#define FFB_ATTR_VSCROLL_WINCOPY(__fpriv) \
-do { unsigned int rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
- unsigned int fbc = FFB_FBC_WINCOPY; \
+do { unsigned int __rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
+ unsigned int __fbc = FFB_FBC_WINCOPY; \
if((__fpriv)->has_double_buffer) { \
- fbc &= ~FFB_FBC_WB_MASK; \
- fbc |= FFB_FBC_WB_AB; \
+ __fbc &= ~FFB_FBC_WB_MASK; \
+ __fbc |= FFB_FBC_WB_AB; \
} \
- if((__fpriv)->fbc_cache != fbc || \
- (__fpriv)->rop_cache != rop || \
+ if((__fpriv)->fbc_cache != __fbc || \
+ (__fpriv)->rop_cache != __rop || \
(__fpriv)->pmask_cache != 0xffffffff || \
(__fpriv)->drawop_cache != FFB_DRAWOP_VSCROLL) { \
ffb_fbcPtr __ffb = (__fpriv)->regs; \
- (__fpriv)->fbc_cache = fbc; \
- (__fpriv)->rop_cache = rop; \
+ (__fpriv)->fbc_cache = __fbc; \
+ (__fpriv)->rop_cache = __rop; \
(__fpriv)->pmask_cache = 0xffffffff; \
(__fpriv)->drawop_cache = FFB_DRAWOP_VSCROLL; \
(__fpriv)->rp_active = 1; \
FFBFifo(__fpriv, 4); \
- (__ffb)->fbc = fbc; \
- (__ffb)->rop = rop; \
+ (__ffb)->fbc = __fbc; \
+ (__ffb)->rop = __rop; \
(__ffb)->pmask = 0xffffffff; \
(__ffb)->drawop = FFB_DRAWOP_VSCROLL; \
(__fpriv)->rp_active = 1; \
@@ -303,25 +303,25 @@
} while(0)
#define FFB_ATTR_VSCROLL_WIN(__fpriv, __pmask, __pwin) \
-do { unsigned int rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
- unsigned int fbc = FFB_FBC_WIN(__pwin); \
+do { unsigned int __rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
+ unsigned int __fbc = FFB_FBC_WIN(__pwin); \
if((__fpriv)->has_double_buffer) { \
- fbc &= ~FFB_FBC_WB_MASK; \
- fbc |= FFB_FBC_WB_AB; \
+ __fbc &= ~FFB_FBC_WB_MASK; \
+ __fbc |= FFB_FBC_WB_AB; \
} \
- if((__fpriv)->fbc_cache != fbc || \
- (__fpriv)->rop_cache != rop || \
+ if((__fpriv)->fbc_cache != __fbc || \
+ (__fpriv)->rop_cache != __rop || \
(__fpriv)->pmask_cache != (__pmask) || \
(__fpriv)->drawop_cache != FFB_DRAWOP_VSCROLL) { \
ffb_fbcPtr __ffb = (__fpriv)->regs; \
- (__fpriv)->fbc_cache = fbc; \
- (__fpriv)->rop_cache = rop; \
+ (__fpriv)->fbc_cache = __fbc; \
+ (__fpriv)->rop_cache = __rop; \
(__fpriv)->pmask_cache = (__pmask); \
(__fpriv)->drawop_cache = FFB_DRAWOP_VSCROLL; \
(__fpriv)->rp_active = 1; \
FFBFifo(__fpriv, 4); \
- (__ffb)->fbc = fbc; \
- (__ffb)->rop = rop; \
+ (__ffb)->fbc = __fbc; \
+ (__ffb)->rop = __rop; \
(__ffb)->pmask = (__pmask); \
(__ffb)->drawop = FFB_DRAWOP_VSCROLL; \
} \
diff -urN xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_regs.h xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_regs.h
--- xc/programs/Xserver/hw/xfree86/drivers/sunffb.orig/ffb_regs.h 2000-05-18 19:21:37.000000000 -0400
+++ xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_regs.h 2004-06-10 23:38:50.765530184 -0400
@@ -432,6 +432,19 @@
#define FFB_MER_EDRA 0x000000c0 /* Enable read-ahead, decreasing */
#define FFB_MER_DRA 0x00000040 /* No read-ahead */
+/* Alpha Blend Control */
+#define FFB_BLENDC_FORCE_ONE 0x00000010 /* Defines 0xff as 1.0 */
+#define FFB_BLENDC_DF_MASK 0x0000000c /* Destination Frac Mask */
+#define FFB_BLENDC_DF_ZERO 0x00000000 /* Destination Frac: 0.00 */
+#define FFB_BLENDC_DF_ONE 0x00000004 /* Destination Frac: 1.00 */
+#define FFB_BLENDC_DF_ONE_M_A 0x00000008 /* Destination Frac: 1.00 - Xsrc */
+#define FFB_BLENDC_DF_A 0x0000000c /* Destination Frac: Xsrc */
+#define FFB_BLENDC_SF_MASK 0x00000003 /* Source Frac Mask */
+#define FFB_BLENDC_SF_ZERO 0x00000000 /* Source Frac: 0.00 */
+#define FFB_BLENDC_SF_ONE 0x00000001 /* Source Frac: 1.00 */
+#define FFB_BLENDC_SF_ONE_M_A 0x00000002 /* Source Frac: 1.00 - Xsrc */
+#define FFB_BLENDC_SF_A 0x00000003 /* Source Frac: Xsrc */
+
/* FBram Config 0 */
#define FFB_FBCFG0_RFTIME 0xff800000
#define FFB_FBCFG0_XMAX 0x007c0000
Reply to: