Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

18 files changed, 5114 insertions, 0 deletions

diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/Imakefile b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/Imakefile
new file mode 100644
index 000000000..6659da9be
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/Imakefile
@@ -0,0 +1,45 @@
+XCOMM $XConsortium: Imakefile /main/7 1996/09/28 17:24:18 rws $
+
+
+
+
+
+XCOMM $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/Imakefile,v 3.20 2002/10/17 02:22:48 dawes Exp $
+#include <Server.tmpl>
+
+BIOS_MOD = os2_bios
+
+SRCS = os2_init.c os2_video.c os2_io.c $(BIOS_MOD).c \
+       os2_ioperm.c os2_VTsw.c os2_mouse.c os2_KbdEv.c os2_stubs.c \
+       os2_select.c os2_diag.c libc_wrapper.c stdResource.c stdPci.c \
+       vidmem.c sigiostubs.c pm_noop.c kmod_noop.c agp_noop.c os2_serial.c \
+       os2_kbd.c
+
+OBJS = os2_init.o os2_video.o os2_io.o $(BIOS_MOD).o \
+       os2_ioperm.o os2_VTsw.o os2_mouse.o os2_kbdEv.o os2_stubs.o \
+       os2_select.o os2_diag.o libc_wrapper.o stdResource.o stdPci.o \
+       vidmem.o sigiostubs.o pm_noop.o kmod_noop.o agp_noop.o os2_serial.o \
+       os2_kbd.o
+
+INCLUDES = -I$(XF86COMSRC) -I$(XF86OSSRC) -I. -I$(SERVERSRC)/include \
+           -I$(SERVERSRC)/mi -I$(XINCLUDESRC) -I$(EXTINCSRC)
+
+RESDEFINES = -DUSESTDRES
+
+DEFINES = $(RESDEFINES)
+
+SubdirLibraryRule($(OBJS))
+NormalLibraryObjectRule()
+NormalAsmObjectRule()
+
+LinkSourceFile(VTsw_noop.c,../shared)
+LinkSourceFile(libc_wrapper.c,../shared)
+LinkSourceFile(stdResource.c,../shared)
+LinkSourceFile(stdPci.c,../shared)
+LinkSourceFile(vidmem.c,../shared)
+LinkSourceFile(sigiostubs.c,../shared)
+LinkSourceFile(pm_noop.c,../shared)
+LinkSourceFile(kmod_noop.c,../shared)
+LinkSourceFile(agp_noop.c,../shared)
+
+DependTarget()
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/README b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/README
new file mode 100644
index 000000000..d07059eed
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/README
@@ -0,0 +1,78 @@
+Information on files in this directory
+--------------------------------------
+\xc\programs\xserver\hw\xfree86\os-support\os2
+
+The files in this directory form the OS-dependent porting layer of
+XFree86 for OS/2. They are the work of:
+
+       Holger Veit <Holger.Veit@gmd.de>
+       Sebastien Marineau <marineau@genie.uottawa.ca>
+
+Some functions which were absent from OS/2,
+such as direct access to IO ports and the mapping of physical memory,
+are implemented in a device-driver written for this purpose by Holger Veit 
+<Holger.Veit@gmd.de>. The driver also implements several functions
+necessary for xterm.
+The driver should be installed in the config.sys with a line:
+
+DEVICE=path\XF86SUP.SYS
+
+The following gives a brief overview of the implementation of the
+porting layer, and lists some of the "gotchas" when modifying the source.
+
+BIOS and physical memory mapping: This is handled by the functions in XF86SUP.SYS driver.
+
+IO permission: Handled by a function in the XF86SUP.SYS driver. Essentially, IO permissions
+are granted for the whole Xserver at server initialisation. The device-driver sets the IOPL
+level to ring 3 for the Xserver, which in essence gives it the same IO privileges that a
+device-driver has. Note the danger here: the Xserver can write to any IO port it wishes,
+and can disable interrupts (something which it does), thus can potentially hang the system.
+
+VT switching (switching back and forth to the WPS): This is handled by the keyboard driver,
+i.e. the stardard keyboard sequences (CTRL-ESC etc.) trigger the switch back to PM. The 
+Xserver is notified of switches by the VIO function VIOSavRedrawWait(), which is run in
+a separate thread. When a switch to/from PM is requested, this function call unblocks, and
+the Xserver either saves or restores the video buffer and video mode. Note that semaphores
+are used to communicate with the main Xserver thread, and handle cases such as server
+reset while the server has lost focus etc.
+A similar mechanism is used to handle hard-error popups. A thread is run which blocks
+on the VIOModeWait() function. When a hard-error notification occurs, the Xserver attempts
+to recover by resetting the screen. Note that, due to some (probable) bugs in the OS/2
+video drivers, this does not always work as expected. According to the specs, the OS/2
+video drivers are supposed to restore the palette when returning from a hard-error. This
+does not seem to be always the case..... so the palette in X may be screwed up after the
+hard-error.
+
+Keyboard input: because X needs all keyboard event to function (both keypresses, key
+releases, for all keys), the keyboard input was implemented by registering a keyboard
+monitor for the Xserver. The keyboard monitor is run in a separate thread, and sends
+the keystrokes back to the Xserver main thread through a queue. Another thread is
+also started, whose purpose is to "eat" the keystrokes returned by KbdCharIn(). Note that 
+the monitor was necessary because the OS/2 keyboard driver does not pass all keystrokes
+to the application calling KbdCharIn().
+
+Mouse input: This was implemented similarly to the keyboard input: mouse events are
+read in a thread, which then passes them to the main Xserver thread through a queue.
+
+Select: this unix and emx function has been reimplemented and optimized for the xserver.
+Because of the need to handle input from pipes, sockets, the mouse and keyboard (which
+select() in unix does but the EMX select does not), it was decided to rewrite it in
+order to minimize CPU usage and maximize responsiveness. Essentially, select() blocks on
+a MuxWait semaphore, and unblocks when input is available from pipes, the mouse and the
+keyboard. The MuxWait semaphore times out every timeslice, so that sockets can be checked
+for activity (unfortunately, sockets are not well-handled in the OS/2 TCPIP and one cannot
+attach a semaphore to a socket). There is also the possibility of using the high-resolution
+timer (found in Merlin) to check sockets more often than every timeslice.
+*** Important: in order to maximize speed, certain shortcuts are utilized in this 
+implementation of select(), which makes it unsuitable as a general-purpose function. Also,
+it is imperative that the EMX select() never be called from the Xserver! ***
+
+
+If you wish to modify the source, be aware that there may be very good reasons as
+to why certain things were done this way. Usually, if certain function implementations
+appear unnecessarily complicated, it is probably because there were subtle problems
+with the simpler solutions. Due to the complexity of the Xserver code, and the
+differences between OS/2 and unix, there are many potential pitfalls.
+
+$XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/README,v 3.1 1996/01/30 15:26:27 dawes Exp $
+
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/int10/Imakefile b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/int10/Imakefile
new file mode 100644
index 000000000..a323229bf
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/int10/Imakefile
@@ -0,0 +1,110 @@
+XCOMM $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/int10/Imakefile,v 1.1 2000/04/05 18:13:55 dawes Exp $
+
+#define IHaveModules
+
+#include <Server.tmpl>
+
+SRCS1 = pci.c xf86int10module.c helper_exec.c helper_mem.c xf86int10.c 
+OBJS1 = pci.o xf86int10module.o helper_exec.o helper_mem.o xf86int10.o 
+
+LinkSourceFile(helper_mem.c,$(XF86SRC)/int10)
+LinkSourceFile(helper_exec.c,$(XF86SRC)/int10)
+LinkSourceFile(xf86int10.c,$(XF86SRC)/int10)
+LinkSourceFile(pci.c,$(XF86SRC)/int10)
+LinkSourceFile(xf86int10module.c,$(XF86SRC)/int10)
+LinkSourceFile(xf86x86emu.c,$(XF86SRC)/int10)
+LinkSourceFile(generic.c,$(XF86SRC)/int10)
+
+INCLUDES = -I. -I$(XF86COMSRC) -I$(XF86SRC)/int10 \
+           -I$(XF86OSSRC) \
+           -I$(SERVERSRC)/include -I$(XINCLUDESRC)
+
+DEFINES=-DHAVE_SYSV_IPC
+
+#if 0
+/* debugging stuff */
+#DEFINES =-D_PC
+#undef XF86INT10_BUILD 
+#define XF86INT10_BUILD X86EMU_GENERIC
+#define X86EMU_LIBPATH /usr/local/lib
+#endif
+
+#if defined(i386Architecture)
+DEFINES =-D_PC
+#endif
+
+/* XXX keep this temporarily for reference */
+#if 0
+#if (XF86INT10_BUILD == X86EMU_GENERIC) 
+
+SRCS = $(SRCS1) xf86x86emu.c generic.c
+OBJS = $(OBJS1) xf86x86emu.o generic.o x86emu.o
+SpecialObjectRule(pci.o, pci.c, -D_X86EMU)
+SpecialObjectRule(helper_exec.o, helper_exec.c, -D_X86EMU)
+SpecialObjectRule(xf86int10.o, xf86int10.c, -D_X86EMU -DSHOW_ALL_DEVICES)
+SpecialObjectRule(generic.o, generic.c, -D_X86EMU)
+SpecialObjectRule(xf86x86emu.o, xf86x86emu.c, -D_X86EMU)
+BuildObjectFromLibraryWithPath(X86EMU_LIBPATH,x86emu,x86emu)
+#endif
+#endif
+
+#if defined(XF86INT10_BUILD) && (XF86INT10_BUILD == X86VM)
+
+SRCS = $(SRCS1) linux.c
+OBJS = $(OBJS1) linux.o
+SpecialObjectRule(pci.o, pci.c, -D_VM86_LINUX)
+SpecialObjectRule(helper_exec.o, helper_exec.c, -D_VM86_LINUX)
+SpecialObjectRule(xf86int10.o, xf86int10.c, -D_VM86_LINUX -DSHOW_ALL_DEVICES)
+SpecialObjectRule(linux.o, linux.c, -D_VM86_LINUX -DHAVE_SYSV_IPC)
+
+#elif (XF86INT10_BUILD == X86EMU_OS)
+
+SpecialObjectRule(pci.o, pci.c, -D_X86EMU)
+SpecialObjectRule(helper_exec.o, helper_exec.c, -D_X86EMU)
+SpecialObjectRule(xf86int10.o, xf86int10.c, -D_X86EMU -DSHOW_ALL_DEVICES)
+SpecialObjectRule(linux.o, linux.c, -D_X86EMU -DHAVE_SYSV_IPC)
+
+X86TOPDIR = $(TOP)/extras/x86emu
+X86SRCDIR = $(X86TOPDIR)/src/x86emu
+X86EMUINCLUDES = -I$(X86TOPDIR)/include -I$(X86SRCDIR)
+
+# if !defined(X86EMU_LIBPATH) 
+X86EMUSRCS = debug.c decode.c fpu.c ops.c ops2.c prim_ops.c sys.c
+X86EMUOBJS = debug.o decode.o fpu.o ops.o ops2.o prim_ops.o sys.o
+
+LinkSourceFile(debug.c,$(X86SRCDIR))
+LinkSourceFile(decode.c,$(X86SRCDIR))
+LinkSourceFile(fpu.c,$(X86SRCDIR))
+LinkSourceFile(ops.c,$(X86SRCDIR))
+LinkSourceFile(ops2.c,$(X86SRCDIR))
+LinkSourceFile(prim_ops.c,$(X86SRCDIR))
+LinkSourceFile(sys.c,$(X86SRCDIR))
+# else
+BuildObjectFromLibraryWithPath(X86EMU_LIBPATH,x86emu,x86emu)
+X86EMUOBJS = x86emu.o
+# endif 
+
+SRCS = $(SRCS1) xf86x86emu.c linux.c $(X86EMUSRCS)
+OBJS = $(OBJS1) xf86x86emu.o linux.o $(X86EMUOBJS)
+
+#endif
+
+#if defined(XF86INT10_BUILD) && XF86INT10_BUILD > X86EMU_GENERIC
+
+LibraryModuleTarget(int10, $(OBJS))
+
+InstallLibraryModule(int10,$(MODULEDIR),linux)
+
+all::
+	@(set -x; cd ../..; \
+	RemoveFile(LibraryTargetName(int10)); \
+	$(LN) linux/int10/LibraryTargetName(int10) . )
+
+InstallDriverSDKLibraryModule(int10,$(DRIVERSDKMODULEDIR),.)
+
+InstallDriverSDKNonExecFile(../../int10/xf86int10.h,$(DRIVERSDKINCLUDEDIR))
+
+#endif
+
+DependTarget()
+
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/int10/os2.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/int10/os2.c
new file mode 100644
index 000000000..d01cfb373
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/int10/os2.c
@@ -0,0 +1,452 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/int10/os2.c,v 1.3 2001/04/30 14:34:58 tsi Exp $ */
+/*
+ *                   XFree86 int10 module
+ *   execute BIOS int 10h calls in x86 real mode environment
+ *                 Copyright 1999 Egbert Eich
+ */
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86str.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+#include "xf86Pci.h"
+#include "compiler.h"
+#define _INT10_PRIVATE
+#include "xf86int10.h"
+#include "int10Defines.h"
+
+static CARD8 read_b(xf86Int10InfoPtr pInt,int addr);
+static CARD16 read_w(xf86Int10InfoPtr pInt,int addr);
+static CARD32 read_l(xf86Int10InfoPtr pInt,int addr);
+static void write_b(xf86Int10InfoPtr pInt,int addr, CARD8 val);
+static void write_w(xf86Int10InfoPtr pInt,int addr, CARD16 val);
+static void write_l(xf86Int10InfoPtr pInt,int addr, CARD32 val);
+
+/*
+ * the emulator cannot pass a pointer to the current xf86Int10InfoRec
+ * to the memory access functions therefore store it here.
+ */
+
+typedef struct {
+    int shift;
+    int pagesize_1;
+    int entries;
+    void* vRam;
+    memType *alloc_rec;
+} genericInt10Priv;
+
+#define INTPriv(x) ((genericInt10Priv*)x->private)
+
+int10MemRec genericMem = {
+    read_b,
+    read_w,
+    read_l,
+    write_b,
+    write_w,
+    write_l
+};
+
+static void MapVRam(xf86Int10InfoPtr pInt);
+static void UnmapVRam(xf86Int10InfoPtr pInt);
+static void setupTable(xf86Int10InfoPtr pInt, memType address,
+		       int loc,int size);
+
+static void *sysMem = NULL;
+
+xf86Int10InfoPtr
+xf86InitInt10(int entityIndex)
+{
+    xf86Int10InfoPtr pInt;
+    int screen;
+    void* intMem;
+    void* vbiosMem;
+    int pagesize;
+    int entries;
+    int shift;
+    legacyVGARec vga;
+    
+    screen = (xf86FindScreenForEntity(entityIndex))->scrnIndex;
+    
+    if (int10skip(xf86Screens[screen],entityIndex))
+	return NULL;
+
+    pInt = (xf86Int10InfoPtr)xnfcalloc(1,sizeof(xf86Int10InfoRec));
+    pInt->entityIndex = entityIndex;
+    if (!xf86Int10ExecSetup(pInt))
+	goto error0;
+    pInt->mem = &genericMem;
+    pagesize = xf86getpagesize();
+    pInt->private = (pointer)xnfcalloc(1,sizeof(genericInt10Priv));
+    entries = SYS_SIZE / pagesize;
+
+    pInt->scrnIndex = screen;
+    INTPriv(pInt)->pagesize_1 = pagesize - 1;
+    INTPriv(pInt)->entries = entries;
+    INTPriv(pInt)->alloc_rec =
+	xnfcalloc(1,sizeof(memType) * entries);
+    for (shift = 0 ; (pagesize >> shift) ; shift++) {};
+    shift -= 1;
+    INTPriv(pInt)->shift = shift;
+
+    /*
+     * we need to map video RAM MMIO as some chipsets map mmio
+     * registers into this range.
+     */
+
+    MapVRam(pInt);
+    intMem = xnfalloc(pagesize);
+    setupTable(pInt,(memType)intMem,0,pagesize);
+    vbiosMem = xnfalloc(V_BIOS_SIZE);
+
+#ifdef _PC
+    if (!sysMem)
+	sysMem = xf86MapVidMem(screen,VIDMEM_FRAMEBUFFER,SYS_BIOS,BIOS_SIZE);
+    setupTable(pInt,(memType)sysMem,SYS_BIOS,BIOS_SIZE);
+    if (xf86ReadBIOS(0,0,(unsigned char *)intMem,LOW_PAGE_SIZE) < 0) {
+	xf86DrvMsg(screen,X_ERROR,"Cannot read int vect\n");
+	goto error1;
+    }
+    if (xf86IsEntityPrimary(entityIndex)) {
+	int size;
+	int cs = MEM_RW(pInt,((0x10<<2)+2));
+
+int i,k,m;
+char buf[100], hx[10];
+for (i=0; i<0x100; i+=16) {
+sprintf(buf,"%04x: ",i);
+for (k=0; k<16; k++) {
+  m = MEM_RB(pInt,i+k);
+  sprintf(hx,"%02x ",((unsigned)m)&0xff);
+  strcat(buf,hx);
+}
+xf86DrvMsg(screen,X_INFO,"%s\n",buf);
+}
+
+
+
+	xf86DrvMsg(screen,X_INFO,"Primary V_BIOS segmant is: 0x%x\n",cs);
+	if (xf86ReadBIOS(cs << 4,0,(unsigned char *)vbiosMem,
+			 0x10) < 0) {
+	    xf86DrvMsg(screen,X_ERROR,"Cannot read V_BIOS (1)\n");
+	    goto error1;
+	}
+	if (!((*(CARD8*)vbiosMem == 0x55)
+	      && (*((CARD8*)vbiosMem + 1) == 0xAA))) {
+	    xf86DrvMsg(screen,X_ERROR,"No V_BIOS found\n");
+	    goto error1;
+	}
+	
+	size = *((CARD8*)vbiosMem + 2) * 512;
+	if (xf86ReadBIOS(cs << 4,0,vbiosMem, size) < 0) {
+	    xf86DrvMsg(screen,X_ERROR,"Cannot read V_BIOS (2)\n");
+	    goto error1;
+	}
+
+	setupTable(pInt,(memType)vbiosMem,cs<<4,size);
+	set_return_trap(pInt);
+	pInt->BIOSseg = cs;
+    } else {
+	reset_int_vect(pInt);
+	set_return_trap(pInt);
+	if (!mapPciRom(pInt,(unsigned char *)(vbiosMem))) {
+	    xf86DrvMsg(screen,X_ERROR,"Cannot read V_BIOS (3)\n");
+	    goto error1;
+	}
+	setupTable(pInt,(memType)vbiosMem,V_BIOS,V_BIOS_SIZE);
+	pInt->BIOSseg = V_BIOS >> 4;
+	pInt->num = 0xe6;
+	LockLegacyVGA(pInt, &vga); 
+	xf86ExecX86int10(pInt);
+	UnlockLegacyVGA(pInt, &vga);
+    }
+#else
+    if (!sysMem) {
+	sysMem = xnfalloc(BIOS_SIZE);
+	setup_system_bios((memType)sysMem);
+    }
+    setupTable(pInt,(memType)sysMem,SYS_BIOS,BIOS_SIZE);
+    setup_int_vect(pInt);
+    set_return_trap(pInt);
+    if (!mapPciRom(pInt,(unsigned char *)(vbiosMem))) {
+	xf86DrvMsg(screen,X_ERROR,"Cannot read V_BIOS (4)\n");
+	goto error1;
+    }
+    setupTable(pInt,(memType)vbiosMem,V_BIOS,V_BIOS_SIZE);
+    pInt->BIOSseg = V_BIOS >> 4;
+    pInt->num = 0xe6;
+    LockLegacyVGA(pInt, &vga);	   
+    xf86ExecX86int10(pInt);
+    UnlockLegacyVGA(pInt, &vga);
+#endif
+    return pInt;
+
+ error1:
+    xfree(vbiosMem);
+    xfree(intMem);
+    UnmapVRam(pInt);
+    xfree(INTPriv(pInt)->alloc_rec);
+    xfree(pInt->private);
+ error0:
+    xfree(pInt);
+
+    return NULL;
+}
+
+static void
+MapVRam(xf86Int10InfoPtr pInt)
+{
+    int screen = pInt->scrnIndex;
+    int pagesize = INTPriv(pInt)->pagesize_1 + 1;
+    int size = ((VRAM_SIZE + pagesize - 1)/pagesize) * pagesize;
+    INTPriv(pInt)->vRam = xf86MapVidMem(screen,VIDMEM_MMIO,V_RAM,size);
+}
+
+static void 
+UnmapVRam(xf86Int10InfoPtr pInt)
+{
+    int screen = pInt->scrnIndex;
+    int pagesize = INTPriv(pInt)->pagesize_1 + 1;
+    int size = ((VRAM_SIZE + pagesize - 1)/pagesize) * pagesize;
+
+    xf86UnMapVidMem(screen,INTPriv(pInt)->vRam,size);
+}
+
+Bool
+MapCurrentInt10(xf86Int10InfoPtr pInt)
+{
+    /* nothing to do here */
+    return TRUE;
+}
+
+void
+xf86FreeInt10(xf86Int10InfoPtr pInt)
+{
+    int pagesize; 
+
+    if (!pInt)
+      return;
+    pagesize = INTPriv(pInt)->pagesize_1 + 1;
+    if (Int10Current == pInt) 
+	Int10Current = NULL;
+    xfree(INTPriv(pInt)->alloc_rec[V_BIOS/pagesize]);
+    xfree(INTPriv(pInt)->alloc_rec[0]);
+    UnmapVRam(pInt);
+    xfree(INTPriv(pInt)->alloc_rec);
+    xfree(pInt->private);
+    xfree(pInt);
+}
+
+void *
+xf86Int10AllocPages(xf86Int10InfoPtr pInt,int num, int *off)
+{
+    void* addr;
+    int pagesize = INTPriv(pInt)->pagesize_1 + 1;
+    int num_pages = INTPriv(pInt)->entries;
+    int i,j;
+    
+    for (i=0;i<num_pages - num;i++) {
+	if (INTPriv(pInt)->alloc_rec[i] == 0) {
+	    for (j=i;j < num + i;j++)
+		if ((INTPriv(pInt)->alloc_rec[j] != 0))
+		    break;
+	    if (j == num + i)
+		break;
+	    else
+		i = i + num;
+	}
+    }
+    if (i == num_pages - num)
+	return NULL;
+
+    *off = i * pagesize;
+    addr = xnfalloc(pagesize * num);
+    setupTable(pInt,(memType)addr,*off,pagesize * num);
+    
+    return addr;
+}
+
+void
+xf86Int10FreePages(xf86Int10InfoPtr pInt, void *pbase, int num)
+{
+    int num_pages = INTPriv(pInt)->entries;
+    int i,j;
+    for (i = 0;i<num_pages - num; i++)
+	if (INTPriv(pInt)->alloc_rec[i]==(memType)pbase) {
+	    for (j = 0; j < num; j++)
+		INTPriv(pInt)->alloc_rec[i] = 0;
+	    break;
+	}
+    xfree(pbase);
+    return;
+}
+
+static void
+setupTable(xf86Int10InfoPtr pInt, memType address,int loc,int size)
+{
+    int pagesize = INTPriv(pInt)->pagesize_1 + 1;
+    int i,j,num;
+
+    i = loc / pagesize;
+    num = (size + pagesize - 1)/ pagesize; /* round up to the nearest page */
+                                           /* boudary if size is not       */
+                                           /* multiple of pagesize         */
+    for (j = 0; j<num; j++) {
+	INTPriv(pInt)->alloc_rec[i+j] = address;
+	address += pagesize;
+    }
+}
+
+#define OFF(addr) \
+          ((addr) & (INTPriv(pInt)->pagesize_1))
+#define SHIFT \
+          (INTPriv(pInt)->shift)
+#define BASE(addr,shift) \
+          (INTPriv(pInt)->alloc_rec[addr >> shift])
+#define V_ADDR(addr,shift,off) \
+          (BASE(addr,shift) + (off))
+#define VRAM_ADDR(addr) (addr - 0xA0000)
+#define VRAM_BASE (INTPriv(pInt)->vRam)
+
+#define VRAM(addr) ((addr >= 0xA0000) && (addr <= 0xBFFFF))
+#define V_ADDR_RB(addr,shift,off) \
+        (VRAM(addr)) ? MMIO_IN8((CARD8*)VRAM_BASE,VRAM_ADDR(addr)) \
+           : *(CARD8*) V_ADDR(addr,shift,off)
+#define V_ADDR_RW(addr,shift,off) \
+        (VRAM(addr)) ? MMIO_IN16((CARD16*)VRAM_BASE,VRAM_ADDR(addr)) \
+           : ldw_u((pointer)V_ADDR(addr,shift,off))
+#define V_ADDR_RL(addr,shift,off) \
+        (VRAM(addr)) ? MMIO_IN32((CARD32*)VRAM_BASE,VRAM_ADDR(addr)) \
+           : ldl_u((pointer)V_ADDR(addr,shift,off))
+
+#define V_ADDR_WB(addr,shift,off,val) \
+        if(VRAM(addr)) \
+            MMIO_OUT8((CARD8*)VRAM_BASE,VRAM_ADDR(addr),val); \
+        else \
+            *(CARD8*) V_ADDR(addr,shift,off) = val;
+#define V_ADDR_WW(addr,shift,off,val) \
+        if(VRAM(addr)) \
+            MMIO_OUT16((CARD16*)VRAM_BASE,VRAM_ADDR(addr),val); \
+        else \
+            stw_u((val),(pointer)(V_ADDR(addr,shift,off)));
+
+#define V_ADDR_WL(addr,shift,off,val) \
+        if (VRAM(addr)) \
+            MMIO_OUT32((CARD32*)VRAM_BASE,VRAM_ADDR(addr),val); \
+        else \
+            stl_u(val,(pointer)(V_ADDR(addr,shift,off)));
+
+static CARD8
+read_b(xf86Int10InfoPtr pInt, int addr)
+{
+    if (!BASE(addr,SHIFT)) return 0xff;
+    
+    return V_ADDR_RB(addr,SHIFT,OFF(addr));
+}
+
+static CARD16
+read_w(xf86Int10InfoPtr pInt, int addr)
+{
+    int shift = SHIFT;
+    int off = OFF(addr);
+
+    if (!BASE(addr,shift)) return 0xffff;
+    
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+    return ((V_ADDR_RB(addr,shift,off))
+	    || ((V_ADDR_RB(addr,shift,off + 1)) << 8));
+#else
+    if (OFF(addr + 1) > 0) {
+	return V_ADDR_RW(addr,SHIFT,OFF(addr));
+    } else {
+	return ((V_ADDR_RB(addr,shift,off + 1))
+	    || ((V_ADDR_RB(addr,shift,off)) << 8));
+    }
+#endif
+}
+
+static CARD32
+read_l(xf86Int10InfoPtr pInt, int addr)
+{
+    int shift = SHIFT;
+    int off = OFF(addr);
+	
+    if (!BASE(addr,shift)) return 0xffffffff;
+    
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+    return ((V_ADDR_RB(addr,shift,off))
+	    || ((V_ADDR_RB(addr,shift,off + 1)) << 8)
+	    || ((V_ADDR_RB(addr,shift,off + 2)) << 16)
+	    || ((V_ADDR_RB(addr,shift,off + 3)) << 24));
+#else
+    if (OFF(addr + 3) > 2) {
+	return V_ADDR_RL(addr,SHIFT,OFF(addr));
+    } else {
+	return ((V_ADDR_RB(addr,shift,off + 3))
+		|| ((V_ADDR_RB(addr,shift,off + 2)) << 8)
+		|| ((V_ADDR_RB(addr,shift,off + 1)) << 16)
+		|| ((V_ADDR_RB(addr,shift,off)) << 24));
+    }
+#endif
+}
+
+static void
+write_b(xf86Int10InfoPtr pInt, int addr, CARD8 val)
+{
+    if (!BASE(addr,SHIFT)) return;
+    
+    V_ADDR_WB(addr,SHIFT,OFF(addr),val);
+}
+
+static void
+write_w(xf86Int10InfoPtr pInt, int addr, CARD16 val)
+{
+    int shift = SHIFT;
+    int off = OFF(addr);
+    
+    if (!BASE(addr,shift)) return;
+    
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+    V_ADDR_WB(addr,shift,off,val);
+    V_ADDR_WB(addr,shift,off + 1,val >> 8);
+#else
+    if (OFF(addr + 1) > 0) {
+	V_ADDR_WW(addr,shift,OFF(addr),val);
+    } else {
+	V_ADDR_WB(addr,shift,off + 1,val);
+	V_ADDR_WB(addr,shift,off,val >> 8);
+    }
+#endif
+}
+
+static void
+write_l(xf86Int10InfoPtr pInt, int addr, CARD32 val)
+{
+    int shift = SHIFT;
+    int off = OFF(addr);
+    if (!BASE(addr,shift)) return;
+    
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+    V_ADDR_WB(addr,shift,off,val);
+    V_ADDR_WB(addr,shift,off + 1, val >> 8);
+    V_ADDR_WB(addr,shift,off + 2, val >> 16);
+    V_ADDR_WB(addr,shift,off + 3, val >> 24);
+#else
+    if (OFF(addr + 3) > 2) {
+	V_ADDR_WL(addr,shift,OFF(addr),val);
+    } else {
+	V_ADDR_WB(addr,shift,off + 3, val);
+	V_ADDR_WB(addr,shift,off + 2, val >> 8);
+	V_ADDR_WB(addr,shift,off + 1, val >> 16);
+	V_ADDR_WB(addr,shift,off, val >> 24);
+    }
+#endif
+}
+
+pointer
+xf86int10Addr(xf86Int10InfoPtr pInt, CARD32 addr)
+{
+    return (pointer) V_ADDR(addr,SHIFT,OFF(addr));
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_VTsw.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_VTsw.c
new file mode 100644
index 000000000..e050a62cb
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_VTsw.c
@@ -0,0 +1,340 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_VTsw.c,v 3.13 2003/06/10 17:03:54 dawes Exp $ */
+/*
+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>
+ * Modified 1996 by Sebastien Marineau <marineau@genie.uottawa.ca>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of David Wexelblat not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  David Wexelblat makes no representations
+ * about the suitability of this software for any purpose.  It is provided
+ * "as is" without express or implied warranty.
+ *
+ * DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL DAVID WEXELBLAT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+/* $XConsortium: os2_VTsw.c /main/7 1996/05/13 16:37:55 kaleb $ */
+
+#define I_NEED_OS2_H
+#define NEED_EVENTS
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "input.h"
+#include "scrnintstr.h"
+
+#define INCL_WINSWITCHLIST
+#define INCL_VIO
+#define INCL_KBD
+#define INCL_DOSPROCESS
+#define INCL_DOSSEMAPHORES
+#define INCL_DOSERRORS
+#undef RT_FONT
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+#include "atKeynames.h"
+
+BOOL SwitchedToWPS=FALSE;
+BOOL WaitingForAccess=FALSE;
+void os2PostKbdEvent();
+HEV hevServerHasFocus;
+HEV hevSwitchRequested;
+HEV hevErrorPopupDetected;
+extern HEV hevPopupPending;
+extern HEV hSwitchToSem;
+BOOL os2PopupErrorPending=FALSE;
+
+/*
+ * Added OS/2 code to handle switching back to WPS
+ */
+
+
+Bool xf86VTSwitchPending()
+{
+	return(xf86Info.vtRequestsPending ? TRUE : FALSE);
+}
+
+Bool xf86VTSwitchAway()
+{
+        APIRET rc;
+	ULONG  drive;
+
+        xf86Info.vtRequestsPending=FALSE;
+        SwitchedToWPS=TRUE;
+
+	rc = DosQuerySysInfo(5,5,&drive,sizeof(drive));
+	rc = DosSuppressPopUps(0x0000L,drive+96);	/* Disable popups */
+	DosPostEventSem(hevSwitchRequested);
+	usleep(30000);
+	return(TRUE);
+}
+
+Bool xf86VTSwitchTo()
+{
+	APIRET rc;
+	ULONG drive,postCount;
+
+	xf86Info.vtRequestsPending=FALSE;
+	SwitchedToWPS=FALSE;
+	rc = DosResetEventSem(hSwitchToSem,&postCount);
+	DosPostEventSem(hevSwitchRequested);
+	rc = DosQuerySysInfo(5,5,&drive,sizeof(drive));
+	rc = DosSuppressPopUps(0x0001L,drive+96);     /* Disable popups */
+
+	/* We reset the state of the control key */
+	os2PostKbdEvent(KEY_LCtrl,1);
+	os2PostKbdEvent(KEY_LCtrl,0);
+	os2PostKbdEvent(KEY_RCtrl,1);
+	os2PostKbdEvent(KEY_RCtrl,0);
+	os2PostKbdEvent(KEY_Alt,1);
+	os2PostKbdEvent(KEY_Alt,0);
+	return(TRUE);
+}
+
+
+/* This function is run as a thread and will notify of switch-to/switch-away events */
+void os2VideoNotify(arg)
+void * arg;
+{
+   USHORT Indic;
+   USHORT NotifyType;
+   APIRET rc;
+   ULONG postCount;
+   Bool FirstTime=TRUE;
+   int timeout_count;
+
+	rc=DosCreateEventSem(NULL,&hevServerHasFocus,0L,FALSE);
+	rc=DosPostEventSem(hevServerHasFocus);
+	rc=DosCreateEventSem(NULL,&hevSwitchRequested,0L,FALSE);
+	rc=DosPostEventSem(hevSwitchRequested);
+
+
+	while(1) {
+	  Indic=0;
+	  rc=VioSavRedrawWait(Indic,&NotifyType,(HVIO)0);
+
+/* Here we handle the semaphore used to indicate wether we have screen access */
+	  if(NotifyType==0) rc=DosResetEventSem(hevServerHasFocus,&postCount);
+          if(FirstTime){
+                   FirstTime=FALSE;
+                   if(NotifyType==1) NotifyType=65535; /* In case a redraw is requested on first call */
+                }
+
+	  if(NotifyType==1){
+/* Notify os2PseudoSelect() that we are back */
+			rc=DosPostEventSem(hSwitchToSem);
+			if (rc) xf86Msg(X_ERROR,"Post SwitchToSem returned %d\n");
+/* Sanity check */
+		if (!SwitchedToWPS) {
+			xf86Msg(X_ERROR,
+				"Abnormal switching back to server detected\n");
+		}
+	  }
+
+/* Here we set the semaphore used to indicate switching request */
+
+        if((NotifyType!=65535)&&(!WaitingForAccess)) {
+                rc=DosResetEventSem(hevSwitchRequested,&postCount);
+                xf86Info.vtRequestsPending=TRUE;
+/* Then wait for semaphore to be posted once switch is complete. Wait 20 secs, then kill server */
+               timeout_count=0;
+               rc=DosSetPriority(2,3,0,1);
+                     do {
+                            rc=DosWaitEventSem(hevSwitchRequested,1000L);
+                            if(rc==ERROR_TIMEOUT){
+                               timeout_count++;
+                               if(timeout_count>25){
+                                  xf86Msg(X_ERROR,
+					  "Server timeout on VT switch request. Server was killed\n");
+                                  DosExit(1L,0);
+                                  }
+                               if(WaitingForAccess) {  /* The server is resetting */
+                                  DosPostEventSem(hevSwitchRequested);
+                                  xf86Info.vtRequestsPending=FALSE;
+                                  }
+                               }
+                          } while (rc==ERROR_TIMEOUT);
+          rc=DosSetPriority(2,2,0,1);
+          }
+         if(NotifyType==1) rc=DosPostEventSem(hevServerHasFocus);
+         if((NotifyType==0)&&(!SwitchedToWPS))
+		xf86Msg(X_ERROR,
+			"Abnormal switching away from server!\n");
+	} /* endwhile */
+
+/* End of thread */
+}
+
+/* This function is run as a thread and will notify of hard-error events */
+void os2HardErrorNotify(arg)
+void * arg;
+{
+   USHORT Indic;
+   USHORT NotifyType;
+   APIRET rc;
+   ULONG postCount;
+
+	rc=DosCreateEventSem(NULL,&hevErrorPopupDetected,0L,FALSE);
+	rc=DosPostEventSem(hevErrorPopupDetected);
+        os2PopupErrorPending=FALSE;
+
+	while(1) {
+	   Indic=0;
+	   rc=VioModeWait(Indic,&NotifyType,(HVIO)0);
+	   if(NotifyType==0){
+                os2PopupErrorPending=TRUE;
+                rc=DosPostEventSem(hSwitchToSem);
+                rc=DosResetEventSem(hevErrorPopupDetected,&postCount);
+                rc=DosWaitEventSem(hevErrorPopupDetected,20000L);
+                if(rc==ERROR_TIMEOUT) GiveUp(0);  /* Shutdown on timeout of semaphore */
+	   }
+	} /* endwhile */
+
+/* End of thread */
+}
+
+static BOOL is_redirected = FALSE;
+
+static void
+redirect_output(void)
+{
+	/* hv300996 create redirect file on boot drive, instead
+	 * anywhere you are just standing
+	 */
+	char buf[20],dr[3];
+	ULONG drive;
+	APIRET rc;
+
+	if (is_redirected) return;
+
+	if ((rc = DosQuerySysInfo(5,5,&drive,sizeof(drive))) != 0)
+		dr[0] = 0;
+	else {	
+		dr[0] = drive+96;
+		dr[1] = ':';
+		dr[2] = 0;
+	}
+	sprintf(buf,"%s\\xf86log.os2",dr);
+
+	ErrorF("\nThis is the XFree86/OS2-4.0 server\n");
+	ErrorF("\nAll output from now on will be redirected to %s\n",buf);
+	freopen(buf,"w",stderr);
+
+	is_redirected = TRUE;
+}
+
+void
+os2ServerVideoAccess()
+{
+   APIRET rc;
+   ULONG fgSession;
+   ULONG length=4;
+   CHAR Status;
+
+   /* Redirect output as early as possible */
+   /* redirect_output(); */
+   /* too many logfiles, server will log to /usr/adm */
+
+/* Wait for screen access. This is called at server reset or at server startup */
+/* Here we do some waiting until this session comes in the foreground before *
+ * going any further. This is because we may have been started in the bg      */
+
+        if(serverGeneration==1){
+                rc=VioScrLock(0, &Status, (HVIO)0);
+                while(Status != 0){
+                        rc=VioScrLock(0, &Status, (HVIO)0);
+                        DosSleep(1000);
+                        }
+                VioScrUnLock((HVIO)0);
+                return;
+                }
+        WaitingForAccess=TRUE;
+        rc=DosWaitEventSem(hevServerHasFocus,SEM_INDEFINITE_WAIT);
+        WaitingForAccess=FALSE;
+        SwitchedToWPS=FALSE;  /* In case server has reset while we were switched to WPS */
+}
+
+/* This next function will attempt to recover from a hard error popup
+ * with an EnterLeave call
+ */
+
+void os2RecoverFromPopup()
+{
+	int j;
+	ULONG postCount;
+
+	if (os2PopupErrorPending) {
+#if 0
+		for (j = 0; j < screenInfo.numScreens; j++)
+			(XF86SCRNINFO(screenInfo.screens[j])->EnterLeaveVT)(LEAVE, j);
+		for (j = 0; j < screenInfo.numScreens; j++)
+			(XF86SCRNINFO(screenInfo.screens[j])->EnterLeaveVT)(ENTER, j);
+#endif
+		DosResetEventSem(hSwitchToSem,&postCount);
+
+		for (j = 0; j < xf86NumScreens; j++) {
+			if (xf86Screens[j]->EnableDisableFBAccess)
+				(*xf86Screens[j]->EnableDisableFBAccess)(j, FALSE);
+		}
+		xf86EnterServerState(SETUP);
+		for (j = 0; j < xf86NumScreens; j++)
+			xf86Screens[j]->LeaveVT(j, 0);
+		for (j = 0; j < xf86NumScreens; j++) {
+			xf86Screens[j]->EnterVT(j, 0);
+		}
+		xf86EnterServerState(OPERATING);
+		for (j = 0; j < xf86NumScreens; j++) {
+			if (xf86Screens[j]->EnableDisableFBAccess)
+				(*xf86Screens[j]->EnableDisableFBAccess)(j, TRUE);
+		}
+
+		/* We reset the state of the control key */
+		os2PostKbdEvent(KEY_LCtrl,1);
+		os2PostKbdEvent(KEY_LCtrl,0);
+		os2PostKbdEvent(KEY_RCtrl,1);
+		os2PostKbdEvent(KEY_RCtrl,0);
+		os2PostKbdEvent(KEY_Alt,1);
+		os2PostKbdEvent(KEY_Alt,0);
+
+		/* Turn screen saver off when switching back */
+		SaveScreens(SCREEN_SAVER_FORCER,ScreenSaverReset);
+		os2PopupErrorPending=FALSE;
+		DosPostEventSem(hevErrorPopupDetected);
+	}
+}
+
+/* This checks wether a popup event is waiting. The semaphore would be reset
+ * by the XF86VIO.DLL function
+ */
+
+void os2CheckPopupPending()
+{
+	int j;
+	ULONG postCount;
+
+	return;  /* For now this is a no-op */
+
+#if 0
+	DosQueryEventSem(hevPopupPending,&postCount);
+	if (postCount==0) {               /* We have a popup pending */
+#if 0
+		for (j = 0; j < screenInfo.numScreens; j++)
+			(XF86SCRNINFO(screenInfo.screens[j])->EnterLeaveVT)(LEAVE, j);
+#endif
+		DosPostEventSem(hevPopupPending);
+	}
+#endif
+}
+
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_bios.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_bios.c
new file mode 100644
index 000000000..4069ad745
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_bios.c
@@ -0,0 +1,143 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_bios.c,v 3.10 2000/04/05 18:13:52 dawes Exp $ */
+/*
+ * (c) Copyright 1994 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ * Modified 1996 by Sebastien Marineau <marineau@genie.uottawa.ca>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XConsortium: os2_bios.c /main/5 1996/10/27 11:48:45 kaleb $ */
+
+#define I_NEED_OS2_H
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "input.h"
+#include "scrnintstr.h"
+
+#define INCL_32
+#define INCL_DOS
+#define INCL_DOSFILEMGR
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+/*
+ * Read BIOS via xf86sup.SYS device driver
+ */
+
+static APIRET doioctl(HFILE fd,ULONG addr,ULONG len,unsigned char* dbuf)
+{
+	UCHAR	*dta;
+	ULONG	plen,dlen;
+	APIRET rc;
+
+	struct {
+		ULONG command;
+		ULONG physaddr;
+		USHORT numbytes;
+	} par;
+
+	/* prepare parameter and data packets for ioctl */
+	par.command 	= 0;
+	par.physaddr 	= addr;
+	par.numbytes 	= dlen = len;
+	plen 		= sizeof(par);
+
+	/* issue call to get a readonly copy of BIOS ROM */
+	rc = DosDevIOCtl(fd, (ULONG)0x76, (ULONG)0x64,
+	   (PVOID)&par, (ULONG)plen, (PULONG)&plen,
+	   (PVOID)dbuf, (ULONG)dlen, (PULONG)&dlen);
+
+	return rc;
+}
+
+int xf86ReadBIOS(Base, Offset, Buf, Len)
+unsigned long Base;
+unsigned long Offset;
+unsigned char *Buf;
+int Len;
+{
+	HFILE	fd;
+	int	i;
+	ULONG	action;
+	APIRET	rc;
+	ULONG	Phys_address;
+	UCHAR*	dta;
+	int	off, chunksz,lensave;
+
+	/* allocate dta */
+	dta = (UCHAR*)xalloc(Len);
+
+	Phys_address=Base+Offset;
+
+	/* open the special device pmap$ (default with OS/2) */
+	if (DosOpen((PSZ)"PMAP$", (PHFILE)&fd, (PULONG)&action,
+	   (ULONG)0, FILE_SYSTEM, FILE_OPEN,
+	   OPEN_SHARE_DENYNONE|OPEN_FLAGS_NOINHERIT|OPEN_ACCESS_READONLY,
+	   (ULONG)0) != 0) {
+		FatalError("xf86ReadBIOS: install DEVICE=path\\xf86sup.SYS!");
+		return -1;
+	}
+
+ 	/* copy 32K at a time */
+ 	off = 0;
+ 	lensave = Len;
+ 	while (Len > 0) {
+ 		chunksz = (Len > 32768) ? 32768 : Len;
+ 		Len -= chunksz;
+ 		rc = doioctl(fd,(ULONG)Phys_address,chunksz,dta+off);
+ 		if (rc != 0) {
+ 			FatalError("xf86ReadBIOS: BIOS map failed, addr=%lx, rc=%d\n",
+ 			Phys_address,rc);
+ 			xfree(dta);
+ 			DosClose(fd);
+ 			return -1;
+ 		}		
+ 		off += chunksz;
+  	}
+
+	/*
+	 * Sanity check... No longer fatal, as some PS/1 and PS/2 fail here but still work.
+	 * S. Marineau, 10/10/96
+         */
+#if 0
+	if ((Phys_address & 0x7fff) != 0 && 
+		(dta[0] != 0x55 || dta[1] != 0xaa)) {
+		FatalError("BIOS sanity check failed, addr=%x\nPlease report if you encounter problems\n",
+			Phys_address);
+	}
+#endif
+
+	/* copy data to buffer */
+ 	memcpy(Buf, dta, lensave);
+	xfree(dta);
+
+	/* close device */
+	DosClose(fd);
+
+ 	return(lensave);
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_diag.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_diag.c
new file mode 100644
index 000000000..f321df5c2
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_diag.c
@@ -0,0 +1,263 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_diag.c,v 3.7 2000/04/05 18:13:52 dawes Exp $ */
+/*
+ * (c) Copyright 1997 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XConsortium$ */
+
+/* This file checks whether the user has installed the system correctly, 
+ * to avoid the numerous questions why this or that does not work
+ */
+
+#define I_NEED_OS2_H
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include "input.h"
+#include "scrnintstr.h"
+
+#include "compiler.h"
+
+#define INCL_DOSFILEMGR
+#define INCL_KBD
+#define INCL_VIO
+#define INCL_DOSMISC
+#define INCL_DOSPROCESS
+#define INCL_DOSSEMAPHORES
+#define INCL_DOSMODULEMGR
+#define INCL_DOSFILEMGR
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+#include <netdb.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+static BOOL diag_checks = FALSE;
+
+/* from Eberhard to check for the right EMX version */
+static void 
+check_emx (void)
+{
+	ULONG rc;
+	HMODULE hmod;
+	char name[CCHMAXPATH];
+	char fail[9];
+
+	if (_emx_rev < 50) {
+		xf86Msg(X_ERROR,"This program requires emx.dll revision 50 (0.9c fix 2) "
+			"or later.\n");
+		rc = DosLoadModule (fail, sizeof (fail), "emx", &hmod);
+		if (rc == 0) {
+			rc = DosQueryModuleName (hmod, sizeof (name), name);
+			if (rc == 0)
+				xf86Msg(X_ERROR,"Please delete or update `%s'.\n", name);
+			DosFreeModule (hmod);
+		}
+		exit (2);
+        }
+}
+
+static void 
+check_bsl(const char *var)
+{
+	char *t1 = strrchr(var,'\\');
+	if (strchr(var,'/')) {
+		xf86Msg(X_WARNING,
+			"\"%s\" must exclusively use backward slashes \"\\\"\n",
+			var);
+	}
+	if (t1 && *(t1+1)=='\0') {
+		xf86Msg(X_WARNING,
+			"\"%s\" mustn't end with \"\\\"\n",var);
+		*t1 = '\0';
+	}
+}
+
+
+static void 
+check_fsl(const char *var)
+{
+	char *t1 = strrchr(var,'/');
+	if (strchr(var,'\\')) {
+		xf86Msg(X_WARNING,
+			"\"%s\" must exclusively use forward slashes \"/\"\n",
+			var);
+	}
+}
+
+
+static void 
+check_long(const char* path)
+{
+	FILE *f;
+	char n[300];
+
+	sprintf(n,"%s\\xf86_test_for_very_long_filename",path);
+	f = fopen(n,"w");
+	if (f==NULL) {
+		xf86Msg(X_WARNING,
+			"\"%s\" does not accept long filenames\nmust reside on HPFS or similar\n",
+		path);
+	} else {
+		fclose(f);
+		unlink(n);
+	}
+}
+
+static char *
+check_env_present(const char *env)
+{
+	char *e = getenv(env);
+	if (!e) {
+		xf86Msg(X_WARNING,
+			"You have no \"%s\" environment variable, but need one\n",
+			env);
+		return 0;
+	}
+	return e;
+}
+
+void os2_checkinstallation(void)
+{
+	char *emxopt, *tmp, *home, *logname, *termcap;
+	char hostname[256], *display, *hostvar, *s, *h;
+	struct hostent *hent;
+	struct in_addr *in;
+	int i;
+
+	if (diag_checks) return;
+	diag_checks = TRUE;
+
+	/* test whether the EMX version is okay */
+	check_emx();
+
+	/* Check a number of environment variables */
+	emxopt = getenv("EMXOPT");
+	if (emxopt) {
+		for (i=0; i<strlen(emxopt); i++) {
+			if (emxopt[i]=='-') {
+				switch (emxopt[++i]) {
+				case 't':
+					xf86Msg(X_ERROR,
+						"Remove -t option from EMXOPT variable!\n");
+					break;
+				case 'r':
+					xf86Msg(X_ERROR,
+						"Remove -r option from EMXOPT variable!\n");
+				}
+			}
+		}
+	}
+
+	tmp = check_env_present("TMP");
+	if (tmp) {
+	        check_bsl(tmp);
+	        check_long(tmp);
+	}
+
+	home = check_env_present("HOME");
+	if (home) {
+	        check_bsl(home);
+	        check_long(home);
+	}
+
+	logname = check_env_present("LOGNAME");
+	termcap = check_env_present("TERMCAP");
+	if (termcap)
+	        check_fsl(termcap);
+
+	if (gethostname(hostname,sizeof(hostname)) != 0) {
+		xf86Msg(X_ERROR,
+			"gethostname() failed: Check TCP/IP setup!\n");
+	} else {
+		xf86Msg(X_INFO,
+			"gethostname() returns: \"%s\"\n",hostname);
+	}
+
+	display = check_env_present("DISPLAY");
+	if (display)
+		xf86Msg(X_INFO,
+			"DISPLAY to listen is set to: \"%s\"\n",
+			display);
+
+	hostvar = check_env_present("HOSTNAME");
+	
+	strcpy(hostname,display);
+	h = strchr(hostname,':');
+	if (!h)
+		xf86Msg(X_WARNING,
+			"Invalid DISPLAY name: expected something like XXX:0.0\n");
+	else
+		*h = 0;
+	h = strchr(hostname,'/');
+	if (h) 
+		h++;
+	else
+		h = hostname;
+
+	if (stricmp(h,hostvar)) {
+		xf86Msg(X_WARNING,
+			"HOSTNAME does not match DISPLAY: Do you really mean this?\n");
+		xf86Msg(X_WARNING,
+			"  This means that xinit/startx and client access may not work\n");
+		xf86Msg(X_WARNING,
+			"  which is intentional usually only when connection to a XDM server\n");
+	}
+
+	hent = gethostbyname(h);
+	if (!hent) 
+		xf86Msg(X_ERROR,
+			"gethostbyname() failed: Check TCP/IP setup\n");
+	else {
+		xf86Msg(X_INFO,
+			"gethostbyname() returns the following data:\n");
+		xf86Msg(X_INFO,"  official host name: \"%s\"\n",hent->h_name);
+		while ((s= *(hent->h_aliases)) != NULL) {
+			xf86Msg(X_INFO,
+				"  alias: \"%s\"\n",s);
+			hent->h_aliases++;
+		}
+		xf86Msg(X_INFO,
+			"  addr type = %d,  addr length = %d\n",
+			hent->h_addrtype, hent->h_length);
+		if (hent->h_addrtype == AF_INET) {
+			while ((in= (struct in_addr*)*(hent->h_addr_list++)) != NULL) {
+				xf86Msg(X_INFO,
+					"  IP address: \"%s\"\n",
+					inet_ntoa(*in));
+			}
+		} else {
+			xf86Msg(X_INFO,
+				"Addrtype should be %d: Check network setup and install TCP/IP support correctly\n",
+				AF_INET);
+		}
+	}
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_init.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_init.c
new file mode 100644
index 000000000..81b2689b8
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_init.c
@@ -0,0 +1,244 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_init.c,v 3.18 2003/11/29 01:48:31 dawes Exp $ */
+/*
+ * (c) Copyright 1994 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ * Modified 1996 Sebastien Marineau <marineau@genie.uottawa.ca>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XConsortium: os2_init.c /main/9 1996/10/19 18:07:13 kaleb $ */
+
+#define I_NEED_OS2_H
+#define INCL_DOSFILEMGR
+#define INCL_KBD
+#define INCL_VIO
+#define INCL_DOSMISC
+#define INCL_DOSPROCESS
+#define INCL_DOSSEMAPHORES
+#define INCL_DOSMODULEMGR
+#define INCL_DOSFILEMGR
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <float.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include "input.h"
+#include "scrnintstr.h"
+
+#include "compiler.h"
+
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+VIOMODEINFO OriginalVideoMode;
+void os2VideoNotify();
+void os2HardErrorNotify();
+void os2KbdMonitorThread();
+void os2KbdBitBucketThread();
+HEV hevPopupPending;
+extern HEV hKbdSem;
+extern BOOL os2HRTimerFlag;
+static unsigned short cw;
+extern void os2_checkinstallation(); /* os2_diag.c */
+
+void xf86OpenConsole()
+{
+    /* try to catch problems before they become obvious */
+    os2_checkinstallation();
+
+    if (serverGeneration == 1) {
+	HKBD fd;
+	ULONG drive;
+	ULONG dummy;
+	KBDHWID hwid;
+	APIRET rc;
+	int VioTid;
+        ULONG actual_handles;
+        LONG new_handles;
+
+	/* hv 250197 workaround for xkb-Problem: switch to X11ROOT drive */
+	char *x11r = getenv("X11ROOT");
+        /* Make sure X11ROOT is set before we go further sm280297 */
+        if (x11r == NULL){ 
+           xf86Msg(X_ERROR,
+		   "Environment variable X11ROOT is not set! Aborting...\n");
+           exit(1);  
+           }
+        if (_chdir2(x11r) < 0) {
+  		xf86Msg(X_ERROR,"Cannot change to X11ROOT directory!\n");
+	}
+
+	xf86Msg(X_INFO,"Console opened\n");
+	OriginalVideoMode.cb=sizeof(VIOMODEINFO);
+	rc=VioGetMode(&OriginalVideoMode,(HVIO)0);
+	if(rc!=0) 
+		xf86Msg(X_ERROR,
+			"Could not get original video mode. RC=%d\n",rc);
+	xf86Info.consoleFd = -1;
+        
+        /* Set the number of handles to higher than the default 20. Set to 80 which should be plenty */
+        new_handles = 0;
+        rc = DosSetRelMaxFH(&new_handles,&actual_handles);
+        if (actual_handles < 80) {
+		new_handles = 80 - actual_handles;
+		rc = DosSetRelMaxFH(&new_handles,&actual_handles);
+		xf86Msg(X_INFO,"Increased number of available handles to %d\n",
+			actual_handles);
+	}
+
+	/* grab the keyboard */
+	rc = KbdGetFocus(0,0);
+	if (rc != 0)
+		FatalError("xf86OpenConsole: cannot grab kbd focus, rc=%d\n",rc);
+
+	/* open the keyboard */
+	rc = KbdOpen(&fd);
+	if (rc != 0)
+		FatalError("xf86OpenConsole: cannot open keyboard, rc=%d\n",rc);
+	xf86Info.consoleFd = fd;
+
+	xf86Msg(X_INFO,"Keyboard opened\n");
+
+	/* assign logical keyboard */
+	KbdFreeFocus(0);
+	rc = KbdGetFocus(0,fd);
+	if (rc != 0)
+		FatalError("xf86OpenConsole: cannot set local kbd focus, rc=%d\n",rc);
+
+/* Create kbd queue semaphore */
+ 
+         rc = DosCreateEventSem(NULL,&hKbdSem,DC_SEM_SHARED,TRUE);
+         if (rc != 0)
+                  FatalError("xf86OpenConsole: cannot create keyboard queue semaphore, rc=%d\n",rc);
+ 
+/* Create popup semaphore */
+
+	rc = DosCreateEventSem("\\SEM32\\XF86PUP",&hevPopupPending,DC_SEM_SHARED,1);
+	if (rc) 
+		xf86Msg(X_ERROR,
+			"Could not create popup semaphore! RC=%d\n",rc);
+#if 0
+	rc=VioRegister("xf86vio","XF86POPUP_SUBCLASS",0x20002004L,0L);
+	if (rc) {
+		FatalError("Could not register XF86VIO.DLL module. Please install in LIBPATH! RC=%d\n",
+				rc);
+	}
+#endif
+
+/* Start up the VIO monitor thread */
+	VioTid=_beginthread(os2VideoNotify,NULL,0x4000,(void *)NULL);
+	xf86Msg(X_INFO,"Started Vio thread, Tid=%d\n",VioTid);
+	rc=DosSetPriority(2,3,0,VioTid);
+
+/* Start up the hard-error VIO monitor thread */
+	VioTid=_beginthread(os2HardErrorNotify,NULL,0x4000,(void *)NULL);
+	xf86Msg(X_INFO,"Started hard error Vio mode monitor thread, Tid=%d\n",
+		VioTid);
+	rc=DosSetPriority(2,3,0,VioTid);
+
+/* We have to set the codepage before the keyboard monitor is registered */
+	rc = KbdSetCp(0,0,fd);
+	if(rc != 0)
+		FatalError("xf86OpenConsole: cannot set keyboard codepage, rc=%d\n",rc);
+
+/* Start up the kbd monitor thread */
+	VioTid=_beginthread(os2KbdMonitorThread,NULL,0x4000,(void *)NULL);
+	xf86Msg(X_INFO,"Started Kbd monitor thread, Tid=%d\n",VioTid);
+	rc=DosSetPriority(2,3,0,VioTid);
+
+/* Disable hard-errors through DosError */
+	rc = DosQuerySysInfo(5,5,&drive,sizeof(drive));
+	rc = DosSuppressPopUps(0x0001L,drive+96);     /* Disable popups */
+	
+	hwid.cb = sizeof(hwid);	/* fix crash on P9000 */
+	rc = KbdGetHWID(&hwid, fd);
+	if (rc == 0) {
+		switch (hwid.idKbd) {
+		default:
+		case 0xab54: /* 88/89 key */
+		case 0:	/*unknown*/
+		case 1: /*real AT 84 key*/
+			xf86Info.kbdType = KB_84; break;
+		case 0xab85: /* 122 key */
+			FatalError("Unsupported extended 122key keyboard found!\n",0);
+		case 0xab41: /* 101/102 key */
+			xf86Info.kbdType = KB_101; break;
+		}				
+	} else
+		xf86Info.kbdType = KB_84; /*defensive*/
+
+/* Start up the Kbd bit-bucket thread. We don't want to leave the kbd events in the driver queue */
+	VioTid=_beginthread(os2KbdBitBucketThread,NULL,0x2000,(void *)NULL);
+	xf86Msg(X_INFO,"Started Kbd bit-bucket thread, Tid=%d\n",VioTid);
+	
+/* fg271103: set control word of FPU to default value to prevent SIGFPE in GLX (and elsewhere?) */
+
+#define DEFAULT_X86_FPU 0x037f
+	
+	cw = _control87(DEFAULT_X86_FPU, 0xFFFF);
+	xf86Msg(X_INFO,"Checking FPCW: %#x\n",cw);
+
+	if (cw != DEFAULT_X86_FPU) {
+		cw = _control87(0,0);
+		xf86Msg(X_INFO,"Set FPCW to %#x\n",cw);
+	}
+
+    }
+    return;
+}
+
+void xf86CloseConsole()
+{
+	APIRET rc;
+	ULONG drive;
+
+	if (xf86Info.consoleFd != -1) {
+		KbdClose(xf86Info.consoleFd);
+	}
+	VioSetMode(&OriginalVideoMode,(HVIO)0);
+	rc = DosQuerySysInfo(5,5,&drive,sizeof(drive));
+	rc = DosSuppressPopUps(0x0000L,drive+96);    /* Reenable popups */
+	rc = DosCloseEventSem(hevPopupPending);
+	rc = VioDeRegister();
+	return;
+}
+
+/* ARGSUSED */
+
+int xf86ProcessArgument (argc, argv, i)
+int argc;
+char *argv[];
+int i;
+{
+	return 0;
+}
+
+void xf86UseMsg()
+{
+	return;
+}
+
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_io.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_io.c
new file mode 100644
index 000000000..e6570aeb9
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_io.c
@@ -0,0 +1,257 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_io.c,v 3.19 2003/11/17 22:20:41 dawes Exp $ */
+/*
+ * (c) Copyright 1994,1999 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ * Modified 1996 by Sebastien Marineau <marineau@genie.uottawa.ca>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XConsortium: os2_io.c /main/9 1996/05/13 16:38:07 kaleb $ */
+
+#define I_NEED_OS2_H
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xpoll.h>
+#include "compiler.h"
+#include <time.h>
+
+#define INCL_DOSPROCESS
+#define INCL_KBD
+#define INCL_MOU
+#define INCL_DOSDEVIOCTL
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+int os2MouseQueueQuery();
+int os2KbdQueueQuery();
+void os2RecoverFromPopup();
+void os2CheckPopupPending();
+extern BOOL os2PopupErrorPending;
+int _select2 (int, fd_set *, fd_set *,fd_set *, struct timeval *);
+
+
+/***************************************************************************/
+
+void xf86SoundKbdBell(loudness, pitch, duration)
+int loudness;
+int pitch;
+int duration;
+{
+	DosBeep((ULONG)pitch, (ULONG)duration);
+}
+
+void xf86SetKbdLeds(leds)
+int leds;
+{
+	KBDINFO kinfo;
+	APIRET rc;
+
+	rc = KbdGetStatus(&kinfo,(HKBD)xf86Info.consoleFd);
+	if (!rc) {
+		kinfo.fsMask = 0x10;
+		kinfo.fsState &= ~0x70;
+		kinfo.fsState |= (leds&0x70);
+		KbdSetStatus(&kinfo,(HKBD)xf86Info.consoleFd);
+	}
+}
+
+int xf86GetKbdLeds()
+{
+	KBDINFO kinfo;
+	APIRET rc;
+
+	rc = KbdGetStatus(&kinfo,(HKBD)xf86Info.consoleFd);
+	return rc ? 0 : kinfo.fsState & 0x70;
+}
+
+void xf86SetKbdRepeat(char rad)
+{
+  int rc;
+  int delay = 250;      /* Default delay */
+  int rate = 30;       /* Default repeat rate */
+
+  struct {
+    USHORT Delay;
+    USHORT Rate;
+  } rateDelay;
+
+  ULONG rateDelaySize = sizeof(rateDelay);
+
+	/*notyet*/
+  return;
+
+  if (xf86Info.kbdRate >= 0) 
+    rate = xf86Info.kbdRate;
+  if (xf86Info.kbdDelay >= 0)
+    delay = xf86Info.kbdDelay;
+
+  rateDelay.Delay = delay;
+  rateDelay.Rate = rate;
+
+  xf86Msg(X_INFO,"Setting typematic rate: Delay=%d, Rate=%d\n",delay,rate);
+
+  rc = DosDevIOCtl( (HFILE) xf86Info.consoleFd,
+           IOCTL_KEYBOARD,
+           KBD_SETTYPAMATICRATE,
+           &rateDelay,
+           rateDelaySize,
+           &rateDelaySize,
+           NULL,
+           0,
+           NULL);
+  if (rc!=0) {
+    xf86Msg(X_ERROR,"xf86SetKbdRepeat: DosDevIOCtl returned %d\n",rc);
+  }
+}
+
+void xf86KbdInit()
+{
+	/*none required*/
+}
+
+
+USHORT OrigKbdState;
+USHORT OrigKbdInterim;
+
+typedef struct {
+    USHORT state;
+    UCHAR makeCode;
+    UCHAR breakCode;
+    USHORT keyID;
+} HOTKEYPARAM;
+
+
+int xf86KbdOn()
+{
+	KBDINFO info;
+	APIRET rc;
+	int i,k;
+	ULONG len;
+
+
+	KbdGetStatus(&info,(HKBD)xf86Info.consoleFd);
+	OrigKbdState=info.fsMask;
+	OrigKbdInterim=info.fsInterim;
+	info.fsMask &= ~0x09;
+	info.fsMask |= 0x136;
+	info.fsInterim &= ~0x20;
+	KbdSetStatus(&info,(HKBD)xf86Info.consoleFd);
+	return -1;
+}
+
+int xf86KbdOff()
+{
+	ULONG len;
+	APIRET rc;
+	KBDINFO info;
+
+	info.fsMask=OrigKbdState;
+	info.fsInterim=OrigKbdInterim;
+	KbdSetStatus(&info,(HKBD)xf86Info.consoleFd);
+	return -1;
+}
+
+#if 0 /*OBSOLETE*/
+void xf86MouseInit(mouse)
+MouseDevPtr mouse;
+{
+	HMOU fd;
+	APIRET rc;
+	USHORT nbut;
+
+	if (serverGeneration == 1) {
+		rc = MouOpen((PSZ)NULL,(PHMOU)&fd);
+		if (rc != 0)
+			FatalError("Cannot open mouse, rc=%d\n", rc);
+			mouse->mseFd = fd;
+	}
+	
+	/* flush mouse queue */
+	MouFlushQue(fd);
+
+	/* check buttons */
+	rc = MouGetNumButtons(&nbut,fd);
+	if (rc == 0)
+		xf86Msg(X_INFO,"OsMouse has %d button(s).\n",nbut);
+}
+#endif
+
+#if 0 /*OBSOLETE*/
+int xf86MouseOn(mouse)
+MouseDevPtr mouse;
+{
+#if 0
+	HMOU fd;
+	APIRET rc;
+	USHORT nbut;
+#endif
+	xf86Msg (X_ERROR,
+		"Calling MouseOn, a bad thing.... Must be some bug in the code!\n");
+
+#if 0
+	if (serverGeneration == 1) {
+		rc = MouOpen((PSZ)NULL,(PHMOU)&fd);
+		if (rc != 0)
+			FatalError("Cannot open mouse, rc=%d\n", rc);
+			mouse->mseFd = fd;
+	}
+	
+	/* flush mouse queue */
+	MouFlushQue(fd);
+
+	/* check buttons */
+	rc = MouGetNumButtons(&nbut,fd);
+	if (rc == 0)
+		xf86Msg(X_INFO,"OsMouse has %d button(s).\n",nbut);
+
+	return (mouse->mseFd);
+#endif
+}
+#endif
+
+#if 0 /*OBSOLETE*/
+/* This table is a bit irritating, because these mouse types are infact
+ * defined in the OS/2 kernel, but I want to force the user to put
+ * "OsMouse" in the config file, and not worry about the particular mouse
+ * type that is connected.
+ */
+Bool xf86SupportedMouseTypes[] =
+{
+	FALSE,	/* Microsoft */
+	FALSE,	/* MouseSystems */
+	FALSE,	/* MMSeries */
+	FALSE,	/* Logitech */
+	FALSE,	/* BusMouse */
+	FALSE,	/* MouseMan */
+	FALSE,	/* PS/2 */
+	FALSE,	/* Hitachi Tablet */
+};
+
+int xf86NumMouseTypes = sizeof(xf86SupportedMouseTypes) /
+			sizeof(xf86SupportedMouseTypes[0]);
+#endif
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_ioperm.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_ioperm.c
new file mode 100644
index 000000000..c03bb96af
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_ioperm.c
@@ -0,0 +1,140 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_ioperm.c,v 3.5 1997/08/26 10:01:38 hohndel Exp $ */
+/*
+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>
+ * Modified 1996 by Sebastien Marineau <marineau@genie.uottawa.ca>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of David Wexelblat not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  David Wexelblat makes no representations
+ * about the suitability of this software for any purpose.  It is provided
+ * "as is" without express or implied warranty.
+ *
+ * DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL DAVID WEXELBLAT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+/* $XConsortium: os2_ioperm.c /main/4 1996/04/18 16:50:01 kaleb $ */
+
+
+
+#define I_NEED_OS2_H
+#define INCL_32
+#define INCL_DOS
+#define INCL_DOSFILEMGR
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+/*
+ * To access I/O ports under OS/2, we use the xf86sup.sys driver.
+ * For the moment, we use a function which basically grants IO priviledge
+ * to the whole server. NOTE: Once the server is running, we should 
+ * change this to use inline IO functions through the callgate returned by 
+ * the fastio$ driver.
+ */
+
+int ioEnabled=FALSE;
+ULONG action;
+char *ioDrvPath = "/dev/fastio$";
+USHORT callgate[3]={0,0,0};
+
+
+Bool xf86EnableIO()
+{
+
+HFILE hfd;
+	ULONG dlen;
+	APIRET rc;
+
+	/* no need to call multiple times */
+	if (ioEnabled) return TRUE;
+	
+	if (DosOpen((PSZ)ioDrvPath, (PHFILE)&hfd, (PULONG)&action,
+	   (ULONG)0, FILE_SYSTEM, FILE_OPEN,
+	   OPEN_SHARE_DENYNONE|OPEN_FLAGS_NOINHERIT|OPEN_ACCESS_READONLY,
+	   (ULONG)0) != 0) {
+		xf86Msg(X_ERROR,"Error opening fastio$ driver...\n");
+		xf86Msg(X_ERROR,"Please install xf86sup.sys in config.sys!\n");
+		return FALSE;
+	}
+	callgate[0] = callgate[1] = 0;
+
+/* Get callgate from driver for fast io to ports and other stuff */
+
+	rc = DosDevIOCtl(hfd, (ULONG)0x76, (ULONG)0x64,
+		NULL, 0, NULL,
+		(ULONG*)&callgate[2], sizeof(USHORT), &dlen);
+	if (rc) {
+		xf86Msg(X_ERROR,
+			"EnableIOPorts failed, rc=%d, dlen=%d; emergency exit\n",
+			rc,dlen);
+		DosClose(hfd);
+		return FALSE;
+	}
+
+/* Calling callgate with function 13 sets IOPL for the program */
+
+	asm volatile ("movl $13,%%ebx;.byte 0xff,0x1d;.long _callgate"
+			: /*no outputs */ 
+			: /*no inputs */
+			: "eax","ebx","ecx","edx","cc");
+
+	ioEnabled = TRUE;
+        DosClose(hfd);
+	return TRUE;
+}
+
+void xf86DisableIO()
+{
+HFILE hfd;
+	ULONG dlen;
+	APIRET rc;
+
+	/* no need to call multiple times */
+	if (!ioEnabled) return;
+	
+	if (DosOpen((PSZ)ioDrvPath, (PHFILE)&hfd, (PULONG)&action,
+	   (ULONG)0, FILE_SYSTEM, FILE_OPEN,
+	   OPEN_SHARE_DENYNONE|OPEN_FLAGS_NOINHERIT|OPEN_ACCESS_READONLY,
+	   (ULONG)0) != 0) {
+		xf86Msg(X_ERROR,"Error opening fastio$ driver...\n");
+		xf86Msg(X_ERROR,"Please install xf86sup.sys in config.sys!\n");
+		return;
+	}
+	callgate[0] = callgate[1] = 0;
+
+	rc = DosDevIOCtl(hfd, (ULONG)0x76, (ULONG)0x64,
+		NULL, 0, NULL,
+		(ULONG*)&callgate[2], sizeof(USHORT), &dlen);
+	if (rc) {
+		xf86Msg(X_ERROR,"DisableIOPorts failed, rc=%d, dlen=%d\n",
+			rc,dlen);
+		DosClose(hfd);
+		return;
+	}
+
+/* Function 14 of callgate brings program back to ring 3 */
+
+	asm volatile ("movl $14,%%ebx;.byte 0xff,0x1d;.long _callgate"
+			: /*no outputs */ 
+			: /*no inputs */
+			: "eax","ebx","ecx","edx","cc");
+	ioEnabled=FALSE;
+        DosClose(hfd);
+	return;
+
+}
+
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_kbd.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_kbd.c
new file mode 100644
index 000000000..f99f12c0f
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_kbd.c
@@ -0,0 +1,158 @@
+/*
+ * Copied from os2_io.c which is
+ *
+ * (c) Copyright 1994,1999 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ * Modified 1996 by Sebastien Marineau <marineau@genie.uottawa.ca>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XFree86$ */
+
+#define I_NEED_OS2_H
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xpoll.h>
+#include "compiler.h"
+#include <time.h>
+
+#define INCL_DOSPROCESS
+#define INCL_KBD
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+#include "xf86Xinput.h"
+#include "xf86OSKbd.h"
+
+
+
+/***************************************************************************/
+
+static void SoundKbdBell(loudness, pitch, duration)
+int loudness;
+int pitch;
+int duration;
+{
+	DosBeep((ULONG)pitch, (ULONG)duration);
+}
+
+static void SetKbdLeds(pInfo, leds)
+InputInfoPtr pInfo;
+int leds;
+{
+	KBDINFO kinfo;
+	APIRET rc;
+
+	rc = KbdGetStatus(&kinfo,(HKBD)xf86Info.consoleFd);
+	if (!rc) {
+		kinfo.fsMask = 0x10;
+		kinfo.fsState &= ~0x70;
+		kinfo.fsState |= (leds&0x70);
+		KbdSetStatus(&kinfo,(HKBD)xf86Info.consoleFd);
+	}
+}
+
+static int GetKbdLeds(pInfo)
+InputInfoPtr pInfo;
+{
+	KBDINFO kinfo;
+	APIRET rc;
+
+	rc = KbdGetStatus(&kinfo,(HKBD)xf86Info.consoleFd);
+	return rc ? 0 : kinfo.fsState & 0x70;
+}
+
+static void SetKbdRepeat(pInfo, rad)
+InputInfoPtr pInfo;
+char rad;
+{
+	/*notyet*/
+}
+
+static void KbdInit(pInfo)
+InputInfoPtr pInfo;
+{
+	/*none required*/
+	xf86Msg(X_INFO,"XKB module: Keyboard initialized\n");
+}
+
+
+static USHORT OrigKbdState;
+static USHORT OrigKbdInterim;
+
+typedef struct {
+    USHORT state;
+    UCHAR makeCode;
+    UCHAR breakCode;
+    USHORT keyID;
+} HOTKEYPARAM;
+
+
+static int KbdOn(pInfo)
+InputInfoPtr pInfo;
+{
+	KBDINFO info;
+
+	KbdGetStatus(&info,(HKBD)xf86Info.consoleFd);
+	OrigKbdState=info.fsMask;
+	OrigKbdInterim=info.fsInterim;
+	info.fsMask &= ~0x09;
+	info.fsMask |= 0x136;
+	info.fsInterim &= ~0x20;
+	KbdSetStatus(&info,(HKBD)xf86Info.consoleFd);
+	return -1;
+}
+
+static int KbdOff(pInfo)
+InputInfoPtr pInfo;
+{
+	KBDINFO info;
+
+	info.fsMask=OrigKbdState;
+	info.fsInterim=OrigKbdInterim;
+	KbdSetStatus(&info,(HKBD)xf86Info.consoleFd);
+	return -1;
+}
+
+Bool
+xf86OSKbdPreInit(InputInfoPtr pInfo)
+{
+	KbdDevPtr pKbd = pInfo->private;
+
+	pKbd->KbdInit		= KbdInit;
+	pKbd->KbdOn		= KbdOn;
+	pKbd->KbdOff		= KbdOff;
+	pKbd->Bell		= SoundKbdBell;
+	pKbd->SetLeds		= SetKbdLeds;
+	pKbd->GetLeds		= GetKbdLeds;
+	pKbd->SetKbdRepeat	= SetKbdRepeat;
+
+	pKbd->vtSwitchSupported	= FALSE;
+
+	/* not yet */
+	return FALSE;
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_kbdEv.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_kbdEv.c
new file mode 100644
index 000000000..861fbf089
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_kbdEv.c
@@ -0,0 +1,511 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_kbdEv.c,v 3.16 2002/05/31 18:46:01 dawes Exp $ */
+/*
+ * (c) Copyright 1994,1996,1999 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ * Modified 1996 Sebastien Marineau <marineau@genie.uottawa.ca>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+ * HOLGER VEIT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XConsortium: os2_kbdEv.c /main/10 1996/10/27 11:48:48 kaleb $ */
+
+#define I_NEED_OS2_H
+#define NEED_EVENTS
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "inputstr.h"
+#include "scrnintstr.h"
+
+#define INCL_KBD
+#define INCL_DOSMONITORS
+#define INCL_WINSWITCHLIST
+#define INCL_DOSQUEUES
+#undef RT_FONT	/* must discard this */
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+#include "atKeynames.h"
+
+/* Attention! these lines copied from ../../common/xf86Events.c */
+#define XE_POINTER 1
+#define XE_KEYBOARD 2
+
+#ifdef XKB
+extern Bool noXkbExtension;
+#endif
+
+#ifdef XTESTEXT1
+
+#define	XTestSERVER_SIDE
+#include <X11/extensions/xtestext1.h>
+extern short xtest_mousex;
+extern short xtest_mousey;
+extern int on_steal_input; 
+extern Bool XTestStealKeyData();
+extern void XTestStealMotionData();
+
+#ifdef XINPUT
+#define ENQUEUE(ev, code, direction, dev_type) \
+ (ev)->u.u.detail = (code); \
+ (ev)->u.u.type = (direction); \
+ if (!on_steal_input || \
+ XTestStealKeyData((ev)->u.u.detail, (ev)->u.u.type, dev_type, \
+ xtest_mousex, xtest_mousey)) \
+ xf86eqEnqueue((ev))
+#else
+#define ENQUEUE(ev, code, direction, dev_type) \
+ (ev)->u.u.detail = (code); \
+ (ev)->u.u.type = (direction); \
+ if (!on_steal_input || \
+ XTestStealKeyData((ev)->u.u.detail, (ev)->u.u.type, dev_type, \
+			xtest_mousex, xtest_mousey)) \
+ mieqEnqueue((ev))
+#endif
+
+#define MOVEPOINTER(dx, dy, time) \
+ if (on_steal_input) \
+ XTestStealMotionData(dx, dy, XE_POINTER, xtest_mousex, xtest_mousey); \
+ miPointerDeltaCursor (dx, dy, time)
+
+#else /* ! XTESTEXT1 */
+
+#ifdef XINPUT
+#define ENQUEUE(ev, code, direction, dev_type) \
+ (ev)->u.u.detail = (code); \
+ (ev)->u.u.type = (direction); \
+ xf86eqEnqueue((ev))
+#else
+#define ENQUEUE(ev, code, direction, dev_type) \
+ (ev)->u.u.detail = (code); \
+ (ev)->u.u.type = (direction); \
+ mieqEnqueue((ev))
+#endif
+#define MOVEPOINTER(dx, dy, time) \
+ miPointerDeltaCursor (dx, dy, time)
+
+#endif
+/* end of include */
+
+HQUEUE hKbdQueue;
+HEV hKbdSem;
+int last_status;
+int lastStatus;
+int lastShiftState;
+extern BOOL SwitchedToWPS;
+
+void os2PostKbdEvent();
+
+int os2KbdQueueQuery()
+{
+	ULONG numElements,postCount;
+ 
+	(void)DosQueryQueue(hKbdQueue,&numElements);
+	if (numElements!=0) return 0; /* We have something in queue */
+
+	DosResetEventSem(hKbdSem,&postCount);
+	return 1;
+}
+
+
+void xf86KbdEvents()
+{
+	KBDKEYINFO keybuf;
+	ULONG numElements;
+	REQUESTDATA requestData;
+	ULONG dataLength, postCount;
+	PVOID dummy;
+	BYTE elemPriority;
+	int scan, down;
+	static int last;
+	USHORT ModState;
+	int i;
+
+	while(DosReadQueue(hKbdQueue,
+			 &requestData,&dataLength,&dummy,
+			 0L,1L,&elemPriority,hKbdSem) == 0) {
+
+		/* xf86Msg(X_INFO,
+		 "Got queue element. data=%d, scancode =%d,up=%d, ddflag %d\n",
+		 requestData.ulData,
+		 (requestData.ulData&0x7F00)>>8,
+		 requestData.ulData&0x8000,
+		 requestData.ulData>>16);*/
+
+		scan=(requestData.ulData&0x7F00)>>8;
+
+		/* the separate cursor keys return 0xe0/scan */
+		if ((requestData.ulData & 0x3F0000)==0x20000) scan=0;
+		if (requestData.ulData & 0x800000) {
+			switch (scan) {
+
+/* BUG ALERT: IBM has in its keyboard driver a 122 key keyboard, which
+ * uses the "server generated scancodes" from atKeynames.h as real scan codes.
+ * We wait until some poor guy with such a keyboard will break the whole
+ * card house though...
+ */
+			case KEY_KP_7: scan = KEY_Home; break;	
+			case KEY_KP_8: scan = KEY_Up; break;	
+			case KEY_KP_9: scan = KEY_PgUp; break;	
+			case KEY_KP_4: scan = KEY_Left; break;	
+			case KEY_KP_5: scan = KEY_Begin; break;	
+			case KEY_KP_6: scan = KEY_Right; break;	
+			case KEY_KP_1: scan = KEY_End; break;	
+			case KEY_KP_2: scan = KEY_Down; break;	
+			case KEY_KP_3: scan = KEY_PgDown; break;	
+			case KEY_KP_0: scan = KEY_Insert; break;	
+			case KEY_KP_Decimal: scan = KEY_Delete; break; 
+			case KEY_Enter: scan = KEY_KP_Enter; break;	
+			case KEY_LCtrl: scan = KEY_RCtrl; break;	
+			case KEY_KP_Multiply: scan = KEY_Print; break; 
+			case KEY_Slash: scan = KEY_KP_Divide; break; 
+			case KEY_Alt: scan = KEY_AltLang; break;	
+			case KEY_ScrollLock: scan = KEY_Break; break; 
+			case 0x5b: scan = KEY_LMeta; break;
+			case 0x5c: scan = KEY_RMeta; break;
+			case 0x5d: scan = KEY_Menu; break;
+			default:
+				/* virtual shifts: ignore */
+			scan = 0; break;
+			}
+		}
+	
+		down = (requestData.ulData&0x8000) ? FALSE : TRUE;
+		if (scan!=0) os2PostKbdEvent(scan, down);
+	}
+	(void)DosResetEventSem(hKbdSem,&postCount);
+}
+
+/*
+ * xf86PostKbdEvent --
+ *	Translate the raw hardware KbdEvent into an XEvent, and tell DIX
+ *	about it. Scancode preprocessing and so on is done ...
+ *
+ * OS/2 specific xf86PostKbdEvent(key) has been moved from common/xf86Events.c
+ * as some things differ, and I didn't want to scatter this routine with
+ * ifdefs further (hv).
+ */
+
+void os2PostKbdEvent(unsigned scanCode, Bool down)
+{
+	KeyClassRec *keyc = ((DeviceIntPtr)xf86Info.pKeyboard)->key;
+	Bool updateLeds = FALSE;
+	Bool UsePrefix = FALSE;
+	Bool Direction = FALSE;
+	xEvent kevent;
+	KeySym *keysym;
+	int keycode;
+	static int lockkeys = 0;
+
+	/*
+	 * and now get some special keysequences
+	 */
+	if ((ModifierDown(ControlMask | AltMask)) ||
+	    (ModifierDown(ControlMask | AltLangMask))) {
+		switch (scanCode) {
+		case KEY_BackSpace:
+			if (!xf86Info.dontZap) GiveUp(0);
+			return;
+		case KEY_KP_Minus: /* Keypad - */
+			if (!xf86Info.dontZoom) {
+				if (down)
+					xf86ZoomViewport(xf86Info.currentScreen, -1);
+				return;
+	 		}
+			break;
+		case KEY_KP_Plus: /* Keypad + */
+			if (!xf86Info.dontZoom) {
+				if (down)
+					xf86ZoomViewport(xf86Info.currentScreen, 1);
+				return;
+			 }
+			 break;
+		}
+	}
+
+	/* CTRL-ESC is std OS/2 hotkey for going back to PM and popping up
+	 * window list... handled by keyboard driverand PM if you tell it. This is 
+	 * what we have done, and thus should never detect this key combo */
+	if (ModifierDown(ControlMask) && scanCode==KEY_Escape) {
+		/* eat it */
+		return;	
+	} else if (ModifierDown(AltLangMask|AltMask) && scanCode==KEY_Escape) {
+		/* same here */
+		return;
+	}
+
+	/*
+	 * Now map the scancodes to real X-keycodes ...
+	 */
+	keycode = scanCode + MIN_KEYCODE;
+	keysym = (keyc->curKeySyms.map +
+		  keyc->curKeySyms.mapWidth * 
+		  (keycode - keyc->curKeySyms.minKeyCode));
+#ifdef XKB
+	if (noXkbExtension) {
+#endif
+	/* Filter autorepeated caps/num/scroll lock keycodes. */
+
+#define CAPSFLAG 0x01
+#define NUMFLAG 0x02
+#define SCROLLFLAG 0x04
+#define MODEFLAG 0x08
+	if (down) {
+		switch (keysym[0]) {
+		case XK_Caps_Lock:
+			if (lockkeys & CAPSFLAG)
+				return;
+			else
+				lockkeys |= CAPSFLAG;
+			break;
+		case XK_Num_Lock:
+			if (lockkeys & NUMFLAG)
+				return;
+			else
+				lockkeys |= NUMFLAG;
+			break;
+		case XK_Scroll_Lock:
+			if (lockkeys & SCROLLFLAG)
+				return;
+			else
+				lockkeys |= SCROLLFLAG;
+			break;
+		}
+
+		if (keysym[1] == XF86XK_ModeLock) {
+			if (lockkeys & MODEFLAG)
+				return;
+			else
+				lockkeys |= MODEFLAG;
+		}
+	} else {
+		switch (keysym[0]) {
+		case XK_Caps_Lock:
+			lockkeys &= ~CAPSFLAG;
+			break;
+		case XK_Num_Lock:
+			lockkeys &= ~NUMFLAG;
+			break;
+		case XK_Scroll_Lock:
+			lockkeys &= ~SCROLLFLAG;
+			break;
+		}
+
+		if (keysym[1] == XF86XK_ModeLock)
+			lockkeys &= ~MODEFLAG;
+	}
+
+	/*
+	 * LockKey special handling:
+	 * ignore releases, toggle on & off on presses.
+	 * Don't deal with the Caps_Lock keysym directly, 
+	 * but check the lock modifier
+	 */
+#ifndef PC98
+	if (keyc->modifierMap[keycode] & LockMask ||
+	    keysym[0] == XK_Scroll_Lock ||
+	    keysym[1] == XF86XK_ModeLock ||
+	    keysym[0] == XK_Num_Lock) {
+		Bool flag;
+
+		if (!down) return;
+		flag = !KeyPressed(keycode);
+		if (!flag) down = !down;
+
+		if (keyc->modifierMap[keycode] & LockMask)
+			xf86Info.capsLock = flag;
+		if (keysym[0] == XK_Num_Lock)
+			xf86Info.numLock = flag;
+		if (keysym[0] == XK_Scroll_Lock)
+			xf86Info.scrollLock = flag;
+		if (keysym[1] == XF86XK_ModeLock)
+			xf86Info.modeSwitchLock = flag;
+		updateLeds = TRUE;
+	}
+#endif /* not PC98 */	
+
+	/* normal, non-keypad keys */
+	if (scanCode < KEY_KP_7 || scanCode > KEY_KP_Decimal) {
+		/* magic ALT_L key on AT84 keyboards for multilingual support */
+		if (xf86Info.kbdType == KB_84 &&
+		    ModifierDown(AltMask) &&
+		    keysym[2] != NoSymbol) {
+			UsePrefix = TRUE;
+			Direction = TRUE;
+		}
+	}
+
+#ifdef XKB /* Warning: got position wrong first time */
+	}
+#endif
+
+	/* check for an autorepeat-event */
+	if ((down && KeyPressed(keycode)) &&
+	    (xf86Info.autoRepeat != AutoRepeatModeOn || keyc->modifierMap[keycode]))
+		return;
+
+	xf86Info.lastEventTime = 
+		kevent.u.keyButtonPointer.time = 
+		GetTimeInMillis();
+
+	/*
+	 * And now send these prefixes ...
+	 * NOTE: There cannot be multiple Mode_Switch keys !!!!
+	 */
+	if (UsePrefix) {
+		ENQUEUE(&kevent,
+			keyc->modifierKeyMap[keyc->maxKeysPerModifier*7],
+			Direction ? KeyPress : KeyRelease,
+			XE_KEYBOARD);
+		ENQUEUE(&kevent, 
+			keycode, 
+			down ? KeyPress : KeyRelease,
+			XE_KEYBOARD);
+		ENQUEUE(&kevent,
+			keyc->modifierKeyMap[keyc->maxKeysPerModifier*7],
+			Direction ? KeyRelease : KeyPress,
+			XE_KEYBOARD);
+	} else {
+#ifdef XFreeDGA
+		if (((ScrnInfoPtr)(xf86Info.currentScreen->devPrivates[xf86ScreenIndex].ptr))->directMode&XF86DGADirectKeyb) {
+			XF86DirectVideoKeyEvent(&kevent, 
+						keycode,
+						down ? KeyPress : KeyRelease);
+		} else
+#endif
+		{
+			ENQUEUE(&kevent,
+				keycode,
+				down ? KeyPress : KeyRelease,
+				XE_KEYBOARD);
+		}
+	}
+
+	if (updateLeds) xf86KbdLeds();
+}
+
+#pragma pack(1)
+struct KeyPacket {
+	unsigned short mnflags;
+	KBDKEYINFO cp;
+	unsigned short ddflags;
+};
+#pragma pack()
+
+/* The next function runs as a thread. It registers a monitor on the kbd
+ * driver, and uses that to get keystrokes. This is because the standard
+ * OS/2 keyboard driver does not send keyboard release events. A queue
+ * is used to communicate with the main thread to send keystrokes */
+
+void os2KbdMonitorThread(void* arg)
+{
+	struct KeyPacket packet;
+	APIRET rc;
+	USHORT length,print_flag;
+	ULONG queueParam;
+	HMONITOR hKbdMonitor;
+	MONIN monInbuf;
+	MONOUT monOutbuf;
+	char queueName[128];
+
+#if 0
+	monInbuf=(MONIN *)_tmalloc(2*sizeof(MONIN));
+	if (monInbuf==NULL) {
+		xf86Msg(X_ERROR,
+			"Could not allocate memory in kbd monitor thread!\n");
+		exit(1);
+	}
+	monOutbuf=(MONOUT *) &monInbuf[1];
+#endif
+
+	monInbuf.cb=sizeof(MONIN);
+	monOutbuf.cb=sizeof(MONOUT);
+
+	rc = DosMonOpen("KBD$",&hKbdMonitor);
+	xf86Msg(X_INFO,"Opened kbd monitor, rc=%d\n",rc);
+ 	rc = DosMonReg(hKbdMonitor,
+		       (PBYTE)&monInbuf,(PBYTE)&monOutbuf,(USHORT)2,(USHORT)-1);
+	xf86Msg(X_INFO,"Kbd monitor registered, rc=%d\n",rc);
+	if (rc) {
+		DosMonClose(hKbdMonitor);
+		exit(1);
+	}
+
+	/* create a queue */
+	sprintf(queueName,"\\QUEUES\\XF86KBD\\%d",getpid());
+	rc = DosCreateQueue(&hKbdQueue,0L,queueName);
+	xf86Msg(X_INFO,"Kbd Queue created, rc=%d\n",rc);
+	(void)DosPurgeQueue(hKbdQueue);
+
+	while (1) {
+		length = sizeof(packet);
+		rc = DosMonRead((PBYTE)&monInbuf,0,(PBYTE)&packet,&length);
+		if (rc)	{
+			xf86Msg(X_ERROR,
+				"DosMonRead returned bad RC! rc=%d\n",rc);
+			DosMonClose(hKbdMonitor);
+			exit(1);
+		}
+		queueParam = packet.mnflags+(packet.ddflags<<16);
+		if (packet.mnflags&0x7F00)
+			DosWriteQueue(hKbdQueue,queueParam,0L,NULL,0L);
+			/*xf86Msg(X_INFO,"Wrote a char to queue, rc=%d\n",rc); */
+		print_flag = packet.ddflags & 0x1F;
+
+		/*xf86Msg(X_INFO,"Kbd Monitor: Key press %d, scan code %d, ddflags %d\n",
+			  packet.mnflags&0x8000,(packet.mnflags&0x7F00)>>8,packet.ddflags); 
+		*/
+
+		/* This line will swallow print-screen keypresses */
+		if (print_flag == 0x13 || print_flag == 0x14 || 
+		    print_flag == 0x15 || print_flag == 0x16)
+			rc = 0;
+		else
+			rc = DosMonWrite((PBYTE)&monOutbuf,(PBYTE)&packet,length); 
+		if (rc) {
+			xf86Msg(X_ERROR,
+				"DosMonWrite returned bad RC! rc=%d\n",rc);
+			DosMonClose(hKbdMonitor);
+			exit(1);
+		}
+	}
+
+	DosCloseQueue(hKbdQueue);
+	DosMonClose(hKbdMonitor);
+}
+
+void os2KbdBitBucketThread(void* arg)
+{
+	KBDKEYINFO key;
+	while (1) {
+		if (xf86Info.consoleFd != -1) {
+			KbdCharIn(&key,1,xf86Info.consoleFd);
+			usleep(100000);
+		} else
+			usleep(500000);
+	}
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_mouse.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_mouse.c
new file mode 100644
index 000000000..e1fd52c2e
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_mouse.c
@@ -0,0 +1,653 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_mouse.c,v 3.17 2002/05/31 18:46:02 dawes Exp $ */
+/*
+ * (c) Copyright 1994,1999,2000 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ * Modified (c) 1996 Sebastien Marineau <marineau@genie.uottawa.ca>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XConsortium: os2_mouse.c /main/10 1996/10/27 11:48:51 kaleb $ */
+
+#define I_NEED_OS2_H
+#define NEED_EVENTS
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "inputstr.h"
+#include "scrnintstr.h"
+
+#include "compiler.h"
+
+#define INCL_DOSFILEMGR
+#define INCL_DOSQUEUES
+#define INCL_MOU
+#undef RT_FONT
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+#include "xf86Config.h"
+
+#include "xf86Xinput.h"
+#include "xf86OSmouse.h"
+#include "mipointer.h"
+
+/* The following support code was copied from mouse.c */
+
+/**********************************************************************
+ *
+ *  Emulate3Button support code
+ *
+ **********************************************************************/
+
+
+/*
+ * Lets create a simple finite-state machine for 3 button emulation:
+ *
+ * We track buttons 1 and 3 (left and right).  There are 11 states:
+ *   0 ground           - initial state
+ *   1 delayed left     - left pressed, waiting for right
+ *   2 delayed right    - right pressed, waiting for left
+ *   3 pressed middle   - right and left pressed, emulated middle sent
+ *   4 pressed left     - left pressed and sent
+ *   5 pressed right    - right pressed and sent
+ *   6 released left    - left released after emulated middle
+ *   7 released right   - right released after emulated middle
+ *   8 repressed left   - left pressed after released left
+ *   9 repressed right  - right pressed after released right
+ *  10 pressed both     - both pressed, not emulating middle
+ *
+ * At each state, we need handlers for the following events
+ *   0: no buttons down
+ *   1: left button down
+ *   2: right button down
+ *   3: both buttons down
+ *   4: emulate3Timeout passed without a button change
+ * Note that button events are not deltas, they are the set of buttons being
+ * pressed now.  It's possible (ie, mouse hardware does it) to go from (eg)
+ * left down to right down without anything in between, so all cases must be
+ * handled.
+ *
+ * a handler consists of three values:
+ *   0: action1
+ *   1: action2
+ *   2: new emulation state
+ *
+ * action > 0: ButtonPress
+ * action = 0: nothing
+ * action < 0: ButtonRelease
+ *
+ * The comment preceeding each section is the current emulation state.
+ * The comments to the right are of the form
+ *      <button state> (<events>) -> <new emulation state>
+ * which should be read as
+ *      If the buttons are in <button state>, generate <events> then go to
+ *      <new emulation state>.
+ */
+static signed char stateTab[11][5][3] = {
+/* 0 ground */
+  {
+    {  0,  0,  0 },   /* nothing -> ground (no change) */
+    {  0,  0,  1 },   /* left -> delayed left */
+    {  0,  0,  2 },   /* right -> delayed right */
+    {  2,  0,  3 },   /* left & right (middle press) -> pressed middle */
+    {  0,  0, -1 }    /* timeout N/A */
+  },
+/* 1 delayed left */
+  {
+    {  1, -1,  0 },   /* nothing (left event) -> ground */
+    {  0,  0,  1 },   /* left -> delayed left (no change) */
+    {  1, -1,  2 },   /* right (left event) -> delayed right */
+    {  2,  0,  3 },   /* left & right (middle press) -> pressed middle */
+    {  1,  0,  4 },   /* timeout (left press) -> pressed left */
+  },
+/* 2 delayed right */
+  {
+    {  3, -3,  0 },   /* nothing (right event) -> ground */
+    {  3, -3,  1 },   /* left (right event) -> delayed left (no change) */
+    {  0,  0,  2 },   /* right -> delayed right (no change) */
+    {  2,  0,  3 },   /* left & right (middle press) -> pressed middle */
+    {  3,  0,  5 },   /* timeout (right press) -> pressed right */
+  },
+/* 3 pressed middle */
+  {
+    { -2,  0,  0 },   /* nothing (middle release) -> ground */
+    {  0,  0,  7 },   /* left -> released right */
+    {  0,  0,  6 },   /* right -> released left */
+    {  0,  0,  3 },   /* left & right -> pressed middle (no change) */
+    {  0,  0, -1 },   /* timeout N/A */
+  },
+/* 4 pressed left */
+  {
+    { -1,  0,  0 },   /* nothing (left release) -> ground */
+    {  0,  0,  4 },   /* left -> pressed left (no change) */
+    { -1,  0,  2 },   /* right (left release) -> delayed right */
+    {  3,  0, 10 },   /* left & right (right press) -> pressed both */
+    {  0,  0, -1 },   /* timeout N/A */
+  },
+/* 5 pressed right */
+  {
+    { -3,  0,  0 },   /* nothing (right release) -> ground */
+    { -3,  0,  1 },   /* left (right release) -> delayed left */
+    {  0,  0,  5 },   /* right -> pressed right (no change) */
+    {  1,  0, 10 },   /* left & right (left press) -> pressed both */
+    {  0,  0, -1 },   /* timeout N/A */
+  },
+/* 6 released left */
+  {
+    { -2,  0,  0 },   /* nothing (middle release) -> ground */
+    { -2,  0,  1 },   /* left (middle release) -> delayed left */
+    {  0,  0,  6 },   /* right -> released left (no change) */
+    {  1,  0,  8 },   /* left & right (left press) -> repressed left */
+    {  0,  0, -1 },   /* timeout N/A */
+  },
+/* 7 released right */
+  {
+    { -2,  0,  0 },   /* nothing (middle release) -> ground */
+    {  0,  0,  7 },   /* left -> released right (no change) */
+    { -2,  0,  2 },   /* right (middle release) -> delayed right */
+    {  3,  0,  9 },   /* left & right (right press) -> repressed right */
+    {  0,  0, -1 },   /* timeout N/A */
+  },
+/* 8 repressed left */
+  {
+    { -2, -1,  0 },   /* nothing (middle release, left release) -> ground */
+    { -2,  0,  4 },   /* left (middle release) -> pressed left */
+    { -1,  0,  6 },   /* right (left release) -> released left */
+    {  0,  0,  8 },   /* left & right -> repressed left (no change) */
+    {  0,  0, -1 },   /* timeout N/A */
+  },
+/* 9 repressed right */
+  {
+    { -2, -3,  0 },   /* nothing (middle release, right release) -> ground */
+    { -3,  0,  7 },   /* left (right release) -> released right */
+    { -2,  0,  5 },   /* right (middle release) -> pressed right */
+    {  0,  0,  9 },   /* left & right -> repressed right (no change) */
+    {  0,  0, -1 },   /* timeout N/A */
+  },
+/* 10 pressed both */
+  {
+    { -1, -3,  0 },   /* nothing (left release, right release) -> ground */
+    { -3,  0,  4 },   /* left (right release) -> pressed left */
+    { -1,  0,  5 },   /* right (left release) -> pressed right */
+    {  0,  0, 10 },   /* left & right -> pressed both (no change) */
+    {  0,  0, -1 },   /* timeout N/A */
+  },
+};
+
+/*
+ * Table to allow quick reversal of natural button mapping to correct mapping
+ */
+
+/*
+ * [JCH-96/01/21] The ALPS GlidePoint pad extends the MS protocol
+ * with a fourth button activated by tapping the PAD.
+ * The 2nd line corresponds to 4th button on; the drv sends
+ * the buttons in the following map (MSBit described first) :
+ * 0 | 4th | 1st | 2nd | 3rd
+ * And we remap them (MSBit described first) :
+ * 0 | 4th | 3rd | 2nd | 1st
+ */
+static char reverseMap[32] = { 0,  4,  2,  6,  1,  5,  3,  7,
+			       8, 12, 10, 14,  9, 13, 11, 15,
+			      16, 20, 18, 22, 17, 21, 19, 23,
+			      24, 28, 26, 30, 25, 29, 27, 31};
+
+
+static char hitachMap[16] = {  0,  2,  1,  3,
+			       8, 10,  9, 11,
+			       4,  6,  5,  7,
+			      12, 14, 13, 15 };
+
+#define reverseBits(map, b)	(((b) & ~0x0f) | map[(b) & 0x0f])
+
+static CARD32
+buttonTimer(InputInfoPtr pInfo)
+{
+    MouseDevPtr pMse;
+    int	sigstate;
+    int id;
+
+    pMse = pInfo->private;
+
+    sigstate = xf86BlockSIGIO ();
+
+    pMse->emulate3Pending = FALSE;
+    if ((id = stateTab[pMse->emulateState][4][0]) != 0) {
+        xf86PostButtonEvent(pInfo->dev, 0, abs(id), (id >= 0), 0, 0);
+        pMse->emulateState = stateTab[pMse->emulateState][4][2];
+    } else {
+        ErrorF("Got unexpected buttonTimer in state %d\n", pMse->emulateState);
+    }
+
+    xf86UnblockSIGIO (sigstate);
+    return 0;
+}
+
+static Bool
+Emulate3ButtonsSoft(InputInfoPtr pInfo)
+{
+    MouseDevPtr pMse = pInfo->private;
+
+    if (!pMse->emulate3ButtonsSoft)
+	return TRUE;
+
+    pMse->emulate3Buttons = FALSE;
+
+    if (pMse->emulate3Pending)
+	buttonTimer(pInfo);
+
+    xf86Msg(X_INFO,"3rd Button detected: disabling emulate3Button\n");
+
+    return FALSE;
+}
+
+static void MouseBlockHandler(pointer data,
+			      struct timeval **waitTime,
+			      pointer LastSelectMask)
+{
+    InputInfoPtr    pInfo = (InputInfoPtr) data;
+    MouseDevPtr	    pMse = (MouseDevPtr) pInfo->private;
+    int		    ms;
+
+    if (pMse->emulate3Pending)
+    {
+	ms = pMse->emulate3Expires - GetTimeInMillis ();
+	if (ms <= 0)
+	    ms = 0;
+	AdjustWaitForDelay (waitTime, ms);
+    }
+}
+
+static void MouseWakeupHandler(pointer data,
+			       int i,
+			       pointer LastSelectMask)
+{
+    InputInfoPtr    pInfo = (InputInfoPtr) data;
+    MouseDevPtr	    pMse = (MouseDevPtr) pInfo->private;
+    int		    ms;
+
+    if (pMse->emulate3Pending)
+    {
+	ms = pMse->emulate3Expires - GetTimeInMillis ();
+	if (ms <= 0)
+	    buttonTimer (pInfo);
+    }
+}
+
+static int
+SupportedInterfaces(void)
+{
+	return MSE_MISC;
+}
+
+static const char* internalNames[] = {
+	"OS2Mouse",
+	NULL
+};
+
+static const char**
+BuiltinNames(void)
+{
+	return internalNames;
+}
+
+static Bool
+CheckProtocol(const char *protocol)
+{
+	int i;
+
+	for (i = 0; internalNames[i]; i++)
+	if (xf86NameCmp(protocol, internalNames[i]) == 0)
+		return TRUE;
+	return FALSE;
+}
+
+static const char *
+DefaultProtocol(void)
+{
+	return "OS2Mouse";
+}
+
+static const char *
+SetupAuto(InputInfoPtr pInfo, int *protoPara)
+{
+	return "OS2Mouse";
+}
+
+HMOU hMouse=65535;
+HEV hMouseSem;
+HQUEUE hMouseQueue;
+InputInfoPtr iinfoPtr;
+int MouseTid;
+BOOL HandleValid=FALSE;
+extern BOOL SwitchedToWPS;
+extern CARD32 LastSwitchTime;
+void os2MouseEventThread(void* arg);
+
+static void
+os2MouseReadInput(InputInfoPtr pInfo)
+{
+	APIRET rc;
+	ULONG postCount,dataLength;
+	PVOID dummy;
+	int buttons;
+	int state;
+	int i, dx,dy;
+	BYTE elemPriority;
+	REQUESTDATA requestData;
+
+	MouseDevPtr pMse = pInfo->private;
+
+	if (!HandleValid) return;
+	while((rc = DosReadQueue(hMouseQueue,
+				 &requestData,&dataLength,&dummy, 
+				 0L,1L,&elemPriority,hMouseSem)) == 0) {
+		dx = requestData.ulData;
+		(void)DosReadQueue(hMouseQueue,
+				  &requestData,&dataLength,&dummy,
+				  0L,1L,&elemPriority,hMouseSem);
+		dy = requestData.ulData;
+		(void)DosReadQueue(hMouseQueue,
+				  &requestData,&dataLength,&dummy,
+				  0L,1L,&elemPriority,hMouseSem);
+		state = requestData.ulData;
+		(void)DosReadQueue(hMouseQueue,
+				  &requestData,&dataLength,&dummy,
+				  0L,1L,&elemPriority,hMouseSem);
+		if (requestData.ulData != 0xFFFFFFFF) 
+			xf86Msg(X_ERROR,
+				"Unexpected mouse event tag, %d\n",
+				requestData.ulData);
+
+		/* Contrary to other systems, OS/2 has mouse buttons *
+		 * in the proper order, so we reverse them before    *
+		 * sending the event.                                */
+		 
+		buttons = ((state & 0x06) ? 4 : 0) |
+			  ((state & 0x18) ? 1 : 0) |
+			  ((state & 0x60) ? 2 : 0);
+		pMse->PostEvent(pInfo, buttons, dx, dy, 0, 0);
+	}
+        DosResetEventSem(hMouseSem,&postCount);
+}
+
+int os2MouseProc(DeviceIntPtr pPointer, int what)
+{
+    APIRET rc = 0;
+    USHORT nbuttons, state;
+    unsigned char map[MSE_MAXBUTTONS + 1];
+    int i;
+
+    InputInfoPtr pInfo = pPointer->public.devicePrivate;
+    MouseDevPtr pMse = pInfo->private;
+    pMse->device = pPointer;
+
+    switch (what) {
+    case DEVICE_INIT: 
+	pPointer->public.on = FALSE;
+	if (hMouse == 65535) 
+	    rc = MouOpen((PSZ)0, &hMouse);
+	if (rc != 0)
+	    xf86Msg(X_WARNING,"%s: cannot open mouse, rc=%d\n", 
+		    pInfo->name,rc);
+	else {
+	    pInfo->fd = hMouse;
+
+	    /* flush mouse queue */
+	    MouFlushQue(hMouse);
+
+	    /* check buttons */
+	    rc = MouGetNumButtons(&nbuttons, hMouse);
+	    if (rc == 0)
+		xf86Msg(X_INFO,"%s: Mouse has %d button(s).\n",
+			pInfo->name,nbuttons);
+	    if (nbuttons==2) nbuttons++;
+
+	    for (i = 1; i<=nbuttons; i++)
+		map[i] = i;
+
+	    InitPointerDeviceStruct((DevicePtr)pPointer, map, nbuttons,
+		miPointerGetMotionEvents, pMse->Ctrl,
+		miPointerGetMotionBufferSize());
+
+	    /* X valuator */
+	    xf86InitValuatorAxisStruct(pPointer, 0, 0, -1, 1, 0, 1);
+	    xf86InitValuatorDefaults(pPointer, 0);
+	    /* y Valuator */
+	    InitValuatorAxisStruct(pPointer, 1, 0, -1, 1, 0, 1);
+	    xf86InitValuatorDefaults(pPointer, 1);
+	    xf86MotionHistoryAllocate(pInfo);
+
+	    /* OK, we are ready to start up the mouse thread ! */
+	    if (!HandleValid) {
+		rc = DosCreateEventSem(NULL,&hMouseSem,DC_SEM_SHARED,TRUE);
+		if (rc != 0)
+		    xf86Msg(X_ERROR,"%s: could not create mouse queue semaphore, rc=%d\n",
+			    pInfo->name,rc);
+		MouseTid = _beginthread(os2MouseEventThread,NULL,0x4000,(void *)pInfo);
+		xf86Msg(X_INFO,
+			"%s: Started Mouse event thread, Tid=%d\n",
+			pInfo->name, MouseTid);
+		DosSetPriority(2,3,0,MouseTid);
+	    }
+	    HandleValid=TRUE;
+	}
+	break;
+      
+    case DEVICE_ON:
+	if (!HandleValid) return -1;
+	pMse->lastButtons = 0;
+	pMse->lastMappedButtons = 0;
+	pMse->emulateState = 0;
+	pPointer->public.on = TRUE;
+	state = 0x300;
+	rc = MouSetDevStatus(&state,hMouse);
+	state = 0x7f;
+	rc = MouSetEventMask(&state,hMouse);
+	MouFlushQue(hMouse);
+	if (pMse->emulate3Buttons || pMse->emulate3ButtonsSoft)
+	{
+	    RegisterBlockAndWakeupHandlers (MouseBlockHandler, MouseWakeupHandler,
+					    (pointer) pInfo);
+	}
+	break;
+
+    case DEVICE_CLOSE:
+    case DEVICE_OFF:
+	if (!HandleValid) return -1;
+        if (pMse->emulate3Buttons || pMse->emulate3ButtonsSoft)
+        {
+	    RemoveBlockAndWakeupHandlers (MouseBlockHandler, MouseWakeupHandler,
+	    			      (pointer) pInfo);
+        }
+	pPointer->public.on = FALSE;
+	state = 0x300;
+	MouSetDevStatus(&state,hMouse);
+	state = 0;
+	MouSetEventMask(&state,hMouse);
+	if (what == DEVICE_CLOSE) {
+/* Comment out for now as this seems to break server */
+#if 0
+	    MouClose(hMouse);
+	    hMouse = 65535;
+	    pInfo->fd = -1;
+	    HandleValid = FALSE;
+#endif
+	}
+	break;
+    }
+    return Success;
+}
+
+int os2MouseQueueQuery()
+{
+    /* Now we check for activity on mouse handles */
+    ULONG numElements,postCount;
+
+    if (!HandleValid) return(1);
+    DosResetEventSem(hMouseSem,&postCount);
+    (void)DosQueryQueue(hMouseQueue,&numElements);
+    if (numElements>0) {     /* Something in mouse queue! */
+	return 0;  /* Will this work? */
+    }
+    return 1;
+}
+
+void os2MouseEventThread(void *arg)
+{
+    APIRET rc;
+    MOUEVENTINFO mev;
+    ULONG queueParam;
+    USHORT waitflg;
+    char queueName[128];
+    MouseDevPtr pMse;
+
+    iinfoPtr = (InputInfoPtr)arg;
+    pMse = iinfoPtr->private;
+
+    sprintf(queueName,"\\QUEUES\\XF86MOU\\%d",getpid());
+    rc = DosCreateQueue(&hMouseQueue,0L,queueName);
+    xf86Msg(X_INFO,"Mouse Queue created, rc=%d\n",rc);
+    (void)DosPurgeQueue(hMouseQueue);
+
+    while(1) {
+	waitflg = 1;
+	rc = MouReadEventQue(&mev,&waitflg,hMouse);
+	if (rc) {
+	    xf86Msg(X_ERROR,
+		    "Bad return code from mouse driver, rc=%d\n",
+		    rc);
+	    xf86Msg(X_ERROR,"Mouse aborting!\n");
+	    break;
+	}
+
+	queueParam = mev.col;
+	if ((rc = DosWriteQueue(hMouseQueue,queueParam,0L,NULL,0L)))
+		break;
+	queueParam = mev.row;
+	if ((rc = DosWriteQueue(hMouseQueue,queueParam,0L,NULL,0L)))
+ 		break;
+        queueParam = mev.fs;
+	if ((rc = DosWriteQueue(hMouseQueue,queueParam,0L,NULL,0L)))
+		break;
+	queueParam = 0xFFFFFFFF;
+	if ((rc = DosWriteQueue(hMouseQueue,queueParam,0L,NULL,0L)))
+		break;
+    }
+    xf86Msg(X_ERROR,
+        "An unrecoverable error in mouse queue has occured, rc=%d. Mouse is shutting down.\n",
+        rc);
+    DosCloseQueue(hMouseQueue);
+}
+
+
+static Bool
+os2MousePreInit(InputInfoPtr pInfo, const char* protocol, int flags) 
+{
+    MouseDevPtr pMse = pInfo->private;
+
+    pMse->protocol = protocol;
+    xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, protocol);
+
+    /* Collect the options, and process the common options. */
+    xf86CollectInputOptions(pInfo, NULL, NULL);
+    xf86ProcessCommonOptions(pInfo, pInfo->options);
+
+    /* Process common mouse options (like Emulate3Buttons, etc). */
+    pMse->CommonOptions(pInfo);
+
+    /* Setup the local procs. */
+    pInfo->device_control = os2MouseProc;
+    pInfo->read_input = os2MouseReadInput;
+
+    pInfo->flags |= XI86_CONFIGURED;
+    return TRUE;
+}
+
+OSMouseInfoPtr
+xf86OSMouseInit(int flags)
+{
+    OSMouseInfoPtr p;
+
+    p = xcalloc(sizeof(OSMouseInfoRec), 1);
+    if (!p)
+        return NULL;
+    p->SupportedInterfaces = SupportedInterfaces;
+    p->BuiltinNames = BuiltinNames;
+    p->DefaultProtocol = DefaultProtocol;
+    p->CheckProtocol = CheckProtocol;
+    p->PreInit = os2MousePreInit;
+    p->SetupAuto = SetupAuto;
+    return p;
+}
+
+void xf86OsMouseEvents()
+{
+	APIRET rc;
+	ULONG postCount,dataLength;
+	PVOID dummy;
+	int buttons;
+	int state;
+	int i, dx,dy;
+	BYTE elemPriority;
+	REQUESTDATA requestData;
+
+	MouseDevPtr pMse = iinfoPtr->private;
+
+	if (!HandleValid) return;
+	while((rc = DosReadQueue(hMouseQueue,
+				 &requestData,&dataLength,&dummy, 
+				 0L,1L,&elemPriority,hMouseSem)) == 0) {
+		dx = requestData.ulData;
+		(void)DosReadQueue(hMouseQueue,
+				  &requestData,&dataLength,&dummy,
+				  0L,1L,&elemPriority,hMouseSem);
+		dy = requestData.ulData;
+		(void)DosReadQueue(hMouseQueue,
+				  &requestData,&dataLength,&dummy,
+				  0L,1L,&elemPriority,hMouseSem);
+		state = requestData.ulData;
+		(void)DosReadQueue(hMouseQueue,
+				  &requestData,&dataLength,&dummy,
+				  0L,1L,&elemPriority,hMouseSem);
+		if (requestData.ulData != 0xFFFFFFFF) 
+			xf86Msg(X_ERROR,
+				"Unexpected mouse event tag, %d\n",
+				requestData.ulData);
+
+		/* Contrary to other systems, OS/2 has mouse buttons *
+		 * in the proper order, so we reverse them before    *
+		 * sending the event.                                */
+		 
+		buttons = ((state & 0x06) ? 4 : 0) |
+			  ((state & 0x18) ? 1 : 0) |
+			  ((state & 0x60) ? 2 : 0);
+		pMse->PostEvent(iinfoPtr, buttons, dx, dy, 0, 0);
+	}
+        DosResetEventSem(hMouseSem,&postCount);
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_select.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_select.c
new file mode 100644
index 000000000..395104242
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_select.c
@@ -0,0 +1,497 @@
+/* $XConsortium: os2_select.c /main/6 1996/10/27 11:48:55 kaleb $ */
+
+
+
+
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_select.c,v 3.9 2003/03/25 04:18:24 dawes Exp $ */
+
+/*
+ * (c) Copyright 1996 by Sebastien Marineau
+ *			<marineau@genie.uottawa.ca>
+ *     Modified 1999 by Holger.Veit@gmd.de
+ *     Modified 2004 by Frank Giessler
+ *			<giessler@biomag.uni-jena.de>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Sebastien Marineau shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Sebastien Marineau.
+ *
+ */
+
+/* os2_select.c: reimplementation of the xserver select(), optimized for speed */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include <io.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/errno.h>
+#include <emx/io.h>
+
+#define I_NEED_OS2_H
+#define INCL_DOSSEMAPHORES
+#define INCL_DOSPROFILE
+#define INCL_DOSPROCESS
+#define INCL_DOSFILEMGR
+#define INCL_DOSMISC
+#define INCL_DOSMODULEMGR
+
+
+#include <X11/Xpoll.h>
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+#include "os2_select.h"
+
+int os2MouseQueueQuery();
+int os2KbdQueueQuery();
+void os2RecoverFromPopup();
+void os2CheckPopupPending();
+void os2SocketMonitorThread();
+extern BOOL os2PopupErrorPending;
+
+extern HEV hKbdSem;
+extern HEV hMouseSem;
+extern HEV hevServerHasFocus;
+HEV hPipeSem;
+HEV hSocketSem;
+HEV hActivateSocketSem;
+HEV hSwitchToSem;
+static HMUX hSelectWait;
+SEMRECORD SelectMuxRecord[5];
+HMODULE hmod_so32dll;
+static struct select_data sd;
+
+static int (*os2_tcp_select)(int *,int,int,int,long);
+static int (*os2_so_cancel)(int);
+static int (*os2_sock_errno)();
+int os2_set_error(ULONG);
+extern int _files[];
+
+
+
+/* This is a new implementation of select, for improved efficiency */
+/* This function performs select() on sockets  */
+/* but uses OS/2 internal fncts to check mouse */
+/* and keyboard. S. Marineau, 27/4/96          */
+
+/* This is still VERY messy */
+
+/* A few note on optimizations: this select has been tuned for maximum
+* performance, and thus has a different approach than a general-purpose
+* select. It should not be used in another app without modifications. Further,
+* it may need modifications if the Xserver os code is modified
+* Assumptions: this is never called with anything in exceptfds. This is
+* silently ignored. Further, if any pipes are specified in the write mask, it is
+* because they have just been stuffed full by the xserver. There is not much
+* in immediately returning with those bits set. Instead, we block on the
+* semaphore for at least one tick, which will let the client at least start
+* to flush the pipe. */
+
+int os2PseudoSelect(nfds,readfds,writefds,exceptfds,timeout)
+	int nfds;
+	fd_set *readfds,*writefds,*exceptfds;
+	struct timeval *timeout;
+{
+
+	static BOOL FirstTime=TRUE;
+
+	int n,ns,np;
+	int ready_handles;
+	ULONG timeout_ms;
+	BOOL any_ready;
+	ULONG semKey,postCount;
+	APIRET rc;
+	char faildata[16];
+	static int Socket_Tid;
+
+	sd.have_read=FALSE; sd.have_write=FALSE;
+	sd.socket_nread=0; sd.socket_nwrite=0; sd.socket_ntotal=0;
+	sd.max_fds=31; ready_handles=0; any_ready=FALSE;
+	sd.pipe_ntotal=0; sd.pipe_have_write=FALSE;
+
+	/* Stuff we have to do the first time this is called to set up various parameters */
+
+	if (FirstTime) {
+		/* First load the so32dll.dll module and get a pointer to the SELECT fn */
+
+		if ((rc=DosLoadModule(faildata,sizeof(faildata),"SO32DLL",&hmod_so32dll))!=0) {
+			FatalError("Could not load module so32dll.dll, rc = %d. Error note %s\n",rc,faildata);
+		}
+		if ((rc = DosQueryProcAddr(hmod_so32dll, 0, "SELECT", (PPFN)&os2_tcp_select))!=0) {
+			FatalError("Could not query address of SELECT, rc = %d.\n",rc);
+		}
+		if ((rc = DosQueryProcAddr(hmod_so32dll, 0, "SO_CANCEL", (PPFN)&os2_so_cancel))!=0) {
+			FatalError("Could not query address of SO_CANCEL, rc = %d.\n",rc);
+		}
+		if ((rc = DosQueryProcAddr(hmod_so32dll, 0, "SOCK_ERRNO", (PPFN)&os2_sock_errno))!=0) {
+			FatalError("Could not query address of SOCK_ERRNO, rc = %d.\n",rc);
+		}
+
+		/* Call these a first time to set the semaphore */
+		xf86OsMouseEvents();
+		xf86KbdEvents();
+
+		DosCreateEventSem(NULL, &hSocketSem,DC_SEM_SHARED,FALSE);
+		DosResetEventSem(hSocketSem,&postCount);
+
+		DosCreateEventSem(NULL, &hActivateSocketSem, DC_SEM_SHARED, FALSE);
+		DosResetEventSem(hActivateSocketSem, &postCount);
+
+		DosCreateEventSem(NULL, &hSwitchToSem, DC_SEM_SHARED, FALSE);
+		DosResetEventSem(hSwitchToSem, &postCount);
+
+		Socket_Tid = _beginthread(os2SocketMonitorThread, NULL, 0x2000,(void *) NULL);
+		xf86Msg(X_INFO,
+			"Started Socket monitor thread, TID=%d\n",Socket_Tid);
+
+		SelectMuxRecord[0].hsemCur = (HSEM)hMouseSem;
+		SelectMuxRecord[0].ulUser = MOUSE_SEM_KEY;
+		SelectMuxRecord[1].hsemCur = (HSEM)hKbdSem;
+		SelectMuxRecord[1].ulUser = KBD_SEM_KEY;
+		SelectMuxRecord[2].hsemCur = (HSEM)hPipeSem;
+		SelectMuxRecord[2].ulUser = PIPE_SEM_KEY;
+		SelectMuxRecord[3].hsemCur = (HSEM)hSocketSem;
+		SelectMuxRecord[3].ulUser = SOCKET_SEM_KEY;
+		SelectMuxRecord[4].hsemCur = (HSEM)hSwitchToSem;
+		SelectMuxRecord[4].ulUser = SWITCHTO_SEM_KEY;
+		
+		rc = DosCreateMuxWaitSem(NULL, &hSelectWait, 5, SelectMuxRecord,
+                DC_SEM_SHARED | DCMW_WAIT_ANY);
+		if (rc) {
+			xf86Msg(X_ERROR,"Could not create MuxWait semaphore, rc=%d\n",rc);
+		}
+		FirstTime = FALSE;
+	}
+
+	rc = DosResetEventSem(hActivateSocketSem, &postCount);
+	/* Set up the time delay structs */
+
+	if (timeout!=NULL) {
+	timeout_ms=timeout->tv_sec*1000+timeout->tv_usec/1000;
+	} else {
+		timeout_ms=1000000;  /* This should be large enough... */
+	}
+
+	/* Zero our local fd_masks */
+	{FD_ZERO(&sd.read_copy);}
+	{FD_ZERO(&sd.write_copy);}
+
+	/* Copy the masks for later use */
+	if (readfds!=NULL) { XFD_COPYSET(readfds,&sd.read_copy); sd.have_read=TRUE; }
+	if (writefds!=NULL) {XFD_COPYSET(writefds,&sd.write_copy); sd.have_write=TRUE; }
+
+	/* And zero the original masks */
+	if (sd.have_read){ FD_ZERO(readfds); }
+	if (sd.have_write) {FD_ZERO(writefds); }
+	if (exceptfds != NULL) {FD_ZERO(exceptfds); }
+
+	/* Now we parse the fd_sets passed to select and separate pipe/sockets */
+	n = os2_parse_select(&sd,nfds);
+
+	/* Now check if we have sockets ready! */
+
+	if (sd.socket_ntotal > 0) {
+		ns = os2_poll_sockets(&sd,readfds,writefds);
+		if (ns>0) {
+			ready_handles+=ns;
+			any_ready = TRUE;
+		} else if (ns == -1) {
+			return(-1);
+		}
+	}
+
+	/* And pipes */
+
+	if (sd.pipe_ntotal > 0) {
+           np = os2_check_pipes(&sd,readfds,writefds);
+		if (np > 0) {
+			ready_handles+=np;
+			any_ready = TRUE;
+		} else if (np == -1) {
+			return(-1);
+		}
+	}
+
+	/* And finally poll input devices */
+	if(!os2MouseQueueQuery() || !os2KbdQueueQuery() ) any_ready = TRUE;
+
+	if (xf86Info.vtRequestsPending) any_ready=TRUE;
+
+	if (os2PopupErrorPending)
+		os2RecoverFromPopup();
+
+	if (!any_ready && timeout_ms) {
+		DosResetEventSem(hSocketSem,&postCount);
+
+		/* Activate the socket thread */
+		if (sd.socket_ntotal>0) {
+			rc = DosPostEventSem(hActivateSocketSem);
+		}
+
+		rc = DosWaitMuxWaitSem(hSelectWait, timeout_ms, &semKey);
+
+		/* If our socket monitor thread is still blocked in os2_tcp_select()
+		 * we have to wake it up by calling os2_so_cancel().
+		 * After that, call os2_tcp_select() once more to get rid of
+		 * error SOCEINTR (10004)
+		 */
+		if (sd.socket_ntotal>0) {
+			rc = DosQueryEventSem(hSocketSem, &postCount);
+
+			if (postCount == 0) {		/* os2_select still blocked */
+				int i,f,g;
+				struct select_data *sd_ptr=&sd;
+
+				if (sd.socket_nread > 0) {
+					for (i=0; i<sd.socket_nread; i++) {
+						f = g = sd_ptr->tcp_select_mask[i];
+						os2_so_cancel(f);
+						os2_tcp_select(&g, 1, 0, 0, 0);  /* get rid of error 10004 */
+					}
+				}
+				if (sd.socket_nwrite > 0) {
+					for (i=sd.socket_nread;
+					     i<sd.socket_nread+sd.socket_nwrite;
+					     i++) {
+						f = g = sd_ptr->tcp_select_mask[i];
+						os2_so_cancel(f);
+						os2_tcp_select(&g, 0, 1, 0, 0); /* get rid of error 10004 */
+					}
+				}
+			} else {		/* not blocked, something must be ready -> get it */
+				ns = os2_poll_sockets(&sd,readfds,writefds);
+				if (ns>0) {
+					ready_handles+=ns;
+				} else if (ns == -1) {
+					return(-1);
+				}
+			}
+		}
+		if (sd.pipe_ntotal > 0) {
+			rc = DosQueryEventSem(hPipeSem,&postCount);
+			if (postCount > 0) {
+				np = os2_check_pipes(&sd,readfds,writefds);
+				if (np > 0) {
+					ready_handles+=np;
+				} else if (np == -1) {
+					return(-1);
+				}
+			}
+		}
+	}
+	/* The polling of sockets/pipe automatically set the proper bits */
+	return (ready_handles);
+}
+
+
+int os2_parse_select(sd,nfds)
+	struct select_data *sd;
+	int nfds;
+{
+   int i;
+	/* First we determine up to which descriptor we need to check.              */
+	/* No need to check up to 256 if we don't have to (and usually we dont...)*/
+	/* Note: stuff here is hardcoded for fd_sets which are int[8] as in EMX!!!    */
+
+	if (nfds > sd->max_fds) {
+		for (i=0;i<((FD_SETSIZE+31)/32);i++) {
+			if (sd->read_copy.fds_bits[i] ||
+			    sd->write_copy.fds_bits[i])
+				sd->max_fds=(i*32) +32;
+		}
+	} else { sd->max_fds = nfds; }
+
+	/* Check if this is greater than specified in select() call */
+	if(sd->max_fds > nfds) sd->max_fds = nfds;
+
+	if (sd->have_read) {
+		for (i = 0; i < sd->max_fds; ++i) {
+			if (FD_ISSET (i, &sd->read_copy)) {
+				if(_files[i] & F_SOCKET) {
+					sd->tcp_select_mask[sd->socket_ntotal]=_getsockhandle(i);
+					sd->tcp_emx_handles[sd->socket_ntotal]=i;
+					sd->socket_ntotal++; sd->socket_nread++;
+				} else if (_files[i] & F_PIPE) {
+					sd -> pipe_ntotal++;
+				}
+			}
+		}
+	}
+	if (sd->have_write) {
+		for (i = 0; i < sd->max_fds; ++i) {
+			if (FD_ISSET (i, &sd->write_copy)) {
+				if (_files[i] & F_SOCKET) {
+					sd->tcp_select_mask[sd->socket_ntotal]=_getsockhandle(i);
+					sd->tcp_emx_handles[sd->socket_ntotal]=i;
+					sd->socket_ntotal++; sd->socket_nwrite++;
+				} else if (_files[i] & F_PIPE) {
+					sd -> pipe_ntotal++;
+					sd -> pipe_have_write=TRUE;
+				}
+			}
+		}
+	}
+	return(sd->socket_ntotal);
+}
+
+
+int os2_poll_sockets(sd,readfds,writefds)
+	struct select_data *sd;
+	fd_set *readfds,*writefds;
+{
+	int e,i;
+	int j,n;
+
+	memcpy(sd->tcp_select_copy,sd->tcp_select_mask,
+	          sd->socket_ntotal*sizeof(int));
+
+	e = os2_tcp_select(sd->tcp_select_copy,sd->socket_nread,
+	                      sd->socket_nwrite, 0, 0);
+
+	if (e == 0) return(e);
+
+	/* We have something ready? */
+	if (e>0) {
+		j = 0; n = 0;
+		for (i = 0; i < sd->socket_nread; ++i, ++j)
+			if (sd->tcp_select_copy[j] != -1) {
+				FD_SET (sd->tcp_emx_handles[j], readfds);
+				n ++;
+			}
+		for (i = 0; i < sd->socket_nwrite; ++i, ++j)
+			if (sd->tcp_select_copy[j] != -1) {
+				FD_SET (sd->tcp_emx_handles[j], writefds);
+				n ++;
+			}
+		errno = 0;
+
+		return n;
+	}
+	if (e<0) {
+		/*Error -- TODO */
+		xf86Msg(X_ERROR,"Error in server select! sock_errno = %d\n",os2_sock_errno());
+		errno = EBADF;
+		return (-1);
+	}
+}
+
+/* Check to see if anything is ready on pipes */
+
+int os2_check_pipes(sd,readfds,writefds)
+	struct select_data *sd;
+	fd_set *readfds,*writefds;
+{
+	int i,e;
+	ULONG ulPostCount;
+	PIPESEMSTATE pipeSemState[128];
+	APIRET rc;
+
+	e = 0;
+	rc = DosResetEventSem(hPipeSem,&ulPostCount);
+	rc = DosQueryNPipeSemState((HSEM) hPipeSem, (PPIPESEMSTATE)&pipeSemState,
+	                              sizeof(pipeSemState));
+	if(rc) xf86Msg(X_ERROR,"SELECT: rc from QueryNPipeSem: %d\n",rc);
+	i=0;
+	while (pipeSemState[i].fStatus != 0) {
+/*           xf86Msg(X_INFO,"SELECT: sem entry, stat=%d, flag=%d, key=%d,avail=%d\n",
+                pipeSemState[i].fStatus,pipeSemState[i].fFlag,pipeSemState[i].usKey,
+                pipeSemState[i].usAvail);  */
+		if ((pipeSemState[i].fStatus == 1) &&
+		    (FD_ISSET(pipeSemState[i].usKey,&sd->read_copy))) {
+			FD_SET(pipeSemState[i].usKey,readfds);
+			e++;
+		} else if ((pipeSemState[i].fStatus == 2)  &&
+		           (FD_ISSET(pipeSemState[i].usKey,&sd->write_copy))) {
+			FD_SET(pipeSemState[i].usKey,writefds);
+			e++;
+		} else if ((pipeSemState[i].fStatus == 3) &&
+		           ((FD_ISSET(pipeSemState[i].usKey,&sd->read_copy)) ||
+		            (FD_ISSET(pipeSemState[i].usKey,&sd->write_copy)) )) {
+			errno = EBADF;
+			/* xf86Msg(X_ERROR,"Pipe has closed down, fd=%d\n",pipeSemState[i].usKey); */
+			return (-1);
+		}
+		i++;
+	} /* endwhile */
+
+	errno = 0;
+	return(e);
+}
+
+
+void os2SocketMonitorThread(void *arg)
+{
+	struct select_data *sd_ptr = &sd;
+	ULONG ulPostCount;
+	int e,rc;
+
+	/* Make thread time critical */
+	DosSetPriority(2L,3L,0L,0L);
+
+	while (1) {
+		rc = DosWaitEventSem(hActivateSocketSem, SEM_INDEFINITE_WAIT);
+		if (rc != 0 )
+			xf86Msg(X_ERROR,"Socket monitor: DosWaitEventSem(hActivateSocketSem..) returned %d\n",rc);
+
+		rc = DosResetEventSem(hActivateSocketSem,&ulPostCount);
+		if (rc != 0 )
+			xf86Msg(X_ERROR,"Socket monitor: DosResetEventSem(&hActivateSocketSem..) returned %d\n",rc);
+
+		/* fg300104:
+		 * The next line shouldn't be here, but the DosPostEventSem()
+		 * below will return 299 from time to time under heavy load
+		 */
+/*		DosResetEventSem(hSocketSem,&ulPostCount);*/
+
+		memcpy(sd_ptr->tcp_select_monitor,sd_ptr->tcp_select_mask,
+		        sd_ptr->socket_ntotal*sizeof(int));
+
+		/* call os2_select(), return only if either something is ready or
+		 * os2_so_cancel() was called
+		 */
+		e = os2_tcp_select(sd_ptr->tcp_select_monitor, sd_ptr->socket_nread,
+		                    sd_ptr->socket_nwrite, 0, -1);
+
+		if (e>0) {
+			rc = DosPostEventSem(hSocketSem);
+			if (rc != 0 )
+				xf86Msg(X_ERROR,"Socket monitor: DosPostEventSem(hSocketSem..) returned %d\n",rc);
+		} else if (e<0) {
+			rc = os2_sock_errno();
+			if (rc != 10004)
+				xf86Msg(X_ERROR,"Socket monitor: os2_select: sock_errno = %d\n",rc);
+		}
+
+		rc = DosQueryEventSem(hevServerHasFocus, &ulPostCount);
+
+		/* no need to rush while switched away */
+		if ((rc==0) && (ulPostCount==0))
+			rc == DosWaitEventSem(hevServerHasFocus,31L);
+	}
+}
+
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_select.h b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_select.h
new file mode 100644
index 000000000..cb2291e09
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_select.h
@@ -0,0 +1,62 @@
+/* $XConsortium: os2_select.h /main/1 1996/05/13 16:38:30 kaleb $ */
+/*
+ * (c) Copyright 1996 by Sebastien Marineau
+ *			<marineau@genie.uottawa.ca>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Sebastien Marineau shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Sebastien Marineau.
+ *
+ */
+
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_select.h,v 3.1 1996/12/27 07:04:31 dawes Exp $ */
+
+/* Header file for os2_select.c */
+
+#define MAX_TCP 256
+
+#define MOUSE_SEM_KEY 0x0F01
+#define KBD_SEM_KEY 0x0F02
+#define PIPE_SEM_KEY 0x0F03
+#define SOCKET_SEM_KEY 0x0F04
+#define SWITCHTO_SEM_KEY 0x0F05
+
+
+struct select_data
+{
+   fd_set read_copy;
+   fd_set write_copy;
+   BOOL have_read;
+   BOOL have_write;
+   int tcp_select_mask[MAX_TCP];
+   int tcp_emx_handles[MAX_TCP];
+   int tcp_select_copy[MAX_TCP];
+   int tcp_select_monitor[MAX_TCP];
+   int socket_nread;
+   int socket_nwrite;
+   int socket_ntotal;
+   int pipe_ntotal;
+   int pipe_have_write;
+   int max_fds;
+};
+
+
+
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_serial.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_serial.c
new file mode 100644
index 000000000..6587b1bda
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_serial.c
@@ -0,0 +1,517 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_serial.c,v 1.3 2000/04/05 18:13:53 dawes Exp $ */
+/*
+ * (c) Copyright 1999 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XConsortium$ */
+
+#define I_NEED_OS2_H
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include "input.h"
+#include "scrnintstr.h"
+
+#include "compiler.h"
+
+#define INCL_DOSDEVIOCTL
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+static int _set_baudrate(HFILE fd,int baud) 
+{
+	USHORT br = baud;
+	ULONG plen;
+	return DosDevIOCtl(fd,IOCTL_ASYNC,ASYNC_SETBAUDRATE,
+			   (PULONG)&br,sizeof(br),&plen,NULL,0,NULL);
+}
+
+#pragma pack(1)
+typedef struct _glinectl {
+	UCHAR databits;
+	UCHAR parity;
+	UCHAR stopbits;
+	UCHAR sendbrk;
+} GLINECTL;
+typedef struct _slinectl {
+	UCHAR databits;
+	UCHAR parity;
+	UCHAR stopbits;
+} SLINECTL;
+
+#pragma pack()
+
+static int _get_linectrl(HFILE fd,GLINECTL* linectrl)
+{
+	ULONG dlen;
+	return DosDevIOCtl(fd,IOCTL_ASYNC,ASYNC_GETLINECTRL,
+		NULL,0,NULL,linectrl,sizeof(GLINECTL),&dlen);
+}
+
+static int _set_linectl(HFILE fd,GLINECTL* linectl)
+{
+	ULONG plen;
+	return DosDevIOCtl(fd,IOCTL_ASYNC,ASYNC_SETLINECTRL,
+		(PULONG)&linectl,sizeof(SLINECTL),&plen,NULL,0,NULL);
+}
+
+static int _get_dcb(HFILE fd,DCBINFO* dcb) {
+
+	ULONG dlen;
+	return DosDevIOCtl(fd,IOCTL_ASYNC,ASYNC_GETDCBINFO,
+		NULL,0,NULL,(PULONG)dcb,sizeof(DCBINFO),&dlen);
+}
+
+static int _set_dcb(HFILE fd,DCBINFO* dcb) 
+{
+	ULONG plen;
+	return DosDevIOCtl(fd,IOCTL_ASYNC, ASYNC_SETDCBINFO,
+			   (PULONG)dcb,sizeof(DCBINFO),&plen,NULL,0,NULL);
+}
+
+#pragma pack(1)
+typedef struct comsize {
+		USHORT nqueued;
+		USHORT qsize;
+} COMSIZE;
+#pragma pack()
+
+static int _get_nread(HFILE fd,ULONG* nread) 
+{
+	ULONG dlen;
+	COMSIZE sz;
+	APIRET rc = DosDevIOCtl(fd,IOCTL_ASYNC,ASYNC_GETINQUECOUNT,
+			 NULL, 0, NULL, sz,sizeof(COMSIZE),&dlen);
+	*nread = sz.nqueued;
+	return rc ? -1 : 0;
+}
+
+int xf86OpenSerial (pointer options)
+{
+	APIRET rc;
+	HFILE fd, i;
+	ULONG action;
+	GLINECTL linectl;
+
+	char* dev = xf86FindOptionValue (options, "Device");
+	xf86MarkOptionUsedByName (options, "Device");
+	if (!dev) {
+		xf86Msg (X_ERROR, "xf86OpenSerial: No Device specified.\n");
+		return -1;
+	}
+
+	rc = DosOpen(dev, &fd, &action, 0, FILE_NORMAL, FILE_OPEN,
+		     OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE, NULL);
+	if (rc) {
+		xf86Msg (X_ERROR,
+			 "xf86OpenSerial: Cannot open device %s, rc=%d.\n",
+			 dev, rc);
+		return -1;
+	}
+
+	/* check whether it is an async device */
+	if (_get_linectrl(fd,&linectl)) {
+		xf86Msg (X_WARNING,
+			 "xf86OpenSerial: Specified device %s is not a tty\n",
+			 dev);
+		DosClose(fd);
+		return -1;
+	}
+
+	/* set up default port parameters */
+	_set_baudrate(fd, 9600);
+
+	linectl.databits = 8;
+	linectl.parity = 0;
+	linectl.stopbits = 0;
+	_set_linectl(fd, &linectl);
+
+	if (xf86SetSerial (fd, options) == -1) {
+		DosClose(fd);
+		return -1;
+	}
+
+	return fd;
+}
+
+int xf86SetSerial (int fd, pointer options)
+{
+	APIRET rc;
+	USHORT baud;
+	ULONG plen,dlen;
+	char *s;
+
+	GLINECTL linectl;
+	DCBINFO dcb;
+
+	if ((s = xf86FindOptionValue (options, "BaudRate"))) {
+		xf86MarkOptionUsedByName (options, "BaudRate");
+		if ((rc = _set_baudrate(fd, atoi(s)))) {
+			xf86Msg (X_ERROR,"Set Baudrate: %s, rc=%d\n", s, rc);
+			return -1;
+		}
+	}
+
+	/* get line parameters */
+	if (DosDevIOCtl((HFILE)fd,IOCTL_ASYNC, ASYNC_GETLINECTRL,
+			NULL,0,NULL,
+			(PULONG)&linectl,sizeof(GLINECTL),&dlen)) return -1;
+
+	if ((s = xf86FindOptionValue (options, "StopBits"))) {
+		xf86MarkOptionUsedByName (options, "StopBits");
+		switch (atoi (s)) {
+		case 1:	linectl.stopbits = 0;
+			break;
+		case 2:	linectl.stopbits = 2;
+			break;
+		default: xf86Msg (X_ERROR,
+				 "Invalid Option StopBits value: %s\n", s);
+			return -1;
+		}
+	}
+
+	if ((s = xf86FindOptionValue (options, "DataBits"))) {
+		int db;
+		xf86MarkOptionUsedByName (options, "DataBits");
+		switch (db = atoi (s)) {
+		case 5: case 6: case 7: case 8:
+			linectl.databits = db;
+			break;
+		default: xf86Msg (X_ERROR,
+				 "Invalid Option DataBits value: %s\n", s);
+			return -1;
+		}
+	}
+
+	if ((s = xf86FindOptionValue (options, "Parity"))) {
+		xf86MarkOptionUsedByName (options, "Parity");
+		if (xf86NameCmp (s, "Odd") == 0)
+			linectl.parity = 1; /* odd */
+		else if (xf86NameCmp (s, "Even") == 0)
+			linectl.parity = 2; /* even */
+		else if (xf86NameCmp (s, "None") == 0)
+			linectl.parity = 0; /* none */
+		else {
+			xf86Msg (X_ERROR,
+				 "Invalid Option Parity value: %s\n", s);
+			return -1;
+		}
+	}
+
+	/* set line parameters */
+	if (_set_linectl(fd,&linectl)) return -1;
+
+	if (xf86FindOptionValue (options, "Vmin"))
+		xf86Msg (X_ERROR, "Vmin unsupported on this OS\n");
+
+	if (xf86FindOptionValue (options, "Vtime"))
+		xf86Msg (X_ERROR, "Vtime unsupported on this OS\n");
+
+	/* get device parameters */
+	if (_get_dcb(fd,&dcb)) return -1;
+
+	if ((s = xf86FindOptionValue (options, "FlowControl"))) {
+		xf86MarkOptionUsedByName (options, "FlowControl");
+		if (xf86NameCmp (s, "XonXoff") == 0)
+			dcb.fbFlowReplace |= 0x03;
+		else if (xf86NameCmp (s, "None") == 0)
+			dcb.fbFlowReplace &= ~0x03;
+		else {
+			xf86Msg (X_ERROR,
+				 "Invalid Option FlowControl value: %s\n", s);
+			return -1;
+		}
+	}
+
+	if ((s = xf86FindOptionValue (options, "ClearDTR"))) {
+		dcb.fbCtlHndShake &= ~0x03; /* DTR=0 */
+		xf86MarkOptionUsedByName (options, "ClearDTR");
+	}
+
+	if ((s = xf86FindOptionValue (options, "ClearRTS"))) {
+		dcb.fbFlowReplace &= ~0xc0; /* RTS=0 */
+		xf86MarkOptionUsedByName (options, "ClearRTS");
+	}
+
+	/* set device parameters */
+	return _set_dcb(fd,&dcb) ? -1 : 0;
+}
+
+int xf86ReadSerial (int fd, void *buf, int count)
+{
+	ULONG nread,nq;
+	APIRET rc;
+
+	/* emulate non-blocking read */
+	if (_get_nread((HFILE)fd,&nq)) return -1;
+	if (nq==0) return 0;
+	if (nq < count) count = nq;
+
+	rc = DosRead((HFILE)fd,(PVOID)buf,(ULONG)count,&nread);
+	return rc ? -1 : (int)nread;
+}
+
+int xf86WriteSerial (int fd, const void *buf, int count)
+{
+	ULONG nwrite;
+	APIRET rc = DosWrite((HFILE)fd,(PVOID)buf,(ULONG)count,&nwrite);
+	return rc ? -1 : (int)nwrite;
+}
+
+int xf86CloseSerial (int fd)
+{
+	APIRET rc = DosClose((HFILE)fd);
+	return rc ? -1 : 0;
+}
+
+int xf86WaitForInput (int fd, int timeout)
+{
+	APIRET rc;
+	ULONG dlen,nq;
+
+	do {
+		if (_get_nread((HFILE)fd,&nq)) return -1;
+		if (nq) return 1;
+
+		DosSleep(10);
+		timeout -= 10000; /* 10000 usec */
+	} while (timeout > 0);
+
+	return 0;
+}
+
+int xf86SerialSendBreak (int fd, int duration)
+{
+	USHORT data;
+	ULONG dlen;
+	APIRET rc;
+	rc = DosDevIOCtl((HFILE)fd,IOCTL_ASYNC,ASYNC_SETBREAKON,
+			NULL, 0, NULL,
+			&data, sizeof(data), &dlen);
+	if (rc)
+		return -1;
+	DosSleep(500);
+
+	rc = DosDevIOCtl((HFILE)fd,IOCTL_ASYNC,ASYNC_SETBREAKOFF,
+			NULL, 0, NULL,
+			&data, sizeof(data), &dlen);
+	return rc ? -1 : 0;
+}
+
+int xf86FlushInput(int fd)
+{
+	APIRET rc;
+	UCHAR buf;
+	ULONG nread,nq;
+
+	if (_get_nread((HFILE)fd,&nq)) return -1;
+
+	/* eat all chars in queue */
+	while (nq) {
+		rc = DosRead((HFILE)fd,&buf,1,&nread);
+		if (rc) return -1;
+		nq--;
+	}
+	return 0;
+}
+
+static struct states {
+        int xf;
+        int os;
+} modemStates[] = {
+        { XF86_M_DTR, 0x01 },
+        { XF86_M_RTS, 0x02 },
+        { XF86_M_CTS, 0x10 },
+        { XF86_M_DSR, 0x20 },
+        { XF86_M_RNG, 0x40 },
+        { XF86_M_CAR, 0x80 },
+};
+
+static int numStates = sizeof(modemStates) / sizeof(modemStates[0]);
+
+static int
+xf2osState(int state)
+{
+        int i;
+        int ret = 0;
+
+        for (i = 0; i < numStates; i++)
+                if (state & modemStates[i].xf)
+                        ret |= modemStates[i].os;
+        return ret;
+}
+
+static int
+os2xfState(int state)
+{
+        int i;
+        int ret = 0;
+
+        for (i = 0; i < numStates; i++)
+                if (state & modemStates[i].os)
+                        ret |= modemStates[i].xf;
+        return ret;
+}
+
+static int
+getOsStateMask(void)
+{
+        int i;
+        int ret = 0;
+        for (i = 0; i < numStates; i++)
+                ret |= modemStates[i].os;
+        return ret;
+}
+
+static int osStateMask = 0;
+
+static 
+int _get_modem_state(int fd,ULONG* state) 
+{
+	ULONG state1,len;
+
+	if (DosDevIOCtl((HFILE)fd,IOCTL_ASYNC,ASYNC_GETMODEMOUTPUT,
+		NULL,0,NULL, state, sizeof(BYTE), &len) != 0 ||
+	    DosDevIOCtl((HFILE)fd,IOCTL_ASYNC,ASYNC_GETMODEMINPUT,
+		NULL,0,NULL, &state1, sizeof(BYTE), &len) != 0)
+		return -1;
+	*state |= state1;
+	*state &= 0xff;
+	return 0;	
+}
+
+static 
+int _set_modem_state(int fd,ULONG state,ULONG mask) 
+{
+	int len;
+	struct {
+		BYTE onmask;
+		BYTE offmask;
+	} modemctrl;
+	modemctrl.onmask = state;
+	modemctrl.offmask = mask;
+
+	if (DosDevIOCtl((HFILE)fd,IOCTL_ASYNC,ASYNC_SETMODEMCTRL,
+		NULL,0,NULL, (PULONG)&modemctrl, sizeof(modemctrl), &len) != 0)
+		return -1;
+	else
+		return 0;
+}
+
+int
+xf86SetSerialModemState(int fd, int state)
+{
+        ULONG s;
+
+        if (fd < 0)
+                return -1;
+
+        /* Don't try to set parameters for non-tty devices. */
+        if (!isatty(fd))
+                return 0;
+
+        if (!osStateMask)
+                osStateMask = getOsStateMask();
+
+        state = xf2osState(state);
+
+	if (_get_modem_state(fd,&s) != 0)
+		return -1;
+
+        s &= ~osStateMask;
+        s |= state;
+
+	return _set_modem_state(fd,s,0x03);
+}
+
+int
+xf86GetSerialModemState(int fd)
+{
+        ULONG s;
+
+        if (fd < 0)
+                return -1;
+
+        /* Don't try to set parameters for non-tty devices. */
+        if (!isatty(fd))
+                return 0;
+
+	if (_get_modem_state(fd,&s) != 0)
+		return -1;
+
+        return os2xfState(s);
+}
+
+int
+xf86SerialModemSetBits(int fd, int bits)
+{
+        int ret;
+        int s;
+
+        if (fd < 0)
+                return -1;
+
+        /* Don't try to set parameters for non-tty devices. */
+        if (!isatty(fd))
+                return 0;
+
+        s = xf2osState(bits);
+	return _set_modem_state(fd,s,0x03);
+}
+
+int
+xf86SerialModemClearBits(int fd, int bits)
+{
+        int ret;
+        int s;
+
+        if (fd < 0)
+                return -1;
+
+        /* Don't try to set parameters for non-tty devices. */
+        if (!isatty(fd))
+                return 0;
+
+        s = xf2osState(bits);
+	return _set_modem_state(fd, 0, ~s & 0xff);
+}
+
+int
+xf86SetSerialSpeed (int fd, int speed)
+{
+	if (fd < 0)
+		return -1;
+
+        /* Don't try to set parameters for non-tty devices. */
+        if (!isatty(fd))
+                return 0;
+
+	return _set_baudrate(fd,speed);
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_stubs.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_stubs.c
new file mode 100644
index 000000000..727a605d1
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_stubs.c
@@ -0,0 +1,403 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_stubs.c,v 3.4 2002/05/31 18:46:02 dawes Exp $ */
+/*
+ * (c) Copyright 1996 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XConsortium: os2_stubs.c /main/3 1996/10/27 11:48:58 kaleb $ */
+
+#define I_NEED_OS2_H
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xpoll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/time.h>
+
+/* This is there to resolve a symbol in Xvfb 
+ * this version is somewhat crippled compared to the one in os2_io.c
+ */
+#ifdef OS2NULLSELECT
+
+/* This below implements select() for calls in xnest. It has been         */
+/* somewhat optimized for improved performance, but assumes a few */
+/* things so it cannot be used as a general select.                             */
+
+#include <sys/select.h>
+#include <sys/errno.h>
+#define INCL_DOSSEMAPHORES
+#define INCL_DOSNPIPES
+#define INCL_DOSMISC
+#define INCL_DOSMODULEMGR
+#undef BOOL
+#undef BYTE
+#include <os2.h>
+
+HEV hPipeSem;
+HMODULE hmod_so32dll;
+static int (*os2_tcp_select)(int*,int,int,int,long);
+ULONG os2_get_sys_millis();
+extern int _files[];
+
+#define MAX_TCP 256
+/* These lifted from sys/emx.h. Change if that changes there! */
+#define F_SOCKET 0x10000000
+#define F_PIPE 0x20000000
+
+struct select_data
+{
+   fd_set read_copy;
+   fd_set write_copy;
+   BOOL have_read;
+   BOOL have_write;
+   int tcp_select_mask[MAX_TCP];
+   int tcp_emx_handles[MAX_TCP];
+   int tcp_select_copy[MAX_TCP];
+   int socket_nread;
+   int socket_nwrite;
+   int socket_ntotal;
+   int pipe_ntotal;
+   int pipe_have_write;
+   int max_fds;
+};
+
+int os2PseudoSelect(int nfds, fd_set *readfds, fd_set *writefds,
+        fd_set *exceptfds, struct timeval *timeout)
+{
+static BOOL FirstTime=TRUE;
+static haveTCPIP=TRUE;
+ULONG timeout_ms;
+ULONG postCount, start_millis,now_millis;
+char faildata[16];
+struct select_data sd;
+BOOL any_ready;
+int np,ns, i,ready_handles,n;
+APIRET rc;
+
+sd.have_read=FALSE; sd.have_write=FALSE; 
+sd.socket_nread=0; sd.socket_nwrite=0; sd.socket_ntotal=0;
+sd.max_fds=31; ready_handles=0; any_ready=FALSE;
+sd.pipe_ntotal=0; sd.pipe_have_write=FALSE;
+
+if(FirstTime){
+   /* First load the so32dll.dll module and get a pointer to the SELECT function */
+
+   if((rc=DosLoadModule(faildata,sizeof(faildata),"SO32DLL",&hmod_so32dll))!=0){
+        fprintf(stderr, "Could not load module so32dll.dll, rc = %d. Error note %s\n",rc,faildata);
+        haveTCPIP=FALSE;
+        }
+   if((rc = DosQueryProcAddr(hmod_so32dll, 0, "SELECT", (PPFN)&os2_tcp_select))!=0){
+        fprintf(stderr, "Could not query address of SELECT, rc = %d.\n",rc);
+        haveTCPIP=FALSE;
+        }
+   /* Call these a first time to set the semaphore */
+    /* rc = DosCreateEventSem(NULL, &hPipeSem, DC_SEM_SHARED, FALSE);
+    if(rc) { 
+             fprintf(stderr, "Could not create event semaphore, rc=%d\n",rc);
+             return(-1);
+             }
+    rc = DosResetEventSem(hPipeSem, &postCount); */ /* Done in xtrans code for servers*/
+
+	/*fprintf(stderr, "Client select() done first-time stuff, sem handle %d.\n",hPipeSem);*/
+
+   FirstTime = FALSE;
+}
+
+/* Set up the time delay structs */
+
+    if(timeout!=NULL) {
+	timeout_ms=timeout->tv_sec*1000+timeout->tv_usec/1000;
+	}
+    else { timeout_ms=1000000; }  /* This should be large enough... */
+    if(timeout_ms>0) start_millis=os2_get_sys_millis();
+
+/* Copy the masks */
+    {FD_ZERO(&sd.read_copy);}
+    {FD_ZERO(&sd.write_copy);}
+    if(readfds!=NULL){ XFD_COPYSET(readfds,&sd.read_copy); sd.have_read=TRUE;}
+    if(writefds!=NULL) {XFD_COPYSET(writefds,&sd.write_copy);sd.have_write=TRUE;}
+
+/* And zero the original masks */
+    if(sd.have_read){ FD_ZERO(readfds);}
+    if(sd.have_write) {FD_ZERO(writefds);}
+    if(exceptfds != NULL) {FD_ZERO(exceptfds);}
+
+/* Now we parse the fd_sets passed to select and separate pipe/sockets */
+        n = os2_parse_select(&sd,nfds);
+        if(n == -1) {
+           errno = EBADF;
+           return (-1);
+           }
+
+/* Now we have three cases: either we have sockets, pipes, or both */
+/* We handle all three cases differently to optimize things */
+
+/* Case 1: only pipes! */
+        if((sd.pipe_ntotal >0) && (!sd.socket_ntotal)){
+            np = os2_check_pipes(&sd,readfds,writefds);
+            if(np > 0){
+               return (np);
+               }
+            else if (np == -1) { return(-1); }
+            while(!any_ready){
+                 rc = DosWaitEventSem(hPipeSem, 1L);
+                 /* if(rc) fprintf(stderr,"Sem-wait timeout, rc = %d\n",rc); */
+                 if(rc == 640)  {
+                     return(0);
+                     }
+                 if((rc != 0) && (rc != 95)) {errno= EBADF; return(-1);}
+                 np = os2_check_pipes(&sd,readfds,writefds);
+                 if (np > 0){
+                    return(np);
+                    }
+                 else if (np < 0){ return(-1); }
+                 }
+          }
+
+/* Case 2: only sockets. Just let the os/2 tcp select do the work */
+        if((sd.socket_ntotal > 0) && (!sd.pipe_ntotal)){
+                ns = os2_check_sockets(&sd, readfds, writefds, timeout_ms);
+                return (ns);
+                }
+
+/* Case 3: combination of both */
+        if((sd.socket_ntotal > 0) && (sd.pipe_ntotal)){
+           np = os2_check_pipes(&sd,readfds,writefds);
+              if(np > 0){
+                 any_ready=TRUE;
+                 ready_handles += np;
+                 }
+              else if (np == -1) { return(-1); }
+
+           ns = os2_check_sockets(&sd,readfds,writefds, 0);
+           if(ns>0){
+               ready_handles+=ns;
+               any_ready = TRUE;
+               }
+           else if (ns == -1) {return(-1);}
+
+           while (!any_ready && timeout_ms){
+
+                rc = DosWaitEventSem(hPipeSem, 1L);
+		if (rc=640) return(0);
+                if(rc == 0){
+                        np = os2_check_pipes(&sd,readfds,writefds);
+                        if(np > 0){
+                        ready_handles+=np;
+                        any_ready = TRUE;
+                        }
+                        else if (np == -1) { 
+                                return(-1); }
+                      }
+
+                 ns = os2_check_sockets(&sd,readfds,writefds,exceptfds, 0);
+                 if(ns>0){
+                      ready_handles+=ns;
+                      any_ready = TRUE;
+                     }
+                 else if (ns == -1) {return(-1);}
+
+                  if (i%8 == 0) { 
+                    now_millis = os2_get_sys_millis();
+                    if((now_millis-start_millis) > timeout_ms) timeout_ms = 0;
+                    }
+                   i++;
+                  }
+        }
+
+return(ready_handles);
+}
+
+
+ULONG os2_get_sys_millis()
+{
+   APIRET rc;
+   ULONG milli;
+
+   rc = DosQuerySysInfo(14, 14, &milli, sizeof(milli));
+   if(rc) {
+        fprintf(stderr,"Bad return code querying the millisecond counter! rc=%d\n",rc);
+        return(0);
+        }
+   return(milli);
+}
+
+int os2_parse_select(sd,nfds)
+struct select_data *sd;
+int nfds;
+{
+   int i;
+   APIRET rc;
+/* First we determine up to which descriptor we need to check.              */
+/* No need to check up to 256 if we don't have to (and usually we dont...)*/
+/* Note: stuff here is hardcoded for fd_sets which are int[8] as in EMX!    */
+
+  if(nfds > sd->max_fds){
+     for(i=0;i<((FD_SETSIZE+31)/32);i++){
+        if(sd->read_copy.fds_bits[i] ||
+            sd->write_copy.fds_bits[i])
+                        sd->max_fds=(i*32) +32;
+        }
+     }
+   else { sd->max_fds = nfds; }
+/* Check if result is greater than specified in select() call */
+  if(sd->max_fds > nfds) sd->max_fds = nfds;
+
+  if (sd->have_read)
+    {
+      for (i = 0; i < sd->max_fds; ++i) {
+        if (FD_ISSET (i, &sd->read_copy)){
+         if(_files[i] & F_SOCKET)
+           {
+            sd->tcp_select_mask[sd->socket_ntotal]=_getsockhandle(i);
+            sd->tcp_emx_handles[sd->socket_ntotal]=i;
+            sd->socket_ntotal++; sd->socket_nread++;
+           }
+         else if (_files[i] & F_PIPE)
+          {
+            sd -> pipe_ntotal++;
+            /* rc = DosSetNPipeSem((HPIPE)i, (HSEM) hPipeSem, i);
+            if(rc) { fprintf(stderr,"Error SETNPIPE rc = %d\n",rc); return -1;} */
+          }
+        }
+      }
+    }
+
+  if (sd->have_write)
+    {
+      for (i = 0; i < sd->max_fds; ++i) {
+        if (FD_ISSET (i, &sd->write_copy)){
+         if(_files[i] & F_SOCKET)
+         {
+            sd->tcp_select_mask[sd->socket_ntotal]=_getsockhandle(i);
+            sd->tcp_emx_handles[sd->socket_ntotal]=i;
+            sd->socket_ntotal++; sd->socket_nwrite++;
+         }
+         else if (_files[i] & F_PIPE)
+          {
+            sd -> pipe_ntotal++;
+            /* rc = DosSetNPipeSem((HPIPE)i, (HSEM) hPipeSem, i);
+            if(rc) { fprintf(stderr,"Error SETNPIPE rc = %d\n",rc); return -1;} */
+            sd -> pipe_have_write=TRUE;
+          }
+        }
+      }
+    }
+
+
+return(sd->socket_ntotal);
+}
+
+
+int os2_check_sockets(sd,readfds,writefds)
+struct select_data *sd;
+fd_set *readfds,*writefds;
+{
+   int e,i;
+   int j,n;
+        memcpy(sd->tcp_select_copy,sd->tcp_select_mask,
+                sd->socket_ntotal*sizeof(int));
+ 
+        e = os2_tcp_select(sd->tcp_select_copy,sd->socket_nread,
+                sd->socket_nwrite, 0, 0);
+
+        if(e == 0) return(e);
+/* We have something ready? */
+        if(e>0){
+            j = 0; n = 0;
+            for (i = 0; i < sd->socket_nread; ++i, ++j)
+                 if (sd->tcp_select_copy[j] != -1)
+                    {
+                    FD_SET (sd->tcp_emx_handles[j], readfds);
+                    n ++;
+                    }
+             for (i = 0; i < sd->socket_nwrite; ++i, ++j)
+                  if (sd->tcp_select_copy[j] != -1)
+                     {
+                     FD_SET (sd->tcp_emx_handles[j], writefds);
+                     n ++;
+                     }
+               errno = 0;
+               
+               return n;
+              }
+        if(e<0){
+           /*Error -- TODO. EBADF is a good choice for now. */
+           fprintf(stderr,"Error in server select! e=%d\n",e);
+           errno = EBADF;
+           return (-1);
+           }
+ }
+
+/* Check to see if anything is ready on pipes */
+
+int os2_check_pipes(sd,readfds,writefds)
+struct select_data *sd;
+fd_set *readfds,*writefds;
+{
+int i,e;
+ULONG ulPostCount;
+PIPESEMSTATE pipeSemState[128];
+APIRET rc;
+        e = 0;
+        rc = DosResetEventSem(hPipeSem,&ulPostCount);
+        rc = DosQueryNPipeSemState((HSEM) hPipeSem, (PPIPESEMSTATE)&pipeSemState, 
+                sizeof(pipeSemState));
+        if(rc) fprintf(stderr,"SELECT: rc from QueryNPipeSem: %d\n",rc);
+        i=0;
+        while (pipeSemState[i].fStatus != 0) {
+           /*fprintf(stderr,"SELECT: sem entry, stat=%d, flag=%d, key=%d,avail=%d\n",
+                pipeSemState[i].fStatus,pipeSemState[i].fFlag,pipeSemState[i].usKey,
+                pipeSemState[i].usAvail);  */
+           if((pipeSemState[i].fStatus == 1) &&
+                    (FD_ISSET(pipeSemState[i].usKey,&sd->read_copy))){
+                FD_SET(pipeSemState[i].usKey,readfds);
+                e++;
+                }
+           else if((pipeSemState[i].fStatus == 2)  &&
+                    (FD_ISSET(pipeSemState[i].usKey,&sd->write_copy))){
+                FD_SET(pipeSemState[i].usKey,writefds);
+                e++;
+                }
+            else if( (pipeSemState[i].fStatus == 3) &&
+                ( (FD_ISSET(pipeSemState[i].usKey,&sd->read_copy)) ||
+                  (FD_ISSET(pipeSemState[i].usKey,&sd->write_copy)) )){
+                errno = EBADF;
+                /* fprintf(stderr,"Pipe has closed down, fd=%d\n",pipeSemState[i].usKey); */
+                return (-1);
+                }
+            i++;
+            } /* endwhile */
+        /*fprintf(stderr,"Done listing pipe sem entries, total %d entries, total ready entries %d\n",i,e);*/
+errno = 0;
+return(e);
+}
+
+#endif
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_video.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_video.c
new file mode 100644
index 000000000..c45b3165e
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/os2/os2_video.c
@@ -0,0 +1,241 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/os2/os2_video.c,v 3.15 2002/05/31 18:46:02 dawes Exp $ */
+/*
+ * (c) Copyright 1994,1999 by Holger Veit
+ *			<Holger.Veit@gmd.de>
+ * Modified 1996 by Sebastien Marineau <marineau@genie.uottawa.ca>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a 
+ * copy of this software and associated documentation files (the "Software"), 
+ * to deal in the Software without restriction, including without limitation 
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+ * and/or sell copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+ * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Holger Veit shall not be
+ * used in advertising or otherwise to promote the sale, use or other dealings
+ * in this Software without prior written authorization from Holger Veit.
+ *
+ */
+/* $XConsortium: os2_video.c /main/8 1996/10/27 11:49:02 kaleb $ */
+
+#define I_NEED_OS2_H
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "input.h"
+#include "scrnintstr.h"
+
+#define INCL_DOSFILEMGR
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+#include "xf86OSpriv.h"
+
+#include "compiler.h"
+
+/***************************************************************************/
+/* Video Memory Mapping helper functions                                   */
+/***************************************************************************/
+
+/* This section uses the xf86sup.sys driver developed for xfree86.
+ * The driver allows mapping of physical memory
+ * You must install it with a line DEVICE=path\xf86sup.sys in config.sys.
+ */
+
+#define LOWORD(X) ((X) & 0xffff)
+#define HIWORD(X) ((X) >> 16)
+
+static HFILE mapdev = -1;
+static ULONG stored_virt_addr;
+static char* mappath = "\\DEV\\PMAP$";
+static HFILE open_mmap() 
+{
+	APIRET rc;
+	ULONG action;
+
+	if (mapdev != -1)
+		return mapdev;
+
+	rc = DosOpen((PSZ)mappath, (PHFILE)&mapdev, (PULONG)&action,
+	   (ULONG)0, FILE_SYSTEM, FILE_OPEN,
+	   OPEN_SHARE_DENYNONE|OPEN_FLAGS_NOINHERIT|OPEN_ACCESS_READONLY,
+	   (ULONG)0);
+	if (rc!=0) {
+		mapdev = -1; }
+	else {
+		/* fg030203: ask for driver version of xf86sup.sys;
+		   no output prior to version 1.539 */
+                struct {
+                       	ULONG	magic;
+                       	ULONG	drvtype;
+                       	ULONG	version;
+                } drvid;
+		ULONG dlen = sizeof(drvid);
+		if ((rc=DosDevIOCtl(mapdev, (ULONG)0x76, (ULONG)0x61,
+			(PVOID)NULL, (ULONG)0, (PULONG)NULL,
+			(PVOID)&drvid, (ULONG)dlen, (PULONG)&dlen))==0) {
+		  xf86Msg(X_INFO,"PMAP$: driver version = %x.%x\n",
+		  	  HIWORD(drvid.version),
+		  	  LOWORD(drvid.version));
+		}
+	}
+	return mapdev;
+}
+
+static void close_mmap()
+{
+	if (mapdev != -1)
+		DosClose(mapdev);
+	mapdev = -1;
+}
+
+/* this structure is used as a parameter packet for the direct access
+ * ioctl of pmap$
+ */
+
+/* Changed here for structure of driver PMAP$ */
+
+typedef struct{
+	ULONG addr;
+	ULONG size;
+} DIOParPkt;
+
+/* This is the data packet for the mapping function */
+
+typedef struct {
+	ULONG addr;
+	USHORT sel;
+} DIODtaPkt;
+
+/***************************************************************************/
+/* Video Memory Mapping section                                            */
+/***************************************************************************/
+
+/* ARGSUSED */
+static pointer
+mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
+{
+	DIOParPkt	par;
+	ULONG		plen;
+	DIODtaPkt	dta;
+	ULONG		dlen;
+	static BOOL	ErrRedir = FALSE;
+	APIRET		rc;
+
+	par.addr	= (ULONG)Base;
+	par.size	= (ULONG)Size;
+	plen 		= sizeof(par);
+	dlen		= sizeof(dta);
+
+	open_mmap();
+	if (mapdev == -1)
+		FatalError("mapVidMem: install DEVICE=path\\XF86SUP.SYS!");
+
+	if ((rc=DosDevIOCtl(mapdev, (ULONG)0x76, (ULONG)0x44,
+	      (PVOID)&par, (ULONG)plen, (PULONG)&plen,
+	      (PVOID)&dta, (ULONG)dlen, (PULONG)&dlen)) == 0) {
+		xf86Msg(X_INFO,"mapVidMem succeeded: (ScreenNum=%d, Base=0x%x, Size=0x%x, vaddr=0x%x)\n",
+		ScreenNum, Base, Size, dta.addr);
+
+		if (dlen==sizeof(dta)) {
+			return (pointer)dta.addr;
+		}
+		/*else fail*/
+	}
+
+	/* fail */
+	FatalError("mapVidMem FAILED!!: rc = %d (ScreenNum=%d, Base=0x%x, Size=0x%x, return len=%d, vaddr=0x%x, sel=0x%x)\n",
+		rc, ScreenNum, Base, Size, dlen, dta.addr, dta.sel);
+	return (pointer)0;
+}
+
+/* ARGSUSED */
+static void
+unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
+{
+	DIOParPkt	par;
+	ULONG		plen,vmaddr;
+	APIRET		rc;
+/* We need here the VIRTADDR for unmapping, not the physical address      */
+/* This should be taken care of either here by keeping track of allocated */
+/* pointers, but this is also already done in the driver... Thus it would */
+/* be a waste to do this tracking twice. Can this be changed when the fn. */
+/* is called? This would require tracking this function in all servers,   */
+/* and changing it appropriately to call this with the virtual adress	  */
+/* If the above mapping function is only called once, then we can store   */
+/* the virtual adress and use it here.... 				  */
+	
+	par.addr	= (ULONG)Base;
+	par.size	= 0xffffffff; /* This is the virtual address parameter. Set this to ignore */
+	plen 		= sizeof(par);
+
+	if (mapdev != -1)
+	    rc = DosDevIOCtl(mapdev, (ULONG)0x76, (ULONG)0x45,
+	      (PVOID)&par, (ULONG)plen, (PULONG)&plen,
+	      &vmaddr, sizeof(ULONG), &plen);
+	if (!rc) {
+	    xf86Msg(X_INFO,"unmapVidMem: Unmap phys memory at virtual address 0x%x\n",
+        		vmaddr);
+        }
+        else {
+            xf86Msg(X_ERROR,"unmapVidMem: Unmap phys memory at base 0x%x, virtual address 0x%x, rc=%d\n",
+        		Base,vmaddr,rc);
+        }
+/* Now if more than one region has been allocated and we close the driver,
+ * the other pointers will immediately become invalid. We avoid closing
+ * driver for now, but this should be fixed for server exit
+ */
+ 
+	/* close_mmap(); */
+}
+
+/***************************************************************************/
+/* Interrupt Handling section                                              */
+/***************************************************************************/
+
+Bool xf86DisableInterrupts()
+{
+	/* allow interrupt disabling but check for side-effects. 
+	 * Not a good policy on OS/2...
+	 */
+        asm ("cli");
+	return TRUE;
+}
+
+void xf86EnableInterrupts()
+{
+	/*Reenable*/
+        asm ("sti");
+}
+
+/***************************************************************************/
+/* Initialize video memory                                                 */
+/***************************************************************************/
+
+void
+xf86OSInitVidMem(VidMemInfoPtr pVidMem)
+{
+        pVidMem->linearSupported = TRUE;
+        pVidMem->mapMem = mapVidMem;
+        pVidMem->unmapMem = unmapVidMem;
+#if 0
+        pVidMem->mapMemSparse = 0;
+        pVidMem->unmapMemSparse = 0;
+#endif
+        pVidMem->setWC = 0; /* no MTRR support */
+        pVidMem->undoWC = 0;
+        pVidMem->initialised = TRUE;
+}