home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ddkx86v5.zip / DDKX86 / SRC / VDH / VDHMODE.C < prev    next >
C/C++ Source or Header  |  1995-04-14  |  79KB  |  1,917 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 = VDHMODE.c
  16.  *
  17.  * DESCRIPTIVE NAME = Base video device handlers - Mode, CLUT, Palette  
  18.  *
  19.  *
  20.  * VERSION      V2.0
  21.  *
  22.  * DATE         
  23.  *
  24.  * DESCRIPTION  This source file contains VDH entry points
  25.  *              which get/set the video mode.
  26.  *
  27.  *              NOTE: These routines execute as ring 2 conforming
  28.  *
  29.  * FUNCTIONS    GetMode,         SetMode                             
  30.  *              SetHWMode, SetEnvMode, GetModeIndex                  
  31.  *
  32.  * NOTES        NONE
  33.  *
  34.  * STRUCTURES   NONE
  35.  *
  36.  * EXTERNAL REFERENCES
  37.  *
  38.  *              NONE
  39.  *
  40.  * EXTERNAL FUNCTIONS  SaveRegs, RestoreRegs        
  41.  *                     AccessHardware, AccessCLUT   
  42.  *                     PhysToUVirt, FreePhysToUVirt 
  43.  *
  44. */
  45.  
  46. /*
  47. **  Include files                                                             
  48. */
  49.  
  50. #define  INCL_BASE                     /* ALL of OS/2 Base                  */
  51. #define  INCL_OS2STD                   /* Needed for NULL definition in     */
  52.                                        /* OS2STD.H                          */
  53. #include <os2.h>
  54. #include "vdhctl.h"                    /* Conditional compilation control   */
  55. #include "vdh.h"                       /* Type definitions                  */
  56.  
  57. /*
  58. **  Externally defined global variables                                       
  59. */
  60.  
  61. extern VIDEOMODE Modes[];              /* Supported modes                   */
  62. extern MEMORYMAPS MemoryMaps[];        /* Memory map info for each mode     */
  63. extern UCHAR READABLE;
  64. extern ULONG PartialSaveSize;          /* Room required to save entire PVB  
  65.                                           in the popup mode                 */
  66. extern USHORT VGA_PRESENT;             /* TRUE if VGA VDH has been          */
  67.                                        /* installed                         */
  68. extern USHORT(APIENTRY *ChainedCallVectorTable[MaxFn])();/*             @T24*/
  69. extern VIDEOHARDWARE VideoHardware;    /*                               @T39*/
  70. extern USHORT OEMFlags;                /* @MS27 */
  71. extern USHORT SVGAPresent;             /* @drw */
  72.  
  73. /*
  74. **  Parameters to ring 2 routines                                             
  75. */
  76.  
  77. extern CLUTDATA far ColorCLUT;
  78. extern CLUTDATA far MonoCLUT;
  79. extern CLUTDATA far SumCLUT;
  80. extern CLUTDATA far ColorCLUTLow;      /* @MS13 */
  81. extern CLUTDATA far ColorCLUT256;      /* @MS13 */
  82. extern CLUTDATA far SumCLUTLow;        /* @MS13 */
  83. extern CLUTDATA far SumCLUT256;        /* @MS13 */
  84. extern USHORT far ColorCLUTCount;      /* @MS13 */
  85. extern USHORT far ColorCLUTLowCount;   /* @MS13 */
  86. extern USHORT far ColorCLUT256Count;   /* @MS13 */
  87. extern USHORT far MonoCLUTCount;       /* @MS13 */
  88. extern USHORT far SumCLUTCount;        /* @MS13 */
  89. extern USHORT far SumCLUTLowCount;     /* @MS13 */
  90. extern USHORT far SumCLUT256Count;     /* @MS13 */
  91. extern CLUTDATA far *LCLUT;            /* @BB9, @S40F*/
  92.  
  93. /*****************************************************************************
  94.  *                                                                          
  95.  *  SUBROUTINE NAME: GetMode                                                
  96.  *                                                                          
  97.  *  DESCRIPTIVE NAME: Get current video mode setting                        
  98.  *                                                                          
  99.  *  FUNCTION: GetMode is called by BVS to get the current mode setting.     
  100.  *            If the request specifies hardware and the hardware is         
  101.  *            readable, the actual hardware setting will be read and        
  102.  *            returned.  Otherwise the returned information will be         
  103.  *            taken from the environment buffer, if it has been passed.     
  104.  *                                                                          
  105.  *  ENTRY POINT: GetMode                                                    
  106.  *    LINKAGE:   CALL FAR ( via BVS-DDI call vector table entry 271 )       
  107.  *                                                                          
  108.  *  INPUT: (Passed on stack)                                                
  109.  *             FAR *Environment ( Environment buffer for the session )      
  110.  *             FAR *ParmBlock                                               
  111.  *                     USHORT Length = length of this packet                
  112.  *                     USHORT Flags  = 0 - Environment buffer only          
  113.  *                                     1 - Hardware also                    
  114.  *                     VIOMODEINFO FAR *ModeDataPTR                         
  115.  *             ULONG Function ( Call vector table entry = 271 )             
  116.  *         (Referenced)                                                     
  117.  *             Modes[] (global data - table of supported video modes )      
  118.  *                                                                          
  119.  *  EXIT-NORMAL: AX = 0                                                     
  120.  *               Current mode setting is returned                           
  121.  *                                                                          
  122.  *  EXIT-ERROR: AX = ERROR_VIO_INVALID_PARMS                                
  123.  *                                                                          
  124.  *  EFFECTS: If hardware specified and hardware is readable, the            
  125.  *           environment buffer is updated, if passed.                      
  126.  *           If the length of ModeData does not exactly fit a               
  127.  *           parameter, the length is adjusted and returned.                
  128.  *                                                                          
  129.  *  INTERNAL REFERENCES:                                                    
  130.  *    ROUTINES: NONE                                                        
  131.  *                                                                          
  132.  *  EXTERNAL REFERENCES:                                                    
  133.  *    ROUTINES: SaveRestoreHW, SetEnvMode                                   
  134.  *                                                                          
  135.  ****************************************************************************/
  136.  
  137.  
  138. USHORT EXPENTRY GetMode(Environment,ParmBlock,Function)
  139.  
  140.   ENVIRONMENT far *Environment;
  141.   VDH_MODE    far *ParmBlock;
  142.   ULONG           Function;
  143.  
  144. {
  145.   USHORT rc,ModeIndex,EnvBufferPassed;
  146.   UCHAR i,MapMask,RegValue;
  147.   USHORT NumBitplanes;
  148.   REGDATA RegData;
  149.   REGADDRESS RegAddress;
  150.   ENVIRONMENT far *TempEnv;
  151.   SEL Selector;
  152.   UCHAR TempChar;                      /*                              @TB21*/
  153.   VIDEOMODE far *pCurMode;             /* Reduce level of indirection,   @S8*/
  154.   VIOMODEINFO far *pReqMode;           /* Reduce level of indirection,   @S8*/
  155.   unsigned register ReqModeLen;        /* Eliminate segment loading,     @S8*/
  156.   int SumCLUT_found,ii,j;              /*                               @BB9*/
  157.  
  158.   rc = ERROR_VIO_INVALID_PARMS;        /* Initialize to error               */
  159.   EnvBufferPassed = SEG(Environment);  /* Non-zero = TRUE                   */
  160.  
  161.   if ((Function == FnGetMode) &&       /* Valid function request            */
  162.      (ParmBlock->Length >= sizeof(VDH_MODE)) && /* Valid packet length      */
  163.      (ParmBlock->Flags <= 1) &&        /* Valid flags                       */
  164.      (EnvBufferPassed || (ParmBlock->Flags&UPDATE_HARDWARE)))
  165.   {
  166.  
  167.     rc = NO_ERROR;                     /* Initialize no error               */
  168.     ReqModeLen = (pReqMode = ParmBlock->ModeDataPTR)->cb;/*              @S8*/
  169.  
  170.     if (ReqModeLen > sizeof(VIOMODEINFO))
  171.     {                                  /*                               @S25*/
  172.       ReqModeLen = MinDLen_Mode_Vres;  /*                               @S25*/
  173.     }                                  /*                               @S25*/
  174.  
  175.     if (ReqModeLen < Mode_Return_Length)/*                               @@A*/
  176.       rc = ERROR_VIO_INVALID_LENGTH;   /*                                @@A*/
  177.  
  178.     else
  179.  
  180.       if (ReqModeLen == Mode_Return_Length)/*                            @@A*/
  181.  
  182.         ReqModeLen = sizeof(VIOMODEINFO);/*                              @@A*/
  183.  
  184.       else
  185.       {                                /*                                @@A*/
  186.  
  187.         /*
  188.         **  If requesting application is running in foreground,                    
  189.         **    - Return hardware value if hardware can be read                      
  190.         **    - Otherwise return environment buffer value                          
  191.         **    ( report error if write-only hardware and no env buffer passed )
  192.         **  If requesting application is running in background,                    
  193.         **    - Return environment buffer value                                    
  194.         **     ( report error if environment buffer was not passed )               
  195.         */
  196.                                                                            
  197.  
  198.         if ((ParmBlock->Flags&UPDATE_HARDWARE) && READABLE)
  199.         {
  200.  
  201. #if      VDHVGA                        /* Read/write hardware               */
  202.                                        /* @MS00 */
  203.  
  204.           /*
  205.           **  Allocate temporary storage to temporary environment buffer                
  206.           */
  207.  
  208.           if (!(rc = DosAllocSeg(sizeof(ENVIRONMENT), (PSEL)&Selector, 0)))
  209.           {
  210.             TempEnv = (ENVIRONMENT far *)MakeFarPTR(Selector, 0);
  211.  
  212.             /*
  213.             **  Read all registers directly from the hardware                             
  214.             */
  215.  
  216.             TempEnv->VideoEnable = 1;  /* Assume video ON               @T34*/
  217.             SaveRestoreHW(TempEnv, GET);
  218.             ModeIndex = GetModeIndex(TempEnv);/* Get mode index + 1         */
  219.  
  220.             if (!ModeIndex--)
  221.               rc = ERROR_VIO_MODE;     /* Somebody corrupted the registers  */
  222.  
  223.             if (!rc && EnvBufferPassed)
  224.  
  225.               /*
  226.               **  Update environment buffer with current mode setting                       
  227.               */
  228.  
  229.               SetEnvMode((UCHAR)ModeIndex, Environment, TempEnv, 0);/*  @T70*/
  230.  
  231.             /*
  232.             **  Deallocate temporary storage to temporary environment buffer              
  233.             */
  234.  
  235.             DosFreeSeg(Selector);
  236.           } 
  237. #endif             /*     VDHVGA @MS00 */
  238.         } 
  239.  
  240.         else
  241.         {
  242.  
  243.           /*
  244.           **  Requesting application is running in the "background"                     
  245.           */
  246.  
  247.           if (EnvBufferPassed)
  248.  
  249.             /*
  250.             **  Retrieve mode setting from environment buffer                             
  251.             */
  252.  
  253.             ModeIndex = Environment->ModeIndex;
  254.  
  255.           else
  256.             rc = ERROR_VIO_INVALID_PARMS;/* Not FG OR write-only, no env    */
  257.                                          /* buffer                          */
  258.         } 
  259.  
  260. #if      VDH8514A                        /* @MS00 */
  261.  
  262.         /*
  263.         **  If the current mode in the environment buffer is an 8514/A native         
  264.         **  mode, return the appropriate information.  Otherwise call GetMode         
  265.         **  in VDHVGA.DLL                                                             
  266.         **                                                                            
  267.         */
  268.  
  269.         if (!Environment->NATIVE_MODE)
  270.           rc = ChainedVDHGetMode((ENVIRONMENT far *)&Environment->VGAEnvironment,
  271.                                   ParmBlock, Function);         /* not      */
  272.                                                                 /* native   */
  273.  
  274.         else
  275.  
  276.           /* Native mode - return the mode data                             */
  277.  
  278. #endif    
  279.  
  280.           if (!rc)
  281.           {
  282.             pCurMode = (VIDEOMODE far *)&Modes[ModeIndex].cb;/*          @S8*/
  283.  
  284.             /*
  285.             **  Mode type:
  286.             **  xxxxxxxb b = 0 Monochrome,  b = 1 Other
  287.             **  xxxxxxbx b = 0 Text,        b = 1 Graphics
  288.             **  xxxxxbxx b = 0 Color burst, b = 1 Color burst disabled
  289.             **  xxxxbxxx b = 0 Normal mode, b = 1 Advanced function ( native )
  290.             */
  291.  
  292.             pReqMode->fbType = pCurMode->fbType;
  293.  
  294.             if (EnvBufferPassed && !(ParmBlock->Flags&UPDATE_HARDWARE))
  295.             {
  296.  
  297. #if      VDHVGA                        /* Read/write hardware               */
  298.                                        /* @MS00 */
  299.  
  300.               if ((Environment->ModeData.fbType&NOT_MONO) /* @MS13 */
  301.                  && !(Environment->ModeData.fbType&GRAPHICS))
  302.               {                        /* @MS13 */
  303.                 /*
  304.                 ** We are looking for any monochrome CLUT, not a particular
  305.                 ** one. Thecharacteristic of a monochrome palette is the same
  306.                 ** intensity for red, green, and blue in each row.
  307.                 */
  308.                 register irow = 0;     /* @MS13 */
  309.  
  310.  
  311.                 while ((irow < 0xFF+1) /* @MS13 */
  312.                    && (Environment->LookupTable[irow].Red ==   /* @MS13 */
  313.                       Environment->LookupTable[irow].Green)    /* @MS13 */
  314.                    && (Environment->LookupTable[irow].Red ==   /* @MS13 */
  315.                       Environment->LookupTable[irow].Blue)     /* @MS13 */
  316.                    )
  317.                   irow++;                                      /* @MS13 */
  318.  
  319.                 /*
  320.                 **  If loop completed, assume black & white
  321.                 */
  322.                 if (irow == 0xFF+1)
  323.                   Environment->ModeData.fbType |= NO_CLR_BRST; /* @MS13 */
  324.               }                                                /* @MS13 */
  325. #endif    
  326.               pReqMode->fbType = Environment->ModeData.fbType;
  327.             } 
  328.  
  329.             if (ReqModeLen < MinDLen_Mode_Color)
  330.               ReqModeLen = MinDLen_Mode_Type;
  331.  
  332.             else
  333.             {
  334.  
  335.               /*
  336.               **  Color ( power of 2 )                                                      
  337.               */
  338.  
  339.               pReqMode->color = pCurMode->color;
  340.  
  341.               if (ReqModeLen < MinDLen_Mode_Column)
  342.                 ReqModeLen = MinDLen_Mode_Color;
  343.  
  344.               else
  345.               {
  346.  
  347.                 /*
  348.                 **  Number of text columns: 40 or 80                                          
  349.                 */
  350.  
  351.                 pReqMode->col = pCurMode->col;
  352.  
  353.                 if (ReqModeLen < MinDLen_Mode_Row)
  354.                   ReqModeLen = MinDLen_Mode_Column;
  355.  
  356.                 else
  357.                 {
  358.  
  359.                   /*
  360.                   **  Number of text rows                                                       
  361.                   */
  362.  
  363.                   pReqMode->row = pCurMode->row;
  364.  
  365.                   if (EnvBufferPassed && !(ParmBlock->Flags&UPDATE_HARDWARE))
  366.                     pReqMode->row = Environment->ModeData.row;
  367.  
  368.                   if (ReqModeLen < MinDLen_Mode_Hres)
  369.                     ReqModeLen = MinDLen_Mode_Row;
  370.  
  371.                   else
  372.                   {
  373.  
  374.                     /*
  375.                     **  Horizontal resolution                                                     
  376.                     */
  377.  
  378.                     pReqMode->hres = pCurMode->hres;
  379.  
  380.                     if (ReqModeLen < MinDLen_Mode_Vres)
  381.                       ReqModeLen = MinDLen_Mode_Hres;
  382.  
  383.                     else
  384.                     {
  385.  
  386.                       /*
  387.                       **  Vertical resolution                                                       
  388.                       */
  389.  
  390.                       pReqMode->vres = pCurMode->vres;
  391.  
  392.                       if (ReqModeLen < MinDLen_Mode_FormatID)
  393.                         ReqModeLen = MinDLen_Mode_Vres;
  394.  
  395.                       else
  396.                       {
  397.  
  398.                         /*
  399.                         **  Attribute format ID                                                       
  400.                         */
  401.  
  402.                         if (EnvBufferPassed)/*                           @P1*/
  403.                           pReqMode->fmt_ID = Environment->ModeData.fmt_ID;
  404.  
  405.                         else           /*                                @P1*/
  406.                           pReqMode->fmt_ID = pCurMode->fmt_ID;
  407.  
  408.                         if (ReqModeLen < MinDLen_Mode_Attrib)
  409.                           ReqModeLen = MinDLen_Mode_FormatID;
  410.  
  411.                         else
  412.                         {
  413.  
  414.                           /*
  415.                           **  Attribute                                                                 
  416.                           */
  417.  
  418.                           if (EnvBufferPassed)/*                         @P1*/
  419.                             pReqMode->attrib = Environment->ModeData.attrib;
  420.  
  421.                           else         /*                                @P1*/
  422.                             pReqMode->attrib = pCurMode->attrib;
  423.  
  424.                           if (ReqModeLen < MinDLen_Mode_BufStart)
  425.                             ReqModeLen = MinDLen_Mode_Attrib;
  426.  
  427.                           else
  428.                           {
  429.  
  430.                             /*
  431.                             **  Physical display buffer start address                                     
  432.                             */
  433.  
  434. #if      VDH8514A                      /* @MS00 */
  435.                             pReqMode->BufferAddress = UNKNOWN;
  436.  
  437. #else
  438.                             pReqMode->BufferAddress = MemoryMaps
  439.                                [pCurMode->MemMap].Start.FullAddress;
  440. #endif    
  441.  
  442.                             if (ReqModeLen < MinDLen_Mode_BufLen)
  443.                               ReqModeLen = MinDLen_Mode_BufStart;
  444.  
  445.                             else
  446.                             {
  447.  
  448.                               /*
  449.                               **  Physical display buffer length                                            
  450.                               */
  451.  
  452. #if      VDH8514A                      /* @MS00 */
  453.                               pReqMode->BufferLength = UNKNOWN;
  454.  
  455. #else
  456.                               pReqMode->BufferLength = pReqMode->fbType
  457.                                  &GRAPHICS?MemoryMaps[pCurMode->MemMap].
  458.                                  TotalSize:2*pReqMode->col *pReqMode->row;
  459.  
  460.                               if (pCurMode->MemMap == MemMap_LoRes)
  461.                                 pReqMode->BufferLength = 16000;/*      @@TB9*/
  462. #endif    
  463.  
  464.                               if (ReqModeLen < MinDLen_Mode_FullBufSz)
  465.                                 ReqModeLen = MinDLen_Mode_BufLen;
  466.  
  467.                               else
  468.                               {
  469.  
  470.                                 /*
  471.                                 **  Full physical display buffer size                                         
  472.                                 */
  473.  
  474.                                 pReqMode->FullBufferSize = 
  475.                                    pReqMode->BufferLength;
  476.  
  477.                                 /*
  478.                                 **  Add size of font buffer only if text mode
  479.                                 */
  480.  
  481.                                 if (!(pCurMode->fbType&GRAPHICS))
  482.                                   pReqMode->FullBufferSize = 
  483.                                      pReqMode->BufferLength+ 
  484.                                      (ULONG)256*(ULONG)
  485.                                            (Environment->ModeData.vres/
  486.                                            Environment->ModeData.row);
  487.  
  488.                                 if (pReqMode->attrib == WorldAttrCount)
  489.                                   pReqMode->FullBufferSize *= WorldAttrMult;
  490.  
  491.                                 if (ReqModeLen < MinDLen_Mode_PartBufSz)
  492.                                   ReqModeLen = MinDLen_Mode_FullBufSz;
  493.  
  494.                                 else
  495.                                 {
  496.  
  497.                                   /*
  498.                                   **  Full physical display buffer size of
  499.                                   **  popup mode
  500.                                   */
  501.  
  502.                                   pReqMode->PartialBufferSize = 
  503.                                      PartialSaveSize;
  504.  
  505.                                   if (pReqMode->attrib == WorldAttrCount)
  506.                                     pReqMode->PartialBufferSize *= 
  507.                                        WorldAttrMult;
  508.  
  509.                                   if (ReqModeLen < MinDLen_Mode_ExtData)
  510.                                     ReqModeLen = MinDLen_Mode_PartBufSz;
  511.  
  512.                                   else
  513.                                   {
  514.  
  515.                                     /*
  516.                                     **  Pointer to extended mode data area
  517.                                     */
  518.  
  519.                                     pReqMode->ExtDataArea = (UCHAR far *)NULL;
  520.                                     ReqModeLen = MinDLen_Mode_ExtData;
  521.                                   } 
  522.                                 }      /* else get PartialBufferSize        */
  523.                               }        /* else get FullBufferSize           */
  524.                             }          /* else get BufferLength             */
  525.                           }            /* else get BufferAddress            */
  526.                         }              /* else get Attribute                */
  527.                       }                /* else get Format ID                */
  528.                     }                  /* else get Vres                     */
  529.                   }                    /* else get Hres                     */
  530.                 }                      /* else get rows                     */
  531.               }                        /* else get columns                  */
  532.             }                          /* else get color                    */
  533.           }                            /* if !rc                            */
  534.       }                                /* else good mode length          @@A*/
  535.   }                                    /* if good parameters                */
  536.  
  537.   if (!rc)
  538.   {                                    /*                                @S8*/
  539.     pReqMode->cb = ReqModeLen;         /*                                @S8*/
  540.   }                                    /*                                @S8*/
  541.  
  542.  
  543.   return (rc);
  544. } 
  545.  
  546. /*****************************************************************************
  547.  *                                                                          
  548.  *  SUBROUTINE NAME: SetMode                                                
  549.  *                                                                          
  550.  *  DESCRIPTIVE NAME: Set video mode                                        
  551.  *                                                                          
  552.  *  FUNCTION: SetMode is called by BVS to set the video mode.               
  553.  *            If the request specifies hardware, the hardware and the       
  554.  *            environment buffer, if passed, will be updated.               
  555.  *            Otherwise just the environment buffer, if passed, will        
  556.  *            be updated.                                                   
  557.  *                                                                          
  558.  *  ENTRY POINT: SetMode                                                    
  559.  *    LINKAGE:   CALL FAR ( via BVS-DDI call vector table entry 272 )       
  560.  *                                                                          
  561.  *  INPUT: (Passed on stack)                                                
  562.  *             FAR *Environment ( Environment buffer for the session )      
  563.  *             FAR *ParmBlock                                               
  564.  *                     USHORT Length = length of this packet                
  565.  *                     USHORT Flags  = 0 - Environment buffer only          
  566.  *                                     1 - Hardware also                    
  567.  *                     VIOMODEINFO FAR *ModeDataPTR                         
  568.  *             ULONG Function ( Call vector table entry = 272 )             
  569.  *         (Referenced)                                                     
  570.  *             Modes[] (global data - table of supported video modes )      
  571.  *                                                                          
  572.  *  EXIT-NORMAL: AX = 0                                                     
  573.  *               Video mode is set                                          
  574.  *                                                                          
  575.  *  EXIT-ERROR: AX = ERROR_VIO_INVALID_PARMS                                
  576.  *                                                                          
  577.  *  INTERNAL REFERENCES:                                                    
  578.  *    ROUTINES: NONE                                                        
  579.  *                                                                          
  580.  *  EXTERNAL REFERENCES:                                                    
  581.  *    ROUTINES: SetHWMode                                                   
  582.  *                                                                          
  583.  ****************************************************************************/
  584.  
  585.  
  586. USHORT EXPENTRY SetMode(Environment,ParmBlock,Function)
  587.  
  588.   ENVIRONMENT far *Environment;
  589.   VDH_MODE    far *ParmBlock;
  590.   ULONG           Function;
  591.  
  592. {
  593.   USHORT rc,i,tempflags,MODE_FOUND,EnvBufferPassed;
  594.   UCHAR FONT_AVAILABLE;                /*                              @@TB1*/
  595.   VIDEOMODE far *pCurMode;             /* Reduce level of indirection,   @S8*/
  596.   VIOMODEINFO far *pReqMode;           /* Reduce level of indirection,   @S8*/
  597.   unsigned register ReqModeLen;        /* Eliminate segment loading,     @S8*/
  598.   USHORT ChainedXGAMode132 = (ParmBlock->Flags & 0x4000);       /*            */
  599.   ParmBlock->Flags &= ~0x4000;                                  /*            */
  600.  
  601.   FONT_AVAILABLE = TRUE;               /*                              @@TB1*/
  602.   rc = ERROR_VIO_INVALID_PARMS;        /* Initialize to error               */
  603.   EnvBufferPassed = SEG(Environment);  /* Non-zero = TRUE                   */
  604.  
  605.   if ((Function == FnSetMode) &&       /* Valid function request            */
  606.      (ParmBlock->Flags <= 0x07) &&     /* Valid flags                       */
  607.      (EnvBufferPassed || (ParmBlock->Flags&UPDATE_HARDWARE)))
  608.   {
  609.     ReqModeLen = (pReqMode = ParmBlock->ModeDataPTR)->cb;/*              @S8*/
  610.     rc = ERROR_VIO_INVALID_LENGTH;     /*             @@TB1INITIALIZETOERROR*/
  611.  
  612.     if ((ParmBlock->Length >= sizeof(VDH_MODE)) && /* @@TB1VALIDPACKETLENGTH*/
  613.        (ReqModeLen >= MinDLen_Mode_Type))          /* @@TB1VALIDMODELENGTH  */
  614.     {
  615.  
  616.       /*
  617.       **  Find the mode based upon matching specified parameters with entry in      
  618.       **  the table of supported modes.  If a partial parameter list is             
  619.       **  provided, use the highest resolution mode that matches the provided       
  620.       **  parameters.                                                               
  621.       */
  622.                                                                             
  623.       rc = ERROR_VIO_MODE;             /* Initialize to error               */
  624.       tempflags = ParmBlock->Flags;
  625.  
  626.       if (pReqMode->fbType&NO_CLR_BRST)
  627.       {
  628.         tempflags |= NO_CLR_BRST;      /* Indicate B/W Mode                 */
  629.       } 
  630.  
  631. #if      1                      /* @drw **************** added SVGA support */
  632.                                 /* Flags bit 2 is 'no validation' flag      */
  633.                                 /* must have SVGAPresent                    */
  634.                                 /* must have an environment to update       */
  635.                                 /* must be text mode                        */
  636.                                 /* must have at least up to 'row' data      */
  637.  
  638.       if (SVGAPresent && EnvBufferPassed && (ParmBlock->Flags&0x04) && 
  639.       (ReqModeLen >= MinDLen_Mode_Row) && !(pReqMode->fbType&GRAPHICS))
  640.       {
  641.         Environment->ModeIndex = 0;
  642. #if     VDHVGA
  643.         Environment->SVGAMode |= MODE_SVGA_ENVFLAG;    /*            */
  644. #endif
  645.         Environment->ModeData.cb = ReqModeLen;
  646.         Environment->ModeData.fbType = pReqMode->fbType;
  647.  
  648.         if (ReqModeLen >= MinDLen_Mode_Color)
  649.           Environment->ModeData.color = pReqMode->color;
  650.  
  651.         if (ReqModeLen >= MinDLen_Mode_Column)
  652.           Environment->ModeData.col = pReqMode->col;
  653.  
  654.         if (ReqModeLen >= MinDLen_Mode_Row)
  655.           Environment->ModeData.row = pReqMode->row;
  656.  
  657.         if (ReqModeLen >= MinDLen_Mode_Hres)
  658.           Environment->ModeData.hres = pReqMode->hres;
  659.  
  660.         if (ReqModeLen >= MinDLen_Mode_Vres)
  661.           Environment->ModeData.vres = pReqMode->vres;
  662.  
  663.         if (ReqModeLen >= MinDLen_Mode_FormatID)
  664.           Environment->ModeData.fmt_ID = pReqMode->fmt_ID;
  665.  
  666.         Environment->ModeData.BufferAddress = (UCHAR FAR *)0x0b8000L;
  667.         Environment->ModeData.BufferLength = 2*pReqMode->col *pReqMode->row;
  668.         Environment->ModeData.ExtDataArea = NULL;
  669.         Environment->ScrollRect.Right = pReqMode->col-1;
  670.         Environment->ScrollRect.Bottom = pReqMode->row-1;
  671.         return (NO_ERROR);
  672.       }                   
  673. #if     VDHVGA
  674.       else
  675.         Environment->SVGAMode &= ~MODE_SVGA_ENVFLAG;            /*           */
  676. #endif
  677. #endif                           /* @drw **************** end SVGA support  */
  678.  
  679.       for (i = 0, MODE_FOUND = FALSE; (i < NUM_MODES) && !MODE_FOUND; i++)
  680.       {                                /* @MS12 */
  681.         pCurMode = (VIDEOMODE far *)&Modes[i].cb;/*                      @S8*/
  682.  
  683.         /*
  684.         **  Verify that the mode is valid by finding it in the mode table             
  685.         */
  686.  
  687. #if      VDHCGA                        /* @MS00 */
  688.         /*
  689.         ** Ignore Color Burst on DSM                               
  690.         */
  691.  
  692.         if ((pCurMode->fbType == pReqMode->fbType)                 /* @MS14 */
  693.         || ((OEMFlags&DSM_MONITOR)                                 /* @MS14 */
  694.         && (pCurMode->fbType == (pReqMode->fbType&~NO_CLR_BRST)))) /* @MS14 */
  695.  
  696. #else                                                              /* @MS00 */
  697.  
  698.           if (pCurMode->fbType == (pReqMode->fbType&~NO_CLR_BRST)) /* @MS14 */
  699. #endif    
  700.  
  701.              /*
  702.              **  Type matches - If color specified, check for match. Otherwise
  703.              **               default color, col, row, hres, vres to this mode
  704.              */
  705.  
  706.              if (ReqModeLen < MinDLen_Mode_Color)
  707.                 MODE_FOUND = TRUE;       /* Found a matching mode           */
  708.  
  709.             else
  710.  
  711.               if (pReqMode->color == pCurMode->color)
  712.  
  713.                 /*
  714.                 **  Color matches - If col specified, check for match. 
  715.                 **      Otherwiswe default col, row, hres, vres to this mode
  716.                 */
  717.  
  718.                 if (ReqModeLen < MinDLen_Mode_Column)
  719.                   MODE_FOUND = TRUE;   /* Found a matching mode             */
  720.  
  721.                 else
  722.  
  723.                   if ((pReqMode->col == pCurMode->col) || (pReqMode->fbType
  724.                      &GRAPHICS))
  725.  
  726.                     /*
  727.                     **  col matches - If row specified, check for match. 
  728.                     **      Otherwise default row, hres and vres to this mode
  729.                     */      
  730.  
  731.                     if (ReqModeLen < MinDLen_Mode_Hres)
  732.                       MODE_FOUND = TRUE;/* Found a matching mode            */
  733.  
  734.                     else
  735.  
  736.                       if (pReqMode->hres == pCurMode->hres)
  737.  
  738.                         /*
  739.                         **  hres matches - If vres specified, check for match.
  740.                         **                 Otherwise default vres to this mode
  741.                         */
  742.  
  743.                         if (ReqModeLen < MinDLen_Mode_Vres)
  744.                           MODE_FOUND = TRUE;/* Found a matching mode        */
  745.  
  746.                         else
  747.  
  748.                           if (pReqMode->vres == pCurMode->vres)
  749.                             MODE_FOUND = TRUE;/* Found a matching mode      */
  750.  
  751. /*
  752. ** If the everything matches so far, call findfont if the rows don't match  
  753. ** and not graphics mode.  If no font found, set a temporary error code.    
  754. ** If no font found and buffer not large enough, reset !MODE_FOUND true.    
  755. */
  756.  
  757.         goto search_part1;
  758.  
  759. search_part2:                          /* MS?? - END */
  760.  
  761.         if (MODE_FOUND && (ReqModeLen >= MinDLen_Mode_Row))
  762.           if (pReqMode->row > 0)
  763.           {                            /*                               @B22*/
  764.  
  765.             if (!(pReqMode->fbType&GRAPHICS) && (pReqMode->row != 
  766.                pCurMode->row))
  767.             {
  768.  
  769. #if      FONT_SUPPORT                  /* @MS00 */
  770.               FONT_AVAILABLE = FindFont(i, pReqMode->row, Environment);
  771.  
  772.               if (!FONT_AVAILABLE || (0x2000 < (pReqMode->row *pReqMode->col)))
  773. #endif    
  774.                    MODE_FOUND = FALSE;
  775.             } 
  776.  
  777.             else
  778.               FONT_AVAILABLE = TRUE;
  779.           }                            /*                               @B22*/
  780.  
  781.           else
  782.             MODE_FOUND = FALSE;        /*                               @B22*/
  783.             goto search_end;
  784.  
  785. search_part1:
  786.  
  787. #if      VDHVGA                        /* @MS00 */
  788.  
  789.         if (MODE_FOUND)
  790.         {                              /*                               @S39*/
  791.  
  792.           /*
  793.           **  Make sure PDP does not exist for modes not valid with PDP
  794.           */
  795.  
  796.           /*          ** The logic of this terrible if statement should be:
  797.           ** If (current mode not supported on plasma display and
  798.           **     display is plasma) or 
  799.           ** if (mode has 132 columns and either
  800.           **     ((IBM_132 mode index used on non-IBM hardware) or
  801.           **     (OEM_132 index used on non-oem hardware)) true or
  802.           ** if (if CGA or MPA mode conflict with VGA)
  803.           **    reset mode found to false.                                      
  804.           */
  805.           if (((pCurMode->Flags&NOT_PLASMA)/*                           @S39*/
  806.              && (VideoHardware.display == PlasmaDisplay)) ||           /*@T39,@S39*/
  807.  
  808.              (
  809.               (pCurMode->col == 132) &&                         /*@B726706 */ 
  810.               ((
  811.                 (i < ModeIndex_OEM_132) &&                      /*@B726706 */
  812.                 (!(Environment->Comp_Reg = VideoHardware.Reg_132) ||  /*           */
  813.                 ((Environment->XGA_PRESENT) && !(ChainedXGAMode132))) /*           */
  814.                ) || 
  815.                (
  816.                 (i >= ModeIndex_OEM_132) && 
  817.                 !(OEMFlags&OEM_132_COLUMNS)
  818.                )                                                /*@B726706 */
  819.              ))                                                 /*@B726706 */
  820.  
  821.              /*
  822.              **  Make sure CGA does not conflict with this VGA mode 
  823.              */
  824.  
  825.              || ((pCurMode->fbType&NOT_MONO)/*                          @S39*/
  826.              && (VideoHardware.fVideoType&CGA_BIT))/*                   @S39*/
  827.  
  828.              /*
  829.              **  Make sure MPA does not conflict with this VGA mode                      
  830.              */
  831.  
  832.              || (!(pCurMode->fbType&NOT_MONO)/*                         @S39*/
  833.              && (VideoHardware.fVideoType&MPA_BIT)))
  834.           {                            /*                               @S39*/
  835.             MODE_FOUND = FALSE;
  836.           }                            /*                               @S39*/
  837.  
  838.         }                              /*                               @S39*/
  839. #endif    
  840.  
  841. #if      VDHEGA                        /* @MS00 */
  842.  
  843.  
  844.           /*
  845.           **  EVEN THOUGH THE SPECIFIED MODE WAS FOUND IN THE MODE TABLE, MAKE          
  846.           **  SURE THAT IT IS VALID WITH THE ATTATCHED MONITOR.  MAKE SURE              
  847.           **  MONOCHROME MONITOR EXISTS FOR MONOCHROME MODES 7,F,10                     
  848.           */
  849.  
  850.           if ((!(pReqMode->fbType&NOT_MONO) && 
  851.           (VideoHardware.display != Mono5151)) ||                /* @T39  */
  852.  
  853.           /*
  854.           **  Make sure monochrome monitor doesn't exist for color modes                
  855.           */
  856.  
  857.           ((pReqMode->fbType&NOT_MONO) && 
  858.           (VideoHardware.display == Mono5151)) ||                /* @T39  */
  859.           ((pCurMode->Flags&EGA_GT_64K) &&                       /* @MS15 */
  860.           (VideoHardware.memory <= 64L*1024L)) ||                /* @MS15 */
  861.  
  862.           /*
  863.           **  Make sure normal color monitor doesn't exist for enhanced modes           
  864.           */
  865.  
  866.           ((pCurMode->Flags&ENHANCED_MONITOR) && 
  867.           (VideoHardware.display != EnColor5154))                /*  @T39*/
  868.             )
  869.  
  870.             MODE_FOUND = FALSE;
  871. #endif    
  872.  
  873.         /*
  874.         **  Make sure disable color burst is not specified on non-applicable
  875.         **  modes
  876.         */
  877.  
  878.         if (MODE_FOUND && ((pReqMode->fbType&NO_CLR_BRST) && 
  879.                           (pCurMode->Flags & IGNORE_CLR_BRST)))
  880.  
  881.            MODE_FOUND = FALSE;          /* END OF                       @T37*/
  882.  
  883.         /*
  884.         **  Check for modes prohibited by OEM flags                                   
  885.         */
  886.  
  887. #if      VDHCGA                        /* @MS19 - BEGIN */
  888.  
  889.         if (MODE_FOUND)
  890.  
  891.           if ((!(OEMFlags&IDC_CGA)
  892.              && (pCurMode->Flags & IDC_PLASMA_ONLY))
  893.              || ((pCurMode->Flags & VDU_DSM_ONLY)
  894.              && (!(OEMFlags & VDU_CGA)
  895.              || !(OEMFlags & DSM_MONITOR) )))
  896.  
  897.             MODE_FOUND = FALSE;
  898.  
  899. #endif    
  900.  
  901. #if      VDHVGA
  902.  
  903.         if (MODE_FOUND)
  904.  
  905.           if (((OEMFlags & STARLIGHT_VGA) && !(pCurMode->fbType & GRAPHICS) &&
  906.              (pCurMode->col == 40) && (pCurMode->hres == 360)) || 
  907.              ((i == ModeIndex_VGC2E) && !(OEMFlags & STARDUST_VGA)))
  908.           {
  909.             MODE_FOUND = FALSE;
  910.           } 
  911.  
  912. #endif                                 /* VDHVGA */
  913.         goto search_part2;
  914.  
  915. /* End of mode table search                                                 */
  916.  
  917. search_end:                            /* @MS19 - END */
  918.         ;
  919.       }                                /* End of For that searches the Mode */
  920.                                        /* table                             */
  921.  
  922.       /*
  923.       **  Verify that the format ID and Attribute count are default or@P1   
  924.       **  ARE THE WORLD FORMAT (LVB FORMAT 70, 3 LVB ATTRIBUTES)            
  925.       */
  926.  
  927.       if (MODE_FOUND)
  928.       {                                /*                                @P1*/
  929.  
  930.         if (ReqModeLen >= MinDLen_Mode_FormatID)
  931.         {                              /*                                @P1*/
  932.  
  933.           if ((pReqMode->fmt_ID != DefaultFormat) && /*                  @P1*/
  934.              (pReqMode->fmt_ID != WorldFormat))
  935.           {                            /*                                @P1*/
  936.             MODE_FOUND = FALSE;        /*                                @P1*/
  937.           }                            /*                                @P1*/
  938.  
  939.           else
  940.           {                            /*                                @P1*/
  941.  
  942.             if (ReqModeLen >= MinDLen_Mode_Attrib)
  943.             {                          /*                                @P1*/
  944.  
  945.               if (((pReqMode->attrib != DefaultAttrCount) && 
  946.                  (pReqMode->attrib != WorldAttrCount) && 
  947.                  (pReqMode->attrib != 0)) ||                       /*  @TB15*/
  948.                  ((pReqMode->attrib != WorldAttrCount) && 
  949.                  (pReqMode->fmt_ID == WorldFormat)))
  950.               {
  951.                 MODE_FOUND = FALSE;    /*                                @P1*/
  952.               }                        /*                                @P1*/
  953.             }                          /*                                @P1*/
  954.           }                            /*                                @P1*/
  955.         }                              /*                                @P1*/
  956.       }                                /*                                @P1*/
  957.  
  958. #if      VDH8514A                      /* @MS00 */
  959.  
  960.         /*
  961.         **  If the specified mode is native to the 8514/A is an 8514/A native          
  962.         **  mode, return the appropriate information.  Otherwise call GetMode          
  963.         **  in VDHVGA.DLL                                                              
  964.         */
  965.  
  966.         if (!MODE_FOUND)
  967.         {
  968.  
  969.           if (VGA_PRESENT)
  970.           {
  971.             tempflags = Environment->NATIVE_MODE;/* Save AFMode flag    @T58*/
  972.             i = (USHORT)Environment->ModeData.fbType;/* Save mode type  @T58*/
  973.             Environment->ModeData.fbType &= ~NATIVE;/* Clear native bit     
  974.                                                                         @T58*/
  975.             Environment->NATIVE_MODE = FALSE;/* Must leave native mode      */
  976.  
  977.             if (ParmBlock->Flags&UPDATE_HARDWARE)
  978.             {
  979.               LeaveNativeMode();
  980.             } 
  981.  
  982.             if ((rc = ChainedVDHSetMode(           /*                   @T58*/
  983.                (ENVIRONMENT far *)&Environment->VGAEnvironment, 
  984.                ParmBlock, Function)))
  985.             {
  986.  
  987.               /* Reset back to AF mode if setmode fails on VGA              */
  988.  
  989.               Environment->NATIVE_MODE = tempflags;/* Restore native mode   */
  990.                                                    /*                   @T58*/
  991.               Environment->ModeData.fbType = (UCHAR)i;/* Restore mode type  
  992.                                                                         @T58*/
  993.  
  994.               if ((ParmBlock->Flags&UPDATE_HARDWARE) && tempflags)
  995.               {                        /*                               @T58*/
  996.                 SetHWMode(Environment->ModeIndex, ParmBlock->Flags, 
  997.                    Environment);
  998.               } 
  999.             } 
  1000.           } 
  1001.         } 
  1002.  
  1003.         else
  1004.         {
  1005.           Environment->NATIVE_MODE = TRUE;/* Must set a Native mode         */
  1006.  
  1007. #else
  1008.  
  1009.           if (MODE_FOUND)
  1010.           {
  1011. #endif    
  1012.  
  1013.             /*
  1014.             **  Parameters are valid
  1015.             **  - Update environment buffer if it was passed         
  1016.             **  - Update hardware if in foreground                   
  1017.             */
  1018.  
  1019.             if (EnvBufferPassed)
  1020.             {
  1021.  
  1022.               /*
  1023.               **  Put all of the caller's parameters into the 
  1024.               **  environment buffer Fill in missing
  1025.               **  parameters with defaults in the mode table                     
  1026.               */
  1027.  
  1028.               Environment->ModeIndex = (UCHAR)i-1;/* Remember actual mode   */
  1029.                                                   /* being set              */
  1030.               Environment->ModeData.cb = ReqModeLen;
  1031.               Environment->ModeData.fbType = pReqMode->fbType;
  1032.  
  1033.               if (ReqModeLen >= MinDLen_Mode_Color)
  1034.                 Environment->ModeData.color = pReqMode->color;
  1035.  
  1036.               else
  1037.                 Environment->ModeData.color = pCurMode->color;
  1038.  
  1039.               if (ReqModeLen >= MinDLen_Mode_Column)
  1040.                 Environment->ModeData.col = pReqMode->col;
  1041.  
  1042.               else
  1043.                 Environment->ModeData.col = pCurMode->col;
  1044.  
  1045.               if (ReqModeLen >= MinDLen_Mode_Row)
  1046.                 Environment->ModeData.row = pReqMode->row;
  1047.  
  1048.               else
  1049.                 Environment->ModeData.row = pCurMode->row;
  1050.  
  1051.               if (ReqModeLen >= MinDLen_Mode_Hres)
  1052.                 Environment->ModeData.hres = pReqMode->hres;
  1053.  
  1054.               else
  1055.                 Environment->ModeData.hres = pCurMode->hres;
  1056.  
  1057.               if (ReqModeLen >= MinDLen_Mode_Vres)
  1058.                 Environment->ModeData.vres = pReqMode->vres;
  1059.  
  1060.               else
  1061.                 Environment->ModeData.vres = pCurMode->vres;
  1062.  
  1063.               if (ReqModeLen >= MinDLen_Mode_FormatID)
  1064.                 Environment->ModeData.fmt_ID = pReqMode->fmt_ID;
  1065.  
  1066.               else
  1067.                 Environment->ModeData.fmt_ID = pCurMode->fmt_ID;
  1068.  
  1069.               /*
  1070.               ** always set World Attribute count if World Format
  1071.               ** was specified
  1072.               */
  1073.  
  1074.               if (Environment->ModeData.fmt_ID == WorldFormat)/*         @P1*/
  1075.                 Environment->ModeData.attrib = WorldAttrCount;/*         @P1*/
  1076.  
  1077.               else
  1078.                 Environment->ModeData.attrib = pCurMode->attrib;
  1079.  
  1080.               Environment->ModeData.BufferAddress = 
  1081.                  MemoryMaps [pCurMode->MemMap].Start.FullAddress;
  1082.  
  1083.               Environment->ModeData.BufferLength = 
  1084.                  Environment->ModeData.fbType & GRAPHICS
  1085.                  ? MemoryMaps[pCurMode->MemMap].TotalSize
  1086.                  : 2 * Environment->ModeData.col * Environment->ModeData.row;
  1087.  
  1088.               if (pCurMode->MemMap == MemMap_LoRes)
  1089.                 Environment->ModeData.BufferLength = 16000;/*          @@TB9*/
  1090.  
  1091.               Environment->ModeData.ExtDataArea = (UCHAR far *)NULL;
  1092.             } 
  1093.  
  1094. #if      FONT_SUPPORT                  /* @MS00 */
  1095.  
  1096.             /*
  1097.             **  Setup the font to be loaded for text modes                                
  1098.             */
  1099.  
  1100.             if (!(pReqMode->fbType&GRAPHICS))
  1101.             {
  1102.  
  1103.               if (EnvBufferPassed)
  1104.               {
  1105.                 FindFont(Environment->ModeIndex, Environment->ModeData.row, 
  1106.                    Environment);
  1107.               } 
  1108.  
  1109.               else
  1110.               {
  1111.                 FindFont((UCHAR)i-1, Modes[(UCHAR)i-1].row, Environment);
  1112.               } 
  1113.             } 
  1114. #endif    
  1115.  
  1116.             /*
  1117.             **  If Flags = UPDATE_HARDWARE, SetHWMode will set the hardware               
  1118.             **  registers If environment buffer is passed, SetHWMode will                 
  1119.             **  shadow the registers                                                      
  1120.             */
  1121.  
  1122.             rc = SetHWMode((UCHAR)(i-1), tempflags, Environment);/*     @T53*/
  1123.  
  1124.           } 
  1125.  
  1126.           if (!FONT_AVAILABLE)         /*                              @@TB1*/
  1127.             rc = ERROR_VIO_FONT;       /* end check for invalid length      */
  1128.         }                              /*                              @@TB1*/
  1129.     }                                  /* end check for invalid parms  @@TB1*/
  1130.  
  1131.     if (rc == NO_ERROR)
  1132.     {                                  /*                                @P1*/
  1133.  
  1134.       if (EnvBufferPassed)
  1135.       {
  1136.         Environment->ScrollRect.Right = Environment->ModeData.col-1;/*   @P1*/
  1137.         Environment->ScrollRect.Bottom = Environment->ModeData.row-1;/*  @P1*/
  1138.  
  1139.         if (Environment->ModeData.fmt_ID == WorldFormat)/*               @P1*/
  1140.           Environment->AttrBufSize = 3;/*                                @P1*/
  1141.  
  1142.         else                           /*                                @P1*/
  1143.           Environment->AttrBufSize = 1;/*                                @P1*/
  1144.       }                                /*                                @P1*/
  1145.     }                                  /*                                @P1*/
  1146.  
  1147.     return (rc);
  1148.   } 
  1149.  
  1150. /*****************************************************************************
  1151.  *                                                                             
  1152.  *  SUBROUTINE NAME: SetHWMode                                                 
  1153.  *                                                                             
  1154.  *  DESCRIPTIVE NAME: Set the hardware mode                                    
  1155.  *                                                                             
  1156.  *  FUNCTION: SetHWMode is called to set the hardware to the supported         
  1157.  *            video mode. If Flags = UPDATE_HARDWARE, the registers            
  1158.  *            are set.  If environment buffer is passed, the registers         
  1159.  *            are shadowed.                                                    
  1160.  *                                                                             
  1161.  *  ENTRY POINT: SetHWMode                                                     
  1162.  *    LINKAGE:   CALL FAR                                                      
  1163.  *                                                                             
  1164.  *  INPUT: (Passed on stack)                                                   
  1165.  *             UCHAR Mode ( Index in table of supported modes )                
  1166.  *         (Referenced)                                                        
  1167.  *             Modes[] (global data - table of supported video modes )         
  1168.  *             Fonts[] (global data - table of ROM font areas )                
  1169.  *                                                                             
  1170.  *  EXIT-NORMAL: Video mode is set on hardware                                 
  1171.  *                                                                             
  1172.  *  EFFECTS: NONE                                                              
  1173.  *                                                                             
  1174.  *  INTERNAL REFERENCES:                                                       
  1175.  *    ROUTINES: SetDefaultCLUT, PhysToUVirt, FreePhysToUVirt                   
  1176.  *                                                                             
  1177.  *  EXTERNAL REFERENCES:                                                       
  1178.  *    ROUTINES: AccessHardware, AccessRegister                                 
  1179.  *                                                                             
  1180.  *****************************************************************************/
  1181.  
  1182.  
  1183.   USHORT PASCAL near SetHWMode(Mode, Flags, Environment)/*         @B15,@T53*/
  1184.  
  1185.   UCHAR Mode;
  1186.   USHORT Flags;
  1187.   ENVIRONMENT far *Environment;
  1188.   {
  1189.  
  1190.     USHORT EnvBufferPassed,Ind,ColorMode,VideoEnable,VideoOn,/*         @C21*/
  1191.            i,j,k,m,rc;                                       /*         @T53*/
  1192.     REGADDRESS RegAddress;
  1193.     REGDATA RegData;
  1194.  
  1195. #if      VDHVGA                        /* @MS00 */
  1196.     CLUTDATA far *CLUT;
  1197.     REGDATA  ClutParms;
  1198.     USHORT   CLUTCount;                /* @MS13 */
  1199. #endif    
  1200.  
  1201.     EnvBufferPassed = SEG(Environment);/* Non-zero = TRUE                   */
  1202.     ColorMode = Modes[Mode].fbType&NOT_MONO;/* Needed by AccessVideoEnable  */
  1203.                                             /* on non-VGA                   */
  1204.  
  1205. #if      !(VDH8514A)                   /* @MS00 */
  1206.  
  1207. /*
  1208. **  Turn the video signal off to reduce snow                                  
  1209. */
  1210.  
  1211.     if (Flags&UPDATE_HARDWARE)
  1212.     {
  1213.  
  1214.       if (EnvBufferPassed)             /*                               @C21*/
  1215.         VideoOn = Environment->VideoEnable;/*                           @C21*/
  1216.  
  1217.       else                             /*                               @C21*/
  1218.  
  1219. #if      VDHVGA                      /*                         @C21,@MS00*/
  1220.   AccessVideoEnable(ColorMode, GET, &VideoOn);/*                        @C21*/
  1221.  
  1222.   #else                                /*                         @C21,@MS00*/
  1223.   VideoOn = 1;                         /*                               @C21*/
  1224.  
  1225. #endif    
  1226.  
  1227.       VideoEnable = 0;                 /* Turn video off                    */
  1228.       AccessVideoEnable(ColorMode, SET, &VideoEnable);/* ring 2 callgate    */
  1229.     } 
  1230. #endif    
  1231.  
  1232. /*
  1233. **  IF NOT GRAPHICS, SEARCH THRU MODE TABLE TO FIND CRTCTLREGS_CMD WITH CURSOR
  1234. **  START/END DATA AND CHANGE THEM TO BE THE 2ND TO LAST AND LAST PEL IN THE  
  1235. **  ROW          INDEX 0XB -> END   0XA -> START                              
  1236. */
  1237.  
  1238.     if (!(Environment->ModeData.fbType&GRAPHICS))
  1239.     {                                                             /*    @C12*/
  1240.  
  1241.       for (i = 0; Modes[Mode].ModeRegs[i].Command != CRTCtlRegs_CMD || 
  1242.          Modes[Mode].ModeRegs[i].RegData.NumEntries < 0x0C; i++);
  1243.                                                                   /*    @C12*/
  1244.       m = Environment->ModeData.vres/Environment->ModeData.row;   /*    @C12*/
  1245.       Modes[Mode].ModeRegs[i].RegData.DataArea[0x0B] = (UCHAR)--m;/*    @C12*/
  1246.       Modes[Mode].ModeRegs[i].RegData.DataArea[0x0A] = (UCHAR)--m;/*    @C12*/
  1247.  
  1248. #if      !(VDHVGA      || VDH8514A)    /* set start line shadow for non-VGA 
  1249.                                                               @C24,B10,@MS00*/
  1250. Environment->EGAShadowTopScanLine = m; /*                               @C24*/
  1251. #endif    
  1252.     }                                  /*                           @C12,B10*/
  1253.  
  1254. #if      VDHCGA                        /* @MS16 - BEGIN */
  1255.  
  1256.       if (OEMFlags&IDC_CGA)
  1257.       {
  1258.         /*
  1259.         ** If setting 640x400 graphics mode, enable extended mode bit.
  1260.         ** For all other CGA modes, keep it clear.
  1261.         */
  1262.  
  1263.         Environment->Hardware.IDCExtendedMode = (Mode == ModeIndex_DMP40)
  1264.         ? 0x01 : 0x00;
  1265.  
  1266.         if (Flags&UPDATE_HARDWARE)
  1267.         {
  1268.           UCHAR byt;
  1269.  
  1270.           RegAddress.DataPort = IDCExtendedModeReg;
  1271.           AccessRegister(&RegAddress, GET, &byt);
  1272.           byt &= ~0x01;
  1273.           byt |= Environment->Hardware.IDCExtendedMode;
  1274.           AccessRegister(&RegAddress, SET, &byt);
  1275.         } 
  1276.       } 
  1277. #endif    
  1278.  
  1279. #if      VDHVGA
  1280.  
  1281.     if (OEMFlags&STARDUST_VGA)
  1282.     {
  1283.       /*
  1284.       ** Clear STARDUST's extended graphics register variables in
  1285.       ** environment. The corresponding hardware registers are
  1286.       ** automatically cleared when the sequencer registers are accessed
  1287.       */
  1288.  
  1289.       for (i = 0x00; i < 0x07; i++)
  1290.         Environment->Hardware.ExtVGARegs[i] = 0x00;
  1291.  
  1292.         /*
  1293.         ** Set 6-bit DAC mode 
  1294.         */
  1295.         Environment->Hardware.DACCmd &= 0x00;
  1296.  
  1297.       if (Flags&UPDATE_HARDWARE)
  1298.       {
  1299.         UCHAR byt;
  1300.  
  1301.         /*
  1302.         ** Set HW DAC if foreground 
  1303.         */
  1304.         RegAddress.DataPort = DACCmdReg;
  1305.         AccessRegister(&RegAddress, GET, &byt);
  1306.         byt &= ~0x02;
  1307.         AccessRegister(&RegAddress, SET, &byt);
  1308.  
  1309.         /*
  1310.         ** Unlock extended VGA graphics regs 
  1311.         */
  1312.         RegAddress.AddressPort = GraphAddressPort;
  1313.         RegAddress.DataPort = GraphDataPort;
  1314.         RegAddress.Flags = NONE;
  1315.         RegData.DataArea = &byt;
  1316.         RegData.FirstEntry = VGA_ENV_REG;
  1317.         RegData.NumEntries = 1;
  1318.         byt = VGA_UNLOCK;
  1319.         AccessHardware(&RegAddress, BYTES, NONE, SET, &RegData);
  1320.       } 
  1321.     } 
  1322. #endif
  1323.  
  1324.     for (i = 0,                        /* JumpCmd= FALSE,                 */
  1325.     Ind = Mode; Modes[Ind].ModeRegs[i].Command; i++)
  1326.     {                                  /* @MS17 */
  1327.  
  1328.       switch (Modes[Ind].ModeRegs[i].Command)
  1329.       {
  1330.  
  1331. #if      !(VDH8514A)                   /* @MS00 */
  1332.  
  1333. #if      VDHEGA        || VDHVGA     /* @MS00 */
  1334.  
  1335. /*
  1336. **  Set the attribute registers                                               
  1337. */
  1338.         case  Attributes_CMD :
  1339.  
  1340.           if (Flags&UPDATE_HARDWARE)
  1341.           {
  1342.             RegAddress.AddressPort = AttAddressPort;
  1343.             RegAddress.DataPort = AttDataWritePort;
  1344.             RegAddress.ColorAdjust = NONE;
  1345.             RegAddress.Flags = Attributes_CMD;
  1346.           } 
  1347.  
  1348. /*
  1349. **  Enter Attribute registers into environment buffer                         
  1350. */
  1351.  
  1352.           if (EnvBufferPassed)
  1353.  
  1354.             for (m = 0, 
  1355.                  k = Modes[Ind].ModeRegs[i].RegData.FirstEntry;
  1356.                  m < Modes[Ind].ModeRegs[i].RegData.NumEntries; 
  1357.                  k++, m++)
  1358.  
  1359.                 Environment->Hardware.Attributes.All[k] = 
  1360.                 Modes[Ind].ModeRegs[i].RegData.DataArea[k];
  1361.  
  1362.           break;
  1363.  
  1364. /*
  1365. **  Set the sequencer registers                                               
  1366. */
  1367.  
  1368.         case  Sequencers_CMD :
  1369.  
  1370.           if (Flags&UPDATE_HARDWARE)
  1371.           {
  1372.             RegAddress.AddressPort = SeqAddressPort;
  1373.             RegAddress.DataPort = SeqDataPort;
  1374.             RegAddress.ColorAdjust = NONE;
  1375.             RegAddress.Flags = Sequencers_CMD;
  1376.           } 
  1377.  
  1378. /*
  1379. **  Enter Sequencer registers into environment buffer                         
  1380. */
  1381.  
  1382.           if (EnvBufferPassed)
  1383.  
  1384.             for (m = 0, 
  1385.                  k = Modes[Ind].ModeRegs[i].RegData.FirstEntry;
  1386.                  m < Modes[Ind].ModeRegs[i].RegData.NumEntries; 
  1387.                  k++, m++)
  1388.  
  1389.               Environment->Hardware.Sequencers.All[k] = 
  1390.               Modes[Ind].ModeRegs[i].RegData.DataArea[k];
  1391.  
  1392.           break;
  1393.  
  1394. /*
  1395. **  Set the graphics registers                                                
  1396. */
  1397.  
  1398.         case  Graphics_CMD :
  1399.  
  1400.           if (Flags&UPDATE_HARDWARE)
  1401.           {
  1402.             RegAddress.AddressPort = GraphAddressPort;
  1403.             RegAddress.DataPort = GraphDataPort;
  1404.             RegAddress.ColorAdjust = NONE;
  1405.             RegAddress.Flags = NONE;
  1406.           } 
  1407.  
  1408. /*
  1409. **  Enter Graphics registers into environment buffer                          
  1410. */
  1411.  
  1412.           if (EnvBufferPassed)
  1413.  
  1414.             for (m = 0, 
  1415.                  k = Modes[Ind].ModeRegs[i].RegData.FirstEntry;
  1416.                  m < Modes[Ind].ModeRegs[i].RegData.NumEntries; 
  1417.                  k++, m++)
  1418.  
  1419. #if      VDHVGA
  1420.  
  1421.               if (k >= 0x40)
  1422.                      Environment->Hardware.ExtVGARegs[k-0x40] =
  1423.                        Modes[Ind].ModeRegs[i].RegData.DataArea[m];
  1424.  
  1425.               else
  1426. #endif
  1427.                      Environment->Hardware.GraphicsRegs[k] = 
  1428.                        Modes[Ind].ModeRegs[i].RegData.DataArea[k];
  1429.           break;
  1430. #endif    
  1431.  
  1432. /*
  1433. **  Set the CRT registers                                                     
  1434. */
  1435.  
  1436.         case  CRTCtlRegs_CMD :
  1437.  
  1438.           if (Flags&UPDATE_HARDWARE)
  1439.           {
  1440.  
  1441. /*
  1442. **  If current cols = 132 then ensure proper register setup for 132 cols      
  1443. */
  1444.  
  1445. #if      VDHVGA                      /*@D1085,@MS00                        */
  1446.  
  1447.             if (Modes[Mode].ModeRegs[i].RegData.DataArea[0x01] == 131)
  1448.             {                          /*@D1085                             */
  1449.  
  1450. //                        if (!SVGAPresent)
  1451. //                        {                        /* @drw */
  1452.  
  1453.                 if (Environment->XGA_PRESENT == FALSE)  
  1454.                 {                      /*@D1452                             */
  1455.                   SET132(Environment->Comp_Reg, 1);/*@D1085                 */
  1456.                 }                      /* endif@D1452                       */
  1457. //                        }                        /* endif                             */
  1458.             }                          /* endif@D1085                       */
  1459. #endif    
  1460.             RegAddress.AddressPort = CRTAddressPort;
  1461.             RegAddress.DataPort = CRTDataPort;
  1462.             RegAddress.ColorAdjust = ColorAdjustment;
  1463.             RegAddress.Flags = NONE;
  1464.           } 
  1465.  
  1466. /*
  1467. **  Enter CRT registers into environment buffer                               
  1468. */
  1469.  
  1470.           if (EnvBufferPassed)
  1471.  
  1472.             for (m = 0, 
  1473.                  k = Modes[Ind].ModeRegs[i].RegData.FirstEntry;
  1474.                  m < Modes[Ind].ModeRegs[i].RegData.NumEntries; 
  1475.                  k++, m++)
  1476.  
  1477.                Environment->Hardware.CRTCtlRegs.All[k] =
  1478.                  Modes[Ind].ModeRegs[i].RegData.DataArea[k];
  1479.  
  1480.           break;
  1481. #endif    
  1482.  
  1483. /*
  1484. **  Set the specified register                                                
  1485. **  (Port address is in 'FirstEntry' field of RegData                         
  1486. */
  1487.  
  1488.         case  RegOutput_CMD :
  1489.  
  1490.           if (Flags&UPDATE_HARDWARE)
  1491.             RegAddress.DataPort = Modes[Ind].ModeRegs[i].RegData.FirstEntry;
  1492.  
  1493. #if      !(VDH8514A)                   /* @MS00 */
  1494.  
  1495.           if (EnvBufferPassed)
  1496.  
  1497.             switch (Modes[Ind].ModeRegs[i].RegData.FirstEntry)
  1498.             {
  1499.  
  1500. #if      VDHEGA        || VDHVGA     /* @MS00 */
  1501.  
  1502.               case  MiscOutputRegWrite:
  1503.                 Environment->Hardware.MiscOutputReg = 
  1504.                 *Modes[Ind].ModeRegs[i].RegData.DataArea;
  1505.                 break;
  1506. #endif    
  1507.  
  1508. #if      VDHEGA                      /* @MS00 */
  1509.  
  1510.               case  Graphics1PosReg:
  1511.                 Environment->Hardware.Graphics1Position = 
  1512.                 *Modes[Ind].ModeRegs[i].RegData.DataArea;
  1513.                 break;
  1514.  
  1515.               case  Graphics2PosReg :
  1516.                 Environment->Hardware.Graphics2Position = 
  1517.                 *Modes[Ind].ModeRegs[i].RegData.DataArea;
  1518.                 break;
  1519.  
  1520. #endif                               /* VDHEGA */
  1521.  
  1522. #if      VDHCGA
  1523.               case  CGAModeCtlReg :
  1524.                 Environment->Hardware.CGAModeControl = 
  1525.                 *Modes[Ind].ModeRegs[i].RegData.DataArea;
  1526.                 break;
  1527.  
  1528.               case  CGAColorSelReg :
  1529.                 Environment->Hardware.CGAColorSelect = 
  1530.                 *Modes[Ind].ModeRegs[i].RegData.DataArea;
  1531.                 break;
  1532.  
  1533. #endif    
  1534.  
  1535. #if      VDHMPA                      /* @MS00 */
  1536.  
  1537.               case  CRTCtlPort1 :
  1538.                 Environment->Hardware.MPAModeControl = 
  1539.                 *Modes[Ind].ModeRegs[i].RegData.DataArea;
  1540.                 break;
  1541.  
  1542. #endif    
  1543.             }                          /* End of inner Switch structure     */
  1544. #endif    
  1545.               break;
  1546.  
  1547. /*
  1548. **  Jump to a command under a different mode                                  
  1549. */
  1550.  
  1551.       }                                /* End of outer Switch structure     */
  1552.  
  1553.       if (Flags&UPDATE_HARDWARE)
  1554.       {
  1555.         if (Modes[Ind].ModeRegs[i].Command == RegOutput_CMD)
  1556.         {
  1557.  
  1558.           if (Modes[Ind].ModeRegs[i].RegData.NumEntries == SETWORD)
  1559.           {                            /*                               @@B1*/
  1560.             AccessRegister(&RegAddress, SETWORD, 
  1561.             Modes[Ind].ModeRegs[i].RegData.DataArea);      /*           @@B1*/
  1562.           } 
  1563.  
  1564.           else
  1565.           {                            /*                               @@B1*/
  1566.             AccessRegister(&RegAddress, SET, 
  1567.             Modes[Ind].ModeRegs[i].RegData.DataArea);       /*          @@B1*/
  1568.           }                            /*                               @@B1*/
  1569.  
  1570. #if      !(VDH8514A)                   /* @MS00 */
  1571.         } 
  1572.  
  1573.         else
  1574.         {
  1575.           AccessHardware(&RegAddress, BYTES, ColorMode, SET, 
  1576.           &Modes[Ind].ModeRegs[i].RegData);
  1577.  
  1578. #if      VDHEGA        || VDHVGA     /* @MS00 */
  1579.  
  1580. /*
  1581. **  Setting attribute registers on a non-VGA turns video on again             
  1582. **  Turn the video off once again to reduce further snow                      
  1583. */
  1584.  
  1585.           if (Modes[Ind].ModeRegs[i].Command == Attributes_CMD)
  1586.             AccessVideoEnable(ColorMode, SET, &VideoEnable);/* callgate     */
  1587. #endif    
  1588. #endif    
  1589.         } 
  1590.       } 
  1591.     } 
  1592.  
  1593. #if      VDHVGA                        /* @MS00 */
  1594.     CLUT = &MonoCLUT;                  /* Preset Mono CLUT as default for   */
  1595.                                        /* Mono modes                        */
  1596.     CLUTCount = MonoCLUTCount;         /* set size of this CLUT       @MS13 */
  1597.  
  1598.     if (Modes[Mode].fbType&NOT_MONO)
  1599.     {
  1600.       CLUT = &SumCLUT;                 /* Preset Summed CLUT as default for */
  1601.                                        /* Color modes @MS13                 */
  1602.       CLUTCount = SumCLUTCount;        /* set size of this CLUT      @MS13  */
  1603.  
  1604.       if (Modes[Mode].color == 8)
  1605.       {                                /* 256 color ?                @MS13  */
  1606.         CLUT = &SumCLUT256;            /* @MS13 */
  1607.         CLUTCount = SumCLUT256Count;   /* @MS13 */
  1608.       }                                /* @MS13 */
  1609.  
  1610.       else
  1611.  
  1612.         if (Modes[Mode].vres == 200)
  1613.         {                              /* low res ?                 @MS13  */
  1614.           CLUT = &SumCLUTLow;          /* @MS13 */
  1615.           CLUTCount = SumCLUTLowCount; /* @MS13 */
  1616.         }                              /* @MS13 */
  1617.  
  1618.       if ((!(VideoHardware.fVideoType&MONO_DISPLAYS))/* Not MONO displays   
  1619.                                                                    @T39,@T73*/
  1620.          && !(Flags&NO_CLR_BRST))
  1621.       {                                /* Not a B/W mode                    */
  1622.         CLUT = &ColorCLUT;             /* Use Color CLUT only for true      
  1623.                                           Color modes                       */
  1624.         CLUTCount = ColorCLUTCount;    /* set size of this CLUT     @MS13   */
  1625.  
  1626.         if (Modes[Mode].color == 8)
  1627.         {                              /* 256 color ?               @MS13   */
  1628.           CLUT = &ColorCLUT256;        /* @MS13 */
  1629.           CLUTCount = ColorCLUT256Count; /* @MS13 */
  1630.         }                              /* @MS13 */
  1631.  
  1632.         else
  1633.  
  1634.           if (Modes[Mode].vres == 200)
  1635.           {                            /* low res ?                  @MS13   */
  1636.             CLUT = &ColorCLUTLow;      /* @MS13 */
  1637.             CLUTCount = ColorCLUTLowCount; /* @MS13 */
  1638.           }                            /* @MS13 */
  1639.       } 
  1640.  
  1641.       else
  1642.       {                                /* set NO_CLR_BRST when using summed 
  1643.                                           color lookup table                */
  1644.  
  1645.         if (!(Environment->ModeData.fbType&GRAPHICS))
  1646.           Environment->ModeData.fbType |= NO_CLR_BRST;/*                @BB8*/
  1647.       } 
  1648.     } 
  1649.  
  1650.     if (Flags&UPDATE_HARDWARE)
  1651.     {
  1652.       ClutParms.DataArea = (UCHAR far *)CLUT;
  1653.       ClutParms.NumEntries = CLUTCount; /* @MS13 */
  1654.                                                                    /* @MS13 */
  1655.  
  1656.       for (i = 0; i < 0xFF+1; i += CLUTCount)
  1657.       {
  1658.         ClutParms.FirstEntry = i;
  1659.         AccessCLUT(SET, (CLUTDATA far *far *)&ClutParms);
  1660.       } 
  1661.  
  1662.       SetTextGrays(Environment);       /* @MS13 */
  1663.     } 
  1664.  
  1665. /*
  1666. **  Enter color lookup table into environment buffer                          
  1667. */
  1668.  
  1669.     if (EnvBufferPassed)
  1670.     {
  1671.  
  1672.       for (i = 0x00; i < 0xFF+1; )
  1673.       {
  1674.  
  1675.         for (j = 0x00; j < 0x3F+1; i++, j++)
  1676.         {
  1677.           Environment->LookupTable[i] = CLUT[j];
  1678.         } 
  1679.       } 
  1680.     } 
  1681.  
  1682. #endif    
  1683.  
  1684.     rc = NO_ERROR;                     /*                               @T53*/
  1685.  
  1686. #if      FONT_SUPPORT                  /* @MS00 */
  1687.  
  1688. /*
  1689. **  Load the appropriate font                                                 
  1690. */
  1691.  
  1692.     if (Flags&UPDATE_HARDWARE)
  1693.       rc = SetHWFont(Environment, Environment->ActiveFontPTR, 
  1694.            (UCHAR far *) PHYSICAL_FONT_BUFFER);        /*               @T53*/
  1695.  
  1696. #endif    
  1697.  
  1698. #if      !(VDH8514A)                   /* @MS00 */
  1699.  
  1700. /*
  1701. **  Turn the video signal back on                                             
  1702. */
  1703.  
  1704.     if ((Flags&UPDATE_HARDWARE) && VideoOn)
  1705.     {                                  /*                               @C21*/
  1706.       VideoEnable = 1;                 /* Turn video on                     */
  1707.       AccessVideoEnable(ColorMode, SET, &VideoEnable);/* ring 2 callgate    */
  1708.     } 
  1709.  
  1710. #endif    
  1711.  
  1712.     return (rc);                       /*                               @T53*/
  1713.   } 
  1714.  
  1715. /*****************************************************************************
  1716.  *                                                                          
  1717.  *  SUBROUTINE NAME: SetEnvMode                                             
  1718.  *                                                                          
  1719.  *  DESCRIPTIVE NAME: Set the envrionment mode                              
  1720.  *                                                                          
  1721.  *  FUNCTION: SetEnvMode is called to update the environment buffer         
  1722.  *            with the current video mode.                                  
  1723.  *                                                                          
  1724.  *  ENTRY POINT: SetEnvMode                                                 
  1725.  *    LINKAGE:   CALL FAR                                                   
  1726.  *                                                                          
  1727.  *  INPUT: (Passed on stack)                                                
  1728.  *             UCHAR Mode ( Index in table of supported modes )             
  1729.  *             FAR * Environment ( far pointer to environment buffer )      
  1730.  *             FAR * HWEnvironment (pointer to hardware state buffer)       
  1731.  *         (Referenced)                                                     
  1732.  *             Modes[] (global data - table of supported video modes )      
  1733.  *                                                                          
  1734.  *  EXIT-NORMAL: Environment buffer is updated to reflect HW state          
  1735.  *                                                                          
  1736.  *  EFFECTS: NONE                                                           
  1737.  *                                                                          
  1738.  *  INTERNAL REFERENCES:                                                    
  1739.  *    ROUTINES: NONE                                                        
  1740.  *                                                                          
  1741.  *  EXTERNAL REFERENCES:                                                    
  1742.  *    ROUTINES: NONE                                                        
  1743.  *                                                                          
  1744.  ****************************************************************************/
  1745.  
  1746.  
  1747.   void PASCAL near SetEnvMode(Mode, Environment, HWEnvironment, GetMode)
  1748.                                                               
  1749.   UCHAR Mode;
  1750.   ENVIRONMENT far *Environment;
  1751.   ENVIRONMENT far *HWEnvironment;
  1752.   USHORT GetMode;                      /*                               @T70*/
  1753.  
  1754.   {
  1755.     int i;
  1756.     UCHAR far *Source;
  1757.     UCHAR far *Destination;
  1758.     VIDEOMODE far *pCurMode;           /* Reduce level of indirection,   @S8*/
  1759.  
  1760. #if      !(VDH8514A)                   /* @MS00 */
  1761.  
  1762. /*
  1763. **  Update environment buffer with current hardware state                     
  1764. */
  1765.  
  1766.     if (HWEnvironment)
  1767.     {
  1768.       Source = (UCHAR far *)&HWEnvironment->Hardware;
  1769.       Destination = (UCHAR far *)&Environment->Hardware;
  1770.  
  1771.       for (i = 0; i < sizeof(HWREGS); i++)
  1772.       {
  1773.         Destination[i] = Source[i];
  1774.       } 
  1775.     } 
  1776.  
  1777. #endif    
  1778.  
  1779.     if (GetMode)
  1780.     {                                  /*                               @T70*/
  1781.  
  1782.       pCurMode = (VIDEOMODE far *)&Modes[Environment->ModeIndex = Mode].cb;
  1783.       Environment->ModeData.cb = pCurMode->cb;
  1784.       Environment->ModeData.fbType = pCurMode->fbType;
  1785.       Environment->ModeData.color = pCurMode->color;
  1786.       Environment->ModeData.col = pCurMode->col;
  1787.       Environment->ModeData.row = pCurMode->row;
  1788.       Environment->ModeData.hres = pCurMode->hres;
  1789.       Environment->ModeData.vres = pCurMode->vres;
  1790.       Environment->ModeData.fmt_ID = pCurMode->fmt_ID;
  1791.       Environment->ModeData.attrib = pCurMode->attrib;
  1792.  
  1793.       Environment->ModeData.BufferAddress = 
  1794.         MemoryMaps[pCurMode->MemMap].Start.FullAddress;
  1795.  
  1796.       Environment->ModeData.BufferLength = 
  1797.         MemoryMaps[pCurMode->MemMap].TotalSize;
  1798.  
  1799.       if (pCurMode->MemMap == MemMap_LoRes)  /*                        @@TB9*/
  1800.         Environment->ModeData.BufferLength = 16000;
  1801.  
  1802.       Environment->ModeData.FullBufferSize = 
  1803.          Environment->ModeData.BufferLength;
  1804.  
  1805.       Environment->ModeData.PartialBufferSize = (ULONG)4000;
  1806.       Environment->ModeData.ExtDataArea = (UCHAR far *)NULL;
  1807.  
  1808. #if      FONT_SUPPORT                  /* @MS00 */
  1809.  
  1810.       if (!(pCurMode->fbType&GRAPHICS))
  1811.       {
  1812.         Environment->ModeData.FullBufferSize += (ULONG)256*(ULONG)
  1813.            (Environment->ModeData.vres/Environment->ModeData.row);
  1814.       } 
  1815.  
  1816.       Environment->ROMFontIndex = pCurMode->ROMFontIndex;
  1817.  
  1818. #endif    
  1819.     }                                  /*                               @T70*/
  1820.   } 
  1821.  
  1822. #if      VDHVGA                        /* Read/write hardware               */
  1823.                                         /* @MS00 */
  1824.  
  1825. /*****************************************************************************
  1826.  *                                                                             
  1827.  *  SUBROUTINE NAME: GetModeIndex                                              
  1828.  *                                                                             
  1829.  *  DESCRIPTIVE NAME: Determine video mode from registers                      
  1830.  *                                                                             
  1831.  *  FUNCTION: GetModeIndex returns the index in the table of modes             
  1832.  *            that corresponds to the current hardware setting.                
  1833.  *                                                                             
  1834.  *  ENTRY POINT: GetModeIndex                                                  
  1835.  *    LINKAGE:   CALL FAR                                                      
  1836.  *                                                                             
  1837.  *  INPUT: (Passed on stack)                                                   
  1838.  *             FAR * Environment ( Registers that have been read )             
  1839.  *         (Referenced)                                                        
  1840.  *             Modes[] ( table of supported video modes )                      
  1841.  *                                                                             
  1842.  *  EXIT-NORMAL: AX = mode table index + 1                                     
  1843.  *                                                                             
  1844.  *  EXIT-ERROR:  AX = 0                                                        
  1845.  *                                                                             
  1846.  *  EFFECTS: NONE                                                              
  1847.  *                                                                             
  1848.  *  INTERNAL REFERENCES:                                                       
  1849.  *    ROUTINES: NONE                                                           
  1850.  *                                                                             
  1851.  *  EXTERNAL REFERENCES:                                                       
  1852.  *    ROUTINES: AccessCLUT                                                     
  1853.  *                                                                             
  1854.  ****************************************************************************/
  1855.  
  1856.  
  1857.   USHORT PASCAL near GetModeIndex(Environment)/*                        @B15*/
  1858.  
  1859.   ENVIRONMENT far *Environment;
  1860.   {
  1861.     USHORT i,MODE_FOUND;
  1862.     VIDEOMODE far *pCurMode;           /* Reduce level of indirection,   @S8*/
  1863.     FarAddress PhysAddress1;           /*                               @C29*/
  1864.     VIDEO_BIOS far *BiosData;          /*                               @C29*/
  1865.  
  1866. /*
  1867. **  An examination of just 4 registers is all that is needed to determine   
  1868. **  which of the supported mode is currently set.  If an unknown mode is    
  1869. **  set, an error is returned.  The registers examined are:                 
  1870. **                  - Miscellaneous Output Register                         
  1871. **                  - Attribute Mode Control Register                       
  1872. **                  - Attribute Color Plane Enable Register                 
  1873. **                  - Sequencer Clocking Mode Register                      
  1874. */
  1875.                                                                             
  1876.  
  1877.     for (i = 0, MODE_FOUND = FALSE; (i < NUM_MODES) && !MODE_FOUND; i++)
  1878.     {                                  /* @MS12 */
  1879.  
  1880.       pCurMode = (VIDEOMODE far *)&Modes[i].cb;/*                        @S8*/
  1881.  
  1882.       if ((Environment->Hardware.MiscOutputReg == pCurMode->CompRegs[0]) && 
  1883.          ((Environment->Hardware.Attributes.Regs.ModeControl&~BLINK_BIT) == 
  1884.          (pCurMode->CompRegs[1]&~BLINK_BIT)) && 
  1885.          (Environment->Hardware.Attributes.Regs.ColorPlane == 
  1886.          pCurMode->CompRegs[2]) && 
  1887.          (Environment->Hardware.Sequencers.Regs.ClockingMode == 
  1888.          pCurMode->CompRegs[3]))
  1889.  
  1890.         MODE_FOUND = TRUE;
  1891.     } 
  1892.  
  1893. /*
  1894. **  If no mode is found, if Protect mode use modeindex from environment
  1895. **  ELSE GET MODE FROM BIOS DATA AREA                                     
  1896. */
  1897.  
  1898.     if (!MODE_FOUND)
  1899.     {                                  /*                          @C29START*/
  1900.       i = Environment->ModeIndex;
  1901.       i++;
  1902.     }                                  /*                            @C29END*/
  1903.  
  1904.     if ((i == ModeIndex_VGC7p+1) &&    /*                               @T71*/
  1905.        (VideoHardware.fVideoType&VGM_BIT))
  1906.     {                                  /*                               @T71*/
  1907.       i++;                             /* Return mono mode index on a mono  
  1908.                                           plasma display                @T71*/
  1909.     }                                  /*                               @T71*/
  1910.  
  1911.     return (i);
  1912.   } 
  1913.  
  1914. #endif    
  1915.  
  1916.  
  1917.