#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86Resources.h"
#include "xf86_ansic.h"
#include "compiler.h"
#include "xf86PciInfo.h"
#include "xf86Pci.h"
#include "mipointer.h"
#include "mibstore.h"
#include "micmap.h"
#include "xf86DDC.h"
#include "xf86RAC.h"
#include "vbe.h"
#include "fb.h"
#include "cfb8_32.h"
#include "dixstruct.h"
#include "mga_reg.h"
#include "mga.h"
#include "mga_macros.h"
#include "xaa.h"
#include "xf86cmap.h"
#include "shadowfb.h"
#include "fbdevhw.h"
#ifdef XF86DRI
#include "dri.h"
#endif
static const OptionInfoRec * MGAAvailableOptions(int chipid, int busid);
static void MGAIdentify(int flags);
static Bool MGAProbe(DriverPtr drv, int flags);
static Bool MGAPreInit(ScrnInfoPtr pScrn, int flags);
static Bool MGAScreenInit(int Index, ScreenPtr pScreen, int argc,
char **argv);
static Bool MGAEnterVT(int scrnIndex, int flags);
static Bool MGAEnterVTFBDev(int scrnIndex, int flags);
static void MGALeaveVT(int scrnIndex, int flags);
static Bool MGACloseScreen(int scrnIndex, ScreenPtr pScreen);
static Bool MGASaveScreen(ScreenPtr pScreen, int mode);
static Bool MGASaveScreenCrtc2(ScreenPtr pScreen, int mode);
#ifdef DISABLE_VGA_IO
static void VgaIOSave(int i, void *arg);
static void VgaIORestore(int i, void *arg);
#endif
static void MGAFreeScreen(int scrnIndex, int flags);
static ModeStatus MGAValidMode(int scrnIndex, DisplayModePtr mode,
Bool verbose, int flags);
static Bool MGAMapMem(ScrnInfoPtr pScrn);
static Bool MGAUnmapMem(ScrnInfoPtr pScrn);
static void MGASave(ScrnInfoPtr pScrn);
static void MGARestore(ScrnInfoPtr pScrn);
static Bool MGAModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode);
static void MGABlockHandler(int, pointer, pointer, pointer);
static void MGAG100BlackMagic(ScrnInfoPtr pScrn);
static int MGAEntityIndex = -1;
#include "mga_merge.h"
DriverRec MGA_C_NAME = {
MGA_VERSION,
MGA_DRIVER_NAME,
MGAIdentify,
MGAProbe,
MGAAvailableOptions,
NULL,
0
};
static SymTabRec MGAChipsets[] = {
{ PCI_CHIP_MGA2064, "mga2064w" },
{ PCI_CHIP_MGA1064, "mga1064sg" },
{ PCI_CHIP_MGA2164, "mga2164w" },
{ PCI_CHIP_MGA2164_AGP, "mga2164w AGP" },
{ PCI_CHIP_MGAG100, "mgag100" },
{ PCI_CHIP_MGAG100_PCI, "mgag100 PCI" },
{ PCI_CHIP_MGAG200, "mgag200" },
{ PCI_CHIP_MGAG200_PCI, "mgag200 PCI" },
{ PCI_CHIP_MGAG400, "mgag400" },
{ PCI_CHIP_MGAG550, "mgag550" },
{-1, NULL }
};
static PciChipsets MGAPciChipsets[] = {
{ PCI_CHIP_MGA2064, PCI_CHIP_MGA2064, (resRange*)RES_SHARED_VGA },
{ PCI_CHIP_MGA1064, PCI_CHIP_MGA1064, (resRange*)RES_SHARED_VGA },
{ PCI_CHIP_MGA2164, PCI_CHIP_MGA2164, (resRange*)RES_SHARED_VGA },
{ PCI_CHIP_MGA2164_AGP, PCI_CHIP_MGA2164_AGP,(resRange*)RES_SHARED_VGA },
{ PCI_CHIP_MGAG100, PCI_CHIP_MGAG100, (resRange*)RES_SHARED_VGA },
{ PCI_CHIP_MGAG100_PCI, PCI_CHIP_MGAG100_PCI,(resRange*)RES_SHARED_VGA },
{ PCI_CHIP_MGAG200, PCI_CHIP_MGAG200, (resRange*)RES_SHARED_VGA },
{ PCI_CHIP_MGAG200_PCI, PCI_CHIP_MGAG200_PCI,(resRange*)RES_SHARED_VGA },
{ PCI_CHIP_MGAG400, PCI_CHIP_MGAG400, (resRange*)RES_SHARED_VGA },
{ PCI_CHIP_MGAG550, PCI_CHIP_MGAG550, (resRange*)RES_SHARED_VGA },
{ -1, -1, (resRange*)RES_UNDEFINED }
};
static const OptionInfoRec MGAOptions[] = {
{ OPTION_SW_CURSOR, "SWcursor", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_HW_CURSOR, "HWcursor", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_PCI_RETRY, "PciRetry", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_SYNC_ON_GREEN, "SyncOnGreen", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_NOACCEL, "NoAccel", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_SHOWCACHE, "ShowCache", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_OVERLAY, "Overlay", OPTV_ANYSTR, {0}, FALSE },
{ OPTION_MGA_SDRAM, "MGASDRAM", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_SHADOW_FB, "ShadowFB", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_FBDEV, "UseFBDev", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_COLOR_KEY, "ColorKey", OPTV_INTEGER, {0}, FALSE },
{ OPTION_SET_MCLK, "SetMclk", OPTV_FREQ, {0}, FALSE },
{ OPTION_OVERCLOCK_MEM, "OverclockMem", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_VIDEO_KEY, "VideoKey", OPTV_INTEGER, {0}, FALSE },
{ OPTION_ROTATE, "Rotate", OPTV_ANYSTR, {0}, FALSE },
{ OPTION_TEXTURED_VIDEO, "TexturedVideo",OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_CRTC2HALF, "Crtc2Half", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_CRTC2RAM, "Crtc2Ram", OPTV_INTEGER, {0}, FALSE },
{ OPTION_INT10, "Int10", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_AGP_MODE, "AGPMode", OPTV_INTEGER, {0}, FALSE },
{ OPTION_AGP_SIZE, "AGPSize", OPTV_INTEGER, {0}, FALSE },
{ OPTION_DIGITAL1, "DigitalScreen1",OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_DIGITAL2, "DigitalScreen2",OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_TV, "TV", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_TVSTANDARD, "TVStandard", OPTV_ANYSTR, {0}, FALSE },
{ OPTION_CABLETYPE, "CableType", OPTV_ANYSTR, {0}, FALSE },
{ OPTION_NOHAL, "NoHal", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_SWAPPED_HEAD, "SwappedHead", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_DRI, "DRI", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_MERGEDFB, "MergedFB", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_HSYNC2, "Monitor2HSync", OPTV_ANYSTR, {0}, FALSE },
{ OPTION_VREFRESH2, "Monitor2VRefresh", OPTV_ANYSTR, {0}, FALSE },
{ OPTION_MONITOR2POS, "Monitor2Position", OPTV_ANYSTR, {0}, FALSE },
{ OPTION_METAMODES, "MetaModes", OPTV_ANYSTR, {0}, FALSE },
{ -1, NULL, OPTV_NONE, {0}, FALSE }
};
static const char *vgahwSymbols[] = {
"vgaHWFreeHWRec",
"vgaHWGetHWRec",
"vgaHWGetIOBase",
"vgaHWGetIndex",
"vgaHWInit",
"vgaHWLock",
"vgaHWMapMem",
"vgaHWProtect",
"vgaHWRestore",
"vgaHWSave",
"vgaHWSaveScreen",
"vgaHWSetMmioFuncs",
"vgaHWUnlock",
"vgaHWUnmapMem",
"vgaHWddc1SetSpeed",
NULL
};
static const char *fbSymbols[] = {
"fbPictureInit",
"fbScreenInit",
NULL
};
static const char *xf8_32bppSymbols[] = {
"cfb8_32ScreenInit",
"xf86Overlay8Plus32Init",
NULL
};
static const char *xaaSymbols[] = {
"XAACachePlanarMonoStipple",
"XAACreateInfoRec",
"XAADestroyInfoRec",
"XAAFallbackOps",
"XAAInit",
"XAAMoveDWORDS",
"XAA_888_plus_PICT_a8_to_8888",
NULL
};
static const char *ramdacSymbols[] = {
"xf86CreateCursorInfoRec",
"xf86DestroyCursorInfoRec",
"xf86InitCursor",
NULL
};
#ifdef XF86DRI
static const char *drmSymbols[] = {
"drmAddBufs",
"drmAddMap",
"drmAgpAcquire",
"drmAgpAlloc",
"drmAgpBind",
"drmAgpDeviceId",
"drmAgpEnable",
"drmAgpFree",
"drmAgpGetMode",
"drmAgpRelease",
"drmAgpUnbind",
"drmAgpVendorId",
"drmCommandNone",
"drmCommandWrite",
"drmCtlInstHandler",
"drmCtlUninstHandler",
"drmFreeVersion",
"drmGetInterruptFromBusID",
"drmGetLibVersion",
"drmGetVersion",
"drmMap",
"drmMapBufs",
"drmUnmap",
"drmUnmapBufs",
NULL
};
static const char *driSymbols[] = {
"DRICloseScreen",
"DRICreateInfoRec",
"DRIDestroyInfoRec",
"DRIFinishScreenInit",
"DRIGetDeviceInfo",
"DRILock",
"DRIQueryVersion",
"DRIScreenInit",
"DRIUnlock",
"GlxSetVisualConfigs",
NULL
};
#endif
#define MGAuseI2C 1
static const char *ddcSymbols[] = {
"xf86DoEDID_DDC1",
#if MGAuseI2C
"xf86DoEDID_DDC2",
#endif
"xf86PrintEDID",
"xf86SetDDCproperties",
NULL
};
static const char *i2cSymbols[] = {
"xf86CreateI2CBusRec",
"xf86I2CBusInit",
NULL
};
static const char *shadowSymbols[] = {
"ShadowFBInit",
NULL
};
#ifdef XFree86LOADER
static const char *vbeSymbols[] = {
"VBEInit",
"vbeDoEDID",
"vbeFree",
NULL
};
#endif
static const char *int10Symbols[] = {
"xf86FreeInt10",
"xf86InitInt10",
NULL
};
static const char *fbdevHWSymbols[] = {
"fbdevHWAdjustFrame",
"fbdevHWEnterVT",
"fbdevHWGetVidmem",
"fbdevHWInit",
"fbdevHWLeaveVT",
"fbdevHWLoadPalette",
"fbdevHWMapMMIO",
"fbdevHWMapVidmem",
"fbdevHWModeInit",
"fbdevHWRestore",
"fbdevHWSave",
"fbdevHWSwitchMode",
"fbdevHWUnmapMMIO",
"fbdevHWUnmapVidmem",
"fbdevHWUseBuildinMode",
"fbdevHWValidMode",
NULL
};
#ifdef USEMGAHAL
static const char *halSymbols[] = {
"MGACloseLibrary",
"MGAGetBOARDHANDLESize",
"MGAGetHardwareInfo",
"MGAOpenLibrary",
"MGARestoreVgaState",
"MGASaveVgaState",
"MGASetMode",
"MGASetVgaMode",
"MGAValidateMode",
"MGAValidateVideoParameters",
"HALSetDisplayStart",
NULL
};
#endif
#ifdef XFree86LOADER
static MODULESETUPPROTO(mgaSetup);
static XF86ModuleVersionInfo mgaVersRec =
{
MGA_DRIVER_NAME,
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XF86_VERSION_CURRENT,
MGA_MAJOR_VERSION, MGA_MINOR_VERSION, MGA_PATCHLEVEL,
ABI_CLASS_VIDEODRV,
ABI_VIDEODRV_VERSION,
MOD_CLASS_VIDEODRV,
{0,0,0,0}
};
XF86ModuleData MGA_MODULE_DATA = { &mgaVersRec, mgaSetup, NULL };
static pointer
mgaSetup(pointer module, pointer opts, int *errmaj, int *errmin)
{
static Bool setupDone = FALSE;
if (!setupDone) {
setupDone = TRUE;
xf86AddDriver(&MGA_C_NAME, module, 0);
LoaderRefSymLists(vgahwSymbols, xaaSymbols,
xf8_32bppSymbols, ramdacSymbols,
ddcSymbols, i2cSymbols, shadowSymbols,
fbdevHWSymbols, vbeSymbols,
fbSymbols, int10Symbols,
#ifdef XF86DRI
drmSymbols, driSymbols,
#endif
#ifdef USEMGAHAL
halSymbols,
#endif
NULL);
return (pointer)1;
} else {
if (errmaj) *errmaj = LDR_ONCEONLY;
return NULL;
}
}
#endif
static MGARamdacRec DacInit = {
FALSE, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL,
90000,
0, X_DEFAULT, X_DEFAULT, FALSE
};
Bool
MGAGetRec(ScrnInfoPtr pScrn)
{
if (pScrn->driverPrivate != NULL)
return TRUE;
pScrn->driverPrivate = xnfcalloc(sizeof(MGARec), 1);
MGAPTR(pScrn)->Dac = DacInit;
return TRUE;
}
void
MGAFreeRec(ScrnInfoPtr pScrn)
{
if (pScrn->driverPrivate == NULL)
return;
xfree(pScrn->driverPrivate);
pScrn->driverPrivate = NULL;
}
static const OptionInfoRec *
MGAAvailableOptions(int chipid, int busid)
{
return MGAOptions;
}
static void
MGAIdentify(int flags)
{
xf86PrintChipsets(MGA_NAME, "driver for Matrox chipsets", MGAChipsets);
}
static Bool
MGAProbe(DriverPtr drv, int flags)
{
int i;
GDevPtr *devSections;
int *usedChips = NULL;
int numDevSections;
int numUsed;
Bool foundScreen = FALSE;
if ((numDevSections = xf86MatchDevice(MGA_DRIVER_NAME,
&devSections)) <= 0) {
return FALSE;
}
if (xf86GetPciVideoInfo() == NULL) {
return FALSE;
}
numUsed = xf86MatchPciInstances(MGA_NAME, PCI_VENDOR_MATROX,
MGAChipsets, MGAPciChipsets, devSections,
numDevSections, drv, &usedChips);
xfree(devSections);
if (numUsed <= 0)
return FALSE;
if (flags & PROBE_DETECT)
foundScreen = TRUE;
else for (i = 0; i < numUsed; i++) {
ScrnInfoPtr pScrn;
EntityInfoPtr pEnt;
#ifdef DISABLE_VGA_IO
MgaSavePtr smga;
#endif
pScrn = NULL;
#ifndef DISABLE_VGA_IO
if ((pScrn = xf86ConfigPciEntity(pScrn, 0,usedChips[i],
MGAPciChipsets, NULL, NULL,
NULL, NULL, NULL)))
#else
smga = xnfalloc(sizeof(MgaSave));
smga->pvp = xf86GetPciInfoForEntity(usedChips[i]);
if ((pScrn = xf86ConfigPciEntity(pScrn, 0,usedChips[i],
MGAPciChipsets, NULL,VgaIOSave,
VgaIOSave, VgaIORestore,smga)))
#endif
{
pScrn->driverVersion = MGA_VERSION;
pScrn->driverName = MGA_DRIVER_NAME;
pScrn->name = MGA_NAME;
pScrn->Probe = MGAProbe;
pScrn->PreInit = MGAPreInit;
pScrn->ScreenInit = MGAScreenInit;
pScrn->SwitchMode = MGASwitchMode;
pScrn->AdjustFrame = MGAAdjustFrame;
pScrn->EnterVT = MGAEnterVT;
pScrn->LeaveVT = MGALeaveVT;
pScrn->FreeScreen = MGAFreeScreen;
pScrn->ValidMode = MGAValidMode;
foundScreen = TRUE;
}
pEnt = xf86GetEntityInfo(usedChips[i]);
if ((pEnt->chipset == PCI_CHIP_MGAG400 || pEnt->chipset == PCI_CHIP_MGAG550)) {
MGAEntPtr pMgaEnt = NULL;
DevUnion *pPriv;
xf86SetEntitySharable(usedChips[i]);
if (MGAEntityIndex < 0)
MGAEntityIndex = xf86AllocateEntityPrivateIndex();
pPriv = xf86GetEntityPrivate(pScrn->entityList[0], MGAEntityIndex);
if (!pPriv->ptr) {
pPriv->ptr = xnfcalloc(sizeof(MGAEntRec), 1);
pMgaEnt = pPriv->ptr;
pMgaEnt->lastInstance = -1;
} else {
pMgaEnt = pPriv->ptr;
}
pMgaEnt->lastInstance++;
xf86SetEntityInstanceForScreen(pScrn, pScrn->entityList[0],
pMgaEnt->lastInstance);
}
}
xfree(usedChips);
return foundScreen;
}
void
MGAReadBios(ScrnInfoPtr pScrn)
{
CARD8 BIOS[0x10000];
CARD16 offset;
CARD8 chksum;
CARD8 *pPINSInfo;
MGAPtr pMga;
MGABiosInfo *pBios;
MGABios2Info *pBios2;
Bool pciBIOS = TRUE;
int rlen;
pMga = MGAPTR(pScrn);
pBios = &pMga->Bios;
pBios2 = &pMga->Bios2;
xf86ReadDomainMemory(pMga->PciTag, pMga->BiosAddress + 0x7ff1u,
sizeof(CARD8), &pMga->BiosOutputMode);
if (pMga->BiosFrom == X_DEFAULT)
pciBIOS = FALSE;
else if (pMga->BiosFrom == X_CONFIG && pMga->BiosAddress < 0x100000)
pciBIOS = TRUE;
if (pciBIOS)
rlen = xf86ReadPciBIOS(0, pMga->PciTag, pMga->FbBaseReg,
BIOS, sizeof(BIOS));
else
rlen = xf86ReadDomainMemory(pMga->PciTag, pMga->BiosAddress,
sizeof(BIOS), BIOS);
if (rlen < (BIOS[2] << 9)) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Could not retrieve video BIOS!\n");
return;
}
if (strncmp((char *)(&BIOS[45]), "MATROX", 6)) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Video BIOS info block not detected!\n");
return;
}
offset = (BIOS[0x7ffd] << 8) | BIOS[0x7ffc];
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Video BIOS info block at offset 0x%05lX\n",
(long)(offset));
#define MGADoBIOSRead(offset, buf, len) memcpy(buf, &BIOS[offset], len)
switch (pMga->Chipset){
case PCI_CHIP_MGA2064:
MGADoBIOSRead(offset,
( CARD8 * ) & pBios->StructLen, sizeof( MGABiosInfo ));
break;
default:
MGADoBIOSRead(offset,
( CARD8 * ) & pBios2->PinID, sizeof( MGABios2Info ));
break;
}
if ( pBios2->PinID == 0x412e ) {
int i;
if ( pBios2->StructLen != 0x40 ) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Video BIOS info block not detected!\n");
pBios2->PinID = 0;
return;
}
chksum = 0;
pPINSInfo = (CARD8 *) &pBios2->PinID;
for (i=0; i < pBios2->StructLen; i++) {
chksum += *pPINSInfo;
pPINSInfo++;
}
if ( chksum ) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Video BIOS info block did not checksum!\n");
pBios2->PinID = 0;
return;
}
if ( pBios2->StructRev == 0 ) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Video BIOS info block does not have a valid revision!\n");
pBios2->PinID = 0;
return;
}
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Found and verified enhanced Video BIOS info block\n");
if ( pBios2->ClkMem == 0 )
pBios2->ClkMem = 50;
if ( pBios2->Clk4MB == 0 )
pBios2->Clk4MB = pBios->ClkBase;
if ( pBios2->Clk8MB == 0 )
pBios2->Clk8MB = pBios->Clk4MB;
pBios->StructLen = 0;
#ifdef DEBUG
for (i = 0; i < 0x40; i++)
ErrorF("Pins[0x%02x] is 0x%02x\n", i,
((unsigned char *)pBios2)[i]);
#endif
} else {
if ( pBios->ClkBase == 0 )
pBios->ClkBase = 4500;
if ( pBios->Clk4MB == 0 )
pBios->Clk4MB = pBios->ClkBase;
if ( pBios->Clk8MB == 0 )
pBios->Clk8MB = pBios->Clk4MB;
pBios2->PinID = 0;
}
}
void
MGASoftReset(ScrnInfoPtr pScrn)
{
MGAPtr pMga = MGAPTR(pScrn);
pMga->FbMapSize = 8192 * 1024;
MGAMapMem(pScrn);
OUTREG(MGAREG_Reset, 1);
usleep(200);
OUTREG(MGAREG_Reset, 0);
OUTREG(MGAREG_MACCESS, 1<<15);
usleep(10);
#if 0
while ( MGAISBUSY() )
usleep(1000);
i = 32;
WAITFIFO(i);
while ( i-- )
OUTREG(MGAREG_SHIFT, 0);
#endif
MGAUnmapMem(pScrn);
}
static int
MGACountRam(ScrnInfoPtr pScrn)
{
MGAPtr pMga = MGAPTR(pScrn);
int ProbeSize = 8192;
int SizeFound = 2048;
CARD32 biosInfo = 0;
#if 0
if(pMga->Primary)
biosInfo = pciReadLong(pMga->PciTag, PCI_OPTION_REG);
#endif
switch(pMga->Chipset) {
case PCI_CHIP_MGA2164:
case PCI_CHIP_MGA2164_AGP:
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Unable to probe memory amount due to hardware bug. "
"Assuming 4096 KB\n");
return 4096;
case PCI_CHIP_MGAG400:
case PCI_CHIP_MGAG550:
if(biosInfo) {
switch((biosInfo >> 10) & 0x07) {
case 0:
return (biosInfo & (1 << 14)) ? 32768 : 16384;
case 1:
case 2:
return 16384;
case 3:
case 5:
return 65536;
case 4:
return 32768;
}
}
ProbeSize = 32768;
break;
case PCI_CHIP_MGAG200:
case PCI_CHIP_MGAG200_PCI:
if(biosInfo) {
switch((biosInfo >> 11) & 0x03) {
case 0:
return 8192;
default:
return 16384;
}
}
ProbeSize = 8192;
break;
case PCI_CHIP_MGAG100:
case PCI_CHIP_MGAG100_PCI:
if(biosInfo)
return (biosInfo & (1 << 12)) ? 16384 : 8192;
case PCI_CHIP_MGA1064:
case PCI_CHIP_MGA2064:
ProbeSize = 8192;
break;
default:
break;
}
if (pMga->FbAddress) {
volatile unsigned char* base;
unsigned char tmp;
int i;
pMga->FbMapSize = ProbeSize * 1024;
MGAMapMem(pScrn);
base = pMga->FbBase;
OUTREG8(MGAREG_CRTCEXT_INDEX, 3);
tmp = INREG8(MGAREG_CRTCEXT_DATA);
OUTREG8(MGAREG_CRTCEXT_DATA, tmp | 0x80);
for(i = ProbeSize; i > 2048; i -= 2048) {
base[(i * 1024) - 1] = 0xAA;
}
OUTREG8(MGAREG_CRTC_INDEX, 0);
usleep(4);
for(i = ProbeSize; i > 2048; i -= 2048) {
if(base[(i * 1024) - 1] == 0xAA) {
SizeFound = i;
break;
}
}
OUTREG8(MGAREG_CRTCEXT_INDEX, 3);
OUTREG8(MGAREG_CRTCEXT_DATA, tmp);
MGAUnmapMem(pScrn);
}
return SizeFound;
}
static xf86MonPtr
MGAdoDDC(ScrnInfoPtr pScrn)
{
vgaHWPtr hwp;
MGAPtr pMga;
xf86MonPtr MonInfo = NULL;
hwp = VGAHWPTR(pScrn);
pMga = MGAPTR(pScrn);
if (pMga->ddc1Read || pMga->i2cInit) {
if (xf86LoadSubModule(pScrn, "ddc")) {
xf86LoaderReqSymLists(ddcSymbols, NULL);
} else {
pMga->ddc1Read = NULL;
pMga->i2cInit = NULL;
return NULL;
}
} else
return NULL;
#if MGAuseI2C
if (pMga->i2cInit) {
if ( xf86LoadSubModule(pScrn, "i2c") ) {
xf86LoaderReqSymLists(i2cSymbols,NULL);
} else {
pMga->i2cInit = NULL;
pMga->I2C = NULL;
}
}
#endif
if (!MGAMapMem(pScrn))
return NULL;
vgaHWSetMmioFuncs(hwp, pMga->IOBase, PORT_OFFSET);
vgaHWGetIOBase(hwp);
if (pMga->Primary) {
hwp->MapSize = 0x10000;
if (!vgaHWMapMem(pScrn))
return NULL;
} else {
if (pMga->DDC1SetSpeed == vgaHWddc1SetSpeed) {
pMga->DDC1SetSpeed = NULL;
xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
"DDC1 disabled - chip not in VGA mode\n");
}
}
MGASave(pScrn);
#if MGAuseI2C
if (pMga->i2cInit) {
pMga->i2cInit(pScrn);
}
if (pMga->I2C) {
MonInfo = xf86DoEDID_DDC2(pScrn->scrnIndex,pMga->I2C);
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "I2C Monitor info: %p\n",
(void *)MonInfo);
xf86PrintEDID(MonInfo);
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "end of I2C Monitor info\n");
}
if (!MonInfo)
#endif
if (pMga->ddc1Read && pMga->DDC1SetSpeed) {
MonInfo = xf86DoEDID_DDC1(pScrn->scrnIndex,
pMga->DDC1SetSpeed,
pMga->ddc1Read ) ;
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "DDC Monitor info: %p\n",
(void *)MonInfo);
xf86PrintEDID( MonInfo );
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "end of DDC Monitor info\n");
}
if (!MonInfo){
vbeInfoPtr pVbe;
if (xf86LoadSubModule(pScrn, "vbe")) {
pVbe = VBEInit(NULL,pMga->pEnt->index);
MonInfo = vbeDoEDID(pVbe, NULL);
vbeFree(pVbe);
if (MonInfo){
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VBE DDC Monitor info: %p\n",
(void *)MonInfo);
xf86PrintEDID( MonInfo );
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "end of VBE DDC Monitor info\n\n");
}
}
}
MGARestore(pScrn);
MGAUnmapMem(pScrn);
if (xf86IsPrimaryPci(pMga->PciInfo) && !pMga->FBDev) {
vgaHWUnmapMem(pScrn);
}
xf86SetDDCproperties(pScrn, MonInfo);
return MonInfo;
}
#ifdef DISABLE_VGA_IO
static void
VgaIOSave(int i, void *arg)
{
MgaSavePtr sMga = arg;
PCITAG tag = pciTag(sMga->pvp->bus,sMga->pvp->device,sMga->pvp->func);
#ifdef DEBUG
ErrorF("mga: VgaIOSave: %d:%d:%d\n", sMga->pvp->bus, sMga->pvp->device,
sMga->pvp->func);
#endif
sMga->enable = (pciReadLong(tag, PCI_OPTION_REG) & 0x100) != 0;
}
static void
VgaIORestore(int i, void *arg)
{
MgaSavePtr sMga = arg;
PCITAG tag = pciTag(sMga->pvp->bus,sMga->pvp->device,sMga->pvp->func);
#ifdef DEBUG
ErrorF("mga: VgaIORestore: %d:%d:%d\n", sMga->pvp->bus, sMga->pvp->device,
sMga->pvp->func);
#endif
pciSetBitsLong(tag, PCI_OPTION_REG, 0x100, sMga->enable ? 0x100 : 0x000);
}
static void
VgaIODisable(void *arg)
{
MGAPtr pMga = arg;
#ifdef DEBUG
ErrorF("mga: VgaIODisable: %d:%d:%d, %s, xf86ResAccessEnter is %s\n",
pMga->PciInfo->bus, pMga->PciInfo->device, pMga->PciInfo->func,
pMga->Primary ? "primary" : "secondary",
BOOLTOSTRING(xf86ResAccessEnter));
#endif
pciSetBitsLong(pMga->PciTag, PCI_OPTION_REG, 0x100, 0x000);
}
static void
VgaIOEnable(void *arg)
{
MGAPtr pMga = arg;
#ifdef DEBUG
ErrorF("mga: VgaIOEnable: %d:%d:%d, %s, xf86ResAccessEnter is %s\n",
pMga->PciInfo->bus, pMga->PciInfo->device, pMga->PciInfo->func,
pMga->Primary ? "primary" : "secondary",
BOOLTOSTRING(xf86ResAccessEnter));
#endif
if (pMga->Primary)
pciSetBitsLong(pMga->PciTag, PCI_OPTION_REG, 0x100, 0x100);
}
#endif
void
MGAProbeDDC(ScrnInfoPtr pScrn, int index)
{
vbeInfoPtr pVbe;
if (xf86LoadSubModule(pScrn, "vbe")) {
pVbe = VBEInit(NULL,index);
ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
vbeFree(pVbe);
}
}
static Bool
MGAPreInit(ScrnInfoPtr pScrn, int flags)
{
MGAPtr pMga;
MessageType from;
int i;
double real;
int bytesPerPixel;
ClockRangePtr clockRanges;
const char *s;
int flags24;
MGAEntPtr pMgaEnt = NULL;
Bool Default;
#ifdef USEMGAHAL
ULONG status;
CARD8 MiscCtlReg;
#endif
if (pScrn->numEntities != 1)
return FALSE;
if (!MGAGetRec(pScrn)) {
return FALSE;
}
pMga = MGAPTR(pScrn);
#ifdef XF86DRI
pMga->haveQuiescense = 1;
#endif
pMga->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
if (pMga->pEnt->location.type != BUS_PCI)
return FALSE;
if (xf86IsEntityShared(pScrn->entityList[0])) {
pMgaEnt = xf86GetEntityPrivate(pScrn->entityList[0],
MGAEntityIndex)->ptr;
pMga->entityPrivate = pMgaEnt;
}
pMga->device = xf86GetDevFromEntity(pScrn->entityList[0],
pScrn->entityInstanceList[0]);
if (flags & PROBE_DETECT) {
MGAProbeDDC(pScrn, pMga->pEnt->index);
return TRUE;
}
if (!xf86LoadSubModule(pScrn, "vgahw"))
return FALSE;
xf86LoaderReqSymLists(vgahwSymbols, NULL);
if (!vgaHWGetHWRec(pScrn))
return FALSE;
pMga->PciInfo = xf86GetPciInfoForEntity(pMga->pEnt->index);
pMga->PciTag = pciTag(pMga->PciInfo->bus, pMga->PciInfo->device,
pMga->PciInfo->func);
pMga->Primary = xf86IsPrimaryPci(pMga->PciInfo);
#ifndef DISABLE_VGA_IO
xf86SetOperatingState(resVgaIo, pMga->pEnt->index, ResUnusedOpr);
xf86SetOperatingState(resVgaMem, pMga->pEnt->index, ResDisableOpr);
#else
pMga->Access.AccessDisable = VgaIODisable;
pMga->Access.AccessEnable = VgaIOEnable;
pMga->Access.arg = pMga;
xf86SetAccessFuncs(pMga->pEnt, &pMga->Access, &pMga->Access);
#endif
pScrn->monitor = pScrn->confScreen->monitor;
if (pMga->device->chipset && *pMga->device->chipset) {
pScrn->chipset = pMga->device->chipset;
pMga->Chipset = xf86StringToToken(MGAChipsets, pScrn->chipset);
from = X_CONFIG;
} else if (pMga->device->chipID >= 0) {
pMga->Chipset = pMga->device->chipID;
pScrn->chipset = (char *)xf86TokenToString(MGAChipsets, pMga->Chipset);
from = X_CONFIG;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipID override: 0x%04X\n",
pMga->Chipset);
} else {
from = X_PROBED;
pMga->Chipset = pMga->PciInfo->chipType;
pScrn->chipset = (char *)xf86TokenToString(MGAChipsets, pMga->Chipset);
}
if (pMga->device->chipRev >= 0) {
pMga->ChipRev = pMga->device->chipRev;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipRev override: %d\n",
pMga->ChipRev);
} else {
pMga->ChipRev = pMga->PciInfo->chipRev;
}
if (pScrn->chipset == NULL) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"ChipID 0x%04X is not recognised\n", pMga->Chipset);
return FALSE;
}
if (pMga->Chipset < 0) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Chipset \"%s\" is not recognised\n", pScrn->chipset);
return FALSE;
}
xf86DrvMsg(pScrn->scrnIndex, from, "Chipset: \"%s\"", pScrn->chipset);
if (pMga->Chipset == PCI_CHIP_MGAG400) {
if (pMga->ChipRev >= 0x80)
xf86ErrorF(" (G450)\n");
else
xf86ErrorF(" (G400)\n");
} else {
xf86ErrorF("\n");
}
#ifdef USEMGAHAL
if (HAL_CHIPSETS) {
Bool loadHal = TRUE;
from = X_DEFAULT;
if (xf86FindOption(pMga->device->options, "NoHal")) {
loadHal = !xf86SetBoolOption(pMga->device->options,
"NoHal", !loadHal);
from = X_CONFIG;
} else if (xf86FindOption(pMga->device->options, "Hal")) {
loadHal = xf86SetBoolOption(pMga->device->options,
"Hal", loadHal);
from = X_CONFIG;
}
if (loadHal && xf86LoadSubModule(pScrn, "mga_hal")) {
xf86LoaderReqSymLists(halSymbols, NULL);
xf86DrvMsg(pScrn->scrnIndex, from,"Matrox HAL module used\n");
pMga->HALLoaded = TRUE;
} else {
xf86DrvMsg(pScrn->scrnIndex, from, "Matrox HAL module not loaded "
"- using builtin mode setup instead\n");
pMga->HALLoaded = FALSE;
}
}
#endif
pMga->DualHeadEnabled = FALSE;
if (xf86IsEntityShared(pScrn->entityList[0])) {
#ifdef USEMGAHAL
if (pMga->HALLoaded || !MGA_DH_NEEDS_HAL(pMga)) {
#else
if (!MGA_DH_NEEDS_HAL(pMga)) {
#endif
pMga->DualHeadEnabled = TRUE;
} else if (xf86IsPrimInitDone(pScrn->entityList[0])) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"This card requires the \"mga_hal\" module for dual-head operation\n"
"\tIt can be found at the Matrox web site <http://www.matrox.com>\n");
}
}
if (xf86IsEntityShared(pScrn->entityList[0])) {
if (!xf86IsPrimInitDone(pScrn->entityList[0])) {
pMga->SecondCrtc = FALSE;
pMga->HWCursor = TRUE;
pMgaEnt->pScrn_1 = pScrn;
} else if (pMga->DualHeadEnabled) {
pMga->SecondCrtc = TRUE;
pMga->HWCursor = FALSE;
pMgaEnt->pScrn_2 = pScrn;
pScrn->AdjustFrame = MGAAdjustFrameCrtc2;
if(pMgaEnt->pScrn_1 && MGAPTR(pMgaEnt->pScrn_1)->MergedFB) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Primary head in Merged framebuffer mode. \n"
"Don't let Xfree try to manage the second head.\n"
"Remove the second screen in the \"ServerLayout\"\n"
"Section of the config file.");
return FALSE;
}
} else {
return FALSE;
}
}
if (pMga->DualHeadEnabled) {
#ifdef XF86DRI
pMga->GetQuiescence = MGAGetQuiescenceShared;
#endif
} else {
pMga->SecondCrtc = FALSE;
pMga->HWCursor = TRUE;
#ifdef XF86DRI
pMga->GetQuiescence = MGAGetQuiescence;
#endif
}
flags24 = Support24bppFb | Support32bppFb | SupportConvert32to24;
s = xf86TokenToOptName(MGAOptions, OPTION_OVERLAY);
#ifndef XF86DRI
if (!(xf86FindOption(pScrn->confScreen->options, s) ||
xf86FindOption(pMga->device->options, s))) {
flags24 |= PreferConvert32to24;
}
#endif
if (pMga->SecondCrtc)
flags24 = Support32bppFb;
if (!xf86SetDepthBpp(pScrn, 0, 0, 0, flags24)) {
return FALSE;
} else {
switch (pScrn->depth) {
case 8:
case 15:
case 16:
case 24:
break;
default:
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Given depth (%d) is not supported by this driver\n",
pScrn->depth);
return FALSE;
}
}
xf86PrintDepthBpp(pScrn);
if (pScrn->depth > 8) {
rgb zeros = {0, 0, 0};
if (!xf86SetWeight(pScrn, zeros, zeros)) {
return FALSE;
} else {
;
}
}
bytesPerPixel = pScrn->bitsPerPixel / 8;
pScrn->progClock = TRUE;
xf86CollectOptions(pScrn, NULL);
if (!(pMga->Options = xalloc(sizeof(MGAOptions))))
return FALSE;
memcpy(pMga->Options, MGAOptions, sizeof(MGAOptions));
xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pMga->Options);
#if !defined(__powerpc__)
pMga->softbooted = FALSE;
if (pMga->Chipset >= PCI_CHIP_MGAG400
&& !pMga->Primary
&& !pMga->SecondCrtc)
Default = TRUE;
else
Default = FALSE;
if (xf86ReturnOptValBool(pMga->Options, OPTION_INT10, Default) &&
xf86LoadSubModule(pScrn, "int10")) {
xf86Int10InfoPtr pInt;
xf86LoaderReqSymLists(int10Symbols, NULL);
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Initializing int10\n");
pInt = xf86InitInt10(pMga->pEnt->index);
if (pInt) pMga->softbooted = TRUE;
xf86FreeInt10(pInt);
}
#endif
if (pScrn->depth == 8)
pScrn->rgbBits = 8;
#ifdef XF86DRI
from = X_DEFAULT;
pMga->agpMode = MGA_DEFAULT_AGP_MODE;
if (xf86GetOptValInteger(pMga->Options,
OPTION_AGP_MODE, &(pMga->agpMode))) {
if (pMga->agpMode < 1) {
pMga->agpMode = 1;
}
if (pMga->agpMode > MGA_MAX_AGP_MODE) {
pMga->agpMode = MGA_MAX_AGP_MODE;
}
from = X_CONFIG;
}
if (xf86GetOptValInteger(pMga->Options,
OPTION_AGP_SIZE, &(pMga->agpSize))) {
xf86DrvMsg(pScrn->scrnIndex, from, "Using %d MB of AGP memory\n",
pMga->agpSize);
}
xf86DrvMsg(pScrn->scrnIndex, from, "Using AGP %dx mode\n",
pMga->agpMode);
#endif
from = X_DEFAULT;
if (xf86GetOptValBool(pMga->Options, OPTION_HW_CURSOR, &pMga->HWCursor)) {
from = X_CONFIG;
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_NOACCEL, FALSE)) {
pMga->NoAccel = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_PCI_RETRY, FALSE)) {
pMga->UsePCIRetry = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "PCI retry enabled\n");
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_SYNC_ON_GREEN, FALSE)) {
pMga->SyncOnGreen = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Sync-on-Green enabled\n");
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_SHOWCACHE, FALSE)) {
pMga->ShowCache = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ShowCache enabled\n");
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_MGA_SDRAM, FALSE)) {
pMga->HasSDRAM = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Has SDRAM\n");
}
if (xf86GetOptValFreq(pMga->Options, OPTION_SET_MCLK, OPTUNITS_MHZ, &real)) {
pMga->MemClk = (int)(real * 1000.0);
}
if ((s = xf86GetOptValString(pMga->Options, OPTION_OVERLAY))) {
if (!*s || !xf86NameCmp(s, "8,24") || !xf86NameCmp(s, "24,8")) {
if(pScrn->bitsPerPixel == 32 && pMga->SecondCrtc == FALSE) {
pMga->Overlay8Plus24 = TRUE;
if(!xf86GetOptValInteger(
pMga->Options, OPTION_COLOR_KEY,&(pMga->colorKey)))
pMga->colorKey = TRANSPARENCY_KEY;
pScrn->colorKey = pMga->colorKey;
pScrn->overlayFlags = OVERLAY_8_32_PLANAR;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"PseudoColor overlay enabled\n");
} else {
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"Option \"Overlay\" is only supported in 32 bits per pixel on"
"the first CRTC\n");
}
} else {
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"\"%s\" is not a valid value for Option \"Overlay\"\n", s);
}
}
if(xf86GetOptValInteger(pMga->Options, OPTION_VIDEO_KEY, &(pMga->videoKey))) {
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "video key set to 0x%x\n",
pMga->videoKey);
} else {
pMga->videoKey = (1 << pScrn->offset.red) |
(1 << pScrn->offset.green) |
(((pScrn->mask.blue >> pScrn->offset.blue) - 1) << pScrn->offset.blue);
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_SHADOW_FB, FALSE)) {
pMga->ShadowFB = TRUE;
pMga->NoAccel = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"Using \"Shadow Framebuffer\" - acceleration disabled\n");
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_FBDEV, FALSE)) {
pMga->FBDev = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"Using framebuffer device\n");
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_OVERCLOCK_MEM, FALSE)) {
pMga->OverclockMem = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Overclocking memory\n");
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_TEXTURED_VIDEO, FALSE)) {
pMga->TexturedVideo = TRUE;
}
if (xf86ReturnOptValBool(pMga->Options, OPTION_MERGEDFB, FALSE)) {
if(!MGAISGx50(pMga)) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"\"Merged Framebuffer\" mode only supported on G450 and G550 boards.\n");
} else {
#ifdef USEMGAHAL
if(pMga->HALLoaded)
{
pMga->MergedFB = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"Using \"Merged Framebuffer\" mode.\n");
if(pMga->HWCursor)
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
" -- Hardware Cursor disabled.\n");
pMga->HWCursor = FALSE;
if(pMga->ShadowFB)
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
" -- Shadow Framebuffer disabled.\n");
pMga->ShadowFB = FALSE;
if(pMga->FBDev)
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
" -- Framebuffer device disabled.\n");
pMga->FBDev = FALSE;
}
else
#endif
{
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"HALLib not loaded! NOT using \"Merged Framebuffer\" mode.\n");
}
}
}
if (pMga->FBDev) {
if (!xf86LoadSubModule(pScrn, "fbdevhw"))
return FALSE;
xf86LoaderReqSymLists(fbdevHWSymbols, NULL);
if (!fbdevHWInit(pScrn, pMga->PciInfo, NULL))
return FALSE;
pScrn->SwitchMode = fbdevHWSwitchMode;
pScrn->AdjustFrame = fbdevHWAdjustFrame;
pScrn->EnterVT = MGAEnterVTFBDev;
pScrn->LeaveVT = fbdevHWLeaveVT;
pScrn->ValidMode = fbdevHWValidMode;
}
pMga->Rotate = 0;
if ((s = xf86GetOptValString(pMga->Options, OPTION_ROTATE))) {
if(!pMga->MergedFB) {
if(!xf86NameCmp(s, "CW")) {
pMga->ShadowFB = TRUE;
pMga->NoAccel = TRUE;
pMga->HWCursor = FALSE;
pMga->Rotate = 1;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"Rotating screen clockwise - acceleration disabled\n");
} else
if(!xf86NameCmp(s, "CCW")) {
pMga->ShadowFB = TRUE;
pMga->NoAccel = TRUE;
pMga->HWCursor = FALSE;
pMga->Rotate = -1;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"Rotating screen counter clockwise - acceleration disabled\n");
} else {
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"\"%s\" is not a valid value for Option \"Rotate\"\n", s);
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Valid options are \"CW\" or \"CCW\"\n");
}
} else {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
" -- Rotation disabled.\n");
}
}
switch (pMga->Chipset) {
case PCI_CHIP_MGA2064:
case PCI_CHIP_MGA2164:
case PCI_CHIP_MGA2164_AGP:
MGA2064SetupFuncs(pScrn);
break;
case PCI_CHIP_MGA1064:
case PCI_CHIP_MGAG100:
case PCI_CHIP_MGAG100_PCI:
case PCI_CHIP_MGAG200:
case PCI_CHIP_MGAG200_PCI:
case PCI_CHIP_MGAG400:
case PCI_CHIP_MGAG550:
MGAGSetupFuncs(pScrn);
break;
}
if (pMga->device->MemBase != 0) {
if (!xf86CheckPciMemBase(pMga->PciInfo, pMga->device->MemBase)) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"MemBase 0x%08lX doesn't match any PCI base register.\n",
pMga->device->MemBase);
MGAFreeRec(pScrn);
return FALSE;
}
pMga->FbAddress = pMga->device->MemBase;
from = X_CONFIG;
} else {
int i = ((pMga->Chipset == PCI_CHIP_MGA1064 && pMga->ChipRev < 3) ||
pMga->Chipset == PCI_CHIP_MGA2064) ? 1 : 0;
pMga->FbBaseReg = i;
if (pMga->PciInfo->memBase[i] != 0) {
pMga->FbAddress = pMga->PciInfo->memBase[i] & 0xff800000;
from = X_PROBED;
} else {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"No valid FB address in PCI config space\n");
MGAFreeRec(pScrn);
return FALSE;
}
}
xf86DrvMsg(pScrn->scrnIndex, from, "Linear framebuffer at 0x%lX\n",
(unsigned long)pMga->FbAddress);
#if !defined(__powerpc__)
if (pMga->device->IOBase != 0) {
if (!xf86CheckPciMemBase(pMga->PciInfo, pMga->device->IOBase)) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"IOBase 0x%08lX doesn't match any PCI base register.\n",
pMga->device->IOBase);
MGAFreeRec(pScrn);
return FALSE;
}
pMga->IOAddress = pMga->device->IOBase;
from = X_CONFIG;
} else
#endif
{
int i = ((pMga->Chipset == PCI_CHIP_MGA1064 && pMga->ChipRev < 3) ||
pMga->Chipset == PCI_CHIP_MGA2064) ? 0 : 1;
if (pMga->PciInfo->memBase[i] != 0) {
pMga->IOAddress = pMga->PciInfo->memBase[i] & 0xffffc000;
from = X_PROBED;
} else {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"No valid MMIO address in PCI config space\n");
MGAFreeRec(pScrn);
return FALSE;
}
}
xf86DrvMsg(pScrn->scrnIndex, from, "MMIO registers at 0x%lX\n",
(unsigned long)pMga->IOAddress);
pMga->ILOADAddress = 0;
if ( pMga->Chipset != PCI_CHIP_MGA2064 ) {
if (pMga->PciInfo->memBase[2] != 0) {
pMga->ILOADAddress = pMga->PciInfo->memBase[2] & 0xffffc000;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Pseudo-DMA transfer window at 0x%lX\n",
(unsigned long)pMga->ILOADAddress);
}
}
#if !defined(__powerpc__)
pMga->BiosFrom = X_NONE;
if (pMga->device->BiosBase != 0) {
pMga->BiosAddress = pMga->device->BiosBase;
pMga->BiosFrom = X_CONFIG;
} else {
if (pMga->PciInfo->biosBase != 0) {
pMga->BiosAddress = pMga->PciInfo->biosBase & 0xffff0000;
pMga->BiosFrom = X_PROBED;
} else if (pMga->Primary) {
pMga->BiosAddress = 0xc0000;
pMga->BiosFrom = X_DEFAULT;
}
}
if (pMga->BiosAddress) {
xf86DrvMsg(pScrn->scrnIndex, pMga->BiosFrom, "BIOS at 0x%lX\n",
(unsigned long)pMga->BiosAddress);
}
if (xf86RegisterResources(pMga->pEnt->index, NULL, ResExclusive)) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"xf86RegisterResources() found resource conflicts\n");
MGAFreeRec(pScrn);
return FALSE;
}
#if defined(__alpha__)
if ((pMga->BiosAddress == 0) && !xf86IsPrimaryPci(pMga->PciInfo))
xf86DrvMsg(pScrn->scrnIndex, pMga->BiosFrom,
"BIOS not found, skipping read\n");
else
#endif
MGAReadBios(pScrn);
if (!pMga->SecondCrtc)
pMga->SecondOutput = FALSE;
else
pMga->SecondOutput = TRUE;
if (pMga->Chipset == PCI_CHIP_MGAG550) {
if (!pMga->SecondCrtc) {
pMga->SecondOutput = (pMga->BiosOutputMode & 0x1) ? TRUE : FALSE;
} else {
pMga->SecondOutput = (pMga->BiosOutputMode & 0x1) ? FALSE : TRUE;
}
}
xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,
"MGABios.RamdacType = 0x%x\n", pMga->Bios.RamdacType);
#endif
pMga->HwBpp = pScrn->bitsPerPixel;
if ( (!pMga->Primary && !pMga->FBDev) || xf86IsPc98() )
MGASoftReset(pScrn);
from = X_PROBED;
if (pMga->device->videoRam != 0) {
pScrn->videoRam = pMga->device->videoRam;
from = X_CONFIG;
} else if (pMga->FBDev) {
pScrn->videoRam = fbdevHWGetVidmem(pScrn)/1024;
} else {
pScrn->videoRam = MGACountRam(pScrn);
}
if (pMga->DualHeadEnabled) {
if(pMga->SecondCrtc == FALSE) {
Bool UseHalf = FALSE;
int adjust;
xf86GetOptValBool(pMga->Options, OPTION_CRTC2HALF, &UseHalf);
adjust = pScrn->videoRam / 2;
if (UseHalf == TRUE ||
xf86GetOptValInteger(pMga->Options, OPTION_CRTC2RAM, &adjust)) {
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"Crtc2 will use %dK of VideoRam\n",
adjust);
} else {
adjust = min(adjust, 8192);
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Crtc2 will use %dK of VideoRam\n",
adjust);
}
pMgaEnt->mastervideoRam = pScrn->videoRam - adjust;
pScrn->videoRam = pMgaEnt->mastervideoRam;
pMgaEnt->slavevideoRam = adjust;
pMgaEnt->masterFbAddress = pMga->FbAddress;
pMga->FbMapSize =
pMgaEnt->masterFbMapSize = pScrn->videoRam * 1024;
pMgaEnt->slaveFbAddress = pMga->FbAddress +
pMgaEnt->masterFbMapSize;
pMgaEnt->slaveFbMapSize = pMgaEnt->slavevideoRam * 1024;
pMga->realSrcOrg = pMga->SrcOrg = 0;
pMga->DstOrg = 0;
} else {
pMga->FbAddress = pMgaEnt->slaveFbAddress;
pMga->FbMapSize = pMgaEnt->slaveFbMapSize;
pScrn->videoRam = pMgaEnt->slavevideoRam;
pMga->DstOrg = pMga->realSrcOrg =
pMgaEnt->slaveFbAddress - pMgaEnt->masterFbAddress;
pMga->SrcOrg = 0;
}
pMgaEnt->refCount++;
} else {
pMga->FbMapSize = pScrn->videoRam * 1024;
switch(pMga->Chipset) {
case PCI_CHIP_MGAG550:
case PCI_CHIP_MGAG400:
case PCI_CHIP_MGAG200:
case PCI_CHIP_MGAG200_PCI:
pMga->SrcOrg = 0;
pMga->DstOrg = 0;
break;
default:
break;
}
}
xf86DrvMsg(pScrn->scrnIndex, from, "VideoRAM: %d kByte\n",
pScrn->videoRam);
pMga->BppShifts[0] = 0;
pMga->BppShifts[1] = 1;
pMga->BppShifts[2] = 0;
pMga->BppShifts[3] = 2;
(*pMga->PreInit)(pScrn);
#if !defined(__powerpc__)
pScrn->monitor->DDC = MGAdoDDC(pScrn);
#endif
{
Gamma zeros = {0.0, 0.0, 0.0};
if (!xf86SetGamma(pScrn, zeros)) {
return FALSE;
}
}
pMga->MinClock = 12000;
xf86DrvMsg(pScrn->scrnIndex, X_DEFAULT, "Min pixel clock is %d MHz\n",
pMga->MinClock / 1000);
if (pMga->device->dacSpeeds[0]) {
int speed = 0;
switch (pScrn->bitsPerPixel) {
case 8:
speed = pMga->device->dacSpeeds[DAC_BPP8];
break;
case 16:
speed = pMga->device->dacSpeeds[DAC_BPP16];
break;
case 24:
speed = pMga->device->dacSpeeds[DAC_BPP24];
break;
case 32:
speed = pMga->device->dacSpeeds[DAC_BPP32];
break;
}
if (speed == 0)
pMga->MaxClock = pMga->device->dacSpeeds[0];
else
pMga->MaxClock = speed;
from = X_CONFIG;
} else {
pMga->MaxClock = pMga->Dac.maxPixelClock;
from = pMga->Dac.ClockFrom;
}
if(pMga->SecondCrtc == TRUE) {
if ((pMga->ChipRev >= 0x80) || (pMga->Chipset == PCI_CHIP_MGAG550)) {
pMga->MaxClock = 234000;
} else {
pMga->MaxClock = 135000;
}
}
xf86DrvMsg(pScrn->scrnIndex, from, "Max pixel clock is %d MHz\n",
pMga->MaxClock / 1000);
clockRanges = xnfcalloc(sizeof(ClockRange), 1);
clockRanges->next = NULL;
clockRanges->minClock = pMga->MinClock;
clockRanges->maxClock = pMga->MaxClock;
clockRanges->clockIndex = -1;
clockRanges->interlaceAllowed = TRUE;
clockRanges->doubleScanAllowed = TRUE;
#ifdef USEMGAHAL
MGA_HAL(clockRanges->interlaceAllowed = FALSE);
MGA_HAL(clockRanges->doubleScanAllowed = FALSE);
#endif
if (pMga->SecondCrtc == TRUE)
clockRanges->interlaceAllowed = FALSE;
clockRanges->ClockMulFactor = 1;
clockRanges->ClockDivFactor = 1;
if (pMga->Dac.SetMemClk) {
if (pMga->MemClk == 0) {
pMga->MemClk = pMga->Dac.MemoryClock;
from = pMga->Dac.MemClkFrom;
} else
from = X_CONFIG;
xf86DrvMsg(pScrn->scrnIndex, from, "MCLK used is %.1f MHz\n",
pMga->MemClk / 1000.0);
}
{
int Pitches1[] =
{640, 768, 800, 960, 1024, 1152, 1280, 1600, 1920, 2048, 0};
int Pitches2[] =
{512, 640, 768, 800, 832, 960, 1024, 1152, 1280, 1600, 1664,
1920, 2048, 0};
int *linePitches = NULL;
int minPitch = 256;
int maxPitch = 2048;
switch(pMga->Chipset) {
case PCI_CHIP_MGA2064:
if (!pMga->NoAccel) {
linePitches = xalloc(sizeof(Pitches1));
memcpy(linePitches, Pitches1, sizeof(Pitches1));
minPitch = maxPitch = 0;
}
break;
case PCI_CHIP_MGA2164:
case PCI_CHIP_MGA2164_AGP:
case PCI_CHIP_MGA1064:
if (!pMga->NoAccel) {
linePitches = xalloc(sizeof(Pitches2));
memcpy(linePitches, Pitches2, sizeof(Pitches2));
minPitch = maxPitch = 0;
}
break;
case PCI_CHIP_MGAG100:
case PCI_CHIP_MGAG100_PCI:
maxPitch = 2048;
break;
case PCI_CHIP_MGAG200:
case PCI_CHIP_MGAG200_PCI:
case PCI_CHIP_MGAG400:
case PCI_CHIP_MGAG550:
maxPitch = 4096;
break;
}
i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
pScrn->display->modes, clockRanges,
linePitches, minPitch, maxPitch,
pMga->Roundings[(pScrn->bitsPerPixel >> 3) - 1] *
pScrn->bitsPerPixel, 128, 2048,
pScrn->display->virtualX,
pScrn->display->virtualY,
pMga->FbMapSize,
LOOKUP_BEST_REFRESH);
if (linePitches)
xfree(linePitches);
}
if (i < 1 && pMga->FBDev) {
fbdevHWUseBuildinMode(pScrn);
pScrn->displayWidth = pScrn->virtualX;
i = 1;
}
if (i == -1) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Validate Modes Failed\n");
MGAFreeRec(pScrn);
return FALSE;
}
xf86PruneDriverModes(pScrn);
if (i == 0 || pScrn->modes == NULL) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
MGAFreeRec(pScrn);
return FALSE;
}
#ifdef USEMGAHAL
MGA_HAL(
if(pMga->SecondCrtc == FALSE) {
pMga->pBoard = xalloc(sizeof(CLIENTDATA) + MGAGetBOARDHANDLESize());
pMga->pClientStruct = xalloc(sizeof(CLIENTDATA));
pMga->pClientStruct->pMga = (MGAPtr) pMga;
MGAMapMem(pScrn);
{
CARD32 opmode;
opmode = INREG(MGAREG_OPMODE);
OUTREG(MGAREG_OPMODE, MGAOPM_DMA_BLIT | opmode);
}
MiscCtlReg = inMGAdac(MGA1064_MISC_CTL);
MGAOpenLibrary(pMga->pBoard,pMga->pClientStruct,sizeof(CLIENTDATA));
outMGAdac(MGA1064_MISC_CTL,MiscCtlReg);
MGAUnmapMem(pScrn);
pMga->pMgaHwInfo = xalloc(sizeof(MGAHWINFO));
MGAGetHardwareInfo(pMga->pBoard,pMga->pMgaHwInfo);
if (pMga->DualHeadEnabled) {
pMgaEnt->pClientStruct = pMga->pClientStruct;
pMgaEnt->pBoard = pMga->pBoard;
pMgaEnt->pMgaHwInfo = pMga->pMgaHwInfo;
}
} else {
pMga->pBoard = pMgaEnt->pBoard;
pMga->pClientStruct = pMgaEnt->pClientStruct;
pMga->pMgaHwInfo = pMgaEnt->pMgaHwInfo;
}
MGAFillModeInfoStruct(pScrn,NULL);
pMga->pMgaModeInfo->ulDispWidth = pScrn->virtualX;
pMga->pMgaModeInfo->ulDispHeight = pScrn->virtualY;
if (ISDIGITAL1(pMga))
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Digital screen detected on first head.\n");
if (ISTV1(pMga))
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"TV detected on first head.\n");
if (ISDIGITAL2(pMga))
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Digital screen detected on second head.\n");
if (ISTV2(pMga))
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"TV detected on second head.\n");
if((status = MGAValidateMode(pMga->pBoard,pMga->pMgaModeInfo)) != 0) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"MGAValidateMode from HALlib found the mode to be invalid.\n"
"\tError: 0x%lx\n", status);
return FALSE;
}
pScrn->displayWidth = pMga->pMgaModeInfo->ulFBPitch;
);
#endif
if (pMga->HasSDRAM) { }
else if ((pMga->PciInfo->subsysCard == PCI_CARD_MILL_G200_SD) ||
(pMga->PciInfo->subsysCard == PCI_CARD_MARV_G200_SD) ||
(pMga->PciInfo->subsysCard == PCI_CARD_MYST_G200_SD) ||
(pMga->PciInfo->subsysCard == PCI_CARD_PROD_G100_SD)) {
pMga->HasSDRAM = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Has SDRAM\n");
}
#ifdef USEMGAHAL
else if ((pMga->softbooted || pMga->Primary ) &&
#else
else if ((pMga->softbooted || pMga->Primary) &&
#endif
(pMga->Chipset != PCI_CHIP_MGA2064) &&
(pMga->Chipset != PCI_CHIP_MGA2164) &&
(pMga->Chipset != PCI_CHIP_MGA2164_AGP)) {
CARD32 option_reg = pciReadLong(pMga->PciTag, PCI_OPTION_REG);
if(!(option_reg & (1 << 14))) {
pMga->HasSDRAM = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Has SDRAM\n");
}
}
#ifdef USEMGAHAL
MGA_HAL(xf86SetCrtcForModes(pScrn, 0));
#endif
MGA_NOT_HAL(xf86SetCrtcForModes(pScrn, INTERLACE_HALVE_V));
pScrn->currentMode = pScrn->modes;
xf86PrintModes(pScrn);
xf86SetDpi(pScrn, 0, 0);
pMga->YDstOrg = 0;
if (((pMga->Chipset == PCI_CHIP_MGA2064) ||
(pMga->Chipset == PCI_CHIP_MGA2164) ||
(pMga->Chipset == PCI_CHIP_MGA2164_AGP)) &&
(pScrn->virtualX * pScrn->virtualY * bytesPerPixel > 4*1024*1024))
{
int offset, offset_modulo, ydstorg_modulo;
offset = (4*1024*1024) % (pScrn->displayWidth * bytesPerPixel);
offset_modulo = 4;
ydstorg_modulo = 64;
if (pScrn->bitsPerPixel == 24)
offset_modulo *= 3;
if (pMga->Interleave)
{
offset_modulo <<= 1;
ydstorg_modulo <<= 1;
}
pMga->YDstOrg = offset / bytesPerPixel;
if (bytesPerPixel < 4) {
while ((offset % offset_modulo) != 0 ||
(pMga->YDstOrg % ydstorg_modulo) != 0) {
offset++;
pMga->YDstOrg = offset / bytesPerPixel;
}
}
}
xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "YDstOrg is set to %d\n",
pMga->YDstOrg);
if(pMga->DualHeadEnabled) {
if(pMga->SecondCrtc == FALSE) {
pMga->FbUsableSize = pMgaEnt->masterFbMapSize;
if( pMga->HWCursor && pMga->Dac.CursorOffscreenMemSize ) {
if( pScrn->virtualY * pScrn->displayWidth *
pScrn->bitsPerPixel / 8 <=
pMga->FbUsableSize - pMga->Dac.CursorOffscreenMemSize ) {
pMga->FbUsableSize -= pMga->Dac.CursorOffscreenMemSize;
pMga->FbCursorOffset =
pMgaEnt->masterFbMapSize -
pMga->Dac.CursorOffscreenMemSize;
} else {
pMga->HWCursor = FALSE;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Too little offscreen memory for HW cursor; "
"using SW cursor\n");
}
}
} else {
pMga->FbUsableSize = pMgaEnt->slaveFbMapSize;
pMga->HWCursor = FALSE;
}
} else {
pMga->FbUsableSize = pMga->FbMapSize - pMga->YDstOrg * bytesPerPixel;
if( pMga->HWCursor && pMga->Dac.CursorOffscreenMemSize ) {
if( pScrn->virtualY * pScrn->displayWidth *
pScrn->bitsPerPixel / 8 <=
pMga->FbUsableSize - pMga->Dac.CursorOffscreenMemSize ) {
pMga->FbUsableSize -= pMga->Dac.CursorOffscreenMemSize;
pMga->FbCursorOffset =
pMga->FbMapSize - pMga->Dac.CursorOffscreenMemSize;
} else {
pMga->HWCursor = FALSE;
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Too little offscreen memory for HW cursor; "
"using SW cursor\n");
}
}
}
if (pMga->Overlay8Plus24) {
if (!xf86LoadSubModule(pScrn, "xf8_32bpp")) {
MGAFreeRec(pScrn);
return FALSE;
}
xf86LoaderReqSymLists(xf8_32bppSymbols, NULL);
} else {
if (!xf86LoadSubModule(pScrn, "fb")) {
MGAFreeRec(pScrn);
return FALSE;
}
xf86LoaderReqSymLists(fbSymbols, NULL);
}
if (!pMga->NoAccel) {
if (!xf86LoadSubModule(pScrn, "xaa")) {
MGAFreeRec(pScrn);
return FALSE;
}
xf86LoaderReqSymLists(xaaSymbols, NULL);
}
if (pMga->HWCursor) {
if (!xf86LoadSubModule(pScrn, "ramdac")) {
MGAFreeRec(pScrn);
return FALSE;
}
xf86LoaderReqSymLists(ramdacSymbols, NULL);
}
if (pMga->ShadowFB) {
if (!xf86LoadSubModule(pScrn, "shadowfb")) {
MGAFreeRec(pScrn);
return FALSE;
}
xf86LoaderReqSymLists(shadowSymbols, NULL);
}
#ifdef XF86DRI
if (xf86ReturnOptValBool(pMga->Options, OPTION_DRI, FALSE)) {
if (xf86LoadSubModule(pScrn, "dri")) {
xf86LoaderReqSymLists(driSymbols, drmSymbols, NULL);
}
}
#endif
pMga->CurrentLayout.bitsPerPixel = pScrn->bitsPerPixel;
pMga->CurrentLayout.depth = pScrn->depth;
pMga->CurrentLayout.displayWidth = pScrn->displayWidth;
pMga->CurrentLayout.weight.red = pScrn->weight.red;
pMga->CurrentLayout.weight.green = pScrn->weight.green;
pMga->CurrentLayout.weight.blue = pScrn->weight.blue;
pMga->CurrentLayout.Overlay8Plus24 = pMga->Overlay8Plus24;
pMga->CurrentLayout.mode = pScrn->currentMode;
if(pMga->MergedFB) {
MGAPreInitMergedFB(pScrn,flags);
};
#ifdef USEMGAHAL
MGA_HAL(
if(pMga->DualHeadEnabled) {
if(pMgaEnt->refCount == 2) {
MGACloseLibrary(pMga->pBoard);
if (pMga->pBoard)
xfree(pMga->pBoard);
if (pMga->pClientStruct)
xfree(pMga->pClientStruct);
if (pMga->pMgaModeInfo)
xfree(pMga->pMgaModeInfo);
if (pMga->pMgaHwInfo)
xfree(pMga->pMgaHwInfo);
pMgaEnt->refCount = 0;
}
} else {
MGACloseLibrary(pMga->pBoard);
if (pMga->pBoard)
xfree(pMga->pBoard);
if (pMga->pClientStruct)
xfree(pMga->pClientStruct);
if (pMga->pMgaModeInfo)
xfree(pMga->pMgaModeInfo);
if (pMga->pMgaHwInfo)
xfree(pMga->pMgaHwInfo);
}
);
#endif
xf86SetPrimInitDone(pScrn->entityList[0]);
return TRUE;
}
static Bool
MGAMapMem(ScrnInfoPtr pScrn)
{
MGAPtr pMga;
pMga = MGAPTR(pScrn);
pMga->IOBase = xf86MapPciMem(pScrn->scrnIndex,
VIDMEM_MMIO | VIDMEM_READSIDEEFFECT,
pMga->PciTag, pMga->IOAddress, 0x4000);
if (pMga->IOBase == NULL)
return FALSE;
pMga->FbBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_FRAMEBUFFER,
pMga->PciTag, pMga->FbAddress,
pMga->FbMapSize);
if (pMga->FbBase == NULL)
return FALSE;
pMga->FbStart = pMga->FbBase + pMga->YDstOrg * (pScrn->bitsPerPixel / 8);
if (pMga->ILOADAddress) {
pMga->ILOADBase = xf86MapPciMem(pScrn->scrnIndex,
VIDMEM_MMIO | VIDMEM_MMIO_32BIT |
VIDMEM_READSIDEEFFECT,
pMga->PciTag, pMga->ILOADAddress, 0x800000);
} else
pMga->ILOADBase = NULL;
return TRUE;
}
static Bool
MGAMapMemFBDev(ScrnInfoPtr pScrn)
{
MGAPtr pMga;
pMga = MGAPTR(pScrn);
pMga->FbBase = fbdevHWMapVidmem(pScrn);
if (pMga->FbBase == NULL)
return FALSE;
pMga->IOBase = fbdevHWMapMMIO(pScrn);
if (pMga->IOBase == NULL)
return FALSE;
pMga->FbStart = pMga->FbBase + pMga->YDstOrg * (pScrn->bitsPerPixel / 8);
#if 1
if(pMga->ILOADAddress)
pMga->ILOADBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_MMIO,
pMga->PciTag, pMga->ILOADAddress, 0x800000);
else pMga->ILOADBase = NULL;
#endif
return TRUE;
}
static Bool
MGAUnmapMem(ScrnInfoPtr pScrn)
{
MGAPtr pMga;
pMga = MGAPTR(pScrn);
xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pMga->IOBase, 0x4000);
pMga->IOBase = NULL;
xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pMga->FbBase, pMga->FbMapSize);
pMga->FbBase = NULL;
pMga->FbStart = NULL;
if(pMga->ILOADBase)
xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pMga->ILOADBase, 0x800000);
pMga->ILOADBase = NULL;
return TRUE;
}
static Bool
MGAUnmapMemFBDev(ScrnInfoPtr pScrn)
{
MGAPtr pMga;
pMga = MGAPTR(pScrn);
fbdevHWUnmapVidmem(pScrn);
pMga->FbBase = NULL;
pMga->FbStart = NULL;
fbdevHWUnmapMMIO(pScrn);
pMga->IOBase = NULL;
return TRUE;
}
static void
MGASave(ScrnInfoPtr pScrn)
{
vgaHWPtr hwp = VGAHWPTR(pScrn);
vgaRegPtr vgaReg = &hwp->SavedReg;
MGAPtr pMga = MGAPTR(pScrn);
MGARegPtr mgaReg = &pMga->SavedReg;
if(pMga->SecondCrtc == TRUE) return;
#ifdef USEMGAHAL
MGA_HAL(if (pMga->pBoard != NULL) MGASaveVgaState(pMga->pBoard));
#endif
(*pMga->Save)(pScrn, vgaReg, mgaReg, pMga->Primary);
}
#ifdef USEMGAHAL
void
MGAFillModeInfoStruct(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
const char *s;
MGAPtr pMga = MGAPTR(pScrn);
Bool digital1 = FALSE;
Bool digital2 = FALSE;
Bool tv1 = FALSE;
Bool tv2 = FALSE;
Bool swap_head
= xf86ReturnOptValBool(pMga->Options, OPTION_SWAPPED_HEAD, FALSE);
if(pMga->MergedFB && mode && mode->Private && (mode->PrivSize == 0)) {
mode = pMga->SecondCrtc ?
((MergedDisplayModePtr)mode->Private)->Monitor2
: ((MergedDisplayModePtr)mode->Private)->Monitor1;
}
if (pMga->pMgaHwInfo)
{
digital1 = ISDIGITAL1(pMga);
digital2 = ISDIGITAL2(pMga);
tv1 = ISTV1(pMga);
tv2 = ISTV2(pMga);
}
pMga->pMgaModeInfo = xalloc(sizeof(MGAMODEINFO));
pMga->pMgaModeInfo->flOutput = 0;
pMga->pMgaModeInfo->ulDeskWidth = pScrn->virtualX;
pMga->pMgaModeInfo->ulDeskHeight = pScrn->virtualY;
pMga->pMgaModeInfo->ulFBPitch = 0;
pMga->pMgaModeInfo->ulBpp = pScrn->bitsPerPixel;
pMga->pMgaModeInfo->ulZoom = 1;
pMga->pMgaModeInfo->flSignalMode = 0x10;
if ((s = xf86GetOptValString(pMga->Options, OPTION_TVSTANDARD))) {
if (!xf86NameCmp(s, "PAL")) {
pMga->pMgaModeInfo->flSignalMode = 0x00;
pMga->pMgaModeInfo->ulRefreshRate = 50;
pMga->pMgaModeInfo->ulTVStandard = TV_PAL;
} else {
pMga->pMgaModeInfo->ulRefreshRate = 60;
pMga->pMgaModeInfo->ulTVStandard = TV_NTSC;
}
} else {
pMga->pMgaModeInfo->ulRefreshRate = 0;
pMga->pMgaModeInfo->ulTVStandard = TV_NTSC;
}
if ((s = xf86GetOptValString(pMga->Options, OPTION_CABLETYPE))) {
if (!xf86NameCmp(s, "SCART_RGB")) {
pMga->pMgaModeInfo->ulCableType = TV_SCART_RGB;
} else if (!xf86NameCmp(s, "SCART_COMPOSITE")) {
pMga->pMgaModeInfo->ulCableType = TV_SCART_COMPOSITE;
} else if (!xf86NameCmp(s, "SCART_TYPE2")) {
pMga->pMgaModeInfo->ulCableType = TV_SCART_TYPE2;
} else {
pMga->pMgaModeInfo->ulCableType = TV_YC_COMPOSITE;
}
} else {
pMga->pMgaModeInfo->ulCableType = TV_YC_COMPOSITE;
}
if(mode) {
pMga->pMgaModeInfo->ulHorizRate = 0;
pMga->pMgaModeInfo->ulDispWidth = mode->HDisplay;
pMga->pMgaModeInfo->ulDispHeight = mode->VDisplay;
pMga->pMgaModeInfo->ulPixClock = mode->Clock;
pMga->pMgaModeInfo->ulHFPorch = mode->HSyncStart - mode->HDisplay;
pMga->pMgaModeInfo->ulHSync = mode->HSyncEnd - mode->HSyncStart;
pMga->pMgaModeInfo->ulHBPorch = mode->HTotal - mode->HSyncEnd;
pMga->pMgaModeInfo->ulVFPorch = mode->VSyncStart - mode->VDisplay;
pMga->pMgaModeInfo->ulVSync = mode->VSyncEnd - mode->VSyncStart;
pMga->pMgaModeInfo->ulVBPorch = mode->VTotal - mode->VSyncEnd;
}
pMga->pMgaModeInfo->ulDstOrg = pMga->DstOrg / (pScrn->bitsPerPixel / 8);
pMga->pMgaModeInfo->ulDisplayOrg = pMga->DstOrg / (pScrn->bitsPerPixel / 8);
pMga->pMgaModeInfo->ulPanXGran = 0;
pMga->pMgaModeInfo->ulPanYGran = 0;
if(pMga->SecondCrtc == TRUE) {
pMga->pMgaModeInfo->flOutput = MGAMODEINFO_SECOND_CRTC |
MGAMODEINFO_FORCE_PITCH |
MGAMODEINFO_FORCE_DISPLAYORG;
if (digital2) {
pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_DIGITAL2;
} else if (tv2) {
pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_TV;
} else {
if (!swap_head) {
pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_ANALOG2;
} else {
pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_ANALOG1;
}
}
} else {
pMga->pMgaModeInfo->flOutput = MGAMODEINFO_FORCE_PITCH;
if (digital1) {
pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_DIGITAL1;
} else if (tv1) {
pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_TV;
} else {
if (!swap_head) {
pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_ANALOG1;
} else {
pMga->pMgaModeInfo->flOutput |= MGAMODEINFO_ANALOG2;
}
}
}
pMga->pMgaModeInfo->ulFBPitch = pScrn->displayWidth;
}
#endif
static Bool
MGAModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
vgaHWPtr hwp = VGAHWPTR(pScrn);
vgaRegPtr vgaReg;
MGAPtr pMga = MGAPTR(pScrn);
MGARegPtr mgaReg;
#ifdef USEMGAHAL
ULONG status;
#endif
vgaHWUnlock(hwp);
if (!vgaHWInit(pScrn, mode))
return FALSE;
pScrn->vtSema = TRUE;
if (!(*pMga->ModeInit)(pScrn, mode))
return FALSE;
vgaHWProtect(pScrn, TRUE);
vgaReg = &hwp->ModeReg;
mgaReg = &pMga->ModeReg;
#ifdef USEMGAHAL
MGA_HAL(
MGAFillModeInfoStruct(pScrn,mode);
if ((status = MGAValidateMode(pMga->pBoard, pMga->pMgaModeInfo)) != 0) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"MGAValidateMode from HALlib found the mode to be invalid.\n"
"\tError: %lx\n", status);
return FALSE;
}
if(pMga->MergedFB) {
MGAFillModeInfoStruct(pMga->pScrn2,mode);
if ((status = MGAValidateVideoParameters(pMga->pBoard, MGAPTR(pMga->pScrn2)->pMgaModeInfo))
!= 0) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"MGAValidateVideoParameters from HALlib found the mode to be invalid.\n\tError: %lx\n", status);
return FALSE;
}
}
);
#endif
#ifdef USEMGAHAL
MGA_HAL(
TmpMgaModeInfo[0] = *pMga->pMgaModeInfo;
if(pMga->SecondCrtc == TRUE)
pMgaModeInfo[1] = pMga->pMgaModeInfo;
else
pMgaModeInfo[0] = pMga->pMgaModeInfo;
TmpMgaModeInfo[0].ulDispWidth = 0;
if(!pMga->MergedFB)
MGAFillDisplayModeStruct(mode, pMga->pMgaModeInfo);
);
#endif
#ifdef XF86DRI
if (pMga->directRenderingEnabled) {
DRILock(screenInfo.screens[pScrn->scrnIndex], 0);
}
#endif
#ifdef USEMGAHAL
MGA_HAL(
if(MGASetMode(pMga->pBoard,pMga->pMgaModeInfo) != 0) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"MGASetMode returned an error."
" Make sure to validate the mode before.\n");
return FALSE;
}
if(pMga->MergedFB
&& MGASetMode(pMga->pBoard,MGAPTR(pMga->pScrn2)->pMgaModeInfo) != 0) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"MGASetMode returned an error."
" Make sure to validate the mode before.\n");
}
);
MGA_HAL(
switch (pMga->Chipset) {
case PCI_CHIP_MGA1064:
case PCI_CHIP_MGAG100:
case PCI_CHIP_MGAG100_PCI:
case PCI_CHIP_MGAG200:
case PCI_CHIP_MGAG200_PCI:
case PCI_CHIP_MGAG400:
case PCI_CHIP_MGAG550:
if(pMga->SecondCrtc == FALSE && pMga->HWCursor == TRUE) {
outMGAdac(MGA1064_CURSOR_BASE_ADR_LOW,
pMga->FbCursorOffset >> 10);
outMGAdac(MGA1064_CURSOR_BASE_ADR_HI,
pMga->FbCursorOffset >> 18);
outMGAdac(MGA1064_CURSOR_CTL, 0x00);
}
if (pMga->Overlay8Plus24 == TRUE) {
outMGAdac(MGA1064_MUL_CTL, MGA1064_MUL_CTL_32bits);
outMGAdac(MGA1064_COL_KEY_MSK_LSB,0xFF);
outMGAdac(MGA1064_COL_KEY_LSB,pMga->colorKey);
outMGAdac(MGA1064_COL_KEY_MSK_MSB,0xFF);
outMGAdac(MGA1064_COL_KEY_MSB,0xFF);
}
break;
default:
break;
}
);
#endif
MGA_NOT_HAL((*pMga->Restore)(pScrn, vgaReg, mgaReg, FALSE));
MGAStormSync(pScrn);
MGAStormEngineInit(pScrn);
vgaHWProtect(pScrn, FALSE);
if (xf86IsPc98()) {
if (pMga->Chipset == PCI_CHIP_MGA2064)
outb(0xfac, 0x01);
else
outb(0xfac, 0x02);
}
pMga->CurrentLayout.mode = mode;
if(pMga->MergedFB && mode->Private && (mode->PrivSize == 0)) {
pMga->M1currentMode = (DisplayModePtr)mode->Private;
}
#ifdef XF86DRI
if (pMga->directRenderingEnabled)
DRIUnlock(screenInfo.screens[pScrn->scrnIndex]);
#endif
#ifdef DEBUG
MGAG450PrintPLL(pScrn);
#endif
return TRUE;
}
static
void MGARestoreSecondCrtc(ScrnInfoPtr pScrn)
{
MGAPtr pMga = MGAPTR(pScrn);
if (MGAISGx50(pMga)) {
if (pMga->SecondOutput
&& (xf86IsEntityShared(pScrn->entityList[0]) || pMga->SecondCrtc)
&& !pMga->MergedFB) {
CARD8 ucXDispCtrl = inMGAdac(MGA1064_DISP_CTL);
ucXDispCtrl &= ~0x0c;
ucXDispCtrl |= 0x04;
outMGAdac(MGA1064_DISP_CTL, ucXDispCtrl);
} else {
CARD8 ucXDispCtrl = inMGAdac(MGA1064_DISP_CTL);
CARD32 ulC2CTL = INREG(MGAREG_C2CTL);
ucXDispCtrl &= ~0x0c;
ucXDispCtrl |= 0x5;
ulC2CTL &= ~0x00100000;
outMGAdac(MGA1064_DISP_CTL, ucXDispCtrl);
OUTREG(MGAREG_C2CTL, ulC2CTL);
}
} else {
CARD32 ulC2CTL = INREG(MGAREG_C2CTL);
ulC2CTL &= ~0x1;
OUTREG(MGAREG_C2CTL, ulC2CTL);
}
return;
}
static void
MGARestore(ScrnInfoPtr pScrn)
{
vgaHWPtr hwp = VGAHWPTR(pScrn);
vgaRegPtr vgaReg = &hwp->SavedReg;
MGAPtr pMga = MGAPTR(pScrn);
MGARegPtr mgaReg = &pMga->SavedReg;
if (pScrn->pScreen != NULL)
MGAStormSync(pScrn);
if((!xf86IsEntityShared(pScrn->entityList[0]) && !pMga->SecondCrtc)
|| pMga->SecondCrtc || pMga->MergedFB) {
MGARestoreSecondCrtc(pScrn);
if(pMga->SecondCrtc) return;
}
vgaHWProtect(pScrn, TRUE);
if (pMga->Primary) {
#ifdef USEMGAHAL
MGA_HAL(
if(pMga->pBoard != NULL) {
MGASetVgaMode(pMga->pBoard);
MGARestoreVgaState(pMga->pBoard);
}
);
#endif
(*pMga->Restore)(pScrn, vgaReg, mgaReg, TRUE);
} else {
vgaHWRestore(pScrn, vgaReg, VGA_SR_MODE);
}
vgaHWProtect(pScrn, FALSE);
}
static void
MGACrtc2FillStrip(ScrnInfoPtr pScrn)
{
MGAPtr pMga = MGAPTR(pScrn);
if (pMga->NoAccel) {
bzero(pMga->FbStart,
(pScrn->bitsPerPixel >> 3) * pScrn->displayWidth * pScrn->virtualY);
} else {
xf86SetLastScrnFlag(pScrn->entityList[0], pScrn->scrnIndex);
pMga->RestoreAccelState(pScrn);
pMga->SetupForSolidFill(pScrn, 0, GXcopy, 0xFFFFFFFF);
pMga->SubsequentSolidFillRect(pScrn, pScrn->virtualX, 0,
pScrn->displayWidth - pScrn->virtualX,
pScrn->virtualY);
MGAStormSync(pScrn);
}
}
static Bool
MGAScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
{
ScrnInfoPtr pScrn;
vgaHWPtr hwp;
MGAPtr pMga;
MGARamdacPtr MGAdac;
int ret;
VisualPtr visual;
unsigned char *FBStart;
int width, height, displayWidth;
MGAEntPtr pMgaEnt = NULL;
int f;
#ifdef XF86DRI
MessageType driFrom = X_DEFAULT;
#endif
pScrn = xf86Screens[pScreen->myNum];
hwp = VGAHWPTR(pScrn);
pMga = MGAPTR(pScrn);
MGAdac = &pMga->Dac;
if (pMga->FBDev) {
if (!MGAMapMemFBDev(pScrn))
return FALSE;
} else {
if (!MGAMapMem(pScrn))
return FALSE;
}
if ((pMga->Chipset == PCI_CHIP_MGAG100)
|| (pMga->Chipset == PCI_CHIP_MGAG100_PCI))
MGAG100BlackMagic(pScrn);
if (pMga->DualHeadEnabled) {
DevUnion *pPriv;
pPriv = xf86GetEntityPrivate(pScrn->entityList[0], MGAEntityIndex);
pMgaEnt = pPriv->ptr;
pMgaEnt->refCount++;
#ifdef USEMGAHAL
MGA_HAL(
if(pMgaEnt->refCount == 1) {
CARD8 MiscCtlReg;
pMga->pBoard = xalloc(sizeof(CLIENTDATA) + MGAGetBOARDHANDLESize());
pMga->pClientStruct = xalloc(sizeof(CLIENTDATA));
pMga->pClientStruct->pMga = (MGAPtr) pMga;
MiscCtlReg = inMGAdac(MGA1064_MISC_CTL);
MGAOpenLibrary(pMga->pBoard,pMga->pClientStruct,sizeof(CLIENTDATA));
outMGAdac(MGA1064_MISC_CTL,MiscCtlReg);
pMga->pMgaHwInfo = xalloc(sizeof(MGAHWINFO));
MGAGetHardwareInfo(pMga->pBoard,pMga->pMgaHwInfo);
if (pMga->pMgaHwInfo->ulCapsSecondOutput & MGAHWINFOCAPS_OUTPUT_TV) {
xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "TV detected\n");
}
if (pMga->pMgaHwInfo->ulCapsFirstOutput &
MGAHWINFOCAPS_OUTPUT_DIGITAL) {
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Digital Screen detected\n");
}
if (pMga->pMgaHwInfo->ulCapsSecondOutput &
MGAHWINFOCAPS_OUTPUT_DIGITAL) {
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Digital Screen detected\n");
}
pMgaEnt->pClientStruct = pMga->pClientStruct;
pMgaEnt->pBoard = pMga->pBoard;
pMgaEnt->pMgaHwInfo = pMga->pMgaHwInfo;
} else {
pMga->pClientStruct = pMgaEnt->pClientStruct;
pMga->pBoard = pMgaEnt->pBoard;
pMga->pMgaHwInfo = pMgaEnt->pMgaHwInfo;
}
);
#endif
} else {
#ifdef USEMGAHAL
CARD8 MiscCtlReg;
MGA_HAL(
pMga->pBoard = xalloc(sizeof(CLIENTDATA) + MGAGetBOARDHANDLESize());
pMga->pClientStruct = xalloc(sizeof(CLIENTDATA));
pMga->pClientStruct->pMga = (MGAPtr) pMga;
MiscCtlReg = inMGAdac(MGA1064_MISC_CTL);
MGAOpenLibrary(pMga->pBoard,pMga->pClientStruct,sizeof(CLIENTDATA));
outMGAdac(MGA1064_MISC_CTL,MiscCtlReg);
pMga->pMgaHwInfo = xalloc(sizeof(MGAHWINFO));
MGAGetHardwareInfo(pMga->pBoard,pMga->pMgaHwInfo);
);
#endif
}
#ifdef USEMGAHAL
MGA_HAL(
if (!pMga->Primary && !pMga->FBDev &&
(pMga->PciInfo->subsysCard == PCI_CARD_MILL_G200_SG) ) {
OUTREG(MGAREG_Reset, 1);
usleep(200);
OUTREG(MGAREG_Reset, 0);
}
);
#endif
vgaHWSetMmioFuncs(hwp, pMga->IOBase, PORT_OFFSET);
vgaHWGetIOBase(hwp);
if (pMga->Primary && !pMga->FBDev) {
hwp->MapSize = 0x10000;
if (!vgaHWMapMem(pScrn))
return FALSE;
}
if (pMga->FBDev) {
fbdevHWSave(pScrn);
pciSetBitsLong(pMga->PciTag, PCI_OPTION_REG, 0x100, 0x000);
if (!fbdevHWModeInit(pScrn, pScrn->currentMode))
return FALSE;
if(pMga->SecondCrtc == FALSE && pMga->HWCursor == TRUE) {
switch (pMga->Chipset) {
case PCI_CHIP_MGA1064:
case PCI_CHIP_MGAG100:
case PCI_CHIP_MGAG100_PCI:
case PCI_CHIP_MGAG200:
case PCI_CHIP_MGAG200_PCI:
case PCI_CHIP_MGAG400:
case PCI_CHIP_MGAG550:
outMGAdac(MGA1064_CURSOR_BASE_ADR_LOW, pMga->FbCursorOffset >> 10);
outMGAdac(MGA1064_CURSOR_BASE_ADR_HI, pMga->FbCursorOffset >> 18);
break;
default:
break;
}
}
MGAStormEngineInit(pScrn);
} else {
MGASave(pScrn);
if (!MGAModeInit(pScrn, pScrn->currentMode))
return FALSE;
}
if (pMga->SecondCrtc == TRUE && !pMga->MergedFB) {
MGASaveScreenCrtc2(pScreen, SCREEN_SAVER_ON);
}
if (pMga->SecondCrtc == FALSE && !pMga->MergedFB) {
MGASaveScreen(pScreen, SCREEN_SAVER_ON);
}
if( pMga->MergedFB ) {
MGASaveScreenMerged( pScreen, SCREEN_SAVER_ON );
}
pScrn->AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
miClearVisualTypes();
if(pMga->Overlay8Plus24 && (pScrn->bitsPerPixel == 32)) {
if (!miSetVisualTypes(8, PseudoColorMask | GrayScaleMask,
pScrn->rgbBits, PseudoColor))
return FALSE;
if (!miSetVisualTypes(24, TrueColorMask, pScrn->rgbBits, TrueColor))
return FALSE;
} else if (pMga->SecondCrtc) {
if (!miSetVisualTypes(pScrn->depth, TrueColorMask, pScrn->rgbBits,
TrueColor))
return FALSE;
if (!miSetPixmapDepths ())
return FALSE;
} else {
if (!xf86SetDefaultVisual(pScrn, -1))
return FALSE;
if (!miSetVisualTypes(pScrn->depth,
miGetDefaultVisualMask(pScrn->depth),
pScrn->rgbBits, pScrn->defaultVisual))
return FALSE;
if (!miSetPixmapDepths ())
return FALSE;
}
width = pScrn->virtualX;
height = pScrn->virtualY;
displayWidth = pScrn->displayWidth;
if(pMga->Rotate) {
height = pScrn->virtualX;
width = pScrn->virtualY;
}
if(pMga->ShadowFB) {
pMga->ShadowPitch = BitmapBytePad(pScrn->bitsPerPixel * width);
pMga->ShadowPtr = xalloc(pMga->ShadowPitch * height);
displayWidth = pMga->ShadowPitch / (pScrn->bitsPerPixel >> 3);
FBStart = pMga->ShadowPtr;
} else {
pMga->ShadowPtr = NULL;
FBStart = pMga->FbStart;
}
#ifdef XF86DRI
if (!xf86ReturnOptValBool(pMga->Options, OPTION_DRI, TRUE)) {
driFrom = X_CONFIG;
} else if ( pMga->NoAccel ) {
xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
"Acceleration disabled, not initializing the DRI\n" );
pMga->directRenderingEnabled = FALSE;
driFrom = X_CONFIG;
}
else if ( pMga->TexturedVideo == TRUE ) {
xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
"Textured video enabled, not initializing the DRI\n" );
pMga->directRenderingEnabled = FALSE;
driFrom = X_CONFIG;
}
else if (pMga->SecondCrtc == TRUE) {
xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
"Not initializing the DRI on the second head\n" );
pMga->directRenderingEnabled = FALSE;
}
else if ((pMga->FbMapSize /
(width * (pScrn->bitsPerPixel >> 3))) <= height * 3) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Static buffer allocation failed, not initializing the DRI\n");
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Need at least %d kB video memory at this resolution, bit depth\n",
(3 * displayWidth * height * (pScrn->bitsPerPixel >> 3)) / 1024 );
pMga->directRenderingEnabled = FALSE;
driFrom = X_PROBED;
}
else {
pMga->directRenderingEnabled = MGADRIScreenInit(pScreen);
}
#endif
if (pMga->Overlay8Plus24) {
ret = cfb8_32ScreenInit(pScreen, FBStart,
width, height,
pScrn->xDpi, pScrn->yDpi,
displayWidth);
} else {
ret = fbScreenInit(pScreen, FBStart, width, height,
pScrn->xDpi, pScrn->yDpi,
displayWidth, pScrn->bitsPerPixel);
}
if (!ret)
return FALSE;
if (pScrn->bitsPerPixel > 8) {
visual = pScreen->visuals + pScreen->numVisuals;
while (--visual >= pScreen->visuals) {
if ((visual->class | DynamicClass) == DirectColor) {
visual->offsetRed = pScrn->offset.red;
visual->offsetGreen = pScrn->offset.green;
visual->offsetBlue = pScrn->offset.blue;
visual->redMask = pScrn->mask.red;
visual->greenMask = pScrn->mask.green;
visual->blueMask = pScrn->mask.blue;
}
}
}
if (!pMga->Overlay8Plus24)
fbPictureInit (pScreen, 0, 0);
xf86SetBlackWhitePixels(pScreen);
pMga->BlockHandler = pScreen->BlockHandler;
pScreen->BlockHandler = MGABlockHandler;
if(!pMga->ShadowFB)
MGADGAInit(pScreen);
if (!pMga->NoAccel)
MGAStormAccelInit(pScreen);
miInitializeBackingStore(pScreen);
xf86SetBackingStore(pScreen);
xf86SetSilkenMouse(pScreen);
miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
if (pMga->HWCursor) {
if(!MGAHWCursorInit(pScreen))
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Hardware cursor initialization failed\n");
}
if(pMga->MergedFB) {
if (!pMga->PointerMoved)
pMga->PointerMoved = pScrn->PointerMoved;
pScrn->PointerMoved = MGAMergePointerMoved;
}
if (!miCreateDefColormap(pScreen))
return FALSE;
if (!pMga->SecondCrtc)
f = CMAP_PALETTED_TRUECOLOR | CMAP_RELOAD_ON_MODE_SWITCH;
else
f = CMAP_RELOAD_ON_MODE_SWITCH;
if(!xf86HandleColormaps(pScreen, 256, 8,
(pMga->FBDev ? fbdevHWLoadPalette : MGAdac->LoadPalette), NULL, f))
return FALSE;
if(pMga->Overlay8Plus24) {
if(!xf86Overlay8Plus32Init(pScreen))
return FALSE;
}
if(pMga->ShadowFB) {
RefreshAreaFuncPtr refreshArea = MGARefreshArea;
if(pMga->Rotate) {
if (!pMga->PointerMoved) {
pMga->PointerMoved = pScrn->PointerMoved;
pScrn->PointerMoved = MGAPointerMoved;
}
switch(pScrn->bitsPerPixel) {
case 8: refreshArea = MGARefreshArea8; break;
case 16: refreshArea = MGARefreshArea16; break;
case 24: refreshArea = MGARefreshArea24; break;
case 32: refreshArea = MGARefreshArea32; break;
}
}
ShadowFBInit(pScreen, refreshArea);
}
if(pMga->SecondCrtc == TRUE && !pMga->MergedFB) {
xf86DPMSInit(pScreen, MGADisplayPowerManagementSetCrtc2, 0);
}
if(pMga->SecondCrtc == FALSE && !pMga->MergedFB) {
xf86DPMSInit(pScreen, MGADisplayPowerManagementSet, 0);
}
if(pMga->MergedFB) {
xf86DPMSInit(pScreen, MGADisplayPowerManagementSetMerged, 0);
}
pScrn->memPhysBase = pMga->FbAddress;
pScrn->fbOffset = pMga->YDstOrg * (pScrn->bitsPerPixel / 8);
if(!pMga->MergedFB) {
if(pMga->SecondCrtc == TRUE) {
pScreen->SaveScreen = MGASaveScreenCrtc2;
} else {
pScreen->SaveScreen = MGASaveScreen;
}
} else {
pScreen->SaveScreen = MGASaveScreenMerged;
}
MGAInitVideo(pScreen);
#ifdef XF86DRI
if (pMga->directRenderingEnabled) {
pMga->directRenderingEnabled = MGADRIFinishScreenInit(pScreen);
}
if (pMga->directRenderingEnabled) {
xf86DrvMsg(pScrn->scrnIndex, driFrom, "Direct rendering enabled\n");
} else {
xf86DrvMsg(pScrn->scrnIndex, driFrom, "Direct rendering disabled\n");
}
if (pMga->DualHeadEnabled && pMga->SecondCrtc == FALSE)
pMgaEnt->directRenderingEnabled = pMga->directRenderingEnabled;
pMga->haveQuiescense = 1;
#endif
pMga->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = MGACloseScreen;
if (serverGeneration == 1) {
xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
}
if (!pMga->MergedFB && pMga->SecondCrtc) {
MGACrtc2FillStrip(pScrn);
}
return TRUE;
}
Bool
MGASwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
{
#ifdef USEMGAHAL
char sCmdIn[256];
char sCmdOut[256];
FILE* fdIn;
# ifdef MATROX_WRITEBACK
FILE* fdOut;
# endif
#endif
if (mode->Flags & 0x80000000) {
#ifdef USEMGAHAL
# ifdef MATROX_WRITEBACK
# define MWB(x) { x; }
# define MWB_COND(x) x
# else
# define MWB(x)
# define MWB_COND(x) 1
# endif
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
MGA_HAL(
fdIn = fopen("/tmp/mgaDriverIn", "rt");
MWB(fdOut = fopen("/tmp/mgaDriverOut", "wt"))
if(fdIn && MWB_COND(fdOut))
{
fgets(sCmdIn, 255, fdIn);
if(sCmdIn)
{
MGAExecuteEscCmd(xf86Screens[scrnIndex], sCmdIn, sCmdOut, mode);
remove("/tmp/mgaDriverIn");
fclose(fdIn);
MWB(
fputs(sCmdOut, fdOut);
fclose(fdOut);
)
mode->Flags &= 0x7FFFFFFF;
return TRUE;
}
else
{
mode->Flags &= 0x7FFFFFFF;
return FALSE;
}
}
else
{
mode->Flags &= 0x7FFFFFFF;
return FALSE;
}
)
#endif
return FALSE;
} else
return MGAModeInit(xf86Screens[scrnIndex], mode);
}
void
MGAAdjustGranularity(ScrnInfoPtr pScrn, int* x, int* y)
{
#ifdef USEMGAHAL
MGA_HAL(
MGAPtr pMga = MGAPTR(pScrn);
MGAPtr pMga2;
int xg = 1;
int yg = 1;
if(pMga->pMgaModeInfo && pMga->pMgaModeInfo->ulPanXGran && pMga->pMgaModeInfo->ulPanYGran) {
xg = pMga->pMgaModeInfo->ulPanXGran;
yg = pMga->pMgaModeInfo->ulPanYGran;
}
if(pMga->pScrn2 && (pMga2 = MGAPTR(pMga->pScrn2)) ) {
if(pMga2->pMgaModeInfo && pMga2->pMgaModeInfo->ulPanXGran && pMga2->pMgaModeInfo->ulPanYGran) {
xg = max(xg,pMga2->pMgaModeInfo->ulPanXGran);
yg = max(yg,pMga2->pMgaModeInfo->ulPanYGran);
}
}
xg=16;
*x -= *x % xg;
*y -= *y % yg;
);
#endif
}
void
MGAAdjustFrame(int scrnIndex, int x, int y, int flags)
{
ScrnInfoPtr pScrn;
int Base, tmp, count;
MGAFBLayout *pLayout;
MGAPtr pMga;
pScrn = xf86Screens[scrnIndex];
pMga = MGAPTR(pScrn);
pLayout = &pMga->CurrentLayout;
#ifdef USEMGAHAL
MGA_HAL(
pMga->HALGranularityOffX = x;
pMga->HALGranularityOffY = y;
MGAAdjustGranularity(pScrn,&x,&y);
pMga->HALGranularityOffX = pMga->HALGranularityOffX - x;
pMga->HALGranularityOffY = pMga->HALGranularityOffY - y;
HALSetDisplayStart(pMga->pBoard,x,y,0);
);
#endif
MGA_NOT_HAL(
if(pMga->ShowCache && y && pScrn->vtSema)
y += pScrn->virtualY - 1;
Base = (y * pLayout->displayWidth + x + pMga->YDstOrg) >>
(3 - pMga->BppShifts[(pLayout->bitsPerPixel >> 3) - 1]);
if (pLayout->bitsPerPixel == 24) {
if (pMga->Chipset == PCI_CHIP_MGAG400 || pMga->Chipset == PCI_CHIP_MGAG550)
Base &= ~1;
Base *= 3;
}
while (INREG8(0x1FDA) & 0x08);
while (!(INREG8(0x1FDA) & 0x08));
count = INREG(MGAREG_VCOUNT) + 2;
while(INREG(MGAREG_VCOUNT) < count);
OUTREG16(MGAREG_CRTC_INDEX, (Base & 0x00FF00) | 0x0C);
OUTREG16(MGAREG_CRTC_INDEX, ((Base & 0x0000FF) << 8) | 0x0D);
OUTREG8(MGAREG_CRTCEXT_INDEX, 0x00);
tmp = INREG8(MGAREG_CRTCEXT_DATA);
OUTREG8(MGAREG_CRTCEXT_DATA, (tmp & 0xF0) | ((Base & 0x0F0000) >> 16));
);
}
#define C2STARTADD0 0x3C28
void
MGAAdjustFrameCrtc2(int scrnIndex, int x, int y, int flags)
{
ScrnInfoPtr pScrn;
int Base;
MGAFBLayout *pLayout;
MGAPtr pMga;
pScrn = xf86Screens[scrnIndex];
pMga = MGAPTR(pScrn);
pLayout = &pMga->CurrentLayout;
#ifdef USEMGAHAL
MGA_HAL(
MGAAdjustGranularity(pScrn,&x,&y);
HALSetDisplayStart(pMga->pBoard,x,y,1);
);
#endif
MGA_NOT_HAL(
if(pMga->ShowCache && y && pScrn->vtSema)
y += pScrn->virtualY - 1;
Base = (y * pLayout->displayWidth + x) * pLayout->bitsPerPixel >> 3;
Base += pMga->DstOrg;
Base &= 0x01ffffc0;
OUTREG(C2STARTADD0, Base);
);
}
static Bool
MGAEnterVT(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
MGAPtr pMga;
pMga = MGAPTR(pScrn);
#ifdef XF86DRI
if (pMga->directRenderingEnabled) {
if (pMga->irq) {
OUTREG(MGAREG_IEN, pMga->reg_ien);
}
DRIUnlock(screenInfo.screens[scrnIndex]);
}
#endif
if (!MGAModeInit(pScrn, pScrn->currentMode))
return FALSE;
pScrn->AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
if (pMga->SecondCrtc) {
MGACrtc2FillStrip(pScrn);
}
return TRUE;
}
static Bool
MGAEnterVTFBDev(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
#ifdef XF86DRI
ScreenPtr pScreen;
MGAPtr pMga;
pMga = MGAPTR(pScrn);
if (pMga->directRenderingEnabled) {
pScreen = screenInfo.screens[scrnIndex];
DRIUnlock(pScreen);
}
#endif
fbdevHWEnterVT(scrnIndex,flags);
MGAStormEngineInit(pScrn);
return TRUE;
}
#define RESTORE_TEXTMODE_ON_DVI(x) \
if (MGAISGx50(x) && \
(ISDIGITAL1(x) || ISDIGITAL2(x))) { \
\
outMGAdac(MGA1064_DVI_PIPE_CTL, 0x0); \
\
outMGAdac(MGA1064_PAN_CTL, 0x7); \
}
static void
MGALeaveVT(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
vgaHWPtr hwp = VGAHWPTR(pScrn);
#ifdef XF86DRI
MGAPtr pMga = MGAPTR(pScrn);
ScreenPtr pScreen;
#endif
MGARestore(pScrn);
vgaHWLock(hwp);
if (xf86IsPc98())
outb(0xfac, 0x00);
#ifdef XF86DRI
if (pMga->directRenderingEnabled) {
pScreen = screenInfo.screens[scrnIndex];
DRILock(pScreen, 0);
}
#endif
#ifdef USEMGAHAL
MGA_HAL( RESTORE_TEXTMODE_ON_DVI(pMga); );
#endif
}
static Bool
MGACloseScreen(int scrnIndex, ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
vgaHWPtr hwp = VGAHWPTR(pScrn);
MGAPtr pMga = MGAPTR(pScrn);
MGAEntPtr pMgaEnt = NULL;
#ifdef USEMGAHAL
MGA_HAL( RESTORE_TEXTMODE_ON_DVI(pMga); );
#endif
if (pMga->MergedFB)
MGACloseScreenMerged(scrnIndex, pScreen);
if (pScrn->vtSema) {
if (pMga->FBDev) {
fbdevHWRestore(pScrn);
MGAUnmapMemFBDev(pScrn);
} else {
MGARestore(pScrn);
vgaHWLock(hwp);
MGAUnmapMem(pScrn);
vgaHWUnmapMem(pScrn);
}
}
#ifdef XF86DRI
if (pMga->directRenderingEnabled) {
MGADRICloseScreen(pScreen);
pMga->directRenderingEnabled=FALSE;
}
#endif
if (pMga->DualHeadEnabled) {
DevUnion *pPriv;
pPriv = xf86GetEntityPrivate(pScrn->entityList[0], MGAEntityIndex);
pMgaEnt = pPriv->ptr;
pMgaEnt->refCount--;
}
#ifdef USEMGAHAL
MGA_HAL(
if(pMga->DualHeadEnabled) {
if(pMgaEnt->refCount == 0) {
MGACloseLibrary(pMga->pBoard);
if (pMga->pBoard)
xfree(pMga->pBoard);
if (pMga->pClientStruct)
xfree(pMga->pClientStruct);
if (pMga->pMgaModeInfo)
xfree(pMga->pMgaModeInfo);
if (pMga->pMgaHwInfo)
xfree(pMga->pMgaHwInfo);
}
} else {
MGACloseLibrary(pMga->pBoard);
if (pMga->pBoard)
xfree(pMga->pBoard);
if (pMga->pClientStruct)
xfree(pMga->pClientStruct);
if (pMga->pMgaModeInfo)
xfree(pMga->pMgaModeInfo);
if (pMga->pMgaHwInfo)
xfree(pMga->pMgaHwInfo);
}
);
#endif
if (pMga->AccelInfoRec)
XAADestroyInfoRec(pMga->AccelInfoRec);
if (pMga->CursorInfoRec)
xf86DestroyCursorInfoRec(pMga->CursorInfoRec);
if (pMga->ShadowPtr)
xfree(pMga->ShadowPtr);
if (pMga->DGAModes)
xfree(pMga->DGAModes);
if (pMga->adaptor)
xfree(pMga->adaptor);
if (pMga->portPrivate)
xfree(pMga->portPrivate);
if (pMga->ScratchBuffer)
xfree(pMga->ScratchBuffer);
pScrn->vtSema = FALSE;
if (xf86IsPc98())
outb(0xfac, 0x00);
xf86ClearPrimInitDone(pScrn->entityList[0]);
if(pMga->BlockHandler)
pScreen->BlockHandler = pMga->BlockHandler;
pScreen->CloseScreen = pMga->CloseScreen;
return (*pScreen->CloseScreen)(scrnIndex, pScreen);
}
static void
MGAFreeScreen(int scrnIndex, int flags)
{
if (xf86LoaderCheckSymbol("vgaHWFreeHWRec"))
vgaHWFreeHWRec(xf86Screens[scrnIndex]);
MGAFreeRec(xf86Screens[scrnIndex]);
}
static ModeStatus
MGAValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
{
int lace;
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
MGAPtr pMga = MGAPTR(pScrn);
lace = 1 + ((mode->Flags & V_INTERLACE) != 0);
if ((mode->CrtcHDisplay <= 2048) &&
(mode->CrtcHSyncStart <= 4096) &&
(mode->CrtcHSyncEnd <= 4096) &&
(mode->CrtcHTotal <= 4096) &&
(mode->CrtcVDisplay <= 2048 * lace) &&
(mode->CrtcVSyncStart <= 4096 * lace) &&
(mode->CrtcVSyncEnd <= 4096 * lace) &&
(mode->CrtcVTotal <= 4096 * lace)) {
if (pMga->SecondCrtc) {
if (flags == MODECHECK_FINAL) {
if (pMga->allowedWidth == 0)
pMga->allowedWidth = pScrn->virtualX;
if (mode->HDisplay != pMga->allowedWidth)
return(MODE_ONE_WIDTH);
}
}
return(MODE_OK);
} else {
return(MODE_BAD);
}
}
static Bool
MGASaveScreenCrtc2(ScreenPtr pScreen, int mode)
{
return FALSE;
}
static Bool
MGASaveScreen(ScreenPtr pScreen, int mode)
{
return vgaHWSaveScreen(pScreen, mode);
}
void
MGADisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
int flags)
{
MGAPtr pMga = MGAPTR(pScrn);
unsigned char seq1 = 0, crtcext1 = 0;
switch (PowerManagementMode)
{
case DPMSModeOn:
seq1 = 0x00;
crtcext1 = 0x00;
break;
case DPMSModeStandby:
seq1 = 0x20;
crtcext1 = 0x10;
break;
case DPMSModeSuspend:
seq1 = 0x20;
crtcext1 = 0x20;
break;
case DPMSModeOff:
seq1 = 0x20;
crtcext1 = 0x30;
break;
}
OUTREG8(MGAREG_SEQ_INDEX, 0x01);
seq1 |= INREG8(MGAREG_SEQ_DATA) & ~0x20;
OUTREG8(MGAREG_SEQ_DATA, seq1);
OUTREG8(MGAREG_CRTCEXT_INDEX, 0x01);
crtcext1 |= INREG8(MGAREG_CRTCEXT_DATA) & ~0x30;
OUTREG8(MGAREG_CRTCEXT_DATA, crtcext1);
}
void
MGADisplayPowerManagementSetCrtc2(ScrnInfoPtr pScrn, int PowerManagementMode,
int flags)
{
MGAPtr pMga = MGAPTR(pScrn);
CARD32 crtc2 = 0;
if (PowerManagementMode != DPMSModeOn)
crtc2 = 0x8;
crtc2 |= INREG(MGAREG_C2CTL) & ~0x8;
OUTREG(MGAREG_C2CTL, crtc2);
}
static void
MGABlockHandler (
int i,
pointer blockData,
pointer pTimeout,
pointer pReadmask
){
ScreenPtr pScreen = screenInfo.screens[i];
ScrnInfoPtr pScrn = xf86Screens[i];
MGAPtr pMga = MGAPTR(pScrn);
if(pMga->PaletteLoadCallback)
(*pMga->PaletteLoadCallback)(pScrn);
pScreen->BlockHandler = pMga->BlockHandler;
(*pScreen->BlockHandler) (i, blockData, pTimeout, pReadmask);
pScreen->BlockHandler = MGABlockHandler;
if(pMga->VideoTimerCallback) {
UpdateCurrentTime();
(*pMga->VideoTimerCallback)(pScrn, currentTime.milliseconds);
}
if(pMga->RenderCallback)
(*pMga->RenderCallback)(pScrn);
}
#if defined (EXTRADEBUG)
CARD8
MGAdbg_inreg8(ScrnInfoPtr pScrn,int addr,int verbose, char* func)
{
CARD8 ret;
ret = MMIO_IN8(MGAPTR(pScrn)->IOBase,addr);
if(verbose)
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"inreg8 : %s: 0x%8x = 0x%x\n",func, addr,ret);
return ret;
}
CARD16
MGAdbg_inreg16(ScrnInfoPtr pScrn,int addr,int verbose, char* func)
{
CARD16 ret;
ret = MMIO_IN16(MGAPTR(pScrn)->IOBase,addr);
if(verbose)
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"inreg16: %s: 0x%8x = 0x%x\n",func, addr,ret);
return ret;
}
CARD32
MGAdbg_inreg32(ScrnInfoPtr pScrn,int addr,int verbose, char* func)
{
CARD32 ret;
ret = MMIO_IN32(MGAPTR(pScrn)->IOBase,addr);
if(verbose)
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"inreg32: %s: 0x%8x = 0x%x\n",func, addr,ret);
return ret;
}
void
MGAdbg_outreg8(ScrnInfoPtr pScrn,int addr,int val, char* func)
{
CARD8 ret;
#if 0
if( addr = MGAREG_CRTCEXT_DATA )
return;
#endif
if( addr != 0x3c00 ) {
ret = MGAdbg_inreg8(pScrn,addr,0,func);
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"outreg8 : %s: 0x%8x = 0x%x was 0x%x\n",
func,addr,val,ret);
}
else {
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "outreg8 : %s: index 0x%x\n",
func,val);
}
MMIO_OUT8(MGAPTR(pScrn)->IOBase,addr,val);
}
void
MGAdbg_outreg16(ScrnInfoPtr pScrn,int addr,int val, char* func)
{
CARD16 ret;
#if 0
if (addr == MGAREG_CRTCEXT_INDEX)
return;
#endif
ret = MGAdbg_inreg16(pScrn,addr,0, func);
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"outreg16: %s: 0x%8x = 0x%x was 0x%x\n",
func,addr,val,ret);
MMIO_OUT16(MGAPTR(pScrn)->IOBase,addr,val);
}
void
MGAdbg_outreg32(ScrnInfoPtr pScrn,int addr,int val, char* func)
{
CARD32 ret;
if (((addr & 0xff00) == 0x1c00)
&& (addr != 0x1c04)
&& (addr != 0x1c20)
&& (addr != 0x1c24)
&& (addr != 0x1c80)
&& (addr != 0x1c8c)
&& (addr != 0x1c94)
&& (addr != 0x1c98)
&& (addr != 0x1c9c)
) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%s: refused address 0x%x\n",
func,addr);
return;
}
ret = MGAdbg_inreg32(pScrn,addr,0, func);
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"outreg32: %s: 0x%8x = 0x%x was 0x%x\n",
func,addr,val,ret);
MMIO_OUT32(MGAPTR(pScrn)->IOBase,addr,val);
}
#endif
static void
MGAG100BlackMagic(ScrnInfoPtr pScrn)
{
MGAPtr pMga = MGAPTR(pScrn);
OUTREG(MGAREG_PLNWT, ~(CARD32)0x0);
OUTREG(MGAREG_MACCESS, 1<<15);
usleep(10);
}