void
VIAFreeLinear(VIAMemPtr mem)
{
DEBUG(ErrorF("Freed %lu (pool %d)\n", mem->base, mem->pool));
switch (mem->pool) {
case 0:
return;
case 1:
{
VIAPtr pVia = VIAPTR(mem->pScrn);
if (pVia->useEXA && !pVia->NoAccel) {
exaOffscreenFree(mem->pScrn->pScreen, mem->exa);
mem->linear = NULL;
mem->pool = 0;
return;
}
}
xf86FreeOffscreenLinear(mem->linear);
mem->linear = NULL;
mem->pool = 0;
return;
case 2:
#ifdef XF86DRI
if (drmCommandWrite(mem->drm_fd, DRM_VIA_FREEMEM,
&mem->drm, sizeof(drm_via_mem_t)) < 0)
ErrorF("DRM module failed free.\n");
#endif
mem->pool = 0;
return;
}
}
void
ViaVbeAdjustFrame(int scrnIndex, int x, int y, int flags)
{
VIAPtr pVia = VIAPTR(xf86Screens[scrnIndex]);
VBESetDisplayStart(pVia->pVbe, x, y, TRUE);
}
/* hide the current cursor */
void
viaHideCursor(ScrnInfoPtr pScrn)
{
VIAPtr pVia = VIAPTR(pScrn);
CARD32 temp;
switch(pVia->Chipset) {
case VIA_CX700:
case VIA_P4M890:
case VIA_P4M900:
case VIA_VX800:
case VIA_VX855:
case VIA_VX900:
if (pVia->pBIOSInfo->FirstCRTC->IsActive) {
temp = VIAGETREG(VIA_REG_HI_CONTROL0);
VIASETREG(VIA_REG_HI_CONTROL0, temp & 0xFFFFFFFA);
}
if (pVia->pBIOSInfo->SecondCRTC->IsActive) {
temp = VIAGETREG(VIA_REG_HI_CONTROL1);
VIASETREG(VIA_REG_HI_CONTROL1, temp & 0xFFFFFFFA);
}
break;
default:
temp = VIAGETREG(VIA_REG_ALPHA_CONTROL);
/* Hardware cursor disable [bit0] */
VIASETREG(VIA_REG_ALPHA_CONTROL, temp & 0xFFFFFFFA);
}
}
static void
VT1621ModeCrtc(xf86CrtcPtr crtc, DisplayModePtr mode)
{
ScrnInfoPtr pScrn = crtc->scrn;
vgaHWPtr hwp = VGAHWPTR(pScrn);
VIAPtr pVia = VIAPTR(pScrn);
VIABIOSInfoPtr pBIOSInfo = pVia->pBIOSInfo;
struct VT1621TableRec Table = VT1621Table[VT1621ModeIndex(pScrn, mode)];
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT1621ModeCrtc\n"));
if (pVia->IsSecondary) {
hwp->writeCrtc(hwp, 0x6A, 0x80);
hwp->writeCrtc(hwp, 0x6B, 0x20);
hwp->writeCrtc(hwp, 0x6C, 0x80);
/* Disable LCD Scaling */
if (!pVia->SAMM || pVia->FirstInit)
hwp->writeCrtc(hwp, 0x79, 0x00);
} else {
hwp->writeCrtc(hwp, 0x6A, 0x00);
hwp->writeCrtc(hwp, 0x6B, 0x80);
hwp->writeCrtc(hwp, 0x6C, Table.PrimaryCR6C);
}
pBIOSInfo->ClockExternal = TRUE;
ViaCrtcMask(hwp, 0x6A, 0x40, 0x40);
ViaCrtcMask(hwp, 0x6C, 0x01, 0x01);
}
static CARD8
VT1622ModeIndex(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
VIABIOSInfoPtr pBIOSInfo = VIAPTR(pScrn)->pBIOSInfo;
struct VT162XTableRec *Table;
int i;
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT1622ModeIndex\n"));
if (pBIOSInfo->TVEncoder == VIA_VT1622)
Table = VT1622Table;
else if (pBIOSInfo->TVEncoder == VIA_VT1625)
Table = VT1625Table;
else
Table = VT1623Table;
for (i = 0; Table[i].Width; i++) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"width=%d:%d, height=%d:%d, std=%d:%d, name=%s:%s.\n",
Table[i].Width, mode->CrtcHDisplay,
Table[i].Height, mode->CrtcVDisplay,
Table[i].Standard, pBIOSInfo->TVType,
Table[i].name, mode->name);
if ((Table[i].Width == mode->CrtcHDisplay) &&
(Table[i].Height == mode->CrtcVDisplay) &&
(Table[i].Standard == pBIOSInfo->TVType) &&
!strcmp(Table[i].name, mode->name))
return i;
}
xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "VT1622ModeIndex:"
" Mode \"%s\" not found in Table\n", mode->name);
return 0xFF;
}
unsigned long
viaXvMCPutImageSize(ScrnInfoPtr pScrn)
{
if (VIAPTR(pScrn)->XvMCEnabled)
return sizeof(ViaXvMCCommandBuffer);
return 0;
}
static Bool
ViaVbeSetRefresh(ScrnInfoPtr pScrn, int maxRefresh)
{
VIAPtr pVia = VIAPTR(pScrn);
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ViaVbeSetRefresh\n"));
vbeInfoPtr pVbe = pVia->pVbe;
ViaVbeInitInt10(pVbe);
pVbe->pInt10->bx = 0x0001;
pVbe->pInt10->cx = ViaVbeGetActiveDevices(pScrn);
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Active Device: %d\n",
pVbe->pInt10->cx));
pVbe->pInt10->di = ViaVbeGetRefreshRateIndex(maxRefresh);
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Refresh Rate Index: %d\n",
pVbe->pInt10->di));
/* Real execution */
xf86ExecX86int10(pVbe->pInt10);
if (pVbe->pInt10->ax != 0x4F)
return FALSE;
return TRUE;
}
static void
ViaXvMCDestroyContext(ScrnInfoPtr pScrn, XvMCContextPtr pContext)
{
VIAPtr pVia = VIAPTR(pScrn);
ViaXvMCPtr vXvMC = &(pVia->xvmc);
int i;
volatile ViaXvMCSAreaPriv *sAPriv;
viaPortPrivPtr pPriv;
XvPortRecPrivatePtr portPriv;
ViaXvMCXVPriv *vx;
for (i = 0; i < VIA_XVMC_MAX_CONTEXTS; i++) {
if (vXvMC->contexts[i] == pContext->context_id) {
sAPriv = (ViaXvMCSAreaPriv *) DRIGetSAREAPrivate(pScrn->pScreen);
portPriv = (XvPortRecPrivatePtr) pContext->port_priv;
pPriv = (viaPortPrivPtr) portPriv->DevPriv.ptr;
vx = (ViaXvMCXVPriv *) pPriv->xvmc_priv;
if ((i | VIA_XVMC_VALID) == vx->ctxDisplaying) {
vx->ctxDisplaying = 0;
}
free(vXvMC->cPrivs[i]);
vXvMC->cPrivs[i] = 0;
vXvMC->nContexts--;
vXvMC->contexts[i] = 0;
return;
}
}
return;
}
static void
ViaXvMCDestroySurface(ScrnInfoPtr pScrn, XvMCSurfacePtr pSurf)
{
VIAPtr pVia = VIAPTR(pScrn);
ViaXvMCPtr vXvMC = &(pVia->xvmc);
int i;
volatile ViaXvMCSAreaPriv *sAPriv;
XvMCContextPtr pContext = pSurf->context;
XvPortRecPrivatePtr portPriv = (XvPortRecPrivatePtr) pContext->port_priv;
viaPortPrivPtr pPriv = (viaPortPrivPtr) portPriv->DevPriv.ptr;
ViaXvMCXVPriv *vx = (ViaXvMCXVPriv *) pPriv->xvmc_priv;
for (i = 0; i < VIA_XVMC_MAX_SURFACES; i++) {
if (vXvMC->surfaces[i] == pSurf->surface_id) {
sAPriv = (ViaXvMCSAreaPriv *) DRIGetSAREAPrivate(pScrn->pScreen);
{
DRM_CAS_RESULT(__ret);
DRM_CAS(&(sAPriv->XvMCDisplaying[vx->xvmc_port]),
i | VIA_XVMC_VALID, 0, __ret);
if (!__ret)
ViaOverlayHide(pScrn);
}
drm_bo_free(pScrn, vXvMC->sPrivs[i]->memory_ref);
free(vXvMC->sPrivs[i]);
vXvMC->nSurfaces--;
vXvMC->sPrivs[i] = 0;
vXvMC->surfaces[i] = 0;
return;
}
}
return;
}
void
ViaCleanupXVMC(ScrnInfoPtr pScrn, XF86VideoAdaptorPtr * XvAdaptors,
int XvAdaptorCount)
{
VIAPtr pVia = VIAPTR(pScrn);
ViaXvMCPtr vXvMC = &(pVia->xvmc);
int i, j;
if (pVia->XvMCEnabled) {
mpegDisable(pVia, 0);
drmRmMap(pVia->drmmode.fd, vXvMC->mmioBase);
cleanupViaXvMC(vXvMC, XvAdaptors, XvAdaptorCount);
}
for (i = 0; i < XvAdaptorCount; ++i) {
if (!XvAdaptors[i])
continue;
for (j = 0; j < XvAdaptors[i]->nPorts; ++j) {
viaPortPrivPtr pPriv = XvAdaptors[i]->pPortPrivates[j].ptr;
if (pPriv->xvmc_priv)
free(pPriv->xvmc_priv);
}
}
pVia->XvMCEnabled = 0;
}
void
VIAUnmapMem(ScrnInfoPtr pScrn)
{
VIAPtr pVia = VIAPTR(pScrn);
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VIAUnmapMem\n"));
ViaMMIODisable(pScrn);
#ifdef HAVE_PCIACCESS
if (pVia->MapBase)
pci_device_unmap_range(pVia->PciInfo, (pointer) pVia->MapBase,
VIA_MMIO_REGSIZE);
if (pVia->BltBase)
pci_device_unmap_range(pVia->PciInfo, (pointer) pVia->BltBase,
VIA_MMIO_BLTSIZE);
if (pVia->FBBase)
pci_device_unmap_range(pVia->PciInfo, (pointer) pVia->FBBase,
pVia->videoRambytes);
#else
if (pVia->MapBase)
xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pVia->MapBase,
VIA_MMIO_REGSIZE);
if (pVia->BltBase)
xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pVia->BltBase,
VIA_MMIO_BLTSIZE);
if (pVia->FBBase)
xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pVia->FBBase,
pVia->videoRambytes);
#endif
}
int
viaOffScreenLinear(VIAMemPtr mem, ScrnInfoPtr pScrn, unsigned long size)
{
int depth = pScrn->bitsPerPixel >> 3;
VIAPtr pVia = VIAPTR(pScrn);
if (pVia->useEXA && !pVia->NoAccel) {
mem->exa = exaOffscreenAlloc(pScrn->pScreen, size,
32, TRUE, NULL, NULL);
if (mem->exa == NULL)
return BadAlloc;
mem->exa->save = viaExaFBSave;
mem->base = mem->exa->offset;
mem->pool = 1;
mem->pScrn = pScrn;
return Success;
}
mem->linear = xf86AllocateOffscreenLinear(pScrn->pScreen,
(size + depth - 1) / depth,
32, NULL, NULL, NULL);
if (mem->linear == NULL)
return BadAlloc;
mem->base = mem->linear->offset * depth;
mem->pool = 1;
mem->pScrn = pScrn;
return Success;
}
static ModeStatus
VT1622ModeValid(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
VIABIOSInfoPtr pBIOSInfo = VIAPTR(pScrn)->pBIOSInfo;
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT1622ModeValid\n"));
if ((mode->PrivSize != sizeof(struct VT162xModePrivate)) ||
((mode->Private != (void *)&VT162xModePrivateNTSC) &&
(mode->Private != (void *)&VT162xModePrivatePAL))) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Not a mode defined by the TV Encoder.\n");
return MODE_BAD;
}
if ((pBIOSInfo->TVType == TVTYPE_NTSC) &&
(mode->Private != (void *)&VT162xModePrivateNTSC)) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"TV standard is NTSC. This is a PAL mode.\n");
return MODE_BAD;
} else if ((pBIOSInfo->TVType == TVTYPE_PAL) &&
(mode->Private != (void *)&VT162xModePrivatePAL)) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"TV standard is PAL. This is a NTSC mode.\n");
return MODE_BAD;
}
if (VT1622ModeIndex(pScrn, mode) != 0xFF)
return MODE_OK;
return MODE_BAD;
}
/*
* Also suited for VT1622A, VT1623, VT1625.
*/
static void
VT1622ModeCrtc(xf86CrtcPtr crtc, DisplayModePtr mode)
{
ScrnInfoPtr pScrn = crtc->scrn;
vgaHWPtr hwp = VGAHWPTR(pScrn);
VIAPtr pVia = VIAPTR(pScrn);
VIABIOSInfoPtr pBIOSInfo = pVia->pBIOSInfo;
struct VT162XTableRec Table;
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT1622ModeCrtc\n"));
if (pBIOSInfo->TVEncoder == VIA_VT1622)
Table = VT1622Table[VT1622ModeIndex(pScrn, mode)];
else if (pBIOSInfo->TVEncoder == VIA_VT1625)
Table = VT1625Table[VT1622ModeIndex(pScrn, mode)];
else /* VT1622A/VT1623 */
Table = VT1623Table[VT1622ModeIndex(pScrn, mode)];
hwp->writeCrtc(hwp, 0x6A, 0x00);
hwp->writeCrtc(hwp, 0x6B, 0x00);
hwp->writeCrtc(hwp, 0x6C, 0x00);
if (pVia->IsSecondary) {
hwp->writeCrtc(hwp, 0x6C, Table.SecondaryCR6C);
ViaCrtcMask(hwp, 0x6A, 0x80, 0x80);
ViaCrtcMask(hwp, 0x6C, 0x80, 0x80);
/* CLE266Ax use 2x XCLK. */
if ((pVia->Chipset == VIA_CLE266) && CLE266_REV_IS_AX(pVia->ChipRev)) {
ViaCrtcMask(hwp, 0x6B, 0x20, 0x20);
/* Fix TV clock polarity for CLE266A2. */
if (pVia->ChipRev == 0x02)
ViaCrtcMask(hwp, 0x6C, 0x1C, 0x1C);
}
/* Disable LCD scaling. */
if (!pVia->SAMM || pVia->FirstInit)
hwp->writeCrtc(hwp, 0x79, 0x00);
} else {
if ((pVia->Chipset == VIA_CLE266) && CLE266_REV_IS_AX(pVia->ChipRev)) {
ViaCrtcMask(hwp, 0x6B, 0x80, 0x80);
/* Fix TV clock polarity for CLE266A2. */
if (pVia->ChipRev == 0x02)
hwp->writeCrtc(hwp, 0x6C, Table.PrimaryCR6C);
}
}
pBIOSInfo->ClockExternal = TRUE;
ViaCrtcMask(hwp, 0x6A, 0x40, 0x40);
ViaSetTVClockSource(crtc);
}
void
ViaVbeDoDPMS(ScrnInfoPtr pScrn, int mode)
{
VIAPtr pVia = VIAPTR(pScrn);
VIABIOSInfoPtr pBIOSInfo = pVia->pBIOSInfo;
if (pBIOSInfo->Panel->IsActive)
ViaVbePanelPower(pVia->pVbe, (mode == DPMSModeOn));
VBEDPMSSet(pVia->pVbe, mode);
}
static Bool
viaUseHWCursorARGB(ScreenPtr pScreen, CursorPtr pCurs)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
VIAPtr pVia = VIAPTR(pScrn);
return (pVia->hwcursor
&& pVia->CursorARGBSupported
&& pCurs->bits->width <= pVia->CursorMaxWidth
&& pCurs->bits->height <= pVia->CursorMaxHeight);
}
void
viaCursorSetFB(ScrnInfoPtr pScrn)
{
VIAPtr pVia = VIAPTR(pScrn);
if ((pVia->FBFreeEnd - pVia->FBFreeStart) > pVia->CursorSize) {
pVia->CursorStart = pVia->FBFreeEnd - pVia->CursorSize;
pVia->FBFreeEnd = pVia->CursorStart;
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "CursorStart: 0x%x\n", pVia->CursorStart);
}
}
static void
VT162xRestore(ScrnInfoPtr pScrn)
{
VIABIOSInfoPtr pBIOSInfo = VIAPTR(pScrn)->pBIOSInfo;
int i;
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT162xRestore\n"));
for (i = 0; i < pBIOSInfo->TVNumRegs; i++)
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, i, pBIOSInfo->TVRegs[i]);
}
static void
VT1625Power(ScrnInfoPtr pScrn, Bool On)
{
VIABIOSInfoPtr pBIOSInfo = VIAPTR(pScrn)->pBIOSInfo;
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT1625Power\n"));
if (On)
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, 0x0E, 0x00);
else
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, 0x0E, 0x3F);
}
static void
VT162xSave(ScrnInfoPtr pScrn)
{
int i;
VIABIOSInfoPtr pBIOSInfo = VIAPTR(pScrn)->pBIOSInfo;
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT162xSave\n"));
for (i = 0; i < pBIOSInfo->TVNumRegs; i++)
xf86I2CReadByte(pBIOSInfo->TVI2CDev, i, &(pBIOSInfo->TVRegs[i]));
}
Bool
ViaVbeModePreInit(ScrnInfoPtr pScrn)
{
VIAPtr pVia = VIAPTR(pScrn);
VbeInfoBlock *vbe;
int i;
memset(&(pVia->vbeMode), 0, sizeof(ViaVbeModeInfo));
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Searching for matching VESA mode(s):\n");
if ((vbe = VBEGetVBEInfo(pVia->pVbe)) == NULL) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VBEGetVBEInfo failed\n");
return FALSE;
}
pVia->vbeMode.major = (unsigned)(vbe->VESAVersion >> 8);
pVia->vbeMode.minor = vbe->VESAVersion & 0xff;
pScrn->modePool = VBEGetModePool(pScrn, pVia->pVbe, vbe, V_MODETYPE_VBE);
if (pScrn->modePool == NULL) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No matching modes\n");
return FALSE;
}
VBESetModeNames(pScrn->modePool);
i = VBEValidateModes(pScrn, NULL, pScrn->display->modes,
NULL, NULL, 0, 2048, 1, 0, 2048,
pScrn->display->virtualX,
pScrn->display->virtualY,
pScrn->videoRam, LOOKUP_BEST_REFRESH);
if (i <= 0) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes.\n");
return (FALSE);
}
VBESetModeParameters(pScrn, pVia->pVbe);
xf86PruneDriverModes(pScrn);
#if 0
pMode = pScrn->modes;
do {
vbeMode = ((VbeModeInfoData *) pMode->Private)->data;
pMode = pMode->next;
} while (pMode != NULL && pMode != pScrn->modes);
#endif
return TRUE;
}
/*
If the driver is unable to use a hardware cursor for reasons
other than the cursor being larger than the maximum specified
in the MaxWidth or MaxHeight field below, it can supply the
UseHWCursor function. If UseHWCursor is provided by the driver,
it will be called whenever the cursor shape changes or the video
mode changes. This is useful for when the hardware cursor cannot
be used in interlaced or doublescan modes.
*/
static Bool
viaUseHWCursor(ScreenPtr pScreen, CursorPtr pCurs)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
VIAPtr pVia = VIAPTR(pScrn);
return (pVia->hwcursor
/* Can't enable HW cursor on both CRTCs at the same time. */
&& !(pVia->pBIOSInfo->FirstCRTC->IsActive
&& pVia->pBIOSInfo->SecondCRTC->IsActive)
&& pCurs->bits->width <= pVia->CursorMaxWidth
&& pCurs->bits->height <= pVia->CursorMaxHeight);
}
static void
ViaSetTVClockSource(xf86CrtcPtr crtc)
{
drmmode_crtc_private_ptr iga = crtc->driver_private;
ScrnInfoPtr pScrn = crtc->scrn;
VIAPtr pVia = VIAPTR(pScrn);
VIABIOSInfoPtr pBIOSInfo = pVia->pBIOSInfo;
vgaHWPtr hwp = VGAHWPTR(pScrn);
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "ViaSetTVClockSource\n"));
switch(pBIOSInfo->TVEncoder) {
case VIA_VT1625:
/* External TV: */
switch(pVia->Chipset) {
case VIA_CX700:
case VIA_VX800:
case VIA_VX855:
/* IGA1 */
if (!iga->index) {
if(pBIOSInfo->TVDIPort == VIA_DI_PORT_DVP1)
ViaCrtcMask(hwp, 0x6C, 0xB0, 0xF0);
else if(pBIOSInfo->TVDIPort == VIA_DI_PORT_DVP0)
ViaCrtcMask(hwp, 0x6C, 0x90, 0xF0);
} else {
/* IGA2 */
if(pBIOSInfo->TVDIPort == VIA_DI_PORT_DVP1)
ViaCrtcMask(hwp, 0x6C, 0x0B, 0x0F);
else if(pBIOSInfo->TVDIPort == VIA_DI_PORT_DVP0)
ViaCrtcMask(hwp, 0x6C, 0x09, 0x0F);
}
break;
default:
if (!iga->index)
ViaCrtcMask(hwp, 0x6C, 0x21, 0x21);
else
ViaCrtcMask(hwp, 0x6C, 0xA1, 0xA1);
break;
}
break;
default:
if (!iga->index)
ViaCrtcMask(hwp, 0x6C, 0x50, 0xF0);
else
ViaCrtcMask(hwp, 0x6C, 0x05, 0x0F);
break;
}
}
static void
VT1621ModeI2C(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
VIABIOSInfoPtr pBIOSInfo = VIAPTR(pScrn)->pBIOSInfo;
struct VT1621TableRec Table = VT1621Table[VT1621ModeIndex(pScrn, mode)];
CARD8 i;
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT1621ModeI2C\n"));
for (i = 0; i < 0x16; i++)
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, i, Table.TV[i]);
VT162xSetSubCarrier(pBIOSInfo->TVI2CDev, Table.SubCarrier);
/* Skip reserved (1A) and version ID (1B). */
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, 0x1C, Table.TV[0x1C]);
/* Skip software reset (1D). */
for (i = 0x1E; i < 0x24; i++)
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, i, Table.TV[i]);
/* Write some zeroes? */
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, 0x24, 0x00);
for (i = 0; i < 0x08; i++)
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, 0x4A + i, 0x00);
if (pBIOSInfo->TVOutput == TVOUTPUT_COMPOSITE)
for (i = 0; i < 0x10; i++)
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, 0x52 + i, Table.TVC[i]);
else
for (i = 0; i < 0x10; i++)
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, 0x52 + i, Table.TVS[i]);
/* Turn on all Composite and S-Video output. */
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, 0x0E, 0x00);
if (pBIOSInfo->TVDotCrawl) {
if (Table.DotCrawlSubCarrier) {
xf86I2CReadByte(pBIOSInfo->TVI2CDev, 0x11, &i);
xf86I2CWriteByte(pBIOSInfo->TVI2CDev, 0x11, i | 0x08);
VT162xSetSubCarrier(pBIOSInfo->TVI2CDev, Table.DotCrawlSubCarrier);
} else
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "This mode does not currently "
"support DotCrawl suppression.\n");
}
}
/*
* VT1625 knows composite, s-video, RGB and YCBCR.
*/
static Bool
VT1625DACSense(ScrnInfoPtr pScrn)
{
VIABIOSInfoPtr pBIOSInfo = VIAPTR(pScrn)->pBIOSInfo;
CARD8 sense;
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT1625DACSense\n"));
sense = VT1625DACSenseI2C(pBIOSInfo->TVI2CDev);
switch (sense) {
case 0x00: /* DAC A,B,C,D,E,F */
pBIOSInfo->TVOutput = TVOUTPUT_RGB;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"VT1625: RGB connected.\n");
return TRUE;
case 0x07: /* DAC A,B,C */
pBIOSInfo->TVOutput = TVOUTPUT_SC;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"VT1625: S-Video & Composite connected.\n");
return TRUE;
case 0x37: /* DAC C */
pBIOSInfo->TVOutput = TVOUTPUT_COMPOSITE;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"VT1625: Composite connected.\n");
return TRUE;
case 0x38: /* DAC D,E,F */
pBIOSInfo->TVOutput = TVOUTPUT_YCBCR;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"VT1625: YCbCr connected.\n");
return TRUE;
case 0x0F: /* DAC A,B */
pBIOSInfo->TVOutput = TVOUTPUT_SVIDEO;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"VT1625: S-Video connected.\n");
return TRUE;
case 0x3F:
pBIOSInfo->TVOutput = TVOUTPUT_NONE;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"VT1625: Nothing connected.\n");
return FALSE;
default:
pBIOSInfo->TVOutput = TVOUTPUT_NONE;
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"VT1625: Unknown cable combination: 0x0%2X.\n", sense);
return FALSE;
}
}
void
VIAInitLinear(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
VIAPtr pVia = VIAPTR(pScrn);
if (pVia->useEXA && !pVia->NoAccel)
return;
else
{
unsigned long offset = (pVia->FBFreeStart + pVia->Bpp - 1) / pVia->Bpp;
long size = pVia->FBFreeEnd / pVia->Bpp - offset;
if (size > 0)
xf86InitFBManagerLinear(pScreen, offset, size);
}
}
static void
VT162xPrintRegs(ScrnInfoPtr pScrn)
{
VIABIOSInfoPtr pBIOSInfo = VIAPTR(pScrn)->pBIOSInfo;
CARD8 i, buf;
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Printing registers for %s\n",
pBIOSInfo->TVI2CDev->DevName);
for (i = 0; i < pBIOSInfo->TVNumRegs; i++) {
xf86I2CReadByte(pBIOSInfo->TVI2CDev, i, &buf);
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "TV%02X: 0x%02X\n", i, buf);
}
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "End of TV registers.\n");
}
/*
Set the cursor position to (x,y). X and/or y may be negative
indicating that the cursor image is partially offscreen on
the left and/or top edges of the screen.
*/
static void
viaSetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
{
VIAPtr pVia = VIAPTR(pScrn);
unsigned xoff, yoff;
if (x < 0) {
xoff = ((-x) & 0xFE);
x = 0;
} else {
xoff = 0;
}
if (y < 0) {
yoff = ((-y) & 0xFE);
y = 0;
} else {
yoff = 0;
}
switch(pVia->Chipset) {
case VIA_CX700:
case VIA_P4M890:
case VIA_P4M900:
case VIA_VX800:
case VIA_VX855:
case VIA_VX900:
if (pVia->pBIOSInfo->FirstCRTC->IsActive) {
VIASETREG(VIA_REG_HI_POS0, ((x << 16) | (y & 0x07ff)));
VIASETREG(VIA_REG_HI_OFFSET0, ((xoff << 16) | (yoff & 0x07ff)));
}
if (pVia->pBIOSInfo->SecondCRTC->IsActive) {
VIASETREG(VIA_REG_HI_POS1, ((x << 16) | (y & 0x07ff)));
VIASETREG(VIA_REG_HI_OFFSET1, ((xoff << 16) | (yoff & 0x07ff)));
}
break;
default:
VIASETREG(VIA_REG_ALPHA_POS, ((x << 16) | (y & 0x07ff)));
VIASETREG(VIA_REG_ALPHA_OFFSET, ((xoff << 16) | (yoff & 0x07ff)));
}
}
void
viaShowCursor(ScrnInfoPtr pScrn)
{
VIAPtr pVia = VIAPTR(pScrn);
switch(pVia->Chipset) {
case VIA_CX700:
case VIA_P4M890:
case VIA_P4M900:
case VIA_VX800:
case VIA_VX855:
case VIA_VX900:
if (pVia->pBIOSInfo->FirstCRTC->IsActive) {
VIASETREG(VIA_REG_HI_CONTROL0, 0x36000005);
}
if (pVia->pBIOSInfo->SecondCRTC->IsActive) {
VIASETREG(VIA_REG_HI_CONTROL1, 0xb6000005);
}
break;
default:
/*temp = 0x76000005;
temp =
(1 << 30) |
(1 << 29) |
(1 << 28) |
(1 << 26) |
(1 << 25) |
(1 << 2) |
(1 << 0);
*/
/* Duoview */
if (pVia->CursorPipe) {
/* Mono Cursor Display Path [bit31]: Secondary */
/* FIXME For CLE266 and KM400 try to enable 32x32 cursor size [bit1] */
VIASETREG(VIA_REG_ALPHA_CONTROL, 0xF6000005);
} else {
/* Mono Cursor Display Path [bit31]: Primary */
VIASETREG(VIA_REG_ALPHA_CONTROL, 0x76000005);
}
}
}
static CARD8
VT1621ModeIndex(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
VIABIOSInfoPtr pBIOSInfo = VIAPTR(pScrn)->pBIOSInfo;
int i;
DEBUG(xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VT1621ModeIndex\n"));
for (i = 0; VT1621Table[i].Width; i++) {
if ((VT1621Table[i].Width == mode->CrtcHDisplay) &&
(VT1621Table[i].Height == mode->CrtcVDisplay) &&
(VT1621Table[i].Standard == pBIOSInfo->TVType) &&
!(strcmp(VT1621Table[i].name, mode->name)))
return i;
}
xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "VT1621ModeIndex:"
" Mode \"%s\" not found in Table\n", mode->name);
return 0xFF;
}
