From a7f89980e5b3f4b9a74c70dbc5ffe8aabd28be28 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Sun, 6 Jul 2014 18:04:32 +0200 Subject: Imported Upstream version 2.9.3 --- hpiutil/SaHpi.h-B | 6785 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6785 insertions(+) create mode 100644 hpiutil/SaHpi.h-B (limited to 'hpiutil/SaHpi.h-B') diff --git a/hpiutil/SaHpi.h-B b/hpiutil/SaHpi.h-B new file mode 100644 index 0000000..38d666b --- /dev/null +++ b/hpiutil/SaHpi.h-B @@ -0,0 +1,6785 @@ +/******************************************************************************* +** +** FILE: +** SaHpi.h +** +** DESCRIPTION: +** This file provides the C language binding for the Service +** Availability(TM) Forum Platform Interface. It contains all of +** the prototypes and type definitions. Note, this file was +** generated from the Platform Interface specification document. +** +** SPECIFICATION VERSION: +** SAI-HPI-B.01.01 +** +** DATE: +** Tue Jun 1 2004 09:33 +** +** LEGAL: +** OWNERSHIP OF SPECIFICATION AND COPYRIGHTS. +** The Specification and all worldwide copyrights therein are +** the exclusive property of Licensor. You may not remove, obscure, or +** alter any copyright or other proprietary rights notices that are in or +** on the copy of the Specification you download. You must reproduce all +** such notices on all copies of the Specification you make. Licensor +** may make changes to the Specification, or to items referenced therein, +** at any time without notice. Licensor is not obligated to support or +** update the Specification. +** +** Copyright(c) 2004, Service Availability(TM) Forum. All rights +** reserved. +** +*******************************************************************************/ + +#ifndef __SAHPI_H +#define __SAHPI_H + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Basic Data Types and Values ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* General Types - need to be specified correctly for the host architecture */ + +/* +** It is recommended that these types be defined such that the data sizes +** and alignment of each data type are as indicated. The only requirement +** for source compatibility is that the types be defined to be able to +** contain at least the required data (e.g., at least signed 8-bit values +** must be contained in the data type defined as SaHpiInt8T, etc.) +** Following the full recommendations for data size and alignment, however, +** may promote more binary compatibility. +*/ + +/* The following definitions produce the recommended sizes and alignments +** using the gcc compiler for the i386 (IA-32) platform. +** +** Note, some recent versions of the gcc compiler exhibit an apparent bug +** that makes the __attribute__ statements applied to the typdef's on +** the 64-bit types below ineffective when those types are used in structures. +** To workaround that bug, it may be required to add similar __attribute__ +** statements on the typedefs of the derived types SaHpiTimeT and +** SaHpiTimeoutT, plus on individual 64-bit data items within structure and +** union definitions in order to align the HPI structures as recommended. +** The structures and unions that contain 64-bit data items are: +** SaHpiSensorReadingUnionT, SaHpiSensorDataFormatT, SaHpiEventT, +** SaHpiAnnouncementT, SaHpiDomainInfoT, SaHpiAlarmT, SaHpiEventLogInfoT, +** and SaHpiEventLogEntryT. For more information, see: +** https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=109911 +*/ + + +/* unsigned 8-bit data, 1-byte alignment */ +typedef unsigned char SaHpiUint8T; + +/* unsigned 16-bit data, 2-byte alignment */ +typedef unsigned short SaHpiUint16T; + +/* unsigned 32-bit data, 4-byte alignment */ +typedef unsigned int SaHpiUint32T; + +/* unsigned 64-bit data, 8-byte alignment */ +typedef unsigned long long int SaHpiUint64T __attribute__((__aligned__(8))); + +/* signed 8-bit data, 1-byte alignment */ +typedef signed char SaHpiInt8T; + +/* signed 16-bit data, 2-byte alignment */ +typedef signed short SaHpiInt16T; + +/* signed 32-bit data, 4-byte alignment */ +typedef signed int SaHpiInt32T; + +/* signed 64-bit data, 8-byte alignment */ +typedef signed long long int SaHpiInt64T __attribute__((__aligned__(8))); + +/* 64-bit floating point, 8-byte alignment */ +typedef double SaHpiFloat64T __attribute__((__aligned__(8))); + + +typedef SaHpiUint8T SaHpiBoolT; +#define SAHPI_TRUE 1 /* While SAHPI_TRUE = 1, any non-zero + value is also considered to be True + and HPI Users/Implementers of this + specification should not test for + equality against SAHPI_TRUE. */ + +#define SAHPI_FALSE 0 + +/* Platform, O/S, or Vendor dependent */ +#define SAHPI_API +#define SAHPI_IN +#define SAHPI_OUT +#define SAHPI_INOUT + +/* +** Identifier for the manufacturer +** +** This is the IANA-assigned private enterprise number for the +** manufacturer of the resource or FRU, or of the manufacturer +** defining an OEM control or event type. A list of current +** IANA-assigned private enterprise numbers may be obtained at +** +** http://www.iana.org/assignments/enterprise-numbers +** +** If a manufacturer does not currently have an assigned number, one +** may be obtained by following the instructions located at +** +** http://www.iana.org/cgi-bin/enterprise.pl +*/ +typedef SaHpiUint32T SaHpiManufacturerIdT; +#define SAHPI_MANUFACTURER_ID_UNSPECIFIED (SaHpiManufacturerIdT)0 + +/* Version Types */ +typedef SaHpiUint32T SaHpiVersionT; + +/* +** Interface Version +** +** The interface version is the version of the actual interface and not the +** version of the implementation. It is a 24 bit value where +** the most significant 8 bits represent the compatibility level +** (with letters represented as the corresponding numbers); +** the next 8 bits represent the major version number; and +** the least significant 8 bits represent the minor version number. +*/ +#define SAHPI_INTERFACE_VERSION (SaHpiVersionT)0x020101 /* B.01.01 */ + +/* +** Return Codes +** +** SaErrorT is defined in the HPI specification. In the future a +** common SAF types definition may be created to contain this type. At +** that time, this typedef should be removed. Each of the return codes +** is defined in Section 4.1 of the specification. +*/ +typedef SaHpiInt32T SaErrorT; /* Return code */ + +/* +** SA_OK: +*/ +#define SA_OK (SaErrorT)0x0000 + +/* This value is the base for all HPI-specific error codes. */ +#define SA_HPI_ERR_BASE -1000 + +#define SA_ERR_HPI_ERROR (SaErrorT)(SA_HPI_ERR_BASE - 1) +#define SA_ERR_HPI_UNSUPPORTED_API (SaErrorT)(SA_HPI_ERR_BASE - 2) +#define SA_ERR_HPI_BUSY (SaErrorT)(SA_HPI_ERR_BASE - 3) +#define SA_ERR_HPI_INTERNAL_ERROR (SaErrorT)(SA_HPI_ERR_BASE - 4) +#define SA_ERR_HPI_INVALID_CMD (SaErrorT)(SA_HPI_ERR_BASE - 5) +#define SA_ERR_HPI_TIMEOUT (SaErrorT)(SA_HPI_ERR_BASE - 6) +#define SA_ERR_HPI_OUT_OF_SPACE (SaErrorT)(SA_HPI_ERR_BASE - 7) +#define SA_ERR_HPI_OUT_OF_MEMORY (SaErrorT)(SA_HPI_ERR_BASE - 8) +#define SA_ERR_HPI_INVALID_PARAMS (SaErrorT)(SA_HPI_ERR_BASE - 9) +#define SA_ERR_HPI_INVALID_DATA (SaErrorT)(SA_HPI_ERR_BASE - 10) +#define SA_ERR_HPI_NOT_PRESENT (SaErrorT)(SA_HPI_ERR_BASE - 11) +#define SA_ERR_HPI_NO_RESPONSE (SaErrorT)(SA_HPI_ERR_BASE - 12) +#define SA_ERR_HPI_DUPLICATE (SaErrorT)(SA_HPI_ERR_BASE - 13) +#define SA_ERR_HPI_INVALID_SESSION (SaErrorT)(SA_HPI_ERR_BASE - 14) +#define SA_ERR_HPI_INVALID_DOMAIN (SaErrorT)(SA_HPI_ERR_BASE - 15) +#define SA_ERR_HPI_INVALID_RESOURCE (SaErrorT)(SA_HPI_ERR_BASE - 16) +#define SA_ERR_HPI_INVALID_REQUEST (SaErrorT)(SA_HPI_ERR_BASE - 17) +#define SA_ERR_HPI_ENTITY_NOT_PRESENT (SaErrorT)(SA_HPI_ERR_BASE - 18) +#define SA_ERR_HPI_READ_ONLY (SaErrorT)(SA_HPI_ERR_BASE - 19) +#define SA_ERR_HPI_CAPABILITY (SaErrorT)(SA_HPI_ERR_BASE - 20) +#define SA_ERR_HPI_UNKNOWN (SaErrorT)(SA_HPI_ERR_BASE - 21) + +/* +** Domain, Session and Resource Type Definitions +*/ + +/* Domain ID. */ +typedef SaHpiUint32T SaHpiDomainIdT; + +/* The SAHPI_UNSPECIFIED_DOMAIN_ID value is used to specify the default +** domain. +*/ +#define SAHPI_UNSPECIFIED_DOMAIN_ID (SaHpiDomainIdT) 0xFFFFFFFF + +/* Session ID. */ +typedef SaHpiUint32T SaHpiSessionIdT; + +/* Resource identifier. */ +typedef SaHpiUint32T SaHpiResourceIdT; + +/* The SAHPI_UNSPECIFIED_RESOURCE_ID value is used to specify the Domain +** Event Log and to specify that there is no resource for such things as HPI +** User events/alarms. +*/ +#define SAHPI_UNSPECIFIED_RESOURCE_ID (SaHpiResourceIdT) 0xFFFFFFFF + +/* Table Related Type Definitions */ +typedef SaHpiUint32T SaHpiEntryIdT; +#define SAHPI_FIRST_ENTRY (SaHpiEntryIdT)0x00000000 +#define SAHPI_LAST_ENTRY (SaHpiEntryIdT)0xFFFFFFFF +#define SAHPI_ENTRY_UNSPECIFIED SAHPI_FIRST_ENTRY + +/* +** Time Related Type Definitions +** +** An HPI time value represents the local time as the number of nanoseconds +** from 00:00:00, January 1, 1970, in a 64-bit signed integer. This format +** is sufficient to represent times with nano-second resolution from the +** year 1678 to 2262. Every API which deals with time values must define +** the timezone used. +** +** It should be noted that although nano-second resolution is supported +** in the data type, the actual resolution provided by an implementation +** may be more limited than this. +** +** The value -2**63, which is 0x8000000000000000, is used to indicate +** "unknown/unspecified time". +** +** Conversion to/from POSIX and other common time representations is +** relatively straightforward. The following code framgment converts +** between SaHpiTimeT and time_t: +** +** time_t tt1, tt2; +** SaHpiTimeT saHpiTime; +** +** time(&tt1); +** saHpiTime = (SaHpiTimeT) tt1 * 1000000000; +** tt2 = saHpiTime / 1000000000; +** +** The following fragment converts between SaHpiTimeT and a struct timeval: +** +** struct timeval tv1, tv2; +** SaHpiTimeT saHpiTime; +** +** gettimeofday(&tv1, NULL); +** saHpiTime = (SaHpiTimeT) tv1.tv_sec * 1000000000 + tv1.tv_usec * 1000; +** tv2.tv_sec = saHpiTime / 1000000000; +** tv2.tv_usec = saHpiTime % 1000000000 / 1000; +** +** The following fragment converts between SaHpiTimeT and a struct timespec: +** +** struct timespec ts1, ts2; +** SaHpiTimeT saHpiTime; +** +** clock_gettime(CLOCK_REALTIME, &ts1); +** saHpiTime = (SaHpiTimeT) ts1.tv_sec * 1000000000 + ts1.tv_nsec; +** ts2.tv_sec = saHpiTime / 1000000000; +** ts2.tv_nsec = saHpiTime % 1000000000; +** +** Note, however, that since time_t is (effectively) universally 32 bits, +** all of these conversions will cease to work on January 18, 2038. +** +** Some subsystems may need the flexibility to report either absolute or +** relative (eg. to system boot) times. This will typically be in the +** case of a board which may or may not, depending on the system setup, +** have an idea of absolute time. For example, some boards may have +** "time of day" clocks which start at zero, and never get set to the +** time of day. +** +** In these cases, times which represent "current" time (in events, for +** example) can be reported based on the clock value, whether it has been +** set to the actual date/time, or whether it represents the elapsed time +** since boot. If it is the time since boot, the value will be (for 27 +** years) less than 0x0C00000000000000, which is Mon May 26 16:58:48 1997. +** If the value is greater than this, then it can be assumed to be an +** absolute time. +** +** There is no practical need within the interface for expressing dates prior +** to the publication of this specification (which is more than five years +** after the "break point" between relative and absolute time). Thus, in all +** instances a time value should be interpreted as "relative" times if the +** value is less than or equal to SAHPI_TIME_MAX_RELATIVE (but not equal to +** SAHPI_TIME_UNSPECIFIED which always means the time is not available), or +** "absolute" times if the value is greater than SAHPI_TIME_MAX_RELATIVE. +*/ +typedef SaHpiInt64T SaHpiTimeT; /* Time in nanoseconds */ + +/* Unspecified or unknown time */ +#define SAHPI_TIME_UNSPECIFIED (SaHpiTimeT) 0x8000000000000000LL + +/* Maximum time that can be specified as relative */ +#define SAHPI_TIME_MAX_RELATIVE (SaHpiTimeT) 0x0C00000000000000LL +typedef SaHpiInt64T SaHpiTimeoutT; /* Timeout in nanoseconds */ + +/* Non-blocking call */ +#define SAHPI_TIMEOUT_IMMEDIATE (SaHpiTimeoutT) 0x0000000000000000LL + +/* Blocking call, wait indefinitely for call to complete */ +#define SAHPI_TIMEOUT_BLOCK (SaHpiTimeoutT) -1LL + +/* +** Language +** +** This enumeration lists all of the languages that can be associated with text. +** +** SAHPI_LANG_UNDEF indicates that the language is unspecified or +** unknown. +*/ +typedef enum { + SAHPI_LANG_UNDEF = 0, SAHPI_LANG_AFAR, SAHPI_LANG_ABKHAZIAN, + SAHPI_LANG_AFRIKAANS, SAHPI_LANG_AMHARIC, SAHPI_LANG_ARABIC, + SAHPI_LANG_ASSAMESE, SAHPI_LANG_AYMARA, SAHPI_LANG_AZERBAIJANI, + SAHPI_LANG_BASHKIR, SAHPI_LANG_BYELORUSSIAN, SAHPI_LANG_BULGARIAN, + SAHPI_LANG_BIHARI, SAHPI_LANG_BISLAMA, SAHPI_LANG_BENGALI, + SAHPI_LANG_TIBETAN, SAHPI_LANG_BRETON, SAHPI_LANG_CATALAN, + SAHPI_LANG_CORSICAN, SAHPI_LANG_CZECH, SAHPI_LANG_WELSH, + SAHPI_LANG_DANISH, SAHPI_LANG_GERMAN, SAHPI_LANG_BHUTANI, + SAHPI_LANG_GREEK, SAHPI_LANG_ENGLISH, SAHPI_LANG_ESPERANTO, + SAHPI_LANG_SPANISH, SAHPI_LANG_ESTONIAN, SAHPI_LANG_BASQUE, + SAHPI_LANG_PERSIAN, SAHPI_LANG_FINNISH, SAHPI_LANG_FIJI, + SAHPI_LANG_FAEROESE, SAHPI_LANG_FRENCH, SAHPI_LANG_FRISIAN, + SAHPI_LANG_IRISH, SAHPI_LANG_SCOTSGAELIC, SAHPI_LANG_GALICIAN, + SAHPI_LANG_GUARANI, SAHPI_LANG_GUJARATI, SAHPI_LANG_HAUSA, + SAHPI_LANG_HINDI, SAHPI_LANG_CROATIAN, SAHPI_LANG_HUNGARIAN, + SAHPI_LANG_ARMENIAN, SAHPI_LANG_INTERLINGUA, SAHPI_LANG_INTERLINGUE, + SAHPI_LANG_INUPIAK, SAHPI_LANG_INDONESIAN, SAHPI_LANG_ICELANDIC, + SAHPI_LANG_ITALIAN, SAHPI_LANG_HEBREW, SAHPI_LANG_JAPANESE, + SAHPI_LANG_YIDDISH, SAHPI_LANG_JAVANESE, SAHPI_LANG_GEORGIAN, + SAHPI_LANG_KAZAKH, SAHPI_LANG_GREENLANDIC, SAHPI_LANG_CAMBODIAN, + SAHPI_LANG_KANNADA, SAHPI_LANG_KOREAN, SAHPI_LANG_KASHMIRI, + SAHPI_LANG_KURDISH, SAHPI_LANG_KIRGHIZ, SAHPI_LANG_LATIN, + SAHPI_LANG_LINGALA, SAHPI_LANG_LAOTHIAN, SAHPI_LANG_LITHUANIAN, + SAHPI_LANG_LATVIANLETTISH, SAHPI_LANG_MALAGASY, SAHPI_LANG_MAORI, + SAHPI_LANG_MACEDONIAN, SAHPI_LANG_MALAYALAM, SAHPI_LANG_MONGOLIAN, + SAHPI_LANG_MOLDAVIAN, SAHPI_LANG_MARATHI, SAHPI_LANG_MALAY, + SAHPI_LANG_MALTESE, SAHPI_LANG_BURMESE, SAHPI_LANG_NAURU, + SAHPI_LANG_NEPALI, SAHPI_LANG_DUTCH, SAHPI_LANG_NORWEGIAN, + SAHPI_LANG_OCCITAN, SAHPI_LANG_AFANOROMO, SAHPI_LANG_ORIYA, + SAHPI_LANG_PUNJABI, SAHPI_LANG_POLISH, SAHPI_LANG_PASHTOPUSHTO, + SAHPI_LANG_PORTUGUESE, SAHPI_LANG_QUECHUA, SAHPI_LANG_RHAETOROMANCE, + SAHPI_LANG_KIRUNDI, SAHPI_LANG_ROMANIAN, SAHPI_LANG_RUSSIAN, + SAHPI_LANG_KINYARWANDA, SAHPI_LANG_SANSKRIT, SAHPI_LANG_SINDHI, + SAHPI_LANG_SANGRO, SAHPI_LANG_SERBOCROATIAN, SAHPI_LANG_SINGHALESE, + SAHPI_LANG_SLOVAK, SAHPI_LANG_SLOVENIAN, SAHPI_LANG_SAMOAN, + SAHPI_LANG_SHONA, SAHPI_LANG_SOMALI, SAHPI_LANG_ALBANIAN, + SAHPI_LANG_SERBIAN, SAHPI_LANG_SISWATI, SAHPI_LANG_SESOTHO, + SAHPI_LANG_SUDANESE, SAHPI_LANG_SWEDISH, SAHPI_LANG_SWAHILI, + SAHPI_LANG_TAMIL, SAHPI_LANG_TELUGU, SAHPI_LANG_TAJIK, + SAHPI_LANG_THAI, SAHPI_LANG_TIGRINYA, SAHPI_LANG_TURKMEN, + SAHPI_LANG_TAGALOG, SAHPI_LANG_SETSWANA, SAHPI_LANG_TONGA, + SAHPI_LANG_TURKISH, SAHPI_LANG_TSONGA, SAHPI_LANG_TATAR, + SAHPI_LANG_TWI, SAHPI_LANG_UKRAINIAN, SAHPI_LANG_URDU, + SAHPI_LANG_UZBEK, SAHPI_LANG_VIETNAMESE, SAHPI_LANG_VOLAPUK, + SAHPI_LANG_WOLOF, SAHPI_LANG_XHOSA, SAHPI_LANG_YORUBA, + SAHPI_LANG_CHINESE, SAHPI_LANG_ZULU +} SaHpiLanguageT; + +/* +** Text Buffers +** +** These structures are used for defining the type of data in the text buffer +** and the length of the buffer. Text buffers are used in the inventory data, +** RDR, RPT, etc. for variable length strings of data. +** +** The encoding of the Data field in the SaHpiTextBufferT structure is defined +** by the value of the DataType field in the buffer. The following table +** describes the various encodings: +** +** DataType Encoding +** -------- -------- +** +** SAHPI_TL_TYPE_UNICODE 16-bit Unicode, least significant byte first. +** Buffer must contain even number of bytes. +** +** SAHPI_TL_TYPE_BCDPLUS 8-bit ASCII, '0'-'9' or space, dash, period, +** colon, comma, or underscore only. +** +** SAHPI_TL_TYPE_ASCII6 8-bit ASCII, reduced set, 0x20=0x5f only. +** +** SAHPI_TL_TYPE_TEXT 8-bit ASCII+Latin 1 +** +** SAHPI_TL_TYPE_BINARY 8-bit bytes, any values legal +** +** Note: "ASCII+Latin 1" is derived from the first 256 characters of +** Unicode 2.0. The first 256 codes of Unicode follow ISO 646 (ASCII) +** and ISO 8859/1 (Latin 1). The Unicode "C0 Controls and Basic Latin" +** set defines the first 128 8-bit characters (00h-7Fh) and the +** "C1 Controls and Latin 1 Supplement" defines the second 128 (80h-FFh). +** +** Note: The SAHPI_TL_TYPE_BCDPLUS and SAHPI_TL_TYPE_ASCII6 encodings +** use normal ASCII character encodings, but restrict the allowed +** characters to a subset of the entire ASCII character set. These +** encodings are used when the target device contains restrictions +** on which characters it can store or display. SAHPI_TL_TYPE_BCDPLUS +** data may be stored externally as 4-bit values, and +** SAHPI_TL_TYPE_ASCII6 may be stored externally as 6-bit values. +** But, regardless of how the data is stored externally, it is +** encoded as 8-bit ASCII in the SaHpiTextBufferT structure passed +** across the HPI. +*/ + +#define SAHPI_MAX_TEXT_BUFFER_LENGTH 255 + +typedef enum { + SAHPI_TL_TYPE_UNICODE = 0, /* 2-byte UNICODE characters; DataLength + must be even. */ + SAHPI_TL_TYPE_BCDPLUS, /* String of ASCII characters, '0'-'9', space, + dash, period, colon, comma or underscore + ONLY */ + SAHPI_TL_TYPE_ASCII6, /* Reduced ASCII character set: 0x20-0x5F + ONLY */ + SAHPI_TL_TYPE_TEXT, /* ASCII+Latin 1 */ + SAHPI_TL_TYPE_BINARY /* Binary data, any values legal */ +} SaHpiTextTypeT; + +typedef struct { + SaHpiTextTypeT DataType; + SaHpiLanguageT Language; /* Language the text is in. */ + SaHpiUint8T DataLength; /* Bytes used in Data buffer */ + SaHpiUint8T Data[SAHPI_MAX_TEXT_BUFFER_LENGTH]; /* Data buffer */ +} SaHpiTextBufferT; + +/* +** Instrument Id +** +** The following data type is used for all management instrument identifiers - +** sensor numbers, control numbers, watchdog timer numbers, etc. +** +*/ + +typedef SaHpiUint32T SaHpiInstrumentIdT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Entities ********** +********** ********** +******************************************************************************** +*******************************************************************************/ +/* +** Entity Types +** +** Entities are used to associate specific hardware components with sensors, +** controls, watchdogs, or resources. Entities are defined with an entity +** type enumeration, and an entity location number (to identify +** the physical location of a particular type of entity). +** +** Entities are uniquely identified in a system with an ordered series of +** Entity Type / Entity Location pairs called an "Entity Path". Each subsequent +** Entity Type/Entity Location in the path is the next higher "containing" +** entity. The "root" of the Entity Path (the outermost level of containment) +** is designated with an Entity Type of SAHPI_ENT_ROOT if the entire Entity Path +** is fewer than SAHPI_MAX_ENTITY_PATH entries in length. +** +** Enumerated Entity Types include those types enumerated by the IPMI Consortium +** for IPMI-managed entities, as well as additional types defined by the +** HPI specification. Room is left in the enumeration for the inclusion of +** Entity Types taken from other lists, if needed in the future. +*/ +/* Base values for entity types from various sources. */ +#define SAHPI_ENT_IPMI_GROUP 0 +#define SAHPI_ENT_SAFHPI_GROUP 0x10000 +#define SAHPI_ENT_ROOT_VALUE 0xFFFF +typedef enum +{ + SAHPI_ENT_UNSPECIFIED = SAHPI_ENT_IPMI_GROUP, + SAHPI_ENT_OTHER, + SAHPI_ENT_UNKNOWN, + SAHPI_ENT_PROCESSOR, + SAHPI_ENT_DISK_BAY, /* Disk or disk bay */ + SAHPI_ENT_PERIPHERAL_BAY, + SAHPI_ENT_SYS_MGMNT_MODULE, /* System management module */ + SAHPI_ENT_SYSTEM_BOARD, /* Main system board, may also be + processor board and/or internal + expansion board */ + SAHPI_ENT_MEMORY_MODULE, /* Board holding memory devices */ + SAHPI_ENT_PROCESSOR_MODULE, /* Holds processors, use this + designation when processors are not + mounted on system board */ + SAHPI_ENT_POWER_SUPPLY, /* Main power supply (supplies) for the + system */ + SAHPI_ENT_ADD_IN_CARD, + SAHPI_ENT_FRONT_PANEL_BOARD, /* Control panel */ + SAHPI_ENT_BACK_PANEL_BOARD, + SAHPI_ENT_POWER_SYSTEM_BOARD, + SAHPI_ENT_DRIVE_BACKPLANE, + SAHPI_ENT_SYS_EXPANSION_BOARD, /* System internal expansion board + (contains expansion slots). */ + SAHPI_ENT_OTHER_SYSTEM_BOARD, /* Part of board set */ + SAHPI_ENT_PROCESSOR_BOARD, /* Holds 1 or more processors. Includes + boards that hold SECC modules) */ + SAHPI_ENT_POWER_UNIT, /* Power unit / power domain (typically + used as a pre-defined logical entity + for grouping power supplies)*/ + SAHPI_ENT_POWER_MODULE, /* Power module / DC-to-DC converter. + Use this value for internal + converters. Note: You should use + entity ID (power supply) for the + main power supply even if the main + supply is a DC-to-DC converter */ + SAHPI_ENT_POWER_MGMNT, /* Power management/distribution + board */ + SAHPI_ENT_CHASSIS_BACK_PANEL_BOARD, + SAHPI_ENT_SYSTEM_CHASSIS, + SAHPI_ENT_SUB_CHASSIS, + SAHPI_ENT_OTHER_CHASSIS_BOARD, + SAHPI_ENT_DISK_DRIVE_BAY, + SAHPI_ENT_PERIPHERAL_BAY_2, + SAHPI_ENT_DEVICE_BAY, + SAHPI_ENT_COOLING_DEVICE, /* Fan/cooling device */ + SAHPI_ENT_COOLING_UNIT, /* Can be used as a pre-defined logical + entity for grouping fans or other + cooling devices. */ + SAHPI_ENT_INTERCONNECT, /* Cable / interconnect */ + SAHPI_ENT_MEMORY_DEVICE, /* This Entity ID should be used for + replaceable memory devices, e.g. + DIMM/SIMM. It is recommended that + Entity IDs not be used for + individual non-replaceable memory + devices. Rather, monitoring and + error reporting should be associated + with the FRU [e.g. memory card] + holding the memory. */ + SAHPI_ENT_SYS_MGMNT_SOFTWARE, /* System Management Software */ + SAHPI_ENT_BIOS, + SAHPI_ENT_OPERATING_SYSTEM, + SAHPI_ENT_SYSTEM_BUS, + SAHPI_ENT_GROUP, /* This is a logical entity for use with + Entity Association records. It is + provided to allow a sensor data + record to point to an entity- + association record when there is no + appropriate pre-defined logical + entity for the entity grouping. + This Entity should not be used as a + physical entity. */ + SAHPI_ENT_REMOTE, /* Out of band management communication + device */ + SAHPI_ENT_EXTERNAL_ENVIRONMENT, + SAHPI_ENT_BATTERY, + SAHPI_ENT_CHASSIS_SPECIFIC = SAHPI_ENT_IPMI_GROUP + 0x90, + SAHPI_ENT_BOARD_SET_SPECIFIC = SAHPI_ENT_IPMI_GROUP + 0xB0, + SAHPI_ENT_OEM_SYSINT_SPECIFIC = SAHPI_ENT_IPMI_GROUP + 0xD0, + SAHPI_ENT_ROOT = SAHPI_ENT_ROOT_VALUE, + SAHPI_ENT_RACK = SAHPI_ENT_SAFHPI_GROUP, + SAHPI_ENT_SUBRACK, + SAHPI_ENT_COMPACTPCI_CHASSIS, + SAHPI_ENT_ADVANCEDTCA_CHASSIS, + SAHPI_ENT_RACK_MOUNTED_SERVER, + SAHPI_ENT_SYSTEM_BLADE, + SAHPI_ENT_SWITCH, /* Network switch, such as a + rack-mounted ethernet or fabric + switch. */ + SAHPI_ENT_SWITCH_BLADE, /* Network switch, as above, but in + a bladed system. */ + SAHPI_ENT_SBC_BLADE, + SAHPI_ENT_IO_BLADE, + SAHPI_ENT_DISK_BLADE, + SAHPI_ENT_DISK_DRIVE, + SAHPI_ENT_FAN, + SAHPI_ENT_POWER_DISTRIBUTION_UNIT, + SAHPI_ENT_SPEC_PROC_BLADE, /* Special Processing Blade, + including DSP */ + SAHPI_ENT_IO_SUBBOARD, /* I/O Sub-Board, including + PMC I/O board */ + SAHPI_ENT_SBC_SUBBOARD, /* SBC Sub-Board, including PMC + SBC board */ + SAHPI_ENT_ALARM_MANAGER, /* Chassis alarm manager board */ + SAHPI_ENT_SHELF_MANAGER, /* Blade-based shelf manager */ + SAHPI_ENT_DISPLAY_PANEL, /* Display panel, such as an + alarm display panel. */ + SAHPI_ENT_SUBBOARD_CARRIER_BLADE, /* Includes PMC Carrier Blade -- + Use only if "carrier" is only + function of blade. Else use + primary function (SBC_BLADE, + DSP_BLADE, etc.). */ + SAHPI_ENT_PHYSICAL_SLOT /* Indicates the physical slot into + which a blade is inserted. */ +} SaHpiEntityTypeT; + +typedef SaHpiUint32T SaHpiEntityLocationT; + +typedef struct { + SaHpiEntityTypeT EntityType; + SaHpiEntityLocationT EntityLocation; +} SaHpiEntityT; + + +#define SAHPI_MAX_ENTITY_PATH 16 + +typedef struct { + SaHpiEntityT Entry[SAHPI_MAX_ENTITY_PATH]; +} SaHpiEntityPathT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Events, part 1 ********** +********** ********** +******************************************************************************** +*******************************************************************************/ +/* +** Category +** +** Sensor events contain an event category and event state. Depending on the +** event category, the event states take on different meanings for events +** generated by specific sensors. +** +** It is recommended that implementations map their sensor specific +** event categories into the set of categories listed here. When such a mapping +** is impractical or impossible, the SAHPI_EC_SENSOR_SPECIFIC category should +** be used. +** +** The SAHPI_EC_GENERIC category can be used for discrete sensors which have +** state meanings other than those identified with other event categories. +*/ +typedef SaHpiUint8T SaHpiEventCategoryT; + +#define SAHPI_EC_UNSPECIFIED (SaHpiEventCategoryT)0x00 /* Unspecified */ +#define SAHPI_EC_THRESHOLD (SaHpiEventCategoryT)0x01 /* Threshold + events */ +#define SAHPI_EC_USAGE (SaHpiEventCategoryT)0x02 /* Usage state + events */ +#define SAHPI_EC_STATE (SaHpiEventCategoryT)0x03 /* Generic state + events */ +#define SAHPI_EC_PRED_FAIL (SaHpiEventCategoryT)0x04 /* Predictive fail + events */ +#define SAHPI_EC_LIMIT (SaHpiEventCategoryT)0x05 /* Limit events */ +#define SAHPI_EC_PERFORMANCE (SaHpiEventCategoryT)0x06 /* Performance + events */ +#define SAHPI_EC_SEVERITY (SaHpiEventCategoryT)0x07 /* Severity + indicating + events */ +#define SAHPI_EC_PRESENCE (SaHpiEventCategoryT)0x08 /* Device presence + events */ +#define SAHPI_EC_ENABLE (SaHpiEventCategoryT)0x09 /* Device enabled + events */ +#define SAHPI_EC_AVAILABILITY (SaHpiEventCategoryT)0x0A /* Availability + state events */ +#define SAHPI_EC_REDUNDANCY (SaHpiEventCategoryT)0x0B /* Redundancy + state events */ +#define SAHPI_EC_SENSOR_SPECIFIC (SaHpiEventCategoryT)0x7E /* Sensor- + specific events */ +#define SAHPI_EC_GENERIC (SaHpiEventCategoryT)0x7F /* OEM defined + events */ + +/* +** Event States +** +** The following event states are specified relative to the categories listed +** above. The event types are only valid for their given category. Each set of +** events is labeled as to which category it belongs to. +** Each event will have only one event state associated with it. When retrieving +** the event status or event enabled status a bit mask of all applicable event +** states is used. Similarly, when setting the event enabled status a bit mask +** of all applicable event states is used. +*/ +typedef SaHpiUint16T SaHpiEventStateT; + +/* +** SaHpiEventCategoryT == +*/ +#define SAHPI_ES_UNSPECIFIED (SaHpiEventStateT)0x0000 + +/* +** SaHpiEventCategoryT == SAHPI_EC_THRESHOLD +** When using these event states, the event state should match +** the event severity (for example SAHPI_ES_LOWER_MINOR should have an +** event severity of SAHPI_MINOR). +*/ +#define SAHPI_ES_LOWER_MINOR (SaHpiEventStateT)0x0001 +#define SAHPI_ES_LOWER_MAJOR (SaHpiEventStateT)0x0002 +#define SAHPI_ES_LOWER_CRIT (SaHpiEventStateT)0x0004 +#define SAHPI_ES_UPPER_MINOR (SaHpiEventStateT)0x0008 +#define SAHPI_ES_UPPER_MAJOR (SaHpiEventStateT)0x0010 +#define SAHPI_ES_UPPER_CRIT (SaHpiEventStateT)0x0020 + +/* SaHpiEventCategoryT == SAHPI_EC_USAGE */ +#define SAHPI_ES_IDLE (SaHpiEventStateT)0x0001 +#define SAHPI_ES_ACTIVE (SaHpiEventStateT)0x0002 +#define SAHPI_ES_BUSY (SaHpiEventStateT)0x0004 + +/* SaHpiEventCategoryT == SAHPI_EC_STATE */ +#define SAHPI_ES_STATE_DEASSERTED (SaHpiEventStateT)0x0001 +#define SAHPI_ES_STATE_ASSERTED (SaHpiEventStateT)0x0002 + +/* SaHpiEventCategoryT == SAHPI_EC_PRED_FAIL */ +#define SAHPI_ES_PRED_FAILURE_DEASSERT (SaHpiEventStateT)0x0001 +#define SAHPI_ES_PRED_FAILURE_ASSERT (SaHpiEventStateT)0x0002 + +/* SaHpiEventCategoryT == SAHPI_EC_LIMIT */ +#define SAHPI_ES_LIMIT_NOT_EXCEEDED (SaHpiEventStateT)0x0001 +#define SAHPI_ES_LIMIT_EXCEEDED (SaHpiEventStateT)0x0002 + +/* SaHpiEventCategoryT == SAHPI_EC_PERFORMANCE */ +#define SAHPI_ES_PERFORMANCE_MET (SaHpiEventStateT)0x0001 +#define SAHPI_ES_PERFORMANCE_LAGS (SaHpiEventStateT)0x0002 + +/* +** SaHpiEventCategoryT == SAHPI_EC_SEVERITY +** When using these event states, the event state should match +** the event severity +*/ +#define SAHPI_ES_OK (SaHpiEventStateT)0x0001 +#define SAHPI_ES_MINOR_FROM_OK (SaHpiEventStateT)0x0002 +#define SAHPI_ES_MAJOR_FROM_LESS (SaHpiEventStateT)0x0004 +#define SAHPI_ES_CRITICAL_FROM_LESS (SaHpiEventStateT)0x0008 +#define SAHPI_ES_MINOR_FROM_MORE (SaHpiEventStateT)0x0010 +#define SAHPI_ES_MAJOR_FROM_CRITICAL (SaHpiEventStateT)0x0020 +#define SAHPI_ES_CRITICAL (SaHpiEventStateT)0x0040 +#define SAHPI_ES_MONITOR (SaHpiEventStateT)0x0080 +#define SAHPI_ES_INFORMATIONAL (SaHpiEventStateT)0x0100 + +/* SaHpiEventCategoryT == SAHPI_EC_PRESENCE */ +#define SAHPI_ES_ABSENT (SaHpiEventStateT)0x0001 +#define SAHPI_ES_PRESENT (SaHpiEventStateT)0x0002 + +/* SaHpiEventCategoryT == SAHPI_EC_ENABLE */ +#define SAHPI_ES_DISABLED (SaHpiEventStateT)0x0001 +#define SAHPI_ES_ENABLED (SaHpiEventStateT)0x0002 + +/* SaHpiEventCategoryT == SAHPI_EC_AVAILABILITY */ +#define SAHPI_ES_RUNNING (SaHpiEventStateT)0x0001 +#define SAHPI_ES_TEST (SaHpiEventStateT)0x0002 +#define SAHPI_ES_POWER_OFF (SaHpiEventStateT)0x0004 +#define SAHPI_ES_ON_LINE (SaHpiEventStateT)0x0008 +#define SAHPI_ES_OFF_LINE (SaHpiEventStateT)0x0010 +#define SAHPI_ES_OFF_DUTY (SaHpiEventStateT)0x0020 +#define SAHPI_ES_DEGRADED (SaHpiEventStateT)0x0040 +#define SAHPI_ES_POWER_SAVE (SaHpiEventStateT)0x0080 +#define SAHPI_ES_INSTALL_ERROR (SaHpiEventStateT)0x0100 + +/* SaHpiEventCategoryT == SAHPI_EC_REDUNDANCY */ +#define SAHPI_ES_FULLY_REDUNDANT (SaHpiEventStateT)0x0001 +#define SAHPI_ES_REDUNDANCY_LOST (SaHpiEventStateT)0x0002 +#define SAHPI_ES_REDUNDANCY_DEGRADED (SaHpiEventStateT)0x0004 +#define SAHPI_ES_REDUNDANCY_LOST_SUFFICIENT_RESOURCES \ + (SaHpiEventStateT)0x0008 +#define SAHPI_ES_NON_REDUNDANT_SUFFICIENT_RESOURCES \ + (SaHpiEventStateT)0x0010 +#define SAHPI_ES_NON_REDUNDANT_INSUFFICIENT_RESOURCES \ + (SaHpiEventStateT)0x0020 +#define SAHPI_ES_REDUNDANCY_DEGRADED_FROM_FULL (SaHpiEventStateT)0x0040 +#define SAHPI_ES_REDUNDANCY_DEGRADED_FROM_NON (SaHpiEventStateT)0x0080 + +/* +** SaHpiEventCategoryT == SAHPI_EC_GENERIC || SAHPI_EC_SENSOR_SPECIFIC +** These event states are implementation-specific. +*/ +#define SAHPI_ES_STATE_00 (SaHpiEventStateT)0x0001 +#define SAHPI_ES_STATE_01 (SaHpiEventStateT)0x0002 +#define SAHPI_ES_STATE_02 (SaHpiEventStateT)0x0004 +#define SAHPI_ES_STATE_03 (SaHpiEventStateT)0x0008 +#define SAHPI_ES_STATE_04 (SaHpiEventStateT)0x0010 +#define SAHPI_ES_STATE_05 (SaHpiEventStateT)0x0020 +#define SAHPI_ES_STATE_06 (SaHpiEventStateT)0x0040 +#define SAHPI_ES_STATE_07 (SaHpiEventStateT)0x0080 +#define SAHPI_ES_STATE_08 (SaHpiEventStateT)0x0100 +#define SAHPI_ES_STATE_09 (SaHpiEventStateT)0x0200 +#define SAHPI_ES_STATE_10 (SaHpiEventStateT)0x0400 +#define SAHPI_ES_STATE_11 (SaHpiEventStateT)0x0800 +#define SAHPI_ES_STATE_12 (SaHpiEventStateT)0x1000 +#define SAHPI_ES_STATE_13 (SaHpiEventStateT)0x2000 +#define SAHPI_ES_STATE_14 (SaHpiEventStateT)0x4000 + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Sensors ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* Sensor Number */ +typedef SaHpiInstrumentIdT SaHpiSensorNumT; +/* The following specifies the named range for standard sensor numbers. */ +#define SAHPI_STANDARD_SENSOR_MIN (SaHpiSensorNumT)0x00000100 +#define SAHPI_STANDARD_SENSOR_MAX (SaHpiSensorNumT)0x000001FF + +/* Type of Sensor */ +typedef enum { + SAHPI_TEMPERATURE = 0x01, + SAHPI_VOLTAGE, + SAHPI_CURRENT, + SAHPI_FAN, + SAHPI_PHYSICAL_SECURITY, + SAHPI_PLATFORM_VIOLATION, + SAHPI_PROCESSOR, + SAHPI_POWER_SUPPLY, + SAHPI_POWER_UNIT, + SAHPI_COOLING_DEVICE, + SAHPI_OTHER_UNITS_BASED_SENSOR, + SAHPI_MEMORY, + SAHPI_DRIVE_SLOT, + SAHPI_POST_MEMORY_RESIZE, + SAHPI_SYSTEM_FW_PROGRESS, + SAHPI_EVENT_LOGGING_DISABLED, + SAHPI_RESERVED1, + SAHPI_SYSTEM_EVENT, + SAHPI_CRITICAL_INTERRUPT, + SAHPI_BUTTON, + SAHPI_MODULE_BOARD, + SAHPI_MICROCONTROLLER_COPROCESSOR, + SAHPI_ADDIN_CARD, + SAHPI_CHASSIS, + SAHPI_CHIP_SET, + SAHPI_OTHER_FRU, + SAHPI_CABLE_INTERCONNECT, + SAHPI_TERMINATOR, + SAHPI_SYSTEM_BOOT_INITIATED, + SAHPI_BOOT_ERROR, + SAHPI_OS_BOOT, + SAHPI_OS_CRITICAL_STOP, + SAHPI_SLOT_CONNECTOR, + SAHPI_SYSTEM_ACPI_POWER_STATE, + SAHPI_RESERVED2, + SAHPI_PLATFORM_ALERT, + SAHPI_ENTITY_PRESENCE, + SAHPI_MONITOR_ASIC_IC, + SAHPI_LAN, + SAHPI_MANAGEMENT_SUBSYSTEM_HEALTH, + SAHPI_BATTERY, + SAHPI_OPERATIONAL = 0xA0, + SAHPI_OEM_SENSOR=0xC0 +} SaHpiSensorTypeT; + +/* +** Sensor Reading Type +** +** These definitions list the available data types that can be +** used for sensor readings. +** +*/ + +#define SAHPI_SENSOR_BUFFER_LENGTH 32 + +typedef enum { + SAHPI_SENSOR_READING_TYPE_INT64, + SAHPI_SENSOR_READING_TYPE_UINT64, + SAHPI_SENSOR_READING_TYPE_FLOAT64, + SAHPI_SENSOR_READING_TYPE_BUFFER /* 32 byte array. The format of + the buffer is implementation- + specific. Sensors that use + this reading type may not have + thresholds that are settable + or readable. */ +} SaHpiSensorReadingTypeT; + +typedef union { + SaHpiInt64T SensorInt64; + SaHpiUint64T SensorUint64; + SaHpiFloat64T SensorFloat64; + SaHpiUint8T SensorBuffer[SAHPI_SENSOR_BUFFER_LENGTH]; +} SaHpiSensorReadingUnionT; + +/* +** Sensor Reading +** +** The sensor reading data structure is returned from a call to get +** sensor reading. The structure is also used when setting and getting sensor +** threshold values and reporting sensor ranges. +** +** IsSupported is set when a sensor reading/threshold value is available. +** Otherwise, if no reading or threshold is supported, this flag is set to +** False. +** +*/ + +typedef struct { + SaHpiBoolT IsSupported; + SaHpiSensorReadingTypeT Type; + SaHpiSensorReadingUnionT Value; +} SaHpiSensorReadingT; + + +/* Sensor Event Mask Actions - used with saHpiSensorEventMasksSet() */ + +typedef enum { + SAHPI_SENS_ADD_EVENTS_TO_MASKS, + SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS +} SaHpiSensorEventMaskActionT; + +/* Value to use for AssertEvents or DeassertEvents parameter + in saHpiSensorEventMasksSet() to set or clear all supported + event states for a sensor in the mask */ + +#define SAHPI_ALL_EVENT_STATES (SaHpiEventStateT)0xFFFF + +/* +** Threshold Values +** This structure encompasses all of the thresholds that can be set. +** These are set and read with the same units as sensors report in +** saHpiSensorReadingGet(). When hysteresis is not constant over the +** range of sensor values, it is calculated at the nominal sensor reading, +** as given in the Range field of the sensor RDR. +** +** Thresholds are required to be set in-order (such that the setting for +** UpCritical is greater than or equal to the setting for UpMajor, etc.).*/ + +typedef struct { + SaHpiSensorReadingT LowCritical; /* Lower Critical Threshold */ + SaHpiSensorReadingT LowMajor; /* Lower Major Threshold */ + SaHpiSensorReadingT LowMinor; /* Lower Minor Threshold */ + SaHpiSensorReadingT UpCritical; /* Upper critical Threshold */ + SaHpiSensorReadingT UpMajor; /* Upper major Threshold */ + SaHpiSensorReadingT UpMinor; /* Upper minor Threshold */ + SaHpiSensorReadingT PosThdHysteresis; /* Positive Threshold Hysteresis */ + SaHpiSensorReadingT NegThdHysteresis; /* Negative Threshold Hysteresis */ +}SaHpiSensorThresholdsT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Sensor Resource Data Records ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* +** Sensor Range +** Sensor range values can include minimum, maximum, normal minimum, normal +** maximum, and nominal values. +** +** Sensor thresholds cannot be set outside of the range defined by SAHPI_SRF_MIN +** through SAHPI_SRF_MAX, if these limits are present (as indicated by the +** SaHpiSensorRangeFlagsT). If the MIN limit is not present, no lower bound +** will be enforced on sensor thresholds. If the MAX limit is not present, no +** upper bound will be enforced on sensor thresholds. +*/ +typedef SaHpiUint8T SaHpiSensorRangeFlagsT; +#define SAHPI_SRF_MIN (SaHpiSensorRangeFlagsT)0x10 +#define SAHPI_SRF_MAX (SaHpiSensorRangeFlagsT)0x08 +#define SAHPI_SRF_NORMAL_MIN (SaHpiSensorRangeFlagsT)0x04 +#define SAHPI_SRF_NORMAL_MAX (SaHpiSensorRangeFlagsT)0x02 +#define SAHPI_SRF_NOMINAL (SaHpiSensorRangeFlagsT)0x01 + +typedef struct { + SaHpiSensorRangeFlagsT Flags; + SaHpiSensorReadingT Max; + SaHpiSensorReadingT Min; + SaHpiSensorReadingT Nominal; + SaHpiSensorReadingT NormalMax; + SaHpiSensorReadingT NormalMin; +} SaHpiSensorRangeT; + +/* +** Sensor Units +** This is a list of all the sensor units supported by HPI. +*/ +typedef enum { + SAHPI_SU_UNSPECIFIED = 0, SAHPI_SU_DEGREES_C, SAHPI_SU_DEGREES_F, + SAHPI_SU_DEGREES_K, SAHPI_SU_VOLTS, SAHPI_SU_AMPS, + SAHPI_SU_WATTS, SAHPI_SU_JOULES, SAHPI_SU_COULOMBS, + SAHPI_SU_VA, SAHPI_SU_NITS, SAHPI_SU_LUMEN, + SAHPI_SU_LUX, SAHPI_SU_CANDELA, SAHPI_SU_KPA, + SAHPI_SU_PSI, SAHPI_SU_NEWTON, SAHPI_SU_CFM, + SAHPI_SU_RPM, SAHPI_SU_HZ, SAHPI_SU_MICROSECOND, + SAHPI_SU_MILLISECOND, SAHPI_SU_SECOND, SAHPI_SU_MINUTE, + SAHPI_SU_HOUR, SAHPI_SU_DAY, SAHPI_SU_WEEK, + SAHPI_SU_MIL, SAHPI_SU_INCHES, SAHPI_SU_FEET, + SAHPI_SU_CU_IN, SAHPI_SU_CU_FEET, SAHPI_SU_MM, + SAHPI_SU_CM, SAHPI_SU_M, SAHPI_SU_CU_CM, + SAHPI_SU_CU_M, SAHPI_SU_LITERS, SAHPI_SU_FLUID_OUNCE, + SAHPI_SU_RADIANS, SAHPI_SU_STERADIANS, SAHPI_SU_REVOLUTIONS, + SAHPI_SU_CYCLES, SAHPI_SU_GRAVITIES, SAHPI_SU_OUNCE, + SAHPI_SU_POUND, SAHPI_SU_FT_LB, SAHPI_SU_OZ_IN, + SAHPI_SU_GAUSS, SAHPI_SU_GILBERTS, SAHPI_SU_HENRY, + SAHPI_SU_MILLIHENRY, SAHPI_SU_FARAD, SAHPI_SU_MICROFARAD, + SAHPI_SU_OHMS, SAHPI_SU_SIEMENS, SAHPI_SU_MOLE, + SAHPI_SU_BECQUEREL, SAHPI_SU_PPM, SAHPI_SU_RESERVED, + SAHPI_SU_DECIBELS, SAHPI_SU_DBA, SAHPI_SU_DBC, + SAHPI_SU_GRAY, SAHPI_SU_SIEVERT, SAHPI_SU_COLOR_TEMP_DEG_K, + SAHPI_SU_BIT, SAHPI_SU_KILOBIT, SAHPI_SU_MEGABIT, + SAHPI_SU_GIGABIT, SAHPI_SU_BYTE, SAHPI_SU_KILOBYTE, + SAHPI_SU_MEGABYTE, SAHPI_SU_GIGABYTE, SAHPI_SU_WORD, + SAHPI_SU_DWORD, SAHPI_SU_QWORD, SAHPI_SU_LINE, + SAHPI_SU_HIT, SAHPI_SU_MISS, SAHPI_SU_RETRY, + SAHPI_SU_RESET, SAHPI_SU_OVERRUN, SAHPI_SU_UNDERRUN, + SAHPI_SU_COLLISION, SAHPI_SU_PACKETS, SAHPI_SU_MESSAGES, + SAHPI_SU_CHARACTERS, SAHPI_SU_ERRORS, SAHPI_SU_CORRECTABLE_ERRORS, + SAHPI_SU_UNCORRECTABLE_ERRORS +} SaHpiSensorUnitsT; + +/* +** Modifier Unit Use +** This type defines how the modifier unit is used. For example: base unit == +** meter, modifier unit == seconds, and modifier unit use == +** SAHPI_SMUU_BASIC_OVER_MODIFIER. The resulting unit would be meters per +** second. +*/ +typedef enum { + SAHPI_SMUU_NONE = 0, + SAHPI_SMUU_BASIC_OVER_MODIFIER, /* Basic Unit / Modifier Unit */ + SAHPI_SMUU_BASIC_TIMES_MODIFIER /* Basic Unit * Modifier Unit */ +} SaHpiSensorModUnitUseT; + +/* +** Data Format +** When IsSupported is False, the sensor does not support data readings +** (it only supports event states). A False setting for this flag +** indicates that the rest of the structure is not meaningful. +** +** This structure encapsulates all of the various types that make up the +** definition of sensor data. For reading type of +** SAHPI_SENSOR_READING_TYPE_BUFFER, the rest of the structure +** (beyond ReadingType) is not meaningful. +** +** The Accuracy Factor is expressed as a floating point percentage +** (e.g. 0.05 = 5%) and represents statistically how close the measured +** reading is to the actual value. It is an interpreted value that +** figures in all sensor accuracies, resolutions, and tolerances. +*/ + +typedef struct { + SaHpiBoolT IsSupported; /* Indicates if sensor data + readings are supported.*/ + SaHpiSensorReadingTypeT ReadingType; /* Type of value for sensor + reading. */ + SaHpiSensorUnitsT BaseUnits; /* Base units (meters, etc.) */ + SaHpiSensorUnitsT ModifierUnits; /* Modifier unit (second, etc.)*/ + SaHpiSensorModUnitUseT ModifierUse; /* Modifier use(m/sec, etc.) */ + SaHpiBoolT Percentage; /* Is value a percentage */ + SaHpiSensorRangeT Range; /* Valid range of sensor */ + SaHpiFloat64T AccuracyFactor; /* Accuracy */ +} SaHpiSensorDataFormatT; + +/* +** Threshold Support +** +** These types define what threshold values are readable and writable. +** Thresholds are read/written in the same ReadingType as is used for sensor +** readings. +*/ +typedef SaHpiUint8T SaHpiSensorThdMaskT; +#define SAHPI_STM_LOW_MINOR (SaHpiSensorThdMaskT)0x01 +#define SAHPI_STM_LOW_MAJOR (SaHpiSensorThdMaskT)0x02 +#define SAHPI_STM_LOW_CRIT (SaHpiSensorThdMaskT)0x04 +#define SAHPI_STM_UP_MINOR (SaHpiSensorThdMaskT)0x08 +#define SAHPI_STM_UP_MAJOR (SaHpiSensorThdMaskT)0x10 +#define SAHPI_STM_UP_CRIT (SaHpiSensorThdMaskT)0x20 +#define SAHPI_STM_UP_HYSTERESIS (SaHpiSensorThdMaskT)0x40 +#define SAHPI_STM_LOW_HYSTERESIS (SaHpiSensorThdMaskT)0x80 + +typedef struct { + SaHpiBoolT IsAccessible; /* True if the sensor + supports readable or writable + thresholds. If False, + rest of structure is not + meaningful. Sensors that have the + IsAccessible flag set must also + support the threshold event category + A sensor of reading type SAHPI_ + SENSOR_READING_TYPE_BUFFER cannot + have accessible thresholds.*/ + SaHpiSensorThdMaskT ReadThold; /* Readable thresholds */ + SaHpiSensorThdMaskT WriteThold; /* Writable thresholds */ + SaHpiBoolT Nonlinear; /* If this flag is set, hysteresis + values are calculated at the nominal + sensor value. */ +} SaHpiSensorThdDefnT; + +/* +** Event Control +** +** This type defines how sensor event messages can be controlled (can be turned +** off and on for each type of event, etc.). +*/ +typedef enum { + SAHPI_SEC_PER_EVENT = 0, /* Event message control per event, + or by entire sensor; sensor event enable + status can be changed, and assert/deassert + masks can be changed */ + SAHPI_SEC_READ_ONLY_MASKS, /* Control for entire sensor only; sensor + event enable status can be changed, but + assert/deassert masks cannot be changed */ + SAHPI_SEC_READ_ONLY /* Event control not supported; sensor event + enable status cannot be changed and + assert/deassert masks cannot be changed */ +} SaHpiSensorEventCtrlT; + +/* +** Record +** +** This is the sensor resource data record which describes all of the static +** data associated with a sensor. +*/ +typedef struct { + SaHpiSensorNumT Num; /* Sensor Number/Index */ + SaHpiSensorTypeT Type; /* General Sensor Type */ + SaHpiEventCategoryT Category; /* Event category */ + SaHpiBoolT EnableCtrl; /* True if HPI User can enable + or disable sensor via + saHpiSensorEnableSet() */ + SaHpiSensorEventCtrlT EventCtrl; /* How events can be controlled */ + SaHpiEventStateT Events; /* Bit mask of event states + supported */ + SaHpiSensorDataFormatT DataFormat; /* Format of the data */ + SaHpiSensorThdDefnT ThresholdDefn; /* Threshold Definition */ + SaHpiUint32T Oem; /* Reserved for OEM use */ +} SaHpiSensorRecT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Aggregate Status ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* These are the default sensor numbers for aggregate status. */ +#define SAHPI_DEFAGSENS_OPER (SaHpiSensorNumT)0x00000100 +#define SAHPI_DEFAGSENS_PWR (SaHpiSensorNumT)0x00000101 +#define SAHPI_DEFAGSENS_TEMP (SaHpiSensorNumT)0x00000102 + +/* The following specifies the named range for aggregate status. */ +#define SAHPI_DEFAGSENS_MIN (SaHpiSensorNumT)0x00000100 +#define SAHPI_DEFAGSENS_MAX (SaHpiSensorNumT)0x0000010F + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Controls ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* Control Number */ +typedef SaHpiInstrumentIdT SaHpiCtrlNumT; + +/* +** Type of Control +** +** This enumerated type defines the different types of generic controls. +*/ +typedef enum { + SAHPI_CTRL_TYPE_DIGITAL = 0x00, + SAHPI_CTRL_TYPE_DISCRETE, + SAHPI_CTRL_TYPE_ANALOG, + SAHPI_CTRL_TYPE_STREAM, + SAHPI_CTRL_TYPE_TEXT, + SAHPI_CTRL_TYPE_OEM = 0xC0 +} SaHpiCtrlTypeT; + +/* +** Control State Type Definitions +*/ + +/* +** Digital Control State Definition +** +** Defines the types of digital control states. +** Any of the four states may be set using saHpiControlSet(). +** Only ON or OFF are appropriate returns from saHpiControlGet(). +** (PULSE_ON and PULSE_OFF are transitory and end in OFF and ON states, +** respectively.) +** OFF - the control is off +** ON - the control is on +** PULSE_OFF - the control is briefly turned off, and then turned back on +** PULSE_ON - the control is briefly turned on, and then turned back off +** +*/ +typedef enum { + SAHPI_CTRL_STATE_OFF = 0, + SAHPI_CTRL_STATE_ON, + SAHPI_CTRL_STATE_PULSE_OFF, + SAHPI_CTRL_STATE_PULSE_ON +} SaHpiCtrlStateDigitalT; + +/* +** Discrete Control State Definition +*/ +typedef SaHpiUint32T SaHpiCtrlStateDiscreteT; + +/* +** Analog Control State Definition +*/ +typedef SaHpiInt32T SaHpiCtrlStateAnalogT; + +/* +** Stream Control State Definition +*/ +#define SAHPI_CTRL_MAX_STREAM_LENGTH 4 +typedef struct { + SaHpiBoolT Repeat; /* Repeat flag */ + SaHpiUint32T StreamLength; /* Length of the data, in bytes, + stored in the stream. */ + SaHpiUint8T Stream[SAHPI_CTRL_MAX_STREAM_LENGTH]; +} SaHpiCtrlStateStreamT; + +/* +** Text Control State Definition +*/ +typedef SaHpiUint8T SaHpiTxtLineNumT; + +/* Reserved number for sending output to all lines */ +#define SAHPI_TLN_ALL_LINES (SaHpiTxtLineNumT)0x00 + +typedef struct { + SaHpiTxtLineNumT Line; /* Operate on line # */ + SaHpiTextBufferT Text; /* Text to display */ +} SaHpiCtrlStateTextT; + +/* +** OEM Control State Definition +*/ +#define SAHPI_CTRL_MAX_OEM_BODY_LENGTH 255 +typedef struct { + SaHpiManufacturerIdT MId; + SaHpiUint8T BodyLength; + SaHpiUint8T Body[SAHPI_CTRL_MAX_OEM_BODY_LENGTH]; /* OEM Specific */ +} SaHpiCtrlStateOemT; + +typedef union { + SaHpiCtrlStateDigitalT Digital; + SaHpiCtrlStateDiscreteT Discrete; + SaHpiCtrlStateAnalogT Analog; + SaHpiCtrlStateStreamT Stream; + SaHpiCtrlStateTextT Text; + SaHpiCtrlStateOemT Oem; +} SaHpiCtrlStateUnionT; + +typedef struct { + SaHpiCtrlTypeT Type; /* Type of control */ + SaHpiCtrlStateUnionT StateUnion; /* Data for control type */ +} SaHpiCtrlStateT; +/* +** Control Mode Type Definition +** +** Controls may be in either AUTO mode or MANUAL mode. +** +*/ +typedef enum { + SAHPI_CTRL_MODE_AUTO, + SAHPI_CTRL_MODE_MANUAL +} SaHpiCtrlModeT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Control Resource Data Records ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* +** Output Type +** +** This enumeration defines the what the control's output will be. +*/ +typedef enum { + SAHPI_CTRL_GENERIC = 0, + SAHPI_CTRL_LED, + SAHPI_CTRL_FAN_SPEED, + SAHPI_CTRL_DRY_CONTACT_CLOSURE, + SAHPI_CTRL_POWER_SUPPLY_INHIBIT, + SAHPI_CTRL_AUDIBLE, + SAHPI_CTRL_FRONT_PANEL_LOCKOUT, + SAHPI_CTRL_POWER_INTERLOCK, + SAHPI_CTRL_POWER_STATE, + SAHPI_CTRL_LCD_DISPLAY, + SAHPI_CTRL_OEM +} SaHpiCtrlOutputTypeT; + +/* +** Specific Record Types +** These types represent the specific types of control resource data records. +*/ +typedef struct { + SaHpiCtrlStateDigitalT Default; +} SaHpiCtrlRecDigitalT; + +typedef struct { + SaHpiCtrlStateDiscreteT Default; +} SaHpiCtrlRecDiscreteT; + +typedef struct { + SaHpiCtrlStateAnalogT Min; /* Minimum Value */ + SaHpiCtrlStateAnalogT Max; /* Maximum Value */ + SaHpiCtrlStateAnalogT Default; +} SaHpiCtrlRecAnalogT; + +typedef struct { + SaHpiCtrlStateStreamT Default; +} SaHpiCtrlRecStreamT; + +typedef struct { + SaHpiUint8T MaxChars; /* Maximum chars per line. + If the control DataType is + SAHPI_TL_TYPE_UNICODE, there will + be two bytes required for each + character. This field reports the + number of characters per line- not the + number of bytes. MaxChars must not be + larger than the number of characters + that can be placed in a single + SaHpiTextBufferT structure. */ + SaHpiUint8T MaxLines; /* Maximum # of lines */ + SaHpiLanguageT Language; /* Language Code */ + SaHpiTextTypeT DataType; /* Permitted Data */ + SaHpiCtrlStateTextT Default; +} SaHpiCtrlRecTextT; + +#define SAHPI_CTRL_OEM_CONFIG_LENGTH 10 +typedef struct { + SaHpiManufacturerIdT MId; + SaHpiUint8T ConfigData[SAHPI_CTRL_OEM_CONFIG_LENGTH]; + SaHpiCtrlStateOemT Default; +} SaHpiCtrlRecOemT; + +typedef union { + SaHpiCtrlRecDigitalT Digital; + SaHpiCtrlRecDiscreteT Discrete; + SaHpiCtrlRecAnalogT Analog; + SaHpiCtrlRecStreamT Stream; + SaHpiCtrlRecTextT Text; + SaHpiCtrlRecOemT Oem; +} SaHpiCtrlRecUnionT; + +/* +** Default Control Mode Structure +** This structure tells an HPI User if the control comes up in Auto mode or +** in Manual mode, by default. It also indicates if the mode can be +** changed (using saHpiControlSet()). When ReadOnly is False, the mode +** can be changed from its default setting; otherwise attempting to +** change the mode will result in an error. +*/ +typedef struct { + SaHpiCtrlModeT Mode; /* Auto or Manual */ + SaHpiBoolT ReadOnly; /* Indicates if mode is read-only */ +} SaHpiCtrlDefaultModeT; + +/* +** Record Definition +** Definition of the control resource data record. +*/ +typedef struct { + SaHpiCtrlNumT Num; /* Control Number/Index */ + SaHpiCtrlOutputTypeT OutputType; + SaHpiCtrlTypeT Type; /* Type of control */ + SaHpiCtrlRecUnionT TypeUnion; /* Specific control record */ + SaHpiCtrlDefaultModeT DefaultMode; /*Indicates if the control comes up + in Auto or Manual mode. */ + SaHpiBoolT WriteOnly; /* Indicates if the control is + write-only. */ + SaHpiUint32T Oem; /* Reserved for OEM use */ +} SaHpiCtrlRecT; + + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Inventory Data Repositories ********** +********** ********** +******************************************************************************** +*******************************************************************************/ +/* +** These structures are used to read and write inventory data to entity +** inventory data repositories within a resource. +*/ +/* +** Inventory Data Repository ID +** Identifier for an inventory data repository. +*/ +typedef SaHpiInstrumentIdT SaHpiIdrIdT; +#define SAHPI_DEFAULT_INVENTORY_ID (SaHpiIdrIdT)0x00000000 + +/* Inventory Data Area type definitions */ +typedef enum { + SAHPI_IDR_AREATYPE_INTERNAL_USE = 0xB0, + SAHPI_IDR_AREATYPE_CHASSIS_INFO, + SAHPI_IDR_AREATYPE_BOARD_INFO, + SAHPI_IDR_AREATYPE_PRODUCT_INFO, + SAHPI_IDR_AREATYPE_OEM = 0xC0, + SAHPI_IDR_AREATYPE_UNSPECIFIED = 0xFF +} SaHpiIdrAreaTypeT; + +/* Inventory Data Field type definitions */ +typedef enum { + SAHPI_IDR_FIELDTYPE_CHASSIS_TYPE, + SAHPI_IDR_FIELDTYPE_MFG_DATETIME, + SAHPI_IDR_FIELDTYPE_MANUFACTURER, + SAHPI_IDR_FIELDTYPE_PRODUCT_NAME, + SAHPI_IDR_FIELDTYPE_PRODUCT_VERSION, + SAHPI_IDR_FIELDTYPE_SERIAL_NUMBER, + SAHPI_IDR_FIELDTYPE_PART_NUMBER, + SAHPI_IDR_FIELDTYPE_FILE_ID, + SAHPI_IDR_FIELDTYPE_ASSET_TAG, + SAHPI_IDR_FIELDTYPE_CUSTOM, + SAHPI_IDR_FIELDTYPE_UNSPECIFIED = 0xFF +} SaHpiIdrFieldTypeT; + +/* Inventory Data Field structure definition */ +typedef struct { + SaHpiEntryIdT AreaId; /* AreaId for the IDA to which */ + /* the Field belongs */ + SaHpiEntryIdT FieldId; /* Field Identifier */ + SaHpiIdrFieldTypeT Type; /* Field Type */ + SaHpiBoolT ReadOnly; /* Describes if a field is read-only. */ + /* All fields in a read-only area are */ + /* flagged as read-only as well.*/ + SaHpiTextBufferT Field; /* Field Data */ +} SaHpiIdrFieldT; + +/* Inventory Data Area header structure definition */ +typedef struct { + SaHpiEntryIdT AreaId; /* Area Identifier */ + SaHpiIdrAreaTypeT Type; /* Type of area */ + SaHpiBoolT ReadOnly; /* Describes if an area is read-only. */ + /* All area headers in a read-only IDR */ + /* are flagged as read-only as well.*/ + SaHpiUint32T NumFields; /* Number of Fields contained in Area */ +} SaHpiIdrAreaHeaderT; + +/* Inventory Data Repository Information structure definition */ +typedef struct { + SaHpiIdrIdT IdrId; /* Repository Identifier */ + SaHpiUint32T UpdateCount; /* The count is incremented any time the */ + /* IDR is changed. It rolls over to zero */ + /* when the maximum value is reached */ + SaHpiBoolT ReadOnly; /* Describes if the IDR is read-only. */ + /* All area headers and fields in a */ + /* read-only IDR are flagged as */ + /* read-only as well.*/ + SaHpiUint32T NumAreas; /* Number of Area contained in IDR */ +} SaHpiIdrInfoT; + + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Inventory Data Repository Resource Data Records ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* +** All inventory data contained in an inventory data repository +** must be represented in the RDR repository +** with an SaHpiInventoryRecT. +*/ +typedef struct { + SaHpiIdrIdT IdrId; + SaHpiBoolT Persistent; /* True indicates that updates to IDR are + automatically and immediately persisted. + False indicates that updates are not + immediately persisted; but optionally may be + persisted via saHpiParmControl() function, as + defined in implementation documentation.*/ + SaHpiUint32T Oem; +} SaHpiInventoryRecT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Watchdogs ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* +** This section defines all of the data types associated with watchdog timers. +*/ + +/* Watchdog Number - Identifier for a watchdog timer. */ +typedef SaHpiInstrumentIdT SaHpiWatchdogNumT; +#define SAHPI_DEFAULT_WATCHDOG_NUM (SaHpiWatchdogNumT)0x00000000 + +/* +** Watchdog Timer Action +** +** These enumerations represent the possible actions to be taken upon watchdog +** timer timeout and the events that are generated for watchdog actions. +*/ +typedef enum { + SAHPI_WA_NO_ACTION = 0, + SAHPI_WA_RESET, + SAHPI_WA_POWER_DOWN, + SAHPI_WA_POWER_CYCLE +} SaHpiWatchdogActionT; + +typedef enum { + SAHPI_WAE_NO_ACTION = 0, + SAHPI_WAE_RESET, + SAHPI_WAE_POWER_DOWN, + SAHPI_WAE_POWER_CYCLE, + SAHPI_WAE_TIMER_INT=0x08 /* Used if Timer Preinterrupt only */ +} SaHpiWatchdogActionEventT; + +/* +** Watchdog Pre-timer Interrupt +** +** These enumerations represent the possible types of interrupts that may be +** triggered by a watchdog pre-timer event. The actual meaning of these +** operations may differ depending on the hardware architecture. +*/ +typedef enum { + SAHPI_WPI_NONE = 0, + SAHPI_WPI_SMI, + SAHPI_WPI_NMI, + SAHPI_WPI_MESSAGE_INTERRUPT, + SAHPI_WPI_OEM = 0x0F +} SaHpiWatchdogPretimerInterruptT; + +/* +** Watchdog Timer Use +** +** These enumerations represent the possible watchdog users that may have caused +** the watchdog to expire. For instance, if watchdog is being used during power +** on self test (POST), and it expires, the SAHPI_WTU_BIOS_POST expiration type +** will be set. Most specific uses for Watchdog timer by users of HPI should +** indicate SAHPI_WTU_SMS_OS if the use is to provide an OS-healthy heartbeat, +** or SAHPI_WTU_OEM if it is used for some other purpose. +*/ +typedef enum { + SAHPI_WTU_NONE = 0, + SAHPI_WTU_BIOS_FRB2, + SAHPI_WTU_BIOS_POST, + SAHPI_WTU_OS_LOAD, + SAHPI_WTU_SMS_OS, /* System Management System providing + heartbeat for OS */ + SAHPI_WTU_OEM, + SAHPI_WTU_UNSPECIFIED = 0x0F +} SaHpiWatchdogTimerUseT; + +/* +** Timer Use Expiration Flags +** These values are used for the Watchdog Timer Use Expiration flags in the +** SaHpiWatchdogT structure. +*/ +typedef SaHpiUint8T SaHpiWatchdogExpFlagsT; +#define SAHPI_WATCHDOG_EXP_BIOS_FRB2 (SaHpiWatchdogExpFlagsT)0x02 +#define SAHPI_WATCHDOG_EXP_BIOS_POST (SaHpiWatchdogExpFlagsT)0x04 +#define SAHPI_WATCHDOG_EXP_OS_LOAD (SaHpiWatchdogExpFlagsT)0x08 +#define SAHPI_WATCHDOG_EXP_SMS_OS (SaHpiWatchdogExpFlagsT)0x10 +#define SAHPI_WATCHDOG_EXP_OEM (SaHpiWatchdogExpFlagsT)0x20 + +/* +** Watchdog Structure +** +** This structure is used by the saHpiWatchdogTimerGet() and +** saHpiWatchdogTimerSet() functions. The use of the structure varies slightly +** by each function. +** +** For saHpiWatchdogTimerGet() : +** +** Log - indicates whether or not the Watchdog is configured to +** issue events. True=events will be generated. +** Running - indicates whether or not the Watchdog is currently +** running or stopped. True=Watchdog is running. +** TimerUse - indicates the current use of the timer; one of the +** enumerated preset uses which was included on the last +** saHpiWatchdogTimerSet() function call, or through some +** other implementation-dependent means to start the +** Watchdog timer. +** TimerAction - indicates what action will be taken when the Watchdog +** times out. +** PretimerInterrupt - indicates which action will be taken +** "PreTimeoutInterval" milliseconds prior to Watchdog +** timer expiration. +** PreTimeoutInterval - indicates how many milliseconds prior to timer time +** out the PretimerInterrupt action will be taken. If +** "PreTimeoutInterval" = 0, the PretimerInterrupt action +** will occur concurrently with "TimerAction." HPI +** implementations may not be able to support millisecond +** resolution, and because of this may have rounded the +** set value to whatever resolution could be supported. +** The HPI implementation will return this rounded value. +** TimerUseExpFlags - set of five bit flags which indicate that a Watchdog +** timer timeout has occurred while the corresponding +** TimerUse value was set. Once set, these flags stay +** set until specifically cleared with a +** saHpiWatchdogTimerSet() call, or by some other +** implementation-dependent means. +** InitialCount - The time, in milliseconds, before the timer will time +** out after the watchdog is started/restarted, or some +** other implementation-dependent strobe is +** sent to the Watchdog. HPI implementations may not be +** able to support millisecond resolution, and because +** of this may have rounded the set value to whatever +** resolution could be supported. The HPI implementation +** will return this rounded value. +** PresentCount - The remaining time in milliseconds before the timer +** will time out unless a saHpiWatchdogTimerReset() +** function call is made, or some other implementation- +** dependent strobe is sent to the Watchdog. +** HPI implementations may not be able to support +** millisecond resolution on watchdog timers, but will +** return the number of clock ticks remaining times the +** number of milliseconds between each tick. +** +** For saHpiWatchdogTimerSet(): +** +** Log - indicates whether or not the Watchdog should issue +** events. True=event will be generated. +** Running - indicates whether or not the Watchdog should be +** stopped before updating. +** True = Watchdog is not stopped. If it is +** already stopped, it will remain stopped, +** but if it is running, it will continue +** to run, with the countown timer reset +** to the new InitialCount. Note that +** there is a race condition possible +** with this setting, so it should be used +** with care. +** False = Watchdog is stopped. After +** saHpiWatchdogTimerSet() is called, a +** subsequent call to +** saHpiWatchdogTimerReset() is required +** to start the timer. +** TimerUse - indicates the current use of the timer. Will control +** which TimerUseExpFlag is set if the timer expires. +** TimerAction - indicates what action will be taken when the Watchdog +** times out. +** PretimerInterrupt - indicates which action will be taken +** "PreTimeoutInterval" milliseconds prior to Watchdog +** timer expiration. +** PreTimeoutInterval - indicates how many milliseconds prior to timer time +** out the PretimerInterrupt action will be taken. If +** "PreTimeoutInterval" = 0, the PretimerInterrupt action +** will occur concurrently with "TimerAction." HPI +** implementations may not be able to support millisecond +** resolution and may have a maximum value restriction. +** These restrictions should be documented by the +** provider of the HPI interface. +** TimerUseExpFlags - Set of five bit flags corresponding to the five +** TimerUse values. For each bit set, the corresponding +** Timer Use Expiration Flag will be CLEARED. Generally, +** a program should only clear the Timer Use Expiration +** Flag corresponding to its own TimerUse, so that other +** software, which may have used the timer for another +** purpose in the past can still read its TimerUseExpFlag +** to determine whether or not the timer expired during +** that use. +** InitialCount - The time, in milliseconds, before the timer will time +** out after a saHpiWatchdogTimerReset() function call is +** made, or some other implementation-dependent strobe is +** sent to the Watchdog. HPI implementations may not be +** able to support millisecond resolution and may have a +** maximum value restriction. These restrictions should +** be documented by the provider of the HPI interface. +** PresentCount - Not used on saHpiWatchdogTimerSet() function. Ignored. +** +*/ + +typedef struct { + SaHpiBoolT Log; + SaHpiBoolT Running; + SaHpiWatchdogTimerUseT TimerUse; + SaHpiWatchdogActionT TimerAction; + SaHpiWatchdogPretimerInterruptT PretimerInterrupt; + SaHpiUint32T PreTimeoutInterval; + SaHpiWatchdogExpFlagsT TimerUseExpFlags; + SaHpiUint32T InitialCount; + SaHpiUint32T PresentCount; +} SaHpiWatchdogT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Watchdog Resource Data Records ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* +** When the "Watchdog" capability is set in a resource, a watchdog with an +** identifier of SAHPI_DEFAULT_WATCHDOG_NUM is required. All watchdogs must be +** represented in the RDR repository with an SaHpiWatchdogRecT, including the +** watchdog with an identifier of SAHPI_DEFAULT_WATCHDOG_NUM. +*/ +typedef struct { + SaHpiWatchdogNumT WatchdogNum; + SaHpiUint32T Oem; +} SaHpiWatchdogRecT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Hot Swap ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* Hot Swap Indicator State */ +typedef enum { + SAHPI_HS_INDICATOR_OFF = 0, + SAHPI_HS_INDICATOR_ON +} SaHpiHsIndicatorStateT; + +/* Hot Swap Action */ +typedef enum { + SAHPI_HS_ACTION_INSERTION = 0, + SAHPI_HS_ACTION_EXTRACTION +} SaHpiHsActionT; + +/* Hot Swap State */ +typedef enum { + SAHPI_HS_STATE_INACTIVE = 0, + SAHPI_HS_STATE_INSERTION_PENDING, + SAHPI_HS_STATE_ACTIVE, + SAHPI_HS_STATE_EXTRACTION_PENDING, + SAHPI_HS_STATE_NOT_PRESENT +} SaHpiHsStateT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Events, Part 2 ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* Event Data Structures */ + +typedef enum { + SAHPI_CRITICAL = 0, + SAHPI_MAJOR, + SAHPI_MINOR, + SAHPI_INFORMATIONAL, + SAHPI_OK, + SAHPI_DEBUG = 0xF0, + SAHPI_ALL_SEVERITIES = 0xFF /* Only used with DAT and Annunciator */ + /* functions. This is not a valid */ + /* severity for events or alarms */ +} SaHpiSeverityT; + + +typedef enum { + SAHPI_RESE_RESOURCE_FAILURE, + SAHPI_RESE_RESOURCE_RESTORED, + SAHPI_RESE_RESOURCE_ADDED +} SaHpiResourceEventTypeT; + + +typedef struct { + SaHpiResourceEventTypeT ResourceEventType; +} SaHpiResourceEventT; + + +/* +** Domain events are used to announce the addition of domain references +** and the removal of domain references to the DRT. +*/ +typedef enum { + SAHPI_DOMAIN_REF_ADDED, + SAHPI_DOMAIN_REF_REMOVED +} SaHpiDomainEventTypeT; + +typedef struct { + SaHpiDomainEventTypeT Type; /* Type of domain event */ + SaHpiDomainIdT DomainId; /* Domain Id of domain added + to or removed from DRT. */ +} SaHpiDomainEventT; + + +/* +** Sensor Optional Data +** +** Sensor events may contain optional data items passed and stored with the +** event. If these optional data items are present, they will be included with +** the event data returned in response to a saHpiEventGet() or +** saHpiEventLogEntryGet() function call. Also, the optional data items may be +** included with the event data passed to the saHpiEventLogEntryAdd() function. +** +** Specific implementations of HPI may have restrictions on how much data may +** be passed to saHpiEventLogEntryAdd(). These restrictions should be documented +** by the provider of the HPI interface. +*/ +typedef SaHpiUint8T SaHpiSensorOptionalDataT; + +#define SAHPI_SOD_TRIGGER_READING (SaHpiSensorOptionalDataT)0x01 +#define SAHPI_SOD_TRIGGER_THRESHOLD (SaHpiSensorOptionalDataT)0x02 +#define SAHPI_SOD_OEM (SaHpiSensorOptionalDataT)0x04 +#define SAHPI_SOD_PREVIOUS_STATE (SaHpiSensorOptionalDataT)0x08 +#define SAHPI_SOD_CURRENT_STATE (SaHpiSensorOptionalDataT)0x10 +#define SAHPI_SOD_SENSOR_SPECIFIC (SaHpiSensorOptionalDataT)0x20 +typedef struct { + SaHpiSensorNumT SensorNum; + SaHpiSensorTypeT SensorType; + SaHpiEventCategoryT EventCategory; + SaHpiBoolT Assertion; /* True = Event State + asserted + False = deasserted */ + SaHpiEventStateT EventState; /* single state being asserted + or deasserted*/ + SaHpiSensorOptionalDataT OptionalDataPresent; + /* the following fields are only valid if the corresponding flag is set + in the OptionalDataPresent field */ + SaHpiSensorReadingT TriggerReading; /* Reading that triggered + the event */ + SaHpiSensorReadingT TriggerThreshold; /* Value of the threshold + that was crossed. Will not + be present if threshold is + not readable. */ + SaHpiEventStateT PreviousState; /* Previous set of asserted + event states. If multiple + event states change at once, + multiple events may be + generated for each changing + event state. This field + should indicate the status of + the sensor event states prior + to any of the simultaneous + changes. + + Thus, it will be the same in + each event generated due to + multiple simultaneous event + state changes. */ + + SaHpiEventStateT CurrentState; /* Current set of asserted + event states. */ + SaHpiUint32T Oem; + SaHpiUint32T SensorSpecific; +} SaHpiSensorEventT; + +typedef SaHpiUint8T SaHpiSensorEnableOptDataT; + +#define SAHPI_SEOD_CURRENT_STATE (SaHpiSensorEnableOptDataT)0x10 + +typedef struct { + SaHpiSensorNumT SensorNum; + SaHpiSensorTypeT SensorType; + SaHpiEventCategoryT EventCategory; + SaHpiBoolT SensorEnable; /* current sensor enable status */ + SaHpiBoolT SensorEventEnable; /* current evt enable status */ + SaHpiEventStateT AssertEventMask; /* current assert event mask */ + SaHpiEventStateT DeassertEventMask; /* current deassert evt mask */ + SaHpiSensorEnableOptDataT OptionalDataPresent; + /* the following fields are only valid if the corresponding flag is set + in the OptionalDataPresent field */ + SaHpiEventStateT CurrentState; /* Current set of asserted + Event states. */ +} SaHpiSensorEnableChangeEventT; + +typedef struct { + SaHpiHsStateT HotSwapState; + SaHpiHsStateT PreviousHotSwapState; +} SaHpiHotSwapEventT; + +typedef struct { + SaHpiWatchdogNumT WatchdogNum; + SaHpiWatchdogActionEventT WatchdogAction; + SaHpiWatchdogPretimerInterruptT WatchdogPreTimerAction; + SaHpiWatchdogTimerUseT WatchdogUse; +} SaHpiWatchdogEventT; + +/* +** The following type defines the types of events that can be reported +** by the HPI software implementation. +** +** Audit events report a discrepancy in the audit process. Audits are typically +** performed by HA software to detect problems. Audits may look for such things +** as corrupted data stores, inconsistent RPT information, or improperly managed +** queues. +** +** Startup events report a failure to start-up properly, or inconsistencies in +** persisted data. +*/ +typedef enum { + SAHPI_HPIE_AUDIT, + SAHPI_HPIE_STARTUP, + SAHPI_HPIE_OTHER +} SaHpiSwEventTypeT; + +typedef struct { + SaHpiManufacturerIdT MId; + SaHpiSwEventTypeT Type; + SaHpiTextBufferT EventData; +} SaHpiHpiSwEventT; + +typedef struct { + SaHpiManufacturerIdT MId; + SaHpiTextBufferT OemEventData; +} SaHpiOemEventT; + +/* +** User events may be used for storing custom events created by an HPI User +** when injecting events into the Event Log using saHpiEventLogEntryAdd(). +*/ +typedef struct { + SaHpiTextBufferT UserEventData; +} SaHpiUserEventT; + +typedef enum { + SAHPI_ET_RESOURCE, + SAHPI_ET_DOMAIN, + SAHPI_ET_SENSOR, + SAHPI_ET_SENSOR_ENABLE_CHANGE, + SAHPI_ET_HOTSWAP, + SAHPI_ET_WATCHDOG, + SAHPI_ET_HPI_SW, + SAHPI_ET_OEM, + SAHPI_ET_USER +} SaHpiEventTypeT; + +typedef union { + SaHpiResourceEventT ResourceEvent; + SaHpiDomainEventT DomainEvent; + SaHpiSensorEventT SensorEvent; + SaHpiSensorEnableChangeEventT SensorEnableChangeEvent; + SaHpiHotSwapEventT HotSwapEvent; + SaHpiWatchdogEventT WatchdogEvent; + SaHpiHpiSwEventT HpiSwEvent; + SaHpiOemEventT OemEvent; + SaHpiUserEventT UserEvent; +} SaHpiEventUnionT; + +typedef struct { + SaHpiResourceIdT Source; + SaHpiEventTypeT EventType; + SaHpiTimeT Timestamp; /*Equal to SAHPI_TIME_UNSPECIFED if time is + not available; Absolute time if greater + than SAHPI_TIME_MAX_RELATIVE, Relative + time if less than or equal to + SAHPI_TIME_MAX_RELATIVE */ + SaHpiSeverityT Severity; + SaHpiEventUnionT EventDataUnion; +} SaHpiEventT; + +/* +** Event Queue Status +** +** This status word is returned to HPI Users that request it +** when saHpiEventGet() is called. +** +*/ + +typedef SaHpiUint32T SaHpiEvtQueueStatusT; + +#define SAHPI_EVT_QUEUE_OVERFLOW (SaHpiEvtQueueStatusT)0x0001 + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Annunciators ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* +** Annunciator Number +** Identifier for an Annunciator management instrument. +*/ +typedef SaHpiInstrumentIdT SaHpiAnnunciatorNumT; + +/* +** The following data type is equivalent to the AIS data type SaNameT. +** it is defined in this header file, so that inclusion of the AIS +** header file is not required. This data type is based on version 1.0 +** of the AIS specification +*/ +#define SA_HPI_MAX_NAME_LENGTH 256 + +typedef struct { + SaHpiUint16T Length; + unsigned char Value[SA_HPI_MAX_NAME_LENGTH]; +} SaHpiNameT; + +/* +** Enumeration of Announcement Types +*/ +typedef enum { + SAHPI_STATUS_COND_TYPE_SENSOR, + SAHPI_STATUS_COND_TYPE_RESOURCE, + SAHPI_STATUS_COND_TYPE_OEM, + SAHPI_STATUS_COND_TYPE_USER +} SaHpiStatusCondTypeT; + + +/* Condition structure definition */ +typedef struct { + + SaHpiStatusCondTypeT Type; /* Status Condition Type */ + SaHpiEntityPathT Entity; /* Entity assoc. with status condition */ + SaHpiDomainIdT DomainId; /* Domain associated with status. + May be SAHPI_UNSPECIFIED_DOMAIND_ID + meaning current domain, or domain + not meaningful for status condition*/ + SaHpiResourceIdT ResourceId; /* Resource associated with status. + May be SAHPI_UNSPECIFIED_RESOURCE_ID + if Type is SAHPI_STATUS_COND_USER. + Must be set to valid ResourceId in + domain specified by DomainId, + or in current domain, if DomainId + is SAHPI_UNSPECIFIED_DOMAIN_ID */ + SaHpiSensorNumT SensorNum; /* Sensor associated with status + Only valid if Type is + SAHPI_STATUS_COND_TYPE_SENSOR */ + SaHpiEventStateT EventState; /* Sensor event state. + Only valid if Type is + SAHPI_STATUS_COND_TYPE_SENSOR. */ + SaHpiNameT Name; /* AIS compatible identifier associated + with Status condition */ + SaHpiManufacturerIdT Mid; /* Manufacturer Id associated with + status condition, required when type + is SAHPI_STATUS_COND_TYPE_OEM. */ + SaHpiTextBufferT Data; /* Optional Data associated with + Status condition */ +} SaHpiConditionT; + + +/* Announcement structure definition */ +typedef struct { + SaHpiEntryIdT EntryId; /* Announcment Entry Id */ + SaHpiTimeT Timestamp; /* Time when announcement added to set */ + SaHpiBoolT AddedByUser; /* True if added to set by HPI User, + False if added automatically by + HPI implementation */ + SaHpiSeverityT Severity; /* Severity of announcement */ + SaHpiBoolT Acknowledged; /* Acknowledged flag */ + SaHpiConditionT StatusCond; /* Detailed status condition */ +} SaHpiAnnouncementT; + + +/* Annunciator Mode - defines who may add or delete entries in set. */ + +typedef enum { + SAHPI_ANNUNCIATOR_MODE_AUTO, + SAHPI_ANNUNCIATOR_MODE_USER, + SAHPI_ANNUNCIATOR_MODE_SHARED +} SaHpiAnnunciatorModeT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Annunciator Resource Data Records ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* +** The following enumerated type defines the possible output types +** which can be associated with an Annunciator Management Instrument +*/ +typedef enum { + SAHPI_ANNUNCIATOR_TYPE_LED = 0, + SAHPI_ANNUNCIATOR_TYPE_DRY_CONTACT_CLOSURE, + SAHPI_ANNUNCIATOR_TYPE_AUDIBLE, + SAHPI_ANNUNCIATOR_TYPE_LCD_DISPLAY, + SAHPI_ANNUNCIATOR_TYPE_MESSAGE, + SAHPI_ANNUNCIATOR_TYPE_COMPOSITE, + SAHPI_ANNUNCIATOR_TYPE_OEM +} SaHpiAnnunciatorTypeT; + + +/* +** All annunciator management instruments +** must be represented in the RDR repository +** with an SaHpiAnnunciatorRecT. +*/ +typedef struct { + SaHpiAnnunciatorNumT AnnunciatorNum; + SaHpiAnnunciatorTypeT AnnunciatorType; /* Annunciator Output Type */ + SaHpiBoolT ModeReadOnly; /* if True, Mode may + not be changed by HPI User */ + SaHpiUint32T MaxConditions; /* maximum number of conditions + that can be held in current + set. 0 means no fixed + limit. */ + SaHpiUint32T Oem; +} SaHpiAnnunciatorRecT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Resource Data Record ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* +** The following describes the different types of records that exist within a +** RDR repository and the RDR super-structure to all of the specific RDR types +** (sensor, inventory data, watchdog, etc.). +*/ +typedef enum { + SAHPI_NO_RECORD, + SAHPI_CTRL_RDR, + SAHPI_SENSOR_RDR, + SAHPI_INVENTORY_RDR, + SAHPI_WATCHDOG_RDR, + SAHPI_ANNUNCIATOR_RDR +} SaHpiRdrTypeT; + +typedef union { + SaHpiCtrlRecT CtrlRec; + SaHpiSensorRecT SensorRec; + SaHpiInventoryRecT InventoryRec; + SaHpiWatchdogRecT WatchdogRec; + SaHpiAnnunciatorRecT AnnunciatorRec; +} SaHpiRdrTypeUnionT; + +typedef struct { + SaHpiEntryIdT RecordId; + SaHpiRdrTypeT RdrType; + SaHpiEntityPathT Entity; /* Entity to which this RDR relates. */ + SaHpiBoolT IsFru; /* Entity is a FRU. This field is + Only valid if the Entity path given + in the "Entity" field is different + from the Entity path in the RPT + entry for the resource. */ + SaHpiRdrTypeUnionT RdrTypeUnion; + SaHpiTextBufferT IdString; +} SaHpiRdrT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Parameter Control ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +typedef enum { + SAHPI_DEFAULT_PARM = 0, + SAHPI_SAVE_PARM, + SAHPI_RESTORE_PARM +} SaHpiParmActionT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Reset ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +typedef enum { + SAHPI_COLD_RESET = 0, + SAHPI_WARM_RESET, + SAHPI_RESET_ASSERT, + SAHPI_RESET_DEASSERT +} SaHpiResetActionT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Power ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +typedef enum { + SAHPI_POWER_OFF = 0, + SAHPI_POWER_ON, + SAHPI_POWER_CYCLE +} SaHpiPowerStateT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Resource Presence Table ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* This section defines the types associated with the RPT. */ + +/* +** GUID - Globally Unique Identifier +** +** The format if the ID follows that specified by the Wired for Management +** Baseline, Version 2.0 specification. HPI uses version 1 of the GUID +** format, with a 3-bit variant field of 10x (where x indicates 'don't care') +*/ +typedef SaHpiUint8T SaHpiGuidT[16]; + +/* +** Resource Info Type Definitions +** +** +** SaHpiResourceInfoT contains static configuration data concerning the +** management controller associated with the resource, or the resource itself. +** Note this information is used to describe the resource; that is, the piece of +** infrastructure which manages an entity (or multiple entities) - NOT the +** entities for which the resource provides management. The purpose of the +** SaHpiResourceInfoT structure is to provide information that an HPI User may +** need in order to interact correctly with the resource (e.g., recognize a +** specific management controller which may have defined OEM fields in sensors, +** OEM controls, etc.). +** +** The GUID is used to uniquely identify a Resource. A GUID value of zero is not +** valid and indicates that the Resource does not have an associated GUID. +** +** All of the fields in the following structure may or may not be used by a +** given resource. +*/ +typedef struct { + SaHpiUint8T ResourceRev; + SaHpiUint8T SpecificVer; + SaHpiUint8T DeviceSupport; + SaHpiManufacturerIdT ManufacturerId; + SaHpiUint16T ProductId; + SaHpiUint8T FirmwareMajorRev; + SaHpiUint8T FirmwareMinorRev; + SaHpiUint8T AuxFirmwareRev; + SaHpiGuidT Guid; +} SaHpiResourceInfoT; + +/* +** Resource Capabilities +** +** This definition defines the capabilities of a given resource. One resource +** may support any number of capabilities using the bit mask. Because each entry +** in an RPT will have the SAHPI_CAPABILITY_RESOURCE bit set, zero is not a +** valid value for the capability flag, and is thus used to indicate "no RPT +** entry present" in some function calls. +** +** SAHPI_CAPABILITY_RESOURCE +** SAHPI_CAPABILITY_EVT_DEASSERTS +** Indicates that all sensors on the resource have the property that their +** Assertion and Deassertion event enable flags are the same. That is, +** for all event states whose assertion triggers an event, it is +** guaranteed that the deassertion of that event will also +** trigger an event. Thus, an HPI User may track the state of sensors on the +** resource by monitoring events rather than polling for state changes. +** SAHPI_CAPABILITY_AGGREGATE_STATUS +** SAHPI_CAPABILITY_CONFIGURATION +** SAHPI_CAPABILITY_MANAGED_HOTSWAP +** Indicates that the resource supports the full managed hot swap model. +** Since hot swap only makes sense for field-replaceable units, the +** SAHPI_CAPABILITY_FRU capability bit must also be set for this resource. +** SAHPI_CAPABILITY_WATCHDOG +** SAHPI_CAPABILITY_CONTROL +** SAHPI_CAPABILITY_FRU +** Indicates that the resource is a field-replaceable unit; i.e., it is +** capable of being removed and replaced in a live system. If +** SAHPI_CAPABILITY_MANAGED_HOTSWAP is also set, the resource supports +** the full hot swap model. If SAHPI_CAPABILITY_MANAGED_HOTSWAP is not +** set, the resource supports the simplified hot swap model. +** SAHPI_CAPABILITY_ANNUNCIATOR +** SAHPI_CAPABILITY_POWER +** SAHPI_CAPABILITY_RESET +** SAHPI_CAPABILITY_INVENTORY_DATA +** SAHPI_CAPABILITY_EVENT_LOG +** SAHPI_CAPABILITY_RDR +** Indicates that a resource data record (RDR) repository is supplied +** by the resource. Since the existence of an RDR is mandatory for all +** management instruments, this +** capability must be asserted if the resource +** contains any sensors, controls, watchdog timers, or inventory +** data repositories. +** SAHPI_CAPABILITY_SENSOR +*/ + +typedef SaHpiUint32T SaHpiCapabilitiesT; +#define SAHPI_CAPABILITY_RESOURCE (SaHpiCapabilitiesT)0X40000000 +#define SAHPI_CAPABILITY_EVT_DEASSERTS (SaHpiCapabilitiesT)0x00008000 +#define SAHPI_CAPABILITY_AGGREGATE_STATUS (SaHpiCapabilitiesT)0x00002000 +#define SAHPI_CAPABILITY_CONFIGURATION (SaHpiCapabilitiesT)0x00001000 +#define SAHPI_CAPABILITY_MANAGED_HOTSWAP (SaHpiCapabilitiesT)0x00000800 +#define SAHPI_CAPABILITY_WATCHDOG (SaHpiCapabilitiesT)0x00000400 +#define SAHPI_CAPABILITY_CONTROL (SaHpiCapabilitiesT)0x00000200 +#define SAHPI_CAPABILITY_FRU (SaHpiCapabilitiesT)0x00000100 +#define SAHPI_CAPABILITY_ANNUNCIATOR (SaHpiCapabilitiesT)0x00000040 +#define SAHPI_CAPABILITY_POWER (SaHpiCapabilitiesT)0x00000020 +#define SAHPI_CAPABILITY_RESET (SaHpiCapabilitiesT)0x00000010 +#define SAHPI_CAPABILITY_INVENTORY_DATA (SaHpiCapabilitiesT)0x00000008 +#define SAHPI_CAPABILITY_EVENT_LOG (SaHpiCapabilitiesT)0x00000004 +#define SAHPI_CAPABILITY_RDR (SaHpiCapabilitiesT)0x00000002 +#define SAHPI_CAPABILITY_SENSOR (SaHpiCapabilitiesT)0x00000001 + +/* +** Resource Managed Hot Swap Capabilities +** +** This definition defines the managed hot swap capabilities of a given +** resource. +** +** SAHPI_HS_CAPABILITY_AUTOEXTRACT_READ_ONLY +** This capability indicates if the hot swap autoextract timer is read-only. +** SAHPI_HS_CAPABILITY_INDICATOR_SUPPORTED +** Indicates whether or not the resource has a hot swap indicator. +*/ + +typedef SaHpiUint32T SaHpiHsCapabilitiesT; +#define SAHPI_HS_CAPABILITY_AUTOEXTRACT_READ_ONLY \ + (SaHpiHsCapabilitiesT)0x80000000 +#define SAHPI_HS_CAPABILITY_INDICATOR_SUPPORTED \ + (SaHpiHsCapabilitiesT)0X40000000 +/* +** RPT Entry +** +** This structure is used to store the RPT entry information. +** +** The ResourceCapabilities field definies the capabilities of the resource. +** This field must be non-zero for all valid resources. +** +** The HotSwapCapabilities field denotes the capabilities of the resource, +** specifically related to hot swap. This field is only valid if the +** resource supports managed hot swap, as indicated by the +** SAHPI_CAPABILITY_MANAGED_HOT_SWAP resource capability. +** +** The ResourceTag is a data field within an RPT entry available to the HPI +** User for associating application specific data with a resource. The HPI +** User supplied data is purely informational and is not used by the HPI +** implementation, domain, or associated resource. For example, an HPI User +** can set the resource tag to a "descriptive" value, which can be used to +** identify the resource in messages to a human operator. +*/ +typedef struct { + SaHpiEntryIdT EntryId; + SaHpiResourceIdT ResourceId; + SaHpiResourceInfoT ResourceInfo; + SaHpiEntityPathT ResourceEntity; /* If resource manages a FRU, entity + path of the FRU */ + /* If resource manages a single + entity, entity path of that + entity. */ + /* If resource manages multiple + entities, the entity path of the + "primary" entity managed by the + resource */ + /* Must be set to the same value in + every domain which contains this + resource */ + SaHpiCapabilitiesT ResourceCapabilities; /* Must be non-0. */ + SaHpiHsCapabilitiesT HotSwapCapabilities; /* Indicates the hot swap + capabilities of the resource */ + SaHpiSeverityT ResourceSeverity; /* Indicates the criticality that + should be raised when the resource + is not responding */ + SaHpiBoolT ResourceFailed; /* Indicates that the resource is not + currently functional */ + SaHpiTextBufferT ResourceTag; +} SaHpiRptEntryT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Domain Information ********** +********** ********** +******************************************************************************** +*******************************************************************************/ + +/* This section defines the types associated with the domain controller. */ + +/* +** Domain Capabilities +** +** This definition defines the capabilities of a given domain. A domain +** may support any number of capabilities using the bit mask. +** +** SAHPI_DOMAIN_CAP_AUTOINSERT_READ_ONLY +** Indicates that the domain auto insert timeout value is read-only +** and may not be modified using the saHpiHotSwapAutoInsertTimeoutSet() +** function. +*/ + +typedef SaHpiUint32T SaHpiDomainCapabilitiesT; +#define SAHPI_DOMAIN_CAP_AUTOINSERT_READ_ONLY \ + (SaHpiDomainCapabilitiesT)0X00000001 + +/* +** Domain Info +** +** This structure is used to store the information regarding the domain +** including information regarding the domain reference table (DRT) and +** the resource presence table (RPT). +** +** The DomainTag field is an informational value that supplies an HPI User +** with naming information for the domain. +** +** NOTE: Regarding timestamps - If the implementation cannot supply an absolute +** timestamp, then it may supply a timestamp relative to some system-defined +** epoch, such as system boot. The value SAHPI_TIME_UNSPECIFIED indicates that +** the time of the update cannot be determined. Otherwise, If the value is less +** than or equal to SAHPI_TIME_MAX_RELATIVE, then it is relative; if it is +** greater than SAHPI_TIME_MAX_RELATIVE, then it is absolute. +** +** The GUID is used to uniquely identify a domain. A GUID value of zero is not +** valid and indicates that the domain does not have an associated GUID. +*/ + +typedef struct { + SaHpiDomainIdT DomainId; /* Unique Domain Id associated with + domain */ + SaHpiDomainCapabilitiesT DomainCapabilities; /* Domain Capabilities */ + SaHpiBoolT IsPeer; /* Indicates that this domain + participates in a peer + relationship. */ + SaHpiTextBufferT DomainTag; /* Information tag associated with + domain */ + SaHpiUint32T DrtUpdateCount; /* This count is incremented any time the + table is changed. It rolls over to + zero when the maximum value is + reached */ + SaHpiTimeT DrtUpdateTimestamp; /* This timestamp is set any time the + DRT table is changed. */ + SaHpiUint32T RptUpdateCount; /* This count is incremented any time + the RPT is changed. It rolls over + to zero when the maximum value is + reached */ + SaHpiTimeT RptUpdateTimestamp; /* This timestamp is set any time the + RPT table is changed. */ + SaHpiUint32T DatUpdateCount; /* This count is incremented any time + the DAT is changed. It rolls over to + zero when the maximum value is + reached */ + SaHpiTimeT DatUpdateTimestamp; /* This timestamp is set any time the + DAT is changed. */ + SaHpiUint32T ActiveAlarms; /* Count of active alarms in the DAT */ + SaHpiUint32T CriticalAlarms; /* Count of active critical alarms in + the DAT */ + SaHpiUint32T MajorAlarms; /* Count of active major alarms in the + DAT */ + SaHpiUint32T MinorAlarms; /* Count of active minor alarms in the + DAT */ + SaHpiUint32T DatUserAlarmLimit; /* Maximum User Alarms that can be + added to DAT. 0=no fixed limit */ + SaHpiBoolT DatOverflow; /* Set to True if there are one + or more non-User Alarms that + are missing from the DAT because + of space limitations */ + SaHpiGuidT Guid; /* GUID associated with domain.*/ +} SaHpiDomainInfoT; + +/* +** DRT Entry +** +** This structure is used to store the DRT entry information. +** +*/ +typedef struct { + SaHpiEntryIdT EntryId; + SaHpiDomainIdT DomainId; /* The Domain ID referenced by this entry */ + SaHpiBoolT IsPeer; /* Indicates if this domain reference + is a peer. If not, the domain reference + is a tier. */ +} SaHpiDrtEntryT; + + +/* +** DAT Entry +** +** This structure is used to store alarm informatin in the DAT +** +*/ + + +typedef SaHpiEntryIdT SaHpiAlarmIdT; + +typedef struct { + SaHpiAlarmIdT AlarmId; /* Alarm Id */ + SaHpiTimeT Timestamp; /* Time when alarm added to DAT */ + SaHpiSeverityT Severity; /* Severity of alarm */ + SaHpiBoolT Acknowledged; /* Acknowledged flag */ + SaHpiConditionT AlarmCond; /* Detailed alarm condition */ +} SaHpiAlarmT; + +/******************************************************************************* +******************************************************************************** +********** ********** +********** Event Log ********** +********** ********** +******************************************************************************** +*******************************************************************************/ +/* This section defines the types associated with the Event Log. */ +/* +** Event Log Information +** +** The Entries entry denotes the number of active entries contained in the Event +** Log. +** The Size entry denotes the total number of entries the Event Log is able to +** hold. +** The UserEventMaxSize entry indicates the maximum size of the text buffer +** data field in an HPI User event that is supported by the Event Log +** implementation. If the implementation does not enforce a more restrictive +** data length, it should be set to SAHPI_MAX_TEXT_BUFFER_LENGTH. +** The UpdateTimestamp entry denotes the time of the last update to the Event +** Log. +** The CurrentTime entry denotes the Event Log's idea of the current time; i.e +** the timestamp that would be placed on an entry if it was added now. +** The Enabled entry indicates whether the Event Log is enabled. If the Event +** Log is "disabled" no events generated within the HPI implementation will be +** added to the Event Log. Events may still be added to the Event Log with +** the saHpiEventLogEntryAdd() function. When the Event Log is "enabled" +** events may be automatically added to the Event Log as they are generated +** in a resource or a domain, however, it is implementation-specific which +** events are automatically added to any Event Log. +** The OverflowFlag entry indicates the Event Log has overflowed. Events have +** been dropped or overwritten due to a table overflow. +** The OverflowAction entry indicates the behavior of the Event Log when an +** overflow occurs. +** The OverflowResetable entry indicates if the overflow flag can be +** cleared by an HPI User with the saHpiEventLogOverflowReset() function. +*/ +typedef enum { + SAHPI_EL_OVERFLOW_DROP, /* New entries are dropped when Event Log is + full*/ + SAHPI_EL_OVERFLOW_OVERWRITE /* Event Log overwrites existing entries + when Event Log is full */ +} SaHpiEventLogOverflowActionT; + +typedef struct { + SaHpiUint32T Entries; + SaHpiUint32T Size; + SaHpiUint32T UserEventMaxSize; + SaHpiTimeT UpdateTimestamp; + SaHpiTimeT CurrentTime; + SaHpiBoolT Enabled; + SaHpiBoolT OverflowFlag; + SaHpiBoolT OverflowResetable; + SaHpiEventLogOverflowActionT OverflowAction; +} SaHpiEventLogInfoT; +/* +** Event Log Entry +** These types define the Event Log entry. +*/ +typedef SaHpiUint32T SaHpiEventLogEntryIdT; +/* Reserved values for Event Log entry IDs */ +#define SAHPI_OLDEST_ENTRY (SaHpiEventLogEntryIdT)0x00000000 +#define SAHPI_NEWEST_ENTRY (SaHpiEventLogEntryIdT)0xFFFFFFFF +#define SAHPI_NO_MORE_ENTRIES (SaHpiEventLogEntryIdT)0xFFFFFFFE + +typedef struct { + SaHpiEventLogEntryIdT EntryId; /* Entry ID for record */ + SaHpiTimeT Timestamp; /* Time at which the event was placed + in the Event Log. If less than or equal to + SAHPI_TIME_MAX_RELATIVE, then it is + relative; if it is greater than SAHPI_TIME_ + MAX_RELATIVE, then it is absolute. */ + SaHpiEventT Event; /* Logged Event */ +} SaHpiEventLogEntryT; + + +/******************************************************************************* +** +** Name: saHpiVersionGet() +** +** Description: +** This function returns the version identifier of the SaHpi specification +** version supported by the HPI implementation. +** +** Parameters: +** None. +** +** Return Value: +** The interface version identifier, of type SaHpiVersionT is returned. +** +** Remarks: +** This function differs from all other interface functions in that it +** returns the version identifier rather than a standard return code. This is +** because the version itself is necessary in order for an HPI User to +** properly interpret subsequent API return codes. Thus, the +** saHpiVersionGet() function returns the interface version identifier +** unconditionally. +** +** This function returns the value of the header file symbol +** SAHPI_INTERFACE_VERSION in the SaHpi.h header file used when the library +** was compiled. An HPI User may compare the returned value to the +** SAHPI_INTERFACE_VERSION symbol in the SaHpi.h header file used by the +** calling program to determine if the accessed library is compatible with the +** calling program. +** +*******************************************************************************/ +SaHpiVersionT SAHPI_API saHpiVersionGet ( void ); + +/******************************************************************************* +** +** Name: saHpiSessionOpen() +** +** Description: +** This function opens an HPI session for a given domain and set of security +** characteristics (future). +** +** Parameters: +** DomainId - [in] Domain identifier of the domain to be accessed by the HPI +** User. A domain identifier of SAHPI_UNSPECIFIED_DOMAIN_ID requests that +** a session be opened to a default domain. +** SessionId - [out] Pointer to a location to store an identifier for the +** newly opened session. This identifier is used for subsequent access to +** domain resources and events. +** SecurityParams - [in] Pointer to security and permissions data structure. +** This parameter is reserved for future use, and must be set to NULL. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_DOMAIN is returned if no domain matching the specified +** domain identifier exists. +** SA_ERR_HPI_INVALID_PARAMS is returned if: +** * A non-null SecurityParams pointer is passed. +** * The SessionId pointer is passed in as NULL. +** SA_ERR_HPI_OUT_OF_SPACE is returned if no more sessions can be opened. +** +** Remarks: +** None. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSessionOpen ( + SAHPI_IN SaHpiDomainIdT DomainId, + SAHPI_OUT SaHpiSessionIdT *SessionId, + SAHPI_IN void *SecurityParams +); + +/******************************************************************************* +** +** Name: saHpiSessionClose() +** +** Description: +** This function closes an HPI session. After closing a session, the SessionId +** will no longer be valid. +** +** Parameters: +** SessionId - [in] Session identifier previously obtained using +** saHpiSessionOpen(). +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** +** Remarks: +** None. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSessionClose ( + SAHPI_IN SaHpiSessionIdT SessionId +); + +/******************************************************************************* +** +** Name: saHpiDiscover() +** +** Description: +** This function requests the underlying management service to discover +** information about resources and associated domains. +** +** This function may be called during operation to update the DRT table and +** the RPT table. An HPI implementation may exhibit latency between when +** hardware changes occur and when the domain DRT and RPT are updated. To +** overcome this latency, the saHpiDiscover() function may be called. When +** this function returns, the DRT and RPT should be updated to reflect the +** current system configuration and status. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained +** using saHpiSessionOpen(). +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** +** Remarks: +** None. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiDiscover ( + SAHPI_IN SaHpiSessionIdT SessionId +); + +/******************************************************************************* +** +** Name: saHpiDomainInfoGet() +** +** Description: +** This function is used for requesting information about the domain, the +** Domain Reference Table (DRT), the Resource Presence Table (RPT), and the +** Domain Alarm Table (DAT), such as table update counters and timestamps, and +** the unique domain identifier associated with the domain. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained +** using saHpiSessionOpen(). +** DomainInfo - [out] Pointer to the information describing the domain and +** DRT. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned if the DomainInfo pointer is passed +** in as NULL. +** +** Remarks: +** None. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiDomainInfoGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_OUT SaHpiDomainInfoT *DomainInfo +); + +/******************************************************************************* +** +** Name: saHpiDrtEntryGet() +** +** Description: +** This function retrieves domain information for the specified entry of the +** DRT. This function allows an HPI User to read the DRT entry-by-entry. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** EntryId - [in] Identifier of the DRT entry to retrieve. Reserved EntryId +** values: +** * SAHPI_FIRST_ENTRY Get first entry +** * SAHPI_LAST_ENTRY Reserved as delimiter for end of list. Not a +** valid entry identifier. +** NextEntryId - [out] Pointer to location to store the EntryId of next entry +** in DRT. +** DrtEntry - [out] Pointer to the structure to hold the returned DRT entry. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_NOT_PRESENT is returned if the: +** * Entry identified by EntryId is not present. +** * EntryId is SAHPI_FIRST_ENTRY and the DRT is empty. +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * DrtEntry pointer is passed in as NULL. +** * NextEntryId pointer is passed in as NULL. +** * EntryId is an invalid reserved value such as SAHPI_LAST_ENTRY. +** +** Remarks: +** If the EntryId parameter is set to SAHPI_FIRST_ENTRY, the first entry in +** the DRT will be returned. When an entry is successfully retrieved, +** NextEntryId will be set to the identifier of the next valid entry; however, +** when the last entry has been retrieved, NextEntryId will be set to +** SAHPI_LAST_ENTRY. To retrieve an entire list of entries, call this function +** first with an EntryId of SAHPI_FIRST_ENTRY and then use the returned +** NextEntryId in the next call. Proceed until the NextEntryId returned is +** SAHPI_LAST_ENTRY. +** +** If an HPI User has not subscribed to receive events and a DRT entry is +** added while the DRT is being read, that new entry may be missed. The +** update counter provides a means for insuring that no domains are missed +** when stepping through the DRT. In order to use this feature, an HPI User +** should call saHpiDomainInfoGet() to get the update counter value before +** retrieving the first DRT entry. After reading the last entry, the HPI User +** should again call saHpiDomainInfoGet() to get the update counter value. If +** the update counter has not been incremented, no new entries have been +** added. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiDrtEntryGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiEntryIdT EntryId, + SAHPI_OUT SaHpiEntryIdT *NextEntryId, + SAHPI_OUT SaHpiDrtEntryT *DrtEntry +); + +/******************************************************************************* +** +** Name: saHpiDomainTagSet() +** +** Description: +** This function allows an HPI User to set a descriptive tag for a particular +** domain. The domain tag is an informational value that supplies an HPI User +** with naming information for the domain. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** DomainTag - [in] Pointer to SaHpiTextBufferT containing the domain tag. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned if the SaHpiTextBufferT structure +** passed as DomainTag is not valid. This would occur when: +** * The DataType is not one of the enumerated values for that type, or +** * The data field contains characters that are not legal according to +** the value of DataType, or +** * The Language is not one of the enumerated values for that type when +** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT. +** SA_ERR_HPI_INVALID_PARAMS is returned if the DomainTag pointer is passed in +** as NULL. +** +** Remarks: +** Typically, the HPI implementation will provide an appropriate default value +** for the domain tag; this function is provided so that an HPI User can +** override the default, if desired. The value of the domain tag may be +** retrieved from the domain's information structure. +** +** The domain tag is not necessarily persistent, and may return to its default +** value if the domain controller function for the domain restarts. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiDomainTagSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiTextBufferT *DomainTag +); + +/******************************************************************************* +** +** Name: saHpiRptEntryGet() +** +** Description: +** This function retrieves resource information for the specified entry of the +** resource presence table. This function allows an HPI User to read the RPT +** entry-by-entry. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** EntryId - [in] Identifier of the RPT entry to retrieve. Reserved EntryId +** values: +** * SAHPI_FIRST_ENTRY Get first entry. +** * SAHPI_LAST_ENTRY Reserved as delimiter for end of list. Not a +** valid entry identifier. +** NextEntryId - [out] Pointer to location to store the EntryId of next entry +** in RPT. +** RptEntry - [out] Pointer to the structure to hold the returned RPT entry. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_NOT_PRESENT is returned when the: +** * Entry identified by EntryId is not present. +** * EntryId is SAHPI_FIRST_ENTRY and the RPT is empty. +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * RptEntry pointer is passed in as NULL. +** * NextEntryId pointer is passed in as NULL. +** * EntryId is an invalid reserved value such as SAHPI_LAST_ENTRY. +** +** Remarks: +** If the EntryId parameter is set to SAHPI_FIRST_ENTRY, the first entry in +** the RPT will be returned. When an entry is successfully retrieved, +** NextEntryId will be set to the identifier of the next valid entry; however, +** when the last entry has been retrieved, NextEntryId will be set to +** SAHPI_LAST_ENTRY. To retrieve an entire list of entries, call this function +** first with an EntryId of SAHPI_FIRST_ENTRY and then use the returned +** NextEntryId in the next call. Proceed until the NextEntryId returned is +** SAHPI_LAST_ENTRY. +** +** At initialization, an HPI User may not wish to turn on eventing, since the +** context of the events, as provided by the RPT, is not known. In this +** instance, if a FRU is inserted into the system while the RPT is being read +** entry by entry, the resource associated with that FRU may be missed. (Keep +** in mind that there is no specified ordering for the RPT entries.) The +** update counter provides a means for insuring that no resources are missed +** when stepping through the RPT. In order to use this feature, an HPI User +** should invoke saHpiDomainInfoGet(), and get the update counter value before +** retrieving the first RPT entry. After reading the last entry, an HPI User +** should again invoke the saHpiDomainInfoGet() to get the RPT update counter +** value. If the update counter has not been incremented, no new records have +** been added. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiRptEntryGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiEntryIdT EntryId, + SAHPI_OUT SaHpiEntryIdT *NextEntryId, + SAHPI_OUT SaHpiRptEntryT *RptEntry +); + +/******************************************************************************* +** +** Name: saHpiRptEntryGetByResourceId() +** +** Description: +** This function retrieves resource information from the resource presence +** table for the specified resource using its ResourceId. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained +** using saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** RptEntry - [out] Pointer to structure to hold the returned RPT entry. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned if the RptEntry pointer is passed +** in as NULL. +** +** Remarks: +** Typically at start-up, the RPT is read entry-by-entry, using +** saHpiRptEntryGet(). From this, an HPI User can establish the set of +** ResourceIds to use for future calls to the HPI functions. +** +** However, there may be other ways of learning ResourceIds without first +** reading the RPT. For example, resources may be added to the domain while +** the system is running in response to a hot swap action. When a resource is +** added, the application will receive a hot swap event containing the +** ResourceId of the new resource. The application may then want to search the +** RPT for more detailed information on the newly added resource. In this +** case, the ResourceId can be used to locate the applicable RPT entry +** information. +** +** Note that saHpiRptEntryGetByResourceId() is valid in any hot swap state, +** except for SAHPI_HS_STATE_NOT_PRESENT. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiRptEntryGetByResourceId ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_OUT SaHpiRptEntryT *RptEntry +); + +/******************************************************************************* +** +** Name: saHpiResourceSeveritySet() +** +** Description: +** This function allows an HPI User to set the severity level applied to an +** event issued if a resource unexpectedly becomes unavailable to the HPI. A +** resource may become unavailable for several reasons including: +** * The FRU associated with the resource is no longer present in the +** system (a surprise extraction has occurred.) +** * A catastrophic failure has occurred. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** Severity - [in] Severity level of event issued when the resource +** unexpectedly becomes unavailable to the HPI. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned when the value for Severity is not +** one of the valid enumerated values for this type. +** +** Remarks: +** Typically, the HPI implementation will provide an appropriate default value +** for the resource severity, which may vary by resource; an HPI User can +** override this default value by use of this function. +** +** If a resource is removed from, then re-added to the RPT (e.g., because of a +** hot swap action), the HPI implementation may reset the value of the +** resource severity. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiResourceSeveritySet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSeverityT Severity +); + +/******************************************************************************* +** +** Name: saHpiResourceTagSet() +** +** Description: +** This function allows an HPI User to set the resource tag of an RPT entry +** for a particular resource. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** ResourceTag - [in] Pointer to SaHpiTextBufferT containing the resource tag. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned if the SaHpiTextBufferT structure +** passed as ResourceTag is not valid. This would occur when: +** * The DataType is not one of the enumerated values for that type, or +** * The data field contains characters that are not legal according to the +** value of DataType, or +** * The Language is not one of the enumerated values for that type when +** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT. +** SA_ERR_HPI_INVALID_PARAMS is returned if the ResourceTag pointer is passed +** in as NULL. +** +** Remarks: +** The resource tag is a data field within an RPT entry available to an HPI +** User for associating application specific data with a resource. HPI User +** supplied data is purely informational and is not used by the HPI +** implementation, domain, or associated resource. For example, an HPI User +** can set the resource tag to a "descriptive" value, which can be used to +** identify the resource in messages to a human operator. +** +** Since the resource tag is contained within an RPT entry, its scope is +** limited to a single domain. A resource that exists in more than one domain +** will have independent resource tags within each domain. +** +** Typically, the HPI implementation will provide an appropriate default value +** for the resource tag; this function is provided so that an HPI User can +** override the default, if desired. The value of the resource tag may be +** retrieved from the resource's RPT entry. +** +** If a resource is removed from, then re-added to the RPT (e.g., because of a +** hot swap action), the HPI implementation may reset the value of the +** resource tag. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiResourceTagSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiTextBufferT *ResourceTag +); + +/******************************************************************************* +** +** Name: saHpiResourceIdGet() +** +** Description: +** This function returns the ResourceId of the resource associated with the +** entity upon which the HPI User is running. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [out] Pointer to location to hold the returned ResourceId. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned if the ResourceId pointer is passed +** in as NULL. +** SA_ERR_HPI_NOT_PRESENT is returned if the entity the HPI User is running on +** is not manageable in the addressed domain. +** SA_ERR_HPI_UNKNOWN is returned if the domain controller cannot determine an +** appropriate response. That is, there may be an appropriate ResourceId in +** the domain to return, but it cannot be determined. +** +** Remarks: +** This function must be issued within a session to a domain that includes a +** resource associated with the entity upon which the HPI User is running, or +** the SA_ERR_HPI_NOT_PRESENT return will be issued. +** +** Since entities are contained within other entities, there may be multiple +** possible resources that could be returned to this call. For example, if +** there is a ResourceId associated with a particular compute blade upon which +** the HPI User is running, and another associated with the chassis which +** contains the compute blade, either could logically be returned as an +** indication of a resource associated with the entity upon which the HPI User +** was running. The function should return the ResourceId of the "smallest" +** resource that is associated with the HPI User. So, in the example above, +** the function should return the ResourceId of the compute blade. +** +** Once the function has returned the ResourceId, the HPI User may issue +** further HPI calls using that ResourceId to learn the type of resource that +** been identified. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiResourceIdGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_OUT SaHpiResourceIdT *ResourceId +); + +/******************************************************************************* +** +** Name: saHpiEventLogInfoGet() +** +** Description: +** This function retrieves the current number of entries in the Event Log, +** total size of the Event Log, the time of the most recent update to the +** Event Log, the current value of the Event Log's clock (i.e., timestamp that +** would be placed on an entry at this moment), the enabled/disabled status of +** the Event Log (see Section 6.4.8 on page 57), the overflow flag, and the +** action taken by the Event Log if an overflow occurs. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Identifier for the Resource containing the Event Log. +** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log. +** Info - [out] Pointer to the returned Event Log information. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event +** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition +** only applies to Resource Event Logs. Domain Event Logs are mandatory, +** and should not return this code. +** SA_ERR_HPI_INVALID_PARAMS is returned if the Info pointer is passed in as +** NULL. +** +** Remarks: +** The size field in the returned Event Log information indicates the maximum +** number of entries that can be held in the Event Log. This number should be +** constant for a particular Event Log. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventLogInfoGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_OUT SaHpiEventLogInfoT *Info +); + +/******************************************************************************* +** +** Name: saHpiEventLogEntryGet() +** +** Description: +** This function retrieves an Event Log entry. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Identifier for the Resource containing the Event Log. +** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log. +** EntryId - [in] Identifier of event log entry to retrieve. Reserved values: +** * SAHPI_OLDEST_ENTRY Oldest entry in the Event Log. +** * SAHPI_NEWEST_ENTRY Newest entry in the Event Log. +** * SAHPI_NO_MORE_ENTRIES Not valid for this parameter. Used only when +** retrieving the next and previous EntryIds. +** PrevEntryId - [out] Event Log entry identifier for the previous (older +** adjacent) entry. Reserved values: +** * SAHPI_OLDEST_ENTRY Not valid for this parameter. Used only for +** the EntryId parameter. +** * SAHPI_NEWEST_ENTRY Not valid for this parameter. Used only for +** the EntryId parameter. +** * SAHPI_NO_MORE_ENTRIES No more entries in the Event Log before the +** one referenced by the EntryId parameter. +** NextEntryId - [out] Event Log entry identifier for the next (newer +** adjacent) entry. Reserved values: +** * SAHPI_OLDEST_ENTRY Not valid for this parameter. Used only for +** the EntryId parameter. +** * SAHPI_NEWEST_ENTRY Not valid for this parameter. Used only for +** the EntryId parameter. +** * SAHPI_NO_MORE_ENTRIES No more entries in the Event Log after the one +** referenced by the EntryId parameter. +** EventLogEntry - [out] Pointer to retrieved Event Log entry. +** Rdr - [in/out] Pointer to structure to receive resource data record +** associated with the Event Log entry, if available. If NULL, no RDR data +** will be returned. +** RptEntry - [in/out] Pointer to structure to receive RPT entry associated +** with the Event Log entry, if available. If NULL, no RPT entry data will +** be returned. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event +** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition +** only applies to Resource Event Logs. Domain Event Logs are mandatory, +** and should not return this code. +** SA_ERR_HPI_NOT_PRESENT is returned when: +** * The Event Log has no entries. +** * The entry identified by EntryId is not present. +** SA_ERR_HPI_INVALID_PARAMS is returned when: +** * Any of PrevEntryId, NextEntryId and EventLogEntry pointers are passed +** in as NULL. +** * SAHPI_NO_MORE_ENTRIES is passed in to EntryId. +** +** Remarks: +** The special EntryIds SAHPI_OLDEST_ENTRY and SAHPI_NEWEST_ENTRY are used to +** select the oldest and newest entries, respectively, in the Event Log being +** read. A returned NextEntryId of SAHPI_NO_MORE_ENTRIES indicates that the +** newest entry has been returned; there are no more entries going forward +** (time-wise) in the Event Log. A returned PrevEntryId of +** SAHPI_NO_MORE_ENTRIES indicates that the oldest entry has been returned. +** +** To retrieve an entire list of entries going forward (oldest entry to newest +** entry) in the Event Log, call this function first with an EntryId of +** SAHPI_OLDEST_ENTRY and then use the returned NextEntryId as the EntryId in +** the next call. Proceed until the NextEntryId returned is +** SAHPI_NO_MORE_ENTRIES. +** +** To retrieve an entire list of entries going backward (newest entry to +** oldest entry) in the Event Log, call this function first with an EntryId of +** SAHPI_NEWEST_ENTRY and then use the returned PrevEntryId as the EntryId in +** the next call. Proceed until the PrevEntryId returned is +** SAHPI_NO_MORE_ENTRIES. +** +** Event Logs may include RPT entries and resource data records associated +** with the resource and sensor issuing an event along with the basic event +** data in the Event Log. Because the system may be reconfigured after the +** event was entered in the Event Log, this stored information may be +** important to interpret the event. If the Event Log includes logged RPT +** entries and/or RDRs, and if an HPI User provides a pointer to a structure +** to receive this information, it will be returned along with the Event Log +** entry. +** +** If an HPI User provides a pointer for an RPT entry, but the Event Log does +** not include a logged RPT entry for the Event Log entry being returned, +** RptEntry->ResourceCapabilities will be set to zero. No valid RptEntry will +** have a zero Capabilities field value. +** +** If an HPI User provides a pointer for an RDR, but the Event Log does not +** include a logged RDR for the Event Log entry being returned, Rdr->RdrType +** will be set to SAHPI_NO_RECORD. +** +** The EntryIds returned via the PrevEntryId and NextEntryId parameters may +** not be in sequential order, but will reflect the previous and next entries +** in a chronological ordering of the Event Log, respectively. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventLogEntryGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiEventLogEntryIdT EntryId, + SAHPI_OUT SaHpiEventLogEntryIdT *PrevEntryId, + SAHPI_OUT SaHpiEventLogEntryIdT *NextEntryId, + SAHPI_OUT SaHpiEventLogEntryT *EventLogEntry, + SAHPI_INOUT SaHpiRdrT *Rdr, + SAHPI_INOUT SaHpiRptEntryT *RptEntry +); + +/******************************************************************************* +** +** Name: saHpiEventLogEntryAdd() +** +** Description: +** This function enables an HPI user to add entries to the Event Log. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Identifier for the Resource containing the Event Log. +** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log. +** EvtEntry - [in] Pointer to event data to write to the Event Log. The Event +** field must be of type SAHPI_ET_USER, and the Source field must be +** SAHPI_UNSPECIFIED_RESOURCE_ID. +** +** Return Value: +** SA_OK is returned if the event is successfully written in the Event Log; +** otherwise, an error code is returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event +** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition +** only applies to Resource Event Logs. Domain Event Logs are mandatory, +** and should not return this code. +** SA_ERR_HPI_INVALID_DATA is returned if the event DataLength is larger than +** that supported by the implementation and reported in the Event Log info +** record. +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * EvtEntry pointer is passed in as NULL. +** * Event structure passed via the EvtEntry parameter is not an event of +** type SAHPI_ET_USER with the Source field set to +** SAHPI_UNSPECIFIED_RESOURCE_ID. +** * The Severity is not one of the valid enumerated values for this type. +** * SaHpiTextBufferT structure passed as part of the User Event structure +** is not valid. This would occur when: +** * The DataType is not one of the enumerated values for that type, or +** * The data field contains characters that are not legal according to +** the value of DataType, or +** * The Language is not one of the enumerated values for that type when +** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT. +** SA_ERR_HPI_OUT_OF_SPACE is returned if the event cannot be written to the +** Event Log because the Event Log is full, and the Event Log +** OverflowAction is SAHPI_EL_OVERFLOW_DROP. +** +** Remarks: +** This function writes an event in the addressed Event Log. Nothing else is +** done with the event. +** +** If the Event Log is full, overflow processing occurs as defined by the +** Event Log's OverflowAction setting, reported in the Event Log info record. +** If, due to an overflow condition, the event is not written, or if existing +** events are overwritten, then the OverflowFlag in the Event Log info record +** will be set, just as it would be if an internally generated event caused +** an overflow condition. If the Event Log's OverflowAction is +** SAHPI_EL_OVERFLOW_DROP, then an error will be returned +** (SA_ERR_HPI_OUT_OF_SPACE) indicating that the saHpiEventLogEntryAdd() +** function did not add the event to the Event Log. If the Event Log's +** OverflowAction is SAHPI_EL_OVERFLOW_OVERWRITE, then the +** saHpiEventLogEntryAdd() function will return SA_OK, indicating that the +** event was added to the Event Log, even though an overflow occurred as a +** side-effect of this operation. The overflow may be detected by checking +** the OverflowFlag in the Event Log info record. +** +** Specific implementations of HPI may have restrictions on how much data may +** be passed to the saHpiEventLogEntryAdd() function. The Event Log info +** record reports the maximum DataLength that is supported by the Event Log +** for User Events. If saHpiEventLogEntryAdd() is called with a User Event +** that has a larger DataLength than is supported, the event will not be added +** to the Event Log, and an error will be returned. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventLogEntryAdd ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiEventT *EvtEntry +); + +/******************************************************************************* +** +** Name: saHpiEventLogClear() +** +** Description: +** This function erases the contents of the specified Event Log. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Identifier for the Resource containing the Event Log. +** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event +** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition +** only applies to Resource Event Logs. Domain Event Logs are mandatory, +** and should not return this code +** +** Remarks: +** The OverflowFlag field in the Event Log info record will be reset when this +** function is called. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventLogClear ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId +); + +/******************************************************************************* +** +** Name: saHpiEventLogTimeGet() +** +** Description: +** This function retrieves the current time from the Event Log's clock. This +** clock is used to timestamp entries written into the Event Log. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Identifier for the Resource containing the Event Log. +** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log. +** Time - [out] Pointer to the returned current Event Log time. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event +** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition +** only applies to Resource Event Logs. Domain Event Logs are mandatory, +** and should not return this code. +** SA_ERR_HPI_INVALID_PARAMS is returned if the Time pointer is passed in as +** NULL. +** +** Remarks: +** If the implementation cannot supply an absolute time value, then it may +** supply a time relative to some system-defined epoch, such as system boot. +** If the time value is less than or equal to SAHPI_TIME_MAX_RELATIVE, then it +** is relative; if it is greater than SAHPI_TIME_MAX_RELATIVE, then it is +** absolute. The HPI implementation must provide valid timestamps for Event +** Log entries, using a default time base if no time has been set. Thus, the +** value SAHPI_TIME_UNSPECIFIED is never returned. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventLogTimeGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_OUT SaHpiTimeT *Time +); + +/******************************************************************************* +** +** Name: saHpiEventLogTimeSet() +** +** Description: +** This function sets the Event Log's clock, which is used to timestamp events +** written into the Event Log. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Identifier for the Resource containing the Event Log. +** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log. +** Time - [in] Time to which the Event Log clock should be set. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event +** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition +** only applies to Resource Event Logs. Domain Event Logs are mandatory, +** and should not return this code. +** SA_ERR_HPI_INVALID_PARAMS is returned when the Time parameter is set to +** SAHPI_TIME_UNSPECIFIED. +** For situations when the underlying implementation cannot represent a time +** value that is specified in Time, SA_ERR_HPI_INVALID_DATA is returned. +** +** Remarks: +** If the Time parameter value is less than or equal to +** SAHPI_TIME_MAX_RELATIVE, but not SAHPI_TIME_UNSPECIFIED, then it is +** relative; if it is greater than SAHPI_TIME_MAX_RELATIVE, then it is +** absolute. Setting this parameter to the value SAHPI_TIME_UNSPECIFIED is +** invalid and will result in an error return code of +** SA_ERR_HPI_INVALID_PARAMS. +** +** Entries placed in the Event Log after this function is called will have +** Event Log timestamps (i.e., the Timestamp field in the SaHpiEventLogEntryT +** structure) based on the new time. Setting the clock does not affect +** existing Event Log entries. If the time is set to a relative time, +** subsequent entries placed in the Event Log will have an Event Log timestamp +** expressed as a relative time; if the time is set to an absolute time, +** subsequent entries will have an Event Log timestamp expressed as an +** absolute time. +** +** This function only sets the Event Log time clock and does not have any +** direct bearing on the timestamps placed on events (i.e., the Timestamp +** field in the SaHpiEventT structure), or the timestamps placed in the domain +** RPT info record. Setting the clocks used to generate timestamps other than +** Event Log timestamps is implementation-dependent, and should be documented +** by the HPI implementation provider. +** +** Some underlying implementations may not be able to handle the same relative +** and absolute time ranges, as those defined in HPI. Such limitations will +** be documented. When a time value is set in a region that is not supported +** by the implementation, an error code of SA_ERR_HPI_INVALID_DATA will be +** returned. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventLogTimeSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiTimeT Time +); + +/******************************************************************************* +** +** Name: saHpiEventLogStateGet() +** +** Description: +** This function enables an HPI User to get the Event Log state. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Identifier for the Resource containing the Event Log. +** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log. +** EnableState - [out] Pointer to the current Event Log enable state. True +** indicates that the Event Log is enabled; False indicates that it is +** disabled. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event +** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition +** only applies to Resource Event Logs. Domain Event Logs are mandatory, +** and should not return this code. +** SA_ERR_HPI_INVALID_PARAMS is returned if the EnableState pointer is passed +** in as NULL. +** +** Remarks: +** If the Event Log is disabled, no events generated within the HPI +** implementation will be added to the Event Log. Events may still be added to +** the Event Log with the saHpiEventLogEntryAdd() function. When the Event Log +** is enabled, events may be automatically added to the Event Log as they are +** generated in a resource or a domain, however, it is implementation-specific +** which events are automatically added to any Event Log. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventLogStateGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_OUT SaHpiBoolT *EnableState +); + +/******************************************************************************* +** +** Name: saHpiEventLogStateSet() +** +** Description: +** This function enables an HPI User to set the Event Log enabled state. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Identifier for the Resource containing the Event Log. +** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log. +** EnableState - [in] Event Log state to be set. True indicates that the Event +** Log is to be enabled; False indicates that it is to be disabled. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event +** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition +** only applies to Resource Event Logs. Domain Event Logs are mandatory, +** and should not return this code. +** +** Remarks: +** If the Event Log is disabled no events generated within the HPI +** implementation will be added to the Event Log. Events may still be added to +** the Event Log using the saHpiEventLogEntryAdd() function. When the Event +** Log is enabled events may be automatically added to the Event Log as they +** are generated in a resource or a domain. The actual set of events that are +** automatically added to any Event Log is implementation-specific. +** +** Typically, the HPI implementation will provide an appropriate default value +** for this parameter, which may vary by resource. This function is provided +** so that an HPI User can override the default, if desired. +** +** If a resource hosting an Event Log is re-initialized (e.g., because of a +** hot swap action), the HPI implementation may reset the value of this +** parameter. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventLogStateSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiBoolT EnableState +); + +/******************************************************************************* +** +** Name: saHpiEventLogOverflowReset() +** +** Description: +** This function resets the OverflowFlag in the Event Log info record of the +** specified Event Log. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Identifier for the Resource containing the Event Log. +** Set to SAHPI_UNSPECIFIED_RESOURCE_ID to address the Domain Event Log. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_CMD is returned if the implementation does not support +** independent clearing of the OverflowFlag on this Event Log. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not have an Event +** Log capability (SAHPI_CAPABILITY_EVENT_LOG) set. Note this condition +** only applies to Resource Event Logs. Domain Event Logs are mandatory, +** and should not return this code. +** +** Remarks: +** The only effect of this function is to clear the OverflowFlag field in the +** Event Log info record for the specified Event Log. If the Event Log is +** still full, the OverflowFlag will be set again as soon as another entry +** needs to be added to the Event Log. +** +** Some Event Log implementations may not allow resetting of the OverflowFlag +** except as a by-product of clearing the entire Event Log with the +** saHpiEventLogClear() function. Such an implementation will return the +** error code, SA_ERR_HPI_INVALID_CMD to this function. The OverflowResetable +** flag in the Event Log info record indicates whether or not the +** implementation supports resetting the OverflowFlag without clearing the +** Event Log. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventLogOverflowReset ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId +); + +/******************************************************************************* +** +** Name: saHpiSubscribe() +** +** Description: +** This function allows an HPI User to subscribe for events. This single call +** provides subscription to all session events, regardless of event type or +** event severity. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_DUPLICATE is returned when a subscription is already in place +** for this session. +** +** Remarks: +** Only one subscription is allowed per session, and additional subscribers +** will receive an appropriate error code. No event filtering will be done by +** the HPI implementation. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSubscribe ( + SAHPI_IN SaHpiSessionIdT SessionId +); + +/******************************************************************************* +** +** Name: saHpiUnsubscribe() +** +** Description: +** This function removes the event subscription for the session. +** +** Parameters: +** SessionId - [in] Session for which event subscription will be closed. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_REQUEST is returned if the session is not currently +** subscribed for events. +** +** Remarks: +** After removal of a subscription, additional saHpiEventGet() calls will not +** be allowed on the session unless an HPI User re-subscribes for events on +** the session first. Any events that are still in the event queue when this +** function is called will be cleared from it. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiUnsubscribe ( + SAHPI_IN SaHpiSessionIdT SessionId +); + +/******************************************************************************* +** +** Name: saHpiEventGet() +** +** Description: +** This function allows an HPI User to get an event. This call is only valid +** within a session that has subscribed for events. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** Timeout - [in] The number of nanoseconds to wait for an event to arrive. +** Reserved time out values: +** * SAHPI_TIMEOUT_IMMEDIATE Time out immediately if there are no events +** available (non-blocking call). +** * SAHPI_TIMEOUT_BLOCK Call should not return until an event is +** retrieved. +** Event - [out] Pointer to the next available event. +** Rdr - [in/out] Pointer to structure to receive the resource data associated +** with the event. If NULL, no RDR will be returned. +** RptEntry - [in/out] Pointer to structure to receive the RPT entry +** associated with the resource that generated the event. If NULL, no RPT +** entry will be returned. +** EventQueueStatus - [in/out] Pointer to location to store event queue +** status. If NULL, event queue status will not be returned. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_REQUEST is returned if an HPI User is not currently +** subscribed for events in this session. +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * Event pointer is passed in as NULL. +** * Timeout parameter is not set to SAHPI_TIMEOUT_BLOCK, +** SAHPI_TIMEOUT_IMMEDIATE or a positive value. +** SA_ERR_HPI_TIMEOUT is returned if no event is available to return within +** the timeout period. If SAHPI_TIMEOUT_IMMEDIATE is passed in the +** Timeout parameter, this error return will be used if there is no event +** queued when the function is called. +** +** Remarks: +** SaHpiEventGet() will also return an EventQueueStatus flag to an HPI User. +** This flag indicates whether or not a queue overflow has occurred. The +** overflow flag is set if any events were unable to be queued because of +** space limitations in the interface implementation. The overflow flag is +** reset whenever saHpiEventGet() is called. +** +** If there are one or more events on the event queue when this function is +** called, it will immediately return the next event on the queue. Otherwise, +** if the Timeout parameter is SAHPI_TIMEOUT_IMMEDIATE, it will return +** SA_ERR_HPI_TIMEOUT immediately. Otherwise, it will block for time +** specified by the timeout parameter; if an event is added to the queue +** within that time it will be returned immediately; if not, saHpiEventGet() +** will return SA_ERR_HPI_TIMEOUT. If the Timeout parameter is +** SAHPI_TIMEOUT_BLOCK, the saHpiEventGet() will block indefinitely, until +** an event becomes available, and then return that event. This provides for +** notification of events as they occur. +** +** If an HPI User provides a pointer for an RPT entry, but the event does not +** include a valid ResourceId for a resource in the domain (e.g., OEM or USER +** type event), then the RptEntry->ResourceCapabilities field will be set to +** zero. No valid RPT entry will have a zero ResourceCapabilities. +** +** If an HPI User provides a pointer for an RDR, but there is no valid RDR +** associated with the event being returned (e.g., returned event is not a +** sensor event), then the Rdr->RdrType field will be set to SAHPI_NO_RECORD. +** +** The timestamp reported in the returned event structure is the best +** approximation an implementation has to when the event actually occurred. +** The implementation may need to make an approximation (such as the time the +** event was placed on the event queue) because it may not have access to the +** actual time the event occurred. The value SAHPI_TIME_UNSPECIFIED indicates +** that the time of the event cannot be determined. +** +** If the implementation cannot supply an absolute timestamp, then it may +** supply a timestamp relative to some system-defined epoch, such as system +** boot. If the timestamp value is less than or equal to +** SAHPI_TIME_MAX_RELATIVE, but not SAHPI_TIME_UNSPECIFIED, then it is +** relative; if it is greater than SAHPI_TIME_MAX_RELATIVE, then it is +** absolute. +** +** If an HPI User passes a NULL pointer for the returned EventQueueStatus +** pointer, the event status will not be returned, but the overflow flag, if +** set, will still be reset. Thus, if an HPI User needs to know about event +** queue overflows, the EventQueueStatus parameter should never be NULL, and +** the overflow flag should be checked after every call to saHpiEventGet(). +** +** If saHpiEventGet() is called with a timeout value other than +** SAHPI_TIMEOUT_IMMEDIATE, and the session is subsequently closed from +** another thread, this function will return with SA_ERR_HPI_INVALID_SESSION. +** If saHpiEventGet() is called with a timeout value other than +** SAHPI_TIMEOUT_IMMEDIATE, and an HPI User subsequently calls +** saHpiUnsubscribe() from another thread, this function will return with +** SA_ERR_HPI_INVALID_REQUEST. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiTimeoutT Timeout, + SAHPI_OUT SaHpiEventT *Event, + SAHPI_INOUT SaHpiRdrT *Rdr, + SAHPI_INOUT SaHpiRptEntryT *RptEntry, + SAHPI_INOUT SaHpiEvtQueueStatusT *EventQueueStatus +); + +/******************************************************************************* +** +** Name: saHpiEventAdd() +** +** Description: +** This function enables an HPI User to add events to the HPI domain +** identified by the SessionId. The domain controller processes an event +** added with this function as if the event originated from within the +** domain. The domain controller will attempt to publish events to all active +** event subscribers and will attempt to log events in the Domain Event Log, +** if room is available. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** EvtEntry - [in] Pointer to event to add to the domain. Event must be of +** type SAHPI_ET_USER, and the Source field must be +** SAHPI_UNSPECIFIED_RESOURCE_ID. +** +** Return Value: +** SA_OK is returned if the event is successfully added to the domain; +** otherwise, an error code is returned. +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * EvtEntry parameter is NULL. +** * Event structure passed via the EvtEntry parameter is not an event of +** type SAHPI_ET_USER with the Source field being +** SAHPI_UNSPECIFIED_RESOURCE_ID. +** * Event structure passed via the EvtEntry parameter has an invalid +** Severity. +** * SaHpiTextBufferT structure passed as part of the User Event structure +** is not valid. This would occur when: +** * The DataType is not one of the enumerated values for that type, or +** * The data field contains characters that are not legal according to +** the value of DataType, or +** * The Language is not one of the enumerated values for that type when +** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT. +** SA_ERR_HPI_INVALID_DATA is returned if the event data does not meet +** implementation-specific restrictions on how much event data may be +** provided in a SAHPI_ET_USER event. +** +** Remarks: +** Specific implementations of HPI may have restrictions on how much data may +** be included in a SAHPI_ET_USER event. If more event data is provided than +** can be processed, an error will be returned. The event data size +** restriction for the SAHPI_ET_USER event type is provided in the +** UserEventMaxSize field in the domain Event Log info structure. An HPI User +** should call the function saHpiEventLogInfoGet() to retrieve the Event +** Log info structure. +** +** The domain controller will attempt to publish the event to all sessions +** within the domain with active event subscriptions; however, a session's +** event queue may overflow due to the addition of the new event. +** +** The domain controller will attempt to log the event in the Domain Event +** Log; however, the Domain Event Log may overflow due to the addition of the +** new event +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiEventAdd ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiEventT *EvtEntry +); + +/******************************************************************************* +** +** Name: saHpiAlarmGetNext() +** +** Description: +** This function allows retrieval of an alarm from the current set of alarms +** held in the Domain Alarm Table (DAT). +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** Severity - [in] Severity level of alarms to retrieve. Set to +** SAHPI_ALL_SEVERITIES to retrieve alarms of any severity; otherwise, set +** to requested severity level. +** UnacknowledgedOnly - [in] Set to True to indicate only unacknowledged +** alarms should be returned. Set to False to indicate either an +** acknowledged or unacknowledged alarm may be returned. +** Alarm - [in/out] Pointer to the structure to hold the returned alarm entry. +** Also, on input, Alarm->AlarmId and Alarm->Timestamp are used to +** identify the previous alarm. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned when: +** * Severity is not one of the valid enumerated values for this type. +** * The Alarm parameter is passed in as NULL. +** SA_ERR_HPI_NOT_PRESENT is returned: +** * If there are no additional alarms in the DAT that meet the criteria +** specified by the Severity and UnacknowledgedOnly parameters. +** * If the passed Alarm->AlarmId field was set to SAHPI_FIRST_ENTRY and +** there are no alarms in the DAT that meet the criteria specified by +** the Severity and UnacknowledgedOnly parameters. +** SA_ERR_HPI_INVALID_DATA is returned if the passed Alarm->AlarmId matches an +** alarm in the DAT, but the passed Alarm->Timestamp does not match the +** timestamp of that alarm. +** +** Remarks: +** All alarms contained in the DAT are maintained in the order in which they +** were added. This function will return the next alarm meeting the +** specifications given by an HPI User that was added to the DAT after the +** alarm whose AlarmId and Timestamp is passed by an HPI User, even if the +** alarm associated with the AlarmId and Timestamp has been deleted. If +** SAHPI_FIRST_ENTRY is passed as the AlarmId, the first alarm in the DAT +** meeting the specifications given by an HPI User is returned. +** +** Alarm selection can be restricted to only alarms of a specified severity, +** and/or only unacknowledged alarms. +** +** To retrieve all alarms contained within the DAT meeting specific +** requirements, call saHpiAlarmGetNext() with the Alarm->AlarmId field set to +** SAHPI_FIRST_ENTRY and the Severity and UnacknowledgedOnly parameters set to +** select what alarms should be returned. Then, repeatedly call +** saHpiAlarmGetNext() passing the previously returned alarm as the Alarm +** parameter, and the same values for Severity and UnacknowledgedOnly until +** the function returns with the error code SA_ERR_HPI_NOT_PRESENT. +** +** SAHPI_FIRST_ENTRY and SAHPI_LAST_ENTRY are reserved AlarmId values, and +** will never be assigned to an alarm in the DAT. +** +** The elements AlarmId and Timestamp are used in the Alarm parameter to +** identify the previous alarm; the next alarm added to the table after this +** alarm that meets the Severity and UnacknowledgedOnly requirements will be +** returned. Alarm->AlarmId may be set to SAHPI_FIRST_ENTRY to select the +** first alarm in the DAT meeting the Severity and UnacknowledgedOnly +** requirements. If Alarm->AlarmId is SAHPI_FIRST_ENTRY, then +** Alarm->Timestamp is ignored. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAlarmGetNext( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiSeverityT Severity, + SAHPI_IN SaHpiBoolT UnacknowledgedOnly, + SAHPI_INOUT SaHpiAlarmT *Alarm +); + +/******************************************************************************* +** +** Name: saHpiAlarmGet() +** +** Description: +** This function allows retrieval of a specific alarm in the Domain Alarm +** Table (DAT) by referencing its AlarmId. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** AlarmId - [in] AlarmId of the alarm to be retrieved from the DAT. +** Alarm - [out] Pointer to the structure to hold the returned alarm entry. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_NOT_PRESENT is returned if the requested AlarmId does not +** correspond to an alarm contained in the DAT. +** SA_ERR_HPI_INVALID_PARAMS is returned when the Alarm parameter is passed in +** as NULL. +** +** Remarks: +** SAHPI_FIRST_ENTRY and SAHPI_LAST_ENTRY are reserved AlarmId values, and +** will never be assigned to an alarm in the DAT. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAlarmGet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiAlarmIdT AlarmId, + SAHPI_OUT SaHpiAlarmT *Alarm +); + +/******************************************************************************* +** +** Name: saHpiAlarmAcknowledge() +** +** Description: +** This function allows an HPI User to acknowledge a single alarm entry or a +** group of alarm entries by severity. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** AlarmId - [in] Identifier of the alarm to be acknowledged. Reserved +** AlarmId values: +** * SAHPI_ENTRY_UNSPECIFIED Ignore this parameter. +** Severity - [in] Severity level of alarms to acknowledge. Ignored unless +** AlarmId is SAHPI_ENTRY_UNSPECIFIED. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_NOT_PRESENT is returned if an alarm entry identified by the +** AlarmId parameter does not exist in the DAT. +** SA_ERR_HPI_INVALID_PARAMS is returned if AlarmId is SAHPI_ENTRY_UNSPECIFIED +** and Severity is not one of the valid enumerated values for this type. +** +** Remarks: +** An HPI User acknowledges an alarm to indicate that it is aware of the alarm +** and to influence platform-specific alarm annunciation that may be provided +** by the implementation. Typically, an implementation ignores acknowledged +** alarms when announcing an alarm on annunciation devices such as audible +** sirens and dry contact closures. However, alarm annunciation is +** implementation-specific. +** +** An acknowledged alarm will have the Acknowledged field in the alarm entry +** set to True. +** +** Alarms are acknowledged by one of two ways: a single alarm entry by AlarmId +** regardless of severity or as a group of alarm entries by Severity +** regardless of AlarmId. +** +** To acknowledge all alarms contained within the DAT, set the Severity +** parameter to SAHPI_ALL_SEVERITIES, and set the AlarmId parameter to +** SAHPI_ENTRY_UNSPECIFIED. +** +** To acknowledge all alarms of a specific severity contained within the DAT, +** set the Severity parameter to the appropriate value, and set the AlarmId +** parameter to SAHPI_ENTRY_UNSPECIFIED. +** +** To acknowledge a single alarm entry, set the AlarmId parameter to a value +** other than SAHPI_ENTRY_UNSPECIFIED. The AlarmId must be a valid identifier +** for an alarm entry present in the DAT at the time of the function call. +** +** If an alarm has been previously acknowledged, acknowledging it again has no +** effect. However, this is not an error. +** +** If the AlarmId parameter has a value other than SAHPI_ENTRY_UNSPECIFIED, +** the Severity parameter is ignored. +** +** If the AlarmId parameter is passed as SAHPI_ENTRY_UNSPECIFIED, and no +** alarms are present that meet the requested Severity, this function will +** have no effect. However, this is not an error. +** +** SAHPI_ENTRY_UNSPECIFIED is defined as the same value as SAHPI_FIRST_ENTRY, +** so using either symbol will have the same effect. However, +** SAHPI_ENTRY_UNSPECIFIED should be used with this function for clarity. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAlarmAcknowledge( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiAlarmIdT AlarmId, + SAHPI_IN SaHpiSeverityT Severity +); + +/******************************************************************************* +** +** Name: saHpiAlarmAdd() +** +** Description: +** This function is used to add a User Alarm to the DAT. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** Alarm - [in/out] Pointer to the alarm entry structure that contains the new +** User Alarm to add to the DAT. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned when the Alarm pointer is passed in +** as NULL. +** SA_ERR_HPI_INVALID_PARAMS is returned when Alarm->Severity is not one of +** the following enumerated values: SAHPI_MINOR, SAHPI_MAJOR, or +** SAHPI_CRITICAL. +** SA_ERR_HPI_INVALID_PARAMS is returned when Alarm->AlarmCond.Type is not +** SAHPI_STATUS_COND_TYPE_USER. +** SA_ERR_HPI_OUT_OF_SPACE is returned if the DAT is not able to add an +** additional User Alarm due to space limits or limits imposed on the +** number of User Alarms permitted in the DAT. +** +** Remarks: +** The AlarmId, and Timestamp fields within the Alarm parameter are not used +** by this function. Instead, on successful completion, these fields are set +** to new values associated with the added alarm. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAlarmAdd( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_INOUT SaHpiAlarmT *Alarm +); + +/******************************************************************************* +** +** Name: saHpiAlarmDelete() +** +** Description: +** This function allows an HPI User to delete a single User Alarm or a group +** of User Alarms from the DAT. Alarms may be deleted individually by +** specifying a specific AlarmId, or they may be deleted as a group by +** specifying a Severity. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** AlarmId - [in] Alarm identifier of the alarm entry to delete. Reserved +** values: +** * SAHPI_ENTRY_UNSPECIFIED Ignore this parameter. +** Severity - [in] Severity level of alarms to delete. Ignored unless AlarmId +** is SAHPI_ENTRY_UNSPECIFIED. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned if AlarmId is SAHPI_ENTRY_UNSPECIFIED +** and Severity is not one of the valid enumerated values for this type. +** SA_ERR_HPI_NOT_PRESENT is returned if an alarm entry identified by the +** AlarmId parameter does not exist in the DAT. +** SA_ERR_HPI_READ_ONLY is returned if the AlarmId parameter indicates a +** non-User Alarm. +** +** Remarks: +** Only User Alarms added to the DAT can be deleted. When deleting alarms by +** severity, only User Alarms of the requested severity will be deleted. +** +** To delete a single, specific alarm, set the AlarmId parameter to a value +** representing an actual User Alarm in the DAT. The Severity parameter is +** ignored when the AlarmId parameter is set to a value other than +** SAHPI_ENTRY_UNSPECIFIED. +** +** To delete a group of User Alarms, set the AlarmId parameter to +** SAHPI_ENTRY_UNSPECIFIED, and set the Severity parameter to identify which +** severity of alarms should be deleted. To clear all User Alarms contained +** within the DAT, set the Severity parameter to SAHPI_ALL_SEVERITIES. +** +** If the AlarmId parameter is passed as SAHPI_ENTRY_UNSPECIFIED, and no User +** Alarms are present that meet the specified Severity, this function will +** have no effect. However, this is not an error. +** +** SAHPI_ENTRY_UNSPECIFIED is defined as the same value as SAHPI_FIRST_ENTRY, +** so using either symbol will have the same effect. However, +** SAHPI_ENTRY_UNSPECIFIED should be used with this function for clarity. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAlarmDelete( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiAlarmIdT AlarmId, + SAHPI_IN SaHpiSeverityT Severity +); + +/******************************************************************************* +** +** Name: saHpiRdrGet() +** +** Description: +** This function returns a resource data record from the addressed resource. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** EntryId - [in] Identifier of the RDR entry to retrieve. Reserved EntryId +** values: +** * SAHPI_FIRST_ENTRY Get first entry. +** * SAHPI_LAST_ENTRY Reserved as delimiter for end of list. Not a +** valid entry identifier. +** NextEntryId - [out] Pointer to location to store EntryId of next entry in +** RDR repository. +** Rdr - [out] Pointer to the structure to receive the requested resource data +** record. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource contains no RDR records +** (and thus does not have the SAHPI_CAPABILITY_RDR flag set in its RPT +** entry). +** SA_ERR_HPI_NOT_PRESENT is returned if an EntryId (other than +** SAHPI_FIRST_ENTRY) is passed that does not correspond to an actual +** EntryId in the resource's RDR repository. +** SA_ERR_HPI_INVALID_PARAMS is returned if: +** * SAHPI_LAST_ENTRY is passed in to EntryId. +** * NextEntryId pointer is passed in as NULL. +** * Rdr pointer is passed in as NULL. +** +** Remarks: +** Submitting an EntryId of SAHPI_FIRST_ENTRY results in the first RDR being +** read. A returned NextEntryId of SAHPI_LAST_ENTRY indicates the last RDR has +** been returned. A successful retrieval will include the next valid EntryId. +** To retrieve the entire list of RDRs, call this function first with an +** EntryId of SAHPI_FIRST_ENTRY and then use the returned NextEntryId in the +** next call. Proceed until the NextEntryId returned is SAHPI_LAST_ENTRY. +** +** A resource's RDR repository is static over the lifetime of the resource; +** therefore no precautions are required against changes to the content of the +** RDR repository while it is being accessed. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiRdrGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiEntryIdT EntryId, + SAHPI_OUT SaHpiEntryIdT *NextEntryId, + SAHPI_OUT SaHpiRdrT *Rdr +); + +/******************************************************************************* +** +** Name: saHpiRdrGetByInstrumentId() +** +** Description: +** This function returns the Resource Data Record (RDR) for a specific +** management instrument hosted by the addressed resource. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** RdrType - [in] Type of RDR being requested. +** InstrumentId - [in] Instrument number identifying the specific RDR to be +** returned. This is a sensor number, control number, watchdog timer +** number, IDR number, or annunciator number, depending on the value of +** the RdrType parameter. +** Rdr - [out] Pointer to the structure to receive the requested RDR. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the: +** * Resource contains no RDR records (and thus does not have the +** SAHPI_CAPABILITY_RDR flag set in its RPT entry). +** * Type of management instrument specified in the RdrType parameter is +** not supported by the resource, as indicated by the Capability field +** in its RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the specific management instrument +** identified in the InstrumentId parameter is not present in the addressed +** resource. +** SA_ERR_HPI_INVALID_PARAMS is returned when the: +** * RdrType parameter is not a valid enumerated value for the type. +** * RdrType is SAHPI_NO_RECORD. +** * Rdr pointer is passed in as NULL. +** +** Remarks: +** The RDR to be returned is identified by RdrType (sensor, control, watchdog +** timer, inventory data repository, or annunciator) and InstrumentId (sensor +** number, control number, watchdog number, IDR number, or annunciator number) +** for the specific management instrument for the RDR being requested. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiRdrGetByInstrumentId ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiRdrTypeT RdrType, + SAHPI_IN SaHpiInstrumentIdT InstrumentId, + SAHPI_OUT SaHpiRdrT *Rdr +); + +/******************************************************************************* +** +** Name: saHpiSensorReadingGet() +** +** Description: +** This function is used to retrieve a sensor reading. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which the sensor reading is being +** retrieved. +** Reading - [in/out] Pointer to a structure to receive sensor reading values +** If NULL, the sensor reading value will not be returned. +** EventState - [in/out] Pointer to location to receive sensor event states. +** If NULL, the sensor event states will not be returned. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors, +** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry. +** SA_ERR_HPI_INVALID_REQUEST is returned if the sensor is currently disabled. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** +** Remarks: +** For sensors that return a type of SAHPI_SENSOR_READING_TYPE_BUFFER, the +** format of the returned data buffer is implementation-specific. +** +** If the sensor does not provide a reading, the Reading structure returned by +** the saHpiSensorReadingGet() function will indicate the reading is not +** supported by setting the IsSupported flag to False. +** +** If the sensor does not support any event states, a value of 0x0000 will be +** returned for the EventState value. This is indistinguishable from the +** return for a sensor that does support event states, but currently has no +** event states asserted. The Sensor RDR Events field can be examined to +** determine if the sensor supports any event states. +** +** It is legal for both the Reading parameter and the EventState parameter to +** be NULL. In this case, no data is returned other than the return code. +** This can be used to determine if a sensor is present and enabled without +** actually returning current sensor data. If the sensor is present and +** enabled, SA_OK is returned; otherwise, an error code is returned. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorReadingGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_INOUT SaHpiSensorReadingT *Reading, + SAHPI_INOUT SaHpiEventStateT *EventState +); + +/******************************************************************************* +** +** Name: saHpiSensorThresholdsGet() +** +** Description: +** This function retrieves the thresholds for the given sensor. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which threshold values are being +** retrieved. +** SensorThresholds - [out] Pointer to returned sensor thresholds. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors, +** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned if the SensorThresholds pointer is +** passed in as NULL. +** SA_ERR_HPI_INVALID_CMD is returned if: +** * Getting a threshold on a sensor that is not a threshold type. +** * The sensor does not have any readable threshold values. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** +** Remarks: +** This function only applies to sensors that support readable thresholds, as +** indicated by the IsAccessible field in the SaHpiSensorThdDefnT structure +** of the sensor's RDR being set to True and the ReadThold field in the same +** structure having a non-zero value. +** +** For thresholds that do not apply to the identified sensor, the IsSupported +** flag of the threshold value field will be set to False. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorThresholdsGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_OUT SaHpiSensorThresholdsT *SensorThresholds +); + + +/******************************************************************************* +** +** Name: saHpiSensorThresholdsSet() +** +** Description: +** This function sets the specified thresholds for the given sensor. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which threshold values are being set. +** SensorThresholds - [in] Pointer to the sensor thresholds values being set. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_DATA is returned if any of the threshold values are +** provided in a format not supported by the sensor. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors, +** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** SA_ERR_HPI_INVALID_CMD is returned when: +** * Writing to a threshold that is not writable. +** * Setting a threshold on a sensor that is not a threshold type as +** indicated by the IsAccessible field of the SaHpiSensorThdDefnT +** structure. +** * Setting a threshold outside of the Min-Max range as defined by the +** Range field of the SensorDataFormat of the RDR. +** SA_ERR_HPI_INVALID_DATA is returned when: +** * Thresholds are set out-of-order (see Remarks). +** * A negative hysteresis value is provided. +** +** Remarks: +** This function only applies to sensors that support writable thresholds, +** as indicated by the IsAccessible field in the SaHpiSensorThdDefnT +** structure of the sensor's RDR being set to True and the WriteThold field +** in the same structure having a non-zero value. +** +** The type of value provided for each threshold setting must correspond to +** the reading format supported by the sensor, as defined by the reading type +** in the DataFormat field of the sensor's RDR (saHpiSensorRecT). +** +** Sensor thresholds cannot be set outside of the range defined by the Range +** field of the SensorDataFormat of the Sensor RDR. If SAHPI_SRF_MAX +** indicates that a maximum reading exists, no sensor threshold may be set +** greater than the Max value. If SAHPI_SRF_MIN indicates that a minimum +** reading exists, no sensor threshold may be set less than the Min value. +** +** Thresholds are required to be set progressively in-order, so that +** Upper Critical >= Upper Major >= Upper Minor >= Lower Minor >= Lower Major +** >= Lower Critical. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorThresholdsSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_IN SaHpiSensorThresholdsT *SensorThresholds +); + +/******************************************************************************* +** +** Name: saHpiSensorTypeGet() +** +** Description: +** This function retrieves the sensor type and event category for the +** specified sensor. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which the type is being retrieved. +** Type - [out] Pointer to returned enumerated sensor type for the specified +** sensor. +** Category - [out] Pointer to location to receive the returned sensor event +** category. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors, +** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * Type pointer is passed in as NULL. +** * Category pointer is passed in as NULL. +** +** Remarks: +** None. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorTypeGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_OUT SaHpiSensorTypeT *Type, + SAHPI_OUT SaHpiEventCategoryT *Category +); + +/******************************************************************************* +** +** Name: saHpiSensorEnableGet() +** +** Description: +** This function returns the current sensor enable status for an addressed +** sensor. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which the sensor enable status is being +** requested. +** SensorEnabled - [out] Pointer to the location to store the sensor enable +** status. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors, +** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned when the SensorEnabled pointer is set +** to NULL. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** +** Remarks: +** The SaHpiBoolT value pointed to by the SensorEnabled parameter will be set +** to True if the sensor is enabled, or False if the sensor is disabled. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorEnableGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_OUT SaHpiBoolT *SensorEnabled +); + +/******************************************************************************* +** +** Name: saHpiSensorEnableSet() +** +** Description: +** This function sets the sensor enable status for an addressed sensor. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which the sensor enable status is being +** set. +** SensorEnabled - [in] Sensor enable status to be set for the sensor. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors, +** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** SA_ERR_HPI_READ_ONLY is returned if the sensor does not support changing +** the enable status (i.e., the EnableCtrl field in the Sensor RDR is set +** to False). +** +** Remarks: +** If a sensor is disabled, any calls to saHpiSensorReadingGet() for that +** sensor will return an error, and no events will be generated for the +** sensor. +** +** Calling saHpiSensorEnableSet() with a SensorEnabled parameter of True +** will enable the sensor. A SensorEnabled parameter of False will disable +** the sensor. +** +** If the sensor enable status changes as the result of this function call, +** an event will be generated. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorEnableSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_IN SaHpiBoolT SensorEnabled +); + +/******************************************************************************* +** +** Name: saHpiSensorEventEnableGet() +** +** Description: +** This function returns the current sensor event enable status for an +** addressed sensor. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which the sensor event enable status is +** being requested. +** SensorEventsEnabled - [out] Pointer to the location to store the sensor +** event enable status. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors, +** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned when the SensorEventsEnabled pointer +** is set to NULL. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** +** Remarks: +** The SaHpiBoolT value pointed to by the SensorEventsEnabled parameter will +** be set to True if event generation for the sensor is enabled, or False if +** event generation for the sensor is disabled. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorEventEnableGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_OUT SaHpiBoolT *SensorEventsEnabled +); + +/******************************************************************************* +** +** Name: saHpiSensorEventEnableSet() +** +** Description: +** This function sets the sensor event enable status for an addressed sensor. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which the sensor enable status is being +** set. +** SensorEventsEnabled - [in] Sensor event enable status to be set for the +** sensor. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support sensors, +** as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** SA_ERR_HPI_READ_ONLY is returned if the sensor does not support changing +** the event enable status (i.e., the EventCtrl field in the Sensor RDR is +** set to SAHPI_SEC_READ_ONLY). +** +** Remarks: +** If event generation for a sensor is disabled, no events will be generated +** as a result of the assertion or deassertion of any event state, regardless +** of the setting of the assert or deassert event masks for the sensor. If +** event generation for a sensor is enabled, events will be generated when +** event states are asserted or deasserted, according to the settings of the +** assert and deassert event masks for the sensor. Event states may still be +** read for a sensor even if event generation is disabled, by using the +** saHpiSensorReadingGet() function. +** +** Calling saHpiSensorEventEnableSet() with a SensorEventsEnabled parameter +** of True will enable event generation for the sensor. A SensorEventsEnabled +** parameter of False will disable event generation for the sensor. +** +** If the sensor event enabled status changes as a result of this function +** call, an event will be generated. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorEventEnableSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_IN SaHpiBoolT SensorEventsEnabled +); + +/******************************************************************************* +** +** Name: saHpiSensorEventMasksGet() +** +** Description: +** This function returns the assert and deassert event masks for a sensor. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which the event enable configuration is +** being requested. +** AssertEventMask - [in/out] Pointer to location to store sensor assert event +** mask. If NULL, assert event mask is not returned. +** DeassertEventMask - [in/out] Pointer to location to store sensor deassert +** event mask. If NULL, deassert event mask is not returned. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** sensors, as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT +** entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** +** Remarks: +** Two bit-mask values are returned by the saHpiSensorEventMasksGet() +** function; one for the sensor assert event mask, and one for the sensor +** deassert event mask. A bit set to '1' in the AssertEventMask value +** indicates that an event will be generated by the sensor when the +** corresponding event state for that sensor changes from deasserted to +** asserted. A bit set to '1' in the DeassertEventMask value indicates that +** an event will be generated by the sensor when the corresponding event +** state for that sensor changes from asserted to deasserted. +** +** Events will only be generated by the sensor if the appropriate +** AssertEventMask or DeassertEventMask bit is set, sensor events are +** enabled, and the sensor is enabled. +** +** For sensors hosted by resources that have the +** SAHPI_CAPABILITY_EVT_DEASSERTS flag set in its RPT entry, the +** AssertEventMask and the DeassertEventMask values will always be the same. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorEventMasksGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_INOUT SaHpiEventStateT *AssertEventMask, + SAHPI_INOUT SaHpiEventStateT *DeassertEventMask +); + +/******************************************************************************* +** +** Name: saHpiSensorEventMasksSet() +** +** Description: +** This function provides the ability to change the settings of the sensor +** assert and deassert event masks. Two parameters contain bit-mask values +** indicating which bits in the sensor assert and deassert event masks should +** be updated. In addition, there is an Action parameter. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** SensorNum - [in] Sensor number for which the event enable configuration +** is being set. +** Action - [in] Enumerated value describing what change should be made to +** the sensor event masks: +** * SAHPI_SENS_ADD_EVENTS_TO_MASKS - for each bit set in the +** AssertEventMask and DeassertEventMask parameters, set the +** corresponding bit in the sensor's assert and deassert event masks, +** respectively. +** * SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS - for each bit set in the +** AssertEventMask and DeassertEventMask parameters, clear the +** corresponding bit in the sensor's assert and deassert event masks, +** respectively. +** AssertEventMask - [in] Bit mask or special value indicating which bits in +** the sensor's assert event mask should be set or cleared. (But see +** Remarks concerning resources with the SAHPI_EVT_DEASSERTS_CAPABILITY +** flag set.) +** DeassertEventMask - [in] Bit mask or special value indicating which bits +** in the sensor's deassert event mask should be set or cleared. (But see +** Remarks concerning resources with the SAHPI_EVT_DEASSERTS_CAPABILITY +** flag set.) +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** sensors, as indicated by SAHPI_CAPABILITY_SENSOR in the resource's RPT +** entry. +** SA_ERR_HPI_INVALID_DATA is returned if the Action parameter is +** SAHPI_SENS_ADD_EVENTS_TO_MASKS, and either of the AssertEventMask or +** DeassertEventMask parameters include a bit for an event state that is +** not supported by the sensor. +** SA_ERR_HPI_INVALID_PARAMS is returned if the Action parameter is out of +** range. +** SA_ERR_HPI_NOT_PRESENT is returned if the sensor is not present. +** SA_ERR_HPI_READ_ONLY is returned if the sensor does not support updating +** the assert and deassert event masks (i.e., the EventCtrl field in the +** Sensor RDR is set to SAHPI_SEC_READ_ONLY_MASKS or SAHPI_SEC_READ_ONLY). +** +** Remarks: +** The bits in the sensor assert and deassert event masks that correspond to +** '1' bits in the bit-mask parameters will be set or cleared, as indicated +** by the Action parameter. The bits in the sensor assert and deassert event +** masks corresponding to '0' bits in the bit-mask parameters will be +** unchanged. +** +** Assuming that a sensor is enabled and event generation for the sensor is +** enabled, then for each bit set in the sensor's assert event mask, an event +** will be generated when the sensor's corresponding event state changes from +** deasserted to asserted. Similarly, for each bit set in the sensor's +** deassert event mask, an event will be generated when the sensor's +** corresponding event state changes from asserted to deasserted. +** +** For sensors hosted by a resource that has the +** SAHPI_CAPABILITY_EVT_DEASSERTS flag set in its RPT entry, the assert and +** deassert event masks cannot be independently configured. When +** saHpiSensorEventMasksSet() is called for sensors in a resource with this +** capability, the DeassertEventMask parameter is ignored, and the +** AssertEventMask parameter is used to determine which bits to set or clear +** in both the assert event mask and deassert event mask for the sensor. +** +** The AssertEventMask or DeassertEventMask parameter may be set to the +** special value, SAHPI_ALL_EVENT_STATES, indicating that all event states +** supported by the sensor should be added to or removed from, the +** corresponding sensor event mask. +** +** If the sensor assert and/or deassert event masks change as a result of +** this function call, an event will be generated. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiSensorEventMasksSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiSensorNumT SensorNum, + SAHPI_IN SaHpiSensorEventMaskActionT Action, + SAHPI_IN SaHpiEventStateT AssertEventMask, + SAHPI_IN SaHpiEventStateT DeassertEventMask +); + +/******************************************************************************* +** +** Name: saHpiControlTypeGet() +** +** Description: +** This function retrieves the control type of a control object. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** CtrlNum - [in] Control number for which the type is being retrieved. +** Type - [out] Pointer to SaHpiCtrlTypeT variable to receive the enumerated +** control type for the specified control. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** controls, as indicated by SAHPI_CAPABILITY_CONTROL in the resource's +** RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the control is not present. +** SA_ERR_HPI_INVALID_PARAMS is returned if the Type pointer is passed in as +** NULL. +** +** Remarks: +** The Type parameter must point to a variable of type SaHpiCtrlTypeT. Upon +** successful completion, the enumerated control type is returned in the +** variable pointed to by Type. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiControlTypeGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiCtrlNumT CtrlNum, + SAHPI_OUT SaHpiCtrlTypeT *Type +); + +/******************************************************************************* +** +** Name: saHpiControlGet() +** +** Description: +** This function retrieves the current state and mode of a control object. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** CtrlNum - [in] Control number for which the state and mode are being +** retrieved. +** CtrlMode - [out] Pointer to the mode of the control. If NULL, the +** control's mode will not be returned. +** CtrlState - [in/out] Pointer to a control data structure into which the +** current control state will be placed. For text controls, the line +** number to read is passed in via CtrlState->StateUnion.Text.Line. +** If NULL, the control's state will not be returned. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_CMD is returned if the control is a write-only control, +** as indicated by the WriteOnly flag in the control's RDR (see remarks). +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** controls, as indicated by the SAHPI_CAPABILITY_CONTROL in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_DATA is returned if the addressed control is a text +** control, and the line number passed in CtrlState->StateUnion.Text.Line +** does not exist in the control and is not SAHPI_TLN_ALL_LINES. +** SA_ERR_HPI_NOT_PRESENT is returned if the control is not present. +** +** Remarks: +** Note that the CtrlState parameter is both an input and an output parameter +** for this function. This is necessary to support line number inputs for +** text controls, as discussed below. +** +** In some cases, the state of a control may be set, but the corresponding +** state cannot be read at a later time. Such controls are delineated with +** the WriteOnly flag in the Control's RDR. +** +** Note that text controls are unique in that they have a state associated +** with each line of the control - the state being the text on that line. The +** line number to be read is passed in to saHpiControlGet() via +** CtrlState->StateUnion.Text.Line; the contents of that line of the control +** will be returned in CtrlState->StateUnion.Text.Text. The first line of +** the text control is line number "1". +** +** If the line number passed in is SAHPI_TLN_ALL_LINES, then +** saHpiControlGet() will return the entire text of the control, or as much +** of it as will fit in a single SaHpiTextBufferT, in +** CtrlState->StateUnion.Text.Text. This value will consist of the text of +** all the lines concatenated, using the maximum number of characters for +** each line (no trimming of trailing blanks). +** +** Note that depending on the data type and language, the text may be encoded +** in 2-byte Unicode, which requires two bytes of data per character. +** +** Note that the number of lines and columns in a text control can be +** obtained from the control's Resource Data Record. +** +** Write-only controls allow the control's state to be set, but the control +** state cannot be subsequently read. Such controls are indicated in the RDR, +** when the WriteOnly flag is set. SA_ERR_HPI_INVALID_CMD is returned when +** calling this function for a write-only control. +** +** It is legal for both the CtrlMode parameter and the CtrlState parameter to +** be NULL. In this case, no data is returned other than the return code. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiControlGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiCtrlNumT CtrlNum, + SAHPI_OUT SaHpiCtrlModeT *CtrlMode, + SAHPI_INOUT SaHpiCtrlStateT *CtrlState +); + +/******************************************************************************* +** +** Name: saHpiControlSet() +** +** Description: +** This function is used for setting the state and/or mode of the specified +** control object. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** CtrlNum - [in] Control number for which the state and/or mode is being set. +** CtrlMode - [in] The mode to set on the control. +** CtrlState - [in] Pointer to a control state data structure holding the +** state to be set. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** controls, as indicated by the SAHPI_CAPABILITY_CONTROL in the +** resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the control is not present. +** SA_ERR_HPI_INVALID_DATA is returned when the: +** * CtrlState->Type field is not the correct type for the control +** identified by the CtrlNum parameter. +** * CtrlState->StateUnion.Analog is out of range of the control record's +** analog Min and Max values. +** * CtrlState->StateUnion.Text.Text.DataLength, combined with the +** CtrlState->StateUnion.Text.Line, overflows the remaining text +** control space. +** * CtrlState->StateUnion.Text.Text.DataType is not set to the DataType +** specified in the RDR. +** * DataType specified in the RDR is SAHPI_TL_TYPE_UNICODE or +** SAHPI_TL_TYPE_TEXT and CtrlState->StateUnion.Text.Text.Language is +** not set to the Language specified in the RDR. +** * OEM control data is invalid (see remarks below). +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * CtrlMode is not one of the valid enumerated values for this type. +** * CtrlMode parameter is not SAHPI_CTRL_MODE_AUTO and the CtrlState +** pointer is passed in as NULL. +** * CtrlState->StateUnion.Digital is not one of the valid enumerated +** values for this type. +** * CtrlState->StateUnion.Stream.StreamLength is bigger than +** SAHPI_CTRL_MAX_STREAM_LENGTH. +** * SaHpiTextBufferT structure passed as CtrlState->StateUnion.Text.Text +** contains text characters that are not allowed according to the value +** of CtrlState->StateUnion.Text.Text.DataType. +** SA_ERR_HPI_INVALID_REQUEST is returned when SAHPI_CTRL_STATE_PULSE_ON is +** issued to a digital control, which is ON (in either manual or auto +** mode). It is also returned when SAHPI_CTRL_STATE_PULSE_OFF is issued +** to a digital control, which is OFF (in either manual or auto mode). +** SA_ERR_HPI_READ_ONLY is returned when attempting to change the mode of a +** control with a read-only mode. +** +** Remarks: +** When the mode is set to SAHPI_CTRL_MODE_AUTO, the state input is ignored. +** Ignored state inputs are not checked by the implementation. +** +** The CtrlState parameter must be of the correct type for the specified +** control. +** +** If the CtrlMode parameter is set to SAHPI_CTRL_MODE_AUTO, then the +** CtrlState parameter is not evaluated, and may be set to any value by an +** HPI User, including a NULL pointer. Text controls include a line number +** and a line of text in the CtrlState parameter, allowing update of just a +** single line of a text control. The first line of the text control is line +** number "1". If less than a full line of data is written, the control will +** clear all spaces beyond those written on the line. Thus writing a +** zero-length string will clear the addressed line. It is also possible to +** include more characters in the text passed in the CtrlState structure than +** will fit on one line; in this case, the control will wrap to the next line +** (still clearing the trailing characters on the last line written). Thus, +** there are two ways to write multiple lines to a text control: (a) call +** saHpiControlSet() repeatedly for each line, or (b) call saHpiControlSet() +** once and send more characters than will fit on one line. An HPI User +** should not assume any "cursor positioning" characters are available to +** use, but rather should always write full lines and allow "wrapping" to +** occur. When calling saHpiControlSet() for a text control, an HPI User may +** set the line number to SAHPI_TLN_ALL_LINES; in this case, the entire +** control will be cleared, and the data will be written starting on line 1. +** (This is different from simply writing at line 1, which only alters the +** lines written to.) +** +** This feature may be used to clear the entire control, which can be +** accomplished by setting: +** CtrlState->StateUnion.Text.Line = SAHPI_TLN_ALL_LINES; +** CtrlState->StateUnion.Text.Text.DataLength = 0; +** +** Note that the number of lines and columns in a text control can be +** obtained from the control's RDR. +** +** The ManufacturerId (MId) field of an OEM control is ignored by the +** implementation when calling saHpiControlSet(). +** +** On an OEM control, it is up to the implementation to determine what is +** invalid data, and to return the specified error code. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiControlSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiCtrlNumT CtrlNum, + SAHPI_IN SaHpiCtrlModeT CtrlMode, + SAHPI_IN SaHpiCtrlStateT *CtrlState +); + +/******************************************************************************* +** +** Name: saHpiIdrInfoGet() +** +** Description: +** This function returns the Inventory Data Repository information including +** the number of areas contained within the IDR and the update counter. The +** Inventory Data Repository is associated with a specific entity. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** IdrId - [in] Identifier for the Inventory Data Repository. +** IdrInfo - [out] Pointer to the information describing the requested +** Inventory Data Repository. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an +** inventory data repository, as indicated by +** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the IDR is not present. +** SA_ERR_HPI_INVALID_PARAMS is returned if the IdrInfo pointer is passed in +** as NULL. +** +** Remarks: +** The update counter provides a means for insuring that no additions or +** changes are missed when retrieving the IDR data. In order to use this +** feature, an HPI User should invoke the saHpiIdrInfoGet(), and retrieve the +** update counter value before retrieving the first Area. After retrieving +** all Areas and Fields of the IDR, an HPI User should again invoke the +** saHpiIdrInfoGet() to get the update counter value. If the update counter +** value has not been incremented, no modification or additions were made to +** the IDR during data retrieval. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiIdrInfoGet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiIdrIdT IdrId, + SAHPI_OUT SaHpiIdrInfoT *IdrInfo +); + +/******************************************************************************* +** +** Name: saHpiIdrAreaHeaderGet() +** +** Description: +** This function returns the Inventory Data Area header information for a +** specific area associated with a particular Inventory Data Repository. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** IdrId - [in] Identifier for the Inventory Data Repository. +** AreaType - [in] Type of Inventory Data Area. +** AreaId - [in] Identifier of Area entry to retrieve from the IDR. Reserved +** AreaId values: +** * SAHPI_FIRST_ENTRY Get first entry. +** * SAHPI_LAST_ENTRY Reserved as a delimiter for end of list. Not a +** valid AreaId. +** NextAreaId - [out] Pointer to location to store the AreaId of next area of +** the requested type within the IDR. +** Header - [out] Pointer to Inventory Data Area Header into which the header +** information will be placed. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an +** inventory data repository, as indicated by +** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the: +** * IDR is not present. +** * AreaType parameter is set to SAHPI_IDR_AREATYPE_UNSPECIFIED, and the +** area specified by the AreaId parameter does not exist in the IDR. +** * AreaType parameter is set to a specific area type, but an area +** matching both the AreaId parameter and AreaType parameter does not +** exist. +** SA_ERR_HPI_INVALID_PARAMS is returned if: +** * AreaType is not one of the valid enumerated values for this type. +** * The AreaId is an invalid reserved value such as SAHPI_LAST_ENTRY. +** * The NextAreaId pointer is passed in as NULL. +** * The Header pointer is passed in as NULL. +** +** Remarks: +** This function allows retrieval of an Inventory Data Area Header by one of +** two ways: by AreaId regardless of type or by AreaType and AreaId. +** +** To retrieve all areas contained within an IDR, set the AreaType parameter +** to SAHPI_IDR_AREATYPE_UNSPECIFIED, and set the AreaId parameter to +** SAHPI_FIRST_ENTRY for the first call. For each subsequent call, set the +** AreaId parameter to the value returned in the NextAreaId parameter. +** Continue calling this function until the NextAreaId parameter contains the +** value SAHPI_LAST_ENTRY. +** +** To retrieve areas of specific type within an IDR, set the AreaType +** parameter to a valid AreaType enumeration. Use the AreaId parameter in +** the same manner described above to retrieve all areas of the specified +** type. Set the AreaId parameter to SAHPI_FIRST_ENTRY to retrieve the first +** area of that type. Use the value returned in NextAreaId to retrieve the +** remaining areas of that type until SAHPI_LAST_ENTRY is returned. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiIdrAreaHeaderGet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiIdrIdT IdrId, + SAHPI_IN SaHpiIdrAreaTypeT AreaType, + SAHPI_IN SaHpiEntryIdT AreaId, + SAHPI_OUT SaHpiEntryIdT *NextAreaId, + SAHPI_OUT SaHpiIdrAreaHeaderT *Header +); + +/******************************************************************************* +** +** Name: saHpiIdrAreaAdd() +** +** Description: +** This function is used to add an Area to the specified Inventory Data +** Repository. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** IdrId - [in] Identifier for the Inventory Data Repository. +** AreaType - [in] Type of Area to add. +** AreaId- [out] Pointer to location to store the AreaId of the newly created +** area. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an +** inventory data repository, as indicated by +** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the IDR is not present. +** SA_ERR_HPI_INVALID_DATA is returned when attempting to add an area with an +** AreaType of SAHPI_IDR_AREATYPE_UNSPECIFIED or when adding an area that +** does not meet the implementation-specific restrictions. +** SA_ERR_HPI_OUT_OF_SPACE is returned if the IDR does not have enough free +** space to allow the addition of the area. +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * AreaId pointer is passed in as NULL. +** * AreaType is not one of the valid enumerated values for this type. +** SA_ERR_HPI_READ_ONLY is returned if the IDR is read-only and does not +** allow the addition of the area. +** +** Remarks: +** On successful completion, the AreaId parameter will contain the AreaId of +** the newly created area. +** +** On successful completion, the ReadOnly element in the new Area's header +** will always be False. +** +** SAHPI_IDR_AREATYPE_UNSPECIFIED is not a valid area type, and should not be +** used with this function. If SAHPI_IDR_AREATYPE_UNSPECIFIED is specified +** as the area type, an error code of SA_ERR_HPI_INVALID_DATA is returned. +** This area type is only valid when used with the saHpiIdrAreaHeaderGet() +** function to retrieve areas of an unspecified type. +** +** Some implementations may restrict the types of areas that may be added. +** These restrictions should be documented. SA_ERR_HPI_INVALID_DATA is +** returned when attempting to add an invalid area type. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiIdrAreaAdd( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiIdrIdT IdrId, + SAHPI_IN SaHpiIdrAreaTypeT AreaType, + SAHPI_OUT SaHpiEntryIdT *AreaId +); + +/******************************************************************************* +** +** Name: saHpiIdrAreaDelete() +** +** Description: +** This function is used to delete an Inventory Data Area, including the Area +** header and all fields contained with the area, from a particular Inventory +** Data Repository. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** IdrId - [in] Identifier for the Inventory Data Repository. +** AreaId - [in] Identifier of Area entry to delete from the IDR. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an +** inventory data repository, as indicated by +** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the: +** * IDR is not present. +** * Area identified by the AreaId parameter does not exist within the IDR. +** SA_ERR_HPI_INVALID_PARAMS is returned when the AreaId is an invalid +** reserved value such as SAHPI_LAST_ENTRY. +** SA_ERR_HPI_READ_ONLY is returned if the: +** * IDA is read-only and therefore cannot be deleted. +** * IDA contains a read-only Field and therefore cannot be deleted. +** * IDR is read-only as deletions are not permitted for an area from a +** read-only IDR. +** +** Remarks: +** Deleting an Inventory Data Area also deletes all fields contained within +** the area. +** +** In some implementations, certain Areas are intrinsically read-only. The +** ReadOnly flag, in the area header, indicates if the Area is read-only. +** +** If the Inventory Data Area is not read-only, but contains a Field that is +** read-only, the Area cannot be deleted. An attempt to delete an Area that +** contains a read-only Field will return an error. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiIdrAreaDelete( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiIdrIdT IdrId, + SAHPI_IN SaHpiEntryIdT AreaId +); + +/******************************************************************************* +** +** Name: saHpiIdrFieldGet() +** +** Description: +** This function returns the Inventory Data Field information from a +** particular Inventory Data Area and Repository. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** IdrId - [in] Identifier for the Inventory Data Repository. +** AreaId - [in] Area identifier for the IDA. +** FieldType - [in] Type of Inventory Data Field. +** FieldId - [in] Identifier of Field to retrieve from the IDA. Reserved +** FieldId values: +** * SAHPI_FIRST_ENTRY Get first entry. +** * SAHPI_LAST_ENTRY Reserved as a delimiter for end of list. Not +** a valid FieldId. +** NextFieldId - [out] Pointer to location to store the FieldId of next field +** of the requested type in the IDA. +** Field - [out] Pointer to Inventory Data Field into which the field +** information will be placed. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an +** inventory data repository, as indicated by +** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the: +** * IDR is not present. +** * Area identified by AreaId is not present. +** * FieldType parameter is set to SAHPI_IDR_FIELDTYPE_UNSPECIFIED, and +** the field specified by the FieldId parameter does not exist in the +** IDA. +** * FieldType parameter is set to a specific field type, but a field +** matching both the FieldId parameter and FieldType parameter does not +** exist. +** SA_ERR_HPI_INVALID_PARAMS is returned if: +** * FieldType is not one of the valid enumerated values for this type. +** * The AreaId or FieldId is an invalid reserved value such as +** SAHPI_LAST_ENTRY. +** * The NextFieldId pointer is passed in as NULL. +** * The Field pointer is passed in as NULL. +** +** Remarks: +** This function allows retrieval of an Inventory Data Field by one of two +** ways: by FieldId regardless of type or by FieldType and FieldId. +** +** To retrieve all fields contained within an IDA, set the FieldType parameter +** to SAHPI_IDR_FIELDTYPE_UNSPECIFIED, and set the FieldId parameter to +** SAHPI_FIRST_ENTRY for the first call. For each subsequent call, set the +** FieldId parameter to the value returned in the NextFieldId parameter. +** Continue calling this function until the NextFieldId parameter contains the +** value SAHPI_LAST_ENTRY. +** +** To retrieve fields of a specific type within an IDA, set the FieldType +** parameter to a valid Field type enumeration. Use the FieldId parameter in +** the same manner described above to retrieve all fields of the specified +** type. Set the FieldId parameter to SAHPI_FIRST_ENTRY to retrieve the first +** field of that type. Use the value returned in NextFieldId to retrieve the +** remaining fields of that type until SAHPI_LAST_ENTRY is returned. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiIdrFieldGet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiIdrIdT IdrId, + SAHPI_IN SaHpiEntryIdT AreaId, + SAHPI_IN SaHpiIdrFieldTypeT FieldType, + SAHPI_IN SaHpiEntryIdT FieldId, + SAHPI_OUT SaHpiEntryIdT *NextFieldId, + SAHPI_OUT SaHpiIdrFieldT *Field +); + +/******************************************************************************* +** +** Name: saHpiIdrFieldAdd() +** +** Description: +** This function is used to add a field to the specified Inventory Data Area +** with a specific Inventory Data Repository. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** IdrId - [in] Identifier for the Inventory Data Repository. +** Field - [in/out] Pointer to Inventory Data Field, which contains the new +** field information to add to the IDA. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an +** inventory data repository, as indicated by +** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the: +** * IDR is not present. +** * Area identified by Field?AreaId does not exist within the IDR. +** SA_ERR_HPI_INVALID_DATA is returned if the Field data is incorrectly +** formatted or does not meet the restrictions for the implementation. +** SA_ERR_HPI_OUT_OF_SPACE is returned if the IDR does not have enough free +** space to allow the addition of the field. +** SA_ERR_HPI_READ_ONLY is returned if the: +** * Area identified by Field?AreaId is read-only and does not allow +** modification to its fields. +** * IDR is identified by IdrId, is read-only, and does not allow +** modification to its fields. +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * The Field type is not one of the valid field type enumerated values. +** * Field type, Field?Type, is set to SAHPI_IDR_FIELDTYPE_UNSPECIFIED. +** * SaHpiTextBufferT structure passed as part of the Field parameter is +** not valid. This occurs when: +** * The DataType is not one of the enumerated values for that type, or +** * The data field contains characters that are not legal according to +** the value of DataType, or +** * The Language is not one of the enumerated values for that type +** when the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT. +** * Field pointer is passed in as NULL. +** +** Remarks: +** The FieldId element within the Field parameter is not used by this +** function. Instead, on successful completion, the FieldId field is set to +** the new value associated with the added Field. +** +** The ReadOnly element in the Field parameter is not used by this function. +** On successful completion, the ReadOnly element in the new Field will +** always be False. +** +** Addition of a read-only Inventory Data Field is not allowed; therefore the +** ReadOnly element in the SaHpiIdrFieldT parameter is ignored. +** +** SAHPI_IDR_FIELDTYPE_UNSPECIFIED is not a valid field type, and should not +** be used with this function. If SAHPI_IDR_FIELDTYPE_UNSPECIFIED is +** specified as the field type, an error code of SA_ERR_HPI_INVALID_DATA is +** returned. This field type is only valid when used with the +** saHpiIdrFieldGet() function to retrieve fields of an unspecified type. +** +** Some implementations have restrictions on what fields are valid in specific +** areas and/or the data format of some fields. These restrictions should be +** documented. SA_ERR_HPI_INVALID_DATA is returned when the field type or +** field data does not meet the implementation-specific restrictions. +** +** The AreaId element within the Field parameter identifies the specific IDA +** into which the new field is added. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiIdrFieldAdd( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiIdrIdT IdrId, + SAHPI_INOUT SaHpiIdrFieldT *Field +); + +/******************************************************************************* +** +** Name: saHpiIdrFieldSet() +** +** Description: +** This function is used to update an Inventory Data Field for a particular +** Inventory Data Area and Repository. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** IdrId - [in] Identifier for the Inventory Data Repository. +** Field - [in] Pointer to Inventory Data Field, which contains the updated +** field information. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an +** inventory data repository, as indicated by +** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the: +** * IDR is not present. +** * Area identified by Field?AreaId does not exist within the IDR or if +** the Field does not exist within the Inventory Data Area. +** SA_ERR_HPI_INVALID_PARAMS is returned if the: +** * Field pointer is passed in as NULL. +** * Field type, Field?Type, is not set to one of the valid field type +** enumerated values. +** * Field type, Field?Type, is set to SAHPI_IDR_FIELDTYPE_UNSPECIFIED. +** SA_ERR_HPI_INVALID_DATA is returned if the field data is incorrectly +** formatted or does not meet the restrictions for the implementation. +** SA_ERR_HPI_OUT_OF_SPACE is returned if the IDR does not have enough free +** space to allow the modification of the field due to an increase in the +** field size. +** SA_ERR_HPI_READ_ONLY is returned if the: +** * Field is read-only and does not allow modifications. +** * Area is read-only and does not allow modifications to its fields. +** * IDR is read-only and does not allow modifications to its fields. +** SA_ERR_HPI_INVALID_PARAMS is returned if the SaHpiTextBufferT structure +** passed as part of the Field parameter is not valid. This occurs when: +** * The DataType is not one of the enumerated values for that type, or +** * The data field contains characters that are not legal according to +** the value of DataType, or +** * The Language is not one of the enumerated values for that type when +** the DataType is SAHPI_TL_TYPE_UNICODE or SAHPI_TL_TYPE_TEXT. +** +** Remarks: +** This function allows modification of both the FieldType and Field data of +** a given Inventory Data Field. This function does not allow modification of +** the read-only attribute of the Inventory Data Field; therefore after a +** successful update, the ReadOnly element in the updated Field will always be +** False. The input value for ReadOnly is ignored. +** +** SAHPI_IDR_FIELDTYPE_UNSPECIFIED is not a valid field type, and should not +** be used with this function. If SAHPI_IDR_FIELDTYPE_UNSPECIFIED is +** specified as the new field type, an error code of SA_ERR_HPI_INVALID_DATA +** is returned. This field type is only valid when used with the +** saHpiIdrFieldGet() function to retrieve fields of an unspecified type. +** +** Some implementations have restrictions on what fields are valid in specific +** areas and/or the data format of some fields. These restrictions should be +** documented. SA_ERR_HPI_INVALID_DATA is returned when the field type or +** field data does not meet the implementation-specific restrictions. +** +** In some implementations, certain Fields are intrinsically read-only. The +** ReadOnly flag, in the field structure, indicates if the Field is read-only. +** +** The Field to update is identified by the AreaId and FieldId elements within +** the Field parameter. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiIdrFieldSet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiIdrIdT IdrId, + SAHPI_IN SaHpiIdrFieldT *Field +); + +/******************************************************************************* +** +** Name: saHpiIdrFieldDelete() +** +** Description: +** This function is used to delete an Inventory Data Field from a particular +** Inventory Data Area and Repository. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** IdrId - [in] Identifier for the Inventory Data Repository. +** AreaId - [in] Area identifier for the IDA. +** FieldId - [in] Identifier of Field to delete from the IDA. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support an +** inventory data repository, as indicated by +** SAHPI_CAPABILITY_INVENTORY_DATA in the resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the: +** * IDR is not present. +** * Area identified by the AreaId parameter does not exist within the IDR, +** or if the Field identified by the FieldId parameter does not exist +** within the IDA. +** SA_ERR_HPI_READ_ONLY is returned if the field, the IDA, or the IDR is +** read-only and does not allow deletion. +** SA_ERR_HPI_INVALID_PARAMS is returned when the AreaId or FieldId is an +** invalid reserved value such as SAHPI_LAST_ENTRY. +** +** Remarks: +** In some implementations, certain fields are intrinsically read-only. The +** ReadOnly flag, in the field structure, indicates if the field is read-only. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiIdrFieldDelete( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiIdrIdT IdrId, + SAHPI_IN SaHpiEntryIdT AreaId, + SAHPI_IN SaHpiEntryIdT FieldId +); + +/******************************************************************************* +** +** Name: saHpiWatchdogTimerGet() +** +** Description: +** This function retrieves the current watchdog timer settings and +** configuration. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** WatchdogNum - [in] Watchdog number that specifies the watchdog timer on a +** resource. +** Watchdog - [out] Pointer to watchdog data structure. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support a +** watchdog timer, as indicated by SAHPI_CAPABILITY_WATCHDOG in the +** resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the WatchdogNum is not present. +** SA_ERR_HPI_INVALID_PARAMS is returned when the Watchdog pointer is passed +** in as NULL. +** +** Remarks: +** See the description of the SaHpiWatchdogT structure in Section 8.11 on +** page 180 for details on what information is returned by this function. +** +** When the watchdog action is SAHPI_WA_RESET, the type of reset (warm or +** cold) is implementation-dependent. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiWatchdogTimerGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiWatchdogNumT WatchdogNum, + SAHPI_OUT SaHpiWatchdogT *Watchdog +); + +/******************************************************************************* +** +** Name: saHpiWatchdogTimerSet() +** +** Description: +** This function provides a method for initializing the watchdog timer +** configuration. +** +** Once the appropriate configuration has been set using +** saHpiWatchdogTimerSet(), an HPI User must then call +** saHpiWatchdogTimerReset() to initially start the watchdog timer, unless +** the watchdog timer was already running prior to calling +** saHpiWatchdogTimerSet() and the Running field in the passed Watchdog +** structure is True. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** WatchdogNum - [in] The watchdog number specifying the specific watchdog +** timer on a resource. +** Watchdog - [in] Pointer to watchdog data structure. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support a +** watchdog timer, as indicated by SAHPI_CAPABILITY_WATCHDOG in the +** resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the WatchdogNum is not present. +** SA_ERR_HPI_INVALID_PARAMS is returned when the: +** * Watchdog->TimerUse is not one of the valid enumerated values for this +** type. +** * Watchdog->TimerAction is not one of the valid enumerated values for +** this type. +** * Watchdog->PretimerInterrupt is not one of the valid enumerated values +** for this type. +** * Watchdog pointer is passed in as NULL. +** SA_ERR_HPI_INVALID_DATA is returned when the: +** * Watchdog->PreTimeoutInterval is outside the acceptable range for the +** implementation. +** * Watchdog->InitialCount is outside the acceptable range for the +** implementation. +** * Value of Watchdog->PreTimeoutInterval is greater than the value of +** Watchdog->InitialCount. +** * Watchdog->PretimerInterrupt is set to an unsupported value. See +** remarks. +** * Watchdog->TimerAction is set to an unsupported value. See remarks. +** * Watchdog->TimerUse is set to an unsupported value. See remarks. +** +** Remarks: +** Configuring the watchdog timer with the saHpiWatchdogTimerSet() function +** does not start the timer running. If the timer was previously stopped +** when this function is called, then it will remain stopped, and must be +** started by calling saHpiWatchdogTimerReset(). If the timer was previously +** running, then it will continue to run if the Watchdog->Running field passed +** is True, or will be stopped if the Watchdog->Running field passed is False. +** If it continues to run, it will restart its count-down from the newly +** configured initial count value. +** +** If the initial counter value is set to 0, then any configured pre-timer +** interrupt action or watchdog timer expiration action will be taken +** immediately when the watchdog timer is started. This provides a mechanism +** for software to force an immediate recovery action should that be dependent +** on a Watchdog timeout occurring. +** +** See the description of the SaHpiWatchdogT structure for more details on the +** effects of this command related to specific data passed in that structure. +** +** Some implementations impose a limit on the acceptable ranges for the +** PreTimeoutInterval or InitialCount. These limitations must be documented. +** SA_ERR_HPI_INVALID_DATA is returned if an attempt is made to set a value +** outside of the supported range. +** +** Some implementations cannot accept all of the enumerated values for +** TimerUse, TimerAction, or PretimerInterrupt. These restrictions should be +** documented. SA_ERR_HPI_INVALID_DATA is returned if an attempt is made to +** select an unsupported option. +** +** When the watchdog action is set to SAHPI_WA_RESET, the type of reset (warm +** or cold) is implementation-dependent. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiWatchdogTimerSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiWatchdogNumT WatchdogNum, + SAHPI_IN SaHpiWatchdogT *Watchdog +); + +/******************************************************************************* +** +** Name: saHpiWatchdogTimerReset() +** +** Description: +** This function provides a method to start or restart the watchdog timer from +** the initial countdown value. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** WatchdogNum - [in] The watchdog number specifying the specific watchdog +** timer on a resource. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support a +** watchdog timer, as indicated by SAHPI_CAPABILITY_WATCHDOG in the +** resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the WatchdogNum is not present. +** SA_ERR_HPI_INVALID_REQUEST is returned if the current watchdog state does +** not allow a reset. +** +** Remarks: +** If the Watchdog has been configured to issue a Pre-Timeout interrupt, and +** that interrupt has already occurred, the saHpiWatchdogTimerReset() function +** will not reset the watchdog counter. The only way to stop a Watchdog from +** timing out once a Pre-Timeout interrupt has occurred is to use the +** saHpiWatchdogTimerSet() function to reset and/or stop the timer. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiWatchdogTimerReset ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiWatchdogNumT WatchdogNum +); + +/******************************************************************************* +** +** Name: saHpiAnnunciatorGetNext() +** +** Description: +** This function allows retrieval of an announcement from the current set of +** announcements held in the Annunciator. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator. +** Severity - [in] Severity level of announcements to retrieve. Set to +** SAHPI_ALL_SEVERITIES to retrieve announcement of any severity; +** otherwise, set to requested severity level. +** UnacknowledgedOnly - [in] Set to True to indicate only unacknowledged +** announcements should be returned. Set to False to indicate either an +** acknowledged or unacknowledged announcement may be returned. +** Announcement - [in/out] Pointer to the structure to hold the returned +** announcement. Also, on input, Announcement->EntryId and +** Announcement->Timestamp are used to identify the "previous" +** announcement. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned when Severity is not one of the +** valid enumerated values for this type. +** SA_ERR_HPI_NOT_PRESENT is returned if: +** * The AnnunciatorNum passed does not address a valid Annunciator +** supported by the resource. +** * There are no announcements (or no unacknowledged announcements if +** UnacknowledgedOnly is True) that meet the specified Severity in the +** current set after the announcement identified by +** Announcement->EntryId and Announcement->Timestamp. +** * There are no announcements (or no unacknowledged announcements if +** UnacknowledgedOnly is True) that meet the specified Severity in the +** current set if the passed Announcement->EntryId field was set to +** SAHPI_FIRST_ENTRY. +** SA_ERR_HPI_INVALID_PARAMS is returned when the Announcement parameter is +** passed in as NULL. +** SA_ERR_HPI_INVALID_DATA is returned if the passed Announcement->EntryId +** matches an announcement in the current set, but the passed +** Announcement->Timestamp does not match the timestamp of that announcement. +** +** Remarks: +** All announcements contained in the set are maintained in the order in which +** they were added. This function will return the next announcement meeting +** the specifications given by an HPI User that was added to the set after the +** announcement whose EntryId and timestamp is passed by an HPI User. If +** SAHPI_FIRST_ENTRY is passed as the EntryId, the first announcement in the +** set meeting the specifications given by an HPI User is returned. This +** function should operate even if the announcement associated with the +** EntryId and Timestamp passed by an HPI User has been deleted. +** +** Selection can be restricted to only announcements of a specified severity, +** and/or only unacknowledged announcements. To retrieve all announcements +** contained meeting specific requirements, call saHpiAnnunciatorGetNext() +** with the Status->EntryId field set to SAHPI_FIRST_ENTRY and the Severity +** and UnacknowledgedOnly parameters set to select what announcements should +** be returned. Then, repeatedly call saHpiAnnunciatorGetNext() passing the +** previously returned announcement as the Announcement parameter, and the +** same values for Severity and UnacknowledgedOnly until the function returns +** with the error code SA_ERR_HPI_NOT_PRESENT. +** +** SAHPI_FIRST_ENTRY and SAHPI_LAST_ENTRY are reserved EntryId values, and +** will never be assigned to an announcement. +** +** The elements EntryId and Timestamp are used in the Announcement parameter +** to identify the "previous" announcement; the next announcement added to the +** table after this announcement that meets the Severity and +** UnacknowledgedOnly requirements will be returned. Announcement->EntryId +** may be set to SAHPI_FIRST_ENTRY to select the first announcement in the +** current set meeting the Severity and UnacknowledgedOnly requirements. If +** Announcement->EntryId is SAHPI_FIRST_ENTRY, then Announcement->Timestamp +** is ignored. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAnnunciatorGetNext( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum, + SAHPI_IN SaHpiSeverityT Severity, + SAHPI_IN SaHpiBoolT UnacknowledgedOnly, + SAHPI_INOUT SaHpiAnnouncementT *Announcement +); + +/******************************************************************************* +** +** Name: saHpiAnnunciatorGet() +** +** Description: +** This function allows retrieval of a specific announcement in the +** Annunciator's current set by referencing its EntryId. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained +** using saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator. +** EntryId - [in] Identifier of the announcement to retrieve from the +** Annunciator. +** Announcement - [out] Pointer to the structure to hold the returned +** announcement. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the +** resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if: +** * The AnnunciatorNum passed does not address a valid Annunciator +** supported by the resource. +** * The requested EntryId does not correspond to an announcement +** contained in the Annunciator. +** SA_ERR_HPI_INVALID_PARAMS is returned when the Announcement parameter is +** passed in as NULL. +** +** Remarks: +** SAHPI_FIRST_ENTRY and SAHPI_LAST_ENTRY are reserved EntryId values, and +** will never be assigned to announcements. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAnnunciatorGet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum, + SAHPI_IN SaHpiEntryIdT EntryId, + SAHPI_OUT SaHpiAnnouncementT *Announcement +); + +/******************************************************************************* +** +** Name: saHpiAnnunciatorAcknowledge() +** +** Description: +** This function allows an HPI User to acknowledge a single announcement or a +** group of announcements by severity. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator. +** EntryId - [in] Entry identifier of the announcement to acknowledge. +** Reserved EntryId values: +** * SAHPI_ENTRY_UNSPECIFIED Ignore this parameter. +** Severity - [in] Severity level of announcements to acknowledge. Ignored +** unless EntryId is SAHPI_ENTRY_UNSPECIFIED. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the +** resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if: +** * The AnnunciatorNum passed does not address a valid Annunciator +** supported by the resource. +** * An announcement identified by the EntryId parameter does not exist in +** the current set. +** SA_ERR_HPI_INVALID_PARAMS is returned if EntryId is SAHPI_ENTRY_UNSPECIFIED +** and Severity is not one of the valid enumerated values for this type. +** +** Remarks: +** Announcements are acknowledged by one of two ways: a single announcement +** by EntryId regardless of severity or as a group of announcements by +** severity regardless of EntryId. +** +** An HPI User acknowledges an announcement to influence the platform-specific +** annunciation provided by the Annunciator management instrument. +** +** An acknowledged announcement will have the Acknowledged field set to True. +** +** To acknowledge all announcements contained within the current set, set the +** Severity parameter to SAHPI_ALL_SEVERITIES, and set the EntryId parameter +** to SAHPI_ENTRY_UNSPECIFIED. +** +** To acknowledge all announcements of a specific severity, set the Severity +** parameter to the appropriate value, and set the EntryId parameter to +** SAHPI_ENTRY_UNSPECIFIED. +** +** To acknowledge a single announcement, set the EntryId parameter to a value +** other than SAHPI_ENTRY_UNSPECIFIED. The EntryId must be a valid identifier +** for an announcement present in the current set. +** +** If an announcement has been previously acknowledged, acknowledging it again +** has no effect. However, this is not an error. +** +** If the EntryId parameter has a value other than SAHPI_ENTRY_UNSPECIFIED, +** the Severity parameter is ignored. +** +** If the EntryId parameter is passed as SAHPI_ENTRY_UNSPECIFIED, and no +** announcements are present that meet the requested Severity, this function +** will have no effect. However, this is not an error. +** +** SAHPI_ENTRY_UNSPECIFIED is defined as the same value as SAHPI_FIRST_ENTRY, +** so using either symbol will have the same effect. However, +** SAHPI_ENTRY_UNSPECIFIED should be used with this function for clarity. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAnnunciatorAcknowledge( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum, + SAHPI_IN SaHpiEntryIdT EntryId, + SAHPI_IN SaHpiSeverityT Severity +); + +/******************************************************************************* +** +** Name: saHpiAnnunciatorAdd() +** +** Description: +** This function is used to add an announcement to the set of items held by an +** Annunciator management instrument. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator. +** Announcement - [in/out] Pointer to structure that contains the new +** announcement to add to the set. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the +** resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the AnnunciatorNum passed does not +** address a valid Annunciator supported by the resource. +** SA_ERR_HPI_INVALID_PARAMS is returned when: +** * The Announcement pointer is passed in as NULL. +** * The Announcement->Severity passed is not valid. +** * The Announcement->StatusCond structure passed in is not valid. +** SA_ERR_HPI_OUT_OF_SPACE is returned if the Annunciator is not able to add +** an additional announcement due to resource limits. +** SA_ERR_HPI_READ_ONLY is returned if the Annunciator is in auto mode. +** +** Remarks: +** The EntryId, Timestamp, and AddedByUser fields within the Announcement +** parameter are not used by this function. Instead, on successful +** completion, these fields are set to new values associated with the added +** announcement. AddedByUser will always be set to True. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAnnunciatorAdd( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum, + SAHPI_INOUT SaHpiAnnouncementT *Announcement +); + +/******************************************************************************* +** +** Name: saHpiAnnunciatorDelete() +** +** Description: +** This function allows an HPI User to delete a single announcement or a group +** of announcements from the current set of an Annunciator. Announcements may +** be deleted individually by specifying a specific EntryId, or they may be +** deleted as a group by specifying a severity. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator. +** EntryId - [in] Entry identifier of the announcement to delete. Reserved +** EntryId values: +** * SAHPI_ENTRY_UNSPECIFIED Ignore this parameter. +** Severity - [in] Severity level of announcements to delete. Ignored unless +** EntryId is SAHPI_ENTRY_UNSPECIFIED. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned if EntryId is SAHPI_ENTRY_UNSPECIFIED +** and Severity is not one of the valid enumerated values for this type. +** SA_ERR_HPI_NOT_PRESENT is returned if: +** * The AnnunciatorNum passed does not address a valid Annunciator +** supported by the resource +** * An announcement identified by the EntryId parameter does not exist in +** the current set of the Annunciator. +** SA_ERR_HPI_READ_ONLY is returned if the Annunciator is in auto mode. +** +** Remarks: +** To delete a single, specific announcement, set the EntryId parameter to a +** value representing an actual announcement in the current set. The Severity +** parameter is ignored when the EntryId parameter is set to a value other +** than SAHPI_ENTRY_UNSPECIFIED. +** +** To delete a group of announcements, set the EntryId parameter to +** SAHPI_ENTRY_UNSPECIFIED, and set the Severity parameter to identify which +** severity of announcements should be deleted. To clear all announcements +** contained within the Annunciator, set the Severity parameter to +** SAHPI_ALL_SEVERITIES. +** +** If the EntryId parameter is passed as SAHPI_ENTRY_UNSPECIFIED, and no +** announcements are present that meet the specified Severity, this function +** will have no effect. However, this is not an error. +** +** SAHPI_ENTRY_UNSPECIFIED is defined as the same value as SAHPI_FIRST_ENTRY, +** so using either symbol will have the same effect. However, +** SAHPI_ENTRY_UNSPECIFIED should be used with this function for clarity. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAnnunciatorDelete( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum, + SAHPI_IN SaHpiEntryIdT EntryId, + SAHPI_IN SaHpiSeverityT Severity +); + +/******************************************************************************* +** +** Name: saHpiAnnunciatorModeGet() +** +** Description: +** This function allows an HPI User to retrieve the current operating mode of +** an Annunciator. The mode indicates whether or not an HPI User is allowed to +** add or delete items in the set, and whether or not the HPI implementation +** will automatically add or delete items in the set. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator. +** Mode - [out] Pointer to location to store the current operating mode of the +** Annunciator where the returned value will be one of the following: +** * SAHPI_ANNUNCIATOR_MODE_AUTO - the HPI implementation may add or delete +** announcements in the set; an HPI User may not add or delete +** announcements in the set. +** * SAHPI_ANNUNCIATOR_MODE_USER - the HPI implementation may not add or +** delete announcements in the set; an HPI User may add or delete +** announcements in the set. +** * SAHPI_ANNUNCIATOR_MODE_SHARED - both the HPI implementation and an HPI +** User may add or delete announcements in the set. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the +** resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the AnnunciatorNum passed does not +** address a valid Annunciator supported by the resource. +** SA_ERR_HPI_INVALID_PARAMS is returned if Mode is passed in as NULL. +** +** Remarks: +** None. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAnnunciatorModeGet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum, + SAHPI_OUT SaHpiAnnunciatorModeT *Mode +); + +/******************************************************************************* +** +** Name: saHpiAnnunciatorModeSet() +** +** Description: +** This function allows an HPI User to change the current operating mode of an +** Annunciator. The mode indicates whether or not an HPI User is allowed to +** add or delete announcements in the set, and whether or not the HPI +** implementation will automatically add or delete announcements in the set. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** AnnunciatorNum - [in] Annunciator number for the addressed Annunciator. +** Mode - [out] Mode to set for the Annunciator: +** * SAHPI_ANNUNCIATOR_MODE_AUTO - the HPI implementation may add or delete +** announcements in the set; an HPI User may not add or delete +** announcements in the set. +** * SAHPI_ANNUNCIATOR_MODE_USER - the HPI implementation may not add or +** delete announcements in the set; an HPI User may add or delete +** announcements in the set. +** * SAHPI_ANNUNCIATOR_MODE_SHARED - both the HPI implementation and an HPI +** User may add or delete announcements in the set. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** Annunciators, as indicated by SAHPI_CAPABILITY_ANNUNCIATOR in the +** resource's RPT entry. +** SA_ERR_HPI_NOT_PRESENT is returned if the AnnunciatorNum passed does not +** address a valid Annunciator supported by the resource. +** SA_ERR_HPI_INVALID_PARAMS is returned if Mode is not a valid enumerated +** value for this type. +** SA_ERR_HPI_READ_ONLY is returned if mode changing is not permitted for +** this Annunciator. +** +** Remarks: +** None. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAnnunciatorModeSet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiAnnunciatorNumT AnnunciatorNum, + SAHPI_IN SaHpiAnnunciatorModeT Mode +); + +/******************************************************************************* +** +** Name: saHpiHotSwapPolicyCancel() +** +** Description: +** A resource supporting hot swap typically supports default policies for +** insertion and extraction. On insertion, the default policy may be for the +** resource to turn the associated FRU's local power on and to de-assert +** reset. On extraction, the default policy may be for the resource to +** immediately power off the FRU and turn on a hot swap indicator. This +** function allows an HPI User, after receiving a hot swap event with +** HotSwapState equal to SAHPI_HS_STATE_INSERTION_PENDING or +** SAHPI_HS_STATE_EXTRACTION_PENDING, to prevent the default policy from +** being executed. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** managed hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in +** the resource's RPT entry. +** SA_ERR_HPI_INVALID_REQUEST is returned if the resource is: +** * Not in the INSERTION PENDING or EXTRACTION PENDING state. +** * Processing an auto-insertion or auto-extraction policy. +** +** Remarks: +** Each time the resource transitions to either the INSERTION PENDING or +** EXTRACTION PENDING state, the default policies will execute after the +** configured timeout period, unless cancelled using +** saHpiHotSwapPolicyCancel() after the transition to INSERTION PENDING or +** EXTRACTION PENDING state and before the timeout expires.The default policy +** cannot be canceled once it has begun to execute. +** +** Because a resource that supports the simplified hot swap model will never +** transition into INSERTION PENDING or EXTRACTION PENDING states, this +** function is not applicable to those resources. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiHotSwapPolicyCancel ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId +); + +/******************************************************************************* +** +** Name: saHpiResourceActiveSet() +** +** Description: +** This function allows an HPI User to request a resource to transition to the +** ACTIVE state from the INSERTION PENDING or EXTRACTION PENDING state. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed +** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_REQUEST is returned if the resource is: +** * Not in the INSERTION PENDING or EXTRACTION PENDING state. +** * Processing an auto-insertion or auto-extraction policy. +** +** Remarks: +** During insertion, a resource supporting hot swap will generate an event to +** indicate that it is in the INSERTION PENDING state. If an HPI User calls +** saHpiHotSwapPolicyCancel() before the resource begins an auto-insert +** operation, then the resource will remain in INSERTION PENDING state while +** an HPI User acts on the resource to integrate it into the system. During +** this state, an HPI User can instruct the resource to power on the +** associated FRU, to de-assert reset, or to turn off its hot swap indicator +** using the saHpiResourcePowerStateSet(), saHpiResourceResetStateSet(), or +** saHpiHotSwapIndicatorStateSet() functions, respectively, if the resource +** has those associated capabilities. Once an HPI User has completed with the +** integration of the FRU, this function must be called to signal that the +** resource should now transition into the ACTIVE state. +** +** An HPI User may also use this function to request a resource to return to +** the ACTIVE state from the EXTRACTION PENDING state in order to reject an +** extraction request. +** +** Because a resource that supports the simplified hot swap model will never +** transition into INSERTION PENDING or EXTRACTION PENDING states, this +** function is not applicable to those resources. +** +** Only valid if resource is in INSERTION PENDING or EXTRACTION PENDING state +** and an auto-insert or auto-extract policy action has not been initiated. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiResourceActiveSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId +); + +/******************************************************************************* +** +** Name: saHpiResourceInactiveSet() +** +** Description: +** This function allows an HPI User to request a resource to transition to the +** INACTIVE state from the INSERTION PENDING or EXTRACTION PENDING state. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed +** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_REQUEST is returned if the resource is: +** * Not in the INSERTION PENDING or EXTRACTION PENDING state. +** * Processing an auto-insertion or auto-extraction policy. +** +** Remarks: +** During extraction, a resource supporting hot swap will generate an event +** to indicate that it is in the EXTRACTION PENDING state. If an HPI User +** calls saHpiHotSwapPolicyCancel() before the resource begins an auto-extract +** operation, then the resource will remain in EXTRACTION PENDING state while +** an HPI User acts on the resource to isolate the associated FRU from the +** system. During this state, an HPI User can instruct the resource to power +** off the FRU, to assert reset, or to turn on its hot swap indicator using +** the saHpiResourcePowerStateSet(), saHpiResourceResetStateSet(), or +** saHpiHotSwapIndicatorStateSet() functions, respectively, if the resource +** has these associated capabilities. Once an HPI User has completed the +** shutdown of the FRU, this function must be called to signal that the +** resource should now transition into the INACTIVE state. +** +** An HPI User may also use this function to request a resource to return to +** the INACTIVE state from the INSERTION PENDING state to abort a hot-swap +** insertion action. +** +** Because a resource that supports the simplified hot swap model will never +** transition into INSERTION PENDING or EXTRACTION PENDING states, this +** function is not applicable to those resources. +** +** Only valid if resource is in EXTRACTION PENDING or INSERTION PENDING state +** and an auto-extract or auto-insert policy action has not been initiated. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiResourceInactiveSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId +); + +/******************************************************************************* +** +** Name: saHpiAutoInsertTimeoutGet() +** +** Description: +** This function allows an HPI User to request the auto-insert timeout value +** within a specific domain. This value indicates how long the resource will +** wait before the default auto-insertion policy is invoked. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** Timeout - [out] Pointer to location to store the number of nanoseconds to +** wait before autonomous handling of the hot swap event. Reserved time +** outvalues: +** * SAHPI_TIMEOUT_IMMEDIATE indicates autonomous handling is immediate. +** * SAHPI_TIMEOUT_BLOCK indicates autonomous handling does not occur. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_INVALID_PARAMS is returned if the Timeout pointer is passed in +** as NULL. +** +** Remarks: +** Each domain maintains a single auto-insert timeout value and it is applied +** to all contained resources upon insertion, which support managed hot swap. +** Further information on the auto-insert timeout can be found in the +** function saHpiAutoInsertTimeoutSet(). +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAutoInsertTimeoutGet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_OUT SaHpiTimeoutT *Timeout +); + +/******************************************************************************* +** +** Name: saHpiAutoInsertTimeoutSet() +** +** Description: +** This function allows an HPI User to configure a timeout for how long to +** wait before the default auto-insertion policy is invoked on a resource +** within a specific domain. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** Timeout - [in] The number of nanoseconds to wait before autonomous handling +** of the hot swap event. Reserved time out values: +** * SAHPI_TIMEOUT_IMMEDIATE indicates proceed immediately to autonomous +** handling. +** * SAHPI_TIMEOUT_BLOCK indicates prevent autonomous handling. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_READ_ONLY is returned if the auto-insert timeout for the domain +** is fixed as indicated by the SAHPI_DOMAIN_CAP_AUTOINSERT_READ_ONLY flag +** in the DomainInfo structure. +** SA_ERR_HPI_INVALID_PARAMS is returned when the Timeout parameter is not set +** to SAHPI_TIMEOUT_BLOCK, SAHPI_TIMEOUT_IMMEDIATE or a positive value. +** +** Remarks: +** This function accepts a parameter instructing each resource to impose a +** delay before performing its default hot swap policy for auto-insertion. +** The parameter may be set to SAHPI_TIMEOUT_IMMEDIATE to direct resources to +** proceed immediately to auto-insertion, or to SAHPI_TIMEOUT_BLOCK to prevent +** auto-insertion from ever occurring. If the parameter is set to another +** value, then it defines the number of nanoseconds between the time a hot +** swap event with HotSwapState = SAHPI_HS_STATE_INSERTION_PENDING is +** generated, and the time that the auto-insertion policy will be invoked for +** that resource. If, during this time period, a saHpiHotSwapPolicyCancel() +** function call is processed, the timer will be stopped, and the +** auto-insertion policy will not be invoked. Each domain maintains a single +** auto-insert timeout value and it is applied to all contained resources upon +** insertion, which support managed hot swap. +** +** Once the auto-insertion policy begins, an HPI User will not be allowed to +** cancel the insertion policy; hence, the timeout should be set appropriately +** to allow for this condition. Note that the timeout period begins when the +** hot swap event with HotSwapState = SAHPI_HS_STATE_INSERTION_PENDING is +** initially generated; not when it is received by an HPI User with a +** saHpiEventGet() function call, or even when it is placed in a session +** event queue. +** +** A resource may exist in multiple domains, which themselves may have +** different auto-insertion timeout values. Upon insertion, the resource will +** begin its auto-insertion policy based on the smallest auto-insertion +** timeout value. As an example, if a resource is inserted into two domains, +** one with an auto-insertion timeout of 5 seconds, and one with an +** auto-insertion timeout of 10 seconds, the resource will begin its +** auto-insertion policy at 5 seconds. +** +** An implementation may enforce a fixed, preset timeout value. In such +** cases, the SAHPI_DOMAIN_CAP_AUTOINSERT_READ_ONLY flag will be set to +** indicate that an HPI User cannot change the auto-insert Timeout value. +** SA_ERR_HPI_READ_ONLY is returned if an HPI User attempts to change a +** read-only timeout. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAutoInsertTimeoutSet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiTimeoutT Timeout +); + +/******************************************************************************* +** +** Name: saHpiAutoExtractTimeoutGet() +** +** Description: +** This function allows an HPI User to request the timeout for how long a +** resource will wait before the default auto-extraction policy is invoked. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** Timeout - [out] Pointer to location to store the number of nanoseconds to +** wait before autonomous handling of the hot swap event. Reserved time +** out values: +** * SAHPI_TIMEOUT_IMMEDIATE indicates autonomous handling is immediate. +** * SAHPI_TIMEOUT_BLOCK indicates autonomous handling does not occur. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed +** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned if the Timeout pointer is passed in +** as NULL. +** +** Remarks: +** Further information on auto-extract timeouts is detailed in +** saHpiAutoExtractTimeoutSet(). +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAutoExtractTimeoutGet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_OUT SaHpiTimeoutT *Timeout +); + +/******************************************************************************* +** +** Name: saHpiAutoExtractTimeoutSet() +** +** Description: +** This function allows an HPI User to configure a timeout for how long to +** wait before the default auto-extraction policy is invoked. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** Timeout - [in] The number of nanoseconds to wait before autonomous handling +** of the hot swap event. Reserved timeout values: +** * SAHPI_TIMEOUT_IMMEDIATE indicates proceed immediately to autonomous +** handling. +** * SAHPI_TIMEOUT_BLOCK indicates prevent autonomous handling. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed +** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned when the Timeout parameter is not set +** to SAHPI_TIMEOUT_BLOCK, SAHPI_TIMEOUT_IMMEDIATE or a positive value. +** SA_ERR_HPI_READ_ONLY is returned if the auto-extract timeout for the +** resource is fixed, as indicated by the +** SAHPI_HS_CAPABILITY_AUTOEXTRACT_READ_ONLY in the resource's RPT entry. +** +** Remarks: +** This function accepts a parameter instructing the resource to impose a +** delay before performing its default hot swap policy for auto-extraction. +** The parameter may be set to SAHPI_TIMEOUT_IMMEDIATE to direct the resource +** to proceed immediately to auto-extraction, or to SAHPI_TIMEOUT_BLOCK to +** prevent auto-extraction from ever occurring on a resource. If the parameter +** is set to another value, then it defines the number of nanoseconds between +** the time a hot swap event with +** HotSwapState = SAHPI_HS_STATE_EXTRACTION_PENDING is generated and the time +** that the auto-extraction policy will be invoked for the resource. If, +** during this time period, a saHpiHotSwapPolicyCancel() function call is +** processed, the timer will be stopped, and the auto-extraction policy will +** not be invoked. +** +** Once the auto-extraction policy begins, an HPI User will not be allowed to +** cancel the extraction policy; hence, the timeout should be set +** appropriately to allow for this condition. Note that the timeout period +** begins when the hot swap event with +** HotSwapState = SAHPI_HS_STATE_EXTRACTION_PENDING is initially generated; +** not when it is received by a HPI User with a saHpiEventGet() function call, +** or even when it is placed in a session event queue. +** +** The auto-extraction policy is set at the resource level and is only +** supported by resources supporting the Managed Hot Swap capability. The +** auto-extraction timeout value cannot be modified if the resource's "Hot +** Swap AutoExtract Read-only" capability is set. After discovering that a +** newly inserted resource supports Managed Hot Swap, and read-write +** auto-extract timeouts, an HPI User may use this function to change the +** timeout of the auto-extraction policy for that resource. If a resource +** supports the simplified hot swap model, setting this timer has no effect +** since the resource will transition directly to NOT PRESENT state on an +** extraction. +** +** An implementation may enforce a fixed, preset timeout value. In such +** cases, the SAHPI_HS_CAPABILITY_AUTOEXTRACT_READ_ONLY flag will be set to +** indicate that an HPI User cannot change the auto-extract Timeout value. +** SA_ERR_HPI_READ_ONLY is returned if an HPI User attempts to change a +** read-only timeout. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiAutoExtractTimeoutSet( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiTimeoutT Timeout +); + +/******************************************************************************* +** +** Name: saHpiHotSwapStateGet() +** +** Description: +** This function allows an HPI User to retrieve the current hot swap state of +** a resource. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** State - [out] Pointer to location to store returned state information. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed +** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned if the State pointer is passed in as +** NULL. +** +** Remarks: +** The returned state will be one of the following four states: +** * SAHPI_HS_STATE_INSERTION_PENDING +** * SAHPI_HS_STATE_ACTIVE +** * SAHPI_HS_STATE_EXTRACTION_PENDING +** * SAHPI_HS_STATE_INACTIVE +** +** The state SAHPI_HS_STATE_NOT_PRESENT will never be returned, because a +** resource that is not present cannot be addressed by this function in the +** first place. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiHotSwapStateGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_OUT SaHpiHsStateT *State +); + +/******************************************************************************* +** +** Name: saHpiHotSwapActionRequest() +** +** Description: +** This function allows an HPI User to invoke an insertion or extraction +** process via software. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** Action - [in] Requested action: +** * SAHPI_HS_ACTION_INSERTION +** * SAHPI_HS_ACTION_EXTRACTION +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support managed +** hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_REQUEST is returned if the resource is not in an +** appropriate hot swap state, or if the requested action is inappropriate +** for the current hot swap state. See the Remarks section below. +** SA_ERR_HPI_INVALID_PARAMS is returned when Action is not one of the valid +** enumerated values for this type. +** +** Remarks: +** A resource supporting hot swap typically requires a physical action on the +** associated FRU to invoke an insertion or extraction process. An insertion +** process is invoked by physically inserting the FRU into a chassis. +** Physically opening an ejector latch or pressing a button invokes the +** extraction process. This function provides an alternative means to invoke +** an insertion or extraction process via software. +** +** This function may only be called: +** * To request an insertion action when the resource is in INACTIVE state. +** * To request an extraction action when the resource is in the ACTIVE +** state. +** The function may not be called when the resource is in any other state. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiHotSwapActionRequest ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiHsActionT Action +); + +/******************************************************************************* +** +** Name: saHpiHotSwapIndicatorStateGet() +** +** Description: +** This function allows an HPI User to retrieve the state of the hot swap +** indicator. A FRU associated with a hot-swappable resource may include a hot +** swap indicator such as a blue LED. This indicator signifies that the FRU is +** ready for removal. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** State - [out] Pointer to location to store state of hot swap indicator. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support: +** * Managed hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in +** the resource's RPT entry. +** * A hot swap indicator on the FRU as indicated by the +** SAHPI_HS_CAPABILITY_INDICATOR_SUPPORTED in the resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned if the State pointer is passed in as +** NULL. +** +** Remarks: +** The returned state is either SAHPI_HS_INDICATOR_OFF or +** SAHPI_HS_INDICATOR_ON. This function will return the state of the +** indicator, regardless of what hot swap state the resource is in. +** +** Not all resources supporting managed hot swap will necessarily support +** this function. Whether or not a resource supports the hot swap indicator +** is specified in the Hot Swap Capabilities field of the RPT entry. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiHotSwapIndicatorStateGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_OUT SaHpiHsIndicatorStateT *State +); + +/******************************************************************************* +** +** Name: saHpiHotSwapIndicatorStateSet() +** +** Description: +** This function allows an HPI User to set the state of the hot swap +** indicator. A FRU associated with a hot-swappable resource may include a hot +** swap indicator such as a blue LED. This indicator signifies that the FRU is +** ready for removal. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** State - [in] State of hot swap indicator to be set. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support: +** * Managed hot swap, as indicated by SAHPI_CAPABILITY_MANAGED_HOTSWAP in +** the resource's RPT entry. +** * A hot swap indicator on the FRU as indicated by the +** SAHPI_HS_CAPABILITY_INDICATOR_SUPPORTED in the resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned when State is not one of the valid +** enumerated values for this type. +** +** Remarks: +** Valid states include SAHPI_HS_INDICATOR_OFF or SAHPI_HS_INDICATOR_ON. This +** function will set the indicator regardless of what hot swap state the +** resource is in, though it is recommended that this function be used only +** in conjunction with moving the resource to the appropriate hot swap state. +** +** Not all resources supporting managed hot swap will necessarily support this +** function. Whether or not a resource supports the hot swap indicator is +** specified in the Hot Swap Capabilities field of the RPT entry. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiHotSwapIndicatorStateSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiHsIndicatorStateT State +); + +/******************************************************************************* +** +** Name: saHpiParmControl() +** +** Description: +** This function allows an HPI User to save and restore parameters associated +** with a specific resource. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** Action - [in] Action to perform on resource parameters. +** * SAHPI_DEFAULT_PARM Restores the factory default settings for a +** specific resource. Factory defaults include sensor thresholds and +** configurations, and resource- specific configuration parameters. +** * SAHPI_SAVE_PARM Stores the resource configuration parameters in +** non-volatile storage. Resource configuration parameters stored in +** non-volatile storage will survive power cycles and resource resets. +** * SAHPI_RESTORE_PARM Restores resource configuration parameters from +** non-volatile storage. Resource configuration parameters include +** sensor thresholds and sensor configurations, as well as +** resource-specific parameters. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support +** parameter control, as indicated by SAHPI_CAPABILITY_CONFIGURATION in the +** resource's RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned when Action is not set to a proper +** value. +** +** Remarks: +** Resource-specific parameters should be documented in an implementation +** guide for the HPI implementation. +** +** When this API is called with SAHPI_RESTORE_PARM as the action prior to +** having made a call with this API where the action parameter was set to +** SAHPI_SAVE_PARM, the default parameters will be restored. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiParmControl ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiParmActionT Action +); + +/******************************************************************************* +** +** Name: saHpiResourceResetStateGet() +** +** Description: +** This function gets the reset state of an entity, allowing an HPI User to +** determine if the entity is being held with its reset asserted. If a +** resource manages multiple entities, this function will address the entity +** which is identified in the RPT entry for the resource. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** ResetAction - [out] The current reset state of the entity. Valid reset +** states are: +** * SAHPI_RESET_ASSERT: The entity's reset is asserted, e.g., for hot +** swap insertion/extraction purposes. +** * SAHPI_RESET_DEASSERT: The entity's reset is not asserted. +** +** Return Value: +** SA_OK is returned if the resource has reset control, and the reset state +** has successfully been determined; otherwise, an error code is returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support reset +** control as indicated by SAHPI_CAPABILITY_RESET in the resource's RPT +** entry. +** SA_ERR_HPI_INVALID_PARAMS is returned if the ResetAction pointer is passed +** in as NULL. +** +** Remarks: +** SAHPI_COLD_RESET and SAHPI_WARM_RESET are pulsed resets, and are not valid +** values to be returned in ResetAction. If the entity is not being held in +** reset (using SAHPI_RESET_ASSERT), the appropriate value is +** SAHPI_RESET_DEASSERT. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiResourceResetStateGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_OUT SaHpiResetActionT *ResetAction +); + +/******************************************************************************* +** +** Name: saHpiResourceResetStateSet() +** +** Description: +** This function directs the resource to perform the specified reset type on +** the entity that it manages. If a resource manages multiple entities, this +** function addresses the entity that is identified in the RPT entry for the +** resource. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** ResetAction - [in] Type of reset to perform on the entity. Valid reset +** actions are: +** * SAHPI_COLD_RESET: Perform a 'Cold Reset' on the entity (pulse), +** leaving reset de-asserted, +** * SAHPI_WARM_RESET: Perform a 'Warm Reset' on the entity (pulse), +** leaving reset de-asserted, +** * SAHPI_RESET_ASSERT: Put the entity into reset state and hold reset +** asserted, e.g., for hot swap insertion/extraction purposes, +** * SAHPI_RESET_DEASSERT: Bring the entity out of the reset state. +** +** Return Value: +** SA_OK is returned if the resource has reset control, and the requested +** reset action has succeeded; otherwise, an error code is returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support resource +** reset control, as indicated by SAHPI_CAPABILITY_RESET in the resource's +** RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned when the ResetAction is not set to a +** proper value. +** SA_ERR_HPI_INVALID_CMD is returned if the requested ResetAction is +** SAHPI_RESET_ASSERT and the resource does not support this action. +** SA_ERR_HPI_INVALID_REQUEST is returned if the ResetAction is +** SAHPI_COLD_RESET or SAHPI_WARM_RESET and reset is currently asserted. +** +** Remarks: +** Some resources may not support holding the entity in reset. If this is the +** case, the resource should return SA_ERR_HPI_INVALID_CMD if the +** SAHPI_RESET_ASSERT action is requested. All resources that have the +** SAHPI_CAPABILITY_RESET flag set in their RPTs should support +** SAHPI_COLD_RESET and SAHPI_WARM_RESET. However, it is not required that +** these actions be different. That is, some resources may only have one +** sort of reset action (e.g., a "cold" reset) which is executed when either +** SAHPI_COLD_RESET or SAHPI_WARM_RESET is requested. +** +** The SAHPI_RESET_ASSERT is used to hold an entity in reset, and +** SAHPI_RESET_DEASSERT is used to bring the entity out of an asserted reset +** state. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiResourceResetStateSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiResetActionT ResetAction +); + +/******************************************************************************* +** +** Name: saHpiResourcePowerStateGet() +** +** Description: +** This function gets the power state of an entity, allowing an HPI User to +** determine if the entity is currently powered on or off. If a resource +** manages multiple entities, this function will address the entity which is +** identified in the RPT entry for the resource. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** State - [out] The current power state of the resource. Valid power states +** are: +** * SAHPI_POWER_OFF: The entity's primary power is OFF, +** * SAHPI_POWER_ON: The entity's primary power is ON. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support power +** management, as indicated by SAHPI_CAPABILITY_POWER in the resource's +** RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned if the State pointer is passed in +** as NULL. +** +** Remarks: +** SAHPI_POWER_CYCLE is a pulsed power operation and is not a valid return +** for the power state. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiResourcePowerStateGet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_OUT SaHpiPowerStateT *State +); + +/******************************************************************************* +** +** Name: saHpiResourcePowerStateSet() +** +** Description: +** This function directs the resource to perform the power control action on +** the entity that it manages. If a resource manages multiple entities, this +** function addresses the entity that is identified in the RPT entry for the +** resource. +** +** Parameters: +** SessionId - [in] Identifier for a session context previously obtained using +** saHpiSessionOpen(). +** ResourceId - [in] Resource identified for this operation. +** State - [in] the requested power control action. Valid values are: +** * SAHPI_POWER_OFF: The entity's primary power is turned OFF, +** * SAHPI_POWER_ON: The entity's primary power is turned ON, +** * SAHPI_POWER_CYCLE: The entity's primary power is turned OFF, then +** turned ON. +** +** Return Value: +** SA_OK is returned on successful completion; otherwise, an error code is +** returned. +** SA_ERR_HPI_CAPABILITY is returned if the resource does not support power +** management, as indicated by SAHPI_CAPABILITY_POWER in the resource's +** RPT entry. +** SA_ERR_HPI_INVALID_PARAMS is returned when State is not one of the valid +** enumerated values for this type. +** +** Remarks: +** This function controls the hardware power on a FRU entity regardless of +** what hot-swap state the resource is in. For example, it is legal (and may +** be desirable) to cycle power on the FRU even while it is in ACTIVE state in +** order to attempt to clear a fault condition. Similarly, a resource could be +** instructed to power on a FRU even while it is in INACTIVE state, for +** example, in order to run off-line diagnostics. +** +** Not all resources supporting hot swap will necessarily support this +** function. In particular, resources that use the simplified hot swap model +** may not have the ability to control FRU power. +** +** This function may also be supported for non-FRU entities if power control +** is available for those entities. +** +*******************************************************************************/ +SaErrorT SAHPI_API saHpiResourcePowerStateSet ( + SAHPI_IN SaHpiSessionIdT SessionId, + SAHPI_IN SaHpiResourceIdT ResourceId, + SAHPI_IN SaHpiPowerStateT State +); + +#endif -- cgit v1.2.3