qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
1656661794
xenocara/xserver/hw/kdrive/vesa/vesa.c
matthieu 889b860699 Importing xserver from X.Org 7.2RC2
2006-11-26 18:13:41 +00:00

1825 lines
41 KiB
C
Raw Blame History

/*
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: vesa.c,v 1.1.1.1 2006/11/26 18:22:04 matthieu Exp $ */
#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;
KdMouseMatrix 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;
}
KdComputeMouseMatrix (&m, pscr->randr,
pscr->mode.XResolution, pscr->mode.YResolution);
KdSetMouseMatrix (&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, &regs) < 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;
}
Reference in New Issue View Git Blame Copy Permalink