Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 706 insertions, 0 deletions

diff --git a/xorg-server/hw/kdrive/vesa/vbe.c b/xorg-server/hw/kdrive/vesa/vbe.c
new file mode 100644
index 000000000..cedefe9fc
--- /dev/null
+++ b/xorg-server/hw/kdrive/vesa/vbe.c
@@ -0,0 +1,706 @@
+/* 
+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.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <kdrive-config.h>
+#endif
+#include "vesa.h"
+
+int
+VbeGetVib (Vm86InfoPtr vi, VbeInfoBlock *vib)
+{
+    int		    code;
+    int		    mark;
+    int		    vib_base;
+    VbeInfoBlock    *vib_low;
+    
+    mark = Vm86MarkMemory (vi);
+    vib_base = Vm86AllocateMemory (vi, sizeof (VbeInfoBlock));
+    vib_low = (VbeInfoBlock*)&(LM(vi, vib_base));
+    vi->vms.regs.eax = 0x4F00;
+    vi->vms.regs.es = POINTER_SEGMENT(vib_base);
+    vi->vms.regs.edi = POINTER_OFFSET(vib_base);
+    memcpy(vib_low->VbeSignature, "VBE2", 4);
+    code = VbeDoInterrupt10(vi);
+    if(code >= 0)
+    {
+	if(memcmp(vib_low->VbeSignature, "VESA", 4) == 0) 
+	    *vib = *vib_low;
+	else
+	    code = -1;
+    }
+    Vm86ReleaseMemory (vi, mark);
+    return code;
+}
+
+int
+VbeGetVmib (Vm86InfoPtr vi, int mode, VbeModeInfoBlock *vmib)
+{
+    int			code;
+    int			mark;
+    int			vmib_base;
+    VbeModeInfoBlock	*vmib_low;
+    
+    mark = Vm86MarkMemory (vi);
+    
+    vmib_base = Vm86AllocateMemory (vi, sizeof (VbeModeInfoBlock));
+    vmib_low = (VbeModeInfoBlock*)&(LM(vi, vmib_base));
+    
+    vi->vms.regs.eax = 0x4F01;
+    vi->vms.regs.ecx = mode&0xFFFF;
+    vi->vms.regs.es = POINTER_SEGMENT(vmib_base);
+    vi->vms.regs.edi = POINTER_OFFSET(vmib_base);
+    code = VbeDoInterrupt10(vi);
+    
+    if(code >= 0)
+	*vmib = *vmib_low;
+    Vm86ReleaseMemory (vi, mark);
+    return code;
+}
+
+static int 
+VbeReportVib(Vm86InfoPtr vi, VbeInfoBlock *vib)
+{
+    U32 i, p;
+    unsigned char c;
+    int error = 0;
+    
+    ErrorF("VBE version %c.%c (", 
+           ((vib->VbeVersion >> 8) & 0xFF) + '0',
+           (vib->VbeVersion & 0xFF)+'0');
+    p = vib->OemStringPtr;
+    for(i = 0; 1; i++) {
+        c = Vm86Memory(vi, MAKE_POINTER_1(p+i));
+        if(!c) break;
+	if (c >= ' ')
+	    ErrorF("%c", c);
+        if (i > 32000) {
+            error = 1;
+            break;
+        }
+    }
+    ErrorF(")\n");
+    ErrorF("DAC is %s, controller is %sVGA compatible%s\n",
+           (vib->Capabilities[0]&1)?"switchable":"fixed",
+           (vib->Capabilities[0]&2)?"not ":"",
+           (vib->Capabilities[0]&3)?", RAMDAC causes snow":"");
+    ErrorF("Total memory: %lu kilobytes\n", 64L*vib->TotalMemory);
+    if(error)
+        return -1;
+    return 0;
+}
+
+#if 0
+static int 
+VbeReportModeInfo(Vm86InfoPtr vi, U16 mode, VbeModeInfoBlock *vmib)
+{
+    int supported = (vmib->ModeAttributes&0x1)?1:0;
+    int colour = (vmib->ModeAttributes&0x8)?1:0;
+    int graphics = (vmib->ModeAttributes&0x10)?1:0;
+    int vga_compatible = !((vmib->ModeAttributes&0x20)?1:0);
+    int linear_fb = (vmib->ModeAttributes&0x80)?1:0;
+
+    ErrorF("0x%04X: %dx%dx%d%s",
+           (unsigned)mode, 
+           (int)vmib->XResolution, (int)vmib->YResolution,
+           (int)vmib->BitsPerPixel,
+           colour?"":" (monochrome)",
+	   graphics?"":" (graphics)",
+	   vga_compatible?"":" (vga compatible)",
+	   linear_fb?"":" (linear frame buffer)");
+    switch(vmib->MemoryModel) {
+    case 0:
+        ErrorF(" text mode (%dx%d)",
+               (int)vmib->XCharSize, (int)vmib->YCharSize);
+        break;
+    case 1:
+        ErrorF(" CGA graphics");
+        break;
+    case 2:
+        ErrorF(" Hercules graphics");
+        break;
+    case 3:
+        ErrorF(" Planar (%d planes)", vmib->NumberOfPlanes);
+        break;
+    case 4:
+        ErrorF(" PseudoColor");
+        break;
+    case 5:
+        ErrorF(" Non-chain 4, 256 colour");
+        break;
+    case 6:
+        if(vmib->DirectColorModeInfo & 1)
+            ErrorF(" DirectColor");
+        else
+            ErrorF(" TrueColor");
+        ErrorF(" [%d:%d:%d:%d]",
+               vmib->RedMaskSize, vmib->GreenMaskSize, vmib->BlueMaskSize,
+               vmib->RsvdMaskSize);
+        if(vmib->DirectColorModeInfo & 2)
+            ErrorF(" (reserved bits are reserved)");
+        break;
+    case 7: ErrorF("YUV");
+        break;
+    default:
+        ErrorF("unknown MemoryModel 0x%X ", vmib->MemoryModel);
+    }
+    if(!supported)
+        ErrorF(" (unsupported)");
+    else if(!linear_fb)
+        ErrorF(" (no linear framebuffer)");
+    ErrorF("\n");
+    return 0;
+}
+#endif
+
+void
+VbeReportInfo (Vm86InfoPtr vi)
+{
+    VbeInfoBlock    vib;
+    int		    code;
+
+    code = VbeGetVib (vi, &vib);
+    if (code >= 0)
+	VbeReportVib(vi, &vib);
+}
+
+int
+VbeGetNmode (Vm86InfoPtr vi)
+{
+    VbeInfoBlock    vib;
+    int		    code;
+    unsigned int    p;
+    int		    n;
+    int		    mode;
+
+    code = VbeGetVib (vi, &vib);
+    if (code >= 0)
+    {
+	p = MAKE_POINTER_1(vib.VideoModePtr);
+	for (n = 0; ; n++)
+	{
+	    mode = Vm86MemoryW(vi, p);
+	    if (mode == 0xffff)
+	        break;
+	    p += 2;
+	}
+	code = n;
+    }
+    return code;
+}
+
+int
+VbeGetModes (Vm86InfoPtr vi, VesaModePtr modes, int nmode)
+{
+    VbeInfoBlock	vib;
+    int			code;
+    unsigned int	p;
+    int			n;
+    int			mode;
+    VbeModeInfoBlock	vmib;
+
+    code = VbeGetVib (vi, &vib);
+    if (code < 0)
+	return code;
+
+    memset (modes, '\0', nmode * sizeof (VesaModeRec));
+    
+    p = MAKE_POINTER_1(vib.VideoModePtr);
+    for (n = 0; n < nmode; n++)
+    {
+	mode = Vm86MemoryW(vi, p);
+	if (mode == 0xffff)
+	    break;
+	modes[n].mode = mode;
+	modes[n].vbe = 1;
+	p += 2;
+    }
+    
+    nmode = n;
+    
+    for (n = 0; n < nmode; n++)
+    {
+	code = VbeGetVmib (vi, modes[n].mode, &vmib);
+	if (code >= 0)
+	{
+	    modes[n].ModeAttributes = vmib.ModeAttributes;
+	    modes[n].NumberOfPlanes = vmib.NumberOfPlanes;
+	    modes[n].BitsPerPixel = vmib.BitsPerPixel;
+	    modes[n].MemoryModel = vmib.MemoryModel;
+	    modes[n].RedMaskSize = vmib.RedMaskSize;
+	    modes[n].RedFieldPosition = vmib.RedFieldPosition;
+	    modes[n].GreenMaskSize = vmib.GreenMaskSize;
+	    modes[n].GreenFieldPosition = vmib.GreenFieldPosition;
+	    modes[n].BlueMaskSize = vmib.BlueMaskSize;
+	    modes[n].BlueFieldPosition = vmib.BlueFieldPosition;
+	    modes[n].RsvdMaskSize = vmib.RsvdMaskSize;
+	    modes[n].RsvdFieldPosition = vmib.RsvdFieldPosition;
+	    modes[n].DirectColorModeInfo = vmib.DirectColorModeInfo;
+	    modes[n].XResolution = vmib.XResolution;
+	    modes[n].YResolution = vmib.YResolution;
+	    modes[n].BytesPerScanLine = vmib.BytesPerScanLine;
+	}
+    }
+    
+    return nmode;
+}
+
+VbeInfoPtr
+VbeInit (Vm86InfoPtr vi)
+{
+    VbeInfoPtr	    vbe;
+    int		    code;
+    VbeInfoBlock    vib;
+
+    code = VbeGetVib (vi, &vib);
+    if (code < 0)
+	return 0;
+    
+    vbe = xalloc (sizeof (VbeInfoRec));
+    if (!vbe)
+	return 0;
+    vbe->palette_format = 6;
+    vbe->palette_wait = TRUE;
+    return vbe;
+}
+
+void
+VbeCleanup (Vm86InfoPtr vi, VbeInfoPtr vbe)
+{
+    xfree (vbe);
+}
+
+int
+VbeSetMode (Vm86InfoPtr vi, VbeInfoPtr vbe, int mode, int linear, int direct)
+{
+    int			code;
+    VbeInfoBlock	vib;
+    int			palette_wait = 0, palette_hi = 0;
+
+    code = VbeGetVib (vi, &vib);
+    if (code < 0)
+	return -1;
+    
+    code = VbeGetVmib (vi, mode, &vbe->vmib);
+    if (code < 0)
+	return -1;
+    
+    mode = (mode & 0xffff) &~ 0x8000;
+    if (linear)
+	mode |= 0x4000;
+    
+    vi->vms.regs.eax = 0x4F02;
+    vi->vms.regs.ebx = mode;
+    code = VbeDoInterrupt10(vi);
+    if(code < 0)
+        return -1;
+    
+    vbe->windowA_offset = vbe->windowB_offset = -1;
+    vbe->last_window = 1;
+    
+    if (!direct)
+    {
+	if(vib.Capabilities[0] & 1)
+	    palette_hi = 1;
+	if(vib.Capabilities[0] & 4)
+	    palette_wait = 1;
+	
+	if(palette_hi || palette_wait)
+	    VbeSetPaletteOptions(vi, vbe, palette_hi?8:6, palette_wait);
+    }
+
+    return 0;
+}
+
+int 
+VbeGetMode(Vm86InfoPtr vi, int *mode)
+{
+    int code;
+    
+    vi->vms.regs.eax = 0x4F03;
+    code = VbeDoInterrupt10(vi);
+    if(code < 0)
+        return - 1;
+    *mode = vi->vms.regs.ebx & 0xFFFF;
+    return 0;
+}
+
+void *
+VbeMapFramebuffer(Vm86InfoPtr vi, VbeInfoPtr vbe, int mode, int *ret_size, CARD32 *ret_phys)
+{
+    U8			*fb;
+    VbeInfoBlock	vib;
+    VbeModeInfoBlock	vmib;
+    int			size;
+    int			pagesize = getpagesize();
+    int			before, after;
+
+    if (VbeGetVib (vi, &vib) < 0)
+	return 0;
+    
+    if (VbeGetVmib (vi, mode, &vmib) < 0)
+	return 0;
+    
+    size = 1024 * 64L * vib.TotalMemory;
+    
+    *ret_size = size;
+    *ret_phys = vmib.PhysBasePtr;
+
+    before = vmib.PhysBasePtr % pagesize;
+    after = pagesize - ((vmib.PhysBasePtr + size) % pagesize);
+    if(after == pagesize)
+        after = 0;
+
+    fb = KdMapDevice (vmib.PhysBasePtr - before, before + size + after);
+    
+    if(fb == 0)
+    {
+        ErrorF("Failed to map framebuffer\n");
+        return NULL;
+    }
+
+    KdSetMappedMode (vmib.PhysBasePtr - before, before + size + after,
+		     KD_MAPPED_MODE_FRAMEBUFFER);
+
+    return fb + before;
+}
+
+void
+VbeUnmapFramebuffer(Vm86InfoPtr vi, VbeInfoPtr vbe, int mode, void *fb)
+{
+    VbeInfoBlock	vib;
+    VbeModeInfoBlock	vmib;
+    int			size;
+    int			pagesize = getpagesize();
+    int			before, after;
+
+    if (VbeGetVib (vi, &vib) < 0)
+	return;
+    
+    if (VbeGetVmib (vi, mode, &vmib) < 0)
+	return;
+    
+    size = 1024 * 64L * vib.TotalMemory;
+
+    before = vmib.PhysBasePtr % pagesize;
+    after = pagesize - ((vmib.PhysBasePtr + size) % pagesize);
+    if(after == pagesize)
+        after = 0;
+
+    fb = (void *) ((char *) fb - before);
+    
+    KdUnmapDevice (fb, before + size + after);
+    KdResetMappedMode (vmib.PhysBasePtr - before, before + size + after,
+		     KD_MAPPED_MODE_FRAMEBUFFER);
+}
+
+int 
+VbeSetPalette(Vm86InfoPtr vi, VbeInfoPtr vbe, int first, int number, U8 *entries)
+{
+    U8	    *palette_scratch;
+    int	    mark;
+    int	    palette_base;
+    int	    i, code;
+
+    if(number == 0)
+        return 0;
+
+    if(first < 0 || number < 0 || first + number > 256) {
+        ErrorF("Cannot set %d, %d palette entries\n", first, number);
+        return -1;
+    }
+    if(vbe->palette_format < 6 || vbe->palette_format > 8) {
+        ErrorF("Impossible palette format %d\n", vbe->palette_format);
+        return -1;
+    }
+
+    mark = Vm86MarkMemory (vi);
+    palette_base = Vm86AllocateMemory (vi, 4 * 256);
+
+    palette_scratch = &LM(vi, palette_base);
+
+    for(i=0; i<number*4; i++)
+	palette_scratch[i] = entries[i] >> (8 - vbe->palette_format);
+
+    vi->vms.regs.eax = 0x4F09;
+    if(vbe->palette_wait)
+	vi->vms.regs.ebx = 0x80;
+    else
+	vi->vms.regs.ebx = 0x00;
+    vi->vms.regs.ecx = number;
+    vi->vms.regs.edx = first;
+    vi->vms.regs.es = POINTER_SEGMENT(palette_base);
+    vi->vms.regs.edi = POINTER_OFFSET(palette_base);
+    code = VbeDoInterrupt10(vi);
+    Vm86ReleaseMemory (vi, mark);
+    
+    if(code < 0)
+	return -1;
+    return 0;
+}
+        
+int 
+VbeGetPalette(Vm86InfoPtr vi, VbeInfoPtr vbe, int first, int number, U8 *entries)
+{
+    U8	    *palette_scratch;
+    int	    mark;
+    int	    palette_base;
+    int	    i, code;
+
+    if(number == 0)
+        return 0;
+
+    if(first < 0 || number < 0 || first + number > 256) {
+        ErrorF("Cannot get %d, %d palette entries\n", first, number);
+        return -1;
+    }
+    if(vbe->palette_format < 6 || vbe->palette_format > 8) {
+        ErrorF("Impossible palette format %d\n", vbe->palette_format);
+        return -1;
+    }
+
+    mark = Vm86MarkMemory (vi);
+    palette_base = Vm86AllocateMemory (vi, 4 * 256);
+    
+    palette_scratch = &LM(vi, palette_base);
+
+    vi->vms.regs.eax = 0x4F09;
+    vi->vms.regs.ebx = 0x01;
+    vi->vms.regs.ecx = number;
+    vi->vms.regs.edx = first;
+    vi->vms.regs.es = POINTER_SEGMENT(palette_base);
+    vi->vms.regs.edi = POINTER_OFFSET(palette_base);
+    code = VbeDoInterrupt10(vi);
+    if(code >= 0)
+    {
+	for(i=0; i<number*4; i++)
+	    entries[i] = palette_scratch[i] << (8-vbe->palette_format);
+    }
+    Vm86ReleaseMemory (vi, mark);
+
+    return 0;
+}   
+        
+int 
+VbeSetPaletteOptions(Vm86InfoPtr vi, VbeInfoPtr vbe, U8 bits, int wait)
+{
+    int code;
+    
+    if(bits < 6 || bits > 8) {
+        ErrorF("Impossible palette format %d\n", bits);
+        return -1;
+    }
+    if(bits != vbe->palette_format) 
+    {
+        vbe->palette_format = 0;
+        vi->vms.regs.eax = 0x4F08;
+        vi->vms.regs.ebx = bits << 8;
+        code = VbeDoInterrupt10(vi);
+        if(code < 0)
+            return -1;
+        vbe->palette_format = bits;
+    }
+    vbe->palette_wait = wait;
+    return 0;
+}
+
+static int
+VbeReallySetWindow(Vm86InfoPtr vi, U8 window, U16 winnum)
+{
+    int code;
+    vi->vms.regs.eax = 0x4F05;
+    vi->vms.regs.ebx = window;
+    vi->vms.regs.edx = winnum;
+    code = VbeDoInterrupt10(vi);
+    if(code < 0)
+        return -1;
+    return 0;
+}
+
+void *
+VbeSetWindow(Vm86InfoPtr vi, VbeInfoPtr vbe, int offset, int purpose, int *size_return)
+{
+    int window_size = vbe->vmib.WinSize * 1024;
+    int code;
+    int winnum;
+
+    if(vbe->windowA_offset >= 0)
+	if(vbe->windowA_offset <= offset && vbe->windowA_offset + window_size > offset)
+	    if(vbe->vmib.WinAAttributes & purpose)
+		goto windowA;
+
+    if(vbe->windowB_offset >= 0)
+	if(vbe->windowB_offset <= offset && vbe->windowB_offset + window_size > offset)
+	    if(vbe->vmib.WinBAttributes & purpose)
+		goto windowB;
+
+    if(!(vbe->vmib.WinBAttributes & purpose) || 
+       !(vbe->vmib.WinBAttributes & VBE_WINDOW_RELOCATE))
+	goto set_windowA;
+
+    if(!(vbe->vmib.WinAAttributes & purpose) || 
+       !(vbe->vmib.WinAAttributes & VBE_WINDOW_RELOCATE))
+	goto set_windowB;
+
+    if(vbe->last_window)
+	goto set_windowA;
+    else
+	goto set_windowB;
+
+set_windowA:
+    winnum = offset / (vbe->vmib.WinGranularity * 1024);
+    code = VbeReallySetWindow(vi, 0, winnum);
+    if(code < 0) {
+	ErrorF("Couldn't set window A to %d*%d\n", 
+	       (int)winnum, (int)vbe->vmib.WinGranularity);
+	return NULL;
+    }
+    vbe->windowA_offset = winnum * vbe->vmib.WinGranularity * 1024;
+windowA:
+    vbe->last_window = 0;
+    *size_return = vbe->vmib.WinSize * 1024 - (offset - vbe->windowA_offset);
+    return ((U8*)&(LM(vi, MAKE_POINTER(vbe->vmib.WinASegment, 0)))) + offset - vbe->windowA_offset;
+
+set_windowB:
+    winnum = offset / (vbe->vmib.WinGranularity * 1024);
+    code = VbeReallySetWindow(vi, 1, winnum);
+    if(code < 0) {
+	ErrorF("Couldn't set window B to %d*%d\n", 
+	       (int)winnum, (int)vbe->vmib.WinGranularity);
+	return NULL;
+    }
+    vbe->windowB_offset = winnum * vbe->vmib.WinGranularity * 1024;
+windowB:
+    vbe->last_window = 1;
+    *size_return = vbe->vmib.WinSize * 1024 - (offset - vbe->windowB_offset);
+    return ((U8*)&(LM(vi, MAKE_POINTER(vbe->vmib.WinBSegment, 0)))) + offset - vbe->windowB_offset;
+}
+
+static const int VbeDPMSModes[4] = {
+    0x00,	    /* KD_DPMS_NORMAL */
+    0x01,	    /* KD_DPMS_STANDBY */
+    0x02,	    /* KD_DPMS_SUSPEND */
+    0x04,	    /* KD_DPMS_POWERDOWN */
+};
+
+Bool
+VbeDPMS(Vm86InfoPtr vi, int mode)
+{
+    int		    code;
+
+    /*
+     * Check which modes are supported
+     */
+    vi->vms.regs.eax = 0x4f10;
+    vi->vms.regs.ebx = 0x0000;
+    vi->vms.regs.es = 0;
+    vi->vms.regs.edi = 0;
+    code = VbeDoInterrupt10 (vi);
+    if (code < 0)
+    {
+	ErrorF ("No DPMS Support %d\n", code);
+	return FALSE;
+    }
+    /* Skip this stage if it's not supported */
+    if (((vi->vms.regs.ebx >> 4) & VbeDPMSModes[mode]) != VbeDPMSModes[mode])
+	return FALSE;
+    
+    /* Select this mode */
+    vi->vms.regs.eax = 0x4f10;
+    vi->vms.regs.ebx = (VbeDPMSModes[mode] << 8) | 0x01;
+    code = VbeDoInterrupt10 (vi);
+    if (code < 0)
+    {
+	ErrorF ("DPMS failed %d\n", code);
+	return FALSE;
+    }
+    
+    return TRUE;
+}
+
+Bool
+VbeBoot(Vm86InfoPtr vi)
+{
+    int	code;
+    int bus = 1;
+    int device = 0;
+    int function = 0;
+
+    vi->vms.regs.eax = (bus << 8) | (device << 3) | (function & 0x7);
+    code = VbeDoInterruptE6 (vi);
+    ErrorF ("Boot: %d\n", code);
+    return TRUE;
+}
+
+int
+VbeDoInterrupt10(Vm86InfoPtr vi)
+{
+    int code;
+    int oldax;
+
+    oldax = vi->vms.regs.eax & 0xFFFF;
+
+    code = Vm86DoInterrupt(vi, 0x10);
+    if(code < 0)
+	return -1;
+
+    if((vi->vms.regs.eax & 0xFFFF) != 0x4F && (oldax & 0xFF00) == 0x4F00) {
+	ErrorF("Int 10h (0x%04X) failed: 0x%04X",
+	       oldax, vi->vms.regs.eax & 0xFFFF);
+	if((oldax & 0xFF00) == 0x4F00) {
+	    switch((vi->vms.regs.eax & 0xFF00)>>8) {
+	    case 0: 
+		ErrorF(" (success)\n"); 
+		return 0;
+	    case 1: 
+		ErrorF(" (function call failed)\n"); 
+		break;
+	    case 2: 
+		ErrorF(" (function not supported on this hardware)\n"); 
+		break;
+	    case 3: 
+		ErrorF(" (function call invalid in this video mode)\n"); 
+		break;
+	    default: 
+		ErrorF(" (unknown error)\n"); 
+		break;
+	    }	    return -1;
+	} else {
+	    ErrorF("\n");
+	}
+    }
+    return code;
+}
+
+int
+VbeDoInterruptE6(Vm86InfoPtr vi)
+{
+    int code;
+    int oldax;
+
+    oldax = vi->vms.regs.eax & 0xffff;
+    
+    code = Vm86DoPOST (vi);
+    ErrorF("POST (0x%04X): 0x%04X\n",
+	   oldax, vi->vms.regs.eax & 0xffff);
+    return code;
+}