02d0910511
Convert KDrive to GPE/GKE interface. Add first-class drivers and enumerate every device separately through Xi, instead of lamely attempting to aggregate them. Add XKB support to the Linux keyboard driver. Add 'thumb button' support to the tslib driver. Rejig InitInput, so each DDX has to add a list of drivers it supports. Support NewInputDeviceRequest, et al.
1825 lines
41 KiB
C
1825 lines
41 KiB
C
/*
|
|
Copyright (c) 2000 by Juliusz Chroboczek
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
*/
|
|
/* $Id$ */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <kdrive-config.h>
|
|
#endif
|
|
#include "vesa.h"
|
|
#include "vga.h"
|
|
#include "vbe.h"
|
|
#ifdef RANDR
|
|
#include <randrstr.h>
|
|
#endif
|
|
|
|
int vesa_video_mode = 0;
|
|
Bool vesa_force_mode = FALSE;
|
|
Bool vesa_swap_rgb = FALSE;
|
|
Bool vesa_shadow = FALSE;
|
|
Bool vesa_linear_fb = TRUE;
|
|
Bool vesa_restore = FALSE;
|
|
Bool vesa_verbose = FALSE;
|
|
Bool vesa_force_text = FALSE;
|
|
Bool vesa_restore_font = TRUE;
|
|
Bool vesa_map_holes = TRUE;
|
|
Bool vesa_boot = FALSE;
|
|
|
|
#define VesaPriv(scr) ((VesaScreenPrivPtr) (scr)->driver)
|
|
|
|
#define vesaWidth(scr,vmib) ((vmib)->XResolution)
|
|
#define vesaHeight(scr,vmib) ((vmib)->YResolution)
|
|
|
|
static Bool
|
|
vesaComputeFramebufferMapping (KdScreenInfo *screen);
|
|
|
|
static Bool
|
|
vesaMapFramebuffer (KdScreenInfo *screen);
|
|
|
|
static Bool
|
|
vesaModeSupportable (VesaModePtr mode, Bool complain)
|
|
{
|
|
if((mode->ModeAttributes & 0x10) == 0) {
|
|
if(complain)
|
|
ErrorF("Text mode specified.\n");
|
|
return FALSE;
|
|
}
|
|
if(mode->MemoryModel != 0x06 && mode->MemoryModel != 0x04 && mode->MemoryModel != 0x03) {
|
|
if(complain)
|
|
ErrorF("Unsupported memory model 0x%X\n", mode->MemoryModel);
|
|
return FALSE;
|
|
}
|
|
if((mode->ModeAttributes & 0x80) == 0) {
|
|
if ((mode->ModeAttributes & 0x40) != 0) {
|
|
if(complain)
|
|
ErrorF("Neither linear nor windowed framebuffer available in this mode\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
if(!(mode->ModeAttributes & 1)) {
|
|
if(complain)
|
|
ErrorF("Mode not supported on this hardware\n");
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static Bool
|
|
vesaModeSupported (VesaCardPrivPtr priv, VesaModePtr mode, Bool complain)
|
|
{
|
|
if (!priv->vbeInfo && mode->vbe) {
|
|
if (complain)
|
|
ErrorF("VBE bios mode not usable.\n");
|
|
return FALSE;
|
|
}
|
|
return vesaModeSupportable (mode, complain);
|
|
}
|
|
|
|
void
|
|
vesaReportMode (VesaModePtr mode)
|
|
{
|
|
int supported = (mode->ModeAttributes&MODE_SUPPORTED)?1:0;
|
|
int colour = (mode->ModeAttributes&MODE_COLOUR)?1:0;
|
|
int graphics = (mode->ModeAttributes&MODE_GRAPHICS)?1:0;
|
|
int vga_compatible = !((mode->ModeAttributes&MODE_VGA)?1:0);
|
|
int linear_fb = (mode->ModeAttributes&MODE_LINEAR)?1:0;
|
|
|
|
ErrorF("0x%04X: %dx%dx%d%s%s",
|
|
(unsigned)mode->mode,
|
|
(int)mode->XResolution, (int)mode->YResolution,
|
|
vesaDepth (mode),
|
|
colour?"":" (monochrome)",
|
|
graphics?"":" (graphics)",
|
|
vga_compatible?"":" (vga compatible)",
|
|
linear_fb?"":" (linear frame buffer)");
|
|
switch(mode->MemoryModel) {
|
|
case MEMORY_TEXT:
|
|
ErrorF(" text mode");
|
|
break;
|
|
case MEMORY_CGA:
|
|
ErrorF(" CGA graphics");
|
|
break;
|
|
case MEMORY_HERCULES:
|
|
ErrorF(" Hercules graphics");
|
|
break;
|
|
case MEMORY_PLANAR:
|
|
ErrorF(" Planar (%d planes)", mode->NumberOfPlanes);
|
|
break;
|
|
case MEMORY_PSEUDO:
|
|
ErrorF(" PseudoColor");
|
|
break;
|
|
case MEMORY_NONCHAIN:
|
|
ErrorF(" Non-chain 4, 256 colour");
|
|
break;
|
|
case MEMORY_DIRECT:
|
|
if(mode->DirectColorModeInfo & MODE_DIRECT)
|
|
ErrorF(" DirectColor");
|
|
else
|
|
ErrorF(" TrueColor");
|
|
ErrorF(" [%d:%d:%d:%d]",
|
|
mode->RedMaskSize, mode->GreenMaskSize, mode->BlueMaskSize,
|
|
mode->RsvdMaskSize);
|
|
if(mode->DirectColorModeInfo & 2)
|
|
ErrorF(" (reserved bits are reserved)");
|
|
break;
|
|
case MEMORY_YUV:
|
|
ErrorF("YUV");
|
|
break;
|
|
default:
|
|
ErrorF("unknown MemoryModel 0x%X ", mode->MemoryModel);
|
|
}
|
|
if(!supported)
|
|
ErrorF(" (unsupported)");
|
|
else if(!linear_fb)
|
|
ErrorF(" (no linear framebuffer)");
|
|
ErrorF("\n");
|
|
}
|
|
|
|
VesaModePtr
|
|
vesaGetModes (Vm86InfoPtr vi, int *ret_nmode)
|
|
{
|
|
VesaModePtr modes;
|
|
int nmode, nmodeVbe, nmodeVga;
|
|
int code;
|
|
|
|
code = VgaGetNmode (vi);
|
|
if (code <= 0)
|
|
nmodeVga = 0;
|
|
else
|
|
nmodeVga = code;
|
|
|
|
code = VbeGetNmode (vi);
|
|
if (code <= 0)
|
|
nmodeVbe = 0;
|
|
else
|
|
nmodeVbe = code;
|
|
|
|
nmode = nmodeVga + nmodeVbe;
|
|
if (nmode <= 0)
|
|
return 0;
|
|
|
|
modes = xalloc (nmode * sizeof (VesaModeRec));
|
|
|
|
memset (modes, '\0', nmode * sizeof (VesaModeRec));
|
|
|
|
if (nmodeVga)
|
|
{
|
|
code = VgaGetModes (vi, modes, nmodeVga);
|
|
if (code <= 0)
|
|
nmodeVga = 0;
|
|
else
|
|
nmodeVga = code;
|
|
}
|
|
|
|
if (nmodeVbe)
|
|
{
|
|
code = VbeGetModes (vi, modes + nmodeVga, nmodeVbe);
|
|
if (code <= 0)
|
|
nmodeVbe = 0;
|
|
else
|
|
nmodeVbe = code;
|
|
}
|
|
|
|
nmode = nmodeVga + nmodeVbe;
|
|
|
|
if (nmode == 0)
|
|
{
|
|
xfree (modes);
|
|
modes = 0;
|
|
return 0;
|
|
}
|
|
*ret_nmode = nmode;
|
|
return modes;
|
|
}
|
|
|
|
Bool
|
|
vesaInitialize (KdCardInfo *card, VesaCardPrivPtr priv)
|
|
{
|
|
priv->vi = Vm86Setup(vesa_map_holes);
|
|
if(!priv->vi)
|
|
goto fail;
|
|
|
|
if (vesa_boot)
|
|
VbeBoot (priv->vi);
|
|
|
|
priv->modes = vesaGetModes (priv->vi, &priv->nmode);
|
|
|
|
if (!priv->modes)
|
|
goto fail;
|
|
|
|
priv->vbeInfo = VbeInit (priv->vi);
|
|
|
|
card->driver = priv;
|
|
|
|
return TRUE;
|
|
|
|
fail:
|
|
if(priv->vi)
|
|
Vm86Cleanup(priv->vi);
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
vesaListModes (void)
|
|
{
|
|
Vm86InfoPtr vi;
|
|
VesaModePtr modes;
|
|
int nmode;
|
|
int n;
|
|
|
|
vi = Vm86Setup (vesa_map_holes);
|
|
if (!vi)
|
|
{
|
|
ErrorF ("Can't setup vm86\n");
|
|
}
|
|
else
|
|
{
|
|
modes = vesaGetModes (vi, &nmode);
|
|
if (!modes)
|
|
{
|
|
ErrorF ("No modes available\n");
|
|
}
|
|
else
|
|
{
|
|
VbeReportInfo (vi);
|
|
for (n = 0; n < nmode; n++)
|
|
{
|
|
if (vesa_force_mode || vesaModeSupportable (modes+n, 0))
|
|
vesaReportMode (modes+n);
|
|
}
|
|
xfree (modes);
|
|
}
|
|
Vm86Cleanup (vi);
|
|
}
|
|
}
|
|
|
|
void
|
|
vesaTestMode (void)
|
|
{
|
|
Vm86InfoPtr vi;
|
|
VesaModePtr modes;
|
|
VesaModePtr mode;
|
|
VbeInfoPtr vbeInfo;
|
|
int nmode;
|
|
int n;
|
|
|
|
vi = Vm86Setup (vesa_map_holes);
|
|
if (!vi)
|
|
{
|
|
ErrorF ("Can't setup vm86\n");
|
|
return;
|
|
}
|
|
modes = vesaGetModes (vi, &nmode);
|
|
if (!modes)
|
|
{
|
|
ErrorF ("No modes available\n");
|
|
return;
|
|
}
|
|
VbeReportInfo (vi);
|
|
vbeInfo = VbeInit (vi);
|
|
for (n = 0; n < nmode; n++)
|
|
{
|
|
if (modes[n].mode == vesa_video_mode)
|
|
break;
|
|
}
|
|
if (n == nmode)
|
|
{
|
|
ErrorF ("no mode specified\n");
|
|
return;
|
|
}
|
|
mode = &modes[n];
|
|
if (mode->vbe)
|
|
{
|
|
ErrorF ("Enable VBE mode 0x%x\n", mode->mode);
|
|
VbeSetMode(vi, vbeInfo, mode->mode, FALSE, FALSE);
|
|
}
|
|
else
|
|
{
|
|
ErrorF ("Enable BIOS mode 0x%x\n", mode->mode);
|
|
VgaSetMode (vi, mode->mode);
|
|
}
|
|
sleep (2);
|
|
ErrorF ("Restore BIOS mode 0x%x\n", 3);
|
|
VgaSetMode (vi, 3);
|
|
xfree (modes);
|
|
Vm86Cleanup (vi);
|
|
}
|
|
|
|
Bool
|
|
vesaCardInit(KdCardInfo *card)
|
|
{
|
|
VesaCardPrivPtr priv;
|
|
|
|
priv = xalloc(sizeof(VesaCardPrivRec));
|
|
if(!priv)
|
|
return FALSE;
|
|
|
|
if (!vesaInitialize (card, priv))
|
|
{
|
|
xfree(priv);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
vesaDepth (VesaModePtr mode)
|
|
{
|
|
if (mode->MemoryModel == MEMORY_DIRECT)
|
|
return (mode->RedMaskSize +
|
|
mode->GreenMaskSize +
|
|
mode->BlueMaskSize);
|
|
else
|
|
return mode->BitsPerPixel;
|
|
}
|
|
|
|
Bool
|
|
vesaModeGood (KdScreenInfo *screen,
|
|
VesaModePtr a)
|
|
{
|
|
if (vesaWidth(screen,a) <= screen->width &&
|
|
vesaHeight(screen,a) <= screen->height &&
|
|
vesaDepth (a) >= screen->fb[0].depth)
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
#define vabs(a) ((a) >= 0 ? (a) : -(a))
|
|
|
|
int
|
|
vesaSizeError (KdScreenInfo *screen,
|
|
VesaModePtr a)
|
|
{
|
|
int xdist, ydist;
|
|
xdist = vabs (screen->width - vesaWidth(screen,a));
|
|
ydist = vabs (screen->height - vesaHeight(screen,a));
|
|
return xdist * xdist + ydist * ydist;
|
|
}
|
|
|
|
Bool
|
|
vesaModeBetter (KdScreenInfo *screen,
|
|
VesaModePtr a,
|
|
VesaModePtr b)
|
|
{
|
|
int aerr, berr;
|
|
|
|
if (vesaModeGood (screen, a))
|
|
{
|
|
if (!vesaModeGood (screen, b))
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (vesaModeGood (screen, b))
|
|
return FALSE;
|
|
}
|
|
aerr = vesaSizeError (screen, a);
|
|
berr = vesaSizeError (screen, b);
|
|
if (aerr < berr)
|
|
return TRUE;
|
|
if (berr < aerr)
|
|
return FALSE;
|
|
if (vabs (screen->fb[0].depth - vesaDepth (a)) <
|
|
vabs (screen->fb[0].depth - vesaDepth (b)))
|
|
return TRUE;
|
|
if (a->BitsPerPixel == 32 && b->BitsPerPixel == 24)
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
VesaModePtr
|
|
vesaSelectMode (KdScreenInfo *screen)
|
|
{
|
|
VesaCardPrivPtr priv = screen->card->driver;
|
|
int i, best;
|
|
|
|
if (vesa_video_mode)
|
|
{
|
|
for (best = 0; best < priv->nmode; best++)
|
|
if (priv->modes[best].mode == vesa_video_mode &&
|
|
(vesaModeSupported (priv, &priv->modes[best], FALSE) ||
|
|
vesa_force_mode))
|
|
return &priv->modes[best];
|
|
}
|
|
for (best = 0; best < priv->nmode; best++)
|
|
{
|
|
if (vesaModeSupported (priv, &priv->modes[best], FALSE))
|
|
break;
|
|
}
|
|
if (best == priv->nmode)
|
|
return 0;
|
|
for (i = best + 1; i < priv->nmode; i++)
|
|
if (vesaModeSupported (priv, &priv->modes[i], FALSE) &&
|
|
vesaModeBetter (screen, &priv->modes[i],
|
|
&priv->modes[best]))
|
|
best = i;
|
|
return &priv->modes[best];
|
|
}
|
|
|
|
Bool
|
|
vesaScreenInitialize (KdScreenInfo *screen, VesaScreenPrivPtr pscr)
|
|
{
|
|
VesaModePtr mode;
|
|
|
|
screen->driver = pscr;
|
|
|
|
if (!screen->width || !screen->height)
|
|
{
|
|
screen->width = 640;
|
|
screen->height = 480;
|
|
}
|
|
if (!screen->fb[0].depth)
|
|
screen->fb[0].depth = 4;
|
|
|
|
if (vesa_verbose)
|
|
ErrorF ("Mode requested %dx%dx%d\n",
|
|
screen->width, screen->height, screen->fb[0].depth);
|
|
|
|
mode = vesaSelectMode (screen);
|
|
|
|
if (!mode)
|
|
{
|
|
if (vesa_verbose)
|
|
ErrorF ("No selectable mode\n");
|
|
return FALSE;
|
|
}
|
|
pscr->mode = *mode;
|
|
|
|
if (vesa_verbose)
|
|
{
|
|
ErrorF ("\t");
|
|
vesaReportMode (&pscr->mode);
|
|
}
|
|
|
|
pscr->randr = screen->randr;
|
|
pscr->shadow = vesa_shadow;
|
|
pscr->origDepth = screen->fb[0].depth;
|
|
/*
|
|
* Compute visual support for the selected depth
|
|
*/
|
|
|
|
switch (pscr->mode.MemoryModel) {
|
|
case MEMORY_DIRECT:
|
|
/* TrueColor or DirectColor */
|
|
screen->fb[0].visuals = (1 << TrueColor);
|
|
screen->fb[0].redMask =
|
|
FbStipMask(pscr->mode.RedFieldPosition, pscr->mode.RedMaskSize);
|
|
screen->fb[0].greenMask =
|
|
FbStipMask(pscr->mode.GreenFieldPosition, pscr->mode.GreenMaskSize);
|
|
screen->fb[0].blueMask =
|
|
FbStipMask(pscr->mode.BlueFieldPosition, pscr->mode.BlueMaskSize);
|
|
break;
|
|
case MEMORY_PSEUDO:
|
|
/* PseudoColor */
|
|
screen->fb[0].visuals = ((1 << StaticGray) |
|
|
(1 << GrayScale) |
|
|
(1 << StaticColor) |
|
|
(1 << PseudoColor) |
|
|
(1 << TrueColor) |
|
|
(1 << DirectColor));
|
|
screen->fb[0].blueMask = 0x00;
|
|
screen->fb[0].greenMask = 0x00;
|
|
screen->fb[0].redMask = 0x00;
|
|
break;
|
|
case MEMORY_PLANAR:
|
|
/* 4 plane planar */
|
|
if (pscr->mode.ModeAttributes & MODE_COLOUR)
|
|
screen->fb[0].visuals = (1 << StaticColor);
|
|
else
|
|
screen->fb[0].visuals = (1 << StaticGray);
|
|
screen->fb[0].blueMask = 0x00;
|
|
screen->fb[0].greenMask = 0x00;
|
|
screen->fb[0].redMask = 0x00;
|
|
break;
|
|
default:
|
|
ErrorF("Unsupported VESA MemoryModel 0x%02X\n",
|
|
pscr->mode.MemoryModel);
|
|
return FALSE;
|
|
}
|
|
screen->rate = 72;
|
|
|
|
if (!vesaComputeFramebufferMapping (screen))
|
|
return FALSE;
|
|
if (!vesaMapFramebuffer (screen))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
vesaScreenInit(KdScreenInfo *screen)
|
|
{
|
|
VesaScreenPrivPtr pscr;
|
|
|
|
pscr = xcalloc (1, sizeof (VesaScreenPrivRec));
|
|
if (!pscr)
|
|
return FALSE;
|
|
if (!vesaScreenInitialize (screen, pscr))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
void *
|
|
vesaSetWindowPlanar(ScreenPtr pScreen,
|
|
CARD32 row,
|
|
CARD32 offset,
|
|
int mode,
|
|
CARD32 *size)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
static int plane;
|
|
int winSize;
|
|
void *base;
|
|
|
|
plane = offset & 3;
|
|
VgaSetWritePlaneMask (priv->vi, (1 << plane));
|
|
offset = offset >> 2;
|
|
if (pscr->mode.vbe)
|
|
{
|
|
base = VbeSetWindow (priv->vi,
|
|
priv->vbeInfo,
|
|
pscr->mode.BytesPerScanLine * row + offset,
|
|
mode,
|
|
&winSize);
|
|
}
|
|
else
|
|
{
|
|
base = VgaSetWindow (priv->vi,
|
|
pscr->mode.mode,
|
|
pscr->mode.BytesPerScanLine * row + offset,
|
|
mode,
|
|
&winSize);
|
|
}
|
|
*size = (CARD32) winSize;
|
|
return base;
|
|
}
|
|
|
|
void *
|
|
vesaSetWindowLinear (ScreenPtr pScreen,
|
|
CARD32 row,
|
|
CARD32 offset,
|
|
int mode,
|
|
CARD32 *size)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
|
|
*size = pscr->mode.BytesPerScanLine;
|
|
return (CARD8 *) pscr->fb + row * pscr->mode.BytesPerScanLine + offset;
|
|
}
|
|
|
|
void *
|
|
vesaSetWindowWindowed (ScreenPtr pScreen,
|
|
CARD32 row,
|
|
CARD32 offset,
|
|
int mode,
|
|
CARD32 *size)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
int winSize;
|
|
void *base;
|
|
|
|
if (pscr->mode.vbe)
|
|
{
|
|
base = VbeSetWindow (priv->vi,
|
|
priv->vbeInfo,
|
|
pscr->mode.BytesPerScanLine * row + offset,
|
|
mode,
|
|
&winSize);
|
|
}
|
|
else
|
|
{
|
|
base = VgaSetWindow (priv->vi,
|
|
pscr->mode.mode,
|
|
pscr->mode.BytesPerScanLine * row + offset,
|
|
mode,
|
|
&winSize);
|
|
}
|
|
*size = (CARD32) winSize;
|
|
return base;
|
|
}
|
|
|
|
void *
|
|
vesaWindowPlanar (ScreenPtr pScreen,
|
|
CARD32 row,
|
|
CARD32 offset,
|
|
int mode,
|
|
CARD32 *size,
|
|
void *closure)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
|
|
if (!pScreenPriv->enabled)
|
|
return 0;
|
|
return vesaSetWindowPlanar (pScreen, row, offset, mode, size);
|
|
}
|
|
|
|
void *
|
|
vesaWindowLinear (ScreenPtr pScreen,
|
|
CARD32 row,
|
|
CARD32 offset,
|
|
int mode,
|
|
CARD32 *size,
|
|
void *closure)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
|
|
if (!pScreenPriv->enabled)
|
|
return 0;
|
|
return vesaSetWindowLinear (pScreen, row, offset, mode, size);
|
|
}
|
|
|
|
void *
|
|
vesaWindowWindowed (ScreenPtr pScreen,
|
|
CARD32 row,
|
|
CARD32 offset,
|
|
int mode,
|
|
CARD32 *size,
|
|
void *closure)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
|
|
if (!pScreenPriv->enabled)
|
|
return 0;
|
|
return vesaSetWindowWindowed (pScreen, row, offset, mode, size);
|
|
}
|
|
|
|
#define vesaInvertBits32(v) { \
|
|
v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555); \
|
|
v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333); \
|
|
v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f); \
|
|
}
|
|
|
|
void *
|
|
vesaWindowCga (ScreenPtr pScreen,
|
|
CARD32 row,
|
|
CARD32 offset,
|
|
int mode,
|
|
CARD32 *size,
|
|
void *closure)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
int line;
|
|
|
|
if (!pScreenPriv->enabled)
|
|
return 0;
|
|
*size = pscr->mode.BytesPerScanLine;
|
|
line = ((row & 1) << 13) + (row >> 1) * pscr->mode.BytesPerScanLine;
|
|
return (CARD8 *) pscr->fb + line + offset;
|
|
}
|
|
|
|
void
|
|
vesaUpdateMono (ScreenPtr pScreen,
|
|
shadowBufPtr pBuf)
|
|
{
|
|
RegionPtr damage = shadowDamage(pBuf);
|
|
PixmapPtr pShadow = pBuf->pPixmap;
|
|
int nbox = REGION_NUM_RECTS (damage);
|
|
BoxPtr pbox = REGION_RECTS (damage);
|
|
FbBits *shaBase, *shaLine, *sha;
|
|
FbStride shaStride;
|
|
int scrBase, scrLine, scr;
|
|
int shaBpp;
|
|
int shaXoff, shaYoff; /* XXX assumed to be zero */
|
|
int x, y, w, h, width;
|
|
int i;
|
|
FbBits *winBase = 0, *win;
|
|
CARD32 winSize;
|
|
FbBits bits;
|
|
|
|
fbGetDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff);
|
|
while (nbox--)
|
|
{
|
|
x = pbox->x1 * shaBpp;
|
|
y = pbox->y1;
|
|
w = (pbox->x2 - pbox->x1) * shaBpp;
|
|
h = pbox->y2 - pbox->y1;
|
|
|
|
scrLine = (x >> FB_SHIFT);
|
|
shaLine = shaBase + y * shaStride + (x >> FB_SHIFT);
|
|
|
|
x &= FB_MASK;
|
|
w = (w + x + FB_MASK) >> FB_SHIFT;
|
|
|
|
while (h--)
|
|
{
|
|
winSize = 0;
|
|
scrBase = 0;
|
|
width = w;
|
|
scr = scrLine;
|
|
sha = shaLine;
|
|
while (width) {
|
|
/* how much remains in this window */
|
|
i = scrBase + winSize - scr;
|
|
if (i <= 0 || scr < scrBase)
|
|
{
|
|
winBase = (FbBits *) (*pBuf->window) (pScreen,
|
|
y,
|
|
scr * sizeof (FbBits),
|
|
SHADOW_WINDOW_WRITE,
|
|
&winSize,
|
|
pBuf->closure);
|
|
if(!winBase)
|
|
return;
|
|
scrBase = scr;
|
|
winSize /= sizeof (FbBits);
|
|
i = winSize;
|
|
}
|
|
win = winBase + (scr - scrBase);
|
|
if (i > width)
|
|
i = width;
|
|
width -= i;
|
|
scr += i;
|
|
while (i--)
|
|
{
|
|
bits = *sha++;
|
|
vesaInvertBits32(bits);
|
|
*win++ = bits;
|
|
}
|
|
}
|
|
shaLine += shaStride;
|
|
y++;
|
|
}
|
|
pbox++;
|
|
}
|
|
}
|
|
|
|
static const CARD16 vga16Colors[16][3] = {
|
|
{ 0, 0, 0, }, /* 0 */
|
|
{ 0, 0, 0xAA,}, /* 1 */
|
|
{ 0, 0xAA,0, }, /* 2 */
|
|
{ 0, 0xAA,0xAA,}, /* 3 */
|
|
{ 0xAA,0, 0, }, /* 4 */
|
|
{ 0xAA,0, 0xAA,}, /* 5 */
|
|
{ 0xAA,0x55,0, }, /* 6 */
|
|
{ 0xAA,0xAA,0xAA,}, /* 7 */
|
|
{ 0x55,0x55,0x55,}, /* 8 */
|
|
{ 0x55,0x55,0xFF,}, /* 9 */
|
|
{ 0x55,0xFF,0x55,}, /* 10 */
|
|
{ 0x55,0xFF,0xFF,}, /* 11 */
|
|
{ 0xFF,0x55,0x55,}, /* 12 */
|
|
{ 0xFF,0x55,0xFF,}, /* 13 */
|
|
{ 0xFF,0xFF,0x55,}, /* 14 */
|
|
{ 0xFF,0xFF,0xFF,}, /* 15 */
|
|
};
|
|
|
|
Bool
|
|
vesaCreateColormap16 (ColormapPtr pmap)
|
|
{
|
|
int i, j;
|
|
|
|
if (pmap->pVisual->ColormapEntries == 16)
|
|
for (i = 0; i < pmap->pVisual->ColormapEntries; i++)
|
|
{
|
|
j = i & 0xf;
|
|
pmap->red[i].co.local.red = (vga16Colors[j][0]<<8)|vga16Colors[j][0];
|
|
pmap->red[i].co.local.green = (vga16Colors[j][1]<<8)|vga16Colors[j][1];
|
|
pmap->red[i].co.local.blue = (vga16Colors[j][2]<<8)|vga16Colors[j][2];
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
vesaSetScreenSizes (ScreenPtr pScreen)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
KdScreenInfo *screen = pScreenPriv->screen;
|
|
VesaScreenPrivPtr pscr = screen->driver;
|
|
|
|
if (pscr->randr & (RR_Rotate_0|RR_Rotate_180))
|
|
{
|
|
pScreen->width = pscr->mode.XResolution;
|
|
pScreen->height = pscr->mode.YResolution;
|
|
pScreen->mmWidth = screen->width_mm;
|
|
pScreen->mmHeight = screen->height_mm;
|
|
}
|
|
else
|
|
{
|
|
pScreen->width = pscr->mode.YResolution;
|
|
pScreen->height = pscr->mode.XResolution;
|
|
pScreen->mmWidth = screen->height_mm;
|
|
pScreen->mmHeight = screen->width_mm;
|
|
}
|
|
}
|
|
|
|
Bool
|
|
vesaSetShadow (ScreenPtr pScreen)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
ShadowUpdateProc update;
|
|
ShadowWindowProc window = 0;
|
|
|
|
if (pscr->randr != RR_Rotate_0)
|
|
update = shadowUpdateRotatePacked;
|
|
else
|
|
update = shadowUpdatePacked;
|
|
switch (pscr->mapping) {
|
|
case VESA_LINEAR:
|
|
window = vesaWindowLinear;
|
|
break;
|
|
case VESA_WINDOWED:
|
|
window = vesaWindowWindowed;
|
|
break;
|
|
case VESA_PLANAR:
|
|
if (pScreenPriv->screen->fb[0].bitsPerPixel == 8)
|
|
update = shadowUpdatePlanar4x8;
|
|
else
|
|
update = shadowUpdatePlanar4;
|
|
window = vesaWindowPlanar;
|
|
break;
|
|
case VESA_MONO:
|
|
update = vesaUpdateMono;
|
|
if (pscr->mode.mode < 8)
|
|
window = vesaWindowCga;
|
|
else
|
|
window = vesaWindowLinear;
|
|
break;
|
|
}
|
|
|
|
return KdShadowSet (pScreen, pscr->randr, update, window);
|
|
}
|
|
|
|
static Bool
|
|
vesaComputeFramebufferMapping (KdScreenInfo *screen)
|
|
{
|
|
VesaScreenPrivPtr pscr = screen->driver;
|
|
int depth, bpp, fbbpp;
|
|
Pixel allbits;
|
|
KdPointerMatrix m;
|
|
|
|
if (vesa_linear_fb)
|
|
{
|
|
pscr->mapping = VESA_LINEAR;
|
|
pscr->shadow = FALSE;
|
|
}
|
|
else
|
|
{
|
|
pscr->mapping = VESA_WINDOWED;
|
|
pscr->shadow = TRUE;
|
|
}
|
|
|
|
depth = vesaDepth (&pscr->mode);
|
|
bpp = pscr->mode.BitsPerPixel;
|
|
|
|
if (bpp > 24)
|
|
bpp = 32;
|
|
else if (bpp > 16)
|
|
bpp = 24;
|
|
else if (bpp > 8)
|
|
bpp = 16;
|
|
else if (bpp > 4)
|
|
bpp = 8;
|
|
else if (bpp > 1)
|
|
bpp = 4;
|
|
else
|
|
bpp = 1;
|
|
fbbpp = bpp;
|
|
|
|
switch (pscr->mode.MemoryModel) {
|
|
case MEMORY_DIRECT:
|
|
allbits = (screen->fb[0].redMask |
|
|
screen->fb[0].greenMask |
|
|
screen->fb[0].blueMask);
|
|
depth = 32;
|
|
while (depth && !(allbits & (1 << (depth - 1))))
|
|
depth--;
|
|
if (vesa_verbose)
|
|
ErrorF ("\tTrue Color %d/%d red 0x%x green 0x%x blue 0x%x\n",
|
|
bpp, depth,
|
|
screen->fb[0].redMask,
|
|
screen->fb[0].greenMask,
|
|
screen->fb[0].blueMask);
|
|
break;
|
|
case MEMORY_PSEUDO:
|
|
if (vesa_verbose)
|
|
ErrorF ("\tPseudo Color bpp %d depth %d\n",
|
|
bpp, depth);
|
|
break;
|
|
case MEMORY_PLANAR:
|
|
if (bpp == 4)
|
|
{
|
|
bpp = screen->fb[0].bitsPerPixel;
|
|
if (bpp != 8)
|
|
bpp = 4;
|
|
depth = bpp;
|
|
}
|
|
if (bpp == 1)
|
|
{
|
|
pscr->mapping = VESA_MONO;
|
|
if (vesa_verbose)
|
|
ErrorF ("\tMonochrome\n");
|
|
}
|
|
else
|
|
{
|
|
pscr->mapping = VESA_PLANAR;
|
|
if (vesa_verbose)
|
|
ErrorF ("\tStatic color bpp %d depth %d\n",
|
|
bpp, depth);
|
|
}
|
|
pscr->randr = RR_Rotate_0;
|
|
pscr->shadow = TRUE;
|
|
break;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
switch (fbbpp) {
|
|
case 8:
|
|
case 16:
|
|
case 32:
|
|
break;
|
|
default:
|
|
pscr->randr = RR_Rotate_0;
|
|
break;
|
|
}
|
|
|
|
if (pscr->randr != RR_Rotate_0)
|
|
pscr->shadow = TRUE;
|
|
|
|
if (vesa_shadow)
|
|
pscr->shadow = vesa_shadow;
|
|
|
|
if (pscr->mapping == VESA_LINEAR && !(pscr->mode.ModeAttributes & MODE_LINEAR))
|
|
{
|
|
pscr->mapping = VESA_WINDOWED;
|
|
pscr->shadow = TRUE;
|
|
}
|
|
KdComputePointerMatrix (&m, pscr->randr,
|
|
pscr->mode.XResolution, pscr->mode.YResolution);
|
|
|
|
KdSetPointerMatrix (&m);
|
|
|
|
screen->width = pscr->mode.XResolution;
|
|
screen->height = pscr->mode.YResolution;
|
|
screen->fb[0].depth = depth;
|
|
screen->fb[0].bitsPerPixel = bpp;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static Bool
|
|
vesaMapFramebuffer (KdScreenInfo *screen)
|
|
{
|
|
VesaCardPrivPtr priv = screen->card->driver;
|
|
VesaScreenPrivPtr pscr = screen->driver;
|
|
|
|
if (pscr->mapped)
|
|
return TRUE;
|
|
switch (pscr->mapping) {
|
|
case VESA_MONO:
|
|
case VESA_LINEAR:
|
|
if (pscr->mode.vbe)
|
|
pscr->fb = VbeMapFramebuffer(priv->vi, priv->vbeInfo,
|
|
pscr->mode.mode,
|
|
&pscr->fb_size,
|
|
&pscr->fb_phys);
|
|
else
|
|
pscr->fb = VgaMapFramebuffer (priv->vi,
|
|
pscr->mode.mode,
|
|
&pscr->fb_size,
|
|
&pscr->fb_phys);
|
|
if (!pscr->fb)
|
|
return FALSE;
|
|
break;
|
|
case VESA_WINDOWED:
|
|
pscr->fb = NULL;
|
|
break;
|
|
case VESA_PLANAR:
|
|
pscr->fb = NULL;
|
|
break;
|
|
}
|
|
|
|
screen->memory_base = pscr->fb;
|
|
screen->memory_size = pscr->fb_size;
|
|
|
|
if (pscr->shadow)
|
|
{
|
|
if (!KdShadowFbAlloc (screen, 0,
|
|
pscr->randr & (RR_Rotate_90|RR_Rotate_270)))
|
|
return FALSE;
|
|
screen->off_screen_base = screen->memory_size;
|
|
}
|
|
else
|
|
{
|
|
screen->fb[0].frameBuffer = (CARD8 *) (pscr->fb);
|
|
screen->fb[0].byteStride = pscr->mode.BytesPerScanLine;
|
|
screen->fb[0].pixelStride = ((pscr->mode.BytesPerScanLine * 8) /
|
|
screen->fb[0].bitsPerPixel);
|
|
screen->off_screen_base = screen->fb[0].byteStride * screen->height;
|
|
}
|
|
pscr->mapped = TRUE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
vesaUnmapFramebuffer (KdScreenInfo *screen)
|
|
{
|
|
VesaCardPrivPtr priv = screen->card->driver;
|
|
VesaScreenPrivPtr pscr = screen->driver;
|
|
|
|
if (!pscr->mapped)
|
|
return;
|
|
|
|
pscr->mapped = FALSE;
|
|
KdShadowFbFree (screen, 0);
|
|
if (pscr->fb)
|
|
{
|
|
if (pscr->mode.vbe)
|
|
VbeUnmapFramebuffer(priv->vi, priv->vbeInfo, pscr->mode.mode, pscr->fb);
|
|
else
|
|
VgaUnmapFramebuffer (priv->vi);
|
|
pscr->fb = 0;
|
|
}
|
|
}
|
|
|
|
#ifdef RANDR
|
|
Bool
|
|
vesaRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaModePtr modes, mode;
|
|
KdScreenInfo *screen = pScreenPriv->screen;
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
int nmode;
|
|
int n;
|
|
RRScreenSizePtr pSize;
|
|
|
|
*rotations = (RR_Rotate_0|RR_Rotate_90|RR_Rotate_180|RR_Rotate_270|
|
|
RR_Reflect_X|RR_Reflect_Y);
|
|
/*
|
|
* Get mode information from BIOS -- every time in case
|
|
* something changes, like an external monitor is plugged in
|
|
*/
|
|
modes = vesaGetModes (priv->vi, &nmode);
|
|
if (!modes)
|
|
return FALSE;
|
|
if (priv->modes)
|
|
xfree (priv->modes);
|
|
priv->modes = modes;
|
|
priv->nmode = nmode;
|
|
for (n = 0; n < nmode; n++)
|
|
{
|
|
mode = &priv->modes[n];
|
|
if (vesaModeSupported (priv, mode, FALSE))
|
|
{
|
|
/*
|
|
* XXX limit reported modes to those matching the current
|
|
* format
|
|
*/
|
|
if (mode->NumberOfPlanes == pscr->mode.NumberOfPlanes &&
|
|
mode->BitsPerPixel == pscr->mode.BitsPerPixel &&
|
|
mode->MemoryModel == pscr->mode.MemoryModel &&
|
|
mode->RedMaskSize == pscr->mode.RedMaskSize &&
|
|
mode->RedFieldPosition == pscr->mode.RedFieldPosition &&
|
|
mode->GreenMaskSize == pscr->mode.GreenMaskSize &&
|
|
mode->GreenFieldPosition == pscr->mode.GreenFieldPosition &&
|
|
mode->BlueMaskSize == pscr->mode.BlueMaskSize &&
|
|
mode->BlueFieldPosition == pscr->mode.BlueFieldPosition)
|
|
{
|
|
int width, height, width_mm, height_mm;
|
|
if (screen->randr & (RR_Rotate_0|RR_Rotate_180))
|
|
{
|
|
width = mode->XResolution;
|
|
height = mode->YResolution;
|
|
width_mm = screen->width_mm;
|
|
height_mm = screen->height_mm;
|
|
}
|
|
else
|
|
{
|
|
width = mode->YResolution;
|
|
height = mode->XResolution;
|
|
width_mm = screen->height_mm;
|
|
height_mm = screen->width_mm;
|
|
}
|
|
pSize = RRRegisterSize (pScreen,
|
|
width, height,
|
|
width_mm, height_mm);
|
|
if (mode->XResolution == screen->width &&
|
|
mode->YResolution == screen->height)
|
|
{
|
|
int randr = KdSubRotation (pscr->randr, screen->randr);
|
|
RRSetCurrentConfig (pScreen, randr, 0, pSize);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
vesaRandRSetConfig (ScreenPtr pScreen,
|
|
Rotation randr,
|
|
int rate,
|
|
RRScreenSizePtr pSize)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaModePtr mode = 0;
|
|
KdScreenInfo *screen = pScreenPriv->screen;
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
int n;
|
|
Bool wasEnabled = pScreenPriv->enabled;
|
|
Bool ret = FALSE;
|
|
VesaScreenPrivRec oldscr;
|
|
int oldwidth;
|
|
int oldheight;
|
|
int oldmmwidth;
|
|
int oldmmheight;
|
|
int newwidth, newheight;
|
|
|
|
if (screen->randr & (RR_Rotate_0|RR_Rotate_180))
|
|
{
|
|
newwidth = pSize->width;
|
|
newheight = pSize->height;
|
|
}
|
|
else
|
|
{
|
|
newwidth = pSize->height;
|
|
newheight = pSize->width;
|
|
}
|
|
for (n = 0; n < priv->nmode; n++)
|
|
{
|
|
mode = &priv->modes[n];
|
|
if (vesaModeSupported (priv, mode, FALSE))
|
|
{
|
|
/*
|
|
* XXX all we have to match is the size
|
|
*/
|
|
if (mode->XResolution == newwidth &&
|
|
mode->YResolution == newheight &&
|
|
mode->NumberOfPlanes == pscr->mode.NumberOfPlanes &&
|
|
mode->BitsPerPixel == pscr->mode.BitsPerPixel &&
|
|
mode->RedMaskSize == pscr->mode.RedMaskSize &&
|
|
mode->RedFieldPosition == pscr->mode.RedFieldPosition &&
|
|
mode->GreenMaskSize == pscr->mode.GreenMaskSize &&
|
|
mode->GreenFieldPosition == pscr->mode.GreenFieldPosition &&
|
|
mode->BlueMaskSize == pscr->mode.BlueMaskSize &&
|
|
mode->BlueFieldPosition == pscr->mode.BlueFieldPosition)
|
|
break;
|
|
}
|
|
}
|
|
if (n == priv->nmode)
|
|
goto bail0;
|
|
|
|
if (wasEnabled)
|
|
KdDisableScreen (pScreen);
|
|
|
|
if (mode->mode != pscr->mode.mode)
|
|
{
|
|
ret = vesaSetMode (pScreen, mode);
|
|
if (!ret)
|
|
goto bail1;
|
|
}
|
|
|
|
oldscr = *pscr;
|
|
|
|
oldwidth = screen->width;
|
|
oldheight = screen->height;
|
|
oldmmwidth = pScreen->mmWidth;
|
|
oldmmheight = pScreen->mmHeight;
|
|
|
|
/*
|
|
* Set new configuration
|
|
*/
|
|
|
|
pscr->mode = *mode;
|
|
pscr->randr = KdAddRotation (screen->randr, randr);
|
|
|
|
/*
|
|
* Can't rotate some formats
|
|
*/
|
|
switch (screen->fb[0].bitsPerPixel) {
|
|
case 8:
|
|
case 16:
|
|
case 32:
|
|
break;
|
|
default:
|
|
if (pscr->randr)
|
|
goto bail2;
|
|
break;
|
|
}
|
|
|
|
KdOffscreenSwapOut (screen->pScreen);
|
|
|
|
vesaUnmapFramebuffer (screen);
|
|
|
|
if (!vesaComputeFramebufferMapping (screen))
|
|
goto bail3;
|
|
|
|
if (!vesaMapFramebuffer (screen))
|
|
goto bail3;
|
|
|
|
vesaSetScreenSizes (screen->pScreen);
|
|
|
|
if (!vesaSetShadow (screen->pScreen))
|
|
goto bail4;
|
|
|
|
/*
|
|
* Set frame buffer mapping
|
|
*/
|
|
(*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
|
|
pScreen->width,
|
|
pScreen->height,
|
|
screen->fb[0].depth,
|
|
screen->fb[0].bitsPerPixel,
|
|
screen->fb[0].byteStride,
|
|
screen->fb[0].frameBuffer);
|
|
|
|
/* set the subpixel order */
|
|
KdSetSubpixelOrder (pScreen, pscr->randr);
|
|
|
|
if (wasEnabled)
|
|
KdEnableScreen (pScreen);
|
|
|
|
return TRUE;
|
|
|
|
bail4:
|
|
vesaUnmapFramebuffer (screen);
|
|
*pscr = oldscr;
|
|
(void) vesaComputeFramebufferMapping (screen);
|
|
(void) vesaMapFramebuffer (screen);
|
|
|
|
bail3:
|
|
pScreen->width = oldwidth;
|
|
pScreen->height = oldheight;
|
|
pScreen->mmWidth = oldmmwidth;
|
|
pScreen->mmHeight = oldmmheight;
|
|
|
|
bail2:
|
|
*pscr = oldscr;
|
|
|
|
(void) vesaSetMode (pScreen, &pscr->mode);
|
|
bail1:
|
|
if (wasEnabled)
|
|
KdEnableScreen (pScreen);
|
|
bail0:
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
Bool
|
|
vesaRandRInit (ScreenPtr pScreen)
|
|
{
|
|
rrScrPrivPtr pScrPriv;
|
|
|
|
if (!RRScreenInit (pScreen))
|
|
return FALSE;
|
|
|
|
pScrPriv = rrGetScrPriv(pScreen);
|
|
pScrPriv->rrGetInfo = vesaRandRGetInfo;
|
|
pScrPriv->rrSetConfig = vesaRandRSetConfig;
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
Bool
|
|
vesaInitScreen(ScreenPtr pScreen)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
switch (pscr->mapping) {
|
|
case VESA_PLANAR:
|
|
pScreen->CreateColormap = vesaCreateColormap16;
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
vesaFinishInitScreen (ScreenPtr pScreen)
|
|
{
|
|
if (!shadowSetup (pScreen))
|
|
return FALSE;
|
|
|
|
#ifdef RANDR
|
|
if (!vesaRandRInit (pScreen))
|
|
return FALSE;
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
vesaCreateResources (ScreenPtr pScreen)
|
|
{
|
|
return vesaSetShadow (pScreen);
|
|
}
|
|
|
|
Bool
|
|
vesaSetMode (ScreenPtr pScreen,
|
|
VesaModePtr mode)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
int code;
|
|
|
|
if (mode->vbe)
|
|
{
|
|
if (vesa_verbose)
|
|
ErrorF ("Enable VBE mode 0x%x\n", mode->mode);
|
|
code = VbeSetMode(priv->vi, priv->vbeInfo, mode->mode,
|
|
pscr->mapping == VESA_LINEAR,
|
|
mode->MemoryModel == MEMORY_DIRECT);
|
|
}
|
|
else
|
|
{
|
|
if (vesa_verbose)
|
|
ErrorF ("Enable BIOS mode 0x%x\n", mode->mode);
|
|
code = VgaSetMode (priv->vi, mode->mode);
|
|
}
|
|
|
|
if(code < 0)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
Bool
|
|
vesaEnable(ScreenPtr pScreen)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
KdScreenInfo *screen = pScreenPriv->screen;
|
|
int i;
|
|
CARD32 size;
|
|
char *p;
|
|
Bool was_mapped = pscr->mapped;
|
|
|
|
if (!vesaMapFramebuffer (screen))
|
|
return FALSE;
|
|
|
|
if (!vesaSetMode (pScreen, &pscr->mode))
|
|
return FALSE;
|
|
|
|
switch (pscr->mapping) {
|
|
case VESA_MONO:
|
|
VgaSetWritePlaneMask (priv->vi, 0x1);
|
|
case VESA_LINEAR:
|
|
if (vesa_restore_font)
|
|
memcpy (priv->text, pscr->fb, VESA_TEXT_SAVE);
|
|
break;
|
|
case VESA_WINDOWED:
|
|
if (vesa_restore_font)
|
|
{
|
|
for (i = 0; i < VESA_TEXT_SAVE;)
|
|
{
|
|
p = vesaSetWindowWindowed (pScreen, 0, i, VBE_WINDOW_READ, &size);
|
|
if(!p) {
|
|
ErrorF("Couldn't set window for saving VGA font\n");
|
|
break;
|
|
}
|
|
if(i + size > VESA_TEXT_SAVE)
|
|
size = VESA_TEXT_SAVE - i;
|
|
memcpy(((char*)priv->text) + i, p, size);
|
|
i += size;
|
|
}
|
|
}
|
|
break;
|
|
case VESA_PLANAR:
|
|
if (vesa_restore_font)
|
|
{
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
p = vesaSetWindowPlanar (pScreen, 0, i, VBE_WINDOW_READ, &size);
|
|
memcpy (((char *)priv->text) + i * (VESA_TEXT_SAVE/4), p,
|
|
(VESA_TEXT_SAVE/4));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (!was_mapped)
|
|
{
|
|
(*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
|
|
pScreen->width,
|
|
pScreen->height,
|
|
screen->fb[0].depth,
|
|
screen->fb[0].bitsPerPixel,
|
|
screen->fb[0].byteStride,
|
|
screen->fb[0].frameBuffer);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
#ifndef TOSHIBA_SMM
|
|
|
|
# ifdef linux
|
|
# define TOSHIBA_SMM 1
|
|
# endif
|
|
|
|
# ifndef TOSHIBA_SMM
|
|
# define TOSHIBA_SMM 0
|
|
# endif
|
|
|
|
#endif
|
|
|
|
#if TOSHIBA_SMM
|
|
/*
|
|
* Toshiba laptops use a special interface to operate the backlight
|
|
*/
|
|
#include <sys/ioctl.h>
|
|
#define TOSH_PROC "/proc/toshiba"
|
|
#define TOSH_DEVICE "/dev/toshiba"
|
|
#define TOSH_SMM _IOWR('t', 0x90, SMMRegisters)
|
|
|
|
typedef struct {
|
|
unsigned int eax;
|
|
unsigned int ebx __attribute__ ((packed));
|
|
unsigned int ecx __attribute__ ((packed));
|
|
unsigned int edx __attribute__ ((packed));
|
|
unsigned int esi __attribute__ ((packed));
|
|
unsigned int edi __attribute__ ((packed));
|
|
} SMMRegisters;
|
|
|
|
#define HCI_BACKLIGHT 0x0002
|
|
#define HCI_DISABLE 0x0000
|
|
#define HCI_ENABLE 0x0001
|
|
#define HCI_GET 0xfe00,
|
|
#define HCI_SET 0xff00
|
|
|
|
Bool
|
|
toshibaDPMS (ScreenPtr pScreen, int mode)
|
|
{
|
|
SMMRegisters regs;
|
|
static int fd;
|
|
|
|
if (!fd)
|
|
fd = open (TOSH_DEVICE, 2);
|
|
if (fd < 0)
|
|
return FALSE;
|
|
regs.eax = HCI_SET;
|
|
regs.ebx = HCI_BACKLIGHT;
|
|
regs.ecx = mode ? HCI_DISABLE : HCI_ENABLE;
|
|
if (ioctl (fd, TOSH_SMM, ®s) < 0)
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
#endif /* TOSHIBA_SMM */
|
|
|
|
Bool
|
|
vesaDPMS (ScreenPtr pScreen, int mode)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
|
|
#if TOSHIBA_SMM
|
|
if (toshibaDPMS (pScreen, mode))
|
|
return TRUE;
|
|
#endif
|
|
if (pscr->mode.vbe)
|
|
return VbeDPMS (priv->vi, mode);
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
vesaDisable(ScreenPtr pScreen)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
KdScreenInfo *screen = pScreenPriv->screen;
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
VesaScreenPrivPtr pscr = screen->driver;
|
|
int i=0;
|
|
CARD32 size;
|
|
char *p;
|
|
|
|
if (vesa_restore_font) {
|
|
switch (pscr->mapping) {
|
|
case VESA_LINEAR:
|
|
case VESA_MONO:
|
|
memcpy(pscr->fb, priv->text, VESA_TEXT_SAVE);
|
|
break;
|
|
case VESA_WINDOWED:
|
|
while(i < VESA_TEXT_SAVE) {
|
|
p = vesaSetWindowWindowed (pScreen, 0, i, VBE_WINDOW_WRITE, &size);
|
|
if(!p) {
|
|
ErrorF("Couldn't set window for restoring VGA font\n");
|
|
break;
|
|
}
|
|
if(i + size > VESA_TEXT_SAVE)
|
|
size = VESA_TEXT_SAVE - i;
|
|
memcpy(p, ((char*)priv->text) + i, size);
|
|
i += size;
|
|
}
|
|
break;
|
|
case VESA_PLANAR:
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
p = vesaSetWindowPlanar (pScreen, 0, i, VBE_WINDOW_WRITE, &size);
|
|
memcpy (p,
|
|
((char *)priv->text) + i * (VESA_TEXT_SAVE/4),
|
|
(VESA_TEXT_SAVE/4));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
vesaUnmapFramebuffer (screen);
|
|
}
|
|
|
|
void
|
|
vesaPreserve(KdCardInfo *card)
|
|
{
|
|
VesaCardPrivPtr priv = card->driver;
|
|
|
|
/* The framebuffer might not be valid at this point, so we cannot
|
|
save the VGA fonts now; we do it in vesaEnable. */
|
|
|
|
if (VbeGetMode (priv->vi, &priv->old_vbe_mode) < 0)
|
|
priv->old_vbe_mode = -1;
|
|
|
|
if (VgaGetMode (priv->vi, &priv->old_vga_mode) < 0)
|
|
priv->old_vga_mode = -1;
|
|
|
|
if (vesa_verbose)
|
|
ErrorF ("Previous modes: VBE 0x%x BIOS 0x%x\n",
|
|
priv->old_vbe_mode, priv->old_vga_mode);
|
|
}
|
|
|
|
void
|
|
vesaRestore(KdCardInfo *card)
|
|
{
|
|
VesaCardPrivPtr priv = card->driver;
|
|
int n;
|
|
|
|
if (vesa_force_text)
|
|
{
|
|
if (vesa_verbose)
|
|
ErrorF ("Forcing switch back to mode 3 text\n");
|
|
priv->old_vbe_mode = -1;
|
|
priv->old_vga_mode = 3;
|
|
}
|
|
for (n = 0; n < priv->nmode; n++)
|
|
if (priv->modes[n].vbe && priv->modes[n].mode == (priv->old_vbe_mode&0x3fff))
|
|
break;
|
|
|
|
if (n < priv->nmode)
|
|
{
|
|
if (vesa_verbose)
|
|
ErrorF ("Restore VBE mode 0x%x\n", priv->old_vbe_mode);
|
|
VbeSetMode (priv->vi, priv->vbeInfo, priv->old_vbe_mode, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
if (vesa_verbose)
|
|
ErrorF ("Restore BIOS mode 0x%x\n", priv->old_vga_mode);
|
|
VgaSetMode (priv->vi, priv->old_vga_mode);
|
|
}
|
|
}
|
|
|
|
void
|
|
vesaCardFini(KdCardInfo *card)
|
|
{
|
|
VesaCardPrivPtr priv = card->driver;
|
|
|
|
if (priv->vbeInfo)
|
|
VbeCleanup (priv->vi, priv->vbeInfo);
|
|
if (priv->modes)
|
|
xfree (priv->modes);
|
|
Vm86Cleanup(priv->vi);
|
|
}
|
|
|
|
void
|
|
vesaScreenFini(KdScreenInfo *screen)
|
|
{
|
|
VesaScreenPrivPtr pscr = screen->driver;
|
|
|
|
KdShadowFbFree (screen, 0);
|
|
vesaUnmapFramebuffer (screen);
|
|
screen->fb[0].depth = pscr->origDepth;
|
|
}
|
|
|
|
int
|
|
vesaSetPalette(VesaCardPrivPtr priv, int first, int number, U8 *entries)
|
|
{
|
|
if (priv->vga_palette)
|
|
return VgaSetPalette (priv->vi, first, number, entries);
|
|
else
|
|
return VbeSetPalette (priv->vi, priv->vbeInfo, first, number, entries);
|
|
}
|
|
|
|
|
|
int
|
|
vesaGetPalette(VesaCardPrivPtr priv, int first, int number, U8 *entries)
|
|
{
|
|
int code;
|
|
|
|
if (priv->vga_palette)
|
|
code = VgaGetPalette (priv->vi, first, number, entries);
|
|
else
|
|
{
|
|
code = VbeGetPalette (priv->vi, priv->vbeInfo, first, number, entries);
|
|
if (code < 0)
|
|
{
|
|
priv->vga_palette = 1;
|
|
code = VgaGetPalette (priv->vi, first, number, entries);
|
|
}
|
|
}
|
|
return code;
|
|
}
|
|
|
|
void
|
|
vesaPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
int p;
|
|
CARD8 *scratch;
|
|
int red, green, blue;
|
|
int min, max;
|
|
|
|
if (vesa_swap_rgb)
|
|
{
|
|
red = 2;
|
|
green = 1;
|
|
blue = 0;
|
|
}
|
|
else
|
|
{
|
|
red = 0;
|
|
green = 1;
|
|
blue = 2;
|
|
}
|
|
|
|
min = 256;
|
|
max = 0;
|
|
while (n--)
|
|
{
|
|
p = pdefs->pixel;
|
|
if (p < min)
|
|
min = p;
|
|
if (p > max)
|
|
max = p;
|
|
scratch = priv->cmap + (p * 4);
|
|
scratch[red] = pdefs->red >> 8;
|
|
scratch[green] = pdefs->green >> 8;
|
|
scratch[blue] = pdefs->blue >> 8;
|
|
scratch[3] = 0;
|
|
pdefs++;
|
|
if (pscr->mapping == VESA_PLANAR)
|
|
{
|
|
/*
|
|
* VGA modes are strange; this code covers all
|
|
* possible modes by duplicating the color information
|
|
* however the attribute registers might be set
|
|
*/
|
|
if (p < 16)
|
|
{
|
|
vesaSetPalette (priv, p, 1, scratch);
|
|
if (p >= 8)
|
|
vesaSetPalette (priv, p+0x30, 1, scratch);
|
|
else if (p == 6)
|
|
vesaSetPalette (priv, 0x14, 1, scratch);
|
|
}
|
|
}
|
|
}
|
|
if (pscr->mapping != VESA_PLANAR)
|
|
vesaSetPalette (priv, min, max-min+1, priv->cmap + min * 4);
|
|
}
|
|
|
|
void
|
|
vesaGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
VesaScreenPrivPtr pscr = pScreenPriv->screen->driver;
|
|
VesaCardPrivPtr priv = pScreenPriv->card->driver;
|
|
int i;
|
|
int red, green, blue;
|
|
int min, max;
|
|
int p;
|
|
CARD8 *scratch;
|
|
|
|
if (vesa_swap_rgb)
|
|
{
|
|
red = 2;
|
|
green = 1;
|
|
blue = 0;
|
|
}
|
|
else
|
|
{
|
|
red = 0;
|
|
green = 1;
|
|
blue = 2;
|
|
}
|
|
|
|
min = 256;
|
|
max = 0;
|
|
for(i = 0; i < n; i++)
|
|
{
|
|
p = pdefs[i].pixel;
|
|
if (p < min)
|
|
min = p;
|
|
if (p > max)
|
|
max = p;
|
|
if (pscr->mapping == VESA_PLANAR)
|
|
vesaGetPalette (priv, p, 1, priv->cmap + p * 4);
|
|
}
|
|
if (pscr->mapping != VESA_PLANAR)
|
|
vesaGetPalette (priv, min, max - min + 1, priv->cmap + min * 4);
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
p = pdefs[i].pixel;
|
|
scratch = priv->cmap + p * 4;
|
|
pdefs[i].red = scratch[red]<<8;
|
|
pdefs[i].green = scratch[green]<<8;
|
|
pdefs[i].blue = scratch[blue]<<8;
|
|
}
|
|
}
|
|
|
|
void
|
|
vesaUseMsg (void)
|
|
{
|
|
ErrorF("\nTinyX VESA Usage:\n");
|
|
ErrorF("-mode VESA video mode to use (Be careful!)\n");
|
|
ErrorF("-listmodes List supported video modes\n");
|
|
ErrorF("-force Attempt even unsupported modes\n");
|
|
ErrorF("-shadow Always use shadow framebuffer (May increase performance)\n");
|
|
ErrorF("-nolinear Never use linear framebuffer (Not useful)\n");
|
|
ErrorF("-swaprgb Use if colors are wrong in PseudoColor and 16 color modes\n");
|
|
ErrorF("-map-holes Use contiguous memory map (For seg fault with rare BIOS)\n");
|
|
ErrorF("-verbose Emit diagnostic messages during BIOS initialization\n");
|
|
ErrorF("-force-text Always use standard 25x80 text mode on server exit or VT switch\n");
|
|
ErrorF("-boot Soft boot video card\n");
|
|
/* XXX: usage for -vesatest, -no-map-holes (don't need?),
|
|
* XXX: and -trash-font. Also in man page. */
|
|
}
|
|
|
|
int
|
|
vesaProcessArgument (int argc, char **argv, int i)
|
|
{
|
|
if(!strcmp(argv[i], "-mode")) {
|
|
if(i+1 < argc) {
|
|
vesa_video_mode = strtol(argv[i+1], NULL, 0);
|
|
} else
|
|
UseMsg();
|
|
return 2;
|
|
} else if(!strcmp(argv[i], "-force")) {
|
|
vesa_force_mode = TRUE;
|
|
return 1;
|
|
} else if(!strcmp(argv[i], "-listmodes")) {
|
|
vesaListModes();
|
|
exit(0);
|
|
} else if(!strcmp(argv[i], "-vesatest")) {
|
|
vesaTestMode();
|
|
exit (0);
|
|
} else if(!strcmp(argv[i], "-swaprgb")) {
|
|
vesa_swap_rgb = TRUE;
|
|
return 1;
|
|
} else if(!strcmp(argv[i], "-shadow")) {
|
|
vesa_shadow = TRUE;
|
|
return 1;
|
|
} else if(!strcmp(argv[i], "-nolinear")) {
|
|
vesa_linear_fb = FALSE;
|
|
return 1;
|
|
} else if(!strcmp(argv[i], "-verbose")) {
|
|
vesa_verbose = TRUE;
|
|
return 1;
|
|
} else if(!strcmp(argv[i], "-force-text")) {
|
|
vesa_force_text = TRUE;
|
|
return 1;
|
|
} else if(!strcmp(argv[i], "-map-holes")) {
|
|
vesa_map_holes = TRUE;
|
|
return 1;
|
|
} else if(!strcmp(argv[i], "-no-map-holes")) {
|
|
vesa_map_holes = FALSE;
|
|
return 1;
|
|
} else if(!strcmp(argv[i], "-trash-font")) {
|
|
vesa_restore_font = FALSE;
|
|
return 1;
|
|
} else if(!strcmp(argv[i], "-boot")) {
|
|
vesa_boot = TRUE;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|