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