[MLX4] Soft Reset: (bugfix in error flow) handling a case when MLX4_BUS fails during...
[mirror/winof/.git] / hw / mlx4 / kernel / bus / inc / 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, 2006, 2007 Cisco Systems.  All rights reserved.\r
9  *\r
10  * This software is available to you under a choice of one of two\r
11  * licenses.  You may choose to be licensed under the terms of the GNU\r
12  * General Public License (GPL) Version 2, available from the file\r
13  * COPYING in the main directory of this source tree, or the\r
14  * OpenIB.org BSD license below:\r
15  *\r
16  *     Redistribution and use in source and binary forms, with or\r
17  *     without modification, are permitted provided that the following\r
18  *     conditions are met:\r
19  *\r
20  *      - Redistributions of source code must retain the above\r
21  *        copyright notice, this list of conditions and the following\r
22  *        disclaimer.\r
23  *\r
24  *      - Redistributions in binary form must reproduce the above\r
25  *        copyright notice, this list of conditions and the following\r
26  *        disclaimer in the documentation and/or other materials\r
27  *        provided with the distribution.\r
28  *\r
29  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
30  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
31  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
32  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
33  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
34  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
35  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
36  * SOFTWARE.\r
37  *\r
38  * $Id: ib_verbs.h 1349 2004-12-16 21:09:43Z roland $\r
39  */\r
40 \r
41 #if !defined(IB_VERBS_H)\r
42 #define IB_VERBS_H\r
43 \r
44 #include <iba\ib_ci.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 #include "ib_verbs_ex.h"\r
55 \r
56 enum rdma_node_type {\r
57         /* IB values map to NodeInfo:NodeType. */\r
58         RDMA_NODE_IB_CA         = 1,\r
59         RDMA_NODE_IB_SWITCH,\r
60         RDMA_NODE_IB_ROUTER,\r
61         RDMA_NODE_RNIC\r
62 };\r
63 \r
64 enum rdma_transport_type {\r
65         RDMA_TRANSPORT_IB,\r
66         RDMA_TRANSPORT_IWARP\r
67 };\r
68 \r
69 enum rdma_transport_type\r
70 rdma_node_get_transport(enum rdma_node_type node_type) __attribute_const__;\r
71 \r
72 enum ib_device_cap_flags {\r
73         IB_DEVICE_RESIZE_MAX_WR         = 1,\r
74         IB_DEVICE_BAD_PKEY_CNTR         = (1<<1),\r
75         IB_DEVICE_BAD_QKEY_CNTR         = (1<<2),\r
76         IB_DEVICE_RAW_MULTI             = (1<<3),\r
77         IB_DEVICE_AUTO_PATH_MIG         = (1<<4),\r
78         IB_DEVICE_CHANGE_PHY_PORT       = (1<<5),\r
79         IB_DEVICE_UD_AV_PORT_ENFORCE    = (1<<6),\r
80         IB_DEVICE_CURR_QP_STATE_MOD     = (1<<7),\r
81         IB_DEVICE_SHUTDOWN_PORT         = (1<<8),\r
82         IB_DEVICE_INIT_TYPE             = (1<<9),\r
83         IB_DEVICE_PORT_ACTIVE_EVENT     = (1<<10),\r
84         IB_DEVICE_SYS_IMAGE_GUID        = (1<<11),\r
85         IB_DEVICE_RC_RNR_NAK_GEN        = (1<<12),\r
86         IB_DEVICE_SRQ_RESIZE            = (1<<13),\r
87         IB_DEVICE_N_NOTIFY_CQ           = (1<<14),\r
88         IB_DEVICE_ZERO_STAG                     = (1<<15),\r
89         IB_DEVICE_SEND_W_INV            = (1<<16),\r
90         IB_DEVICE_MEM_WINDOW            = (1<<17),\r
91         IB_DEVICE_IPOIB_CSUM            = (1<<18),\r
92         IB_DEVICE_UD_TSO                        = (1<<19)\r
93 };\r
94 \r
95 enum ib_atomic_cap {\r
96         IB_ATOMIC_NON,\r
97         IB_ATOMIC_HCA,\r
98         IB_ATOMIC_GLOB\r
99 };\r
100 \r
101 struct ib_device_attr {\r
102         u64                     fw_ver;\r
103         __be64                  sys_image_guid;\r
104         u64                     max_mr_size;\r
105         u64                     page_size_cap;\r
106         u32                     vendor_id;\r
107         u32                     vendor_part_id;\r
108         u32                     hw_ver;\r
109         int                     max_qp;\r
110         int                     max_qp_wr;\r
111         int                     device_cap_flags;\r
112         int                     max_sge;\r
113         int                     max_sge_rd;\r
114         int                     max_cq;\r
115         int                     max_cqe;\r
116         int                     max_mr;\r
117         int                     max_pd;\r
118         int                     max_qp_rd_atom;\r
119         int                     max_ee_rd_atom;\r
120         int                     max_res_rd_atom;\r
121         int                     max_qp_init_rd_atom;\r
122         int                     max_ee_init_rd_atom;\r
123         enum ib_atomic_cap      atomic_cap;\r
124         int                     max_ee;\r
125         int                     max_rdd;\r
126         int                     max_mw;\r
127         int                     max_raw_ipv6_qp;\r
128         int                     max_raw_ethy_qp;\r
129         int                     max_mcast_grp;\r
130         int                     max_mcast_qp_attach;\r
131         int                     max_total_mcast_qp_attach;\r
132         u64                     max_ah;\r
133         int                     max_fmr;\r
134         int                     max_map_per_fmr;\r
135         int                     max_srq;\r
136         int                     max_srq_wr;\r
137         int                     max_srq_sge;\r
138         u16                     max_pkeys;\r
139         u8                      local_ca_ack_delay;\r
140 };\r
141 \r
142 enum ib_mtu {\r
143         IB_MTU_256  = 1,\r
144         IB_MTU_512  = 2,\r
145         IB_MTU_1024 = 3,\r
146         IB_MTU_2048 = 4,\r
147         IB_MTU_4096 = 5\r
148 };\r
149 \r
150 static inline int ib_mtu_enum_to_int(enum ib_mtu mtu)\r
151 {\r
152         switch (mtu) {\r
153         case IB_MTU_256:  return  256;\r
154         case IB_MTU_512:  return  512;\r
155         case IB_MTU_1024: return 1024;\r
156         case IB_MTU_2048: return 2048;\r
157         case IB_MTU_4096: return 4096;\r
158         default:          return -1;\r
159         }\r
160 }\r
161 \r
162 enum ib_port_state {\r
163         IB_PORT_NOP             = 0,\r
164         IB_PORT_DOWN            = 1,\r
165         IB_PORT_INIT            = 2,\r
166         IB_PORT_ARMED           = 3,\r
167         IB_PORT_ACTIVE          = 4,\r
168         IB_PORT_ACTIVE_DEFER    = 5\r
169 };\r
170 \r
171 enum ib_port_cap_flags {\r
172         IB_PORT_SM                              = 1 <<  1,\r
173         IB_PORT_NOTICE_SUP                      = 1 <<  2,\r
174         IB_PORT_TRAP_SUP                        = 1 <<  3,\r
175         IB_PORT_OPT_IPD_SUP                     = 1 <<  4,\r
176         IB_PORT_AUTO_MIGR_SUP                   = 1 <<  5,\r
177         IB_PORT_SL_MAP_SUP                      = 1 <<  6,\r
178         IB_PORT_MKEY_NVRAM                      = 1 <<  7,\r
179         IB_PORT_PKEY_NVRAM                      = 1 <<  8,\r
180         IB_PORT_LED_INFO_SUP                    = 1 <<  9,\r
181         IB_PORT_SM_DISABLED                     = 1 << 10,\r
182         IB_PORT_SYS_IMAGE_GUID_SUP              = 1 << 11,\r
183         IB_PORT_PKEY_SW_EXT_PORT_TRAP_SUP       = 1 << 12,\r
184         IB_PORT_CM_SUP                          = 1 << 16,\r
185         IB_PORT_SNMP_TUNNEL_SUP                 = 1 << 17,\r
186         IB_PORT_REINIT_SUP                      = 1 << 18,\r
187         IB_PORT_DEVICE_MGMT_SUP                 = 1 << 19,\r
188         IB_PORT_VENDOR_CLASS_SUP                = 1 << 20,\r
189         IB_PORT_DR_NOTICE_SUP                   = 1 << 21,\r
190         IB_PORT_CAP_MASK_NOTICE_SUP             = 1 << 22,\r
191         IB_PORT_BOOT_MGMT_SUP                   = 1 << 23,\r
192         IB_PORT_LINK_LATENCY_SUP                = 1 << 24,\r
193         IB_PORT_CLIENT_REG_SUP                  = 1 << 25\r
194 };\r
195 \r
196 enum ib_port_width {\r
197         IB_WIDTH_1X     = 1,\r
198         IB_WIDTH_4X     = 2,\r
199         IB_WIDTH_8X     = 4,\r
200         IB_WIDTH_12X    = 8\r
201 };\r
202 \r
203 static inline int ib_width_enum_to_int(enum ib_port_width width)\r
204 {\r
205         switch (width) {\r
206         case IB_WIDTH_1X:  return  1;\r
207         case IB_WIDTH_4X:  return  4;\r
208         case IB_WIDTH_8X:  return  8;\r
209         case IB_WIDTH_12X: return 12;\r
210         default:          return -1;\r
211         }\r
212 }\r
213 \r
214 struct ib_port_attr {\r
215         enum ib_port_state      state;\r
216         enum ib_mtu             max_mtu;\r
217         enum ib_mtu             active_mtu;\r
218         int                     gid_tbl_len;\r
219         u32                     port_cap_flags;\r
220         u32                     max_msg_sz;\r
221         u32                     bad_pkey_cntr;\r
222         u32                     qkey_viol_cntr;\r
223         u16                     pkey_tbl_len;\r
224         u16                     lid;\r
225         u16                     sm_lid;\r
226         u8                      lmc;\r
227         u8                      max_vl_num;\r
228         u8                      sm_sl;\r
229         u8                      subnet_timeout;\r
230         u8                      init_type_reply;\r
231         u8                      active_width;\r
232         u8                      active_speed;\r
233         u8                      phys_state;\r
234 };\r
235 \r
236 enum ib_device_modify_flags {\r
237         IB_DEVICE_MODIFY_SYS_IMAGE_GUID = 1 << 0,\r
238         IB_DEVICE_MODIFY_NODE_DESC      = 1 << 1\r
239 };\r
240 \r
241 struct ib_device_modify {\r
242         u64     sys_image_guid;\r
243         char    node_desc[64];\r
244 };\r
245 \r
246 enum ib_port_modify_flags {\r
247         IB_PORT_SHUTDOWN                = 1,\r
248         IB_PORT_INIT_TYPE               = (1<<2),\r
249         IB_PORT_RESET_QKEY_CNTR         = (1<<3)\r
250 };\r
251 \r
252 struct ib_port_modify {\r
253         u32     set_port_cap_mask;\r
254         u32     clr_port_cap_mask;\r
255         u8      init_type;\r
256 };\r
257 \r
258 enum ib_event_type {\r
259         IB_EVENT_CQ_ERR                                         = IB_AE_CQ_ERROR,\r
260         IB_EVENT_QP_FATAL                                       = IB_AE_QP_FATAL,\r
261         IB_EVENT_QP_REQ_ERR                                     = IB_AE_WQ_REQ_ERROR,\r
262         IB_EVENT_QP_ACCESS_ERR                          = IB_AE_WQ_ACCESS_ERROR,\r
263         IB_EVENT_COMM_EST                                       = IB_AE_QP_COMM,\r
264         IB_EVENT_SQ_DRAINED                                     = IB_AE_SQ_DRAINED,\r
265         IB_EVENT_PATH_MIG                                       = IB_AE_QP_APM,\r
266         IB_EVENT_PATH_MIG_ERR                           = IB_AE_QP_APM_ERROR,\r
267         IB_EVENT_DEVICE_FATAL                           = IB_AE_LOCAL_FATAL,\r
268         IB_EVENT_PORT_ACTIVE                            = IB_AE_PORT_ACTIVE,\r
269         IB_EVENT_PORT_ERR                                       = IB_AE_PORT_DOWN,\r
270         IB_EVENT_SRQ_LIMIT_REACHED                      = IB_AE_SRQ_LIMIT_REACHED,\r
271         IB_EVENT_SRQ_ERR                                        = IB_AE_SRQ_CATAS_ERROR,\r
272         IB_EVENT_QP_LAST_WQE_REACHED            = IB_AE_SRQ_QP_LAST_WQE_REACHED,\r
273         IB_EVENT_RESET_DRIVER                           = IB_AE_RESET_DRIVER,   // device will be reset upon fatal error\r
274         IB_EVENT_RESET_CLIENT                           = IB_AE_RESET_CLIENT,   // device will be reset upon client request\r
275         IB_EVENT_RESET_END                                      = IB_AE_RESET_END,              // device has been reset \r
276         IB_EVENT_RESET_FAILED                           = IB_AE_RESET_FAILED,           // device has been reset \r
277         IB_EVENT_LID_CHANGE                                     = IB_AE_UNKNOWN + 1,\r
278         IB_EVENT_PKEY_CHANGE,\r
279         IB_EVENT_SM_CHANGE,\r
280         IB_EVENT_CLIENT_REREGISTER\r
281 };\r
282 \r
283 struct ib_event {\r
284         struct ib_device        *device;\r
285         union {\r
286                 struct ib_cq    *cq;\r
287                 struct ib_qp    *qp;\r
288                 struct ib_srq   *srq;\r
289                 u8              port_num;\r
290         } element;\r
291         enum ib_event_type      event;\r
292         struct ib_event_ex      x;\r
293 };\r
294 \r
295 enum ib_event_handler_flags {\r
296         IB_IVH_RESET_CB         = (1 << 0),\r
297         IB_IVH_NOTIFIED         = (1 << 1),\r
298         IB_IVH_RESET_READY      = (1 << 2)\r
299 };\r
300 \r
301 \r
302 struct ib_event_handler {\r
303         struct ib_device *device;\r
304         void            (*handler)(struct ib_event_handler *, struct ib_event *);\r
305         struct list_head  list;\r
306         void *            ctx;\r
307         void *            rsrv_ptr;\r
308         u32               flags;\r
309 };\r
310 \r
311 #define INIT_IB_EVENT_HANDLER(_ptr, _device, _handler, _ctx, _rptr, _flags)             \\r
312         {                                                       \\r
313                 (_ptr)->device  = _device;                      \\r
314                 (_ptr)->handler = _handler;             \\r
315                 INIT_LIST_HEAD(&(_ptr)->list);          \\r
316                 (_ptr)->ctx = _ctx;             \\r
317                 (_ptr)->rsrv_ptr = _rptr;               \\r
318                 (_ptr)->flags = _flags;                 \\r
319         }\r
320 \r
321 struct ib_global_route {\r
322         union ib_gid    dgid;\r
323         u32             flow_label;\r
324         u8              sgid_index;\r
325         u8              hop_limit;\r
326         u8              traffic_class;\r
327 };\r
328 \r
329 struct ib_grh {\r
330         __be32          version_tclass_flow;\r
331         __be16          paylen;\r
332         u8              next_hdr;\r
333         u8              hop_limit;\r
334         union ib_gid    sgid;\r
335         union ib_gid    dgid;\r
336 };\r
337 \r
338 enum {\r
339         IB_MULTICAST_QPN = 0xffffff\r
340 };\r
341 \r
342 #define XIB_LID_PERMISSIVE      __constant_htons(0xFFFF)\r
343 \r
344 enum ib_ah_flags {\r
345         IB_AH_GRH       = 1\r
346 };\r
347 \r
348 enum ib_rate {\r
349         IB_RATE_PORT_CURRENT = 0,\r
350         IB_RATE_2_5_GBPS = 2,\r
351         IB_RATE_5_GBPS   = 5,\r
352         IB_RATE_10_GBPS  = 3,\r
353         IB_RATE_20_GBPS  = 6,\r
354         IB_RATE_30_GBPS  = 4,\r
355         IB_RATE_40_GBPS  = 7,\r
356         IB_RATE_60_GBPS  = 8,\r
357         IB_RATE_80_GBPS  = 9,\r
358         IB_RATE_120_GBPS = 10\r
359 };\r
360 \r
361 /**\r
362  * ib_rate_to_mult - Convert the IB rate enum to a multiple of the\r
363  * base rate of 2.5 Gbit/sec.  For example, IB_RATE_5_GBPS will be\r
364  * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.\r
365  * @rate: rate to convert.\r
366  */\r
367 int ib_rate_to_mult(enum ib_rate rate) __attribute_const__;\r
368 \r
369 /**\r
370  * mult_to_ib_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate\r
371  * enum.\r
372  * @mult: multiple to convert.\r
373  */\r
374 enum ib_rate mult_to_ib_rate(int mult) __attribute_const__;\r
375 \r
376 struct ib_ah_attr {\r
377         struct ib_global_route  grh;\r
378         u16                     dlid;\r
379         u8                      sl;\r
380         u8                      src_path_bits;\r
381         u8                      static_rate;\r
382         u8                      ah_flags;\r
383         u8                      port_num;\r
384 };\r
385 \r
386 enum ib_wc_status {\r
387         IB_WC_SUCCESS,\r
388         IB_WC_LOC_LEN_ERR,\r
389         IB_WC_LOC_QP_OP_ERR,\r
390         IB_WC_LOC_EEC_OP_ERR,\r
391         IB_WC_LOC_PROT_ERR,\r
392         IB_WC_WR_FLUSH_ERR,\r
393         IB_WC_MW_BIND_ERR,\r
394         IB_WC_BAD_RESP_ERR,\r
395         IB_WC_LOC_ACCESS_ERR,\r
396         IB_WC_REM_INV_REQ_ERR,\r
397         IB_WC_REM_ACCESS_ERR,\r
398         IB_WC_REM_OP_ERR,\r
399         IB_WC_RETRY_EXC_ERR,\r
400         IB_WC_RNR_RETRY_EXC_ERR,\r
401         IB_WC_LOC_RDD_VIOL_ERR,\r
402         IB_WC_REM_INV_RD_REQ_ERR,\r
403         IB_WC_REM_ABORT_ERR,\r
404         IB_WC_INV_EECN_ERR,\r
405         IB_WC_INV_EEC_STATE_ERR,\r
406         IB_WC_FATAL_ERR,\r
407         IB_WC_RESP_TIMEOUT_ERR,\r
408         IB_WC_GENERAL_ERR\r
409 };\r
410 \r
411 enum ib_wc_opcode {\r
412         XIB_WC_SEND,\r
413         XIB_WC_RDMA_WRITE,\r
414         XIB_WC_RDMA_READ,\r
415         XIB_WC_COMP_SWAP,\r
416         XIB_WC_FETCH_ADD,\r
417         XIB_WC_BIND_MW,\r
418         XIB_WC_LSO, //for Linux compatibility\r
419 /*\r
420  * Set value of XIB_WC_RECV so consumers can test if a completion is a\r
421  * receive by testing (opcode & XIB_WC_RECV).\r
422  */\r
423         XIB_WC_RECV                     = 1 << 7,\r
424         XIB_WC_RECV_RDMA_WITH_IMM\r
425 };\r
426 \r
427 enum ib_wc_flags {\r
428         IB_WC_GRH               = 1,\r
429         IB_WC_WITH_IMM          = (1<<1),\r
430         IB_WC_FORWARD           = (1<<2)\r
431 };\r
432 \r
433 struct ib_wc {\r
434         u64                     wr_id;\r
435         enum ib_wc_status       status;\r
436         enum ib_wc_opcode       opcode;\r
437         u32                     vendor_err;\r
438         u32                     byte_len;\r
439         struct ib_qp           *qp;\r
440         __be32                  imm_data;\r
441         u32                     src_qp;\r
442         int                     wc_flags;\r
443         u16                     pkey_index;\r
444         u16                     slid;\r
445         u8                      sl;\r
446         u8                      dlid_path_bits;\r
447         u8                      port_num;       /* valid only for DR SMPs on switches */\r
448 };\r
449 \r
450 enum ib_cq_notify_flags {\r
451         IB_CQ_SOLICITED                 = 1 << 0,\r
452         IB_CQ_NEXT_COMP                 = 1 << 1,\r
453         IB_CQ_SOLICITED_MASK            = IB_CQ_SOLICITED | IB_CQ_NEXT_COMP,\r
454         IB_CQ_REPORT_MISSED_EVENTS      = 1 << 2,\r
455 };\r
456 \r
457 enum ib_srq_attr_mask {\r
458         XIB_SRQ_MAX_WR  = 1 << 0,\r
459         XIB_SRQ_LIMIT   = 1 << 1,\r
460 };\r
461 \r
462 struct ib_srq_attr {\r
463         u32     max_wr;\r
464         u32     max_sge;\r
465         u32     srq_limit;\r
466 };\r
467 \r
468 struct ib_srq_init_attr {\r
469         void                  (*event_handler)(ib_event_rec_t *);\r
470         void                   *srq_context;\r
471         struct ib_srq_attr      attr;\r
472 };\r
473 \r
474 struct ib_qp_cap {\r
475         u32     max_send_wr;\r
476         u32     max_recv_wr;\r
477         u32     max_send_sge;\r
478         u32     max_recv_sge;\r
479         u32     max_inline_data;\r
480 };\r
481 \r
482 enum ib_sig_type {\r
483         IB_SIGNAL_ALL_WR,\r
484         IB_SIGNAL_REQ_WR\r
485 };\r
486 \r
487 enum ib_qp_type {\r
488         /*\r
489          * IB_QPT_SMI and IB_QPT_GSI have to be the first two entries\r
490          * here (and in that order) since the MAD layer uses them as\r
491          * indices into a 2-entry table.\r
492          */\r
493         IB_QPT_SMI,\r
494         IB_QPT_GSI,\r
495 \r
496         IB_QPT_RC,\r
497         IB_QPT_UC,\r
498         IB_QPT_UD,\r
499         IB_QPT_RAW_IP_V6,\r
500         IB_QPT_RAW_ETY\r
501 };\r
502 \r
503 enum ib_qp_create_flags {\r
504         IB_QP_CREATE_IPOIB_UD_LSO = 1 << 0,\r
505 };\r
506 \r
507 struct ib_qp_init_attr {\r
508         void                  (*event_handler)(ib_event_rec_t *);\r
509         void                   *qp_context;\r
510         struct ib_cq           *send_cq;\r
511         struct ib_cq           *recv_cq;\r
512         struct ib_srq          *srq;\r
513         struct ib_qp_cap                cap;\r
514         enum ib_sig_type                sq_sig_type;\r
515         enum ib_qp_type                 qp_type;\r
516         enum ib_qp_create_flags create_flags;\r
517         u8                      port_num; /* special QP types only */\r
518 };\r
519 \r
520 enum ib_rnr_timeout {\r
521         IB_RNR_TIMER_655_36 =  0,\r
522         IB_RNR_TIMER_000_01 =  1,\r
523         IB_RNR_TIMER_000_02 =  2,\r
524         IB_RNR_TIMER_000_03 =  3,\r
525         IB_RNR_TIMER_000_04 =  4,\r
526         IB_RNR_TIMER_000_06 =  5,\r
527         IB_RNR_TIMER_000_08 =  6,\r
528         IB_RNR_TIMER_000_12 =  7,\r
529         IB_RNR_TIMER_000_16 =  8,\r
530         IB_RNR_TIMER_000_24 =  9,\r
531         IB_RNR_TIMER_000_32 = 10,\r
532         IB_RNR_TIMER_000_48 = 11,\r
533         IB_RNR_TIMER_000_64 = 12,\r
534         IB_RNR_TIMER_000_96 = 13,\r
535         IB_RNR_TIMER_001_28 = 14,\r
536         IB_RNR_TIMER_001_92 = 15,\r
537         IB_RNR_TIMER_002_56 = 16,\r
538         IB_RNR_TIMER_003_84 = 17,\r
539         IB_RNR_TIMER_005_12 = 18,\r
540         IB_RNR_TIMER_007_68 = 19,\r
541         IB_RNR_TIMER_010_24 = 20,\r
542         IB_RNR_TIMER_015_36 = 21,\r
543         IB_RNR_TIMER_020_48 = 22,\r
544         IB_RNR_TIMER_030_72 = 23,\r
545         IB_RNR_TIMER_040_96 = 24,\r
546         IB_RNR_TIMER_061_44 = 25,\r
547         IB_RNR_TIMER_081_92 = 26,\r
548         IB_RNR_TIMER_122_88 = 27,\r
549         IB_RNR_TIMER_163_84 = 28,\r
550         IB_RNR_TIMER_245_76 = 29,\r
551         IB_RNR_TIMER_327_68 = 30,\r
552         IB_RNR_TIMER_491_52 = 31\r
553 };\r
554         \r
555 enum ib_qp_attr_mask {\r
556         IB_QP_STATE                     = 1,\r
557         IB_QP_CUR_STATE                 = (1<<1),\r
558         IB_QP_EN_SQD_ASYNC_NOTIFY       = (1<<2),\r
559         IB_QP_ACCESS_FLAGS              = (1<<3),\r
560         IB_QP_PKEY_INDEX                = (1<<4),\r
561         IB_QP_PORT                      = (1<<5),\r
562         IB_QP_QKEY                      = (1<<6),\r
563         IB_QP_AV                        = (1<<7),\r
564         IB_QP_PATH_MTU                  = (1<<8),\r
565         IB_QP_TIMEOUT                   = (1<<9),\r
566         IB_QP_RETRY_CNT                 = (1<<10),\r
567         IB_QP_RNR_RETRY                 = (1<<11),\r
568         IB_QP_RQ_PSN                    = (1<<12),\r
569         IB_QP_MAX_QP_RD_ATOMIC          = (1<<13),\r
570         IB_QP_ALT_PATH                  = (1<<14),\r
571         IB_QP_MIN_RNR_TIMER             = (1<<15),\r
572         IB_QP_SQ_PSN                    = (1<<16),\r
573         IB_QP_MAX_DEST_RD_ATOMIC        = (1<<17),\r
574         IB_QP_PATH_MIG_STATE            = (1<<18),\r
575         IB_QP_CAP                       = (1<<19),\r
576         IB_QP_DEST_QPN                  = (1<<20)\r
577 };\r
578 \r
579 enum ib_qp_state {\r
580         XIB_QPS_RESET,\r
581         XIB_QPS_INIT,\r
582         XIB_QPS_RTR,\r
583         XIB_QPS_RTS,\r
584         XIB_QPS_SQD,\r
585         XIB_QPS_SQE,\r
586         XIB_QPS_ERR\r
587 };\r
588 \r
589 enum ib_mig_state {\r
590         IB_MIG_MIGRATED,\r
591         IB_MIG_REARM,\r
592         IB_MIG_ARMED\r
593 };\r
594 \r
595 struct ib_qp_attr {\r
596         enum ib_qp_state        qp_state;\r
597         enum ib_qp_state        cur_qp_state;\r
598         enum ib_mtu             path_mtu;\r
599         enum ib_mig_state       path_mig_state;\r
600         u32                     qkey;\r
601         u32                     rq_psn;\r
602         u32                     sq_psn;\r
603         u32                     dest_qp_num;\r
604         int                     qp_access_flags;\r
605         struct ib_qp_cap        cap;\r
606         struct ib_ah_attr       ah_attr;\r
607         struct ib_ah_attr       alt_ah_attr;\r
608         u16                     pkey_index;\r
609         u16                     alt_pkey_index;\r
610         u8                      en_sqd_async_notify;\r
611         u8                      sq_draining;\r
612         u8                      max_rd_atomic;\r
613         u8                      max_dest_rd_atomic;\r
614         u8                      min_rnr_timer;\r
615         u8                      port_num;\r
616         u8                      timeout;\r
617         u8                      retry_cnt;\r
618         u8                      rnr_retry;\r
619         u8                      alt_port_num;\r
620         u8                      alt_timeout;\r
621 };\r
622 \r
623 enum ib_wr_opcode {\r
624         IB_WR_RDMA_WRITE,\r
625         IB_WR_RDMA_WRITE_WITH_IMM,\r
626         IB_WR_SEND,\r
627         IB_WR_SEND_WITH_IMM,\r
628         IB_WR_RDMA_READ,\r
629         IB_WR_ATOMIC_CMP_AND_SWP,\r
630         IB_WR_ATOMIC_FETCH_AND_ADD,\r
631         IB_WR_LSO\r
632 };\r
633 \r
634 enum ib_send_flags {\r
635         IB_SEND_FENCE           = 1,\r
636         IB_SEND_SIGNALED        = (1<<1),\r
637         IB_SEND_SOLICITED       = (1<<2),\r
638         IB_SEND_INLINE          = (1<<3)\r
639 };\r
640 \r
641 struct ib_sge {\r
642         u64     addr;\r
643         u32     length;\r
644         u32     lkey;\r
645 };\r
646 \r
647 struct ib_send_wr {\r
648         struct ib_send_wr      *next;\r
649         u64                     wr_id;\r
650         struct ib_sge          *sg_list;\r
651         int                     num_sge;\r
652         enum ib_wr_opcode       opcode;\r
653         int                     send_flags;\r
654         __be32                  imm_data;\r
655         union {\r
656                 struct {\r
657                         u64     remote_addr;\r
658                         u32     rkey;\r
659                 } rdma;\r
660                 struct {\r
661                         u64     remote_addr;\r
662                         u64     compare_add;\r
663                         u64     swap;\r
664                         u32     rkey;\r
665                 } atomic;\r
666                 struct {\r
667                         struct ib_ah *ah;\r
668                         void    *header;\r
669                         int             hlen;\r
670                         int             mss;\r
671                         u32             remote_qpn;\r
672                         u32             remote_qkey;\r
673                         u16             pkey_index; /* valid for GSI only */\r
674                         u8              port_num;   /* valid for DR SMPs on switch only */\r
675                 } ud;\r
676         } wr;\r
677 };\r
678 \r
679 struct ib_recv_wr {\r
680         struct ib_recv_wr      *next;\r
681         u64                     wr_id;\r
682         struct ib_sge          *sg_list;\r
683         int                     num_sge;\r
684 };\r
685 \r
686 enum ib_access_flags {\r
687         IB_ACCESS_LOCAL_WRITE   = 1,\r
688         IB_ACCESS_REMOTE_WRITE  = (1<<1),\r
689         IB_ACCESS_REMOTE_READ   = (1<<2),\r
690         IB_ACCESS_REMOTE_ATOMIC = (1<<3),\r
691         IB_ACCESS_MW_BIND       = (1<<4)\r
692 };\r
693 \r
694 struct ib_phys_buf {\r
695         u64      addr;\r
696         u64      size;\r
697 };\r
698 \r
699 struct ib_mr_attr {\r
700         struct ib_pd    *pd;\r
701         u64             device_virt_addr;\r
702         u64             size;\r
703         int             mr_access_flags;\r
704         u32             lkey;\r
705         u32             rkey;\r
706 };\r
707 \r
708 enum ib_mr_rereg_flags {\r
709         IB_MR_REREG_TRANS       = 1,\r
710         IB_MR_REREG_PD          = (1<<1),\r
711         IB_MR_REREG_ACCESS      = (1<<2)\r
712 };\r
713 \r
714 struct ib_mw_bind {\r
715         struct ib_mr   *mr;\r
716         u64             wr_id;\r
717         u64             addr;\r
718         u32             length;\r
719         int             send_flags;\r
720         int             mw_access_flags;\r
721 };\r
722 \r
723 struct ib_fmr_attr {\r
724         int     max_pages;\r
725         int     max_maps;\r
726         u8      page_shift;\r
727 };\r
728 struct ib_ucontext {\r
729         struct ib_device       *device;\r
730         int                     closing;\r
731         struct ib_ucontext_ex   x;\r
732 };\r
733 \r
734 struct ib_udata {\r
735         void        *inbuf;\r
736         void        *outbuf;\r
737         size_t       inlen;\r
738         size_t       outlen;\r
739 };\r
740 \r
741 #define INIT_UDATA(udata, ibuf, obuf, ilen, olen)                       \\r
742         {                                                               \\r
743                 (udata)->inbuf  = (void *) (ibuf);              \\r
744                 (udata)->outbuf = (void *) (obuf);              \\r
745                 (udata)->inlen  = (ilen);                               \\r
746                 (udata)->outlen = (olen);                               \\r
747         }\r
748 \r
749 struct ib_pd {\r
750         struct ib_device       *device;\r
751         struct ib_ucontext     *p_uctx;\r
752         atomic_t                usecnt; /* count all resources */\r
753 };\r
754 \r
755 struct ib_ah {\r
756         struct ib_device        *device;\r
757         struct ib_pd            *pd;\r
758         struct ib_ucontext      *p_uctx;\r
759 };\r
760 \r
761 typedef void (*ib_comp_handler)(void *cq_context);\r
762 \r
763 struct ib_cq {\r
764         struct ib_device       *device;\r
765         struct ib_ucontext     *p_uctx;\r
766         ib_comp_handler         comp_handler;\r
767         void                  (*event_handler)(ib_event_rec_t *);\r
768         void *                  cq_context;\r
769         int                     cqe;\r
770         atomic_t                usecnt; /* count number of work queues */\r
771 };\r
772 \r
773 struct ib_srq {\r
774         struct ib_device       *device;\r
775         struct ib_pd           *pd;\r
776         struct ib_ucontext     *p_uctx;\r
777         void                  (*event_handler)(ib_event_rec_t *);\r
778         void                   *srq_context;\r
779         atomic_t                usecnt;\r
780 };\r
781 \r
782 struct ib_qp {\r
783         struct ib_device       *device;\r
784         struct ib_pd           *pd;\r
785         struct ib_cq           *send_cq;\r
786         struct ib_cq           *recv_cq;\r
787         struct ib_srq          *srq;\r
788         struct ib_ucontext     *p_uctx;\r
789         void                  (*event_handler)(ib_event_rec_t *);\r
790         void                   *qp_context;\r
791         u32                     qp_num;\r
792         enum ib_qp_type         qp_type;\r
793 };\r
794 \r
795 struct ib_mr {\r
796         struct ib_device  *device;\r
797         struct ib_pd      *pd;\r
798         struct ib_ucontext *p_uctx;\r
799         u32                lkey;\r
800         u32                rkey;\r
801         atomic_t           usecnt; /* count number of MWs */\r
802 };\r
803 \r
804 struct ib_mw {\r
805         struct ib_device        *device;\r
806         struct ib_pd            *pd;\r
807         struct ib_ucontext  *p_uctx;\r
808         u32                     rkey;\r
809 };\r
810 \r
811 struct ib_fmr {\r
812         struct ib_device        *device;\r
813         struct ib_pd            *pd;\r
814         struct list_head        list;\r
815         u32                     lkey;\r
816         u32                     rkey;\r
817 };\r
818 \r
819 struct ib_mad;\r
820 struct ib_grh;\r
821 \r
822 enum ib_process_mad_flags {\r
823         IB_MAD_IGNORE_MKEY      = 1,\r
824         IB_MAD_IGNORE_BKEY      = 2,\r
825         IB_MAD_IGNORE_ALL       = IB_MAD_IGNORE_MKEY | IB_MAD_IGNORE_BKEY\r
826 };\r
827 \r
828 enum ib_mad_result {\r
829         IB_MAD_RESULT_FAILURE  = 0,      /* (!SUCCESS is the important flag) */\r
830         IB_MAD_RESULT_SUCCESS  = 1 << 0, /* MAD was successfully processed   */\r
831         IB_MAD_RESULT_REPLY    = 1 << 1, /* Reply packet needs to be sent    */\r
832         IB_MAD_RESULT_CONSUMED = 1 << 2  /* Packet consumed: stop processing */\r
833 };\r
834 \r
835 #define IB_DEVICE_NAME_MAX 64\r
836 \r
837 struct ib_cache {\r
838         rwlock_t                lock;\r
839         struct ib_event_handler event_handler;\r
840         struct ib_pkey_cache  **pkey_cache;\r
841         struct ib_gid_cache   **gid_cache;\r
842         u8                     *lmc_cache;\r
843         struct ib_cache_ex      x;\r
844 };\r
845 \r
846 struct ib_dma_mapping_ops {\r
847         int             (*mapping_error)(struct ib_device *dev,\r
848                                          u64 dma_addr);\r
849         u64             (*map_single)(struct ib_device *dev,\r
850                                       void *ptr, size_t size,\r
851                                       enum dma_data_direction direction);\r
852         void            (*unmap_single)(struct ib_device *dev,\r
853                                         u64 addr, size_t size,\r
854                                         enum dma_data_direction direction);\r
855         u64             (*map_page)(struct ib_device *dev,\r
856                                     dma_addr_t page, unsigned long offset,\r
857                                     size_t size,\r
858                                     enum dma_data_direction direction);\r
859         void            (*unmap_page)(struct ib_device *dev,\r
860                                       u64 addr, size_t size,\r
861                                       enum dma_data_direction direction);\r
862         int             (*map_sg)(struct ib_device *dev,\r
863                                   struct scatterlist *sg, int nents,\r
864                                   enum dma_data_direction direction);\r
865         void            (*unmap_sg)(struct ib_device *dev,\r
866                                     struct scatterlist *sg, int nents,\r
867                                     enum dma_data_direction direction);\r
868         u64             (*dma_address)(struct ib_device *dev,\r
869                                        struct scatterlist *sg);\r
870         unsigned int    (*dma_len)(struct ib_device *dev,\r
871                                    struct scatterlist *sg);\r
872         void            (*sync_single_for_cpu)(struct ib_device *dev,\r
873                                                u64 dma_handle,\r
874                                                size_t size,\r
875                                                enum dma_data_direction dir);\r
876         void            (*sync_single_for_device)(struct ib_device *dev,\r
877                                                   u64 dma_handle,\r
878                                                   size_t size,\r
879                                                   enum dma_data_direction dir);\r
880         void            *(*alloc_coherent)(struct ib_device *dev,\r
881                                            size_t size,\r
882                                            u64 *dma_handle,\r
883                                            gfp_t flag);\r
884         void            (*free_coherent)(struct ib_device *dev,\r
885                                          size_t size, void *cpu_addr,\r
886                                          u64 dma_handle);\r
887 };\r
888 \r
889 struct iw_cm_verbs;\r
890 \r
891 struct ib_device {\r
892         struct mlx4_dev                *dma_device;\r
893 \r
894         char                          name[IB_DEVICE_NAME_MAX];\r
895 \r
896         struct list_head              event_handler_list;\r
897         spinlock_t                    event_handler_lock;\r
898 \r
899         struct list_head              core_list;\r
900         struct list_head              client_data_list;\r
901         spinlock_t                    client_data_lock;\r
902 \r
903         struct ib_cache               cache;\r
904         int                          *pkey_tbl_len;\r
905         int                          *gid_tbl_len;\r
906 \r
907         u32                           flags;\r
908 \r
909         int                           num_comp_vectors;\r
910 \r
911         struct iw_cm_verbs           *iwcm;\r
912 \r
913         int                        (*query_device)(struct ib_device *device,\r
914                                                    struct ib_device_attr *device_attr);\r
915         int                        (*query_port)(struct ib_device *device,\r
916                                                  u8 port_num,\r
917                                                  struct ib_port_attr *port_attr);\r
918         int                        (*query_gid_chunk)(struct ib_device *device,\r
919                                                 u8 port_num, int index,\r
920                                                 union ib_gid gid[8], int size);\r
921         int                        (*query_pkey_chunk)(struct ib_device *device,\r
922                                                  u8 port_num, u16 index, __be16 pkey[32], int size);\r
923         int                        (*modify_device)(struct ib_device *device,\r
924                                                     int device_modify_mask,\r
925                                                     struct ib_device_modify *device_modify);\r
926         int                        (*modify_port)(struct ib_device *device,\r
927                                                   u8 port_num, int port_modify_mask,\r
928                                                   struct ib_port_modify *port_modify);\r
929         struct ib_ucontext *       (*alloc_ucontext)(struct ib_device *device,\r
930                                                      struct ib_udata *udata);\r
931         int                        (*dealloc_ucontext)(struct ib_ucontext *context);\r
932         int                        (*mmap)(struct ib_ucontext *context,\r
933                                            struct vm_area_struct *vma);\r
934         struct ib_pd *             (*alloc_pd)(struct ib_device *device,\r
935                                                struct ib_ucontext *context,\r
936                                                struct ib_udata *udata);\r
937         int                        (*dealloc_pd)(struct ib_pd *pd);\r
938         struct ib_ah *             (*create_ah)(struct ib_pd *pd,\r
939                                                 struct ib_ah_attr *ah_attr);\r
940         int                        (*modify_ah)(struct ib_ah *ah,\r
941                                                 struct ib_ah_attr *ah_attr);\r
942         int                        (*query_ah)(struct ib_ah *ah,\r
943                                                struct ib_ah_attr *ah_attr);\r
944         int                        (*destroy_ah)(struct ib_ah *ah);\r
945         struct ib_srq *            (*create_srq)(struct ib_pd *pd,\r
946                                                  struct ib_srq_init_attr *srq_init_attr,\r
947                                                  struct ib_udata *udata);\r
948         int                        (*modify_srq)(struct ib_srq *srq,\r
949                                                  struct ib_srq_attr *srq_attr,\r
950                                                  enum ib_srq_attr_mask srq_attr_mask,\r
951                                                  struct ib_udata *udata);\r
952         int                        (*query_srq)(struct ib_srq *srq,\r
953                                                 struct ib_srq_attr *srq_attr);\r
954         int                        (*destroy_srq)(struct ib_srq *srq);\r
955         int                        (*post_srq_recv)(struct ib_srq *srq,\r
956                                                     ib_recv_wr_t *recv_wr,\r
957                                                     ib_recv_wr_t **bad_recv_wr);\r
958         struct ib_qp *             (*create_qp)(struct ib_pd *pd,\r
959                                                 struct ib_qp_init_attr *qp_init_attr,\r
960                                                 struct ib_udata *udata);\r
961         int                        (*modify_qp)(struct ib_qp *qp,\r
962                                                 struct ib_qp_attr *qp_attr,\r
963                                                 int qp_attr_mask,\r
964                                                 struct ib_udata *udata);\r
965         int                        (*query_qp)(struct ib_qp *qp,\r
966                                                struct ib_qp_attr *qp_attr,\r
967                                                int qp_attr_mask,\r
968                                                struct ib_qp_init_attr *qp_init_attr);\r
969         int                        (*destroy_qp)(struct ib_qp *qp);\r
970         int                        (*post_send)(struct ib_qp *qp,\r
971                                                 ib_send_wr_t *send_wr,\r
972                                                 ib_send_wr_t **bad_send_wr);\r
973         int                        (*post_recv)(struct ib_qp *qp,\r
974                                                 ib_recv_wr_t *recv_wr,\r
975                                                 ib_recv_wr_t **bad_recv_wr);\r
976         struct ib_cq *             (*create_cq)(struct ib_device *device, int cqe,\r
977                                                 int comp_vector,\r
978                                                 struct ib_ucontext *context,\r
979                                                 struct ib_udata *udata);\r
980         int                        (*modify_cq)(struct ib_cq *cq, u16 cq_count,\r
981                                                 u16 cq_period);\r
982         int                        (*destroy_cq)(struct ib_cq *cq);\r
983         int                        (*resize_cq)(struct ib_cq *cq, int cqe,\r
984                                                 struct ib_udata *udata);\r
985         int                        (*poll_cq)(struct ib_cq *ibcq,\r
986                         ib_wc_t** const pp_free_wclist, ib_wc_t** const pp_done_wclist);\r
987         int                        (*peek_cq)(struct ib_cq *cq, int wc_cnt);\r
988         int                        (*req_notify_cq)(struct ib_cq *cq,\r
989                                                     enum ib_cq_notify_flags flags);\r
990         int                        (*req_ncomp_notif)(struct ib_cq *cq,\r
991                                                       int wc_cnt);\r
992         struct ib_mr *             (*get_dma_mr)(struct ib_pd *pd,\r
993                                                  int mr_access_flags);\r
994         struct ib_mr *             (*reg_phys_mr)(struct ib_pd *pd,\r
995                                                   struct ib_phys_buf *phys_buf_array,\r
996                                                   int num_phys_buf,\r
997                                                   int mr_access_flags,\r
998                                                   u64 *iova_start);\r
999         struct ib_mr *             (*reg_user_mr)(struct ib_pd *pd,\r
1000                                                   u64 start, u64 length,\r
1001                                                   u64 virt_addr,\r
1002                                                   int mr_access_flags,\r
1003                                                   struct ib_udata *udata);\r
1004         int                        (*query_mr)(struct ib_mr *mr,\r
1005                                                struct ib_mr_attr *mr_attr);\r
1006         int                        (*dereg_mr)(struct ib_mr *mr);\r
1007         int                        (*rereg_phys_mr)(struct ib_mr *mr,\r
1008                                                     int mr_rereg_mask,\r
1009                                                     struct ib_pd *pd,\r
1010                                                     struct ib_phys_buf *phys_buf_array,\r
1011                                                     int num_phys_buf,\r
1012                                                     int mr_access_flags,\r
1013                                                     u64 *iova_start);\r
1014         struct ib_mw *             (*alloc_mw)(struct ib_pd *pd);\r
1015         int                        (*bind_mw)(struct ib_qp *qp,\r
1016                                               struct ib_mw *mw,\r
1017                                               struct ib_mw_bind *mw_bind);\r
1018         int                        (*dealloc_mw)(struct ib_mw *mw);\r
1019         struct ib_fmr *            (*alloc_fmr)(struct ib_pd *pd,\r
1020                                                 int mr_access_flags,\r
1021                                                 struct ib_fmr_attr *fmr_attr);\r
1022         int                        (*map_phys_fmr)(struct ib_fmr *fmr,\r
1023                                                    u64 *page_list, int list_len,\r
1024                                                    u64 iova);\r
1025         int                        (*unmap_fmr)(struct list_head *fmr_list);\r
1026         int                        (*dealloc_fmr)(struct ib_fmr *fmr);\r
1027         int                        (*attach_mcast)(struct ib_qp *qp,\r
1028                                                    union ib_gid *gid,\r
1029                                                    u16 lid);\r
1030         int                        (*detach_mcast)(struct ib_qp *qp,\r
1031                                                    union ib_gid *gid,\r
1032                                                    u16 lid);\r
1033         int                        (*process_mad)(struct ib_device *device,\r
1034                                                   int process_mad_flags,\r
1035                                                   u8 port_num,\r
1036                                                   ib_wc_t *in_wc,\r
1037                                                   struct ib_grh *in_grh,\r
1038                                                   struct ib_mad *in_mad,\r
1039                                                   struct ib_mad *out_mad);\r
1040 \r
1041         struct ib_dma_mapping_ops   *dma_ops;\r
1042         struct list_head             port_list;\r
1043 \r
1044         enum {\r
1045                 IB_DEV_UNINITIALIZED,\r
1046                 IB_DEV_REGISTERED,\r
1047                 IB_DEV_UNREGISTERED\r
1048         }                            reg_state;\r
1049 \r
1050         u64                          uverbs_cmd_mask;\r
1051         int                          uverbs_abi_ver;\r
1052 \r
1053         char                         node_desc[64];\r
1054         __be64                       node_guid;\r
1055         u8                           node_type;\r
1056         u8                           phys_port_cnt;\r
1057         struct ib_device_ex          x;\r
1058 };\r
1059 \r
1060 struct ib_client {\r
1061         char  *name;\r
1062         void (*add)   (struct ib_device *);\r
1063         void (*remove)(struct ib_device *);\r
1064 \r
1065         struct list_head list;\r
1066 };\r
1067 \r
1068 struct ib_device *ib_alloc_device(size_t size);\r
1069 void ib_dealloc_device(struct ib_device *device);\r
1070 \r
1071 int ib_register_device   (struct ib_device *device);\r
1072 void ib_unregister_device(struct ib_device *device);\r
1073 \r
1074 int ib_register_client   (struct ib_client *client);\r
1075 void ib_unregister_client(struct ib_client *client);\r
1076 \r
1077 void *ib_get_client_data(struct ib_device *device, struct ib_client *client);\r
1078 void  ib_set_client_data(struct ib_device *device, struct ib_client *client,\r
1079                          void *data);\r
1080 \r
1081 static inline int ib_copy_from_udata(void *dest, struct ib_udata *udata, size_t len)\r
1082 {\r
1083         if (len > udata->inlen)\r
1084                 return -EFAULT;\r
1085         memcpy(dest, udata->inbuf, len);\r
1086         return 0;\r
1087 }\r
1088 \r
1089 static inline int ib_copy_to_udata(struct ib_udata *udata, void *src, size_t len)\r
1090 {\r
1091         if (len > udata->outlen)\r
1092                 return -EFAULT;\r
1093         memcpy(udata->outbuf, src, len);\r
1094         return 0;\r
1095 }\r
1096 \r
1097 /**\r
1098  * ib_modify_qp_is_ok - Check that the supplied attribute mask\r
1099  * contains all required attributes and no attributes not allowed for\r
1100  * the given QP state transition.\r
1101  * @cur_state: Current QP state\r
1102  * @next_state: Next QP state\r
1103  * @type: QP type\r
1104  * @mask: Mask of supplied QP attributes\r
1105  *\r
1106  * This function is a helper function that a low-level driver's\r
1107  * modify_qp method can use to validate the consumer's input.  It\r
1108  * checks that cur_state and next_state are valid QP states, that a\r
1109  * transition from cur_state to next_state is allowed by the IB spec,\r
1110  * and that the attribute mask supplied is allowed for the transition.\r
1111  */\r
1112 int ib_modify_qp_is_ok(enum ib_qp_state cur_state, enum ib_qp_state next_state,\r
1113                        enum ib_qp_type type, enum ib_qp_attr_mask mask);\r
1114 \r
1115 int ib_register_event_handler  (struct ib_event_handler *event_handler);\r
1116 int ib_unregister_event_handler(struct ib_event_handler *event_handler);\r
1117 void ib_dispatch_event(struct ib_event *event);\r
1118 \r
1119 int ib_query_device(struct ib_device *device,\r
1120                     struct ib_device_attr *device_attr);\r
1121 \r
1122 int ib_query_port(struct ib_device *device,\r
1123                   u8 port_num, struct ib_port_attr *port_attr);\r
1124 \r
1125 int ib_query_gid_chunk(struct ib_device *device,\r
1126                  u8 port_num, int index, union ib_gid gid[8], int size);\r
1127 \r
1128 int ib_query_pkey_chunk(struct ib_device *device,\r
1129                   u8 port_num, u16 index, __be16 pkey[32], int size);\r
1130 \r
1131 int ib_modify_device(struct ib_device *device,\r
1132                      int device_modify_mask,\r
1133                      struct ib_device_modify *device_modify);\r
1134 \r
1135 int ib_modify_port(struct ib_device *device,\r
1136                    u8 port_num, int port_modify_mask,\r
1137                    struct ib_port_modify *port_modify);\r
1138 \r
1139 int ib_find_gid(struct ib_device *device, union ib_gid *gid,\r
1140                 u8 *port_num, u16 *index);\r
1141 \r
1142 int ib_find_pkey(struct ib_device *device,\r
1143                  u8 port_num, __be16 pkey, u16 *index);\r
1144 \r
1145 /**\r
1146  * ib_alloc_pd - Allocates an unused protection domain.\r
1147  * @device: The device on which to allocate the protection domain.\r
1148  *\r
1149  * A protection domain object provides an association between QPs, shared\r
1150  * receive queues, address handles, memory regions, and memory windows.\r
1151  */\r
1152 struct ib_pd *ib_alloc_pd(struct ib_device *device);\r
1153 \r
1154 /**\r
1155  * ib_dealloc_pd - Deallocates a protection domain.\r
1156  * @pd: The protection domain to deallocate.\r
1157  */\r
1158 int ib_dealloc_pd(struct ib_pd *pd);\r
1159 \r
1160 /**\r
1161  * ib_create_ah - Creates an address handle for the given address vector.\r
1162  * @pd: The protection domain associated with the address handle.\r
1163  * @ah_attr: The attributes of the address vector.\r
1164  *\r
1165  * The address handle is used to reference a local or global destination\r
1166  * in all UD QP post sends.\r
1167  */\r
1168 struct ib_ah *ib_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr);\r
1169 \r
1170 /**\r
1171  * ib_init_ah_from_wc - Initializes address handle attributes from a\r
1172  *   work completion.\r
1173  * @device: Device on which the received message arrived.\r
1174  * @port_num: Port on which the received message arrived.\r
1175  * @wc: Work completion associated with the received message.\r
1176  * @grh: References the received global route header.  This parameter is\r
1177  *   ignored unless the work completion indicates that the GRH is valid.\r
1178  * @ah_attr: Returned attributes that can be used when creating an address\r
1179  *   handle for replying to the message.\r
1180  */\r
1181 int ib_init_ah_from_wc(struct ib_device *device, u8 port_num, ib_wc_t *wc,\r
1182                        struct ib_grh *grh, struct ib_ah_attr *ah_attr);\r
1183 \r
1184 /**\r
1185  * ib_create_ah_from_wc - Creates an address handle associated with the\r
1186  *   sender of the specified work completion.\r
1187  * @pd: The protection domain associated with the address handle.\r
1188  * @wc: Work completion information associated with a received message.\r
1189  * @grh: References the received global route header.  This parameter is\r
1190  *   ignored unless the work completion indicates that the GRH is valid.\r
1191  * @port_num: The outbound port number to associate with the address.\r
1192  *\r
1193  * The address handle is used to reference a local or global destination\r
1194  * in all UD QP post sends.\r
1195  */\r
1196 struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, ib_wc_t *wc,\r
1197                                    struct ib_grh *grh, u8 port_num);\r
1198 \r
1199 /**\r
1200  * ib_modify_ah - Modifies the address vector associated with an address\r
1201  *   handle.\r
1202  * @ah: The address handle to modify.\r
1203  * @ah_attr: The new address vector attributes to associate with the\r
1204  *   address handle.\r
1205  */\r
1206 int ib_modify_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr);\r
1207 \r
1208 /**\r
1209  * ib_query_ah - Queries the address vector associated with an address\r
1210  *   handle.\r
1211  * @ah: The address handle to query.\r
1212  * @ah_attr: The address vector attributes associated with the address\r
1213  *   handle.\r
1214  */\r
1215 int ib_query_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr);\r
1216 \r
1217 /**\r
1218  * ib_destroy_ah - Destroys an address handle.\r
1219  * @ah: The address handle to destroy.\r
1220  */\r
1221 int ib_destroy_ah(struct ib_ah *ah);\r
1222 \r
1223 /**\r
1224  * ib_create_srq - Creates a SRQ associated with the specified protection\r
1225  *   domain.\r
1226  * @pd: The protection domain associated with the SRQ.\r
1227  * @srq_init_attr: A list of initial attributes required to create the\r
1228  *   SRQ.  If SRQ creation succeeds, then the attributes are updated to\r
1229  *   the actual capabilities of the created SRQ.\r
1230  *\r
1231  * srq_attr->max_wr and srq_attr->max_sge are read the determine the\r
1232  * requested size of the SRQ, and set to the actual values allocated\r
1233  * on return.  If ib_create_srq() succeeds, then max_wr and max_sge\r
1234  * will always be at least as large as the requested values.\r
1235  */\r
1236 struct ib_srq *ib_create_srq(struct ib_pd *pd,\r
1237                              struct ib_srq_init_attr *srq_init_attr);\r
1238 \r
1239 /**\r
1240  * ib_modify_srq - Modifies the attributes for the specified SRQ.\r
1241  * @srq: The SRQ to modify.\r
1242  * @srq_attr: On input, specifies the SRQ attributes to modify.  On output,\r
1243  *   the current values of selected SRQ attributes are returned.\r
1244  * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ\r
1245  *   are being modified.\r
1246  *\r
1247  * The mask may contain XIB_SRQ_MAX_WR to resize the SRQ and/or\r
1248  * XIB_SRQ_LIMIT to set the SRQ's limit and request notification when\r
1249  * the number of receives queued drops below the limit.\r
1250  */\r
1251 int ib_modify_srq(struct ib_srq *srq,\r
1252                   struct ib_srq_attr *srq_attr,\r
1253                   enum ib_srq_attr_mask srq_attr_mask);\r
1254 \r
1255 /**\r
1256  * ib_query_srq - Returns the attribute list and current values for the\r
1257  *   specified SRQ.\r
1258  * @srq: The SRQ to query.\r
1259  * @srq_attr: The attributes of the specified SRQ.\r
1260  */\r
1261 int ib_query_srq(struct ib_srq *srq,\r
1262                  struct ib_srq_attr *srq_attr);\r
1263 \r
1264 /**\r
1265  * ib_destroy_srq - Destroys the specified SRQ.\r
1266  * @srq: The SRQ to destroy.\r
1267  */\r
1268 int ib_destroy_srq(struct ib_srq *srq);\r
1269 \r
1270 /**\r
1271  * ib_post_srq_recv - Posts a list of work requests to the specified SRQ.\r
1272  * @srq: The SRQ to post the work request on.\r
1273  * @recv_wr: A list of work requests to post on the receive queue.\r
1274  * @bad_recv_wr: On an immediate failure, this parameter will reference\r
1275  *   the work request that failed to be posted on the QP.\r
1276  */\r
1277 static inline int ib_post_srq_recv(struct ib_srq *srq,\r
1278                                    ib_recv_wr_t *recv_wr,\r
1279                                    ib_recv_wr_t **bad_recv_wr)\r
1280 {\r
1281         return srq->device->post_srq_recv(srq, recv_wr, bad_recv_wr);\r
1282 }\r
1283 \r
1284 /**\r
1285  * ib_create_qp - Creates a QP associated with the specified protection\r
1286  *   domain.\r
1287  * @pd: The protection domain associated with the QP.\r
1288  * @qp_init_attr: A list of initial attributes required to create the\r
1289  *   QP.  If QP creation succeeds, then the attributes are updated to\r
1290  *   the actual capabilities of the created QP.\r
1291  */\r
1292 struct ib_qp *ib_create_qp(struct ib_pd *pd,\r
1293                            struct ib_qp_init_attr *qp_init_attr);\r
1294 \r
1295 /**\r
1296  * ib_modify_qp - Modifies the attributes for the specified QP and then\r
1297  *   transitions the QP to the given state.\r
1298  * @qp: The QP to modify.\r
1299  * @qp_attr: On input, specifies the QP attributes to modify.  On output,\r
1300  *   the current values of selected QP attributes are returned.\r
1301  * @qp_attr_mask: A bit-mask used to specify which attributes of the QP\r
1302  *   are being modified.\r
1303  */\r
1304 int ib_modify_qp(struct ib_qp *qp,\r
1305                  struct ib_qp_attr *qp_attr,\r
1306                  int qp_attr_mask);\r
1307 \r
1308 /**\r
1309  * ib_query_qp - Returns the attribute list and current values for the\r
1310  *   specified QP.\r
1311  * @qp: The QP to query.\r
1312  * @qp_attr: The attributes of the specified QP.\r
1313  * @qp_attr_mask: A bit-mask used to select specific attributes to query.\r
1314  * @qp_init_attr: Additional attributes of the selected QP.\r
1315  *\r
1316  * The qp_attr_mask may be used to limit the query to gathering only the\r
1317  * selected attributes.\r
1318  */\r
1319 int ib_query_qp(struct ib_qp *qp,\r
1320                 struct ib_qp_attr *qp_attr,\r
1321                 int qp_attr_mask,\r
1322                 struct ib_qp_init_attr *qp_init_attr);\r
1323 \r
1324 /**\r
1325  * ib_modify_cq - Modifies moderation params of the CQ\r
1326  * @cq: The CQ to modify.\r
1327  * @cq_count: number of CQEs that will tirgger an event\r
1328  * @cq_period: max period of time beofre triggering an event\r
1329  *\r
1330  * Users can examine the cq structure to determine the actual CQ size.\r
1331  */\r
1332 int ib_modify_cq(struct ib_cq *cq, u16 cq_count, u16 cq_period);\r
1333 \r
1334 /**\r
1335  * ib_destroy_qp - Destroys the specified QP.\r
1336  * @qp: The QP to destroy.\r
1337  */\r
1338 int ib_destroy_qp(struct ib_qp *qp);\r
1339 \r
1340 /**\r
1341  * ib_post_send - Posts a list of work requests to the send queue of\r
1342  *   the specified QP.\r
1343  * @qp: The QP to post the work request on.\r
1344  * @send_wr: A list of work requests to post on the send queue.\r
1345  * @bad_send_wr: On an immediate failure, this parameter will reference\r
1346  *   the work request that failed to be posted on the QP.\r
1347  */\r
1348 static inline int ib_post_send(struct ib_qp *qp,\r
1349                                ib_send_wr_t *send_wr,\r
1350                                ib_send_wr_t **bad_send_wr)\r
1351 {\r
1352         return qp->device->post_send(qp, send_wr, bad_send_wr);\r
1353 }\r
1354 \r
1355 /**\r
1356  * ib_post_recv - Posts a list of work requests to the receive queue of\r
1357  *   the specified QP.\r
1358  * @qp: The QP to post the work request on.\r
1359  * @recv_wr: A list of work requests to post on the receive queue.\r
1360  * @bad_recv_wr: On an immediate failure, this parameter will reference\r
1361  *   the work request that failed to be posted on the QP.\r
1362  */\r
1363 static inline int ib_post_recv(struct ib_qp *qp,\r
1364                                ib_recv_wr_t *recv_wr,\r
1365                                ib_recv_wr_t **bad_recv_wr)\r
1366 {\r
1367         return qp->device->post_recv(qp, recv_wr, bad_recv_wr);\r
1368 }\r
1369 \r
1370 /**\r
1371  * ib_create_cq - Creates a CQ on the specified device.\r
1372  * @device: The device on which to create the CQ.\r
1373  * @comp_handler: A user-specified callback that is invoked when a\r
1374  *   completion event occurs on the CQ.\r
1375  * @event_handler: A user-specified callback that is invoked when an\r
1376  *   asynchronous event not associated with a completion occurs on the CQ.\r
1377  * @cq_context: Context associated with the CQ returned to the user via\r
1378  *   the associated completion and event handlers.\r
1379  * @cqe: The minimum size of the CQ.\r
1380  * @comp_vector - Completion vector used to signal completion events.\r
1381  *     Must be >= 0 and < context->num_comp_vectors.\r
1382  *\r
1383  * Users can examine the cq structure to determine the actual CQ size.\r
1384  */\r
1385 struct ib_cq *ib_create_cq(struct ib_device *device,\r
1386                            ib_comp_handler comp_handler,\r
1387                            void (*event_handler)(ib_event_rec_t *),\r
1388                            void *cq_context, int cqe, int comp_vector);\r
1389 \r
1390 /**\r
1391  * ib_resize_cq - Modifies the capacity of the CQ.\r
1392  * @cq: The CQ to resize.\r
1393  * @cqe: The minimum size of the CQ.\r
1394  *\r
1395  * Users can examine the cq structure to determine the actual CQ size.\r
1396  */\r
1397 int ib_resize_cq(struct ib_cq *cq, int cqe);\r
1398 \r
1399 /**\r
1400  * ib_destroy_cq - Destroys the specified CQ.\r
1401  * @cq: The CQ to destroy.\r
1402  */\r
1403 int ib_destroy_cq(struct ib_cq *cq);\r
1404 \r
1405 /**\r
1406  * ib_poll_cq - poll a CQ for completion(s)\r
1407  * @cq:the CQ being polled\r
1408  * @pp_free_wclist:\r
1409  *              On input, a list of work completion structures provided by\r
1410  *              the client.  These are used to report completed work requests through\r
1411  *              the pp_done_wclist.\r
1412  *\r
1413  *              On output, this contains the list of work completions structures for\r
1414  *              which no work completion was found.\r
1415  * @pp_done_wclist:A list of work completions retrieved from the completion queue.\r
1416  *\r
1417  * Poll a CQ for (possibly multiple) completions.  If the return value\r
1418  * is < 0, an error occurred.  If the return value is >= 0, it is the\r
1419  * number of completions returned.  If the return value is\r
1420  * non-negative and < num_entries, then the CQ was emptied.\r
1421  */\r
1422 static inline int ib_poll_cq(struct ib_cq *cq, ib_wc_t** const pp_free_wclist,\r
1423                              ib_wc_t** const pp_done_wclist)\r
1424 {\r
1425         return cq->device->poll_cq(cq, pp_free_wclist, pp_done_wclist);\r
1426 }\r
1427 \r
1428 /**\r
1429  * ib_peek_cq - Returns the number of unreaped completions currently\r
1430  *   on the specified CQ.\r
1431  * @cq: The CQ to peek.\r
1432  * @wc_cnt: A minimum number of unreaped completions to check for.\r
1433  *\r
1434  * If the number of unreaped completions is greater than or equal to wc_cnt,\r
1435  * this function returns wc_cnt, otherwise, it returns the actual number of\r
1436  * unreaped completions.\r
1437  */\r
1438 int ib_peek_cq(struct ib_cq *cq, int wc_cnt);\r
1439 \r
1440 /**\r
1441  * ib_req_notify_cq - Request completion notification on a CQ.\r
1442  * @cq: The CQ to generate an event for.\r
1443  * @flags:\r
1444  *   Must contain exactly one of %IB_CQ_SOLICITED or %IB_CQ_NEXT_COMP\r
1445  *   to request an event on the next solicited event or next work\r
1446  *   completion at any type, respectively. %IB_CQ_REPORT_MISSED_EVENTS\r
1447  *   may also be |ed in to request a hint about missed events, as\r
1448  *   described below.\r
1449  *\r
1450  * Return Value:\r
1451  *    < 0 means an error occurred while requesting notification\r
1452  *   == 0 means notification was requested successfully, and if\r
1453  *        IB_CQ_REPORT_MISSED_EVENTS was passed in, then no events\r
1454  *        were missed and it is safe to wait for another event.  In\r
1455  *        this case is it guaranteed that any work completions added\r
1456  *        to the CQ since the last CQ poll will trigger a completion\r
1457  *        notification event.\r
1458  *    > 0 is only returned if IB_CQ_REPORT_MISSED_EVENTS was passed\r
1459  *        in.  It means that the consumer must poll the CQ again to\r
1460  *        make sure it is empty to avoid missing an event because of a\r
1461  *        race between requesting notification and an entry being\r
1462  *        added to the CQ.  This return value means it is possible\r
1463  *        (but not guaranteed) that a work completion has been added\r
1464  *        to the CQ since the last poll without triggering a\r
1465  *        completion notification event.\r
1466  */\r
1467 static inline int ib_req_notify_cq(struct ib_cq *cq,\r
1468                                    enum ib_cq_notify_flags flags)\r
1469 {\r
1470         return cq->device->req_notify_cq(cq, flags);\r
1471 }\r
1472 \r
1473 /**\r
1474  * ib_req_ncomp_notif - Request completion notification when there are\r
1475  *   at least the specified number of unreaped completions on the CQ.\r
1476  * @cq: The CQ to generate an event for.\r
1477  * @wc_cnt: The number of unreaped completions that should be on the\r
1478  *   CQ before an event is generated.\r
1479  */\r
1480 static inline int ib_req_ncomp_notif(struct ib_cq *cq, int wc_cnt)\r
1481 {\r
1482         return cq->device->req_ncomp_notif ?\r
1483                 cq->device->req_ncomp_notif(cq, wc_cnt) :\r
1484                 -ENOSYS;\r
1485 }\r
1486 \r
1487 /**\r
1488  * ib_get_dma_mr - Returns a memory region for system memory that is\r
1489  *   usable for DMA.\r
1490  * @pd: The protection domain associated with the memory region.\r
1491  * @mr_access_flags: Specifies the memory access rights.\r
1492  *\r
1493  * Note that the ib_dma_*() functions defined below must be used\r
1494  * to create/destroy addresses used with the Lkey or Rkey returned\r
1495  * by ib_get_dma_mr().\r
1496  */\r
1497 struct ib_mr *ib_get_dma_mr(struct ib_pd *pd, int mr_access_flags);\r
1498 \r
1499 #if 0\r
1500 // TODO: do we need that\r
1501 /**\r
1502  * ib_dma_mapping_error - check a DMA addr for error\r
1503  * @dev: The device for which the dma_addr was created\r
1504  * @dma_addr: The DMA address to check\r
1505  */\r
1506 static inline int ib_dma_mapping_error(struct ib_device *dev, u64 dma_addr)\r
1507 {\r
1508         if (dev->dma_ops)\r
1509                 return dev->dma_ops->mapping_error(dev, dma_addr);\r
1510         return dma_mapping_error(dma_addr);\r
1511 }\r
1512 \r
1513 /**\r
1514  * ib_dma_map_single - Map a kernel virtual address to DMA address\r
1515  * @dev: The device for which the dma_addr is to be created\r
1516  * @cpu_addr: The kernel virtual address\r
1517  * @size: The size of the region in bytes\r
1518  * @direction: The direction of the DMA\r
1519  */\r
1520 static inline u64 ib_dma_map_single(struct ib_device *dev,\r
1521                                     void *cpu_addr, size_t size,\r
1522                                     enum dma_data_direction direction)\r
1523 {\r
1524         if (dev->dma_ops)\r
1525                 return dev->dma_ops->map_single(dev, cpu_addr, size, direction);\r
1526         return dma_map_single(dev->dma_device, cpu_addr, size, direction);\r
1527 }\r
1528 \r
1529 /**\r
1530  * ib_dma_unmap_single - Destroy a mapping created by ib_dma_map_single()\r
1531  * @dev: The device for which the DMA address was created\r
1532  * @addr: The DMA address\r
1533  * @size: The size of the region in bytes\r
1534  * @direction: The direction of the DMA\r
1535  */\r
1536 static inline void ib_dma_unmap_single(struct ib_device *dev,\r
1537                                        u64 addr, size_t size,\r
1538                                        enum dma_data_direction direction)\r
1539 {\r
1540         if (dev->dma_ops)\r
1541                 dev->dma_ops->unmap_single(dev, addr, size, direction);\r
1542         else\r
1543                 dma_unmap_single(dev->dma_device, addr, size, direction);\r
1544 }\r
1545 \r
1546 /**\r
1547  * ib_dma_map_page - Map a physical page to DMA address\r
1548  * @dev: The device for which the dma_addr is to be created\r
1549  * @page: The page to be mapped\r
1550  * @offset: The offset within the page\r
1551  * @size: The size of the region in bytes\r
1552  * @direction: The direction of the DMA\r
1553  */\r
1554 static inline u64 ib_dma_map_page(struct ib_device *dev,\r
1555                                   struct page *page,\r
1556                                   unsigned long offset,\r
1557                                   size_t size,\r
1558                                          enum dma_data_direction direction)\r
1559 {\r
1560         if (dev->dma_ops)\r
1561                 return dev->dma_ops->map_page(dev, page, offset, size, direction);\r
1562         return dma_map_page(dev->dma_device, page, offset, size, direction);\r
1563 }\r
1564 \r
1565 /**\r
1566  * ib_dma_unmap_page - Destroy a mapping created by ib_dma_map_page()\r
1567  * @dev: The device for which the DMA address was created\r
1568  * @addr: The DMA address\r
1569  * @size: The size of the region in bytes\r
1570  * @direction: The direction of the DMA\r
1571  */\r
1572 static inline void ib_dma_unmap_page(struct ib_device *dev,\r
1573                                      u64 addr, size_t size,\r
1574                                      enum dma_data_direction direction)\r
1575 {\r
1576         if (dev->dma_ops)\r
1577                 dev->dma_ops->unmap_page(dev, addr, size, direction);\r
1578         else\r
1579                 dma_unmap_page(dev->dma_device, addr, size, direction);\r
1580 }\r
1581 \r
1582 /**\r
1583  * ib_dma_map_sg - Map a scatter/gather list to DMA addresses\r
1584  * @dev: The device for which the DMA addresses are to be created\r
1585  * @sg: The array of scatter/gather entries\r
1586  * @nents: The number of scatter/gather entries\r
1587  * @direction: The direction of the DMA\r
1588  */\r
1589 static inline int ib_dma_map_sg(struct ib_device *dev,\r
1590                                 struct scatterlist *sg, int nents,\r
1591                                 enum dma_data_direction direction)\r
1592 {\r
1593         if (dev->dma_ops)\r
1594                 return dev->dma_ops->map_sg(dev, sg, nents, direction);\r
1595         return dma_map_sg(dev->dma_device, sg, nents, direction);\r
1596 }\r
1597 \r
1598 /**\r
1599  * ib_dma_unmap_sg - Unmap a scatter/gather list of DMA addresses\r
1600  * @dev: The device for which the DMA addresses were created\r
1601  * @sg: The array of scatter/gather entries\r
1602  * @nents: The number of scatter/gather entries\r
1603  * @direction: The direction of the DMA\r
1604  */\r
1605 static inline void ib_dma_unmap_sg(struct ib_device *dev,\r
1606                                    struct scatterlist *sg, int nents,\r
1607                                    enum dma_data_direction direction)\r
1608 {\r
1609         if (dev->dma_ops)\r
1610                 dev->dma_ops->unmap_sg(dev, sg, nents, direction);\r
1611         else\r
1612                 dma_unmap_sg(dev->dma_device, sg, nents, direction);\r
1613 }\r
1614 \r
1615 /**\r
1616  * ib_sg_dma_address - Return the DMA address from a scatter/gather entry\r
1617  * @dev: The device for which the DMA addresses were created\r
1618  * @sg: The scatter/gather entry\r
1619  */\r
1620 static inline u64 ib_sg_dma_address(struct ib_device *dev,\r
1621                                     struct scatterlist *sg)\r
1622 {\r
1623         if (dev->dma_ops)\r
1624                 return dev->dma_ops->dma_address(dev, sg);\r
1625         return sg_dma_address(sg);\r
1626 }\r
1627 \r
1628 /**\r
1629  * ib_sg_dma_len - Return the DMA length from a scatter/gather entry\r
1630  * @dev: The device for which the DMA addresses were created\r
1631  * @sg: The scatter/gather entry\r
1632  */\r
1633 static inline unsigned int ib_sg_dma_len(struct ib_device *dev,\r
1634                                          struct scatterlist *sg)\r
1635 {\r
1636         if (dev->dma_ops)\r
1637                 return dev->dma_ops->dma_len(dev, sg);\r
1638         return sg_dma_len(sg);\r
1639 }\r
1640 \r
1641 /**\r
1642  * ib_dma_sync_single_for_cpu - Prepare DMA region to be accessed by CPU\r
1643  * @dev: The device for which the DMA address was created\r
1644  * @addr: The DMA address\r
1645  * @size: The size of the region in bytes\r
1646  * @dir: The direction of the DMA\r
1647  */\r
1648 static inline void ib_dma_sync_single_for_cpu(struct ib_device *dev,\r
1649                                               u64 addr,\r
1650                                               size_t size,\r
1651                                               enum dma_data_direction dir)\r
1652 {\r
1653         if (dev->dma_ops)\r
1654                 dev->dma_ops->sync_single_for_cpu(dev, addr, size, dir);\r
1655         else\r
1656                 dma_sync_single_for_cpu(dev->dma_device, addr, size, dir);\r
1657 }\r
1658 \r
1659 /**\r
1660  * ib_dma_sync_single_for_device - Prepare DMA region to be accessed by device\r
1661  * @dev: The device for which the DMA address was created\r
1662  * @addr: The DMA address\r
1663  * @size: The size of the region in bytes\r
1664  * @dir: The direction of the DMA\r
1665  */\r
1666 static inline void ib_dma_sync_single_for_device(struct ib_device *dev,\r
1667                                                  u64 addr,\r
1668                                                  size_t size,\r
1669                                                  enum dma_data_direction dir)\r
1670 {\r
1671         if (dev->dma_ops)\r
1672                 dev->dma_ops->sync_single_for_device(dev, addr, size, dir);\r
1673         else\r
1674                 dma_sync_single_for_device(dev->dma_device, addr, size, dir);\r
1675 }\r
1676 \r
1677 /**\r
1678  * ib_dma_alloc_coherent - Allocate memory and map it for DMA\r
1679  * @dev: The device for which the DMA address is requested\r
1680  * @size: The size of the region to allocate in bytes\r
1681  * @dma_handle: A pointer for returning the DMA address of the region\r
1682  * @flag: memory allocator flags\r
1683  */\r
1684 static inline void *ib_dma_alloc_coherent(struct ib_device *dev,\r
1685                                            size_t size,\r
1686                                            u64 *dma_handle,\r
1687                                            gfp_t flag)\r
1688 {\r
1689         if (dev->dma_ops)\r
1690                 return dev->dma_ops->alloc_coherent(dev, size, dma_handle, flag);\r
1691         else {\r
1692                 dma_addr_t handle;\r
1693                 void *ret;\r
1694 \r
1695                 ret = dma_alloc_coherent(dev->dma_device, size, &handle, flag);\r
1696                 *dma_handle = handle;\r
1697                 return ret;\r
1698         }\r
1699 }\r
1700 \r
1701 /**\r
1702  * ib_dma_free_coherent - Free memory allocated by ib_dma_alloc_coherent()\r
1703  * @dev: The device for which the DMA addresses were allocated\r
1704  * @size: The size of the region\r
1705  * @cpu_addr: the address returned by ib_dma_alloc_coherent()\r
1706  * @dma_handle: the DMA address returned by ib_dma_alloc_coherent()\r
1707  */\r
1708 static inline void ib_dma_free_coherent(struct ib_device *dev,\r
1709                                         size_t size, void *cpu_addr,\r
1710                                         u64 dma_handle)\r
1711 {\r
1712         if (dev->dma_ops)\r
1713                 dev->dma_ops->free_coherent(dev, size, cpu_addr, dma_handle);\r
1714         else\r
1715                 dma_free_coherent(dev->dma_device, size, cpu_addr, dma_handle);\r
1716 }\r
1717 \r
1718 #endif\r
1719 \r
1720 /**\r
1721  * ib_reg_phys_mr - Prepares a virtually addressed memory region for use\r
1722  *   by an HCA.\r
1723  * @pd: The protection domain associated assigned to the registered region.\r
1724  * @phys_buf_array: Specifies a list of physical buffers to use in the\r
1725  *   memory region.\r
1726  * @num_phys_buf: Specifies the size of the phys_buf_array.\r
1727  * @mr_access_flags: Specifies the memory access rights.\r
1728  * @iova_start: The offset of the region's starting I/O virtual address.\r
1729  */\r
1730 struct ib_mr *ib_reg_phys_mr(struct ib_pd *pd,\r
1731                              struct ib_phys_buf *phys_buf_array,\r
1732                              int num_phys_buf,\r
1733                              int mr_access_flags,\r
1734                              u64 *iova_start);\r
1735 \r
1736 /**\r
1737  * ib_rereg_phys_mr - Modifies the attributes of an existing memory region.\r
1738  *   Conceptually, this call performs the functions deregister memory region\r
1739  *   followed by register physical memory region.  Where possible,\r
1740  *   resources are reused instead of deallocated and reallocated.\r
1741  * @mr: The memory region to modify.\r
1742  * @mr_rereg_mask: A bit-mask used to indicate which of the following\r
1743  *   properties of the memory region are being modified.\r
1744  * @pd: If %IB_MR_REREG_PD is set in mr_rereg_mask, this field specifies\r
1745  *   the new protection domain to associated with the memory region,\r
1746  *   otherwise, this parameter is ignored.\r
1747  * @phys_buf_array: If %IB_MR_REREG_TRANS is set in mr_rereg_mask, this\r
1748  *   field specifies a list of physical buffers to use in the new\r
1749  *   translation, otherwise, this parameter is ignored.\r
1750  * @num_phys_buf: If %IB_MR_REREG_TRANS is set in mr_rereg_mask, this\r
1751  *   field specifies the size of the phys_buf_array, otherwise, this\r
1752  *   parameter is ignored.\r
1753  * @mr_access_flags: If %IB_MR_REREG_ACCESS is set in mr_rereg_mask, this\r
1754  *   field specifies the new memory access rights, otherwise, this\r
1755  *   parameter is ignored.\r
1756  * @iova_start: The offset of the region's starting I/O virtual address.\r
1757  */\r
1758 int ib_rereg_phys_mr(struct ib_mr *mr,\r
1759                      int mr_rereg_mask,\r
1760                      struct ib_pd *pd,\r
1761                      struct ib_phys_buf *phys_buf_array,\r
1762                      int num_phys_buf,\r
1763                      int mr_access_flags,\r
1764                      u64 *iova_start);\r
1765 \r
1766 /**\r
1767  * ib_query_mr - Retrieves information about a specific memory region.\r
1768  * @mr: The memory region to retrieve information about.\r
1769  * @mr_attr: The attributes of the specified memory region.\r
1770  */\r
1771 int ib_query_mr(struct ib_mr *mr, struct ib_mr_attr *mr_attr);\r
1772 \r
1773 /**\r
1774  * ib_dereg_mr - Deregisters a memory region and removes it from the\r
1775  *   HCA translation table.\r
1776  * @mr: The memory region to deregister.\r
1777  */\r
1778 int ib_dereg_mr(struct ib_mr *mr);\r
1779 \r
1780 /**\r
1781  * ib_alloc_mw - Allocates a memory window.\r
1782  * @pd: The protection domain associated with the memory window.\r
1783  */\r
1784 struct ib_mw *ib_alloc_mw(struct ib_pd *pd);\r
1785 \r
1786 /**\r
1787  * ib_bind_mw - Posts a work request to the send queue of the specified\r
1788  *   QP, which binds the memory window to the given address range and\r
1789  *   remote access attributes.\r
1790  * @qp: QP to post the bind work request on.\r
1791  * @mw: The memory window to bind.\r
1792  * @mw_bind: Specifies information about the memory window, including\r
1793  *   its address range, remote access rights, and associated memory region.\r
1794  */\r
1795 static inline int ib_bind_mw(struct ib_qp *qp,\r
1796                              struct ib_mw *mw,\r
1797                              struct ib_mw_bind *mw_bind)\r
1798 {\r
1799         /* XXX reference counting in corresponding MR? */\r
1800         return mw->device->bind_mw ?\r
1801                 mw->device->bind_mw(qp, mw, mw_bind) :\r
1802                 -ENOSYS;\r
1803 }\r
1804 \r
1805 /**\r
1806  * ib_dealloc_mw - Deallocates a memory window.\r
1807  * @mw: The memory window to deallocate.\r
1808  */\r
1809 int ib_dealloc_mw(struct ib_mw *mw);\r
1810 \r
1811 /**\r
1812  * ib_alloc_fmr - Allocates a unmapped fast memory region.\r
1813  * @pd: The protection domain associated with the unmapped region.\r
1814  * @mr_access_flags: Specifies the memory access rights.\r
1815  * @fmr_attr: Attributes of the unmapped region.\r
1816  *\r
1817  * A fast memory region must be mapped before it can be used as part of\r
1818  * a work request.\r
1819  */\r
1820 struct ib_fmr *ib_alloc_fmr(struct ib_pd *pd,\r
1821                             int mr_access_flags,\r
1822                             struct ib_fmr_attr *fmr_attr);\r
1823 \r
1824 /**\r
1825  * ib_map_phys_fmr - Maps a list of physical pages to a fast memory region.\r
1826  * @fmr: The fast memory region to associate with the pages.\r
1827  * @page_list: An array of physical pages to map to the fast memory region.\r
1828  * @list_len: The number of pages in page_list.\r
1829  * @iova: The I/O virtual address to use with the mapped region.\r
1830  */\r
1831 static inline int ib_map_phys_fmr(struct ib_fmr *fmr,\r
1832                                   u64 *page_list, int list_len,\r
1833                                   u64 iova)\r
1834 {\r
1835         return fmr->device->map_phys_fmr(fmr, page_list, list_len, iova);\r
1836 }\r
1837 \r
1838 /**\r
1839  * ib_unmap_fmr - Removes the mapping from a list of fast memory regions.\r
1840  * @fmr_list: A linked list of fast memory regions to unmap.\r
1841  */\r
1842 int ib_unmap_fmr(struct list_head *fmr_list);\r
1843 \r
1844 /**\r
1845  * ib_dealloc_fmr - Deallocates a fast memory region.\r
1846  * @fmr: The fast memory region to deallocate.\r
1847  */\r
1848 int ib_dealloc_fmr(struct ib_fmr *fmr);\r
1849 \r
1850 /**\r
1851  * ib_attach_mcast - Attaches the specified QP to a multicast group.\r
1852  * @qp: QP to attach to the multicast group.  The QP must be type\r
1853  *   IB_QPT_UD.\r
1854  * @gid: Multicast group GID.\r
1855  * @lid: Multicast group LID in host byte order.\r
1856  *\r
1857  * In order to send and receive multicast packets, subnet\r
1858  * administration must have created the multicast group and configured\r
1859  * the fabric appropriately.  The port associated with the specified\r
1860  * QP must also be a member of the multicast group.\r
1861  */\r
1862 int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);\r
1863 \r
1864 /**\r
1865  * ib_detach_mcast - Detaches the specified QP from a multicast group.\r
1866  * @qp: QP to detach from the multicast group.\r
1867  * @gid: Multicast group GID.\r
1868  * @lid: Multicast group LID in host byte order.\r
1869  */\r
1870 int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);\r
1871 \r
1872 #endif /* IB_VERBS_H */\r