diff options
Diffstat (limited to 'nx-X11/programs/Xserver/hw/xfree86/os-support/sysv')
7 files changed, 1378 insertions, 0 deletions
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/Imakefile b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/Imakefile new file mode 100644 index 000000000..2ba9baf92 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/Imakefile @@ -0,0 +1,58 @@ +XCOMM $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sysv/Imakefile,v 3.24 2002/10/11 01:47:00 dawes Exp $ + + + + + +XCOMM $XConsortium: Imakefile /main/10 1996/10/25 11:38:05 kaleb $ + +#include <Server.tmpl> + +#if defined(SVR4Architecture) || defined(i386Sco325Architecture) +BIOS_MOD = bios_mmap +#else +BIOS_MOD = bios_devmem +#endif + +MOUSESRC = sysv_mouse.c +MOUSEOBJ = sysv_mouse.o + +SRCS = sysv_init.c sysv_video.c sysv_io.c $(BIOS_MOD).c VTsw_usl.c \ + sysv_kbd.c std_kbdEv.c posix_tty.c $(MOUSESRC) xqueue.c \ + libc_wrapper.c stdResource.c stdPci.c vidmem.c sigiostubs.c pm_noop.c \ + kmod_noop.c agp_noop.c + +OBJS = sysv_init.o sysv_video.o sysv_io.o $(BIOS_MOD).o VTsw_usl.o \ + sysv_kbd.o std_kbdEv.o posix_tty.o $(MOUSEOBJ) xqueue.o \ + libc_wrapper.o stdResource.o stdPci.o vidmem.o sigiostubs.o pm_noop.o \ + kmod_noop.o agp_noop.o + +INCLUDES = -I$(XF86COMSRC) -I$(XF86OSSRC) -I. -I$(SERVERSRC)/include \ + -I$(XINCLUDESRC) -I$(EXTINCSRC) -I$(SERVERSRC)/mi + +RESDEFINES = -DUSESTDRES + +DEFINES = $(RESDEFINES) + +SubdirLibraryRule($(OBJS)) +NormalLibraryObjectRule() + +#if !defined(SVR4Architecture) +LinkSourceFile(bios_devmem.c,../shared) +#else +LinkSourceFile(bios_mmap.c,../shared) +#endif +LinkSourceFile(VTsw_usl.c,../shared) +LinkSourceFile(sysv_kbd.c,../shared) +LinkSourceFile(std_kbdEv.c,../shared) +LinkSourceFile(posix_tty.c,../shared) +LinkSourceFile(libc_wrapper.c,../shared) +LinkSourceFile(stdResource.c,../shared) +LinkSourceFile(stdPci.c,../shared) +LinkSourceFile(vidmem.c,../shared) +LinkSourceFile(sigiostubs.c,../shared) +LinkSourceFile(pm_noop.c,../shared) +LinkSourceFile(kmod_noop.c,../shared) +LinkSourceFile(agp_noop.c,../shared) + +DependTarget() diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_init.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_init.c new file mode 100644 index 000000000..3edffd446 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_init.c @@ -0,0 +1,254 @@ +/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sysv/sysv_init.c,v 3.4.4.3 1998/07/18 17:53:57 dawes Exp $ */ +/* + * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany + * Copyright 1993 by David Wexelblat <dwex@goblin.org> + * + * 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 and David Wexelblat + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. Thomas Roell and + * David Wexelblat makes no representations about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + * + * THOMAS ROELL AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR 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: sysv_init.c /main/4 1996/02/21 17:54:31 kaleb $ */ + +#ifdef HAVE_XORG_CONFIG_H +#include <xorg-config.h> +#endif + +#include <X11/X.h> +#include <X11/Xmd.h> + +#include "compiler.h" + +#include "xf86.h" +#include "xf86Priv.h" +#include "xf86_OSlib.h" + +static Bool KeepTty = FALSE; +#ifdef SVR4 +static Bool Protect0 = FALSE; +#endif +static int VTnum = -1; + + +void +xf86OpenConsole() +{ + int fd; + struct vt_mode VT; + char vtname1[10],vtname2[10]; + MessageType from = X_PROBED; + + if (serverGeneration == 1) + { + /* check if we're run with euid==0 */ + if (geteuid() != 0) + { + FatalError("xf86OpenConsole: Server must be suid root\n"); + } + +#ifdef SVR4 + /* 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); + } + } +#endif + /* + * setup the virtual terminal manager + */ + if (VTnum != -1) + { + xf86Info.vtno = VTnum; + from = X_CMDLINE; + } + else + { + if ((fd = open("/dev/console",O_WRONLY,0)) < 0) + { + FatalError( + "xf86OpenConsole: Cannot open /dev/console (%s)\n", + strerror(errno)); + } + if ((ioctl(fd, VT_OPENQRY, &xf86Info.vtno) < 0) || + (xf86Info.vtno == -1)) + { + FatalError("xf86OpenConsole: Cannot find a free VT\n"); + } + close(fd); + } + xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno); + + sprintf(vtname1,"/dev/vc%02d",xf86Info.vtno); /* ESIX */ + sprintf(vtname2,"/dev/vt%02d",xf86Info.vtno); /* rest of the world */ + + if (!KeepTty) + { + setpgrp(); + } + + if (((xf86Info.consoleFd = open(vtname1, O_RDWR|O_NDELAY, 0)) < 0) && + ((xf86Info.consoleFd = open(vtname2, O_RDWR|O_NDELAY, 0)) < 0)) + { + FatalError("xf86OpenConsole: Cannot open %s (%s) (%s)\n", + vtname2, vtname1, strerror(errno)); + } + + /* change ownership of the vt */ + if (chown(vtname1, getuid(), getgid()) < 0) + { + chown(vtname2, getuid(), getgid()); + } + + /* + * now get the VT + */ + if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) + { + xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n"); + } + if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) != 0) + { + xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed\n"); + } + if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) < 0) + { + FatalError("xf86OpenConsole: VT_GETMODE failed\n"); + } + + signal(SIGUSR1, xf86VTRequest); + + VT.mode = VT_PROCESS; + VT.relsig = SIGUSR1; + VT.acqsig = SIGUSR1; + if (ioctl(xf86Info.consoleFd, VT_SETMODE, &VT) < 0) + { + FatalError("xf86OpenConsole: VT_SETMODE VT_PROCESS failed\n"); + } + if (ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS) < 0) + { + FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed\n"); + } + } + else + { + /* serverGeneration != 1 */ + /* + * now get the VT + */ + if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno) != 0) + { + xf86Msg(X_WARNING, "xf86OpenConsole: VT_ACTIVATE failed\n"); + } + if (ioctl(xf86Info.consoleFd, VT_WAITACTIVE, xf86Info.vtno) != 0) + { + xf86Msg(X_WARNING, "xf86OpenConsole: VT_WAITACTIVE failed\n"); + } + /* + * 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() +{ + struct vt_mode VT; + +#if 0 + ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno); + ioctl(xf86Info.consoleFd, VT_WAITACTIVE, 0); +#endif + ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT); /* Back to text mode ... */ + if (ioctl(xf86Info.consoleFd, VT_GETMODE, &VT) != -1) + { + VT.mode = VT_AUTO; + 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); + } +#ifdef SVR4 + /* + * 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); + } +#endif + if ((argv[i][0] == 'v') && (argv[i][1] == 't')) + { + if (sscanf(argv[i], "vt%2d", &VTnum) == 0) + { + UseMsg(); + VTnum = -1; + return(0); + } + return(1); + } + return(0); +} + +void +xf86UseMsg() +{ + ErrorF("vtXX use the specified VT number\n"); + ErrorF("-keeptty "); + ErrorF("don't detach controlling tty (for debugging only)\n"); + return; +} diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_io.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_io.c new file mode 100644 index 000000000..6fb642bce --- /dev/null +++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_io.c @@ -0,0 +1,78 @@ +/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sysv/sysv_io.c,v 3.10 2002/10/11 01:40:37 dawes Exp $ */ +/* + * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany + * Copyright 1993 by David Dawes <dawes@xfree86.org> + * + * 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 and David Dawes + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. Thomas Roell and + * David Dawes makes no representations about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + * + * THOMAS ROELL AND DAVID DAWES DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR DAVID DAWES 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: sysv_io.c /main/8 1996/10/19 18:08:06 kaleb $ */ + +#ifdef HAVE_XORG_CONFIG_H +#include <xorg-config.h> +#endif + +#include <X11/X.h> + +#include "compiler.h" + +#include "xf86.h" +#include "xf86Priv.h" +#include "xf86_OSlib.h" + +void +xf86SoundKbdBell(int loudness, int pitch, int duration) +{ + if (loudness && pitch) + { +#ifdef KDMKTONE + /* + * If we have KDMKTONE use it to avoid putting the server + * to sleep + */ + ioctl(xf86Info.consoleFd, KDMKTONE, + ((1193190 / pitch) & 0xffff) | + (((unsigned long)duration * + loudness / 50) << 16)); +#else + ioctl(xf86Info.consoleFd, KIOCSOUND, 1193180 / pitch); + usleep(xf86Info.bell_duration * loudness * 20); + ioctl(xf86Info.consoleFd, KIOCSOUND, 0); +#endif + } +} + +void +xf86SetKbdLeds(int leds) +{ +#ifdef KBIO_SETMODE + ioctl(xf86Info.consoleFd, KBIO_SETMODE, KBM_AT); + ioctl(xf86Info.consoleFd, KDSETLED, leds); + ioctl(xf86Info.consoleFd, KBIO_SETMODE, KBM_XT); +#endif +} + +#include "xf86OSKbd.h" + +Bool +xf86OSKbdPreInit(InputInfoPtr pInfo) +{ + return FALSE; +} diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_mouse.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_mouse.c new file mode 100644 index 000000000..f839362fc --- /dev/null +++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_mouse.c @@ -0,0 +1,64 @@ +/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sysv/sysv_mouse.c,v 1.3 1999/09/04 13:04:49 dawes Exp $ */ + +/* + * Copyright 1999 by The XFree86 Project, Inc. + */ + +#ifdef HAVE_XORG_CONFIG_H +#include <xorg-config.h> +#endif + +#include <X11/X.h> +#include "xf86.h" +#include "xf86Xinput.h" +#include "xf86OSmouse.h" +#include "xqueue.h" + +static int +SupportedInterfaces(void) +{ + /* XXX Need to check this. */ + return MSE_SERIAL | MSE_AUTO; +} + +#ifndef ISC +static const char *internalNames[] = { + "Xqueue", + NULL +}; + +static const char ** +BuiltinNames(void) +{ + return internalNames; +} + +static Bool +CheckProtocol(const char *protocol) +{ + int i; + + for (i = 0; internalNames[i]; i++) + if (xf86NameCmp(protocol, internalNames[i]) == 0) + return TRUE; + return FALSE; +} +#endif + +OSMouseInfoPtr +xf86OSMouseInit(int flags) +{ + OSMouseInfoPtr p; + + p = xcalloc(sizeof(OSMouseInfoRec), 1); + if (!p) + return NULL; + p->SupportedInterfaces = SupportedInterfaces; +#ifndef ISC + p->BuiltinNames = BuiltinNames; + p->CheckProtocol = CheckProtocol; + p->PreInit = XqueueMousePreInit; +#endif + return p; +} + diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_video.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_video.c new file mode 100644 index 000000000..e8c26dada --- /dev/null +++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/sysv_video.c @@ -0,0 +1,369 @@ +/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sysv/sysv_video.c,v 3.20tsi Exp $ */ +/* + * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany + * Copyright 1993 by David Wexelblat <dwex@goblin.org> + * + * 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 and David Wexelblat + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. Thomas Roell and + * David Wexelblat makes no representations about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + * + * THOMAS ROELL AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR 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: sysv_video.c /main/8 1996/10/25 11:38:09 kaleb $ */ + +#ifdef HAVE_XORG_CONFIG_H +#include <xorg-config.h> +#endif + +#include <X11/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 + +#ifndef SI86IOPL +#define SET_IOPL() sysi86(SI86V86,V86SC_IOPL,PS_IOPL) +#define RESET_IOPL() sysi86(SI86V86,V86SC_IOPL,0) +#else +#define SET_IOPL() sysi86(SI86IOPL,3) +#define RESET_IOPL() sysi86(SI86IOPL,0) +#endif + +/***************************************************************************/ +/* Video Memory Mapping section */ +/***************************************************************************/ + +/* + * XXX Support for SVR3 will need to be reworked if needed. In particular + * the Region parameter is no longer passed, and will need to be dealt + * with internally if required. + * OK, i'll rework that thing ... (clean it up a lot) + * SVR3 Support only with SVR3_MMAPDRV (mr) + * + */ + +#ifdef HAS_SVR3_MMAPDRV +#ifndef MMAP_DEBUG +#define MMAP_DEBUG 3 +#endif + +struct kd_memloc MapDSC; +int mmapFd = -2; + +static int +mmapStat(pointer Base, unsigned long Size) { + + int nmmreg,i=0,region=-1; + mmapinfo_t *ibuf; + + nmmreg = ioctl(mmapFd, GETNMMREG); + + if(nmmreg <= 0) + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "\nNo physical memory mapped currently.\n\n"); + else { + if((ibuf = (mmapinfo_t *)malloc(nmmreg*sizeof(mmapinfo_t))) == NULL) + xf86Msg(X_WARNING, + "Couldn't allocate memory 4 mmapinfo_t\n"); + else { + if(ioctl(mmapFd, GETMMREG, ibuf) != -1) + { + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "# mmapStat: [Size=%x,Base=%x]\n", Size, Base); + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "# Physical Address Size Reference Count\n"); + for(i = 0; i < nmmreg; i++) { + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "%-4d 0x%08X %5dk %5d ", + i, ibuf[i].physaddr, ibuf[i].length/1024, ibuf[i].refcnt); + if (ibuf[i].physaddr == Base || ibuf[i].length == Size ) { + xf86MsgVerb(X_INFO, MMAP_DEBUG,"MATCH !!!"); + if (region==-1) region=i; + } + xf86ErrorFVerb(MMAP_DEBUG, "\n"); + } + xf86ErrorFVerb(MMAP_DEBUG, "\n"); + } + free(ibuf); + } + } + if (region == -1 && nmmreg > 0) region=region * i; + return(region); +} +#endif + + +static Bool +linearVidMem() +{ +#ifdef SVR4 + return TRUE; +#elif defined(HAS_SVR3_MMAPDRV) + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "# xf86LinearVidMem: MMAP 2.2.2 called\n"); + + if(mmapFd >= 0) return TRUE; + + if ((mmapFd = open("/dev/mmap", O_RDWR)) != -1) + { + if(ioctl(mmapFd, GETVERSION) < 0x0222) { + xf86Msg(X_WARNING, + "xf86LinearVidMem: MMAP 2.2.2 or above required\n"); + xf86ErrorF("\tlinear memory access disabled\n"); + return FALSE; + } + return TRUE; + } + xf86Msg(X_WARNING, "xf86LinearVidMem: failed to open /dev/mmap (%s)\n", + strerror(errno)); + xf86ErrorF("\tlinear memory access disabled\n"); + return FALSE; +#endif +} + +static pointer +mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags) +{ + pointer base; + int fd; + +#if defined(SVR4) + 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)); + } +#else /* SVR4 */ +#ifdef HAS_SVR3_MMAPDRV + + xf86MsgVerb(X_INFO, MMAP_DEBUG, "# xf86MapVidMem: MMAP 2.2.2 called\n"); + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "MMAP_VERSION: 0x%x\n",ioctl(mmapFd, GETVERSION)); + if (ioctl(mmapFd, GETVERSION) == -1) + { + xf86LinearVidMem(); + } + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "MMAP_VERSION: 0x%x\n",ioctl(mmapFd, GETVERSION)); + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "xf86MapVidMem: Screen: %d\n", ScreenNum); + mmapStat(Base,Size); + /* To force the MMAP driver to provide the address */ + base = (pointer)0; + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "xf86MapVidMem: [s=%x,a=%x]\n", Size, Base); + MapDSC.vaddr = (char *)base; + MapDSC.physaddr = (char *)Base; + MapDSC.length = Size; + MapDSC.ioflg = 1; + if(mmapFd >= 0) + { + if((base = (pointer)ioctl(mmapFd, MAP, &MapDSC)) == (pointer)-1) + { + FatalError("%s: Could not mmap framebuffer [s=%x,a=%x] (%s)\n", + "xf86MapVidMem", Size, Base, strerror(errno)); + /* NOTREACHED */ + } + + /* Next time we want the same address! */ + MapDSC.vaddr = (char *)base; + } + + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "MapDSC.vaddr : 0x%x\n", MapDSC.vaddr); + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "MapDSC.physaddr: 0x%x\n", MapDSC.physaddr); + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "MapDSC.length : %d\n", MapDSC.length); + mmapStat(Base,Size); + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "xf86MapVidMem: [s=%x,a=%x,b=%x]\n", Size, Base, base); + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "xf86MapVidMem: SUCCEED Mapping FrameBuffer \n"); +#endif /* HAS_SVR3_MMAPDRV */ +#endif /* SVR4 */ + return(base); +} + +/* ARGSUSED */ +static void +unmapVidMem(int ScreenNum, pointer Base, unsigned long Size) +{ +#if defined (SVR4) + munmap(Base, Size); +#else /* SVR4 */ +#ifdef HAS_SVR3_MMAPDRV + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "# xf86UnMapVidMem: UNMapping FrameBuffer\n"); + mmapStat(Base,Size); + ioctl(mmapFd, UNMAPRM , Base); + mmapStat(Base,Size); + xf86MsgVerb(X_INFO, MMAP_DEBUG, + "# xf86UnMapVidMem: Screen: %d [v=%x]\n", ScreenNum, Base); +#endif /* HAS_SVR3_MMAPDRV */ +#endif /* SVR4 */ + return; +} + +#if defined(SVR4) && defined(i386) && !defined(sun) +/* + * 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. + */ + +/* + * XXX Should get this the correct way (see os/xalloc.c), but since this is + * for one platform I'll be lazy. + */ +#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; +} +#endif + +void +xf86OSInitVidMem(VidMemInfoPtr pVidMem) +{ + pVidMem->linearSupported = linearVidMem(); + pVidMem->mapMem = mapVidMem; + pVidMem->unmapMem = unmapVidMem; +#if defined(SVR4) && defined(i386) && !defined(sun) + pVidMem->readSideEffects = readSideEffects; +#endif + pVidMem->initialised = TRUE; +} + +/***************************************************************************/ +/* I/O Permissions section */ +/***************************************************************************/ + +static Bool ExtendedEnabled = FALSE; +static Bool InitDone = FALSE; + +Bool +xf86EnableIO() +{ + int i; + + if (ExtendedEnabled) + return TRUE; + + if (SET_IOPL() < 0) + { + xf86Msg(X_WARNING, + "xf86EnableIO: Failed to set IOPL for extended I/O\n"); + return FALSE; + } + ExtendedEnabled = TRUE; + + return TRUE; +} + +void +xf86DisableIO() +{ + if (!ExtendedEnabled) + return; + + RESET_IOPL(); + ExtendedEnabled = FALSE; + + return; +} + +/***************************************************************************/ +/* Interrupt Handling section */ +/***************************************************************************/ + +Bool +xf86DisableInterrupts() +{ + if (!ExtendedEnabled) + { + if (SET_IOPL() < 0) + { + return(FALSE); + } + } + +#ifdef __GNUC__ + __asm__ __volatile__("cli"); +#else + asm("cli"); +#endif /* __GNUC__ */ + + if (!ExtendedEnabled) + { + RESET_IOPL(); + } + return(TRUE); +} + +void +xf86EnableInterrupts() +{ + if (!ExtendedEnabled) + { + if (SET_IOPL() < 0) + { + return; + } + } + +#ifdef __GNUC__ + __asm__ __volatile__("sti"); +#else + asm("sti"); +#endif /* __GNUC__ */ + + if (!ExtendedEnabled) + { + RESET_IOPL(); + } + return; +} diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/xqueue.c b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/xqueue.c new file mode 100644 index 000000000..6c2132cef --- /dev/null +++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/xqueue.c @@ -0,0 +1,543 @@ +/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sysv/xqueue.c,v 3.19 2000/02/10 22:33:45 dawes Exp $ */ +/* + * 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: xqueue.c /main/8 1996/10/19 18:08:11 kaleb $ */ + +#ifdef HAVE_XORG_CONFIG_H +#include <xorg-config.h> +#endif + +#include <X11/X.h> +#include "compiler.h" + +#include "xf86.h" +#include "xf86Priv.h" +#include "xf86_OSlib.h" +#include "xf86Xinput.h" +#include "xf86OSmouse.h" +#include "xqueue.h" + +#ifdef XQUEUE + +static xqEventQueue *XqueQaddr; +static int xqueFd = -1; +#ifndef XQUEUE_ASYNC +static int xquePipe[2]; +#endif + +#ifdef XKB +#include "inputstr.h" +#include <X11/extensions/XKB.h> +#include <X11/extensions/XKBstr.h> +#include <X11/extensions/XKBsrv.h> +extern Bool noXkbExtension; +#endif + +#include "xf86Xinput.h" +#include "mipointer.h" + +typedef struct { + int xquePending; + int xqueSema; +} XqInfoRec, *XqInfoPtr; + +InputInfoPtr XqMouse = NULL; +InputInfoPtr XqKeyboard = NULL; + +#ifndef XQUEUE_ASYNC +/* + * xf86XqueSignal -- + * Trap the signal from xqueue and let it be known that events are + * ready for collection + */ + +static void +xf86XqueSignal(int signum) +{ + ((XqInfoPtr)(((MouseDevPtr)(XqMouse->private))->mousePriv))->xquePending = 1; + /* + * This is a hack, but it is the only reliable way I can find of letting + * the main select() loop know that there is more input waiting. Receiving + * a signal will interrupt select(), but there is no way I can find of + * dealing with events that come in between the end of processing the + * last set and when select() gets called. + * + * Suggestions for better ways of dealing with this without going back to + * asynchronous event processing are welcome. + */ +#ifdef DEBUG + ErrorF("xf86XqueSignal\n"); +#endif + write(xquePipe[1], "X", 1); + signal(SIGUSR2, xf86XqueSignal); +} +#endif + + +/* + * xf86XqueKbdProc -- + * Handle the initialization, etc. of a keyboard. + */ + +int +xf86XqueKbdProc(DeviceIntPtr pKeyboard, int what) +{ + KeySymsRec keySyms; + CARD8 modMap[MAP_LENGTH]; + + switch (what) { + + case DEVICE_INIT: + + xf86KbdGetMapping(&keySyms, modMap); + + /* + * Get also the initial led settings + */ + ioctl(xf86Info.consoleFd, KDGETLED, &xf86Info.leds); + + /* + * Perform final initialization of the system private keyboard + * structure and fill in various slots in the device record + * itself which couldn't be filled in before. + */ + pKeyboard->public.on = FALSE; + +#ifdef XKB + if (noXkbExtension) { +#endif + InitKeyboardDeviceStruct((DevicePtr)xf86Info.pKeyboard, + &keySyms, + modMap, + xf86KbdBell, + (KbdCtrlProcPtr)xf86KbdCtrl); +#ifdef XKB + } else { + XkbComponentNamesRec names; + if (XkbInitialMap) { + if ((xf86Info.xkbkeymap = strchr(XkbInitialMap, '/')) != NULL) + xf86Info.xkbkeymap++; + else + xf86Info.xkbkeymap = XkbInitialMap; + } + if (xf86Info.xkbkeymap) { + names.keymap = xf86Info.xkbkeymap; + names.keycodes = NULL; + names.types = NULL; + names.compat = NULL; + names.symbols = NULL; + names.geometry = NULL; + } else { + names.keymap = NULL; + names.keycodes = xf86Info.xkbkeycodes; + names.types = xf86Info.xkbtypes; + names.compat = xf86Info.xkbcompat; + names.symbols = xf86Info.xkbsymbols; + names.geometry = xf86Info.xkbgeometry; + } + if ((xf86Info.xkbkeymap || xf86Info.xkbcomponents_specified) + && (xf86Info.xkbmodel == NULL || xf86Info.xkblayout == NULL)) { + xf86Info.xkbrules = NULL; + } + XkbSetRulesDflts(xf86Info.xkbrules, xf86Info.xkbmodel, + xf86Info.xkblayout, xf86Info.xkbvariant, + xf86Info.xkboptions); + XkbInitKeyboardDeviceStruct(pKeyboard, + &names, + &keySyms, + modMap, + xf86KbdBell, + (KbdCtrlProcPtr)xf86KbdCtrl); + } +#endif + + xf86InitKBD(TRUE); + break; + + case DEVICE_ON: + pKeyboard->public.on = TRUE; + xf86InitKBD(FALSE); + break; + + case DEVICE_CLOSE: + case DEVICE_OFF: + pKeyboard->public.on = FALSE; + break; + } + + return (Success); +} + + +/* + * xf86XqueEvents -- + * Get some events from our queue. Nothing to do here ... + */ + +void +xf86XqueEvents() +{ +} + + +#ifdef XQUEUE_ASYNC +static void XqDoInput(int signum); +#endif + +void +XqReadInput(InputInfoPtr pInfo) +{ + MouseDevPtr pMse; + XqInfoPtr pXq; + xqEvent *XqueEvents; + int XqueHead; + char buf[100]; + signed char dx, dy; + + if (xqueFd < 0) + return; + + pMse = pInfo->private; + pXq = pMse->mousePriv; + + XqueEvents = XqueQaddr->xq_events; + XqueHead = XqueQaddr->xq_head; + + while (XqueHead != XqueQaddr->xq_tail) { + switch (XqueEvents[XqueHead].xq_type) { + case XQ_BUTTON: + pMse->PostEvent(pInfo, ~(XqueEvents[XqueHead].xq_code) & 0x07, + 0, 0, 0, 0); +#ifdef DEBUG + ErrorF("xqueue: buttons: %d\n", ~(XqueEvents[XqueHead].xq_code) & 0x07); +#endif + break; + + case XQ_MOTION: + dx = (signed char)XqueEvents[XqueHead].xq_x; + dy = (signed char)XqueEvents[XqueHead].xq_y; + pMse->PostEvent(pInfo, ~(XqueEvents[XqueHead].xq_code) & 0x07, + (int)dx, (int)dy, 0, 0); +#ifdef DEBUG + ErrorF("xqueue: Motion: (%d, %d) (buttons: %d)\n", dx, dy, ~(XqueEvents[XqueHead].xq_code) & 0x07); +#endif + break; + + case XQ_KEY: + /* XXX Need to deal with the keyboard part nicely. */ +#ifdef DEBUG + ErrorF("xqueue: key: %d\n", XqueEvents[XqueHead].xq_code); +#endif + xf86PostKbdEvent(XqueEvents[XqueHead].xq_code); + break; + default: + xf86Msg(X_WARNING, "Unknown Xque Event: 0x%02x\n", + XqueEvents[XqueHead].xq_type); + } + + if ((++XqueHead) == XqueQaddr->xq_size) XqueHead = 0; + xf86Info.inputPending = TRUE; + } + + /* reenable the signal-processing */ +#ifdef XQUEUE_ASYNC + signal(SIGUSR2, XqDoInput); +#endif + +#ifndef XQUEUE_ASYNC + { + int rval; + + while ((rval = read(xquePipe[0], buf, sizeof(buf))) > 0) +#ifdef DEBUG + ErrorF("Read %d bytes from xquePipe[0]\n", rval); +#else + ; +#endif + } +#endif + +#ifdef DEBUG + ErrorF("Leaving XqReadInput()\n"); +#endif + pXq->xquePending = 0; + XqueQaddr->xq_head = XqueQaddr->xq_tail; + XqueQaddr->xq_sigenable = 1; /* UNLOCK */ +} + +#ifdef XQUEUE_ASYNC +static void +XqDoInput(int signum) +{ + if (XqMouse) + XqReadInput(XqMouse); +} +#endif + +static void +XqBlock(pointer blockData, OSTimePtr pTimeout, pointer pReadmask) +{ + InputInfoPtr pInfo; + MouseDevPtr pMse; + XqInfoPtr pXq; + /* + * On MP SVR4 boxes, a race condition exists because the XQUEUE does + * not have anyway to lock it for exclusive access. This results in one + * processor putting something on the queue at the same time the other + * processor is taking it something off. The count of items in the queue + * can get off by 1. This just goes and checks to see if an extra event + * was put in the queue a during this period. The signal for this event + * was ignored while processing the previous event. + */ + + pInfo = blockData; + pMse = pInfo->private; + pXq = pMse-> mousePriv; + if (!pXq->xquePending) { +#ifdef DEBUG + ErrorF("XqBlock: calling XqReadInput()\n"); +#endif + XqReadInput((InputInfoPtr)blockData); + } else { +#ifdef DEBUG + ErrorF("XqBlock: not calling XqReadInput()\n"); +#endif + ; + } + /* + * Make sure that any events that come in here are passed on without. + * waiting for the next wakeup. + */ + if (xf86Info.inputPending) { +#ifdef DEBUG + ErrorF("XqBlock: calling ProcessInputEvents()\n"); +#endif + ProcessInputEvents(); + } else { +#ifdef DEBUG + ErrorF("XqBlock: not calling ProcessInputEvents()\n"); +#endif + ; + } +} + +/* + * XqEnable -- + * Enable the handling of the Xque + */ + +static int +XqEnable(InputInfoPtr pInfo) +{ + MouseDevPtr pMse; + XqInfoPtr pXq; + static struct kd_quemode xqueMode; + static Bool was_here = FALSE; + + pMse = pInfo->private; + pXq = pMse->mousePriv; + + if (xqueFd < 0) { + if ((xqueFd = open("/dev/mouse", O_RDONLY | O_NDELAY)) < 0) { + if (xf86GetAllowMouseOpenFail()) { + xf86Msg(X_WARNING, + "%s: Cannot open /dev/mouse (%s) - Continuing...\n", + pInfo->name, strerror(errno)); + return Success; + } else { + xf86Msg(X_ERROR, "%s: Cannot open /dev/mouse (%s)\n", + pInfo->name, strerror(errno)); + return !Success; + } + } + } +#ifndef XQUEUE_ASYNC + if (!was_here) { + pipe(xquePipe); + fcntl(xquePipe[0], F_SETFL, fcntl(xquePipe[0], F_GETFL, 0) | O_NDELAY); + fcntl(xquePipe[1], F_SETFL, fcntl(xquePipe[1], F_GETFL, 0) | O_NDELAY); + was_here = TRUE; + } +#endif + + if (pXq->xqueSema++ == 0) { +#ifdef XQUEUE_ASYNC + (void) signal(SIGUSR2, XqDoInput); +#else + (void) signal(SIGUSR2, xf86XqueSignal); +#endif + xqueMode.qsize = 64; /* max events */ + xqueMode.signo = SIGUSR2; + ioctl(xf86Info.consoleFd, KDQUEMODE, NULL); + + if (ioctl(xf86Info.consoleFd, KDQUEMODE, &xqueMode) < 0) { + xf86Msg(X_ERROR, "%s: Cannot set KDQUEMODE", pInfo->name); + return !Success; + } + XqueQaddr = (xqEventQueue *)xqueMode.qaddr; + XqueQaddr->xq_sigenable = 1; /* UNLOCK */ + } + + return Success; +} + + + +/* + * xf86XqueDisable -- + * disable the handling of the Xque + */ + +static int +XqDisable(InputInfoPtr pInfo) +{ + MouseDevPtr pMse; + XqInfoPtr pXq; + + pMse = pInfo->private; + pXq = pMse->mousePriv; + + if (pXq->xqueSema-- == 1) + { + XqueQaddr->xq_sigenable = 0; /* LOCK */ + + if (ioctl(xf86Info.consoleFd, KDQUEMODE, NULL) < 0) { + xf86Msg(X_ERROR, "%s: Cannot unset KDQUEMODE", pInfo->name); + return !Success; + } + } + + if (xqueFd >= 0) { + close(xqueFd); + xqueFd = -1; + } + + return Success; +} + +/* + * XqMouseProc -- + * Handle the initialization, etc. of a mouse + */ + +static int +XqMouseProc(DeviceIntPtr pPointer, int what) +{ + InputInfoPtr pInfo; + MouseDevPtr pMse; + unchar map[4]; + 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; + + InitPointerDeviceStruct((DevicePtr)pPointer, + map, + 3, + 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); + RegisterBlockAndWakeupHandlers(XqBlock, (WakeupHandlerProcPtr)NoopDDA, + pInfo); + break; + + case DEVICE_ON: + pMse->lastButtons = 0; + pMse->lastMappedButtons = 0; + pMse->emulateState = 0; + pPointer->public.on = TRUE; + ret = XqEnable(pInfo); +#ifndef XQUEUE_ASYNC + if (xquePipe[0] != -1) { + pInfo->fd = xquePipe[0]; + AddEnabledDevice(xquePipe[0]); + } +#endif + return ret; + + case DEVICE_CLOSE: + case DEVICE_OFF: + pPointer->public.on = FALSE; + ret = XqDisable(pInfo); +#ifndef XQUEUE_ASYNC + if (xquePipe[0] != -1) { + RemoveEnabledDevice(xquePipe[0]); + pInfo->fd = -1; + } +#endif + return ret; + } + return Success; +} + +Bool +XqueueMousePreInit(InputInfoPtr pInfo, const char *protocol, int flags) +{ + MouseDevPtr pMse; + XqInfoPtr pXq; + + pMse = pInfo->private; + pMse->protocol = protocol; + xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, protocol); + pXq = pMse->mousePriv = xnfcalloc(sizeof(XqInfoRec), 1); + + /* Collect the options, and process the common options. */ + xf86CollectInputOptions(pInfo, NULL, NULL); + xf86ProcessCommonOptions(pInfo, pInfo->options); + + /* Process common mouse options (like Emulate3Buttons, etc). */ + pMse->CommonOptions(pInfo); + + /* Setup the local procs. */ + pInfo->device_control = XqMouseProc; +#ifdef XQUEUE_ASYNC + pInfo->read_input = NULL; +#else + pInfo->read_input = XqReadInput; +#endif + pInfo->fd = -1; + + XqMouse = pInfo; + + pInfo->flags |= XI86_CONFIGURED; + return TRUE; +} + +#endif /* XQUEUE */ diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/xqueue.h b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/xqueue.h new file mode 100644 index 000000000..d693d2b36 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/sysv/xqueue.h @@ -0,0 +1,12 @@ +/* $XFree86$ */ + +#ifdef HAVE_XORG_CONFIG_H +#include <xorg-config.h> +#endif + +#ifndef _XF86_XQUEUE_H_ +#define _XF86_XQUEUE_H_ + +Bool XqueueMousePreInit(InputInfoPtr pInfo, const char *protocol, int flags); + +#endif |