/*
* 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.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86cmap.h"
#include "compiler.h"
#include "vgaHW.h"
#include "mipointer.h"
#include "micmap.h"
#include "fb.h"
#include "regionstr.h"
#include "xf86xv.h"
#include <X11/extensions/Xv.h>
#include "xf86Pci.h"
/* framebuffer offscreen manager */
#include "xf86fbman.h"
/* include xaa includes */
#ifdef HAVE_XAA_H
#include "xaa.h"
#include "xaarop.h"
#endif
/* H/W cursor support */
#include "xf86Cursor.h"
/* Driver specific headers */
#include "ast.h"
#include "ast_2dtool.h"
#ifdef Accel_2D
#ifdef HAVE_XAA_H
/* ROP Translation Table */
int ASTXAACopyROP[16] =
{
ROP_0, /* GXclear */
ROP_DSa, /* GXand */
ROP_SDna, /* GXandReverse */
ROP_S, /* GXcopy */
ROP_DSna, /* GXandInverted */
ROP_D, /* GXnoop */
ROP_DSx, /* GXxor */
ROP_DSo, /* GXor */
ROP_DSon, /* GXnor */
ROP_DSxn, /* GXequiv */
ROP_Dn, /* GXinvert*/
ROP_SDno, /* GXorReverse */
ROP_Sn, /* GXcopyInverted */
ROP_DSno, /* GXorInverted */
ROP_DSan, /* GXnand */
ROP_1 /* GXset */
};
int ASTXAAPatternROP[16]=
{
ROP_0,
ROP_DPa,
ROP_PDna,
ROP_P,
ROP_DPna,
ROP_D,
ROP_DPx,
ROP_DPo,
ROP_DPon,
ROP_PDxn,
ROP_Dn,
ROP_PDno,
ROP_Pn,
ROP_DPno,
ROP_DPan,
ROP_1
};
/* Prototype type declaration */
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);
static void ASTSetHWClipping(ScrnInfoPtr pScrn, int delta_y);
static void AIPSubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
int x1, int y1, int x2, int y2, int flags);
static void AIPSubsequentDashedTwoPointLine(ScrnInfoPtr pScrn,
int x1, int y1, int x2, int y2,
int flags, int phase);
Bool
ASTAccelInit(ScreenPtr pScreen)
{
XAAInfoRecPtr infoPtr;
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
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)
{
if ( (pAST->jChipType == AST2300) || (pAST->jChipType == AST2400) || (pAST->jChipType == AST2500) || (pAST->jChipType == AST1180) )
{
infoPtr->SubsequentSolidTwoPointLine = AIPSubsequentSolidTwoPointLine;
}
else
{
infoPtr->SubsequentSolidTwoPointLine = ASTSubsequentSolidTwoPointLine;
}
infoPtr->SetupForSolidLine = ASTSetupForSolidLine;
infoPtr->SubsequentSolidHorVertLine = ASTSubsequentSolidHorVertLine;
infoPtr->SolidLineFlags = NO_PLANEMASK;
}
/* Dashed Lines */
if (pAST->ENGCaps & ENG_CAP_DashedLine)
{
if ( (pAST->jChipType == AST2300) || (pAST->jChipType == AST2400) || (pAST->jChipType == AST2500) || (pAST->jChipType == AST1180) )
{
infoPtr->SubsequentDashedTwoPointLine = AIPSubsequentDashedTwoPointLine;
}
else
{
infoPtr->SubsequentDashedTwoPointLine = ASTSubsequentDashedTwoPointLine;
}
infoPtr->SetupForDashedLine = ASTSetupForDashedLine;
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_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 */
vASTWaitEngIdle(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 |= (ASTXAACopyROP[rop] << 8);
pAST->ulCMDReg = cmdreg;
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*2);
ASTSetupSRCPitch(pSingleCMD, pAST->VideoModeInfo.ScreenPitch);
pSingleCMD++;
ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
/* Update Write Pointer */
mUpdateWritePointer;
}
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;
int delta_y = 0;
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentScreenToScreenCopy\n");
*/
if ((width != 0) && (height != 0))
{
/* Modify Reg. Value */
cmdreg = pAST->ulCMDReg;
if (pAST->EnableClip)
cmdreg |= CMD_ENABLE_CLIP;
else
cmdreg &= ~CMD_ENABLE_CLIP;
srcbase = dstbase = 0;
if (x1 < x2)
cmdreg |= CMD_X_DEC;
if (y1 < y2)
cmdreg |= CMD_Y_DEC;
if ((y1 + height) >= MAX_SRC_Y)
{
srcbase=pAST->VideoModeInfo.ScreenPitch*y1;
y1 = 0;
}
if ((y2 + height) >= pScrn->virtualY)
{
delta_y = y2;
dstbase=pAST->VideoModeInfo.ScreenPitch*y2;
y2 = 0;
}
if (cmdreg & CMD_X_DEC)
{
src_x = x1 + width - 1;
dst_x = x2 + width - 1;
}
else
{
src_x = x1;
dst_x = x2;
}
if (cmdreg & CMD_Y_DEC)
{
src_y = y1 + height - 1;
dst_y = y2 + height - 1;
}
else
{
src_y = y1;
dst_y = y2;
}
if (pAST->EnableClip)
ASTSetHWClipping(pScrn, delta_y);
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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);
vASTWaitEngIdle(pScrn, pAST);
}
} /* width & height check */
} /* 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 |= (ASTXAAPatternROP[rop] << 8);
pAST->ulCMDReg = cmdreg;
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*2);
ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
pSingleCMD++;
ASTSetupFG(pSingleCMD, color);
/* Update Write Pointer */
mUpdateWritePointer;
}
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;
int delta_y = 0;
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentSolidFillRect\n");
*/
if ((width != 0) && (height != 0))
{
/* Modify Reg. Value */
cmdreg = pAST->ulCMDReg;
if (pAST->EnableClip)
cmdreg |= CMD_ENABLE_CLIP;
else
cmdreg &= ~CMD_ENABLE_CLIP;
dstbase = 0;
if (dst_y >= pScrn->virtualY)
{
delta_y = dst_y;
dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y;
dst_y=0;
}
if (pAST->EnableClip)
ASTSetHWClipping(pScrn, delta_y);
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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);
vASTWaitEngIdle(pScrn, pAST);
}
} /* width & height check */
} /* 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 |= (ASTXAAPatternROP[rop] << 8);
pAST->ulCMDReg = cmdreg;
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*3);
ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
pSingleCMD++;
ASTSetupFG(pSingleCMD, color);
pSingleCMD++;
ASTSetupBG(pSingleCMD, 0);
/* Update Write Pointer */
mUpdateWritePointer;
}
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;
int delta_y = 0;
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentSolidHorVertLine\n");
*/
if (len != 0)
{
/* Modify Reg. Value */
cmdreg = (pAST->ulCMDReg & (~CMD_MASK)) | CMD_BITBLT;
if (pAST->EnableClip)
cmdreg |= CMD_ENABLE_CLIP;
else
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)
{
delta_y = y;
dstbase=pAST->VideoModeInfo.ScreenPitch*y;
y=0;
}
if (pAST->EnableClip)
ASTSetHWClipping(pScrn, delta_y);
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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);
vASTWaitEngIdle(pScrn, pAST);
}
} /* len check */
} /* 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;
int delta_y = 0;
/*
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;
else
ulCommand &= ~CMD_ENABLE_CLIP;
dstbase = 0;
miny = (y1 > y2) ? y2 : y1;
maxy = (y1 > y2) ? y1 : y2;
if(maxy >= pScrn->virtualY) {
delta_y = miny;
dstbase = pAST->VideoModeInfo.ScreenPitch * miny;
y1 -= miny;
y2 -= miny;
}
LineInfo.X1 = x1;
LineInfo.Y1 = y1;
LineInfo.X2 = x2;
LineInfo.Y2 = y2;
bASTGetLineTerm(&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->EnableClip)
ASTSetHWClipping(pScrn, delta_y);
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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;
/* Patch KDE pass abnormal point, ycchen@052507 */
vASTWaitEngIdle(pScrn, pAST);
}
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);
vASTWaitEngIdle(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 |= (ASTXAAPatternROP[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 *) pASTjRequestCMDQ(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));
/* Update Write Pointer */
mUpdateWritePointer;
}
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;
int delta_y = 0;
/*
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;
else
ulCommand &= ~CMD_ENABLE_CLIP;
dstbase = 0;
miny = (y1 > y2) ? y2 : y1;
maxy = (y1 > y2) ? y1 : y2;
if(maxy >= pScrn->virtualY) {
delta_y = miny;
dstbase = pAST->VideoModeInfo.ScreenPitch * miny;
y1 -= miny;
y2 -= miny;
}
LineInfo.X1 = x1;
LineInfo.Y1 = y1;
LineInfo.X2 = x2;
LineInfo.Y2 = y2;
bASTGetLineTerm(&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->EnableClip)
ASTSetHWClipping(pScrn, delta_y);
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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;
/* Patch KDE pass abnormal point, ycchen@052507 */
vASTWaitEngIdle(pScrn, pAST);
}
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);
vASTWaitEngIdle(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 |= (ASTXAAPatternROP[rop] << 8);
pAST->ulCMDReg = cmdreg;
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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);
/* Update Write Pointer */
mUpdateWritePointer;
}
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;
int delta_y = 0;
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentMonoPatternFill\n");
*/
/* Modify Reg. Value */
cmdreg = pAST->ulCMDReg;
if (pAST->EnableClip)
cmdreg |= CMD_ENABLE_CLIP;
else
cmdreg &= ~CMD_ENABLE_CLIP;
dstbase = 0;
if (dst_y >= pScrn->virtualY)
{
delta_y = dst_y;
dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y;
dst_y=0;
}
if (pAST->EnableClip)
ASTSetHWClipping(pScrn, delta_y);
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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);
vASTWaitEngIdle(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 |= (ASTXAAPatternROP[rop] << 8);
pAST->ulCMDReg = cmdreg;
cpp = (pScrn->bitsPerPixel + 1) / 8;
pataddr = (CARD32 *)(pAST->FBVirtualAddr +
(paty * pAST->VideoModeInfo.ScreenPitch) + (patx * cpp));
ulPatSize = 8*8*cpp;
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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++;
}
}
/* Update Write Pointer */
mUpdateWritePointer;
}
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;
int delta_y = 0;
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentColor8x8PatternFillRect\n");
*/
/* Modify Reg. Value */
cmdreg = pAST->ulCMDReg;
if (pAST->EnableClip)
cmdreg |= CMD_ENABLE_CLIP;
else
cmdreg &= ~CMD_ENABLE_CLIP;
dstbase = 0;
if (dst_y >= pScrn->virtualY)
{
delta_y = dst_y;
dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y;
dst_y=0;
}
if (pAST->EnableClip)
ASTSetHWClipping(pScrn, delta_y);
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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);
vASTWaitEngIdle(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 |= (ASTXAAPatternROP[rop] << 8);
if(bg == -1) {
cmdreg |= CMD_FONT_TRANSPARENT;
bg = 0;
}
pAST->ulCMDReg = cmdreg;
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*3);
ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
pSingleCMD++;
ASTSetupFG(pSingleCMD, fg);
pSingleCMD++;
ASTSetupBG(pSingleCMD, bg);
/* Update Write Pointer */
mUpdateWritePointer;
}
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;
int delta_y = 0;
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentCPUToScreenColorExpandFill\n");
*/
/* Modify Reg. Value */
cmdreg = pAST->ulCMDReg;
if (pAST->EnableClip)
cmdreg |= CMD_ENABLE_CLIP;
else
cmdreg &= ~CMD_ENABLE_CLIP;
dstbase = 0;
if (dst_y >= pScrn->virtualY)
{
delta_y = dst_y;
dstbase=pAST->VideoModeInfo.ScreenPitch*dst_y;
dst_y=0;
}
if (pAST->EnableClip)
ASTSetHWClipping(pScrn, delta_y);
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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);
vASTWaitEngIdle(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 |= (ASTXAAPatternROP[rop] << 8);
if(bg == -1) {
cmdreg |= CMD_FONT_TRANSPARENT;
bg = 0;
}
pAST->ulCMDReg = cmdreg;
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*3);
ASTSetupDSTPitchHeight(pSingleCMD, pAST->VideoModeInfo.ScreenPitch, -1);
pSingleCMD++;
ASTSetupFG(pSingleCMD, fg);
pSingleCMD++;
ASTSetupBG(pSingleCMD, bg);
/* Update Write Pointer */
mUpdateWritePointer;
}
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;
int delta_y = 0;
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentScreenToScreenColorExpandFill\n");
*/
/* Modify Reg. Value */
cmdreg = pAST->ulCMDReg;
if (pAST->EnableClip)
cmdreg |= CMD_ENABLE_CLIP;
else
cmdreg &= ~CMD_ENABLE_CLIP;
dstbase = 0;
if (dst_y >= pScrn->virtualY)
{
delta_y = dst_y;
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->EnableClip)
ASTSetHWClipping(pScrn, delta_y);
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(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);
vASTWaitEngIdle(pScrn, pAST);
}
}
/* Clipping */
static void
ASTSetHWClipping(ScrnInfoPtr pScrn, int delta_y)
{
ASTRecPtr pAST = ASTPTR(pScrn);
PKT_SC *pSingleCMD;
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*2);
ASTSetupCLIP1(pSingleCMD, pAST->clip_left, pAST->clip_top - delta_y);
pSingleCMD++;
ASTSetupCLIP2(pSingleCMD, pAST->clip_right + 1, pAST->clip_bottom - delta_y + 1);
/* Update Write Pointer */
mUpdateWritePointer;
}
else
{
ASTSetupCLIP1_MMIO(pAST->clip_left, pAST->clip_top - delta_y);
ASTSetupCLIP2_MMIO(pAST->clip_right + 1, pAST->clip_bottom - delta_y + 1);
}
}
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;
pAST->clip_left = left;
pAST->clip_top = top;
pAST->clip_right = right;
pAST->clip_bottom = bottom;
}
static void
ASTDisableClipping(ScrnInfoPtr pScrn)
{
ASTRecPtr pAST = ASTPTR(pScrn);
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTDisableClipping\n");
*/
pAST->EnableClip = FALSE;
}
static void AIPSubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
int x1, int y1, int x2, int y2, int flags)
{
ASTRecPtr pAST = ASTPTR(pScrn);
PKT_SC *pSingleCMD;
ULONG dstbase, ulCommand;
ULONG miny, maxy;
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentSolidTwoPointLine\n");
*/
/* Modify Reg. Value */
ulCommand = (pAST->ulCMDReg & (~CMD_MASK)) | CMD_LINEDRAW | CMD_NORMAL_LINE;
if(flags & OMIT_LAST)
ulCommand |= CMD_NOT_DRAW_LAST_PIXEL;
else
ulCommand &= ~CMD_NOT_DRAW_LAST_PIXEL;
if (pAST->EnableClip)
ulCommand |= CMD_ENABLE_CLIP;
else
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;
}
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*5);
ASTSetupDSTBase(pSingleCMD, dstbase);
pSingleCMD++;
AIPSetupLineXY(pSingleCMD, x1, y1);
pSingleCMD++;
AIPSetupLineXY2(pSingleCMD, x2, y2);
pSingleCMD++;
AIPSetupLineNumber(pSingleCMD, 0);
pSingleCMD++;
ASTSetupCMDReg(pSingleCMD, ulCommand);
/* Update Write Pointer */
mUpdateWritePointer;
/* Patch KDE pass abnormal point, ycchen@052507 */
vASTWaitEngIdle(pScrn, pAST);
}
else
{
ASTSetupDSTBase_MMIO(dstbase);
AIPSetupLineXY_MMIO(x1, y1);
AIPSetupLineXY2_MMIO(x2, y2);
AIPSetupLineNumber_MMIO(0);
ASTSetupCMDReg_MMIO(ulCommand);
vASTWaitEngIdle(pScrn, pAST);
}
} /* end of AIPSubsequentSolidTwoPointLine */
static void
AIPSubsequentDashedTwoPointLine(ScrnInfoPtr pScrn,
int x1, int y1, int x2, int y2,
int flags, int phase)
{
ASTRecPtr pAST = ASTPTR(pScrn);
PKT_SC *pSingleCMD;
ULONG dstbase, ulCommand;
ULONG miny, maxy;
/*
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ASTSubsequentDashedTwoPointLine\n");
*/
/* Modify Reg. Value */
ulCommand = pAST->ulCMDReg | CMD_NORMAL_LINE;
if(flags & OMIT_LAST)
ulCommand |= CMD_NOT_DRAW_LAST_PIXEL;
else
ulCommand &= ~CMD_NOT_DRAW_LAST_PIXEL;
if (pAST->EnableClip)
ulCommand |= CMD_ENABLE_CLIP;
else
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;
}
if (!pAST->MMIO2D)
{
/* Write to CMDQ */
pSingleCMD = (PKT_SC *) pASTjRequestCMDQ(pAST, PKT_SINGLE_LENGTH*5);
ASTSetupDSTBase(pSingleCMD, dstbase);
pSingleCMD++;
AIPSetupLineXY(pSingleCMD, x1, y1);
pSingleCMD++;
AIPSetupLineXY2(pSingleCMD, x2, y2);
pSingleCMD++;
AIPSetupLineNumber(pSingleCMD, 0);
pSingleCMD++;
ASTSetupCMDReg(pSingleCMD, ulCommand);
/* Update Write Pointer */
mUpdateWritePointer;
/* Patch KDE pass abnormal point, ycchen@052507 */
vASTWaitEngIdle(pScrn, pAST);
}
else
{
ASTSetupDSTBase_MMIO(dstbase);
AIPSetupLineXY_MMIO(x1, y1);
AIPSetupLineXY2_MMIO(x2, y2);
AIPSetupLineNumber_MMIO(0);
ASTSetupCMDReg_MMIO(ulCommand);
vASTWaitEngIdle(pScrn, pAST);
}
}
#endif /* HAVE_XAA_H */
#ifdef AstVideo
/*
* Video Part
* by ic_yang
*/
#include "fourcc.h"
void ASTDisplayVideo(ScrnInfoPtr pScrn, ASTPortPrivPtr pPriv, RegionPtr clipBoxes, int id)
{
ASTPtr pAST = ASTPTR(pScrn);
int nBoxs;
int ScaleFactorH, ScaleFactorV;
ULONG InitScaleFactorH, InitScaleFactorV;
BURSTSCALECMD CopyCmd = {0};
PBURSTSCALECMD pCopyCmd = NULL;
float fScaleX = 0, fScaleY = 0;
xRectangle rect;
BoxPtr pBox = NULL;
short lSrcX, lSrcY;
ULONG dwCmd = 0;
int i;
pBox = REGION_RECTS(clipBoxes);
nBoxs = REGION_NUM_RECTS(clipBoxes);
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "MMIO=%x,pBox=%x, nBoxs=%x\n", pAST->MMIO2D, pBox, nBoxs);
if(0==pPriv->drw_w || 0==pPriv->drw_h)
{
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "drwx=%x, drwy=%x\n", pPriv->drw_w, pPriv->drw_h);
return;
}
/* calc scaling factor */
fScaleX = (float)pPriv->src_w /(float)pPriv->drw_w;
fScaleY = (float)pPriv->src_h /(float)pPriv->drw_h;
if (pPriv->src_w == pPriv->drw_w)
ScaleFactorH = 0x8000;
else
ScaleFactorH = (ULONG)((pPriv->src_w-1)*0x8000)/pPriv->drw_w;
if (pPriv->src_h == pPriv->drw_h)
{
ScaleFactorV = 0x8000;
dwCmd |= SCALE_EQUAL_VER; /* Setting it save the bandwidtch */
}
else
{
ScaleFactorV = (ULONG)((pPriv->src_h-1)*0x8000)/pPriv->drw_h;
}
if (pPriv->drw_w >= pPriv->src_w)
InitScaleFactorH = 0;
else
InitScaleFactorH = 0x4000;
if (pPriv->drw_h >= pPriv->src_h)
InitScaleFactorV = 0;
else
InitScaleFactorV = 0x4000;
switch(pScrn->bitsPerPixel)
{
case 32:
dwCmd = CMD_COLOR_32;
break;
case 16:
dwCmd = CMD_COLOR_16;
break;
case 8:
dwCmd = CMD_COLOR_08;
break;
}
dwCmd |= CMD_TYPE_SCALE;
if (pPriv->drw_w >= pPriv->src_w)
dwCmd |= SCALE_SEG_NUM_1;
else
dwCmd |= SCALE_SEG_NUM_2;
dwCmd |= SCALE_FORMAT_YUV2RGB;
switch(id)
{
case PIXEL_FMT_YUY2:
dwCmd |= YUV_FORMAT_YUYV;
break;
case PIXEL_FMT_UYVY:
dwCmd |= YUV_FORMAT_UYVY;
break;
default:
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Other pix format:%x\n", id);
break;
}
for(i = 0; i < nBoxs; i++, pBox++)
{
rect.x = pBox->x1 - pPriv->drw_x;
rect.y = pBox->y1 - pPriv->drw_y;
rect.width = pBox->x2 - pBox->x1;
rect.height = pBox->y2 - pBox->y1;
lSrcX = (ULONG)((float)rect.x * fScaleX + pPriv->src_x + 0.5f);
lSrcY = (ULONG)((float)rect.y * fScaleY + pPriv->src_y + 0.5f);
pCopyCmd = (BURSTSCALECMD*)pASTjRequestCMDQ(pAST, PKT_TYPESCALE_LENGTH);
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "pCopyCmd=%p, pBox=%x,%x,%x,%x\n", pCopyCmd, pBox->x1, pBox->y1, pBox->x2, pBox->y2);
CopyCmd.dwHeader0 = (ULONG) PKT_BURST_CMD_HEADER0 |
PKT_TYPESCALE_DATALENGTH |
PKT_TYPESCALE_ADDRSTART |
BURST_FORCE_CMD;
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "CopyCmd.dwHeader0=%x\n", CopyCmd.dwHeader0);
CopyCmd.dwSrcPitch = (ULONG)(pPriv->srcPitch << 16);
CopyCmd.dwDstHeightPitch = (ULONG) ((pAST->VideoModeInfo.ScreenPitch << 16) | 0xFFFF);
CopyCmd.dwDstXY = (ULONG) ((pBox->x1 << 16) | (pBox->y1 & 0xFFFF));
CopyCmd.dwSrcXY = (ULONG) ((lSrcX << 16) | (lSrcY & 0xFFFF));
CopyCmd.dwRecHeightWidth = (ULONG) ((rect.width << 16) | rect.height);
CopyCmd.dwInitScaleFactorH = InitScaleFactorH;
CopyCmd.dwInitScaleFactorV = InitScaleFactorV;
CopyCmd.dwScaleFactorH = ScaleFactorH;
CopyCmd.dwScaleFactorV = ScaleFactorV;
CopyCmd.dwSrcBaseAddr = pPriv->bufAddr[pPriv->currentBuf];
CopyCmd.dwDstBaseAddr = 0;
CopyCmd.dwCmd = dwCmd;
CopyCmd.NullData[0] = 0; /* for alignment */
memcpy(pCopyCmd, &CopyCmd, sizeof(CopyCmd));
mUpdateWritePointer;
#if 0
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%08x, %08x, %08x, %08x\n",
*(ULONG *)(pAST->MMIOVirtualAddr+0x8000),
*(ULONG *)(pAST->MMIOVirtualAddr+0x8004),
*(ULONG *)(pAST->MMIOVirtualAddr+0x8008),
*(ULONG *)(pAST->MMIOVirtualAddr+0x800C));
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%08x, %08x, %08x, %08x\n",
*(ULONG *)(pAST->MMIOVirtualAddr+0x8010),
*(ULONG *)(pAST->MMIOVirtualAddr+0x8014),
*(ULONG *)(pAST->MMIOVirtualAddr+0x8018),
*(ULONG *)(pAST->MMIOVirtualAddr+0x801C));
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%08x, %08x, %08x, %08x\n",
*(ULONG *)(pAST->MMIOVirtualAddr+0x8020),
*(ULONG *)(pAST->MMIOVirtualAddr+0x8024),
*(ULONG *)(pAST->MMIOVirtualAddr+0x8028),
*(ULONG *)(pAST->MMIOVirtualAddr+0x802C));
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%08x, %08x, %08x, %08x\n",
*(ULONG *)(pAST->MMIOVirtualAddr+0x8030),
*(ULONG *)(pAST->MMIOVirtualAddr+0x8034),
*(ULONG *)(pAST->MMIOVirtualAddr+0x8038),
*(ULONG *)(pAST->MMIOVirtualAddr+0x803C));
#endif
} /* End of for-loop */
} /* ASTDisplayVideo */
#endif /* AstVideo */
#endif /* end of Accel_2D */