static Bool
CG3ScreenInit(SCREEN_INIT_ARGS_DECL)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
Cg3Ptr pCg3;
int ret;
pCg3 = GET_CG3_FROM_SCRN(pScrn);
/* Map the CG3 memory */
pCg3->fb =
xf86MapSbusMem (pCg3->psdp, CG3_RAM_VOFF,
(pCg3->psdp->width * pCg3->psdp->height));
if (! pCg3->fb)
return FALSE;
/* Darken the screen for aesthetic reasons and set the viewport */
CG3SaveScreen(pScreen, SCREEN_SAVER_ON);
/*
* The next step is to setup the screen's visuals, and initialise the
* framebuffer code. In cases where the framebuffer's default
* choices for things like visual layouts and bits per RGB are OK,
* this may be as simple as calling the framebuffer's ScreenInit()
* function. If not, the visuals will need to be setup before calling
* a fb ScreenInit() function and fixed up after.
*/
/*
* Reset visual list.
*/
miClearVisualTypes();
/* Set the bits per RGB for 8bpp mode */
pScrn->rgbBits = 8;
/* Setup the visuals we support. */
if (!miSetVisualTypes(pScrn->depth, miGetDefaultVisualMask(pScrn->depth),
pScrn->rgbBits, pScrn->defaultVisual))
return FALSE;
miSetPixmapDepths ();
/*
* Call the framebuffer layer's ScreenInit function, and fill in other
* pScreen fields.
*/
ret = fbScreenInit(pScreen, pCg3->fb, pScrn->virtualX,
pScrn->virtualY, pScrn->xDpi, pScrn->yDpi,
pScrn->virtualX, 8);
if (!ret)
return FALSE;
#ifdef RENDER
fbPictureInit (pScreen, 0, 0);
#endif
xf86SetBackingStore(pScreen);
xf86SetSilkenMouse(pScreen);
xf86SetBlackWhitePixels(pScreen);
/* Initialise cursor functions */
miDCInitialize (pScreen, xf86GetPointerScreenFuncs());
/* Initialise default colourmap */
if (!miCreateDefColormap(pScreen))
return FALSE;
if(!xf86SbusHandleColormaps(pScreen, pCg3->psdp))
return FALSE;
pCg3->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = CG3CloseScreen;
pScreen->SaveScreen = CG3SaveScreen;
/* Report any unused options (only for the first generation) */
if (serverGeneration == 1) {
xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
}
/* unblank the screen */
CG3SaveScreen(pScreen, SCREEN_SAVER_OFF);
/* Done */
return TRUE;
}
/* Called at each server generation */
static Bool NestedScreenInit(int scrnIndex, ScreenPtr pScreen, int argc,
char **argv) {
ScrnInfoPtr pScrn;
NestedPrivatePtr pNested;
Pixel redMask, greenMask, blueMask;
xf86DrvMsg(scrnIndex, X_INFO, "NestedScreenInit\n");
pScrn = xf86Screens[pScreen->myNum];
pNested = PNESTED(pScrn);
/*NESTEDScrn = pScrn;*/
NestedPrintPscreen(pScrn);
/* Save state:
* NestedSave(pScrn); */
//Load_Nested_Mouse();
pNested->clientData = NestedClientCreateScreen(scrnIndex,
pNested->displayName,
pScrn->virtualX,
pScrn->virtualY,
pNested->originX,
pNested->originY,
pScrn->depth,
pScrn->bitsPerPixel,
&redMask, &greenMask, &blueMask);
if (!pNested->clientData) {
xf86DrvMsg(scrnIndex, X_ERROR, "Failed to create client screen\n");
return FALSE;
}
TimerSet(NULL, 0, 1, NestedMouseTimer, pNested->clientData);
miClearVisualTypes();
if (!miSetVisualTypesAndMasks(pScrn->depth,
miGetDefaultVisualMask(pScrn->depth),
pScrn->rgbBits, pScrn->defaultVisual,
redMask, greenMask, blueMask))
return FALSE;
if (!miSetPixmapDepths())
return FALSE;
if (!fbScreenInit(pScreen, NestedClientGetFrameBuffer(PCLIENTDATA(pScrn)),
pScrn->virtualX, pScrn->virtualY, pScrn->xDpi,
pScrn->yDpi, pScrn->displayWidth, pScrn->bitsPerPixel))
return FALSE;
fbPictureInit(pScreen, 0, 0);
xf86SetBlackWhitePixels(pScreen);
miInitializeBackingStore(pScreen);
xf86SetBackingStore(pScreen);
miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
if (!miCreateDefColormap(pScreen))
return FALSE;
pNested->update = NestedShadowUpdate;
/*pNested->window = NestedShadowWindow;*/
pScreen->SaveScreen = NestedSaveScreen;
if (!shadowSetup(pScreen))
return FALSE;
pNested->CreateScreenResources = pScreen->CreateScreenResources;
pScreen->CreateScreenResources = NestedCreateScreenResources;
pNested->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = NestedCloseScreen;
// Schedule the NestedInputLoadDriver function to load once the
// input core is initialized.
pNested->timer = TimerSet(NULL, 0, TIMER_CALLBACK_INTERVAL,
NestedTimerCallback, (pointer)pScrn);
return TRUE;
}
vfbScreenInit(ScreenPtr pScreen, int argc, char **argv)
#endif
{
#if XORG < 113
vfbScreenInfoPtr pvfb = &vfbScreens[index];
#else
vfbScreenInfoPtr pvfb = &vfbScreens[pScreen->myNum];
#endif
int dpi;
int ret;
void *pbits;
#ifdef RANDR
rrScrPrivPtr rp;
#endif
#if XORG >= 113
if (!dixRegisterPrivateKey(&cmapScrPrivateKeyRec, PRIVATE_SCREEN, 0))
return FALSE;
#endif
/* 96 is the default used by most other systems */
dpi = 96;
if (monitorResolution)
dpi = monitorResolution;
pbits = vfbAllocateFramebufferMemory(&pvfb->fb);
if (!pbits) return FALSE;
#if XORG < 113
vncFbptr[index] = pbits;
vncFbstride[index] = pvfb->fb.paddedWidth;
#else
vncFbptr[pScreen->myNum] = pbits;
vncFbstride[pScreen->myNum] = pvfb->fb.paddedWidth;
#endif
miSetPixmapDepths();
switch (pvfb->fb.depth) {
case 8:
miSetVisualTypesAndMasks (8,
((1 << StaticGray) |
(1 << GrayScale) |
(1 << StaticColor) |
(1 << PseudoColor) |
(1 << TrueColor) |
(1 << DirectColor)),
8, PseudoColor, 0, 0, 0);
break;
case 16:
miSetVisualTypesAndMasks (16,
((1 << TrueColor) |
(1 << DirectColor)),
8, TrueColor, 0xf800, 0x07e0, 0x001f);
break;
case 24:
miSetVisualTypesAndMasks (24,
((1 << TrueColor) |
(1 << DirectColor)),
8, TrueColor, 0xff0000, 0x00ff00, 0x0000ff);
break;
case 32:
miSetVisualTypesAndMasks (32,
((1 << TrueColor) |
(1 << DirectColor)),
8, TrueColor, 0xff000000, 0x00ff0000, 0x0000ff00);
break;
default:
return FALSE;
}
ret = fbScreenInit(pScreen, pbits, pvfb->fb.width, pvfb->fb.height,
dpi, dpi, pvfb->fb.paddedWidth, pvfb->fb.bitsPerPixel);
#ifdef RENDER
if (ret && Render)
ret = fbPictureInit (pScreen, 0, 0);
#endif
if (!ret) return FALSE;
#if XORG < 110
miInitializeBackingStore(pScreen);
#endif
/*
* Circumvent the backing store that was just initialised. This amounts
* to a truely bizarre way of initialising SaveDoomedAreas and friends.
*/
pScreen->InstallColormap = vfbInstallColormap;
pScreen->UninstallColormap = vfbUninstallColormap;
pScreen->ListInstalledColormaps = vfbListInstalledColormaps;
pScreen->SaveScreen = vfbSaveScreen;
miPointerInitialize(pScreen, &vfbPointerSpriteFuncs, &vfbPointerCursorFuncs,
FALSE);
pScreen->blackPixel = pvfb->blackPixel;
pScreen->whitePixel = pvfb->whitePixel;
if (!pvfb->pixelFormatDefined) {
switch (pvfb->fb.depth) {
case 16:
pvfb->pixelFormatDefined = TRUE;
pvfb->rgbNotBgr = TRUE;
pvfb->blueBits = pvfb->redBits = 5;
pvfb->greenBits = 6;
break;
case 24:
case 32:
pvfb->pixelFormatDefined = TRUE;
pvfb->rgbNotBgr = TRUE;
pvfb->blueBits = pvfb->redBits = pvfb->greenBits = 8;
break;
}
}
if (pvfb->pixelFormatDefined) {
VisualPtr vis = pScreen->visuals;
for (int i = 0; i < pScreen->numVisuals; i++) {
if (pvfb->rgbNotBgr) {
vis->offsetBlue = 0;
vis->blueMask = (1 << pvfb->blueBits) - 1;
vis->offsetGreen = pvfb->blueBits;
vis->greenMask = ((1 << pvfb->greenBits) - 1) << vis->offsetGreen;
vis->offsetRed = vis->offsetGreen + pvfb->greenBits;
vis->redMask = ((1 << pvfb->redBits) - 1) << vis->offsetRed;
} else {
vis->offsetRed = 0;
vis->redMask = (1 << pvfb->redBits) - 1;
vis->offsetGreen = pvfb->redBits;
vis->greenMask = ((1 << pvfb->greenBits) - 1) << vis->offsetGreen;
vis->offsetBlue = vis->offsetGreen + pvfb->greenBits;
vis->blueMask = ((1 << pvfb->blueBits) - 1) << vis->offsetBlue;
}
vis++;
}
}
ret = fbCreateDefColormap(pScreen);
if (!ret) return FALSE;
miSetZeroLineBias(pScreen, pvfb->lineBias);
pvfb->closeScreen = pScreen->CloseScreen;
pScreen->CloseScreen = vfbCloseScreen;
#ifdef RANDR
ret = RRScreenInit(pScreen);
if (!ret) return FALSE;
rp = rrGetScrPriv(pScreen);
rp->rrGetInfo = vncRandRGetInfo;
rp->rrSetConfig = NULL;
rp->rrScreenSetSize = vncRandRScreenSetSize;
rp->rrCrtcSet = vncRandRCrtcSet;
rp->rrOutputValidateMode = vncRandROutputValidateMode;
rp->rrModeDestroy = vncRandRModeDestroy;
ret = vncRandRInit(pScreen);
if (!ret) return FALSE;
#endif
return TRUE;
} /* end vfbScreenInit */
