diff options
| author | Alan Coopersmith <Alan.Coopersmith@sun.com> | 2006-03-14 23:18:18 +0000 |
|---|---|---|
| committer | Alan Coopersmith <Alan.Coopersmith@sun.com> | 2006-03-14 23:18:18 +0000 |
| commit | 7ce3a2ba6d211aeaa19a6841935bc50205788d62 (patch) | |
| tree | 0eec6a9e5041332927fc69ca881fca589a156739 /src/ast_accel.c | |
Initial code release from ASPEED Technology Inc. Bugzilla #4937
<https://bugs.freedesktop.org/show_bug.cgi?id=4937> Attachment 3686
<https://bugs.freedesktop.org/attachment.cgi?id=3686>
Diffstat (limited to 'src/ast_accel.c')
| -rw-r--r-- | src/ast_accel.c | 1358 |
1 files changed, 1358 insertions, 0 deletions
diff --git a/src/ast_accel.c b/src/ast_accel.c new file mode 100644 index 0000000..69da85f --- /dev/null +++ b/src/ast_accel.c @@ -0,0 +1,1358 @@ +/*
+ * Copyright (c) 2005 ASPEED Technology Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the authors not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. The authors makes no representations
+ * about the suitability of this software for any purpose. It is provided
+ * "as is" without express or implied warranty.
+ *
+ * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "xf86.h"
+#include "xf86_ansic.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "regionstr.h"
+#include "xf86xv.h"
+#include "Xv.h"
+#include "vbe.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+
+/* framebuffer offscreen manager */
+#include "xf86fbman.h"
+
+/* include xaa includes */
+#include "xaa.h"
+#include "xaarop.h"
+
+/* H/W cursor support */
+#include "xf86Cursor.h"
+
+/* Driver specific headers */
+#include "ast.h"
+
+#ifdef Accel_2D
+
+/* extern function */
+extern void vWaitEngIdle(ScrnInfoPtr pScrn, ASTRecPtr pAST);
+extern UCHAR *pjRequestCMDQ(ASTRecPtr pAST, ULONG ulDataLen);
+extern Bool bGetLineTerm(_LINEInfo *LineInfo, LINEPARAM *dsLineParam);
+extern LONG lGetDiaRg(LONG GFracX, LONG GFracY);
+
+/* Prototype type declaration */
+Bool ASTAccelInit(ScreenPtr pScreen);
+static void ASTSync(ScrnInfoPtr pScrn);
+static void ASTSetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
+ int xdir, int ydir, int rop,
+ unsigned int planemask, int trans_color);
+static void ASTSubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1, int x2,
+ int y2, int w, int h);
+static void ASTSetupForSolidFill(ScrnInfoPtr pScrn,
+ int color, int rop, unsigned int planemask);
+static void ASTSubsequentSolidFillRect(ScrnInfoPtr pScrn,
+ int dst_x, int dst_y, int width, int height);
+static void ASTSetupForSolidLine(ScrnInfoPtr pScrn,
+ int color, int rop, unsigned int planemask);
+static void ASTSubsequentSolidHorVertLine(ScrnInfoPtr pScrn,
+ int x, int y, int len, int dir);
+static void ASTSubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
+ int x1, int y1, int x2, int y2, int flags);
+static void ASTSetupForDashedLine(ScrnInfoPtr pScrn,
+ int fg, int bg, int rop, unsigned int planemask,
+ int length, UCHAR *pattern);
+static void ASTSubsequentDashedTwoPointLine(ScrnInfoPtr pScrn,
+ int x1, int y1, int x2, int y2,
+ int flags, int phase);
+static void ASTSetupForMonoPatternFill(ScrnInfoPtr pScrn,
+ int patx, int paty, int fg, int bg,
+ int rop, unsigned int planemask);
+static void ASTSubsequentMonoPatternFill(ScrnInfoPtr pScrn,
+ int patx, int paty,
+ int x, int y, int w, int h);
+static void ASTSetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,
+ int rop, unsigned int planemask, int trans_col);
+static void ASTSubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn, int patx, int paty,
+ int x, int y, int w, int h);
+static void ASTSetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int fg, int bg,
+ int rop, unsigned int planemask);
+static void ASTSubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int x, int y,
+ int width, int height, int skipleft);
+static void ASTSetupForScreenToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int fg, int bg,
+ int rop, unsigned int planemask);
+static void ASTSubsequentScreenToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int x, int y, int width, int height,
+ int src_x, int src_y, int offset);
+static void ASTSetClippingRectangle(ScrnInfoPtr pScrn,
+ int left, int top, int right, int bottom);
+static void ASTDisableClipping(ScrnInfoPtr pScrn);
+
+Bool
+ASTAccelInit(ScreenPtr pScreen)
+{
+ XAAInfoRecPtr infoPtr;
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ ASTRecPtr pAST = ASTPTR(pScrn);
+
+ pAST->AccelInfoPtr = infoPtr = XAACreateInfoRec();
+ if (!infoPtr) return FALSE;
+
+ infoPtr->Flags = LINEAR_FRAMEBUFFER |
+ OFFSCREEN_PIXMAPS |
+ PIXMAP_CACHE;
+
+ /* Sync */
+ if (pAST->ENGCaps & ENG_CAP_Sync)
+ infoPtr->Sync = ASTSync;
+
+ /* Screen To Screen copy */
+ if (pAST->ENGCaps & ENG_CAP_ScreenToScreenCopy)
+ {
+ infoPtr->SetupForScreenToScreenCopy = ASTSetupForScreenToScreenCopy;
+ infoPtr->SubsequentScreenToScreenCopy = ASTSubsequentScreenToScreenCopy;
+ infoPtr->ScreenToScreenCopyFlags = NO_TRANSPARENCY | NO_PLANEMASK;
+ }
+
+ /* Solid fill */
+ if (pAST->ENGCaps & ENG_CAP_SolidFill)
+ {
+ infoPtr->SetupForSolidFill = ASTSetupForSolidFill;
+ infoPtr->SubsequentSolidFillRect = ASTSubsequentSolidFillRect;
+ infoPtr->SolidFillFlags = NO_PLANEMASK;
+ }
+
+ /* Solid Lines */
+ if (pAST->ENGCaps & ENG_CAP_SolidLine)
+ {
+ infoPtr->SetupForSolidLine = ASTSetupForSolidLine;
+ infoPtr->SubsequentSolidHorVertLine = ASTSubsequentSolidHorVertLine;
+ infoPtr->SubsequentSolidTwoPointLine = ASTSubsequentSolidTwoPointLine;
+ infoPtr->SolidLineFlags = NO_PLANEMASK;
+ }
+
+ /* Dashed Lines */
+ if (pAST->ENGCaps & ENG_CAP_DashedLine)
+ {
+ infoPtr->SetupForDashedLine = ASTSetupForDashedLine;
+ infoPtr->SubsequentDashedTwoPointLine = ASTSubsequentDashedTwoPointLine;
+ infoPtr->DashPatternMaxLength = 64;
+ infoPtr->DashedLineFlags = NO_PLANEMASK |
+ LINE_PATTERN_MSBFIRST_LSBJUSTIFIED;
+ }
+
+ /* 8x8 mono pattern fill */
+ if (pAST->ENGCaps & ENG_CAP_Mono8x8PatternFill)
+ {
+ infoPtr->SetupForMono8x8PatternFill = ASTSetupForMonoPatternFill;
+ infoPtr->SubsequentMono8x8PatternFillRect = ASTSubsequentMonoPatternFill;
+ infoPtr->Mono8x8PatternFillFlags = NO_PLANEMASK |
+ NO_TRANSPARENCY |
+ HARDWARE_PATTERN_SCREEN_ORIGIN |
+ HARDWARE_PATTERN_PROGRAMMED_BITS |
+ BIT_ORDER_IN_BYTE_MSBFIRST;
+ }
+
+ /* 8x8 color pattern fill */
+ if (pAST->ENGCaps & ENG_CAP_Color8x8PatternFill)
+ {
+ infoPtr->SetupForColor8x8PatternFill = ASTSetupForColor8x8PatternFill;
+ infoPtr->SubsequentColor8x8PatternFillRect = ASTSubsequentColor8x8PatternFillRect;
+ infoPtr->Color8x8PatternFillFlags = NO_PLANEMASK |
+ NO_TRANSPARENCY |
+ HARDWARE_PATTERN_SCREEN_ORIGIN;
+ }
+
+ /* CPU To Screen Color Expand */
+ if (pAST->ENGCaps & ENG_CAP_CPUToScreenColorExpand)
+ {
+ infoPtr->SetupForCPUToScreenColorExpandFill = ASTSetupForCPUToScreenColorExpandFill;
+ infoPtr->SubsequentCPUToScreenColorExpandFill = ASTSubsequentCPUToScreenColorExpandFill;
+ infoPtr->ColorExpandRange = MAX_PATReg_Size;
+ infoPtr->ColorExpandBase = MMIOREG_PAT;
+ infoPtr->CPUToScreenColorExpandFillFlags = NO_PLANEMASK |
+ BIT_ORDER_IN_BYTE_MSBFIRST;
+ }
+
+ /* Screen To Screen Color Expand */
+ if (pAST->ENGCaps & ENG_CAP_ScreenToScreenColorExpand)
+ {
+ infoPtr->SetupForScreenToScreenColorExpandFill = ASTSetupForScreenToScreenColorExpandFill;
+ infoPtr->SubsequentScreenToScreenColorExpandFill = ASTSubsequentScreenToScreenColorExpandFill;
+ infoPtr->ScreenToScreenColorExpandFillFlags = NO_PLANEMASK |
+ BIT_ORDER_IN_BYTE_MSBFIRST;
+ }
+
+ /* Clipping */
+ if (pAST->ENGCaps & ENG_CAP_Clipping)
+ {
+ infoPtr->SetClippingRectangle = ASTSetClippingRectangle;
+ infoPtr->DisableClipping = ASTDisableClipping;
+ infoPtr->ClippingFlags = HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY |
+ HARDWARE_CLIP_MONO_8x8_FILL |
+ HARDWARE_CLIP_COLOR_8x8_FILL |
+ HARDWARE_CLIP_SOLID_FILL |
+ HARDWARE_CLIP_SOLID_LINE |
+ HARDWARE_CLIP_DASHED_LINE |
+ HARDWARE_CLIP_SOLID_LINE;
+ }
+
+ return(XAAInit(pScreen, infoPtr));
+
+} /* end of ASTAccelInit */
+
+
+static void
+ASTSync(ScrnInfoPtr pScrn)
+{
+ ASTRecPtr pAST = ASTPTR(pScrn);
+
+ /* wait engle idle */
+ vWaitEngIdle(pScrn, pAST);
+
+} /* end of ASTSync */
+
+
+static void ASTSetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
+ int xdir, int ydir, int rop,
+ unsigned int planemask, int trans_color)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG cmdreg;
+
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForScreenToScreenCopy\n");
+*/
+ /* Modify Reg. Value */
+ cmdreg = CMD_BITBLT;
+ switch (pAST->VideoModeInfo.bitsPerPixel)
+ {
+ case 8:
+ cmdreg |= CMD_COLOR_08;
+ break;
+ case 15:
+ case 16:
+ cmdreg |= CMD_COLOR_16;
+ break;
+ case 24:
+ case 32:
+ cmdreg |= CMD_COLOR_32;
+ break;
+ }
+ cmdreg |= (XAACopyROP[rop] << 8);
+ pAST->ulCMDReg = cmdreg;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*2);
+
+ ASTSetupSRCPitch(pSingleCMD, pAST->VideoModeInfo.ScreenPitch);
+ pSingleCMD++;
+ ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
+ }
+ else
+ {
+ /* Write to MMIO */
+ ASTSetupSRCPitch_MMIO(pAST->VideoModeInfo.ScreenPitch);
+ ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1);
+ }
+
+} /* end of ASTSetupForScreenToScreenCopy */
+
+static void
+ASTSubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1, int x2,
+ int y2, int width, int height)
+{
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ int src_x, src_y, dst_x, dst_y;
+ ULONG srcbase, dstbase, cmdreg;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentScreenToScreenCopy\n");
+*/
+
+ /* Modify Reg. Value */
+ cmdreg = pAST->ulCMDReg;
+ if (pAST->EnableClip)
+ cmdreg |= CMD_ENABLE_CLIP;
+ srcbase = dstbase = 0;
+
+ if (y1 >= MAX_SRC_Y)
+ {
+ srcbase=pAST->VideoModeInfo.ScreenPitch*y1;
+ y1=0;
+ }
+
+ if (y2 >= pScrn->virtualY)
+ {
+ dstbase=pAST->VideoModeInfo.ScreenPitch*y2;
+ y2=0;
+ }
+
+ if (x1 < x2)
+ {
+ src_x = x1 + width - 1;
+ dst_x = x2 + width - 1;
+ cmdreg |= CMD_X_DEC;
+ }
+ else
+ {
+ src_x = x1;
+ dst_x = x2;
+ }
+
+ if (y1 < y2)
+ {
+ src_y = y1 + height - 1;
+ dst_y = y2 + height - 1;
+ cmdreg |= CMD_Y_DEC;
+ }
+ else
+ {
+ src_y = y1;
+ dst_y = y2;
+ }
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*6);
+
+ ASTSetupSRCBase(pSingleCMD, srcbase);
+ pSingleCMD++;
+ ASTSetupDSTBase(pSingleCMD, dstbase);
+ pSingleCMD++;
+ ASTSetupDSTXY(pSingleCMD, dst_x, dst_y);
+ pSingleCMD++;
+ ASTSetupSRCXY(pSingleCMD, src_x, src_y);
+ pSingleCMD++;
+ ASTSetupRECTXY(pSingleCMD, width, height);
+ pSingleCMD++;
+ ASTSetupCMDReg(pSingleCMD, cmdreg);
+
+ /* Update Write Pointer */
+ mUpdateWritePointer;
+
+ }
+ else
+ {
+ ASTSetupSRCBase_MMIO(srcbase);
+ ASTSetupDSTBase_MMIO(dstbase);
+ ASTSetupDSTXY_MMIO(dst_x, dst_y);
+ ASTSetupSRCXY_MMIO(src_x, src_y);
+ ASTSetupRECTXY_MMIO(width, height);
+ ASTSetupCMDReg_MMIO(cmdreg);
+
+ vWaitEngIdle(pScrn, pAST);
+ }
+
+} /* end of ASTSubsequentScreenToScreenCopy */
+
+static void
+ASTSetupForSolidFill(ScrnInfoPtr pScrn,
+ int color, int rop, unsigned int planemask)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG cmdreg;
+
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForSolidFill\n");
+*/
+ /* Modify Reg. Value */
+ cmdreg = CMD_BITBLT | CMD_PAT_FGCOLOR;
+ switch (pAST->VideoModeInfo.bitsPerPixel)
+ {
+ case 8:
+ cmdreg |= CMD_COLOR_08;
+ break;
+ case 15:
+ case 16:
+ cmdreg |= CMD_COLOR_16;
+ break;
+ case 24:
+ case 32:
+ cmdreg |= CMD_COLOR_32;
+ break;
+ }
+ cmdreg |= (XAAPatternROP[rop] << 8);
+ pAST->ulCMDReg = cmdreg;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*2);
+
+ ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
+ pSingleCMD++;
+ ASTSetupFG(pSingleCMD, color);
+ }
+ else
+ {
+ ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1);
+ ASTSetupFG_MMIO(color);
+ }
+
+} /* end of ASTSetupForSolidFill */
+
+
+static void
+ASTSubsequentSolidFillRect(ScrnInfoPtr pScrn,
+ int dst_x, int dst_y, int width, int height)
+{
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG dstbase, cmdreg;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentSolidFillRect\n");
+*/
+
+ /* Modify Reg. Value */
+ cmdreg = pAST->ulCMDReg;
+ if (pAST->EnableClip)
+ cmdreg |= CMD_ENABLE_CLIP;
+ dstbase = 0;
+
+ if (dst_y >= pScrn->virtualY)
+ {
+ dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y;
+ dst_y=0;
+ }
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*4);
+
+ ASTSetupDSTBase(pSingleCMD, dstbase);
+ pSingleCMD++;
+ ASTSetupDSTXY(pSingleCMD, dst_x, dst_y);
+ pSingleCMD++;
+ ASTSetupRECTXY(pSingleCMD, width, height);
+ pSingleCMD++;
+ ASTSetupCMDReg(pSingleCMD, cmdreg);
+
+ /* Update Write Pointer */
+ mUpdateWritePointer;
+
+ }
+ else
+ {
+ ASTSetupDSTBase_MMIO(dstbase);
+ ASTSetupDSTXY_MMIO(dst_x, dst_y);
+ ASTSetupRECTXY_MMIO(width, height);
+ ASTSetupCMDReg_MMIO(cmdreg);
+
+ vWaitEngIdle(pScrn, pAST);
+
+ }
+
+
+} /* end of ASTSubsequentSolidFillRect */
+
+/* Line */
+static void ASTSetupForSolidLine(ScrnInfoPtr pScrn,
+ int color, int rop, unsigned int planemask)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG cmdreg;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForSolidLine\n");
+*/
+ /* Modify Reg. Value */
+ cmdreg = CMD_BITBLT;
+ switch (pAST->VideoModeInfo.bitsPerPixel)
+ {
+ case 8:
+ cmdreg |= CMD_COLOR_08;
+ break;
+ case 15:
+ case 16:
+ cmdreg |= CMD_COLOR_16;
+ break;
+ case 24:
+ case 32:
+ cmdreg |= CMD_COLOR_32;
+ break;
+ }
+ cmdreg |= (XAAPatternROP[rop] << 8);
+ pAST->ulCMDReg = cmdreg;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*3);
+
+ ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
+ pSingleCMD++;
+ ASTSetupFG(pSingleCMD, color);
+ pSingleCMD++;
+ ASTSetupBG(pSingleCMD, 0);
+
+ }
+ else
+ {
+ /* Write to MMIO */
+ ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1);
+ ASTSetupFG_MMIO(color);
+ ASTSetupBG_MMIO(0);
+ }
+
+} /* end of ASTSetupForSolidLine */
+
+
+static void ASTSubsequentSolidHorVertLine(ScrnInfoPtr pScrn,
+ int x, int y, int len, int dir)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG dstbase, cmdreg;
+ int width, height;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentSolidHorVertLine\n");
+*/
+
+ /* Modify Reg. Value */
+ cmdreg = (pAST->ulCMDReg & (~CMD_MASK)) | CMD_BITBLT;
+ if (pAST->EnableClip)
+ cmdreg |= CMD_ENABLE_CLIP;
+ dstbase = 0;
+
+ if(dir == DEGREES_0) { /* horizontal */
+ width = len;
+ height = 1;
+ } else { /* vertical */
+ width = 1;
+ height = len;
+ }
+
+ if ((y + height) >= pScrn->virtualY)
+ {
+ dstbase=pAST->VideoModeInfo.ScreenPitch*y;
+ y=0;
+ }
+
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*4);
+
+ ASTSetupDSTBase(pSingleCMD, dstbase);
+ pSingleCMD++;
+ ASTSetupDSTXY(pSingleCMD, x, y);
+ pSingleCMD++;
+ ASTSetupRECTXY(pSingleCMD, width, height);
+ pSingleCMD++;
+ ASTSetupCMDReg(pSingleCMD, cmdreg);
+
+ /* Update Write Pointer */
+ mUpdateWritePointer;
+
+ }
+ else
+ {
+ ASTSetupDSTBase_MMIO(dstbase);
+ ASTSetupDSTXY_MMIO(x, y);
+ ASTSetupRECTXY_MMIO(width, height);
+ ASTSetupCMDReg_MMIO(cmdreg);
+
+ vWaitEngIdle(pScrn, pAST);
+
+ }
+
+
+} /* end of ASTSubsequentSolidHorVertLine */
+
+static void ASTSubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
+ int x1, int y1, int x2, int y2, int flags)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ LINEPARAM dsLineParam;
+ _LINEInfo LineInfo;
+ ULONG dstbase, ulCommand;
+ ULONG miny, maxy;
+ USHORT usXM;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentSolidTwoPointLine\n");
+*/
+
+ /* Modify Reg. Value */
+ ulCommand = (pAST->ulCMDReg & (~CMD_MASK)) | CMD_LINEDRAW;
+ if(flags & OMIT_LAST)
+ ulCommand |= CMD_NOT_DRAW_LAST_PIXEL;
+ else
+ ulCommand &= ~CMD_NOT_DRAW_LAST_PIXEL;
+ if (pAST->EnableClip)
+ ulCommand |= CMD_ENABLE_CLIP;
+ dstbase = 0;
+ miny = (y1 > y2) ? y2 : y1;
+ maxy = (y1 > y2) ? y1 : y2;
+ if(maxy >= pScrn->virtualY) {
+ dstbase = pAST->VideoModeInfo.ScreenPitch * miny;
+ y1 -= miny;
+ y2 -= miny;
+ }
+
+ LineInfo.X1 = x1 << 4;
+ LineInfo.X2 = x2 << 4;
+ LineInfo.Y1 = y1 << 4;
+ LineInfo.Y2 = y2 << 4;
+
+ bGetLineTerm(&LineInfo, &dsLineParam); /* Get Line Parameter */
+
+ if (dsLineParam.dwLineAttributes & LINEPARAM_X_DEC)
+ ulCommand |= CMD_X_DEC;
+ if (dsLineParam.dwLineAttributes & LINEPARAM_Y_DEC)
+ ulCommand |= CMD_Y_DEC;
+
+ usXM = (dsLineParam.dwLineAttributes & LINEPARAM_XM) ? 1:0;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*7);
+
+ ASTSetupDSTBase(pSingleCMD, dstbase);
+ pSingleCMD++;
+ ASTSetupLineXY(pSingleCMD, dsLineParam.dsLineX, dsLineParam.dsLineY);
+ pSingleCMD++;
+ ASTSetupLineXMErrTerm(pSingleCMD, usXM , dsLineParam.dwErrorTerm);
+ pSingleCMD++;
+ ASTSetupLineWidth(pSingleCMD, dsLineParam.dsLineWidth);
+ pSingleCMD++;
+ ASTSetupLineK1Term(pSingleCMD, dsLineParam.dwK1Term);
+ pSingleCMD++;
+ ASTSetupLineK2Term(pSingleCMD, dsLineParam.dwK2Term);
+ pSingleCMD++;
+ ASTSetupCMDReg(pSingleCMD, ulCommand);
+
+ /* Update Write Pointer */
+ mUpdateWritePointer;
+
+ }
+ else
+ {
+ ASTSetupDSTBase_MMIO(dstbase);
+ ASTSetupLineXY_MMIO(dsLineParam.dsLineX, dsLineParam.dsLineY);
+ ASTSetupLineXMErrTerm_MMIO( usXM , dsLineParam.dwErrorTerm);
+ ASTSetupLineWidth_MMIO(dsLineParam.dsLineWidth);
+ ASTSetupLineK1Term_MMIO(dsLineParam.dwK1Term);
+ ASTSetupLineK2Term_MMIO(dsLineParam.dwK2Term);
+ ASTSetupCMDReg_MMIO(ulCommand);
+
+ vWaitEngIdle(pScrn, pAST);
+
+ }
+
+
+} /* end of ASTSubsequentSolidTwoPointLine */
+
+/* Dash Line */
+static void
+ASTSetupForDashedLine(ScrnInfoPtr pScrn,
+ int fg, int bg, int rop, unsigned int planemask,
+ int length, UCHAR *pattern)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG cmdreg;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForDashedLine\n");
+*/
+ /* Modify Reg. Value */
+ cmdreg = CMD_LINEDRAW | CMD_RESET_STYLE_COUNTER | CMD_ENABLE_LINE_STYLE;
+
+ switch (pAST->VideoModeInfo.bitsPerPixel)
+ {
+ case 8:
+ cmdreg |= CMD_COLOR_08;
+ break;
+ case 15:
+ case 16:
+ cmdreg |= CMD_COLOR_16;
+ break;
+ case 24:
+ case 32:
+ cmdreg |= CMD_COLOR_32;
+ break;
+ }
+ cmdreg |= (XAAPatternROP[rop] << 8);
+ if(bg == -1) {
+ cmdreg |= CMD_TRANSPARENT;
+ bg = 0;
+ }
+ cmdreg |= (((length-1) & 0x3F) << 24); /* line period */
+ pAST->ulCMDReg = cmdreg;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*5);
+
+ ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
+ pSingleCMD++;
+ ASTSetupFG(pSingleCMD, fg);
+ pSingleCMD++;
+ ASTSetupBG(pSingleCMD, bg);
+ pSingleCMD++;
+ ASTSetupLineStyle1(pSingleCMD, *pattern);
+ pSingleCMD++;
+ ASTSetupLineStyle2(pSingleCMD, *(pattern+4));
+
+ }
+ else
+ {
+ /* Write to MMIO */
+ ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1);
+ ASTSetupFG_MMIO(fg);
+ ASTSetupBG_MMIO(bg);
+ ASTSetupLineStyle1_MMIO(*pattern);
+ ASTSetupLineStyle2_MMIO(*(pattern+4));
+
+ }
+
+}
+
+static void
+ASTSubsequentDashedTwoPointLine(ScrnInfoPtr pScrn,
+ int x1, int y1, int x2, int y2,
+ int flags, int phase)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ LINEPARAM dsLineParam;
+ _LINEInfo LineInfo;
+ ULONG dstbase, ulCommand;
+ ULONG miny, maxy;
+ USHORT usXM;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentDashedTwoPointLine\n");
+*/
+
+ /* Modify Reg. Value */
+ ulCommand = pAST->ulCMDReg;
+ if(flags & OMIT_LAST)
+ ulCommand |= CMD_NOT_DRAW_LAST_PIXEL;
+ else
+ ulCommand &= ~CMD_NOT_DRAW_LAST_PIXEL;
+ if (pAST->EnableClip)
+ ulCommand |= CMD_ENABLE_CLIP;
+ dstbase = 0;
+ miny = (y1 > y2) ? y2 : y1;
+ maxy = (y1 > y2) ? y1 : y2;
+ if(maxy >= pScrn->virtualY) {
+ dstbase = pAST->VideoModeInfo.ScreenPitch * miny;
+ y1 -= miny;
+ y2 -= miny;
+ }
+
+ LineInfo.X1 = x1 << 4;
+ LineInfo.X2 = x2 << 4;
+ LineInfo.Y1 = y1 << 4;
+ LineInfo.Y2 = y2 << 4;
+
+ bGetLineTerm(&LineInfo, &dsLineParam); /* Get Line Parameter */
+
+ if (dsLineParam.dwLineAttributes & LINEPARAM_X_DEC)
+ ulCommand |= CMD_X_DEC;
+ if (dsLineParam.dwLineAttributes & LINEPARAM_Y_DEC)
+ ulCommand |= CMD_Y_DEC;
+
+ usXM = (dsLineParam.dwLineAttributes & LINEPARAM_XM) ? 1:0;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*7);
+
+ ASTSetupDSTBase(pSingleCMD, dstbase);
+ pSingleCMD++;
+ ASTSetupLineXY(pSingleCMD, dsLineParam.dsLineX, dsLineParam.dsLineY);
+ pSingleCMD++;
+ ASTSetupLineXMErrTerm(pSingleCMD, usXM , dsLineParam.dwErrorTerm);
+ pSingleCMD++;
+ ASTSetupLineWidth(pSingleCMD, dsLineParam.dsLineWidth);
+ pSingleCMD++;
+ ASTSetupLineK1Term(pSingleCMD, dsLineParam.dwK1Term);
+ pSingleCMD++;
+ ASTSetupLineK2Term(pSingleCMD, dsLineParam.dwK2Term);
+ pSingleCMD++;
+ ASTSetupCMDReg(pSingleCMD, ulCommand);
+
+ /* Update Write Pointer */
+ mUpdateWritePointer;
+
+ }
+ else
+ {
+ ASTSetupDSTBase_MMIO(dstbase);
+ ASTSetupLineXY_MMIO(dsLineParam.dsLineX, dsLineParam.dsLineY);
+ ASTSetupLineXMErrTerm_MMIO( usXM , dsLineParam.dwErrorTerm);
+ ASTSetupLineWidth_MMIO(dsLineParam.dsLineWidth);
+ ASTSetupLineK1Term_MMIO(dsLineParam.dwK1Term);
+ ASTSetupLineK2Term_MMIO(dsLineParam.dwK2Term);
+ ASTSetupCMDReg_MMIO(ulCommand);
+
+ vWaitEngIdle(pScrn, pAST);
+
+ }
+
+}
+
+/* Mono Pattern Fill */
+static void
+ASTSetupForMonoPatternFill(ScrnInfoPtr pScrn,
+ int patx, int paty, int fg, int bg,
+ int rop, unsigned int planemask)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG cmdreg;
+
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForMonoPatternFill\n");
+*/
+ /* Modify Reg. Value */
+ cmdreg = CMD_BITBLT | CMD_PAT_MONOMASK;
+ switch (pAST->VideoModeInfo.bitsPerPixel)
+ {
+ case 8:
+ cmdreg |= CMD_COLOR_08;
+ break;
+ case 15:
+ case 16:
+ cmdreg |= CMD_COLOR_16;
+ break;
+ case 24:
+ case 32:
+ cmdreg |= CMD_COLOR_32;
+ break;
+ }
+ cmdreg |= (XAAPatternROP[rop] << 8);
+ pAST->ulCMDReg = cmdreg;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*5);
+
+ ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
+ pSingleCMD++;
+ ASTSetupFG(pSingleCMD, fg);
+ pSingleCMD++;
+ ASTSetupBG(pSingleCMD, bg);
+ pSingleCMD++;
+ ASTSetupMONO1(pSingleCMD, patx);
+ pSingleCMD++;
+ ASTSetupMONO2(pSingleCMD, paty);
+ }
+ else
+ {
+ ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1);
+ ASTSetupFG_MMIO(fg);
+ ASTSetupBG_MMIO(bg);
+ ASTSetupMONO1_MMIO(patx);
+ ASTSetupMONO2_MMIO(paty);
+ }
+
+} /* end of ASTSetupForMonoPatternFill */
+
+
+static void
+ASTSubsequentMonoPatternFill(ScrnInfoPtr pScrn,
+ int patx, int paty,
+ int dst_x, int dst_y, int width, int height)
+{
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG dstbase, cmdreg;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentMonoPatternFill\n");
+*/
+
+ /* Modify Reg. Value */
+ cmdreg = pAST->ulCMDReg;
+ if (pAST->EnableClip)
+ cmdreg |= CMD_ENABLE_CLIP;
+ dstbase = 0;
+
+ if (dst_y >= pScrn->virtualY)
+ {
+ dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y;
+ dst_y=0;
+ }
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*4);
+
+ ASTSetupDSTBase(pSingleCMD, dstbase);
+ pSingleCMD++;
+ ASTSetupDSTXY(pSingleCMD, dst_x, dst_y);
+ pSingleCMD++;
+ ASTSetupRECTXY(pSingleCMD, width, height);
+ pSingleCMD++;
+ ASTSetupCMDReg(pSingleCMD, cmdreg);
+
+ /* Update Write Pointer */
+ mUpdateWritePointer;
+
+ }
+ else
+ {
+ ASTSetupDSTBase_MMIO(dstbase);
+ ASTSetupDSTXY_MMIO(dst_x, dst_y);
+ ASTSetupRECTXY_MMIO(width, height);
+ ASTSetupCMDReg_MMIO(cmdreg);
+
+ vWaitEngIdle(pScrn, pAST);
+ }
+
+} /* end of ASTSubsequentMonoPatternFill */
+
+static void
+ASTSetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,
+ int rop, unsigned int planemask, int trans_col)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG cmdreg;
+ CARD32 *pataddr;
+ ULONG ulPatSize;
+ int i, j, cpp;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForColor8x8PatternFill\n");
+*/
+ /* Modify Reg. Value */
+ cmdreg = CMD_BITBLT | CMD_PAT_PATREG;
+ switch (pAST->VideoModeInfo.bitsPerPixel)
+ {
+ case 8:
+ cmdreg |= CMD_COLOR_08;
+ break;
+ case 15:
+ case 16:
+ cmdreg |= CMD_COLOR_16;
+ break;
+ case 24:
+ case 32:
+ cmdreg |= CMD_COLOR_32;
+ break;
+ }
+ cmdreg |= (XAAPatternROP[rop] << 8);
+ pAST->ulCMDReg = cmdreg;
+ cpp = (pScrn->bitsPerPixel + 1) / 8;
+ pataddr = (CARD32 *)(pAST->FBVirtualAddr +
+ (paty * pAST->VideoModeInfo.ScreenWidth) + (patx * cpp));
+ ulPatSize = 8*8*cpp;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*(1 + ulPatSize/4));
+ ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
+ pSingleCMD++;
+ for (i=0; i<8; i++)
+ {
+ for (j=0; j<8*cpp/4; j++)
+ {
+ ASTSetupPatReg(pSingleCMD, (i*j + j) , (*(CARD32 *) (pataddr++)));
+ pSingleCMD++;
+ }
+ }
+ }
+ else
+ {
+ ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1);
+ for (i=0; i<8; i++)
+ {
+ for (j=0; j<8*cpp/4; j++)
+ {
+ ASTSetupPatReg_MMIO((i*j + j) , (*(CARD32 *) (pataddr++)));
+ }
+ }
+
+ }
+
+} /* end of ASTSetupForColor8x8PatternFill */
+
+static void
+ASTSubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn, int patx, int paty,
+ int dst_x, int dst_y, int width, int height)
+{
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG dstbase, cmdreg;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentColor8x8PatternFillRect\n");
+*/
+
+ /* Modify Reg. Value */
+ cmdreg = pAST->ulCMDReg;
+ if (pAST->EnableClip)
+ cmdreg |= CMD_ENABLE_CLIP;
+ dstbase = 0;
+
+ if (dst_y >= pScrn->virtualY)
+ {
+ dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y;
+ dst_y=0;
+ }
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*4);
+
+ ASTSetupDSTBase(pSingleCMD, dstbase);
+ pSingleCMD++;
+ ASTSetupDSTXY(pSingleCMD, dst_x, dst_y);
+ pSingleCMD++;
+ ASTSetupRECTXY(pSingleCMD, width, height);
+ pSingleCMD++;
+ ASTSetupCMDReg(pSingleCMD, cmdreg);
+
+ /* Update Write Pointer */
+ mUpdateWritePointer;
+
+ }
+ else
+ {
+ ASTSetupDSTBase_MMIO(dstbase);
+ ASTSetupDSTXY_MMIO(dst_x, dst_y);
+ ASTSetupRECTXY_MMIO(width, height);
+ ASTSetupCMDReg_MMIO(cmdreg);
+
+ vWaitEngIdle(pScrn, pAST);
+ }
+
+} /* ASTSubsequentColor8x8PatternFillRect */
+
+/* CPU to Screen Expand */
+static void
+ASTSetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int fg, int bg,
+ int rop, unsigned int planemask)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG cmdreg;
+
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForCPUToScreenColorExpandFill\n");
+*/
+ /* Modify Reg. Value */
+ cmdreg = CMD_COLOREXP;
+ switch (pAST->VideoModeInfo.bitsPerPixel)
+ {
+ case 8:
+ cmdreg |= CMD_COLOR_08;
+ break;
+ case 15:
+ case 16:
+ cmdreg |= CMD_COLOR_16;
+ break;
+ case 24:
+ case 32:
+ cmdreg |= CMD_COLOR_32;
+ break;
+ }
+ cmdreg |= (XAAPatternROP[rop] << 8);
+ if(bg == -1) {
+ cmdreg |= CMD_FONT_TRANSPARENT;
+ bg = 0;
+ }
+ pAST->ulCMDReg = cmdreg;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*3);
+
+ ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
+ pSingleCMD++;
+ ASTSetupFG(pSingleCMD, fg);
+ pSingleCMD++;
+ ASTSetupBG(pSingleCMD, bg);
+
+ }
+ else
+ {
+ ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1);
+ ASTSetupFG_MMIO(fg);
+ ASTSetupBG_MMIO(bg);
+
+ }
+
+}
+
+static void
+ASTSubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int dst_x, int dst_y,
+ int width, int height, int offset)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG dstbase, cmdreg;
+
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentCPUToScreenColorExpandFill\n");
+*/
+
+ /* Modify Reg. Value */
+ cmdreg = pAST->ulCMDReg;
+ if (pAST->EnableClip)
+ cmdreg |= CMD_ENABLE_CLIP;
+ dstbase = 0;
+
+ if (dst_y >= pScrn->virtualY)
+ {
+ dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y;
+ dst_y=0;
+ }
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*5);
+
+ ASTSetupSRCPitch(pSingleCMD, ((width+7)/8));
+ pSingleCMD++;
+ ASTSetupDSTBase(pSingleCMD, dstbase);
+ pSingleCMD++;
+ ASTSetupDSTXY(pSingleCMD, dst_x, dst_y);
+ pSingleCMD++;
+ ASTSetupRECTXY(pSingleCMD, width, height);
+ pSingleCMD++;
+ ASTSetupCMDReg(pSingleCMD, cmdreg);
+
+ /* Update Write Pointer */
+ mUpdateWritePointer;
+
+ }
+ else
+ {
+ ASTSetupSRCPitch_MMIO((width+7)/8);
+ ASTSetupDSTBase_MMIO(dstbase);
+ ASTSetupDSTXY_MMIO(dst_x, dst_y);
+ ASTSetupSRCXY_MMIO(0, 0);
+
+ ASTSetupRECTXY_MMIO(width, height);
+ ASTSetupCMDReg_MMIO(cmdreg);
+
+ vWaitEngIdle(pScrn, pAST);
+
+ }
+
+}
+
+
+/* Screen to Screen Color Expand */
+static void
+ASTSetupForScreenToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int fg, int bg,
+ int rop, unsigned int planemask)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG cmdreg;
+
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetupForScreenToScreenColorExpandFill\n");
+*/
+
+ /* Modify Reg. Value */
+ cmdreg = CMD_ENHCOLOREXP;
+ switch (pAST->VideoModeInfo.bitsPerPixel)
+ {
+ case 8:
+ cmdreg |= CMD_COLOR_08;
+ break;
+ case 15:
+ case 16:
+ cmdreg |= CMD_COLOR_16;
+ break;
+ case 24:
+ case 32:
+ cmdreg |= CMD_COLOR_32;
+ break;
+ }
+ cmdreg |= (XAAPatternROP[rop] << 8);
+ if(bg == -1) {
+ cmdreg |= CMD_FONT_TRANSPARENT;
+ bg = 0;
+ }
+ pAST->ulCMDReg = cmdreg;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*3);
+
+ ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
+ pSingleCMD++;
+ ASTSetupFG(pSingleCMD, fg);
+ pSingleCMD++;
+ ASTSetupBG(pSingleCMD, bg);
+
+ }
+ else
+ {
+ ASTSetupDSTPitchHeight_MMIO(pAST->VideoModeInfo.ScreenPitch, -1);
+ ASTSetupFG_MMIO(fg);
+ ASTSetupBG_MMIO(bg);
+
+ }
+
+}
+
+
+
+static void
+ASTSubsequentScreenToScreenColorExpandFill(ScrnInfoPtr pScrn,
+ int dst_x, int dst_y, int width, int height,
+ int src_x, int src_y, int offset)
+{
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+ ULONG srcbase, dstbase, cmdreg;
+ USHORT srcpitch;
+
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentScreenToScreenColorExpandFill\n");
+*/
+
+ /* Modify Reg. Value */
+ cmdreg = pAST->ulCMDReg;
+ if (pAST->EnableClip)
+ cmdreg |= CMD_ENABLE_CLIP;
+ dstbase = 0;
+ if (dst_y >= pScrn->virtualY)
+ {
+ dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y;
+ dst_y=0;
+ }
+ srcbase = pAST->VideoModeInfo.ScreenPitch*src_y + ((pScrn->bitsPerPixel+1)/8)*src_x;
+ srcpitch = (pScrn->displayWidth+7)/8;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*6);
+
+ ASTSetupSRCBase(pSingleCMD, srcbase);
+ pSingleCMD++;
+ ASTSetupSRCPitch(pSingleCMD,srcpitch);
+ pSingleCMD++;
+ ASTSetupDSTBase(pSingleCMD, dstbase);
+ pSingleCMD++;
+ ASTSetupDSTXY(pSingleCMD, dst_x, dst_y);
+ pSingleCMD++;
+ ASTSetupRECTXY(pSingleCMD, width, height);
+ pSingleCMD++;
+ ASTSetupCMDReg(pSingleCMD, cmdreg);
+
+ /* Update Write Pointer */
+ mUpdateWritePointer;
+
+ }
+ else
+ {
+ ASTSetupSRCBase_MMIO(srcbase);
+ ASTSetupSRCPitch_MMIO(srcpitch);
+ ASTSetupDSTBase_MMIO(dstbase);
+ ASTSetupDSTXY_MMIO(dst_x, dst_y);
+ ASTSetupRECTXY_MMIO(width, height);
+ ASTSetupCMDReg_MMIO(cmdreg);
+
+ vWaitEngIdle(pScrn, pAST);
+
+ }
+
+}
+
+
+/* Clipping */
+static void
+ASTSetClippingRectangle(ScrnInfoPtr pScrn,
+ int left, int top, int right, int bottom)
+{
+
+ ASTRecPtr pAST = ASTPTR(pScrn);
+ PKT_SC *pSingleCMD;
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSetClippingRectangle\n");
+*/
+ pAST->EnableClip = TRUE;
+
+ if (!pAST->MMIO2D)
+ {
+ /* Write to CMDQ */
+ pSingleCMD = (PKT_SC *) pjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*2);
+
+ ASTSetupCLIP1(pSingleCMD, left, top);
+ pSingleCMD++;
+ ASTSetupCLIP2(pSingleCMD, right, bottom);
+ }
+ else
+ {
+ ASTSetupCLIP1_MMIO(left, top);
+ ASTSetupCLIP2_MMIO(right, bottom);
+ }
+
+}
+
+static void
+ASTDisableClipping(ScrnInfoPtr pScrn)
+{
+ ASTRecPtr pAST = ASTPTR(pScrn);
+/*
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTDisableClipping\n");
+*/
+ pAST->EnableClip = FALSE;
+}
+
+
+#endif /* end of Accel_2D */
|