#include "fb.h"
#include "cfb8_32.h"
#include "micmap.h"
#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86_ansic.h"
#include "xf86Version.h"
#include "xf86PciInfo.h"
#include "xf86Pci.h"
#include "xf86cmap.h"
#include "shadowfb.h"
#include "fbdevhw.h"
#include "xf86RAC.h"
#include "xf86Resources.h"
#include "xf86int10.h"
#include "dixstruct.h"
#include "vbe.h"
#include "compiler.h"
#include "mipointer.h"
#include "mibstore.h"
#include "pm3_regs.h"
#include "glint_regs.h"
#include "IBM.h"
#include "TI.h"
#include "glint.h"
#define _XF86DGA_SERVER_
#include "extensions/xf86dgastr.h"
#include "globals.h"
#define DPMS_SERVER
#include "extensions/dpms.h"
#define DEBUG 0
#if DEBUG
# define TRACE_ENTER(str) ErrorF("glint: " str " %d\n",pScrn->scrnIndex)
# define TRACE_EXIT(str) ErrorF("glint: " str " done\n")
# define TRACE(str) ErrorF("glint trace: " str "\n")
#else
# define TRACE_ENTER(str)
# define TRACE_EXIT(str)
# define TRACE(str)
#endif
static const OptionInfoRec * GLINTAvailableOptions(int chipid, int busid);
static void GLINTIdentify(int flags);
static Bool GLINTProbe(DriverPtr drv, int flags);
static Bool GLINTPreInit(ScrnInfoPtr pScrn, int flags);
static Bool GLINTScreenInit(int Index, ScreenPtr pScreen, int argc,
char **argv);
static Bool GLINTEnterVT(int scrnIndex, int flags);
static void GLINTLeaveVT(int scrnIndex, int flags);
static Bool GLINTCloseScreen(int scrnIndex, ScreenPtr pScreen);
static Bool GLINTSaveScreen(ScreenPtr pScreen, int mode);
static void GLINTFreeScreen(int scrnIndex, int flags);
static ModeStatus GLINTValidMode(int scrnIndex, DisplayModePtr mode,
Bool verbose, int flags);
static Bool GLINTMapMem(ScrnInfoPtr pScrn);
static Bool GLINTUnmapMem(ScrnInfoPtr pScrn);
static void GLINTSave(ScrnInfoPtr pScrn);
static void GLINTRestore(ScrnInfoPtr pScrn);
static Bool GLINTModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode);
static void GLINTBlockHandler(int, pointer, pointer, pointer);
static int GLINTEntityIndex = -1;
static Bool FBDevProbed = FALSE;
DriverRec GLINT = {
VERSION,
GLINT_DRIVER_NAME,
GLINTIdentify,
GLINTProbe,
GLINTAvailableOptions,
NULL,
0
};
static SymTabRec GLINTVGAChipsets[] = {
{ PCI_VENDOR_TI_CHIP_PERMEDIA2, "ti_pm2" },
{ PCI_VENDOR_TI_CHIP_PERMEDIA, "ti_pm" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA4, "pm4" },
{ PCI_VENDOR_3DLABS_CHIP_R4, "r4" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA3, "pm3" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V, "pm2v" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA2, "pm2" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA, "pm" },
{-1, NULL }
};
static PciChipsets GLINTVGAPciChipsets[] = {
{ PCI_VENDOR_TI_CHIP_PERMEDIA2, PCI_VENDOR_TI_CHIP_PERMEDIA2, RES_SHARED_VGA },
{ PCI_VENDOR_TI_CHIP_PERMEDIA, PCI_VENDOR_TI_CHIP_PERMEDIA, NULL },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA4, PCI_VENDOR_3DLABS_CHIP_PERMEDIA4, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_R4, PCI_VENDOR_3DLABS_CHIP_R4, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA3, PCI_VENDOR_3DLABS_CHIP_PERMEDIA3, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V, PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA2, PCI_VENDOR_3DLABS_CHIP_PERMEDIA2, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA, PCI_VENDOR_3DLABS_CHIP_PERMEDIA, NULL },
{ -1, -1, RES_UNDEFINED }
};
static SymTabRec GLINTChipsets[] = {
{ PCI_VENDOR_3DLABS_CHIP_GAMMA, "gamma" },
{ PCI_VENDOR_3DLABS_CHIP_GAMMA2, "gamma2" },
{ PCI_VENDOR_TI_CHIP_PERMEDIA2, "ti_pm2" },
{ PCI_VENDOR_TI_CHIP_PERMEDIA, "ti_pm" },
{ PCI_VENDOR_3DLABS_CHIP_R4, "r4" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA4, "pm4" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA3, "pm3" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V, "pm2v" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA2, "pm2" },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA, "pm" },
{ PCI_VENDOR_3DLABS_CHIP_300SX, "300sx" },
{ PCI_VENDOR_3DLABS_CHIP_500TX, "500tx" },
{ PCI_VENDOR_3DLABS_CHIP_MX, "mx" },
{ PCI_VENDOR_3DLABS_CHIP_DELTA, "delta" },
{ -1, NULL }
};
static PciChipsets GLINTPciChipsets[] = {
{ PCI_VENDOR_3DLABS_CHIP_GAMMA, PCI_VENDOR_3DLABS_CHIP_GAMMA, NULL },
{ PCI_VENDOR_3DLABS_CHIP_GAMMA2, PCI_VENDOR_3DLABS_CHIP_GAMMA2, NULL },
{ PCI_VENDOR_TI_CHIP_PERMEDIA2, PCI_VENDOR_TI_CHIP_PERMEDIA2, RES_SHARED_VGA },
{ PCI_VENDOR_TI_CHIP_PERMEDIA, PCI_VENDOR_TI_CHIP_PERMEDIA, NULL },
{ PCI_VENDOR_3DLABS_CHIP_R4, PCI_VENDOR_3DLABS_CHIP_R4, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA4, PCI_VENDOR_3DLABS_CHIP_PERMEDIA4, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA3, PCI_VENDOR_3DLABS_CHIP_PERMEDIA3, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V, PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA2, PCI_VENDOR_3DLABS_CHIP_PERMEDIA2, RES_SHARED_VGA },
{ PCI_VENDOR_3DLABS_CHIP_PERMEDIA, PCI_VENDOR_3DLABS_CHIP_PERMEDIA, NULL },
{ PCI_VENDOR_3DLABS_CHIP_300SX, PCI_VENDOR_3DLABS_CHIP_300SX, NULL },
{ PCI_VENDOR_3DLABS_CHIP_500TX, PCI_VENDOR_3DLABS_CHIP_500TX, NULL },
{ PCI_VENDOR_3DLABS_CHIP_MX, PCI_VENDOR_3DLABS_CHIP_MX, NULL },
{ PCI_VENDOR_3DLABS_CHIP_DELTA, PCI_VENDOR_3DLABS_CHIP_DELTA, NULL },
{ -1, -1, RES_UNDEFINED }
};
typedef enum {
OPTION_SW_CURSOR,
OPTION_RGB_BITS,
OPTION_NOACCEL,
OPTION_BLOCK_WRITE,
OPTION_FIREGL3000,
OPTION_OVERLAY,
OPTION_SHADOW_FB,
OPTION_FBDEV,
OPTION_FLATPANEL,
OPTION_VIDEO_KEY
} GLINTOpts;
static const OptionInfoRec GLINTOptions[] = {
{ OPTION_SW_CURSOR, "SWcursor", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_RGB_BITS, "RGBbits", OPTV_INTEGER, {0}, FALSE },
{ OPTION_NOACCEL, "NoAccel", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_BLOCK_WRITE, "BlockWrite", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_FIREGL3000, "FireGL3000", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_OVERLAY, "Overlay", OPTV_ANYSTR, {0}, FALSE },
{ OPTION_SHADOW_FB, "ShadowFB", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_FBDEV, "UseFBDev", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_FLATPANEL, "UseFlatPanel", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_VIDEO_KEY, "VideoKey", OPTV_BOOLEAN, {0}, FALSE },
{ -1, NULL, OPTV_NONE, {0}, FALSE }
};
static RamDacSupportedInfoRec IBMRamdacs[] = {
{ IBM526DB_RAMDAC },
{ IBM526_RAMDAC },
{ IBM640_RAMDAC },
{ -1 }
};
static RamDacSupportedInfoRec TIRamdacs[] = {
{ TI3030_RAMDAC },
{ TI3026_RAMDAC },
{ -1 }
};
static const char *xf8_32bppSymbols[] = {
"cfb8_32ScreenInit",
"xf86Overlay8Plus32Init",
NULL
};
static const char *xaaSymbols[] = {
"XAACreateInfoRec",
"XAADestroyInfoRec",
"XAAInit",
"XAAPolyLines",
"XAAPolySegment",
NULL
};
static const char *fbSymbols[] = {
"fbBres",
"fbPictureInit",
"fbScreenInit",
NULL
};
static const char *ddcSymbols[] = {
"xf86PrintEDID",
"xf86DoEDID_DDC2",
"xf86SetDDCproperties",
NULL
};
static const char *i2cSymbols[] = {
"xf86CreateI2CBusRec",
"xf86DestroyI2CBusRec",
"xf86DestroyI2CDevRec",
"xf86I2CBusInit",
"xf86I2CDevInit",
"xf86I2CProbeAddress",
"xf86I2CWriteByte",
"xf86I2CWriteVec",
NULL
};
static const char *shadowSymbols[] = {
"ShadowFBInit",
NULL
};
#ifdef XFree86LOADER
static const char *vbeSymbols[] = {
"VBEInit",
"vbeDoEDID",
"vbeFree",
NULL
};
#endif
static const char *ramdacSymbols[] = {
"IBMramdac526CalculateMNPCForClock",
"IBMramdac640CalculateMNPCForClock",
"IBMramdacProbe",
"RamDacCreateInfoRec",
"RamDacDestroyInfoRec",
"RamDacFreeRec",
"RamDacGetHWIndex",
"RamDacHandleColormaps",
"RamDacInit",
"TIramdacCalculateMNPForClock",
"TIramdacLoadPalette",
"TIramdacProbe",
"xf86CreateCursorInfoRec",
"xf86DestroyCursorInfoRec",
"xf86InitCursor",
NULL
};
static const char *fbdevHWSymbols[] = {
"fbdevHWFreeRec",
"fbdevHWInit",
"fbdevHWProbe",
"fbdevHWUseBuildinMode",
"fbdevHWGetDepth",
"fbdevHWGetVidmem",
"fbdevHWLoadPalette",
"fbdevHWAdjustFrame",
"fbdevHWEnterVT",
"fbdevHWLeaveVT",
"fbdevHWMapMMIO",
"fbdevHWMapVidmem",
"fbdevHWModeInit",
"fbdevHWRestore",
"fbdevHWSave",
"fbdevHWSwitchMode",
"fbdevHWUnmapMMIO",
"fbdevHWUnmapVidmem",
"fbdevHWValidMode",
NULL
};
const char *GLINTint10Symbols[] = {
"xf86FreeInt10",
"xf86InitInt10",
NULL
};
#ifdef XFree86LOADER
#ifdef XF86DRI
static const char *drmSymbols[] = {
"drmAddBufs",
"drmAddMap",
"drmAgpAcquire",
"drmAgpAlloc",
"drmAgpBind",
"drmAgpEnable",
"drmAgpFree",
"drmAgpGetMode",
"drmAgpRelease",
"drmAgpUnbind",
"drmCommandWrite",
"drmCtlInstHandler",
"drmFreeBufs",
"drmFreeVersion",
"drmGetInterruptFromBusID",
"drmGetLibVersion",
"drmGetVersion",
"drmMap",
"drmMapBufs",
"drmUnmap",
"drmUnmapBufs",
NULL
};
static const char *driSymbols[] = {
"DRICloseScreen",
"DRICreateInfoRec",
"DRIDestroyInfoRec",
"DRIFinishScreenInit",
"DRIGetDrawableIndex",
"DRIQueryVersion",
"DRIScreenInit",
"GlxSetVisualConfigs",
NULL
};
#endif
static MODULESETUPPROTO(glintSetup);
static XF86ModuleVersionInfo glintVersRec =
{
"glint",
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XF86_VERSION_CURRENT,
GLINT_MAJOR_VERSION, GLINT_MINOR_VERSION, GLINT_PATCHLEVEL,
ABI_CLASS_VIDEODRV,
ABI_VIDEODRV_VERSION,
MOD_CLASS_VIDEODRV,
{0,0,0,0}
};
XF86ModuleData glintModuleData = { &glintVersRec, glintSetup, NULL };
pointer
glintSetup(pointer module, pointer opts, int *errmaj, int *errmin)
{
static Bool setupDone = FALSE;
if (!setupDone) {
setupDone = TRUE;
xf86AddDriver(&GLINT, module, 0);
LoaderRefSymLists(fbSymbols, ddcSymbols, i2cSymbols,
xaaSymbols, xf8_32bppSymbols,
shadowSymbols, fbdevHWSymbols, GLINTint10Symbols,
vbeSymbols, ramdacSymbols,
#ifdef XF86DRI
drmSymbols, driSymbols,
#endif
NULL);
return (pointer)TRUE;
}
if (errmaj) *errmaj = LDR_ONCEONLY;
return NULL;
}
#endif
#define PARTPROD(a,b,c) (((a)<<6) | ((b)<<3) | (c))
static char bppand[4] = { 0x03,
0x01,
0x00,
0x00 };
static int partprod500TX[] = {
-1,
PARTPROD(0,0,1), PARTPROD(0,0,2), PARTPROD(0,1,2), PARTPROD(0,0,3),
PARTPROD(0,1,3), PARTPROD(0,2,3), PARTPROD(1,2,3), PARTPROD(0,0,4),
PARTPROD(0,1,4), PARTPROD(0,2,4), PARTPROD(1,2,4), PARTPROD(0,3,4),
PARTPROD(1,3,4), PARTPROD(2,3,4), -1, PARTPROD(0,0,5),
PARTPROD(0,1,5), PARTPROD(0,2,5), PARTPROD(1,2,5), PARTPROD(0,3,5),
PARTPROD(1,3,5), PARTPROD(2,3,5), -1, PARTPROD(0,4,5),
PARTPROD(1,4,5), PARTPROD(2,4,5), PARTPROD(3,4,5), -1,
-1, -1, -1, PARTPROD(0,0,6),
PARTPROD(0,1,6), PARTPROD(0,2,6), PARTPROD(1,2,6), PARTPROD(0,3,6),
PARTPROD(1,3,6), PARTPROD(2,3,6), -1, PARTPROD(0,4,6),
PARTPROD(1,4,6), PARTPROD(2,4,6), -1, PARTPROD(3,4,6),
-1, -1, -1, PARTPROD(0,5,6),
PARTPROD(1,5,6), PARTPROD(2,5,6), -1, PARTPROD(3,5,6),
-1, -1, -1, PARTPROD(4,5,6),
-1, -1, -1, -1,
-1, -1, -1, PARTPROD(0,0,7),
-1, PARTPROD(0,2,7), PARTPROD(1,2,7), PARTPROD(0,3,7),
PARTPROD(1,3,7), PARTPROD(2,3,7), -1, PARTPROD(0,4,7),
PARTPROD(1,4,7), PARTPROD(2,4,7), -1, PARTPROD(3,4,7),
-1, -1, -1, PARTPROD(0,5,7),
PARTPROD(1,5,7), PARTPROD(2,5,7), -1, PARTPROD(3,5,7),
-1, -1, -1, PARTPROD(4,5,7),
-1, -1, -1, -1,
-1, -1, -1, PARTPROD(0,6,7),
PARTPROD(1,6,7), PARTPROD(2,6,7), -1, PARTPROD(3,6,7),
-1, -1, -1, PARTPROD(4,6,7),
-1, -1, -1, -1,
-1, -1, -1, PARTPROD(5,6,7),
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, PARTPROD(0,7,7),
0};
int partprodPermedia[] = {
-1,
PARTPROD(0,0,1), PARTPROD(0,1,1), PARTPROD(1,1,1), PARTPROD(1,1,2),
PARTPROD(1,2,2), PARTPROD(2,2,2), PARTPROD(1,2,3), PARTPROD(2,2,3),
PARTPROD(1,3,3), PARTPROD(2,3,3), PARTPROD(1,2,4), PARTPROD(3,3,3),
PARTPROD(1,3,4), PARTPROD(2,3,4), -1, PARTPROD(3,3,4),
PARTPROD(1,4,4), PARTPROD(2,4,4), -1, PARTPROD(3,4,4),
-1, PARTPROD(2,3,5), -1, PARTPROD(4,4,4),
PARTPROD(1,4,5), PARTPROD(2,4,5), PARTPROD(3,4,5), -1,
-1, -1, -1, PARTPROD(4,4,5),
PARTPROD(1,5,5), PARTPROD(2,5,5), -1, PARTPROD(3,5,5),
-1, -1, -1, PARTPROD(4,5,5),
-1, -1, -1, PARTPROD(3,4,6),
-1, -1, -1, PARTPROD(5,5,5),
PARTPROD(1,5,6), PARTPROD(2,5,6), -1, PARTPROD(3,5,6),
-1, -1, -1, PARTPROD(4,5,6),
-1, -1, -1, -1,
-1, -1, -1, PARTPROD(5,5,6),
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
0};
static void
GLINTDisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
int flags)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
int videocontrol = 0, vtgpolarity = 0;
if((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_500TX) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_300SX) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_MX) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_300SX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_500TX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_MX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) &&
(pGlint->MultiChip == PCI_CHIP_MX)) ) {
vtgpolarity = GLINT_READ_REG(VTGPolarity) & 0xFFFFFFF0;
} else {
videocontrol = GLINT_READ_REG(PMVideoControl) & 0xFFFFFFD6;
}
switch (PowerManagementMode) {
case DPMSModeOn:
videocontrol |= 0x29;
vtgpolarity |= 0x05;
break;
case DPMSModeStandby:
videocontrol |= 0x20;
vtgpolarity |= 0x04;
break;
case DPMSModeSuspend:
videocontrol |= 0x08;
vtgpolarity |= 0x01;
break;
case DPMSModeOff:
videocontrol |= 0x00;
vtgpolarity |= 0x00;
break;
default:
return;
}
if((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_500TX) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_300SX) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_MX) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_300SX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_500TX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_MX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) &&
(pGlint->MultiChip == PCI_CHIP_MX)) ) {
GLINT_SLOW_WRITE_REG(vtgpolarity, VTGPolarity);
} else {
GLINT_SLOW_WRITE_REG(videocontrol, PMVideoControl);
}
}
static Bool
GLINTGetRec(ScrnInfoPtr pScrn)
{
TRACE_ENTER("GLINTGetRec");
if (pScrn->driverPrivate != NULL)
return TRUE;
pScrn->driverPrivate = xnfcalloc(sizeof(GLINTRec), 1);
TRACE_EXIT("GLINTGetRec");
return TRUE;
}
static void
GLINTFreeRec(ScrnInfoPtr pScrn)
{
TRACE_ENTER("GLINTFreeRec");
if (pScrn->driverPrivate == NULL)
return;
xfree(pScrn->driverPrivate);
pScrn->driverPrivate = NULL;
TRACE_EXIT("GLINTFreeRec");
}
static void
GLINTIdentify(int flags)
{
xf86PrintChipsets(GLINT_NAME, "driver for 3Dlabs chipsets", GLINTChipsets);
}
static const OptionInfoRec *
GLINTAvailableOptions(int chipid, int busid)
{
return GLINTOptions;
}
static void
GLINTProbeDDC(ScrnInfoPtr pScrn, int index)
{
vbeInfoPtr pVbe;
if (xf86LoadSubModule(pScrn, "vbe"))
{
pVbe = VBEInit(NULL,index);
vbeDoEDID(pVbe, NULL);
vbeFree(pVbe);
}
}
static Bool
GLINTProbe(DriverPtr drv, int flags)
{
int i;
pciVideoPtr pPci, *checkusedPci;
GDevPtr *devSections;
int numDevSections;
int numUsed,bus,device,func;
char *dev;
int *usedChips = NULL;
Bool foundScreen = FALSE;
char *name;
TRACE_EXIT("GLINTProbe (Enter)");
if ((numDevSections = xf86MatchDevice(GLINT_DRIVER_NAME,
&devSections)) <= 0) {
return FALSE;
}
checkusedPci = xf86GetPciVideoInfo();
if (checkusedPci == NULL && devSections ) {
if (!xf86LoadDrvSubModule(drv, "fbdevhw"))
return FALSE;
xf86LoaderReqSymLists(fbdevHWSymbols, NULL);
for (i = 0; i < numDevSections; i++) {
dev = xf86FindOptionValue(devSections[i]->options,"fbdev");
if (devSections[i]->busID) {
xf86ParsePciBusString(devSections[i]->busID,&bus,&device,&func);
if (!xf86CheckPciSlot(bus,device,func))
continue;
}
if (fbdevHWProbe(NULL,dev,&name)) {
ScrnInfoPtr pScrn;
if (strcmp(name,"Permedia2")) continue;
foundScreen = TRUE;
pScrn = NULL;
if (devSections[i]->busID) {
int entity;
entity = xf86ClaimPciSlot(bus,device,func,drv,
0,devSections[i],
TRUE);
pScrn = xf86ConfigPciEntity(pScrn,0,entity,
NULL,RES_SHARED_VGA,
NULL,NULL,NULL,NULL);
if (pScrn)
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"claimed PCI slot %d:%d:%d\n",bus,device,func);
} else {
int entity;
entity = xf86ClaimIsaSlot(drv, 0,
devSections[i], TRUE);
pScrn = xf86ConfigIsaEntity(pScrn,0,entity,
NULL,RES_SHARED_VGA,
NULL,NULL,NULL,NULL);
}
if (pScrn) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"%s successfully probed\n", dev ? dev : "default framebuffer device");
pScrn->driverVersion = VERSION;
pScrn->driverName = GLINT_DRIVER_NAME;
pScrn->name = GLINT_NAME;
pScrn->Probe = GLINTProbe;
pScrn->PreInit = GLINTPreInit;
pScrn->ScreenInit = GLINTScreenInit;
pScrn->SwitchMode = GLINTSwitchMode;
pScrn->FreeScreen = GLINTFreeScreen;
pScrn->EnterVT = GLINTEnterVT;
}
}
}
xfree(devSections);
} else if (checkusedPci) {
if (flags & PROBE_DETECT) {
numUsed = xf86MatchPciInstances(GLINT_NAME, 0,
GLINTVGAChipsets, GLINTVGAPciChipsets,
devSections,
numDevSections, drv, &usedChips);
} else {
numUsed = xf86MatchPciInstances(GLINT_NAME, 0,
GLINTChipsets, GLINTPciChipsets, devSections,
numDevSections, drv, &usedChips);
}
xfree(devSections);
if (numUsed <= 0)
return FALSE;
foundScreen = TRUE;
if (!(flags & PROBE_DETECT))
for (i = 0; i < numUsed; i++) {
ScrnInfoPtr pScrn = NULL;
GLINTEntPtr pGlintEnt = NULL;
DevUnion *pPriv;
pPci = xf86GetPciInfoForEntity(usedChips[i]);
if ((pScrn = xf86ConfigPciEntity(pScrn, 0, usedChips[i],
GLINTPciChipsets, NULL,
NULL, NULL, NULL, NULL))) {
if ((pPci->subsysVendor == 0x1097) &&
(pPci->subsysCard == 0x3d32)) {
int eIndex;
if (!xf86IsEntityShared(usedChips[i])) {
eIndex = xf86ClaimPciSlot(pPci->bus,
pPci->device,
1,
drv, -1 ,
NULL, FALSE);
xf86AddEntityToScreen(pScrn,eIndex);
} else {
eIndex = xf86ClaimPciSlot(pPci->bus,
pPci->device,
2,
drv, -1 ,
NULL, FALSE);
xf86AddEntityToScreen(pScrn,eIndex);
}
} else
if ((pPci->chipType == PCI_CHIP_GAMMA) ||
(pPci->chipType == PCI_CHIP_GAMMA2) ||
(pPci->chipType == PCI_CHIP_DELTA)) {
while (*checkusedPci != NULL) {
int eIndex;
if ((pPci->bus == (*checkusedPci)->bus &&
pPci->device == (*checkusedPci)->device) &&
pPci->func != (*checkusedPci)->func) {
eIndex = xf86ClaimPciSlot((*checkusedPci)->bus,
(*checkusedPci)->device,
(*checkusedPci)->func,
drv, -1 ,
NULL, FALSE);
if (eIndex != -1) {
xf86AddEntityToScreen(pScrn,eIndex);
} else {
ErrorF("BusID %d:%d:%d already claimed\n",
(*checkusedPci)->bus,
(*checkusedPci)->device,
(*checkusedPci)->func);
xfree(usedChips);
return FALSE;
}
}
checkusedPci++;
}
}
pScrn->driverVersion = VERSION;
pScrn->driverName = GLINT_DRIVER_NAME;
pScrn->name = GLINT_NAME;
pScrn->Probe = GLINTProbe;
pScrn->PreInit = GLINTPreInit;
pScrn->ScreenInit = GLINTScreenInit;
pScrn->SwitchMode = GLINTSwitchMode;
pScrn->FreeScreen = GLINTFreeScreen;
pScrn->EnterVT = GLINTEnterVT;
}
if ((pPci->subsysVendor == 0x1097) &&
(pPci->subsysCard == 0x3d32)) {
xf86SetEntitySharable(usedChips[i]);
if (GLINTEntityIndex < 0)
GLINTEntityIndex = xf86AllocateEntityPrivateIndex();
pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
GLINTEntityIndex);
if (!pPriv->ptr) {
pPriv->ptr = xnfcalloc(sizeof(GLINTEntRec), 1);
pGlintEnt = pPriv->ptr;
pGlintEnt->lastInstance = -1;
} else {
pGlintEnt = pPriv->ptr;
}
pGlintEnt->lastInstance++;
xf86SetEntityInstanceForScreen(pScrn,
pScrn->entityList[0], pGlintEnt->lastInstance);
}
}
}
xfree(usedChips);
TRACE_EXIT("GLINTProbe");
return foundScreen;
}
static int *
GetAccelPitchValues(ScrnInfoPtr pScrn)
{
int *linePitches = NULL;
int i, n = 0;
int *linep = NULL;
GLINTPtr pGlint = GLINTPTR(pScrn);
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
linep = &partprodPermedia[0];
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_300SX:
case PCI_VENDOR_3DLABS_CHIP_MX:
linep = &partprod500TX[0];
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_MX:
case PCI_CHIP_500TX:
case PCI_CHIP_300SX:
linep = &partprod500TX[0];
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
linep = &partprodPermedia[0];
break;
}
break;
}
for (i = 0; linep[i] != 0; i++) {
if (linep[i] != -1) {
n++;
linePitches = xnfrealloc(linePitches, n * sizeof(int));
linePitches[n - 1] = i << 5;
}
}
if (n > 0) {
linePitches = xnfrealloc(linePitches, (n + 1) * sizeof(int));
linePitches[n] = 0;
}
return linePitches;
}
static void
GLINTProbeTIramdac(ScrnInfoPtr pScrn)
{
GLINTPtr pGlint;
CARD32 temp = 0;
pGlint = GLINTPTR(pScrn);
pGlint->RamDacRec = RamDacCreateInfoRec();
pGlint->RamDacRec->ReadDAC = glintInTIIndReg;
pGlint->RamDacRec->WriteDAC = glintOutTIIndReg;
pGlint->RamDacRec->ReadAddress = glintTIReadAddress;
pGlint->RamDacRec->WriteAddress = glintTIWriteAddress;
pGlint->RamDacRec->ReadData = glintTIReadData;
pGlint->RamDacRec->WriteData = glintTIWriteData;
pGlint->RamDacRec->LoadPalette = TIramdacLoadPalette;
if(!RamDacInit(pScrn, pGlint->RamDacRec)) {
RamDacDestroyInfoRec(pGlint->RamDacRec);
return;
}
GLINTMapMem(pScrn);
if (pGlint->numMultiDevices == 2) {
temp = GLINT_READ_REG(GCSRAperture);
GLINT_SLOW_WRITE_REG(GCSRSecondaryGLINTMapEn, GCSRAperture);
}
pGlint->RamDac = TIramdacProbe(pScrn, TIRamdacs);
if (pGlint->numMultiDevices == 2) {
GLINT_SLOW_WRITE_REG(temp, GCSRAperture);
}
GLINTUnmapMem(pScrn);
}
static void
GLINTProbeIBMramdac(ScrnInfoPtr pScrn)
{
GLINTPtr pGlint;
pGlint = GLINTPTR(pScrn);
pGlint->RamDacRec = RamDacCreateInfoRec();
pGlint->RamDacRec->ReadDAC = glintInIBMRGBIndReg;
pGlint->RamDacRec->WriteDAC = glintOutIBMRGBIndReg;
pGlint->RamDacRec->ReadAddress = glintIBMReadAddress;
pGlint->RamDacRec->WriteAddress = glintIBMWriteAddress;
pGlint->RamDacRec->ReadData = glintIBMReadData;
pGlint->RamDacRec->WriteData = glintIBMWriteData;
pGlint->RamDacRec->LoadPalette = NULL;
if(!RamDacInit(pScrn, pGlint->RamDacRec)) {
RamDacDestroyInfoRec(pGlint->RamDacRec);
return;
}
GLINTMapMem(pScrn);
pGlint->RamDac = IBMramdacProbe(pScrn, IBMRamdacs);
GLINTUnmapMem(pScrn);
}
static Bool
GLINTPreInit(ScrnInfoPtr pScrn, int flags)
{
GLINTPtr pGlint;
GLINTEntPtr pGlintEnt = NULL;
MessageType from;
int i;
Bool Overlay = FALSE;
int maxwidth = 0, maxheight = 0;
ClockRangePtr clockRanges;
char *mod = NULL;
const char *s;
const char **syms = NULL;
TRACE_ENTER("GLINTPreInit");
if (pScrn->numEntities < 1)
return FALSE;
if (!GLINTGetRec(pScrn)) {
return FALSE;
}
pGlint = GLINTPTR(pScrn);
pGlint->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
if (xf86IsEntityShared(pScrn->entityList[0])) {
pGlintEnt = xf86GetEntityPrivate(pScrn->entityList[0],
GLINTEntityIndex)->ptr;
pGlint->entityPrivate = pGlintEnt;
}
if (pGlint->pEnt->location.type == BUS_PCI)
{
pGlint->PciInfo = xf86GetPciInfoForEntity(pGlint->pEnt->index);
pGlint->PciTag = pciTag(pGlint->PciInfo->bus, pGlint->PciInfo->device,
pGlint->PciInfo->func);
}
pGlint->InFifoSpace = 0;
pGlint->numMultiDevices = 0;
pGlint->IOOffset = 0;
if (pScrn->numEntities > 1) {
pciVideoPtr pPci;
EntityInfoPtr pEnt;
for (i = 1; i < pScrn->numEntities; i++) {
pEnt = xf86GetEntityInfo(pScrn->entityList[i]);
pPci = xf86GetPciInfoForEntity(pEnt->index);
if ( (pPci->chipType == PCI_CHIP_MX) ||
(pPci->chipType == PCI_CHIP_PERMEDIA) ||
(pPci->chipType == PCI_CHIP_TI_PERMEDIA) ||
(pPci->chipType == PCI_CHIP_500TX) ||
(pPci->chipType == PCI_CHIP_300SX) ||
(pPci->chipType == PCI_CHIP_R4) ||
(pPci->chipType == PCI_CHIP_PERMEDIA3) ) {
pGlint->MultiChip = pPci->chipType;
if (pGlint->numMultiDevices >= GLINT_MAX_MULTI_DEVICES) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"%d multiple chips unsupported, aborting. (Max - 2)\n",
pGlint->numMultiDevices);
return FALSE;
} else {
pGlint->MultiPciInfo[pGlint->numMultiDevices] = pPci;
pGlint->numMultiDevices++;
}
}
}
}
{
EntityInfoPtr pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
pciVideoPtr pPci = xf86GetPciInfoForEntity(pEnt->index);
if ( ((pPci->chipType == PCI_CHIP_GAMMA) ||
(pPci->chipType == PCI_CHIP_GAMMA2) ||
(pPci->chipType == PCI_CHIP_DELTA)) &&
(pGlint->numMultiDevices == 0) ) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Gamma/Delta with ZERO connected chips, aborting\n");
return FALSE;
}
}
if (flags & PROBE_DETECT) {
EntityInfoPtr pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
pciVideoPtr pPci = xf86GetPciInfoForEntity(pEnt->index);
if ((pPci->chipType != PCI_CHIP_GAMMA) &&
(pPci->chipType != PCI_CHIP_GAMMA2) &&
(pPci->chipType != PCI_CHIP_DELTA)) {
GLINTProbeDDC(pScrn, pGlint->pEnt->index);
return TRUE;
} else
return FALSE;
}
xf86SetOperatingState(resVga, pGlint->pEnt->index, ResDisableOpr);
pScrn->racMemFlags = RAC_FB | RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT;
pScrn->racIoFlags = RAC_FB | RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT;
pScrn->monitor = pScrn->confScreen->monitor;
if (FBDevProbed) {
int default_depth, fbbpp;
if (!fbdevHWInit(pScrn,NULL,xf86FindOptionValue(pGlint->pEnt->device->options,"fbdev"))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "fbdevHWInit failed!\n");
return FALSE;
}
default_depth = fbdevHWGetDepth(pScrn,&fbbpp);
if (!xf86SetDepthBpp(pScrn, default_depth, default_depth, fbbpp,0))
return FALSE;
} else {
if (!xf86SetDepthBpp(pScrn, 8, 0, 0, Support24bppFb | Support32bppFb
))
return FALSE;
}
switch (pScrn->depth) {
case 8:
case 15:
case 16:
case 24:
case 30:
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 {
;
}
}
if (!xf86SetDefaultVisual(pScrn, -1)) {
return FALSE;
} else {
if (pScrn->depth > 8 && pScrn->defaultVisual != TrueColor) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual"
" (%s) is not supported at depth %d\n",
xf86GetVisualName(pScrn->defaultVisual), pScrn->depth);
return FALSE;
}
}
{
Gamma zeros = {0.0, 0.0, 0.0};
if (!xf86SetGamma(pScrn, zeros)) {
return FALSE;
}
}
pScrn->progClock = TRUE;
xf86CollectOptions(pScrn, NULL);
if (!(pGlint->Options = xalloc(sizeof(GLINTOptions))))
return FALSE;
memcpy(pGlint->Options, GLINTOptions, sizeof(GLINTOptions));
xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pGlint->Options);
if (pScrn->depth == 30) pScrn->rgbBits = 10;
else pScrn->rgbBits = 8;
if (xf86GetOptValInteger(pGlint->Options, OPTION_RGB_BITS, &pScrn->rgbBits)) {
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Bits per RGB set to %d\n",
pScrn->rgbBits);
}
from = X_DEFAULT;
pGlint->HWCursor = TRUE;
if (xf86ReturnOptValBool(pGlint->Options, OPTION_SW_CURSOR, FALSE)) {
from = X_CONFIG;
pGlint->HWCursor = FALSE;
}
xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n",
pGlint->HWCursor ? "HW" : "SW");
if (xf86ReturnOptValBool(pGlint->Options, OPTION_FLATPANEL, FALSE)) {
pGlint->UseFlatPanel = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Using Flat Panel Interface\n");
}
if (xf86ReturnOptValBool(pGlint->Options, OPTION_NOACCEL, FALSE)) {
pGlint->NoAccel = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
}
if (xf86ReturnOptValBool(pGlint->Options, OPTION_SHADOW_FB, FALSE)) {
pGlint->ShadowFB = TRUE;
pGlint->NoAccel = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"Using \"Shadow Framebuffer\" - acceleration disabled\n");
}
if(xf86GetOptValInteger(pGlint->Options, OPTION_VIDEO_KEY,
&(pGlint->videoKey))) {
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "video key set to 0x%x\n",
pGlint->videoKey);
} else {
pGlint->videoKey = (1 << 16) |
(1 << 8) |
((pScrn->mask.blue - 1) << 0);
}
if (xf86ReturnOptValBool(pGlint->Options, OPTION_FBDEV, FALSE)) {
if (!FBDevProbed && !xf86LoadSubModule(pScrn, "fbdevhw"))
{
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "couldn't load fbdevHW module!\n");
return FALSE;
}
xf86LoaderReqSymLists(fbdevHWSymbols, NULL);
if (!fbdevHWInit(pScrn,NULL,xf86FindOptionValue(pGlint->pEnt->device->options,"fbdev")))
{
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "fbdevHWInit failed!\n");
return FALSE;
}
pGlint->FBDev = TRUE;
from = X_CONFIG;
pScrn->AdjustFrame = fbdevHWAdjustFrame;
pScrn->LeaveVT = fbdevHWLeaveVT;
pScrn->ValidMode = fbdevHWValidMode;
} else {
pGlint->FBDev = FALSE;
from = X_PROBED;
pScrn->AdjustFrame = GLINTAdjustFrame;
pScrn->LeaveVT = GLINTLeaveVT;
pScrn->ValidMode = GLINTValidMode;
}
xf86DrvMsg(pScrn->scrnIndex, from, "%s Linux framebuffer device\n",
pGlint->FBDev ? "Using" : "Not using");
pScrn->overlayFlags = 0;
from = X_DEFAULT;
if ((s = xf86GetOptValString(pGlint->Options, OPTION_OVERLAY))) {
if (!*s || !xf86NameCmp(s, "8,24") || !xf86NameCmp(s, "24,8")) {
Overlay = TRUE;
} else {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"\"%s\" is not a valid value for Option \"Overlay\"\n", s);
}
}
if (Overlay) {
if ((pScrn->depth == 24) && (pScrn->bitsPerPixel == 32)) {
pScrn->colorKey = 255;
pScrn->overlayFlags = OVERLAY_8_32_PLANAR;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "24/8 overlay enabled\n");
}
}
pGlint->DoubleBuffer = FALSE;
pGlint->RamDac = NULL;
pGlint->STATE = FALSE;
if (FBDevProbed) {
pScrn->chipset = "ti_pm2";
pGlint->Chipset = xf86StringToToken(GLINTChipsets, pScrn->chipset);
from = X_PROBED;
} else {
if (pGlint->pEnt->device->chipset && *pGlint->pEnt->device->chipset) {
pScrn->chipset = pGlint->pEnt->device->chipset;
pGlint->Chipset = xf86StringToToken(GLINTChipsets, pScrn->chipset);
from = X_CONFIG;
} else if (pGlint->pEnt->device->chipID >= 0) {
pGlint->Chipset = pGlint->pEnt->device->chipID;
pScrn->chipset = (char *)xf86TokenToString(GLINTChipsets,
pGlint->Chipset);
from = X_CONFIG;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipID override: 0x%04X\n",
pGlint->Chipset);
} else {
from = X_PROBED;
pGlint->Chipset = pGlint->PciInfo->vendor << 16 |
pGlint->PciInfo->chipType;
pScrn->chipset = (char *)xf86TokenToString(GLINTChipsets,
pGlint->Chipset);
}
if (pGlint->pEnt->device->chipRev >= 0) {
pGlint->ChipRev = pGlint->pEnt->device->chipRev;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipRev override: %d\n",
pGlint->ChipRev);
} else {
pGlint->ChipRev = pGlint->PciInfo->chipRev;
}
}
if (pScrn->chipset == NULL) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"ChipID 0x%04X is not recognised\n", pGlint->Chipset);
return FALSE;
}
if (pGlint->Chipset < 0) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Chipset \"%s\" is not recognised\n", pScrn->chipset);
return FALSE;
}
xf86DrvMsg(pScrn->scrnIndex, from, "Chipset: \"%s\"\n", pScrn->chipset);
if ((pGlint->Chipset == PCI_VENDOR_TI_CHIP_PERMEDIA2) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2)) {
if (xf86ReturnOptValBool(pGlint->Options, OPTION_BLOCK_WRITE, FALSE)) {
pGlint->UseBlockWrite = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Block Writes enabled\n");
}
}
if (xf86ReturnOptValBool(pGlint->Options, OPTION_FIREGL3000, FALSE)) {
pGlint->UseFireGL3000 = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
"Diamond FireGL3000 mode enabled\n");
}
if (!FBDevProbed) {
if (pGlint->pEnt->device->MemBase != 0) {
pGlint->FbAddress = pGlint->pEnt->device->MemBase;
from = X_CONFIG;
} else {
pGlint->FbAddress = pGlint->PciInfo->memBase[2] & 0xFF800000;
}
if (pGlint->FbAddress)
xf86DrvMsg(pScrn->scrnIndex, from, "Linear framebuffer at 0x%lX\n",
(unsigned long)pGlint->FbAddress);
if (pGlint->FbAddress == 0) {
if (pGlint->MultiPciInfo[0]->memBase[2]) {
pGlint->FbAddress = pGlint->MultiPciInfo[0]->memBase[2];
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"FrameBuffer used from first rasterizer chip at 0x%lx\n",
pGlint->MultiPciInfo[0]->memBase[2]);
} else {
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"No FrameBuffer memory - aborting\n");
return FALSE;
}
}
if (pGlint->pEnt->device->IOBase != 0) {
pGlint->IOAddress = pGlint->pEnt->device->IOBase;
from = X_CONFIG;
} else {
pGlint->IOAddress = pGlint->PciInfo->memBase[0] & 0xFFFFC000;
}
if ((IS_J2000) && (pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA)) {
if ((xf86IsEntityShared(pScrn->entityList[0])) &&
(xf86IsPrimInitDone(pScrn->entityList[0]))) {
pGlint->IOAddress += 0x10000;
pGlint->MultiIndex = 2;
} else {
xf86SetPrimInitDone(pScrn->entityList[0]);
pGlint->MultiIndex = 1;
}
#if X_BYTE_ORDER == X_BIG_ENDIAN
GLINT_SLOW_WRITE_REG(
GLINT_READ_REG(GCSRAperture) | GCSRBitSwap
, GCSRAperture);
} else {
pGlint->IOAddress += 0x10000;
#endif
}
xf86DrvMsg(pScrn->scrnIndex, from, "MMIO registers at 0x%lX\n",
(unsigned long)pGlint->IOAddress);
pGlint->irq = pGlint->pEnt->device->irq;
for (i = 0; i < pScrn->numEntities; i++) {
EntityInfoPtr pEnt;
pEnt = xf86GetEntityInfo(pScrn->entityList[i]);
if (xf86RegisterResources(pEnt->index, NULL, ResExclusive)) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"xf86RegisterResources() found resource conflicts\n");
return FALSE;
}
}
}
if (pGlint->Chipset != PCI_VENDOR_3DLABS_CHIP_GAMMA &&
pGlint->Chipset != PCI_VENDOR_3DLABS_CHIP_GAMMA2 &&
pGlint->Chipset != PCI_VENDOR_3DLABS_CHIP_DELTA &&
!xf86IsPrimaryPci(pGlint->PciInfo) && !pGlint->FBDev) {
if ( xf86LoadSubModule(pScrn, "int10")){
xf86Int10InfoPtr pInt;
xf86LoaderReqSymLists(GLINTint10Symbols, NULL);
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Initializing int10\n");
pInt = xf86InitInt10(pGlint->pEnt->index);
xf86FreeInt10(pInt);
}
}
pGlint->FbMapSize = 0;
{
GLINTMapMem(pScrn);
switch (pGlint->Chipset) {
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
Permedia3PreInit(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2VPreInit(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
Permedia2PreInit(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
switch (pGlint->MultiChip) {
case PCI_CHIP_PERMEDIA3:
Permedia3PreInit(pScrn);
break;
}
break;
case PCI_VENDOR_3DLABS_CHIP_DELTA:
{
int basecopro =
pGlint->MultiPciInfo[0]->memBase[0] & 0xFFFFC000;
int basedelta = pGlint->PciInfo->memBase[0] & 0xFFFFC000;
int glintdelta = pGlint->PciTag;
int glintcopro = pciTag(pGlint->MultiPciInfo[0]->bus,
pGlint->MultiPciInfo[0]->device,
pGlint->MultiPciInfo[0]->func);
int base3copro, offset;
if( (basedelta & 0x20000) ^ (basecopro & 0x20000) ) {
if ((pGlint->MultiChip == PCI_CHIP_PERMEDIA) ||
(pGlint->MultiChip == PCI_CHIP_TI_PERMEDIA)) {
offset = 0x20;
} else {
offset = 0x1c;
}
base3copro = pciReadLong(glintcopro, offset);
if( (basecopro & 0x20000) ^ (base3copro & 0x20000) ) {
base3copro += 0x20000;
}
(void) pciReadLong(glintdelta, 0x10);
pciWriteLong(glintdelta, 0x10, 0xffffffff);
(void) pciReadLong(glintdelta, 0x10);
pciWriteLong(glintdelta, 0x10, base3copro);
(void) pciReadLong(glintcopro, 0x30);
pciWriteLong(glintcopro, 0x30, 0xffffffff);
(void) pciReadLong(glintcopro, 0x30);
pciWriteLong(glintcopro, 0x30, 0);
pGlint->IOAddress =
pGlint->PciInfo->memBase[0] = base3copro;
xf86DrvMsg(pScrn->scrnIndex, from,
"Delta Bug - Changing MMIO registers to 0x%lX\n",
(unsigned long)pGlint->IOAddress);
}
}
break;
default:
break;
}
GLINTUnmapMem(pScrn);
}
pGlint->HwBpp = pScrn->bitsPerPixel;
pGlint->FbBase = NULL;
if (!FBDevProbed) {
if (pGlint->pEnt->device->videoRam != 0) {
pScrn->videoRam = pGlint->pEnt->device->videoRam;
from = X_CONFIG;
} else {
GLINTMapMem(pScrn);
switch (pGlint->Chipset) {
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_300SX:
case PCI_VENDOR_3DLABS_CHIP_MX:
pScrn->videoRam = (1 << ((GLINT_READ_REG(FBMemoryCtl) &
0xE0000000)>>29)) * 1024;
break;
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
pScrn->videoRam = (((GLINT_READ_REG(PMMemConfig) >> 29) &
0x03) + 1) * 2048;
break;
case PCI_VENDOR_3DLABS_CHIP_R4:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
pScrn->videoRam = Permedia3MemorySizeDetect(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_DELTA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
switch (pGlint->MultiChip) {
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Attached Rasterizer is GLINT Permedia\n");
pScrn->videoRam = (((GLINT_READ_REG(PMMemConfig)>>29) &
0x03) + 1) * 2048;
break;
case PCI_CHIP_300SX:
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Attached Rasterizer is GLINT 300SX\n");
pScrn->videoRam = (1 << ((GLINT_READ_REG(FBMemoryCtl) &
0xE0000000)>>29)) * 1024;
break;
case PCI_CHIP_500TX:
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Attached Rasterizer is GLINT 500TX\n");
pScrn->videoRam = (1 << ((GLINT_READ_REG(FBMemoryCtl) &
0xE0000000)>>29)) * 1024;
break;
case PCI_CHIP_MX:
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Attached Rasterizer is GLINT MX\n");
pScrn->videoRam =
(1 << ((GLINT_READ_REG(FBMemoryCtl) &
0xE0000000)>>29)) * 1024;
break;
case PCI_CHIP_PERMEDIA3:
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Attached Rasterizer is Permedia3\n");
pScrn->videoRam = Permedia3MemorySizeDetect(pScrn);
break;
case PCI_CHIP_R4:
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Attached Rasterizer is R4\n");
pScrn->videoRam = Permedia3MemorySizeDetect(pScrn);
break;
}
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Number of Rasterizers attached is %d\n",
pGlint->numMultiDevices);
break;
}
GLINTUnmapMem(pScrn);
}
} else {
pScrn->videoRam = fbdevHWGetVidmem(pScrn)/1024;
}
pGlint->FbMapSize = pScrn->videoRam * 1024;
pGlint->MultiAperture = FALSE;
if ( ((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA2)) &&
(pGlint->numMultiDevices == 2) ) {
CARD32 chipconfig;
CARD32 size = 0;
GLINTMapMem(pScrn);
(void) GLINT_READ_REG(GCSRAperture);
GLINT_SLOW_WRITE_REG(GCSRSecondaryGLINTMapEn, GCSRAperture);
chipconfig = GLINT_READ_REG(GChipConfig);
GLINT_SLOW_WRITE_REG(GCSRSecondaryGLINTMapEn, GCSRAperture);
GLINTUnmapMem(pScrn);
switch (chipconfig & GChipMultiGLINTApMask) {
case GChipMultiGLINTAp_0M:
size = 0;
break;
case GChipMultiGLINTAp_16M:
size = 16 * 1024 * 1024;
break;
case GChipMultiGLINTAp_32M:
size = 32 * 1024 * 1024;
break;
case GChipMultiGLINTAp_64M:
size = 64 * 1024 * 1024;
break;
}
if (size == 0) {
xf86DrvMsg(pScrn->scrnIndex, from, "MultiAperture: disabled\n");
} else {
xf86DrvMsg(pScrn->scrnIndex, from, "MultiAperture: enabled\n");
pGlint->FbMapSize = size;
pGlint->MultiAperture = TRUE;
}
}
xf86DrvMsg(pScrn->scrnIndex, from, "VideoRAM: %ld kByte\n",
pGlint->FbMapSize / 1024);
if (!xf86LoadSubModule(pScrn, "ramdac"))
return FALSE;
xf86LoaderReqSymLists(ramdacSymbols, NULL);
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
pGlint->FIFOSize = 256;
maxheight = 2048;
maxwidth = 2048;
pGlint->RefClock = 14318;
pGlint->RamDacRec = RamDacCreateInfoRec();
pGlint->RamDacRec->ReadDAC = Permedia2InIndReg;
pGlint->RamDacRec->WriteDAC = Permedia2OutIndReg;
pGlint->RamDacRec->ReadAddress = Permedia2ReadAddress;
pGlint->RamDacRec->WriteAddress = Permedia2WriteAddress;
pGlint->RamDacRec->ReadData = Permedia2ReadData;
pGlint->RamDacRec->WriteData = Permedia2WriteData;
if(!RamDacInit(pScrn, pGlint->RamDacRec)) {
RamDacDestroyInfoRec(pGlint->RamDacRec);
return FALSE;
}
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
pGlint->FIFOSize = 256;
maxheight = 2048;
maxwidth = 2048;
pGlint->RefClock = 14318;
pGlint->RamDacRec = RamDacCreateInfoRec();
pGlint->RamDacRec->ReadDAC = Permedia2vInIndReg;
pGlint->RamDacRec->WriteDAC = Permedia2vOutIndReg;
pGlint->RamDacRec->ReadAddress = Permedia2ReadAddress;
pGlint->RamDacRec->WriteAddress = Permedia2WriteAddress;
pGlint->RamDacRec->ReadData = Permedia2ReadData;
pGlint->RamDacRec->WriteData = Permedia2WriteData;
if(!RamDacInit(pScrn, pGlint->RamDacRec)) {
RamDacDestroyInfoRec(pGlint->RamDacRec);
return FALSE;
}
break;
case PCI_VENDOR_3DLABS_CHIP_R4:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
if (pScrn->bitsPerPixel == 24) {
xf86DrvMsg(pScrn->scrnIndex, from,
"-depth 24 -pixmap24 not supported by this chip.\n");
return FALSE;
}
pGlint->FIFOSize = 120;
maxheight = 4096;
maxwidth = 4096;
pGlint->RefClock = 14318;
pGlint->RamDacRec = RamDacCreateInfoRec();
pGlint->RamDacRec->ReadDAC = Permedia2vInIndReg;
pGlint->RamDacRec->WriteDAC = Permedia2vOutIndReg;
pGlint->RamDacRec->ReadAddress = Permedia2ReadAddress;
pGlint->RamDacRec->WriteAddress = Permedia2WriteAddress;
pGlint->RamDacRec->ReadData = Permedia2ReadData;
pGlint->RamDacRec->WriteData = Permedia2WriteData;
if(!RamDacInit(pScrn, pGlint->RamDacRec)) {
RamDacDestroyInfoRec(pGlint->RamDacRec);
return FALSE;
}
break;
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
pGlint->FIFOSize = 31;
maxheight = 1024;
maxwidth = 1536;
if (!pGlint->RamDac) {
GLINTProbeTIramdac(pScrn);
if (pGlint->RamDac)
if (pGlint->RamDac->RamDacType == (TI3026_RAMDAC))
pGlint->RefClock = 14318;
}
if (!pGlint->RamDac) {
GLINTProbeIBMramdac(pScrn);
if (pGlint->RamDac) {
if (pGlint->RamDac->RamDacType == (IBM526DB_RAMDAC) ||
pGlint->RamDac->RamDacType == (IBM526_RAMDAC))
pGlint->RefClock = 14318;
}
}
if (!pGlint->RamDac)
return FALSE;
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_300SX:
case PCI_VENDOR_3DLABS_CHIP_MX:
pGlint->FIFOSize = 15;
if (pScrn->bitsPerPixel == 24) {
xf86DrvMsg(pScrn->scrnIndex, from,
"-depth 24 -pixmap24 not supported by this chip.\n");
return FALSE;
}
maxheight = 4096;
maxwidth = 4096;
if (!pGlint->RamDac) {
GLINTProbeTIramdac(pScrn);
if (pGlint->RamDac)
if ( (pGlint->RamDac->RamDacType == (TI3026_RAMDAC)) ||
(pGlint->RamDac->RamDacType == (TI3030_RAMDAC)) )
pGlint->RefClock = 14318;
}
if (!pGlint->RamDac) {
GLINTProbeIBMramdac(pScrn);
if (pGlint->RamDac) {
if (pGlint->RamDac->RamDacType == (IBM640_RAMDAC))
pGlint->RefClock = 28322;
else
if (pGlint->RamDac->RamDacType == (IBM526DB_RAMDAC) ||
pGlint->RamDac->RamDacType == (IBM526_RAMDAC))
pGlint->RefClock = 40000;
}
}
if (!pGlint->RamDac)
return FALSE;
break;
case PCI_VENDOR_3DLABS_CHIP_DELTA:
pGlint->FIFOSize = 15;
switch (pGlint->MultiChip) {
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
maxheight = 1024;
maxwidth = 1536;
if (!pGlint->RamDac) {
GLINTProbeTIramdac(pScrn);
if (pGlint->RamDac)
if (pGlint->RamDac->RamDacType == (TI3026_RAMDAC))
pGlint->RefClock = 14318;
}
if (!pGlint->RamDac) {
GLINTProbeIBMramdac(pScrn);
if (pGlint->RamDac) {
if (pGlint->RamDac->RamDacType == (IBM526DB_RAMDAC) ||
pGlint->RamDac->RamDacType == (IBM526_RAMDAC))
pGlint->RefClock = 14318;
}
}
if (!pGlint->RamDac)
return FALSE;
break;
case PCI_CHIP_500TX:
case PCI_CHIP_300SX:
case PCI_CHIP_MX:
if (pScrn->bitsPerPixel == 24) {
xf86DrvMsg(pScrn->scrnIndex, from,
"-depth 24 -pixmap24 not supported by this chip.\n");
return FALSE;
}
maxheight = 4096;
maxwidth = 4096;
if (!pGlint->RamDac) {
GLINTProbeTIramdac(pScrn);
if (pGlint->RamDac)
if ( (pGlint->RamDac->RamDacType == (TI3026_RAMDAC)) ||
(pGlint->RamDac->RamDacType == (TI3030_RAMDAC)) )
pGlint->RefClock = 14318;
}
if (!pGlint->RamDac) {
GLINTProbeIBMramdac(pScrn);
if (pGlint->RamDac) {
if (pGlint->RamDac->RamDacType == (IBM640_RAMDAC) ||
pGlint->RamDac->RamDacType == (IBM526DB_RAMDAC) ||
pGlint->RamDac->RamDacType == (IBM526_RAMDAC))
pGlint->RefClock = 40000;
}
}
break;
}
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
pGlint->FIFOSize = 32;
if (pScrn->bitsPerPixel == 24) {
xf86DrvMsg(pScrn->scrnIndex, from,
"-depth 24 -pixmap24 not supported by this chip.\n");
return FALSE;
}
maxheight = 4096;
maxwidth = 4096;
if (IS_J2000) {
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Appian Jeronimo 2000 board detected\n");
pGlint->RefClock = 14318;
pGlint->RamDacRec = RamDacCreateInfoRec();
pGlint->RamDacRec->ReadDAC = Permedia2vInIndReg;
pGlint->RamDacRec->WriteDAC = Permedia2vOutIndReg;
pGlint->RamDacRec->ReadAddress = Permedia2ReadAddress;
pGlint->RamDacRec->WriteAddress = Permedia2WriteAddress;
pGlint->RamDacRec->ReadData = Permedia2ReadData;
pGlint->RamDacRec->WriteData = Permedia2WriteData;
if(!RamDacInit(pScrn, pGlint->RamDacRec)) {
RamDacDestroyInfoRec(pGlint->RamDacRec);
return FALSE;
}
break;
}
if (IS_GMX2000) {
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"3DLabs GMX2000 board detected\n");
ACCESSCHIP2();
GLINTProbeTIramdac(pScrn);
ACCESSCHIP1();
pGlint->RamDacRec->ReadDAC = GMX2000InIndReg;
pGlint->RamDacRec->WriteDAC = GMX2000OutIndReg;
pGlint->RamDacRec->ReadAddress = GMX2000ReadAddress;
pGlint->RamDacRec->WriteAddress = GMX2000WriteAddress;
pGlint->RamDacRec->ReadData = GMX2000ReadData;
pGlint->RamDacRec->WriteData = GMX2000WriteData;
pGlint->RefClock = 14318;
break;
}
if (!pGlint->RamDac) {
GLINTProbeTIramdac(pScrn);
if (pGlint->RamDac)
if ( (pGlint->RamDac->RamDacType == (TI3026_RAMDAC)) ||
(pGlint->RamDac->RamDacType == (TI3030_RAMDAC)) )
pGlint->RefClock = 14318;
}
if (!pGlint->RamDac) {
GLINTProbeIBMramdac(pScrn);
if (pGlint->RamDac) {
if (pGlint->RamDac->RamDacType == (IBM640_RAMDAC))
pGlint->RefClock = 28322;
else
if (pGlint->RamDac->RamDacType == (IBM526DB_RAMDAC) ||
pGlint->RamDac->RamDacType == (IBM526_RAMDAC))
pGlint->RefClock = 40000;
}
}
if (!pGlint->RamDac) {
if ((pGlint->MultiChip == PCI_CHIP_PERMEDIA3) ||
(pGlint->MultiChip == PCI_CHIP_R4)) {
pGlint->RefClock = 14318;
pGlint->RamDacRec = RamDacCreateInfoRec();
pGlint->RamDacRec->ReadDAC = Permedia2vInIndReg;
pGlint->RamDacRec->WriteDAC = Permedia2vOutIndReg;
pGlint->RamDacRec->ReadAddress = Permedia2ReadAddress;
pGlint->RamDacRec->WriteAddress = Permedia2WriteAddress;
pGlint->RamDacRec->ReadData = Permedia2ReadData;
pGlint->RamDacRec->WriteData = Permedia2WriteData;
}
if(!RamDacInit(pScrn, pGlint->RamDacRec)) {
RamDacDestroyInfoRec(pGlint->RamDacRec);
return FALSE;
}
} else
if (!pGlint->RamDac)
return FALSE;
break;
}
if ( pGlint->RamDac &&
(pGlint->RamDac->RamDacType != (IBM640_RAMDAC)) &&
(pScrn->depth == 30) )
{
xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
"Depth 30 not supported for this chip\n");
return FALSE;
}
if (pGlint->FIFOSize)
xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "FIFO Size is %d DWORDS\n",
pGlint->FIFOSize);
pGlint->MinClock = 16250;
xf86DrvMsg(pScrn->scrnIndex, X_DEFAULT, "Min pixel clock is %d MHz\n",
pGlint->MinClock / 1000);
if (pGlint->pEnt->device->dacSpeeds[0]) {
int speed = 0;
switch (pScrn->bitsPerPixel) {
case 8:
speed = pGlint->pEnt->device->dacSpeeds[DAC_BPP8];
break;
case 16:
speed = pGlint->pEnt->device->dacSpeeds[DAC_BPP16];
break;
case 24:
speed = pGlint->pEnt->device->dacSpeeds[DAC_BPP24];
break;
case 32:
speed = pGlint->pEnt->device->dacSpeeds[DAC_BPP32];
break;
}
if (speed == 0)
pGlint->MaxClock = pGlint->pEnt->device->dacSpeeds[0];
else
pGlint->MaxClock = speed;
from = X_CONFIG;
} else {
if((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_500TX)||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_300SX) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_MX) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_300SX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_500TX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_MX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) &&
(pGlint->MultiChip == PCI_CHIP_MX)) )
pGlint->MaxClock = 220000;
if ( (pGlint->Chipset == PCI_VENDOR_TI_CHIP_PERMEDIA) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
((pGlint->MultiChip == PCI_CHIP_PERMEDIA) ||
(pGlint->MultiChip == PCI_CHIP_TI_PERMEDIA))) ) {
switch (pScrn->bitsPerPixel) {
case 8:
pGlint->MaxClock = 200000;
break;
case 16:
pGlint->MaxClock = 100000;
break;
case 24:
pGlint->MaxClock = 50000;
break;
case 32:
pGlint->MaxClock = 50000;
break;
}
}
if ( (pGlint->Chipset == PCI_VENDOR_TI_CHIP_PERMEDIA2) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V) ) {
switch (pScrn->bitsPerPixel) {
case 8:
pGlint->MaxClock = 230000;
break;
case 16:
pGlint->MaxClock = 230000;
break;
case 24:
pGlint->MaxClock = 150000;
break;
case 32:
pGlint->MaxClock = 110000;
break;
}
}
if ((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA3) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA4) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_R4) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA2) &&
(pGlint->MultiChip == PCI_CHIP_R4)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) &&
(pGlint->MultiChip == PCI_CHIP_PERMEDIA3)) )
pGlint->MaxClock = 300000;
}
xf86DrvMsg(pScrn->scrnIndex, from, "Max pixel clock is %d MHz\n",
pGlint->MaxClock / 1000);
clockRanges = xnfcalloc(sizeof(ClockRange), 1);
clockRanges->next = NULL;
clockRanges->minClock = pGlint->MinClock;
clockRanges->maxClock = pGlint->MaxClock;
clockRanges->clockIndex = -1;
clockRanges->interlaceAllowed = FALSE;
clockRanges->doubleScanAllowed = FALSE;
if ((pGlint->NoAccel) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA3) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA4) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_R4) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA2) &&
(pGlint->MultiChip == PCI_CHIP_R4)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) &&
(pGlint->MultiChip == PCI_CHIP_PERMEDIA3)) ) {
i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
pScrn->display->modes, clockRanges,
NULL, 256, maxwidth,
pScrn->bitsPerPixel, 128, maxheight,
pScrn->display->virtualX,
pScrn->display->virtualY,
pGlint->FbMapSize,
LOOKUP_BEST_REFRESH);
} else {
i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
pScrn->display->modes, clockRanges,
GetAccelPitchValues(pScrn), 32, maxwidth,
pScrn->bitsPerPixel, 128, maxheight,
pScrn->display->virtualX,
pScrn->display->virtualY,
pGlint->FbMapSize,
LOOKUP_BEST_REFRESH);
}
if (i < 1 && pGlint->FBDev) {
fbdevHWUseBuildinMode(pScrn);
i = 1;
}
if (i == -1) {
GLINTFreeRec(pScrn);
return FALSE;
}
if (i == 0 || pScrn->modes == NULL) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
GLINTFreeRec(pScrn);
return FALSE;
}
if (pGlint->FBDev) {
switch (pScrn->bitsPerPixel) {
case 8:
pGlint->BppShift = 2;
break;
case 16:
if (pGlint->DoubleBuffer) {
pGlint->BppShift = 0;
} else {
pGlint->BppShift = 1;
}
break;
case 24:
pGlint->BppShift = 2;
break;
case 32:
pGlint->BppShift = 0;
break;
}
pScrn->displayWidth = pScrn->virtualX;
if (pGlint->HWCursor) {
DisplayModePtr mode, first = mode = pScrn->modes;
do {
mode->Flags |= V_PHSYNC | V_PVSYNC;
mode->Flags &= ~V_NHSYNC | ~V_NVSYNC;
mode = mode->next;
} while (mode != NULL && mode != first);
}
}
xf86PruneDriverModes(pScrn);
if ((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_500TX) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_300SX) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_MX) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_300SX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_500TX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_DELTA) &&
(pGlint->MultiChip == PCI_CHIP_MX)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) &&
(pGlint->MultiChip == PCI_CHIP_MX)) ) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"This GLINT chip only supports one modeline, using first\n");
pScrn->modes->next = NULL;
pScrn->virtualX = pScrn->modes->HDisplay;
pScrn->virtualY = pScrn->modes->VDisplay;
pScrn->displayWidth = pScrn->virtualX;
if (partprod500TX[pScrn->displayWidth >> 5] == -1) {
i = -1;
do {
pScrn->displayWidth += 32;
i = partprod500TX[pScrn->displayWidth >> 5];
} while (i == -1);
}
}
if (pScrn->virtualX > maxwidth) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"GLINTModeInit: virtual width (%d) too big for hardware\n",
pScrn->virtualX);
return FALSE;
}
if (pScrn->virtualY > maxheight) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"GLINTModeInit: virtual height (%d) too big for hardware\n",
pScrn->virtualY);
return FALSE;
}
switch (pGlint->Chipset)
{
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
pGlint->pprod = partprodPermedia[pScrn->displayWidth >> 5];
pGlint->bppalign = bppand[(pScrn->bitsPerPixel>>3)-1];
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_MX:
case PCI_VENDOR_3DLABS_CHIP_300SX:
pGlint->pprod = partprod500TX[pScrn->displayWidth >> 5];
pGlint->bppalign = 0;
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_MX:
case PCI_CHIP_500TX:
case PCI_CHIP_300SX:
pGlint->pprod = partprod500TX[pScrn->displayWidth >> 5];
pGlint->bppalign = 0;
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
pGlint->pprod = partprodPermedia[pScrn->displayWidth >> 5];
pGlint->bppalign = bppand[(pScrn->bitsPerPixel>>3)-1];
break;
}
break;
}
if ( ((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA2)) &&
(pGlint->numMultiDevices == 2) ) {
int bytesPerPixel, realWidthBytes, inputXSpanBytes;
CARD32 postMultiply, productEnable, use16xProduct, inputXSpan;
CARD32 binaryEval, glintApSize;
bytesPerPixel = (pScrn->bitsPerPixel >> 3);
realWidthBytes = pScrn->displayWidth * bytesPerPixel;
binaryEval = ((realWidthBytes << 1) - 1);
if (binaryEval & (8 << 10)) {
inputXSpan = 3;
inputXSpanBytes = 8 * 1024;
}
else if (binaryEval & (4 << 10)) {
inputXSpan = 2;
inputXSpanBytes = 4 * 1024;
}
else if (binaryEval & (2 << 10)) {
inputXSpan = 1;
inputXSpanBytes = 2 * 1024;
}
else {
inputXSpan = 0;
inputXSpanBytes = 1024;
}
binaryEval = realWidthBytes >> 3;
postMultiply = 0;
while ((postMultiply < 5) && !(binaryEval & 1)) {
postMultiply++;
binaryEval >>= 1;
}
postMultiply <<= 7;
if (binaryEval & ~0x1f) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"GLINTModeInit: width (%d) too big\n",
pScrn->displayWidth);
return FALSE;
}
if ((binaryEval & 0x12) == 0x12) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"GLINTModeInit: width (%d) is mult 18, not supported\n",
pScrn->displayWidth);
return FALSE;
}
if (binaryEval & 0x10) {
productEnable = (((binaryEval & 0xf) | 0x2) << 3);
use16xProduct = (1 << 2);
}
else {
productEnable = ((binaryEval & 0xf) << 3);
use16xProduct = 0;
}
binaryEval = ((pScrn->videoRam << 11) - 1);
if (binaryEval & (32 << 20)) {
glintApSize = 3 << 10;
}
else if (binaryEval & (16 << 20)) {
glintApSize = 2 << 10;
}
else if (binaryEval & (8 << 20)) {
glintApSize = 1 << 10;
}
else {
glintApSize = 0 << 10;
}
pGlint->realWidth = ( glintApSize |
postMultiply |
productEnable |
use16xProduct |
inputXSpan );
pScrn->displayWidth = inputXSpanBytes / bytesPerPixel;
}
pScrn->currentMode = pScrn->modes;
xf86SetCrtcForModes(pScrn, INTERLACE_HALVE_V);
xf86PrintModes(pScrn);
xf86SetDpi(pScrn, 0, 0);
switch (pScrn->bitsPerPixel) {
case 8:
case 16:
case 24:
mod = "fb";
syms = fbSymbols;
break;
case 32:
if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR) {
mod = "xf8_32bpp";
syms = xf8_32bppSymbols;
} else {
mod = "fb";
syms = fbSymbols;
}
break;
}
if (mod && xf86LoadSubModule(pScrn, mod) == NULL) {
GLINTFreeRec(pScrn);
return FALSE;
}
if (mod && syms) {
xf86LoaderReqSymLists(syms, NULL);
}
if (!pGlint->NoAccel) {
if (!xf86LoadSubModule(pScrn, "xaa")) {
GLINTFreeRec(pScrn);
return FALSE;
}
xf86LoaderReqSymLists(xaaSymbols, NULL);
}
if (pGlint->ShadowFB) {
if (!xf86LoadSubModule(pScrn, "shadowfb")) {
GLINTFreeRec(pScrn);
return FALSE;
}
xf86LoaderReqSymLists(shadowSymbols, NULL);
}
if (!xf86LoadSubModule(pScrn, "ddc")) {
GLINTFreeRec(pScrn);
return FALSE;
}
xf86LoaderReqSymLists(ddcSymbols, NULL);
if ((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA3) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA4) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_R4) ||
(pGlint->Chipset == PCI_VENDOR_TI_CHIP_PERMEDIA2)) {
if (xf86LoadSubModule(pScrn, "i2c")) {
I2CBusPtr pBus;
xf86LoaderReqSymLists(i2cSymbols, NULL);
if ((pBus = xf86CreateI2CBusRec())) {
pBus->BusName = "DDC";
pBus->scrnIndex = pScrn->scrnIndex;
pBus->I2CUDelay = Permedia2I2CUDelay;
pBus->I2CPutBits = Permedia2I2CPutBits;
pBus->I2CGetBits = Permedia2I2CGetBits;
pBus->DriverPrivate.ptr = pGlint;
if (!xf86I2CBusInit(pBus)) {
xf86DestroyI2CBusRec(pBus, TRUE, TRUE);
} else
pGlint->DDCBus = pBus;
}
if ((pBus = xf86CreateI2CBusRec())) {
pBus->BusName = "Video";
pBus->scrnIndex = pScrn->scrnIndex;
pBus->I2CUDelay = Permedia2I2CUDelay;
pBus->I2CPutBits = Permedia2I2CPutBits;
pBus->I2CGetBits = Permedia2I2CGetBits;
pBus->DriverPrivate.ptr = pGlint;
if (!xf86I2CBusInit(pBus)) {
xf86DestroyI2CBusRec(pBus, TRUE, TRUE);
} else
pGlint->VSBus = pBus;
}
}
}
TRACE_EXIT("GLINTPreInit");
return TRUE;
}
static Bool
GLINTMapMem(ScrnInfoPtr pScrn)
{
GLINTPtr pGlint;
pGlint = GLINTPTR(pScrn);
TRACE_ENTER("GLINTMapMem");
if (pGlint->FBDev) {
pGlint->FbBase = fbdevHWMapVidmem(pScrn);
if (pGlint->FbBase == NULL)
return FALSE;
pGlint->IOBase = fbdevHWMapMMIO(pScrn);
if (pGlint->IOBase == NULL)
return FALSE;
TRACE_EXIT("GLINTMapMem");
return TRUE;
}
pGlint->IOBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_MMIO_32BIT,
pGlint->PciTag, pGlint->IOAddress, 0x20000);
if (pGlint->IOBase == NULL)
return FALSE;
if (pGlint->FbMapSize != 0) {
pGlint->FbBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_FRAMEBUFFER,
pGlint->PciTag,
pGlint->FbAddress,
pGlint->FbMapSize);
if (pGlint->FbBase == NULL)
return FALSE;
}
TRACE_EXIT("GLINTMapMem");
return TRUE;
}
static Bool
GLINTUnmapMem(ScrnInfoPtr pScrn)
{
GLINTPtr pGlint;
pGlint = GLINTPTR(pScrn);
TRACE_ENTER("GLINTUnmapMem");
if (pGlint->FBDev) {
fbdevHWUnmapVidmem(pScrn);
pGlint->FbBase = NULL;
fbdevHWUnmapMMIO(pScrn);
pGlint->IOBase = NULL;
TRACE_EXIT("GLINTUnmapMem");
return TRUE;
}
xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pGlint->IOBase, 0x20000);
pGlint->IOBase = NULL;
if (pGlint->FbBase != NULL)
xf86UnMapVidMem(pScrn->scrnIndex, (pointer)pGlint->FbBase, pGlint->FbMapSize);
pGlint->FbBase = NULL;
TRACE_EXIT("GLINTUnmapMem");
return TRUE;
}
static void
GLINTSave(ScrnInfoPtr pScrn)
{
GLINTPtr pGlint;
GLINTRegPtr glintReg;
GLINTRegPtr glintReg2;
RamDacHWRecPtr pRAMDAC;
RamDacRegRecPtr RAMDACreg;
pGlint = GLINTPTR(pScrn);
pRAMDAC = RAMDACHWPTR(pScrn);
glintReg = &pGlint->SavedReg[0];
glintReg2 = &pGlint->SavedReg[1];
RAMDACreg = &pRAMDAC->SavedReg;
TRACE_ENTER("GLINTSave");
switch (pGlint->Chipset)
{
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
Permedia2Save(pScrn, glintReg);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2VSave(pScrn, glintReg);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
Permedia3Save(pScrn, glintReg);
break;
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
PermediaSave(pScrn, glintReg);
(*pGlint->RamDac->Save)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_300SX:
case PCI_VENDOR_3DLABS_CHIP_MX:
TXSave(pScrn, glintReg);
(*pGlint->RamDac->Save)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_500TX:
case PCI_CHIP_300SX:
case PCI_CHIP_MX:
if (pGlint->numMultiDevices == 2) {
ACCESSCHIP2()
TXSave(pScrn, glintReg2);
#if 0
(*pGlint->RamDac->Save)(pScrn, pGlint->RamDacRec, RAMDACreg2);
#endif
ACCESSCHIP1();
}
TXSave(pScrn, glintReg);
(*pGlint->RamDac->Save)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
PermediaSave(pScrn, glintReg);
(*pGlint->RamDac->Save)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
if (pGlint->numMultiDevices == 2) {
ACCESSCHIP2();
Permedia3Save(pScrn, glintReg2);
ACCESSCHIP1();
}
Permedia3Save(pScrn, glintReg);
break;
}
break;
}
TRACE_EXIT("GLINTSave");
}
static Bool
GLINTModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
int ret = -1;
GLINTPtr pGlint = GLINTPTR(pScrn);
RamDacHWRecPtr pRAMDAC = RAMDACHWPTR(pScrn);
RamDacRegRecPtr RAMDACreg;
GLINTRegPtr glintReg = &pGlint->ModeReg[0];
GLINTRegPtr glintReg2 = &pGlint->ModeReg[1];
pScrn->vtSema = TRUE;
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
ret = Permedia2Init(pScrn, mode);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
ret = Permedia2VInit(pScrn, mode);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
ret = Permedia3Init(pScrn, mode, glintReg);
break;
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
ret = PermediaInit(pScrn, mode);
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_300SX:
case PCI_VENDOR_3DLABS_CHIP_MX:
ret = TXInit(pScrn, mode, glintReg);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_MX:
case PCI_CHIP_500TX:
case PCI_CHIP_300SX:
if (pGlint->numMultiDevices == 2) {
ACCESSCHIP2();
ret = TXInit(pScrn, mode, glintReg2);
ACCESSCHIP1();
}
ret = TXInit(pScrn, mode, glintReg);
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
ret = PermediaInit(pScrn, mode);
break;
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
if (pGlint->numMultiDevices == 2) {
ACCESSCHIP2();
ret = Permedia3Init(pScrn, mode, glintReg2);
ACCESSCHIP1();
}
ret = Permedia3Init(pScrn, mode, glintReg);
break;
}
break;
}
if (!ret)
return FALSE;
glintReg = &pGlint->ModeReg[0];
glintReg2 = &pGlint->ModeReg[1];
RAMDACreg = &pRAMDAC->ModeReg;
pGlint->STATE = FALSE;
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
Permedia2Restore(pScrn, glintReg);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2VRestore(pScrn, glintReg);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
Permedia3Restore(pScrn, glintReg);
break;
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
PermediaRestore(pScrn, glintReg);
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_300SX:
case PCI_VENDOR_3DLABS_CHIP_MX:
TXRestore(pScrn, glintReg);
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_500TX:
case PCI_CHIP_300SX:
case PCI_CHIP_MX:
if (pGlint->numMultiDevices == 2) {
ACCESSCHIP2();
TXRestore(pScrn, glintReg2);
#if 0
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec,RAMDACreg2);
#endif
ACCESSCHIP1();
}
TXRestore(pScrn, glintReg);
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
PermediaRestore(pScrn, glintReg);
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
if (pGlint->numMultiDevices == 2) {
ACCESSCHIP2();
Permedia3Restore(pScrn, glintReg2);
ACCESSCHIP1();
}
Permedia3Restore(pScrn, glintReg);
break;
}
break;
}
if (xf86IsPc98())
outb(0xfac, 0x01);
return TRUE;
}
static void
GLINTRestore(ScrnInfoPtr pScrn)
{
GLINTPtr pGlint;
GLINTRegPtr glintReg;
GLINTRegPtr glintReg2;
RamDacHWRecPtr pRAMDAC;
RamDacRegRecPtr RAMDACreg;
pGlint = GLINTPTR(pScrn);
pRAMDAC = RAMDACHWPTR(pScrn);
glintReg = &pGlint->SavedReg[0];
glintReg2 = &pGlint->SavedReg[1];
RAMDACreg = &pRAMDAC->SavedReg;
TRACE_ENTER("GLINTRestore");
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
Permedia2VideoLeaveVT(pScrn);
Permedia2Restore(pScrn, glintReg);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2VideoLeaveVT(pScrn);
Permedia2VRestore(pScrn, glintReg);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
Permedia3Restore(pScrn, glintReg);
break;
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
PermediaRestore(pScrn, glintReg);
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_300SX:
case PCI_VENDOR_3DLABS_CHIP_MX:
TXRestore(pScrn, glintReg);
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_MX:
case PCI_CHIP_500TX:
case PCI_CHIP_300SX:
if (pGlint->numMultiDevices == 2) {
ACCESSCHIP2();
TXRestore(pScrn, glintReg2);
#if 0
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec,RAMDACreg2);
#endif
ACCESSCHIP1();
}
TXRestore(pScrn, glintReg);
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
PermediaRestore(pScrn, glintReg);
(*pGlint->RamDac->Restore)(pScrn, pGlint->RamDacRec, RAMDACreg);
break;
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
if (pGlint->numMultiDevices == 2) {
ACCESSCHIP2();
Permedia3Restore(pScrn, glintReg2);
ACCESSCHIP1();
}
Permedia3Restore(pScrn, glintReg);
break;
}
break;
}
TRACE_EXIT("GLINTRestore");
}
static Bool
GLINTScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
{
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
GLINTPtr pGlint = GLINTPTR(pScrn);
int ret, displayWidth;
int init_picture = 0;
unsigned char *FBStart;
VisualPtr visual;
TRACE_ENTER("GLINTScreenInit");
if (!GLINTMapMem(pScrn))
return FALSE;
if (pGlint->FBDev) {
fbdevHWSave(pScrn);
if (!fbdevHWModeInit(pScrn, pScrn->currentMode)) {
xf86DrvMsg(scrnIndex, X_ERROR,
"Internal error: invalid mode\n");
return FALSE;
}
} else
GLINTSave(pScrn);
{
xf86MonPtr pMon = NULL;
if (pGlint->DDCBus)
pMon = xf86DoEDID_DDC2(pScrn->scrnIndex, pGlint->DDCBus);
if (!pMon)
;
xf86SetDDCproperties(pScrn,xf86PrintEDID(pMon));
}
if ( (!pGlint->FBDev) && !(GLINTModeInit(pScrn, pScrn->currentMode))) {
xf86DrvMsg(scrnIndex, X_ERROR,
"Internal error: invalid mode\n");
return FALSE;
}
GLINTSaveScreen(pScreen, SCREEN_SAVER_ON);
GLINTAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
miClearVisualTypes();
if((pScrn->overlayFlags & OVERLAY_8_32_PLANAR) &&
(pScrn->bitsPerPixel == 32)) {
if (!miSetVisualTypes(8, PseudoColorMask | GrayScaleMask,
pScrn->rgbBits, PseudoColor))
return FALSE;
if (!miSetVisualTypes(24, TrueColorMask, pScrn->rgbBits, TrueColor))
return FALSE;
} else {
if (!miSetVisualTypes(pScrn->depth,
miGetDefaultVisualMask(pScrn->depth),
pScrn->rgbBits, pScrn->defaultVisual))
return FALSE;
if (!miSetPixmapDepths())
return FALSE;
}
#ifdef XF86DRI
if (!pGlint->NoAccel && pGlint->HWCursor) {
pGlint->directRenderingEnabled = GLINTDRIScreenInit(pScreen);
} else {
pGlint->directRenderingEnabled = FALSE;
}
#endif
if(pGlint->ShadowFB) {
pGlint->ShadowPitch = BitmapBytePad(pScrn->bitsPerPixel * pScrn->virtualX);
pGlint->ShadowPtr = xalloc(pGlint->ShadowPitch * pScrn->virtualY);
displayWidth = pGlint->ShadowPitch / (pScrn->bitsPerPixel >> 3);
FBStart = pGlint->ShadowPtr;
} else {
pGlint->ShadowPtr = NULL;
displayWidth = pScrn->displayWidth;
FBStart = pGlint->FbBase;
}
switch (pScrn->bitsPerPixel) {
case 8:
case 16:
case 24:
ret = fbScreenInit(pScreen, FBStart,
pScrn->virtualX, pScrn->virtualY,
pScrn->xDpi, pScrn->yDpi,
displayWidth, pScrn->bitsPerPixel);
init_picture = 1;
break;
case 32:
if(pScrn->overlayFlags & OVERLAY_8_32_PLANAR)
ret = cfb8_32ScreenInit(pScreen, FBStart,
pScrn->virtualX, pScrn->virtualY,
pScrn->xDpi, pScrn->yDpi,
displayWidth);
else {
ret = fbScreenInit(pScreen, FBStart,
pScrn->virtualX, pScrn->virtualY,
pScrn->xDpi, pScrn->yDpi,
displayWidth, pScrn->bitsPerPixel);
init_picture = 1;
}
break;
default:
xf86DrvMsg(scrnIndex, X_ERROR,
"Internal error: invalid bpp (%d) in GLINTScrnInit\n",
pScrn->bitsPerPixel);
ret = FALSE;
break;
}
if (!ret)
return FALSE;
xf86SetBlackWhitePixels(pScreen);
pGlint->BlockHandler = pScreen->BlockHandler;
pScreen->BlockHandler = GLINTBlockHandler;
#if !defined(__sparc__)
if (!pGlint->ShadowFB)
GLINTDGAInit(pScreen);
#endif
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 (init_picture)
fbPictureInit(pScreen, 0, 0);
if (!pGlint->NoAccel) {
switch (pGlint->Chipset)
{
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2AccelInit(pScreen);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
Permedia3AccelInit(pScreen);
break;
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
PermediaAccelInit(pScreen);
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_MX:
TXAccelInit(pScreen);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_500TX:
case PCI_CHIP_MX:
TXAccelInit(pScreen);
break;
case PCI_CHIP_300SX:
SXAccelInit(pScreen);
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
PermediaAccelInit(pScreen);
break;
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
Permedia3AccelInit(pScreen);
break;
}
break;
case PCI_VENDOR_3DLABS_CHIP_300SX:
SXAccelInit(pScreen);
break;
}
}
miInitializeBackingStore(pScreen);
xf86SetBackingStore(pScreen);
xf86SetSilkenMouse(pScreen);
miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
if (pGlint->HWCursor) {
if ((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2) ||
(pGlint->Chipset == PCI_VENDOR_TI_CHIP_PERMEDIA2))
Permedia2HWCursorInit(pScreen);
else
if ((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA3) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA4) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_R4) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA2) &&
(pGlint->MultiChip == PCI_CHIP_R4)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) &&
(pGlint->MultiChip == PCI_CHIP_PERMEDIA3)) )
Permedia2vHWCursorInit(pScreen);
else
if ( ((pGlint->RamDac->RamDacType == (IBM526DB_RAMDAC)) ||
(pGlint->RamDac->RamDacType == (IBM526_RAMDAC)) ||
(pGlint->RamDac->RamDacType == (IBM640_RAMDAC))) )
glintIBMHWCursorInit(pScreen);
else
if ( (pGlint->RamDac->RamDacType == (TI3030_RAMDAC)) ||
(pGlint->RamDac->RamDacType == (TI3026_RAMDAC)) )
glintTIHWCursorInit(pScreen);
}
if (!miCreateDefColormap(pScreen))
return FALSE;
if ((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA3) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA4) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_R4) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA2) &&
(pGlint->MultiChip == PCI_CHIP_R4)) ||
((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_GAMMA) &&
(pGlint->MultiChip == PCI_CHIP_PERMEDIA3)) ) {
if (!xf86HandleColormaps(pScreen, 256, pScrn->rgbBits,
(pGlint->FBDev) ? fbdevHWLoadPalette :
((pScrn->depth == 16) ? Permedia3LoadPalette16:Permedia3LoadPalette),
NULL,
CMAP_RELOAD_ON_MODE_SWITCH |
((pScrn->overlayFlags & OVERLAY_8_32_PLANAR)
? 0 : CMAP_PALETTED_TRUECOLOR)))
return FALSE;
} else
if ((pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V) ||
(pGlint->Chipset == PCI_VENDOR_3DLABS_CHIP_PERMEDIA2) ||
(pGlint->Chipset == PCI_VENDOR_TI_CHIP_PERMEDIA2)) {
if (!xf86HandleColormaps(pScreen, 256, pScrn->rgbBits,
(pGlint->FBDev) ? fbdevHWLoadPalette :
((pScrn->depth == 16) ? Permedia2LoadPalette16:Permedia2LoadPalette),
NULL,
CMAP_RELOAD_ON_MODE_SWITCH |
((pScrn->overlayFlags & OVERLAY_8_32_PLANAR)
? 0 : CMAP_PALETTED_TRUECOLOR)))
return FALSE;
} else {
if (pScrn->rgbBits == 10) {
if (!RamDacHandleColormaps(pScreen, 1024, pScrn->rgbBits,
CMAP_RELOAD_ON_MODE_SWITCH | CMAP_PALETTED_TRUECOLOR))
return FALSE;
} else {
if (!RamDacHandleColormaps(pScreen, 256, pScrn->rgbBits,
CMAP_RELOAD_ON_MODE_SWITCH |
((pScrn->overlayFlags & OVERLAY_8_32_PLANAR)
? 0 : CMAP_PALETTED_TRUECOLOR)))
return FALSE;
}
}
if((pScrn->overlayFlags & OVERLAY_8_32_PLANAR) &&
(pScrn->bitsPerPixel == 32)) {
if(!xf86Overlay8Plus32Init(pScreen))
return FALSE;
}
if(pGlint->ShadowFB)
ShadowFBInit(pScreen, GLINTRefreshArea);
xf86DPMSInit(pScreen, (DPMSSetProcPtr)GLINTDisplayPowerManagementSet, 0);
#ifdef XF86DRI
if (pGlint->directRenderingEnabled) {
pGlint->directRenderingEnabled = GLINTDRIFinishScreenInit(pScreen);
}
if (pGlint->directRenderingEnabled) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"direct rendering enabled\n");
} else {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"direct rendering disabled\n");
}
#endif
pScrn->memPhysBase = pGlint->FbAddress;
pScrn->fbOffset = 0;
pGlint->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = GLINTCloseScreen;
pScreen->SaveScreen = GLINTSaveScreen;
if (serverGeneration == 1) {
xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
}
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2VideoInit(pScreen);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
Permedia3InitVideo(pScreen);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
switch (pGlint->MultiChip) {
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
Permedia3InitVideo(pScreen);
}
}
#if 0
GLINTSaveScreen(pScreen, SCREEN_SAVER_OFF);
#endif
TRACE_EXIT("GLINTScreenInit");
return TRUE;
}
Bool
GLINTSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
{
ScrnInfoPtr pScrn;
GLINTPtr pGlint;
pScrn = xf86Screens[scrnIndex];
pGlint = GLINTPTR(pScrn);
TRACE_ENTER("GLINTSwitchMode");
if (pGlint->FBDev) {
Bool ret = fbdevHWSwitchMode(scrnIndex, mode, flags);
if (!pGlint->NoAccel) {
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2InitializeEngine(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
Permedia3InitializeEngine(pScrn);
break;
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
PermediaInitializeEngine(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_MX:
TXInitializeEngine(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_300SX:
SXInitializeEngine(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_500TX:
case PCI_CHIP_MX:
TXInitializeEngine(pScrn);
break;
case PCI_CHIP_300SX:
SXInitializeEngine(pScrn);
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
PermediaInitializeEngine(pScrn);
break;
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
Permedia3InitializeEngine(pScrn);
break;
}
break;
}
}
TRACE_EXIT("GLINTSwitchMode (fbdev ?)");
return ret;
}
TRACE_EXIT("GLINTSwitchMode (normal)");
return GLINTModeInit(xf86Screens[scrnIndex], mode);
}
void
GLINTAdjustFrame(int scrnIndex, int x, int y, int flags)
{
ScrnInfoPtr pScrn;
CARD32 base;
GLINTPtr pGlint;
pScrn = xf86Screens[scrnIndex];
pGlint = GLINTPTR(pScrn);
TRACE_ENTER("GLINTAdjustFrame");
if (pGlint->FBDev) {
fbdevHWAdjustFrame(scrnIndex, x, y, flags);
TRACE_EXIT("GLINTAdjustFrame (fbdev)");
return;
}
base = ((y * pScrn->displayWidth + x) >> 1) >> pGlint->BppShift;
if (pScrn->bitsPerPixel == 24) base *= 3;
switch (pGlint->Chipset)
{
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
GLINT_SLOW_WRITE_REG(base, PMScreenBase);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
base = (y * pScrn->displayWidth + x) >> pGlint->BppShift;
GLINT_SLOW_WRITE_REG(base, PMScreenBase);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
base = (y * pScrn->displayWidth + x) >> pGlint->BppShift;
GLINT_SLOW_WRITE_REG(base, PMScreenBase);
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
GLINT_SLOW_WRITE_REG(base, PMScreenBase);
break;
}
break;
}
TRACE_EXIT("GLINTAdjustFrame (normal)");
}
static Bool
GLINTEnterVT(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("GLINTEnterVT");
if (pGlint->FBDev)
fbdevHWEnterVT(scrnIndex, flags);
else
if (!GLINTModeInit(pScrn, pScrn->currentMode))
return FALSE;
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2VideoEnterVT(pScrn);
break;
}
if (!pGlint->NoAccel) {
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2InitializeEngine(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
Permedia3InitializeEngine(pScrn);
break;
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
PermediaInitializeEngine(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_MX:
TXInitializeEngine(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_300SX:
SXInitializeEngine(pScrn);
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_500TX:
case PCI_CHIP_MX:
TXInitializeEngine(pScrn);
break;
case PCI_CHIP_300SX:
SXInitializeEngine(pScrn);
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
PermediaInitializeEngine(pScrn);
break;
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
Permedia3InitializeEngine(pScrn);
break;
}
break;
}
}
TRACE_EXIT("GLINTEnterVTFBDev");
return TRUE;
}
static void
GLINTLeaveVT(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("GLINTLeaveVT");
pGlint->STATE = TRUE;
GLINTRestore(pScrn);
if (xf86IsPc98())
outb(0xfac, 0x00);
TRACE_EXIT("GLINTLeaveVT");
}
static Bool
GLINTCloseScreen(int scrnIndex, ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
GLINTPtr pGlint = GLINTPTR(pScrn);
TRACE_ENTER("GLINTCloseScreen");
#ifdef XF86DRI
if (pGlint->directRenderingEnabled) {
GLINTDRICloseScreen(pScreen);
}
#endif
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
Permedia2VideoUninit(pScrn);
break;
}
if (pScrn->vtSema) {
if(pGlint->CursorInfoRec)
pGlint->CursorInfoRec->HideCursor(pScrn);
if (pGlint->FBDev)
fbdevHWRestore(pScrn);
else {
pGlint->STATE = TRUE;
GLINTRestore(pScrn);
}
GLINTUnmapMem(pScrn);
}
if(pGlint->AccelInfoRec)
XAADestroyInfoRec(pGlint->AccelInfoRec);
if(pGlint->CursorInfoRec)
xf86DestroyCursorInfoRec(pGlint->CursorInfoRec);
if (pGlint->ShadowPtr)
xfree(pGlint->ShadowPtr);
if (pGlint->DGAModes)
xfree(pGlint->DGAModes);
if (pGlint->ScratchBuffer)
xfree(pGlint->ScratchBuffer);
pScrn->vtSema = FALSE;
if (xf86IsPc98())
outb(0xfac, 0x00);
if(pGlint->BlockHandler)
pScreen->BlockHandler = pGlint->BlockHandler;
pScreen->CloseScreen = pGlint->CloseScreen;
TRACE_EXIT("GLINTCloseScreen");
return (*pScreen->CloseScreen)(scrnIndex, pScreen);
}
static void
GLINTFreeScreen(int scrnIndex, int flags)
{
#if DEBUG
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
#endif
TRACE_ENTER("GLINTFreeScreen");
if (xf86LoaderCheckSymbol("fbdevHWFreeRec"))
fbdevHWFreeRec(xf86Screens[scrnIndex]);
if (xf86LoaderCheckSymbol("RamDacFreeRec"))
RamDacFreeRec(xf86Screens[scrnIndex]);
GLINTFreeRec(xf86Screens[scrnIndex]);
TRACE_EXIT("GLINTFreeScreen");
}
static ModeStatus
GLINTValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
GLINTPtr pGlint = GLINTPTR(pScrn);
if (mode->Flags & V_INTERLACE)
return(MODE_NO_INTERLACE);
if (pScrn->bitsPerPixel == 24) {
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
if (mode->HDisplay % 8) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"HDisplay %d not divisible by 8, fixing...\n", mode->HDisplay);
mode->HDisplay -= (mode->HDisplay % 8);
mode->CrtcHDisplay = mode->CrtcHBlankStart = mode->HDisplay;
}
if (mode->HSyncStart % 8) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"HSyncStart %d not divisible by 8, fixing...\n", mode->HSyncStart);
mode->HSyncStart -= (mode->HSyncStart % 8);
mode->CrtcHSyncStart = mode->HSyncStart;
}
if (mode->HSyncEnd % 8) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"HSyncEnd %d not divisible by 8, fixing...\n", mode->HSyncEnd);
mode->HSyncEnd -= (mode->HSyncEnd % 8);
mode->CrtcHSyncEnd = mode->HSyncEnd;
}
if (mode->HTotal % 8) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"HTotal %d not divisible by 8, fixing...\n", mode->HTotal);
mode->HTotal -= (mode->HTotal % 8);
mode->CrtcHBlankEnd = mode->CrtcHTotal = mode->HTotal;
}
break;
}
}
return(MODE_OK);
}
static Bool
GLINTSaveScreen(ScreenPtr pScreen, int mode)
{
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
GLINTPtr pGlint = GLINTPTR(pScrn);
CARD32 temp;
Bool unblank;
TRACE_ENTER("GLINTSaveScreen");
unblank = xf86IsUnblank(mode);
if (unblank)
SetTimeSinceLastInputEvent();
if ((pScrn != NULL ) && pScrn->vtSema) {
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
temp = GLINT_READ_REG(PMVideoControl);
if (unblank) temp |= 1;
else temp &= 0xFFFFFFFE;
GLINT_SLOW_WRITE_REG(temp, PMVideoControl);
break;
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_300SX:
case PCI_VENDOR_3DLABS_CHIP_MX:
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
temp = GLINT_READ_REG(PMVideoControl);
if (unblank) temp |= 1;
else temp &= 0xFFFFFFFE;
GLINT_SLOW_WRITE_REG(temp, PMVideoControl);
break;
}
break;
}
}
TRACE_EXIT("GLINTSaveScreen");
return TRUE;
}
static void
GLINTBlockHandler (
int i,
pointer blockData,
pointer pTimeout,
pointer pReadmask
){
ScreenPtr pScreen = screenInfo.screens[i];
ScrnInfoPtr pScrn = xf86Screens[i];
GLINTPtr pGlint = GLINTPTR(pScrn);
int sigstate = xf86BlockSIGIO();
if(pGlint->CursorColorCallback)
(*pGlint->CursorColorCallback)(pScrn);
if(pGlint->LoadCursorCallback)
(*pGlint->LoadCursorCallback)(pScrn);
xf86UnblockSIGIO(sigstate);
pScreen->BlockHandler = pGlint->BlockHandler;
(*pScreen->BlockHandler) (i, blockData, pTimeout, pReadmask);
pScreen->BlockHandler = GLINTBlockHandler;
if(pGlint->VideoTimerCallback) {
UpdateCurrentTime();
(*pGlint->VideoTimerCallback)(pScrn, currentTime.milliseconds);
}
}
#ifdef DEBUG
void
GLINT_VERB_WRITE_REG(GLINTPtr pGlint, CARD32 v, int r, char *file, int line)
{
if (xf86GetVerbosity() > 2)
ErrorF("[0x%04x] <- 0x%08lx (%s, %d)\n",
r, (unsigned long)v, file, line);
*(volatile CARD32 *)((char *) pGlint->IOBase + pGlint->IOOffset + r) = v;
}
CARD32
GLINT_VERB_READ_REG(GLINTPtr pGlint, CARD32 r, char *file, int line)
{
CARD32 v =
*(volatile CARD32 *)((char *) pGlint->IOBase + pGlint->IOOffset + r);
if (xf86GetVerbosity() > 2)
ErrorF("[0x%04lx] -> 0x%08lx (%s, %d)\n", (unsigned long)r,
(unsigned long)v, file, line);
return v;
}
#endif
void GLINT_MoveBYTE(
register CARD32* dest,
register unsigned char* src,
register int dwords)
{
#ifdef __alpha__
write_mem_barrier();
#endif
while(dwords) {
*dest = *src;
src += 1;
dest += 1;
dwords -= 1;
}
}
void GLINT_MoveWORDS(
register CARD32* dest,
register unsigned short* src,
register int dwords)
{
#ifdef __alpha__
write_mem_barrier();
#endif
while(dwords & ~0x01) {
*dest = *src;
*(dest + 1) = *(src + 1);
src += 2;
dest += 2;
dwords -= 2;
}
if (dwords)
*dest = *src;
}
void GLINT_MoveDWORDS(
register CARD32* dest,
register CARD32* src,
register int dwords)
{
#ifdef __alpha__
write_mem_barrier();
#endif
if ((unsigned long)src & 0x3UL) {
unsigned char *pchar;
while (dwords & ~0x03) {
pchar = (unsigned char *)(src + 0);
*(dest + 0) = (((CARD32)pchar[0] << 24) |
((CARD32)pchar[1] << 16) |
((CARD32)pchar[2] << 8) |
((CARD32)pchar[3] << 0));
pchar = (unsigned char *)(src + 1);
*(dest + 1) = (((CARD32)pchar[0] << 24) |
((CARD32)pchar[1] << 16) |
((CARD32)pchar[2] << 8) |
((CARD32)pchar[3] << 0));
pchar = (unsigned char *)(src + 2);
*(dest + 2) = (((CARD32)pchar[0] << 24) |
((CARD32)pchar[1] << 16) |
((CARD32)pchar[2] << 8) |
((CARD32)pchar[3] << 0));
pchar = (unsigned char *)(src + 3);
*(dest + 3) = (((CARD32)pchar[0] << 24) |
((CARD32)pchar[1] << 16) |
((CARD32)pchar[2] << 8) |
((CARD32)pchar[3] << 0));
src += 4;
dest += 4;
dwords -= 4;
}
if (!dwords)
return;
pchar = (unsigned char *)(src + 0);
*(dest + 0) = (((CARD32)pchar[0] << 24) |
((CARD32)pchar[1] << 16) |
((CARD32)pchar[2] << 8) |
((CARD32)pchar[3] << 0));
if (dwords == 1)
return;
pchar = (unsigned char *)(src + 1);
*(dest + 1) = (((CARD32)pchar[0] << 24) |
((CARD32)pchar[1] << 16) |
((CARD32)pchar[2] << 8) |
((CARD32)pchar[3] << 0));
if (dwords == 2)
return;
pchar = (unsigned char *)(src + 2);
*(dest + 2) = (((CARD32)pchar[0] << 24) |
((CARD32)pchar[1] << 16) |
((CARD32)pchar[2] << 8) |
((CARD32)pchar[3] << 0));
} else {
while (dwords & ~0x03) {
*dest = *src;
*(dest + 1) = *(src + 1);
*(dest + 2) = *(src + 2);
*(dest + 3) = *(src + 3);
src += 4;
dest += 4;
dwords -= 4;
}
if (!dwords)
return;
*dest = *src;
if (dwords == 1)
return;
*(dest + 1) = *(src + 1);
if (dwords == 2)
return;
*(dest + 2) = *(src + 2);
}
}
int
Shiftbpp(ScrnInfoPtr pScrn, int value)
{
GLINTPtr pGlint = GLINTPTR(pScrn);
int logbytesperaccess = 2;
switch (pGlint->Chipset) {
case PCI_VENDOR_TI_CHIP_PERMEDIA:
case PCI_VENDOR_TI_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA2V:
logbytesperaccess = 2;
break;
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA3:
case PCI_VENDOR_3DLABS_CHIP_PERMEDIA4:
case PCI_VENDOR_3DLABS_CHIP_R4:
logbytesperaccess = 4;
break;
case PCI_VENDOR_3DLABS_CHIP_300SX:
case PCI_VENDOR_3DLABS_CHIP_500TX:
case PCI_VENDOR_3DLABS_CHIP_MX:
if ( (pGlint->RamDac->RamDacType == (IBM640_RAMDAC)) ||
(pGlint->RamDac->RamDacType == (TI3030_RAMDAC)) )
logbytesperaccess = 4;
else
logbytesperaccess = 3;
break;
case PCI_VENDOR_3DLABS_CHIP_GAMMA:
case PCI_VENDOR_3DLABS_CHIP_GAMMA2:
case PCI_VENDOR_3DLABS_CHIP_DELTA:
switch (pGlint->MultiChip) {
case PCI_CHIP_500TX:
case PCI_CHIP_300SX:
case PCI_CHIP_MX:
if ( (pGlint->RamDac->RamDacType == (IBM640_RAMDAC)) ||
(pGlint->RamDac->RamDacType == (TI3030_RAMDAC)) )
logbytesperaccess = 4;
else
logbytesperaccess = 3;
break;
case PCI_CHIP_PERMEDIA:
case PCI_CHIP_TI_PERMEDIA:
logbytesperaccess = 2;
break;
case PCI_CHIP_R4:
case PCI_CHIP_PERMEDIA3:
logbytesperaccess = 4;
break;
}
}
switch (pScrn->bitsPerPixel) {
case 8:
value >>= logbytesperaccess;
pGlint->BppShift = logbytesperaccess;
break;
case 16:
if (pGlint->DoubleBuffer) {
value >>= (logbytesperaccess-2);
pGlint->BppShift = logbytesperaccess-2;
} else {
value >>= (logbytesperaccess-1);
pGlint->BppShift = logbytesperaccess-1;
}
break;
case 24:
value *= 3;
value >>= logbytesperaccess;
pGlint->BppShift = logbytesperaccess;
break;
case 32:
value >>= (logbytesperaccess-2);
pGlint->BppShift = logbytesperaccess-2;
break;
}
return (value);
}