Return to QVisionDAC.m CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / DriverKit / QVision / QVision_reloc.tproj

Annotation of Examples/DriverKit/QVision/QVision_reloc.tproj/QVisionDAC.m, revision 1.1

1.1     ! root        1: /* Copyright (c) 1993 by NeXT Computer, Inc as an unpublished work.
        !             2:  * All rights reserved.
        !             3:  *
        !             4:  * QVisionDAC.m -- DAC support for the QVision.
        !             5:  *
        !             6:  * History
        !             7:  * Thu Sep 15 16:13:45 PDT 1994, James C. Lee
        !             8:  *   Added AT&T 20C505 DAC support
        !             9:  * Author:  Derek B Clegg      30 June 1993
        !            10:  * Based on work by Joe Pasqua.
        !            11:  */
        !            12: #import <driverkit/generalFuncs.h>
        !            13: #import <driverkit/i386/ioPorts.h>
        !            14: #import <bsd/dev/ev_types.h>
        !            15: #import "QVision.h"
        !            16: 
        !            17: /* The `ProgramDAC' category of `QVision'. */
        !            18: 
        !            19: @implementation QVision (ProgramDAC)
        !            20: 
        !            21: // also check for AT&T 20C505 DAC; it's BT485 compatible
        !            22: static DACtype checkForBrooktreeDAC(void)
        !            23: {
        !            24:     DACtype dac;
        !            25: 
        !            26:     /* Unlock the extended graphics registers. */
        !            27:     outw(VGA_GRFX_INDEX, 0x050f);
        !            28: 
        !            29:     /* Unlock some more extended registers. */
        !            30:     outb(VGA_GRFX_INDEX, 0x10);
        !            31:     outb(VGA_GRFX_DATA, 0x08);
        !            32: 
        !            33:     /* Read the status register. */
        !            34:     switch (inb(DAC_EXT_REG) & 0xF0) {
        !            35:     case 0x40:
        !            36:        dac = Bt484;
        !            37:        break;
        !            38:     case 0x80:
        !            39:        dac = Bt485;
        !            40:        break;
        !            41:     case 0x20:
        !            42:        dac = Bt485A;
        !            43:        break;
        !            44:     case 0xd0:
        !            45:        dac = ATT20C505;
        !            46:        break;
        !            47:     default:
        !            48:        dac = UnknownDAC;
        !            49:        break;
        !            50:     }
        !            51:     return dac;
        !            52: }
        !            53: 
        !            54: - determineDACType
        !            55: {
        !            56:     dac = checkForBrooktreeDAC();
        !            57:     return self;
        !            58: }
        !            59: 
        !            60: /* Default gamma precompensation table for color displays.
        !            61:  * Gamma 2.2 LUT for P22 phosphor displays (Hitachi, NEC, generic VGA) */
        !            62: 
        !            63: static const unsigned char gamma16[] = {
        !            64:       0,  74, 102, 123, 140, 155, 168, 180,
        !            65:     192, 202, 212, 221, 230, 239, 247, 255
        !            66: };
        !            67: 
        !            68: static const unsigned char gamma8[] = {
        !            69:       0,  15,  22,  27,  31,  35,  39,  42,  45,  47,  50,  52,
        !            70:      55,  57,  59,  61,  63,  65,  67,  69,  71,  73,  74,  76,
        !            71:      78,  79,  81,  82,  84,  85,  87,  88,  90,  91,  93,  94,
        !            72:      95,  97,  98,  99, 100, 102, 103, 104, 105, 107, 108, 109,
        !            73:     110, 111, 112, 114, 115, 116, 117, 118, 119, 120, 121, 122,
        !            74:     123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
        !            75:     135, 136, 137, 138, 139, 140, 141, 141, 142, 143, 144, 145,
        !            76:     146, 147, 148, 148, 149, 150, 151, 152, 153, 153, 154, 155, 
        !            77:     156, 157, 158, 158, 159, 160, 161, 162, 162, 163, 164, 165,
        !            78:     165, 166, 167, 168, 168, 169, 170, 171, 171, 172, 173, 174,
        !            79:     174, 175, 176, 177, 177, 178, 179, 179, 180, 181, 182, 182,
        !            80:     183, 184, 184, 185, 186, 186, 187, 188, 188, 189, 190, 190, 
        !            81:     191, 192, 192, 193, 194, 194, 195, 196, 196, 197, 198, 198,
        !            82:     199, 200, 200, 201, 201, 202, 203, 203, 204, 205, 205, 206, 
        !            83:     206, 207, 208, 208, 209, 210, 210, 211, 211, 212, 213, 213,
        !            84:     214, 214, 215, 216, 216, 217, 217, 218, 218, 219, 220, 220, 
        !            85:     221, 221, 222, 222, 223, 224, 224, 225, 225, 226, 226, 227,
        !            86:     228, 228, 229, 229, 230, 230, 231, 231, 232, 233, 233, 234, 
        !            87:     234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 240, 240,
        !            88:     241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 
        !            89:     247, 247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252,
        !            90:     253, 253, 254, 255, 
        !            91: };
        !            92: 
        !            93: static void
        !            94: SetGammaValue(unsigned int r, unsigned int g, unsigned int b, int level)
        !            95: {
        !            96:     outb(PALETTE_DATA, EV_SCALE_BRIGHTNESS(level, r));
        !            97:     outb(PALETTE_DATA, EV_SCALE_BRIGHTNESS(level, g));
        !            98:     outb(PALETTE_DATA, EV_SCALE_BRIGHTNESS(level, b));
        !            99: }
        !           100: 
        !           101: - setGammaTable
        !           102: {
        !           103:     unsigned int i, j, g;
        !           104:     const IODisplayInfo *displayInfo;
        !           105: 
        !           106:     displayInfo = [self displayInfo];
        !           107: 
        !           108:     outb(PALETTE_WRITE, 0x00);
        !           109: 
        !           110:     if (redTransferTable != 0) {
        !           111:        for (i = 0; i < transferTableCount; i++) {
        !           112:            for (j = 0; j < 256/transferTableCount; j++) {
        !           113:                SetGammaValue(redTransferTable[i], greenTransferTable[i],
        !           114:                              blueTransferTable[i], brightnessLevel);
        !           115:            }
        !           116:        }
        !           117:     } else {
        !           118:        switch (displayInfo->bitsPerPixel) {
        !           119:        case IO_24BitsPerPixel:
        !           120:        case IO_8BitsPerPixel:
        !           121:            for (g = 0; g < 256; g++) {
        !           122:                SetGammaValue(gamma8[g], gamma8[g], gamma8[g],
        !           123:                              brightnessLevel);
        !           124:            }
        !           125:            break;
        !           126:        case IO_15BitsPerPixel:
        !           127:            for (i = 0; i < 32; i++) {
        !           128:                for (j = 0; j < 8; j++) {
        !           129:                    SetGammaValue(gamma16[i/2], gamma16[i/2], gamma16[i/2],
        !           130:                                  brightnessLevel);
        !           131:                }
        !           132:            }
        !           133:            break;
        !           134:        default:
        !           135:            break;
        !           136:        }
        !           137:     }
        !           138:     return self;
        !           139: }
        !           140: 
        !           141: - resetDAC
        !           142: {
        !           143:     const QVisionMode *mode;
        !           144: 
        !           145:     mode = [self displayInfo]->parameters;
        !           146: 
        !           147:     if (dac == Bt485 || dac == Bt485A || dac == ATT20C505) {
        !           148:        /* Brooktree 485 or 485A only! */
        !           149:        outb(DAC_CMD_0, 0x80);          /* Enable the DAC_EXT_REG. */
        !           150:        outb(PALETTE_WRITE, 0x01);      /* Make 13C6 be the DAC_EXT_REG. */
        !           151:        outb(DAC_EXT_REG, 0x00);        /* Turn off clock doubling. */
        !           152:        outb(PALETTE_WRITE, 0x00);      /* Restore 13C6. */
        !           153:     }
        !           154: 
        !           155:     /* Restore DAC command registers 0, 1, & 2 to their initial VGA values. */
        !           156:     outb(DAC_CMD_0, 0x40);
        !           157:     outb(DAC_CMD_1, 0x00);
        !           158:     outb(DAC_CMD_2, 0x20);
        !           159: 
        !           160:     return self;
        !           161: }
        !           162: 
        !           163: - programDAC
        !           164: {
        !           165:     const QVisionMode *mode;
        !           166: 
        !           167:     mode = [self displayInfo]->parameters;
        !           168: 
        !           169:     /* Load DAC Command regs. */
        !           170:     outb(DAC_CMD_0, 0x02);             /* 8-bit DAC. */
        !           171:     outb(DAC_CMD_1, mode->dacCmd1);    /* Set the bits per pixel. */
        !           172:     outb(DAC_CMD_2, 0x20);             /* Allow advanced modes. */
        !           173:        
        !           174:     if (mode->needsPixelDoubling &&
        !           175:        (dac == Bt485 || dac == Bt485A || dac == ATT20C505))
        !           176:     {
        !           177:        /* Brooktree 485 or 485A, or AT&T 20C505 only! */
        !           178:        outb(DAC_CMD_0, 0x82);          /* Enable the DAC_EXT_REG. */
        !           179:        outb(PALETTE_WRITE, 0x01);      /* Make 13C6 be the DAC_EXT_REG. */
        !           180:        outb(DAC_EXT_REG, 0x08);        /* Turn on clock doubling. */
        !           181:     }
        !           182: 
        !           183:     /* Set overscan color (black) */
        !           184:     outb(CO_COLOR_WRITE, 0x00);
        !           185:     outb(CO_COLOR_DATA, 0x00);         /* Red component. */
        !           186:     outb(CO_COLOR_DATA, 0x00);         /* Green component. */
        !           187:     outb(CO_COLOR_DATA, 0x00);         /* Blue component. */
        !           188: 
        !           189:     return self;
        !           190: }
        !           191: @end

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