no_comment

10 files changed, 2268 insertions, 1 deletions

diff --git a/tools/Makefile b/tools/Makefile
index c76c5fc6d..dc31b6b0d 100644
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -1,9 +1,11 @@
 ROOTDEST    = /export
+RPMS        = $(wildcard $(ROOTDEST)/Mandrake/RPMS/*.rpm)
 BASE        = $(ROOTDEST)/Mandrake/base
 
-ALL = gendepslist rpm2header
 .PHONY: clean install
 
+all: $(BASE)/depslist $(BASE)/hdlist
+
 install:
 	$(MAKE) gendepslist rpm2header
 	install make_mdkinst_stage2 gendepslist rpm2header genhdlist $(ROOTDEST)/misc
diff --git a/tools/ddcprobe/.cvsignore b/tools/ddcprobe/.cvsignore
new file mode 100644
index 000000000..c3c3641f3
--- /dev/null
+++ b/tools/ddcprobe/.cvsignore
@@ -0,0 +1 @@
+ddcxinfos
diff --git a/tools/ddcprobe/Makefile b/tools/ddcprobe/Makefile
new file mode 100644
index 000000000..e2bf84011
--- /dev/null
+++ b/tools/ddcprobe/Makefile
@@ -0,0 +1,18 @@
+CFLAGS=-Wall -O # -g -DDEBUG
+TARGETS=ddcxinfos
+
+ddcxinfos: lrmi.o vesamode.o vbe.o ddcxinfos.o
+
+libvbe.a: lrmi.o vesamode.o vbe.o
+	$(AR) cru $@ $^
+
+#install: $(DESTDIR)/usr/include/vbe.h $(DESTDIR)/usr/lib/libvbe.a
+
+$(DESTDIR)/usr/include/vbe.h:
+	install -m 644 vbe.h $(DESTDIR)/usr/include/vbe.h
+
+$(DESTDIR)/usr/lib/libvbe.a:
+	install -m 644 libvbe.a $(DESTDIR)/usr/lib/libvbe.a
+
+clean:
+	$(RM) $(TARGETS) *.o core
diff --git a/tools/ddcprobe/ddcxinfos.c b/tools/ddcprobe/ddcxinfos.c
new file mode 100644
index 000000000..439bdc75b
--- /dev/null
+++ b/tools/ddcprobe/ddcxinfos.c
@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "vbe.h"
+#include "vesamode.h"
+#ident "$Id$"
+
+#define SQR(x) ((x) * (x))
+
+int main(int argc, char **argv)
+{
+	int i, j;
+	u_int16_t *mode_list;
+	unsigned char hmin, hmax, vmin, vmax;
+	struct vbe_info *vbe_info;
+	struct vbe_edid1_info *edid;
+	struct vbe_modeline *modelines;
+	
+
+	if ((vbe_info = vbe_get_vbe_info()) == NULL) return 1;
+
+	printf("%dKB of video ram\n", vbe_info->memory_size * 64);
+
+	/* List supported standard modes. */
+	for (mode_list = vbe_info->mode_list.list; *mode_list != 0xffff; mode_list++)
+	  for (i = 0; known_vesa_modes[i].x; i++)
+	    if (known_vesa_modes[i].number == *mode_list)
+	      printf("%d %d %d\n", 
+		     known_vesa_modes[i].colors,
+		     known_vesa_modes[i].x,
+		     known_vesa_modes[i].y
+		     );
+	printf("\n");
+
+	if ((edid = vbe_get_edid_info()) == NULL) return 0;
+	if (edid->version == 255 && edid->revision == 255) return 0;
+
+	vbe_get_edid_ranges(edid, &hmin, &hmax, &vmin, &vmax);
+	modelines = vbe_get_edid_modelines(edid);
+
+	printf(hmin ? "%d-%d\n" : "\n", hmin, hmax);
+	printf(vmin ? "%d-%d\n" : "\n", vmin, vmax);
+
+	{ 
+	  double size = sqrt(SQR(edid->max_size_horizontal) + 
+			     SQR(edid->max_size_vertical)) / 2.54;
+	  printf(size ? "%3.2f inches monitor (truly %3.2f')\n" : "\n", size * 1.08, size);
+	}
+
+	for(j=0; modelines && (modelines[j].refresh != 0); j++){
+	  printf("# %dx%d, %1.1f%sHz",
+		 modelines[j].width,
+		 modelines[j].height,
+		 modelines[j].refresh,
+		 modelines[j].interlaced?"i":""
+		 );
+	  if(modelines[j].modeline) {
+	    printf("; hfreq=%f, vfreq=%f\n%s\n",
+		   modelines[j].hfreq,
+		   modelines[j].vfreq,
+		   modelines[j].modeline);
+	  } else printf("\n");
+	}
+	return 0;
+}
diff --git a/tools/ddcprobe/lrmi.c b/tools/ddcprobe/lrmi.c
new file mode 100644
index 000000000..ca8af0a1e
--- /dev/null
+++ b/tools/ddcprobe/lrmi.c
@@ -0,0 +1,911 @@
+/*
+Linux Real Mode Interface - A library of DPMI-like functions for Linux.
+
+Copyright (C) 1998 by Josh Vanderhoof
+
+You are free to distribute and modify this file, as long as you
+do not remove this copyright notice and clearly label modified
+versions as being modified.
+
+This software has NO WARRANTY.  Use it at your own risk.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/io.h>
+#include <asm/vm86.h>
+
+#ifdef USE_LIBC_VM86
+#include <sys/vm86.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lrmi.h"
+
+#define REAL_MEM_BASE 	((void *)0x10000)
+#define REAL_MEM_SIZE 	0x10000
+#define REAL_MEM_BLOCKS 	0x100
+
+struct mem_block
+	{
+	unsigned int size : 20;
+	unsigned int free : 1;
+	};
+
+static struct
+	{
+	int ready;
+	int count;
+	struct mem_block blocks[REAL_MEM_BLOCKS];
+	} mem_info = { 0 };
+
+static int
+real_mem_init(void)
+	{
+	void *m;
+	int fd_zero;
+
+	if (mem_info.ready)
+		return 1;
+
+	fd_zero = open("/dev/zero", O_RDONLY);
+	if (fd_zero == -1)
+		{
+		perror("open /dev/zero");
+		return 0;
+		}
+
+	m = mmap((void *)REAL_MEM_BASE, REAL_MEM_SIZE,
+	 PROT_READ | PROT_WRITE | PROT_EXEC,
+	 MAP_FIXED | MAP_PRIVATE, fd_zero, 0);
+
+	if (m == (void *)-1)
+		{
+		perror("mmap /dev/zero");
+		close(fd_zero);
+		return 0;
+		}
+
+	mem_info.ready = 1;
+	mem_info.count = 1;
+	mem_info.blocks[0].size = REAL_MEM_SIZE;
+	mem_info.blocks[0].free = 1;
+
+	return 1;
+	}
+
+
+static void
+insert_block(int i)
+	{
+	memmove(
+	 mem_info.blocks + i + 1,
+	 mem_info.blocks + i,
+	 (mem_info.count - i) * sizeof(struct mem_block));
+
+	mem_info.count++;
+	}
+
+static void
+delete_block(int i)
+	{
+	mem_info.count--;
+
+	memmove(
+	 mem_info.blocks + i,
+	 mem_info.blocks + i + 1,
+	 (mem_info.count - i) * sizeof(struct mem_block));
+	}
+
+void *
+LRMI_alloc_real(int size)
+	{
+	int i;
+	char *r = (char *)REAL_MEM_BASE;
+
+	if (!mem_info.ready)
+		return NULL;
+
+	if (mem_info.count == REAL_MEM_BLOCKS)
+		return NULL;
+
+	size = (size + 15) & ~15;
+
+	for (i = 0; i < mem_info.count; i++)
+		{
+		if (mem_info.blocks[i].free && size < mem_info.blocks[i].size)
+			{
+			insert_block(i);
+
+			mem_info.blocks[i].size = size;
+			mem_info.blocks[i].free = 0;
+			mem_info.blocks[i + 1].size -= size;
+
+			return (void *)r;
+			}
+
+		r += mem_info.blocks[i].size;
+		}
+
+	return NULL;
+	}
+
+
+void
+LRMI_free_real(void *m)
+	{
+	int i;
+	char *r = (char *)REAL_MEM_BASE;
+
+	if (!mem_info.ready)
+		return;
+
+	i = 0;
+	while (m != (void *)r)
+		{
+		r += mem_info.blocks[i].size;
+		i++;
+		if (i == mem_info.count)
+			return;
+		}
+
+	mem_info.blocks[i].free = 1;
+
+	if (i + 1 < mem_info.count && mem_info.blocks[i + 1].free)
+		{
+		mem_info.blocks[i].size += mem_info.blocks[i + 1].size;
+		delete_block(i + 1);
+		}
+
+	if (i - 1 >= 0 && mem_info.blocks[i - 1].free)
+		{
+		mem_info.blocks[i - 1].size += mem_info.blocks[i].size;
+		delete_block(i);
+		}
+	}
+
+
+#define DEFAULT_VM86_FLAGS 	(IF_MASK | IOPL_MASK)
+#define DEFAULT_STACK_SIZE 	0x1000
+#define RETURN_TO_32_INT 	255
+
+static struct
+	{
+	int ready;
+	unsigned short ret_seg, ret_off;
+	unsigned short stack_seg, stack_off;
+	struct vm86_struct vm;
+	} context = { 0 };
+
+
+static inline void
+set_bit(unsigned int bit, void *array)
+	{
+	unsigned char *a = array;
+
+	a[bit / 8] |= (1 << (bit % 8));
+	}
+
+
+static inline unsigned int
+get_int_seg(int i)
+	{
+	return *(unsigned short *)(i * 4 + 2);
+	}
+
+
+static inline unsigned int
+get_int_off(int i)
+	{
+	return *(unsigned short *)(i * 4);
+	}
+
+
+static inline void
+pushw(unsigned short i)
+	{
+	struct vm86_regs *r = &context.vm.regs;
+	r->esp -= 2;
+	*(unsigned short *)(((unsigned int)r->ss << 4) + r->esp) = i;
+	}
+
+
+int
+LRMI_init(void)
+	{
+	void *m;
+	int fd_mem;
+
+	if (context.ready)
+		return 1;
+
+	if (!real_mem_init())
+		return 0;
+
+	/*
+	 Map the Interrupt Vectors (0x0 - 0x400) + BIOS data (0x400 - 0x502)
+	 and the ROM (0xa0000 - 0x100000)
+	*/
+	fd_mem = open("/dev/mem", O_RDWR);
+
+	if (fd_mem == -1)
+		{
+		perror("open /dev/mem");
+		return 0;
+		}
+
+	m = mmap((void *)0, 0x502,
+	 PROT_READ | PROT_WRITE | PROT_EXEC,
+	 MAP_FIXED | MAP_PRIVATE, fd_mem, 0);
+
+	if (m == (void *)-1)
+		{
+		perror("mmap /dev/mem");
+		return 0;
+		}
+
+	m = mmap((void *)0xa0000, 0x100000 - 0xa0000,
+	 PROT_READ | PROT_WRITE,
+	 MAP_FIXED | MAP_SHARED, fd_mem, 0xa0000);
+
+	if (m == (void *)-1)
+		{
+		perror("mmap /dev/mem");
+		return 0;
+		}
+
+
+	/*
+	 Allocate a stack
+	*/
+	m = LRMI_alloc_real(DEFAULT_STACK_SIZE);
+
+	context.stack_seg = (unsigned int)m >> 4;
+	context.stack_off = DEFAULT_STACK_SIZE;
+
+	/*
+	 Allocate the return to 32 bit routine
+	*/
+	m = LRMI_alloc_real(2);
+
+	context.ret_seg = (unsigned int)m >> 4;
+	context.ret_off = (unsigned int)m & 0xf;
+
+	((unsigned char *)m)[0] = 0xcd; 	/* int opcode */
+	((unsigned char *)m)[1] = RETURN_TO_32_INT;
+
+	memset(&context.vm, 0, sizeof(context.vm));
+
+	/*
+	 Enable kernel emulation of all ints except RETURN_TO_32_INT
+	*/
+	memset(&context.vm.int_revectored, 0, sizeof(context.vm.int_revectored));
+	set_bit(RETURN_TO_32_INT, &context.vm.int_revectored);
+
+	context.ready = 1;
+
+	return 1;
+	}
+
+
+static void
+set_regs(struct LRMI_regs *r)
+	{
+	context.vm.regs.edi = r->edi;
+	context.vm.regs.esi = r->esi;
+	context.vm.regs.ebp = r->ebp;
+	context.vm.regs.ebx = r->ebx;
+	context.vm.regs.edx = r->edx;
+	context.vm.regs.ecx = r->ecx;
+	context.vm.regs.eax = r->eax;
+	context.vm.regs.eflags = DEFAULT_VM86_FLAGS;
+	context.vm.regs.es = r->es;
+	context.vm.regs.ds = r->ds;
+	context.vm.regs.fs = r->fs;
+	context.vm.regs.gs = r->gs;
+	}
+
+
+static void
+get_regs(struct LRMI_regs *r)
+	{
+	r->edi = context.vm.regs.edi;
+	r->esi = context.vm.regs.esi;
+	r->ebp = context.vm.regs.ebp;
+	r->ebx = context.vm.regs.ebx;
+	r->edx = context.vm.regs.edx;
+	r->ecx = context.vm.regs.ecx;
+	r->eax = context.vm.regs.eax;
+	r->flags = context.vm.regs.eflags;
+	r->es = context.vm.regs.es;
+	r->ds = context.vm.regs.ds;
+	r->fs = context.vm.regs.fs;
+	r->gs = context.vm.regs.gs;
+	}
+
+#define DIRECTION_FLAG 	(1 << 10)
+
+static void
+em_ins(int size)
+	{
+	unsigned int edx, edi;
+
+	edx = context.vm.regs.edx & 0xffff;
+	edi = context.vm.regs.edi & 0xffff;
+	edi += (unsigned int)context.vm.regs.ds << 4;
+
+	if (context.vm.regs.eflags & DIRECTION_FLAG)
+		{
+		if (size == 4)
+			asm volatile ("std; insl; cld"
+			 : "=D" (edi) : "d" (edx), "0" (edi));
+		else if (size == 2)
+			asm volatile ("std; insw; cld"
+			 : "=D" (edi) : "d" (edx), "0" (edi));
+		else
+			asm volatile ("std; insb; cld"
+			 : "=D" (edi) : "d" (edx), "0" (edi));
+		}
+	else
+		{
+		if (size == 4)
+			asm volatile ("cld; insl"
+			 : "=D" (edi) : "d" (edx), "0" (edi));
+		else if (size == 2)
+			asm volatile ("cld; insw"
+			 : "=D" (edi) : "d" (edx), "0" (edi));
+		else
+			asm volatile ("cld; insb"
+			 : "=D" (edi) : "d" (edx), "0" (edi));
+		}
+
+	edi -= (unsigned int)context.vm.regs.ds << 4;
+
+	context.vm.regs.edi &= 0xffff0000;
+	context.vm.regs.edi |= edi & 0xffff;
+	}
+
+static void
+em_rep_ins(int size)
+	{
+	unsigned int ecx, edx, edi;
+
+	ecx = context.vm.regs.ecx & 0xffff;
+	edx = context.vm.regs.edx & 0xffff;
+	edi = context.vm.regs.edi & 0xffff;
+	edi += (unsigned int)context.vm.regs.ds << 4;
+
+	if (context.vm.regs.eflags & DIRECTION_FLAG)
+		{
+		if (size == 4)
+			asm volatile ("std; rep; insl; cld"
+			 : "=D" (edi), "=c" (ecx)
+			 : "d" (edx), "0" (edi), "1" (ecx));
+		else if (size == 2)
+			asm volatile ("std; rep; insw; cld"
+			 : "=D" (edi), "=c" (ecx)
+			 : "d" (edx), "0" (edi), "1" (ecx));
+		else
+			asm volatile ("std; rep; insb; cld"
+			 : "=D" (edi), "=c" (ecx)
+			 : "d" (edx), "0" (edi), "1" (ecx));
+		}
+	else
+		{
+		if (size == 4)
+			asm volatile ("cld; rep; insl"
+			 : "=D" (edi), "=c" (ecx)
+			 : "d" (edx), "0" (edi), "1" (ecx));
+		else if (size == 2)
+			asm volatile ("cld; rep; insw"
+			 : "=D" (edi), "=c" (ecx)
+			 : "d" (edx), "0" (edi), "1" (ecx));
+		else
+			asm volatile ("cld; rep; insb"
+			 : "=D" (edi), "=c" (ecx)
+			 : "d" (edx), "0" (edi), "1" (ecx));
+		}
+
+	edi -= (unsigned int)context.vm.regs.ds << 4;
+
+	context.vm.regs.edi &= 0xffff0000;
+	context.vm.regs.edi |= edi & 0xffff;
+
+	context.vm.regs.ecx &= 0xffff0000;
+	context.vm.regs.ecx |= ecx & 0xffff;
+	}
+
+static void
+em_outs(int size)
+	{
+	unsigned int edx, esi;
+
+	edx = context.vm.regs.edx & 0xffff;
+	esi = context.vm.regs.esi & 0xffff;
+	esi += (unsigned int)context.vm.regs.ds << 4;
+
+	if (context.vm.regs.eflags & DIRECTION_FLAG)
+		{
+		if (size == 4)
+			asm volatile ("std; outsl; cld"
+			 : "=S" (esi) : "d" (edx), "0" (esi));
+		else if (size == 2)
+			asm volatile ("std; outsw; cld"
+			 : "=S" (esi) : "d" (edx), "0" (esi));
+		else
+			asm volatile ("std; outsb; cld"
+			 : "=S" (esi) : "d" (edx), "0" (esi));
+		}
+	else
+		{
+		if (size == 4)
+			asm volatile ("cld; outsl"
+			 : "=S" (esi) : "d" (edx), "0" (esi));
+		else if (size == 2)
+			asm volatile ("cld; outsw"
+			 : "=S" (esi) : "d" (edx), "0" (esi));
+		else
+			asm volatile ("cld; outsb"
+			 : "=S" (esi) : "d" (edx), "0" (esi));
+		}
+
+	esi -= (unsigned int)context.vm.regs.ds << 4;
+
+	context.vm.regs.esi &= 0xffff0000;
+	context.vm.regs.esi |= esi & 0xffff;
+	}
+
+static void
+em_rep_outs(int size)
+	{
+	unsigned int ecx, edx, esi;
+
+	ecx = context.vm.regs.ecx & 0xffff;
+	edx = context.vm.regs.edx & 0xffff;
+	esi = context.vm.regs.esi & 0xffff;
+	esi += (unsigned int)context.vm.regs.ds << 4;
+
+	if (context.vm.regs.eflags & DIRECTION_FLAG)
+		{
+		if (size == 4)
+			asm volatile ("std; rep; outsl; cld"
+			 : "=S" (esi), "=c" (ecx)
+			 : "d" (edx), "0" (esi), "1" (ecx));
+		else if (size == 2)
+			asm volatile ("std; rep; outsw; cld"
+			 : "=S" (esi), "=c" (ecx)
+			 : "d" (edx), "0" (esi), "1" (ecx));
+		else
+			asm volatile ("std; rep; outsb; cld"
+			 : "=S" (esi), "=c" (ecx)
+			 : "d" (edx), "0" (esi), "1" (ecx));
+		}
+	else
+		{
+		if (size == 4)
+			asm volatile ("cld; rep; outsl"
+			 : "=S" (esi), "=c" (ecx)
+			 : "d" (edx), "0" (esi), "1" (ecx));
+		else if (size == 2)
+			asm volatile ("cld; rep; outsw"
+			 : "=S" (esi), "=c" (ecx)
+			 : "d" (edx), "0" (esi), "1" (ecx));
+		else
+			asm volatile ("cld; rep; outsb"
+			 : "=S" (esi), "=c" (ecx)
+			 : "d" (edx), "0" (esi), "1" (ecx));
+		}
+
+	esi -= (unsigned int)context.vm.regs.ds << 4;
+
+	context.vm.regs.esi &= 0xffff0000;
+	context.vm.regs.esi |= esi & 0xffff;
+
+	context.vm.regs.ecx &= 0xffff0000;
+	context.vm.regs.ecx |= ecx & 0xffff;
+	}
+
+static void
+em_inbl(unsigned char literal)
+	{
+	context.vm.regs.eax = inb(literal) & 0xff;
+	}
+
+static void
+em_inb(void)
+	{
+	asm volatile ("inb (%w1), %b0"
+	 : "=a" (context.vm.regs.eax)
+	 : "d" (context.vm.regs.edx), "0" (context.vm.regs.eax));
+	}
+
+static void
+em_inw(void)
+	{
+	asm volatile ("inw (%w1), %w0"
+	 : "=a" (context.vm.regs.eax)
+	 : "d" (context.vm.regs.edx), "0" (context.vm.regs.eax));
+	}
+
+static void
+em_inl(void)
+	{
+	asm volatile ("inl (%w1), %0"
+	 : "=a" (context.vm.regs.eax)
+	 : "d" (context.vm.regs.edx));
+	}
+
+static void
+em_outbl(unsigned char literal)
+	{
+	outb(context.vm.regs.eax & 0xff, literal);
+	}
+
+static void
+em_outb(void)
+	{
+	asm volatile ("outb %b0, (%w1)"
+	 : : "a" (context.vm.regs.eax),
+	 "d" (context.vm.regs.edx));
+	}
+
+static void
+em_outw(void)
+	{
+	asm volatile ("outw %w0, (%w1)"
+	 : : "a" (context.vm.regs.eax),
+	 "d" (context.vm.regs.edx));
+	}
+
+static void
+em_outl(void)
+	{
+	asm volatile ("outl %0, (%w1)"
+	 : : "a" (context.vm.regs.eax),
+	 "d" (context.vm.regs.edx));
+	}
+
+static int
+emulate(void)
+	{
+	unsigned char *insn;
+	struct
+		{
+		unsigned int size : 1;
+		unsigned int rep : 1;
+		} prefix = { 0, 0 };
+	int i = 0;
+
+	insn = (unsigned char *)((unsigned int)context.vm.regs.cs << 4);
+	insn += context.vm.regs.eip;
+
+	while (1)
+		{
+		if (insn[i] == 0x66)
+			{
+			prefix.size = 1 - prefix.size;
+			i++;
+			}
+		else if (insn[i] == 0xf3)
+			{
+			prefix.rep = 1;
+			i++;
+			}
+		else if (insn[i] == 0xf0 || insn[i] == 0xf2
+		 || insn[i] == 0x26 || insn[i] == 0x2e
+		 || insn[i] == 0x36 || insn[i] == 0x3e
+		 || insn[i] == 0x64 || insn[i] == 0x65
+		 || insn[i] == 0x67)
+			{
+			/* these prefixes are just ignored */
+			i++;
+			}
+		else if (insn[i] == 0x6c)
+			{
+			if (prefix.rep)
+				em_rep_ins(1);
+			else
+				em_ins(1);
+			i++;
+			break;
+			}
+		else if (insn[i] == 0x6d)
+			{
+			if (prefix.rep)
+				{
+				if (prefix.size)
+					em_rep_ins(4);
+				else
+					em_rep_ins(2);
+				}
+			else
+				{
+				if (prefix.size)
+					em_ins(4);
+				else
+					em_ins(2);
+				}
+			i++;
+			break;
+			}
+		else if (insn[i] == 0x6e)
+			{
+			if (prefix.rep)
+				em_rep_outs(1);
+			else
+				em_outs(1);
+			i++;
+			break;
+			}
+		else if (insn[i] == 0x6f)
+			{
+			if (prefix.rep)
+				{
+				if (prefix.size)
+					em_rep_outs(4);
+				else
+					em_rep_outs(2);
+				}
+			else
+				{
+				if (prefix.size)
+					em_outs(4);
+				else
+					em_outs(2);
+				}
+			i++;
+			break;
+			}
+		else if (insn[i] == 0xe4)
+			{
+			em_inbl(insn[i + 1]);
+			i += 2;
+			break;
+			}
+		else if (insn[i] == 0xe6)
+			{
+			em_outbl(insn[i + 1]);
+			i += 2;
+			break;
+			}
+		else if (insn[i] == 0xec)
+			{
+			em_inb();
+			i++;
+			break;
+			}
+		else if (insn[i] == 0xed)
+			{
+			if (prefix.size)
+				em_inl();
+			else
+				em_inw();
+			i++;
+			break;
+			}
+		else if (insn[i] == 0xee)
+			{
+			em_outb();
+			i++;
+			break;
+			}
+		else if (insn[i] == 0xef)
+			{
+			if (prefix.size)
+				em_outl();
+			else
+				em_outw();
+
+			i++;
+			break;
+			}
+		else
+			return 0;
+		}
+
+	context.vm.regs.eip += i;
+	return 1;
+	}
+
+
+/*
+ I don't know how to make sure I get the right vm86() from libc.
+ The one I want is syscall # 113 (vm86old() in libc 5, vm86() in glibc)
+ which should be declared as "int vm86(struct vm86_struct *);" in
+ <sys/vm86.h>.
+
+ This just does syscall 113 with inline asm, which should work
+ for both libc's (I hope).
+*/
+#if !defined(USE_LIBC_VM86)
+static int
+lrmi_vm86(struct vm86_struct *vm)
+	{
+	int r;
+#ifdef __PIC__
+	asm volatile (
+	 "pushl %%ebx\n\t"
+	 "movl %2, %%ebx\n\t"
+	 "int $0x80\n\t"
+	 "popl %%ebx"
+	 : "=a" (r)
+	 : "0" (113), "r" (vm));
+#else
+	asm volatile (
+	 "int $0x80"
+	 : "=a" (r)
+	 : "0" (113), "b" (vm));
+#endif
+	return r;
+	}
+#else
+#define lrmi_vm86 vm86
+#endif
+
+
+static void
+debug_info(int vret)
+	{
+	int i;
+	unsigned char *p;
+
+	fputs("vm86() failed\n", stderr);
+	fprintf(stderr, "return = 0x%x\n", vret);
+	fprintf(stderr, "eax = 0x%08lx\n", context.vm.regs.eax);
+	fprintf(stderr, "ebx = 0x%08lx\n", context.vm.regs.ebx);
+	fprintf(stderr, "ecx = 0x%08lx\n", context.vm.regs.ecx);
+	fprintf(stderr, "edx = 0x%08lx\n", context.vm.regs.edx);
+	fprintf(stderr, "esi = 0x%08lx\n", context.vm.regs.esi);
+	fprintf(stderr, "edi = 0x%08lx\n", context.vm.regs.edi);
+	fprintf(stderr, "ebp = 0x%08lx\n", context.vm.regs.ebp);
+	fprintf(stderr, "eip = 0x%08lx\n", context.vm.regs.eip);
+	fprintf(stderr, "cs  = 0x%04x\n", context.vm.regs.cs);
+	fprintf(stderr, "esp = 0x%08lx\n", context.vm.regs.esp);
+	fprintf(stderr, "ss  = 0x%04x\n", context.vm.regs.ss);
+	fprintf(stderr, "ds  = 0x%04x\n", context.vm.regs.ds);
+	fprintf(stderr, "es  = 0x%04x\n", context.vm.regs.es);
+	fprintf(stderr, "fs  = 0x%04x\n", context.vm.regs.fs);
+	fprintf(stderr, "gs  = 0x%04x\n", context.vm.regs.gs);
+	fprintf(stderr, "eflags  = 0x%08lx\n", context.vm.regs.eflags);
+
+	fputs("cs:ip = [ ", stderr);
+
+	p = (unsigned char *)((context.vm.regs.cs << 4) + (context.vm.regs.eip & 0xffff));
+
+	for (i = 0; i < 16; ++i)
+		fprintf(stderr, "%02x ", (unsigned int)p[i]);
+
+	fputs("]\n", stderr);
+	}
+
+
+static int
+run_vm86(void)
+	{
+	unsigned int vret;
+
+	while (1)
+		{
+		vret = lrmi_vm86(&context.vm);
+
+		if (VM86_TYPE(vret) == VM86_INTx)
+			{
+			unsigned int v = VM86_ARG(vret);
+
+			if (v == RETURN_TO_32_INT)
+				return 1;
+
+			pushw(context.vm.regs.eflags);
+			pushw(context.vm.regs.cs);
+			pushw(context.vm.regs.eip);
+
+			context.vm.regs.cs = get_int_seg(v);
+			context.vm.regs.eip = get_int_off(v);
+			context.vm.regs.eflags &= ~(VIF_MASK | TF_MASK);
+
+			continue;
+			}
+
+		if (VM86_TYPE(vret) != VM86_UNKNOWN)
+			break;
+
+		if (!emulate())
+			break;
+		}
+
+#ifdef ORIGINAL_LRMI_CODE_THAT_GOT_IFDEFED_OUT
+	debug_info(vret);
+#endif
+	return 0;
+	}
+
+
+int
+LRMI_call(struct LRMI_regs *r)
+	{
+	unsigned int vret;
+
+	memset(&context.vm.regs, 0, sizeof(context.vm.regs));
+
+	set_regs(r);
+
+	context.vm.regs.cs = r->cs;
+	context.vm.regs.eip = r->ip;
+
+	if (r->ss == 0 && r->sp == 0)
+		{
+		context.vm.regs.ss = context.stack_seg;
+		context.vm.regs.esp = context.stack_off;
+		}
+	else
+		{
+		context.vm.regs.ss = r->ss;
+		context.vm.regs.esp = r->sp;
+		}
+
+	pushw(context.ret_seg);
+	pushw(context.ret_off);
+
+	vret = run_vm86();
+
+	get_regs(r);
+
+	return vret;
+	}
+
+
+int
+LRMI_int(int i, struct LRMI_regs *r)
+	{
+	unsigned int vret;
+	unsigned int seg, off;
+
+	seg = get_int_seg(i);
+	off = get_int_off(i);
+
+	/*
+	 If the interrupt is in regular memory, it's probably
+	 still pointing at a dos TSR (which is now gone).
+	*/
+	if (seg < 0xa000 || (seg << 4) + off >= 0x100000)
+		{
+#ifdef ORIGINAL_LRMI_CODE_THAT_GOT_IFDEFED_OUT
+		fprintf(stderr, "Int 0x%x is not in rom (%04x:%04x)\n", i, seg, off);
+#endif
+		return 0;
+		}
+
+	memset(&context.vm.regs, 0, sizeof(context.vm.regs));
+
+	set_regs(r);
+
+	context.vm.regs.cs = seg;
+	context.vm.regs.eip = off;
+
+	if (r->ss == 0 && r->sp == 0)
+		{
+		context.vm.regs.ss = context.stack_seg;
+		context.vm.regs.esp = context.stack_off;
+		}
+	else
+		{
+		context.vm.regs.ss = r->ss;
+		context.vm.regs.esp = r->sp;
+		}
+
+	pushw(DEFAULT_VM86_FLAGS);
+	pushw(context.ret_seg);
+	pushw(context.ret_off);
+
+	vret = run_vm86();
+
+	get_regs(r);
+
+	return vret;
+	}
+
diff --git a/tools/ddcprobe/lrmi.h b/tools/ddcprobe/lrmi.h
new file mode 100644
index 000000000..c9c186365
--- /dev/null
+++ b/tools/ddcprobe/lrmi.h
@@ -0,0 +1,85 @@
+/*
+Linux Real Mode Interface - A library of DPMI-like functions for Linux.
+
+Copyright (C) 1998 by Josh Vanderhoof
+
+You are free to distribute and modify this file, as long as you
+do not remove this copyright notice and clearly label modified
+versions as being modified.
+
+This software has NO WARRANTY.  Use it at your own risk.
+*/
+
+#ifndef LRMI_H
+#define LRMI_H
+
+struct LRMI_regs
+	{
+	unsigned int edi;
+	unsigned int esi;
+	unsigned int ebp;
+	unsigned int reserved;
+	unsigned int ebx;
+	unsigned int edx;
+	unsigned int ecx;
+	unsigned int eax;
+	unsigned short int flags;
+	unsigned short int es;
+	unsigned short int ds;
+	unsigned short int fs;
+	unsigned short int gs;
+	unsigned short int ip;
+	unsigned short int cs;
+	unsigned short int sp;
+	unsigned short int ss;
+	};
+
+
+#ifndef LRMI_PREFIX
+#define LRMI_PREFIX LRMI_
+#endif
+
+#define LRMI_CONCAT2(a, b) 	a ## b
+#define LRMI_CONCAT(a, b) 	LRMI_CONCAT2(a, b)
+#define LRMI_MAKENAME(a) 	LRMI_CONCAT(LRMI_PREFIX, a)
+
+/*
+ Initialize
+ returns 1 if sucessful, 0 for failure
+*/
+#define LRMI_init LRMI_MAKENAME(init)
+int
+LRMI_init(void);
+
+/*
+ Simulate a 16 bit far call
+ returns 1 if sucessful, 0 for failure
+*/
+#define LRMI_call LRMI_MAKENAME(call)
+int
+LRMI_call(struct LRMI_regs *r);
+
+/*
+ Simulate a 16 bit interrupt
+ returns 1 if sucessful, 0 for failure
+*/
+#define LRMI_int LRMI_MAKENAME(int)
+int
+LRMI_int(int interrupt, struct LRMI_regs *r);
+
+/*
+ Allocate real mode memory
+ The returned block is paragraph (16 byte) aligned
+*/
+#define LRMI_alloc_real LRMI_MAKENAME(alloc_real)
+void *
+LRMI_alloc_real(int size);
+
+/*
+ Free real mode memory
+*/
+#define LRMI_free_real LRMI_MAKENAME(free_real)
+void
+LRMI_free_real(void *m);
+
+#endif
diff --git a/tools/ddcprobe/vbe.c b/tools/ddcprobe/vbe.c
new file mode 100644
index 000000000..a67e56d0b
--- /dev/null
+++ b/tools/ddcprobe/vbe.c
@@ -0,0 +1,709 @@
+#include <sys/types.h>
+#include <sys/io.h>
+#include <sys/mman.h>
+#include <netinet/in.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <limits.h>
+#include <ctype.h>
+#include "lrmi.h"
+#include "vesamode.h"
+#include "vbe.h"
+#ident "$Id$"
+
+/* Return information about a particular video mode. */
+struct vbe_mode_info *vbe_get_mode_info(u_int16_t mode)
+{
+	struct LRMI_regs regs;
+	char *mem;
+	struct vbe_mode_info *ret = NULL;
+
+	/* Initialize LRMI. */
+	if(LRMI_init() == 0) {
+		return NULL;
+	}
+
+	/* Allocate a chunk of memory. */
+	mem = LRMI_alloc_real(sizeof(struct vbe_mode_info));
+	if(mem == NULL) {
+		return NULL;
+	}
+	memset(mem, 0, sizeof(struct vbe_mode_info));
+
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f01;
+	regs.ecx = mode;
+	regs.es = ((u_int32_t)mem) >> 4;
+	regs.edi = ((u_int32_t)mem) & 0x0f;
+
+	/* Do it. */
+	iopl(3);
+	ioperm(0, 0x400, 1);
+
+	if(LRMI_int(0x10, &regs) == 0) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+
+	/* Check for successful return. */
+	if((regs.eax & 0xffff) != 0x004f) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+
+	/* Get memory for return. */
+	ret = malloc(sizeof(struct vbe_mode_info));
+	if(ret == NULL) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+
+	/* Copy the buffer for return. */
+	memcpy(ret, mem, sizeof(struct vbe_mode_info));
+
+	/* Clean up and return. */
+	LRMI_free_real(mem);
+	return ret;
+}
+
+/* Get VBE info. */
+struct vbe_info *vbe_get_vbe_info()
+{
+	struct LRMI_regs regs;
+	unsigned char *mem;
+	struct vbe_info *ret = NULL;
+	int i;
+
+	/* Initialize LRMI. */
+	if(LRMI_init() == 0) {
+		return NULL;
+	}
+
+	/* Allocate a chunk of memory. */
+	mem = LRMI_alloc_real(sizeof(struct vbe_mode_info));
+	if(mem == NULL) {
+		return NULL;
+	}
+	memset(mem, 0, sizeof(struct vbe_mode_info));
+
+	/* Set up registers for the interrupt call. */
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f00;
+	regs.es = ((u_int32_t)mem) >> 4;
+	regs.edi = ((u_int32_t)mem) & 0x0f;
+	memcpy(mem, "VBE2", 4);
+
+	/* Do it. */
+	iopl(3);
+	ioperm(0, 0x400, 1);
+
+	if(LRMI_int(0x10, &regs) == 0) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+
+	/* Check for successful return code. */
+	if((regs.eax & 0xffff) != 0x004f) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+
+	/* Get memory to return the information. */
+	ret = malloc(sizeof(struct vbe_info));
+	if(ret == NULL) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+	memcpy(ret, mem, sizeof(struct vbe_info));
+
+	/* Set up pointers to usable memory. */
+	ret->mode_list.list = (u_int16_t*) ((ret->mode_list.addr.seg << 4) +
+					    (ret->mode_list.addr.ofs));
+	ret->oem_name.string = (char*) ((ret->oem_name.addr.seg << 4) +
+					(ret->oem_name.addr.ofs));
+
+	/* Snip, snip. */
+	mem = strdup(ret->oem_name.string); /* leak */
+	while(((i = strlen(mem)) > 0) && isspace(mem[i - 1])) {
+		mem[i - 1] = '\0';
+	}
+	ret->oem_name.string = mem;
+
+	/* Set up pointers for VESA 3.0+ strings. */
+	if(ret->version[1] >= 3) {
+
+		/* Vendor name. */
+		ret->vendor_name.string = (char*)
+			 ((ret->vendor_name.addr.seg << 4)
+			+ (ret->vendor_name.addr.ofs));
+
+		mem = strdup(ret->vendor_name.string); /* leak */
+		while(((i = strlen(mem)) > 0) && isspace(mem[i - 1])) {
+			mem[i - 1] = '\0';
+		}
+		ret->vendor_name.string = mem;
+
+		/* Product name. */
+		ret->product_name.string = (char*)
+			 ((ret->product_name.addr.seg << 4)
+			+ (ret->product_name.addr.ofs));
+
+		mem = strdup(ret->product_name.string); /* leak */
+		while(((i = strlen(mem)) > 0) && isspace(mem[i - 1])) {
+			mem[i - 1] = '\0';
+		}
+		ret->product_name.string = mem;
+
+		/* Product revision. */
+		ret->product_revision.string = (char*)
+			 ((ret->product_revision.addr.seg << 4)
+			+ (ret->product_revision.addr.ofs));
+
+		mem = strdup(ret->product_revision.string); /* leak */
+		while(((i = strlen(mem)) > 0) && isspace(mem[i - 1])) {
+			mem[i - 1] = '\0';
+		}
+		ret->product_revision.string = mem;
+	}
+
+	/* Cleanup. */
+	LRMI_free_real(mem);
+	return ret;
+}
+
+/* Check if EDID queries are suorted. */
+int vbe_get_edid_supported()
+{
+	struct LRMI_regs regs;
+	int ret = 0;
+
+	/* Initialize LRMI. */
+	if(LRMI_init() == 0) {
+		return 0;
+	}
+
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f15;
+	regs.ebx = 0x0000;
+	regs.es = 0x3000;
+	regs.edi = 0x3000;
+
+	/* Do it. */
+	iopl(3);
+	ioperm(0, 0x400, 1);
+
+	if(LRMI_int(0x10, &regs) == 0) {
+		return 0;
+	}
+
+	/* Check for successful return. */
+	if((regs.eax & 0xff) == 0x4f) {
+		/* Supported. */
+		ret = 1;
+	} else {
+		/* Not supported. */
+		ret = 0;
+	}
+
+	/* Clean up and return. */
+	return ret;
+}
+
+/* Get EDID info. */
+struct vbe_edid1_info *vbe_get_edid_info()
+{
+	struct LRMI_regs regs;
+	unsigned char *mem;
+	struct vbe_edid1_info *ret = NULL;
+	u_int16_t man;
+
+	/* Initialize LRMI. */
+	if(LRMI_init() == 0) {
+		return NULL;
+	}
+
+	/* Allocate a chunk of memory. */
+	mem = LRMI_alloc_real(sizeof(struct vbe_edid1_info));
+	if(mem == NULL) {
+		return NULL;
+	}
+	memset(mem, 0, sizeof(struct vbe_edid1_info));
+
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f15;
+	regs.ebx = 0x0001;
+	regs.es = ((u_int32_t)mem) >> 4;
+	regs.edi = ((u_int32_t)mem) & 0x0f;
+
+	/* Do it. */
+	iopl(3);
+	ioperm(0, 0x400, 1);
+
+	if(LRMI_int(0x10, &regs) == 0) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+
+#if 0
+	/* Check for successful return. */
+	if((regs.eax & 0xffff) != 0x004f) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+#elseif
+	/* Check for successful return. */
+	if((regs.eax & 0xff) != 0x4f) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+#endif
+
+	/* Get memory for return. */
+	ret = malloc(sizeof(struct vbe_edid1_info));
+	if(ret == NULL) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+
+	/* Copy the buffer for return. */
+	memcpy(ret, mem, sizeof(struct vbe_edid1_info));
+
+	memcpy(&man, &ret->manufacturer_name, 2);
+	man = ntohs(man);
+	memcpy(&ret->manufacturer_name, &man, 2);
+
+	LRMI_free_real(mem);
+	return ret;
+}
+
+/* Figure out what the current video mode is. */
+int32_t vbe_get_mode()
+{
+	struct LRMI_regs regs;
+	int32_t ret = -1;
+
+	/* Initialize LRMI. */
+	if(LRMI_init() == 0) {
+		return -1;
+	}
+
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f03;
+
+	/* Do it. */
+	iopl(3);
+	ioperm(0, 0x400, 1);
+
+	if(LRMI_int(0x10, &regs) == 0) {
+		return -1;
+	}
+
+	/* Save the returned value. */
+	if((regs.eax & 0xffff) == 0x004f) {
+		ret = regs.ebx & 0xffff;
+	} else {
+		ret = -1;
+	}
+
+	/* Clean up and return. */
+	return ret;
+}
+
+/* Set the video mode. */
+void vbe_set_mode(u_int16_t mode)
+{
+	struct LRMI_regs regs;
+
+	/* Initialize LRMI. */
+	if(LRMI_init() == 0) {
+		return;
+	}
+
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f02;
+	regs.ebx = mode;
+
+	/* Do it. */
+	iopl(3);
+	ioperm(0, 0x400, 1);
+	LRMI_int(0x10, &regs);
+
+	/* Return. */
+	return;
+}
+
+/* Just read ranges from the EDID. */
+void vbe_get_edid_ranges(struct vbe_edid1_info *edid,
+			 unsigned char *hmin, unsigned char *hmax,
+			 unsigned char *vmin, unsigned char *vmax)
+{
+	struct vbe_edid_monitor_descriptor *monitor;
+	int i;
+
+	*hmin = *hmax = *vmin = *vmax = 0;
+
+	for(i = 0; i < 4; i++) {
+		monitor = &edid->monitor_details.monitor_descriptor[i];
+		if(monitor->type == vbe_edid_monitor_descriptor_range) {
+			*hmin = monitor->data.range_data.horizontal_min;
+			*hmax = monitor->data.range_data.horizontal_max;
+			*vmin = monitor->data.range_data.vertical_min;
+			*vmax = monitor->data.range_data.vertical_max;
+		}
+	}
+}
+
+static int compare_vbe_modelines(const void *m1, const void *m2)
+{
+	const struct vbe_modeline *M1 = (const struct vbe_modeline*) m1;
+	const struct vbe_modeline *M2 = (const struct vbe_modeline*) m2;
+	if(M1->width < M2->width) return -1;
+	if(M1->width > M2->width) return 1;
+	return 0;
+}
+
+struct vbe_modeline *vbe_get_edid_modelines()
+{
+	struct vbe_edid1_info *edid;
+	struct vbe_modeline *ret;
+	char buf[LINE_MAX];
+	int modeline_count = 0, i, j;
+
+	if((edid = vbe_get_edid_info()) == NULL) {
+		return NULL;
+	}
+
+	memcpy(buf, &edid->established_timings,
+	       sizeof(edid->established_timings));
+	for(i = 0; i < (8 * sizeof(edid->established_timings)); i++) {
+		if(buf[i / 8] & (1 << (i % 8))) {
+			modeline_count++;
+		}
+	}
+
+	/* Count the number of standard timings. */
+	for(i = 0; i < 8; i++) {
+		int x, v;
+		x = edid->standard_timing[i].xresolution;
+		v = edid->standard_timing[i].vfreq;
+		if(((edid->standard_timing[i].xresolution & 0x01) != x) &&
+		   ((edid->standard_timing[i].vfreq & 0x01) != v)) {
+			modeline_count++;
+		}
+	}
+
+	ret = malloc(sizeof(struct vbe_modeline) * (modeline_count + 1));
+	if(ret == NULL) {
+		return NULL;
+	}
+	memset(ret, 0, sizeof(struct vbe_modeline) * (modeline_count + 1));
+
+	modeline_count = 0;
+
+	/* Fill out established timings. */
+	if(edid->established_timings.timing_720x400_70) {
+		ret[modeline_count].width = 720;
+		ret[modeline_count].height = 400;
+		ret[modeline_count].refresh = 70;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_720x400_88) {
+		ret[modeline_count].width = 720;
+		ret[modeline_count].height = 400;
+		ret[modeline_count].refresh = 88;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_640x480_60) {
+		ret[modeline_count].width = 640;
+		ret[modeline_count].height = 480;
+		ret[modeline_count].refresh = 60;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_640x480_67) {
+		ret[modeline_count].width = 640;
+		ret[modeline_count].height = 480;
+		ret[modeline_count].refresh = 67;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_640x480_72) {
+		ret[modeline_count].width = 640;
+		ret[modeline_count].height = 480;
+		ret[modeline_count].refresh = 72;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_640x480_75) {
+		ret[modeline_count].width = 640;
+		ret[modeline_count].height = 480;
+		ret[modeline_count].refresh = 75;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_800x600_56) {
+		ret[modeline_count].width = 800;
+		ret[modeline_count].height = 600;
+		ret[modeline_count].refresh = 56;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_800x600_60) {
+		ret[modeline_count].width = 800;
+		ret[modeline_count].height = 600;
+		ret[modeline_count].refresh = 60;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_800x600_72) {
+		ret[modeline_count].width = 800;
+		ret[modeline_count].height = 600;
+		ret[modeline_count].refresh = 72;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_800x600_75) {
+		ret[modeline_count].width = 800;
+		ret[modeline_count].height = 600;
+		ret[modeline_count].refresh = 75;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_832x624_75) {
+		ret[modeline_count].width = 832;
+		ret[modeline_count].height = 624;
+		ret[modeline_count].refresh = 75;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_1024x768_87i) {
+		ret[modeline_count].width = 1024;
+		ret[modeline_count].height = 768;
+		ret[modeline_count].refresh = 87;
+		ret[modeline_count].interlaced = 1;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_1024x768_60){
+		ret[modeline_count].width = 1024;
+		ret[modeline_count].height = 768;
+		ret[modeline_count].refresh = 60;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_1024x768_70){
+		ret[modeline_count].width = 1024;
+		ret[modeline_count].height = 768;
+		ret[modeline_count].refresh = 70;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_1024x768_75){
+		ret[modeline_count].width = 1024;
+		ret[modeline_count].height = 768;
+		ret[modeline_count].refresh = 75;
+		modeline_count++;
+	}
+	if(edid->established_timings.timing_1280x1024_75) {
+		ret[modeline_count].width = 1280;
+		ret[modeline_count].height = 1024;
+		ret[modeline_count].refresh = 75;
+		modeline_count++;
+	}
+
+	/* Add in standard timings. */
+	for(i = 0; i < 8; i++) {
+		float aspect = 1;
+		int x, v;
+		x = edid->standard_timing[i].xresolution;
+		v = edid->standard_timing[i].vfreq;
+		if(((edid->standard_timing[i].xresolution & 0x01) != x) &&
+		   ((edid->standard_timing[i].vfreq & 0x01) != v)) {
+			switch(edid->standard_timing[i].aspect) {
+				case aspect_75: aspect = 0.7500; break;
+				case aspect_8: aspect = 0.8000; break;
+				case aspect_5625: aspect = 0.5625; break;
+				default: aspect = 1; break;
+			}
+			x = (edid->standard_timing[i].xresolution + 31) * 8;
+			ret[modeline_count].width = x;
+			ret[modeline_count].height = x * aspect;
+			ret[modeline_count].refresh =
+				edid->standard_timing[i].vfreq + 60;
+			modeline_count++;
+		}
+	}
+
+	/* Now tack on any matching modelines. */
+	for(i = 0; ret[i].refresh != 0; i++) {
+		struct vesa_timing_t *t = NULL;
+		for(j = 0; known_vesa_timings[j].refresh != 0; j++) {
+			t = &known_vesa_timings[j];
+			if(ret[i].width == t->x)
+			if(ret[i].height == t->y)
+			if(ret[i].refresh == t->refresh) {
+				snprintf(buf, sizeof(buf),
+					 "ModeLine \"%dx%d\"\t%6.2f "
+					 "%4d %4d %4d %4d %4d %4d %4d %4d %s %s"
+					 , t->x, t->y, t->dotclock,
+					 t->timings[0],
+					 t->timings[0] + t->timings[1],
+					 t->timings[0] + t->timings[1] +
+					 t->timings[2],
+					 t->timings[0] + t->timings[1] +
+					 t->timings[2] + t->timings[3],
+					 t->timings[4],
+					 t->timings[4] + t->timings[5],
+					 t->timings[4] + t->timings[5] +
+					 t->timings[6],
+					 t->timings[4] + t->timings[5] +
+					 t->timings[6] + t->timings[7],
+					 t->hsync == hsync_pos ?
+					 "+hsync" : "-hsync",
+					 t->vsync == vsync_pos ?
+					 "+vsync" : "-vsync");
+				ret[i].modeline = strdup(buf);
+				ret[i].hfreq = t->hfreq;
+				ret[i].vfreq = t->vfreq;
+			}
+		}
+	}
+
+	modeline_count = 0;
+	for(i = 0; ret[i].refresh != 0; i++) {
+		modeline_count++;
+	}
+	qsort(ret, modeline_count, sizeof(ret[0]), compare_vbe_modelines);
+
+	return ret;
+}
+
+const void *vbe_save_svga_state()
+{
+	struct LRMI_regs regs;
+	unsigned char *mem;
+	u_int16_t block_size;
+	void *data;
+
+	/* Initialize LRMI. */
+	if(LRMI_init() == 0) {
+		return NULL;
+	}
+
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f04;
+	regs.ecx = 0xffff;
+	regs.edx = 0;
+
+	iopl(3);
+	ioperm(0, 0x400, 1);
+
+	if(LRMI_int(0x10, &regs) == 0) {
+		return NULL;
+	}
+
+	if((regs.eax & 0xff) != 0x4f) {
+		fprintf(stderr, "Get SuperVGA Video State not supported.\n");
+		return NULL;
+	}
+
+	if((regs.eax & 0xffff) != 0x004f) {
+		fprintf(stderr, "Get SuperVGA Video State Info failed.\n");
+		return NULL;
+	}
+
+	block_size = 64 * (regs.ebx & 0xffff);
+
+	/* Allocate a chunk of memory. */
+	mem = LRMI_alloc_real(block_size);
+	if(mem == NULL) {
+		return NULL;
+	}
+	memset(mem, 0, sizeof(block_size));
+	
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f04;
+	regs.ecx = 0x000f;
+	regs.edx = 0x0001;
+	regs.es  = ((u_int32_t)mem) >> 4;
+	regs.ebx = ((u_int32_t)mem) & 0x0f;
+	memset(mem, 0, block_size);
+	iopl(3);
+	ioperm(0, 0x400, 1);
+
+	if(LRMI_int(0x10, &regs) == 0) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+
+	if((regs.eax & 0xffff) != 0x004f) {
+		fprintf(stderr, "Get SuperVGA Video State Save failed.\n");
+		return NULL;
+	}
+
+	data = malloc(block_size);
+	if(data == NULL) {
+		LRMI_free_real(mem);
+		return NULL;
+	}
+
+	/* Clean up and return. */
+	memcpy(data, mem, block_size);
+	LRMI_free_real(mem);
+	return data;
+}
+
+void vbe_restore_svga_state(const void *state)
+{
+	struct LRMI_regs regs;
+	unsigned char *mem;
+	u_int16_t block_size;
+
+	/* Initialize LRMI. */
+	if(LRMI_init() == 0) {
+		return;
+	}
+
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f04;
+	regs.ecx = 0x000f;
+	regs.edx = 0;
+
+	/* Find out how much memory we need. */
+	iopl(3);
+	ioperm(0, 0x400, 1);
+
+	if(LRMI_int(0x10, &regs) == 0) {
+		return;
+	}
+
+	if((regs.eax & 0xff) != 0x4f) {
+		fprintf(stderr, "Get SuperVGA Video State not supported.\n");
+		return;
+	}
+
+	if((regs.eax & 0xffff) != 0x004f) {
+		fprintf(stderr, "Get SuperVGA Video State Info failed.\n");
+		return;
+	}
+
+	block_size = 64 * (regs.ebx & 0xffff);
+
+	/* Allocate a chunk of memory. */
+	mem = LRMI_alloc_real(block_size);
+	if(mem == NULL) {
+		return;
+	}
+	memset(mem, 0, sizeof(block_size));
+
+	memset(&regs, 0, sizeof(regs));
+	regs.eax = 0x4f04;
+	regs.ecx = 0x000f;
+	regs.edx = 0x0002;
+	regs.es  = 0x2000;
+	regs.ebx = 0x0000;
+	memcpy(mem, state, block_size);
+
+	iopl(3);
+	ioperm(0, 0x400, 1);
+
+	if(LRMI_int(0x10, &regs) == 0) {
+		LRMI_free_real(mem);
+		return;
+	}
+
+	if((regs.eax & 0xffff) != 0x004f) {
+		fprintf(stderr, "Get SuperVGA Video State Restore failed.\n");
+		return;
+	}
+}
diff --git a/tools/ddcprobe/vbe.h b/tools/ddcprobe/vbe.h
new file mode 100644
index 000000000..338d3bd88
--- /dev/null
+++ b/tools/ddcprobe/vbe.h
@@ -0,0 +1,312 @@
+#ifndef vbe_h
+#define vbe_h
+#ident "$Id$"
+#include <sys/types.h>
+
+/* Record returned by int 0x10, function 0x4f, subfunction 0x00. */
+struct vbe_info {
+	unsigned char signature[4];
+	unsigned char version[2];
+	union {
+		struct {
+			u_int16_t ofs;
+			u_int16_t seg;
+		} addr;
+		const char *string;
+	} oem_name;
+	u_int32_t capabilities;
+	union {
+		struct {
+			u_int16_t ofs;
+			u_int16_t seg;
+		} addr;
+		u_int16_t *list;
+	} mode_list;
+	u_int16_t memory_size;
+	/* VESA 3.0+ */
+	u_int16_t vbe_revision;
+	union {
+		struct {
+			u_int16_t ofs;
+			u_int16_t seg;
+		} addr;
+		const char *string;
+	} vendor_name;
+	union {
+		struct {
+			u_int16_t ofs;
+			u_int16_t seg;
+		} addr;
+		const char *string;
+	} product_name;
+	union {
+		struct {
+			u_int16_t ofs;
+			u_int16_t seg;
+		} addr;
+		const char *string;
+	} product_revision;
+	char reserved1[222];
+	char reserved2[256];
+} __attribute__ ((packed));
+
+/* Stuff returned by int 0x10, function 0x4f, subfunction 0x01. */
+struct vbe_mode_info {
+	/* required for all VESA versions */
+	struct {
+		/* VBE 1.0+ */
+		u_int16_t supported: 1;
+		u_int16_t optional_info_available: 1;
+		u_int16_t bios_output_supported: 1;
+		u_int16_t color: 1;
+		u_int16_t graphics: 1;
+		/* VBE 2.0+ */
+		u_int16_t not_vga_compatible: 1;
+		u_int16_t not_bank_switched: 1;
+		u_int16_t lfb: 1;
+		/* VBE 1.0+ */
+		u_int16_t unknown: 1;
+		u_int16_t must_enable_directaccess_in_10: 1;
+	} mode_attributes;
+	struct {
+		unsigned char exists: 1;
+		unsigned char readable: 1;
+		unsigned char writeable: 1;
+		unsigned char reserved: 5;
+	} windowa_attributes, windowb_attributes;
+	u_int16_t window_granularity;
+	u_int16_t window_size;
+	u_int16_t windowa_start_segment, windowb_start_segment;
+	u_int16_t window_positioning_seg, window_positioning_ofs;
+	u_int16_t bytes_per_scanline;
+	/* optional for VESA 1.0/1.1, required for OEM modes */
+	u_int16_t w, h;
+	unsigned char cell_width, cell_height;
+	unsigned char memory_planes;
+	unsigned char bpp;
+	unsigned char banks;
+	enum {
+		memory_model_text = 0,
+		memory_model_cga = 1,
+		memory_model_hgc = 2,
+		memory_model_ega16 = 3,
+		memory_model_packed_pixel = 4,
+		memory_model_sequ256 = 5,
+		memory_model_direct_color = 6,
+		memory_model_yuv = 7,
+	} memory_model: 8;
+	unsigned char bank_size;
+	unsigned char image_pages;
+	unsigned char reserved1;
+	/* required for VESA 1.2+ */
+	unsigned char red_mask, red_field;
+	unsigned char green_mask, green_field;
+	unsigned char blue_mask, blue_field;
+	unsigned char reserved_mask, reserved_field;
+	unsigned char direct_color_mode_info;
+	/* VESA 2.0+ */
+	u_int32_t linear_buffer_address;
+	u_int32_t offscreen_memory_address;
+	u_int16_t offscreen_memory_size;
+	unsigned char reserved2[206];
+} __attribute__ ((packed));
+
+/* Modeline information used by XFree86. */
+struct vbe_modeline {
+	u_int16_t width, height;
+	unsigned char interlaced;
+	float refresh;
+	char *modeline;
+	float hfreq, vfreq, pixel_clock;
+};
+
+/* Aspect ratios used in EDID info. */
+enum vbe_edid_aspect {
+	aspect_unknown = 0,
+	aspect_75,
+	aspect_8,
+	aspect_5625,
+};
+
+/* Detailed timing information used in EDID v1.x */
+struct vbe_edid_detailed_timing {
+	u_int16_t pixel_clock;
+#define VBE_EDID_DETAILED_TIMING_PIXEL_CLOCK(_x) \
+	((_x).pixel_clock * 10000)
+	unsigned char horizontal_active;
+	unsigned char horizontal_blanking;
+	unsigned char horizontal_active_hi: 4;
+	unsigned char horizontal_blanking_hi: 4;
+#define VBE_EDID_DETAILED_TIMING_HORIZONTAL_ACTIVE(_x) \
+	(((_x).horizontal_active_hi << 8) + (_x).horizontal_active)
+#define VBE_EDID_DETAILED_TIMING_HORIZONTAL_BLANKING(_x) \
+	(((_x).horizontal_blanking_hi << 8) + (_x).horizontal_blanking)
+	unsigned char vertical_active;
+	unsigned char vertical_blanking;
+	unsigned char vertical_active_hi: 4;
+	unsigned char vertical_blanking_hi: 4;
+#define VBE_EDID_DETAILED_TIMING_VERTICAL_ACTIVE(_x) \
+	(((_x).vertical_active_hi << 8) + (_x).vertical_active)
+#define VBE_EDID_DETAILED_TIMING_VERTICAL_BLANKING(_x) \
+	(((_x).vertical_blanking_hi << 8) + (_x).vertical_blanking)
+	unsigned char hsync_offset;
+	unsigned char hsync_pulse_width;
+	unsigned char vsync_offset: 4;
+	unsigned char vsync_pulse_width: 4;
+	unsigned char hsync_offset_hi: 2;
+	unsigned char hsync_pulse_width_hi: 2;
+	unsigned char vsync_offset_hi: 2;
+	unsigned char vsync_pulse_width_hi: 2;
+#define VBE_EDID_DETAILED_TIMING_HSYNC_OFFSET(_x) \
+	(((_x).hsync_offset_hi << 8) + (_x).hsync_offset)
+#define VBE_EDID_DETAILED_TIMING_HSYNC_PULSE_WIDTH(_x) \
+	(((_x).hsync_pulse_width_hi << 8) + (_x).hsync_pulse_width)
+#define VBE_EDID_DETAILED_TIMING_VSYNC_OFFSET(_x) \
+	(((_x).vsync_offset_hi << 4) + (_x).vsync_offset)
+#define VBE_EDID_DETAILED_TIMING_VSYNC_PULSE_WIDTH(_x) \
+	(((_x).vsync_pulse_width_hi << 4) + (_x).vsync_pulse_width)
+	unsigned char himage_size;
+	unsigned char vimage_size;
+	unsigned char himage_size_hi: 4;
+	unsigned char vimage_size_hi: 4;
+#define VBE_EDID_DETAILED_TIMING_HIMAGE_SIZE(_x) \
+	(((_x).himage_size_hi << 8) + (_x).himage_size)
+#define VBE_EDID_DETAILED_TIMING_VIMAGE_SIZE(_x) \
+	(((_x).vimage_size_hi << 8) + (_x).vimage_size)
+	unsigned char hborder;
+	unsigned char vborder;
+	struct {
+		unsigned char interlaced: 1;
+		unsigned char stereo: 2;
+		unsigned char digital_composite: 2;
+		unsigned char variant: 2;
+		unsigned char zero: 1;
+	} flags __attribute__ ((packed));
+} __attribute__ ((packed));
+
+enum {
+	vbe_edid_monitor_descriptor_serial = 0xff,
+	vbe_edid_monitor_descriptor_ascii = 0xfe,
+	vbe_edid_monitor_descriptor_range = 0xfd,
+	vbe_edid_monitor_descriptor_name = 0xfc,
+} vbe_edid_monitor_descriptor_types;
+
+struct vbe_edid_monitor_descriptor {
+	u_int16_t zero_flag_1;
+	unsigned char zero_flag_2;
+	unsigned char type;
+	unsigned char zero_flag_3;
+	union {
+		char string[13];
+		struct {
+			unsigned char vertical_min;
+			unsigned char vertical_max;
+			unsigned char horizontal_min;
+			unsigned char horizontal_max;
+			unsigned char pixel_clock_max;
+			unsigned char gtf_data[8];
+		} range_data;
+	} data;
+} __attribute__ ((packed));
+
+struct vbe_edid1_info {
+	unsigned char header[8];
+	struct {
+		u_int16_t char3: 5;
+		u_int16_t char2: 5;
+		u_int16_t char1: 5;
+		u_int16_t zero: 1;
+	} manufacturer_name __attribute__ ((packed));
+	u_int16_t product_code;
+	u_int32_t serial_number;
+	unsigned char week;
+	unsigned char year;
+	unsigned char version;
+	unsigned char revision;
+	struct {
+		unsigned char separate_sync: 1;
+		unsigned char composite_sync: 1;
+		unsigned char sync_on_green: 1;
+		unsigned char unused: 2;
+		unsigned char voltage_level: 2;
+		unsigned char digital: 1;
+	} video_input_definition __attribute__ ((packed));
+	unsigned char max_size_horizontal;
+	unsigned char max_size_vertical;
+	unsigned char gamma;
+	struct {
+		unsigned char unused1: 3;
+		unsigned char rgb: 1;
+		unsigned char unused2: 1;
+		unsigned char active_off: 1;
+		unsigned char suspend: 1;
+		unsigned char standby: 1;
+	} feature_support __attribute__ ((packed));
+	unsigned char color_characteristics[10];
+	struct {
+		unsigned char timing_720x400_70: 1;
+		unsigned char timing_720x400_88: 1;
+		unsigned char timing_640x480_60: 1;
+		unsigned char timing_640x480_67: 1;
+		unsigned char timing_640x480_72: 1;
+		unsigned char timing_640x480_75: 1;
+		unsigned char timing_800x600_56: 1;
+		unsigned char timing_800x600_60: 1;
+		unsigned char timing_800x600_72: 1;
+		unsigned char timing_800x600_75: 1;
+		unsigned char timing_832x624_75: 1;
+		unsigned char timing_1024x768_87i: 1;
+		unsigned char timing_1024x768_60: 1;
+		unsigned char timing_1024x768_70: 1;
+		unsigned char timing_1024x768_75: 1;
+		unsigned char timing_1280x1024_75: 1;
+	} established_timings __attribute__ ((packed));
+	struct {
+		unsigned char timing_1152x870_75: 1;
+		unsigned char reserved: 7;
+	} manufacturer_timings __attribute__ ((packed));
+	struct {
+		u_int16_t xresolution: 8;
+		u_int16_t vfreq: 6;
+		u_int16_t aspect: 2;
+	} standard_timing[8] __attribute__ ((packed));
+	union {
+		struct vbe_edid_detailed_timing detailed_timing[4];
+		struct vbe_edid_monitor_descriptor monitor_descriptor[4];
+	} monitor_details __attribute__ ((packed));
+	unsigned char extension_flag;
+	unsigned char checksum;
+	unsigned char padding[128];
+} __attribute__ ((packed));
+
+#define VBE_LINEAR_FRAMEBUFFER 0x4000
+
+/* Get VESA information. */
+struct vbe_info *vbe_get_vbe_info();
+
+/* Get information about a particular video mode, bitwise or with
+   VBE_LINEAR_FRAMEBUFFER to check if LFB version is supported. */
+struct vbe_mode_info *vbe_get_mode_info(u_int16_t mode);
+
+/* Check if EDID reads are supported, and do them. */
+int vbe_get_edid_supported();
+struct vbe_edid1_info *vbe_get_edid_info();
+
+/* Get the current video mode, -1 on error. */
+int32_t vbe_get_mode();
+/* Set a new video mode, bitwise or with VBE_LINEAR_FRAMEBUFFER. */
+void vbe_set_mode(u_int16_t mode);
+
+/* Save/restore the SVGA state.  Call free() on the state record when done. */
+const void *vbe_save_svga_state();
+void vbe_restore_svga_state(const void *state);
+
+/* Get the ranges of values suitable for the attached monitor. */
+void vbe_get_edid_ranges(struct vbe_edid1_info *edid,
+			 unsigned char *hmin, unsigned char *hmax,
+			 unsigned char *vmin, unsigned char *vmax);
+
+/* Get a list of modelines that will work with this monitor. */
+struct vbe_modeline *vbe_get_edid_modelines();
+
+#endif
diff --git a/tools/ddcprobe/vesamode.c b/tools/ddcprobe/vesamode.c
new file mode 100644
index 000000000..9d4c3797a
--- /dev/null
+++ b/tools/ddcprobe/vesamode.c
@@ -0,0 +1,132 @@
+#include "vesamode.h"
+#ident "$Id$"
+
+/* Known standard VESA modes. */
+struct vesa_mode_t known_vesa_modes[] = {
+	/* VESA 1.0/1.1 ? */
+	{0x100,	640, 400, 256,	"640x400x256"},
+	{0x101,	640, 480, 256,	"640x480x256"},
+	{0x102,	800, 600, 16,	"800x600x16"},
+	{0x103,	800, 600, 256,	"800x600x256"},
+	{0x104,	1024, 768, 16,	"1024x768x16"},
+	{0x105,	1024, 768, 256,	"1024x768x256"},
+	{0x106,	1280, 1024, 16,	"1280x1024x16"},
+	{0x107,	1280, 1024, 256,"1280x1024x256"},
+	{0x108,	80, 60, 16,	"80x60 (text)"},
+	{0x109,	132, 25, 16,	"132x25 (text)"},
+	{0x10a,	132, 43, 16,	"132x43 (text)"},
+	{0x10b,	132, 50, 16,	"132x50 (text)"},
+	{0x10c,	132, 60, 16,	"132x60 (text)"},
+	/* VESA 1.2+ */
+	{0x10d,	320, 200, 32768,	"320x200x32k"},
+	{0x10e,	320, 200, 65536,	"320x200x64k"},
+	{0x10f,	320, 200, 16777216,	"320x200x16m"},
+	{0x110,	640, 480, 32768,	"640x480x32k"},
+	{0x111,	640, 480, 65536,	"640x480x64k"},
+	{0x112,	640, 480, 16777216,	"640x480x16m"},
+	{0x113,	800, 600, 32768,	"800x600x32k"},
+	{0x114,	800, 600, 65536,	"800x600x64k"},
+	{0x115,	800, 600, 16777216,	"800x600x16m"},
+	{0x116,	1024, 768, 32768,	"1024x768x32k"},
+	{0x117,	1024, 768, 65536,	"1024x768x64k"},
+	{0x118,	1024, 768, 16777216,	"1024x768x16m"},
+	{0x119,	1280, 1024, 32768,	"1280x1024x32k"},
+	{0x11a,	1280, 1024, 65536,	"1280x1024x64k"},
+	{0x11b,	1280, 1024, 16777216,	"1280x1024x16m"},
+	/* VESA 2.0+ */
+	{0x120,	1600, 1200, 256,	"1600x1200x256"},
+	{0x121,	1600, 1200, 32768,	"1600x1200x32k"},
+	{0x122,	1600, 1200, 65536,	"1600x1200x64k"},
+	{    0,    0,    0, 0,		""},
+};
+
+struct vesa_timing_t known_vesa_timings[] = {
+	/* Source: VESA Monitor Timing Specifications 1.0 rev 0.8 */
+	{ 640,  350, 85,  31.500, { 640, 32,  64,  96,  350,32, 3, 60},
+	  hsync_pos, vsync_neg, 37.861,  85.080},
+
+	{ 640,  400, 85,  31.500, { 640, 32,  64,  96,  400, 1, 3, 41},
+	  hsync_neg, vsync_pos, 37.861,  85.080},
+
+	{ 720,  400, 85,  35.500, { 720, 36, 72,  108,  400, 1, 3, 42},
+	  hsync_neg, vsync_pos, 37.861,  85.080},
+
+	{ 640,  480, 60,  25.175, { 640,  8,  96,  40,  480, 2, 2, 25},
+	 hsync_neg, vsync_neg,  31.469,  59.940},
+	{ 640,  480, 72,  31.500, { 640, 16,  40, 120,  480, 1, 3, 20},
+	 hsync_neg, vsync_neg,  37.861,  72.809},
+	{ 640,  480, 75,  31.500, { 640, 16,  64, 120,  480, 1, 3, 16},
+	 hsync_neg, vsync_neg,  37.500,  75.000},
+	{ 640,  480, 85,  36.000, { 640, 56,  56,  80,  480, 1, 3, 25},
+	 hsync_neg, vsync_neg,  43.269,  85.008},
+
+	{ 800,  600, 56,  36.000, { 800, 24,  72, 128,  600, 1, 2, 22},
+	 hsync_pos, vsync_pos,  35.156,  56.250},
+	{ 800,  600, 60,  40.000, { 800, 40, 128,  88,  600, 1, 4, 23},
+	 hsync_pos, vsync_pos,  37.879,  60.317},
+	{ 800,  600, 72,  50.000, { 800, 56, 120,  64,  600,37, 6, 23},
+	 hsync_pos, vsync_pos,  48.077,  72.188},
+	{ 800,  600, 75,  49.500, { 800, 16,  80, 160,  600, 1, 3, 21},
+	 hsync_pos, vsync_pos,  46.875,  75.000},
+	{ 800,  600, 85,  56.250, { 800, 32,  64, 152,  600, 1, 3, 27},
+	 hsync_pos, vsync_pos,  53.674,  85.061},
+
+	{1024,  768, 43,  44.900, {1024,  8, 176,  56,  768, 0, 4, 20},
+	 hsync_pos, vsync_pos,  35.522,  86.957},
+	{1024,  768, 60,  65.000, {1024, 24, 136, 160,  768, 3, 6, 29},
+	 hsync_neg, vsync_neg,  48.363,  60.004},
+	{1024,  768, 70,  75.000, {1024, 24, 136, 144,  768, 3, 6, 29},
+	 hsync_neg, vsync_neg,  56.476,  70.069},
+	{1024,  768, 75,  78.750, {1024, 16,  96, 176,  768, 1, 3, 28},
+	 hsync_pos, vsync_pos,  60.023,  75.029},
+	{1024,  768, 85,  94.500, {1024, 48,  96, 208,  768, 1, 3, 36},
+	 hsync_pos, vsync_pos,  68.677,  84.997},
+
+	{1152,  864, 70,  94.200, {1152, 32,  96, 192,  864, 1, 3, 46},
+	 hsync_pos, vsync_pos,   0.000,   0.000},
+	{1152,  864, 75, 108.000, {1152, 64, 128, 256,  864, 1, 3, 32},
+	 hsync_pos, vsync_pos,  67.500,  75.000},
+	{1152,  864, 85, 121.500, {1152, 64, 128, 224,  864, 1, 3, 43},
+	 hsync_pos, vsync_pos,   0.000,   0.000},
+
+	{1280,  960, 60, 108.000, {1280, 96, 112, 312,  960, 1, 3, 36},
+	 hsync_pos, vsync_pos,  60.000,  60.000},
+	{1280,  960, 85, 148.500, {1280, 64, 160, 224,  960, 1, 3, 47},
+	 hsync_pos, vsync_pos,  85.398,  85.002},
+
+	{1280, 1024, 60, 108.000, {1280, 48, 112, 248, 1024, 1, 3, 38},
+	 hsync_pos, vsync_pos,  63.981,  60.020},
+	{1280, 1024, 75, 135.000, {1280, 16, 144, 248, 1024, 1, 3, 38},
+	 hsync_pos, vsync_pos,  79.976,  75.025},
+	{1280, 1024, 85, 157.500, {1280, 64, 160, 224, 1024, 1, 3, 44},
+	 hsync_pos, vsync_pos,  91.146,  85.024},
+
+	{1600, 1200, 60, 162.000, {1600, 64, 192, 304, 1200, 1, 3, 46},
+	 hsync_pos, vsync_pos,  75.000,  60.000},
+	{1600, 1200, 65, 175.500, {1600, 64, 192, 304, 1200, 1, 3, 46},
+	 hsync_pos, vsync_pos,  81.250,  65.000},
+	{1600, 1200, 70, 189.000, {1600, 64, 192, 304, 1200, 1, 3, 46},
+	 hsync_pos, vsync_pos,  87.500,  70.000},
+	{1600, 1200, 75, 202.500, {1600, 64, 192, 304, 1200, 1, 3, 46},
+	 hsync_pos, vsync_pos,  93.750,  75.000},
+	{1600, 1200, 85, 229.500, {1600, 64, 192, 304, 1200, 1, 3, 46},
+	 hsync_pos, vsync_pos, 106.250,  85.000},
+
+	{1792, 1344, 60, 204.750, {1792,128, 200, 328, 1344, 1, 3, 46},
+	 hsync_neg, vsync_pos,  83.640,  60.000},
+	{1792, 1344, 75, 261.000, {1792, 96, 216, 352, 1344, 1, 3, 69},
+	 hsync_neg, vsync_pos, 106.270,  74.997},
+
+	{1856, 1392, 60, 218.250, {1856, 96, 224, 352, 1392, 1, 3, 43},
+	 hsync_neg, vsync_pos,  86.333,  59.995},
+	{1856, 1392, 75, 288.000, {1856,128, 224, 352, 1392, 1, 3,104},
+	 hsync_neg, vsync_pos, 112.500,  75.000},
+
+	{1920, 1440, 60, 234.000, {1920,128, 208, 344, 1440, 1, 3, 56},
+	 hsync_neg, vsync_pos,  90.000,  60.000},
+	{1920, 1440, 75, 297.000, {1920,144, 224, 352, 1440, 1, 3, 56},
+	 hsync_neg, vsync_pos, 112.500,  75.000},
+
+	{   0,    0,  0,   0.000, {   0,  0,   0,   0,    0, 0, 0,  0},
+	 000000000, 000000000,   0.000,   0.000},
+};
diff --git a/tools/ddcprobe/vesamode.h b/tools/ddcprobe/vesamode.h
new file mode 100644
index 000000000..b7eef9283
--- /dev/null
+++ b/tools/ddcprobe/vesamode.h
@@ -0,0 +1,31 @@
+#ifndef vesamode_h
+#define vesamode_h
+#include <sys/types.h>
+#ident "$Id$"
+
+typedef enum { hsync_neg = 0, hsync_pos } hsync_t;
+typedef enum { vsync_neg = 0, vsync_pos } vsync_t;
+
+struct vesa_mode_t {
+	u_int16_t number;
+	u_int16_t x, y;
+	u_int32_t colors;
+	const char *text;
+	const char *modeline;
+};
+
+struct vesa_timing_t {
+	u_int16_t x, y;
+	float refresh;
+	float dotclock;
+	u_int16_t timings[8];
+	hsync_t hsync;
+	vsync_t vsync;
+	float hfreq;
+	float vfreq;
+};
+
+extern struct vesa_mode_t known_vesa_modes[];
+extern struct vesa_timing_t known_vesa_timings[];
+
+#endif /* vesamode_h */