windows-xp/Source/XPSP1/NT/drivers/published/ddk/inc/hbaapi.mof

//***************************************************************************
//
//  hbaapi.mof
// 
//  Module: WDM classes to expose HBA api data from drivers
//
//  Purpose: Contains WDM classes that specify the HBA data to be exposed 
//           via the HBA api set.
//
//  Copyright (c) 2001 Microsoft Corporation
//
//***************************************************************************

#pragma namespace("\\\\.\\root\\wmi")

//
// HBA specific classes
//
[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("This class exposes statistical information associated with "
             "a Fibre Channel port. There should be one instance of this "
             "class for each port.") : amended,
 guid("{27EFABA4-362A-4f20-920B-ED66E280FCF5}")
]
class MSFC_FibrePortHBAStatistics
{
    [key] 
    string InstanceName;
    boolean Active;

    [
     Description ("Unique identifier for the port. This idenitifer must "
                  "be unique among all ports on all adapters. The same "
                  "value for the identifier must be used for the same port "
                  "in other classes that expose port information") : amended,
     WmiRefClass("MSFC_FibrePort"),
     WmiRefProperty("UniquePortId"),
     WmiDataId(1)
    ]
    uint64 UniquePortId;                // CIM_FibrePort REF

    [HBAType("HBA_STATUS"),
     Description("HBA Status result for the query operation"),
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
     Values{
             "Operation was successful ",
             "Error ",
             "Function not supported.",
             "invalid handle ",
             "Bad argument ",
             "WWN not recognized ",
             "Index not recognized ",
             "Larger buffer required ",
             "Data is stale, HBARefreshInformation is required "
           } : amended,
     WmiDataId(2)
    ]
    uint32 HBAStatus;

    // Note 4 byte padding

    [
     WmiDataId(3)
    ]
    sint64 SecondsSinceLastReset;

    [
     WmiDataId(4)
    ]
    sint64 TxFrames;

    [
     WmiDataId(5)
    ]
    sint64 TxWords;

    [
     WmiDataId(6)
    ]
    sint64 RxFrames;

    [
     WmiDataId(7)
    ]
    sint64 RxWords;

    [
     WmiDataId(8)
    ]
    sint64 LIPCount;

    [
     WmiDataId(9)
    ]
    sint64 NOSCount;

    [
     WmiDataId(10)
    ]
    sint64 ErrorFrames;

    [
     WmiDataId(11)
    ]
    sint64 DumpedFrames;

    [
     WmiDataId(12)
    ]
    sint64 LinkFailureCount;

    // CIM_FibrePort.LossofSyncCounter
    [
     WmiDataId(13)
    ]
    sint64 LossOfSyncCount;

    // CIM_FibrePort.LossofSignalCounter
    [
     WmiDataId(14)
    ]
    sint64 LossOfSignalCount;

    [
     WmiDataId(15)
    ]
    sint64 PrimitiveSeqProtocolErrCount;

    [
     WmiDataId(16)
    ]
    sint64 InvalidTxWordCount;

    // CIM_FibrePort.CRCErrors
    [
     WmiDataId(17)
    ]
    sint64 InvalidCRCCount;

};

[WMI, 
 HBAType("HBA_PORTATTRIBUTES"),
 guid("{A76BD4E3-9961-4d9b-B6BE-86E698260F68}")
]
class MSFC_HBAPortAttributesResults
{
    [HBAType("HBA_WWN"),
     WmiDataId(1)
    ]
    uint8 NodeWWN[8];

    [HBAType("HBA_WWN"),
     WmiDataId(2)
    ]
    uint8 PortWWN[8];

    [
     WmiDataId(3)
    ]
    uint32 PortFcId;

    // CIM_FibrePort.CurrentPortType
    [HBAType("HBA_PORTTYPE"),
     Values{"Unknown", "Other", "Not present", "Fabric", "Public Loop",
            "HBA_PORTTYPE_FLPORT", "Fabric Port", "Fabric expansion port",
            "Generic Fabric Port", "Private Loop", "Point to Point"} : amended,
     ValueMap{"1", "2", "3", "5", "6", "7", "8", "9", "10", "20", "21"},
     WmiDataId(4)
    ]
    uint32 PortType;

    // CIM_LogicalDevice.Availability
    [HBAType("HBA_PORTSTATE"),
     Values{"Unknown", "Operational", "User Offline", "Bypassed", 
            "In diagnostics mode", "Link Down", "Port Error", "Loopback"
           } : amended,
     ValueMap{"1","2","3","4","5","6","7","8"},
     WmiDataId(5)
    ]
    uint32 PortState;

    // CIM_FibreChannelAdapter.SupportedCOS
    // TODO: See GS-2 spec for enumeration/ValueMap
    [HBAType("HBA_COS"),
     WmiDataId(6)
    ]
    uint32 PortSupportedClassofService;

    // CIM_FibreChannelAdapter.FC4TypesSupported
    [HBAType("HBA_FC4TYPES"),
     WmiDataId(7)
    ]
    uint8 PortSupportedFc4Types[32];

    [HBAType("HBA_FC4TYPES"),
     WmiDataId(8)
    ]
    uint8 PortActiveFc4Types[32];

    [HBAType("HBA_PORTSPEED"),
     Values{"1 GBit/sec", "2 GBit/sec", "10 GBit/sec"} : amended,
     ValueMap{"1", "2", "4"},
     WmiDataId(9)
    ]
    uint32 PortSupportedSpeed;

    // CIM_LogicalPort.Speed
    [HBAType("HBA_PORTSPEED"),
     Values{"1 GBit/sec", "2 GBit/sec", "10 GBit/sec"} : amended,
     ValueMap{"1", "2", "4"},
     WmiDataId(10)
    ]
    uint32 PortSpeed;

    [
     WmiDataId(11)
    ]
    uint32 PortMaxFrameSize;

    [HBAType("HBA_WWN"),
     WmiDataId(12)
    ]
    uint8 FabricName[8];

    [
     WmiDataId(13)
    ]
    uint32 NumberofDiscoveredPorts;

    [MaxLen(256),
     WmiDataId(14)
    ]
    string PortSymbolicName;

    [MaxLen(256),
     WmiDataId(15)
    ]
    string OSDeviceName;
};

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("This class exposes attribute information associated with "
             "a Fibre Channel port. There should be one instance of this "
             "class for each port.") : amended,
 guid("{61B397FD-F5AE-4950-9758-0EE598E3C6E6}")
]
class MSFC_FibrePortHBAAttributes
{
    [key] 
    string InstanceName;
    boolean Active;

    [
     Description ("Unique identifier for the port. This idenitifer must "
                  "be unique among all ports on all adapters. The same "
                  "value for the identifier must be used for the same port "
                  "in other classes that expose port information") : amended,
     WmiRefClass("MSFC_FibrePort"),
     WmiRefProperty("UniquePortId"),
     WmiDataId(1)
    ]
    uint64 UniquePortId;                // CIM_FibrePort REF

    [HBAType("HBA_STATUS"),
     Description("HBA Status result for the query operation"),
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
     Values{
             "Operation was successful ",
             "Error ",
             "Function not supported.",
             "invalid handle ",
             "Bad argument ",
             "WWN not recognized ",
             "Index not recognized ",
             "Larger buffer required ",
             "Data is stale, HBARefreshInformation is required "
           } : amended,
     WmiDataId(2)
    ]
    uint32 HBAStatus;

    [HBAType("HBA_PORTATTRIBUTES"),
     WmiDataId(3)
    ]
    MSFC_HBAPortAttributesResults Attributes;
};

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("This class exposes operations that can be performed on "
             "a Fibre Channel port. There should be one instance of this "
             "class for each port.") : amended,
 guid("{E693553E-EDF6-4d57-BF08-EFCAAE1A2E1C}")
]
class MSFC_FibrePortHBAMethods
{
    [key] 
    string InstanceName;
    boolean Active;

    [
     Implemented,
     WmiMethodId(1)
    ]
    void ResetStatistics();
};


[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("This class exposes attribute information associated with a "
             "fibre channel adapter. There should be one instance of this "
             "class for each adapter") : amended,
 guid("{F8F3EA26-AB2C-4593-8B84-C56428E6BEDB}")
]
class MSFC_FCAdapterHBAAttributes
{
    [key] 
    string InstanceName;
    boolean Active;

    [
     Description ("Unique identifier for the adapter. This idenitifer must "
                  "be unique among all adapters. The same "
                  "value for the identifier must be used for the same adapter "
                  "in other classes that expose adapter information") : amended,

     WmiRefClass("MSFC_FibreChannelAdapter"),
     WmiRefProperty("UniqueAdapterId"),     
     WmiDataId(1)
    ]
    uint64 UniqueAdapterId;             // CIM_FibreChannelAdapter REF

    [HBAType("HBA_STATUS"),
     Description("HBA Status result for the query operation"),
     ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
     Values{
             "Operation was successful ",
             "Error ",
             "Function not supported.",
             "invalid handle ",
             "Bad argument ",
             "WWN not recognized ",
             "Index not recognized ",
             "Larger buffer required ",
             "Data is stale, HBARefreshInformation is required "
           } : amended,
     WmiDataId(2)
    ]
    uint32 HBAStatus;

    // CIM_NetworkAdapter.PermamentAddress
    [HBAType("HBA_WWN"),
     WmiDataId(3)
    ]
    uint8 NodeWWN[8];

    [WmiDataId(4)
    ]
    uint32 VendorSpecificID;

    [WmiDataId(5)
    ]
    uint32 NumberOfPorts;

    // CIM_PhysicalElement
    [MaxLen(64),
     WmiDataId(6)
    ]
    string Manufacturer;

    // CIM_PhysicalElement
    [MaxLen(64),
     WmiDataId(7)
    ]
    string SerialNumber; 

    // CIM_PhysicalElement
    [MaxLen(256),
     WmiDataId(8)
    ]
    string Model; 

    [MaxLen(256),
     WmiDataId(9)
    ]
    string ModelDescription; 

    [MaxLen(256),
     WmiDataId(10)
    ]
    string NodeSymbolicName; 

    // CIM_PhysicalElement
    [MaxLen(256),
     WmiDataId(11)
    ]
    string HardwareVersion; 

    [MaxLen(256),
     WmiDataId(12)
    ]
    string DriverVersion; 

    [MaxLen(256),
     WmiDataId(13)
    ]
    string OptionROMVersion; 

    [MaxLen(256),
     WmiDataId(14)
    ]
    string FirmwareVersion; 

    [MaxLen(256),
     WmiDataId(15)
    ]
    string DriverName; 
};



[WMI, 
 Description("This class exposes FC3 Management information associated with "
             "a fibre channel adapter. There should be one instance of this "
             "class for each adapter") : amended,
 guid("{5966A24F-6AA5-418e-B75C-2F214DFB4B18}")
]
class HBAFC3MgmtInfo
{
    [
     Description ("Unique identifier for the adapter. This idenitifer must "
                  "be unique among all adapters. The same "
                  "value for the identifier must be used for the same adapter "
                  "in other classes that expose adapter information") : amended,

     WmiRefClass("MSFC_FibreChannelAdapter"),
     WmiRefProperty("UniqueAdapterId"),     
     WmiDataId(1)
    ]
    uint64 UniqueAdapterId;             // CIM_FibreChannelAdapter REF
    
    [HBAType("HBA_WWN"),
     WmiDataId(2)
    ]
    uint8 wwn[8];

    [
     WmiDataId(3)
    ]
    uint32 unittype;

    [
     WmiDataId(4)
    ]
    uint32 PortId;

    [
     WmiDataId(5)
    ]
    uint32 NumberOfAttachedNodes;

    [
     WmiDataId(6)
    ]
    uint16 IPVersion;

    [
     WmiDataId(7)
    ]
    uint16 UDPPort;

    [
     WmiDataId(8)
    ]
    uint8 IPAddress[16];

    [
     WmiDataId(9)
    ]
    uint16 reserved;

    [
     WmiDataId(10)
    ]
    uint16 TopologyDiscoveryFlags;
};


[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("This class exposes port discovery operations that can be by a "
             "fibre channel adapter. There should be one instance of this "
             "class for each adapter") : amended,
 guid("{DF87D4ED-4612-4d12-85FB-83574EC34B7C}")
]
class MSFC_HBAPortMethods
{
    [key] 
    string InstanceName;
    boolean Active;

    [
     Implemented,
     WmiMethodId(1)
    ]
    void GetDiscoveredPortAttributes(
            [in
             ] uint32 PortIndex,

             [in] uint32 DiscoveredPortIndex,

             [out,
              HBAType("HBA_STATUS"),
              Description("HBA Status result for the operation"),
              ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
              Values{
                     "Operation was successful ",
                     "Error ",
                     "Function not supported.",
                     "invalid handle ",
                     "Bad argument ",
                     "WWN not recognized ",
                     "Index not recognized ",
                     "Larger buffer required ",
                     "Data is stale, HBARefreshInformation is required "
                   } : amended
             ] uint32 HBAStatus,

             [out,
              HBAType("HBA_PORTATTRIBUTES")
             ] MSFC_HBAPortAttributesResults PortAttributes);

    [
     Implemented,
     WmiMethodId(2)
    ]
    void GetPortAttributesByWWN(
                [in,
                 HBAType("HBA_WWN")] uint8 wwn[8],

                [out,
                 HBAType("HBA_STATUS"),
                 Description("HBA Status result for the operation"),
                 ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
                 Values{
                     "Operation was successful ",
                     "Error ",
                     "Function not supported.",
                     "invalid handle ",
                     "Bad argument ",
                     "WWN not recognized ",
                     "Index not recognized ",
                     "Larger buffer required ",
                     "Data is stale, HBARefreshInformation is required "
                   } : amended
                ] uint32 HBAStatus,

                [out,
                 HBAType("HBA_PORTATTRIBUTES")
                 ] MSFC_HBAPortAttributesResults PortAttributes);
    
    [
     Implemented,
     WmiMethodId(3)
    ]
    void RefreshInformation();    
};

[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("This class exposes FC3 management operations that can be done by a "
             "fibre channel adapter. There should be one instance of this "
             "class for each adapter") : amended,
 guid("{5F339B02-881B-454c-B6A0-D73449A66F0C}")
]
class MSFC_HBAFc3MgmtMethods
{
    [key] 
    string InstanceName;
    boolean Active;

    [
     Implemented,
     WmiMethodId(1)
    ]
    void SendCTPassThru(
              [in] uint32 RequestBufferCount,
              [in,
               WmiSizeIs("RequestBufferCount")
              ] uint8 RequestBuffer[],                

              [out,
               HBAType("HBA_STATUS"),
               Description("HBA Status result for the operation"),
               ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
               Values{
                     "Operation was successful ",
                     "Error ",
                     "Function not supported.",
                     "invalid handle ",
                     "Bad argument ",
                     "WWN not recognized ",
                     "Index not recognized ",
                     "Larger buffer required ",
                     "Data is stale, HBARefreshInformation is required "
                   } : amended
              ] uint32 HBAStatus,

              [out] uint32 ResponseBufferCount,

              [out,
               WmiSizeIs("ResponseBufferCount")
              ]
              uint8 ResponseBuffer[]);



    [
     Implemented,
     WmiMethodId(2)
    ]
    void SendRNID(
              [in,
               HBAType("HBA_WWN")
              ] uint8 wwn[8],

              [in,
               HBAType("HBA_WWNTYPE"),
               Values{"NODE_WWN", "PORT_WWN"},
               ValueMap{"0", "1"}
              ] uint32 wwntype,

              [out,
               HBAType("HBA_STATUS"),
               Description("HBA Status result for the operation"),
               ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
               Values{
                     "Operation was successful ",
                     "Error ",
                     "Function not supported.",
                     "invalid handle ",
                     "Bad argument ",
                     "WWN not recognized ",
                     "Index not recognized ",
                     "Larger buffer required ",
                     "Data is stale, HBARefreshInformation is required "
                   } : amended
              ] uint32 HBAStatus,

              [out] uint32 ResponseBufferCount,

              [out,
               WmiSizeIs("ResponseBufferCount")
              ] uint8 ResponseBuffer[]);


    [
     Implemented,
     WmiMethodId(3)
    ]
    void GetFC3MgmtInfo(
              [out,
               HBAType("HBA_STATUS"),
               Description("HBA Status result for the operation"),
               ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
               Values{
                     "Operation was successful ",
                     "Error ",
                     "Function not supported.",
                     "invalid handle ",
                     "Bad argument ",
                     "WWN not recognized ",
                     "Index not recognized ",
                     "Larger buffer required ",
                     "Data is stale, HBARefreshInformation is required "
                   } : amended
              ] uint32 HBAStatus,

              [out] HBAFC3MgmtInfo MgmtInfo);

    [
     Implemented,
     WmiMethodId(4)
    ]
    void SetFC3MgmtInfo(
              [out,
               HBAType("HBA_STATUS"),
               Description("HBA Status result for the operation"),
               ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
               Values{
                     "Operation was successful ",
                     "Error ",
                     "Function not supported.",
                     "invalid handle ",
                     "Bad argument ",
                     "WWN not recognized ",
                     "Index not recognized ",
                     "Larger buffer required ",
                     "Data is stale, HBARefreshInformation is required "
                   } : amended
              ] uint32 HBAStatus,

              [in] HBAFC3MgmtInfo MgmtInfo);


};

[HBAType("HBA_SCSIID"),
 WMI,
 guid("{A76F5058-B1F0-4622-9E88-5CC41E34454A}")
]
class HBAScsiID
{
    [MaxLen(256),
     WmiDataId(1)
    ]
    string OSDeviceName;

    [WmiDataId(2)
    ]
    uint32 ScsiBusNumber;

    [WmiDataId(3)
    ]
    uint32 ScsiTargetNumber;

    [WmiDataId(4)
    ]
    uint32 ScsiOSLun;
};

[HBAType("HBA_FCPID"),
 WMI,
 guid("{FF02BC96-7FB0-4bac-8F97-C71E495FA698}")
]
class HBAFCPID
{
    [
     WmiDataId(1)
    ]
    uint32 Fcid;

    [HBAType("HBA_WWN"),
     WmiDataId(2)
    ]
    uint8 NodeWWN[8];

    [HBAType("HBA_WWN"),
     WmiDataId(3)
    ]
    uint8 PortWWN[8];

    [
     WmiDataId(4)
    ]
    uint64 FcpLun;
};

[HBAType("HBA_FCPSCSIENTRY"),
 WMI,
 guid("{77CA1248-1505-4221-8EB6-BBB6EC771A87}")
]
class HBAFCPScsiEntry
{
    [
     HBAType("HBA_SCSIID"),
     WmiDataId(1)
    ]
    HBAScsiID ScsiId;
    [
     HBAType("HBA_FCPID"),
     WmiDataId(2)
    ]
    HBAFCPID FCPId;
};

[HBAType("HBA_FCPBINDINGENTRY"),
 WMI,
 guid("{FCEFF8B7-9D6B-4115-8422-05992451A629}")
]
class HBAFCPBindingEntry
{
    [HBAType("HBA_FCPBINDINGTYPE"),
     Values{"TO_D_ID", "TO_WWN"},
     ValueMap{"0", "1"},
     WmiDataId(1)
    ]
    uint32 Type;

    [HBAType("HBA_FCPSCSIENTRY"),
     WmiDataId(2)
    ]
    HBAScsiID ScsiId;

    [HBAType("HBA_FCID"),
     WmiDataId(3)
    ]
    HBAFCPID FCPId;
};



[WMI, 
 Dynamic,
 Provider("WmiProv"),
 Description("This class exposes operations associated with FCP "
             "on a Fibre Channel adapter. There should be one instance of this "
             "class for each adapter.") : amended,
 guid("{7A1FC391-5B23-4c19-B0EB-B1AEF59050C3}")
]
class MSFC_HBAFCPInfo
{
    [key] 
    string InstanceName;
    boolean Active;

    [
     Implemented,
     WmiMethodId(1)
    ]
    void GetFcpTargetMapping(
              [out,
               HBAType("HBA_STATUS"),
               Description("HBA Status result for the operation"),
               ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
               Values{
                     "Operation was successful ",
                     "Error ",
                     "Function not supported.",
                     "invalid handle ",
                     "Bad argument ",
                     "WWN not recognized ",
                     "Index not recognized ",
                     "Larger buffer required ",
                     "Data is stale, HBARefreshInformation is required "
                   } : amended
              ] uint32 HBAStatus,


              [out] uint32 EntryCount,

              [out,
               WmiSizeIs("EntryCount")] HBAFCPScsiEntry Entry[]);

    [
     Implemented,
     WmiMethodId(2)
    ]
    void GetFcpPersistentBinding(
              [out,
               HBAType("HBA_STATUS"),
               Description("HBA Status result for the operation"),
               ValueMap{"0", "1", "2", "3", "4", "5", "6", "7", "8"},
               Values{
                     "Operation was successful ",
                     "Error ",
                     "Function not supported.",
                     "invalid handle ",
                     "Bad argument ",
                     "WWN not recognized ",
                     "Index not recognized ",
                     "Larger buffer required ",
                     "Data is stale, HBARefreshInformation is required "
                   } : amended
              ] uint32 HBAStatus,

              [out] uint32 EntryCount,
              [out,
               WmiSizeIs("EntryCount")
              ] HBAFCPBindingEntry Entry[]);
};