]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - include/rdma/ib_verbs.h
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


1082b4c81b2ce607e11c4b69b5d7de1124edc0af
[mirror_ubuntu-bionic-kernel.git] / include / rdma / ib_verbs.h
1 /*
2 * Copyright (c) 2004 Mellanox Technologies Ltd. All rights reserved.
3 * Copyright (c) 2004 Infinicon Corporation. All rights reserved.
4 * Copyright (c) 2004 Intel Corporation. All rights reserved.
5 * Copyright (c) 2004 Topspin Corporation. All rights reserved.
6 * Copyright (c) 2004 Voltaire Corporation. All rights reserved.
7 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
8 * Copyright (c) 2005, 2006, 2007 Cisco Systems. All rights reserved.
9 *
10 * This software is available to you under a choice of one of two
11 * licenses. You may choose to be licensed under the terms of the GNU
12 * General Public License (GPL) Version 2, available from the file
13 * COPYING in the main directory of this source tree, or the
14 * OpenIB.org BSD license below:
15 *
16 * Redistribution and use in source and binary forms, with or
17 * without modification, are permitted provided that the following
18 * conditions are met:
19 *
20 * - Redistributions of source code must retain the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer.
23 *
24 * - Redistributions in binary form must reproduce the above
25 * copyright notice, this list of conditions and the following
26 * disclaimer in the documentation and/or other materials
27 * provided with the distribution.
28 *
29 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
30 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
31 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
32 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
33 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
34 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
35 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
36 * SOFTWARE.
37 */
38
39 #if !defined(IB_VERBS_H)
40 #define IB_VERBS_H
41
42 #include <linux/types.h>
43 #include <linux/device.h>
44 #include <linux/mm.h>
45 #include <linux/dma-mapping.h>
46 #include <linux/kref.h>
47 #include <linux/list.h>
48 #include <linux/rwsem.h>
49 #include <linux/scatterlist.h>
50 #include <linux/workqueue.h>
51 #include <linux/socket.h>
52 #include <linux/irq_poll.h>
53 #include <uapi/linux/if_ether.h>
54 #include <net/ipv6.h>
55 #include <net/ip.h>
56 #include <linux/string.h>
57 #include <linux/slab.h>
58 #include <linux/netdevice.h>
59
60 #include <linux/if_link.h>
61 #include <linux/atomic.h>
62 #include <linux/mmu_notifier.h>
63 #include <linux/uaccess.h>
64 #include <linux/cgroup_rdma.h>
65 #include <uapi/rdma/ib_user_verbs.h>
66
67 extern struct workqueue_struct *ib_wq;
68 extern struct workqueue_struct *ib_comp_wq;
69
70 union ib_gid {
71 u8 raw[16];
72 struct {
73 __be64 subnet_prefix;
74 __be64 interface_id;
75 } global;
76 };
77
78 extern union ib_gid zgid;
79
80 enum ib_gid_type {
81 /* If link layer is Ethernet, this is RoCE V1 */
82 IB_GID_TYPE_IB = 0,
83 IB_GID_TYPE_ROCE = 0,
84 IB_GID_TYPE_ROCE_UDP_ENCAP = 1,
85 IB_GID_TYPE_SIZE
86 };
87
88 #define ROCE_V2_UDP_DPORT 4791
89 struct ib_gid_attr {
90 enum ib_gid_type gid_type;
91 struct net_device *ndev;
92 };
93
94 enum rdma_node_type {
95 /* IB values map to NodeInfo:NodeType. */
96 RDMA_NODE_IB_CA = 1,
97 RDMA_NODE_IB_SWITCH,
98 RDMA_NODE_IB_ROUTER,
99 RDMA_NODE_RNIC,
100 RDMA_NODE_USNIC,
101 RDMA_NODE_USNIC_UDP,
102 };
103
104 enum {
105 /* set the local administered indication */
106 IB_SA_WELL_KNOWN_GUID = BIT_ULL(57) | 2,
107 };
108
109 enum rdma_transport_type {
110 RDMA_TRANSPORT_IB,
111 RDMA_TRANSPORT_IWARP,
112 RDMA_TRANSPORT_USNIC,
113 RDMA_TRANSPORT_USNIC_UDP
114 };
115
116 enum rdma_protocol_type {
117 RDMA_PROTOCOL_IB,
118 RDMA_PROTOCOL_IBOE,
119 RDMA_PROTOCOL_IWARP,
120 RDMA_PROTOCOL_USNIC_UDP
121 };
122
123 __attribute_const__ enum rdma_transport_type
124 rdma_node_get_transport(enum rdma_node_type node_type);
125
126 enum rdma_network_type {
127 RDMA_NETWORK_IB,
128 RDMA_NETWORK_ROCE_V1 = RDMA_NETWORK_IB,
129 RDMA_NETWORK_IPV4,
130 RDMA_NETWORK_IPV6
131 };
132
133 static inline enum ib_gid_type ib_network_to_gid_type(enum rdma_network_type network_type)
134 {
135 if (network_type == RDMA_NETWORK_IPV4 ||
136 network_type == RDMA_NETWORK_IPV6)
137 return IB_GID_TYPE_ROCE_UDP_ENCAP;
138
139 /* IB_GID_TYPE_IB same as RDMA_NETWORK_ROCE_V1 */
140 return IB_GID_TYPE_IB;
141 }
142
143 static inline enum rdma_network_type ib_gid_to_network_type(enum ib_gid_type gid_type,
144 union ib_gid *gid)
145 {
146 if (gid_type == IB_GID_TYPE_IB)
147 return RDMA_NETWORK_IB;
148
149 if (ipv6_addr_v4mapped((struct in6_addr *)gid))
150 return RDMA_NETWORK_IPV4;
151 else
152 return RDMA_NETWORK_IPV6;
153 }
154
155 enum rdma_link_layer {
156 IB_LINK_LAYER_UNSPECIFIED,
157 IB_LINK_LAYER_INFINIBAND,
158 IB_LINK_LAYER_ETHERNET,
159 };
160
161 enum ib_device_cap_flags {
162 IB_DEVICE_RESIZE_MAX_WR = (1 << 0),
163 IB_DEVICE_BAD_PKEY_CNTR = (1 << 1),
164 IB_DEVICE_BAD_QKEY_CNTR = (1 << 2),
165 IB_DEVICE_RAW_MULTI = (1 << 3),
166 IB_DEVICE_AUTO_PATH_MIG = (1 << 4),
167 IB_DEVICE_CHANGE_PHY_PORT = (1 << 5),
168 IB_DEVICE_UD_AV_PORT_ENFORCE = (1 << 6),
169 IB_DEVICE_CURR_QP_STATE_MOD = (1 << 7),
170 IB_DEVICE_SHUTDOWN_PORT = (1 << 8),
171 IB_DEVICE_INIT_TYPE = (1 << 9),
172 IB_DEVICE_PORT_ACTIVE_EVENT = (1 << 10),
173 IB_DEVICE_SYS_IMAGE_GUID = (1 << 11),
174 IB_DEVICE_RC_RNR_NAK_GEN = (1 << 12),
175 IB_DEVICE_SRQ_RESIZE = (1 << 13),
176 IB_DEVICE_N_NOTIFY_CQ = (1 << 14),
177
178 /*
179 * This device supports a per-device lkey or stag that can be
180 * used without performing a memory registration for the local
181 * memory. Note that ULPs should never check this flag, but
182 * instead of use the local_dma_lkey flag in the ib_pd structure,
183 * which will always contain a usable lkey.
184 */
185 IB_DEVICE_LOCAL_DMA_LKEY = (1 << 15),
186 IB_DEVICE_RESERVED /* old SEND_W_INV */ = (1 << 16),
187 IB_DEVICE_MEM_WINDOW = (1 << 17),
188 /*
189 * Devices should set IB_DEVICE_UD_IP_SUM if they support
190 * insertion of UDP and TCP checksum on outgoing UD IPoIB
191 * messages and can verify the validity of checksum for
192 * incoming messages. Setting this flag implies that the
193 * IPoIB driver may set NETIF_F_IP_CSUM for datagram mode.
194 */
195 IB_DEVICE_UD_IP_CSUM = (1 << 18),
196 IB_DEVICE_UD_TSO = (1 << 19),
197 IB_DEVICE_XRC = (1 << 20),
198
199 /*
200 * This device supports the IB "base memory management extension",
201 * which includes support for fast registrations (IB_WR_REG_MR,
202 * IB_WR_LOCAL_INV and IB_WR_SEND_WITH_INV verbs). This flag should
203 * also be set by any iWarp device which must support FRs to comply
204 * to the iWarp verbs spec. iWarp devices also support the
205 * IB_WR_RDMA_READ_WITH_INV verb for RDMA READs that invalidate the
206 * stag.
207 */
208 IB_DEVICE_MEM_MGT_EXTENSIONS = (1 << 21),
209 IB_DEVICE_BLOCK_MULTICAST_LOOPBACK = (1 << 22),
210 IB_DEVICE_MEM_WINDOW_TYPE_2A = (1 << 23),
211 IB_DEVICE_MEM_WINDOW_TYPE_2B = (1 << 24),
212 IB_DEVICE_RC_IP_CSUM = (1 << 25),
213 /* Deprecated. Please use IB_RAW_PACKET_CAP_IP_CSUM. */
214 IB_DEVICE_RAW_IP_CSUM = (1 << 26),
215 /*
216 * Devices should set IB_DEVICE_CROSS_CHANNEL if they
217 * support execution of WQEs that involve synchronization
218 * of I/O operations with single completion queue managed
219 * by hardware.
220 */
221 IB_DEVICE_CROSS_CHANNEL = (1 << 27),
222 IB_DEVICE_MANAGED_FLOW_STEERING = (1 << 29),
223 IB_DEVICE_SIGNATURE_HANDOVER = (1 << 30),
224 IB_DEVICE_ON_DEMAND_PAGING = (1ULL << 31),
225 IB_DEVICE_SG_GAPS_REG = (1ULL << 32),
226 IB_DEVICE_VIRTUAL_FUNCTION = (1ULL << 33),
227 /* Deprecated. Please use IB_RAW_PACKET_CAP_SCATTER_FCS. */
228 IB_DEVICE_RAW_SCATTER_FCS = (1ULL << 34),
229 IB_DEVICE_RDMA_NETDEV_OPA_VNIC = (1ULL << 35),
230 };
231
232 enum ib_signature_prot_cap {
233 IB_PROT_T10DIF_TYPE_1 = 1,
234 IB_PROT_T10DIF_TYPE_2 = 1 << 1,
235 IB_PROT_T10DIF_TYPE_3 = 1 << 2,
236 };
237
238 enum ib_signature_guard_cap {
239 IB_GUARD_T10DIF_CRC = 1,
240 IB_GUARD_T10DIF_CSUM = 1 << 1,
241 };
242
243 enum ib_atomic_cap {
244 IB_ATOMIC_NONE,
245 IB_ATOMIC_HCA,
246 IB_ATOMIC_GLOB
247 };
248
249 enum ib_odp_general_cap_bits {
250 IB_ODP_SUPPORT = 1 << 0,
251 IB_ODP_SUPPORT_IMPLICIT = 1 << 1,
252 };
253
254 enum ib_odp_transport_cap_bits {
255 IB_ODP_SUPPORT_SEND = 1 << 0,
256 IB_ODP_SUPPORT_RECV = 1 << 1,
257 IB_ODP_SUPPORT_WRITE = 1 << 2,
258 IB_ODP_SUPPORT_READ = 1 << 3,
259 IB_ODP_SUPPORT_ATOMIC = 1 << 4,
260 };
261
262 struct ib_odp_caps {
263 uint64_t general_caps;
264 struct {
265 uint32_t rc_odp_caps;
266 uint32_t uc_odp_caps;
267 uint32_t ud_odp_caps;
268 } per_transport_caps;
269 };
270
271 struct ib_rss_caps {
272 /* Corresponding bit will be set if qp type from
273 * 'enum ib_qp_type' is supported, e.g.
274 * supported_qpts |= 1 << IB_QPT_UD
275 */
276 u32 supported_qpts;
277 u32 max_rwq_indirection_tables;
278 u32 max_rwq_indirection_table_size;
279 };
280
281 enum ib_cq_creation_flags {
282 IB_CQ_FLAGS_TIMESTAMP_COMPLETION = 1 << 0,
283 IB_CQ_FLAGS_IGNORE_OVERRUN = 1 << 1,
284 };
285
286 struct ib_cq_init_attr {
287 unsigned int cqe;
288 int comp_vector;
289 u32 flags;
290 };
291
292 struct ib_device_attr {
293 u64 fw_ver;
294 __be64 sys_image_guid;
295 u64 max_mr_size;
296 u64 page_size_cap;
297 u32 vendor_id;
298 u32 vendor_part_id;
299 u32 hw_ver;
300 int max_qp;
301 int max_qp_wr;
302 u64 device_cap_flags;
303 int max_sge;
304 int max_sge_rd;
305 int max_cq;
306 int max_cqe;
307 int max_mr;
308 int max_pd;
309 int max_qp_rd_atom;
310 int max_ee_rd_atom;
311 int max_res_rd_atom;
312 int max_qp_init_rd_atom;
313 int max_ee_init_rd_atom;
314 enum ib_atomic_cap atomic_cap;
315 enum ib_atomic_cap masked_atomic_cap;
316 int max_ee;
317 int max_rdd;
318 int max_mw;
319 int max_raw_ipv6_qp;
320 int max_raw_ethy_qp;
321 int max_mcast_grp;
322 int max_mcast_qp_attach;
323 int max_total_mcast_qp_attach;
324 int max_ah;
325 int max_fmr;
326 int max_map_per_fmr;
327 int max_srq;
328 int max_srq_wr;
329 int max_srq_sge;
330 unsigned int max_fast_reg_page_list_len;
331 u16 max_pkeys;
332 u8 local_ca_ack_delay;
333 int sig_prot_cap;
334 int sig_guard_cap;
335 struct ib_odp_caps odp_caps;
336 uint64_t timestamp_mask;
337 uint64_t hca_core_clock; /* in KHZ */
338 struct ib_rss_caps rss_caps;
339 u32 max_wq_type_rq;
340 u32 raw_packet_caps; /* Use ib_raw_packet_caps enum */
341 };
342
343 enum ib_mtu {
344 IB_MTU_256 = 1,
345 IB_MTU_512 = 2,
346 IB_MTU_1024 = 3,
347 IB_MTU_2048 = 4,
348 IB_MTU_4096 = 5
349 };
350
351 static inline int ib_mtu_enum_to_int(enum ib_mtu mtu)
352 {
353 switch (mtu) {
354 case IB_MTU_256: return 256;
355 case IB_MTU_512: return 512;
356 case IB_MTU_1024: return 1024;
357 case IB_MTU_2048: return 2048;
358 case IB_MTU_4096: return 4096;
359 default: return -1;
360 }
361 }
362
363 static inline enum ib_mtu ib_mtu_int_to_enum(int mtu)
364 {
365 if (mtu >= 4096)
366 return IB_MTU_4096;
367 else if (mtu >= 2048)
368 return IB_MTU_2048;
369 else if (mtu >= 1024)
370 return IB_MTU_1024;
371 else if (mtu >= 512)
372 return IB_MTU_512;
373 else
374 return IB_MTU_256;
375 }
376
377 enum ib_port_state {
378 IB_PORT_NOP = 0,
379 IB_PORT_DOWN = 1,
380 IB_PORT_INIT = 2,
381 IB_PORT_ARMED = 3,
382 IB_PORT_ACTIVE = 4,
383 IB_PORT_ACTIVE_DEFER = 5
384 };
385
386 enum ib_port_cap_flags {
387 IB_PORT_SM = 1 << 1,
388 IB_PORT_NOTICE_SUP = 1 << 2,
389 IB_PORT_TRAP_SUP = 1 << 3,
390 IB_PORT_OPT_IPD_SUP = 1 << 4,
391 IB_PORT_AUTO_MIGR_SUP = 1 << 5,
392 IB_PORT_SL_MAP_SUP = 1 << 6,
393 IB_PORT_MKEY_NVRAM = 1 << 7,
394 IB_PORT_PKEY_NVRAM = 1 << 8,
395 IB_PORT_LED_INFO_SUP = 1 << 9,
396 IB_PORT_SM_DISABLED = 1 << 10,
397 IB_PORT_SYS_IMAGE_GUID_SUP = 1 << 11,
398 IB_PORT_PKEY_SW_EXT_PORT_TRAP_SUP = 1 << 12,
399 IB_PORT_EXTENDED_SPEEDS_SUP = 1 << 14,
400 IB_PORT_CM_SUP = 1 << 16,
401 IB_PORT_SNMP_TUNNEL_SUP = 1 << 17,
402 IB_PORT_REINIT_SUP = 1 << 18,
403 IB_PORT_DEVICE_MGMT_SUP = 1 << 19,
404 IB_PORT_VENDOR_CLASS_SUP = 1 << 20,
405 IB_PORT_DR_NOTICE_SUP = 1 << 21,
406 IB_PORT_CAP_MASK_NOTICE_SUP = 1 << 22,
407 IB_PORT_BOOT_MGMT_SUP = 1 << 23,
408 IB_PORT_LINK_LATENCY_SUP = 1 << 24,
409 IB_PORT_CLIENT_REG_SUP = 1 << 25,
410 IB_PORT_IP_BASED_GIDS = 1 << 26,
411 };
412
413 enum ib_port_width {
414 IB_WIDTH_1X = 1,
415 IB_WIDTH_4X = 2,
416 IB_WIDTH_8X = 4,
417 IB_WIDTH_12X = 8
418 };
419
420 static inline int ib_width_enum_to_int(enum ib_port_width width)
421 {
422 switch (width) {
423 case IB_WIDTH_1X: return 1;
424 case IB_WIDTH_4X: return 4;
425 case IB_WIDTH_8X: return 8;
426 case IB_WIDTH_12X: return 12;
427 default: return -1;
428 }
429 }
430
431 enum ib_port_speed {
432 IB_SPEED_SDR = 1,
433 IB_SPEED_DDR = 2,
434 IB_SPEED_QDR = 4,
435 IB_SPEED_FDR10 = 8,
436 IB_SPEED_FDR = 16,
437 IB_SPEED_EDR = 32,
438 IB_SPEED_HDR = 64
439 };
440
441 /**
442 * struct rdma_hw_stats
443 * @timestamp - Used by the core code to track when the last update was
444 * @lifespan - Used by the core code to determine how old the counters
445 * should be before being updated again. Stored in jiffies, defaults
446 * to 10 milliseconds, drivers can override the default be specifying
447 * their own value during their allocation routine.
448 * @name - Array of pointers to static names used for the counters in
449 * directory.
450 * @num_counters - How many hardware counters there are. If name is
451 * shorter than this number, a kernel oops will result. Driver authors
452 * are encouraged to leave BUILD_BUG_ON(ARRAY_SIZE(@name) < num_counters)
453 * in their code to prevent this.
454 * @value - Array of u64 counters that are accessed by the sysfs code and
455 * filled in by the drivers get_stats routine
456 */
457 struct rdma_hw_stats {
458 unsigned long timestamp;
459 unsigned long lifespan;
460 const char * const *names;
461 int num_counters;
462 u64 value[];
463 };
464
465 #define RDMA_HW_STATS_DEFAULT_LIFESPAN 10
466 /**
467 * rdma_alloc_hw_stats_struct - Helper function to allocate dynamic struct
468 * for drivers.
469 * @names - Array of static const char *
470 * @num_counters - How many elements in array
471 * @lifespan - How many milliseconds between updates
472 */
473 static inline struct rdma_hw_stats *rdma_alloc_hw_stats_struct(
474 const char * const *names, int num_counters,
475 unsigned long lifespan)
476 {
477 struct rdma_hw_stats *stats;
478
479 stats = kzalloc(sizeof(*stats) + num_counters * sizeof(u64),
480 GFP_KERNEL);
481 if (!stats)
482 return NULL;
483 stats->names = names;
484 stats->num_counters = num_counters;
485 stats->lifespan = msecs_to_jiffies(lifespan);
486
487 return stats;
488 }
489
490
491 /* Define bits for the various functionality this port needs to be supported by
492 * the core.
493 */
494 /* Management 0x00000FFF */
495 #define RDMA_CORE_CAP_IB_MAD 0x00000001
496 #define RDMA_CORE_CAP_IB_SMI 0x00000002
497 #define RDMA_CORE_CAP_IB_CM 0x00000004
498 #define RDMA_CORE_CAP_IW_CM 0x00000008
499 #define RDMA_CORE_CAP_IB_SA 0x00000010
500 #define RDMA_CORE_CAP_OPA_MAD 0x00000020
501
502 /* Address format 0x000FF000 */
503 #define RDMA_CORE_CAP_AF_IB 0x00001000
504 #define RDMA_CORE_CAP_ETH_AH 0x00002000
505 #define RDMA_CORE_CAP_OPA_AH 0x00004000
506
507 /* Protocol 0xFFF00000 */
508 #define RDMA_CORE_CAP_PROT_IB 0x00100000
509 #define RDMA_CORE_CAP_PROT_ROCE 0x00200000
510 #define RDMA_CORE_CAP_PROT_IWARP 0x00400000
511 #define RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP 0x00800000
512 #define RDMA_CORE_CAP_PROT_RAW_PACKET 0x01000000
513 #define RDMA_CORE_CAP_PROT_USNIC 0x02000000
514
515 #define RDMA_CORE_PORT_IBA_IB (RDMA_CORE_CAP_PROT_IB \
516 | RDMA_CORE_CAP_IB_MAD \
517 | RDMA_CORE_CAP_IB_SMI \
518 | RDMA_CORE_CAP_IB_CM \
519 | RDMA_CORE_CAP_IB_SA \
520 | RDMA_CORE_CAP_AF_IB)
521 #define RDMA_CORE_PORT_IBA_ROCE (RDMA_CORE_CAP_PROT_ROCE \
522 | RDMA_CORE_CAP_IB_MAD \
523 | RDMA_CORE_CAP_IB_CM \
524 | RDMA_CORE_CAP_AF_IB \
525 | RDMA_CORE_CAP_ETH_AH)
526 #define RDMA_CORE_PORT_IBA_ROCE_UDP_ENCAP \
527 (RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP \
528 | RDMA_CORE_CAP_IB_MAD \
529 | RDMA_CORE_CAP_IB_CM \
530 | RDMA_CORE_CAP_AF_IB \
531 | RDMA_CORE_CAP_ETH_AH)
532 #define RDMA_CORE_PORT_IWARP (RDMA_CORE_CAP_PROT_IWARP \
533 | RDMA_CORE_CAP_IW_CM)
534 #define RDMA_CORE_PORT_INTEL_OPA (RDMA_CORE_PORT_IBA_IB \
535 | RDMA_CORE_CAP_OPA_MAD)
536
537 #define RDMA_CORE_PORT_RAW_PACKET (RDMA_CORE_CAP_PROT_RAW_PACKET)
538
539 #define RDMA_CORE_PORT_USNIC (RDMA_CORE_CAP_PROT_USNIC)
540
541 struct ib_port_attr {
542 u64 subnet_prefix;
543 enum ib_port_state state;
544 enum ib_mtu max_mtu;
545 enum ib_mtu active_mtu;
546 int gid_tbl_len;
547 u32 port_cap_flags;
548 u32 max_msg_sz;
549 u32 bad_pkey_cntr;
550 u32 qkey_viol_cntr;
551 u16 pkey_tbl_len;
552 u16 lid;
553 u16 sm_lid;
554 u8 lmc;
555 u8 max_vl_num;
556 u8 sm_sl;
557 u8 subnet_timeout;
558 u8 init_type_reply;
559 u8 active_width;
560 u8 active_speed;
561 u8 phys_state;
562 bool grh_required;
563 };
564
565 enum ib_device_modify_flags {
566 IB_DEVICE_MODIFY_SYS_IMAGE_GUID = 1 << 0,
567 IB_DEVICE_MODIFY_NODE_DESC = 1 << 1
568 };
569
570 #define IB_DEVICE_NODE_DESC_MAX 64
571
572 struct ib_device_modify {
573 u64 sys_image_guid;
574 char node_desc[IB_DEVICE_NODE_DESC_MAX];
575 };
576
577 enum ib_port_modify_flags {
578 IB_PORT_SHUTDOWN = 1,
579 IB_PORT_INIT_TYPE = (1<<2),
580 IB_PORT_RESET_QKEY_CNTR = (1<<3),
581 IB_PORT_OPA_MASK_CHG = (1<<4)
582 };
583
584 struct ib_port_modify {
585 u32 set_port_cap_mask;
586 u32 clr_port_cap_mask;
587 u8 init_type;
588 };
589
590 enum ib_event_type {
591 IB_EVENT_CQ_ERR,
592 IB_EVENT_QP_FATAL,
593 IB_EVENT_QP_REQ_ERR,
594 IB_EVENT_QP_ACCESS_ERR,
595 IB_EVENT_COMM_EST,
596 IB_EVENT_SQ_DRAINED,
597 IB_EVENT_PATH_MIG,
598 IB_EVENT_PATH_MIG_ERR,
599 IB_EVENT_DEVICE_FATAL,
600 IB_EVENT_PORT_ACTIVE,
601 IB_EVENT_PORT_ERR,
602 IB_EVENT_LID_CHANGE,
603 IB_EVENT_PKEY_CHANGE,
604 IB_EVENT_SM_CHANGE,
605 IB_EVENT_SRQ_ERR,
606 IB_EVENT_SRQ_LIMIT_REACHED,
607 IB_EVENT_QP_LAST_WQE_REACHED,
608 IB_EVENT_CLIENT_REREGISTER,
609 IB_EVENT_GID_CHANGE,
610 IB_EVENT_WQ_FATAL,
611 };
612
613 const char *__attribute_const__ ib_event_msg(enum ib_event_type event);
614
615 struct ib_event {
616 struct ib_device *device;
617 union {
618 struct ib_cq *cq;
619 struct ib_qp *qp;
620 struct ib_srq *srq;
621 struct ib_wq *wq;
622 u8 port_num;
623 } element;
624 enum ib_event_type event;
625 };
626
627 struct ib_event_handler {
628 struct ib_device *device;
629 void (*handler)(struct ib_event_handler *, struct ib_event *);
630 struct list_head list;
631 };
632
633 #define INIT_IB_EVENT_HANDLER(_ptr, _device, _handler) \
634 do { \
635 (_ptr)->device = _device; \
636 (_ptr)->handler = _handler; \
637 INIT_LIST_HEAD(&(_ptr)->list); \
638 } while (0)
639
640 struct ib_global_route {
641 union ib_gid dgid;
642 u32 flow_label;
643 u8 sgid_index;
644 u8 hop_limit;
645 u8 traffic_class;
646 };
647
648 struct ib_grh {
649 __be32 version_tclass_flow;
650 __be16 paylen;
651 u8 next_hdr;
652 u8 hop_limit;
653 union ib_gid sgid;
654 union ib_gid dgid;
655 };
656
657 union rdma_network_hdr {
658 struct ib_grh ibgrh;
659 struct {
660 /* The IB spec states that if it's IPv4, the header
661 * is located in the last 20 bytes of the header.
662 */
663 u8 reserved[20];
664 struct iphdr roce4grh;
665 };
666 };
667
668 #define IB_QPN_MASK 0xFFFFFF
669
670 enum {
671 IB_MULTICAST_QPN = 0xffffff
672 };
673
674 #define IB_LID_PERMISSIVE cpu_to_be16(0xFFFF)
675 #define IB_MULTICAST_LID_BASE cpu_to_be16(0xC000)
676
677 enum ib_ah_flags {
678 IB_AH_GRH = 1
679 };
680
681 enum ib_rate {
682 IB_RATE_PORT_CURRENT = 0,
683 IB_RATE_2_5_GBPS = 2,
684 IB_RATE_5_GBPS = 5,
685 IB_RATE_10_GBPS = 3,
686 IB_RATE_20_GBPS = 6,
687 IB_RATE_30_GBPS = 4,
688 IB_RATE_40_GBPS = 7,
689 IB_RATE_60_GBPS = 8,
690 IB_RATE_80_GBPS = 9,
691 IB_RATE_120_GBPS = 10,
692 IB_RATE_14_GBPS = 11,
693 IB_RATE_56_GBPS = 12,
694 IB_RATE_112_GBPS = 13,
695 IB_RATE_168_GBPS = 14,
696 IB_RATE_25_GBPS = 15,
697 IB_RATE_100_GBPS = 16,
698 IB_RATE_200_GBPS = 17,
699 IB_RATE_300_GBPS = 18
700 };
701
702 /**
703 * ib_rate_to_mult - Convert the IB rate enum to a multiple of the
704 * base rate of 2.5 Gbit/sec. For example, IB_RATE_5_GBPS will be
705 * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.
706 * @rate: rate to convert.
707 */
708 __attribute_const__ int ib_rate_to_mult(enum ib_rate rate);
709
710 /**
711 * ib_rate_to_mbps - Convert the IB rate enum to Mbps.
712 * For example, IB_RATE_2_5_GBPS will be converted to 2500.
713 * @rate: rate to convert.
714 */
715 __attribute_const__ int ib_rate_to_mbps(enum ib_rate rate);
716
717
718 /**
719 * enum ib_mr_type - memory region type
720 * @IB_MR_TYPE_MEM_REG: memory region that is used for
721 * normal registration
722 * @IB_MR_TYPE_SIGNATURE: memory region that is used for
723 * signature operations (data-integrity
724 * capable regions)
725 * @IB_MR_TYPE_SG_GAPS: memory region that is capable to
726 * register any arbitrary sg lists (without
727 * the normal mr constraints - see
728 * ib_map_mr_sg)
729 */
730 enum ib_mr_type {
731 IB_MR_TYPE_MEM_REG,
732 IB_MR_TYPE_SIGNATURE,
733 IB_MR_TYPE_SG_GAPS,
734 };
735
736 /**
737 * Signature types
738 * IB_SIG_TYPE_NONE: Unprotected.
739 * IB_SIG_TYPE_T10_DIF: Type T10-DIF
740 */
741 enum ib_signature_type {
742 IB_SIG_TYPE_NONE,
743 IB_SIG_TYPE_T10_DIF,
744 };
745
746 /**
747 * Signature T10-DIF block-guard types
748 * IB_T10DIF_CRC: Corresponds to T10-PI mandated CRC checksum rules.
749 * IB_T10DIF_CSUM: Corresponds to IP checksum rules.
750 */
751 enum ib_t10_dif_bg_type {
752 IB_T10DIF_CRC,
753 IB_T10DIF_CSUM
754 };
755
756 /**
757 * struct ib_t10_dif_domain - Parameters specific for T10-DIF
758 * domain.
759 * @bg_type: T10-DIF block guard type (CRC|CSUM)
760 * @pi_interval: protection information interval.
761 * @bg: seed of guard computation.
762 * @app_tag: application tag of guard block
763 * @ref_tag: initial guard block reference tag.
764 * @ref_remap: Indicate wethear the reftag increments each block
765 * @app_escape: Indicate to skip block check if apptag=0xffff
766 * @ref_escape: Indicate to skip block check if reftag=0xffffffff
767 * @apptag_check_mask: check bitmask of application tag.
768 */
769 struct ib_t10_dif_domain {
770 enum ib_t10_dif_bg_type bg_type;
771 u16 pi_interval;
772 u16 bg;
773 u16 app_tag;
774 u32 ref_tag;
775 bool ref_remap;
776 bool app_escape;
777 bool ref_escape;
778 u16 apptag_check_mask;
779 };
780
781 /**
782 * struct ib_sig_domain - Parameters for signature domain
783 * @sig_type: specific signauture type
784 * @sig: union of all signature domain attributes that may
785 * be used to set domain layout.
786 */
787 struct ib_sig_domain {
788 enum ib_signature_type sig_type;
789 union {
790 struct ib_t10_dif_domain dif;
791 } sig;
792 };
793
794 /**
795 * struct ib_sig_attrs - Parameters for signature handover operation
796 * @check_mask: bitmask for signature byte check (8 bytes)
797 * @mem: memory domain layout desciptor.
798 * @wire: wire domain layout desciptor.
799 */
800 struct ib_sig_attrs {
801 u8 check_mask;
802 struct ib_sig_domain mem;
803 struct ib_sig_domain wire;
804 };
805
806 enum ib_sig_err_type {
807 IB_SIG_BAD_GUARD,
808 IB_SIG_BAD_REFTAG,
809 IB_SIG_BAD_APPTAG,
810 };
811
812 /**
813 * struct ib_sig_err - signature error descriptor
814 */
815 struct ib_sig_err {
816 enum ib_sig_err_type err_type;
817 u32 expected;
818 u32 actual;
819 u64 sig_err_offset;
820 u32 key;
821 };
822
823 enum ib_mr_status_check {
824 IB_MR_CHECK_SIG_STATUS = 1,
825 };
826
827 /**
828 * struct ib_mr_status - Memory region status container
829 *
830 * @fail_status: Bitmask of MR checks status. For each
831 * failed check a corresponding status bit is set.
832 * @sig_err: Additional info for IB_MR_CEHCK_SIG_STATUS
833 * failure.
834 */
835 struct ib_mr_status {
836 u32 fail_status;
837 struct ib_sig_err sig_err;
838 };
839
840 /**
841 * mult_to_ib_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate
842 * enum.
843 * @mult: multiple to convert.
844 */
845 __attribute_const__ enum ib_rate mult_to_ib_rate(int mult);
846
847 enum rdma_ah_attr_type {
848 RDMA_AH_ATTR_TYPE_IB,
849 RDMA_AH_ATTR_TYPE_ROCE,
850 RDMA_AH_ATTR_TYPE_OPA,
851 };
852
853 struct ib_ah_attr {
854 u16 dlid;
855 u8 src_path_bits;
856 };
857
858 struct roce_ah_attr {
859 u8 dmac[ETH_ALEN];
860 };
861
862 struct opa_ah_attr {
863 u32 dlid;
864 u8 src_path_bits;
865 };
866
867 struct rdma_ah_attr {
868 struct ib_global_route grh;
869 u8 sl;
870 u8 static_rate;
871 u8 port_num;
872 u8 ah_flags;
873 enum rdma_ah_attr_type type;
874 union {
875 struct ib_ah_attr ib;
876 struct roce_ah_attr roce;
877 struct opa_ah_attr opa;
878 };
879 };
880
881 enum ib_wc_status {
882 IB_WC_SUCCESS,
883 IB_WC_LOC_LEN_ERR,
884 IB_WC_LOC_QP_OP_ERR,
885 IB_WC_LOC_EEC_OP_ERR,
886 IB_WC_LOC_PROT_ERR,
887 IB_WC_WR_FLUSH_ERR,
888 IB_WC_MW_BIND_ERR,
889 IB_WC_BAD_RESP_ERR,
890 IB_WC_LOC_ACCESS_ERR,
891 IB_WC_REM_INV_REQ_ERR,
892 IB_WC_REM_ACCESS_ERR,
893 IB_WC_REM_OP_ERR,
894 IB_WC_RETRY_EXC_ERR,
895 IB_WC_RNR_RETRY_EXC_ERR,
896 IB_WC_LOC_RDD_VIOL_ERR,
897 IB_WC_REM_INV_RD_REQ_ERR,
898 IB_WC_REM_ABORT_ERR,
899 IB_WC_INV_EECN_ERR,
900 IB_WC_INV_EEC_STATE_ERR,
901 IB_WC_FATAL_ERR,
902 IB_WC_RESP_TIMEOUT_ERR,
903 IB_WC_GENERAL_ERR
904 };
905
906 const char *__attribute_const__ ib_wc_status_msg(enum ib_wc_status status);
907
908 enum ib_wc_opcode {
909 IB_WC_SEND,
910 IB_WC_RDMA_WRITE,
911 IB_WC_RDMA_READ,
912 IB_WC_COMP_SWAP,
913 IB_WC_FETCH_ADD,
914 IB_WC_LSO,
915 IB_WC_LOCAL_INV,
916 IB_WC_REG_MR,
917 IB_WC_MASKED_COMP_SWAP,
918 IB_WC_MASKED_FETCH_ADD,
919 /*
920 * Set value of IB_WC_RECV so consumers can test if a completion is a
921 * receive by testing (opcode & IB_WC_RECV).
922 */
923 IB_WC_RECV = 1 << 7,
924 IB_WC_RECV_RDMA_WITH_IMM
925 };
926
927 enum ib_wc_flags {
928 IB_WC_GRH = 1,
929 IB_WC_WITH_IMM = (1<<1),
930 IB_WC_WITH_INVALIDATE = (1<<2),
931 IB_WC_IP_CSUM_OK = (1<<3),
932 IB_WC_WITH_SMAC = (1<<4),
933 IB_WC_WITH_VLAN = (1<<5),
934 IB_WC_WITH_NETWORK_HDR_TYPE = (1<<6),
935 };
936
937 struct ib_wc {
938 union {
939 u64 wr_id;
940 struct ib_cqe *wr_cqe;
941 };
942 enum ib_wc_status status;
943 enum ib_wc_opcode opcode;
944 u32 vendor_err;
945 u32 byte_len;
946 struct ib_qp *qp;
947 union {
948 __be32 imm_data;
949 u32 invalidate_rkey;
950 } ex;
951 u32 src_qp;
952 int wc_flags;
953 u16 pkey_index;
954 u16 slid;
955 u8 sl;
956 u8 dlid_path_bits;
957 u8 port_num; /* valid only for DR SMPs on switches */
958 u8 smac[ETH_ALEN];
959 u16 vlan_id;
960 u8 network_hdr_type;
961 };
962
963 enum ib_cq_notify_flags {
964 IB_CQ_SOLICITED = 1 << 0,
965 IB_CQ_NEXT_COMP = 1 << 1,
966 IB_CQ_SOLICITED_MASK = IB_CQ_SOLICITED | IB_CQ_NEXT_COMP,
967 IB_CQ_REPORT_MISSED_EVENTS = 1 << 2,
968 };
969
970 enum ib_srq_type {
971 IB_SRQT_BASIC,
972 IB_SRQT_XRC
973 };
974
975 enum ib_srq_attr_mask {
976 IB_SRQ_MAX_WR = 1 << 0,
977 IB_SRQ_LIMIT = 1 << 1,
978 };
979
980 struct ib_srq_attr {
981 u32 max_wr;
982 u32 max_sge;
983 u32 srq_limit;
984 };
985
986 struct ib_srq_init_attr {
987 void (*event_handler)(struct ib_event *, void *);
988 void *srq_context;
989 struct ib_srq_attr attr;
990 enum ib_srq_type srq_type;
991
992 union {
993 struct {
994 struct ib_xrcd *xrcd;
995 struct ib_cq *cq;
996 } xrc;
997 } ext;
998 };
999
1000 struct ib_qp_cap {
1001 u32 max_send_wr;
1002 u32 max_recv_wr;
1003 u32 max_send_sge;
1004 u32 max_recv_sge;
1005 u32 max_inline_data;
1006
1007 /*
1008 * Maximum number of rdma_rw_ctx structures in flight at a time.
1009 * ib_create_qp() will calculate the right amount of neededed WRs
1010 * and MRs based on this.
1011 */
1012 u32 max_rdma_ctxs;
1013 };
1014
1015 enum ib_sig_type {
1016 IB_SIGNAL_ALL_WR,
1017 IB_SIGNAL_REQ_WR
1018 };
1019
1020 enum ib_qp_type {
1021 /*
1022 * IB_QPT_SMI and IB_QPT_GSI have to be the first two entries
1023 * here (and in that order) since the MAD layer uses them as
1024 * indices into a 2-entry table.
1025 */
1026 IB_QPT_SMI,
1027 IB_QPT_GSI,
1028
1029 IB_QPT_RC,
1030 IB_QPT_UC,
1031 IB_QPT_UD,
1032 IB_QPT_RAW_IPV6,
1033 IB_QPT_RAW_ETHERTYPE,
1034 IB_QPT_RAW_PACKET = 8,
1035 IB_QPT_XRC_INI = 9,
1036 IB_QPT_XRC_TGT,
1037 IB_QPT_MAX,
1038 /* Reserve a range for qp types internal to the low level driver.
1039 * These qp types will not be visible at the IB core layer, so the
1040 * IB_QPT_MAX usages should not be affected in the core layer
1041 */
1042 IB_QPT_RESERVED1 = 0x1000,
1043 IB_QPT_RESERVED2,
1044 IB_QPT_RESERVED3,
1045 IB_QPT_RESERVED4,
1046 IB_QPT_RESERVED5,
1047 IB_QPT_RESERVED6,
1048 IB_QPT_RESERVED7,
1049 IB_QPT_RESERVED8,
1050 IB_QPT_RESERVED9,
1051 IB_QPT_RESERVED10,
1052 };
1053
1054 enum ib_qp_create_flags {
1055 IB_QP_CREATE_IPOIB_UD_LSO = 1 << 0,
1056 IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK = 1 << 1,
1057 IB_QP_CREATE_CROSS_CHANNEL = 1 << 2,
1058 IB_QP_CREATE_MANAGED_SEND = 1 << 3,
1059 IB_QP_CREATE_MANAGED_RECV = 1 << 4,
1060 IB_QP_CREATE_NETIF_QP = 1 << 5,
1061 IB_QP_CREATE_SIGNATURE_EN = 1 << 6,
1062 /* FREE = 1 << 7, */
1063 IB_QP_CREATE_SCATTER_FCS = 1 << 8,
1064 IB_QP_CREATE_CVLAN_STRIPPING = 1 << 9,
1065 IB_QP_CREATE_SOURCE_QPN = 1 << 10,
1066 /* reserve bits 26-31 for low level drivers' internal use */
1067 IB_QP_CREATE_RESERVED_START = 1 << 26,
1068 IB_QP_CREATE_RESERVED_END = 1 << 31,
1069 };
1070
1071 /*
1072 * Note: users may not call ib_close_qp or ib_destroy_qp from the event_handler
1073 * callback to destroy the passed in QP.
1074 */
1075
1076 struct ib_qp_init_attr {
1077 void (*event_handler)(struct ib_event *, void *);
1078 void *qp_context;
1079 struct ib_cq *send_cq;
1080 struct ib_cq *recv_cq;
1081 struct ib_srq *srq;
1082 struct ib_xrcd *xrcd; /* XRC TGT QPs only */
1083 struct ib_qp_cap cap;
1084 enum ib_sig_type sq_sig_type;
1085 enum ib_qp_type qp_type;
1086 enum ib_qp_create_flags create_flags;
1087
1088 /*
1089 * Only needed for special QP types, or when using the RW API.
1090 */
1091 u8 port_num;
1092 struct ib_rwq_ind_table *rwq_ind_tbl;
1093 u32 source_qpn;
1094 };
1095
1096 struct ib_qp_open_attr {
1097 void (*event_handler)(struct ib_event *, void *);
1098 void *qp_context;
1099 u32 qp_num;
1100 enum ib_qp_type qp_type;
1101 };
1102
1103 enum ib_rnr_timeout {
1104 IB_RNR_TIMER_655_36 = 0,
1105 IB_RNR_TIMER_000_01 = 1,
1106 IB_RNR_TIMER_000_02 = 2,
1107 IB_RNR_TIMER_000_03 = 3,
1108 IB_RNR_TIMER_000_04 = 4,
1109 IB_RNR_TIMER_000_06 = 5,
1110 IB_RNR_TIMER_000_08 = 6,
1111 IB_RNR_TIMER_000_12 = 7,
1112 IB_RNR_TIMER_000_16 = 8,
1113 IB_RNR_TIMER_000_24 = 9,
1114 IB_RNR_TIMER_000_32 = 10,
1115 IB_RNR_TIMER_000_48 = 11,
1116 IB_RNR_TIMER_000_64 = 12,
1117 IB_RNR_TIMER_000_96 = 13,
1118 IB_RNR_TIMER_001_28 = 14,
1119 IB_RNR_TIMER_001_92 = 15,
1120 IB_RNR_TIMER_002_56 = 16,
1121 IB_RNR_TIMER_003_84 = 17,
1122 IB_RNR_TIMER_005_12 = 18,
1123 IB_RNR_TIMER_007_68 = 19,
1124 IB_RNR_TIMER_010_24 = 20,
1125 IB_RNR_TIMER_015_36 = 21,
1126 IB_RNR_TIMER_020_48 = 22,
1127 IB_RNR_TIMER_030_72 = 23,
1128 IB_RNR_TIMER_040_96 = 24,
1129 IB_RNR_TIMER_061_44 = 25,
1130 IB_RNR_TIMER_081_92 = 26,
1131 IB_RNR_TIMER_122_88 = 27,
1132 IB_RNR_TIMER_163_84 = 28,
1133 IB_RNR_TIMER_245_76 = 29,
1134 IB_RNR_TIMER_327_68 = 30,
1135 IB_RNR_TIMER_491_52 = 31
1136 };
1137
1138 enum ib_qp_attr_mask {
1139 IB_QP_STATE = 1,
1140 IB_QP_CUR_STATE = (1<<1),
1141 IB_QP_EN_SQD_ASYNC_NOTIFY = (1<<2),
1142 IB_QP_ACCESS_FLAGS = (1<<3),
1143 IB_QP_PKEY_INDEX = (1<<4),
1144 IB_QP_PORT = (1<<5),
1145 IB_QP_QKEY = (1<<6),
1146 IB_QP_AV = (1<<7),
1147 IB_QP_PATH_MTU = (1<<8),
1148 IB_QP_TIMEOUT = (1<<9),
1149 IB_QP_RETRY_CNT = (1<<10),
1150 IB_QP_RNR_RETRY = (1<<11),
1151 IB_QP_RQ_PSN = (1<<12),
1152 IB_QP_MAX_QP_RD_ATOMIC = (1<<13),
1153 IB_QP_ALT_PATH = (1<<14),
1154 IB_QP_MIN_RNR_TIMER = (1<<15),
1155 IB_QP_SQ_PSN = (1<<16),
1156 IB_QP_MAX_DEST_RD_ATOMIC = (1<<17),
1157 IB_QP_PATH_MIG_STATE = (1<<18),
1158 IB_QP_CAP = (1<<19),
1159 IB_QP_DEST_QPN = (1<<20),
1160 IB_QP_RESERVED1 = (1<<21),
1161 IB_QP_RESERVED2 = (1<<22),
1162 IB_QP_RESERVED3 = (1<<23),
1163 IB_QP_RESERVED4 = (1<<24),
1164 IB_QP_RATE_LIMIT = (1<<25),
1165 };
1166
1167 enum ib_qp_state {
1168 IB_QPS_RESET,
1169 IB_QPS_INIT,
1170 IB_QPS_RTR,
1171 IB_QPS_RTS,
1172 IB_QPS_SQD,
1173 IB_QPS_SQE,
1174 IB_QPS_ERR
1175 };
1176
1177 enum ib_mig_state {
1178 IB_MIG_MIGRATED,
1179 IB_MIG_REARM,
1180 IB_MIG_ARMED
1181 };
1182
1183 enum ib_mw_type {
1184 IB_MW_TYPE_1 = 1,
1185 IB_MW_TYPE_2 = 2
1186 };
1187
1188 struct ib_qp_attr {
1189 enum ib_qp_state qp_state;
1190 enum ib_qp_state cur_qp_state;
1191 enum ib_mtu path_mtu;
1192 enum ib_mig_state path_mig_state;
1193 u32 qkey;
1194 u32 rq_psn;
1195 u32 sq_psn;
1196 u32 dest_qp_num;
1197 int qp_access_flags;
1198 struct ib_qp_cap cap;
1199 struct rdma_ah_attr ah_attr;
1200 struct rdma_ah_attr alt_ah_attr;
1201 u16 pkey_index;
1202 u16 alt_pkey_index;
1203 u8 en_sqd_async_notify;
1204 u8 sq_draining;
1205 u8 max_rd_atomic;
1206 u8 max_dest_rd_atomic;
1207 u8 min_rnr_timer;
1208 u8 port_num;
1209 u8 timeout;
1210 u8 retry_cnt;
1211 u8 rnr_retry;
1212 u8 alt_port_num;
1213 u8 alt_timeout;
1214 u32 rate_limit;
1215 };
1216
1217 enum ib_wr_opcode {
1218 IB_WR_RDMA_WRITE,
1219 IB_WR_RDMA_WRITE_WITH_IMM,
1220 IB_WR_SEND,
1221 IB_WR_SEND_WITH_IMM,
1222 IB_WR_RDMA_READ,
1223 IB_WR_ATOMIC_CMP_AND_SWP,
1224 IB_WR_ATOMIC_FETCH_AND_ADD,
1225 IB_WR_LSO,
1226 IB_WR_SEND_WITH_INV,
1227 IB_WR_RDMA_READ_WITH_INV,
1228 IB_WR_LOCAL_INV,
1229 IB_WR_REG_MR,
1230 IB_WR_MASKED_ATOMIC_CMP_AND_SWP,
1231 IB_WR_MASKED_ATOMIC_FETCH_AND_ADD,
1232 IB_WR_REG_SIG_MR,
1233 /* reserve values for low level drivers' internal use.
1234 * These values will not be used at all in the ib core layer.
1235 */
1236 IB_WR_RESERVED1 = 0xf0,
1237 IB_WR_RESERVED2,
1238 IB_WR_RESERVED3,
1239 IB_WR_RESERVED4,
1240 IB_WR_RESERVED5,
1241 IB_WR_RESERVED6,
1242 IB_WR_RESERVED7,
1243 IB_WR_RESERVED8,
1244 IB_WR_RESERVED9,
1245 IB_WR_RESERVED10,
1246 };
1247
1248 enum ib_send_flags {
1249 IB_SEND_FENCE = 1,
1250 IB_SEND_SIGNALED = (1<<1),
1251 IB_SEND_SOLICITED = (1<<2),
1252 IB_SEND_INLINE = (1<<3),
1253 IB_SEND_IP_CSUM = (1<<4),
1254
1255 /* reserve bits 26-31 for low level drivers' internal use */
1256 IB_SEND_RESERVED_START = (1 << 26),
1257 IB_SEND_RESERVED_END = (1 << 31),
1258 };
1259
1260 struct ib_sge {
1261 u64 addr;
1262 u32 length;
1263 u32 lkey;
1264 };
1265
1266 struct ib_cqe {
1267 void (*done)(struct ib_cq *cq, struct ib_wc *wc);
1268 };
1269
1270 struct ib_send_wr {
1271 struct ib_send_wr *next;
1272 union {
1273 u64 wr_id;
1274 struct ib_cqe *wr_cqe;
1275 };
1276 struct ib_sge *sg_list;
1277 int num_sge;
1278 enum ib_wr_opcode opcode;
1279 int send_flags;
1280 union {
1281 __be32 imm_data;
1282 u32 invalidate_rkey;
1283 } ex;
1284 };
1285
1286 struct ib_rdma_wr {
1287 struct ib_send_wr wr;
1288 u64 remote_addr;
1289 u32 rkey;
1290 };
1291
1292 static inline struct ib_rdma_wr *rdma_wr(struct ib_send_wr *wr)
1293 {
1294 return container_of(wr, struct ib_rdma_wr, wr);
1295 }
1296
1297 struct ib_atomic_wr {
1298 struct ib_send_wr wr;
1299 u64 remote_addr;
1300 u64 compare_add;
1301 u64 swap;
1302 u64 compare_add_mask;
1303 u64 swap_mask;
1304 u32 rkey;
1305 };
1306
1307 static inline struct ib_atomic_wr *atomic_wr(struct ib_send_wr *wr)
1308 {
1309 return container_of(wr, struct ib_atomic_wr, wr);
1310 }
1311
1312 struct ib_ud_wr {
1313 struct ib_send_wr wr;
1314 struct ib_ah *ah;
1315 void *header;
1316 int hlen;
1317 int mss;
1318 u32 remote_qpn;
1319 u32 remote_qkey;
1320 u16 pkey_index; /* valid for GSI only */
1321 u8 port_num; /* valid for DR SMPs on switch only */
1322 };
1323
1324 static inline struct ib_ud_wr *ud_wr(struct ib_send_wr *wr)
1325 {
1326 return container_of(wr, struct ib_ud_wr, wr);
1327 }
1328
1329 struct ib_reg_wr {
1330 struct ib_send_wr wr;
1331 struct ib_mr *mr;
1332 u32 key;
1333 int access;
1334 };
1335
1336 static inline struct ib_reg_wr *reg_wr(struct ib_send_wr *wr)
1337 {
1338 return container_of(wr, struct ib_reg_wr, wr);
1339 }
1340
1341 struct ib_sig_handover_wr {
1342 struct ib_send_wr wr;
1343 struct ib_sig_attrs *sig_attrs;
1344 struct ib_mr *sig_mr;
1345 int access_flags;
1346 struct ib_sge *prot;
1347 };
1348
1349 static inline struct ib_sig_handover_wr *sig_handover_wr(struct ib_send_wr *wr)
1350 {
1351 return container_of(wr, struct ib_sig_handover_wr, wr);
1352 }
1353
1354 struct ib_recv_wr {
1355 struct ib_recv_wr *next;
1356 union {
1357 u64 wr_id;
1358 struct ib_cqe *wr_cqe;
1359 };
1360 struct ib_sge *sg_list;
1361 int num_sge;
1362 };
1363
1364 enum ib_access_flags {
1365 IB_ACCESS_LOCAL_WRITE = 1,
1366 IB_ACCESS_REMOTE_WRITE = (1<<1),
1367 IB_ACCESS_REMOTE_READ = (1<<2),
1368 IB_ACCESS_REMOTE_ATOMIC = (1<<3),
1369 IB_ACCESS_MW_BIND = (1<<4),
1370 IB_ZERO_BASED = (1<<5),
1371 IB_ACCESS_ON_DEMAND = (1<<6),
1372 IB_ACCESS_HUGETLB = (1<<7),
1373 };
1374
1375 /*
1376 * XXX: these are apparently used for ->rereg_user_mr, no idea why they
1377 * are hidden here instead of a uapi header!
1378 */
1379 enum ib_mr_rereg_flags {
1380 IB_MR_REREG_TRANS = 1,
1381 IB_MR_REREG_PD = (1<<1),
1382 IB_MR_REREG_ACCESS = (1<<2),
1383 IB_MR_REREG_SUPPORTED = ((IB_MR_REREG_ACCESS << 1) - 1)
1384 };
1385
1386 struct ib_fmr_attr {
1387 int max_pages;
1388 int max_maps;
1389 u8 page_shift;
1390 };
1391
1392 struct ib_umem;
1393
1394 enum rdma_remove_reason {
1395 /* Userspace requested uobject deletion. Call could fail */
1396 RDMA_REMOVE_DESTROY,
1397 /* Context deletion. This call should delete the actual object itself */
1398 RDMA_REMOVE_CLOSE,
1399 /* Driver is being hot-unplugged. This call should delete the actual object itself */
1400 RDMA_REMOVE_DRIVER_REMOVE,
1401 /* Context is being cleaned-up, but commit was just completed */
1402 RDMA_REMOVE_DURING_CLEANUP,
1403 };
1404
1405 struct ib_rdmacg_object {
1406 #ifdef CONFIG_CGROUP_RDMA
1407 struct rdma_cgroup *cg; /* owner rdma cgroup */
1408 #endif
1409 };
1410
1411 struct ib_ucontext {
1412 struct ib_device *device;
1413 struct ib_uverbs_file *ufile;
1414 int closing;
1415
1416 /* locking the uobjects_list */
1417 struct mutex uobjects_lock;
1418 struct list_head uobjects;
1419 /* protects cleanup process from other actions */
1420 struct rw_semaphore cleanup_rwsem;
1421 enum rdma_remove_reason cleanup_reason;
1422
1423 struct pid *tgid;
1424 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
1425 struct rb_root umem_tree;
1426 /*
1427 * Protects .umem_rbroot and tree, as well as odp_mrs_count and
1428 * mmu notifiers registration.
1429 */
1430 struct rw_semaphore umem_rwsem;
1431 void (*invalidate_range)(struct ib_umem *umem,
1432 unsigned long start, unsigned long end);
1433
1434 struct mmu_notifier mn;
1435 atomic_t notifier_count;
1436 /* A list of umems that don't have private mmu notifier counters yet. */
1437 struct list_head no_private_counters;
1438 int odp_mrs_count;
1439 #endif
1440
1441 struct ib_rdmacg_object cg_obj;
1442 };
1443
1444 struct ib_uobject {
1445 u64 user_handle; /* handle given to us by userspace */
1446 struct ib_ucontext *context; /* associated user context */
1447 void *object; /* containing object */
1448 struct list_head list; /* link to context's list */
1449 struct ib_rdmacg_object cg_obj; /* rdmacg object */
1450 int id; /* index into kernel idr */
1451 struct kref ref;
1452 atomic_t usecnt; /* protects exclusive access */
1453 struct rcu_head rcu; /* kfree_rcu() overhead */
1454
1455 const struct uverbs_obj_type *type;
1456 };
1457
1458 struct ib_uobject_file {
1459 struct ib_uobject uobj;
1460 /* ufile contains the lock between context release and file close */
1461 struct ib_uverbs_file *ufile;
1462 };
1463
1464 struct ib_udata {
1465 const void __user *inbuf;
1466 void __user *outbuf;
1467 size_t inlen;
1468 size_t outlen;
1469 };
1470
1471 struct ib_pd {
1472 u32 local_dma_lkey;
1473 u32 flags;
1474 struct ib_device *device;
1475 struct ib_uobject *uobject;
1476 atomic_t usecnt; /* count all resources */
1477
1478 u32 unsafe_global_rkey;
1479
1480 /*
1481 * Implementation details of the RDMA core, don't use in drivers:
1482 */
1483 struct ib_mr *__internal_mr;
1484 };
1485
1486 struct ib_xrcd {
1487 struct ib_device *device;
1488 atomic_t usecnt; /* count all exposed resources */
1489 struct inode *inode;
1490
1491 struct mutex tgt_qp_mutex;
1492 struct list_head tgt_qp_list;
1493 };
1494
1495 struct ib_ah {
1496 struct ib_device *device;
1497 struct ib_pd *pd;
1498 struct ib_uobject *uobject;
1499 enum rdma_ah_attr_type type;
1500 };
1501
1502 typedef void (*ib_comp_handler)(struct ib_cq *cq, void *cq_context);
1503
1504 enum ib_poll_context {
1505 IB_POLL_DIRECT, /* caller context, no hw completions */
1506 IB_POLL_SOFTIRQ, /* poll from softirq context */
1507 IB_POLL_WORKQUEUE, /* poll from workqueue */
1508 };
1509
1510 struct ib_cq {
1511 struct ib_device *device;
1512 struct ib_uobject *uobject;
1513 ib_comp_handler comp_handler;
1514 void (*event_handler)(struct ib_event *, void *);
1515 void *cq_context;
1516 int cqe;
1517 atomic_t usecnt; /* count number of work queues */
1518 enum ib_poll_context poll_ctx;
1519 struct ib_wc *wc;
1520 union {
1521 struct irq_poll iop;
1522 struct work_struct work;
1523 };
1524 };
1525
1526 struct ib_srq {
1527 struct ib_device *device;
1528 struct ib_pd *pd;
1529 struct ib_uobject *uobject;
1530 void (*event_handler)(struct ib_event *, void *);
1531 void *srq_context;
1532 enum ib_srq_type srq_type;
1533 atomic_t usecnt;
1534
1535 union {
1536 struct {
1537 struct ib_xrcd *xrcd;
1538 struct ib_cq *cq;
1539 u32 srq_num;
1540 } xrc;
1541 } ext;
1542 };
1543
1544 enum ib_raw_packet_caps {
1545 /* Strip cvlan from incoming packet and report it in the matching work
1546 * completion is supported.
1547 */
1548 IB_RAW_PACKET_CAP_CVLAN_STRIPPING = (1 << 0),
1549 /* Scatter FCS field of an incoming packet to host memory is supported.
1550 */
1551 IB_RAW_PACKET_CAP_SCATTER_FCS = (1 << 1),
1552 /* Checksum offloads are supported (for both send and receive). */
1553 IB_RAW_PACKET_CAP_IP_CSUM = (1 << 2),
1554 /* When a packet is received for an RQ with no receive WQEs, the
1555 * packet processing is delayed.
1556 */
1557 IB_RAW_PACKET_CAP_DELAY_DROP = (1 << 3),
1558 };
1559
1560 enum ib_wq_type {
1561 IB_WQT_RQ
1562 };
1563
1564 enum ib_wq_state {
1565 IB_WQS_RESET,
1566 IB_WQS_RDY,
1567 IB_WQS_ERR
1568 };
1569
1570 struct ib_wq {
1571 struct ib_device *device;
1572 struct ib_uobject *uobject;
1573 void *wq_context;
1574 void (*event_handler)(struct ib_event *, void *);
1575 struct ib_pd *pd;
1576 struct ib_cq *cq;
1577 u32 wq_num;
1578 enum ib_wq_state state;
1579 enum ib_wq_type wq_type;
1580 atomic_t usecnt;
1581 };
1582
1583 enum ib_wq_flags {
1584 IB_WQ_FLAGS_CVLAN_STRIPPING = 1 << 0,
1585 IB_WQ_FLAGS_SCATTER_FCS = 1 << 1,
1586 IB_WQ_FLAGS_DELAY_DROP = 1 << 2,
1587 };
1588
1589 struct ib_wq_init_attr {
1590 void *wq_context;
1591 enum ib_wq_type wq_type;
1592 u32 max_wr;
1593 u32 max_sge;
1594 struct ib_cq *cq;
1595 void (*event_handler)(struct ib_event *, void *);
1596 u32 create_flags; /* Use enum ib_wq_flags */
1597 };
1598
1599 enum ib_wq_attr_mask {
1600 IB_WQ_STATE = 1 << 0,
1601 IB_WQ_CUR_STATE = 1 << 1,
1602 IB_WQ_FLAGS = 1 << 2,
1603 };
1604
1605 struct ib_wq_attr {
1606 enum ib_wq_state wq_state;
1607 enum ib_wq_state curr_wq_state;
1608 u32 flags; /* Use enum ib_wq_flags */
1609 u32 flags_mask; /* Use enum ib_wq_flags */
1610 };
1611
1612 struct ib_rwq_ind_table {
1613 struct ib_device *device;
1614 struct ib_uobject *uobject;
1615 atomic_t usecnt;
1616 u32 ind_tbl_num;
1617 u32 log_ind_tbl_size;
1618 struct ib_wq **ind_tbl;
1619 };
1620
1621 struct ib_rwq_ind_table_init_attr {
1622 u32 log_ind_tbl_size;
1623 /* Each entry is a pointer to Receive Work Queue */
1624 struct ib_wq **ind_tbl;
1625 };
1626
1627 enum port_pkey_state {
1628 IB_PORT_PKEY_NOT_VALID = 0,
1629 IB_PORT_PKEY_VALID = 1,
1630 IB_PORT_PKEY_LISTED = 2,
1631 };
1632
1633 struct ib_qp_security;
1634
1635 struct ib_port_pkey {
1636 enum port_pkey_state state;
1637 u16 pkey_index;
1638 u8 port_num;
1639 struct list_head qp_list;
1640 struct list_head to_error_list;
1641 struct ib_qp_security *sec;
1642 };
1643
1644 struct ib_ports_pkeys {
1645 struct ib_port_pkey main;
1646 struct ib_port_pkey alt;
1647 };
1648
1649 struct ib_qp_security {
1650 struct ib_qp *qp;
1651 struct ib_device *dev;
1652 /* Hold this mutex when changing port and pkey settings. */
1653 struct mutex mutex;
1654 struct ib_ports_pkeys *ports_pkeys;
1655 /* A list of all open shared QP handles. Required to enforce security
1656 * properly for all users of a shared QP.
1657 */
1658 struct list_head shared_qp_list;
1659 void *security;
1660 bool destroying;
1661 atomic_t error_list_count;
1662 struct completion error_complete;
1663 int error_comps_pending;
1664 };
1665
1666 /*
1667 * @max_write_sge: Maximum SGE elements per RDMA WRITE request.
1668 * @max_read_sge: Maximum SGE elements per RDMA READ request.
1669 */
1670 struct ib_qp {
1671 struct ib_device *device;
1672 struct ib_pd *pd;
1673 struct ib_cq *send_cq;
1674 struct ib_cq *recv_cq;
1675 spinlock_t mr_lock;
1676 int mrs_used;
1677 struct list_head rdma_mrs;
1678 struct list_head sig_mrs;
1679 struct ib_srq *srq;
1680 struct ib_xrcd *xrcd; /* XRC TGT QPs only */
1681 struct list_head xrcd_list;
1682
1683 /* count times opened, mcast attaches, flow attaches */
1684 atomic_t usecnt;
1685 struct list_head open_list;
1686 struct ib_qp *real_qp;
1687 struct ib_uobject *uobject;
1688 void (*event_handler)(struct ib_event *, void *);
1689 void *qp_context;
1690 u32 qp_num;
1691 u32 max_write_sge;
1692 u32 max_read_sge;
1693 enum ib_qp_type qp_type;
1694 struct ib_rwq_ind_table *rwq_ind_tbl;
1695 struct ib_qp_security *qp_sec;
1696 };
1697
1698 struct ib_mr {
1699 struct ib_device *device;
1700 struct ib_pd *pd;
1701 u32 lkey;
1702 u32 rkey;
1703 u64 iova;
1704 u32 length;
1705 unsigned int page_size;
1706 bool need_inval;
1707 union {
1708 struct ib_uobject *uobject; /* user */
1709 struct list_head qp_entry; /* FR */
1710 };
1711 };
1712
1713 struct ib_mw {
1714 struct ib_device *device;
1715 struct ib_pd *pd;
1716 struct ib_uobject *uobject;
1717 u32 rkey;
1718 enum ib_mw_type type;
1719 };
1720
1721 struct ib_fmr {
1722 struct ib_device *device;
1723 struct ib_pd *pd;
1724 struct list_head list;
1725 u32 lkey;
1726 u32 rkey;
1727 };
1728
1729 /* Supported steering options */
1730 enum ib_flow_attr_type {
1731 /* steering according to rule specifications */
1732 IB_FLOW_ATTR_NORMAL = 0x0,
1733 /* default unicast and multicast rule -
1734 * receive all Eth traffic which isn't steered to any QP
1735 */
1736 IB_FLOW_ATTR_ALL_DEFAULT = 0x1,
1737 /* default multicast rule -
1738 * receive all Eth multicast traffic which isn't steered to any QP
1739 */
1740 IB_FLOW_ATTR_MC_DEFAULT = 0x2,
1741 /* sniffer rule - receive all port traffic */
1742 IB_FLOW_ATTR_SNIFFER = 0x3
1743 };
1744
1745 /* Supported steering header types */
1746 enum ib_flow_spec_type {
1747 /* L2 headers*/
1748 IB_FLOW_SPEC_ETH = 0x20,
1749 IB_FLOW_SPEC_IB = 0x22,
1750 /* L3 header*/
1751 IB_FLOW_SPEC_IPV4 = 0x30,
1752 IB_FLOW_SPEC_IPV6 = 0x31,
1753 /* L4 headers*/
1754 IB_FLOW_SPEC_TCP = 0x40,
1755 IB_FLOW_SPEC_UDP = 0x41,
1756 IB_FLOW_SPEC_VXLAN_TUNNEL = 0x50,
1757 IB_FLOW_SPEC_INNER = 0x100,
1758 /* Actions */
1759 IB_FLOW_SPEC_ACTION_TAG = 0x1000,
1760 IB_FLOW_SPEC_ACTION_DROP = 0x1001,
1761 };
1762 #define IB_FLOW_SPEC_LAYER_MASK 0xF0
1763 #define IB_FLOW_SPEC_SUPPORT_LAYERS 8
1764
1765 /* Flow steering rule priority is set according to it's domain.
1766 * Lower domain value means higher priority.
1767 */
1768 enum ib_flow_domain {
1769 IB_FLOW_DOMAIN_USER,
1770 IB_FLOW_DOMAIN_ETHTOOL,
1771 IB_FLOW_DOMAIN_RFS,
1772 IB_FLOW_DOMAIN_NIC,
1773 IB_FLOW_DOMAIN_NUM /* Must be last */
1774 };
1775
1776 enum ib_flow_flags {
1777 IB_FLOW_ATTR_FLAGS_DONT_TRAP = 1UL << 1, /* Continue match, no steal */
1778 IB_FLOW_ATTR_FLAGS_RESERVED = 1UL << 2 /* Must be last */
1779 };
1780
1781 struct ib_flow_eth_filter {
1782 u8 dst_mac[6];
1783 u8 src_mac[6];
1784 __be16 ether_type;
1785 __be16 vlan_tag;
1786 /* Must be last */
1787 u8 real_sz[0];
1788 };
1789
1790 struct ib_flow_spec_eth {
1791 u32 type;
1792 u16 size;
1793 struct ib_flow_eth_filter val;
1794 struct ib_flow_eth_filter mask;
1795 };
1796
1797 struct ib_flow_ib_filter {
1798 __be16 dlid;
1799 __u8 sl;
1800 /* Must be last */
1801 u8 real_sz[0];
1802 };
1803
1804 struct ib_flow_spec_ib {
1805 u32 type;
1806 u16 size;
1807 struct ib_flow_ib_filter val;
1808 struct ib_flow_ib_filter mask;
1809 };
1810
1811 /* IPv4 header flags */
1812 enum ib_ipv4_flags {
1813 IB_IPV4_DONT_FRAG = 0x2, /* Don't enable packet fragmentation */
1814 IB_IPV4_MORE_FRAG = 0X4 /* For All fragmented packets except the
1815 last have this flag set */
1816 };
1817
1818 struct ib_flow_ipv4_filter {
1819 __be32 src_ip;
1820 __be32 dst_ip;
1821 u8 proto;
1822 u8 tos;
1823 u8 ttl;
1824 u8 flags;
1825 /* Must be last */
1826 u8 real_sz[0];
1827 };
1828
1829 struct ib_flow_spec_ipv4 {
1830 u32 type;
1831 u16 size;
1832 struct ib_flow_ipv4_filter val;
1833 struct ib_flow_ipv4_filter mask;
1834 };
1835
1836 struct ib_flow_ipv6_filter {
1837 u8 src_ip[16];
1838 u8 dst_ip[16];
1839 __be32 flow_label;
1840 u8 next_hdr;
1841 u8 traffic_class;
1842 u8 hop_limit;
1843 /* Must be last */
1844 u8 real_sz[0];
1845 };
1846
1847 struct ib_flow_spec_ipv6 {
1848 u32 type;
1849 u16 size;
1850 struct ib_flow_ipv6_filter val;
1851 struct ib_flow_ipv6_filter mask;
1852 };
1853
1854 struct ib_flow_tcp_udp_filter {
1855 __be16 dst_port;
1856 __be16 src_port;
1857 /* Must be last */
1858 u8 real_sz[0];
1859 };
1860
1861 struct ib_flow_spec_tcp_udp {
1862 u32 type;
1863 u16 size;
1864 struct ib_flow_tcp_udp_filter val;
1865 struct ib_flow_tcp_udp_filter mask;
1866 };
1867
1868 struct ib_flow_tunnel_filter {
1869 __be32 tunnel_id;
1870 u8 real_sz[0];
1871 };
1872
1873 /* ib_flow_spec_tunnel describes the Vxlan tunnel
1874 * the tunnel_id from val has the vni value
1875 */
1876 struct ib_flow_spec_tunnel {
1877 u32 type;
1878 u16 size;
1879 struct ib_flow_tunnel_filter val;
1880 struct ib_flow_tunnel_filter mask;
1881 };
1882
1883 struct ib_flow_spec_action_tag {
1884 enum ib_flow_spec_type type;
1885 u16 size;
1886 u32 tag_id;
1887 };
1888
1889 struct ib_flow_spec_action_drop {
1890 enum ib_flow_spec_type type;
1891 u16 size;
1892 };
1893
1894 union ib_flow_spec {
1895 struct {
1896 u32 type;
1897 u16 size;
1898 };
1899 struct ib_flow_spec_eth eth;
1900 struct ib_flow_spec_ib ib;
1901 struct ib_flow_spec_ipv4 ipv4;
1902 struct ib_flow_spec_tcp_udp tcp_udp;
1903 struct ib_flow_spec_ipv6 ipv6;
1904 struct ib_flow_spec_tunnel tunnel;
1905 struct ib_flow_spec_action_tag flow_tag;
1906 struct ib_flow_spec_action_drop drop;
1907 };
1908
1909 struct ib_flow_attr {
1910 enum ib_flow_attr_type type;
1911 u16 size;
1912 u16 priority;
1913 u32 flags;
1914 u8 num_of_specs;
1915 u8 port;
1916 /* Following are the optional layers according to user request
1917 * struct ib_flow_spec_xxx
1918 * struct ib_flow_spec_yyy
1919 */
1920 };
1921
1922 struct ib_flow {
1923 struct ib_qp *qp;
1924 struct ib_uobject *uobject;
1925 };
1926
1927 struct ib_mad_hdr;
1928 struct ib_grh;
1929
1930 enum ib_process_mad_flags {
1931 IB_MAD_IGNORE_MKEY = 1,
1932 IB_MAD_IGNORE_BKEY = 2,
1933 IB_MAD_IGNORE_ALL = IB_MAD_IGNORE_MKEY | IB_MAD_IGNORE_BKEY
1934 };
1935
1936 enum ib_mad_result {
1937 IB_MAD_RESULT_FAILURE = 0, /* (!SUCCESS is the important flag) */
1938 IB_MAD_RESULT_SUCCESS = 1 << 0, /* MAD was successfully processed */
1939 IB_MAD_RESULT_REPLY = 1 << 1, /* Reply packet needs to be sent */
1940 IB_MAD_RESULT_CONSUMED = 1 << 2 /* Packet consumed: stop processing */
1941 };
1942
1943 struct ib_port_cache {
1944 u64 subnet_prefix;
1945 struct ib_pkey_cache *pkey;
1946 struct ib_gid_table *gid;
1947 u8 lmc;
1948 enum ib_port_state port_state;
1949 };
1950
1951 struct ib_cache {
1952 rwlock_t lock;
1953 struct ib_event_handler event_handler;
1954 struct ib_port_cache *ports;
1955 };
1956
1957 struct iw_cm_verbs;
1958
1959 struct ib_port_immutable {
1960 int pkey_tbl_len;
1961 int gid_tbl_len;
1962 u32 core_cap_flags;
1963 u32 max_mad_size;
1964 };
1965
1966 /* rdma netdev type - specifies protocol type */
1967 enum rdma_netdev_t {
1968 RDMA_NETDEV_OPA_VNIC,
1969 RDMA_NETDEV_IPOIB,
1970 };
1971
1972 /**
1973 * struct rdma_netdev - rdma netdev
1974 * For cases where netstack interfacing is required.
1975 */
1976 struct rdma_netdev {
1977 void *clnt_priv;
1978 struct ib_device *hca;
1979 u8 port_num;
1980
1981 /* cleanup function must be specified */
1982 void (*free_rdma_netdev)(struct net_device *netdev);
1983
1984 /* control functions */
1985 void (*set_id)(struct net_device *netdev, int id);
1986 /* send packet */
1987 int (*send)(struct net_device *dev, struct sk_buff *skb,
1988 struct ib_ah *address, u32 dqpn);
1989 /* multicast */
1990 int (*attach_mcast)(struct net_device *dev, struct ib_device *hca,
1991 union ib_gid *gid, u16 mlid,
1992 int set_qkey, u32 qkey);
1993 int (*detach_mcast)(struct net_device *dev, struct ib_device *hca,
1994 union ib_gid *gid, u16 mlid);
1995 };
1996
1997 struct ib_port_pkey_list {
1998 /* Lock to hold while modifying the list. */
1999 spinlock_t list_lock;
2000 struct list_head pkey_list;
2001 };
2002
2003 struct ib_device {
2004 /* Do not access @dma_device directly from ULP nor from HW drivers. */
2005 struct device *dma_device;
2006
2007 char name[IB_DEVICE_NAME_MAX];
2008
2009 struct list_head event_handler_list;
2010 spinlock_t event_handler_lock;
2011
2012 spinlock_t client_data_lock;
2013 struct list_head core_list;
2014 /* Access to the client_data_list is protected by the client_data_lock
2015 * spinlock and the lists_rwsem read-write semaphore */
2016 struct list_head client_data_list;
2017
2018 struct ib_cache cache;
2019 /**
2020 * port_immutable is indexed by port number
2021 */
2022 struct ib_port_immutable *port_immutable;
2023
2024 int num_comp_vectors;
2025
2026 struct ib_port_pkey_list *port_pkey_list;
2027
2028 struct iw_cm_verbs *iwcm;
2029
2030 /**
2031 * alloc_hw_stats - Allocate a struct rdma_hw_stats and fill in the
2032 * driver initialized data. The struct is kfree()'ed by the sysfs
2033 * core when the device is removed. A lifespan of -1 in the return
2034 * struct tells the core to set a default lifespan.
2035 */
2036 struct rdma_hw_stats *(*alloc_hw_stats)(struct ib_device *device,
2037 u8 port_num);
2038 /**
2039 * get_hw_stats - Fill in the counter value(s) in the stats struct.
2040 * @index - The index in the value array we wish to have updated, or
2041 * num_counters if we want all stats updated
2042 * Return codes -
2043 * < 0 - Error, no counters updated
2044 * index - Updated the single counter pointed to by index
2045 * num_counters - Updated all counters (will reset the timestamp
2046 * and prevent further calls for lifespan milliseconds)
2047 * Drivers are allowed to update all counters in leiu of just the
2048 * one given in index at their option
2049 */
2050 int (*get_hw_stats)(struct ib_device *device,
2051 struct rdma_hw_stats *stats,
2052 u8 port, int index);
2053 int (*query_device)(struct ib_device *device,
2054 struct ib_device_attr *device_attr,
2055 struct ib_udata *udata);
2056 int (*query_port)(struct ib_device *device,
2057 u8 port_num,
2058 struct ib_port_attr *port_attr);
2059 enum rdma_link_layer (*get_link_layer)(struct ib_device *device,
2060 u8 port_num);
2061 /* When calling get_netdev, the HW vendor's driver should return the
2062 * net device of device @device at port @port_num or NULL if such
2063 * a net device doesn't exist. The vendor driver should call dev_hold
2064 * on this net device. The HW vendor's device driver must guarantee
2065 * that this function returns NULL before the net device reaches
2066 * NETDEV_UNREGISTER_FINAL state.
2067 */
2068 struct net_device *(*get_netdev)(struct ib_device *device,
2069 u8 port_num);
2070 int (*query_gid)(struct ib_device *device,
2071 u8 port_num, int index,
2072 union ib_gid *gid);
2073 /* When calling add_gid, the HW vendor's driver should
2074 * add the gid of device @device at gid index @index of
2075 * port @port_num to be @gid. Meta-info of that gid (for example,
2076 * the network device related to this gid is available
2077 * at @attr. @context allows the HW vendor driver to store extra
2078 * information together with a GID entry. The HW vendor may allocate
2079 * memory to contain this information and store it in @context when a
2080 * new GID entry is written to. Params are consistent until the next
2081 * call of add_gid or delete_gid. The function should return 0 on
2082 * success or error otherwise. The function could be called
2083 * concurrently for different ports. This function is only called
2084 * when roce_gid_table is used.
2085 */
2086 int (*add_gid)(struct ib_device *device,
2087 u8 port_num,
2088 unsigned int index,
2089 const union ib_gid *gid,
2090 const struct ib_gid_attr *attr,
2091 void **context);
2092 /* When calling del_gid, the HW vendor's driver should delete the
2093 * gid of device @device at gid index @index of port @port_num.
2094 * Upon the deletion of a GID entry, the HW vendor must free any
2095 * allocated memory. The caller will clear @context afterwards.
2096 * This function is only called when roce_gid_table is used.
2097 */
2098 int (*del_gid)(struct ib_device *device,
2099 u8 port_num,
2100 unsigned int index,
2101 void **context);
2102 int (*query_pkey)(struct ib_device *device,
2103 u8 port_num, u16 index, u16 *pkey);
2104 int (*modify_device)(struct ib_device *device,
2105 int device_modify_mask,
2106 struct ib_device_modify *device_modify);
2107 int (*modify_port)(struct ib_device *device,
2108 u8 port_num, int port_modify_mask,
2109 struct ib_port_modify *port_modify);
2110 struct ib_ucontext * (*alloc_ucontext)(struct ib_device *device,
2111 struct ib_udata *udata);
2112 int (*dealloc_ucontext)(struct ib_ucontext *context);
2113 int (*mmap)(struct ib_ucontext *context,
2114 struct vm_area_struct *vma);
2115 struct ib_pd * (*alloc_pd)(struct ib_device *device,
2116 struct ib_ucontext *context,
2117 struct ib_udata *udata);
2118 int (*dealloc_pd)(struct ib_pd *pd);
2119 struct ib_ah * (*create_ah)(struct ib_pd *pd,
2120 struct rdma_ah_attr *ah_attr,
2121 struct ib_udata *udata);
2122 int (*modify_ah)(struct ib_ah *ah,
2123 struct rdma_ah_attr *ah_attr);
2124 int (*query_ah)(struct ib_ah *ah,
2125 struct rdma_ah_attr *ah_attr);
2126 int (*destroy_ah)(struct ib_ah *ah);
2127 struct ib_srq * (*create_srq)(struct ib_pd *pd,
2128 struct ib_srq_init_attr *srq_init_attr,
2129 struct ib_udata *udata);
2130 int (*modify_srq)(struct ib_srq *srq,
2131 struct ib_srq_attr *srq_attr,
2132 enum ib_srq_attr_mask srq_attr_mask,
2133 struct ib_udata *udata);
2134 int (*query_srq)(struct ib_srq *srq,
2135 struct ib_srq_attr *srq_attr);
2136 int (*destroy_srq)(struct ib_srq *srq);
2137 int (*post_srq_recv)(struct ib_srq *srq,
2138 struct ib_recv_wr *recv_wr,
2139 struct ib_recv_wr **bad_recv_wr);
2140 struct ib_qp * (*create_qp)(struct ib_pd *pd,
2141 struct ib_qp_init_attr *qp_init_attr,
2142 struct ib_udata *udata);
2143 int (*modify_qp)(struct ib_qp *qp,
2144 struct ib_qp_attr *qp_attr,
2145 int qp_attr_mask,
2146 struct ib_udata *udata);
2147 int (*query_qp)(struct ib_qp *qp,
2148 struct ib_qp_attr *qp_attr,
2149 int qp_attr_mask,
2150 struct ib_qp_init_attr *qp_init_attr);
2151 int (*destroy_qp)(struct ib_qp *qp);
2152 int (*post_send)(struct ib_qp *qp,
2153 struct ib_send_wr *send_wr,
2154 struct ib_send_wr **bad_send_wr);
2155 int (*post_recv)(struct ib_qp *qp,
2156 struct ib_recv_wr *recv_wr,
2157 struct ib_recv_wr **bad_recv_wr);
2158 struct ib_cq * (*create_cq)(struct ib_device *device,
2159 const struct ib_cq_init_attr *attr,
2160 struct ib_ucontext *context,
2161 struct ib_udata *udata);
2162 int (*modify_cq)(struct ib_cq *cq, u16 cq_count,
2163 u16 cq_period);
2164 int (*destroy_cq)(struct ib_cq *cq);
2165 int (*resize_cq)(struct ib_cq *cq, int cqe,
2166 struct ib_udata *udata);
2167 int (*poll_cq)(struct ib_cq *cq, int num_entries,
2168 struct ib_wc *wc);
2169 int (*peek_cq)(struct ib_cq *cq, int wc_cnt);
2170 int (*req_notify_cq)(struct ib_cq *cq,
2171 enum ib_cq_notify_flags flags);
2172 int (*req_ncomp_notif)(struct ib_cq *cq,
2173 int wc_cnt);
2174 struct ib_mr * (*get_dma_mr)(struct ib_pd *pd,
2175 int mr_access_flags);
2176 struct ib_mr * (*reg_user_mr)(struct ib_pd *pd,
2177 u64 start, u64 length,
2178 u64 virt_addr,
2179 int mr_access_flags,
2180 struct ib_udata *udata);
2181 int (*rereg_user_mr)(struct ib_mr *mr,
2182 int flags,
2183 u64 start, u64 length,
2184 u64 virt_addr,
2185 int mr_access_flags,
2186 struct ib_pd *pd,
2187 struct ib_udata *udata);
2188 int (*dereg_mr)(struct ib_mr *mr);
2189 struct ib_mr * (*alloc_mr)(struct ib_pd *pd,
2190 enum ib_mr_type mr_type,
2191 u32 max_num_sg);
2192 int (*map_mr_sg)(struct ib_mr *mr,
2193 struct scatterlist *sg,
2194 int sg_nents,
2195 unsigned int *sg_offset);
2196 struct ib_mw * (*alloc_mw)(struct ib_pd *pd,
2197 enum ib_mw_type type,
2198 struct ib_udata *udata);
2199 int (*dealloc_mw)(struct ib_mw *mw);
2200 struct ib_fmr * (*alloc_fmr)(struct ib_pd *pd,
2201 int mr_access_flags,
2202 struct ib_fmr_attr *fmr_attr);
2203 int (*map_phys_fmr)(struct ib_fmr *fmr,
2204 u64 *page_list, int list_len,
2205 u64 iova);
2206 int (*unmap_fmr)(struct list_head *fmr_list);
2207 int (*dealloc_fmr)(struct ib_fmr *fmr);
2208 int (*attach_mcast)(struct ib_qp *qp,
2209 union ib_gid *gid,
2210 u16 lid);
2211 int (*detach_mcast)(struct ib_qp *qp,
2212 union ib_gid *gid,
2213 u16 lid);
2214 int (*process_mad)(struct ib_device *device,
2215 int process_mad_flags,
2216 u8 port_num,
2217 const struct ib_wc *in_wc,
2218 const struct ib_grh *in_grh,
2219 const struct ib_mad_hdr *in_mad,
2220 size_t in_mad_size,
2221 struct ib_mad_hdr *out_mad,
2222 size_t *out_mad_size,
2223 u16 *out_mad_pkey_index);
2224 struct ib_xrcd * (*alloc_xrcd)(struct ib_device *device,
2225 struct ib_ucontext *ucontext,
2226 struct ib_udata *udata);
2227 int (*dealloc_xrcd)(struct ib_xrcd *xrcd);
2228 struct ib_flow * (*create_flow)(struct ib_qp *qp,
2229 struct ib_flow_attr
2230 *flow_attr,
2231 int domain);
2232 int (*destroy_flow)(struct ib_flow *flow_id);
2233 int (*check_mr_status)(struct ib_mr *mr, u32 check_mask,
2234 struct ib_mr_status *mr_status);
2235 void (*disassociate_ucontext)(struct ib_ucontext *ibcontext);
2236 void (*drain_rq)(struct ib_qp *qp);
2237 void (*drain_sq)(struct ib_qp *qp);
2238 int (*set_vf_link_state)(struct ib_device *device, int vf, u8 port,
2239 int state);
2240 int (*get_vf_config)(struct ib_device *device, int vf, u8 port,
2241 struct ifla_vf_info *ivf);
2242 int (*get_vf_stats)(struct ib_device *device, int vf, u8 port,
2243 struct ifla_vf_stats *stats);
2244 int (*set_vf_guid)(struct ib_device *device, int vf, u8 port, u64 guid,
2245 int type);
2246 struct ib_wq * (*create_wq)(struct ib_pd *pd,
2247 struct ib_wq_init_attr *init_attr,
2248 struct ib_udata *udata);
2249 int (*destroy_wq)(struct ib_wq *wq);
2250 int (*modify_wq)(struct ib_wq *wq,
2251 struct ib_wq_attr *attr,
2252 u32 wq_attr_mask,
2253 struct ib_udata *udata);
2254 struct ib_rwq_ind_table * (*create_rwq_ind_table)(struct ib_device *device,
2255 struct ib_rwq_ind_table_init_attr *init_attr,
2256 struct ib_udata *udata);
2257 int (*destroy_rwq_ind_table)(struct ib_rwq_ind_table *wq_ind_table);
2258 /**
2259 * rdma netdev operation
2260 *
2261 * Driver implementing alloc_rdma_netdev must return -EOPNOTSUPP if it
2262 * doesn't support the specified rdma netdev type.
2263 */
2264 struct net_device *(*alloc_rdma_netdev)(
2265 struct ib_device *device,
2266 u8 port_num,
2267 enum rdma_netdev_t type,
2268 const char *name,
2269 unsigned char name_assign_type,
2270 void (*setup)(struct net_device *));
2271
2272 struct module *owner;
2273 struct device dev;
2274 struct kobject *ports_parent;
2275 struct list_head port_list;
2276
2277 enum {
2278 IB_DEV_UNINITIALIZED,
2279 IB_DEV_REGISTERED,
2280 IB_DEV_UNREGISTERED
2281 } reg_state;
2282
2283 int uverbs_abi_ver;
2284 u64 uverbs_cmd_mask;
2285 u64 uverbs_ex_cmd_mask;
2286
2287 char node_desc[IB_DEVICE_NODE_DESC_MAX];
2288 __be64 node_guid;
2289 u32 local_dma_lkey;
2290 u16 is_switch:1;
2291 u8 node_type;
2292 u8 phys_port_cnt;
2293 struct ib_device_attr attrs;
2294 struct attribute_group *hw_stats_ag;
2295 struct rdma_hw_stats *hw_stats;
2296
2297 #ifdef CONFIG_CGROUP_RDMA
2298 struct rdmacg_device cg_device;
2299 #endif
2300
2301 /**
2302 * The following mandatory functions are used only at device
2303 * registration. Keep functions such as these at the end of this
2304 * structure to avoid cache line misses when accessing struct ib_device
2305 * in fast paths.
2306 */
2307 int (*get_port_immutable)(struct ib_device *, u8, struct ib_port_immutable *);
2308 void (*get_dev_fw_str)(struct ib_device *, char *str, size_t str_len);
2309 };
2310
2311 struct ib_client {
2312 char *name;
2313 void (*add) (struct ib_device *);
2314 void (*remove)(struct ib_device *, void *client_data);
2315
2316 /* Returns the net_dev belonging to this ib_client and matching the
2317 * given parameters.
2318 * @dev: An RDMA device that the net_dev use for communication.
2319 * @port: A physical port number on the RDMA device.
2320 * @pkey: P_Key that the net_dev uses if applicable.
2321 * @gid: A GID that the net_dev uses to communicate.
2322 * @addr: An IP address the net_dev is configured with.
2323 * @client_data: The device's client data set by ib_set_client_data().
2324 *
2325 * An ib_client that implements a net_dev on top of RDMA devices
2326 * (such as IP over IB) should implement this callback, allowing the
2327 * rdma_cm module to find the right net_dev for a given request.
2328 *
2329 * The caller is responsible for calling dev_put on the returned
2330 * netdev. */
2331 struct net_device *(*get_net_dev_by_params)(
2332 struct ib_device *dev,
2333 u8 port,
2334 u16 pkey,
2335 const union ib_gid *gid,
2336 const struct sockaddr *addr,
2337 void *client_data);
2338 struct list_head list;
2339 };
2340
2341 struct ib_device *ib_alloc_device(size_t size);
2342 void ib_dealloc_device(struct ib_device *device);
2343
2344 void ib_get_device_fw_str(struct ib_device *device, char *str, size_t str_len);
2345
2346 int ib_register_device(struct ib_device *device,
2347 int (*port_callback)(struct ib_device *,
2348 u8, struct kobject *));
2349 void ib_unregister_device(struct ib_device *device);
2350
2351 int ib_register_client (struct ib_client *client);
2352 void ib_unregister_client(struct ib_client *client);
2353
2354 void *ib_get_client_data(struct ib_device *device, struct ib_client *client);
2355 void ib_set_client_data(struct ib_device *device, struct ib_client *client,
2356 void *data);
2357
2358 static inline int ib_copy_from_udata(void *dest, struct ib_udata *udata, size_t len)
2359 {
2360 return copy_from_user(dest, udata->inbuf, len) ? -EFAULT : 0;
2361 }
2362
2363 static inline int ib_copy_to_udata(struct ib_udata *udata, void *src, size_t len)
2364 {
2365 return copy_to_user(udata->outbuf, src, len) ? -EFAULT : 0;
2366 }
2367
2368 static inline bool ib_is_udata_cleared(struct ib_udata *udata,
2369 size_t offset,
2370 size_t len)
2371 {
2372 const void __user *p = udata->inbuf + offset;
2373 bool ret;
2374 u8 *buf;
2375
2376 if (len > USHRT_MAX)
2377 return false;
2378
2379 buf = memdup_user(p, len);
2380 if (IS_ERR(buf))
2381 return false;
2382
2383 ret = !memchr_inv(buf, 0, len);
2384 kfree(buf);
2385 return ret;
2386 }
2387
2388 /**
2389 * ib_modify_qp_is_ok - Check that the supplied attribute mask
2390 * contains all required attributes and no attributes not allowed for
2391 * the given QP state transition.
2392 * @cur_state: Current QP state
2393 * @next_state: Next QP state
2394 * @type: QP type
2395 * @mask: Mask of supplied QP attributes
2396 * @ll : link layer of port
2397 *
2398 * This function is a helper function that a low-level driver's
2399 * modify_qp method can use to validate the consumer's input. It
2400 * checks that cur_state and next_state are valid QP states, that a
2401 * transition from cur_state to next_state is allowed by the IB spec,
2402 * and that the attribute mask supplied is allowed for the transition.
2403 */
2404 int ib_modify_qp_is_ok(enum ib_qp_state cur_state, enum ib_qp_state next_state,
2405 enum ib_qp_type type, enum ib_qp_attr_mask mask,
2406 enum rdma_link_layer ll);
2407
2408 int ib_register_event_handler (struct ib_event_handler *event_handler);
2409 int ib_unregister_event_handler(struct ib_event_handler *event_handler);
2410 void ib_dispatch_event(struct ib_event *event);
2411
2412 int ib_query_port(struct ib_device *device,
2413 u8 port_num, struct ib_port_attr *port_attr);
2414
2415 enum rdma_link_layer rdma_port_get_link_layer(struct ib_device *device,
2416 u8 port_num);
2417
2418 /**
2419 * rdma_cap_ib_switch - Check if the device is IB switch
2420 * @device: Device to check
2421 *
2422 * Device driver is responsible for setting is_switch bit on
2423 * in ib_device structure at init time.
2424 *
2425 * Return: true if the device is IB switch.
2426 */
2427 static inline bool rdma_cap_ib_switch(const struct ib_device *device)
2428 {
2429 return device->is_switch;
2430 }
2431
2432 /**
2433 * rdma_start_port - Return the first valid port number for the device
2434 * specified
2435 *
2436 * @device: Device to be checked
2437 *
2438 * Return start port number
2439 */
2440 static inline u8 rdma_start_port(const struct ib_device *device)
2441 {
2442 return rdma_cap_ib_switch(device) ? 0 : 1;
2443 }
2444
2445 /**
2446 * rdma_end_port - Return the last valid port number for the device
2447 * specified
2448 *
2449 * @device: Device to be checked
2450 *
2451 * Return last port number
2452 */
2453 static inline u8 rdma_end_port(const struct ib_device *device)
2454 {
2455 return rdma_cap_ib_switch(device) ? 0 : device->phys_port_cnt;
2456 }
2457
2458 static inline int rdma_is_port_valid(const struct ib_device *device,
2459 unsigned int port)
2460 {
2461 return (port >= rdma_start_port(device) &&
2462 port <= rdma_end_port(device));
2463 }
2464
2465 static inline bool rdma_protocol_ib(const struct ib_device *device, u8 port_num)
2466 {
2467 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_IB;
2468 }
2469
2470 static inline bool rdma_protocol_roce(const struct ib_device *device, u8 port_num)
2471 {
2472 return device->port_immutable[port_num].core_cap_flags &
2473 (RDMA_CORE_CAP_PROT_ROCE | RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP);
2474 }
2475
2476 static inline bool rdma_protocol_roce_udp_encap(const struct ib_device *device, u8 port_num)
2477 {
2478 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP;
2479 }
2480
2481 static inline bool rdma_protocol_roce_eth_encap(const struct ib_device *device, u8 port_num)
2482 {
2483 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_ROCE;
2484 }
2485
2486 static inline bool rdma_protocol_iwarp(const struct ib_device *device, u8 port_num)
2487 {
2488 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_IWARP;
2489 }
2490
2491 static inline bool rdma_ib_or_roce(const struct ib_device *device, u8 port_num)
2492 {
2493 return rdma_protocol_ib(device, port_num) ||
2494 rdma_protocol_roce(device, port_num);
2495 }
2496
2497 static inline bool rdma_protocol_raw_packet(const struct ib_device *device, u8 port_num)
2498 {
2499 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_RAW_PACKET;
2500 }
2501
2502 static inline bool rdma_protocol_usnic(const struct ib_device *device, u8 port_num)
2503 {
2504 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_USNIC;
2505 }
2506
2507 /**
2508 * rdma_cap_ib_mad - Check if the port of a device supports Infiniband
2509 * Management Datagrams.
2510 * @device: Device to check
2511 * @port_num: Port number to check
2512 *
2513 * Management Datagrams (MAD) are a required part of the InfiniBand
2514 * specification and are supported on all InfiniBand devices. A slightly
2515 * extended version are also supported on OPA interfaces.
2516 *
2517 * Return: true if the port supports sending/receiving of MAD packets.
2518 */
2519 static inline bool rdma_cap_ib_mad(const struct ib_device *device, u8 port_num)
2520 {
2521 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_MAD;
2522 }
2523
2524 /**
2525 * rdma_cap_opa_mad - Check if the port of device provides support for OPA
2526 * Management Datagrams.
2527 * @device: Device to check
2528 * @port_num: Port number to check
2529 *
2530 * Intel OmniPath devices extend and/or replace the InfiniBand Management
2531 * datagrams with their own versions. These OPA MADs share many but not all of
2532 * the characteristics of InfiniBand MADs.
2533 *
2534 * OPA MADs differ in the following ways:
2535 *
2536 * 1) MADs are variable size up to 2K
2537 * IBTA defined MADs remain fixed at 256 bytes
2538 * 2) OPA SMPs must carry valid PKeys
2539 * 3) OPA SMP packets are a different format
2540 *
2541 * Return: true if the port supports OPA MAD packet formats.
2542 */
2543 static inline bool rdma_cap_opa_mad(struct ib_device *device, u8 port_num)
2544 {
2545 return (device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_OPA_MAD)
2546 == RDMA_CORE_CAP_OPA_MAD;
2547 }
2548
2549 /**
2550 * rdma_cap_ib_smi - Check if the port of a device provides an Infiniband
2551 * Subnet Management Agent (SMA) on the Subnet Management Interface (SMI).
2552 * @device: Device to check
2553 * @port_num: Port number to check
2554 *
2555 * Each InfiniBand node is required to provide a Subnet Management Agent
2556 * that the subnet manager can access. Prior to the fabric being fully
2557 * configured by the subnet manager, the SMA is accessed via a well known
2558 * interface called the Subnet Management Interface (SMI). This interface
2559 * uses directed route packets to communicate with the SM to get around the
2560 * chicken and egg problem of the SM needing to know what's on the fabric
2561 * in order to configure the fabric, and needing to configure the fabric in
2562 * order to send packets to the devices on the fabric. These directed
2563 * route packets do not need the fabric fully configured in order to reach
2564 * their destination. The SMI is the only method allowed to send
2565 * directed route packets on an InfiniBand fabric.
2566 *
2567 * Return: true if the port provides an SMI.
2568 */
2569 static inline bool rdma_cap_ib_smi(const struct ib_device *device, u8 port_num)
2570 {
2571 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_SMI;
2572 }
2573
2574 /**
2575 * rdma_cap_ib_cm - Check if the port of device has the capability Infiniband
2576 * Communication Manager.
2577 * @device: Device to check
2578 * @port_num: Port number to check
2579 *
2580 * The InfiniBand Communication Manager is one of many pre-defined General
2581 * Service Agents (GSA) that are accessed via the General Service
2582 * Interface (GSI). It's role is to facilitate establishment of connections
2583 * between nodes as well as other management related tasks for established
2584 * connections.
2585 *
2586 * Return: true if the port supports an IB CM (this does not guarantee that
2587 * a CM is actually running however).
2588 */
2589 static inline bool rdma_cap_ib_cm(const struct ib_device *device, u8 port_num)
2590 {
2591 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_CM;
2592 }
2593
2594 /**
2595 * rdma_cap_iw_cm - Check if the port of device has the capability IWARP
2596 * Communication Manager.
2597 * @device: Device to check
2598 * @port_num: Port number to check
2599 *
2600 * Similar to above, but specific to iWARP connections which have a different
2601 * managment protocol than InfiniBand.
2602 *
2603 * Return: true if the port supports an iWARP CM (this does not guarantee that
2604 * a CM is actually running however).
2605 */
2606 static inline bool rdma_cap_iw_cm(const struct ib_device *device, u8 port_num)
2607 {
2608 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IW_CM;
2609 }
2610
2611 /**
2612 * rdma_cap_ib_sa - Check if the port of device has the capability Infiniband
2613 * Subnet Administration.
2614 * @device: Device to check
2615 * @port_num: Port number to check
2616 *
2617 * An InfiniBand Subnet Administration (SA) service is a pre-defined General
2618 * Service Agent (GSA) provided by the Subnet Manager (SM). On InfiniBand
2619 * fabrics, devices should resolve routes to other hosts by contacting the
2620 * SA to query the proper route.
2621 *
2622 * Return: true if the port should act as a client to the fabric Subnet
2623 * Administration interface. This does not imply that the SA service is
2624 * running locally.
2625 */
2626 static inline bool rdma_cap_ib_sa(const struct ib_device *device, u8 port_num)
2627 {
2628 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_SA;
2629 }
2630
2631 /**
2632 * rdma_cap_ib_mcast - Check if the port of device has the capability Infiniband
2633 * Multicast.
2634 * @device: Device to check
2635 * @port_num: Port number to check
2636 *
2637 * InfiniBand multicast registration is more complex than normal IPv4 or
2638 * IPv6 multicast registration. Each Host Channel Adapter must register
2639 * with the Subnet Manager when it wishes to join a multicast group. It
2640 * should do so only once regardless of how many queue pairs it subscribes
2641 * to this group. And it should leave the group only after all queue pairs
2642 * attached to the group have been detached.
2643 *
2644 * Return: true if the port must undertake the additional adminstrative
2645 * overhead of registering/unregistering with the SM and tracking of the
2646 * total number of queue pairs attached to the multicast group.
2647 */
2648 static inline bool rdma_cap_ib_mcast(const struct ib_device *device, u8 port_num)
2649 {
2650 return rdma_cap_ib_sa(device, port_num);
2651 }
2652
2653 /**
2654 * rdma_cap_af_ib - Check if the port of device has the capability
2655 * Native Infiniband Address.
2656 * @device: Device to check
2657 * @port_num: Port number to check
2658 *
2659 * InfiniBand addressing uses a port's GUID + Subnet Prefix to make a default
2660 * GID. RoCE uses a different mechanism, but still generates a GID via
2661 * a prescribed mechanism and port specific data.
2662 *
2663 * Return: true if the port uses a GID address to identify devices on the
2664 * network.
2665 */
2666 static inline bool rdma_cap_af_ib(const struct ib_device *device, u8 port_num)
2667 {
2668 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_AF_IB;
2669 }
2670
2671 /**
2672 * rdma_cap_eth_ah - Check if the port of device has the capability
2673 * Ethernet Address Handle.
2674 * @device: Device to check
2675 * @port_num: Port number to check
2676 *
2677 * RoCE is InfiniBand over Ethernet, and it uses a well defined technique
2678 * to fabricate GIDs over Ethernet/IP specific addresses native to the
2679 * port. Normally, packet headers are generated by the sending host
2680 * adapter, but when sending connectionless datagrams, we must manually
2681 * inject the proper headers for the fabric we are communicating over.
2682 *
2683 * Return: true if we are running as a RoCE port and must force the
2684 * addition of a Global Route Header built from our Ethernet Address
2685 * Handle into our header list for connectionless packets.
2686 */
2687 static inline bool rdma_cap_eth_ah(const struct ib_device *device, u8 port_num)
2688 {
2689 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_ETH_AH;
2690 }
2691
2692 /**
2693 * rdma_cap_opa_ah - Check if the port of device supports
2694 * OPA Address handles
2695 * @device: Device to check
2696 * @port_num: Port number to check
2697 *
2698 * Return: true if we are running on an OPA device which supports
2699 * the extended OPA addressing.
2700 */
2701 static inline bool rdma_cap_opa_ah(struct ib_device *device, u8 port_num)
2702 {
2703 return (device->port_immutable[port_num].core_cap_flags &
2704 RDMA_CORE_CAP_OPA_AH) == RDMA_CORE_CAP_OPA_AH;
2705 }
2706
2707 /**
2708 * rdma_max_mad_size - Return the max MAD size required by this RDMA Port.
2709 *
2710 * @device: Device
2711 * @port_num: Port number
2712 *
2713 * This MAD size includes the MAD headers and MAD payload. No other headers
2714 * are included.
2715 *
2716 * Return the max MAD size required by the Port. Will return 0 if the port
2717 * does not support MADs
2718 */
2719 static inline size_t rdma_max_mad_size(const struct ib_device *device, u8 port_num)
2720 {
2721 return device->port_immutable[port_num].max_mad_size;
2722 }
2723
2724 /**
2725 * rdma_cap_roce_gid_table - Check if the port of device uses roce_gid_table
2726 * @device: Device to check
2727 * @port_num: Port number to check
2728 *
2729 * RoCE GID table mechanism manages the various GIDs for a device.
2730 *
2731 * NOTE: if allocating the port's GID table has failed, this call will still
2732 * return true, but any RoCE GID table API will fail.
2733 *
2734 * Return: true if the port uses RoCE GID table mechanism in order to manage
2735 * its GIDs.
2736 */
2737 static inline bool rdma_cap_roce_gid_table(const struct ib_device *device,
2738 u8 port_num)
2739 {
2740 return rdma_protocol_roce(device, port_num) &&
2741 device->add_gid && device->del_gid;
2742 }
2743
2744 /*
2745 * Check if the device supports READ W/ INVALIDATE.
2746 */
2747 static inline bool rdma_cap_read_inv(struct ib_device *dev, u32 port_num)
2748 {
2749 /*
2750 * iWarp drivers must support READ W/ INVALIDATE. No other protocol
2751 * has support for it yet.
2752 */
2753 return rdma_protocol_iwarp(dev, port_num);
2754 }
2755
2756 int ib_query_gid(struct ib_device *device,
2757 u8 port_num, int index, union ib_gid *gid,
2758 struct ib_gid_attr *attr);
2759
2760 int ib_set_vf_link_state(struct ib_device *device, int vf, u8 port,
2761 int state);
2762 int ib_get_vf_config(struct ib_device *device, int vf, u8 port,
2763 struct ifla_vf_info *info);
2764 int ib_get_vf_stats(struct ib_device *device, int vf, u8 port,
2765 struct ifla_vf_stats *stats);
2766 int ib_set_vf_guid(struct ib_device *device, int vf, u8 port, u64 guid,
2767 int type);
2768
2769 int ib_query_pkey(struct ib_device *device,
2770 u8 port_num, u16 index, u16 *pkey);
2771
2772 int ib_modify_device(struct ib_device *device,
2773 int device_modify_mask,
2774 struct ib_device_modify *device_modify);
2775
2776 int ib_modify_port(struct ib_device *device,
2777 u8 port_num, int port_modify_mask,
2778 struct ib_port_modify *port_modify);
2779
2780 int ib_find_gid(struct ib_device *device, union ib_gid *gid,
2781 enum ib_gid_type gid_type, struct net_device *ndev,
2782 u8 *port_num, u16 *index);
2783
2784 int ib_find_pkey(struct ib_device *device,
2785 u8 port_num, u16 pkey, u16 *index);
2786
2787 enum ib_pd_flags {
2788 /*
2789 * Create a memory registration for all memory in the system and place
2790 * the rkey for it into pd->unsafe_global_rkey. This can be used by
2791 * ULPs to avoid the overhead of dynamic MRs.
2792 *
2793 * This flag is generally considered unsafe and must only be used in
2794 * extremly trusted environments. Every use of it will log a warning
2795 * in the kernel log.
2796 */
2797 IB_PD_UNSAFE_GLOBAL_RKEY = 0x01,
2798 };
2799
2800 struct ib_pd *__ib_alloc_pd(struct ib_device *device, unsigned int flags,
2801 const char *caller);
2802 #define ib_alloc_pd(device, flags) \
2803 __ib_alloc_pd((device), (flags), __func__)
2804 void ib_dealloc_pd(struct ib_pd *pd);
2805
2806 /**
2807 * rdma_create_ah - Creates an address handle for the given address vector.
2808 * @pd: The protection domain associated with the address handle.
2809 * @ah_attr: The attributes of the address vector.
2810 *
2811 * The address handle is used to reference a local or global destination
2812 * in all UD QP post sends.
2813 */
2814 struct ib_ah *rdma_create_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr);
2815
2816 /**
2817 * ib_get_gids_from_rdma_hdr - Get sgid and dgid from GRH or IPv4 header
2818 * work completion.
2819 * @hdr: the L3 header to parse
2820 * @net_type: type of header to parse
2821 * @sgid: place to store source gid
2822 * @dgid: place to store destination gid
2823 */
2824 int ib_get_gids_from_rdma_hdr(const union rdma_network_hdr *hdr,
2825 enum rdma_network_type net_type,
2826 union ib_gid *sgid, union ib_gid *dgid);
2827
2828 /**
2829 * ib_get_rdma_header_version - Get the header version
2830 * @hdr: the L3 header to parse
2831 */
2832 int ib_get_rdma_header_version(const union rdma_network_hdr *hdr);
2833
2834 /**
2835 * ib_init_ah_from_wc - Initializes address handle attributes from a
2836 * work completion.
2837 * @device: Device on which the received message arrived.
2838 * @port_num: Port on which the received message arrived.
2839 * @wc: Work completion associated with the received message.
2840 * @grh: References the received global route header. This parameter is
2841 * ignored unless the work completion indicates that the GRH is valid.
2842 * @ah_attr: Returned attributes that can be used when creating an address
2843 * handle for replying to the message.
2844 */
2845 int ib_init_ah_from_wc(struct ib_device *device, u8 port_num,
2846 const struct ib_wc *wc, const struct ib_grh *grh,
2847 struct rdma_ah_attr *ah_attr);
2848
2849 /**
2850 * ib_create_ah_from_wc - Creates an address handle associated with the
2851 * sender of the specified work completion.
2852 * @pd: The protection domain associated with the address handle.
2853 * @wc: Work completion information associated with a received message.
2854 * @grh: References the received global route header. This parameter is
2855 * ignored unless the work completion indicates that the GRH is valid.
2856 * @port_num: The outbound port number to associate with the address.
2857 *
2858 * The address handle is used to reference a local or global destination
2859 * in all UD QP post sends.
2860 */
2861 struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, const struct ib_wc *wc,
2862 const struct ib_grh *grh, u8 port_num);
2863
2864 /**
2865 * rdma_modify_ah - Modifies the address vector associated with an address
2866 * handle.
2867 * @ah: The address handle to modify.
2868 * @ah_attr: The new address vector attributes to associate with the
2869 * address handle.
2870 */
2871 int rdma_modify_ah(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
2872
2873 /**
2874 * rdma_query_ah - Queries the address vector associated with an address
2875 * handle.
2876 * @ah: The address handle to query.
2877 * @ah_attr: The address vector attributes associated with the address
2878 * handle.
2879 */
2880 int rdma_query_ah(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
2881
2882 /**
2883 * rdma_destroy_ah - Destroys an address handle.
2884 * @ah: The address handle to destroy.
2885 */
2886 int rdma_destroy_ah(struct ib_ah *ah);
2887
2888 /**
2889 * ib_create_srq - Creates a SRQ associated with the specified protection
2890 * domain.
2891 * @pd: The protection domain associated with the SRQ.
2892 * @srq_init_attr: A list of initial attributes required to create the
2893 * SRQ. If SRQ creation succeeds, then the attributes are updated to
2894 * the actual capabilities of the created SRQ.
2895 *
2896 * srq_attr->max_wr and srq_attr->max_sge are read the determine the
2897 * requested size of the SRQ, and set to the actual values allocated
2898 * on return. If ib_create_srq() succeeds, then max_wr and max_sge
2899 * will always be at least as large as the requested values.
2900 */
2901 struct ib_srq *ib_create_srq(struct ib_pd *pd,
2902 struct ib_srq_init_attr *srq_init_attr);
2903
2904 /**
2905 * ib_modify_srq - Modifies the attributes for the specified SRQ.
2906 * @srq: The SRQ to modify.
2907 * @srq_attr: On input, specifies the SRQ attributes to modify. On output,
2908 * the current values of selected SRQ attributes are returned.
2909 * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ
2910 * are being modified.
2911 *
2912 * The mask may contain IB_SRQ_MAX_WR to resize the SRQ and/or
2913 * IB_SRQ_LIMIT to set the SRQ's limit and request notification when
2914 * the number of receives queued drops below the limit.
2915 */
2916 int ib_modify_srq(struct ib_srq *srq,
2917 struct ib_srq_attr *srq_attr,
2918 enum ib_srq_attr_mask srq_attr_mask);
2919
2920 /**
2921 * ib_query_srq - Returns the attribute list and current values for the
2922 * specified SRQ.
2923 * @srq: The SRQ to query.
2924 * @srq_attr: The attributes of the specified SRQ.
2925 */
2926 int ib_query_srq(struct ib_srq *srq,
2927 struct ib_srq_attr *srq_attr);
2928
2929 /**
2930 * ib_destroy_srq - Destroys the specified SRQ.
2931 * @srq: The SRQ to destroy.
2932 */
2933 int ib_destroy_srq(struct ib_srq *srq);
2934
2935 /**
2936 * ib_post_srq_recv - Posts a list of work requests to the specified SRQ.
2937 * @srq: The SRQ to post the work request on.
2938 * @recv_wr: A list of work requests to post on the receive queue.
2939 * @bad_recv_wr: On an immediate failure, this parameter will reference
2940 * the work request that failed to be posted on the QP.
2941 */
2942 static inline int ib_post_srq_recv(struct ib_srq *srq,
2943 struct ib_recv_wr *recv_wr,
2944 struct ib_recv_wr **bad_recv_wr)
2945 {
2946 return srq->device->post_srq_recv(srq, recv_wr, bad_recv_wr);
2947 }
2948
2949 /**
2950 * ib_create_qp - Creates a QP associated with the specified protection
2951 * domain.
2952 * @pd: The protection domain associated with the QP.
2953 * @qp_init_attr: A list of initial attributes required to create the
2954 * QP. If QP creation succeeds, then the attributes are updated to
2955 * the actual capabilities of the created QP.
2956 */
2957 struct ib_qp *ib_create_qp(struct ib_pd *pd,
2958 struct ib_qp_init_attr *qp_init_attr);
2959
2960 /**
2961 * ib_modify_qp_with_udata - Modifies the attributes for the specified QP.
2962 * @qp: The QP to modify.
2963 * @attr: On input, specifies the QP attributes to modify. On output,
2964 * the current values of selected QP attributes are returned.
2965 * @attr_mask: A bit-mask used to specify which attributes of the QP
2966 * are being modified.
2967 * @udata: pointer to user's input output buffer information
2968 * are being modified.
2969 * It returns 0 on success and returns appropriate error code on error.
2970 */
2971 int ib_modify_qp_with_udata(struct ib_qp *qp,
2972 struct ib_qp_attr *attr,
2973 int attr_mask,
2974 struct ib_udata *udata);
2975
2976 /**
2977 * ib_modify_qp - Modifies the attributes for the specified QP and then
2978 * transitions the QP to the given state.
2979 * @qp: The QP to modify.
2980 * @qp_attr: On input, specifies the QP attributes to modify. On output,
2981 * the current values of selected QP attributes are returned.
2982 * @qp_attr_mask: A bit-mask used to specify which attributes of the QP
2983 * are being modified.
2984 */
2985 int ib_modify_qp(struct ib_qp *qp,
2986 struct ib_qp_attr *qp_attr,
2987 int qp_attr_mask);
2988
2989 /**
2990 * ib_query_qp - Returns the attribute list and current values for the
2991 * specified QP.
2992 * @qp: The QP to query.
2993 * @qp_attr: The attributes of the specified QP.
2994 * @qp_attr_mask: A bit-mask used to select specific attributes to query.
2995 * @qp_init_attr: Additional attributes of the selected QP.
2996 *
2997 * The qp_attr_mask may be used to limit the query to gathering only the
2998 * selected attributes.
2999 */
3000 int ib_query_qp(struct ib_qp *qp,
3001 struct ib_qp_attr *qp_attr,
3002 int qp_attr_mask,
3003 struct ib_qp_init_attr *qp_init_attr);
3004
3005 /**
3006 * ib_destroy_qp - Destroys the specified QP.
3007 * @qp: The QP to destroy.
3008 */
3009 int ib_destroy_qp(struct ib_qp *qp);
3010
3011 /**
3012 * ib_open_qp - Obtain a reference to an existing sharable QP.
3013 * @xrcd - XRC domain
3014 * @qp_open_attr: Attributes identifying the QP to open.
3015 *
3016 * Returns a reference to a sharable QP.
3017 */
3018 struct ib_qp *ib_open_qp(struct ib_xrcd *xrcd,
3019 struct ib_qp_open_attr *qp_open_attr);
3020
3021 /**
3022 * ib_close_qp - Release an external reference to a QP.
3023 * @qp: The QP handle to release
3024 *
3025 * The opened QP handle is released by the caller. The underlying
3026 * shared QP is not destroyed until all internal references are released.
3027 */
3028 int ib_close_qp(struct ib_qp *qp);
3029
3030 /**
3031 * ib_post_send - Posts a list of work requests to the send queue of
3032 * the specified QP.
3033 * @qp: The QP to post the work request on.
3034 * @send_wr: A list of work requests to post on the send queue.
3035 * @bad_send_wr: On an immediate failure, this parameter will reference
3036 * the work request that failed to be posted on the QP.
3037 *
3038 * While IBA Vol. 1 section 11.4.1.1 specifies that if an immediate
3039 * error is returned, the QP state shall not be affected,
3040 * ib_post_send() will return an immediate error after queueing any
3041 * earlier work requests in the list.
3042 */
3043 static inline int ib_post_send(struct ib_qp *qp,
3044 struct ib_send_wr *send_wr,
3045 struct ib_send_wr **bad_send_wr)
3046 {
3047 return qp->device->post_send(qp, send_wr, bad_send_wr);
3048 }
3049
3050 /**
3051 * ib_post_recv - Posts a list of work requests to the receive queue of
3052 * the specified QP.
3053 * @qp: The QP to post the work request on.
3054 * @recv_wr: A list of work requests to post on the receive queue.
3055 * @bad_recv_wr: On an immediate failure, this parameter will reference
3056 * the work request that failed to be posted on the QP.
3057 */
3058 static inline int ib_post_recv(struct ib_qp *qp,
3059 struct ib_recv_wr *recv_wr,
3060 struct ib_recv_wr **bad_recv_wr)
3061 {
3062 return qp->device->post_recv(qp, recv_wr, bad_recv_wr);
3063 }
3064
3065 struct ib_cq *ib_alloc_cq(struct ib_device *dev, void *private,
3066 int nr_cqe, int comp_vector, enum ib_poll_context poll_ctx);
3067 void ib_free_cq(struct ib_cq *cq);
3068 int ib_process_cq_direct(struct ib_cq *cq, int budget);
3069
3070 /**
3071 * ib_create_cq - Creates a CQ on the specified device.
3072 * @device: The device on which to create the CQ.
3073 * @comp_handler: A user-specified callback that is invoked when a
3074 * completion event occurs on the CQ.
3075 * @event_handler: A user-specified callback that is invoked when an
3076 * asynchronous event not associated with a completion occurs on the CQ.
3077 * @cq_context: Context associated with the CQ returned to the user via
3078 * the associated completion and event handlers.
3079 * @cq_attr: The attributes the CQ should be created upon.
3080 *
3081 * Users can examine the cq structure to determine the actual CQ size.
3082 */
3083 struct ib_cq *ib_create_cq(struct ib_device *device,
3084 ib_comp_handler comp_handler,
3085 void (*event_handler)(struct ib_event *, void *),
3086 void *cq_context,
3087 const struct ib_cq_init_attr *cq_attr);
3088
3089 /**
3090 * ib_resize_cq - Modifies the capacity of the CQ.
3091 * @cq: The CQ to resize.
3092 * @cqe: The minimum size of the CQ.
3093 *
3094 * Users can examine the cq structure to determine the actual CQ size.
3095 */
3096 int ib_resize_cq(struct ib_cq *cq, int cqe);
3097
3098 /**
3099 * ib_modify_cq - Modifies moderation params of the CQ
3100 * @cq: The CQ to modify.
3101 * @cq_count: number of CQEs that will trigger an event
3102 * @cq_period: max period of time in usec before triggering an event
3103 *
3104 */
3105 int ib_modify_cq(struct ib_cq *cq, u16 cq_count, u16 cq_period);
3106
3107 /**
3108 * ib_destroy_cq - Destroys the specified CQ.
3109 * @cq: The CQ to destroy.
3110 */
3111 int ib_destroy_cq(struct ib_cq *cq);
3112
3113 /**
3114 * ib_poll_cq - poll a CQ for completion(s)
3115 * @cq:the CQ being polled
3116 * @num_entries:maximum number of completions to return
3117 * @wc:array of at least @num_entries &struct ib_wc where completions
3118 * will be returned
3119 *
3120 * Poll a CQ for (possibly multiple) completions. If the return value
3121 * is < 0, an error occurred. If the return value is >= 0, it is the
3122 * number of completions returned. If the return value is
3123 * non-negative and < num_entries, then the CQ was emptied.
3124 */
3125 static inline int ib_poll_cq(struct ib_cq *cq, int num_entries,
3126 struct ib_wc *wc)
3127 {
3128 return cq->device->poll_cq(cq, num_entries, wc);
3129 }
3130
3131 /**
3132 * ib_peek_cq - Returns the number of unreaped completions currently
3133 * on the specified CQ.
3134 * @cq: The CQ to peek.
3135 * @wc_cnt: A minimum number of unreaped completions to check for.
3136 *
3137 * If the number of unreaped completions is greater than or equal to wc_cnt,
3138 * this function returns wc_cnt, otherwise, it returns the actual number of
3139 * unreaped completions.
3140 */
3141 int ib_peek_cq(struct ib_cq *cq, int wc_cnt);
3142
3143 /**
3144 * ib_req_notify_cq - Request completion notification on a CQ.
3145 * @cq: The CQ to generate an event for.
3146 * @flags:
3147 * Must contain exactly one of %IB_CQ_SOLICITED or %IB_CQ_NEXT_COMP
3148 * to request an event on the next solicited event or next work
3149 * completion at any type, respectively. %IB_CQ_REPORT_MISSED_EVENTS
3150 * may also be |ed in to request a hint about missed events, as
3151 * described below.
3152 *
3153 * Return Value:
3154 * < 0 means an error occurred while requesting notification
3155 * == 0 means notification was requested successfully, and if
3156 * IB_CQ_REPORT_MISSED_EVENTS was passed in, then no events
3157 * were missed and it is safe to wait for another event. In
3158 * this case is it guaranteed that any work completions added
3159 * to the CQ since the last CQ poll will trigger a completion
3160 * notification event.
3161 * > 0 is only returned if IB_CQ_REPORT_MISSED_EVENTS was passed
3162 * in. It means that the consumer must poll the CQ again to
3163 * make sure it is empty to avoid missing an event because of a
3164 * race between requesting notification and an entry being
3165 * added to the CQ. This return value means it is possible
3166 * (but not guaranteed) that a work completion has been added
3167 * to the CQ since the last poll without triggering a
3168 * completion notification event.
3169 */
3170 static inline int ib_req_notify_cq(struct ib_cq *cq,
3171 enum ib_cq_notify_flags flags)
3172 {
3173 return cq->device->req_notify_cq(cq, flags);
3174 }
3175
3176 /**
3177 * ib_req_ncomp_notif - Request completion notification when there are
3178 * at least the specified number of unreaped completions on the CQ.
3179 * @cq: The CQ to generate an event for.
3180 * @wc_cnt: The number of unreaped completions that should be on the
3181 * CQ before an event is generated.
3182 */
3183 static inline int ib_req_ncomp_notif(struct ib_cq *cq, int wc_cnt)
3184 {
3185 return cq->device->req_ncomp_notif ?
3186 cq->device->req_ncomp_notif(cq, wc_cnt) :
3187 -ENOSYS;
3188 }
3189
3190 /**
3191 * ib_dma_mapping_error - check a DMA addr for error
3192 * @dev: The device for which the dma_addr was created
3193 * @dma_addr: The DMA address to check
3194 */
3195 static inline int ib_dma_mapping_error(struct ib_device *dev, u64 dma_addr)
3196 {
3197 return dma_mapping_error(dev->dma_device, dma_addr);
3198 }
3199
3200 /**
3201 * ib_dma_map_single - Map a kernel virtual address to DMA address
3202 * @dev: The device for which the dma_addr is to be created
3203 * @cpu_addr: The kernel virtual address
3204 * @size: The size of the region in bytes
3205 * @direction: The direction of the DMA
3206 */
3207 static inline u64 ib_dma_map_single(struct ib_device *dev,
3208 void *cpu_addr, size_t size,
3209 enum dma_data_direction direction)
3210 {
3211 return dma_map_single(dev->dma_device, cpu_addr, size, direction);
3212 }
3213
3214 /**
3215 * ib_dma_unmap_single - Destroy a mapping created by ib_dma_map_single()
3216 * @dev: The device for which the DMA address was created
3217 * @addr: The DMA address
3218 * @size: The size of the region in bytes
3219 * @direction: The direction of the DMA
3220 */
3221 static inline void ib_dma_unmap_single(struct ib_device *dev,
3222 u64 addr, size_t size,
3223 enum dma_data_direction direction)
3224 {
3225 dma_unmap_single(dev->dma_device, addr, size, direction);
3226 }
3227
3228 /**
3229 * ib_dma_map_page - Map a physical page to DMA address
3230 * @dev: The device for which the dma_addr is to be created
3231 * @page: The page to be mapped
3232 * @offset: The offset within the page
3233 * @size: The size of the region in bytes
3234 * @direction: The direction of the DMA
3235 */
3236 static inline u64 ib_dma_map_page(struct ib_device *dev,
3237 struct page *page,
3238 unsigned long offset,
3239 size_t size,
3240 enum dma_data_direction direction)
3241 {
3242 return dma_map_page(dev->dma_device, page, offset, size, direction);
3243 }
3244
3245 /**
3246 * ib_dma_unmap_page - Destroy a mapping created by ib_dma_map_page()
3247 * @dev: The device for which the DMA address was created
3248 * @addr: The DMA address
3249 * @size: The size of the region in bytes
3250 * @direction: The direction of the DMA
3251 */
3252 static inline void ib_dma_unmap_page(struct ib_device *dev,
3253 u64 addr, size_t size,
3254 enum dma_data_direction direction)
3255 {
3256 dma_unmap_page(dev->dma_device, addr, size, direction);
3257 }
3258
3259 /**
3260 * ib_dma_map_sg - Map a scatter/gather list to DMA addresses
3261 * @dev: The device for which the DMA addresses are to be created
3262 * @sg: The array of scatter/gather entries
3263 * @nents: The number of scatter/gather entries
3264 * @direction: The direction of the DMA
3265 */
3266 static inline int ib_dma_map_sg(struct ib_device *dev,
3267 struct scatterlist *sg, int nents,
3268 enum dma_data_direction direction)
3269 {
3270 return dma_map_sg(dev->dma_device, sg, nents, direction);
3271 }
3272
3273 /**
3274 * ib_dma_unmap_sg - Unmap a scatter/gather list of DMA addresses
3275 * @dev: The device for which the DMA addresses were created
3276 * @sg: The array of scatter/gather entries
3277 * @nents: The number of scatter/gather entries
3278 * @direction: The direction of the DMA
3279 */
3280 static inline void ib_dma_unmap_sg(struct ib_device *dev,
3281 struct scatterlist *sg, int nents,
3282 enum dma_data_direction direction)
3283 {
3284 dma_unmap_sg(dev->dma_device, sg, nents, direction);
3285 }
3286
3287 static inline int ib_dma_map_sg_attrs(struct ib_device *dev,
3288 struct scatterlist *sg, int nents,
3289 enum dma_data_direction direction,
3290 unsigned long dma_attrs)
3291 {
3292 return dma_map_sg_attrs(dev->dma_device, sg, nents, direction,
3293 dma_attrs);
3294 }
3295
3296 static inline void ib_dma_unmap_sg_attrs(struct ib_device *dev,
3297 struct scatterlist *sg, int nents,
3298 enum dma_data_direction direction,
3299 unsigned long dma_attrs)
3300 {
3301 dma_unmap_sg_attrs(dev->dma_device, sg, nents, direction, dma_attrs);
3302 }
3303 /**
3304 * ib_sg_dma_address - Return the DMA address from a scatter/gather entry
3305 * @dev: The device for which the DMA addresses were created
3306 * @sg: The scatter/gather entry
3307 *
3308 * Note: this function is obsolete. To do: change all occurrences of
3309 * ib_sg_dma_address() into sg_dma_address().
3310 */
3311 static inline u64 ib_sg_dma_address(struct ib_device *dev,
3312 struct scatterlist *sg)
3313 {
3314 return sg_dma_address(sg);
3315 }
3316
3317 /**
3318 * ib_sg_dma_len - Return the DMA length from a scatter/gather entry
3319 * @dev: The device for which the DMA addresses were created
3320 * @sg: The scatter/gather entry
3321 *
3322 * Note: this function is obsolete. To do: change all occurrences of
3323 * ib_sg_dma_len() into sg_dma_len().
3324 */
3325 static inline unsigned int ib_sg_dma_len(struct ib_device *dev,
3326 struct scatterlist *sg)
3327 {
3328 return sg_dma_len(sg);
3329 }
3330
3331 /**
3332 * ib_dma_sync_single_for_cpu - Prepare DMA region to be accessed by CPU
3333 * @dev: The device for which the DMA address was created
3334 * @addr: The DMA address
3335 * @size: The size of the region in bytes
3336 * @dir: The direction of the DMA
3337 */
3338 static inline void ib_dma_sync_single_for_cpu(struct ib_device *dev,
3339 u64 addr,
3340 size_t size,
3341 enum dma_data_direction dir)
3342 {
3343 dma_sync_single_for_cpu(dev->dma_device, addr, size, dir);
3344 }
3345
3346 /**
3347 * ib_dma_sync_single_for_device - Prepare DMA region to be accessed by device
3348 * @dev: The device for which the DMA address was created
3349 * @addr: The DMA address
3350 * @size: The size of the region in bytes
3351 * @dir: The direction of the DMA
3352 */
3353 static inline void ib_dma_sync_single_for_device(struct ib_device *dev,
3354 u64 addr,
3355 size_t size,
3356 enum dma_data_direction dir)
3357 {
3358 dma_sync_single_for_device(dev->dma_device, addr, size, dir);
3359 }
3360
3361 /**
3362 * ib_dma_alloc_coherent - Allocate memory and map it for DMA
3363 * @dev: The device for which the DMA address is requested
3364 * @size: The size of the region to allocate in bytes
3365 * @dma_handle: A pointer for returning the DMA address of the region
3366 * @flag: memory allocator flags
3367 */
3368 static inline void *ib_dma_alloc_coherent(struct ib_device *dev,
3369 size_t size,
3370 dma_addr_t *dma_handle,
3371 gfp_t flag)
3372 {
3373 return dma_alloc_coherent(dev->dma_device, size, dma_handle, flag);
3374 }
3375
3376 /**
3377 * ib_dma_free_coherent - Free memory allocated by ib_dma_alloc_coherent()
3378 * @dev: The device for which the DMA addresses were allocated
3379 * @size: The size of the region
3380 * @cpu_addr: the address returned by ib_dma_alloc_coherent()
3381 * @dma_handle: the DMA address returned by ib_dma_alloc_coherent()
3382 */
3383 static inline void ib_dma_free_coherent(struct ib_device *dev,
3384 size_t size, void *cpu_addr,
3385 dma_addr_t dma_handle)
3386 {
3387 dma_free_coherent(dev->dma_device, size, cpu_addr, dma_handle);
3388 }
3389
3390 /**
3391 * ib_dereg_mr - Deregisters a memory region and removes it from the
3392 * HCA translation table.
3393 * @mr: The memory region to deregister.
3394 *
3395 * This function can fail, if the memory region has memory windows bound to it.
3396 */
3397 int ib_dereg_mr(struct ib_mr *mr);
3398
3399 struct ib_mr *ib_alloc_mr(struct ib_pd *pd,
3400 enum ib_mr_type mr_type,
3401 u32 max_num_sg);
3402
3403 /**
3404 * ib_update_fast_reg_key - updates the key portion of the fast_reg MR
3405 * R_Key and L_Key.
3406 * @mr - struct ib_mr pointer to be updated.
3407 * @newkey - new key to be used.
3408 */
3409 static inline void ib_update_fast_reg_key(struct ib_mr *mr, u8 newkey)
3410 {
3411 mr->lkey = (mr->lkey & 0xffffff00) | newkey;
3412 mr->rkey = (mr->rkey & 0xffffff00) | newkey;
3413 }
3414
3415 /**
3416 * ib_inc_rkey - increments the key portion of the given rkey. Can be used
3417 * for calculating a new rkey for type 2 memory windows.
3418 * @rkey - the rkey to increment.
3419 */
3420 static inline u32 ib_inc_rkey(u32 rkey)
3421 {
3422 const u32 mask = 0x000000ff;
3423 return ((rkey + 1) & mask) | (rkey & ~mask);
3424 }
3425
3426 /**
3427 * ib_alloc_fmr - Allocates a unmapped fast memory region.
3428 * @pd: The protection domain associated with the unmapped region.
3429 * @mr_access_flags: Specifies the memory access rights.
3430 * @fmr_attr: Attributes of the unmapped region.
3431 *
3432 * A fast memory region must be mapped before it can be used as part of
3433 * a work request.
3434 */
3435 struct ib_fmr *ib_alloc_fmr(struct ib_pd *pd,
3436 int mr_access_flags,
3437 struct ib_fmr_attr *fmr_attr);
3438
3439 /**
3440 * ib_map_phys_fmr - Maps a list of physical pages to a fast memory region.
3441 * @fmr: The fast memory region to associate with the pages.
3442 * @page_list: An array of physical pages to map to the fast memory region.
3443 * @list_len: The number of pages in page_list.
3444 * @iova: The I/O virtual address to use with the mapped region.
3445 */
3446 static inline int ib_map_phys_fmr(struct ib_fmr *fmr,
3447 u64 *page_list, int list_len,
3448 u64 iova)
3449 {
3450 return fmr->device->map_phys_fmr(fmr, page_list, list_len, iova);
3451 }
3452
3453 /**
3454 * ib_unmap_fmr - Removes the mapping from a list of fast memory regions.
3455 * @fmr_list: A linked list of fast memory regions to unmap.
3456 */
3457 int ib_unmap_fmr(struct list_head *fmr_list);
3458
3459 /**
3460 * ib_dealloc_fmr - Deallocates a fast memory region.
3461 * @fmr: The fast memory region to deallocate.
3462 */
3463 int ib_dealloc_fmr(struct ib_fmr *fmr);
3464
3465 /**
3466 * ib_attach_mcast - Attaches the specified QP to a multicast group.
3467 * @qp: QP to attach to the multicast group. The QP must be type
3468 * IB_QPT_UD.
3469 * @gid: Multicast group GID.
3470 * @lid: Multicast group LID in host byte order.
3471 *
3472 * In order to send and receive multicast packets, subnet
3473 * administration must have created the multicast group and configured
3474 * the fabric appropriately. The port associated with the specified
3475 * QP must also be a member of the multicast group.
3476 */
3477 int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
3478
3479 /**
3480 * ib_detach_mcast - Detaches the specified QP from a multicast group.
3481 * @qp: QP to detach from the multicast group.
3482 * @gid: Multicast group GID.
3483 * @lid: Multicast group LID in host byte order.
3484 */
3485 int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
3486
3487 /**
3488 * ib_alloc_xrcd - Allocates an XRC domain.
3489 * @device: The device on which to allocate the XRC domain.
3490 */
3491 struct ib_xrcd *ib_alloc_xrcd(struct ib_device *device);
3492
3493 /**
3494 * ib_dealloc_xrcd - Deallocates an XRC domain.
3495 * @xrcd: The XRC domain to deallocate.
3496 */
3497 int ib_dealloc_xrcd(struct ib_xrcd *xrcd);
3498
3499 struct ib_flow *ib_create_flow(struct ib_qp *qp,
3500 struct ib_flow_attr *flow_attr, int domain);
3501 int ib_destroy_flow(struct ib_flow *flow_id);
3502
3503 static inline int ib_check_mr_access(int flags)
3504 {
3505 /*
3506 * Local write permission is required if remote write or
3507 * remote atomic permission is also requested.
3508 */
3509 if (flags & (IB_ACCESS_REMOTE_ATOMIC | IB_ACCESS_REMOTE_WRITE) &&
3510 !(flags & IB_ACCESS_LOCAL_WRITE))
3511 return -EINVAL;
3512
3513 return 0;
3514 }
3515
3516 /**
3517 * ib_check_mr_status: lightweight check of MR status.
3518 * This routine may provide status checks on a selected
3519 * ib_mr. first use is for signature status check.
3520 *
3521 * @mr: A memory region.
3522 * @check_mask: Bitmask of which checks to perform from
3523 * ib_mr_status_check enumeration.
3524 * @mr_status: The container of relevant status checks.
3525 * failed checks will be indicated in the status bitmask
3526 * and the relevant info shall be in the error item.
3527 */
3528 int ib_check_mr_status(struct ib_mr *mr, u32 check_mask,
3529 struct ib_mr_status *mr_status);
3530
3531 struct net_device *ib_get_net_dev_by_params(struct ib_device *dev, u8 port,
3532 u16 pkey, const union ib_gid *gid,
3533 const struct sockaddr *addr);
3534 struct ib_wq *ib_create_wq(struct ib_pd *pd,
3535 struct ib_wq_init_attr *init_attr);
3536 int ib_destroy_wq(struct ib_wq *wq);
3537 int ib_modify_wq(struct ib_wq *wq, struct ib_wq_attr *attr,
3538 u32 wq_attr_mask);
3539 struct ib_rwq_ind_table *ib_create_rwq_ind_table(struct ib_device *device,
3540 struct ib_rwq_ind_table_init_attr*
3541 wq_ind_table_init_attr);
3542 int ib_destroy_rwq_ind_table(struct ib_rwq_ind_table *wq_ind_table);
3543
3544 int ib_map_mr_sg(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
3545 unsigned int *sg_offset, unsigned int page_size);
3546
3547 static inline int
3548 ib_map_mr_sg_zbva(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
3549 unsigned int *sg_offset, unsigned int page_size)
3550 {
3551 int n;
3552
3553 n = ib_map_mr_sg(mr, sg, sg_nents, sg_offset, page_size);
3554 mr->iova = 0;
3555
3556 return n;
3557 }
3558
3559 int ib_sg_to_pages(struct ib_mr *mr, struct scatterlist *sgl, int sg_nents,
3560 unsigned int *sg_offset, int (*set_page)(struct ib_mr *, u64));
3561
3562 void ib_drain_rq(struct ib_qp *qp);
3563 void ib_drain_sq(struct ib_qp *qp);
3564 void ib_drain_qp(struct ib_qp *qp);
3565
3566 int ib_resolve_eth_dmac(struct ib_device *device,
3567 struct rdma_ah_attr *ah_attr);
3568 int ib_get_eth_speed(struct ib_device *dev, u8 port_num, u8 *speed, u8 *width);
3569
3570 static inline u8 *rdma_ah_retrieve_dmac(struct rdma_ah_attr *attr)
3571 {
3572 if (attr->type == RDMA_AH_ATTR_TYPE_ROCE)
3573 return attr->roce.dmac;
3574 return NULL;
3575 }
3576
3577 static inline void rdma_ah_set_dlid(struct rdma_ah_attr *attr, u32 dlid)
3578 {
3579 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
3580 attr->ib.dlid = (u16)dlid;
3581 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
3582 attr->opa.dlid = dlid;
3583 }
3584
3585 static inline u32 rdma_ah_get_dlid(const struct rdma_ah_attr *attr)
3586 {
3587 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
3588 return attr->ib.dlid;
3589 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
3590 return attr->opa.dlid;
3591 return 0;
3592 }
3593
3594 static inline void rdma_ah_set_sl(struct rdma_ah_attr *attr, u8 sl)
3595 {
3596 attr->sl = sl;
3597 }
3598
3599 static inline u8 rdma_ah_get_sl(const struct rdma_ah_attr *attr)
3600 {
3601 return attr->sl;
3602 }
3603
3604 static inline void rdma_ah_set_path_bits(struct rdma_ah_attr *attr,
3605 u8 src_path_bits)
3606 {
3607 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
3608 attr->ib.src_path_bits = src_path_bits;
3609 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
3610 attr->opa.src_path_bits = src_path_bits;
3611 }
3612
3613 static inline u8 rdma_ah_get_path_bits(const struct rdma_ah_attr *attr)
3614 {
3615 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
3616 return attr->ib.src_path_bits;
3617 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
3618 return attr->opa.src_path_bits;
3619 return 0;
3620 }
3621
3622 static inline void rdma_ah_set_port_num(struct rdma_ah_attr *attr, u8 port_num)
3623 {
3624 attr->port_num = port_num;
3625 }
3626
3627 static inline u8 rdma_ah_get_port_num(const struct rdma_ah_attr *attr)
3628 {
3629 return attr->port_num;
3630 }
3631
3632 static inline void rdma_ah_set_static_rate(struct rdma_ah_attr *attr,
3633 u8 static_rate)
3634 {
3635 attr->static_rate = static_rate;
3636 }
3637
3638 static inline u8 rdma_ah_get_static_rate(const struct rdma_ah_attr *attr)
3639 {
3640 return attr->static_rate;
3641 }
3642
3643 static inline void rdma_ah_set_ah_flags(struct rdma_ah_attr *attr,
3644 enum ib_ah_flags flag)
3645 {
3646 attr->ah_flags = flag;
3647 }
3648
3649 static inline enum ib_ah_flags
3650 rdma_ah_get_ah_flags(const struct rdma_ah_attr *attr)
3651 {
3652 return attr->ah_flags;
3653 }
3654
3655 static inline const struct ib_global_route
3656 *rdma_ah_read_grh(const struct rdma_ah_attr *attr)
3657 {
3658 return &attr->grh;
3659 }
3660
3661 /*To retrieve and modify the grh */
3662 static inline struct ib_global_route
3663 *rdma_ah_retrieve_grh(struct rdma_ah_attr *attr)
3664 {
3665 return &attr->grh;
3666 }
3667
3668 static inline void rdma_ah_set_dgid_raw(struct rdma_ah_attr *attr, void *dgid)
3669 {
3670 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
3671
3672 memcpy(grh->dgid.raw, dgid, sizeof(grh->dgid));
3673 }
3674
3675 static inline void rdma_ah_set_subnet_prefix(struct rdma_ah_attr *attr,
3676 __be64 prefix)
3677 {
3678 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
3679
3680 grh->dgid.global.subnet_prefix = prefix;
3681 }
3682
3683 static inline void rdma_ah_set_interface_id(struct rdma_ah_attr *attr,
3684 __be64 if_id)
3685 {
3686 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
3687
3688 grh->dgid.global.interface_id = if_id;
3689 }
3690
3691 static inline void rdma_ah_set_grh(struct rdma_ah_attr *attr,
3692 union ib_gid *dgid, u32 flow_label,
3693 u8 sgid_index, u8 hop_limit,
3694 u8 traffic_class)
3695 {
3696 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
3697
3698 attr->ah_flags = IB_AH_GRH;
3699 if (dgid)
3700 grh->dgid = *dgid;
3701 grh->flow_label = flow_label;
3702 grh->sgid_index = sgid_index;
3703 grh->hop_limit = hop_limit;
3704 grh->traffic_class = traffic_class;
3705 }
3706
3707 /*Get AH type */
3708 static inline enum rdma_ah_attr_type rdma_ah_find_type(struct ib_device *dev,
3709 u32 port_num)
3710 {
3711 if ((rdma_protocol_roce(dev, port_num)) ||
3712 (rdma_protocol_iwarp(dev, port_num)))
3713 return RDMA_AH_ATTR_TYPE_ROCE;
3714 else if ((rdma_protocol_ib(dev, port_num)) &&
3715 (rdma_cap_opa_ah(dev, port_num)))
3716 return RDMA_AH_ATTR_TYPE_OPA;
3717 else
3718 return RDMA_AH_ATTR_TYPE_IB;
3719 }
3720 #endif /* IB_VERBS_H */
ubuntu-bionic-kernel mirror