/* Copyright (c) 1986, 1987 by Hewlett-Packard Company Copyright (c) 1986, 1987 by the Massachusetts Institute of Technology Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, 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 M.I.T. not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. HEWLETT-PACKARD MAKES NO WARRANTY OF ANY KIND WITH REGARD TO THIS SOFWARE, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Hewlett-Packard shall not be liable for errors contained herein or direct, indirect, special, incidental or consequential damages in connection with the furnishing, performance, or use of this material. This software is not subject to any license of the American Telephone and Telegraph Company or of the Regents of the University of California. */ /******************************************************************************* * * File: init.c * RCS: $Revision: 1.2 $ * Description: Multiple screen initialization * Author: John Howard Palevich * Created: April 22, 1987 * Modified: April 29, 1987 17:41:59 (John Howard Palevich) * Language: C * Package: USER * Status: Experimental (Do Not Distribute) * * (c) Copyright 1987, Hewlett-Packard, Inc., all rights reserved. * *******************************************************************************/ #include "X.h" #include "Xproto.h" #include <servermd.h> #include "screenint.h" #include "input.h" #include "cursor.h" #include "misc.h" #include "scrnintstr.h" #include "gcstruct.h" #include <stdio.h> #include <ctype.h> #include <signal.h> #include <setjmp.h> #include <sys/types.h> #include <sys/stat.h> #ifdef hpux # include <sys/sysmacros.h> #endif #ifndef hpux # include <sys/ioctl.h> # include <grfioctl.h> #else # include <sys/graphics.h> #endif #include "hpDisplays.h" #include <fcntl.h> extern char *display; /* display number as a string */ static char xscreens[80]; static int ConfigFile=FALSE; #ifdef hpux static char DefaultScreen[]="/dev/crt"; #else static char DefaultScreen[]="/dev/grf0"; #endif /* * NewRule is an array of replacement rules. Given a replacement rule, * * colunm foreground pixel background pixel * 0 0 0 * 1 0 1 * 2 1 0 * 3 1 1 * 4 1 clear * 5 0 clear */ u_char XHP_NewRule [16][6] = { GXclear, GXclear, GXclear, GXclear, GXandInverted,GXandInverted, GXclear, GXandInverted, GXand, GXnoop, GXnoop, GXandInverted, GXclear, GXnor, GXandReverse, GXinvert,GXxor, GXandInverted, GXclear, GXcopyInverted,GXcopy, GXset, GXor, GXandInverted, GXnoop, GXand, GXandInverted, GXclear, GXandInverted,GXnoop, GXnoop, GXnoop, GXnoop, GXnoop, GXnoop, GXnoop, GXnoop, GXequiv, GXxor, GXinvert,GXxor, GXnoop, GXnoop, GXorInverted, GXor, GXset, GXor, GXnoop, GXinvert,GXandReverse, GXnor, GXclear, GXandInverted,GXxor, GXinvert,GXxor, GXequiv, GXnoop, GXnoop, GXxor, GXinvert,GXinvert, GXinvert, GXinvert,GXxor, GXxor, GXinvert,GXnand, GXorReverse, GXset, GXor, GXxor, GXset, GXcopy, GXcopyInverted,GXclear, GXandInverted,GXor, GXset, GXor, GXorInverted, GXnoop, GXnoop, GXor, GXset, GXorReverse, GXnand, GXinvert,GXxor, GXor, GXset, GXset, GXset, GXset, GXor, GXor }; #define IOMAP_BASE 0xb00000 static unsigned char *iomapBase; int TopcatBrainDamage = 0; int catseyeMono = 0; static PixmapFormatRec formats[] = { 1, 1, BITMAP_SCANLINE_PAD, /* 1-bit deep for all */ #if 0 4, 4, BITMAP_SCANLINE_PAD, /* 4-bit deep for Burgundy */ #endif 8, 8, BITMAP_SCANLINE_PAD, /* 8-bit deep for most color displays */ #if 0 16,16, BITMAP_SCANLINE_PAD, /*16-bit deep for most color displays */ #endif }; #define NUMFORMATS (sizeof formats)/(sizeof formats[0]) /* Pmap represents all 256 combinations of 8 bits of information. */ /* For example, if my byte of 8 pixels of information is 01010101 */ /* then the bytes that get written in memory are 00ff00ff,00ff00ff*/ /* The bytes are written using the current write enable and */ /* drawmode value. */ int XHP_pmap[256][2]={0x00000000,0x00000000, 0x00000000,0x000000ff, 0x00000000,0x0000ff00, 0x00000000,0x0000ffff, 0x00000000,0x00ff0000, 0x00000000,0x00ff00ff, 0x00000000,0x00ffff00, 0x00000000,0x00ffffff, 0x00000000,0xff000000, 0x00000000,0xff0000ff, 0x00000000,0xff00ff00, 0x00000000,0xff00ffff, 0x00000000,0xffff0000, 0x00000000,0xffff00ff, 0x00000000,0xffffff00, 0x00000000,0xffffffff, 0x000000ff,0x00000000, 0x000000ff,0x000000ff, 0x000000ff,0x0000ff00, 0x000000ff,0x0000ffff, 0x000000ff,0x00ff0000, 0x000000ff,0x00ff00ff, 0x000000ff,0x00ffff00, 0x000000ff,0x00ffffff, 0x000000ff,0xff000000, 0x000000ff,0xff0000ff, 0x000000ff,0xff00ff00, 0x000000ff,0xff00ffff, 0x000000ff,0xffff0000, 0x000000ff,0xffff00ff, 0x000000ff,0xffffff00, 0x000000ff,0xffffffff, 0x0000ff00,0x00000000, 0x0000ff00,0x000000ff, 0x0000ff00,0x0000ff00, 0x0000ff00,0x0000ffff, 0x0000ff00,0x00ff0000, 0x0000ff00,0x00ff00ff, 0x0000ff00,0x00ffff00, 0x0000ff00,0x00ffffff, 0x0000ff00,0xff000000, 0x0000ff00,0xff0000ff, 0x0000ff00,0xff00ff00, 0x0000ff00,0xff00ffff, 0x0000ff00,0xffff0000, 0x0000ff00,0xffff00ff, 0x0000ff00,0xffffff00, 0x0000ff00,0xffffffff, 0x0000ffff,0x00000000, 0x0000ffff,0x000000ff, 0x0000ffff,0x0000ff00, 0x0000ffff,0x0000ffff, 0x0000ffff,0x00ff0000, 0x0000ffff,0x00ff00ff, 0x0000ffff,0x00ffff00, 0x0000ffff,0x00ffffff, 0x0000ffff,0xff000000, 0x0000ffff,0xff0000ff, 0x0000ffff,0xff00ff00, 0x0000ffff,0xff00ffff, 0x0000ffff,0xffff0000, 0x0000ffff,0xffff00ff, 0x0000ffff,0xffffff00, 0x0000ffff,0xffffffff, 0x00ff0000,0x00000000, 0x00ff0000,0x000000ff, 0x00ff0000,0x0000ff00, 0x00ff0000,0x0000ffff, 0x00ff0000,0x00ff0000, 0x00ff0000,0x00ff00ff, 0x00ff0000,0x00ffff00, 0x00ff0000,0x00ffffff, 0x00ff0000,0xff000000, 0x00ff0000,0xff0000ff, 0x00ff0000,0xff00ff00, 0x00ff0000,0xff00ffff, 0x00ff0000,0xffff0000, 0x00ff0000,0xffff00ff, 0x00ff0000,0xffffff00, 0x00ff0000,0xffffffff, 0x00ff00ff,0x00000000, 0x00ff00ff,0x000000ff, 0x00ff00ff,0x0000ff00, 0x00ff00ff,0x0000ffff, 0x00ff00ff,0x00ff0000, 0x00ff00ff,0x00ff00ff, 0x00ff00ff,0x00ffff00, 0x00ff00ff,0x00ffffff, 0x00ff00ff,0xff000000, 0x00ff00ff,0xff0000ff, 0x00ff00ff,0xff00ff00, 0x00ff00ff,0xff00ffff, 0x00ff00ff,0xffff0000, 0x00ff00ff,0xffff00ff, 0x00ff00ff,0xffffff00, 0x00ff00ff,0xffffffff, 0x00ffff00,0x00000000, 0x00ffff00,0x000000ff, 0x00ffff00,0x0000ff00, 0x00ffff00,0x0000ffff, 0x00ffff00,0x00ff0000, 0x00ffff00,0x00ff00ff, 0x00ffff00,0x00ffff00, 0x00ffff00,0x00ffffff, 0x00ffff00,0xff000000, 0x00ffff00,0xff0000ff, 0x00ffff00,0xff00ff00, 0x00ffff00,0xff00ffff, 0x00ffff00,0xffff0000, 0x00ffff00,0xffff00ff, 0x00ffff00,0xffffff00, 0x00ffff00,0xffffffff, 0x00ffffff,0x00000000, 0x00ffffff,0x000000ff, 0x00ffffff,0x0000ff00, 0x00ffffff,0x0000ffff, 0x00ffffff,0x00ff0000, 0x00ffffff,0x00ff00ff, 0x00ffffff,0x00ffff00, 0x00ffffff,0x00ffffff, 0x00ffffff,0xff000000, 0x00ffffff,0xff0000ff, 0x00ffffff,0xff00ff00, 0x00ffffff,0xff00ffff, 0x00ffffff,0xffff0000, 0x00ffffff,0xffff00ff, 0x00ffffff,0xffffff00, 0x00ffffff,0xffffffff, 0xff000000,0x00000000, 0xff000000,0x000000ff, 0xff000000,0x0000ff00, 0xff000000,0x0000ffff, 0xff000000,0x00ff0000, 0xff000000,0x00ff00ff, 0xff000000,0x00ffff00, 0xff000000,0x00ffffff, 0xff000000,0xff000000, 0xff000000,0xff0000ff, 0xff000000,0xff00ff00, 0xff000000,0xff00ffff, 0xff000000,0xffff0000, 0xff000000,0xffff00ff, 0xff000000,0xffffff00, 0xff000000,0xffffffff, 0xff0000ff,0x00000000, 0xff0000ff,0x000000ff, 0xff0000ff,0x0000ff00, 0xff0000ff,0x0000ffff, 0xff0000ff,0x00ff0000, 0xff0000ff,0x00ff00ff, 0xff0000ff,0x00ffff00, 0xff0000ff,0x00ffffff, 0xff0000ff,0xff000000, 0xff0000ff,0xff0000ff, 0xff0000ff,0xff00ff00, 0xff0000ff,0xff00ffff, 0xff0000ff,0xffff0000, 0xff0000ff,0xffff00ff, 0xff0000ff,0xffffff00, 0xff0000ff,0xffffffff, 0xff00ff00,0x00000000, 0xff00ff00,0x000000ff, 0xff00ff00,0x0000ff00, 0xff00ff00,0x0000ffff, 0xff00ff00,0x00ff0000, 0xff00ff00,0x00ff00ff, 0xff00ff00,0x00ffff00, 0xff00ff00,0x00ffffff, 0xff00ff00,0xff000000, 0xff00ff00,0xff0000ff, 0xff00ff00,0xff00ff00, 0xff00ff00,0xff00ffff, 0xff00ff00,0xffff0000, 0xff00ff00,0xffff00ff, 0xff00ff00,0xffffff00, 0xff00ff00,0xffffffff, 0xff00ffff,0x00000000, 0xff00ffff,0x000000ff, 0xff00ffff,0x0000ff00, 0xff00ffff,0x0000ffff, 0xff00ffff,0x00ff0000, 0xff00ffff,0x00ff00ff, 0xff00ffff,0x00ffff00, 0xff00ffff,0x00ffffff, 0xff00ffff,0xff000000, 0xff00ffff,0xff0000ff, 0xff00ffff,0xff00ff00, 0xff00ffff,0xff00ffff, 0xff00ffff,0xffff0000, 0xff00ffff,0xffff00ff, 0xff00ffff,0xffffff00, 0xff00ffff,0xffffffff, 0xffff0000,0x00000000, 0xffff0000,0x000000ff, 0xffff0000,0x0000ff00, 0xffff0000,0x0000ffff, 0xffff0000,0x00ff0000, 0xffff0000,0x00ff00ff, 0xffff0000,0x00ffff00, 0xffff0000,0x00ffffff, 0xffff0000,0xff000000, 0xffff0000,0xff0000ff, 0xffff0000,0xff00ff00, 0xffff0000,0xff00ffff, 0xffff0000,0xffff0000, 0xffff0000,0xffff00ff, 0xffff0000,0xffffff00, 0xffff0000,0xffffffff, 0xffff00ff,0x00000000, 0xffff00ff,0x000000ff, 0xffff00ff,0x0000ff00, 0xffff00ff,0x0000ffff, 0xffff00ff,0x00ff0000, 0xffff00ff,0x00ff00ff, 0xffff00ff,0x00ffff00, 0xffff00ff,0x00ffffff, 0xffff00ff,0xff000000, 0xffff00ff,0xff0000ff, 0xffff00ff,0xff00ff00, 0xffff00ff,0xff00ffff, 0xffff00ff,0xffff0000, 0xffff00ff,0xffff00ff, 0xffff00ff,0xffffff00, 0xffff00ff,0xffffffff, 0xffffff00,0x00000000, 0xffffff00,0x000000ff, 0xffffff00,0x0000ff00, 0xffffff00,0x0000ffff, 0xffffff00,0x00ff0000, 0xffffff00,0x00ff00ff, 0xffffff00,0x00ffff00, 0xffffff00,0x00ffffff, 0xffffff00,0xff000000, 0xffffff00,0xff0000ff, 0xffffff00,0xff00ff00, 0xffffff00,0xff00ffff, 0xffffff00,0xffff0000, 0xffffff00,0xffff00ff, 0xffffff00,0xffffff00, 0xffffff00,0xffffffff, 0xffffffff,0x00000000, 0xffffffff,0x000000ff, 0xffffffff,0x0000ff00, 0xffffffff,0x0000ffff, 0xffffffff,0x00ff0000, 0xffffffff,0x00ff00ff, 0xffffffff,0x00ffff00, 0xffffffff,0x00ffffff, 0xffffffff,0xff000000, 0xffffffff,0xff0000ff, 0xffffffff,0xff00ff00, 0xffffffff,0xff00ffff, 0xffffffff,0xffff0000, 0xffffffff,0xffff00ff, 0xffffffff,0xffffff00, 0xffffffff,0xffffffff}; /*XHP_pmap end*/ int XHP_QUADALIGN; static jmp_buf env; /* * routine to handle the bus error we might get in testing for the alignment * restrictions of this cpu. */ static int sigbusHandler() { XHP_QUADALIGN = 1; longjmp(env, 1); } static int ReadLine(); typedef struct { char *productNumber; char *productNickname; Bool (*InfoScreen)(); Bool (*InitScreen)(); } ScreenTableRec; static ScreenTableRec *FindScreen(); #define MAXARG 10 #define MAXSTRING 120 /*- *----------------------------------------------------------------------- * 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; FILE *in; static int firstTime = 1; static int numScreens; static ScreenTableRec *FoundScreens[MAXSCREENS]; ScreenTableRec *s; #ifdef hpux char *dispaddr, *getenv(); #endif struct stat statbuf; char minornumber[10]; /* * test for data alignment restriction of this cpu. If this cpu * doesn't allow long-word writes on an odd address, then we assume * that it requires quad-word alignment. This reduces our headaches * to only two cases - 68020s (no restrictions) and others (e.g. * 68010 and Spectrum). */ { int *test; char foo[8]; static struct sigvec timeout_vec = { sigbusHandler, 0, 0 }; struct sigvec old_vec; test = (int *) ((int)foo | 3) + 1; /* generate an odd address */ XHP_QUADALIGN = 0; #ifdef hp300 #define sigvector sigvec #endif #if defined(hp9000s300) || defined(hp300) /* check for 310 */ sigvector(SIGBUS, &timeout_vec, &old_vec); if(!setjmp(env)) *test = 1; /* generate a bus error on 68010s or Spectrums */ sigvector(SIGBUS, &old_vec, 0); #else /* need word align on 800 */ XHP_QUADALIGN = 1; #endif /* hp9000s300 */ } iomapBase = (unsigned char *) IOMAP_BASE; #ifdef hpux if (dispaddr = getenv("SB_DISPLAY_ADDR")) iomapBase = (unsigned char *) strtol(dispaddr, (char **)NULL, 0); #endif 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 (firstTime) { firstTime = 0; (void) sprintf(xscreens, "%s/X%sscreens", LIBDIR, display); if (NULL == (in = fopen (xscreens, "r"))) { perror(xscreens); ErrorF("Can't open screen configuration file, defaulting to %s.\n", DefaultScreen); ConfigFile=FALSE; } else ConfigFile=TRUE; numScreens = 0; for (i = 0; i<MAXSCREENS && ((!ConfigFile) ? TRUE : ! feof(in) ); i++) { char *argv[MAXARG]; int argc; if (!ConfigFile) argv[0] = DefaultScreen; else { while (!(argc = ReadLine(in, argv))) /* handle blank lines */ ; if (argc == -1) /* eof */ break; if (argc < 0) { ErrorF("InitOutput: %s: line %d: Too many fields.\n", xscreens, i+1); goto fatal_error; } /* for compatibility with R2 screens tables */ if (argc == 3) { if ((strcmp (argv[0], "topcat") == 0) || (strcmp (argv[0], "Topcat") == 0)) { argv[0] = argv[2]; argc = 1; } else { ErrorF ("InitOutput: %s, line %d: unsupported display type \"%s\".\n", xscreens, i+1, argv[0]); goto fatal_error; } } if ( argc != 1 ) { ErrorF("InitOutput: %s: line %d: Wrong number of fields.\n", xscreens, i+1); goto fatal_error; } } if ((s = FindScreen(argv[0])) == NULL) { ErrorF("InitOutput: %s: line %d: Unknown screen %s.\n", xscreens, i+1, argv[0]); goto fatal_error; } /* munge new structure to match old argv structures */ /* BOGOSITY ALERT argv and argc are munged for subsequent calls */ argv[2] = argv[0]; argv[0] = s->productNickname; if (stat(argv[2], &statbuf) < 0) { ErrorF("InitOutput: %s: could not stat %s.\n",argv[0],argv[2]); goto fatal_error; } #ifdef hpux (void) sprintf(minornumber, "%x", minor(statbuf.st_rdev)); #else (void) sprintf(minornumber, "%d", minor(statbuf.st_rdev)); #endif argv[3] = minornumber; argc = 4; if (!(s->InfoScreen)(numScreens, argv, argc)) { ErrorF("InitOutput: %s: line %d: Couldn't find this screen %s.\n", xscreens, i+1, argv[0]); goto fatal_error; } FoundScreens[numScreens++] = s; if (!ConfigFile) break; } if (ConfigFile) fclose(in); } for (i=0; i<numScreens; i++) { s = FoundScreens[i]; if (AddScreen(s->InitScreen, argc, argv) < 0) { ErrorF("InitOutput: Couldn't add a screen.\n"); exit (1); } } return; fatal_error: fclose(in); ErrorF("InitOutput: Couldn't initialize screens.\n"); exit(1); } static int ReadLine(in, argv) FILE *in; char **argv; { int argc; static char line[MAXSTRING]; char *s; int state; if (NULL == fgets(line, MAXSTRING, in)) return(-1); for (state = argc = 0, s = line; argc < MAXARG; s++) { switch ( *s ) { case '#': case '\n': *s = '\0'; case '\0': return (argc); case ' ': case '\t': state = 0; *s = '\0'; break; default: if ( state == 0 ) { state = 1; argv[argc++] = s; } break; } } return(-2); } #define STUPID_MOBERLY -1 /* Declare the ScreenInfo(), ScreenInit() and ScreenClose() functions here. */ extern Bool mobScreenInfo(), mobScreenInit(); extern Bool gbxScreenInfo(), gbxScreenInit(); extern Bool topcatScreenInfo(), topcatScreenInit(); extern Bool mrtopcatScreenInfo(), mrtopcatScreenInit(); extern Bool catseyeScreenInfo(), catseyeScreenInit(); extern Bool renScreenInfo(), renScreenInit(); extern Bool orenScreenInfo(), orenScreenInit(); extern Bool davinciScreenInfo(), davinciScreenInit(); extern Bool oDavinciScreenInit(); extern Bool hyperScreenInfo(), hyperScreenInit(); /* * Table of known frame buffers */ static ScreenTableRec screenTable[] = { {"98633", "moberly", mobScreenInfo, mobScreenInit}, {"98700", "gatorbox", gbxScreenInfo, gbxScreenInit}, {"98547", "topcat", topcatScreenInfo, topcatScreenInit}, {"98543", "mrtopcat", mrtopcatScreenInfo, mrtopcatScreenInit}, {"98550", "catseye", topcatScreenInfo, topcatScreenInit}, {"98720", "renaissance", renScreenInfo, renScreenInit}, {"98720", "orenaissance", orenScreenInfo, orenScreenInit}, {"98730", "davinci", davinciScreenInfo, davinciScreenInit}, {"98730", "odavinci", davinciScreenInfo, oDavinciScreenInit}, {"a1096a", "hyperion", hyperScreenInfo, hyperScreenInit}, {(char *) NULL, (char *) NULL, (Bool (*)()) NULL, (Bool (*)()) NULL} }; static ScreenTableRec * FindScreen(devname) char *devname; { ScreenTableRec *s; int fd, gcid; #ifdef hpux int gcon; #endif char name[40]; static struct stat buf; struct hp_grfreg *ce; if ((fd = open(devname, O_RDWR)) < 0) { perror(devname); ErrorF("FindScreen couldn't open %s \n", devname); return (NULL); } #ifdef hpux if (ioctl(fd, GCON, &gcon) < 0 || ioctl(fd, GCID, &gcid) < 0) gcid = STUPID_MOBERLY; #else { struct grfinfo gi; if (ioctl(fd, GRFIOCGINFO, &gi) < 0 || ioctl(fd, GRFIOCON, 0) < 0) gcid = STUPID_MOBERLY; else gcid = gi.gd_id; } #endif fstat(fd, &buf); switch (gcid) { case GCID_GATORBOX: strcpy(name, "gatorbox"); break; case GCID_TOPCAT: #ifdef hpux ce = (struct hp_grfreg *) iomapBase; if (ioctl(fd, GCMAP, &ce) < 0) { perror("GCMAP:"); ErrorF("FindScreen: Error getting address of %s\n", devname); close (fd); return (NULL); } #else { u_char *Addr = (u_char *) 0; if (ioctl (fd, GRFIOCMAP, &Addr) < 0) { (void) ioctl (fd, GRFIOCOFF, 0); perror("GRFIOCMAP:"); ErrorF("FindScreen: Error getting address of %s\n", devname); close (fd); return (NULL); } ce = (struct hp_grfreg *) Addr; } #endif if (ce->gr_id2 >= ID2_LCC) strcpy(name, "catseye"); else if (ce->gr_bits) strcpy(name, "mrtopcat"); else strcpy(name, "topcat"); #ifdef hpux if (ioctl(fd, GCUNMAP, &ce) < 0) { perror("GCUNMAP:"); ErrorF("FindScreen: Error freeing temp storage %s\n", devname); close (fd); return (NULL); } #else if (ioctl(fd, GRFIOCUNMAP, &ce) < 0) { perror("GRFIOCUNMAP:"); ErrorF("FindScreen: Error freeing temp storage %s\n", devname); close (fd); return (NULL); } #endif break; case GCID_RENAISSANCE: if ((minor(buf.st_rdev)) & 0x000003) strcpy(name, "orenaissance"); else strcpy(name, "renaissance"); break; case GCID_FIREEYE: strcpy(name, "catseye"); break; case GCID_HYPERION: strcpy(name, "hyperion"); break; case GCID_DAVINCI: if ((minor(buf.st_rdev)) & 0x000003) strcpy(name, "odavinci"); else strcpy(name, "davinci"); break; case STUPID_MOBERLY: strcpy(name, "moberly"); break; default: ErrorF("FindScreen: unknown screen type %s \n", devname); return (NULL); } close (fd); for (s = screenTable; s->productNumber != NULL; s++) { if (strcmp(s->productNumber, name) == 0 || strcmp(s->productNickname, name) == 0) return (s); } return (NULL); } #ifdef hpux unsigned char * FrameBufferBase(size) long int size; { unsigned char *base = iomapBase; /* Round size to a 4K page */ size = (size + 4095) & 0xfffff000; iomapBase += size; return ( base ); } #endif /* * DDX - specific abort routine. Called by AbortServer(). */ void AbortDDX() { } /* Called by GiveUp(). */ void ddxGiveUp() { } int ddxProcessArgument (argc, argv, i) int argc; char *argv[]; int i; { if (strcmp (argv[i], "-tcbd") == 0) { TopcatBrainDamage++; return 1; } if (strcmp (argv[i], "-catseyeMono") == 0) { catseyeMono++; return 1; } return 0; } void ddxUseMsg() { ErrorF("-tcbd run in topcat braindamage mode\n"); ErrorF("-catseyeMono run 2bit deep catseyes in Monochrome\n"); }