565. Support for multithreaded libraries on NetBSD when used in conjunction

    with the GNU pth library (#4113, Chris Sekiya).
564. Add /usr/pkg/bin to NetBSD's DefaultUserPath (#4112, Bernd Ernesti).
563. Add a (Linux-specific) VESA driver for Keith's small X server (#4111,
    Juliusz Chroboczek).
562. Update Hungarian xkb maps (#A.145, Peter Soos). remove koi8-r encoding
    file since it's built-in

hw/kdrive/vesa/Imakefile

+XCOMM $XFree86$
+
+#include <Server.tmpl>
+
+SRCS = 	vesa.c vesainit.c vbe.c 
+
+OBJS = 	vesa.o vesainit.o vbe.o
+
+INCLUDES = -I.. -I. -I$(XBUILDINCDIR) -I$(FONTINCSRC) \
+	   -I../../../fb -I../../../mi -I../../../include -I../../../os  \
+           -I$(EXTINCSRC) -I$(XINCLUDESRC)
+
+NormalLibraryObjectRule()
+NormalLibraryTarget(vesa,$(OBJS))
+InstallManPage(Xvesa,$(MANDIR))
+DependTarget()

hw/kdrive/vesa/Xvesa.man

+.\" $XFree86$
+.TH Xvesa 1
+.SH NAME
+Xvesa \- VESA VBE tiny X server
+.SH SYNOPSIS
+.B Xvesa
+.RI [ :display ] 
+.RI [ option ...]
+.SH DESCRIPTION
+Xvesa is an X server for Linux on the x86 platform.  Xvesa manipulates
+the video hardware by running the VESA BIOS in VM86 mode.  It
+therefore runs untrusted code with full priviledges, and is one of the
+most insecure X servers available.
+.B Run at your own risk.
+.SH OPTIONS
+In addition to the normal tiny-X server's options (to be described in
+a separate man page),
+.B Xvesa
+accepts the following command line switches:
+.TP 8
+.B -mode \fIn\fB
+specifies the VESA video mode to use.  If mode
+.I n
+is not supported by your BIOS and hardware,
+.B Xvesa
+will fail, hang your system, or make your monitor explode.  You are on
+your own.  The list of video modes that your BIOS claims to support
+can be obtained by using the 
+.B -listmodes
+option.
+.TP 8
+.B -listmodes
+tells the server to list all supported video modes.  If
+.B -force
+was specified before
+.BR -listmodes ,
+lists all the modes that your BIOS claims to support, even those that
+the
+.B Xvesa
+server won't be able to use.
+.TP 8
+.B -force
+tells the server to disable some sanity checks and use the specified
+mode even if the BIOS claims not to support it.
+.SH KEYBOARD
+Xvesa handles the keyboard in the same manner as the
+.B Xfbdev
+Linux X server.  See Xfbdev(1) (not yet written) for more information.
+.SH BUGS
+.B Xvesa
+opens all IO ports and runs your VESA BIOS, which may safely be
+assumed to be buggy.  Allowing your users to run
+.B Xvesa
+is a major security hole.  Allowing yourself to run
+.B Xvesa
+is probably a mistake.
+.SH SEE ALSO
+X(1), Xserver(1), xdm(1), xinit(1), Xfbdev(1).
+.SH AUTHORS
+The tiny-X server was written by Keith Packard, and the VESA driver
+was added by Juliusz Chroboczek who didn't realise what he was doing
+until it was too late.  Tiny-X uses code from XFree86, which in turn
+is based on the Sample Implementation.

hw/kdrive/vesa/vbe.h

+/* 
+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.
+*/
+/* $XFree86$ */
+
+#ifndef _VBE_H
+#define _VBE_H
+
+#ifndef U8
+#define U8 unsigned char
+#define U16 unsigned short
+#define U32 unsigned int
+#endif
+
+/* The whole addressable memory */
+#define SYSMEM_BASE 0x00000
+#define SYSMEM_SIZE 0x100000
+
+/* Interrupt vectors and BIOS data area */
+/* This is allocated privately from /dev/mem */
+#define MAGICMEM_BASE 0x00000
+#define MAGICMEM_SIZE 0x01000
+
+/* The low memory, allocated privately from /dev/zero */
+/* 64KB should be enough for anyone, as they used to say */
+#define LOMEM_BASE 0x10000
+#define LOMEM_SIZE 0x10000
+
+/* The video memory and BIOS ROM, allocated shared from /dev/mem */
+#define HIMEM_BASE 0xA0000
+#define HIMEM_SIZE (SYSMEM_BASE + SYSMEM_SIZE - HIMEM_BASE)
+
+/* The BIOS ROM */
+#define ROM_BASE 0xC0000
+#define ROM_SIZE 0x30000
+
+#define STACK_SIZE 0x1000
+
+#define POINTER_SEGMENT(ptr) (((unsigned int)ptr)>>4)
+#define POINTER_OFFSET(ptr) (((unsigned int)ptr)&0x000F)
+#define MAKE_POINTER(seg, off) (((((unsigned int)(seg))<<4) + (unsigned int)(off)))
+#define MAKE_POINTER_1(lw) MAKE_POINTER(((lw)&0xFFFF0000)/0x10000, (lw)&0xFFFF)
+#define ALLOC_FAIL ((U32)-1)
+
+typedef struct _VbeInfoRec {
+    int devmem, devzero;
+    void *magicMem, *loMem, *hiMem, *fb;
+    U32 fb_size;
+    U32 brk;
+    struct vm86_struct vms;
+    U32 ret_code, stack_base, vib_base, vmib_base, statebuffer_base, palette_scratch_base;
+    U8 palette_format;
+    int palette_wait;
+} VbeInfoRec, *VbeInfoPtr;
+
+typedef struct _VbeInfoBlock {
+    U8 VbeSignature[4];         /* VBE Signature */
+    U16 VbeVersion;             /* VBE Version */
+    U32 OemStringPtr;           /* Pointer to OEM String */
+    U8 Capabilities[4];         /* Capabilities of graphics controller */
+    U32 VideoModePtr;           /* Pointer to VideoModeList */
+    U16 TotalMemory;            /* Number of 64kb memory blocks */
+/* Added for VBE 2.0 */
+    U16 OemSoftwareRev;         /* VBE implementation Software revision */
+    U32 OemVendorNamePtr;       /* Pointer to Vendor Name String */
+    U32 OemProductNamePtr;	/* Pointer to Product Name String */
+    U32 OemProductRevPtr;       /* Pointer to Product Revision String */
+    U8 Reserved[222];           /* Reserved for VBE implementation */
+    U8 OemData[256];            /* Data Area for OEM Strings*/
+} __attribute__((packed)) VbeInfoBlock;
+
+typedef struct _VbeModeInfoBlock {
+/* Mandatory information for all VBE revisions */
+    U16 ModeAttributes;         /* mode attributes */
+    U8 WinAAttributes;          /* window A attributes */
+    U8 WinBAttributes;          /* window B attributes */
+    U16 WinGranularity;         /* window granularity */
+    U16 WinSize;                /* window size */
+    U16 WinASegment;            /* window A start segment */
+    U16 WinBSegment;            /* window B start segment */
+    U32 WinFuncPtr;             /* pointer to window function */
+    U16 BytesPerScanLine;       /* bytes per scan line */
+/* Mandatory information for VBE 1.2 and above */
+    U16 XResolution;            /* horizontal resolution */
+    U16 YResolution;            /* vertical resolution */
+    U8 XCharSize;               /* character cell width in pixels */
+    U8 YCharSize;               /* character cell height in pixels */
+    U8 NumberOfPlanes;          /* number of memory planes */
+    U8 BitsPerPixel;            /* bits per pixel */
+    U8 NumberOfBanks;           /* number of banks */
+    U8 MemoryModel;             /* memory model type */
+    U8 BankSize;                /* bank size in KB */
+    U8 NumberOfImagePages;      /* number of images */
+    U8 Reserved;                /* reserved for page function */
+/* Direct Color fields (required for direct/6 and YUV/7 memory models) */
+    U8 RedMaskSize;             /* size of direct color red mask in bits */
+    U8 RedFieldPosition;        /* bit position of lsb of red mask */
+    U8 GreenMaskSize;           /* size of direct color green mask in bits */
+    U8 GreenFieldPosition;      /* bit position of lsb of green mask */
+    U8 BlueMaskSize;            /* size of direct color blue mask in bits */
+    U8 BlueFieldPosition;       /* bit position of lsb of blue mask */
+    U8 RsvdMaskSize;            /* size of direct color reserved mask bits*/
+    U8 RsvdFieldPosition;       /* bit position of lsb of reserved mask */
+    U8 DirectColorModeInfo;     /* direct color mode attributes */
+/* Mandatory information for VBE 2.0 and above */
+    U32 PhysBasePtr;            /* physical address for flat memory fb */
+    U32 OffScreenMemOffset;     /* pointer to start of off screen memory */
+    U16 OffScreenMemSize;       /* amount of off screen memory in 1k units */
+    U8 Reserved2[206];          /* remainder of ModeInfoBlock */
+} __attribute__((packed)) VbeModeInfoBlock;
+
+
+typedef struct _SupVbeInfoBlock {
+    U8 SupVbeSignature[7];      /* Supplemental VBE Signature */
+    U16 SupVbeVersion;          /* Supplemental VBE Version*/
+    U8 SupVbeSubFunc[8];	/* Bitfield of supported subfunctions */
+    U16 OemSoftwareRev;         /* OEM Software revision */
+    U32 OemVendorNamePtr;       /* Pointer to Vendor Name String */
+    U32 OemProductNamePtr;	/* Pointer to Product Name String */
+    U32 OemProductRevPtr;       /* Pointer to Product Revision String */
+    U32 OemStringPtr;           /* Pointer to OEM String */
+    U8 Reserved[221];           /* Reserved */
+} __attribute__((packed)) SupVbeInfoBlock;
+
+VbeInfoPtr VbeSetup(void);
+void VbeCleanup(VbeInfoPtr vi);
+VbeInfoBlock *VbeGetInfo(VbeInfoPtr vi);
+VbeModeInfoBlock *VbeGetModeInfo(VbeInfoPtr vi, int mode);
+int VbeSetMode(VbeInfoPtr vi, int mode);
+int  VbeGetMode(VbeInfoPtr vi, int *mode);
+int VbeSetupStateBuffer(VbeInfoPtr vi);
+int VbeSaveState(VbeInfoPtr vi);
+int VbeRestoreState(VbeInfoPtr vi);
+void *VbeMapFramebuffer(VbeInfoPtr vi);
+int VbeUnmapFrambuffer(VbeInfoPtr vi);
+int VbeSetPalette(VbeInfoPtr vi, int first, int number, U8 *entries);
+int VbeSetPaletteOptions(VbeInfoPtr vi, U8 bits, int wait);
+int VbeReportInfo(VbeInfoPtr, VbeInfoBlock *);
+int VbeReportModeInfo(VbeInfoPtr, U16 mode, VbeModeInfoBlock *);
+
+int VbeDoInterrupt(VbeInfoPtr, int num);
+int VbeDoInterrupt10(VbeInfoPtr vi);
+int  VbeIsMemory(VbeInfoPtr vi, U32 i);
+U8 VbeMemory(VbeInfoPtr, U32);
+U16 VbeMemoryW(VbeInfoPtr, U32);
+void VbeWriteMemory(VbeInfoPtr, U32, U8);
+int VbeAllocateMemory(VbeInfoPtr, int);
+#endif

hw/kdrive/vesa/vesa.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.
+*/
+/* $XFree86$ */
+
+#include "vesa.h"
+
+#define DEFAULT_MODE 0x115
+
+int vesa_video_mode = DEFAULT_MODE;
+Bool vesa_force_mode = FALSE;
+
+static Bool
+vesaModeSupported(VbeInfoPtr vi, VbeModeInfoBlock *vmib, Bool complain)
+{
+    if((vmib->ModeAttributes & 0x10) == 0) {
+        if(complain)
+            ErrorF("Text mode specified.\n");
+        return FALSE;
+    }
+    if(vmib->MemoryModel != 0x06 && vmib->MemoryModel != 0x04) {
+        if(complain)
+            ErrorF("Unsupported memory model 0x%X\n", vmib->MemoryModel);
+        return FALSE;
+    }
+    if((vmib->ModeAttributes & 0x80) == 0) {
+        if(complain)
+            ErrorF("No linear framebuffer available in this mode\n");
+        return FALSE;
+    }
+    if(!(vmib->ModeAttributes&1)) {
+        if(complain)
+            ErrorF("Mode not supported on this hardware\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+Bool
+vesaListModes()
+{
+    int code;
+    VbeInfoPtr vi = NULL;
+    VbeInfoBlock *vib;
+    VbeModeInfoBlock *vmib;
+    unsigned i;
+
+    vi = VbeSetup();
+    if(!vi)
+        goto fail;
+
+    vib = VbeGetInfo(vi);
+    if(!vib)
+        goto fail;
+
+    VbeReportInfo(vi, vib);
+    i = MAKE_POINTER_1(vib->VideoModePtr);
+
+    while(VbeMemoryW(vi, i) != 0xFFFF) {
+        vmib = VbeGetModeInfo(vi, VbeMemoryW(vi, i));
+        if(!vmib)
+            goto fail;
+        if(vesa_force_mode || vesaModeSupported(vi, vmib, FALSE))
+           VbeReportModeInfo(vi, VbeMemoryW(vi, i), vmib);
+        i+=2;
+    }
+
+    VbeCleanup(vi);
+    return TRUE;
+
+  fail:
+    VbeCleanup(vi);
+    return FALSE;
+}
+
+Bool
+vesaCardInit(KdCardInfo *card)
+{
+    VesaPrivPtr priv;
+    int code;
+
+    priv = xalloc(sizeof(VesaPrivRec));
+    if(!priv)
+        goto fail;
+
+    priv->mode = vesa_video_mode;
+
+    priv->vi = VbeSetup();
+    if(!priv->vi)
+        goto fail;
+
+    priv->vib = VbeGetInfo(priv->vi);
+    if(!priv->vib) 
+        goto fail;
+
+    priv->vmib = VbeGetModeInfo(priv->vi, priv->mode);
+    if(!priv->vmib)
+        goto fail;
+
+    if(!vesa_force_mode && !vesaModeSupported(priv->vi, priv->vmib, TRUE))
+       goto fail;
+
+    code = VbeSetupStateBuffer(priv->vi);
+    if(code < 0)
+        goto fail;
+
+    code = VbeSaveState(priv->vi);
+    if(code<0)
+        goto fail;
+
+    priv->fb = VbeMapFramebuffer(priv->vi);
+    if(!priv->vi)
+        goto fail;
+
+    card->driver = priv;
+
+    return TRUE;
+
+  fail:
+    if(priv) {
+        if(priv->vi)
+            VbeCleanup(priv->vi);
+        xfree(priv);
+    }
+    return FALSE;
+}
+
+Bool
+vesaScreenInit(KdScreenInfo *screen)
+{
+    VesaPrivPtr priv = screen->card->driver;
+    Pixel allbits;
+    int	depth;
+
+    screen->width = priv->vmib->XResolution;
+    screen->height = priv->vmib->YResolution;
+    screen->fb[0].depth = priv->vmib->BitsPerPixel;
+    screen->fb[0].bitsPerPixel = priv->vmib->BitsPerPixel;
+    screen->fb[0].byteStride = priv->vmib->BytesPerScanLine;
+    screen->fb[0].pixelStride = 
+        (priv->vmib->BytesPerScanLine * 8) / priv->vmib->BitsPerPixel;
+
+    if(priv->vmib->MemoryModel == 0x06) {
+        /* TrueColor or DirectColor */
+        screen->fb[0].visuals = (1 << TrueColor);
+        screen->fb[0].redMask = 
+            FbStipMask(priv->vmib->RedFieldPosition, priv->vmib->RedMaskSize);
+        screen->fb[0].greenMask = 
+            FbStipMask(priv->vmib->GreenFieldPosition, priv->vmib->GreenMaskSize);
+        screen->fb[0].blueMask = 
+            FbStipMask(priv->vmib->BlueFieldPosition, priv->vmib->BlueMaskSize);
+        allbits = 
+            screen->fb[0].redMask | 
+            screen->fb[0].greenMask | 
+            screen->fb[0].blueMask;
+        depth = 32;
+        while (depth && !(allbits & (1 << (depth - 1))))
+            depth--;
+        screen->fb[0].depth = depth;
+    } else if (priv->vmib->MemoryModel == 0x04) {
+        /* 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;
+    } else {
+        ErrorF("Unsupported VESA MemoryModel 0x%02X\n",
+               priv->vmib->MemoryModel);
+        return FALSE;
+    }
+
+    screen->rate = 72;
+    screen->fb[0].frameBuffer = (CARD8 *)(priv->fb);
+
+    return TRUE;
+}
+
+Bool
+vesaInitScreen(ScreenPtr pScreen)
+{
+    return TRUE;
+}
+
+void
+vesaEnable(ScreenPtr pScreen)
+{
+    KdScreenPriv(pScreen);
+    VesaPrivPtr priv = pScreenPriv->card->driver;
+    int code;
+    int palette_wait = 0, palette_hi = 0;
+
+    code = VbeSetMode(priv->vi, priv->mode);
+    if(code < 0)
+        FatalError("Couldn't set mode\n");
+
+    if(priv->vib->Capabilities[0] & 1)
+        palette_hi = 1;
+    if(priv->vib->Capabilities[0] & 4)
+        palette_wait = 1;
+    if(palette_hi || palette_wait)
+        VbeSetPaletteOptions(priv->vi, palette_hi?8:6, palette_wait);
+
+    return;
+}
+
+void
+vesaDisable(ScreenPtr pScreen)
+{
+    KdScreenPriv(pScreen);
+    VesaPrivPtr priv = pScreenPriv->card->driver;
+
+}
+
+void
+vesaPreserve(KdCardInfo *card)
+{
+    VesaPrivPtr priv = card->driver;
+    int code;
+
+    code = VbeSaveState(priv->vi);
+    if(code < 0)
+        FatalError("Couldn't save state\n");
+
+    return;
+}
+
+void
+vesaRestore(KdCardInfo *card)
+{
+    VesaPrivPtr priv = card->driver;
+    VbeRestoreState(priv->vi);
+    return;
+}
+
+void
+vesaCardFini(KdCardInfo *card)
+{
+    VesaPrivPtr priv = card->driver;
+    VbeUnmapFramebuffer(priv->vi);
+    VbeCleanup(priv->vi);
+    return;
+}
+
+void 
+vesaScreenFini(KdScreenInfo *screen)
+{
+  return;
+}
+
+void
+vesaPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
+{
+    KdScreenPriv(pScreen);
+    VesaPrivPtr priv = pScreenPriv->card->driver;
+    int i, j, k;
+    CARD8 scratch[4*256];
+
+    i = 0;
+    while(i < n) {
+        j = i + 1;
+        /* For some reason, doing more than one entry at a time breaks */
+        while(j < n && pdefs[j].pixel == pdefs[j-1].pixel + 1 && j - i < 1)
+            j++;
+        for(k=0; k<(j - i); k++) {
+            /* The opposite of what the spec says? */
+            scratch[k+3] = 0;
+            scratch[k+2] = pdefs[i+k].red >> 8;
+            scratch[k+1] = pdefs[i+k].green >> 8;
+            scratch[k+0] = pdefs[i+k].blue >> 8;
+        }
+        VbeSetPalette(priv->vi, pdefs[i].pixel, j - i, scratch);
+        i = j;
+    }
+}
+
+void
+vesaGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
+{
+    KdScreenPriv(pScreen);
+    VesaPrivPtr priv = pScreenPriv->card->driver;
+    int first, i, j, k;
+    CARD8 scratch[4];
+
+    for(i = 0; i<n; i++) {
+        VbeGetPalette(priv->vi, pdefs[i].pixel, 1, scratch);
+        pdefs[i].red = scratch[2]<<8;
+        pdefs[i].green = scratch[1]<<8;
+        pdefs[i].blue = scratch[0]<<8;
+    }
+}

hw/kdrive/vesa/vesa.h

+/* 
+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.
+*/
+/* $XFree86$ */
+
+#ifndef _VESA_H_
+#define _VESA_H_
+
+#include "kdrive.h"
+#include <sys/vm86.h>
+#include "vbe.h"
+
+typedef struct _VesaPriv {
+    int mode;
+    VbeInfoPtr vi;
+    VbeInfoBlock *vib;
+    VbeModeInfoBlock *vmib;
+    void *fb;
+} VesaPrivRec, *VesaPrivPtr;
+
+extern int vesa_video_mode;
+extern Bool vesa_force_mode;
+
+Bool vesaListModes(void);
+Bool vesaInitialize(KdCardInfo *card, VesaPrivPtr priv);
+Bool vesaCardInit(KdCardInfo *card);
+Bool vesaScreenInit(KdScreenInfo *screen);
+Bool vesaInitScreen(ScreenPtr pScreen);
+void vesaEnable(ScreenPtr pScreen);
+void vesaDisable(ScreenPtr pScreen);
+void vesaPreserve(KdCardInfo *card);
+void vesaRestore(KdCardInfo *card);
+void vesaCardFini(KdCardInfo *card);
+void vesaScreenFini(KdScreenInfo *screen);
+void vesaPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs);
+void vesaGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs);
+
+#endif _VESA_H_

hw/kdrive/vesa/vesainit.c

+/*