[HW, TOOLS] fixed a bug, causing incorrect value of max_addr_handles in query_ca...
[mirror/winof/.git] / hw / mthca / kernel / ib_verbs.h
1 /*\r
2  * Copyright (c) 2004 Mellanox Technologies Ltd.  All rights reserved.\r
3  * Copyright (c) 2004 Infinicon Corporation.  All rights reserved.\r
4  * Copyright (c) 2004 Intel Corporation.  All rights reserved.\r
5  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.\r
6  * Copyright (c) 2004 Voltaire Corporation.  All rights reserved.\r
7  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.\r
8  * Copyright (c) 2005 Cisco Systems.  All rights reserved.\r
9  * Portions Copyright (c) 2008 Microsoft Corporation.  All rights reserved.\r
10  *\r
11  * This software is available to you under the OpenIB.org BSD license\r
12  * below:\r
13  *\r
14  *     Redistribution and use in source and binary forms, with or\r
15  *     without modification, are permitted provided that the following\r
16  *     conditions are met:\r
17  *\r
18  *      - Redistributions of source code must retain the above\r
19  *        copyright notice, this list of conditions and the following\r
20  *        disclaimer.\r
21  *\r
22  *      - Redistributions in binary form must reproduce the above\r
23  *        copyright notice, this list of conditions and the following\r
24  *        disclaimer in the documentation and/or other materials\r
25  *        provided with the distribution.\r
26  *\r
27  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
28  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
29  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
30  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
31  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
32  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
33  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
34  * SOFTWARE.\r
35  *\r
36  * $Id$\r
37  */\r
38 \r
39 #if !defined(IB_VERBS_H)\r
40 #define IB_VERBS_H\r
41 \r
42 #include <iba/ib_types.h>\r
43 #include <iba/ib_ci.h>\r
44 #include <mt_l2w.h>\r
45 \r
46 union ib_gid {\r
47         u8      raw[16];\r
48         struct {\r
49                 __be64  subnet_prefix;\r
50                 __be64  interface_id;\r
51         } global;\r
52 };\r
53 \r
54 enum ib_node_type {\r
55         IB_NODE_CA      = 1,\r
56         IB_NODE_SWITCH,\r
57         IB_NODE_ROUTER\r
58 };\r
59 \r
60 enum ib_device_cap_flags {\r
61         IB_DEVICE_RESIZE_MAX_WR         = 1,\r
62         IB_DEVICE_BAD_PKEY_CNTR         = (1<<1),\r
63         IB_DEVICE_BAD_QKEY_CNTR         = (1<<2),\r
64         IB_DEVICE_RAW_MULTI             = (1<<3),\r
65         IB_DEVICE_AUTO_PATH_MIG         = (1<<4),\r
66         IB_DEVICE_CHANGE_PHY_PORT       = (1<<5),\r
67         IB_DEVICE_UD_AV_PORT_ENFORCE    = (1<<6),\r
68         IB_DEVICE_CURR_QP_STATE_MOD     = (1<<7),\r
69         IB_DEVICE_SHUTDOWN_PORT         = (1<<8),\r
70         IB_DEVICE_INIT_TYPE             = (1<<9),\r
71         IB_DEVICE_PORT_ACTIVE_EVENT     = (1<<10),\r
72         IB_DEVICE_SYS_IMAGE_GUID        = (1<<11),\r
73         IB_DEVICE_RC_RNR_NAK_GEN        = (1<<12),\r
74         IB_DEVICE_SRQ_RESIZE            = (1<<13),\r
75         IB_DEVICE_N_NOTIFY_CQ           = (1<<14),\r
76 };\r
77 \r
78 struct ib_device_attr {\r
79         u64                     fw_ver;\r
80         __be64                  sys_image_guid;\r
81         u64                     max_mr_size;\r
82         u64                     page_size_cap;\r
83         u32                     vendor_id;\r
84         u32                     vendor_part_id;\r
85         u32                     hw_ver;\r
86         int                     max_qp;\r
87         int                     max_qp_wr;\r
88         int                     device_cap_flags;\r
89         int                     max_sge;\r
90         int                     max_sge_rd;\r
91         int                     max_cq;\r
92         int                     max_cqe;\r
93         int                     max_mr;\r
94         int                     max_pd;\r
95         int                     max_qp_rd_atom;\r
96         int                     max_ee_rd_atom;\r
97         int                     max_res_rd_atom;\r
98         int                     max_qp_init_rd_atom;\r
99         int                     max_ee_init_rd_atom;\r
100         enum ib_atomic_cap      atomic_cap;\r
101         int                     max_ee;\r
102         int                     max_rdd;\r
103         int                     max_mw;\r
104         int                     max_raw_ipv6_qp;\r
105         int                     max_raw_ethy_qp;\r
106         int                     max_mcast_grp;\r
107         int                     max_mcast_qp_attach;\r
108         int                     max_total_mcast_qp_attach;\r
109         u64                     max_ah;\r
110         int                     max_fmr;\r
111         int                     max_map_per_fmr;\r
112         int                     max_srq;\r
113         int                     max_srq_wr;\r
114         int                     max_srq_sge;\r
115         u16                     max_pkeys;\r
116         u8                      local_ca_ack_delay;\r
117 };\r
118 \r
119 static inline int ib_mtu_enum_to_int(int mtu)\r
120 {\r
121         switch (mtu) {\r
122         case IB_MTU_LEN_256:  return  256;\r
123         case IB_MTU_LEN_512:  return  512;\r
124         case IB_MTU_LEN_1024: return 1024;\r
125         case IB_MTU_LEN_2048: return 2048;\r
126         case IB_MTU_LEN_4096: return 4096;\r
127         default:          return -1;\r
128         }\r
129 }\r
130 \r
131 enum ib_port_state {\r
132         IB_PORT_NOP             = 0,\r
133         IB_PORT_DOWN            = 1,\r
134         IB_PORT_INIT            = 2,\r
135         IB_PORT_ARMED           = 3,\r
136         IB_PORT_ACTIVE          = 4,\r
137         IB_PORT_ACTIVE_DEFER    = 5\r
138 };\r
139 \r
140 enum ib_port_cap_flags {\r
141         IB_PORT_SM                              = 1 <<  1,\r
142         IB_PORT_NOTICE_SUP                      = 1 <<  2,\r
143         IB_PORT_TRAP_SUP                        = 1 <<  3,\r
144         IB_PORT_OPT_IPD_SUP                     = 1 <<  4,\r
145         IB_PORT_AUTO_MIGR_SUP                   = 1 <<  5,\r
146         IB_PORT_SL_MAP_SUP                      = 1 <<  6,\r
147         IB_PORT_MKEY_NVRAM                      = 1 <<  7,\r
148         IB_PORT_PKEY_NVRAM                      = 1 <<  8,\r
149         IB_PORT_LED_INFO_SUP                    = 1 <<  9,\r
150         IB_PORT_SM_DISABLED                     = 1 << 10,\r
151         IB_PORT_SYS_IMAGE_GUID_SUP              = 1 << 11,\r
152         IB_PORT_PKEY_SW_EXT_PORT_TRAP_SUP       = 1 << 12,\r
153         IB_PORT_CM_SUP                          = 1 << 16,\r
154         IB_PORT_SNMP_TUNNEL_SUP                 = 1 << 17,\r
155         IB_PORT_REINIT_SUP                      = 1 << 18,\r
156         IB_PORT_DEVICE_MGMT_SUP                 = 1 << 19,\r
157         IB_PORT_VENDOR_CLASS_SUP                = 1 << 20,\r
158         IB_PORT_DR_NOTICE_SUP                   = 1 << 21,\r
159         IB_PORT_CAP_MASK_NOTICE_SUP             = 1 << 22,\r
160         IB_PORT_BOOT_MGMT_SUP                   = 1 << 23,\r
161         IB_PORT_LINK_LATENCY_SUP                = 1 << 24,\r
162         IB_PORT_CLIENT_REG_SUP                  = 1 << 25\r
163 };\r
164 \r
165 enum ib_port_width {\r
166         IB_WIDTH_1X     = 1,\r
167         IB_WIDTH_4X     = 2,\r
168         IB_WIDTH_8X     = 4,\r
169         IB_WIDTH_12X    = 8\r
170 };\r
171 \r
172 static inline int ib_width_enum_to_int(enum ib_port_width width)\r
173 {\r
174         switch (width) {\r
175         case IB_WIDTH_1X:  return  1;\r
176         case IB_WIDTH_4X:  return  4;\r
177         case IB_WIDTH_8X:  return  8;\r
178         case IB_WIDTH_12X: return 12;\r
179         default:          return -1;\r
180         }\r
181 }\r
182 \r
183 struct ib_port_attr {\r
184         enum ib_port_state      state;\r
185         enum ib_mtu             max_mtu;\r
186         enum ib_mtu             active_mtu;\r
187         int                     gid_tbl_len;\r
188         u32                     port_cap_flags;\r
189         u32                     max_msg_sz;\r
190         u32                     bad_pkey_cntr;\r
191         u32                     qkey_viol_cntr;\r
192         u16                     pkey_tbl_len;\r
193         u16                     lid;\r
194         u16                     sm_lid;\r
195         u8                      lmc;\r
196         u8                      max_vl_num;\r
197         u8                      sm_sl;\r
198         u8                      subnet_timeout;\r
199         u8                      init_type_reply;\r
200         u8                      active_width;\r
201         u8                      active_speed;\r
202         u8                      phys_state;\r
203 };\r
204 \r
205 enum ib_device_modify_flags {\r
206         IB_DEVICE_MODIFY_SYS_IMAGE_GUID = 1\r
207 };\r
208 \r
209 struct ib_device_modify {\r
210         u64     sys_image_guid;\r
211 };\r
212 \r
213 enum ib_port_modify_flags {\r
214         IB_PORT_SHUTDOWN                = 1,\r
215         IB_PORT_INIT_TYPE               = (1<<2),\r
216         IB_PORT_RESET_QKEY_CNTR         = (1<<3)\r
217 };\r
218 \r
219 struct ib_port_modify {\r
220         u32     set_port_cap_mask;\r
221         u32     clr_port_cap_mask;\r
222         u8      init_type;\r
223 };\r
224 \r
225 enum ib_event_type {\r
226         IB_EVENT_CQ_ERR                                                                 = IB_AE_CQ_ERROR,\r
227         IB_EVENT_QP_FATAL                                                               = IB_AE_QP_FATAL,\r
228         IB_EVENT_QP_REQ_ERR                                                     = IB_AE_WQ_REQ_ERROR,\r
229         IB_EVENT_QP_ACCESS_ERR                                  = IB_AE_WQ_ACCESS_ERROR,\r
230         IB_EVENT_COMM_EST                                                       = IB_AE_QP_COMM,\r
231         IB_EVENT_SQ_DRAINED                                             = IB_AE_SQ_DRAINED,\r
232         IB_EVENT_PATH_MIG                                                               = IB_AE_QP_APM,\r
233         IB_EVENT_PATH_MIG_ERR                                   = IB_AE_QP_APM_ERROR,\r
234         IB_EVENT_DEVICE_FATAL                                           = IB_AE_LOCAL_FATAL,\r
235         IB_EVENT_PORT_ACTIVE                                            = IB_AE_PORT_ACTIVE,\r
236         IB_EVENT_PORT_ERR                                                               = IB_AE_PORT_DOWN,\r
237         IB_EVENT_SRQ_LIMIT_REACHED                              = IB_AE_SRQ_LIMIT_REACHED,\r
238         IB_EVENT_SRQ_CATAS_ERROR                                        = IB_AE_SRQ_CATAS_ERROR,\r
239         IB_EVENT_SRQ_QP_LAST_WQE_REACHED                = IB_AE_SRQ_QP_LAST_WQE_REACHED,\r
240         IB_EVENT_LID_CHANGE                                                     = IB_AE_UNKNOWN + 1,\r
241         IB_EVENT_PKEY_CHANGE,\r
242         IB_EVENT_SM_CHANGE\r
243 };\r
244 \r
245 struct ib_event {\r
246         struct ib_device        *device;\r
247         union {\r
248                 struct ib_cq    *cq;\r
249                 struct ib_qp    *qp;\r
250                 struct ib_srq   *srq;\r
251                 u8              port_num;\r
252         } element;\r
253         enum ib_event_type      event;\r
254         uint64_t                vendor_specific;\r
255 };\r
256 \r
257 struct ib_event_handler {\r
258         struct ib_device *device;\r
259         void            (*handler)(struct ib_event_handler *, struct ib_event *);\r
260         struct list_head  list;\r
261 };\r
262 \r
263 #define INIT_IB_EVENT_HANDLER(_ptr, _device, _handler)          \\r
264         (_ptr)->device  = _device;                      \\r
265         (_ptr)->handler = _handler;                     \\r
266         INIT_LIST_HEAD(&(_ptr)->list)                   \r
267 \r
268 struct ib_global_route {\r
269         union ib_gid    dgid;\r
270         u32             flow_label;\r
271         u8              sgid_index;\r
272         u8              hop_limit;\r
273         u8              traffic_class;\r
274 };\r
275 \r
276 struct ib_grh {\r
277         __be32          version_tclass_flow;\r
278         __be16          paylen;\r
279         u8              next_hdr;\r
280         u8              hop_limit;\r
281         union ib_gid    sgid;\r
282         union ib_gid    dgid;\r
283 };\r
284 \r
285 enum {\r
286         IB_MULTICAST_QPN = 0xffffff\r
287 };\r
288 \r
289 enum ib_ah_flags {\r
290         IB_AH_GRH       = 1\r
291 };\r
292 \r
293 struct ib_ah_attr {\r
294         struct ib_global_route  grh;\r
295         u16                     dlid;\r
296         u8                      sl;\r
297         u8                      src_path_bits;\r
298         u8                      static_rate;\r
299         u8                      ah_flags;\r
300         u8                      port_num;\r
301 };\r
302 \r
303 enum ib_cq_notify {\r
304         IB_CQ_SOLICITED,\r
305         IB_CQ_NEXT_COMP\r
306 };\r
307 \r
308 struct ib_srq_init_attr {\r
309         void                                    (*event_handler)(struct ib_event *, void *);\r
310         void                                    *srq_context;\r
311         ib_srq_attr_t                   attr;\r
312 };\r
313 \r
314 struct ib_qp_cap {\r
315         u32     max_send_wr;\r
316         u32     max_recv_wr;\r
317         u32     max_send_sge;\r
318         u32     max_recv_sge;\r
319         u32     max_inline_data;\r
320 };\r
321 \r
322 enum ib_sig_type {\r
323         IB_SIGNAL_ALL_WR,\r
324         IB_SIGNAL_REQ_WR\r
325 };\r
326 \r
327 struct ib_qp_init_attr {\r
328         void                  (*event_handler)(struct ib_event *, void *);\r
329         void                   *qp_context;\r
330         struct ib_cq           *send_cq;\r
331         struct ib_cq           *recv_cq;\r
332         struct ib_srq          *srq;\r
333         struct ib_qp_cap        cap;\r
334         enum ib_sig_type        sq_sig_type;\r
335         enum ib_qp_type_t               qp_type;\r
336         u8                      port_num; /* special QP types only */\r
337 };\r
338 \r
339 enum ib_rnr_timeout {\r
340         IB_RNR_TIMER_655_36 =  0,\r
341         IB_RNR_TIMER_000_01 =  1,\r
342         IB_RNR_TIMER_000_02 =  2,\r
343         IB_RNR_TIMER_000_03 =  3,\r
344         IB_RNR_TIMER_000_04 =  4,\r
345         IB_RNR_TIMER_000_06 =  5,\r
346         IB_RNR_TIMER_000_08 =  6,\r
347         IB_RNR_TIMER_000_12 =  7,\r
348         IB_RNR_TIMER_000_16 =  8,\r
349         IB_RNR_TIMER_000_24 =  9,\r
350         IB_RNR_TIMER_000_32 = 10,\r
351         IB_RNR_TIMER_000_48 = 11,\r
352         IB_RNR_TIMER_000_64 = 12,\r
353         IB_RNR_TIMER_000_96 = 13,\r
354         IB_RNR_TIMER_001_28 = 14,\r
355         IB_RNR_TIMER_001_92 = 15,\r
356         IB_RNR_TIMER_002_56 = 16,\r
357         IB_RNR_TIMER_003_84 = 17,\r
358         IB_RNR_TIMER_005_12 = 18,\r
359         IB_RNR_TIMER_007_68 = 19,\r
360         IB_RNR_TIMER_010_24 = 20,\r
361         IB_RNR_TIMER_015_36 = 21,\r
362         IB_RNR_TIMER_020_48 = 22,\r
363         IB_RNR_TIMER_030_72 = 23,\r
364         IB_RNR_TIMER_040_96 = 24,\r
365         IB_RNR_TIMER_061_44 = 25,\r
366         IB_RNR_TIMER_081_92 = 26,\r
367         IB_RNR_TIMER_122_88 = 27,\r
368         IB_RNR_TIMER_163_84 = 28,\r
369         IB_RNR_TIMER_245_76 = 29,\r
370         IB_RNR_TIMER_327_68 = 30,\r
371         IB_RNR_TIMER_491_52 = 31\r
372 };\r
373 \r
374 enum ib_qp_attr_mask {\r
375         IB_QP_STATE                     = 1,\r
376         IB_QP_CUR_STATE                 = (1<<1),\r
377         IB_QP_EN_SQD_ASYNC_NOTIFY       = (1<<2),\r
378         IB_QP_ACCESS_FLAGS              = (1<<3),\r
379         IB_QP_PKEY_INDEX                = (1<<4),\r
380         IB_QP_PORT                      = (1<<5),\r
381         IB_QP_QKEY                      = (1<<6),\r
382         IB_QP_AV                        = (1<<7),\r
383         IB_QP_PATH_MTU                  = (1<<8),\r
384         IB_QP_TIMEOUT                   = (1<<9),\r
385         IB_QP_RETRY_CNT                 = (1<<10),\r
386         IB_QP_RNR_RETRY                 = (1<<11),\r
387         IB_QP_RQ_PSN                    = (1<<12),\r
388         IB_QP_MAX_QP_RD_ATOMIC          = (1<<13),\r
389         IB_QP_ALT_PATH                  = (1<<14),\r
390         IB_QP_MIN_RNR_TIMER             = (1<<15),\r
391         IB_QP_SQ_PSN                    = (1<<16),\r
392         IB_QP_MAX_DEST_RD_ATOMIC        = (1<<17),\r
393         IB_QP_PATH_MIG_STATE            = (1<<18),\r
394         IB_QP_CAP                       = (1<<19),\r
395         IB_QP_DEST_QPN                  = (1<<20)\r
396 };\r
397 \r
398 //TODO: these literals are also defined in ib_types.h and have there ANOTHER VALUES !!! \r
399 enum ib_qp_state {\r
400         IBQPS_RESET,\r
401         IBQPS_INIT,\r
402         IBQPS_RTR,\r
403         IBQPS_RTS,\r
404         IBQPS_SQD,\r
405         IBQPS_SQE,\r
406         IBQPS_ERR\r
407 };\r
408 \r
409 \r
410 struct ib_qp_attr {\r
411         enum ib_qp_state        qp_state;\r
412         enum ib_qp_state        cur_qp_state;\r
413         enum ib_mtu             path_mtu;\r
414         ib_apm_state_t  path_mig_state;\r
415         u32                     qkey;\r
416         u32                     rq_psn;\r
417         u32                     sq_psn;\r
418         u32                     dest_qp_num;\r
419         int                     qp_access_flags;\r
420         struct ib_qp_cap        cap;\r
421         struct ib_ah_attr       ah_attr;\r
422         struct ib_ah_attr       alt_ah_attr;\r
423         u16                     pkey_index;\r
424         u16                     alt_pkey_index;\r
425         u8                      en_sqd_async_notify;\r
426         u8                      sq_draining;\r
427         u8                      max_rd_atomic;\r
428         u8                      max_dest_rd_atomic;\r
429         u8                      min_rnr_timer;\r
430         u8                      port_num;\r
431         u8                      timeout;\r
432         u8                      retry_cnt;\r
433         u8                      rnr_retry;\r
434         u8                      alt_port_num;\r
435         u8                      alt_timeout;\r
436 };\r
437 \r
438 struct ib_sge {\r
439         u64     addr;\r
440         u32     length;\r
441         u32     lkey;\r
442 };\r
443 \r
444 \r
445 typedef enum MTHCA_QP_ACCESS_FLAGS {\r
446         MTHCA_ACCESS_LOCAL_WRITE        = 1,\r
447         MTHCA_ACCESS_REMOTE_WRITE       = (1<<1),\r
448         MTHCA_ACCESS_REMOTE_READ        = (1<<2),\r
449         MTHCA_ACCESS_REMOTE_ATOMIC      = (1<<3),\r
450         MTHCA_ACCESS_MW_BIND    = (1<<4)\r
451 } mthca_qp_access_t;\r
452 \r
453 struct ib_phys_buf {\r
454         u64      addr;\r
455         u64      size;\r
456 };\r
457 \r
458 struct ib_mr_attr {\r
459         struct ib_pd    *pd;\r
460         u64             device_virt_addr;\r
461         u64             size;\r
462         mthca_qp_access_t               mr_access_flags;\r
463         u32             lkey;\r
464         u32             rkey;\r
465 };\r
466 \r
467 enum ib_mr_rereg_flags {\r
468         IB_MR_REREG_TRANS       = 1,\r
469         IB_MR_REREG_PD          = (1<<1),\r
470         IB_MR_REREG_ACCESS      = (1<<2)\r
471 };\r
472 \r
473 struct ib_mw_bind {\r
474         struct ib_mr   *mr;\r
475         u64             wr_id;\r
476         u64             addr;\r
477         u32             length;\r
478         int             send_flags;\r
479         int             mw_access_flags;\r
480 };\r
481 \r
482 struct ib_fmr_attr {\r
483         int     max_pages;\r
484         int     max_maps;\r
485         u8      page_shift;\r
486 };\r
487 \r
488 struct ib_ucontext {\r
489         struct ib_device  *device;\r
490         PVOID   user_uar;\r
491         struct ib_pd *pd;\r
492         atomic_t                usecnt; /* count all resources */\r
493         ULONG           is_removing;\r
494         cl_list_item_t list_item;                       // chain of user contexts\r
495         // for tools support\r
496         KMUTEX  mutex;\r
497         PMDL    p_mdl;\r
498         PVOID   va;\r
499         int     fw_if_open;\r
500 };\r
501 \r
502 struct ib_uobject {\r
503         u64                     user_handle;    /* handle given to us by userspace */\r
504         struct ib_ucontext     *context;        /* associated user context */\r
505         struct list_head        list;           /* link to context's list */\r
506         u32                     id;             /* index into kernel idr */\r
507 };\r
508 \r
509 struct ib_umem {\r
510         u64             user_base;\r
511         u64             virt_base;\r
512         u64                     length;\r
513         int                     offset;\r
514         int                     page_size;\r
515         int                     writable;\r
516         struct list_head        chunk_list;\r
517 };\r
518 \r
519 #pragma warning( disable : 4200 )\r
520 struct ib_umem_chunk {\r
521         struct list_head        list;\r
522         int                     nents;\r
523         int                     nmap;\r
524         struct scatterlist      page_list[0];\r
525 };\r
526 #pragma warning( default : 4200 )\r
527 \r
528 #define IB_UMEM_MAX_PAGE_CHUNK                                          \\r
529         ((PAGE_SIZE - offsetof(struct ib_umem_chunk, page_list)) /      \\r
530          ((char *) &((struct ib_umem_chunk *) 0)->page_list[1] -        \\r
531           (char *) &((struct ib_umem_chunk *) 0)->page_list[0]))\r
532 \r
533 struct ib_pd {\r
534         struct list_head        list;           /* for chaining AV MRs (for user mode only) */\r
535         struct ib_device       *device;\r
536         struct ib_ucontext      *ucontext;\r
537         atomic_t                usecnt; /* count all resources */\r
538         KMUTEX mutex;   /* for chaining AV MRs (for user mode only) */\r
539 };\r
540 \r
541 struct ib_ah {\r
542         struct ib_device        *device;\r
543         struct ib_pd            *pd;\r
544         struct ib_ucontext      *ucontext;\r
545 };\r
546 \r
547 typedef void (*ib_comp_handler)(struct ib_cq *cq, void *cq_context);\r
548 \r
549 struct ib_cq {\r
550         struct ib_device       *device;\r
551         struct ib_ucontext      *ucontext;\r
552         struct ib_mr *ib_mr;\r
553         ib_comp_handler         comp_handler;\r
554         void                  (*event_handler)(struct ib_event *, void *);\r
555         void *                  cq_context;\r
556         int                     cqe;\r
557         atomic_t                usecnt; /* count number of work queues */\r
558 };\r
559 \r
560 struct ib_srq {\r
561         struct ib_device       *device;\r
562         struct ib_pd           *pd;\r
563         struct ib_ucontext      *ucontext;\r
564         struct ib_mr *ib_mr;\r
565         void                  (*event_handler)(struct ib_event *, void *);\r
566         void                   *srq_context;\r
567         atomic_t                usecnt; /* count number of work queues */\r
568 };\r
569 \r
570 struct ib_qp {\r
571         struct ib_device       *device;\r
572         struct ib_pd           *pd;\r
573         struct ib_cq           *send_cq;\r
574         struct ib_cq           *recv_cq;\r
575         struct ib_srq          *srq;\r
576         struct ib_ucontext      *ucontext;\r
577         struct ib_mr *ib_mr;\r
578         void                  (*event_handler)(struct ib_event *, void *);\r
579         void                   *qp_context;\r
580         u32                     qp_num;\r
581         enum ib_qp_type_t               qp_type;\r
582 };\r
583 \r
584 struct ib_mr {\r
585         struct list_head        list;           /* for chaining AV MRs (for user mode only) */\r
586         struct ib_device  *device;\r
587         struct ib_pd      *pd;\r
588         u32                lkey;\r
589         u32                rkey;\r
590         atomic_t           usecnt; /* count number of MWs */\r
591 };\r
592 \r
593 struct ib_mw {\r
594         struct ib_device        *device;\r
595         struct ib_pd            *pd;\r
596         u32                     rkey;\r
597 };\r
598 \r
599 struct ib_fmr {\r
600         struct ib_device        *device;\r
601         struct ib_pd            *pd;\r
602         struct list_head        list;\r
603         u32                     lkey;\r
604         u32                     rkey;\r
605 };\r
606 \r
607 struct ib_mad;\r
608 struct ib_grh;\r
609 \r
610 enum ib_process_mad_flags {\r
611         IB_MAD_IGNORE_MKEY      = 1,\r
612         IB_MAD_IGNORE_BKEY      = 2,\r
613         IB_MAD_IGNORE_ALL       = IB_MAD_IGNORE_MKEY | IB_MAD_IGNORE_BKEY\r
614 };\r
615 \r
616 enum ib_mad_result {\r
617         IB_MAD_RESULT_FAILURE  = 0,      /* (!SUCCESS is the important flag) */\r
618         IB_MAD_RESULT_SUCCESS  = 1 << 0, /* MAD was successfully processed   */\r
619         IB_MAD_RESULT_REPLY    = 1 << 1, /* Reply packet needs to be sent    */\r
620         IB_MAD_RESULT_CONSUMED = 1 << 2  /* Packet consumed: stop processing */\r
621 };\r
622 \r
623 #define IB_DEVICE_NAME_MAX 64\r
624 \r
625 struct ib_cache {\r
626         rwlock_t                lock;\r
627         struct ib_event_handler event_handler;\r
628         struct ib_pkey_cache  **pkey_cache;\r
629         struct ib_gid_cache   **gid_cache;\r
630 };\r
631 \r
632 struct mthca_dev;\r
633 \r
634 struct ib_device {\r
635         struct mthca_dev                *mdev;\r
636 \r
637         char                          name[IB_DEVICE_NAME_MAX];\r
638 \r
639         struct list_head              event_handler_list;\r
640         spinlock_t                    event_handler_lock;\r
641 \r
642         struct list_head              core_list;\r
643         struct list_head              client_data_list;\r
644         spinlock_t                    client_data_lock;\r
645 \r
646         struct ib_cache               cache;\r
647 \r
648         u32                           flags;\r
649 \r
650         int                        (*query_device)(struct ib_device *device,\r
651                                                    struct ib_device_attr *device_attr);\r
652         int                        (*query_port)(struct ib_device *device,\r
653                                                  u8 port_num,\r
654                                                  struct ib_port_attr *port_attr);\r
655         int                        (*query_gid_chunk)(struct ib_device *device,\r
656                                                 u8 port_num, int index,\r
657                                                 union ib_gid gid[8]);\r
658         int                        (*query_pkey_chunk)(struct ib_device *device,\r
659                                                  u8 port_num, u16 index, __be16 pkey[32]);\r
660         int                        (*modify_device)(struct ib_device *device,\r
661                                                     int device_modify_mask,\r
662                                                     struct ib_device_modify *device_modify);\r
663         int                        (*modify_port)(struct ib_device *device,\r
664                                                   u8 port_num, int port_modify_mask,\r
665                                                   struct ib_port_modify *port_modify);\r
666         struct ib_ucontext *       (*alloc_ucontext)(struct ib_device *device,\r
667                                                      ci_umv_buf_t* const        p_umv_buf);\r
668         int                        (*dealloc_ucontext)(struct ib_ucontext *context);\r
669         struct ib_pd *             (*alloc_pd)(struct ib_device *device,\r
670                                                struct ib_ucontext *context,\r
671                                                ci_umv_buf_t* const      p_umv_buf);\r
672         int                        (*dealloc_pd)(struct ib_pd *pd);\r
673         struct ib_ah *             (*create_ah)(struct ib_pd *pd,\r
674                                                 struct ib_ah_attr *ah_attr);\r
675         int                        (*modify_ah)(struct ib_ah *ah,\r
676                                                 struct ib_ah_attr *ah_attr);\r
677         int                        (*query_ah)(struct ib_ah *ah,\r
678                                                struct ib_ah_attr *ah_attr);\r
679         int                        (*destroy_ah)(struct ib_ah *ah);\r
680         struct ib_srq *            (*create_srq)(struct ib_pd *pd,\r
681                                                  struct ib_srq_init_attr *srq_init_attr,\r
682                                                  ci_umv_buf_t* const    p_umv_buf);\r
683         int                        (*modify_srq)(struct ib_srq *srq,\r
684                                                  ib_srq_attr_t *srq_attr,\r
685                                                  ib_srq_attr_mask_t srq_attr_mask);\r
686         int                        (*query_srq)(struct ib_srq *srq,\r
687                                                 ib_srq_attr_t *srq_attr);\r
688         int                        (*destroy_srq)(struct ib_srq *srq);\r
689         int                        (*post_srq_recv)(struct ib_srq *srq,\r
690                                                     struct _ib_recv_wr *recv_wr,\r
691                                                     struct _ib_recv_wr **bad_recv_wr);\r
692         struct ib_qp *             (*create_qp)(struct ib_pd *pd,\r
693                                                 struct ib_qp_init_attr *qp_init_attr,\r
694                                                 ci_umv_buf_t* const     p_umv_buf);\r
695         int                        (*modify_qp)(struct ib_qp *qp,\r
696                                                 struct ib_qp_attr *qp_attr,\r
697                                                 int qp_attr_mask);\r
698         int                        (*query_qp)(struct ib_qp *qp,\r
699                                                struct ib_qp_attr *qp_attr,\r
700                                                int qp_attr_mask,\r
701                                                struct ib_qp_init_attr *qp_init_attr);\r
702         int                        (*destroy_qp)(struct ib_qp *qp);\r
703         int                        (*post_send)(struct ib_qp *qp,\r
704                                                 struct _ib_send_wr *send_wr,\r
705                                                 struct _ib_send_wr **bad_send_wr);\r
706         int                        (*post_recv)(struct ib_qp *qp,\r
707                                                 struct _ib_recv_wr *recv_wr,\r
708                                                 struct _ib_recv_wr **bad_recv_wr);\r
709         struct ib_cq *             (*create_cq)(struct ib_device *device, int cqe,\r
710                                                 struct ib_ucontext *context,\r
711                                                 ci_umv_buf_t* const     p_umv_buf);\r
712         int                        (*destroy_cq)(struct ib_cq *cq);\r
713         int                        (*resize_cq)(struct ib_cq *cq, int *cqe);\r
714         int                        (*poll_cq)(struct ib_cq *cq, int num_entries,\r
715                                               struct _ib_wc *wc);\r
716         int                        (*peek_cq)(struct ib_cq *cq, int wc_cnt);\r
717         int                        (*req_notify_cq)(struct ib_cq *cq,\r
718                                                     enum ib_cq_notify cq_notify);\r
719         int                        (*req_ncomp_notif)(struct ib_cq *cq,\r
720                                                       int wc_cnt);\r
721         struct ib_mr *             (*get_dma_mr)(struct ib_pd *pd,\r
722                                                  mthca_qp_access_t mr_access_flags);\r
723         struct ib_mr *             (*reg_phys_mr)(struct ib_pd *pd,\r
724                                                   struct ib_phys_buf *phys_buf_array,\r
725                                                   int num_phys_buf,\r
726                                                   mthca_qp_access_t mr_access_flags,\r
727                                                   u64 *iova_start);\r
728         struct ib_mr *                     (*reg_virt_mr)(struct ib_pd *pd, \r
729                                                 void* vaddr, uint64_t length, uint64_t hca_va,\r
730                                                 mthca_qp_access_t acc, boolean_t um_call, boolean_t secure);\r
731         int                        (*query_mr)(struct ib_mr *mr,\r
732                                                struct ib_mr_attr *mr_attr);\r
733         int                        (*dereg_mr)(struct ib_mr *mr);\r
734         int                        (*rereg_phys_mr)(struct ib_mr *mr,\r
735                                                     int mr_rereg_mask,\r
736                                                     struct ib_pd *pd,\r
737                                                     struct ib_phys_buf *phys_buf_array,\r
738                                                     int num_phys_buf,\r
739                                                     mthca_qp_access_t mr_access_flags,\r
740                                                     u64 *iova_start);\r
741         struct ib_mw *             (*alloc_mw)(struct ib_pd *pd);\r
742         int                        (*bind_mw)(struct ib_qp *qp,\r
743                                               struct ib_mw *mw,\r
744                                               struct ib_mw_bind *mw_bind);\r
745         int                        (*dealloc_mw)(struct ib_mw *mw);\r
746         struct ib_fmr *            (*alloc_fmr)(struct ib_pd *pd,\r
747                                                 mthca_qp_access_t mr_access_flags,\r
748                                                 struct ib_fmr_attr *fmr_attr);\r
749         int                        (*map_phys_fmr)(struct ib_fmr *fmr,\r
750                                                    u64 *page_list, int list_len,\r
751                                                    u64 iova);\r
752         int                        (*unmap_fmr)(struct list_head *fmr_list);\r
753         int                        (*dealloc_fmr)(struct ib_fmr *fmr);\r
754         int                        (*attach_mcast)(struct ib_qp *qp,\r
755                                                    union ib_gid *gid,\r
756                                                    u16 lid);\r
757         int                        (*detach_mcast)(struct ib_qp *qp,\r
758                                                    union ib_gid *gid,\r
759                                                    u16 lid);\r
760         int                        (*process_mad)(struct ib_device *device,\r
761                                                   int process_mad_flags,\r
762                                                   u8 port_num,\r
763                                                   struct _ib_wc *in_wc,\r
764                                                   struct _ib_grh *in_grh,\r
765                                                   struct ib_mad *in_mad,\r
766                                                   struct ib_mad *out_mad);\r
767 \r
768         struct list_head             port_list;\r
769 \r
770         u64                                                             uverbs_cmd_mask;\r
771         __be64                                  node_guid;\r
772         u8                           node_type;\r
773         u8                           phys_port_cnt;\r
774 };\r
775 \r
776 struct ib_client {\r
777         char  *name;\r
778         void (*add)   (struct ib_device *);\r
779         void (*remove)(struct ib_device *);\r
780 \r
781         struct list_head list;\r
782 };\r
783 \r
784 struct ib_device *ib_alloc_device(size_t size);\r
785 void ib_dealloc_device(struct ib_device *device);\r
786 \r
787 int ib_register_device   (struct ib_device *device);\r
788 void ib_unregister_device(struct ib_device *device);\r
789 \r
790 int ib_register_client   (struct ib_client *client);\r
791 void ib_unregister_client(struct ib_client *client);\r
792 \r
793 void *ib_get_client_data(struct ib_device *device, struct ib_client *client);\r
794 void  ib_set_client_data(struct ib_device *device, struct ib_client *client,\r
795                          void *data);\r
796 \r
797 int ib_core_init(void);\r
798 \r
799 void ib_core_cleanup(void);\r
800 \r
801 int ib_register_event_handler  (struct ib_event_handler *event_handler);\r
802 int ib_unregister_event_handler(struct ib_event_handler *event_handler);\r
803 void ib_dispatch_event(struct ib_event *event);\r
804 \r
805 int ib_query_device(struct ib_device *device,\r
806                     struct ib_device_attr *device_attr);\r
807 \r
808 int ib_query_port(struct ib_device *device,\r
809                   u8 port_num, struct ib_port_attr *port_attr);\r
810 \r
811 int ib_query_gid_chunk(struct ib_device *device,\r
812                  u8 port_num, int index, union ib_gid gid[8]);\r
813 \r
814 int ib_query_pkey_chunk(struct ib_device *device,\r
815                   u8 port_num, u16 index, __be16 pkey[32]);\r
816 \r
817 int ib_modify_device(struct ib_device *device,\r
818                      int device_modify_mask,\r
819                      struct ib_device_modify *device_modify);\r
820 \r
821 int ib_modify_port(struct ib_device *device,\r
822                    u8 port_num, int port_modify_mask,\r
823                    struct ib_port_modify *port_modify);\r
824 \r
825 /**\r
826  * ibv_alloc_pd - Allocates an unused protection domain.\r
827  * @device: The device on which to allocate the protection domain.\r
828  * @context: user process context (for application calls only)\r
829  * @p_umv_buf: parameters structure (for application calls only)\r
830  *\r
831  * A protection domain object provides an association between QPs, shared\r
832  * receive queues, address handles, memory regions, and memory windows.\r
833  */\r
834 struct ib_pd *ibv_alloc_pd(struct ib_device *device,\r
835         struct ib_ucontext *context, ci_umv_buf_t* const p_umv_buf);\r
836 \r
837 /**\r
838  * ibv_dealloc_pd - Deallocates a protection domain.\r
839  * @pd: The protection domain to deallocate.\r
840  */\r
841 int ibv_dealloc_pd(struct ib_pd *pd);\r
842 \r
843 /**\r
844  * ibv_create_ah - Creates an address handle for the given address vector.\r
845  * @pd: The protection domain associated with the address handle.\r
846  * @ah_attr: The attributes of the address vector.\r
847  * @context: user process context (for application calls only)\r
848  * @p_umv_buf: parameters structure (for application calls only)\r
849  *\r
850  * The address handle is used to reference a local or global destination\r
851  * in all UD QP post sends.\r
852  */\r
853 struct ib_ah *ibv_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr,\r
854         struct ib_ucontext *context, ci_umv_buf_t* const p_umv_buf);\r
855 \r
856 /**\r
857  * ibv_create_ah_from_wc - Creates an address handle associated with the\r
858  *   sender of the specified work completion.\r
859  * @pd: The protection domain associated with the address handle.\r
860  * @wc: Work completion information associated with a received message.\r
861  * @grh: References the received global route header.  This parameter is\r
862  *   ignored unless the work completion indicates that the GRH is valid.\r
863  * @port_num: The outbound port number to associate with the address.\r
864  *\r
865  * The address handle is used to reference a local or global destination\r
866  * in all UD QP post sends.\r
867  */\r
868 struct ib_ah *ibv_create_ah_from_wc(struct ib_pd *pd, struct _ib_wc *wc,\r
869                                    struct ib_grh *grh, u8 port_num);\r
870 \r
871 /**\r
872  * ibv_modify_ah - Modifies the address vector associated with an address\r
873  *   handle.\r
874  * @ah: The address handle to modify.\r
875  * @ah_attr: The new address vector attributes to associate with the\r
876  *   address handle.\r
877  */\r
878 int ibv_modify_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr);\r
879 \r
880 /**\r
881  * ibv_query_ah - Queries the address vector associated with an address\r
882  *   handle.\r
883  * @ah: The address handle to query.\r
884  * @ah_attr: The address vector attributes associated with the address\r
885  *   handle.\r
886  */\r
887 int ibv_query_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr);\r
888 \r
889 /**\r
890  * ibv_destroy_ah - Destroys an address handle.\r
891  * @ah: The address handle to destroy.\r
892  */\r
893 int ibv_destroy_ah(struct ib_ah *ah);\r
894 \r
895 /**\r
896  * ibv_create_srq - Creates a SRQ associated with the specified protection\r
897  *   domain.\r
898  * @pd: The protection domain associated with the SRQ.\r
899  * @srq_init_attr: A list of initial attributes required to create the\r
900  *   SRQ.  If SRQ creation succeeds, then the attributes are updated to \r
901  *   the actual capabilities of the created SRQ.\r
902  * @context: user process context (for application calls only)\r
903  * @p_umv_buf: parameters structure (for application calls only)\r
904  *\r
905  * srq_attr->max_wr and srq_attr->max_sge are read the determine the\r
906  * requested size of the SRQ, and set to the actual values allocated\r
907  * on return.  If ibv_create_srq() succeeds, then max_wr and max_sge\r
908  * will always be at least as large as the requested values.\r
909  */\r
910 struct ib_srq *ibv_create_srq(struct ib_pd *pd,\r
911         struct ib_srq_init_attr *srq_init_attr,\r
912         struct ib_ucontext *context, ci_umv_buf_t* const p_umv_buf);\r
913 \r
914 \r
915 /**\r
916  * ibv_modify_srq - Modifies the attributes for the specified SRQ.\r
917  * @srq: The SRQ to modify.\r
918  * @srq_attr: On input, specifies the SRQ attributes to modify.  On output,\r
919  *   the current values of selected SRQ attributes are returned.\r
920  * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ\r
921  *   are being modified.\r
922  *\r
923  * The mask may contain IB_SRQ_MAX_WR to resize the SRQ and/or\r
924  * IB_SRQ_LIMIT to set the SRQ's limit and request notification when\r
925  * the number of receives queued drops below the limit.\r
926  */\r
927 int ibv_modify_srq(struct ib_srq *srq,\r
928         ib_srq_attr_t *srq_attr,\r
929         ib_srq_attr_mask_t srq_attr_mask);\r
930 \r
931 /**\r
932  * ibv_query_srq - Returns the attribute list and current values for the\r
933  *   specified SRQ.\r
934  * @srq: The SRQ to query.\r
935  * @srq_attr: The attributes of the specified SRQ.\r
936  */\r
937 int ibv_query_srq(struct ib_srq *srq,\r
938         ib_srq_attr_t *srq_attr);\r
939 \r
940 /**\r
941  * ibv_destroy_srq - Destroys the specified SRQ.\r
942  * @srq: The SRQ to destroy.\r
943  */\r
944 int ibv_destroy_srq(struct ib_srq *srq);\r
945 \r
946 /**\r
947  * ibv_post_srq_recv - Posts a list of work requests to the specified SRQ.\r
948  * @srq: The SRQ to post the work request on.\r
949  * @recv_wr: A list of work requests to post on the receive queue.\r
950  * @bad_recv_wr: On an immediate failure, this parameter will reference\r
951  *   the work request that failed to be posted on the QP.\r
952  */\r
953 static inline int ibv_post_srq_recv(struct ib_srq *srq,\r
954         struct _ib_recv_wr *recv_wr,\r
955         struct _ib_recv_wr **bad_recv_wr)\r
956 {\r
957         return srq->device->post_srq_recv(srq, recv_wr, bad_recv_wr);\r
958 }\r
959 \r
960 /**\r
961  * ibv_create_qp - Creates a QP associated with the specified protection\r
962  *   domain.\r
963  * @pd: The protection domain associated with the QP.\r
964  * @qp_init_attr: A list of initial attributes required to create the\r
965  *   QP.  If QP creation succeeds, then the attributes are updated to\r
966  *   the actual capabilities of the created QP.\r
967  * @context: user process context (for application calls only)\r
968  * @p_umv_buf: parameters structure (for application calls only)\r
969  */\r
970 struct ib_qp *ibv_create_qp(struct ib_pd *pd,\r
971         struct ib_qp_init_attr *qp_init_attr,\r
972         struct ib_ucontext *context, ci_umv_buf_t* const p_umv_buf);\r
973 \r
974 /**\r
975  * ibv_modify_qp - Modifies the attributes for the specified QP and then\r
976  *   transitions the QP to the given state.\r
977  * @qp: The QP to modify.\r
978  * @qp_attr: On input, specifies the QP attributes to modify.  On output,\r
979  *   the current values of selected QP attributes are returned.\r
980  * @qp_attr_mask: A bit-mask used to specify which attributes of the QP\r
981  *   are being modified.\r
982  */\r
983 int ibv_modify_qp(struct ib_qp *qp,\r
984                  struct ib_qp_attr *qp_attr,\r
985                  int qp_attr_mask);\r
986 \r
987 /**\r
988  * ibv_query_qp - Returns the attribute list and current values for the\r
989  *   specified QP.\r
990  * @qp: The QP to query.\r
991  * @qp_attr: The attributes of the specified QP.\r
992  * @qp_attr_mask: A bit-mask used to select specific attributes to query.\r
993  * @qp_init_attr: Additional attributes of the selected QP.\r
994  *\r
995  * The qp_attr_mask may be used to limit the query to gathering only the\r
996  * selected attributes.\r
997  */\r
998 int ibv_query_qp(struct ib_qp *qp,\r
999                 struct ib_qp_attr *qp_attr,\r
1000                 int qp_attr_mask,\r
1001                 struct ib_qp_init_attr *qp_init_attr);\r
1002 \r
1003 /**\r
1004  * ibv_destroy_qp - Destroys the specified QP.\r
1005  * @qp: The QP to destroy.\r
1006  */\r
1007 int ibv_destroy_qp(struct ib_qp *qp);\r
1008 \r
1009 /**\r
1010  * ib_post_send - Posts a list of work requests to the send queue of\r
1011  *   the specified QP.\r
1012  * @qp: The QP to post the work request on.\r
1013  * @send_wr: A list of work requests to post on the send queue.\r
1014  * @bad_send_wr: On an immediate failure, this parameter will reference\r
1015  *   the work request that failed to be posted on the QP.\r
1016  */\r
1017 static inline int ib_post_send(struct ib_qp *qp,\r
1018                                struct _ib_send_wr *send_wr,\r
1019                                struct _ib_send_wr **bad_send_wr)\r
1020 {\r
1021         return qp->device->post_send(qp, send_wr, bad_send_wr);\r
1022 }\r
1023 \r
1024 /**\r
1025  * ib_post_recv - Posts a list of work requests to the receive queue of\r
1026  *   the specified QP.\r
1027  * @qp: The QP to post the work request on.\r
1028  * @recv_wr: A list of work requests to post on the receive queue.\r
1029  * @bad_recv_wr: On an immediate failure, this parameter will reference\r
1030  *   the work request that failed to be posted on the QP.\r
1031  */\r
1032 static inline int ib_post_recv(struct ib_qp *qp,\r
1033                                struct _ib_recv_wr *recv_wr,\r
1034                                struct _ib_recv_wr **bad_recv_wr)\r
1035 {\r
1036         return qp->device->post_recv(qp, recv_wr, bad_recv_wr);\r
1037 }\r
1038 \r
1039 /**\r
1040  * ibv_create_cq - Creates a CQ on the specified device.\r
1041  * @device: The device on which to create the CQ.\r
1042  * @comp_handler: A user-specified callback that is invoked when a\r
1043  *   completion event occurs on the CQ.\r
1044  * @event_handler: A user-specified callback that is invoked when an\r
1045  *   asynchronous event not associated with a completion occurs on the CQ.\r
1046  * @cq_context: Context associated with the CQ returned to the user via\r
1047  *   the associated completion and event handlers.\r
1048  * @cqe: The minimum size of the CQ.\r
1049  * @context: user process context (for application calls only)\r
1050  * @p_umv_buf: parameters structure (for application calls only)\r
1051  *\r
1052  * Users can examine the cq structure to determine the actual CQ size.\r
1053  */\r
1054 struct ib_cq *ibv_create_cq(struct ib_device *device,\r
1055                            ib_comp_handler comp_handler,\r
1056                            void (*event_handler)(struct ib_event *, void *),\r
1057                            void *cq_context, int cqe, \r
1058                            struct ib_ucontext *context, ci_umv_buf_t* const p_umv_buf);\r
1059 \r
1060 /**\r
1061  * ibv_resize_cq - Modifies the capacity of the CQ.\r
1062  * @cq: The CQ to resize.\r
1063  * @cqe: The minimum size of the CQ.\r
1064  *\r
1065  * Users can examine the cq structure to determine the actual CQ size.\r
1066  */\r
1067 int ibv_resize_cq(struct ib_cq *cq, int cqe);\r
1068 \r
1069 /**\r
1070  * ibv_destroy_cq - Destroys the specified CQ.\r
1071  * @cq: The CQ to destroy.\r
1072  */\r
1073 int ibv_destroy_cq(struct ib_cq *cq);\r
1074 \r
1075 /**\r
1076  * ib_poll_cq - poll a CQ for completion(s)\r
1077  * @cq:the CQ being polled\r
1078  * @num_entries:maximum number of completions to return\r
1079  * @wc:array of at least @num_entries &struct _ib_wc where completions\r
1080  *   will be returned\r
1081  *\r
1082  * Poll a CQ for (possibly multiple) completions.  If the return value\r
1083  * is < 0, an error occurred.  If the return value is >= 0, it is the\r
1084  * number of completions returned.  If the return value is\r
1085  * non-negative and < num_entries, then the CQ was emptied.\r
1086  */\r
1087 static inline int ib_poll_cq(struct ib_cq *cq, int num_entries,\r
1088                              struct _ib_wc *wc)\r
1089 {\r
1090         return cq->device->poll_cq(cq, num_entries, wc);\r
1091 }\r
1092 \r
1093 /**\r
1094  * ib_peek_cq - Returns the number of unreaped completions currently\r
1095  *   on the specified CQ.\r
1096  * @cq: The CQ to peek.\r
1097  * @wc_cnt: A minimum number of unreaped completions to check for.\r
1098  *\r
1099  * If the number of unreaped completions is greater than or equal to wc_cnt,\r
1100  * this function returns wc_cnt, otherwise, it returns the actual number of\r
1101  * unreaped completions.\r
1102  */\r
1103 int ib_peek_cq(struct ib_cq *cq, int wc_cnt);\r
1104 \r
1105 /**\r
1106  * ib_req_notify_cq - Request completion notification on a CQ.\r
1107  * @cq: The CQ to generate an event for.\r
1108  * @cq_notify: If set to %IB_CQ_SOLICITED, completion notification will\r
1109  *   occur on the next solicited event. If set to %IB_CQ_NEXT_COMP,\r
1110  *   notification will occur on the next completion.\r
1111  */\r
1112 static inline int ib_req_notify_cq(struct ib_cq *cq,\r
1113                                    enum ib_cq_notify cq_notify)\r
1114 {\r
1115         return cq->device->req_notify_cq(cq, cq_notify);\r
1116 }\r
1117 \r
1118 /**\r
1119  * ib_req_ncomp_notif - Request completion notification when there are\r
1120  *   at least the specified number of unreaped completions on the CQ.\r
1121  * @cq: The CQ to generate an event for.\r
1122  * @wc_cnt: The number of unreaped completions that should be on the\r
1123  *   CQ before an event is generated.\r
1124  */\r
1125 static inline int ib_req_ncomp_notif(struct ib_cq *cq, int wc_cnt)\r
1126 {\r
1127         return cq->device->req_ncomp_notif ?\r
1128                 cq->device->req_ncomp_notif(cq, wc_cnt) :\r
1129                 -ENOSYS;\r
1130 }\r
1131 \r
1132 /**\r
1133  * ibv_reg_mr - Prepares a virtually addressed memory region for use\r
1134  *   by an HCA.\r
1135  * @pd: The protection domain associated assigned to the registered region.\r
1136  * @vaddr: virtual address of the region\r
1137  * @length: Specifies the size of the region.\r
1138  * @hca_va: virtual address in HCA\r
1139  * @mr_access_flags: Specifies the memory access rights.\r
1140  * @um_call: call from user, when TRUE.\r
1141  * @secure: secure the memory from releasing (only for um_call == TRUE)\r
1142  */\r
1143 struct ib_mr *ibv_reg_mr(struct ib_pd *pd, \r
1144         mthca_qp_access_t mr_access_flags,\r
1145         void*                                   vaddr,\r
1146         uint64_t                                length,\r
1147         uint64_t                                hca_va,\r
1148         boolean_t                               um_call,\r
1149         boolean_t                               secure\r
1150         );\r
1151 \r
1152 /**\r
1153  * ibv_get_dma_mr - Returns a memory region for system memory that is\r
1154  *   usable for DMA.\r
1155  * @pd: The protection domain associated with the memory region.\r
1156  * @mr_access_flags: Specifies the memory access rights.\r
1157  */\r
1158 struct ib_mr *ibv_get_dma_mr(struct ib_pd *pd, mthca_qp_access_t mr_access_flags);\r
1159 \r
1160 /**\r
1161  * ibv_reg_phys_mr - Prepares a virtually addressed memory region for use\r
1162  *   by an HCA.\r
1163  * @pd: The protection domain associated assigned to the registered region.\r
1164  * @phys_buf_array: Specifies a list of physical buffers to use in the\r
1165  *   memory region.\r
1166  * @num_phys_buf: Specifies the size of the phys_buf_array.\r
1167  * @mr_access_flags: Specifies the memory access rights.\r
1168  * @iova_start: The offset of the region's starting I/O virtual address.\r
1169  */\r
1170 struct ib_mr *ibv_reg_phys_mr(struct ib_pd *pd,\r
1171                              struct ib_phys_buf *phys_buf_array,\r
1172                              int num_phys_buf,\r
1173                              mthca_qp_access_t mr_access_flags,\r
1174                              u64 *iova_start);\r
1175 \r
1176 /**\r
1177  * ibv_rereg_phys_mr - Modifies the attributes of an existing memory region.\r
1178  *   Conceptually, this call performs the functions deregister memory region\r
1179  *   followed by register physical memory region.  Where possible,\r
1180  *   resources are reused instead of deallocated and reallocated.\r
1181  * @mr: The memory region to modify.\r
1182  * @mr_rereg_mask: A bit-mask used to indicate which of the following\r
1183  *   properties of the memory region are being modified.\r
1184  * @pd: If %IB_MR_REREG_PD is set in mr_rereg_mask, this field specifies\r
1185  *   the new protection domain to associated with the memory region,\r
1186  *   otherwise, this parameter is ignored.\r
1187  * @phys_buf_array: If %IB_MR_REREG_TRANS is set in mr_rereg_mask, this\r
1188  *   field specifies a list of physical buffers to use in the new\r
1189  *   translation, otherwise, this parameter is ignored.\r
1190  * @num_phys_buf: If %IB_MR_REREG_TRANS is set in mr_rereg_mask, this\r
1191  *   field specifies the size of the phys_buf_array, otherwise, this\r
1192  *   parameter is ignored.\r
1193  * @mr_access_flags: If %IB_MR_REREG_ACCESS is set in mr_rereg_mask, this\r
1194  *   field specifies the new memory access rights, otherwise, this\r
1195  *   parameter is ignored.\r
1196  * @iova_start: The offset of the region's starting I/O virtual address.\r
1197  */\r
1198 int ibv_rereg_phys_mr(struct ib_mr *mr,\r
1199                      int mr_rereg_mask,\r
1200                      struct ib_pd *pd,\r
1201                      struct ib_phys_buf *phys_buf_array,\r
1202                      int num_phys_buf,\r
1203                      mthca_qp_access_t mr_access_flags,\r
1204                      u64 *iova_start);\r
1205 \r
1206 /**\r
1207  * ibv_query_mr - Retrieves information about a specific memory region.\r
1208  * @mr: The memory region to retrieve information about.\r
1209  * @mr_attr: The attributes of the specified memory region.\r
1210  */\r
1211 int ibv_query_mr(struct ib_mr *mr, struct ib_mr_attr *mr_attr);\r
1212 \r
1213 /**\r
1214  * ibv_dereg_mr - Deregisters a memory region and removes it from the\r
1215  *   HCA translation table.\r
1216  * @mr: The memory region to deregister.\r
1217  */\r
1218 int ibv_dereg_mr(struct ib_mr *mr);\r
1219 \r
1220 /**\r
1221  * ibv_alloc_mw - Allocates a memory window.\r
1222  * @pd: The protection domain associated with the memory window.\r
1223  */\r
1224 struct ib_mw *ibv_alloc_mw(struct ib_pd *pd);\r
1225 \r
1226 /**\r
1227  * ib_bind_mw - Posts a work request to the send queue of the specified\r
1228  *   QP, which binds the memory window to the given address range and\r
1229  *   remote access attributes.\r
1230  * @qp: QP to post the bind work request on.\r
1231  * @mw: The memory window to bind.\r
1232  * @mw_bind: Specifies information about the memory window, including\r
1233  *   its address range, remote access rights, and associated memory region.\r
1234  */\r
1235 static inline int ib_bind_mw(struct ib_qp *qp,\r
1236                              struct ib_mw *mw,\r
1237                              struct ib_mw_bind *mw_bind)\r
1238 {\r
1239         /* XXX reference counting in corresponding MR? */\r
1240         return mw->device->bind_mw ?\r
1241                 mw->device->bind_mw(qp, mw, mw_bind) :\r
1242                 -ENOSYS;\r
1243 }\r
1244 \r
1245 /**\r
1246  * ibv_dealloc_mw - Deallocates a memory window.\r
1247  * @mw: The memory window to deallocate.\r
1248  */\r
1249 int ibv_dealloc_mw(struct ib_mw *mw);\r
1250 \r
1251 /**\r
1252  * ibv_alloc_fmr - Allocates a unmapped fast memory region.\r
1253  * @pd: The protection domain associated with the unmapped region.\r
1254  * @mr_access_flags: Specifies the memory access rights.\r
1255  * @fmr_attr: Attributes of the unmapped region.\r
1256  *\r
1257  * A fast memory region must be mapped before it can be used as part of\r
1258  * a work request.\r
1259  */\r
1260 struct ib_fmr *ibv_alloc_fmr(struct ib_pd *pd,\r
1261                             mthca_qp_access_t mr_access_flags,\r
1262                             struct ib_fmr_attr *fmr_attr);\r
1263 \r
1264 /**\r
1265  * ib_map_phys_fmr - Maps a list of physical pages to a fast memory region.\r
1266  * @fmr: The fast memory region to associate with the pages.\r
1267  * @page_list: An array of physical pages to map to the fast memory region.\r
1268  * @list_len: The number of pages in page_list.\r
1269  * @iova: The I/O virtual address to use with the mapped region.\r
1270  */\r
1271 int ibv_map_phys_fmr(struct ib_fmr *fmr,\r
1272                                   u64 *page_list, int list_len,\r
1273                                   u64 iova);\r
1274 \r
1275 /**\r
1276  * ibv_unmap_fmr - Removes the mapping from a list of fast memory regions.\r
1277  * @fmr_list: A linked list of fast memory regions to unmap.\r
1278  */\r
1279 int ibv_unmap_fmr(struct list_head *fmr_list);\r
1280 \r
1281 /**\r
1282  * ibv_dealloc_fmr - Deallocates a fast memory region.\r
1283  * @fmr: The fast memory region to deallocate.\r
1284  */\r
1285 int ibv_dealloc_fmr(struct ib_fmr *fmr);\r
1286 \r
1287 /**\r
1288  * ibv_attach_mcast - Attaches the specified QP to a multicast group.\r
1289  * @qp: QP to attach to the multicast group.  The QP must be type\r
1290  *   IB_QPT_UNRELIABLE_DGRM.\r
1291  * @gid: Multicast group GID.\r
1292  * @lid: Multicast group LID in host byte order.\r
1293  *\r
1294  * In order to send and receive multicast packets, subnet\r
1295  * administration must have created the multicast group and configured\r
1296  * the fabric appropriately.  The port associated with the specified\r
1297  * QP must also be a member of the multicast group.\r
1298  */\r
1299 int ibv_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);\r
1300 \r
1301 /**\r
1302  * ibv_detach_mcast - Detaches the specified QP from a multicast group.\r
1303  * @qp: QP to detach from the multicast group.\r
1304  * @gid: Multicast group GID.\r
1305  * @lid: Multicast group LID in host byte order.\r
1306  */\r
1307 int ibv_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);\r
1308 \r
1309 /**\r
1310  * ibv_um_close - Releases application.\r
1311  * @h_um_ca: application context\r
1312  */\r
1313 void ibv_um_close(struct ib_ucontext * h_um_ca);\r
1314 \r
1315 #endif /* IB_VERBS_H */\r