419 lines
9.4 KiB
C
419 lines
9.4 KiB
C
/* $NetBSD: dreamcastInit.c,v 1.3 2010/10/10 05:33:32 tsutsui Exp $ */
|
|
|
|
/*
|
|
* Modified from hpcInit.c of Xhpc
|
|
*/
|
|
|
|
#include "dreamcast.h"
|
|
#include "gcstruct.h"
|
|
#include "mi.h"
|
|
#include "mibstore.h"
|
|
#include "cfb.h"
|
|
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
/* XXX should we use this or not? */
|
|
#include <dev/wscons/wsksymdef.h>
|
|
|
|
static Bool dreamcastDevsInited = FALSE;
|
|
|
|
dreamcastKbdPrivRec dreamcastKbdPriv = {
|
|
-1, /* fd */
|
|
-1, /* keyboard type */
|
|
-1, /* layout */
|
|
0, /* click */
|
|
(Leds)0, /* leds */
|
|
};
|
|
|
|
dreamcastPtrPrivRec dreamcastPtrPriv = {
|
|
-1, /* fd */
|
|
0, /* last known button state */
|
|
};
|
|
|
|
#if 0
|
|
/*
|
|
* a list of devices to try if there is no environment or command
|
|
* line list of devices
|
|
*/
|
|
static char *fallbackList[] = {
|
|
"/dev/ttyE0", "/dev/ttyE1", "/dev/ttyE2", "/dev/ttyE3",
|
|
"/dev/ttyE4", "/dev/ttyE5", "/dev/ttyE6", "/dev/ttyE7",
|
|
};
|
|
#define FALLBACK_LIST_LEN sizeof fallbackList / sizeof fallbackList[0]
|
|
#endif
|
|
|
|
dreamcastFbRec dreamcastFbs[MAXSCREENS];
|
|
|
|
static PixmapFormatRec formats[] = {
|
|
{ 1, 1, BITMAP_SCANLINE_PAD}, /* 1 bit deep */
|
|
{ 8, 8, BITMAP_SCANLINE_PAD}, /* 8 bit deep */
|
|
{ 16, 16, BITMAP_SCANLINE_PAD}, /* 16 bit deep */
|
|
};
|
|
#define NUMFORMATS (sizeof formats)/(sizeof formats[0])
|
|
|
|
dreamcastFbPtr
|
|
dreamcastGetScreenFb(pScreen)
|
|
ScreenPtr pScreen;
|
|
{
|
|
return (&dreamcastFbs[pScreen->myNum]);
|
|
}
|
|
|
|
/*
|
|
* OpenFrameBuffer --
|
|
* Open a frame buffer according to several rules.
|
|
*
|
|
* Results:
|
|
* The fd of the framebuffer.
|
|
*/
|
|
static int
|
|
OpenFrameBuffer(char *device, int screen)
|
|
/* char *device; e.g. "/dev/ttyE0" */
|
|
/* int screen; what screen am I going to be */
|
|
{
|
|
int ret = TRUE;
|
|
|
|
dreamcastFbs[screen].fd = -1;
|
|
dreamcastFbs[screen].devname = device;
|
|
if (access (device, R_OK | W_OK) == -1)
|
|
return FALSE;
|
|
if ((dreamcastFbs[screen].fd = open(device, O_RDWR, 0)) == -1) {
|
|
dreamcastError(device);
|
|
ret = FALSE;
|
|
} else {
|
|
int mode = WSDISPLAYIO_MODE_MAPPED;
|
|
if (ioctl(dreamcastFbs[screen].fd, WSDISPLAYIO_SMODE, &mode) == -1) {
|
|
dreamcastError("unable to set frame buffer mode");
|
|
}
|
|
if (ioctl(dreamcastFbs[screen].fd, WSDISPLAYIO_GINFO,
|
|
&dreamcastFbs[screen].info) == -1) {
|
|
dreamcastError("unable to get frame buffer info");
|
|
(void) close(dreamcastFbs[screen].fd);
|
|
dreamcastFbs[screen].fd = -1;
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
if (!ret)
|
|
dreamcastFbs[screen].fd = -1;
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* SigIOHandler --
|
|
* Signal handler for SIGIO - input is available.
|
|
*
|
|
* Results:
|
|
* dreamcastSigIO is set - ProcessInputEvents() will be called soon.
|
|
*
|
|
* Side Effects:
|
|
* None
|
|
*
|
|
*/
|
|
static void
|
|
SigIOHandler(int sig)
|
|
{
|
|
int olderrno = errno;
|
|
|
|
dreamcastEnqueueEvents();
|
|
errno = olderrno;
|
|
}
|
|
|
|
static char**
|
|
GetDeviceList (int argc, char **argv)
|
|
{
|
|
int i;
|
|
char *envList = NULL;
|
|
char *cmdList = NULL;
|
|
char **deviceList = (char **)NULL;
|
|
char *ttyn = NULL;
|
|
char *p;
|
|
int ttyfd = -1;
|
|
char ttyE0[] = "/dev/ttyE0";
|
|
|
|
for (i = 1; i < argc; i++)
|
|
if (strcmp (argv[i], "-dev") == 0 && i+1 < argc) {
|
|
cmdList = argv[i + 1];
|
|
break;
|
|
}
|
|
|
|
if (!cmdList)
|
|
envList = getenv ("XDEVICE");
|
|
|
|
if (!cmdList && !envList) {
|
|
if (isatty(2))
|
|
ttyfd = 2;
|
|
else if (isatty(0))
|
|
ttyfd = 0;
|
|
else if (isatty(1))
|
|
ttyfd = 1;
|
|
|
|
if (ttyfd >= 0) {
|
|
if ((p = ttyname(ttyfd)) == NULL)
|
|
ttyn = ttyE0;
|
|
else if (strncmp(p, ttyE0, strlen(ttyE0)-1) == 0)
|
|
ttyn = p;
|
|
else
|
|
ttyn = ttyE0;
|
|
} else
|
|
ttyn = ttyE0;
|
|
}
|
|
|
|
if (cmdList || envList || ttyn) {
|
|
char *_tmpa;
|
|
char *_tmpb;
|
|
int _i1;
|
|
deviceList = (char **) xalloc ((MAXSCREENS + 1) * sizeof (char *));
|
|
_tmpa = (cmdList) ? cmdList : (envList) ? envList : ttyn;
|
|
for (_i1 = 0; _i1 < MAXSCREENS; _i1++) {
|
|
_tmpb = strtok (_tmpa, ":");
|
|
if (_tmpb)
|
|
deviceList[_i1] = strdup(_tmpb);
|
|
else
|
|
deviceList[_i1] = NULL;
|
|
_tmpa = NULL;
|
|
}
|
|
deviceList[MAXSCREENS] = NULL;
|
|
}
|
|
return deviceList;
|
|
}
|
|
|
|
void
|
|
OsVendorPreInit(void)
|
|
{
|
|
}
|
|
|
|
void
|
|
OsVendorInit(void)
|
|
{
|
|
}
|
|
|
|
static void
|
|
InitKbdMouse(int argc, char **argv)
|
|
{
|
|
struct rlimit rl;
|
|
int maxfds, kbdtype, layout;
|
|
int i;
|
|
|
|
static int inited;
|
|
|
|
if (inited)
|
|
return;
|
|
|
|
/*
|
|
* one per client, one per screen, one per listen endpoint,
|
|
* keyboard, mouse, and stderr
|
|
*/
|
|
maxfds = MAXCLIENTS + MAXSCREENS + 5;
|
|
|
|
if (getrlimit (RLIMIT_NOFILE, &rl) == 0) {
|
|
rl.rlim_cur = maxfds < rl.rlim_max ? maxfds : rl.rlim_max;
|
|
(void) setrlimit (RLIMIT_NOFILE, &rl);
|
|
}
|
|
|
|
dreamcastKbdPriv.fd = dreamcastPtrPriv.fd = -1;
|
|
|
|
/*
|
|
* use mouse multiplexer if it's available.
|
|
*/
|
|
dreamcastKbdPriv.fd = open("/dev/wskbd", O_RDWR);
|
|
dreamcastPtrPriv.fd = open("/dev/wsmouse", O_RDWR);
|
|
|
|
/*
|
|
* try each mouse device
|
|
*/
|
|
for (i = 0; i < 8; i++) {
|
|
char dvname[16];
|
|
|
|
if (dreamcastKbdPriv.fd == -1) {
|
|
sprintf(dvname, "/dev/wskbd%d", i);
|
|
dreamcastKbdPriv.fd = open(dvname, O_RDWR);
|
|
}
|
|
|
|
if (dreamcastPtrPriv.fd == -1) {
|
|
sprintf(dvname, "/dev/wsmouse%d", i);
|
|
if ((dreamcastPtrPriv.fd = open(dvname, O_RDWR)) < 0)
|
|
dreamcastError(dvname);
|
|
}
|
|
}
|
|
|
|
if (dreamcastKbdPriv.fd == -1)
|
|
dreamcastFatalError(("Can't open keyboard device\n"));
|
|
if (dreamcastPtrPriv.fd == -1)
|
|
dreamcastFatalError(("Can't open pointer device\n"));
|
|
noXkbExtension = FALSE; /* XXX for now */
|
|
inited = 1;
|
|
|
|
if (ioctl(dreamcastKbdPriv.fd, WSKBDIO_GTYPE, &kbdtype) == -1) {
|
|
dreamcastError("cannot get keyboard type\n");
|
|
kbdtype = -1;
|
|
}
|
|
|
|
switch (kbdtype) {
|
|
case WSKBD_TYPE_MAPLE:
|
|
/* XXX: not used for now */
|
|
dreamcastKbdPriv.type = DREAMCAST_KBDTYPE_MAPLE;
|
|
break;
|
|
default:
|
|
dreamcastFatalError(("Unknown keyboard type\n"));
|
|
break;
|
|
}
|
|
if (ioctl(dreamcastKbdPriv.fd, WSKBDIO_GETENCODING, &layout) == -1) {
|
|
dreamcastError("cannot get keyboard layout\n");
|
|
layout = -1;
|
|
}
|
|
|
|
switch (KB_ENCODING(layout)) {
|
|
case KB_JP:
|
|
dreamcastKbdPriv.layout = DREAMCAST_KBDLAYOUT_JP;
|
|
break;
|
|
case KB_UK:
|
|
dreamcastKbdPriv.layout = DREAMCAST_KBDLAYOUT_UK;
|
|
break;
|
|
case KB_US:
|
|
dreamcastKbdPriv.layout = DREAMCAST_KBDLAYOUT_US;
|
|
break;
|
|
default:
|
|
dreamcastError("Unknown keyboard layout; assume JP layout.\n");
|
|
dreamcastKbdPriv.layout = DREAMCAST_KBDLAYOUT_JP;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* InitOutput --
|
|
* Initialize screenInfo for all actually accessible framebuffers.
|
|
* The
|
|
*
|
|
* Results:
|
|
* screenInfo init proc field set
|
|
*
|
|
* Side Effects:
|
|
* None
|
|
*/
|
|
void
|
|
InitOutput(pScreenInfo, argc, argv)
|
|
ScreenInfo *pScreenInfo;
|
|
int argc;
|
|
char **argv;
|
|
{
|
|
int i, scr;
|
|
int nonBlockConsole = 0;
|
|
char **devList;
|
|
extern Bool RunFromSmartParent;
|
|
|
|
if (!monitorResolution)
|
|
monitorResolution = 75;
|
|
if (RunFromSmartParent)
|
|
nonBlockConsole = 1;
|
|
for (i = 1; i < argc; i++) {
|
|
if (!strcmp(argv[i],"-debug"))
|
|
nonBlockConsole = 0;
|
|
}
|
|
|
|
pScreenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
|
|
pScreenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
|
|
pScreenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
|
|
pScreenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
|
|
|
|
pScreenInfo->numPixmapFormats = NUMFORMATS;
|
|
for (i=0; i< NUMFORMATS; i++)
|
|
pScreenInfo->formats[i] = formats[i];
|
|
if (!dreamcastDevsInited) {
|
|
/* first time ever */
|
|
for (scr = 0; scr < MAXSCREENS; scr++)
|
|
dreamcastFbs[scr].fd = -1;
|
|
devList = GetDeviceList (argc, argv);
|
|
for (i = 0, scr = 0; devList[i] != NULL && scr < MAXSCREENS; i++) {
|
|
if (OpenFrameBuffer (devList[i], scr))
|
|
scr++;
|
|
}
|
|
dreamcastDevsInited = TRUE;
|
|
xfree (devList);
|
|
}
|
|
for (scr = 0; scr < MAXSCREENS; scr++)
|
|
if (dreamcastFbs[scr].fd != -1)
|
|
(void) AddScreen (dreamcastFBInit, argc, argv);
|
|
(void) OsSignal(SIGWINCH, SIG_IGN);
|
|
}
|
|
|
|
/*
|
|
* InitInput --
|
|
* Initialize all supported input devices...what else is there
|
|
* besides pointer and keyboard?
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* Two DeviceRec's are allocated and registered as the system pointer
|
|
* and keyboard devices.
|
|
*/
|
|
void
|
|
InitInput(argc, argv)
|
|
int argc;
|
|
char **argv;
|
|
{
|
|
pointer p, k;
|
|
|
|
InitKbdMouse(argc, argv);
|
|
|
|
p = AddInputDevice(dreamcastMouseProc, TRUE);
|
|
k = AddInputDevice(dreamcastKbdProc, TRUE);
|
|
if (!p || !k)
|
|
dreamcastFatalError(("failed to create input devices in InitInput"));
|
|
|
|
RegisterPointerDevice(p);
|
|
RegisterKeyboardDevice(k);
|
|
miRegisterPointerDevice(screenInfo.screens[0], p);
|
|
(void) mieqInit (k, p);
|
|
#define SET_FLOW(fd) fcntl(fd, F_SETFL, FNDELAY | FASYNC)
|
|
(void) OsSignal(SIGIO, SigIOHandler);
|
|
#define WANT_SIGNALS(fd) fcntl(fd, F_SETOWN, getpid())
|
|
if (dreamcastKbdPriv.fd >= 0) {
|
|
if (SET_FLOW(dreamcastKbdPriv.fd) == -1 ||
|
|
WANT_SIGNALS(dreamcastKbdPriv.fd) == -1) {
|
|
(void) close (dreamcastKbdPriv.fd);
|
|
dreamcastKbdPriv.fd = -1;
|
|
dreamcastFatalError(("Async kbd I/O failed in InitInput"));
|
|
}
|
|
}
|
|
if (dreamcastPtrPriv.fd >= 0) {
|
|
if (SET_FLOW(dreamcastPtrPriv.fd) == -1 ||
|
|
WANT_SIGNALS(dreamcastPtrPriv.fd) == -1) {
|
|
(void) close (dreamcastPtrPriv.fd);
|
|
dreamcastPtrPriv.fd = -1;
|
|
dreamcastFatalError(("Async mouse I/O failed in InitInput"));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*#ifdef DDXOSFATALERROR*/
|
|
void OsVendorFatalError(void)
|
|
{
|
|
}
|
|
/*#endif*/
|
|
|
|
#ifdef DPMSExtension
|
|
/**************************************************************
|
|
* DPMSSet(), DPMSGet(), DPMSSupported()
|
|
*
|
|
* stubs
|
|
*
|
|
***************************************************************/
|
|
#include <Xext/dpmsproc.h>
|
|
|
|
void DPMSSet (int level)
|
|
{
|
|
}
|
|
|
|
int DPMSGet (int *level)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
Bool DPMSSupported (void)
|
|
{
|
|
return FALSE;
|
|
}
|
|
#endif
|