home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 January / pcwk_01_1999.iso / Tajnepp / MCLK093 / VGA.CPP < prev    next >
C/C++ Source or Header  |  1997-05-04  |  6KB  |  294 lines
  1. //    vga.cpp        03/21/97    v0.93ß
  2. //
  3. //    This file contains the BASE CLASS for all sub-derived SVGA chipsets.
  4. //    class vga does NOT offer any user-alterable settings, by itself.
  5. //
  6. //    The version# of VGA.CPP always reflects the MOST RECENT DATE of any
  7. //    of the constituent svga source codes (S3, CIRRUS, etc.)
  8. //
  9.  
  10. #define __vgachipset__
  11. #include "vga.h"
  12.  
  13. //    Required for proper chips.h operation
  14.  
  15. #include <dos.h>
  16. #include<stdio.h>
  17. #include<string.h>
  18. #include<stdlib.h>
  19.  
  20. /*
  21.  *    VGA class function definitions
  22.  */
  23.  
  24.  
  25. vga::vga( vga_info info )    // Constructor, Initializes "vga.id" with info
  26. {
  27.     id= info;
  28.     num_param=0;    //    Set number of parameters to 0
  29.     param=NULL;    //    Set param pointer to NULL
  30.     status = EXIT_SUCCESS;
  31. }
  32.  
  33. uchar
  34. vga::shift( uchar in )
  35. {    //    Shift will "remap" data according to S3-801/805's parameters
  36.     switch ( in )    {
  37.         case 0x02:    in = 3;    // 0010 -> 0011
  38.             break;
  39.         case 0x03:    in = 2;    // 0011 -> 0010
  40.             break;
  41.         default:    ;        //All other values unaffected
  42.     }
  43.     return in;
  44. }
  45.  
  46.  
  47. char *
  48. vga::bitstat( uchar bit )    //    Returns "ENABLE or DISABLE"
  49. {
  50.     return ( bit ? "enable" : "disable" );
  51. //    if ( bit )
  52. //        return "enable";
  53. //    else
  54. //        return "disable";
  55. }
  56.  
  57.  
  58. uchar vga::read_SR ( uchar index )    // Read VGA_SR register 'index'
  59. {
  60.     outportb( _SRindex, index );
  61.     return inportb( _SRIO );
  62. }
  63.  
  64. void vga::write_SR( uchar index, uchar data )    // Write VGA_SR register
  65. {
  66.     outportb( _SRindex, index );
  67.     outportb( _SRIO, data );
  68. }
  69.  
  70. uchar vga::read_CR ( uchar index )    // Read VGA_CR register 'index'
  71. {
  72.     outportb( _CRindex, index );
  73.     return inportb( _CRIO );
  74. }
  75.  
  76. void vga::write_CR( uchar index, uchar data )    // Write VGA_CR register
  77. {
  78.     outportb( _CRindex, index );
  79.     outportb( _CRIO, data );
  80. }
  81.  
  82.  
  83. uchar    //    Read a single BIT(bit) from VGA IO port index
  84. vga::read_bit ( int port, uchar index, uchar bit )
  85. {
  86.     uchar data;
  87.     outportb( port, index );
  88.     data = inportb( port + 1 );
  89.     return ( data >> bit ) & 0x01;    // Returns 1 or 0
  90. }
  91.  
  92.  
  93. uchar
  94. vga::read_bit ( int port, uchar bit )
  95. {
  96.     return ( inportb( port ) >> bit ) & 0x01;
  97. }
  98.  
  99.  
  100. void    // Write a single BIT(bit) to VGA IO port, while preserving other bits!
  101. vga::write_bit( int port, uchar index, uchar bit, uchar data )
  102. {
  103.     uchar old_byte, mask = 0x01;
  104.  
  105.     mask = ~( mask << bit );
  106.     data = data << bit;
  107.  
  108.     outportb( port, index );
  109.     old_byte = inportb( port + 1 ) & mask;
  110.     outportb( port, index );
  111.     outportb( port + 1, old_byte | data );
  112. }
  113.  
  114. void
  115. vga::write_bit( int port, uchar bit, uchar data )
  116. {
  117.     uchar old_byte, mask = 0x01;
  118.  
  119.     mask = ~( mask << bit ); // negate bitfield 0010 0000 -> 1101 1111
  120.     data = data << bit;
  121.  
  122.     old_byte = inportb( port ) & mask;
  123.     outportb( port, old_byte | data );
  124. }
  125.  
  126.  
  127. // returns # of parameters scanned, 0 if unsuccessful
  128. int
  129. vga::parse_param( int index, uchar *parsed ) // Acquire 1 parameter
  130. {
  131.     int temp = 0;
  132.     if ( param[ index ] )
  133.         temp = sscanf( param[ index ], " %u", parsed );
  134.  
  135.     return temp;    //    0 = unsucessful
  136. }
  137.  
  138.  
  139. // Quick function for printing (to string deststr) HEX values XX
  140.  
  141. void
  142. vga::hexout( ostrstream &deststr, int value )
  143. {
  144.     deststr.setf( ios::hex | ios::uppercase );
  145.     deststr.fill('0');
  146.     deststr.width( 2 );    // Want left-edge blank digits to be '0'
  147.     deststr << value ;
  148.     deststr.unsetf( ios::hex | ios::uppercase );
  149. }
  150.  
  151.  
  152. message
  153. vga::get_vgahelp( void )
  154. {
  155.     INITMSG( msg.text );
  156.  
  157.     msgout<<"**** If you're running MCLK from Windows 3.x or Windows95, "<<
  158.         "\n**** you must do so from a FULL-SCREEN DOS box!" <<
  159.         "\n\nFor a list of supported chipsets\n\t" << _argv[ 0 ] <<
  160.         " /F\n\nUsage : MCLK.EXE /0 aa /1 bb /2 cc " <<
  161.         ".. \n\n\t...where 0, 1 & 2 represent menu option(s) " <<
  162.         "0 - 5\n\t...and aa, bb, cc, etc. are parameters." <<
  163.         "\n\t   (some functions require several parameters)" ;
  164.     msgout << ends ;    // Terminate string!
  165.     return msg;
  166. }
  167.  
  168.  
  169. //    This next function is the "command-center."  The main program, MCLK.CPP,
  170. //    access all SVGA functions (settings) through this go() function.
  171. void
  172. vga::go( int fxn, int cmd )    // cmd = _SET, _GET, _QUERY
  173. {
  174.     status= EXIT_SUCCESS;
  175.     msg.text[ 0 ] = NULL; // 0.90 to fix text-redundancy during execution
  176.     msg.temp[ 0 ] = NULL; // 0.90 of multiple commands
  177.     INITMSG( msg.text );
  178.         // Initialize msgout to first char in text-buffer
  179.  
  180.     if ( num_param == 0 )    // If there are no parameters, default to HELP
  181.         cmd = _HELP;
  182.  
  183.     switch ( cmd )    {
  184.         case _HELP:    case _SET:    case _GET:    case _QUERY:
  185.             switch( fxn )    {
  186.                 case 0:    _mclk( cmd );
  187.                     break;
  188.                 case 1:    _fxn1( cmd );
  189.                     break;
  190.                 case 2:    _fxn2( cmd );
  191.                     break;
  192.                 case 3:    _fxn3( cmd );
  193.                     break;
  194.                 case 4:    _fxn4( cmd );
  195.                     break;
  196.                 case 5:    _fxn5( cmd );
  197.                     break;
  198.                 default:
  199.                     msgout << "_fxn" << fxn << " not defined" << ends;
  200.                     status= EXIT_FAILURE;
  201.             }
  202.             break;
  203.         default:
  204.             msgout << "vga::go( " << cmd << " ) unrecognized cmd" <<
  205.                 ends;
  206.             status= EXIT_FAILURE;
  207.     }
  208. }
  209.  
  210.  
  211. message    //    Returns a struct message, with what available SVGA settings
  212. vga::get_settings( void )
  213. {
  214.     message settings;
  215.     ostrstream stgout( settings.text, sizeof( settings.text ) );
  216.  
  217.     _mclk( _QUERY );
  218.     stgout << msg.text ;
  219.     _fxn1( _QUERY );
  220.     stgout << msg.text ;
  221.     _fxn2( _QUERY );
  222.     stgout << msg.text ;
  223.     _fxn3( _QUERY );
  224.     stgout << msg.text ;
  225.     _fxn4( _QUERY );
  226.     stgout << msg.text ;
  227.     _fxn5( _QUERY );
  228.     stgout << msg.text << ends;
  229.     return settings;
  230. }
  231.  
  232.  
  233. void
  234. vga::_fxn1( int cmd )
  235. {
  236.     INITMSG( msg.text );
  237.     msgout << "1  function NOT available.\n" << ends;
  238.     status = EXIT_FAILURE;
  239. }
  240.  
  241.  
  242. void
  243. vga::_fxn2( int cmd )
  244. {
  245.     INITMSG( msg.text );
  246.     msgout << "2  function NOT available.\n" << ends ;
  247.     status = EXIT_FAILURE;
  248. }
  249.  
  250.  
  251. void
  252. vga::_fxn3( int cmd )
  253. {
  254.     INITMSG( msg.text );
  255.     msgout << "3  function NOT available.\n" << ends;
  256.     status = EXIT_FAILURE;
  257. }
  258.  
  259.  
  260. void
  261. vga::_fxn4( int cmd )
  262. {
  263.     INITMSG( msg.text );
  264.     msgout << "4  function NOT available.\n" << ends;
  265.     status = EXIT_FAILURE;
  266. }
  267.  
  268.  
  269. void
  270. vga::_fxn5( int cmd )
  271. {
  272.     INITMSG( msg.text );
  273.     msgout << "5  function NOT available.\n" << ends;
  274.     status = EXIT_FAILURE;
  275. }
  276.  
  277.  
  278. void
  279. vga::_mclk( int cmd )
  280. {
  281.     INITMSG( msg.text );
  282.     msgout << "0  MCLK function NOT available.\n" << ends;
  283.     status = EXIT_FAILURE;
  284. }
  285.  
  286.  
  287. message
  288. vga::_info( void )
  289. {
  290.     INITMSG( msg.text );
  291.     msgout << "(No chipset specific information available.)" << ends;
  292.     status = EXIT_FAILURE;
  293.     return msg;
  294. }