![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sunInit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / sun|
Return to sunInit.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / sun |
1.1 root 1: /*-
2: * sunInit.c --
3: * Initialization functions for screen/keyboard/mouse, etc.
4: *
5: * Copyright (c) 1987 by the Regents of the University of California
6: *
7: * Permission to use, copy, modify, and distribute this
8: * software and its documentation for any purpose and without
9: * fee is hereby granted, provided that the above copyright
10: * notice appear in all copies. The University of California
11: * makes no representations about the suitability of this
12: * software for any purpose. It is provided "as is" without
13: * express or implied warranty.
14: *
15: *
16: */
17:
18: /************************************************************
19: Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
20:
21: All Rights Reserved
22:
23: Permission to use, copy, modify, and distribute this
24: software and its documentation for any purpose and without
25: fee is hereby granted, provided that the above copyright no-
26: tice appear in all copies and that both that copyright no-
27: tice and this permission notice appear in supporting docu-
28: mentation, and that the names of Sun or MIT not be used in
29: advertising or publicity pertaining to distribution of the
30: software without specific prior written permission. Sun and
31: M.I.T. make no representations about the suitability of this
32: software for any purpose. It is provided "as is" without any
33: express or implied warranty.
34:
35: SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
36: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
37: NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
38: ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
39: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
40: PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
41: OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
42: THE USE OR PERFORMANCE OF THIS SOFTWARE.
43:
44: ********************************************************/
45:
46: #ifndef lint
47: static char sccsid[] = "%W %G Copyright 1987 Sun Micro";
48: #endif
49:
50: #include "sun.h"
51: #include <servermd.h>
52: #include "dixstruct.h"
53: #include "dix.h"
54: #include "opaque.h"
55:
56: extern int sunMouseProc();
57: extern void sunKbdProc();
58: extern Bool sunBW2Probe();
59: extern Bool sunCG2CProbe();
60: extern Bool sunCG4CProbe();
61: extern void ProcessInputEvents();
62:
63: extern void SetInputCheck();
64: extern char *strncpy();
65: extern GCPtr CreateScratchGC();
66:
67: #define XDEVICE "XDEVICE"
68: #define PARENT "WINDOW_GFX"
69:
70: int sunSigIO = 0; /* For use with SetInputCheck */
71:
72: /* What should this *really* be? */
73: #define MOTION_BUFFER_SIZE 0
74:
75: /*-
76: *-----------------------------------------------------------------------
77: * SigIOHandler --
78: * Signal handler for SIGIO - input is available.
79: *
80: * Results:
81: * isItTimeToYield is set - ProcessInputEvents() will be called soon.
82: *
83: * Side Effects:
84: * None
85: *
86: *-----------------------------------------------------------------------
87: */
88: /*ARGSUSED*/
89: static void
90: SigIOHandler(sig, code, scp)
91: int code;
92: int sig;
93: struct sigcontext *scp;
94: {
95: sunSigIO++;
96: isItTimeToYield++;
97: }
98:
99: /*
100: * ZOIDS should only ever be defined if SUN_WINDOWS is also defined.
101: */
102: #ifdef ZOIDS
103: sunFbDataRec sunFbData[] = {
104: sunBW2Probe, "/dev/bwtwo0", neverProbed, 0, 0,
105: sunCG2CProbe, "/dev/cgtwo0", neverProbed, 0, 0,
106: sunCG4CProbe, "/dev/cgfour0", neverProbed, 0, 0,
107: };
108: #else ZOIDS
109: sunFbDataRec sunFbData[] = {
110: sunBW2Probe, "/dev/bwtwo0", neverProbed,
111: sunCG2CProbe, "/dev/cgtwo0", neverProbed,
112: sunCG4CProbe, "/dev/cgfour0", neverProbed,
113: };
114: #endif ZOIDS
115:
116: /*
117: * NUMSCREENS is the number of supported frame buffers (i.e. the number of
118: * structures in sunFbData which have an actual probeProc).
119: */
120: #define NUMSCREENS (sizeof(sunFbData)/sizeof(sunFbData[0]))
121: #define NUMDEVICES 2
122:
123: fbFd sunFbs[NUMSCREENS]; /* Space for descriptors of open frame buffers */
124:
125: static PixmapFormatRec formats[] = {
126: 1, 1, BITMAP_SCANLINE_PAD, /* 1-bit deep */
127: 8, 8, BITMAP_SCANLINE_PAD, /* 8-bit deep */
128: };
129: #define NUMFORMATS (sizeof formats)/(sizeof formats[0])
130:
131: /*-
132: *-----------------------------------------------------------------------
133: * InitOutput --
134: * Initialize screenInfo for all actually accessible framebuffers.
135: * The
136: *
137: * Results:
138: * screenInfo init proc field set
139: *
140: * Side Effects:
141: * None
142: *
143: *-----------------------------------------------------------------------
144: */
145:
146: InitOutput(pScreenInfo, argc, argv)
147: ScreenInfo *pScreenInfo;
148: int argc;
149: char **argv;
150: {
151: int i, index, ac = argc;
152: char **av = argv;
153: int nonBlockConsole = 1;
154:
155: while (ac--) {
156: if (!strcmp(*av,"-debug")) {
157: nonBlockConsole = 0;
158: break;
159: }
160: av++;
161: }
162: /*
163: * Writes to /dev/console can block - causing an
164: * excess of error messages to hang the server in
165: * deadlock. So.......
166: */
167: if (nonBlockConsole && (fcntl(2, F_SETFL, O_NDELAY) < 0)) {
168: perror("fcntl");
169: ErrorF("InitOutput: can't put stderr in non-block mode\n");
170: }
171: pScreenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
172: pScreenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
173: pScreenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
174: pScreenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
175:
176: pScreenInfo->numPixmapFormats = NUMFORMATS;
177: for (i=0; i< NUMFORMATS; i++)
178: {
179: pScreenInfo->formats[i] = formats[i];
180: }
181:
182: for (i = 0, index = 0; i < NUMSCREENS; i++) {
183: if ((* sunFbData[i].probeProc) (pScreenInfo, index, i, argc, argv)) {
184: /* This display exists OK */
185: index++;
186: } else {
187: /* This display can't be opened */
188: ;
189: }
190: }
191: if (index == 0)
192: FatalError("Can't find any displays\n");
193:
194: pScreenInfo->numScreens = index;
195:
196: sunInitCursor();
197: signal(SIGWINCH, SIG_IGN);
198: }
199:
200: /*-
201: *-----------------------------------------------------------------------
202: * InitInput --
203: * Initialize all supported input devices...what else is there
204: * besides pointer and keyboard?
205: *
206: * Results:
207: * None.
208: *
209: * Side Effects:
210: * Two DeviceRec's are allocated and registered as the system pointer
211: * and keyboard devices.
212: *
213: *-----------------------------------------------------------------------
214: */
215: /*ARGSUSED*/
216: InitInput(argc, argv)
217: int argc;
218: char **argv;
219: {
220: DevicePtr p, k;
221: static int zero = 0;
222:
223: p = AddInputDevice(sunMouseProc, TRUE);
224: k = AddInputDevice(sunKbdProc, TRUE);
225:
226: RegisterPointerDevice(p, MOTION_BUFFER_SIZE);
227: RegisterKeyboardDevice(k);
228: signal(SIGIO, SigIOHandler);
229:
230: SetInputCheck (&zero, &isItTimeToYield);
231: }
232:
233: /*-
234: *-----------------------------------------------------------------------
235: * sunQueryBestSize --
236: * Supposed to hint about good sizes for things.
237: *
238: * Results:
239: * Perhaps change *pwidth (Height irrelevant)
240: *
241: * Side Effects:
242: * None.
243: *
244: *-----------------------------------------------------------------------
245: */
246: /*ARGSUSED*/
247: void
248: sunQueryBestSize(class, pwidth, pheight)
249: int class;
250: short *pwidth;
251: short *pheight;
252: {
253: unsigned width, test;
254:
255: switch(class)
256: {
257: case CursorShape:
258: case TileShape:
259: case StippleShape:
260: width = *pwidth;
261: if (width > 0) {
262: /* Return the closes power of two not less than what they gave me */
263: test = 0x80000000;
264: /* Find the highest 1 bit in the width given */
265: while(!(test & width))
266: test >>= 1;
267: /* If their number is greater than that, bump up to the next
268: * power of two */
269: if((test - 1) & width)
270: test <<= 1;
271: *pwidth = test;
272: }
273: /* We don't care what height they use */
274: break;
275: }
276: }
277:
278: /*-
279: *-----------------------------------------------------------------------
280: * sunScreenInit --
281: * Things which must be done for all types of frame buffers...
282: * Should be called last of all.
283: *
284: * Results:
285: * None.
286: *
287: * Side Effects:
288: * The graphics context for the screen is created. The CreateGC,
289: * CreateWindow and ChangeWindowAttributes vectors are changed in
290: * the screen structure.
291: *
292: * Both a BlockHandler and a WakeupHandler are installed for the
293: * first screen. Together, these handlers implement autorepeat
294: * keystrokes on the Sun.
295: *
296: *-----------------------------------------------------------------------
297: */
298: void
299: sunScreenInit (pScreen)
300: ScreenPtr pScreen;
301: {
302: fbFd *fb;
303: DrawablePtr pDrawable;
304: extern void sunBlockHandler();
305: extern void sunWakeupHandler();
306: static autoRepeatHandlersInstalled = FALSE;
307: static ScreenPtr autoRepeatScreen;
308:
309: fb = &sunFbs[pScreen->myNum];
310:
311: /*
312: * Prepare the GC for cursor functions on this screen.
313: * Do this before setting interceptions to avoid looping when
314: * putting down the cursor...
315: */
316: pDrawable = (DrawablePtr)(pScreen->devPrivate);
317:
318: fb->pGC = CreateScratchGC (pDrawable->pScreen, pDrawable->depth);
319:
320: /*
321: * By setting graphicsExposures false, we prevent any expose events
322: * from being generated in the CopyArea requests used by the cursor
323: * routines.
324: */
325: fb->pGC->graphicsExposures = FALSE;
326:
327: /*
328: * Preserve the "regular" functions
329: */
330: fb->CreateGC = pScreen->CreateGC;
331: fb->CreateWindow = pScreen->CreateWindow;
332: fb->ChangeWindowAttributes = pScreen->ChangeWindowAttributes;
333: fb->GetImage = pScreen->GetImage;
334: fb->GetSpans = pScreen->GetSpans;
335:
336: /*
337: * Interceptions
338: */
339: pScreen->CreateGC = sunCreateGC;
340: pScreen->CreateWindow = sunCreateWindow;
341: pScreen->ChangeWindowAttributes = sunChangeWindowAttributes;
342: pScreen->QueryBestSize = sunQueryBestSize;
343: pScreen->GetImage = sunGetImage;
344: pScreen->GetSpans = sunGetSpans;
345:
346: /*
347: * Cursor functions
348: */
349: pScreen->RealizeCursor = sunRealizeCursor;
350: pScreen->UnrealizeCursor = sunUnrealizeCursor;
351: pScreen->DisplayCursor = sunDisplayCursor;
352: pScreen->SetCursorPosition = sunSetCursorPosition;
353: pScreen->CursorLimits = sunCursorLimits;
354: pScreen->PointerNonInterestBox = sunPointerNonInterestBox;
355: pScreen->ConstrainCursor = sunConstrainCursor;
356: pScreen->RecolorCursor = sunRecolorCursor;
357:
358: /*
359: * Block/Unblock handlers
360: */
361: if (autoRepeatHandlersInstalled == FALSE) {
362: autoRepeatScreen = pScreen;
363: autoRepeatHandlersInstalled = TRUE;
364: }
365:
366: if (pScreen == autoRepeatScreen) {
367: pScreen->BlockHandler = sunBlockHandler;
368: pScreen->WakeupHandler = sunWakeupHandler;
369: }
370:
371: }
372:
373: extern char *getenv();
374:
375: /*-
376: *-----------------------------------------------------------------------
377: * nthdev --
378: * Return the nth device in a colon-separated list of devices.
379: * n is 0-origin.
380: *
381: * Results:
382: * A pointer to a STATIC string which is the device name.
383: *
384: * Side Effects:
385: * None.
386: *
387: *-----------------------------------------------------------------------
388: */
389: static char *
390: nthdev (dList, n)
391: register char *dList; /* Colon-separated device names */
392: int n; /* Device number wanted */
393: {
394: char *result;
395: static char returnstring[100];
396:
397: while (n--) {
398: while (*dList && *dList != ':') {
399: dList++;
400: }
401: }
402: if (*dList) {
403: register char *cp = dList;
404:
405: while (*cp && *cp != ':') {
406: cp++;
407: }
408: result = returnstring;
409: strncpy (result, dList, cp - dList);
410: result[cp - dList] = '\0';
411: } else {
412: result = (char *)0;
413: }
414: return (result);
415: }
416:
417: /*-
418: *-----------------------------------------------------------------------
419: * sunOpenFrameBuffer --
420: * Open a frame buffer according to several rules. If running under
421: * overview and we're set up for it, use the device given in the
422: * PARENT envariable and note that the screen is under overview.
423: * Else find the device to use by looking in the sunFbData table,
424: * an XDEVICE envariable, a -dev switch or using /dev/fb if trying
425: * to open screen 0 and all else has failed.
426: *
427: * Results:
428: * The fd of the framebuffer.
429: *
430: * Side Effects:
431: *
432: *-----------------------------------------------------------------------
433: */
434: int
435: sunOpenFrameBuffer(expect, pfbType, index, fbNum, argc, argv)
436: int expect; /* The expected type of framebuffer */
437: struct fbtype *pfbType; /* Place to store the fb info */
438: int fbNum; /* Index into the sunFbData array */
439: int index; /* Screen index */
440: int argc; /* Command-line arguments... */
441: char **argv; /* ... */
442: {
443: char *name=(char *)0;
444: int i; /* Index into argument list */
445: int fd = -1; /* Descriptor to device */
446: static int devFbUsed=FALSE; /* true if /dev/fb has been used for a */
447: /* screen already */
448: static Bool inited = FALSE;
449: static char *xdevice; /* string of devices to use from environ */
450: static char *devsw; /* string of devices from args */
451:
452: sunFbs[index].parent = FALSE;
453:
454: if (!inited) {
455: xdevice = devsw = (char *)NULL;
456:
457: xdevice = getenv (XDEVICE);
458: /*
459: * Look for an argument of the form -dev <device-string>
460: * If such a one is found place the <device-string> in devsw.
461: */
462: for (i = 1; i < argc; i++) {
463: if ((strcmp(argv[i], "-dev") == 0) && (i + 1 < argc)) {
464: devsw = argv[i+1];
465: break;
466: }
467: }
468: inited = TRUE;
469: }
470:
471: /*
472: * Attempt to find a file name for the frame buffer
473: */
474:
475: /*
476: * First see if any device was given on the command line.
477: * If one was and the device is both readable and writeable,
478: * set 'name' to it, else set it to NULL.
479: */
480: if (devsw == (char *)NULL ||
481: (name = nthdev (devsw, index)) == (char *)NULL ||
482: (access (name, R_OK | W_OK) != 0) ||
483: (strcmp(name, sunFbData[fbNum].devName) != 0)) {
484: name = (char *)NULL;
485: }
486:
487: /*
488: * If we still don't have a device for this screen, check the
489: * environment variable for one. If one was given, stick its
490: * path in name and check its accessibility. If it's not
491: * properly accessible, then reset the name to NULL to force the
492: * checking of the sunFbData array.
493: */
494: if (devsw == (char *)NULL && name == (char *)NULL &&
495: xdevice != (char *)NULL &&
496: (name = nthdev(xdevice, index)) != (char *)NULL &&
497: (access (name, R_OK | W_OK) != 0)) {
498: name = (char *)NULL;
499: }
500:
501: /*
502: * Take the device given in the frame buffer description
503: * and see if it exists and is accessible. If it does/is,
504: * we will use it, as long as no other device was given.
505: */
506: if (devsw == (char *)NULL && name == (char *)NULL &&
507: access(sunFbData[fbNum].devName, (R_OK | W_OK)) == 0) {
508: name = sunFbData[fbNum].devName;
509: }
510:
511: /*
512: * If we still have nothing and have yet to use "/dev/fb" for
513: * a screen, default the name to be "/dev/fb"
514: */
515: if (devsw == (char *)NULL && name == (char *)NULL && !devFbUsed) {
516: name = "/dev/fb";
517: }
518:
519:
520: if (name != (char *) NULL && sunUseSunWindows()) {
521: #ifdef SUN_WINDOWS
522:
523: /*
524: * Running X in coexistence with SunWindows.
525: *
526: * This section of code enables X to run with SunWindows. This is
527: * accomplished by opening up screens and windows in the SunWindows
528: * style and accepting input events from them. However, since the X
529: * graphics libraries want a raw framebuffer, we open the
530: * framebuffer of the current screen and return that. So we get
531: * input from SunWindows but send output to the raw framebuffer.
532: */
533:
534: char *parent = getenv("WINDOW_PARENT");
535: struct screen sc;
536: int winFd;
537: int parentFd;
538: int framebufferFd;
539: Rect r;
540: static struct screen newScreen;
541: struct inputmask inputMask;
542: Bool keepParent = FALSE;
543:
544: /*
545: * If no device was specified on the command line, open the window
546: * specified in WINDOW_PARENT. If a device was specified, open a
547: * new screen on that device and use it as a parent window.
548: */
549:
550: if ( devsw ) {
551: bzero( (caddr_t)&newScreen, sizeof(newScreen) );
552: strcpy( newScreen.scr_fbname, name );
553: newScreen.scr_flags |= SCR_TOGGLEENABLE;
554: if ( (parentFd = win_screennew( &newScreen )) < 0 ) {
555: ErrorF( "sunOpenFrameBuffer: Can't open new screen on %s.\n",
556: name );
557: return( -1 );
558: }
559: keepParent = TRUE;
560: } else {
561: if ((parentFd = open(parent, 2, 0)) < 0) {
562: ErrorF("sunOpenFrameBuffer: Can't open parent %s.\n", parent);
563: return (-1);
564: }
565: }
566:
567: if ((winFd = win_getnewwindow()) < 0) {
568: ErrorF("sunOpenFrameBuffer: Can't open a new window.\n");
569: close( parentFd );
570: return (-1);
571: }
572:
573: /* link the new window into the window hierarchy */
574: bzero((caddr_t) & r, sizeof r);
575: win_getrect(parentFd, &r);
576: win_setrect(winFd, &r);
577: win_setlink(winFd, WL_PARENT, win_fdtonumber(parentFd));
578: win_setlink(winFd, WL_OLDERSIB, win_getlink(parentFd, WL_TOPCHILD));
579: sunFbs[index].parent = TRUE;
580:
581: /*
582: * We would like to close the parent window here, since it's no
583: * longer needed. However, in the case where the parent is really a
584: * screen, we have to keep it open, because closing a screen closes
585: * all the windows on that screen.
586: */
587:
588: if ( ! keepParent )
589: close(parentFd);
590:
591: /*
592: * Express interest in SunView mouse events. Note: the win_insert
593: * must be AFTER setting the input mask in order to receive the
594: * initial LOC_WINENTER event.
595: */
596:
597: input_imnull(&inputMask);
598: inputMask.im_flags = IM_ASCII | IM_META | IM_NEGEVENT | IM_INTRANSIT;
599:
600: #ifdef notdef
601: win_setinputcodebit(&inputMask, KBD_USE);
602: win_setinputcodebit(&inputMask, KBD_DONE);
603: #endif notdef
604: win_setinputcodebit(&inputMask, LOC_MOVE);
605: win_setinputcodebit(&inputMask, LOC_WINEXIT);
606: win_setinputcodebit(&inputMask, LOC_WINENTER);
607: win_setinputcodebit(&inputMask, MS_LEFT);
608: win_setinputcodebit(&inputMask, MS_MIDDLE);
609: win_setinputcodebit(&inputMask, MS_RIGHT);
610: win_set_pick_mask(winFd, &inputMask);
611:
612: win_insert(winFd);
613:
614: /*
615: * Determine the framebuffer name from the window's screen, then
616: * open it. Then do an FBIOGTYPE ioctl to determine its type.
617: */
618:
619: win_screenget( winFd, &sc );
620: if ((framebufferFd = open(sc.scr_fbname, O_RDWR, 0)) < 0) {
621: ErrorF("sunOpenFrameBuffer: can't open %s\n",sc.scr_fbname);
622: (void) close(winFd);
623: (void) close(parentFd);
624: return (-1);
625: }
626:
627: if (ioctl(framebufferFd, FBIOGTYPE, pfbType) < 0) {
628: perror("sunOpenFrameBuffer");
629: (void) close(framebufferFd);
630: (void) close(winFd);
631: (void) close(parentFd);
632: return (-1);
633: }
634:
635: if (pfbType->fb_type != expect) {
636: (void) close(framebufferFd);
637: (void) close(winFd);
638: (void) close(parentFd);
639: return (-1);
640: }
641:
642: /*
643: * NDELAY only applies to "input" fds, or fds that can be
644: * read. sunwindows fds are read, while frame buffer fds aren't.
645: * That's why this fcntl is in the conditional compilation section.
646: */
647:
648: if (fcntl(winFd, F_SETFL, O_NDELAY) < 0) {
649: ErrorF("Can't set O_NDELAY on %s\n",name);
650: perror("sunOpenFrameBuffer");
651: (void) close(winFd);
652: return (-1);
653: }
654:
655: fd = framebufferFd;
656: windowFd = winFd;
657: #else
658: ErrorF("Not configured to run inside SunWindows\n");
659: fd = -1;
660: #endif SUN_WINDOWS
661: } else if (name) {
662: fd = open(name, O_RDWR, 0);
663: if (fd < 0) {
664: return (-1);
665: }
666: if (ioctl(fd, FBIOGTYPE, pfbType) < 0) {
667: perror("sunOpenFrameBuffer");
668: (void) close(fd);
669: return (-1);
670: }
671: /* XXX - this is temporary 'cos the CG4 pretends its a BW2 */
672: if (strcmp(name, sunFbData[fbNum].devName) != 0 && pfbType->fb_type != expect) {
673: (void) close(fd);
674: return (-1);
675: }
676: }
677:
678: if (name && strcmp (name, "/dev/fb") == 0) {
679: devFbUsed = TRUE;
680: }
681:
682: return (fd);
683: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.