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