![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOFramebuffer.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / libDriver / ppc|
Return to IOFramebuffer.m CVS log | Up to [Apple Darwin 0.x] / driverkit / libDriver / ppc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /* Copyright (c) 1992-96 NeXT Software, Inc. All rights reserved.
25: *
26: * IOFramebuffer.m - Implements common methods for "standard" frame
27: * buffers.
28: *
29: *
30: * HISTORY
31: * 26 Oct 95 Dean Reece
32: * Moved strtol() out of this class into its own file (strtol.c)
33: * 24 Oct 95 Rakesh Dubey
34: * Added mode change feature.
35: * 01 Sep 92 Joe Pasqua
36: * Created.
37: */
38:
39: #define KERNEL_PRIVATE 1
40: #define DRIVER_PRIVATE 1
41:
42: /* Notes:
43: * The definition of a standard frame buffer is anything with direct
44: * 32 bit access to a 2 & 8 bit gray, 8 & 16 & 32 bit color. For 16 bit
45: * displays we support both 4/4/4 and 5/5/5 samples per channel.
46: *
47: * This class implements the evScreen protocol for all StdFBDisplays. Well,
48: * almost. The setBrightness method doesn't do anything. Subclasses must
49: * override this and implement it as appropriate for the device.
50: *
51: * To find things that need to be fixed, search for FIX, to find questions
52: * to be resolved, search for ASK, to find stuff that still needs to be
53: * done, search for TO DO.
54: */
55:
56: #import <string.h>
57: #import <stdlib.h>
58: #ifdef i386
59: #import <bsd/dev/i386/FBConsole.h>
60: #endif
61:
62: #ifdef ppc
63: #import <bsd/dev/ppc/FBConsole.h>
64: #import <driverkit/ppc/IOSmartDisplay.h>
65: #import <driverkit/ppc/IOFramebuffer.h>
66: #import <driverkit/ppc/IOTreeDevice.h> // for IOApertureInfo
67: #endif
68:
69: #import <driverkit/EventDriver.h>
70: #import <bsd/dev/evio.h>
71:
72: #ifdef i386
73: #import <bsd/dev/i386/kmDevice.h>
74: #endif
75: #ifdef ppc
76: #import <bsd/dev/ppc/kmDevice.h>
77: #endif
78:
79: #import <driverkit/KernBus.h>
80: #import <driverkit/KernBusMemory.h>
81: #import <driverkit/IODisplayPrivate.h>
82: #import <driverkit/IOFrameBufferShared.h>
83: #import <driverkit/IODirectDevicePrivate.h>
84: #import <driverkit/displayDefs.h>
85: #ifdef i386
86: #import <driverkit/i386/directDevice.h>
87: #import <driverkit/i386/driverTypes.h>
88: #endif
89: #ifdef ppc
90: #import <driverkit/ppc/directDevice.h>
91: #import <driverkit/ppc/driverTypes.h>
92: #endif
93:
94: #define CLEARSEMA(shmem) ev_unlock(&shmem->cursorSema)
95: #define SETSEMA(shmem) \
96: if (!ev_try_lock(&shmem->cursorSema)) return self;
97: #define TOUCHBOUNDS(one, two) \
98: (((one.minx < two.maxx) && (two.minx < one.maxx)) && \
99: ((one.miny < two.maxy) && (two.miny < one.maxy)))
100:
101: #define RBMASK 0xF0F0 /* Short, or 16 bit format */
102: #define GAMASK 0x0F0F /* Short, or 16 bit format */
103: #define AMASK 0x000F /* Short, or 16 bit format */
104:
105: #define GetShmem(instance) ((StdFBShmem_t *)(instance->priv))
106:
107: extern long int strtol(const char *nptr, char **endptr, int base);
108:
109: #ifndef IO_DISPLAY_MODE_SAFE
110: #define IO_DISPLAY_MODE_SAFE 0x00000001
111: #endif
112: #ifndef IO_DISPLAY_MODE_DEFAULT
113: #define IO_DISPLAY_MODE_DEFAULT 0x00000002
114: #endif
115:
116: static BOOL wsStartup;
117: static Class gSmartDisplayClass;
118:
119: @implementation IOFramebuffer
120:
121:
122: //
123: // BEGIN: Generic utility routines and methods
124: //
125: - (IOReturn)_registerWithED
126: // Description: Register this display device with the event driver.
127: {
128: int token;
129: int shmem_size;
130: Bounds bounds;
131: StdFBShmem_t *shmem;
132:
133: token = [[EventDriver instance] registerScreen:self
134: bounds:&bounds
135: shmem:&(self->priv)
136: size:&shmem_size];
137: shmem = GetShmem(self);
138: if ( token == -1 )
139: return IO_R_INVALID_ARG;
140: // We allow the shmem_size to be less than sizeof(StdFBShmem_t)
141: // so that we need not consume the extra space that some of the
142: // larger cursor variants require if we are really a lower bitdepth.
143: if ( shmem_size > sizeof(StdFBShmem_t) )
144: {
145: IOLog("%s: shmem_size > sizeof (StdFBShmem_t)(%d<>%d)\n",
146: [self name], shmem_size, sizeof (StdFBShmem_t));
147: [[EventDriver instance] unregisterScreen:token];
148: return IO_R_INVALID_ARG;
149: }
150: // Init shared memory area
151: memset((char *)shmem, 0, shmem_size);
152: shmem->cursorShow = 1;
153: shmem->screenBounds = bounds;
154: [self setToken:token];
155: cursorShmemBitsPerPixel = [self displayInfo]->bitsPerPixel;
156: cursorBitsPerPixel = cursorShmemBitsPerPixel;
157: return IO_R_SUCCESS;
158: }
159:
160: #define short34to35WithGamma(x) \
161: ( (_bm34To35SampleTable[((x) & 0x00F0) >> 4]) \
162: | (_bm34To35SampleTable[((x) & 0x0F00) >> 8] << 5) \
163: | (_bm34To35SampleTable[(x) >> 12] << 10) )
164:
165: #define short35to34WithGamma(x) \
166: ( 0x000F \
167: | (_bm35To34SampleTable[x & 0x001F] << 4) \
168: | (_bm35To34SampleTable[(x & 0x03E0) >> 5] << 8) \
169: | (_bm35To34SampleTable[(x & 0x7C00) >> 10] << 12) )
170:
171: static void StdFBDisplayCursor16(IOFramebuffer *inst)
172: // Description: Displays the cursor on the framebuffer by first saving
173: // what's underneath the cursor, then drawing the cursor there.
174: // NOTE:The topleft of the cursorRect passed in is not
175: // necessarily the cursor location.The cursorRect is adjusted to
176: // compensate for the cursor hotspot.If the frame buffer is
177: // cacheable, flush at the end of the drawing operation. A
178: // saveRect is stored which defines the actual area of the screen
179: // that is saved.This is used by RemoveCursor in restoring the
180: // screen data later.
181: {
182: IODisplayInfo *dpy;
183: StdFBShmem_t *shmem;
184: vm_offset_t startPtr; /* Starting screen data pointer */
185: unsigned int vramRow;
186: Bounds saveRect;
187: short i, j, width, cursRow;
188: unsigned short *vramPtr; /* screen data pointer */
189: volatile unsigned short *savePtr; /* saved screen data pointer */
190: unsigned short s, d, f;
191: volatile unsigned short *cursPtr;
192: unsigned char *_bm34To35SampleTable;
193: unsigned char *_bm35To34SampleTable;
194:
195: dpy = [inst displayInfo];
196: shmem = GetShmem(inst);
197: saveRect = shmem->cursorRect;
198: /* Clip saveRect vertical within screen bounds */
199: if (saveRect.miny < shmem->screenBounds.miny)
200: saveRect.miny = shmem->screenBounds.miny;
201: if (saveRect.maxy > shmem->screenBounds.maxy)
202: saveRect.maxy = shmem->screenBounds.maxy;
203: if (saveRect.minx < shmem->screenBounds.minx)
204: saveRect.minx = shmem->screenBounds.minx;
205: if (saveRect.maxx > shmem->screenBounds.maxx)
206: saveRect.maxx = shmem->screenBounds.maxx;
207: shmem->saveRect = saveRect; /* Remember save rect for RemoveCursor */
208:
209: vramRow = dpy->totalWidth; /* Scanline width in pixels */
210: vramPtr = (unsigned short *)dpy->frameBuffer +
211: (vramRow * (saveRect.miny - shmem->screenBounds.miny)) +
212: (saveRect.minx - shmem->screenBounds.minx);
213: startPtr = (vm_offset_t) vramPtr;
214: width = saveRect.maxx - saveRect.minx;
215: vramRow -= width;
216:
217: cursRow = CURSORWIDTH - width;
218: savePtr = shmem->cursor.rgb.save;
219: cursPtr = shmem->cursor.rgb.image[shmem->frame];
220: cursPtr += (saveRect.miny - shmem->cursorRect.miny) * CURSORWIDTH +
221: (saveRect.minx - shmem->cursorRect.minx);
222:
223: if (dpy->bitsPerPixel == IO_12BitsPerPixel)
224: {
225: for (i = saveRect.maxy - saveRect.miny; --i != -1; ) {
226: for (j = width; --j != -1; ) {
227: d = *savePtr++ = *vramPtr;
228: if ( (s = *cursPtr++) == 0 )
229: { /* Transparent black area. Leave dst as is. */
230: ++vramPtr;
231: continue;
232: }
233: if ( (f = (~s) & (unsigned int)AMASK) == 0 )
234: { /* Opaque cursor pixel. Mark it. */
235: *vramPtr++ = s;
236: continue;
237: }
238: /* Alpha is not 0 or 1.0. Sover the cursor. */
239: *vramPtr++ = s + (((((d & RBMASK)>>4)*f + GAMASK) & RBMASK)
240: | ((((d & GAMASK)*f+GAMASK)>>4) & GAMASK));
241: }
242: cursPtr += cursRow; /* starting point of next cursor line */
243: vramPtr += vramRow; /* starting point of next screen line */
244: }
245: }
246: else // dpy->bitsPerPixel == IO_15BitsPerPixel
247: {
248: // These tables should always be set by the Window Server before
249: // it enables cursor drawing. If they're not set, it's an error.
250: if ( (_bm34To35SampleTable = inst->_bm34To35SampleTable) == NULL
251: || (_bm35To34SampleTable = inst->_bm35To34SampleTable) == NULL )
252: return;
253: for (i = saveRect.maxy - saveRect.miny; --i>=0; ) {
254: for (j = width; --j>=0; ) {
255: d = *savePtr++ = *vramPtr;
256: if ( (s = *cursPtr++) == 0 )
257: { /* Transparent black area. Leave dst as is. */
258: ++vramPtr;
259: continue;
260: }
261: if ( (f = (~s) & (unsigned int)AMASK) == 0 )
262: { /* Opaque cursor pixel. Mark it. */
263: *vramPtr++ = short34to35WithGamma(s);
264: continue;
265: }
266: /* Alpha is not 0 or 1.0. Sover the cursor. */
267: d = short35to34WithGamma(d);
268: d = s + (((((d & RBMASK)>>4)*f + GAMASK) & RBMASK)
269: | ((((d & GAMASK)*f+GAMASK)>>4) & GAMASK));
270: *vramPtr++ = short34to35WithGamma(d);
271: }
272: cursPtr += cursRow; /* starting point of next cursor line */
273: vramPtr += vramRow; /* starting point of next screen line */
274: }
275: }
276: }
277:
278: static inline unsigned int MUL32(unsigned int a, unsigned int b)
279: {
280: unsigned int v, w;
281:
282: v = ((a & 0xff00ff00) >> 8) * b;
283: v += ((v & 0xff00ff00) >> 8) + 0x00010001;
284: w = (a & 0x00ff00ff) * b;
285: w += ((w & 0xff00ff00) >> 8) + 0x00010001;
286:
287: return (v & 0xff00ff00) | ((w >> 8) & 0x00ff00ff);
288: }
289:
290: static inline unsigned char map32to256( unsigned char *directToLogical, unsigned int s)
291: {
292: unsigned char logicalValue;
293:
294: if ((s ^ (s>>8)) & 0x00ffff00) {
295: logicalValue = directToLogical[(s>>24) + 0] +
296: directToLogical[((s>>16)&0xff) + 256] +
297: directToLogical[((s>>8)&0xff) + 512];
298: } else {
299: logicalValue = directToLogical[(s>>24) + 768];
300: }
301: return( directToLogical[ logicalValue + 1024 ]); // final conversion from NeXT palette
302: // to actual palette
303: }
304:
305: static void StdFBDisplayCursor8(IOFramebuffer *inst)
306: // Description: Displays the cursor on the framebuffer by first saving
307: // what's underneath the cursor, then drawing the cursor there.
308: // NOTE:The topleft of the cursorRect passed in is not
309: // necessarily the cursor location.The cursorRect is adjusted to
310: // compensate for the cursor hotspot.If the frame buffer is
311: // cacheable, flush at the end of the drawing operation. A
312: // saveRect is stored which defines the actual area of the screen
313: // that is saved.This is used by RemoveCursor in restoring the
314: // screen data later.
315: {
316: IODisplayInfo *dpy;
317: StdFBShmem_t *shmem;
318: vm_offset_t startPtr; /* Starting screen data pointer */
319: unsigned int vramRow;
320: Bounds saveRect;
321: short i, j, width, cursRow;
322: unsigned char *vramPtr; /* screen data pointer */
323: volatile unsigned char *savePtr; /* saved screen data pointer */
324: unsigned short s, d;
325: unsigned char dst, alpha;
326: unsigned int rgb32val;
327: volatile unsigned char *cursPtr;
328: volatile unsigned char *maskPtr; /* cursor mask pointer */
329: unsigned int *_bm256To38SampleTable = inst->_bm256To38SampleTable;
330: unsigned char *_bm38To256SampleTable = inst->_bm38To256SampleTable;
331:
332: dpy = [inst displayInfo];
333: shmem = GetShmem(inst);
334: saveRect = shmem->cursorRect;
335: /* Clip saveRect vertical within screen bounds */
336: if (saveRect.miny < shmem->screenBounds.miny)
337: saveRect.miny = shmem->screenBounds.miny;
338: if (saveRect.maxy > shmem->screenBounds.maxy)
339: saveRect.maxy = shmem->screenBounds.maxy;
340: if (saveRect.minx < shmem->screenBounds.minx)
341: saveRect.minx = shmem->screenBounds.minx;
342: if (saveRect.maxx > shmem->screenBounds.maxx)
343: saveRect.maxx = shmem->screenBounds.maxx;
344: shmem->saveRect = saveRect; /* Remember save rect for RemoveCursor */
345:
346: vramRow = dpy->totalWidth; /* Scanline width in pixels */
347: vramPtr = (unsigned char *)dpy->frameBuffer +
348: (vramRow * (saveRect.miny - shmem->screenBounds.miny)) +
349: (saveRect.minx - shmem->screenBounds.minx);
350: startPtr = (vm_offset_t) vramPtr;
351: width = saveRect.maxx - saveRect.minx;
352: vramRow -= width;
353:
354: cursRow = CURSORWIDTH - width;
355: savePtr = shmem->cursor.bw8.save;
356: cursPtr = shmem->cursor.bw8.image[shmem->frame];
357: maskPtr = shmem->cursor.bw8.mask[shmem->frame];
358: i = (saveRect.miny - shmem->cursorRect.miny) * CURSORWIDTH +
359: (saveRect.minx - shmem->cursorRect.minx);
360: cursPtr += i;
361: maskPtr += i;
362:
363: if (dpy->colorSpace == IO_OneIsWhiteColorSpace) {
364: for (i = saveRect.maxy - saveRect.miny; --i>=0; ) {
365: for (j = width; --j>=0; ) {
366: int t;
367: d = *savePtr++ = *vramPtr;
368: s = *cursPtr++;
369: t = d * (255 - *maskPtr++);
370: d = s + ((t + (t >> 8) + 1) >> 8);
371: *vramPtr++ = d;
372: }
373: cursPtr += cursRow; /* starting point of next cursor line */
374: maskPtr += cursRow;
375: vramPtr += vramRow; /* starting point of next screen line */
376: }
377: } else { // dpy->colorSpace == IO_RGBColorSpace
378: for (i = saveRect.maxy - saveRect.miny; --i>=0; ) {
379: for (j = width; --j>=0; savePtr++,maskPtr++,cursPtr++,vramPtr++) {
380: *savePtr = *vramPtr;
381: if (alpha = *maskPtr) {
382: dst = *cursPtr;
383: if (alpha = ~alpha) {
384: rgb32val = _bm256To38SampleTable[*vramPtr];
385: rgb32val = (_bm256To38SampleTable[dst] & ~0xff) +
386: MUL32(rgb32val, alpha);
387: dst = map32to256(_bm38To256SampleTable, rgb32val);
388: }
389: *vramPtr = dst;
390: }
391: }
392: cursPtr += cursRow; /* starting point of next cursor line */
393: maskPtr += cursRow;
394: vramPtr += vramRow; /* starting point of next screen line */
395: }
396: }
397: }
398:
399: static void StdFBRemoveCursor16(IOFramebuffer *inst)
400: // Description: RemoveCursor erases the cursor by replacing the background
401: // image that was saved by the previous call to DisplayCursor.
402: // If the frame buffer is cacheable, flush at the end of the
403: // drawing operation.
404: {
405: IODisplayInfo *dpy;
406: StdFBShmem_t *shmem;
407: short i, j, width;
408: vm_offset_t startPtr;
409: unsigned int vramRow;
410: Bounds saveRect;
411: unsigned short *vramPtr;
412: volatile unsigned short *savePtr;
413:
414: dpy = [inst displayInfo];
415: shmem = GetShmem(inst);
416: saveRect = shmem->saveRect;
417: vramRow = dpy->totalWidth; /* Scanline width in pixels */
418: vramPtr = (unsigned short *)dpy->frameBuffer +
419: (vramRow * (saveRect.miny - shmem->screenBounds.miny))
420: + (saveRect.minx - shmem->screenBounds.minx);
421: width = saveRect.maxx - saveRect.minx;
422: vramRow -= width;
423: savePtr = shmem->cursor.rgb.save;
424: startPtr = (vm_offset_t) vramPtr;
425: for (i = saveRect.maxy - saveRect.miny; --i != -1; ) {
426: for (j = width; --j != -1; )
427: *vramPtr++ = *savePtr++;
428: vramPtr += vramRow;
429: }
430: }
431:
432: static void StdFBRemoveCursor8(IOFramebuffer *inst)
433: // Description: RemoveCursor erases the cursor by replacing the background
434: // image that was saved by the previous call to DisplayCursor.
435: // If the frame buffer is cacheable, flush at the end of the
436: // drawing operation.
437: {
438: IODisplayInfo *dpy;
439: StdFBShmem_t *shmem;
440: short i, j, width;
441: vm_offset_t startPtr;
442: unsigned int vramRow;
443: Bounds saveRect;
444: unsigned char *vramPtr;
445: volatile unsigned char *savePtr;
446:
447: dpy = [inst displayInfo];
448: shmem = GetShmem(inst);
449: saveRect = shmem->saveRect;
450: vramRow = dpy->totalWidth; /* Scanline width in pixels */
451: vramPtr = (unsigned char *)dpy->frameBuffer +
452: (vramRow * (saveRect.miny - shmem->screenBounds.miny))
453: + (saveRect.minx - shmem->screenBounds.minx);
454: width = saveRect.maxx - saveRect.minx;
455: vramRow -= width;
456: savePtr = shmem->cursor.bw8.save;
457: startPtr = (vm_offset_t) vramPtr;
458: for (i = saveRect.maxy - saveRect.miny; --i != -1; ) {
459: for (j = width; --j != -1; )
460: *vramPtr++ = *savePtr++;
461: vramPtr += vramRow;
462: }
463: }
464:
465: static void StdFBDisplayCursor32(IOFramebuffer *inst)
466: {
467: IODisplayInfo *dpy;
468: StdFBShmem_t *shmem;
469: unsigned int vramRow;
470: Bounds saveRect;
471: int i, j, width, cursRow;
472: unsigned int *vramPtr; /* screen data pointer */
473: volatile unsigned int *savePtr; /* saved screen data pointer */
474: unsigned int s, d, f;
475: volatile unsigned int *cursPtr;
476:
477: dpy = [inst displayInfo];
478: shmem = GetShmem(inst);
479: saveRect = shmem->cursorRect;
480: /* Clip saveRect vertical within screen bounds */
481: if (saveRect.miny < shmem->screenBounds.miny)
482: saveRect.miny = shmem->screenBounds.miny;
483: if (saveRect.maxy > shmem->screenBounds.maxy)
484: saveRect.maxy = shmem->screenBounds.maxy;
485: if (saveRect.minx < shmem->screenBounds.minx)
486: saveRect.minx = shmem->screenBounds.minx;
487: if (saveRect.maxx > shmem->screenBounds.maxx)
488: saveRect.maxx = shmem->screenBounds.maxx;
489: shmem->saveRect = saveRect; /* Remember save rect for RemoveCursor */
490:
491: vramRow = dpy->totalWidth; /* Scanline width in pixels */
492: vramPtr = (unsigned int *)dpy->frameBuffer +
493: (vramRow * (saveRect.miny - shmem->screenBounds.miny)) +
494: (saveRect.minx - shmem->screenBounds.minx);
495: width = saveRect.maxx - saveRect.minx;
496: vramRow -= width;
497:
498: cursRow = CURSORWIDTH - width;
499: savePtr = shmem->cursor.rgb24.save;
500: cursPtr = shmem->cursor.rgb24.image[shmem->frame];
501: cursPtr += (saveRect.miny - shmem->cursorRect.miny) * CURSORWIDTH +
502: (saveRect.minx - shmem->cursorRect.minx);
503:
504: if (dpy->pixelEncoding[0] == IO_SampleTypeAlpha ||
505: dpy->pixelEncoding[0] == IO_SampleTypeSkip) {
506: /* Pixel format is Axxx */
507: for (i = saveRect.maxy - saveRect.miny; --i != -1; ) {
508: for (j = width; --j != -1; ) {
509: d = *savePtr++ = *vramPtr;
510: s = *cursPtr++;
511: f = s >> 24;
512: if (f) {
513: if (f == 0xff) // Opaque pixel
514: *vramPtr++ = s;
515: else { // SOVER the cursor pixel
516: s <<= 8; d <<= 8; /* Now pixels are xxxA */
517: f ^= 0xFF;
518: d = s+(((((d&0xFF00FF00)>>8)*f+0x00FF00FF)&0xFF00FF00)
519: | ((((d & 0x00FF00FF)*f+0x00FF00FF)>>8) &
520: 0x00FF00FF));
521: *vramPtr++ = (d>>8) | 0xff000000;
522: }
523: } else // Transparent cursor pixel
524: vramPtr++;
525: }
526: cursPtr += cursRow; /* starting point of next cursor line */
527: vramPtr += vramRow; /* starting point of next screen line */
528: }
529: } else {
530: /* Pixel format is xxxA */
531: for (i = saveRect.maxy - saveRect.miny; --i != -1; ) {
532: for (j = width; --j != -1; ) {
533: d = *savePtr++ = *vramPtr;
534: s = *cursPtr++;
535: f = s & (unsigned int)0xFF;
536: if (f) {
537: if (f == 0xff) // Opaque pixel
538: *vramPtr++ = s;
539: else { // SOVER the cursor pixel
540: f ^= 0xFF;
541: d = s+(((((d&0xFF00FF00)>>8)*f+0x00FF00FF)&0xFF00FF00)
542: | ((((d & 0x00FF00FF)*f+0x00FF00FF)>>8) &
543: 0x00FF00FF));
544: *vramPtr++ = d;
545: }
546: } else // Transparent cursor pixel
547: vramPtr++;
548: }
549: cursPtr += cursRow; /* starting point of next cursor line */
550: vramPtr += vramRow; /* starting point of next screen line */
551: }
552: }
553: }
554:
555: static void StdFBRemoveCursor32(IOFramebuffer *inst)
556: {
557: IODisplayInfo *dpy;
558: StdFBShmem_t *shmem;
559: int i, j, width;
560: unsigned int vramRow;
561: Bounds saveRect;
562: unsigned int *vramPtr;
563: unsigned int *savePtr;
564:
565: dpy = [inst displayInfo];
566: shmem = GetShmem(inst);
567: saveRect = shmem->saveRect;
568: vramRow = dpy->totalWidth; /* Scanline width in pixels */
569: vramPtr = (unsigned int *)dpy->frameBuffer +
570: (vramRow * (saveRect.miny - shmem->screenBounds.miny))
571: + (saveRect.minx - shmem->screenBounds.minx);
572: width = saveRect.maxx - saveRect.minx;
573: vramRow -= width;
574: savePtr = (unsigned int *)shmem->cursor.rgb24.save;
575: for (i = saveRect.maxy - saveRect.miny; --i != -1; ) {
576: for (j = width; --j != -1; )
577: *vramPtr++ = *savePtr++;
578: vramPtr += vramRow;
579: }
580: }
581:
582: static inline void StdFBDisplayCursor(IOFramebuffer *inst)
583: {
584: switch (inst->cursorBitsPerPixel) {
585: default:
586: case IO_12BitsPerPixel:
587: case IO_15BitsPerPixel:
588: StdFBDisplayCursor16(inst);
589: break;
590: case IO_8BitsPerPixel:
591: StdFBDisplayCursor8(inst);
592: break;
593: case IO_24BitsPerPixel:
594: StdFBDisplayCursor32(inst);
595: case (-1):
596: break;
597: }
598: }
599:
600: static inline void StdFBRemoveCursor(IOFramebuffer *inst)
601: {
602: switch (inst->cursorBitsPerPixel) {
603: default:
604: case IO_12BitsPerPixel:
605: case IO_15BitsPerPixel:
606: StdFBRemoveCursor16(inst);
607: break;
608: case IO_8BitsPerPixel:
609: StdFBRemoveCursor8(inst);
610: break;
611: case IO_24BitsPerPixel:
612: StdFBRemoveCursor32(inst);
613: case (-1):
614: break;
615: }
616: }
617:
618:
619: #define RemoveCursor(inst) StdFBRemoveCursor(inst)
620: static inline void DisplayCursor(IOFramebuffer *inst)
621: {
622: Point hs;
623: StdFBShmem_t *shmem;
624:
625: shmem = GetShmem(inst);
626: hs = shmem->hotSpot[shmem->frame];
627: shmem->cursorRect.maxx =
628: (shmem->cursorRect.minx = (shmem->cursorLoc).x - hs.x) + 16;
629: shmem->cursorRect.maxy =
630: (shmem->cursorRect.miny = (shmem->cursorLoc).y - hs.y) + 16;
631: StdFBDisplayCursor(inst);
632: shmem->oldCursorRect = shmem->cursorRect;
633: }
634:
635: static inline void SysHideCursor(IOFramebuffer *inst)
636: {
637: if (!GetShmem(inst)->cursorShow++)
638: RemoveCursor(inst);
639: }
640:
641: static inline void SysShowCursor(IOFramebuffer *inst)
642: {
643: if (GetShmem(inst)->cursorShow)
644: if (!--(GetShmem(inst)->cursorShow))
645: DisplayCursor(inst);
646: }
647:
648: static inline void CheckShield(IOFramebuffer *inst)
649: {
650: Point hs;
651: int intersect;
652: Bounds tempRect;
653: StdFBShmem_t *shmem;
654:
655: shmem = GetShmem(inst);
656: /* Calculate temp cursorRect */
657: hs = shmem->hotSpot[shmem->frame];
658: tempRect.maxx = (tempRect.minx = (shmem->cursorLoc).x - hs.x) + 16;
659: tempRect.maxy = (tempRect.miny = (shmem->cursorLoc).y - hs.y) + 16;
660:
661: intersect = TOUCHBOUNDS(tempRect, shmem->shieldRect);
662: if (intersect != shmem->shielded)
663: (shmem->shielded = intersect) ?
664: SysHideCursor(inst) : SysShowCursor(inst);
665: }
666: //
667: // END: Generic utility routines
668: //
669:
670:
671: //
672: // BEGIN: Implementation of the evScreen protocol
673: //
674: - hideCursor: (int)token
675: {
676: SETSEMA(GetShmem(self));
677: SysHideCursor(self);
678: CLEARSEMA(GetShmem(self));
679: return self;
680: }
681:
682: - moveCursor:(Point*)cursorLoc frame:(int)frame token:(int)t
683: {
684: StdFBShmem_t *shmem;
685:
686: shmem = GetShmem(self);
687: SETSEMA(shmem);
688: shmem->frame = frame;
689: shmem->cursorLoc = *cursorLoc;
690: if (!shmem->cursorShow++)
691: RemoveCursor(self);
692: if (shmem->cursorObscured) {
693: shmem->cursorObscured = 0;
694: if (shmem->cursorShow)
695: --shmem->cursorShow;
696: }
697: if (shmem->shieldFlag) CheckShield(self);
698: if (shmem->cursorShow)
699: if (!--shmem->cursorShow)
700: DisplayCursor(self);
701: CLEARSEMA(shmem);
702: return self;
703: }
704:
705: - showCursor:(Point*)cursorLoc frame:(int)frame token:(int)t
706: {
707: StdFBShmem_t *shmem;
708:
709: shmem = GetShmem(self);
710: SETSEMA(GetShmem(self));
711: shmem->frame = frame;
712: shmem->cursorLoc = *cursorLoc;
713: if (shmem->shieldFlag) CheckShield(self);
714: SysShowCursor(self);
715: CLEARSEMA(shmem);
716: return self;
717: }
718:
719: - setBrightness:(int)level token:(int)t
720: {
721: if ( level < EV_SCREEN_MIN_BRIGHTNESS
722: || level > EV_SCREEN_MAX_BRIGHTNESS )
723: {
724: IOLog("%s: Invalid arg to setBrightness:%d\n",
725: [self name], level );
726: }
727: return self;
728: }
729: //
730: // END: Implementation of the evScreen protocol
731: //
732: //
733: // BEGIN: EXPORTED Methods
734: //
735:
736: - initFromDeviceDescription:deviceDescription
737: {
738: extern int sprintf(char *s, const char *format, ...);
739: static int nextUnit = 0;
740: char nameBuf[20];
741:
742: if ([super initFromDeviceDescription:deviceDescription] == nil)
743: return [super free];
744:
745: _pendingDisplayMode = -1;
746:
747: sprintf(nameBuf, "Display%d", nextUnit);
748: [self setUnit: nextUnit++];
749: [self setName:nameBuf];
750: return self;
751: }
752:
753: - (IOConsoleInfo *)allocateConsoleInfo;
754: // Description: Allocates a console support info structure based on this
755: // display. This structure, and the functions in it, are used
756: // to display alert and console windows.
757: {
758: return FBAllocateConsole([self displayInfo]);
759: }
760:
761: static const char *
762: find_parameter(const char *parameter, const char *string)
763: {
764: int c;
765: size_t length;
766:
767: length = strlen(parameter);
768: while (*string != 0) {
769: if (strncmp(string, parameter, length) == 0) {
770: string += length;
771: while ((c = *string) != '\0' && (c == ' ' || c == '\t'))
772: string++;
773: return (c != 0) ? string : 0;
774: }
775: string++;
776: }
777: return 0;
778: }
779:
780:
781: static UInt32
782: ActiveBytes( IODisplayInfo * displayInfo )
783: {
784: UInt32 bytesPerPixel;
785:
786: switch( displayInfo->bitsPerPixel) {
787: case IO_8BitsPerPixel:
788: bytesPerPixel = 1;
789: break;
790: case IO_15BitsPerPixel:
791: bytesPerPixel = 2;
792: break;
793: case IO_24BitsPerPixel:
794: default:
795: bytesPerPixel = 4;
796: break;
797: }
798: // The last line may not have the full rowBytes physically present,
799: // only the active pixels.
800: return( displayInfo->rowBytes * (displayInfo->height - 1)
801: + (displayInfo->width * bytesPerPixel));
802: }
803:
804: - convertPixelInfoToDisplayInfo:(IOFBPixelInformation *)pixelInfo mono:(BOOL)mono
805: displayInfo:(IODisplayInfo *)displayInfo
806: {
807: IOBitsPerPixel nextDepth;
808: const char * nextPixels;
809: IOColorSpace nextCSpace;
810: static const char * apple8BitMonoEncoding = "WWWWWWWW";
811: static const char * apple8BitEncoding = "PPPPPPPP";
812: static const char * apple16BitEncoding = "-RRRRRGGGGGBBBBB";
813: static const char * apple32BitEncoding = "--------RRRRRRRRGGGGGGGGBBBBBBBB";
814:
815: nextCSpace = IO_RGBColorSpace;
816:
817: switch( pixelInfo->bitsPerPixel ) {
818: default:
819: case 8:
820: nextDepth = IO_8BitsPerPixel;
821: if( mono) {
822: nextCSpace = IO_OneIsWhiteColorSpace;
823: nextPixels = apple8BitMonoEncoding;
824: } else {
825: nextPixels = apple8BitEncoding;
826: }
827: break;
828: case 16:
829: nextDepth = IO_15BitsPerPixel;
830: nextPixels = apple16BitEncoding;
831: break;
832: case 32:
833: nextDepth = IO_24BitsPerPixel;
834: nextPixels = apple32BitEncoding;
835: break;
836: }
837:
838: bzero(displayInfo, sizeof(IODisplayInfo));
839:
840: strncpy(displayInfo->pixelEncoding, nextPixels, strlen(nextPixels));
841: displayInfo->width = pixelInfo->width;
842: displayInfo->height = pixelInfo->height;
843: displayInfo->rowBytes = pixelInfo->rowBytes;
844: displayInfo->totalWidth = (pixelInfo->rowBytes * 8) / pixelInfo->bitsPerPixel;
845: displayInfo->refreshRate = (pixelInfo->refreshRate + 0x8000) >> 16;
846: displayInfo->bitsPerPixel = nextDepth;
847: displayInfo->colorSpace = nextCSpace;
848: displayInfo->flags = IO_DISPLAY_HAS_TRANSFER_TABLE
849: | [self tempFlags];
850: return( self);
851: }
852:
853: - (IOReturn) getNextMode:(IOFBIndex *)index modeInfo:(IOFBDisplayModeInformation *)modeInfo needFlags:(UInt32)needFlags
854: {
855: IOReturn err;
856: IOFBDisplayModeID modeID;
857: IOFBTimingInformation timingInfo;
858: UInt32 flags;
859:
860: do {
861: err = [self getDisplayModeByIndex:(*index)++ displayMode:&modeID];
862: if( err)
863: break;
864: err = [self getDisplayModeInformation:modeID info:modeInfo];
865: if( err)
866: break;
867:
868: err = [self getDisplayModeTiming:0 mode:modeID timingInfo:&timingInfo connectFlags:&flags];
869:
870: } while( (err == noErr) && ((flags & needFlags) != needFlags) );
871:
872: return( err);
873: }
874:
875: // Apple standard 8-bit CLUT
876:
877: const UInt8 appleClut8[ 256 * 3 ] = {
878: 0xFF,0xFF,0xFF, 0xFF,0xFF,0xCC, 0xFF,0xFF,0x99, 0xFF,0xFF,0x66,
879: 0xFF,0xFF,0x33, 0xFF,0xFF,0x00, 0xFF,0xCC,0xFF, 0xFF,0xCC,0xCC,
880: 0xFF,0xCC,0x99, 0xFF,0xCC,0x66, 0xFF,0xCC,0x33, 0xFF,0xCC,0x00,
881: 0xFF,0x99,0xFF, 0xFF,0x99,0xCC, 0xFF,0x99,0x99, 0xFF,0x99,0x66,
882: 0xFF,0x99,0x33, 0xFF,0x99,0x00, 0xFF,0x66,0xFF, 0xFF,0x66,0xCC,
883: 0xFF,0x66,0x99, 0xFF,0x66,0x66, 0xFF,0x66,0x33, 0xFF,0x66,0x00,
884: 0xFF,0x33,0xFF, 0xFF,0x33,0xCC, 0xFF,0x33,0x99, 0xFF,0x33,0x66,
885: 0xFF,0x33,0x33, 0xFF,0x33,0x00, 0xFF,0x00,0xFF, 0xFF,0x00,0xCC,
886: 0xFF,0x00,0x99, 0xFF,0x00,0x66, 0xFF,0x00,0x33, 0xFF,0x00,0x00,
887: 0xCC,0xFF,0xFF, 0xCC,0xFF,0xCC, 0xCC,0xFF,0x99, 0xCC,0xFF,0x66,
888: 0xCC,0xFF,0x33, 0xCC,0xFF,0x00, 0xCC,0xCC,0xFF, 0xCC,0xCC,0xCC,
889: 0xCC,0xCC,0x99, 0xCC,0xCC,0x66, 0xCC,0xCC,0x33, 0xCC,0xCC,0x00,
890: 0xCC,0x99,0xFF, 0xCC,0x99,0xCC, 0xCC,0x99,0x99, 0xCC,0x99,0x66,
891: 0xCC,0x99,0x33, 0xCC,0x99,0x00, 0xCC,0x66,0xFF, 0xCC,0x66,0xCC,
892: 0xCC,0x66,0x99, 0xCC,0x66,0x66, 0xCC,0x66,0x33, 0xCC,0x66,0x00,
893: 0xCC,0x33,0xFF, 0xCC,0x33,0xCC, 0xCC,0x33,0x99, 0xCC,0x33,0x66,
894: 0xCC,0x33,0x33, 0xCC,0x33,0x00, 0xCC,0x00,0xFF, 0xCC,0x00,0xCC,
895: 0xCC,0x00,0x99, 0xCC,0x00,0x66, 0xCC,0x00,0x33, 0xCC,0x00,0x00,
896: 0x99,0xFF,0xFF, 0x99,0xFF,0xCC, 0x99,0xFF,0x99, 0x99,0xFF,0x66,
897: 0x99,0xFF,0x33, 0x99,0xFF,0x00, 0x99,0xCC,0xFF, 0x99,0xCC,0xCC,
898: 0x99,0xCC,0x99, 0x99,0xCC,0x66, 0x99,0xCC,0x33, 0x99,0xCC,0x00,
899: 0x99,0x99,0xFF, 0x99,0x99,0xCC, 0x99,0x99,0x99, 0x99,0x99,0x66,
900: 0x99,0x99,0x33, 0x99,0x99,0x00, 0x99,0x66,0xFF, 0x99,0x66,0xCC,
901: 0x99,0x66,0x99, 0x99,0x66,0x66, 0x99,0x66,0x33, 0x99,0x66,0x00,
902: 0x99,0x33,0xFF, 0x99,0x33,0xCC, 0x99,0x33,0x99, 0x99,0x33,0x66,
903: 0x99,0x33,0x33, 0x99,0x33,0x00, 0x99,0x00,0xFF, 0x99,0x00,0xCC,
904: 0x99,0x00,0x99, 0x99,0x00,0x66, 0x99,0x00,0x33, 0x99,0x00,0x00,
905: 0x66,0xFF,0xFF, 0x66,0xFF,0xCC, 0x66,0xFF,0x99, 0x66,0xFF,0x66,
906: 0x66,0xFF,0x33, 0x66,0xFF,0x00, 0x66,0xCC,0xFF, 0x66,0xCC,0xCC,
907: 0x66,0xCC,0x99, 0x66,0xCC,0x66, 0x66,0xCC,0x33, 0x66,0xCC,0x00,
908: 0x66,0x99,0xFF, 0x66,0x99,0xCC, 0x66,0x99,0x99, 0x66,0x99,0x66,
909: 0x66,0x99,0x33, 0x66,0x99,0x00, 0x66,0x66,0xFF, 0x66,0x66,0xCC,
910: 0x66,0x66,0x99, 0x66,0x66,0x66, 0x66,0x66,0x33, 0x66,0x66,0x00,
911: 0x66,0x33,0xFF, 0x66,0x33,0xCC, 0x66,0x33,0x99, 0x66,0x33,0x66,
912: 0x66,0x33,0x33, 0x66,0x33,0x00, 0x66,0x00,0xFF, 0x66,0x00,0xCC,
913: 0x66,0x00,0x99, 0x66,0x00,0x66, 0x66,0x00,0x33, 0x66,0x00,0x00,
914: 0x33,0xFF,0xFF, 0x33,0xFF,0xCC, 0x33,0xFF,0x99, 0x33,0xFF,0x66,
915: 0x33,0xFF,0x33, 0x33,0xFF,0x00, 0x33,0xCC,0xFF, 0x33,0xCC,0xCC,
916: 0x33,0xCC,0x99, 0x33,0xCC,0x66, 0x33,0xCC,0x33, 0x33,0xCC,0x00,
917: 0x33,0x99,0xFF, 0x33,0x99,0xCC, 0x33,0x99,0x99, 0x33,0x99,0x66,
918: 0x33,0x99,0x33, 0x33,0x99,0x00, 0x33,0x66,0xFF, 0x33,0x66,0xCC,
919: 0x33,0x66,0x99, 0x33,0x66,0x66, 0x33,0x66,0x33, 0x33,0x66,0x00,
920: 0x33,0x33,0xFF, 0x33,0x33,0xCC, 0x33,0x33,0x99, 0x33,0x33,0x66,
921: 0x33,0x33,0x33, 0x33,0x33,0x00, 0x33,0x00,0xFF, 0x33,0x00,0xCC,
922: 0x33,0x00,0x99, 0x33,0x00,0x66, 0x33,0x00,0x33, 0x33,0x00,0x00,
923: 0x00,0xFF,0xFF, 0x00,0xFF,0xCC, 0x00,0xFF,0x99, 0x00,0xFF,0x66,
924: 0x00,0xFF,0x33, 0x00,0xFF,0x00, 0x00,0xCC,0xFF, 0x00,0xCC,0xCC,
925: 0x00,0xCC,0x99, 0x00,0xCC,0x66, 0x00,0xCC,0x33, 0x00,0xCC,0x00,
926: 0x00,0x99,0xFF, 0x00,0x99,0xCC, 0x00,0x99,0x99, 0x00,0x99,0x66,
927: 0x00,0x99,0x33, 0x00,0x99,0x00, 0x00,0x66,0xFF, 0x00,0x66,0xCC,
928: 0x00,0x66,0x99, 0x00,0x66,0x66, 0x00,0x66,0x33, 0x00,0x66,0x00,
929: 0x00,0x33,0xFF, 0x00,0x33,0xCC, 0x00,0x33,0x99, 0x00,0x33,0x66,
930: 0x00,0x33,0x33, 0x00,0x33,0x00, 0x00,0x00,0xFF, 0x00,0x00,0xCC,
931: 0x00,0x00,0x99, 0x00,0x00,0x66, 0x00,0x00,0x33, 0xEE,0x00,0x00,
932: 0xDD,0x00,0x00, 0xBB,0x00,0x00, 0xAA,0x00,0x00, 0x88,0x00,0x00,
933: 0x77,0x00,0x00, 0x55,0x00,0x00, 0x44,0x00,0x00, 0x22,0x00,0x00,
934: 0x11,0x00,0x00, 0x00,0xEE,0x00, 0x00,0xDD,0x00, 0x00,0xBB,0x00,
935: 0x00,0xAA,0x00, 0x00,0x88,0x00, 0x00,0x77,0x00, 0x00,0x55,0x00,
936: 0x00,0x44,0x00, 0x00,0x22,0x00, 0x00,0x11,0x00, 0x00,0x00,0xEE,
937: 0x00,0x00,0xDD, 0x00,0x00,0xBB, 0x00,0x00,0xAA, 0x00,0x00,0x88,
938: 0x00,0x00,0x77, 0x00,0x00,0x55, 0x00,0x00,0x44, 0x00,0x00,0x22,
939: 0x00,0x00,0x11, 0xEE,0xEE,0xEE, 0xDD,0xDD,0xDD, 0xBB,0xBB,0xBB,
940: 0xAA,0xAA,0xAA, 0x88,0x88,0x88, 0x77,0x77,0x77, 0x55,0x55,0x55,
941: 0x44,0x44,0x44, 0x22,0x22,0x22, 0x11,0x11,0x11, 0x00,0x00,0x00
942: };
943:
944: ///////////////////// Backwards compatibility goo /////////////////////
945:
946: - (IOReturn) makeConfigList
947: {
948: IOFBDisplayModeInformation info;
949: IOFBPixelInformation pixelInfo;
950: IOFBIndex depth;
951: struct ModeData * modeData;
952: UInt32 modeIndex;
953: UInt32 preflight;
954: IOReturn err;
955: enum { kNeedFlags = (kDisplayModeValidFlag /*| kDisplayModeSafeFlag */) };
956:
957: numModes = numConfigs = 0;
958: preflight = 1;
959: modeData = NULL;
960: do {
961:
962: if( numModes) {
963: modeData = IOMalloc( numModes * sizeof( struct ModeData));
964: modeTable = modeData;
965: }
966: modeIndex = 0;
967: while( (noErr == [self getNextMode:&modeIndex modeInfo:&info needFlags:kNeedFlags])) {
968:
969: if( modeData) {
970: if( (modeData - modeTable) >= numModes)
971: kprintf("!!MODE LIST BAD!!\n");
972: else {
973:
974: depth = -1;
975: do {
976: err = [self getPixelInformationForDisplayMode:info.displayModeID andDepthIndex:++depth
977: pixelInfo:&pixelInfo];
978:
979: if( (err == noErr) && (pixelInfo.bitsPerPixel >= 8)) {
980: modeData->modeID = info.displayModeID;
981: modeData->firstDepth = depth;
982: modeData->numDepths = 1 + info.maxDepthIndex - depth;
983: if( pixelInfo.bitsPerPixel == 8)
984: modeData->numDepths++; // +MONO
985: numConfigs += modeData->numDepths;
986: modeData++;
987: break;
988: }
989: } while( (err == noErr) && (depth < info.maxDepthIndex));
990: }
991: } else
992: numModes++;
993: }
994: } while( preflight--);
995:
996: return( noErr);
997: }
998:
999: - (IOReturn) getDisplayModeAndDepthForIndex:(UInt32)configIndex
1000: mode:(IOFBDisplayModeID *)mode depth:(IOFBIndex *)depth mono:(BOOL *)mono
1001: {
1002: struct ModeData * modeData;
1003: UInt32 modeIndex;
1004:
1005: for( modeIndex = 0, modeData = modeTable;
1006: modeIndex < numModes;
1007: modeIndex++, modeData++) {
1008:
1009: if( configIndex < modeData->numDepths) {
1010: *mode = modeData->modeID;
1011: *mono = (configIndex == 0);
1012: if( *mono)
1013: *depth = modeData->firstDepth;
1014: else
1015: *depth = modeData->firstDepth + configIndex - 1;
1016: return( noErr);
1017: }
1018: configIndex -= modeData->numDepths;
1019: }
1020:
1021: return( IO_R_UNDEFINED_MODE);
1022: }
1023:
1024: - (IOReturn) getConfigIndexForDisplayModeAndDepth:
1025: (IOFBDisplayModeID)mode depth:(IOFBIndex)depth mono:(BOOL)mono
1026: configIndex:(UInt32 *)configIndex
1027: {
1028: UInt32 index;
1029: struct ModeData * modeData;
1030: UInt32 modeIndex;
1031:
1032: for( modeIndex = 0, modeData = modeTable, index = 0;
1033: modeIndex < numModes;
1034: modeIndex++, modeData++) {
1035:
1036: if( mode == modeData->modeID) {
1037: if( depth <= modeData->firstDepth) // 8 bpp mode
1038: index += (mono ? 0 : 1);
1039: else
1040: index += depth - modeData->firstDepth + 1;
1041: *configIndex = index;
1042: return( noErr);
1043: }
1044: index += modeData->numDepths;
1045: }
1046:
1047: return( IO_R_UNDEFINED_MODE);
1048: }
1049:
1050: - (IOReturn) getCurrentConfigIndex:(UInt32 *)configIndex
1051: {
1052: return( [self getConfigIndexForDisplayModeAndDepth:currentDisplayModeID
1053: depth:currentDepthIndex mono:currentMono
1054: configIndex:configIndex]);
1055: }
1056:
1057: - (IOReturn) getDisplayInfoForConfigIndex:(UInt32)index info:(IODisplayInfo *)displayInfo
1058: connectFlags:(UInt32 *)flags
1059: {
1060: IOFBPixelInformation pixelInfo;
1061: IOReturn err;
1062: IOFBDisplayModeID mode;
1063: IOFBIndex depth;
1064: IOFBTimingInformation timingInfo;
1065: BOOL mono;
1066:
1067: err = [self getDisplayModeAndDepthForIndex:index
1068: mode:&mode depth:&depth mono:&mono];
1069:
1070: if( err == noErr)
1071: err = [self getPixelInformationForDisplayMode:mode andDepthIndex:depth
1072: pixelInfo:&pixelInfo];
1073:
1074: if( err == noErr)
1075: [self convertPixelInfoToDisplayInfo:&pixelInfo mono:mono displayInfo:displayInfo];
1076:
1077: if( flags &&
1078: [self getDisplayModeTiming:0 mode:mode timingInfo:&timingInfo connectFlags:flags])
1079: *flags = 0;
1080:
1081: return( err);
1082: }
1083:
1084: ///////////////////////////////////////////////////////
1085:
1086: - (IOReturn) open
1087: {
1088: IOReturn err;
1089: IOFBConfiguration config;
1090: IOFBTimingInformation timingInfo;
1091: IOFBDisplayModeID startMode;
1092: IOFBIndex startDepth;
1093: UInt32 startFlags = 0;
1094: UInt32 modeIndex;
1095: IOFBDisplayModeInformation info;
1096:
1097: enum { kNeedFlags = (kDisplayModeValidFlag | kDisplayModeSafeFlag) };
1098:
1099: if( opened == NO) {
1100:
1101: opened = YES;
1102: smartDisplay = [gSmartDisplayClass findForConnection:self refCon:0];
1103: [self makeConfigList];
1104:
1105: // Check the startup mode with the display
1106:
1107: [self getConfiguration:&config];
1108: err = [self getStartupMode:&startMode depth:&startDepth];
1109: if( err) {
1110: startMode = config.displayMode;
1111: startDepth = config.depth;
1112: }
1113:
1114: err = [self getDisplayModeInformation:startMode info:&info];
1115:
1116: if( err == noErr)
1117: err = [self getDisplayModeTiming:0 mode:startMode
1118: timingInfo:&timingInfo connectFlags:&startFlags];
1119:
1120: if( err || ((startFlags & kDisplayModeValidFlag) != kDisplayModeValidFlag) ) {
1121:
1122: // look for default
1123: modeIndex = 0;
1124: err = [self getNextMode:&modeIndex modeInfo:&info needFlags:kDisplayModeDefaultFlag];
1125: if( err) {
1126: // D'oh, look for a valid and safe
1127: modeIndex = 0;
1128: err = [self getNextMode:&modeIndex modeInfo:&info needFlags:kNeedFlags];
1129: }
1130: if( err == noErr)
1131: startMode = info.displayModeID;
1132: }
1133:
1134: if( startDepth > info.maxDepthIndex)
1135: startDepth = info.maxDepthIndex;
1136:
1137: // make the preferred mode pending, but come up at 8bpp for faster console
1138: _pendingDisplayMode = 0;
1139: pendingDisplayModeID = startMode;
1140: pendingDepthIndex = startDepth;
1141: // look for 8bpp mode
1142: err = [self getConfigIndexForDisplayModeAndDepth:startMode depth:0
1143: mono:NO configIndex:&modeIndex];
1144: if( err == noErr)
1145: err = [self getDisplayModeAndDepthForIndex:modeIndex
1146: mode:&startMode depth:&startDepth mono:¤tMono];
1147:
1148: currentMono = (0 != (config.flags & kFBLuminanceMapped));
1149: pendingMono = currentMono;
1150:
1151: if( (startMode != config.displayMode) || (startDepth != config.depth)) {
1152:
1153: id deviceDesc = [self deviceDescription];
1154:
1155: if( [deviceDesc respondsTo:@selector(denyNVRAM:)])
1156: [deviceDesc denyNVRAM:YES];
1157:
1158: [self setDisplayMode:startMode depth:startDepth page:0];
1159:
1160: if( [deviceDesc respondsTo:@selector(denyNVRAM:)])
1161: [deviceDesc denyNVRAM:NO];
1162: }
1163: [self setupForCurrentConfig];
1164: }
1165:
1166: return( noErr);
1167: }
1168:
1169: + (BOOL)probe:deviceDescription
1170: {
1171: IOFramebuffer *inst;
1172:
1173: // Create an instance and initialize some basic instance variables.
1174: inst = [[self alloc] initFromDeviceDescription:deviceDescription];
1175: if (inst == nil)
1176: return NO;
1177:
1178: [inst setDeviceKind:"Linear Framebuffer"];
1179:
1180: [inst registerDevice];
1181:
1182: return YES;
1183: }
1184:
1185: - (IOReturn) setUserRanges
1186: {
1187: IOReturn err;
1188: id deviceDescrip;
1189: UInt32 i, start, size;
1190:
1191: deviceDescrip = [self deviceDescription];
1192: [deviceDescrip setMemoryRangeList:0 num:0];
1193:
1194: // needs to be much better !!
1195: for( i = 0; i < numRanges; i++) {
1196:
1197: start = userAccessRanges[ i ].start;
1198: size = start & 0xfff;
1199: start = start - size;
1200: size = (size + 0xfff + userAccessRanges[ i ].size) & 0xfffff000;
1201: userAccessRanges[ i ].start = start;
1202: userAccessRanges[ i ].size = size;
1203: }
1204:
1205: err = [deviceDescrip setMemoryRangeList:userAccessRanges num:numRanges];
1206:
1207: if(err) {
1208: IOLog("%s: setMemoryRangeList FAIL:%d for \n",[self name], err );
1209: #if 1 // print ranges
1210: for( i = 0; i < numRanges; i++)
1211: IOLog(" start:%x size:%x", userAccessRanges[ i ].start, userAccessRanges[ i ].size );
1212: #endif
1213: }
1214: #if 1 // print ranges
1215: {
1216: int i, num;
1217: IORange * range;
1218:
1219: num = [deviceDescrip numMemoryRanges];
1220: kprintf("%s: setMemoryRangeList num:%d", [self name], num);
1221: for (i = 0; i < num; i++) {
1222: range = [deviceDescrip memoryRangeList] + i;
1223: kprintf(" start:%x size:%x", range->start, range->size);
1224: }
1225: kprintf("\n");
1226: }
1227: #endif
1228: return( err);
1229: }
1230:
1231: - (IOReturn) addUserRanges:(IORange *)ranges num:(UInt32)num
1232: {
1233: UInt32 i;
1234:
1235: for( i = 0; i < num; i++) {
1236: userAccessRanges[ i + 1 ].start = ranges[ i ].start;
1237: userAccessRanges[ i + 1 ].size = ranges[ i ].size;
1238: }
1239: numRanges = num + 1;
1240: return( noErr);
1241: }
1242:
1243: - (IOReturn) setupForCurrentConfig
1244: {
1245: IOReturn err;
1246: IOFBConfiguration config;
1247: IOFBPixelInformation pixelInfo;
1248: IODisplayInfo * displayInfo;
1249: IOFBApertureInformation apInfo;
1250: IOFBIndex apIndex;
1251:
1252: displayInfo = [self displayInfo]; // current mode
1253:
1254: err = [self getConfiguration:&config];
1255: if( err)
1256: kprintf("setupForCurrentConfig:getConfiguration %d\n", err);
1257: currentDisplayModeID = config.displayMode;
1258: currentDepthIndex = config.depth;
1259:
1260: err = [self getPixelInformationForDisplayMode:currentDisplayModeID andDepthIndex:currentDepthIndex
1261: pixelInfo:&pixelInfo];
1262: if( err)
1263: kprintf("setupForCurrentConfig:getPixelInformationForDisplayMode %d\n", err);
1264:
1265: [self convertPixelInfoToDisplayInfo:&pixelInfo
1266: mono:currentMono
1267: displayInfo:displayInfo];
1268: displayInfo->frameBuffer = (void *) config.mappedFramebuffer; // for cursor rendering
1269:
1270: if( (clutValid == NO) && (pixelInfo.pixelType == kIOFBRGBCLUTPixelType)) {
1271:
1272: IOFBColorEntry * tempTable;
1273: int i;
1274:
1275: tempTable = IOMalloc( 256 * sizeof( IOFBColorEntry));
1276: if( tempTable) {
1277:
1278: for( i = 0; i < 256; i++) {
1279: if( currentMono) {
1280: UInt32 lum;
1281:
1282: lum = 0x0101 * i;
1283: tempTable[ i ].red = lum;
1284: tempTable[ i ].green = lum;
1285: tempTable[ i ].blue = lum;
1286: } else {
1287: tempTable[ i ].red = (appleClut8[ i * 3 + 0 ] << 8) | appleClut8[ i * 3 + 0 ];
1288: tempTable[ i ].green = (appleClut8[ i * 3 + 1 ] << 8) | appleClut8[ i * 3 + 1 ];
1289: tempTable[ i ].blue = (appleClut8[ i * 3 + 2 ] << 8) | appleClut8[ i * 3 + 2 ];
1290: }
1291: }
1292: [self setCLUT:tempTable index:0 numEntries:256
1293: brightness:EV_SCREEN_MAX_BRIGHTNESS options:0];
1294: IOFree( tempTable, 256 * sizeof( IOFBColorEntry));
1295: }
1296: }
1297: clutValid = YES;
1298:
1299: [kmId registerDisplay:self]; // console now available
1300:
1301: kprintf( "%s: using (%dx%d@%dHz,%s)\n", [self name], displayInfo->width, displayInfo->height,
1302: displayInfo->refreshRate,displayInfo->pixelEncoding );
1303:
1304: // our guess:
1305: if( numRanges < 1)
1306: numRanges = 1;
1307: userAccessRanges[0].start = config.physicalFramebuffer;
1308: userAccessRanges[0].size = ActiveBytes( displayInfo);
1309: // what the driver says:
1310: apIndex = 0;
1311: while( noErr == [self getApertureInformationByIndex:apIndex++ apertureInfo:&apInfo]) {
1312: if( apInfo.type == kIOFBGraphicsMemory) {
1313: userAccessRanges[0].start = apInfo.physicalAddress;
1314: userAccessRanges[0].size = apInfo.length;
1315: }
1316: }
1317: err = [self setUserRanges];
1318:
1319: framebufferOffset = config.physicalFramebuffer - userAccessRanges[0].start;
1320:
1321: if( cursorShmemBitsPerPixel == displayInfo->bitsPerPixel)
1322: cursorBitsPerPixel = displayInfo->bitsPerPixel;
1323:
1324: return( noErr);
1325: }
1326:
1327: - (IOReturn)
1328: getDisplayModeTiming:(IOFBIndex)connectIndex mode:(IOFBDisplayModeID)modeID
1329: timingInfo:(IOFBTimingInformation *)info connectFlags:(UInt32 *)flags
1330:
1331: {
1332: OSStatus err = noErr;
1333:
1334: // if smartDisplay is nil, the flags get passed through
1335: err = [smartDisplay getDisplayInfoForMode:info flags:flags];
1336: return( err );
1337: }
1338:
1339: //////////////////////////////////////////////////////////////////////
1340: // IOCallDeviceMethods:
1341:
1342:
1343: //////////////////////////////////////////////////////////////////////
1344:
1345: // Description: Get parameters for the display object. These include support
1346: // for getting the frame buffer parameters, registering it
1347: // with the event system, returning the registration token.
1348:
1349: - (IOReturn)getIntValues:(unsigned *)parameterArray
1350: forParameter:(IOParameterName)parameterName
1351: count:(unsigned int *)count
1352: {
1353: unsigned int fb_dimensions[STDFB_FB_DIMENSIONS_SIZE];
1354: IOReturn r;
1355: int i;
1356: unsigned *returnedCount = count;
1357: unsigned maxCount = *count;
1358:
1359: if (strcmp(parameterName, STDFB_FB_MAP) == 0) {
1360: parameterArray[0] = 0;
1361:
1362: // [self enterLinearMode];
1363: *returnedCount = 1;
1364: return IO_R_SUCCESS;
1365:
1366: } else if (strcmp(parameterName, STDFB_FB_DIMENSIONS) == 0) {
1367: IODisplayInfo *display = [self displayInfo];
1368:
1369: r = [self open];
1370: if( r)
1371: return( r); // this will halt WS on this display
1372: if( wsStartup)
1373: (void) [self _commitToPendingMode];
1374: [self setupForCurrentConfig];
1375:
1376: fb_dimensions[STDFB_FB_WIDTH] = display->width;
1377: fb_dimensions[STDFB_FB_HEIGHT] = display->height;
1378: fb_dimensions[STDFB_FB_ROWBYTES] = display->rowBytes;
1379: fb_dimensions[STDFB_FB_FLAGS] = display->flags;
1380: switch (display->bitsPerPixel) {
1381: case IO_2BitsPerPixel:
1382: fb_dimensions[STDFB_FB_BITS_PER_PIXEL] = 2; break;
1383: case IO_8BitsPerPixel:
1384: fb_dimensions[STDFB_FB_BITS_PER_PIXEL] = 8; break;
1385: case IO_12BitsPerPixel:
1386: fb_dimensions[STDFB_FB_BITS_PER_PIXEL] = 12; break;
1387: case IO_15BitsPerPixel:
1388: fb_dimensions[STDFB_FB_BITS_PER_PIXEL] = 15; break;
1389: case IO_24BitsPerPixel:
1390: fb_dimensions[STDFB_FB_BITS_PER_PIXEL] = 32; break;
1391: default:
1392: /* Should return an error. */
1393: break;
1394: }
1395:
1396: *returnedCount = 0;
1397: for( i=0; i<STDFB_FB_DIMENSIONS_SIZE; i++) {
1398: if (*returnedCount == maxCount)
1399: break;
1400: parameterArray[i] = fb_dimensions[i];
1401: (*returnedCount)++;
1402: }
1403: return IO_R_SUCCESS;
1404:
1405: } else if (strcmp(parameterName, STDFB_FB_REGISTER) == 0) {
1406: r = [self _registerWithED];
1407: *returnedCount = 0;
1408: if (maxCount > 0) {
1409: *returnedCount = 1;
1410: parameterArray[0] = [self token];
1411: }
1412: return r;
1413:
1414: } else if (strcmp(parameterName, IO_GET_DISPLAY_INFO) == 0) {
1415: const IODisplayInfo *displayInfo;
1416: if ((*count != 5) && (*count != 7))
1417: return IO_R_INVALID_ARG;
1418: displayInfo = [self displayInfo];
1419: parameterArray[0] = displayInfo->width;
1420: parameterArray[1] = displayInfo->height;
1421: parameterArray[2] = displayInfo->refreshRate;
1422: parameterArray[3] = (unsigned)displayInfo->bitsPerPixel;
1423: parameterArray[4] = (unsigned)displayInfo->colorSpace;
1424: if (*count == 7) {
1425: parameterArray[5] = displayInfo->totalWidth;
1426: parameterArray[6] = displayInfo->rowBytes;
1427: }
1428: return IO_R_SUCCESS;
1429:
1430: } else if (strcmp(parameterName, IO_GET_DISPLAY_MODE_NUM) == 0) {
1431: if (*count != 1)
1432: return IO_R_INVALID_ARG;
1433: parameterArray[0] = numConfigs;
1434: return IO_R_SUCCESS;
1435:
1436: } else if (strncmp(parameterName, IO_GET_DISPLAY_MODE_INFO,
1437: sizeof(IO_GET_DISPLAY_MODE_INFO)-1) == 0) {
1438: IODisplayInfo theDisplayInfo;
1439: IODisplayInfo *displayInfo = &theDisplayInfo;
1440: const char *s;
1441: int mode;
1442: UInt32 flags;
1443:
1444: if (*count != 14) {
1445: return IO_R_INVALID_ARG;
1446: }
1447: s = find_parameter(IO_GET_DISPLAY_MODE_INFO, parameterName);
1448: if (s == 0) {
1449: return IO_R_INVALID_ARG;
1450: }
1451: mode = strtol(s, 0, 10);
1452:
1453: r = [self getDisplayInfoForConfigIndex:mode info:displayInfo
1454: connectFlags:&flags];
1455: if( r)
1456: return( r);
1457:
1458: parameterArray[0] = displayInfo->width;
1459: parameterArray[1] = displayInfo->height;
1460: parameterArray[2] = displayInfo->refreshRate;
1461: parameterArray[3] = (unsigned)displayInfo->bitsPerPixel;
1462: parameterArray[4] = (unsigned)displayInfo->colorSpace;
1463: parameterArray[5] = displayInfo->totalWidth;
1464: parameterArray[6] = displayInfo->rowBytes;
1465:
1466: parameterArray[7] = displayInfo->memorySize;
1467: parameterArray[8] = displayInfo->scanRate;
1468: parameterArray[9] = ((flags & kDisplayModeSafeFlag) ? IO_DISPLAY_MODE_SAFE : 0)
1469: | ((flags & kDisplayModeDefaultFlag) ? IO_DISPLAY_MODE_DEFAULT : 0);
1470: parameterArray[10] = displayInfo->dotClockRate;
1471: parameterArray[11] = displayInfo->screenWidth;
1472: parameterArray[12] = displayInfo->screenHeight;
1473: parameterArray[13] = displayInfo->modeUnavailableFlag;
1474: return IO_R_SUCCESS;
1475:
1476: } else if (strcmp(parameterName, IO_GET_DISPLAY_MEMORY) == 0) {
1477: if (*count != 1)
1478: return IO_R_INVALID_ARG;
1479: parameterArray[0] = 0;
1480: return IO_R_SUCCESS;
1481:
1482: } else if (strcmp(parameterName, IO_GET_RAMDAC_SPEED) == 0) {
1483: if (*count != 1)
1484: return IO_R_INVALID_ARG;
1485: parameterArray[0] = 0;
1486: return IO_R_SUCCESS;
1487:
1488: } else if (strcmp(parameterName, IO_GET_CURRENT_DISPLAY_MODE) == 0) {
1489: if (*count != 1)
1490: return IO_R_INVALID_ARG;
1491: return( [self getCurrentConfigIndex:(UInt32 *)parameterArray]);
1492:
1493: } else if (strcmp(parameterName, IO_GET_PENDING_DISPLAY_MODE) == 0) {
1494: if (*count != 1)
1495: return IO_R_INVALID_ARG;
1496: if (_pendingDisplayMode >= 0) {
1497: parameterArray[0] = _pendingDisplayMode;
1498: return IO_R_SUCCESS;
1499: } else {
1500: return IO_R_UNDEFINED_MODE;
1501: }
1502:
1503: } else if (strcmp(parameterName, "IOGetFramebufferOffset") == 0) {
1504:
1505: if( *count != 1)
1506: return IO_R_INVALID_ARG;
1507: parameterArray[0] = framebufferOffset;
1508: return IO_R_SUCCESS;
1509:
1510: } else if (strncmp(parameterName, IO_SET_PENDING_DISPLAY_MODE,
1511: sizeof(IO_SET_PENDING_DISPLAY_MODE) - 1 ) == 0) {
1512: const char *s;
1513: int mode;
1514:
1515: if (*count != 0) {
1516: return IO_R_INVALID_ARG;
1517: }
1518: s = find_parameter(IO_SET_PENDING_DISPLAY_MODE, parameterName);
1519: if (s == 0) {
1520: return IO_R_INVALID_ARG;
1521: }
1522: mode = strtol(s, 0, 10);
1523:
1524: if ([self setPendingDisplayMode:mode] == YES) {
1525: return IO_R_SUCCESS;
1526: } else {
1527: return IO_R_FAILED_TO_SET_MODE;
1528: }
1529:
1530: } else {
1531: return [super getIntValues:parameterArray
1532: forParameter:parameterName
1533: count:count];
1534: }
1535: }
1536:
1537:
1538: /* Set parameters for the display object. This can be used to unregister the
1539: * frame buffer as well as to set the transfer function.
1540: */
1541: - (IOReturn)setIntValues:(unsigned *)parameterArray
1542: forParameter:(IOParameterName)parameterName
1543: count:(unsigned int)count
1544: {
1545: int i;
1546:
1547: if (strcmp(parameterName, STDFB_FB_UNMAP) == 0) {
1548: //[self unMapFrameBuffer];
1549: return IO_R_SUCCESS;
1550:
1551: } else if (strcmp(parameterName, STDFB_FB_UNREGISTER) == 0) {
1552: if (count != 1)
1553: return IO_R_INVALID_ARG;
1554: [[EventDriver instance] unregisterScreen:parameterArray[0]];
1555: return IO_R_SUCCESS;
1556:
1557: } else if (strcmp(parameterName, IO_SET_TRANSFER_TABLE) == 0) {
1558: switch ([self displayInfo]->bitsPerPixel) {
1559: case IO_2BitsPerPixel:
1560: if (count != IO_2BPP_TRANSFER_TABLE_SIZE)
1561: return IO_R_INVALID_ARG;
1562: break;
1563: case IO_8BitsPerPixel:
1564: if (count != IO_8BPP_TRANSFER_TABLE_SIZE)
1565: return IO_R_INVALID_ARG;
1566: break;
1567: case IO_12BitsPerPixel:
1568: if (count != IO_12BPP_TRANSFER_TABLE_SIZE)
1569: return IO_R_INVALID_ARG;
1570: break;
1571: case IO_15BitsPerPixel:
1572: if (count != IO_15BPP_TRANSFER_TABLE_SIZE)
1573: return IO_R_INVALID_ARG;
1574: break;
1575: case IO_24BitsPerPixel:
1576: if (count != IO_24BPP_TRANSFER_TABLE_SIZE)
1577: return IO_R_INVALID_ARG;
1578: break;
1579: default:
1580: return IO_R_INVALID_ARG;
1581: }
1582: [self setTransferTable:parameterArray count:count];
1583: return IO_R_SUCCESS;
1584:
1585: } else if (strcmp(parameterName, STDFB_BM256_TO_BM38_MAP) == 0) {
1586: if (count != STDFB_BM256_TO_BM38_MAP_SIZE)
1587: return IO_R_INVALID_ARG;
1588: if (_bm256To38SampleTable == NULL)
1589: _bm256To38SampleTable = (unsigned int *)
1590: IOMalloc(STDFB_BM256_TO_BM38_MAP_SIZE * sizeof(int));
1591: for (i = 0; i < count; i++)
1592: _bm256To38SampleTable[i] = parameterArray[i];
1593: return IO_R_SUCCESS;
1594:
1595: } else if (strcmp(parameterName, STDFB_BM38_TO_BM256_MAP) == 0) {
1596:
1597: if ((count != STDFB_BM38_TO_BM256_MAP_SIZE)
1598: && (count != STDFB_BM38_TO_256_WITH_LOGICAL_SIZE))
1599: return IO_R_INVALID_ARG;
1600: if (_bm38To256SampleTable == NULL) {
1601: _bm38To256SampleTable = (unsigned char *)
1602: IOMalloc(STDFB_BM38_TO_256_WITH_LOGICAL_SIZE * sizeof(int));
1603: }
1604: if( count != STDFB_BM38_TO_256_WITH_LOGICAL_SIZE)
1605: for (i = 0; i < 256; i++)
1606: _bm38To256SampleTable[ 1024 + i ] = i;
1607: for (i = 0; i < count; i++)
1608: *(((unsigned int *)_bm38To256SampleTable) + i) = parameterArray[i];
1609: return IO_R_SUCCESS;
1610:
1611: } else if (strcmp(parameterName, IO_SET_PENDING_DISPLAY_MODE) == 0) {
1612: if (count != 1)
1613: return IO_R_INVALID_ARG;
1614: if ([self setPendingDisplayMode:parameterArray[0]] == YES) {
1615: return IO_R_SUCCESS;
1616: } else {
1617: return IO_R_FAILED_TO_SET_MODE;
1618: }
1619: } else {
1620: return [super setIntValues:parameterArray forParameter:parameterName
1621: count:count];
1622: }
1623: }
1624:
1625:
1626: /* Get parameters for the display object.
1627: */
1628: - (IOReturn)getCharValues:(unsigned char *)parameterArray
1629: forParameter:(IOParameterName)parameterName
1630: count:(unsigned *)count
1631: {
1632: if (strcmp(parameterName, STDFB_FB_PIXEL_ENCODING) == 0) {
1633: if (*count != STDFB_FB_PIXEL_ENCODING_SIZE)
1634: return IO_R_INVALID_ARG;
1635:
1636: /* Copy the format string out of the display structure */
1637: strncpy(parameterArray, [self displayInfo]->pixelEncoding,
1638: STDFB_FB_PIXEL_ENCODING_SIZE);
1639: return IO_R_SUCCESS;
1640:
1641:
1642: } else if (strcmp(parameterName, "PostScript Driver") == 0) {
1643: wsStartup = YES;
1644: return IO_R_UNSUPPORTED;
1645:
1646: #if 0
1647: } else if (strcmp(parameterName, "PostScript Driver") == 0) {
1648:
1649: if (*count != sizeof(IOString))
1650: return IO_R_INVALID_ARG;
1651:
1652: strcpy(parameterArray, "NDRV_psdrvr");
1653: return IO_R_SUCCESS;
1654:
1655: } else if (strcmp(parameterName, "Server Name") == 0) {
1656:
1657: strcpy(parameterArray, "IONDRVFramebuffer");
1658: return IO_R_SUCCESS;
1659: #endif
1660:
1661: } else {
1662: return [super getCharValues:parameterArray
1663: forParameter:parameterName
1664: count:count];
1665: }
1666: }
1667:
1668: // Description: Set parameters for the display object. This can be used
1669: // to set the mapping tables used for conversion between
1670: // 4 BPS and 5 BPS data in 5-5-5 frame buffer support,
1671: // and bm256 <--> bm38 conversion tables as well.
1672: //
1673: - (IOReturn)setCharValues:(unsigned char *)parameterArray
1674: forParameter:(IOParameterName)parameterName
1675: count:(unsigned int)count
1676: {
1677: int i;
1678:
1679: if (strcmp(parameterName, STDFB_4BPS_TO_5BPS_MAP) == 0) {
1680: if (count != STDFB_4BPS_TO_5BPS_MAP_SIZE)
1681: return IO_R_INVALID_ARG;
1682: if (_bm34To35SampleTable == NULL)
1683: _bm34To35SampleTable = IOMalloc(STDFB_4BPS_TO_5BPS_MAP_SIZE);
1684: for (i = 0; i < count; i++)
1685: _bm34To35SampleTable[i] = parameterArray[i];
1686: return IO_R_SUCCESS;
1687:
1688: } else if (strcmp(parameterName, STDFB_5BPS_TO_4BPS_MAP) == 0) {
1689: if (count != STDFB_5BPS_TO_4BPS_MAP_SIZE)
1690: return IO_R_INVALID_ARG;
1691: if (_bm35To34SampleTable == NULL)
1692: _bm35To34SampleTable = IOMalloc(STDFB_5BPS_TO_4BPS_MAP_SIZE);
1693: for (i = 0; i < count; i++)
1694: _bm35To34SampleTable[i] = parameterArray[i];
1695: return IO_R_SUCCESS;
1696: } else if (strcmp(parameterName, IO_COMMIT_TO_PENDING_DISPLAY_MODE) == 0) {
1697: if ( [self _commitToPendingMode]) {
1698: return IO_R_SUCCESS;
1699: } else {
1700: return IO_R_UNSUPPORTED;
1701: }
1702: } else {
1703: return [super setCharValues:parameterArray
1704: forParameter:parameterName
1705: count:count];
1706: }
1707: }
1708:
1709:
1710: - (BOOL)setPendingDisplayMode:(int)configIndex
1711: {
1712: IOReturn err;
1713:
1714: err = [self getDisplayModeAndDepthForIndex:configIndex
1715: mode:&pendingDisplayModeID depth:&pendingDepthIndex mono:&pendingMono];
1716: if( err == noErr) {
1717: wsStartup = NO;
1718: _pendingDisplayMode = configIndex;
1719: [self setStartupMode:pendingDisplayModeID depth:pendingDepthIndex];
1720: }
1721: return( err == noErr);
1722: }
1723:
1724: - (int)pendingDisplayMode
1725: {
1726: return _pendingDisplayMode;
1727: }
1728:
1729: - setTransferTable:(const unsigned int *)table count:(int)count
1730: {
1731: return self;
1732: }
1733:
1734: - (UInt32) tempFlags
1735: {
1736: return( 0);
1737: }
1738:
1739: - (BOOL)_commitToPendingMode
1740: {
1741:
1742: if( _pendingDisplayMode < 0)
1743: return( NO);
1744:
1745: [kmId unregisterDisplay:self]; // tell kmDevice this device is unavail
1746: cursorBitsPerPixel = (-1);
1747: currentMono = pendingMono;
1748: [self setDisplayMode:pendingDisplayModeID depth:pendingDepthIndex page:0];
1749: _pendingDisplayMode = -1; /* mode switch is complete */
1750: [self setupForCurrentConfig];
1751:
1752: return( YES);
1753: }
1754:
1755: + initialize
1756: {
1757: gSmartDisplayClass = objc_lookUpClass("IOSmartDisplay");
1758: return( self);
1759: }
1760:
1761: //////////////////////////////////////////////////////////////////////////////////////////////////////
1762: // IOCallDeviceMethods:
1763:
1764: // these should be somewhere else, IODevice or something:
1765:
1766: - (IOReturn) IOGetApertures:(IOApertureInfo *)outputParams size:(unsigned *) outputCount
1767: {
1768: IOReturn err = noErr;
1769: UInt32 items;
1770:
1771: items = (*outputCount) / sizeof( IOApertureInfo);
1772: err = [[self deviceDescription]
1773: getApertures:outputParams items:&items];
1774: *outputCount = items * sizeof( IOApertureInfo);
1775:
1776: return( err);
1777: }
1778:
1779:
1780: - (IOReturn) IOGetDeviceName:(char *)outputParams size:(unsigned *) outputCount
1781: {
1782: IOReturn err = noErr;
1783: char * name;
1784: UInt32 len, plen;
1785:
1786: name = [[self deviceDescription] nodeName];
1787: plen = strlen( name);
1788: len = *outputCount - 1;
1789: *outputCount = plen + 1;
1790: if( plen < len)
1791: len = plen;
1792: strncpy( outputParams, name, len);
1793: outputParams[ len ] = 0;
1794:
1795: return( err);
1796: }
1797:
1798: // really IOFramebuffer:
1799:
1800: - (IOReturn) IOFBSetUserRange:(IORange *)inputParams size:(unsigned) inputCount
1801: {
1802: IOReturn err = noErr;
1803: UInt32 items;
1804:
1805: items = inputCount / sizeof( IORange);
1806: err = [self addUserRanges:(IORange *)inputParams num:items];
1807: if( err == noErr)
1808: err = [self setUserRanges];
1809:
1810: return( err);
1811:
1812: }
1813:
1814: - property_IODeviceClass:(char *)classes length:(unsigned int *)maxLen
1815: {
1816: strcpy( classes, IOClassFramebuffer);
1817: return( self);
1818: }
1819:
1820: //////////////////////////////////////////////////////////////////////////////////////////////////////
1821:
1822: - (IOReturn)
1823: getDisplayModeByIndex:(IOFBIndex)modeIndex displayMode:(IOFBDisplayModeID *)displayModeID {}
1824:
1825: - (IOReturn)
1826: getDisplayModeInformation:(IOFBDisplayModeID)modeID info:(IOFBDisplayModeInformation *)info {}
1827:
1828: - (IOReturn)
1829: getPixelInformationForDisplayMode:(IOFBDisplayModeID)mode andDepthIndex:(IOFBIndex)depthIndex
1830: pixelInfo:(IOFBPixelInformation *)info {}
1831:
1832: - (IOReturn)
1833: setDisplayMode:(IOFBDisplayModeID)modeID depth:(IOFBIndex)depthIndex page:(IOFBIndex)pageIndex {}
1834: - (IOReturn)
1835: setStartupMode:(IOFBDisplayModeID)modeID depth:(IOFBIndex)depthIndex {}
1836: - (IOReturn)
1837: getStartupMode:(IOFBDisplayModeID *)modeID depth:(IOFBIndex *)depthIndex {}
1838:
1839: - (IOReturn)
1840: getConfiguration:(IOFBConfiguration *)config {}
1841:
1842: - (IOReturn)
1843: getAttributeForMode:(IOFBDisplayModeID) modeID andDepth:(IOFBIndex)depthIndex
1844: attribute:(IOFBSelect)attr value:(UInt32 *)value {}
1845:
1846: - (IOReturn)
1847: getApertureInformationByIndex:(IOFBIndex)apertureIndex
1848: apertureInfo:(IOFBApertureInformation *)apertureInfo
1849: {
1850: return( IO_R_UNSUPPORTED);
1851: }
1852:
1853: - (IOReturn)
1854: setCLUT:(IOFBColorEntry *) colors index:(UInt32)index numEntries:(UInt32)numEntries
1855: brightness:(IOFixed)brightness options:(IOOptionBits)options {}
1856:
1857: //// Gammas
1858:
1859: - (IOReturn)
1860: setGammaTable:(UInt32) channelCount dataCount:(UInt32)dataCount dataWidth:(UInt32)dataWidth
1861: data:(void *)data {}
1862:
1863:
1864: + (IOReturn)
1865: convertCursorImage:(void *)cursorImage hwDescription:(HardwareCursorDescriptorRec *)hwDescrip
1866: cursorResult:(HardwareCursorInfoRec *)cursorResult {}
1867:
1868:
1869: - (IOReturn)
1870: setCursorImage:(void *)cursorImage {}
1871: - (IOReturn)
1872: setCursorState:(SInt32)x y:(SInt32)y visible:(Boolean)visible {}
1873:
1874: - (IOReturn)
1875: registerForInterruptType:(IOFBSelect)interruptType proc:(IOFBInterruptProc)proc refcon:(UInt32)refcon {}
1876:
1877: - (IOReturn)
1878: setInterruptState:(IOFBSelect)interruptType state:(UInt32)state {}
1879:
1880: - (IOReturn)
1881: setAttribute:(IOFBSelect)attribute value:(UInt32)value {}
1882:
1883: - (IOReturn)
1884: getAttribute:(IOFBSelect)attribute value:(UInt32 *)value {}
1885:
1886: - (IOReturn)
1887: privateCall:(IOFBSelect)callClass select:(IOFBSelect)select
1888: paramSize:(UInt32)paramSize params:(void *)params
1889: resultSize:(UInt32 *)resultSize results:(void *)results {}
1890:
1891: - (IOReturn)
1892: getConnections:(IOFBIndex)connectIndex
1893: connectInfo:(IOFBConnectionInfo *)info {}
1894:
1895: - (IOReturn)
1896: setConnectionAttribute:(IOFBIndex)connectIndex attribute:(IOFBSelect)attribute value:(UInt32)value {}
1897:
1898: - (IOReturn)
1899: getConnectionAttribute:(IOFBIndex)connectIndex attribute:(IOFBSelect)attribute value:(UInt32 *)value {}
1900:
1901:
1902: @end
1903:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.