/******************************************************************************* ** ** FILE: ** SaHpi.h ** ** DESCRIPTION: ** This file provides the C language binding for the Service ** Availability(TM) Forum Platform Interface. It contains all of ** the prototypes and type definitions. Note, this file was ** generated from the Platform Interface specification document. ** ** SPECIFICATION VERSION: ** SAI-HPI-A.01.01 ** ** DATE: ** Thu Oct 3 14:48:41 2002 ** ** LEGAL: ** OWNERSHIP OF SPECIFICATION AND COPYRIGHTS. ** The Specification and all worldwide copyrights therein are ** the exclusive property of Licensor. You may not remove, obscure, or ** alter any copyright or other proprietary rights notices that are in or ** on the copy of the Specification you download. You must reproduce all ** such notices on all copies of the Specification you make. Licensor ** may make changes to the Specification, or to items referenced therein, ** at any time without notice. Licensor is not obligated to support or ** update the Specification. ** ** Copyright(c) 2002, Service Availability(TM) Forum. All rights ** reserved. ** *******************************************************************************/ #ifndef __SAHPI_H #define __SAHPI_H /******************************************************************************* ******************************************************************************** ********** ********** ********** Basic Data Types and Values ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* General Types - need to be specified correctly for the host architecture */ typedef unsigned char SaHpiUint8T; typedef unsigned short SaHpiUint16T; typedef unsigned int SaHpiUint32T; typedef char SaHpiInt8T; typedef short SaHpiInt16T; typedef int SaHpiInt32T; typedef long long SaHpiInt64T; typedef float SaHpiFloat32T; typedef double SaHpiFloat64T; typedef SaHpiUint8T SaHpiBoolT; #define SAHPI_TRUE 1 #define SAHPI_FALSE 0 /* Platform, O/S, or Vendor dependent */ #define SAHPI_API #define SAHPI_IN #define SAHPI_OUT #define SAHPI_INOUT /* ** Identifier for the manufacturer ** ** This is the IANA-assigned private enterprise number for the ** manufacturer of the resource or FRU, or of the manufacturer ** defining an OEM control or event type. A list of current ** IANA-assigned private enterprise numbers may be obtained at ** ** http://www.iana.org/assignments/enterprise-numbers ** ** If a manufacturer does not currently have an assigned number, one ** may be obtained by following the instructions located at ** ** http://www.iana.org/cgi-bin/enterprise.pl */ typedef SaHpiUint32T SaHpiManufacturerIdT; #define SAHPI_MANUFACTURER_ID_UNSPECIFIED (SaHpiManufacturerIdT)0 /* Version Types */ typedef SaHpiUint32T SaHpiVersionT; /* ** Interface Version ** ** The interface version is the version of the actual interface and not the ** version of the implementation. It is a 24 bit value where ** the most significant 8 bits represent the compatibility level ** (with letters represented as the corresponding numbers); ** the next 8 bits represent the major version number; and ** the least significant 8 bits represent the minor version number. */ #define SAHPI_INTERFACE_VERSION (SaHpiVersionT)0x010101 /* A.01.01 */ /* ** Return Codes ** ** SaErrorT is defined in the HPI specification. In the future a ** common SAF types definition may be created to contain this type. At ** that time, this typedef should be removed. */ typedef SaHpiInt32T SaErrorT; /* Return code */ /* ** SA_OK: This code indicates that a command completed successfully. */ #define SA_OK (SaErrorT)0x0000 /* This value is the base for all HPI-specific error codes. */ #define SA_HPI_ERR_BASE -1000 /* ** SA_ERR_HPI_ERROR: An unspecified error occurred. This code should ** be returned only as a last resort; eg. if the cause of an error ** cannot be determined. */ #define SA_ERR_HPI_ERROR (SaErrorT)(SA_HPI_ERR_BASE - 1) /* ** SA_ERR_HPI_UNSUPPORTED_API: The HPI implementation does not support ** this API. This code is appropriate, for example, if invoking the ** Hot Swap functions on an HPI implementation which has no hot swap ** support. Note that such an implementation would not report any hot ** swap capabilities via its RDRs. */ #define SA_ERR_HPI_UNSUPPORTED_API (SaErrorT)(SA_HPI_ERR_BASE - 2) /* ** SA_ERR_HPI_BUSY: The command cannot be performed because the ** targeted device is busy. */ #define SA_ERR_HPI_BUSY (SaErrorT)(SA_HPI_ERR_BASE - 3) /* ** SA_ERR_HPI_INVALID: The request is fundamentally invalid. */ #define SA_ERR_HPI_INVALID (SaErrorT)(SA_HPI_ERR_BASE - 4) /* ** SA_ERR_HPI_INVALID_CMD: The specific object to which a command was ** directed does not support that command (which was otherwise valid). */ #define SA_ERR_HPI_INVALID_CMD (SaErrorT)(SA_HPI_ERR_BASE - 5) /* ** SA_ERR_HPI_TIMEOUT: The requested operation, which had a timeout ** value specified, timed out. For example, when reading input with a ** timeout value, if no input arrives within the timeout interval, ** this code should be returned. This should only be returned in ** cases where a timeout is anticipated as a valid consequence of the ** operation; if the addressed entity is not responding due to a ** fault, use SA_ERR_HPI_NO_RESPONSE (qv). */ #define SA_ERR_HPI_TIMEOUT (SaErrorT)(SA_HPI_ERR_BASE - 6) /* ** SA_ERR_HPI_OUT_OF_SPACE: The requested command failed due to ** resource limits. */ #define SA_ERR_HPI_OUT_OF_SPACE (SaErrorT)(SA_HPI_ERR_BASE - 7) /* ** SA_ERR_HPI_DATA_TRUNCATED: The returned data was truncated. For ** example, when reading data into a fixed-size buffer, if the data is ** larger than the buffer, this code should be returned. */ #define SA_ERR_HPI_DATA_TRUNCATED (SaErrorT)(SA_HPI_ERR_BASE - 8) /* ** SA_ERR_HPI_DATA_LEN_INVALID: The specified data length is invalid. */ #define SA_ERR_HPI_DATA_LEN_INVALID (SaErrorT)(SA_HPI_ERR_BASE - 9) /* ** SA_ERR_HPI_DATA_EX_LIMITS: The supplied data exceeds limits. */ #define SA_ERR_HPI_DATA_EX_LIMITS (SaErrorT)(SA_HPI_ERR_BASE - 10) /* ** SA_ERR_HPI_INVALID_PARAMS: One or more parameters to the command ** were invalid. */ #define SA_ERR_HPI_INVALID_PARAMS (SaErrorT)(SA_HPI_ERR_BASE - 11) /* ** SA_ERR_HPI_INVALID_DATA: Cannot return requested data; eg. the ** specific object to which a command was directed does not support ** the data required by the command. */ #define SA_ERR_HPI_INVALID_DATA (SaErrorT)(SA_HPI_ERR_BASE - 12) /* ** SA_ERR_HPI_NOT_PRESENT: The requested object was not present. For ** example, this code would be returned when attempting to access an ** entry in a RPT or RDR which is not present. As another example, this ** code would also be returned when accessing an invalid management ** instrument on a valid resource. */ #define SA_ERR_HPI_NOT_PRESENT (SaErrorT)(SA_HPI_ERR_BASE - 13) /* ** SA_ERR_HPI_INVALID_DATA_FIELD: Invalid data field. */ #define SA_ERR_HPI_INVALID_DATA_FIELD (SaErrorT)(SA_HPI_ERR_BASE - 14) /* ** SA_ERR_HPI_INVALID_SENSOR_CMD: Invalid sensor command. */ #define SA_ERR_HPI_INVALID_SENSOR_CMD (SaErrorT)(SA_HPI_ERR_BASE - 15) /* ** SA_ERR_HPI_NO_RESPONSE: There was no response from the domain or ** object targeted by the command, due to some fault. This code ** indicates an un-anticipated failure to respond; compare with ** SA_ERR_HPI_TIMEOUT. */ #define SA_ERR_HPI_NO_RESPONSE (SaErrorT)(SA_HPI_ERR_BASE - 16) /* ** SA_ERR_HPI_DUPLICATE: Duplicate request -- such as attempting to ** initialize something which has already been initialized (and which ** cannot be initialized twice). */ #define SA_ERR_HPI_DUPLICATE (SaErrorT)(SA_HPI_ERR_BASE - 17) /* ** SA_ERR_HPI_UPDATING: The command could not be completed because ** the targeted object is in update mode. */ #define SA_ERR_HPI_UPDATING (SaErrorT)(SA_HPI_ERR_BASE - 18) /* ** SA_ERR_HPI_INITIALIZING: The command could not be completed because ** the targeted object is initializing. */ #define SA_ERR_HPI_INITIALIZING (SaErrorT)(SA_HPI_ERR_BASE - 19) /* ** SA_ERR_HPI_UNKNOWN: This code should be returned if, for some ** reason, the HPI implementation cannot determine the proper response ** to a command. For example, there may be a proper value to return ** for a given call, but the implementation may be unable to determine ** which one it is. */ #define SA_ERR_HPI_UNKNOWN (SaErrorT)(SA_HPI_ERR_BASE - 20) /* ** SA_ERR_HPI_INVALID_SESSION: An invalid session ID was specified in ** the command. */ #define SA_ERR_HPI_INVALID_SESSION (SaErrorT)(SA_HPI_ERR_BASE - 21) /* ** SA_ERR_HPI_INVALID_DOMAIN: Invalid domain ID specified -- ie. a ** domain ID which does not correspond to any real domain was ** specified in the command. */ #define SA_ERR_HPI_INVALID_DOMAIN (SaErrorT)(SA_HPI_ERR_BASE - 22) /* ** SA_ERR_HPI_INVALID_RESOURCE: Invalid resource ID specified -- ie. a ** resource ID which does not correspond to a resource in the addressed ** domain was specified in the command. */ #define SA_ERR_HPI_INVALID_RESOURCE (SaErrorT)(SA_HPI_ERR_BASE - 23) /* ** SA_ERR_HPI_INVALID_REQUEST: The request is invalid in the current ** context. An example would be attempting to unsubscribe for events, ** when the caller has not subscribed to events. */ #define SA_ERR_HPI_INVALID_REQUEST (SaErrorT)(SA_HPI_ERR_BASE - 24) /* ** SA_ERR_HPI_ENTITY_NOT_PRESENT: The addressed management instrument is not active ** because the entity with which it is associated is not present. This ** condition could occur, for instance, when an alarm module is managing a ** fan tray FRU. The alarm module would contain management instruments (sensors, ** etc) for the fan tray. The fan tray may be removed, even though the ** management instruments are still represented in the alarm module. In this ** case, SA_ERR_HPI_ENTITY_NOT_PRESENT would be returned if a management instrument ** associated with a removed entity is accessed. */ #define SA_ERR_HPI_ENTITY_NOT_PRESENT (SaErrorT)(SA_HPI_ERR_BASE - 25) /* ** SA_ERR_HPI_UNINITIALIZED: This code is returned when a request is ** made, and the HPI has not, yet, been initialized via saHpiInitialize(). */ #define SA_ERR_HPI_UNINITIALIZED (SaErrorT)(SA_HPI_ERR_BASE - 26) /* ** Domain, Session and Resource Type Definitions */ /* Domain ID. */ typedef SaHpiUint32T SaHpiDomainIdT; #define SAHPI_DEFAULT_DOMAIN_ID (SaHpiDomainIdT)0 /* The SAHPI_UNSPECIFIED_DOMAIN_ID value may be used by an implementation ** when populating the ResourceId value for an RPT entry that is a ** domain only. */ #define SAHPI_UNSPECIFIED_DOMAIN_ID (SaHpiDomainIdT) 0xFFFFFFFF /* Session ID. */ typedef SaHpiUint32T SaHpiSessionIdT; /* Resource identifier. */ typedef SaHpiUint32T SaHpiResourceIdT; /* The SAHPI_UNSPECIFIED_RESOURCE_ID value may be used by an implementation ** when populating the DomainId value for an RPT entry that is a ** resource only. Note that this reserved value (0xFFFFFFFF) is also used ** to designate the domain controller, for domain-based event log access. */ #define SAHPI_UNSPECIFIED_RESOURCE_ID (SaHpiResourceIdT) 0xFFFFFFFF /* The SAHPI_DOMAIN_CONTROLLER_ID value is a reserved resource ID ** value which is used to select the domain controller's event log ** (as opposed to a real resource's event log) when accessing logs. ** This value must not be used as the ID of any real resource. */ #define SAHPI_DOMAIN_CONTROLLER_ID (SaHpiResourceIdT) 0xFFFFFFFE /* Table Related Type Definitions */ typedef SaHpiUint32T SaHpiEntryIdT; #define SAHPI_FIRST_ENTRY (SaHpiEntryIdT)0x00000000 #define SAHPI_LAST_ENTRY (SaHpiEntryIdT)0xFFFFFFFF /* ** Time Related Type Definitions ** ** An HPI time value represents the local time as the number of nanoseconds ** from 00:00:00, January 1, 1970, in a 64-bit signed integer. This format ** is sufficient to represent times with nano-second resolution from the ** year 1678 to 2262. Every API which deals with time values must define ** the timezone used. ** ** It should be noted that although nano-second resolution is supported ** in the data type, the actual resolution provided by an implementation ** may be more limited than this. ** ** The value -2**63, which is 0x8000000000000000, is used to indicate ** "unknown/unspecified time". ** ** Conversion to/from POSIX and other common time representations is ** relatively straightforward. The following code framgment converts ** between SaHpiTimeT and time_t: ** ** time_t tt1, tt2; ** SaHpiTimeT saHpiTime; ** ** time(&tt1); ** saHpiTime = (SaHpiTimeT) tt1 * 1000000000; ** tt2 = saHpiTime / 1000000000; ** ** The following fragment converts between SaHpiTimeT and a struct timeval: ** ** struct timeval tv1, tv2; ** SaHpiTimeT saHpiTime; ** ** gettimeofday(&tv1, NULL); ** saHpiTime = (SaHpiTimeT) tv1.tv_sec * 1000000000 + tv1.tv_usec * 1000; ** tv2.tv_sec = saHpiTime / 1000000000; ** tv2.tv_usec = saHpiTime % 1000000000 / 1000; ** ** The following fragment converts between SaHpiTimeT and a struct timespec: ** ** struct timespec ts1, ts2; ** SaHpiTimeT saHpiTime; ** ** clock_gettime(CLOCK_REALTIME, &ts1); ** saHpiTime = (SaHpiTimeT) ts1.tv_sec * 1000000000 + ts1.tv_nsec; ** ts2.tv_sec = saHpiTime / 1000000000; ** ts2.tv_nsec = saHpiTime % 1000000000; ** ** Note, however, that since time_t is (effectively) universally 32 bits, ** all of these conversions will cease to work on January 18, 2038. ** ** Some subsystems may need the flexibility to report either absolute or ** relative (eg. to system boot) times. This will typically be in the ** case of a board which may or may not, depending on the system setup, ** have an idea of absolute time. For example, some boards may have ** "time of day" clocks which start at zero, and never get set to the ** time of day. ** ** In these cases, times which represent "current" time (in events, for ** example) can be reported based on the clock value, whether it has been ** set to the actual date/time, or whether it represents the elapsed time ** since boot. If it is the time since boot, the value will be (for 27 ** years) less than 0x0C00000000000000, which is Mon May 26 16:58:48 1997. ** If the value is greater than this, then it can be assumed to be an ** absolute time. ** ** Every API which can report either absolute or relative times must ** state this rule clearly in its interface specification. */ typedef SaHpiInt64T SaHpiTimeT; /* Time in nanoseconds */ /* Unspecified or unknown time */ #define SAHPI_TIME_UNSPECIFIED (SaHpiTimeT) 0x8000000000000000 /* Maximum time that can be specified as relative */ #define SAHPI_TIME_MAX_RELATIVE (SaHpiTimeT) 0x0C00000000000000 typedef SaHpiInt64T SaHpiTimeoutT; /* Timeout in nanoseconds */ /* Non-blocking call */ #define SAHPI_TIMEOUT_IMMEDIATE (SaHpiTimeoutT) 0x0000000000000000 /* Blocking call, wait indefinitely for call to complete */ #define SAHPI_TIMEOUT_BLOCK (SaHpiTimeoutT) -1 /* ** Language ** ** This enumeration lists all of the languages that can be associated with text. ** ** SAHPI_LANG_UNDEF indicates that the language is unspecified or ** unknown. */ typedef enum { SAHPI_LANG_UNDEF = 0, SAHPI_LANG_AFAR, SAHPI_LANG_ABKHAZIAN, SAHPI_LANG_AFRIKAANS, SAHPI_LANG_AMHARIC, SAHPI_LANG_ARABIC, SAHPI_LANG_ASSAMESE, SAHPI_LANG_AYMARA, SAHPI_LANG_AZERBAIJANI, SAHPI_LANG_BASHKIR, SAHPI_LANG_BYELORUSSIAN, SAHPI_LANG_BULGARIAN, SAHPI_LANG_BIHARI, SAHPI_LANG_BISLAMA, SAHPI_LANG_BENGALI, SAHPI_LANG_TIBETAN, SAHPI_LANG_BRETON, SAHPI_LANG_CATALAN, SAHPI_LANG_CORSICAN, SAHPI_LANG_CZECH, SAHPI_LANG_WELSH, SAHPI_LANG_DANISH, SAHPI_LANG_GERMAN, SAHPI_LANG_BHUTANI, SAHPI_LANG_GREEK, SAHPI_LANG_ENGLISH, SAHPI_LANG_ESPERANTO, SAHPI_LANG_SPANISH, SAHPI_LANG_ESTONIAN, SAHPI_LANG_BASQUE, SAHPI_LANG_PERSIAN, SAHPI_LANG_FINNISH, SAHPI_LANG_FIJI, SAHPI_LANG_FAEROESE, SAHPI_LANG_FRENCH, SAHPI_LANG_FRISIAN, SAHPI_LANG_IRISH, SAHPI_LANG_SCOTSGAELIC, SAHPI_LANG_GALICIAN, SAHPI_LANG_GUARANI, SAHPI_LANG_GUJARATI, SAHPI_LANG_HAUSA, SAHPI_LANG_HINDI, SAHPI_LANG_CROATIAN, SAHPI_LANG_HUNGARIAN, SAHPI_LANG_ARMENIAN, SAHPI_LANG_INTERLINGUA, SAHPI_LANG_INTERLINGUE, SAHPI_LANG_INUPIAK, SAHPI_LANG_INDONESIAN, SAHPI_LANG_ICELANDIC, SAHPI_LANG_ITALIAN, SAHPI_LANG_HEBREW, SAHPI_LANG_JAPANESE, SAHPI_LANG_YIDDISH, SAHPI_LANG_JAVANESE, SAHPI_LANG_GEORGIAN, SAHPI_LANG_KAZAKH, SAHPI_LANG_GREENLANDIC, SAHPI_LANG_CAMBODIAN, SAHPI_LANG_KANNADA, SAHPI_LANG_KOREAN, SAHPI_LANG_KASHMIRI, SAHPI_LANG_KURDISH, SAHPI_LANG_KIRGHIZ, SAHPI_LANG_LATIN, SAHPI_LANG_LINGALA, SAHPI_LANG_LAOTHIAN, SAHPI_LANG_LITHUANIAN, SAHPI_LANG_LATVIANLETTISH, SAHPI_LANG_MALAGASY, SAHPI_LANG_MAORI, SAHPI_LANG_MACEDONIAN, SAHPI_LANG_MALAYALAM, SAHPI_LANG_MONGOLIAN, SAHPI_LANG_MOLDAVIAN, SAHPI_LANG_MARATHI, SAHPI_LANG_MALAY, SAHPI_LANG_MALTESE, SAHPI_LANG_BURMESE, SAHPI_LANG_NAURU, SAHPI_LANG_NEPALI, SAHPI_LANG_DUTCH, SAHPI_LANG_NORWEGIAN, SAHPI_LANG_OCCITAN, SAHPI_LANG_AFANOROMO, SAHPI_LANG_ORIYA, SAHPI_LANG_PUNJABI, SAHPI_LANG_POLISH, SAHPI_LANG_PASHTOPUSHTO, SAHPI_LANG_PORTUGUESE, SAHPI_LANG_QUECHUA, SAHPI_LANG_RHAETOROMANCE, SAHPI_LANG_KIRUNDI, SAHPI_LANG_ROMANIAN, SAHPI_LANG_RUSSIAN, SAHPI_LANG_KINYARWANDA, SAHPI_LANG_SANSKRIT, SAHPI_LANG_SINDHI, SAHPI_LANG_SANGRO, SAHPI_LANG_SERBOCROATIAN, SAHPI_LANG_SINGHALESE, SAHPI_LANG_SLOVAK, SAHPI_LANG_SLOVENIAN, SAHPI_LANG_SAMOAN, SAHPI_LANG_SHONA, SAHPI_LANG_SOMALI, SAHPI_LANG_ALBANIAN, SAHPI_LANG_SERBIAN, SAHPI_LANG_SISWATI, SAHPI_LANG_SESOTHO, SAHPI_LANG_SUDANESE, SAHPI_LANG_SWEDISH, SAHPI_LANG_SWAHILI, SAHPI_LANG_TAMIL, SAHPI_LANG_TELUGU, SAHPI_LANG_TAJIK, SAHPI_LANG_THAI, SAHPI_LANG_TIGRINYA, SAHPI_LANG_TURKMEN, SAHPI_LANG_TAGALOG, SAHPI_LANG_SETSWANA, SAHPI_LANG_TONGA, SAHPI_LANG_TURKISH, SAHPI_LANG_TSONGA, SAHPI_LANG_TATAR, SAHPI_LANG_TWI, SAHPI_LANG_UKRAINIAN, SAHPI_LANG_URDU, SAHPI_LANG_UZBEK, SAHPI_LANG_VIETNAMESE, SAHPI_LANG_VOLAPUK, SAHPI_LANG_WOLOF, SAHPI_LANG_XHOSA, SAHPI_LANG_YORUBA, SAHPI_LANG_CHINESE, SAHPI_LANG_ZULU } SaHpiLanguageT; /* ** Text Buffers ** ** These structures are used for defining the type of data in the text buffer ** and the length of the buffer. Text buffers are used in the inventory data, ** RDR, RPT, etc. for variable length strings of data. */ #define SAHPI_MAX_TEXT_BUFFER_LENGTH 255 typedef enum { SAHPI_TL_TYPE_BINARY = 0, /* String of bytes, any values legal */ SAHPI_TL_TYPE_BCDPLUS, /* String of 0-9, space, dash, period ONLY */ SAHPI_TL_TYPE_ASCII6, /* Reduced ASCII character set: 0x20-0x5F ONLY */ SAHPI_TL_TYPE_LANGUAGE /* ASCII or UNICODE depending on language */ } SaHpiTextTypeT; typedef struct { SaHpiTextTypeT DataType; SaHpiLanguageT Language; /* Language the text is in. */ SaHpiUint8T DataLength; /* Bytes used in Data buffer */ SaHpiUint8T Data[SAHPI_MAX_TEXT_BUFFER_LENGTH]; /* Data buffer */ } SaHpiTextBufferT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Entities ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* ** Entity Types ** ** Entities are used to associate specific hardware components with sensors, ** controls, watchdogs, or resources. Entities are defined with an entity ** type enumeration, and an entity instance number (to distinguish between ** multiple instances of a particular type of entity; e.g., multiple power ** supplies in a system). ** ** Entities are uniquely identified in a system with an ordered series of ** Entity Type / Entity Instance pairs called an "Entity Path". Each subsequent ** Entity Type/Entity Instance in the path is the next higher "containing" ** entity. The "root" of the Entity Path (the outermost level of containment) ** is designated with an Entity Type of SAHPI_ENT_ROOT if the entire Entity Path ** is fewer than SAHPI_MAX_ENTITY_PATH entries in length. ** ** Enumerated Entity Types include those types enumerated by the IPMI Consortium ** for IPMI-managed entities, as well as additional types defined by the ** HPI specification. Room is left in the enumeration for the inclusion of ** Entity Types taken from other lists, if needed in the future. */ /* Base values for entity types from various sources. */ #define SAHPI_ENT_IPMI_GROUP 0 #define SAHPI_ENT_SAFHPI_GROUP 0x10000 #define SAHPI_ENT_ROOT_VALUE 0xFFFF typedef enum { SAHPI_ENT_UNSPECIFIED = SAHPI_ENT_IPMI_GROUP, SAHPI_ENT_OTHER, SAHPI_ENT_UNKNOWN, SAHPI_ENT_PROCESSOR, SAHPI_ENT_DISK_BAY, /* Disk or disk bay */ SAHPI_ENT_PERIPHERAL_BAY, SAHPI_ENT_SYS_MGMNT_MODULE, /* System management module */ SAHPI_ENT_SYSTEM_BOARD, /* Main system board, may also be processor board and/or internal expansion board */ SAHPI_ENT_MEMORY_MODULE, /* Board holding memory devices */ SAHPI_ENT_PROCESSOR_MODULE, /* Holds processors, use this designation when processors are not mounted on system board */ SAHPI_ENT_POWER_SUPPLY, /* Main power supply (supplies) for the system */ SAHPI_ENT_ADD_IN_CARD, SAHPI_ENT_FRONT_PANEL_BOARD, /* Control panel */ SAHPI_ENT_BACK_PANEL_BOARD, SAHPI_ENT_POWER_SYSTEM_BOARD, SAHPI_ENT_DRIVE_BACKPLANE, SAHPI_ENT_SYS_EXPANSION_BOARD, /* System internal expansion board (contains expansion slots). */ SAHPI_ENT_OTHER_SYSTEM_BOARD, /* Part of board set */ SAHPI_ENT_PROCESSOR_BOARD, /* Holds 1 or more processors. Includes boards that hold SECC modules) */ SAHPI_ENT_POWER_UNIT, /* Power unit / power domain (typically used as a pre-defined logical entity for grouping power supplies)*/ SAHPI_ENT_POWER_MODULE, /* Power module / DC-to-DC converter. Use this value for internal converters. Note: You should use entity ID (power supply) for the main power supply even if the main supply is a DC-to-DC converter */ SAHPI_ENT_POWER_MGMNT, /* Power management/distribution board */ SAHPI_ENT_CHASSIS_BACK_PANEL_BOARD, SAHPI_ENT_SYSTEM_CHASSIS, SAHPI_ENT_SUB_CHASSIS, SAHPI_ENT_OTHER_CHASSIS_BOARD, SAHPI_ENT_DISK_DRIVE_BAY, SAHPI_ENT_PERIPHERAL_BAY_2, SAHPI_ENT_DEVICE_BAY, SAHPI_ENT_COOLING_DEVICE, /* Fan/cooling device */ SAHPI_ENT_COOLING_UNIT, /* Can be used as a pre-defined logical entity for grouping fans or other cooling devices. */ SAHPI_ENT_INTERCONNECT, /* Cable / interconnect */ SAHPI_ENT_MEMORY_DEVICE, /* This Entity ID should be used for replaceable memory devices, e.g. DIMM/SIMM. It is recommended that Entity IDs not be used for individual non-replaceable memory devices. Rather, monitoring and error reporting should be associated with the FRU [e.g. memory card] holding the memory. */ SAHPI_ENT_SYS_MGMNT_SOFTWARE, /* System Management Software */ SAHPI_ENT_BIOS, SAHPI_ENT_OPERATING_SYSTEM, SAHPI_ENT_SYSTEM_BUS, SAHPI_ENT_GROUP, /* This is a logical entity for use with Entity Association records. It is provided to allow a sensor data record to point to an entity- association record when there is no appropriate pre-defined logical entity for the entity grouping. This Entity should not be used as a physical entity. */ SAHPI_ENT_REMOTE, /* Out of band management communication device */ SAHPI_ENT_EXTERNAL_ENVIRONMENT, SAHPI_ENT_BATTERY, SAHPI_ENT_CHASSIS_SPECIFIC = SAHPI_ENT_IPMI_GROUP + 0x90, SAHPI_ENT_BOARD_SET_SPECIFIC = SAHPI_ENT_IPMI_GROUP + 0xB0, SAHPI_ENT_OEM_SYSINT_SPECIFIC = SAHPI_ENT_IPMI_GROUP + 0xD0, SAHPI_ENT_ROOT = SAHPI_ENT_ROOT_VALUE, SAHPI_ENT_RACK = SAHPI_ENT_SAFHPI_GROUP, SAHPI_ENT_SUBRACK, SAHPI_ENT_COMPACTPCI_CHASSIS, SAHPI_ENT_ADVANCEDTCA_CHASSIS, SAHPI_ENT_SYSTEM_SLOT, SAHPI_ENT_SBC_BLADE, SAHPI_ENT_IO_BLADE, SAHPI_ENT_DISK_BLADE, SAHPI_ENT_DISK_DRIVE, SAHPI_ENT_FAN, SAHPI_ENT_POWER_DISTRIBUTION_UNIT, SAHPI_ENT_SPEC_PROC_BLADE, /* Special Processing Blade, including DSP */ SAHPI_ENT_IO_SUBBOARD, /* I/O Sub-Board, including PMC I/O board */ SAHPI_ENT_SBC_SUBBOARD, /* SBC Sub-Board, including PMC SBC board */ SAHPI_ENT_ALARM_MANAGER, /* Chassis alarm manager board */ SAHPI_ENT_ALARM_MANAGER_BLADE, /* Blade-based alarm manager */ SAHPI_ENT_SUBBOARD_CARRIER_BLADE /* Includes PMC Carrier Blade -- Use only if "carrier" is only function of blade. Else use primary function (SBC_BLADE, DSP_BLADE, etc.). */ } SaHpiEntityTypeT; typedef SaHpiUint32T SaHpiEntityInstanceT; typedef struct { SaHpiEntityTypeT EntityType; SaHpiEntityInstanceT EntityInstance; } SaHpiEntityT; #define SAHPI_MAX_ENTITY_PATH 16 typedef struct { SaHpiEntityT Entry[SAHPI_MAX_ENTITY_PATH]; } SaHpiEntityPathT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Events, part 1 ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* ** Category ** ** Sensor events contain an event category and event state. Depending on the ** event category, the event states take on different meanings for events ** generated by specific sensors. ** ** The SAHPI_EC_GENERIC category can be used for discrete sensors which have ** state meanings other than those identified with other event categories. */ typedef SaHpiUint8T SaHpiEventCategoryT; #define SAHPI_EC_UNSPECIFIED (SaHpiEventCategoryT)0x00 /* Unspecified */ #define SAHPI_EC_THRESHOLD (SaHpiEventCategoryT)0x01 /* Threshold events */ #define SAHPI_EC_USAGE (SaHpiEventCategoryT)0x02 /* Usage state events */ #define SAHPI_EC_STATE (SaHpiEventCategoryT)0x03 /* Generic state events */ #define SAHPI_EC_PRED_FAIL (SaHpiEventCategoryT)0x04 /* Predictive fail events */ #define SAHPI_EC_LIMIT (SaHpiEventCategoryT)0x05 /* Limit events */ #define SAHPI_EC_PERFORMANCE (SaHpiEventCategoryT)0x06 /* Performance events */ #define SAHPI_EC_SEVERITY (SaHpiEventCategoryT)0x07 /* Severity indicating events */ #define SAHPI_EC_PRESENCE (SaHpiEventCategoryT)0x08 /* Device presence events */ #define SAHPI_EC_ENABLE (SaHpiEventCategoryT)0x09 /* Device enabled events */ #define SAHPI_EC_AVAILABILITY (SaHpiEventCategoryT)0x0A /* Availability state events */ #define SAHPI_EC_REDUNDANCY (SaHpiEventCategoryT)0x0B /* Redundancy state events */ #define SAHPI_EC_USER (SaHpiEventCategoryT)0x7E /* User defined events */ #define SAHPI_EC_GENERIC (SaHpiEventCategoryT)0x7F /* OEM defined events */ /* ** Event States ** ** The following event states are specified relative to the categories listed ** above. The event types are only valid for their given category. Each set of ** events is labeled as to which category it belongs to. ** Each event will have only one event state associated with it. When retrieving ** the event status or event enabled status a bit mask of all applicable event ** states is used. Similarly, when setting the event enabled status a bit mask ** of all applicable event states is used. */ typedef SaHpiUint16T SaHpiEventStateT; /* ** SaHpiEventCategoryT == */ #define SAHPI_ES_UNSPECIFIED (SaHpiEventStateT)0x0000 /* ** SaHpiEventCategoryT == SAHPI_EC_THRESHOLD ** When using these event states, the event state should match ** the event severity (for example SAHPI_ES_LOWER_MINOR should have an ** event severity of SAHPI_MINOR). */ #define SAHPI_ES_LOWER_MINOR (SaHpiEventStateT)0x0001 #define SAHPI_ES_LOWER_MAJOR (SaHpiEventStateT)0x0002 #define SAHPI_ES_LOWER_CRIT (SaHpiEventStateT)0x0004 #define SAHPI_ES_UPPER_MINOR (SaHpiEventStateT)0x0008 #define SAHPI_ES_UPPER_MAJOR (SaHpiEventStateT)0x0010 #define SAHPI_ES_UPPER_CRIT (SaHpiEventStateT)0x0020 /* SaHpiEventCategoryT == SAHPI_EC_USAGE */ #define SAHPI_ES_IDLE (SaHpiEventStateT)0x0001 #define SAHPI_ES_ACTIVE (SaHpiEventStateT)0x0002 #define SAHPI_ES_BUSY (SaHpiEventStateT)0x0004 /* SaHpiEventCategoryT == SAHPI_EC_STATE */ #define SAHPI_ES_STATE_DEASSERTED (SaHpiEventStateT)0x0001 #define SAHPI_ES_STATE_ASSERTED (SaHpiEventStateT)0x0002 /* SaHpiEventCategoryT == SAHPI_EC_PRED_FAIL */ #define SAHPI_ES_PRED_FAILURE_DEASSERT (SaHpiEventStateT)0x0001 #define SAHPI_ES_PRED_FAILURE_ASSERT (SaHpiEventStateT)0x0002 /* SaHpiEventCategoryT == SAHPI_EC_LIMIT */ #define SAHPI_ES_LIMIT_NOT_EXCEEDED (SaHpiEventStateT)0x0001 #define SAHPI_ES_LIMIT_EXCEEDED (SaHpiEventStateT)0x0002 /* SaHpiEventCategoryT == SAHPI_EC_PERFORMANCE */ #define SAHPI_ES_PERFORMANCE_MET (SaHpiEventStateT)0x0001 #define SAHPI_ES_PERFORMANCE_LAGS (SaHpiEventStateT)0x0002 /* ** SaHpiEventCategoryT == SAHPI_EC_SEVERITY ** When using these event states, the event state should match ** the event severity */ #define SAHPI_ES_OK (SaHpiEventStateT)0x0001 #define SAHPI_ES_MINOR_FROM_OK (SaHpiEventStateT)0x0002 #define SAHPI_ES_MAJOR_FROM_LESS (SaHpiEventStateT)0x0004 #define SAHPI_ES_CRITICAL_FROM_LESS (SaHpiEventStateT)0x0008 #define SAHPI_ES_MINOR_FROM_MORE (SaHpiEventStateT)0x0010 #define SAHPI_ES_MAJOR_FROM_CRITICAL (SaHpiEventStateT)0x0020 #define SAHPI_ES_CRITICAL (SaHpiEventStateT)0x0040 #define SAHPI_ES_MONITOR (SaHpiEventStateT)0x0080 #define SAHPI_ES_INFORMATIONAL (SaHpiEventStateT)0x0100 /* SaHpiEventCategoryT == SAHPI_EC_PRESENCE */ #define SAHPI_ES_ABSENT (SaHpiEventStateT)0x0001 #define SAHPI_ES_PRESENT (SaHpiEventStateT)0x0002 /* SaHpiEventCategoryT == SAHPI_EC_ENABLE */ #define SAHPI_ES_DISABLED (SaHpiEventStateT)0x0001 #define SAHPI_ES_ENABLED (SaHpiEventStateT)0x0002 /* SaHpiEventCategoryT == SAHPI_EC_AVAILABILITY */ #define SAHPI_ES_RUNNING (SaHpiEventStateT)0x0001 #define SAHPI_ES_TEST (SaHpiEventStateT)0x0002 #define SAHPI_ES_POWER_OFF (SaHpiEventStateT)0x0004 #define SAHPI_ES_ON_LINE (SaHpiEventStateT)0x0008 #define SAHPI_ES_OFF_LINE (SaHpiEventStateT)0x0010 #define SAHPI_ES_OFF_DUTY (SaHpiEventStateT)0x0020 #define SAHPI_ES_DEGRADED (SaHpiEventStateT)0x0040 #define SAHPI_ES_POWER_SAVE (SaHpiEventStateT)0x0080 #define SAHPI_ES_INSTALL_ERROR (SaHpiEventStateT)0x0100 /* SaHpiEventCategoryT == SAHPI_EC_REDUNDANCY */ #define SAHPI_ES_FULLY_REDUNDANT (SaHpiEventStateT)0x0001 #define SAHPI_ES_REDUNDANCY_LOST (SaHpiEventStateT)0x0002 #define SAHPI_ES_REDUNDANCY_DEGRADED (SaHpiEventStateT)0x0004 #define SAHPI_ES_REDUNDANCY_LOST_SUFFICIENT_RESOURCES \ (SaHpiEventStateT)0x0008 #define SAHPI_ES_NON_REDUNDANT_SUFFICIENT_RESOURCES \ (SaHpiEventStateT)0x0010 #define SAHPI_ES_NON_REDUNDANT_INSUFFICIENT_RESOURCES \ (SaHpiEventStateT)0x0020 #define SAHPI_ES_REDUNDANCY_DEGRADED_FROM_FULL (SaHpiEventStateT)0x0040 #define SAHPI_ES_REDUNDANCY_DEGRADED_FROM_NON (SaHpiEventStateT)0x0080 /* ** SaHpiEventCategoryT == SAHPI_EC_GENERIC || SAHPI_EC_USER ** These event states are defined by the OEM or the user of the ** implementation. */ #define SAHPI_ES_STATE_00 (SaHpiEventStateT)0x0001 #define SAHPI_ES_STATE_01 (SaHpiEventStateT)0x0002 #define SAHPI_ES_STATE_02 (SaHpiEventStateT)0x0004 #define SAHPI_ES_STATE_03 (SaHpiEventStateT)0x0008 #define SAHPI_ES_STATE_04 (SaHpiEventStateT)0x0010 #define SAHPI_ES_STATE_05 (SaHpiEventStateT)0x0020 #define SAHPI_ES_STATE_06 (SaHpiEventStateT)0x0040 #define SAHPI_ES_STATE_07 (SaHpiEventStateT)0x0080 #define SAHPI_ES_STATE_08 (SaHpiEventStateT)0x0100 #define SAHPI_ES_STATE_09 (SaHpiEventStateT)0x0200 #define SAHPI_ES_STATE_10 (SaHpiEventStateT)0x0400 #define SAHPI_ES_STATE_11 (SaHpiEventStateT)0x0800 #define SAHPI_ES_STATE_12 (SaHpiEventStateT)0x1000 #define SAHPI_ES_STATE_13 (SaHpiEventStateT)0x2000 #define SAHPI_ES_STATE_14 (SaHpiEventStateT)0x4000 /******************************************************************************* ******************************************************************************** ********** ********** ********** Sensors ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* Sensor Number */ typedef SaHpiUint8T SaHpiSensorNumT; /* Type of Sensor */ typedef enum { SAHPI_TEMPERATURE = 0x01, SAHPI_VOLTAGE, SAHPI_CURRENT, SAHPI_FAN, SAHPI_PHYSICAL_SECURITY, SAHPI_PLATFORM_VIOLATION, SAHPI_PROCESSOR, SAHPI_POWER_SUPPLY, SAHPI_POWER_UNIT, SAHPI_COOLING_DEVICE, SAHPI_OTHER_UNITS_BASED_SENSOR, SAHPI_MEMORY, SAHPI_DRIVE_SLOT, SAHPI_POST_MEMORY_RESIZE, SAHPI_SYSTEM_FW_PROGRESS, SAHPI_EVENT_LOGGING_DISABLED, SAHPI_RESERVED1, SAHPI_SYSTEM_EVENT, SAHPI_CRITICAL_INTERRUPT, SAHPI_BUTTON, SAHPI_MODULE_BOARD, SAHPI_MICROCONTROLLER_COPROCESSOR, SAHPI_ADDIN_CARD, SAHPI_CHASSIS, SAHPI_CHIP_SET, SAHPI_OTHER_FRU, SAHPI_CABLE_INTERCONNECT, SAHPI_TERMINATOR, SAHPI_SYSTEM_BOOT_INITIATED, SAHPI_BOOT_ERROR, SAHPI_OS_BOOT, SAHPI_OS_CRITICAL_STOP, SAHPI_SLOT_CONNECTOR, SAHPI_SYSTEM_ACPI_POWER_STATE, SAHPI_RESERVED2, SAHPI_PLATFORM_ALERT, SAHPI_ENTITY_PRESENCE, SAHPI_MONITOR_ASIC_IC, SAHPI_LAN, SAHPI_MANAGEMENT_SUBSYSTEM_HEALTH, SAHPI_BATTERY, SAHPI_OPERATIONAL = 0xA0, SAHPI_OEM_SENSOR=0xC0 } SaHpiSensorTypeT; /* ** Interpreted Sensor Reading Type ** ** These definitions list the available data types that can be ** used for interpreted sensor readings. Interpreted sensor readings are provided ** because typically sensors measure their associated entities in a way that is ** not human readable/understandable. For example a fan sensor may measure the ** number of ticks that it takes a fan blade to move passed a sensor. The human ** readable reading type would be revolutions per minute (RPM). */ #define SAHPI_SENSOR_BUFFER_LENGTH 32 typedef enum { SAHPI_SENSOR_INTERPRETED_TYPE_UINT8, SAHPI_SENSOR_INTERPRETED_TYPE_UINT16, SAHPI_SENSOR_INTERPRETED_TYPE_UINT32, SAHPI_SENSOR_INTERPRETED_TYPE_INT8, SAHPI_SENSOR_INTERPRETED_TYPE_INT16, SAHPI_SENSOR_INTERPRETED_TYPE_INT32, SAHPI_SENSOR_INTERPRETED_TYPE_FLOAT32, SAHPI_SENSOR_INTERPRETED_TYPE_BUFFER /* 32 byte array */ } SaHpiSensorInterpretedTypeT; typedef union { SaHpiUint8T SensorUint8; SaHpiUint16T SensorUint16; SaHpiUint32T SensorUint32; SaHpiInt8T SensorInt8; SaHpiInt16T SensorInt16; SaHpiInt32T SensorInt32; SaHpiFloat32T SensorFloat32; SaHpiUint8T SensorBuffer[SAHPI_SENSOR_BUFFER_LENGTH]; } SaHpiSensorInterpretedUnionT; typedef struct { SaHpiSensorInterpretedTypeT Type; SaHpiSensorInterpretedUnionT Value; } SaHpiSensorInterpretedT; /* ** Sensor Status ** ** The sensor status structure is used to determine if sensor scanning is ** enabled and if events are enabled. If events are enabled, the structure will ** have valid data for the outstanding sensor event states. */ typedef SaHpiUint8T SaHpiSensorStatusT; #define SAHPI_SENSTAT_EVENTS_ENABLED (SaHpiSensorStatusT)0x80 #define SAHPI_SENSTAT_SCAN_ENABLED (SaHpiSensorStatusT)0x40 #define SAHPI_SENSTAT_BUSY (SaHpiSensorStatusT)0x20 typedef struct { SaHpiSensorStatusT SensorStatus; SaHpiEventStateT EventStatus; } SaHpiSensorEvtStatusT; /* Sensor Event Enables */ typedef struct { SaHpiSensorStatusT SensorStatus; SaHpiEventStateT AssertEvents; SaHpiEventStateT DeassertEvents; } SaHpiSensorEvtEnablesT; /* ** Sensor Reading ** ** The sensor reading type is the data structure returned from a call to get ** sensor reading. The structure is also used when setting and getting sensor ** threshold values and reporting sensor ranges. ** Each sensor may support one or more of raw, interpreted, or event status ** representations of the sensor data. For analog sensors the raw value is the ** raw value from the sensor (such as ticks per fan blade) and the interpreted ** value is the raw value converted in to a usable format (such as RPM). The ** interpreted value can be calculated by the HPI implementation using the ** sensor factors or by another OEM means. */ typedef SaHpiUint8T SaHpiSensorReadingFormatsT; #define SAHPI_SRF_RAW (SaHpiSensorReadingFormatsT)0x01 #define SAHPI_SRF_INTERPRETED (SaHpiSensorReadingFormatsT)0x02 #define SAHPI_SRF_EVENT_STATE (SaHpiSensorReadingFormatsT)0x04 typedef struct { SaHpiSensorReadingFormatsT ValuesPresent; SaHpiUint32T Raw; SaHpiSensorInterpretedT Interpreted; SaHpiSensorEvtStatusT EventStatus; } SaHpiSensorReadingT; /* ** Threshold Values ** This structure encompasses all of the thresholds that can be set. */ typedef struct { SaHpiSensorReadingT LowCritical; /* Lower Critical Threshold */ SaHpiSensorReadingT LowMajor; /* Lower Major Threshold */ SaHpiSensorReadingT LowMinor; /* Lower Minor Threshold */ SaHpiSensorReadingT UpCritical; /* Upper critical Threshold */ SaHpiSensorReadingT UpMajor; /* Upper major Threshold */ SaHpiSensorReadingT UpMinor; /* Upper minor Threshold */ SaHpiSensorReadingT PosThdHysteresis; /* Positive Threshold Hysteresis */ SaHpiSensorReadingT NegThdHysteresis; /* Negative Threshold Hysteresis */ }SaHpiSensorThresholdsT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Sensor Resource Data Records ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* ** Sensor Factors ** ** The sensor factors structure defines the conversion factors for linear and ** linearized sensors. ** The SaHpiSensorLinearizationT enumeration coupled with the various other ** sensor factors define a formula that can be applied to raw sensor data to ** convert it to appropriate engineering units. If linearization is ** SAHPI_SL_NONLINEAR, SAHPI_SL_UNSPECIFIED, or SAHPI_SL_OEM then there is no ** predefined conversion from raw to interpreted and the sensor factors may or ** may not be meaningful depending on the implementation. ** For other linearization values, raw readings may be converted to interpreted ** values using the formula: **Interpreted = L [( M*raw + B*10^ExpB )*10^ExpR ] **where "L[x]" is the indicated linearization function ** (for SAHPI_SL_LINEAR, L[x]=x). ** The Tolerance Factor is given as +/- 1/2 raw counts, so tolerance in ** interpreted values can be calculated as: ** L[ M * ToleranceFactor/2 * 10^ExpR ] ** The Accuracy Factor is given as 1/100 of a percent, scaled up by ExpA. Thus ** the accuracy is: **( ( AccuracyFactor/100 ) / 10^ExpA )% */ typedef enum { SAHPI_SL_LINEAR = 0, /* Already linear */ SAHPI_SL_LN, SAHPI_SL_LOG10, SAHPI_SL_LOG2, SAHPI_SL_E, SAHPI_SL_EXP10, SAHPI_SL_EXP2, SAHPI_SL_1OVERX, SAHPI_SL_SQRX, SAHPI_SL_CUBEX, SAHPI_SL_SQRTX, SAHPI_SL_CUBERTX, SAHPI_SL_NONLINEAR = 0x70, /* Cannot be linearized with a predefind formula*/ SAHPI_SL_OEM, SAHPI_SL_UNSPECIFIED = 0xFF } SaHpiSensorLinearizationT; typedef struct { SaHpiInt16T M_Factor; /* M Factor */ SaHpiInt16T B_Factor; /* B Factor */ SaHpiUint16T AccuracyFactor; /* Accuracy */ SaHpiUint8T ToleranceFactor; /* Tolerance */ SaHpiUint8T ExpA; /* Accuracy Exp */ SaHpiInt8T ExpR; /* Result Exp */ SaHpiInt8T ExpB; /* B Exp */ SaHpiSensorLinearizationT Linearization; } SaHpiSensorFactorsT; /* ** Sensor Range ** Sensor range values can include minimum, maximum, normal minimum, normal ** maximum, and nominal values. */ typedef SaHpiUint8T SaHpiSensorRangeFlagsT; #define SAHPI_SRF_MIN (SaHpiSensorRangeFlagsT)0x10 #define SAHPI_SRF_MAX (SaHpiSensorRangeFlagsT)0x08 #define SAHPI_SRF_NORMAL_MIN (SaHpiSensorRangeFlagsT)0x04 #define SAHPI_SRF_NORMAL_MAX (SaHpiSensorRangeFlagsT)0x02 #define SAHPI_SRF_NOMINAL (SaHpiSensorRangeFlagsT)0x01 typedef struct { SaHpiSensorRangeFlagsT Flags; SaHpiSensorReadingT Max; SaHpiSensorReadingT Min; SaHpiSensorReadingT Nominal; SaHpiSensorReadingT NormalMax; SaHpiSensorReadingT NormalMin; } SaHpiSensorRangeT; /* ** Sensor Units ** This is a list of all the sensor units supported by HPI. */ typedef enum { SAHPI_SU_UNSPECIFIED = 0, SAHPI_SU_DEGREES_C, SAHPI_SU_DEGREES_F, SAHPI_SU_DEGREES_K, SAHPI_SU_VOLTS, SAHPI_SU_AMPS, SAHPI_SU_WATTS, SAHPI_SU_JOULES, SAHPI_SU_COULOMBS, SAHPI_SU_VA, SAHPI_SU_NITS, SAHPI_SU_LUMEN, SAHPI_SU_LUX, SAHPI_SU_CANDELA, SAHPI_SU_KPA, SAHPI_SU_PSI, SAHPI_SU_NEWTON, SAHPI_SU_CFM, SAHPI_SU_RPM, SAHPI_SU_HZ, SAHPI_SU_MICROSECOND, SAHPI_SU_MILLISECOND, SAHPI_SU_SECOND, SAHPI_SU_MINUTE, SAHPI_SU_HOUR, SAHPI_SU_DAY, SAHPI_SU_WEEK, SAHPI_SU_MIL, SAHPI_SU_INCHES, SAHPI_SU_FEET, SAHPI_SU_CU_IN, SAHPI_SU_CU_FEET, SAHPI_SU_MM, SAHPI_SU_CM, SAHPI_SU_M, SAHPI_SU_CU_CM, SAHPI_SU_CU_M, SAHPI_SU_LITERS, SAHPI_SU_FLUID_OUNCE, SAHPI_SU_RADIANS, SAHPI_SU_STERADIANS, SAHPI_SU_REVOLUTIONS, SAHPI_SU_CYCLES, SAHPI_SU_GRAVITIES, SAHPI_SU_OUNCE, SAHPI_SU_POUND, SAHPI_SU_FT_LB, SAHPI_SU_OZ_IN, SAHPI_SU_GAUSS, SAHPI_SU_GILBERTS, SAHPI_SU_HENRY, SAHPI_SU_MILLIHENRY, SAHPI_SU_FARAD, SAHPI_SU_MICROFARAD, SAHPI_SU_OHMS, SAHPI_SU_SIEMENS, SAHPI_SU_MOLE, SAHPI_SU_BECQUEREL, SAHPI_SU_PPM, SAHPI_SU_RESERVED, SAHPI_SU_DECIBELS, SAHPI_SU_DBA, SAHPI_SU_DBC, SAHPI_SU_GRAY, SAHPI_SU_SIEVERT, SAHPI_SU_COLOR_TEMP_DEG_K, SAHPI_SU_BIT, SAHPI_SU_KILOBIT, SAHPI_SU_MEGABIT, SAHPI_SU_GIGABIT, SAHPI_SU_BYTE, SAHPI_SU_KILOBYTE, SAHPI_SU_MEGABYTE, SAHPI_SU_GIGABYTE, SAHPI_SU_WORD, SAHPI_SU_DWORD, SAHPI_SU_QWORD, SAHPI_SU_LINE, SAHPI_SU_HIT, SAHPI_SU_MISS, SAHPI_SU_RETRY, SAHPI_SU_RESET, SAHPI_SU_OVERRUN, SAHPI_SU_UNDERRUN, SAHPI_SU_COLLISION, SAHPI_SU_PACKETS, SAHPI_SU_MESSAGES, SAHPI_SU_CHARACTERS, SAHPI_SU_ERRORS, SAHPI_SU_CORRECTABLE_ERRORS, SAHPI_SU_UNCORRECTABLE_ERRORS } SaHpiSensorUnitsT; /* ** Modifier Unit Use ** This type defines how the modifier unit is used. For example: base unit == ** meter, modifier unit == seconds, and modifier unit use == ** SAHPI_SMUU_BASIC_OVER_MODIFIER. The resulting unit would be meters per second. */ typedef enum { SAHPI_SMUU_NONE = 0, SAHPI_SMUU_BASIC_OVER_MODIFIER, /* Basic Unit / Modifier Unit */ SAHPI_SMUU_BASIC_TIMES_MODIFIER /* Basic Unit * Modifier Unit */ } SaHpiSensorModUnitUseT; /* ** Sign Format ** This type defines what the sign format of the sensor's raw value is (1's ** complement, unsigned, etc.). */ typedef enum { SAHPI_SDF_UNSIGNED = 0, SAHPI_SDF_1S_COMPLEMENT, SAHPI_SDF_2S_COMPLEMENT } SaHpiSensorSignFormatT; /* ** Data Format ** This structure encapsulates all of the various types that make up the ** definition of sensor data. */ typedef struct { SaHpiSensorReadingFormatsT ReadingFormats; /* Indicates if sensor supports readings in raw, interpreted, and/or event status formats */ SaHpiBoolT IsNumeric; /* If FALSE, rest of this structure is not meaningful */ SaHpiSensorSignFormatT SignFormat; /* Signed format */ SaHpiSensorUnitsT BaseUnits; /* Base units (meters, etc.) */ SaHpiSensorUnitsT ModifierUnits; /* Modifier unit (second, etc.) */ SaHpiSensorModUnitUseT ModifierUse; /* Modifier use(m/sec, etc.) */ SaHpiBoolT FactorsStatic; /* True if the sensor factors are static. If false factors vary over sensor range, and are not accessible through HPI */ SaHpiSensorFactorsT Factors; SaHpiBoolT Percentage; /* Is value a percentage */ SaHpiSensorRangeT Range; /* Valid range of sensor */ } SaHpiSensorDataFormatT; /* ** Threshold Support ** ** These types define what threshold values are readable, writable, and fixed. ** It also defines how the threshold values are read and written. */ typedef SaHpiUint8T SaHpiSensorThdMaskT; #define SAHPI_STM_LOW_MINOR (SaHpiSensorThdMaskT)0x01 #define SAHPI_STM_LOW_MAJOR (SaHpiSensorThdMaskT)0x02 #define SAHPI_STM_LOW_CRIT (SaHpiSensorThdMaskT)0x04 #define SAHPI_STM_UP_MINOR (SaHpiSensorThdMaskT)0x08 #define SAHPI_STM_UP_MAJOR (SaHpiSensorThdMaskT)0x10 #define SAHPI_STM_UP_CRIT (SaHpiSensorThdMaskT)0x20 #define SAHPI_STM_UP_HYSTERESIS (SaHpiSensorThdMaskT)0x40 #define SAHPI_STM_LOW_HYSTERESIS (SaHpiSensorThdMaskT)0x80 typedef SaHpiUint8T SaHpiSensorThdCapT; #define SAHPI_STC_RAW (SaHpiSensorThdMaskT)0x01 /* read/write as raw counts */ #define SAHPI_STC_INTERPRETED (SaHpiSensorThdMaskT)0x02 /* read/write as interpreted */ typedef struct { SaHpiBoolT IsThreshold; /* True if the sensor supports thresholds. If false, rest of structure is not meaningful. */ SaHpiSensorThdCapT TholdCapabilities; SaHpiSensorThdMaskT ReadThold; /* Readable thresholds */ SaHpiSensorThdMaskT WriteThold; /* Writable thresholds */ SaHpiSensorThdMaskT FixedThold; /* Fixed thresholds */ } SaHpiSensorThdDefnT; /* ** Event Control ** ** This type defines how sensor event messages can be controlled (can be turned ** off and on for each type of event, etc.). */ typedef enum { SAHPI_SEC_PER_EVENT = 0, /* Event message control per event */ SAHPI_SEC_ENTIRE_SENSOR, /* Control for entire sensor only */ SAHPI_SEC_GLOBAL_DISABLE, /* Global disable of events only */ SAHPI_SEC_NO_EVENTS /* Events not supported */ } SaHpiSensorEventCtrlT; /* ** Record ** ** This is the sensor resource data record which describes all of the static ** data associated with a sensor. */ typedef struct { SaHpiSensorNumT Num; /* Sensor Number/Index */ SaHpiSensorTypeT Type; /* General Sensor Type */ SaHpiEventCategoryT Category; /* Event category */ SaHpiSensorEventCtrlT EventCtrl; /* How events can be controlled */ SaHpiEventStateT Events; /* Bit mask of event states supported */ SaHpiBoolT Ignore; /* Ignore sensor (entity not present, disabled, etc.) */ SaHpiSensorDataFormatT DataFormat; /* Format of the data */ SaHpiSensorThdDefnT ThresholdDefn; /* Threshold Definition */ SaHpiUint32T Oem; /* Reserved for OEM use */ } SaHpiSensorRecT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Aggregate Status ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* These are the default sensor numbers for aggregate status. */ #define SAHPI_DEFAGSENS_OPER (SaHpiSensorNumT)0xFE #define SAHPI_DEFAGSENS_PWR (SaHpiSensorNumT)0xFD #define SAHPI_DEFAGSENS_TEMP (SaHpiSensorNumT)0xFC /******************************************************************************* ******************************************************************************** ********** ********** ********** Controls ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* Control Number */ typedef SaHpiUint8T SaHpiCtrlNumT; /* ** Type of Control ** ** This enumerated type defines the different types of generic controls. */ typedef enum { SAHPI_CTRL_TYPE_DIGITAL = 0x00, SAHPI_CTRL_TYPE_DISCRETE, SAHPI_CTRL_TYPE_ANALOG, SAHPI_CTRL_TYPE_STREAM, SAHPI_CTRL_TYPE_TEXT, SAHPI_CTRL_TYPE_OEM = 0xC0 } SaHpiCtrlTypeT; /* ** Control State Type Definitions ** ** Defines the types of control states. */ typedef enum { SAHPI_CTRL_STATE_OFF = 0, SAHPI_CTRL_STATE_ON, SAHPI_CTRL_STATE_PULSE_OFF, SAHPI_CTRL_STATE_PULSE_ON, SAHPI_CTRL_STATE_AUTO = 0xFF } SaHpiCtrlStateDigitalT; typedef SaHpiUint32T SaHpiCtrlStateDiscreteT; typedef SaHpiInt32T SaHpiCtrlStateAnalogT; #define SAHPI_CTRL_MAX_STREAM_LENGTH 4 typedef struct { SaHpiBoolT Repeat; /* Repeat flag */ SaHpiUint32T StreamLength; /* Length of the data, in bytes, ** stored in the stream. */ SaHpiUint8T Stream[SAHPI_CTRL_MAX_STREAM_LENGTH]; } SaHpiCtrlStateStreamT; typedef SaHpiUint8T SaHpiTxtLineNumT; /* Reserved number for sending output to all lines */ #define SAHPI_TLN_ALL_LINES (SaHpiTxtLineNumT)0xFF typedef struct { SaHpiTxtLineNumT Line; /* Operate on line # */ SaHpiTextBufferT Text; /* Text to display */ } SaHpiCtrlStateTextT; #define SAHPI_CTRL_MAX_OEM_BODY_LENGTH 255 typedef struct { SaHpiManufacturerIdT MId; SaHpiUint8T BodyLength; SaHpiUint8T Body[SAHPI_CTRL_MAX_OEM_BODY_LENGTH]; /* OEM Specific */ } SaHpiCtrlStateOemT; typedef union { SaHpiCtrlStateDigitalT Digital; SaHpiCtrlStateDiscreteT Discrete; SaHpiCtrlStateAnalogT Analog; SaHpiCtrlStateStreamT Stream; SaHpiCtrlStateTextT Text; SaHpiCtrlStateOemT Oem; } SaHpiCtrlStateUnionT; typedef struct { SaHpiCtrlTypeT Type; /* Type of control */ SaHpiCtrlStateUnionT StateUnion; /* Data for control type */ } SaHpiCtrlStateT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Control Resource Data Records ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* ** Output Type ** ** This enumeration defines the what the control's output will be. */ typedef enum { SAHPI_CTRL_GENERIC = 0, SAHPI_CTRL_LED, SAHPI_CTRL_FAN_SPEED, SAHPI_CTRL_DRY_CONTACT_CLOSURE, SAHPI_CTRL_POWER_SUPPLY_INHIBIT, SAHPI_CTRL_AUDIBLE, SAHPI_CTRL_FRONT_PANEL_LOCKOUT, SAHPI_CTRL_POWER_INTERLOCK, SAHPI_CTRL_POWER_STATE, SAHPI_CTRL_LCD_DISPLAY, SAHPI_CTRL_OEM } SaHpiCtrlOutputTypeT; /* ** Specific Record Types ** These types represent the specific types of control resource data records. */ typedef struct { SaHpiCtrlStateDigitalT Default; } SaHpiCtrlRecDigitalT; typedef struct { SaHpiCtrlStateDiscreteT Default; } SaHpiCtrlRecDiscreteT; typedef struct { SaHpiCtrlStateAnalogT Min; /* Minimum Value */ SaHpiCtrlStateAnalogT Max; /* Maximum Value */ SaHpiCtrlStateAnalogT Default; } SaHpiCtrlRecAnalogT; typedef struct { SaHpiCtrlStateStreamT Default; } SaHpiCtrlRecStreamT; typedef struct { SaHpiUint8T MaxChars; /* Maximum chars per line */ SaHpiUint8T MaxLines; /* Maximum # of lines */ SaHpiLanguageT Language; /* Language Code */ SaHpiTextTypeT DataType; /* Permitted Data */ SaHpiCtrlStateTextT Default; } SaHpiCtrlRecTextT; #define SAHPI_CTRL_OEM_CONFIG_LENGTH 10 typedef struct { SaHpiManufacturerIdT MId; SaHpiUint8T ConfigData[SAHPI_CTRL_OEM_CONFIG_LENGTH]; SaHpiCtrlStateOemT Default; } SaHpiCtrlRecOemT; typedef union { SaHpiCtrlRecDigitalT Digital; SaHpiCtrlRecDiscreteT Discrete; SaHpiCtrlRecAnalogT Analog; SaHpiCtrlRecStreamT Stream; SaHpiCtrlRecTextT Text; SaHpiCtrlRecOemT Oem; } SaHpiCtrlRecUnionT; /* ** Record Definition ** Definition of the control resource data record. */ typedef struct { SaHpiCtrlNumT Num; /* Control Number/Index */ SaHpiBoolT Ignore; /* Ignore control (entity not present, disabled, etc.) */ SaHpiCtrlOutputTypeT OutputType; SaHpiCtrlTypeT Type; /* Type of control */ SaHpiCtrlRecUnionT TypeUnion; /* Specific control record */ SaHpiUint32T Oem; /* Reserved for OEM use */ } SaHpiCtrlRecT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Entity Inventory Data ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* ** These structures are used to read and write inventory data to entity inventory ** repositories within a resource. */ /* ** Entity Inventory Repository ID ** Identifier for an entity inventory repository. */ typedef SaHpiUint8T SaHpiEirIdT; #define SAHPI_DEFAULT_INVENTORY_ID (SaHpiEirIdT)0x00 /* Data Validity */ typedef enum { SAHPI_INVENT_DATA_VALID, SAHPI_INVENT_DATA_INVALID, SAHPI_INVENT_DATA_OVERFLOW } SaHpiInventDataValidityT; /* Inventory Record definitions */ typedef enum { SAHPI_INVENT_RECTYPE_INTERNAL_USE = 0xB0, SAHPI_INVENT_RECTYPE_CHASSIS_INFO, SAHPI_INVENT_RECTYPE_BOARD_INFO, SAHPI_INVENT_RECTYPE_PRODUCT_INFO, SAHPI_INVENT_RECTYPE_OEM = 0xC0 } SaHpiInventDataRecordTypeT; typedef enum { SAHPI_INVENT_CTYP_OTHER = 1, SAHPI_INVENT_CTYP_UNKNOWN, SAHPI_INVENT_CTYP_DESKTOP, SAHPI_INVENT_CTYP_LOW_PROFILE_DESKTOP, SAHPI_INVENT_CTYP_PIZZA_BOX, SAHPI_INVENT_CTYP_MINI_TOWER, SAHPI_INVENT_CTYP_TOWER, SAHPI_INVENT_CTYP_PORTABLE, SAHPI_INVENT_CTYP_LAPTOP, SAHPI_INVENT_CTYP_NOTEBOOK, SAHPI_INVENT_CTYP_HANDHELD, SAHPI_INVENT_CTYP_DOCKING_STATION, SAHPI_INVENT_CTYP_ALLINONE, SAHPI_INVENT_CTYP_SUBNOTEBOOK, SAHPI_INVENT_CTYP_SPACE_SAVING, SAHPI_INVENT_CTYP_LUNCH_BOX, SAHPI_INVENT_CTYP_MAIN_SERVER, SAHPI_INVENT_CTYP_EXPANSION, SAHPI_INVENT_CTYP_SUBCHASSIS, SAHPI_INVENT_CTYP_BUS_EXPANSION_CHASSIS, SAHPI_INVENT_CTYP_PERIPHERAL_CHASSIS, SAHPI_INVENT_CTYP_RAID_CHASSIS, SAHPI_INVENT_CTYP_RACKMOUNT } SaHpiInventChassisTypeT; typedef struct { SaHpiUint8T Data[1]; /* Variable length opaque data */ } SaHpiInventInternalUseDataT; typedef struct { SaHpiTimeT MfgDateTime; /* May be set to SAHPI_TIME_UNSPECIFIED if manufacturing date/time not available */ SaHpiTextBufferT *Manufacturer; SaHpiTextBufferT *ProductName; SaHpiTextBufferT *ProductVersion; SaHpiTextBufferT *ModelNumber; SaHpiTextBufferT *SerialNumber; SaHpiTextBufferT *PartNumber; SaHpiTextBufferT *FileId; SaHpiTextBufferT *AssetTag; SaHpiTextBufferT *CustomField[1]; /* Variable number of fields, last is NULL */ } SaHpiInventGeneralDataT; typedef struct { SaHpiInventChassisTypeT Type; /* Type of chassis */ SaHpiInventGeneralDataT GeneralData; } SaHpiInventChassisDataT; typedef struct { SaHpiManufacturerIdT MId;/* OEM Manuf. ID */ SaHpiUint8T Data[1]; /* Variable length data, defined by OEM, Length derived from DataLength in SaHpiInventDataRecordT structure: DataLength - 4(because DataLength includes the MId) */ } SaHpiInventOemDataT; typedef union { SaHpiInventInternalUseDataT InternalUse; SaHpiInventChassisDataT ChassisInfo; SaHpiInventGeneralDataT BoardInfo; SaHpiInventGeneralDataT ProductInfo; SaHpiInventOemDataT OemData; } SaHpiInventDataUnionT; typedef struct { SaHpiInventDataRecordTypeT RecordType; SaHpiUint32T DataLength; /* Length of Data field for this record */ SaHpiInventDataUnionT RecordData; /* Variable length data */ } SaHpiInventDataRecordT; typedef struct { SaHpiInventDataValidityT Validity; /* Indication as to whether data Returned by saHpiEntityInventoryDataRead() is complete and valid. Unless this flag indicates valid data, saHpiEntityInventoryDataWrite() will not take any actions except to return an error.*/ SaHpiInventDataRecordT *DataRecords[1]; /* Array of pointers to inventory Data Records. Variable number of entries. Last entry is NULL. */ } SaHpiInventoryDataT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Inventory Resource Data Records ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* ** All inventory data contained in an entity inventory repository ** must be represented in the RDR repository ** with an SaHpiInventoryRecT. */ typedef struct { SaHpiEirIdT EirId; SaHpiUint32T Oem; } SaHpiInventoryRecT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Watchdogs ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* ** This section defines all of the data types associated with watchdog timers. */ /* Watchdog Number - Identifier for a watchdog timer. */ typedef SaHpiUint8T SaHpiWatchdogNumT; #define SAHPI_DEFAULT_WATCHDOG_NUM (SaHpiWatchdogNumT)0x00 /* ** Watchdog Timer Action ** ** These enumerations represent the possible actions to be taken upon watchdog ** timer timeout and the events that are generated for watchdog actions. */ typedef enum { SAHPI_WA_NO_ACTION = 0, SAHPI_WA_RESET, SAHPI_WA_POWER_DOWN, SAHPI_WA_POWER_CYCLE } SaHpiWatchdogActionT; typedef enum { SAHPI_WAE_NO_ACTION = 0, SAHPI_WAE_RESET, SAHPI_WAE_POWER_DOWN, SAHPI_WAE_POWER_CYCLE, SAHPI_WAE_TIMER_INT=0x08 /* Used if Timer Preinterrupt only */ } SaHpiWatchdogActionEventT; /* ** Watchdog Pre-timer Interrupt ** ** These enumerations represent the possible types of interrupts that may be ** triggered by a watchdog pre-timer event. The actual meaning of these ** operations may differ depending on the hardware architecture. */ typedef enum { SAHPI_WPI_NONE = 0, SAHPI_WPI_SMI, SAHPI_WPI_NMI, SAHPI_WPI_MESSAGE_INTERRUPT, SAHPI_WPI_OEM = 0x0F } SaHpiWatchdogPretimerInterruptT; /* ** Watchdog Timer Use ** ** These enumerations represent the possible watchdog users that may have caused ** the watchdog to expire. For instance, if watchdog is being used during power ** on self test (POST), and it expires, the SAHPI_WTU_BIOS_POST expiration type ** will be set. Most specific uses for Watchdog timer by users of HPI should ** indicate SAHPI_WTU_SMS_OS if the use is to provide an OS-healthy heartbeat, ** or SAHPI_WTU_OEM if it is used for some other purpose. */ typedef enum { SAHPI_WTU_NONE = 0, SAHPI_WTU_BIOS_FRB2, SAHPI_WTU_BIOS_POST, SAHPI_WTU_OS_LOAD, SAHPI_WTU_SMS_OS, /* System Management System providing heartbeat for OS */ SAHPI_WTU_OEM, SAHPI_WTU_UNSPECIFIED = 0x0F } SaHpiWatchdogTimerUseT; /* ** Timer Use Expiration Flags ** These values are used for the Watchdog Timer Use Expiration flags in the ** SaHpiWatchdogT structure. */ typedef SaHpiUint8T SaHpiWatchdogExpFlagsT; #define SAHPI_WATCHDOG_EXP_BIOS_FRB2 (SaHpiWatchdogExpFlagsT)0x02 #define SAHPI_WATCHDOG_EXP_BIOS_POST (SaHpiWatchdogExpFlagsT)0x04 #define SAHPI_WATCHDOG_EXP_OS_LOAD (SaHpiWatchdogExpFlagsT)0x08 #define SAHPI_WATCHDOG_EXP_SMS_OS (SaHpiWatchdogExpFlagsT)0x10 #define SAHPI_WATCHDOG_EXP_OEM (SaHpiWatchdogExpFlagsT)0x20 /* ** Watchdog Structure ** ** This structure is used by the saHpiWatchdogTimerGet() and ** saHpiWatchdogTimerSet() functions. The use of the structure varies slightly by ** each function. ** ** For saHpiWatchdogTimerGet() : ** ** Log - indicates whether or not the Watchdog is configured to ** issue an event when it next times out. TRUE=event will ** be issued on timeout. ** Running - indicates whether or not the Watchdog is currently ** running or stopped. TRUE=Watchdog is running. ** TimerUse - indicates the current use of the timer; one of five ** preset uses which was included on the last ** saHpiWatchdogTimerSet() function call, or through some ** other implementation-dependent means to start the ** Watchdog timer. ** TimerAction - indicates what action will be taken when the Watchdog ** times out. ** PretimerInterrupt - indicates which action will be taken ** "PreTimeoutInterval" seconds prior to Watchdog timer ** expiration. ** PreTimeoutInterval - indicates how many milliseconds prior to timer time ** out the PretimerInterrupt action will be taken. If ** "PreTimeoutInterval" = 0, the PretimerInterrupt action ** will occur concurrently with "TimerAction." HPI ** implementations may not be able to support millisecond ** resolution and may have a maximum value restriction. ** These restrictions should be documented by the ** provider of the HPI interface. ** TimerUseExpFlags - set of five bit flags which indicate that a Watchdog ** timer timeout has occurred while the corresponding ** TimerUse value was set. Once set, these flags stay ** set until specifically cleared with a ** saHpiWatchdogTimerSet() call, or by some other ** implementation-dependent means. ** InitialCount - The time, in milliseconds, before the timer will time ** out after a saHpiWatchdogTimerReset() function call is ** made, or some other implementation-dependent strobe is ** sent to the Watchdog. HPI implementations may not be ** able to support millisecond resolution and may have a ** maximum value restriction. These restrictions should ** be documented by the provider of the HPI interface. ** PresentCount - The remaining time in milliseconds before the timer ** will time out unless a saHpiWatchdogTimerReset() ** function call is made, or some other implementation- ** dependent strobe is sent to the Watchdog. ** HPI implementations may not be able to support ** millisecond resolution on watchdog timers, but will ** return the number of clock ticks remaining times the ** number of milliseconds between each tick. ** ** For saHpiWatchdogTimerSet(): ** ** Log - indicates whether or not the Watchdog should issue ** an event when it next times out. TRUE=event will be ** issued on timeout. ** Running - indicates whether or not the Watchdog should be ** stopped before updating. ** TRUE = Watchdog is not stopped. If it is already ** stopped, it will remain stopped, but if it is ** running, it will continue to run, with the ** countdown timer reset to the new InitialCount. ** Note that there is a race condition possible ** with this setting, so it should be used with ** care. ** FALSE = Watchdog is stopped. After ** saHpiWatchdogTimerSet() is called, a subsequent ** call to saHpiWatchdogTimerReset() is required to ** start the timer. ** TimerUse - indicates the current use of the timer. Will control ** which TimerUseExpFlag is set if the timer expires. ** TimerAction - indicates what action will be taken when the Watchdog ** times out. ** PretimerInterrupt - indicates which action will be taken ** "PreTimeoutInterval" seconds prior to Watchdog timer ** expiration. ** PreTimeoutInterval - indicates how many milliseconds prior to timer time ** out the PretimerInterrupt action will be taken. If ** "PreTimeoutInterval" = 0, the PretimerInterrupt action ** will occur concurrently with "TimerAction." HPI ** implementations may not be able to support millisecond ** resolution and may have a maximum value restriction. ** These restrictions should be documented by the ** provider of the HPI interface. ** TimerUseExpFlags - Set of five bit flags corresponding to the five ** TimerUse values. For each bit set, the corresponding ** Timer Use Expiration Flag will be CLEARED. Generally, ** a program should only clear the Timer Use Expiration ** Flag corresponding to its own TimerUse, so that other ** software, which may have used the timer for another ** purpose in the past can still read its TimerUseExpFlag ** to determine whether or not the timer expired during ** that use. ** InitialCount - The time, in milliseconds, before the timer will time ** out after a saHpiWatchdogTimerReset() function call is ** made, or some other implementation-dependent strobe is ** sent to the Watchdog. HPI implementations may not be ** able to support millisecond resolution and may have a ** maximum value restriction. These restrictions should ** be documented by the provider of the HPI interface. ** PresentCount - Not used on saHpiWatchdogTimerSet() function. Ignored. ** */ typedef struct { SaHpiBoolT Log; SaHpiBoolT Running; SaHpiWatchdogTimerUseT TimerUse; SaHpiWatchdogActionT TimerAction; SaHpiWatchdogPretimerInterruptT PretimerInterrupt; SaHpiUint32T PreTimeoutInterval; SaHpiWatchdogExpFlagsT TimerUseExpFlags; SaHpiUint32T InitialCount; SaHpiUint32T PresentCount; } SaHpiWatchdogT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Watchdog Resource Data Records ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* ** When the "Watchdog" capability is set in a resource, a watchdog with an ** identifier of SAHPI_DEFAULT_WATCHDOG_NUM is required. All watchdogs must be ** represented in the RDR repository with an SaHpiWatchdogRecT, including the ** watchdog with an identifier of SAHPI_DEFAULT_WATCHDOG_NUM. */ typedef struct { SaHpiWatchdogNumT WatchdogNum; SaHpiUint32T Oem; } SaHpiWatchdogRecT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Resource Data Record ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* ** The following describes the different types of records that exist within a ** RDR repository and the RDR super-structure to all of the specific RDR types ** (sensor, inventory data, watchdog, etc.). */ typedef enum { SAHPI_NO_RECORD, SAHPI_CTRL_RDR, SAHPI_SENSOR_RDR, SAHPI_INVENTORY_RDR, SAHPI_WATCHDOG_RDR } SaHpiRdrTypeT; typedef union { SaHpiCtrlRecT CtrlRec; SaHpiSensorRecT SensorRec; SaHpiInventoryRecT InventoryRec; SaHpiWatchdogRecT WatchdogRec; } SaHpiRdrTypeUnionT; typedef struct { SaHpiEntryIdT RecordId; SaHpiRdrTypeT RdrType; SaHpiEntityPathT Entity; /* Entity to which this RDR relates. */ SaHpiRdrTypeUnionT RdrTypeUnion; SaHpiTextBufferT IdString; } SaHpiRdrT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Hot Swap ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* Power State */ typedef enum { SAHPI_HS_POWER_OFF = 0, SAHPI_HS_POWER_ON, SAHPI_HS_POWER_CYCLE } SaHpiHsPowerStateT; /* Hot Swap Indicator State */ typedef enum { SAHPI_HS_INDICATOR_OFF = 0, SAHPI_HS_INDICATOR_ON } SaHpiHsIndicatorStateT; /* Hot Swap Action */ typedef enum { SAHPI_HS_ACTION_INSERTION = 0, SAHPI_HS_ACTION_EXTRACTION } SaHpiHsActionT; /* Hot Swap State */ typedef enum { SAHPI_HS_STATE_INACTIVE = 0, SAHPI_HS_STATE_INSERTION_PENDING, SAHPI_HS_STATE_ACTIVE_HEALTHY, SAHPI_HS_STATE_ACTIVE_UNHEALTHY, SAHPI_HS_STATE_EXTRACTION_PENDING, SAHPI_HS_STATE_NOT_PRESENT } SaHpiHsStateT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Events, Part 2 ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* Event Data Structures */ /* ** Sensor Optional Data ** ** Sensor events may contain optional data items passed and stored with the ** event. If these optional data items are present, they will be included with ** the event data returned in response to a saHpiEventGet() or ** saHpiEventLogEntryGet() function call. Also, the optional data items may be ** included with the event data passed to the saHpiEventLogEntryAdd() function. ** ** Specific implementations of HPI may have restrictions on how much data may ** be passed to saHpiEventLogEntryAdd(). These restrictions should be documented ** by the provider of the HPI interface. */ typedef enum { SAHPI_CRITICAL = 0, SAHPI_MAJOR, SAHPI_MINOR, SAHPI_INFORMATIONAL, SAHPI_OK, SAHPI_DEBUG = 0xF0 } SaHpiSeverityT; typedef SaHpiUint8T SaHpiSensorOptionalDataT; #define SAHPI_SOD_TRIGGER_READING (SaHpiSensorOptionalDataT)0x01 #define SAHPI_SOD_TRIGGER_THRESHOLD (SaHpiSensorOptionalDataT)0x02 #define SAHPI_SOD_OEM (SaHpiSensorOptionalDataT)0x04 #define SAHPI_SOD_PREVIOUS_STATE (SaHpiSensorOptionalDataT)0x08 #define SAHPI_SOD_SENSOR_SPECIFIC (SaHpiSensorOptionalDataT)0x10 typedef struct { SaHpiSensorNumT SensorNum; SaHpiSensorTypeT SensorType; SaHpiEventCategoryT EventCategory; SaHpiBoolT Assertion; /* TRUE = Event State asserted FALSE = deasserted */ SaHpiEventStateT EventState; /* State being asserted deasserted */ SaHpiSensorOptionalDataT OptionalDataPresent; SaHpiSensorReadingT TriggerReading; /* Reading that triggered the event */ SaHpiSensorReadingT TriggerThreshold; SaHpiEventStateT PreviousState; SaHpiUint32T Oem; SaHpiUint32T SensorSpecific; } SaHpiSensorEventT; typedef struct { SaHpiHsStateT HotSwapState; SaHpiHsStateT PreviousHotSwapState; } SaHpiHotSwapEventT; typedef struct { SaHpiWatchdogNumT WatchdogNum; SaHpiWatchdogActionEventT WatchdogAction; SaHpiWatchdogPretimerInterruptT WatchdogPreTimerAction; SaHpiWatchdogTimerUseT WatchdogUse; } SaHpiWatchdogEventT; #define SAHPI_OEM_EVENT_DATA_SIZE 32 typedef struct { SaHpiManufacturerIdT MId; SaHpiUint8T OemEventData[SAHPI_OEM_EVENT_DATA_SIZE]; } SaHpiOemEventT; /* ** User events may be used for storing custom events created by the application / middleware; ** eg. when injecting events into the event log using saHpiEventLogEntryAdd(). */ #define SAHPI_USER_EVENT_DATA_SIZE 32 typedef struct { SaHpiUint8T UserEventData[SAHPI_USER_EVENT_DATA_SIZE]; } SaHpiUserEventT; typedef enum { SAHPI_ET_SENSOR, SAHPI_ET_HOTSWAP, SAHPI_ET_WATCHDOG, SAHPI_ET_OEM, SAHPI_ET_USER } SaHpiEventTypeT; typedef union { SaHpiSensorEventT SensorEvent; SaHpiHotSwapEventT HotSwapEvent; SaHpiWatchdogEventT WatchdogEvent; SaHpiOemEventT OemEvent; SaHpiUserEventT UserEvent; } SaHpiEventUnionT; typedef struct { SaHpiResourceIdT Source; SaHpiEventTypeT EventType; SaHpiTimeT Timestamp; SaHpiSeverityT Severity; SaHpiEventUnionT EventDataUnion; } SaHpiEventT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Parameter Control ********** ********** ********** ******************************************************************************** *******************************************************************************/ typedef enum { SAHPI_DEFAULT_PARM = 0, SAHPI_SAVE_PARM, SAHPI_RESTORE_PARM } SaHpiParmActionT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Reset ********** ********** ********** ******************************************************************************** *******************************************************************************/ typedef enum { SAHPI_COLD_RESET = 0, SAHPI_WARM_RESET, SAHPI_RESET_ASSERT, SAHPI_RESET_DEASSERT } SaHpiResetActionT; /******************************************************************************* ******************************************************************************** ********** ********** ********** Resource Presence Table ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* This section defines the types associated with the RPT. */ typedef struct { SaHpiUint32T UpdateCount; /* This count is incremented any time the table is changed. It rolls over to zero when the maximum value is reached */ SaHpiTimeT UpdateTimestamp; /* This time is set any time the table is changed. If the implementation cannot supply an absolute timestamp, then it may supply a timestamp relative to some system- defined epoch, such as system boot. The value SAHPI_TIME_UNSPECIFIED indicates that the time of the update cannot be determined. Otherwise, If the value is less than or equal to SAHPI_TIME_MAX_RELATIVE, then it is relative; if it is greater than SAHPI_TIME_MAX_RELATIVE, then it is absolute. */ } SaHpiRptInfoT; /* ** Resource Info Type Definitions ** ** ** SaHpiResourceInfoT contains static configuration data concerning the ** management controller associated with the resource, or the resource itself. ** Note this information is used to describe the resource; that is, the piece of ** infrastructure which manages an entity (or multiple entities) - NOT the entities ** for which the resource provides management. The purpose of the ** SaHpiResourceInfoT structure is to provide information that the HPI user may ** need in order to interact correctly with the resource (e.g., recognize a ** specific management controller which may have defined OEM fields in sensors, ** OEM controls, etc.). ** ** All of the fields in the following structure may or may not be used by a ** given resource. */ typedef struct { SaHpiUint8T ResourceRev; SaHpiUint8T SpecificVer; SaHpiUint8T DeviceSupport; SaHpiManufacturerIdT ManufacturerId; SaHpiUint16T ProductId; SaHpiUint8T FirmwareMajorRev; SaHpiUint8T FirmwareMinorRev; SaHpiUint8T AuxFirmwareRev; } SaHpiResourceInfoT; /* ** Resource Capabilities ** ** This definition defines the capabilities of a given resource. One resource ** may support any number of capabilities using the bit mask. Every resource ** must set at least one of these capabilities; ie. zero is not a valid value ** for a resource's capabilities. ** ** SAHPI_CAPABILITY_DOMAIN ** SAHPI_CAPABILITY_RESOURCE ** SAHPI_CAPABILITY_EVT_DEASSERTS ** Indicates that all sensors on the resource have the property that their ** Assertion and Deassertion event enable flags are the same. That is, ** for all event states whose assertion triggers an event, it is ** guaranteed that the deassertion of that event will also ** trigger an event. Thus, the user may track the state of sensors on the ** resource by monitoring events rather than polling for state changes. ** SAHPI_CAPABILITY_AGGREGATE_STATUS ** SAHPI_CAPABILITY_CONFIGURATION ** SAHPI_CAPABILITY_MANAGED_HOTSWAP ** Indicates that the resource supports managed hotswap. Since hotswap only ** makes sense for field-replaceable units, the SAHPI_CAPABILITY_FRU ** capability bit must also be set for this resource. ** SAHPI_CAPABILITY_WATCHDOG ** SAHPI_CAPABILITY_CONTROL ** SAHPI_CAPABILITY_FRU ** Indicates that the resource is a field-replaceable unit; i.e., it is ** capable of being removed and replaced in a live system. This does not ** necessarily imply that the resource supports managed hotswap. ** SAHPI_CAPABILITY_INVENTORY_DATA ** SAHPI_CAPABILITY_SEL ** SAHPI_CAPABILITY_RDR ** Indicates that a resource data record (RDR) repository is supplied ** by the resource. Since the existence of an RDR is mandatory, this ** capability must be asserted. ** SAHPI_CAPABILITY_SENSOR */ typedef SaHpiUint32T SaHpiCapabilitiesT; #define SAHPI_CAPABILITY_DOMAIN (SaHpiCapabilitiesT)0x80000000 #define SAHPI_CAPABILITY_RESOURCE (SaHpiCapabilitiesT)0X40000000 #define SAHPI_CAPABILITY_EVT_DEASSERTS (SaHpiCapabilitiesT)0x00008000 #define SAHPI_CAPABILITY_AGGREGATE_STATUS (SaHpiCapabilitiesT)0x00002000 #define SAHPI_CAPABILITY_CONFIGURATION (SaHpiCapabilitiesT)0x00001000 #define SAHPI_CAPABILITY_MANAGED_HOTSWAP (SaHpiCapabilitiesT)0x00000800 #define SAHPI_CAPABILITY_WATCHDOG (SaHpiCapabilitiesT)0x00000400 #define SAHPI_CAPABILITY_CONTROL (SaHpiCapabilitiesT)0x00000200 #define SAHPI_CAPABILITY_FRU (SaHpiCapabilitiesT)0x00000100 #define SAHPI_CAPABILITY_INVENTORY_DATA (SaHpiCapabilitiesT)0x00000008 #define SAHPI_CAPABILITY_SEL (SaHpiCapabilitiesT)0x00000004 #define SAHPI_CAPABILITY_RDR (SaHpiCapabilitiesT)0x00000002 #define SAHPI_CAPABILITY_SENSOR (SaHpiCapabilitiesT)0x00000001 /* ** RPT Entry ** ** This structure is used to store the RPT entry information. ** ** The ResourceCapabilities field definies the capabilities of the resource. ** This field must be non-zero for all valid resources. ** ** The ResourceTag field is an informational value that supplies the caller with naming ** information for the resource. This should be set to the "user-visible" name for a ** resource, which can be used to identify the resource in messages to a human operator. ** For example, it could be set to match a physical printed label attached to the primary ** entity which the resource manages. See section 5.2.6, saHpiResourceTagSet(), on page 33. */ typedef struct { SaHpiEntryIdT EntryId; SaHpiResourceIdT ResourceId; SaHpiResourceInfoT ResourceInfo; SaHpiEntityPathT ResourceEntity; /* If resource manages a FRU, entity path of the FRU */ /* If resource manages a single entity, entity path of that entity. */ /* If resource manages multiple entities, the entity path of the "primary" entity managed by the resource */ /* Must be set to the same value in every domain which contains this resource */ SaHpiCapabilitiesT ResourceCapabilities; /* Must be non-0. */ SaHpiSeverityT ResourceSeverity; /* Indicates the criticality that should be raised when the resource is not responding */ SaHpiDomainIdT DomainId; /* The Domain ID is used when the resource is also a domain. */ SaHpiTextBufferT ResourceTag; } SaHpiRptEntryT; /******************************************************************************* ******************************************************************************** ********** ********** ********** System Event Log ********** ********** ********** ******************************************************************************** *******************************************************************************/ /* This section defines the types associated with the SEL. */ /* ** Event Log Information ** ** The Entries entry denotes the number of active entries contained in the log. ** The Size entry denotes the total number of entries the log is able to hold. ** The UpdateTimestamp entry denotes the timestamp of the last addition, ** deletion or log clear operation. ** The CurrentTime entry denotes the log's idea of the current time; i.e the ** timestamp that would be placed on an entry if it was added now. ** The Enabled entry indicates whether the log is enabled. If the event log ** is "disabled" no events generated within the HPI implementation will be ** added to the event log. Events may still be added to the event log with ** the saHpiEventLogEntryAdd() function. When the event log is "enabled" ** events may be automatically added to the event log as they are generated ** in a resource or a domain, however, it is implementation-specific which ** events are automatically added to any event log. ** The OverflowFlag entry indicates the log has overflowed. Events have been ** dropped or overwritten due to a table overflow. ** The OverflowAction entry indicates the behavior of the SEL when an overflow ** occurs. ** The DeleteEntrySupported indicates whether the delete command is supported for ** event log entries. Note that clearing an entire log is valid even if this ** flag is not set. */ typedef enum { SAHPI_SEL_OVERFLOW_DROP, /* New entries are dropped when log is full*/ SAHPI_SEL_OVERFLOW_WRAP, /* Log wraps when log is full */ SAHPI_SEL_OVERFLOW_WRITELAST /* Last entry overwritten when log is full */ } SaHpiSelOverflowActionT; typedef struct { SaHpiUint32T Entries; SaHpiUint32T Size; SaHpiTimeT UpdateTimestamp; SaHpiTimeT CurrentTime; SaHpiBoolT Enabled; SaHpiBoolT OverflowFlag; SaHpiSelOverflowActionT OverflowAction; SaHpiBoolT DeleteEntrySupported; } SaHpiSelInfoT; /* ** Event Log Entry ** These types define the event log entry. */ typedef SaHpiUint32T SaHpiSelEntryIdT; /* Reserved values for event log entry IDs */ #define SAHPI_OLDEST_ENTRY (SaHpiSelEntryIdT)0x00000000 #define SAHPI_NEWEST_ENTRY (SaHpiSelEntryIdT)0xFFFFFFFF #define SAHPI_NO_MORE_ENTRIES (SaHpiSelEntryIdT)0xFFFFFFFE typedef struct { SaHpiSelEntryIdT EntryId; /* Entry ID for record */ SaHpiTimeT Timestamp; /* Time at which the event was placed in the event log. The value SAHPI_TIME_UNSPECIFIED indicates that the time of the event cannot be determined; otherwise, if less than or equal to SAHPI_TIME_MAX_RELATIVE, then it relative; if it is greater than SAHPI_TIME_MAX_RELATIVE, then it is absolute. */ SaHpiEventT Event; /* Logged Event */ } SaHpiSelEntryT; /******************************************************************************* ** ** Name: saHpiInitialize ** ** Description: ** This function allows the management service an opportunity to perform ** platform-specific initialization. saHpiInitialize() must be called ** before any other functions are called. ** ** Parameters: ** HpiImplVersion - [out] Pointer to the version of the HPI ** implementation. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. SA_ERR_HPI_DUPLICATE is returned when the HPI has already ** been initialized. Once one saHpiInitialize() call has been made, ** another one cannot be made until after a saHpiFinalize() call is made. ** ** ** Remarks: ** This function returns the version of the HPI implementation. Note: If ** the HPI interface version is needed it can be retrieved from the ** SAHPI_INTERFACE_VERSION definition. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiInitialize( SAHPI_OUT SaHpiVersionT *HpiImplVersion ); /******************************************************************************* ** ** Name: saHpiFinalize ** ** Description: ** This function allows the management service an opportunity to perform ** platform-specific cleanup. All sessions should be closed (see ** saHpiSessionClose()), before this function is executed. All open ** sessions will be forcibly closed upon execution of this command. ** ** Parameters: ** None. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. 5 Domains ** *******************************************************************************/ SaErrorT SAHPI_API saHpiFinalize ( ); /******************************************************************************* ** ** Name: saHpiSessionOpen ** ** Description: ** This function opens a HPI session for a given domain and set of ** security characteristics (future). This function call assumes that a ** pre-arranged agreement between caller and the HPI implementation ** identifies the resources within the specified domain. As a future ** roadmap item, functions for discovery of domains and allocation of ** resources within domains may be developed. ** ** Parameters: ** DomainId - [in] Domain ID to be controlled by middleware/application. ** A domain ID of SAHPI_DEFAULT_DOMAIN_ID indicates the default domain. ** SessionId - [out] Pointer to a location to store a handle to the newly ** opened session. This handle is used for subsequent access to domain ** resources and events. ** SecurityParams - [in] Pointer to security and permissions data ** structure. This parameter is reserved for future use, and must be set ** to NULL. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. SA_ERR_HPI_INVALID_DOMAIN is returned if no domain ** matching the specified domain ID exists. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSessionOpen ( SAHPI_IN SaHpiDomainIdT DomainId, SAHPI_OUT SaHpiSessionIdT *SessionId, SAHPI_IN void *SecurityParams ); /******************************************************************************* ** ** Name: saHpiSessionClose ** ** Description: ** This function closes a HPI session. After closing a session, the ** session ID will no longer be valid. ** ** Parameters: ** SessionId - [in] Session handle previously obtained using ** saHpiSessionOpen(). ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSessionClose ( SAHPI_IN SaHpiSessionIdT SessionId ); /******************************************************************************* ** ** Name: saHpiResourcesDiscover ** ** Description: ** This function requests the underlying management service to discover ** information about the resources it controls for the domain associated ** with the open session. This function may be called during operation to ** regenerate the RPT table. For those FRUs that must be discovered by ** polling, latency between FRU insertion and actual addition of the ** resource associated with that FRU to the RPT exists. To overcome this ** latency, a discovery of all present resources may be forced by calling ** saHpiResourcesDiscover (). ** ** Parameters: ** SessionId - [in] Handle to session context. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourcesDiscover ( SAHPI_IN SaHpiSessionIdT SessionId ); /******************************************************************************* ** ** Name: saHpiRptInfoGet ** ** Description: ** This function is used for requesting information about the resource ** presence table (RPT) such as an update counter and timestamp. This is ** particularly useful when using saHpiRptEntryGet() (see page 31). ** ** Parameters: ** SessionId - [in] Handle to session context. ** RptInfo - [out] Pointer to the information describing the resource ** presence table. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiRptInfoGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_OUT SaHpiRptInfoT *RptInfo ); /******************************************************************************* ** ** Name: saHpiRptEntryGet ** ** Description: ** This function retrieves resource information for the specified entry ** of the resource presence table. This function allows the caller to ** read the RPT entry-by-entry. If the EntryID parameter is set to ** SAHPI_FIRST_ENTRY, the first entry in the RPT will be returned. When ** an entry is successfully retrieved, *NextEntryID will be set to the ** ID of the next valid entry; however, when the last entry has been ** retrieved, *NextEntryID will be set to SAHPI_LAST_ENTRY. To retrieve ** an entire list of entries, call this function first with an EntryID of ** SAHPI_FIRST_ENTRY and then use the returned NextEntryID in the next ** call. Proceed until the NextEntryID returned is SAHPI_LAST_ENTRY. At ** initialization, the user may not wish to turn on eventing, since the ** context of the events, as provided by the RPT, is not known. In this ** instance, if a FRU is inserted into the system while the RPT is being ** read entry by entry, the resource associated with that FRU may be ** missed. (Keep in mind that there is no specified ordering for the RPT ** entries.) The update counter provides a means for insuring that no ** resources are missed when stepping through the RPT. In order to use ** this feature, the user should invoke saHpiRptInfoGet(), and get the ** update counter value before retrieving the first RPT entry. After ** reading the last entry, the user should again invoke the ** saHpiRptInfoGet() to get the update counter value. If the update ** counter has not been incremented, no new records have been added. ** ** Parameters: ** SessionId - [in] Handle to session context. ** EntryId - [in] Handle of the entry to retrieve from the RPT. Reserved ** entry ID values: SAHPI_FIRST_ENTRY Get first entry SAHPI_LAST_ENTRY ** Reserved as delimiter for end of list. Not a valid entry identifier. ** ** NextEntryId - [out] Pointer to location to store the record ID of next ** entry in RPT. ** RptEntry - [out] Pointer to the structure to hold the returned RPT ** entry. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiRptEntryGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiEntryIdT EntryId, SAHPI_OUT SaHpiEntryIdT *NextEntryId, SAHPI_OUT SaHpiRptEntryT *RptEntry ); /******************************************************************************* ** ** Name: saHpiRptEntryGetByResourceId ** ** Description: ** This function retrieves resource information from the resource ** presence table for the specified resource using its resource ID. ** Typically at start-up, the RPT is read entry-by-entry, using ** saHpiRptEntryGet(). From this, the caller can establish the set of ** resource IDs to use for future calls to the HPI functions. However, ** there may be other ways of learning resource IDs without first reading ** the RPT. For example, resources may be added to the domain while the ** system is running in response to a hot-swap action. When a resource is ** added, the application will receive a hot-swap event containing the ** resource ID of the new resource. The application may then want to ** search the RPT for more detailed information on the newly added ** resource. In this case, the resource ID can be used to locate the ** applicable RPT entry information. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource whose RPT entry should ** be returned. ** RptEntry - [out] Pointer to structure to hold the returned RPT entry. ** ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiRptEntryGetByResourceId ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_OUT SaHpiRptEntryT *RptEntry ); /******************************************************************************* ** ** Name: saHpiResourceSeveritySet ** ** Description: ** This function allows the caller to set the severity level applied to ** an event issued if a resource unexpectedly becomes unavailable to the ** HPI. A resource may become unavailable for several reasons including: ** ? The FRU associated with the resource is no longer present in the ** system (a surprise extraction has occurred) ? A catastrophic failure ** has occurred Typically, the HPI implementation will provide an ** appropriate default value for this parameter, which may vary by ** resource; management software can override this default value by use ** of this function ? If a resource is removed from, then re-added to the ** RPT (e.g., because of a hot-swap action), the HPI implementation may ** reset the value of this parameter. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource for which the severity ** level will be set. ** Severity - [in] Severity level of event issued when the resource ** unexpectedly becomes unavailable to the HPI. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourceSeveritySet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSeverityT Severity ); /******************************************************************************* ** ** Name: saHpiResourceTagSet ** ** Description: ** This function allows the caller to set the resource tag for a ** particular resource. The resource tag is an informational value that ** supplies the caller with naming information for the resource. This ** should be set to the "user-visible" name for a resource, which can be ** used to identify the resource in messages to a human operator. For ** example, it could be set to match a physical, printed label attached ** to the entity associated with the resource. Typically, the HPI ** implementation will provide an appropriate default value for this ** parameter; this function is provided so that management software can ** override the default, if desired. The value of the resource tag may be ** retrieved from the resource's RPT entry. Note: If a resource is ** removed from, then re-added to the RPT (e.g., because of a hot-swap ** action), the HPI implementation may reset the value of this parameter. ** ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource for which the resource ** tag should be set. ** ResourceTag - [in] Pointer to string representing the resource tag. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourceTagSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiTextBufferT *ResourceTag ); /******************************************************************************* ** ** Name: saHpiResourceIdGet ** ** Description: ** This function returns the resource ID of the resource associated with ** the entity upon which the caller is running. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [out] Pointer to location to hold the returned resource ** ID. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. SA_ERR_HPI_NOT_PRESENT is returned if the entity the ** caller is running on is not manageable in the addressed domain. ** SA_ERR_HPI_UNKNOWN is returned if the domain controller cannot ** determine an appropriate response. That is, there may be an ** appropriate resource ID in the domain to return, but it cannot be ** determined. ** ** Remarks: ** This function must be issued within a session to a domain that ** includes a resource associated with the entity upon which the caller ** is running, or the SA_ERR_HPI_NOT_PRESENT return will be issued. Since ** entities are contained within other entities, there may be multiple ** possible resources that could be returned to this call. For example, ** if there is a resource ID associated with a particular compute blade ** upon which the caller is running, and another associated with the ** chassis which contains the compute blade, either could logically be ** returned as an indication of a resource associated with the entity ** upon which the caller was running. The function should return the ** resource ID of the "smallest" resource that is associated with the ** caller. So, in the example above, the function should return the ** resource ID of the compute blade. Once the function has returned the ** resourceID, the caller may issue further HPI calls using that ** resourceID to learn the type of resource that been identified. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourceIdGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_OUT SaHpiResourceIdT *ResourceId ); /******************************************************************************* ** ** Name: saHpiEntitySchemaGet ** ** Description: ** This function returns the identifier of the Entity Schema for the HPI ** implementation. This schema defines valid Entity Paths that may be ** returned by the HPI implementation. ** ** Parameters: ** SessionId - [in] Handle to session context. ** SchemaId - [out] Pointer to the ID of the schema in use; zero ** indicates that a custom schema is in use. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** This function may be issued on any session opened to any domain in the ** system, and will return the same identifier. The identifier returned ** should either be zero, indicating that the HPI implementation uses a ** custom schema; or one of the schema identifiers defined in Appendix A, ** "Pre-Defined Entity Schemas," page 107. In the case of a custom ** schema, the HPI implementation may use arbitrary entity paths to ** describe resources in the system; in the case of a pre-defined schema, ** all entity paths should conform to the schema. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEntitySchemaGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_OUT SaHpiUint32T *SchemaId ); /******************************************************************************* ** ** Name: saHpiEventLogInfoGet ** ** Description: ** This function retrieves the number of entries in the system event log, ** total size of the event log, timestamp for the most recent entry, the ** log's idea of the current time (i.e., timestamp that would be placed ** on an entry at this moment), enabled/disabled status of the log (see ** saHpiEventLogStateSet()), the overflow flag, the overflow action, and ** whether the log supports deletion of individual entries. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource that contains the system ** event log to be managed. Set to SAHPI_DOMAIN_CONTROLLER_ID to address ** the domain system event log. ** Info - [out] Pointer to the returned SEL information. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventLogInfoGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_OUT SaHpiSelInfoT *Info ); /******************************************************************************* ** ** Name: saHpiEventLogEntryGet ** ** Description: ** This function retrieves an event log entry from a system event log. ** The special entry IDs SAHPI_OLDEST_ENTRY and SAHPI_NEWEST_ENTRY are ** used to select the oldest and newest entries, respectively, in the log ** being read. A returned NextEntryID of SAHPI_NO_MORE_ENTRIES indicates ** that the newest entry has been returned; there are no more entries ** going forward (time-wise) in the log. A returned PrevEntryID of ** SAHPI_NO_MORE_ENTRIES indicates that the oldest entry has been ** returned. To retrieve an entire list of entries going forward (oldest ** entry to newest entry) in the log, call this function first with an ** EntryID of SAHPI_OLDEST_ENTRY and then use the returned NextEntryID as ** the EntryID in the next call. Proceed until the NextEntryID returned ** is SAHPI_NO_MORE_ENTRIES. To retrieve an entire list of entries going ** backward (newest entry to oldest entry) in the log, call this function ** first with an EntryID of SAHPI_NEWEST_ENTRY and then use the returned ** PrevEntryID as the EntryID in the next call. Proceed until the ** PrevEntryID returned is SAHPI_NO_MORE_ENTRIES. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource that contains the system ** event log to be read. Set to SAHPI_DOMAIN_CONTROLLER_ID to address the ** domain system event log. ** EntryId - [in] Handle of the entry to retrieve from the SEL. Reserved ** event log entry ID values: SAHPI_OLDEST_ENTRY Oldest entry in the ** log. SAHPI_NEWEST_ENTRY Newest entry in the log. ** SAHPI_NO_MORE_ENTRIES Not valid for this parameter. Used only when ** retrieving the next and previous entry IDs. ** PrevEntryId - [out] Handle of previous (older adjacent) entry in event ** log. Reserved event log entry ID values: SAHPI_OLDEST_ENTRY Not valid ** for this parameter. Used only for the EntryID parameter. ** SAHPI_NEWEST_ENTRY Not valid for this parameter. Used only for the ** EntryID parameter. SAHPI_NO_MORE_ENTRIES No more entries in the log ** before the one referenced by the EntryId parameter. ** NextEntryId - [out] Handle of next (newer adjacent) entry in event ** log. Reserved event log entry ID values: SAHPI_OLDEST_ENTRY Not valid ** for this parameter. Used only for the EntryID parameter. ** SAHPI_NEWEST_ENTRY Not valid for this parameter. Used only for the ** EntryID parameter. SAHPI_NO_MORE_ENTRIES No more entries in the log ** after the one referenced by the EntryId parameter. ** EventLogEntry - [out] Pointer to retrieved event log entry. ** Rdr - [in/out] Pointer to structure to receive resource data record ** associated with the event, if available. If NULL, no RDR data will be ** returned. ** RptEntry - [in/out] Pointer to structure to receive RPT Entry ** associated with the event, if available. If NULL, no RPT entry data ** will be returned. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Event logs may include RPT entries and resource data records ** associated with the resource and sensor issuing an event along with ** the basic event data in the log. Because the system may be ** reconfigured after the event was entered in the log, this stored ** information may be important to interpret the event. If the event log ** includes logged RPT Entries and/or RDRs, and if the caller provides a ** pointer to a structure to receive this information, it will be ** returned along with the event log entry. If the caller provides a ** pointer for an RPT entry, but the event log does not include a logged ** RPT entry for the event being returned, RptEntry->ResourceCapabilities ** will be set to zero. No valid RPTEntry will have a zero value here. If ** the caller provides a pointer for an RDR, but the event log does not ** include a logged RDR for the event being returned, Rdr->RdrType will ** be set to SAHPI_NO_RECORD. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventLogEntryGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSelEntryIdT EntryId, SAHPI_OUT SaHpiSelEntryIdT *PrevEntryId, SAHPI_OUT SaHpiSelEntryIdT *NextEntryId, SAHPI_OUT SaHpiSelEntryT *EventLogEntry, SAHPI_INOUT SaHpiRdrT *Rdr, SAHPI_INOUT SaHpiRptEntryT *RptEntry ); /******************************************************************************* ** ** Name: saHpiEventLogEntryAdd ** ** Description: ** This function enables system management software to add entries to the ** system event log. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource that contains the system ** event log to be managed. Set to SAHPI_DOMAIN_CONTROLLER_ID to address ** the Domain System Event Log. ** EvtEntry - [in] Pointer to event log entry data to write to the system ** event log. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** This function forces a write of the event to the addressed event log. ** Nothing else is done with the event. Specific implementations of HPI ** may have restrictions on how much data may be passed to the ** saHpiEventLogEntryAdd() function. These restrictions should be ** documented by the provider of the HPI interface. If more event log ** data is provided than can be written, an error will be returned. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventLogEntryAdd ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSelEntryT *EvtEntry ); /******************************************************************************* ** ** Name: saHpiEventLogEntryDelete ** ** Description: ** This function deletes an event log entry. This operation is only valid ** if so indicated by saHpiEventLogInfoGet(), via the ** DeleteEntrySupported field in the SaHpiSelInfoT structure. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] ResourceID of the resource that contains the system ** event log to be managed. Set to SAHPI_DOMAIN_CONTROLLER_ID to address ** the domain system event log. ** EntryId - [in] Entry ID on the event log entry to delete. Reserved ** event log entry ID values: SAHPI_OLDEST_ENTRY - Oldest entry in the ** log. SAHPI_NEWEST_ENTRY - Newest entry in the log. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. SA_ERR_HPI_INVALID_CMD is returned if this log does not ** support this operation. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventLogEntryDelete ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSelEntryIdT EntryId ); /******************************************************************************* ** ** Name: saHpiEventLogClear ** ** Description: ** This function erases the contents of the specified system event log. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] ResourceID of the resource that contains the system ** event log to be managed. Set to SAHPI_DOMAIN_CONTROLLER_ID to address ** the domain system event log. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Note that all event logs must support the "clear" operation, ** regardless of the setting of the DeleteEntrySupported field in the ** SaHpiSelInfoT structure returned by saHpiEventLogInfoGet(). ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventLogClear ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId ); /******************************************************************************* ** ** Name: saHpiEventLogTimeGet ** ** Description: ** This function retrieves the current time from the event log's own time ** clock. The value of this clock is used to timestamp log entries ** written into the log. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] ResourceID of the resource that contains the System ** Event Log to be managed. Set to SAHPI_DOMAIN_CONTROLLER_ID to address ** the Domain System Event Log. ** Time - [out] Pointer to the returned SEL current time. If the ** implementation cannot supply an absolute time value, then it may ** supply a time relative to some system-defined epoch, such as system ** boot. If the time value is less than or equal to ** SAHPI_TIME_MAX_RELATIVE, but not SAHPI_TIME_UNSPECIFIED, then it is ** relative; if it is greater than SAHPI_TIME_MAX_RELATIVE, then it is ** absolute. The value SAHPI_TIME_UNSPECIFIED indicates that the time is ** not set, or cannot be determined. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventLogTimeGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_OUT SaHpiTimeT *Time ); /******************************************************************************* ** ** Name: saHpiEventLogTimeSet ** ** Description: ** This function sets the event log's time clock, which is used to ** timestamp events written into the log. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource that contains the system ** event log to be managed. set to SAHPI_DOMAIN_CONTROLLER_ID to address ** the domain system event log. ** Time - [in] time to set the SEL clock to. If the implementation cannot ** supply an absolute time, then it may supply a time relative to some ** system-defined epoch, such as system boot. If the timestamp value is ** less than or equal to SAHPI_TIME_MAX_RELATIVE, but not ** SAHPI_TIME_UNSPECIFIED, then it is relative; if it is greater than ** SAHPI_TIME_MAX_RELATIVE, then it is absolute. The value ** SAHPI_TIME_UNSPECIFIED indicates that the time of the event cannot be ** determined. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventLogTimeSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiTimeT Time ); /******************************************************************************* ** ** Name: saHpiEventLogStateGet ** ** Description: ** This function enables system management software to get the event log ** state. If the event log is "disabled" no events generated within the ** HPI implementation will be added to the event log. Events may still be ** added to the event log with the saHpiEventLogEntryAdd() function. When ** the event log is "enabled" events may be automatically added to the ** event log as they are generated in a resource or a domain, however, it ** is implementation-specific which events are automatically added to any ** event log. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] ResourceID of the resource that contains the System ** Event Log to be managed. Set to SAHPI_DOMAIN_CONTROLLER_ID to address ** the Domain System Event Log. ** Enable - [out] Pointer to the current SEL state. True indicates that ** the SEL is enabled; false indicates that it is disabled. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventLogStateGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_OUT SaHpiBoolT *Enable ); /******************************************************************************* ** ** Name: saHpiEventLogStateSet ** ** Description: ** This function enables system management software to set the event log ** enabled state. If the event log is "disabled" no events generated ** within the HPI implementation will be added to the event log. Events ** may still be added to the event log using the saHpiEventLogEntryAdd() ** function. When the event log is "enabled" events may be automatically ** added to the event log as they are generated in a resource or a ** domain. The actual set of events that are automatically added to any ** event log is implementation-specific. Typically, the HPI ** implementation will provide an appropriate default value for this ** parameter, which may vary by resource. This function is provided so ** that management software can override the default, if desired. Note: ** If a resource hosting an event log is re-initialized (e.g., because of ** a hot-swap action), the HPI implementation may reset the value of this ** parameter. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource that contains the system ** event log to be managed. Set to SAHPI_DOMAIN_CONTROLLER_ID to address ** the domain system event log. ** Enable - [in] SEL state to be set. True indicates that the SEL is to ** be enabled; false indicates that it is to be disabled. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventLogStateSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiBoolT Enable ); /******************************************************************************* ** ** Name: saHpiSubscribe ** ** Description: ** This function allows the caller to subscribe for session events. This ** single call provides subscription to all session events, regardless of ** event type or event severity. Only one subscription is allowed per ** session, and additional subscribers will receive an appropriate error ** code. No event filtering will be done by the underlying management ** service. ** ** Parameters: ** SessionId - [in] Session for which event subscription will be opened. ** ProvideActiveAlarms - [in] Indicates whether or not alarms which are ** active at the time of subscription should be queued for future ** retrieval via the saHpiEventGet() function. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. SA_ERR_HPI_DUPLICATE is returned when a subscription is ** already in place for this session. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSubscribe ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiBoolT ProvideActiveAlarms ); /******************************************************************************* ** ** Name: saHpiUnsubscribe ** ** Description: ** This function removes the event subscription for the session. After ** removal of a subscription, additional saHpiEventGet() calls will not ** be allowed unless the caller re-subscribes for events first. Any ** events that are still in the event queue when this function is called ** will be cleared from it. ** ** Parameters: ** SessionId - [in] Session for which event subscription will be closed. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. SA_ERR_HPI_INVALID_REQUEST is returned if the caller is ** not currently subscribed for events in this session. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiUnsubscribe ( SAHPI_IN SaHpiSessionIdT SessionId ); /******************************************************************************* ** ** Name: saHpiEventGet ** ** Description: ** This function allows the caller to get an event. This call is only ** valid within a session, which has subscribed for events. If the ** ProvideActiveAlarms parameter was set in the subscription, the first ** events retrieved will reflect the state of currently active alarms for ** the resources belonging to the domain. After all active alarms are ** retrieved this function will begin returning newly generated events as ** the domain controller receives them. If there are one or more events ** on the event queue when this function is called, it will immediately ** return the next event on the queue. Otherwise, if the Timeout ** parameter is SAHPI_TIMEOUT_IMMEDIATE, it will return ** SA_ERR_HPI_TIMEOUT immediately. Otherwise, it will block for a time ** specified by the timeout parameter; if an event is added to the queue ** within that time, it will be returned immediately; if not, ** saHpiEventGet() will return SA_ERR_HPI_TIMEOUT. If the Timeout ** parameter is SAHPI_TIMEOUT_BLOCK, then saHpiEventGet() will block ** indefinitely, until an event becomes available, and then return that ** event. This provides for notification of events as they occur. ** ** Parameters: ** SessionId - [in] Session for which events are retrieved. ** Timeout - [in] The number of nanoseconds to wait for an event to ** arrive. Reserved time out values: SAHPI_TIMEOUT_IMMEDIATE Time out ** immediately if there are no events available (non-blocking call). ** SAHPI_TIMEOUT_BLOCK Call should not return until an event is ** retrieved. ** Event - [out] Pointer to the next available event. ** Rdr - [in/out] Pointer to structure to receive the resource data ** associated with the event. If NULL, no RDR will be returned. ** RptEntry - [in/out] Pointer to structure to receive the RPT entry ** associated with the resource that generated the event. If NULL, no RPT ** entry will be returned. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. SA_ERR_HPI_TIMEOUT is returned if no event is available ** to return within the timeout period. If SAHPI_TIMEOUT_IMMEDIATE is ** passed in the Timeout parameter, this error return will be used if ** there is no event queued when the function is called. ** ** Remarks: ** If the caller provides a pointer for an RPT entry, but the event does ** not include a valid resource ID for a resource in the domain (possible ** on OEM or USER type event), then the ResourceCapabilities field in ** *RptEntry will be set to zero. No valid RPT entry will have a zero ** value here. If the caller provides a pointer for an RDR, but there is ** no valid RDR associated with the event being returned (e.g., returned ** event is not a sensor event), Rdr->RdrType will be set to ** SAHPI_NO_RECORD. The timestamp reported in the returned event ** structure is the best approximation an implementation has to when the ** event actually occurred. The implementation may need to make an ** approximation (such as the time the event was placed on the event ** queue) because it may not have access to the actual time the event ** occurred. The value SAHPI_TIME_UNSPECIFIED indicates that the time of ** the event cannot be determined. If the implementation cannot supply an ** absolute timestamp, then it may supply a timestamp relative to some ** system-defined epoch, such as system boot. If the timestamp value is ** less than or equal to SAHPI_TIME_MAX_RELATIVE, but not ** SAHPI_TIME_UNSPECIFIED, then it is relative; if it is greater than ** SAHPI_TIME_MAX_RELATIVE, then it is absolute. 6 Resource Functions ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEventGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiTimeoutT Timeout, SAHPI_OUT SaHpiEventT *Event, SAHPI_INOUT SaHpiRdrT *Rdr, SAHPI_INOUT SaHpiRptEntryT *RptEntry ); /******************************************************************************* ** ** Name: saHpiRdrGet ** ** Description: ** This function returns a resource data record from the addressed ** resource. Submitting an EntryId of SAHPI_FIRST_ENTRY results in the ** first RDR being read. A returned NextEntryID of SAHPI_LAST_ENTRY ** indicates the last RDR has been returned. A successful retrieval will ** include the next valid EntryId. To retrieve the entire list of RDRs, ** call this function first with an EntryId of SAHPI_FIRST_ENTRY and then ** use the returned NextEntryId in the next call. Proceed until the ** NextEntryId returned is SAHPI_LAST_ENTRY. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** EntryId - [in] Handle of the RDR to retrieve. Reserved entry ID ** values: SAHPI_FIRST_ENTRY Get first entry SAHPI_LAST_ENTRY Reserved as ** delimiter for end of list. Not a valid entry identifier. ** NextEntryId - [out] Pointer to location to store Entry ID of next ** entry in RDR repository. ** Rdr - [out] Pointer to the structure to receive the requested resource ** data record. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** A resource's RDR repository is static over the lifetime of the ** resource; therefore no precautions are required against changes to the ** content of the RDR repository while it is being accessed. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiRdrGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiEntryIdT EntryId, SAHPI_OUT SaHpiEntryIdT *NextEntryId, SAHPI_OUT SaHpiRdrT *Rdr ); /******************************************************************************* ** ** Name: saHpiSensorReadingGet ** ** Description: ** This function is used to retrieve a sensor reading. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** SensorNum - [in] Sensor number for which the sensor reading is being ** retrieved. ** Reading - [out] Pointer to a structure to receive sensor reading ** values. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSensorReadingGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSensorNumT SensorNum, SAHPI_OUT SaHpiSensorReadingT *Reading ); /******************************************************************************* ** ** Name: saHpiSensorReadingConvert ** ** Description: ** This function converts between raw and interpreted sensor reading ** values. The type of conversion done depends on the passed-in ** ReadingInput parameter. If it contains only a raw value, then this is ** converted to an interpreted value in ConvertedReading; if it contains ** only an interpreted value, then this is converted to a raw value in ** ConvertedReading. If it contains neither type of value, or both, then ** an error is returned. The ReadingInput parameter is not altered in any ** case. If the sensor does not use raw values - i.e., it directly ** returns interpreted values - then this routine returns an error. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** SensorNum - [in] Sensor number for which reading is associated. ** ReadingInput - [in] Pointer to the structure that contains raw or ** interpreted reading to be converted. ** ConvertedReading - [out] Pointer to structure to hold converted ** reading. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. SA_ERR_HPI_INVALID_PARAMS is returned if the ReadingInput ** parameter is invalid; e.g. if it contains neither a raw nor an ** interpreted value; or if it contains both; or if it contains an ** invalid value. SA_ERR_HPI_INVALID_DATA is returned if the sensor does ** not support raw readings. SA_ERR_HPI_NOT_PRESENT is returned if the ** sensor is not present. ** ** Remarks: ** The EventStatus field in ReadingInput is not used by this function. To ** make conversions, sensor-specific data may be required. Thus, the ** function references a particular sensor in the system through the ** SessionID/ResourceID/SensorNum parameters. If this sensor is not ** present, and sensor- specific information is required, the conversion ** will fail and SA_ERR_HPI_NOT_PRESENT will be returned. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSensorReadingConvert ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSensorNumT SensorNum, SAHPI_IN SaHpiSensorReadingT *ReadingInput, SAHPI_OUT SaHpiSensorReadingT *ConvertedReading ); /******************************************************************************* ** ** Name: saHpiSensorThresholdsGet ** ** Description: ** This function retrieves the thresholds for the given sensor. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** SensorNum - [in] Sensor number for which threshold values are being ** retrieved. ** SensorThresholds - [out] Pointer to returned sensor thresholds. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSensorThresholdsGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSensorNumT SensorNum, SAHPI_OUT SaHpiSensorThresholdsT *SensorThresholds ); /******************************************************************************* ** ** Name: saHpiSensorThresholdsSet ** ** Description: ** This function sets the specified thresholds for the given sensor. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of addressed resource. ** SensorNum - [in] Sensor number for which threshold values are being ** set. ** SensorThresholds - [in] Pointer to the sensor thresholds values being ** set. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** For each threshold or hysteresis value to be set, the corresponding ** sensor reading structure must indicate whether a raw or interpreted ** value is present. If neither are present, then that threshold or ** hysteresis value will not be set. Each sensor may require settings to ** be done with raw, or interpreted values, or may permit either; this is ** defined by the field ThresholdDefn.TholdCapabilities in the sensor's ** RDR (saHpiSensorRecT). If the interpreted value and raw value are both ** provided, and both are legal for the sensor, the interpreted value ** will be ignored and the raw value will be used. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSensorThresholdsSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSensorNumT SensorNum, SAHPI_IN SaHpiSensorThresholdsT *SensorThresholds ); /******************************************************************************* ** ** Name: saHpiSensorTypeGet ** ** Description: ** This function retrieves the sensor type and event category for the ** specified sensor. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** SensorNum - [in] Sensor number for which the type is being retrieved ** Type - [out] Pointer to returned enumerated sensor type for the ** specified sensor. ** Category - [out] Pointer to location to receive the returned sensor ** event category. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSensorTypeGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSensorNumT SensorNum, SAHPI_OUT SaHpiSensorTypeT *Type, SAHPI_OUT SaHpiEventCategoryT *Category ); /******************************************************************************* ** ** Name: saHpiSensorEventEnablesGet ** ** Description: ** This function provides the ability to get the disable or enable event ** message generation status for individual sensor events. The sensor ** event states are relative to the event category specified by the ** sensor. See the SaHpiEventCategoryT definition in section 7.3, ** "Events, Part 1," on page 83 for more information. Within the ** structure returned, there are two elements that contain bit flags; one ** for assertion events and one for de-assertion events. A bit set to '1' ** in the "AssertEvents" element in the structure indicates that an event ** will be generated when the corresponding event state changes from ** de-asserted to asserted on that sensor. A bit set to '1' in the ** "DeassertEvents" element in the structure indicates that an event will ** be generated when the corresponding event state changes from asserted ** to de-asserted on that sensor. The saHpiSensorEventEnablesGet() ** function also returns the general sensor status - whether the sensor ** is completely disabled, or event generation is completely disabled. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** SensorNum - [in] Sensor number for which the event enable ** configuration is being requested ** Enables - [out] Pointer to the structure for returning sensor status ** and event enable information. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Disabling events means that events are disabled for all sessions, not ** just the session referenced by the SessionId parameter. For sensors ** hosted by resources that have the "SAHPI_CAPABILITY_EVT_DEASSERTS" ** flag set in its RPT entry, the "AssertEvents" element and the ** "DeassertsEvents" element will always have same value. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSensorEventEnablesGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSensorNumT SensorNum, SAHPI_OUT SaHpiSensorEvtEnablesT *Enables ); /******************************************************************************* ** ** Name: saHpiSensorEventEnablesSet ** ** Description: ** This function provides the ability to set the disable or enable event ** message generation status for individual sensor events. The sensor ** event states are relative to the event category specified by the ** sensor. See the SaHpiEventCategoryT definition for more information. ** Within the structure passed, there are two elements, which contain bit ** flags; one for assertion events and one for de-assertion events. ** However, the use of these two elements depends on whether the resource ** addressed has the "SAHPI_CAPABILITY_EVT_DEASSERTS" flag set in its RPT ** entry. This capability, if set, advertises that all sensors hosted by ** the resource will always send a "de-assert" event when any state is ** de-asserted whose assertion generates an "assert" event. Thus, for ** sensors hosted by resources that advertise this behavior, it is not ** meaningful to control assert events and de-assert events separately. ** For sensors on resources that do not have the ** "SAHPI_CAPABILITY_EVT_DEASSERTS" flag set, a bit set to '1' in the ** "AssertEvents" element in the structure indicates that an event will ** be generated when the corresponding event state changes from ** de-asserted to asserted on that sensor., and a bit set to '1' in the ** "DeassertEvents" element in the structure indicates that an event will ** be generated when the corresponding event state changes from asserted ** to de-asserted on that sensor. For sensors on resources, which do have ** the "SAHPI_CAPABILITY_EVT_DEASSERTS" flag set, the "DeassertEvents" ** element is not used. For sensors on these resources, a bit set to '1' ** in the "AssertEvents" element in the structure indicates that an event ** will be generated when the corresponding event state changes in either ** direction (de-asserted to asserted or asserted to de-asserted). The ** saHpiSensorEventEnablesSet() function also allows setting of general ** sensor status - whether the sensor is completely disabled, or event ** generation is completely disabled. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** SensorNum - [in] Sensor number for which the event enables are being ** set. ** Enables - [in] Pointer to the structure containing the enabled status ** for each event. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Disabling events means that events are disabled for all sessions, not ** just the session referenced by the SessionId parameter. ** saHpiSensorEventEnablesGet () will return the values which were last ** set by saHpiSensorEventEnablesSet() for the "AssertEvents" and ** "DeassertEvents" elements in the passed data structures. However, for ** sensors hosted by any resource that has the ** SAHPI_CAPABILITY_EVT_DEASSERTS flag set in its RPT entry, the passed ** "AssertEvents" element on the saHpiSensorEventEnablesSet () function ** is used for both assertion and de-assertion event enable flags. In ** this case, this value will be returned in both the "AssertEvents" and ** "DeassertEvents" elements on a subsequent saHpiSensorEventEnablesGet ** () call. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiSensorEventEnablesSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiSensorNumT SensorNum, SAHPI_IN SaHpiSensorEvtEnablesT *Enables ); /******************************************************************************* ** ** Name: saHpiControlTypeGet ** ** Description: ** This function retrieves the control type of a control object. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** CtrlNum - [in] Control number ** Type - [out] Pointer to SaHpiCtrlTypeT variable to receive the ** enumerated control type for the specified control. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** The Type parameter must point to a variable of type SaHpiCtrlTypeT. ** Upon successful completion, the enumerated control type is returned in ** the variable pointed to by Type. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiControlTypeGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiCtrlNumT CtrlNum, SAHPI_OUT SaHpiCtrlTypeT *Type ); /******************************************************************************* ** ** Name: saHpiControlStateGet ** ** Description: ** This function retrieves the current state (generally the last state ** set) of a control object. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of addressed resource. ** CtrlNum - [in] Number of the control for which the state is being ** retrieved. ** CtrlState - [in/out] Pointer to a control data structure into which ** the current control state will be placed. For text controls, the line ** number to read is passed in via CtrlState->StateUnion.Text.Line. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Note that Text controls are unique in that they have a state ** associated with each line of the control - the state being the text on ** that line. The line number to be read is passed in to ** sahpiControlStateGet()via CtrlState- >StateUnion.Text.Line; the ** contents of that line of the control will be returned in CtrlState- ** >StateUnion.Text.Text. If the line number passed in is ** SAHPI_TLN_ALL_LINES, then sahpiControlStateGet() will return the ** entire text of the control, or as much of it as will fit in a single ** SaHpiTextBufferT, in CtrlState- >StateUnion.Text.Text. This value will ** consist of the text of all the lines concatenated, using the maximum ** number of characters for each line (no trimming of trailing blanks). ** Note that depending on the data type and language, the text may be ** encoded in 2-byte Unicode, which requires two bytes of data per ** character. Note that the number of lines and columns in a text control ** can be obtained from the control's Resource Data Record. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiControlStateGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiCtrlNumT CtrlNum, SAHPI_INOUT SaHpiCtrlStateT *CtrlState ); /******************************************************************************* ** ** Name: saHpiControlStateSet ** ** Description: ** This function is used for setting the state of the specified control ** object. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** CtrlNum - [in] Number of the control for which the state is being set. ** ** CtrlState - [in] Pointer to a control state data structure holding the ** state to be set ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** The CtrlState parameter must be of the correct type for the specified ** control. Text controls include a line number and a line of text in the ** CtrlState parameter, allowing update of just a single line of a text ** control. If less than a full line of data is written, the control will ** clear all spaces beyond those written on the line. Thus writing a ** zero-length string will clear the addressed line. It is also possible ** to include more characters in the text passed in the CtrlState ** structure than will fit on one line; in this case, the control will ** "wrap" to the next line (still clearing the trailing characters on the ** last line written). Thus, there are two ways to write multiple lines ** to a text control: (a) call saHpiControlStateSet() repeatedly for each ** line, or (b) call saHpiControlStateSet() once and send more characters ** than will fit on one line. The caller should not assume any "cursor ** positioning" characters are available to use, but rather should always ** write full lines and allow "wrapping" to occur. When calling ** saHpiControlStateSet() for a text control, the caller may set the line ** number to SAHPI_TLN_ALL_LINES; in this case, the entire control will ** be cleared, and the data will be written starting on line 0. (This is ** different from simply writing at line 0, which only alters the lines ** written to.) This feature may be used to clear the entire control, ** which can be accomplished by setting: CtrlState->StateUnion.Text.Line ** = SAHPI_TLN_ALL_LINES; CtrlState->StateUnion.Text.Text.DataLength = 0; ** Note that the number of lines and columns in a text control can be ** obtained from the control's Resource Data Record. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiControlStateSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiCtrlNumT CtrlNum, SAHPI_IN SaHpiCtrlStateT *CtrlState ); /******************************************************************************* ** ** Name: saHpiEntityInventoryDataRead ** ** Description: ** This function returns inventory data for a particular entity ** associated with a resource. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** EirId - [in] Identifier for the entity inventory repository. ** BufferSize - [in] Size of the InventData buffer passed in. ** InventData - [out] Pointer to the buffer for the returned data. ** ActualSize - [out] Pointer to size of the actual amount of data ** returned. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. SA_ERR_INVENT_DATA_TRUNCATED is returned if the buffer ** passed in the InventData structure is not large enough (as indicated ** by the "BufferSize" parameter) to hold the entire InventData ** structure. ** ** Remarks: ** Before calling saHpiEntityInventoryDataRead() the caller should ** allocate a sufficiently large buffer to hold the data, and pass the ** size of the buffer in the "BufferSize" parameter. The ** saHpiEntityInventoryDataRead() function will return, at the location ** pointed to by the ActualSize parameter, the actual space used in the ** buffer to hold the returned data. If the data will not fit in the ** buffer, as much as will fit will be returned, *ActualSize will be set ** to indicated a suggested buffer size for the entire inventory data, ** the "Validity" field in the InventData buffer will be set to ** "SAHPI_INVENT_DATA_OVERFLOW," and an error return will be made. Since ** it is impossible to know how large the inventory data may be without ** actually reading and processing it from the entity inventory ** repository, it may be advisable to err on the large side in allocating ** the buffer. Note that the data includes many pointers to ** SaHpiTextBufferT structures. The implementation of ** saHpiEntityInventoryDataRead() may not reserve space for the maximum ** size of each of these structures when formatting the data in the ** returned buffer. Thus, if a user wishes to lengthen the data in one of ** these structures, a new SaHpiTextBufferT structure should be ** allocated, and the appropriate pointer reset to point to this new ** structure in memory. See the description of the SaHpiInventoryDataT ** structure in section 7.9, "Entity Inventory Data," on page 94, for ** details on the format of the returned data. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEntityInventoryDataRead ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiEirIdT EirId, SAHPI_IN SaHpiUint32T BufferSize, SAHPI_OUT SaHpiInventoryDataT *InventData, SAHPI_OUT SaHpiUint32T *ActualSize ); /******************************************************************************* ** ** Name: saHpiEntityInventoryDataWrite ** ** Description: ** This function writes the specified data to the inventory information ** area. Note: If the resource hosting the inventory data is ** re-initialized, or if the entity itself is removed and reinserted, the ** inventory data may be reset to its default settings, losing data ** written to the repository with this function. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** EirId - [in] Identifier for the entity inventory repository. ** InventData - [in] Pointer to data to write to the repository. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** The SaHpiInventoryDataT structure consists of a Validity field and ** then a set of pointers to record structures. It is not required that ** all pointers point to data within a single contiguous buffer. The ** "Validity" field in the SaHpiInventoryDataT structure must be set to ** "SAHPI_INVENT_DATA_VALID," or else the saHpiEntityInventoryDataWrite() ** function will take no action and return an error. This is to help ** prevent invalid data returned by a saHpiEntityInventoryDataRead() ** function from being inadvertently written to the resource. For this ** protection to work, the caller should not change the value of the ** "Validity" field in the SaHpiInventoryDataT structure unless building ** an entire Inventory Data set from scratch. Some implementations may ** impose limitations on the languages of the strings passed in within ** the InventData parameter. Implementation-specific documentation ** should identify these restrictions. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiEntityInventoryDataWrite ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiEirIdT EirId, SAHPI_IN SaHpiInventoryDataT *InventData ); /******************************************************************************* ** ** Name: saHpiWatchdogTimerGet ** ** Description: ** This function retrieves the current watchdog timer settings and ** configuration. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource, which contains the ** watchdog timer being addressed. ** WatchdogNum - [in] The watchdog number that specifies the watchdog ** timer on a resource. ** Watchdog - [out] Pointer to watchdog data structure. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** See the description of the SaHpiWatchdogT structure in 7.11, ** "Watchdogs" on page 96 for details on what information is returned by ** this function. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiWatchdogTimerGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiWatchdogNumT WatchdogNum, SAHPI_OUT SaHpiWatchdogT *Watchdog ); /******************************************************************************* ** ** Name: saHpiWatchdogTimerSet ** ** Description: ** This function provides a method for initializing the watchdog timer ** configuration. Once the appropriate configuration has be set using ** saHpiWatchdogTimerSet(), the user must then call ** saHpiWatchdogTimerReset() to initially start the watchdog timer. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the resource that contains the ** watchdog timer being addressed. ** WatchdogNum - [in] The watchdog number specifying the specific ** watchdog timer on a resource. ** Watchdog - [in] Pointer to watchdog data structure. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** If the initial counter value in the SaHpiWatchdogT structure is set to ** 0, the Watchdog will immediately time out and take the pre-timeout and ** timeout actions, as well as log an event. This provides a mechanism ** for software to force an immediate recovery action should that be ** dependent on a Watchdog timeout occurring. See the description of the ** SaHpiWatchdogT structure for more details on the effects of this ** command related to specific data passed in that structure. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiWatchdogTimerSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiWatchdogNumT WatchdogNum, SAHPI_IN SaHpiWatchdogT *Watchdog ); /******************************************************************************* ** ** Name: saHpiWatchdogTimerReset ** ** Description: ** This function provides a method to start or restart the watchdog timer ** from the initial countdown value. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID for the resource that contains the ** watchdog timer being addressed. ** WatchdogNum - [in] The watchdog number specifying the specific ** watchdog timer on a resource. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** If the Watchdog has been configured to issue a Pre-Timeout interrupt, ** and that interrupt has already occurred, the saHpiWatchdogTimerReset() ** function will not reset the watchdog counter. The only way to stop a ** Watchdog from timing out once a Pre-Timeout interrupt has occurred is ** to use the saHpiWatchdogTimerSet() function to reset and/or stop the ** timer. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiWatchdogTimerReset ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiWatchdogNumT WatchdogNum ); /******************************************************************************* ** ** Name: saHpiHotSwapControlRequest ** ** Description: ** A resource supporting hot swap typically supports default policies for ** insertion and extraction. On insertion, the default policy may be for ** the resource to turn the associated FRU's local power on and to ** de-assert reset. On extraction, the default policy may be for the ** resource to immediately power off the FRU and turn on a hot swap ** indicator. This function allows a caller, after receiving a hot swap ** event with HotSwapState equal to SAHPI_HS_STATE_INSERTION_PENDING or ** SAHPI_HS_STATE_EXTRACTION_PENDING, to request control of the hot swap ** policy and prevent the default policy from being invoked. Because a ** resource that supports the simplified hot swap model will never ** transition into Insertion Pending or Extraction Pending states, this ** function is not applicable to those resources. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiHotSwapControlRequest ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId ); /******************************************************************************* ** ** Name: saHpiResourceActiveSet ** ** Description: ** During insertion, a resource supporting hot swap will generate an ** event to indicate that it is in the INSERTION PENDING state. If the ** management middleware or other user software calls ** saHpiHotSwapControlRequest() before the resource begins an auto-insert ** operation, then the resource will remain in INSERTION PENDING state ** while the user acts on the resource to integrate it into the system. ** During this state, the user can instruct the resource to power on the ** associated FRU, to de-assert reset, or to turn off its hot swap ** indicator using the saHpiResourcePowerStateSet(), ** saHpiResourceResetStateSet(), or saHpiHotSwapIndicatorStateSet() ** functions, respectively. Once the user has completed with the ** integration of the FRU, this function must be called to signal that ** the resource should now transition into ACTIVE/HEALTHY or ** ACTIVE/UNHEALTHY state (depending on whether or not there are active ** faults). The user may also use this function to request a resource to ** return to the ACTIVE/HEALTHY or ACTIVE/UNHEALTHY state from the ** EXTRACTION PENDING state in order to reject an extraction request. ** Because a resource that supports the simplified hot swap model will ** never transition into Insertion Pending or Extraction Pending states, ** this function is not applicable to those resources. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Only valid if resource is in INSERTION PENDING or EXTRACTION PENDING ** state and an auto-insert or auto-extract policy action has not been ** initiated. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourceActiveSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId ); /******************************************************************************* ** ** Name: saHpiResourceInactiveSet ** ** Description: ** During extraction, a resource supporting hot swap will generate an ** event to indicate that it is in the EXTRACTION PENDING state. If the ** management middleware or other user software calls ** saHpiHotSwapControlRequest() before the resource begins an ** auto-extract operation, then the resource will remain in EXTRACTION ** PENDING state while the user acts on the resource to isolate the ** associated FRU from the system. During this state, the user can ** instruct the resource to power off the FRU, to assert reset, or to ** turn on its hot swap indicator using the saHpiResourcePowerStateSet(), ** saHpiResourceResetStateSet(), or saHpiHotSwapIndicatorStateSet() ** functions, respectively. Once the user has completed the shutdown of ** the FRU, this function must be called to signal that the resource ** should now transition into INACTIVE state. The user may also use this ** function to request a resource to return to the INACTIVE state from ** the INSERTION PENDING state to abort a hot-swap insertion action. ** Because a resource that supports the simplified hot swap model will ** never transition into Insertion Pending or Extraction Pending states, ** this function is not applicable to those resources. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Only valid if resource is in EXTRACTION PENDING or INSERTION PENDING ** state and an auto-extract or auto-insert policy action has not been ** initiated. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourceInactiveSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId ); /******************************************************************************* ** ** Name: saHpiAutoInsertTimeoutGet ** ** Description: ** This function allows the caller to request the auto-insert timeout ** value. This value indicates how long the HPI implementation will wait ** before the default auto-insertion policy is invoked. Further ** information on the auto-insert timeout can be found in the function ** saHpiAutoInsertTimeoutSet(). ** ** Parameters: ** SessionId - [in] Handle to session context. ** Timeout - [out] Pointer to location to store the number of nanoseconds ** to wait before autonomous handling of the hotswap event. Reserved time ** out values: SAHPI_TIMEOUT_IMMEDIATE indicates autonomous handling is ** immediate. SAHPI_TIMEOUT_BLOCK indicates autonomous handling does not ** occur. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiAutoInsertTimeoutGet( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_OUT SaHpiTimeoutT *Timeout ); /******************************************************************************* ** ** Name: saHpiAutoInsertTimeoutSet ** ** Description: ** This function allows the caller to configure a timeout for how long to ** wait before the default auto-insertion policy is invoked. This ** function accepts a parameter instructing the implementation to impose ** a delay before a resource will perform its default hot swap policy for ** auto-insertion. The parameter may be set to SAHPI_TIMEOUT_IMMEDIATE to ** direct resources to proceed immediately to auto-insertion, or to ** SAHPI_TIMEOUT_BLOCK to prevent auto-insertion from ever occurring. If ** the parameter is set to another value, then it defines the number of ** nanoseconds between the time a hot swap event with HotSwapState = ** SAHPI_HS_STATE_INSERTION_PENDING is generated, and the time that the ** auto-insertion policy will be invoked for that resource. If, during ** this time period, a saHpiHotSwapControlRequest() function is ** processed, the timer will be stopped, and the auto-insertion policy ** will not be invoked. Once the auto-insertion process begins, the user ** software will not be allowed to take control of the insertion process; ** hence, the timeout should be set appropriately to allow for this ** condition. Note that the timeout period begins when the hot swap event ** with HotSwapState = SAHPI_HS_STATE_INSERTION_PENDING is initially ** generated; not when it is received by a caller with a saHpiEventGet() ** function call, or even when it is placed in a session event queue. ** ** Parameters: ** SessionId - [in] Handle to session context. ** Timeout - [in] The number of nanoseconds to wait before autonomous ** handling of the hotswap event. Reserved time out values: ** SAHPI_TIMEOUT_IMMEDIATE indicates proceed immediately to autonomous ** handling. SAHPI_TIMEOUT_BLOCK indicates prevent autonomous handling. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiAutoInsertTimeoutSet( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiTimeoutT Timeout ); /******************************************************************************* ** ** Name: saHpiAutoExtractTimeoutGet ** ** Description: ** This function allows the caller to request the timeout for how long ** the implementation will wait before the default auto-extraction policy ** is invoked. Further information on auto-extract time outs is detailed ** in saHpiAutoExtractTimeoutSet(). ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** Timeout - [out] Pointer to location to store the number of nanoseconds ** to wait before autonomous handling of the hotswap event. Reserved time ** out values: SAHPI_TIMEOUT_IMMEDIATE indicates autonomous handling is ** immediate. SAHPI_TIMEOUT_BLOCK indicates autonomous handling does not ** occur. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiAutoExtractTimeoutGet( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_OUT SaHpiTimeoutT *Timeout ); /******************************************************************************* ** ** Name: saHpiAutoExtractTimeoutSet ** ** Description: ** This function allows the caller to configure a timeout for how long to ** wait before the default auto-extraction policy is invoked. This ** function accepts a parameter instructing the implementation to impose ** a delay before a resource will perform its default hot swap policy for ** auto-extraction. The parameter may be set to SAHPI_TIMEOUT_IMMEDIATE ** to direct the resource to proceed immediately to auto-extraction, or ** to SAHPI_TIMEOUT_BLOCK to prevent auto-extraction from ever occurring ** on a resource. If the parameter is set to another value, then it ** defines the number of nanoseconds between the time a hot swap event ** with HotSwapState = SAHPI_HS_STATE_EXTRACTION_PENDING is generated, ** and the time that the auto- extraction policy will be invoked for the ** resource. If, during this time period, a saHpiHotSwapControlRequest() ** function is processed, the timer will be stopped, and the ** auto-extraction policy will not be invoked. Once the auto-extraction ** process begins, the user software will not be allowed to take control ** of the extraction process; hence, the timeout should be set ** appropriately to allow for this condition. Note that the timeout ** period begins when the hot swap event with HotSwapState = ** SAHPI_HS_STATE_EXTRACTION_PENDING is initially generated; not when it ** is received by a caller with a saHpiEventGet() function call, or even ** when it is placed in a session event queue. The auto-extraction policy ** is set at the resource level and is only supported by resources ** supporting the "Managed Hot Swap" capability. After discovering that a ** newly inserted resource supports "Managed Hot Swap," middleware or ** other user software may use this function to change the default ** auto-extraction policy for that resource. If a resource supports the ** simplified hot-swap model, setting this timer has no effect since the ** resource will transition directly to "Not Present" state on an ** extraction. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** Timeout - [in] The number of nanoseconds to wait before autonomous ** handling of the hotswap event. Reserved time out values: ** SAHPI_TIMEOUT_IMMEDIATE indicates proceed immediately to autonomous ** handling. SAHPI_TIMEOUT_BLOCK indicates prevent autonomous handling. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiAutoExtractTimeoutSet( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiTimeoutT Timeout ); /******************************************************************************* ** ** Name: saHpiHotSwapStateGet ** ** Description: ** This function allows the caller to retrieve the current hot swap state ** of a resource. The returned state will be one of the following five ** states: ? SAHPI_HS_STATE_INSERTION_PENDING ? ** SAHPI_HS_STATE_ACTIVE_HEALTHY ? SAHPI_HS_STATE_ACTIVE_UNHEALTHY ? ** SAHPI_HS_STATE_EXTRACTION_PENDING ? SAHPI_HS_STATE_INACTIVE The state ** SAHPI_HS_STATE_NOT_PRESENT will never be returned, because a resource ** that is not present cannot be addressed by this function in the first ** place. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** State - [out] Pointer to location to store returned state information. ** ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** None. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiHotSwapStateGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_OUT SaHpiHsStateT *State ); /******************************************************************************* ** ** Name: saHpiHotSwapActionRequest ** ** Description: ** A resource supporting hot swap typically requires a physical action on ** the associated FRU to invoke an insertion or extraction process. An ** insertion process is invoked by physically inserting the FRU into a ** chassis. Physically opening an ejector latch or pressing a button ** invokes the extraction process. This function allows the caller to ** invoke an insertion or extraction process via software. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** Action - [in] Requested action: SAHPI_HS_ACTION_INSERTION or ** SAHPI_HS_ACTION_EXTRACTION ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** There may be limitations on when saHpiHotSwapActionRequest() may be ** called, and what value may be used for the "Action" parameter ** depending on what state the resource is currently in. At the least, ** this function may be called: ? To request an Insertion action when the ** resource is in INACTIVE state ? To request an Extraction action when ** the resource is in the ACTIVE/HEALTHY or ACTIVE/ UNHEALTHY state. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiHotSwapActionRequest ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiHsActionT Action ); /******************************************************************************* ** ** Name: saHpiResourcePowerStateGet ** ** Description: ** A typical resource supporting hot swap will have the ability to ** control local power on the FRU associated with the resource. During ** insertion, the FRU can be instructed to power on. During extraction ** the FRU can be requested to power off. This function allows the caller ** to retrieve the current power state of the FRU associated with the ** specified resource. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** State - [out] The current power state of the resource. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** This function returns the actual low-level power state of the FRU, ** regardless of what hot-swap state the resource is in. Not all ** resources supporting managed hot swap will necessarily support this ** function. In particular, resources that use the simplified hot swap ** model may not have the ability to control FRU power. An appropriate ** error code will be returned if the resource does not support power ** control on the FRU. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourcePowerStateGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_OUT SaHpiHsPowerStateT *State ); /******************************************************************************* ** ** Name: saHpiResourcePowerStateSet ** ** Description: ** A typical resource supporting hot swap will have to ability to control ** local power on the FRU associated with the resource. During insertion, ** the FRU can be instructed to power on. During extraction the FRU can ** be requested to power off. This function allows the caller to set the ** current power state of the FRU associated with the specified resource. ** ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** State - [in] the new power state that the specified resource will be ** set to. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** This function controls the hardware power on the FRU of what hot-swap ** state the resource is in. For example, it is legal (and may be ** desirable) to cycle power on the FRU even while it is in ACTIVE state ** in order to attempt to clear a fault condition. Similarly, a resource ** could be instructed to power on a FRU even while it is in INACTIVE ** state, for example, in order to run off-line diagnostics. Not all ** resources supporting managed hot swap will necessarily support this ** function. In particular, resources that use the simplified hot swap ** model may not have the ability to control FRU power. An appropriate ** error code will be returned if the resource does not support power ** control on the FRU. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourcePowerStateSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiHsPowerStateT State ); /******************************************************************************* ** ** Name: saHpiHotSwapIndicatorStateGet ** ** Description: ** A FRU associated with a hot-swappable resource may include a hot swap ** indicator such as a blue LED. This indicator signifies that the FRU is ** ready for removal.. This function allows the caller to retrieve the ** state of this indicator. The returned state is either ** SAHPI_HS_INDICATOR_OFF or SAHPI_HS_INDICATOR_ON. This function will ** return the state of the indicator, regardless of what hot swap state ** the resource is in. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** State - [out] Pointer to location to store state of hot swap ** indicator. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Not all resources supporting managed hot swap will necessarily support ** this function. In particular, resources that use the simplified hot ** swap model may not have the ability to control a FRU hot swap ** indicator (it is likely that none exists). An appropriate error code ** will be returned if the resource does not support control of a hot ** swap indicator on the FRU. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiHotSwapIndicatorStateGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_OUT SaHpiHsIndicatorStateT *State ); /******************************************************************************* ** ** Name: saHpiHotSwapIndicatorStateSet ** ** Description: ** A FRU associated with a hot-swappable resource may include a hot swap ** indicator such as a blue LED. This indicator signifies that the FRU is ** ready for removal. This function allows the caller to set the state of ** this indicator. Valid states include SAHPI_HS_INDICATOR_OFF or ** SAHPI_HS_INDICATOR_ON. This function will set the indicator regardless ** of what hot swap state the resource is in, though it is recommended ** that this function be used only in conjunction with moving the ** resource to the appropriate hot swap state. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource ** State - [in] State of hot swap indicator to be set. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Not all resources supporting managed hot swap will necessarily support ** this function. In particular, resources that use the simplified hot ** swap model may not have the ability to control a FRU hot swap ** indicator (it is likely that none exists). An appropriate error code ** will be returned if the resource does not support control of a hot ** swap indicator on the FRU. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiHotSwapIndicatorStateSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiHsIndicatorStateT State ); /******************************************************************************* ** ** Name: saHpiParmControl ** ** Description: ** This function allows the user to save and restore parameters ** associated with a specific resource. Valid actions for this function ** include: SAHPI_DEFAULT_PARM Restores the factory default settings for ** a specific resource. Factory defaults include sensor thresholds and ** configurations, and resource- specific configuration parameters. ** SAHPI_SAVE_PARM Stores the resource configuration parameters in ** non-volatile storage. Resource configuration parameters stored in ** non-volatile storage will survive power cycles and resource resets. ** SAHPI_RESTORE_PARM Restores resource configuration parameters from ** non-volatile storage. Resource configuration parameters include sensor ** thresholds and sensor configurations, as well as resource-specific ** parameters. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** Action - [in] Action to perform on resource parameters. ** ** Return Value: ** SA_OK is returned on successful completion; otherwise, an error code ** is returned. ** ** Remarks: ** Resource-specific parameters should be documented in an implementation ** guide for the HPI implementation. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiParmControl ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiParmActionT Action ); /******************************************************************************* ** ** Name: saHpiResourceResetStateGet ** ** Description: ** This function gets the reset state of an entity, allowing the user to ** determine if the entity is being held with its reset asserted. If a ** resource manages multiple entities, this function will address the ** entity which is identified in the RPT entry for the resource. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** ResetAction - [out] The current reset state of the entity. Valid reset ** states are: SAHPI_RESET_ASSERT: The entity's reset is asserted, e.g., ** for hot swap insertion/extraction purposes SAHPI_RESET_DEASSERT: The ** entity's reset is not asserted ** ** Return Value: ** SA_OK is returned if the resource has reset control, and the reset ** state has successfully been determined; otherwise, an error code is ** returned. SA_ERR_HPI_INVALID_CMD is returned if the resource has no ** reset control. ** ** Remarks: ** SAHPI_RESET_COLD and SAHPI_RESET_WARM are pulsed resets, and are not ** valid return values for ResetAction. If the entity is not being held ** in reset (using SAHPI_RESET_ASSERT), the appropriate return value is ** SAHPI_RESET_DEASSERT. ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourceResetStateGet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_OUT SaHpiResetActionT *ResetAction ); /******************************************************************************* ** ** Name: saHpiResourceResetStateSet ** ** Description: ** This function directs the resource to perform the specified reset type ** on the entity that it manages. If a resource manages multiple ** entities, this function addresses the entity that is identified in the ** RPT entry for the resource. Entities may be reset for a variety of ** reasons. A misbehaving entity may be reset to bring it to a known ** state. In these cases, either a warm reset or a cold reset may be ** performed. A warm reset preserves entity state, whereas a cold reset ** does not. Both of these reset types are pulsed asserted and then ** de-asserted by the HPI implementation. This allows the HPI ** implementation to hold the reset asserted for the appropriate length ** of time, as needed by each entity. saHpiResourceResetStateSet() can ** also be used for insertion and extraction scenarios. A typical ** resource supporting hot swap will have to ability to control local ** reset within the FRU. During insertion, a resource can be instructed ** to assert reset, while the FRU powers on. During extraction a resource ** can be requested to assert reset before the FRU is powered off. This ** function allows the caller to set the reset state of the specified ** FRU. SAHPI_RESET_ASSERT is used to hold the resource in reset; the FRU ** is brought out of the reset state by using either SAHPI_COLD_RESET or ** SAHPI_WARM_RESET. ** ** Parameters: ** SessionId - [in] Handle to session context. ** ResourceId - [in] Resource ID of the addressed resource. ** ResetAction - [in] Type of reset to perform on the entity. Valid reset ** actions are: SAHPI_COLD_RESET: Perform a 'Cold Reset' on the entity ** (pulse), leaving reset de-asserted SAHPI_WARM_RESET: Perform a 'Warm ** Reset' on the entity (pulse), leaving reset de-asserted ** SAHPI_RESET_ASSERT: Put the entity into reset state and hold reset ** asserted, e.g., for hot swap insertion/extraction purposes ** ** Return Value: ** SA_OK is returned if the resource has reset control, and the requested ** reset action has succeeded; otherwise, an error code is returned. ** SA_ERR_HPI_INVALID_CMD is returned if the resource has no reset ** control, or if the requested reset action is not supported by the ** resource. ** ** Remarks: ** Some resources may not support reset, or may only support a subset of ** the defined reset action types. Also, on some resources, cold and warm ** resets may be equivalent. 7 Data Type Definitions ** *******************************************************************************/ SaErrorT SAHPI_API saHpiResourceResetStateSet ( SAHPI_IN SaHpiSessionIdT SessionId, SAHPI_IN SaHpiResourceIdT ResourceId, SAHPI_IN SaHpiResetActionT ResetAction ); #endif