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_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");
}
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_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_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_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");
}
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_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_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
SMILynx_WriteMode(ScrnInfoPtr pScrn, vgaRegPtr vgaSavePtr, SMIRegPtr restore)
{
SMIPtr pSmi = SMIPTR(pScrn);
int i;
CARD8 tmp;
CARD32 offset;
vgaHWPtr hwp = VGAHWPTR(pScrn);
int vgaIOBase = hwp->IOBase;
int vgaCRIndex = vgaIOBase + VGA_CRTC_INDEX_OFFSET;
int vgaCRData = vgaIOBase + VGA_CRTC_DATA_OFFSET;
ENTER();
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x17, restore->SR17);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x18, restore->SR18);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x20, restore->SR20);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21, restore->SR21);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x22, restore->SR22);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x23, restore->SR23);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x24, restore->SR24);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x31, restore->SR31);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x32, restore->SR32);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x66, restore->SR66);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x68, restore->SR68);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x69, restore->SR69);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6A, restore->SR6A);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6B, restore->SR6B);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6C, restore->SR6C);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6D, restore->SR6D);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x81, restore->SR81);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0xA0, restore->SRA0);
if (pSmi->useBIOS && restore->mode != 0){
pSmi->pInt10->num = 0x10;
pSmi->pInt10->ax = restore->mode | 0x80;
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Setting mode 0x%02X\n",
restore->mode);
xf86ExecX86int10(pSmi->pInt10);
/* Enable linear mode. */
outb(pSmi->PIOBase + VGA_SEQ_INDEX, 0x18);
tmp = inb(pSmi->PIOBase + VGA_SEQ_DATA);
outb(pSmi->PIOBase + VGA_SEQ_DATA, tmp | 0x01);
/* Enable DPR/VPR registers. */
tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21, tmp & ~0x03);
} else {
/* Restore the standard VGA registers */
vgaHWRestore(pScrn, vgaSavePtr, VGA_SR_ALL);
if (restore->smiDACMask) {
VGAOUT8(pSmi, VGA_DAC_MASK, restore->smiDACMask);
} else {
VGAOUT8(pSmi, VGA_DAC_MASK, 0xFF);
}
VGAOUT8(pSmi, VGA_DAC_WRITE_ADDR, 0);
for (i = 0; i < 256; i++) {
VGAOUT8(pSmi, VGA_DAC_DATA, restore->smiDacRegs[i][0]);
VGAOUT8(pSmi, VGA_DAC_DATA, restore->smiDacRegs[i][1]);
VGAOUT8(pSmi, VGA_DAC_DATA, restore->smiDacRegs[i][2]);
}
for (i = 0, offset = 2; i < 8192; i++, offset += 8) {
*(pSmi->FBBase + offset) = restore->smiFont[i];
}
if (SMI_LYNXM_SERIES(pSmi->Chipset)) {
/* Restore secondary registers */
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E,
restore->CR90[14] | 0x20);
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33_2);
for (i = 0; i < 14; i++) {
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i,
restore->CR40_2[i]);
}
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9F, restore->CR9F_2);
/* Restore primary registers */
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9E,
restore->CR90[14] & ~0x20);
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33);
for (i = 0; i < 14; i++) {
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i,
restore->CR40[i]);
}
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x9F, restore->CR9F);
/* Restore common registers */
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x30, restore->CR30);
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A, restore->CR3A);
for (i = 0; i < 15; i++)
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x90 + i,
restore->CR90[i]);
for (i = 0; i < 14; i++)
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0xA0 + i,
restore->CRA0[i]);
}else{
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x30, restore->CR30);
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x33, restore->CR33);
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x3A, restore->CR3A);
for (i = 0; i < 14; i++) {
VGAOUT8_INDEX(pSmi, vgaCRIndex, vgaCRData, 0x40 + i,
restore->CR40[i]);
}
}
if (pSmi->Dualhead) {
/* dualhead stuff */
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x40, restore->SR40);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x41, restore->SR41);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x42, restore->SR42);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x43, restore->SR43);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x44, restore->SR44);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x45, restore->SR45);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x48, restore->SR48);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x49, restore->SR49);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x4A, restore->SR4A);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x4B, restore->SR4B);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x4C, restore->SR4C);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x50, restore->SR50);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x51, restore->SR51);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x52, restore->SR52);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x53, restore->SR53);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x54, restore->SR54);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x55, restore->SR55);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x56, restore->SR56);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x57, restore->SR57);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x5A, restore->SR5A);
/* PLL2 stuff */
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6E, restore->SR6E);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x6F, restore->SR6F);
}
}
/* Reset the graphics engine */
WRITE_DPR(pSmi, 0x10, restore->DPR10);
WRITE_DPR(pSmi, 0x1C, restore->DPR1C);
WRITE_DPR(pSmi, 0x20, restore->DPR20);
WRITE_DPR(pSmi, 0x24, restore->DPR24);
WRITE_DPR(pSmi, 0x28, restore->DPR28);
WRITE_DPR(pSmi, 0x2C, restore->DPR2C);
WRITE_DPR(pSmi, 0x30, restore->DPR30);
WRITE_DPR(pSmi, 0x3C, restore->DPR3C);
WRITE_DPR(pSmi, 0x40, restore->DPR40);
WRITE_DPR(pSmi, 0x44, restore->DPR44);
/* write video controller regs */
WRITE_VPR(pSmi, 0x00, restore->VPR00);
WRITE_VPR(pSmi, 0x0C, restore->VPR0C);
WRITE_VPR(pSmi, 0x10, restore->VPR10);
if(pSmi->Chipset == SMI_COUGAR3DR) {
WRITE_FPR(pSmi, FPR00, restore->FPR00_);
WRITE_FPR(pSmi, FPR0C, restore->FPR0C_);
WRITE_FPR(pSmi, FPR10, restore->FPR10_);
}
WRITE_CPR(pSmi, 0x00, restore->CPR00);
if (xf86GetVerbosity() > 1) {
xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, VERBLEV,
"Done restoring mode. Register dump:\n");
SMI_PrintRegs(pScrn);
}
vgaHWProtect(pScrn, FALSE);
LEAVE();
}
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");
}
