we can just get this from kudzu now

15 files changed, 0 insertions, 3758 deletions

diff --git a/ddcprobe/COPYING b/ddcprobe/COPYING
deleted file mode 100644
index 0b643ac83..000000000
--- a/ddcprobe/COPYING
+++ /dev/null
@@ -1,483 +0,0 @@
-
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
-                    675 Mass Ave, Cambridge, MA 02139, USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the library GPL.  It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it.  You can use it for
-your libraries, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library.  If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software.  To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
-  Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs.  This
-license, the GNU Library General Public License, applies to certain
-designated libraries.  This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
-  The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it.  Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program.  However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
-  Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries.  We
-concluded that weaker conditions might promote sharing better.
-
-  However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves.  This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them.  (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.)  The hope is that this
-will lead to faster development of free libraries.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, while the latter only
-works together with the library.
-
-  Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License").  Each licensee is
-addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also compile or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    c) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    d) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Library General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-     Appendix: How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free
-    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
-
diff --git a/ddcprobe/Makefile b/ddcprobe/Makefile
deleted file mode 100644
index 5c3cd133f..000000000
--- a/ddcprobe/Makefile
+++ /dev/null
@@ -1,45 +0,0 @@
-CFLAGS=-Wall -O2 -g# -DDEBUG
-
-TARGETS=ddcprobe svgamodes ddcxinfo modetest libvbe.a
-
-ifeq (.depend,$(wildcard .depend))
-TARGET=all
-else
-TARGET=depend all
-endif
-
-everything: $(TARGET)
-
-all: $(TARGETS)
-
-install: $(TARGETS)
-	cp -a ddcprobe $(DESTDIR)/usr/sbin/ddcprobe
-
-ddcprobe: lrmi.o vesamode.o vbe.o ddcprobe.o
-
-svgamodes: lrmi.o vesamode.o vbe.o svgamodes.o
-
-ddcxinfo: lrmi.o vesamode.o vbe.o ddcxinfo.o
-
-modetest: lrmi.o vesamode.o vbe.o modetest.o
-
-libvbe.a: lrmi.o vesamode.o vbe.o
-	$(AR) cru $@ $^
-
-install-lib: $(prefix)/include/vbe.h $(prefix)/lib/libvbe.a
-
-$(prefix)/include/vbe.h:
-	install -m 644 vbe.h $(prefix)/include/vbe.h
-
-$(prefix)/lib/libvbe.a:
-	install -m 644 libvbe.a $(prefix)/lib/libvbe.a
-
-clean:
-	$(RM) $(TARGETS) *.o .depend core
-
-depend:
-	$(CPP) -M $(CFLAGS) *.c > .depend
-
-ifeq (.depend,$(wildcard .depend))
-include .depend
-endif                                           
diff --git a/ddcprobe/README b/ddcprobe/README
deleted file mode 100644
index bdba8f378..000000000
--- a/ddcprobe/README
+++ /dev/null
@@ -1,8 +0,0 @@
-This is some VBE/DDC stuff.  It makes calls to the VESA extensions in the BIOS
-using a slightly modified version of Josh Vanderhoof's LRMI 0.6, and generally
-requires a 2.2 or newer kernel.  The idea for reading EDID data from the BIOS
-came from Matt Wilson <msw@gimp.org>, as well as several ideas about better ways
-to lay out data structure declarations.
-
-Nalin Dahyabhai
-bigfun@pobox.com
diff --git a/ddcprobe/bioscall.c b/ddcprobe/bioscall.c
deleted file mode 100644
index f58b3b6c0..000000000
--- a/ddcprobe/bioscall.c
+++ /dev/null
@@ -1,350 +0,0 @@
-#include <sys/types.h>
-#include <sys/io.h>
-#include <sys/stat.h>
-#include <sys/vm86.h>
-#include <sys/syscall.h>
-#include <sys/mman.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <netinet/in.h>
-#include "bioscall.h"
-#ident "$Id$"
-
-#define DFLAG 0x0400
-#define IFLAG 0x0200
-#define TFLAG 0x0100
-#define SFLAG 0x0080
-#define ZFLAG 0x0040
-#define AFLAG 0x0010
-#define PFLAG 0x0004
-#define CFLAG 0x0001
-
-/* Dump some of the interesting parts of a register struct to stdout. */
-void dump_regs(struct vm86_regs *regs)
-{
-	printf("ax = 0x%04lx\n", regs->eax & 0xffff);
-	printf("bx = 0x%04lx\n", regs->ebx & 0xffff);
-	printf("cx = 0x%04lx\n", regs->ecx & 0xffff);
-	printf("dx = 0x%04lx\n", regs->edx & 0xffff);
-	printf("cs = 0x%04x\n", regs->cs  & 0xffff);
-	printf("ip = 0x%08lx\n", regs->eip & 0xffffffff);
-	printf("ss = 0x%04x\n", regs->ss  & 0xffff);
-	printf("sp = 0x%08lx\n", regs->esp & 0xffffffff);
-	printf("%04x:%08lx = (%ld)\n",
-	       regs->cs & 0xffff, regs->eip,
-	       regs->cs * 16 + regs->eip);
-}
-
-/* Call vm86, but do I/O that gets trapped. We could skip vm86() altogether,
-   but then I'm not trying to emulate an entire CPU here.  Luckily, none of
-   the I/O instructions (or push/pop) affect the flags, so we can leave them
-   alone and just deal with performing the I/O operation that caused a return
-   to 32-bit mode. */
-void do_vm86(struct vm86_struct *vm, char *memory, unsigned stop_eip) {
-	int ret;
-	unsigned start_cs, start_eip;
-	unsigned char *ip = NULL;
-
-	/* Save the starting instruction address. */
-	start_cs = vm->regs.cs;
-	start_eip = vm->regs.eip;
-
-	/* We'll need to pass I/O through.  PCI devices have higher addresses
-	   than we can get access to with ioperm(). */
-	if(iopl(3) != 0) {
-		return;
-	}
-
-	/* Do it. */
-	ret = syscall(SYS_vm86old, vm);
-	while((vm->regs.cs * 16 + vm->regs.eip) != (start_cs * 16 + stop_eip)) {
-		ip = &memory[vm->regs.cs * 16 + vm->regs.eip];
-#ifdef DEBUG2
-		printf("Unexpected return:\n");
-		dump_regs(&vm->regs);
-		printf("Offending instructions: %02x %02x %02x %02x\n",
-		       ip[0], ip[1], ip[2], ip[3]);
-#endif
-		switch(ip[0]) {
-			case 0xe4: { /* in al, literal */
-				vm->regs.eax &= 0xffffff00;
-				vm->regs.eax |= inb(ip[1]);
-				vm->regs.eip += 2;
-				break;
-			}
-			case 0xe6: { /* out al, literal */
-				outb(vm->regs.eax & 0xff, ip[1]);
-				vm->regs.eip += 2;
-				break;
-			}
-			case 0xec: { /* in al, dx */
-				vm->regs.eax &= 0xffffff00;
-				vm->regs.eax |= inb(vm->regs.edx & 0xffff);
-				vm->regs.eip++;
-				break;
-			}
-			case 0xed: { /* in ax, dx */
-				vm->regs.eax &= 0xffff0000;
-				vm->regs.eax |= inw(vm->regs.edx & 0xffff);
-				vm->regs.eip++;
-				break;
-			}
-			case 0xee: { /* out al, dx */
-				outb(vm->regs.eax & 0xff,
-				     vm->regs.edx & 0xffff);
-				vm->regs.eip++;
-				break;
-			}
-			case 0xef: { /* out ax, dx */
-				outw(vm->regs.eax & 0xffff,
-				     vm->regs.edx & 0xffff);
-				vm->regs.eip++;
-				break;
-			}
-			case 0x6c: { /* insb */
-				unsigned char *result = (unsigned char*)
-					&memory[vm->regs.es*16 + vm->regs.edi];
-				*result = inb(vm->regs.edx & 0xffff);
-				if(vm->regs.eflags & DFLAG) {
-					vm->regs.edi -= 1;
-				} else {
-					vm->regs.edi += 1;
-				}
-				if(ip[-1] == 0xf3) { /* rep'ped */
-					vm->regs.ecx--;
-					vm->regs.eip--;
-				} else {
-					vm->regs.eip++;
-				}
-				break;
-			}
-			case 0x6d: { /* insw */
-				u_int16_t *result = (u_int16_t*)
-					&memory[vm->regs.es*16 + vm->regs.edi];
-				*result = inw(vm->regs.edx & 0xffff);
-				if(vm->regs.eflags & DFLAG) {
-					vm->regs.edi -= 2;
-				} else {
-					vm->regs.edi += 2;
-				}
-				if(ip[-1] == 0xf3) { /* rep'ped */
-					vm->regs.ecx--;
-					vm->regs.eip--;
-				} else {
-					vm->regs.eip++;
-				}
-				break;
-			}
-			case 0x6e: { /* outsb */
-				unsigned char *result = (unsigned char*)
-					&memory[vm->regs.es*16 + vm->regs.edi];
-				outb(*result,
-				     vm->regs.edx & 0xffff);
-				if(vm->regs.eflags & DFLAG) {
-					vm->regs.edi -= 1;
-				} else {
-					vm->regs.edi += 1;
-				}
-				if(ip[-1] == 0xf3) { /* rep'ped */
-					vm->regs.ecx--;
-					vm->regs.eip--;
-				} else {
-					vm->regs.eip++;
-				}
-				break;
-			}
-			case 0x6f: { /* outsw */
-				u_int16_t *result = (u_int16_t*)
-					&memory[vm->regs.es*16 + vm->regs.edi];
-				outw(*result,
-				     vm->regs.edx & 0xffff);
-				if(vm->regs.eflags & DFLAG) {
-					vm->regs.edi -= 2;
-				} else {
-					vm->regs.edi += 2;
-				}
-				if(ip[-1] == 0xf3) { /* rep'ped */
-					vm->regs.ecx--;
-					vm->regs.eip--;
-				} else {
-					vm->regs.eip++;
-				}
-				break;
-			}
-			case 0xfa: { /* cli */
-				vm->regs.eflags &= ~(IFLAG);
-				vm->regs.eip++;
-				break;
-			}
-			case 0xfb: { /* sti */
-				vm->regs.eflags |= ~(IFLAG);
-				vm->regs.eip++;
-				break;
-			}
-			case 0x9c: { /* pushf */
-				vm->regs.esp -= 2;
-				*(u_int16_t*) &memory[vm->regs.ss * 16 +
-						      vm->regs.esp]
-						    = vm->regs.eflags & 0xffff;
-				vm->regs.eip++;
-				break;
-			}
-			case 0x9d: { /* popf */
-				vm->regs.esp += 2;
-				vm->regs.eflags &= 0xffff0000;
-				vm->regs.eflags |= 
-				*(u_int16_t*) &memory[vm->regs.ss * 16 +
-						      vm->regs.esp];
-				vm->regs.eip++;
-				break;
-			}
-			case 0xf0: { /* lock prefix */
-				/* ignore it */
-				vm->regs.eip++;
-				break;
-			}
-			case 0x66: {
-				/* 32-bit extension prefix.  Valid, even in
-				   v86 mode.  Weird. */
-				vm->regs.eip++;
-				ip++;
-				switch(ip[0]) {
-					case 0xed: { /* in eax, dx */
-						vm->regs.eax =
-						inl(vm->regs.edx & 0xffff);
-						vm->regs.eip++;
-						break;
-					}
-					case 0xef: { /* out eax, dx */
-						outl(vm->regs.eax,
-						     vm->regs.edx & 0xffff);
-						vm->regs.eip++;
-						break;
-					}
-					default: {
-						fprintf(stderr, "unhandled "
-							"32-bit opcode\n");
-						exit(1);
-					}
-				}
-				break;
-			}
-			case 0x55: { /* push bp */
-				vm->regs.esp -= 2;
-				*(u_int16_t*) &memory[vm->regs.ss * 16 +
-						      vm->regs.esp]
-						    = vm->regs.ebp & 0xffff;
-				vm->regs.eip++;
-				break;
-			}
-			case 0x5d: { /* pop bp */
-				vm->regs.ebp &= 0xffff0000;
-				vm->regs.ebp |= *(u_int16_t*)
-					&memory[vm->regs.ss*16 + vm->regs.esp];
-				vm->regs.esp += 2;
-				vm->regs.eip++;
-				break;
-			}
-			case 0x59: { /* pop cx -- Banshee */
-				vm->regs.ecx &= 0xffff0000;
-				vm->regs.ecx |= *(u_int16_t*)
-					&memory[vm->regs.ss*16 + vm->regs.esp];
-				vm->regs.esp += 2;
-				vm->regs.eip++;
-			}
-			case 0xc3: { /* ret near, just pop ip */
-				vm->regs.eip &= 0xffff0000;
-				vm->regs.eip |= *(u_int16_t*)
-					&memory[vm->regs.ss*16 + vm->regs.esp];
-				vm->regs.esp += 2;
-				break;
-			}
-			case 0xcb: { /* ret far, pop both ip and cs */
-				vm->regs.eip &= 0xffff0000;
-				vm->regs.eip |= *(u_int16_t*)
-					&memory[vm->regs.ss*16 + vm->regs.esp];
-				vm->regs.esp += 2;
-				vm->regs.cs = *(u_int16_t*)
-					&memory[vm->regs.ss*16 + vm->regs.esp];
-				vm->regs.esp += 2;
-				break;
-			}
-			default: {
-				fprintf(stderr, "Unexpected stop!\n");
-				dump_regs(&vm->regs);
-				printf("Offending instructions: %02x %02x %02x %02x\n",
-				       ip[0], ip[1], ip[2], ip[3]);
-				exit(1);
-			}
-		}
-		ip = &memory[vm->regs.cs * 16 + vm->regs.eip];
-#ifdef DEBUG
-		printf("Resuming execution:\n");
-		dump_regs(&vm->regs);
-		printf("Offending instructions: %02x %02x %02x %02x\n",
-		       ip[0], ip[1], ip[2], ip[3]);
-#endif
-		ret = syscall(SYS_vm86old, vm);
-	}
-#ifdef DEBUG
-	printf("Reached stopping point, returning.\n");
-#endif
-	return;
-}
-
-/* Get a snapshot of the first megabyte of memory for use with vm86. */
-unsigned char *vm86_ram_alloc()
-{
-	unsigned char *memory;
-	int fd;
-
-	/* Grab address 0 for this process.  mmap() 1 megabyte + 64k HMA */
-	memory = mmap(0, 0x110000, PROT_READ | PROT_EXEC | PROT_WRITE,
-		      MAP_PRIVATE | MAP_FIXED | MAP_ANON, -1, 0x00000);
-	if(memory == MAP_FAILED) {
-		perror("error mmap()ing memory for the BIOS");
-		return MAP_FAILED;
-	}
-
-	/* Copy the low megabyte to our mmap()'ed buffer. */
-	fd = open("/dev/mem", O_RDONLY);
-	if(fd == -1) {
-		perror("reading kernel memory");
-		return MAP_FAILED;
-	}
-	// read(fd, memory, 0x110000);
-	lseek(fd, 0, SEEK_SET);
-	read(fd, &memory[0], 0x10000);
-	lseek(fd, 0xa0000, SEEK_SET);
-	read(fd, &memory[0xa0000], 0x50000);
-	close(fd);
-
-	return memory;
-}
-
-void vm86_ram_free(unsigned char *ram)
-{
-	munmap(ram, 0x110000);
-}
-
-void bioscall(unsigned char int_no, struct vm86_regs *regs, unsigned char *mem)
-{
-	unsigned char call[] = {0xcd, int_no, 0xcd, 0x09};
-	struct vm86_struct vm;
-	memset(&vm, 0, sizeof(vm));
-	memcpy(&vm.regs, regs, sizeof(vm.regs));
-	vm.regs.cs  = BIOSCALL_START_SEG;
-	vm.regs.eip = BIOSCALL_START_OFS;
-	vm.regs.ss  = BIOSCALL_START_SEG;
-	vm.regs.esp = 0xfff0 - BIOSCALL_START_OFS;
-	vm.regs.eflags = VM_MASK | IOPL_MASK;
-	memcpy(&mem[BIOSCALL_START_SEG * 16 + BIOSCALL_START_OFS], call,
-	       sizeof(call));
-	do_vm86(&vm, mem, BIOSCALL_START_OFS + sizeof(call));
-	memcpy(regs, &vm.regs, sizeof(vm.regs));
-}
diff --git a/ddcprobe/bioscall.h b/ddcprobe/bioscall.h
deleted file mode 100644
index 0851d0882..000000000
--- a/ddcprobe/bioscall.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef bioscall_h
-#define bioscall_h
-
-/* Print some of the interesting parts of a vm86_regs structure. */
-void dump_regs(struct vm86_regs *regs);
-
-/* Call vm86 using the given memory block, stopping if we break at a
-   given address. */
-void do_vm86(struct vm86_struct *vm, char *memory, unsigned stop_eip);
-
-/* Memory-map a megabyte at address 0, and copy the kernel's low megabyte
-   into the memory block, returning the result. */
-unsigned char *vm86_ram_alloc();
-void vm86_ram_free(unsigned char *ram);
-
-/* Handle everything, using the memory mapped at address 0.  The code that makes
-   the actual code to the bios is stored at segment BIOSCALL_START_SEG, offset
-   BIOSCALL_START_OFS, so expect that area to be destroyed if you use it. */
-#define BIOSCALL_START_SEG 0x8000
-#define BIOSCALL_START_OFS 0x0000
-void bioscall(unsigned char int_no, struct vm86_regs *regs, unsigned char *mem);
-
-#endif /* bioscall_h */
diff --git a/ddcprobe/ddcprobe.c b/ddcprobe/ddcprobe.c
deleted file mode 100644
index 7d1021d3a..000000000
--- a/ddcprobe/ddcprobe.c
+++ /dev/null
@@ -1,281 +0,0 @@
-#define _GNU_SOURCE
-#include <sys/types.h>
-#include <sys/io.h>
-#include <sys/stat.h>
-#include <sys/vm86.h>
-#include <sys/syscall.h>
-#include <sys/mman.h>
-#include <assert.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <netinet/in.h>
-#include "vbe.h"
-#include "vesamode.h"
-#include "lrmi.h"
-#ident "$Id$"
-
-char *snip(char *string)
-{
-	int i;
-	
-	/* This is always a 13 character buffer */
-	/* and it's not always terminated. */
-	string[12] = '\0';
-	
-	while(((i = strlen(string)) > 0) &&
-	       (isspace(string[i - 1]) ||
-	        (string[i - 1] == '\n') ||
-	        (string[i - 1] == '\r'))) {
-		string[i - 1] = '\0';
-	}
-	return string;
-}
-
-int main(int argc, char **argv)
-{
-	struct vbe_info *vbe_info = NULL;
-	struct vbe_edid1_info *edid_info = NULL;
-	u_int16_t *mode_list = NULL;
-	char manufacturer[4];
-	int i;
-
-	assert(sizeof(struct vbe_info) == 512);
-	assert(sizeof(struct vbe_edid1_info) == 256);
-	assert(sizeof(struct vbe_edid_detailed_timing) == 18);
-	assert(sizeof(struct vbe_edid_monitor_descriptor) == 18);
-
-	vbe_info = vbe_get_vbe_info();
-	if(vbe_info == NULL) {
-		printf("VESA BIOS Extensions not detected.\n");
-		exit(0);
-	}
-
-	/* Signature. */
-	printf("%c%c%c%c %d.%d detected.\n",
-	       vbe_info->signature[0], vbe_info->signature[1],
-	       vbe_info->signature[2], vbe_info->signature[3],
-	       vbe_info->version[1], vbe_info->version[0]);
-
-	/* OEM Strings. */
-	printf("OEM Name: %s\n", vbe_info->oem_name.string);
-	if(vbe_info->version[1] >= 3) {
-		printf("Vendor Name: %s\n",
-		       vbe_info->vendor_name.string);
-		printf("Product Name: %s\n",
-		       vbe_info->product_name.string);
-		printf("Product Revision: %s\n",
-		       vbe_info->product_revision.string);
-	}
-
-       if (strcasestr(vbe_info->oem_name.string, "intel")
-           && strstr(vbe_info->oem_name.string, "810")) {
-               printf("Intel 810 VESA video memory = %d * 64k blocks = %dkb. Use 4MB video memory.\n",
-                      vbe_info->memory_size, vbe_info->memory_size * 64);
-               printf("Memory installed = 64 * 64k blocks = 4096kb\n");
-       } else
-               printf("Memory installed = %d * 64k blocks = %dkb\n",
-                      vbe_info->memory_size, vbe_info->memory_size * 64);
-
-	/* List supported standard modes. */
-	mode_list = vbe_info->mode_list.list;
-	if(*mode_list != 0xffff) {
-		printf("Supported standard modes:\n");
-	}
-	for(;*mode_list != 0xffff; mode_list++) {
-		int i;
-		for(i = 0; known_vesa_modes[i].x != 0; i++) {
-			if(known_vesa_modes[i].number == *mode_list) {
-				printf("\t%s\n", known_vesa_modes[i].text);
-			}
-		}
-	}
-
-	if(!vbe_get_edid_supported()) {
-		printf("EDID read not supported by video card.\n");
-		exit(0);
-	}
-
-	edid_info = vbe_get_edid_info();
-
-	/* Interpret results. */
-	if((edid_info == NULL) || (edid_info->version == 0)) {
-		printf("EDID read failed. (No DDC-capable monitor attached?)\n");
-		exit(0);
-	}
-
-	if ((edid_info->version == 0xff && edid_info->revision == 0xff)
-	    || (edid_info->version == 0 && edid_info->revision == 0)) {
-		printf("EDID read failed, returned empty data\n");
-		exit(0);
-	}	    
-
-	printf("EDID ver. %d rev. %d.\n",
-	       edid_info->version, edid_info->revision);
-
-	manufacturer[0] = edid_info->manufacturer_name.char1 + 'A' - 1;
-	manufacturer[1] = edid_info->manufacturer_name.char2 + 'A' - 1;
-	manufacturer[2] = edid_info->manufacturer_name.char3 + 'A' - 1;
-	manufacturer[3] = '\0';
-	printf("Manufacturer: %s\n", manufacturer);
-	printf("ID: %04x\n", edid_info->product_code);
-	printf("EISA ID: %s%04x\n", manufacturer, edid_info->product_code);
-	
-	if(edid_info->serial_number != 0xffffffff) {
-		if(strcmp(manufacturer, "MAG") == 0) {
-			edid_info->serial_number -= 0x7000000;
-		}
-		if(strcmp(manufacturer, "OQI") == 0) {
-			edid_info->serial_number -= 456150000;
-		}
-		if(strcmp(manufacturer, "VSC") == 0) {
-			edid_info->serial_number -= 640000000;
-		}
-	}
-	printf("Serial number: %08x.\n", edid_info->serial_number);
-
-	printf("Manufactured in week %d of %d.\n",
-	       edid_info->week, edid_info->year + 1990);
-
-	printf("Input signal type: %s%s%s%s.\n",
-	       edid_info->video_input_definition.separate_sync ?
-	       "separate sync, " : "",
-	       edid_info->video_input_definition.composite_sync ?
-	       "composite sync, " : "",
-	       edid_info->video_input_definition.sync_on_green ?
-	       "sync on green, " : "",
-	       edid_info->video_input_definition.digital ?
-	       "digital signal" : "analog signal");
-
-	printf("Screen size max %d cm horizontal, %d cm vertical.\n",
-	       edid_info->max_size_horizontal,
-	       edid_info->max_size_vertical);
-
-	printf("Gamma: %f.\n", edid_info->gamma / 100.0 + 1);
-
-	printf("DPMS flags: %s, %s%s, %s%s, %s%s.\n",
-	       edid_info->feature_support.rgb ? "RGB" : "non-RGB",
-	       edid_info->feature_support.active_off ? "" : "no ", "active off",
-	       edid_info->feature_support.suspend ? "" : "no ", "suspend",
-	       edid_info->feature_support.standby ? "" : "no ", "standby");
-
-	printf("Established timings:\n");
-	if(edid_info->established_timings.timing_720x400_70)
-		printf("\t720x400 @ 70 Hz (VGA 640x400, IBM)\n");
-	if(edid_info->established_timings.timing_720x400_88)
-		printf("\t720x400 @ 88 Hz (XGA2)\n");
-	if(edid_info->established_timings.timing_640x480_60)
-		printf("\t640x480 @ 60 Hz (VGA)\n");
-	if(edid_info->established_timings.timing_640x480_67)
-		printf("\t640x480 @ 67 Hz (Mac II, Apple)\n");
-	if(edid_info->established_timings.timing_640x480_72)
-		printf("\t640x480 @ 72 Hz (VESA)\n");
-	if(edid_info->established_timings.timing_640x480_75)
-		printf("\t640x480 @ 75 Hz (VESA)\n");
-	if(edid_info->established_timings.timing_800x600_56)
-		printf("\t800x600 @ 56 Hz (VESA)\n");
-	if(edid_info->established_timings.timing_800x600_60)
-		printf("\t800x600 @ 60 Hz (VESA)\n");
-	if(edid_info->established_timings.timing_800x600_72)
-		printf("\t800x600 @ 72 Hz (VESA)\n");
-	if(edid_info->established_timings.timing_800x600_75)
-		printf("\t800x600 @ 75 Hz (VESA)\n");
-	if(edid_info->established_timings.timing_832x624_75)
-		printf("\t832x624 @ 75 Hz (Mac II)\n");
-	if(edid_info->established_timings.timing_1024x768_87i)
-		printf("\t1024x768 @ 87 Hz Interlaced (8514A)\n");
-	if(edid_info->established_timings.timing_1024x768_60)
-		printf("\t1024x768 @ 60 Hz (VESA)\n");
-	if(edid_info->established_timings.timing_1024x768_70)
-		printf("\t1024x768 @ 70 Hz (VESA)\n");
-	if(edid_info->established_timings.timing_1024x768_75)
-		printf("\t1024x768 @ 75 Hz (VESA)\n");
-	if(edid_info->established_timings.timing_1280x1024_75)
-		printf("\t1280x1024 @ 75 Hz (VESA)\n");
-
-	/* Standard timings. */
-	for(i = 0; i < 8; i++) {
-		double aspect = 1;
-		unsigned int x, y;
-		unsigned char xres, vfreq;
-		xres = edid_info->standard_timing[i].xresolution;
-		vfreq = edid_info->standard_timing[i].vfreq;
-		if((xres != vfreq) ||
-		   ((xres != 0) && (xres != 1)) ||
-		   ((vfreq != 0) && (vfreq != 1))) {
-			switch(edid_info->standard_timing[i].aspect) {
-				case 0: aspect = 1; break; /*undefined*/
-				case 1: aspect = 0.750; break;
-				case 2: aspect = 0.800; break;
-				case 3: aspect = 0.625; break;
-			}
-			x = (xres + 31) * 8;
-			y = x * aspect;
-			printf("Standard timing %d: %d Hz, %dx%d\n", i,
-			       (vfreq & 0x3f) + 60, x, y);
-		}
-	}
-
-	/* Detailed timing information. */
-	for(i = 0; i < 4; i++) {
-		struct vbe_edid_monitor_descriptor *monitor = NULL;
-		struct vbe_edid_detailed_timing *timing = NULL;
-
-		timing = &edid_info->monitor_details.detailed_timing[i];
-		monitor = &edid_info->monitor_details.monitor_descriptor[i];
-
-		if((monitor->zero_flag_1 != 0) || (monitor->zero_flag_2 != 0)) {
-			printf("Detailed timing %d:\n", i);
-			printf("\tPixel clock: %d\n",
-			       VBE_EDID_DETAILED_TIMING_PIXEL_CLOCK(*timing));
-			printf("\tHorizontal active time (pixel width): %d\n",
-			       VBE_EDID_DETAILED_TIMING_HORIZONTAL_ACTIVE(*timing));
-			printf("\tHorizontal blank time (pixel width): %d\n",
-			       VBE_EDID_DETAILED_TIMING_HORIZONTAL_BLANKING(*timing));
-			printf("\tVertical active time (pixel height): %d\n",
-			       VBE_EDID_DETAILED_TIMING_VERTICAL_ACTIVE(*timing));
-			printf("\tVertical blank time (pixel height): %d\n",
-			       VBE_EDID_DETAILED_TIMING_VERTICAL_BLANKING(*timing));
-			printf("\tHorizontal sync offset: %d\n",
-			       VBE_EDID_DETAILED_TIMING_HSYNC_OFFSET(*timing));
-			printf("\tHorizontal sync pulse width: %d\n",
-			       VBE_EDID_DETAILED_TIMING_HSYNC_PULSE_WIDTH(*timing));
-			printf("\tVertical sync offset: %d\n",
-			       VBE_EDID_DETAILED_TIMING_VSYNC_OFFSET(*timing));
-			printf("\tVertical sync pulse width: %d\n",
-			       VBE_EDID_DETAILED_TIMING_VSYNC_PULSE_WIDTH(*timing));
-			printf("\tDimensions: %dx%d\n",
-			       VBE_EDID_DETAILED_TIMING_HIMAGE_SIZE(*timing),
-			       VBE_EDID_DETAILED_TIMING_VIMAGE_SIZE(*timing));
-		} else
-		if(monitor->type == vbe_edid_monitor_descriptor_serial) {
-			printf("Monitor details %d:\n", i);
-			printf("\tSerial number: %s\n",
-			       snip(monitor->data.string));
-		} else
-		if(monitor->type == vbe_edid_monitor_descriptor_ascii) {
-			printf("Monitor details %d:\n", i);
-			printf("\tASCII String: %s:\n",
-			       snip(monitor->data.string));
-		} else
-		if(monitor->type == vbe_edid_monitor_descriptor_name) {
-			printf("Monitor details %d:\n", i);
-			printf("\tName: %s\n",
-			       snip(monitor->data.string));
-		} else
-		if(monitor->type == vbe_edid_monitor_descriptor_range) {
-			printf("Monitor details %d:\n", i);
-			printf("\tTiming ranges: "
-			       "horizontal = %d - %d, vertical = %d - %d\n",
-			       monitor->data.range_data.horizontal_min,
-			       monitor->data.range_data.horizontal_max,
-			       monitor->data.range_data.vertical_min,
-			       monitor->data.range_data.vertical_max);
-		}
-	}
-	return 0;
-}
diff --git a/ddcprobe/ddcxinfo.c b/ddcprobe/ddcxinfo.c
deleted file mode 100644
index 3667c1e75..000000000
--- a/ddcprobe/ddcxinfo.c
+++ /dev/null
@@ -1,77 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "vbe.h"
-#ident "$Id$"
-
-int main(int argc, char **argv)
-{
-	int i, j;
-	unsigned char hmin = -1, hmax = -1, vmin = -1, vmax = -1;
-	if(argc < 2) {
-		char *p = argv[0];
-		if(strchr(p, '/')) {
-			p = strchr(p, '/');
-			p++;
-		}
-		fprintf(stderr,"syntax: %s [-hsync] [-vsync] [-modelines]\n",p);
-		exit(1);
-	}
-	for(i = 1; i < argc; i++) {
-		if((strcmp(argv[i], "-hsync") == 0) ||
-		   (strcmp(argv[i], "-vsync") == 0)) {
-			vbe_get_edid_ranges(&hmin, &hmax, &vmin, &vmax);
-			if(!hmin && !hmax && !vmin && !vmax) {
-				struct vbe_modeline* modelines;
-				modelines = vbe_get_edid_modelines();
-				for(j = 0;
-				    modelines && (modelines[j].refresh != 0);
-				   j++) {
-					if(hmin == 0) hmin = modelines[j].hfreq;
-					/* guess */
-					if(modelines[j].hfreq)
-					hmin = (hmin < modelines[j].hfreq) ?
-					        hmin : modelines[j].hfreq;
-					if(modelines[j].hfreq)
-					hmax = (hmax > modelines[j].hfreq) ?
-					        hmax : modelines[j].hfreq;
-					if(vmin == 0) vmin = modelines[j].vfreq;
-					if(modelines[j].vfreq)
-					vmin = (vmin < modelines[j].vfreq) ?
-					        vmin : modelines[j].vfreq;
-					if(modelines[j].vfreq)
-					vmax = (vmax > modelines[j].vfreq) ?
-					        vmax : modelines[j].vfreq;
-				}
-			}
-		}
-		if(strcmp(argv[i], "-hsync") == 0) {
-			printf("%d-%d\n", hmin, hmax);
-		}
-		if(strcmp(argv[i], "-vsync") == 0) {
-			printf("%d-%d\n", vmin, vmax);
-		}
-		if(strcmp(argv[i], "-modelines") == 0) {
-			struct vbe_modeline* modelines;
-			modelines = vbe_get_edid_modelines();
-			for(j=0; modelines && (modelines[j].refresh != 0); j++){
-				if(modelines[j].modeline) {
-					printf("# %dx%d, %1.1f%sHz; hfreq=%f, vfreq=%f\n%s\n",
-					       modelines[j].width,
-					       modelines[j].height,
-					       modelines[j].refresh,
-					       modelines[j].interlaced?"i":"",
-					       modelines[j].hfreq,
-					       modelines[j].vfreq,
-					       modelines[j].modeline);
-				}
-			}
-			if(modelines) {
-				free(modelines);
-			} else {
-				return 1;
-			}
-		}
-	}
-	return 0;
-}
diff --git a/ddcprobe/lrmi.c b/ddcprobe/lrmi.c
deleted file mode 100644
index ce13c1091..000000000
--- a/ddcprobe/lrmi.c
+++ /dev/null
@@ -1,912 +0,0 @@
-/*
-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
-
-
-#ifdef ORIGINAL_LRMI_CODE_THAT_GOT_IFDEFED_OUT
-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);
-	}
-#endif
-
-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/ddcprobe/lrmi.h b/ddcprobe/lrmi.h
deleted file mode 100644
index c9c186365..000000000
--- a/ddcprobe/lrmi.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-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/ddcprobe/modetest.c b/ddcprobe/modetest.c
deleted file mode 100644
index 6e5a318b8..000000000
--- a/ddcprobe/modetest.c
+++ /dev/null
@@ -1,128 +0,0 @@
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include <sys/ioctl.h>
-#include <linux/kd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <assert.h>
-#include <fcntl.h>
-#include "vbe.h"
-#ident "$Id$"
-
-#define VESA_MODE 0x112
-
-int main(int argc, char **argv)
-{
-	const void *start_state;
-	u_int16_t start_mode;
-	struct vbe_info *info;
-	struct vbe_mode_info *mode_info;
-	char fontdata[32 * 512];
-	struct consolefontdesc font = {512, 32, fontdata};
-	int fd, tty_fd;
-	long tty_mode;
-	char *lfb;
-	int i, j;
-
-	/* Make sure we have VESA on this machine. */
-	info = vbe_get_vbe_info();
-	if(info == NULL) {
-		fprintf(stderr, "VESA BIOS Extensions not detected.\n");
-		exit(1);
-	}
-	fprintf(stderr, "Detected %c%c%c%c %d.%d\n",
-		info->signature[0], info->signature[1],
-		info->signature[2], info->signature[3],
-		info->version[1], info->version[0]);
-
-	/* Open the current tty.  We'll need this for setting fonts. */
-	tty_fd = open("/dev/tty", O_RDWR);
-	if(tty_fd == -1) {
-		perror("opening tty");
-		exit(1);
-	}
-
-	/* Save the current VESA state and mode. */
-	start_state = vbe_save_svga_state();
-	start_mode = vbe_get_mode();
-
-	/* Make sure we don't have garbage values for these. */
-	assert(start_state);
-	assert(start_mode);
-	printf("Started in mode 0x%04x.\n", start_mode);
-
-	/* Make sure the desired mode is available. */
-	mode_info = vbe_get_mode_info(VBE_LINEAR_FRAMEBUFFER | VESA_MODE);
-	assert(mode_info != NULL);
-	assert(mode_info->linear_buffer_address != 0);
-
-	/* Memory-map the framebuffer for direct access (whee!) */
-	fd = open("/dev/mem", O_RDWR);
-	if(fd == -1) {
-		perror("opening framebuffer");
-		exit(1);
-	}
-	lfb = mmap(NULL,
-		   mode_info->bytes_per_scanline * mode_info->h,
-		   PROT_WRITE,
-		   MAP_SHARED,
-		   fd,
-		   mode_info->linear_buffer_address);
-	if(lfb == MAP_FAILED) {
-		perror("memory-mapping framebuffer");
-		exit(1);
-	}
-
-	/* Get the console's current mode and font for restoring when we're
-	   finished messing with it. */
-	if(ioctl(tty_fd, KDGETMODE, &tty_mode) != 0) {
-		perror("getting console mode");
-		exit(1);
-	}
-	if(ioctl(tty_fd, GIO_FONTX, &font) != 0) {
-		perror("saving console font");
-		exit(1);
-	}
-
-	/* Tell the console we're going into graphics mode. */
-	if(ioctl(tty_fd, KDSETMODE, KD_GRAPHICS) != 0) {
-		perror("preparing for graphics");
-		exit(1);
-	}
-
-	/* Do the switch. */
-	fprintf(stderr, "Switching to mode 0x%04x: %dx%d, %d-bit...\n",
-		VBE_LINEAR_FRAMEBUFFER | VESA_MODE,
-		mode_info->w, mode_info->h, mode_info->bpp);
-	vbe_set_mode(VBE_LINEAR_FRAMEBUFFER | VESA_MODE);
-
-	/* Test pattern time! */
-	for(i = 0; i < mode_info->h; i++)
-	for(j = 0; j < mode_info->w; j++) {
-		lfb[3 * (i * mode_info->w + j) + 0] = j % 256;
-		lfb[3 * (i * mode_info->w + j) + 1] = j % 128;
-		lfb[3 * (i * mode_info->w + j) + 2] = j % 64;
-	}
-
-	/* Pause to admire the display. */
-	sleep(10);
-
-	/* Restore the original video mode, hardware settings,
-	   VT mode and font. */
-	vbe_set_mode(start_mode);
-	vbe_restore_svga_state(start_state);
-	fprintf(stderr, "Back to normal.\n");
-
-	if(ioctl(tty_fd, KDSETMODE, tty_mode) != 0) {
-		perror("switching vt back to normal mode");
-	}
-	if(ioctl(tty_fd, PIO_FONTX, &font) != 0) {
-		perror("restoring console font");
-		system("setfont");
-	}
-
-	return 0;
-}
diff --git a/ddcprobe/svgamodes.c b/ddcprobe/svgamodes.c
deleted file mode 100644
index 4f0ea7a20..000000000
--- a/ddcprobe/svgamodes.c
+++ /dev/null
@@ -1,179 +0,0 @@
-#include <sys/types.h>
-#include <sys/io.h>
-#include <sys/stat.h>
-#include <sys/vm86.h>
-#include <sys/syscall.h>
-#include <sys/mman.h>
-#include <assert.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <netinet/in.h>
-#include "vbe.h"
-#include "vesamode.h"
-#include "lrmi.h"
-#ident "$Id$"
-
-/* Callback for qsort(). */
-static int compare_16(const void *i1, const void *i2)
-{
-	const u_int16_t *I1, *I2;
-	I1 = (const u_int16_t*) i1;
-	I2 = (const u_int16_t*) i2;
-	if(*I1 < *I2) return -1;
-	if(*I1 > *I2) return 1;
-	return 0;
-}
-
-int main(int argc, char **argv)
-{
-	struct vbe_info *vbe_info = NULL;
-	struct vbe_mode_info *mode_info = NULL;
-	u_int16_t *mode_list = NULL;
-	int mode_count = 0;
-	float vesa_version;
-
-	/* Get basic information. */
-	vbe_info = vbe_get_vbe_info();
-	if(vbe_info == NULL) {
-		printf("VESA BIOS Extensions not detected.\n");
-		exit(0);
-	}
-
-	/* Print the signature, should be "VESA <digit>.<digit>". */
-	printf("%c%c%c%c %d.%d detected.\n",
-	       vbe_info->signature[0], vbe_info->signature[1],
-	       vbe_info->signature[2], vbe_info->signature[3],
-	       vbe_info->version[1], vbe_info->version[0]);
-	vesa_version =  (vbe_info->version[1]) + (vbe_info->version[0]) / 10.0;
-
-	/* List supported standard modes. */
-	mode_list = vbe_info->mode_list.list;
-	if(*mode_list != 0xffff) {
-		printf("Supported modes:\n");
-	}
-	/* Count the number of modes. */
-	for(;*mode_list != 0xffff; mode_list++) {
-		mode_count++;
-	}
-	/* Sort the mode list, because my ATI doesn't.  Grrr... */
-	mode_list = vbe_info->mode_list.list;
-	if(*mode_list != 0xffff) {
-		qsort(mode_list, mode_count, sizeof(u_int16_t), compare_16);
-	}
-	/* Dump info about the video mode. */
-	for(;*mode_list != 0xffff; mode_list++) {
-		int j;
-		/* Mode number. */
-		printf("0x%03x\t", *mode_list);
-		for(j = 0; known_vesa_modes[j].x != 0; j++) {
-		/* If it's a standard mode, print info about it. */
-		if(known_vesa_modes[j].number == *mode_list) {
-			printf("Specs list this as %dx%d, %d colors.",
-			       known_vesa_modes[j].x,
-			       known_vesa_modes[j].y,
-			       known_vesa_modes[j].colors);
-		}}
-		printf("\n");
-		/* Get mode information from the BIOS.  Should never fail. */
-		mode_info = vbe_get_mode_info(*mode_list);
-		if(mode_info == NULL) {
-			printf("Get mode information not supported by BIOS.\n");
-			exit(0);
-		}
-
-		/* Report what the BIOS says about the mode, should agree
-		   with VESA on standard modes. */
-		if(mode_info->w && mode_info->h && mode_info->bpp) {
-			printf("\tBIOS reports this as %dx%d, %d bpp",
-			       mode_info->w, mode_info->h,
-			       mode_info->bpp);
-		}
-		if(mode_info->bytes_per_scanline) {
-			printf(", %d bytes per scanline.",
-			       mode_info->bytes_per_scanline);
-		}
-		printf("\n");
-		/* Check the 'supported' bit.  Should be set, because this is
-		   in the main supported modes list. */
-		printf("\t%s, ", mode_info->mode_attributes.supported ?
-		       "Supported" : "Not supported");
-		/* Color?  Graphics? */
-		printf("%s ", mode_info->mode_attributes.color ?
-		       "Color" : "Monochrome");
-		printf("%s.\n", mode_info->mode_attributes.graphics ?
-		       "Graphics" : "Text");
-		/* Check for LFB stuff.  Ralf's list says that you need to
-		   query with bit 14 set to check if an LFB version of the mode
-		   is available, but the ATI always returns true. */
-		if(vesa_version >= 2.0) {
-			/* Regular info about the current mode. */
-			struct vbe_mode_info *info = NULL;
-			printf("\t%sVGA compatible.\n",
-			       mode_info->mode_attributes.not_vga_compatible ?
-			       "Not " : "");
-			printf("\tThis is %san LFB mode.\n",
-			       mode_info->mode_attributes.lfb ?
-			       "" : "not ");
-			/* Info about the LFB variant mode (bit 14 set). */
-			info = vbe_get_mode_info(*mode_list |
-						 VBE_LINEAR_FRAMEBUFFER);
-			if(info) {
-				if(info->mode_attributes.lfb) {
-					printf("\tLFB variant available.\n");
-				}
-				free(info);
-			}
-			if((mode_info->mode_attributes.lfb) ||
-			   (info && (info->mode_attributes.lfb))) {
-				printf("\tLFB at address 0x%8x.\n",
-				       mode_info->linear_buffer_address);
-			}
-		}
-		/* Memory model: EGA = icky bit planes, packed-pixel = palette,
-		   direct color = LFB compatible but needs bank switches. */
-		printf("\tMemory model: ");
-		switch(mode_info->memory_model) {
-			case memory_model_text: {
-				printf("text.\n");
-				break;
-			}
-       			case memory_model_cga: {
-				printf("CGA.\n");
-				break;
-			}
-       			case memory_model_hgc: {
-				printf("Hercules.\n");
-				break;
-			}
-       			case memory_model_ega16: {
-				printf("EGA.\n");
-				break;
-			}
-       			case memory_model_packed_pixel: {
-				printf("packed-pixel.\n");
-				break;
-			}
-       			case memory_model_sequ256: {
-				printf("sequential 256.\n");
-				break;
-			}
-       			case memory_model_direct_color: {
-				printf("direct color.\n");
-				break;
-			}
-       			case memory_model_yuv: {
-				printf("YUV.\n");
-				break;
-			}
-			default : {
-				printf("unknown/OEM.\n");
-			}
-		}
-	}
-	return 0;
-}
diff --git a/ddcprobe/vbe.c b/ddcprobe/vbe.c
deleted file mode 100644
index aec3141d2..000000000
--- a/ddcprobe/vbe.c
+++ /dev/null
@@ -1,713 +0,0 @@
-#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(unsigned char *hmin, unsigned char *hmax,
-			 unsigned char *vmin, unsigned char *vmax)
-{
-	struct vbe_edid1_info *edid;
-	struct vbe_edid_monitor_descriptor *monitor;
-	int i;
-
-	*hmin = *hmax = *vmin = *vmax = 0;
-
-	if((edid = vbe_get_edid_info()) == NULL) {
-		return;
-	}
-
-	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/ddcprobe/vbe.h b/ddcprobe/vbe.h
deleted file mode 100644
index feae8498a..000000000
--- a/ddcprobe/vbe.h
+++ /dev/null
@@ -1,311 +0,0 @@
-#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(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/ddcprobe/vesamode.c b/ddcprobe/vesamode.c
deleted file mode 100644
index 9d4c3797a..000000000
--- a/ddcprobe/vesamode.c
+++ /dev/null
@@ -1,132 +0,0 @@
-#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/ddcprobe/vesamode.h b/ddcprobe/vesamode.h
deleted file mode 100644
index b7eef9283..000000000
--- a/ddcprobe/vesamode.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#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 */