void
DualPermedia3Sync(
ScrnInfoPtr pScrn
){
GLINTPtr pGlint = GLINTPTR(pScrn);
CHECKCLIPPING;
while (GLINT_READ_REG(DMACount) != 0);
GLINT_WAIT(3);
GLINT_WRITE_REG(3, BroadcastMask); /* hack! this shouldn't need to be reloaded */
GLINT_WRITE_REG(0x400, FilterMode);
GLINT_WRITE_REG(0, GlintSync);
/* Read 1st PM3 until Sync Tag shows */
ACCESSCHIP1();
do {
while(GLINT_READ_REG(OutFIFOWords) == 0);
} while (GLINT_READ_REG(OutputFIFO) != Sync_tag);
ACCESSCHIP2();
/* Read 2nd PM3 until Sync Tag shows */
do {
while(GLINT_READ_REG(OutFIFOWords) == 0);
} while (GLINT_READ_REG(OutputFIFO) != Sync_tag);
ACCESSCHIP1();
}
static void
Permedia2SetupForScreenToScreenCopy2432bpp(ScrnInfoPtr pScrn,
int xdir, int ydir, int rop,
unsigned int planemask, int transparency_color)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SetupForScreenToScreenCopy2432bpp");
pGlint->BltScanDirection = 0;
if (xdir == 1) pGlint->BltScanDirection |= XPositive;
if (ydir == 1) pGlint->BltScanDirection |= YPositive;
if (pScrn->bitsPerPixel == 24) {
GLINT_WAIT(4);
} else {
GLINT_WAIT(5);
DO_PLANEMASK(planemask);
}
GLINT_WRITE_REG(UNIT_DISABLE, ColorDDAMode);
if ((rop == GXset) || (rop == GXclear)) {
GLINT_WRITE_REG(pGlint->pprod, FBReadMode);
} else {
if ((rop == GXcopy) || (rop == GXcopyInverted)) {
GLINT_WRITE_REG(pGlint->pprod|FBRM_SrcEnable, FBReadMode);
} else {
GLINT_WRITE_REG(pGlint->pprod|FBRM_SrcEnable|FBRM_DstEnable,
FBReadMode);
}
}
LOADROP(rop);
}
void Permedia3LoadPalette(
ScrnInfoPtr pScrn,
int numColors,
int *indices,
LOCO *colors,
VisualPtr pVisual
){
#if 0
GLINTPtr pGlint = GLINTPTR(pScrn);
#endif
int i, index, shift = 0, j, repeat = 1;
if (pScrn->depth == 15) {
repeat = 8;
shift = 3;
}
for(i = 0; i < numColors; i++) {
index = indices[i];
for (j = 0; j < repeat; j++) {
Permedia2WriteAddress(pScrn, (index << shift)+j);
Permedia2WriteData(pScrn, colors[index].red);
Permedia2WriteData(pScrn, colors[index].green);
Permedia2WriteData(pScrn, colors[index].blue);
}
#if 0
GLINT_SLOW_WRITE_REG(index, PM3LUTIndex);
GLINT_SLOW_WRITE_REG((colors[index].red & 0xFF) |
((colors[index].green & 0xFF) << 8) |
((colors[index].blue & 0xFF) << 16),
PM3LUTData);
#endif
}
}
static void
Permedia3SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1,
int x2, int y2, int w, int h)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
/* Spans needs to be 32 bit aligned. */
int x_align = x1 & 0x1f;
TRACE_ENTER("Permedia3SubsequentScreenToScreenCopy");
GLINT_WAIT(5);
GLINT_WRITE_REG(((y2&0x0fff)<<16)|(x2&0x0fff), ScissorMinXY);
GLINT_WRITE_REG((((y2+h)&0x0fff)<<16)|((x2+w)&0x0fff), ScissorMaxXY);
GLINT_WRITE_REG(
PM3RectanglePosition_XOffset(x2-x_align) |
PM3RectanglePosition_YOffset(y2),
PM3RectanglePosition);
GLINT_WRITE_REG(
PM3FBSourceReadBufferOffset_XOffset(x1-x2)|
PM3FBSourceReadBufferOffset_YOffset(y1-y2),
PM3FBSourceReadBufferOffset);
GLINT_WRITE_REG(pGlint->PM3_Render2D |
PM3Render2D_Width(w+x_align)|
PM3Render2D_Height(h),
PM3Render2D);
TRACE_EXIT("Permedia3SubsequentScreenToScreenCopy");
}
static void
Permedia2SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1,
int x2, int y2, int w, int h)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
char align;
TRACE_ENTER("Permedia2SubsequentScreenToScreenCopy");
/* We can only use GXcopy for Packed modes */
if (pGlint->ROP != GXcopy) {
GLINT_WAIT(5);
GLINT_WRITE_REG(pGlint->FrameBufferReadMode, FBReadMode);
Permedia2LoadCoord(pScrn, x2, y2, w, h);
GLINT_WRITE_REG(((y1-y2)&0x0FFF)<<16 | ((x1-x2)&0x0FFF), FBSourceDelta);
} else {
align = (x2 & pGlint->bppalign) - (x1 & pGlint->bppalign);
GLINT_WAIT(6);
GLINT_WRITE_REG(pGlint->FrameBufferReadMode|FBRM_Packed, FBReadMode);
Permedia2LoadCoord(pScrn, x2>>pGlint->BppShift, y2,
(w+7)>>pGlint->BppShift, h);
GLINT_WRITE_REG(align<<29|x2<<16|(x2+w), PackedDataLimits);
GLINT_WRITE_REG(((y1-y2)&0x0FFF)<<16 | (((x1 & ~pGlint->bppalign)-(x2 & ~pGlint->bppalign))&0x0FFF), FBSourceDelta);
}
GLINT_WRITE_REG(PrimitiveRectangle | pGlint->BltScanDirection, Render);
TRACE_EXIT("Permedia2SubsequentScreenToScreenCopy");
}
static void
Permedia2SetupForMono8x8PatternFill24bpp(ScrnInfoPtr pScrn,
int patternx, int patterny,
int fg, int bg, int rop,
unsigned int planemask)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SetupForMono8x8PatternFill24bpp");
if (bg == -1) pGlint->FrameBufferReadMode = -1;
else pGlint->FrameBufferReadMode = 0;
pGlint->ForeGroundColor = fg;
pGlint->BackGroundColor = bg;
REPLICATE(pGlint->ForeGroundColor);
REPLICATE(pGlint->BackGroundColor);
GLINT_WAIT(12);
GLINT_WRITE_REG((patternx & 0xFF), AreaStipplePattern0);
GLINT_WRITE_REG((patternx & 0xFF00) >> 8, AreaStipplePattern1);
GLINT_WRITE_REG((patternx & 0xFF0000) >> 16, AreaStipplePattern2);
GLINT_WRITE_REG((patternx & 0xFF000000) >> 24, AreaStipplePattern3);
GLINT_WRITE_REG((patterny & 0xFF), AreaStipplePattern4);
GLINT_WRITE_REG((patterny & 0xFF00) >> 8, AreaStipplePattern5);
GLINT_WRITE_REG((patterny & 0xFF0000) >> 16, AreaStipplePattern6);
GLINT_WRITE_REG((patterny & 0xFF000000) >> 24, AreaStipplePattern7);
GLINT_WRITE_REG(UNIT_ENABLE, ColorDDAMode);
if (rop == GXcopy) {
GLINT_WRITE_REG(pGlint->pprod, FBReadMode);
} else {
GLINT_WRITE_REG(pGlint->pprod | FBRM_DstEnable, FBReadMode);
}
LOADROP(rop);
}
static void
Permedia2SubsequentSolidBresenhamLine( ScrnInfoPtr pScrn,
int x, int y, int dmaj, int dmin, int e, int len, int octant)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SubsequentSolidBresenhamLine");
if(dmaj == dmin) {
GLINT_WAIT(6);
if(octant & YDECREASING) {
GLINT_WRITE_REG(-1<<16, dY);
} else {
GLINT_WRITE_REG(1<<16, dY);
}
if(octant & XDECREASING) {
GLINT_WRITE_REG(-1<<16, dXDom);
} else {
GLINT_WRITE_REG(1<<16, dXDom);
}
GLINT_WRITE_REG(x<<16, StartXDom);
GLINT_WRITE_REG(y<<16, StartY);
GLINT_WRITE_REG(len,GLINTCount);
GLINT_WRITE_REG(PrimitiveLine, Render);
return;
}
fbBres(pGlint->CurrentDrawable, pGlint->CurrentGC, 0,
(octant & XDECREASING) ? -1 : 1,
(octant & YDECREASING) ? -1 : 1,
(octant & YMAJOR) ? Y_AXIS : X_AXIS,
x, y, e, dmin, -dmaj, len);
}
static void
Permedia3SubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
CARD32 *srcp = (CARD32*)pGlint->XAAScanlineColorExpandBuffers[bufno];
int dwords = pGlint->dwords;
if (!pGlint->ScanlineDirect) {
while(dwords >= pGlint->FIFOSize) {
GLINT_WAIT(pGlint->FIFOSize);
GLINT_WRITE_REG(((pGlint->FIFOSize - 2) << 16) | 0x0D, OutputFIFO);
GLINT_MoveDWORDS(
(CARD32*)((char*)pGlint->IOBase + OutputFIFO + 4),
(CARD32*)srcp, pGlint->FIFOSize - 1);
dwords -= pGlint->FIFOSize - 1;
srcp += pGlint->FIFOSize - 1;
}
if(dwords) {
GLINT_WAIT(dwords + 1);
GLINT_WRITE_REG(((dwords - 1) << 16) | 0x0D, OutputFIFO);
GLINT_MoveDWORDS(
(CARD32*)((char*)pGlint->IOBase + OutputFIFO + 4),
(CARD32*)srcp, dwords);
}
}
}
static void
Permedia2SubsequentMono8x8PatternFillRect24bpp(ScrnInfoPtr pScrn,
int patternx, int patterny,
int x, int y,
int w, int h)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SubsequentMono8x8PatternFillRect24bpp");
GLINT_WAIT(8);
Permedia2LoadCoord(pScrn, x, y, w, h);
if (pGlint->FrameBufferReadMode != -1) {
GLINT_WRITE_REG(pGlint->BackGroundColor, ConstantColor);
GLINT_WRITE_REG(patternx<<7|patterny<<12| ASM_InvertPattern |
STIPPLE_SWAP | UNIT_ENABLE, AreaStippleMode);
GLINT_WRITE_REG(AreaStippleEnable | XPositive |
YPositive | PrimitiveRectangle, Render);
}
GLINT_WRITE_REG(pGlint->ForeGroundColor, ConstantColor);
GLINT_WRITE_REG(patternx<<7|patterny<<12|UNIT_ENABLE, AreaStippleMode);
GLINT_WRITE_REG(AreaStippleEnable | XPositive | YPositive |
PrimitiveRectangle, Render);
}
static void
Permedia3SetupForScanlineCPUToScreenColorExpandFill(
ScrnInfoPtr pScrn,
int fg, int bg,
int rop,
unsigned int planemask
){
GLINTPtr pGlint = GLINTPTR(pScrn);
REPLICATE(fg);
pGlint->PM3_Render2D =
PM3Render2D_SpanOperation |
PM3Render2D_XPositive |
PM3Render2D_YPositive |
PM3Render2D_Operation_SyncOnBitMask;
pGlint->PM3_Config2D =
PM3Config2D_UserScissorEnable |
PM3Config2D_UseConstantSource |
PM3Config2D_ForegroundROPEnable |
PM3Config2D_ForegroundROP(rop) |
PM3Config2D_FBWriteEnable;
if ((rop!=GXclear)&&(rop!=GXset)&&(rop!=GXcopy)&&(rop!=GXcopyInverted))
pGlint->PM3_Config2D |= PM3Config2D_FBDestReadEnable;
if (bg != -1) {
REPLICATE(bg);
pGlint->PM3_Config2D |= PM3Config2D_OpaqueSpan;
GLINT_WAIT(4);
GLINT_WRITE_REG(bg, BackgroundColor);
}
else GLINT_WAIT(3);
GLINT_WRITE_REG(fg, PM3ForegroundColor);
PM3_PLANEMASK(planemask);
GLINT_WRITE_REG(pGlint->PM3_Config2D, PM3Config2D);
}
static void
Permedia3SubsequentFillRectSolid32bpp(ScrnInfoPtr pScrn, int x, int y, int w, int h)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia3SubsequentFillRectSolid32bpp");
GLINT_WAIT(6);
/* Put the chip into 16bpp mode */
GLINT_WRITE_REG(1, PixelSize);
/* Now double the displayWidth */
GLINT_WRITE_REG(
PM3FBWriteBufferWidth_Width(pScrn->displayWidth<<1),
PM3FBWriteBufferWidth0);
/* and double the x,w coords */
GLINT_WRITE_REG(
PM3RectanglePosition_XOffset(x<<1) |
PM3RectanglePosition_YOffset(y),
PM3RectanglePosition);
GLINT_WRITE_REG(pGlint->PM3_Render2D |
PM3Render2D_Width(w<<1) | PM3Render2D_Height(h),
PM3Render2D);
/* Now fixup */
GLINT_WRITE_REG(
PM3FBWriteBufferWidth_Width(pScrn->displayWidth),
PM3FBWriteBufferWidth0);
GLINT_WRITE_REG(0, PixelSize);
TRACE_EXIT("Permedia3SubsequentFillRectSolid32bpp");
}
static void
Permedia2SetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
int xdir, int ydir, int rop,
unsigned int planemask, int transparency_color)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SetupForScreenToScreenCopy");
pGlint->BltScanDirection = 0;
if (xdir == 1) pGlint->BltScanDirection |= XPositive;
if (ydir == 1) pGlint->BltScanDirection |= YPositive;
GLINT_WAIT(4);
DO_PLANEMASK(planemask);
GLINT_WRITE_REG(UNIT_DISABLE, ColorDDAMode);
if ((rop == GXset) || (rop == GXclear)) {
pGlint->FrameBufferReadMode = pGlint->pprod;
} else
if ((rop == GXcopy) || (rop == GXcopyInverted)) {
pGlint->FrameBufferReadMode = pGlint->pprod |FBRM_SrcEnable;
} else {
pGlint->FrameBufferReadMode = pGlint->pprod | FBRM_SrcEnable |
FBRM_DstEnable;
}
LOADROP(rop);
TRACE_EXIT("Permedia2SetupForScreenToScreenCopy");
}
static void
Permedia3SubsequentImageWriteScanline(ScrnInfoPtr pScrn, int bufno)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
int dwords = pGlint->dwords;
if (pGlint->ScanlineDirect) {
if (pGlint->cpucount--)
GLINT_WAIT(dwords);
return;
} else {
while(dwords >= pGlint->FIFOSize) {
GLINT_WAIT(pGlint->FIFOSize);
GLINT_WRITE_REG(((pGlint->FIFOSize - 2) << 16) | (0x15 << 4) |
0x05, OutputFIFO);
GLINT_MoveDWORDS(
(CARD32*)((char*)pGlint->IOBase + OutputFIFO + 4),
(CARD32*)pGlint->XAAScanlineColorExpandBuffers[bufno],
pGlint->FIFOSize - 1);
dwords -= pGlint->FIFOSize - 1;
}
if(dwords) {
GLINT_WAIT(dwords + 1);
GLINT_WRITE_REG(((dwords - 1) << 16) | (0x15 << 4) |
0x05, OutputFIFO);
GLINT_MoveDWORDS(
(CARD32*)((char*)pGlint->IOBase + OutputFIFO + 4),
(CARD32*)pGlint->XAAScanlineColorExpandBuffers[bufno],
dwords);
}
}
}
static void
Permedia3RestoreAccelState(ScrnInfoPtr pScrn)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
if ((IS_J2000) && (pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA)) {
GLINT_SLOW_WRITE_REG(pGlint->MultiIndex, BroadcastMask);
}
Permedia3Sync(pScrn);
}
static void
Permedia2SubsequentFillRectSolid24bpp(ScrnInfoPtr pScrn, int x, int y, int w, int h)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SubsequentFillRectSolid24bpp");
GLINT_WAIT(3);
Permedia2LoadCoord(pScrn, x, y, w, h);
GLINT_WRITE_REG(PrimitiveRectangle | XPositive | YPositive, Render);
}
static void
Permedia2SubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SubsequentColorExpandScanline");
if (pGlint->cpucount--)
GLINT_WAIT(pGlint->dwords);
}
/* Solid Fills */
static void
Permedia3SetupForFillRectSolid(ScrnInfoPtr pScrn, int color,
int rop, unsigned int planemask)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia3SetupForFillRectSolid");
/* Prepare Common Render2D & Config2D data */
pGlint->PM3_Render2D =
PM3Render2D_XPositive |
PM3Render2D_YPositive |
PM3Render2D_Operation_Normal;
pGlint->PM3_Config2D =
PM3Config2D_UseConstantSource |
PM3Config2D_ForegroundROPEnable |
PM3Config2D_ForegroundROP(rop) |
PM3Config2D_FBWriteEnable;
GLINT_WAIT(3);
REPLICATE(color);
/* We can't do block fills properly at 32bpp, so we can stick the chip
* into 16bpp and double the width and xcoord, but it seems that at
* extremely high resolutions (above 1600) it doesn't fill.
* so, we fall back to the slower span filling method.
*/
if ((rop == GXcopy) && (pScrn->bitsPerPixel == 32) &&
(pScrn->displayWidth <= 1600)) {
pGlint->AccelInfoRec->SubsequentSolidFillRect =
Permedia3SubsequentFillRectSolid32bpp;
if (pGlint->PM3_UsingSGRAM) {
GLINT_WRITE_REG(color, PM3FBBlockColor);
} else {
pGlint->PM3_Render2D |= PM3Render2D_SpanOperation;
GLINT_WRITE_REG(color, PM3ForegroundColor);
}
} else {
pGlint->AccelInfoRec->SubsequentSolidFillRect =
Permedia3SubsequentFillRectSolid;
/* Can't do block fills at 8bpp either */
if ((rop == GXcopy) && (pScrn->bitsPerPixel == 16)) {
if (pGlint->PM3_UsingSGRAM) {
GLINT_WRITE_REG(color, PM3FBBlockColor);
} else {
pGlint->PM3_Render2D |= PM3Render2D_SpanOperation;
GLINT_WRITE_REG(color, PM3ForegroundColor);
}
} else {
pGlint->PM3_Render2D |= PM3Render2D_SpanOperation;
GLINT_WRITE_REG(color, PM3ForegroundColor);
}
}
PM3_PLANEMASK(planemask);
if (((rop!=GXclear)&&(rop!=GXset)&&(rop!=GXcopy)&&(rop!=GXcopyInverted))
|| ((planemask != 0xffffffff) && !(pGlint->PM3_UsingSGRAM)))
pGlint->PM3_Config2D |= PM3Config2D_FBDestReadEnable;
GLINT_WRITE_REG(pGlint->PM3_Config2D, PM3Config2D);
TRACE_EXIT("Permedia3SetupForFillRectSolid");
}
static void
Permedia3SetClippingRectangle(ScrnInfoPtr pScrn, int x1, int y1, int x2, int y2)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
GLINT_WAIT(3);
GLINT_WRITE_REG(((y1&0x0fff)<<16)|(x1&0x0fff), ScissorMinXY);
GLINT_WRITE_REG(((y2&0x0fff)<<16)|(x2&0x0fff), ScissorMaxXY);
GLINT_WRITE_REG(1, ScissorMode);
pGlint->ClippingOn = TRUE;
}
static void
Permedia2SubsequentScreenToScreenCopy2432bpp(ScrnInfoPtr pScrn, int x1,
int y1, int x2, int y2, int w, int h)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SubsequentScreenToScreenCopy2432bpp");
GLINT_WAIT(4);
Permedia2LoadCoord(pScrn, x2, y2, w, h);
GLINT_WRITE_REG(((y1-y2)&0x0FFF)<<16 | ((x1-x2)&0x0FFF), FBSourceDelta);
GLINT_WRITE_REG(PrimitiveRectangle | pGlint->BltScanDirection, Render);
}
/* 8x8 Mono Pattern Fills */
static void
Permedia3SetupForMono8x8PatternFill(ScrnInfoPtr pScrn,
int patternx, int patterny,
int fg, int bg, int rop,
unsigned int planemask)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia3SetupForMono8x8PatternFill");
REPLICATE(fg);
pGlint->PM3_Render2D =
PM3Render2D_AreaStippleEnable |
PM3Render2D_SpanOperation |
PM3Render2D_XPositive |
PM3Render2D_YPositive |
PM3Render2D_Operation_Normal;
pGlint->PM3_Config2D =
PM3Config2D_UseConstantSource |
PM3Config2D_ForegroundROPEnable |
PM3Config2D_ForegroundROP(rop) |
PM3Config2D_FBWriteEnable;
if ((rop!=GXclear)&&(rop!=GXset)&&(rop!=GXcopy)&&(rop!=GXcopyInverted))
pGlint->PM3_Config2D |= PM3Config2D_FBDestReadEnable;
pGlint->PM3_AreaStippleMode = 1;
/* Mirror stipple pattern horizontally */
#if X_BYTE_ORDER == X_BIG_ENDIAN
pGlint->PM3_AreaStippleMode |= (1<<18);
#endif
pGlint->PM3_AreaStippleMode |= (2<<1);
pGlint->PM3_AreaStippleMode |= (2<<4);
if (bg != -1) {
REPLICATE(bg);
pGlint->PM3_Config2D |= PM3Config2D_OpaqueSpan;
pGlint->PM3_AreaStippleMode |= 1<<20;
GLINT_WAIT(12);
GLINT_WRITE_REG(bg, BackgroundColor);
}
else GLINT_WAIT(11);
GLINT_WRITE_REG((patternx & 0xFF), AreaStipplePattern0);
GLINT_WRITE_REG((patternx & 0xFF00) >> 8, AreaStipplePattern1);
GLINT_WRITE_REG((patternx & 0xFF0000) >> 16, AreaStipplePattern2);
GLINT_WRITE_REG((patternx & 0xFF000000) >> 24, AreaStipplePattern3);
GLINT_WRITE_REG((patterny & 0xFF), AreaStipplePattern4);
GLINT_WRITE_REG((patterny & 0xFF00) >> 8, AreaStipplePattern5);
GLINT_WRITE_REG((patterny & 0xFF0000) >> 16, AreaStipplePattern6);
GLINT_WRITE_REG((patterny & 0xFF000000) >> 24, AreaStipplePattern7);
GLINT_WRITE_REG(fg, PM3ForegroundColor);
PM3_PLANEMASK(planemask);
GLINT_WRITE_REG(pGlint->PM3_Config2D, PM3Config2D);
TRACE_EXIT("Permedia3SetupForMono8x8PatternFill");
}
static void
Permedia2PolySegmentThinSolidWrapper(
DrawablePtr pDraw,
GCPtr pGC,
int nseg,
xSegment *pSeg
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
GLINTPtr pGlint = GLINTPTR(infoRec->pScrn);
TRACE("Permedia2PolySegmentThinSolidWrapper");
pGlint->CurrentGC = pGC;
pGlint->CurrentDrawable = pDraw;
if(infoRec->NeedToSync) (*infoRec->Sync)(infoRec->pScrn);
XAAPolySegment(pDraw, pGC, nseg, pSeg);
}
void
Permedia2Sync(ScrnInfoPtr pScrn)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
CHECKCLIPPING;
while (GLINT_READ_REG(DMACount) != 0);
GLINT_WAIT(2);
GLINT_WRITE_REG(0x400, FilterMode);
GLINT_WRITE_REG(0, GlintSync);
do {
while(GLINT_READ_REG(OutFIFOWords) == 0);
} while (GLINT_READ_REG(OutputFIFO) != Sync_tag);
}
static void
Permedia2WritePixmap8bpp(
ScrnInfoPtr pScrn,
int x, int y, int w, int h,
unsigned char *src,
int srcwidth,
int rop,
unsigned int planemask,
int transparency_color,
int bpp, int depth
)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
GLINTPtr pGlint = GLINTPTR(pScrn);
int skipleft, dwords, count;
CARD32* srcp;
unsigned char *srcpbyte;
Bool FastTexLoad = FALSE;
TRACE_ENTER("Permedia2SubsequentMono8x8PatternFillRect24bpp");
GLINT_WAIT(3);
DO_PLANEMASK(planemask);
GLINT_WRITE_REG(pGlint->RasterizerSwap,RasterizerMode);
if (rop == GXcopy) {
GLINT_WRITE_REG(pGlint->pprod | FBRM_Packed, FBReadMode);
} else {
GLINT_WRITE_REG(pGlint->pprod | FBRM_DstEnable, FBReadMode);
}
dwords = (w + 3) >> 2;
#if X_BYTE_ORDER == X_LITTLE_ENDIAN
if((!(x&3)) && (!(w&3))) FastTexLoad = TRUE;
#endif
if((rop != GXcopy) || (planemask != ~0))
FastTexLoad = FALSE;
if (rop == GXcopy) {
skipleft = 0;
} else {
if((skipleft = (long)src & 0x03)) {
skipleft /= (bpp>>3);
x -= skipleft;
w += skipleft;
src = (unsigned char*)((long)src & ~0x03);
}
}
static void
Permedia2PolylinesThinSolidWrapper(
DrawablePtr pDraw,
GCPtr pGC,
int mode,
int npt,
DDXPointPtr pPts
){
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
GLINTPtr pGlint = GLINTPTR(infoRec->pScrn);
TRACE("Permedia2PolylinesThinSolidWrapper");
pGlint->CurrentGC = pGC;
pGlint->CurrentDrawable = pDraw;
if(infoRec->NeedToSync) (*infoRec->Sync)(infoRec->pScrn);
XAAPolyLines(pDraw, pGC, mode, npt, pPts);
}
static void
Permedia3SubsequentFillRectSolid(ScrnInfoPtr pScrn, int x, int y, int w, int h)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia3SubsequentFillRectSolid");
GLINT_WAIT(2);
GLINT_WRITE_REG(
PM3RectanglePosition_XOffset(x) |
PM3RectanglePosition_YOffset(y),
PM3RectanglePosition);
GLINT_WRITE_REG(pGlint->PM3_Render2D |
PM3Render2D_Width(w) | PM3Render2D_Height(h),
PM3Render2D);
TRACE_EXIT("Permedia3SubsequentFillRectSolid");
}
static void
Permedia2SetupForFillRectSolid24bpp(ScrnInfoPtr pScrn, int color,
int rop, unsigned int planemask)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
pGlint->ForeGroundColor = color;
TRACE_ENTER("Permedia2SetupForFillRectSolid24bpp");
GLINT_WAIT(5);
GLINT_WRITE_REG(UNIT_ENABLE, ColorDDAMode);
GLINT_WRITE_REG(color, ConstantColor);
if (rop == GXcopy) {
GLINT_WRITE_REG(pGlint->pprod, FBReadMode);
} else {
GLINT_WRITE_REG(pGlint->pprod | FBRM_DstEnable, FBReadMode);
}
LOADROP(rop);
}
static void Permedia2LoadCoord(
ScrnInfoPtr pScrn,
int x, int y,
int w, int h
){
GLINTPtr pGlint = GLINTPTR(pScrn);
if ((h != pGlint->h) || (w != pGlint->w)) {
pGlint->w = w;
pGlint->h = h;
GLINT_WRITE_REG(((h&0x0FFF)<<16)|(w&0x0FFF), RectangleSize);
}
if ((y != pGlint->y) || (x != pGlint->x)) {
pGlint->x = x;
pGlint->y = y;
GLINT_WRITE_REG(((y&0x0FFF)<<16)|(x&0x0FFF), RectangleOrigin);
}
}
static void
Permedia2SetupForSolidLine(ScrnInfoPtr pScrn, int color,
int rop, unsigned int planemask)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SetupForSolidLine");
GLINT_WAIT(6);
DO_PLANEMASK(planemask);
GLINT_WRITE_REG(UNIT_DISABLE, ColorDDAMode);
GLINT_WRITE_REG(color, GLINTColor);
if (rop == GXcopy) {
GLINT_WRITE_REG(pGlint->pprod, FBReadMode);
} else {
GLINT_WRITE_REG(pGlint->pprod | FBRM_DstEnable, FBReadMode);
}
LOADROP(rop);
}
static void
Permedia2SubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
int patternx, int patterny,
int x, int y,
int w, int h)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SubsequentMono8x8PatternFillRect()");
GLINT_WAIT(9);
Permedia2LoadCoord(pScrn, x, y, w, h);
if (pGlint->FrameBufferReadMode != -1) {
if (pGlint->ROP == GXcopy) {
GLINT_WRITE_REG(pGlint->BackGroundColor, FBBlockColor);
GLINT_WRITE_REG(ASM_InvertPattern|patternx<<7|patterny<<12|
STIPPLE_SWAP | UNIT_ENABLE, AreaStippleMode);
GLINT_WRITE_REG(AreaStippleEnable | FastFillEnable |
XPositive | YPositive | PrimitiveRectangle, Render);
} else {
GLINT_WRITE_REG(pGlint->ForeGroundColor, ConstantColor);
GLINT_WRITE_REG(pGlint->BackGroundColor, Texel0);
GLINT_WRITE_REG(patternx<<7|patterny<<12|
STIPPLE_SWAP | UNIT_ENABLE, AreaStippleMode);
GLINT_WRITE_REG(AreaStippleEnable | XPositive | TextureEnable |
YPositive | PrimitiveRectangle, Render);
return;
}
}
if (pGlint->ROP == GXcopy) {
GLINT_WRITE_REG(pGlint->ForeGroundColor, FBBlockColor);
pGlint->FrameBufferReadMode = FastFillEnable;
} else {
GLINT_WRITE_REG(pGlint->ForeGroundColor, ConstantColor);
pGlint->FrameBufferReadMode = 0;
}
GLINT_WRITE_REG(patternx<<7|patterny<<12|STIPPLE_SWAP|UNIT_ENABLE, AreaStippleMode);
GLINT_WRITE_REG(AreaStippleEnable | pGlint->FrameBufferReadMode |
XPositive | YPositive | PrimitiveRectangle, Render);
TRACE_EXIT("Permedia2SubsequentMono8x8PatternFillRect()");
}
static void
Permedia3SubsequentScanlineCPUToScreenColorExpandFill(
ScrnInfoPtr pScrn,
int x, int y, int w, int h,
int skipleft
){
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("Permedia2SubsequentScanlineCPUToScreenColorExpandFill");
pGlint->dwords = ((w + 31) >> 5); /* dwords per scanline */
pGlint->cpucount = h;
GLINT_WAIT(5);
GLINT_WRITE_REG(((y&0x0fff)<<16)|((x+skipleft)&0x0fff), ScissorMinXY);
GLINT_WRITE_REG((((y+h)&0x0fff)<<16)|((x+w)&0x0fff), ScissorMaxXY);
GLINT_WRITE_REG(
PM3RectanglePosition_XOffset(x) |
PM3RectanglePosition_YOffset(y),
PM3RectanglePosition);
GLINT_WRITE_REG(pGlint->PM3_Render2D |
PM3Render2D_Width(w) | PM3Render2D_Height(h),
PM3Render2D);
#if defined(__alpha__)
if (0) /* force Alpha to use indirect always */
#else
if ((pGlint->dwords*h) < pGlint->FIFOSize)
#endif
{
/* Turn on direct for less than 120 dword colour expansion */
pGlint->XAAScanlineColorExpandBuffers[0] = pGlint->IOBase+OutputFIFO+4;
pGlint->ScanlineDirect = 1;
GLINT_WRITE_REG(((pGlint->dwords*h)-1)<<16 | 0x0D, OutputFIFO);
GLINT_WAIT(pGlint->dwords*h);
} else {
/* Use indirect for anything else */
pGlint->XAAScanlineColorExpandBuffers[0] = pGlint->ScratchBuffer;
pGlint->ScanlineDirect = 0;
}
pGlint->cpucount--;
}
