/*M*
//                    INTEL CORPORATION PROPRIETARY INFORMATION
//      This software is supplied under the terms of a license agreement or
//      nondisclosure agreement with Intel Corporation and may not be copied
//      or disclosed except in accordance with the terms of that agreement.
//            Copyright (c) 1995 Intel Corporation.  All Rights Reserved.
//
//  PVCS:
//      $Workfile:   INTRFACE.H  $
//      $Revision:   1.22  $
//      $Modtime:   23 Nov 1999 16:47:54  $
//      $Author:   hfcheng  $
//
//  Purpose:     
//          contains data structure and function prototype defintitions for
//          DIM application interface.
//  Contents:
//
//	SENSOR_TYPE
//
//  THRESHHOLD_TYPE
//
//  ACCESS_STATUS
//
//  SENSOR_PLACEMENT_CODE
//
//  STRING_TYPE
//
//  STRING_DATA
//
//  SENSOR_INFO_THRESHHOLD_BASED
//
//	SENSOR_DIGITAL_DISCRETE
//
//	SENSOR_INFO_DIGITAL_DISCRETE
//
//  SENSOR_INFO
//
//  API_PROC
//
//  API_CLASS_SENSOR
//
//	API_CLASS_SYSTEM_CONTROL
//
//  API_CLASS_SYSTEM_SECURITY
//
//  API_CLASS_EVENT_LOG
//
//  API_CLASS_INVENTORY
//
//  API_CLASS_POWER_SUPPLY
//
//  API_CLASS_MEMORY
//
//	API_CLASS_PROCESSOR
//
//  API_CLASS_CACHE
//
//  API_CLASS_BIOS
//
//	API_CLASS_SYSTEM_SLOTS
//
//  API_CLASS_PHYSICAL_CONTAINER
//
//  EVENT_CAPABILITY
//
//  EVENT_DATA_ANALOG
//
//  EVENT_DATA_DISCRETE_DIGITAL
//
//	EVENT_DATA_SENSOR
//
//	MEMORY_MODULE_LOCATION_CODE
//
//	MEMORY_MODULE_USAGE_CODE
//
//  MEMORY_MODULE_ERROR_TYPE
//
//  MEMORY_MODULE_ERROR_CORRECTION_CODE
//
//  MEMORY_DEVICE_FORM_FACTOR
//
//  MEMORY_DEVICE_TYPE
//
//  MEMORY_DEVICE_TYPE_DETAIL
//
//  MEMORY_LAST_ERROR_UPDATE
//
//	MEMORY_ERROR_OPERATION
//
//  MEMORY_MODULE_ERROR_INFO
//
//  MEMORY_ERROR_GRANULARITY
//
//	MEMORY_DEVICE_ERROR_INFO
//
//  PROCESSOR_TYPE
//
//  PROCESSOR_FAMILY
//
//  PROCESSOR_UPGRADE
//
//  CACHE_LEVEL
//
//  WRITE_POLICY
//
//  ERROR_CORRECTION
//
//	CACHE_TYPE
//
//	BIOS_CHARACTERISTIC_ENUM
//
//  PRIMARY_BIOS_ENUM
//
//  SLOT_WIDTH
//
//  SLOT_USAGE
//
//  SLOT_CATEGORY
//
//  POWER_SUPPLY_TYPE
//
//  VOLTAGE_SWITCHING_RANGE
//
//  ACTIVE_INPUT_RANGE
//
//  CONTROL_ACTION
//
//  WATCHDOG_TIMEOUT_ACTION_CODE
//
//  WATCHDOG_MODE
//
//  CACHE_INFO
//
//  EVENT_DATA_MEMORY
//
//  EVENT_DATA_PROCESSOR
//
//  EVENT_DATA
//
//  CI_EVENT_ENTRY_POINT
//
//  DRIVER_API_STRUCT
//
//  EVENT_BASED_API_CLASS
// 
//	FRU_DATA
//
//	MEMORY_MODULE_INFO
//
//  MEMORY_DEVICE_INFO
//
//  PROCESSOR_INFO
//
//  BIOS_INFO
//
//  SLOT_INFO
//
//  POWER_SUPPLY_INFO
//
//  SYSTEM_CONTROL_INFO
//
//  SECURITY_STATUS
//
//	SECURITY_INFO
//
//  PHYSICAL_CONTAINER_TYPE
//
//	PHYSICAL_CONTAINER_BOOT_STATE
//
//  PHYSICAL_CONTAINER_LOCK_STATE
//
//  PHYSICAL_CONTAINER_POWER_STATE
//
//	PHYSICAL_CONTAINER_THERMAL_STATE
//
//  PHYSICAL_CONTAINER_SECURITY_STATE
//
//	PHYSICAL_CONTAINER_INFO
//
//  DIM_REGISTER_EVENT
//
//  DIM_UNREGISTER_EVENT
//
//  Notes:
//              
//
*M*/
/*
 * $Log:   //cospublic004/shareddata/ISC/ISC2x/COMMON/SRC/CIF/COMMON/INTRFACE.H.v  $
 * 
 *    Rev 1.22   02 Dec 1999 14:54:34   hfcheng
 * fixed for 9044.  The memory device group 
 * has been upgraded from version 001 to 
 * 002
 * 
 *    Rev 1.21   27 Sep 1999 14:53:44   jpaiasno
 * Fixed various logic problems  in the code related
 * to hot -plug  Power supply processing .
 * 
 *    Rev 1.20   14 Sep 1999 17:03:16   gprakash
 * Hot add code ported from the ISC 1.9 branch.
 * 
 *    Rev 1.19   Sep 07 1999 17:48:00   rchandrx
 * Compiler warning suppression fix
 * 
 *    Rev 1.16   Jul 22 1999 11:51:32   sganeshx
 * 1. Added a new enum to the sensor type
 *     WATCH_DOG_TIMER2 (for WatchDog Timer
 *     2 as required by IPMI v1.0)
 * 
 *    Rev 1.15   19 May 1999 10:02:50   jpaiasno
 * Added support for Multiple and  hot swap
 * power units and cooling unut
 * 
 *    Rev 1.14   18 May 1999 13:57:08   jpaiasno
 * Added more processor status types
 * 
 *    Rev 1.13   18 May 1999 13:37:56   jpaiasno
 * Added DIM codes for Processor Status types
 * 
 *    Rev 1.12   14 May 1999 15:36:02   jpaiasno
 * Added 'status' field to the
 * structure  'PROCESSOR_INFO'
 * 
 * 
 *    Rev 1.11   30 Mar 1999 15:04:28   jpaiasno
 * Added functional support for hot-swap events
 * 
 *    Rev 1.10   Mar 30 1999 10:36:04   sganeshx
 * 1. removed redundant code
 * 2. corrected some prototypes
 * 3. added comments
 * 
 *    Rev 1.9   22 Mar 1999 16:30:44   jpaiasno
 * Added support for Hot-Swap Power Supply
 * Events and made some IPMI 1.0 related changes
 * 
 *    Rev 1.8   03 Feb 1999 13:26:02   gprakash
 * Port of PCI Hot Plug code from the Saber 
 * (ISC 1.9) branch.  
 * 
 *    Rev 1.7   11 Jan 1999 08:47:42   sganeshx
 * added IPMI v1.0 specific entity IDs
 * 
 *    Rev 1.6   09 Dec 1998 14:45:38   jpaiasno
 * added code related to DPC functionality
 * 
 *    Rev 1.5   17 Nov 1998 15:58:16   sctripat
 * Changed string size from 64 to 128
 * 
 *    Rev 1.4   05 Nov 1998 14:39:50   sctripat
 * Netware compilation changes (UCHAR, BOOL).
 * 
 *    Rev 1.3   19 Oct 1998 16:59:14   sctripat
 * in APIClassPaging, order of get and set pagestring changed to match with DIM.
 * 
 *    Rev 1.0   Sep 20 1998 17:05:22   whcernan
 * Initial revision.
 * 
 *    Rev 1.26   17 Jul 1998 16:09:12   jpaiasno
 * Added new field 'sensorId' to 'SENSOR_INFO'
 * structure. Also, added code to populate it in
 * the function 'GetSensorInfo'.
 * 
 *    Rev 1.25   03 Apr 1998 11:18:22   jpaiasno
 * changed all processor and Cache enum definations to
 * start with 1
 * 
 *    Rev 1.24   09 Jan 1998 11:00:18   djneuhen
 * Modified to remove compilation warnings
 * No functional changes
 * 
 *    Rev 1.23   05 Jan 1998 11:52:54   HMAHADEX
 * Under UNIX code, Removed the header file windows. Because of this
 * files UNIX madrona sensor would not compile. And the header files was not necessary anyway.
 * 
 *    Rev 1.23   05 Jan 1998 11:50:46   HMAHADEX
 *  
 * 
 *    Rev 1.22   16 Dec 1997 10:18:44   sctripat
 * Initial Unix checkin. Many changes. Please
 * see ifdef Unix statements
 * 
 *    Rev 1.21   02 Dec 1997 09:05:14   sjadex
 * Changed ParallelPortCapabilities to reflect the MIF definition 
 * and removed the 'nMaximumSpeed' member in the 'ParallelPortsInfo' structure.
 * 
 *    Rev 1.20   25 Nov 1997 17:23:30   sjadex
 * Replaced DWORDs with int
 * 
 *    Rev 1.19   20 Nov 1997 19:18:40   djneuhen
 * Added StatusDisplay (LCD) interface
 * 
 *    Rev 1.18   19 Nov 1997 14:42:32   fkhanx
 *  
 * 
 *    Rev 1.17   19 Nov 1997 11:50:44   sjadex
 * Added fru apis for keyboard, mouse and video interfaces.
 * 
 *    Rev 1.16   19 Nov 1997 11:31:58   sjadex
 * Changed BOOL to 'unsigned char'
 * 
 *    Rev 1.15   14 Nov 1997 08:31:32   sjadex
 * Added comments for the new WFM1.1 group interfaces
 * 
 *    Rev 1.14   13 Nov 1997 19:04:34   sjadex
 * Added new WFM 1.1 group interfaces
 * 
 *    Rev 1.13   26 Sep 1997 16:46:50   jpaiasno
 * minor changes to documentation
 * 
 *    Rev 1.12   24 Sep 1997 14:46:14   sjadex
 * Fixed nested comment
 * 
 *    Rev 1.11   23 Sep 1997 14:16:08   jpaiasno
 * added comments and changed the sequence of arguments for
 * sensor related apis such as  'GetSensorThreshholdValue' and
 * 'SetSensorThreshholdValue'
 * 
 *    Rev 1.9.2.0   25 Aug 1997 11:06:10   akumar7
 * Commented Code by Pai.
 * 
 */




#ifndef _INTERFACE_
#define _INTERFACE_


#ifdef _WINDOWS
#include <windows.h>
#endif

typedef void (*DIM_CLEANUP)(void);


#pragma pack(1)


//////////////////////////////////////////////////////////////////////
// SENSOR_TYPE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:       SENSOR_TYPE
//  Purpose:   Enum type definition for type of the sensor
//  Context:   Used in DIM api functions for specifying sensor type.
//       
//     
*D*/


typedef enum{

    TEMPERATURE = 1,

    VOLTAGE,

    CURRENT,

    FAN,

    SECURITY,

    SECURE_MODE_VIOLATION,

    PROCESSOR,

    POWER_SUPPLY,

    POWER_UNIT,

    COOLING_DEVICE,

    OTHER_SENSOR_TYPE,

    MEMORY,

    WATCH_DOG_TIMER = 0x11,

	WATCH_DOG_TIMER2 = 0x23,

   //add - php **********
	SLOT_CONNECTOR = 0x21		//to comply with ipmi v1.0
	//********************


} SENSOR_TYPE;





//Trigger Event base definitions

#define EVENT_CLASS_THRESHHOLD                  1
#define EVENT_CLASS_DISCRETE_USAGE_STATE        2
#define EVENT_CLASS_DISCRETE_SEVERITY           7
#define EVENT_CLASS_DISCRETE_TRANSITION         0xA
#define EVENT_CLASS_DISCRETE_REDUNDANCY         0xB

#define EVENT_CLASS_DIGITAL_ASSERT              3
#define EVENT_CLASS_DIGITAL_PREDICTIVE          4
#define EVENT_CLASS_DIGITAL_LIMIT               5
#define EVENT_CLASS_DIGITAL_PERFORMANCE         6
#define EVENT_CLASS_DIGITAL_DEVICE_AVILABILITY  8
#define EVENT_CLASS_DIGITAL_DEVICE_STATE        9

//add - php ************
#define	EVENT_CLASS_SENSOR_SPECIFIC_DEASSERTION 0xE6
//**********************

#define EVENT_CLASS_SENSOR_SPECIFIC             0xE7            

#define EVENT_CLASS_INVALID                     0xFF

// new values defined in IPMI v1.0
#define IPMI10_EVENT_CLASS_SENSOR_SPECIFIC		0x6F
#define IPMI10_EVENT_CLASS_SENSOR_SPECIFIC_DEASSERTION		0xEF





//offsets for event class threshhold

#define LO_NON_CRITICAL_GOING_LOW    0

#define LO_NON_CRITICAL_GOING_HIGH   1

#define LO_CRITICAL_GOING_LOW        2

#define LO_CRITICAL_GOING_HIGH       3

#define LO_NON_RECOVER_GOING_LOW     4

#define LO_NON_RECOVER_GOING_HIGH    5
								
#define UP_NON_CRITICAL_GOING_LOW    6

#define UP_NON_CRITICAL_GOING_HIGH   7

#define UP_CRITICAL_GOING_LOW        8

#define UP_CRITICAL_GOING_HIGH       9

#define UP_NON_RECOVER_GOING_LOW     10

#define UP_NON_RECOVER_GOING_HIGH    11 



//offsets for event class discrete usage state

#define TRANSITION_TO_IDLE           0
 
#define TRANSITION_TO_ACTIVE         1

#define TRANSITION_TO_BUSY           2




//offsets for event class digital assert

#define STATE_DEASSERTED             0

#define STATE_ASSERTED               1



//offsets for event class digital predictive

#define PREDICTIVE_FAILURE_DEASSERTED  0

#define PREDICTIVE_FAILURE_ASSERTED    1





//offsets for event class digital limit

#define  LIMIT_NOT_EXCEEDED     0

#define  LIMIT_EXCEEDED         1




//offsets for event class digital performance

#define  PERFORMANCE_MET   0

#define  PERFORMANCE_LAGS  1


//offsets for event class discrete severity

#define  TRANSITION_TO_OK                                       0

#define  TRANSITION_TO_NON_CRITICAL_FROM_OK                     1

#define  TRANSITION_TO_CRITICAL_FROM_LESS_SEVERE                2

#define  TRANSITION_TO_NON_RECOVER_FROM_LESS_SEVERE             3       

#define  TRANSITION_TO_NON_CRITICAL_FROM_MORE_SEVERE            4

#define  TRANSITION_TO_CRITICAL_FROM_NON_RECOVER                5

#define  TRANSITION_TO_NON_RECOVER                              6

#define  TRANSITION_TO_MONITOR                                  7

#define  TRANSITION_TO_INFORMATIONAL                            8





//offsets for event class digital device availability

#define  DEVICE_REMOVED  0

#define  DEVICE_INSERTED 1






//offsets for event class digital device state

#define DEVICE_DISABLED  0

#define DEVICE_ENABLED   1
			   


//offsets for  event class discrete transition


#define  TRANSITION_TO_RUNNING   0

#define  TRANSITION_TO_IN_TEST   1

#define  TRANSITION_TO_POWER_OFF 2

#define  TRANSITION_TO_ON_LINE   3

#define  TRANSITION_TO_OFF_LINE  4

#define  TRANSITION_TO_OFF_DUTY  5

#define  TRANSITION_TO_DEGRADED  6      

#define  TRANSITION_TO_POWER_SAVE 7

#define  INSTALL_ERROR           8





//offsets for event class redundancy

#define  REDUNDANCY_REGAINED    0

#define  REDUNDANCY_LOST        1

#define  REDUNDANCY_DEGRADED    2


//offsets for event class sensor specific ( processor sensor)

#define  PROCESSOR_IERR                    0
#define  PROCESSOR_THERMAL_TRIP            1
#define  PROCESSOR_FRB1_FAILURE            2
#define  PROCESSOR_FRB3_FAILURE            3
#define  PROCESSOR_CONFIGURATION_ERROR     4       
#define  PROCESSOR_UNCORRECTABLE_ERROR     5
#define  PROCESSOR_PRESENCE_DETECTED       6
#define  PROCESSOR_DISABLED                7            
			
	
//offsets for event class sensor specific ( memory sensor)

#define  MEMORY_CORRECTABLE_ECC_ERROR   0
#define  MEMORY_UNCORRECTABLE_ECC_ERROR 1
#define  MEMORY_PARITY_ERROR            2                       


//offsets for event class sensor specific(power supply)
#define PRESENCE_DETECTED                               0
#define FAILURE_DETECTED                                1
#define PREDICTIVE_FAILURE                              2           


#define SLOT_UNKNOWN_BIT_MASK            0x1		//bit 0
#define SLOT_ISA_BIT_MASK                0x2		//bit 1
#define SLOT_EISA_BIT_MASK               0x4		//bit 2
#define SLOT_MCA_BIT_MASK                0x8		//bit 3
#define SLOT_PCI_BIT_MASK                0x10		//bit 4
#define SLOT_VL_VESA_BIT_MASK            0x20		//bit 5
#define SLOT_PCMCIA_BIT_MASK             0x40		//bit 6
#define SLOT_NU_BUS_BIT_MASK             0x80		//bit 7
#define SLOT_PC98_C20_BIT_MASK           0x100		//bit 8
#define SLOT_PC98_C24_BIT_MASK           0x200		//bit 9
#define SLOT_PC98_E_BIT_MASK             0x400		//bit 10
#define SLOT_PC98_LOCAL_BUS_BIT_MASK     0x800		//bit 11
#define SLOT_PC98_CARD_BIT_MASK          0x1000		//bit 12
//add -php
#define SLOT_PCI_66MHZ_BIT_MASK			 0x40000	//bit 18
#define	SLOT_PHP_CAPABLE_BIT_MASK		 0x80000	//bit 19





#define OFFSET_INVALID          0xff

#define UNSUPPORTED_INT_VALUE   0x80000000
		       






//////////////////////////////////////////////////////////////////////
// THRESHHOLD_TYPE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      THRESHHOLD_TYPE
//  Purpose:   Enum type definition for type of the sensor threshhold
//  Context:   Used in DIM api functions for specifying sensor 
//				threshhold type.
//       
//     
*D*/


 typedef enum   {
		        	UPPER_NON_RECOVERABLE,
		 	        UPPER_CRITICAL,
			        UPPER_NON_CRITICAL,
			        LOWER_NON_RECOVERABLE,
			        LOWER_CRITICAL,
		            LOWER_NON_CRITICAL
               } THRESHHOLD_TYPE;






//////////////////////////////////////////////////////////////////////
// ACCESS_STATUS
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      ACCESS_STATUS
//  Purpose:   Enum type definition for status of accessing a function
//  Context:   Used in DIM api functions for returning the status
//				of access.       
//     
*D*/

typedef enum {

                 ACCESS_OK,

	             ACCESS_ERROR,

	             ACCESS_OUT_OF_RANGE,

	             ACCESS_END_OF_DATA,

	             ACCESS_UNSUPPORTED,

	             ACCESS_INVALID_TRANSACTION,

				 ACCESS_PAGE_BUSY

         }ACCESS_STATUS;



//////////////////////////////////////////////////////////////////////
// SENSOR_PLACEMENT_CODE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      SENSOR_PLACEMENT_CODE
//  Purpose:   Enum type definition for specifying placement of the
//				sensor.
//  Context:   Used in DIM api functions for specifying sensor's 
//				placement.
//       
// 
//     
*D*/



typedef  enum { 

	              OTHER_PLACEMENT_CODE =1, 

	              UNKNOWN_PLACEMENT_CODE, 

	              PROCESSOR_PLACEMENT_CODE,

			      DISK,
			
	              PERIPHERAL_BAY,
 
	              SYSTEM_MANAGEMENT_MODULE,
	
	              SYSTEM_BOARD,
			
		          MEMORY_MODULE,
 
	              PROCESSOR_MODULE,
	   
	              POWER_UNIT_PLACEMENT_CODE,

	              ADD_IN_CARD ,
			
		          FRONT_PANEL_BOARD,
		  
	              BACK_PANEL_BOARD,

	              POWER_SYSTEM_BOARD,

	              DRIVE_BACK_PLANE          
			

		} SENSOR_PLACEMENT_CODE;



//////////////////////////////////////////////////////////////////////
// STRING_TYPE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      STRING_TYPE
//  Purpose:   Enum type definition for specifying the type of the
//				string data passed to or returned from the DIM.
//  Context:   Used in DIM api functions for specifying the
//				type of string data..
//       
//     
*D*/


typedef enum {
			   UNICODE = 0,
			   BCD_PLUS,
			   SIX_BIT_ASCII,
			   EIGHT_BIT_ASCII,
			   ST_UNKNOWN
 
			}STRING_TYPE;



//////////////////////////////////////////////////////////////////////
// STRING_DATA
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      STRING_DATA
//  Purpose:   Structure type definition for string data
//  Context:   Used in DIM api functions for specifying string
//				variables
//  Fields:		
//		type			type of the string data
//     	stringLength	number of bytes in the string buffer
//		stringData		the string buffer
*D*/

     




 typedef struct {

	                STRING_TYPE                     type;
	                unsigned char                   stringLength;
	                unsigned char                   stringData[128];


               } STRING_DATA;


//////////////////////////////////////////////////////////////////////
// SENSOR_INFO_THRESHHOLD_BASED
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      SENSOR_INFO_THRESHHOLD_BASED
//  Purpose:   Structure type definition for specifying data
//				associated with threshhold based sensors
//
//  Context:   Used in 'SENSOR_INFO' structure definition
//  Fields:		
//		readThhholdMask		The bit mask specifying which threshholds
//							are readable
//
//      writeThholdMask		The bit mask specifying which threshholds are 
//							settable.
//
//		sensorResolution;   resolution of the sensor expressed in units
//							of monitored parameter (temperature,voltage etc.)                                       
//
//		sensorTolerance;    sensor tolerance expressed in units of monitored
//							parameter.
//
//		accuracy;			sensor accuracy expressed in 1/100th of a
//							percent
//
//   sensorNominalReading   Nominal reading expressed in units of monitored
//							parameter
//
//   sensorNormalMaxReading Maximum limit value of the normal reading of the
//							sensor expressed in units of monitored parameter
//
//  sensorNormalMinReading  Minimum limit value of the normal reading of
//							sensor expressed in units of monitored parameter
//
//  sensorMaxReading        Mamimum reading supported by the sensor, expressed       
//							in units of monitored parameter.
//
// sensorMinReading			Minimum reading supported by the sensor, expressed
//							in units of monitored parameter.
//
// defaultUpperNonRecover   default value of upper non recoverable threshhold
//							expressed in units of monitored parameter
//
// defaultUpperCritical     default value of upper critical threshhold
//							expressed in units of monitored parameter.
//
//defaultUpperNonCritical   default value of upper non critical threshhold
//							expressed in units of monitored parameter.
//
//defaultLowerNonRecover	default value of lower non recoverable threshhold
//							expressed in units of monitored parameter.
//
// defaultLowerCritical		default value of lower critical threshhold
//							expressed in units of monitored parameter.
//
// defaultLowerNonCritical  default value of lower non critical threshhold
//							expressed in units of monitored parameter.
//
//defaultPositiveHysterisis default value of +ve hysterisis expressed in units
//							of monitored parameter.
//
//defaultNegativeHysterisis default value of -ve hysterisis
//							expressed in units of monitored parameter.
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/

 
 
 
 typedef struct {



                unsigned char   readThholdMask;

                unsigned char   writeThholdMask;

                int				sensorResolution;  //for the type of the  unit refer
										           //to the comment mentioned below                                        
                int				sensorTolerance;   //for the type of the  unit refer
										           //to the comment mentioned below
 
                int				accuracy;		   //expressed in 1/100th of a
										           //percent

// the unit of the fields specified below, is the same as that of current value  
// in ‘GetSensorCurrentValue’ api function as applicable to threshold based 
// sensors.

               int                             sensorNominalReading;

               int                             sensorNormalMaxReading;

               int                             sensorNormalMinReading;

               int                             sensorMaxReading;       

               int                             sensorMinReading;

               int                             defaultUpperNonRecover;

               int                             defaultUpperCritical;

               int                             defaultUpperNonCritical;

               int                             defaultLowerNonRecover;

               int                             defaultLowerCritical;

               int                             defaultLowerNonCritical;

               int                             defaultPositiveHysterisis;

               int                             defaultNegativeHysterisis;      
	


}SENSOR_INFO_THRESHHOLD_BASED;


#define         ARRAY_NUMBER                             3
#define         SENSOR_DISABLED_VALUE                   0x7FFFFFFF
#define         SENSOR_ENABLED_VALUE                    0x80000000


#define       ANALOG									 1
#define       DIGITAL_DISCRETE							 2 


/////////////////////////////////////////////////////////////////////
//	SENSOR_DIGITAL_DISCRETE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      SENSOR_DIGITAL_DISCRETE
//  Purpose:   Structure type definition OF DIGITAL/DISCRETE
//				sensor
//  Context:   Used in 'SENSOR_INFO_DIGITAL_DISCRETE'
//
//  Fields:		
//		
//	eventBase				event type base code supported by the sensor
//	supportedOffsetBitMask	Bit mask of supported offsets w.r.t. to the
//							event type base code.
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/



typedef struct {

                unsigned char           eventBase;
                unsigned short          supportedOffsetBitMask;

//The ‘eventbase’ and ‘supportedOffsetBitMask’ definitions are the same as the
//the definitions of ‘base’ and ‘offset’  value returned by
//‘GetSensorCurrentValue’ function (applicable to digital/discrete sensors only)


               }SENSOR_DIGITAL_DISCRETE;




/////////////////////////////////////////////////////////////////////
//	SENSOR_INFO_DIGITAL_DISCRETE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      SENSOR_INFO_DIGITAL_DISCRETE
//  Purpose:   Structure type definition OF DIGITAL/DISCRETE
//				(sensor with support for one or more event types)
//
//  Context:   Used in 'SENSOR_INFO' structure definition
//
//  Fields:		
//		
//	numberOfSensorStruct	nmuber of logical sensors(sensors with a distinct event types
//							for the same physical sensor).
//
//	structArray				array of logical sensors.
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/


typedef struct {

                    int                            numberOfSensorStruct;
                    SENSOR_DIGITAL_DISCRETE        structArray[ARRAY_NUMBER];



               }SENSOR_INFO_DIGITAL_DISCRETE;





/////////////////////////////////////////////////////////////////////
//	SENSOR_INFO
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      SENSOR_INFO
//  Purpose:   Structure type definition of a sensor

//  Context:   Used by DIM for sensor database.
//
//  Fields:		
//		
//	sensorName	   sensor description
//
// sensorCategory   type of sensor:       01  sensor with threshhold
//										  02  digital/discrete
//						                        without threshhold
//  pCode			sensor placement code
//
//  capability      sensor capability
//
//  categorySpecificInfo  data structure based on sensor category
//							either analog or digital/discrete.
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/



typedef struct {



                 STRING_DATA     sensorName;

                 unsigned char sensorCategory;   //type of sensor:  01  sensor with threshhold
								//				   02  digital/discrete
								//						without threshhold

	


                SENSOR_PLACEMENT_CODE   pCode;

                unsigned char                   capability;



                union {

                           SENSOR_INFO_THRESHHOLD_BASED      analog;

                           SENSOR_INFO_DIGITAL_DISCRETE      digitalDiscrete;      


                      }categorySpecificInfo ;

			int sensorId;
			int  parentIndx;
          }SENSOR_INFO;





typedef  ACCESS_STATUS (*API_PROC)()   ;



/////////////////////////////////////////////////////////////////////
//	API_CLASS_SENSOR
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_SENSOR
//  Purpose:   Structure type definition of sensor class api array.
//			   used by DIM to pass the pointers to sensor class
//				Api functions supported by it
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//	GetNumberOfSensors		pointer to function to get number of sensors
//
//  GetSensorInfo			pointer to function to get sensor related info
//
//  GetSensorCurrentValue   pointer to function to get sensor's current value
//
//  GetSensorThreshholdValue pointer to function to get sensor's 
//								threshhold value
//
//  SetSensorThreshholdValue pointer to function to set sensor's threshhold value
//
//  GetSensorFruInfo		pointer to function to get sensor related fru data	          
//
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/



typedef struct {   

                  API_PROC     GetNumberOfSensors;
                  API_PROC     GetSensorInfo;
                  API_PROC     GetSensorCurrentValue;
                  API_PROC     GetSensorThreshholdValue;
                  API_PROC     SetSensorThreshholdValue;
                  API_PROC     GetSensorFruInfo;          



                }  API_CLASS_SENSOR;




/////////////////////////////////////////////////////////////////////
//	API_CLASS_SYSTEM_CONTROL
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_SYSTEM_CONTROL
//  Purpose:   Structure type definition for system control api array
//			   used by DIM to pass the pointers to system control class
//				Api functions supported by it
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//
//  GetSystemControlInfo		pointer to function to get system 
//									control information
//
// InitiateSystemControlAction  pointer to function to initiate a 
//								system control action
//
// SetWatchDogTimeoutValue		pointer to function to set the watchdog timeout value
//
// ResetWatchDogTimer;			Pointer to function to start or disable the watchdog.
//
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/



typedef struct {


                 API_PROC GetSystemControlInfo;
                 API_PROC InitiateSystemControlAction;
                 API_PROC SetWatchDogTimeoutValue;
                 API_PROC ResetWatchDogTimer;     
 

              } API_CLASS_SYSTEM_CONTROL;





/////////////////////////////////////////////////////////////////////
//	API_CLASS_SYSTEM_SECURITY
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_SYSTEM_SECURITY
//  Purpose:   Structure type definition for system security class api
//			   array used by DIM to pass the pointers to system security
//			   class Api functions supported by it
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
// GetSystemSecurityInfo     pointer to API functions to get system security
//								related data
//
// SetFrontPanelSecureMode	 Pointer to function to enable or disable 
//								front panel keys.
//
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/

typedef struct {

                 API_PROC GetSystemSecurityInfo;
                 API_PROC SetFrontPanelSecureMode;



               } API_CLASS_SYSTEM_SECURITY;




/////////////////////////////////////////////////////////////////////
//	API_CLASS_EVENT_LOG
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_EVENT_LOG
//  Purpose:   Structure type definition for event log class api
//			   array used by DIM to pass the pointers to event log
//			   class Api functions supported by it
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//			GetEventlogRecord  pointer to function to get system
//								event log record.
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/



typedef struct {

                 API_PROC  GetEventlogRecord;


               } API_CLASS_EVENT_LOG;




/////////////////////////////////////////////////////////////////////
//	API_CLASS_INVENTORY
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_INVENTORY
//  Purpose:   Structure type definition for inventory class api
//			   array used by DIM to pass the pointers to inventory
//			   class Api functions supported by it
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//			GetFruData  pointer to function to get fru data records.
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/



typedef struct {

                 API_PROC  GetFruData;


               } API_CLASS_INVENTORY;


/////////////////////////////////////////////////////////////////////
//	API_CLASS_POWER_SUPPLY
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_POWER_SUPPLY
//  Purpose:   Structure type definition for power supply class api
//			   array used by DIM to pass the pointers to power supply
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		 GetPowerSupplyInfo  Pointer to function to get power supply
//								related information.
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/





typedef struct {

                 API_PROC GetPowerSupplyInfo;



               } API_CLASS_POWER_SUPPLY;



/////////////////////////////////////////////////////////////////////
//	API_CLASS_MEMORY
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_MEMORY
//  Purpose:   Structure type definition for memory class api
//			   array used by DIM to pass the pointers to memory
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//     GetNumberOfMemoryModules		Pointer to function get the 
//									number of memory modules.
//
//     GetMemoryModuleInfo			Pointer to function to get
//									memory module information
//
//    GetMemoryModuleErrorInfo	     Pointer to function to 
//									memory module error related data
//					  
//
//    GetMemoryModuleFruInfo		Pointer to function to get
//									fru related data of the memory
//									module
//
//   GetMemoryModulePartitionAddress  Pointer to function to get
//									 the address of a memory modules's
//									partition
//
//  GetMemoryModulePartitionWidth   Pointer  to function to get
//									the width of the  partition
//									of a specific memory module.
//
//   GetNumberOfMemoryDevices		Pointer to function to get 
//									number of installed memory
//									devices in a memory module.
//
//   GetMemoryDeviceInfo			Pointer to function to get
//									information of a memory device
//
//    GetMemoryDeviceErrorInfo		Pointer to function to get
//									error related information
//									of amemory device.	
//
//     GetMemoryDeviceFruInfo		Pointer to function to get 
//									fru related information of a
//									memory device.
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/


typedef struct {

                  API_PROC     GetNumberOfMemoryModules;
                  API_PROC     GetMemoryModuleInfo;
                  API_PROC     GetMemoryModuleErrorInfo;          
                  API_PROC     GetMemoryModuleFruInfo;
                  API_PROC     GetMemoryModulePartitionAddress;
                  API_PROC     GetMemoryModulePartitionWidth;
                  API_PROC     GetNumberOfMemoryDevices;
                  API_PROC     GetMemoryDeviceInfo;
                  API_PROC     GetMemoryDeviceErrorInfo;
                  API_PROC     GetMemoryDeviceFruInfo;
 




}  API_CLASS_MEMORY;




/////////////////////////////////////////////////////////////////////
//	API_CLASS_PROCESSOR
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_PROCESSOR
//  Purpose:   Structure type definition for processor class api
//			   array used by DIM to pass the pointers to processor
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetNumberOfProcessors  pointer to Api function to get number of processors
//
//      GetProcessorInfo	   pointer to Api function to get processor info	
//
//      GetProcessorFruInfo	   pointer to Api function to get fru information
//								of the processor	
//
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/




typedef struct {

                 API_PROC        GetNumberOfProcessors;
                 API_PROC        GetProcessorInfo;
                 API_PROC        GetProcessorFruInfo;
 


               }  API_CLASS_PROCESSOR;



/////////////////////////////////////////////////////////////////////
//	API_CLASS_CACHE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_CACHE
//  Purpose:   Structure type definition for CACHE class api
//			   array used by DIM to pass the pointers to CACHE
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetNumberOfCache   pointer to Api function to get caches
//
//      GetCacheInfo	   pointer to Api function to get cache info	
//
//      GetCacheFruInfo	   pointer to Api function to get fru information
//								of the cache	
//
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/



typedef struct {

                 API_PROC     GetNumberOfCache;
                 API_PROC     GetCacheInfo;
                 API_PROC     GetCacheFruInfo;

			   
               }  API_CLASS_CACHE;



/////////////////////////////////////////////////////////////////////
//	API_CLASS_BIOS
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_BIOS
//  Purpose:   Structure type definition for bios class api
//			   array used by DIM to pass the pointers to bios
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetNumberOfBiosComponents  pointer to Api function to get number of 
//									bios components
//
//      GetBiosInfo				   pointer to Api function to get 
//								   Bios info	
//
//      GetBiosCharacteristicDescription	
//								   pointer to api function to get the 
//									characteristics description of bios 
//									component.
//									
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/


typedef struct {

                  API_PROC    GetNumberOfBiosComponents;
                  API_PROC    GetBiosInfo;
                  API_PROC    GetBiosCharacteristicDescription;   


               }  API_CLASS_BIOS;


/////////////////////////////////////////////////////////////////////
//	API_CLASS_SYSTEM_SLOTS
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_SYSTEM_SLOTS
//  Purpose:   Structure type definition for system slots class api
//			   array used by DIM to pass the pointers to system slots
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetNumberOfSystemSlots	  pointer to Api function to get number of 
//									system slots
//
//      GetSlotInfo				   pointer to Api function to get 
//								   Slot info	
//
//
//		GetSensorCurrentValue		pointer to Api function to get php sensor info
//
//		GetNumberOfPhpSlots			pointer to Api function to get # of php slots
//
//		GetPhpArrayIndex			pointer to Api function to get php index
//
//		GetPhpDeviceType			pointer to Api function to get pci device type
//
//		GetPhpDeviceManufacturer	pointer to Api function to get pci device manufacture
//
//		GetPhpDeviceRevision		pointer to Api function to get pci device revision
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/

typedef struct {

                   API_PROC GetNumberOfSystemSlots;
                   API_PROC GetSlotInfo;
				   API_PROC GetSensorCurrentValue; 		//add - php
				   API_PROC GetNumberOfPhpSlots;		//add - php
				   API_PROC	GetPhpArrayIndex;		   //add - php
				   API_PROC GetPhpDeviceManufacturer;	//add - php
               } API_CLASS_SYSTEM_SLOTS;

//php - device
/////////////////////////////////////////////////////////////////////
//	API_CLASS_PHP_DEVICE_GROUP
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      API_CLASS_PHP_DEVICE_GROUP
//  Purpose:   Structure type definition for system slots class api
//			   array used by DIM to pass the pointers to system slots
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetNumberOfPhpSlots			pointer to Api function to get # of php slots
//
//		GetPhpDeviceType			pointer to Api function to get pci device type
//
//		GetPhpDeviceManufacturer	pointer to Api function to get pci device manufacture
//
//		GetPhpDeviceRevision		pointer to Api function to get pci device revision
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/
typedef struct {
				   API_PROC GetNumberOfPhpSlots;		//add - php
				   API_PROC GetPhpDeviceType;			//add - php
				   API_PROC GetPhpDeviceManufacturer;	//add - php
				   API_PROC GetPhpDeviceRevision;		//add - php
               } API_CLASS_PHP_DEVICE_GROUP;


/////////////////////////////////////////////////////////////////////
//	API_CLASS_PHYSICAL_CONTAINER
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_PHYSICAL_CONTAINER
//  Purpose:   Structure type definition for physical container class api
//			   array used by DIM to pass the pointers to physical container
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetPhysicalContainerInfo	api function to get the
//									physical container information
//
//		GetPhysicalContainerFruInfo	api function to get the fru
//									 related information of the
//									physical container
//									
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/




typedef struct {

                   API_PROC  GetPhysicalContainerInfo;
                   API_PROC  GetPhysicalContainerFruInfo;



               } API_CLASS_PHYSICAL_CONTAINER;

/*D*
//  Name:      API_CLASS_STATUS_DISPLAY
//  Purpose:   Structure type definition for status display (LCD) class api
//			   array used by DIM to pass the pointers to physical container
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetStatusDisplayInfo	api function to get the
//									status display information
//
//		GetStatusDisplayFruInfo	api function to get the fru
//									 related information of the
//									status display
//
//		SetStatusDisplayState	api function to set the status display state
//									 it can be turned on or off
//									
//		SetStatusDisplayString	api function to set the status display text
//									 
//		GetStatusDisplayString	api function to get the current status display text
//									 
//									
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.	
*D*/


typedef struct {

		API_PROC  GetStatusDisplayInfo;
		API_PROC  GetStatusDisplayFruInfo;
		API_PROC  SetStatusDisplayState;
		API_PROC  GetStatusDisplayString;
		API_PROC  SetStatusDisplayString;

} API_CLASS_STATUS_DISPLAY;


/*D*
//  Name:      API_CLASS_PAGING
//  Purpose:   Structure type definition for paging class api
//			   array used by DIM to pass the pointers to paging
//			   class Api functions supported by it.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//  GetPepCapabilities		To get paging and event filtering capabilities including version,
//							paging supported and maximum page string size
//
//  GetPepConfiguration		To get paging and event filtering configuration including a flag if
//							if filtering enabled and enable/disable paging
//
//	SetPepConfiguration		To set paging and filtering configuration including enable/disable
//							filtering and enable/disable paging
//
//	SetPageString			To set pep page string
//
//	GetPageString			To get pep page string
//
//	PageImmediate			Generate immediate page
//
*D*/


typedef struct {

		API_PROC  GetPepCapabilities;
		API_PROC  GetPepConfiguration;
		API_PROC  SetPepConfiguration;
		API_PROC  GetPageString;
		API_PROC  SetPageString;
		API_PROC  PageImmediate;

} API_CLASS_PAGING;



// @@@@@ New WFM groups - shashi 11/14/97 @@@@@

/////////////////////////////////////////////////////////////////////
//	API_CLASS_MEMORY_ARRAY_MAPPED_ADDRESSES
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_MEMORY_ARRAY_MAPPED_ADDRESSES
//  Purpose:   
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetNumberOfMemoryArrayMappedAddressEntries 
//									api function to get number of 
//									memory array mapped addresses
//
//		GetMemoryArrayMappedAddressEntry
//									api function to get 
//									memory array mapped address
//									
//
*D*/

typedef struct {

			API_PROC     GetNumberOfMemoryArrayMappedAddressEntries;
			API_PROC     GetMemoryArrayMappedAddressEntry;

}  API_CLASS_MEMORY_ARRAY_MAPPED_ADDRESSES;

/////////////////////////////////////////////////////////////////////
//	API_CLASS_MEMORY_DEVICE_MAPPED_ADDRESSES
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_MEMORY_DEVICE_MAPPED_ADDRESSES
//  Purpose:   
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetNumberOfMemoryDeviceMappedAddressEntries
//									api function to get number of 
//									memory device mapped addresses
//
//		GetMemoryDeviceMappedAddressEntry
//									api function to get 
//									memory device mapped address
//									
//
*D*/

typedef struct {

			API_PROC     GetNumberOfMemoryDeviceMappedAddressEntries;
			API_PROC     GetMemoryDeviceMappedAddressEntry;

}  API_CLASS_MEMORY_DEVICE_MAPPED_ADDRESSES;



/////////////////////////////////////////////////////////////////////
//	API_CLASS_OPERATING_SYSTEM
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_OPERATING_SYSTEM
//  Purpose:   Structure to get OS information
//
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//		GetNumOfOperatingSystems	api function to gets the
//									number of OSes installed in the system
//
//		GetOperatingSystemInfo		function to get OS information 
//									
//									
//
*D*/

typedef struct 
{   
		API_PROC 	GetNumOfOperatingSystems;
		API_PROC 	GetOperatingSystemInfo;
} API_CLASS_OPERATING_SYSTEM;



/////////////////////////////////////////////////////////////////////
//	API_CLASS_SERIAL_PORTS
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_SERIAL_PORTS
//  Purpose:   Structure to get serial ports info
//
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		GetNumberOfSerialPorts - gets the number of serial ports 
//										 installed in the system
//
//				GetSerialPortInfo	   - gets information about the specified
//										 serial port		
//									
//
*D*/

typedef struct 
{   
		API_PROC 	GetNumberOfSerialPorts;
		API_PROC	GetSerialPortInfo;
} API_CLASS_SERIAL_PORTS;

/////////////////////////////////////////////////////////////////////
//	API_CLASS_PARALLEL_PORTS
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_PARALLEL_PORTS
//  Purpose:   Structure to get parallel ports info
//
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		GetNumberOfParallelPorts - gets the number of parallel ports 
//										 installed in the system
//
//				GetSerialPortInfo	   - gets information about the specified
//										 parallel port		
//									
//
*D*/

typedef struct 
{   
		API_PROC 	GetNumberOfParallelPorts;
		API_PROC	GetParallelPortInfo;
} API_CLASS_PARALLEL_PORTS;

/////////////////////////////////////////////////////////////////////
//	API_CLASS_KEYBOARD
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_KEYBOARD
//  Purpose:   Structure to get keyboard info
//
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		GetKeyboardInfo		gets information about the keyboard
//									
//
*D*/
typedef struct 
{   
		API_PROC 	GetKeyboardInfo;
		API_PROC	GetKeyboardFruInfo;
} API_CLASS_KEYBOARD;

/////////////////////////////////////////////////////////////////////
//	API_CLASS_MOUSE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_MOUSE
//  Purpose:   Structure to get mouse information
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		GetMouseInfo		gets mouse info.
//									
//
*D*/
typedef struct 
{   
		API_PROC 	GetMouseInfo;
		API_PROC 	GetMouseFruInfo;
} API_CLASS_MOUSE;



/////////////////////////////////////////////////////////////////////
//	 API_CLASS_VIDEO
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_VIDEO
//  Purpose:   Structure to get video information
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//		GetNumberOfVideoDevices		gets the no. of video devices installed
//		GetVideoInfo				function to get specified video info.
//									
//									
//
*D*/
typedef struct 
{   
		API_PROC	GetNumberOfVideoDevices;
		API_PROC 	GetVideoInfo;
		API_PROC 	GetVideoFruInfo;
} API_CLASS_VIDEO;


/////////////////////////////////////////////////////////////////////
//	API_CLASS_VIDEO_BIOS
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_VIDEO_BIOS
//  Purpose:   Structure to get video bios info.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//				GetVideoBiosInfo	api function to get video bios info
//
*D*/
typedef struct 
{   
		API_PROC 	GetVideoBiosInfo;
} API_CLASS_VIDEO_BIOS;


// @@@@@ End New WFM groups - shashi 11/14/97 @@@@@

//API class for DPC Discovery
/////////////////////////////////////////////////////////////////////
//	API_CLASS_DPC_DISCOVERY
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      API_CLASS_DPC_DISCOVERY
//  Purpose:   Structure definition for DPC Discovery related APIs.
//
//  Context:   Used in 'DRIVER_API_STRUCT' structure definition
//
//  Fields:		
//
//
*D*/
typedef struct 
{   
	API_PROC	GetDpcDialNumberString;
	API_PROC	SetDpcDialNumberString;
   	API_PROC	GetDpcPartitionPresenceFlag;
   	API_PROC	GetDpcPartitionScanFlag;
   	API_PROC	GetDpcPartitionBootFlag;
   	API_PROC	SetDpcPartitionScanFlag;
   	API_PROC	SetDpcPartitionBootFlag;
   	API_PROC	SetPiSoftwareVersion;


} API_CLASS_DPC_DISCOVERY;



/////////////////////////////////////////////////////////////////////
//	API_CLASS_COOLING_UNIT
//////////////////////////////////////////////////////////////////////


typedef struct 
{   
	API_PROC	GetCoolingUnitNumber;
	API_PROC	GetCoolingUnitStatus;

} API_CLASS_COOLING_UNIT;



//////////////////////////////////////////////////////////////////////
// EVENT_CAPABILITY
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      EVENT_CAPABILITY
//  Purpose:   Enum type definition for event generation 
//				capability of the api class entity
//  Context:   Used in DIM to specify the event generation
//				of an api class supported by it.
.
//       
//     
*D*/



typedef enum { EVENT_FALSE,EVENT_TRUE } EVENT_CAPABILITY ;




//////////////////////////////////////////////////////////////////////
// EVENT_DATA_ANALOG
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      EVENT_DATA_ANALOG
//  Purpose:   Structure definition of event data for a sensor
//				with threshhold
//  Context:   Used in structure definition 'EVENT_DATA_SENSOR'
//       
//	Fields:
//		triggerCodeOffset	offset w.r.t. event type base code 'threshhold'
//			
//		sensorReading		value of the sensor reading during the event
//							expressed in terms of units of the monitored
//							parameter.
//
//		threshholdValue		value of the threshhold during event generation
//							expressed interms of units of the monitored
//							parameter.
//
//     
*D*/


typedef   struct {

                    // trigger  base class code is threshhold, so it is implied here.

                     unsigned char  triggerCodeOffset;
                     int            sensorReading;
                     int            threshholdValue;

                }EVENT_DATA_ANALOG;




//////////////////////////////////////////////////////////////////////
// EVENT_DATA_DISCRETE_DIGITAL
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      EVENT_DATA_DISCRETE_DIGITAL
//  Purpose:   Structure definition of event data for a 
//				Digital/Discrete  Sensor.
//  Context:   Used in structure definition 'EVENT_DATA_SENSOR'
//       
//	Fields:
//		triggerCodeOffset	offset w.r.t. event type base code 'threshhold'
//			
//		sensorReading		value of the sensor reading during the event
//							expressed in terms of units of the monitored
//							parameter.
//
//		threshholdValue		value of the threshhold during event generation
//							expressed interms of units of the monitored
//							parameter.
//
//		severityOffset		offset code w.r.t. event type base code 'Severity'		
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.
//     
*D*/


typedef   struct {

                     unsigned char  eventbaseCode;
                     unsigned char  eventOffset;
                     unsigned char  previousEventOffset;
                     unsigned char  severityOffset;   //w.r.t.event type code base  ‘SEVERITY’

                 }EVENT_DATA_DISCRETE_DIGITAL;


//note that all the above fields may not be filled with valid codes. Calling //application should check for invalid codes before using these values.




//////////////////////////////////////////////////////////////////////
// EVENT_DATA_SENSOR
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      EVENT_DATA_SENSOR
//  Purpose:   Structure definition of event data for a 
//				 Sensor Api Class Entity 
//.
//  Context:   Used By DIMM  to specify event related data.
//
//  Fields:
//
//  sensorIndex   index number of the sensor
//
// eventDataType   event specific type of the sensor (digital-discrete or analog)
//
// sensorType		monitoring-parameter specific type of the sensor 
//					(temperature,voltage etc.)
//
// eventCategory    event data structure, depending on the event specific type of 
//					of the sensor	
//
// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.

*D*/


typedef  struct {

                     int            sensorIndex;
                     unsigned char  eventDataType;  // 1 = analog
									                // 2 = discreteDigital
                     SENSOR_TYPE    sensorType;

                     union {

                             EVENT_DATA_ANALOG               analog;
							 EVENT_DATA_DISCRETE_DIGITAL     discreteDigital;

                           } eventCategory;

               }  EVENT_DATA_SENSOR;



//DMI BIOS based structure and enum definitions 
//////////////////////////////////////////////////////////////////////
// MEMORY_MODULE_LOCATION_CODE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      MEMORY_MODULE_LOCATION_CODE
//  Purpose:   Enum type definition for Memory module
//				location
//  Context:   used in 'MEMORY_MODULE_INFO' structure definition
.
//       
//     
*D*/





typedef  enum { 
			       MMP_LOCATION_OTHER = 1, 

			       MMP_LOCATION_UNKNOWN, 

			       MMP_SYSTEM_BOARD,

			       MMP_ISA_ADD_ON_CARD,
			
          		   MMP_EISA_ADD_ON_CARD,
 
			       MMP_PCI_ADD_ON_CARD,
	
			       MMP_MCA_ADD_ON_CARD,
 
			       MMP_PCMCIA_ADD_ON_CARD,
	   
			       MMP_PROPERIETARY_ADD_ON_CARD,

		           MMP_NU_BUS = 0x10,

			       MMP_ADD_ON_CARD_PC_98_C20 = 0xA0, 
	     
			       MMP_ADD_ON_CARD_PC_98_C24,

			       MMP_ADD_ON_PC_98_E ,
		
			       MMP_ADD_ON_PC_98_LOCAL_BUS,

			       MMP_ADD_ON_PC_98_CARD_SLOT
			

    		} MEMORY_MODULE_LOCATION_CODE;






//////////////////////////////////////////////////////////////////////
// MEMORY_MODULE_USAGE_CODE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      MEMORY_MODULE_USAGE_CODE
//  Purpose:   Enum type definition for Memory module
//				usage
//  Context:   Used in 'MEMORY_MODULE_INFO' structure 
//				defintion
//       
//     
*D*/




typedef  enum { 
		            MMU_OTHER = 1, 

		            MMU_UNKNOWN, 

		            MMU_SYSTEM_MEMORY,

		            MMU_VIDEO_MEMORY,
			
			    MMU_FLASH_MEMORY,
 
			    MMU_NON_VOLATILE_MEMORY
	
		    } MEMORY_MODULE_USAGE_CODE;






//////////////////////////////////////////////////////////////////////
// MEMORY_MODULE_ERROR_TYPE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      MEMORY_MODULE_ERROR_TYPE
//  Purpose:   Enum type definition for Memory module
//				error type
//  Context:   Used in 'MEMORY_MODULE_INFO' structure 
//				defintion
//       
//     
*D*/

typedef  enum { 

	       	        ME_OTHER = 1, 

		            ME_UNKNOWN, 

		            ME_OK,

		            ME_BAD_READ,
			
		            ME_PARITY,
			
		            ME_SINGLE_BIT,

			        ME_DOUBLE_BIT,
 
			        ME_MULTI_BIT,

			        ME_NIBBLE,
       
	                ME_CHECKSUM,

	                ME_CRC,

	                ME_CORRECTED_SINGLE_BIT,

	                ME_CORRECTED,

	                ME_UNCORRECTABLE
	
		} MEMORY_ERROR_TYPE;




//////////////////////////////////////////////////////////////////////
// MEMORY_MODULE_ERROR_CORRECTION_CODE
//////////////////////////////////////////////////////////////////////

/*D*
//  Name:      MEMORY_MODULE_ERROR_CORRECTION_CODE
//  Purpose:   Enum type definition for Memory module
//				supported error correction code
//  Context:   Used in 'MEMORY_MODULE_INFO' structure 
//				defintion
//       
//     
*D*/


typedef  enum { 
				MEC_OTHER = 1, 

				MEC_UNKNOWN, 

				MEC_NONE,

				MEC_PARITY,
			
				MEC_SINGLE_BIT_ECC,
 
				MEC_MULTI_BIT_ECC,

				MEC_CRC

       	} MEMORY_ERROR_CORRECTION_CODE;



//////////////////////////////////////////////////////////////////////
// MEMORY_DEVICE_FORM_FACTOR
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_DEVICE_FORM_FACTOR
//  Purpose:   Enum type definition for Memory Device's
//				form factor
//  Context:   Used in 'MEMORY_DEVICE_INFO' structure 
//				defintion
//       
//     
*D*/



typedef  enum { 
	     	     MDF_OTHER = 1, 

		         MDF_UNKNOWN, 

		         MDF_SIMM,

			     MDF_SIP,
			
		         MDF_CHIP,
 
		         MDF_DIP,

			     MDF_ZIP,

			     MDF_PROPRIETARY_CARD,

			     MDF_DIMM,

			     MDF_TSOP,

			     MDF_ROW_OF_CHIPS,

				 MDF_RIMM,

				 MDF_SODIMM
	 
		} MEMORY_DEVICE_FORM_FACTOR;




//////////////////////////////////////////////////////////////////////
// MEMORY_DEVICE_TYPE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_DEVICE_TYPE
//  Purpose:   Enum type definition for type ofMemory Device
//				
//  Context:   Used in 'MEMORY_DEVICE_INFO' structure 
//				defintion
//       
//     
*D*/



typedef  enum { 
				MDT_OTHER = 1, 

				MDT_UNKNOWN, 

				MDT_DRAM,

				MDT_EDRAM,
			
				MDT_VRAM,
 
				MDT_SRAM,

				MDT_RAM,

				MDT_ROM,

				MDT_FLASH,

				MDT_EEPROM,

				MDT_FEPROM,

				MDT_EPROM,

				MDT_CDRAM,

				MDT_3DRAM,

				MDT_SDRAM,

				MDT_SGRAM
	 
		} MEMORY_DEVICE_TYPE;





//////////////////////////////////////////////////////////////////////
// MEMORY_DEVICE_TYPE_DETAIL
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_DEVICE_TYPE_DETAIL
//  Purpose:   Enum type definition for type ofMemory Device
//				
//  Context:   Used in 'MEMORY_DEVICE_INFO' structure 
//				defintion
//       
//     
*D*/



typedef  enum { 
		          MDTD_OTHER = 1, 

		          MDTD_UNKNOWN, 

		          MDTD_FAST_PAGED,

		          MDTD_STATIC_COLUMN,
			
		          MDTD_PSEUDO_STATIC,
 
		          MDTD_RAM_BUS,

			      MDTD_SYNCHRONOUS,

				  MDTD_CMOS,

				  MDTD_EDO,

				  MDTD_WINDOW_DRAM,

				  MDTD_CACHE_DRAM,

				  MDTD_NON_VOLATILE
	 
		} MEMORY_DEVICE_TYPE_DETAIL;








//////////////////////////////////////////////////////////////////////
// MEMORY_LAST_ERROR_UPDATE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_LAST_ERROR_UPDATE
//  Purpose:   Enum type definition for update time
//			   for most recently occured memory error	
//				
//  Context:   Used in 'MEMORY_MODULE_ERROR_INFO' structure 
//				defintion
//       
//     
*D*/


typedef  enum { 
		         MLE_OTHER = 1, 

		         MLE_UNKNOWN, 

		         MLE_NO_UPDATE_FROM_LAST_START,

		         MLE_UPDATE_PRIOR_TO_START,

		         MLE_UPDATE_DURING_RUN_TIME

	         } MEMORY_LAST_ERROR_UPDATE;



//////////////////////////////////////////////////////////////////////
// MEMORY_ERROR_OPERATION
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_ERROR_OPERATION
//  Purpose:   Enum type definition for type of
//				memory access operation during the occurence
//				of an memory error	
//				
//  Context:   Used in 'MEMORY_MODULE_ERROR_INFO' structure 
//				defintion
//       
//     
*D*/


typedef  enum { 

		      MEO_OTHER = 1, 

		      MEO_UNKNOWN, 

		      MEO_READ,

		      MEO_WRITE,

	          MEO_PARTIAL_WRITE

	} MEMORY_ERROR_OPERATION;



//////////////////////////////////////////////////////////////////////
// MEMORY_MODULE_ERROR_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_MODULE_ERROR_INFO
//  Purpose:   Structure type definition for data associated
//				with an error in a memory module. 	
//				
//  Context:   Used by DIM to return memory module
//				related error data (GetMemoryModuleErrorInfo).       
//     
//  Fields:
//    
//		errorType           type of the error
//
//		update				update instance
//
//		operation			memory access operation
//
//      transferSize		transfer size in bytes             
//	
//		errorData			erroneous data bytes buffer
//   
//		vSyndrome			vendor syndrome string buffer
//
//		errorAddress		physical memory address associated
//							with the error.
//
//		errorRange			error range in bytes.
*D*/



typedef  struct { 
		
			
                  MEMORY_ERROR_TYPE         errorType;

                  MEMORY_LAST_ERROR_UPDATE  update;

                  MEMORY_ERROR_OPERATION    operation;

                  int                       transferSize;

                  char                      errorData[64];  // erroneous data bytes

                  char                      vSyndrome[64];  // vendor syndrome

                  int                       errorAddress[2];// memory address at which
									                        // the error occuered.
                  int                       errorRange;     // error range in bytes


              } MEMORY_MODULE_ERROR_INFO;





//////////////////////////////////////////////////////////////////////
// MEMORY_ERROR_GRANULARITY
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_ERORR_GRANULARITY
//  Purpose:   Enum type definition for resolvable
//				granularity of the memory error
//				
//  Context:   Used in 'MEMORY_DEVICE_ERROR_INFO' structure 
//				defintion
//       
//     
*D*/





typedef  enum { 
         		      MEG_OTHER = 1, 

		              MEG_UNKNOWN, 

		              MEG_DEVICE_LEVEL,

		              MEG_MEMORY_PARTITION_LEVEL


	        } MEMORY_ERROR_GRANULARITY;




//////////////////////////////////////////////////////////////////////
// MEMORY_DEVICE_ERROR_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_DEVICE_ERROR_INFO
//  Purpose:   Structure type definition for data associated
//				with an error in a memory device. 	
//				
//  Context:   Used by DIM to return memory device error
//				related  data (GetMemoryDeviceErrorInfo).       
//     
//  Fields:
//    
//		errorType           type of the error
//
//	   granularity			resolvable granularity of the 
//							error
//
//		update				update instance
//
//		operation			memory access operation
//
//      dataSize			size in bytes of the data 
//							associated with the error.            
//	
//		errorData			erroneous data bytes buffer
//   
//		vSyndrome			vendor syndrome string buffer
//
//		dErrorAddress       error address relative to device
//
//		mErrorAddress		physical memory address(bus relative) associated
//							with the error.
//
//		errorRange			error range in bytes.
*D*/




typedef  struct { 
		
			
                  MEMORY_ERROR_TYPE          errorType;

                  MEMORY_ERROR_GRANULARITY   granularity;

                  MEMORY_LAST_ERROR_UPDATE   update;

                  MEMORY_ERROR_OPERATION     operation;

                  int                        dataSize;

                  char                       errorDataLength;

                  char                       errorData[64];  // erroneous data bytes

                  char                       vSyndromeLength;

                  char						 vSyndrome[64];  // vendor syndrome

                  int						 dErrorAddress;  // error start address relative
											                 // to the device

                  int                        mErrorAddress;  // memory address at which         
				                      						 // the error occuered relative to the 
				                 							 // to the bus for the memory module
					  
                  int						 errorRange;	// error range in bytes


            } MEMORY_DEVICE_ERROR_INFO;







//////////////////////////////////////////////////////////////////////
// PROCESSOR_TYPE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PROCESSOR_TYPE
//  Purpose:   Enum type definition for type of the processor
//				
//  Context:   Used in 'PROCESSOR_INFO' structure 
//				defintion
//       
//     
*D*/





/*************************************************************
 * PROCESSOR_TYPE
 ************************************************************/


typedef  enum { 

                  PT_OTHER=1,
                  PT_UNKNOWN,
                  PT_CENTRAL_PROCESSOR,
                  PT_MATH_PROCESSOR,
                  PT_DSP_PROCESSOR,
                  PT_VIDEO_PROCESSOR

             } PROCESSOR_TYPE;



//////////////////////////////////////////////////////////////////////
// PROCESSOR_FAMILY
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PROCESSOR_FAMILY
//  Purpose:   Enum type definition for the family of the processor
//				
//  Context:   Used in 'PROCESSOR_INFO' structure 
//				defintion
//       
//     
*D*/



/*************************************************************
 * PROCESSOR_FAMILY
 ************************************************************/


typedef  enum { 
                 PF_OTHER = 0x1,
                 PF_UNKNOWN,
                 PF_8086,
                 PF_80286,
                 PF_80386,
                 PF_80486,
                 PF_8087,
                 PF_80287,
                 PF_80387,
                 PF_80487,
                 PF_PENTIUM,
                 PF_PENTIUM_PRO,
                 PF_M1 = 0x12,
                 PF_K5 =19,
                 PF_POWER_PC = 0x20,
                 PF_POWER_PC_601,
                 PF_POWER_PC_603,
                 PF_POWER_PC_603_PLUS,
                 PF_POWER_PC_604,
                 PF_ALPHA_FAMILY = 0x30,
                 PF_MIPS_FAMILY = 0x40,
                 PF_SPARC_FAMILY=0x50,
                 PF_68040=0x60,
                 PF_68XXX_FAMILY,
                 PF_68000,
                 PF_68010,
                 PF_68020,
                 PF_68030,
                 PF_HOBBIT =0x70,
                 PF_WEITEK=0X80,
                 PF_PA_RISC=0X90,
                 PF_V30=0XA0


           } PROCESSOR_FAMILY;







//////////////////////////////////////////////////////////////////////
// PROCESSOR_UPGRADE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PROCESSOR_UPGRADE
//  Purpose:   Enum type definition for upgrade method of the processor
//				
//  Context:   Used in 'PROCESSOR_INFO' structure 
//				defintion
//       
//     
*D*/



/*************************************************************
 * PROCESSOR_UPGRADE
 ************************************************************/


typedef  enum { 

                 PU_OTHER=1,
                 PU_UNKNOWN,
                 PU_DAUGHTER_BOARD,
                 PU_ZIF_SOCKET,
                 PU_REPLACEMENT_PIGGY_BACK,
                 PU_NONE,
                 PU_LIF_SOCKET

              } PROCESSOR_UPGRADE;



//////////////////////////////////////////////////////////////////////
// CACHE_LEVEL
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      CACHE_LEVEL
//  Purpose:   Enum type definition for cache level
//				
//  Context:   Used in 'CACHE_INFO' structure 
//				defintion
//       
//     
*D*/


/*************************************************************
 * CACHE_LEVEL
 ************************************************************/


typedef  enum { 

                   CL_OTHER =1,
                   CL_UNKNOWN,
                   CL_PRIMARY,
                   CL_SECONDARY,
                   CL_TERTIARY
              } CACHE_LEVEL;


//////////////////////////////////////////////////////////////////////
// WRITE_POLICY
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      WRITE_POLICY
//  Purpose:   Enum type definition for write access policy
//				of the cache
//
//  Context:   Used in 'CACHE_INFO' structure 
//				defintion
//       
//     
*D*/




/*************************************************************
 * WRITE_POLICY
 ************************************************************/


typedef  enum { 

                   CW_OTHER=1,
                   CW_UNKNOWN,
                   CW_WRITE_BACK,
                   CW_WRITE_THROUGH
             } WRITE_POLICY;


//////////////////////////////////////////////////////////////////////
// ERROR_CORRECTION
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      ERROR_CORRECTION
//  Purpose:   Enum type definition for error correction
//				method for cache memory
//
//  Context:   Used in 'CACHE_INFO' structure 
//				defintion
//       
//     
*D*/




/*************************************************************
 * ERROR_CORRECTION
 ************************************************************/


typedef  enum { 

                   CE_OTHER=1,
                   CE_UNKNOWN,
                   CE_NONE,
                   CE_PARITY,
                   CE_SINGLE_BIT_ECC,
                   CE_MULTI_BIT_ECC

} ERROR_CORRECTION;


//////////////////////////////////////////////////////////////////////
// CACHE_TYPE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      CACHE_TYPE
//  Purpose:   Enum type definition for type of the cache
//				
//  Context:   Used in 'CACHE_INFO' structure 
//				defintion
//       
//     
*D*/




/*************************************************************
 * CACHE_TYPE
 ************************************************************/


typedef  enum { 

                CT_OTHER=1,
                CT_UNKNOWN,
                CT_CODE,
                CT_DATA,
                CT_UNIFIED

             } CACHE_TYPE;



//////////////////////////////////////////////////////////////////////
// BIOS_CHARACTERISTIC_ENUM
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      BIOS_CHARACTERISTSIC_ENUM
//  Purpose:   Enum type definition for Bios Characteristic.
//				
//  Context:   Used in 'BIOS_INFO' structure 
//				defintion
//       
//     
*D*/




/*************************************************************
 * BIOS_CHARACTERISTIC_ENUM
 ************************************************************/


typedef  enum {

                 BC_OTHER,
                 BC_UNKNOWN,
                 BC_UNSUPPORTED,
                 BC_ISA_SUPPORT,
                 BC_MCA_SUPPORT,
                 BC_EISA_SUPPORT,
                 BC_PCI_SUPPORT,
                 BC_PCMCIA_SUPPORT,
                 BC_PNP_SUPPORT,
                 BC_APM_SUPPORT,
                 BC_UPGRADEABLE_BIOS,
                 BC_SHADOWING_ALLOWED,
                 BC_VL_VESA_SUPPORT,
                 BC_ESCD_SUPPORT,
                 BC_PC_98

            }BIOS_CHARACTERISTIC_ENUM;


//////////////////////////////////////////////////////////////////////
// PRIMARY_BIOS_ENUM
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PRIMARY_BIOS_ENUM
//  Purpose:   Enum type definition to specify whether primary bios
//				or not
//				
//  Context:   Used in 'BIOS_INFO' structure 
//				defintion
//       
//     
*D*/



/*************************************************************
 * PRIMARY_BIOS_ENUM
 ************************************************************/


typedef  enum {

                 PB_FALSE,
                 PB_TRUE

              }PRIMARY_BIOS_ENUM;





//////////////////////////////////////////////////////////////////////
// SLOT_WIDTH
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SLOT_WIDTH
//  Purpose:   Enum type definition for width of the slot
//				
//  Context:   Used in 'SLOT_INFO' structure 
//				defintion
//       
//     
*D*/

/*************************************************************
 * SLOT_WIDTH
 ************************************************************/

typedef enum {

                SW_OTHER,
                SW_UNKNOWN,
                SW_CARD_8_BIT,
                SW_CARD_16_BIT,
                SW_CARD_32_BIT,
                SW_CARD_64_BIT,
                SW_CARD_128_BIT


             } SLOT_WIDTH;




//////////////////////////////////////////////////////////////////////
// SLOT_USAGE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SLOT_USAGE
//  Purpose:   Enum type definition for usage of the slot
//				
//  Context:   Used in 'SLOT_INFO' structure 
//				defintion
//       
//     
*D*/

/*************************************************************
 * SLOT_USAGE
 ************************************************************/
typedef enum {

                  SU_OTHER,
                  SU_UNKNOWN,
                  SU_AVAILABLE,
                  SU_IN_USE

            } SLOT_USAGE;


//////////////////////////////////////////////////////////////////////
// SLOT_CATEGORY
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SLOT_CATEGORY
//  Purpose:   Enum type definition for category of the slot
//				
//  Context:   Used in 'SLOT_INFO' structure 
//				defintion
//       
//     
*D*/


/*************************************************************
 * SLOT_CATEGORY
 ************************************************************/
typedef enum {
                 SC_OTHER,
                 SC_UNKNOWN,
                 SC_BUS_CONNECTOR,
                 SC_PCMCIA_SLOT,
                 SC_MOTHERBOARD


             }SLOT_CATEGORY;

       
//////////////////////////////////////////////////////////////////////
// POWER_SUPPLY_TYPE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      POWER_SUPPLY_TYPE
//  Purpose:   Enum type definition for type of the power
//				supply
//				
//  Context:   Used in 'POWER_SUPPLY_INFO' structure 
//				defintion
//       
//     
*D*/

typedef  enum {  

                   PST_OTHER,
                   PST_UNKNOWN,
                   PST_LINEAR,
                   PST_SWITCHING,
                   PST_BATTERY,
                   PST_UPS,
                   PST_CONVERTER,
                   PST_REGULATOR

             }POWER_SUPPLY_TYPE;


//////////////////////////////////////////////////////////////////////
// VOLTAGE_SWITCHING_RANGE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      VOLTAGE_SWITCHING_RANGE
//  Purpose:   Enum type definition for input voltage switching range 
//				capability of the power supply
//				
//  Context:   Used in 'POWER_SUPPLY_INFO' structure 
//				defintion
//       
//     
*D*/


typedef enum {
                VSR_OTHER,
                VSR_UNKNOWN,
                VSR_MANUAL,
                VSR_AUTOSWITCH,
                VSR_WIDE_RANGE,
                VSR_NOT_APPLICABLE

             }VOLTAGE_SWITCHING_RANGE;




//////////////////////////////////////////////////////////////////////
// ACTIVE_INPUT_RANGE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      ACTIVE_INPUT_RANGE
//  Purpose:   Enum type definition for current input voltage range 
//				capability of the power supply
//				
//  Context:   Used in 'POWER_SUPPLY_INFO' structure 
//				defintion
//       
//     
*D*/


typedef  enum {

                AIR_OTHER,
                AIR_UNKNOWN,
                AIR_RANGE_1,
                AIR_RANGE_2,
                AIR_BOTH

             }ACTIVE_INPUT_RANGE;



//////////////////////////////////////////////////////////////////////
// CONTROL_ACTION
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      CONTROL_ACTION
//  Purpose:   Enum type definition for action type
//				
//  Context:   Used in 'InitiateSystemControlAction' api 
//				function of the DIM
//       
//     
*D*/

 



/*************************************************************
 * CONTROL_ACTION
 ************************************************************/

typedef enum {

               IMMEDIATE_RESET = 1,
			   
			   IMMEDIATE_POWER_OFF,

               SHUTDOWN_ONLY,

               SHUTDOWN_AND_RESET,

               SHUTDOWN_AND_POWER_OFF,

               SHUTDOWN_AND_DELAYED_RESET,

               SHUTDOWN_AND_DELAYED_POWER_OFF,

               GENERATE_NMI

}CONTROL_ACTION;




//////////////////////////////////////////////////////////////////////
// WATCHDOG_TIMEOUT_ACTION_CODE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      WATCHDOG_TIMEOUT_ACTION_CODE
//  Purpose:   Enum type definition for timeout related action
//				of the watchdog timer.
//				
//  Context:   Used in 'SEtWatchDogTimeoutValue' api function
//				of the DIM
//       
//     
*D*/

/*************************************************************
 * WATCHDOG_TIMEOUT_ACTION_CODE
 ************************************************************/

typedef enum {

                RESET=1,

                POWEROFF,

                NMI

            } WATCHDOG_TIMEOUT_ACTION_CODE;


//////////////////////////////////////////////////////////////////////
// WATCHDOG_MODE
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      WATCHDOG_MODE
//  Purpose:   Enum type definition for operating mode
//				of the watchdog.
//
//  Context:   Used in 'ResetWatchdogTimer' api finction 
//				of the DIM.
//       
//     
*D*/



/*************************************************************
 * WATCHDOG_MODE
 ************************************************************/

typedef enum {

                  DISABLE = 1,

                  RUN

             } WATCHDOG_MODE;





//////////////////////////////////////////////////////////////////////
// CACHE_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      CACHE_INFO
//  Purpose:   Structure type definition for data	
//				related to cache
//  Context:   Used by DIM to return cache data 
//				(GetCacheInfo).       
//     
//  Fields:
//		level		cache level
//	
//		speed		cache speed in nanoseconds	
//
//		size		cache size in kilobytes
//	
//		writePolicy	write access policy for the cache.
//	
//		errorCorrection	 correction method for cache memory
//							related errors
//
//      type			type of the cache
*D*/



/*************************************************************
 * CACHE_INFO
 ************************************************************/


typedef  struct { 

                   CACHE_LEVEL             level;
                   int                     speed ;  // in Nanoseconds
                   int                     size  ;  // size of the cache in kilobytes
                   WRITE_POLICY            writePolicy;
                   ERROR_CORRECTION        errorCorrection;
                   CACHE_TYPE              type;


               } CACHE_INFO;





//DPC discovery related enum definitions

typedef	enum 	
	{
		PARTITION_PRESENCE_STATE_OTHER = 1,
		PARTITION_PRESENCE_STATE_UNKNOWN,
		PARTITION_PRESENCE_STATE_PRESENT,
		PARTITION_PRESENCE_STATE_NOT_PRESENT

	}PARTITION_PRESENCE_FLAG;



typedef	enum 	
	{
		PARTITION_SCAN_STATE_OTHER = 1,
		PARTITION_SCAN_STATE_UNKNOWN,
		PARTITION_SCAN_STATE_SCAN,
		PARTITION_SCAN_STATE_DO_NOT_SCAN

	}PARTITION_SCAN_FLAG;


typedef	enum 	
	{
		PARTITION_BOOT_STATE_OTHER = 1,
		PARTITION_BOOT_STATE_UNKNOWN,
		PARTITION_BOOT_STATE_BOOT,
		PARTITION_BOOT_STATE_DO_NOT_BOOT

	}PARTITION_BOOT_FLAG;








//////////////////////////////////////////////////////////////////////
// EVENT_DATA_MEMORY
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      EVENT_DATA_MEMORY
//  Purpose:   Structure type definition for data	
//				related to memory event.
//  Context:   Used by DIM to return memory event data. 
//				(in 'EVENT_DATA' structure).       
//     
//  Fields:
//		 deviceIndex       memory device's index number
//
//	     moduleIndex		memory modules's index number
//
//	     partitionIndex		index number of the memory partition                  
//
//	     eventOffset		offset number w.r.t. event type 'sensor
//							specific'   
*D*/


/*************************************************************
 * EVENT_DATA_MEMORY
 ************************************************************/

typedef  struct { 


		    

	                int deviceIndex;

	                int moduleIndex;

	                int partitionIndex;                  

	                unsigned char eventOffset;  

		  

		      } EVENT_DATA_MEMORY;




//////////////////////////////////////////////////////////////////////
// EVENT_DATA_PROCESSOR
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      EVENT_DATA_PROCESSOR
//  Purpose:   Structure type definition for data	
//				related to processor event .
//  Context:   Used by DIM to return processor event data. 
//				(in 'EVENT_DATA' structure).       
//     
//  Fields:
//		processorIndex  index number of the processor
//
//		eventOffset		offset number of the event w.r.t.
//						base event type 'Sensor Specific'
*D*/


/*************************************************************
 * EVENT_DATA_PROCESSOR
 ************************************************************/

typedef  struct { 


		             int processorIndex;

		             unsigned char eventOffset; // w.r.t. sensor specific event                                                             
					            				// base (processor sensor)



		        } EVENT_DATA_PROCESSOR;



#define MAX_OPTIONAL_EVENT_DATA   8

//////////////////////////////////////////////////////////////////////
// EVENT_DATA
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      EVENT_DATA
//  Purpose:   Structure type definition for data	
//				related to event.
//  Context:   Used by DIM to return event data. 
//				(if the framework has registered for it)       
//     
//  Fields:
//
//	 apiClassId			class Id of the api array associated with 
//						the event
//	 ciHandle[2];      this was passed by the ci framework in ‘CiGetApiInfo’  
//
//	 event             category specific event data
*D*/





typedef   struct {

                      int apiClassId;

                      int   ciHandle[2];     // this was passed by the ci framework in ‘CiGetApiInfo’  

                      union {

                               EVENT_DATA_SENSOR       sensorEventData;
                               EVENT_DATA_MEMORY       memoryEventData;
                               EVENT_DATA_PROCESSOR    processorEventData;

//depending on the requirement more structures will be  added 

                            }event;

					  //new additions for hot swap  events

					 int optEventData[MAX_OPTIONAL_EVENT_DATA];	


                  }EVENT_DATA;



typedef  ACCESS_STATUS (*CI_EVENT_ENTRY_POINT)(EVENT_DATA *eventData) ; 


// api Id specific constants

#define		API_CLASS_ID_SENSOR                                 1
#define     API_CLASS_ID_MEMORY                                 2
#define     API_CLASS_ID_PROCESSOR                              3
#define     API_CLASS_ID_BIOS		                            4
#define     API_CLASS_ID_CACHE                                  5
#define     API_CLASS_ID_SYSTEM_SECURITY                        6
#define     API_CLASS_ID_SYSTEM_CONTROL                         7
#define     API_CLASS_ID_EVENT_LOG                              8
#define     API_CLASS_ID_INVENTORY                              9
#define     API_CLASS_ID_SYSTEM_SLOTS                           10
#define     API_CLASS_ID_POWER_SUPPLY                           11
#define     API_CLASS_ID_PHYSICAL_CONTAINER                     12
#define     API_CLASS_ID_MEMORY_ARRAY_MAPPED_ADDRESSES			13
#define		API_CLASS_ID_MEMORY_DEVICE_MAPPED_ADDRESSES			14	
#define		API_CLASS_ID_OPERATING_SYSTEM						15
#define		API_CLASS_ID_SERIAL_PORTS							16
#define		API_CLASS_ID_PARALLEL_PORTS							17
#define		API_CLASS_ID_KEYBOARD								18
#define		API_CLASS_ID_MOUSE									19
#define		API_CLASS_ID_VIDEO									20
#define		API_CLASS_ID_VIDEO_BIOS								21
#define		API_CLASS_ID_STATUS_DISPLAY							22
#define		API_CLASS_ID_PAGING									23
//php - device
#define		API_CLASS_ID_PHP_DEVICE_GROUP						24

//definition for DPC discovery
#define		API_CLASS_ID_DPC_DISCOVERY							25

//definition for COOLING UNIT 
#define	API_CLASS_ID_COOLING_UNIT								26











/*************************************************************
 * DRIVER_API_STRUCT
 ************************************************************/


//////////////////////////////////////////////////////////////////////
// DRIVER_API_STRUCT
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      DRIVER_API_STRUCT
//  Purpose:   Structure type definition for specifying 	
//				api class data.
//  Context:   Used by DIM to pass the array of data structures
//				associated with apis supported by the DIM. cif
//				calls the dim using 'CiGetApiInfo' to get this
//				information. 
//				       
//     
//  Fields:
//
//	 apiClassId			class Id of the api associated with 
//						the event
//
//	 api				 category specific api data.
//
//	 capability			specifies whether the api class entity
//						is event-pron or not.
*D*/

#ifdef SOLARIS // Solaris can't handle packing this struct
#pragma pack()
#endif

typedef  struct { 

         			int apiClassId; // 1 = sensor
		        					// 2 = memory
		 		        			// 3 = processor        
						        	// 4 = bios
							        // 5 = cache
							        // 6 = system security
							        // 7 = system control
							        // 8 = event log
							        // 9 = inventory   
							        // 10 = system slots
							        // 11 = Power supply
							        // 12 = Physical Container
									// 13 = Memory Array Mapped Addresses
									// 14 = Memory Device Mapped Addresses
									// 15 = Operating System
									// 16 = Serial Ports
									// 17 = Parallel Ports
									// 18 = Keyboard
									// 19 = Mouse
									// 20 = Video
									// 21 = Video BIOS
									// 22 = Status Display (LCD)
									// 23 = Paging
					                // 25 = DPC discovery
					 
			         union {
							  void							*api_void;	// to quiet compiler
				              API_CLASS_SENSOR				*api_sensor;
				              API_CLASS_MEMORY				*api_memory;
				              API_CLASS_PROCESSOR			*api_processor;
				              API_CLASS_BIOS				*api_bios;
				              API_CLASS_CACHE				*api_cache;
				              API_CLASS_SYSTEM_SECURITY		*api_system_security;
				              API_CLASS_SYSTEM_CONTROL		*api_system_control;
				              API_CLASS_EVENT_LOG			*api_event_log;
				              API_CLASS_INVENTORY			*api_inventory;
				              API_CLASS_SYSTEM_SLOTS		*api_slots;
				              API_CLASS_POWER_SUPPLY		*api_power_supply;
				              API_CLASS_PHYSICAL_CONTAINER	*api_physical_container;
							  API_CLASS_MEMORY_ARRAY_MAPPED_ADDRESSES	*apiMemArrayMappedAddresses;
						      API_CLASS_MEMORY_DEVICE_MAPPED_ADDRESSES	*apiMemDeviceMappedAddresses;
							  API_CLASS_OPERATING_SYSTEM	*apiOperatingSystem;
							  API_CLASS_SERIAL_PORTS		*apiSerialPorts;
							  API_CLASS_PARALLEL_PORTS		*apiParallelPorts;
							  API_CLASS_KEYBOARD			*apiKeyboard;
							  API_CLASS_MOUSE				*apiMouse;
							  API_CLASS_VIDEO				*apiVideo;
							  API_CLASS_VIDEO_BIOS			*apiVideoBios;
							  API_CLASS_STATUS_DISPLAY		*apiStatusDisplay;
 							  //php - device
							  API_CLASS_PHP_DEVICE_GROUP	*apiPhpDeviceGroup;	

							  API_CLASS_PAGING				*apiPaging;

							//API Class for DPC discovery
							  API_CLASS_DPC_DISCOVERY		*apiDpcDiscovery;




		                  } api;


		 EVENT_CAPABILITY             capability;
	     
			 
		} DRIVER_API_STRUCT     ;

#ifdef SOLARIS
#pragma pack(1)
#endif


//////////////////////////////////////////////////////////////////////
// EVENT_BASED_API_CLASS
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      EVENT_BASED_API_CLASS
//  Purpose:   Structure type definition for specifying 	
//			   api class based entities to be registerd with DIM 
//			   for reporting events.
//	 
//  Context:   Used by CIF to pass array of api classes to the 
//			   DIM for reporting events. DIM will call CIF
//			   if an event associated with any of the entities of these
//			   api classes has occured.
//				       
//     
//  Fields:
//
//	 apiClassId			class Id of the api  
//						
//
//   ciHandle			handle passed by cif to the dim to 
//						to be returned during occurence of an 
//						event associated with the api based
//						entity.
//
//// NOTE: For more details refer to 'Madrona Instrumentation Driver Interface
//		 specification'.
 
*D*/




typedef  struct {


                  int   apiClassId;
                  int   ciHandle[2];  


	
                } EVENT_BASED_API_CLASS ;




//////////////////////////////////////////////////////////////////////
// FRU_DATA
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      FRU_DATA
//  Purpose:   Structure type definition for specifying 	
//			   FRU data.
//	 
//  Context:   Used by DIM to pass the fru data.
//				       
//     
//  Fields:
//   description      description of the fru .
//
//	 manufacturer	  manufacturer of the fru	
//
//   model			  model number of the fru	
//
//	 partNumber		  part number of the fru	
//
//	 serialNumber	  serial number of the fru	   
//
//	revisionLevel	  revision level number of the fru.
//
*D*/

 

/*************************************************************
 * FRU_DATA
 ************************************************************/

typedef struct {

                 STRING_DATA description;

                 STRING_DATA manufacturer;

                 STRING_DATA model;

                 STRING_DATA partNumber;

                 STRING_DATA serialNumber;   

                 STRING_DATA revisionLevel;

              } FRU_DATA;





//////////////////////////////////////////////////////////////////////
// MEMORY_MODULE_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_MODULE_INFO
//  Purpose:   Structure type definition for specifying 	
//				 memory module data.
//
//  Context:   Used by DIM to pass the memory module data
//				('GetMemoryModuleInfo')
//				       
//     
//  Fields:
//
//     numberOfPartitions  number of memory partitions in the module
//
//	   locationCode			location code of the memory module
//
//     usageCode			usage code of the memory module
//
//	  errorCode				main type of error correction
//							supported by the module     
//
//   maxMemoryCapacity      maximum mamoey capacity of the
//							memory module in magabytes.
//
// numberOfDeviceSockets	number of memory device sockets available on
//							the memory module
//
//numberOfDeviceSocketsUsed  number of device sockets used on the memory     
//								memory module.			
//
*D*/






/*************************************************************
 * MEMORY_MODULE_INFO
 ************************************************************/

typedef struct {



                     int                            numberOfPartitions;

                     MEMORY_MODULE_LOCATION_CODE    locationCode;

                     MEMORY_MODULE_USAGE_CODE	    usageCode;

                     MEMORY_ERROR_CORRECTION_CODE   errorCode; // main type of error correction
					                           				   //supported by the module     

                     int                            maxMemoryCapacity; // in megabytes

                     int                            numberOfDeviceSockets;

                     int                            numberOfDeviceSocketsUsed;      
			

                }MEMORY_MODULE_INFO;




//////////////////////////////////////////////////////////////////////
// MEMORY_DEVICE_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      MEMORY_DEVICE_INFO
//  Purpose:   Structure type definition for specifying 	
//				 memory device data.
//
//  Context:   Used by DIM to pass the memory module data
//				('GetMemoryDeviceInfo')
//				       
//     
//  Fields:
//     mModuleIndex;       index number of the memory module
//
//     mParitionIndex     index  number of the partition to which
//							this memory device belongs.	
//
//    mappedStartAddress   starting (physical) address of the device
//
//    mappedEndAddress		end     (physical)	address of the 	device
//
//	 partitionRowPosition   row position of the device within the
//							partition
//
//	 interleavePosition		interleaveposition of the device
//
//	 deviceLocator			locator string of the device
//
//	 bankLocator			bank locator string of the device
//
//	 size					size of the device in bytes
//
//  formFactor				form factor of the device
//
//  totalWidth              total width of the device in bits
//
//  dataWidth               width of the data bits of the device
//
//   dType					type of the device
//
//   dTypeDetail			device type detail byte
//
//   deviceSet				device set number
//
//   interleaveDepth		depth of the interleave
//
*D*/


/*************************************************************
 * MEMORY_DEVICE_INFO
 ************************************************************/

typedef struct {


                   int                        mModuleIndex;                 // memory module index

                   int                        mParitionIndex;               // partition index

                   int                        mappedStartAddress;

                   int                        mappedEndAddress;

                   int                        partitionRowPosition;

                   int                        interleavePosition;

                   STRING_DATA                deviceLocator;

                   STRING_DATA                bankLocator;

                   int                        size;  //in bytes

                   MEMORY_DEVICE_FORM_FACTOR  formFactor;

                   int                        totalWidth;              //total width in bits

                   int                        dataWidth;               //data width

                   MEMORY_DEVICE_TYPE         dType;

                   MEMORY_DEVICE_TYPE_DETAIL  dTypeDetail;

                   int                        deviceSet;

                   int                        interleaveDepth;

}MEMORY_DEVICE_INFO;




/*************************************************************
 * MEMORY_ARRAY_MAPPED_ADDRESS for sm bios
 ************************************************************/

typedef struct
{

	unsigned short		handle;
	unsigned long		startingAddress;
	unsigned long		endingAddress;
	unsigned short		memoryArrayHandle;
	unsigned char		partitionWidth;

} MEMORY_ARRAY_MAPPED_ADDRESS;

/*************************************************************
 * MEMORY_DEVICE_MAPPED_ADDRESS for sm bios
 ************************************************************/

typedef struct
{

	unsigned short		handle;
	unsigned long		startingAddress;
	unsigned long		endingAddress;
	unsigned short		memoryDeviceHandle;
	unsigned short		memoryArrayMappedAddressHandle;
	unsigned char		partitionRowPosition;
	unsigned char		interleavePosition;
	unsigned char		interleaveDataDepth;

} MEMORY_DEVICE_MAPPED_ADDRESS;




//////////////////////////////////////////////////////////////////////
// PROCESSOR_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PROCESSOR_INFO
//  Purpose:   Structure type definition for specifying 	
//				 processor data.
//
//  Context:   Used by DIM to pass the processor data
//				('GetProcessorInfo')
//				       
//     
//  Fields:
//      type				type of the processor
//
//      family				family type of the processor
//
//      version				version number of the processor
//
//      maxSpeed            maximum speed of the processor (in Mhz)
//
//      currentSpeed        current speed of the processor (in Mhz)
//
//      upgrade				processor upgrade method
//
//      l1CacheIndex		index number of the L1 cache      
//
//      l2CacheIndex		index number of the L2 cache	
//
//      l3CacheIndex;       index number of the L3 cache
*D*/




/*************************************************************
 * PROCESSOR_INFO
 ************************************************************/


typedef  struct { 
		
                    PROCESSOR_TYPE          type;
                    PROCESSOR_FAMILY        family;
                    STRING_DATA             version;
                    int                     maxSpeed;               //maximum speed in Mhz
                    int                     currentSpeed;           //current speed in Mhz
                    PROCESSOR_UPGRADE       upgrade;
                    int                     l1CacheIndex;      
                    int                     l2CacheIndex;
                    int                     l3CacheIndex;                       
					int						 status;


                } PROCESSOR_INFO;

#define		DIM_PROCESSOR_STATUS_ENABLED				0x3
#define		DIM_PROCESSOR_STATUS_DISABLED_BY_USER		0x4
#define		DIM_PROCESSOR_STATUS_DISABLED_BY_FIRMWARE	0x5




//////////////////////////////////////////////////////////////////////
// BIOS_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      BIOS_INFO
//  Purpose:   Structure type definition for specifying 	
//				 bios data.
//
//  Context:   Used by DIM to pass the bios data
//				('GetBiosInfo')
//				       
//     
//  Fields:
//
//	  manufacturer    bios manufacturer string
//
//    biosVersion	  bios version number string
//	
//    loaderVersion	  bios loader version string
//
//    releaseDate	  bios release data string	
//
//    romSize;        size of the bios ROM in kilobytes
//
//    startAddress	  starting physical address of the bios	
//
//    endAddress	  ending physical address of the bios	
//
//   primaryBios	  flag to specify whether primary bios or not	
//
//  characteristics   bios characteristics bit mask
//
//		bit0 = 1   not available (all other bits are invalid).
//		bit 1 = 1  ISA is supported      
//		bit 2 = 1  MCA is supported      
//		bit 3 = 1  EISA is supported     
//		bit 4 = 1  PCI is supported      
//		bit 5 = 1  PCMCIA is supported   
//		bit 6 = 1  PNP is supported      
//		bit 7 = 1  APM is supported      
//		bit 8 = 1  BIOS is upgradable
//		bit 9 = 1  shadowing is allowed  
//		bit 10 =1  VL-VESA is supported  
//		bit 12 =1  ESCD is supported     
//		bit 13 =1  boot from CD is supported     
//		bit 14 =1  selectable boot is supported  
//		bit 15 =1  BOOT ROM is socketed  
//		bit 16 =1  boot from PCMCIA is                                                       //                  supported       
//		bit 17 = 1 EDD  support is available     
//		bit 18 = 1 INT13 NEC9800 1.2 Mb                                                      //                  (3.5 inch, 360 rpm)     floppy                                      //                  is supported.   
//		bit 19 = 1 INT13 TOSHIBA 1.2 Mb                                                      //                  (3.5 inch, 360 rpm)     floppy                                      //                  is supported.                                           
//		bit 20 = 1 INT13 360 KB Floppy (5.25 inch)                                           //                      is supported                                            
//		bit 21 = 1 INT13 1.2MB Floppy (5.25 inch)                                                            //                      is supported.                                           
//		bit 22 = 1 INT13 720 MB Floppy (3.5 inch)                                            //                      is supported.                                           
//		bit 23 = 1 INT13 2.88 MB Floppy (3.5 inch)                                           //                      is supported.                   
//		bit 24 = 1 INT5  Print Screen supported
//		bit 25 = 1 INT9  8042 keyboard services 
//						 supported.
//		bit 26 = 1 INT14  serial services                                                    // supported.                                   
//		bit 27 = 1 INT17  Printer Services                                                                   supported.
//		bit 28 = 1 INT10 CGA video services                                                  //      supported
//		bit 29 = 1 PC98 supported.   
//		bits 31:30 reserved.

  *D*/


/*************************************************************
 * BIOS_INFO
 ************************************************************/


typedef  struct { 
		
                     STRING_DATA				manufacturer;
                     STRING_DATA                biosVersion;
                     STRING_DATA				loaderVersion;
                     STRING_DATA                releaseDate;
                     int                        romSize;         //in kilobytes
                     int                        startAddress;
                     int                        endAddress;
                     PRIMARY_BIOS_ENUM          primaryBios;
                     int						characteristics;    
	

              } BIOS_INFO;





//////////////////////////////////////////////////////////////////////
// SLOT_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SLOT_INFO
//  Purpose:   Structure type definition for specifying 	
//				 slot data.
//
//  Context:   Used by DIM to pass the bios data
//				('GetSlotInfo')
//				       
//     
//  Fields:
//
//	  slotType          type of the slot
//
//	  slotLength        length of the slot		
//
//	  width	            width of the slot
//
//	  currentUsage      current usage status of	the slot
//
//    slotDescription	description of the slot
//
//    slotCategory		category of the slot
*D*/					  			

/*************************************************************
 * SLOT_INFO
 ************************************************************/


typedef  struct {

                    int slotType ;  //bit   0     = 1  unknown. In this case all other bits                         //                                      are invalid
				                    //bit   1       =       1 slot supports ISA bus
				                    //bit   2       =       1 slot supports EISA bus
				                    //bit   3       =       1 slot supports MCA bus
				                    //bit   4       =       1 slot supports PCI bus
				                    //bit   5       =       1 slot supports VL bus
				                    //bit   6       =       1 slot supports PCMCIA bus
				                    //bit   7       =       1 slot supports NuBus
				                    //bit   8       =       1 slot supports PC-98/C20 bus
				                    //bit   9       =       1 slot supports PC-98/C24 bus
				                    //bit   10      =       1 slot supports PC-98/E bus
				                    //bit   11      =       1 slot supports PC-98/Local bus
				                    //bit   12      =       1 slot supports PC-98/Card Slot

                  unsigned char  slotLength ;     // 01 = other
				                        		  // 02 = unknown
					                              // 03 = half length
					                              // 04 = full length                       
  				  //add - pir
				  unsigned short slotID;	//id gotten from $PIR table

                  SLOT_WIDTH  width;

                  SLOT_USAGE  currentUsage;

                  STRING_DATA     slotDescription;

                  SLOT_CATEGORY slotCategory;


           }SLOT_INFO;


//php - pir
//////////////////////////////////////////////////////////////////////
// PHP_PIR_SLOT_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PHP_PIR_SLOT_INFO
//  Purpose:   Structure type definition for specifying php pir info 	
//  Context:   Used by DIM to pass the pir data	('GetPhpPIRSlotInfo')
//  Fields:
//		bSlotNumber -	php slot number
//		bBusNumber	-	php bus number
//		bDeviceNumber -	php device number
*D*/					  			
/*************************************************************
 * PHP_PIR_SLOT_INFO
 ************************************************************/
typedef struct {
		unsigned short	slotNumber;
		unsigned char	busNumber;
		unsigned char	deviceNumber;
}PHP_PIR_SLOT_INFO;





//////////////////////////////////////////////////////////////////////
// POWER_SUPPLY_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      POWER_SUPPLY_INFO
//  Purpose:   Structure type definition for specifying 	
//				 power supply data.
//
//  Context:   Used by DIM to pass the power supply data
//				('GetPowerSupplyInfo')
//				       
//     
//  Fields:
//    powerUnitIndexNumber  index numebr of the power unit
//
//		 type				type of the power supply
//
//	 inputVoltage1Low		low limit of input voltage1 in millivolts
//
//  inputVoltage1High       high limit of input voltage1 in millivolts
//
//	voltageSensor1Index     index number of output voltage sensor 1
//
//  currentSensor1Index		index number of output current sensor 1 
//
//  inputVoltage2Low 		low limit of input voltage2 in millivolts
//
// inputVoltage2High		high limit of input voltage2 in millivolts
//
// voltageSensor2Index		index number of output voltage sensor 2
//
// currentSensor2Index		index number of output voltage sensor 2
//
// inputRange				input voltage switching range code
//
// range					active input voltage range
//
// input1FrequencyLow     low limit of input voltage1  frequency in Hz.
//
// input1FrequencyHigh	  high limit of input voltage1  frequency in Hz.	
//
// input2FrequencyLow     low limit of input voltage2  frequency in Hz
//
// input2FrequencyHigh    high  limit of input voltage2  frequency in Hz..
//
// outputPower;           output power in watts          
//
// inputVoltageCapability  input voltage capability description 
//
*D*/





/*************************************************************
 * POWER_SUPPLY_INFO
 ************************************************************/


typedef  struct { 

                    int                        powerUnitIndexNumber;
                    POWER_SUPPLY_TYPE          type;
                    int                        inputVoltage1Low ;  // in millivolts
                    int                        inputVoltage1High;  // in millivolts
                    int                        voltageSensor1Index;
                    int                        currentSensor1Index;
                    int                        inputVoltage2Low ;  // in millivolts
                    int                        inputVoltage2High;  // in millivolts
                    int                        voltageSensor2Index;
                    int                        currentSensor2Index;
                    VOLTAGE_SWITCHING_RANGE    inputRange;
                    ACTIVE_INPUT_RANGE         range;
                    int                        input1FrequencyLow;  // in Hz.
                    int                        input1FrequencyHigh; // in Hz.
                    int                        input2FrequencyLow;  // in Hz.
                    int                        input2FrequencyHigh; // in Hz.
                    int                        outputPower;             // in Hz           
				    STRING_DATA                inputVoltageCapability;

            }POWER_SUPPLY_INFO;


typedef struct {

				 unsigned char  bCombVoltage;			// 7:4 - Voltage 1, 3:0 - Voltage 2
				 unsigned short usTotalCombWattage;		// 
} COMBINED_WATTAGE;

/*************************************************************
 * FRU_10_POWER_SUPPLY_INFO
 ************************************************************/


typedef  struct { 

                    unsigned short             usOverallCapacity;
                    unsigned short			   usPeakVA;
					unsigned char			   bInrushCurrent;
					unsigned char			   bInrushInterval; //in milliseconds

					unsigned short			   usInpVoltRange1Lo; // (10mV, LSB first)
					unsigned short			   usInpVoltRange1Hi; // (10mV, LSB first)
					unsigned short			   usInpVoltRange2Lo; // (10mV, LSB first)
					unsigned short			   usInpVoltRange2Hi; // (10mV, LSB first)

					unsigned char			   bInpFrequencyLo;
					unsigned char			   bInpFrequencyHi;

					unsigned char			   bACDropoutTolerance; // in milliseconds

					unsigned char			   bBinaryFlags;

					unsigned char			   usPeakWattage;

					COMBINED_WATTAGE		   combinedWattage;

					unsigned char			   bPredFailTachThresholdLo;


            }FRU_10_POWER_SUPPLY_INFO;



//////////////////////////////////////////////////////////////////////
// SYSTEM_CONTROL_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SYSTEM_CONTROL_INFO
//  Purpose:   Structure type definition for specifying 	
//				 system control data.
//
//  Context:   Used by DIM to pass the system control data
//				('GetSystemControlInfo')
//				       
//     
//  Fields:
//   actionCapbility	  action support related bit mask
//
//	 watchDogIncrementTime resolution of the watchdog time in
//							in milliseconds.
//
//  watchDogMaxCountTime   maximum timeout value of the watchdog 
//							in milliseconds
*D*/


/*************************************************************
 * SYSTEM_CONTROL_INFO
 ************************************************************/

typedef struct {



                    int      actionCapability;
					// bit 0 = 1 immediate power off supported

					// bit 1 = 1 immediate reset supported 
			
					// bit 2 = 1 NMI action supported
					

					
					// bit 3 = 1 shutdown only supported

					// bit 4 = 1 shutdown and reset supported

					// bit 5 = 1 shutdown and delayed reset                                                         //                      supported.
	 
					// bit 6 = 1 shutdown and power-off supported

					// bit 7 = 1 shutdown and delayed power-off supported.

					// bit 8 = 1 watchdog timer supported

					// bit 9 = 1 power off on timeout by
					//             watchdog timer spported

					// bit10 = 1 System reset on timeout
					//               by watchdog timer supported.   

					// all other bits are reserved.                 

                   int watchDogIncrementTime;	   // watchdog timer’s time interval per count in                                      
				                    			   // milli seconds.

                  int watchDogMaxCountTime;        // maximum time counted by watchdog timer in                                            //  milliseconds.   If ‘enabled’, the watchdog timer                                            //  must be reset within this time before the                                          
				                    	           // timeout . 

// The above two fields are valid only is ‘watchdog’ supported field is set
// else these values will be set to 0x80000000.


} SYSTEM_CONTROL_INFO;


//////////////////////////////////////////////////////////////////////
// SECURITY_STATUS
//////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SECURITY_STATUS
//  Purpose:   Enum type definition for specifying security status 
//				of the system
//				
//  Context:   Used in 'SECURITY_INFO' structure 
//				defintion
//       
//     
*D*/




typedef enum{    

	           STATUS_OTHER = 1,
               STATUS_UNKNOWN,
	           STATUS_DISABLED,
	           STATUS_ENABLED,
	           STATUS_NOT_IMPLEMENTED
	
	
           }SECURITY_STATUS ;

//////////////////////////////////////////////////////////////////////
// SECURITY_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SECURITY_INFO
//  Purpose:   Structure type definition for specifying 	
//				 security status of the system.
//
//  Context:   Used by DIM to pass the system security status info
//				('GetSecurityInfo')
//				       
//     
//  Fields:
//
//	 powerOnPassword    status of the power on password
//
//	 keyBoardPassword   status of the keyboard
//
//   administratorPassword status of administrator password
//
//	frontPanelReset       status of the front panel buttons

*D*/


typedef struct {

	             SECURITY_STATUS powerOnPassword;
	             SECURITY_STATUS keyBoardPassword;
	             SECURITY_STATUS administratorPassword;
	             SECURITY_STATUS frontPanelReset;


              } SECURITY_INFO;


//////////////////////////////////////////////////////////////////////
// PHYSICAL_CONTAINER_TYPE
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PHYSICAL_CONTAINER_TYPE
//  Purpose:   Enum type definition for specifying 	
//				 type of the physical container
//
//  Context:   Used in 'PHYSICAL_CONTAINER_INFO' structure definition
//				       
//     
//  
*D*/

typedef enum {

                    CONTAINER_TYPE_OTHER =1,
                    CONTAINER_TYPE_UNKNOWN,
                    CONATINER_TYPE_DESKTOP,
                    CONTAINER_TYPE_LOW_PROFILE_DESKTOP,
                    CONTAINER_TYPE_PIZZA_BOX,
                    CONTAINER_TYPE_MINI_TOWER,
                    CONTAINER_TYPE_TOWER,
                    CONTAINER_TYPE_PORTABLE,
                    CONTAINER_TYPE_LAPTOP,
                    CONTAINER_TYPE_NOTEBOOK,
                    CONTAINER_TYPE_HAND_HELD,
                    CONTAINER_TYPE_DOCKING_STATION,
                    CONTAINER_TYPE_All_IN_ONE,
                    CONTAINER_TYPE_SUB_NOTE_BOOK,
                    CONTAINER_TYPE_SPACE_SAVING,
                    CONTAINER_TYPE_LUNCH_BOX,
                    CONTAINER_TYPE_MAIN_SYSTEM_CHASSIS,
                    CONTAINER_TYPE_EXPANSION_CHASSIS,
                    CONTAINER_TYPE_SUB_CHASSIS,
                    CONTAINER_TYPE_BUS_EXPANSION_CHASSIS,
                    CONTAINER_TYPE_PERIPHERAL_CHASSIS,
                    CONTAINER_TYPE_RAID_CHASSIS,
                    CONTAINER_TYPE_RACK_MOUNT_CHASSIS



} PHYSICAL_CONTAINER_TYPE;




//////////////////////////////////////////////////////////////////////
// PHYSICAL_CONTAINER_BOOT_STATE
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PHYSICAL_CONTAINER_BOOT_STATE
//  Purpose:   Enum type definition for specifying 	
//				boot state of the physical container
//
//  Context:   Used in 'PHYSICAL_CONTAINER_INFO' structure definition
//				       
//     
//  
*D*/

typedef enum {

                  CONTAINER_BOOT_STATE_OTHER = 1,
                  CONTAINER_BOOT_STATE_UNKNOWN,
                  CONTAINER_BOOT_STATE_OK,
                  CONTAINER_BOOT_STATE_NON_CRITICAL,
                  CONTAINER_BOOT_STATE_CRITICAL,
                  CONTAINER_BOOT_STATE_NON_RECOVERABLE

            }PHYSICAL_CONTAINER_BOOT_STATE;

//////////////////////////////////////////////////////////////////////
// PHYSICAL_CONTAINER_LOCK_STATE
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PHYSICAL_CONTAINER_LOCK_STATE
//  Purpose:   Enum type definition for specifying 	
//				 lock state of the physical container
//
//  Context:   Used in 'PHYSICAL_CONTAINER_INFO' structure definition
//				       
//     
//  
*D*/


typedef enum {

               CONTAINER_LOCK_NOT_PRESENT,
               CONTAINER_LOCK_PRESENT,
               CONTAINER_LOCK_STATE_UNKNOWN
             } PHYSICAL_CONTAINER_LOCK_STATE;


//////////////////////////////////////////////////////////////////////
// PHYSICAL_CONTAINER_POWER_STATE
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PHYSICAL_CONTAINER_POWER_STATE
//  Purpose:   Enum type definition for specifying 	
//				 type of the physical container
//
//  Context:   Used in 'PHYSICAL_CONTAINER_INFO' structure definition
//				       
//     
//  
*D*/



typedef enum {

                CONTAINER_POWER_STATE_OTHER = 1,
                CONTAINER_POWER_STATE_UNKNOWN,
                CONTAINER_POWER_STATE_OK,
                CONTAINER_POWER_STATE_NON_CRITICAL,
                CONTAINER_POWER_STATE_CRITICAL,
                CONTAINER_POWER_STATE_NON_RECOVERABLE

            }PHYSICAL_CONTAINER_POWER_STATE;


//////////////////////////////////////////////////////////////////////
// PHYSICAL_CONTAINER_THERMAL_STATE
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PHYSICAL_CONTAINER_THERMAL_STATE
//  Purpose:   Enum type definition for specifying 	
//				 thermal state the physical container
//
//  Context:   Used in 'PHYSICAL_CONTAINER_INFO' structure definition
//				       
//     
//  
*D*/

typedef enum {

                CONTAINER_THERMAL_STATE_OTHER = 1,
                CONTAINER_THERMAL_STATE_UNKNOWN,
                CONTAINER_THERMAL_STATE_OK,
                CONTAINER_THERMAL_STATE_NON_CRITICAL,
                CONTAINER_THERMAL_STATE_CRITICAL,
                CONTAINER_THERMAL_STATE_NON_RECOVERABLE


            }PHYSICAL_CONTAINER_THERMAL_STATE;


//////////////////////////////////////////////////////////////////////
// PHYSICAL_CONTAINER_SECURITY_STATE
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PHYSICAL_CONTAINER_TYPE
//  Purpose:   Enum type definition for specifying 	
//				 security state of the physical container
//
//  Context:   Used in 'PHYSICAL_CONTAINER_INFO' structure definition
//				       
//     
//  
*D*/



typedef enum {

                 CONTAINER_SECURITY_STATE_OTHER = 1,
                 CONTAINER_SECURITY_STATE_UNKNOWN,
                 CONTAINER_SECURITY_STATE_OK,
                 CONTAINER_SECURITY_STATE_BREACH_DETECTED


            }PHYSICAL_CONTAINER_SECURITY_STATE;



//////////////////////////////////////////////////////////////////////
// PHYSICAL_CONTAINER_INFO
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      PHYSICAL_CONTAINER_INFO
//  Purpose:   Structure type definition for specifying 	
//				 information of the physical container.
//
//  Context:   Used by DIM to pass the  information of the
//				physical container ('GetPhysicalContainerInfo')
//				       
//     
//  Fields:
//
//              containerType       type of the physical container
//
//              assetTag			 asset tag string
//
//             lockState             lock state of the physical
//									 container.
//
//             bootState             boot state of the physical
//                                   container
//
//             powerState            power state of the physical 
//                                   container
//
//            thermalState           thermal state of the physical
//                                   container
//
//            containerName          name of the physical container 
//
//            containerLocation      physical container location string
//
//            securityState          security state of the physical 
//                                   container. 
*D*/



typedef struct {

                  PHYSICAL_CONTAINER_TYPE                 containerType;
                  STRING_DATA                             assetTag;
                  PHYSICAL_CONTAINER_LOCK_STATE           lockState;
                  PHYSICAL_CONTAINER_BOOT_STATE           bootState;
                  PHYSICAL_CONTAINER_POWER_STATE          powerState;
                  PHYSICAL_CONTAINER_THERMAL_STATE        thermalState;
                  STRING_DATA                             containerName;
                  STRING_DATA                             containerLocation;
                  PHYSICAL_CONTAINER_SECURITY_STATE       securityState;
              } PHYSICAL_CONTAINER_INFO;


//////////////////////////////////////////////////////////////////////
// STATUS_DISPLAY_INFO
/////////////////////////////////////////////////////////////////////
//  Name:      STATUS_DISPLAY_INFO
//  Purpose:   Structure type definition for specifying 	
//				 information of the physical container.
//
//  Context:   Used by DIM to pass the  information of the
//				physical container ('GetStatusDisplayInfo')
//				       
//     
//  Fields:
//
//              rows		display row cont
//				columns		display column count
//				state		current display state (type STATUS_DISPLAY_STATE)
//				name		display name
//
typedef enum {

	STATUS_DISPLAY_OTHER = 1,
	STATUS_DISPLAY_UNKNOWN,
	STATUS_DISPLAY_OFF,
	STATUS_DISPLAY_ON

} STATUS_DISPLAY_STATE;

typedef struct {

    int						rows;
    int						columns;
    STATUS_DISPLAY_STATE	state;
	STRING_DATA				name;

} STATUS_DISPLAY_INFO;

////////////////////////////////////////////////////////////////////////////
// PAGING structures
////////////////////////////////////////////////////////////////////////////

typedef struct {
	int	 Version;			// pep version supported on this platform
	int Pep_Supported;		// True YES, False no
	unsigned int Max_Page_String_Size;	// maximum size of the Page string
} PAGING_CAPS;

#define NV_FILTERING		1
#define V_FILTERING			2
#define LOGGING				3
#define PAGING				4

typedef struct {
	int which_to_set;		/* which one of folllowing is to be set or used */
	int Enable_nv_Filtering;		// True - Yes, False - no
	int Enable_v_Filtering;		// True - Yes, False - no
	int Enable_Logging;		// True - Yes, False - no
	int Enable_Paging;			// True - Yes, False - no
} PAGING_CONFIGURATION;

#define MAX_PAGING_STRING_SIZE  128

typedef struct {
	unsigned char String_Type; // NV or RAM string
	char Page_String[MAX_PAGING_STRING_SIZE];
} PAGE_STRING;





//@@@@@ New WFM groups - shashi 11/14/97 @@@@@

//////////////////////////////////////////////////////////////////////
// ESTORAGE_TYPE
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      ESTORAGE_TYPE
//  Purpose:   
//
//  Context:   Used by CIF to register for events
//
//	Arguments:
//
*D*/

typedef enum
{
	EST_OTHER=1,
	EST_UNKNOWN,
	EST_HARD_DISK,
	EST_FLOPPY_DISK,
	EST_OPTICAL_ROM,
	EST_OPTICAL_WORM,
	EST_OPTICAL_RW,
	EST_COMPACT_DISK,
	EST_FLASH_DISK,
	EST_BERNOULLI,
	EST_OPTICAL_FLOPPY_DISK
}ESTORAGE_TYPE;


//////////////////////////////////////////////////////////////////////
// SOperatingSystemInfo
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SOperatingSystemInfo
//  Purpose:   
//
//  Context:   Used by CIF to register for events
//
//	Arguments:
//
*D*/

typedef struct{
					STRING_DATA 	sdOSName;			// OS Name
					STRING_DATA 	sdOSVersion;	    // OS Version
					unsigned char	bIsPrimary;			// TRUE if this is the primary OS.
					ESTORAGE_TYPE 	eStorageType;		// Boot Device Storage type	
					int				nBootDeviceIndex;	// Index into the Disks table ??
					STRING_DATA		sdDescription;		// OS Description
			  }SOperatingSystemInfo;




//////////////////////////////////////////////////////////////////////
// SSerialPortInfo and related enums
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SSerialPortInfo
//  Purpose:   
//
//  Context:   Used by CIF to register for events
//
//	Arguments:
//
*D*/

typedef enum
{
	ECT_OTHER = 1,
	ECT_UNKNOWN,
	ECT_DB9_PIN_MALE,
	ECT_DB9_PIN_FEMALE,
	ECT_DB25_PIN_MALE,
	ECT_DB25_PIN_FEMALE,
	ECT_RJ_11,
	ECT_RJ_45,
	ECT_PROPRIETARY,
	ECT_CIRCULAR_DIN8_MALE,
	ECT_CIRCULAR_DIN8_FEMALE
} EConnectorType;

typedef enum
{
	SPC_OTHER=1,
	SPC_UNKNOWN,
	SPC_XT_AT_COMPATIBLE,
	SPC_16450_COMAPTIBLE,
	SPC_16550_COMPATIBLE,
	SPC_16550A_COMPATIBLE
} ESerialPortCapabilities;

typedef struct
{
	int						nPortAddress;	// Port Address
	int						nIRQUsed;		// Port IRQ 
	STRING_DATA				sdLogicalName;  // Port Name
	EConnectorType			eConnectorType; // Connector Type
	int						nMaximumSpeed;	// Maximum speed
	ESerialPortCapabilities	eCapabilities;
} SSerialPortInfo;

//////////////////////////////////////////////////////////////////////
// Parallel Port info and related enum
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:		Parallel Port info
//  Purpose:   
//
//  Context:   Used by CIF to register for events
//
//	Arguments:
//
*D*/

typedef enum
{
	CTP_OTHER = 1,
	CTP_UNKNOWN,
	CTP_DB25_PIN_FEMALE,
	CTP_DB25_PIN_MALE,
	CTP_CENTRONICS,
	CTP_MINI_CENTRONICS,
	CTP_PROPRIETARY
} EParallelPortConnectorType;

typedef enum 
{
	ECP_OTHER = 1,
	ECP_UNKNOWN,
	ECP_XT_AT,
	ECP_PS2,
	ECP_IEEE_1284,
	ECP_PROPRIETARY
}EConnectorPinout;

// Port capabilities
/*
	"Bit 0 (2^0) set = XT/AT compatible, \n "
	"Bit 1 (2^1) set = PS/2 compatible, \n "
	"Bit 2 (2^2) set = ECP, \n "
	"Bit 3 (2^3) set = EPP, \n "
	"Bit 4 (2^4) set = PC-98, \n "
	"Bit 5 (2^5) set = PC-98-Hireso, \n "
	"Bit 6 (2^6) set = PC-H98"
*/
typedef enum
{
	PPC_XT_AT_COMPATIBLE	= 0x0,
	PPC_PS2_COMAPTIBLE		= 0x1,
	PPC_ECP					= 0x2,
	PPC_EPP					= 0x4,
	PPC_PC_98				= 0x8,
	PPC_PC_98_HIRESO		= 0x10,
	PPC_H98					= 0x20
} EParallelPortCapabilities;

typedef struct
{
	int							nPortAddress; 	// Port Address
	int							nIRQUsed;		// Port IRQ 
	STRING_DATA					sdLogicalName;  // Port Name
	EParallelPortConnectorType	eConnectorType;	// connector type
	EConnectorPinout			ePinout;		// connector pinout
	unsigned char				bDMASupport;	// TRUE if supported
	EParallelPortCapabilities	eCapabilities;  // capabilities
} SParallelPortInfo;




//////////////////////////////////////////////////////////////////////
// SKeyboardInfo and related enums
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SKeyboardInfo 
//  Purpose:   
//
//  Context:   Used by CIF to register for events
//
//	Arguments:
//
*D*/

typedef enum
{
	KCT_OTHER=1,
	KCT_UNKNOWN,
	KCT_MINI_DIN,
	KCT_MICRO_DIN,
	KCT_PS2,
	KCT_INFRARED,
	KCT_HP_HIL,
	KCT_DB9,
	KCT_ACCESS_BUS,
	KCT_PC_98
} EkeyboardConnectorType;

typedef enum
{
	KBSS_OTHER = 1,
	KBSS_UNKNOWN,
	KBSS_NONE,
	KBSS_EXT_IF_LOCKED_OUT,
	KBSS_EXT_IF_ENABLED
}EKBSecuritySettings;

typedef struct
{
	STRING_DATA 			sdKeyboardLayout; 
	STRING_DATA 			sdKeyboardType;
	EkeyboardConnectorType 	eConnectorType;
	EKBSecuritySettings		eSecurity;
} SKeyboardInfo;


//////////////////////////////////////////////////////////////////////
// SMouseInfo and related enum
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SMouseInfo
//  Purpose:   
//
//  Context:   Used by CIF to register for events
//
//	Arguments:
//
*D*/
typedef enum
{
	MI_OTHER=1,
	MI_UNKNOWN,
	MI_SERIAL,
	MI_PS2,
	MI_INFRARED,
	MI_HP_HIL,
	MI_BUS_MOUSE,
	MI_ADB,
	MI_BUS_MOUSE_DB9 = 160,
	MI_BUS_MOUSE_MICRO_DIN = 161
} EMouseInterface;

typedef enum 
{
	MSS_OTHER = 1,
	MSS_UNKNOWN,
	MSS_NONE,
	MSS_EXT_IF_LOCKED_OUT,
	MSS_EXT_IF_ENABLED
}EMouseSecuritySettings;

typedef struct
{
	EMouseInterface		eInterface;
	int					nIRQ;
	int 				nMouseButtons;
	STRING_DATA			sdPortName;
	STRING_DATA			sdDriverName;
	STRING_DATA			sdDriverVersion;
	EMouseSecuritySettings	eSecuritySettings;
} SMouseInfo;



//////////////////////////////////////////////////////////////////////
// SVideoInfo and related enum
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SVideoInfo
//  Purpose:   
//
//  Context:   Used by CIF to register for events
//
//	Arguments:
//
*D*/

typedef enum
{
	EVT_OTHER = 1,
	EVT_UNKNOWN,
	EVT_CGA,
	EVT_EGA,
	EVT_VGA,
	EVT_SVGA,
	EVT_MDA,
	EVT_HGC,
	EVT_MCGA,
	EVT_8514A,
	EVT_XGA,
	EVT_LINEAR_FRAME_BUFFER,
	EVT_PC_98
	
} EVideoType;

typedef enum
{
	VMT_OTHER=1,
	VMT_UNKNOWN,
	VMT_VRAM,
	VMT_DRAM,
	VMT_SRAM,
	VMT_WRAM,
	VMT_EDO_RAM,
	VMT_BURST_SYNCH_DRAM,
	VMT_PIPELINED_BURST_RAM
}EvideoMemoryType;


typedef enum
{
	VSM_OTHER=1,
	VSM_UNKNOWN,
	VSM_INTERLACED,
	VSM_NON_INTERLACED
}EScanMode;
typedef enum
{
	VPL_OTHER = 1,
	VPL_UNKNOWN,
	VPL_INTEGRATED,
	VPL_ADD_ON_CARD
}EVideoLocation;

typedef struct
{
	EVideoType 			eVideoType;
	int					nCurrentVideoMode;
	int 				nMinimumRefreshRate;
	int 				nMaximumRefreshRate;
	EvideoMemoryType	eVideoMemType;
	int					nVideoMemSize;
	EScanMode			eScanMode;	
	EVideoLocation		eLocation;
	int					nCurrVertRes;
	int					nCurrHorizRes;
	int 				nCurrBitsPerPixel;
	int					nCurrNoOfRows;
	int					nCurrNoOfCol;
	int 				nCurrRefreshRate;
} SVideoInfo;


//////////////////////////////////////////////////////////////////////
// SVideoBiosInfo
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      SVideoBiosInfo
//  Purpose:   
//
//  Context:   Used by CIF to register for events
//
//	Arguments:
//
*D*/


typedef struct
{
	STRING_DATA		sdManufacturer;
	STRING_DATA		sdVersion;
	STRING_DATA		sdReleaseDate;
	unsigned char	bShadowState;
}SVideoBiosInfo;

// @@@@@ End New WFM groups - shashi 11/14/97 @@@@@

// Entity ID definitions from IPMI v1.0 specification
typedef enum
{
	ENTITY_ID_UNSPEC	=	0,
	ENTITY_ID_OTHER,
	ENTITY_ID_UNKNOWN,
	ENTITY_ID_PROCESSOR,
	ENTITY_ID_DISK,
	ENTITY_ID_PERIPHERAL_BAY,
	ENTITY_ID_SYS_MGMT_MODULE,
	ENTITY_ID_SYSTEM_BOARD,
	ENTITY_ID_MEMORY_MODULE,
	ENTITY_ID_PROCESSOR_MODULE,
	ENTITY_ID_POWER_SUPPLY,
	ENTITY_ID_ADDIN_CARD,
	ENTITY_ID_FRONT_PANEL_BOARD,
	ENTITY_ID_BACK_PANEL_BOARD,
	ENTITY_ID_POWER_SYSTEM_BOARD,
	ENTITY_ID_DRIVE_BACKPLANE,
	ENTITY_ID_SYS_INT_EXP_BOARD,
	ENTITY_ID_OTHER_SYS_BOARD,
	ENTITY_ID_PROCESSOR_BOARD,
	ENTITY_ID_POWER_DOMAIN,
	ENTITY_ID_POWER_MODULE,
	ENTITY_ID_POWER_DIST_BOARD,
	ENTITY_ID_CHASSIS_BACK_PANEL_BOARD,
	ENTITY_ID_SYSTEM_CHASSIS,
	ENTITY_ID_SUB_CHASSIS,
	ENTITY_ID_OTHER_CHASSIS_BOARD,
	ENTITY_ID_DISK_DRIVE_BAY,
	ENTITY_ID_PERIPHERAL_BAY_2,
	ENTITY_ID_DEVICE_BAY,
	ENTITY_ID_COOLING_DEVICE,
	ENTITY_ID_COOLING_UNIT,
	ENTITY_ID_INTERCONNECT,
	ENTITY_ID_MEMORY_DEVICE,
	ENTITY_ID_SYS_MGMT_SOFTWARE,
	ENTITY_ID_BIOS,
	ENTITY_ID_OS,
	ENTITY_ID_SYSTEM_BUS,
	ENTITY_ID_GROUP
} IPMI10_ENTITY_ID;


////////////////////////////////////////////////////////////////////
//Cooling Unit related enum definitions
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      CoolingUnitStatus
//  Purpose:   
//
//  Context:   defined and used in CIF/DIM interface to pass cooling 
//				unit status
//
//	Arguments:
//
*D*/

typedef enum
{
	
		COOLING_UNIT_STS_OTHER = 1,
		COOLING_UNIT_STS_UNKNOWN,
		COOLING_UNIT_STS_NOT_APPLICABLE,
		COOLING_UNIT_STS_OFFLINE,
		COOLING_UNIT_STS_REDUNDANT,
		COOLING_UNIT_STS_REDUNDANCY_DEGRADED,
		COOLING_UNIT_STS_REDUNDANCY_LOST
		
} CoolingUnitStatus;

//////////////////////////////////////////////////////////////////////
// DIM_REGISTER_EVENT
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      DIM_REGISTER_EVENT
//  Purpose:   Function pointer definition for dim's entry point 	
//				.to register for event
//
//  Context:   Used by CIF to register for events
//
//	Arguments:
//    eventApiClassArray    pointer to array of api classes filled 
//                          with ci handles. These handles would be
//                          passed back during event generation by the dim
//
//    arrayNumber           number of elements in the event api class array.
//
//    eventFunctionPointer  pointer to the CIF's event entry point.
//                          DIM calls this point to report an event.
//
*D*/
typedef ACCESS_STATUS (*DIM_REGISTER_EVENT) (

   EVENT_BASED_API_CLASS      *eventApiClassArray ,
   int                        arrayNumber,
   CI_EVENT_ENTRY_POINT       eventFunctionPointer
   
   );



//////////////////////////////////////////////////////////////////////
// DIM_UNREGISTER_EVENT
/////////////////////////////////////////////////////////////////////
/*D*
//  Name:      DIM_UNREGISTER_EVENT
//  Purpose:   Function pointer definition for dim's entry point 	
//				.to un-register for event
//
//  Context:   Used by CIF to un-register for events
//
//	Arguments:
//    eventApiClassArray    pointer to array of api classes filled 
//                          with ci handles. These handles would be
//                          passed back during event generation by the dim
//
//    arrayNumber           number of elements in the event api class array.
//
//
*D*/

typedef ACCESS_STATUS (*DIM_UNREGISTER_EVENT) (

                                                EVENT_BASED_API_CLASS      *eventApiClassArray ,
                                                int                        arrayNumber
   
                                              );






//function prototypes

ACCESS_STATUS GetNumberOfSensors(

                                  SENSOR_TYPE    sType,
                                  int                        *sensorNumber

                                );


ACCESS_STATUS GetSensorCurrentValue(

                                       SENSOR_TYPE                     sType,
                                       int                             index,
                                       unsigned char                   eventBase,		
                                       int                             *value

);

//add - php
ACCESS_STATUS GetPhpArrayIndex(
							   int dmiIndex,
							   int *phpIndex
							  );


ACCESS_STATUS GetSensorInfo(

                             SENSOR_TYPE    sType,
                             int            index,
                             SENSOR_INFO    *sPointer
                           );


ACCESS_STATUS GetSensorThreshholdValue(

                                          SENSOR_TYPE       sType,
                                          int               index,
                                          THRESHHOLD_TYPE   tType,
                                          int               *value


                                      );


ACCESS_STATUS SetSensorThreshholdValue(

                                         SENSOR_TYPE     sType,
                                         int             index,
                                         THRESHHOLD_TYPE tType,
                                         int             tValue
                                      );



 ACCESS_STATUS  GetSensorFruInfo (

	 				               SENSOR_TYPE  type,  
	 				               int          index,
					               FRU_DATA     *fruData
		    
					             );



ACCESS_STATUS GetNumberOfMemoryModules(

                                         int    *numberOfModules
                                       );


ACCESS_STATUS GetMemoryModuleInfo(

                                       int                        index,
                                       MEMORY_MODULE_INFO         *memInfo
                                 );


ACCESS_STATUS GetMemoryModuleErrorInfo(

                                          int                          index,
                                          MEMORY_MODULE_ERROR_INFO     *errorPtr
                                       );



ACCESS_STATUS GetMemoryModuleFruInfo(

                                         int           index,
                                         FRU_DATA      *fruPtr
                                    );


ACCESS_STATUS GetMemoryModulePartitionAddress(

                                               int       mIndex,
                                               int       pIndex,
                                               int       *mStartAddress,
                                               int       *mEndAddress
                                             );



ACCESS_STATUS GetMemoryModulePartitionWidth(

                                                int    mIndex,
                                                int    pIndex,
                                                int    *pWidth
                                           );


ACCESS_STATUS GetNumberOfMemoryDevices(


                                               int     mIndex,
                                               int     *deviceNumber

                                     );



ACCESS_STATUS GetMemoryDeviceInfo(


                                      int                  mIndex,
                                      int                  dIndex,
                                      MEMORY_DEVICE_INFO   *deviceInfo
                                 );


ACCESS_STATUS GetMemoryDeviceErrorInfo(

                                         int              mIndex,
                                         int              dIndex,
                                         MEMORY_DEVICE_ERROR_INFO  *dErrorInfo
                                      );


ACCESS_STATUS GetMemoryDeviceFruInfo(

                                         int        mIndex,
                                         int        dIndex,
                                         FRU_DATA   *fruPtr
                                    );


ACCESS_STATUS GetNumberOfProcessors(

                                       int        *numberOfProcessors
                                   );
 




ACCESS_STATUS GetProcessorInfo(

                                  int                index,
                                  PROCESSOR_INFO     *processorInfo
                             );



ACCESS_STATUS GetProcessorFruInfo(

                                   int               index,
                                   FRU_DATA          *fruPtr
                                 );





ACCESS_STATUS GetNumberOfCache(

                                   int             *numberOfCaches
                              );




ACCESS_STATUS GetCacheInfo(

                                  int               index,
                                  CACHE_INFO        *cacheInfo
                          );




ACCESS_STATUS GetCacheFruInfo(

                                   int           index,
                                   FRU_DATA      *fruPtr
                             );






ACCESS_STATUS GetNumberOfBiosComponents(

                                           int    *numberOfBioses
                                       );






ACCESS_STATUS GetBiosInfo(

                            int                index,
                            BIOS_INFO          *biosInfo
                         );






ACCESS_STATUS GetBiosCharacteristicDescription(

                                                  int           index,
                                                  BIOS_CHARACTERISTIC_ENUM type,
                                                  STRING_DATA              *description
                                              );



  


ACCESS_STATUS GetNumberOfSystemSlots(

                                       int        *numberOfSlots
                                   );






ACCESS_STATUS GetSlotInfo(

                            int               index,
                            SLOT_INFO         *slotInfo
                         );




ACCESS_STATUS GetPowerSupplyInfo(
				                   int               index, 
				                   POWER_SUPPLY_INFO *pInfo
                    			 );



ACCESS_STATUS GetSystemControlInfo(

	                                SYSTEM_CONTROL_INFO *infoStructure

                              	 );

ACCESS_STATUS  InitiateSystemControlAction(

			                                CONTROL_ACTION  actionCode,
 
			                                int   delayTime

                                           );





ACCESS_STATUS ResetWatchDogTimer	(
                                         WATCHDOG_MODE mode
                                    );


ACCESS_STATUS SetWatchDogTimeoutValue  (
	                                       WATCHDOG_TIMEOUT_ACTION_CODE actionCode,
	                                       int                          timeOutValue
                                       );


ACCESS_STATUS GetSystemSecurityInfo(

                                        SECURITY_INFO *infoPtr
                                   );


ACCESS_STATUS GetPhysicalContainerInfo(
                                         PHYSICAL_CONTAINER_INFO *infoPtr
                                     );


ACCESS_STATUS GetPhysicalContainerFruInfo(

                                             FRU_DATA *fruPtr
                                         );


ACCESS_STATUS GetFruData(

                              int      *recordId,
                              FRU_DATA *fruPtr
                        );


ACCESS_STATUS SetFrontPanelSecureMode(

                                           SECURITY_STATUS status

                                      ) ;



ACCESS_STATUS GetEventLogRecord(
								 int *recordId ,
								 int  *timeStamp,
								 char *recordPtr,
								 int *recordLength
								);

 
// @@@@@ New WFM groups - shashi 11/14/97 @@@@@

// Memory array mapped addresses
ACCESS_STATUS	GetNumberOfMemoryArrayMappedAddressEntries(int *);
ACCESS_STATUS	GetMemoryArrayMappedAddressEntry(int, MEMORY_ARRAY_MAPPED_ADDRESS *);

// Memory device mapped addresses
ACCESS_STATUS	GetNumberOfMemoryDeviceMappedAddressEntries(int *);
ACCESS_STATUS	GetMemoryDeviceMappedAddressEntry(int, MEMORY_DEVICE_MAPPED_ADDRESS *);

// OS 
ACCESS_STATUS	GetNumOfOperatingSystems(int*);
ACCESS_STATUS	GetOperatingSystemInfo(int nOS, SOperatingSystemInfo* pOSInfo);

// Serial Ports
ACCESS_STATUS	GetNumberOfSerialPorts(int* nPorts);
ACCESS_STATUS	GetSerialPortInfo(int nPort, SSerialPortInfo* pPortInfo);

// Parallel Ports
ACCESS_STATUS	GetNumberOfParallelPorts(int* nPorts);
ACCESS_STATUS	GetParallelPortInfo(int nPort, SParallelPortInfo* pPortInfo);

// Keyboard
ACCESS_STATUS	GetKeyboardInfo(SKeyboardInfo*);
ACCESS_STATUS	GetKeyboardFruInfo(FRU_DATA*);

// Mouse
ACCESS_STATUS	GetMouseInfo(SMouseInfo*);
ACCESS_STATUS	GetMouseFruInfo(FRU_DATA*);

// Video
ACCESS_STATUS 	GetNumberOfVideoDevices(int*);
ACCESS_STATUS	GetVideoInfo(int nDevice, SVideoInfo*);
ACCESS_STATUS	GetVideoFruInfo(int, FRU_DATA*);
// Video BIOS
ACCESS_STATUS	GetVideoBiosInfo(int nDevice, SVideoBiosInfo*);


// @@@@@ End New WFM groups - shashi 11/14/97 @@@@@

//add - php **************************
ACCESS_STATUS GetNumberOfPhpSlots(int *num);
ACCESS_STATUS GetPhpArrayIndex(int dmiIndex,int *phpIndex);
ACCESS_STATUS GetPhpDeviceType(int index, STRING_DATA *);
ACCESS_STATUS GetPhpDeviceManufacturer(int index,STRING_DATA *);
ACCESS_STATUS GetPhpDeviceRevision(int index,STRING_DATA *);
//************************************
//
// Status Display prototypes
//
ACCESS_STATUS GetStatusDisplayInfo(	STATUS_DISPLAY_INFO *info );
ACCESS_STATUS SetStatusDisplayState( STATUS_DISPLAY_STATE *state );
ACCESS_STATUS GetStatusDisplayString( STRING_DATA *string );
ACCESS_STATUS SetStatusDisplayString( STRING_DATA *string );

// Paging prototypes
ACCESS_STATUS GetPepCapabilities (PAGING_CAPS *);
ACCESS_STATUS GetPepConfiguration (PAGING_CONFIGURATION *);
ACCESS_STATUS SetPepConfiguration (PAGING_CONFIGURATION *);
ACCESS_STATUS GetPageString		(PAGE_STRING *);
ACCESS_STATUS SetPageString		(PAGE_STRING *);
ACCESS_STATUS PageImmediate		(unsigned char mem_type); // NV or RAM


//DPC Discovery related  function prototypes

ACCESS_STATUS	GetDpcDialNumberString(char *dailString, int *stringLength);
ACCESS_STATUS	SetDpcDialNumberString(char *dailString, int  stringLength);
ACCESS_STATUS	GetDpcPartitionPresenceFlag(PARTITION_PRESENCE_FLAG *flag);
ACCESS_STATUS	GetDpcPartitionScanFlag(PARTITION_SCAN_FLAG *flag);
ACCESS_STATUS	GetDpcPartitionBootFlag(PARTITION_BOOT_FLAG *flag);
ACCESS_STATUS	SetDpcPartitionScanFlag(PARTITION_SCAN_FLAG flag);
ACCESS_STATUS	SetDpcPartitionBootFlag(PARTITION_BOOT_FLAG flag);
ACCESS_STATUS	SetPiSoftwareVersion(int majVer, int minVer);

//Cooling Unit related APIs
ACCESS_STATUS   GetCoolingUnitStatus(int index,CoolingUnitStatus *status);
ACCESS_STATUS	GetCoolingUnitNumber(int  *number);




#pragma pack()

#endif

