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");
}
Datum
pgchem_remove_hydrogens (PG_FUNCTION_ARGS)
{
char *molfile = NULL;
char *smiles = NULL;
//unsigned int *efa_array = NULL;
MOLECULE *retval;
MOLECULE *arg_molecule = PG_GETARG_MOLECULE_P (0);
bool nonpolaronly = PG_GETARG_BOOL (1);
smiles =
ob_delete_hydrogens (SMIPTR (arg_molecule),
nonpolaronly ? 1 : 0);
molfile = ob_smiles_to_mol (smiles);
if(molfile == NULL || !strlen(molfile)) {
elog (ERROR, "Molfile generation failed! Offender was :\n %s",smiles);
}
//efa_array = ob_efa_array(smiles);
retval = new_molecule (smiles, molfile);
free (molfile);
free (smiles);
//free (efa_array);
PG_RETURN_MOLECULE_P (retval);
}
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_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_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");
}
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_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");
}
Bool
SMI_I2CInit(ScrnInfoPtr pScrn)
{
SMIPtr pSmi = SMIPTR(pScrn);
if (pSmi->I2C == NULL) {
I2CBusPtr I2CPtr = xf86CreateI2CBusRec();
if (I2CPtr == NULL)
return FALSE;
I2CPtr->BusName = "I2C bus";
I2CPtr->scrnIndex = pScrn->scrnIndex;
I2CPtr->I2CPutBits = SMI_I2CPutBits;
I2CPtr->I2CGetBits = SMI_I2CGetBits;
if (!xf86I2CBusInit(I2CPtr)) {
xf86DestroyI2CBusRec(I2CPtr, TRUE, TRUE);
return FALSE;
}
pSmi->I2C = I2CPtr;
}
return TRUE;
}
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_I2CGetBits(I2CBusPtr b, int *clock, int *data)
{
SMIPtr pSmi = SMIPTR(xf86Screens[b->scrnIndex]);
unsigned int reg = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72);
*clock = reg & 0x04;
*data = reg & 0x08;
}
/* This function is used to debug, it prints out the contents of Lynx regs */
void
SMILynx_PrintRegs(ScrnInfoPtr pScrn)
{
unsigned char i;
SMIPtr pSmi = SMIPTR(pScrn);
vgaHWPtr hwp = VGAHWPTR(pScrn);
int vgaCRIndex = hwp->IOBase + VGA_CRTC_INDEX_OFFSET;
int vgaCRReg = hwp->IOBase + VGA_CRTC_DATA_OFFSET;
int vgaStatus = hwp->IOBase + VGA_IN_STAT_1_OFFSET;
xf86ErrorFVerb(VERBLEV, "MISCELLANEOUS OUTPUT\n %02X\n",
VGAIN8(pSmi, VGA_MISC_OUT_R));
xf86ErrorFVerb(VERBLEV, "\nSEQUENCER\n"
" x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF");
for (i = 0x00; i <= 0xAF; i++) {
if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
xf86ErrorFVerb(VERBLEV, "%02X ",
VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, i));
}
xf86ErrorFVerb(VERBLEV, "\n\nCRT CONTROLLER\n"
" x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF");
for (i = 0x00; i <= 0xAD; i++) {
if (i == 0x20) i = 0x30;
if (i == 0x50) i = 0x90;
if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
xf86ErrorFVerb(VERBLEV, "%02X ",
VGAIN8_INDEX(pSmi, vgaCRIndex, vgaCRReg, i));
}
xf86ErrorFVerb(VERBLEV, "\n\nGRAPHICS CONTROLLER\n"
" x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF");
for (i = 0x00; i <= 0x08; i++) {
if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
xf86ErrorFVerb(VERBLEV, "%02X ",
VGAIN8_INDEX(pSmi, VGA_GRAPH_INDEX, VGA_GRAPH_DATA, i));
}
xf86ErrorFVerb(VERBLEV, "\n\nATTRIBUTE 0CONTROLLER\n"
" x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF");
for (i = 0x00; i <= 0x14; i++) {
(void) VGAIN8(pSmi, vgaStatus);
if ((i & 0xF) == 0x0) xf86ErrorFVerb(VERBLEV, "\n%02X|", i);
if ((i & 0x3) == 0x0) xf86ErrorFVerb(VERBLEV, " ");
xf86ErrorFVerb(VERBLEV, "%02X ",
VGAIN8_INDEX(pSmi, VGA_ATTR_INDEX, VGA_ATTR_DATA_R, i));
}
(void) VGAIN8(pSmi, vgaStatus);
VGAOUT8(pSmi, VGA_ATTR_INDEX, 0x20);
}
static void
SMI_I2CPutBits(I2CBusPtr b, int clock, int data)
{
SMIPtr pSmi = SMIPTR(xf86Screens[b->scrnIndex]);
unsigned int reg = 0x30;
if (clock) reg |= 0x01;
if (data) reg |= 0x02;
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72, reg);
}
/* 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");
}
DisplayModePtr
SMI_OutputGetModes_native(xf86OutputPtr output)
{
SMIPtr pSmi = SMIPTR(output->scrn);
ENTER();
#ifdef HAVE_XMODES
LEAVE(xf86CVTMode(pSmi->lcdWidth, pSmi->lcdHeight, 60.0f, FALSE, FALSE));
#else
LEAVE(NULL);
#endif
}
static Bool
SMI_CrtcLock (xf86CrtcPtr crtc)
{
ScrnInfoPtr pScrn = crtc->scrn;
SMIPtr pSmi = SMIPTR(pScrn);
ENTER();
WaitIdle();
LEAVE(FALSE);
}
Bool
SMI_OutputPreInit(ScrnInfoPtr pScrn)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER();
if(SMI_MSOC_SERIES(pSmi->Chipset)){
LEAVE( SMI501_OutputPreInit(pScrn) );
}else{
LEAVE( SMILynx_OutputPreInit(pScrn) );
}
}
static PixmapPtr
SMI_CrtcShadowCreate (xf86CrtcPtr crtc, void *data, int width, int height)
{
ScrnInfoPtr pScrn = crtc->scrn;
SMIPtr pSmi = SMIPTR(pScrn);
int aligned_pitch;
ENTER();
aligned_pitch = (width * pSmi->Bpp + 15) & ~15;
LEAVE(GetScratchPixmapHeader(pScrn->pScreen,width,height,pScrn->depth,
pScrn->bitsPerPixel,aligned_pitch,data));
}
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");
}
/*
* SMI_DisplayPowerManagementSet -- Sets VESA Display Power Management
* Signaling (DPMS) Mode.
*/
void
SMILynx_DisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
int flags)
{
SMIPtr pSmi = SMIPTR(pScrn);
SMIRegPtr mode = pSmi->mode;
vgaHWPtr hwp = VGAHWPTR(pScrn);
ENTER();
/* If we already are in the requested DPMS mode, just return */
if (pSmi->CurrentDPMS != PowerManagementMode) {
/* Read the required SR registers for the DPMS handler */
CARD8 SR01 = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01);
switch (PowerManagementMode) {
case DPMSModeOn:
SR01 &= ~0x20; /* Screen on */
mode->SR23 &= ~0xC0; /* Disable chip activity detection */
break;
case DPMSModeStandby:
case DPMSModeSuspend:
case DPMSModeOff:
SR01 |= 0x20; /* Screen off */
mode->SR23 = (mode->SR23 & ~0x07) | 0xD8; /* Enable chip activity detection
Enable internal auto-standby mode
Enable both IO Write and Host Memory write detect
0 minutes timeout */
break;
}
/* Wait for vertical retrace */
while (hwp->readST01(hwp) & 0x8) ;
while (!(hwp->readST01(hwp) & 0x8)) ;
/* Write the registers */
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x01, SR01);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x23, mode->SR23);
/* Set the DPMS mode to every output and CRTC */
xf86DPMSSet(pScrn, PowerManagementMode, flags);
/* Save the current power state */
pSmi->CurrentDPMS = PowerManagementMode;
}
LEAVE();
}
static unsigned int
SMILynx_ddc1Read(ScrnInfoPtr pScrn)
{
register vgaHWPtr hwp = VGAHWPTR(pScrn);
SMIPtr pSmi = SMIPTR(pScrn);
unsigned int ret;
ENTER();
while (hwp->readST01(hwp) & 0x8) ;
while (!(hwp->readST01(hwp) & 0x8)) ;
ret = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72) & 0x08;
LEAVE(ret);
}
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");
}
Bool
SMI_CrtcPreInit(ScrnInfoPtr pScrn)
{
SMIPtr pSmi = SMIPTR(pScrn);
ENTER();
xf86CrtcConfigInit(pScrn,&SMI_CrtcConfigFuncs);
xf86CrtcSetSizeRange(pScrn,128,128,4096,4096);
if(SMI_MSOC_SERIES(pSmi->Chipset)){
LEAVE( SMI501_CrtcPreInit(pScrn) );
}else{
LEAVE( SMILynx_CrtcPreInit(pScrn) );
}
}
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_CrtcShadowAllocate (xf86CrtcPtr crtc, int width, int height)
{
ScrnInfoPtr pScrn = crtc->scrn;
SMIPtr pSmi = SMIPTR(pScrn);
SMICrtcPrivatePtr crtcPriv = SMICRTC(crtc);
int offset, size;
ENTER();
size = ((width * pSmi->Bpp + 15) & ~15) * height;
offset = SMI_AllocateMemory(pScrn, &crtcPriv->shadowArea, size);
if (!crtcPriv->shadowArea)
LEAVE(NULL);
LEAVE(pSmi->FBBase + offset);
}
Datum
molecule_out (PG_FUNCTION_ARGS)
{
MOLECULE *molecule = PG_GETARG_MOLECULE_P (0);
//int sizesmi = molecule->sizesmi;
//int i;
//unsigned int *arr = (unsigned int*) EFAPTR(molecule);
char *result = (char *) palloc (molecule->sizesmi);
memset(result,0x0,molecule->sizesmi);
strncpy (result, SMIPTR(molecule), molecule->sizesmi);
//for(i=0;i<arr[0];i++) printf("%d ",arr[i]);
//printf("\n");
PG_RETURN_CSTRING (result);
}
static void
SMI_CrtcShadowDestroy (xf86CrtcPtr crtc, PixmapPtr pPixmap, void *data)
{
ScrnInfoPtr pScrn = crtc->scrn;
SMIPtr pSmi = SMIPTR(pScrn);
SMICrtcPrivatePtr crtcPriv = SMICRTC(crtc);
ENTER();
if (pSmi->useEXA && pPixmap)
FreeScratchPixmapHeader(pPixmap);
if (crtcPriv->shadowArea) {
SMI_FreeMemory(pScrn, crtcPriv->shadowArea);
crtcPriv->shadowArea = NULL;
}
LEAVE();
}
xf86MonPtr
SMILynx_ddc1(ScrnInfoPtr pScrn)
{
SMIPtr pSmi = SMIPTR(pScrn);
xf86MonPtr pMon;
unsigned char tmp;
ENTER();
tmp = VGAIN8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72);
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72, tmp | 0x20);
pMon = xf86PrintEDID(xf86DoEDID_DDC1(XF86_SCRN_ARG(pScrn),
vgaHWddc1SetSpeedWeak(),
SMILynx_ddc1Read));
VGAOUT8_INDEX(pSmi, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x72, tmp);
LEAVE(pMon);
}
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);
}
