void
RHDVGARestore(RHDPtr rhdPtr)
{
struct rhdVGA *VGA = rhdPtr->VGA;
RHDFUNC(rhdPtr);
if (!VGA)
return; /* We don't need to warn , this is intended use */
if (!VGA->Stored) {
xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR,
"%s: trying to restore uninitialized values.\n", __func__);
return;
}
if (VGA->FB)
memcpy(((CARD8 *) rhdPtr->FbBase) + VGA->FBOffset, VGA->FB,
VGA->FBSize);
RHDRegWrite(rhdPtr, VGA_RENDER_CONTROL, VGA->Render_Control);
RHDRegWrite(rhdPtr, VGA_MODE_CONTROL, VGA->Mode_Control);
RHDRegWrite(rhdPtr, VGA_HDP_CONTROL, VGA->HDP_Control);
RHDRegWrite(rhdPtr, D1VGA_CONTROL, VGA->D1_Control);
RHDRegWrite(rhdPtr, D2VGA_CONTROL, VGA->D2_Control);
RHD_UNSETDEBUGFLAG(rhdPtr, VGA_SETUP);
}
static void
LUTxSave(struct rhdLUT *LUT)
{
CARD16 RegOff;
int i;
RHDFUNC(LUT);
if (LUT->Id == RHD_LUT_A)
RegOff = RHD_REGOFFSET_LUTA;
else
RegOff = RHD_REGOFFSET_LUTB;
LUT->StoreControl = RHDRegRead(LUT, RegOff + DC_LUTA_CONTROL);
LUT->StoreBlackBlue = RHDRegRead(LUT, RegOff + DC_LUTA_BLACK_OFFSET_BLUE);
LUT->StoreBlackGreen = RHDRegRead(LUT, RegOff + DC_LUTA_BLACK_OFFSET_GREEN);
LUT->StoreBlackRed = RHDRegRead(LUT, RegOff + DC_LUTA_BLACK_OFFSET_RED);
LUT->StoreWhiteBlue = RHDRegRead(LUT, RegOff + DC_LUTA_WHITE_OFFSET_BLUE);
LUT->StoreWhiteGreen = RHDRegRead(LUT, RegOff + DC_LUTA_WHITE_OFFSET_GREEN);
LUT->StoreWhiteRed = RHDRegRead(LUT, RegOff + DC_LUTA_WHITE_OFFSET_RED);
RHDRegWrite(LUT, DC_LUT_RW_MODE, 0); /* Table */
if (LUT->Id == RHD_LUT_A)
RHDRegWrite(LUT, DC_LUT_READ_PIPE_SELECT, 0);
else
RHDRegWrite(LUT, DC_LUT_READ_PIPE_SELECT, 1);
RHDRegWrite(LUT, DC_LUT_RW_INDEX, 0);
for (i = 0; i < 0x300; i++)
LUT->StoreEntry[i] = RHDRegRead(LUT, DC_LUT_SEQ_COLOR);
LUT->Stored = TRUE;
}
static void
rhdAtomScaleSet(struct rhdCrtc *Crtc, enum rhdCrtcScaleType Type,
DisplayModePtr Mode, DisplayModePtr ScaledToMode)
{
RHDPtr rhdPtr = RHDPTRI(Crtc);
struct rhdScalerOverscan Overscan;
struct atomCrtcOverscan AtomOverscan;
enum atomCrtc AtomCrtc = RHD_CRTC_1;
enum atomScaler Scaler = 0;
enum atomScaleMode ScaleMode = 0;
union AtomBiosArg data;
CARD32 RegOff = 0;
LOG("FUNCTION: %s: %s viewport: %dx%d\n", __func__, Crtc->Name,
Mode->CrtcHDisplay, Mode->CrtcVDisplay);
/* D1Mode registers */
if (Crtc->Id == RHD_CRTC_1)
RegOff = D1_REG_OFFSET;
else
RegOff = D2_REG_OFFSET;
RHDRegWrite(Crtc, RegOff + D1MODE_VIEWPORT_SIZE,
Mode->CrtcVDisplay | (Mode->CrtcHDisplay << 16));
RHDRegWrite(Crtc, RegOff + D1MODE_VIEWPORT_START, 0);
Overscan = rhdCalculateOverscan(Mode, ScaledToMode, Type);
Type = Overscan.Type;
//ASSERT(Crtc->ScalePriv);
data.Address = &((Crtc->ScalePriv)->RegList);
RHDAtomBiosFunc(rhdPtr->scrnIndex, rhdPtr->atomBIOS, ATOM_SET_REGISTER_LIST_LOCATION, &data);
AtomOverscan.ovscnLeft = Overscan.OverscanLeft;
AtomOverscan.ovscnRight = Overscan.OverscanRight;
AtomOverscan.ovscnTop = Overscan.OverscanTop;
AtomOverscan.ovscnBottom = Overscan.OverscanBottom;
switch (Crtc->Id) {
case RHD_CRTC_1:
Scaler = atomScaler1;
AtomCrtc = atomCrtc1;
break;
case RHD_CRTC_2:
Scaler = atomScaler2;
AtomCrtc = atomCrtc2;
break;
}
rhdAtomSetCRTCOverscan(rhdPtr->atomBIOS, AtomCrtc, &AtomOverscan);
switch (Type) {
case RHD_CRTC_SCALE_TYPE_NONE:
ScaleMode = atomScaleDisable;
break;
case RHD_CRTC_SCALE_TYPE_CENTER:
ScaleMode = atomScaleCenter;
break;
case RHD_CRTC_SCALE_TYPE_SCALE:
case RHD_CRTC_SCALE_TYPE_SCALE_KEEP_ASPECT_RATIO: /* scaled to fullscreen */
ScaleMode = atomScaleExpand;
break;
}
rhdAtomSetScaler(rhdPtr->atomBIOS, Scaler, ScaleMode);
data.Address = NULL;
RHDAtomBiosFunc(rhdPtr->scrnIndex, rhdPtr->atomBIOS, ATOM_SET_REGISTER_LIST_LOCATION, &data);
RHDMCTuneAccessForDisplay(rhdPtr, Crtc->Id, Mode,
ScaledToMode ? ScaledToMode : Mode);
}
static void
LUTxRestore(struct rhdLUT *LUT)
{
CARD16 RegOff;
int i;
RHDFUNC(LUT);
if (!LUT->Stored) {
xf86DrvMsg(LUT->scrnIndex, X_ERROR, "%s: %s: nothing stored!\n",
__func__, LUT->Name);
return;
}
if (LUT->Id == RHD_LUT_A)
RegOff = RHD_REGOFFSET_LUTA;
else
RegOff = RHD_REGOFFSET_LUTB;
RHDRegWrite(LUT, RegOff + DC_LUTA_BLACK_OFFSET_BLUE, LUT->StoreBlackBlue);
RHDRegWrite(LUT, RegOff + DC_LUTA_BLACK_OFFSET_GREEN, LUT->StoreBlackGreen);
RHDRegWrite(LUT, RegOff + DC_LUTA_BLACK_OFFSET_RED, LUT->StoreBlackRed);
RHDRegWrite(LUT, RegOff + DC_LUTA_WHITE_OFFSET_BLUE, LUT->StoreWhiteBlue);
RHDRegWrite(LUT, RegOff + DC_LUTA_WHITE_OFFSET_GREEN, LUT->StoreWhiteGreen);
RHDRegWrite(LUT, RegOff + DC_LUTA_WHITE_OFFSET_RED, LUT->StoreWhiteRed);
if (LUT->Id == RHD_LUT_A)
RHDRegWrite(LUT, DC_LUT_RW_SELECT, 0);
else
RHDRegWrite(LUT, DC_LUT_RW_SELECT, 1);
RHDRegWrite(LUT, DC_LUT_RW_MODE, 0); /* Table */
RHDRegWrite(LUT, DC_LUT_WRITE_EN_MASK, 0x0000003F);
RHDRegWrite(LUT, DC_LUT_RW_INDEX, 0);
for (i = 0; i < 0x300; i++)
RHDRegWrite(LUT, DC_LUT_SEQ_COLOR, LUT->StoreEntry[i]);
RHDRegWrite(LUT, RegOff + DC_LUTA_CONTROL, LUT->StoreControl);
}
static void
LUTxSet(struct rhdLUT *LUT, int numColors, int *indices, LOCO *colors)
{
//ScrnInfoPtr pScrn = xf86Screens[LUT->scrnIndex];
CARD16 RegOff;
int i, index;
LUT->Initialised = TRUE; /* thank you RandR */
if (LUT->Id == RHD_LUT_A)
RegOff = RHD_REGOFFSET_LUTA;
else
RegOff = RHD_REGOFFSET_LUTB;
RHDRegWrite(LUT, RegOff + DC_LUTA_CONTROL, 0);
RHDRegWrite(LUT, RegOff + DC_LUTA_BLACK_OFFSET_BLUE, 0);
RHDRegWrite(LUT, RegOff + DC_LUTA_BLACK_OFFSET_GREEN, 0);
RHDRegWrite(LUT, RegOff + DC_LUTA_BLACK_OFFSET_RED, 0);
RHDRegWrite(LUT, RegOff + DC_LUTA_WHITE_OFFSET_BLUE, 0x0000FFFF);
RHDRegWrite(LUT, RegOff + DC_LUTA_WHITE_OFFSET_GREEN, 0x0000FFFF);
RHDRegWrite(LUT, RegOff + DC_LUTA_WHITE_OFFSET_RED, 0x0000FFFF);
if (LUT->Id == RHD_LUT_A)
RHDRegWrite(LUT, DC_LUT_RW_SELECT, 0);
else
RHDRegWrite(LUT, DC_LUT_RW_SELECT, 1);
RHDRegWrite(LUT, DC_LUT_RW_MODE, 0); /* table */
RHDRegWrite(LUT, DC_LUT_WRITE_EN_MASK, 0x0000003F);
int depth = 32;
switch (depth) {
case 8:
case 24:
case 32:
for (i = 0; i < numColors; i++) {
index = indices[i];
RHDRegWrite(LUT, DC_LUT_RW_INDEX, index);
RHDRegWrite(LUT, DC_LUT_30_COLOR, (colors[index].red << 22) |
(colors[index].green << 12) | (colors[index].blue << 2));
}
break;
case 16:
for (i = 0; i < numColors; i++) {
int j;
index = indices[i];
RHDRegWrite(LUT, DC_LUT_RW_INDEX, 4 * index);
for (j = 0; j < 4; j++)
RHDRegWrite(LUT, DC_LUT_30_COLOR, (colors[index/2].red << 24) |
(colors[index].green << 14) | (colors[index/2].blue << 4));
}
break;
case 15:
for (i = 0; i < numColors; i++) {
int j;
index = indices[i];
RHDRegWrite(LUT, DC_LUT_RW_INDEX, 8 * index);
for (j = 0; j < 8; j++)
RHDRegWrite(LUT, DC_LUT_30_COLOR, (colors[index].red << 25) |
(colors[index].green << 15) | (colors[index].blue << 5));
}
break;
}
}
