blob: 9dc4e7e0aba4e8d686a74272200352902f83a23e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
Roland Dreier2a1d9b72005-08-10 23:03:10 -07007 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
Roland Dreierf7c6a7b2007-03-04 16:15:11 -08008 * Copyright (c) 2005, 2006, 2007 Cisco Systems. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 */
38
39#if !defined(IB_VERBS_H)
40#define IB_VERBS_H
41
42#include <linux/types.h>
43#include <linux/device.h>
Ralph Campbell9b513092006-12-12 14:27:41 -080044#include <linux/mm.h>
45#include <linux/dma-mapping.h>
Michael S. Tsirkin459d6e22007-02-04 14:11:55 -080046#include <linux/kref.h>
Dotan Barakbfb3ea12007-07-31 16:49:15 +030047#include <linux/list.h>
48#include <linux/rwsem.h>
Adrian Bunk87ae9af2007-10-30 10:35:04 +010049#include <linux/scatterlist.h>
Tejun Heof0626712010-10-19 15:24:36 +000050#include <linux/workqueue.h>
Yotam Kenneth9268f722015-07-30 17:50:15 +030051#include <linux/socket.h>
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -080052#include <linux/irq_poll.h>
Matan Barakdd5f03b2013-12-12 18:03:11 +020053#include <uapi/linux/if_ether.h>
Somnath Koturc865f242015-12-23 14:56:51 +020054#include <net/ipv6.h>
55#include <net/ip.h>
Matan Barak301a7212015-12-15 20:30:10 +020056#include <linux/string.h>
57#include <linux/slab.h>
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -070058#include <linux/netdevice.h>
Roland Dreiere2773c02005-07-07 17:57:10 -070059
Eli Cohen50174a72016-03-11 22:58:38 +020060#include <linux/if_link.h>
Arun Sharma600634972011-07-26 16:09:06 -070061#include <linux/atomic.h>
Haggai Eran882214e2014-12-11 17:04:18 +020062#include <linux/mmu_notifier.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080063#include <linux/uaccess.h>
Parav Pandit43579b52017-01-10 00:02:14 +000064#include <linux/cgroup_rdma.h>
Nicolas Dichtelea6819e2017-03-27 14:20:14 +020065#include <uapi/rdma/ib_user_verbs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Tejun Heof0626712010-10-19 15:24:36 +000067extern struct workqueue_struct *ib_wq;
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -080068extern struct workqueue_struct *ib_comp_wq;
Tejun Heof0626712010-10-19 15:24:36 +000069
Linus Torvalds1da177e2005-04-16 15:20:36 -070070union ib_gid {
71 u8 raw[16];
72 struct {
Sean Hefty97f52eb2005-08-13 21:05:57 -070073 __be64 subnet_prefix;
74 __be64 interface_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 } global;
76};
77
Moni Shouae26be1b2015-07-30 18:33:29 +030078extern union ib_gid zgid;
79
Matan Barakb39ffa12015-12-23 14:56:47 +020080enum 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,
Matan Barak7766a992015-12-23 14:56:50 +020084 IB_GID_TYPE_ROCE_UDP_ENCAP = 1,
Matan Barakb39ffa12015-12-23 14:56:47 +020085 IB_GID_TYPE_SIZE
86};
87
Moni Shoua7ead4bc2016-01-14 17:50:38 +020088#define ROCE_V2_UDP_DPORT 4791
Matan Barak03db3a22015-07-30 18:33:26 +030089struct ib_gid_attr {
Matan Barakb39ffa12015-12-23 14:56:47 +020090 enum ib_gid_type gid_type;
Matan Barak03db3a22015-07-30 18:33:26 +030091 struct net_device *ndev;
92};
93
Tom Tucker07ebafb2006-08-03 16:02:42 -050094enum 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,
Upinder Malhi \(umalhi\)180771a2013-09-10 03:36:59 +000099 RDMA_NODE_RNIC,
100 RDMA_NODE_USNIC,
Upinder Malhi5db57652014-01-15 17:02:36 -0800101 RDMA_NODE_USNIC_UDP,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102};
103
Eli Cohena0c1b2a2016-03-11 22:58:37 +0200104enum {
105 /* set the local administered indication */
106 IB_SA_WELL_KNOWN_GUID = BIT_ULL(57) | 2,
107};
108
Tom Tucker07ebafb2006-08-03 16:02:42 -0500109enum rdma_transport_type {
110 RDMA_TRANSPORT_IB,
Upinder Malhi \(umalhi\)180771a2013-09-10 03:36:59 +0000111 RDMA_TRANSPORT_IWARP,
Upinder Malhi248567f2014-01-09 14:48:19 -0800112 RDMA_TRANSPORT_USNIC,
113 RDMA_TRANSPORT_USNIC_UDP
Tom Tucker07ebafb2006-08-03 16:02:42 -0500114};
115
Michael Wang6b90a6d2015-05-05 14:50:18 +0200116enum rdma_protocol_type {
117 RDMA_PROTOCOL_IB,
118 RDMA_PROTOCOL_IBOE,
119 RDMA_PROTOCOL_IWARP,
120 RDMA_PROTOCOL_USNIC_UDP
121};
122
Roland Dreier8385fd82014-06-04 10:00:16 -0700123__attribute_const__ enum rdma_transport_type
124rdma_node_get_transport(enum rdma_node_type node_type);
Tom Tucker07ebafb2006-08-03 16:02:42 -0500125
Somnath Koturc865f242015-12-23 14:56:51 +0200126enum 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
133static 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
143static 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
Eli Cohena3f5ada2010-09-27 17:51:10 -0700155enum rdma_link_layer {
156 IB_LINK_LAYER_UNSPECIFIED,
157 IB_LINK_LAYER_INFINIBAND,
158 IB_LINK_LAYER_ETHERNET,
159};
160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161enum ib_device_cap_flags {
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200162 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),
Christoph Hellwigb1adc712015-12-23 19:12:45 +0100177
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 */
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200185 IB_DEVICE_LOCAL_DMA_LKEY = (1 << 15),
186 IB_DEVICE_RESERVED /* old SEND_W_INV */ = (1 << 16),
187 IB_DEVICE_MEM_WINDOW = (1 << 17),
Eli Cohene0605d92008-01-30 18:30:57 +0200188 /*
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 */
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200195 IB_DEVICE_UD_IP_CSUM = (1 << 18),
196 IB_DEVICE_UD_TSO = (1 << 19),
197 IB_DEVICE_XRC = (1 << 20),
Christoph Hellwigb1adc712015-12-23 19:12:45 +0100198
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 */
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200208 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),
Noa Osherovichebaaee22017-01-18 15:39:54 +0200213 /* Deprecated. Please use IB_RAW_PACKET_CAP_IP_CSUM. */
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200214 IB_DEVICE_RAW_IP_CSUM = (1 << 26),
Leon Romanovsky8a06ce52015-12-20 12:16:10 +0200215 /*
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),
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200222 IB_DEVICE_MANAGED_FLOW_STEERING = (1 << 29),
223 IB_DEVICE_SIGNATURE_HANDOVER = (1 << 30),
Max Gurtovoy47355b32016-06-06 19:34:39 +0300224 IB_DEVICE_ON_DEMAND_PAGING = (1ULL << 31),
Sagi Grimbergf5aa9152016-02-29 19:07:32 +0200225 IB_DEVICE_SG_GAPS_REG = (1ULL << 32),
Max Gurtovoyc7e162a2016-06-06 19:34:40 +0300226 IB_DEVICE_VIRTUAL_FUNCTION = (1ULL << 33),
Noa Osherovichebaaee22017-01-18 15:39:54 +0200227 /* Deprecated. Please use IB_RAW_PACKET_CAP_SCATTER_FCS. */
Max Gurtovoyc7e162a2016-06-06 19:34:40 +0300228 IB_DEVICE_RAW_SCATTER_FCS = (1ULL << 34),
Vishwanathapura, Niranjana62e45942017-04-12 20:29:21 -0700229 IB_DEVICE_RDMA_NETDEV_OPA_VNIC = (1ULL << 35),
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200230};
231
232enum 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
238enum ib_signature_guard_cap {
239 IB_GUARD_T10DIF_CRC = 1,
240 IB_GUARD_T10DIF_CSUM = 1 << 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241};
242
243enum ib_atomic_cap {
244 IB_ATOMIC_NONE,
245 IB_ATOMIC_HCA,
246 IB_ATOMIC_GLOB
247};
248
Sagi Grimberg860f10a2014-12-11 17:04:16 +0200249enum ib_odp_general_cap_bits {
Artemy Kovalyov25bf14d2017-01-18 16:58:06 +0200250 IB_ODP_SUPPORT = 1 << 0,
251 IB_ODP_SUPPORT_IMPLICIT = 1 << 1,
Sagi Grimberg860f10a2014-12-11 17:04:16 +0200252};
253
254enum 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
262struct 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
Yishai Hadasccf20562016-08-28 11:28:43 +0300271struct 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
Matan Barakb9926b922015-06-11 16:35:22 +0300281enum ib_cq_creation_flags {
282 IB_CQ_FLAGS_TIMESTAMP_COMPLETION = 1 << 0,
Leon Romanovsky8a06ce52015-12-20 12:16:10 +0200283 IB_CQ_FLAGS_IGNORE_OVERRUN = 1 << 1,
Matan Barakb9926b922015-06-11 16:35:22 +0300284};
285
Matan Barakbcf4c1e2015-06-11 16:35:20 +0300286struct ib_cq_init_attr {
287 unsigned int cqe;
288 int comp_vector;
289 u32 flags;
290};
291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292struct ib_device_attr {
293 u64 fw_ver;
Sean Hefty97f52eb2005-08-13 21:05:57 -0700294 __be64 sys_image_guid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 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;
Leon Romanovskyfb532d62016-02-23 10:25:25 +0200302 u64 device_cap_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 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;
Vladimir Sokolovsky5e80ba82010-04-14 17:23:01 +0300315 enum ib_atomic_cap masked_atomic_cap;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 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;
Steve Wise00f7ec32008-07-14 23:48:45 -0700330 unsigned int max_fast_reg_page_list_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 u16 max_pkeys;
332 u8 local_ca_ack_delay;
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200333 int sig_prot_cap;
334 int sig_guard_cap;
Sagi Grimberg860f10a2014-12-11 17:04:16 +0200335 struct ib_odp_caps odp_caps;
Matan Barak24306dc2015-06-11 16:35:24 +0300336 uint64_t timestamp_mask;
337 uint64_t hca_core_clock; /* in KHZ */
Yishai Hadasccf20562016-08-28 11:28:43 +0300338 struct ib_rss_caps rss_caps;
339 u32 max_wq_type_rq;
Noa Osherovichebaaee22017-01-18 15:39:54 +0200340 u32 raw_packet_caps; /* Use ib_raw_packet_caps enum */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341};
342
343enum 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
351static 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
Amrani, Ramd3f4aad2016-12-26 08:40:57 +0200363static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377enum 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
386enum 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,
Marcel Apfelbaum71eeba12011-10-05 14:21:47 +0300399 IB_PORT_EXTENDED_SPEEDS_SUP = 1 << 14,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 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,
Moni Shouab4a26a22014-02-09 11:54:34 +0200409 IB_PORT_CLIENT_REG_SUP = 1 << 25,
Matan Barak03db3a22015-07-30 18:33:26 +0300410 IB_PORT_IP_BASED_GIDS = 1 << 26,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411};
412
413enum 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
420static 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
Or Gerlitz2e966912012-02-28 18:49:50 +0200431enum 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,
Noa Osherovich12113a32017-04-20 20:53:31 +0300437 IB_SPEED_EDR = 32,
438 IB_SPEED_HDR = 64
Or Gerlitz2e966912012-02-28 18:49:50 +0200439};
440
Christoph Lameterb40f4752016-05-16 12:49:33 -0500441/**
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 */
457struct rdma_hw_stats {
458 unsigned long timestamp;
459 unsigned long lifespan;
460 const char * const *names;
461 int num_counters;
462 u64 value[];
Steve Wise7f624d02008-07-14 23:48:48 -0700463};
464
Christoph Lameterb40f4752016-05-16 12:49:33 -0500465#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 */
473static 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;
Steve Wise7f624d02008-07-14 23:48:48 -0700478
Christoph Lameterb40f4752016-05-16 12:49:33 -0500479 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);
Steve Wise7f624d02008-07-14 23:48:48 -0700486
Christoph Lameterb40f4752016-05-16 12:49:33 -0500487 return stats;
488}
489
Steve Wise7f624d02008-07-14 23:48:48 -0700490
Ira Weinyf9b22e32015-05-13 20:02:59 -0400491/* 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
Ira Weiny65995fe2015-06-06 14:38:32 -0400500#define RDMA_CORE_CAP_OPA_MAD 0x00000020
Ira Weinyf9b22e32015-05-13 20:02:59 -0400501
502/* Address format 0x000FF000 */
503#define RDMA_CORE_CAP_AF_IB 0x00001000
504#define RDMA_CORE_CAP_ETH_AH 0x00002000
Dasaratharaman Chandramouli94d595c2017-03-20 19:38:09 -0400505#define RDMA_CORE_CAP_OPA_AH 0x00004000
Ira Weinyf9b22e32015-05-13 20:02:59 -0400506
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
Matan Barak7766a992015-12-23 14:56:50 +0200511#define RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP 0x00800000
Or Gerlitzaa773bd2017-01-24 13:02:35 +0200512#define RDMA_CORE_CAP_PROT_RAW_PACKET 0x01000000
Or Gerlitzce1e0552017-01-24 13:02:38 +0200513#define RDMA_CORE_CAP_PROT_USNIC 0x02000000
Ira Weinyf9b22e32015-05-13 20:02:59 -0400514
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 \
Ira Weinyf9b22e32015-05-13 20:02:59 -0400524 | RDMA_CORE_CAP_AF_IB \
525 | RDMA_CORE_CAP_ETH_AH)
Matan Barak7766a992015-12-23 14:56:50 +0200526#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)
Ira Weinyf9b22e32015-05-13 20:02:59 -0400532#define RDMA_CORE_PORT_IWARP (RDMA_CORE_CAP_PROT_IWARP \
533 | RDMA_CORE_CAP_IW_CM)
Ira Weiny65995fe2015-06-06 14:38:32 -0400534#define RDMA_CORE_PORT_INTEL_OPA (RDMA_CORE_PORT_IBA_IB \
535 | RDMA_CORE_CAP_OPA_MAD)
Ira Weinyf9b22e32015-05-13 20:02:59 -0400536
Or Gerlitzaa773bd2017-01-24 13:02:35 +0200537#define RDMA_CORE_PORT_RAW_PACKET (RDMA_CORE_CAP_PROT_RAW_PACKET)
538
Or Gerlitzce1e0552017-01-24 13:02:38 +0200539#define RDMA_CORE_PORT_USNIC (RDMA_CORE_CAP_PROT_USNIC)
540
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541struct ib_port_attr {
Eli Cohenfad61ad2016-03-11 22:58:36 +0200542 u64 subnet_prefix;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 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;
Eli Cohena0c1b2a2016-03-11 22:58:37 +0200562 bool grh_required;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563};
564
565enum ib_device_modify_flags {
Roland Dreierc5bcbbb2006-02-02 09:47:14 -0800566 IB_DEVICE_MODIFY_SYS_IMAGE_GUID = 1 << 0,
567 IB_DEVICE_MODIFY_NODE_DESC = 1 << 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568};
569
Yuval Shaiabd99fde2016-08-25 10:57:07 -0700570#define IB_DEVICE_NODE_DESC_MAX 64
571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572struct ib_device_modify {
573 u64 sys_image_guid;
Yuval Shaiabd99fde2016-08-25 10:57:07 -0700574 char node_desc[IB_DEVICE_NODE_DESC_MAX];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575};
576
577enum 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};
582
583struct ib_port_modify {
584 u32 set_port_cap_mask;
585 u32 clr_port_cap_mask;
586 u8 init_type;
587};
588
589enum ib_event_type {
590 IB_EVENT_CQ_ERR,
591 IB_EVENT_QP_FATAL,
592 IB_EVENT_QP_REQ_ERR,
593 IB_EVENT_QP_ACCESS_ERR,
594 IB_EVENT_COMM_EST,
595 IB_EVENT_SQ_DRAINED,
596 IB_EVENT_PATH_MIG,
597 IB_EVENT_PATH_MIG_ERR,
598 IB_EVENT_DEVICE_FATAL,
599 IB_EVENT_PORT_ACTIVE,
600 IB_EVENT_PORT_ERR,
601 IB_EVENT_LID_CHANGE,
602 IB_EVENT_PKEY_CHANGE,
Roland Dreierd41fcc62005-08-18 12:23:08 -0700603 IB_EVENT_SM_CHANGE,
604 IB_EVENT_SRQ_ERR,
605 IB_EVENT_SRQ_LIMIT_REACHED,
Leonid Arsh63942c92006-06-17 20:37:35 -0700606 IB_EVENT_QP_LAST_WQE_REACHED,
Or Gerlitz761d90e2011-06-15 14:39:29 +0000607 IB_EVENT_CLIENT_REREGISTER,
608 IB_EVENT_GID_CHANGE,
Yishai Hadasf213c052016-05-23 15:20:49 +0300609 IB_EVENT_WQ_FATAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610};
611
Bart Van Asschedb7489e2015-08-03 10:01:52 -0700612const char *__attribute_const__ ib_event_msg(enum ib_event_type event);
Sagi Grimberg2b1b5b62015-05-18 13:40:28 +0300613
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614struct ib_event {
615 struct ib_device *device;
616 union {
617 struct ib_cq *cq;
618 struct ib_qp *qp;
Roland Dreierd41fcc62005-08-18 12:23:08 -0700619 struct ib_srq *srq;
Yishai Hadasf213c052016-05-23 15:20:49 +0300620 struct ib_wq *wq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 u8 port_num;
622 } element;
623 enum ib_event_type event;
624};
625
626struct ib_event_handler {
627 struct ib_device *device;
628 void (*handler)(struct ib_event_handler *, struct ib_event *);
629 struct list_head list;
630};
631
632#define INIT_IB_EVENT_HANDLER(_ptr, _device, _handler) \
633 do { \
634 (_ptr)->device = _device; \
635 (_ptr)->handler = _handler; \
636 INIT_LIST_HEAD(&(_ptr)->list); \
637 } while (0)
638
639struct ib_global_route {
640 union ib_gid dgid;
641 u32 flow_label;
642 u8 sgid_index;
643 u8 hop_limit;
644 u8 traffic_class;
645};
646
Hal Rosenstock513789e2005-07-27 11:45:34 -0700647struct ib_grh {
Sean Hefty97f52eb2005-08-13 21:05:57 -0700648 __be32 version_tclass_flow;
649 __be16 paylen;
Hal Rosenstock513789e2005-07-27 11:45:34 -0700650 u8 next_hdr;
651 u8 hop_limit;
652 union ib_gid sgid;
653 union ib_gid dgid;
654};
655
Somnath Koturc865f242015-12-23 14:56:51 +0200656union rdma_network_hdr {
657 struct ib_grh ibgrh;
658 struct {
659 /* The IB spec states that if it's IPv4, the header
660 * is located in the last 20 bytes of the header.
661 */
662 u8 reserved[20];
663 struct iphdr roce4grh;
664 };
665};
666
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667enum {
668 IB_MULTICAST_QPN = 0xffffff
669};
670
Harvey Harrisonf3a7c662009-02-14 22:58:35 -0800671#define IB_LID_PERMISSIVE cpu_to_be16(0xFFFF)
Dennis Dalessandrob4e64392016-01-06 10:04:31 -0800672#define IB_MULTICAST_LID_BASE cpu_to_be16(0xC000)
Sean Hefty97f52eb2005-08-13 21:05:57 -0700673
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674enum ib_ah_flags {
675 IB_AH_GRH = 1
676};
677
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700678enum ib_rate {
679 IB_RATE_PORT_CURRENT = 0,
680 IB_RATE_2_5_GBPS = 2,
681 IB_RATE_5_GBPS = 5,
682 IB_RATE_10_GBPS = 3,
683 IB_RATE_20_GBPS = 6,
684 IB_RATE_30_GBPS = 4,
685 IB_RATE_40_GBPS = 7,
686 IB_RATE_60_GBPS = 8,
687 IB_RATE_80_GBPS = 9,
Marcel Apfelbaum71eeba12011-10-05 14:21:47 +0300688 IB_RATE_120_GBPS = 10,
689 IB_RATE_14_GBPS = 11,
690 IB_RATE_56_GBPS = 12,
691 IB_RATE_112_GBPS = 13,
692 IB_RATE_168_GBPS = 14,
693 IB_RATE_25_GBPS = 15,
694 IB_RATE_100_GBPS = 16,
695 IB_RATE_200_GBPS = 17,
696 IB_RATE_300_GBPS = 18
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700697};
698
699/**
700 * ib_rate_to_mult - Convert the IB rate enum to a multiple of the
701 * base rate of 2.5 Gbit/sec. For example, IB_RATE_5_GBPS will be
702 * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.
703 * @rate: rate to convert.
704 */
Roland Dreier8385fd82014-06-04 10:00:16 -0700705__attribute_const__ int ib_rate_to_mult(enum ib_rate rate);
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700706
707/**
Marcel Apfelbaum71eeba12011-10-05 14:21:47 +0300708 * ib_rate_to_mbps - Convert the IB rate enum to Mbps.
709 * For example, IB_RATE_2_5_GBPS will be converted to 2500.
710 * @rate: rate to convert.
711 */
Roland Dreier8385fd82014-06-04 10:00:16 -0700712__attribute_const__ int ib_rate_to_mbps(enum ib_rate rate);
Marcel Apfelbaum71eeba12011-10-05 14:21:47 +0300713
Sagi Grimberg17cd3a22014-02-23 14:19:04 +0200714
715/**
Sagi Grimberg9bee1782015-07-30 10:32:35 +0300716 * enum ib_mr_type - memory region type
717 * @IB_MR_TYPE_MEM_REG: memory region that is used for
718 * normal registration
719 * @IB_MR_TYPE_SIGNATURE: memory region that is used for
720 * signature operations (data-integrity
721 * capable regions)
Sagi Grimbergf5aa9152016-02-29 19:07:32 +0200722 * @IB_MR_TYPE_SG_GAPS: memory region that is capable to
723 * register any arbitrary sg lists (without
724 * the normal mr constraints - see
725 * ib_map_mr_sg)
Sagi Grimberg17cd3a22014-02-23 14:19:04 +0200726 */
Sagi Grimberg9bee1782015-07-30 10:32:35 +0300727enum ib_mr_type {
728 IB_MR_TYPE_MEM_REG,
729 IB_MR_TYPE_SIGNATURE,
Sagi Grimbergf5aa9152016-02-29 19:07:32 +0200730 IB_MR_TYPE_SG_GAPS,
Sagi Grimberg17cd3a22014-02-23 14:19:04 +0200731};
732
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200733/**
Sagi Grimberg78eda2b2014-08-13 19:54:35 +0300734 * Signature types
735 * IB_SIG_TYPE_NONE: Unprotected.
736 * IB_SIG_TYPE_T10_DIF: Type T10-DIF
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200737 */
Sagi Grimberg78eda2b2014-08-13 19:54:35 +0300738enum ib_signature_type {
739 IB_SIG_TYPE_NONE,
740 IB_SIG_TYPE_T10_DIF,
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200741};
742
743/**
744 * Signature T10-DIF block-guard types
745 * IB_T10DIF_CRC: Corresponds to T10-PI mandated CRC checksum rules.
746 * IB_T10DIF_CSUM: Corresponds to IP checksum rules.
747 */
748enum ib_t10_dif_bg_type {
749 IB_T10DIF_CRC,
750 IB_T10DIF_CSUM
751};
752
753/**
754 * struct ib_t10_dif_domain - Parameters specific for T10-DIF
755 * domain.
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200756 * @bg_type: T10-DIF block guard type (CRC|CSUM)
757 * @pi_interval: protection information interval.
758 * @bg: seed of guard computation.
759 * @app_tag: application tag of guard block
760 * @ref_tag: initial guard block reference tag.
Sagi Grimberg78eda2b2014-08-13 19:54:35 +0300761 * @ref_remap: Indicate wethear the reftag increments each block
762 * @app_escape: Indicate to skip block check if apptag=0xffff
763 * @ref_escape: Indicate to skip block check if reftag=0xffffffff
764 * @apptag_check_mask: check bitmask of application tag.
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200765 */
766struct ib_t10_dif_domain {
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200767 enum ib_t10_dif_bg_type bg_type;
768 u16 pi_interval;
769 u16 bg;
770 u16 app_tag;
771 u32 ref_tag;
Sagi Grimberg78eda2b2014-08-13 19:54:35 +0300772 bool ref_remap;
773 bool app_escape;
774 bool ref_escape;
775 u16 apptag_check_mask;
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200776};
777
778/**
779 * struct ib_sig_domain - Parameters for signature domain
780 * @sig_type: specific signauture type
781 * @sig: union of all signature domain attributes that may
782 * be used to set domain layout.
783 */
784struct ib_sig_domain {
785 enum ib_signature_type sig_type;
786 union {
787 struct ib_t10_dif_domain dif;
788 } sig;
789};
790
791/**
792 * struct ib_sig_attrs - Parameters for signature handover operation
793 * @check_mask: bitmask for signature byte check (8 bytes)
794 * @mem: memory domain layout desciptor.
795 * @wire: wire domain layout desciptor.
796 */
797struct ib_sig_attrs {
798 u8 check_mask;
799 struct ib_sig_domain mem;
800 struct ib_sig_domain wire;
801};
802
803enum ib_sig_err_type {
804 IB_SIG_BAD_GUARD,
805 IB_SIG_BAD_REFTAG,
806 IB_SIG_BAD_APPTAG,
807};
808
809/**
810 * struct ib_sig_err - signature error descriptor
811 */
812struct ib_sig_err {
813 enum ib_sig_err_type err_type;
814 u32 expected;
815 u32 actual;
816 u64 sig_err_offset;
817 u32 key;
818};
819
820enum ib_mr_status_check {
821 IB_MR_CHECK_SIG_STATUS = 1,
822};
823
824/**
825 * struct ib_mr_status - Memory region status container
826 *
827 * @fail_status: Bitmask of MR checks status. For each
828 * failed check a corresponding status bit is set.
829 * @sig_err: Additional info for IB_MR_CEHCK_SIG_STATUS
830 * failure.
831 */
832struct ib_mr_status {
833 u32 fail_status;
834 struct ib_sig_err sig_err;
835};
836
Marcel Apfelbaum71eeba12011-10-05 14:21:47 +0300837/**
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700838 * mult_to_ib_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate
839 * enum.
840 * @mult: multiple to convert.
841 */
Roland Dreier8385fd82014-06-04 10:00:16 -0700842__attribute_const__ enum ib_rate mult_to_ib_rate(int mult);
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700843
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -0400844enum rdma_ah_attr_type {
845 RDMA_AH_ATTR_TYPE_IB,
846 RDMA_AH_ATTR_TYPE_ROCE,
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -0400847 RDMA_AH_ATTR_TYPE_OPA,
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -0400848};
849
850struct ib_ah_attr {
851 u16 dlid;
852 u8 src_path_bits;
853};
854
855struct roce_ah_attr {
856 u8 dmac[ETH_ALEN];
857};
858
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -0400859struct opa_ah_attr {
860 u32 dlid;
861 u8 src_path_bits;
862};
863
Dasaratharaman Chandramouli90898852017-04-29 14:41:18 -0400864struct rdma_ah_attr {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 struct ib_global_route grh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 u8 sl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 u8 static_rate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 u8 port_num;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -0400869 u8 ah_flags;
870 enum rdma_ah_attr_type type;
871 union {
872 struct ib_ah_attr ib;
873 struct roce_ah_attr roce;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -0400874 struct opa_ah_attr opa;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -0400875 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876};
877
878enum ib_wc_status {
879 IB_WC_SUCCESS,
880 IB_WC_LOC_LEN_ERR,
881 IB_WC_LOC_QP_OP_ERR,
882 IB_WC_LOC_EEC_OP_ERR,
883 IB_WC_LOC_PROT_ERR,
884 IB_WC_WR_FLUSH_ERR,
885 IB_WC_MW_BIND_ERR,
886 IB_WC_BAD_RESP_ERR,
887 IB_WC_LOC_ACCESS_ERR,
888 IB_WC_REM_INV_REQ_ERR,
889 IB_WC_REM_ACCESS_ERR,
890 IB_WC_REM_OP_ERR,
891 IB_WC_RETRY_EXC_ERR,
892 IB_WC_RNR_RETRY_EXC_ERR,
893 IB_WC_LOC_RDD_VIOL_ERR,
894 IB_WC_REM_INV_RD_REQ_ERR,
895 IB_WC_REM_ABORT_ERR,
896 IB_WC_INV_EECN_ERR,
897 IB_WC_INV_EEC_STATE_ERR,
898 IB_WC_FATAL_ERR,
899 IB_WC_RESP_TIMEOUT_ERR,
900 IB_WC_GENERAL_ERR
901};
902
Bart Van Asschedb7489e2015-08-03 10:01:52 -0700903const char *__attribute_const__ ib_wc_status_msg(enum ib_wc_status status);
Sagi Grimberg2b1b5b62015-05-18 13:40:28 +0300904
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905enum ib_wc_opcode {
906 IB_WC_SEND,
907 IB_WC_RDMA_WRITE,
908 IB_WC_RDMA_READ,
909 IB_WC_COMP_SWAP,
910 IB_WC_FETCH_ADD,
Eli Cohenc93570f2008-04-16 21:09:27 -0700911 IB_WC_LSO,
Steve Wise00f7ec32008-07-14 23:48:45 -0700912 IB_WC_LOCAL_INV,
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +0300913 IB_WC_REG_MR,
Vladimir Sokolovsky5e80ba82010-04-14 17:23:01 +0300914 IB_WC_MASKED_COMP_SWAP,
915 IB_WC_MASKED_FETCH_ADD,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916/*
917 * Set value of IB_WC_RECV so consumers can test if a completion is a
918 * receive by testing (opcode & IB_WC_RECV).
919 */
920 IB_WC_RECV = 1 << 7,
921 IB_WC_RECV_RDMA_WITH_IMM
922};
923
924enum ib_wc_flags {
925 IB_WC_GRH = 1,
Steve Wise00f7ec32008-07-14 23:48:45 -0700926 IB_WC_WITH_IMM = (1<<1),
927 IB_WC_WITH_INVALIDATE = (1<<2),
Or Gerlitzd927d502012-01-11 19:03:51 +0200928 IB_WC_IP_CSUM_OK = (1<<3),
Matan Barakdd5f03b2013-12-12 18:03:11 +0200929 IB_WC_WITH_SMAC = (1<<4),
930 IB_WC_WITH_VLAN = (1<<5),
Somnath Koturc865f242015-12-23 14:56:51 +0200931 IB_WC_WITH_NETWORK_HDR_TYPE = (1<<6),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932};
933
934struct ib_wc {
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -0800935 union {
936 u64 wr_id;
937 struct ib_cqe *wr_cqe;
938 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 enum ib_wc_status status;
940 enum ib_wc_opcode opcode;
941 u32 vendor_err;
942 u32 byte_len;
Michael S. Tsirkin062dbb62006-12-31 21:09:42 +0200943 struct ib_qp *qp;
Steve Wise00f7ec32008-07-14 23:48:45 -0700944 union {
945 __be32 imm_data;
946 u32 invalidate_rkey;
947 } ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 u32 src_qp;
949 int wc_flags;
950 u16 pkey_index;
951 u16 slid;
952 u8 sl;
953 u8 dlid_path_bits;
954 u8 port_num; /* valid only for DR SMPs on switches */
Matan Barakdd5f03b2013-12-12 18:03:11 +0200955 u8 smac[ETH_ALEN];
956 u16 vlan_id;
Somnath Koturc865f242015-12-23 14:56:51 +0200957 u8 network_hdr_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958};
959
Roland Dreiered23a722007-05-06 21:02:48 -0700960enum ib_cq_notify_flags {
961 IB_CQ_SOLICITED = 1 << 0,
962 IB_CQ_NEXT_COMP = 1 << 1,
963 IB_CQ_SOLICITED_MASK = IB_CQ_SOLICITED | IB_CQ_NEXT_COMP,
964 IB_CQ_REPORT_MISSED_EVENTS = 1 << 2,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965};
966
Sean Hefty96104ed2011-05-23 16:31:36 -0700967enum ib_srq_type {
Sean Hefty418d5132011-05-23 19:42:29 -0700968 IB_SRQT_BASIC,
969 IB_SRQT_XRC
Sean Hefty96104ed2011-05-23 16:31:36 -0700970};
971
Roland Dreierd41fcc62005-08-18 12:23:08 -0700972enum ib_srq_attr_mask {
973 IB_SRQ_MAX_WR = 1 << 0,
974 IB_SRQ_LIMIT = 1 << 1,
975};
976
977struct ib_srq_attr {
978 u32 max_wr;
979 u32 max_sge;
980 u32 srq_limit;
981};
982
983struct ib_srq_init_attr {
984 void (*event_handler)(struct ib_event *, void *);
985 void *srq_context;
986 struct ib_srq_attr attr;
Sean Hefty96104ed2011-05-23 16:31:36 -0700987 enum ib_srq_type srq_type;
Sean Hefty418d5132011-05-23 19:42:29 -0700988
989 union {
990 struct {
991 struct ib_xrcd *xrcd;
992 struct ib_cq *cq;
993 } xrc;
994 } ext;
Roland Dreierd41fcc62005-08-18 12:23:08 -0700995};
996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997struct ib_qp_cap {
998 u32 max_send_wr;
999 u32 max_recv_wr;
1000 u32 max_send_sge;
1001 u32 max_recv_sge;
1002 u32 max_inline_data;
Christoph Hellwiga060b562016-05-03 18:01:09 +02001003
1004 /*
1005 * Maximum number of rdma_rw_ctx structures in flight at a time.
1006 * ib_create_qp() will calculate the right amount of neededed WRs
1007 * and MRs based on this.
1008 */
1009 u32 max_rdma_ctxs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010};
1011
1012enum ib_sig_type {
1013 IB_SIGNAL_ALL_WR,
1014 IB_SIGNAL_REQ_WR
1015};
1016
1017enum ib_qp_type {
1018 /*
1019 * IB_QPT_SMI and IB_QPT_GSI have to be the first two entries
1020 * here (and in that order) since the MAD layer uses them as
1021 * indices into a 2-entry table.
1022 */
1023 IB_QPT_SMI,
1024 IB_QPT_GSI,
1025
1026 IB_QPT_RC,
1027 IB_QPT_UC,
1028 IB_QPT_UD,
1029 IB_QPT_RAW_IPV6,
Sean Heftyb42b63c2011-05-23 19:59:25 -07001030 IB_QPT_RAW_ETHERTYPE,
Or Gerlitzc938a612012-03-01 12:17:51 +02001031 IB_QPT_RAW_PACKET = 8,
Sean Heftyb42b63c2011-05-23 19:59:25 -07001032 IB_QPT_XRC_INI = 9,
1033 IB_QPT_XRC_TGT,
Jack Morgenstein0134f162013-07-07 17:25:52 +03001034 IB_QPT_MAX,
1035 /* Reserve a range for qp types internal to the low level driver.
1036 * These qp types will not be visible at the IB core layer, so the
1037 * IB_QPT_MAX usages should not be affected in the core layer
1038 */
1039 IB_QPT_RESERVED1 = 0x1000,
1040 IB_QPT_RESERVED2,
1041 IB_QPT_RESERVED3,
1042 IB_QPT_RESERVED4,
1043 IB_QPT_RESERVED5,
1044 IB_QPT_RESERVED6,
1045 IB_QPT_RESERVED7,
1046 IB_QPT_RESERVED8,
1047 IB_QPT_RESERVED9,
1048 IB_QPT_RESERVED10,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049};
1050
Eli Cohenb846f252008-04-16 21:09:27 -07001051enum ib_qp_create_flags {
Ron Livne47ee1b92008-07-14 23:48:48 -07001052 IB_QP_CREATE_IPOIB_UD_LSO = 1 << 0,
1053 IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK = 1 << 1,
Leon Romanovsky8a06ce52015-12-20 12:16:10 +02001054 IB_QP_CREATE_CROSS_CHANNEL = 1 << 2,
1055 IB_QP_CREATE_MANAGED_SEND = 1 << 3,
1056 IB_QP_CREATE_MANAGED_RECV = 1 << 4,
Matan Barak90f1d1b2013-11-07 15:25:12 +02001057 IB_QP_CREATE_NETIF_QP = 1 << 5,
Sagi Grimberg1b01d332014-02-23 14:19:05 +02001058 IB_QP_CREATE_SIGNATURE_EN = 1 << 6,
Or Gerlitz09b93082014-05-11 15:15:11 +03001059 IB_QP_CREATE_USE_GFP_NOIO = 1 << 7,
Majd Dibbinyb531b902016-04-17 17:19:36 +03001060 IB_QP_CREATE_SCATTER_FCS = 1 << 8,
Noa Osherovich9c2b2702017-01-18 15:39:56 +02001061 IB_QP_CREATE_CVLAN_STRIPPING = 1 << 9,
Jack Morgensteind2b57062012-08-03 08:40:37 +00001062 /* reserve bits 26-31 for low level drivers' internal use */
1063 IB_QP_CREATE_RESERVED_START = 1 << 26,
1064 IB_QP_CREATE_RESERVED_END = 1 << 31,
Eli Cohenb846f252008-04-16 21:09:27 -07001065};
1066
Yishai Hadas73c40c62013-08-01 18:49:53 +03001067/*
1068 * Note: users may not call ib_close_qp or ib_destroy_qp from the event_handler
1069 * callback to destroy the passed in QP.
1070 */
1071
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072struct ib_qp_init_attr {
1073 void (*event_handler)(struct ib_event *, void *);
1074 void *qp_context;
1075 struct ib_cq *send_cq;
1076 struct ib_cq *recv_cq;
1077 struct ib_srq *srq;
Sean Heftyb42b63c2011-05-23 19:59:25 -07001078 struct ib_xrcd *xrcd; /* XRC TGT QPs only */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 struct ib_qp_cap cap;
1080 enum ib_sig_type sq_sig_type;
1081 enum ib_qp_type qp_type;
Eli Cohenb846f252008-04-16 21:09:27 -07001082 enum ib_qp_create_flags create_flags;
Christoph Hellwiga060b562016-05-03 18:01:09 +02001083
1084 /*
1085 * Only needed for special QP types, or when using the RW API.
1086 */
1087 u8 port_num;
Yishai Hadasa9017e22016-05-23 15:20:54 +03001088 struct ib_rwq_ind_table *rwq_ind_tbl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089};
1090
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07001091struct ib_qp_open_attr {
1092 void (*event_handler)(struct ib_event *, void *);
1093 void *qp_context;
1094 u32 qp_num;
1095 enum ib_qp_type qp_type;
1096};
1097
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098enum ib_rnr_timeout {
1099 IB_RNR_TIMER_655_36 = 0,
1100 IB_RNR_TIMER_000_01 = 1,
1101 IB_RNR_TIMER_000_02 = 2,
1102 IB_RNR_TIMER_000_03 = 3,
1103 IB_RNR_TIMER_000_04 = 4,
1104 IB_RNR_TIMER_000_06 = 5,
1105 IB_RNR_TIMER_000_08 = 6,
1106 IB_RNR_TIMER_000_12 = 7,
1107 IB_RNR_TIMER_000_16 = 8,
1108 IB_RNR_TIMER_000_24 = 9,
1109 IB_RNR_TIMER_000_32 = 10,
1110 IB_RNR_TIMER_000_48 = 11,
1111 IB_RNR_TIMER_000_64 = 12,
1112 IB_RNR_TIMER_000_96 = 13,
1113 IB_RNR_TIMER_001_28 = 14,
1114 IB_RNR_TIMER_001_92 = 15,
1115 IB_RNR_TIMER_002_56 = 16,
1116 IB_RNR_TIMER_003_84 = 17,
1117 IB_RNR_TIMER_005_12 = 18,
1118 IB_RNR_TIMER_007_68 = 19,
1119 IB_RNR_TIMER_010_24 = 20,
1120 IB_RNR_TIMER_015_36 = 21,
1121 IB_RNR_TIMER_020_48 = 22,
1122 IB_RNR_TIMER_030_72 = 23,
1123 IB_RNR_TIMER_040_96 = 24,
1124 IB_RNR_TIMER_061_44 = 25,
1125 IB_RNR_TIMER_081_92 = 26,
1126 IB_RNR_TIMER_122_88 = 27,
1127 IB_RNR_TIMER_163_84 = 28,
1128 IB_RNR_TIMER_245_76 = 29,
1129 IB_RNR_TIMER_327_68 = 30,
1130 IB_RNR_TIMER_491_52 = 31
1131};
1132
1133enum ib_qp_attr_mask {
1134 IB_QP_STATE = 1,
1135 IB_QP_CUR_STATE = (1<<1),
1136 IB_QP_EN_SQD_ASYNC_NOTIFY = (1<<2),
1137 IB_QP_ACCESS_FLAGS = (1<<3),
1138 IB_QP_PKEY_INDEX = (1<<4),
1139 IB_QP_PORT = (1<<5),
1140 IB_QP_QKEY = (1<<6),
1141 IB_QP_AV = (1<<7),
1142 IB_QP_PATH_MTU = (1<<8),
1143 IB_QP_TIMEOUT = (1<<9),
1144 IB_QP_RETRY_CNT = (1<<10),
1145 IB_QP_RNR_RETRY = (1<<11),
1146 IB_QP_RQ_PSN = (1<<12),
1147 IB_QP_MAX_QP_RD_ATOMIC = (1<<13),
1148 IB_QP_ALT_PATH = (1<<14),
1149 IB_QP_MIN_RNR_TIMER = (1<<15),
1150 IB_QP_SQ_PSN = (1<<16),
1151 IB_QP_MAX_DEST_RD_ATOMIC = (1<<17),
1152 IB_QP_PATH_MIG_STATE = (1<<18),
1153 IB_QP_CAP = (1<<19),
Matan Barakdd5f03b2013-12-12 18:03:11 +02001154 IB_QP_DEST_QPN = (1<<20),
Matan Barakaa744cc2015-10-15 18:38:53 +03001155 IB_QP_RESERVED1 = (1<<21),
1156 IB_QP_RESERVED2 = (1<<22),
1157 IB_QP_RESERVED3 = (1<<23),
1158 IB_QP_RESERVED4 = (1<<24),
Bodong Wang528e5a12016-12-01 13:43:14 +02001159 IB_QP_RATE_LIMIT = (1<<25),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160};
1161
1162enum ib_qp_state {
1163 IB_QPS_RESET,
1164 IB_QPS_INIT,
1165 IB_QPS_RTR,
1166 IB_QPS_RTS,
1167 IB_QPS_SQD,
1168 IB_QPS_SQE,
1169 IB_QPS_ERR
1170};
1171
1172enum ib_mig_state {
1173 IB_MIG_MIGRATED,
1174 IB_MIG_REARM,
1175 IB_MIG_ARMED
1176};
1177
Shani Michaeli7083e422013-02-06 16:19:12 +00001178enum ib_mw_type {
1179 IB_MW_TYPE_1 = 1,
1180 IB_MW_TYPE_2 = 2
1181};
1182
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183struct ib_qp_attr {
1184 enum ib_qp_state qp_state;
1185 enum ib_qp_state cur_qp_state;
1186 enum ib_mtu path_mtu;
1187 enum ib_mig_state path_mig_state;
1188 u32 qkey;
1189 u32 rq_psn;
1190 u32 sq_psn;
1191 u32 dest_qp_num;
1192 int qp_access_flags;
1193 struct ib_qp_cap cap;
Dasaratharaman Chandramouli90898852017-04-29 14:41:18 -04001194 struct rdma_ah_attr ah_attr;
1195 struct rdma_ah_attr alt_ah_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 u16 pkey_index;
1197 u16 alt_pkey_index;
1198 u8 en_sqd_async_notify;
1199 u8 sq_draining;
1200 u8 max_rd_atomic;
1201 u8 max_dest_rd_atomic;
1202 u8 min_rnr_timer;
1203 u8 port_num;
1204 u8 timeout;
1205 u8 retry_cnt;
1206 u8 rnr_retry;
1207 u8 alt_port_num;
1208 u8 alt_timeout;
Bodong Wang528e5a12016-12-01 13:43:14 +02001209 u32 rate_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210};
1211
1212enum ib_wr_opcode {
1213 IB_WR_RDMA_WRITE,
1214 IB_WR_RDMA_WRITE_WITH_IMM,
1215 IB_WR_SEND,
1216 IB_WR_SEND_WITH_IMM,
1217 IB_WR_RDMA_READ,
1218 IB_WR_ATOMIC_CMP_AND_SWP,
Eli Cohenc93570f2008-04-16 21:09:27 -07001219 IB_WR_ATOMIC_FETCH_AND_ADD,
Roland Dreier0f39cf32008-04-16 21:09:32 -07001220 IB_WR_LSO,
1221 IB_WR_SEND_WITH_INV,
Steve Wise00f7ec32008-07-14 23:48:45 -07001222 IB_WR_RDMA_READ_WITH_INV,
1223 IB_WR_LOCAL_INV,
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03001224 IB_WR_REG_MR,
Vladimir Sokolovsky5e80ba82010-04-14 17:23:01 +03001225 IB_WR_MASKED_ATOMIC_CMP_AND_SWP,
1226 IB_WR_MASKED_ATOMIC_FETCH_AND_ADD,
Sagi Grimberg1b01d332014-02-23 14:19:05 +02001227 IB_WR_REG_SIG_MR,
Jack Morgenstein0134f162013-07-07 17:25:52 +03001228 /* reserve values for low level drivers' internal use.
1229 * These values will not be used at all in the ib core layer.
1230 */
1231 IB_WR_RESERVED1 = 0xf0,
1232 IB_WR_RESERVED2,
1233 IB_WR_RESERVED3,
1234 IB_WR_RESERVED4,
1235 IB_WR_RESERVED5,
1236 IB_WR_RESERVED6,
1237 IB_WR_RESERVED7,
1238 IB_WR_RESERVED8,
1239 IB_WR_RESERVED9,
1240 IB_WR_RESERVED10,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241};
1242
1243enum ib_send_flags {
1244 IB_SEND_FENCE = 1,
1245 IB_SEND_SIGNALED = (1<<1),
1246 IB_SEND_SOLICITED = (1<<2),
Eli Cohene0605d92008-01-30 18:30:57 +02001247 IB_SEND_INLINE = (1<<3),
Jack Morgenstein0134f162013-07-07 17:25:52 +03001248 IB_SEND_IP_CSUM = (1<<4),
1249
1250 /* reserve bits 26-31 for low level drivers' internal use */
1251 IB_SEND_RESERVED_START = (1 << 26),
1252 IB_SEND_RESERVED_END = (1 << 31),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253};
1254
1255struct ib_sge {
1256 u64 addr;
1257 u32 length;
1258 u32 lkey;
1259};
1260
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001261struct ib_cqe {
1262 void (*done)(struct ib_cq *cq, struct ib_wc *wc);
1263};
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265struct ib_send_wr {
1266 struct ib_send_wr *next;
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001267 union {
1268 u64 wr_id;
1269 struct ib_cqe *wr_cqe;
1270 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 struct ib_sge *sg_list;
1272 int num_sge;
1273 enum ib_wr_opcode opcode;
1274 int send_flags;
Roland Dreier0f39cf32008-04-16 21:09:32 -07001275 union {
1276 __be32 imm_data;
1277 u32 invalidate_rkey;
1278 } ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279};
1280
Christoph Hellwige622f2f2015-10-08 09:16:33 +01001281struct ib_rdma_wr {
1282 struct ib_send_wr wr;
1283 u64 remote_addr;
1284 u32 rkey;
1285};
1286
1287static inline struct ib_rdma_wr *rdma_wr(struct ib_send_wr *wr)
1288{
1289 return container_of(wr, struct ib_rdma_wr, wr);
1290}
1291
1292struct ib_atomic_wr {
1293 struct ib_send_wr wr;
1294 u64 remote_addr;
1295 u64 compare_add;
1296 u64 swap;
1297 u64 compare_add_mask;
1298 u64 swap_mask;
1299 u32 rkey;
1300};
1301
1302static inline struct ib_atomic_wr *atomic_wr(struct ib_send_wr *wr)
1303{
1304 return container_of(wr, struct ib_atomic_wr, wr);
1305}
1306
1307struct ib_ud_wr {
1308 struct ib_send_wr wr;
1309 struct ib_ah *ah;
1310 void *header;
1311 int hlen;
1312 int mss;
1313 u32 remote_qpn;
1314 u32 remote_qkey;
1315 u16 pkey_index; /* valid for GSI only */
1316 u8 port_num; /* valid for DR SMPs on switch only */
1317};
1318
1319static inline struct ib_ud_wr *ud_wr(struct ib_send_wr *wr)
1320{
1321 return container_of(wr, struct ib_ud_wr, wr);
1322}
1323
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03001324struct ib_reg_wr {
1325 struct ib_send_wr wr;
1326 struct ib_mr *mr;
1327 u32 key;
1328 int access;
1329};
1330
1331static inline struct ib_reg_wr *reg_wr(struct ib_send_wr *wr)
1332{
1333 return container_of(wr, struct ib_reg_wr, wr);
1334}
1335
Christoph Hellwige622f2f2015-10-08 09:16:33 +01001336struct ib_sig_handover_wr {
1337 struct ib_send_wr wr;
1338 struct ib_sig_attrs *sig_attrs;
1339 struct ib_mr *sig_mr;
1340 int access_flags;
1341 struct ib_sge *prot;
1342};
1343
1344static inline struct ib_sig_handover_wr *sig_handover_wr(struct ib_send_wr *wr)
1345{
1346 return container_of(wr, struct ib_sig_handover_wr, wr);
1347}
1348
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349struct ib_recv_wr {
1350 struct ib_recv_wr *next;
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001351 union {
1352 u64 wr_id;
1353 struct ib_cqe *wr_cqe;
1354 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 struct ib_sge *sg_list;
1356 int num_sge;
1357};
1358
1359enum ib_access_flags {
1360 IB_ACCESS_LOCAL_WRITE = 1,
1361 IB_ACCESS_REMOTE_WRITE = (1<<1),
1362 IB_ACCESS_REMOTE_READ = (1<<2),
1363 IB_ACCESS_REMOTE_ATOMIC = (1<<3),
Shani Michaeli7083e422013-02-06 16:19:12 +00001364 IB_ACCESS_MW_BIND = (1<<4),
Sagi Grimberg860f10a2014-12-11 17:04:16 +02001365 IB_ZERO_BASED = (1<<5),
1366 IB_ACCESS_ON_DEMAND = (1<<6),
Artemy Kovalyov0008b842017-04-05 09:23:57 +03001367 IB_ACCESS_HUGETLB = (1<<7),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368};
1369
Christoph Hellwigb7d3e0a2015-12-23 19:12:47 +01001370/*
1371 * XXX: these are apparently used for ->rereg_user_mr, no idea why they
1372 * are hidden here instead of a uapi header!
1373 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374enum ib_mr_rereg_flags {
1375 IB_MR_REREG_TRANS = 1,
1376 IB_MR_REREG_PD = (1<<1),
Matan Barak7e6edb92014-07-31 11:01:28 +03001377 IB_MR_REREG_ACCESS = (1<<2),
1378 IB_MR_REREG_SUPPORTED = ((IB_MR_REREG_ACCESS << 1) - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379};
1380
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381struct ib_fmr_attr {
1382 int max_pages;
1383 int max_maps;
Or Gerlitzd36f34a2006-02-02 10:43:45 -08001384 u8 page_shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385};
1386
Haggai Eran882214e2014-12-11 17:04:18 +02001387struct ib_umem;
1388
Matan Barak38321252017-04-04 13:31:42 +03001389enum rdma_remove_reason {
1390 /* Userspace requested uobject deletion. Call could fail */
1391 RDMA_REMOVE_DESTROY,
1392 /* Context deletion. This call should delete the actual object itself */
1393 RDMA_REMOVE_CLOSE,
1394 /* Driver is being hot-unplugged. This call should delete the actual object itself */
1395 RDMA_REMOVE_DRIVER_REMOVE,
1396 /* Context is being cleaned-up, but commit was just completed */
1397 RDMA_REMOVE_DURING_CLEANUP,
1398};
1399
Parav Pandit43579b52017-01-10 00:02:14 +00001400struct ib_rdmacg_object {
1401#ifdef CONFIG_CGROUP_RDMA
1402 struct rdma_cgroup *cg; /* owner rdma cgroup */
1403#endif
1404};
1405
Roland Dreiere2773c02005-07-07 17:57:10 -07001406struct ib_ucontext {
1407 struct ib_device *device;
Matan Barak771addf2017-04-04 13:31:41 +03001408 struct ib_uverbs_file *ufile;
Roland Dreierf7c6a7b2007-03-04 16:15:11 -08001409 int closing;
Shachar Raindel8ada2c12014-12-11 17:04:17 +02001410
Matan Barak38321252017-04-04 13:31:42 +03001411 /* locking the uobjects_list */
1412 struct mutex uobjects_lock;
1413 struct list_head uobjects;
1414 /* protects cleanup process from other actions */
1415 struct rw_semaphore cleanup_rwsem;
1416 enum rdma_remove_reason cleanup_reason;
1417
Shachar Raindel8ada2c12014-12-11 17:04:17 +02001418 struct pid *tgid;
Haggai Eran882214e2014-12-11 17:04:18 +02001419#ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
1420 struct rb_root umem_tree;
1421 /*
1422 * Protects .umem_rbroot and tree, as well as odp_mrs_count and
1423 * mmu notifiers registration.
1424 */
1425 struct rw_semaphore umem_rwsem;
1426 void (*invalidate_range)(struct ib_umem *umem,
1427 unsigned long start, unsigned long end);
1428
1429 struct mmu_notifier mn;
1430 atomic_t notifier_count;
1431 /* A list of umems that don't have private mmu notifier counters yet. */
1432 struct list_head no_private_counters;
1433 int odp_mrs_count;
1434#endif
Parav Pandit43579b52017-01-10 00:02:14 +00001435
1436 struct ib_rdmacg_object cg_obj;
Roland Dreiere2773c02005-07-07 17:57:10 -07001437};
1438
1439struct ib_uobject {
1440 u64 user_handle; /* handle given to us by userspace */
1441 struct ib_ucontext *context; /* associated user context */
Roland Dreier9ead1902006-06-17 20:44:49 -07001442 void *object; /* containing object */
Roland Dreiere2773c02005-07-07 17:57:10 -07001443 struct list_head list; /* link to context's list */
Parav Pandit43579b52017-01-10 00:02:14 +00001444 struct ib_rdmacg_object cg_obj; /* rdmacg object */
Roland Dreierb3d636b2008-04-16 21:01:06 -07001445 int id; /* index into kernel idr */
Roland Dreier9ead1902006-06-17 20:44:49 -07001446 struct kref ref;
Matan Barak38321252017-04-04 13:31:42 +03001447 atomic_t usecnt; /* protects exclusive access */
Mike Marciniszynd144da82015-11-02 12:13:25 -05001448 struct rcu_head rcu; /* kfree_rcu() overhead */
Matan Barak38321252017-04-04 13:31:42 +03001449
1450 const struct uverbs_obj_type *type;
Roland Dreiere2773c02005-07-07 17:57:10 -07001451};
1452
Matan Barakcf8966b2017-04-04 13:31:46 +03001453struct ib_uobject_file {
1454 struct ib_uobject uobj;
1455 /* ufile contains the lock between context release and file close */
1456 struct ib_uverbs_file *ufile;
Roland Dreiere2773c02005-07-07 17:57:10 -07001457};
1458
Roland Dreiere2773c02005-07-07 17:57:10 -07001459struct ib_udata {
Yann Droneaud309243e2013-12-11 23:01:44 +01001460 const void __user *inbuf;
Roland Dreiere2773c02005-07-07 17:57:10 -07001461 void __user *outbuf;
1462 size_t inlen;
1463 size_t outlen;
1464};
1465
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466struct ib_pd {
Jason Gunthorpe96249d72015-08-05 14:14:45 -06001467 u32 local_dma_lkey;
Christoph Hellwiged082d32016-09-05 12:56:17 +02001468 u32 flags;
Roland Dreiere2773c02005-07-07 17:57:10 -07001469 struct ib_device *device;
1470 struct ib_uobject *uobject;
1471 atomic_t usecnt; /* count all resources */
Christoph Hellwig50d46332016-09-05 12:56:16 +02001472
Christoph Hellwiged082d32016-09-05 12:56:17 +02001473 u32 unsafe_global_rkey;
1474
Christoph Hellwig50d46332016-09-05 12:56:16 +02001475 /*
1476 * Implementation details of the RDMA core, don't use in drivers:
1477 */
1478 struct ib_mr *__internal_mr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479};
1480
Sean Hefty59991f92011-05-23 17:52:46 -07001481struct ib_xrcd {
1482 struct ib_device *device;
Sean Heftyd3d72d92011-05-26 23:06:44 -07001483 atomic_t usecnt; /* count all exposed resources */
Sean Hefty53d0bd12011-05-24 08:33:46 -07001484 struct inode *inode;
Sean Heftyd3d72d92011-05-26 23:06:44 -07001485
1486 struct mutex tgt_qp_mutex;
1487 struct list_head tgt_qp_list;
Sean Hefty59991f92011-05-23 17:52:46 -07001488};
1489
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490struct ib_ah {
1491 struct ib_device *device;
1492 struct ib_pd *pd;
Roland Dreiere2773c02005-07-07 17:57:10 -07001493 struct ib_uobject *uobject;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04001494 enum rdma_ah_attr_type type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495};
1496
1497typedef void (*ib_comp_handler)(struct ib_cq *cq, void *cq_context);
1498
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001499enum ib_poll_context {
1500 IB_POLL_DIRECT, /* caller context, no hw completions */
1501 IB_POLL_SOFTIRQ, /* poll from softirq context */
1502 IB_POLL_WORKQUEUE, /* poll from workqueue */
1503};
1504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505struct ib_cq {
Roland Dreiere2773c02005-07-07 17:57:10 -07001506 struct ib_device *device;
1507 struct ib_uobject *uobject;
1508 ib_comp_handler comp_handler;
1509 void (*event_handler)(struct ib_event *, void *);
Dotan Barak4deccd62008-07-14 23:48:44 -07001510 void *cq_context;
Roland Dreiere2773c02005-07-07 17:57:10 -07001511 int cqe;
1512 atomic_t usecnt; /* count number of work queues */
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001513 enum ib_poll_context poll_ctx;
1514 struct ib_wc *wc;
1515 union {
1516 struct irq_poll iop;
1517 struct work_struct work;
1518 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519};
1520
1521struct ib_srq {
Roland Dreierd41fcc62005-08-18 12:23:08 -07001522 struct ib_device *device;
1523 struct ib_pd *pd;
1524 struct ib_uobject *uobject;
1525 void (*event_handler)(struct ib_event *, void *);
1526 void *srq_context;
Sean Hefty96104ed2011-05-23 16:31:36 -07001527 enum ib_srq_type srq_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 atomic_t usecnt;
Sean Hefty418d5132011-05-23 19:42:29 -07001529
1530 union {
1531 struct {
1532 struct ib_xrcd *xrcd;
1533 struct ib_cq *cq;
1534 u32 srq_num;
1535 } xrc;
1536 } ext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537};
1538
Noa Osherovichebaaee22017-01-18 15:39:54 +02001539enum ib_raw_packet_caps {
1540 /* Strip cvlan from incoming packet and report it in the matching work
1541 * completion is supported.
1542 */
1543 IB_RAW_PACKET_CAP_CVLAN_STRIPPING = (1 << 0),
1544 /* Scatter FCS field of an incoming packet to host memory is supported.
1545 */
1546 IB_RAW_PACKET_CAP_SCATTER_FCS = (1 << 1),
1547 /* Checksum offloads are supported (for both send and receive). */
1548 IB_RAW_PACKET_CAP_IP_CSUM = (1 << 2),
1549};
1550
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001551enum ib_wq_type {
1552 IB_WQT_RQ
1553};
1554
1555enum ib_wq_state {
1556 IB_WQS_RESET,
1557 IB_WQS_RDY,
1558 IB_WQS_ERR
1559};
1560
1561struct ib_wq {
1562 struct ib_device *device;
1563 struct ib_uobject *uobject;
1564 void *wq_context;
1565 void (*event_handler)(struct ib_event *, void *);
1566 struct ib_pd *pd;
1567 struct ib_cq *cq;
1568 u32 wq_num;
1569 enum ib_wq_state state;
1570 enum ib_wq_type wq_type;
1571 atomic_t usecnt;
1572};
1573
Noa Osherovich10bac722017-01-18 15:39:55 +02001574enum ib_wq_flags {
1575 IB_WQ_FLAGS_CVLAN_STRIPPING = 1 << 0,
Noa Osherovich27b0df12017-01-18 15:39:57 +02001576 IB_WQ_FLAGS_SCATTER_FCS = 1 << 1,
Noa Osherovich10bac722017-01-18 15:39:55 +02001577};
1578
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001579struct ib_wq_init_attr {
1580 void *wq_context;
1581 enum ib_wq_type wq_type;
1582 u32 max_wr;
1583 u32 max_sge;
1584 struct ib_cq *cq;
1585 void (*event_handler)(struct ib_event *, void *);
Noa Osherovich10bac722017-01-18 15:39:55 +02001586 u32 create_flags; /* Use enum ib_wq_flags */
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001587};
1588
1589enum ib_wq_attr_mask {
Noa Osherovich10bac722017-01-18 15:39:55 +02001590 IB_WQ_STATE = 1 << 0,
1591 IB_WQ_CUR_STATE = 1 << 1,
1592 IB_WQ_FLAGS = 1 << 2,
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001593};
1594
1595struct ib_wq_attr {
1596 enum ib_wq_state wq_state;
1597 enum ib_wq_state curr_wq_state;
Noa Osherovich10bac722017-01-18 15:39:55 +02001598 u32 flags; /* Use enum ib_wq_flags */
1599 u32 flags_mask; /* Use enum ib_wq_flags */
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001600};
1601
Yishai Hadas6d397862016-05-23 15:20:51 +03001602struct ib_rwq_ind_table {
1603 struct ib_device *device;
1604 struct ib_uobject *uobject;
1605 atomic_t usecnt;
1606 u32 ind_tbl_num;
1607 u32 log_ind_tbl_size;
1608 struct ib_wq **ind_tbl;
1609};
1610
1611struct ib_rwq_ind_table_init_attr {
1612 u32 log_ind_tbl_size;
1613 /* Each entry is a pointer to Receive Work Queue */
1614 struct ib_wq **ind_tbl;
1615};
1616
Bart Van Assche632bc3f2016-07-21 13:03:30 -07001617/*
1618 * @max_write_sge: Maximum SGE elements per RDMA WRITE request.
1619 * @max_read_sge: Maximum SGE elements per RDMA READ request.
1620 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621struct ib_qp {
1622 struct ib_device *device;
1623 struct ib_pd *pd;
1624 struct ib_cq *send_cq;
1625 struct ib_cq *recv_cq;
Christoph Hellwigfffb0382016-05-03 18:01:07 +02001626 spinlock_t mr_lock;
1627 int mrs_used;
Christoph Hellwiga060b562016-05-03 18:01:09 +02001628 struct list_head rdma_mrs;
Christoph Hellwig0e353e32016-05-03 18:01:12 +02001629 struct list_head sig_mrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 struct ib_srq *srq;
Sean Heftyb42b63c2011-05-23 19:59:25 -07001631 struct ib_xrcd *xrcd; /* XRC TGT QPs only */
Sean Heftyd3d72d92011-05-26 23:06:44 -07001632 struct list_head xrcd_list;
Christoph Hellwigfffb0382016-05-03 18:01:07 +02001633
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001634 /* count times opened, mcast attaches, flow attaches */
1635 atomic_t usecnt;
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07001636 struct list_head open_list;
1637 struct ib_qp *real_qp;
Roland Dreiere2773c02005-07-07 17:57:10 -07001638 struct ib_uobject *uobject;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 void (*event_handler)(struct ib_event *, void *);
1640 void *qp_context;
1641 u32 qp_num;
Bart Van Assche632bc3f2016-07-21 13:03:30 -07001642 u32 max_write_sge;
1643 u32 max_read_sge;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 enum ib_qp_type qp_type;
Yishai Hadasa9017e22016-05-23 15:20:54 +03001645 struct ib_rwq_ind_table *rwq_ind_tbl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646};
1647
1648struct ib_mr {
Roland Dreiere2773c02005-07-07 17:57:10 -07001649 struct ib_device *device;
1650 struct ib_pd *pd;
Roland Dreiere2773c02005-07-07 17:57:10 -07001651 u32 lkey;
1652 u32 rkey;
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03001653 u64 iova;
1654 u32 length;
1655 unsigned int page_size;
Steve Wised4a85c32016-05-03 18:01:08 +02001656 bool need_inval;
Christoph Hellwigfffb0382016-05-03 18:01:07 +02001657 union {
1658 struct ib_uobject *uobject; /* user */
1659 struct list_head qp_entry; /* FR */
1660 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661};
1662
1663struct ib_mw {
1664 struct ib_device *device;
1665 struct ib_pd *pd;
Roland Dreiere2773c02005-07-07 17:57:10 -07001666 struct ib_uobject *uobject;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 u32 rkey;
Shani Michaeli7083e422013-02-06 16:19:12 +00001668 enum ib_mw_type type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669};
1670
1671struct ib_fmr {
1672 struct ib_device *device;
1673 struct ib_pd *pd;
1674 struct list_head list;
1675 u32 lkey;
1676 u32 rkey;
1677};
1678
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001679/* Supported steering options */
1680enum ib_flow_attr_type {
1681 /* steering according to rule specifications */
1682 IB_FLOW_ATTR_NORMAL = 0x0,
1683 /* default unicast and multicast rule -
1684 * receive all Eth traffic which isn't steered to any QP
1685 */
1686 IB_FLOW_ATTR_ALL_DEFAULT = 0x1,
1687 /* default multicast rule -
1688 * receive all Eth multicast traffic which isn't steered to any QP
1689 */
1690 IB_FLOW_ATTR_MC_DEFAULT = 0x2,
1691 /* sniffer rule - receive all port traffic */
1692 IB_FLOW_ATTR_SNIFFER = 0x3
1693};
1694
1695/* Supported steering header types */
1696enum ib_flow_spec_type {
1697 /* L2 headers*/
Moses Reuben76bd23b2016-11-14 19:04:48 +02001698 IB_FLOW_SPEC_ETH = 0x20,
1699 IB_FLOW_SPEC_IB = 0x22,
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001700 /* L3 header*/
Moses Reuben76bd23b2016-11-14 19:04:48 +02001701 IB_FLOW_SPEC_IPV4 = 0x30,
1702 IB_FLOW_SPEC_IPV6 = 0x31,
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001703 /* L4 headers*/
Moses Reuben76bd23b2016-11-14 19:04:48 +02001704 IB_FLOW_SPEC_TCP = 0x40,
1705 IB_FLOW_SPEC_UDP = 0x41,
Moses Reuben0dbf3332016-11-14 19:04:47 +02001706 IB_FLOW_SPEC_VXLAN_TUNNEL = 0x50,
Moses Reubenfbf46862016-11-14 19:04:51 +02001707 IB_FLOW_SPEC_INNER = 0x100,
Moses Reuben460d0192017-01-18 14:59:48 +02001708 /* Actions */
1709 IB_FLOW_SPEC_ACTION_TAG = 0x1000,
Slava Shwartsman483a3962017-04-03 13:13:51 +03001710 IB_FLOW_SPEC_ACTION_DROP = 0x1001,
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001711};
Matan Barak240ae002013-11-07 15:25:13 +02001712#define IB_FLOW_SPEC_LAYER_MASK 0xF0
Moses Reubenfbf46862016-11-14 19:04:51 +02001713#define IB_FLOW_SPEC_SUPPORT_LAYERS 8
Matan Barak22878db2013-09-01 18:39:52 +03001714
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001715/* Flow steering rule priority is set according to it's domain.
1716 * Lower domain value means higher priority.
1717 */
1718enum ib_flow_domain {
1719 IB_FLOW_DOMAIN_USER,
1720 IB_FLOW_DOMAIN_ETHTOOL,
1721 IB_FLOW_DOMAIN_RFS,
1722 IB_FLOW_DOMAIN_NIC,
1723 IB_FLOW_DOMAIN_NUM /* Must be last */
1724};
1725
Marina Varshavera3100a72016-02-18 18:31:05 +02001726enum ib_flow_flags {
1727 IB_FLOW_ATTR_FLAGS_DONT_TRAP = 1UL << 1, /* Continue match, no steal */
1728 IB_FLOW_ATTR_FLAGS_RESERVED = 1UL << 2 /* Must be last */
1729};
1730
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001731struct ib_flow_eth_filter {
1732 u8 dst_mac[6];
1733 u8 src_mac[6];
1734 __be16 ether_type;
1735 __be16 vlan_tag;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001736 /* Must be last */
1737 u8 real_sz[0];
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001738};
1739
1740struct ib_flow_spec_eth {
Moses Reubenfbf46862016-11-14 19:04:51 +02001741 u32 type;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001742 u16 size;
1743 struct ib_flow_eth_filter val;
1744 struct ib_flow_eth_filter mask;
1745};
1746
Matan Barak240ae002013-11-07 15:25:13 +02001747struct ib_flow_ib_filter {
1748 __be16 dlid;
1749 __u8 sl;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001750 /* Must be last */
1751 u8 real_sz[0];
Matan Barak240ae002013-11-07 15:25:13 +02001752};
1753
1754struct ib_flow_spec_ib {
Moses Reubenfbf46862016-11-14 19:04:51 +02001755 u32 type;
Matan Barak240ae002013-11-07 15:25:13 +02001756 u16 size;
1757 struct ib_flow_ib_filter val;
1758 struct ib_flow_ib_filter mask;
1759};
1760
Maor Gottlieb989a3a82016-08-30 16:58:33 +03001761/* IPv4 header flags */
1762enum ib_ipv4_flags {
1763 IB_IPV4_DONT_FRAG = 0x2, /* Don't enable packet fragmentation */
1764 IB_IPV4_MORE_FRAG = 0X4 /* For All fragmented packets except the
1765 last have this flag set */
1766};
1767
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001768struct ib_flow_ipv4_filter {
1769 __be32 src_ip;
1770 __be32 dst_ip;
Maor Gottlieb989a3a82016-08-30 16:58:33 +03001771 u8 proto;
1772 u8 tos;
1773 u8 ttl;
1774 u8 flags;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001775 /* Must be last */
1776 u8 real_sz[0];
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001777};
1778
1779struct ib_flow_spec_ipv4 {
Moses Reubenfbf46862016-11-14 19:04:51 +02001780 u32 type;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001781 u16 size;
1782 struct ib_flow_ipv4_filter val;
1783 struct ib_flow_ipv4_filter mask;
1784};
1785
Maor Gottlieb4c2aae72016-06-17 15:14:50 +03001786struct ib_flow_ipv6_filter {
1787 u8 src_ip[16];
1788 u8 dst_ip[16];
Maor Gottlieba72c6a22016-08-30 16:58:34 +03001789 __be32 flow_label;
1790 u8 next_hdr;
1791 u8 traffic_class;
1792 u8 hop_limit;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001793 /* Must be last */
1794 u8 real_sz[0];
Maor Gottlieb4c2aae72016-06-17 15:14:50 +03001795};
1796
1797struct ib_flow_spec_ipv6 {
Moses Reubenfbf46862016-11-14 19:04:51 +02001798 u32 type;
Maor Gottlieb4c2aae72016-06-17 15:14:50 +03001799 u16 size;
1800 struct ib_flow_ipv6_filter val;
1801 struct ib_flow_ipv6_filter mask;
1802};
1803
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001804struct ib_flow_tcp_udp_filter {
1805 __be16 dst_port;
1806 __be16 src_port;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001807 /* Must be last */
1808 u8 real_sz[0];
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001809};
1810
1811struct ib_flow_spec_tcp_udp {
Moses Reubenfbf46862016-11-14 19:04:51 +02001812 u32 type;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001813 u16 size;
1814 struct ib_flow_tcp_udp_filter val;
1815 struct ib_flow_tcp_udp_filter mask;
1816};
1817
Moses Reuben0dbf3332016-11-14 19:04:47 +02001818struct ib_flow_tunnel_filter {
1819 __be32 tunnel_id;
1820 u8 real_sz[0];
1821};
1822
1823/* ib_flow_spec_tunnel describes the Vxlan tunnel
1824 * the tunnel_id from val has the vni value
1825 */
1826struct ib_flow_spec_tunnel {
Moses Reubenfbf46862016-11-14 19:04:51 +02001827 u32 type;
Moses Reuben0dbf3332016-11-14 19:04:47 +02001828 u16 size;
1829 struct ib_flow_tunnel_filter val;
1830 struct ib_flow_tunnel_filter mask;
1831};
1832
Moses Reuben460d0192017-01-18 14:59:48 +02001833struct ib_flow_spec_action_tag {
1834 enum ib_flow_spec_type type;
1835 u16 size;
1836 u32 tag_id;
1837};
1838
Slava Shwartsman483a3962017-04-03 13:13:51 +03001839struct ib_flow_spec_action_drop {
1840 enum ib_flow_spec_type type;
1841 u16 size;
1842};
1843
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001844union ib_flow_spec {
1845 struct {
Moses Reubenfbf46862016-11-14 19:04:51 +02001846 u32 type;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001847 u16 size;
1848 };
1849 struct ib_flow_spec_eth eth;
Matan Barak240ae002013-11-07 15:25:13 +02001850 struct ib_flow_spec_ib ib;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001851 struct ib_flow_spec_ipv4 ipv4;
1852 struct ib_flow_spec_tcp_udp tcp_udp;
Maor Gottlieb4c2aae72016-06-17 15:14:50 +03001853 struct ib_flow_spec_ipv6 ipv6;
Moses Reuben0dbf3332016-11-14 19:04:47 +02001854 struct ib_flow_spec_tunnel tunnel;
Moses Reuben460d0192017-01-18 14:59:48 +02001855 struct ib_flow_spec_action_tag flow_tag;
Slava Shwartsman483a3962017-04-03 13:13:51 +03001856 struct ib_flow_spec_action_drop drop;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001857};
1858
1859struct ib_flow_attr {
1860 enum ib_flow_attr_type type;
1861 u16 size;
1862 u16 priority;
1863 u32 flags;
1864 u8 num_of_specs;
1865 u8 port;
1866 /* Following are the optional layers according to user request
1867 * struct ib_flow_spec_xxx
1868 * struct ib_flow_spec_yyy
1869 */
1870};
1871
1872struct ib_flow {
1873 struct ib_qp *qp;
1874 struct ib_uobject *uobject;
1875};
1876
Ira Weiny4cd7c942015-06-06 14:38:31 -04001877struct ib_mad_hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878struct ib_grh;
1879
1880enum ib_process_mad_flags {
1881 IB_MAD_IGNORE_MKEY = 1,
1882 IB_MAD_IGNORE_BKEY = 2,
1883 IB_MAD_IGNORE_ALL = IB_MAD_IGNORE_MKEY | IB_MAD_IGNORE_BKEY
1884};
1885
1886enum ib_mad_result {
1887 IB_MAD_RESULT_FAILURE = 0, /* (!SUCCESS is the important flag) */
1888 IB_MAD_RESULT_SUCCESS = 1 << 0, /* MAD was successfully processed */
1889 IB_MAD_RESULT_REPLY = 1 << 1, /* Reply packet needs to be sent */
1890 IB_MAD_RESULT_CONSUMED = 1 << 2 /* Packet consumed: stop processing */
1891};
1892
Jack Wang21d64542017-01-17 10:11:12 +01001893struct ib_port_cache {
Daniel Jurgens883c71f2017-05-19 15:48:51 +03001894 u64 subnet_prefix;
Jack Wang21d64542017-01-17 10:11:12 +01001895 struct ib_pkey_cache *pkey;
1896 struct ib_gid_table *gid;
1897 u8 lmc;
1898 enum ib_port_state port_state;
1899};
1900
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901struct ib_cache {
1902 rwlock_t lock;
1903 struct ib_event_handler event_handler;
Jack Wang21d64542017-01-17 10:11:12 +01001904 struct ib_port_cache *ports;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905};
1906
Tom Tucker07ebafb2006-08-03 16:02:42 -05001907struct iw_cm_verbs;
1908
Ira Weiny77386132015-05-13 20:02:58 -04001909struct ib_port_immutable {
1910 int pkey_tbl_len;
1911 int gid_tbl_len;
Ira Weinyf9b22e32015-05-13 20:02:59 -04001912 u32 core_cap_flags;
Ira Weiny337877a2015-06-06 14:38:29 -04001913 u32 max_mad_size;
Ira Weiny77386132015-05-13 20:02:58 -04001914};
1915
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -07001916/* rdma netdev type - specifies protocol type */
1917enum rdma_netdev_t {
Niranjana Vishwanathapuraf0ad83ac2017-04-10 11:22:25 +03001918 RDMA_NETDEV_OPA_VNIC,
1919 RDMA_NETDEV_IPOIB,
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -07001920};
1921
1922/**
1923 * struct rdma_netdev - rdma netdev
1924 * For cases where netstack interfacing is required.
1925 */
1926struct rdma_netdev {
1927 void *clnt_priv;
1928 struct ib_device *hca;
1929 u8 port_num;
1930
1931 /* control functions */
1932 void (*set_id)(struct net_device *netdev, int id);
Niranjana Vishwanathapuraf0ad83ac2017-04-10 11:22:25 +03001933 /* send packet */
1934 int (*send)(struct net_device *dev, struct sk_buff *skb,
1935 struct ib_ah *address, u32 dqpn);
1936 /* multicast */
1937 int (*attach_mcast)(struct net_device *dev, struct ib_device *hca,
1938 union ib_gid *gid, u16 mlid,
1939 int set_qkey, u32 qkey);
1940 int (*detach_mcast)(struct net_device *dev, struct ib_device *hca,
1941 union ib_gid *gid, u16 mlid);
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -07001942};
1943
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944struct ib_device {
Bart Van Assche0957c292017-03-07 22:56:53 +00001945 /* Do not access @dma_device directly from ULP nor from HW drivers. */
1946 struct device *dma_device;
1947
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 char name[IB_DEVICE_NAME_MAX];
1949
1950 struct list_head event_handler_list;
1951 spinlock_t event_handler_lock;
1952
Alexander Chiang17a55f72010-02-02 19:09:16 +00001953 spinlock_t client_data_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 struct list_head core_list;
Haggai Eran7c1eb452015-07-30 17:50:14 +03001955 /* Access to the client_data_list is protected by the client_data_lock
1956 * spinlock and the lists_rwsem read-write semaphore */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 struct list_head client_data_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958
1959 struct ib_cache cache;
Ira Weiny77386132015-05-13 20:02:58 -04001960 /**
1961 * port_immutable is indexed by port number
1962 */
1963 struct ib_port_immutable *port_immutable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964
Michael S. Tsirkinf4fd0b22007-05-03 13:48:47 +03001965 int num_comp_vectors;
1966
Tom Tucker07ebafb2006-08-03 16:02:42 -05001967 struct iw_cm_verbs *iwcm;
1968
Christoph Lameterb40f4752016-05-16 12:49:33 -05001969 /**
1970 * alloc_hw_stats - Allocate a struct rdma_hw_stats and fill in the
1971 * driver initialized data. The struct is kfree()'ed by the sysfs
1972 * core when the device is removed. A lifespan of -1 in the return
1973 * struct tells the core to set a default lifespan.
1974 */
1975 struct rdma_hw_stats *(*alloc_hw_stats)(struct ib_device *device,
1976 u8 port_num);
1977 /**
1978 * get_hw_stats - Fill in the counter value(s) in the stats struct.
1979 * @index - The index in the value array we wish to have updated, or
1980 * num_counters if we want all stats updated
1981 * Return codes -
1982 * < 0 - Error, no counters updated
1983 * index - Updated the single counter pointed to by index
1984 * num_counters - Updated all counters (will reset the timestamp
1985 * and prevent further calls for lifespan milliseconds)
1986 * Drivers are allowed to update all counters in leiu of just the
1987 * one given in index at their option
1988 */
1989 int (*get_hw_stats)(struct ib_device *device,
1990 struct rdma_hw_stats *stats,
1991 u8 port, int index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 int (*query_device)(struct ib_device *device,
Matan Barak2528e332015-06-11 16:35:25 +03001993 struct ib_device_attr *device_attr,
1994 struct ib_udata *udata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 int (*query_port)(struct ib_device *device,
1996 u8 port_num,
1997 struct ib_port_attr *port_attr);
Eli Cohena3f5ada2010-09-27 17:51:10 -07001998 enum rdma_link_layer (*get_link_layer)(struct ib_device *device,
1999 u8 port_num);
Matan Barak03db3a22015-07-30 18:33:26 +03002000 /* When calling get_netdev, the HW vendor's driver should return the
2001 * net device of device @device at port @port_num or NULL if such
2002 * a net device doesn't exist. The vendor driver should call dev_hold
2003 * on this net device. The HW vendor's device driver must guarantee
2004 * that this function returns NULL before the net device reaches
2005 * NETDEV_UNREGISTER_FINAL state.
2006 */
2007 struct net_device *(*get_netdev)(struct ib_device *device,
2008 u8 port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 int (*query_gid)(struct ib_device *device,
2010 u8 port_num, int index,
2011 union ib_gid *gid);
Matan Barak03db3a22015-07-30 18:33:26 +03002012 /* When calling add_gid, the HW vendor's driver should
2013 * add the gid of device @device at gid index @index of
2014 * port @port_num to be @gid. Meta-info of that gid (for example,
2015 * the network device related to this gid is available
2016 * at @attr. @context allows the HW vendor driver to store extra
2017 * information together with a GID entry. The HW vendor may allocate
2018 * memory to contain this information and store it in @context when a
2019 * new GID entry is written to. Params are consistent until the next
2020 * call of add_gid or delete_gid. The function should return 0 on
2021 * success or error otherwise. The function could be called
2022 * concurrently for different ports. This function is only called
2023 * when roce_gid_table is used.
2024 */
2025 int (*add_gid)(struct ib_device *device,
2026 u8 port_num,
2027 unsigned int index,
2028 const union ib_gid *gid,
2029 const struct ib_gid_attr *attr,
2030 void **context);
2031 /* When calling del_gid, the HW vendor's driver should delete the
2032 * gid of device @device at gid index @index of port @port_num.
2033 * Upon the deletion of a GID entry, the HW vendor must free any
2034 * allocated memory. The caller will clear @context afterwards.
2035 * This function is only called when roce_gid_table is used.
2036 */
2037 int (*del_gid)(struct ib_device *device,
2038 u8 port_num,
2039 unsigned int index,
2040 void **context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 int (*query_pkey)(struct ib_device *device,
2042 u8 port_num, u16 index, u16 *pkey);
2043 int (*modify_device)(struct ib_device *device,
2044 int device_modify_mask,
2045 struct ib_device_modify *device_modify);
2046 int (*modify_port)(struct ib_device *device,
2047 u8 port_num, int port_modify_mask,
2048 struct ib_port_modify *port_modify);
Roland Dreiere2773c02005-07-07 17:57:10 -07002049 struct ib_ucontext * (*alloc_ucontext)(struct ib_device *device,
2050 struct ib_udata *udata);
2051 int (*dealloc_ucontext)(struct ib_ucontext *context);
2052 int (*mmap)(struct ib_ucontext *context,
2053 struct vm_area_struct *vma);
2054 struct ib_pd * (*alloc_pd)(struct ib_device *device,
2055 struct ib_ucontext *context,
2056 struct ib_udata *udata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 int (*dealloc_pd)(struct ib_pd *pd);
2058 struct ib_ah * (*create_ah)(struct ib_pd *pd,
Dasaratharaman Chandramouli90898852017-04-29 14:41:18 -04002059 struct rdma_ah_attr *ah_attr,
Moni Shoua477864c2016-11-23 08:23:24 +02002060 struct ib_udata *udata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 int (*modify_ah)(struct ib_ah *ah,
Dasaratharaman Chandramouli90898852017-04-29 14:41:18 -04002062 struct rdma_ah_attr *ah_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 int (*query_ah)(struct ib_ah *ah,
Dasaratharaman Chandramouli90898852017-04-29 14:41:18 -04002064 struct rdma_ah_attr *ah_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 int (*destroy_ah)(struct ib_ah *ah);
Roland Dreierd41fcc62005-08-18 12:23:08 -07002066 struct ib_srq * (*create_srq)(struct ib_pd *pd,
2067 struct ib_srq_init_attr *srq_init_attr,
2068 struct ib_udata *udata);
2069 int (*modify_srq)(struct ib_srq *srq,
2070 struct ib_srq_attr *srq_attr,
Ralph Campbell9bc57e22006-08-11 14:58:09 -07002071 enum ib_srq_attr_mask srq_attr_mask,
2072 struct ib_udata *udata);
Roland Dreierd41fcc62005-08-18 12:23:08 -07002073 int (*query_srq)(struct ib_srq *srq,
2074 struct ib_srq_attr *srq_attr);
2075 int (*destroy_srq)(struct ib_srq *srq);
2076 int (*post_srq_recv)(struct ib_srq *srq,
2077 struct ib_recv_wr *recv_wr,
2078 struct ib_recv_wr **bad_recv_wr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 struct ib_qp * (*create_qp)(struct ib_pd *pd,
Roland Dreiere2773c02005-07-07 17:57:10 -07002080 struct ib_qp_init_attr *qp_init_attr,
2081 struct ib_udata *udata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 int (*modify_qp)(struct ib_qp *qp,
2083 struct ib_qp_attr *qp_attr,
Ralph Campbell9bc57e22006-08-11 14:58:09 -07002084 int qp_attr_mask,
2085 struct ib_udata *udata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 int (*query_qp)(struct ib_qp *qp,
2087 struct ib_qp_attr *qp_attr,
2088 int qp_attr_mask,
2089 struct ib_qp_init_attr *qp_init_attr);
2090 int (*destroy_qp)(struct ib_qp *qp);
2091 int (*post_send)(struct ib_qp *qp,
2092 struct ib_send_wr *send_wr,
2093 struct ib_send_wr **bad_send_wr);
2094 int (*post_recv)(struct ib_qp *qp,
2095 struct ib_recv_wr *recv_wr,
2096 struct ib_recv_wr **bad_recv_wr);
Matan Barakbcf4c1e2015-06-11 16:35:20 +03002097 struct ib_cq * (*create_cq)(struct ib_device *device,
2098 const struct ib_cq_init_attr *attr,
Roland Dreiere2773c02005-07-07 17:57:10 -07002099 struct ib_ucontext *context,
2100 struct ib_udata *udata);
Eli Cohen2dd57162008-04-16 21:09:33 -07002101 int (*modify_cq)(struct ib_cq *cq, u16 cq_count,
2102 u16 cq_period);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 int (*destroy_cq)(struct ib_cq *cq);
Roland Dreier33b9b3e2006-01-30 14:29:21 -08002104 int (*resize_cq)(struct ib_cq *cq, int cqe,
2105 struct ib_udata *udata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 int (*poll_cq)(struct ib_cq *cq, int num_entries,
2107 struct ib_wc *wc);
2108 int (*peek_cq)(struct ib_cq *cq, int wc_cnt);
2109 int (*req_notify_cq)(struct ib_cq *cq,
Roland Dreiered23a722007-05-06 21:02:48 -07002110 enum ib_cq_notify_flags flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 int (*req_ncomp_notif)(struct ib_cq *cq,
2112 int wc_cnt);
2113 struct ib_mr * (*get_dma_mr)(struct ib_pd *pd,
2114 int mr_access_flags);
Roland Dreiere2773c02005-07-07 17:57:10 -07002115 struct ib_mr * (*reg_user_mr)(struct ib_pd *pd,
Roland Dreierf7c6a7b2007-03-04 16:15:11 -08002116 u64 start, u64 length,
2117 u64 virt_addr,
Roland Dreiere2773c02005-07-07 17:57:10 -07002118 int mr_access_flags,
2119 struct ib_udata *udata);
Matan Barak7e6edb92014-07-31 11:01:28 +03002120 int (*rereg_user_mr)(struct ib_mr *mr,
2121 int flags,
2122 u64 start, u64 length,
2123 u64 virt_addr,
2124 int mr_access_flags,
2125 struct ib_pd *pd,
2126 struct ib_udata *udata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 int (*dereg_mr)(struct ib_mr *mr);
Sagi Grimberg9bee1782015-07-30 10:32:35 +03002128 struct ib_mr * (*alloc_mr)(struct ib_pd *pd,
2129 enum ib_mr_type mr_type,
2130 u32 max_num_sg);
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03002131 int (*map_mr_sg)(struct ib_mr *mr,
2132 struct scatterlist *sg,
Christoph Hellwigff2ba992016-05-03 18:01:04 +02002133 int sg_nents,
Bart Van Assche9aa8b322016-05-12 10:49:15 -07002134 unsigned int *sg_offset);
Shani Michaeli7083e422013-02-06 16:19:12 +00002135 struct ib_mw * (*alloc_mw)(struct ib_pd *pd,
Matan Barakb2a239d2016-02-29 18:05:29 +02002136 enum ib_mw_type type,
2137 struct ib_udata *udata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 int (*dealloc_mw)(struct ib_mw *mw);
2139 struct ib_fmr * (*alloc_fmr)(struct ib_pd *pd,
2140 int mr_access_flags,
2141 struct ib_fmr_attr *fmr_attr);
2142 int (*map_phys_fmr)(struct ib_fmr *fmr,
2143 u64 *page_list, int list_len,
2144 u64 iova);
2145 int (*unmap_fmr)(struct list_head *fmr_list);
2146 int (*dealloc_fmr)(struct ib_fmr *fmr);
2147 int (*attach_mcast)(struct ib_qp *qp,
2148 union ib_gid *gid,
2149 u16 lid);
2150 int (*detach_mcast)(struct ib_qp *qp,
2151 union ib_gid *gid,
2152 u16 lid);
2153 int (*process_mad)(struct ib_device *device,
2154 int process_mad_flags,
2155 u8 port_num,
Ira Weinya97e2d82015-05-31 17:15:30 -04002156 const struct ib_wc *in_wc,
2157 const struct ib_grh *in_grh,
Ira Weiny4cd7c942015-06-06 14:38:31 -04002158 const struct ib_mad_hdr *in_mad,
2159 size_t in_mad_size,
2160 struct ib_mad_hdr *out_mad,
2161 size_t *out_mad_size,
2162 u16 *out_mad_pkey_index);
Sean Hefty59991f92011-05-23 17:52:46 -07002163 struct ib_xrcd * (*alloc_xrcd)(struct ib_device *device,
2164 struct ib_ucontext *ucontext,
2165 struct ib_udata *udata);
2166 int (*dealloc_xrcd)(struct ib_xrcd *xrcd);
Hadar Hen Zion319a4412013-08-07 14:01:59 +03002167 struct ib_flow * (*create_flow)(struct ib_qp *qp,
2168 struct ib_flow_attr
2169 *flow_attr,
2170 int domain);
2171 int (*destroy_flow)(struct ib_flow *flow_id);
Sagi Grimberg1b01d332014-02-23 14:19:05 +02002172 int (*check_mr_status)(struct ib_mr *mr, u32 check_mask,
2173 struct ib_mr_status *mr_status);
Yishai Hadas036b1062015-08-13 18:32:05 +03002174 void (*disassociate_ucontext)(struct ib_ucontext *ibcontext);
Steve Wise765d6772016-02-17 08:15:41 -08002175 void (*drain_rq)(struct ib_qp *qp);
2176 void (*drain_sq)(struct ib_qp *qp);
Eli Cohen50174a72016-03-11 22:58:38 +02002177 int (*set_vf_link_state)(struct ib_device *device, int vf, u8 port,
2178 int state);
2179 int (*get_vf_config)(struct ib_device *device, int vf, u8 port,
2180 struct ifla_vf_info *ivf);
2181 int (*get_vf_stats)(struct ib_device *device, int vf, u8 port,
2182 struct ifla_vf_stats *stats);
2183 int (*set_vf_guid)(struct ib_device *device, int vf, u8 port, u64 guid,
2184 int type);
Yishai Hadas5fd251c2016-05-23 15:20:48 +03002185 struct ib_wq * (*create_wq)(struct ib_pd *pd,
2186 struct ib_wq_init_attr *init_attr,
2187 struct ib_udata *udata);
2188 int (*destroy_wq)(struct ib_wq *wq);
2189 int (*modify_wq)(struct ib_wq *wq,
2190 struct ib_wq_attr *attr,
2191 u32 wq_attr_mask,
2192 struct ib_udata *udata);
Yishai Hadas6d397862016-05-23 15:20:51 +03002193 struct ib_rwq_ind_table * (*create_rwq_ind_table)(struct ib_device *device,
2194 struct ib_rwq_ind_table_init_attr *init_attr,
2195 struct ib_udata *udata);
2196 int (*destroy_rwq_ind_table)(struct ib_rwq_ind_table *wq_ind_table);
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -07002197 /**
2198 * rdma netdev operations
2199 *
2200 * Driver implementing alloc_rdma_netdev must return -EOPNOTSUPP if it
2201 * doesn't support the specified rdma netdev type.
2202 */
2203 struct net_device *(*alloc_rdma_netdev)(
2204 struct ib_device *device,
2205 u8 port_num,
2206 enum rdma_netdev_t type,
2207 const char *name,
2208 unsigned char name_assign_type,
2209 void (*setup)(struct net_device *));
2210 void (*free_rdma_netdev)(struct net_device *netdev);
Ralph Campbell9b513092006-12-12 14:27:41 -08002211
Roland Dreiere2773c02005-07-07 17:57:10 -07002212 struct module *owner;
Tony Jonesf4e91eb2008-02-22 00:13:36 +01002213 struct device dev;
Greg Kroah-Hartman35be0682007-12-17 15:54:39 -04002214 struct kobject *ports_parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215 struct list_head port_list;
2216
2217 enum {
2218 IB_DEV_UNINITIALIZED,
2219 IB_DEV_REGISTERED,
2220 IB_DEV_UNREGISTERED
2221 } reg_state;
2222
Roland Dreier274c0892005-09-29 14:17:48 -07002223 int uverbs_abi_ver;
Alexander Chiang17a55f72010-02-02 19:09:16 +00002224 u64 uverbs_cmd_mask;
Yann Droneaudf21519b2013-11-06 23:21:49 +01002225 u64 uverbs_ex_cmd_mask;
Roland Dreier274c0892005-09-29 14:17:48 -07002226
Yuval Shaiabd99fde2016-08-25 10:57:07 -07002227 char node_desc[IB_DEVICE_NODE_DESC_MAX];
Sean Heftycf311cd2006-01-10 07:39:34 -08002228 __be64 node_guid;
Steve Wise96f15c02008-07-14 23:48:53 -07002229 u32 local_dma_lkey;
Hal Rosenstock41390322015-06-29 09:57:00 -04002230 u16 is_switch:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 u8 node_type;
2232 u8 phys_port_cnt;
Ira Weiny3e153a92015-12-18 10:59:44 +02002233 struct ib_device_attr attrs;
Christoph Lameterb40f4752016-05-16 12:49:33 -05002234 struct attribute_group *hw_stats_ag;
2235 struct rdma_hw_stats *hw_stats;
Ira Weiny77386132015-05-13 20:02:58 -04002236
Parav Pandit43579b52017-01-10 00:02:14 +00002237#ifdef CONFIG_CGROUP_RDMA
2238 struct rdmacg_device cg_device;
2239#endif
2240
Ira Weiny77386132015-05-13 20:02:58 -04002241 /**
2242 * The following mandatory functions are used only at device
2243 * registration. Keep functions such as these at the end of this
2244 * structure to avoid cache line misses when accessing struct ib_device
2245 * in fast paths.
2246 */
2247 int (*get_port_immutable)(struct ib_device *, u8, struct ib_port_immutable *);
Ira Weiny5fa76c22016-06-15 02:21:56 -04002248 void (*get_dev_fw_str)(struct ib_device *, char *str, size_t str_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249};
2250
2251struct ib_client {
2252 char *name;
2253 void (*add) (struct ib_device *);
Haggai Eran7c1eb452015-07-30 17:50:14 +03002254 void (*remove)(struct ib_device *, void *client_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255
Yotam Kenneth9268f722015-07-30 17:50:15 +03002256 /* Returns the net_dev belonging to this ib_client and matching the
2257 * given parameters.
2258 * @dev: An RDMA device that the net_dev use for communication.
2259 * @port: A physical port number on the RDMA device.
2260 * @pkey: P_Key that the net_dev uses if applicable.
2261 * @gid: A GID that the net_dev uses to communicate.
2262 * @addr: An IP address the net_dev is configured with.
2263 * @client_data: The device's client data set by ib_set_client_data().
2264 *
2265 * An ib_client that implements a net_dev on top of RDMA devices
2266 * (such as IP over IB) should implement this callback, allowing the
2267 * rdma_cm module to find the right net_dev for a given request.
2268 *
2269 * The caller is responsible for calling dev_put on the returned
2270 * netdev. */
2271 struct net_device *(*get_net_dev_by_params)(
2272 struct ib_device *dev,
2273 u8 port,
2274 u16 pkey,
2275 const union ib_gid *gid,
2276 const struct sockaddr *addr,
2277 void *client_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 struct list_head list;
2279};
2280
2281struct ib_device *ib_alloc_device(size_t size);
2282void ib_dealloc_device(struct ib_device *device);
2283
Ira Weiny5fa76c22016-06-15 02:21:56 -04002284void ib_get_device_fw_str(struct ib_device *device, char *str, size_t str_len);
2285
Ralph Campbell9a6edb62010-05-06 17:03:25 -07002286int ib_register_device(struct ib_device *device,
2287 int (*port_callback)(struct ib_device *,
2288 u8, struct kobject *));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289void ib_unregister_device(struct ib_device *device);
2290
2291int ib_register_client (struct ib_client *client);
2292void ib_unregister_client(struct ib_client *client);
2293
2294void *ib_get_client_data(struct ib_device *device, struct ib_client *client);
2295void ib_set_client_data(struct ib_device *device, struct ib_client *client,
2296 void *data);
2297
Roland Dreiere2773c02005-07-07 17:57:10 -07002298static inline int ib_copy_from_udata(void *dest, struct ib_udata *udata, size_t len)
2299{
2300 return copy_from_user(dest, udata->inbuf, len) ? -EFAULT : 0;
2301}
2302
2303static inline int ib_copy_to_udata(struct ib_udata *udata, void *src, size_t len)
2304{
Yann Droneaud43c611652015-02-05 22:10:18 +01002305 return copy_to_user(udata->outbuf, src, len) ? -EFAULT : 0;
Roland Dreiere2773c02005-07-07 17:57:10 -07002306}
2307
Matan Barak301a7212015-12-15 20:30:10 +02002308static inline bool ib_is_udata_cleared(struct ib_udata *udata,
2309 size_t offset,
2310 size_t len)
2311{
2312 const void __user *p = udata->inbuf + offset;
Markus Elfring92d27ae2016-08-22 18:23:24 +02002313 bool ret;
Matan Barak301a7212015-12-15 20:30:10 +02002314 u8 *buf;
2315
2316 if (len > USHRT_MAX)
2317 return false;
2318
Markus Elfring92d27ae2016-08-22 18:23:24 +02002319 buf = memdup_user(p, len);
2320 if (IS_ERR(buf))
Matan Barak301a7212015-12-15 20:30:10 +02002321 return false;
2322
Matan Barak301a7212015-12-15 20:30:10 +02002323 ret = !memchr_inv(buf, 0, len);
Matan Barak301a7212015-12-15 20:30:10 +02002324 kfree(buf);
2325 return ret;
2326}
2327
Roland Dreier8a518662006-02-13 12:48:12 -08002328/**
2329 * ib_modify_qp_is_ok - Check that the supplied attribute mask
2330 * contains all required attributes and no attributes not allowed for
2331 * the given QP state transition.
2332 * @cur_state: Current QP state
2333 * @next_state: Next QP state
2334 * @type: QP type
2335 * @mask: Mask of supplied QP attributes
Matan Barakdd5f03b2013-12-12 18:03:11 +02002336 * @ll : link layer of port
Roland Dreier8a518662006-02-13 12:48:12 -08002337 *
2338 * This function is a helper function that a low-level driver's
2339 * modify_qp method can use to validate the consumer's input. It
2340 * checks that cur_state and next_state are valid QP states, that a
2341 * transition from cur_state to next_state is allowed by the IB spec,
2342 * and that the attribute mask supplied is allowed for the transition.
2343 */
2344int ib_modify_qp_is_ok(enum ib_qp_state cur_state, enum ib_qp_state next_state,
Matan Barakdd5f03b2013-12-12 18:03:11 +02002345 enum ib_qp_type type, enum ib_qp_attr_mask mask,
2346 enum rdma_link_layer ll);
Roland Dreier8a518662006-02-13 12:48:12 -08002347
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348int ib_register_event_handler (struct ib_event_handler *event_handler);
2349int ib_unregister_event_handler(struct ib_event_handler *event_handler);
2350void ib_dispatch_event(struct ib_event *event);
2351
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352int ib_query_port(struct ib_device *device,
2353 u8 port_num, struct ib_port_attr *port_attr);
2354
Eli Cohena3f5ada2010-09-27 17:51:10 -07002355enum rdma_link_layer rdma_port_get_link_layer(struct ib_device *device,
2356 u8 port_num);
2357
Ira Weiny0cf18d72015-05-13 20:02:55 -04002358/**
Hal Rosenstock41390322015-06-29 09:57:00 -04002359 * rdma_cap_ib_switch - Check if the device is IB switch
2360 * @device: Device to check
2361 *
2362 * Device driver is responsible for setting is_switch bit on
2363 * in ib_device structure at init time.
2364 *
2365 * Return: true if the device is IB switch.
2366 */
2367static inline bool rdma_cap_ib_switch(const struct ib_device *device)
2368{
2369 return device->is_switch;
2370}
2371
2372/**
Ira Weiny0cf18d72015-05-13 20:02:55 -04002373 * rdma_start_port - Return the first valid port number for the device
2374 * specified
2375 *
2376 * @device: Device to be checked
2377 *
2378 * Return start port number
2379 */
2380static inline u8 rdma_start_port(const struct ib_device *device)
2381{
Hal Rosenstock41390322015-06-29 09:57:00 -04002382 return rdma_cap_ib_switch(device) ? 0 : 1;
Ira Weiny0cf18d72015-05-13 20:02:55 -04002383}
2384
2385/**
2386 * rdma_end_port - Return the last valid port number for the device
2387 * specified
2388 *
2389 * @device: Device to be checked
2390 *
2391 * Return last port number
2392 */
2393static inline u8 rdma_end_port(const struct ib_device *device)
2394{
Hal Rosenstock41390322015-06-29 09:57:00 -04002395 return rdma_cap_ib_switch(device) ? 0 : device->phys_port_cnt;
Ira Weiny0cf18d72015-05-13 20:02:55 -04002396}
2397
Yuval Shaia24dc8312017-01-25 18:41:37 +02002398static inline int rdma_is_port_valid(const struct ib_device *device,
2399 unsigned int port)
2400{
2401 return (port >= rdma_start_port(device) &&
2402 port <= rdma_end_port(device));
2403}
2404
Ira Weiny5ede9282015-05-31 17:15:29 -04002405static inline bool rdma_protocol_ib(const struct ib_device *device, u8 port_num)
Michael Wangde66be92015-05-05 14:50:19 +02002406{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002407 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_IB;
Michael Wangde66be92015-05-05 14:50:19 +02002408}
2409
Ira Weiny5ede9282015-05-31 17:15:29 -04002410static inline bool rdma_protocol_roce(const struct ib_device *device, u8 port_num)
Michael Wangde66be92015-05-05 14:50:19 +02002411{
Matan Barak7766a992015-12-23 14:56:50 +02002412 return device->port_immutable[port_num].core_cap_flags &
2413 (RDMA_CORE_CAP_PROT_ROCE | RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP);
2414}
2415
2416static inline bool rdma_protocol_roce_udp_encap(const struct ib_device *device, u8 port_num)
2417{
2418 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP;
2419}
2420
2421static inline bool rdma_protocol_roce_eth_encap(const struct ib_device *device, u8 port_num)
2422{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002423 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_ROCE;
Michael Wangde66be92015-05-05 14:50:19 +02002424}
2425
Ira Weiny5ede9282015-05-31 17:15:29 -04002426static inline bool rdma_protocol_iwarp(const struct ib_device *device, u8 port_num)
Michael Wangde66be92015-05-05 14:50:19 +02002427{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002428 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_IWARP;
Michael Wangde66be92015-05-05 14:50:19 +02002429}
2430
Ira Weiny5ede9282015-05-31 17:15:29 -04002431static inline bool rdma_ib_or_roce(const struct ib_device *device, u8 port_num)
Michael Wangde66be92015-05-05 14:50:19 +02002432{
Matan Barak7766a992015-12-23 14:56:50 +02002433 return rdma_protocol_ib(device, port_num) ||
2434 rdma_protocol_roce(device, port_num);
Michael Wangde66be92015-05-05 14:50:19 +02002435}
2436
Or Gerlitzaa773bd2017-01-24 13:02:35 +02002437static inline bool rdma_protocol_raw_packet(const struct ib_device *device, u8 port_num)
2438{
2439 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_RAW_PACKET;
2440}
2441
Or Gerlitzce1e0552017-01-24 13:02:38 +02002442static inline bool rdma_protocol_usnic(const struct ib_device *device, u8 port_num)
2443{
2444 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_USNIC;
2445}
2446
Michael Wangc757dea2015-05-05 14:50:32 +02002447/**
Michael Wang296ec002015-05-18 10:41:45 +02002448 * rdma_cap_ib_mad - Check if the port of a device supports Infiniband
Michael Wangc757dea2015-05-05 14:50:32 +02002449 * Management Datagrams.
Michael Wang296ec002015-05-18 10:41:45 +02002450 * @device: Device to check
2451 * @port_num: Port number to check
Michael Wangc757dea2015-05-05 14:50:32 +02002452 *
Michael Wang296ec002015-05-18 10:41:45 +02002453 * Management Datagrams (MAD) are a required part of the InfiniBand
2454 * specification and are supported on all InfiniBand devices. A slightly
2455 * extended version are also supported on OPA interfaces.
Michael Wangc757dea2015-05-05 14:50:32 +02002456 *
Michael Wang296ec002015-05-18 10:41:45 +02002457 * Return: true if the port supports sending/receiving of MAD packets.
Michael Wangc757dea2015-05-05 14:50:32 +02002458 */
Ira Weiny5ede9282015-05-31 17:15:29 -04002459static inline bool rdma_cap_ib_mad(const struct ib_device *device, u8 port_num)
Michael Wangc757dea2015-05-05 14:50:32 +02002460{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002461 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_MAD;
Michael Wangc757dea2015-05-05 14:50:32 +02002462}
2463
Michael Wang29541e32015-05-05 14:50:33 +02002464/**
Ira Weiny65995fe2015-06-06 14:38:32 -04002465 * rdma_cap_opa_mad - Check if the port of device provides support for OPA
2466 * Management Datagrams.
2467 * @device: Device to check
2468 * @port_num: Port number to check
2469 *
2470 * Intel OmniPath devices extend and/or replace the InfiniBand Management
2471 * datagrams with their own versions. These OPA MADs share many but not all of
2472 * the characteristics of InfiniBand MADs.
2473 *
2474 * OPA MADs differ in the following ways:
2475 *
2476 * 1) MADs are variable size up to 2K
2477 * IBTA defined MADs remain fixed at 256 bytes
2478 * 2) OPA SMPs must carry valid PKeys
2479 * 3) OPA SMP packets are a different format
2480 *
2481 * Return: true if the port supports OPA MAD packet formats.
2482 */
2483static inline bool rdma_cap_opa_mad(struct ib_device *device, u8 port_num)
2484{
2485 return (device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_OPA_MAD)
2486 == RDMA_CORE_CAP_OPA_MAD;
2487}
2488
2489/**
Michael Wang296ec002015-05-18 10:41:45 +02002490 * rdma_cap_ib_smi - Check if the port of a device provides an Infiniband
2491 * Subnet Management Agent (SMA) on the Subnet Management Interface (SMI).
2492 * @device: Device to check
2493 * @port_num: Port number to check
Michael Wang29541e32015-05-05 14:50:33 +02002494 *
Michael Wang296ec002015-05-18 10:41:45 +02002495 * Each InfiniBand node is required to provide a Subnet Management Agent
2496 * that the subnet manager can access. Prior to the fabric being fully
2497 * configured by the subnet manager, the SMA is accessed via a well known
2498 * interface called the Subnet Management Interface (SMI). This interface
2499 * uses directed route packets to communicate with the SM to get around the
2500 * chicken and egg problem of the SM needing to know what's on the fabric
2501 * in order to configure the fabric, and needing to configure the fabric in
2502 * order to send packets to the devices on the fabric. These directed
2503 * route packets do not need the fabric fully configured in order to reach
2504 * their destination. The SMI is the only method allowed to send
2505 * directed route packets on an InfiniBand fabric.
Michael Wang29541e32015-05-05 14:50:33 +02002506 *
Michael Wang296ec002015-05-18 10:41:45 +02002507 * Return: true if the port provides an SMI.
Michael Wang29541e32015-05-05 14:50:33 +02002508 */
Ira Weiny5ede9282015-05-31 17:15:29 -04002509static inline bool rdma_cap_ib_smi(const struct ib_device *device, u8 port_num)
Michael Wang29541e32015-05-05 14:50:33 +02002510{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002511 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_SMI;
Michael Wang29541e32015-05-05 14:50:33 +02002512}
2513
Michael Wang72219cea2015-05-05 14:50:34 +02002514/**
2515 * rdma_cap_ib_cm - Check if the port of device has the capability Infiniband
2516 * Communication Manager.
Michael Wang296ec002015-05-18 10:41:45 +02002517 * @device: Device to check
2518 * @port_num: Port number to check
Michael Wang72219cea2015-05-05 14:50:34 +02002519 *
Michael Wang296ec002015-05-18 10:41:45 +02002520 * The InfiniBand Communication Manager is one of many pre-defined General
2521 * Service Agents (GSA) that are accessed via the General Service
2522 * Interface (GSI). It's role is to facilitate establishment of connections
2523 * between nodes as well as other management related tasks for established
2524 * connections.
Michael Wang72219cea2015-05-05 14:50:34 +02002525 *
Michael Wang296ec002015-05-18 10:41:45 +02002526 * Return: true if the port supports an IB CM (this does not guarantee that
2527 * a CM is actually running however).
Michael Wang72219cea2015-05-05 14:50:34 +02002528 */
Ira Weiny5ede9282015-05-31 17:15:29 -04002529static inline bool rdma_cap_ib_cm(const struct ib_device *device, u8 port_num)
Michael Wang72219cea2015-05-05 14:50:34 +02002530{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002531 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_CM;
Michael Wang72219cea2015-05-05 14:50:34 +02002532}
2533
Michael Wang04215332015-05-05 14:50:35 +02002534/**
2535 * rdma_cap_iw_cm - Check if the port of device has the capability IWARP
2536 * Communication Manager.
Michael Wang296ec002015-05-18 10:41:45 +02002537 * @device: Device to check
2538 * @port_num: Port number to check
Michael Wang04215332015-05-05 14:50:35 +02002539 *
Michael Wang296ec002015-05-18 10:41:45 +02002540 * Similar to above, but specific to iWARP connections which have a different
2541 * managment protocol than InfiniBand.
Michael Wang04215332015-05-05 14:50:35 +02002542 *
Michael Wang296ec002015-05-18 10:41:45 +02002543 * Return: true if the port supports an iWARP CM (this does not guarantee that
2544 * a CM is actually running however).
Michael Wang04215332015-05-05 14:50:35 +02002545 */
Ira Weiny5ede9282015-05-31 17:15:29 -04002546static inline bool rdma_cap_iw_cm(const struct ib_device *device, u8 port_num)
Michael Wang04215332015-05-05 14:50:35 +02002547{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002548 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IW_CM;
Michael Wang04215332015-05-05 14:50:35 +02002549}
2550
Michael Wangfe53ba22015-05-05 14:50:36 +02002551/**
2552 * rdma_cap_ib_sa - Check if the port of device has the capability Infiniband
2553 * Subnet Administration.
Michael Wang296ec002015-05-18 10:41:45 +02002554 * @device: Device to check
2555 * @port_num: Port number to check
Michael Wangfe53ba22015-05-05 14:50:36 +02002556 *
Michael Wang296ec002015-05-18 10:41:45 +02002557 * An InfiniBand Subnet Administration (SA) service is a pre-defined General
2558 * Service Agent (GSA) provided by the Subnet Manager (SM). On InfiniBand
2559 * fabrics, devices should resolve routes to other hosts by contacting the
2560 * SA to query the proper route.
Michael Wangfe53ba22015-05-05 14:50:36 +02002561 *
Michael Wang296ec002015-05-18 10:41:45 +02002562 * Return: true if the port should act as a client to the fabric Subnet
2563 * Administration interface. This does not imply that the SA service is
2564 * running locally.
Michael Wangfe53ba22015-05-05 14:50:36 +02002565 */
Ira Weiny5ede9282015-05-31 17:15:29 -04002566static inline bool rdma_cap_ib_sa(const struct ib_device *device, u8 port_num)
Michael Wangfe53ba22015-05-05 14:50:36 +02002567{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002568 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_SA;
Michael Wangfe53ba22015-05-05 14:50:36 +02002569}
2570
Michael Wanga31ad3b2015-05-05 14:50:37 +02002571/**
2572 * rdma_cap_ib_mcast - Check if the port of device has the capability Infiniband
2573 * Multicast.
Michael Wang296ec002015-05-18 10:41:45 +02002574 * @device: Device to check
2575 * @port_num: Port number to check
Michael Wanga31ad3b2015-05-05 14:50:37 +02002576 *
Michael Wang296ec002015-05-18 10:41:45 +02002577 * InfiniBand multicast registration is more complex than normal IPv4 or
2578 * IPv6 multicast registration. Each Host Channel Adapter must register
2579 * with the Subnet Manager when it wishes to join a multicast group. It
2580 * should do so only once regardless of how many queue pairs it subscribes
2581 * to this group. And it should leave the group only after all queue pairs
2582 * attached to the group have been detached.
Michael Wanga31ad3b2015-05-05 14:50:37 +02002583 *
Michael Wang296ec002015-05-18 10:41:45 +02002584 * Return: true if the port must undertake the additional adminstrative
2585 * overhead of registering/unregistering with the SM and tracking of the
2586 * total number of queue pairs attached to the multicast group.
Michael Wanga31ad3b2015-05-05 14:50:37 +02002587 */
Ira Weiny5ede9282015-05-31 17:15:29 -04002588static inline bool rdma_cap_ib_mcast(const struct ib_device *device, u8 port_num)
Michael Wanga31ad3b2015-05-05 14:50:37 +02002589{
2590 return rdma_cap_ib_sa(device, port_num);
2591}
2592
Michael Wangbc0f1d72015-05-05 14:50:38 +02002593/**
Michael Wang30a74ef2015-05-05 14:50:39 +02002594 * rdma_cap_af_ib - Check if the port of device has the capability
2595 * Native Infiniband Address.
Michael Wang296ec002015-05-18 10:41:45 +02002596 * @device: Device to check
2597 * @port_num: Port number to check
Michael Wang30a74ef2015-05-05 14:50:39 +02002598 *
Michael Wang296ec002015-05-18 10:41:45 +02002599 * InfiniBand addressing uses a port's GUID + Subnet Prefix to make a default
2600 * GID. RoCE uses a different mechanism, but still generates a GID via
2601 * a prescribed mechanism and port specific data.
Michael Wang30a74ef2015-05-05 14:50:39 +02002602 *
Michael Wang296ec002015-05-18 10:41:45 +02002603 * Return: true if the port uses a GID address to identify devices on the
2604 * network.
Michael Wang30a74ef2015-05-05 14:50:39 +02002605 */
Ira Weiny5ede9282015-05-31 17:15:29 -04002606static inline bool rdma_cap_af_ib(const struct ib_device *device, u8 port_num)
Michael Wang30a74ef2015-05-05 14:50:39 +02002607{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002608 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_AF_IB;
Michael Wang30a74ef2015-05-05 14:50:39 +02002609}
2610
2611/**
Michael Wang227128f2015-05-05 14:50:40 +02002612 * rdma_cap_eth_ah - Check if the port of device has the capability
Michael Wang296ec002015-05-18 10:41:45 +02002613 * Ethernet Address Handle.
2614 * @device: Device to check
2615 * @port_num: Port number to check
Michael Wang227128f2015-05-05 14:50:40 +02002616 *
Michael Wang296ec002015-05-18 10:41:45 +02002617 * RoCE is InfiniBand over Ethernet, and it uses a well defined technique
2618 * to fabricate GIDs over Ethernet/IP specific addresses native to the
2619 * port. Normally, packet headers are generated by the sending host
2620 * adapter, but when sending connectionless datagrams, we must manually
2621 * inject the proper headers for the fabric we are communicating over.
Michael Wang227128f2015-05-05 14:50:40 +02002622 *
Michael Wang296ec002015-05-18 10:41:45 +02002623 * Return: true if we are running as a RoCE port and must force the
2624 * addition of a Global Route Header built from our Ethernet Address
2625 * Handle into our header list for connectionless packets.
Michael Wang227128f2015-05-05 14:50:40 +02002626 */
Ira Weiny5ede9282015-05-31 17:15:29 -04002627static inline bool rdma_cap_eth_ah(const struct ib_device *device, u8 port_num)
Michael Wang227128f2015-05-05 14:50:40 +02002628{
Ira Weinyf9b22e32015-05-13 20:02:59 -04002629 return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_ETH_AH;
Michael Wang227128f2015-05-05 14:50:40 +02002630}
2631
2632/**
Dasaratharaman Chandramouli94d595c2017-03-20 19:38:09 -04002633 * rdma_cap_opa_ah - Check if the port of device supports
2634 * OPA Address handles
2635 * @device: Device to check
2636 * @port_num: Port number to check
2637 *
2638 * Return: true if we are running on an OPA device which supports
2639 * the extended OPA addressing.
2640 */
2641static inline bool rdma_cap_opa_ah(struct ib_device *device, u8 port_num)
2642{
2643 return (device->port_immutable[port_num].core_cap_flags &
2644 RDMA_CORE_CAP_OPA_AH) == RDMA_CORE_CAP_OPA_AH;
2645}
2646
2647/**
Ira Weiny337877a2015-06-06 14:38:29 -04002648 * rdma_max_mad_size - Return the max MAD size required by this RDMA Port.
2649 *
2650 * @device: Device
2651 * @port_num: Port number
2652 *
2653 * This MAD size includes the MAD headers and MAD payload. No other headers
2654 * are included.
2655 *
2656 * Return the max MAD size required by the Port. Will return 0 if the port
2657 * does not support MADs
2658 */
2659static inline size_t rdma_max_mad_size(const struct ib_device *device, u8 port_num)
2660{
2661 return device->port_immutable[port_num].max_mad_size;
2662}
2663
Matan Barak03db3a22015-07-30 18:33:26 +03002664/**
2665 * rdma_cap_roce_gid_table - Check if the port of device uses roce_gid_table
2666 * @device: Device to check
2667 * @port_num: Port number to check
2668 *
2669 * RoCE GID table mechanism manages the various GIDs for a device.
2670 *
2671 * NOTE: if allocating the port's GID table has failed, this call will still
2672 * return true, but any RoCE GID table API will fail.
2673 *
2674 * Return: true if the port uses RoCE GID table mechanism in order to manage
2675 * its GIDs.
2676 */
2677static inline bool rdma_cap_roce_gid_table(const struct ib_device *device,
2678 u8 port_num)
2679{
2680 return rdma_protocol_roce(device, port_num) &&
2681 device->add_gid && device->del_gid;
2682}
2683
Christoph Hellwig002516e2016-05-03 18:01:05 +02002684/*
2685 * Check if the device supports READ W/ INVALIDATE.
2686 */
2687static inline bool rdma_cap_read_inv(struct ib_device *dev, u32 port_num)
2688{
2689 /*
2690 * iWarp drivers must support READ W/ INVALIDATE. No other protocol
2691 * has support for it yet.
2692 */
2693 return rdma_protocol_iwarp(dev, port_num);
2694}
2695
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696int ib_query_gid(struct ib_device *device,
Matan Barak55ee3ab2015-10-15 18:38:45 +03002697 u8 port_num, int index, union ib_gid *gid,
2698 struct ib_gid_attr *attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699
Eli Cohen50174a72016-03-11 22:58:38 +02002700int ib_set_vf_link_state(struct ib_device *device, int vf, u8 port,
2701 int state);
2702int ib_get_vf_config(struct ib_device *device, int vf, u8 port,
2703 struct ifla_vf_info *info);
2704int ib_get_vf_stats(struct ib_device *device, int vf, u8 port,
2705 struct ifla_vf_stats *stats);
2706int ib_set_vf_guid(struct ib_device *device, int vf, u8 port, u64 guid,
2707 int type);
2708
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709int ib_query_pkey(struct ib_device *device,
2710 u8 port_num, u16 index, u16 *pkey);
2711
2712int ib_modify_device(struct ib_device *device,
2713 int device_modify_mask,
2714 struct ib_device_modify *device_modify);
2715
2716int ib_modify_port(struct ib_device *device,
2717 u8 port_num, int port_modify_mask,
2718 struct ib_port_modify *port_modify);
2719
Yosef Etigin5eb620c2007-05-14 07:26:51 +03002720int ib_find_gid(struct ib_device *device, union ib_gid *gid,
Matan Barakb39ffa12015-12-23 14:56:47 +02002721 enum ib_gid_type gid_type, struct net_device *ndev,
2722 u8 *port_num, u16 *index);
Yosef Etigin5eb620c2007-05-14 07:26:51 +03002723
2724int ib_find_pkey(struct ib_device *device,
2725 u8 port_num, u16 pkey, u16 *index);
2726
Christoph Hellwiged082d32016-09-05 12:56:17 +02002727enum ib_pd_flags {
2728 /*
2729 * Create a memory registration for all memory in the system and place
2730 * the rkey for it into pd->unsafe_global_rkey. This can be used by
2731 * ULPs to avoid the overhead of dynamic MRs.
2732 *
2733 * This flag is generally considered unsafe and must only be used in
2734 * extremly trusted environments. Every use of it will log a warning
2735 * in the kernel log.
2736 */
2737 IB_PD_UNSAFE_GLOBAL_RKEY = 0x01,
2738};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739
Christoph Hellwiged082d32016-09-05 12:56:17 +02002740struct ib_pd *__ib_alloc_pd(struct ib_device *device, unsigned int flags,
2741 const char *caller);
2742#define ib_alloc_pd(device, flags) \
2743 __ib_alloc_pd((device), (flags), __func__)
Jason Gunthorpe7dd78642015-08-05 14:34:31 -06002744void ib_dealloc_pd(struct ib_pd *pd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745
2746/**
Dasaratharaman Chandramouli0a18cfe2017-04-29 14:41:19 -04002747 * rdma_create_ah - Creates an address handle for the given address vector.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748 * @pd: The protection domain associated with the address handle.
2749 * @ah_attr: The attributes of the address vector.
2750 *
2751 * The address handle is used to reference a local or global destination
2752 * in all UD QP post sends.
2753 */
Dasaratharaman Chandramouli0a18cfe2017-04-29 14:41:19 -04002754struct ib_ah *rdma_create_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755
2756/**
Moni Shoua850d8fd2016-11-10 11:30:56 +02002757 * ib_get_gids_from_rdma_hdr - Get sgid and dgid from GRH or IPv4 header
2758 * work completion.
2759 * @hdr: the L3 header to parse
2760 * @net_type: type of header to parse
2761 * @sgid: place to store source gid
2762 * @dgid: place to store destination gid
2763 */
2764int ib_get_gids_from_rdma_hdr(const union rdma_network_hdr *hdr,
2765 enum rdma_network_type net_type,
2766 union ib_gid *sgid, union ib_gid *dgid);
2767
2768/**
2769 * ib_get_rdma_header_version - Get the header version
2770 * @hdr: the L3 header to parse
2771 */
2772int ib_get_rdma_header_version(const union rdma_network_hdr *hdr);
2773
2774/**
Sean Hefty4e00d692006-06-17 20:37:39 -07002775 * ib_init_ah_from_wc - Initializes address handle attributes from a
2776 * work completion.
2777 * @device: Device on which the received message arrived.
2778 * @port_num: Port on which the received message arrived.
2779 * @wc: Work completion associated with the received message.
2780 * @grh: References the received global route header. This parameter is
2781 * ignored unless the work completion indicates that the GRH is valid.
2782 * @ah_attr: Returned attributes that can be used when creating an address
2783 * handle for replying to the message.
2784 */
Ira Weiny73cdaae2015-05-31 17:15:31 -04002785int ib_init_ah_from_wc(struct ib_device *device, u8 port_num,
2786 const struct ib_wc *wc, const struct ib_grh *grh,
Dasaratharaman Chandramouli90898852017-04-29 14:41:18 -04002787 struct rdma_ah_attr *ah_attr);
Sean Hefty4e00d692006-06-17 20:37:39 -07002788
2789/**
Hal Rosenstock513789e2005-07-27 11:45:34 -07002790 * ib_create_ah_from_wc - Creates an address handle associated with the
2791 * sender of the specified work completion.
2792 * @pd: The protection domain associated with the address handle.
2793 * @wc: Work completion information associated with a received message.
2794 * @grh: References the received global route header. This parameter is
2795 * ignored unless the work completion indicates that the GRH is valid.
2796 * @port_num: The outbound port number to associate with the address.
2797 *
2798 * The address handle is used to reference a local or global destination
2799 * in all UD QP post sends.
2800 */
Ira Weiny73cdaae2015-05-31 17:15:31 -04002801struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, const struct ib_wc *wc,
2802 const struct ib_grh *grh, u8 port_num);
Hal Rosenstock513789e2005-07-27 11:45:34 -07002803
2804/**
Dasaratharaman Chandramouli67b985b2017-04-29 14:41:20 -04002805 * rdma_modify_ah - Modifies the address vector associated with an address
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806 * handle.
2807 * @ah: The address handle to modify.
2808 * @ah_attr: The new address vector attributes to associate with the
2809 * address handle.
2810 */
Dasaratharaman Chandramouli67b985b2017-04-29 14:41:20 -04002811int rdma_modify_ah(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812
2813/**
Dasaratharaman Chandramoulibfbfd662017-04-29 14:41:21 -04002814 * rdma_query_ah - Queries the address vector associated with an address
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815 * handle.
2816 * @ah: The address handle to query.
2817 * @ah_attr: The address vector attributes associated with the address
2818 * handle.
2819 */
Dasaratharaman Chandramoulibfbfd662017-04-29 14:41:21 -04002820int rdma_query_ah(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821
2822/**
Dasaratharaman Chandramouli36523152017-04-29 14:41:22 -04002823 * rdma_destroy_ah - Destroys an address handle.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 * @ah: The address handle to destroy.
2825 */
Dasaratharaman Chandramouli36523152017-04-29 14:41:22 -04002826int rdma_destroy_ah(struct ib_ah *ah);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827
2828/**
Roland Dreierd41fcc62005-08-18 12:23:08 -07002829 * ib_create_srq - Creates a SRQ associated with the specified protection
2830 * domain.
2831 * @pd: The protection domain associated with the SRQ.
Dotan Barakabb6e9b2006-02-23 12:13:51 -08002832 * @srq_init_attr: A list of initial attributes required to create the
2833 * SRQ. If SRQ creation succeeds, then the attributes are updated to
2834 * the actual capabilities of the created SRQ.
Roland Dreierd41fcc62005-08-18 12:23:08 -07002835 *
2836 * srq_attr->max_wr and srq_attr->max_sge are read the determine the
2837 * requested size of the SRQ, and set to the actual values allocated
2838 * on return. If ib_create_srq() succeeds, then max_wr and max_sge
2839 * will always be at least as large as the requested values.
2840 */
2841struct ib_srq *ib_create_srq(struct ib_pd *pd,
2842 struct ib_srq_init_attr *srq_init_attr);
2843
2844/**
2845 * ib_modify_srq - Modifies the attributes for the specified SRQ.
2846 * @srq: The SRQ to modify.
2847 * @srq_attr: On input, specifies the SRQ attributes to modify. On output,
2848 * the current values of selected SRQ attributes are returned.
2849 * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ
2850 * are being modified.
2851 *
2852 * The mask may contain IB_SRQ_MAX_WR to resize the SRQ and/or
2853 * IB_SRQ_LIMIT to set the SRQ's limit and request notification when
2854 * the number of receives queued drops below the limit.
2855 */
2856int ib_modify_srq(struct ib_srq *srq,
2857 struct ib_srq_attr *srq_attr,
2858 enum ib_srq_attr_mask srq_attr_mask);
2859
2860/**
2861 * ib_query_srq - Returns the attribute list and current values for the
2862 * specified SRQ.
2863 * @srq: The SRQ to query.
2864 * @srq_attr: The attributes of the specified SRQ.
2865 */
2866int ib_query_srq(struct ib_srq *srq,
2867 struct ib_srq_attr *srq_attr);
2868
2869/**
2870 * ib_destroy_srq - Destroys the specified SRQ.
2871 * @srq: The SRQ to destroy.
2872 */
2873int ib_destroy_srq(struct ib_srq *srq);
2874
2875/**
2876 * ib_post_srq_recv - Posts a list of work requests to the specified SRQ.
2877 * @srq: The SRQ to post the work request on.
2878 * @recv_wr: A list of work requests to post on the receive queue.
2879 * @bad_recv_wr: On an immediate failure, this parameter will reference
2880 * the work request that failed to be posted on the QP.
2881 */
2882static inline int ib_post_srq_recv(struct ib_srq *srq,
2883 struct ib_recv_wr *recv_wr,
2884 struct ib_recv_wr **bad_recv_wr)
2885{
2886 return srq->device->post_srq_recv(srq, recv_wr, bad_recv_wr);
2887}
2888
2889/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890 * ib_create_qp - Creates a QP associated with the specified protection
2891 * domain.
2892 * @pd: The protection domain associated with the QP.
Dotan Barakabb6e9b2006-02-23 12:13:51 -08002893 * @qp_init_attr: A list of initial attributes required to create the
2894 * QP. If QP creation succeeds, then the attributes are updated to
2895 * the actual capabilities of the created QP.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 */
2897struct ib_qp *ib_create_qp(struct ib_pd *pd,
2898 struct ib_qp_init_attr *qp_init_attr);
2899
2900/**
2901 * ib_modify_qp - Modifies the attributes for the specified QP and then
2902 * transitions the QP to the given state.
2903 * @qp: The QP to modify.
2904 * @qp_attr: On input, specifies the QP attributes to modify. On output,
2905 * the current values of selected QP attributes are returned.
2906 * @qp_attr_mask: A bit-mask used to specify which attributes of the QP
2907 * are being modified.
2908 */
2909int ib_modify_qp(struct ib_qp *qp,
2910 struct ib_qp_attr *qp_attr,
2911 int qp_attr_mask);
2912
2913/**
2914 * ib_query_qp - Returns the attribute list and current values for the
2915 * specified QP.
2916 * @qp: The QP to query.
2917 * @qp_attr: The attributes of the specified QP.
2918 * @qp_attr_mask: A bit-mask used to select specific attributes to query.
2919 * @qp_init_attr: Additional attributes of the selected QP.
2920 *
2921 * The qp_attr_mask may be used to limit the query to gathering only the
2922 * selected attributes.
2923 */
2924int ib_query_qp(struct ib_qp *qp,
2925 struct ib_qp_attr *qp_attr,
2926 int qp_attr_mask,
2927 struct ib_qp_init_attr *qp_init_attr);
2928
2929/**
2930 * ib_destroy_qp - Destroys the specified QP.
2931 * @qp: The QP to destroy.
2932 */
2933int ib_destroy_qp(struct ib_qp *qp);
2934
2935/**
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07002936 * ib_open_qp - Obtain a reference to an existing sharable QP.
2937 * @xrcd - XRC domain
2938 * @qp_open_attr: Attributes identifying the QP to open.
2939 *
2940 * Returns a reference to a sharable QP.
2941 */
2942struct ib_qp *ib_open_qp(struct ib_xrcd *xrcd,
2943 struct ib_qp_open_attr *qp_open_attr);
2944
2945/**
2946 * ib_close_qp - Release an external reference to a QP.
Sean Heftyd3d72d92011-05-26 23:06:44 -07002947 * @qp: The QP handle to release
2948 *
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07002949 * The opened QP handle is released by the caller. The underlying
2950 * shared QP is not destroyed until all internal references are released.
Sean Heftyd3d72d92011-05-26 23:06:44 -07002951 */
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07002952int ib_close_qp(struct ib_qp *qp);
Sean Heftyd3d72d92011-05-26 23:06:44 -07002953
2954/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 * ib_post_send - Posts a list of work requests to the send queue of
2956 * the specified QP.
2957 * @qp: The QP to post the work request on.
2958 * @send_wr: A list of work requests to post on the send queue.
2959 * @bad_send_wr: On an immediate failure, this parameter will reference
2960 * the work request that failed to be posted on the QP.
Bart Van Assche55464d42009-12-09 14:20:04 -08002961 *
2962 * While IBA Vol. 1 section 11.4.1.1 specifies that if an immediate
2963 * error is returned, the QP state shall not be affected,
2964 * ib_post_send() will return an immediate error after queueing any
2965 * earlier work requests in the list.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966 */
2967static inline int ib_post_send(struct ib_qp *qp,
2968 struct ib_send_wr *send_wr,
2969 struct ib_send_wr **bad_send_wr)
2970{
2971 return qp->device->post_send(qp, send_wr, bad_send_wr);
2972}
2973
2974/**
2975 * ib_post_recv - Posts a list of work requests to the receive queue of
2976 * the specified QP.
2977 * @qp: The QP to post the work request on.
2978 * @recv_wr: A list of work requests to post on the receive queue.
2979 * @bad_recv_wr: On an immediate failure, this parameter will reference
2980 * the work request that failed to be posted on the QP.
2981 */
2982static inline int ib_post_recv(struct ib_qp *qp,
2983 struct ib_recv_wr *recv_wr,
2984 struct ib_recv_wr **bad_recv_wr)
2985{
2986 return qp->device->post_recv(qp, recv_wr, bad_recv_wr);
2987}
2988
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08002989struct ib_cq *ib_alloc_cq(struct ib_device *dev, void *private,
2990 int nr_cqe, int comp_vector, enum ib_poll_context poll_ctx);
2991void ib_free_cq(struct ib_cq *cq);
2992int ib_process_cq_direct(struct ib_cq *cq, int budget);
2993
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994/**
2995 * ib_create_cq - Creates a CQ on the specified device.
2996 * @device: The device on which to create the CQ.
2997 * @comp_handler: A user-specified callback that is invoked when a
2998 * completion event occurs on the CQ.
2999 * @event_handler: A user-specified callback that is invoked when an
3000 * asynchronous event not associated with a completion occurs on the CQ.
3001 * @cq_context: Context associated with the CQ returned to the user via
3002 * the associated completion and event handlers.
Matan Barak8e372102015-06-11 16:35:21 +03003003 * @cq_attr: The attributes the CQ should be created upon.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004 *
3005 * Users can examine the cq structure to determine the actual CQ size.
3006 */
3007struct ib_cq *ib_create_cq(struct ib_device *device,
3008 ib_comp_handler comp_handler,
3009 void (*event_handler)(struct ib_event *, void *),
Matan Barak8e372102015-06-11 16:35:21 +03003010 void *cq_context,
3011 const struct ib_cq_init_attr *cq_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012
3013/**
3014 * ib_resize_cq - Modifies the capacity of the CQ.
3015 * @cq: The CQ to resize.
3016 * @cqe: The minimum size of the CQ.
3017 *
3018 * Users can examine the cq structure to determine the actual CQ size.
3019 */
3020int ib_resize_cq(struct ib_cq *cq, int cqe);
3021
3022/**
Eli Cohen2dd57162008-04-16 21:09:33 -07003023 * ib_modify_cq - Modifies moderation params of the CQ
3024 * @cq: The CQ to modify.
3025 * @cq_count: number of CQEs that will trigger an event
3026 * @cq_period: max period of time in usec before triggering an event
3027 *
3028 */
3029int ib_modify_cq(struct ib_cq *cq, u16 cq_count, u16 cq_period);
3030
3031/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 * ib_destroy_cq - Destroys the specified CQ.
3033 * @cq: The CQ to destroy.
3034 */
3035int ib_destroy_cq(struct ib_cq *cq);
3036
3037/**
3038 * ib_poll_cq - poll a CQ for completion(s)
3039 * @cq:the CQ being polled
3040 * @num_entries:maximum number of completions to return
3041 * @wc:array of at least @num_entries &struct ib_wc where completions
3042 * will be returned
3043 *
3044 * Poll a CQ for (possibly multiple) completions. If the return value
3045 * is < 0, an error occurred. If the return value is >= 0, it is the
3046 * number of completions returned. If the return value is
3047 * non-negative and < num_entries, then the CQ was emptied.
3048 */
3049static inline int ib_poll_cq(struct ib_cq *cq, int num_entries,
3050 struct ib_wc *wc)
3051{
3052 return cq->device->poll_cq(cq, num_entries, wc);
3053}
3054
3055/**
3056 * ib_peek_cq - Returns the number of unreaped completions currently
3057 * on the specified CQ.
3058 * @cq: The CQ to peek.
3059 * @wc_cnt: A minimum number of unreaped completions to check for.
3060 *
3061 * If the number of unreaped completions is greater than or equal to wc_cnt,
3062 * this function returns wc_cnt, otherwise, it returns the actual number of
3063 * unreaped completions.
3064 */
3065int ib_peek_cq(struct ib_cq *cq, int wc_cnt);
3066
3067/**
3068 * ib_req_notify_cq - Request completion notification on a CQ.
3069 * @cq: The CQ to generate an event for.
Roland Dreiered23a722007-05-06 21:02:48 -07003070 * @flags:
3071 * Must contain exactly one of %IB_CQ_SOLICITED or %IB_CQ_NEXT_COMP
3072 * to request an event on the next solicited event or next work
3073 * completion at any type, respectively. %IB_CQ_REPORT_MISSED_EVENTS
3074 * may also be |ed in to request a hint about missed events, as
3075 * described below.
3076 *
3077 * Return Value:
3078 * < 0 means an error occurred while requesting notification
3079 * == 0 means notification was requested successfully, and if
3080 * IB_CQ_REPORT_MISSED_EVENTS was passed in, then no events
3081 * were missed and it is safe to wait for another event. In
3082 * this case is it guaranteed that any work completions added
3083 * to the CQ since the last CQ poll will trigger a completion
3084 * notification event.
3085 * > 0 is only returned if IB_CQ_REPORT_MISSED_EVENTS was passed
3086 * in. It means that the consumer must poll the CQ again to
3087 * make sure it is empty to avoid missing an event because of a
3088 * race between requesting notification and an entry being
3089 * added to the CQ. This return value means it is possible
3090 * (but not guaranteed) that a work completion has been added
3091 * to the CQ since the last poll without triggering a
3092 * completion notification event.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093 */
3094static inline int ib_req_notify_cq(struct ib_cq *cq,
Roland Dreiered23a722007-05-06 21:02:48 -07003095 enum ib_cq_notify_flags flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096{
Roland Dreiered23a722007-05-06 21:02:48 -07003097 return cq->device->req_notify_cq(cq, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098}
3099
3100/**
3101 * ib_req_ncomp_notif - Request completion notification when there are
3102 * at least the specified number of unreaped completions on the CQ.
3103 * @cq: The CQ to generate an event for.
3104 * @wc_cnt: The number of unreaped completions that should be on the
3105 * CQ before an event is generated.
3106 */
3107static inline int ib_req_ncomp_notif(struct ib_cq *cq, int wc_cnt)
3108{
3109 return cq->device->req_ncomp_notif ?
3110 cq->device->req_ncomp_notif(cq, wc_cnt) :
3111 -ENOSYS;
3112}
3113
3114/**
Ralph Campbell9b513092006-12-12 14:27:41 -08003115 * ib_dma_mapping_error - check a DMA addr for error
3116 * @dev: The device for which the dma_addr was created
3117 * @dma_addr: The DMA address to check
3118 */
3119static inline int ib_dma_mapping_error(struct ib_device *dev, u64 dma_addr)
3120{
Bart Van Assche0957c292017-03-07 22:56:53 +00003121 return dma_mapping_error(dev->dma_device, dma_addr);
Ralph Campbell9b513092006-12-12 14:27:41 -08003122}
3123
3124/**
3125 * ib_dma_map_single - Map a kernel virtual address to DMA address
3126 * @dev: The device for which the dma_addr is to be created
3127 * @cpu_addr: The kernel virtual address
3128 * @size: The size of the region in bytes
3129 * @direction: The direction of the DMA
3130 */
3131static inline u64 ib_dma_map_single(struct ib_device *dev,
3132 void *cpu_addr, size_t size,
3133 enum dma_data_direction direction)
3134{
Bart Van Assche0957c292017-03-07 22:56:53 +00003135 return dma_map_single(dev->dma_device, cpu_addr, size, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003136}
3137
3138/**
3139 * ib_dma_unmap_single - Destroy a mapping created by ib_dma_map_single()
3140 * @dev: The device for which the DMA address was created
3141 * @addr: The DMA address
3142 * @size: The size of the region in bytes
3143 * @direction: The direction of the DMA
3144 */
3145static inline void ib_dma_unmap_single(struct ib_device *dev,
3146 u64 addr, size_t size,
3147 enum dma_data_direction direction)
3148{
Bart Van Assche0957c292017-03-07 22:56:53 +00003149 dma_unmap_single(dev->dma_device, addr, size, direction);
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003150}
3151
Ralph Campbell9b513092006-12-12 14:27:41 -08003152/**
3153 * ib_dma_map_page - Map a physical page to DMA address
3154 * @dev: The device for which the dma_addr is to be created
3155 * @page: The page to be mapped
3156 * @offset: The offset within the page
3157 * @size: The size of the region in bytes
3158 * @direction: The direction of the DMA
3159 */
3160static inline u64 ib_dma_map_page(struct ib_device *dev,
3161 struct page *page,
3162 unsigned long offset,
3163 size_t size,
3164 enum dma_data_direction direction)
3165{
Bart Van Assche0957c292017-03-07 22:56:53 +00003166 return dma_map_page(dev->dma_device, page, offset, size, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003167}
3168
3169/**
3170 * ib_dma_unmap_page - Destroy a mapping created by ib_dma_map_page()
3171 * @dev: The device for which the DMA address was created
3172 * @addr: The DMA address
3173 * @size: The size of the region in bytes
3174 * @direction: The direction of the DMA
3175 */
3176static inline void ib_dma_unmap_page(struct ib_device *dev,
3177 u64 addr, size_t size,
3178 enum dma_data_direction direction)
3179{
Bart Van Assche0957c292017-03-07 22:56:53 +00003180 dma_unmap_page(dev->dma_device, addr, size, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003181}
3182
3183/**
3184 * ib_dma_map_sg - Map a scatter/gather list to DMA addresses
3185 * @dev: The device for which the DMA addresses are to be created
3186 * @sg: The array of scatter/gather entries
3187 * @nents: The number of scatter/gather entries
3188 * @direction: The direction of the DMA
3189 */
3190static inline int ib_dma_map_sg(struct ib_device *dev,
3191 struct scatterlist *sg, int nents,
3192 enum dma_data_direction direction)
3193{
Bart Van Assche0957c292017-03-07 22:56:53 +00003194 return dma_map_sg(dev->dma_device, sg, nents, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003195}
3196
3197/**
3198 * ib_dma_unmap_sg - Unmap a scatter/gather list of DMA addresses
3199 * @dev: The device for which the DMA addresses were created
3200 * @sg: The array of scatter/gather entries
3201 * @nents: The number of scatter/gather entries
3202 * @direction: The direction of the DMA
3203 */
3204static inline void ib_dma_unmap_sg(struct ib_device *dev,
3205 struct scatterlist *sg, int nents,
3206 enum dma_data_direction direction)
3207{
Bart Van Assche0957c292017-03-07 22:56:53 +00003208 dma_unmap_sg(dev->dma_device, sg, nents, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003209}
3210
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003211static inline int ib_dma_map_sg_attrs(struct ib_device *dev,
3212 struct scatterlist *sg, int nents,
3213 enum dma_data_direction direction,
Krzysztof Kozlowski00085f12016-08-03 13:46:00 -07003214 unsigned long dma_attrs)
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003215{
Bart Van Assche0957c292017-03-07 22:56:53 +00003216 return dma_map_sg_attrs(dev->dma_device, sg, nents, direction,
3217 dma_attrs);
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003218}
3219
3220static inline void ib_dma_unmap_sg_attrs(struct ib_device *dev,
3221 struct scatterlist *sg, int nents,
3222 enum dma_data_direction direction,
Krzysztof Kozlowski00085f12016-08-03 13:46:00 -07003223 unsigned long dma_attrs)
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003224{
Bart Van Assche0957c292017-03-07 22:56:53 +00003225 dma_unmap_sg_attrs(dev->dma_device, sg, nents, direction, dma_attrs);
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003226}
Ralph Campbell9b513092006-12-12 14:27:41 -08003227/**
3228 * ib_sg_dma_address - Return the DMA address from a scatter/gather entry
3229 * @dev: The device for which the DMA addresses were created
3230 * @sg: The scatter/gather entry
Mike Marciniszynea58a592014-03-28 13:26:59 -04003231 *
3232 * Note: this function is obsolete. To do: change all occurrences of
3233 * ib_sg_dma_address() into sg_dma_address().
Ralph Campbell9b513092006-12-12 14:27:41 -08003234 */
3235static inline u64 ib_sg_dma_address(struct ib_device *dev,
3236 struct scatterlist *sg)
3237{
Ben Collinsd1998ef2006-12-13 22:10:05 -05003238 return sg_dma_address(sg);
Ralph Campbell9b513092006-12-12 14:27:41 -08003239}
3240
3241/**
3242 * ib_sg_dma_len - Return the DMA length from a scatter/gather entry
3243 * @dev: The device for which the DMA addresses were created
3244 * @sg: The scatter/gather entry
Mike Marciniszynea58a592014-03-28 13:26:59 -04003245 *
3246 * Note: this function is obsolete. To do: change all occurrences of
3247 * ib_sg_dma_len() into sg_dma_len().
Ralph Campbell9b513092006-12-12 14:27:41 -08003248 */
3249static inline unsigned int ib_sg_dma_len(struct ib_device *dev,
3250 struct scatterlist *sg)
3251{
Ben Collinsd1998ef2006-12-13 22:10:05 -05003252 return sg_dma_len(sg);
Ralph Campbell9b513092006-12-12 14:27:41 -08003253}
3254
3255/**
3256 * ib_dma_sync_single_for_cpu - Prepare DMA region to be accessed by CPU
3257 * @dev: The device for which the DMA address was created
3258 * @addr: The DMA address
3259 * @size: The size of the region in bytes
3260 * @dir: The direction of the DMA
3261 */
3262static inline void ib_dma_sync_single_for_cpu(struct ib_device *dev,
3263 u64 addr,
3264 size_t size,
3265 enum dma_data_direction dir)
3266{
Bart Van Assche0957c292017-03-07 22:56:53 +00003267 dma_sync_single_for_cpu(dev->dma_device, addr, size, dir);
Ralph Campbell9b513092006-12-12 14:27:41 -08003268}
3269
3270/**
3271 * ib_dma_sync_single_for_device - Prepare DMA region to be accessed by device
3272 * @dev: The device for which the DMA address was created
3273 * @addr: The DMA address
3274 * @size: The size of the region in bytes
3275 * @dir: The direction of the DMA
3276 */
3277static inline void ib_dma_sync_single_for_device(struct ib_device *dev,
3278 u64 addr,
3279 size_t size,
3280 enum dma_data_direction dir)
3281{
Bart Van Assche0957c292017-03-07 22:56:53 +00003282 dma_sync_single_for_device(dev->dma_device, addr, size, dir);
Ralph Campbell9b513092006-12-12 14:27:41 -08003283}
3284
3285/**
3286 * ib_dma_alloc_coherent - Allocate memory and map it for DMA
3287 * @dev: The device for which the DMA address is requested
3288 * @size: The size of the region to allocate in bytes
3289 * @dma_handle: A pointer for returning the DMA address of the region
3290 * @flag: memory allocator flags
3291 */
3292static inline void *ib_dma_alloc_coherent(struct ib_device *dev,
3293 size_t size,
Bart Van Assched43dbac2017-01-20 13:04:10 -08003294 dma_addr_t *dma_handle,
Ralph Campbell9b513092006-12-12 14:27:41 -08003295 gfp_t flag)
3296{
Bart Van Assche0957c292017-03-07 22:56:53 +00003297 return dma_alloc_coherent(dev->dma_device, size, dma_handle, flag);
Ralph Campbell9b513092006-12-12 14:27:41 -08003298}
3299
3300/**
3301 * ib_dma_free_coherent - Free memory allocated by ib_dma_alloc_coherent()
3302 * @dev: The device for which the DMA addresses were allocated
3303 * @size: The size of the region
3304 * @cpu_addr: the address returned by ib_dma_alloc_coherent()
3305 * @dma_handle: the DMA address returned by ib_dma_alloc_coherent()
3306 */
3307static inline void ib_dma_free_coherent(struct ib_device *dev,
3308 size_t size, void *cpu_addr,
Bart Van Assched43dbac2017-01-20 13:04:10 -08003309 dma_addr_t dma_handle)
Ralph Campbell9b513092006-12-12 14:27:41 -08003310{
Bart Van Assche0957c292017-03-07 22:56:53 +00003311 dma_free_coherent(dev->dma_device, size, cpu_addr, dma_handle);
Ralph Campbell9b513092006-12-12 14:27:41 -08003312}
3313
3314/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003315 * ib_dereg_mr - Deregisters a memory region and removes it from the
3316 * HCA translation table.
3317 * @mr: The memory region to deregister.
Shani Michaeli7083e422013-02-06 16:19:12 +00003318 *
3319 * This function can fail, if the memory region has memory windows bound to it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 */
3321int ib_dereg_mr(struct ib_mr *mr);
3322
Sagi Grimberg9bee1782015-07-30 10:32:35 +03003323struct ib_mr *ib_alloc_mr(struct ib_pd *pd,
3324 enum ib_mr_type mr_type,
3325 u32 max_num_sg);
Steve Wise00f7ec32008-07-14 23:48:45 -07003326
3327/**
Steve Wise00f7ec32008-07-14 23:48:45 -07003328 * ib_update_fast_reg_key - updates the key portion of the fast_reg MR
3329 * R_Key and L_Key.
3330 * @mr - struct ib_mr pointer to be updated.
3331 * @newkey - new key to be used.
3332 */
3333static inline void ib_update_fast_reg_key(struct ib_mr *mr, u8 newkey)
3334{
3335 mr->lkey = (mr->lkey & 0xffffff00) | newkey;
3336 mr->rkey = (mr->rkey & 0xffffff00) | newkey;
3337}
3338
3339/**
Shani Michaeli7083e422013-02-06 16:19:12 +00003340 * ib_inc_rkey - increments the key portion of the given rkey. Can be used
3341 * for calculating a new rkey for type 2 memory windows.
3342 * @rkey - the rkey to increment.
3343 */
3344static inline u32 ib_inc_rkey(u32 rkey)
3345{
3346 const u32 mask = 0x000000ff;
3347 return ((rkey + 1) & mask) | (rkey & ~mask);
3348}
3349
3350/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003351 * ib_alloc_fmr - Allocates a unmapped fast memory region.
3352 * @pd: The protection domain associated with the unmapped region.
3353 * @mr_access_flags: Specifies the memory access rights.
3354 * @fmr_attr: Attributes of the unmapped region.
3355 *
3356 * A fast memory region must be mapped before it can be used as part of
3357 * a work request.
3358 */
3359struct ib_fmr *ib_alloc_fmr(struct ib_pd *pd,
3360 int mr_access_flags,
3361 struct ib_fmr_attr *fmr_attr);
3362
3363/**
3364 * ib_map_phys_fmr - Maps a list of physical pages to a fast memory region.
3365 * @fmr: The fast memory region to associate with the pages.
3366 * @page_list: An array of physical pages to map to the fast memory region.
3367 * @list_len: The number of pages in page_list.
3368 * @iova: The I/O virtual address to use with the mapped region.
3369 */
3370static inline int ib_map_phys_fmr(struct ib_fmr *fmr,
3371 u64 *page_list, int list_len,
3372 u64 iova)
3373{
3374 return fmr->device->map_phys_fmr(fmr, page_list, list_len, iova);
3375}
3376
3377/**
3378 * ib_unmap_fmr - Removes the mapping from a list of fast memory regions.
3379 * @fmr_list: A linked list of fast memory regions to unmap.
3380 */
3381int ib_unmap_fmr(struct list_head *fmr_list);
3382
3383/**
3384 * ib_dealloc_fmr - Deallocates a fast memory region.
3385 * @fmr: The fast memory region to deallocate.
3386 */
3387int ib_dealloc_fmr(struct ib_fmr *fmr);
3388
3389/**
3390 * ib_attach_mcast - Attaches the specified QP to a multicast group.
3391 * @qp: QP to attach to the multicast group. The QP must be type
3392 * IB_QPT_UD.
3393 * @gid: Multicast group GID.
3394 * @lid: Multicast group LID in host byte order.
3395 *
3396 * In order to send and receive multicast packets, subnet
3397 * administration must have created the multicast group and configured
3398 * the fabric appropriately. The port associated with the specified
3399 * QP must also be a member of the multicast group.
3400 */
3401int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
3402
3403/**
3404 * ib_detach_mcast - Detaches the specified QP from a multicast group.
3405 * @qp: QP to detach from the multicast group.
3406 * @gid: Multicast group GID.
3407 * @lid: Multicast group LID in host byte order.
3408 */
3409int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
3410
Sean Hefty59991f92011-05-23 17:52:46 -07003411/**
3412 * ib_alloc_xrcd - Allocates an XRC domain.
3413 * @device: The device on which to allocate the XRC domain.
3414 */
3415struct ib_xrcd *ib_alloc_xrcd(struct ib_device *device);
3416
3417/**
3418 * ib_dealloc_xrcd - Deallocates an XRC domain.
3419 * @xrcd: The XRC domain to deallocate.
3420 */
3421int ib_dealloc_xrcd(struct ib_xrcd *xrcd);
3422
Hadar Hen Zion319a4412013-08-07 14:01:59 +03003423struct ib_flow *ib_create_flow(struct ib_qp *qp,
3424 struct ib_flow_attr *flow_attr, int domain);
3425int ib_destroy_flow(struct ib_flow *flow_id);
3426
Eli Cohen1c636f82013-10-31 15:26:32 +02003427static inline int ib_check_mr_access(int flags)
3428{
3429 /*
3430 * Local write permission is required if remote write or
3431 * remote atomic permission is also requested.
3432 */
3433 if (flags & (IB_ACCESS_REMOTE_ATOMIC | IB_ACCESS_REMOTE_WRITE) &&
3434 !(flags & IB_ACCESS_LOCAL_WRITE))
3435 return -EINVAL;
3436
3437 return 0;
3438}
3439
Sagi Grimberg1b01d332014-02-23 14:19:05 +02003440/**
3441 * ib_check_mr_status: lightweight check of MR status.
3442 * This routine may provide status checks on a selected
3443 * ib_mr. first use is for signature status check.
3444 *
3445 * @mr: A memory region.
3446 * @check_mask: Bitmask of which checks to perform from
3447 * ib_mr_status_check enumeration.
3448 * @mr_status: The container of relevant status checks.
3449 * failed checks will be indicated in the status bitmask
3450 * and the relevant info shall be in the error item.
3451 */
3452int ib_check_mr_status(struct ib_mr *mr, u32 check_mask,
3453 struct ib_mr_status *mr_status);
3454
Yotam Kenneth9268f722015-07-30 17:50:15 +03003455struct net_device *ib_get_net_dev_by_params(struct ib_device *dev, u8 port,
3456 u16 pkey, const union ib_gid *gid,
3457 const struct sockaddr *addr);
Yishai Hadas5fd251c2016-05-23 15:20:48 +03003458struct ib_wq *ib_create_wq(struct ib_pd *pd,
3459 struct ib_wq_init_attr *init_attr);
3460int ib_destroy_wq(struct ib_wq *wq);
3461int ib_modify_wq(struct ib_wq *wq, struct ib_wq_attr *attr,
3462 u32 wq_attr_mask);
Yishai Hadas6d397862016-05-23 15:20:51 +03003463struct ib_rwq_ind_table *ib_create_rwq_ind_table(struct ib_device *device,
3464 struct ib_rwq_ind_table_init_attr*
3465 wq_ind_table_init_attr);
3466int ib_destroy_rwq_ind_table(struct ib_rwq_ind_table *wq_ind_table);
Yotam Kenneth9268f722015-07-30 17:50:15 +03003467
Christoph Hellwigff2ba992016-05-03 18:01:04 +02003468int ib_map_mr_sg(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
Bart Van Assche9aa8b322016-05-12 10:49:15 -07003469 unsigned int *sg_offset, unsigned int page_size);
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03003470
3471static inline int
Christoph Hellwigff2ba992016-05-03 18:01:04 +02003472ib_map_mr_sg_zbva(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
Bart Van Assche9aa8b322016-05-12 10:49:15 -07003473 unsigned int *sg_offset, unsigned int page_size)
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03003474{
3475 int n;
3476
Christoph Hellwigff2ba992016-05-03 18:01:04 +02003477 n = ib_map_mr_sg(mr, sg, sg_nents, sg_offset, page_size);
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03003478 mr->iova = 0;
3479
3480 return n;
3481}
3482
Christoph Hellwigff2ba992016-05-03 18:01:04 +02003483int ib_sg_to_pages(struct ib_mr *mr, struct scatterlist *sgl, int sg_nents,
Bart Van Assche9aa8b322016-05-12 10:49:15 -07003484 unsigned int *sg_offset, int (*set_page)(struct ib_mr *, u64));
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03003485
Steve Wise765d6772016-02-17 08:15:41 -08003486void ib_drain_rq(struct ib_qp *qp);
3487void ib_drain_sq(struct ib_qp *qp);
3488void ib_drain_qp(struct ib_qp *qp);
Moni Shoua850d8fd2016-11-10 11:30:56 +02003489
Moni Shouac90ea9d2016-11-23 08:23:22 +02003490int ib_resolve_eth_dmac(struct ib_device *device,
Dasaratharaman Chandramouli90898852017-04-29 14:41:18 -04003491 struct rdma_ah_attr *ah_attr);
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04003492
3493static inline u8 *rdma_ah_retrieve_dmac(struct rdma_ah_attr *attr)
3494{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04003495 if (attr->type == RDMA_AH_ATTR_TYPE_ROCE)
3496 return attr->roce.dmac;
3497 return NULL;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04003498}
3499
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04003500static inline void rdma_ah_set_dlid(struct rdma_ah_attr *attr, u32 dlid)
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04003501{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04003502 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04003503 attr->ib.dlid = (u16)dlid;
3504 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
3505 attr->opa.dlid = dlid;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04003506}
3507
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04003508static inline u32 rdma_ah_get_dlid(const struct rdma_ah_attr *attr)
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04003509{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04003510 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
3511 return attr->ib.dlid;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04003512 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
3513 return attr->opa.dlid;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04003514 return 0;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04003515}
3516
3517static inline void rdma_ah_set_sl(struct rdma_ah_attr *attr, u8 sl)
3518{
3519 attr->sl = sl;
3520}
3521
3522static inline u8 rdma_ah_get_sl(const struct rdma_ah_attr *attr)
3523{
3524 return attr->sl;
3525}
3526
3527static inline void rdma_ah_set_path_bits(struct rdma_ah_attr *attr,
3528 u8 src_path_bits)
3529{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04003530 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
3531 attr->ib.src_path_bits = src_path_bits;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04003532 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
3533 attr->opa.src_path_bits = src_path_bits;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04003534}
3535
3536static inline u8 rdma_ah_get_path_bits(const struct rdma_ah_attr *attr)
3537{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04003538 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
3539 return attr->ib.src_path_bits;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04003540 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
3541 return attr->opa.src_path_bits;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04003542 return 0;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04003543}
3544
3545static inline void rdma_ah_set_port_num(struct rdma_ah_attr *attr, u8 port_num)
3546{
3547 attr->port_num = port_num;
3548}
3549
3550static inline u8 rdma_ah_get_port_num(const struct rdma_ah_attr *attr)
3551{
3552 return attr->port_num;
3553}
3554
3555static inline void rdma_ah_set_static_rate(struct rdma_ah_attr *attr,
3556 u8 static_rate)
3557{
3558 attr->static_rate = static_rate;
3559}
3560
3561static inline u8 rdma_ah_get_static_rate(const struct rdma_ah_attr *attr)
3562{
3563 return attr->static_rate;
3564}
3565
3566static inline void rdma_ah_set_ah_flags(struct rdma_ah_attr *attr,
3567 enum ib_ah_flags flag)
3568{
3569 attr->ah_flags = flag;
3570}
3571
3572static inline enum ib_ah_flags
3573 rdma_ah_get_ah_flags(const struct rdma_ah_attr *attr)
3574{
3575 return attr->ah_flags;
3576}
3577
3578static inline const struct ib_global_route
3579 *rdma_ah_read_grh(const struct rdma_ah_attr *attr)
3580{
3581 return &attr->grh;
3582}
3583
3584/*To retrieve and modify the grh */
3585static inline struct ib_global_route
3586 *rdma_ah_retrieve_grh(struct rdma_ah_attr *attr)
3587{
3588 return &attr->grh;
3589}
3590
3591static inline void rdma_ah_set_dgid_raw(struct rdma_ah_attr *attr, void *dgid)
3592{
3593 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
3594
3595 memcpy(grh->dgid.raw, dgid, sizeof(grh->dgid));
3596}
3597
3598static inline void rdma_ah_set_subnet_prefix(struct rdma_ah_attr *attr,
3599 __be64 prefix)
3600{
3601 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
3602
3603 grh->dgid.global.subnet_prefix = prefix;
3604}
3605
3606static inline void rdma_ah_set_interface_id(struct rdma_ah_attr *attr,
3607 __be64 if_id)
3608{
3609 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
3610
3611 grh->dgid.global.interface_id = if_id;
3612}
3613
3614static inline void rdma_ah_set_grh(struct rdma_ah_attr *attr,
3615 union ib_gid *dgid, u32 flow_label,
3616 u8 sgid_index, u8 hop_limit,
3617 u8 traffic_class)
3618{
3619 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
3620
3621 attr->ah_flags = IB_AH_GRH;
3622 if (dgid)
3623 grh->dgid = *dgid;
3624 grh->flow_label = flow_label;
3625 grh->sgid_index = sgid_index;
3626 grh->hop_limit = hop_limit;
3627 grh->traffic_class = traffic_class;
3628}
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04003629
3630/*Get AH type */
3631static inline enum rdma_ah_attr_type rdma_ah_find_type(struct ib_device *dev,
3632 u32 port_num)
3633{
3634 if ((rdma_protocol_roce(dev, port_num)) ||
3635 (rdma_protocol_iwarp(dev, port_num)))
3636 return RDMA_AH_ATTR_TYPE_ROCE;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04003637 else if ((rdma_protocol_ib(dev, port_num)) &&
3638 (rdma_cap_opa_ah(dev, port_num)))
3639 return RDMA_AH_ATTR_TYPE_OPA;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04003640 else
3641 return RDMA_AH_ATTR_TYPE_IB;
3642}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003643#endif /* IB_VERBS_H */