![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOSVGADisplay.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 / Kernel|
Return to IOSVGADisplay.m CVS log | Up to [Apple Darwin 0.x] / driverkit / libDriver / Kernel |
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) 1993 NeXT Computer, Inc. All rights reserved. ! 25: * ! 26: * IOSVGADisplay.m - Implements common methods for SVGA display driver class. ! 27: * ! 28: * ! 29: * HISTORY ! 30: * 07 July 93 Scott Forstall ! 31: * Created from earlier work by Joe Pasqua and Gary Crum. ! 32: */ ! 33: ! 34: #define KERNEL_PRIVATE 1 ! 35: #define DRIVER_PRIVATE 1 ! 36: ! 37: /* Notes: ! 38: * This class implements the evScreen protocol for all IOSVGADisplays. Well, ! 39: * almost. The setBrightness method doesn't do anything. Subclasses must ! 40: * override this and implement it as appropriate for the device. ! 41: * ! 42: * To find things that need to be fixed, search for FIX, to find questions ! 43: * to be resolved, search for QUESTION, to find stuff that still needs to be ! 44: * done, search for TO DO. ! 45: */ ! 46: ! 47: #import <string.h> ! 48: #import <stdlib.h> ! 49: #import <bsd/dev/i386/VGAConsole.h> ! 50: #import <stdio.h> ! 51: #import <driverkit/EventDriver.h> ! 52: #import <bsd/dev/evio.h> ! 53: #import <bsd/dev/i386/kmDevice.h> ! 54: #import <driverkit/KernBus.h> ! 55: #import <driverkit/KernBusMemory.h> ! 56: #import <driverkit/IODisplayPrivate.h> ! 57: #import <driverkit/IOSVGADisplay.h> ! 58: #import <driverkit/IOVGAShared.h> ! 59: #import <driverkit/i386/directDevice.h> ! 60: #import <driverkit/i386/driverTypes.h> ! 61: ! 62: ! 63: // ! 64: // BEGIN: Defines used in this file ! 65: // ! 66: ! 67: #define CURSOR_WIDTH_IN_PIXELS 16 ! 68: #define PPXMASK ((unsigned int)0x0000000f) ! 69: ! 70: #if (SWAPBITS == DEVICE_CONSISTENT) ! 71: #define LSHIFT >> ! 72: #define RSHIFT << ! 73: #define LSHIFTEQ >>= ! 74: #define RSHIFTEQ <<= ! 75: #else (SWAPBITS == DEVICE_CONSISTENT) ! 76: #define LSHIFT << ! 77: #define RSHIFT >> ! 78: #define LSHIFTEQ <<= ! 79: #define RSHIFTEQ >>= ! 80: #endif (SWAPBITS == DEVICE_CONSISTENT) ! 81: ! 82: #define CLEAR_SEMAPHORE(shmem) \ ! 83: ev_unlock(&shmem->cursorSema) ! 84: #define SET_SEMAPHORE(shmem) \ ! 85: if (!ev_try_lock(&shmem->cursorSema)) return self ! 86: #define RECTS_INTERSECT(one, two) \ ! 87: (((one.minx < two.maxx) && (two.minx < one.maxx)) && \ ! 88: ((one.miny < two.maxy) && (two.miny < one.maxy))) ! 89: ! 90: // ! 91: // END: Defines used in this file ! 92: // ! 93: ! 94: ! 95: @implementation IOSVGADisplay ! 96: ! 97: // ! 98: // BEGIN: Implementation of private routines for SVGA ! 99: // ! 100: ! 101: ! 102: - (VGAShmem_t *)_shmem ! 103: // Description: Return IOSVGADisplay's shared memory which is ! 104: // stored in a private instance variable. ! 105: { ! 106: return (VGAShmem_t *)_priv; ! 107: } ! 108: ! 109: ! 110: - (IOReturn)_registerWithED ! 111: // Description: Register this display device with the event driver. ! 112: // Set up and initialize the shared memory. ! 113: { ! 114: int shmem_size; ! 115: Bounds bounds; ! 116: int token; ! 117: VGAShmem_t *shmem; ! 118: ! 119: token = [[EventDriver instance] registerScreen:self ! 120: bounds:&bounds ! 121: shmem:&(self->_priv) ! 122: size:&shmem_size]; ! 123: shmem = [self _shmem]; ! 124: ! 125: if ( token == -1 ) { ! 126: return IO_R_INVALID_ARG; ! 127: } ! 128: ! 129: // We allow the shmem_size to be less than sizeof(VGAShmem_t) ! 130: // so that we need not consume the extra space that some of the ! 131: // larger cursor variants require if we are really a lower bitdepth. ! 132: if ( shmem_size > sizeof(VGAShmem_t) ) { ! 133: IOLog("%s: shmem_size > sizeof (VGAShmem_t)(%d<>%d)\n", ! 134: [self name], shmem_size, sizeof (VGAShmem_t)); ! 135: [[EventDriver instance] unregisterScreen:token]; ! 136: return IO_R_INVALID_ARG; ! 137: } ! 138: ! 139: // Init shared memory area ! 140: bzero( (char *)shmem, shmem_size ); ! 141: shmem->cursorShow = 1; ! 142: shmem->screenBounds = bounds; ! 143: [self setToken:token]; ! 144: ! 145: return IO_R_SUCCESS; ! 146: } ! 147: ! 148: ! 149: - (void)_readBpp4planar: (unsigned short *)fb toBpp2packed32: (unsigned int *)dst ! 150: // Description: reads in a 4-planar representation, converts it into a ! 151: // packed-32 representation, and writes the result into ! 152: // dst. ! 153: { ! 154: unsigned int v, i; ! 155: ! 156: [self setReadPlane: 1]; ! 157: i = 0xffff ^ *fb; ! 158: v = (i & 0x8000) << 2 | (i & 0x4000) << 5 | (i & 0x2000) << 8 ! 159: | (i & 0x1000) << 11 | (i & 0x0800) << 14 | (i & 0x0400) << 17 ! 160: | (i & 0x0200) << 20 | (i & 0x0100) << 23 | (i & 0x0080) >> 6 ! 161: | (i & 0x0040) >> 3 | (i & 0x0020) | (i & 0x0010) << 3 ! 162: | (i & 0x0008) << 6 | (i & 0x0004) << 9 | (i & 0x0002) << 12 ! 163: | (i & 0x0001) << 15; ! 164: ! 165: [self setReadPlane: 0]; ! 166: i = 0xffff ^ *fb; ! 167: v |= (i & 0x8000) << 1 | (i & 0x4000) << 4 | (i & 0x2000) << 7 ! 168: | (i & 0x1000) << 10 | (i & 0x0800) << 13 | (i & 0x0400) << 16 ! 169: | (i & 0x0200) << 19 | (i & 0x0100) << 22 | (i & 0x0080) >> 7 ! 170: | (i & 0x0040) >> 4 | (i & 0x0020) >> 1 | (i & 0x0010) << 2 ! 171: | (i & 0x0008) << 5 | (i & 0x0004) << 8 | (i & 0x0002) << 11 ! 172: | (i & 0x0001) << 14; ! 173: ! 174: *dst = v; ! 175: } ! 176: ! 177: - (void)_writeBpp2packed32: (unsigned int *)dst toBpp4planar: (unsigned short *)fb ! 178: // Description: reads in a packed-32 representation, converts it into a ! 179: // 4-planar representation, and writes the result into ! 180: // fb. ! 181: { ! 182: unsigned int i, dstvalue; ! 183: unsigned short fbvalue; ! 184: unsigned char fblo, fbhi; ! 185: ! 186: [self setWritePlane: 1]; ! 187: dstvalue = *dst; ! 188: i = dstvalue & 0xAAAA; ! 189: fblo = 0xff ^ (char) (((i & 0x8000) >> 15) | ((i & 0x2000) >> 12) ! 190: | ((i & 0x0800) >> 9) | ((i & 0x0200) >> 6) ! 191: | ((i & 0x0080) >> 3) | (i & 0x0020) ! 192: | ((i & 0x0008) << 3) | ((i & 0x0002) << 6)); ! 193: i = (dstvalue >> 16) & 0xAAAA; ! 194: fbhi = 0xff ^ (char) (((i & 0x8000) >> 15) | ((i & 0x2000) >> 12) ! 195: | ((i & 0x0800) >> 9) | ((i & 0x0200) >> 6) ! 196: | ((i & 0x0080) >> 3) | (i & 0x0020) ! 197: | ((i & 0x0008) << 3) | ((i & 0x0002) << 6)); ! 198: fbvalue = (((unsigned short)fbhi) << 8) | fblo; ! 199: *fb = fbvalue; ! 200: ! 201: [self setWritePlane: 0]; ! 202: dstvalue = *dst; ! 203: i = dstvalue & 0x5555; ! 204: fblo = 0xff ^ (char) (((i & 0x4000) >> 14) | ((i & 0x1000) >> 11) ! 205: | ((i & 0x0400) >> 8) | ((i & 0x0100) >> 5) ! 206: | ((i & 0x0040) >> 2) | ((i & 0x0010) << 1) ! 207: | ((i & 0x0004) << 4) | ((i & 0x0001) << 7)); ! 208: i = (dstvalue >> 16) & 0x5555; ! 209: fbhi = 0xff ^ (char) (((i & 0x4000) >> 14) | ((i & 0x1000) >> 11) ! 210: | ((i & 0x0400) >> 8) | ((i & 0x0100) >> 5) ! 211: | ((i & 0x0040) >> 2) | ((i & 0x0010) << 1) ! 212: | ((i & 0x0004) << 4) | ((i & 0x0001) << 7)); ! 213: fbvalue = (((unsigned short)fbhi) << 8) | fblo; ! 214: *fb = fbvalue; ! 215: } ! 216: ! 217: ! 218: - (void)_VGADisplayCursor: (IODisplayInfo *)dpy shmem: (VGAShmem_t *)shmem ! 219: // Description: Displays the cursor on the framebuffer by first saving ! 220: // what's underneath the cursor, then drawing the cursor there. ! 221: // NOTE:The topleft of the cursorRect passed in is not ! 222: // necessarily the cursor location.The cursorRect is adjusted to ! 223: // compensate for the cursor hotspot.If the frame buffer is ! 224: // cacheable, flush at the end of the drawing operation. A ! 225: // saveRect is stored which defines the actual area of the screen ! 226: // that is saved.This is used by RemoveCursor in restoring the ! 227: // screen data later. ! 228: { ! 229: Bounds screenBounds = shmem->screenBounds; ! 230: Bounds saveRect; /* cursor save rectangle (local) */ ! 231: unsigned int *cursPtr; /* cursor data pointer */ ! 232: unsigned int *vramPtr; /* screen data pointer */ ! 233: unsigned int *savePtr; /* saved screen data pointer */ ! 234: unsigned int *maskPtr; /* cursor mask pointer */ ! 235: int i, doLeft, doRight, skew, rSkew; ! 236: static unsigned int vramBuf[2]; ! 237: unsigned short *this_segment, *fb; ! 238: unsigned int fb_x_offset_shorts; ! 239: unsigned int fb_shorts_per_line; ! 240: unsigned int fb_lines_per_segment; ! 241: unsigned int fb_segment; ! 242: unsigned int fb_next_segment_y; ! 243: int y; ! 244: int miny, maxy; /* absolute min and max y--not relative address */ ! 245: /* e.g. 0 <= miny <= SCREEN_HEIGHT */ ! 246: ! 247: [self savePlaneAndSegmentSettings]; ! 248: ! 249: saveRect = shmem->cursorRect; ! 250: vramPtr = (unsigned int *)vramBuf; ! 251: ! 252: // ! 253: // Clip saveRect vertical within screen bounds ! 254: // ! 255: if (saveRect.miny < screenBounds.miny) { ! 256: saveRect.miny = screenBounds.miny; ! 257: } ! 258: if (saveRect.maxy > screenBounds.maxy) { ! 259: saveRect.maxy = screenBounds.maxy; ! 260: } ! 261: i = shmem->cursorRect.minx - screenBounds.minx; ! 262: saveRect.minx = i - (i & PPXMASK) + screenBounds.minx; ! 263: saveRect.maxx = saveRect.minx + CURSORWIDTH*2; ! 264: shmem->saveRect = saveRect; ! 265: ! 266: // ! 267: // skew is in bits ! 268: // ! 269: skew = (shmem->cursorRect.minx & PPXMASK)<<1; ! 270: rSkew = 32-skew; ! 271: ! 272: // ! 273: // Set up pointers for saving and drawing ! 274: // ! 275: cursPtr = shmem->cursor.bw.image[shmem->frame]; ! 276: maskPtr = shmem->cursor.bw.mask[shmem->frame]; ! 277: savePtr = shmem->cursor.bw.save; ! 278: i = saveRect.miny - shmem->cursorRect.miny; ! 279: cursPtr += i; ! 280: maskPtr += i; ! 281: ! 282: // ! 283: // Since we are drawing an int at a time, and it may ! 284: // cross an int boundary, we draw it in two pieces (left ! 285: // and right) which are offset by skew. ! 286: // ! 287: doLeft = (saveRect.minx >= screenBounds.minx); ! 288: doRight = (saveRect.maxx <= screenBounds.maxx); ! 289: ! 290: // ! 291: // VGA related assignments ! 292: // ! 293: // QUESTION--isn't this a little fishy?? Should this be the address we mapped? ! 294: this_segment = (unsigned short *)(0xa0000); ! 295: fb_x_offset_shorts = (saveRect.minx - screenBounds.minx) >> 4; ! 296: fb_shorts_per_line = dpy->width >> 4; ! 297: fb_lines_per_segment = 0x10000 / (dpy->width >> 3); ! 298: ! 299: miny = saveRect.miny - screenBounds.miny; ! 300: maxy = saveRect.maxy - screenBounds.miny; ! 301: ! 302: fb = this_segment + ! 303: ((miny % fb_lines_per_segment) * fb_shorts_per_line) + ! 304: fb_x_offset_shorts; ! 305: fb_segment = miny / fb_lines_per_segment; ! 306: fb_next_segment_y = (fb_lines_per_segment * (fb_segment + 1)); ! 307: ! 308: [self setWriteSegment: fb_segment]; ! 309: [self setReadSegment: fb_segment]; ! 310: ! 311: for ( y = miny; ! 312: y < maxy; ! 313: y++) { ! 314: register unsigned int workreg; ! 315: ! 316: // ! 317: // Change VGA segment if necessary. ! 318: // ! 319: if (y == fb_next_segment_y) { ! 320: fb = this_segment + ! 321: ((y % fb_lines_per_segment) * fb_shorts_per_line) + ! 322: fb_x_offset_shorts; ! 323: fb_segment++; ! 324: fb_next_segment_y += fb_lines_per_segment; ! 325: ! 326: [self setWriteSegment: fb_segment]; ! 327: [self setReadSegment: fb_segment]; ! 328: } ! 329: ! 330: if (doLeft) { ! 331: [self _readBpp4planar:fb toBpp2packed32:vramPtr]; ! 332: *savePtr++ = workreg = *vramPtr; ! 333: *vramPtr = (workreg&(~((*maskPtr) RSHIFT skew))) | ! 334: ((*cursPtr) RSHIFT skew); ! 335: [self _writeBpp2packed32:vramPtr toBpp4planar:fb]; ! 336: } ! 337: if (doRight) { ! 338: if (!skew) { ! 339: savePtr++; ! 340: } else { ! 341: [self _readBpp4planar:(fb+1) toBpp2packed32:(vramPtr+1)]; ! 342: *savePtr++ = workreg = *(vramPtr+1); ! 343: *(vramPtr+1)= (workreg&(~((*maskPtr) LSHIFT rSkew))) | ! 344: ((*cursPtr) LSHIFT rSkew); ! 345: [self _writeBpp2packed32:(vramPtr+1) toBpp4planar:(fb+1)]; ! 346: } ! 347: } ! 348: ! 349: // ! 350: // Advance fb (pointer into VGA framebuffer) one line. ! 351: // ! 352: fb += fb_shorts_per_line; ! 353: ! 354: cursPtr++; ! 355: maskPtr++; ! 356: } ! 357: ! 358: [self restorePlaneAndSegmentSettings]; ! 359: } ! 360: ! 361: ! 362: - (void)_VGARemoveCursor: (IODisplayInfo *)dpy shmem: (VGAShmem_t *)shmem ! 363: // Description: RemoveCursor erases the cursor by replacing the background ! 364: // image that was saved by the previous call to DisplayCursor. ! 365: // If the frame buffer is cacheable, flush at the end of the ! 366: // drawing operation. ! 367: { ! 368: int doLeft, doRight; ! 369: unsigned int lmask = 0, rmask = 0; ! 370: unsigned int *vramPtr; ! 371: unsigned int *savePtr; ! 372: Bounds screenBounds = shmem->screenBounds; ! 373: Bounds saveRect = shmem->saveRect; ! 374: #if __BIG_ENDIAN__ ! 375: static const unsigned int mask_array[16] = { ! 376: 0xFFFFFFFF,0x3FFFFFFF,0x0FFFFFFF,0x03FFFFFF, ! 377: 0x00FFFFFF,0x003FFFFF,0x000FFFFF,0x0003FFFF, ! 378: 0x0000FFFF,0x00003FFF,0x00000FFF,0x000003FF, ! 379: 0x000000FF,0x0000003f,0x0000000F,0x00000003 ! 380: }; ! 381: #else ! 382: static unsigned int mask_array[17] = { ! 383: 0xFFFFFFFF,0xFFFFFFFC,0xFFFFFFF0,0xFFFFFFC0, ! 384: 0xFFFFFF00,0xFFFFFC00,0xFFFFF000,0xFFFFC000, ! 385: 0xFFFF0000,0xFFFC0000,0xFFF00000,0xFFC00000, ! 386: 0xFF000000,0xFC000000,0xF0000000,0xC0000000,0x00000000}; ! 387: #endif ! 388: static unsigned int vramBuf[2]; ! 389: unsigned short *this_segment, *fb; ! 390: unsigned int fb_x_offset_shorts; ! 391: unsigned int fb_shorts_per_line; ! 392: unsigned int fb_lines_per_segment; ! 393: unsigned int fb_segment; ! 394: unsigned int fb_next_segment_y; ! 395: int y; ! 396: int skew; ! 397: int miny, maxy; /* absolute min and max y--not relative address */ ! 398: /* e.g. 0 <= miny <= SCREEN_HEIGHT */ ! 399: ! 400: [self savePlaneAndSegmentSettings]; ! 401: ! 402: vramPtr = (unsigned int *)vramBuf; ! 403: ! 404: // ! 405: // VGA related assignments ! 406: // ! 407: // QUESTION--isn't this a little fishy?? Should this be the address we mapped? ! 408: this_segment = (unsigned short *)(0xa0000); ! 409: fb_x_offset_shorts = (saveRect.minx - screenBounds.minx) >> 4; ! 410: fb_shorts_per_line = dpy->width >> 4; ! 411: ! 412: miny = saveRect.miny - screenBounds.miny; ! 413: maxy = saveRect.maxy - screenBounds.miny; ! 414: ! 415: // ! 416: // VGA bank size is 64K ! 417: // ! 418: fb_lines_per_segment = 0x10000 / (dpy->width >> 3); ! 419: fb = this_segment + ! 420: ((miny % fb_lines_per_segment) * fb_shorts_per_line) + ! 421: fb_x_offset_shorts; ! 422: fb_segment = miny / fb_lines_per_segment; ! 423: fb_next_segment_y = (fb_lines_per_segment * (fb_segment + 1)); ! 424: ! 425: [self setWriteSegment: fb_segment]; ! 426: [self setReadSegment: fb_segment]; ! 427: ! 428: // ! 429: // skew is in bits ! 430: // ! 431: skew = (shmem->cursorRect.minx & PPXMASK)<<1; ! 432: ! 433: savePtr = shmem->cursor.bw.save; ! 434: if (doLeft = (saveRect.minx >= screenBounds.minx)) { ! 435: lmask = mask_array[shmem->oldCursorRect.minx - saveRect.minx]; ! 436: } ! 437: if (doRight = (saveRect.maxx <= screenBounds.maxx)) { ! 438: rmask = ~mask_array[16-(saveRect.maxx - shmem->oldCursorRect.maxx)]; ! 439: } ! 440: ! 441: for ( y = miny; ! 442: y < maxy; ! 443: y++) { ! 444: ! 445: // ! 446: // Change VGA segment if necessary. ! 447: // ! 448: if (y == fb_next_segment_y) { ! 449: fb = this_segment + ! 450: ((y % fb_lines_per_segment) * fb_shorts_per_line) + ! 451: fb_x_offset_shorts; ! 452: fb_segment++; ! 453: fb_next_segment_y += fb_lines_per_segment; ! 454: ! 455: [self setWriteSegment: fb_segment]; ! 456: [self setReadSegment: fb_segment]; ! 457: } ! 458: ! 459: if (doLeft) { ! 460: [self _readBpp4planar:fb toBpp2packed32:vramPtr]; ! 461: *vramPtr = (*vramPtr&(~lmask))|(*savePtr++&lmask); ! 462: [self _writeBpp2packed32:vramPtr toBpp4planar:fb]; ! 463: } ! 464: ! 465: if (doRight) { ! 466: if (!skew) { ! 467: savePtr++; ! 468: } else { ! 469: [self _readBpp4planar:(fb+1) toBpp2packed32:(vramPtr+1)]; ! 470: *(vramPtr+1)=(*(vramPtr+1)&(~rmask))|(*savePtr++&rmask); ! 471: [self _writeBpp2packed32:(vramPtr+1) toBpp4planar:(fb+1)]; ! 472: } ! 473: } ! 474: ! 475: // ! 476: // Advance fb (pointer into VGA framebuffer) one line. ! 477: // ! 478: fb += fb_shorts_per_line; ! 479: ! 480: } ! 481: ! 482: [self restorePlaneAndSegmentSettings]; ! 483: } ! 484: ! 485: - (void)_displayCursor: (IODisplayInfo *)d shmem: (VGAShmem_t *)shmem ! 486: // Description: Private routine to display the cursor. Sets up the ! 487: // cursor rect. ! 488: { ! 489: Point hs; ! 490: hs = shmem->hotSpot[shmem->frame]; ! 491: shmem->cursorRect.maxx = ! 492: (shmem->cursorRect.minx = (shmem->cursorLoc).x - hs.x) + 16; ! 493: shmem->cursorRect.maxy = ! 494: (shmem->cursorRect.miny = (shmem->cursorLoc).y - hs.y) + 16; ! 495: [self _VGADisplayCursor:d shmem:shmem]; ! 496: shmem->oldCursorRect = shmem->cursorRect; ! 497: } ! 498: ! 499: - (void)_sysHideCursor: (IODisplayInfo *)d shmem: (VGAShmem_t *)shmem ! 500: // Description: Private routing to hide the cursor. ! 501: { ! 502: if (!shmem->cursorShow++) { ! 503: [self _VGARemoveCursor:d shmem:shmem]; ! 504: } ! 505: } ! 506: ! 507: - (void)_sysShowCursor: (IODisplayInfo *)d shmem: (VGAShmem_t *)shmem ! 508: // Description: Private routine to show the cursor ! 509: { ! 510: if (shmem->cursorShow) ! 511: if (!--shmem->cursorShow) ! 512: [self _displayCursor:d shmem:shmem]; ! 513: } ! 514: ! 515: - (void)_checkShield: (IODisplayInfo *)d shmem: (VGAShmem_t *)shmem ! 516: // Description: QUESTION ! 517: { ! 518: Point hs; ! 519: int intersect; ! 520: Bounds tempRect; ! 521: ! 522: // ! 523: // Calculate temp cursorRect ! 524: // ! 525: hs = shmem->hotSpot[shmem->frame]; ! 526: tempRect.maxx = (tempRect.minx = (shmem->cursorLoc).x - hs.x) + 16; ! 527: tempRect.maxy = (tempRect.miny = (shmem->cursorLoc).y - hs.y) + 16; ! 528: ! 529: intersect = RECTS_INTERSECT(tempRect, shmem->shieldRect); ! 530: if (intersect != shmem->shielded) { ! 531: (shmem->shielded = intersect) ? [self _sysHideCursor:d shmem:shmem] : ! 532: [self _sysShowCursor:d shmem:shmem]; ! 533: } ! 534: } ! 535: ! 536: ! 537: static const char * ! 538: find_parameter(const char *parameter, const char *string) ! 539: // Description: Find parameter in string and return what follows ! 540: // it. E.g. for string = "Width: 10" and ! 541: // parameter = "Width:" return "10". ! 542: { ! 543: int c; ! 544: size_t length; ! 545: ! 546: length = strlen(parameter); ! 547: while (*string != 0) { ! 548: if (strncmp(string, parameter, length) == 0) { ! 549: string += length; ! 550: while ((c = *string) != '\0' && (c == ' ' || c == '\t')) ! 551: string++; ! 552: return (c != 0) ? string : 0; ! 553: } ! 554: string++; ! 555: } ! 556: return 0; ! 557: } ! 558: ! 559: ! 560: - (void)_generateName: (char *)name andUnit:(IOObjectNumber *)unit ! 561: // Description: Used to generate a name for a new Display object. ! 562: // "name" is a char array of size IO_STRING_LENGTH ! 563: { ! 564: static int nextSVGAUnit = 0; ! 565: ! 566: *unit = nextSVGAUnit++; ! 567: sprintf(name, "SVGADisplay%d", *unit); ! 568: } ! 569: ! 570: ! 571: // ! 572: // END: Implementation of private routines for SVGA ! 573: // ! 574: ! 575: ! 576: ! 577: // ! 578: // BEGIN: Implementation of the evScreen protocol ! 579: // ! 580: ! 581: ! 582: - hideCursor: (int)token ! 583: { ! 584: SET_SEMAPHORE([self _shmem]); ! 585: [self _sysHideCursor:[self displayInfo] shmem:[self _shmem]]; ! 586: CLEAR_SEMAPHORE([self _shmem]); ! 587: return self; ! 588: } ! 589: ! 590: - moveCursor:(Point*)cursorLoc frame:(int)frame token:(int)t ! 591: { ! 592: VGAShmem_t *shmem; ! 593: ! 594: shmem = [self _shmem]; ! 595: SET_SEMAPHORE(shmem); ! 596: shmem->frame = frame; ! 597: shmem->cursorLoc = *cursorLoc; ! 598: if (!shmem->cursorShow++) { ! 599: [self _VGARemoveCursor:[self displayInfo] shmem:shmem]; ! 600: } ! 601: if (shmem->cursorObscured) { ! 602: shmem->cursorObscured = 0; ! 603: if (shmem->cursorShow) ! 604: --shmem->cursorShow; ! 605: } ! 606: if (shmem->shieldFlag) { ! 607: [self _checkShield:[self displayInfo] shmem:shmem]; ! 608: } ! 609: if (shmem->cursorShow) { ! 610: if (!--shmem->cursorShow) { ! 611: [self _displayCursor:[self displayInfo] shmem:shmem]; ! 612: } ! 613: } ! 614: CLEAR_SEMAPHORE(shmem); ! 615: return self; ! 616: } ! 617: ! 618: - showCursor:(Point*)cursorLoc frame:(int)frame token:(int)t ! 619: { ! 620: VGAShmem_t *shmem; ! 621: ! 622: shmem = [self _shmem]; ! 623: SET_SEMAPHORE(shmem); ! 624: shmem->frame = frame; ! 625: shmem->cursorLoc = *cursorLoc; ! 626: if (shmem->shieldFlag) { ! 627: [self _checkShield:[self displayInfo] shmem:shmem]; ! 628: } ! 629: [self _sysShowCursor:[self displayInfo] shmem:shmem]; ! 630: CLEAR_SEMAPHORE(shmem); ! 631: return self; ! 632: } ! 633: ! 634: // ! 635: // END: Implementation of the evScreen protocol ! 636: // ! 637: ! 638: ! 639: // ! 640: // BEGIN: EXPORTED methods ! 641: // ! 642: ! 643: - (void)setReadSegment: (unsigned char)segmentNum ! 644: // Description: Select which 64K segment we intend to read from - ! 645: // this must be overridden by a subclasser. ! 646: { ! 647: } ! 648: ! 649: ! 650: - (void)setWriteSegment: (unsigned char)segmentNum ! 651: // Description: Select which 64K segment we intend to write from - ! 652: // this must be overridden by a subclasser. ! 653: { ! 654: } ! 655: ! 656: ! 657: - (void)setReadPlane: (unsigned char)planeNum ! 658: // Description: Select which of 4 bit planes to read from in planar ! 659: // modes - only one plane can be active at a time. ! 660: { ! 661: } ! 662: ! 663: ! 664: - (void)setWritePlane: (unsigned char)planeNum ! 665: // Description: Select one of 4 bit planes to write to in planar modes, ! 666: // although more than one plane can be active at a time, ! 667: // this routine only allows access to 1 plane at a time. ! 668: { ! 669: } ! 670: ! 671: ! 672: - (void)savePlaneAndSegmentSettings ! 673: // Description: Save plane and segment settings. These methods must ! 674: // be implemented by subclasses in a device specific way. ! 675: { ! 676: } ! 677: ! 678: ! 679: - (void)restorePlaneAndSegmentSettings ! 680: // Description: Restore plane and segment settings. These methods must ! 681: // be implemented by subclasses in a device specific way. ! 682: { ! 683: } ! 684: ! 685: ! 686: - (void)enterSVGAMode ! 687: // Description: Put the display into SVGA mode. This typically happens ! 688: // when the window server starts running. This method is ! 689: // implemented by subclasses in a device specific way. ! 690: { ! 691: } ! 692: ! 693: ! 694: - (void)revertToVGAMode ! 695: // Description: Get the device out of whatever advanced mode it was using ! 696: // and back into a state where it can be used as a standard ! 697: // VGA device. This method is implemented by subclasses in a ! 698: // device specific way. ! 699: { ! 700: } ! 701: ! 702: ! 703: task_t (task_self)(void); // from /NextDeveloper/Headers/mach/mach_traps.h ! 704: ! 705: - (vm_address_t)mapFrameBufferAtPhysicalAddress:(unsigned int)addr ! 706: length:(int)length; ! 707: // Description: Look up the physical memory location for this device instance ! 708: // and map it into VM for use by the device driver. If problems ! 709: // occur, the method returns (vm_address_t)0. If addr is not 0, ! 710: // then it is used as the physical memory address and ! 711: // length is used as the length. ! 712: { ! 713: vm_address_t vmLocation; ! 714: IOReturn result = IO_R_SUCCESS; ! 715: ! 716: if (addr != 0) // Override configuration XXX BOGUS!!! ! 717: { ! 718: // This is totally bogus. I cannot believe that it is ! 719: // public API. NB: This mapping cannot be freed using ! 720: // unmapMemoryRange:from: in IOEISADirectDevice. ! 721: if (_KernBusMemoryCreateMapping(addr, ! 722: length, ! 723: &vmLocation, ! 724: current_task_EXTERNAL(), ! 725: YES, ! 726: IO_WriteThrough) != KERN_SUCCESS) ! 727: result = IO_R_NO_MEMORY; ! 728: } ! 729: else ! 730: { ! 731: result = [self mapMemoryRange:0 //QUESTION--what is this??? ! 732: to:&vmLocation ! 733: findSpace:YES ! 734: cache:IO_WriteThrough]; ! 735: } ! 736: ! 737: if (result != IO_R_SUCCESS) ! 738: { ! 739: IOLog("IOSVGADisplay/mapFrameBuffer: Can't map memory (%s)\n", ! 740: [self stringFromReturn:result]); ! 741: return (vm_address_t)0; ! 742: } ! 743: ! 744: return vmLocation; ! 745: } ! 746: ! 747: ! 748: ! 749: - (int)selectMode:(const IODisplayInfo *)modeList ! 750: count:(int)count ! 751: valid:(const BOOL *)isValid ! 752: // Description: Choose a mode from the list `modeList' (containing `count' ! 753: // modes) based on the value of the `DisplayMode' key in the ! 754: // device's config table. If `isValid' is nonzero, each element ! 755: // specifies whether or not the corresponding mode is valid. ! 756: { ! 757: const char *displayMode; ! 758: IOConfigTable *configTable; ! 759: int k, width, height; ! 760: int screenWidth, screenHeight, memorySize, ramdacSpeed; ! 761: int scanRate; ! 762: unsigned int modeUnavailableFlag; ! 763: IOBitsPerPixel bitsPerPixel; ! 764: IOColorSpace colorSpace; ! 765: int refreshRate; ! 766: const char *s; ! 767: ! 768: /* Get the string describing the display mode. */ ! 769: ! 770: configTable = [[self deviceDescription] configTable]; ! 771: if (configTable == nil) ! 772: return -1; ! 773: displayMode = [configTable valueForStringKey:"Display Mode"]; ! 774: if (displayMode == 0) { ! 775: /* Historical: for 3.1 drivers only. */ ! 776: displayMode = [configTable valueForStringKey:"DisplayMode"]; ! 777: if (displayMode == 0) ! 778: return -1; ! 779: } ! 780: ! 781: /* Parse the string. It should be of the form ! 782: * Width:# Height:# ColorSpace:(BW:#|RGB:###/#) Refresh:# Hz ! 783: * where `Width' and `Height' specify the width and height of the ! 784: * framebuffer, `ColorSpace' specifies the color space for the ! 785: * framebuffer, and `Refresh' specifies the refresh rate in Hz. ! 786: * The color space parameter should be either BW followed by the ! 787: * bits/pixel, or RGB followed by the bits/component for each ! 788: * component followed by the bits/pixel. ! 789: * ! 790: * For example, here is the display mode specification for the ! 791: * RGB mode of the S3: ! 792: * Width: 800 Height: 600 ColorSpace: RGB:555/16 Refresh: 60 Hz ! 793: */ ! 794: ! 795: height = width = 0; ! 796: s = find_parameter("Width:", displayMode); ! 797: if (s != 0) { ! 798: width = strtol(s, 0, 10); ! 799: } ! 800: ! 801: s = find_parameter("Height:", displayMode); ! 802: if (s != 0) { ! 803: height = strtol(s, 0, 10); ! 804: } ! 805: ! 806: s = find_parameter("Refresh:", displayMode); ! 807: if (s == 0) ! 808: return -1; ! 809: refreshRate = strtol(s, 0, 10); ! 810: ! 811: s = find_parameter("ColorSpace:", displayMode); ! 812: if (s == 0) ! 813: return -1; ! 814: if (strncmp(s, "BW:2", 4) == 0) { ! 815: bitsPerPixel = IO_2BitsPerPixel; ! 816: colorSpace = IO_OneIsBlackColorSpace; ! 817: } else if (strncmp(s, "BW:8", 4) == 0) { ! 818: bitsPerPixel = IO_8BitsPerPixel; ! 819: colorSpace = IO_OneIsWhiteColorSpace; ! 820: } else if (strncmp(s, "RGB:256/8", 9) == 0) { ! 821: bitsPerPixel = IO_8BitsPerPixel; ! 822: colorSpace = IO_RGBColorSpace; ! 823: } else if (strncmp(s, "RGB:444/16", 10) == 0) { ! 824: bitsPerPixel = IO_12BitsPerPixel; ! 825: colorSpace = IO_RGBColorSpace; ! 826: } else if (strncmp(s, "RGB:555/16", 10) == 0) { ! 827: bitsPerPixel = IO_15BitsPerPixel; ! 828: colorSpace = IO_RGBColorSpace; ! 829: } else if (strncmp(s, "RGB:888/32", 10) == 0) { ! 830: bitsPerPixel = IO_24BitsPerPixel; ! 831: colorSpace = IO_RGBColorSpace; ! 832: } else { ! 833: return -1; ! 834: } ! 835: ! 836: ! 837: /* ! 838: * Now look for 4.0 style optional parameters. The display mode ! 839: * specification looks like "Resolution:1280x1024 Screen:1600x1200 ! 840: * Refresh:60Hz ColorSpace:RGB:444/16 Memory:4MB RAMDAC:175Hz Sync:1000"; ! 841: */ ! 842: ! 843: s = find_parameter("Resolution:", displayMode); ! 844: if (s != 0) { ! 845: char *end; ! 846: width = strtol(s, &end, 10); ! 847: height = strtol(end+1, 0, 10); ! 848: } ! 849: ! 850: if ((height == 0) || (width == 0)) ! 851: return -1; ! 852: ! 853: s = find_parameter("Screen:", displayMode); ! 854: if (s != 0) { ! 855: char *end; ! 856: screenWidth = strtol(s, &end, 10); ! 857: height = strtol(end+1, 0, 10); ! 858: } else { ! 859: screenWidth = width; ! 860: screenHeight = height; ! 861: } ! 862: ! 863: /* These parameters are not used by the superclass. */ ! 864: s = find_parameter("Memory:", displayMode); ! 865: if (s != 0) { ! 866: memorySize = strtol(s, 0, 10); ! 867: } ! 868: ! 869: s = find_parameter("RAMDAC:", displayMode); ! 870: if (s != 0) { ! 871: ramdacSpeed = strtol(s, 0, 10); ! 872: } ! 873: ! 874: s = find_parameter("Sync:", displayMode); ! 875: if (s != 0) { ! 876: scanRate = strtol(s, 0, 10); ! 877: } ! 878: ! 879: modeUnavailableFlag = 0; ! 880: s = find_parameter("Available:", displayMode); ! 881: if (s != 0) { ! 882: modeUnavailableFlag = strtol(s, 0, 10); ! 883: } ! 884: ! 885: ! 886: /* Now try to match these parameters with the list of modes. */ ! 887: for (k = 0; k < count; k++) { ! 888: if (isValid != 0 && !isValid[k]) ! 889: continue; ! 890: if (modeUnavailableFlag != 0) ! 891: continue; ! 892: if (modeList[k].width == width ! 893: && modeList[k].height == height ! 894: && modeList[k].colorSpace == colorSpace ! 895: && modeList[k].bitsPerPixel == bitsPerPixel ! 896: && modeList[k].refreshRate == refreshRate) { ! 897: switch (bitsPerPixel) { ! 898: case IO_2BitsPerPixel: s = "BW:2"; break; ! 899: case IO_8BitsPerPixel: ! 900: if (colorSpace == IO_RGBColorSpace) s = "RGB:256/8"; ! 901: else s = "BW:8"; ! 902: break; ! 903: case IO_12BitsPerPixel: s = "RGB:444/16"; break; ! 904: case IO_15BitsPerPixel: s = "RGB:555/16"; break; ! 905: case IO_24BitsPerPixel: s = "RGB:888/32"; break; ! 906: default: s = "Unknown color space"; break; ! 907: } ! 908: IOLog("Display: Mode selected: %d x %d @ %d Hz (%s)\n", ! 909: width, height, refreshRate, s); ! 910: return k; ! 911: } ! 912: } ! 913: IOLog("Display: Requested mode is not available.\n"); ! 914: return -1; ! 915: } ! 916: ! 917: ! 918: - (int)selectMode: (const IODisplayInfo *)modeList count:(int)count ! 919: // Description: Equivalent to the above with `isValid' set to zero. ! 920: { ! 921: return [self selectMode:modeList count:count valid:0]; ! 922: } ! 923: ! 924: ! 925: + (BOOL)probe:deviceDescription ! 926: // Description: Create an instance of subclass to be associated with ! 927: // specified deviceDescription. Returns whether or not ! 928: // successful. ! 929: { ! 930: IOSVGADisplay *inst; ! 931: ! 932: // Create an instance and initialize some basic instance variables. ! 933: inst = [[self alloc] initFromDeviceDescription:deviceDescription]; ! 934: if (inst == nil) { ! 935: return NO; ! 936: } ! 937: ! 938: [inst setDeviceKind:"frame buffer"]; ! 939: ! 940: [inst registerDevice]; ! 941: ! 942: return YES; ! 943: } ! 944: ! 945: ! 946: ! 947: ! 948: - initFromDeviceDescription:deviceDescription ! 949: // Description: Initialize per specified deviceDescription. Returns ! 950: // nil on error ! 951: { ! 952: char name[IO_STRING_LENGTH]; ! 953: IOObjectNumber unit; ! 954: ! 955: if ([super initFromDeviceDescription:deviceDescription] == nil) { ! 956: return [super free]; ! 957: } ! 958: ! 959: [self _generateName:name andUnit:&unit]; ! 960: [self setUnit:unit]; ! 961: [self setName:name]; ! 962: return self; ! 963: } ! 964: ! 965: ! 966: ! 967: - setBrightness:(int)level token:(int)t ! 968: // Description: Setting the brighness is a device-specific operation ! 969: // which must be implemented by a subclass. This just ! 970: // checks if a legal level was sent. ! 971: { ! 972: if ( level < EV_SCREEN_MIN_BRIGHTNESS ! 973: || level > EV_SCREEN_MAX_BRIGHTNESS ) ! 974: { ! 975: IOLog("%s: Invalid arg to setBrightness:%d\n", ! 976: [self name], level ); ! 977: } ! 978: return self; ! 979: } ! 980: ! 981: - (IOReturn)getIntValues:(unsigned *)parameterArray ! 982: forParameter:(IOParameterName)parameterName ! 983: count:(unsigned int *)count ! 984: // Description: Get and set parameters. These include support ! 985: // for getting the frame buffer parameters, registering it ! 986: // with the event system, returning the registration token. ! 987: { ! 988: unsigned int fb_dimensions[VGA_FB_DIMENSIONS_SIZE]; ! 989: IOReturn r; ! 990: int i; ! 991: unsigned *returnedCount = count; ! 992: unsigned maxCount = *count; ! 993: ! 994: if ( strcmp(parameterName, VGA_FB_MAP) == 0 ) ! 995: { ! 996: parameterArray[0] = 0; ! 997: [self enterSVGAMode]; ! 998: [kmId registerDisplay:self]; ! 999: *returnedCount = 1; ! 1000: return IO_R_SUCCESS; ! 1001: } ! 1002: else if ( strcmp(parameterName, VGA_FB_DIMENSIONS) == 0 ) ! 1003: { ! 1004: IODisplayInfo *display = [self displayInfo]; ! 1005: ! 1006: fb_dimensions[VGA_FB_WIDTH] = display->width; ! 1007: fb_dimensions[VGA_FB_HEIGHT] = display->height; ! 1008: fb_dimensions[VGA_FB_ROWBYTES] = display->rowBytes; ! 1009: ! 1010: *returnedCount = 0; ! 1011: for( i=0; i<VGA_FB_DIMENSIONS_SIZE; i++) { ! 1012: if (*returnedCount == maxCount) ! 1013: break; ! 1014: parameterArray[i] = fb_dimensions[i]; ! 1015: (*returnedCount)++; ! 1016: } ! 1017: return IO_R_SUCCESS; ! 1018: ! 1019: } ! 1020: else if ( strcmp(parameterName, VGA_FB_REGISTER) == 0 ) ! 1021: { ! 1022: r = [self _registerWithED]; ! 1023: *returnedCount = 0; ! 1024: if ( maxCount > 0 ) ! 1025: { ! 1026: *returnedCount = 1; ! 1027: parameterArray[0] = [self token]; ! 1028: } ! 1029: return r; ! 1030: } ! 1031: else ! 1032: { ! 1033: r = [super getIntValues:parameterArray ! 1034: forParameter:parameterName ! 1035: count:returnedCount]; ! 1036: return r; ! 1037: } ! 1038: } ! 1039: ! 1040: ! 1041: - (IOReturn)setIntValues:(unsigned *)parameterArray ! 1042: forParameter:(IOParameterName)parameterName ! 1043: count:(unsigned int)count ! 1044: // Description: Set parameters. This can be used to unregister the frame ! 1045: // buffer as well as set the transfer function. ! 1046: { ! 1047: if ( strcmp(parameterName, VGA_FB_UNMAP) == 0 ) { ! 1048: // [self _unmap]; ! 1049: [self revertToVGAMode]; ! 1050: return IO_R_SUCCESS; ! 1051: } else if ( strcmp(parameterName, VGA_FB_UNREGISTER) == 0 ) { ! 1052: if ( count != 1 ) ! 1053: return IO_R_INVALID_ARG; ! 1054: [[EventDriver instance] unregisterScreen:parameterArray[0]]; ! 1055: return IO_R_SUCCESS; ! 1056: ! 1057: } else { ! 1058: return [super setIntValues:parameterArray ! 1059: forParameter:parameterName ! 1060: count:count]; ! 1061: } ! 1062: } ! 1063: ! 1064: - (IOConsoleInfo *)allocateConsoleInfo; ! 1065: // Description: Allocates a console support info structure based on this ! 1066: // display. This structure, and the functions in it, are used ! 1067: // to display alert and console windows. ! 1068: { ! 1069: return SVGAAllocateConsole([self displayInfo]); ! 1070: } ! 1071: ! 1072: // ! 1073: // END: EXPORTED methods ! 1074: // ! 1075: ! 1076: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.