home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ddkx86v5.zip / DDKX86 / SRC / VDH / VDHPALET.C < prev    next >
C/C++ Source or Header  |  1995-04-14  |  33KB  |  724 lines
  1. /*DDK*************************************************************************/
  2. /*                                                                           */
  3. /* COPYRIGHT (C) Microsoft Corporation, 1989                                 */
  4. /* COPYRIGHT    Copyright (C) 1995 IBM Corporation                           */
  5. /*                                                                           */
  6. /*    The following IBM OS/2 WARP source code is provided to you solely for  */
  7. /*    the purpose of assisting you in your development of OS/2 WARP device   */
  8. /*    drivers. You may use this code in accordance with the IBM License      */
  9. /*    Agreement provided in the IBM Device Driver Source Kit for OS/2. This  */
  10. /*    Copyright statement may not be removed.                                */
  11. /*                                                                           */
  12. /*****************************************************************************/
  13. /*****************************************************************************
  14.  *
  15.  * SOURCE FILE NAME = VDHPALET.c
  16.  *
  17.  * DESCRIPTIVE NAME = Base video device handlers - Color Lookup/Palette 
  18.  *
  19.  *
  20.  * VERSION      V2.0
  21.  *
  22.  * DATE         
  23.  *
  24.  * DESCRIPTION  This source file contains VDH entry points which             
  25.  *              get/set the color lookup table and palette registers.
  26.  *              and get/set palette registers.
  27.  *
  28.  *  NOTE:       These routines execute as ring 2 conforming           
  29.  *
  30.  * FUNCTIONS    GetColorLookup,  SetColorLookup                       
  31.  *              GetPaletteReg,   SetPaletteReg                        
  32.  *
  33.  * NOTES        NONE
  34.  *
  35.  * STRUCTURES   NONE
  36.  *
  37.  * EXTERNAL REFERENCES
  38.  *              SaveRegs, RestoreRegs          
  39.  *              AccessHardware, AccessCLUT      
  40.  *              PhysToUVirt, FreePhysToUVirt    
  41.  *
  42.  * EXTERNAL FUNCTIONS
  43.  *
  44.  *              NONE
  45.  *
  46. */
  47.  
  48. /*
  49. **  Include files                                                            
  50. */
  51.  
  52. #define  INCL_BASE                     /* ALL of OS/2 Base                  */
  53. #define  INCL_OS2STD                   /* Needed for NULL definition in     */
  54.                                        /* OS2STD.H                          */
  55. #include <os2.h>
  56. #include "vdhctl.h"                    /* Conditional compilation control   */
  57. #include "vdh.h"                       /* Type definitions                  */
  58.  
  59. /*
  60. **  Externally defined global variables                                      
  61. */
  62.  
  63. extern VIDEOMODE Modes[];              /* Supported modes                   */
  64. extern MEMORYMAPS MemoryMaps[];        /* Memory map info for each mode     */
  65. extern UCHAR LCDGrayLUT[];             /* LCD gray scale lookup table       */
  66. extern USHORT OEMFlags;                /* OEM specific features             */
  67. extern SHORT HugeShift;                /* Huge shift value                  */
  68. extern UCHAR READABLE;
  69. extern ULONG PartialSaveSize;          /* Room required to save entire PVB  */
  70.                                        /* in the popup mode                 */
  71. extern USHORT VGA_PRESENT;             /* TRUE if VGA VDH has been          */
  72.                                        /* installed                         */
  73. extern USHORT(APIENTRY *ChainedCallVectorTable[MaxFn])();/*             @T24*/
  74.  
  75. /*
  76. **  Parameters to ring 2 routines                                            
  77. */
  78.  
  79. extern UCHAR CRTReg1;
  80. extern UCHAR CRTReg2;
  81. extern UCHAR PelHeightFixup;
  82. extern UCHAR ScreenRemainder;
  83. extern CLUTDATA far ColorCLUT;
  84. extern CLUTDATA far MonoCLUT;
  85. extern CLUTDATA far SumCLUT;
  86.  
  87. #if      VDHVGA        || VDH8514A     /* Start of               @S24CHANGES*/
  88.                                        /* MS00                              */
  89.  
  90. /*****************************************************************************
  91.  *                                                                          
  92.  *  SUBROUTINE NAME: GetColorLookup                                         
  93.  *                                                                          
  94.  *  DESCRIPTIVE NAME: Get color lookup table                                
  95.  *                                                                          
  96.  *  FUNCTION: GetColorLookup is called by BVS to return a specified         
  97.  *            portion of the current color lookup table settings            
  98.  *                                                                          
  99.  *  ENTRY POINT: GetColorLookup                                             
  100.  *    LINKAGE:   CALL FAR ( via BVS-DDI call vector table entry 263 )       
  101.  *                                                                          
  102.  *  INPUT: (Passed on stack)                                                
  103.  *             FAR *Environment ( Environment buffer for the session )      
  104.  *             FAR *ParmBlock                                               
  105.  *                     USHORT Length = length of this packet                
  106.  *                     USHORT Flags  = 0 - Environment buffer only          
  107.  *                                     1 - Hardware also                    
  108.  *                     CLUTDATA far *LookupTable ( 0x00 - 0xFF )            
  109.  *                                     UCHAR Red                            
  110.  *                                     UCHAR Green                          
  111.  *                                     UCHAR Blue                           
  112.  *                     USHORT   FirstEntry                                  
  113.  *                     USHORT   NumEntries                                  
  114.  *             ULONG Function ( Call vector table entry = 263 )             
  115.  *                                                                          
  116.  *  EXIT-NORMAL: AX = 0                                                     
  117.  *               Portion of CLUT requested is returned                      
  118.  *                                                                          
  119.  *  EXIT-ERROR: AX = ERROR_VIO_INVALID_PARMS                                
  120.  *                                                                          
  121.  *  EFFECTS: If hardware specified and hardware is readable, the            
  122.  *           environment buffer is updated, if passed.                      
  123.  *                                                                          
  124.  *  INTERNAL REFERENCES:                                                    
  125.  *    ROUTINES: NONE                                                        
  126.  *                                                                          
  127.  *  EXTERNAL REFERENCES:                                                    
  128.  *    ROUTINES: AccessCLUT                                                  
  129.  *                                                                          
  130.  ****************************************************************************/
  131.  
  132. USHORT EXPENTRY GetColorLookup(Environment,ParmBlock,Function)
  133.  
  134.   ENVIRONMENT far *Environment;
  135.   VDH_CLUT far *ParmBlock;
  136.   ULONG Function;
  137.  
  138. {
  139.   USHORT rc,EnvBufferPassed;
  140.   int i,j;
  141.  
  142.   rc = ERROR_VIO_INVALID_PARMS;        /* Initialize to error               */
  143.   EnvBufferPassed = SEG(Environment);  /* Non-zero = TRUE                   */
  144.  
  145.   #if      VDH8514A                    /*  MS00                             */
  146.  
  147.   if (EnvBufferPassed)
  148.   {
  149.  
  150.     if (!(Environment->ModeData.fbType & NATIVE))
  151.     {                                  /* Passthru VGA modes                */
  152.       rc = (*ChainedCallVectorTable[Function-FnTextBufferUpdate])((char far *)
  153.             &Environment->VGAEnvironment, ParmBlock, Function);
  154.       return (rc);
  155.     } 
  156.   } 
  157.  
  158.   else
  159.   {
  160.     return (rc);
  161.   } 
  162.  
  163.   #endif        /*          VDH8514A,  MS00                                 */
  164.  
  165.   if ((Function == FnGetColorLookupTable) && /* Valid function request      */
  166.      (ParmBlock->Length >= sizeof(VDH_CLUT)) && /* Valid packet length      */
  167.      (ParmBlock->Flags <= 1) &&        /* Valid flags                       */
  168.      (ParmBlock->NumEntries) &&        /* Non-zero amount                   */
  169.      (ParmBlock->FirstEntry <= 0xFF) && /* Valid first entry                */
  170.      (ParmBlock->FirstEntry + ParmBlock->NumEntries <= 0xFF+1) &&
  171.      (EnvBufferPassed || (ParmBlock->Flags & UPDATE_HARDWARE)))
  172.   {
  173.  
  174. /*
  175. **  If requesting application is running in foreground,           
  176. **    - Return hardware value                                     
  177. **    - Otherwise return environment buffer value                 
  178. **  If requesting application is running in background,           
  179. **    - Return environment buffer value                           
  180. **     ( report error if environment buffer was not passed )      
  181. */
  182.  
  183.     rc = NO_ERROR;                     /* Initialize no error               */
  184.  
  185. /*
  186. **  Get CLUT values directly from the hardware                              
  187. */
  188.  
  189.     if (ParmBlock->Flags & UPDATE_HARDWARE)
  190.     {
  191.       AccessCLUT(GET, &ParmBlock->LookupTable);/* ring 2 callgate           */
  192.  
  193.   #if      VDHVGA                      /*  MS00                             */
  194.  
  195. /*
  196. **  Copy CLUT values from caller's parmeter area to the env buffer 
  197. */
  198.  
  199.       if (EnvBufferPassed)
  200.       {
  201.  
  202.         for (i = ParmBlock->FirstEntry, j = 0; j < ParmBlock->NumEntries;
  203.              i++, j++)
  204.         {
  205.           Environment->LookupTable[i] = ParmBlock->LookupTable[j]; /*  MS20 */
  206.         } 
  207.       } 
  208.     } 
  209.  
  210.     else
  211.     {                                  /* Caller in background              */
  212.  
  213. /*
  214. **  Copy CLUT values from env buffer to caller's parameter area   
  215. */
  216.  
  217.       for (i = ParmBlock->FirstEntry, j = 0; j < ParmBlock->NumEntries; 
  218.            i++, j ++)
  219.       {
  220.         ParmBlock->LookupTable[j] = Environment->LookupTable[i]; /*  MS20   */
  221.       } 
  222.  
  223.   #endif        /*        VDH8514A,  MS00                                   */
  224.     } 
  225.   } 
  226.  
  227.   return (rc);
  228. } 
  229.  
  230. /*****************************************************************************
  231.  *                                                                        
  232.  *  SUBROUTINE NAME: SetColorLookup                                       
  233.  *                                                                        
  234.  *  DESCRIPTIVE NAME: Set color lookup table                              
  235.  *                                                                        
  236.  *  FUNCTION: SetColorLookup is called by BVS to set a specified          
  237.  *            portion of the color lookup table settings                  
  238.  *                                                                        
  239.  *  ENTRY POINT: SetColorLookup                                           
  240.  *    LINKAGE:   CALL FAR ( via BVS-DDI call vector table entry 264 )     
  241.  *                                                                        
  242.  *  INPUT: (Passed on stack)                                              
  243.  *             FAR *Environment ( Environment buffer for the session )    
  244.  *             FAR *ParmBlock                                             
  245.  *                     USHORT Length = length of this packet              
  246.  *                     USHORT Flags  = 0 - Environment buffer only        
  247.  *                                     1 - Hardware also                  
  248.  *                     CLUTDATA far *LookupTable ( 0x00 - 0xFF )          
  249.  *                                     UCHAR Red                          
  250.  *                                     UCHAR Green                        
  251.  *                                     UCHAR Blue                         
  252.  *                     USHORT   FirstEntry                                
  253.  *                     USHORT   NumEntries                                
  254.  *             ULONG Function ( Call vector table entry = 264 )           
  255.  *                                                                        
  256.  *  EXIT-NORMAL: AX = 0                                                   
  257.  *               Portion of CLUT requested is set                         
  258.  *                                                                        
  259.  *  EXIT-ERROR: AX = ERROR_VIO_INVALID_PARMS                              
  260.  *                                                                        
  261.  *  INTERNAL REFERENCES:                                                  
  262.  *    ROUTINES: NONE                                                      
  263.  *                                                                        
  264.  *  EXTERNAL REFERENCES:                                                  
  265.  *    ROUTINES: AccessCLUT                                                
  266.  *                                                                        
  267.  ****************************************************************************/
  268.  
  269. USHORT EXPENTRY SetColorLookup(Environment,ParmBlock,Function)
  270.  
  271.   ENVIRONMENT far *Environment;
  272.   VDH_CLUT far *ParmBlock;
  273.   ULONG Function;
  274.  
  275. {
  276.  
  277.   USHORT rc,i,j,EnvBufferPassed;
  278.   rc = ERROR_VIO_INVALID_PARMS;        /* Initialize to error               */
  279.   EnvBufferPassed = SEG(Environment);  /* Non-zero = TRUE                   */
  280.  
  281.   #if      VDH8514A                    /*  MS00                             */
  282.  
  283.   if (EnvBufferPassed)
  284.   {
  285.  
  286.     if (!(Environment->ModeData.fbType&NATIVE))
  287.     {                                  /* Passthru VGA modes                */
  288.       rc = (*ChainedCallVectorTable[Function-FnTextBufferUpdate])((char far *)
  289.          &Environment->VGAEnvironment, ParmBlock, Function);
  290.       return (rc);
  291.     } 
  292.   } 
  293.  
  294.   else
  295.   {
  296.     return (rc);
  297.   } 
  298.   #endif        /*        VDH8514A,  MS00                                   */
  299.  
  300.   if ((Function == FnSetColorLookupTable) && /* Valid function request      */
  301.      (ParmBlock->Length >= sizeof(VDH_CLUT)) && /* Valid packet length      */
  302.      (ParmBlock->Flags <= 1) &&        /* Valid flags                       */
  303.      (ParmBlock->NumEntries) &&        /* Non-zero amount                   */
  304.      (ParmBlock->FirstEntry <= 0xFF) && /* Valid first entry                */
  305.      (ParmBlock->FirstEntry + ParmBlock->NumEntries <= 0xFF+1) &&
  306.      (EnvBufferPassed || (ParmBlock->Flags & UPDATE_HARDWARE)))
  307.   {
  308.  
  309. /*
  310. **  Parameters are valid - Update environment buffer if it was passed  
  311. **                       - Update hardware if in foreground            
  312. */
  313.  
  314.     rc = NO_ERROR;                     /* Initialize no error               */
  315.  
  316.   #if      VDHVGA                      /*  MS00                             */
  317.  
  318. /*
  319. **  Copy CLUT values from caller's parmeter area to the env buffer       
  320. */
  321.  
  322.     if (EnvBufferPassed)
  323.     {
  324.  
  325.       for (i = ParmBlock->FirstEntry, j = 0; j < ParmBlock->NumEntries; 
  326.            i++, j++)
  327.       {
  328.         Environment->LookupTable[i] = ParmBlock->LookupTable[j]; /*  MS20   */
  329.       } 
  330.  
  331.     } 
  332.  
  333.   #endif        /*        VDHVGA,  MS00                                     */
  334.  
  335. /*
  336. **  Set CLUT registers directly on the hardware                      
  337. */
  338.  
  339.     if (ParmBlock->Flags & UPDATE_HARDWARE)
  340.     {
  341.       AccessCLUT(SET, &ParmBlock->LookupTable);/* ring 2 callgate           */
  342.     } 
  343.   } 
  344.   return (rc);
  345. } 
  346.  
  347. #endif              /*  VDHVGA || VDH8514A    End of @S24 changes           */
  348.  
  349. #if      PALETTE_SUPPORT                   /* MS00                          */
  350.  
  351. /*****************************************************************************
  352.  *                                                                        
  353.  *  SUBROUTINE NAME: GetPaletteReg                                        
  354.  *                                                                        
  355.  *  DESCRIPTIVE NAME: Get palette registers                               
  356.  *                                                                        
  357.  *  FUNCTION: GetPaletteReg is called by BVS to return the specified      
  358.  *            portion of the palette registers.  If the request           
  359.  *            specifies hardware and the hardware is readable, the        
  360.  *            actual hardware setting will be read and returned.          
  361.  *            Otherwise the returned information will be taken from       
  362.  *            the environment buffer, if it has been passed.              
  363.  *                                                                        
  364.  *  ENTRY POINT: GetPaletteReg                                            
  365.  *    LINKAGE:   CALL FAR ( via BVS-DDI call vector table entry 273 )     
  366.  *                                                                        
  367.  *  INPUT: (Passed on stack)                                              
  368.  *             FAR *Environment ( Environment buffer for the session )    
  369.  *             FAR *ParmBlock                                             
  370.  *                     USHORT Length = length of this packet              
  371.  *                     USHORT Flags  = 0 - Environment buffer only        
  372.  *                                     1 - Hardware also                  
  373.  *                     FAR *PaletteBuffer                                 
  374.  *                     USHORT   FirstEntry                                
  375.  *                     USHORT   NumEntries                                
  376.  *             ULONG Function ( Call vector table entry = 273 )           
  377.  *                                                                        
  378.  *  EXIT-NORMAL: AX = 0                                                   
  379.  *               Requested palette registers are returned                 
  380.  *                                                                        
  381.  *  EXIT-ERROR: AX = ERROR_VIO_INVALID_PARMS                              
  382.  *                                                                        
  383.  *  EFFECTS: If hardware specified and hardware is readable, the          
  384.  *           environment buffer is updated, if passed.                    
  385.  *                                                                        
  386.  *  INTERNAL REFERENCES:                                                  
  387.  *    ROUTINES: NONE                                                      
  388.  *                                                                        
  389.  *  EXTERNAL REFERENCES:                                                  
  390.  *    ROUTINES: AccessHardware                                            
  391.  *                                                                        
  392.  ****************************************************************************/
  393.  
  394. USHORT EXPENTRY GetPaletteReg(Environment,ParmBlock,Function)
  395.  
  396.   ENVIRONMENT far *Environment;
  397.   VDH_PALETTE far *ParmBlock;
  398.   ULONG Function;
  399.  
  400. {
  401.  
  402.   USHORT rc,ColorMode,                 /*                               @C21*/
  403.          VideoOn,                      /*                               @C21*/
  404.          EnvBufferPassed;
  405.   int i,j;
  406.   REGADDRESS RegAddress;
  407.  
  408.  
  409.   rc = ERROR_VIO_INVALID_PARMS;        /* Initialize to error               */
  410.   EnvBufferPassed = SEG(Environment);  /* Non-zero = TRUE                   */
  411.  
  412.   if ((Function == FnGetPaletteRegisters) && /* Valid function request      */
  413.      (ParmBlock->Length >= sizeof(VDH_PALETTE)) && /* Valid packet length   */
  414.      (ParmBlock->Flags <= 1) &&        /* Valid flags                       */
  415.      (EnvBufferPassed || (ParmBlock->Flags & UPDATE_HARDWARE)))
  416.  
  417.     if ((ParmBlock->PaletteBuffer.NumEntries) && /* Non-zero amount         */
  418.        (ParmBlock->PaletteBuffer.FirstEntry <= 0x0F) && /* Valid first      */
  419.                                                         /*  entry           */
  420.        (ParmBlock->PaletteBuffer.FirstEntry +
  421.         ParmBlock->PaletteBuffer.NumEntries <= 0x0F+1))
  422.     {
  423.       rc = NO_ERROR;                   /* Initialize no error               */
  424.  
  425. /*
  426. **  If requesting application is running in foreground,                  
  427. **    - Return hardware value if hardware can be read                    
  428. **    - Otherwise return environment buffer value                        
  429. **     ( report error if write-only hardware and no env buffer passed )  
  430. **  If requesting application is running in background,                  
  431. **    - Return environment buffer value                                  
  432. **     ( report error if environment buffer was not passed )             
  433. */
  434.  
  435.       if ((ParmBlock->Flags&UPDATE_HARDWARE) && READABLE)
  436.       {
  437.  
  438.  #if      VDHVGA                        /* Read/write hardware              */
  439.                                         /*  MS00                            */
  440.  
  441. /*
  442. **  Get palette values directly from the hardware                     
  443. **  Accessing the Attribute regs resets the VideoEnable status so have
  444. **  TO RESET IT IF IT WAS ON BEFORE THE CALL                          
  445. */
  446.  
  447.         ColorMode = HardwareColor();   /* color/mono mode ( hardware )  @C21*/
  448.  
  449.         if (EnvBufferPassed)           /*                               @C21*/
  450.           VideoOn = Environment->VideoEnable;/*                         @C21*/
  451.  
  452.         else                           /*                               @C21*/
  453.           AccessVideoEnable(ColorMode, GET, &VideoOn);/*                @C21*/
  454.         RegAddress.AddressPort = AttAddressPort;
  455.         RegAddress.DataPort = AttDataReadPort;
  456.         RegAddress.ColorAdjust = NONE;
  457.         RegAddress.Flags = Attributes_CMD;
  458.         AccessHardware(&RegAddress, WORDS, HardwareColor(), GET, 
  459.                       (REGDATA far *)&ParmBlock->PaletteBuffer);
  460.  
  461.         if (VideoOn)                   /*                               @C21*/
  462.           AccessVideoEnable(ColorMode, SET, &VideoOn);/*                @C21*/
  463.  
  464.         if (EnvBufferPassed)
  465.  
  466. /*
  467. **  Copy palette values from caller's parmeter area to the env buffer        
  468. */
  469.  
  470.           for (i = ParmBlock->PaletteBuffer.FirstEntry, j = 0; 
  471.                j < ParmBlock->PaletteBuffer.NumEntries; i++, j++)
  472.  
  473.             Environment->Hardware.Attributes.Regs.Palettes[i] = 
  474.                     (UCHAR) ParmBlock->PaletteBuffer.DataArea[j];
  475.  
  476.   #endif        /*        VDHVGA,  MS00                                     */
  477.       } 
  478.  
  479.       else
  480.       {
  481.  
  482. /*
  483. **  Requesting application is running in the background                      
  484. */
  485.  
  486.         if (EnvBufferPassed)
  487.  
  488. /*
  489. **  Copy palette values from env buffer to caller's parameter area           
  490. */
  491.  
  492.           for (i = ParmBlock->PaletteBuffer.FirstEntry, j = 0;
  493.                j < ParmBlock->PaletteBuffer.NumEntries; i++, j++)
  494.  
  495.             ParmBlock->PaletteBuffer.DataArea[j] = (USHORT)
  496.                Environment->Hardware.Attributes.Regs.Palettes[i];
  497.  
  498.         else
  499.           rc = ERROR_VIO_INVALID_PARMS;/* Not FG OR write-only, no env      */
  500.                                        /* buffer                            */
  501.       } 
  502.     } 
  503.  
  504.  
  505.   return (rc);
  506. } 
  507.  
  508. /*****************************************************************************
  509.  *                                                                         
  510.  *  SUBROUTINE NAME: SetPaletteReg                                         
  511.  *                                                                         
  512.  *  DESCRIPTIVE NAME: Set palette registers                                
  513.  *                                                                         
  514.  *  FUNCTION: SetPaletteReg is called by BVS to set the specified          
  515.  *            portion of the palette registers.  If the request            
  516.  *            specifies hardware the hardware and the environment          
  517.  *            buffer, if passed, will be updated.  Otherwise just the      
  518.  *            environment buffer, if passed, will be updated.              
  519.  *                                                                         
  520.  *  ENTRY POINT: SetPaletteReg                                             
  521.  *    LINKAGE:   CALL FAR ( via BVS-DDI call vector table entry 274 )      
  522.  *                                                                         
  523.  *  INPUT: (Passed on stack)                                               
  524.  *             FAR *Environment ( Environment buffer for the session )     
  525.  *             FAR *ParmBlock                                              
  526.  *                     USHORT Length = length of this packet               
  527.  *                     USHORT Flags  = 0 - Environment buffer only         
  528.  *                                     1 - Hardware also                   
  529.  *                     FAR *PaletteBuffer                                  
  530.  *                     USHORT   FirstEntry                                 
  531.  *                     USHORT   NumEntries                                 
  532.  *             ULONG Function ( Call vector table entry = 274 )            
  533.  *                                                                         
  534.  *  EXIT-NORMAL: AX = 0                                                    
  535.  *               Requested palette registers are set                       
  536.  *                                                                         
  537.  *  EXIT-ERROR: AX = ERROR_VIO_INVALID_PARMS                               
  538.  *                                                                         
  539.  *  INTERNAL REFERENCES:                                                   
  540.  *    ROUTINES: NONE                                                       
  541.  *                                                                         
  542.  *  EXTERNAL REFERENCES:                                                   
  543.  *    ROUTINES: AccessHardware                                             
  544.  *                                                                         
  545.  ****************************************************************************/
  546.  
  547. USHORT EXPENTRY SetPaletteReg(Environment,ParmBlock,Function)
  548.  
  549.   ENVIRONMENT far *Environment;
  550.   VDH_PALETTE far *ParmBlock;
  551.   ULONG Function;
  552.  
  553. {
  554.  
  555.   USHORT rc,i,j,ColorMode,VideoOn,     /*                               @C21*/
  556.          EnvBufferPassed;
  557.   REGADDRESS RegAddress;
  558.  
  559.  
  560.   rc = ERROR_VIO_INVALID_PARMS;        /* Init to error                     */
  561.   EnvBufferPassed = SEG(Environment);  /* Non-zero = TRUE                   */
  562.  
  563.   if ((Function == FnSetPaletteRegisters) && /* Valid function request      */
  564.      (ParmBlock->Length >= sizeof(VDH_PALETTE)) && /* Valid packet length   */
  565.      (ParmBlock->Flags <= 1) &&        /* Valid flags                       */
  566.      (ParmBlock->PaletteBuffer.FirstEntry <= 0x0F) && /*     @@AVALID1STNTRY*/
  567.      (EnvBufferPassed || (ParmBlock->Flags&UPDATE_HARDWARE)))
  568.  
  569.     if ((ParmBlock->PaletteBuffer.NumEntries) && /* Non-zero amount         */
  570.        (ParmBlock->PaletteBuffer.FirstEntry +
  571.         ParmBlock->PaletteBuffer.NumEntries <= 0x0F+1))
  572.     {
  573.       rc = NO_ERROR;                   /* Initialize no error               */
  574.  
  575. /*
  576. **  Parameters are valid - Update environment buffer if it was passed       
  577. **                       - Update hardware if in foreground                  
  578. */
  579.  
  580.       if (EnvBufferPassed)
  581.       {
  582.  
  583. /*
  584. **  Copy palette values from caller's parmeter area to the env buffer        
  585. */
  586.  
  587.         for (i = ParmBlock->PaletteBuffer.FirstEntry, j = 0; 
  588.              j < ParmBlock->PaletteBuffer.NumEntries; i++, j++)
  589.  
  590.           Environment->Hardware.Attributes.Regs.Palettes[i] = 
  591.                 (UCHAR) ParmBlock->PaletteBuffer.DataArea[j];
  592.  
  593.       } 
  594.  
  595.       if (ParmBlock->Flags&UPDATE_HARDWARE)
  596.       {
  597.  
  598. /*
  599. **  Set palette values directly from the hardware                            
  600. **  Accessing the Attribute regs resets the VideoEnable status so have
  601. **  TO RESET IT IF IT WAS ON BEFORE THE CALL                          
  602. */
  603.  
  604.         RegAddress.AddressPort = AttAddressPort;
  605.         RegAddress.DataPort = AttDataWritePort;
  606.         RegAddress.ColorAdjust = NONE;
  607.         RegAddress.Flags = Attributes_CMD;
  608.  
  609.  #if      VDHVGA                       /* Read/write hardware               */
  610.                                        /*  MS00                             */
  611.         ColorMode = HardwareColor();   /* color/mono mode ( hardware )      */
  612.  
  613.   #else                                /* Write-only hardware               */
  614.         ColorMode = Environment->ModeData.fbType & NOT_MONO;/* color/mono   */
  615.                                        /* mode (env buffer)                 */
  616.  
  617.   #endif        /*        VDHVGA,  MS00                                     */
  618.  
  619.         if (EnvBufferPassed)           /*                               @C21*/
  620.           VideoOn = Environment->VideoEnable;/*                         @C21*/
  621.  
  622.         else                           /*                               @C21*/
  623.  
  624.   #if      VDHVGA                      /*                          @C21,MS00*/
  625.   AccessVideoEnable(ColorMode, GET, &VideoOn);/*                        @C21*/
  626.  
  627.   #else                                /*                          @C21,MS00*/
  628.   VideoOn = 1;                         /*                               @C21*/
  629.   #endif                               /*   VDHVGA,   @C21,MS00             */
  630.  
  631.         AccessHardware(&RegAddress, WORDS, ColorMode, SET, 
  632.                       (REGDATA far *) &ParmBlock->PaletteBuffer);
  633.  
  634.         if (VideoOn)                   /*                               @C21*/
  635.           AccessVideoEnable(ColorMode, SET, &VideoOn);/*                @C21*/
  636.       } 
  637.     } 
  638.  
  639.   return (rc);
  640. } 
  641.  
  642. #endif        /*        PALETTE_SUPPORT,  MS00                              */
  643.  
  644. #if      VDHVGA                         /*  MS21 - BEGIN                    */
  645.  
  646. /***************************************************************************
  647.  *
  648.  * FUNCTION NAME = SetTextGrays(Environment)
  649.  *
  650.  * DESCRIPTION   = 
  651.  *                                                                      
  652.  *     When running on an LCD in text mode, this programs the gray scale
  653.  *     so that foreground/background combinations have nearly the same  
  654.  *     contrast as the standard colors do on a color monitor.           
  655.  *                                                                      
  656.  * INPUT         = *Environment;
  657.  * OUTPUT        = NONE
  658.  *
  659.  * RETURN-NORMAL = NONE
  660.  * RETURN-ERROR  = NONE
  661.  *
  662.  **************************************************************************/
  663.  
  664. void PASCAL near SetTextGrays(Environment)
  665.  
  666.   ENVIRONMENT far *Environment;        /*  Session environment buffer       */
  667.  
  668. {
  669.   REGADDRESS RegAddress;
  670.   REGDATA RegData;
  671.   UCHAR DataArea;
  672.   USHORT i;
  673.  
  674.  
  675.   if ((OEMFlags&(PRISM_VGA|CRYSTAL_VGA)) /*  LCD adapter                    */
  676.      && (Environment->ModeData.fbType == NOT_MONO))
  677.   {                                    /*  & Color text mode                */
  678.                                        /*  = Set gray scale                 */
  679.     /*
  680.     ** Open access to extended VGA registers
  681.     */
  682.     RegAddress.AddressPort = GraphAddressPort;
  683.     RegAddress.DataPort = GraphDataPort;
  684.     RegAddress.Flags = NONE;
  685.     RegData.DataArea = &DataArea;
  686.     RegData.FirstEntry = VGA_ENV_REG;
  687.     RegData.NumEntries = 1;
  688.     DataArea = VGA_UNLOCK;
  689.     AccessHardware(&RegAddress, BYTES, NONE, SET, &RegData);
  690.  
  691.     /*
  692.     ** Map 16 colors onto gray levels.
  693.     */
  694.     for (i = 0; i < 16; i++)
  695.     {
  696.  
  697.       /*
  698.       ** Use color's palette value as index into gray scale LUT...
  699.       */
  700.       RegData.FirstEntry = LCD_GRAYSCALE_ADDR;
  701.       DataArea = Environment->Hardware.Attributes.Regs.Palettes[i];
  702.       AccessHardware(&RegAddress, BYTES, NONE, SET, &RegData);
  703.  
  704.       /*
  705.       ** then set that entry to a gray level.
  706.       */
  707.       RegData.FirstEntry = LCD_GRAYSCALE_DATA;
  708.       DataArea = (OEMFlags&CRYSTAL_VGA)?LCDGrayLUT[i] /*  range 0..31       */
  709.          : LCDGrayLUT[i] >> 1;                         /*  range 0..15       */
  710.       AccessHardware(&RegAddress, BYTES, NONE, SET, &RegData);
  711.     } 
  712.  
  713.     /*
  714.     ** Close access to extended VGA registers
  715.     */
  716.     RegData.FirstEntry = VGA_ENV_REG;
  717.     DataArea = VGA_LOCK;
  718.     AccessHardware(&RegAddress, BYTES, NONE, SET, &RegData);
  719.   } 
  720. } 
  721.  
  722. #endif            /*    VDHVGA,  @MS21 - END                                */
  723.  
  724.