static void
SMI_SetupForSolidFill(ScrnInfoPtr pScrn, int color, int rop,
unsigned int planemask)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SetupForSolidFill");
DEBUG((VERBLEV, "color=%08X rop=%02X\n", color, rop));
pSmi->AccelCmd = XAAPatternROP[rop]
| SMI_BITBLT
| SMI_START_ENGINE;
if (pSmi->ClipTurnedOn)
{
WaitQueue(4);
WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
pSmi->ClipTurnedOn = FALSE;
}
else
{
WaitQueue(3);
}
WRITE_DPR(pSmi, 0x14, color);
WRITE_DPR(pSmi, 0x34, 0xFFFFFFFF);
WRITE_DPR(pSmi, 0x38, 0xFFFFFFFF);
LEAVE_PROC("SMI_SetupForSolidFill");
}
static void
SMI_SubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn, int patx, int paty,
int x, int y, int w, int h)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SubsequentColor8x8PatternFillRect");
DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d\n", x, y, w, h));
if (pScrn->bitsPerPixel == 24)
{
x *= 3;
w *= 3;
if (pSmi->Chipset == SMI_LYNX)
{
y *= 3;
}
}
WaitQueue(3);
WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF)); /* PDR#950 */
WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
LEAVE_PROC("SMI_SubsequentColor8x8PatternFillRect");
}
static void
SMI_SetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir, int ydir, int rop,
unsigned int planemask, int trans)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SetupForScreenToScreenCopy");
DEBUG((VERBLEV, "xdir=%d ydir=%d rop=%02X trans=%08X\n", xdir, ydir,
rop, trans));
pSmi->AccelCmd = XAACopyROP[rop]
| SMI_BITBLT
| SMI_START_ENGINE;
if ((xdir == -1) || (ydir == -1))
{
pSmi->AccelCmd |= SMI_RIGHT_TO_LEFT;
}
if (trans != -1)
{
pSmi->AccelCmd |= SMI_TRANSPARENT_SRC | SMI_TRANSPARENT_PXL;
WaitQueue(1);
WRITE_DPR(pSmi, 0x20, trans);
}
if (pSmi->ClipTurnedOn)
{
WaitQueue(1);
WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
pSmi->ClipTurnedOn = FALSE;
}
LEAVE_PROC("SMI_SetupForScreenToScreenCopy");
}
static void
SMI_DisableClipping(ScrnInfoPtr pScrn)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_DisableClipping");
pSmi->ScissorsLeft = 0;
if (pScrn->bitsPerPixel == 24)
{
if (pSmi->Chipset == SMI_LYNX)
{
pSmi->ScissorsRight = ((pSmi->height * 3) << 16)
| (pSmi->width * 3);
}
else
{
pSmi->ScissorsRight = (pSmi->height << 16) | (pSmi->width * 3);
}
}
else
{
pSmi->ScissorsRight = (pSmi->height << 16) | pSmi->width;
}
pSmi->ClipTurnedOn = FALSE;
WaitQueue(2);
WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
WRITE_DPR(pSmi, 0x30, pSmi->ScissorsRight);
LEAVE_PROC("SMI_DisableClipping");
}
void
SMI_GEReset(ScrnInfoPtr pScrn, int from_timeout, int line, char *file)
{
SMIPtr pSmi = SMIPTR(pScrn);
CARD8 tmp;
ENTER_PROC("SMI_GEReset");
if (from_timeout)
{
if (pSmi->GEResetCnt++ < 10 || xf86GetVerbosity() > 1)
{
xf86DrvMsg(pScrn->scrnIndex,X_INFO,"\tSMI_GEReset called from %s line %d\n", file, line);
}
}
else
{
WaitIdleEmpty();
}
tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x15);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x15, tmp | 0x30);
WaitIdleEmpty();
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x15, tmp);
SMI_EngineReset(pScrn);
LEAVE_PROC("SMI_GEReset");
}
static void
SMI_SetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, int fg, int bg,
int rop, unsigned int planemask)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SetupForCPUToScreenColorExpandFill");
DEBUG((VERBLEV, "fg=%08X bg=%08X rop=%02X\n", fg, bg, rop));
pSmi->AccelCmd = XAACopyROP[rop]
| SMI_HOSTBLT_WRITE
| SMI_SRC_MONOCHROME
| SMI_START_ENGINE;
if (bg == -1)
{
pSmi->AccelCmd |= SMI_TRANSPARENT_SRC;
WaitQueue(3);
WRITE_DPR(pSmi, 0x14, fg);
WRITE_DPR(pSmi, 0x18, ~fg);
WRITE_DPR(pSmi, 0x20, fg);
}
else
{
WaitQueue(2);
WRITE_DPR(pSmi, 0x14, fg);
WRITE_DPR(pSmi, 0x18, bg);
}
LEAVE_PROC("SMI_SetupForCPUToScreenColorExpandFill");
}
static void
SMI_SetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty, int rop,
unsigned int planemask, int trans_color)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SetupForColor8x8PatternFill");
DEBUG((VERBLEV, "patx=%d paty=%d rop=%02X trans_color=%08X\n", patx, paty,
rop, trans_color));
pSmi->AccelCmd = XAAPatternROP[rop]
| SMI_BITBLT
| SMI_COLOR_PATTERN
| SMI_START_ENGINE;
if (pScrn->bitsPerPixel <= 16)
{
/* PDR#950 */
CARD8* pattern = pSmi->FBBase
+ (patx + paty * pSmi->Stride) * pSmi->Bpp;
WaitIdleEmpty();
WRITE_DPR(pSmi, 0x0C, SMI_BITBLT | SMI_COLOR_PATTERN);
memcpy(pSmi->DataPortBase, pattern, 8 * pSmi->Bpp * 8);
}
else
{
if (pScrn->bitsPerPixel == 24)
{
patx *= 3;
if (pSmi->Chipset == SMI_LYNX)
{
paty *= 3;
}
}
WaitQueue(1);
WRITE_DPR(pSmi, 0x00, (patx << 16) | (paty & 0xFFFF));
}
if (trans_color == -1)
{
pSmi->AccelCmd |= SMI_TRANSPARENT_SRC | SMI_TRANSPARENT_PXL;
WaitQueue(1);
WRITE_DPR(pSmi, 0x20, trans_color);
}
if (pSmi->ClipTurnedOn)
{
WaitQueue(1);
WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
pSmi->ClipTurnedOn = FALSE;
}
LEAVE_PROC("SMI_SetupForColor8x8PatternFill");
}
/* The sync function for the GE */
void
SMI_AccelSync(ScrnInfoPtr pScrn)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_AccelSync");
WaitIdleEmpty(); /* #161 */
LEAVE_PROC("SMI_AccelSync");
}
static void
SMI_SubsequentImageWriteRect(ScrnInfoPtr pScrn, int x, int y, int w, int h,
int skipleft)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SubsequentImageWriteRect");
DEBUG((VERBLEV, "x=%d y=%d w=%d h=%d skipleft=%d\n", x, y, w, h, skipleft));
if (pScrn->bitsPerPixel == 24)
{
x *= 3;
w *= 3;
skipleft *= 3;
if (pSmi->Chipset == SMI_LYNX)
{
y *= 3;
}
}
if (skipleft)
{
WaitQueue(5);
WRITE_DPR(pSmi, 0x2C, (pSmi->ScissorsLeft & 0xFFFF0000) |
(x + skipleft) | 0x2000);
pSmi->ClipTurnedOn = TRUE;
}
else
{
if (pSmi->ClipTurnedOn)
{
WaitQueue(5);
WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
pSmi->ClipTurnedOn = FALSE;
}
else
{
WaitQueue(4);
}
}
WRITE_DPR(pSmi, 0x00, 0);
WRITE_DPR(pSmi, 0x04, (x << 16) | (y * 0xFFFF));
WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
LEAVE_PROC("SMI_SubsequentImageWriteRect");
}
static void
SMI_ValidatePolylines(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
SMIPtr pSmi = SMIPTR(infoRec->pScrn);
ENTER_PROC("SMI_ValidatePolylines");
pSmi->ValidatePolylines(pGC, changes, pDraw);
if (pGC->ops->Polylines == XAAFallbackOps.Polylines)
{
/* Override the Polylines function with our own Polylines function. */
pGC->ops->Polylines = SMI_Polylines;
}
LEAVE_PROC("SMI_ValidatePolylines");
}
static void
SMI_SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int x1, int y1, int x2,
int y2, int w, int h)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SubsequentScreenToScreenCopy");
DEBUG((VERBLEV, "x1=%d y1=%d x2=%d y2=%d w=%d h=%d\n", x1, y1, x2, y2, w,
h));
if (pSmi->AccelCmd & SMI_RIGHT_TO_LEFT)
{
x1 += w - 1;
y1 += h - 1;
x2 += w - 1;
y2 += h - 1;
}
if (pScrn->bitsPerPixel == 24)
{
x1 *= 3;
x2 *= 3;
w *= 3;
if (pSmi->Chipset == SMI_LYNX)
{
y1 *= 3;
y2 *= 3;
}
if (pSmi->AccelCmd & SMI_RIGHT_TO_LEFT)
{
x1 += 2;
x2 += 2;
}
}
WaitQueue(4);
WRITE_DPR(pSmi, 0x00, (x1 << 16) + (y1 & 0xFFFF));
WRITE_DPR(pSmi, 0x04, (x2 << 16) + (y2 & 0xFFFF));
WRITE_DPR(pSmi, 0x08, (w << 16) + (h & 0xFFFF));
WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
LEAVE_PROC("SMI_SubsequentScreenToScreenCopy");
}
static void
SMI_SetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty, int fg,
int bg, int rop, unsigned int planemask)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SetupForMono8x8PatternFill");
DEBUG((VERBLEV, "patx=%08X paty=%08X fg=%08X bg=%08X rop=%02X\n", patx,
paty, fg, bg, rop));
pSmi->AccelCmd = XAAPatternROP[rop]
| SMI_BITBLT
| SMI_START_ENGINE;
if (pSmi->ClipTurnedOn)
{
WaitQueue(1);
WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
pSmi->ClipTurnedOn = FALSE;
}
if (bg == -1)
{
WaitQueue(5);
WRITE_DPR(pSmi, 0x14, fg);
WRITE_DPR(pSmi, 0x18, ~fg);
WRITE_DPR(pSmi, 0x20, fg);
WRITE_DPR(pSmi, 0x34, patx);
WRITE_DPR(pSmi, 0x38, paty);
}
else
{
WaitQueue(4);
WRITE_DPR(pSmi, 0x14, fg);
WRITE_DPR(pSmi, 0x18, bg);
WRITE_DPR(pSmi, 0x34, patx);
WRITE_DPR(pSmi, 0x38, paty);
}
LEAVE_PROC("SMI_SetupForMono8x8PatternFill");
}
static void
SMI_SetClippingRectangle(ScrnInfoPtr pScrn, int left, int top, int right,
int bottom)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SetClippingRectangle");
DEBUG((VERBLEV, "left=%d top=%d right=%d bottom=%d\n", left, top, right,
bottom));
/* CZ 26.10.2001: this code prevents offscreen pixmaps being drawn ???
left = max(left, 0);
top = max(top, 0);
right = min(right, pSmi->width);
bottom = min(bottom, pSmi->height);
*/
if (pScrn->bitsPerPixel == 24)
{
left *= 3;
right *= 3;
if (pSmi->Chipset == SMI_LYNX)
{
top *= 3;
bottom *= 3;
}
}
pSmi->ScissorsLeft = (top << 16) | (left & 0xFFFF) | 0x2000;
pSmi->ScissorsRight = (bottom << 16) | (right & 0xFFFF);
pSmi->ClipTurnedOn = FALSE;
WaitQueue(2);
WRITE_DPR(pSmi, 0x2C, pSmi->ScissorsLeft);
WRITE_DPR(pSmi, 0x30, pSmi->ScissorsRight);
LEAVE_PROC("SMI_SetClippingRectangle");
}
/******************************************************************************\
|* SMI_RefreshArea
|*=============================================================================
|*
|* PARAMETERS: pScrn Pointer to ScrnInfo structure.
|* num Number of boxes to refresh.
|* pbox Pointer to an array of boxes to refresh.
|*
|* DESCRIPTION: Refresh a portion of the shadow buffer to the visual screen
|* buffer. This is mainly used for rotation purposes.
|* y
|* RETURNS: Nothing.
|*
\******************************************************************************/
void SMI_RefreshArea(ScrnInfoPtr pScrn, int num, BoxPtr pbox)
{
SMIPtr pSmi = SMIPTR(pScrn);
int width, height, srcX, srcY, destX, destY;
ENTER_PROC("SMI_RefreshArea");
/* #671 */
if (pSmi->polyLines)
{
pSmi->polyLines = FALSE;
return;
}
if (pSmi->rotate)
{
/* IF we need to do rotation, setup the hardware here. */
WaitIdleEmpty();
WRITE_DPR(pSmi, 0x10, pSmi->ShadowPitch);
WRITE_DPR(pSmi, 0x3C, pSmi->ShadowPitch);
WRITE_DPR(pSmi, 0x44, pSmi->FBOffset >> 3);
}
static void
SMI_SubsequentSolidHorVertLine(ScrnInfoPtr pScrn, int x, int y, int len,
int dir)
{
SMIPtr pSmi = SMIPTR(pScrn);
int w, h;
ENTER_PROC("SMI_SubsequentSolidHorVertLine");
DEBUG((VERBLEV, "x=%d y=%d len=%d dir=%d\n", x, y, len, dir));
if (dir == DEGREES_0)
{
w = len;
h = 1;
}
else
{
w = 1;
h = len;
}
if (pScrn->bitsPerPixel == 24)
{
x *= 3;
w *= 3;
if (pSmi->Chipset == SMI_LYNX)
{
y *= 3;
}
}
WaitQueue(3);
WRITE_DPR(pSmi, 0x04, (x << 16) | (y & 0xFFFF));
WRITE_DPR(pSmi, 0x08, (w << 16) | (h & 0xFFFF));
WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
LEAVE_PROC("SMI_SubsequentSolidHorVertLine");
}
static void
SMI_SetupForImageWrite(ScrnInfoPtr pScrn, int rop, unsigned int planemask,
int trans_color, int bpp, int depth)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_SetupForImageWrite");
DEBUG((VERBLEV, "rop=%02X trans_color=%08X bpp=%d depth=%d\n", rop,
trans_color, bpp, depth));
pSmi->AccelCmd = XAACopyROP[rop]
| SMI_HOSTBLT_WRITE
| SMI_START_ENGINE;
if (trans_color != -1)
{
pSmi->AccelCmd |= SMI_TRANSPARENT_SRC | SMI_TRANSPARENT_PXL;
WaitQueue(1);
WRITE_DPR(pSmi, 0x20, trans_color);
}
LEAVE_PROC("SMI_SetupForImageWrite");
}
void
SMI_EngineReset(ScrnInfoPtr pScrn)
{
SMIPtr pSmi = SMIPTR(pScrn);
CARD32 DEDataFormat = 0;
int i;
int xyAddress[] = { 320, 400, 512, 640, 800, 1024, 1280, 1600, 2048 };
ENTER_PROC("SMI_EngineReset");
pSmi->Stride = (pSmi->width * pSmi->Bpp + 15) & ~15;
switch (pScrn->bitsPerPixel)
{
case 8:
DEDataFormat = 0x00000000;
break;
case 16:
pSmi->Stride >>= 1;
DEDataFormat = 0x00100000;
break;
case 24:
DEDataFormat = 0x00300000;
break;
case 32:
pSmi->Stride >>= 2;
DEDataFormat = 0x00200000;
break;
}
for (i = 0; i < sizeof(xyAddress) / sizeof(xyAddress[0]); i++)
{
if (pSmi->rotate)
{
if (xyAddress[i] == pSmi->height)
{
DEDataFormat |= i << 16;
break;
}
}
else
{
if (xyAddress[i] == pSmi->width)
{
DEDataFormat |= i << 16;
break;
}
}
}
WaitIdleEmpty();
WRITE_DPR(pSmi, 0x10, (pSmi->Stride << 16) | pSmi->Stride);
WRITE_DPR(pSmi, 0x1C, DEDataFormat);
WRITE_DPR(pSmi, 0x24, 0xFFFFFFFF);
WRITE_DPR(pSmi, 0x28, 0xFFFFFFFF);
WRITE_DPR(pSmi, 0x3C, (pSmi->Stride << 16) | pSmi->Stride);
WRITE_DPR(pSmi, 0x40, 0);
WRITE_DPR(pSmi, 0x44, 0);
SMI_DisableClipping(pScrn);
LEAVE_PROC("SMI_EngineReset");
}
static void
SMI_Polylines(DrawablePtr pDraw, GCPtr pGC, int mode, int npt,
DDXPointPtr pptInit)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
ScrnInfoPtr pScrn = infoRec->pScrn;
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_Polylines");
/* Call the original Polylines function. */
pGC->ops->Polylines = XAAFallbackOps.Polylines;
(*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
pGC->ops->Polylines = SMI_Polylines;
if (IS_VISIBLE(pDraw) && npt)
{
/* Allocate a temporary buffer for all segments of the polyline. */
BoxPtr pBox = xnfcalloc(sizeof(BoxRec), npt);
int extra = pGC->lineWidth >> 1, box;
if (npt > 1)
{
/* Adjust the extra space required per polyline segment. */
if (pGC->joinStyle == JoinMiter)
{
extra = 6 * pGC->lineWidth;
}
else if (pGC->capStyle == CapProjecting)
{
extra = pGC->lineWidth;
}
}
for (box = 0; --npt;)
{
/* Setup the bounding box for one polyline segment. */
pBox[box].x1 = pptInit->x;
pBox[box].y1 = pptInit->y;
pptInit++;
pBox[box].x2 = pptInit->x;
pBox[box].y2 = pptInit->y;
if (mode == CoordModePrevious)
{
pBox[box].x2 += pBox[box].x1;
pBox[box].y2 += pBox[box].y1;
}
/* Sort coordinates. */
if (pBox[box].x1 > pBox[box].x2)
{
int tmp = pBox[box].x1;
pBox[box].x1 = pBox[box].x2;
pBox[box].x2 = tmp;
}
if (pBox[box].y1 > pBox[box].y2)
{
int tmp = pBox[box].y1;
pBox[box].y1 = pBox[box].y2;
pBox[box].y2 = tmp;
}
/* Add extra space required for each polyline segment. */
pBox[box].x1 -= extra;
pBox[box].y1 -= extra;
pBox[box].x2 += extra + 1;
pBox[box].y2 += extra + 1;
/* See if we need to draw this polyline segment. */
TRANSLATE_BOX(pBox[box], pDraw);
TRIM_BOX(pBox[box], pGC);
if (BOX_NOT_EMPTY(pBox[box]))
{
box++;
}
}
if (box)
{
/* Refresh all polyline segments now. */
SMI_RefreshArea(pScrn, box, pBox);
}
/* Free the temporary buffer. */
xfree(pBox);
}
Bool
SMI_AccelInit(ScreenPtr pScreen)
{
XAAInfoRecPtr infoPtr;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
SMIPtr pSmi = SMIPTR(pScrn);
/*BoxRec AvailFBArea;*/
Bool ret;
/*int numLines, maxLines;*/
ENTER_PROC("SMI_AccelInit");
pSmi->AccelInfoRec = infoPtr = XAACreateInfoRec();
if (infoPtr == NULL)
{
LEAVE_PROC("SMI_AccelInit");
return FALSE;
}
infoPtr->Flags = PIXMAP_CACHE
| LINEAR_FRAMEBUFFER
| OFFSCREEN_PIXMAPS;
infoPtr->Sync = SMI_AccelSync;
/* Screen to screen copies */
infoPtr->ScreenToScreenCopyFlags = NO_PLANEMASK
| ONLY_TWO_BITBLT_DIRECTIONS;
infoPtr->SetupForScreenToScreenCopy = SMI_SetupForScreenToScreenCopy;
infoPtr->SubsequentScreenToScreenCopy = SMI_SubsequentScreenToScreenCopy;
if (pScrn->bitsPerPixel == 24)
{
infoPtr->ScreenToScreenCopyFlags |= NO_TRANSPARENCY;
}
if ((pSmi->Chipset == SMI_LYNX3D) && (pScrn->bitsPerPixel == 8))
{
infoPtr->ScreenToScreenCopyFlags |= GXCOPY_ONLY;
}
/* Solid Fills */
infoPtr->SolidFillFlags = NO_PLANEMASK;
infoPtr->SetupForSolidFill = SMI_SetupForSolidFill;
infoPtr->SubsequentSolidFillRect = SMI_SubsequentSolidFillRect;
/* Solid Lines */
infoPtr->SolidLineFlags = NO_PLANEMASK;
infoPtr->SetupForSolidLine = SMI_SetupForSolidFill;
infoPtr->SubsequentSolidHorVertLine = SMI_SubsequentSolidHorVertLine;
/* Color Expansion Fills */
infoPtr->CPUToScreenColorExpandFillFlags = ROP_NEEDS_SOURCE
| NO_PLANEMASK
| BIT_ORDER_IN_BYTE_MSBFIRST
| LEFT_EDGE_CLIPPING
| CPU_TRANSFER_PAD_DWORD
| SCANLINE_PAD_DWORD;
infoPtr->ColorExpandBase = pSmi->DataPortBase;
infoPtr->ColorExpandRange = pSmi->DataPortSize;
infoPtr->SetupForCPUToScreenColorExpandFill =
SMI_SetupForCPUToScreenColorExpandFill;
infoPtr->SubsequentCPUToScreenColorExpandFill =
SMI_SubsequentCPUToScreenColorExpandFill;
/* 8x8 Mono Pattern Fills */
infoPtr->Mono8x8PatternFillFlags = NO_PLANEMASK
| HARDWARE_PATTERN_PROGRAMMED_BITS
| HARDWARE_PATTERN_SCREEN_ORIGIN
| BIT_ORDER_IN_BYTE_MSBFIRST;
infoPtr->SetupForMono8x8PatternFill = SMI_SetupForMono8x8PatternFill;
infoPtr->SubsequentMono8x8PatternFillRect =
SMI_SubsequentMono8x8PatternFillRect;
/* 8x8 Color Pattern Fills */
if (!SMI_LYNX3D_SERIES(pSmi->Chipset) || (pScrn->bitsPerPixel != 24))
{
infoPtr->Color8x8PatternFillFlags = NO_PLANEMASK
| HARDWARE_PATTERN_SCREEN_ORIGIN;
infoPtr->SetupForColor8x8PatternFill =
SMI_SetupForColor8x8PatternFill;
infoPtr->SubsequentColor8x8PatternFillRect =
SMI_SubsequentColor8x8PatternFillRect;
}
#if SMI_USE_IMAGE_WRITES
/* Image Writes */
infoPtr->ImageWriteFlags = ROP_NEEDS_SOURCE
| NO_PLANEMASK
| CPU_TRANSFER_PAD_DWORD
| SCANLINE_PAD_DWORD;
infoPtr->ImageWriteBase = pSmi->DataPortBase;
infoPtr->ImageWriteRange = pSmi->DataPortSize;
infoPtr->SetupForImageWrite = SMI_SetupForImageWrite;
infoPtr->SubsequentImageWriteRect = SMI_SubsequentImageWriteRect;
#endif
/* Clipping */
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;
infoPtr->SetClippingRectangle = SMI_SetClippingRectangle;
infoPtr->DisableClipping = SMI_DisableClipping;
/* Pixmap Cache */
if (pScrn->bitsPerPixel == 24)
{
infoPtr->CachePixelGranularity = 16;
}
else
{
infoPtr->CachePixelGranularity = 128 / pScrn->bitsPerPixel;
}
/* Offscreen Pixmaps */
infoPtr->maxOffPixWidth = 4096;
infoPtr->maxOffPixHeight = 4096;
if (pScrn->bitsPerPixel == 24)
{
infoPtr->maxOffPixWidth = 4096 / 3;
if (pSmi->Chipset == SMI_LYNX)
{
infoPtr->maxOffPixHeight = 4096 / 3;
}
}
SMI_EngineReset(pScrn);
/* CZ 18.06.2001: moved to smi_driver.c before the NoAccel question
to have offscreen framebuffer in NoAccel mode */
#if 0
maxLines = pSmi->FBReserved / (pSmi->width * pSmi->Bpp);
if (pSmi->rotate)
{
numLines = maxLines;
}
else
{
#if defined(XvExtension) && SMI_USE_VIDEO
numLines = ((pSmi->FBReserved - pSmi->width * pSmi->Bpp * pSmi->height)
* 25 / 100 + pSmi->width * pSmi->Bpp - 1)
/ (pSmi->width * pSmi->Bpp);
numLines += pSmi->height;
#else
numLines = maxLines;
#endif
}
AvailFBArea.x1 = 0;
AvailFBArea.y1 = 0;
AvailFBArea.x2 = pSmi->width;
AvailFBArea.y2 = numLines;
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "FrameBuffer Box: %d,%d - %d,%d\n",
AvailFBArea.x1, AvailFBArea.y1, AvailFBArea.x2, AvailFBArea.y2);
xf86InitFBManager(pScreen, &AvailFBArea);
#endif
ret = XAAInit(pScreen, infoPtr);
if (ret && pSmi->shadowFB) /* #671 */
{
pSmi->ValidatePolylines = infoPtr->ValidatePolylines;
infoPtr->ValidatePolylines = SMI_ValidatePolylines;
}
LEAVE_PROC("SMI_AccelInit");
return(ret);
}
