xserver/hw/xorg/fbdevhw Makefile.am, NONE, 1.1 fbdevhw.c, NONE,
1.1 fbdevhw.h, NONE, 1.1 fbdevhwstub.c, NONE, 1.1 fbpriv.h,
NONE, 1.1
Daniel Stone
xserver-commit at pdx.freedesktop.org
Sun Apr 25 23:52:16 EST 2004
- Previous message: xserver/hw/xorg/dummylib Makefile.am, NONE, 1.1 dummylib.h, NONE,
1.1 fatalerror.c, NONE, 1.1 getvalidbios.c, NONE,
1.1 logvwrite.c, NONE, 1.1 pcitestmulti.c, NONE, 1.1 strlcat.c,
NONE, 1.1 strlcpy.c, NONE, 1.1 verrorf.c, NONE, 1.1 xalloc.c,
NONE, 1.1 xf86addrestolist.c, NONE, 1.1 xf86allocscripi.c,
NONE, 1.1 xf86drvmsg.c, NONE, 1.1 xf86drvmsgverb.c, NONE,
1.1 xf86errorf.c, NONE, 1.1 xf86errorfverb.c, NONE,
1.1 xf86getpagesize.c, NONE, 1.1 xf86getverb.c, NONE,
1.1 xf86info.c, NONE, 1.1 xf86msg.c, NONE, 1.1 xf86msgverb.c,
NONE, 1.1 xf86opt.c, NONE, 1.1 xf86screens.c, NONE,
1.1 xf86servisinit.c, NONE, 1.1 xf86verbose.c, NONE, 1.1
- Next message: xserver/hw/xorg/i2c Makefile.am, NONE, 1.1 xf86i2c.c, NONE,
1.1 xf86i2c.h, NONE, 1.1 xf86i2cmodule.c, NONE, 1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
Committed by: daniel
Update of /cvs/xserver/xserver/hw/xorg/fbdevhw
In directory pdx:/tmp/cvs-serv17025/hw/xorg/fbdevhw
Added Files:
Makefile.am fbdevhw.c fbdevhw.h fbdevhwstub.c fbpriv.h
Log Message:
Xizzle is dead, long live Xorg.
Re-import the DDX from X11R6.7, complete with automakey goodness, and do the
requisite configure.ac, et al, updates; also import the XKB extension from the
6.7 DIX.
Currently it'll link and then hang solid in RADEONInitAccel(), or the next
function if you enable NoAccel.
--- NEW FILE: Makefile.am ---
lib_LIBRARIES = libxorgfbdevhw.a
#if FBDEVHW
libxorgfbdevhw_a_SOURCES = fbdevhw.c
#else
#libxorgfbdevhw_a_SOURCES = fbdevhwstub.c
#endif
INCLUDES = $(XORG_INCS) -I$(srcdir)/../i2c -I$(top_srcdir)/Xext \
-I$(top_srcdir)/mi
AM_CFLAGS = $(XORG_CFLAGS)
sdk_INCLUDEDIR = $(includedir)/xorg
sdk_INCLUDES = fbdevhw.h
--- NEW FILE: fbdevhw.c ---
/* $XFree86: xc/programs/Xserver/hw/xfree86/fbdevhw/fbdevhw.c,v 1.32 2003/08/26 10:57:03 daenzer Exp $ */
/* all driver need this */
#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86_ansic.h"
/* pci stuff */
#include "xf86PciInfo.h"
#include "xf86Pci.h"
#include "xf86cmap.h"
#include "fbdevhw.h"
#include "fbpriv.h"
#include "asm/page.h" /* #define for PAGE_* */
#include "globals.h"
#define DPMS_SERVER
#include <X11/extensions/dpms.h>
#define DEBUG 0
#if DEBUG
# define TRACE_ENTER(str) ErrorF("fbdevHW: " str " %d\n",pScrn->scrnIndex)
#else
# define TRACE_ENTER(str)
#endif
/* -------------------------------------------------------------------- */
#ifdef XFree86LOADER
static MODULESETUPPROTO(fbdevhwSetup);
static XF86ModuleVersionInfo fbdevHWVersRec =
{
"fbdevhw",
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XORG_VERSION_CURRENT,
0, 0, 2,
ABI_CLASS_VIDEODRV,
ABI_VIDEODRV_VERSION,
MOD_CLASS_NONE,
{0,0,0,0}
};
XF86ModuleData fbdevhwModuleData = { &fbdevHWVersRec, fbdevhwSetup, NULL };
static pointer
fbdevhwSetup(pointer module, pointer opts, int *errmaj, int *errmin)
{
const char *osname;
/* Check that we're being loaded on a Linux system */
LoaderGetOS(&osname, NULL, NULL, NULL);
if (!osname || strcmp(osname, "linux") != 0) {
if (errmaj)
*errmaj = LDR_BADOS;
if (errmin)
*errmin = 0;
return NULL;
} else {
/* OK */
return (pointer)1;
}
}
#else /* XFree86LOADER */
#include <fcntl.h>
#include <errno.h>
#include <sys/mman.h>
#endif /* XFree86LOADER */
/* -------------------------------------------------------------------- */
/* our private data, and two functions to allocate/free this */
#define FBDEVHWPTRLVAL(p) (p)->privates[fbdevHWPrivateIndex].ptr
#define FBDEVHWPTR(p) ((fbdevHWPtr)(FBDEVHWPTRLVAL(p)))
static int fbdevHWPrivateIndex = -1;
typedef struct {
/* framebuffer device: filename (/dev/fb*), handle, more */
char* device;
int fd;
void* fbmem;
unsigned int fbmem_len;
unsigned int fboff;
char* mmio;
unsigned int mmio_len;
/* current hardware state */
struct fb_fix_screeninfo fix;
struct fb_var_screeninfo var;
/* saved video mode */
struct fb_var_screeninfo saved_var;
/* FIXME: unused??? [geert] */
struct fb_cmap saved_cmap;
unsigned short *saved_red;
unsigned short *saved_green;
unsigned short *saved_blue;
/* buildin video mode */
DisplayModeRec buildin;
} fbdevHWRec, *fbdevHWPtr;
Bool
fbdevHWGetRec(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr;
if (fbdevHWPrivateIndex < 0)
fbdevHWPrivateIndex = xf86AllocateScrnInfoPrivateIndex();
if (FBDEVHWPTR(pScrn) != NULL)
return TRUE;
fPtr = FBDEVHWPTRLVAL(pScrn) = xnfcalloc(sizeof(fbdevHWRec), 1);
return TRUE;
}
void
fbdevHWFreeRec(ScrnInfoPtr pScrn)
{
if (fbdevHWPrivateIndex < 0)
return;
if (FBDEVHWPTR(pScrn) == NULL)
return;
xfree(FBDEVHWPTR(pScrn));
FBDEVHWPTRLVAL(pScrn) = NULL;
}
/* -------------------------------------------------------------------- */
/* some helpers for printing debug informations */
#if DEBUG
static void
print_fbdev_mode(char *txt, struct fb_var_screeninfo *var)
{
ErrorF( "fbdev %s mode:\t%d %d %d %d %d %d %d %d %d %d %d:%d:%d\n",
txt,var->pixclock,
var->xres, var->right_margin, var->hsync_len, var->left_margin,
var->yres, var->lower_margin, var->vsync_len, var->upper_margin,
var->bits_per_pixel,
var->red.length, var->green.length, var->blue.length);
}
static void
print_xfree_mode(char *txt, DisplayModePtr mode)
{
ErrorF( "xfree %s mode:\t%d %d %d %d %d %d %d %d %d\n",
txt,mode->Clock,
mode->HDisplay, mode->HSyncStart, mode->HSyncEnd, mode->HTotal,
mode->VDisplay, mode->VSyncStart, mode->VSyncEnd, mode->VTotal);
}
#endif
/* -------------------------------------------------------------------- */
/* Convert timings between the XFree and the Frame Buffer Device */
static void
xfree2fbdev_fblayout(ScrnInfoPtr pScrn, struct fb_var_screeninfo *var)
{
var->xres_virtual = pScrn->virtualX;
var->yres_virtual = pScrn->virtualY;
var->bits_per_pixel = pScrn->bitsPerPixel;
var->red.length = pScrn->weight.red;
var->green.length = pScrn->weight.green;
var->blue.length = pScrn->weight.blue;
}
static void
xfree2fbdev_timing(DisplayModePtr mode, struct fb_var_screeninfo *var)
{
var->xres = mode->HDisplay;
var->yres = mode->VDisplay;
if (var->xres_virtual < var->xres)
var->xres_virtual = var->xres;
if (var->yres_virtual < var->yres)
var->yres_virtual = var->yres;
var->xoffset = var->yoffset = 0;
var->pixclock = mode->Clock ? 1000000000/mode->Clock : 0;
var->right_margin = mode->HSyncStart-mode->HDisplay;
var->hsync_len = mode->HSyncEnd-mode->HSyncStart;
var->left_margin = mode->HTotal-mode->HSyncEnd;
var->lower_margin = mode->VSyncStart-mode->VDisplay;
var->vsync_len = mode->VSyncEnd-mode->VSyncStart;
var->upper_margin = mode->VTotal-mode->VSyncEnd;
var->sync = 0;
if (mode->Flags & V_PHSYNC)
var->sync |= FB_SYNC_HOR_HIGH_ACT;
if (mode->Flags & V_PVSYNC)
var->sync |= FB_SYNC_VERT_HIGH_ACT;
if (mode->Flags & V_PCSYNC)
var->sync |= FB_SYNC_COMP_HIGH_ACT;
#if 1 /* Badly needed for PAL/NTSC on Amiga (amifb)!! [geert] */
if (mode->Flags & V_BCAST)
var->sync |= FB_SYNC_BROADCAST;
#endif
if (mode->Flags & V_INTERLACE)
var->vmode = FB_VMODE_INTERLACED;
else if (mode->Flags & V_DBLSCAN)
var->vmode = FB_VMODE_DOUBLE;
else
var->vmode = FB_VMODE_NONINTERLACED;
}
static void
fbdev2xfree_timing(struct fb_var_screeninfo *var, DisplayModePtr mode)
{
mode->Clock = var->pixclock ? 1000000000/var->pixclock : 28000000;
mode->HDisplay = var->xres;
mode->HSyncStart = mode->HDisplay+var->right_margin;
mode->HSyncEnd = mode->HSyncStart+var->hsync_len;
mode->HTotal = mode->HSyncEnd+var->left_margin;
mode->VDisplay = var->yres;
mode->VSyncStart = mode->VDisplay+var->lower_margin;
mode->VSyncEnd = mode->VSyncStart+var->vsync_len;
mode->VTotal = mode->VSyncEnd+var->upper_margin;
mode->Flags = 0;
mode->Flags |= var->sync & FB_SYNC_HOR_HIGH_ACT ? V_PHSYNC : V_NHSYNC;
mode->Flags |= var->sync & FB_SYNC_VERT_HIGH_ACT ? V_PVSYNC : V_NVSYNC;
mode->Flags |= var->sync & FB_SYNC_COMP_HIGH_ACT ? V_PCSYNC : V_NCSYNC;
#if 1 /* Badly needed for PAL/NTSC on Amiga (amifb)!! [geert] */
if (var->sync & FB_SYNC_BROADCAST)
mode->Flags |= V_BCAST;
#endif
if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED)
mode->Flags |= V_INTERLACE;
else if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE)
mode->Flags |= V_DBLSCAN;
mode->SynthClock = mode->Clock;
mode->CrtcHDisplay = mode->HDisplay;
mode->CrtcHSyncStart = mode->HSyncStart;
mode->CrtcHSyncEnd = mode->HSyncEnd;
mode->CrtcHTotal = mode->HTotal;
mode->CrtcVDisplay = mode->VDisplay;
mode->CrtcVSyncStart = mode->VSyncStart;
mode->CrtcVSyncEnd = mode->VSyncEnd;
mode->CrtcVTotal = mode->VTotal;
mode->CrtcHAdjusted = FALSE;
mode->CrtcVAdjusted = FALSE;
}
/* -------------------------------------------------------------------- */
/* open correct framebuffer device */
/* try to find the framebuffer device for a given PCI device */
static int
fbdev_open_pci(pciVideoPtr pPci, char **namep)
{
struct fb_fix_screeninfo fix;
char filename[16];
int fd,i,j;
memType res_start, res_end;
for (i = 0; i < 8; i++) {
sprintf(filename,"/dev/fb%d",i);
if (-1 == (fd = open(filename,O_RDWR,0))) {
xf86DrvMsg(-1, X_WARNING,
"open %s: %s\n", filename, strerror(errno));
continue;
}
if (-1 == ioctl(fd,FBIOGET_FSCREENINFO,(void*)&fix)) {
close(fd);
continue;
}
for (j = 0; j < 6; j++) {
res_start = pPci->memBase[j];
res_end = res_start+pPci->size[j];
if ((0 != fix.smem_len &&
(memType) fix.smem_start >= res_start &&
(memType) fix.smem_start < res_end) ||
(0 != fix.mmio_len &&
(memType) fix.mmio_start >= res_start &&
(memType) fix.mmio_start < res_end))
break;
}
if (j == 6) {
close(fd);
continue;
}
if (namep) {
*namep = xnfalloc(16);
strncpy(*namep,fix.id,16);
}
return fd;
}
if (namep)
*namep = NULL;
return -1;
}
static int
fbdev_open(int scrnIndex, char *dev, char** namep)
{
struct fb_fix_screeninfo fix;
int fd;
/* try argument (from XF86Config) first */
if (dev) {
fd = open(dev,O_RDWR,0);
} else {
/* second: environment variable */
dev = getenv("FRAMEBUFFER");
if ((NULL == dev) || ((fd = open(dev,O_RDWR,0)) == -1)) {
/* last try: default device */
dev = "/dev/fb0";
fd = open(dev,O_RDWR,0);
}
}
if (fd == -1) {
xf86DrvMsg(scrnIndex, X_ERROR,
"open %s: %s\n", dev, strerror(errno));
return -1;
}
if (namep) {
if (-1 == ioctl(fd,FBIOGET_FSCREENINFO,(void*)(&fix))) {
*namep = NULL;
xf86DrvMsg(scrnIndex, X_ERROR,
"FBIOGET_FSCREENINFO: %s\n", strerror(errno));
return -1;
} else {
*namep = xnfalloc(16);
strncpy(*namep,fix.id,16);
}
}
return fd;
}
/* -------------------------------------------------------------------- */
Bool
fbdevHWProbe(pciVideoPtr pPci, char *device,char **namep)
{
int fd;
if (pPci)
fd = fbdev_open_pci(pPci,namep);
else
fd = fbdev_open(-1,device,namep);
if (-1 == fd)
return FALSE;
close(fd);
return TRUE;
}
Bool
fbdevHWInit(ScrnInfoPtr pScrn, pciVideoPtr pPci, char *device)
{
fbdevHWPtr fPtr;
TRACE_ENTER("Init");
fbdevHWGetRec(pScrn);
fPtr = FBDEVHWPTR(pScrn);
/* open device */
if (pPci)
fPtr->fd = fbdev_open_pci(pPci,NULL);
else
fPtr->fd = fbdev_open(pScrn->scrnIndex,device,NULL);
if (-1 == fPtr->fd) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Failed to open framebuffer device, consult warnings"
" and/or errors above for possible reasons\n"
"\t(you may have to look at the server log to see"
" warnings)\n");
return FALSE;
}
/* get current fb device settings */
if (-1 == ioctl(fPtr->fd,FBIOGET_FSCREENINFO,(void*)(&fPtr->fix))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"ioctl FBIOGET_FSCREENINFO: %s\n",
strerror(errno));
return FALSE;
}
if (-1 == ioctl(fPtr->fd,FBIOGET_VSCREENINFO,(void*)(&fPtr->var))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"ioctl FBIOGET_VSCREENINFO: %s\n",
strerror(errno));
return FALSE;
}
/* we can use the current settings as "buildin mode" */
fbdev2xfree_timing(&fPtr->var, &fPtr->buildin);
fPtr->buildin.name = "current";
fPtr->buildin.next = &fPtr->buildin;
fPtr->buildin.prev = &fPtr->buildin;
fPtr->buildin.type |= M_T_BUILTIN;
return TRUE;
}
char*
fbdevHWGetName(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
return fPtr->fix.id;
}
int
fbdevHWGetDepth(ScrnInfoPtr pScrn, int *fbbpp)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
if (fbbpp)
*fbbpp = fPtr->var.bits_per_pixel;
if (fPtr->fix.visual == FB_VISUAL_TRUECOLOR ||
fPtr->fix.visual == FB_VISUAL_DIRECTCOLOR)
return fPtr->var.red.length+fPtr->var.green.length+
fPtr->var.blue.length;
else
return fPtr->var.bits_per_pixel;
}
int
fbdevHWGetLineLength(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
if (fPtr->fix.line_length)
return fPtr->fix.line_length;
else
return fPtr->var.xres_virtual*fPtr->var.bits_per_pixel/8;
}
int
fbdevHWGetType(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
return fPtr->fix.type;
}
int
fbdevHWGetVidmem(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
return fPtr->fix.smem_len;
}
void
fbdevHWSetVideoModes(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
int virtX = pScrn->display->virtualX;
int virtY = pScrn->display->virtualY;
struct fb_var_screeninfo var;
char **modename;
DisplayModePtr mode,this,last = pScrn->modes;
TRACE_ENTER("VerifyModes");
if (NULL == pScrn->display->modes)
return;
for (modename = pScrn->display->modes; *modename != NULL; modename++) {
for (mode = pScrn->monitor->Modes; mode != NULL; mode = mode->next)
if (0 == strcmp(mode->name,*modename))
break;
if (NULL == mode) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"\tmode \"%s\" not found\n", *modename);
continue;
}
memset(&var,0,sizeof(var));
xfree2fbdev_timing(mode,&var);
var.xres_virtual = virtX;
var.yres_virtual = virtY;
var.bits_per_pixel = pScrn->bitsPerPixel;
var.red.length = pScrn->weight.red;
var.green.length = pScrn->weight.green;
var.blue.length = pScrn->weight.blue;
var.activate = FB_ACTIVATE_TEST;
if (var.xres_virtual < var.xres) var.xres_virtual = var.xres;
if (var.yres_virtual < var.yres) var.yres_virtual = var.yres;
if (-1 == ioctl(fPtr->fd,FBIOPUT_VSCREENINFO,(void*)(&var))) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"\tmode \"%s\" test failed\n", *modename);
continue;
}
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"\tmode \"%s\" ok\n", *modename);
if (virtX < var.xres) virtX = var.xres;
if (virtY < var.yres) virtY = var.yres;
if (NULL == pScrn->modes) {
pScrn->modes = xnfalloc(sizeof(DisplayModeRec));
this = pScrn->modes;
memcpy(this,mode,sizeof(DisplayModeRec));
this->next = this;
this->prev = this;
} else {
this = xnfalloc(sizeof(DisplayModeRec));
memcpy(this,mode,sizeof(DisplayModeRec));
this->next = pScrn->modes;
this->prev = last;
last->next = this;
pScrn->modes->prev = this;
}
last = this;
}
pScrn->virtualX = virtX;
pScrn->virtualY = virtY;
}
DisplayModePtr
fbdevHWGetBuildinMode(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
return &fPtr->buildin;
}
void
fbdevHWUseBuildinMode(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("UseBuildinMode");
pScrn->modes = &fPtr->buildin;
pScrn->virtualX = pScrn->display->virtualX;
pScrn->virtualY = pScrn->display->virtualY;
if (pScrn->virtualX < fPtr->buildin.HDisplay)
pScrn->virtualX = fPtr->buildin.HDisplay;
if (pScrn->virtualY < fPtr->buildin.VDisplay)
pScrn->virtualY = fPtr->buildin.VDisplay;
}
/* -------------------------------------------------------------------- */
static void
calculateFbmem_len(fbdevHWPtr fPtr)
{
fPtr->fboff = (unsigned long) fPtr->fix.smem_start & ~PAGE_MASK;
fPtr->fbmem_len = (fPtr->fboff+fPtr->fix.smem_len+~PAGE_MASK) &
PAGE_MASK;
}
void*
fbdevHWMapVidmem(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("MapVidmem");
if (NULL == fPtr->fbmem) {
calculateFbmem_len(fPtr);
fPtr->fbmem = mmap(NULL, fPtr->fbmem_len, PROT_READ | PROT_WRITE,
MAP_SHARED, fPtr->fd, 0);
if (-1 == (long)fPtr->fbmem) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"mmap fbmem: %s\n", strerror(errno));
fPtr->fbmem = NULL;
} else {
/* Perhaps we'd better add fboff to fbmem and return 0 in
fbdevHWLinearOffset()? Of course we then need to mask
fPtr->fbmem with PAGE_MASK in fbdevHWUnmapVidmem() as
well. [geert] */
}
}
pScrn->memPhysBase = (unsigned long)fPtr->fix.smem_start & (unsigned long)(PAGE_MASK);
pScrn->fbOffset = (unsigned long)fPtr->fix.smem_start & (unsigned long)(~PAGE_MASK);
return fPtr->fbmem;
}
int
fbdevHWLinearOffset(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("LinearOffset");
return fPtr->fboff;
}
Bool
fbdevHWUnmapVidmem(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("UnmapVidmem");
if (NULL != fPtr->fbmem) {
if (-1 == munmap(fPtr->fbmem, fPtr->fbmem_len))
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"munmap fbmem: %s\n", strerror(errno));
fPtr->fbmem = NULL;
}
return TRUE;
}
void*
fbdevHWMapMMIO(ScrnInfoPtr pScrn)
{
unsigned int mmio_off;
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("MapMMIO");
if (NULL == fPtr->mmio) {
/* tell the kernel not to use accels to speed up console scrolling */
fPtr->var.accel_flags = 0;
if (0 != ioctl(fPtr->fd,FBIOPUT_VSCREENINFO,(void*)(&fPtr->var))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"FBIOPUT_VSCREENINFO: %s\n", strerror(errno));
return FALSE;
}
mmio_off = (unsigned long) fPtr->fix.mmio_start & ~PAGE_MASK;
fPtr->mmio_len = (mmio_off+fPtr->fix.mmio_len+~PAGE_MASK) &
PAGE_MASK;
if (NULL == fPtr->fbmem)
calculateFbmem_len(fPtr);
fPtr->mmio = mmap(NULL, fPtr->mmio_len, PROT_READ | PROT_WRITE,
MAP_SHARED, fPtr->fd, fPtr->fbmem_len);
if (-1 == (long)fPtr->mmio) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"mmap mmio: %s\n", strerror(errno));
fPtr->mmio = NULL;
} else
fPtr->mmio += mmio_off;
}
return fPtr->mmio;
}
Bool
fbdevHWUnmapMMIO(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("UnmapMMIO");
if (NULL != fPtr->mmio) {
if (-1 == munmap((void *)((unsigned long)fPtr->mmio & PAGE_MASK), fPtr->mmio_len))
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"munmap mmio: %s\n", strerror(errno));
fPtr->mmio = NULL;
/* FIXME: restore var.accel_flags [geert] */
}
return TRUE;
}
/* -------------------------------------------------------------------- */
Bool
fbdevHWModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("ModeInit");
xfree2fbdev_fblayout(pScrn, &fPtr->var);
xfree2fbdev_timing(mode, &fPtr->var);
#if DEBUG
print_xfree_mode("init",mode);
print_fbdev_mode("init",&fPtr->var);
#endif
pScrn->vtSema = TRUE;
/* set */
if (0 != ioctl(fPtr->fd,FBIOPUT_VSCREENINFO,(void*)(&fPtr->var))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"FBIOPUT_VSCREENINFO: %s\n", strerror(errno));
return FALSE;
}
/* read back */
if (0 != ioctl(fPtr->fd,FBIOGET_FSCREENINFO,(void*)(&fPtr->fix))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"FBIOGET_FSCREENINFO: %s\n", strerror(errno));
return FALSE;
}
if (0 != ioctl(fPtr->fd,FBIOGET_VSCREENINFO,(void*)(&fPtr->var))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"FBIOGET_VSCREENINFO: %s\n", strerror(errno));
return FALSE;
}
return TRUE;
}
/* -------------------------------------------------------------------- */
/* video mode save/restore */
/* TODO: colormap */
void
fbdevHWSave(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("Save");
if (0 != ioctl(fPtr->fd,FBIOGET_VSCREENINFO,(void*)(&fPtr->saved_var)))
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"FBIOGET_VSCREENINFO: %s\n", strerror(errno));
}
void
fbdevHWRestore(ScrnInfoPtr pScrn)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("Restore");
if (0 != ioctl(fPtr->fd,FBIOPUT_VSCREENINFO,(void*)(&fPtr->saved_var)))
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"FBIOPUT_VSCREENINFO: %s\n", strerror(errno));
}
/* -------------------------------------------------------------------- */
/* callback for xf86HandleColormaps */
void
fbdevHWLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
LOCO *colors, VisualPtr pVisual)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
struct fb_cmap cmap;
unsigned short red,green,blue;
int i;
TRACE_ENTER("ModeInit");
cmap.len = 1;
cmap.red = &red;
cmap.green = &green;
cmap.blue = &blue;
cmap.transp = NULL;
for (i = 0; i < numColors; i++) {
cmap.start = indices[i];
red = (colors[indices[i]].red << 8) |
colors[indices[i]].red;
green = (colors[indices[i]].green << 8) |
colors[indices[i]].green;
blue = (colors[indices[i]].blue << 8) |
colors[indices[i]].blue;
if (-1 == ioctl(fPtr->fd,FBIOPUTCMAP,(void*)&cmap))
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"FBIOPUTCMAP: %s\n", strerror(errno));
}
}
/* -------------------------------------------------------------------- */
/* these can be hooked directly into ScrnInfoRec */
ModeStatus
fbdevHWValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
struct fb_var_screeninfo var;
TRACE_ENTER("ValidMode");
memcpy(&var,&fPtr->var,sizeof(var));
xfree2fbdev_timing(mode, &var);
var.activate = FB_ACTIVATE_TEST;
if (0 != ioctl(fPtr->fd,FBIOPUT_VSCREENINFO,(void*)(&fPtr->var))) {
xf86DrvMsg(scrnIndex, X_ERROR,
"FBIOPUT_VSCREENINFO: %s\n", strerror(errno));
return MODE_BAD;
}
return MODE_OK;
}
Bool
fbdevHWSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("SwitchMode");
xfree2fbdev_timing(mode, &fPtr->var);
if (0 != ioctl(fPtr->fd,FBIOPUT_VSCREENINFO,(void*)(&fPtr->var))) {
xf86DrvMsg(scrnIndex, X_ERROR,
"FBIOPUT_VSCREENINFO: %s\n", strerror(errno));
return FALSE;
}
return TRUE;
}
void
fbdevHWAdjustFrame(int scrnIndex, int x, int y, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
TRACE_ENTER("AdjustFrame");
if ( x < 0 || x + fPtr->var.xres > fPtr->var.xres_virtual ||
y < 0 || y + fPtr->var.yres > fPtr->var.yres_virtual )
return;
fPtr->var.xoffset = x;
fPtr->var.yoffset = y;
if (-1 == ioctl(fPtr->fd,FBIOPAN_DISPLAY,(void*)&fPtr->var))
xf86DrvMsgVerb(scrnIndex,5, X_WARNING,
"FBIOPAN_DISPLAY: %s\n", strerror(errno));
}
Bool
fbdevHWEnterVT(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
TRACE_ENTER("EnterVT");
if (!fbdevHWModeInit(pScrn, pScrn->currentMode))
return FALSE;
fbdevHWAdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
return TRUE;
}
void
fbdevHWLeaveVT(int scrnIndex, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
TRACE_ENTER("LeaveVT");
fbdevHWRestore(pScrn);
}
void
fbdevHWDPMSSet(ScrnInfoPtr pScrn, int mode, int flags)
{
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
unsigned long fbmode;
if (!pScrn->vtSema)
return;
switch (mode) {
case DPMSModeOn:
fbmode = 0;
break;
case DPMSModeStandby:
fbmode = 2;
break;
case DPMSModeSuspend:
fbmode = 3;
break;
case DPMSModeOff:
fbmode = 4;
break;
default:
return;
}
if (-1 == ioctl(fPtr->fd, FBIOBLANK, (void *)fbmode))
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"FBIOBLANK: %s\n", strerror(errno));
}
Bool
fbdevHWSaveScreen(ScreenPtr pScreen, int mode)
{
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
unsigned long unblank;
if (!pScrn->vtSema)
return TRUE;
unblank = xf86IsUnblank(mode);
if (-1 == ioctl(fPtr->fd, FBIOBLANK, (void *)(1-unblank))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"FBIOBLANK: %s\n", strerror(errno));
return FALSE;
}
return TRUE;
}
--- NEW FILE: fbdevhw.h ---
/* $XFree86: xc/programs/Xserver/hw/xfree86/fbdevhw/fbdevhw.h,v 1.11 2001/10/01 13:44:12 eich Exp $ */
#ifndef _FBDEVHW_H_
#define _FBDEVHW_H_
#include "xf86str.h"
#include "colormapst.h"
#define FBDEVHW_PACKED_PIXELS 0 /* Packed Pixels */
#define FBDEVHW_PLANES 1 /* Non interleaved planes */
#define FBDEVHW_INTERLEAVED_PLANES 2 /* Interleaved planes */
#define FBDEVHW_TEXT 3 /* Text/attributes */
#define FBDEVHW_VGA_PLANES 4 /* EGA/VGA planes */
Bool fbdevHWGetRec(ScrnInfoPtr pScrn);
void fbdevHWFreeRec(ScrnInfoPtr pScrn);
Bool fbdevHWProbe(pciVideoPtr pPci, char *device, char **namep);
Bool fbdevHWInit(ScrnInfoPtr pScrn, pciVideoPtr pPci, char *device);
char* fbdevHWGetName(ScrnInfoPtr pScrn);
int fbdevHWGetDepth(ScrnInfoPtr pScrn, int *fbbpp);
int fbdevHWGetLineLength(ScrnInfoPtr pScrn);
int fbdevHWGetType(ScrnInfoPtr pScrn);
int fbdevHWGetVidmem(ScrnInfoPtr pScrn);
void* fbdevHWMapVidmem(ScrnInfoPtr pScrn);
int fbdevHWLinearOffset(ScrnInfoPtr pScrn);
Bool fbdevHWUnmapVidmem(ScrnInfoPtr pScrn);
void* fbdevHWMapMMIO(ScrnInfoPtr pScrn);
Bool fbdevHWUnmapMMIO(ScrnInfoPtr pScrn);
void fbdevHWSetVideoModes(ScrnInfoPtr pScrn);
DisplayModePtr fbdevHWGetBuildinMode(ScrnInfoPtr pScrn);
void fbdevHWUseBuildinMode(ScrnInfoPtr pScrn);
Bool fbdevHWModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode);
void fbdevHWSave(ScrnInfoPtr pScrn);
void fbdevHWRestore(ScrnInfoPtr pScrn);
void fbdevHWLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
LOCO *colors, VisualPtr pVisual);
ModeStatus fbdevHWValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags);
Bool fbdevHWSwitchMode(int scrnIndex, DisplayModePtr mode, int flags);
void fbdevHWAdjustFrame(int scrnIndex, int x, int y, int flags);
Bool fbdevHWEnterVT(int scrnIndex, int flags);
void fbdevHWLeaveVT(int scrnIndex, int flags);
void fbdevHWDPMSSet(ScrnInfoPtr pScrn, int mode, int flags);
Bool fbdevHWSaveScreen(ScreenPtr pScreen, int mode);
#endif
--- NEW FILE: fbdevhwstub.c ---
/* $XFree86: xc/programs/Xserver/hw/xfree86/fbdevhw/fbdevhwstub.c,v 1.12 2001/10/28 03:33:55 tsi Exp $ */
#include "xf86.h"
#include "xf86cmap.h"
#include "fbdevhw.h"
/* Stubs for the static server on platforms that don't support fbdev */
Bool
fbdevHWGetRec(ScrnInfoPtr pScrn)
{
return FALSE;
}
void
fbdevHWFreeRec(ScrnInfoPtr pScrn)
{
}
Bool
fbdevHWProbe(pciVideoPtr pPci, char *device, char **namep)
{
return FALSE;
}
Bool
fbdevHWInit(ScrnInfoPtr pScrn, pciVideoPtr pPci, char *device)
{
xf86Msg(X_ERROR, "fbdevhw is not available on this platform\n");
return FALSE;
}
char*
fbdevHWGetName(ScrnInfoPtr pScrn)
{
return NULL;
}
int
fbdevHWGetDepth(ScrnInfoPtr pScrn, int *fbbpp)
{
return -1;
}
int
fbdevHWGetLineLength(ScrnInfoPtr pScrn)
{
return -1; /* Should cause something spectacular... */
}
int
fbdevHWGetType(ScrnInfoPtr pScrn)
{
return -1;
}
int
fbdevHWGetVidmem(ScrnInfoPtr pScrn)
{
return -1;
}
void
fbdevHWSetVideoModes(ScrnInfoPtr pScrn)
{
}
DisplayModePtr
fbdevHWGetBuildinMode(ScrnInfoPtr pScrn)
{
return NULL;
}
void
fbdevHWUseBuildinMode(ScrnInfoPtr pScrn)
{
}
void*
fbdevHWMapVidmem(ScrnInfoPtr pScrn)
{
return NULL;
}
int
fbdevHWLinearOffset(ScrnInfoPtr pScrn)
{
return 0;
}
Bool
fbdevHWUnmapVidmem(ScrnInfoPtr pScrn)
{
return FALSE;
}
void*
fbdevHWMapMMIO(ScrnInfoPtr pScrn)
{
return NULL;
}
Bool
fbdevHWUnmapMMIO(ScrnInfoPtr pScrn)
{
return FALSE;
}
Bool
fbdevHWModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
return FALSE;
}
void
fbdevHWSave(ScrnInfoPtr pScrn)
{
}
void
fbdevHWRestore(ScrnInfoPtr pScrn)
{
}
void
fbdevHWLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
LOCO *colors, VisualPtr pVisual)
{
}
ModeStatus
fbdevHWValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
{
return MODE_ERROR;
}
Bool
fbdevHWSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
{
return FALSE;
}
void
fbdevHWAdjustFrame(int scrnIndex, int x, int y, int flags)
{
}
Bool
fbdevHWEnterVT(int scrnIndex, int flags)
{
return FALSE;
}
void
fbdevHWLeaveVT(int scrnIndex, int flags)
{
}
void
fbdevHWDPMSSet(ScrnInfoPtr pScrn, int mode, int flags)
{
}
Bool
fbdevHWSaveScreen(ScreenPtr pScreen, int mode)
{
return FALSE;
}
--- NEW FILE: fbpriv.h ---
/*
* copyed from from linux kernel 2.2.4
* removed internal stuff (#ifdef __KERNEL__)
*/
/* $XFree86: xc/programs/Xserver/hw/xfree86/fbdevhw/fbpriv.h,v 1.2 2000/01/21 02:30:02 dawes Exp $ */
#ifndef _LINUX_FB_H
#define _LINUX_FB_H
#include <asm/types.h>
/* Definitions of frame buffers */
#define FB_MAJOR 29
#define FB_MODES_SHIFT 5 /* 32 modes per framebuffer */
#define FB_NUM_MINORS 256 /* 256 Minors */
#define FB_MAX (FB_NUM_MINORS / (1 << FB_MODES_SHIFT))
#define GET_FB_IDX(node) (MINOR(node) >> FB_MODES_SHIFT)
/* ioctls
0x46 is 'F' */
#define FBIOGET_VSCREENINFO 0x4600
#define FBIOPUT_VSCREENINFO 0x4601
#define FBIOGET_FSCREENINFO 0x4602
#define FBIOGETCMAP 0x4604
#define FBIOPUTCMAP 0x4605
#define FBIOPAN_DISPLAY 0x4606
/* 0x4607-0x460B are defined below */
/* #define FBIOGET_MONITORSPEC 0x460C */
/* #define FBIOPUT_MONITORSPEC 0x460D */
/* #define FBIOSWITCH_MONIBIT 0x460E */
#define FBIOGET_CON2FBMAP 0x460F
#define FBIOPUT_CON2FBMAP 0x4610
#define FBIOBLANK 0x4611
#define FB_TYPE_PACKED_PIXELS 0 /* Packed Pixels */
#define FB_TYPE_PLANES 1 /* Non interleaved planes */
#define FB_TYPE_INTERLEAVED_PLANES 2 /* Interleaved planes */
#define FB_TYPE_TEXT 3 /* Text/attributes */
#define FB_AUX_TEXT_MDA 0 /* Monochrome text */
#define FB_AUX_TEXT_CGA 1 /* CGA/EGA/VGA Color text */
#define FB_AUX_TEXT_S3_MMIO 2 /* S3 MMIO fasttext */
#define FB_AUX_TEXT_MGA_STEP16 3 /* MGA Millenium I: text, attr, 14 reserved bytes */
#define FB_AUX_TEXT_MGA_STEP8 4 /* other MGAs: text, attr, 6 reserved bytes */
#define FB_VISUAL_MONO01 0 /* Monochr. 1=Black 0=White */
#define FB_VISUAL_MONO10 1 /* Monochr. 1=White 0=Black */
#define FB_VISUAL_TRUECOLOR 2 /* True color */
#define FB_VISUAL_PSEUDOCOLOR 3 /* Pseudo color (like atari) */
#define FB_VISUAL_DIRECTCOLOR 4 /* Direct color */
#define FB_VISUAL_STATIC_PSEUDOCOLOR 5 /* Pseudo color readonly */
#define FB_ACCEL_NONE 0 /* no hardware accelerator */
#define FB_ACCEL_ATARIBLITT 1 /* Atari Blitter */
#define FB_ACCEL_AMIGABLITT 2 /* Amiga Blitter */
#define FB_ACCEL_S3_TRIO64 3 /* Cybervision64 (S3 Trio64) */
#define FB_ACCEL_NCR_77C32BLT 4 /* RetinaZ3 (NCR 77C32BLT) */
#define FB_ACCEL_S3_VIRGE 5 /* Cybervision64/3D (S3 ViRGE) */
#define FB_ACCEL_ATI_MACH64GX 6 /* ATI Mach 64GX family */
#define FB_ACCEL_DEC_TGA 7 /* DEC 21030 TGA */
#define FB_ACCEL_ATI_MACH64CT 8 /* ATI Mach 64CT family */
#define FB_ACCEL_ATI_MACH64VT 9 /* ATI Mach 64CT family VT class */
#define FB_ACCEL_ATI_MACH64GT 10 /* ATI Mach 64CT family GT class */
#define FB_ACCEL_SUN_CREATOR 11 /* Sun Creator/Creator3D */
#define FB_ACCEL_SUN_CGSIX 12 /* Sun cg6 */
#define FB_ACCEL_SUN_LEO 13 /* Sun leo/zx */
#define FB_ACCEL_IMS_TWINTURBO 14 /* IMS Twin Turbo */
#define FB_ACCEL_3DLABS_PERMEDIA2 15 /* 3Dlabs Permedia 2 */
#define FB_ACCEL_MATROX_MGA2064W 16 /* Matrox MGA2064W (Millenium) */
#define FB_ACCEL_MATROX_MGA1064SG 17 /* Matrox MGA1064SG (Mystique) */
#define FB_ACCEL_MATROX_MGA2164W 18 /* Matrox MGA2164W (Millenium II) */
#define FB_ACCEL_MATROX_MGA2164W_AGP 19 /* Matrox MGA2164W (Millenium II) */
#define FB_ACCEL_MATROX_MGAG100 20 /* Matrox G100 (Productiva G100) */
#define FB_ACCEL_MATROX_MGAG200 21 /* Matrox G200 (Myst, Mill, ...) */
#define FB_ACCEL_SUN_CG14 22 /* Sun cgfourteen */
#define FB_ACCEL_SUN_BWTWO 23 /* Sun bwtwo */
#define FB_ACCEL_SUN_CGTHREE 24 /* Sun cgthree */
#define FB_ACCEL_SUN_TCX 25 /* Sun tcx */
#define FB_ACCEL_MATROX_MGAG400 26 /* Matrox G400 */
#define FB_ACCEL_NV3 27 /* nVidia RIVA 128 */
#define FB_ACCEL_NV4 28 /* nVidia RIVA TNT */
#define FB_ACCEL_NV5 29 /* nVidia RIVA TNT2 */
#define FB_ACCEL_CT_6555x 30 /* C&T 6555x */
#define FB_ACCEL_3DFX_BANSHEE 31 /* 3Dfx Banshee */
#define FB_ACCEL_ATI_RAGE128 32 /* ATI Rage128 family */
struct fb_fix_screeninfo {
char id[16]; /* identification string eg "TT Builtin" */
char *smem_start; /* Start of frame buffer mem */
/* (physical address) */
__u32 smem_len; /* Length of frame buffer mem */
__u32 type; /* see FB_TYPE_* */
__u32 type_aux; /* Interleave for interleaved Planes */
__u32 visual; /* see FB_VISUAL_* */
__u16 xpanstep; /* zero if no hardware panning */
__u16 ypanstep; /* zero if no hardware panning */
__u16 ywrapstep; /* zero if no hardware ywrap */
__u32 line_length; /* length of a line in bytes */
char *mmio_start; /* Start of Memory Mapped I/O */
/* (physical address) */
__u32 mmio_len; /* Length of Memory Mapped I/O */
__u32 accel; /* Type of acceleration available */
__u16 reserved[3]; /* Reserved for future compatibility */
};
/* Interpretation of offset for color fields: All offsets are from the right,
* inside a "pixel" value, which is exactly 'bits_per_pixel' wide (means: you
* can use the offset as right argument to <<). A pixel afterwards is a bit
* stream and is written to video memory as that unmodified. This implies
* big-endian byte order if bits_per_pixel is greater than 8.
*/
struct fb_bitfield {
__u32 offset; /* beginning of bitfield */
__u32 length; /* length of bitfield */
__u32 msb_right; /* != 0 : Most significant bit is */
/* right */
};
#define FB_NONSTD_HAM 1 /* Hold-And-Modify (HAM) */
#define FB_ACTIVATE_NOW 0 /* set values immediately (or vbl)*/
#define FB_ACTIVATE_NXTOPEN 1 /* activate on next open */
#define FB_ACTIVATE_TEST 2 /* don't set, round up impossible */
#define FB_ACTIVATE_MASK 15
/* values */
#define FB_ACTIVATE_VBL 16 /* activate values on next vbl */
#define FB_CHANGE_CMAP_VBL 32 /* change colormap on vbl */
#define FB_ACTIVATE_ALL 64 /* change all VCs on this fb */
#define FB_ACCELF_TEXT 1 /* text mode acceleration */
#define FB_SYNC_HOR_HIGH_ACT 1 /* horizontal sync high active */
#define FB_SYNC_VERT_HIGH_ACT 2 /* vertical sync high active */
#define FB_SYNC_EXT 4 /* external sync */
#define FB_SYNC_COMP_HIGH_ACT 8 /* composite sync high active */
#define FB_SYNC_BROADCAST 16 /* broadcast video timings */
/* vtotal = 144d/288n/576i => PAL */
/* vtotal = 121d/242n/484i => NTSC */
#define FB_SYNC_ON_GREEN 32 /* sync on green */
#define FB_VMODE_NONINTERLACED 0 /* non interlaced */
#define FB_VMODE_INTERLACED 1 /* interlaced */
#define FB_VMODE_DOUBLE 2 /* double scan */
#define FB_VMODE_MASK 255
#define FB_VMODE_YWRAP 256 /* ywrap instead of panning */
#define FB_VMODE_SMOOTH_XPAN 512 /* smooth xpan possible (internally used) */
#define FB_VMODE_CONUPDATE 512 /* don't update x/yoffset */
struct fb_var_screeninfo {
__u32 xres; /* visible resolution */
__u32 yres;
__u32 xres_virtual; /* virtual resolution */
__u32 yres_virtual;
__u32 xoffset; /* offset from virtual to visible */
__u32 yoffset; /* resolution */
__u32 bits_per_pixel; /* guess what */
__u32 grayscale; /* != 0 Graylevels instead of colors */
struct fb_bitfield red; /* bitfield in fb mem if true color, */
struct fb_bitfield green; /* else only length is significant */
struct fb_bitfield blue;
struct fb_bitfield transp; /* transparency */
__u32 nonstd; /* != 0 Non standard pixel format */
__u32 activate; /* see FB_ACTIVATE_* */
__u32 height; /* height of picture in mm */
__u32 width; /* width of picture in mm */
__u32 accel_flags; /* acceleration flags (hints) */
/* Timing: All values in pixclocks, except pixclock (of course) */
__u32 pixclock; /* pixel clock in ps (pico seconds) */
__u32 left_margin; /* time from sync to picture */
__u32 right_margin; /* time from picture to sync */
__u32 upper_margin; /* time from sync to picture */
__u32 lower_margin;
__u32 hsync_len; /* length of horizontal sync */
__u32 vsync_len; /* length of vertical sync */
__u32 sync; /* see FB_SYNC_* */
__u32 vmode; /* see FB_VMODE_* */
__u32 reserved[6]; /* Reserved for future compatibility */
};
struct fb_cmap {
__u32 start; /* First entry */
__u32 len; /* Number of entries */
__u16 *red; /* Red values */
__u16 *green;
__u16 *blue;
__u16 *transp; /* transparency, can be NULL */
};
struct fb_con2fbmap {
__u32 console;
__u32 framebuffer;
};
struct fb_monspecs {
__u32 hfmin; /* hfreq lower limit (Hz) */
__u32 hfmax; /* hfreq upper limit (Hz) */
__u16 vfmin; /* vfreq lower limit (Hz) */
__u16 vfmax; /* vfreq upper limit (Hz) */
unsigned dpms : 1; /* supports DPMS */
};
#if 1
#define FBCMD_GET_CURRENTPAR 0xDEAD0005
#define FBCMD_SET_CURRENTPAR 0xDEAD8005
#endif
#if 1 /* Preliminary */
/*
* Hardware Cursor
*/
#define FBIOGET_FCURSORINFO 0x4607
#define FBIOGET_VCURSORINFO 0x4608
#define FBIOPUT_VCURSORINFO 0x4609
#define FBIOGET_CURSORSTATE 0x460A
#define FBIOPUT_CURSORSTATE 0x460B
struct fb_fix_cursorinfo {
__u16 crsr_width; /* width and height of the cursor in */
__u16 crsr_height; /* pixels (zero if no cursor) */
__u16 crsr_xsize; /* cursor size in display pixels */
__u16 crsr_ysize;
__u16 crsr_color1; /* colormap entry for cursor color1 */
__u16 crsr_color2; /* colormap entry for cursor color2 */
};
struct fb_var_cursorinfo {
__u16 width;
__u16 height;
__u16 xspot;
__u16 yspot;
__u8 data[1]; /* field with [height][width] */
};
struct fb_cursorstate {
__s16 xoffset;
__s16 yoffset;
__u16 mode;
};
#define FB_CURSOR_OFF 0
#define FB_CURSOR_ON 1
#define FB_CURSOR_FLASH 2
#endif /* Preliminary */
#endif /* _LINUX_FB_H */
- Previous message: xserver/hw/xorg/dummylib Makefile.am, NONE, 1.1 dummylib.h, NONE,
1.1 fatalerror.c, NONE, 1.1 getvalidbios.c, NONE,
1.1 logvwrite.c, NONE, 1.1 pcitestmulti.c, NONE, 1.1 strlcat.c,
NONE, 1.1 strlcpy.c, NONE, 1.1 verrorf.c, NONE, 1.1 xalloc.c,
NONE, 1.1 xf86addrestolist.c, NONE, 1.1 xf86allocscripi.c,
NONE, 1.1 xf86drvmsg.c, NONE, 1.1 xf86drvmsgverb.c, NONE,
1.1 xf86errorf.c, NONE, 1.1 xf86errorfverb.c, NONE,
1.1 xf86getpagesize.c, NONE, 1.1 xf86getverb.c, NONE,
1.1 xf86info.c, NONE, 1.1 xf86msg.c, NONE, 1.1 xf86msgverb.c,
NONE, 1.1 xf86opt.c, NONE, 1.1 xf86screens.c, NONE,
1.1 xf86servisinit.c, NONE, 1.1 xf86verbose.c, NONE, 1.1
- Next message: xserver/hw/xorg/i2c Makefile.am, NONE, 1.1 xf86i2c.c, NONE,
1.1 xf86i2c.h, NONE, 1.1 xf86i2cmodule.c, NONE, 1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
More information about the xserver-commit
mailing list