ulp/libibverbs/include/infiniband/verbs.h

   1 /*\r
   2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.\r
   3  * Copyright (c) 2004, 2008 Intel Corporation.  All rights reserved.\r
   4  * Copyright (c) 2005, 2006, 2007 Cisco Systems, Inc.  All rights reserved.\r
   5  * Copyright (c) 2005 PathScale, Inc.  All rights reserved.\r
   6  *\r
   7  * This software is available to you under the OpenFabrics.org BSD license\r
   8  * below:\r
   9  *\r
  10  *     Redistribution and use in source and binary forms, with or\r
  11  *     without modification, are permitted provided that the following\r
  12  *     conditions are met:\r
  13  *\r
  14  *      - Redistributions of source code must retain the above\r
  15  *        copyright notice, this list of conditions and the following\r
  16  *        disclaimer.\r
  17  *\r
  18  *      - Redistributions in binary form must reproduce the above\r
  19  *        copyright notice, this list of conditions and the following\r
  20  *        disclaimer in the documentation and/or other materials\r
  21  *        provided with the distribution.\r
  22  *\r
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
  30  * SOFTWARE.\r
  31  */\r
  32 \r
  33 #pragma once\r
  34 \r
  35 #ifndef INFINIBAND_VERBS_H\r
  36 #define INFINIBAND_VERBS_H\r
  37 \r
  38 #include <windows.h>\r
  39 #include <rdma\winverbs.h>\r
  40 #include <errno.h>\r
  41 #include <comp_channel.h>\r
  42 \r
  43 #ifdef __cplusplus\r
  44 extern "C" {\r
  45 #endif\r
  46 \r
  47 /*\r
  48  * Interfaces based on libibverbs 1.1.2.\r
  49  */\r
  50 \r
  51 typedef unsigned __int8         uint8_t;\r
  52 typedef unsigned __int16        uint16_t;\r
  53 typedef unsigned __int32        uint32_t;\r
  54 typedef unsigned __int64        uint64_t;\r
  55 \r
  56 #define EOVERFLOW               WV_BUFFER_OVERFLOW\r
  57 #define EISCONN                 WV_CONNECTION_ACTIVE\r
  58 #define ECONNREFUSED    WV_CONNECTION_REFUSED\r
  59 #define ETIMEDOUT               WV_TIMEOUT\r
  60 #define ENETUNREACH             WV_HOST_UNREACHABLE\r
  61 #define EADDRINUSE              WV_ADDRESS_ALREADY_EXISTS\r
  62 #define EALREADY                WV_IO_PENDING\r
  63 #define EAFNOSUPPORT    WV_INVALID_ADDRESS\r
  64 #define EWOULDBLOCK             WV_DEVICE_BUSY\r
  65 \r
  66 #define ECONNRESET              WSAECONNRESET\r
  67 \r
  68 union ibv_gid\r
  69 {\r
  70         uint8_t                 raw[16];\r
  71         struct\r
  72         {\r
  73                 uint64_t        subnet_prefix;\r
  74                 uint64_t        interface_id;\r
  75 \r
  76         }       global;\r
  77 };\r
  78 \r
  79 enum ibv_node_type\r
  80 {\r
  81         IBV_NODE_UNKNOWN        = -1,\r
  82         IBV_NODE_CA             = 1,\r
  83         IBV_NODE_SWITCH,\r
  84         IBV_NODE_ROUTER,\r
  85         IBV_NODE_RNIC\r
  86 };\r
  87 \r
  88 enum ibv_transport_type\r
  89 {\r
  90         IBV_TRANSPORT_UNKNOWN   = WvDeviceUnknown,\r
  91         IBV_TRANSPORT_IB                = WvDeviceInfiniband,\r
  92         IBV_TRANSPORT_IWARP             = WvDeviceIwarp\r
  93 };\r
  94 \r
  95 enum ibv_device_cap_flags\r
  96 {\r
  97         IBV_DEVICE_RESIZE_MAX_WR                = WV_DEVICE_RESIZE_MAX_WR,\r
  98         IBV_DEVICE_BAD_PKEY_CNTR                = WV_DEVICE_BAD_PKEY_COUNTER,\r
  99         IBV_DEVICE_BAD_QKEY_CNTR                = WV_DEVICE_BAD_QKEY_COUNTER,\r
 100         IBV_DEVICE_RAW_MULTI                    = 0,\r
 101         IBV_DEVICE_AUTO_PATH_MIG                = WV_DEVICE_PATH_MIGRATION,\r
 102         IBV_DEVICE_CHANGE_PHY_PORT              = WV_DEVICE_CHANGE_PHYSICAL_PORT,\r
 103         IBV_DEVICE_UD_AV_PORT_ENFORCE   = WV_DEVICE_AH_PORT_CHECKING,\r
 104         IBV_DEVICE_CURR_QP_STATE_MOD    = WV_DEVICE_QP_STATE_MODIFIER,\r
 105         IBV_DEVICE_SHUTDOWN_PORT                = WV_DEVICE_SHUTDOWN_PORT,\r
 106         IBV_DEVICE_INIT_TYPE                    = WV_DEVICE_INIT_TYPE,\r
 107         IBV_DEVICE_PORT_ACTIVE_EVENT    = WV_DEVICE_PORT_ACTIVE_EVENT,\r
 108         IBV_DEVICE_SYS_IMAGE_GUID               = WV_DEVICE_SYSTEM_IMAGE_GUID,\r
 109         IBV_DEVICE_RC_RNR_NAK_GEN               = WV_DEVICE_RC_RNR_NAK_GENERATION,\r
 110         IBV_DEVICE_SRQ_RESIZE                   = WV_DEVICE_SRQ_RESIZE,\r
 111         IBV_DEVICE_N_NOTIFY_CQ                  = WV_DEVICE_BATCH_NOTIFY_CQ\r
 112 };\r
 113 \r
 114 enum ibv_atomic_cap\r
 115 {\r
 116         IBV_ATOMIC_NONE = WvAtomicNone,\r
 117         IBV_ATOMIC_HCA  = WvAtomicDevice,\r
 118         IBV_ATOMIC_GLOB = WvAtomicNode\r
 119 };\r
 120 \r
 121 struct ibv_device_attr\r
 122 {\r
 123         char                    fw_ver[64];\r
 124         uint64_t                node_guid;\r
 125         uint64_t                sys_image_guid;\r
 126         uint64_t                max_mr_size;\r
 127         uint64_t                page_size_cap;\r
 128         uint32_t                vendor_id;\r
 129         uint32_t                vendor_part_id;\r
 130         uint32_t                hw_ver;\r
 131         int                             max_qp;\r
 132         int                             max_qp_wr;\r
 133         int                             device_cap_flags;\r
 134         int                             max_sge;\r
 135         int                             max_sge_rd;\r
 136         int                             max_cq;\r
 137         int                             max_cqe;\r
 138         int                             max_mr;\r
 139         int                             max_pd;\r
 140         int                             max_qp_rd_atom;\r
 141         int                             max_ee_rd_atom;\r
 142         int                             max_res_rd_atom;\r
 143         int                             max_qp_init_rd_atom;\r
 144         int                             max_ee_init_rd_atom;\r
 145         enum ibv_atomic_cap     atomic_cap;\r
 146         int                             max_ee;\r
 147         int                             max_rdd;\r
 148         int                             max_mw;\r
 149         int                             max_raw_ipv6_qp;\r
 150         int                             max_raw_ethy_qp;\r
 151         int                             max_mcast_grp;\r
 152         int                             max_mcast_qp_attach;\r
 153         int                             max_total_mcast_qp_attach;\r
 154         int                             max_ah;\r
 155         int                             max_fmr;\r
 156         int                             max_map_per_fmr;\r
 157         int                             max_srq;\r
 158         int                             max_srq_wr;\r
 159         int                             max_srq_sge;\r
 160         uint16_t                max_pkeys;\r
 161         uint8_t                 local_ca_ack_delay;\r
 162         uint8_t                 phys_port_cnt;\r
 163 };\r
 164 \r
 165 enum ibv_mtu\r
 166 {\r
 167         IBV_MTU_256  = 1,\r
 168         IBV_MTU_512  = 2,\r
 169         IBV_MTU_1024 = 3,\r
 170         IBV_MTU_2048 = 4,\r
 171         IBV_MTU_4096 = 5\r
 172 };\r
 173 \r
 174 enum ibv_port_state\r
 175 {\r
 176         IBV_PORT_NOP                    = WvPortNop,\r
 177         IBV_PORT_DOWN                   = WvPortDown,\r
 178         IBV_PORT_INIT                   = WvPortInit,\r
 179         IBV_PORT_ARMED                  = WvPortArmed,\r
 180         IBV_PORT_ACTIVE                 = WvPortActive,\r
 181         IBV_PORT_ACTIVE_DEFER   = WvPortActiveDefer\r
 182 };\r
 183 \r
 184 struct ibv_port_attr\r
 185 {\r
 186         enum ibv_port_state     state;\r
 187         enum ibv_mtu            max_mtu;\r
 188         enum ibv_mtu            active_mtu;\r
 189         int                                     gid_tbl_len;\r
 190         uint32_t                        port_cap_flags;\r
 191         uint32_t                        max_msg_sz;\r
 192         uint32_t                        bad_pkey_cntr;\r
 193         uint32_t                        qkey_viol_cntr;\r
 194         uint16_t                        pkey_tbl_len;\r
 195         uint16_t                        lid;\r
 196         uint16_t                        sm_lid;\r
 197         uint8_t                         lmc;\r
 198         uint8_t                         max_vl_num;\r
 199         uint8_t                         sm_sl;\r
 200         uint8_t                         subnet_timeout;\r
 201         uint8_t                         init_type_reply;\r
 202         uint8_t                         active_width;\r
 203         uint8_t                         active_speed;\r
 204         uint8_t                         phys_state;\r
 205 };\r
 206 \r
 207 // Only device/port level events are currently supported.\r
 208 enum ibv_event_type\r
 209 {\r
 210         IBV_EVENT_CQ_ERR,\r
 211         IBV_EVENT_QP_FATAL,\r
 212         IBV_EVENT_QP_REQ_ERR,\r
 213         IBV_EVENT_QP_ACCESS_ERR,\r
 214         IBV_EVENT_COMM_EST,\r
 215         IBV_EVENT_SQ_DRAINED,\r
 216         IBV_EVENT_PATH_MIG,\r
 217         IBV_EVENT_PATH_MIG_ERR,\r
 218         IBV_EVENT_DEVICE_FATAL,\r
 219         IBV_EVENT_PORT_ACTIVE,\r
 220         IBV_EVENT_PORT_ERR,\r
 221         IBV_EVENT_LID_CHANGE,\r
 222         IBV_EVENT_PKEY_CHANGE,\r
 223         IBV_EVENT_SM_CHANGE,\r
 224         IBV_EVENT_SRQ_ERR,\r
 225         IBV_EVENT_SRQ_LIMIT_REACHED,\r
 226         IBV_EVENT_QP_LAST_WQE_REACHED,\r
 227         IBV_EVENT_CLIENT_REREGISTER\r
 228 };\r
 229 \r
 230 struct ibv_async_event\r
 231 {\r
 232         union\r
 233         {\r
 234                 struct ibv_cq  *cq;\r
 235                 struct ibv_qp  *qp;\r
 236                 struct ibv_srq *srq;\r
 237                 int                             port_num;\r
 238 \r
 239         }       element;\r
 240         enum ibv_event_type     event_type;\r
 241 };\r
 242 \r
 243 enum ibv_wc_status\r
 244 {\r
 245         IBV_WC_SUCCESS,\r
 246         IBV_WC_LOC_LEN_ERR,\r
 247         IBV_WC_LOC_QP_OP_ERR,\r
 248         IBV_WC_LOC_PROT_ERR,\r
 249         IBV_WC_WR_FLUSH_ERR,\r
 250         IBV_WC_MW_BIND_ERR,\r
 251         IBV_WC_REM_ACCESS_ERR,\r
 252         IBV_WC_REM_OP_ERR,\r
 253         IBV_WC_RNR_RETRY_EXC_ERR,\r
 254         IBV_WC_RESP_TIMEOUT_ERR,\r
 255         IBV_WC_REM_INV_REQ_ERR,\r
 256         IBV_WC_BAD_RESP_ERR,\r
 257         IBV_WC_LOC_ACCESS_ERR,\r
 258         IBV_WC_GENERAL_ERR,\r
 259         IBV_WC_FATAL_ERR,\r
 260         IBV_WC_RETRY_EXC_ERR,\r
 261         IBV_WC_REM_ABORT_ERR,\r
 262         IBV_WC_LOC_EEC_OP_ERR,\r
 263         IBV_WC_LOC_RDD_VIOL_ERR,\r
 264         IBV_WC_REM_INV_RD_REQ_ERR,\r
 265         IBV_WC_INV_EECN_ERR,\r
 266         IBV_WC_INV_EEC_STATE_ERR\r
 267 };\r
 268 \r
 269 __declspec(dllexport)\r
 270 const char *ibv_wc_status_str(enum ibv_wc_status status);\r
 271 \r
 272 enum ibv_wc_opcode\r
 273 {\r
 274         IBV_WC_SEND                                     = WvSend,\r
 275         IBV_WC_RDMA_WRITE                       = WvRdmaWrite,\r
 276         IBV_WC_RDMA_READ                        = WvRdmaRead,\r
 277         IBV_WC_COMP_SWAP                        = WvCompareExchange,\r
 278         IBV_WC_FETCH_ADD                        = WvFetchAdd,\r
 279         IBV_WC_BIND_MW                          = WvBindWindow,\r
 280 /*\r
 281  * Set value of IBV_WC_RECV so consumers can test if a completion is a\r
 282  * receive by testing (opcode & IBV_WC_RECV).\r
 283  */\r
 284         IBV_WC_RECV                                     = WvReceive,\r
 285         IBV_WC_RECV_RDMA_WITH_IMM       = WvReceiveRdmaWrite\r
 286 };\r
 287 \r
 288 enum ibv_wc_flags\r
 289 {\r
 290         IBV_WC_GRH                      = WV_WC_GRH_VALID,\r
 291         IBV_WC_WITH_IMM         = WV_WC_IMMEDIATE\r
 292 };\r
 293 \r
 294 struct ibv_wc\r
 295 {\r
 296         union\r
 297         {\r
 298                 uint32_t                        qp_num;\r
 299                 void*                           reserved;\r
 300         };\r
 301         uint64_t                        wr_id;\r
 302         enum ibv_wc_opcode      opcode;\r
 303         uint32_t                        byte_len;\r
 304         uint32_t                        vendor_err2;\r
 305         uint32_t                        vendor_err;\r
 306         enum ibv_wc_status      status;\r
 307 \r
 308         enum ibv_wc_flags       wc_flags;\r
 309         uint32_t                        imm_data;       /* in network byte order */\r
 310         uint32_t                        src_qp;\r
 311         uint16_t                        pkey_index;\r
 312         uint16_t                        slid;\r
 313         uint8_t                         sl;\r
 314         uint8_t                         dlid_path_bits;\r
 315 };\r
 316 \r
 317 enum ibv_access_flags\r
 318 {\r
 319         IBV_ACCESS_LOCAL_WRITE          = WV_ACCESS_LOCAL_WRITE,\r
 320         IBV_ACCESS_REMOTE_WRITE         = WV_ACCESS_REMOTE_WRITE,\r
 321         IBV_ACCESS_REMOTE_READ          = WV_ACCESS_REMOTE_READ,\r
 322         IBV_ACCESS_REMOTE_ATOMIC        = WV_ACCESS_REMOTE_ATOMIC,\r
 323         IBV_ACCESS_MW_BIND                      = WV_ACCESS_MW_BIND\r
 324 };\r
 325 \r
 326 struct ibv_pd\r
 327 {\r
 328         struct ibv_context      *context;\r
 329         IWVProtectionDomain     *handle;\r
 330 };\r
 331 \r
 332 /* Reregister MR not supported by WinVerbs */\r
 333 enum ibv_rereg_mr_flags\r
 334 {\r
 335         IBV_REREG_MR_CHANGE_TRANSLATION = (1 << 0),\r
 336         IBV_REREG_MR_CHANGE_PD                  = (1 << 1),\r
 337         IBV_REREG_MR_CHANGE_ACCESS              = (1 << 2),\r
 338         IBV_REREG_MR_KEEP_VALID                 = (1 << 3)\r
 339 };\r
 340 \r
 341 struct ibv_mr\r
 342 {\r
 343         struct ibv_context      *context;\r
 344         struct ibv_pd           *pd;\r
 345         void                            *addr;\r
 346         size_t                          length;\r
 347         uint32_t                        lkey;\r
 348         uint32_t                        rkey;\r
 349 };\r
 350 \r
 351 /* Memory windows not implemented by WinVerbs */\r
 352 enum ibv_mw_type\r
 353 {\r
 354         IBV_MW_TYPE_1           = 1,\r
 355         IBV_MW_TYPE_2           = 2\r
 356 };\r
 357 \r
 358 /* Memory windows not implemented by WinVerbs */\r
 359 struct ibv_mw\r
 360 {\r
 361         struct ibv_context      *context;\r
 362         struct ibv_pd           *pd;\r
 363         uint32_t                        rkey;\r
 364 };\r
 365 \r
 366 struct ibv_global_route\r
 367 {\r
 368         union ibv_gid           dgid;\r
 369         uint32_t                        flow_label;\r
 370         uint8_t                         sgid_index;\r
 371         uint8_t                         hop_limit;\r
 372         uint8_t                         traffic_class;\r
 373 };\r
 374 \r
 375 struct ibv_grh\r
 376 {\r
 377         uint32_t                        version_tclass_flow;\r
 378         uint16_t                        paylen;\r
 379         uint8_t                         next_hdr;\r
 380         uint8_t                         hop_limit;\r
 381         union ibv_gid           sgid;\r
 382         union ibv_gid           dgid;\r
 383 };\r
 384 \r
 385 enum ibv_rate\r
 386 {\r
 387         IBV_RATE_MAX      = 0,\r
 388         IBV_RATE_2_5_GBPS = 2,\r
 389         IBV_RATE_5_GBPS   = 5,\r
 390         IBV_RATE_10_GBPS  = 3,\r
 391         IBV_RATE_20_GBPS  = 6,\r
 392         IBV_RATE_30_GBPS  = 4,\r
 393         IBV_RATE_40_GBPS  = 7,\r
 394         IBV_RATE_60_GBPS  = 8,\r
 395         IBV_RATE_80_GBPS  = 9,\r
 396         IBV_RATE_120_GBPS = 10\r
 397 };\r
 398 \r
 399 /**\r
 400  * ibv_rate_to_mult - Convert the IB rate enum to a multiple of the\r
 401  * base rate of 2.5 Gbit/sec.  For example, IBV_RATE_5_GBPS will be\r
 402  * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.\r
 403  * @rate: rate to convert.\r
 404  */\r
 405 __declspec(dllexport)\r
 406 int ibv_rate_to_mult(enum ibv_rate rate);\r
 407 \r
 408 /**\r
 409  * mult_to_ibv_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate enum.\r
 410  * @mult: multiple to convert.\r
 411  */\r
 412 __declspec(dllexport)\r
 413 enum ibv_rate mult_to_ibv_rate(int mult);\r
 414 \r
 415 struct ibv_ah_attr\r
 416 {\r
 417         struct ibv_global_route grh;\r
 418         uint16_t                                dlid;\r
 419         uint8_t                                 sl;\r
 420         uint8_t                                 src_path_bits;\r
 421         uint8_t                                 static_rate;\r
 422         uint8_t                                 is_global;\r
 423         uint8_t                                 port_num;\r
 424 };\r
 425 \r
 426 enum ibv_srq_attr_mask\r
 427 {\r
 428         IBV_SRQ_MAX_WR  = 1 << 0,\r
 429         IBV_SRQ_LIMIT   = 1 << 1\r
 430 };\r
 431 \r
 432 struct ibv_srq_attr\r
 433 {\r
 434         uint32_t                max_wr;\r
 435         uint32_t                max_sge;\r
 436         uint32_t                srq_limit;\r
 437 };\r
 438 \r
 439 struct ibv_srq_init_attr\r
 440 {\r
 441         void                            *srq_context;\r
 442         struct ibv_srq_attr     attr;\r
 443 };\r
 444 \r
 445 enum ibv_qp_type\r
 446 {\r
 447         IBV_QPT_RC = WvQpTypeRc,\r
 448         IBV_QPT_UC = WvQpTypeUc,\r
 449         IBV_QPT_UD = WvQpTypeUd\r
 450 };\r
 451 \r
 452 struct ibv_qp_cap\r
 453 {\r
 454         uint32_t                max_send_wr;\r
 455         uint32_t                max_recv_wr;\r
 456         uint32_t                max_send_sge;\r
 457         uint32_t                max_recv_sge;\r
 458         uint32_t                max_inline_data;\r
 459 };\r
 460 \r
 461 struct ibv_qp_init_attr\r
 462 {\r
 463         void                            *qp_context;\r
 464         struct ibv_cq           *send_cq;\r
 465         struct ibv_cq           *recv_cq;\r
 466         struct ibv_srq          *srq;\r
 467         struct ibv_qp_cap       cap;\r
 468         enum ibv_qp_type        qp_type;\r
 469         int                                     sq_sig_all;\r
 470 };\r
 471 \r
 472 enum ibv_qp_attr_mask\r
 473 {\r
 474         IBV_QP_STATE                            = WV_QP_ATTR_STATE,\r
 475         IBV_QP_CUR_STATE                        = WV_QP_ATTR_CURRENT_STATE,\r
 476         IBV_QP_EN_SQD_ASYNC_NOTIFY      = WV_QP_ATTR_FLAGS,\r
 477         IBV_QP_ACCESS_FLAGS                     = WV_QP_ATTR_ACCESS_FLAGS,\r
 478         IBV_QP_PKEY_INDEX                       = WV_QP_ATTR_PKEY_INDEX,\r
 479         IBV_QP_PORT                                     = WV_QP_ATTR_PORT_NUMBER,\r
 480         IBV_QP_QKEY                                     = WV_QP_ATTR_QKEY,\r
 481         IBV_QP_AV                                       = WV_QP_ATTR_AV,\r
 482         IBV_QP_PATH_MTU                         = WV_QP_ATTR_AV,\r
 483         IBV_QP_TIMEOUT                          = WV_QP_ATTR_ACK_TIMEOUT,\r
 484         IBV_QP_RETRY_CNT                        = WV_QP_ATTR_ERROR_RETRY_COUNT,\r
 485         IBV_QP_RNR_RETRY                        = WV_QP_ATTR_RNR_RETRY_COUNT,\r
 486         IBV_QP_RQ_PSN                           = WV_QP_ATTR_RECEIVE_PSN,\r
 487         IBV_QP_MAX_QP_RD_ATOMIC         = WV_QP_ATTR_INITIATOR_DEPTH,\r
 488         IBV_QP_ALT_PATH                         = WV_QP_ATTR_ALTERNATE_AV,\r
 489         IBV_QP_MIN_RNR_TIMER            = WV_QP_ATTR_RNR_NAK_TIMEOUT,\r
 490         IBV_QP_SQ_PSN                           = WV_QP_ATTR_SEND_PSN,\r
 491         IBV_QP_MAX_DEST_RD_ATOMIC       = WV_QP_ATTR_RESPONDER_RESOURCES,\r
 492         IBV_QP_PATH_MIG_STATE           = WV_QP_ATTR_PATH_MIG_STATE,\r
 493         IBV_QP_CAP                                      = WV_QP_ATTR_CAPABILITIES,\r
 494         IBV_QP_DEST_QPN                         = WV_QP_ATTR_DESTINATION_QPN\r
 495 };\r
 496 \r
 497 enum ibv_qp_state\r
 498 {\r
 499         IBV_QPS_RESET   = WvQpStateReset,\r
 500         IBV_QPS_INIT    = WvQpStateInit,\r
 501         IBV_QPS_RTR             = WvQpStateRtr,\r
 502         IBV_QPS_RTS             = WvQpStateRts,\r
 503         IBV_QPS_SQD             = WvQpStateSqd,\r
 504         IBV_QPS_SQE             = WvQpStateSqError,\r
 505         IBV_QPS_ERR             = WvQpStateError\r
 506 };\r
 507 \r
 508 enum ibv_mig_state\r
 509 {\r
 510         IBV_MIG_MIGRATED        = WvApmMigrated,\r
 511         IBV_MIG_REARM           = WvApmRearm,\r
 512         IBV_MIG_ARMED           = WvApmArmed\r
 513 };\r
 514 \r
 515 struct ibv_qp_attr\r
 516 {\r
 517         enum ibv_qp_state       qp_state;\r
 518         enum ibv_qp_state       cur_qp_state;\r
 519         enum ibv_mtu            path_mtu;\r
 520         enum ibv_mig_state      path_mig_state;\r
 521         uint32_t                        qkey;\r
 522         uint32_t                        rq_psn;\r
 523         uint32_t                        sq_psn;\r
 524         uint32_t                        dest_qp_num;\r
 525         int                                     qp_access_flags;\r
 526         struct ibv_qp_cap       cap;\r
 527         struct ibv_ah_attr      ah_attr;\r
 528         struct ibv_ah_attr      alt_ah_attr;\r
 529         uint16_t                        pkey_index;\r
 530         uint16_t                        alt_pkey_index;\r
 531         uint8_t                         en_sqd_async_notify;\r
 532         uint8_t                         sq_draining;\r
 533         uint8_t                         max_rd_atomic;\r
 534         uint8_t                         max_dest_rd_atomic;\r
 535         uint8_t                         min_rnr_timer;\r
 536         uint8_t                         port_num;\r
 537         uint8_t                         timeout;\r
 538         uint8_t                         retry_cnt;\r
 539         uint8_t                         rnr_retry;\r
 540         uint8_t                         alt_port_num;\r
 541         uint8_t                         alt_timeout;\r
 542 };\r
 543 \r
 544 enum ibv_wr_opcode\r
 545 {\r
 546         IBV_WR_SEND = WvSend,\r
 547         IBV_WR_RDMA_WRITE = WvRdmaWrite,\r
 548         IBV_WR_RDMA_READ = WvRdmaRead,\r
 549         IBV_WR_ATOMIC_CMP_AND_SWP = WvCompareExchange,\r
 550         IBV_WR_ATOMIC_FETCH_AND_ADD = WvFetchAdd,\r
 551         IBV_WR_SEND_WITH_IMM = WvSend | 0x80000000,\r
 552         IBV_WR_RDMA_WRITE_WITH_IMM = WvRdmaWrite | 0x80000000,\r
 553 };\r
 554 \r
 555 enum ibv_send_flags\r
 556 {\r
 557         IBV_SEND_FENCE          = WV_SEND_FENCE,\r
 558         IBV_SEND_SIGNALED       = WV_SEND_SIGNALED,\r
 559         IBV_SEND_SOLICITED      = WV_SEND_SOLICITED,\r
 560         IBV_SEND_INLINE         = WV_SEND_INLINE\r
 561 };\r
 562 \r
 563 struct ibv_sge\r
 564 {\r
 565         uint64_t                addr;\r
 566         uint32_t                length;\r
 567         uint32_t                lkey;\r
 568 };\r
 569 \r
 570 struct ibv_send_wr\r
 571 {\r
 572         uint64_t                                wr_id;\r
 573         struct ibv_send_wr              *next;\r
 574         struct ibv_sge                  *sg_list;\r
 575         int                                             num_sge;\r
 576         enum ibv_wr_opcode              opcode;\r
 577         enum ibv_send_flags             send_flags;\r
 578         uint32_t                                imm_data;       /* in network byte order */\r
 579         union\r
 580         {\r
 581                 struct\r
 582                 {\r
 583                         uint64_t                remote_addr;\r
 584                         uint32_t                rkey;\r
 585 \r
 586                 }       rdma;\r
 587                 struct\r
 588                 {\r
 589                         uint64_t                remote_addr;\r
 590                         uint32_t                rkey;\r
 591                         uint64_t                compare_add;\r
 592                         uint64_t                swap;\r
 593 \r
 594                 }       atomic;\r
 595                 struct\r
 596                 {\r
 597                         struct ibv_ah  *ah;\r
 598                         uint32_t                remote_qpn;\r
 599                         uint32_t                remote_qkey;\r
 600 \r
 601                 }       ud;\r
 602         }       wr;\r
 603 };\r
 604 \r
 605 struct ibv_recv_wr\r
 606 {\r
 607         uint64_t                                wr_id;\r
 608         struct ibv_recv_wr     *next;\r
 609         struct ibv_sge         *sg_list;\r
 610         int                                             num_sge;\r
 611 };\r
 612 \r
 613 /* Memory windows not implemented by WinVerbs */\r
 614 struct ibv_mw_bind\r
 615 {\r
 616         uint64_t                                wr_id;\r
 617         struct ibv_mr                   *mr;\r
 618         void                                    *addr;\r
 619         size_t                                  length;\r
 620         enum ibv_send_flags             send_flags;\r
 621         enum ibv_access_flags   mw_access_flags;\r
 622 };\r
 623 \r
 624 struct ibv_srq\r
 625 {\r
 626         struct ibv_context              *context;\r
 627         void                                    *srq_context;\r
 628         struct ibv_pd                   *pd;\r
 629         IWVSharedReceiveQueue   *handle;\r
 630 };\r
 631 \r
 632 struct ibv_qp\r
 633 {\r
 634         struct ibv_context              *context;\r
 635         void                                    *qp_context;\r
 636         struct ibv_pd                   *pd;\r
 637         struct ibv_cq                   *send_cq;\r
 638         struct ibv_cq                   *recv_cq;\r
 639         struct ibv_srq                  *srq;\r
 640         IWVQueuePair                    *handle;\r
 641         union\r
 642         {\r
 643                 IWVDatagramQueuePair    *ud_handle;\r
 644                 IWVConnectQueuePair             *conn_handle;\r
 645         };\r
 646         uint32_t                                qp_num;\r
 647         enum ibv_qp_state       state;\r
 648         enum ibv_qp_type                qp_type;\r
 649 };\r
 650 \r
 651 struct ibv_comp_channel\r
 652 {\r
 653         struct ibv_context              *context;\r
 654         COMP_CHANNEL                    comp_channel;\r
 655 };\r
 656 \r
 657 struct ibv_cq\r
 658 {\r
 659         struct ibv_context              *context;\r
 660         struct ibv_comp_channel *channel;\r
 661         void                                    *cq_context;\r
 662         IWVCompletionQueue              *handle;\r
 663         int                                             cqe;\r
 664         COMP_ENTRY                              comp_entry;\r
 665         LONG volatile                   notify_cnt;\r
 666         LONG volatile                   ack_cnt;\r
 667 };\r
 668 \r
 669 struct ibv_ah\r
 670 {\r
 671         struct ibv_context              *context;\r
 672         struct ibv_pd                   *pd;\r
 673         IWVAddressHandle                *handle;\r
 674         ULONG_PTR                               key;\r
 675 };\r
 676 \r
 677 struct ibv_device;\r
 678 struct ibv_context;\r
 679 \r
 680 enum\r
 681 {\r
 682         IBV_SYSFS_NAME_MAX      = 64\r
 683 };\r
 684 \r
 685 struct ibv_device\r
 686 {\r
 687         enum ibv_node_type              node_type;\r
 688         enum ibv_transport_type transport_type;\r
 689         char                                    name[IBV_SYSFS_NAME_MAX];\r
 690 };\r
 691 \r
 692 struct ibv_context\r
 693 {\r
 694         struct ibv_device               *device;\r
 695         IWVDevice                               *cmd_if;\r
 696         COMP_CHANNEL                    channel;\r
 697 };\r
 698 \r
 699 /**\r
 700  * ibv_get_device_list - Get list of IB devices currently available\r
 701  * @num_devices: optional.  if non-NULL, set to the number of devices\r
 702  * returned in the array.\r
 703  *\r
 704  * Return a NULL-terminated array of IB devices.  The array can be\r
 705  * released with ibv_free_device_list().\r
 706  */\r
 707 __declspec(dllexport)\r
 708 struct ibv_device **ibv_get_device_list(int *num_devices);\r
 709 \r
 710 /**\r
 711  * ibv_free_device_list - Free list from ibv_get_device_list()\r
 712  *\r
 713  * Free an array of devices returned from ibv_get_device_list().  Once\r
 714  * the array is freed, pointers to devices that were not opened with\r
 715  * ibv_open_device() are no longer valid.  Client code must open all\r
 716  * devices it intends to use before calling ibv_free_device_list().\r
 717  */\r
 718 __declspec(dllexport)\r
 719 void ibv_free_device_list(struct ibv_device **list);\r
 720 \r
 721 /**\r
 722  * ibv_get_device_name - Return kernel device name\r
 723  */\r
 724 __declspec(dllexport)\r
 725 const char *ibv_get_device_name(struct ibv_device *device);\r
 726 \r
 727 /**\r
 728  * ibv_get_device_guid - Return device's node GUID\r
 729  */\r
 730 __declspec(dllexport)\r
 731 uint64_t ibv_get_device_guid(struct ibv_device *device);\r
 732 \r
 733 /**\r
 734  * ibv_open_device - Initialize device for use\r
 735  */\r
 736 __declspec(dllexport)\r
 737 struct ibv_context *ibv_open_device(struct ibv_device *device);\r
 738 \r
 739 /**\r
 740  * ibv_close_device - Release device\r
 741  */\r
 742 __declspec(dllexport)\r
 743 int ibv_close_device(struct ibv_context *context);\r
 744 \r
 745 /**\r
 746  * ibv_get_async_event - Get next async event\r
 747  * @event: Pointer to use to return async event\r
 748  *\r
 749  * All async events returned by ibv_get_async_event() must eventually\r
 750  * be acknowledged with ibv_ack_async_event().\r
 751  */\r
 752 __declspec(dllexport)\r
 753 int ibv_get_async_event(struct ibv_context *context,\r
 754                                                 struct ibv_async_event *event);\r
 755 \r
 756 /**\r
 757  * ibv_ack_async_event - Acknowledge an async event\r
 758  * @event: Event to be acknowledged.\r
 759  *\r
 760  * All async events which are returned by ibv_get_async_event() must\r
 761  * be acknowledged.  To avoid races, destroying an object (CQ, SRQ or\r
 762  * QP) will wait for all affiliated events to be acknowledged, so\r
 763  * there should be a one-to-one correspondence between acks and\r
 764  * successful gets.\r
 765  */\r
 766 __declspec(dllexport)\r
 767 void ibv_ack_async_event(struct ibv_async_event *event);\r
 768 \r
 769 /**\r
 770  * ibv_query_device - Get device properties\r
 771  */\r
 772 __declspec(dllexport)\r
 773 int ibv_query_device(struct ibv_context *context,\r
 774                                          struct ibv_device_attr *device_attr);\r
 775 \r
 776 /**\r
 777  * ibv_query_port - Get port properties\r
 778  */\r
 779 __declspec(dllexport)\r
 780 int ibv_query_port(struct ibv_context *context, uint8_t port_num,\r
 781                                    struct ibv_port_attr *port_attr);\r
 782 \r
 783 /**\r
 784  * ibv_query_gid - Get a GID table entry\r
 785  */\r
 786 __declspec(dllexport)\r
 787 int ibv_query_gid(struct ibv_context *context, uint8_t port_num,\r
 788                                   int index, union ibv_gid *gid);\r
 789 \r
 790 /**\r
 791  * ibv_query_pkey - Get a P_Key table entry\r
 792  */\r
 793 __declspec(dllexport)\r
 794 int ibv_query_pkey(struct ibv_context *context, uint8_t port_num,\r
 795                                    int index, uint16_t *pkey);\r
 796 \r
 797 /**\r
 798  * ibv_alloc_pd - Allocate a protection domain\r
 799  */\r
 800 __declspec(dllexport)\r
 801 struct ibv_pd *ibv_alloc_pd(struct ibv_context *context);\r
 802 \r
 803 /**\r
 804  * ibv_dealloc_pd - Free a protection domain\r
 805  */\r
 806 __declspec(dllexport)\r
 807 int ibv_dealloc_pd(struct ibv_pd *pd);\r
 808 \r
 809 /**\r
 810  * ibv_reg_mr - Register a memory region\r
 811  */\r
 812 __declspec(dllexport)\r
 813 struct ibv_mr *ibv_reg_mr(struct ibv_pd *pd, void *addr,\r
 814                                                   size_t length, enum ibv_access_flags access);\r
 815 \r
 816 /**\r
 817  * ibv_dereg_mr - Deregister a memory region\r
 818  */\r
 819 __declspec(dllexport)\r
 820 int ibv_dereg_mr(struct ibv_mr *mr);\r
 821 \r
 822 /**\r
 823  * ibv_create_comp_channel - Create a completion event channel\r
 824  */\r
 825 __declspec(dllexport)\r
 826 struct ibv_comp_channel *ibv_create_comp_channel(struct ibv_context *context);\r
 827 \r
 828 /**\r
 829  * ibv_destroy_comp_channel - Destroy a completion event channel\r
 830  */\r
 831 __declspec(dllexport)\r
 832 int ibv_destroy_comp_channel(struct ibv_comp_channel *channel);\r
 833 \r
 834 /**\r
 835  * ibv_create_cq - Create a completion queue\r
 836  * @context - Context CQ will be attached to\r
 837  * @cqe - Minimum number of entries required for CQ\r
 838  * @cq_context - Consumer-supplied context returned for completion events\r
 839  * @channel - Completion channel where completion events will be queued.\r
 840  *     May be NULL if completion events will not be used.\r
 841  * @comp_vector - Completion vector used to signal completion events.\r
 842  *     Must be >= 0 and < context->num_comp_vectors.\r
 843  */\r
 844 __declspec(dllexport)\r
 845 struct ibv_cq *ibv_create_cq(struct ibv_context *context, int cqe,\r
 846                                                          void *cq_context,\r
 847                                                          struct ibv_comp_channel *channel,\r
 848                                                          int comp_vector);\r
 849 \r
 850 /**\r
 851  * ibv_resize_cq - Modifies the capacity of the CQ.\r
 852  * @cq: The CQ to resize.\r
 853  * @cqe: The minimum size of the CQ.\r
 854  *\r
 855  * Users can examine the cq structure to determine the actual CQ size.\r
 856  */\r
 857 __declspec(dllexport)\r
 858 int ibv_resize_cq(struct ibv_cq *cq, int cqe);\r
 859 \r
 860 /**\r
 861  * ibv_destroy_cq - Destroy a completion queue\r
 862  */\r
 863 __declspec(dllexport)\r
 864 int ibv_destroy_cq(struct ibv_cq *cq);\r
 865 \r
 866 /**\r
 867  * ibv_get_cq_event - Read next CQ event\r
 868  * @channel: Channel to get next event from.\r
 869  * @cq: Used to return pointer to CQ.\r
 870  * @cq_context: Used to return consumer-supplied CQ context.\r
 871  *\r
 872  * All completion events returned by ibv_get_cq_event() must\r
 873  * eventually be acknowledged with ibv_ack_cq_events().\r
 874  */\r
 875 __declspec(dllexport)\r
 876 int ibv_get_cq_event(struct ibv_comp_channel *channel,\r
 877                                          struct ibv_cq **cq, void **cq_context);\r
 878 \r
 879 /**\r
 880  * ibv_ack_cq_events - Acknowledge CQ completion events\r
 881  * @cq: CQ to acknowledge events for\r
 882  * @nevents: Number of events to acknowledge.\r
 883  *\r
 884  * All completion events which are returned by ibv_get_cq_event() must\r
 885  * be acknowledged.  To avoid races, ibv_destroy_cq() will wait for\r
 886  * all completion events to be acknowledged, so there should be a\r
 887  * one-to-one correspondence between acks and successful gets.  An\r
 888  * application may accumulate multiple completion events and\r
 889  * acknowledge them in a single call to ibv_ack_cq_events() by passing\r
 890  * the number of events to ack in @nevents.\r
 891  */\r
 892 __declspec(dllexport)\r
 893 void ibv_ack_cq_events(struct ibv_cq *cq, unsigned int nevents);\r
 894 \r
 895 /**\r
 896  * ibv_poll_cq - Poll a CQ for work completions\r
 897  * @cq:the CQ being polled\r
 898  * @num_entries:maximum number of completions to return\r
 899  * @wc:array of at least @num_entries of &struct ibv_wc where completions\r
 900  *   will be returned\r
 901  *\r
 902  * Poll a CQ for (possibly multiple) completions.  If the return value\r
 903  * is < 0, an error occurred.  If the return value is >= 0, it is the\r
 904  * number of completions returned.  If the return value is\r
 905  * non-negative and strictly less than num_entries, then the CQ was\r
 906  * emptied.\r
 907  */\r
 908 __declspec(dllexport)\r
 909 int ibv_poll_cq(struct ibv_cq *cq, int num_entries, struct ibv_wc *wc);\r
 910 \r
 911 /**\r
 912  * ibv_req_notify_cq - Request completion notification on a CQ.  An\r
 913  *   event will be added to the completion channel associated with the\r
 914  *   CQ when an entry is added to the CQ.\r
 915  * @cq: The completion queue to request notification for.\r
 916  * @solicited_only: If non-zero, an event will be generated only for\r
 917  *   the next solicited CQ entry.  If zero, any CQ entry, solicited or\r
 918  *   not, will generate an event.\r
 919  */\r
 920 __declspec(dllexport)\r
 921 int ibv_req_notify_cq(struct ibv_cq *cq, int solicited_only);\r
 922 \r
 923 /**\r
 924  * ibv_create_srq - Creates a SRQ associated with the specified protection\r
 925  *   domain.\r
 926  * @pd: The protection domain associated with the SRQ.\r
 927  * @srq_init_attr: A list of initial attributes required to create the SRQ.\r
 928  *\r
 929  * srq_attr->max_wr and srq_attr->max_sge are read the determine the\r
 930  * requested size of the SRQ, and set to the actual values allocated\r
 931  * on return.  If ibv_create_srq() succeeds, then max_wr and max_sge\r
 932  * will always be at least as large as the requested values.\r
 933  */\r
 934 __declspec(dllexport)\r
 935 struct ibv_srq *ibv_create_srq(struct ibv_pd *pd,\r
 936                                                            struct ibv_srq_init_attr *srq_init_attr);\r
 937 \r
 938 /**\r
 939  * ibv_modify_srq - Modifies the attributes for the specified SRQ.\r
 940  * @srq: The SRQ to modify.\r
 941  * @srq_attr: On input, specifies the SRQ attributes to modify.  On output,\r
 942  *   the current values of selected SRQ attributes are returned.\r
 943  * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ\r
 944  *   are being modified.\r
 945  *\r
 946  * The mask may contain IBV_SRQ_MAX_WR to resize the SRQ and/or\r
 947  * IBV_SRQ_LIMIT to set the SRQ's limit and request notification when\r
 948  * the number of receives queued drops below the limit.\r
 949  */\r
 950 __declspec(dllexport)\r
 951 int ibv_modify_srq(struct ibv_srq *srq,\r
 952                                    struct ibv_srq_attr *srq_attr,\r
 953                                    enum ibv_srq_attr_mask srq_attr_mask);\r
 954 \r
 955 /**\r
 956  * ibv_query_srq - Returns the attribute list and current values for the\r
 957  *   specified SRQ.\r
 958  * @srq: The SRQ to query.\r
 959  * @srq_attr: The attributes of the specified SRQ.\r
 960  */\r
 961 __declspec(dllexport)\r
 962 int ibv_query_srq(struct ibv_srq *srq, struct ibv_srq_attr *srq_attr);\r
 963 \r
 964 /**\r
 965  * ibv_destroy_srq - Destroys the specified SRQ.\r
 966  * @srq: The SRQ to destroy.\r
 967  */\r
 968 __declspec(dllexport)\r
 969 int ibv_destroy_srq(struct ibv_srq *srq);\r
 970 \r
 971 /**\r
 972  * ibv_post_srq_recv - Posts a list of work requests to the specified SRQ.\r
 973  * @srq: The SRQ to post the work request on.\r
 974  * @recv_wr: A list of work requests to post on the receive queue.\r
 975  * @bad_recv_wr: On an immediate failure, this parameter will reference\r
 976  *   the work request that failed to be posted on the QP.\r
 977  */\r
 978 __declspec(dllexport)\r
 979 int ibv_post_srq_recv(struct ibv_srq *srq,\r
 980                                           struct ibv_recv_wr *recv_wr,\r
 981                                           struct ibv_recv_wr **bad_recv_wr);\r
 982 \r
 983 /**\r
 984  * ibv_create_qp - Create a queue pair.\r
 985  */\r
 986 __declspec(dllexport)\r
 987 struct ibv_qp *ibv_create_qp(struct ibv_pd *pd,\r
 988                                                          struct ibv_qp_init_attr *qp_init_attr);\r
 989 \r
 990 /**\r
 991  * ibv_modify_qp - Modify a queue pair.\r
 992  */\r
 993 __declspec(dllexport)\r
 994 int ibv_modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr,\r
 995                                   enum ibv_qp_attr_mask attr_mask);\r
 996 \r
 997 /**\r
 998  * ibv_query_qp - Returns the attribute list and current values for the\r
 999  *   specified QP.\r
1000  * @qp: The QP to query.\r
1001  * @attr: The attributes of the specified QP.\r
1002  * @attr_mask: A bit-mask used to select specific attributes to query.\r
1003  * @init_attr: Additional attributes of the selected QP.\r
1004  *\r
1005  * The qp_attr_mask may be used to limit the query to gathering only the\r
1006  * selected attributes.\r
1007  */\r
1008 __declspec(dllexport)\r
1009 int ibv_query_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr,\r
1010                                  enum ibv_qp_attr_mask attr_mask,\r
1011                                  struct ibv_qp_init_attr *init_attr);\r
1012 \r
1013 /**\r
1014  * ibv_destroy_qp - Destroy a queue pair.\r
1015  */\r
1016 __declspec(dllexport)\r
1017 int ibv_destroy_qp(struct ibv_qp *qp);\r
1018 \r
1019 /**\r
1020  * ibv_post_send - Post a list of work requests to a send queue.\r
1021  *\r
1022  * If IBV_SEND_INLINE flag is set, the data buffers can be reused\r
1023  * immediately after the call returns.\r
1024  */\r
1025 __declspec(dllexport)\r
1026 int ibv_post_send(struct ibv_qp *qp, struct ibv_send_wr *wr,\r
1027                                   struct ibv_send_wr **bad_wr);\r
1028 \r
1029 /**\r
1030  * ibv_post_recv - Post a list of work requests to a receive queue.\r
1031  */\r
1032 __declspec(dllexport)\r
1033 int ibv_post_recv(struct ibv_qp *qp, struct ibv_recv_wr *wr,\r
1034                                   struct ibv_recv_wr **bad_wr);\r
1035 \r
1036 /**\r
1037  * ibv_create_ah - Create an address handle.\r
1038  */\r
1039 __declspec(dllexport)\r
1040 struct ibv_ah *ibv_create_ah(struct ibv_pd *pd, struct ibv_ah_attr *attr);\r
1041 \r
1042 /**\r
1043  * ibv_init_ah_from_wc - Initializes address handle attributes from a\r
1044  *   work completion.\r
1045  * @context: Device context on which the received message arrived.\r
1046  * @port_num: Port on which the received message arrived.\r
1047  * @wc: Work completion associated with the received message.\r
1048  * @grh: References the received global route header.  This parameter is\r
1049  *   ignored unless the work completion indicates that the GRH is valid.\r
1050  * @ah_attr: Returned attributes that can be used when creating an address\r
1051  *   handle for replying to the message.\r
1052  */\r
1053 __declspec(dllexport)\r
1054 int ibv_init_ah_from_wc(struct ibv_context *context, uint8_t port_num,\r
1055                                                 struct ibv_wc *wc, struct ibv_grh *grh,\r
1056                                                 struct ibv_ah_attr *ah_attr);\r
1057 \r
1058 /**\r
1059  * ibv_create_ah_from_wc - Creates an address handle associated with the\r
1060  *   sender of the specified work completion.\r
1061  * @pd: The protection domain associated with the address handle.\r
1062  * @wc: Work completion information associated with a received message.\r
1063  * @grh: References the received global route header.  This parameter is\r
1064  *   ignored unless the work completion indicates that the GRH is valid.\r
1065  * @port_num: The outbound port number to associate with the address.\r
1066  *\r
1067  * The address handle is used to reference a local or global destination\r
1068  * in all UD QP post sends.\r
1069  */\r
1070 __declspec(dllexport)\r
1071 struct ibv_ah *ibv_create_ah_from_wc(struct ibv_pd *pd, struct ibv_wc *wc,\r
1072                                                                          struct ibv_grh *grh, uint8_t port_num);\r
1073 \r
1074 /**\r
1075  * ibv_destroy_ah - Destroy an address handle.\r
1076  */\r
1077 __declspec(dllexport)\r
1078 int ibv_destroy_ah(struct ibv_ah *ah);\r
1079 \r
1080 /**\r
1081  * ibv_attach_mcast - Attaches the specified QP to a multicast group.\r
1082  * @qp: QP to attach to the multicast group.  The QP must be a UD QP.\r
1083  * @gid: Multicast group GID.\r
1084  * @lid: Multicast group LID in host byte order.\r
1085  *\r
1086  * In order to route multicast packets correctly, subnet\r
1087  * administration must have created the multicast group and configured\r
1088  * the fabric appropriately.  The port associated with the specified\r
1089  * QP must also be a member of the multicast group.\r
1090  */\r
1091 __declspec(dllexport)\r
1092 int ibv_attach_mcast(struct ibv_qp *qp, union ibv_gid *gid, uint16_t lid);\r
1093 \r
1094 /**\r
1095  * ibv_detach_mcast - Detaches the specified QP from a multicast group.\r
1096  * @qp: QP to detach from the multicast group.\r
1097  * @gid: Multicast group GID.\r
1098  * @lid: Multicast group LID in host byte order.\r
1099  */\r
1100 __declspec(dllexport)\r
1101 int ibv_detach_mcast(struct ibv_qp *qp, union ibv_gid *gid, uint16_t lid);\r
1102 \r
1103 /**\r
1104  * ibv_node_type_str - Return string describing node_type enum value\r
1105  */\r
1106 __declspec(dllexport)\r
1107 const char *ibv_node_type_str(enum ibv_node_type node_type);\r
1108 \r
1109 /**\r
1110  * ibv_port_state_str - Return string describing port_state enum value\r
1111  */\r
1112 __declspec(dllexport)\r
1113 const char *ibv_port_state_str(enum ibv_port_state port_state);\r
1114 \r
1115 /**\r
1116  * ibv_event_type_str - Return string describing event_type enum value\r
1117  */\r
1118 __declspec(dllexport)\r
1119 const char *ibv_event_type_str(enum ibv_event_type event);\r
1120 \r
1121 /*\r
1122  * Windows specific structures and interfaces\r
1123  */\r
1124 struct ibvw_windata\r
1125 {\r
1126         IWVProvider             *prov;\r
1127         COMP_MANAGER    *comp_mgr;\r
1128 };\r
1129 \r
1130 #define IBVW_WINDATA_VERSION 1\r
1131 \r
1132 __declspec(dllexport)\r
1133 int ibvw_get_windata(struct ibvw_windata *windata, int version);\r
1134 \r
1135 __declspec(dllexport)\r
1136 void ibvw_release_windata(struct ibvw_windata *windata, int version);\r
1137 \r
1138 #ifdef __cplusplus\r
1139 }\r
1140 #endif\r
1141 \r
1142 #endif /* INFINIBAND_VERBS_H */\r