395 lines
7.8 KiB
C
395 lines
7.8 KiB
C
/*-
|
|
* Copyright (C) 1994 Bradley A. Grantham and Lawrence A. Kesteloot
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. The names of the Alice Group or any of its members may not be used
|
|
* to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE ALICE GROUP ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE ALICE GROUP BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <servermd.h>
|
|
#include "mac68k.h"
|
|
#include "dixstruct.h"
|
|
#include "dix.h"
|
|
#include "opaque.h"
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <sys/mman.h>
|
|
|
|
|
|
#define CATCH_BROKEN_MODE 1
|
|
|
|
|
|
void ProcessInputEvents(void);
|
|
|
|
|
|
int mac_adbfd;
|
|
|
|
Time mac_lasteventtime;
|
|
|
|
int mac_scrs = 0;
|
|
fbinfo_t mac_fbs[MAXSCREENS];
|
|
|
|
DeviceIntPtr mac68k_mouse;
|
|
DeviceIntPtr mac68k_kbd;
|
|
|
|
int mac68k_mouseproc(
|
|
DeviceIntPtr mouse,
|
|
int what);
|
|
|
|
int mac68k_kbdproc(
|
|
DeviceIntPtr mouse,
|
|
int what);
|
|
|
|
Bool mac68kMonoInit(
|
|
int index,
|
|
ScreenPtr screen,
|
|
int argc,
|
|
char **argv);
|
|
|
|
|
|
void mac68k_enqevents(
|
|
void);
|
|
|
|
|
|
static void handle_sigio(
|
|
int flags)
|
|
{
|
|
mac68k_enqevents();
|
|
}
|
|
|
|
void OsVendorPreInit(
|
|
#if NeedFunctionPrototypes
|
|
void
|
|
#endif
|
|
)
|
|
{
|
|
}
|
|
|
|
#if MAC68K_IOHACK
|
|
void OsVendorInit(
|
|
#if NeedFunctionPrototypes
|
|
void
|
|
#endif
|
|
)
|
|
{
|
|
}
|
|
|
|
int initialize_desktop()
|
|
#else
|
|
|
|
void OsVendorInit(
|
|
#if NeedFunctionPrototypes
|
|
void
|
|
#endif
|
|
)
|
|
|
|
#endif
|
|
{
|
|
int i, j;
|
|
struct imagedata *id;
|
|
int totalscreens;
|
|
int argnum = 1;
|
|
|
|
mac_adbfd = open ("/dev/adb", O_RDWR);
|
|
|
|
if (mac_adbfd == -1) {
|
|
ErrorF("Couldn't open /dev/adb...");
|
|
FatalError(sys_errlist[errno]);
|
|
}
|
|
|
|
mac68k_getmouse(); /* find mouse and set up or error */
|
|
mac68k_getkbd(); /* find keyboard and set up or error */
|
|
|
|
signal(SIGIO, handle_sigio);
|
|
}
|
|
|
|
void
|
|
choose_best_depths(void)
|
|
{
|
|
#if 0
|
|
int scr, mode, best;
|
|
struct imagedata *si;
|
|
int umph, bestumph; /* "umph" is goodness of screen */
|
|
/* Could have a nicer calculation, like depth versus */
|
|
/* resolution versus dimensions with weights... */
|
|
char scrstr[100];
|
|
|
|
for(scr = 0; scr < mac_ci.numscreens; scr++){
|
|
best = -1;
|
|
if(mac_si[scr].nummodes > 0){
|
|
best = 0;
|
|
si = &mac_si[scr].modes[0].modeinfo;
|
|
bestumph = si->pixelSize * (si->right - si->left) *
|
|
(si->bottom - si->top);
|
|
|
|
for(mode = 1; mode < mac_si[scr].nummodes; mode++){
|
|
si = &mac_si[scr].modes[mode].modeinfo;
|
|
umph = si->pixelSize * (si->right - si->left) *
|
|
(si->bottom - si->top);
|
|
if(umph > bestumph){
|
|
bestumph = umph;
|
|
best = mode;
|
|
}
|
|
}
|
|
}else{
|
|
sprintf(scrstr, "Cannot find modes for screen %d."
|
|
" Ignoring.", scr);
|
|
ErrorF(scrstr);
|
|
}
|
|
mac_bestmode[scr] = best;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
Bool mac68k_screeninit(
|
|
ScreenPtr screen)
|
|
{
|
|
miDCInitialize(screen, &mac_mousefuncs);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
parse_args(
|
|
int argc,
|
|
char **argv)
|
|
{
|
|
/* try to match argv params to screens and depths */
|
|
/* BARF I really should do this, but not right now, */
|
|
/* while I am feverishly trying to finish the other X code. */
|
|
}
|
|
|
|
|
|
void
|
|
setup_screens(
|
|
ScreenInfo *xsi,
|
|
int argc,
|
|
char **argv)
|
|
{
|
|
char fname[128];
|
|
int done = 0;
|
|
caddr_t vaddr;
|
|
int scr;
|
|
|
|
do {
|
|
sprintf(fname, "/dev/grf%d", mac_scrs);
|
|
#if DEBUG
|
|
ErrorF("attempting %s...\n", fname);
|
|
#endif
|
|
if ((mac_fbs[mac_scrs].fd = open(fname, O_RDWR)) != -1) {
|
|
#if DEBUG
|
|
ErrorF("opened successfully\n");
|
|
#endif
|
|
if (ioctl (mac_fbs[mac_scrs].fd, GRFIOCGMODE,
|
|
&mac_fbs[mac_scrs].idata) != 0)
|
|
{
|
|
ErrorF("Couldn't get info for %d.\n",mac_scrs);
|
|
FatalError(sys_errlist[errno]);
|
|
}
|
|
vaddr = mmap(0, mac_fbs[mac_scrs].idata.fbsize,
|
|
(PROT_READ|PROT_WRITE),MAP_SHARED,
|
|
mac_fbs[mac_scrs].fd,
|
|
mac_fbs[mac_scrs].idata.fboff);
|
|
if (vaddr == (caddr_t) -1) {
|
|
ErrorF("Couldn't map SCREEN %d.\n", mac_scrs);
|
|
FatalError(sys_errlist[errno]);
|
|
}
|
|
mac_fbs[mac_scrs].modenum = 0;
|
|
mac_fbs[mac_scrs].vaddr = vaddr;
|
|
mac_fbs[mac_scrs].added = FALSE;
|
|
mac_scrs++;
|
|
} else {
|
|
if (errno != ENXIO) {
|
|
ErrorF("Couldn't open %s.\n", fname);
|
|
FatalError(sys_errlist[errno]);
|
|
}
|
|
done = 1;
|
|
}
|
|
} while(!done);
|
|
|
|
if(mac_scrs == 0)
|
|
FatalError("Can't run X server with no screens!");
|
|
|
|
xsi->imageByteOrder = IMAGE_BYTE_ORDER;
|
|
xsi->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
|
|
xsi->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
|
|
xsi->bitmapBitOrder = BITMAP_BIT_ORDER;
|
|
|
|
xsi->formats[0].depth = 1;
|
|
xsi->formats[0].bitsPerPixel = 1;
|
|
xsi->formats[0].scanlinePad = BITMAP_SCANLINE_PAD;
|
|
|
|
xsi->formats[1].depth = 8;
|
|
xsi->formats[1].bitsPerPixel = 8;
|
|
xsi->formats[1].scanlinePad = BITMAP_SCANLINE_PAD;
|
|
|
|
xsi->formats[2].depth = 16;
|
|
xsi->formats[2].bitsPerPixel = 16;
|
|
xsi->formats[2].scanlinePad = BITMAP_SCANLINE_PAD;
|
|
|
|
xsi->formats[3].depth = 24;
|
|
xsi->formats[3].bitsPerPixel = 32;
|
|
xsi->formats[3].scanlinePad = BITMAP_SCANLINE_PAD;
|
|
|
|
xsi->numPixmapFormats = 4;
|
|
|
|
#if DEBUG
|
|
ErrorF("# of screens: %d\n", mac_scrs);
|
|
#endif
|
|
for(scr = 0; scr < mac_scrs; scr++){
|
|
#if DEBUG
|
|
ErrorF("adding screen %d\n", scr);
|
|
#endif
|
|
#if CATCH_BROKEN_MODE
|
|
if(mac_fbs[scr].idata.psize == 0)
|
|
mac_fbs[scr].idata.psize = 1;
|
|
#endif /* CATCH_BROKEN_MODE */
|
|
if(mac_fbs[scr].idata.psize == 1)
|
|
AddScreen(mac68kMonoInit, argc, argv);
|
|
else
|
|
#if COLOR_SUPPORT /* Damn, I'm lazy! */
|
|
AddScreen(mac68kColorInit, argc, argv);
|
|
#else
|
|
FatalError("I don't support color screens!\n");
|
|
#endif
|
|
}
|
|
|
|
xsi->numScreens = scr;
|
|
}
|
|
|
|
|
|
void InitOutput(
|
|
ScreenInfo *xsi,
|
|
int argc,
|
|
char **argv)
|
|
{
|
|
static int dejavu = 0;
|
|
|
|
if(dejavu)
|
|
return;
|
|
else
|
|
dejavu = 1;
|
|
|
|
/* set up all screens */
|
|
#if MAC68K_IOHACK
|
|
initialize_desktop();
|
|
#endif
|
|
choose_best_depths();
|
|
parse_args(argc, argv);
|
|
setup_screens(xsi, argc, argv);
|
|
}
|
|
|
|
|
|
void InitInput(
|
|
int argc,
|
|
char **argv)
|
|
{
|
|
DeviceIntPtr mouse;
|
|
DeviceIntPtr kbd;
|
|
static int dejavu = 0;
|
|
|
|
if(dejavu)
|
|
return;
|
|
else
|
|
dejavu = 1;
|
|
|
|
mac68k_mouse = mouse = AddInputDevice((DeviceProc)mac68k_mouseproc,
|
|
TRUE);
|
|
RegisterPointerDevice(mouse);
|
|
miRegisterPointerDevice(screenInfo.screens[0], mouse);
|
|
|
|
mac68k_kbd = kbd = AddInputDevice((DeviceProc)mac68k_kbdproc, TRUE);
|
|
RegisterKeyboardDevice(kbd);
|
|
|
|
if (!mieqInit ((DevicePtr)kbd, (DevicePtr)mouse))
|
|
FatalError ("could not initialize event queue");
|
|
|
|
mac_lasteventtime = time(0) * 1000;
|
|
}
|
|
|
|
|
|
void AbortDDX(void)
|
|
{
|
|
close(mac_adbfd);
|
|
}
|
|
|
|
|
|
void ddxGiveUp(void)
|
|
{
|
|
}
|
|
|
|
|
|
int ddxProcessArgument(
|
|
int argc,
|
|
char **argv,
|
|
int i)
|
|
{
|
|
if(strcmp(argv[i], "-screen") == 0)
|
|
return(3);
|
|
return(0);
|
|
}
|
|
|
|
|
|
void ddxUseMsg(void)
|
|
{
|
|
ErrorF("-screen S D\t\t\tuse depth <D> for screen <S>");
|
|
ErrorF("\t(use the 'console' program for screen information)");
|
|
}
|
|
|
|
|
|
void MessageF(
|
|
char *s)
|
|
{
|
|
ErrorF(s);
|
|
}
|
|
|
|
void OsVendorFatalError(void)
|
|
{
|
|
}
|
|
|
|
#ifdef DPMSExtension
|
|
/*
|
|
* DPMS stubs
|
|
*/
|
|
void DPMSSet(int level)
|
|
{
|
|
}
|
|
|
|
int DPMSGet(int level)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
Bool DPMSSupported()
|
|
{
|
|
return FALSE;
|
|
}
|
|
#endif /* DPMSExtension */
|