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

10 files changed, 2287 insertions, 0 deletions

diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/Imakefile b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/Imakefile
new file mode 100644
index 000000000..35502389a
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/Imakefile
@@ -0,0 +1,56 @@
+XCOMM $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sco/Imakefile,v 3.15 2002/10/17 02:22:49 dawes Exp $
+
+
+
+
+XCOMM $XConsortium: Imakefile /main/4 1996/09/28 17:24:25 rws $
+
+#include <Server.tmpl>
+
+SRCS = sco_init.c sco_video.c sco_io.c sco_iop.c sco_mouse.c VTsw_sco.c \
+       std_kbdEv.c posix_tty.c bios_mmap.c vidmem.c \
+       libc_wrapper.c stdResource.c stdPci.c sigiostubs.c pm_noop.c \
+       kmod_noop.c agp_noop.c sco_kbd.c at_scancode.c sco_KbdMap.c
+
+OBJS = sco_init.o sco_video.o sco_io.o sco_iop.o sco_mouse.o VTsw_sco.o \
+       std_kbdEv.o posix_tty.o bios_mmap.o vidmem.o \
+       libc_wrapper.o stdResource.o stdPci.o sigiostubs.o pm_noop.o \
+       kmod_noop.o agp_noop.o sco_kbd.o at_scancode.o sco_KbdMap.o \
+       sco_event.o
+
+INCLUDES = -I$(XF86COMSRC) -I$(XF86OSSRC) -I. -I$(SERVERSRC)/include \
+           -I$(SERVERSRC)/mi -I$(XINCLUDESRC) -I$(EXTINCSRC)
+
+RESDEFINES = -DUSESTDRES
+
+DEFINES = $(RESDEFINES)
+
+SubdirLibraryRule($(OBJS))
+NormalLibraryObjectRule()
+
+XCOMM Hack for SCO platforms to get around a bug in GNU ld. The server needs
+XCOMM to link with -levent for the event driver interface. However, that is
+XCOMM a COFF-only library, and GCC/GNU ld only deal with ELF. Theoretically,
+XCOMM GNU ld will convert COFF to ELF on the fly, but it gets it wrong. The
+XCOMM SCO link editor gets it right. So we create an object here that the
+XCOMM server can link against.
+sco_event.o:
+	@ar x /usr/lib/libevent.a mouse.o
+	@/usr/ccs/bin/elf/ld -r -o sco_event.o mouse.o
+	@rm -f mouse.o
+
+LinkSourceFile(bios_mmap.c,../shared)
+LinkSourceFile(std_kbdEv.c,../shared)
+LinkSourceFile(at_scancode.c,../shared)
+LinkSourceFile(posix_tty.c,../shared)
+LinkSourceFile(libc_wrapper.c,../shared)
+LinkSourceFile(stdResource.c,../shared)
+LinkSourceFile(stdPci.c,../shared)
+LinkSourceFile(sigiostubs.c,../shared)
+LinkSourceFile(pm_noop.c,../shared)
+LinkSourceFile(kmod_noop.c,../shared)
+LinkSourceFile(agp_noop.c,../shared)
+LinkSourceFile(vidmem.c,../shared)
+
+DependTarget()
+
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/VTsw_sco.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/VTsw_sco.c
new file mode 100644
index 000000000..beb86ccad
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/VTsw_sco.c
@@ -0,0 +1,119 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sco/VTsw_sco.c,v 1.2 1998/07/25 16:56:57 dawes Exp $ */
+/*
+ * Copyright 1993 by David Wexelblat <dwex@goblin.org>
+ * Copyright 1993 by David McCullough <davidm@stallion.oz.au>
+ *
+ * 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: VTsw_sco.c /main/2 1995/11/13 06:08:36 kaleb $ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+/* For the event driver prototypes */
+#include <sys/event.h>
+#include <mouse.h>
+
+/*
+ * Handle the VT-switching interface for SCO
+ */
+
+/*
+ * This function is the signal handler for the VT-switching signal.  It
+ * is only referenced inside the OS-support layer. NOTE: we do NOT need
+ * to re-arm the signal here, since we used sigaction() to set the signal
+ * disposition in sco_init.c. If we had used signal(), we would need to
+ * re-arm the signal here. All we need to do now is record the fact that
+ * we got the signal. XFree86 handles the rest.
+ */
+void
+xf86VTRequest(int sig)
+{
+  xf86Info.vtRequestsPending = TRUE;
+  return;
+}
+
+Bool
+xf86VTSwitchPending(void)
+{
+  return(xf86Info.vtRequestsPending ? TRUE : FALSE);
+}
+
+/*
+ * When we switch away, we need to flush and suspend the event driver
+ * before the VT_RELDISP. We also need to get the current LED status
+ * and preserve it, so that we can restore it when we come back.
+ */
+static int sco_ledstatus = -1;
+static unsigned int sco_ledstate = 0;
+
+Bool
+xf86VTSwitchAway(void)
+{
+  ev_flush();
+  ev_suspend();
+
+  sco_ledstatus = ioctl(xf86Info.consoleFd, KDGETLED, &sco_ledstate);
+
+  xf86Info.vtRequestsPending = FALSE;
+  if (ioctl(xf86Info.consoleFd, VT_RELDISP, VT_TRUE) < 0) {
+    return(FALSE);
+  } else {
+    return(TRUE);
+  }
+}
+
+/*
+ * When we come back to the X server, we need to resume the event driver,
+ * and we need to restore the LED settings to what they were when we
+ * switched away.
+ */
+Bool
+xf86VTSwitchTo(void)
+{
+  ev_resume();
+
+  xf86Info.vtRequestsPending = FALSE;
+  if (ioctl(xf86Info.consoleFd, VT_RELDISP, VT_ACKACQ) < 0) {
+    return(FALSE);
+  } else {
+    if (sco_ledstatus >= 0) {
+      ioctl (xf86Info.consoleFd, KDSETLED, sco_ledstate);
+    }
+    sco_ledstatus = -1;
+
+    /*
+     * Convince the console driver this screen is in graphics mode,
+     * otherwise it assumes it can do more to the screen than it should.
+     */
+    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0) {
+        ErrorF("Failed to set graphics mode (%s)\n", strerror(errno));
+    }
+
+    return TRUE;
+  }
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_KbdMap.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_KbdMap.c
new file mode 100644
index 000000000..6a0e9de04
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_KbdMap.c
@@ -0,0 +1,304 @@
+/* $XFree86$ */
+/*
+ * Copyright 2005 by J. Kean Johnston <jkj@sco.com>
+ *
+ * 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 J. Kean Johnston not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  J. Kean Johnston makes no
+ * representations about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ * J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL J. KEAN JOHNSTON 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.
+ */
+
+/*
+ * Based on xf86KbdMap.c, which is
+ * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
+ * Copyright (c) 1992-2003 by The XFree86 Project, Inc.
+ */
+
+#include "X.h"
+#include "Xmd.h"
+#include "input.h"
+#include "scrnintstr.h"
+
+#include "compiler.h"
+
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+#include "xf86Xinput.h"
+#include "xf86OSKbd.h"
+#include "atKeynames.h"
+#include "xf86Keymap.h"
+
+#include "sco_kbd.h"
+
+#define KD_GET_ENTRY(i,n) \
+  eascii_to_x[((priv->keymap.key[i].spcl << (n+1)) & 0x100) + priv->keymap.key[i].map[n]]
+
+/*
+ * NOTE: Not all possible remappable symbols are remapped. There are two main
+ *       reasons:
+ *                 a) The mapping between scancode and SYSV/386 - symboltable
+ *                    is inconsistent between different versions and has some
+ *                    BIG mistakes.
+ *                 b) In X-Windows there is a difference between numpad-keys
+ *                    and normal keys. SYSV/386 uses for both kinds of keys
+ *                    the same symbol.
+ *
+ *       Thus only the alpha keypad and the function keys are translated.
+ *       Also CapsLock, NumLock, ScrollLock, Shift, Control & Alt.
+ */
+
+static unsigned char remap[128] = {
+     0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,   /* 0x00 - 0x07 */
+  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,   /* 0x08 - 0x0f */
+  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,   /* 0x10 - 0x17 */
+  0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,   /* 0x18 - 0x1f */
+  0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,   /* 0x20 - 0x27 */
+  0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,   /* 0x28 - 0x2f */
+  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,    0,   /* 0x30 - 0x37 */
+  0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,   /* 0x38 - 0x3f */
+  0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,    0,   /* 0x40 - 0x47 */
+     0,    0,    0,    0,    0,    0,    0,    0,   /* 0x48 - 0x4f */
+     0,    0,    0,    0,    0,    0, 0x56, 0x57,   /* 0x50 - 0x57 */
+  0x58,    0,    0,    0,    0,    0,    0,    0,   /* 0x58 - 0x5f */
+     0,    0,    0,    0,    0,    0,    0,    0,   /* 0x60 - 0x67 */
+     0,    0,    0,    0,    0,    0,    0,    0,   /* 0x68 - 0x6f */
+     0,    0, 0x69, 0x65,    0,    0,    0,    0,   /* 0x70 - 0x77 */
+     0,    0,    0,    0,    0,    0,    0,    0,   /* 0x78 - 0x7f */
+};
+
+static KeySym eascii_to_x[512] = {
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	XK_BackSpace,	XK_Tab,		XK_Linefeed,	NoSymbol,
+	NoSymbol,	XK_Return,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	XK_Escape,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	XK_space,	XK_exclam,	XK_quotedbl,	XK_numbersign,
+	XK_dollar,	XK_percent,	XK_ampersand,	XK_apostrophe,
+	XK_parenleft,	XK_parenright,	XK_asterisk,	XK_plus,
+	XK_comma,	XK_minus,	XK_period,	XK_slash,
+	XK_0,		XK_1,		XK_2,		XK_3,
+	XK_4,		XK_5,		XK_6,		XK_7,
+	XK_8,		XK_9,		XK_colon,	XK_semicolon,
+	XK_less,	XK_equal,	XK_greater,	XK_question,
+	XK_at,		XK_A,		XK_B,		XK_C,
+	XK_D,		XK_E,		XK_F,		XK_G,
+	XK_H,		XK_I,		XK_J,		XK_K,
+	XK_L,		XK_M,		XK_N,		XK_O,
+	XK_P,		XK_Q,		XK_R,		XK_S,
+	XK_T,		XK_U,		XK_V,		XK_W,
+	XK_X,		XK_Y,		XK_Z,		XK_bracketleft,
+	XK_backslash,	XK_bracketright,XK_asciicircum,	XK_underscore,
+	XK_grave,	XK_a,		XK_b,		XK_c,
+	XK_d,		XK_e,		XK_f,		XK_g,
+	XK_h,		XK_i,		XK_j,		XK_k,
+	XK_l,		XK_m,		XK_n,		XK_o,
+	XK_p,		XK_q,		XK_r,		XK_s,
+	XK_t,		XK_u,		XK_v,		XK_w,
+	XK_x,		XK_y,		XK_z,		XK_braceleft,
+	XK_bar,		XK_braceright,	XK_asciitilde,	XK_Delete,
+	XK_Ccedilla,	XK_udiaeresis,	XK_eacute,	XK_acircumflex,
+	XK_adiaeresis,	XK_agrave,	XK_aring,	XK_ccedilla,
+	XK_ecircumflex,	XK_ediaeresis,	XK_egrave,	XK_idiaeresis,
+	XK_icircumflex,	XK_igrave,	XK_Adiaeresis,	XK_Aring,
+	XK_Eacute,	XK_ae,		XK_AE,		XK_ocircumflex,
+	XK_odiaeresis,	XK_ograve,	XK_ucircumflex,	XK_ugrave,
+	XK_ydiaeresis,	XK_Odiaeresis,	XK_Udiaeresis,	XK_cent,
+	XK_sterling,	XK_yen,		XK_paragraph,	XK_section,
+	XK_aacute,	XK_iacute,	XK_oacute,	XK_uacute,
+	XK_ntilde,	XK_Ntilde,	XK_ordfeminine,	XK_masculine,
+	XK_questiondown,XK_hyphen,	XK_notsign,	XK_onehalf,
+	XK_onequarter,	XK_exclamdown,	XK_guillemotleft,XK_guillemotright,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	XK_Greek_alpha,	XK_ssharp,	XK_Greek_GAMMA,	XK_Greek_pi,
+	XK_Greek_SIGMA,	XK_Greek_sigma,	XK_mu,	        XK_Greek_tau,
+	XK_Greek_PHI,	XK_Greek_THETA,	XK_Greek_OMEGA,	XK_Greek_delta,
+	XK_infinity,	XK_Ooblique,	XK_Greek_epsilon, XK_intersection,
+	XK_identical,	XK_plusminus,	XK_greaterthanequal, XK_lessthanequal,
+	XK_topintegral,	XK_botintegral,	XK_division,	XK_similarequal,
+	XK_degree,	NoSymbol,	NoSymbol,	XK_radical,
+	XK_Greek_eta,	XK_twosuperior,	XK_periodcentered, NoSymbol,
+
+	/* 
+	 * special marked entries (256 + x)
+	 */
+
+	NoSymbol,	NoSymbol,	XK_Shift_L,	XK_Shift_R,
+	XK_Caps_Lock,	XK_Num_Lock,	XK_Scroll_Lock,	XK_Alt_L,
+	NoSymbol,	XK_Control_L,	XK_Alt_L,	XK_Alt_R,
+	XK_Control_L,	XK_Control_R,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	XK_F1,
+	XK_F2,		XK_F3,		XK_F4,		XK_F5,
+	XK_F6,		XK_F7,		XK_F8,		XK_F9,
+	XK_F10,		XK_F11,		XK_F12,		NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+	NoSymbol,	NoSymbol,	NoSymbol,	NoSymbol,
+      };
+
+/*
+ * KbdGetMapping --
+ *	Get the national keyboard mapping. The keyboard type is set, a new map
+ *      and the modifiermap is computed.
+ */
+
+void
+KbdGetMapping (InputInfoPtr pInfo, KeySymsPtr pKeySyms, CARD8 *pModMap)
+{
+  KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
+  ScoKbdPrivPtr priv = (ScoKbdPrivPtr) pKbd->private;
+  KeySym *k;
+  int i;
+  KeySym *pMap = map;
+
+  for (i = 0; i < priv->keymap.n_keys && i < NUM_KEYCODES; i++) {
+    if (remap[i]) {
+      k = pMap + (remap[i] << 2);
+	
+      k[0] = KD_GET_ENTRY(i,0);       /* non-shifed */
+      k[1] = KD_GET_ENTRY(i,1);	      /* shifted */
+      k[2] = KD_GET_ENTRY(i,4);	      /* alt */
+      k[3] = KD_GET_ENTRY(i,5);	      /* alt - shifted */
+
+      if (k[3] == k[2]) k[3] = NoSymbol;
+      if (k[2] == k[1]) k[2] = NoSymbol;
+      if (k[1] == k[0]) k[1] = NoSymbol;
+      if (k[0] == k[2] && k[1] == k[3]) k[2] = k[3] = NoSymbol;
+    }
+  }
+
+  /*
+   * compute the modifier map
+   */
+  for (i = 0; i < MAP_LENGTH; i++)
+    pModMap[i] = NoSymbol;  /* make sure it is restored */
+  
+  for (k = pMap, i = MIN_KEYCODE;
+       i < (NUM_KEYCODES + MIN_KEYCODE);
+       i++, k += GLYPHS_PER_KEY) {
+    
+    switch(*k) {
+    case XK_Shift_L:
+    case XK_Shift_R:
+      pModMap[i] = ShiftMask;
+      break;
+      
+    case XK_Control_L:
+    case XK_Control_R:
+      pModMap[i] = ControlMask;
+      break;
+      
+    case XK_Caps_Lock:
+      pModMap[i] = LockMask;
+      break;
+      
+    case XK_Alt_L:
+    case XK_Alt_R:
+      pModMap[i] = AltMask;
+      break;
+      
+    case XK_Num_Lock:
+      pModMap[i] = NumLockMask;
+      break;
+
+    case XK_Scroll_Lock:
+      pModMap[i] = ScrollLockMask;
+      break;
+
+      /* kana support */
+    case XK_Kana_Lock:
+    case XK_Kana_Shift:
+      pModMap[i] = KanaMask;
+      break;
+
+      /* alternate toggle for multinational support */
+    case XK_Mode_switch:
+      pModMap[i] = AltLangMask;
+      break;
+    }
+  }
+
+  pKeySyms->map        = pMap;
+  pKeySyms->mapWidth   = GLYPHS_PER_KEY;
+  pKeySyms->minKeyCode = MIN_KEYCODE;
+  pKeySyms->maxKeyCode = MAX_KEYCODE;
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_init.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_init.c
new file mode 100644
index 000000000..bc1f3b56d
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_init.c
@@ -0,0 +1,296 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sco/sco_init.c,v 3.13 2002/06/03 21:22:10 dawes Exp $ */
+/*
+ * Copyright 2001-2005 by J. Kean Johnston <jkj@sco.com>
+ *
+ * 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 J. Kean Johnston not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  J. Kean Johnston makes no
+ * representations about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ * J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL J. KEAN JOHNSTON 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$ */
+
+/* Re-written May 2001 to represent the current state of reality */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xmd.h>
+
+#include "compiler.h"
+
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+static Bool KeepTty = FALSE;
+static int VTnum = -1;
+static char vtdevice[48];
+static int sco_console_mode = -1;
+
+extern Bool mpxLock;
+
+void
+xf86OpenConsole(void)
+{
+  int i, ioctl_ret;
+  struct vt_mode VT;
+  struct vid_info vidinf;
+  struct sigaction sigvtsw;
+  char *ttn;
+
+  if (serverGeneration == 1) {
+    /* check if we're run with euid==0 */
+    if (geteuid() != 0) {
+      FatalError("xf86OpenConsole: Server must be setuid root\n");
+    }
+
+    /* If we are run in the background we will get SIGTTOU. Ignore it. */
+    OsSignal (SIGTTOU, SIG_IGN);
+
+    /*
+     * Set up the virtual terminal (multiscreen in SCO parlance).
+     * For the actual console itself, screens are numbered from
+     * 1 to (usually) 16. However, it is possible to have a nested
+     * server, and it is also possible to be on a multi-console
+     * system such as MaxSpeed or SunRiver. Therefore, we should
+     * not make any assumptions about the TTY name we are on, and
+     * instead we rely on ttyname() to give us the real TTY name.
+     * Previously, we tried to determine the TTY name manually.
+     * This is wrong. The only time we need to futz with the TTY name
+     * is if we were given the name of a TTY to run on explicity on
+     * the command line.
+     */
+
+    if (VTnum == -1) {
+      /*
+       * No device was specified. We need to query the kernel to see which
+       * console device we are on (and in fact if we are on a console at all).
+       */
+      ttn = ttyname (1);
+
+      if (ttn == (char *)0) {
+	FatalError ("xf86OpenConsole: Could not determine TTY name: %s\n",
+	  strerror(errno));
+      }
+      strlcpy (vtdevice, ttn, sizeof(vtdevice));
+    } else if (VTnum >= 0) {
+      snprintf (vtdevice, sizeof(vtdevice), "/dev/tty%02d", VTnum);
+    }
+
+    /*
+     * Now we can dispose of stdin/stdout
+     */
+    fclose (stdin);
+    fclose (stdout);
+
+    if ((xf86Info.consoleFd = open(vtdevice, O_RDWR | O_NDELAY, 0)) < 0) {
+      FatalError("xf86OpenConsole: Cannot open %s: %s\n", vtdevice,
+	strerror(errno));
+    }
+
+    /*
+     * We make 100% sure we use the correct VT number. This can get ugly
+     * where there are multi-consoles in use, so we make sure we query
+     * the kernel for the correct VT number. It knows best, we don't.
+     */
+    vidinf.size = sizeof(vidinf);
+    if (ioctl (xf86Info.consoleFd, CONS_GETINFO, &vidinf) < 0) {
+      FatalError ("xf86OpenConsole: %s not a console device "
+	"or error querying device: %s\n", vtdevice, strerror (errno));
+    }
+    xf86Info.vtno = vidinf.m_num;
+    VTnum = vidinf.m_num + 1; /* 0-based */
+
+    ErrorF("(using VT%02d device %s)\n\n", VTnum, vtdevice);
+
+    /* We activate the console just in case its not the one we are on */
+    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) {
+        ErrorF("xf86OpenConsole: VT_ACTIVATE failed (%s)\n", strerror(errno));
+    }
+
+    /* Disassociate from controling TTY */
+    if (!KeepTty) {
+      setpgrp();
+    }
+
+    /*
+     * Now we get the current mode that the console device is in. We will
+     * use this later when we close the console device to restore it to
+     * that same mode.
+     */
+    if ((sco_console_mode = ioctl(xf86Info.consoleFd, CONS_GET, 0L)) < 0) {
+      FatalError("xf86OpenConsole: CONS_GET failed on console (%s)\n",
+          strerror(errno));
+    }
+
+    if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0) {
+      FatalError("xf86OpenConsole: VT_GETMODE failed (%s)\n", strerror(errno));
+    }
+
+    sigvtsw.sa_handler = xf86VTRequest;
+    sigfillset(&sigvtsw.sa_mask);
+    sigvtsw.sa_flags = 0;
+
+    /* NOTE: Using sigaction means we dont have to re-arm the signal */
+    sigaction(SIGUSR1, &sigvtsw, NULL);
+
+    VT.mode = VT_PROCESS;
+    VT.relsig = SIGUSR1;
+    VT.acqsig = SIGUSR1;
+    VT.frsig = SIGINT;          /* Not implemented */
+    VT.waitv = 0;
+
+    /*
+     * The SCO X server tries the following call 5 times. Lets do the same
+     * thing. It shouldn't really be required but sometimes things take a
+     * while to settle down when switching screens. *helpless shrug* I know
+     * its sucks but ...
+     */
+
+    ioctl_ret = 0;
+    for (i = 0; i < 5; i++) {
+      ioctl_ret = ioctl(xf86Info.consoleFd, VT_SETMODE, &VT);
+      if (ioctl_ret >= 0)
+        break;
+      usleep(999999); /* Dont use nap() - it forces linking with -lx */
+    }
+
+    if (ioctl_ret < 0) {
+      FatalError("xf86OpenConsole: VT_SETMODE failed (%s)\n", strerror(errno));
+    }
+
+    /*
+     * Convince the console driver we are in graphics mode.
+     */
+    if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0) {
+        ErrorF("Failed to set graphics mode (%s)\n", strerror(errno));
+    }
+  } else { /* serverGeneration != 1 */
+    if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) {
+      ErrorF("xf86OpenConsole: VT_ACTIVATE failed (%s)\n", strerror(errno));
+    }
+  }
+}
+
+/*
+ * Restore the console to its previous state. This may cause flicker if
+ * the screen was previous in a graphics mode, because we first set it
+ * to text mode. This has the advantage of getting the console driver
+ * to do a soft reset on the card, which really does help settle the
+ * video card down again after coming out of Xfree86.
+ */
+void
+xf86CloseConsole(void)
+{
+  struct vt_mode VT;
+  struct sigaction sigvtsw;
+
+  /* Set text mode (possibly briefly) */
+  ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT0);
+
+  /* Restore the original mode */
+  if (sco_console_mode != -1) {
+      ioctl(xf86Info.consoleFd, MODESWITCH | sco_console_mode, 0L);
+  }
+
+  ioctl(xf86Info.consoleFd, VT_RELDISP, 1);     /* Release the display */
+
+  sigvtsw.sa_handler = SIG_DFL;
+  sigfillset(&sigvtsw.sa_mask);
+  sigvtsw.sa_flags = 0;
+
+  sigaction(SIGUSR1, &sigvtsw, NULL);
+
+  VT.mode = VT_AUTO;
+  VT.waitv = 0;
+  VT.relsig = SIGUSR1;
+  VT.acqsig = SIGUSR1;
+  VT.frsig  = SIGINT;
+  ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* Revert to auto handling */
+
+  close(xf86Info.consoleFd); /* We're done with the device */
+}
+
+int
+xf86ProcessArgument(int argc, char *argv[], int i)
+{
+  /*
+   * Keep server from detaching from controlling tty.  This is useful
+   * when debugging (so the server can receive keyboard signals).
+   */
+  if (!strcmp(argv[i], "-keeptty")) {
+    KeepTty = TRUE;
+    return(1);
+  }
+
+  /*
+   * By default, the X server wants to bind itself to CPU 0. This makes
+   * sure that the server has full access to the I/O ports at IOPL 3.
+   * Some SMP systems have trouble with I/O on CPU's other than 0. If,
+   * however, you have a system that is well behaved, you can specify
+   * this argument and let the scheduler decide which CPU the server
+   * should run on.
+   */
+  if (!strcmp(argv[i], "-nompxlock")) {
+    mpxLock = FALSE;
+    return (1);
+  }
+
+  /*
+   * Specify the VT number to run on (NOT the device).
+   */
+  if ((argv[i][0] == 'v') && (argv[i][1] == 't')) {
+    if (sscanf(argv[i], "vt%2d", &VTnum) == 0) {
+      UseMsg();
+      VTnum = -1;
+      return(0);
+    }
+    if (VTnum <= 0) {
+      UseMsg();
+      VTnum = -1;
+      return(0);
+    }
+    return(1);
+  }
+
+  /*
+   * Use a device the user specifies.
+   */
+  if (!strcmp(argv[i], "-crt")) {
+    if (++i > argc) {
+      UseMsg();
+      VTnum = -1;
+      return(0);
+    } else {
+      VTnum = -2;
+      strlcpy (vtdevice, argv[i], sizeof(vtdevice));
+      return(2);
+    }
+  }
+  return(0);
+}
+
+void
+xf86UseMsg(void)
+{
+	ErrorF("vtXX                   use the specified VT number\n");
+	ErrorF("-crt DEVICE            use the specified VT device\n");
+        ErrorF("-nompxlock             dont bind X server to CPU 0\n");
+	ErrorF("-keeptty               ");
+	ErrorF("don't detach controlling tty (for debugging only)\n");
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_io.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_io.c
new file mode 100644
index 000000000..c97916cf5
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_io.c
@@ -0,0 +1,269 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sco/sco_io.c,v 3.9 2002/10/11 01:40:36 dawes Exp $ */
+/*
+ * Copyright 2001 by J. Kean Johnston <jkj@sco.com>
+ *
+ * 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 J. Kean Johnston not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  J. Kean Johnston makes no
+ * representations about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ * J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL J. KEAN JOHNSTON 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$ */
+
+/* Re-written May 2001 to represent the current state of reality */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+
+#include "compiler.h"
+
+#define _NEED_SYSI86
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86OSpriv.h"
+#include "xf86_OSlib.h"
+
+#include <sys/param.h>
+#include <sys/emap.h>
+#include <sys/nmap.h>
+
+void
+xf86SoundKbdBell(int loudness, int pitch, int duration)
+{
+  if (loudness && pitch) {
+    ioctl(xf86Info.consoleFd, KIOCSOUND, 1193180 / pitch);
+    usleep(duration * loudness * 20);
+    ioctl(xf86Info.consoleFd, KIOCSOUND, 0);
+  }
+}
+
+void
+xf86SetKbdLeds(int leds)
+{
+  /*
+   * sleep the first time through under SCO.  There appears to be a
+   * timing problem in the driver which causes the keyboard to be lost.
+   * This usleep stops it from occurring. NOTE: this was in the old code.
+   * I am not convinced it is true any longer, but it doesn't hurt to
+   * leave this in here.
+   */
+  static int once = 1;
+
+  if (once) {
+    usleep(100);
+    once = 0;
+  }
+
+  ioctl(xf86Info.consoleFd, KDSETLED, leds );
+}
+
+int
+xf86GetKbdLeds(void)
+{
+  int leds;
+
+  ioctl (xf86Info.consoleFd, KDGETLED, &leds);
+  return leds;
+}
+
+/*
+ * Much of the code in this function is duplicated from the Linux code
+ * by Orest Zborowski <obz@Kodak.com> and David Dawes <dawes@xfree86.org>.
+ * Please see the file ../linux/lnx_io.c for full copyright information.
+ *
+ * NOTE: Only OpenServer Release 5.0.6 with Release Supplement 5.0.6A
+ * and later have the required ioctl. 5.0.6A or higher is HIGHLY
+ * recommended. The console driver is quite a different beast on that OS.
+ */
+void
+xf86SetKbdRepeat(char rad)
+{
+#if defined(KBIO_SETRATE)
+  int i;
+  int value = 0x7f;     /* Maximum delay with slowest rate */
+  int delay = 250;      /* Default delay */
+  int rate = 300;       /* Default repeat rate */
+
+  static int valid_rates[] = { 300, 267, 240, 218, 200, 185, 171, 160, 150,
+                               133, 120, 109, 100, 92, 86, 80, 75, 67,
+                               60, 55, 50, 46, 43, 40, 37, 33, 30, 27,
+                               25, 23, 21, 20 };
+#define RATE_COUNT (sizeof( valid_rates ) / sizeof( int ))
+
+  static int valid_delays[] = { 250, 500, 750, 1000 };
+#define DELAY_COUNT (sizeof( valid_delays ) / sizeof( int ))
+
+  if (xf86Info.kbdRate >= 0) 
+    rate = xf86Info.kbdRate * 10;
+  if (xf86Info.kbdDelay >= 0)
+    delay = xf86Info.kbdDelay;
+
+  for (i = 0; i < RATE_COUNT; i++)
+    if (rate >= valid_rates[i]) {
+      value &= 0x60;
+      value |= i;
+      break;
+    }
+
+  for (i = 0; i < DELAY_COUNT; i++)
+    if (delay <= valid_delays[i]) {
+      value &= 0x1f;
+      value |= i << 5;
+      break;
+    }
+
+  ioctl (xf86Info.consoleFd, KBIO_SETRATE, value);
+#endif /* defined(KBIO_SETRATE) */
+}
+
+static Bool use_tcs = TRUE, use_kd = TRUE;
+static Bool no_nmap = TRUE, no_emap = TRUE;
+static int orig_getsc, orig_kbm;
+static struct termios orig_termios;
+static keymap_t keymap, noledmap;
+static uchar_t *sc_mapbuf;
+static uchar_t *sc_mapbuf2;
+
+void
+xf86KbdInit(void)
+{
+  orig_getsc = 0;
+  if (ioctl (xf86Info.consoleFd, TCGETSC, &orig_getsc) < 0)
+    use_tcs = FALSE;
+  if (ioctl (xf86Info.consoleFd, KDGKBMODE, &orig_kbm) < 0)
+    use_kd = FALSE;
+
+  if (!use_tcs && !use_kd)
+    FatalError ("xf86KbdInit: Could not determine keyboard mode\n");
+
+  /*
+   * One day this should be fixed to translate normal ASCII characters
+   * back into scancodes or into events that XFree86 wants, but not
+   * now. For the time being, we only support scancode mode screens.
+  */
+  if (use_tcs && !(orig_getsc & KB_ISSCANCODE))
+    FatalError ("xf86KbdInit: Keyboard can not send scancodes\n");
+
+  /*
+   * We need to get the original keyboard map and NUL out the lock
+   * modifiers. This prevents the scancode API from messing with
+   * the keyboard LED's. We restore the original map when we exit.
+   */
+  if (ioctl (xf86Info.consoleFd, GIO_KEYMAP, &keymap) < 0) {
+    FatalError ("xf86KbdInit: Failed to get keyboard map (%s)\n",
+        strerror(errno));
+  }
+  if (ioctl (xf86Info.consoleFd, GIO_KEYMAP, &noledmap) < 0) {
+    FatalError ("xf86KbdInit: Failed to get keyboard map (%s)\n",
+        strerror(errno));
+  } else {
+    int i, j;
+
+    for (i = 0; i < noledmap.n_keys; i++) {
+      for (j = 0; j < NUM_STATES; j++) {
+        if (IS_SPECIAL(noledmap, i, j) &&
+            ((noledmap.key[i].map[j] == K_CLK) ||
+             (noledmap.key[i].map[j] == K_NLK) ||
+             (noledmap.key[i].map[j] == K_SLK))) {
+          noledmap.key[i].map[j] = K_NOP;
+        }
+      }
+    }
+  }
+
+  if (ioctl (xf86Info.consoleFd, XCGETA, &orig_termios) < 0) {
+    FatalError ("xf86KbdInit: Failed to get terminal modes (%s)\n",
+        strerror(errno));
+  }
+
+  sc_mapbuf = xalloc (10*BSIZE);
+  sc_mapbuf2 = xalloc(10*BSIZE);
+
+  /* Get the emap */
+  if (ioctl (xf86Info.consoleFd, LDGMAP, sc_mapbuf) < 0) {
+    if (errno != ENAVAIL) {
+      FatalError ("xf86KbdInit: Failed to retrieve e-map (%s)\n",
+          strerror (errno));
+    }
+    no_emap = FALSE;
+  }
+
+  /* Get the nmap */
+  if (ioctl (xf86Info.consoleFd, NMGMAP, sc_mapbuf2) < 0) {
+    if (errno != ENAVAIL) {
+      FatalError ("xf86KbdInit: Failed to retrieve n-map (%s)\n",
+          strerror (errno));
+    }
+    no_nmap = FALSE;
+  }
+}
+
+int
+xf86KbdOn(void)
+{
+  struct termios newtio;
+
+  ioctl (xf86Info.consoleFd, LDNMAP); /* Turn e-mapping off */
+  ioctl (xf86Info.consoleFd, NMNMAP); /* Turn n-mapping off */
+
+  newtio = orig_termios;        /* structure copy */
+  newtio.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
+  newtio.c_oflag = 0;
+  newtio.c_cflag = CREAD | CS8 | B9600;
+  newtio.c_lflag = 0;
+  newtio.c_cc[VTIME]=0;
+  newtio.c_cc[VMIN]=1;
+  cfsetispeed(&newtio, 9600);
+  cfsetospeed(&newtio, 9600);
+  ioctl(xf86Info.consoleFd, XCSETA, &newtio);
+
+  /* Now tell the keyboard driver to send us raw scancodes */
+  if (use_tcs) {
+    int nm = orig_getsc;
+    nm &= ~KB_XSCANCODE;
+    ioctl (xf86Info.consoleFd, TCSETSC, &nm);
+  }
+
+  if (use_kd)
+    ioctl (xf86Info.consoleFd, KDSKBMODE, K_RAW);
+
+  ioctl (xf86Info.consoleFd, PIO_KEYMAP, &noledmap);
+
+  return(xf86Info.consoleFd);
+}
+
+int
+xf86KbdOff(void)
+{
+  /* Revert back to original translate scancode mode */
+  if (use_tcs)
+    ioctl (xf86Info.consoleFd, TCSETSC, &orig_getsc);
+  if (use_kd)
+    ioctl (xf86Info.consoleFd, KDSKBMODE, orig_kbm);
+
+  ioctl (xf86Info.consoleFd, PIO_KEYMAP, &keymap);
+
+  if (no_emap)
+    ioctl (xf86Info.consoleFd, LDSMAP, sc_mapbuf);
+  if (no_nmap)
+    ioctl (xf86Info.consoleFd, NMSMAP, sc_mapbuf2);
+
+  ioctl(xf86Info.consoleFd, XCSETA, &orig_termios);
+
+  return(xf86Info.consoleFd);
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_iop.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_iop.c
new file mode 100644
index 000000000..35d48e04a
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_iop.c
@@ -0,0 +1,136 @@
+/* $XFree86$ */
+/*
+ * Copyright 2001 by J. Kean Johnston <jkj@caldera.com>
+ *
+ * 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 J. Kean Johnston not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  J. Kean Johnston makes no
+ * representations about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ * J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL J. KEAN JOHNSTON 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$ */
+
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+
+#include "compiler.h"
+
+#define _NEED_SYSI86
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86OSpriv.h"
+#include "xf86_OSlib.h"
+
+
+/***************************************************************************/
+/* I/O Permissions section                                                 */
+/***************************************************************************/
+
+/*
+ * There is a right way and a wrong way of doing this. Unfortunately, we
+ * are forced to do it the wrong way. The right way is to be told the range
+ * or ranges of I/O ports the driver(s) need access to, in order to use the
+ * CONS_IOPERM ioctl() to grant access only to those ports we care about.
+ * This way we can guarantee some small level of stability because a driver
+ * does not have access to all ports (which would mean it could play with
+ * the PIT and thus affect scheduling times, or a whole slew of other
+ * nasty things). However, because XFree86 currently only enables or disables
+ * ALL port access, we need to run at IOPL 3, which basically means the
+ * X Server runs at the same level as the kernel. You can image why this is
+ * unsafe. Oh, and this is not a problem unique to OSR5, other OSes are
+ * affected by this as well.
+ *
+ * So, for the time being, we change our IOPL until such time as the XFree86
+ * architecture is changed to allow for tighter control of I/O ports. If and
+ * when it is, then the CONS_ADDIOP/DELIOP ioctl() should be used to enable 
+ * or disable access to the desired ports.
+ */
+
+extern long sysi86 (int cmd, ...);
+
+static Bool IOEnabled = FALSE;
+
+Bool
+xf86EnableIO(void)
+{
+	if (IOEnabled)
+		return TRUE;
+
+	if (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) < 0) {
+		xf86Msg(X_WARNING,"Failed to set IOPL for extended I/O\n");
+		return FALSE;
+	}
+	
+	IOEnabled = TRUE;
+	return TRUE;
+}
+
+void
+xf86DisableIO(void)
+{
+	if (!IOEnabled)
+		return;
+
+	sysi86(SI86V86, V86SC_IOPL, 0);
+	IOEnabled = FALSE;
+}
+
+/***************************************************************************/
+/* Interrupt Handling section                                              */
+/***************************************************************************/
+
+Bool
+xf86DisableInterrupts(void)
+{
+  if (!IOEnabled) {
+    if (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) < 0)
+      return FALSE;
+  }
+
+#ifdef __GNUC__
+  __asm__ __volatile__("cli");
+#else 
+  asm("cli");
+#endif /* __GNUC__ */
+
+  if (!IOEnabled) {
+    sysi86(SI86V86, V86SC_IOPL, PS_IOPL);
+  }
+
+  return(TRUE);
+}
+
+void
+xf86EnableInterrupts(void)
+{
+  if (!IOEnabled) {
+    if (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) < 0)
+      return;
+  }
+
+#ifdef __GNUC__
+  __asm__ __volatile__("sti");
+#else 
+  asm("sti");
+#endif /* __GNUC__ */
+
+  if (!IOEnabled) {
+    sysi86(SI86V86, V86SC_IOPL, PS_IOPL);
+  }
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_kbd.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_kbd.c
new file mode 100644
index 000000000..a26b7e96b
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_kbd.c
@@ -0,0 +1,530 @@
+/* $XFree86$ */
+/*
+ * Copyright 2005 by J. Kean Johnston <jkj@sco.com>
+ *
+ * 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 J. Kean Johnston not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  J. Kean Johnston makes no
+ * representations about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ * J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL J. KEAN JOHNSTON 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$ */
+
+/*
+ * Based on sco_io.c which is
+ * (C) Copyright 2003 J. Kean Johnston <jkj@sco.com>
+ *
+ * Based on lnx_kbd.c which is 
+ * Copyright (c) 2002 by The XFree86 Project, Inc.
+ *
+ * Based on the code from lnx_io.c which is
+ * Copyright 1992 by Orest Zborowski <obz@Kodak.com>
+ * Copyright 1993 by David Dawes <dawes@xfree86.org>
+ */
+
+#define NEED_EVENTS
+#include "X.h"
+
+#include "compiler.h"
+
+#define _NEED_SYSI86
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86OSpriv.h"
+#include "xf86_OSlib.h"
+
+#include "xf86Xinput.h"
+#include "xf86OSKbd.h"
+#include "atKeynames.h"
+#include "sco_kbd.h"
+
+#include <sys/param.h>
+#include <sys/emap.h>
+#include <sys/nmap.h>
+
+static KbdProtocolRec protocols[] = {
+  { "standard", PROT_STD },
+  { NULL, PROT_UNKNOWN_KBD }
+};
+
+extern Bool VTSwitchEnabled;
+#ifdef USE_VT_SYSREQ
+extern Bool VTSysreqToggle;
+#endif
+
+static void
+SoundBell(InputInfoPtr pInfo, int loudness, int pitch, int duration)
+{
+  if (loudness && pitch) {
+    ioctl(pInfo->fd, KIOCSOUND, 1193180 / pitch);
+    usleep(duration * loudness * 20);
+    ioctl(pInfo->fd, KIOCSOUND, 0);
+  }
+}
+
+static void
+SetKbdLeds(InputInfoPtr pInfo, int leds)
+{
+  int real_leds = 0;
+  static int once = 1;
+
+  /*
+   * sleep the first time through under SCO.  There appears to be a
+   * timing problem in the driver which causes the keyboard to be lost.
+   * This usleep stops it from occurring. NOTE: this was in the old code.
+   * I am not convinced it is true any longer, but it doesn't hurt to
+   * leave this in here.
+   */
+  if (once) {
+    usleep(100);
+    once = 0;
+  }
+
+#ifdef LED_CAP
+  if (leds & XLED1)
+    real_leds |= LED_CAP;
+  if (leds & XLED2)
+    real_leds |= LED_NUM;
+  if (leds & XLED3)
+    real_leds |= LED_SCR;
+#ifdef LED_COMP
+  if (leds & XLED4)
+    real_leds |= LED_COMP;
+#else
+  if (leds & XLED4)
+    real_leds |= LED_SCR;
+#endif
+#endif
+  ioctl(pInfo->fd, KDSETLED, real_leds);
+}
+
+static int
+GetKbdLeds(InputInfoPtr pInfo)
+{
+    int real_leds, leds = 0;
+
+    ioctl(pInfo->fd, KDGETLED, &real_leds);
+
+    if (real_leds & LED_CAP) leds |= XLED1;
+    if (real_leds & LED_NUM) leds |= XLED2;
+    if (real_leds & LED_SCR) leds |= XLED3;
+
+    return(leds);
+}
+
+/*
+ * NOTE: Only OpenServer Release 5.0.6 with Release Supplement 5.0.6A
+ * and later have the required ioctl. 5.0.6A or higher is HIGHLY
+ * recommended. The console driver is quite a different beast on that OS.
+ */
+#undef rate
+
+static void
+SetKbdRepeat(InputInfoPtr pInfo, char rad)
+{
+#if defined(KBIO_SETRATE)
+  KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
+  int i;
+  int value = 0x7f;     /* Maximum delay with slowest rate */
+  int delay = 250;      /* Default delay */
+  int rate = 300;       /* Default repeat rate */
+
+  static int valid_rates[] = { 300, 267, 240, 218, 200, 185, 171, 160, 150,
+                               133, 120, 109, 100, 92, 86, 80, 75, 67,
+                               60, 55, 50, 46, 43, 40, 37, 33, 30, 27,
+                               25, 23, 21, 20 };
+#define RATE_COUNT (sizeof( valid_rates ) / sizeof( int ))
+
+  static int valid_delays[] = { 250, 500, 750, 1000 };
+#define DELAY_COUNT (sizeof( valid_delays ) / sizeof( int ))
+
+  if (pKbd->rate >= 0) 
+    rate = pKbd->rate * 10;
+  if (pKbd->delay >= 0)
+    delay = pKbd->delay;
+
+  for (i = 0; i < RATE_COUNT; i++)
+    if (rate >= valid_rates[i]) {
+      value &= 0x60;
+      value |= i;
+      break;
+    }
+
+  for (i = 0; i < DELAY_COUNT; i++)
+    if (delay <= valid_delays[i]) {
+      value &= 0x1f;
+      value |= i << 5;
+      break;
+    }
+
+  ioctl (pInfo->fd, KBIO_SETRATE, value);
+#endif /* defined(KBIO_SETRATE) */
+}
+
+static int
+KbdInit(InputInfoPtr pInfo, int what)
+{
+  KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
+  ScoKbdPrivPtr priv = (ScoKbdPrivPtr) pKbd->private;
+
+  if (pKbd->isConsole) {
+    priv->use_tcs = 1;
+    priv->use_kd = 1;
+    priv->no_nmap = 1;
+    priv->no_emap = 1;
+    priv->orig_getsc = 0;
+
+    if (ioctl (pInfo->fd, TCGETSC, &priv->orig_getsc) < 0)
+      priv->use_tcs = 0;
+    if (ioctl (pInfo->fd, KDGKBMODE, &priv->orig_kbm) < 0)
+      priv->use_kd = 0;
+
+    if (!priv->use_tcs && !priv->use_kd) {
+      xf86Msg (X_ERROR, "KbdInit: Could not determine keyboard mode\n");
+      return !Success;
+    }
+
+    /*
+     * One day this should be fixed to translate normal ASCII characters
+     * back into scancodes or into events that XFree86 wants, but not
+     * now. For the time being, we only support scancode mode screens.
+     */
+    if (priv->use_tcs && !(priv->orig_getsc & KB_ISSCANCODE)) {
+      xf86Msg (X_ERROR, "KbdInit: Keyboard can not send scancodes\n");
+      return !Success;
+    }
+
+    /*
+     * We need to get the original keyboard map and NUL out the lock
+     * modifiers. This prevents the scancode API from messing with
+     * the keyboard LED's. We restore the original map when we exit.
+     */
+    if (ioctl (pInfo->fd, GIO_KEYMAP, &priv->keymap) < 0) {
+      xf86Msg (X_ERROR, "KbdInit: Failed to get keyboard map (%s)\n",
+        strerror(errno));
+      return !Success;
+    }
+    if (ioctl (pInfo->fd, GIO_KEYMAP, &priv->noledmap) < 0) {
+      xf86Msg (X_ERROR, "KbdInit: Failed to get keyboard map (%s)\n",
+        strerror(errno));
+      return !Success;
+    } else {
+      int i, j;
+
+      for (i = 0; i < priv->noledmap.n_keys; i++) {
+        for (j = 0; j < NUM_STATES; j++) {
+          if (IS_SPECIAL(priv->noledmap, i, j) &&
+            ((priv->noledmap.key[i].map[j] == K_CLK) ||
+             (priv->noledmap.key[i].map[j] == K_NLK) ||
+             (priv->noledmap.key[i].map[j] == K_SLK))) {
+            priv->noledmap.key[i].map[j] = K_NOP;
+          }
+        }
+      }
+    }
+
+    if (ioctl (pInfo->fd, XCGETA, &priv->kbdtty) < 0) {
+      xf86Msg (X_ERROR, "KbdInit: Failed to get terminal modes (%s)\n",
+        strerror(errno));
+      return !Success;
+    }
+
+    priv->sc_mapbuf = xalloc (10*BSIZE);
+    priv->sc_mapbuf2 = xalloc(10*BSIZE);
+
+    /* Get the emap */
+    if (ioctl (pInfo->fd, LDGMAP, priv->sc_mapbuf) < 0) {
+      if (errno != ENAVAIL) {
+        xf86Msg (X_ERROR, "KbdInit: Failed to retrieve e-map (%s)\n",
+          strerror (errno));
+        return !Success;
+      }
+      priv->no_emap = 0;
+    }
+
+    /* Get the nmap */
+    if (ioctl (pInfo->fd, NMGMAP, priv->sc_mapbuf2) < 0) {
+      if (errno != ENAVAIL) {
+        xf86Msg (X_ERROR, "KbdInit: Failed to retrieve n-map (%s)\n",
+          strerror (errno));
+        return !Success;
+      }
+      priv->no_nmap = 0;
+    }
+  } /* End of if we are on a console */
+
+  return Success;
+}
+
+static int
+KbdOn(InputInfoPtr pInfo, int what)
+{
+  KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
+  ScoKbdPrivPtr priv = (ScoKbdPrivPtr) pKbd->private;
+  struct termios newtio;
+
+  if (pKbd->isConsole) {
+    ioctl (pInfo->fd, LDNMAP); /* Turn e-mapping off */
+    ioctl (pInfo->fd, NMNMAP); /* Turn n-mapping off */
+
+    newtio = priv->kbdtty;     /* structure copy */
+    newtio.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
+    newtio.c_oflag = 0;
+    newtio.c_cflag = CREAD | CS8 | B9600;
+    newtio.c_lflag = 0;
+    newtio.c_cc[VTIME]=0;
+    newtio.c_cc[VMIN]=1;
+    cfsetispeed(&newtio, 9600);
+    cfsetospeed(&newtio, 9600);
+    ioctl(pInfo->fd, XCSETA, &newtio);
+
+    /* Now tell the keyboard driver to send us raw scancodes */
+    if (priv->use_tcs) {
+      int nm = priv->orig_getsc;
+      nm &= ~KB_XSCANCODE;
+      ioctl (pInfo->fd, TCSETSC, &nm);
+    }
+
+    if (priv->use_kd)
+      ioctl (pInfo->fd, KDSKBMODE, K_RAW);
+
+    ioctl (pInfo->fd, PIO_KEYMAP, &priv->noledmap);
+  }
+
+  return Success;
+}
+
+static int
+KbdOff(InputInfoPtr pInfo, int what)
+{
+  KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
+  ScoKbdPrivPtr priv = (ScoKbdPrivPtr) pKbd->private;
+
+  if (pKbd->isConsole) {
+    /* Revert back to original translate scancode mode */
+    if (priv->use_tcs)
+      ioctl (pInfo->fd, TCSETSC, &priv->orig_getsc);
+    if (priv->use_kd)
+      ioctl (pInfo->fd, KDSKBMODE, priv->orig_kbm);
+
+    ioctl (pInfo->fd, PIO_KEYMAP, &priv->keymap);
+
+    if (priv->no_emap)
+      ioctl (pInfo->fd, LDSMAP, priv->sc_mapbuf);
+    if (priv->no_nmap)
+      ioctl (pInfo->fd, NMSMAP, priv->sc_mapbuf2);
+
+    ioctl(pInfo->fd, XCSETA, &priv->kbdtty);
+  }
+
+  return Success;
+}
+
+static int
+GetSpecialKey(InputInfoPtr pInfo, int scanCode)
+{
+  KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
+  int specialkey = scanCode;
+
+  if (pKbd->CustomKeycodes) {
+      specialkey = pKbd->specialMap->map[scanCode];
+  }
+  return specialkey;
+}
+
+#define ModifierSet(k) ((modifiers & (k)) == (k))
+
+static Bool
+SpecialKey(InputInfoPtr pInfo, int key, Bool down, int modifiers)
+{
+  KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
+
+  if(!pKbd->vtSwitchSupported)
+    return FALSE;
+
+  if ((!ModifierSet(ShiftMask)) && ((ModifierSet(ControlMask | AltMask)) ||
+      (ModifierSet(ControlMask | AltLangMask)))) {
+    if (VTSwitchEnabled && !xf86Info.vtSysreq) {
+      switch (key) {
+        case KEY_F1:
+        case KEY_F2:
+        case KEY_F3:
+        case KEY_F4:
+        case KEY_F5:
+        case KEY_F6:
+        case KEY_F7:
+        case KEY_F8:
+        case KEY_F9:
+        case KEY_F10:
+          if (down) {
+	    int sts = key - KEY_F1;
+	    if (sts != xf86Info.vtno) {
+	      ioctl(pInfo->fd, VT_ACTIVATE, sts);
+	    }
+            return TRUE;
+          }
+        case KEY_F11:
+        case KEY_F12:
+          if (down) {
+	    int sts = key - KEY_F11 + 10;
+	    if (sts != xf86Info.vtno) {
+	      ioctl(pInfo->fd, VT_ACTIVATE, sts);
+	    }
+            return TRUE;
+          }
+      }
+    }
+  }
+#ifdef USE_VT_SYSREQ
+  if (VTSwitchEnabled && xf86Info.vtSysreq) {
+    switch (key) {
+      case KEY_F1:
+      case KEY_F2:
+      case KEY_F3:
+      case KEY_F4:
+      case KEY_F5:
+      case KEY_F6:
+      case KEY_F7:
+      case KEY_F8:
+      case KEY_F9:
+      case KEY_F10:
+        if (VTSysreqToggle && down) {
+          ioctl(pInfo->fd, VT_ACTIVATE, key - KEY_F1);
+          VTSysreqToggle = FALSE;
+          return TRUE;
+        }
+        break;
+      case KEY_F11:
+      case KEY_F12:
+        if (VTSysreqToggle && down) {
+          ioctl(pInfo->fd, VT_ACTIVATE, key - KEY_F11 + 10);
+          VTSysreqToggle = FALSE;
+          return TRUE;
+        }
+        break;
+        /* Ignore these keys -- ie don't let them cancel an alt-sysreq */
+      case KEY_Alt:
+      case KEY_AltLang:
+        break;
+      case KEY_SysReqest:
+        if (!(ModifierSet(ShiftMask) || ModifierSet(ControlMask))) {
+          if ((ModifierSet(AltMask) || ModifierSet(AltLangMask)) && down)
+            VTSysreqToggle = TRUE;
+        }
+        break;
+      default:
+        /*
+         * We only land here when Alt-SysReq is followed by a
+         * non-switching key.
+         */
+        if (VTSysreqToggle)
+          VTSysreqToggle = FALSE;
+    }
+  }
+#endif /* USE_VT_SYSREQ */
+  return FALSE;
+} 
+
+static void
+stdReadInput(InputInfoPtr pInfo)
+{
+  KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
+  unsigned char rBuf[64];
+  int nBytes, i;
+
+  if ((nBytes = read( pInfo->fd, (char *)rBuf, sizeof(rBuf))) > 0) {
+    for (i = 0; i < nBytes; i++) {
+      pKbd->PostEvent(pInfo, rBuf[i] & 0x7f, rBuf[i] & 0x80 ? FALSE : TRUE);
+    }
+  }
+}
+
+static Bool
+OpenKeyboard(InputInfoPtr pInfo)
+{
+  KbdDevPtr pKbd = (KbdDevPtr) pInfo->private;
+  int i;
+  KbdProtocolId prot = PROT_UNKNOWN_KBD;
+  char *s;
+
+  s = xf86SetStrOption(pInfo->options, "Protocol", NULL);
+  for (i = 0; protocols[i].name; i++) {
+    if (xf86NameCmp(s, protocols[i].name) == 0) {
+      prot = protocols[i].id;
+      break;
+    }
+  }
+
+  switch (prot) {
+    case PROT_STD:
+      pInfo->read_input = stdReadInput;
+      break;
+    default:
+      xf86Msg(X_ERROR,"\"%s\" is not a valid keyboard protocol name\n", s);
+      xfree(s);
+      return FALSE;
+  }
+
+  xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, s);
+  xfree(s);
+
+  s = xf86SetStrOption(pInfo->options, "Device", NULL);
+  if (s == NULL) {
+    pInfo->fd = xf86Info.consoleFd;
+    pKbd->isConsole = TRUE;
+  } else {
+    pInfo->fd = open(s, O_RDONLY | O_NONBLOCK | O_EXCL);
+    if (pInfo->fd == -1) {
+      xf86Msg(X_ERROR, "%s: cannot open \"%s\"\n", pInfo->name, s);
+      xfree(s);
+      return FALSE;
+    }
+    pKbd->isConsole = FALSE;
+    xfree(s);
+  }
+
+  if (pKbd->isConsole)
+    pKbd->vtSwitchSupported = TRUE;
+
+  return TRUE;
+}
+
+Bool
+xf86OSKbdPreInit(InputInfoPtr pInfo)
+{
+  KbdDevPtr pKbd = pInfo->private;
+
+  pKbd->KbdInit           = KbdInit;
+  pKbd->KbdOn             = KbdOn;
+  pKbd->KbdOff            = KbdOff;
+  pKbd->Bell              = SoundBell;
+  pKbd->SetLeds           = SetKbdLeds;
+  pKbd->GetLeds           = GetKbdLeds;
+  pKbd->SetKbdRepeat      = SetKbdRepeat;
+  pKbd->KbdGetMapping     = KbdGetMapping;
+  pKbd->SpecialKey        = SpecialKey;
+  pKbd->GetSpecialKey     = GetSpecialKey;
+  pKbd->OpenKeyboard      = OpenKeyboard;
+  pKbd->RemapScanCode     = ATScancode;
+  pKbd->vtSwitchSupported = FALSE;
+
+  pKbd->private = xcalloc(sizeof(ScoKbdPrivRec), 1);
+  if (pKbd->private == NULL) {
+    xf86Msg(X_ERROR,"can't allocate keyboard OS private data\n");
+    return FALSE;
+  }
+
+  return TRUE;
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_kbd.h b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_kbd.h
new file mode 100644
index 000000000..a79cd7bb9
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_kbd.h
@@ -0,0 +1,20 @@
+/* $XFree86$ */
+#ifndef SCO_KBD_HDR
+#define SCO_KBD_HDR
+
+typedef struct {
+  int use_tcs;
+  int use_kd;
+  int no_nmap;
+  int no_emap;
+  int orig_getsc;
+  int orig_kbm;
+  struct termios kbdtty;
+  keymap_t keymap, noledmap;
+  uchar_t *sc_mapbuf;
+  uchar_t *sc_mapbuf2;
+} ScoKbdPrivRec, *ScoKbdPrivPtr;
+
+extern void KbdGetMapping(InputInfoPtr pInfo, KeySymsPtr pKeySyms,
+  CARD8 *pModMap);
+#endif /* SCO_KBD_HDR */
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_mouse.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_mouse.c
new file mode 100644
index 000000000..ea81c947d
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_mouse.c
@@ -0,0 +1,261 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sco/sco_mouse.c,v 3.12 2001/06/30 22:41:49 tsi Exp $ */
+/*
+ * Copyright 2001 by J. Kean Johnston <jkj@sco.com>
+ *
+ * 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 J. Kean Johnston not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  J. Kean Johnston makes no
+ * representations about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ * J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL J. KEAN JOHNSTON 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$ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "compiler.h"
+
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+#include "xf86Xinput.h"
+#include "xf86OSmouse.h"
+#include "mipointer.h"
+#include <sys/event.h>
+#include <mouse.h>
+
+static int
+SupportedInterfaces (void)
+{
+  return MSE_MISC;
+}
+
+static const char *internalNames[] = {
+  "OSMouse",
+  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 "OSMouse";
+}
+
+static const char *
+evtErrStr (int evterr)
+{
+  switch (evterr) {
+  case -1: return "error in config files";
+  case -2: return "no mouse devices to attach";
+  case -3: return "unable to open device";
+  case -4: return "unable to open event queue";
+  case -999: return "unable to initialize event driver";
+  default: return "unknown event driver error";
+  }
+}
+
+static int
+OsMouseProc (DeviceIntPtr pPointer, int what)
+{
+  InputInfoPtr pInfo;
+  MouseDevPtr pMse;
+  unsigned char map[9];
+  dmask_t dmask;
+  MessageType from = X_CONFIG;
+  int evi;
+
+  pInfo = pPointer->public.devicePrivate;
+  pMse = pInfo->private;
+  pMse->device = pPointer;
+
+  switch (what) {
+  case DEVICE_INIT: 
+    pPointer->public.on = FALSE;
+
+    dmask = D_ABS | D_REL | D_BUTTON;
+    if ((evi = ev_initf(xf86Info.consoleFd)) < 0) {
+      FatalError ("OsMouseProc: Event driver initialization failed (%s)\n",
+          evtErrStr(evi));
+    }
+    pInfo->fd = ev_open (&dmask);
+    if (pInfo->fd < 0) {
+      FatalError ("OsMouseProc: DEVICE_INIT failed (%s)\n", evtErrStr(pInfo->fd));
+    }
+
+    pMse->buttons = xf86SetIntOption (pInfo->options, "Buttons", 0);
+    if (pMse->buttons == 0) {
+      pMse->buttons = 8;
+      from = X_DEFAULT;
+    }
+    xf86Msg (from, "%s: Buttons: %d\n", pInfo->name, pMse->buttons);
+
+    for (evi = 0; evi <= 8; evi++)
+      map[evi] = evi;
+
+    InitPointerDeviceStruct((DevicePtr)pPointer, map, 8,
+        miPointerGetMotionEvents, pMse->Ctrl,
+        miPointerGetMotionBufferSize());
+
+    /* X valuator */
+    xf86InitValuatorAxisStruct(pPointer, 0, 0, -1, 1, 0, 1);
+    xf86InitValuatorDefaults(pPointer, 0);
+
+    /* Y valuator */
+    xf86InitValuatorAxisStruct(pPointer, 1, 0, -1, 1, 0, 1);
+    xf86InitValuatorDefaults(pPointer, 1);
+
+    xf86MotionHistoryAllocate(pInfo);
+
+    ev_flush();
+    ev_suspend();
+    break;
+
+  case DEVICE_ON:
+    pMse->lastButtons = 0;
+    pMse->lastMappedButtons = 0;
+    pMse->emulateState = 0;
+    pPointer->public.on = TRUE;
+    ev_resume();
+    AddEnabledDevice (pInfo->fd);
+    break;
+
+  case DEVICE_OFF:
+  case DEVICE_CLOSE:
+    pPointer->public.on = FALSE;
+    RemoveEnabledDevice (pInfo->fd);
+    if (what == DEVICE_CLOSE) {
+      ev_close();
+      pInfo->fd = -1;
+    } else {
+      ev_suspend();
+    }
+    break;
+  }
+
+  return Success;
+}
+
+static void
+OsMouseReadInput (InputInfoPtr pInfo)
+{
+  MouseDevPtr pMse;
+  EVENT *evp;
+
+  pMse = pInfo->private;
+
+  while ((evp = ev_read()) != (EVENT *)0) {
+    int buttons = EV_BUTTONS(*evp);
+    int dx = EV_DX(*evp), dy = -(EV_DY(*evp)), dz = 0;
+
+    if (buttons & WHEEL_FWD)
+      dz = -1;
+    else if (buttons & WHEEL_BACK)
+      dz = 1;
+
+    buttons &= ~(WHEEL_FWD | WHEEL_BACK);
+
+    pMse->PostEvent (pInfo, buttons, dx, dy, dz, 0);
+    ev_pop();
+  }
+}
+
+static Bool
+OsMousePreInit(InputInfoPtr pInfo, const char *protocol, int flags)
+{
+  MouseDevPtr pMse;
+
+  /* This is called when the protocol is "OSMouse". */
+
+  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);
+
+  /* Check if the device can be opened. */
+  pInfo->fd = ev_initf(xf86Info.consoleFd);
+  if (pInfo->fd != -1) {
+    dmask_t dmask = (D_ABS | D_REL | D_BUTTON);
+    pInfo->fd = ev_open(&dmask);
+  } else {
+    pInfo->fd = -999;
+  }
+
+  if (pInfo->fd < 0) {
+    if (xf86GetAllowMouseOpenFail())
+      xf86Msg(X_WARNING, "%s: cannot open event manager (%s)\n",
+          pInfo->name, evtErrStr(pInfo->fd));
+    else {
+      xf86Msg(X_ERROR, "%s: cannot open event manager (%s)\n",
+          pInfo->name, evtErrStr(pInfo->fd));
+      xfree(pMse);
+      return FALSE;
+    }
+  }
+  ev_close();
+  pInfo->fd = -1;
+
+  /* Process common mouse options (like Emulate3Buttons, etc). */
+  pMse->CommonOptions(pInfo);
+
+  /* Setup the local procs. */
+  pInfo->device_control = OsMouseProc;
+  pInfo->read_input = OsMouseReadInput;
+    
+  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                    = OsMousePreInit;
+
+  return p;
+}
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_video.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_video.c
new file mode 100644
index 000000000..dd81786bb
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sco/sco_video.c
@@ -0,0 +1,296 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sco/sco_video.c,v 3.8tsi Exp $ */
+/*
+ * Copyright 2001 by J. Kean Johnston <jkj@sco.com>
+ *
+ * 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 J. Kean Johnston not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  J. Kean Johnston makes no
+ * representations about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ * J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL J. KEAN JOHNSTON 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$ */
+
+/* Re-written May 2001 to represent the current state of reality */
+
+/*
+ * This file contains the completely re-written SCO OpenServer video
+ * routines for XFree86 4.x. Much of this is based on the SCO X server
+ * code (which is an X11R5 server) and will probably only work on
+ * OpenServer versions 5.0.5, 5.0.6 and later. Please send me (jkj@sco.com)
+ * email if you have any questions.
+ *
+ * Ideally, you should use OSR5.0.6A or later, with the updated console
+ * driver for 5.0.6A (its the default driver in 5.0.7 and later).
+ * However, if you are running on an older system, this code will detect
+ * that and adjust accordingly.
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <X11/X.h>
+#include "input.h"
+#include "scrnintstr.h"
+
+#define _NEED_SYSI86
+#include "xf86.h"
+#include "xf86Priv.h"
+#include "xf86OSpriv.h"
+#include "xf86_OSlib.h"
+
+#include <sys/ci/ciioctl.h>
+#define MPXNAME "/dev/atp1"
+#define BASECPU 1
+
+Bool mpxLock = TRUE;
+
+#define USE_VASMETHOD	1
+
+/***************************************************************************/
+/* Video Memory Mapping section                                            */
+/***************************************************************************/
+
+static int sco_mcdone = 0, sco_ismc = 0;
+
+/***************************************************************************/
+/*
+ * To map the video memory, we first need to see if we are on a multi-console
+ * system. If we are, we need to try to use an existing video class in the
+ * kernel. We do this by retrieving the list of currently defined classes
+ * (via the new CONS_GETCLASS ioctl()) to see if we have a class that will
+ * match the range of memory we desire. If we can't find one, we have an
+ * error and we abort.
+ *
+ * If we are not using a multi-console, we can simply use mmap() to map in
+ * the frame buffer, using the classs-access method as a fall-back only if
+ * the mmap() fails (it shouldn't). We always set the appropriate pointers
+ * in the config structure to point ot the right function to map and unmap
+ * the video memory. An alternative to using mmap() is to use the new
+ * CONS_ADDVAS call, which will use vasmalloc() and vasbind() in the kernel
+ * to map the physical address to a virtual one, which it then returns.
+ * I am not 100% sure if this is faster or not, but it may prove easier to
+ * debug things. Just to be on the safe side, I have included both methods
+ * here, and the mmap() method can be used by setting USE_VASMETHOD to 0
+ * above.
+ */
+
+#if !defined(CONS_ADDVAS)
+# undef USE_VASMETHOD
+# define USE_VASMETHOD 0
+#endif
+
+static int
+scoIsMultiConsole (void)
+{
+	int x;
+
+	if (sco_mcdone)
+		return sco_ismc;
+	x = access ("/usr/lib/vidconf/.multiconsole", F_OK);
+	if (x == 0)
+		sco_ismc = 1;
+	sco_mcdone = 1;
+	return sco_ismc;
+}
+
+/*
+ * This maps memory using mmap()
+ */
+static pointer
+mapVidMemMMAP(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
+{
+  int fd;
+  unsigned long realBase, alignOff;
+  pointer base;
+
+  fd = open (DEV_MEM, (flags & VIDMEM_READONLY) ? O_RDONLY : O_RDWR);
+  if (fd < 0) {
+    FatalError("xf86MapVidMem: failed to open %s (%s)\n", DEV_MEM,
+       	strerror(errno));
+    return 0; /* NOTREACHED */
+  }
+
+  realBase = Base & ~(getpagesize() - 1);
+  alignOff = Base - realBase;
+
+#ifdef DEBUG
+  ErrorF("base: %lx, realBase: %lx, alignOff: %lx\n", Base,realBase,alignOff);
+#endif
+
+  base = mmap((caddr_t)0, Size + alignOff,
+	      (flags & VIDMEM_READONLY) ? PROT_READ : (PROT_READ | PROT_WRITE),
+  	      MAP_SHARED, fd, (off_t)realBase);
+  close(fd);
+  if (base == MAP_FAILED) {
+    FatalError("xf86MapVidMem: Could not mmap framebuffer (0x%08x,0x%x) (%s)\n",
+       	Base, Size, strerror(errno));
+    return 0; /* NOTREACHED */
+  }
+
+#ifdef DEBUG
+    ErrorF("base: %lx aligned base: %lx\n",base, base + alignOff);
+#endif
+    return (pointer)((char *)base + alignOff);
+}
+
+#if (USE_VASMETHOD)
+/*
+ * This maps memory using the virtual address space (VAS) console calls.
+ */
+static pointer
+mapVidMemVAS(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
+{
+  struct vidvasmem vas;
+  pointer base;
+
+  vas.base = (long)Base;
+  vas.size = (long)Size;
+
+  base = (pointer)ioctl (xf86Info.consoleFd, CONS_ADDVAS, &vas);
+  if (base == (pointer)-1) {
+    return mapVidMemMMAP(ScreenNum, Base, Size, flags);
+  }
+  return base;
+}
+#endif /* USE_VASMETHOD */
+
+struct vidclass vidclasslist[] = {
+	{ "VBE", "", 0xf0000000, 0x2000000, 0 },
+	{ "P9000", "", 0xc0000000, 0x400000, 0 },
+	{ "TULIP", "", 0x80000000, 0x400000, 0 },
+	{ "VIPER", "", 0xa0000000, 0x400000, 0 },
+	{ "S3T", "", 0xa0000000, 0x200000, 0 },
+	{ "S3DT", "", 0x4000000, 0x400000, 0 },
+	{ "MGA", "", 0x2200000, 0x4000, 0 },
+	{ "CLVGA", "", 0xa0000, 0x20000, 0 },
+	{ "OLIVE", "", 0xd8000000, 0x400000, 0 },
+	{ "S3C", "", 0xa0000, 0x10000, 0 },
+	{ "MGAVLB", "", 0xac000, 0x34000, 0 },
+	{ "ATI8514", "", 0xFF000, 0x1000, 0 },
+	{ "GXREGS", "", 0xb0000, 0x10000, 0 },
+	{ "GX", "", 0xa0000, 0x10000, 0 },
+	{ "CT64300", "", 0xa0000000, 0x400000, 0 },
+	{ "SVGA", "", 0xa0000, 0x20000, 0 },
+	{ "S3V", "", 0xa0000000, 0x400000, 0 },
+	{ "8514A", "", 0xFF000, 0x1000, 0 },
+	{ "VGA", "", 0xa0000, 0x10000, 0 },
+	{ 0 }
+};
+
+static pointer
+mapVidMemVC(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
+{
+  struct vidclass *vcp;
+  char *class = NULL;
+  pointer base;
+
+  for (vcp = vidclasslist; vcp->name; vcp++) {
+    if ((vcp->base == Base) && (vcp->size == Size)) {
+      class = vcp->name;
+      break;
+    }
+  }
+
+  if (class == NULL) {
+    /*
+     * As a fall-back, we will try and use the mmap() approach. This may
+     * prove to be the wrong thing to do, but time and testing will tell.
+     */
+    ErrorF("xf86MapVidMem: No class map defined for (0x%08x,0x%08x)\n", Base, Size);
+#if USE_VASMETHOD
+    return mapVidMemVAS(ScreenNum, Base, Size, flags);
+#else /* !USE_VASMETHOD */
+    return mapVidMemMMAP(ScreenNum, Base, Size, flags);
+#endif
+  }
+
+  /*
+   * We found a suitable class. Try and use it.
+   */
+  base = (pointer)ioctl(xf86Info.consoleFd, MAP_CLASS, class);
+  if ((int)base == -1) {
+    FatalError("xf86MapVidMem: Failed to map video memory class `%s'\n", class);
+    return 0; /* NOTREACHED */
+  }
+
+  return base;
+}
+
+/*
+ * Unmapping the video memory is easy. We always call munmap(), as it is
+ * safe to do so even if we haven't actually mapped in any pages via mmap().
+ * In the case where we used the video class, we don't need to do anything
+ * as the kernel will clean up the TSS when we exit, and will undo the
+ * vasbind() that was done when the class was originally mapped. If we used
+ * vasmap, we simply undo the map. Again, it is benign to call vasunmap
+ * even if we got the frame buffer via some other mechanism (like mmap).
+ */
+
+static void
+unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
+{
+#if USE_VASMETHOD
+  struct vidvasmem vas;
+  int x;
+
+  vas.base = (long)Base;
+  vas.size = (long)Size;
+
+  x = ioctl (xf86Info.consoleFd, CONS_DELVAS, &vas);
+  if (x == 0)
+    return;
+#endif /* USE_VASMETHOD */
+
+  munmap(Base, Size);
+}
+
+/*
+ * Set things up to point to our local functions. When the kernel gets
+ * MTRR support, we will need to add the required functions for that
+ * here too. MTRR support will most likely appear in 5.0.8 or 5.1.0.
+ *
+ * We also want to lock the X server process to the base CPU in an MPX
+ * system, since we will be going to IOPL 3. Most engine drivers can cope
+ * with I/O access on any CPU but there are a few (AST Manhattan I believe)
+ * that can't, so the server needs to be locked to CPU0.
+ */
+void
+xf86OSInitVidMem(VidMemInfoPtr pVidMem)
+{
+  int mpx_fd;
+
+  if (scoIsMultiConsole ()) {
+    pVidMem->mapMem = mapVidMemVC;
+  } else {
+#if USE_VASMETHOD
+    pVidMem->mapMem = mapVidMemVAS;
+#else
+    pVidMem->mapMem = mapVidMemMMAP;
+#endif
+  }
+
+  pVidMem->unmapMem = unmapVidMem;
+  pVidMem->linearSupported = TRUE;
+  pVidMem->initialised = TRUE;
+
+  if (mpxLock && (mpx_fd = open (MPXNAME, O_RDONLY)) > 0) {
+    if (ioctl (mpx_fd, ACPU_XLOCK, BASECPU) < 0)
+      ErrorF ("xf86OSInitVidMem: Can not bind to CPU 0 (%s)\n",
+          strerror(errno));
+    close (mpx_fd);
+  }
+}
+