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