frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xserver/hw/kdrive/linux/linux.c

485 lines
11 KiB
C
Raw Blame History

/*
* $RCSId: xc/programs/Xserver/hw/kdrive/linux/linux.c,v 1.6 2001/07/24 21:26:17 keithp Exp $
*
* Copyright © 1999 Keith Packard
*
* 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 Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD 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.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "kdrive.h"
#include "klinux.h"
#include <errno.h>
#include <signal.h>
#include <linux/vt.h>
#include <linux/kd.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <X11/keysym.h>
#include <linux/apm_bios.h>
static int vtno;
int LinuxConsoleFd;
int LinuxApmFd = -1;
static int activeVT;
static Bool enabled;
static void
LinuxVTRequest (int sig)
{
kdSwitchPending = TRUE;
}
/* Check before chowning -- this avoids touching the file system */
static void
LinuxCheckChown (char *file)
{
struct stat st;
__uid_t u;
__gid_t g;
if (stat (file, &st) < 0)
return;
u = getuid ();
g = getgid ();
if (st.st_uid != u || st.st_gid != g)
chown (file, u, g);
}
static int
LinuxInit (void)
{
int fd = -1;
char vtname[11];
struct vt_stat vts;
LinuxConsoleFd = -1;
/* check if we're run with euid==0 */
if (geteuid() != 0)
{
FatalError("LinuxInit: Server must be suid root\n");
}
if (kdVirtualTerminal >= 0)
vtno = kdVirtualTerminal;
else
{
if ((fd = open("/dev/tty0",O_WRONLY,0)) < 0)
{
FatalError(
"LinuxInit: Cannot open /dev/tty0 (%s)\n",
strerror(errno));
}
if ((ioctl(fd, VT_OPENQRY, &vtno) < 0) ||
(vtno == -1))
{
FatalError("xf86OpenConsole: Cannot find a free VT\n");
}
}
close(fd);
sprintf(vtname,"/dev/tty%d",vtno); /* /dev/tty1-64 */
if ((LinuxConsoleFd = open(vtname, O_RDWR|O_NDELAY, 0)) < 0)
{
FatalError("LinuxInit: Cannot open %s (%s)\n",
vtname, strerror(errno));
}
/* change ownership of the vt */
LinuxCheckChown (vtname);
/*
* the current VT device we're running on is not "console", we want
* to grab all consoles too
*
* Why is this needed?
*/
LinuxCheckChown ("/dev/tty0");
/*
* Linux doesn't switch to an active vt after the last close of a vt,
* so we do this ourselves by remembering which is active now.
*/
memset (&vts, '\0', sizeof (vts)); /* valgrind */
if (ioctl(LinuxConsoleFd, VT_GETSTATE, &vts) == 0)
{
activeVT = vts.v_active;
}
return 1;
}
Bool
LinuxFindPci (CARD16 vendor, CARD16 device, CARD32 count, KdCardAttr *attr)
{
FILE *f;
char line[2048], *l, *end;
CARD32 bus, id, addr;
int n;
CARD32 ven_dev;
Bool ret = FALSE;
int i;
attr->vendorID = vendor;
attr->deviceID = device;
ven_dev = (((CARD32) vendor) << 16) | ((CARD32) device);
f = fopen ("/proc/bus/pci/devices", "r");
if (!f)
return FALSE;
attr->io = 0;
while (fgets (line, sizeof (line)-1, f))
{
line[sizeof(line)-1] = '\0';
l = line;
bus = strtoul (l, &end, 16);
if (end == l)
continue;
l = end;
id = strtoul (l, &end, 16);
if (end == l)
continue;
l = end;
if (id != ven_dev)
continue;
if (count--)
continue;
(void) strtoul (l, &end, 16); /* IRQ */
if (end == l)
continue;
l = end;
n = 0;
for (i = 0; i < 6; i++)
{
addr = strtoul (l, &end, 16);
if (end == l)
break;
if (addr & 1)
attr->io = addr & ~0xf;
else
{
if (n == KD_MAX_CARD_ADDRESS)
break;
attr->address[n++] = addr & ~0xf;
}
l = end;
}
while (n > 0)
{
if (attr->address[n-1] != 0)
break;
n--;
}
attr->naddr = n;
attr->domain = 0; /* XXX */
attr->bus = (bus >> 8) & 0xff;
attr->slot = (bus >> 3) & 0x1f;
attr->func = bus & 0x07;
ret = TRUE;
break;
}
fclose (f);
return ret;
}
unsigned char *
LinuxGetPciCfg(KdCardAttr *attr)
{
char filename[256];
FILE *f;
unsigned char *cfg;
int r;
snprintf(filename, 255, "/proc/bus/pci/%02x/%02x.%x",
attr->bus >> 8, (attr->bus & 0xff) >> 3, attr->bus & 7);
/* fprintf(stderr,"Find card on path %s\n",filename); */
if (!(f=fopen(filename,"r")))
return NULL;
if (!(cfg=xalloc(256)))
{
fclose(f);
return NULL;
}
if (256 != (r=fread(cfg, 1, 256, f)))
{
fprintf(stderr,"LinuxGetPciCfg: read %d, expected 256\n",r);
free(cfg);
cfg=NULL;
}
fclose(f);
/* fprintf(stderr,"LinuxGetPciCfg: success, returning %p\n",cfg); */
return cfg;
}
static void
LinuxSetSwitchMode (int mode)
{
struct sigaction act;
struct vt_mode VT;
if (ioctl(LinuxConsoleFd, VT_GETMODE, &VT) < 0)
{
FatalError ("LinuxInit: VT_GETMODE failed\n");
}
if (mode == VT_PROCESS)
{
act.sa_handler = LinuxVTRequest;
sigemptyset (&act.sa_mask);
act.sa_flags = 0;
sigaction (SIGUSR1, &act, 0);
VT.mode = mode;
VT.relsig = SIGUSR1;
VT.acqsig = SIGUSR1;
}
else
{
act.sa_handler = SIG_IGN;
sigemptyset (&act.sa_mask);
act.sa_flags = 0;
sigaction (SIGUSR1, &act, 0);
VT.mode = mode;
VT.relsig = 0;
VT.acqsig = 0;
}
if (ioctl(LinuxConsoleFd, VT_SETMODE, &VT) < 0)
{
FatalError("LinuxInit: VT_SETMODE failed\n");
}
}
static void
LinuxApmBlock (pointer blockData, OSTimePtr pTimeout, pointer pReadmask)
{
}
static Bool LinuxApmRunning;
static void
LinuxApmWakeup (pointer blockData, int result, pointer pReadmask)
{
fd_set *readmask = (fd_set *) pReadmask;
if (result > 0 && LinuxApmFd >= 0 && FD_ISSET (LinuxApmFd, readmask))
{
apm_event_t event;
Bool running = LinuxApmRunning;
int cmd = APM_IOC_SUSPEND;
while (read (LinuxApmFd, &event, sizeof (event)) == sizeof (event))
{
switch (event) {
case APM_SYS_STANDBY:
case APM_USER_STANDBY:
running = FALSE;
cmd = APM_IOC_STANDBY;
break;
case APM_SYS_SUSPEND:
case APM_USER_SUSPEND:
case APM_CRITICAL_SUSPEND:
running = FALSE;
cmd = APM_IOC_SUSPEND;
break;
case APM_NORMAL_RESUME:
case APM_CRITICAL_RESUME:
case APM_STANDBY_RESUME:
running = TRUE;
break;
}
}
if (running && !LinuxApmRunning)
{
KdResume ();
LinuxApmRunning = TRUE;
}
else if (!running && LinuxApmRunning)
{
KdSuspend ();
LinuxApmRunning = FALSE;
ioctl (LinuxApmFd, cmd, 0);
}
}
}
#ifdef FNONBLOCK
#define NOBLOCK FNONBLOCK
#else
#define NOBLOCK FNDELAY
#endif
static void
LinuxEnable (void)
{
if (enabled)
return;
if (kdSwitchPending)
{
kdSwitchPending = FALSE;
ioctl (LinuxConsoleFd, VT_RELDISP, VT_ACKACQ);
}
/*
* Open the APM driver
*/
LinuxApmFd = open ("/dev/apm_bios", 2);
if (LinuxApmFd < 0 && errno == ENOENT)
LinuxApmFd = open ("/dev/misc/apm_bios", 2);
if (LinuxApmFd >= 0)
{
LinuxApmRunning = TRUE;
fcntl (LinuxApmFd, F_SETFL, fcntl (LinuxApmFd, F_GETFL) | NOBLOCK);
RegisterBlockAndWakeupHandlers (LinuxApmBlock, LinuxApmWakeup, 0);
AddEnabledDevice (LinuxApmFd);
}
/*
* now get the VT
*/
LinuxSetSwitchMode (VT_AUTO);
if (ioctl(LinuxConsoleFd, VT_ACTIVATE, vtno) != 0)
{
FatalError("LinuxInit: VT_ACTIVATE failed\n");
}
if (ioctl(LinuxConsoleFd, VT_WAITACTIVE, vtno) != 0)
{
FatalError("LinuxInit: VT_WAITACTIVE failed\n");
}
LinuxSetSwitchMode (VT_PROCESS);
if (ioctl(LinuxConsoleFd, KDSETMODE, KD_GRAPHICS) < 0)
{
FatalError("LinuxInit: KDSETMODE KD_GRAPHICS failed\n");
}
enabled = TRUE;
}
static Bool
LinuxSpecialKey (KeySym sym)
{
struct vt_stat vts;
int con;
if (XK_F1 <= sym && sym <= XK_F12)
{
con = sym - XK_F1 + 1;
memset (&vts, '\0', sizeof (vts)); /* valgrind */
ioctl (LinuxConsoleFd, VT_GETSTATE, &vts);
if (con != vts.v_active && (vts.v_state & (1 << con)))
{
ioctl (LinuxConsoleFd, VT_ACTIVATE, con);
return TRUE;
}
}
return FALSE;
}
static void
LinuxDisable (void)
{
ioctl(LinuxConsoleFd, KDSETMODE, KD_TEXT); /* Back to text mode ... */
if (kdSwitchPending)
{
kdSwitchPending = FALSE;
ioctl (LinuxConsoleFd, VT_RELDISP, 1);
}
enabled = FALSE;
if (LinuxApmFd >= 0)
{
RemoveBlockAndWakeupHandlers (LinuxApmBlock, LinuxApmWakeup, 0);
RemoveEnabledDevice (LinuxApmFd);
close (LinuxApmFd);
LinuxApmFd = -1;
}
}
static void
LinuxFini (void)
{
struct vt_mode VT;
struct vt_stat vts;
int fd;
if (LinuxConsoleFd < 0)
return;
if (ioctl(LinuxConsoleFd, VT_GETMODE, &VT) != -1)
{
VT.mode = VT_AUTO;
ioctl(LinuxConsoleFd, VT_SETMODE, &VT); /* set dflt vt handling */
}
memset (&vts, '\0', sizeof (vts)); /* valgrind */
ioctl (LinuxConsoleFd, VT_GETSTATE, &vts);
if (vtno == vts.v_active)
{
/*
* Find a legal VT to switch to, either the one we started from
* or the lowest active one that isn't ours
*/
if (activeVT < 0 ||
activeVT == vts.v_active ||
!(vts.v_state & (1 << activeVT)))
{
for (activeVT = 1; activeVT < 16; activeVT++)
if (activeVT != vtno && (vts.v_state & (1 << activeVT)))
break;
if (activeVT == 16)
activeVT = -1;
}
/*
* Perform a switch back to the active VT when we were started
*/
if (activeVT >= -1)
{
ioctl (LinuxConsoleFd, VT_ACTIVATE, activeVT);
ioctl (LinuxConsoleFd, VT_WAITACTIVE, activeVT);
activeVT = -1;
}
}
close(LinuxConsoleFd); /* make the vt-manager happy */
fd = open ("/dev/tty0", O_RDWR|O_NDELAY, 0);
if (fd >= 0)
{
memset (&vts, '\0', sizeof (vts)); /* valgrind */
ioctl (fd, VT_GETSTATE, &vts);
if (ioctl (fd, VT_DISALLOCATE, vtno) < 0)
fprintf (stderr, "Can't deallocate console %d errno %d\n", vtno, errno);
close (fd);
}
return;
}
KdOsFuncs LinuxFuncs = {
LinuxInit,
LinuxEnable,
LinuxSpecialKey,
LinuxDisable,
LinuxFini,
0
};
void
OsVendorInit (void)
{
KdOsInit (&LinuxFuncs);
}
Reference in New Issue View Git Blame Copy Permalink