2006-11-26 11:13:41 -07:00
|
|
|
/* all driver need this */
|
|
|
|
#ifdef HAVE_XORG_CONFIG_H
|
|
|
|
#include <xorg-config.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "xf86.h"
|
2014-05-02 13:27:46 -06:00
|
|
|
#include "xf86Modes.h"
|
2006-11-26 11:13:41 -07:00
|
|
|
#include "xf86_OSproc.h"
|
|
|
|
|
|
|
|
/* pci stuff */
|
|
|
|
#include "xf86Pci.h"
|
|
|
|
|
|
|
|
#include "xf86cmap.h"
|
|
|
|
|
|
|
|
#include "fbdevhw.h"
|
|
|
|
#include "fbpriv.h"
|
|
|
|
#include "globals.h"
|
2010-07-27 13:02:24 -06:00
|
|
|
#include <X11/extensions/dpmsconst.h>
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
#define PAGE_MASK (~(getpagesize() - 1))
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
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}
|
2006-11-26 11:13:41 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
_X_EXPORT XF86ModuleData fbdevhwModuleData = {
|
|
|
|
&fbdevHWVersRec,
|
2011-11-05 07:32:40 -06:00
|
|
|
NULL,
|
2006-11-26 11:13:41 -07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/* 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 {
|
2012-06-10 07:21:05 -06:00
|
|
|
/* 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;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
/* current hardware state */
|
|
|
|
struct fb_fix_screeninfo fix;
|
|
|
|
struct fb_var_screeninfo var;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
/* saved video mode */
|
|
|
|
struct fb_var_screeninfo saved_var;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
/* buildin video mode */
|
|
|
|
DisplayModeRec buildin;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
} fbdevHWRec, *fbdevHWPtr;
|
|
|
|
|
|
|
|
Bool
|
|
|
|
fbdevHWGetRec(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
if (fbdevHWPrivateIndex < 0)
|
|
|
|
fbdevHWPrivateIndex = xf86AllocateScrnInfoPrivateIndex();
|
|
|
|
|
|
|
|
if (FBDEVHWPTR(pScrn) != NULL)
|
|
|
|
return TRUE;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2014-09-27 11:52:59 -06:00
|
|
|
FBDEVHWPTRLVAL(pScrn) = xnfcalloc(sizeof(fbdevHWRec), 1);
|
2012-06-10 07:21:05 -06:00
|
|
|
return TRUE;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
fbdevHWFreeRec(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
if (fbdevHWPrivateIndex < 0)
|
|
|
|
return;
|
|
|
|
free(FBDEVHWPTR(pScrn));
|
|
|
|
FBDEVHWPTRLVAL(pScrn) = NULL;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
2010-07-27 13:02:24 -06:00
|
|
|
int
|
|
|
|
fbdevHWGetFD(ScrnInfoPtr pScrn)
|
|
|
|
{
|
|
|
|
fbdevHWPtr fPtr;
|
|
|
|
|
|
|
|
fbdevHWGetRec(pScrn);
|
|
|
|
fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
|
|
|
|
return fPtr->fd;
|
|
|
|
}
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/* some helpers for printing debug informations */
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
static void
|
|
|
|
print_fbdev_mode(char *txt, struct fb_var_screeninfo *var)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
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);
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
print_xfree_mode(char *txt, DisplayModePtr mode)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
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);
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/* Convert timings between the XFree and the Frame Buffer Device */
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfree2fbdev_fblayout(ScrnInfoPtr pScrn, struct fb_var_screeninfo *var)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
var->xres_virtual = pScrn->displayWidth ? pScrn->displayWidth :
|
|
|
|
pScrn->virtualX;
|
|
|
|
var->yres_virtual = pScrn->virtualY;
|
|
|
|
var->bits_per_pixel = pScrn->bitsPerPixel;
|
|
|
|
if (pScrn->defaultVisual == TrueColor ||
|
|
|
|
pScrn->defaultVisual == DirectColor) {
|
|
|
|
var->red.length = pScrn->weight.red;
|
|
|
|
var->green.length = pScrn->weight.green;
|
|
|
|
var->blue.length = pScrn->weight.blue;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
var->red.length = 8;
|
|
|
|
var->green.length = 8;
|
|
|
|
var->blue.length = 8;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfree2fbdev_timing(DisplayModePtr mode, struct fb_var_screeninfo *var)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
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 (mode->Flags & V_BCAST)
|
|
|
|
var->sync |= FB_SYNC_BROADCAST;
|
|
|
|
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;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
2007-11-24 10:55:21 -07:00
|
|
|
static Bool
|
|
|
|
fbdev_modes_equal(struct fb_var_screeninfo *set, struct fb_var_screeninfo *req)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
return (set->xres_virtual >= req->xres_virtual &&
|
|
|
|
set->yres_virtual >= req->yres_virtual &&
|
|
|
|
set->bits_per_pixel == req->bits_per_pixel &&
|
|
|
|
set->red.length == req->red.length &&
|
|
|
|
set->green.length == req->green.length &&
|
|
|
|
set->blue.length == req->blue.length &&
|
|
|
|
set->xres == req->xres && set->yres == req->yres &&
|
|
|
|
set->right_margin == req->right_margin &&
|
|
|
|
set->hsync_len == req->hsync_len &&
|
|
|
|
set->left_margin == req->left_margin &&
|
|
|
|
set->lower_margin == req->lower_margin &&
|
|
|
|
set->vsync_len == req->vsync_len &&
|
|
|
|
set->upper_margin == req->upper_margin &&
|
|
|
|
set->sync == req->sync && set->vmode == req->vmode);
|
2007-11-24 10:55:21 -07:00
|
|
|
}
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
static void
|
|
|
|
fbdev2xfree_timing(struct fb_var_screeninfo *var, DisplayModePtr mode)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
mode->Clock = var->pixclock ? 1000000000 / var->pixclock : 0;
|
|
|
|
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 (var->sync & FB_SYNC_BROADCAST)
|
|
|
|
mode->Flags |= V_BCAST;
|
|
|
|
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;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/* open correct framebuffer device */
|
|
|
|
|
2008-11-02 08:26:08 -07:00
|
|
|
/**
|
|
|
|
* Try to find the framebuffer device for a given PCI device
|
|
|
|
*/
|
2006-11-26 11:13:41 -07:00
|
|
|
static int
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdev_open_pci(struct pci_device *pPci, char **namep)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
struct fb_fix_screeninfo fix;
|
|
|
|
char filename[256];
|
|
|
|
int fd, i;
|
2008-11-02 08:26:08 -07:00
|
|
|
|
|
|
|
for (i = 0; i < 8; i++) {
|
2012-06-10 07:21:05 -06:00
|
|
|
snprintf(filename, sizeof(filename),
|
|
|
|
"/sys/bus/pci/devices/%04x:%02x:%02x.%d/graphics/fb%d",
|
|
|
|
pPci->domain, pPci->bus, pPci->dev, pPci->func, i);
|
2008-11-02 08:26:08 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
fd = open(filename, O_RDONLY, 0);
|
2009-10-31 08:09:43 -06:00
|
|
|
if (fd < 0) {
|
2012-06-10 07:21:05 -06:00
|
|
|
snprintf(filename, sizeof(filename),
|
|
|
|
"/sys/bus/pci/devices/%04x:%02x:%02x.%d/graphics:fb%d",
|
|
|
|
pPci->domain, pPci->bus, pPci->dev, pPci->func, i);
|
2009-10-31 08:09:43 -06:00
|
|
|
fd = open(filename, O_RDONLY, 0);
|
|
|
|
}
|
2012-06-10 07:21:05 -06:00
|
|
|
if (fd >= 0) {
|
|
|
|
close(fd);
|
|
|
|
snprintf(filename, sizeof(filename), "/dev/fb%d", i);
|
|
|
|
|
|
|
|
fd = open(filename, O_RDWR, 0);
|
|
|
|
if (fd != -1) {
|
|
|
|
if (ioctl(fd, FBIOGET_FSCREENINFO, (void *) &fix) != -1) {
|
|
|
|
if (namep) {
|
|
|
|
*namep = xnfalloc(16);
|
|
|
|
strncpy(*namep, fix.id, 16);
|
|
|
|
}
|
|
|
|
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
}
|
2008-11-02 08:26:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (namep)
|
2012-06-10 07:21:05 -06:00
|
|
|
*namep = NULL;
|
2008-11-02 08:26:08 -07:00
|
|
|
|
2011-11-05 07:32:40 -06:00
|
|
|
xf86DrvMsg(-1, X_ERROR, "Unable to find a valid framebuffer device\n");
|
2008-11-02 08:26:08 -07:00
|
|
|
return -1;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2014-09-27 11:52:59 -06:00
|
|
|
fbdev_open(int scrnIndex, const char *dev, char **namep)
|
2012-06-10 07:21:05 -06:00
|
|
|
{
|
|
|
|
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;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
Bool
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWProbe(struct pci_device *pPci, char *device, char **namep)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
int fd;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (pPci)
|
|
|
|
fd = fbdev_open_pci(pPci, namep);
|
|
|
|
else
|
|
|
|
fd = fbdev_open(-1, device, namep);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (-1 == fd)
|
|
|
|
return FALSE;
|
|
|
|
close(fd);
|
|
|
|
return TRUE;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Bool
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWInit(ScrnInfoPtr pScrn, struct pci_device *pPci, char *device)
|
|
|
|
{
|
|
|
|
fbdevHWPtr fPtr;
|
|
|
|
|
|
|
|
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 *
|
2006-11-26 11:13:41 -07:00
|
|
|
fbdevHWGetName(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
|
|
|
|
return fPtr->fix.id;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fbdevHWGetDepth(ScrnInfoPtr pScrn, int *fbbpp)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (fbbpp)
|
|
|
|
*fbbpp = fPtr->var.bits_per_pixel;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
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;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fbdevHWGetLineLength(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (fPtr->fix.line_length)
|
|
|
|
return fPtr->fix.line_length;
|
|
|
|
else
|
|
|
|
return fPtr->var.xres_virtual * fPtr->var.bits_per_pixel / 8;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fbdevHWGetType(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
|
|
|
|
return fPtr->fix.type;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fbdevHWGetVidmem(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
|
|
|
|
return fPtr->fix.smem_len;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
2007-11-24 10:55:21 -07:00
|
|
|
static Bool
|
|
|
|
fbdevHWSetMode(ScrnInfoPtr pScrn, DisplayModePtr mode, Bool check)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
struct fb_var_screeninfo req_var = fPtr->var, set_var;
|
2007-11-24 10:55:21 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
xfree2fbdev_fblayout(pScrn, &req_var);
|
|
|
|
xfree2fbdev_timing(mode, &req_var);
|
2007-11-24 10:55:21 -07:00
|
|
|
|
|
|
|
#if DEBUG
|
2012-06-10 07:21:05 -06:00
|
|
|
print_xfree_mode("init", mode);
|
|
|
|
print_fbdev_mode("init", &req_var);
|
2007-11-24 10:55:21 -07:00
|
|
|
#endif
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
set_var = req_var;
|
2007-11-24 10:55:21 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (check)
|
|
|
|
set_var.activate = FB_ACTIVATE_TEST;
|
2007-11-24 10:55:21 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (0 != ioctl(fPtr->fd, FBIOPUT_VSCREENINFO, (void *) (&set_var))) {
|
|
|
|
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
|
|
|
|
"FBIOPUT_VSCREENINFO: %s\n", strerror(errno));
|
|
|
|
return FALSE;
|
|
|
|
}
|
2007-11-24 10:55:21 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!fbdev_modes_equal(&set_var, &req_var)) {
|
|
|
|
if (!check)
|
|
|
|
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
|
|
|
|
"FBIOPUT_VSCREENINFO succeeded but modified " "mode\n");
|
2007-11-24 10:55:21 -07:00
|
|
|
#if DEBUG
|
2012-06-10 07:21:05 -06:00
|
|
|
print_fbdev_mode("returned", &set_var);
|
2007-11-24 10:55:21 -07:00
|
|
|
#endif
|
2012-06-10 07:21:05 -06:00
|
|
|
return FALSE;
|
|
|
|
}
|
2007-11-24 10:55:21 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!check)
|
|
|
|
fPtr->var = set_var;
|
2007-11-24 10:55:21 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
return TRUE;
|
2007-11-24 10:55:21 -07:00
|
|
|
}
|
|
|
|
|
2006-11-26 11:13:41 -07:00
|
|
|
void
|
|
|
|
fbdevHWSetVideoModes(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2014-09-27 11:52:59 -06:00
|
|
|
const char **modename;
|
2012-06-10 07:21:05 -06:00
|
|
|
DisplayModePtr mode, this, last = pScrn->modes;
|
|
|
|
|
|
|
|
if (NULL == pScrn->display->modes)
|
|
|
|
return;
|
|
|
|
|
|
|
|
pScrn->virtualX = pScrn->display->virtualX;
|
|
|
|
pScrn->virtualY = pScrn->display->virtualY;
|
|
|
|
|
|
|
|
for (modename = pScrn->display->modes; *modename != NULL; modename++) {
|
|
|
|
for (mode = pScrn->monitor->Modes; mode != NULL; mode = mode->next) {
|
|
|
|
if (0 == strcmp(mode->name, *modename)) {
|
|
|
|
if (fbdevHWSetMode(pScrn, mode, TRUE))
|
|
|
|
break;
|
|
|
|
|
|
|
|
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
|
|
|
|
"\tmode \"%s\" test failed\n", *modename);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NULL == mode) {
|
|
|
|
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
|
|
|
|
"\tmode \"%s\" not found\n", *modename);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "\tmode \"%s\" ok\n", *modename);
|
|
|
|
|
|
|
|
if (pScrn->virtualX < mode->HDisplay)
|
|
|
|
pScrn->virtualX = mode->HDisplay;
|
|
|
|
if (pScrn->virtualY < mode->VDisplay)
|
|
|
|
pScrn->virtualY = mode->VDisplay;
|
|
|
|
|
|
|
|
if (NULL == pScrn->modes) {
|
|
|
|
this = pScrn->modes = xf86DuplicateMode(mode);
|
|
|
|
this->next = this;
|
|
|
|
this->prev = this;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
this = xf86DuplicateMode(mode);
|
|
|
|
this->next = pScrn->modes;
|
|
|
|
this->prev = last;
|
|
|
|
last->next = this;
|
|
|
|
pScrn->modes->prev = this;
|
|
|
|
}
|
|
|
|
last = this;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
DisplayModePtr
|
|
|
|
fbdevHWGetBuildinMode(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
|
|
|
|
return &fPtr->buildin;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
fbdevHWUseBuildinMode(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
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;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static void
|
|
|
|
calculateFbmem_len(fbdevHWPtr fPtr)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fPtr->fboff = (unsigned long) fPtr->fix.smem_start & ~PAGE_MASK;
|
|
|
|
fPtr->fbmem_len = (fPtr->fboff + fPtr->fix.smem_len + ~PAGE_MASK) &
|
|
|
|
PAGE_MASK;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
void *
|
2006-11-26 11:13:41 -07:00
|
|
|
fbdevHWMapVidmem(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
|
|
|
|
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;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fbdevHWLinearOffset(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
return fPtr->fboff;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Bool
|
|
|
|
fbdevHWUnmapVidmem(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
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;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
void *
|
2006-11-26 11:13:41 -07:00
|
|
|
fbdevHWMapMMIO(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
unsigned int mmio_off;
|
|
|
|
|
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
|
|
|
|
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;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Bool
|
|
|
|
fbdevHWUnmapMMIO(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
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;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
Bool
|
|
|
|
fbdevHWModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
|
2012-06-10 07:21:05 -06:00
|
|
|
{
|
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
|
|
|
|
pScrn->vtSema = TRUE;
|
|
|
|
|
|
|
|
/* set */
|
|
|
|
if (!fbdevHWSetMode(pScrn, mode, FALSE))
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pScrn->defaultVisual == TrueColor ||
|
|
|
|
pScrn->defaultVisual == DirectColor) {
|
|
|
|
/* XXX: This is a hack, but it should be a NOP for all the setups that
|
|
|
|
* worked before and actually seems to fix some others...
|
|
|
|
*/
|
|
|
|
pScrn->offset.red = fPtr->var.red.offset;
|
|
|
|
pScrn->offset.green = fPtr->var.green.offset;
|
|
|
|
pScrn->offset.blue = fPtr->var.blue.offset;
|
|
|
|
pScrn->mask.red =
|
|
|
|
((1 << fPtr->var.red.length) - 1) << fPtr->var.red.offset;
|
|
|
|
pScrn->mask.green =
|
|
|
|
((1 << fPtr->var.green.length) - 1) << fPtr->var.green.offset;
|
|
|
|
pScrn->mask.blue =
|
|
|
|
((1 << fPtr->var.blue.length) - 1) << fPtr->var.blue.offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/* video mode save/restore */
|
|
|
|
void
|
|
|
|
fbdevHWSave(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (0 != ioctl(fPtr->fd, FBIOGET_VSCREENINFO, (void *) (&fPtr->saved_var)))
|
|
|
|
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
|
|
|
|
"FBIOGET_VSCREENINFO: %s\n", strerror(errno));
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
fbdevHWRestore(ScrnInfoPtr pScrn)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (0 != ioctl(fPtr->fd, FBIOPUT_VSCREENINFO, (void *) (&fPtr->saved_var)))
|
|
|
|
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
|
|
|
|
"FBIOPUT_VSCREENINFO: %s\n", strerror(errno));
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/* callback for xf86HandleColormaps */
|
|
|
|
|
|
|
|
void
|
|
|
|
fbdevHWLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
|
2012-06-10 07:21:05 -06:00
|
|
|
LOCO * colors, VisualPtr pVisual)
|
|
|
|
{
|
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
struct fb_cmap cmap;
|
|
|
|
unsigned short red, green, blue;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
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));
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/* these can be hooked directly into ScrnInfoRec */
|
|
|
|
|
|
|
|
ModeStatus
|
2013-06-07 11:28:45 -06:00
|
|
|
fbdevHWValidMode(ScrnInfoPtr pScrn, DisplayModePtr mode, Bool verbose, int flags)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!fbdevHWSetMode(pScrn, mode, TRUE))
|
|
|
|
return MODE_BAD;
|
2007-11-24 10:55:21 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
return MODE_OK;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Bool
|
2013-06-07 11:28:45 -06:00
|
|
|
fbdevHWSwitchMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!fbdevHWSetMode(pScrn, mode, FALSE))
|
|
|
|
return FALSE;
|
2007-11-24 10:55:21 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
return TRUE;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2013-06-07 11:28:45 -06:00
|
|
|
fbdevHWAdjustFrame(ScrnInfoPtr pScrn, int x, int y)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (x < 0 || x + fPtr->var.xres > fPtr->var.xres_virtual ||
|
|
|
|
y < 0 || y + fPtr->var.yres > fPtr->var.yres_virtual)
|
|
|
|
return;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
fPtr->var.xoffset = x;
|
|
|
|
fPtr->var.yoffset = y;
|
|
|
|
if (-1 == ioctl(fPtr->fd, FBIOPAN_DISPLAY, (void *) &fPtr->var))
|
2013-06-07 11:28:45 -06:00
|
|
|
xf86DrvMsgVerb(pScrn->scrnIndex, X_WARNING, 5,
|
2012-06-10 07:21:05 -06:00
|
|
|
"FBIOPAN_DISPLAY: %s\n", strerror(errno));
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Bool
|
2013-06-07 11:28:45 -06:00
|
|
|
fbdevHWEnterVT(ScrnInfoPtr pScrn)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!fbdevHWModeInit(pScrn, pScrn->currentMode))
|
|
|
|
return FALSE;
|
2013-06-07 11:28:45 -06:00
|
|
|
fbdevHWAdjustFrame(pScrn, pScrn->frameX0, pScrn->frameY0);
|
2012-06-10 07:21:05 -06:00
|
|
|
return TRUE;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2013-06-07 11:28:45 -06:00
|
|
|
fbdevHWLeaveVT(ScrnInfoPtr pScrn)
|
2006-11-26 11:13:41 -07:00
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWRestore(pScrn);
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
fbdevHWDPMSSet(ScrnInfoPtr pScrn, int mode, int flags)
|
|
|
|
{
|
2012-06-10 07:21:05 -06:00
|
|
|
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));
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Bool
|
|
|
|
fbdevHWSaveScreen(ScreenPtr pScreen, int mode)
|
|
|
|
{
|
2013-06-07 11:28:45 -06:00
|
|
|
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWPtr fPtr = FBDEVHWPTR(pScrn);
|
|
|
|
unsigned long unblank;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (!pScrn->vtSema)
|
|
|
|
return TRUE;
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
unblank = xf86IsUnblank(mode);
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
if (-1 == ioctl(fPtr->fd, FBIOBLANK, (void *) (1 - unblank))) {
|
|
|
|
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
|
|
|
|
"FBIOBLANK: %s\n", strerror(errno));
|
|
|
|
return FALSE;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
2012-06-10 07:21:05 -06:00
|
|
|
return TRUE;
|
2006-11-26 11:13:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
xf86SwitchModeProc *
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWSwitchModeWeak(void)
|
|
|
|
{
|
|
|
|
return fbdevHWSwitchMode;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
xf86AdjustFrameProc *
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWAdjustFrameWeak(void)
|
|
|
|
{
|
|
|
|
return fbdevHWAdjustFrame;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
xf86EnterVTProc *
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWEnterVTWeak(void)
|
|
|
|
{
|
|
|
|
return fbdevHWEnterVT;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
xf86LeaveVTProc *
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWLeaveVTWeak(void)
|
|
|
|
{
|
|
|
|
return fbdevHWLeaveVT;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
xf86ValidModeProc *
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWValidModeWeak(void)
|
|
|
|
{
|
|
|
|
return fbdevHWValidMode;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
xf86DPMSSetProc *
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWDPMSSetWeak(void)
|
|
|
|
{
|
|
|
|
return fbdevHWDPMSSet;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
xf86LoadPaletteProc *
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWLoadPaletteWeak(void)
|
|
|
|
{
|
|
|
|
return fbdevHWLoadPalette;
|
|
|
|
}
|
2006-11-26 11:13:41 -07:00
|
|
|
|
|
|
|
SaveScreenProcPtr
|
2012-06-10 07:21:05 -06:00
|
|
|
fbdevHWSaveScreenWeak(void)
|
|
|
|
{
|
|
|
|
return fbdevHWSaveScreen;
|
|
|
|
}
|