Return to S3.m CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / DriverKit / S3 / S3_reloc.tproj

Annotation of Examples/DriverKit/S3/S3_reloc.tproj/S3.m, revision 1.1

1.1     ! root        1: /* Copyright (c) 1993 by NeXT Computer, Inc.
        !             2:  * All rights reserved.
        !             3:  *
        !             4:  * S3.m -- driver for S3 86C805 and 86C928 Graphics Accelerators
        !             5:  *
        !             6:  * Created by Peter Graffagnino 1/31/93
        !             7:  * Modified by Derek B Clegg   21 May 1993
        !             8:  */
        !             9: #import <driverkit/i386/IOEISADeviceDescription.h>
        !            10: #import "S3.h"
        !            11: 
        !            12: @implementation S3
        !            13: 
        !            14: /* Put the display into linear framebuffer mode. This typically happens
        !            15:  * when the window server starts running.
        !            16:  */
        !            17: - (void)enterLinearMode
        !            18: {
        !            19:     /* Set up the chip to use the selected mode. */
        !            20:     [self initializeMode];
        !            21: 
        !            22:     /* Set the gamma-corrected gray-scale palette if necessary. */
        !            23:     [self setGammaTable];
        !            24: 
        !            25:     /* Enter linear mode. */
        !            26:     if ([self enableLinearFrameBuffer] == nil) {
        !            27:        IOLog("%s: Failed to enter linear mode.\n", [self name]);
        !            28:        return;
        !            29:     }
        !            30: }
        !            31: 
        !            32: /* Get the device out of whatever advanced linear mode it was using and back
        !            33:  * into a state where it can be used as a standard VGA device.
        !            34:  */
        !            35: - (void)revertToVGAMode
        !            36: {
        !            37:     /* Reset the VGA parameters. */
        !            38:     [self resetVGA];
        !            39: 
        !            40:     /* Let the superclass do whatever work it needs to do. */
        !            41:     [super revertToVGAMode];
        !            42: }
        !            43: 
        !            44: /* Set the brightness to `level'.
        !            45:  */
        !            46: - setBrightness:(int)level token:(int)t
        !            47: {
        !            48:     if (level < EV_SCREEN_MIN_BRIGHTNESS || level > EV_SCREEN_MAX_BRIGHTNESS) {
        !            49:        IOLog("QVision: Invalid brightness level `%d'.\n", level);
        !            50:        return nil;
        !            51:     }
        !            52:     brightnessLevel = level;
        !            53:     [self setGammaTable];
        !            54:     return self;
        !            55: }
        !            56: 
        !            57: /* Set the transfer tables.
        !            58:  */
        !            59: - setTransferTable:(const unsigned int *)table count:(int)numEntries
        !            60: {
        !            61:     int k;
        !            62:     IOBitsPerPixel bpp;
        !            63:     IOColorSpace cspace;
        !            64: 
        !            65:     if (redTransferTable != 0)
        !            66:        IOFree(redTransferTable, 3 * transferTableCount);
        !            67: 
        !            68:     transferTableCount = numEntries;
        !            69: 
        !            70:     redTransferTable = IOMalloc(3 * numEntries);
        !            71:     greenTransferTable = redTransferTable + numEntries;
        !            72:     blueTransferTable = greenTransferTable + numEntries;
        !            73: 
        !            74:     bpp = [self displayInfo]->bitsPerPixel;
        !            75:     cspace = [self displayInfo]->colorSpace;
        !            76: 
        !            77:     if (bpp == IO_8BitsPerPixel && cspace == IO_OneIsWhiteColorSpace) {
        !            78:        for (k = 0; k < numEntries; k++) {
        !            79:            redTransferTable[k] = greenTransferTable[k] =
        !            80:                blueTransferTable[k] = table[k] & 0xFF;
        !            81:        }
        !            82:     } else if (cspace == IO_RGBColorSpace &&
        !            83:               (bpp == IO_8BitsPerPixel ||
        !            84:                bpp == IO_15BitsPerPixel ||
        !            85:                bpp == IO_24BitsPerPixel)) {
        !            86:        for (k = 0; k < numEntries; k++) {
        !            87:            redTransferTable[k] = (table[k] >> 24) & 0xFF;
        !            88:            greenTransferTable[k] = (table[k] >> 16) & 0xFF;
        !            89:            blueTransferTable[k] = (table[k] >> 8) & 0xFF;
        !            90:        }
        !            91:     } else {
        !            92:        IOFree(redTransferTable, 3 * numEntries);
        !            93:        redTransferTable = 0;
        !            94:     }
        !            95:     [self setGammaTable];
        !            96:     return self;
        !            97: }
        !            98: 
        !            99: - initFromDeviceDescription:deviceDescription
        !           100: {
        !           101:     IODisplayInfo *displayInfo;
        !           102:     const IORange *range;
        !           103:     const S3Mode *s3mode;
        !           104:     const char *s;
        !           105: 
        !           106:     if ([super initFromDeviceDescription:deviceDescription] == nil)
        !           107:        return [super free];
        !           108: 
        !           109:     if ([self determineConfiguration] == nil)
        !           110:        return [super free];
        !           111: 
        !           112:     if ([self selectMode] == nil)
        !           113:        return [super free];
        !           114: 
        !           115:     range = [deviceDescription memoryRangeList];
        !           116:     if (range == 0) {
        !           117:        IOLog("%s: No memory range set.\n", [self name]);
        !           118:        return [super free];
        !           119:     }
        !           120:     videoRamAddress = range[0].start;
        !           121: 
        !           122:     redTransferTable = greenTransferTable = blueTransferTable = 0;
        !           123:     transferTableCount = 0;
        !           124:     brightnessLevel = EV_SCREEN_MAX_BRIGHTNESS;
        !           125: 
        !           126:     displayInfo = [self displayInfo];
        !           127:     s3mode = displayInfo->parameters;
        !           128:     displayInfo->flags = 0;
        !           129: 
        !           130:     /* Some S3 805 cards have a lot of flicker when write-posting or
        !           131:      * read-ahead is enabled.  We disable both, but provide a way to
        !           132:      * turn them on from the config table.  It's a good idea to enable
        !           133:      * both if possible, since it speeds up the display a good deal.
        !           134:      */
        !           135: 
        !           136:     writePostingEnabled = [self booleanForStringKey:"WritePostingEnabled"
        !           137:                       withDefault:(adapter == S3_805 ? NO : YES)];
        !           138:     readAheadCacheEnabled = [self booleanForStringKey:"ReadAheadCacheEnabled"
        !           139:                         withDefault:(adapter == S3_805 ? NO : YES)];
        !           140: 
        !           141:     /* Turn on s/w gamma correction.  (This is only necessary for the 555/16
        !           142:      * modes.) */
        !           143: 
        !           144:     if ([self hasTransferTable])
        !           145:        displayInfo->flags |= IO_DISPLAY_HAS_TRANSFER_TABLE;
        !           146: 
        !           147:     if ([self needsSoftwareGammaCorrection])
        !           148:        displayInfo->flags |= IO_DISPLAY_NEEDS_SOFTWARE_GAMMA_CORRECTION;
        !           149: 
        !           150:     if (adapter == S3_805) {
        !           151:        /* On the 805, always turn the cache off. */
        !           152:        displayInfo->flags |= IO_DISPLAY_CACHE_OFF;
        !           153:     } else {
        !           154:        s = [self valueForStringKey:"DisplayCacheMode"];
        !           155:        if (s != 0) {
        !           156:            if (strcmp(s, "Off") == 0)
        !           157:                displayInfo->flags |= IO_DISPLAY_CACHE_OFF;
        !           158:            else if (strcmp(s, "WriteThrough") == 0)
        !           159:                displayInfo->flags |= IO_DISPLAY_CACHE_WRITETHROUGH;
        !           160:            else if (strcmp(s, "CopyBack") == 0)
        !           161:                displayInfo->flags |= IO_DISPLAY_CACHE_COPYBACK;
        !           162:            else
        !           163:                IOLog("%s: Unrecognized value for key `DisplayCacheMode': "
        !           164:                      "`%s'.\n", [self name], s);
        !           165:        }
        !           166:     }
        !           167: 
        !           168:     displayInfo->frameBuffer =
        !           169:         (void *)[self mapFrameBufferAtPhysicalAddress:videoRamAddress
        !           170:             length:s3mode->memSize];
        !           171:     if (displayInfo->frameBuffer == 0)
        !           172:        return [super free];
        !           173: 
        !           174:     IOLog("%s: Initialized `%s' @ %d Hz.\n", [self name], s3mode->name, 
        !           175:          displayInfo->refreshRate);
        !           176: 
        !           177:     return self;
        !           178: }
        !           179: @end

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.