#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86_ansic.h"
#include "xf86Version.h"
#include "mipointer.h"
#include "mibstore.h"
#include "micmap.h"
#define PSZ 8
#include "cfb.h"
#undef PSZ
#include "cfb32.h"
#include "cfb8_32wid.h"
#include "xf86cmap.h"
#include "ffb.h"
static const OptionInfoRec * FFBAvailableOptions(int chipid, int busid);
static void FFBIdentify(int flags);
static Bool FFBProbe(DriverPtr drv, int flags);
static Bool FFBPreInit(ScrnInfoPtr pScrn, int flags);
static Bool FFBScreenInit(int Index, ScreenPtr pScreen, int argc,
char **argv);
static Bool FFBEnterVT(int scrnIndex, int flags);
static void FFBLeaveVT(int scrnIndex, int flags);
static Bool FFBCloseScreen(int scrnIndex, ScreenPtr pScreen);
static Bool FFBSaveScreen(ScreenPtr pScreen, int mode);
static Bool FFBSwitchMode(int scrnIndex, DisplayModePtr mode, int flags);
static void FFBAdjustFrame(int scrnIndex, int x, int y, int flags);
static void FFBFreeScreen(int scrnIndex, int flags);
static ModeStatus FFBValidMode(int scrnIndex, DisplayModePtr mode,
Bool verbose, int flags);
static void FFBDPMSMode(ScrnInfoPtr pScrn, int DPMSMode, int flags);
extern void FFB_InitDGA(ScreenPtr pScreen);
void FFBSync(ScrnInfoPtr pScrn);
#define VERSION 4000
#define FFB_NAME "SUNFFB"
#define FFB_DRIVER_NAME "sunffb"
#define FFB_MAJOR_VERSION 1
#define FFB_MINOR_VERSION 0
#define FFB_PATCHLEVEL 0
DriverRec SUNFFB = {
VERSION,
FFB_DRIVER_NAME,
FFBIdentify,
FFBProbe,
FFBAvailableOptions,
NULL,
0
};
typedef enum {
OPTION_SW_CURSOR,
OPTION_HW_CURSOR,
OPTION_NOACCEL
} FFBOpts;
static const OptionInfoRec FFBOptions[] = {
{ OPTION_SW_CURSOR, "SWcursor", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_HW_CURSOR, "HWcursor", OPTV_BOOLEAN, {0}, FALSE },
{ OPTION_NOACCEL, "NoAccel", OPTV_BOOLEAN, {0}, FALSE },
{ -1, NULL, OPTV_NONE, {0}, FALSE }
};
#ifdef XFree86LOADER
static MODULESETUPPROTO(ffbSetup);
static XF86ModuleVersionInfo sunffbVersRec =
{
"sunffb",
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XF86_VERSION_CURRENT,
FFB_MAJOR_VERSION, FFB_MINOR_VERSION, FFB_PATCHLEVEL,
ABI_CLASS_VIDEODRV,
ABI_VIDEODRV_VERSION,
MOD_CLASS_VIDEODRV,
{0,0,0,0}
};
XF86ModuleData sunffbModuleData = { &sunffbVersRec, ffbSetup, NULL };
pointer
ffbSetup(pointer module, pointer opts, int *errmaj, int *errmin)
{
static Bool setupDone = FALSE;
if (!setupDone) {
setupDone = TRUE;
xf86AddDriver(&SUNFFB, module, 0);
return (pointer)TRUE;
} else {
if (errmaj) *errmaj = LDR_ONCEONLY;
return NULL;
}
}
#endif
static Bool
FFBGetRec(ScrnInfoPtr pScrn)
{
if (pScrn->driverPrivate != NULL)
return TRUE;
pScrn->driverPrivate = xnfcalloc(sizeof(FFBRec), 1);
return TRUE;
}
static void
FFBFreeRec(ScrnInfoPtr pScrn)
{
FFBPtr pFfb;
if (pScrn->driverPrivate == NULL)
return;
pFfb = GET_FFB_FROM_SCRN(pScrn);
xfree(pScrn->driverPrivate);
pScrn->driverPrivate = NULL;
return;
}
static const OptionInfoRec *
FFBAvailableOptions(int chipid, int busid)
{
return FFBOptions;
}
static void
FFBIdentify(int flags)
{
xf86Msg(X_INFO, "%s: driver for Creator, Creator 3D and Elite 3D\n", FFB_NAME);
}
static Bool
FFBProbe(DriverPtr drv, int flags)
{
int i;
GDevPtr *devSections;
int *usedChips;
int numDevSections;
int numUsed;
Bool foundScreen = FALSE;
EntityInfoPtr pEnt;
if ((numDevSections = xf86MatchDevice(FFB_DRIVER_NAME,
&devSections)) <= 0) {
return FALSE;
}
numUsed = xf86MatchSbusInstances(FFB_NAME, SBUS_DEVICE_FFB,
devSections, numDevSections,
drv, &usedChips);
xfree(devSections);
if (numUsed <= 0)
return FALSE;
if (flags & PROBE_DETECT)
foundScreen = TRUE;
else for (i = 0; i < numUsed; i++) {
pEnt = xf86GetEntityInfo(usedChips[i]);
if(pEnt->active) {
ScrnInfoPtr pScrn;
pScrn = xf86AllocateScreen(drv, 0);
pScrn->driverVersion = VERSION;
pScrn->driverName = FFB_DRIVER_NAME;
pScrn->name = FFB_NAME;
pScrn->Probe = FFBProbe;
pScrn->PreInit = FFBPreInit;
pScrn->ScreenInit = FFBScreenInit;
pScrn->SwitchMode = FFBSwitchMode;
pScrn->AdjustFrame = FFBAdjustFrame;
pScrn->EnterVT = FFBEnterVT;
pScrn->LeaveVT = FFBLeaveVT;
pScrn->FreeScreen = FFBFreeScreen;
pScrn->ValidMode = FFBValidMode;
xf86AddEntityToScreen(pScrn, pEnt->index);
foundScreen = TRUE;
}
xfree(pEnt);
}
xfree(usedChips);
return foundScreen;
}
static Bool
FFBPreInit(ScrnInfoPtr pScrn, int flags)
{
FFBPtr pFfb;
sbusDevicePtr psdp;
MessageType from;
int i;
if (flags & PROBE_DETECT) return FALSE;
if (!FFBGetRec(pScrn))
return FALSE;
pFfb = GET_FFB_FROM_SCRN(pScrn);
pScrn->monitor = pScrn->confScreen->monitor;
if (pScrn->numEntities > 1)
return FALSE;
for (i = 0; i < pScrn->numEntities; i++) {
EntityInfoPtr pEnt = xf86GetEntityInfo(pScrn->entityList[i]);
if (pEnt->location.type == BUS_SBUS) {
psdp = xf86GetSbusInfoForEntity(pEnt->index);
pFfb->psdp = psdp;
} else
return FALSE;
}
if (!xf86SetDepthBpp(pScrn, 24, 0, 32, Support32bppFb)) {
return FALSE;
} else {
switch (pScrn->depth) {
case 24:
break;
default:
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Given depth (%d) is not supported by this driver\n",
pScrn->depth);
return FALSE;
}
}
xf86CollectOptions(pScrn, NULL);
if (!(pFfb->Options = xalloc(sizeof(FFBOptions))))
return FALSE;
memcpy(pFfb->Options, FFBOptions, sizeof(FFBOptions));
xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pFfb->Options);
if (pScrn->depth > 8) {
rgb weight = {8, 8, 8};
rgb mask = {0xff, 0xff00, 0xff0000};
if (!xf86SetWeight(pScrn, weight, mask)) {
return FALSE;
}
}
if (!xf86SetDefaultVisual(pScrn, -1))
return FALSE;
{
Gamma zeros = {0.0, 0.0, 0.0};
if (!xf86SetGamma(pScrn, zeros)) {
return FALSE;
}
}
from = X_DEFAULT;
pFfb->HWCursor = TRUE;
if (xf86GetOptValBool(pFfb->Options, OPTION_HW_CURSOR, &pFfb->HWCursor))
from = X_CONFIG;
if (xf86ReturnOptValBool(pFfb->Options, OPTION_SW_CURSOR, FALSE)) {
from = X_CONFIG;
pFfb->HWCursor = FALSE;
}
xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n",
pFfb->HWCursor ? "HW" : "SW");
if (xf86ReturnOptValBool(pFfb->Options, OPTION_NOACCEL, FALSE)) {
pFfb->NoAccel = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
}
if (xf86LoadSubModule(pScrn, "xf8_32wid") == NULL) {
FFBFreeRec(pScrn);
return FALSE;
}
if (xf86LoadSubModule(pScrn, "cfb32") == NULL) {
FFBFreeRec(pScrn);
return FALSE;
}
if (xf86LoadSubModule(pScrn, "cfb") == NULL) {
FFBFreeRec(pScrn);
return FALSE;
}
if (pFfb->HWCursor && xf86LoadSubModule(pScrn, "ramdac") == NULL) {
FFBFreeRec(pScrn);
return FALSE;
}
if (xf86LoadSubModule(pScrn, "dbe") == NULL) {
FFBFreeRec(pScrn);
return FALSE;
}
#if 0
if (xf86LoadSubModule(pScrn, "drm") == NULL) {
FFBFreeRec(pScrn);
return FALSE;
}
if (xf86LoadSubModule(pScrn, "dri") == NULL) {
FFBFreeRec(pScrn);
return FALSE;
}
#endif
pScrn->progClock = TRUE;
if(pScrn->display->virtualX || pScrn->display->virtualY) {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"FFB does not support a virtual desktop\n");
pScrn->display->virtualX = 0;
pScrn->display->virtualY = 0;
}
xf86SbusUseBuiltinMode(pScrn, pFfb->psdp);
pScrn->currentMode = pScrn->modes;
pScrn->displayWidth = pScrn->virtualX;
xf86SetDpi(pScrn, 0, 0);
return TRUE;
}
static void
FFBProbeBoardType(FFBPtr pFfb)
{
ffb_fbcPtr ffb = pFfb->regs;
volatile unsigned int *afb_fem;
unsigned int val;
afb_fem = ((volatile unsigned int *) ((char *)ffb + 0x1540));
val = *afb_fem;
val &= 0x7f;
xf86Msg(X_INFO, "%s: ", pFfb->psdp->device);
if (val == 0x3f || val == 0x07 || val == 0x01) {
if (val == 0x3f || val != 0x07) {
pFfb->ffb_type = afb_m6;
ErrorF("AFB: Detected Elite3D/M6.\n");
} else {
pFfb->ffb_type = afb_m3;
ErrorF("AFB: Detected Elite3D/M3.\n");
}
pFfb->has_double_res = 0;
pFfb->has_z_buffer = 1;
pFfb->has_double_buffer = 1;
} else {
unsigned char sbits;
sbits = *((volatile unsigned char *)pFfb->strapping_bits);
sbits = *((volatile unsigned char *)pFfb->strapping_bits);
switch (sbits & 0x78) {
case (0x0 << 5) | (0x0 << 3):
pFfb->ffb_type = ffb1_prototype;
ErrorF("Detected FFB1 pre-FCS prototype, ");
break;
case (0x0 << 5) | (0x1 << 3):
pFfb->ffb_type = ffb1_standard;
ErrorF("Detected FFB1, ");
break;
case (0x0 << 5) | (0x3 << 3):
pFfb->ffb_type = ffb1_speedsort;
ErrorF("Detected FFB1-SpeedSort, ");
break;
case (0x1 << 5) | (0x0 << 3):
pFfb->ffb_type = ffb2_prototype;
ErrorF("Detected FFB2/vertical pre-FCS prototype, ");
break;
case (0x1 << 5) | (0x1 << 3):
pFfb->ffb_type = ffb2_vertical;
ErrorF("Detected FFB2/vertical, ");
break;
case (0x1 << 5) | (0x2 << 3):
pFfb->ffb_type = ffb2_vertical_plus;
ErrorF("Detected FFB2+/vertical, ");
break;
case (0x2 << 5) | (0x0 << 3):
pFfb->ffb_type = ffb2_horizontal;
ErrorF("Detected FFB2/horizontal, ");
break;
case (0x2 << 5) | (0x2 << 3):
pFfb->ffb_type = ffb2_horizontal;
ErrorF("Detected FFB2+/horizontal, ");
break;
default:
pFfb->ffb_type = ffb2_vertical;
ErrorF("Unknown boardID[%08x], assuming FFB2, ", sbits);
break;
};
if (sbits & (1 << 2)) {
ErrorF("DoubleRES, ");
pFfb->has_double_res = 1;
} else {
pFfb->has_double_res = 0;
}
if (sbits & (1 << 1)) {
ErrorF("Z-buffer, ");
pFfb->has_z_buffer = 1;
} else {
pFfb->has_z_buffer = 0;
}
if (sbits & (1 << 0)) {
ErrorF("Double-buffered.\n");
if ((ffb->fbcfg0 & FFB_FBCFG0_RES_MASK) != FFB_FBCFG0_RES_HIGH)
pFfb->has_double_buffer = 1;
else
pFfb->has_double_buffer = 1;
} else {
ErrorF("Single-buffered.\n");
pFfb->has_double_buffer = 0;
}
}
}
static unsigned long CreatorUnaccelGeneration = 0;
static int CreatorUnaccelWindowPrivateIndex;
#define CreatorUnaccelGetWid(w) \
((w)->devPrivates[CreatorUnaccelWindowPrivateIndex].val)
#define CreatorUnaccelSetWid(w,wid) \
(((w)->devPrivates[CreatorUnaccelWindowPrivateIndex].val) = (wid))
static unsigned int
CreatorWidGet(WindowPtr pWin)
{
return CreatorUnaccelGetWid(pWin);
}
static Bool
CreatorWidAlloc(WindowPtr pWin)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
unsigned int wid;
int i, visual, visclass;
visual = wVisual(pWin);
visclass = 0;
for (i = 0; i < pScreen->numVisuals; i++) {
if (pScreen->visuals[i].vid == visual) {
visclass = pScreen->visuals[i].class;
break;
}
}
wid = FFBWidAlloc(pFfb, visclass, wColormap(pWin), TRUE);
if (wid == (unsigned int) -1)
return FALSE;
CreatorUnaccelSetWid(pWin, wid);
return TRUE;
}
static void
CreatorWidFree(WindowPtr pWin)
{
ScrnInfoPtr pScrn = xf86Screens[pWin->drawable.pScreen->myNum];
FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
unsigned int wid = CreatorUnaccelGetWid(pWin);
FFBWidFree(pFfb, wid);
}
static cfb8_32WidOps CreatorUnaccelWidOps = {
CreatorWidGet,
CreatorWidAlloc,
CreatorWidFree,
NULL,
NULL
};
static Bool
CreatorUnaccelWidInit(ScreenPtr pScreen)
{
if (serverGeneration != CreatorUnaccelGeneration) {
CreatorUnaccelWindowPrivateIndex =
AllocateWindowPrivateIndex();
if (CreatorUnaccelWindowPrivateIndex == -1)
return FALSE;
}
return TRUE;
}
static Bool
FFBScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
{
ScrnInfoPtr pScrn;
FFBPtr pFfb;
int ret;
unsigned int afb_fem;
VisualPtr visual;
if (!FFBDbePreInit(pScreen))
return FALSE;
pScrn = xf86Screens[pScreen->myNum];
pFfb = GET_FFB_FROM_SCRN(pScrn);
pFfb->fb = pFfb->dfb24 =
xf86MapSbusMem (pFfb->psdp, FFB_DFB24_VOFF, 0x1000000);
if (! pFfb->dfb24)
return FALSE;
pFfb->dfb8r =
xf86MapSbusMem (pFfb->psdp, FFB_DFB8R_VOFF, 0x400000);
if (! pFfb->dfb8r)
return FALSE;
pFfb->dfb8x =
xf86MapSbusMem (pFfb->psdp, FFB_DFB8X_VOFF, 0x400000);
if (! pFfb->dfb8x)
return FALSE;
pFfb->sfb32 =
xf86MapSbusMem (pFfb->psdp, FFB_SFB32_VOFF, 0x1000000);
if (!pFfb->sfb32)
return FALSE;
pFfb->sfb8r =
xf86MapSbusMem(pFfb->psdp, FFB_SFB8R_VOFF, 0x400000);
if (!pFfb->sfb8r)
return FALSE;
pFfb->sfb8x =
xf86MapSbusMem(pFfb->psdp, FFB_SFB8X_VOFF, 0x400000);
if (!pFfb->sfb8x)
return FALSE;
pFfb->regs =
xf86MapSbusMem (pFfb->psdp, FFB_FBC_REGS_VOFF, 16384);
if (! pFfb->regs)
return FALSE;
pFfb->dac =
xf86MapSbusMem (pFfb->psdp, FFB_DAC_VOFF, 8192);
if (! pFfb->dac)
return FALSE;
pFfb->strapping_bits = (volatile unsigned int *)
xf86MapSbusMem(pFfb->psdp, FFB_EXP_VOFF, 8192);
if (! pFfb->strapping_bits)
return FALSE;
FFBProbeBoardType(pFfb);
if (FFBDacInit(pFfb) == FALSE)
return FALSE;
afb_fem = *(unsigned int *)((char *)pFfb->regs + 0x1540);
if ((afb_fem & 0x7f) != 0x3f &&
(afb_fem & 0x7f) != 0x07 &&
(afb_fem & 0x7f) != 0x01)
xf86Msg(X_INFO, "%s: Detected Creator/Creator3D\n", pFfb->psdp->device);
else {
xf86Msg(X_INFO, "%s: Detected Elite3D M3/M6, checking firmware...\n", pFfb->psdp->device);
if (afb_fem == 0x1) {
xf86Msg(X_INFO, "%s: ... AFB firmware not loaded\n", pFfb->psdp->device);
if (!pFfb->NoAccel) {
xf86Msg(X_WARNING, "%s: Forcing no acceleration on Elite3D M3/M6\n", pFfb->psdp->device);
pFfb->NoAccel = TRUE;
}
} else
xf86Msg(X_INFO, "%s: ... AFB firmware is loaded\n", pFfb->psdp->device);
}
FFBSaveScreen(pScreen, SCREEN_SAVER_ON);
if (pFfb->NoAccel == TRUE) {
if (!CreatorUnaccelWidInit(pScreen))
return FALSE;
}
miClearVisualTypes();
if (!miSetVisualTypes(24, TrueColorMask | DirectColorMask,
pScrn->rgbBits, TrueColor))
return FALSE;
if (!miSetVisualTypes(8, PseudoColorMask | GrayScaleMask | StaticGrayMask,
pScrn->rgbBits, PseudoColor))
return FALSE;
#ifdef XF86DRI
if (pFfb->ffb_type != afb_m3 && pFfb->ffb_type != afb_m6 &&
pFfb->NoAccel == FALSE) {
pFfb->dri_enabled = FFBDRIScreenInit(pScreen);
if (pFfb->dri_enabled == TRUE)
xf86Msg(X_INFO, "%s: DRM initialized\n",
pFfb->psdp->device);
else
xf86Msg(X_INFO, "%s: DRM setup failed\n",
pFfb->psdp->device);
} else {
pFfb->dri_enabled = FALSE;
}
#endif
if (pFfb->NoAccel == TRUE) {
ret = cfb8_32WidScreenInit(pScreen, pFfb->dfb24, pFfb->dfb8r, pFfb->dfb8x,
pScrn->virtualX, pScrn->virtualY,
pScrn->xDpi, pScrn->yDpi,
2048, 2048, 2048, 8,
&CreatorUnaccelWidOps);
} else {
ret = cfb8_32WidScreenInit(pScreen, pFfb->sfb32, pFfb->sfb8r, pFfb->dfb8x,
pScrn->virtualX, pScrn->virtualY,
pScrn->xDpi, pScrn->yDpi,
2048, 2048, 2048, 8,
&CreatorUnaccelWidOps);
}
if (!ret)
return FALSE;
miInitializeBackingStore(pScreen);
xf86SetBackingStore(pScreen);
xf86SetSilkenMouse(pScreen);
xf86SetBlackWhitePixels(pScreen);
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 (!pFfb->NoAccel) {
if (!FFBAccelInit(pScreen, pFfb))
return FALSE;
xf86Msg(X_INFO, "%s: Using acceleration\n", pFfb->psdp->device);
}
miDCInitialize (pScreen, xf86GetPointerScreenFuncs());
if (pFfb->HWCursor) {
if(!FFBHWCursorInit(pScreen)) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Hardware cursor initialization failed\n");
return(FALSE);
}
xf86SbusHideOsHwCursor(pFfb->psdp);
}
if (!miCreateDefColormap(pScreen))
return FALSE;
if (!xf86HandleColormaps(pScreen, 256, 8,
FFBDacLoadPalette, NULL,
#if 0
CMAP_PALETTED_TRUECOLOR |
#endif
CMAP_LOAD_EVEN_IF_OFFSCREEN |
CMAP_RELOAD_ON_MODE_SWITCH))
return FALSE;
if (!pFfb->NoAccel)
FFB_InitDGA(pScreen);
#ifdef XF86DRI
if (pFfb->dri_enabled) {
pFfb->dri_enabled = FFBDRIFinishScreenInit(pScreen);
if (pFfb->dri_enabled)
xf86Msg(X_INFO, "%s: DRM finish setup complete\n",
pFfb->psdp->device);
else
xf86Msg(X_INFO, "%s: DRM finish setup failed\n",
pFfb->psdp->device);
}
#endif
pFfb->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = FFBCloseScreen;
pScreen->SaveScreen = FFBSaveScreen;
(void) xf86DPMSInit(pScreen, FFBDPMSMode, 0);
if (serverGeneration == 1) {
xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
}
FFBSaveScreen(pScreen, SCREEN_SAVER_OFF);
return TRUE;
}
static Bool
FFBSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
{
return TRUE;
}
static void
FFBAdjustFrame(int scrnIndex, int x, int y, int flags)
{
return;
}
static Bool
FFBEnterVT(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
pFfb->vtSema = FALSE;
if (!pFfb->NoAccel)
CreatorVtChange (pScrn->pScreen, TRUE);
if (pFfb->HWCursor)
xf86SbusHideOsHwCursor (pFfb->psdp);
FFBDacEnterVT(pFfb);
return TRUE;
}
static void
FFBLeaveVT(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
FFBDacLeaveVT(pFfb);
if (!pFfb->NoAccel)
CreatorVtChange (pScrn->pScreen, FALSE);
if (pFfb->HWCursor)
xf86SbusHideOsHwCursor (pFfb->psdp);
pFfb->vtSema = TRUE;
return;
}
static Bool
FFBCloseScreen(int scrnIndex, ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
#ifdef XF86DRI
if (pFfb->dri_enabled)
FFBDRICloseScreen(pScreen);
#endif
FFBDacFini(pFfb);
pScrn->vtSema = FALSE;
xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb24, 0x1000000);
xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8r, 0x400000);
xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8x, 0x400000);
xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb32, 0x1000000);
xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8r, 0x400000);
xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8x, 0x400000);
xf86UnmapSbusMem(pFfb->psdp, pFfb->regs, 16384);
xf86UnmapSbusMem(pFfb->psdp, pFfb->dac, 8192);
xf86UnmapSbusMem(pFfb->psdp, (void *)pFfb->strapping_bits, 8192);
if (pFfb->HWCursor)
xf86SbusHideOsHwCursor (pFfb->psdp);
pScreen->CloseScreen = pFfb->CloseScreen;
return (*pScreen->CloseScreen)(scrnIndex, pScreen);
}
static void
FFBFreeScreen(int scrnIndex, int flags)
{
FFBFreeRec(xf86Screens[scrnIndex]);
}
static ModeStatus
FFBValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
{
if (mode->Flags & V_INTERLACE)
return(MODE_BAD);
return(MODE_OK);
}
static Bool
FFBSaveScreen(ScreenPtr pScreen, int mode)
{
return FFBDacSaveScreen(GET_FFB_FROM_SCREEN(pScreen), mode);
}
void
FFBSync(ScrnInfoPtr pScrn)
{
return;
}
static void
FFBDPMSMode(ScrnInfoPtr pScrn, int DPMSMode, int flags)
{
FFBDacDPMSMode(GET_FFB_FROM_SCRN(pScrn), DPMSMode, flags);
}