frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

xfbdev: Remove 

With the shadow framebuffer overallocation bug fixed (ref below), Xorg +
fbdev has tens to hundreds of kilobytes more baseline memory usage than
Xfbdev. That's not nothing, but it's little enough that we should focus
our efforts on the server that actually gets development attention.

https://cgit.freedesktop.org/xorg/driver/xf86-video-fbdev/commit/?id=2c5eba8

Signed-off-by: Adam Jackson <ajax@redhat.com>
Acked-by: Alex Deucher <alexander.deucher@amd.com>
This commit is contained in:
Adam Jackson 2017-02-16 12:46:22 -05:00
parent 35fbcb3f99
commit feed7e3f98
8 changed files with 1 additions and 1177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
configure.ac
View File

@ -659,7 +659,6 @@ AC_ARG_ENABLE(glamor, AS_HELP_STRING([--enable-glamor], [Build glamor di
dnl kdrive and its subsystems
AC_ARG_ENABLE(kdrive, AS_HELP_STRING([--enable-kdrive], [Build kdrive servers (default: no)]), [KDRIVE=$enableval], [KDRIVE=no])
AC_ARG_ENABLE(xephyr, AS_HELP_STRING([--enable-xephyr], [Build the kdrive Xephyr server (default: auto)]), [XEPHYR=$enableval], [XEPHYR=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-evdev, AS_HELP_STRING([--enable-kdrive-evdev], [Build evdev driver for kdrive (default: auto)]), [KDRIVE_EVDEV=$enableval], [KDRIVE_EVDEV=auto])
AC_ARG_ENABLE(libunwind, AS_HELP_STRING([--enable-libunwind], [Use libunwind for backtracing (default: auto)]), [LIBUNWIND="$enableval"], [LIBUNWIND="auto"])
@ -2371,17 +2370,6 @@ if test "$KDRIVE" = yes; then
AC_DEFINE(KDRIVESERVER,1,[Build Kdrive X server])
AC_DEFINE(KDRIVEDDXACTIONS,,[Build kdrive ddx])
AC_CHECK_HEADERS([linux/fb.h])
if test "$ac_cv_header_linux_fb_h" = yes && test "x$XFBDEV" = xauto; then
XFBDEV=yes
fi
if test "x$XFBDEV" = xyes; then
KDRIVEFBDEVLIB=yes
AC_DEFINE(KDRIVEFBDEV, 1, [Build fbdev-based kdrive server])
fi
PKG_CHECK_MODULES([TSLIB], [tslib-0.0], [HAVE_TSLIB="yes"], [HAVE_TSLIB="no"])
if test "x$HAVE_TSLIB" = xno; then
AC_CHECK_LIB(ts, ts_open, [
@ -2471,9 +2459,7 @@ AC_SUBST([KDRIVE_LIBS])
AM_CONDITIONAL(KDRIVELINUX, [test "x$KDRIVELINUX" = xyes])
AM_CONDITIONAL(KDRIVE_EVDEV, [test "x$KDRIVE_EVDEV" = xyes])
AM_CONDITIONAL(TSLIB, [test "x$HAVE_TSLIB" = xyes])
AM_CONDITIONAL(KDRIVEFBDEV, [test "x$XFBDEV" = xyes])
AM_CONDITIONAL(XEPHYR, [test "x$KDRIVE" = xyes && test "x$XEPHYR" = xyes])
AM_CONDITIONAL(BUILD_KDRIVEFBDEVLIB, [test "x$KDRIVE" = xyes && test "x$KDRIVEFBDEVLIB" = xyes])
dnl Xwayland DDX
@ -2654,7 +2640,6 @@ hw/xquartz/xpr/Makefile
hw/kdrive/Makefile
hw/kdrive/ephyr/Makefile
hw/kdrive/ephyr/man/Makefile
hw/kdrive/fbdev/Makefile
hw/kdrive/linux/Makefile
hw/kdrive/src/Makefile
hw/xwayland/Makefile

7
hw/kdrive/Makefile.am
View File

@ -1,7 +1,3 @@
if BUILD_KDRIVEFBDEVLIB
FBDEV_SUBDIRS = fbdev
endif
if XEPHYR
XEPHYR_SUBDIRS = ephyr
endif
@ -11,7 +7,6 @@ LINUX_SUBDIRS = linux
endif
SERVER_SUBDIRS = \
$(FBDEV_SUBDIRS) \
$(XEPHYR_SUBDIRS)
SUBDIRS = \
@ -19,7 +14,7 @@ SUBDIRS = \
$(LINUX_SUBDIRS) \
$(SERVER_SUBDIRS)
DIST_SUBDIRS = fbdev ephyr src linux
DIST_SUBDIRS = ephyr src linux
relink:
$(AM_V_at)for i in $(SERVER_SUBDIRS) ; do $(MAKE) -C $$i relink || exit 1 ; done

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

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

30
hw/kdrive/fbdev/Makefile.am
View File

@ -1,30 +0,0 @@
AM_CPPFLAGS = \
@KDRIVE_INCS@ \
@KDRIVE_CFLAGS@
noinst_LTLIBRARIES = libfbdev.la
libfbdev_la_SOURCES = \
fbdev.c \
fbdev.h
if KDRIVEFBDEV
bin_PROGRAMS = Xfbdev
Xfbdev_SOURCES = \
fbinit.c
Xfbdev_LDADD = \
libfbdev.la \
@KDRIVE_MAIN_LIB@ \
@KDRIVE_LIBS@
Xfbdev_DEPENDENCIES = \
libfbdev.la \
$(KDRIVE_PURE_LIBS)
Xfbdev_LDFLAGS = $(LD_EXPORT_SYMBOLS_FLAG)
relink:
$(AM_V_at)rm -f $(bin_PROGRAMS) && $(MAKE) $(bin_PROGRAMS)
endif

28
hw/kdrive/fbdev/Xfbdev.man
View File

@ -1,28 +0,0 @@
.\" $RCSId: xc/programs/Xserver/hw/kdrive/fbdev/Xfbdev.man,v 1.4 2001/01/27 18:20:40 dawes Exp $
.\"
.TH Xfbdev 1 __vendorversion__
.SH NAME
Xfbdev \- Linux framebuffer device tiny X server
.SH SYNOPSIS
.B Xfbdev
.RI [ :display ]
.RI [ option ...]
.SH DESCRIPTION
.B Xfbdev
is a generic X server for Linux.
.B Xfbdev
doesn't know about any particular hardware, and uses the framebuffer
provided by the Linux framebuffer device.
.SH OPTIONS
.B Xfbdev
accepts the common options of the Xkdrive family of servers. Please
see Xkdrive(1).
.SH KEYBOARD
To be written.
.SH SEE ALSO
X(__miscmansuffix__), Xserver(1), Xkdrive(1), xdm(1), xinit(1).
.SH AUTHORS
The
.B Xfbdev
server was written by Keith Packard.

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

@ -1,892 +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 "fbdev.h"
#include <sys/ioctl.h>
#include <errno.h>
const char *fbdevDevicePath = NULL;
static Bool
fbdevInitialize(KdCardInfo * card, FbdevPriv * priv)
{
unsigned long off;
if (fbdevDevicePath == NULL)
fbdevDevicePath = "/dev/fb0";
if ((priv->fd = open(fbdevDevicePath, O_RDWR)) < 0) {
ErrorF("Error opening framebuffer %s: %s\n",
fbdevDevicePath, strerror(errno));
return FALSE;
}
/* quiet valgrind */
memset(&priv->fix, '\0', sizeof(priv->fix));
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 (ioctl(priv->fd, FBIOGET_VSCREENINFO, &priv->var) < 0) {
perror("Error with /dev/fb ioctl FIOGET_VSCREENINFO");
close(priv->fd);
return FALSE;
}
priv->fb_base = (char *) mmap((caddr_t) NULL,
priv->fix.smem_len,
PROT_READ | PROT_WRITE,
MAP_SHARED, priv->fd, 0);
if (priv->fb_base == (char *) -1) {
perror("ERROR: mmap framebuffer fails!");
close(priv->fd);
return FALSE;
}
off = (unsigned long) priv->fix.smem_start % (unsigned long) getpagesize();
priv->fb = priv->fb_base + off;
return TRUE;
}
Bool
fbdevCardInit(KdCardInfo * card)
{
FbdevPriv *priv;
priv = (FbdevPriv *) malloc(sizeof(FbdevPriv));
if (!priv)
return FALSE;
if (!fbdevInitialize(card, priv)) {
free(priv);
return FALSE;
}
card->driver = priv;
return TRUE;
}
static Pixel
fbdevMakeContig(Pixel orig, Pixel others)
{
Pixel low;
low = lowbit(orig) >> 1;
while (low && (others & low) == 0) {
orig |= low;
low >>= 1;
}
return orig;
}
static Bool
fbdevModeSupported(KdScreenInfo * screen, const KdMonitorTiming * t)
{
return TRUE;
}
static void
fbdevConvertMonitorTiming(const KdMonitorTiming * t,
struct fb_var_screeninfo *var)
{
memset(var, 0, sizeof(struct fb_var_screeninfo));
var->xres = t->horizontal;
var->yres = t->vertical;
var->xres_virtual = t->horizontal;
var->yres_virtual = t->vertical;
var->xoffset = 0;
var->yoffset = 0;
var->pixclock = t->clock ? 1000000000 / t->clock : 0;
var->left_margin = t->hbp;
var->right_margin = t->hfp;
var->upper_margin = t->vbp;
var->lower_margin = t->vfp;
var->hsync_len = t->hblank - t->hfp - t->hbp;
var->vsync_len = t->vblank - t->vfp - t->vbp;
var->sync = 0;
var->vmode = 0;
if (t->hpol == KdSyncPositive)
var->sync |= FB_SYNC_HOR_HIGH_ACT;
if (t->vpol == KdSyncPositive)
var->sync |= FB_SYNC_VERT_HIGH_ACT;
}
static Bool
fbdevScreenInitialize(KdScreenInfo * screen, FbdevScrPriv * scrpriv)
{
FbdevPriv *priv = screen->card->driver;
Pixel allbits;
int depth;
Bool gray;
struct fb_var_screeninfo var;
const KdMonitorTiming *t;
int k;
k = ioctl(priv->fd, FBIOGET_VSCREENINFO, &var);
if (!screen->width || !screen->height) {
if (k >= 0) {
screen->width = var.xres;
screen->height = var.yres;
}
else {
screen->width = 1024;
screen->height = 768;
}
screen->rate = 103; /* FIXME: should get proper value from fb driver */
}
if (!screen->fb.depth) {
if (k >= 0)
screen->fb.depth = var.bits_per_pixel;
else
screen->fb.depth = 16;
}
if ((screen->width != var.xres) || (screen->height != var.yres)) {
t = KdFindMode(screen, fbdevModeSupported);
screen->rate = t->rate;
screen->width = t->horizontal;
screen->height = t->vertical;
/* Now try setting the mode */
if (k < 0 || (t->horizontal != var.xres || t->vertical != var.yres))
fbdevConvertMonitorTiming(t, &var);
}
var.activate = FB_ACTIVATE_NOW;
var.bits_per_pixel = screen->fb.depth;
var.nonstd = 0;
var.grayscale = 0;
k = ioctl(priv->fd, FBIOPUT_VSCREENINFO, &var);
if (k < 0) {
fprintf(stderr, "error: %s\n", strerror(errno));
return FALSE;
}
/* Re-get the "fixed" parameters since they might have changed */
k = ioctl(priv->fd, FBIOGET_FSCREENINFO, &priv->fix);
if (k < 0)
perror("FBIOGET_FSCREENINFO");
/* Now get the new screeninfo */
ioctl(priv->fd, FBIOGET_VSCREENINFO, &priv->var);
depth = priv->var.bits_per_pixel;
gray = priv->var.grayscale;
/* Calculate fix.line_length if it's zero */
if (!priv->fix.line_length)
priv->fix.line_length = (priv->var.xres_virtual * depth + 7) / 8;
switch (priv->fix.visual) {
case FB_VISUAL_MONO01:
case FB_VISUAL_MONO10:
screen->fb.visuals = (1 << StaticGray);
break;
case FB_VISUAL_PSEUDOCOLOR:
screen->fb.visuals = (1 << StaticGray);
if (priv->var.bits_per_pixel == 1) {
/* Override to monochrome, to have preallocated black/white */
priv->fix.visual = FB_VISUAL_MONO01;
} else if (gray) {
/* could also support GrayScale, but what's the point? */
} else {
screen->fb.visuals = ((1 << StaticGray) |
(1 << GrayScale) |
(1 << StaticColor) |
(1 << PseudoColor) |
(1 << TrueColor) | (1 << DirectColor));
}
screen->fb.blueMask = 0x00;
screen->fb.greenMask = 0x00;
screen->fb.redMask = 0x00;
break;
case FB_VISUAL_STATIC_PSEUDOCOLOR:
if (gray) {
screen->fb.visuals = (1 << StaticGray);
}
else {
screen->fb.visuals = (1 << StaticColor);
}
screen->fb.blueMask = 0x00;
screen->fb.greenMask = 0x00;
screen->fb.redMask = 0x00;
break;
case FB_VISUAL_TRUECOLOR:
case FB_VISUAL_DIRECTCOLOR:
screen->fb.visuals = (1 << TrueColor);
#define Mask(o,l) (((1 << l) - 1) << o)
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.redMask = fbdevMakeContig(screen->fb.redMask,
screen->fb.greenMask |
screen->fb.blueMask);
screen->fb.greenMask = fbdevMakeContig(screen->fb.greenMask,
screen->fb.redMask |
screen->fb.blueMask);
screen->fb.blueMask = fbdevMakeContig(screen->fb.blueMask,
screen->fb.redMask |
screen->fb.greenMask);
allbits =
screen->fb.redMask | screen->fb.greenMask | screen->fb.blueMask;
depth = 32;
while (depth && !(allbits & (1 << (depth - 1))))
depth--;
break;
default:
return FALSE;
break;
}
screen->fb.depth = depth;
screen->fb.bitsPerPixel = priv->var.bits_per_pixel;
scrpriv->randr = screen->randr;
return fbdevMapFramebuffer(screen);
}
Bool
fbdevScreenInit(KdScreenInfo * screen)
{
FbdevScrPriv *scrpriv;
scrpriv = calloc(1, sizeof(FbdevScrPriv));
if (!scrpriv)
return FALSE;
screen->driver = scrpriv;
if (!fbdevScreenInitialize(screen, scrpriv)) {
screen->driver = 0;
free(scrpriv);
return FALSE;
}
return TRUE;
}
static void *
fbdevWindowLinear(ScreenPtr pScreen,
CARD32 row,
CARD32 offset, int mode, CARD32 *size, void *closure)
{
KdScreenPriv(pScreen);
FbdevPriv *priv = pScreenPriv->card->driver;
if (!pScreenPriv->enabled)
return 0;
*size = priv->fix.line_length;
return (CARD8 *) priv->fb + row * priv->fix.line_length + offset;
}
static void *
fbdevWindowAfb(ScreenPtr pScreen,
CARD32 row,
CARD32 offset, int mode, CARD32 *size, void *closure)
{
KdScreenPriv(pScreen);
FbdevPriv *priv = pScreenPriv->card->driver;
if (!pScreenPriv->enabled)
return 0;
/* offset to next plane */
*size = priv->var.yres_virtual * priv->fix.line_length;
return (CARD8 *) priv->fb + row * priv->fix.line_length + offset;
}
Bool
fbdevMapFramebuffer(KdScreenInfo * screen)
{
FbdevScrPriv *scrpriv = screen->driver;
KdPointerMatrix m;
FbdevPriv *priv = screen->card->driver;
if (scrpriv->randr != RR_Rotate_0 ||
priv->fix.type != FB_TYPE_PACKED_PIXELS)
scrpriv->shadow = TRUE;
else
scrpriv->shadow = FALSE;
KdComputePointerMatrix(&m, scrpriv->randr, screen->width, screen->height);
KdSetPointerMatrix(&m);
screen->width = priv->var.xres;
screen->height = priv->var.yres;
if (scrpriv->shadow) {
if (!KdShadowFbAlloc(screen,
scrpriv->randr & (RR_Rotate_90 | RR_Rotate_270)))
return FALSE;
}
else {
screen->fb.byteStride = priv->fix.line_length;
screen->fb.pixelStride = (priv->fix.line_length * 8 /
priv->var.bits_per_pixel);
screen->fb.frameBuffer = (CARD8 *) (priv->fb);
}
return TRUE;
}
static void
fbdevSetScreenSizes(ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
FbdevScrPriv *scrpriv = screen->driver;
FbdevPriv *priv = screen->card->driver;
if (scrpriv->randr & (RR_Rotate_0 | RR_Rotate_180)) {
pScreen->width = priv->var.xres;
pScreen->height = priv->var.yres;
pScreen->mmWidth = screen->width_mm;
pScreen->mmHeight = screen->height_mm;
}
else {
pScreen->width = priv->var.yres;
pScreen->height = priv->var.xres;
pScreen->mmWidth = screen->height_mm;
pScreen->mmHeight = screen->width_mm;
}
}
static Bool
fbdevUnmapFramebuffer(KdScreenInfo * screen)
{
KdShadowFbFree(screen);
return TRUE;
}
static Bool
fbdevSetShadow(ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
FbdevScrPriv *scrpriv = screen->driver;
FbdevPriv *priv = screen->card->driver;
ShadowUpdateProc update;
ShadowWindowProc window;
int useYX = 0;
#ifdef __arm__
/* Use variant copy routines that always read left to right in the
shadow framebuffer. Reading vertical strips is exceptionally
slow on XScale due to cache effects. */
useYX = 1;
#endif
window = fbdevWindowLinear;
update = 0;
switch (priv->fix.type) {
case FB_TYPE_PACKED_PIXELS:
if (scrpriv->randr)
if (priv->var.bits_per_pixel == 16) {
switch (scrpriv->randr) {
case RR_Rotate_90:
if (useYX)
update = shadowUpdateRotate16_90YX;
else
update = shadowUpdateRotate16_90;
break;
case RR_Rotate_180:
update = shadowUpdateRotate16_180;
break;
case RR_Rotate_270:
if (useYX)
update = shadowUpdateRotate16_270YX;
else
update = shadowUpdateRotate16_270;
break;
default:
update = shadowUpdateRotate16;
break;
}
}
else
update = shadowUpdateRotatePacked;
else
update = shadowUpdatePacked;
break;
case FB_TYPE_PLANES:
window = fbdevWindowAfb;
switch (priv->var.bits_per_pixel) {
case 4:
update = shadowUpdateAfb4;
break;
case 8:
update = shadowUpdateAfb8;
break;
default:
FatalError("Bitplanes with bpp %u are not yet supported\n",
priv->var.bits_per_pixel);
}
break;
case FB_TYPE_INTERLEAVED_PLANES:
if (priv->fix.type_aux == 2) {
switch (priv->var.bits_per_pixel) {
case 4:
update = shadowUpdateIplan2p4;
break;
case 8:
update = shadowUpdateIplan2p8;
break;
default:
FatalError("Atari interleaved bitplanes with bpp %u are not yet supported\n",
priv->var.bits_per_pixel);
}
} else {
FatalError("Interleaved bitplanes with interleave %u are not yet supported\n",
priv->fix.type_aux);
}
break;
case FB_TYPE_TEXT:
FatalError("Text frame buffers are not yet supported\n");
break;
case FB_TYPE_VGA_PLANES:
FatalError("VGA planes are not yet supported\n");
break;
default:
FatalError("Unsupported frame buffer type %u\n", priv->fix.type);
break;
}
return KdShadowSet(pScreen, scrpriv->randr, update, window);
}
#ifdef RANDR
static Bool
fbdevRandRGetInfo(ScreenPtr pScreen, Rotation * rotations)
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
FbdevScrPriv *scrpriv = screen->driver;
RRScreenSizePtr pSize;
Rotation randr;
int n;
*rotations = RR_Rotate_All | RR_Reflect_All;
for (n = 0; n < pScreen->numDepths; n++)
if (pScreen->allowedDepths[n].numVids)
break;
if (n == pScreen->numDepths)
return FALSE;
pSize = RRRegisterSize(pScreen,
screen->width,
screen->height, screen->width_mm, screen->height_mm);
randr = KdSubRotation(scrpriv->randr, screen->randr);
RRSetCurrentConfig(pScreen, randr, 0, pSize);
return TRUE;
}
static Bool
fbdevRandRSetConfig(ScreenPtr pScreen,
Rotation randr, int rate, RRScreenSizePtr pSize)
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
FbdevScrPriv *scrpriv = screen->driver;
Bool wasEnabled = pScreenPriv->enabled;
FbdevScrPriv oldscr;
int oldwidth;
int oldheight;
int oldmmwidth;
int oldmmheight;
int newwidth, newheight, newmmwidth, newmmheight;
if (screen->randr & (RR_Rotate_0 | RR_Rotate_180)) {
newwidth = pSize->width;
newheight = pSize->height;
newmmwidth = pSize->mmWidth;
newmmheight = pSize->mmHeight;
}
else {
newwidth = pSize->height;
newheight = pSize->width;
newmmwidth = pSize->mmHeight;
newmmheight = pSize->mmWidth;
}
if (wasEnabled)
KdDisableScreen(pScreen);
oldscr = *scrpriv;
oldwidth = screen->width;
oldheight = screen->height;
oldmmwidth = pScreen->mmWidth;
oldmmheight = pScreen->mmHeight;
/*
* Set new configuration
*/
scrpriv->randr = KdAddRotation(screen->randr, randr);
pScreen->width = newwidth;
pScreen->height = newheight;
pScreen->mmWidth = newmmwidth;
pScreen->mmHeight = newmmheight;
fbdevUnmapFramebuffer(screen);
if (!fbdevMapFramebuffer(screen))
goto bail4;
KdShadowUnset(screen->pScreen);
if (!fbdevSetShadow(screen->pScreen))
goto bail4;
fbdevSetScreenSizes(screen->pScreen);
/*
* Set frame buffer mapping
*/
(*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap(pScreen),
pScreen->width,
pScreen->height,
screen->fb.depth,
screen->fb.bitsPerPixel,
screen->fb.byteStride,
screen->fb.frameBuffer);
/* set the subpixel order */
KdSetSubpixelOrder(pScreen, scrpriv->randr);
if (wasEnabled)
KdEnableScreen(pScreen);
return TRUE;
bail4:
fbdevUnmapFramebuffer(screen);
*scrpriv = oldscr;
(void) fbdevMapFramebuffer(screen);
pScreen->width = oldwidth;
pScreen->height = oldheight;
pScreen->mmWidth = oldmmwidth;
pScreen->mmHeight = oldmmheight;
if (wasEnabled)
KdEnableScreen(pScreen);
return FALSE;
}
static Bool
fbdevRandRInit(ScreenPtr pScreen)
{
rrScrPrivPtr pScrPriv;
if (!RRScreenInit(pScreen))
return FALSE;
pScrPriv = rrGetScrPriv(pScreen);
pScrPriv->rrGetInfo = fbdevRandRGetInfo;
pScrPriv->rrSetConfig = fbdevRandRSetConfig;
return TRUE;
}
#endif
static Bool
fbdevCreateColormap(ColormapPtr pmap)
{
ScreenPtr pScreen = pmap->pScreen;
KdScreenPriv(pScreen);
FbdevPriv *priv = pScreenPriv->card->driver;
VisualPtr pVisual;
int i;
int nent;
xColorItem *pdefs;
switch (priv->fix.visual) {
case FB_VISUAL_MONO01:
pScreen->whitePixel = 0;
pScreen->blackPixel = 1;
pmap->red[0].co.local.red = 65535;
pmap->red[0].co.local.green = 65535;
pmap->red[0].co.local.blue = 65535;
pmap->red[1].co.local.red = 0;
pmap->red[1].co.local.green = 0;
pmap->red[1].co.local.blue = 0;
return TRUE;
case FB_VISUAL_MONO10:
pScreen->blackPixel = 0;
pScreen->whitePixel = 1;
pmap->red[0].co.local.red = 0;
pmap->red[0].co.local.green = 0;
pmap->red[0].co.local.blue = 0;
pmap->red[1].co.local.red = 65535;
pmap->red[1].co.local.green = 65535;
pmap->red[1].co.local.blue = 65535;
return TRUE;
case FB_VISUAL_STATIC_PSEUDOCOLOR:
pVisual = pmap->pVisual;
nent = pVisual->ColormapEntries;
pdefs = xallocarray(nent, sizeof(xColorItem));
if (!pdefs)
return FALSE;
for (i = 0; i < nent; i++)
pdefs[i].pixel = i;
fbdevGetColors(pScreen, nent, pdefs);
for (i = 0; i < nent; i++) {
pmap->red[i].co.local.red = pdefs[i].red;
pmap->red[i].co.local.green = pdefs[i].green;
pmap->red[i].co.local.blue = pdefs[i].blue;
}
free(pdefs);
return TRUE;
default:
return fbInitializeColormap(pmap);
}
}
Bool
fbdevInitScreen(ScreenPtr pScreen)
{
pScreen->CreateColormap = fbdevCreateColormap;
return TRUE;
}
Bool
fbdevFinishInitScreen(ScreenPtr pScreen)
{
if (!shadowSetup(pScreen))
return FALSE;
#ifdef RANDR
if (!fbdevRandRInit(pScreen))
return FALSE;
#endif
return TRUE;
}
Bool
fbdevCreateResources(ScreenPtr pScreen)
{
return fbdevSetShadow(pScreen);
}
void
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)
{
KdScreenPriv(pScreen);
FbdevPriv *priv = pScreenPriv->card->driver;
int k;
priv->var.activate = FB_ACTIVATE_NOW | FB_CHANGE_CMAP_VBL;
/* display it on the LCD */
k = ioctl(priv->fd, FBIOPUT_VSCREENINFO, &priv->var);
if (k < 0) {
perror("FBIOPUT_VSCREENINFO");
return FALSE;
}
if (priv->fix.visual == FB_VISUAL_DIRECTCOLOR) {
int i;
for (i = 0;
i < (1 << priv->var.red.length) ||
i < (1 << priv->var.green.length) ||
i < (1 << priv->var.blue.length); i++) {
priv->red[i] = i * 65535 / ((1 << priv->var.red.length) - 1);
priv->green[i] = i * 65535 / ((1 << priv->var.green.length) - 1);
priv->blue[i] = i * 65535 / ((1 << priv->var.blue.length) - 1);
}
fbdevUpdateFbColormap(priv, 0, i);
}
return TRUE;
}
Bool
fbdevDPMS(ScreenPtr pScreen, int mode)
{
KdScreenPriv(pScreen);
FbdevPriv *priv = pScreenPriv->card->driver;
static int oldmode = -1;
if (mode == oldmode)
return TRUE;
#ifdef FBIOPUT_POWERMODE
if (ioctl(priv->fd, FBIOPUT_POWERMODE, &mode) >= 0) {
oldmode = mode;
return TRUE;
}
#endif
#ifdef FBIOBLANK
if (ioctl(priv->fd, FBIOBLANK, mode ? mode + 1 : 0) >= 0) {
oldmode = mode;
return TRUE;
}
#endif
return FALSE;
}
void
fbdevDisable(ScreenPtr pScreen)
{
}
void
fbdevRestore(KdCardInfo * card)
{
}
void
fbdevScreenFini(KdScreenInfo * screen)
{
}
void
fbdevCardFini(KdCardInfo * card)
{
FbdevPriv *priv = card->driver;
munmap(priv->fb_base, priv->fix.smem_len);
close(priv->fd);
free(priv);
}
/*
* Retrieve actual colormap and return selected n entries in pdefs.
*/
void
fbdevGetColors(ScreenPtr pScreen, int n, xColorItem * pdefs)
{
KdScreenPriv(pScreen);
FbdevPriv *priv = pScreenPriv->card->driver;
struct fb_cmap cmap;
int p;
int k;
int min, max;
min = 256;
max = 0;
for (k = 0; k < n; k++) {
if (pdefs[k].pixel < min)
min = pdefs[k].pixel;
if (pdefs[k].pixel > max)
max = pdefs[k].pixel;
}
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;
k = ioctl(priv->fd, FBIOGETCMAP, &cmap);
if (k < 0) {
perror("can't get colormap");
return;
}
while (n--) {
p = pdefs->pixel;
pdefs->red = priv->red[p];
pdefs->green = priv->green[p];
pdefs->blue = priv->blue[p];
pdefs++;
}
}
/*
* Change colormap by updating n entries described in pdefs.
*/
void
fbdevPutColors(ScreenPtr pScreen, int n, xColorItem * pdefs)
{
KdScreenPriv(pScreen);
FbdevPriv *priv = pScreenPriv->card->driver;
int p;
int min, max;
min = 256;
max = 0;
while (n--) {
p = pdefs->pixel;
priv->red[p] = pdefs->red;
priv->green[p] = pdefs->green;
priv->blue[p] = pdefs->blue;
if (p < min)
min = p;
if (p > max)
max = p;
pdefs++;
}
fbdevUpdateFbColormap(priv, min, max);
}

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

@ -1,99 +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.
*/
#ifndef _FBDEV_H_
#define _FBDEV_H_
#include <stdio.h>
#include <linux/fb.h>
#include <unistd.h>
#include <sys/mman.h>
#include "kdrive.h"
#ifdef RANDR
#include "randrstr.h"
#endif
typedef struct _fbdevPriv {
struct fb_var_screeninfo var;
struct fb_fix_screeninfo fix;
__u16 red[256];
__u16 green[256];
__u16 blue[256];
int fd;
char *fb;
char *fb_base;
} FbdevPriv;
typedef struct _fbdevScrPriv {
Rotation randr;
Bool shadow;
} FbdevScrPriv;
extern KdCardFuncs fbdevFuncs;
extern const char *fbdevDevicePath;
Bool
fbdevCardInit(KdCardInfo * card);
Bool
fbdevScreenInit(KdScreenInfo * screen);
Bool
fbdevInitScreen(ScreenPtr pScreen);
Bool
fbdevFinishInitScreen(ScreenPtr pScreen);
Bool
fbdevCreateResources(ScreenPtr pScreen);
void
fbdevPreserve(KdCardInfo * card);
Bool
fbdevEnable(ScreenPtr pScreen);
Bool
fbdevDPMS(ScreenPtr pScreen, int mode);
void
fbdevDisable(ScreenPtr pScreen);
void
fbdevRestore(KdCardInfo * card);
void
fbdevScreenFini(KdScreenInfo * screen);
void
fbdevCardFini(KdCardInfo * card);
void
fbdevGetColors(ScreenPtr pScreen, int n, xColorItem * pdefs);
void
fbdevPutColors(ScreenPtr pScreen, int n, xColorItem * pdefs);
Bool
fbdevMapFramebuffer(KdScreenInfo * screen);
#endif /* _FBDEV_H_ */

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

@ -1,105 +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 <fbdev.h>
void
InitCard(char *name)
{
KdCardInfoAdd(&fbdevFuncs, 0);
}
void
InitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
{
KdInitOutput(pScreenInfo, argc, argv);
}
void
InitInput(int argc, char **argv)
{
KdOsAddInputDrivers();
KdInitInput();
}
void
CloseInput(void)
{
KdCloseInput();
}
void
ddxUseMsg(void)
{
KdUseMsg();
ErrorF("\nXfbdev Device Usage:\n");
ErrorF
("-fb path Framebuffer device to use. Defaults to /dev/fb0\n");
ErrorF("\n");
}
int
ddxProcessArgument(int argc, char **argv, int i)
{
if (!strcmp(argv[i], "-fb")) {
if (i + 1 < argc) {
fbdevDevicePath = argv[i + 1];
return 2;
}
UseMsg();
exit(1);
}
return KdProcessArgument(argc, argv, i);
}
KdCardFuncs fbdevFuncs = {
fbdevCardInit, /* cardinit */
fbdevScreenInit, /* scrinit */
fbdevInitScreen, /* initScreen */
fbdevFinishInitScreen, /* finishInitScreen */
fbdevCreateResources, /* createRes */
fbdevPreserve, /* preserve */
fbdevEnable, /* enable */
fbdevDPMS, /* dpms */
fbdevDisable, /* disable */
fbdevRestore, /* restore */
fbdevScreenFini, /* scrfini */
fbdevCardFini, /* cardfini */
0, /* initCursor */
0, /* enableCursor */
0, /* disableCursor */
0, /* finiCursor */
0, /* recolorCursor */
0, /* initAccel */
0, /* enableAccel */
0, /* disableAccel */
0, /* finiAccel */
fbdevGetColors, /* getColors */
fbdevPutColors, /* putColors */
};