From 5390c7ab05d23f64e6d9afaa558be246a6d6e1b4 Mon Sep 17 00:00:00 2001 From: Kean Johnson Date: Tue, 8 Nov 2005 06:33:30 +0000 Subject: See ChangeLog entry 2005-11-07 for details. --- Xext/xf86bigfont.c | 2 +- Xprint/attributes.c | 4 +- hw/xfree86/common/compiler.h | 18 +- hw/xfree86/common/scoasm.h | 4 +- hw/xfree86/common/xf86Config.c | 16 +- hw/xfree86/common/xf86Configure.c | 23 +- hw/xfree86/common/xf86Events.c | 18 +- hw/xfree86/common/xf86Init.c | 4 +- hw/xfree86/loader/loader.c | 20 ++ hw/xfree86/loader/os.c | 4 +- hw/xfree86/os-support/sco/VTsw_sco.c | 6 +- hw/xfree86/os-support/sco/sco_KbdMap.c | 304 ++++++++++++++++++ hw/xfree86/os-support/sco/sco_init.c | 100 ++---- hw/xfree86/os-support/sco/sco_io.c | 16 +- hw/xfree86/os-support/sco/sco_iop.c | 12 +- hw/xfree86/os-support/sco/sco_kbd.c | 530 +++++++++++++++++++++++++++++++ hw/xfree86/os-support/sco/sco_kbd.h | 20 ++ hw/xfree86/os-support/sco/sco_mouse.c | 28 +- hw/xfree86/os-support/shared/sysv_kbd.c | 2 +- hw/xfree86/os-support/usl/usl_KbdMap.c | 304 ++++++++++++++++++ hw/xfree86/os-support/usl/usl_init.c | 359 +++++++++++++++++++++ hw/xfree86/os-support/usl/usl_io.c | 172 ++++++++++ hw/xfree86/os-support/usl/usl_iop.c | 108 +++++++ hw/xfree86/os-support/usl/usl_kbd.c | 456 ++++++++++++++++++++++++++ hw/xfree86/os-support/usl/usl_kbd.h | 14 + hw/xfree86/os-support/usl/usl_mouse.c | 187 +++++++++++ hw/xfree86/os-support/usl/usl_video.c | 111 +++++++ hw/xfree86/os-support/usl/usl_vtsw.c | 97 ++++++ hw/xfree86/os-support/usl/usl_xqueue.c | 363 +++++++++++++++++++++ hw/xfree86/os-support/usl/usl_xqueue.h | 9 + hw/xfree86/os-support/xf86_OSlib.h | 18 +- hw/xfree86/os-support/xf86_OSproc.h | 4 + hw/xfree86/os-support/xf86_ansic.h | 3 +- hw/xfree86/parser/Monitor.c | 6 +- hw/xfree86/utils/xorgcfg/cards.c | 3 + hw/xfree86/utils/xorgcfg/interface.c | 8 +- hw/xfree86/utils/xorgcfg/keyboard-cfg.c | 14 +- hw/xfree86/utils/xorgcfg/mouse-cfg.c | 5 +- hw/xfree86/utils/xorgcfg/text-mode.c | 37 ++- hw/xfree86/utils/xorgconfig/xorgconfig.c | 9 + hw/xfree86/vbe/vbe.h | 3 +- include/os.h | 2 +- os/access.c | 11 +- os/osinit.c | 4 +- os/utils.c | 50 +++ 45 files changed, 3310 insertions(+), 178 deletions(-) create mode 100644 hw/xfree86/os-support/sco/sco_KbdMap.c create mode 100644 hw/xfree86/os-support/sco/sco_kbd.c create mode 100644 hw/xfree86/os-support/sco/sco_kbd.h create mode 100644 hw/xfree86/os-support/usl/usl_KbdMap.c create mode 100644 hw/xfree86/os-support/usl/usl_init.c create mode 100644 hw/xfree86/os-support/usl/usl_io.c create mode 100644 hw/xfree86/os-support/usl/usl_iop.c create mode 100644 hw/xfree86/os-support/usl/usl_kbd.c create mode 100644 hw/xfree86/os-support/usl/usl_kbd.h create mode 100644 hw/xfree86/os-support/usl/usl_mouse.c create mode 100644 hw/xfree86/os-support/usl/usl_video.c create mode 100644 hw/xfree86/os-support/usl/usl_vtsw.c create mode 100644 hw/xfree86/os-support/usl/usl_xqueue.c create mode 100644 hw/xfree86/os-support/usl/usl_xqueue.h diff --git a/Xext/xf86bigfont.c b/Xext/xf86bigfont.c index f9cedca4b..36af17622 100644 --- a/Xext/xf86bigfont.c +++ b/Xext/xf86bigfont.c @@ -51,7 +51,7 @@ #ifdef SVR4 #include #endif -#if defined(ISC) || defined(__CYGWIN__) || defined(SCO) || defined(SCO325) +#if defined(ISC) || defined(__CYGWIN__) || defined(__SCO__) #include #include #endif diff --git a/Xprint/attributes.c b/Xprint/attributes.c index 2cb082ce3..60f6803a3 100644 --- a/Xprint/attributes.c +++ b/Xprint/attributes.c @@ -61,7 +61,7 @@ copyright holders. #include #include -#if (defined(sun) && defined(SVR4)) || (defined(SCO)) +#if (defined(sun) && defined(SVR4)) || defined(__SCO__) || defined(__UNIXWARE__) #include #endif #include "scrnintstr.h" @@ -1377,7 +1377,7 @@ ReplaceAllKeywords( defined(linux) || \ defined(__CYGWIN__) || \ (defined(sun) && !defined(SVR4)) || \ - (defined(SVR4) && !defined(sun) && !defined(USL)) || \ + (defined(SVR4) && !defined(sun) && !defined(__UNIXWARE__)) || \ defined(__UNIXOS2__) || \ defined(ISC) || \ defined(Lynx) || \ diff --git a/hw/xfree86/common/compiler.h b/hw/xfree86/common/compiler.h index f7df9b649..d323f677b 100644 --- a/hw/xfree86/common/compiler.h +++ b/hw/xfree86/common/compiler.h @@ -1604,18 +1604,8 @@ extern void outl(unsigned int a, unsigned int l); # define asm __asm # endif # endif -# ifdef SVR4 -#if 0 -# include -#endif -# ifndef __HIGHC__ -# if !defined(__USLC__) && !defined(__SUNPRO_C) -# define __USLC__ -# endif -# endif -# endif # ifndef SCO325 -# if defined(USL) +# if defined(__UNIXWARE__) # if defined(IN_MODULE) # /* avoid including for on UnixWare */ # define ushort unsigned short @@ -1627,15 +1617,15 @@ extern void outl(unsigned int a, unsigned int l); # else # include # endif /* IN_MODULE */ -# endif /* USL */ +# endif /* __UNIXWARE__ */ # if !defined(sgi) && !defined(__SUNPRO_C) # include # endif # else # include "scoasm.h" # endif -# if !defined(__HIGHC__) && !defined(SCO325) && !defined(sgi) && \ - !defined(__SUNPRO_C) +# if (!defined(__HIGHC__) && !defined(sgi) && !defined(__SUNPRO_C)) || \ + defined(__USLC__) # pragma asm partial_optimization outl # pragma asm partial_optimization outw # pragma asm partial_optimization outb diff --git a/hw/xfree86/common/scoasm.h b/hw/xfree86/common/scoasm.h index a8baea6c2..5a5af8eb9 100644 --- a/hw/xfree86/common/scoasm.h +++ b/hw/xfree86/common/scoasm.h @@ -35,7 +35,7 @@ #include #endif -#ifdef SCO325 +#if defined(__SCO__) && defined(__USLC__) #ifndef _SCOASM_HDR_INC #define _SCOASM_HDR_INC @@ -140,4 +140,4 @@ asm int inb(port) } #endif /* _SCOASM_HDR_INC */ -#endif /* SCO325 */ +#endif /* __SCO__ && __USLC__ */ diff --git a/hw/xfree86/common/xf86Config.c b/hw/xfree86/common/xf86Config.c index 75003741c..4e5f6dd4a 100644 --- a/hw/xfree86/common/xf86Config.c +++ b/hw/xfree86/common/xf86Config.c @@ -1106,6 +1106,11 @@ configInputKbd(IDevPtr inputp) MessageType from = X_DEFAULT; Bool customKeycodesDefault = FALSE; int verb = 0; +#if defined(XQUEUE) + char *kbdproto = "Xqueue"; +#else + char *kbdproto = "standard"; +#endif /* Initialize defaults */ xf86Info.xleds = 0L; @@ -1146,16 +1151,25 @@ configInputKbd(IDevPtr inputp) xf86Info.xkbgeometry = NULL; #endif - s = xf86SetStrOption(inputp->commonOptions, "Protocol", "standard"); + s = xf86SetStrOption(inputp->commonOptions, "Protocol", kbdproto); if (xf86NameCmp(s, "standard") == 0) { xf86Info.kbdProc = xf86KbdProc; xf86Info.kbdEvents = xf86KbdEvents; xfree(s); } else if (xf86NameCmp(s, "xqueue") == 0) { +#ifdef __UNIXWARE__ + /* + * To retain compatibility with older config files, on UnixWare, we + * accept the xqueue protocol but use the normal keyboard procs. + */ + xf86Info.kbdProc = xf86KbdProc; + xf86Info.kbdEvents = xf86KbdEvents; +#else #ifdef XQUEUE xf86Info.kbdProc = xf86XqueKbdProc; xf86Info.kbdEvents = xf86XqueEvents; xf86Msg(X_CONFIG, "Xqueue selected for keyboard input\n"); +#endif #endif xfree(s); #ifdef WSCONS_SUPPORT diff --git a/hw/xfree86/common/xf86Configure.c b/hw/xfree86/common/xf86Configure.c index 0f7a334ea..29b693493 100644 --- a/hw/xfree86/common/xf86Configure.c +++ b/hw/xfree86/common/xf86Configure.c @@ -76,8 +76,11 @@ Bool foundMouse = FALSE; #if defined(__UNIXOS2__) #define DFLT_MOUSE_DEV "mouse$" #define DFLT_MOUSE_PROTO "OS2Mouse" -#elif defined(SCO) +#elif defined(__SCO__) static char *DFLT_MOUSE_PROTO = "OSMouse"; +#elif defined(__UNIXWARE__) +static char *DFLT_MOUSE_PROTO = "Xqueue"; +static char *DFLT_MOUSE_DEV = "/dev/mouse"; #elif defined(QNX4) static char *DFLT_MOUSE_PROTO = "OSMouse"; static char *DFLT_MOUSE_DEV = "/dev/mouse"; @@ -294,7 +297,7 @@ configureInputSection (void) } #endif -#ifndef SCO +#ifndef __SCO__ fd = open(DFLT_MOUSE_DEV, 0); if (fd != -1) { foundMouse = TRUE; @@ -311,12 +314,14 @@ configureInputSection (void) mouse->inp_driver = "mouse"; mouse->inp_option_lst = xf86addNewOption(mouse->inp_option_lst, "Protocol", DFLT_MOUSE_PROTO); -#ifndef SCO +#ifndef __SCO__ mouse->inp_option_lst = xf86addNewOption(mouse->inp_option_lst, "Device", DFLT_MOUSE_DEV); -#endif +#ifndef __UNIXWARE__ mouse->inp_option_lst = xf86addNewOption(mouse->inp_option_lst, "ZAxisMapping", "4 5 6 7"); +#endif +#endif ptr = (XF86ConfInputPtr)xf86addListItem((glp)ptr, (glp)mouse); return ptr; } @@ -885,7 +890,7 @@ DoConfigure() #ifdef __UNIXOS2__ #define PATH_MAX 2048 #endif -#if defined(SCO) || defined(SCO325) +#if !defined(PATH_MAX) #define PATH_MAX 1024 #endif const char* configfile = XF86CONFIGFILE".new"; @@ -1009,13 +1014,13 @@ DoConfigure() ErrorF("\n"); -#ifdef SCO +#ifdef __SCO__ ErrorF("\n"__XSERVERNAME__ " is using the kernel event driver to access the mouse.\n" "If you wish to use the internal "__XSERVERNAME__ - "mouse drivers, please\n" + " mouse drivers, please\n" "edit the file and correct the Device.\n"); -#else /* !SCO */ +#else /* !__SCO__ */ if (!foundMouse) { ErrorF("\n"__XSERVERNAME__" is not able to detect your mouse.\n" "Edit the file and correct the Device.\n"); @@ -1028,7 +1033,7 @@ DoConfigure() "the protocol.\n",DFLT_MOUSE_DEV); #endif } -#endif /* !SCO */ +#endif /* !__SCO__ */ if (xf86NumScreens > 1) { ErrorF("\n"__XSERVERNAME__ diff --git a/hw/xfree86/common/xf86Events.c b/hw/xfree86/common/xf86Events.c index 74a93d295..ef63ea24e 100644 --- a/hw/xfree86/common/xf86Events.c +++ b/hw/xfree86/common/xf86Events.c @@ -364,7 +364,7 @@ xf86ProcessActionEvent(ActionEvent action, void *arg) case ACTION_SWITCHSCREEN: if (VTSwitchEnabled && !xf86Info.dontVTSwitch && arg) { int vtno = *((int *) arg); -#ifdef SCO +#if defined(__SCO__) || defined(__UNIXWARE__) vtno--; #endif #if defined(QNX4) @@ -377,12 +377,13 @@ xf86ProcessActionEvent(ActionEvent action, void *arg) break; case ACTION_SWITCHSCREEN_NEXT: if (VTSwitchEnabled && !xf86Info.dontVTSwitch) { -#if defined(SCO) /* Shouldn't this be true for (sun) && (i386) && (SVR4) ? */ +/* Shouldn't this be true for (sun) && (i386) && (SVR4) ? */ +#if defined(__SCO__) || defined(__UNIXWARE__) if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) < 0) #else if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno + 1) < 0) #endif -#if defined (SCO) || (defined(sun) && defined (i386) && defined (SVR4)) +#if defined (__SCO__) || (defined(sun) && defined (i386) && defined (SVR4)) || defined(__UNIXWARE__) if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, 0) < 0) #else if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, 1) < 0) @@ -784,7 +785,7 @@ special: break; #endif -#if defined(linux) || (defined(CSRG_BASED) && (defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) || defined(WSCONS_SUPPORT))) || defined(SCO) +#if defined(linux) || (defined(CSRG_BASED) && (defined(SYSCONS_SUPPORT) || defined(PCVT_SUPPORT) || defined(WSCONS_SUPPORT))) || defined(__SCO__) || defined(__UNIXWARE__) /* * Under Linux, the raw keycodes are consumed before the kernel * does any processing on them, so we must emulate the vt switching @@ -923,7 +924,7 @@ special: #endif /* USE_VT_SYSREQ */ -#ifdef SCO +#ifdef __SCO__ /* * With the console in raw mode, SCO will not switch consoles, * you get around this by activating the next console along, if @@ -938,7 +939,7 @@ special: xf86ProcessActionEvent(ACTION_SWITCHSCREEN_NEXT, NULL); return; } -#endif /* SCO */ +#endif /* __SCO__ */ #ifdef XKB } #endif @@ -1104,8 +1105,9 @@ special: Bool xf86CommonSpecialKey(int key, Bool down, int modifiers) { - if ((ModifierIsSet(ControlMask | AltMask)) || - (ModifierIsSet(ControlMask | AltLangMask))) { + if ((!ModifierIsSet(ShiftMask)) && + (((ModifierIsSet(ControlMask | AltMask)) || + (ModifierIsSet(ControlMask | AltLangMask))))) { switch (key) { case KEY_BackSpace: diff --git a/hw/xfree86/common/xf86Init.c b/hw/xfree86/common/xf86Init.c index 31363784b..38103af7f 100644 --- a/hw/xfree86/common/xf86Init.c +++ b/hw/xfree86/common/xf86Init.c @@ -906,7 +906,7 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv) xf86EnterServerState(SETUP); } } -#ifdef SCO +#ifdef SCO325 else { /* * Under SCO we must ack that we got the console at startup, @@ -919,7 +919,7 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv) xf86Msg(X_WARNING, "VT_ACKACQ failed"); } } -#endif /* SCO */ +#endif /* SCO325 */ for (i = 0; i < xf86NumScreens; i++) { xf86EnableAccess(xf86Screens[i]); diff --git a/hw/xfree86/loader/loader.c b/hw/xfree86/loader/loader.c index eb81826fc..5a2c127d5 100644 --- a/hw/xfree86/loader/loader.c +++ b/hw/xfree86/loader/loader.c @@ -402,6 +402,26 @@ LoaderInit(void) */ mallopt(M_MMAP_MAX, 0); #endif +#if defined(__UNIXWARE__) && !defined(__GNUC__) + /* For UnixWare we need to load the C Runtime libraries which are + * normally auto-linked by the compiler. Otherwise we are bound to + * see unresolved symbols when trying to use the type "long long". + * Obviously, this does not apply if the GNU C compiler is used. + */ + { + int errmaj, errmin, wasLoaded; /* place holders */ + char *xcrtpath = DEFAULT_MODULE_PATH "/libcrt.a"; + char *uwcrtpath = "/usr/ccs/lib/libcrt.a"; + char *path; + struct stat st; + + if(stat(xcrtpath, &st) < 0) + path = uwcrtpath; /* fallback: try to get libcrt.a from the uccs */ + else + path = xcrtpath; /* get the libcrt.a we compiled with */ + LoaderOpen (path, "libcrt", 0, &errmaj, &errmin, &wasLoaded); + } +#endif } /* diff --git a/hw/xfree86/loader/os.c b/hw/xfree86/loader/os.c index 010730586..9715af07b 100644 --- a/hw/xfree86/loader/os.c +++ b/hw/xfree86/loader/os.c @@ -50,7 +50,7 @@ #define OSNAME "lynxos" #elif defined(__GNU__) #define OSNAME "hurd" -#elif defined(SCO) +#elif defined(__SCO__) #define OSNAME "sco" #elif defined(DGUX) #define OSNAME "dgux" @@ -58,6 +58,8 @@ #define OSNAME "isc" #elif defined(SVR4) && defined(sun) #define OSNAME "solaris" +#elif defined(SVR5) +#define OSNAME "svr5" #elif defined(SVR4) #define OSNAME "svr4" #elif defined(__UNIXOS2__) diff --git a/hw/xfree86/os-support/sco/VTsw_sco.c b/hw/xfree86/os-support/sco/VTsw_sco.c index e0e7912b6..beb86ccad 100644 --- a/hw/xfree86/os-support/sco/VTsw_sco.c +++ b/hw/xfree86/os-support/sco/VTsw_sco.c @@ -58,7 +58,7 @@ xf86VTRequest(int sig) } Bool -xf86VTSwitchPending() +xf86VTSwitchPending(void) { return(xf86Info.vtRequestsPending ? TRUE : FALSE); } @@ -72,7 +72,7 @@ static int sco_ledstatus = -1; static unsigned int sco_ledstate = 0; Bool -xf86VTSwitchAway() +xf86VTSwitchAway(void) { ev_flush(); ev_suspend(); @@ -93,7 +93,7 @@ xf86VTSwitchAway() * switched away. */ Bool -xf86VTSwitchTo() +xf86VTSwitchTo(void) { ev_resume(); diff --git a/hw/xfree86/os-support/sco/sco_KbdMap.c b/hw/xfree86/os-support/sco/sco_KbdMap.c new file mode 100644 index 000000000..6a0e9de04 --- /dev/null +++ b/hw/xfree86/os-support/sco/sco_KbdMap.c @@ -0,0 +1,304 @@ +/* $XFree86$ */ +/* + * Copyright 2005 by J. Kean Johnston + * + * 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/hw/xfree86/os-support/sco/sco_init.c b/hw/xfree86/os-support/sco/sco_init.c index d200eccb4..bc1f3b56d 100644 --- a/hw/xfree86/os-support/sco/sco_init.c +++ b/hw/xfree86/os-support/sco/sco_init.c @@ -1,6 +1,6 @@ /* $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 by J. Kean Johnston + * Copyright 2001-2005 by J. Kean Johnston * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -39,19 +39,19 @@ static Bool KeepTty = FALSE; static int VTnum = -1; -static char *vtdevice = NULL; +static char vtdevice[48]; static int sco_console_mode = -1; extern Bool mpxLock; void -xf86OpenConsole() +xf86OpenConsole(void) { - int fd,i, ioctl_ret; + int i, ioctl_ret; struct vt_mode VT; - static char vtname[32]; struct vid_info vidinf; struct sigaction sigvtsw; + char *ttn; if (serverGeneration == 1) { /* check if we're run with euid==0 */ @@ -59,6 +59,9 @@ xf86OpenConsole() 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 @@ -67,75 +70,37 @@ xf86OpenConsole() * 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, XFree86 tried to determine the TTY name manually. + * Previously, we tried to determine the TTY name manually. * This is wrong. The only time we need to futz with the TTY name - * if if we were given the name of a TTY to run on explicity on + * is if we were given the name of a TTY to run on explicity on * the command line. */ if (VTnum == -1) { /* - * We can query the current VT number using CONS_GETINFO. + * 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). */ - char *ttn; - - vidinf.size = sizeof(vidinf); - if (ioctl (0, CONS_GETINFO, &vidinf) < 0) { - FatalError ("xf86OpenConsole: Not on a console device " - "or error querying device (%s)\n", strerror (errno)); - } - - VTnum = vidinf.m_num + 1; /* 0-based */ - ttn = ttyname (0); + ttn = ttyname (1); if (ttn == (char *)0) { - ErrorF ("xf86OpenConsole: Error determining TTY name (%s)\n", - strerror(errno)); - snprintf (vtname, sizeof(vtname)-1, "/dev/tty%02d", VTnum); - } else { - strlcpy (vtname, ttn, sizeof(vtname)); - } - vtdevice = vtname; - } else if (VTnum == -2 || VTnum >= 0) { - /* - * An explicit device was specified. Make sure its a console device. - */ - if (VTnum != -2) { - snprintf (vtname, sizeof(vtname)-1, "/dev/tty%02d", VTnum); - vtdevice = vtname; - } - - fd = open (vtdevice, O_RDWR | O_NDELAY, 0); - if (fd < 0) { - FatalError ("xf86OpenConsole: Can not open device '%s' (%s)\n", - vtdevice, strerror(errno)); - } - - vidinf.size = sizeof(vidinf); - if (ioctl (fd, CONS_GETINFO, &vidinf) < 0) { - FatalError ("xf86OpenConsole: '%s' is not a console device " - "or error querying device (%s)\n", vtname, strerror (errno)); + FatalError ("xf86OpenConsole: Could not determine TTY name: %s\n", + strerror(errno)); } - VTnum = vidinf.m_num + 1; /* 0-based */ - close (fd); /* We're done with it for now */ + strlcpy (vtdevice, ttn, sizeof(vtdevice)); + } else if (VTnum >= 0) { + snprintf (vtdevice, sizeof(vtdevice), "/dev/tty%02d", VTnum); } - ErrorF("(using VT%02d device %s)\n\n", VTnum, vtdevice); + /* + * 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)); - } - - /* Dispose of stdin and stdout */ - if (freopen(vtdevice, "r+", stdin) == (FILE *) NULL) { - FatalError("xf86OpenConsole: Cannot reopen stdin as %s (%s)\n", - vtdevice, strerror(errno)); - } - - if (freopen(vtname, "r+", stdout) == (FILE *) NULL) { - FatalError("xf86OpenConsole: Cannot reopen stdout as %s (%s)\n", - vtdevice, strerror(errno)); + FatalError("xf86OpenConsole: Cannot open %s: %s\n", vtdevice, + strerror(errno)); } /* @@ -145,10 +110,13 @@ xf86OpenConsole() */ vidinf.size = sizeof(vidinf); if (ioctl (xf86Info.consoleFd, CONS_GETINFO, &vidinf) < 0) { - FatalError ("xf86OpenConsole: Failed to query console number (%s)\n", - strerror (errno)); + 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) { @@ -161,7 +129,7 @@ xf86OpenConsole() } /* - * Now we get the current mode that the console device is on. We will + * 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. */ @@ -227,7 +195,7 @@ xf86OpenConsole() * video card down again after coming out of Xfree86. */ void -xf86CloseConsole() +xf86CloseConsole(void) { struct vt_mode VT; struct sigaction sigvtsw; @@ -310,7 +278,7 @@ xf86ProcessArgument(int argc, char *argv[], int i) return(0); } else { VTnum = -2; - vtdevice = argv[i]; + strlcpy (vtdevice, argv[i], sizeof(vtdevice)); return(2); } } @@ -318,7 +286,7 @@ xf86ProcessArgument(int argc, char *argv[], int i) } void -xf86UseMsg() +xf86UseMsg(void) { ErrorF("vtXX use the specified VT number\n"); ErrorF("-crt DEVICE use the specified VT device\n"); diff --git a/hw/xfree86/os-support/sco/sco_io.c b/hw/xfree86/os-support/sco/sco_io.c index fd4c9b780..c97916cf5 100644 --- a/hw/xfree86/os-support/sco/sco_io.c +++ b/hw/xfree86/os-support/sco/sco_io.c @@ -73,7 +73,7 @@ xf86SetKbdLeds(int leds) } int -xf86GetKbdLeds() +xf86GetKbdLeds(void) { int leds; @@ -140,7 +140,7 @@ static uchar_t *sc_mapbuf; static uchar_t *sc_mapbuf2; void -xf86KbdInit() +xf86KbdInit(void) { orig_getsc = 0; if (ioctl (xf86Info.consoleFd, TCGETSC, &orig_getsc) < 0) @@ -214,7 +214,7 @@ xf86KbdInit() } int -xf86KbdOn() +xf86KbdOn(void) { struct termios newtio; @@ -248,7 +248,7 @@ xf86KbdOn() } int -xf86KbdOff() +xf86KbdOff(void) { /* Revert back to original translate scancode mode */ if (use_tcs) @@ -267,11 +267,3 @@ xf86KbdOff() return(xf86Info.consoleFd); } - -#include "xf86OSKbd.h" - -Bool -xf86OSKbdPreInit(InputInfoPtr pInfo) -{ - return FALSE; -} diff --git a/hw/xfree86/os-support/sco/sco_iop.c b/hw/xfree86/os-support/sco/sco_iop.c index e9bf72890..35d48e04a 100644 --- a/hw/xfree86/os-support/sco/sco_iop.c +++ b/hw/xfree86/os-support/sco/sco_iop.c @@ -66,7 +66,8 @@ extern long sysi86 (int cmd, ...); static Bool IOEnabled = FALSE; -Bool xf86EnableIO(void) +Bool +xf86EnableIO(void) { if (IOEnabled) return TRUE; @@ -80,7 +81,8 @@ Bool xf86EnableIO(void) return TRUE; } -void xf86DisableIO(void) +void +xf86DisableIO(void) { if (!IOEnabled) return; @@ -93,7 +95,8 @@ void xf86DisableIO(void) /* Interrupt Handling section */ /***************************************************************************/ -Bool xf86DisableInterrupts() +Bool +xf86DisableInterrupts(void) { if (!IOEnabled) { if (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) < 0) @@ -113,7 +116,8 @@ Bool xf86DisableInterrupts() return(TRUE); } -void xf86EnableInterrupts() +void +xf86EnableInterrupts(void) { if (!IOEnabled) { if (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) < 0) diff --git a/hw/xfree86/os-support/sco/sco_kbd.c b/hw/xfree86/os-support/sco/sco_kbd.c new file mode 100644 index 000000000..a26b7e96b --- /dev/null +++ b/hw/xfree86/os-support/sco/sco_kbd.c @@ -0,0 +1,530 @@ +/* $XFree86$ */ +/* + * Copyright 2005 by J. Kean Johnston + * + * 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 + * + * 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 + * Copyright 1993 by David Dawes + */ + +#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 +#include +#include + +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/hw/xfree86/os-support/sco/sco_kbd.h b/hw/xfree86/os-support/sco/sco_kbd.h new file mode 100644 index 000000000..a79cd7bb9 --- /dev/null +++ b/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/hw/xfree86/os-support/sco/sco_mouse.c b/hw/xfree86/os-support/sco/sco_mouse.c index 9e167852b..d60107f68 100644 --- a/hw/xfree86/os-support/sco/sco_mouse.c +++ b/hw/xfree86/os-support/sco/sco_mouse.c @@ -42,8 +42,7 @@ static int SupportedInterfaces (void) { - /* FIXME: Is this correct? Should we just return MSE_MISC? */ - return MSE_SERIAL | MSE_BUS | MSE_PS2 | MSE_XPS2 | MSE_MISC | MSE_AUTO; + return MSE_MISC; } static const char *internalNames[] = { @@ -107,8 +106,8 @@ OsMouseProc (DeviceIntPtr pPointer, int what) case DEVICE_INIT: pPointer->public.on = FALSE; - dmask = D_REL | D_BUTTON; - if ((evi = ev_init()) < 0) { + dmask = D_ABS | D_REL | D_BUTTON; + if ((evi = ev_initf(xf86Info.consoleFd)) < 0) { FatalError ("OsMouseProc: Event driver initialization failed (%s)\n", evtErrStr(evi)); } @@ -127,9 +126,9 @@ OsMouseProc (DeviceIntPtr pPointer, int what) map[1] = 1; map[2] = 2; map[3] = 3; - map[4] = 6; - map[5] = 7; - map[6] = 8; + map[4] = 7; + map[5] = 8; + map[6] = 6; map[7] = 4; map[8] = 5; /* Compatibile with SCO X server */ @@ -161,7 +160,7 @@ OsMouseProc (DeviceIntPtr pPointer, int what) case DEVICE_OFF: case DEVICE_CLOSE: - pPointer->public.on = TRUE; + pPointer->public.on = FALSE; RemoveEnabledDevice (pInfo->fd); if (what == DEVICE_CLOSE) { ev_close(); @@ -185,18 +184,15 @@ OsMouseReadInput (InputInfoPtr pInfo) while ((evp = ev_read()) != (EVENT *)0) { int buttons = EV_BUTTONS(*evp); - int dx = EV_DX(*evp), dy = -(EV_DY(*evp)), dz = 0, dw = 0; + int dx = EV_DX(*evp), dy = -(EV_DY(*evp)); if (EV_TAG(*evp) & T_WHEEL) { - dz = (dy & 0x08) ? (dy & 0x0f) - 16 : (dy & 0x0f); - dx = dy = 0; - pMse->PostEvent (pInfo, buttons, dx, dy, dz, dw); + pMse->PostEvent (pInfo, buttons, 0, 0, 0, 0); /* Simulate button release */ - dz = 0; buttons &= ~(WHEEL_FWD | WHEEL_BACK); } - pMse->PostEvent (pInfo, buttons, dx, dy, dz, dw); + pMse->PostEvent (pInfo, buttons, dx, dy, 0, 0); ev_pop(); } } @@ -217,9 +213,9 @@ OsMousePreInit(InputInfoPtr pInfo, const char *protocol, int flags) xf86ProcessCommonOptions(pInfo, pInfo->options); /* Check if the device can be opened. */ - pInfo->fd = ev_init(); + pInfo->fd = ev_initf(xf86Info.consoleFd); if (pInfo->fd != -1) { - dmask_t dmask = (D_REL | D_BUTTON); + dmask_t dmask = (D_ABS | D_REL | D_BUTTON); pInfo->fd = ev_open(&dmask); } else { pInfo->fd = -999; diff --git a/hw/xfree86/os-support/shared/sysv_kbd.c b/hw/xfree86/os-support/shared/sysv_kbd.c index dd1ca3356..3a3544e8c 100644 --- a/hw/xfree86/os-support/shared/sysv_kbd.c +++ b/hw/xfree86/os-support/shared/sysv_kbd.c @@ -65,7 +65,7 @@ xf86KbdInit() ioctl (xf86Info.consoleFd, KDGKBMODE, &kbdtrans); #endif ioctl (xf86Info.consoleFd, TCGETA, &kbdtty); -#if defined(E_TABSZ) && !defined(SCO325) +#if defined(E_TABSZ) kbdemap = xalloc(E_TABSZ); if (ioctl(xf86Info.consoleFd, LDGMAP, kbdemap) < 0) { diff --git a/hw/xfree86/os-support/usl/usl_KbdMap.c b/hw/xfree86/os-support/usl/usl_KbdMap.c new file mode 100644 index 000000000..76032e61a --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_KbdMap.c @@ -0,0 +1,304 @@ +/* $XdotOrg$ */ +/* + * Copyright 2005 by J. Kean Johnston + * + * 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 "usl_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; + USLKbdPrivPtr priv = (USLKbdPrivPtr) 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 += 4) { + + 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/hw/xfree86/os-support/usl/usl_init.c b/hw/xfree86/os-support/usl/usl_init.c new file mode 100644 index 000000000..120ce1bcc --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_init.c @@ -0,0 +1,359 @@ +/* $XdotOrg$ */ +/* + * Copyright 2001-2005 by Kean Johnston + * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany + * Copyright 1993 by David Wexelblat + * + * 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 names of Thomas Roell, David Wexelblat + * and Kean Johnston not be used in advertising or publicity pertaining to + * distribution of the software without specific, written prior permission. + * Thomas Roell, David Wexelblat and Kean Johnston make no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THOMAS ROELL, DAVID WEXELBLAT AND KEAN JOHNSTON DISCLAIM ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THOMAS ROELLm DAVID WEXELBLAT + * OR 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$ */ + +#include "X.h" +#include "Xmd.h" + +#include "compiler.h" + +#include "xf86.h" +#include "xf86Priv.h" +#include "xf86_OSlib.h" + +#include + +static Bool KeepTty = FALSE; +static Bool Protect0 = FALSE; +static Bool CRTSpecified = FALSE; +static int VTnum = -1; +static char vtdevice[48]; + +int usl_is_osr6 = -1; + +static Bool +IsConsoleDevice(const char *dev) +{ + if ((!strcmp (dev, "/dev/console")) || + (!strcmp (dev, "/dev/syscon")) || + (!strcmp (dev, "/dev/systty"))) + return TRUE; + + return FALSE; +} + +static int +is_osr6 (void) +{ + struct utsname uts; + + if (usl_is_osr6 == -1) { + if (uname (&uts) < 0) { + FatalError ("get_usl_ver: Failed to determine UNIX name (%s)\n", + strerror (errno)); + } + + if (uts.version[0] == '6') + usl_is_osr6 = 1; + else + usl_is_osr6 = 0; + } + + return usl_is_osr6; +} + + +void +xf86OpenConsole(void) +{ + int fd, i, ioctl_ret; + struct vt_mode VT; + struct vt_stat vts; + MessageType from = X_PROBED; + struct sigaction sigvtsw; + char *ttn; + + if (serverGeneration == 1) { + int isconsole = 0, consdev = 0; + + /* check if we're run with euid==0 */ + if (geteuid() != 0) { + FatalError("xf86OpenConsole: Server must be suid root\n"); + } + + /* If we are run in the background we will get SIGTTOU. Ignore it. */ + OsSignal (SIGTTOU, SIG_IGN); + + /* Protect page 0 to help find NULL dereferencing */ + /* mprotect() doesn't seem to work */ + if (Protect0) { + int fd = -1; + + if ((fd = open("/dev/zero", O_RDONLY, 0)) < 0) { + xf86Msg(X_WARNING, "xf86OpenConsole: cannot open /dev/zero (%s)\n", + strerror(errno)); + } else { + if ((int)mmap(0, 0x1000, PROT_NONE, + MAP_FIXED | MAP_SHARED, fd, 0) == -1) { + xf86Msg(X_WARNING, "xf86OpenConsole: failed to protect page 0 (%s)\n", + strerror(errno)); + } + close(fd); + } + } + + /* + * setup the virtual terminal manager + */ + 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). + */ + if (ioctl (0, VT_GETSTATE, &vts) < 0) { + FatalError("xf86OpenConsole: Could not query active VT: %s\n", + strerror(errno)); + } + VTnum = vts.v_active; + if (is_osr6()) + snprintf (vtdevice, sizeof(vtdevice), "/dev/tty%02d", VTnum + 1); + else + snprintf (vtdevice, sizeof(vtdevice), "/dev/vt%02d", VTnum); + } else { + from = X_CMDLINE; + if (is_osr6()) + snprintf (vtdevice, sizeof(vtdevice), "/dev/tty%02d", VTnum + 1); + else + snprintf (vtdevice, sizeof(vtdevice), "/dev/vt%02d", VTnum); + } + + if (IsConsoleDevice(vtdevice)) { + isconsole = 1; + CRTSpecified = FALSE; /* Dont honour -crt /dev/console */ + } + + if (ioctl (0, KIOCINFO, 0) >= 0) + consdev = 1 + isconsole; + + if ((!CRTSpecified) && (isconsole || (!consdev))) { + /* + * Need to find a free VT + */ + if ((fd = open ("/dev/console", O_WRONLY | O_NOCTTY)) < 0) { + FatalError ("xf86OpenConsole: Could not open /dev/console: %s\n", + strerror (errno)); + } + + if (ioctl (fd, VT_OPENQRY, &VTnum) < 0) { + FatalError ("xf86OpenConsole: Cannot find a free VT: %s\n", + strerror(errno)); + } + close (fd); + if (usl_is_osr6) + snprintf (vtdevice, sizeof(vtdevice), "/dev/tty%02d", VTnum + 1); + else + snprintf (vtdevice, sizeof(vtdevice), "/dev/vt%02d", VTnum); + } + + /* + * Now we can dispose of stdin/stdout + */ + fclose (stdin); + fclose (stdout); + + if (CRTSpecified || isconsole || consdev != 1) { + if (!KeepTty) { + setpgrp(); + } + } + + if ((xf86Info.consoleFd = open(vtdevice, O_RDWR | O_NONBLOCK, 0)) < 0) { + FatalError("xf86OpenConsole: Cannot open %s: %s\n", vtdevice, + strerror(errno)); + } + + xf86Msg (from, "using VT number %d (%s)\n\n", VTnum, vtdevice); + xf86Info.vtno = VTnum; + + /* change ownership of the vt */ + chown(vtdevice, getuid(), getgid()); + + /* + * now get the VT + */ + if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) { + FatalError("xf86OpenConsole: VT_ACTIVATE failed: %s\n", + strerror(errno)); + } + if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) != 0) { + FatalError("xf86OpenConsole: VT_WAITACTIVE failed: %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; + sigaction(SIGUSR1, &sigvtsw, NULL); + + VT.mode = VT_PROCESS; + VT.relsig = SIGUSR1; + VT.acqsig = SIGUSR1; + + ioctl_ret = ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); + if (ioctl_ret < 0) { + FatalError("xf86OpenConsole: VT_SETMODE failed: %s\n", strerror(errno)); + } + + if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0) { + FatalError("xf86OpenConsole: KD_GRAPHICS failed: %s\n", strerror(errno)); + } + } else { /* serverGeneration != 1 */ + /* + * now get the VT + */ + if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) { + FatalError("xf86OpenConsole: VT_ACTIVATE failed: %s\n", strerror(errno)); + } + if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) != 0) { + FatalError("xf86OpenConsole: VT_WAITACTIVE failed: %s\n",strerror(errno)); + } + /* + * If the server doesn't have the VT when the reset occurs, + * this is to make sure we don't continue until the activate + * signal is received. + */ + if (!xf86Screens[0]->vtSema) + sleep(5); + } + return; +} + +void +xf86CloseConsole(void) +{ + struct vt_mode VT; + struct sigaction sigvtsw; + + ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT); /* Back to text mode ... */ + + sigvtsw.sa_handler = SIG_DFL; + sigfillset(&sigvtsw.sa_mask); + sigvtsw.sa_flags = 0; + sigaction(SIGUSR1, &sigvtsw, NULL); + + if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) != -1) { + VT.mode = VT_AUTO; + VT.waitv = 0; + ioctl(xf86Info.consoleFd, VT_SETMODE, &VT); /* set dflt vt handling */ + } + close(xf86Info.consoleFd); /* make the vt-manager happy */ + return; +} + +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); + } + + /* + * Undocumented flag to protect page 0 from read/write to help + * catch NULL pointer dereferences. This is purely a debugging + * flag. + */ + if (!strcmp(argv[i], "-protect0")) { + Protect0 = TRUE; + return(1); + } + + if ((argv[i][0] == 'v') && (argv[i][1] == 't')) { + if (sscanf(argv[i], "vt%2d", &VTnum) == 0) { + UseMsg(); + VTnum = -1; + return(0); + } + VTnum -= is_osr6(); + CRTSpecified = TRUE; + return(1); + } + + /* + * Use a device the user specifies. + */ + if (!strcmp(argv[i], "-crt")) { + if (++i > argc) { + UseMsg(); + VTnum = -1; + return(0); + } else { + char *mytty = ttyname(0); + char *arg = argv[i]; + + if (!mytty) + mytty = "\1"; + if (!arg[0]) + arg = "\2"; /* Prevent idiots from using -crt "" */ + + if (strcmp (mytty, arg) != 0) { + char *fmt; + + if (is_osr6()) + fmt = "/dev/tty%02d"; + else + fmt = "/dev/vt%02d"; + + if (sscanf(arg, fmt, &VTnum) == 0) { + UseMsg(); + VTnum = -1; + return(0); + } + + /* OSR6 devices start names at 1, UW7 starts at 0 */ + VTnum -= is_osr6(); + CRTSpecified = TRUE; + } + return(2); + } + } + return(0); +} + +void +xf86UseMsg(void) +{ + if (is_osr6()) { + ErrorF("-crt /dev/ttyXX use the specified VT device\n"); + ErrorF("vtXX use the specified VT number (01-16)\n"); + } else { + ErrorF("-crt /dev/vtXX use the specified VT device\n"); + ErrorF("vtXX use the specified VT number (00-15)\n"); + } + + ErrorF("-keeptty "); + ErrorF("don't detach controlling tty (for debugging only)\n"); + return; +} diff --git a/hw/xfree86/os-support/usl/usl_io.c b/hw/xfree86/os-support/usl/usl_io.c new file mode 100644 index 000000000..a62fdc6f6 --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_io.c @@ -0,0 +1,172 @@ +/* $XdotOrg$ */ +/* + * Copyright 2001-2005 by Kean Johnston + * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany + * Copyright 1993 by David Dawes + * + * 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 names of Thomas Roell, David Dawes + * and Kean Johnston not be used in advertising or publicity pertaining to + * distribution of the software without specific, written prior permission. + * Thomas Roell, David Dawes and Kean Johnston make no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THOMAS ROELL, DAVID DAWES AND KEAN JOHNSTON DISCLAIM ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THOMAS ROELLm DAVID WEXELBLAT + * OR 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$ */ + +#include "X.h" + +#include "compiler.h" + +#include "xf86.h" +#include "xf86Priv.h" +#include "xf86_OSlib.h" + +void +xf86SoundKbdBell(int loudness, int pitch, int duration) +{ + if (loudness && pitch) { + ioctl(xf86Info.consoleFd, KIOCSOUND, 1193180 / pitch); + usleep(xf86Info.bell_duration * loudness * 20); + ioctl(xf86Info.consoleFd, KIOCSOUND, 0); + } +} + +void +xf86SetKbdLeds(int leds) +{ + 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 and David Dawes . + * Please see the file ../linux/lnx_io.c for full copyright information. + */ +void +xf86SetKbdRepeat(char rad) +{ + 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, KDSETTYPEMATICS, value); +} + +static int orig_kbm; +static struct termio orig_termio; +static keymap_t keymap, noledmap; + +void +xf86KbdInit(void) +{ + ioctl (xf86Info.consoleFd, KDGKBMODE, &orig_kbm); + ioctl (xf86Info.consoleFd, TCGETA, &orig_termio); + /* + * 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_SPECKEY(&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; + } + } + } + } +} + +int +xf86KbdOn(void) +{ + struct termio newtio; + + newtio = orig_termio; /* 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; + ioctl(xf86Info.consoleFd, TCSETA, &newtio); + + ioctl (xf86Info.consoleFd, KDSKBMODE, K_RAW); + ioctl (xf86Info.consoleFd, PIO_KEYMAP, &noledmap); + + return(xf86Info.consoleFd); +} + +int +xf86KbdOff(void) +{ + ioctl (xf86Info.consoleFd, KDSKBMODE, orig_kbm); + ioctl (xf86Info.consoleFd, PIO_KEYMAP, &keymap); + ioctl(xf86Info.consoleFd, TCSETA, &orig_termio); + + return(xf86Info.consoleFd); +} diff --git a/hw/xfree86/os-support/usl/usl_iop.c b/hw/xfree86/os-support/usl/usl_iop.c new file mode 100644 index 000000000..2beac0b31 --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_iop.c @@ -0,0 +1,108 @@ +/* $XdotOrg$ */ +/* + * Copyright 2001,2005 by Kean Johnston + * + * 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 Kean Johnston not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Kean Johnston makes no + * representations about the suitability of this software for any purpose. + * It is provided "as is" without express or implied warranty. + * + * KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL 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$ */ + + +#include "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 */ +/***************************************************************************/ + +static Bool IOEnabled = FALSE; + +Bool +xf86EnableIO(void) +{ + if (IOEnabled) + return TRUE; + + if (sysi86(SI86IOPL, 3) < 0) + FatalError("Failed to set IOPL for extended I/O\n"); + IOEnabled = TRUE; + return TRUE; +} + +void +xf86DisableIO(void) +{ + if (!IOEnabled) + return; + + sysi86(SI86IOPL, 0); + IOEnabled = FALSE; +} + +/***************************************************************************/ +/* Interrupt Handling section */ +/***************************************************************************/ + +Bool +xf86DisableInterrupts(void) +{ + if (!IOEnabled) { + if (sysi86(SI86IOPL, 3) < 0) + return FALSE; + } + +#ifdef __GNUC__ + __asm__ __volatile__("cli"); +#else + asm("cli"); +#endif /* __GNUC__ */ + + if (!IOEnabled) { + sysi86(SI86IOPL, 0); + } + + return(TRUE); +} + +void +xf86EnableInterrupts(void) +{ + if (!IOEnabled) { + if (sysi86(SI86IOPL, 3) < 0) + return; + } + +#ifdef __GNUC__ + __asm__ __volatile__("sti"); +#else + asm("sti"); +#endif /* __GNUC__ */ + + if (!IOEnabled) { + sysi86(SI86IOPL, 0); + } +} + diff --git a/hw/xfree86/os-support/usl/usl_kbd.c b/hw/xfree86/os-support/usl/usl_kbd.c new file mode 100644 index 000000000..11aa2cf03 --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_kbd.c @@ -0,0 +1,456 @@ +/* $XdotOrg$ */ +/* + * Copyright 2005 by Kean Johnston + * + * 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 Kean Johnston not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Kean Johnston makes no + * representations about the suitability of this software for any purpose. + * It is provided "as is" without express or implied warranty. + * + * KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL 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 Kean Johnston + * + * 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 + * Copyright 1993 by David Dawes + */ + +#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 "usl_kbd.h" +#include "usl_xqueue.h" + +#include + +static KbdProtocolRec protocols[] = { + { "standard", PROT_STD }, + { "Xqueue", PROT_XQUEUE }, + { 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; + + if (leds & XLED1) + real_leds |= LED_CAP; + if (leds & XLED2) + real_leds |= LED_NUM; + if (leds & XLED3) + real_leds |= LED_SCR; + 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); +} + +static void +SetKbdRepeat(InputInfoPtr pInfo, char rad) +{ + 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, KDSETTYPEMATICS, value); +} + +static int +KbdInit(InputInfoPtr pInfo, int what) +{ + KbdDevPtr pKbd = (KbdDevPtr) pInfo->private; + USLKbdPrivPtr priv = (USLKbdPrivPtr) pKbd->private; + + if (pKbd->isConsole) { + if (ioctl (pInfo->fd, KDGKBMODE, &priv->orig_kbm) < 0) { + xf86Msg (X_ERROR, "KbdInit: Could not determine keyboard mode\n"); + return !Success; + } + + /* + * We need to get the original keyboard map and NUL out the lock + * modifiers. This prevents the kernel from messing with + * the keyboard LED's. We restore the original map when we exit. + * Note that we also have to eliminate screen switch sequences + * else the VT manager will switch for us, which we don't want. + * For example, lets say you had changed the VT manager to switch + * on Alt-Fx instead of Ctrl-Alt-Fx. This means that while inside + * X, you cant use, for example, Alt-F4, which is a pain in the + * fundamental when you're using CDE-like thingies. + */ + 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_SPECKEY(&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_FRCNEXT) || + (priv->noledmap.key[i].map[j] == K_FRCPREV) || + ((priv->noledmap.key[i].map[j] >= K_VTF) && + (priv->noledmap.key[i].map[j] <= K_VTL)) )) { + priv->noledmap.key[i].map[j] = K_NOP; + } + } + } + } + + if (ioctl (pInfo->fd, TCGETA, &priv->kbdtty) < 0) { + xf86Msg (X_ERROR, "KbdInit: Failed to get terminal modes (%s)\n", + strerror(errno)); + return !Success; + } + } /* End of if we are on a console */ + + return Success; +} + +static int +KbdOn(InputInfoPtr pInfo, int what) +{ + KbdDevPtr pKbd = (KbdDevPtr) pInfo->private; + USLKbdPrivPtr priv = (USLKbdPrivPtr) pKbd->private; + struct termio newtio; + + if (pKbd->isConsole) { + /* + * Use the calculated keyboard map that does not have active + * LED lock handling (we track LEDs ourselves). + */ + ioctl (pInfo->fd, PIO_KEYMAP, &priv->noledmap); + +#ifdef NOTYET + 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; + ioctl(pInfo->fd, TCSETA, &newtio); + + if (priv->xq == 0) + ioctl (pInfo->fd, KDSKBMODE, K_RAW); + else +#endif + XqKbdOnOff (pInfo, 1); + } + + return Success; +} + +static int +KbdOff(InputInfoPtr pInfo, int what) +{ + KbdDevPtr pKbd = (KbdDevPtr) pInfo->private; + USLKbdPrivPtr priv = (USLKbdPrivPtr) pKbd->private; + + if (pKbd->isConsole) { + /* Revert back to original translate scancode mode */ +#ifdef NOTYET + if (priv->xq == 0) + ioctl (pInfo->fd, KDSKBMODE, priv->orig_kbm); + else +#endif + XqKbdOnOff (pInfo, 0); + + ioctl (pInfo->fd, PIO_KEYMAP, &priv->keymap); + ioctl(pInfo->fd, TCSETA, &priv->kbdtty); + } + + return Success; +} + +#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_SWITCH, 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_SWITCH, 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; +} + +#ifdef NOTYET +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); + } + } +} +#endif + +static Bool +OpenKeyboard(InputInfoPtr pInfo) +{ + KbdDevPtr pKbd = (KbdDevPtr) pInfo->private; + USLKbdPrivPtr priv = (USLKbdPrivPtr) pKbd->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: +#ifdef NOTYET + pInfo->read_input = stdReadInput; + priv->xq = 0; + break; +#endif + case PROT_XQUEUE: + pInfo->read_input = NULL; /* Handled by the XQUEUE signal handler */ + priv->xq = 1; + 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->OpenKeyboard = OpenKeyboard; + + pKbd->GetSpecialKey = NULL; + pKbd->RemapScanCode = ATScancode; + pKbd->vtSwitchSupported = FALSE; + + pKbd->private = xcalloc(sizeof(USLKbdPrivRec), 1); + if (pKbd->private == NULL) { + xf86Msg(X_ERROR,"can't allocate keyboard OS private data\n"); + return FALSE; + } + + return TRUE; +} diff --git a/hw/xfree86/os-support/usl/usl_kbd.h b/hw/xfree86/os-support/usl/usl_kbd.h new file mode 100644 index 000000000..990c13cc7 --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_kbd.h @@ -0,0 +1,14 @@ +/* $XdotOrg$ */ +#ifndef SCO_KBD_HDR +#define SCO_KBD_HDR + +typedef struct { + int orig_kbm; + struct termio kbdtty; + keymap_t keymap, noledmap; + int xq; +} USLKbdPrivRec, *USLKbdPrivPtr; + +extern void KbdGetMapping(InputInfoPtr pInfo, KeySymsPtr pKeySyms, + CARD8 *pModMap); +#endif /* SCO_KBD_HDR */ diff --git a/hw/xfree86/os-support/usl/usl_mouse.c b/hw/xfree86/os-support/usl/usl_mouse.c new file mode 100644 index 000000000..68e4e9028 --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_mouse.c @@ -0,0 +1,187 @@ +/* $XdotOrg$ */ + +/* + * Copyright 2005 Kean Johnston + * Copyright 1999 by The XFree86 Project, Inc. + * + * 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 names of The XFree86 Project, Inc + * and Kean Johnston not be used in advertising or publicity pertaining to + * distribution of the software without specific, written prior permission. + * The XFree86 Project, Inc and Kean Johnston make no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THE XFREE86 PROJECT, INC AND KEAN JOHNSTON DISCLAIM ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THOMAS ROELLm DAVID WEXELBLAT + * OR 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. + * + */ + +#include "X.h" +#include "compiler.h" +#include "xf86.h" +#include "xf86Xinput.h" +#include "xf86OSmouse.h" +#include "xf86Priv.h" +#include "xf86_OSlib.h" +#include "mipointer.h" +#include "usl_xqueue.h" + +static int +SupportedInterfaces(void) +{ + return MSE_MISC; +} + +static const char *internalNames[] = { + "Xqueue", + NULL +}; + +static const char ** +BuiltinNames(void) +{ + return internalNames; +} + +static const char * +DefaultProtocol (void) +{ + return "Xqueue"; +} + +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 int +OsMouseProc(DeviceIntPtr pPointer, int what) +{ + InputInfoPtr pInfo; + MouseDevPtr pMse; + unsigned char map[9]; + int ret; + + pInfo = pPointer->public.devicePrivate; + pMse = pInfo->private; + pMse->device = pPointer; + + switch (what) { + case DEVICE_INIT: + pPointer->public.on = FALSE; + + map[1] = 1; + map[2] = 2; + map[3] = 3; + map[4] = 7; + map[5] = 8; + map[6] = 6; + map[7] = 4; + map[8] = 5; + + 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); + break; + + case DEVICE_ON: + pMse->lastButtons = 0; + pMse->emulateState = 0; + pPointer->public.on = TRUE; + XqMseOnOff (pInfo, 1); + break; + + case DEVICE_CLOSE: + case DEVICE_OFF: + pPointer->public.on = FALSE; + XqMseOnOff (pInfo, 0); + break; + } + return Success; +} + +static Bool +OsMousePreInit(InputInfoPtr pInfo, const char *protocol, int flags) +{ + /* This is called when the protocol is "Xqueue" */ + MouseDevPtr pMse; + + 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); + + pInfo->fd = -1; +#if 0 + /* Make sure we can open the mouse */ + pInfo->fd = open ("/dev/mouse", O_RDONLY | O_NONBLOCK); + + if (pInfo->fd < 0) { + if (xf86GetAllowMouseOpenFail()) { + xf86Msg(X_WARNING, "%s: cannot open /dev/mouse (%s)\n", + pInfo->name, strerror(errno)); + } else { + xf86Msg(X_ERROR, "%s: cannot open /dev/mouse (%s)\n", + pInfo->name, strerror(errno)); + xfree(pMse); + return FALSE; + } + } +#endif + + /* Process common mouse options (like Emulate3Buttons, etc). */ + pMse->CommonOptions(pInfo); + + /* Setup the local procs. */ + pInfo->device_control = OsMouseProc; + pInfo->read_input = NULL; /* Handled by the XQUEUE signal handler */ + + 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/hw/xfree86/os-support/usl/usl_video.c b/hw/xfree86/os-support/usl/usl_video.c new file mode 100644 index 000000000..160282aab --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_video.c @@ -0,0 +1,111 @@ +/* $XdotOrg$ */ +/* + * Copyrught 2005 Kean Johnston + * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany + * Copyright 1993 by David Wexelblat + * + * 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 names of Thomas Roell, David Dawes + * and Kean Johnston not be used in advertising or publicity pertaining to + * distribution of the software without specific, written prior permission. + * Thomas Roell, David Dawes and Kean Johnston make no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * THOMAS ROELL, DAVID DAWES AND KEAN JOHNSTON DISCLAIM ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THOMAS ROELLm DAVID WEXELBLAT + * OR 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$ */ + +#include "X.h" + +#define _NEED_SYSI86 +#include "xf86.h" +#include "xf86Priv.h" +#include "xf86_OSlib.h" +#include "xf86OSpriv.h" + +#ifndef MAP_FAILED +#define MAP_FAILED ((void *)-1) +#endif + +static Bool +linearVidMem(void) +{ + return TRUE; +} + +static pointer +mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags) +{ + pointer base; + int fd; + + 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)); + } + base = mmap((caddr_t)0, Size, (flags & VIDMEM_READONLY) ? + PROT_READ : (PROT_READ | PROT_WRITE), + MAP_SHARED, fd, (off_t)Base); + close(fd); + + if (base == MAP_FAILED) { + FatalError("%s: Could not mmap framebuffer [s=%x,a=%x] (%s)\n", + "xf86MapVidMem", Size, Base, strerror(errno)); + } + return(base); +} + +/* ARGSUSED */ +static void +unmapVidMem(int ScreenNum, pointer Base, unsigned long Size) +{ + munmap(Base, Size); +} + +/* + * For some SVR4 versions, a 32-bit read is done for the first location + * in each page when the page is first mapped. If this is done while + * memory access is enabled for regions that have read side-effects, + * this can cause unexpected results, including lockups on some hardware. + * This function is called to make sure each page is mapped while it is + * safe to do so. + */ + +#define X_PAGE_SIZE 4096 + +static void +readSideEffects(int ScreenNum, pointer Base, unsigned long Size) +{ + unsigned long base, end, addr; + CARD32 val; + + base = (unsigned long)Base; + end = base + Size; + + for (addr = base; addr < end; addr += X_PAGE_SIZE) + val = *(volatile CARD32 *)addr; +} + +void +xf86OSInitVidMem(VidMemInfoPtr pVidMem) +{ + pVidMem->linearSupported = linearVidMem(); + pVidMem->mapMem = mapVidMem; + pVidMem->unmapMem = unmapVidMem; + pVidMem->readSideEffects = readSideEffects; + pVidMem->initialised = TRUE; +} + diff --git a/hw/xfree86/os-support/usl/usl_vtsw.c b/hw/xfree86/os-support/usl/usl_vtsw.c new file mode 100644 index 000000000..5c6673f31 --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_vtsw.c @@ -0,0 +1,97 @@ +/* $XdotOrg$ */ +/* + * Copyright 2005 by Kean Johnston + * Copyright 1993 by David Wexelblat + * Copyright 1993 by David McCullough + * + * 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$ */ + +#include "X.h" + +#include "xf86.h" +#include "xf86Priv.h" +#include "xf86_OSlib.h" + +/* + * Handle the VT-switching interface for SCO UnixWare / OpenServer 6 + */ + +/* + * 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 usl_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); +} + +static int usl_ledstatus = -1; +static unsigned int usl_ledstate = 0; + +Bool +xf86VTSwitchAway(void) +{ + usl_ledstatus = ioctl(xf86Info.consoleFd, KDGETLED, &usl_ledstate); + + xf86Info.vtRequestsPending = FALSE; + if (ioctl(xf86Info.consoleFd, VT_RELDISP, 1) < 0) { + return(FALSE); + } else { + return(TRUE); + } +} + +Bool +xf86VTSwitchTo(void) +{ + xf86Info.vtRequestsPending = FALSE; + if (ioctl(xf86Info.consoleFd, VT_RELDISP, VT_ACKACQ) < 0) { + return(FALSE); + } else { + if (usl_ledstatus >= 0) { + ioctl (xf86Info.consoleFd, KDSETLED, usl_ledstate); + } + usl_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/hw/xfree86/os-support/usl/usl_xqueue.c b/hw/xfree86/os-support/usl/usl_xqueue.c new file mode 100644 index 000000000..ccdbe8da4 --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_xqueue.c @@ -0,0 +1,363 @@ +/* $XdotOrg$ */ +/* + * Copyright 2005 by Kean Johnston + * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany + * Copyright 1993-1999 by The XFree86 Project, Inc. + * + * 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 the copyright holders not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The copyright holders make no + * representations about the suitability of this software for any purpose. + * It is provided "as is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS 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$ */ + +#include "X.h" +#include "compiler.h" + +#include "xf86.h" +#include "xf86Priv.h" +#include "xf86_OSlib.h" +#include "xf86Xinput.h" +#include "xf86OSmouse.h" +#include "xf86OSKbd.h" +#include "usl_xqueue.h" + +#ifdef XKB +#include "inputstr.h" +#include +#include +#include +extern Bool noXkbExtension; +#endif + +#include "xf86Xinput.h" +#include "mipointer.h" + +#if !defined(XQ_WHEEL) +# define XQ_WHEEL 4 +#endif + +/* + * Implementation notes + * + * This code is based on a mixture of the original XFree86 sysv/xqueue.c + * and information gathered from the SCO X server code (no actual code + * was used, just the principles). + * + * The XFree86 XQUEUE code went to some considerable lengths to implement + * what it calls "asynchronous XQUEUE". This involved creating a pipe, + * and writing to that pipe each time an XQUEUE signal is received. The + * one end of that pipe was then added to the list of selectable file + * descriptors with AddEnabledDevice(). I completely fail to see the need + * for this, and this code does not implement that mechanism. The server + * will be interrupted anyway by the XQUEUE driver, so whether we pull the + * events off the queue at the time we receive the signal or whether we + * write to a pipe and then have the main select() loop stop and call us, + * it makes no difference I can fathom. + * + * The code also differs from the original XFree86 code in that it maintains + * local variables for the number of devices initialized. The original code + * stored that information in the private data pointer of the mouse structure, + * but this same code is used for both the keyboard and the mouse, so that + * was changed. + * + * Part of the difficulty in dealing with XQUEUE is that it is a single + * interface to two devices. The recent changes in XFree86/Xorg try to + * treat the mouse and keyboard as discrete devices, and the code is + * structured in such a way that they should be able to be independently + * opened and closed. But we can't do that with XQUEUE, so we have to + * centralize XQUEUE access here in this module. + */ + +static xqEventQueue *xqQaddr = NULL; +static int xqSigEnable = 1; +static int xqEnableCount = 0; +static struct kd_quemode xqMode; + +/* + * These two pointers are set when the keyboard/mouse handler procs + * are called to turn them on or off. This is so that we can call the + * correct PostEvent for the device. + */ +static InputInfoPtr xqMouse = NULL; +static InputInfoPtr xqKeyboard = NULL; + +static void XqSignalHandler (int signo); + +/* + * Private functions + */ +static void +XqReset (void) +{ + if (xqEnableCount > 0) { + xqQaddr->xq_head = xqQaddr->xq_tail; + xqQaddr->xq_sigenable = xqSigEnable; + } +} + +#ifdef NOTNEEDED +static void +XqLock (void) +{ + xqSigEnable = 0; + if (xqEnableCount > 0) { + xqQaddr->xq_sigenable = xqSigEnable; + } +} + +static void +XqUnlock (void) +{ + xqSigEnable = 1; + if (xqEnableCount > 0) { + xqQaddr->xq_sigenable = xqSigEnable; + } +} +#endif /* NOTNEEDED */ + +/* + * Since this code is shared between two devices, we need to keep track + * of how many times we've been enabled or disabled. For example, if the + * keyboard has been turned off, but the mouse hasn't, then we do not + * want the whole queue off. Only when both devices are turned off do we + * actually disable Xqueue mode. When either device is turned on, we + * enable it. + */ +static int +XqEnable (InputInfoPtr pInfo) +{ + struct sigaction xqsig; + static int msefd = -1; + + if (msefd == -1) { + msefd = open ("/dev/mouse", O_RDONLY | O_NONBLOCK); +#if 0 + msefd = open ("/dev/mouse", O_RDONLY | O_NONBLOCK | O_NOCTTY); + if (msefd < 0) { + /* + * Try giving it a controlling tty + */ + msefd = open (ttyname(xf86Info.consoleFd), O_RDWR | O_NONBLOCK); + if (msefd >= 0) + close (msefd); + msefd = open ("/dev/mouse", O_RDONLY | O_NONBLOCK | O_NOCTTY); + if (msefd < 0) + sleep(2); + } +#endif + } + + if (msefd < 0) { + if (xf86GetAllowMouseOpenFail()) { + ErrorF("%s: cannot open /dev/mouse (%s)\n", + ttyname(xf86Info.consoleFd), strerror(errno)); + } else { + sleep(5); + FatalError ("%s: cannot open /dev/mouse (%s)\n", + ttyname(xf86Info.consoleFd), strerror(errno)); + } + } + + if (xqEnableCount++ == 0) { + xqMode.qaddr = 0; + ioctl (xf86Info.consoleFd, KDQUEMODE, NULL); + + /* + * Note: We need to make sure the signal is armed before we enable + * XQUEUE mode, so that if we get events immediately after the ioctl + * we dont have an unhandled signal coming to the Xserver. + * Also note that we use sigaction, so that we do not have to re-arm + * the signal every time it is delivered, which just slows things + * down (setting a signal is a fairly expensive operation). + */ + + xqsig.sa_handler = XqSignalHandler; + sigfillset (&xqsig.sa_mask); + xqsig.sa_flags = 0; + sigaction (SIGUSR2, &xqsig, NULL); + + /* + * This is a fairly large queue size. Since we are reacting to events + * asynchronously, its best for performance if we deal with as many + * events as possible, and high resolution mice generate a lot of + * events. + */ + xqMode.qsize = 64; + xqMode.signo = SIGUSR2; + xqMode.qaddr = 0; + if (ioctl (xf86Info.consoleFd, KDQUEMODE, &xqMode) < 0) { + xf86Msg (X_ERROR, "%s: could not set XQUEUE mode (%s)", pInfo->name, + strerror(errno)); + xqEnableCount--; + + xqsig.sa_handler = SIG_DFL; + sigfillset (&xqsig.sa_mask); + xqsig.sa_flags = 0; + sigaction (SIGUSR2, &xqsig, NULL); + + return !Success; + } + + /* + * We're in business. The workstation is now in XQUEUE mode. + */ + xqQaddr = (xqEventQueue *)xqMode.qaddr; + xqQaddr->xq_sigenable = 0; /* LOCK */ + nap(500); + XqReset(); + } + return Success; +} + +static int +XqDisable (InputInfoPtr pInfo) +{ + struct sigaction xqsig; + + if (xqEnableCount-- == 1) { + xqQaddr->xq_sigenable = 0; /* LOCK */ + + if (ioctl (xf86Info.consoleFd, KDQUEMODE, NULL) < 0) { + xf86Msg (X_ERROR, "%s: could not unset XQUEUE mode (%s)", pInfo->name, + strerror(errno)); + xqEnableCount++; + return !Success; + } + + xqsig.sa_handler = SIG_DFL; + sigfillset (&xqsig.sa_mask); + xqsig.sa_flags = 0; + sigaction (SIGUSR2, &xqsig, NULL); + } + + return Success; +} + +/* + * XQUEUE signal handler. This is what goes through the list of events + * we've already received and dispatches them to either the keyboard or + * mouse event poster. + */ +static void +XqSignalHandler (int signo) +{ + xqEvent *xqEvents = xqQaddr->xq_events; + int xqHead = xqQaddr->xq_head; + xEvent xE; + MouseDevPtr pMse = NULL; + KbdDevPtr pKbd = NULL; + signed char dx, dy; + + if (xqMouse) + pMse = (MouseDevPtr)xqMouse->private; + if (xqKeyboard) + pKbd = (KbdDevPtr)xqKeyboard->private; + + while (xqHead != xqQaddr->xq_tail) { + + switch (xqEvents[xqHead].xq_type) { + case XQ_MOTION: + dx = (signed char)xqEvents[xqHead].xq_x; + dy = (signed char)xqEvents[xqHead].xq_y; + if (pMse) + pMse->PostEvent(xqMouse, ~(xqEvents[xqHead].xq_code) & 0x07, + (int)dx, (int)dy, 0, 0); + break; + + case XQ_BUTTON: + if (pMse) + pMse->PostEvent(xqMouse, ~(xqEvents[xqHead].xq_code) & 0x07, + 0, 0, 0, 0); + break; + + case XQ_WHEEL: + if (pMse) { + int wbut = pMse->lastButtons; + if (xqEvents[xqHead].xq_code == 1) + wbut |= 0x80; + else + wbut |= 0x40; + pMse->PostEvent(xqMouse, wbut, 0, 0, 0, 0); + /* Simulate button release */ + wbut &= ~0xc0; + pMse->PostEvent(xqMouse, wbut, 0, 0, 0, 0); + } + break; + + case XQ_KEY: + if (pKbd) + pKbd->PostEvent(xqKeyboard, xqEvents[xqHead].xq_code & 0x7f, + xqEvents[xqHead].xq_code & 0x80 ? FALSE : TRUE); + break; + + default: + xf86Msg(X_WARNING, "XQUEUE: unknown event type %d\n", + xqEvents[xqHead].xq_type); + break; + } + + xqHead++; + if (xqHead == xqQaddr->xq_size) + xqHead = 0; + xf86Info.inputPending = TRUE; + } + + XqReset(); +} + +/* + * Public functions + */ +int +XqMseOnOff (InputInfoPtr pInfo, int on) +{ + if (on) { + if (xqMouse) { + if (xqMouse != pInfo) + xf86Msg(X_WARNING, "XqMseOnOff: mouse pointer structure changed!\n"); + xqMouse = pInfo; + } else { + xqMouse = pInfo; + return XqEnable(pInfo); + } + } else { + xqMouse = NULL; + return XqDisable(pInfo); + } + return Success; +} + +int +XqKbdOnOff (InputInfoPtr pInfo, int on) +{ + if (on) { + if (xqKeyboard) { + if (xqKeyboard != pInfo) + xf86Msg(X_WARNING, "XqKbdOnOff: keyboard pointer structure changed!\n"); + xqKeyboard = pInfo; + } else { + xqKeyboard = pInfo; + return XqEnable(pInfo); + } + } else { + xqKeyboard = NULL; + return XqDisable(pInfo); + } + return Success; +} + diff --git a/hw/xfree86/os-support/usl/usl_xqueue.h b/hw/xfree86/os-support/usl/usl_xqueue.h new file mode 100644 index 000000000..bad86a907 --- /dev/null +++ b/hw/xfree86/os-support/usl/usl_xqueue.h @@ -0,0 +1,9 @@ +/* $XdotOrg$ */ + +#ifndef _XF86_USL_XQUEUE_H_ +#define _XF86_USL_XQUEUE_H_ + +extern int XqMseOnOff (InputInfoPtr pInfo, int on); +extern int XqKbdOnOff (InputInfoPtr pInfo, int on); + +#endif diff --git a/hw/xfree86/os-support/xf86_OSlib.h b/hw/xfree86/os-support/xf86_OSlib.h index c86247a46..a154c6a13 100644 --- a/hw/xfree86/os-support/xf86_OSlib.h +++ b/hw/xfree86/os-support/xf86_OSlib.h @@ -118,7 +118,7 @@ typedef signed long xf86ssize_t; # include # include # include -# if defined(SCO) || defined(ISC) +# if defined(__SCO__) || defined(ISC) # include # endif @@ -176,7 +176,7 @@ typedef signed long xf86ssize_t; # if !defined(sun) # include # endif -# if defined(SCO) +# if defined(SCO325) # include # include # include @@ -203,16 +203,16 @@ typedef signed long xf86ssize_t; # define LED_NUM LED_NUM_LOCK # define LED_SCR LED_SCROLL_LOCK # define LED_COMP LED_COMPOSE -# endif /* SCO */ +# endif /* sun */ # if !defined(VT_ACKACQ) # define VT_ACKACQ 2 # endif /* !VT_ACKACQ */ -# if defined(SCO) +# if defined(__SCO__) # include # define POSIX_TTY -# endif /* SCO */ +# endif /* __SCO__ */ # if defined(SVR4) || defined(SCO325) # include @@ -243,9 +243,11 @@ typedef signed long xf86ssize_t; # define i386 /* not defined in ANSI C mode */ # endif /* ATT && !i386 */ -# if (defined(ATT) || defined(SVR4)) && !defined(sun) && !defined(SCO325) -# ifndef XQUEUE -# define XQUEUE +# if (defined(ATT) || defined(SVR4)) && !defined(sun) +# ifndef __UNIXWARE__ +# ifndef XQUEUE +# define XQUEUE +# endif # endif # include # endif /* ATT || SVR4 */ diff --git a/hw/xfree86/os-support/xf86_OSproc.h b/hw/xfree86/os-support/xf86_OSproc.h index 74ec766e2..83ce9ed2b 100644 --- a/hw/xfree86/os-support/xf86_OSproc.h +++ b/hw/xfree86/os-support/xf86_OSproc.h @@ -136,6 +136,10 @@ extern void xf86WrapperInit(void); #include #include "opaque.h" +#if defined(XQUEUE) +#include "input.h" /* for DeviceIntPtr */ +#endif + _XFUNCPROTOBEGIN /* public functions */ diff --git a/hw/xfree86/os-support/xf86_ansic.h b/hw/xfree86/os-support/xf86_ansic.h index 733a5543d..c4090dc16 100644 --- a/hw/xfree86/os-support/xf86_ansic.h +++ b/hw/xfree86/os-support/xf86_ansic.h @@ -55,7 +55,8 @@ #if defined(XFree86LOADER) || defined(NEED_XF86_TYPES) -#if !defined(SYSV) && !defined(SVR4) && !defined(Lynx) || defined(SCO) +#if !defined(SYSV) && !defined(SVR4) && !defined(Lynx) || \ + defined(__SCO__) || defined(__UNIXWARE__) #define HAVE_VSSCANF #define HAVE_VFSCANF #endif diff --git a/hw/xfree86/parser/Monitor.c b/hw/xfree86/parser/Monitor.c index 8669471a7..52ff5a735 100644 --- a/hw/xfree86/parser/Monitor.c +++ b/hw/xfree86/parser/Monitor.c @@ -676,16 +676,16 @@ xf86printMonitorSection (FILE * cf, XF86ConfMonitorPtr ptr) ptr->mon_width, ptr->mon_height); if ( ptr->mon_n_hsync || ptr->mon_n_vrefresh ) - fprintf(cf," ### Uncomment if you don't want to default to DDC:\n"); + fprintf(cf," ### Comment all HorizSync and VertSync values to use DDC:\n"); for (i = 0; i < ptr->mon_n_hsync; i++) { - fprintf (cf, "#\tHorizSync %2.1f - %2.1f\n", + fprintf (cf, "\tHorizSync %2.1f - %2.1f\n", ptr->mon_hsync[i].lo, ptr->mon_hsync[i].hi); } for (i = 0; i < ptr->mon_n_vrefresh; i++) { - fprintf (cf, "#\tVertRefresh %2.1f - %2.1f\n", + fprintf (cf, "\tVertRefresh %2.1f - %2.1f\n", ptr->mon_vrefresh[i].lo, ptr->mon_vrefresh[i].hi); } diff --git a/hw/xfree86/utils/xorgcfg/cards.c b/hw/xfree86/utils/xorgcfg/cards.c index a1ec65c85..62bcfbbda 100644 --- a/hw/xfree86/utils/xorgcfg/cards.c +++ b/hw/xfree86/utils/xorgcfg/cards.c @@ -489,6 +489,9 @@ LookupCard(char *name) { CardsEntry **ptr; + if (NumCardsEntry == 0 || CardsDB == 0) + return NULL; + ptr = (CardsEntry**)bsearch(name, CardsDB, NumCardsEntry, sizeof(CardsEntry*), BCompareCards); diff --git a/hw/xfree86/utils/xorgcfg/interface.c b/hw/xfree86/utils/xorgcfg/interface.c index 0bc6a5dd9..e329d909f 100644 --- a/hw/xfree86/utils/xorgcfg/interface.c +++ b/hw/xfree86/utils/xorgcfg/interface.c @@ -68,6 +68,9 @@ #define DefaultXFree86Dir "/usr/X11R6" #endif +#define IS_KBDDRIV(S) ((strcasecmp((S),"kbd") == 0) || \ + (strcasecmp((S), "keyboard") == 0)) + /* * Prototypes */ @@ -791,7 +794,7 @@ InitializeDevices(void) mouse_x = work->core.width - (work->core.width >> 2); } } - else if (strcasecmp(input->inp_driver, "keyboard") == 0) { + else if (IS_KBDDRIV(input->inp_driver)) { device = AddDevice(KEYBOARD, (XtPointer)input, keyboard_x, keyboard_y); SetTip(device); if ((keyboard_x += DEFAULT_KEYBOARD_WIDTH) > @@ -1645,8 +1648,7 @@ EnableDeviceCallback(Widget w, XtPointer user_data, XtPointer call_data) while (nex != NULL) { if (strcasecmp(nex->iref_inputdev->inp_driver, "mouse") == 0) ++nmouses; - else if (strcasecmp(nex->iref_inputdev->inp_driver, - "keyboard") == 0) + else if (IS_KBDDRIV(nex->iref_inputdev->inp_driver)) ++nkeyboards; iref = nex; nex = (XF86ConfInputrefPtr)(nex->list.next); diff --git a/hw/xfree86/utils/xorgcfg/keyboard-cfg.c b/hw/xfree86/utils/xorgcfg/keyboard-cfg.c index b8697c11f..334070d4e 100644 --- a/hw/xfree86/utils/xorgcfg/keyboard-cfg.c +++ b/hw/xfree86/utils/xorgcfg/keyboard-cfg.c @@ -38,6 +38,9 @@ #include #include +#define IS_KBDDRIV(X) ((strcasecmp((X),"kbd") == 0) || \ + (strcasecmp((X), "keyboard") == 0)) + /* * Types */ @@ -159,8 +162,7 @@ KeyboardConfig(XtPointer config) XF86ConfInputPtr key = XF86Config->conf_input_lst; while (key != NULL) { - if (strcasecmp(key->inp_driver, "keyboard") == 0 && - xkb_infos[i]->conf == key) + if (IS_KBDDRIV(key->inp_driver) && xkb_infos[i]->conf == key) break; key = (XF86ConfInputPtr)(key->list.next); } @@ -216,7 +218,7 @@ KeyboardConfig(XtPointer config) int nkeyboards = 0; while (input != NULL) { - if (strcasecmp(input->inp_driver, "keyboard") == 0) + if (IS_KBDDRIV(input->inp_driver)) ++nkeyboards; input = (XF86ConfInputPtr)(input->list.next); } @@ -253,7 +255,11 @@ KeyboardConfig(XtPointer config) keyboard = XtNew(XF86ConfInputRec); keyboard->list.next = NULL; keyboard->inp_identifier = XtNewString(ident_string); +#if defined(USE_DEPRECATED_KEYBOARD_DRIVER) keyboard->inp_driver = XtNewString("keyboard"); +#else + keyboard->inp_driver = XtNewString("kbd"); +#endif keyboard->inp_option_lst = xf86newOption(XtNewString(XkbRules), XtNewString(rules)); xf86addNewOption(keyboard->inp_option_lst, @@ -493,7 +499,7 @@ InitializeKeyboard(void) /* XXX Assumes the first keyboard is the core keyboard */ while (keyboard != NULL) { - if (strcasecmp(keyboard->inp_driver, "keyboard") == 0) + if (IS_KBDDRIV(keyboard->inp_driver)) break; keyboard = (XF86ConfInputPtr)(keyboard->list.next); } diff --git a/hw/xfree86/utils/xorgcfg/mouse-cfg.c b/hw/xfree86/utils/xorgcfg/mouse-cfg.c index 0f646828f..49bfc61a2 100644 --- a/hw/xfree86/utils/xorgcfg/mouse-cfg.c +++ b/hw/xfree86/utils/xorgcfg/mouse-cfg.c @@ -58,9 +58,12 @@ static struct MouseProtocol { #ifdef __UNIXOS2__ {"OS2Mouse", MTYPE_AUTOMOUSE}, #endif -#ifdef SCO +#ifdef __SCO__ {"OsMouse", MTYPE_AUTOMOUSE}, #endif +#if defined(__UNIXWARE__) + {"Xqueue", MTYPE_XQUEUE}, +#endif #ifdef WSCONS_SUPPORT {"wsmouse", MTYPE_AUTOMOUSE}, #endif diff --git a/hw/xfree86/utils/xorgcfg/text-mode.c b/hw/xfree86/utils/xorgcfg/text-mode.c index 1c7f69f4f..5be13b40a 100644 --- a/hw/xfree86/utils/xorgcfg/text-mode.c +++ b/hw/xfree86/utils/xorgcfg/text-mode.c @@ -33,7 +33,8 @@ #include #include #include -#if defined(_SCO_DS) || (defined(sun) && defined(__SVR4)) +#if defined(__SCO__) || defined(__UNIXWARE__) || \ + (defined(sun) && defined(__SVR4)) #include #else #include @@ -47,6 +48,9 @@ #include "xf86config.h" #include "loader.h" +#define IS_KBDDRIV(X) ((strcmp((X),"kbd") == 0) || \ + (strcmp((X), "keyboard") == 0)) + #ifndef PROJECT_ROOT #define PROJECT_ROOT "/usr/X11R6" #endif @@ -201,16 +205,21 @@ TextMode(void) ClearScreen(); refresh(); - if (Dialog( __XSERVERNAME__"Configuration", + if (Dialog( __XSERVERNAME__" Configuration", "This program will create the "__XCONFIGFILE__" file, based on " "menu selections you make.\n" "\n" +#if defined(__SCO__) || defined(__UNIXWARE__) + "The "__XCONFIGFILE__" file usually resides in /etc. A " + "sample "__XCONFIGFILE__" file is supplied with " +#else #ifndef __UNIXOS2__ "The "__XCONFIGFILE__" file usually resides in /usr/X11R6/etc/X11 " #else "The "__XCONFIGFILE__" file usually resides in "XF86CONFIGDIR" " #endif "or /etc/X11. A sample "__XCONFIGFILE__" file is supplied with " +#endif __XSERVERNAME__"; it is configured for a standard VGA card and " "monitor with 640x480 resolution. This program will ask for " "a pathname when it is ready to write the file.\n" @@ -350,9 +359,12 @@ static char *protocols[] = { #ifdef __UNIXOS2__ "OS2Mouse", #endif -#ifdef SCO +#ifdef __SCO__ "OsMouse", #endif +#ifdef __UNIXWARE__ + "Xqueue", +#endif #ifdef WSCONS_SUPPORT "wsmouse", #endif @@ -611,7 +623,7 @@ KeyboardConfig(void) nlist = 0; while (input) { - if (strcmp(input->inp_driver, "keyboard") == 0) { + if (IS_KBDDRIV(input->inp_driver)) { list = (char**)XtRealloc((XtPointer)list, (nlist + 1) * sizeof(char*)); list[nlist] = XtMalloc(sizeof(Edit) + strlen(input->inp_identifier) + 1); @@ -730,7 +742,11 @@ KeyboardConfig(void) input->inp_option_lst = xf86addNewOption(input->inp_option_lst, XtNewString("XkbLayout"), XtNewString("us")); +#if defined(USE_DEPRECATED_KEYBOARD_DRIVER) input->inp_driver = XtNewString("keyboard"); +#else + input->inp_driver = XtNewString("kbd"); +#endif XF86Config->conf_input_lst = xf86addInput(XF86Config, input); } @@ -806,7 +822,11 @@ KeyboardConfig(void) XtNewString("XkbLayout"), XtNewString(layout)); if (input->inp_driver == NULL) { +#if defined(USE_DEPRECATED_KEYBOARD_DRIVER) input->inp_driver = XtNewString("keyboard"); +#else + input->inp_driver = XtNewString("kbd"); +#endif XF86Config->conf_input_lst = xf86addInput(XF86Config->conf_input_lst, input); } @@ -1884,7 +1904,7 @@ LayoutConfig(void) mouses[nmouses] = input; ++nmouses; } - else if (strcmp(input->inp_driver, "keyboard") == 0) { + else if (IS_KBDDRIV(input->inp_driver)) { keyboards = (XF86ConfInputPtr*)XtRealloc((XtPointer)keyboards, (nkeyboards + 1) * sizeof(XF86ConfInputPtr)); keyboards[nkeyboards] = input; @@ -2119,7 +2139,7 @@ LayoutConfig(void) piref = NULL; iref = layout->lay_input_lst; while (iref) { - if (strcmp(iref->iref_inputdev->inp_driver, "keyboard") == 0) { + if (IS_KBDDRIV(iref->iref_inputdev->inp_driver)) { if (keyboard == NULL) piref = iref; if (xf86findOption(iref->iref_option_lst, "CoreKeyboard")) { @@ -2165,7 +2185,7 @@ LayoutConfig(void) list[nlist++] = keyboard->inp_identifier; input = XF86Config->conf_input_lst; while (input) { - if (input != keyboard && strcmp(input->inp_driver, "keyboard") == 0) { + if (input != keyboard && IS_KBDDRIV(input->inp_driver)) { list = (char**)XtRealloc((XtPointer)list, (nlist + 1) * sizeof(char*)); list[nlist++] = input->inp_identifier; } @@ -3206,6 +3226,9 @@ DialogInput(char *title, char *prompt, int height, int width, char *init, continue; case KEY_BACKSPACE: case 0177: +#if defined(__SCO__) || defined(__UNIXWARE__) + case '\b': +#endif if (input_x || scrlx) { wattrset(dialog, dialog_attr); diff --git a/hw/xfree86/utils/xorgconfig/xorgconfig.c b/hw/xfree86/utils/xorgconfig/xorgconfig.c index db8b51bd8..227803c29 100644 --- a/hw/xfree86/utils/xorgconfig/xorgconfig.c +++ b/hw/xfree86/utils/xorgconfig/xorgconfig.c @@ -2134,8 +2134,13 @@ static char *pointersection_text1 = "\n" "# Identifier and driver\n" "\n" +#if defined(__UNIXWARE__) || defined(XQUEUE) +"# Identifier \"Mouse1\"\n" +"# Driver \"mouse\"\n" +#else " Identifier \"Mouse1\"\n" " Driver \"mouse\"\n" +#endif ; static char *pointersection_text2 = @@ -2143,7 +2148,11 @@ static char *pointersection_text2 = "# When using XQUEUE, comment out the above two lines, and uncomment\n" "# the following line.\n" "\n" +#if defined(__UNIXWARE__) || defined(XQUEUE) +" Option \"Protocol\" \"Xqueue\"\n" +#else "# Option \"Protocol\" \"Xqueue\"\n" +#endif "\n" "# Mouse-speed setting for PS/2 mouse.\n" "\n" diff --git a/hw/xfree86/vbe/vbe.h b/hw/xfree86/vbe/vbe.h index 32515462e..c7970abd0 100644 --- a/hw/xfree86/vbe/vbe.h +++ b/hw/xfree86/vbe/vbe.h @@ -60,8 +60,7 @@ typedef struct vbeControllerInfoBlock { CARD8 OemData[256]; } vbeControllerInfoRec, *vbeControllerInfoPtr; -#if defined(__GNUC__) || defined(SCO) || defined(__USLC__) || \ - defined(__SUNPRO_C) +#if defined(__GNUC__) || defined(__USLC__) || defined(__SUNPRO_C) #pragma pack() /* All GCC versions recognise this syntax */ #else #pragma pack(0) diff --git a/include/os.h b/include/os.h index 7823b795d..0b3354eec 100644 --- a/include/os.h +++ b/include/os.h @@ -93,7 +93,7 @@ typedef struct _NewClientRec *NewClientPtr; #endif #ifndef IN_MODULE -#ifdef SCO +#ifdef __SCO__ #include #endif #include diff --git a/os/access.c b/os/access.c index 329d1cfea..80430fb3d 100644 --- a/os/access.c +++ b/os/access.c @@ -84,9 +84,9 @@ SOFTWARE. #include #include -#if defined(TCPCONN) || defined(STREAMSCONN) || defined(ISC) || defined(SCO) +#if defined(TCPCONN) || defined(STREAMSCONN) || defined(ISC) || defined(__SCO__) #include -#endif /* TCPCONN || STREAMSCONN || ISC || SCO */ +#endif /* TCPCONN || STREAMSCONN || ISC || __SCO__ */ #ifdef DNETCONN #include #include @@ -138,9 +138,7 @@ SOFTWARE. #endif /* hpux */ #ifdef SVR4 -#ifndef SCO #include -#endif #include #endif @@ -193,6 +191,11 @@ SOFTWARE. #endif #endif +#ifdef __SCO__ +/* The system defined value is wrong. MAXPATHLEN is set in sco5.cf. */ +#undef PATH_MAX +#endif + #define X_INCLUDE_NETDB_H #include diff --git a/os/osinit.c b/os/osinit.c index f9e253f2d..ea99ace21 100644 --- a/os/osinit.c +++ b/os/osinit.c @@ -69,7 +69,7 @@ SOFTWARE. #endif #endif -#if defined(Lynx) || defined(SCO) || defined(SCO325) +#if defined(Lynx) || defined(__SCO__) #include #endif @@ -114,7 +114,7 @@ OsInit(void) #ifdef XFree86LOADER xf86WrapperInit(); #endif -#if !defined(SCO) && !defined(__CYGWIN__) +#if !defined(__SCO__) && !defined(__CYGWIN__) && !defined(__UNIXWARE__) fclose(stdin); fclose(stdout); #endif diff --git a/os/utils.c b/os/utils.c index f23e1036c..4c794c2c9 100644 --- a/os/utils.c +++ b/os/utils.c @@ -2238,3 +2238,53 @@ CheckUserAuthorization(void) } #endif } + +#ifdef __SCO__ +#include + +static void +lockit (int fd, short what) +{ + struct flock lck; + + lck.l_whence = 0; + lck.l_start = 0; + lck.l_len = 1; + lck.l_type = what; + + (void)fcntl (fd, F_SETLKW, &lck); +} + +/* SCO OpenServer 5 lacks pread/pwrite. Emulate them. */ +ssize_t +pread (int fd, void *buf, size_t nbytes, off_t offset) +{ + off_t saved; + ssize_t ret; + + lockit (fd, F_RDLCK); + saved = lseek (fd, 0, SEEK_CUR); + lseek (fd, offset, SEEK_SET); + ret = read (fd, buf, nbytes); + lseek (fd, saved, SEEK_SET); + lockit (fd, F_UNLCK); + + return ret; +} + +ssize_t +pwrite (int fd, const void *buf, size_t nbytes, off_t offset) +{ + off_t saved; + ssize_t ret; + + lockit (fd, F_WRLCK); + saved = lseek (fd, 0, SEEK_CUR); + lseek (fd, offset, SEEK_SET); + ret = write (fd, buf, nbytes); + lseek (fd, saved, SEEK_SET); + lockit (fd, F_UNLCK); + + return ret; +} +#endif /* __SCO__ */ -- cgit v1.2.3