frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xserver/hw/kdrive/vesa/vbe.c

708 lines
17 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.
*/
/* $RCSId: xc/programs/Xserver/hw/kdrive/vesa/vbe.c,v 1.9 2001/05/29 04:54:12 keithp Exp $ */
#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)?"fixed":"switchable",
(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;
}
Reference in New Issue View Git Blame Copy Permalink