andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote branch 'dottedmag/for-keithp'

Browse Source
This commit is contained in:
Keith Packard 2010-01-07 10:32:21 -08:00
commit 8ab4749aae
26 changed files with 373 additions and 932 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
configure.ac
View File

@ -640,6 +640,10 @@ AC_ARG_ENABLE(kdrive, AS_HELP_STRING([--enable-kdrive], [Build kdrive se
AC_ARG_ENABLE(xephyr, AS_HELP_STRING([--enable-xephyr], [Build the kdrive Xephyr server (default: auto)]), [XEPHYR=$enableval], [XEPHYR=auto])
AC_ARG_ENABLE(xfake, AS_HELP_STRING([--enable-xfake], [Build the kdrive 'fake' server (default: auto)]), [XFAKE=$enableval], [XFAKE=auto])
AC_ARG_ENABLE(xfbdev, AS_HELP_STRING([--enable-xfbdev], [Build the kdrive framebuffer device server (default: auto)]), [XFBDEV=$enableval], [XFBDEV=auto])
dnl kdrive options
AC_ARG_ENABLE(kdrive-kbd, AS_HELP_STRING([--enable-kdrive-kbd], [Build kbd driver for kdrive (default: enabled)]), [KDRIVE_KBD=$enableval], [KDRIVE_KBD=yes])
AC_ARG_ENABLE(kdrive-mouse, AC_HELP_STRING([--enable-kdrive-mouse], [Build mouse driver for kdrive (default: enabled)]), [KDRIVE_MOUSE=$enableval], [KDRIVE_MOUSE=yes])
AC_ARG_ENABLE(kdrive-evdev, AC_HELP_STRING([--enable-kdrive-evdev], [Build evdev driver for kdrive (default: enabled)]), [KDRIVE_EVDEV=$enableval], [KDRIVE_EVDEV=yes])
dnl chown/chmod to be setuid root as part of build
@ -1991,6 +1995,10 @@ XEPHYR_LIBS=
XEPHYR_INCS=
AM_CONDITIONAL(KDRIVE, [test x$KDRIVE = xyes])
AM_CONDITIONAL(KDRIVE_KBD, test "x$KDRIVE_KBD" = xyes)
AM_CONDITIONAL(KDRIVE_EVDEV, test "x$KDRIVE_EVDEV" = xyes)
AM_CONDITIONAL(KDRIVE_MOUSE, test "x$KDRIVE_MOUSE" = xyes)
if test "$KDRIVE" = yes; then
AC_DEFINE(KDRIVESERVER,1,[Build Kdrive X server])
AC_DEFINE(KDRIVEDDXACTIONS,,[Build kdrive ddx])
@ -2023,6 +2031,16 @@ if test "$KDRIVE" = yes; then
fi
fi
if test "x$KDRIVE_KBD" = xyes; then
AC_DEFINE(KDRIVE_KBD, 1, [Enable KDrive kbd driver])
fi
if test "x$KDRIVE_EVDEV" = xyes; then
AC_DEFINE(KDRIVE_EVDEV, 1, [Enable KDrive evdev driver])
fi
if test "x$KDRIVE_MOUSE" = xyes; then
AC_DEFINE(KDRIVE_MOUSE, 1, [Enable KDrive mouse driver])
fi
XEPHYR_REQUIRED_LIBS="x11 $LIBXEXT xfont xau xdmcp"
if test "x$XV" = xyes; then
XEPHYR_REQUIRED_LIBS="$XEPHYR_REQUIRED_LIBS xv"

131
hw/kdrive/ephyr/ephyr.c
View File

@ -101,77 +101,77 @@ ephyrScreenInitialize (KdScreenInfo *screen, EphyrScrPriv *scrpriv)
}
if (EphyrWantGrayScale)
screen->fb[0].depth = 8;
screen->fb.depth = 8;
if (screen->fb[0].depth && screen->fb[0].depth != hostx_get_depth())
if (screen->fb.depth && screen->fb.depth != hostx_get_depth())
{
if (screen->fb[0].depth < hostx_get_depth()
&& (screen->fb[0].depth == 24 || screen->fb[0].depth == 16
|| screen->fb[0].depth == 8))
if (screen->fb.depth < hostx_get_depth()
&& (screen->fb.depth == 24 || screen->fb.depth == 16
|| screen->fb.depth == 8))
{
hostx_set_server_depth(screen, screen->fb[0].depth);
hostx_set_server_depth(screen, screen->fb.depth);
}
else
ErrorF("\nXephyr: requested screen depth not supported, setting to match hosts.\n");
}
screen->fb[0].depth = hostx_get_server_depth(screen);
screen->fb.depth = hostx_get_server_depth(screen);
screen->rate = 72;
if (screen->fb[0].depth <= 8)
if (screen->fb.depth <= 8)
{
if (EphyrWantGrayScale)
screen->fb[0].visuals = ((1 << StaticGray) | (1 << GrayScale));
screen->fb.visuals = ((1 << StaticGray) | (1 << GrayScale));
else
screen->fb[0].visuals = ((1 << StaticGray) |
(1 << GrayScale) |
(1 << StaticColor) |
(1 << PseudoColor) |
(1 << TrueColor) |
(1 << DirectColor));
screen->fb.visuals = ((1 << StaticGray) |
(1 << GrayScale) |
(1 << StaticColor) |
(1 << PseudoColor) |
(1 << TrueColor) |
(1 << DirectColor));
screen->fb[0].redMask = 0x00;
screen->fb[0].greenMask = 0x00;
screen->fb[0].blueMask = 0x00;
screen->fb[0].depth = 8;
screen->fb[0].bitsPerPixel = 8;
screen->fb.redMask = 0x00;
screen->fb.greenMask = 0x00;
screen->fb.blueMask = 0x00;
screen->fb.depth = 8;
screen->fb.bitsPerPixel = 8;
}
else
{
screen->fb[0].visuals = (1 << TrueColor);
screen->fb.visuals = (1 << TrueColor);
if (screen->fb[0].depth <= 15)
if (screen->fb.depth <= 15)
{
screen->fb[0].depth = 15;
screen->fb[0].bitsPerPixel = 16;
screen->fb.depth = 15;
screen->fb.bitsPerPixel = 16;
}
else if (screen->fb[0].depth <= 16)
else if (screen->fb.depth <= 16)
{
screen->fb[0].depth = 16;
screen->fb[0].bitsPerPixel = 16;
screen->fb.depth = 16;
screen->fb.bitsPerPixel = 16;
}
else if (screen->fb[0].depth <= 24)
else if (screen->fb.depth <= 24)
{
screen->fb[0].depth = 24;
screen->fb[0].bitsPerPixel = 32;
screen->fb.depth = 24;
screen->fb.bitsPerPixel = 32;
}
else if (screen->fb[0].depth <= 30)
else if (screen->fb.depth <= 30)
{
screen->fb[0].depth = 30;
screen->fb[0].bitsPerPixel = 32;
screen->fb.depth = 30;
screen->fb.bitsPerPixel = 32;
}
else
{
ErrorF("\nXephyr: Unsupported screen depth %d\n",
screen->fb[0].depth);
screen->fb.depth);
return FALSE;
}
hostx_get_visual_masks (screen, &redMask, &greenMask, &blueMask);
screen->fb[0].redMask = (Pixel) redMask;
screen->fb[0].greenMask = (Pixel) greenMask;
screen->fb[0].blueMask = (Pixel) blueMask;
screen->fb.redMask = (Pixel) redMask;
screen->fb.greenMask = (Pixel) greenMask;
screen->fb.blueMask = (Pixel) blueMask;
}
@ -220,6 +220,22 @@ ephyrWindowLinear (ScreenPtr pScreen,
return priv->base + row * priv->bytes_per_line + offset;
}
/**
* Figure out display buffer size. If fakexa is enabled, allocate a larger
* buffer so that fakexa has space to put offscreen pixmaps.
*/
int
ephyrBufferHeight(KdScreenInfo *screen)
{
int buffer_height;
if (ephyrFuncs.initAccel == NULL)
buffer_height = screen->height;
else
buffer_height = 3 * screen->height;
return buffer_height;
}
Bool
ephyrMapFramebuffer (KdScreenInfo *screen)
{
@ -234,30 +250,19 @@ ephyrMapFramebuffer (KdScreenInfo *screen)
KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
KdSetPointerMatrix (&m);
priv->bytes_per_line = ((screen->width * screen->fb[0].bitsPerPixel + 31) >> 5) << 2;
/* point the framebuffer to the data in an XImage */
/* If fakexa is enabled, allocate a larger buffer so that fakexa has space to
* put offscreen pixmaps.
*/
if (ephyrFuncs.initAccel == NULL)
buffer_height = screen->height;
else
buffer_height = 3 * screen->height;
priv->bytes_per_line = ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2;
buffer_height = ephyrBufferHeight(screen);
priv->base = hostx_screen_init (screen, screen->width, screen->height, buffer_height);
screen->memory_base = (CARD8 *) (priv->base);
screen->memory_size = priv->bytes_per_line * buffer_height;
screen->off_screen_base = priv->bytes_per_line * screen->height;
if ((scrpriv->randr & RR_Rotate_0) && !(scrpriv->randr & RR_Reflect_All))
{
scrpriv->shadow = FALSE;
screen->fb[0].byteStride = priv->bytes_per_line;
screen->fb[0].pixelStride = screen->width;
screen->fb[0].frameBuffer = (CARD8 *) (priv->base);
screen->fb.byteStride = priv->bytes_per_line;
screen->fb.pixelStride = screen->width;
screen->fb.frameBuffer = (CARD8 *) (priv->base);
}
else
{
@ -266,7 +271,7 @@ ephyrMapFramebuffer (KdScreenInfo *screen)
EPHYR_LOG("allocing shadow");
KdShadowFbAlloc (screen, 0,
KdShadowFbAlloc (screen,
scrpriv->randr & (RR_Rotate_90|RR_Rotate_270));
}
@ -302,7 +307,7 @@ ephyrUnmapFramebuffer (KdScreenInfo *screen)
EphyrScrPriv *scrpriv = screen->driver;
if (scrpriv->shadow)
KdShadowFbFree (screen, 0);
KdShadowFbFree (screen);
/* Note, priv->base will get freed when XImage recreated */
@ -566,10 +571,10 @@ ephyrRandRSetConfig (ScreenPtr pScreen,
(*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
pScreen->width,
pScreen->height,
screen->fb[0].depth,
screen->fb[0].bitsPerPixel,
screen->fb[0].byteStride,
screen->fb[0].frameBuffer);
screen->fb.depth,
screen->fb.bitsPerPixel,
screen->fb.byteStride,
screen->fb.frameBuffer);
/* set the subpixel order */
@ -730,7 +735,7 @@ ephyrScreenFini (KdScreenInfo *screen)
{
EphyrScrPriv *scrpriv = screen->driver;
if (scrpriv->shadow) {
KdShadowFbFree (screen, 0);
KdShadowFbFree (screen);
}
xfree(screen->driver);
screen->driver = NULL;
@ -1022,7 +1027,7 @@ ephyrCardFini (KdCardInfo *card)
}
void
ephyrGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
ephyrGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
{
/* XXX Not sure if this is right */
@ -1039,7 +1044,7 @@ ephyrGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
}
void
ephyrPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
ephyrPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
{
int min, max, p;

6
hw/kdrive/ephyr/ephyr.h
View File

@ -116,10 +116,10 @@ void
ephyrCardFini (KdCardInfo *card);
void
ephyrGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs);
ephyrGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
void
ephyrPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs);
ephyrPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
Bool
ephyrMapFramebuffer (KdScreenInfo *screen);
@ -180,6 +180,8 @@ extern Bool ephyrCursorInit(ScreenPtr pScreen);
extern void ephyrCursorEnable(ScreenPtr pScreen);
extern int ephyrBufferHeight(KdScreenInfo *screen);
/* ephyr_draw.c */
Bool

7
hw/kdrive/ephyr/ephyr_draw.c
View File

@ -428,6 +428,7 @@ ephyrDrawInit(ScreenPtr pScreen)
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
EphyrScrPriv *scrpriv = screen->driver;
EphyrPriv *priv = screen->card->driver;
EphyrFakexaPriv *fakexa;
Bool success;
@ -441,9 +442,9 @@ ephyrDrawInit(ScreenPtr pScreen)
return FALSE;
}
fakexa->exa->memoryBase = screen->memory_base;
fakexa->exa->memorySize = screen->memory_size;
fakexa->exa->offScreenBase = screen->off_screen_base;
fakexa->exa->memoryBase = (CARD8 *) (priv->base);
fakexa->exa->memorySize = priv->bytes_per_line * ephyrBufferHeight(screen);
fakexa->exa->offScreenBase = priv->bytes_per_line * screen->height;
/* Since we statically link against EXA, we shouldn't have to be smart about
* versioning.

15
hw/kdrive/ephyr/ephyrinit.c
View File

@ -40,17 +40,18 @@ extern Bool noGlxVisualInit;
#endif
extern Bool ephyrNoXV;
#ifdef KDRIVE_EVDEV
extern KdPointerDriver LinuxEvdevMouseDriver;
extern KdKeyboardDriver LinuxEvdevKeyboardDriver;
#endif
void processScreenArg (char *screen_size, char *parent_id) ;
void
InitCard (char *name)
{
KdCardAttr attr;
EPHYR_DBG("mark");
KdCardInfoAdd (&ephyrFuncs, &attr, 0);
KdCardInfoAdd (&ephyrFuncs, 0);
}
void
@ -66,11 +67,11 @@ InitInput (int argc, char **argv)
KdPointerInfo *pi;
KdAddKeyboardDriver(&EphyrKeyboardDriver);
#ifdef linux
#ifdef KDRIVE_EVDEV
KdAddKeyboardDriver(&LinuxEvdevKeyboardDriver);
#endif
KdAddPointerDriver(&EphyrMouseDriver);
#ifdef linux
#ifdef KDRIVE_EVDEV
KdAddPointerDriver(&LinuxEvdevMouseDriver);
#endif

2
hw/kdrive/ephyr/ephyrvideo.c
View File

@ -302,7 +302,7 @@ ephyrInitVideo (ScreenPtr pScreen)
EPHYR_LOG ("enter\n") ;
if (screen->fb[0].bitsPerPixel == 8) {
if (screen->fb.bitsPerPixel == 8) {
EPHYR_LOG_ERROR ("8 bits depth not supported\n") ;
return FALSE ;
}

84
hw/kdrive/fake/fake.c
View File

@ -69,45 +69,45 @@ fakeScreenInitialize (KdScreenInfo *screen, FakeScrPriv *scrpriv)
if (screen->height <= 0)
screen->height = 1;
if (!screen->fb[0].depth)
screen->fb[0].depth = 16;
if (!screen->fb.depth)
screen->fb.depth = 16;
if (screen->fb[0].depth <= 8)
if (screen->fb.depth <= 8)
{
screen->fb[0].visuals = ((1 << StaticGray) |
(1 << GrayScale) |
(1 << StaticColor) |
(1 << PseudoColor) |
(1 << TrueColor) |
(1 << DirectColor));
screen->fb.visuals = ((1 << StaticGray) |
(1 << GrayScale) |
(1 << StaticColor) |
(1 << PseudoColor) |
(1 << TrueColor) |
(1 << DirectColor));
}
else
{
screen->fb[0].visuals = (1 << TrueColor);
screen->fb.visuals = (1 << TrueColor);
#define Mask(o,l) (((1 << l) - 1) << o)
if (screen->fb[0].depth <= 15)
if (screen->fb.depth <= 15)
{
screen->fb[0].depth = 15;
screen->fb[0].bitsPerPixel = 16;
screen->fb[0].redMask = Mask (10, 5);
screen->fb[0].greenMask = Mask (5, 5);
screen->fb[0].blueMask = Mask (0, 5);
screen->fb.depth = 15;
screen->fb.bitsPerPixel = 16;
screen->fb.redMask = Mask (10, 5);
screen->fb.greenMask = Mask (5, 5);
screen->fb.blueMask = Mask (0, 5);
}
else if (screen->fb[0].depth <= 16)
else if (screen->fb.depth <= 16)
{
screen->fb[0].depth = 16;
screen->fb[0].bitsPerPixel = 16;
screen->fb[0].redMask = Mask (11, 5);
screen->fb[0].greenMask = Mask (5, 6);
screen->fb[0].blueMask = Mask (0, 5);
screen->fb.depth = 16;
screen->fb.bitsPerPixel = 16;
screen->fb.redMask = Mask (11, 5);
screen->fb.greenMask = Mask (5, 6);
screen->fb.blueMask = Mask (0, 5);
}
else
{
screen->fb[0].depth = 24;
screen->fb[0].bitsPerPixel = 32;
screen->fb[0].redMask = Mask (16, 8);
screen->fb[0].greenMask = Mask (8, 8);
screen->fb[0].blueMask = Mask (0, 8);
screen->fb.depth = 24;
screen->fb.bitsPerPixel = 32;
screen->fb.redMask = Mask (16, 8);
screen->fb.greenMask = Mask (8, 8);
screen->fb.blueMask = Mask (0, 8);
}
}
@ -167,26 +167,22 @@ fakeMapFramebuffer (KdScreenInfo *screen)
KdSetPointerMatrix (&m);
priv->bytes_per_line = ((screen->width * screen->fb[0].bitsPerPixel + 31) >> 5) << 2;
priv->bytes_per_line = ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2;
if (priv->base)
free (priv->base);
priv->base = malloc (priv->bytes_per_line * screen->height);
screen->memory_base = (CARD8 *) (priv->base);
screen->memory_size = 0;
screen->off_screen_base = 0;
if (scrpriv->shadow)
{
if (!KdShadowFbAlloc (screen, 0,
scrpriv->randr & (RR_Rotate_90|RR_Rotate_270)))
if (!KdShadowFbAlloc (screen, scrpriv->randr & (RR_Rotate_90|RR_Rotate_270)))
return FALSE;
}
else
{
screen->fb[0].byteStride = priv->bytes_per_line;
screen->fb[0].pixelStride = (priv->bytes_per_line * 8/
screen->fb[0].bitsPerPixel);
screen->fb[0].frameBuffer = (CARD8 *) (priv->base);
screen->fb.byteStride = priv->bytes_per_line;
screen->fb.pixelStride = (priv->bytes_per_line * 8/
screen->fb.bitsPerPixel);
screen->fb.frameBuffer = (CARD8 *) (priv->base);
}
return TRUE;
@ -219,7 +215,7 @@ Bool
fakeUnmapFramebuffer (KdScreenInfo *screen)
{
FakePriv *priv = screen->card->driver;
KdShadowFbFree (screen, 0);
KdShadowFbFree (screen);
if (priv->base)
{
free (priv->base);
@ -341,10 +337,10 @@ fakeRandRSetConfig (ScreenPtr pScreen,
(*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
pScreen->width,
pScreen->height,
screen->fb[0].depth,
screen->fb[0].bitsPerPixel,
screen->fb[0].byteStride,
screen->fb[0].frameBuffer);
screen->fb.depth,
screen->fb.bitsPerPixel,
screen->fb.byteStride,
screen->fb.frameBuffer);
/* set the subpixel order */
@ -463,7 +459,7 @@ fakeCardFini (KdCardInfo *card)
}
void
fakeGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
fakeGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
{
while (n--)
{
@ -475,6 +471,6 @@ fakeGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
}
void
fakePutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
fakePutColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
{
}

4
hw/kdrive/fake/fake.h
View File

@ -85,10 +85,10 @@ void
fakeCardFini (KdCardInfo *card);
void
fakeGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs);
fakeGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
void
fakePutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs);
fakePutColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
Bool
fakeMapFramebuffer (KdScreenInfo *screen);

4
hw/kdrive/fake/fakeinit.c
View File

@ -28,9 +28,7 @@
void
InitCard (char *name)
{
KdCardAttr attr;
KdCardInfoAdd (&fakeFuncs, &attr, 0);
KdCardInfoAdd (&fakeFuncs, 0);
}
void

154
hw/kdrive/fbdev/fbdev.c
View File

@ -32,10 +32,9 @@ extern int KdTsPhyScreen;
char *fbdevDevicePath = NULL;
Bool
static Bool
fbdevInitialize (KdCardInfo *card, FbdevPriv *priv)
{
int k;
unsigned long off;
if (fbdevDevicePath == NULL)
@ -50,14 +49,14 @@ fbdevInitialize (KdCardInfo *card, FbdevPriv *priv)
/* quiet valgrind */
memset (&priv->fix, '\0', sizeof (priv->fix));
if ((k=ioctl(priv->fd, FBIOGET_FSCREENINFO, &priv->fix)) < 0) {
if (ioctl(priv->fd, FBIOGET_FSCREENINFO, &priv->fix) < 0) {
perror("Error with /dev/fb ioctl FIOGET_FSCREENINFO");
close (priv->fd);
return FALSE;
}
/* quiet valgrind */
memset (&priv->var, '\0', sizeof (priv->var));
if ((k=ioctl(priv->fd, FBIOGET_VSCREENINFO, &priv->var)) < 0) {
if (ioctl(priv->fd, FBIOGET_VSCREENINFO, &priv->var) < 0) {
perror("Error with /dev/fb ioctl FIOGET_VSCREENINFO");
close (priv->fd);
return FALSE;
@ -148,7 +147,7 @@ fbdevConvertMonitorTiming (const KdMonitorTiming *t, struct fb_var_screeninfo *v
var->sync |= FB_SYNC_VERT_HIGH_ACT;
}
Bool
static Bool
fbdevScreenInitialize (KdScreenInfo *screen, FbdevScrPriv *scrpriv)
{
FbdevPriv *priv = screen->card->driver;
@ -175,12 +174,12 @@ fbdevScreenInitialize (KdScreenInfo *screen, FbdevScrPriv *scrpriv)
}
screen->rate = 103; /* FIXME: should get proper value from fb driver */
}
if (!screen->fb[0].depth)
if (!screen->fb.depth)
{
if (k >= 0)
screen->fb[0].depth = var.bits_per_pixel;
screen->fb.depth = var.bits_per_pixel;
else
screen->fb[0].depth = 16;
screen->fb.depth = 16;
}
if ((screen->width != var.xres) || (screen->height != var.yres))
@ -196,7 +195,7 @@ fbdevScreenInitialize (KdScreenInfo *screen, FbdevScrPriv *scrpriv)
}
var.activate = FB_ACTIVATE_NOW;
var.bits_per_pixel = screen->fb[0].depth;
var.bits_per_pixel = screen->fb.depth;
var.nonstd = 0;
var.grayscale = 0;
@ -222,60 +221,60 @@ fbdevScreenInitialize (KdScreenInfo *screen, FbdevScrPriv *scrpriv)
case FB_VISUAL_PSEUDOCOLOR:
if (gray)
{
screen->fb[0].visuals = (1 << StaticGray);
screen->fb.visuals = (1 << StaticGray);
/* could also support GrayScale, but what's the point? */
}
else
{
screen->fb[0].visuals = ((1 << StaticGray) |
screen->fb.visuals = ((1 << StaticGray) |
(1 << GrayScale) |
(1 << StaticColor) |
(1 << PseudoColor) |
(1 << TrueColor) |
(1 << DirectColor));
}
screen->fb[0].blueMask = 0x00;
screen->fb[0].greenMask = 0x00;
screen->fb[0].redMask = 0x00;
screen->fb.blueMask = 0x00;
screen->fb.greenMask = 0x00;
screen->fb.redMask = 0x00;
break;
case FB_VISUAL_STATIC_PSEUDOCOLOR:
if (gray)
{
screen->fb[0].visuals = (1 << StaticGray);
screen->fb.visuals = (1 << StaticGray);
}
else
{
screen->fb[0].visuals = (1 << StaticColor);
screen->fb.visuals = (1 << StaticColor);
}
screen->fb[0].blueMask = 0x00;
screen->fb[0].greenMask = 0x00;
screen->fb[0].redMask = 0x00;
screen->fb.blueMask = 0x00;
screen->fb.greenMask = 0x00;
screen->fb.redMask = 0x00;
break;
case FB_VISUAL_TRUECOLOR:
case FB_VISUAL_DIRECTCOLOR:
screen->fb[0].visuals = (1 << TrueColor);
screen->fb.visuals = (1 << TrueColor);
#define Mask(o,l) (((1 << l) - 1) << o)
screen->fb[0].redMask = Mask (priv->var.red.offset, priv->var.red.length);
screen->fb[0].greenMask = Mask (priv->var.green.offset, priv->var.green.length);
screen->fb[0].blueMask = Mask (priv->var.blue.offset, priv->var.blue.length);
screen->fb.redMask = Mask (priv->var.red.offset, priv->var.red.length);
screen->fb.greenMask = Mask (priv->var.green.offset, priv->var.green.length);
screen->fb.blueMask = Mask (priv->var.blue.offset, priv->var.blue.length);
/*
* This is a kludge so that Render will work -- fill in the gaps
* in the pixel
*/
screen->fb[0].redMask = fbdevMakeContig (screen->fb[0].redMask,
screen->fb[0].greenMask|
screen->fb[0].blueMask);
screen->fb.redMask = fbdevMakeContig (screen->fb.redMask,
screen->fb.greenMask|
screen->fb.blueMask);
screen->fb[0].greenMask = fbdevMakeContig (screen->fb[0].greenMask,
screen->fb[0].redMask|
screen->fb[0].blueMask);
screen->fb.greenMask = fbdevMakeContig (screen->fb.greenMask,
screen->fb.redMask|
screen->fb.blueMask);
screen->fb[0].blueMask = fbdevMakeContig (screen->fb[0].blueMask,
screen->fb[0].redMask|
screen->fb[0].greenMask);
screen->fb.blueMask = fbdevMakeContig (screen->fb.blueMask,
screen->fb.redMask|
screen->fb.greenMask);
allbits = screen->fb[0].redMask | screen->fb[0].greenMask | screen->fb[0].blueMask;
allbits = screen->fb.redMask | screen->fb.greenMask | screen->fb.blueMask;
depth = 32;
while (depth && !(allbits & (1 << (depth - 1))))
depth--;
@ -284,8 +283,8 @@ fbdevScreenInitialize (KdScreenInfo *screen, FbdevScrPriv *scrpriv)
return FALSE;
break;
}
screen->fb[0].depth = depth;
screen->fb[0].bitsPerPixel = priv->var.bits_per_pixel;
screen->fb.depth = depth;
screen->fb.bitsPerPixel = priv->var.bits_per_pixel;
scrpriv->randr = screen->randr;
@ -310,7 +309,7 @@ fbdevScreenInit (KdScreenInfo *screen)
return TRUE;
}
void *
static void *
fbdevWindowLinear (ScreenPtr pScreen,
CARD32 row,
CARD32 offset,
@ -345,29 +344,25 @@ fbdevMapFramebuffer (KdScreenInfo *screen)
screen->width = priv->var.xres;
screen->height = priv->var.yres;
screen->memory_base = (CARD8 *) (priv->fb);
screen->memory_size = priv->fix.smem_len;
if (scrpriv->shadow)
{
if (!KdShadowFbAlloc (screen, 0,
if (!KdShadowFbAlloc (screen,
scrpriv->randr & (RR_Rotate_90|RR_Rotate_270)))
return FALSE;
screen->off_screen_base = screen->memory_size;
}
else
{
screen->fb[0].byteStride = priv->fix.line_length;
screen->fb[0].pixelStride = (priv->fix.line_length * 8 /
screen->fb.byteStride = priv->fix.line_length;
screen->fb.pixelStride = (priv->fix.line_length * 8 /
priv->var.bits_per_pixel);
screen->fb[0].frameBuffer = (CARD8 *) (priv->fb);
screen->off_screen_base = screen->fb[0].byteStride * screen->height;
screen->fb.frameBuffer = (CARD8 *) (priv->fb);
}
return TRUE;
}
void
static void
fbdevSetScreenSizes (ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
@ -391,14 +386,14 @@ fbdevSetScreenSizes (ScreenPtr pScreen)
}
}
Bool
static Bool
fbdevUnmapFramebuffer (KdScreenInfo *screen)
{
KdShadowFbFree (screen, 0);
KdShadowFbFree (screen);
return TRUE;
}
Bool
static Bool
fbdevSetShadow (ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
@ -449,7 +444,7 @@ fbdevSetShadow (ScreenPtr pScreen)
#ifdef RANDR
Bool
static Bool
fbdevRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
{
KdScreenPriv(pScreen);
@ -480,7 +475,7 @@ fbdevRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
return TRUE;
}
Bool
static Bool
fbdevRandRSetConfig (ScreenPtr pScreen,
Rotation randr,
int rate,
@ -542,10 +537,10 @@ fbdevRandRSetConfig (ScreenPtr pScreen,
(*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
pScreen->width,
pScreen->height,
screen->fb[0].depth,
screen->fb[0].bitsPerPixel,
screen->fb[0].byteStride,
screen->fb[0].frameBuffer);
screen->fb.depth,
screen->fb.bitsPerPixel,
screen->fb.byteStride,
screen->fb.frameBuffer);
/* set the subpixel order */
@ -569,7 +564,7 @@ bail4:
return FALSE;
}
Bool
static Bool
fbdevRandRInit (ScreenPtr pScreen)
{
rrScrPrivPtr pScrPriv;
@ -584,7 +579,7 @@ fbdevRandRInit (ScreenPtr pScreen)
}
#endif
Bool
static Bool
fbdevCreateColormap (ColormapPtr pmap)
{
ScreenPtr pScreen = pmap->pScreen;
@ -604,7 +599,7 @@ fbdevCreateColormap (ColormapPtr pmap)
return FALSE;
for (i = 0; i < nent; i++)
pdefs[i].pixel = i;
fbdevGetColors (pScreen, 0, nent, pdefs);
fbdevGetColors (pScreen, nent, pdefs);
for (i = 0; i < nent; i++)
{
pmap->red[i].co.local.red = pdefs[i].red;
@ -655,6 +650,21 @@ fbdevPreserve (KdCardInfo *card)
{
}
static int
fbdevUpdateFbColormap(FbdevPriv *priv, int minidx, int maxidx)
{
struct fb_cmap cmap;
cmap.start = minidx;
cmap.len = maxidx - minidx + 1;
cmap.red = &priv->red[minidx];
cmap.green = &priv->green[minidx];
cmap.blue = &priv->blue[minidx];
cmap.transp = 0;
return ioctl(priv->fd, FBIOPUTCMAP, &cmap);
}
Bool
fbdevEnable (ScreenPtr pScreen)
{
@ -674,7 +684,6 @@ fbdevEnable (ScreenPtr pScreen)
if (priv->fix.visual == FB_VISUAL_DIRECTCOLOR)
{
struct fb_cmap cmap;
int i;
for (i = 0;
@ -686,13 +695,8 @@ fbdevEnable (ScreenPtr pScreen)
priv->green[i] = i * 65535 / ((1 << priv->var.green.length) - 1);
priv->blue[i] = i * 65535 / ((1 << priv->var.blue.length) - 1);
}
cmap.start = 0;
cmap.len = i;
cmap.red = &priv->red[0];
cmap.green = &priv->green[0];
cmap.blue = &priv->blue[0];
cmap.transp = 0;
ioctl (priv->fd, FBIOPUTCMAP, &cmap);
fbdevUpdateFbColormap(priv, 0, i);
}
return TRUE;
}
@ -748,8 +752,11 @@ fbdevCardFini (KdCardInfo *card)
xfree (priv);
}
/*
* Retrieve actual colormap and return selected n entries in pdefs.
*/
void
fbdevGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
fbdevGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
{
KdScreenPriv(pScreen);
FbdevPriv *priv = pScreenPriv->card->driver;
@ -789,12 +796,14 @@ fbdevGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
}
}
/*
* Change colormap by updating n entries described in pdefs.
*/
void
fbdevPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
fbdevPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
{
KdScreenPriv(pScreen);
FbdevPriv *priv = pScreenPriv->card->driver;
struct fb_cmap cmap;
int p;
int min, max;
@ -812,11 +821,6 @@ fbdevPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
max = p;
pdefs++;
}
cmap.start = min;
cmap.len = max - min + 1;
cmap.red = &priv->red[min];
cmap.green = &priv->green[min];
cmap.blue = &priv->blue[min];
cmap.transp = 0;
ioctl (priv->fd, FBIOPUTCMAP, &cmap);
fbdevUpdateFbColormap(priv, min, max);
}

44
hw/kdrive/fbdev/fbdev.h
View File

@ -51,18 +51,12 @@ typedef struct _fbdevScrPriv {
extern KdCardFuncs fbdevFuncs;
extern char* fbdevDevicePath;
Bool
fbdevInitialize (KdCardInfo *card, FbdevPriv *priv);
Bool
fbdevCardInit (KdCardInfo *card);
Bool
fbdevScreenInit (KdScreenInfo *screen);
Bool
fbdevScreenInitialize (KdScreenInfo *screen, FbdevScrPriv *scrpriv);
Bool
fbdevInitScreen (ScreenPtr pScreen);
@ -94,46 +88,12 @@ void
fbdevCardFini (KdCardInfo *card);
void
fbdevGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs);
fbdevGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
void
fbdevPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs);
fbdevPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
Bool
fbdevMapFramebuffer (KdScreenInfo *screen);
void *
fbdevWindowLinear (ScreenPtr pScreen,
CARD32 row,
CARD32 offset,
int mode,
CARD32 *size,
void *closure);
void
fbdevSetScreenSizes (ScreenPtr pScreen);
Bool
fbdevUnmapFramebuffer (KdScreenInfo *screen);
Bool
fbdevSetShadow (ScreenPtr pScreen);
Bool
fbdevCreateColormap (ColormapPtr pmap);
#ifdef RANDR
Bool
fbdevRandRGetInfo (ScreenPtr pScreen, Rotation *rotations);
Bool
fbdevRandRSetConfig (ScreenPtr pScreen,
Rotation randr,
int rate,
RRScreenSizePtr pSize);
Bool
fbdevRandRInit (ScreenPtr pScreen);
#endif
#endif /* _FBDEV_H_ */

4
hw/kdrive/fbdev/fbinit.c
View File

@ -28,9 +28,7 @@
void
InitCard (char *name)
{
KdCardAttr attr;
KdCardInfoAdd (&fbdevFuncs, &attr, 0);
KdCardInfoAdd (&fbdevFuncs, 0);
}
void

29
hw/kdrive/linux/Makefile.am
View File

@ -6,19 +6,22 @@ AM_CFLAGS = -DHAVE_DIX_CONFIG_H
noinst_LTLIBRARIES = liblinux.la
if TSLIB
TSLIB_C = tslib.c
liblinux_la_SOURCES =
liblinux_la_SOURCES += linux.c klinux.h
if KDRIVE_KBD
liblinux_la_SOURCES += keyboard.c
endif
KDRIVE_HW_SOURCES = \
evdev.c \
keyboard.c \
linux.c
if KDRIVE_EVDEV
liblinux_la_SOURCES += evdev.c
endif
liblinux_la_SOURCES = \
bus.c \
mouse.c \
ms.c \
ps2.c \
$(KDRIVE_HW_SOURCES) \
$(TSLIB_C)
if KDRIVE_MOUSE
liblinux_la_SOURCES += mouse.c ms.c ps2.c
endif
if TSLIB
liblinux_la_SOURCES += tslib.c
endif

132
hw/kdrive/linux/bus.c
View File

@ -1,132 +0,0 @@
/*
* Copyright © 2000 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifdef HAVE_CONFIG_H
#include <kdrive-config.h>
#endif
#include <X11/X.h>
#include <X11/Xproto.h>
#include <X11/Xpoll.h>
#include "inputstr.h"
#include "scrnintstr.h"
#include "kdrive.h"
/* /dev/adbmouse is a busmouse */
static void
BusRead (int adbPort, void *closure)
{
unsigned char buf[3];
int n;
int dx, dy;
unsigned long flags;
n = read (adbPort, buf, 3);
if (n == 3)
{
flags = KD_MOUSE_DELTA;
dx = (char) buf[1];
dy = -(char) buf[2];
if ((buf[0] & 4) == 0)
flags |= KD_BUTTON_1;
if ((buf[0] & 2) == 0)
flags |= KD_BUTTON_2;
if ((buf[0] & 1) == 0)
flags |= KD_BUTTON_3;
KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
}
}
char *BusNames[] = {
"/dev/adbmouse",
"/dev/mouse",
};
#define NUM_BUS_NAMES (sizeof (BusNames) / sizeof (BusNames[0]))
static int
BusInit (KdPointerInfo *pi)
{
int i, fd = 0;
if (!pi->path || (strcmp(pi->path, "auto") == 0))
{
for (i = 0; i < NUM_BUS_NAMES; i++)
{
if ((fd = open (BusNames[i], 0)) >= 0)
{
close(fd);
xfree(pi->path);
pi->path = strdup(BusNames[i]);
return Success;
}
}
}
else
{
if ((fd = open(pi->path, 0)) >= 0)
{
close(fd);
return Success;
}
}
return !Success;
}
static int
BusEnable (KdPointerInfo *pi)
{
int fd = open(pi->path, 0);
if (fd >= 0)
{
KdRegisterFd(fd, BusRead, pi);
pi->driverPrivate = (void *)fd;
return Success;
}
else
{
return !Success;
}
}
static void
BusDisable (KdPointerInfo *pi)
{
KdUnregisterFd(pi, (int)pi->driverPrivate, TRUE);
}
static void
BusFini (KdPointerInfo *pi)
{
return;
}
KdPointerDriver BusMouseDriver = {
"bus",
BusInit,
BusEnable,
BusDisable,
BusFini,
NULL
};

24
hw/kdrive/linux/linux.c
View File

@ -33,6 +33,22 @@
#include <X11/keysym.h>
#include <linux/apm_bios.h>
#ifdef KDRIVE_MOUSE
extern KdPointerDriver LinuxMouseDriver;
extern KdPointerDriver Ps2MouseDriver;
extern KdPointerDriver MsMouseDriver;
#endif
#ifdef TSLIB
extern KdPointerDriver TsDriver;
#endif
#ifdef KDRIVE_EVDEV
extern KdPointerDriver LinuxEvdevMouseDriver;
extern KdKeyboardDriver LinuxEvdevKeyboardDriver;
#endif
#ifdef KDRIVE_KBD
extern KdKeyboardDriver LinuxKeyboardDriver;
#endif
static int vtno;
int LinuxConsoleFd;
int LinuxApmFd = -1;
@ -345,15 +361,21 @@ LinuxFini (void)
void
KdOsAddInputDrivers (void)
{
#ifdef KDRIVE_MOUSE
KdAddPointerDriver(&LinuxMouseDriver);
KdAddPointerDriver(&MsMouseDriver);
KdAddPointerDriver(&Ps2MouseDriver);
#endif
#ifdef TSLIB
KdAddPointerDriver(&TsDriver);
#endif
#ifdef KDRIVE_EVDEV
KdAddPointerDriver(&LinuxEvdevMouseDriver);
KdAddKeyboardDriver(&LinuxKeyboardDriver);
KdAddKeyboardDriver(&LinuxEvdevKeyboardDriver);
#endif
#ifdef KDRIVE_KBD
KdAddKeyboardDriver(&LinuxKeyboardDriver);
#endif
}
static void

2
hw/kdrive/sdl/.gitignore vendored
View File

@ -1,2 +0,0 @@
# Add & Override for this directory and it's subdirectories
Xsdl

2
hw/kdrive/src/Makefile.am
View File

@ -15,12 +15,10 @@ endif
libkdrive_la_SOURCES = \
fourcc.h \
kcmap.c \
kcurscol.c \
kdrive.c \
kdrive.h \
kinfo.c \
kinput.c \
kmap.c \
kmode.c \
kshadow.c \
$(KDRIVE_XV_SOURCES) \

121
hw/kdrive/src/kcmap.c
View File

@ -30,10 +30,10 @@
*/
void
KdSetColormap (ScreenPtr pScreen, int fb)
KdSetColormap (ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
ColormapPtr pCmap = pScreenPriv->pInstalledmap[fb];
ColormapPtr pCmap = pScreenPriv->pInstalledmap;
Pixel pixels[KD_MAX_PSEUDO_SIZE];
xrgb colors[KD_MAX_PSEUDO_SIZE];
xColorItem defs[KD_MAX_PSEUDO_SIZE];
@ -41,7 +41,7 @@ KdSetColormap (ScreenPtr pScreen, int fb)
if (!pScreenPriv->card->cfuncs->putColors)
return;
if (pScreenPriv->screen->fb[fb].depth > KD_MAX_PSEUDO_DEPTH)
if (pScreenPriv->screen->fb.depth > KD_MAX_PSEUDO_DEPTH)
return;
if (!pScreenPriv->enabled)
@ -55,12 +55,12 @@ KdSetColormap (ScreenPtr pScreen, int fb)
* true/direct as well as pseudo/static visuals
*/
for (i = 0; i < (1 << pScreenPriv->screen->fb[fb].depth); i++)
for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
pixels[i] = i;
QueryColors (pCmap, (1 << pScreenPriv->screen->fb[fb].depth), pixels, colors);
QueryColors (pCmap, (1 << pScreenPriv->screen->fb.depth), pixels, colors);
for (i = 0; i < (1 << pScreenPriv->screen->fb[fb].depth); i++)
for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
{
defs[i].pixel = i;
defs[i].red = colors[i].red;
@ -69,8 +69,8 @@ KdSetColormap (ScreenPtr pScreen, int fb)
defs[i].flags = DoRed|DoGreen|DoBlue;
}
(*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen, fb,
(1 << pScreenPriv->screen->fb[fb].depth),
(*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen,
(1 << pScreenPriv->screen->fb.depth),
defs);
/* recolor hardware cursor */
@ -87,77 +87,35 @@ KdEnableColormap (ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
int i;
int fb;
Bool done = FALSE;
if (!pScreenPriv->card->cfuncs->putColors)
return;
for (fb = 0; fb < KD_MAX_FB && pScreenPriv->screen->fb[fb].depth; fb++)
if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH)
{
if (pScreenPriv->screen->fb[fb].depth <= KD_MAX_PSEUDO_DEPTH && !done)
{
for (i = 0; i < (1 << pScreenPriv->screen->fb[fb].depth); i++)
pScreenPriv->systemPalette[i].pixel = i;
(*pScreenPriv->card->cfuncs->getColors) (pScreen, fb,
(1 << pScreenPriv->screen->fb[fb].depth),
pScreenPriv->systemPalette);
done = TRUE;
}
KdSetColormap (pScreen, fb);
for (i = 0; i < (1 << pScreenPriv->screen->fb.depth); i++)
pScreenPriv->systemPalette[i].pixel = i;
(*pScreenPriv->card->cfuncs->getColors) (pScreen,
(1 << pScreenPriv->screen->fb.depth),
pScreenPriv->systemPalette);
}
KdSetColormap (pScreen);
}
void
KdDisableColormap (ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
int fb;
if (!pScreenPriv->card->cfuncs->putColors)
return;
for (fb = 0; fb < KD_MAX_FB && pScreenPriv->screen->fb[fb].depth; fb++)
{
if (pScreenPriv->screen->fb[fb].depth <= KD_MAX_PSEUDO_DEPTH)
{
(*pScreenPriv->card->cfuncs->putColors) (pScreen, fb,
(1 << pScreenPriv->screen->fb[fb].depth),
pScreenPriv->systemPalette);
break;
}
}
}
static int
KdColormapFb (ColormapPtr pCmap)
{
ScreenPtr pScreen = pCmap->pScreen;
KdScreenPriv (pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
int d;
DepthPtr depth;
int v;
VisualID vid = pCmap->pVisual->vid;
int fb;
if (screen->fb[1].depth)
if (pScreenPriv->screen->fb.depth <= KD_MAX_PSEUDO_DEPTH)
{
for (d = 0; d < pScreen->numDepths; d++)
{
depth = &pScreen->allowedDepths[d];
for (v = 0; v < depth->numVids; v++)
{
if (depth->vids[v] == vid)
{
for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++)
{
if (depth->depth == screen->fb[fb].depth)
return fb;
}
}
}
}
(*pScreenPriv->card->cfuncs->putColors) (pScreen,
(1 << pScreenPriv->screen->fb.depth),
pScreenPriv->systemPalette);
}
return 0;
}
/*
@ -173,20 +131,19 @@ void
KdInstallColormap (ColormapPtr pCmap)
{
KdScreenPriv(pCmap->pScreen);
int fb = KdColormapFb (pCmap);
if (pCmap == pScreenPriv->pInstalledmap[fb])
if (pCmap == pScreenPriv->pInstalledmap)
return;
/* Tell X clients that the installed colormap is going away. */
if (pScreenPriv->pInstalledmap[fb])
WalkTree(pScreenPriv->pInstalledmap[fb]->pScreen, TellLostMap,
(pointer) &(pScreenPriv->pInstalledmap[fb]->mid));
if (pScreenPriv->pInstalledmap)
WalkTree(pScreenPriv->pInstalledmap->pScreen, TellLostMap,
(pointer) &(pScreenPriv->pInstalledmap->mid));
/* Take note of the new installed colorscreen-> */
pScreenPriv->pInstalledmap[fb] = pCmap;
pScreenPriv->pInstalledmap = pCmap;
KdSetColormap (pCmap->pScreen, fb);
KdSetColormap (pCmap->pScreen);
/* Tell X clients of the new colormap */
WalkTree(pCmap->pScreen, TellGainedMap, (pointer) &(pCmap->mid));
@ -203,12 +160,11 @@ void
KdUninstallColormap (ColormapPtr pCmap)
{
KdScreenPriv(pCmap->pScreen);
int fb = KdColormapFb (pCmap);
Colormap defMapID;
ColormapPtr defMap;
/* ignore if not installed */
if (pCmap != pScreenPriv->pInstalledmap[fb])
if (pCmap != pScreenPriv->pInstalledmap)
return;
/* ignore attempts to uninstall default colormap */
@ -216,17 +172,17 @@ KdUninstallColormap (ColormapPtr pCmap)
if ((Colormap) pCmap->mid == defMapID)
return;
/* install default if on same fb */
/* install default */
dixLookupResourceByType((pointer *)&defMap, defMapID, RT_COLORMAP,
serverClient, DixInstallAccess);
if (defMap && KdColormapFb (defMap) == fb)
if (defMap)
(*pCmap->pScreen->InstallColormap)(defMap);
else
{
/* uninstall and clear colormap pointer */
WalkTree(pCmap->pScreen, TellLostMap,
(pointer) &(pCmap->mid));
pScreenPriv->pInstalledmap[fb] = 0;
pScreenPriv->pInstalledmap = 0;
}
}
@ -234,16 +190,12 @@ int
KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps)
{
KdScreenPriv(pScreen);
int fb;
int n = 0;
for (fb = 0; fb < KD_MAX_FB && pScreenPriv->screen->fb[fb].depth; fb++)
if (pScreenPriv->pInstalledmap)
{
if (pScreenPriv->pInstalledmap[fb])
{
*pCmaps++ = pScreenPriv->pInstalledmap[fb]->mid;
n++;
}
*pCmaps++ = pScreenPriv->pInstalledmap->mid;
n++;
}
return n;
}
@ -261,15 +213,14 @@ KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs)
KdScreenPriv(pCmap->pScreen);
VisualPtr pVisual;
xColorItem expanddefs[KD_MAX_PSEUDO_SIZE];
int fb = KdColormapFb (pCmap);
if (pCmap != pScreenPriv->pInstalledmap[fb])
if (pCmap != pScreenPriv->pInstalledmap)
return;
if (!pScreenPriv->card->cfuncs->putColors)
return;
if (pScreenPriv->screen->fb[fb].depth > KD_MAX_PSEUDO_DEPTH)
if (pScreenPriv->screen->fb.depth > KD_MAX_PSEUDO_DEPTH)
return;
if (!pScreenPriv->enabled)
@ -287,7 +238,7 @@ KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs)
pdefs = expanddefs;
}
(*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen, fb, ndef, pdefs);
(*pScreenPriv->card->cfuncs->putColors) (pCmap->pScreen, ndef, pdefs);
/* recolor hardware cursor */
if (pScreenPriv->card->cfuncs->recolorCursor)

94
hw/kdrive/src/kcurscol.c
View File

@ -1,94 +0,0 @@
/*
* Copyright © 1999 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifdef HAVE_CONFIG_H
#include <kdrive-config.h>
#endif
#include "kdrive.h"
#include "cursorstr.h"
static int
KdComputeCmapShift (unsigned long mask)
{
int shift;
unsigned long bit;
shift = 16;
bit = 0x80000000;
while (!(mask & bit))
{
shift--;
bit >>= 1;
}
return shift;
}
#define Shift(v,d) ((d) < 0 ? ((v) >> (-d)) : ((v) << (d)))
void
KdAllocateCursorPixels (ScreenPtr pScreen,
int fb,
CursorPtr pCursor,
Pixel *source,
Pixel *mask)
{
xColorItem sourceColor, maskColor;
int r, g, b;
KdScreenPriv(pScreen);
if (pScreenPriv->screen->fb[fb].redMask)
{
r = KdComputeCmapShift (pScreenPriv->screen->fb[fb].redMask);
g = KdComputeCmapShift (pScreenPriv->screen->fb[fb].greenMask);
b = KdComputeCmapShift (pScreenPriv->screen->fb[fb].blueMask);
*source = ((Shift(pCursor->foreRed,r) & pScreenPriv->screen->fb[fb].redMask) |
(Shift(pCursor->foreGreen,g) & pScreenPriv->screen->fb[fb].greenMask) |
(Shift(pCursor->foreBlue,b) & pScreenPriv->screen->fb[fb].blueMask));
*mask = ((Shift(pCursor->backRed,r) & pScreenPriv->screen->fb[fb].redMask) |
(Shift(pCursor->backGreen,g) & pScreenPriv->screen->fb[fb].greenMask) |
(Shift(pCursor->backBlue,b) & pScreenPriv->screen->fb[fb].blueMask));
}
else
{
/*
* Set these to an invalid pixel value so that
* when the store colors comes through, the cursor
* won't get recolored
*/
*source = ~0;
*mask = ~0;
sourceColor.red = pCursor->foreRed;
sourceColor.green = pCursor->foreGreen;
sourceColor.blue = pCursor->foreBlue;
FakeAllocColor(pScreenPriv->pInstalledmap[fb], &sourceColor);
maskColor.red = pCursor->backRed;
maskColor.green = pCursor->backGreen;
maskColor.blue = pCursor->backBlue;
FakeAllocColor(pScreenPriv->pInstalledmap[fb], &maskColor);
FakeFreeColor(pScreenPriv->pInstalledmap[fb], sourceColor.pixel);
FakeFreeColor(pScreenPriv->pInstalledmap[fb], maskColor.pixel);
*source = sourceColor.pixel;
*mask = maskColor.pixel;
}
}

109
hw/kdrive/src/kdrive.c
View File

@ -389,7 +389,6 @@ KdParseScreen (KdScreenInfo *screen,
{
char delim;
char save[1024];
int fb;
int i;
int pixels, mm;
@ -403,8 +402,7 @@ KdParseScreen (KdScreenInfo *screen,
screen->height_mm = 0;
screen->subpixel_order = kdSubpixelOrder;
screen->rate = 0;
for (fb = 0; fb < KD_MAX_FB; fb++)
screen->fb[fb].depth = 0;
screen->fb.depth = 0;
if (!arg)
return;
if (strlen (arg) >= sizeof (save))
@ -477,25 +475,18 @@ KdParseScreen (KdScreenInfo *screen,
screen->randr |= RR_Reflect_Y;
}
fb = 0;
while (fb < KD_MAX_FB)
arg = KdParseFindNext (arg, "x/,", save, &delim);
if (save[0])
{
arg = KdParseFindNext (arg, "x/,", save, &delim);
if (!save[0])
break;
screen->fb[fb].depth = atoi(save);
screen->fb.depth = atoi(save);
if (delim == '/')
{
arg = KdParseFindNext (arg, "x,", save, &delim);
if (!save[0])
break;
screen->fb[fb].bitsPerPixel = atoi (save);
if (save[0])
screen->fb.bitsPerPixel = atoi (save);
}
else
screen->fb[fb].bitsPerPixel = 0;
if (delim != ',')
break;
fb++;
screen->fb.bitsPerPixel = 0;
}
if (delim == 'x')
@ -538,7 +529,7 @@ void
KdUseMsg (void)
{
ErrorF("\nTinyX Device Dependent Usage:\n");
ErrorF("-screen WIDTH[/WIDTHMM]xHEIGHT[/HEIGHTMM][@ROTATION][X][Y][xDEPTH/BPP{,DEPTH/BPP}[xFREQ]] Specify screen characteristics\n");
ErrorF("-screen WIDTH[/WIDTHMM]xHEIGHT[/HEIGHTMM][@ROTATION][X][Y][xDEPTH/BPP[xFREQ]] Specify screen characteristics\n");
ErrorF("-rgba rgb/bgr/vrgb/vbgr/none Specify subpixel ordering for LCD panels\n");
ErrorF("-mouse driver [,n,,options] Specify the pointer driver and its options (n is the number of buttons)\n");
ErrorF("-keybd driver [,,options] Specify the keyboard driver and its options\n");
@ -919,7 +910,6 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
KdScreenInfo *screen = kdCurrentScreen;
KdCardInfo *card = screen->card;
KdPrivScreenPtr pScreenPriv;
int fb;
/*
* note that screen->fb is set up for the nominal orientation
* of the screen; that means if randr is rotated, the values
@ -949,8 +939,7 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
screen->pScreen = pScreen;
pScreenPriv->screen = screen;
pScreenPriv->card = card;
for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++)
pScreenPriv->bytesPerPixel[fb] = screen->fb[fb].bitsPerPixel >> 3;
pScreenPriv->bytesPerPixel = screen->fb.bitsPerPixel >> 3;
pScreenPriv->dpmsState = KD_DPMS_NORMAL;
#ifdef PANORAMIX
dixScreenOrigins[pScreen->myNum] = screen->origin;
@ -964,11 +953,11 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
* backing store
*/
if (!fbSetupScreen (pScreen,
screen->fb[0].frameBuffer,
screen->fb.frameBuffer,
width, height,
monitorResolution, monitorResolution,
screen->fb[0].pixelStride,
screen->fb[0].bitsPerPixel))
screen->fb.pixelStride,
screen->fb.bitsPerPixel))
{
return FALSE;
}
@ -984,36 +973,14 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
pScreen->SaveScreen = KdSaveScreen;
pScreen->CreateWindow = KdCreateWindow;
#if KD_MAX_FB > 1
if (screen->fb[1].depth)
if (!fbFinishScreenInit (pScreen,
screen->fb.frameBuffer,
width, height,
monitorResolution, monitorResolution,
screen->fb.pixelStride,
screen->fb.bitsPerPixel))
{
if (!fbOverlayFinishScreenInit (pScreen,
screen->fb[0].frameBuffer,
screen->fb[1].frameBuffer,
width, height,
monitorResolution, monitorResolution,
screen->fb[0].pixelStride,
screen->fb[1].pixelStride,
screen->fb[0].bitsPerPixel,
screen->fb[1].bitsPerPixel,
screen->fb[0].depth,
screen->fb[1].depth))
{
return FALSE;
}
}
else
#endif
{
if (!fbFinishScreenInit (pScreen,
screen->fb[0].frameBuffer,
width, height,
monitorResolution, monitorResolution,
screen->fb[0].pixelStride,
screen->fb[0].bitsPerPixel))
{
return FALSE;
}
return FALSE;
}
/*
@ -1143,7 +1110,6 @@ KdSetPixmapFormats (ScreenInfo *pScreenInfo)
KdScreenInfo *screen;
int i;
int bpp;
int fb;
PixmapFormatRec *format;
for (i = 1; i <= 32; i++)
@ -1159,16 +1125,13 @@ KdSetPixmapFormats (ScreenInfo *pScreenInfo)
{
for (screen = card->screenList; screen; screen = screen->next)
{
for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++)
{
bpp = screen->fb[fb].bitsPerPixel;
if (bpp == 24)
bpp = 32;
if (!depthToBpp[screen->fb[fb].depth])
depthToBpp[screen->fb[fb].depth] = bpp;
else if (depthToBpp[screen->fb[fb].depth] != bpp)
return FALSE;
}
bpp = screen->fb.bitsPerPixel;
if (bpp == 24)
bpp = 32;
if (!depthToBpp[screen->fb.depth])
depthToBpp[screen->fb.depth] = bpp;
else if (depthToBpp[screen->fb.depth] != bpp)
return FALSE;
}
}
@ -1214,20 +1177,15 @@ KdAddScreen (ScreenInfo *pScreenInfo,
{
unsigned long visuals;
Pixel rm, gm, bm;
int fb;
visuals = 0;
rm = gm = bm = 0;
for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++)
if (pScreenInfo->formats[i].depth == screen->fb.depth)
{
if (pScreenInfo->formats[i].depth == screen->fb[fb].depth)
{
visuals = screen->fb[fb].visuals;
rm = screen->fb[fb].redMask;
gm = screen->fb[fb].greenMask;
bm = screen->fb[fb].blueMask;
break;
}
visuals = screen->fb.visuals;
rm = screen->fb.redMask;
gm = screen->fb.greenMask;
bm = screen->fb.blueMask;
}
fbSetVisualTypesAndMasks (pScreenInfo->formats[i].depth,
visuals,
@ -1246,10 +1204,9 @@ int
KdDepthToFb (ScreenPtr pScreen, int depth)
{
KdScreenPriv(pScreen);
int fb;
for (fb = 0; fb <= KD_MAX_FB && pScreenPriv->screen->fb[fb].frameBuffer; fb++)
if (pScreenPriv->screen->fb[fb].depth == depth)
for (fb = 0; fb <= KD_MAX_FB && pScreenPriv->screen->fb.frameBuffer; fb++)
if (pScreenPriv->screen->fb.depth == depth)
return fb;
}

92
hw/kdrive/src/kdrive.h
View File

@ -53,45 +53,15 @@
#define KD_DPMS_POWERDOWN 3
#define KD_DPMS_MAX KD_DPMS_POWERDOWN
#ifndef KD_MAX_FB
#define KD_MAX_FB FB_OVERLAY_MAX
#endif
#ifndef KD_MAX_CARD_ADDRESS
#define KD_MAX_CARD_ADDRESS 8
#endif
#define Status int
/*
* Configuration information per video card
*/
typedef struct _KdCardAttr {
CARD32 io;
CARD32 address[KD_MAX_CARD_ADDRESS];
int naddr;
/* PCI bus info */
CARD16 vendorID;
CARD16 deviceID;
CARD8 domain;
CARD8 bus;
CARD8 slot;
CARD8 func;
} KdCardAttr;
typedef struct _KdCardInfo {
struct _KdCardFuncs *cfuncs;
void *closure;
KdCardAttr attr;
void *driver;
struct _KdScreenInfo *screenList;
int selected;
struct _KdCardInfo *next;
Bool needSync;
int lastMarker;
} KdCardInfo;
extern KdCardInfo *kdCardInfo;
@ -130,10 +100,7 @@ typedef struct _KdScreenInfo {
Bool softCursor;
int mynum;
DDXPointRec origin;
KdFrameBuffer fb[KD_MAX_FB];
CARD8 *memory_base;
unsigned long memory_size;
unsigned long off_screen_base;
KdFrameBuffer fb;
} KdScreenInfo;
typedef struct _KdCardFuncs {
@ -161,8 +128,8 @@ typedef struct _KdCardFuncs {
void (*disableAccel) (ScreenPtr);
void (*finiAccel) (ScreenPtr);
void (*getColors) (ScreenPtr, int, int, xColorItem *);
void (*putColors) (ScreenPtr, int, int, xColorItem *);
void (*getColors) (ScreenPtr, int, xColorItem *);
void (*putColors) (ScreenPtr, int, xColorItem *);
} KdCardFuncs;
@ -175,11 +142,11 @@ typedef struct {
Bool enabled;
Bool closed;
int bytesPerPixel[KD_MAX_FB];
int bytesPerPixel;
int dpmsState;
ColormapPtr pInstalledmap[KD_MAX_FB]; /* current colormap */
ColormapPtr pInstalledmap; /* current colormap */
xColorItem systemPalette[KD_MAX_PSEUDO_SIZE];/* saved windows colors */
CreateScreenResourcesProcPtr CreateScreenResources;
@ -392,12 +359,9 @@ extern KdOsFuncs *kdOsFuncs;
dixSetPrivate(&(pScreen)->devPrivates, kdScreenPrivateKey, v)
#define KdScreenPriv(pScreen) KdPrivScreenPtr pScreenPriv = KdGetScreenPriv(pScreen)
/* knoop.c */
extern GCOps kdNoopOps;
/* kcmap.c */
void
KdSetColormap (ScreenPtr pScreen, int fb);
KdSetColormap (ScreenPtr pScreen);
void
KdEnableColormap (ScreenPtr pScreen);
@ -417,14 +381,6 @@ KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps);
void
KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs);
/* kcurscol.c */
void
KdAllocateCursorPixels (ScreenPtr pScreen,
int fb,
CursorPtr pCursor,
Pixel *source,
Pixel *mask);
/* kdrive.c */
extern miPointerScreenFuncRec kdPointerScreenFuncs;
@ -527,7 +483,6 @@ KdBacktrace (int signum);
/* kinfo.c */
KdCardInfo *
KdCardInfoAdd (KdCardFuncs *funcs,
KdCardAttr *attr,
void *closure);
KdCardInfo *
@ -624,37 +579,6 @@ KdRingBell (KdKeyboardInfo *ki,
int pitch,
int duration);
extern KdPointerDriver LinuxMouseDriver;
extern KdPointerDriver LinuxEvdevMouseDriver;
extern KdPointerDriver Ps2MouseDriver;
extern KdPointerDriver BusMouseDriver;
extern KdPointerDriver MsMouseDriver;
extern KdPointerDriver TsDriver;
extern KdKeyboardDriver LinuxKeyboardDriver;
extern KdKeyboardDriver LinuxEvdevKeyboardDriver;
extern KdOsFuncs LinuxFuncs;
extern KdPointerDriver VxWorksMouseDriver;
extern KdKeyboardDriver VxWorksKeyboardDriver;
extern KdOsFuncs VxWorksFuncs;
/* kmap.c */
#define KD_MAPPED_MODE_REGISTERS 0
#define KD_MAPPED_MODE_FRAMEBUFFER 1
void *
KdMapDevice (CARD32 addr, CARD32 size);
void
KdUnmapDevice (void *addr, CARD32 size);
void
KdSetMappedMode (CARD32 addr, CARD32 size, int mode);
void
KdResetMappedMode (CARD32 addr, CARD32 size, int mode);
/* kmode.c */
const KdMonitorTiming *
KdFindMode (KdScreenInfo *screen,
@ -684,10 +608,10 @@ KdRandRGetTiming (ScreenPtr pScreen,
/* kshadow.c */
Bool
KdShadowFbAlloc (KdScreenInfo *screen, int fb, Bool rotate);
KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate);
void
KdShadowFbFree (KdScreenInfo *screen, int fb);
KdShadowFbFree (KdScreenInfo *screen);
Bool
KdShadowSet (ScreenPtr pScreen, int randr, ShadowUpdateProc update, ShadowWindowProc window);

2
hw/kdrive/src/kinfo.c
View File

@ -29,7 +29,6 @@ KdCardInfo *kdCardInfo;
KdCardInfo *
KdCardInfoAdd (KdCardFuncs *funcs,
KdCardAttr *attr,
void *closure)
{
KdCardInfo *ci, **prev;
@ -40,7 +39,6 @@ KdCardInfoAdd (KdCardFuncs *funcs,
for (prev = &kdCardInfo; *prev; prev = &(*prev)->next);
*prev = ci;
ci->cfuncs = funcs;
ci->attr = *attr;
ci->closure = closure;
ci->screenList = 0;
ci->selected = 0;

172
hw/kdrive/src/kmap.c
View File

@ -1,172 +0,0 @@
/*
* Copyright © 1999 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <kdrive-config.h>
#include "kdrive.h"
#include <errno.h>
#include <unistd.h>
#include <sys/mman.h>
#ifdef HAVE_ASM_MTRR_H
#include <asm/mtrr.h>
#endif
#include <sys/ioctl.h>
void *
KdMapDevice (CARD32 addr, CARD32 size)
{
#ifdef WINDOWS
void *a;
void *d;
d = VirtualAlloc (NULL, size, MEM_RESERVE, PAGE_NOACCESS);
if (!d)
return NULL;
DRAW_DEBUG ((DEBUG_S3INIT, "Virtual address of 0x%x is 0x%x", addr, d));
a = VirtualCopyAddr (addr);
DRAW_DEBUG ((DEBUG_S3INIT, "Translated address is 0x%x", a));
if (!VirtualCopy (d, a, size,
PAGE_READWRITE|PAGE_NOCACHE|PAGE_PHYSICAL))
{
DRAW_DEBUG ((DEBUG_FAILURE, "VirtualCopy failed %d",
GetLastError ()));
return NULL;
}
DRAW_DEBUG ((DEBUG_S3INIT, "Device mapped successfully"));
return d;
#endif
#ifdef linux
void *a;
int fd;
#ifdef __arm__
fd = open ("/dev/mem", O_RDWR|O_SYNC);
#else
fd = open ("/dev/mem", O_RDWR);
#endif
if (fd < 0)
FatalError ("KdMapDevice: failed to open /dev/mem (%s)\n",
strerror (errno));
a = mmap ((caddr_t) 0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, addr);
close (fd);
if ((long) a == -1)
FatalError ("KdMapDevice: failed to map frame buffer (%s)\n",
strerror (errno));
return a;
#endif
}
void
KdUnmapDevice (void *addr, CARD32 size)
{
#ifdef WINDOWS
VirtualFree (addr, size, MEM_DECOMMIT);
VirtualFree (addr, 0, MEM_RELEASE);
#endif
#ifdef linux
munmap (addr, size);
#endif
}
#ifdef HAVE_ASM_MTRR_H
static int mtrr;
#endif
void
KdSetMappedMode (CARD32 addr, CARD32 size, int mode)
{
#ifdef HAVE_ASM_MTRR_H
struct mtrr_sentry sentry;
unsigned long base, bound;
unsigned int type = MTRR_TYPE_WRBACK;
if (addr < 0x100000)
return;
if (!mtrr)
mtrr = open ("/proc/mtrr", 2);
if (mtrr > 0)
{
unsigned long nsize;
base = addr & ~((1<<22)-1);
bound = ((addr + size) + ((1<<22) - 1)) & ~((1<<22) - 1);
nsize = 1;
while (nsize < (bound - base))
nsize <<= 1;
switch (mode) {
case KD_MAPPED_MODE_REGISTERS:
type = MTRR_TYPE_UNCACHABLE;
break;
case KD_MAPPED_MODE_FRAMEBUFFER:
type = MTRR_TYPE_WRCOMB;
break;
}
sentry.base = base;
sentry.size = nsize;
sentry.type = type;
if (ioctl (mtrr, MTRRIOC_ADD_ENTRY, &sentry) < 0)
ErrorF ("MTRRIOC_ADD_ENTRY failed 0x%x 0x%x %d (%s)\n",
base, bound - base, type, strerror(errno));
}
#endif
}
void
KdResetMappedMode (CARD32 addr, CARD32 size, int mode)
{
#ifdef HAVE_ASM_MTRR_H
struct mtrr_sentry sentry;
unsigned long base, bound;
unsigned int type = MTRR_TYPE_WRBACK;
if (addr < 0x100000)
return;
if (!mtrr)
mtrr = open ("/proc/mtrr", 2);
if (mtrr > 0)
{
unsigned long nsize;
base = addr & ~((1<<22)-1);
bound = ((addr + size) + ((1<<22) - 1)) & ~((1<<22) - 1);
nsize = 1;
while (nsize < (bound - base))
nsize <<= 1;
switch (mode) {
case KD_MAPPED_MODE_REGISTERS:
type = MTRR_TYPE_UNCACHABLE;
break;
case KD_MAPPED_MODE_FRAMEBUFFER:
type = MTRR_TYPE_WRCOMB;
break;
}
sentry.base = base;
sentry.size = nsize;
sentry.type = type;
if (ioctl (mtrr, MTRRIOC_DEL_ENTRY, &sentry) < 0)
ErrorF ("MTRRIOC_DEL_ENTRY failed 0x%x 0x%x %d (%s)\n",
base, bound - base, type, strerror(errno));
}
#endif
}

10
hw/kdrive/src/kmode.c
View File

@ -321,12 +321,10 @@ KdTuneMode (KdScreenInfo *screen,
/*
* Fix requested depth and geometry until it works
*/
if (screen->fb[1].depth)
screen->fb[1].depth = 0;
else if (screen->fb[0].depth > 16)
screen->fb[0].depth = 16;
else if (screen->fb[0].depth > 8)
screen->fb[0].depth = 8;
if (screen->fb.depth > 16)
screen->fb.depth = 16;
else if (screen->fb.depth > 8)
screen->fb.depth = 8;
else
{
t = kdFindPrevSize (KdFindMode (screen, supported));

34
hw/kdrive/src/kshadow.c
View File

@ -26,36 +26,36 @@
#include "kdrive.h"
Bool
KdShadowFbAlloc (KdScreenInfo *screen, int fb, Bool rotate)
KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate)
{
int paddedWidth;
void *buf;
int width = rotate ? screen->height : screen->width;
int height = rotate ? screen->width : screen->height;
int bpp = screen->fb[fb].bitsPerPixel;
int bpp = screen->fb.bitsPerPixel;
/* use fb computation for width */
paddedWidth = ((width * bpp + FB_MASK) >> FB_SHIFT) * sizeof (FbBits);
buf = xalloc (paddedWidth * height);
if (!buf)
return FALSE;
if (screen->fb[fb].shadow)
xfree (screen->fb[fb].frameBuffer);
screen->fb[fb].shadow = TRUE;
screen->fb[fb].frameBuffer = buf;
screen->fb[fb].byteStride = paddedWidth;
screen->fb[fb].pixelStride = paddedWidth * 8 / bpp;
if (screen->fb.shadow)
xfree (screen->fb.frameBuffer);
screen->fb.shadow = TRUE;
screen->fb.frameBuffer = buf;
screen->fb.byteStride = paddedWidth;
screen->fb.pixelStride = paddedWidth * 8 / bpp;
return TRUE;
}
void
KdShadowFbFree (KdScreenInfo *screen, int fb)
KdShadowFbFree (KdScreenInfo *screen)
{
if (screen->fb[fb].shadow)
if (screen->fb.shadow)
{
xfree (screen->fb[fb].frameBuffer);
screen->fb[fb].frameBuffer = 0;
screen->fb[fb].shadow = FALSE;
xfree (screen->fb.frameBuffer);
screen->fb.frameBuffer = 0;
screen->fb.shadow = FALSE;
}
}
@ -64,14 +64,12 @@ KdShadowSet (ScreenPtr pScreen, int randr, ShadowUpdateProc update, ShadowWindow
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
int fb;
shadowRemove (pScreen, pScreen->GetScreenPixmap(pScreen));
for (fb = 0; fb < KD_MAX_FB && screen->fb[fb].depth; fb++)
if(screen->fb.shadow)
{
if (screen->fb[fb].shadow)
return shadowAdd (pScreen, pScreen->GetScreenPixmap(pScreen),
update, window, randr, 0);
return shadowAdd (pScreen, pScreen->GetScreenPixmap(pScreen),
update, window, randr, 0);
}
return TRUE;
}

9
include/kdrive-config.h.in
View File

@ -19,6 +19,15 @@
/* Support tslib touchscreen abstraction library */
#undef TSLIB
/* Support KDrive kbd driver */
#undef KDRIVE_KBD
/* Support KDrive mouse driver */
#undef KDRIVE_MOUSE
/* Support KDrive evdev driver */
#undef KDRIVE_EVDEV
/* Verbose debugging output hilarity */
#undef DEBUG