summaryrefslogtreecommitdiff
path: root/hpiutil/SaHpi.h-B
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-07-06 18:04:32 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-07-06 18:04:32 +0200
commita7f89980e5b3f4b9a74c70dbc5ffe8aabd28be28 (patch)
tree41c4deec1fdfbafd7821b4ca7a9772ac0abd92f5 /hpiutil/SaHpi.h-B
Imported Upstream version 2.9.3upstream/2.9.3
Diffstat (limited to 'hpiutil/SaHpi.h-B')
-rw-r--r--hpiutil/SaHpi.h-B6785
1 files changed, 6785 insertions, 0 deletions
diff --git a/hpiutil/SaHpi.h-B b/hpiutil/SaHpi.h-B
new file mode 100644
index 0000000..38d666b
--- /dev/null
+++ b/hpiutil/SaHpi.h-B
@@ -0,0 +1,6785 @@
+/*******************************************************************************
+**
+** 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-B.01.01
+**
+** DATE:
+** Tue Jun 1 2004 09:33
+**
+** 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) 2004, 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 */
+
+/*
+** It is recommended that these types be defined such that the data sizes
+** and alignment of each data type are as indicated. The only requirement
+** for source compatibility is that the types be defined to be able to
+** contain at least the required data (e.g., at least signed 8-bit values
+** must be contained in the data type defined as SaHpiInt8T, etc.)
+** Following the full recommendations for data size and alignment, however,
+** may promote more binary compatibility.
+*/
+
+/* The following definitions produce the recommended sizes and alignments
+** using the gcc compiler for the i386 (IA-32) platform.
+**
+** Note, some recent versions of the gcc compiler exhibit an apparent bug
+** that makes the __attribute__ statements applied to the typdef's on
+** the 64-bit types below ineffective when those types are used in structures.
+** To workaround that bug, it may be required to add similar __attribute__
+** statements on the typedefs of the derived types SaHpiTimeT and
+** SaHpiTimeoutT, plus on individual 64-bit data items within structure and
+** union definitions in order to align the HPI structures as recommended.
+** The structures and unions that contain 64-bit data items are:
+** SaHpiSensorReadingUnionT, SaHpiSensorDataFormatT, SaHpiEventT,
+** SaHpiAnnouncementT, SaHpiDomainInfoT, SaHpiAlarmT, SaHpiEventLogInfoT,
+** and SaHpiEventLogEntryT. For more information, see:
+** https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=109911
+*/
+
+
+/* unsigned 8-bit data, 1-byte alignment */
+typedef unsigned char SaHpiUint8T;
+
+/* unsigned 16-bit data, 2-byte alignment */
+typedef unsigned short SaHpiUint16T;
+
+/* unsigned 32-bit data, 4-byte alignment */
+typedef unsigned int SaHpiUint32T;
+
+/* unsigned 64-bit data, 8-byte alignment */
+typedef unsigned long long int SaHpiUint64T __attribute__((__aligned__(8)));
+
+/* signed 8-bit data, 1-byte alignment */
+typedef signed char SaHpiInt8T;
+
+/* signed 16-bit data, 2-byte alignment */
+typedef signed short SaHpiInt16T;
+
+/* signed 32-bit data, 4-byte alignment */
+typedef signed int SaHpiInt32T;
+
+/* signed 64-bit data, 8-byte alignment */
+typedef signed long long int SaHpiInt64T __attribute__((__aligned__(8)));
+
+/* 64-bit floating point, 8-byte alignment */
+typedef double SaHpiFloat64T __attribute__((__aligned__(8)));
+
+
+typedef SaHpiUint8T SaHpiBoolT;
+#define SAHPI_TRUE 1 /* While SAHPI_TRUE = 1, any non-zero
+ value is also considered to be True
+ and HPI Users/Implementers of this
+ specification should not test for
+ equality against SAHPI_TRUE. */
+
+#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)0x020101 /* B.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. Each of the return codes
+** is defined in Section 4.1 of the specification.
+*/
+typedef SaHpiInt32T SaErrorT; /* Return code */
+
+/*
+** SA_OK:
+*/
+#define SA_OK (SaErrorT)0x0000
+
+/* This value is the base for all HPI-specific error codes. */
+#define SA_HPI_ERR_BASE -1000
+
+#define SA_ERR_HPI_ERROR (SaErrorT)(SA_HPI_ERR_BASE - 1)
+#define SA_ERR_HPI_UNSUPPORTED_API (SaErrorT)(SA_HPI_ERR_BASE - 2)
+#define SA_ERR_HPI_BUSY (SaErrorT)(SA_HPI_ERR_BASE - 3)
+#define SA_ERR_HPI_INTERNAL_ERROR (SaErrorT)(SA_HPI_ERR_BASE - 4)
+#define SA_ERR_HPI_INVALID_CMD (SaErrorT)(SA_HPI_ERR_BASE - 5)
+#define SA_ERR_HPI_TIMEOUT (SaErrorT)(SA_HPI_ERR_BASE - 6)
+#define SA_ERR_HPI_OUT_OF_SPACE (SaErrorT)(SA_HPI_ERR_BASE - 7)
+#define SA_ERR_HPI_OUT_OF_MEMORY (SaErrorT)(SA_HPI_ERR_BASE - 8)
+#define SA_ERR_HPI_INVALID_PARAMS (SaErrorT)(SA_HPI_ERR_BASE - 9)
+#define SA_ERR_HPI_INVALID_DATA (SaErrorT)(SA_HPI_ERR_BASE - 10)
+#define SA_ERR_HPI_NOT_PRESENT (SaErrorT)(SA_HPI_ERR_BASE - 11)
+#define SA_ERR_HPI_NO_RESPONSE (SaErrorT)(SA_HPI_ERR_BASE - 12)
+#define SA_ERR_HPI_DUPLICATE (SaErrorT)(SA_HPI_ERR_BASE - 13)
+#define SA_ERR_HPI_INVALID_SESSION (SaErrorT)(SA_HPI_ERR_BASE - 14)
+#define SA_ERR_HPI_INVALID_DOMAIN (SaErrorT)(SA_HPI_ERR_BASE - 15)
+#define SA_ERR_HPI_INVALID_RESOURCE (SaErrorT)(SA_HPI_ERR_BASE - 16)
+#define SA_ERR_HPI_INVALID_REQUEST (SaErrorT)(SA_HPI_ERR_BASE - 17)
+#define SA_ERR_HPI_ENTITY_NOT_PRESENT (SaErrorT)(SA_HPI_ERR_BASE - 18)
+#define SA_ERR_HPI_READ_ONLY (SaErrorT)(SA_HPI_ERR_BASE - 19)
+#define SA_ERR_HPI_CAPABILITY (SaErrorT)(SA_HPI_ERR_BASE - 20)
+#define SA_ERR_HPI_UNKNOWN (SaErrorT)(SA_HPI_ERR_BASE - 21)
+
+/*
+** Domain, Session and Resource Type Definitions
+*/
+
+/* Domain ID. */
+typedef SaHpiUint32T SaHpiDomainIdT;
+
+/* The SAHPI_UNSPECIFIED_DOMAIN_ID value is used to specify the default
+** domain.
+*/
+#define SAHPI_UNSPECIFIED_DOMAIN_ID (SaHpiDomainIdT) 0xFFFFFFFF
+
+/* Session ID. */
+typedef SaHpiUint32T SaHpiSessionIdT;
+
+/* Resource identifier. */
+typedef SaHpiUint32T SaHpiResourceIdT;
+
+/* The SAHPI_UNSPECIFIED_RESOURCE_ID value is used to specify the Domain
+** Event Log and to specify that there is no resource for such things as HPI
+** User events/alarms.
+*/
+#define SAHPI_UNSPECIFIED_RESOURCE_ID (SaHpiResourceIdT) 0xFFFFFFFF
+
+/* Table Related Type Definitions */
+typedef SaHpiUint32T SaHpiEntryIdT;
+#define SAHPI_FIRST_ENTRY (SaHpiEntryIdT)0x00000000
+#define SAHPI_LAST_ENTRY (SaHpiEntryIdT)0xFFFFFFFF
+#define SAHPI_ENTRY_UNSPECIFIED SAHPI_FIRST_ENTRY
+
+/*
+** 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.
+**
+** There is no practical need within the interface for expressing dates prior
+** to the publication of this specification (which is more than five years
+** after the "break point" between relative and absolute time). Thus, in all
+** instances a time value should be interpreted as "relative" times if the
+** value is less than or equal to SAHPI_TIME_MAX_RELATIVE (but not equal to
+** SAHPI_TIME_UNSPECIFIED which always means the time is not available), or
+** "absolute" times if the value is greater than SAHPI_TIME_MAX_RELATIVE.
+*/
+typedef SaHpiInt64T SaHpiTimeT; /* Time in nanoseconds */
+
+/* Unspecified or unknown time */
+#define SAHPI_TIME_UNSPECIFIED (SaHpiTimeT) 0x8000000000000000LL
+
+/* Maximum time that can be specified as relative */
+#define SAHPI_TIME_MAX_RELATIVE (SaHpiTimeT) 0x0C00000000000000LL
+typedef SaHpiInt64T SaHpiTimeoutT; /* Timeout in nanoseconds */
+
+/* Non-blocking call */
+#define SAHPI_TIMEOUT_IMMEDIATE (SaHpiTimeoutT) 0x0000000000000000LL
+
+/* Blocking call, wait indefinitely for call to complete */
+#define SAHPI_TIMEOUT_BLOCK (SaHpiTimeoutT) -1LL
+
+/*
+** 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.
+**
+** The encoding of the Data field in the SaHpiTextBufferT structure is defined
+** by the value of the DataType field in the buffer. The following table
+** describes the various encodings:
+**
+** DataType Encoding
+** -------- --------
+**
+** SAHPI_TL_TYPE_UNICODE 16-bit Unicode, least significant byte first.
+** Buffer must contain even number of bytes.
+**
+** SAHPI_TL_TYPE_BCDPLUS 8-bit ASCII, '0'-'9' or space, dash, period,
+** colon, comma, or underscore only.
+**
+** SAHPI_TL_TYPE_ASCII6 8-bit ASCII, reduced set, 0x20=0x5f only.
+**
+** SAHPI_TL_TYPE_TEXT 8-bit ASCII+Latin 1
+**
+** SAHPI_TL_TYPE_BINARY 8-bit bytes, any values legal
+**
+** Note: "ASCII+Latin 1" is derived from the first 256 characters of
+** Unicode 2.0. The first 256 codes of Unicode follow ISO 646 (ASCII)
+** and ISO 8859/1 (Latin 1). The Unicode "C0 Controls and Basic Latin"
+** set defines the first 128 8-bit characters (00h-7Fh) and the
+** "C1 Controls and Latin 1 Supplement" defines the second 128 (80h-FFh).
+**
+** Note: The SAHPI_TL_TYPE_BCDPLUS and SAHPI_TL_TYPE_ASCII6 encodings
+** use normal ASCII character encodings, but restrict the allowed
+** characters to a subset of the entire ASCII character set. These
+** encodings are used when the target device contains restrictions
+** on which characters it can store or display. SAHPI_TL_TYPE_BCDPLUS
+** data may be stored externally as 4-bit values, and
+** SAHPI_TL_TYPE_ASCII6 may be stored externally as 6-bit values.
+** But, regardless of how the data is stored externally, it is
+** encoded as 8-bit ASCII in the SaHpiTextBufferT structure passed
+** across the HPI.
+*/
+
+#define SAHPI_MAX_TEXT_BUFFER_LENGTH 255
+
+typedef enum {
+ SAHPI_TL_TYPE_UNICODE = 0, /* 2-byte UNICODE characters; DataLength
+ must be even. */
+ SAHPI_TL_TYPE_BCDPLUS, /* String of ASCII characters, '0'-'9', space,
+ dash, period, colon, comma or underscore
+ ONLY */
+ SAHPI_TL_TYPE_ASCII6, /* Reduced ASCII character set: 0x20-0x5F
+ ONLY */
+ SAHPI_TL_TYPE_TEXT, /* ASCII+Latin 1 */
+ SAHPI_TL_TYPE_BINARY /* Binary data, any values legal */
+} 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;
+
+/*
+** Instrument Id
+**
+** The following data type is used for all management instrument identifiers -
+** sensor numbers, control numbers, watchdog timer numbers, etc.
+**
+*/
+
+typedef SaHpiUint32T SaHpiInstrumentIdT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** 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 location number (to identify
+** the physical location of a particular type of entity).
+**
+** Entities are uniquely identified in a system with an ordered series of
+** Entity Type / Entity Location pairs called an "Entity Path". Each subsequent
+** Entity Type/Entity Location 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_RACK_MOUNTED_SERVER,
+ SAHPI_ENT_SYSTEM_BLADE,
+ SAHPI_ENT_SWITCH, /* Network switch, such as a
+ rack-mounted ethernet or fabric
+ switch. */
+ SAHPI_ENT_SWITCH_BLADE, /* Network switch, as above, but in
+ a bladed system. */
+ 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_SHELF_MANAGER, /* Blade-based shelf manager */
+ SAHPI_ENT_DISPLAY_PANEL, /* Display panel, such as an
+ alarm display panel. */
+ 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.). */
+ SAHPI_ENT_PHYSICAL_SLOT /* Indicates the physical slot into
+ which a blade is inserted. */
+} SaHpiEntityTypeT;
+
+typedef SaHpiUint32T SaHpiEntityLocationT;
+
+typedef struct {
+ SaHpiEntityTypeT EntityType;
+ SaHpiEntityLocationT EntityLocation;
+} 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.
+**
+** It is recommended that implementations map their sensor specific
+** event categories into the set of categories listed here. When such a mapping
+** is impractical or impossible, the SAHPI_EC_SENSOR_SPECIFIC category should
+** be used.
+**
+** 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_SENSOR_SPECIFIC (SaHpiEventCategoryT)0x7E /* Sensor-
+ specific 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 == <any>
+*/
+#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_SENSOR_SPECIFIC
+** These event states are implementation-specific.
+*/
+#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 SaHpiInstrumentIdT SaHpiSensorNumT;
+/* The following specifies the named range for standard sensor numbers. */
+#define SAHPI_STANDARD_SENSOR_MIN (SaHpiSensorNumT)0x00000100
+#define SAHPI_STANDARD_SENSOR_MAX (SaHpiSensorNumT)0x000001FF
+
+/* 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;
+
+/*
+** Sensor Reading Type
+**
+** These definitions list the available data types that can be
+** used for sensor readings.
+**
+*/
+
+#define SAHPI_SENSOR_BUFFER_LENGTH 32
+
+typedef enum {
+ SAHPI_SENSOR_READING_TYPE_INT64,
+ SAHPI_SENSOR_READING_TYPE_UINT64,
+ SAHPI_SENSOR_READING_TYPE_FLOAT64,
+ SAHPI_SENSOR_READING_TYPE_BUFFER /* 32 byte array. The format of
+ the buffer is implementation-
+ specific. Sensors that use
+ this reading type may not have
+ thresholds that are settable
+ or readable. */
+} SaHpiSensorReadingTypeT;
+
+typedef union {
+ SaHpiInt64T SensorInt64;
+ SaHpiUint64T SensorUint64;
+ SaHpiFloat64T SensorFloat64;
+ SaHpiUint8T SensorBuffer[SAHPI_SENSOR_BUFFER_LENGTH];
+} SaHpiSensorReadingUnionT;
+
+/*
+** Sensor Reading
+**
+** The sensor reading data structure is returned from a call to get
+** sensor reading. The structure is also used when setting and getting sensor
+** threshold values and reporting sensor ranges.
+**
+** IsSupported is set when a sensor reading/threshold value is available.
+** Otherwise, if no reading or threshold is supported, this flag is set to
+** False.
+**
+*/
+
+typedef struct {
+ SaHpiBoolT IsSupported;
+ SaHpiSensorReadingTypeT Type;
+ SaHpiSensorReadingUnionT Value;
+} SaHpiSensorReadingT;
+
+
+/* Sensor Event Mask Actions - used with saHpiSensorEventMasksSet() */
+
+typedef enum {
+ SAHPI_SENS_ADD_EVENTS_TO_MASKS,
+ SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS
+} SaHpiSensorEventMaskActionT;
+
+/* Value to use for AssertEvents or DeassertEvents parameter
+ in saHpiSensorEventMasksSet() to set or clear all supported
+ event states for a sensor in the mask */
+
+#define SAHPI_ALL_EVENT_STATES (SaHpiEventStateT)0xFFFF
+
+/*
+** Threshold Values
+** This structure encompasses all of the thresholds that can be set.
+** These are set and read with the same units as sensors report in
+** saHpiSensorReadingGet(). When hysteresis is not constant over the
+** range of sensor values, it is calculated at the nominal sensor reading,
+** as given in the Range field of the sensor RDR.
+**
+** Thresholds are required to be set in-order (such that the setting for
+** UpCritical is greater than or equal to the setting for UpMajor, etc.).*/
+
+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 Range
+** Sensor range values can include minimum, maximum, normal minimum, normal
+** maximum, and nominal values.
+**
+** Sensor thresholds cannot be set outside of the range defined by SAHPI_SRF_MIN
+** through SAHPI_SRF_MAX, if these limits are present (as indicated by the
+** SaHpiSensorRangeFlagsT). If the MIN limit is not present, no lower bound
+** will be enforced on sensor thresholds. If the MAX limit is not present, no
+** upper bound will be enforced on sensor thresholds.
+*/
+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;
+
+/*
+** Data Format
+** When IsSupported is False, the sensor does not support data readings
+** (it only supports event states). A False setting for this flag
+** indicates that the rest of the structure is not meaningful.
+**
+** This structure encapsulates all of the various types that make up the
+** definition of sensor data. For reading type of
+** SAHPI_SENSOR_READING_TYPE_BUFFER, the rest of the structure
+** (beyond ReadingType) is not meaningful.
+**
+** The Accuracy Factor is expressed as a floating point percentage
+** (e.g. 0.05 = 5%) and represents statistically how close the measured
+** reading is to the actual value. It is an interpreted value that
+** figures in all sensor accuracies, resolutions, and tolerances.
+*/
+
+typedef struct {
+ SaHpiBoolT IsSupported; /* Indicates if sensor data
+ readings are supported.*/
+ SaHpiSensorReadingTypeT ReadingType; /* Type of value for sensor
+ reading. */
+ SaHpiSensorUnitsT BaseUnits; /* Base units (meters, etc.) */
+ SaHpiSensorUnitsT ModifierUnits; /* Modifier unit (second, etc.)*/
+ SaHpiSensorModUnitUseT ModifierUse; /* Modifier use(m/sec, etc.) */
+ SaHpiBoolT Percentage; /* Is value a percentage */
+ SaHpiSensorRangeT Range; /* Valid range of sensor */
+ SaHpiFloat64T AccuracyFactor; /* Accuracy */
+} SaHpiSensorDataFormatT;
+
+/*
+** Threshold Support
+**
+** These types define what threshold values are readable and writable.
+** Thresholds are read/written in the same ReadingType as is used for sensor
+** readings.
+*/
+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 struct {
+ SaHpiBoolT IsAccessible; /* True if the sensor
+ supports readable or writable
+ thresholds. If False,
+ rest of structure is not
+ meaningful. Sensors that have the
+ IsAccessible flag set must also
+ support the threshold event category
+ A sensor of reading type SAHPI_
+ SENSOR_READING_TYPE_BUFFER cannot
+ have accessible thresholds.*/
+ SaHpiSensorThdMaskT ReadThold; /* Readable thresholds */
+ SaHpiSensorThdMaskT WriteThold; /* Writable thresholds */
+ SaHpiBoolT Nonlinear; /* If this flag is set, hysteresis
+ values are calculated at the nominal
+ sensor value. */
+} 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,
+ or by entire sensor; sensor event enable
+ status can be changed, and assert/deassert
+ masks can be changed */
+ SAHPI_SEC_READ_ONLY_MASKS, /* Control for entire sensor only; sensor
+ event enable status can be changed, but
+ assert/deassert masks cannot be changed */
+ SAHPI_SEC_READ_ONLY /* Event control not supported; sensor event
+ enable status cannot be changed and
+ assert/deassert masks cannot be changed */
+} 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 */
+ SaHpiBoolT EnableCtrl; /* True if HPI User can enable
+ or disable sensor via
+ saHpiSensorEnableSet() */
+ SaHpiSensorEventCtrlT EventCtrl; /* How events can be controlled */
+ SaHpiEventStateT Events; /* Bit mask of event states
+ supported */
+ 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)0x00000100
+#define SAHPI_DEFAGSENS_PWR (SaHpiSensorNumT)0x00000101
+#define SAHPI_DEFAGSENS_TEMP (SaHpiSensorNumT)0x00000102
+
+/* The following specifies the named range for aggregate status. */
+#define SAHPI_DEFAGSENS_MIN (SaHpiSensorNumT)0x00000100
+#define SAHPI_DEFAGSENS_MAX (SaHpiSensorNumT)0x0000010F
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Controls **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+/* Control Number */
+typedef SaHpiInstrumentIdT 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
+*/
+
+/*
+** Digital Control State Definition
+**
+** Defines the types of digital control states.
+** Any of the four states may be set using saHpiControlSet().
+** Only ON or OFF are appropriate returns from saHpiControlGet().
+** (PULSE_ON and PULSE_OFF are transitory and end in OFF and ON states,
+** respectively.)
+** OFF - the control is off
+** ON - the control is on
+** PULSE_OFF - the control is briefly turned off, and then turned back on
+** PULSE_ON - the control is briefly turned on, and then turned back off
+**
+*/
+typedef enum {
+ SAHPI_CTRL_STATE_OFF = 0,
+ SAHPI_CTRL_STATE_ON,
+ SAHPI_CTRL_STATE_PULSE_OFF,
+ SAHPI_CTRL_STATE_PULSE_ON
+} SaHpiCtrlStateDigitalT;
+
+/*
+** Discrete Control State Definition
+*/
+typedef SaHpiUint32T SaHpiCtrlStateDiscreteT;
+
+/*
+** Analog Control State Definition
+*/
+typedef SaHpiInt32T SaHpiCtrlStateAnalogT;
+
+/*
+** Stream Control State Definition
+*/
+#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;
+
+/*
+** Text Control State Definition
+*/
+typedef SaHpiUint8T SaHpiTxtLineNumT;
+
+/* Reserved number for sending output to all lines */
+#define SAHPI_TLN_ALL_LINES (SaHpiTxtLineNumT)0x00
+
+typedef struct {
+ SaHpiTxtLineNumT Line; /* Operate on line # */
+ SaHpiTextBufferT Text; /* Text to display */
+} SaHpiCtrlStateTextT;
+
+/*
+** OEM Control State Definition
+*/
+#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 Mode Type Definition
+**
+** Controls may be in either AUTO mode or MANUAL mode.
+**
+*/
+typedef enum {
+ SAHPI_CTRL_MODE_AUTO,
+ SAHPI_CTRL_MODE_MANUAL
+} SaHpiCtrlModeT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** 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.
+ If the control DataType is
+ SAHPI_TL_TYPE_UNICODE, there will
+ be two bytes required for each
+ character. This field reports the
+ number of characters per line- not the
+ number of bytes. MaxChars must not be
+ larger than the number of characters
+ that can be placed in a single
+ SaHpiTextBufferT structure. */
+ 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;
+
+/*
+** Default Control Mode Structure
+** This structure tells an HPI User if the control comes up in Auto mode or
+** in Manual mode, by default. It also indicates if the mode can be
+** changed (using saHpiControlSet()). When ReadOnly is False, the mode
+** can be changed from its default setting; otherwise attempting to
+** change the mode will result in an error.
+*/
+typedef struct {
+ SaHpiCtrlModeT Mode; /* Auto or Manual */
+ SaHpiBoolT ReadOnly; /* Indicates if mode is read-only */
+} SaHpiCtrlDefaultModeT;
+
+/*
+** Record Definition
+** Definition of the control resource data record.
+*/
+typedef struct {
+ SaHpiCtrlNumT Num; /* Control Number/Index */
+ SaHpiCtrlOutputTypeT OutputType;
+ SaHpiCtrlTypeT Type; /* Type of control */
+ SaHpiCtrlRecUnionT TypeUnion; /* Specific control record */
+ SaHpiCtrlDefaultModeT DefaultMode; /*Indicates if the control comes up
+ in Auto or Manual mode. */
+ SaHpiBoolT WriteOnly; /* Indicates if the control is
+ write-only. */
+ SaHpiUint32T Oem; /* Reserved for OEM use */
+} SaHpiCtrlRecT;
+
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Inventory Data Repositories **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+/*
+** These structures are used to read and write inventory data to entity
+** inventory data repositories within a resource.
+*/
+/*
+** Inventory Data Repository ID
+** Identifier for an inventory data repository.
+*/
+typedef SaHpiInstrumentIdT SaHpiIdrIdT;
+#define SAHPI_DEFAULT_INVENTORY_ID (SaHpiIdrIdT)0x00000000
+
+/* Inventory Data Area type definitions */
+typedef enum {
+ SAHPI_IDR_AREATYPE_INTERNAL_USE = 0xB0,
+ SAHPI_IDR_AREATYPE_CHASSIS_INFO,
+ SAHPI_IDR_AREATYPE_BOARD_INFO,
+ SAHPI_IDR_AREATYPE_PRODUCT_INFO,
+ SAHPI_IDR_AREATYPE_OEM = 0xC0,
+ SAHPI_IDR_AREATYPE_UNSPECIFIED = 0xFF
+} SaHpiIdrAreaTypeT;
+
+/* Inventory Data Field type definitions */
+typedef enum {
+ SAHPI_IDR_FIELDTYPE_CHASSIS_TYPE,
+ SAHPI_IDR_FIELDTYPE_MFG_DATETIME,
+ SAHPI_IDR_FIELDTYPE_MANUFACTURER,
+ SAHPI_IDR_FIELDTYPE_PRODUCT_NAME,
+ SAHPI_IDR_FIELDTYPE_PRODUCT_VERSION,
+ SAHPI_IDR_FIELDTYPE_SERIAL_NUMBER,
+ SAHPI_IDR_FIELDTYPE_PART_NUMBER,
+ SAHPI_IDR_FIELDTYPE_FILE_ID,
+ SAHPI_IDR_FIELDTYPE_ASSET_TAG,
+ SAHPI_IDR_FIELDTYPE_CUSTOM,
+ SAHPI_IDR_FIELDTYPE_UNSPECIFIED = 0xFF
+} SaHpiIdrFieldTypeT;
+
+/* Inventory Data Field structure definition */
+typedef struct {
+ SaHpiEntryIdT AreaId; /* AreaId for the IDA to which */
+ /* the Field belongs */
+ SaHpiEntryIdT FieldId; /* Field Identifier */
+ SaHpiIdrFieldTypeT Type; /* Field Type */
+ SaHpiBoolT ReadOnly; /* Describes if a field is read-only. */
+ /* All fields in a read-only area are */
+ /* flagged as read-only as well.*/
+ SaHpiTextBufferT Field; /* Field Data */
+} SaHpiIdrFieldT;
+
+/* Inventory Data Area header structure definition */
+typedef struct {
+ SaHpiEntryIdT AreaId; /* Area Identifier */
+ SaHpiIdrAreaTypeT Type; /* Type of area */
+ SaHpiBoolT ReadOnly; /* Describes if an area is read-only. */
+ /* All area headers in a read-only IDR */
+ /* are flagged as read-only as well.*/
+ SaHpiUint32T NumFields; /* Number of Fields contained in Area */
+} SaHpiIdrAreaHeaderT;
+
+/* Inventory Data Repository Information structure definition */
+typedef struct {
+ SaHpiIdrIdT IdrId; /* Repository Identifier */
+ SaHpiUint32T UpdateCount; /* The count is incremented any time the */
+ /* IDR is changed. It rolls over to zero */
+ /* when the maximum value is reached */
+ SaHpiBoolT ReadOnly; /* Describes if the IDR is read-only. */
+ /* All area headers and fields in a */
+ /* read-only IDR are flagged as */
+ /* read-only as well.*/
+ SaHpiUint32T NumAreas; /* Number of Area contained in IDR */
+} SaHpiIdrInfoT;
+
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Inventory Data Repository Resource Data Records **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+/*
+** All inventory data contained in an inventory data repository
+** must be represented in the RDR repository
+** with an SaHpiInventoryRecT.
+*/
+typedef struct {
+ SaHpiIdrIdT IdrId;
+ SaHpiBoolT Persistent; /* True indicates that updates to IDR are
+ automatically and immediately persisted.
+ False indicates that updates are not
+ immediately persisted; but optionally may be
+ persisted via saHpiParmControl() function, as
+ defined in implementation documentation.*/
+ SaHpiUint32T Oem;
+} SaHpiInventoryRecT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Watchdogs **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+/*
+** This section defines all of the data types associated with watchdog timers.
+*/
+
+/* Watchdog Number - Identifier for a watchdog timer. */
+typedef SaHpiInstrumentIdT SaHpiWatchdogNumT;
+#define SAHPI_DEFAULT_WATCHDOG_NUM (SaHpiWatchdogNumT)0x00000000
+
+/*
+** 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 events. True=events will be generated.
+** 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 the
+** enumerated 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" milliseconds 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 because of this may have rounded the
+** set value to whatever resolution could be supported.
+** The HPI implementation will return this rounded value.
+** 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 the watchdog is started/restarted, or some
+** other implementation-dependent strobe is
+** sent to the Watchdog. HPI implementations may not be
+** able to support millisecond resolution, and because
+** of this may have rounded the set value to whatever
+** resolution could be supported. The HPI implementation
+** will return this rounded value.
+** 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
+** events. True=event will be generated.
+** 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 countown 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" milliseconds 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;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Hot Swap **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+/* 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,
+ SAHPI_HS_STATE_EXTRACTION_PENDING,
+ SAHPI_HS_STATE_NOT_PRESENT
+} SaHpiHsStateT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Events, Part 2 **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+/* Event Data Structures */
+
+typedef enum {
+ SAHPI_CRITICAL = 0,
+ SAHPI_MAJOR,
+ SAHPI_MINOR,
+ SAHPI_INFORMATIONAL,
+ SAHPI_OK,
+ SAHPI_DEBUG = 0xF0,
+ SAHPI_ALL_SEVERITIES = 0xFF /* Only used with DAT and Annunciator */
+ /* functions. This is not a valid */
+ /* severity for events or alarms */
+} SaHpiSeverityT;
+
+
+typedef enum {
+ SAHPI_RESE_RESOURCE_FAILURE,
+ SAHPI_RESE_RESOURCE_RESTORED,
+ SAHPI_RESE_RESOURCE_ADDED
+} SaHpiResourceEventTypeT;
+
+
+typedef struct {
+ SaHpiResourceEventTypeT ResourceEventType;
+} SaHpiResourceEventT;
+
+
+/*
+** Domain events are used to announce the addition of domain references
+** and the removal of domain references to the DRT.
+*/
+typedef enum {
+ SAHPI_DOMAIN_REF_ADDED,
+ SAHPI_DOMAIN_REF_REMOVED
+} SaHpiDomainEventTypeT;
+
+typedef struct {
+ SaHpiDomainEventTypeT Type; /* Type of domain event */
+ SaHpiDomainIdT DomainId; /* Domain Id of domain added
+ to or removed from DRT. */
+} SaHpiDomainEventT;
+
+
+/*
+** 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 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_CURRENT_STATE (SaHpiSensorOptionalDataT)0x10
+#define SAHPI_SOD_SENSOR_SPECIFIC (SaHpiSensorOptionalDataT)0x20
+typedef struct {
+ SaHpiSensorNumT SensorNum;
+ SaHpiSensorTypeT SensorType;
+ SaHpiEventCategoryT EventCategory;
+ SaHpiBoolT Assertion; /* True = Event State
+ asserted
+ False = deasserted */
+ SaHpiEventStateT EventState; /* single state being asserted
+ or deasserted*/
+ SaHpiSensorOptionalDataT OptionalDataPresent;
+ /* the following fields are only valid if the corresponding flag is set
+ in the OptionalDataPresent field */
+ SaHpiSensorReadingT TriggerReading; /* Reading that triggered
+ the event */
+ SaHpiSensorReadingT TriggerThreshold; /* Value of the threshold
+ that was crossed. Will not
+ be present if threshold is
+ not readable. */
+ SaHpiEventStateT PreviousState; /* Previous set of asserted
+ event states. If multiple
+ event states change at once,
+ multiple events may be
+ generated for each changing
+ event state. This field
+ should indicate the status of
+ the sensor event states prior
+ to any of the simultaneous
+ changes.
+
+ Thus, it will be the same in
+ each event generated due to
+ multiple simultaneous event
+ state changes. */
+
+ SaHpiEventStateT CurrentState; /* Current set of asserted
+ event states. */
+ SaHpiUint32T Oem;
+ SaHpiUint32T SensorSpecific;
+} SaHpiSensorEventT;
+
+typedef SaHpiUint8T SaHpiSensorEnableOptDataT;
+
+#define SAHPI_SEOD_CURRENT_STATE (SaHpiSensorEnableOptDataT)0x10
+
+typedef struct {
+ SaHpiSensorNumT SensorNum;
+ SaHpiSensorTypeT SensorType;
+ SaHpiEventCategoryT EventCategory;
+ SaHpiBoolT SensorEnable; /* current sensor enable status */
+ SaHpiBoolT SensorEventEnable; /* current evt enable status */
+ SaHpiEventStateT AssertEventMask; /* current assert event mask */
+ SaHpiEventStateT DeassertEventMask; /* current deassert evt mask */
+ SaHpiSensorEnableOptDataT OptionalDataPresent;
+ /* the following fields are only valid if the corresponding flag is set
+ in the OptionalDataPresent field */
+ SaHpiEventStateT CurrentState; /* Current set of asserted
+ Event states. */
+} SaHpiSensorEnableChangeEventT;
+
+typedef struct {
+ SaHpiHsStateT HotSwapState;
+ SaHpiHsStateT PreviousHotSwapState;
+} SaHpiHotSwapEventT;
+
+typedef struct {
+ SaHpiWatchdogNumT WatchdogNum;
+ SaHpiWatchdogActionEventT WatchdogAction;
+ SaHpiWatchdogPretimerInterruptT WatchdogPreTimerAction;
+ SaHpiWatchdogTimerUseT WatchdogUse;
+} SaHpiWatchdogEventT;
+
+/*
+** The following type defines the types of events that can be reported
+** by the HPI software implementation.
+**
+** Audit events report a discrepancy in the audit process. Audits are typically
+** performed by HA software to detect problems. Audits may look for such things
+** as corrupted data stores, inconsistent RPT information, or improperly managed
+** queues.
+**
+** Startup events report a failure to start-up properly, or inconsistencies in
+** persisted data.
+*/
+typedef enum {
+ SAHPI_HPIE_AUDIT,
+ SAHPI_HPIE_STARTUP,
+ SAHPI_HPIE_OTHER
+} SaHpiSwEventTypeT;
+
+typedef struct {
+ SaHpiManufacturerIdT MId;
+ SaHpiSwEventTypeT Type;
+ SaHpiTextBufferT EventData;
+} SaHpiHpiSwEventT;
+
+typedef struct {
+ SaHpiManufacturerIdT MId;
+ SaHpiTextBufferT OemEventData;
+} SaHpiOemEventT;
+
+/*
+** User events may be used for storing custom events created by an HPI User
+** when injecting events into the Event Log using saHpiEventLogEntryAdd().
+*/
+typedef struct {
+ SaHpiTextBufferT UserEventData;
+} SaHpiUserEventT;
+
+typedef enum {
+ SAHPI_ET_RESOURCE,
+ SAHPI_ET_DOMAIN,
+ SAHPI_ET_SENSOR,
+ SAHPI_ET_SENSOR_ENABLE_CHANGE,
+ SAHPI_ET_HOTSWAP,
+ SAHPI_ET_WATCHDOG,
+ SAHPI_ET_HPI_SW,
+ SAHPI_ET_OEM,
+ SAHPI_ET_USER
+} SaHpiEventTypeT;
+
+typedef union {
+ SaHpiResourceEventT ResourceEvent;
+ SaHpiDomainEventT DomainEvent;
+ SaHpiSensorEventT SensorEvent;
+ SaHpiSensorEnableChangeEventT SensorEnableChangeEvent;
+ SaHpiHotSwapEventT HotSwapEvent;
+ SaHpiWatchdogEventT WatchdogEvent;
+ SaHpiHpiSwEventT HpiSwEvent;
+ SaHpiOemEventT OemEvent;
+ SaHpiUserEventT UserEvent;
+} SaHpiEventUnionT;
+
+typedef struct {
+ SaHpiResourceIdT Source;
+ SaHpiEventTypeT EventType;
+ SaHpiTimeT Timestamp; /*Equal to SAHPI_TIME_UNSPECIFED if time is
+ not available; Absolute time if greater
+ than SAHPI_TIME_MAX_RELATIVE, Relative
+ time if less than or equal to
+ SAHPI_TIME_MAX_RELATIVE */
+ SaHpiSeverityT Severity;
+ SaHpiEventUnionT EventDataUnion;
+} SaHpiEventT;
+
+/*
+** Event Queue Status
+**
+** This status word is returned to HPI Users that request it
+** when saHpiEventGet() is called.
+**
+*/
+
+typedef SaHpiUint32T SaHpiEvtQueueStatusT;
+
+#define SAHPI_EVT_QUEUE_OVERFLOW (SaHpiEvtQueueStatusT)0x0001
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Annunciators **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+/*
+** Annunciator Number
+** Identifier for an Annunciator management instrument.
+*/
+typedef SaHpiInstrumentIdT SaHpiAnnunciatorNumT;
+
+/*
+** The following data type is equivalent to the AIS data type SaNameT.
+** it is defined in this header file, so that inclusion of the AIS
+** header file is not required. This data type is based on version 1.0
+** of the AIS specification
+*/
+#define SA_HPI_MAX_NAME_LENGTH 256
+
+typedef struct {
+ SaHpiUint16T Length;
+ unsigned char Value[SA_HPI_MAX_NAME_LENGTH];
+} SaHpiNameT;
+
+/*
+** Enumeration of Announcement Types
+*/
+typedef enum {
+ SAHPI_STATUS_COND_TYPE_SENSOR,
+ SAHPI_STATUS_COND_TYPE_RESOURCE,
+ SAHPI_STATUS_COND_TYPE_OEM,
+ SAHPI_STATUS_COND_TYPE_USER
+} SaHpiStatusCondTypeT;
+
+
+/* Condition structure definition */
+typedef struct {
+
+ SaHpiStatusCondTypeT Type; /* Status Condition Type */
+ SaHpiEntityPathT Entity; /* Entity assoc. with status condition */
+ SaHpiDomainIdT DomainId; /* Domain associated with status.
+ May be SAHPI_UNSPECIFIED_DOMAIND_ID
+ meaning current domain, or domain
+ not meaningful for status condition*/
+ SaHpiResourceIdT ResourceId; /* Resource associated with status.
+ May be SAHPI_UNSPECIFIED_RESOURCE_ID
+ if Type is SAHPI_STATUS_COND_USER.
+ Must be set to valid ResourceId in
+ domain specified by DomainId,
+ or in current domain, if DomainId
+ is SAHPI_UNSPECIFIED_DOMAIN_ID */
+ SaHpiSensorNumT SensorNum; /* Sensor associated with status
+ Only valid if Type is
+ SAHPI_STATUS_COND_TYPE_SENSOR */
+ SaHpiEventStateT EventState; /* Sensor event state.
+ Only valid if Type is
+ SAHPI_STATUS_COND_TYPE_SENSOR. */
+ SaHpiNameT Name; /* AIS compatible identifier associated
+ with Status condition */
+ SaHpiManufacturerIdT Mid; /* Manufacturer Id associated with
+ status condition, required when type
+ is SAHPI_STATUS_COND_TYPE_OEM. */
+ SaHpiTextBufferT Data; /* Optional Data associated with
+ Status condition */
+} SaHpiConditionT;
+
+
+/* Announcement structure definition */
+typedef struct {
+ SaHpiEntryIdT EntryId; /* Announcment Entry Id */
+ SaHpiTimeT Timestamp; /* Time when announcement added to set */
+ SaHpiBoolT AddedByUser; /* True if added to set by HPI User,
+ False if added automatically by
+ HPI implementation */
+ SaHpiSeverityT Severity; /* Severity of announcement */
+ SaHpiBoolT Acknowledged; /* Acknowledged flag */
+ SaHpiConditionT StatusCond; /* Detailed status condition */
+} SaHpiAnnouncementT;
+
+
+/* Annunciator Mode - defines who may add or delete entries in set. */
+
+typedef enum {
+ SAHPI_ANNUNCIATOR_MODE_AUTO,
+ SAHPI_ANNUNCIATOR_MODE_USER,
+ SAHPI_ANNUNCIATOR_MODE_SHARED
+} SaHpiAnnunciatorModeT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Annunciator Resource Data Records **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+/*
+** The following enumerated type defines the possible output types
+** which can be associated with an Annunciator Management Instrument
+*/
+typedef enum {
+ SAHPI_ANNUNCIATOR_TYPE_LED = 0,
+ SAHPI_ANNUNCIATOR_TYPE_DRY_CONTACT_CLOSURE,
+ SAHPI_ANNUNCIATOR_TYPE_AUDIBLE,
+ SAHPI_ANNUNCIATOR_TYPE_LCD_DISPLAY,
+ SAHPI_ANNUNCIATOR_TYPE_MESSAGE,
+ SAHPI_ANNUNCIATOR_TYPE_COMPOSITE,
+ SAHPI_ANNUNCIATOR_TYPE_OEM
+} SaHpiAnnunciatorTypeT;
+
+
+/*
+** All annunciator management instruments
+** must be represented in the RDR repository
+** with an SaHpiAnnunciatorRecT.
+*/
+typedef struct {
+ SaHpiAnnunciatorNumT AnnunciatorNum;
+ SaHpiAnnunciatorTypeT AnnunciatorType; /* Annunciator Output Type */
+ SaHpiBoolT ModeReadOnly; /* if True, Mode may
+ not be changed by HPI User */
+ SaHpiUint32T MaxConditions; /* maximum number of conditions
+ that can be held in current
+ set. 0 means no fixed
+ limit. */
+ SaHpiUint32T Oem;
+} SaHpiAnnunciatorRecT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** 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,
+ SAHPI_ANNUNCIATOR_RDR
+} SaHpiRdrTypeT;
+
+typedef union {
+ SaHpiCtrlRecT CtrlRec;
+ SaHpiSensorRecT SensorRec;
+ SaHpiInventoryRecT InventoryRec;
+ SaHpiWatchdogRecT WatchdogRec;
+ SaHpiAnnunciatorRecT AnnunciatorRec;
+} SaHpiRdrTypeUnionT;
+
+typedef struct {
+ SaHpiEntryIdT RecordId;
+ SaHpiRdrTypeT RdrType;
+ SaHpiEntityPathT Entity; /* Entity to which this RDR relates. */
+ SaHpiBoolT IsFru; /* Entity is a FRU. This field is
+ Only valid if the Entity path given
+ in the "Entity" field is different
+ from the Entity path in the RPT
+ entry for the resource. */
+ SaHpiRdrTypeUnionT RdrTypeUnion;
+ SaHpiTextBufferT IdString;
+} SaHpiRdrT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** 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;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Power **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+typedef enum {
+ SAHPI_POWER_OFF = 0,
+ SAHPI_POWER_ON,
+ SAHPI_POWER_CYCLE
+} SaHpiPowerStateT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Resource Presence Table **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+/* This section defines the types associated with the RPT. */
+
+/*
+** GUID - Globally Unique Identifier
+**
+** The format if the ID follows that specified by the Wired for Management
+** Baseline, Version 2.0 specification. HPI uses version 1 of the GUID
+** format, with a 3-bit variant field of 10x (where x indicates 'don't care')
+*/
+typedef SaHpiUint8T SaHpiGuidT[16];
+
+/*
+** 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 an 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.).
+**
+** The GUID is used to uniquely identify a Resource. A GUID value of zero is not
+** valid and indicates that the Resource does not have an associated GUID.
+**
+** 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;
+ SaHpiGuidT Guid;
+} SaHpiResourceInfoT;
+
+/*
+** Resource Capabilities
+**
+** This definition defines the capabilities of a given resource. One resource
+** may support any number of capabilities using the bit mask. Because each entry
+** in an RPT will have the SAHPI_CAPABILITY_RESOURCE bit set, zero is not a
+** valid value for the capability flag, and is thus used to indicate "no RPT
+** entry present" in some function calls.
+**
+** 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, an HPI 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 the full managed hot swap model.
+** Since hot swap 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. If
+** SAHPI_CAPABILITY_MANAGED_HOTSWAP is also set, the resource supports
+** the full hot swap model. If SAHPI_CAPABILITY_MANAGED_HOTSWAP is not
+** set, the resource supports the simplified hot swap model.
+** SAHPI_CAPABILITY_ANNUNCIATOR
+** SAHPI_CAPABILITY_POWER
+** SAHPI_CAPABILITY_RESET
+** SAHPI_CAPABILITY_INVENTORY_DATA
+** SAHPI_CAPABILITY_EVENT_LOG
+** SAHPI_CAPABILITY_RDR
+** Indicates that a resource data record (RDR) repository is supplied
+** by the resource. Since the existence of an RDR is mandatory for all
+** management instruments, this
+** capability must be asserted if the resource
+** contains any sensors, controls, watchdog timers, or inventory
+** data repositories.
+** SAHPI_CAPABILITY_SENSOR
+*/
+
+typedef SaHpiUint32T SaHpiCapabilitiesT;
+#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_ANNUNCIATOR (SaHpiCapabilitiesT)0x00000040
+#define SAHPI_CAPABILITY_POWER (SaHpiCapabilitiesT)0x00000020
+#define SAHPI_CAPABILITY_RESET (SaHpiCapabilitiesT)0x00000010
+#define SAHPI_CAPABILITY_INVENTORY_DATA (SaHpiCapabilitiesT)0x00000008
+#define SAHPI_CAPABILITY_EVENT_LOG (SaHpiCapabilitiesT)0x00000004
+#define SAHPI_CAPABILITY_RDR (SaHpiCapabilitiesT)0x00000002
+#define SAHPI_CAPABILITY_SENSOR (SaHpiCapabilitiesT)0x00000001
+
+/*
+** Resource Managed Hot Swap Capabilities
+**
+** This definition defines the managed hot swap capabilities of a given
+** resource.
+**
+** SAHPI_HS_CAPABILITY_AUTOEXTRACT_READ_ONLY
+** This capability indicates if the hot swap autoextract timer is read-only.
+** SAHPI_HS_CAPABILITY_INDICATOR_SUPPORTED
+** Indicates whether or not the resource has a hot swap indicator.
+*/
+
+typedef SaHpiUint32T SaHpiHsCapabilitiesT;
+#define SAHPI_HS_CAPABILITY_AUTOEXTRACT_READ_ONLY \
+ (SaHpiHsCapabilitiesT)0x80000000
+#define SAHPI_HS_CAPABILITY_INDICATOR_SUPPORTED \
+ (SaHpiHsCapabilitiesT)0X40000000
+/*
+** 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 HotSwapCapabilities field denotes the capabilities of the resource,
+** specifically related to hot swap. This field is only valid if the
+** resource supports managed hot swap, as indicated by the
+** SAHPI_CAPABILITY_MANAGED_HOT_SWAP resource capability.
+**
+** The ResourceTag is a data field within an RPT entry available to the HPI
+** User for associating application specific data with a resource. The HPI
+** User supplied data is purely informational and is not used by the HPI
+** implementation, domain, or associated resource. For example, an HPI User
+** can set the resource tag to a "descriptive" value, which can be used to
+** identify the resource in messages to a human operator.
+*/
+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. */
+ SaHpiHsCapabilitiesT HotSwapCapabilities; /* Indicates the hot swap
+ capabilities of the resource */
+ SaHpiSeverityT ResourceSeverity; /* Indicates the criticality that
+ should be raised when the resource
+ is not responding */
+ SaHpiBoolT ResourceFailed; /* Indicates that the resource is not
+ currently functional */
+ SaHpiTextBufferT ResourceTag;
+} SaHpiRptEntryT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Domain Information **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+
+/* This section defines the types associated with the domain controller. */
+
+/*
+** Domain Capabilities
+**
+** This definition defines the capabilities of a given domain. A domain
+** may support any number of capabilities using the bit mask.
+**
+** SAHPI_DOMAIN_CAP_AUTOINSERT_READ_ONLY
+** Indicates that the domain auto insert timeout value is read-only
+** and may not be modified using the saHpiHotSwapAutoInsertTimeoutSet()
+** function.
+*/
+
+typedef SaHpiUint32T SaHpiDomainCapabilitiesT;
+#define SAHPI_DOMAIN_CAP_AUTOINSERT_READ_ONLY \
+ (SaHpiDomainCapabilitiesT)0X00000001
+
+/*
+** Domain Info
+**
+** This structure is used to store the information regarding the domain
+** including information regarding the domain reference table (DRT) and
+** the resource presence table (RPT).
+**
+** The DomainTag field is an informational value that supplies an HPI User
+** with naming information for the domain.
+**
+** NOTE: Regarding timestamps - 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.
+**
+** The GUID is used to uniquely identify a domain. A GUID value of zero is not
+** valid and indicates that the domain does not have an associated GUID.
+*/
+
+typedef struct {
+ SaHpiDomainIdT DomainId; /* Unique Domain Id associated with
+ domain */
+ SaHpiDomainCapabilitiesT DomainCapabilities; /* Domain Capabilities */
+ SaHpiBoolT IsPeer; /* Indicates that this domain
+ participates in a peer
+ relationship. */
+ SaHpiTextBufferT DomainTag; /* Information tag associated with
+ domain */
+ SaHpiUint32T DrtUpdateCount; /* This count is incremented any time the
+ table is changed. It rolls over to
+ zero when the maximum value is
+ reached */
+ SaHpiTimeT DrtUpdateTimestamp; /* This timestamp is set any time the
+ DRT table is changed. */
+ SaHpiUint32T RptUpdateCount; /* This count is incremented any time
+ the RPT is changed. It rolls over
+ to zero when the maximum value is
+ reached */
+ SaHpiTimeT RptUpdateTimestamp; /* This timestamp is set any time the
+ RPT table is changed. */
+ SaHpiUint32T DatUpdateCount; /* This count is incremented any time
+ the DAT is changed. It rolls over to
+ zero when the maximum value is
+ reached */
+ SaHpiTimeT DatUpdateTimestamp; /* This timestamp is set any time the
+ DAT is changed. */
+ SaHpiUint32T ActiveAlarms; /* Count of active alarms in the DAT */
+ SaHpiUint32T CriticalAlarms; /* Count of active critical alarms in
+ the DAT */
+ SaHpiUint32T MajorAlarms; /* Count of active major alarms in the
+ DAT */
+ SaHpiUint32T MinorAlarms; /* Count of active minor alarms in the
+ DAT */
+ SaHpiUint32T DatUserAlarmLimit; /* Maximum User Alarms that can be
+ added to DAT. 0=no fixed limit */
+ SaHpiBoolT DatOverflow; /* Set to True if there are one
+ or more non-User Alarms that
+ are missing from the DAT because
+ of space limitations */
+ SaHpiGuidT Guid; /* GUID associated with domain.*/
+} SaHpiDomainInfoT;
+
+/*
+** DRT Entry
+**
+** This structure is used to store the DRT entry information.
+**
+*/
+typedef struct {
+ SaHpiEntryIdT EntryId;
+ SaHpiDomainIdT DomainId; /* The Domain ID referenced by this entry */
+ SaHpiBoolT IsPeer; /* Indicates if this domain reference
+ is a peer. If not, the domain reference
+ is a tier. */
+} SaHpiDrtEntryT;
+
+
+/*
+** DAT Entry
+**
+** This structure is used to store alarm informatin in the DAT
+**
+*/
+
+
+typedef SaHpiEntryIdT SaHpiAlarmIdT;
+
+typedef struct {
+ SaHpiAlarmIdT AlarmId; /* Alarm Id */
+ SaHpiTimeT Timestamp; /* Time when alarm added to DAT */
+ SaHpiSeverityT Severity; /* Severity of alarm */
+ SaHpiBoolT Acknowledged; /* Acknowledged flag */
+ SaHpiConditionT AlarmCond; /* Detailed alarm condition */
+} SaHpiAlarmT;
+
+/*******************************************************************************
+********************************************************************************
+********** **********
+********** Event Log **********
+********** **********
+********************************************************************************
+*******************************************************************************/
+/* This section defines the types associated with the Event Log. */
+/*
+** Event Log Information
+**
+** The Entries entry denotes the number of active entries contained in the Event
+** Log.
+** The Size entry denotes the total number of entries the Event Log is able to
+** hold.
+** The UserEventMaxSize entry indicates the maximum size of the text buffer
+** data field in an HPI User event that is supported by the Event Log
+** implementation. If the implementation does not enforce a more restrictive
+** data length, it should be set to SAHPI_MAX_TEXT_BUFFER_LENGTH.
+** The UpdateTimestamp entry denotes the time of the last update to the Event
+** Log.
+** The CurrentTime entry denotes the Event 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 Event 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 Event Log has overflowed. Events have
+** been dropped or overwritten due to a table overflow.
+** The OverflowAction entry indicates the behavior of the Event Log when an
+** overflow occurs.
+** The OverflowResetable entry indicates if the overflow flag can be
+** cleared by an HPI User with the saHpiEventLogOverflowReset() function.
+*/
+typedef enum {
+ SAHPI_EL_OVERFLOW_DROP, /* New entries are dropped when Event Log is
+ full*/
+ SAHPI_EL_OVERFLOW_OVERWRITE /* Event Log overwrites existing entries
+ when Event Log is full */
+} SaHpiEventLogOverflowActionT;
+
+typedef struct {
+ SaHpiUint32T Entries;
+ SaHpiUint32T Size;
+ SaHpiUint32T UserEventMaxSize;
+ SaHpiTimeT UpdateTimestamp;
+ SaHpiTimeT CurrentTime;
+ SaHpiBoolT Enabled;
+ SaHpiBoolT OverflowFlag;
+ SaHpiBoolT OverflowResetable;
+ SaHpiEventLogOverflowActionT OverflowAction;
+} SaHpiEventLogInfoT;
+/*
+** Event Log Entry
+** These types define the Event Log entry.
+*/
+typedef SaHpiUint32T SaHpiEventLogEntryIdT;
+/* Reserved values for Event Log entry IDs */
+#define SAHPI_OLDEST_ENTRY (SaHpiEventLogEntryIdT)0x00000000
+#define SAHPI_NEWEST_ENTRY (SaHpiEventLogEntryIdT)0xFFFFFFFF
+#define SAHPI_NO_MORE_ENTRIES (SaHpiEventLogEntryIdT)0xFFFFFFFE
+
+typedef struct {
+ SaHpiEventLogEntryIdT EntryId; /* Entry ID for record */
+ SaHpiTimeT Timestamp; /* Time at which the event was placed
+ in the Event Log. If 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. */
+ SaHpiEventT Event; /* Logged Event */
+} SaHpiEventLogEntryT;
+
+
+/*******************************************************************************
+**
+** Name: saHpiVersionGet()
+**
+** Description:
+** This function returns the version identifier of the SaHpi specification
+** version supported by the HPI implementation.
+**
+** Parameters:
+** None.
+**
+** Return Value:
+** The interface version identifier, of type SaHpiVersionT is returned.
+**
+** Remarks:
+** This function differs from all other interface functions in that it
+** returns the version identifier rather than a standard return code. This is
+** because the version itself is necessary in order for an HPI User to
+** properly interpret subsequent API return codes. Thus, the
+** saHpiVersionGet() function returns the interface version identifier
+** unconditionally.
+**
+** This function returns the value of the header file symbol
+** SAHPI_INTERFACE_VERSION in the SaHpi.h header file used when the library
+** was compiled. An HPI User may compare the returned value to the
+** SAHPI_INTERFACE_VERSION symbol in the SaHpi.h header file used by the
+** calling program to determine if the accessed library is compatible with the
+** calling program.
+**
+*******************************************************************************/
+SaHpiVersionT SAHPI_API saHpiVersionGet ( void );
+
+/*******************************************************************************
+**
+** Name: saHpiSessionOpen()
+**
+** Description:
+** This function opens an HPI session for a given domain and set of security
+** characteristics (future).
+**
+** Parameters:
+** DomainId - [in] Domain identifier of the domain to be accessed by the HPI
+** User. A domain identifier of SAHPI_UNSPECIFIED_DOMAIN_ID requests that
+** a session be opened to a default domain.
+** SessionId - [out] Pointer to a location to store an identifier for the
+** newly opened session. This identifier 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 identifier exists.
+** SA_ERR_HPI_INVALID_PARAMS is returned if:
+** * A non-null SecurityParams pointer is passed.
+** * The SessionId pointer is passed in as NULL.
+** SA_ERR_HPI_OUT_OF_SPACE is returned if no more sessions can be opened.
+**
+** Remarks:
+** None.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiSessionOpen (
+ SAHPI_IN SaHpiDomainIdT DomainId,
+ SAHPI_OUT SaHpiSessionIdT *SessionId,
+ SAHPI_IN void *SecurityParams
+);
+
+/*******************************************************************************
+**
+** Name: saHpiSessionClose()
+**
+** Description:
+** This function closes an HPI session. After closing a session, the SessionId
+** will no longer be valid.
+**
+** Parameters:
+** SessionId - [in] Session identifier 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: saHpiDiscover()
+**
+** Description:
+** This function requests the underlying management service to discover
+** information about resources and associated domains.
+**
+** This function may be called during operation to update the DRT table and
+** the RPT table. An HPI implementation may exhibit latency between when
+** hardware changes occur and when the domain DRT and RPT are updated. To
+** overcome this latency, the saHpiDiscover() function may be called. When
+** this function returns, the DRT and RPT should be updated to reflect the
+** current system configuration and status.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained
+** using saHpiSessionOpen().
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+**
+** Remarks:
+** None.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiDiscover (
+ SAHPI_IN SaHpiSessionIdT SessionId
+);
+
+/*******************************************************************************
+**
+** Name: saHpiDomainInfoGet()
+**
+** Description:
+** This function is used for requesting information about the domain, the
+** Domain Reference Table (DRT), the Resource Presence Table (RPT), and the
+** Domain Alarm Table (DAT), such as table update counters and timestamps, and
+** the unique domain identifier associated with the domain.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained
+** using saHpiSessionOpen().
+** DomainInfo - [out] Pointer to the information describing the domain and
+** DRT.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the DomainInfo pointer is passed
+** in as NULL.
+**
+** Remarks:
+** None.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiDomainInfoGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_OUT SaHpiDomainInfoT *DomainInfo
+);
+
+/*******************************************************************************
+**
+** Name: saHpiDrtEntryGet()
+**
+** Description:
+** This function retrieves domain information for the specified entry of the
+** DRT. This function allows an HPI User to read the DRT entry-by-entry.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** EntryId - [in] Identifier of the DRT entry to retrieve. Reserved EntryId
+** 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 EntryId of next entry
+** in DRT.
+** DrtEntry - [out] Pointer to the structure to hold the returned DRT entry.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_NOT_PRESENT is returned if the:
+** * Entry identified by EntryId is not present.
+** * EntryId is SAHPI_FIRST_ENTRY and the DRT is empty.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * DrtEntry pointer is passed in as NULL.
+** * NextEntryId pointer is passed in as NULL.
+** * EntryId is an invalid reserved value such as SAHPI_LAST_ENTRY.
+**
+** Remarks:
+** If the EntryId parameter is set to SAHPI_FIRST_ENTRY, the first entry in
+** the DRT will be returned. When an entry is successfully retrieved,
+** NextEntryId will be set to the identifier 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.
+**
+** If an HPI User has not subscribed to receive events and a DRT entry is
+** added while the DRT is being read, that new entry may be missed. The
+** update counter provides a means for insuring that no domains are missed
+** when stepping through the DRT. In order to use this feature, an HPI User
+** should call saHpiDomainInfoGet() to get the update counter value before
+** retrieving the first DRT entry. After reading the last entry, the HPI User
+** should again call saHpiDomainInfoGet() to get the update counter value. If
+** the update counter has not been incremented, no new entries have been
+** added.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiDrtEntryGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiEntryIdT EntryId,
+ SAHPI_OUT SaHpiEntryIdT *NextEntryId,
+ SAHPI_OUT SaHpiDrtEntryT *DrtEntry
+);
+
+/*******************************************************************************
+**
+** Name: saHpiDomainTagSet()
+**
+** Description:
+** This function allows an HPI User to set a descriptive tag for a particular
+** domain. The domain tag is an informational value that supplies an HPI User
+** with naming information for the domain.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** DomainTag - [in] Pointer to SaHpiTextBufferT containing the domain tag.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the SaHpiTextBufferT structure
+** passed as DomainTag is not valid. This would occur when:
+** * The DataType is not one of the enumerated values for that type, or
+** * The data field contains characters that are not legal according to
+** the value of DataType, or
+** * The Language is not one of the enumerated values for that type when
+** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the DomainTag pointer is passed in
+** as NULL.
+**
+** Remarks:
+** Typically, the HPI implementation will provide an appropriate default value
+** for the domain tag; this function is provided so that an HPI User can
+** override the default, if desired. The value of the domain tag may be
+** retrieved from the domain's information structure.
+**
+** The domain tag is not necessarily persistent, and may return to its default
+** value if the domain controller function for the domain restarts.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiDomainTagSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiTextBufferT *DomainTag
+);
+
+/*******************************************************************************
+**
+** Name: saHpiRptEntryGet()
+**
+** Description:
+** This function retrieves resource information for the specified entry of the
+** resource presence table. This function allows an HPI User to read the RPT
+** entry-by-entry.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** EntryId - [in] Identifier of the RPT entry to retrieve. Reserved EntryId
+** 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 EntryId 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.
+** SA_ERR_HPI_NOT_PRESENT is returned when the:
+** * Entry identified by EntryId is not present.
+** * EntryId is SAHPI_FIRST_ENTRY and the RPT is empty.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * RptEntry pointer is passed in as NULL.
+** * NextEntryId pointer is passed in as NULL.
+** * EntryId is an invalid reserved value such as SAHPI_LAST_ENTRY.
+**
+** Remarks:
+** 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 identifier 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, an HPI 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, an HPI User
+** should invoke saHpiDomainInfoGet(), and get the update counter value before
+** retrieving the first RPT entry. After reading the last entry, an HPI User
+** should again invoke the saHpiDomainInfoGet() to get the RPT update counter
+** value. If the update counter has not been incremented, no new records have
+** been added.
+**
+*******************************************************************************/
+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 ResourceId.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained
+** using saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the RptEntry pointer is passed
+** in as NULL.
+**
+** Remarks:
+** Typically at start-up, the RPT is read entry-by-entry, using
+** saHpiRptEntryGet(). From this, an HPI User can establish the set of
+** ResourceIds to use for future calls to the HPI functions.
+**
+** However, there may be other ways of learning ResourceIds 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
+** ResourceId 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 ResourceId can be used to locate the applicable RPT entry
+** information.
+**
+** Note that saHpiRptEntryGetByResourceId() is valid in any hot swap state,
+** except for SAHPI_HS_STATE_NOT_PRESENT.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiRptEntryGetByResourceId (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_OUT SaHpiRptEntryT *RptEntry
+);
+
+/*******************************************************************************
+**
+** Name: saHpiResourceSeveritySet()
+**
+** Description:
+** This function allows an HPI User 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.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the value for Severity is not
+** one of the valid enumerated values for this type.
+**
+** Remarks:
+** Typically, the HPI implementation will provide an appropriate default value
+** for the resource severity, which may vary by resource; an HPI User 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 the
+** resource severity.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiResourceSeveritySet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiSeverityT Severity
+);
+
+/*******************************************************************************
+**
+** Name: saHpiResourceTagSet()
+**
+** Description:
+** This function allows an HPI User to set the resource tag of an RPT entry
+** for a particular resource.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** ResourceTag - [in] Pointer to SaHpiTextBufferT containing the resource tag.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the SaHpiTextBufferT structure
+** passed as ResourceTag is not valid. This would occur when:
+** * The DataType is not one of the enumerated values for that type, or
+** * The data field contains characters that are not legal according to the
+** value of DataType, or
+** * The Language is not one of the enumerated values for that type when
+** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the ResourceTag pointer is passed
+** in as NULL.
+**
+** Remarks:
+** The resource tag is a data field within an RPT entry available to an HPI
+** User for associating application specific data with a resource. HPI User
+** supplied data is purely informational and is not used by the HPI
+** implementation, domain, or associated resource. For example, an HPI User
+** can set the resource tag to a "descriptive" value, which can be used to
+** identify the resource in messages to a human operator.
+**
+** Since the resource tag is contained within an RPT entry, its scope is
+** limited to a single domain. A resource that exists in more than one domain
+** will have independent resource tags within each domain.
+**
+** Typically, the HPI implementation will provide an appropriate default value
+** for the resource tag; this function is provided so that an HPI User can
+** override the default, if desired. The value of the resource tag may be
+** retrieved from the resource's RPT entry.
+**
+** 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 the
+** resource tag.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiResourceTagSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiTextBufferT *ResourceTag
+);
+
+/*******************************************************************************
+**
+** Name: saHpiResourceIdGet()
+**
+** Description:
+** This function returns the ResourceId of the resource associated with the
+** entity upon which the HPI User is running.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [out] Pointer to location to hold the returned ResourceId.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the ResourceId pointer is passed
+** in as NULL.
+** SA_ERR_HPI_NOT_PRESENT is returned if the entity the HPI User 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 ResourceId 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 HPI User 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 ResourceId associated with a particular compute blade upon which
+** the HPI User 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 HPI User
+** was running. The function should return the ResourceId of the "smallest"
+** resource that is associated with the HPI User. So, in the example above,
+** the function should return the ResourceId of the compute blade.
+**
+** Once the function has returned the ResourceId, the HPI User 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: saHpiEventLogInfoGet()
+**
+** Description:
+** This function retrieves the current number of entries in the Event Log,
+** total size of the Event Log, the time of the most recent update to the
+** Event Log, the current value of the Event Log's clock (i.e., timestamp that
+** would be placed on an entry at this moment), the enabled/disabled status of
+** the Event Log (see Section 6.4.8 on page 57), the overflow flag, and the
+** action taken by the Event Log if an overflow occurs.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Identifier for the Resource containing the Event Log.
+** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log.
+** Info - [out] Pointer to the returned Event Log information.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event
+** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition
+** only applies to Resource Event Logs. Domain Event Logs are mandatory,
+** and should not return this code.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the Info pointer is passed in as
+** NULL.
+**
+** Remarks:
+** The size field in the returned Event Log information indicates the maximum
+** number of entries that can be held in the Event Log. This number should be
+** constant for a particular Event Log.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiEventLogInfoGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_OUT SaHpiEventLogInfoT *Info
+);
+
+/*******************************************************************************
+**
+** Name: saHpiEventLogEntryGet()
+**
+** Description:
+** This function retrieves an Event Log entry.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Identifier for the Resource containing the Event Log.
+** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log.
+** EntryId - [in] Identifier of event log entry to retrieve. Reserved values:
+** * SAHPI_OLDEST_ENTRY Oldest entry in the Event Log.
+** * SAHPI_NEWEST_ENTRY Newest entry in the Event Log.
+** * SAHPI_NO_MORE_ENTRIES Not valid for this parameter. Used only when
+** retrieving the next and previous EntryIds.
+** PrevEntryId - [out] Event Log entry identifier for the previous (older
+** adjacent) entry. Reserved 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 Event Log before the
+** one referenced by the EntryId parameter.
+** NextEntryId - [out] Event Log entry identifier for the next (newer
+** adjacent) entry. Reserved 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 Event 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 Log entry, if available. If NULL, no RDR data
+** will be returned.
+** RptEntry - [in/out] Pointer to structure to receive RPT entry associated
+** with the Event Log entry, 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event
+** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition
+** only applies to Resource Event Logs. Domain Event Logs are mandatory,
+** and should not return this code.
+** SA_ERR_HPI_NOT_PRESENT is returned when:
+** * The Event Log has no entries.
+** * The entry identified by EntryId is not present.
+** SA_ERR_HPI_INVALID_PARAMS is returned when:
+** * Any of PrevEntryId, NextEntryId and EventLogEntry pointers are passed
+** in as NULL.
+** * SAHPI_NO_MORE_ENTRIES is passed in to EntryId.
+**
+** Remarks:
+** The special EntryIds SAHPI_OLDEST_ENTRY and SAHPI_NEWEST_ENTRY are used to
+** select the oldest and newest entries, respectively, in the Event 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 Event 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 Event 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 Event 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.
+**
+** 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 Event Log. Because the system may be reconfigured after the
+** event was entered in the Event Log, this stored information may be
+** important to interpret the event. If the Event Log includes logged RPT
+** entries and/or RDRs, and if an HPI User provides a pointer to a structure
+** to receive this information, it will be returned along with the Event Log
+** entry.
+**
+** If an HPI User provides a pointer for an RPT entry, but the Event Log does
+** not include a logged RPT entry for the Event Log entry being returned,
+** RptEntry->ResourceCapabilities will be set to zero. No valid RptEntry will
+** have a zero Capabilities field value.
+**
+** If an HPI User provides a pointer for an RDR, but the Event Log does not
+** include a logged RDR for the Event Log entry being returned, Rdr->RdrType
+** will be set to SAHPI_NO_RECORD.
+**
+** The EntryIds returned via the PrevEntryId and NextEntryId parameters may
+** not be in sequential order, but will reflect the previous and next entries
+** in a chronological ordering of the Event Log, respectively.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiEventLogEntryGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiEventLogEntryIdT EntryId,
+ SAHPI_OUT SaHpiEventLogEntryIdT *PrevEntryId,
+ SAHPI_OUT SaHpiEventLogEntryIdT *NextEntryId,
+ SAHPI_OUT SaHpiEventLogEntryT *EventLogEntry,
+ SAHPI_INOUT SaHpiRdrT *Rdr,
+ SAHPI_INOUT SaHpiRptEntryT *RptEntry
+);
+
+/*******************************************************************************
+**
+** Name: saHpiEventLogEntryAdd()
+**
+** Description:
+** This function enables an HPI user to add entries to the Event Log.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Identifier for the Resource containing the Event Log.
+** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log.
+** EvtEntry - [in] Pointer to event data to write to the Event Log. The Event
+** field must be of type SAHPI_ET_USER, and the Source field must be
+** SAHPI_UNSPECIFIED_RESOURCE_ID.
+**
+** Return Value:
+** SA_OK is returned if the event is successfully written in the Event Log;
+** otherwise, an error code is returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event
+** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition
+** only applies to Resource Event Logs. Domain Event Logs are mandatory,
+** and should not return this code.
+** SA_ERR_HPI_INVALID_DATA is returned if the event DataLength is larger than
+** that supported by the implementation and reported in the Event Log info
+** record.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * EvtEntry pointer is passed in as NULL.
+** * Event structure passed via the EvtEntry parameter is not an event of
+** type SAHPI_ET_USER with the Source field set to
+** SAHPI_UNSPECIFIED_RESOURCE_ID.
+** * The Severity is not one of the valid enumerated values for this type.
+** * SaHpiTextBufferT structure passed as part of the User Event structure
+** is not valid. This would occur when:
+** * The DataType is not one of the enumerated values for that type, or
+** * The data field contains characters that are not legal according to
+** the value of DataType, or
+** * The Language is not one of the enumerated values for that type when
+** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT.
+** SA_ERR_HPI_OUT_OF_SPACE is returned if the event cannot be written to the
+** Event Log because the Event Log is full, and the Event Log
+** OverflowAction is SAHPI_EL_OVERFLOW_DROP.
+**
+** Remarks:
+** This function writes an event in the addressed Event Log. Nothing else is
+** done with the event.
+**
+** If the Event Log is full, overflow processing occurs as defined by the
+** Event Log's OverflowAction setting, reported in the Event Log info record.
+** If, due to an overflow condition, the event is not written, or if existing
+** events are overwritten, then the OverflowFlag in the Event Log info record
+** will be set, just as it would be if an internally generated event caused
+** an overflow condition. If the Event Log's OverflowAction is
+** SAHPI_EL_OVERFLOW_DROP, then an error will be returned
+** (SA_ERR_HPI_OUT_OF_SPACE) indicating that the saHpiEventLogEntryAdd()
+** function did not add the event to the Event Log. If the Event Log's
+** OverflowAction is SAHPI_EL_OVERFLOW_OVERWRITE, then the
+** saHpiEventLogEntryAdd() function will return SA_OK, indicating that the
+** event was added to the Event Log, even though an overflow occurred as a
+** side-effect of this operation. The overflow may be detected by checking
+** the OverflowFlag in the Event Log info record.
+**
+** Specific implementations of HPI may have restrictions on how much data may
+** be passed to the saHpiEventLogEntryAdd() function. The Event Log info
+** record reports the maximum DataLength that is supported by the Event Log
+** for User Events. If saHpiEventLogEntryAdd() is called with a User Event
+** that has a larger DataLength than is supported, the event will not be added
+** to the Event Log, and an error will be returned.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiEventLogEntryAdd (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiEventT *EvtEntry
+);
+
+/*******************************************************************************
+**
+** Name: saHpiEventLogClear()
+**
+** Description:
+** This function erases the contents of the specified Event Log.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Identifier for the Resource containing the Event Log.
+** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event
+** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition
+** only applies to Resource Event Logs. Domain Event Logs are mandatory,
+** and should not return this code
+**
+** Remarks:
+** The OverflowFlag field in the Event Log info record will be reset when this
+** function is called.
+**
+*******************************************************************************/
+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 clock. This
+** clock is used to timestamp entries written into the Event Log.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Identifier for the Resource containing the Event Log.
+** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log.
+** Time - [out] Pointer to the returned current Event Log time.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event
+** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition
+** only applies to Resource Event Logs. Domain Event Logs are mandatory,
+** and should not return this code.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the Time pointer is passed in as
+** NULL.
+**
+** Remarks:
+** 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, then it
+** is relative; if it is greater than SAHPI_TIME_MAX_RELATIVE, then it is
+** absolute. The HPI implementation must provide valid timestamps for Event
+** Log entries, using a default time base if no time has been set. Thus, the
+** value SAHPI_TIME_UNSPECIFIED is never returned.
+**
+*******************************************************************************/
+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 clock, which is used to timestamp events
+** written into the Event Log.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Identifier for the Resource containing the Event Log.
+** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log.
+** Time - [in] Time to which the Event Log clock should be set.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event
+** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition
+** only applies to Resource Event Logs. Domain Event Logs are mandatory,
+** and should not return this code.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the Time parameter is set to
+** SAHPI_TIME_UNSPECIFIED.
+** For situations when the underlying implementation cannot represent a time
+** value that is specified in Time, SA_ERR_HPI_INVALID_DATA is returned.
+**
+** Remarks:
+** If the Time parameter 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. Setting this parameter to the value SAHPI_TIME_UNSPECIFIED is
+** invalid and will result in an error return code of
+** SA_ERR_HPI_INVALID_PARAMS.
+**
+** Entries placed in the Event Log after this function is called will have
+** Event Log timestamps (i.e., the Timestamp field in the SaHpiEventLogEntryT
+** structure) based on the new time. Setting the clock does not affect
+** existing Event Log entries. If the time is set to a relative time,
+** subsequent entries placed in the Event Log will have an Event Log timestamp
+** expressed as a relative time; if the time is set to an absolute time,
+** subsequent entries will have an Event Log timestamp expressed as an
+** absolute time.
+**
+** This function only sets the Event Log time clock and does not have any
+** direct bearing on the timestamps placed on events (i.e., the Timestamp
+** field in the SaHpiEventT structure), or the timestamps placed in the domain
+** RPT info record. Setting the clocks used to generate timestamps other than
+** Event Log timestamps is implementation-dependent, and should be documented
+** by the HPI implementation provider.
+**
+** Some underlying implementations may not be able to handle the same relative
+** and absolute time ranges, as those defined in HPI. Such limitations will
+** be documented. When a time value is set in a region that is not supported
+** by the implementation, an error code of SA_ERR_HPI_INVALID_DATA will be
+** returned.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiEventLogTimeSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiTimeT Time
+);
+
+/*******************************************************************************
+**
+** Name: saHpiEventLogStateGet()
+**
+** Description:
+** This function enables an HPI User to get the Event Log state.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Identifier for the Resource containing the Event Log.
+** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log.
+** EnableState - [out] Pointer to the current Event Log enable state. True
+** indicates that the Event Log is enabled; False indicates that it is
+** disabled.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event
+** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition
+** only applies to Resource Event Logs. Domain Event Logs are mandatory,
+** and should not return this code.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the EnableState pointer is passed
+** in as NULL.
+**
+** Remarks:
+** 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.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiEventLogStateGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_OUT SaHpiBoolT *EnableState
+);
+
+/*******************************************************************************
+**
+** Name: saHpiEventLogStateSet()
+**
+** Description:
+** This function enables an HPI User to set the Event Log enabled state.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Identifier for the Resource containing the Event Log.
+** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log.
+** EnableState - [in] Event Log state to be set. True indicates that the Event
+** Log 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event
+** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition
+** only applies to Resource Event Logs. Domain Event Logs are mandatory,
+** and should not return this code.
+**
+** Remarks:
+** 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 an HPI User can override the default, if desired.
+**
+** 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.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiEventLogStateSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiBoolT EnableState
+);
+
+/*******************************************************************************
+**
+** Name: saHpiEventLogOverflowReset()
+**
+** Description:
+** This function resets the OverflowFlag in the Event Log info record of the
+** specified Event Log.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Identifier for the Resource containing the Event Log.
+** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_CMD is returned if the implementation does not support
+** independent clearing of the OverflowFlag on this Event Log.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event
+** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition
+** only applies to Resource Event Logs. Domain Event Logs are mandatory,
+** and should not return this code.
+**
+** Remarks:
+** The only effect of this function is to clear the OverflowFlag field in the
+** Event Log info record for the specified Event Log. If the Event Log is
+** still full, the OverflowFlag will be set again as soon as another entry
+** needs to be added to the Event Log.
+**
+** Some Event Log implementations may not allow resetting of the OverflowFlag
+** except as a by-product of clearing the entire Event Log with the
+** saHpiEventLogClear() function. Such an implementation will return the
+** error code, SA_ERR_HPI_INVALID_CMD to this function. The OverflowResetable
+** flag in the Event Log info record indicates whether or not the
+** implementation supports resetting the OverflowFlag without clearing the
+** Event Log.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiEventLogOverflowReset (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId
+);
+
+/*******************************************************************************
+**
+** Name: saHpiSubscribe()
+**
+** Description:
+** This function allows an HPI User to subscribe for events. This single call
+** provides subscription to all session events, regardless of event type or
+** event severity.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+**
+** 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:
+** Only one subscription is allowed per session, and additional subscribers
+** will receive an appropriate error code. No event filtering will be done by
+** the HPI implementation.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiSubscribe (
+ SAHPI_IN SaHpiSessionIdT SessionId
+);
+
+/*******************************************************************************
+**
+** Name: saHpiUnsubscribe()
+**
+** Description:
+** This function removes the event subscription for the session.
+**
+** 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 session is not currently
+** subscribed for events.
+**
+** Remarks:
+** After removal of a subscription, additional saHpiEventGet() calls will not
+** be allowed on the session unless an HPI User re-subscribes for events on
+** the session first. Any events that are still in the event queue when this
+** function is called will be cleared from it.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiUnsubscribe (
+ SAHPI_IN SaHpiSessionIdT SessionId
+);
+
+/*******************************************************************************
+**
+** Name: saHpiEventGet()
+**
+** Description:
+** This function allows an HPI User to get an event. This call is only valid
+** within a session that has subscribed for events.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** 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.
+** EventQueueStatus - [in/out] Pointer to location to store event queue
+** status. If NULL, event queue status will not be returned.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_REQUEST is returned if an HPI User is not currently
+** subscribed for events in this session.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * Event pointer is passed in as NULL.
+** * Timeout parameter is not set to SAHPI_TIMEOUT_BLOCK,
+** SAHPI_TIMEOUT_IMMEDIATE or a positive value.
+** 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:
+** SaHpiEventGet() will also return an EventQueueStatus flag to an HPI User.
+** This flag indicates whether or not a queue overflow has occurred. The
+** overflow flag is set if any events were unable to be queued because of
+** space limitations in the interface implementation. The overflow flag is
+** reset whenever saHpiEventGet() is called.
+**
+** 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 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, the saHpiEventGet() will block indefinitely, until
+** an event becomes available, and then return that event. This provides for
+** notification of events as they occur.
+**
+** If an HPI User provides a pointer for an RPT entry, but the event does not
+** include a valid ResourceId for a resource in the domain (e.g., OEM or USER
+** type event), then the RptEntry->ResourceCapabilities field will be set to
+** zero. No valid RPT entry will have a zero ResourceCapabilities.
+**
+** If an HPI User 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), then the Rdr->RdrType field 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.
+**
+** If an HPI User passes a NULL pointer for the returned EventQueueStatus
+** pointer, the event status will not be returned, but the overflow flag, if
+** set, will still be reset. Thus, if an HPI User needs to know about event
+** queue overflows, the EventQueueStatus parameter should never be NULL, and
+** the overflow flag should be checked after every call to saHpiEventGet().
+**
+** If saHpiEventGet() is called with a timeout value other than
+** SAHPI_TIMEOUT_IMMEDIATE, and the session is subsequently closed from
+** another thread, this function will return with SA_ERR_HPI_INVALID_SESSION.
+** If saHpiEventGet() is called with a timeout value other than
+** SAHPI_TIMEOUT_IMMEDIATE, and an HPI User subsequently calls
+** saHpiUnsubscribe() from another thread, this function will return with
+** SA_ERR_HPI_INVALID_REQUEST.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiEventGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiTimeoutT Timeout,
+ SAHPI_OUT SaHpiEventT *Event,
+ SAHPI_INOUT SaHpiRdrT *Rdr,
+ SAHPI_INOUT SaHpiRptEntryT *RptEntry,
+ SAHPI_INOUT SaHpiEvtQueueStatusT *EventQueueStatus
+);
+
+/*******************************************************************************
+**
+** Name: saHpiEventAdd()
+**
+** Description:
+** This function enables an HPI User to add events to the HPI domain
+** identified by the SessionId. The domain controller processes an event
+** added with this function as if the event originated from within the
+** domain. The domain controller will attempt to publish events to all active
+** event subscribers and will attempt to log events in the Domain Event Log,
+** if room is available.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** EvtEntry - [in] Pointer to event to add to the domain. Event must be of
+** type SAHPI_ET_USER, and the Source field must be
+** SAHPI_UNSPECIFIED_RESOURCE_ID.
+**
+** Return Value:
+** SA_OK is returned if the event is successfully added to the domain;
+** otherwise, an error code is returned.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * EvtEntry parameter is NULL.
+** * Event structure passed via the EvtEntry parameter is not an event of
+** type SAHPI_ET_USER with the Source field being
+** SAHPI_UNSPECIFIED_RESOURCE_ID.
+** * Event structure passed via the EvtEntry parameter has an invalid
+** Severity.
+** * SaHpiTextBufferT structure passed as part of the User Event structure
+** is not valid. This would occur when:
+** * The DataType is not one of the enumerated values for that type, or
+** * The data field contains characters that are not legal according to
+** the value of DataType, or
+** * The Language is not one of the enumerated values for that type when
+** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT.
+** SA_ERR_HPI_INVALID_DATA is returned if the event data does not meet
+** implementation-specific restrictions on how much event data may be
+** provided in a SAHPI_ET_USER event.
+**
+** Remarks:
+** Specific implementations of HPI may have restrictions on how much data may
+** be included in a SAHPI_ET_USER event. If more event data is provided than
+** can be processed, an error will be returned. The event data size
+** restriction for the SAHPI_ET_USER event type is provided in the
+** UserEventMaxSize field in the domain Event Log info structure. An HPI User
+** should call the function saHpiEventLogInfoGet() to retrieve the Event
+** Log info structure.
+**
+** The domain controller will attempt to publish the event to all sessions
+** within the domain with active event subscriptions; however, a session's
+** event queue may overflow due to the addition of the new event.
+**
+** The domain controller will attempt to log the event in the Domain Event
+** Log; however, the Domain Event Log may overflow due to the addition of the
+** new event
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiEventAdd (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiEventT *EvtEntry
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAlarmGetNext()
+**
+** Description:
+** This function allows retrieval of an alarm from the current set of alarms
+** held in the Domain Alarm Table (DAT).
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** Severity - [in] Severity level of alarms to retrieve. Set to
+** SAHPI_ALL_SEVERITIES to retrieve alarms of any severity; otherwise, set
+** to requested severity level.
+** UnacknowledgedOnly - [in] Set to True to indicate only unacknowledged
+** alarms should be returned. Set to False to indicate either an
+** acknowledged or unacknowledged alarm may be returned.
+** Alarm - [in/out] Pointer to the structure to hold the returned alarm entry.
+** Also, on input, Alarm->AlarmId and Alarm->Timestamp are used to
+** identify the previous alarm.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_PARAMS is returned when:
+** * Severity is not one of the valid enumerated values for this type.
+** * The Alarm parameter is passed in as NULL.
+** SA_ERR_HPI_NOT_PRESENT is returned:
+** * If there are no additional alarms in the DAT that meet the criteria
+** specified by the Severity and UnacknowledgedOnly parameters.
+** * If the passed Alarm->AlarmId field was set to SAHPI_FIRST_ENTRY and
+** there are no alarms in the DAT that meet the criteria specified by
+** the Severity and UnacknowledgedOnly parameters.
+** SA_ERR_HPI_INVALID_DATA is returned if the passed Alarm->AlarmId matches an
+** alarm in the DAT, but the passed Alarm->Timestamp does not match the
+** timestamp of that alarm.
+**
+** Remarks:
+** All alarms contained in the DAT are maintained in the order in which they
+** were added. This function will return the next alarm meeting the
+** specifications given by an HPI User that was added to the DAT after the
+** alarm whose AlarmId and Timestamp is passed by an HPI User, even if the
+** alarm associated with the AlarmId and Timestamp has been deleted. If
+** SAHPI_FIRST_ENTRY is passed as the AlarmId, the first alarm in the DAT
+** meeting the specifications given by an HPI User is returned.
+**
+** Alarm selection can be restricted to only alarms of a specified severity,
+** and/or only unacknowledged alarms.
+**
+** To retrieve all alarms contained within the DAT meeting specific
+** requirements, call saHpiAlarmGetNext() with the Alarm->AlarmId field set to
+** SAHPI_FIRST_ENTRY and the Severity and UnacknowledgedOnly parameters set to
+** select what alarms should be returned. Then, repeatedly call
+** saHpiAlarmGetNext() passing the previously returned alarm as the Alarm
+** parameter, and the same values for Severity and UnacknowledgedOnly until
+** the function returns with the error code SA_ERR_HPI_NOT_PRESENT.
+**
+** SAHPI_FIRST_ENTRY and SAHPI_LAST_ENTRY are reserved AlarmId values, and
+** will never be assigned to an alarm in the DAT.
+**
+** The elements AlarmId and Timestamp are used in the Alarm parameter to
+** identify the previous alarm; the next alarm added to the table after this
+** alarm that meets the Severity and UnacknowledgedOnly requirements will be
+** returned. Alarm->AlarmId may be set to SAHPI_FIRST_ENTRY to select the
+** first alarm in the DAT meeting the Severity and UnacknowledgedOnly
+** requirements. If Alarm->AlarmId is SAHPI_FIRST_ENTRY, then
+** Alarm->Timestamp is ignored.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAlarmGetNext(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiSeverityT Severity,
+ SAHPI_IN SaHpiBoolT UnacknowledgedOnly,
+ SAHPI_INOUT SaHpiAlarmT *Alarm
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAlarmGet()
+**
+** Description:
+** This function allows retrieval of a specific alarm in the Domain Alarm
+** Table (DAT) by referencing its AlarmId.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** AlarmId - [in] AlarmId of the alarm to be retrieved from the DAT.
+** Alarm - [out] Pointer to the structure to hold the returned alarm entry.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_NOT_PRESENT is returned if the requested AlarmId does not
+** correspond to an alarm contained in the DAT.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the Alarm parameter is passed in
+** as NULL.
+**
+** Remarks:
+** SAHPI_FIRST_ENTRY and SAHPI_LAST_ENTRY are reserved AlarmId values, and
+** will never be assigned to an alarm in the DAT.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAlarmGet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiAlarmIdT AlarmId,
+ SAHPI_OUT SaHpiAlarmT *Alarm
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAlarmAcknowledge()
+**
+** Description:
+** This function allows an HPI User to acknowledge a single alarm entry or a
+** group of alarm entries by severity.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** AlarmId - [in] Identifier of the alarm to be acknowledged. Reserved
+** AlarmId values:
+** * SAHPI_ENTRY_UNSPECIFIED Ignore this parameter.
+** Severity - [in] Severity level of alarms to acknowledge. Ignored unless
+** AlarmId is SAHPI_ENTRY_UNSPECIFIED.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_NOT_PRESENT is returned if an alarm entry identified by the
+** AlarmId parameter does not exist in the DAT.
+** SA_ERR_HPI_INVALID_PARAMS is returned if AlarmId is SAHPI_ENTRY_UNSPECIFIED
+** and Severity is not one of the valid enumerated values for this type.
+**
+** Remarks:
+** An HPI User acknowledges an alarm to indicate that it is aware of the alarm
+** and to influence platform-specific alarm annunciation that may be provided
+** by the implementation. Typically, an implementation ignores acknowledged
+** alarms when announcing an alarm on annunciation devices such as audible
+** sirens and dry contact closures. However, alarm annunciation is
+** implementation-specific.
+**
+** An acknowledged alarm will have the Acknowledged field in the alarm entry
+** set to True.
+**
+** Alarms are acknowledged by one of two ways: a single alarm entry by AlarmId
+** regardless of severity or as a group of alarm entries by Severity
+** regardless of AlarmId.
+**
+** To acknowledge all alarms contained within the DAT, set the Severity
+** parameter to SAHPI_ALL_SEVERITIES, and set the AlarmId parameter to
+** SAHPI_ENTRY_UNSPECIFIED.
+**
+** To acknowledge all alarms of a specific severity contained within the DAT,
+** set the Severity parameter to the appropriate value, and set the AlarmId
+** parameter to SAHPI_ENTRY_UNSPECIFIED.
+**
+** To acknowledge a single alarm entry, set the AlarmId parameter to a value
+** other than SAHPI_ENTRY_UNSPECIFIED. The AlarmId must be a valid identifier
+** for an alarm entry present in the DAT at the time of the function call.
+**
+** If an alarm has been previously acknowledged, acknowledging it again has no
+** effect. However, this is not an error.
+**
+** If the AlarmId parameter has a value other than SAHPI_ENTRY_UNSPECIFIED,
+** the Severity parameter is ignored.
+**
+** If the AlarmId parameter is passed as SAHPI_ENTRY_UNSPECIFIED, and no
+** alarms are present that meet the requested Severity, this function will
+** have no effect. However, this is not an error.
+**
+** SAHPI_ENTRY_UNSPECIFIED is defined as the same value as SAHPI_FIRST_ENTRY,
+** so using either symbol will have the same effect. However,
+** SAHPI_ENTRY_UNSPECIFIED should be used with this function for clarity.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAlarmAcknowledge(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiAlarmIdT AlarmId,
+ SAHPI_IN SaHpiSeverityT Severity
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAlarmAdd()
+**
+** Description:
+** This function is used to add a User Alarm to the DAT.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** Alarm - [in/out] Pointer to the alarm entry structure that contains the new
+** User Alarm to add to the DAT.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the Alarm pointer is passed in
+** as NULL.
+** SA_ERR_HPI_INVALID_PARAMS is returned when Alarm->Severity is not one of
+** the following enumerated values: SAHPI_MINOR, SAHPI_MAJOR, or
+** SAHPI_CRITICAL.
+** SA_ERR_HPI_INVALID_PARAMS is returned when Alarm->AlarmCond.Type is not
+** SAHPI_STATUS_COND_TYPE_USER.
+** SA_ERR_HPI_OUT_OF_SPACE is returned if the DAT is not able to add an
+** additional User Alarm due to space limits or limits imposed on the
+** number of User Alarms permitted in the DAT.
+**
+** Remarks:
+** The AlarmId, and Timestamp fields within the Alarm parameter are not used
+** by this function. Instead, on successful completion, these fields are set
+** to new values associated with the added alarm.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAlarmAdd(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_INOUT SaHpiAlarmT *Alarm
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAlarmDelete()
+**
+** Description:
+** This function allows an HPI User to delete a single User Alarm or a group
+** of User Alarms from the DAT. Alarms may be deleted individually by
+** specifying a specific AlarmId, or they may be deleted as a group by
+** specifying a Severity.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** AlarmId - [in] Alarm identifier of the alarm entry to delete. Reserved
+** values:
+** * SAHPI_ENTRY_UNSPECIFIED Ignore this parameter.
+** Severity - [in] Severity level of alarms to delete. Ignored unless AlarmId
+** is SAHPI_ENTRY_UNSPECIFIED.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_PARAMS is returned if AlarmId is SAHPI_ENTRY_UNSPECIFIED
+** and Severity is not one of the valid enumerated values for this type.
+** SA_ERR_HPI_NOT_PRESENT is returned if an alarm entry identified by the
+** AlarmId parameter does not exist in the DAT.
+** SA_ERR_HPI_READ_ONLY is returned if the AlarmId parameter indicates a
+** non-User Alarm.
+**
+** Remarks:
+** Only User Alarms added to the DAT can be deleted. When deleting alarms by
+** severity, only User Alarms of the requested severity will be deleted.
+**
+** To delete a single, specific alarm, set the AlarmId parameter to a value
+** representing an actual User Alarm in the DAT. The Severity parameter is
+** ignored when the AlarmId parameter is set to a value other than
+** SAHPI_ENTRY_UNSPECIFIED.
+**
+** To delete a group of User Alarms, set the AlarmId parameter to
+** SAHPI_ENTRY_UNSPECIFIED, and set the Severity parameter to identify which
+** severity of alarms should be deleted. To clear all User Alarms contained
+** within the DAT, set the Severity parameter to SAHPI_ALL_SEVERITIES.
+**
+** If the AlarmId parameter is passed as SAHPI_ENTRY_UNSPECIFIED, and no User
+** Alarms are present that meet the specified Severity, this function will
+** have no effect. However, this is not an error.
+**
+** SAHPI_ENTRY_UNSPECIFIED is defined as the same value as SAHPI_FIRST_ENTRY,
+** so using either symbol will have the same effect. However,
+** SAHPI_ENTRY_UNSPECIFIED should be used with this function for clarity.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAlarmDelete(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiAlarmIdT AlarmId,
+ SAHPI_IN SaHpiSeverityT Severity
+);
+
+/*******************************************************************************
+**
+** Name: saHpiRdrGet()
+**
+** Description:
+** This function returns a resource data record from the addressed resource.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** EntryId - [in] Identifier of the RDR entry to retrieve. Reserved EntryId
+** 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 EntryId 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource contains no RDR records
+** (and thus does not have the SAHPI_CAPABILITY_RDR flag set in its RPT
+** entry).
+** SA_ERR_HPI_NOT_PRESENT is returned if an EntryId (other than
+** SAHPI_FIRST_ENTRY) is passed that does not correspond to an actual
+** EntryId in the resource's RDR repository.
+** SA_ERR_HPI_INVALID_PARAMS is returned if:
+** * SAHPI_LAST_ENTRY is passed in to EntryId.
+** * NextEntryId pointer is passed in as NULL.
+** * Rdr pointer is passed in as NULL.
+**
+** Remarks:
+** 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.
+**
+** 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: saHpiRdrGetByInstrumentId()
+**
+** Description:
+** This function returns the Resource Data Record (RDR) for a specific
+** management instrument hosted by the addressed resource.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** RdrType - [in] Type of RDR being requested.
+** InstrumentId - [in] Instrument number identifying the specific RDR to be
+** returned. This is a sensor number, control number, watchdog timer
+** number, IDR number, or annunciator number, depending on the value of
+** the RdrType parameter.
+** Rdr - [out] Pointer to the structure to receive the requested RDR.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the:
+** * Resource contains no RDR records (and thus does not have the
+** SAHPI_CAPABILITY_RDR flag set in its RPT entry).
+** * Type of management instrument specified in the RdrType parameter is
+** not supported by the resource, as indicated by the Capability field
+** in its RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the specific management instrument
+** identified in the InstrumentId parameter is not present in the addressed
+** resource.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the:
+** * RdrType parameter is not a valid enumerated value for the type.
+** * RdrType is SAHPI_NO_RECORD.
+** * Rdr pointer is passed in as NULL.
+**
+** Remarks:
+** The RDR to be returned is identified by RdrType (sensor, control, watchdog
+** timer, inventory data repository, or annunciator) and InstrumentId (sensor
+** number, control number, watchdog number, IDR number, or annunciator number)
+** for the specific management instrument for the RDR being requested.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiRdrGetByInstrumentId (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiRdrTypeT RdrType,
+ SAHPI_IN SaHpiInstrumentIdT InstrumentId,
+ SAHPI_OUT SaHpiRdrT *Rdr
+);
+
+/*******************************************************************************
+**
+** Name: saHpiSensorReadingGet()
+**
+** Description:
+** This function is used to retrieve a sensor reading.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** SensorNum - [in] Sensor number for which the sensor reading is being
+** retrieved.
+** Reading - [in/out] Pointer to a structure to receive sensor reading values
+** If NULL, the sensor reading value will not be returned.
+** EventState - [in/out] Pointer to location to receive sensor event states.
+** If NULL, the sensor event states will not be returned.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors,
+** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry.
+** SA_ERR_HPI_INVALID_REQUEST is returned if the sensor is currently disabled.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+**
+** Remarks:
+** For sensors that return a type of SAHPI_SENSOR_READING_TYPE_BUFFER, the
+** format of the returned data buffer is implementation-specific.
+**
+** If the sensor does not provide a reading, the Reading structure returned by
+** the saHpiSensorReadingGet() function will indicate the reading is not
+** supported by setting the IsSupported flag to False.
+**
+** If the sensor does not support any event states, a value of 0x0000 will be
+** returned for the EventState value. This is indistinguishable from the
+** return for a sensor that does support event states, but currently has no
+** event states asserted. The Sensor RDR Events field can be examined to
+** determine if the sensor supports any event states.
+**
+** It is legal for both the Reading parameter and the EventState parameter to
+** be NULL. In this case, no data is returned other than the return code.
+** This can be used to determine if a sensor is present and enabled without
+** actually returning current sensor data. If the sensor is present and
+** enabled, SA_OK is returned; otherwise, an error code is returned.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiSensorReadingGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiSensorNumT SensorNum,
+ SAHPI_INOUT SaHpiSensorReadingT *Reading,
+ SAHPI_INOUT SaHpiEventStateT *EventState
+);
+
+/*******************************************************************************
+**
+** Name: saHpiSensorThresholdsGet()
+**
+** Description:
+** This function retrieves the thresholds for the given sensor.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors,
+** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the SensorThresholds pointer is
+** passed in as NULL.
+** SA_ERR_HPI_INVALID_CMD is returned if:
+** * Getting a threshold on a sensor that is not a threshold type.
+** * The sensor does not have any readable threshold values.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+**
+** Remarks:
+** This function only applies to sensors that support readable thresholds, as
+** indicated by the IsAccessible field in the SaHpiSensorThdDefnT structure
+** of the sensor's RDR being set to True and the ReadThold field in the same
+** structure having a non-zero value.
+**
+** For thresholds that do not apply to the identified sensor, the IsSupported
+** flag of the threshold value field will be set to False.
+**
+*******************************************************************************/
+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] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_INVALID_DATA is returned if any of the threshold values are
+** provided in a format not supported by the sensor.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors,
+** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+** SA_ERR_HPI_INVALID_CMD is returned when:
+** * Writing to a threshold that is not writable.
+** * Setting a threshold on a sensor that is not a threshold type as
+** indicated by the IsAccessible field of the SaHpiSensorThdDefnT
+** structure.
+** * Setting a threshold outside of the Min-Max range as defined by the
+** Range field of the SensorDataFormat of the RDR.
+** SA_ERR_HPI_INVALID_DATA is returned when:
+** * Thresholds are set out-of-order (see Remarks).
+** * A negative hysteresis value is provided.
+**
+** Remarks:
+** This function only applies to sensors that support writable thresholds,
+** as indicated by the IsAccessible field in the SaHpiSensorThdDefnT
+** structure of the sensor's RDR being set to True and the WriteThold field
+** in the same structure having a non-zero value.
+**
+** The type of value provided for each threshold setting must correspond to
+** the reading format supported by the sensor, as defined by the reading type
+** in the DataFormat field of the sensor's RDR (saHpiSensorRecT).
+**
+** Sensor thresholds cannot be set outside of the range defined by the Range
+** field of the SensorDataFormat of the Sensor RDR. If SAHPI_SRF_MAX
+** indicates that a maximum reading exists, no sensor threshold may be set
+** greater than the Max value. If SAHPI_SRF_MIN indicates that a minimum
+** reading exists, no sensor threshold may be set less than the Min value.
+**
+** Thresholds are required to be set progressively in-order, so that
+** Upper Critical >= Upper Major >= Upper Minor >= Lower Minor >= Lower Major
+** >= Lower Critical.
+**
+*******************************************************************************/
+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] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors,
+** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * Type pointer is passed in as NULL.
+** * Category pointer is passed in as NULL.
+**
+** 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: saHpiSensorEnableGet()
+**
+** Description:
+** This function returns the current sensor enable status for an addressed
+** sensor.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** SensorNum - [in] Sensor number for which the sensor enable status is being
+** requested.
+** SensorEnabled - [out] Pointer to the location to store the sensor enable
+** status.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors,
+** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the SensorEnabled pointer is set
+** to NULL.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+**
+** Remarks:
+** The SaHpiBoolT value pointed to by the SensorEnabled parameter will be set
+** to True if the sensor is enabled, or False if the sensor is disabled.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiSensorEnableGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiSensorNumT SensorNum,
+ SAHPI_OUT SaHpiBoolT *SensorEnabled
+);
+
+/*******************************************************************************
+**
+** Name: saHpiSensorEnableSet()
+**
+** Description:
+** This function sets the sensor enable status for an addressed sensor.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** SensorNum - [in] Sensor number for which the sensor enable status is being
+** set.
+** SensorEnabled - [in] Sensor enable status to be set for the sensor.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors,
+** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+** SA_ERR_HPI_READ_ONLY is returned if the sensor does not support changing
+** the enable status (i.e., the EnableCtrl field in the Sensor RDR is set
+** to False).
+**
+** Remarks:
+** If a sensor is disabled, any calls to saHpiSensorReadingGet() for that
+** sensor will return an error, and no events will be generated for the
+** sensor.
+**
+** Calling saHpiSensorEnableSet() with a SensorEnabled parameter of True
+** will enable the sensor. A SensorEnabled parameter of False will disable
+** the sensor.
+**
+** If the sensor enable status changes as the result of this function call,
+** an event will be generated.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiSensorEnableSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiSensorNumT SensorNum,
+ SAHPI_IN SaHpiBoolT SensorEnabled
+);
+
+/*******************************************************************************
+**
+** Name: saHpiSensorEventEnableGet()
+**
+** Description:
+** This function returns the current sensor event enable status for an
+** addressed sensor.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** SensorNum - [in] Sensor number for which the sensor event enable status is
+** being requested.
+** SensorEventsEnabled - [out] Pointer to the location to store the sensor
+** event enable status.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors,
+** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the SensorEventsEnabled pointer
+** is set to NULL.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+**
+** Remarks:
+** The SaHpiBoolT value pointed to by the SensorEventsEnabled parameter will
+** be set to True if event generation for the sensor is enabled, or False if
+** event generation for the sensor is disabled.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiSensorEventEnableGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiSensorNumT SensorNum,
+ SAHPI_OUT SaHpiBoolT *SensorEventsEnabled
+);
+
+/*******************************************************************************
+**
+** Name: saHpiSensorEventEnableSet()
+**
+** Description:
+** This function sets the sensor event enable status for an addressed sensor.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** SensorNum - [in] Sensor number for which the sensor enable status is being
+** set.
+** SensorEventsEnabled - [in] Sensor event enable status to be set for the
+** sensor.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors,
+** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+** SA_ERR_HPI_READ_ONLY is returned if the sensor does not support changing
+** the event enable status (i.e., the EventCtrl field in the Sensor RDR is
+** set to SAHPI_SEC_READ_ONLY).
+**
+** Remarks:
+** If event generation for a sensor is disabled, no events will be generated
+** as a result of the assertion or deassertion of any event state, regardless
+** of the setting of the assert or deassert event masks for the sensor. If
+** event generation for a sensor is enabled, events will be generated when
+** event states are asserted or deasserted, according to the settings of the
+** assert and deassert event masks for the sensor. Event states may still be
+** read for a sensor even if event generation is disabled, by using the
+** saHpiSensorReadingGet() function.
+**
+** Calling saHpiSensorEventEnableSet() with a SensorEventsEnabled parameter
+** of True will enable event generation for the sensor. A SensorEventsEnabled
+** parameter of False will disable event generation for the sensor.
+**
+** If the sensor event enabled status changes as a result of this function
+** call, an event will be generated.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiSensorEventEnableSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiSensorNumT SensorNum,
+ SAHPI_IN SaHpiBoolT SensorEventsEnabled
+);
+
+/*******************************************************************************
+**
+** Name: saHpiSensorEventMasksGet()
+**
+** Description:
+** This function returns the assert and deassert event masks for a sensor.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** SensorNum - [in] Sensor number for which the event enable configuration is
+** being requested.
+** AssertEventMask - [in/out] Pointer to location to store sensor assert event
+** mask. If NULL, assert event mask is not returned.
+** DeassertEventMask - [in/out] Pointer to location to store sensor deassert
+** event mask. If NULL, deassert event mask is not returned.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** sensors, as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT
+** entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+**
+** Remarks:
+** Two bit-mask values are returned by the saHpiSensorEventMasksGet()
+** function; one for the sensor assert event mask, and one for the sensor
+** deassert event mask. A bit set to '1' in the AssertEventMask value
+** indicates that an event will be generated by the sensor when the
+** corresponding event state for that sensor changes from deasserted to
+** asserted. A bit set to '1' in the DeassertEventMask value indicates that
+** an event will be generated by the sensor when the corresponding event
+** state for that sensor changes from asserted to deasserted.
+**
+** Events will only be generated by the sensor if the appropriate
+** AssertEventMask or DeassertEventMask bit is set, sensor events are
+** enabled, and the sensor is enabled.
+**
+** For sensors hosted by resources that have the
+** SAHPI_CAPABILITY_EVT_DEASSERTS flag set in its RPT entry, the
+** AssertEventMask and the DeassertEventMask values will always be the same.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiSensorEventMasksGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiSensorNumT SensorNum,
+ SAHPI_INOUT SaHpiEventStateT *AssertEventMask,
+ SAHPI_INOUT SaHpiEventStateT *DeassertEventMask
+);
+
+/*******************************************************************************
+**
+** Name: saHpiSensorEventMasksSet()
+**
+** Description:
+** This function provides the ability to change the settings of the sensor
+** assert and deassert event masks. Two parameters contain bit-mask values
+** indicating which bits in the sensor assert and deassert event masks should
+** be updated. In addition, there is an Action parameter.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** SensorNum - [in] Sensor number for which the event enable configuration
+** is being set.
+** Action - [in] Enumerated value describing what change should be made to
+** the sensor event masks:
+** * SAHPI_SENS_ADD_EVENTS_TO_MASKS - for each bit set in the
+** AssertEventMask and DeassertEventMask parameters, set the
+** corresponding bit in the sensor's assert and deassert event masks,
+** respectively.
+** * SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS - for each bit set in the
+** AssertEventMask and DeassertEventMask parameters, clear the
+** corresponding bit in the sensor's assert and deassert event masks,
+** respectively.
+** AssertEventMask - [in] Bit mask or special value indicating which bits in
+** the sensor's assert event mask should be set or cleared. (But see
+** Remarks concerning resources with the SAHPI_EVT_DEASSERTS_CAPABILITY
+** flag set.)
+** DeassertEventMask - [in] Bit mask or special value indicating which bits
+** in the sensor's deassert event mask should be set or cleared. (But see
+** Remarks concerning resources with the SAHPI_EVT_DEASSERTS_CAPABILITY
+** flag set.)
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** sensors, as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT
+** entry.
+** SA_ERR_HPI_INVALID_DATA is returned if the Action parameter is
+** SAHPI_SENS_ADD_EVENTS_TO_MASKS, and either of the AssertEventMask or
+** DeassertEventMask parameters include a bit for an event state that is
+** not supported by the sensor.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the Action parameter is out of
+** range.
+** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present.
+** SA_ERR_HPI_READ_ONLY is returned if the sensor does not support updating
+** the assert and deassert event masks (i.e., the EventCtrl field in the
+** Sensor RDR is set to SAHPI_SEC_READ_ONLY_MASKS or SAHPI_SEC_READ_ONLY).
+**
+** Remarks:
+** The bits in the sensor assert and deassert event masks that correspond to
+** '1' bits in the bit-mask parameters will be set or cleared, as indicated
+** by the Action parameter. The bits in the sensor assert and deassert event
+** masks corresponding to '0' bits in the bit-mask parameters will be
+** unchanged.
+**
+** Assuming that a sensor is enabled and event generation for the sensor is
+** enabled, then for each bit set in the sensor's assert event mask, an event
+** will be generated when the sensor's corresponding event state changes from
+** deasserted to asserted. Similarly, for each bit set in the sensor's
+** deassert event mask, an event will be generated when the sensor's
+** corresponding event state changes from asserted to deasserted.
+**
+** For sensors hosted by a resource that has the
+** SAHPI_CAPABILITY_EVT_DEASSERTS flag set in its RPT entry, the assert and
+** deassert event masks cannot be independently configured. When
+** saHpiSensorEventMasksSet() is called for sensors in a resource with this
+** capability, the DeassertEventMask parameter is ignored, and the
+** AssertEventMask parameter is used to determine which bits to set or clear
+** in both the assert event mask and deassert event mask for the sensor.
+**
+** The AssertEventMask or DeassertEventMask parameter may be set to the
+** special value, SAHPI_ALL_EVENT_STATES, indicating that all event states
+** supported by the sensor should be added to or removed from, the
+** corresponding sensor event mask.
+**
+** If the sensor assert and/or deassert event masks change as a result of
+** this function call, an event will be generated.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiSensorEventMasksSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiSensorNumT SensorNum,
+ SAHPI_IN SaHpiSensorEventMaskActionT Action,
+ SAHPI_IN SaHpiEventStateT AssertEventMask,
+ SAHPI_IN SaHpiEventStateT DeassertEventMask
+);
+
+/*******************************************************************************
+**
+** Name: saHpiControlTypeGet()
+**
+** Description:
+** This function retrieves the control type of a control object.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** CtrlNum - [in] Control number for which the type is being retrieved.
+** 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** controls, as indicated by SAHPI_CAPABILITY_CONTROL in the resource's
+** RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the control is not present.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the Type pointer is passed in as
+** NULL.
+**
+** 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: saHpiControlGet()
+**
+** Description:
+** This function retrieves the current state and mode of a control object.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** CtrlNum - [in] Control number for which the state and mode are being
+** retrieved.
+** CtrlMode - [out] Pointer to the mode of the control. If NULL, the
+** control's mode will not be returned.
+** 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.
+** If NULL, the control's state will not be returned.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_INVALID_CMD is returned if the control is a write-only control,
+** as indicated by the WriteOnly flag in the control's RDR (see remarks).
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** controls, as indicated by the SAHPI_CAPABILITY_CONTROL in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_DATA is returned if the addressed control is a text
+** control, and the line number passed in CtrlState->StateUnion.Text.Line
+** does not exist in the control and is not SAHPI_TLN_ALL_LINES.
+** SA_ERR_HPI_NOT_PRESENT is returned if the control is not present.
+**
+** Remarks:
+** Note that the CtrlState parameter is both an input and an output parameter
+** for this function. This is necessary to support line number inputs for
+** text controls, as discussed below.
+**
+** In some cases, the state of a control may be set, but the corresponding
+** state cannot be read at a later time. Such controls are delineated with
+** the WriteOnly flag in the Control's RDR.
+**
+** 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 saHpiControlGet() via
+** CtrlState->StateUnion.Text.Line; the contents of that line of the control
+** will be returned in CtrlState->StateUnion.Text.Text. The first line of
+** the text control is line number "1".
+**
+** If the line number passed in is SAHPI_TLN_ALL_LINES, then
+** saHpiControlGet() 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.
+**
+** Write-only controls allow the control's state to be set, but the control
+** state cannot be subsequently read. Such controls are indicated in the RDR,
+** when the WriteOnly flag is set. SA_ERR_HPI_INVALID_CMD is returned when
+** calling this function for a write-only control.
+**
+** It is legal for both the CtrlMode parameter and the CtrlState parameter to
+** be NULL. In this case, no data is returned other than the return code.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiControlGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiCtrlNumT CtrlNum,
+ SAHPI_OUT SaHpiCtrlModeT *CtrlMode,
+ SAHPI_INOUT SaHpiCtrlStateT *CtrlState
+);
+
+/*******************************************************************************
+**
+** Name: saHpiControlSet()
+**
+** Description:
+** This function is used for setting the state and/or mode of the specified
+** control object.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** CtrlNum - [in] Control number for which the state and/or mode is being set.
+** CtrlMode - [in] The mode to set on the control.
+** 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** controls, as indicated by the SAHPI_CAPABILITY_CONTROL in the
+** resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the control is not present.
+** SA_ERR_HPI_INVALID_DATA is returned when the:
+** * CtrlState->Type field is not the correct type for the control
+** identified by the CtrlNum parameter.
+** * CtrlState->StateUnion.Analog is out of range of the control record's
+** analog Min and Max values.
+** * CtrlState->StateUnion.Text.Text.DataLength, combined with the
+** CtrlState->StateUnion.Text.Line, overflows the remaining text
+** control space.
+** * CtrlState->StateUnion.Text.Text.DataType is not set to the DataType
+** specified in the RDR.
+** * DataType specified in the RDR is SAHPI_TL_TYPE_UNICODE or
+** SAHPI_TL_TYPE_TEXT and CtrlState->StateUnion.Text.Text.Language is
+** not set to the Language specified in the RDR.
+** * OEM control data is invalid (see remarks below).
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * CtrlMode is not one of the valid enumerated values for this type.
+** * CtrlMode parameter is not SAHPI_CTRL_MODE_AUTO and the CtrlState
+** pointer is passed in as NULL.
+** * CtrlState->StateUnion.Digital is not one of the valid enumerated
+** values for this type.
+** * CtrlState->StateUnion.Stream.StreamLength is bigger than
+** SAHPI_CTRL_MAX_STREAM_LENGTH.
+** * SaHpiTextBufferT structure passed as CtrlState->StateUnion.Text.Text
+** contains text characters that are not allowed according to the value
+** of CtrlState->StateUnion.Text.Text.DataType.
+** SA_ERR_HPI_INVALID_REQUEST is returned when SAHPI_CTRL_STATE_PULSE_ON is
+** issued to a digital control, which is ON (in either manual or auto
+** mode). It is also returned when SAHPI_CTRL_STATE_PULSE_OFF is issued
+** to a digital control, which is OFF (in either manual or auto mode).
+** SA_ERR_HPI_READ_ONLY is returned when attempting to change the mode of a
+** control with a read-only mode.
+**
+** Remarks:
+** When the mode is set to SAHPI_CTRL_MODE_AUTO, the state input is ignored.
+** Ignored state inputs are not checked by the implementation.
+**
+** The CtrlState parameter must be of the correct type for the specified
+** control.
+**
+** If the CtrlMode parameter is set to SAHPI_CTRL_MODE_AUTO, then the
+** CtrlState parameter is not evaluated, and may be set to any value by an
+** HPI User, including a NULL pointer. 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. The first line of the text control is line
+** number "1". 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
+** saHpiControlSet() repeatedly for each line, or (b) call saHpiControlSet()
+** once and send more characters than will fit on one line. An HPI User
+** 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 saHpiControlSet() for a text control, an HPI User 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 1.
+** (This is different from simply writing at line 1, 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 RDR.
+**
+** The ManufacturerId (MId) field of an OEM control is ignored by the
+** implementation when calling saHpiControlSet().
+**
+** On an OEM control, it is up to the implementation to determine what is
+** invalid data, and to return the specified error code.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiControlSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiCtrlNumT CtrlNum,
+ SAHPI_IN SaHpiCtrlModeT CtrlMode,
+ SAHPI_IN SaHpiCtrlStateT *CtrlState
+);
+
+/*******************************************************************************
+**
+** Name: saHpiIdrInfoGet()
+**
+** Description:
+** This function returns the Inventory Data Repository information including
+** the number of areas contained within the IDR and the update counter. The
+** Inventory Data Repository is associated with a specific entity.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** IdrId - [in] Identifier for the Inventory Data Repository.
+** IdrInfo - [out] Pointer to the information describing the requested
+** Inventory Data Repository.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an
+** inventory data repository, as indicated by
+** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the IDR is not present.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the IdrInfo pointer is passed in
+** as NULL.
+**
+** Remarks:
+** The update counter provides a means for insuring that no additions or
+** changes are missed when retrieving the IDR data. In order to use this
+** feature, an HPI User should invoke the saHpiIdrInfoGet(), and retrieve the
+** update counter value before retrieving the first Area. After retrieving
+** all Areas and Fields of the IDR, an HPI User should again invoke the
+** saHpiIdrInfoGet() to get the update counter value. If the update counter
+** value has not been incremented, no modification or additions were made to
+** the IDR during data retrieval.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiIdrInfoGet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiIdrIdT IdrId,
+ SAHPI_OUT SaHpiIdrInfoT *IdrInfo
+);
+
+/*******************************************************************************
+**
+** Name: saHpiIdrAreaHeaderGet()
+**
+** Description:
+** This function returns the Inventory Data Area header information for a
+** specific area associated with a particular Inventory Data Repository.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** IdrId - [in] Identifier for the Inventory Data Repository.
+** AreaType - [in] Type of Inventory Data Area.
+** AreaId - [in] Identifier of Area entry to retrieve from the IDR. Reserved
+** AreaId values:
+** * SAHPI_FIRST_ENTRY Get first entry.
+** * SAHPI_LAST_ENTRY Reserved as a delimiter for end of list. Not a
+** valid AreaId.
+** NextAreaId - [out] Pointer to location to store the AreaId of next area of
+** the requested type within the IDR.
+** Header - [out] Pointer to Inventory Data Area Header into which the header
+** information will be placed.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an
+** inventory data repository, as indicated by
+** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the:
+** * IDR is not present.
+** * AreaType parameter is set to SAHPI_IDR_AREATYPE_UNSPECIFIED, and the
+** area specified by the AreaId parameter does not exist in the IDR.
+** * AreaType parameter is set to a specific area type, but an area
+** matching both the AreaId parameter and AreaType parameter does not
+** exist.
+** SA_ERR_HPI_INVALID_PARAMS is returned if:
+** * AreaType is not one of the valid enumerated values for this type.
+** * The AreaId is an invalid reserved value such as SAHPI_LAST_ENTRY.
+** * The NextAreaId pointer is passed in as NULL.
+** * The Header pointer is passed in as NULL.
+**
+** Remarks:
+** This function allows retrieval of an Inventory Data Area Header by one of
+** two ways: by AreaId regardless of type or by AreaType and AreaId.
+**
+** To retrieve all areas contained within an IDR, set the AreaType parameter
+** to SAHPI_IDR_AREATYPE_UNSPECIFIED, and set the AreaId parameter to
+** SAHPI_FIRST_ENTRY for the first call. For each subsequent call, set the
+** AreaId parameter to the value returned in the NextAreaId parameter.
+** Continue calling this function until the NextAreaId parameter contains the
+** value SAHPI_LAST_ENTRY.
+**
+** To retrieve areas of specific type within an IDR, set the AreaType
+** parameter to a valid AreaType enumeration. Use the AreaId parameter in
+** the same manner described above to retrieve all areas of the specified
+** type. Set the AreaId parameter to SAHPI_FIRST_ENTRY to retrieve the first
+** area of that type. Use the value returned in NextAreaId to retrieve the
+** remaining areas of that type until SAHPI_LAST_ENTRY is returned.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiIdrAreaHeaderGet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiIdrIdT IdrId,
+ SAHPI_IN SaHpiIdrAreaTypeT AreaType,
+ SAHPI_IN SaHpiEntryIdT AreaId,
+ SAHPI_OUT SaHpiEntryIdT *NextAreaId,
+ SAHPI_OUT SaHpiIdrAreaHeaderT *Header
+);
+
+/*******************************************************************************
+**
+** Name: saHpiIdrAreaAdd()
+**
+** Description:
+** This function is used to add an Area to the specified Inventory Data
+** Repository.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** IdrId - [in] Identifier for the Inventory Data Repository.
+** AreaType - [in] Type of Area to add.
+** AreaId- [out] Pointer to location to store the AreaId of the newly created
+** area.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an
+** inventory data repository, as indicated by
+** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the IDR is not present.
+** SA_ERR_HPI_INVALID_DATA is returned when attempting to add an area with an
+** AreaType of SAHPI_IDR_AREATYPE_UNSPECIFIED or when adding an area that
+** does not meet the implementation-specific restrictions.
+** SA_ERR_HPI_OUT_OF_SPACE is returned if the IDR does not have enough free
+** space to allow the addition of the area.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * AreaId pointer is passed in as NULL.
+** * AreaType is not one of the valid enumerated values for this type.
+** SA_ERR_HPI_READ_ONLY is returned if the IDR is read-only and does not
+** allow the addition of the area.
+**
+** Remarks:
+** On successful completion, the AreaId parameter will contain the AreaId of
+** the newly created area.
+**
+** On successful completion, the ReadOnly element in the new Area's header
+** will always be False.
+**
+** SAHPI_IDR_AREATYPE_UNSPECIFIED is not a valid area type, and should not be
+** used with this function. If SAHPI_IDR_AREATYPE_UNSPECIFIED is specified
+** as the area type, an error code of SA_ERR_HPI_INVALID_DATA is returned.
+** This area type is only valid when used with the saHpiIdrAreaHeaderGet()
+** function to retrieve areas of an unspecified type.
+**
+** Some implementations may restrict the types of areas that may be added.
+** These restrictions should be documented. SA_ERR_HPI_INVALID_DATA is
+** returned when attempting to add an invalid area type.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiIdrAreaAdd(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiIdrIdT IdrId,
+ SAHPI_IN SaHpiIdrAreaTypeT AreaType,
+ SAHPI_OUT SaHpiEntryIdT *AreaId
+);
+
+/*******************************************************************************
+**
+** Name: saHpiIdrAreaDelete()
+**
+** Description:
+** This function is used to delete an Inventory Data Area, including the Area
+** header and all fields contained with the area, from a particular Inventory
+** Data Repository.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** IdrId - [in] Identifier for the Inventory Data Repository.
+** AreaId - [in] Identifier of Area entry to delete from the IDR.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an
+** inventory data repository, as indicated by
+** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the:
+** * IDR is not present.
+** * Area identified by the AreaId parameter does not exist within the IDR.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the AreaId is an invalid
+** reserved value such as SAHPI_LAST_ENTRY.
+** SA_ERR_HPI_READ_ONLY is returned if the:
+** * IDA is read-only and therefore cannot be deleted.
+** * IDA contains a read-only Field and therefore cannot be deleted.
+** * IDR is read-only as deletions are not permitted for an area from a
+** read-only IDR.
+**
+** Remarks:
+** Deleting an Inventory Data Area also deletes all fields contained within
+** the area.
+**
+** In some implementations, certain Areas are intrinsically read-only. The
+** ReadOnly flag, in the area header, indicates if the Area is read-only.
+**
+** If the Inventory Data Area is not read-only, but contains a Field that is
+** read-only, the Area cannot be deleted. An attempt to delete an Area that
+** contains a read-only Field will return an error.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiIdrAreaDelete(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiIdrIdT IdrId,
+ SAHPI_IN SaHpiEntryIdT AreaId
+);
+
+/*******************************************************************************
+**
+** Name: saHpiIdrFieldGet()
+**
+** Description:
+** This function returns the Inventory Data Field information from a
+** particular Inventory Data Area and Repository.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** IdrId - [in] Identifier for the Inventory Data Repository.
+** AreaId - [in] Area identifier for the IDA.
+** FieldType - [in] Type of Inventory Data Field.
+** FieldId - [in] Identifier of Field to retrieve from the IDA. Reserved
+** FieldId values:
+** * SAHPI_FIRST_ENTRY Get first entry.
+** * SAHPI_LAST_ENTRY Reserved as a delimiter for end of list. Not
+** a valid FieldId.
+** NextFieldId - [out] Pointer to location to store the FieldId of next field
+** of the requested type in the IDA.
+** Field - [out] Pointer to Inventory Data Field into which the field
+** information will be placed.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an
+** inventory data repository, as indicated by
+** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the:
+** * IDR is not present.
+** * Area identified by AreaId is not present.
+** * FieldType parameter is set to SAHPI_IDR_FIELDTYPE_UNSPECIFIED, and
+** the field specified by the FieldId parameter does not exist in the
+** IDA.
+** * FieldType parameter is set to a specific field type, but a field
+** matching both the FieldId parameter and FieldType parameter does not
+** exist.
+** SA_ERR_HPI_INVALID_PARAMS is returned if:
+** * FieldType is not one of the valid enumerated values for this type.
+** * The AreaId or FieldId is an invalid reserved value such as
+** SAHPI_LAST_ENTRY.
+** * The NextFieldId pointer is passed in as NULL.
+** * The Field pointer is passed in as NULL.
+**
+** Remarks:
+** This function allows retrieval of an Inventory Data Field by one of two
+** ways: by FieldId regardless of type or by FieldType and FieldId.
+**
+** To retrieve all fields contained within an IDA, set the FieldType parameter
+** to SAHPI_IDR_FIELDTYPE_UNSPECIFIED, and set the FieldId parameter to
+** SAHPI_FIRST_ENTRY for the first call. For each subsequent call, set the
+** FieldId parameter to the value returned in the NextFieldId parameter.
+** Continue calling this function until the NextFieldId parameter contains the
+** value SAHPI_LAST_ENTRY.
+**
+** To retrieve fields of a specific type within an IDA, set the FieldType
+** parameter to a valid Field type enumeration. Use the FieldId parameter in
+** the same manner described above to retrieve all fields of the specified
+** type. Set the FieldId parameter to SAHPI_FIRST_ENTRY to retrieve the first
+** field of that type. Use the value returned in NextFieldId to retrieve the
+** remaining fields of that type until SAHPI_LAST_ENTRY is returned.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiIdrFieldGet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiIdrIdT IdrId,
+ SAHPI_IN SaHpiEntryIdT AreaId,
+ SAHPI_IN SaHpiIdrFieldTypeT FieldType,
+ SAHPI_IN SaHpiEntryIdT FieldId,
+ SAHPI_OUT SaHpiEntryIdT *NextFieldId,
+ SAHPI_OUT SaHpiIdrFieldT *Field
+);
+
+/*******************************************************************************
+**
+** Name: saHpiIdrFieldAdd()
+**
+** Description:
+** This function is used to add a field to the specified Inventory Data Area
+** with a specific Inventory Data Repository.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** IdrId - [in] Identifier for the Inventory Data Repository.
+** Field - [in/out] Pointer to Inventory Data Field, which contains the new
+** field information to add to the IDA.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an
+** inventory data repository, as indicated by
+** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the:
+** * IDR is not present.
+** * Area identified by Field?AreaId does not exist within the IDR.
+** SA_ERR_HPI_INVALID_DATA is returned if the Field data is incorrectly
+** formatted or does not meet the restrictions for the implementation.
+** SA_ERR_HPI_OUT_OF_SPACE is returned if the IDR does not have enough free
+** space to allow the addition of the field.
+** SA_ERR_HPI_READ_ONLY is returned if the:
+** * Area identified by Field?AreaId is read-only and does not allow
+** modification to its fields.
+** * IDR is identified by IdrId, is read-only, and does not allow
+** modification to its fields.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * The Field type is not one of the valid field type enumerated values.
+** * Field type, Field?Type, is set to SAHPI_IDR_FIELDTYPE_UNSPECIFIED.
+** * SaHpiTextBufferT structure passed as part of the Field parameter is
+** not valid. This occurs when:
+** * The DataType is not one of the enumerated values for that type, or
+** * The data field contains characters that are not legal according to
+** the value of DataType, or
+** * The Language is not one of the enumerated values for that type
+** when the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT.
+** * Field pointer is passed in as NULL.
+**
+** Remarks:
+** The FieldId element within the Field parameter is not used by this
+** function. Instead, on successful completion, the FieldId field is set to
+** the new value associated with the added Field.
+**
+** The ReadOnly element in the Field parameter is not used by this function.
+** On successful completion, the ReadOnly element in the new Field will
+** always be False.
+**
+** Addition of a read-only Inventory Data Field is not allowed; therefore the
+** ReadOnly element in the SaHpiIdrFieldT parameter is ignored.
+**
+** SAHPI_IDR_FIELDTYPE_UNSPECIFIED is not a valid field type, and should not
+** be used with this function. If SAHPI_IDR_FIELDTYPE_UNSPECIFIED is
+** specified as the field type, an error code of SA_ERR_HPI_INVALID_DATA is
+** returned. This field type is only valid when used with the
+** saHpiIdrFieldGet() function to retrieve fields of an unspecified type.
+**
+** Some implementations have restrictions on what fields are valid in specific
+** areas and/or the data format of some fields. These restrictions should be
+** documented. SA_ERR_HPI_INVALID_DATA is returned when the field type or
+** field data does not meet the implementation-specific restrictions.
+**
+** The AreaId element within the Field parameter identifies the specific IDA
+** into which the new field is added.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiIdrFieldAdd(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiIdrIdT IdrId,
+ SAHPI_INOUT SaHpiIdrFieldT *Field
+);
+
+/*******************************************************************************
+**
+** Name: saHpiIdrFieldSet()
+**
+** Description:
+** This function is used to update an Inventory Data Field for a particular
+** Inventory Data Area and Repository.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** IdrId - [in] Identifier for the Inventory Data Repository.
+** Field - [in] Pointer to Inventory Data Field, which contains the updated
+** field information.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an
+** inventory data repository, as indicated by
+** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the:
+** * IDR is not present.
+** * Area identified by Field?AreaId does not exist within the IDR or if
+** the Field does not exist within the Inventory Data Area.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the:
+** * Field pointer is passed in as NULL.
+** * Field type, Field?Type, is not set to one of the valid field type
+** enumerated values.
+** * Field type, Field?Type, is set to SAHPI_IDR_FIELDTYPE_UNSPECIFIED.
+** SA_ERR_HPI_INVALID_DATA is returned if the field data is incorrectly
+** formatted or does not meet the restrictions for the implementation.
+** SA_ERR_HPI_OUT_OF_SPACE is returned if the IDR does not have enough free
+** space to allow the modification of the field due to an increase in the
+** field size.
+** SA_ERR_HPI_READ_ONLY is returned if the:
+** * Field is read-only and does not allow modifications.
+** * Area is read-only and does not allow modifications to its fields.
+** * IDR is read-only and does not allow modifications to its fields.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the SaHpiTextBufferT structure
+** passed as part of the Field parameter is not valid. This occurs when:
+** * The DataType is not one of the enumerated values for that type, or
+** * The data field contains characters that are not legal according to
+** the value of DataType, or
+** * The Language is not one of the enumerated values for that type when
+** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT.
+**
+** Remarks:
+** This function allows modification of both the FieldType and Field data of
+** a given Inventory Data Field. This function does not allow modification of
+** the read-only attribute of the Inventory Data Field; therefore after a
+** successful update, the ReadOnly element in the updated Field will always be
+** False. The input value for ReadOnly is ignored.
+**
+** SAHPI_IDR_FIELDTYPE_UNSPECIFIED is not a valid field type, and should not
+** be used with this function. If SAHPI_IDR_FIELDTYPE_UNSPECIFIED is
+** specified as the new field type, an error code of SA_ERR_HPI_INVALID_DATA
+** is returned. This field type is only valid when used with the
+** saHpiIdrFieldGet() function to retrieve fields of an unspecified type.
+**
+** Some implementations have restrictions on what fields are valid in specific
+** areas and/or the data format of some fields. These restrictions should be
+** documented. SA_ERR_HPI_INVALID_DATA is returned when the field type or
+** field data does not meet the implementation-specific restrictions.
+**
+** In some implementations, certain Fields are intrinsically read-only. The
+** ReadOnly flag, in the field structure, indicates if the Field is read-only.
+**
+** The Field to update is identified by the AreaId and FieldId elements within
+** the Field parameter.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiIdrFieldSet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiIdrIdT IdrId,
+ SAHPI_IN SaHpiIdrFieldT *Field
+);
+
+/*******************************************************************************
+**
+** Name: saHpiIdrFieldDelete()
+**
+** Description:
+** This function is used to delete an Inventory Data Field from a particular
+** Inventory Data Area and Repository.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** IdrId - [in] Identifier for the Inventory Data Repository.
+** AreaId - [in] Area identifier for the IDA.
+** FieldId - [in] Identifier of Field to delete from the IDA.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an
+** inventory data repository, as indicated by
+** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the:
+** * IDR is not present.
+** * Area identified by the AreaId parameter does not exist within the IDR,
+** or if the Field identified by the FieldId parameter does not exist
+** within the IDA.
+** SA_ERR_HPI_READ_ONLY is returned if the field, the IDA, or the IDR is
+** read-only and does not allow deletion.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the AreaId or FieldId is an
+** invalid reserved value such as SAHPI_LAST_ENTRY.
+**
+** Remarks:
+** In some implementations, certain fields are intrinsically read-only. The
+** ReadOnly flag, in the field structure, indicates if the field is read-only.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiIdrFieldDelete(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiIdrIdT IdrId,
+ SAHPI_IN SaHpiEntryIdT AreaId,
+ SAHPI_IN SaHpiEntryIdT FieldId
+);
+
+/*******************************************************************************
+**
+** Name: saHpiWatchdogTimerGet()
+**
+** Description:
+** This function retrieves the current watchdog timer settings and
+** configuration.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** WatchdogNum - [in] 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support a
+** watchdog timer, as indicated by SAHPI_CAPABILITY_WATCHDOG in the
+** resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the WatchdogNum is not present.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the Watchdog pointer is passed
+** in as NULL.
+**
+** Remarks:
+** See the description of the SaHpiWatchdogT structure in Section 8.11 on
+** page 180 for details on what information is returned by this function.
+**
+** When the watchdog action is SAHPI_WA_RESET, the type of reset (warm or
+** cold) is implementation-dependent.
+**
+*******************************************************************************/
+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 been set using
+** saHpiWatchdogTimerSet(), an HPI User must then call
+** saHpiWatchdogTimerReset() to initially start the watchdog timer, unless
+** the watchdog timer was already running prior to calling
+** saHpiWatchdogTimerSet() and the Running field in the passed Watchdog
+** structure is True.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support a
+** watchdog timer, as indicated by SAHPI_CAPABILITY_WATCHDOG in the
+** resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the WatchdogNum is not present.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the:
+** * Watchdog->TimerUse is not one of the valid enumerated values for this
+** type.
+** * Watchdog->TimerAction is not one of the valid enumerated values for
+** this type.
+** * Watchdog->PretimerInterrupt is not one of the valid enumerated values
+** for this type.
+** * Watchdog pointer is passed in as NULL.
+** SA_ERR_HPI_INVALID_DATA is returned when the:
+** * Watchdog->PreTimeoutInterval is outside the acceptable range for the
+** implementation.
+** * Watchdog->InitialCount is outside the acceptable range for the
+** implementation.
+** * Value of Watchdog->PreTimeoutInterval is greater than the value of
+** Watchdog->InitialCount.
+** * Watchdog->PretimerInterrupt is set to an unsupported value. See
+** remarks.
+** * Watchdog->TimerAction is set to an unsupported value. See remarks.
+** * Watchdog->TimerUse is set to an unsupported value. See remarks.
+**
+** Remarks:
+** Configuring the watchdog timer with the saHpiWatchdogTimerSet() function
+** does not start the timer running. If the timer was previously stopped
+** when this function is called, then it will remain stopped, and must be
+** started by calling saHpiWatchdogTimerReset(). If the timer was previously
+** running, then it will continue to run if the Watchdog->Running field passed
+** is True, or will be stopped if the Watchdog->Running field passed is False.
+** If it continues to run, it will restart its count-down from the newly
+** configured initial count value.
+**
+** If the initial counter value is set to 0, then any configured pre-timer
+** interrupt action or watchdog timer expiration action will be taken
+** immediately when the watchdog timer is started. 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.
+**
+** Some implementations impose a limit on the acceptable ranges for the
+** PreTimeoutInterval or InitialCount. These limitations must be documented.
+** SA_ERR_HPI_INVALID_DATA is returned if an attempt is made to set a value
+** outside of the supported range.
+**
+** Some implementations cannot accept all of the enumerated values for
+** TimerUse, TimerAction, or PretimerInterrupt. These restrictions should be
+** documented. SA_ERR_HPI_INVALID_DATA is returned if an attempt is made to
+** select an unsupported option.
+**
+** When the watchdog action is set to SAHPI_WA_RESET, the type of reset (warm
+** or cold) is implementation-dependent.
+**
+*******************************************************************************/
+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] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support a
+** watchdog timer, as indicated by SAHPI_CAPABILITY_WATCHDOG in the
+** resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the WatchdogNum is not present.
+** SA_ERR_HPI_INVALID_REQUEST is returned if the current watchdog state does
+** not allow a reset.
+**
+** 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: saHpiAnnunciatorGetNext()
+**
+** Description:
+** This function allows retrieval of an announcement from the current set of
+** announcements held in the Annunciator.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator.
+** Severity - [in] Severity level of announcements to retrieve. Set to
+** SAHPI_ALL_SEVERITIES to retrieve announcement of any severity;
+** otherwise, set to requested severity level.
+** UnacknowledgedOnly - [in] Set to True to indicate only unacknowledged
+** announcements should be returned. Set to False to indicate either an
+** acknowledged or unacknowledged announcement may be returned.
+** Announcement - [in/out] Pointer to the structure to hold the returned
+** announcement. Also, on input, Announcement->EntryId and
+** Announcement->Timestamp are used to identify the "previous"
+** announcement.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned when Severity is not one of the
+** valid enumerated values for this type.
+** SA_ERR_HPI_NOT_PRESENT is returned if:
+** * The AnnunciatorNum passed does not address a valid Annunciator
+** supported by the resource.
+** * There are no announcements (or no unacknowledged announcements if
+** UnacknowledgedOnly is True) that meet the specified Severity in the
+** current set after the announcement identified by
+** Announcement->EntryId and Announcement->Timestamp.
+** * There are no announcements (or no unacknowledged announcements if
+** UnacknowledgedOnly is True) that meet the specified Severity in the
+** current set if the passed Announcement->EntryId field was set to
+** SAHPI_FIRST_ENTRY.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the Announcement parameter is
+** passed in as NULL.
+** SA_ERR_HPI_INVALID_DATA is returned if the passed Announcement->EntryId
+** matches an announcement in the current set, but the passed
+** Announcement->Timestamp does not match the timestamp of that announcement.
+**
+** Remarks:
+** All announcements contained in the set are maintained in the order in which
+** they were added. This function will return the next announcement meeting
+** the specifications given by an HPI User that was added to the set after the
+** announcement whose EntryId and timestamp is passed by an HPI User. If
+** SAHPI_FIRST_ENTRY is passed as the EntryId, the first announcement in the
+** set meeting the specifications given by an HPI User is returned. This
+** function should operate even if the announcement associated with the
+** EntryId and Timestamp passed by an HPI User has been deleted.
+**
+** Selection can be restricted to only announcements of a specified severity,
+** and/or only unacknowledged announcements. To retrieve all announcements
+** contained meeting specific requirements, call saHpiAnnunciatorGetNext()
+** with the Status->EntryId field set to SAHPI_FIRST_ENTRY and the Severity
+** and UnacknowledgedOnly parameters set to select what announcements should
+** be returned. Then, repeatedly call saHpiAnnunciatorGetNext() passing the
+** previously returned announcement as the Announcement parameter, and the
+** same values for Severity and UnacknowledgedOnly until the function returns
+** with the error code SA_ERR_HPI_NOT_PRESENT.
+**
+** SAHPI_FIRST_ENTRY and SAHPI_LAST_ENTRY are reserved EntryId values, and
+** will never be assigned to an announcement.
+**
+** The elements EntryId and Timestamp are used in the Announcement parameter
+** to identify the "previous" announcement; the next announcement added to the
+** table after this announcement that meets the Severity and
+** UnacknowledgedOnly requirements will be returned. Announcement->EntryId
+** may be set to SAHPI_FIRST_ENTRY to select the first announcement in the
+** current set meeting the Severity and UnacknowledgedOnly requirements. If
+** Announcement->EntryId is SAHPI_FIRST_ENTRY, then Announcement->Timestamp
+** is ignored.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAnnunciatorGetNext(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,
+ SAHPI_IN SaHpiSeverityT Severity,
+ SAHPI_IN SaHpiBoolT UnacknowledgedOnly,
+ SAHPI_INOUT SaHpiAnnouncementT *Announcement
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAnnunciatorGet()
+**
+** Description:
+** This function allows retrieval of a specific announcement in the
+** Annunciator's current set by referencing its EntryId.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained
+** using saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator.
+** EntryId - [in] Identifier of the announcement to retrieve from the
+** Annunciator.
+** Announcement - [out] Pointer to the structure to hold the returned
+** announcement.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the
+** resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if:
+** * The AnnunciatorNum passed does not address a valid Annunciator
+** supported by the resource.
+** * The requested EntryId does not correspond to an announcement
+** contained in the Annunciator.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the Announcement parameter is
+** passed in as NULL.
+**
+** Remarks:
+** SAHPI_FIRST_ENTRY and SAHPI_LAST_ENTRY are reserved EntryId values, and
+** will never be assigned to announcements.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAnnunciatorGet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,
+ SAHPI_IN SaHpiEntryIdT EntryId,
+ SAHPI_OUT SaHpiAnnouncementT *Announcement
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAnnunciatorAcknowledge()
+**
+** Description:
+** This function allows an HPI User to acknowledge a single announcement or a
+** group of announcements by severity.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator.
+** EntryId - [in] Entry identifier of the announcement to acknowledge.
+** Reserved EntryId values:
+** * SAHPI_ENTRY_UNSPECIFIED Ignore this parameter.
+** Severity - [in] Severity level of announcements to acknowledge. Ignored
+** unless EntryId is SAHPI_ENTRY_UNSPECIFIED.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the
+** resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if:
+** * The AnnunciatorNum passed does not address a valid Annunciator
+** supported by the resource.
+** * An announcement identified by the EntryId parameter does not exist in
+** the current set.
+** SA_ERR_HPI_INVALID_PARAMS is returned if EntryId is SAHPI_ENTRY_UNSPECIFIED
+** and Severity is not one of the valid enumerated values for this type.
+**
+** Remarks:
+** Announcements are acknowledged by one of two ways: a single announcement
+** by EntryId regardless of severity or as a group of announcements by
+** severity regardless of EntryId.
+**
+** An HPI User acknowledges an announcement to influence the platform-specific
+** annunciation provided by the Annunciator management instrument.
+**
+** An acknowledged announcement will have the Acknowledged field set to True.
+**
+** To acknowledge all announcements contained within the current set, set the
+** Severity parameter to SAHPI_ALL_SEVERITIES, and set the EntryId parameter
+** to SAHPI_ENTRY_UNSPECIFIED.
+**
+** To acknowledge all announcements of a specific severity, set the Severity
+** parameter to the appropriate value, and set the EntryId parameter to
+** SAHPI_ENTRY_UNSPECIFIED.
+**
+** To acknowledge a single announcement, set the EntryId parameter to a value
+** other than SAHPI_ENTRY_UNSPECIFIED. The EntryId must be a valid identifier
+** for an announcement present in the current set.
+**
+** If an announcement has been previously acknowledged, acknowledging it again
+** has no effect. However, this is not an error.
+**
+** If the EntryId parameter has a value other than SAHPI_ENTRY_UNSPECIFIED,
+** the Severity parameter is ignored.
+**
+** If the EntryId parameter is passed as SAHPI_ENTRY_UNSPECIFIED, and no
+** announcements are present that meet the requested Severity, this function
+** will have no effect. However, this is not an error.
+**
+** SAHPI_ENTRY_UNSPECIFIED is defined as the same value as SAHPI_FIRST_ENTRY,
+** so using either symbol will have the same effect. However,
+** SAHPI_ENTRY_UNSPECIFIED should be used with this function for clarity.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAnnunciatorAcknowledge(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,
+ SAHPI_IN SaHpiEntryIdT EntryId,
+ SAHPI_IN SaHpiSeverityT Severity
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAnnunciatorAdd()
+**
+** Description:
+** This function is used to add an announcement to the set of items held by an
+** Annunciator management instrument.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator.
+** Announcement - [in/out] Pointer to structure that contains the new
+** announcement to add to the set.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the
+** resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the AnnunciatorNum passed does not
+** address a valid Annunciator supported by the resource.
+** SA_ERR_HPI_INVALID_PARAMS is returned when:
+** * The Announcement pointer is passed in as NULL.
+** * The Announcement->Severity passed is not valid.
+** * The Announcement->StatusCond structure passed in is not valid.
+** SA_ERR_HPI_OUT_OF_SPACE is returned if the Annunciator is not able to add
+** an additional announcement due to resource limits.
+** SA_ERR_HPI_READ_ONLY is returned if the Annunciator is in auto mode.
+**
+** Remarks:
+** The EntryId, Timestamp, and AddedByUser fields within the Announcement
+** parameter are not used by this function. Instead, on successful
+** completion, these fields are set to new values associated with the added
+** announcement. AddedByUser will always be set to True.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAnnunciatorAdd(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,
+ SAHPI_INOUT SaHpiAnnouncementT *Announcement
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAnnunciatorDelete()
+**
+** Description:
+** This function allows an HPI User to delete a single announcement or a group
+** of announcements from the current set of an Annunciator. Announcements may
+** be deleted individually by specifying a specific EntryId, or they may be
+** deleted as a group by specifying a severity.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator.
+** EntryId - [in] Entry identifier of the announcement to delete. Reserved
+** EntryId values:
+** * SAHPI_ENTRY_UNSPECIFIED Ignore this parameter.
+** Severity - [in] Severity level of announcements to delete. Ignored unless
+** EntryId is SAHPI_ENTRY_UNSPECIFIED.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned if EntryId is SAHPI_ENTRY_UNSPECIFIED
+** and Severity is not one of the valid enumerated values for this type.
+** SA_ERR_HPI_NOT_PRESENT is returned if:
+** * The AnnunciatorNum passed does not address a valid Annunciator
+** supported by the resource
+** * An announcement identified by the EntryId parameter does not exist in
+** the current set of the Annunciator.
+** SA_ERR_HPI_READ_ONLY is returned if the Annunciator is in auto mode.
+**
+** Remarks:
+** To delete a single, specific announcement, set the EntryId parameter to a
+** value representing an actual announcement in the current set. The Severity
+** parameter is ignored when the EntryId parameter is set to a value other
+** than SAHPI_ENTRY_UNSPECIFIED.
+**
+** To delete a group of announcements, set the EntryId parameter to
+** SAHPI_ENTRY_UNSPECIFIED, and set the Severity parameter to identify which
+** severity of announcements should be deleted. To clear all announcements
+** contained within the Annunciator, set the Severity parameter to
+** SAHPI_ALL_SEVERITIES.
+**
+** If the EntryId parameter is passed as SAHPI_ENTRY_UNSPECIFIED, and no
+** announcements are present that meet the specified Severity, this function
+** will have no effect. However, this is not an error.
+**
+** SAHPI_ENTRY_UNSPECIFIED is defined as the same value as SAHPI_FIRST_ENTRY,
+** so using either symbol will have the same effect. However,
+** SAHPI_ENTRY_UNSPECIFIED should be used with this function for clarity.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAnnunciatorDelete(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,
+ SAHPI_IN SaHpiEntryIdT EntryId,
+ SAHPI_IN SaHpiSeverityT Severity
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAnnunciatorModeGet()
+**
+** Description:
+** This function allows an HPI User to retrieve the current operating mode of
+** an Annunciator. The mode indicates whether or not an HPI User is allowed to
+** add or delete items in the set, and whether or not the HPI implementation
+** will automatically add or delete items in the set.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator.
+** Mode - [out] Pointer to location to store the current operating mode of the
+** Annunciator where the returned value will be one of the following:
+** * SAHPI_ANNUNCIATOR_MODE_AUTO - the HPI implementation may add or delete
+** announcements in the set; an HPI User may not add or delete
+** announcements in the set.
+** * SAHPI_ANNUNCIATOR_MODE_USER - the HPI implementation may not add or
+** delete announcements in the set; an HPI User may add or delete
+** announcements in the set.
+** * SAHPI_ANNUNCIATOR_MODE_SHARED - both the HPI implementation and an HPI
+** User may add or delete announcements in the set.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the
+** resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the AnnunciatorNum passed does not
+** address a valid Annunciator supported by the resource.
+** SA_ERR_HPI_INVALID_PARAMS is returned if Mode is passed in as NULL.
+**
+** Remarks:
+** None.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAnnunciatorModeGet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,
+ SAHPI_OUT SaHpiAnnunciatorModeT *Mode
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAnnunciatorModeSet()
+**
+** Description:
+** This function allows an HPI User to change the current operating mode of an
+** Annunciator. The mode indicates whether or not an HPI User is allowed to
+** add or delete announcements in the set, and whether or not the HPI
+** implementation will automatically add or delete announcements in the set.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator.
+** Mode - [out] Mode to set for the Annunciator:
+** * SAHPI_ANNUNCIATOR_MODE_AUTO - the HPI implementation may add or delete
+** announcements in the set; an HPI User may not add or delete
+** announcements in the set.
+** * SAHPI_ANNUNCIATOR_MODE_USER - the HPI implementation may not add or
+** delete announcements in the set; an HPI User may add or delete
+** announcements in the set.
+** * SAHPI_ANNUNCIATOR_MODE_SHARED - both the HPI implementation and an HPI
+** User may add or delete announcements in the set.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the
+** resource's RPT entry.
+** SA_ERR_HPI_NOT_PRESENT is returned if the AnnunciatorNum passed does not
+** address a valid Annunciator supported by the resource.
+** SA_ERR_HPI_INVALID_PARAMS is returned if Mode is not a valid enumerated
+** value for this type.
+** SA_ERR_HPI_READ_ONLY is returned if mode changing is not permitted for
+** this Annunciator.
+**
+** Remarks:
+** None.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAnnunciatorModeSet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum,
+ SAHPI_IN SaHpiAnnunciatorModeT Mode
+);
+
+/*******************************************************************************
+**
+** Name: saHpiHotSwapPolicyCancel()
+**
+** 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 an HPI User, after receiving a hot swap event with
+** HotSwapState equal to SAHPI_HS_STATE_INSERTION_PENDING or
+** SAHPI_HS_STATE_EXTRACTION_PENDING, to prevent the default policy from
+** being executed.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** managed hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in
+** the resource's RPT entry.
+** SA_ERR_HPI_INVALID_REQUEST is returned if the resource is:
+** * Not in the INSERTION PENDING or EXTRACTION PENDING state.
+** * Processing an auto-insertion or auto-extraction policy.
+**
+** Remarks:
+** Each time the resource transitions to either the INSERTION PENDING or
+** EXTRACTION PENDING state, the default policies will execute after the
+** configured timeout period, unless cancelled using
+** saHpiHotSwapPolicyCancel() after the transition to INSERTION PENDING or
+** EXTRACTION PENDING state and before the timeout expires.The default policy
+** cannot be canceled once it has begun to execute.
+**
+** 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.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiHotSwapPolicyCancel (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId
+);
+
+/*******************************************************************************
+**
+** Name: saHpiResourceActiveSet()
+**
+** Description:
+** This function allows an HPI User to request a resource to transition to the
+** ACTIVE state from the INSERTION PENDING or EXTRACTION PENDING state.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed
+** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_REQUEST is returned if the resource is:
+** * Not in the INSERTION PENDING or EXTRACTION PENDING state.
+** * Processing an auto-insertion or auto-extraction policy.
+**
+** Remarks:
+** During insertion, a resource supporting hot swap will generate an event to
+** indicate that it is in the INSERTION PENDING state. If an HPI User calls
+** saHpiHotSwapPolicyCancel() before the resource begins an auto-insert
+** operation, then the resource will remain in INSERTION PENDING state while
+** an HPI User acts on the resource to integrate it into the system. During
+** this state, an HPI 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, if the resource
+** has those associated capabilities. Once an HPI User has completed with the
+** integration of the FRU, this function must be called to signal that the
+** resource should now transition into the ACTIVE state.
+**
+** An HPI User may also use this function to request a resource to return to
+** the ACTIVE 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.
+**
+** 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:
+** This function allows an HPI User to request a resource to transition to the
+** INACTIVE state from the INSERTION PENDING or EXTRACTION PENDING state.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed
+** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_REQUEST is returned if the resource is:
+** * Not in the INSERTION PENDING or EXTRACTION PENDING state.
+** * Processing an auto-insertion or auto-extraction policy.
+**
+** Remarks:
+** During extraction, a resource supporting hot swap will generate an event
+** to indicate that it is in the EXTRACTION PENDING state. If an HPI User
+** calls saHpiHotSwapPolicyCancel() before the resource begins an auto-extract
+** operation, then the resource will remain in EXTRACTION PENDING state while
+** an HPI User acts on the resource to isolate the associated FRU from the
+** system. During this state, an HPI 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, if the resource
+** has these associated capabilities. Once an HPI User has completed the
+** shutdown of the FRU, this function must be called to signal that the
+** resource should now transition into the INACTIVE state.
+**
+** An HPI 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.
+**
+** 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 an HPI User to request the auto-insert timeout value
+** within a specific domain. This value indicates how long the resource will
+** wait before the default auto-insertion policy is invoked.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** Timeout - [out] Pointer to location to store the number of nanoseconds to
+** wait before autonomous handling of the hot swap event. Reserved time
+** outvalues:
+** * 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.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the Timeout pointer is passed in
+** as NULL.
+**
+** Remarks:
+** Each domain maintains a single auto-insert timeout value and it is applied
+** to all contained resources upon insertion, which support managed hot swap.
+** Further information on the auto-insert timeout can be found in the
+** function saHpiAutoInsertTimeoutSet().
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAutoInsertTimeoutGet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_OUT SaHpiTimeoutT *Timeout
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAutoInsertTimeoutSet()
+**
+** Description:
+** This function allows an HPI User to configure a timeout for how long to
+** wait before the default auto-insertion policy is invoked on a resource
+** within a specific domain.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** Timeout - [in] The number of nanoseconds to wait before autonomous handling
+** of the hot swap 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.
+** SA_ERR_HPI_READ_ONLY is returned if the auto-insert timeout for the domain
+** is fixed as indicated by the SAHPI_DOMAIN_CAP_AUTOINSERT_READ_ONLY flag
+** in the DomainInfo structure.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the Timeout parameter is not set
+** to SAHPI_TIMEOUT_BLOCK, SAHPI_TIMEOUT_IMMEDIATE or a positive value.
+**
+** Remarks:
+** This function accepts a parameter instructing each resource to impose a
+** delay before performing 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 saHpiHotSwapPolicyCancel()
+** function call is processed, the timer will be stopped, and the
+** auto-insertion policy will not be invoked. Each domain maintains a single
+** auto-insert timeout value and it is applied to all contained resources upon
+** insertion, which support managed hot swap.
+**
+** Once the auto-insertion policy begins, an HPI User will not be allowed to
+** cancel the insertion policy; 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 an HPI User with a
+** saHpiEventGet() function call, or even when it is placed in a session
+** event queue.
+**
+** A resource may exist in multiple domains, which themselves may have
+** different auto-insertion timeout values. Upon insertion, the resource will
+** begin its auto-insertion policy based on the smallest auto-insertion
+** timeout value. As an example, if a resource is inserted into two domains,
+** one with an auto-insertion timeout of 5 seconds, and one with an
+** auto-insertion timeout of 10 seconds, the resource will begin its
+** auto-insertion policy at 5 seconds.
+**
+** An implementation may enforce a fixed, preset timeout value. In such
+** cases, the SAHPI_DOMAIN_CAP_AUTOINSERT_READ_ONLY flag will be set to
+** indicate that an HPI User cannot change the auto-insert Timeout value.
+** SA_ERR_HPI_READ_ONLY is returned if an HPI User attempts to change a
+** read-only timeout.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAutoInsertTimeoutSet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiTimeoutT Timeout
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAutoExtractTimeoutGet()
+**
+** Description:
+** This function allows an HPI User to request the timeout for how long a
+** resource will wait before the default auto-extraction policy is invoked.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** Timeout - [out] Pointer to location to store the number of nanoseconds to
+** wait before autonomous handling of the hot swap 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed
+** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the Timeout pointer is passed in
+** as NULL.
+**
+** Remarks:
+** Further information on auto-extract timeouts is detailed in
+** saHpiAutoExtractTimeoutSet().
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAutoExtractTimeoutGet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_OUT SaHpiTimeoutT *Timeout
+);
+
+/*******************************************************************************
+**
+** Name: saHpiAutoExtractTimeoutSet()
+**
+** Description:
+** This function allows an HPI User to configure a timeout for how long to
+** wait before the default auto-extraction policy is invoked.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** Timeout - [in] The number of nanoseconds to wait before autonomous handling
+** of the hot swap event. Reserved timeout 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed
+** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the Timeout parameter is not set
+** to SAHPI_TIMEOUT_BLOCK, SAHPI_TIMEOUT_IMMEDIATE or a positive value.
+** SA_ERR_HPI_READ_ONLY is returned if the auto-extract timeout for the
+** resource is fixed, as indicated by the
+** SAHPI_HS_CAPABILITY_AUTOEXTRACT_READ_ONLY in the resource's RPT entry.
+**
+** Remarks:
+** This function accepts a parameter instructing the resource to impose a
+** delay before performing 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 saHpiHotSwapPolicyCancel() function call is
+** processed, the timer will be stopped, and the auto-extraction policy will
+** not be invoked.
+**
+** Once the auto-extraction policy begins, an HPI User will not be allowed to
+** cancel the extraction policy; 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 HPI User 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. The
+** auto-extraction timeout value cannot be modified if the resource's "Hot
+** Swap AutoExtract Read-only" capability is set. After discovering that a
+** newly inserted resource supports Managed Hot Swap, and read-write
+** auto-extract timeouts, an HPI User may use this function to change the
+** timeout of the 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.
+**
+** An implementation may enforce a fixed, preset timeout value. In such
+** cases, the SAHPI_HS_CAPABILITY_AUTOEXTRACT_READ_ONLY flag will be set to
+** indicate that an HPI User cannot change the auto-extract Timeout value.
+** SA_ERR_HPI_READ_ONLY is returned if an HPI User attempts to change a
+** read-only timeout.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiAutoExtractTimeoutSet(
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiTimeoutT Timeout
+);
+
+/*******************************************************************************
+**
+** Name: saHpiHotSwapStateGet()
+**
+** Description:
+** This function allows an HPI User to retrieve the current hot swap state of
+** a resource.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed
+** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the State pointer is passed in as
+** NULL.
+**
+** Remarks:
+** The returned state will be one of the following four states:
+** * SAHPI_HS_STATE_INSERTION_PENDING
+** * SAHPI_HS_STATE_ACTIVE
+** * 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.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiHotSwapStateGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_OUT SaHpiHsStateT *State
+);
+
+/*******************************************************************************
+**
+** Name: saHpiHotSwapActionRequest()
+**
+** Description:
+** This function allows an HPI User to invoke an insertion or extraction
+** process via software.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** Action - [in] Requested action:
+** * SAHPI_HS_ACTION_INSERTION
+** * SAHPI_HS_ACTION_EXTRACTION
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed
+** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_REQUEST is returned if the resource is not in an
+** appropriate hot swap state, or if the requested action is inappropriate
+** for the current hot swap state. See the Remarks section below.
+** SA_ERR_HPI_INVALID_PARAMS is returned when Action is not one of the valid
+** enumerated values for this type.
+**
+** Remarks:
+** 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 provides an alternative means to invoke
+** an insertion or extraction process via software.
+**
+** This function may only 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
+** state.
+** The function may not be called when the resource is in any other state.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiHotSwapActionRequest (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiHsActionT Action
+);
+
+/*******************************************************************************
+**
+** Name: saHpiHotSwapIndicatorStateGet()
+**
+** Description:
+** This function allows an HPI User to retrieve the state of the hot swap
+** indicator. 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.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support:
+** * Managed hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in
+** the resource's RPT entry.
+** * A hot swap indicator on the FRU as indicated by the
+** SAHPI_HS_CAPABILITY_INDICATOR_SUPPORTED in the resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the State pointer is passed in as
+** NULL.
+**
+** Remarks:
+** 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.
+**
+** Not all resources supporting managed hot swap will necessarily support
+** this function. Whether or not a resource supports the hot swap indicator
+** is specified in the Hot Swap Capabilities field of the RPT entry.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiHotSwapIndicatorStateGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_OUT SaHpiHsIndicatorStateT *State
+);
+
+/*******************************************************************************
+**
+** Name: saHpiHotSwapIndicatorStateSet()
+**
+** Description:
+** This function allows an HPI User to set the state of the hot swap
+** indicator. 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.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support:
+** * Managed hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in
+** the resource's RPT entry.
+** * A hot swap indicator on the FRU as indicated by the
+** SAHPI_HS_CAPABILITY_INDICATOR_SUPPORTED in the resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned when State is not one of the valid
+** enumerated values for this type.
+**
+** Remarks:
+** 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.
+**
+** Not all resources supporting managed hot swap will necessarily support this
+** function. Whether or not a resource supports the hot swap indicator is
+** specified in the Hot Swap Capabilities field of the RPT entry.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiHotSwapIndicatorStateSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiHsIndicatorStateT State
+);
+
+/*******************************************************************************
+**
+** Name: saHpiParmControl()
+**
+** Description:
+** This function allows an HPI User to save and restore parameters associated
+** with a specific resource.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** Action - [in] Action to perform on resource parameters.
+** * 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.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support
+** parameter control, as indicated by SAHPI_CAPABILITY_CONFIGURATION in the
+** resource's RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned when Action is not set to a proper
+** value.
+**
+** Remarks:
+** Resource-specific parameters should be documented in an implementation
+** guide for the HPI implementation.
+**
+** When this API is called with SAHPI_RESTORE_PARM as the action prior to
+** having made a call with this API where the action parameter was set to
+** SAHPI_SAVE_PARM, the default parameters will be restored.
+**
+*******************************************************************************/
+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 an HPI 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] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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_CAPABILITY is returned if the resource does not support reset
+** control as indicated by SAHPI_CAPABILITY_RESET in the resource's RPT
+** entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the ResetAction pointer is passed
+** in as NULL.
+**
+** Remarks:
+** SAHPI_COLD_RESET and SAHPI_WARM_RESET are pulsed resets, and are not valid
+** values to be returned in ResetAction. If the entity is not being held in
+** reset (using SAHPI_RESET_ASSERT), the appropriate 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.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** 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,
+** * SAHPI_RESET_DEASSERT: Bring the entity out of the reset state.
+**
+** 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_CAPABILITY is returned if the resource does not support resource
+** reset control, as indicated by SAHPI_CAPABILITY_RESET in the resource's
+** RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned when the ResetAction is not set to a
+** proper value.
+** SA_ERR_HPI_INVALID_CMD is returned if the requested ResetAction is
+** SAHPI_RESET_ASSERT and the resource does not support this action.
+** SA_ERR_HPI_INVALID_REQUEST is returned if the ResetAction is
+** SAHPI_COLD_RESET or SAHPI_WARM_RESET and reset is currently asserted.
+**
+** Remarks:
+** Some resources may not support holding the entity in reset. If this is the
+** case, the resource should return SA_ERR_HPI_INVALID_CMD if the
+** SAHPI_RESET_ASSERT action is requested. All resources that have the
+** SAHPI_CAPABILITY_RESET flag set in their RPTs should support
+** SAHPI_COLD_RESET and SAHPI_WARM_RESET. However, it is not required that
+** these actions be different. That is, some resources may only have one
+** sort of reset action (e.g., a "cold" reset) which is executed when either
+** SAHPI_COLD_RESET or SAHPI_WARM_RESET is requested.
+**
+** The SAHPI_RESET_ASSERT is used to hold an entity in reset, and
+** SAHPI_RESET_DEASSERT is used to bring the entity out of an asserted reset
+** state.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiResourceResetStateSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiResetActionT ResetAction
+);
+
+/*******************************************************************************
+**
+** Name: saHpiResourcePowerStateGet()
+**
+** Description:
+** This function gets the power state of an entity, allowing an HPI User to
+** determine if the entity is currently powered on or off. 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] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** State - [out] The current power state of the resource. Valid power states
+** are:
+** * SAHPI_POWER_OFF: The entity's primary power is OFF,
+** * SAHPI_POWER_ON: The entity's primary power is ON.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support power
+** management, as indicated by SAHPI_CAPABILITY_POWER in the resource's
+** RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned if the State pointer is passed in
+** as NULL.
+**
+** Remarks:
+** SAHPI_POWER_CYCLE is a pulsed power operation and is not a valid return
+** for the power state.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiResourcePowerStateGet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_OUT SaHpiPowerStateT *State
+);
+
+/*******************************************************************************
+**
+** Name: saHpiResourcePowerStateSet()
+**
+** Description:
+** This function directs the resource to perform the power control action 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.
+**
+** Parameters:
+** SessionId - [in] Identifier for a session context previously obtained using
+** saHpiSessionOpen().
+** ResourceId - [in] Resource identified for this operation.
+** State - [in] the requested power control action. Valid values are:
+** * SAHPI_POWER_OFF: The entity's primary power is turned OFF,
+** * SAHPI_POWER_ON: The entity's primary power is turned ON,
+** * SAHPI_POWER_CYCLE: The entity's primary power is turned OFF, then
+** turned ON.
+**
+** Return Value:
+** SA_OK is returned on successful completion; otherwise, an error code is
+** returned.
+** SA_ERR_HPI_CAPABILITY is returned if the resource does not support power
+** management, as indicated by SAHPI_CAPABILITY_POWER in the resource's
+** RPT entry.
+** SA_ERR_HPI_INVALID_PARAMS is returned when State is not one of the valid
+** enumerated values for this type.
+**
+** Remarks:
+** This function controls the hardware power on a FRU entity regardless 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 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.
+**
+** This function may also be supported for non-FRU entities if power control
+** is available for those entities.
+**
+*******************************************************************************/
+SaErrorT SAHPI_API saHpiResourcePowerStateSet (
+ SAHPI_IN SaHpiSessionIdT SessionId,
+ SAHPI_IN SaHpiResourceIdT ResourceId,
+ SAHPI_IN SaHpiPowerStateT State
+);
+
+#endif