![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sunCG2M.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 sunCG2M.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / sun |
1.1 root 1: /*-
2: * sunCG2M.c --
3: * Functions to support the sun CG2 board when treated as a monochrome
4: * frame buffer.
5: *
6: * Copyright (c) 1987 by the Regents of the University of California
7: * Copyright (c) 1987 by Adam de Boor, UC Berkeley
8: *
9: * Permission to use, copy, modify, and distribute this
10: * software and its documentation for any purpose and without
11: * fee is hereby granted, provided that the above copyright
12: * notice appear in all copies. The University of California
13: * makes no representations about the suitability of this
14: * software for any purpose. It is provided "as is" without
15: * express or implied warranty.
16: *
17: *
18: */
19: #ifndef lint
20: static char rcsid[] =
21: "$Header: sunCG2M.c,v 4.4 87/09/11 17:04:55 sun Exp $ SPRITE (Berkeley)";
22: #endif lint
23:
24: #include "sun.h"
25: #include "resource.h"
26:
27: #include <sys/mman.h>
28: #include <pixrect/memreg.h>
29: #include <pixrect/cg2reg.h>
30: #include <struct.h>
31:
32: extern caddr_t mmap();
33: #ifndef _MAP_NEW
34: extern caddr_t valloc();
35: #endif _MAP_NEW
36:
37: /*-
38: * The cg2 frame buffer is divided into several pieces.
39: * 1) a stack of 8 monochrome bitplanes
40: * 2) an array of 8-bit pixels
41: * 3) a union of these two where modifications are done via RasterOp
42: * chips
43: * 4) various control registers
44: * 5) a shadow colormap.
45: *
46: * Each of these things is at a given offset from the base of the 4Mb devoted
47: * to each color board. In addition, the mmap() system call insists on the
48: * address and the length to be mapped being aligned on 8K boundaries.
49: */
50: struct cg2m_reg {
51: char pad[4096]; /* The status register is at 0x309000 */
52: /* which isn't on an 8K boundary, so we */
53: /* have to pad this thing here to make */
54: /* the mmaping work... */
55: union {
56: struct cg2statusreg csr; /* Control/status register */
57: char pad[4096]; /* This is the amount of room */
58: /* dedicated to the status register */
59: } u_csr;
60: };
61:
62: struct cg2m_ppmask {
63: union {
64: unsigned short ppmask; /* Per-plane mask */
65: char pad[8192]; /* Padding to keep the length of */
66: /* these registers page-aligned... */
67:
68: } u_ppmask;
69: };
70:
71: struct cg2m_cmap {
72: union {
73: struct { /* Shouldn't these be u_char's??? */
74: u_short redmap[256]; /* Red-component map */
75: u_short greenmap[256]; /* Green-component map */
76: u_short bluemap[256]; /* Blue-component map */
77: } cmap;
78: char pad[8192];
79: } u_cmap;
80: };
81:
82: typedef struct cg2m {
83: union bitplane *image; /* The first bitplane -- treated as a */
84: /* monochrome frame buffer. */
85: struct cg2m_reg *u_csr; /* the status register */
86: struct cg2m_ppmask *u_ppmask; /* the plane mask register */
87: struct cg2m_cmap *u_cmap; /* the colormap */
88: } CG2M, CG2MRec, *CG2MPtr;
89:
90: #define CG2M_IMAGE(fb) ((caddr_t)((fb).image))
91: #define CG2M_IMAGEOFF ((off_t)0x00000000)
92: #define CG2M_IMAGELEN (sizeof(union bitplane))
93: #define CG2M_REG(fb) ((caddr_t)((fb).u_csr))
94: #define CG2M_REGOFF ((off_t)0x00308000)
95: #define CG2M_REGLEN (2*8192)
96: #define CG2M_MASK(fb) ((caddr_t)((fb).u_ppmask))
97: #define CG2M_MASKOFF ((off_t)0x0030A000)
98: #define CG2M_MASKLEN (0x2000)
99: #define CG2M_CMAP(fb) ((caddr_t)((fb).u_cmap))
100: #define CG2M_CMAPOFF ((off_t)0x00310000)
101: #define CG2M_CMAPLEN 8192
102:
103: /*-
104: *-----------------------------------------------------------------------
105: * sunCG2MSaveScreen --
106: * Preserve the color screen by turning on or off the video
107: *
108: * Results:
109: * None.
110: *
111: * Side Effects:
112: * Video state is switched
113: *
114: *-----------------------------------------------------------------------
115: */
116: static Bool
117: sunCG2MSaveScreen (pScreen, on)
118: ScreenPtr pScreen;
119: Bool on;
120: {
121: int state = on;
122:
123: switch (on) {
124: case SCREEN_SAVER_FORCER:
125: SetTimeSinceLastInputEvent();
126: screenSaved = FALSE;
127: state = 1;
128: break;
129: case SCREEN_SAVER_OFF:
130: screenSaved = FALSE;
131: state = 1;
132: break;
133: case SCREEN_SAVER_ON:
134: default:
135: screenSaved = TRUE;
136: state = 0;
137: break;
138: }
139: ((CG2MPtr)sunFbs[pScreen->myNum].fb)->u_csr->u_csr.csr.video_enab = state;
140: return( TRUE );
141: }
142:
143: /*-
144: *-----------------------------------------------------------------------
145: * sunCG2MCloseScreen --
146: * called to ensure video is enabled when server exits.
147: *
148: * Results:
149: * Screen is unsaved.
150: *
151: * Side Effects:
152: * None
153: *
154: *-----------------------------------------------------------------------
155: */
156: /*ARGSUSED*/
157: static Bool
158: sunCG2MCloseScreen(i, pScreen)
159: int i;
160: ScreenPtr pScreen;
161: {
162: return (pScreen->SaveScreen(pScreen, SCREEN_SAVER_OFF));
163: }
164:
165: /*-
166: *-----------------------------------------------------------------------
167: * sunCG2MResolveColor --
168: * Resolve an RGB value into some sort of thing we can handle.
169: * Just looks to see if the intensity of the color is greater than
170: * 1/2 and sets it to 'white' (all ones) if so and 'black' (all zeroes)
171: * if not.
172: *
173: * Results:
174: * *pred, *pgreen and *pblue are overwritten with the resolved color.
175: *
176: * Side Effects:
177: * see above.
178: *
179: *-----------------------------------------------------------------------
180: */
181: /*ARGSUSED*/
182: static void
183: sunCG2MResolveColor(pred, pgreen, pblue, pVisual)
184: unsigned short *pred;
185: unsigned short *pgreen;
186: unsigned short *pblue;
187: VisualPtr pVisual;
188: {
189: *pred = *pgreen = *pblue =
190: (((39L * *pred +
191: 50L * *pgreen +
192: 11L * *pblue) >> 8) >= (((1<<8)-1)*50)) ? ~0 : 0;
193: }
194:
195: /*-
196: *-----------------------------------------------------------------------
197: * sunCG2CreateColormap --
198: * create a bw colormap
199: *
200: * Results:
201: * None
202: *
203: * Side Effects:
204: * allocate two pixels
205: *
206: *-----------------------------------------------------------------------
207: */
208: void
209: sunCG2CreateColormap(pmap)
210: ColormapPtr pmap;
211: {
212: int red, green, blue, pix;
213:
214: /* this is a monochrome colormap, it only has two entries, just fill
215: * them in by hand. If it were a more complex static map, it would be
216: * worth writing a for loop or three to initialize it */
217:
218: /* this will be pixel 0 */
219: red = green = blue = ~0;
220: AllocColor(pmap, &red, &green, &blue, &pix, 0);
221:
222: /* this will be pixel 1 */
223: red = green = blue = 0;
224: AllocColor(pmap, &red, &green, &blue, &pix, 0);
225:
226: }
227:
228: /*-
229: *-----------------------------------------------------------------------
230: * sunCG2DestroyColormap --
231: * destroy a bw colormap
232: *
233: * Results:
234: * None
235: *
236: * Side Effects:
237: * None
238: *
239: *-----------------------------------------------------------------------
240: */
241: /*ARGSUSED*/
242: void
243: sunCG2DestroyColormap(pmap)
244: ColormapPtr pmap;
245: {
246: }
247:
248:
249: /*-
250: *-----------------------------------------------------------------------
251: * sunCG2MInit --
252: * Attempt to find and initialize a cg2 framebuffer used as mono
253: *
254: * Results:
255: * TRUE if everything went ok. FALSE if not.
256: *
257: * Side Effects:
258: * Most of the elements of the ScreenRec are filled in. The
259: * video is enabled for the frame buffer...
260: *
261: *-----------------------------------------------------------------------
262: */
263: /*ARGSUSED*/
264: static Bool
265: sunCG2MInit (index, pScreen, argc, argv)
266: int index; /* The index of pScreen in the ScreenInfo */
267: ScreenPtr pScreen; /* The Screen to initialize */
268: int argc; /* The number of the Server's arguments. */
269: char **argv; /* The arguments themselves. Don't change! */
270: {
271: ColormapPtr pCmap;
272:
273: if (!mfbScreenInit (index, pScreen,
274: ((CG2MPtr)sunFbs[index].fb)->image,
275: sunFbs[index].info.fb_width,
276: sunFbs[index].info.fb_height, 90, 90))
277: return (FALSE);
278:
279: pScreen->SaveScreen = sunCG2MSaveScreen;
280: pScreen->RealizeCursor = sunRealizeCursor;
281: pScreen->UnrealizeCursor = sunUnrealizeCursor;
282: pScreen->DisplayCursor = sunDisplayCursor;
283: pScreen->SetCursorPosition = sunSetCursorPosition;
284: pScreen->CursorLimits = sunCursorLimits;
285: pScreen->PointerNonInterestBox = sunPointerNonInterestBox;
286: pScreen->ConstrainCursor = sunConstrainCursor;
287: pScreen->RecolorCursor = sunRecolorCursor;
288: pScreen->ResolveColor = sunCG2MResolveColor;
289: pScreen->CreateColormap = sunCG2CreateColormap;
290: pScreen->DestroyColormap = sunCG2DestroyColormap;
291: pScreen->RegionCreate = miRegionCreate;
292: pScreen->RegionCopy = miRegionCopy;
293: pScreen->RegionDestroy = miRegionDestroy;
294: pScreen->Intersect = miIntersect;
295: pScreen->Inverse = miInverse;
296: pScreen->Union = miUnion;
297: pScreen->Subtract = miSubtract;
298: pScreen->RegionReset = miRegionReset;
299: pScreen->TranslateRegion = miTranslateRegion;
300: pScreen->RectIn = miRectIn;
301: pScreen->PointInRegion = miPointInRegion;
302:
303: pScreen->whitePixel = 0;
304: pScreen->blackPixel = 1;
305:
306: if (CreateColormap(pScreen->defColormap, pScreen,
307: LookupID(pScreen->rootVisual, RT_VISUALID, RC_CORE),
308: &pCmap, AllocNone, 0) != Success
309: || pCmap == NULL)
310: FatalError("Can't create colormap in sunCG2MInit()\n");
311: mfbInstallColormap(pCmap);
312:
313: /*
314: * Enable video output...
315: */
316: sunCG2MSaveScreen(pScreen, SCREEN_SAVER_FORCER);
317:
318: sunScreenInit (pScreen);
319: return (TRUE);
320: }
321:
322: /*-
323: *-----------------------------------------------------------------------
324: * sunCG2MProbe --
325: * Attempt to find and initialize a cg2 framebuffer used as mono
326: *
327: * Results:
328: * TRUE if everything went ok. FALSE if not.
329: *
330: * Side Effects:
331: * Memory is allocated for the frame buffer and the buffer is mapped.
332: *
333: *-----------------------------------------------------------------------
334: */
335: Bool
336: sunCG2MProbe (pScreenInfo, index, fbNum, argc, argv)
337: ScreenInfo *pScreenInfo; /* The screenInfo struct */
338: int index; /* The index of pScreen in the ScreenInfo */
339: int fbNum; /* Index into the sunFbData array */
340: int argc; /* The number of the Server's arguments. */
341: char **argv; /* The arguments themselves. Don't change! */
342: {
343: int i;
344: int oldNumScreens;
345:
346: if (sunFbData[fbNum].probeStatus == probedAndFailed) {
347: return FALSE;
348: }
349:
350: if (sunFbData[fbNum].probeStatus == neverProbed) {
351: int fd;
352: struct fbtype fbType;
353: static CG2MRec CG2Mfb;
354:
355: if ((fd = sunOpenFrameBuffer(FBTYPE_SUN2COLOR, &fbType, index, fbNum,
356: argc, argv)) < 0) {
357: sunFbData[fbNum].probeStatus = probedAndFailed;
358: return FALSE;
359: }
360:
361: #ifdef _MAP_NEW
362: if ((int)(CG2Mfb.image = (union bitplane *) mmap ((caddr_t) 0,
363: CG2M_IMAGELEN, PROT_READ | PROT_WRITE,
364: MAP_SHARED | _MAP_NEW, fd, CG2M_IMAGEOFF)) == -1) {
365: Error ("Mapping cg2m.image");
366: goto bad;
367: }
368: if ((int)(CG2Mfb.u_csr = (struct cg2m_reg *) mmap ((caddr_t) 0,
369: CG2M_REGLEN, PROT_READ | PROT_WRITE,
370: MAP_SHARED | _MAP_NEW, fd, CG2M_REGOFF)) == -1) {
371: Error ("Mapping cg2m.reg");
372: goto bad;
373: }
374: if ((int)(CG2Mfb.u_ppmask = (struct cg2m_ppmask *) mmap ((caddr_t) 0,
375: CG2M_MASKLEN, PROT_READ | PROT_WRITE,
376: MAP_SHARED | _MAP_NEW, fd, CG2M_MASKOFF)) == -1) {
377: Error ("Mapping cg2m.reg");
378: goto bad;
379: }
380: if ((int)(CG2Mfb.u_cmap = (struct cg2m_cmap *) mmap ((caddr_t) 0,
381: CG2M_CMAPLEN, PROT_READ | PROT_WRITE,
382: MAP_SHARED | _MAP_NEW, fd, CG2M_CMAPOFF)) != -1) {
383: goto ok;
384: }
385: Error ("Mapping cg2m.cmap");
386: #else
387: CG2Mfb.image = (union bitplane *)valloc (CG2M_IMAGELEN + CG2M_REGLEN +
388: CG2M_MASKLEN + CG2M_CMAPLEN);
389: CG2Mfb.u_csr = (struct cg2m_reg *) ((char *)CG2Mfb.image +
390: CG2M_IMAGELEN);
391: CG2Mfb.u_ppmask = (struct cg2m_ppmask *) ((char *)CG2Mfb.u_csr +
392: CG2M_REGLEN);
393: CG2Mfb.u_cmap = (struct cg2m_cmap *) ((char *)CG2Mfb.u_ppmask +
394: CG2M_MASKLEN);
395: if (CG2Mfb.image == (union bitplane *) NULL) {
396: ErrorF ("Could not allocate room for frame buffer.\n");
397: sunFbData[fbNum].probeStatus = probedAndFailed;
398: return FALSE;
399: }
400:
401: if (mmap (CG2M_IMAGE(CG2Mfb), CG2M_IMAGELEN, PROT_READ | PROT_WRITE,
402: MAP_SHARED, fd, CG2M_IMAGEOFF) < 0) {
403: Error ("Mapping cg2m.image");
404: goto bad;
405: }
406: if (mmap (CG2M_REG(CG2Mfb), CG2M_REGLEN, PROT_READ | PROT_WRITE,
407: MAP_SHARED, fd, CG2M_REGOFF) < 0) {
408: Error ("Mapping cg2m.reg");
409: goto bad;
410: }
411: if (mmap (CG2M_MASK(CG2Mfb), CG2M_MASKLEN, PROT_READ | PROT_WRITE,
412: MAP_SHARED, fd, CG2M_MASKOFF) < 0) {
413: Error ("Mapping cg2m.mask");
414: goto bad;
415: }
416: if (mmap (CG2M_CMAP(CG2Mfb), CG2M_CMAPLEN, PROT_READ | PROT_WRITE,
417: MAP_SHARED, fd, CG2M_CMAPOFF) >= 0) {
418: goto ok;
419: }
420: Error ("Mapping cg2m.cmap");
421: #endif _MAP_NEW
422: bad:
423: sunFbData[fbNum].probeStatus = probedAndFailed;
424: (void) close (fd);
425: return FALSE;
426:
427: ok:
428: /*
429: * Enable only the first plane and make all even pixels be white,
430: * while all odd pixels are black.
431: */
432: CG2Mfb.u_ppmask->u_ppmask.ppmask = 1;
433: CG2Mfb.u_csr->u_csr.csr.update_cmap = 0;
434: for ( i=0; i<256; i+=2 ) {
435: CG2Mfb.u_cmap->u_cmap.cmap.redmap[i] =
436: CG2Mfb.u_cmap->u_cmap.cmap.greenmap[i] =
437: CG2Mfb.u_cmap->u_cmap.cmap.bluemap[i] = 255;
438: CG2Mfb.u_cmap->u_cmap.cmap.redmap[i+1] =
439: CG2Mfb.u_cmap->u_cmap.cmap.greenmap[i+1] =
440: CG2Mfb.u_cmap->u_cmap.cmap.bluemap[i+1] = 0;
441: }
442: CG2Mfb.u_csr->u_csr.csr.update_cmap = 1;
443:
444: sunFbs[index].fd = fd;
445: sunFbs[index].info = fbType;
446: sunFbs[index].fb = (pointer) &CG2Mfb;
447: sunFbs[index].EnterLeave = NoopDDA;
448: sunFbData[fbNum].probeStatus = probedAndSucceeded;
449: }
450:
451: oldNumScreens = pScreenInfo->numScreens;
452: i = AddScreen(sunCG2MInit, argc, argv);
453: pScreenInfo->screen[index].CloseScreen = sunCG2MCloseScreen;
454: return (i > oldNumScreens);
455: }
456:
457:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.