/* BEGIN_ICS_COPYRIGHT3 ****************************************
Copyright (c) 2015-2017, Intel Corporation
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of Intel Corporation nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
** END_ICS_COPYRIGHT3 ****************************************/
/* [ICS VERSION STRING: unknown] */
#ifndef __IBA_IB_MAD_H__
#define __IBA_IB_MAD_H__
#include "iba/public/datatypes.h"
/* Ths should be removed from here */
#include "iba/stl_types.h"
#include "iba/public/ibyteswap.h"
#include "iba/public/imemory.h"
#if defined (__cplusplus)
extern "C" {
#endif
#include "iba/public/ipackon.h"
/* --------------------------------------------------------------------------
* Defines
*/
// convert a 0-N bit number to a index and uint8 mask for access to
// multi-byte fields which are stored as uint8[] arrays for long bit masks
// Note for uint16, uint32 bytes, byte swapping has already been done so
// simple (1<<bit) masks can be used and these macros should NOT be used
// size is in bits (must be a multiple of 8)
#define LONG_MASK_BIT_INDEX(bit, size) ((((size)/8)-1)-(bit)/8)// byte 0=MSB,byte 7=LSB
#define LONG_MASK_BIT_MASK(bit) (1 << ((bit)%8)) // bit 0=LSbit,bit 7=MSbit
#define IB_MAD_BLOCK_SIZE 256
#if !defined(STL_MAD_BLOCK_SIZE)
#define STL_MAD_BLOCK_SIZE 2048
#endif
#define MAD_BLOCK_SIZE STL_MAD_BLOCK_SIZE
#define IB_BASE_VERSION 1
/* use ib_generalServices.h or ib_sm_types.h to get proper class version */
/*
* MANAGEMENT CLASS METHODS
* Methods define the operations which a management class supports. Each
* management class can define its own set of Methods.
* The upper bit of the Method field is designated as the response bit (R)
* and is used to distinguish three types of methods:
*/
/* Management Class Values */
#define MCLASS_SM_LID_ROUTED 0x01
#define MCLASS_SM_DIRECTED_ROUTE 0x81
#define MCLASS_RESERVED_02 0x02
#define MCLASS_SUBN_ADM 0x03 /* Subnet Administration class */
/* All Nodes hosting a */
/* Subnet Manager */
#define MCLASS_PERF 0x04 /* Performance Management class */
#define MCLASS_BM 0x05 /* Baseboard Management class */
#define MCLASS_DEV_MGT 0x06 /* Device Management class */
#define MCLASS_COMM_MGT 0x07 /* Communications Management class */
#define MCLASS_SNMP 0x08 /* SNMP Tunneling class (tunneling */
/* of the SNMP protocol through */
/* the IBA fabric) */
/*
* Vendor Defined classes 0x09-0x0F
*/
#define MCLASS_DEV_CONF_MGT 0x10 /* Device Configuration Management */
/* class (CFM/IORM) */
#define MCLASS_DTA 0x20 /* IBTA CIWG Device Test Agent */
#define MCLASS_CC 0x21 /* Congestion Control class */
#define MCLASS_VFI_PM 0x32 /* PM VFI mclass value */
/* --------------------------------------------------------------------------
* MANAGEMENT CLASS METHODS
* Methods define the operations which a management class supports. Each
* management class can define its own set of Methods.
* The upper bit of the Method field is designated as the response bit (R)
* and is used to distinguish three types of methods:
*
* a) Messages - Methods for which no response is ever generated. The R
* bit is not set and a corresponding Method with the R bit set is reserved
* and not used.
* b) Requests - Methods for which a response may be generated. The R
* bit is not set and a corresponding Method with the R bit set is defined
* and potentially used to respond.
* c) Responses - Methods generated in response to a request. The R bit
* is set and a corresponding Method with the R bit not set is defined
* and used to trigger the response.
*
* It is anticipated that many classes will use similar Methods.
* In order to provide regularity among management datagrams,
* if any of the Methods needed by a class has the same semantics
* as one of the Methods defined below it shall use that Method name
* and value.
*
* A class is not required to support all of the common methods defined here.
* However, the class shall not redefine the values assigned to these
* common methods for their class-dependent methods. All class-depen-dent
* method values shall start at 0x10 and use the R bit according to the
* semantics of types of Methods defined above.
*/
/* Common Management Methods (including R bit) Description */
/* 0x00, 0x80 Reserved. */
#define MMTHD_GET 0x01 /* Request (read) an attribute from a node */
#define MMTHD_SET 0x02 /* Request a set (write) of an attribute */
/* in a node */
#define MMTHD_SEND 0x03 /* Send a datagram. Does not require */
/* a response. */
#define MMTHD_RESERVED_04 0x04 /* Reserved. */
#define MMTHD_TRAP 0x05 /* Unsolicited datagram sent from a node */
/* indicating an event occured that may */
/* be of interest. */
/* A trap method shall always use the */
/* Notice attribute. */
#define MMTHD_REPORT 0x06 /* Forwarding an event/trap/notice to */
/* interested party. */
#define MMTHD_TRAP_REPRESS 0x07 /* Instruct a Trap sender to stop sending */
/* a repeated Trap. */
/* 0x08-0x0F - Reserved */
/* 0x10-0x7F - Class-specific methods defined by Class */
#define MMTHD_GET_RESP 0x81 /* The response from an attribute Get or */
/* Set request. */
#define MMTHD_RESERVED_82 0x82 /* Reserved. */
#define MMTHD_RESERVED_83 0x83 /* Reserved. */
#define MMTHD_RESERVED_84 0x84 /* Reserved. */
#define MMTHD_RESERVED_85 0x85 /* Reserved. */
#define MMTHD_REPORT_RESP 0x86 /* Response to a Report(). */
/* 0x87-0x8F - Reserved. */
/* 0x90-0xFF - Class-dependent methods. Usage is defined by the class. */
/* --------------------------------------------------------------------------
* STATUS FIELD
* The Status field is only valid for methods of type Response (R bit set).
* It consists of 16 bits, each bit representing a unique status indication.
* The 8 low order bits of the field are used for indications common to
* all classes.
*
* The 8 upper bits of the field can be used for class-dependent indications.
* A status field value of zero (no bit set) indicates a successful response.
* It is reserved and shall be set to 0 for methods of type Request and
* Message.
*/
/*
* MAD Status Field Bit Values
*/
#define MAD_STATUS_SUCCESS 0x0000
#define MAD_STATUS_BUSY 0x0001
#define MAD_STATUS_REDIRECT_REQD 0x0002
/*
* bits 2-4 Code for invalid field
* 0 -no invalid fields
* 1 -The class version specified is not supported.
* (IBTA 1.1 also includes unsupported Base version in this category)
* 2 -The method specified is not supported
* 3 -The method/attribute combination is not supported
* 4-6:Reserved
* 7 -One or more fields in the attribute contain an invalid value.
*
* Defines below are coded for use against AsReg16 of MAD_STATUS
*/
#define MAD_STATUS_UNSUPPORTED_CLASS_VER 0x0004
#define MAD_STATUS_UNSUPPORTED_VER MAD_STATUS_UNSUPPORTED_CLASS_VER
#define MAD_STATUS_UNSUPPORTED_METHOD 0x0008
#define MAD_STATUS_UNSUPPORTED_METHOD_ATTRIB 0x000c
/* 0x0010-0x0018 - Reserved */
#define MAD_STATUS_INVALID_ATTRIB 0x001c
/* 0x0020-0x00ff - Reserved */
/* 0x0100-0xff00 class-dependent values. */
typedef union _MAD_STATUS {
uint16 AsReg16;
struct { IB_BITFIELD5(uint16,
ClassSpecific: 8, /* Class dependent values */
Reserved1 : 3,
InvalidField: 3,
RedirectRqrd: 1, /* Redirect_required Redirection. not an error */
Busy : 1) /* Temporarily busy. MAD discarded. not an error */
} PACK_SUFFIX S;
} PACK_SUFFIX MAD_STATUS;
/* convert MAD Status to a string
* The string will only contain the message corresponding to the defined values
* to be safe, callers should also display the hex value in the event a
* reserved or class specific value is returned by the manager/agent
*/
IBA_API const char* iba_mad_status_msg(MAD_STATUS madStatus);
IBA_API const char* iba_mad_status_msg2(uint16 madStatus);
/* --------------------------------------------------------------------------
* MANAGEMENT CLASS ATTRIBUTES
* Attributes define the data which a management class manipulates. Each
* management class defines its own set of Attributes.
* Attributes are composite structures consisting of components typically
* representing hardware registers in nodes. Attributes can be read or
* written. Each Attribute is assigned a unique Attribute ID.
* Some Components within Attributes are identified as reserved. They shall
* be set to zero when building a MAD, except when building a response
* MAD where they may contain the corresponding contents of the request
* MAD. They shall be ignored in received MADs.
* An Attribute Modifier is also provided for each Attribute; however, not
* all Attributes utilize this modifier. The use of the Attribute Modifier
* is Attribute specific. When the Attribute Modifier is not used it shall
* be set to zero. It is not possible to selectively set a single Component
* within an Attribute. A Get() must be performed to obtain the whole
* attribute, the single Component must be modified in the result and a
* Set() must be performed to write the whole attribute. No atomicity is
* provided in this sequence of operations.
* Some Components within an Attribute may not be settable. In this case,
* the respective Components within the Attribute are simply ignored
* when setting.
*
* Each management class provides a section that describe its Attributes
* and the Components contained within them, along with their settability,
* and how they are mapped into the Data field of the MAD.
* A given Attribute shall have the same format for the Get(), Set()
* and Get-Resp() Methods if used with those Methods. Its format for other
* Methods may be different, in particular a given Attribute may have a
* different format for SendResp() than it has for Send().
*
* The following common Attributes are defined:
* All class-dependent attributes values shall start at 0x0010.
*/
/* Common Attributes */
#define MCLASS_ATTRIB_ID_RESERVED_0 0x0000 /* Reserved */
#define MCLASS_ATTRIB_ID_CLASS_PORT_INFO 0x0001
#define MCLASS_ATTRIB_ID_NOTICE 0x0002
#define MCLASS_ATTRIB_ID_INFORM_INFO 0x0003
/* 0x0004-0x000F - Reserved */
/* 0x0010-0x7FFF - Class-dependant values. */
/* Baseboard Management Attributes IDs */ /* Attribute Modifier values */
#define BM_ATTRIB_MOD_REQUEST 0x0000
#define BM_ATTRIB_MOD_RESPONSE 0x0001
/* --------------------------------------------------------------------------
* MANAGEMENT DATAGRAMS
* Management Datagrams (MADs) provide a set of defined packets, which
* are used by managers and agents to communicate across a fabric. There
* is a format and specified use for each MAD, which corresponds to
* predefined management classes. MADs provide a fundamental mechanism
* for in-band management.
*
* MANAGEMENT DATAGRAM FORMAT
* The MAD is an abstract definition of a base format whose data area usage
* shall be defined by a management class. The base format of the MAD to
* which all classes will conform is described in the structure MAD.
* The MAD shall have a packet payload of 256 bytes. This is to guarantee
* that MADs will not get dropped by a node that only supports the minimum
* packet size.
* Any unused portion of the 256 bytes shall be filled with zeroes when
* building a MAD, except when building a response MAD where the unused
* portion may contain the corresponding contents of the request MAD.
*/
typedef struct _MAD_COMMON {
uint8 BaseVersion; /* Version of management datagram base */
/* format.Value is set to 1 */
uint8 MgmtClass; /* Class of operation. */
uint8 ClassVersion; /* Version of MAD class-specific format. */
/* Value is set to 1 except */
/* for the Vendor class */
union {
uint8 AsReg8;
struct { IB_BITFIELD2(uint8,
R :1, /* Request/response field, */
/* conformant to base class definition */
Method :7) /* Method to perform based on */
/* the management class */
} PACK_SUFFIX s;
} mr;
union {
/* All MADs use this structure */
struct {
MAD_STATUS Status; /* Code indicating status of method */
uint16 Reserved1; /* Reserved. Shall be set to 0 */
} NS; /* Normal MAD */
/* This structure is used only for Directed Route SMP's */
struct {
struct { IB_BITFIELD2(uint16,
D :1, /* Direction bit to determine */
/* direction of packet */
Status :15)/* Code indicating status of method */
} PACK_SUFFIX s;
uint8 HopPointer; /* used to indicate the current byte */
/* of the Initial/Return Path field. */
uint8 HopCount; /* used to contain the number of valid */
/* bytes in the Initial/Return Path */
} DR; /* Directed Route only */
} u;
uint64 TransactionID; /* Transaction specific identifier */
uint16 AttributeID; /* Defines objects being operated */
/* on by a management class */
uint16 Reserved2; /* Reserved. Shall be set to 0 */
uint32 AttributeModifier; /* Provides further scope to */
/* the Attributes, usage */
/* determined by the management class */
} PACK_SUFFIX MAD_COMMON;
/*
* MAD Base Fields
*/
typedef struct _MAD
{
MAD_COMMON common;
uint8 Data[MAD_BLOCK_SIZE - sizeof(MAD_COMMON)];
} PACK_SUFFIX MAD;
/* Responses are implicitly expected for most requests
* however behaviour can be class specific.
* Note that MMTHD_TRAP_REPRESS does not have R bit set but
* is technically a response, however MMTHD_REPORT_RESP does
*
* For mads which are not a request, TransactionID is owned by client.
* For requests, the GSI will use low bits of TransactionID for client
* identification to facilitate directing response to correct client.
*/
#define MAD_IS_REQUEST(mad) \
(((mad)->common.mr.s.R == 0 \
&& (mad)->common.mr.s.Method != MMTHD_TRAP_REPRESS \
&& (mad)->common.mr.s.Method != MMTHD_SEND) \
|| (((mad)->common.MgmtClass == MCLASS_BM) && \
( (mad)->common.mr.s.Method == MMTHD_SEND && !((mad)->common.AttributeModifier & BM_ATTRIB_MOD_RESPONSE))))
/* mads for which a GET_RESP should be returned if validation fails */
#define MAD_EXPECT_GET_RESP(mad) \
((mad)->common.mr.s.R == 0 \
&& ((mad)->common.mr.s.Method == MMTHD_GET \
|| (mad)->common.mr.s.Method == MMTHD_SET))
/* could optimize and skip MMTHD_SEND test below since R=1 -> != SEND
* however we play it safe in case remote node fails to initialize
* R bit for a SEND message.
*/
#define MAD_IS_RESPONSE(mad) \
((((mad)->common.mr.s.R \
|| (mad)->common.mr.s.Method == MMTHD_TRAP_REPRESS) \
&& (mad)->common.mr.s.Method != MMTHD_SEND) \
|| (((mad)->common.MgmtClass == MCLASS_BM) && \
((mad)->common.mr.s.Method == MMTHD_SEND && ((mad)->common.AttributeModifier & BM_ATTRIB_MOD_RESPONSE))))
/* SENDs are technically a 3rd type, not necessarily a request nor response */
#define MAD_IS_SEND(mad) \
((mad)->common.mr.s.Method == MMTHD_SEND)
#define MAD_SET_VERSION_INFO(mad, base_ver, mgmt_class, class_ver) {\
(mad)->common.BaseVersion = base_ver; \
(mad)->common.MgmtClass = mgmt_class; \
(mad)->common.ClassVersion = class_ver; \
}
#define MAD_GET_VERSION_INFO(mad, base_ver, mgmt_class, class_ver) {\
(*base_ver) = (mad)->common.BaseVersion; \
(*mgmt_class) = (mad)->common.MgmtClass; \
(*class_ver) = (mad)->common.ClassVersion; \
}
#define MAD_GET_STATUS(mad, status) {\
(*status) = (mad)->common.u.NS.Status; \
}
#define MAD_SET_TRANSACTION_ID(mad, id) {\
(mad)->common.TransactionID = id; \
}
#define MAD_GET_TRANSACTION_ID(mad, id) {\
(*id) = (mad)->common.TransactionID; \
}
#define MAD_SET_ATTRIB_ID(mad, id) {\
(mad)->common.AttributeID = id; \
}
#define MAD_GET_ATTRIB_ID(mad, id) {\
(*id) = (mad)->common.AttributeID; \
}
#define MAD_SET_ATTRIB_MOD(mad, amod) {\
(mad)->common.AttributeModifier = amod; \
}
#define MAD_GET_ATTRIB_MOD(mad, amod) {\
(*amod) = (mad)->common.AttributeModifier; \
}
#define MAD_SET_METHOD_TYPE(mad, method) {\
(mad)->common.mr.s.Method = method; \
}
#define MAD_GET_METHOD_TYPE(mad, method) {\
(*method) = (mad)->common.mr.s.Method; \
}
/*
* ClassPortInfo
*/
/* CapMask common bits */
#define CLASS_PORT_CAPMASK_TRAP 0x0001 /* can generate traps */
#define CLASS_PORT_CAPMASK_NOTICE 0x0002 /* implements Get/Set Notice */
/* mask for class specific bits */
#define CLASS_PORT_CAPMASK_CLASS_SPECIFIC 0xff00
typedef struct _ClassPortInfo{
uint8 BaseVersion;
uint8 ClassVersion;
uint16 CapMask;
union {
uint32 AsReg32;
struct { IB_BITFIELD2(uint32,
CapMask2: 27,
RespTimeValue: 5)
} PACK_SUFFIX s;
} u1;
/* Define any re-direction. */
IB_GID RedirectGID;
union {
uint32 AsReg32;
struct { IB_BITFIELD3(uint32,
RedirectTClass: 8,
RedirectSL: 4,
RedirectFlowLabel:20)
} PACK_SUFFIX s;
} u2;
IB_LID RedirectLID;
uint16 Redirect_P_Key;
union {
uint32 AsReg32;
struct { IB_BITFIELD2(uint32,
Reserved2: 8,
RedirectQP: 24)
} PACK_SUFFIX s;
} u3;
uint32 Redirect_Q_Key;
/* Define any refor traps */
IB_GID TrapGID;
union {
uint32 AsReg32;
struct { IB_BITFIELD3(uint32,
TrapTClass: 8,
TrapSL: 4,
TrapFlowLabel: 20)
} PACK_SUFFIX s;
} u4;
IB_LID TrapLID;
uint16 Trap_P_Key;
union {
uint32 AsReg32;
struct { IB_BITFIELD2(uint32,
TrapHopLimit: 8,
TrapQP: 24)
} PACK_SUFFIX s;
} u5;
uint32 Trap_Q_Key;
} PACK_SUFFIX ClassPortInfo, IB_CLASS_PORT_INFO;
/* Notice */
/* Channel adapters, switches, and routers implementing Notice attributes
* shall conform to the definition specified.
*/
/*
* Node type info
*/
typedef enum _NODE_TYPE {
IBA_NODE_CHANNEL_ADAPTER = 1,
IBA_NODE_SWITCH = 2,
IBA_NODE_ROUTER = 3,
} NODE_TYPE;
/*
* Trap/Notice type
*/
typedef enum _NOTICE_TYPE {
IB_NOTICE_FATAL = 0,
IB_NOTICE_URGENT = 1,
IB_NOTICE_SECURITY = 2,
IB_NOTICE_SM = 3,
IB_NOTICE_INFO = 4,
IB_NOTICE_ALL = 0xFFFF
} IB_NOTICE_TYPE;
/*
* Notice
*/
typedef struct _NOTICE {
union {
/* Generic Notice attributes */
struct /*_GENERIC*/ {
union {
uint32 AsReg32;
struct { IB_BITFIELD3(uint32,
IsGeneric: 1, /* 1= generic */
Type : 7, /* IB_NOTICE_TYPE */
ProducerType:24) /* NODE_TYPE */
} PACK_SUFFIX s;
} u;
/* If generic, indicates a class-defined trap number. */
/* Number 0xFFFF is reserved. */
uint16 TrapNumber;
} PACK_SUFFIX Generic;
/* Vendor specific Notice attributes */
struct /*_VENDOR*/ {
union {
uint32 AsReg32;
struct { IB_BITFIELD3(uint32,
IsGeneric: 1,
Type : 7,
VendorID: 24) /* Vendor OUI */
} PACK_SUFFIX s;
} u;
/* If not generic, this is Device ID information as assigned by */
/* device manufacturer. */
uint16 DeviceID;
} PACK_SUFFIX Vendor;
} u;
/* Common Notice attributes */
IB_LID IssuerLID; /* LID of requester */
/* Toggle:
* For Notices, alternates between zero and one after each Notice is
* cleared.
* For Traps, this shall be set to 0.
*
* Count:
* For Notices, indicates the number of notices queued on this channel
* adapter, switch, or router.
* For Traps, this shall be set to all zeroes.
*/
struct { IB_BITFIELD2(uint16,
Toggle :1,
Count :15)
} PACK_SUFFIX Stats;
uint8 Data[54];
IB_GID IssuerGID;
} PACK_SUFFIX IB_NOTICE;
/*
* Structure of the IB_NOTICE Data for the following traps:
* SMA_TRAP_GID_NOW_IN_SERVICE
* SMA_TRAP_GID_OUT_OF_SERVICE
* SMA_TRAP_ADD_MULTICAST_GROUP
* SMA_TRAP_DEL_MULTICAST_GROUP
*/
typedef struct _TRAPS_64_65_66_67_DETAILS
{
uint8 Reserved[6];
IB_GID GIDAddress;
uint8 Padding[32];
} PACK_SUFFIX TRAPS_64_65_66_67_DETAILS, TRAP_64_DETAILS, TRAP_65_DETAILS, TRAP_66_DETAILS, TRAP_67_DETAILS;
/*
* InformInfo
*/
typedef struct _INFORM_INFO {
IB_GID GID; /* specifies specific GID to subscribe for. */
/* Set to zero if not desired. */
IB_LID LIDRangeBegin; /* 0xFFFF encapsulates all LIDs */
IB_LID LIDRangeEnd;
uint16 Reserved;
uint8 IsGeneric; /* 1 = forward generic traps */
/* 0 = vendor specific */
uint8 Subscribe; /* 1 = subscribe, 0 = unsubscribe */
uint16 Type; /* IB_NOTICE_TYPE */
union {
struct /*_GENERIC_II*/ {
uint16 TrapNumber;
union {
uint32 AsReg32;
struct { IB_BITFIELD3(uint32,
QPNumber:24,
Reserved:3,
RespTimeValue:5)
} PACK_SUFFIX s;
} u2;
union {
uint32 AsReg32;
struct { IB_BITFIELD2(uint32,
Reserved: 8,
ProducerType: 24) /* NODE_TYPE */
} PACK_SUFFIX s;
} u;
} PACK_SUFFIX Generic;
struct /*_VENDOR_II*/ {
uint16 DeviceID;
union {
uint32 AsReg32;
struct { IB_BITFIELD3(uint32,
QPNumber:24,
Reserved:3,
RespTimeValue:5)
} PACK_SUFFIX s;
} u2;
union {
uint32 AsReg32;
struct { IB_BITFIELD2(uint32,
Reserved: 8,
VendorID: 24) /* Vendor OUI */
} PACK_SUFFIX s;
} u;
} PACK_SUFFIX Vendor;
} u;
} PACK_SUFFIX IB_INFORM_INFO;
#include "iba/public/ipackoff.h"
/* --------------------------------------------------------------------------
* Swap between cpu and wire formats
*/
static __inline
void
BSWAP_MAD_HEADER(
MAD *Dest
)
{
#if CPU_LE
Dest->common.u.NS.Status.AsReg16 = ntoh16( Dest->common.u.NS.Status.AsReg16);
Dest->common.TransactionID = ntoh64(Dest->common.TransactionID);
Dest->common.AttributeID = ntoh16(Dest->common.AttributeID );
Dest->common.AttributeModifier = ntoh32(Dest->common.AttributeModifier);
#endif
}
static __inline
void
BSWAP_IB_CLASS_PORT_INFO(
IB_CLASS_PORT_INFO *Dest
)
{
#if CPU_LE
Dest->CapMask = ntoh16(Dest->CapMask);
Dest->u1.AsReg32 = ntoh32(Dest->u1.AsReg32);
BSWAP_IB_GID(&Dest->RedirectGID);
Dest->u2.AsReg32 = ntoh32(Dest->u2.AsReg32);
Dest->RedirectLID = ntoh16(Dest->RedirectLID);
Dest->Redirect_P_Key = ntoh16(Dest->Redirect_P_Key);
Dest->u3.AsReg32 = ntoh32(Dest->u3.AsReg32);
Dest->Redirect_Q_Key = ntoh32(Dest->Redirect_Q_Key);
BSWAP_IB_GID(&Dest->TrapGID);
Dest->u4.AsReg32 = ntoh32(Dest->u4.AsReg32);
Dest->TrapLID = ntoh16(Dest->TrapLID);
Dest->Trap_P_Key = ntoh16(Dest->Trap_P_Key);
Dest->u5.AsReg32 = ntoh32(Dest->u5.AsReg32);
Dest->Trap_Q_Key = ntoh32(Dest->Trap_Q_Key);
#endif
}
static __inline
void
BSWAP_IB_NOTICE(
IB_NOTICE *Dest
)
{
#if CPU_LE
/* Can do Generic since Vendor has same types, just different field names */
Dest->u.Generic.u.AsReg32 = ntoh32(Dest->u.Generic.u.AsReg32);
Dest->u.Generic.TrapNumber = ntoh16(Dest->u.Generic.TrapNumber);
Dest->IssuerLID = ntoh16(Dest->IssuerLID);
BSWAP_IB_GID(&Dest->IssuerGID);
#endif
}
/*
* Swaps the GIDAddress in the IB_NOTICE Data
*/
static __inline
void
BSWAP_TRAPS_64_65_66_67_DETAILS(TRAPS_64_65_66_67_DETAILS *Dest)
{
#if CPU_LE
BSWAP_IB_GID(&Dest->GIDAddress);
#endif
}
#define BSWAP_TRAP_64_DETAILS(Dest) BSWAP_TRAPS_64_65_66_67_DETAILS(Dest)
#define BSWAP_TRAP_65_DETAILS(Dest) BSWAP_TRAPS_64_65_66_67_DETAILS(Dest)
#define BSWAP_TRAP_66_DETAILS(Dest) BSWAP_TRAPS_64_65_66_67_DETAILS(Dest)
#define BSWAP_TRAP_67_DETAILS(Dest) BSWAP_TRAPS_64_65_66_67_DETAILS(Dest)
static __inline
void
BSWAP_INFORM_INFO(
IB_INFORM_INFO *Dest
)
{
#if CPU_LE
BSWAP_IB_GID(&Dest->GID);
Dest->LIDRangeBegin = ntoh16(Dest->LIDRangeBegin);
Dest->LIDRangeEnd = ntoh16(Dest->LIDRangeEnd);
Dest->Type = ntoh16(Dest->Type);
/* Can do Generic since Vendor has same types, just different field names */
Dest->u.Generic.TrapNumber = ntoh16(Dest->u.Generic.TrapNumber);
Dest->u.Generic.u2.AsReg32 = ntoh32(Dest->u.Generic.u2.AsReg32);
Dest->u.Generic.u.AsReg32 = ntoh32(Dest->u.Generic.u.AsReg32);
#endif
}
#if defined (__cplusplus)
};
#endif
#endif /* __IBA_IB_MAD_H__ */