48514fee3c
framebuffer formats except cfb and the overlay modes should work, and
r128 and radeon need to be loaded from the ati driver (both issues to
be fixed soon). Tested on i740, s3virge, mach64, tdfx, vesa, and vga
drivers. elfloader users shouldn't be affected.
387 lines
10 KiB
C
387 lines
10 KiB
C
/*
|
|
Copyright (C) 1999. The XFree86 Project Inc.
|
|
|
|
Written by David S. Miller (davem@redhat.com)
|
|
|
|
Based largely upon the xf8_16bpp module which is
|
|
Mark Vojkovich's work.
|
|
*/
|
|
|
|
/* $XFree86$ */
|
|
|
|
#include "X.h"
|
|
#include "Xmd.h"
|
|
#include "misc.h"
|
|
#include "servermd.h"
|
|
#include "scrnintstr.h"
|
|
#include "pixmapstr.h"
|
|
#include "resource.h"
|
|
#include "colormap.h"
|
|
#include "colormapst.h"
|
|
#define PSZ 8
|
|
#include "cfb.h"
|
|
#undef PSZ
|
|
#include "cfb32.h"
|
|
#include "cfb8_32wid.h"
|
|
#include "mi.h"
|
|
#include "micmap.h"
|
|
#include "mistruct.h"
|
|
#include "gcstruct.h"
|
|
#include "dix.h"
|
|
#include "mibstore.h"
|
|
#include "xf86str.h"
|
|
#include "xf86.h"
|
|
|
|
/* CAUTION: We require that cfb8 and cfb32 were NOT
|
|
compiled with CFB_NEED_SCREEN_PRIVATE */
|
|
|
|
int cfb8_32WidScreenPrivateIndex;
|
|
int cfb8_32WidGetScreenPrivateIndex(void)
|
|
{
|
|
return cfb8_32WidScreenPrivateIndex;
|
|
}
|
|
|
|
static unsigned long cfb8_32WidGeneration = 0;
|
|
extern WindowPtr *WindowTable;
|
|
|
|
static PixmapPtr cfb8_32WidGetWindowPixmap(WindowPtr pWin);
|
|
|
|
static void
|
|
cfb8_32WidSaveAreas(
|
|
PixmapPtr pPixmap,
|
|
RegionPtr prgnSave,
|
|
int xorg,
|
|
int yorg,
|
|
WindowPtr pWin
|
|
);
|
|
|
|
static void
|
|
cfb8_32WidRestoreAreas(
|
|
PixmapPtr pPixmap,
|
|
RegionPtr prgnRestore,
|
|
int xorg,
|
|
int yorg,
|
|
WindowPtr pWin
|
|
);
|
|
|
|
static BSFuncRec cfb8_32WidBSFuncRec = {
|
|
cfb8_32WidSaveAreas,
|
|
cfb8_32WidRestoreAreas,
|
|
(BackingStoreSetClipmaskRgnProcPtr) 0,
|
|
(BackingStoreGetImagePixmapProcPtr) 0,
|
|
(BackingStoreGetSpansPixmapProcPtr) 0,
|
|
};
|
|
|
|
static void
|
|
cfb8_32WidGetSpans(
|
|
DrawablePtr pDraw,
|
|
int wMax,
|
|
DDXPointPtr ppt,
|
|
int *pwidth,
|
|
int nspans,
|
|
char *pchardstStart
|
|
);
|
|
|
|
static void
|
|
cfb8_32WidGetImage (
|
|
DrawablePtr pDraw,
|
|
int sx, int sy, int w, int h,
|
|
unsigned int format,
|
|
unsigned long planeMask,
|
|
char *pdstLine
|
|
);
|
|
|
|
static Bool cfb8_32WidCreateGC(GCPtr pGC);
|
|
static void cfb8_32WidEnableDisableFBAccess(int index, Bool enable);
|
|
|
|
|
|
static Bool
|
|
cfb8_32WidAllocatePrivates(ScreenPtr pScreen)
|
|
{
|
|
cfb8_32WidScreenPtr pScreenPriv;
|
|
|
|
if (cfb8_32WidGeneration != serverGeneration) {
|
|
if ((cfb8_32WidScreenPrivateIndex = AllocateScreenPrivateIndex()) < 0)
|
|
return FALSE;
|
|
cfb8_32WidGeneration = serverGeneration;
|
|
}
|
|
|
|
if (!(pScreenPriv = xalloc(sizeof(cfb8_32WidScreenRec))))
|
|
return FALSE;
|
|
|
|
pScreen->devPrivates[cfb8_32WidScreenPrivateIndex].ptr = (pointer)pScreenPriv;
|
|
|
|
/* All cfb will have the same GC and Window private indicies */
|
|
if (!mfbAllocatePrivates(pScreen, &cfbWindowPrivateIndex, &cfbGCPrivateIndex))
|
|
return FALSE;
|
|
|
|
/* The cfb indicies are the mfb indicies. Reallocating them resizes them */
|
|
if (!AllocateWindowPrivate(pScreen, cfbWindowPrivateIndex, sizeof(cfbPrivWin)))
|
|
return FALSE;
|
|
|
|
if (!AllocateGCPrivate(pScreen, cfbGCPrivateIndex, sizeof(cfbPrivGC)))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static Bool
|
|
cfb8_32WidSetupScreen(
|
|
ScreenPtr pScreen,
|
|
int xsize, int ysize, /* in pixels */
|
|
int dpix, int dpiy
|
|
){
|
|
if (!cfb8_32WidAllocatePrivates(pScreen))
|
|
return FALSE;
|
|
|
|
pScreen->defColormap = FakeClientID(0);
|
|
|
|
/* let CreateDefColormap do whatever it wants for pixels */
|
|
pScreen->blackPixel = pScreen->whitePixel = (Pixel) 0;
|
|
pScreen->QueryBestSize = mfbQueryBestSize;
|
|
|
|
/* SaveScreen */
|
|
pScreen->GetImage = cfb8_32WidGetImage;
|
|
pScreen->GetSpans = cfb8_32WidGetSpans;
|
|
pScreen->CreateWindow = cfb8_32WidCreateWindow;
|
|
pScreen->DestroyWindow = cfb8_32WidDestroyWindow;
|
|
pScreen->PositionWindow = cfb8_32WidPositionWindow;
|
|
pScreen->ChangeWindowAttributes = cfb8_32WidChangeWindowAttributes;
|
|
pScreen->RealizeWindow = cfb32MapWindow; /* OK */
|
|
pScreen->UnrealizeWindow = cfb32UnmapWindow; /* OK */
|
|
pScreen->PaintWindowBackground = cfb8_32WidPaintWindow;
|
|
pScreen->PaintWindowBorder = cfb8_32WidPaintWindow;
|
|
pScreen->CopyWindow = cfb8_32WidCopyWindow;
|
|
pScreen->CreatePixmap = cfb32CreatePixmap; /* OK */
|
|
pScreen->DestroyPixmap = cfb32DestroyPixmap; /* OK */
|
|
pScreen->RealizeFont = mfbRealizeFont;
|
|
pScreen->UnrealizeFont = mfbUnrealizeFont;
|
|
pScreen->CreateGC = cfb8_32WidCreateGC;
|
|
pScreen->CreateColormap = miInitializeColormap;
|
|
pScreen->DestroyColormap = (void (*)())NoopDDA;
|
|
pScreen->InstallColormap = miInstallColormap;
|
|
pScreen->UninstallColormap = miUninstallColormap;
|
|
pScreen->ListInstalledColormaps = miListInstalledColormaps;
|
|
pScreen->StoreColors = (void (*)())NoopDDA;
|
|
pScreen->ResolveColor = miResolveColor;
|
|
pScreen->BitmapToRegion = mfbPixmapToRegion;
|
|
|
|
mfbRegisterCopyPlaneProc (pScreen, cfbCopyPlane);
|
|
return TRUE;
|
|
}
|
|
|
|
static Bool
|
|
cfb8_32WidCreateScreenResources(ScreenPtr pScreen)
|
|
{
|
|
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
|
|
cfb8_32WidScreenPtr pScreenPriv = CFB8_32WID_GET_SCREEN_PRIVATE(pScreen);
|
|
PixmapPtr pix8, pix32, pixWid;
|
|
|
|
xfree(pScreen->devPrivate); /* freeing miScreenInitParmsRec */
|
|
|
|
pix8 = (*pScreen->CreatePixmap)(pScreen, 0, 0, 8);
|
|
pix32 = (*pScreen->CreatePixmap)(pScreen, 0, 0, pScrn->depth);
|
|
pixWid = (*pScreen->CreatePixmap)(pScreen, 0, 0, pScreenPriv->bitsPerWid);
|
|
if (!pix32 || !pix8 || !pixWid)
|
|
return FALSE;
|
|
|
|
pix8->drawable.width = pScreen->width;
|
|
pix8->drawable.height = pScreen->height;
|
|
pix8->devKind = pScreenPriv->width8;
|
|
pix8->devPrivate.ptr = pScreenPriv->pix8;
|
|
|
|
pix32->drawable.width = pScreen->width;
|
|
pix32->drawable.height = pScreen->height;
|
|
pix32->devKind = pScreenPriv->width32 * 4;
|
|
pix32->devPrivate.ptr = pScreenPriv->pix32;
|
|
|
|
pixWid->drawable.width = pScreen->width;
|
|
pixWid->drawable.height = pScreen->height;
|
|
pixWid->devKind = (pScreenPriv->widthWid * pScreenPriv->bitsPerWid) / 8;
|
|
pixWid->devPrivate.ptr = pScreenPriv->pixWid;
|
|
|
|
pScreenPriv->pix8 = (pointer) pix8;
|
|
pScreenPriv->pix32 = (pointer) pix32;
|
|
pScreenPriv->pixWid = (pointer) pixWid;
|
|
|
|
pScreen->devPrivate = (pointer) pix32;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static Bool
|
|
cfb8_32WidCloseScreen (int i, ScreenPtr pScreen)
|
|
{
|
|
cfb8_32WidScreenPtr pScreenPriv = CFB8_32WID_GET_SCREEN_PRIVATE(pScreen);
|
|
|
|
xfree((pointer) pScreenPriv);
|
|
|
|
return cfb32CloseScreen(i, pScreen);
|
|
}
|
|
|
|
static Bool
|
|
cfb8_32WidFinishScreenInit(
|
|
ScreenPtr pScreen,
|
|
int xsize, int ysize, /* in pixels */
|
|
int dpix, int dpiy /* dots per inch */
|
|
){
|
|
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
|
|
VisualPtr visuals;
|
|
DepthPtr depths;
|
|
int nvisuals;
|
|
int ndepths;
|
|
int rootdepth;
|
|
VisualID defaultVisual;
|
|
|
|
rootdepth = 0;
|
|
if (!miInitVisuals(&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
|
|
&defaultVisual,((unsigned long)1<<(32-1)), 8, -1))
|
|
return FALSE;
|
|
|
|
if (!miScreenInit(pScreen, NULL, xsize, ysize, dpix, dpiy, 0,
|
|
rootdepth, ndepths, depths,
|
|
defaultVisual, nvisuals, visuals))
|
|
return FALSE;
|
|
|
|
pScreen->BackingStoreFuncs = cfb8_32WidBSFuncRec;
|
|
pScreen->CreateScreenResources = cfb8_32WidCreateScreenResources;
|
|
pScreen->CloseScreen = cfb8_32WidCloseScreen;
|
|
pScreen->GetWindowPixmap = cfb8_32WidGetWindowPixmap;
|
|
pScreen->WindowExposures = cfb8_32WidWindowExposures;
|
|
|
|
pScrn->EnableDisableFBAccess = cfb8_32WidEnableDisableFBAccess;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
cfb8_32WidScreenInit(
|
|
ScreenPtr pScreen,
|
|
pointer pbits32, /* pointer to screen bitmap */
|
|
pointer pbits8,
|
|
pointer pbitsWid, /* pointer to WID bitmap */
|
|
int xsize, int ysize, /* in pixels */
|
|
int dpix, int dpiy, /* dots per inch */
|
|
int width32, /* pixel width of frame buffer */
|
|
int width8,
|
|
int widthWid,
|
|
int bitsPerWid,
|
|
cfb8_32WidOps *WIDOps
|
|
){
|
|
cfb8_32WidScreenPtr pScreenPriv;
|
|
|
|
if (!WIDOps || !WIDOps->WidGet || !WIDOps->WidAlloc || !WIDOps->WidFree)
|
|
return FALSE;
|
|
|
|
if (!cfb8_32WidSetupScreen(pScreen, xsize, ysize, dpix, dpiy))
|
|
return FALSE;
|
|
|
|
pScreenPriv = CFB8_32WID_GET_SCREEN_PRIVATE(pScreen);
|
|
pScreenPriv->pix8 = pbits8;
|
|
pScreenPriv->pix32 = pbits32;
|
|
pScreenPriv->pixWid = pbitsWid;
|
|
pScreenPriv->width8 = width8;
|
|
pScreenPriv->width32 = width32;
|
|
pScreenPriv->widthWid = widthWid;
|
|
pScreenPriv->bitsPerWid = bitsPerWid;
|
|
|
|
pScreenPriv->WIDOps = xalloc(sizeof(cfb8_32WidOps));
|
|
if (!pScreenPriv->WIDOps)
|
|
return FALSE;
|
|
|
|
*(pScreenPriv->WIDOps) = *WIDOps;
|
|
|
|
if (!WIDOps->WidFillBox || !WIDOps->WidCopyArea)
|
|
cfb8_32WidGenericOpsInit(pScreenPriv);
|
|
|
|
return cfb8_32WidFinishScreenInit(pScreen, xsize, ysize, dpix, dpiy);
|
|
}
|
|
|
|
static PixmapPtr
|
|
cfb8_32WidGetWindowPixmap(WindowPtr pWin)
|
|
{
|
|
cfb8_32WidScreenPtr pScreenPriv =
|
|
CFB8_32WID_GET_SCREEN_PRIVATE(pWin->drawable.pScreen);
|
|
|
|
return ((pWin->drawable.bitsPerPixel == 8) ?
|
|
(PixmapPtr) pScreenPriv->pix8 : (PixmapPtr) pScreenPriv->pix32);
|
|
}
|
|
|
|
static void
|
|
cfb8_32WidGetImage (DrawablePtr pDraw, int sx, int sy, int w, int h,
|
|
unsigned int format, unsigned long planemask, char *pdstLine)
|
|
{
|
|
if (!w || !h)
|
|
return;
|
|
|
|
if (pDraw->bitsPerPixel == 8)
|
|
cfbGetImage(pDraw, sx, sy, w, h, format, planemask, pdstLine);
|
|
else
|
|
cfb32GetImage(pDraw, sx, sy, w, h, format, planemask, pdstLine);
|
|
}
|
|
|
|
static void
|
|
cfb8_32WidGetSpans(DrawablePtr pDraw, int wMax, DDXPointPtr ppt, int *pwidth, int nspans, char *pDst)
|
|
{
|
|
if (pDraw->bitsPerPixel == 8)
|
|
cfbGetSpans(pDraw, wMax, ppt, pwidth, nspans, pDst);
|
|
else
|
|
cfb32GetSpans(pDraw, wMax, ppt, pwidth, nspans, pDst);
|
|
}
|
|
|
|
static void
|
|
cfb8_32WidSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg, WindowPtr pWin)
|
|
{
|
|
if (pWin->drawable.bitsPerPixel == 8)
|
|
cfbSaveAreas(pPixmap, prgnSave, xorg, yorg, pWin);
|
|
else
|
|
cfb32SaveAreas(pPixmap, prgnSave, xorg, yorg, pWin);
|
|
}
|
|
|
|
static void
|
|
cfb8_32WidRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg, int yorg, WindowPtr pWin)
|
|
{
|
|
if (pWin->drawable.bitsPerPixel == 8)
|
|
cfbRestoreAreas(pPixmap, prgnRestore, xorg, yorg, pWin);
|
|
else
|
|
cfb32RestoreAreas(pPixmap, prgnRestore, xorg, yorg, pWin);
|
|
}
|
|
|
|
|
|
static Bool
|
|
cfb8_32WidCreateGC(GCPtr pGC)
|
|
{
|
|
if (pGC->depth == 8)
|
|
return cfbCreateGC(pGC);
|
|
else
|
|
return cfb32CreateGC(pGC);
|
|
}
|
|
|
|
static void
|
|
cfb8_32WidEnableDisableFBAccess(int index, Bool enable)
|
|
{
|
|
ScreenPtr pScreen = xf86Screens[index]->pScreen;
|
|
cfb8_32WidScreenPtr pScreenPriv = CFB8_32WID_GET_SCREEN_PRIVATE(pScreen);
|
|
static DevUnion devPrivates8[MAXSCREENS];
|
|
static DevUnion devPrivates32[MAXSCREENS];
|
|
PixmapPtr pix8, pix32;
|
|
|
|
pix8 = (PixmapPtr) pScreenPriv->pix8;
|
|
pix32 = (PixmapPtr) pScreenPriv->pix32;
|
|
|
|
if (enable) {
|
|
pix8->devPrivate = devPrivates8[index];
|
|
pix32->devPrivate = devPrivates32[index];
|
|
}
|
|
|
|
xf86EnableDisableFBAccess (index, enable);
|
|
|
|
if (!enable) {
|
|
devPrivates8[index] = pix8->devPrivate;
|
|
pix8->devPrivate.ptr = 0;
|
|
devPrivates32[index] = pix32->devPrivate;
|
|
pix32->devPrivate.ptr = 0;
|
|
}
|
|
}
|