home *** CD-ROM | disk | FTP | other *** search
/ NeXTSTEP 3.2 (Developer) / NS_dev_3.2.iso / NextDeveloper / Examples / DriverKit / JAWS / JAWS_reloc.tproj / JAWS.m < prev    next >
Encoding:
Text File  |  1993-08-07  |  8.7 KB  |  324 lines
  1. /*     Copyright (c) 1992 NeXT Computer, Inc.  All rights reserved. 
  2.  *
  3.  * JAWS.m - Jaws display driver, ObjC implementation.
  4.  *
  5.  * HISTORY
  6.  * 02 Sep 92    Joe Pasqua
  7.  *      Created. 
  8.  * 12 July 1993    Derek B Clegg
  9.  *    Cleanup for external release.
  10.  */
  11.  
  12. /* TO DO:
  13.  *   Implement other modes. Perhaps a large grayscale mode.
  14.  */
  15.  
  16. #import <string.h>
  17. #import <driverkit/generalFuncs.h>
  18. #import <driverkit/kernelDriver.h>
  19. #import <driverkit/i386/ioPorts.h>
  20. #import <driverkit/i386/directDevice.h>
  21. #import "JAWS.h"
  22. #import "JAWSModes.h"
  23.  
  24. static inline void
  25. setValue(unsigned int address, unsigned int value)
  26. {
  27.     *(unsigned int *)address = value;
  28.     IODelay(50);
  29. }
  30.  
  31. @implementation JAWS
  32.  
  33. - (const char *)valueForStringKey:(const char *)key
  34. {
  35.     IOConfigTable *configTable;
  36.     configTable = [[self deviceDescription] configTable];
  37.     if (configTable == nil)
  38.     return 0;
  39.     return [configTable valueForStringKey:key];
  40. }
  41.  
  42. - (BOOL)booleanForStringKey:(const char *)key withDefault:(BOOL)defaultValue
  43. {
  44.     const char *value;
  45.  
  46.     value = [self valueForStringKey:key];
  47.     if (value == 0)
  48.     return defaultValue;
  49.     
  50.     if (value[0] == 'Y' || value[0] == 'y') {
  51.     if (value[1] == '\0'
  52.         || ((value[1] == 'E' || value[1] == 'e')
  53.         && (value[2] == 'S' || value[2] == 's')
  54.         && value[3] == '\0')) {
  55.         return YES;
  56.     }
  57.     } else if (value[0] == 'N' || value[0] == 'n') {
  58.     if (value[1] == '\0'
  59.         || ((value[1] == 'O' || value[1] == 'o')
  60.         && value[2] == '\0')) {
  61.         return NO;
  62.     }
  63.     }
  64.     IOLog("%s: Unrecognized value for key `%s': `%s'.\n",
  65.       [self name], key, value);
  66.     return defaultValue;
  67. }
  68.  
  69. /* Default gamma precompensation table for color displays.
  70.  * Gamma 2.2 LUT for P22 phosphor displays (Hitachi, NEC, generic VGA).
  71.  */
  72.  
  73. static const unsigned char gamma_table[16] = {
  74.       0,  74, 102, 123, 140, 155, 168, 180,
  75.     192, 202, 212, 221, 230, 239, 247, 255,
  76. };
  77.  
  78. /* Load the JAWS palette and scale the values according to the brightness
  79.  * levels entered.  A 16 step table is used.  The value for each step is
  80.  * loaded into the pixel addressable RAM location, and the 15 following,
  81.  * not normally addressed locations, to prevent problems from vendor PWB
  82.  * changes and noise (specifically ground bounce).
  83.  */
  84. - (void)setJawsPalette:(int)level
  85. {
  86.     unsigned int g, k, v, palette;
  87.  
  88.     palette = (unsigned int)JAWS_COL_PAL;
  89.  
  90.     for (g = 0; g < 16; g++) {
  91.     v = EV_SCALE_BRIGHTNESS(level, gamma_table[g]);
  92.         for (k = 0; k < 16; k++) {
  93.         setValue(palette, (v << 16) | (v << 8) | v);
  94.         palette += sizeof(unsigned int);
  95.     }
  96.     }
  97. }
  98.  
  99. /* Initialize the guts of the Jaws card.
  100.  */
  101. - (void)initializeG332
  102. {
  103.     unsigned int cra_reg_value;
  104.  
  105.     /* Boot location. */
  106.  
  107. #if JAWS_VIDEO_MW == 1024
  108.     setValue(JAWS_BOOT_REG, CLK_SRC_PLL | CLK_PLL_MUL_9);
  109. #elif JAWS_VIDEO_MW == 1120
  110.     setValue(JAWS_BOOT_REG, CLK_SRC_PLL | CLK_PLL_MUL_C);
  111. #elif JAWS_VIDEO_MW == 1152
  112.     setValue(JAWS_BOOT_REG, CLK_SRC_PLL | CLK_PLL_MUL_B);
  113. #endif
  114.  
  115.     /* Control Register */
  116.  
  117.     cra_reg_value = (CRA_VTG_DIS | CRA_NON_INT | CRA_FMT_CCI | CRA_MDE_MST
  118.              | CRA_CBL_INP | CRA_BLK_PED | CRA_CLK_PAD | CRA_BLK_ENA
  119.              | CRA_1KB_1KB | CRA_DMA_DIS | CRA_SYN_000 | CRA_PPI_INT
  120.              | CRA_SMP_DIS | CRA_NON_008 | CRA_CRS_DIS);
  121.  
  122.     if (useCompositeSync) {
  123.     cra_reg_value |= (CRA_SYN_PLN | CRA_SYN_CMP | CRA_FMT_C_S);
  124.     } else {
  125.     cra_reg_value |= (CRA_SYN_PLN | CRA_SYN_SEP | CRA_FMT_VID);
  126.     }
  127.     setValue(JAWS_CRA_REG, cra_reg_value);
  128.  
  129. #if JAWS_VIDEO_MW == 1024
  130.     /* Various VTG registers - values determined empirically. */
  131.     setValue(JAWS_VTG_HALF_SYNC,     0x00000011);
  132.     setValue(JAWS_VTG_BACK_PORCH,     0x00000024);
  133.     setValue(JAWS_VTG_DISPLAY,         0x00000100);
  134.     setValue(JAWS_VTG_SHORTDISPLAY,     0x0000005B);
  135.     setValue(JAWS_VTG_BROADPAUSE,     0x000000A1);
  136.     setValue(JAWS_VTG_VSYNC,         0x0000000C);
  137.     setValue(JAWS_VTG_VPREEQUALISE,     0x0000000C);
  138.     setValue(JAWS_VTG_VPOSTEQUALISE,     0x0000000C);
  139.     setValue(JAWS_VTG_VBLANK,         0x00000028);
  140.     setValue(JAWS_VTG_VDISPLAY,     0x00000600);
  141.     setValue(JAWS_VTG_LINETIME,     0x0000014A);
  142.     setValue(JAWS_VTG_LINESTART,     0x00000000);
  143.     setValue(JAWS_VTG_MEMINIT,         0x000003E8);
  144.     setValue(JAWS_VTG_TRANSFERDELAY,     0x00000018);
  145.  
  146. #elif JAWS_VIDEO_MW == 1120
  147.     /* Various VTG registers - values determined empirically. */
  148.     setValue(JAWS_VTG_HALF_SYNC,     0x00000010);
  149.     setValue(JAWS_VTG_BACK_PORCH,     0x00000047);
  150.     setValue(JAWS_VTG_DISPLAY,         0x00000118);
  151.     setValue(JAWS_VTG_SHORTDISPLAY,     0x0000004E);
  152.     setValue(JAWS_VTG_BROADPAUSE,     0x000000B5);
  153.     setValue(JAWS_VTG_VSYNC,         0x00000010);
  154.     setValue(JAWS_VTG_VPREEQUALISE,     0x00000010);
  155.     setValue(JAWS_VTG_VPOSTEQUALISE,     0x00000010);
  156.     setValue(JAWS_VTG_VBLANK,         0x00000050);
  157.     setValue(JAWS_VTG_VDISPLAY,     0x00000680);
  158.     setValue(JAWS_VTG_LINETIME,     0x00000194);
  159.     setValue(JAWS_VTG_LINESTART,     0x00000000);
  160.     setValue(JAWS_VTG_MEMINIT,         0x000001E8);
  161.     setValue(JAWS_VTG_TRANSFERDELAY,     0x00000018);
  162.  
  163. #elif JAWS_VIDEO_MW == 1152
  164.     /* Various VTG registers - values determined empirically. */
  165.     setValue(JAWS_VTG_HALF_SYNC,     0x0000000D);
  166.     setValue(JAWS_VTG_BACK_PORCH,     0x0000002E);
  167.     setValue(JAWS_VTG_DISPLAY,         0x00000120);
  168.     setValue(JAWS_VTG_SHORTDISPLAY,     0x00000069);
  169.     setValue(JAWS_VTG_BROADPAUSE,     0x000000B1);
  170.     setValue(JAWS_VTG_VSYNC,         0x00000006);
  171.     setValue(JAWS_VTG_VPREEQUALISE,     0x00000006);
  172.     setValue(JAWS_VTG_VPOSTEQUALISE,     0x00000006);
  173.     setValue(JAWS_VTG_VBLANK,         0x00000040);
  174.     setValue(JAWS_VTG_VDISPLAY,     0x00000708);
  175.     setValue(JAWS_VTG_LINETIME,     0x0000016E);
  176.     setValue(JAWS_VTG_LINESTART,     0x00000000);
  177.     setValue(JAWS_VTG_MEMINIT,         0x000001E0);
  178.     setValue(JAWS_VTG_TRANSFERDELAY,     0x00000020);
  179. #endif
  180.  
  181.     /* Mask register. */
  182.     setValue(JAWS_MASK_REG, 0x00FFFFFF);
  183.  
  184.     /* Top of Screen. */
  185.     setValue(JAWS_TOS_REG, 0x00000000);
  186.  
  187.     /* CRA reg again. */
  188.     cra_reg_value = (CRA_VTG_ENA | CRA_NON_INT | CRA_FMT_CCI | CRA_MDE_MST
  189.              | CRA_CBL_INP | CRA_CLK_PAD | CRA_BLK_PED | CRA_BLK_ENA
  190.              | CRA_1KB_1KB | CRA_DMA_ENA | CRA_SYN_000 | CRA_PPI_INT
  191.              | CRA_SMP_DEL | CRA_NON_016 | CRA_CRS_DIS);
  192.  
  193.     if (useCompositeSync) {
  194.     cra_reg_value |= (CRA_SYN_PLN | CRA_SYN_CMP | CRA_FMT_C_S);
  195.     } else {
  196.     cra_reg_value |= (CRA_SYN_PLN | CRA_SYN_SEP | CRA_FMT_VID);
  197.     }
  198.     setValue(JAWS_CRA_REG, cra_reg_value);
  199.  
  200.     [self setJawsPalette:EV_SCREEN_MAX_BRIGHTNESS];
  201. }    
  202.  
  203. static inline void
  204. setJawsCtl(jaws_ctl_reg_t reg)
  205. {
  206.     union {
  207.     jaws_ctl_reg_t reg;
  208.     unsigned char iodata;
  209.     } v;
  210.     v.reg = reg;
  211.     outb(JAWS_CTL_REG_IOADDR, v.iodata);
  212. }
  213.  
  214. - (void)enableJawsMode
  215. {
  216.     jaws_ctl_reg_t ctl;
  217.  
  218.     ctl.phys = JAWS_CTL_PHYS_512M;
  219.     ctl.cache = 1;
  220.     ctl.ienable = 0;
  221.     ctl.JAWSvga = 1;
  222.     ctl.bbp12 = 1;
  223.  
  224.     ctl.reset = 1;
  225.     setJawsCtl(ctl);
  226.     
  227.     IODelay(100);
  228.     
  229.     ctl.reset = 0;
  230.     setJawsCtl(ctl);
  231.  
  232.     /* Initialize the video controller. */
  233.     [self initializeG332];
  234. }
  235.  
  236. - (void)revertToVGAMode
  237. {
  238.     jaws_ctl_reg_t ctl;
  239.  
  240.     ctl.phys = 0;
  241.     ctl.cache = 0;
  242.     ctl.ienable = 0;
  243.     ctl.retrace = 0;
  244.     ctl.JAWSvga = 0;
  245.     ctl.bbp12 = 0;
  246.  
  247.     ctl.reset = 1;
  248.     setJawsCtl(ctl);
  249.     
  250.     IODelay(100);
  251.     
  252.     ctl.reset = 0;
  253.     setJawsCtl(ctl);
  254. }
  255.  
  256. - (void)enterLinearMode
  257. {
  258.     IODisplayInfo *display;
  259.     [self enableJawsMode];
  260.     display = [self displayInfo];
  261.     memset(display->frameBuffer, 0, display->height * display->rowBytes);
  262. }
  263.  
  264. - (BOOL)JAWSPresent
  265. {
  266.     int slot;
  267.     unsigned int cardID;
  268.  
  269.     if (![self isEISAPresent])
  270.     return FALSE;
  271.  
  272.     for (slot = 1; slot < 16; slot++)
  273.     if ([self getEISAId:&cardID forSlot:slot] && cardID == JAWS_EISA_ID)
  274.         return TRUE;
  275.     return FALSE;
  276. }
  277.  
  278. - initFromDeviceDescription:deviceDescription
  279. {
  280.     IODisplayInfo *display;
  281.  
  282.     if (![self JAWSPresent])
  283.     return [super free];
  284.  
  285.     if ([super initFromDeviceDescription:deviceDescription] == nil)
  286.     return [super free];
  287.  
  288.     useCompositeSync = [self booleanForStringKey:"UseCompositeSync"
  289.             withDefault:NO];
  290.  
  291.     display = [self displayInfo];
  292.     display->frameBuffer = 
  293.     (void *)[self mapFrameBufferAtPhysicalAddress:0 length:0];
  294.     if (display->frameBuffer == 0)
  295.         return [super free];
  296.  
  297.     baseAddress = (vm_offset_t)display->frameBuffer;
  298.  
  299.     display->width = JAWS_VIDEO_W;
  300.     display->height = JAWS_VIDEO_H;
  301.     display->totalWidth = JAWS_VIDEO_MW;
  302.     display->rowBytes = JAWS_VIDEO_NBPL;
  303.     display->bitsPerPixel = IO_12BitsPerPixel;
  304.     strcpy(display->pixelEncoding, "RRRRGGGGBBBB----");
  305.     display->flags = 0;
  306.     return self;
  307. }
  308.  
  309. /* This is from the `IOScreenEvents' protocol. We override our superclass
  310.  * for this since it doesn't know how to set our brightness.
  311.  */
  312.  
  313. - setBrightness:(int)level token:(int)t
  314. {
  315.     if (level < EV_SCREEN_MIN_BRIGHTNESS || level > EV_SCREEN_MAX_BRIGHTNESS) {
  316.     IOLog("%s: Invalid argument to setBrightness: %d\n", [self name],
  317.           level);
  318.     return nil;
  319.     }
  320.     [self setJawsPalette:level];
  321.     return self;
  322. }
  323. @end
  324.