include/rdma/ib_verbs.h

   1 /*
   2  * Copyright (c) 2004 Mellanox Technologies Ltd.  All rights reserved.
   3  * Copyright (c) 2004 Infinicon Corporation.  All rights reserved.
   4  * Copyright (c) 2004 Intel Corporation.  All rights reserved.
   5  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
   6  * Copyright (c) 2004 Voltaire Corporation.  All rights reserved.
   7  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
   8  * Copyright (c) 2005, 2006, 2007 Cisco Systems.  All rights reserved.
   9  *
  10  * This software is available to you under a choice of one of two
  11  * licenses.  You may choose to be licensed under the terms of the GNU
  12  * General Public License (GPL) Version 2, available from the file
  13  * COPYING in the main directory of this source tree, or the
  14  * OpenIB.org BSD license below:
  15  *
  16  *     Redistribution and use in source and binary forms, with or
  17  *     without modification, are permitted provided that the following
  18  *     conditions are met:
  19  *
  20  *      - Redistributions of source code must retain the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer.
  23  *
  24  *      - Redistributions in binary form must reproduce the above
  25  *        copyright notice, this list of conditions and the following
  26  *        disclaimer in the documentation and/or other materials
  27  *        provided with the distribution.
  28  *
  29  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  30  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  31  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  32  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  33  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  34  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  35  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  36  * SOFTWARE.
  37  */
  38
  39 #if !defined(IB_VERBS_H)
  40 #define IB_VERBS_H
  41
  42 #include <linux/types.h>
  43 #include <linux/device.h>
  44 #include <linux/dma-mapping.h>
  45 #include <linux/kref.h>
  46 #include <linux/list.h>
  47 #include <linux/rwsem.h>
  48 #include <linux/workqueue.h>
  49 #include <linux/irq_poll.h>
  50 #include <uapi/linux/if_ether.h>
  51 #include <net/ipv6.h>
  52 #include <net/ip.h>
  53 #include <linux/string.h>
  54 #include <linux/slab.h>
  55 #include <linux/netdevice.h>
  56 #include <linux/refcount.h>
  57 #include <linux/if_link.h>
  58 #include <linux/atomic.h>
  59 #include <linux/mmu_notifier.h>
  60 #include <linux/uaccess.h>
  61 #include <linux/cgroup_rdma.h>
  62 #include <linux/irqflags.h>
  63 #include <linux/preempt.h>
  64 #include <linux/dim.h>
  65 #include <uapi/rdma/ib_user_verbs.h>
  66 #include <rdma/rdma_counter.h>
  67 #include <rdma/restrack.h>
  68 #include <rdma/signature.h>
  69 #include <uapi/rdma/rdma_user_ioctl.h>
  70 #include <uapi/rdma/ib_user_ioctl_verbs.h>
  71
  72 #define IB_FW_VERSION_NAME_MAX  ETHTOOL_FWVERS_LEN
  73
  74 struct ib_umem_odp;
  75 struct ib_uqp_object;
  76 struct ib_usrq_object;
  77 struct ib_uwq_object;
  78
  79 extern struct workqueue_struct *ib_wq;
  80 extern struct workqueue_struct *ib_comp_wq;
  81 extern struct workqueue_struct *ib_comp_unbound_wq;
  82
  83 struct ib_ucq_object;
  84
  85 __printf(3, 4) __cold
  86 void ibdev_printk(const char *level, const struct ib_device *ibdev,
  87                   const char *format, ...);
  88 __printf(2, 3) __cold
  89 void ibdev_emerg(const struct ib_device *ibdev, const char *format, ...);
  90 __printf(2, 3) __cold
  91 void ibdev_alert(const struct ib_device *ibdev, const char *format, ...);
  92 __printf(2, 3) __cold
  93 void ibdev_crit(const struct ib_device *ibdev, const char *format, ...);
  94 __printf(2, 3) __cold
  95 void ibdev_err(const struct ib_device *ibdev, const char *format, ...);
  96 __printf(2, 3) __cold
  97 void ibdev_warn(const struct ib_device *ibdev, const char *format, ...);
  98 __printf(2, 3) __cold
  99 void ibdev_notice(const struct ib_device *ibdev, const char *format, ...);
 100 __printf(2, 3) __cold
 101 void ibdev_info(const struct ib_device *ibdev, const char *format, ...);
 102
 103 #if defined(CONFIG_DYNAMIC_DEBUG)
 104 #define ibdev_dbg(__dev, format, args...)                       \
 105         dynamic_ibdev_dbg(__dev, format, ##args)
 106 #else
 107 __printf(2, 3) __cold
 108 static inline
 109 void ibdev_dbg(const struct ib_device *ibdev, const char *format, ...) {}
 110 #endif
 111
 112 #define ibdev_level_ratelimited(ibdev_level, ibdev, fmt, ...)           \
 113 do {                                                                    \
 114         static DEFINE_RATELIMIT_STATE(_rs,                              \
 115                                       DEFAULT_RATELIMIT_INTERVAL,       \
 116                                       DEFAULT_RATELIMIT_BURST);         \
 117         if (__ratelimit(&_rs))                                          \
 118                 ibdev_level(ibdev, fmt, ##__VA_ARGS__);                 \
 119 } while (0)
 120
 121 #define ibdev_emerg_ratelimited(ibdev, fmt, ...) \
 122         ibdev_level_ratelimited(ibdev_emerg, ibdev, fmt, ##__VA_ARGS__)
 123 #define ibdev_alert_ratelimited(ibdev, fmt, ...) \
 124         ibdev_level_ratelimited(ibdev_alert, ibdev, fmt, ##__VA_ARGS__)
 125 #define ibdev_crit_ratelimited(ibdev, fmt, ...) \
 126         ibdev_level_ratelimited(ibdev_crit, ibdev, fmt, ##__VA_ARGS__)
 127 #define ibdev_err_ratelimited(ibdev, fmt, ...) \
 128         ibdev_level_ratelimited(ibdev_err, ibdev, fmt, ##__VA_ARGS__)
 129 #define ibdev_warn_ratelimited(ibdev, fmt, ...) \
 130         ibdev_level_ratelimited(ibdev_warn, ibdev, fmt, ##__VA_ARGS__)
 131 #define ibdev_notice_ratelimited(ibdev, fmt, ...) \
 132         ibdev_level_ratelimited(ibdev_notice, ibdev, fmt, ##__VA_ARGS__)
 133 #define ibdev_info_ratelimited(ibdev, fmt, ...) \
 134         ibdev_level_ratelimited(ibdev_info, ibdev, fmt, ##__VA_ARGS__)
 135
 136 #if defined(CONFIG_DYNAMIC_DEBUG)
 137 /* descriptor check is first to prevent flooding with "callbacks suppressed" */
 138 #define ibdev_dbg_ratelimited(ibdev, fmt, ...)                          \
 139 do {                                                                    \
 140         static DEFINE_RATELIMIT_STATE(_rs,                              \
 141                                       DEFAULT_RATELIMIT_INTERVAL,       \
 142                                       DEFAULT_RATELIMIT_BURST);         \
 143         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);                 \
 144         if (DYNAMIC_DEBUG_BRANCH(descriptor) && __ratelimit(&_rs))      \
 145                 __dynamic_ibdev_dbg(&descriptor, ibdev, fmt,            \
 146                                     ##__VA_ARGS__);                     \
 147 } while (0)
 148 #else
 149 __printf(2, 3) __cold
 150 static inline
 151 void ibdev_dbg_ratelimited(const struct ib_device *ibdev, const char *format, ...) {}
 152 #endif
 153
 154 union ib_gid {
 155         u8      raw[16];
 156         struct {
 157                 __be64  subnet_prefix;
 158                 __be64  interface_id;
 159         } global;
 160 };
 161
 162 extern union ib_gid zgid;
 163
 164 enum ib_gid_type {
 165         /* If link layer is Ethernet, this is RoCE V1 */
 166         IB_GID_TYPE_IB        = 0,
 167         IB_GID_TYPE_ROCE      = 0,
 168         IB_GID_TYPE_ROCE_UDP_ENCAP = 1,
 169         IB_GID_TYPE_SIZE
 170 };
 171
 172 #define ROCE_V2_UDP_DPORT      4791
 173 struct ib_gid_attr {
 174         struct net_device __rcu *ndev;
 175         struct ib_device        *device;
 176         union ib_gid            gid;
 177         enum ib_gid_type        gid_type;
 178         u16                     index;
 179         u8                      port_num;
 180 };
 181
 182 enum {
 183         /* set the local administered indication */
 184         IB_SA_WELL_KNOWN_GUID   = BIT_ULL(57) | 2,
 185 };
 186
 187 enum rdma_transport_type {
 188         RDMA_TRANSPORT_IB,
 189         RDMA_TRANSPORT_IWARP,
 190         RDMA_TRANSPORT_USNIC,
 191         RDMA_TRANSPORT_USNIC_UDP,
 192         RDMA_TRANSPORT_UNSPECIFIED,
 193 };
 194
 195 enum rdma_protocol_type {
 196         RDMA_PROTOCOL_IB,
 197         RDMA_PROTOCOL_IBOE,
 198         RDMA_PROTOCOL_IWARP,
 199         RDMA_PROTOCOL_USNIC_UDP
 200 };
 201
 202 __attribute_const__ enum rdma_transport_type
 203 rdma_node_get_transport(unsigned int node_type);
 204
 205 enum rdma_network_type {
 206         RDMA_NETWORK_IB,
 207         RDMA_NETWORK_ROCE_V1 = RDMA_NETWORK_IB,
 208         RDMA_NETWORK_IPV4,
 209         RDMA_NETWORK_IPV6
 210 };
 211
 212 static inline enum ib_gid_type ib_network_to_gid_type(enum rdma_network_type network_type)
 213 {
 214         if (network_type == RDMA_NETWORK_IPV4 ||
 215             network_type == RDMA_NETWORK_IPV6)
 216                 return IB_GID_TYPE_ROCE_UDP_ENCAP;
 217
 218         /* IB_GID_TYPE_IB same as RDMA_NETWORK_ROCE_V1 */
 219         return IB_GID_TYPE_IB;
 220 }
 221
 222 static inline enum rdma_network_type
 223 rdma_gid_attr_network_type(const struct ib_gid_attr *attr)
 224 {
 225         if (attr->gid_type == IB_GID_TYPE_IB)
 226                 return RDMA_NETWORK_IB;
 227
 228         if (ipv6_addr_v4mapped((struct in6_addr *)&attr->gid))
 229                 return RDMA_NETWORK_IPV4;
 230         else
 231                 return RDMA_NETWORK_IPV6;
 232 }
 233
 234 enum rdma_link_layer {
 235         IB_LINK_LAYER_UNSPECIFIED,
 236         IB_LINK_LAYER_INFINIBAND,
 237         IB_LINK_LAYER_ETHERNET,
 238 };
 239
 240 enum ib_device_cap_flags {
 241         IB_DEVICE_RESIZE_MAX_WR                 = (1 << 0),
 242         IB_DEVICE_BAD_PKEY_CNTR                 = (1 << 1),
 243         IB_DEVICE_BAD_QKEY_CNTR                 = (1 << 2),
 244         IB_DEVICE_RAW_MULTI                     = (1 << 3),
 245         IB_DEVICE_AUTO_PATH_MIG                 = (1 << 4),
 246         IB_DEVICE_CHANGE_PHY_PORT               = (1 << 5),
 247         IB_DEVICE_UD_AV_PORT_ENFORCE            = (1 << 6),
 248         IB_DEVICE_CURR_QP_STATE_MOD             = (1 << 7),
 249         IB_DEVICE_SHUTDOWN_PORT                 = (1 << 8),
 250         /* Not in use, former INIT_TYPE         = (1 << 9),*/
 251         IB_DEVICE_PORT_ACTIVE_EVENT             = (1 << 10),
 252         IB_DEVICE_SYS_IMAGE_GUID                = (1 << 11),
 253         IB_DEVICE_RC_RNR_NAK_GEN                = (1 << 12),
 254         IB_DEVICE_SRQ_RESIZE                    = (1 << 13),
 255         IB_DEVICE_N_NOTIFY_CQ                   = (1 << 14),
 256
 257         /*
 258          * This device supports a per-device lkey or stag that can be
 259          * used without performing a memory registration for the local
 260          * memory.  Note that ULPs should never check this flag, but
 261          * instead of use the local_dma_lkey flag in the ib_pd structure,
 262          * which will always contain a usable lkey.
 263          */
 264         IB_DEVICE_LOCAL_DMA_LKEY                = (1 << 15),
 265         /* Reserved, old SEND_W_INV             = (1 << 16),*/
 266         IB_DEVICE_MEM_WINDOW                    = (1 << 17),
 267         /*
 268          * Devices should set IB_DEVICE_UD_IP_SUM if they support
 269          * insertion of UDP and TCP checksum on outgoing UD IPoIB
 270          * messages and can verify the validity of checksum for
 271          * incoming messages.  Setting this flag implies that the
 272          * IPoIB driver may set NETIF_F_IP_CSUM for datagram mode.
 273          */
 274         IB_DEVICE_UD_IP_CSUM                    = (1 << 18),
 275         IB_DEVICE_UD_TSO                        = (1 << 19),
 276         IB_DEVICE_XRC                           = (1 << 20),
 277
 278         /*
 279          * This device supports the IB "base memory management extension",
 280          * which includes support for fast registrations (IB_WR_REG_MR,
 281          * IB_WR_LOCAL_INV and IB_WR_SEND_WITH_INV verbs).  This flag should
 282          * also be set by any iWarp device which must support FRs to comply
 283          * to the iWarp verbs spec.  iWarp devices also support the
 284          * IB_WR_RDMA_READ_WITH_INV verb for RDMA READs that invalidate the
 285          * stag.
 286          */
 287         IB_DEVICE_MEM_MGT_EXTENSIONS            = (1 << 21),
 288         IB_DEVICE_BLOCK_MULTICAST_LOOPBACK      = (1 << 22),
 289         IB_DEVICE_MEM_WINDOW_TYPE_2A            = (1 << 23),
 290         IB_DEVICE_MEM_WINDOW_TYPE_2B            = (1 << 24),
 291         IB_DEVICE_RC_IP_CSUM                    = (1 << 25),
 292         /* Deprecated. Please use IB_RAW_PACKET_CAP_IP_CSUM. */
 293         IB_DEVICE_RAW_IP_CSUM                   = (1 << 26),
 294         /*
 295          * Devices should set IB_DEVICE_CROSS_CHANNEL if they
 296          * support execution of WQEs that involve synchronization
 297          * of I/O operations with single completion queue managed
 298          * by hardware.
 299          */
 300         IB_DEVICE_CROSS_CHANNEL                 = (1 << 27),
 301         IB_DEVICE_MANAGED_FLOW_STEERING         = (1 << 29),
 302         IB_DEVICE_INTEGRITY_HANDOVER            = (1 << 30),
 303         IB_DEVICE_ON_DEMAND_PAGING              = (1ULL << 31),
 304         IB_DEVICE_SG_GAPS_REG                   = (1ULL << 32),
 305         IB_DEVICE_VIRTUAL_FUNCTION              = (1ULL << 33),
 306         /* Deprecated. Please use IB_RAW_PACKET_CAP_SCATTER_FCS. */
 307         IB_DEVICE_RAW_SCATTER_FCS               = (1ULL << 34),
 308         IB_DEVICE_RDMA_NETDEV_OPA_VNIC          = (1ULL << 35),
 309         /* The device supports padding incoming writes to cacheline. */
 310         IB_DEVICE_PCI_WRITE_END_PADDING         = (1ULL << 36),
 311         IB_DEVICE_ALLOW_USER_UNREG              = (1ULL << 37),
 312 };
 313
 314 enum ib_atomic_cap {
 315         IB_ATOMIC_NONE,
 316         IB_ATOMIC_HCA,
 317         IB_ATOMIC_GLOB
 318 };
 319
 320 enum ib_odp_general_cap_bits {
 321         IB_ODP_SUPPORT          = 1 << 0,
 322         IB_ODP_SUPPORT_IMPLICIT = 1 << 1,
 323 };
 324
 325 enum ib_odp_transport_cap_bits {
 326         IB_ODP_SUPPORT_SEND     = 1 << 0,
 327         IB_ODP_SUPPORT_RECV     = 1 << 1,
 328         IB_ODP_SUPPORT_WRITE    = 1 << 2,
 329         IB_ODP_SUPPORT_READ     = 1 << 3,
 330         IB_ODP_SUPPORT_ATOMIC   = 1 << 4,
 331         IB_ODP_SUPPORT_SRQ_RECV = 1 << 5,
 332 };
 333
 334 struct ib_odp_caps {
 335         uint64_t general_caps;
 336         struct {
 337                 uint32_t  rc_odp_caps;
 338                 uint32_t  uc_odp_caps;
 339                 uint32_t  ud_odp_caps;
 340                 uint32_t  xrc_odp_caps;
 341         } per_transport_caps;
 342 };
 343
 344 struct ib_rss_caps {
 345         /* Corresponding bit will be set if qp type from
 346          * 'enum ib_qp_type' is supported, e.g.
 347          * supported_qpts |= 1 << IB_QPT_UD
 348          */
 349         u32 supported_qpts;
 350         u32 max_rwq_indirection_tables;
 351         u32 max_rwq_indirection_table_size;
 352 };
 353
 354 enum ib_tm_cap_flags {
 355         /*  Support tag matching with rendezvous offload for RC transport */
 356         IB_TM_CAP_RNDV_RC = 1 << 0,
 357 };
 358
 359 struct ib_tm_caps {
 360         /* Max size of RNDV header */
 361         u32 max_rndv_hdr_size;
 362         /* Max number of entries in tag matching list */
 363         u32 max_num_tags;
 364         /* From enum ib_tm_cap_flags */
 365         u32 flags;
 366         /* Max number of outstanding list operations */
 367         u32 max_ops;
 368         /* Max number of SGE in tag matching entry */
 369         u32 max_sge;
 370 };
 371
 372 struct ib_cq_init_attr {
 373         unsigned int    cqe;
 374         u32             comp_vector;
 375         u32             flags;
 376 };
 377
 378 enum ib_cq_attr_mask {
 379         IB_CQ_MODERATE = 1 << 0,
 380 };
 381
 382 struct ib_cq_caps {
 383         u16     max_cq_moderation_count;
 384         u16     max_cq_moderation_period;
 385 };
 386
 387 struct ib_dm_mr_attr {
 388         u64             length;
 389         u64             offset;
 390         u32             access_flags;
 391 };
 392
 393 struct ib_dm_alloc_attr {
 394         u64     length;
 395         u32     alignment;
 396         u32     flags;
 397 };
 398
 399 struct ib_device_attr {
 400         u64                     fw_ver;
 401         __be64                  sys_image_guid;
 402         u64                     max_mr_size;
 403         u64                     page_size_cap;
 404         u32                     vendor_id;
 405         u32                     vendor_part_id;
 406         u32                     hw_ver;
 407         int                     max_qp;
 408         int                     max_qp_wr;
 409         u64                     device_cap_flags;
 410         int                     max_send_sge;
 411         int                     max_recv_sge;
 412         int                     max_sge_rd;
 413         int                     max_cq;
 414         int                     max_cqe;
 415         int                     max_mr;
 416         int                     max_pd;
 417         int                     max_qp_rd_atom;
 418         int                     max_ee_rd_atom;
 419         int                     max_res_rd_atom;
 420         int                     max_qp_init_rd_atom;
 421         int                     max_ee_init_rd_atom;
 422         enum ib_atomic_cap      atomic_cap;
 423         enum ib_atomic_cap      masked_atomic_cap;
 424         int                     max_ee;
 425         int                     max_rdd;
 426         int                     max_mw;
 427         int                     max_raw_ipv6_qp;
 428         int                     max_raw_ethy_qp;
 429         int                     max_mcast_grp;
 430         int                     max_mcast_qp_attach;
 431         int                     max_total_mcast_qp_attach;
 432         int                     max_ah;
 433         int                     max_fmr;
 434         int                     max_map_per_fmr;
 435         int                     max_srq;
 436         int                     max_srq_wr;
 437         int                     max_srq_sge;
 438         unsigned int            max_fast_reg_page_list_len;
 439         unsigned int            max_pi_fast_reg_page_list_len;
 440         u16                     max_pkeys;
 441         u8                      local_ca_ack_delay;
 442         int                     sig_prot_cap;
 443         int                     sig_guard_cap;
 444         struct ib_odp_caps      odp_caps;
 445         uint64_t                timestamp_mask;
 446         uint64_t                hca_core_clock; /* in KHZ */
 447         struct ib_rss_caps      rss_caps;
 448         u32                     max_wq_type_rq;
 449         u32                     raw_packet_caps; /* Use ib_raw_packet_caps enum */
 450         struct ib_tm_caps       tm_caps;
 451         struct ib_cq_caps       cq_caps;
 452         u64                     max_dm_size;
 453         /* Max entries for sgl for optimized performance per READ */
 454         u32                     max_sgl_rd;
 455 };
 456
 457 enum ib_mtu {
 458         IB_MTU_256  = 1,
 459         IB_MTU_512  = 2,
 460         IB_MTU_1024 = 3,
 461         IB_MTU_2048 = 4,
 462         IB_MTU_4096 = 5
 463 };
 464
 465 static inline int ib_mtu_enum_to_int(enum ib_mtu mtu)
 466 {
 467         switch (mtu) {
 468         case IB_MTU_256:  return  256;
 469         case IB_MTU_512:  return  512;
 470         case IB_MTU_1024: return 1024;
 471         case IB_MTU_2048: return 2048;
 472         case IB_MTU_4096: return 4096;
 473         default:          return -1;
 474         }
 475 }
 476
 477 static inline enum ib_mtu ib_mtu_int_to_enum(int mtu)
 478 {
 479         if (mtu >= 4096)
 480                 return IB_MTU_4096;
 481         else if (mtu >= 2048)
 482                 return IB_MTU_2048;
 483         else if (mtu >= 1024)
 484                 return IB_MTU_1024;
 485         else if (mtu >= 512)
 486                 return IB_MTU_512;
 487         else
 488                 return IB_MTU_256;
 489 }
 490
 491 enum ib_port_state {
 492         IB_PORT_NOP             = 0,
 493         IB_PORT_DOWN            = 1,
 494         IB_PORT_INIT            = 2,
 495         IB_PORT_ARMED           = 3,
 496         IB_PORT_ACTIVE          = 4,
 497         IB_PORT_ACTIVE_DEFER    = 5
 498 };
 499
 500 enum ib_port_phys_state {
 501         IB_PORT_PHYS_STATE_SLEEP = 1,
 502         IB_PORT_PHYS_STATE_POLLING = 2,
 503         IB_PORT_PHYS_STATE_DISABLED = 3,
 504         IB_PORT_PHYS_STATE_PORT_CONFIGURATION_TRAINING = 4,
 505         IB_PORT_PHYS_STATE_LINK_UP = 5,
 506         IB_PORT_PHYS_STATE_LINK_ERROR_RECOVERY = 6,
 507         IB_PORT_PHYS_STATE_PHY_TEST = 7,
 508 };
 509
 510 enum ib_port_width {
 511         IB_WIDTH_1X     = 1,
 512         IB_WIDTH_2X     = 16,
 513         IB_WIDTH_4X     = 2,
 514         IB_WIDTH_8X     = 4,
 515         IB_WIDTH_12X    = 8
 516 };
 517
 518 static inline int ib_width_enum_to_int(enum ib_port_width width)
 519 {
 520         switch (width) {
 521         case IB_WIDTH_1X:  return  1;
 522         case IB_WIDTH_2X:  return  2;
 523         case IB_WIDTH_4X:  return  4;
 524         case IB_WIDTH_8X:  return  8;
 525         case IB_WIDTH_12X: return 12;
 526         default:          return -1;
 527         }
 528 }
 529
 530 enum ib_port_speed {
 531         IB_SPEED_SDR    = 1,
 532         IB_SPEED_DDR    = 2,
 533         IB_SPEED_QDR    = 4,
 534         IB_SPEED_FDR10  = 8,
 535         IB_SPEED_FDR    = 16,
 536         IB_SPEED_EDR    = 32,
 537         IB_SPEED_HDR    = 64
 538 };
 539
 540 /**
 541  * struct rdma_hw_stats
 542  * @lock - Mutex to protect parallel write access to lifespan and values
 543  *    of counters, which are 64bits and not guaranteeed to be written
 544  *    atomicaly on 32bits systems.
 545  * @timestamp - Used by the core code to track when the last update was
 546  * @lifespan - Used by the core code to determine how old the counters
 547  *   should be before being updated again.  Stored in jiffies, defaults
 548  *   to 10 milliseconds, drivers can override the default be specifying
 549  *   their own value during their allocation routine.
 550  * @name - Array of pointers to static names used for the counters in
 551  *   directory.
 552  * @num_counters - How many hardware counters there are.  If name is
 553  *   shorter than this number, a kernel oops will result.  Driver authors
 554  *   are encouraged to leave BUILD_BUG_ON(ARRAY_SIZE(@name) < num_counters)
 555  *   in their code to prevent this.
 556  * @value - Array of u64 counters that are accessed by the sysfs code and
 557  *   filled in by the drivers get_stats routine
 558  */
 559 struct rdma_hw_stats {
 560         struct mutex    lock; /* Protect lifespan and values[] */
 561         unsigned long   timestamp;
 562         unsigned long   lifespan;
 563         const char * const *names;
 564         int             num_counters;
 565         u64             value[];
 566 };
 567
 568 #define RDMA_HW_STATS_DEFAULT_LIFESPAN 10
 569 /**
 570  * rdma_alloc_hw_stats_struct - Helper function to allocate dynamic struct
 571  *   for drivers.
 572  * @names - Array of static const char *
 573  * @num_counters - How many elements in array
 574  * @lifespan - How many milliseconds between updates
 575  */
 576 static inline struct rdma_hw_stats *rdma_alloc_hw_stats_struct(
 577                 const char * const *names, int num_counters,
 578                 unsigned long lifespan)
 579 {
 580         struct rdma_hw_stats *stats;
 581
 582         stats = kzalloc(sizeof(*stats) + num_counters * sizeof(u64),
 583                         GFP_KERNEL);
 584         if (!stats)
 585                 return NULL;
 586         stats->names = names;
 587         stats->num_counters = num_counters;
 588         stats->lifespan = msecs_to_jiffies(lifespan);
 589
 590         return stats;
 591 }
 592
 593
 594 /* Define bits for the various functionality this port needs to be supported by
 595  * the core.
 596  */
 597 /* Management                           0x00000FFF */
 598 #define RDMA_CORE_CAP_IB_MAD            0x00000001
 599 #define RDMA_CORE_CAP_IB_SMI            0x00000002
 600 #define RDMA_CORE_CAP_IB_CM             0x00000004
 601 #define RDMA_CORE_CAP_IW_CM             0x00000008
 602 #define RDMA_CORE_CAP_IB_SA             0x00000010
 603 #define RDMA_CORE_CAP_OPA_MAD           0x00000020
 604
 605 /* Address format                       0x000FF000 */
 606 #define RDMA_CORE_CAP_AF_IB             0x00001000
 607 #define RDMA_CORE_CAP_ETH_AH            0x00002000
 608 #define RDMA_CORE_CAP_OPA_AH            0x00004000
 609 #define RDMA_CORE_CAP_IB_GRH_REQUIRED   0x00008000
 610
 611 /* Protocol                             0xFFF00000 */
 612 #define RDMA_CORE_CAP_PROT_IB           0x00100000
 613 #define RDMA_CORE_CAP_PROT_ROCE         0x00200000
 614 #define RDMA_CORE_CAP_PROT_IWARP        0x00400000
 615 #define RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP 0x00800000
 616 #define RDMA_CORE_CAP_PROT_RAW_PACKET   0x01000000
 617 #define RDMA_CORE_CAP_PROT_USNIC        0x02000000
 618
 619 #define RDMA_CORE_PORT_IB_GRH_REQUIRED (RDMA_CORE_CAP_IB_GRH_REQUIRED \
 620                                         | RDMA_CORE_CAP_PROT_ROCE     \
 621                                         | RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP)
 622
 623 #define RDMA_CORE_PORT_IBA_IB          (RDMA_CORE_CAP_PROT_IB  \
 624                                         | RDMA_CORE_CAP_IB_MAD \
 625                                         | RDMA_CORE_CAP_IB_SMI \
 626                                         | RDMA_CORE_CAP_IB_CM  \
 627                                         | RDMA_CORE_CAP_IB_SA  \
 628                                         | RDMA_CORE_CAP_AF_IB)
 629 #define RDMA_CORE_PORT_IBA_ROCE        (RDMA_CORE_CAP_PROT_ROCE \
 630                                         | RDMA_CORE_CAP_IB_MAD  \
 631                                         | RDMA_CORE_CAP_IB_CM   \
 632                                         | RDMA_CORE_CAP_AF_IB   \
 633                                         | RDMA_CORE_CAP_ETH_AH)
 634 #define RDMA_CORE_PORT_IBA_ROCE_UDP_ENCAP                       \
 635                                         (RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP \
 636                                         | RDMA_CORE_CAP_IB_MAD  \
 637                                         | RDMA_CORE_CAP_IB_CM   \
 638                                         | RDMA_CORE_CAP_AF_IB   \
 639                                         | RDMA_CORE_CAP_ETH_AH)
 640 #define RDMA_CORE_PORT_IWARP           (RDMA_CORE_CAP_PROT_IWARP \
 641                                         | RDMA_CORE_CAP_IW_CM)
 642 #define RDMA_CORE_PORT_INTEL_OPA       (RDMA_CORE_PORT_IBA_IB  \
 643                                         | RDMA_CORE_CAP_OPA_MAD)
 644
 645 #define RDMA_CORE_PORT_RAW_PACKET       (RDMA_CORE_CAP_PROT_RAW_PACKET)
 646
 647 #define RDMA_CORE_PORT_USNIC            (RDMA_CORE_CAP_PROT_USNIC)
 648
 649 struct ib_port_attr {
 650         u64                     subnet_prefix;
 651         enum ib_port_state      state;
 652         enum ib_mtu             max_mtu;
 653         enum ib_mtu             active_mtu;
 654         int                     gid_tbl_len;
 655         unsigned int            ip_gids:1;
 656         /* This is the value from PortInfo CapabilityMask, defined by IBA */
 657         u32                     port_cap_flags;
 658         u32                     max_msg_sz;
 659         u32                     bad_pkey_cntr;
 660         u32                     qkey_viol_cntr;
 661         u16                     pkey_tbl_len;
 662         u32                     sm_lid;
 663         u32                     lid;
 664         u8                      lmc;
 665         u8                      max_vl_num;
 666         u8                      sm_sl;
 667         u8                      subnet_timeout;
 668         u8                      init_type_reply;
 669         u8                      active_width;
 670         u8                      active_speed;
 671         u8                      phys_state;
 672         u16                     port_cap_flags2;
 673 };
 674
 675 enum ib_device_modify_flags {
 676         IB_DEVICE_MODIFY_SYS_IMAGE_GUID = 1 << 0,
 677         IB_DEVICE_MODIFY_NODE_DESC      = 1 << 1
 678 };
 679
 680 #define IB_DEVICE_NODE_DESC_MAX 64
 681
 682 struct ib_device_modify {
 683         u64     sys_image_guid;
 684         char    node_desc[IB_DEVICE_NODE_DESC_MAX];
 685 };
 686
 687 enum ib_port_modify_flags {
 688         IB_PORT_SHUTDOWN                = 1,
 689         IB_PORT_INIT_TYPE               = (1<<2),
 690         IB_PORT_RESET_QKEY_CNTR         = (1<<3),
 691         IB_PORT_OPA_MASK_CHG            = (1<<4)
 692 };
 693
 694 struct ib_port_modify {
 695         u32     set_port_cap_mask;
 696         u32     clr_port_cap_mask;
 697         u8      init_type;
 698 };
 699
 700 enum ib_event_type {
 701         IB_EVENT_CQ_ERR,
 702         IB_EVENT_QP_FATAL,
 703         IB_EVENT_QP_REQ_ERR,
 704         IB_EVENT_QP_ACCESS_ERR,
 705         IB_EVENT_COMM_EST,
 706         IB_EVENT_SQ_DRAINED,
 707         IB_EVENT_PATH_MIG,
 708         IB_EVENT_PATH_MIG_ERR,
 709         IB_EVENT_DEVICE_FATAL,
 710         IB_EVENT_PORT_ACTIVE,
 711         IB_EVENT_PORT_ERR,
 712         IB_EVENT_LID_CHANGE,
 713         IB_EVENT_PKEY_CHANGE,
 714         IB_EVENT_SM_CHANGE,
 715         IB_EVENT_SRQ_ERR,
 716         IB_EVENT_SRQ_LIMIT_REACHED,
 717         IB_EVENT_QP_LAST_WQE_REACHED,
 718         IB_EVENT_CLIENT_REREGISTER,
 719         IB_EVENT_GID_CHANGE,
 720         IB_EVENT_WQ_FATAL,
 721 };
 722
 723 const char *__attribute_const__ ib_event_msg(enum ib_event_type event);
 724
 725 struct ib_event {
 726         struct ib_device        *device;
 727         union {
 728                 struct ib_cq    *cq;
 729                 struct ib_qp    *qp;
 730                 struct ib_srq   *srq;
 731                 struct ib_wq    *wq;
 732                 u8              port_num;
 733         } element;
 734         enum ib_event_type      event;
 735 };
 736
 737 struct ib_event_handler {
 738         struct ib_device *device;
 739         void            (*handler)(struct ib_event_handler *, struct ib_event *);
 740         struct list_head  list;
 741 };
 742
 743 #define INIT_IB_EVENT_HANDLER(_ptr, _device, _handler)          \
 744         do {                                                    \
 745                 (_ptr)->device  = _device;                      \
 746                 (_ptr)->handler = _handler;                     \
 747                 INIT_LIST_HEAD(&(_ptr)->list);                  \
 748         } while (0)
 749
 750 struct ib_global_route {
 751         const struct ib_gid_attr *sgid_attr;
 752         union ib_gid    dgid;
 753         u32             flow_label;
 754         u8              sgid_index;
 755         u8              hop_limit;
 756         u8              traffic_class;
 757 };
 758
 759 struct ib_grh {
 760         __be32          version_tclass_flow;
 761         __be16          paylen;
 762         u8              next_hdr;
 763         u8              hop_limit;
 764         union ib_gid    sgid;
 765         union ib_gid    dgid;
 766 };
 767
 768 union rdma_network_hdr {
 769         struct ib_grh ibgrh;
 770         struct {
 771                 /* The IB spec states that if it's IPv4, the header
 772                  * is located in the last 20 bytes of the header.
 773                  */
 774                 u8              reserved[20];
 775                 struct iphdr    roce4grh;
 776         };
 777 };
 778
 779 #define IB_QPN_MASK             0xFFFFFF
 780
 781 enum {
 782         IB_MULTICAST_QPN = 0xffffff
 783 };
 784
 785 #define IB_LID_PERMISSIVE       cpu_to_be16(0xFFFF)
 786 #define IB_MULTICAST_LID_BASE   cpu_to_be16(0xC000)
 787
 788 enum ib_ah_flags {
 789         IB_AH_GRH       = 1
 790 };
 791
 792 enum ib_rate {
 793         IB_RATE_PORT_CURRENT = 0,
 794         IB_RATE_2_5_GBPS = 2,
 795         IB_RATE_5_GBPS   = 5,
 796         IB_RATE_10_GBPS  = 3,
 797         IB_RATE_20_GBPS  = 6,
 798         IB_RATE_30_GBPS  = 4,
 799         IB_RATE_40_GBPS  = 7,
 800         IB_RATE_60_GBPS  = 8,
 801         IB_RATE_80_GBPS  = 9,
 802         IB_RATE_120_GBPS = 10,
 803         IB_RATE_14_GBPS  = 11,
 804         IB_RATE_56_GBPS  = 12,
 805         IB_RATE_112_GBPS = 13,
 806         IB_RATE_168_GBPS = 14,
 807         IB_RATE_25_GBPS  = 15,
 808         IB_RATE_100_GBPS = 16,
 809         IB_RATE_200_GBPS = 17,
 810         IB_RATE_300_GBPS = 18,
 811         IB_RATE_28_GBPS  = 19,
 812         IB_RATE_50_GBPS  = 20,
 813         IB_RATE_400_GBPS = 21,
 814         IB_RATE_600_GBPS = 22,
 815 };
 816
 817 /**
 818  * ib_rate_to_mult - Convert the IB rate enum to a multiple of the
 819  * base rate of 2.5 Gbit/sec.  For example, IB_RATE_5_GBPS will be
 820  * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.
 821  * @rate: rate to convert.
 822  */
 823 __attribute_const__ int ib_rate_to_mult(enum ib_rate rate);
 824
 825 /**
 826  * ib_rate_to_mbps - Convert the IB rate enum to Mbps.
 827  * For example, IB_RATE_2_5_GBPS will be converted to 2500.
 828  * @rate: rate to convert.
 829  */
 830 __attribute_const__ int ib_rate_to_mbps(enum ib_rate rate);
 831
 832
 833 /**
 834  * enum ib_mr_type - memory region type
 835  * @IB_MR_TYPE_MEM_REG:       memory region that is used for
 836  *                            normal registration
 837  * @IB_MR_TYPE_SG_GAPS:       memory region that is capable to
 838  *                            register any arbitrary sg lists (without
 839  *                            the normal mr constraints - see
 840  *                            ib_map_mr_sg)
 841  * @IB_MR_TYPE_DM:            memory region that is used for device
 842  *                            memory registration
 843  * @IB_MR_TYPE_USER:          memory region that is used for the user-space
 844  *                            application
 845  * @IB_MR_TYPE_DMA:           memory region that is used for DMA operations
 846  *                            without address translations (VA=PA)
 847  * @IB_MR_TYPE_INTEGRITY:     memory region that is used for
 848  *                            data integrity operations
 849  */
 850 enum ib_mr_type {
 851         IB_MR_TYPE_MEM_REG,
 852         IB_MR_TYPE_SG_GAPS,
 853         IB_MR_TYPE_DM,
 854         IB_MR_TYPE_USER,
 855         IB_MR_TYPE_DMA,
 856         IB_MR_TYPE_INTEGRITY,
 857 };
 858
 859 enum ib_mr_status_check {
 860         IB_MR_CHECK_SIG_STATUS = 1,
 861 };
 862
 863 /**
 864  * struct ib_mr_status - Memory region status container
 865  *
 866  * @fail_status: Bitmask of MR checks status. For each
 867  *     failed check a corresponding status bit is set.
 868  * @sig_err: Additional info for IB_MR_CEHCK_SIG_STATUS
 869  *     failure.
 870  */
 871 struct ib_mr_status {
 872         u32                 fail_status;
 873         struct ib_sig_err   sig_err;
 874 };
 875
 876 /**
 877  * mult_to_ib_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate
 878  * enum.
 879  * @mult: multiple to convert.
 880  */
 881 __attribute_const__ enum ib_rate mult_to_ib_rate(int mult);
 882
 883 enum rdma_ah_attr_type {
 884         RDMA_AH_ATTR_TYPE_UNDEFINED,
 885         RDMA_AH_ATTR_TYPE_IB,
 886         RDMA_AH_ATTR_TYPE_ROCE,
 887         RDMA_AH_ATTR_TYPE_OPA,
 888 };
 889
 890 struct ib_ah_attr {
 891         u16                     dlid;
 892         u8                      src_path_bits;
 893 };
 894
 895 struct roce_ah_attr {
 896         u8                      dmac[ETH_ALEN];
 897 };
 898
 899 struct opa_ah_attr {
 900         u32                     dlid;
 901         u8                      src_path_bits;
 902         bool                    make_grd;
 903 };
 904
 905 struct rdma_ah_attr {
 906         struct ib_global_route  grh;
 907         u8                      sl;
 908         u8                      static_rate;
 909         u8                      port_num;
 910         u8                      ah_flags;
 911         enum rdma_ah_attr_type type;
 912         union {
 913                 struct ib_ah_attr ib;
 914                 struct roce_ah_attr roce;
 915                 struct opa_ah_attr opa;
 916         };
 917 };
 918
 919 enum ib_wc_status {
 920         IB_WC_SUCCESS,
 921         IB_WC_LOC_LEN_ERR,
 922         IB_WC_LOC_QP_OP_ERR,
 923         IB_WC_LOC_EEC_OP_ERR,
 924         IB_WC_LOC_PROT_ERR,
 925         IB_WC_WR_FLUSH_ERR,
 926         IB_WC_MW_BIND_ERR,
 927         IB_WC_BAD_RESP_ERR,
 928         IB_WC_LOC_ACCESS_ERR,
 929         IB_WC_REM_INV_REQ_ERR,
 930         IB_WC_REM_ACCESS_ERR,
 931         IB_WC_REM_OP_ERR,
 932         IB_WC_RETRY_EXC_ERR,
 933         IB_WC_RNR_RETRY_EXC_ERR,
 934         IB_WC_LOC_RDD_VIOL_ERR,
 935         IB_WC_REM_INV_RD_REQ_ERR,
 936         IB_WC_REM_ABORT_ERR,
 937         IB_WC_INV_EECN_ERR,
 938         IB_WC_INV_EEC_STATE_ERR,
 939         IB_WC_FATAL_ERR,
 940         IB_WC_RESP_TIMEOUT_ERR,
 941         IB_WC_GENERAL_ERR
 942 };
 943
 944 const char *__attribute_const__ ib_wc_status_msg(enum ib_wc_status status);
 945
 946 enum ib_wc_opcode {
 947         IB_WC_SEND,
 948         IB_WC_RDMA_WRITE,
 949         IB_WC_RDMA_READ,
 950         IB_WC_COMP_SWAP,
 951         IB_WC_FETCH_ADD,
 952         IB_WC_LSO,
 953         IB_WC_LOCAL_INV,
 954         IB_WC_REG_MR,
 955         IB_WC_MASKED_COMP_SWAP,
 956         IB_WC_MASKED_FETCH_ADD,
 957 /*
 958  * Set value of IB_WC_RECV so consumers can test if a completion is a
 959  * receive by testing (opcode & IB_WC_RECV).
 960  */
 961         IB_WC_RECV                      = 1 << 7,
 962         IB_WC_RECV_RDMA_WITH_IMM
 963 };
 964
 965 enum ib_wc_flags {
 966         IB_WC_GRH               = 1,
 967         IB_WC_WITH_IMM          = (1<<1),
 968         IB_WC_WITH_INVALIDATE   = (1<<2),
 969         IB_WC_IP_CSUM_OK        = (1<<3),
 970         IB_WC_WITH_SMAC         = (1<<4),
 971         IB_WC_WITH_VLAN         = (1<<5),
 972         IB_WC_WITH_NETWORK_HDR_TYPE     = (1<<6),
 973 };
 974
 975 struct ib_wc {
 976         union {
 977                 u64             wr_id;
 978                 struct ib_cqe   *wr_cqe;
 979         };
 980         enum ib_wc_status       status;
 981         enum ib_wc_opcode       opcode;
 982         u32                     vendor_err;
 983         u32                     byte_len;
 984         struct ib_qp           *qp;
 985         union {
 986                 __be32          imm_data;
 987                 u32             invalidate_rkey;
 988         } ex;
 989         u32                     src_qp;
 990         u32                     slid;
 991         int                     wc_flags;
 992         u16                     pkey_index;
 993         u8                      sl;
 994         u8                      dlid_path_bits;
 995         u8                      port_num;       /* valid only for DR SMPs on switches */
 996         u8                      smac[ETH_ALEN];
 997         u16                     vlan_id;
 998         u8                      network_hdr_type;
 999 };
1000
1001 enum ib_cq_notify_flags {
1002         IB_CQ_SOLICITED                 = 1 << 0,
1003         IB_CQ_NEXT_COMP                 = 1 << 1,
1004         IB_CQ_SOLICITED_MASK            = IB_CQ_SOLICITED | IB_CQ_NEXT_COMP,
1005         IB_CQ_REPORT_MISSED_EVENTS      = 1 << 2,
1006 };
1007
1008 enum ib_srq_type {
1009         IB_SRQT_BASIC,
1010         IB_SRQT_XRC,
1011         IB_SRQT_TM,
1012 };
1013
1014 static inline bool ib_srq_has_cq(enum ib_srq_type srq_type)
1015 {
1016         return srq_type == IB_SRQT_XRC ||
1017                srq_type == IB_SRQT_TM;
1018 }
1019
1020 enum ib_srq_attr_mask {
1021         IB_SRQ_MAX_WR   = 1 << 0,
1022         IB_SRQ_LIMIT    = 1 << 1,
1023 };
1024
1025 struct ib_srq_attr {
1026         u32     max_wr;
1027         u32     max_sge;
1028         u32     srq_limit;
1029 };
1030
1031 struct ib_srq_init_attr {
1032         void                  (*event_handler)(struct ib_event *, void *);
1033         void                   *srq_context;
1034         struct ib_srq_attr      attr;
1035         enum ib_srq_type        srq_type;
1036
1037         struct {
1038                 struct ib_cq   *cq;
1039                 union {
1040                         struct {
1041                                 struct ib_xrcd *xrcd;
1042                         } xrc;
1043
1044                         struct {
1045                                 u32             max_num_tags;
1046                         } tag_matching;
1047                 };
1048         } ext;
1049 };
1050
1051 struct ib_qp_cap {
1052         u32     max_send_wr;
1053         u32     max_recv_wr;
1054         u32     max_send_sge;
1055         u32     max_recv_sge;
1056         u32     max_inline_data;
1057
1058         /*
1059          * Maximum number of rdma_rw_ctx structures in flight at a time.
1060          * ib_create_qp() will calculate the right amount of neededed WRs
1061          * and MRs based on this.
1062          */
1063         u32     max_rdma_ctxs;
1064 };
1065
1066 enum ib_sig_type {
1067         IB_SIGNAL_ALL_WR,
1068         IB_SIGNAL_REQ_WR
1069 };
1070
1071 enum ib_qp_type {
1072         /*
1073          * IB_QPT_SMI and IB_QPT_GSI have to be the first two entries
1074          * here (and in that order) since the MAD layer uses them as
1075          * indices into a 2-entry table.
1076          */
1077         IB_QPT_SMI,
1078         IB_QPT_GSI,
1079
1080         IB_QPT_RC,
1081         IB_QPT_UC,
1082         IB_QPT_UD,
1083         IB_QPT_RAW_IPV6,
1084         IB_QPT_RAW_ETHERTYPE,
1085         IB_QPT_RAW_PACKET = 8,
1086         IB_QPT_XRC_INI = 9,
1087         IB_QPT_XRC_TGT,
1088         IB_QPT_MAX,
1089         IB_QPT_DRIVER = 0xFF,
1090         /* Reserve a range for qp types internal to the low level driver.
1091          * These qp types will not be visible at the IB core layer, so the
1092          * IB_QPT_MAX usages should not be affected in the core layer
1093          */
1094         IB_QPT_RESERVED1 = 0x1000,
1095         IB_QPT_RESERVED2,
1096         IB_QPT_RESERVED3,
1097         IB_QPT_RESERVED4,
1098         IB_QPT_RESERVED5,
1099         IB_QPT_RESERVED6,
1100         IB_QPT_RESERVED7,
1101         IB_QPT_RESERVED8,
1102         IB_QPT_RESERVED9,
1103         IB_QPT_RESERVED10,
1104 };
1105
1106 enum ib_qp_create_flags {
1107         IB_QP_CREATE_IPOIB_UD_LSO               = 1 << 0,
1108         IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK   = 1 << 1,
1109         IB_QP_CREATE_CROSS_CHANNEL              = 1 << 2,
1110         IB_QP_CREATE_MANAGED_SEND               = 1 << 3,
1111         IB_QP_CREATE_MANAGED_RECV               = 1 << 4,
1112         IB_QP_CREATE_NETIF_QP                   = 1 << 5,
1113         IB_QP_CREATE_INTEGRITY_EN               = 1 << 6,
1114         /* FREE                                 = 1 << 7, */
1115         IB_QP_CREATE_SCATTER_FCS                = 1 << 8,
1116         IB_QP_CREATE_CVLAN_STRIPPING            = 1 << 9,
1117         IB_QP_CREATE_SOURCE_QPN                 = 1 << 10,
1118         IB_QP_CREATE_PCI_WRITE_END_PADDING      = 1 << 11,
1119         /* reserve bits 26-31 for low level drivers' internal use */
1120         IB_QP_CREATE_RESERVED_START             = 1 << 26,
1121         IB_QP_CREATE_RESERVED_END               = 1 << 31,
1122 };
1123
1124 /*
1125  * Note: users may not call ib_close_qp or ib_destroy_qp from the event_handler
1126  * callback to destroy the passed in QP.
1127  */
1128
1129 struct ib_qp_init_attr {
1130         /* Consumer's event_handler callback must not block */
1131         void                  (*event_handler)(struct ib_event *, void *);
1132
1133         void                   *qp_context;
1134         struct ib_cq           *send_cq;
1135         struct ib_cq           *recv_cq;
1136         struct ib_srq          *srq;
1137         struct ib_xrcd         *xrcd;     /* XRC TGT QPs only */
1138         struct ib_qp_cap        cap;
1139         enum ib_sig_type        sq_sig_type;
1140         enum ib_qp_type         qp_type;
1141         u32                     create_flags;
1142
1143         /*
1144          * Only needed for special QP types, or when using the RW API.
1145          */
1146         u8                      port_num;
1147         struct ib_rwq_ind_table *rwq_ind_tbl;
1148         u32                     source_qpn;
1149 };
1150
1151 struct ib_qp_open_attr {
1152         void                  (*event_handler)(struct ib_event *, void *);
1153         void                   *qp_context;
1154         u32                     qp_num;
1155         enum ib_qp_type         qp_type;
1156 };
1157
1158 enum ib_rnr_timeout {
1159         IB_RNR_TIMER_655_36 =  0,
1160         IB_RNR_TIMER_000_01 =  1,
1161         IB_RNR_TIMER_000_02 =  2,
1162         IB_RNR_TIMER_000_03 =  3,
1163         IB_RNR_TIMER_000_04 =  4,
1164         IB_RNR_TIMER_000_06 =  5,
1165         IB_RNR_TIMER_000_08 =  6,
1166         IB_RNR_TIMER_000_12 =  7,
1167         IB_RNR_TIMER_000_16 =  8,
1168         IB_RNR_TIMER_000_24 =  9,
1169         IB_RNR_TIMER_000_32 = 10,
1170         IB_RNR_TIMER_000_48 = 11,
1171         IB_RNR_TIMER_000_64 = 12,
1172         IB_RNR_TIMER_000_96 = 13,
1173         IB_RNR_TIMER_001_28 = 14,
1174         IB_RNR_TIMER_001_92 = 15,
1175         IB_RNR_TIMER_002_56 = 16,
1176         IB_RNR_TIMER_003_84 = 17,
1177         IB_RNR_TIMER_005_12 = 18,
1178         IB_RNR_TIMER_007_68 = 19,
1179         IB_RNR_TIMER_010_24 = 20,
1180         IB_RNR_TIMER_015_36 = 21,
1181         IB_RNR_TIMER_020_48 = 22,
1182         IB_RNR_TIMER_030_72 = 23,
1183         IB_RNR_TIMER_040_96 = 24,
1184         IB_RNR_TIMER_061_44 = 25,
1185         IB_RNR_TIMER_081_92 = 26,
1186         IB_RNR_TIMER_122_88 = 27,
1187         IB_RNR_TIMER_163_84 = 28,
1188         IB_RNR_TIMER_245_76 = 29,
1189         IB_RNR_TIMER_327_68 = 30,
1190         IB_RNR_TIMER_491_52 = 31
1191 };
1192
1193 enum ib_qp_attr_mask {
1194         IB_QP_STATE                     = 1,
1195         IB_QP_CUR_STATE                 = (1<<1),
1196         IB_QP_EN_SQD_ASYNC_NOTIFY       = (1<<2),
1197         IB_QP_ACCESS_FLAGS              = (1<<3),
1198         IB_QP_PKEY_INDEX                = (1<<4),
1199         IB_QP_PORT                      = (1<<5),
1200         IB_QP_QKEY                      = (1<<6),
1201         IB_QP_AV                        = (1<<7),
1202         IB_QP_PATH_MTU                  = (1<<8),
1203         IB_QP_TIMEOUT                   = (1<<9),
1204         IB_QP_RETRY_CNT                 = (1<<10),
1205         IB_QP_RNR_RETRY                 = (1<<11),
1206         IB_QP_RQ_PSN                    = (1<<12),
1207         IB_QP_MAX_QP_RD_ATOMIC          = (1<<13),
1208         IB_QP_ALT_PATH                  = (1<<14),
1209         IB_QP_MIN_RNR_TIMER             = (1<<15),
1210         IB_QP_SQ_PSN                    = (1<<16),
1211         IB_QP_MAX_DEST_RD_ATOMIC        = (1<<17),
1212         IB_QP_PATH_MIG_STATE            = (1<<18),
1213         IB_QP_CAP                       = (1<<19),
1214         IB_QP_DEST_QPN                  = (1<<20),
1215         IB_QP_RESERVED1                 = (1<<21),
1216         IB_QP_RESERVED2                 = (1<<22),
1217         IB_QP_RESERVED3                 = (1<<23),
1218         IB_QP_RESERVED4                 = (1<<24),
1219         IB_QP_RATE_LIMIT                = (1<<25),
1220 };
1221
1222 enum ib_qp_state {
1223         IB_QPS_RESET,
1224         IB_QPS_INIT,
1225         IB_QPS_RTR,
1226         IB_QPS_RTS,
1227         IB_QPS_SQD,
1228         IB_QPS_SQE,
1229         IB_QPS_ERR
1230 };
1231
1232 enum ib_mig_state {
1233         IB_MIG_MIGRATED,
1234         IB_MIG_REARM,
1235         IB_MIG_ARMED
1236 };
1237
1238 enum ib_mw_type {
1239         IB_MW_TYPE_1 = 1,
1240         IB_MW_TYPE_2 = 2
1241 };
1242
1243 struct ib_qp_attr {
1244         enum ib_qp_state        qp_state;
1245         enum ib_qp_state        cur_qp_state;
1246         enum ib_mtu             path_mtu;
1247         enum ib_mig_state       path_mig_state;
1248         u32                     qkey;
1249         u32                     rq_psn;
1250         u32                     sq_psn;
1251         u32                     dest_qp_num;
1252         int                     qp_access_flags;
1253         struct ib_qp_cap        cap;
1254         struct rdma_ah_attr     ah_attr;
1255         struct rdma_ah_attr     alt_ah_attr;
1256         u16                     pkey_index;
1257         u16                     alt_pkey_index;
1258         u8                      en_sqd_async_notify;
1259         u8                      sq_draining;
1260         u8                      max_rd_atomic;
1261         u8                      max_dest_rd_atomic;
1262         u8                      min_rnr_timer;
1263         u8                      port_num;
1264         u8                      timeout;
1265         u8                      retry_cnt;
1266         u8                      rnr_retry;
1267         u8                      alt_port_num;
1268         u8                      alt_timeout;
1269         u32                     rate_limit;
1270 };
1271
1272 enum ib_wr_opcode {
1273         /* These are shared with userspace */
1274         IB_WR_RDMA_WRITE = IB_UVERBS_WR_RDMA_WRITE,
1275         IB_WR_RDMA_WRITE_WITH_IMM = IB_UVERBS_WR_RDMA_WRITE_WITH_IMM,
1276         IB_WR_SEND = IB_UVERBS_WR_SEND,
1277         IB_WR_SEND_WITH_IMM = IB_UVERBS_WR_SEND_WITH_IMM,
1278         IB_WR_RDMA_READ = IB_UVERBS_WR_RDMA_READ,
1279         IB_WR_ATOMIC_CMP_AND_SWP = IB_UVERBS_WR_ATOMIC_CMP_AND_SWP,
1280         IB_WR_ATOMIC_FETCH_AND_ADD = IB_UVERBS_WR_ATOMIC_FETCH_AND_ADD,
1281         IB_WR_LSO = IB_UVERBS_WR_TSO,
1282         IB_WR_SEND_WITH_INV = IB_UVERBS_WR_SEND_WITH_INV,
1283         IB_WR_RDMA_READ_WITH_INV = IB_UVERBS_WR_RDMA_READ_WITH_INV,
1284         IB_WR_LOCAL_INV = IB_UVERBS_WR_LOCAL_INV,
1285         IB_WR_MASKED_ATOMIC_CMP_AND_SWP =
1286                 IB_UVERBS_WR_MASKED_ATOMIC_CMP_AND_SWP,
1287         IB_WR_MASKED_ATOMIC_FETCH_AND_ADD =
1288                 IB_UVERBS_WR_MASKED_ATOMIC_FETCH_AND_ADD,
1289
1290         /* These are kernel only and can not be issued by userspace */
1291         IB_WR_REG_MR = 0x20,
1292         IB_WR_REG_MR_INTEGRITY,
1293
1294         /* reserve values for low level drivers' internal use.
1295          * These values will not be used at all in the ib core layer.
1296          */
1297         IB_WR_RESERVED1 = 0xf0,
1298         IB_WR_RESERVED2,
1299         IB_WR_RESERVED3,
1300         IB_WR_RESERVED4,
1301         IB_WR_RESERVED5,
1302         IB_WR_RESERVED6,
1303         IB_WR_RESERVED7,
1304         IB_WR_RESERVED8,
1305         IB_WR_RESERVED9,
1306         IB_WR_RESERVED10,
1307 };
1308
1309 enum ib_send_flags {
1310         IB_SEND_FENCE           = 1,
1311         IB_SEND_SIGNALED        = (1<<1),
1312         IB_SEND_SOLICITED       = (1<<2),
1313         IB_SEND_INLINE          = (1<<3),
1314         IB_SEND_IP_CSUM         = (1<<4),
1315
1316         /* reserve bits 26-31 for low level drivers' internal use */
1317         IB_SEND_RESERVED_START  = (1 << 26),
1318         IB_SEND_RESERVED_END    = (1 << 31),
1319 };
1320
1321 struct ib_sge {
1322         u64     addr;
1323         u32     length;
1324         u32     lkey;
1325 };
1326
1327 struct ib_cqe {
1328         void (*done)(struct ib_cq *cq, struct ib_wc *wc);
1329 };
1330
1331 struct ib_send_wr {
1332         struct ib_send_wr      *next;
1333         union {
1334                 u64             wr_id;
1335                 struct ib_cqe   *wr_cqe;
1336         };
1337         struct ib_sge          *sg_list;
1338         int                     num_sge;
1339         enum ib_wr_opcode       opcode;
1340         int                     send_flags;
1341         union {
1342                 __be32          imm_data;
1343                 u32             invalidate_rkey;
1344         } ex;
1345 };
1346
1347 struct ib_rdma_wr {
1348         struct ib_send_wr       wr;
1349         u64                     remote_addr;
1350         u32                     rkey;
1351 };
1352
1353 static inline const struct ib_rdma_wr *rdma_wr(const struct ib_send_wr *wr)
1354 {
1355         return container_of(wr, struct ib_rdma_wr, wr);
1356 }
1357
1358 struct ib_atomic_wr {
1359         struct ib_send_wr       wr;
1360         u64                     remote_addr;
1361         u64                     compare_add;
1362         u64                     swap;
1363         u64                     compare_add_mask;
1364         u64                     swap_mask;
1365         u32                     rkey;
1366 };
1367
1368 static inline const struct ib_atomic_wr *atomic_wr(const struct ib_send_wr *wr)
1369 {
1370         return container_of(wr, struct ib_atomic_wr, wr);
1371 }
1372
1373 struct ib_ud_wr {
1374         struct ib_send_wr       wr;
1375         struct ib_ah            *ah;
1376         void                    *header;
1377         int                     hlen;
1378         int                     mss;
1379         u32                     remote_qpn;
1380         u32                     remote_qkey;
1381         u16                     pkey_index; /* valid for GSI only */
1382         u8                      port_num;   /* valid for DR SMPs on switch only */
1383 };
1384
1385 static inline const struct ib_ud_wr *ud_wr(const struct ib_send_wr *wr)
1386 {
1387         return container_of(wr, struct ib_ud_wr, wr);
1388 }
1389
1390 struct ib_reg_wr {
1391         struct ib_send_wr       wr;
1392         struct ib_mr            *mr;
1393         u32                     key;
1394         int                     access;
1395 };
1396
1397 static inline const struct ib_reg_wr *reg_wr(const struct ib_send_wr *wr)
1398 {
1399         return container_of(wr, struct ib_reg_wr, wr);
1400 }
1401
1402 struct ib_recv_wr {
1403         struct ib_recv_wr      *next;
1404         union {
1405                 u64             wr_id;
1406                 struct ib_cqe   *wr_cqe;
1407         };
1408         struct ib_sge          *sg_list;
1409         int                     num_sge;
1410 };
1411
1412 enum ib_access_flags {
1413         IB_ACCESS_LOCAL_WRITE = IB_UVERBS_ACCESS_LOCAL_WRITE,
1414         IB_ACCESS_REMOTE_WRITE = IB_UVERBS_ACCESS_REMOTE_WRITE,
1415         IB_ACCESS_REMOTE_READ = IB_UVERBS_ACCESS_REMOTE_READ,
1416         IB_ACCESS_REMOTE_ATOMIC = IB_UVERBS_ACCESS_REMOTE_ATOMIC,
1417         IB_ACCESS_MW_BIND = IB_UVERBS_ACCESS_MW_BIND,
1418         IB_ZERO_BASED = IB_UVERBS_ACCESS_ZERO_BASED,
1419         IB_ACCESS_ON_DEMAND = IB_UVERBS_ACCESS_ON_DEMAND,
1420         IB_ACCESS_HUGETLB = IB_UVERBS_ACCESS_HUGETLB,
1421         IB_ACCESS_RELAXED_ORDERING = IB_UVERBS_ACCESS_RELAXED_ORDERING,
1422
1423         IB_ACCESS_OPTIONAL = IB_UVERBS_ACCESS_OPTIONAL_RANGE,
1424         IB_ACCESS_SUPPORTED =
1425                 ((IB_ACCESS_HUGETLB << 1) - 1) | IB_ACCESS_OPTIONAL,
1426 };
1427
1428 /*
1429  * XXX: these are apparently used for ->rereg_user_mr, no idea why they
1430  * are hidden here instead of a uapi header!
1431  */
1432 enum ib_mr_rereg_flags {
1433         IB_MR_REREG_TRANS       = 1,
1434         IB_MR_REREG_PD          = (1<<1),
1435         IB_MR_REREG_ACCESS      = (1<<2),
1436         IB_MR_REREG_SUPPORTED   = ((IB_MR_REREG_ACCESS << 1) - 1)
1437 };
1438
1439 struct ib_fmr_attr {
1440         int     max_pages;
1441         int     max_maps;
1442         u8      page_shift;
1443 };
1444
1445 struct ib_umem;
1446
1447 enum rdma_remove_reason {
1448         /*
1449          * Userspace requested uobject deletion or initial try
1450          * to remove uobject via cleanup. Call could fail
1451          */
1452         RDMA_REMOVE_DESTROY,
1453         /* Context deletion. This call should delete the actual object itself */
1454         RDMA_REMOVE_CLOSE,
1455         /* Driver is being hot-unplugged. This call should delete the actual object itself */
1456         RDMA_REMOVE_DRIVER_REMOVE,
1457         /* uobj is being cleaned-up before being committed */
1458         RDMA_REMOVE_ABORT,
1459 };
1460
1461 struct ib_rdmacg_object {
1462 #ifdef CONFIG_CGROUP_RDMA
1463         struct rdma_cgroup      *cg;            /* owner rdma cgroup */
1464 #endif
1465 };
1466
1467 struct ib_ucontext {
1468         struct ib_device       *device;
1469         struct ib_uverbs_file  *ufile;
1470         /*
1471          * 'closing' can be read by the driver only during a destroy callback,
1472          * it is set when we are closing the file descriptor and indicates
1473          * that mm_sem may be locked.
1474          */
1475         bool closing;
1476
1477         bool cleanup_retryable;
1478
1479         struct ib_rdmacg_object cg_obj;
1480         /*
1481          * Implementation details of the RDMA core, don't use in drivers:
1482          */
1483         struct rdma_restrack_entry res;
1484         struct xarray mmap_xa;
1485 };
1486
1487 struct ib_uobject {
1488         u64                     user_handle;    /* handle given to us by userspace */
1489         /* ufile & ucontext owning this object */
1490         struct ib_uverbs_file  *ufile;
1491         /* FIXME, save memory: ufile->context == context */
1492         struct ib_ucontext     *context;        /* associated user context */
1493         void                   *object;         /* containing object */
1494         struct list_head        list;           /* link to context's list */
1495         struct ib_rdmacg_object cg_obj;         /* rdmacg object */
1496         int                     id;             /* index into kernel idr */
1497         struct kref             ref;
1498         atomic_t                usecnt;         /* protects exclusive access */
1499         struct rcu_head         rcu;            /* kfree_rcu() overhead */
1500
1501         const struct uverbs_api_object *uapi_object;
1502 };
1503
1504 struct ib_udata {
1505         const void __user *inbuf;
1506         void __user *outbuf;
1507         size_t       inlen;
1508         size_t       outlen;
1509 };
1510
1511 struct ib_pd {
1512         u32                     local_dma_lkey;
1513         u32                     flags;
1514         struct ib_device       *device;
1515         struct ib_uobject      *uobject;
1516         atomic_t                usecnt; /* count all resources */
1517
1518         u32                     unsafe_global_rkey;
1519
1520         /*
1521          * Implementation details of the RDMA core, don't use in drivers:
1522          */
1523         struct ib_mr           *__internal_mr;
1524         struct rdma_restrack_entry res;
1525 };
1526
1527 struct ib_xrcd {
1528         struct ib_device       *device;
1529         atomic_t                usecnt; /* count all exposed resources */
1530         struct inode           *inode;
1531
1532         struct mutex            tgt_qp_mutex;
1533         struct list_head        tgt_qp_list;
1534 };
1535
1536 struct ib_ah {
1537         struct ib_device        *device;
1538         struct ib_pd            *pd;
1539         struct ib_uobject       *uobject;
1540         const struct ib_gid_attr *sgid_attr;
1541         enum rdma_ah_attr_type  type;
1542 };
1543
1544 typedef void (*ib_comp_handler)(struct ib_cq *cq, void *cq_context);
1545
1546 enum ib_poll_context {
1547         IB_POLL_DIRECT,            /* caller context, no hw completions */
1548         IB_POLL_SOFTIRQ,           /* poll from softirq context */
1549         IB_POLL_WORKQUEUE,         /* poll from workqueue */
1550         IB_POLL_UNBOUND_WORKQUEUE, /* poll from unbound workqueue */
1551 };
1552
1553 struct ib_cq {
1554         struct ib_device       *device;
1555         struct ib_ucq_object   *uobject;
1556         ib_comp_handler         comp_handler;
1557         void                  (*event_handler)(struct ib_event *, void *);
1558         void                   *cq_context;
1559         int                     cqe;
1560         atomic_t                usecnt; /* count number of work queues */
1561         enum ib_poll_context    poll_ctx;
1562         struct ib_wc            *wc;
1563         union {
1564                 struct irq_poll         iop;
1565                 struct work_struct      work;
1566         };
1567         struct workqueue_struct *comp_wq;
1568         struct dim *dim;
1569
1570         /* updated only by trace points */
1571         ktime_t timestamp;
1572         bool interrupt;
1573
1574         /*
1575          * Implementation details of the RDMA core, don't use in drivers:
1576          */
1577         struct rdma_restrack_entry res;
1578 };
1579
1580 struct ib_srq {
1581         struct ib_device       *device;
1582         struct ib_pd           *pd;
1583         struct ib_usrq_object  *uobject;
1584         void                  (*event_handler)(struct ib_event *, void *);
1585         void                   *srq_context;
1586         enum ib_srq_type        srq_type;
1587         atomic_t                usecnt;
1588
1589         struct {
1590                 struct ib_cq   *cq;
1591                 union {
1592                         struct {
1593                                 struct ib_xrcd *xrcd;
1594                                 u32             srq_num;
1595                         } xrc;
1596                 };
1597         } ext;
1598 };
1599
1600 enum ib_raw_packet_caps {
1601         /* Strip cvlan from incoming packet and report it in the matching work
1602          * completion is supported.
1603          */
1604         IB_RAW_PACKET_CAP_CVLAN_STRIPPING       = (1 << 0),
1605         /* Scatter FCS field of an incoming packet to host memory is supported.
1606          */
1607         IB_RAW_PACKET_CAP_SCATTER_FCS           = (1 << 1),
1608         /* Checksum offloads are supported (for both send and receive). */
1609         IB_RAW_PACKET_CAP_IP_CSUM               = (1 << 2),
1610         /* When a packet is received for an RQ with no receive WQEs, the
1611          * packet processing is delayed.
1612          */
1613         IB_RAW_PACKET_CAP_DELAY_DROP            = (1 << 3),
1614 };
1615
1616 enum ib_wq_type {
1617         IB_WQT_RQ
1618 };
1619
1620 enum ib_wq_state {
1621         IB_WQS_RESET,
1622         IB_WQS_RDY,
1623         IB_WQS_ERR
1624 };
1625
1626 struct ib_wq {
1627         struct ib_device       *device;
1628         struct ib_uwq_object   *uobject;
1629         void                *wq_context;
1630         void                (*event_handler)(struct ib_event *, void *);
1631         struct ib_pd           *pd;
1632         struct ib_cq           *cq;
1633         u32             wq_num;
1634         enum ib_wq_state       state;
1635         enum ib_wq_type wq_type;
1636         atomic_t                usecnt;
1637 };
1638
1639 enum ib_wq_flags {
1640         IB_WQ_FLAGS_CVLAN_STRIPPING     = 1 << 0,
1641         IB_WQ_FLAGS_SCATTER_FCS         = 1 << 1,
1642         IB_WQ_FLAGS_DELAY_DROP          = 1 << 2,
1643         IB_WQ_FLAGS_PCI_WRITE_END_PADDING = 1 << 3,
1644 };
1645
1646 struct ib_wq_init_attr {
1647         void                   *wq_context;
1648         enum ib_wq_type wq_type;
1649         u32             max_wr;
1650         u32             max_sge;
1651         struct  ib_cq          *cq;
1652         void                (*event_handler)(struct ib_event *, void *);
1653         u32             create_flags; /* Use enum ib_wq_flags */
1654 };
1655
1656 enum ib_wq_attr_mask {
1657         IB_WQ_STATE             = 1 << 0,
1658         IB_WQ_CUR_STATE         = 1 << 1,
1659         IB_WQ_FLAGS             = 1 << 2,
1660 };
1661
1662 struct ib_wq_attr {
1663         enum    ib_wq_state     wq_state;
1664         enum    ib_wq_state     curr_wq_state;
1665         u32                     flags; /* Use enum ib_wq_flags */
1666         u32                     flags_mask; /* Use enum ib_wq_flags */
1667 };
1668
1669 struct ib_rwq_ind_table {
1670         struct ib_device        *device;
1671         struct ib_uobject      *uobject;
1672         atomic_t                usecnt;
1673         u32             ind_tbl_num;
1674         u32             log_ind_tbl_size;
1675         struct ib_wq    **ind_tbl;
1676 };
1677
1678 struct ib_rwq_ind_table_init_attr {
1679         u32             log_ind_tbl_size;
1680         /* Each entry is a pointer to Receive Work Queue */
1681         struct ib_wq    **ind_tbl;
1682 };
1683
1684 enum port_pkey_state {
1685         IB_PORT_PKEY_NOT_VALID = 0,
1686         IB_PORT_PKEY_VALID = 1,
1687         IB_PORT_PKEY_LISTED = 2,
1688 };
1689
1690 struct ib_qp_security;
1691
1692 struct ib_port_pkey {
1693         enum port_pkey_state    state;
1694         u16                     pkey_index;
1695         u8                      port_num;
1696         struct list_head        qp_list;
1697         struct list_head        to_error_list;
1698         struct ib_qp_security  *sec;
1699 };
1700
1701 struct ib_ports_pkeys {
1702         struct ib_port_pkey     main;
1703         struct ib_port_pkey     alt;
1704 };
1705
1706 struct ib_qp_security {
1707         struct ib_qp           *qp;
1708         struct ib_device       *dev;
1709         /* Hold this mutex when changing port and pkey settings. */
1710         struct mutex            mutex;
1711         struct ib_ports_pkeys  *ports_pkeys;
1712         /* A list of all open shared QP handles.  Required to enforce security
1713          * properly for all users of a shared QP.
1714          */
1715         struct list_head        shared_qp_list;
1716         void                   *security;
1717         bool                    destroying;
1718         atomic_t                error_list_count;
1719         struct completion       error_complete;
1720         int                     error_comps_pending;
1721 };
1722
1723 /*
1724  * @max_write_sge: Maximum SGE elements per RDMA WRITE request.
1725  * @max_read_sge:  Maximum SGE elements per RDMA READ request.
1726  */
1727 struct ib_qp {
1728         struct ib_device       *device;
1729         struct ib_pd           *pd;
1730         struct ib_cq           *send_cq;
1731         struct ib_cq           *recv_cq;
1732         spinlock_t              mr_lock;
1733         int                     mrs_used;
1734         struct list_head        rdma_mrs;
1735         struct list_head        sig_mrs;
1736         struct ib_srq          *srq;
1737         struct ib_xrcd         *xrcd; /* XRC TGT QPs only */
1738         struct list_head        xrcd_list;
1739
1740         /* count times opened, mcast attaches, flow attaches */
1741         atomic_t                usecnt;
1742         struct list_head        open_list;
1743         struct ib_qp           *real_qp;
1744         struct ib_uqp_object   *uobject;
1745         void                  (*event_handler)(struct ib_event *, void *);
1746         void                   *qp_context;
1747         /* sgid_attrs associated with the AV's */
1748         const struct ib_gid_attr *av_sgid_attr;
1749         const struct ib_gid_attr *alt_path_sgid_attr;
1750         u32                     qp_num;
1751         u32                     max_write_sge;
1752         u32                     max_read_sge;
1753         enum ib_qp_type         qp_type;
1754         struct ib_rwq_ind_table *rwq_ind_tbl;
1755         struct ib_qp_security  *qp_sec;
1756         u8                      port;
1757
1758         bool                    integrity_en;
1759         /*
1760          * Implementation details of the RDMA core, don't use in drivers:
1761          */
1762         struct rdma_restrack_entry     res;
1763
1764         /* The counter the qp is bind to */
1765         struct rdma_counter    *counter;
1766 };
1767
1768 struct ib_dm {
1769         struct ib_device  *device;
1770         u32                length;
1771         u32                flags;
1772         struct ib_uobject *uobject;
1773         atomic_t           usecnt;
1774 };
1775
1776 struct ib_mr {
1777         struct ib_device  *device;
1778         struct ib_pd      *pd;
1779         u32                lkey;
1780         u32                rkey;
1781         u64                iova;
1782         u64                length;
1783         unsigned int       page_size;
1784         enum ib_mr_type    type;
1785         bool               need_inval;
1786         union {
1787                 struct ib_uobject       *uobject;       /* user */
1788                 struct list_head        qp_entry;       /* FR */
1789         };
1790
1791         struct ib_dm      *dm;
1792         struct ib_sig_attrs *sig_attrs; /* only for IB_MR_TYPE_INTEGRITY MRs */
1793         /*
1794          * Implementation details of the RDMA core, don't use in drivers:
1795          */
1796         struct rdma_restrack_entry res;
1797 };
1798
1799 struct ib_mw {
1800         struct ib_device        *device;
1801         struct ib_pd            *pd;
1802         struct ib_uobject       *uobject;
1803         u32                     rkey;
1804         enum ib_mw_type         type;
1805 };
1806
1807 struct ib_fmr {
1808         struct ib_device        *device;
1809         struct ib_pd            *pd;
1810         struct list_head        list;
1811         u32                     lkey;
1812         u32                     rkey;
1813 };
1814
1815 /* Supported steering options */
1816 enum ib_flow_attr_type {
1817         /* steering according to rule specifications */
1818         IB_FLOW_ATTR_NORMAL             = 0x0,
1819         /* default unicast and multicast rule -
1820          * receive all Eth traffic which isn't steered to any QP
1821          */
1822         IB_FLOW_ATTR_ALL_DEFAULT        = 0x1,
1823         /* default multicast rule -
1824          * receive all Eth multicast traffic which isn't steered to any QP
1825          */
1826         IB_FLOW_ATTR_MC_DEFAULT         = 0x2,
1827         /* sniffer rule - receive all port traffic */
1828         IB_FLOW_ATTR_SNIFFER            = 0x3
1829 };
1830
1831 /* Supported steering header types */
1832 enum ib_flow_spec_type {
1833         /* L2 headers*/
1834         IB_FLOW_SPEC_ETH                = 0x20,
1835         IB_FLOW_SPEC_IB                 = 0x22,
1836         /* L3 header*/
1837         IB_FLOW_SPEC_IPV4               = 0x30,
1838         IB_FLOW_SPEC_IPV6               = 0x31,
1839         IB_FLOW_SPEC_ESP                = 0x34,
1840         /* L4 headers*/
1841         IB_FLOW_SPEC_TCP                = 0x40,
1842         IB_FLOW_SPEC_UDP                = 0x41,
1843         IB_FLOW_SPEC_VXLAN_TUNNEL       = 0x50,
1844         IB_FLOW_SPEC_GRE                = 0x51,
1845         IB_FLOW_SPEC_MPLS               = 0x60,
1846         IB_FLOW_SPEC_INNER              = 0x100,
1847         /* Actions */
1848         IB_FLOW_SPEC_ACTION_TAG         = 0x1000,
1849         IB_FLOW_SPEC_ACTION_DROP        = 0x1001,
1850         IB_FLOW_SPEC_ACTION_HANDLE      = 0x1002,
1851         IB_FLOW_SPEC_ACTION_COUNT       = 0x1003,
1852 };
1853 #define IB_FLOW_SPEC_LAYER_MASK 0xF0
1854 #define IB_FLOW_SPEC_SUPPORT_LAYERS 10
1855
1856 /* Flow steering rule priority is set according to it's domain.
1857  * Lower domain value means higher priority.
1858  */
1859 enum ib_flow_domain {
1860         IB_FLOW_DOMAIN_USER,
1861         IB_FLOW_DOMAIN_ETHTOOL,
1862         IB_FLOW_DOMAIN_RFS,
1863         IB_FLOW_DOMAIN_NIC,
1864         IB_FLOW_DOMAIN_NUM /* Must be last */
1865 };
1866
1867 enum ib_flow_flags {
1868         IB_FLOW_ATTR_FLAGS_DONT_TRAP = 1UL << 1, /* Continue match, no steal */
1869         IB_FLOW_ATTR_FLAGS_EGRESS = 1UL << 2, /* Egress flow */
1870         IB_FLOW_ATTR_FLAGS_RESERVED  = 1UL << 3  /* Must be last */
1871 };
1872
1873 struct ib_flow_eth_filter {
1874         u8      dst_mac[6];
1875         u8      src_mac[6];
1876         __be16  ether_type;
1877         __be16  vlan_tag;
1878         /* Must be last */
1879         u8      real_sz[];
1880 };
1881
1882 struct ib_flow_spec_eth {
1883         u32                       type;
1884         u16                       size;
1885         struct ib_flow_eth_filter val;
1886         struct ib_flow_eth_filter mask;
1887 };
1888
1889 struct ib_flow_ib_filter {
1890         __be16 dlid;
1891         __u8   sl;
1892         /* Must be last */
1893         u8      real_sz[];
1894 };
1895
1896 struct ib_flow_spec_ib {
1897         u32                      type;
1898         u16                      size;
1899         struct ib_flow_ib_filter val;
1900         struct ib_flow_ib_filter mask;
1901 };
1902
1903 /* IPv4 header flags */
1904 enum ib_ipv4_flags {
1905         IB_IPV4_DONT_FRAG = 0x2, /* Don't enable packet fragmentation */
1906         IB_IPV4_MORE_FRAG = 0X4  /* For All fragmented packets except the
1907                                     last have this flag set */
1908 };
1909
1910 struct ib_flow_ipv4_filter {
1911         __be32  src_ip;
1912         __be32  dst_ip;
1913         u8      proto;
1914         u8      tos;
1915         u8      ttl;
1916         u8      flags;
1917         /* Must be last */
1918         u8      real_sz[];
1919 };
1920
1921 struct ib_flow_spec_ipv4 {
1922         u32                        type;
1923         u16                        size;
1924         struct ib_flow_ipv4_filter val;
1925         struct ib_flow_ipv4_filter mask;
1926 };
1927
1928 struct ib_flow_ipv6_filter {
1929         u8      src_ip[16];
1930         u8      dst_ip[16];
1931         __be32  flow_label;
1932         u8      next_hdr;
1933         u8      traffic_class;
1934         u8      hop_limit;
1935         /* Must be last */
1936         u8      real_sz[];
1937 };
1938
1939 struct ib_flow_spec_ipv6 {
1940         u32                        type;
1941         u16                        size;
1942         struct ib_flow_ipv6_filter val;
1943         struct ib_flow_ipv6_filter mask;
1944 };
1945
1946 struct ib_flow_tcp_udp_filter {
1947         __be16  dst_port;
1948         __be16  src_port;
1949         /* Must be last */
1950         u8      real_sz[];
1951 };
1952
1953 struct ib_flow_spec_tcp_udp {
1954         u32                           type;
1955         u16                           size;
1956         struct ib_flow_tcp_udp_filter val;
1957         struct ib_flow_tcp_udp_filter mask;
1958 };
1959
1960 struct ib_flow_tunnel_filter {
1961         __be32  tunnel_id;
1962         u8      real_sz[];
1963 };
1964
1965 /* ib_flow_spec_tunnel describes the Vxlan tunnel
1966  * the tunnel_id from val has the vni value
1967  */
1968 struct ib_flow_spec_tunnel {
1969         u32                           type;
1970         u16                           size;
1971         struct ib_flow_tunnel_filter  val;
1972         struct ib_flow_tunnel_filter  mask;
1973 };
1974
1975 struct ib_flow_esp_filter {
1976         __be32  spi;
1977         __be32  seq;
1978         /* Must be last */
1979         u8      real_sz[];
1980 };
1981
1982 struct ib_flow_spec_esp {
1983         u32                           type;
1984         u16                           size;
1985         struct ib_flow_esp_filter     val;
1986         struct ib_flow_esp_filter     mask;
1987 };
1988
1989 struct ib_flow_gre_filter {
1990         __be16 c_ks_res0_ver;
1991         __be16 protocol;
1992         __be32 key;
1993         /* Must be last */
1994         u8      real_sz[];
1995 };
1996
1997 struct ib_flow_spec_gre {
1998         u32                           type;
1999         u16                           size;
2000         struct ib_flow_gre_filter     val;
2001         struct ib_flow_gre_filter     mask;
2002 };
2003
2004 struct ib_flow_mpls_filter {
2005         __be32 tag;
2006         /* Must be last */
2007         u8      real_sz[];
2008 };
2009
2010 struct ib_flow_spec_mpls {
2011         u32                           type;
2012         u16                           size;
2013         struct ib_flow_mpls_filter     val;
2014         struct ib_flow_mpls_filter     mask;
2015 };
2016
2017 struct ib_flow_spec_action_tag {
2018         enum ib_flow_spec_type        type;
2019         u16                           size;
2020         u32                           tag_id;
2021 };
2022
2023 struct ib_flow_spec_action_drop {
2024         enum ib_flow_spec_type        type;
2025         u16                           size;
2026 };
2027
2028 struct ib_flow_spec_action_handle {
2029         enum ib_flow_spec_type        type;
2030         u16                           size;
2031         struct ib_flow_action        *act;
2032 };
2033
2034 enum ib_counters_description {
2035         IB_COUNTER_PACKETS,
2036         IB_COUNTER_BYTES,
2037 };
2038
2039 struct ib_flow_spec_action_count {
2040         enum ib_flow_spec_type type;
2041         u16 size;
2042         struct ib_counters *counters;
2043 };
2044
2045 union ib_flow_spec {
2046         struct {
2047                 u32                     type;
2048                 u16                     size;
2049         };
2050         struct ib_flow_spec_eth         eth;
2051         struct ib_flow_spec_ib          ib;
2052         struct ib_flow_spec_ipv4        ipv4;
2053         struct ib_flow_spec_tcp_udp     tcp_udp;
2054         struct ib_flow_spec_ipv6        ipv6;
2055         struct ib_flow_spec_tunnel      tunnel;
2056         struct ib_flow_spec_esp         esp;
2057         struct ib_flow_spec_gre         gre;
2058         struct ib_flow_spec_mpls        mpls;
2059         struct ib_flow_spec_action_tag  flow_tag;
2060         struct ib_flow_spec_action_drop drop;
2061         struct ib_flow_spec_action_handle action;
2062         struct ib_flow_spec_action_count flow_count;
2063 };
2064
2065 struct ib_flow_attr {
2066         enum ib_flow_attr_type type;
2067         u16          size;
2068         u16          priority;
2069         u32          flags;
2070         u8           num_of_specs;
2071         u8           port;
2072         union ib_flow_spec flows[];
2073 };
2074
2075 struct ib_flow {
2076         struct ib_qp            *qp;
2077         struct ib_device        *device;
2078         struct ib_uobject       *uobject;
2079 };
2080
2081 enum ib_flow_action_type {
2082         IB_FLOW_ACTION_UNSPECIFIED,
2083         IB_FLOW_ACTION_ESP = 1,
2084 };
2085
2086 struct ib_flow_action_attrs_esp_keymats {
2087         enum ib_uverbs_flow_action_esp_keymat                   protocol;
2088         union {
2089                 struct ib_uverbs_flow_action_esp_keymat_aes_gcm aes_gcm;
2090         } keymat;
2091 };
2092
2093 struct ib_flow_action_attrs_esp_replays {
2094         enum ib_uverbs_flow_action_esp_replay                   protocol;
2095         union {
2096                 struct ib_uverbs_flow_action_esp_replay_bmp     bmp;
2097         } replay;
2098 };
2099
2100 enum ib_flow_action_attrs_esp_flags {
2101         /* All user-space flags at the top: Use enum ib_uverbs_flow_action_esp_flags
2102          * This is done in order to share the same flags between user-space and
2103          * kernel and spare an unnecessary translation.
2104          */
2105
2106         /* Kernel flags */
2107         IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED  = 1ULL << 32,
2108         IB_FLOW_ACTION_ESP_FLAGS_MOD_ESP_ATTRS  = 1ULL << 33,
2109 };
2110
2111 struct ib_flow_spec_list {
2112         struct ib_flow_spec_list        *next;
2113         union ib_flow_spec              spec;
2114 };
2115
2116 struct ib_flow_action_attrs_esp {
2117         struct ib_flow_action_attrs_esp_keymats         *keymat;
2118         struct ib_flow_action_attrs_esp_replays         *replay;
2119         struct ib_flow_spec_list                        *encap;
2120         /* Used only if IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED is enabled.
2121          * Value of 0 is a valid value.
2122          */
2123         u32                                             esn;
2124         u32                                             spi;
2125         u32                                             seq;
2126         u32                                             tfc_pad;
2127         /* Use enum ib_flow_action_attrs_esp_flags */
2128         u64                                             flags;
2129         u64                                             hard_limit_pkts;
2130 };
2131
2132 struct ib_flow_action {
2133         struct ib_device                *device;
2134         struct ib_uobject               *uobject;
2135         enum ib_flow_action_type        type;
2136         atomic_t                        usecnt;
2137 };
2138
2139 struct ib_mad;
2140 struct ib_grh;
2141
2142 enum ib_process_mad_flags {
2143         IB_MAD_IGNORE_MKEY      = 1,
2144         IB_MAD_IGNORE_BKEY      = 2,
2145         IB_MAD_IGNORE_ALL       = IB_MAD_IGNORE_MKEY | IB_MAD_IGNORE_BKEY
2146 };
2147
2148 enum ib_mad_result {
2149         IB_MAD_RESULT_FAILURE  = 0,      /* (!SUCCESS is the important flag) */
2150         IB_MAD_RESULT_SUCCESS  = 1 << 0, /* MAD was successfully processed   */
2151         IB_MAD_RESULT_REPLY    = 1 << 1, /* Reply packet needs to be sent    */
2152         IB_MAD_RESULT_CONSUMED = 1 << 2  /* Packet consumed: stop processing */
2153 };
2154
2155 struct ib_port_cache {
2156         u64                   subnet_prefix;
2157         struct ib_pkey_cache  *pkey;
2158         struct ib_gid_table   *gid;
2159         u8                     lmc;
2160         enum ib_port_state     port_state;
2161 };
2162
2163 struct ib_port_immutable {
2164         int                           pkey_tbl_len;
2165         int                           gid_tbl_len;
2166         u32                           core_cap_flags;
2167         u32                           max_mad_size;
2168 };
2169
2170 struct ib_port_data {
2171         struct ib_device *ib_dev;
2172
2173         struct ib_port_immutable immutable;
2174
2175         spinlock_t pkey_list_lock;
2176         struct list_head pkey_list;
2177
2178         struct ib_port_cache cache;
2179
2180         spinlock_t netdev_lock;
2181         struct net_device __rcu *netdev;
2182         struct hlist_node ndev_hash_link;
2183         struct rdma_port_counter port_counter;
2184         struct rdma_hw_stats *hw_stats;
2185 };
2186
2187 /* rdma netdev type - specifies protocol type */
2188 enum rdma_netdev_t {
2189         RDMA_NETDEV_OPA_VNIC,
2190         RDMA_NETDEV_IPOIB,
2191 };
2192
2193 /**
2194  * struct rdma_netdev - rdma netdev
2195  * For cases where netstack interfacing is required.
2196  */
2197 struct rdma_netdev {
2198         void              *clnt_priv;
2199         struct ib_device  *hca;
2200         u8                 port_num;
2201
2202         /*
2203          * cleanup function must be specified.
2204          * FIXME: This is only used for OPA_VNIC and that usage should be
2205          * removed too.
2206          */
2207         void (*free_rdma_netdev)(struct net_device *netdev);
2208
2209         /* control functions */
2210         void (*set_id)(struct net_device *netdev, int id);
2211         /* send packet */
2212         int (*send)(struct net_device *dev, struct sk_buff *skb,
2213                     struct ib_ah *address, u32 dqpn);
2214         /* multicast */
2215         int (*attach_mcast)(struct net_device *dev, struct ib_device *hca,
2216                             union ib_gid *gid, u16 mlid,
2217                             int set_qkey, u32 qkey);
2218         int (*detach_mcast)(struct net_device *dev, struct ib_device *hca,
2219                             union ib_gid *gid, u16 mlid);
2220 };
2221
2222 struct rdma_netdev_alloc_params {
2223         size_t sizeof_priv;
2224         unsigned int txqs;
2225         unsigned int rxqs;
2226         void *param;
2227
2228         int (*initialize_rdma_netdev)(struct ib_device *device, u8 port_num,
2229                                       struct net_device *netdev, void *param);
2230 };
2231
2232 struct ib_odp_counters {
2233         atomic64_t faults;
2234         atomic64_t invalidations;
2235 };
2236
2237 struct ib_counters {
2238         struct ib_device        *device;
2239         struct ib_uobject       *uobject;
2240         /* num of objects attached */
2241         atomic_t        usecnt;
2242 };
2243
2244 struct ib_counters_read_attr {
2245         u64     *counters_buff;
2246         u32     ncounters;
2247         u32     flags; /* use enum ib_read_counters_flags */
2248 };
2249
2250 struct uverbs_attr_bundle;
2251 struct iw_cm_id;
2252 struct iw_cm_conn_param;
2253
2254 #define INIT_RDMA_OBJ_SIZE(ib_struct, drv_struct, member)                      \
2255         .size_##ib_struct =                                                    \
2256                 (sizeof(struct drv_struct) +                                   \
2257                  BUILD_BUG_ON_ZERO(offsetof(struct drv_struct, member)) +      \
2258                  BUILD_BUG_ON_ZERO(                                            \
2259                          !__same_type(((struct drv_struct *)NULL)->member,     \
2260                                       struct ib_struct)))
2261
2262 #define rdma_zalloc_drv_obj_gfp(ib_dev, ib_type, gfp)                         \
2263         ((struct ib_type *)kzalloc(ib_dev->ops.size_##ib_type, gfp))
2264
2265 #define rdma_zalloc_drv_obj(ib_dev, ib_type)                                   \
2266         rdma_zalloc_drv_obj_gfp(ib_dev, ib_type, GFP_KERNEL)
2267
2268 #define DECLARE_RDMA_OBJ_SIZE(ib_struct) size_t size_##ib_struct
2269
2270 struct rdma_user_mmap_entry {
2271         struct kref ref;
2272         struct ib_ucontext *ucontext;
2273         unsigned long start_pgoff;
2274         size_t npages;
2275         bool driver_removed;
2276 };
2277
2278 /* Return the offset (in bytes) the user should pass to libc's mmap() */
2279 static inline u64
2280 rdma_user_mmap_get_offset(const struct rdma_user_mmap_entry *entry)
2281 {
2282         return (u64)entry->start_pgoff << PAGE_SHIFT;
2283 }
2284
2285 /**
2286  * struct ib_device_ops - InfiniBand device operations
2287  * This structure defines all the InfiniBand device operations, providers will
2288  * need to define the supported operations, otherwise they will be set to null.
2289  */
2290 struct ib_device_ops {
2291         struct module *owner;
2292         enum rdma_driver_id driver_id;
2293         u32 uverbs_abi_ver;
2294         unsigned int uverbs_no_driver_id_binding:1;
2295
2296         int (*post_send)(struct ib_qp *qp, const struct ib_send_wr *send_wr,
2297                          const struct ib_send_wr **bad_send_wr);
2298         int (*post_recv)(struct ib_qp *qp, const struct ib_recv_wr *recv_wr,
2299                          const struct ib_recv_wr **bad_recv_wr);
2300         void (*drain_rq)(struct ib_qp *qp);
2301         void (*drain_sq)(struct ib_qp *qp);
2302         int (*poll_cq)(struct ib_cq *cq, int num_entries, struct ib_wc *wc);
2303         int (*peek_cq)(struct ib_cq *cq, int wc_cnt);
2304         int (*req_notify_cq)(struct ib_cq *cq, enum ib_cq_notify_flags flags);
2305         int (*req_ncomp_notif)(struct ib_cq *cq, int wc_cnt);
2306         int (*post_srq_recv)(struct ib_srq *srq,
2307                              const struct ib_recv_wr *recv_wr,
2308                              const struct ib_recv_wr **bad_recv_wr);
2309         int (*process_mad)(struct ib_device *device, int process_mad_flags,
2310                            u8 port_num, const struct ib_wc *in_wc,
2311                            const struct ib_grh *in_grh,
2312                            const struct ib_mad *in_mad, struct ib_mad *out_mad,
2313                            size_t *out_mad_size, u16 *out_mad_pkey_index);
2314         int (*query_device)(struct ib_device *device,
2315                             struct ib_device_attr *device_attr,
2316                             struct ib_udata *udata);
2317         int (*modify_device)(struct ib_device *device, int device_modify_mask,
2318                              struct ib_device_modify *device_modify);
2319         void (*get_dev_fw_str)(struct ib_device *device, char *str);
2320         const struct cpumask *(*get_vector_affinity)(struct ib_device *ibdev,
2321                                                      int comp_vector);
2322         int (*query_port)(struct ib_device *device, u8 port_num,
2323                           struct ib_port_attr *port_attr);
2324         int (*modify_port)(struct ib_device *device, u8 port_num,
2325                            int port_modify_mask,
2326                            struct ib_port_modify *port_modify);
2327         /**
2328          * The following mandatory functions are used only at device
2329          * registration.  Keep functions such as these at the end of this
2330          * structure to avoid cache line misses when accessing struct ib_device
2331          * in fast paths.
2332          */
2333         int (*get_port_immutable)(struct ib_device *device, u8 port_num,
2334                                   struct ib_port_immutable *immutable);
2335         enum rdma_link_layer (*get_link_layer)(struct ib_device *device,
2336                                                u8 port_num);
2337         /**
2338          * When calling get_netdev, the HW vendor's driver should return the
2339          * net device of device @device at port @port_num or NULL if such
2340          * a net device doesn't exist. The vendor driver should call dev_hold
2341          * on this net device. The HW vendor's device driver must guarantee
2342          * that this function returns NULL before the net device has finished
2343          * NETDEV_UNREGISTER state.
2344          */
2345         struct net_device *(*get_netdev)(struct ib_device *device, u8 port_num);
2346         /**
2347          * rdma netdev operation
2348          *
2349          * Driver implementing alloc_rdma_netdev or rdma_netdev_get_params
2350          * must return -EOPNOTSUPP if it doesn't support the specified type.
2351          */
2352         struct net_device *(*alloc_rdma_netdev)(
2353                 struct ib_device *device, u8 port_num, enum rdma_netdev_t type,
2354                 const char *name, unsigned char name_assign_type,
2355                 void (*setup)(struct net_device *));
2356
2357         int (*rdma_netdev_get_params)(struct ib_device *device, u8 port_num,
2358                                       enum rdma_netdev_t type,
2359                                       struct rdma_netdev_alloc_params *params);
2360         /**
2361          * query_gid should be return GID value for @device, when @port_num
2362          * link layer is either IB or iWarp. It is no-op if @port_num port
2363          * is RoCE link layer.
2364          */
2365         int (*query_gid)(struct ib_device *device, u8 port_num, int index,
2366                          union ib_gid *gid);
2367         /**
2368          * When calling add_gid, the HW vendor's driver should add the gid
2369          * of device of port at gid index available at @attr. Meta-info of
2370          * that gid (for example, the network device related to this gid) is
2371          * available at @attr. @context allows the HW vendor driver to store
2372          * extra information together with a GID entry. The HW vendor driver may
2373          * allocate memory to contain this information and store it in @context
2374          * when a new GID entry is written to. Params are consistent until the
2375          * next call of add_gid or delete_gid. The function should return 0 on
2376          * success or error otherwise. The function could be called
2377          * concurrently for different ports. This function is only called when
2378          * roce_gid_table is used.
2379          */
2380         int (*add_gid)(const struct ib_gid_attr *attr, void **context);
2381         /**
2382          * When calling del_gid, the HW vendor's driver should delete the
2383          * gid of device @device at gid index gid_index of port port_num
2384          * available in @attr.
2385          * Upon the deletion of a GID entry, the HW vendor must free any
2386          * allocated memory. The caller will clear @context afterwards.
2387          * This function is only called when roce_gid_table is used.
2388          */
2389         int (*del_gid)(const struct ib_gid_attr *attr, void **context);
2390         int (*query_pkey)(struct ib_device *device, u8 port_num, u16 index,
2391                           u16 *pkey);
2392         int (*alloc_ucontext)(struct ib_ucontext *context,
2393                               struct ib_udata *udata);
2394         void (*dealloc_ucontext)(struct ib_ucontext *context);
2395         int (*mmap)(struct ib_ucontext *context, struct vm_area_struct *vma);
2396         /**
2397          * This will be called once refcount of an entry in mmap_xa reaches
2398          * zero. The type of the memory that was mapped may differ between
2399          * entries and is opaque to the rdma_user_mmap interface.
2400          * Therefore needs to be implemented by the driver in mmap_free.
2401          */
2402         void (*mmap_free)(struct rdma_user_mmap_entry *entry);
2403         void (*disassociate_ucontext)(struct ib_ucontext *ibcontext);
2404         int (*alloc_pd)(struct ib_pd *pd, struct ib_udata *udata);
2405         void (*dealloc_pd)(struct ib_pd *pd, struct ib_udata *udata);
2406         int (*create_ah)(struct ib_ah *ah, struct rdma_ah_attr *ah_attr,
2407                          u32 flags, struct ib_udata *udata);
2408         int (*modify_ah)(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
2409         int (*query_ah)(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
2410         void (*destroy_ah)(struct ib_ah *ah, u32 flags);
2411         int (*create_srq)(struct ib_srq *srq,
2412                           struct ib_srq_init_attr *srq_init_attr,
2413                           struct ib_udata *udata);
2414         int (*modify_srq)(struct ib_srq *srq, struct ib_srq_attr *srq_attr,
2415                           enum ib_srq_attr_mask srq_attr_mask,
2416                           struct ib_udata *udata);
2417         int (*query_srq)(struct ib_srq *srq, struct ib_srq_attr *srq_attr);
2418         void (*destroy_srq)(struct ib_srq *srq, struct ib_udata *udata);
2419         struct ib_qp *(*create_qp)(struct ib_pd *pd,
2420                                    struct ib_qp_init_attr *qp_init_attr,
2421                                    struct ib_udata *udata);
2422         int (*modify_qp)(struct ib_qp *qp, struct ib_qp_attr *qp_attr,
2423                          int qp_attr_mask, struct ib_udata *udata);
2424         int (*query_qp)(struct ib_qp *qp, struct ib_qp_attr *qp_attr,
2425                         int qp_attr_mask, struct ib_qp_init_attr *qp_init_attr);
2426         int (*destroy_qp)(struct ib_qp *qp, struct ib_udata *udata);
2427         int (*create_cq)(struct ib_cq *cq, const struct ib_cq_init_attr *attr,
2428                          struct ib_udata *udata);
2429         int (*modify_cq)(struct ib_cq *cq, u16 cq_count, u16 cq_period);
2430         void (*destroy_cq)(struct ib_cq *cq, struct ib_udata *udata);
2431         int (*resize_cq)(struct ib_cq *cq, int cqe, struct ib_udata *udata);
2432         struct ib_mr *(*get_dma_mr)(struct ib_pd *pd, int mr_access_flags);
2433         struct ib_mr *(*reg_user_mr)(struct ib_pd *pd, u64 start, u64 length,
2434                                      u64 virt_addr, int mr_access_flags,
2435                                      struct ib_udata *udata);
2436         int (*rereg_user_mr)(struct ib_mr *mr, int flags, u64 start, u64 length,
2437                              u64 virt_addr, int mr_access_flags,
2438                              struct ib_pd *pd, struct ib_udata *udata);
2439         int (*dereg_mr)(struct ib_mr *mr, struct ib_udata *udata);
2440         struct ib_mr *(*alloc_mr)(struct ib_pd *pd, enum ib_mr_type mr_type,
2441                                   u32 max_num_sg, struct ib_udata *udata);
2442         struct ib_mr *(*alloc_mr_integrity)(struct ib_pd *pd,
2443                                             u32 max_num_data_sg,
2444                                             u32 max_num_meta_sg);
2445         int (*advise_mr)(struct ib_pd *pd,
2446                          enum ib_uverbs_advise_mr_advice advice, u32 flags,
2447                          struct ib_sge *sg_list, u32 num_sge,
2448                          struct uverbs_attr_bundle *attrs);
2449         int (*map_mr_sg)(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
2450                          unsigned int *sg_offset);
2451         int (*check_mr_status)(struct ib_mr *mr, u32 check_mask,
2452                                struct ib_mr_status *mr_status);
2453         struct ib_mw *(*alloc_mw)(struct ib_pd *pd, enum ib_mw_type type,
2454                                   struct ib_udata *udata);
2455         int (*dealloc_mw)(struct ib_mw *mw);
2456         struct ib_fmr *(*alloc_fmr)(struct ib_pd *pd, int mr_access_flags,
2457                                     struct ib_fmr_attr *fmr_attr);
2458         int (*map_phys_fmr)(struct ib_fmr *fmr, u64 *page_list, int list_len,
2459                             u64 iova);
2460         int (*unmap_fmr)(struct list_head *fmr_list);
2461         int (*dealloc_fmr)(struct ib_fmr *fmr);
2462         int (*attach_mcast)(struct ib_qp *qp, union ib_gid *gid, u16 lid);
2463         int (*detach_mcast)(struct ib_qp *qp, union ib_gid *gid, u16 lid);
2464         struct ib_xrcd *(*alloc_xrcd)(struct ib_device *device,
2465                                       struct ib_udata *udata);
2466         int (*dealloc_xrcd)(struct ib_xrcd *xrcd, struct ib_udata *udata);
2467         struct ib_flow *(*create_flow)(struct ib_qp *qp,
2468                                        struct ib_flow_attr *flow_attr,
2469                                        int domain, struct ib_udata *udata);
2470         int (*destroy_flow)(struct ib_flow *flow_id);
2471         struct ib_flow_action *(*create_flow_action_esp)(
2472                 struct ib_device *device,
2473                 const struct ib_flow_action_attrs_esp *attr,
2474                 struct uverbs_attr_bundle *attrs);
2475         int (*destroy_flow_action)(struct ib_flow_action *action);
2476         int (*modify_flow_action_esp)(
2477                 struct ib_flow_action *action,
2478                 const struct ib_flow_action_attrs_esp *attr,
2479                 struct uverbs_attr_bundle *attrs);
2480         int (*set_vf_link_state)(struct ib_device *device, int vf, u8 port,
2481                                  int state);
2482         int (*get_vf_config)(struct ib_device *device, int vf, u8 port,
2483                              struct ifla_vf_info *ivf);
2484         int (*get_vf_stats)(struct ib_device *device, int vf, u8 port,
2485                             struct ifla_vf_stats *stats);
2486         int (*get_vf_guid)(struct ib_device *device, int vf, u8 port,
2487                             struct ifla_vf_guid *node_guid,
2488                             struct ifla_vf_guid *port_guid);
2489         int (*set_vf_guid)(struct ib_device *device, int vf, u8 port, u64 guid,
2490                            int type);
2491         struct ib_wq *(*create_wq)(struct ib_pd *pd,
2492                                    struct ib_wq_init_attr *init_attr,
2493                                    struct ib_udata *udata);
2494         void (*destroy_wq)(struct ib_wq *wq, struct ib_udata *udata);
2495         int (*modify_wq)(struct ib_wq *wq, struct ib_wq_attr *attr,
2496                          u32 wq_attr_mask, struct ib_udata *udata);
2497         struct ib_rwq_ind_table *(*create_rwq_ind_table)(
2498                 struct ib_device *device,
2499                 struct ib_rwq_ind_table_init_attr *init_attr,
2500                 struct ib_udata *udata);
2501         int (*destroy_rwq_ind_table)(struct ib_rwq_ind_table *wq_ind_table);
2502         struct ib_dm *(*alloc_dm)(struct ib_device *device,
2503                                   struct ib_ucontext *context,
2504                                   struct ib_dm_alloc_attr *attr,
2505                                   struct uverbs_attr_bundle *attrs);
2506         int (*dealloc_dm)(struct ib_dm *dm, struct uverbs_attr_bundle *attrs);
2507         struct ib_mr *(*reg_dm_mr)(struct ib_pd *pd, struct ib_dm *dm,
2508                                    struct ib_dm_mr_attr *attr,
2509                                    struct uverbs_attr_bundle *attrs);
2510         struct ib_counters *(*create_counters)(
2511                 struct ib_device *device, struct uverbs_attr_bundle *attrs);
2512         int (*destroy_counters)(struct ib_counters *counters);
2513         int (*read_counters)(struct ib_counters *counters,
2514                              struct ib_counters_read_attr *counters_read_attr,
2515                              struct uverbs_attr_bundle *attrs);
2516         int (*map_mr_sg_pi)(struct ib_mr *mr, struct scatterlist *data_sg,
2517                             int data_sg_nents, unsigned int *data_sg_offset,
2518                             struct scatterlist *meta_sg, int meta_sg_nents,
2519                             unsigned int *meta_sg_offset);
2520
2521         /**
2522          * alloc_hw_stats - Allocate a struct rdma_hw_stats and fill in the
2523          *   driver initialized data.  The struct is kfree()'ed by the sysfs
2524          *   core when the device is removed.  A lifespan of -1 in the return
2525          *   struct tells the core to set a default lifespan.
2526          */
2527         struct rdma_hw_stats *(*alloc_hw_stats)(struct ib_device *device,
2528                                                 u8 port_num);
2529         /**
2530          * get_hw_stats - Fill in the counter value(s) in the stats struct.
2531          * @index - The index in the value array we wish to have updated, or
2532          *   num_counters if we want all stats updated
2533          * Return codes -
2534          *   < 0 - Error, no counters updated
2535          *   index - Updated the single counter pointed to by index
2536          *   num_counters - Updated all counters (will reset the timestamp
2537          *     and prevent further calls for lifespan milliseconds)
2538          * Drivers are allowed to update all counters in leiu of just the
2539          *   one given in index at their option
2540          */
2541         int (*get_hw_stats)(struct ib_device *device,
2542                             struct rdma_hw_stats *stats, u8 port, int index);
2543         /*
2544          * This function is called once for each port when a ib device is
2545          * registered.
2546          */
2547         int (*init_port)(struct ib_device *device, u8 port_num,
2548                          struct kobject *port_sysfs);
2549         /**
2550          * Allows rdma drivers to add their own restrack attributes.
2551          */
2552         int (*fill_res_entry)(struct sk_buff *msg,
2553                               struct rdma_restrack_entry *entry);
2554
2555         /* Device lifecycle callbacks */
2556         /*
2557          * Called after the device becomes registered, before clients are
2558          * attached
2559          */
2560         int (*enable_driver)(struct ib_device *dev);
2561         /*
2562          * This is called as part of ib_dealloc_device().
2563          */
2564         void (*dealloc_driver)(struct ib_device *dev);
2565
2566         /* iWarp CM callbacks */
2567         void (*iw_add_ref)(struct ib_qp *qp);
2568         void (*iw_rem_ref)(struct ib_qp *qp);
2569         struct ib_qp *(*iw_get_qp)(struct ib_device *device, int qpn);
2570         int (*iw_connect)(struct iw_cm_id *cm_id,
2571                           struct iw_cm_conn_param *conn_param);
2572         int (*iw_accept)(struct iw_cm_id *cm_id,
2573                          struct iw_cm_conn_param *conn_param);
2574         int (*iw_reject)(struct iw_cm_id *cm_id, const void *pdata,
2575                          u8 pdata_len);
2576         int (*iw_create_listen)(struct iw_cm_id *cm_id, int backlog);
2577         int (*iw_destroy_listen)(struct iw_cm_id *cm_id);
2578         /**
2579          * counter_bind_qp - Bind a QP to a counter.
2580          * @counter - The counter to be bound. If counter->id is zero then
2581          *   the driver needs to allocate a new counter and set counter->id
2582          */
2583         int (*counter_bind_qp)(struct rdma_counter *counter, struct ib_qp *qp);
2584         /**
2585          * counter_unbind_qp - Unbind the qp from the dynamically-allocated
2586          *   counter and bind it onto the default one
2587          */
2588         int (*counter_unbind_qp)(struct ib_qp *qp);
2589         /**
2590          * counter_dealloc -De-allocate the hw counter
2591          */
2592         int (*counter_dealloc)(struct rdma_counter *counter);
2593         /**
2594          * counter_alloc_stats - Allocate a struct rdma_hw_stats and fill in
2595          * the driver initialized data.
2596          */
2597         struct rdma_hw_stats *(*counter_alloc_stats)(
2598                 struct rdma_counter *counter);
2599         /**
2600          * counter_update_stats - Query the stats value of this counter
2601          */
2602         int (*counter_update_stats)(struct rdma_counter *counter);
2603
2604         /**
2605          * Allows rdma drivers to add their own restrack attributes
2606          * dumped via 'rdma stat' iproute2 command.
2607          */
2608         int (*fill_stat_entry)(struct sk_buff *msg,
2609                                struct rdma_restrack_entry *entry);
2610
2611         DECLARE_RDMA_OBJ_SIZE(ib_ah);
2612         DECLARE_RDMA_OBJ_SIZE(ib_cq);
2613         DECLARE_RDMA_OBJ_SIZE(ib_pd);
2614         DECLARE_RDMA_OBJ_SIZE(ib_srq);
2615         DECLARE_RDMA_OBJ_SIZE(ib_ucontext);
2616 };
2617
2618 struct ib_core_device {
2619         /* device must be the first element in structure until,
2620          * union of ib_core_device and device exists in ib_device.
2621          */
2622         struct device dev;
2623         possible_net_t rdma_net;
2624         struct kobject *ports_kobj;
2625         struct list_head port_list;
2626         struct ib_device *owner; /* reach back to owner ib_device */
2627 };
2628
2629 struct rdma_restrack_root;
2630 struct ib_device {
2631         /* Do not access @dma_device directly from ULP nor from HW drivers. */
2632         struct device                *dma_device;
2633         struct ib_device_ops         ops;
2634         char                          name[IB_DEVICE_NAME_MAX];
2635         struct rcu_head rcu_head;
2636
2637         struct list_head              event_handler_list;
2638         /* Protects event_handler_list */
2639         struct rw_semaphore event_handler_rwsem;
2640
2641         /* Protects QP's event_handler calls and open_qp list */
2642         spinlock_t qp_open_list_lock;
2643
2644         struct rw_semaphore           client_data_rwsem;
2645         struct xarray                 client_data;
2646         struct mutex                  unregistration_lock;
2647
2648         /* Synchronize GID, Pkey cache entries, subnet prefix, LMC */
2649         rwlock_t cache_lock;
2650         /**
2651          * port_data is indexed by port number
2652          */
2653         struct ib_port_data *port_data;
2654
2655         int                           num_comp_vectors;
2656
2657         union {
2658                 struct device           dev;
2659                 struct ib_core_device   coredev;
2660         };
2661
2662         /* First group for device attributes,
2663          * Second group for driver provided attributes (optional).
2664          * It is NULL terminated array.
2665          */
2666         const struct attribute_group    *groups[3];
2667
2668         u64                          uverbs_cmd_mask;
2669         u64                          uverbs_ex_cmd_mask;
2670
2671         char                         node_desc[IB_DEVICE_NODE_DESC_MAX];
2672         __be64                       node_guid;
2673         u32                          local_dma_lkey;
2674         u16                          is_switch:1;
2675         /* Indicates kernel verbs support, should not be used in drivers */
2676         u16                          kverbs_provider:1;
2677         /* CQ adaptive moderation (RDMA DIM) */
2678         u16                          use_cq_dim:1;
2679         u8                           node_type;
2680         u8                           phys_port_cnt;
2681         struct ib_device_attr        attrs;
2682         struct attribute_group       *hw_stats_ag;
2683         struct rdma_hw_stats         *hw_stats;
2684
2685 #ifdef CONFIG_CGROUP_RDMA
2686         struct rdmacg_device         cg_device;
2687 #endif
2688
2689         u32                          index;
2690         struct rdma_restrack_root *res;
2691
2692         const struct uapi_definition   *driver_def;
2693
2694         /*
2695          * Positive refcount indicates that the device is currently
2696          * registered and cannot be unregistered.
2697          */
2698         refcount_t refcount;
2699         struct completion unreg_completion;
2700         struct work_struct unregistration_work;
2701
2702         const struct rdma_link_ops *link_ops;
2703
2704         /* Protects compat_devs xarray modifications */
2705         struct mutex compat_devs_mutex;
2706         /* Maintains compat devices for each net namespace */
2707         struct xarray compat_devs;
2708
2709         /* Used by iWarp CM */
2710         char iw_ifname[IFNAMSIZ];
2711         u32 iw_driver_flags;
2712 };
2713
2714 struct ib_client_nl_info;
2715 struct ib_client {
2716         const char *name;
2717         void (*add)   (struct ib_device *);
2718         void (*remove)(struct ib_device *, void *client_data);
2719         void (*rename)(struct ib_device *dev, void *client_data);
2720         int (*get_nl_info)(struct ib_device *ibdev, void *client_data,
2721                            struct ib_client_nl_info *res);
2722         int (*get_global_nl_info)(struct ib_client_nl_info *res);
2723
2724         /* Returns the net_dev belonging to this ib_client and matching the
2725          * given parameters.
2726          * @dev:         An RDMA device that the net_dev use for communication.
2727          * @port:        A physical port number on the RDMA device.
2728          * @pkey:        P_Key that the net_dev uses if applicable.
2729          * @gid:         A GID that the net_dev uses to communicate.
2730          * @addr:        An IP address the net_dev is configured with.
2731          * @client_data: The device's client data set by ib_set_client_data().
2732          *
2733          * An ib_client that implements a net_dev on top of RDMA devices
2734          * (such as IP over IB) should implement this callback, allowing the
2735          * rdma_cm module to find the right net_dev for a given request.
2736          *
2737          * The caller is responsible for calling dev_put on the returned
2738          * netdev. */
2739         struct net_device *(*get_net_dev_by_params)(
2740                         struct ib_device *dev,
2741                         u8 port,
2742                         u16 pkey,
2743                         const union ib_gid *gid,
2744                         const struct sockaddr *addr,
2745                         void *client_data);
2746
2747         refcount_t uses;
2748         struct completion uses_zero;
2749         u32 client_id;
2750
2751         /* kverbs are not required by the client */
2752         u8 no_kverbs_req:1;
2753 };
2754
2755 /*
2756  * IB block DMA iterator
2757  *
2758  * Iterates the DMA-mapped SGL in contiguous memory blocks aligned
2759  * to a HW supported page size.
2760  */
2761 struct ib_block_iter {
2762         /* internal states */
2763         struct scatterlist *__sg;       /* sg holding the current aligned block */
2764         dma_addr_t __dma_addr;          /* unaligned DMA address of this block */
2765         unsigned int __sg_nents;        /* number of SG entries */
2766         unsigned int __sg_advance;      /* number of bytes to advance in sg in next step */
2767         unsigned int __pg_bit;          /* alignment of current block */
2768 };
2769
2770 struct ib_device *_ib_alloc_device(size_t size);
2771 #define ib_alloc_device(drv_struct, member)                                    \
2772         container_of(_ib_alloc_device(sizeof(struct drv_struct) +              \
2773                                       BUILD_BUG_ON_ZERO(offsetof(              \
2774                                               struct drv_struct, member))),    \
2775                      struct drv_struct, member)
2776
2777 void ib_dealloc_device(struct ib_device *device);
2778
2779 void ib_get_device_fw_str(struct ib_device *device, char *str);
2780
2781 int ib_register_device(struct ib_device *device, const char *name);
2782 void ib_unregister_device(struct ib_device *device);
2783 void ib_unregister_driver(enum rdma_driver_id driver_id);
2784 void ib_unregister_device_and_put(struct ib_device *device);
2785 void ib_unregister_device_queued(struct ib_device *ib_dev);
2786
2787 int ib_register_client   (struct ib_client *client);
2788 void ib_unregister_client(struct ib_client *client);
2789
2790 void __rdma_block_iter_start(struct ib_block_iter *biter,
2791                              struct scatterlist *sglist,
2792                              unsigned int nents,
2793                              unsigned long pgsz);
2794 bool __rdma_block_iter_next(struct ib_block_iter *biter);
2795
2796 /**
2797  * rdma_block_iter_dma_address - get the aligned dma address of the current
2798  * block held by the block iterator.
2799  * @biter: block iterator holding the memory block
2800  */
2801 static inline dma_addr_t
2802 rdma_block_iter_dma_address(struct ib_block_iter *biter)
2803 {
2804         return biter->__dma_addr & ~(BIT_ULL(biter->__pg_bit) - 1);
2805 }
2806
2807 /**
2808  * rdma_for_each_block - iterate over contiguous memory blocks of the sg list
2809  * @sglist: sglist to iterate over
2810  * @biter: block iterator holding the memory block
2811  * @nents: maximum number of sg entries to iterate over
2812  * @pgsz: best HW supported page size to use
2813  *
2814  * Callers may use rdma_block_iter_dma_address() to get each
2815  * blocks aligned DMA address.
2816  */
2817 #define rdma_for_each_block(sglist, biter, nents, pgsz)         \
2818         for (__rdma_block_iter_start(biter, sglist, nents,      \
2819                                      pgsz);                     \
2820              __rdma_block_iter_next(biter);)
2821
2822 /**
2823  * ib_get_client_data - Get IB client context
2824  * @device:Device to get context for
2825  * @client:Client to get context for
2826  *
2827  * ib_get_client_data() returns the client context data set with
2828  * ib_set_client_data(). This can only be called while the client is
2829  * registered to the device, once the ib_client remove() callback returns this
2830  * cannot be called.
2831  */
2832 static inline void *ib_get_client_data(struct ib_device *device,
2833                                        struct ib_client *client)
2834 {
2835         return xa_load(&device->client_data, client->client_id);
2836 }
2837 void  ib_set_client_data(struct ib_device *device, struct ib_client *client,
2838                          void *data);
2839 void ib_set_device_ops(struct ib_device *device,
2840                        const struct ib_device_ops *ops);
2841
2842 int rdma_user_mmap_io(struct ib_ucontext *ucontext, struct vm_area_struct *vma,
2843                       unsigned long pfn, unsigned long size, pgprot_t prot,
2844                       struct rdma_user_mmap_entry *entry);
2845 int rdma_user_mmap_entry_insert(struct ib_ucontext *ucontext,
2846                                 struct rdma_user_mmap_entry *entry,
2847                                 size_t length);
2848 int rdma_user_mmap_entry_insert_range(struct ib_ucontext *ucontext,
2849                                       struct rdma_user_mmap_entry *entry,
2850                                       size_t length, u32 min_pgoff,
2851                                       u32 max_pgoff);
2852
2853 struct rdma_user_mmap_entry *
2854 rdma_user_mmap_entry_get_pgoff(struct ib_ucontext *ucontext,
2855                                unsigned long pgoff);
2856 struct rdma_user_mmap_entry *
2857 rdma_user_mmap_entry_get(struct ib_ucontext *ucontext,
2858                          struct vm_area_struct *vma);
2859 void rdma_user_mmap_entry_put(struct rdma_user_mmap_entry *entry);
2860
2861 void rdma_user_mmap_entry_remove(struct rdma_user_mmap_entry *entry);
2862
2863 static inline int ib_copy_from_udata(void *dest, struct ib_udata *udata, size_t len)
2864 {
2865         return copy_from_user(dest, udata->inbuf, len) ? -EFAULT : 0;
2866 }
2867
2868 static inline int ib_copy_to_udata(struct ib_udata *udata, void *src, size_t len)
2869 {
2870         return copy_to_user(udata->outbuf, src, len) ? -EFAULT : 0;
2871 }
2872
2873 static inline bool ib_is_buffer_cleared(const void __user *p,
2874                                         size_t len)
2875 {
2876         bool ret;
2877         u8 *buf;
2878
2879         if (len > USHRT_MAX)
2880                 return false;
2881
2882         buf = memdup_user(p, len);
2883         if (IS_ERR(buf))
2884                 return false;
2885
2886         ret = !memchr_inv(buf, 0, len);
2887         kfree(buf);
2888         return ret;
2889 }
2890
2891 static inline bool ib_is_udata_cleared(struct ib_udata *udata,
2892                                        size_t offset,
2893                                        size_t len)
2894 {
2895         return ib_is_buffer_cleared(udata->inbuf + offset, len);
2896 }
2897
2898 /**
2899  * ib_is_destroy_retryable - Check whether the uobject destruction
2900  * is retryable.
2901  * @ret: The initial destruction return code
2902  * @why: remove reason
2903  * @uobj: The uobject that is destroyed
2904  *
2905  * This function is a helper function that IB layer and low-level drivers
2906  * can use to consider whether the destruction of the given uobject is
2907  * retry-able.
2908  * It checks the original return code, if it wasn't success the destruction
2909  * is retryable according to the ucontext state (i.e. cleanup_retryable) and
2910  * the remove reason. (i.e. why).
2911  * Must be called with the object locked for destroy.
2912  */
2913 static inline bool ib_is_destroy_retryable(int ret, enum rdma_remove_reason why,
2914                                            struct ib_uobject *uobj)
2915 {
2916         return ret && (why == RDMA_REMOVE_DESTROY ||
2917                        uobj->context->cleanup_retryable);
2918 }
2919
2920 /**
2921  * ib_destroy_usecnt - Called during destruction to check the usecnt
2922  * @usecnt: The usecnt atomic
2923  * @why: remove reason
2924  * @uobj: The uobject that is destroyed
2925  *
2926  * Non-zero usecnts will block destruction unless destruction was triggered by
2927  * a ucontext cleanup.
2928  */
2929 static inline int ib_destroy_usecnt(atomic_t *usecnt,
2930                                     enum rdma_remove_reason why,
2931                                     struct ib_uobject *uobj)
2932 {
2933         if (atomic_read(usecnt) && ib_is_destroy_retryable(-EBUSY, why, uobj))
2934                 return -EBUSY;
2935         return 0;
2936 }
2937
2938 /**
2939  * ib_modify_qp_is_ok - Check that the supplied attribute mask
2940  * contains all required attributes and no attributes not allowed for
2941  * the given QP state transition.
2942  * @cur_state: Current QP state
2943  * @next_state: Next QP state
2944  * @type: QP type
2945  * @mask: Mask of supplied QP attributes
2946  *
2947  * This function is a helper function that a low-level driver's
2948  * modify_qp method can use to validate the consumer's input.  It
2949  * checks that cur_state and next_state are valid QP states, that a
2950  * transition from cur_state to next_state is allowed by the IB spec,
2951  * and that the attribute mask supplied is allowed for the transition.
2952  */
2953 bool ib_modify_qp_is_ok(enum ib_qp_state cur_state, enum ib_qp_state next_state,
2954                         enum ib_qp_type type, enum ib_qp_attr_mask mask);
2955
2956 void ib_register_event_handler(struct ib_event_handler *event_handler);
2957 void ib_unregister_event_handler(struct ib_event_handler *event_handler);
2958 void ib_dispatch_event(const struct ib_event *event);
2959
2960 int ib_query_port(struct ib_device *device,
2961                   u8 port_num, struct ib_port_attr *port_attr);
2962
2963 enum rdma_link_layer rdma_port_get_link_layer(struct ib_device *device,
2964                                                u8 port_num);
2965
2966 /**
2967  * rdma_cap_ib_switch - Check if the device is IB switch
2968  * @device: Device to check
2969  *
2970  * Device driver is responsible for setting is_switch bit on
2971  * in ib_device structure at init time.
2972  *
2973  * Return: true if the device is IB switch.
2974  */
2975 static inline bool rdma_cap_ib_switch(const struct ib_device *device)
2976 {
2977         return device->is_switch;
2978 }
2979
2980 /**
2981  * rdma_start_port - Return the first valid port number for the device
2982  * specified
2983  *
2984  * @device: Device to be checked
2985  *
2986  * Return start port number
2987  */
2988 static inline u8 rdma_start_port(const struct ib_device *device)
2989 {
2990         return rdma_cap_ib_switch(device) ? 0 : 1;
2991 }
2992
2993 /**
2994  * rdma_for_each_port - Iterate over all valid port numbers of the IB device
2995  * @device - The struct ib_device * to iterate over
2996  * @iter - The unsigned int to store the port number
2997  */
2998 #define rdma_for_each_port(device, iter)                                       \
2999         for (iter = rdma_start_port(device + BUILD_BUG_ON_ZERO(!__same_type(   \
3000                                                      unsigned int, iter)));    \
3001              iter <= rdma_end_port(device); (iter)++)
3002
3003 /**
3004  * rdma_end_port - Return the last valid port number for the device
3005  * specified
3006  *
3007  * @device: Device to be checked
3008  *
3009  * Return last port number
3010  */
3011 static inline u8 rdma_end_port(const struct ib_device *device)
3012 {
3013         return rdma_cap_ib_switch(device) ? 0 : device->phys_port_cnt;
3014 }
3015
3016 static inline int rdma_is_port_valid(const struct ib_device *device,
3017                                      unsigned int port)
3018 {
3019         return (port >= rdma_start_port(device) &&
3020                 port <= rdma_end_port(device));
3021 }
3022
3023 static inline bool rdma_is_grh_required(const struct ib_device *device,
3024                                         u8 port_num)
3025 {
3026         return device->port_data[port_num].immutable.core_cap_flags &
3027                RDMA_CORE_PORT_IB_GRH_REQUIRED;
3028 }
3029
3030 static inline bool rdma_protocol_ib(const struct ib_device *device, u8 port_num)
3031 {
3032         return device->port_data[port_num].immutable.core_cap_flags &
3033                RDMA_CORE_CAP_PROT_IB;
3034 }
3035
3036 static inline bool rdma_protocol_roce(const struct ib_device *device, u8 port_num)
3037 {
3038         return device->port_data[port_num].immutable.core_cap_flags &
3039                (RDMA_CORE_CAP_PROT_ROCE | RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP);
3040 }
3041
3042 static inline bool rdma_protocol_roce_udp_encap(const struct ib_device *device, u8 port_num)
3043 {
3044         return device->port_data[port_num].immutable.core_cap_flags &
3045                RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP;
3046 }
3047
3048 static inline bool rdma_protocol_roce_eth_encap(const struct ib_device *device, u8 port_num)
3049 {
3050         return device->port_data[port_num].immutable.core_cap_flags &
3051                RDMA_CORE_CAP_PROT_ROCE;
3052 }
3053
3054 static inline bool rdma_protocol_iwarp(const struct ib_device *device, u8 port_num)
3055 {
3056         return device->port_data[port_num].immutable.core_cap_flags &
3057                RDMA_CORE_CAP_PROT_IWARP;
3058 }
3059
3060 static inline bool rdma_ib_or_roce(const struct ib_device *device, u8 port_num)
3061 {
3062         return rdma_protocol_ib(device, port_num) ||
3063                 rdma_protocol_roce(device, port_num);
3064 }
3065
3066 static inline bool rdma_protocol_raw_packet(const struct ib_device *device, u8 port_num)
3067 {
3068         return device->port_data[port_num].immutable.core_cap_flags &
3069                RDMA_CORE_CAP_PROT_RAW_PACKET;
3070 }
3071
3072 static inline bool rdma_protocol_usnic(const struct ib_device *device, u8 port_num)
3073 {
3074         return device->port_data[port_num].immutable.core_cap_flags &
3075                RDMA_CORE_CAP_PROT_USNIC;
3076 }
3077
3078 /**
3079  * rdma_cap_ib_mad - Check if the port of a device supports Infiniband
3080  * Management Datagrams.
3081  * @device: Device to check
3082  * @port_num: Port number to check
3083  *
3084  * Management Datagrams (MAD) are a required part of the InfiniBand
3085  * specification and are supported on all InfiniBand devices.  A slightly
3086  * extended version are also supported on OPA interfaces.
3087  *
3088  * Return: true if the port supports sending/receiving of MAD packets.
3089  */
3090 static inline bool rdma_cap_ib_mad(const struct ib_device *device, u8 port_num)
3091 {
3092         return device->port_data[port_num].immutable.core_cap_flags &
3093                RDMA_CORE_CAP_IB_MAD;
3094 }
3095
3096 /**
3097  * rdma_cap_opa_mad - Check if the port of device provides support for OPA
3098  * Management Datagrams.
3099  * @device: Device to check
3100  * @port_num: Port number to check
3101  *
3102  * Intel OmniPath devices extend and/or replace the InfiniBand Management
3103  * datagrams with their own versions.  These OPA MADs share many but not all of
3104  * the characteristics of InfiniBand MADs.
3105  *
3106  * OPA MADs differ in the following ways:
3107  *
3108  *    1) MADs are variable size up to 2K
3109  *       IBTA defined MADs remain fixed at 256 bytes
3110  *    2) OPA SMPs must carry valid PKeys
3111  *    3) OPA SMP packets are a different format
3112  *
3113  * Return: true if the port supports OPA MAD packet formats.
3114  */
3115 static inline bool rdma_cap_opa_mad(struct ib_device *device, u8 port_num)
3116 {
3117         return device->port_data[port_num].immutable.core_cap_flags &
3118                 RDMA_CORE_CAP_OPA_MAD;
3119 }
3120
3121 /**
3122  * rdma_cap_ib_smi - Check if the port of a device provides an Infiniband
3123  * Subnet Management Agent (SMA) on the Subnet Management Interface (SMI).
3124  * @device: Device to check
3125  * @port_num: Port number to check
3126  *
3127  * Each InfiniBand node is required to provide a Subnet Management Agent
3128  * that the subnet manager can access.  Prior to the fabric being fully
3129  * configured by the subnet manager, the SMA is accessed via a well known
3130  * interface called the Subnet Management Interface (SMI).  This interface
3131  * uses directed route packets to communicate with the SM to get around the
3132  * chicken and egg problem of the SM needing to know what's on the fabric
3133  * in order to configure the fabric, and needing to configure the fabric in
3134  * order to send packets to the devices on the fabric.  These directed
3135  * route packets do not need the fabric fully configured in order to reach
3136  * their destination.  The SMI is the only method allowed to send
3137  * directed route packets on an InfiniBand fabric.
3138  *
3139  * Return: true if the port provides an SMI.
3140  */
3141 static inline bool rdma_cap_ib_smi(const struct ib_device *device, u8 port_num)
3142 {
3143         return device->port_data[port_num].immutable.core_cap_flags &
3144                RDMA_CORE_CAP_IB_SMI;
3145 }
3146
3147 /**
3148  * rdma_cap_ib_cm - Check if the port of device has the capability Infiniband
3149  * Communication Manager.
3150  * @device: Device to check
3151  * @port_num: Port number to check
3152  *
3153  * The InfiniBand Communication Manager is one of many pre-defined General
3154  * Service Agents (GSA) that are accessed via the General Service
3155  * Interface (GSI).  It's role is to facilitate establishment of connections
3156  * between nodes as well as other management related tasks for established
3157  * connections.
3158  *
3159  * Return: true if the port supports an IB CM (this does not guarantee that
3160  * a CM is actually running however).
3161  */
3162 static inline bool rdma_cap_ib_cm(const struct ib_device *device, u8 port_num)
3163 {
3164         return device->port_data[port_num].immutable.core_cap_flags &
3165                RDMA_CORE_CAP_IB_CM;
3166 }
3167
3168 /**
3169  * rdma_cap_iw_cm - Check if the port of device has the capability IWARP
3170  * Communication Manager.
3171  * @device: Device to check
3172  * @port_num: Port number to check
3173  *
3174  * Similar to above, but specific to iWARP connections which have a different
3175  * managment protocol than InfiniBand.
3176  *
3177  * Return: true if the port supports an iWARP CM (this does not guarantee that
3178  * a CM is actually running however).
3179  */
3180 static inline bool rdma_cap_iw_cm(const struct ib_device *device, u8 port_num)
3181 {
3182         return device->port_data[port_num].immutable.core_cap_flags &
3183                RDMA_CORE_CAP_IW_CM;
3184 }
3185
3186 /**
3187  * rdma_cap_ib_sa - Check if the port of device has the capability Infiniband
3188  * Subnet Administration.
3189  * @device: Device to check
3190  * @port_num: Port number to check
3191  *
3192  * An InfiniBand Subnet Administration (SA) service is a pre-defined General
3193  * Service Agent (GSA) provided by the Subnet Manager (SM).  On InfiniBand
3194  * fabrics, devices should resolve routes to other hosts by contacting the
3195  * SA to query the proper route.
3196  *
3197  * Return: true if the port should act as a client to the fabric Subnet
3198  * Administration interface.  This does not imply that the SA service is
3199  * running locally.
3200  */
3201 static inline bool rdma_cap_ib_sa(const struct ib_device *device, u8 port_num)
3202 {
3203         return device->port_data[port_num].immutable.core_cap_flags &
3204                RDMA_CORE_CAP_IB_SA;
3205 }
3206
3207 /**
3208  * rdma_cap_ib_mcast - Check if the port of device has the capability Infiniband
3209  * Multicast.
3210  * @device: Device to check
3211  * @port_num: Port number to check
3212  *
3213  * InfiniBand multicast registration is more complex than normal IPv4 or
3214  * IPv6 multicast registration.  Each Host Channel Adapter must register
3215  * with the Subnet Manager when it wishes to join a multicast group.  It
3216  * should do so only once regardless of how many queue pairs it subscribes
3217  * to this group.  And it should leave the group only after all queue pairs
3218  * attached to the group have been detached.
3219  *
3220  * Return: true if the port must undertake the additional adminstrative
3221  * overhead of registering/unregistering with the SM and tracking of the
3222  * total number of queue pairs attached to the multicast group.
3223  */
3224 static inline bool rdma_cap_ib_mcast(const struct ib_device *device, u8 port_num)
3225 {
3226         return rdma_cap_ib_sa(device, port_num);
3227 }
3228
3229 /**
3230  * rdma_cap_af_ib - Check if the port of device has the capability
3231  * Native Infiniband Address.
3232  * @device: Device to check
3233  * @port_num: Port number to check
3234  *
3235  * InfiniBand addressing uses a port's GUID + Subnet Prefix to make a default
3236  * GID.  RoCE uses a different mechanism, but still generates a GID via
3237  * a prescribed mechanism and port specific data.
3238  *
3239  * Return: true if the port uses a GID address to identify devices on the
3240  * network.
3241  */
3242 static inline bool rdma_cap_af_ib(const struct ib_device *device, u8 port_num)
3243 {
3244         return device->port_data[port_num].immutable.core_cap_flags &
3245                RDMA_CORE_CAP_AF_IB;
3246 }
3247
3248 /**
3249  * rdma_cap_eth_ah - Check if the port of device has the capability
3250  * Ethernet Address Handle.
3251  * @device: Device to check
3252  * @port_num: Port number to check
3253  *
3254  * RoCE is InfiniBand over Ethernet, and it uses a well defined technique
3255  * to fabricate GIDs over Ethernet/IP specific addresses native to the
3256  * port.  Normally, packet headers are generated by the sending host
3257  * adapter, but when sending connectionless datagrams, we must manually
3258  * inject the proper headers for the fabric we are communicating over.
3259  *
3260  * Return: true if we are running as a RoCE port and must force the
3261  * addition of a Global Route Header built from our Ethernet Address
3262  * Handle into our header list for connectionless packets.
3263  */
3264 static inline bool rdma_cap_eth_ah(const struct ib_device *device, u8 port_num)
3265 {
3266         return device->port_data[port_num].immutable.core_cap_flags &
3267                RDMA_CORE_CAP_ETH_AH;
3268 }
3269
3270 /**
3271  * rdma_cap_opa_ah - Check if the port of device supports
3272  * OPA Address handles
3273  * @device: Device to check
3274  * @port_num: Port number to check
3275  *
3276  * Return: true if we are running on an OPA device which supports
3277  * the extended OPA addressing.
3278  */
3279 static inline bool rdma_cap_opa_ah(struct ib_device *device, u8 port_num)
3280 {
3281         return (device->port_data[port_num].immutable.core_cap_flags &
3282                 RDMA_CORE_CAP_OPA_AH) == RDMA_CORE_CAP_OPA_AH;
3283 }
3284
3285 /**
3286  * rdma_max_mad_size - Return the max MAD size required by this RDMA Port.
3287  *
3288  * @device: Device
3289  * @port_num: Port number
3290  *
3291  * This MAD size includes the MAD headers and MAD payload.  No other headers
3292  * are included.
3293  *
3294  * Return the max MAD size required by the Port.  Will return 0 if the port
3295  * does not support MADs
3296  */
3297 static inline size_t rdma_max_mad_size(const struct ib_device *device, u8 port_num)
3298 {
3299         return device->port_data[port_num].immutable.max_mad_size;
3300 }
3301
3302 /**
3303  * rdma_cap_roce_gid_table - Check if the port of device uses roce_gid_table
3304  * @device: Device to check
3305  * @port_num: Port number to check
3306  *
3307  * RoCE GID table mechanism manages the various GIDs for a device.
3308  *
3309  * NOTE: if allocating the port's GID table has failed, this call will still
3310  * return true, but any RoCE GID table API will fail.
3311  *
3312  * Return: true if the port uses RoCE GID table mechanism in order to manage
3313  * its GIDs.
3314  */
3315 static inline bool rdma_cap_roce_gid_table(const struct ib_device *device,
3316                                            u8 port_num)
3317 {
3318         return rdma_protocol_roce(device, port_num) &&
3319                 device->ops.add_gid && device->ops.del_gid;
3320 }
3321
3322 /*
3323  * Check if the device supports READ W/ INVALIDATE.
3324  */
3325 static inline bool rdma_cap_read_inv(struct ib_device *dev, u32 port_num)
3326 {
3327         /*
3328          * iWarp drivers must support READ W/ INVALIDATE.  No other protocol
3329          * has support for it yet.
3330          */
3331         return rdma_protocol_iwarp(dev, port_num);
3332 }
3333
3334 /**
3335  * rdma_find_pg_bit - Find page bit given address and HW supported page sizes
3336  *
3337  * @addr: address
3338  * @pgsz_bitmap: bitmap of HW supported page sizes
3339  */
3340 static inline unsigned int rdma_find_pg_bit(unsigned long addr,
3341                                             unsigned long pgsz_bitmap)
3342 {
3343         unsigned long align;
3344         unsigned long pgsz;
3345
3346         align = addr & -addr;
3347
3348         /* Find page bit such that addr is aligned to the highest supported
3349          * HW page size
3350          */
3351         pgsz = pgsz_bitmap & ~(-align << 1);
3352         if (!pgsz)
3353                 return __ffs(pgsz_bitmap);
3354
3355         return __fls(pgsz);
3356 }
3357
3358 int ib_set_vf_link_state(struct ib_device *device, int vf, u8 port,
3359                          int state);
3360 int ib_get_vf_config(struct ib_device *device, int vf, u8 port,
3361                      struct ifla_vf_info *info);
3362 int ib_get_vf_stats(struct ib_device *device, int vf, u8 port,
3363                     struct ifla_vf_stats *stats);
3364 int ib_get_vf_guid(struct ib_device *device, int vf, u8 port,
3365                     struct ifla_vf_guid *node_guid,
3366                     struct ifla_vf_guid *port_guid);
3367 int ib_set_vf_guid(struct ib_device *device, int vf, u8 port, u64 guid,
3368                    int type);
3369
3370 int ib_query_pkey(struct ib_device *device,
3371                   u8 port_num, u16 index, u16 *pkey);
3372
3373 int ib_modify_device(struct ib_device *device,
3374                      int device_modify_mask,
3375                      struct ib_device_modify *device_modify);
3376
3377 int ib_modify_port(struct ib_device *device,
3378                    u8 port_num, int port_modify_mask,
3379                    struct ib_port_modify *port_modify);
3380
3381 int ib_find_gid(struct ib_device *device, union ib_gid *gid,
3382                 u8 *port_num, u16 *index);
3383
3384 int ib_find_pkey(struct ib_device *device,
3385                  u8 port_num, u16 pkey, u16 *index);
3386
3387 enum ib_pd_flags {
3388         /*
3389          * Create a memory registration for all memory in the system and place
3390          * the rkey for it into pd->unsafe_global_rkey.  This can be used by
3391          * ULPs to avoid the overhead of dynamic MRs.
3392          *
3393          * This flag is generally considered unsafe and must only be used in
3394          * extremly trusted environments.  Every use of it will log a warning
3395          * in the kernel log.
3396          */
3397         IB_PD_UNSAFE_GLOBAL_RKEY        = 0x01,
3398 };
3399
3400 struct ib_pd *__ib_alloc_pd(struct ib_device *device, unsigned int flags,
3401                 const char *caller);
3402
3403 #define ib_alloc_pd(device, flags) \
3404         __ib_alloc_pd((device), (flags), KBUILD_MODNAME)
3405
3406 /**
3407  * ib_dealloc_pd_user - Deallocate kernel/user PD
3408  * @pd: The protection domain
3409  * @udata: Valid user data or NULL for kernel objects
3410  */
3411 void ib_dealloc_pd_user(struct ib_pd *pd, struct ib_udata *udata);
3412
3413 /**
3414  * ib_dealloc_pd - Deallocate kernel PD
3415  * @pd: The protection domain
3416  *
3417  * NOTE: for user PD use ib_dealloc_pd_user with valid udata!
3418  */
3419 static inline void ib_dealloc_pd(struct ib_pd *pd)
3420 {
3421         ib_dealloc_pd_user(pd, NULL);
3422 }
3423
3424 enum rdma_create_ah_flags {
3425         /* In a sleepable context */
3426         RDMA_CREATE_AH_SLEEPABLE = BIT(0),
3427 };
3428
3429 /**
3430  * rdma_create_ah - Creates an address handle for the given address vector.
3431  * @pd: The protection domain associated with the address handle.
3432  * @ah_attr: The attributes of the address vector.
3433  * @flags: Create address handle flags (see enum rdma_create_ah_flags).
3434  *
3435  * The address handle is used to reference a local or global destination
3436  * in all UD QP post sends.
3437  */
3438 struct ib_ah *rdma_create_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr,
3439                              u32 flags);
3440
3441 /**
3442  * rdma_create_user_ah - Creates an address handle for the given address vector.
3443  * It resolves destination mac address for ah attribute of RoCE type.
3444  * @pd: The protection domain associated with the address handle.
3445  * @ah_attr: The attributes of the address vector.
3446  * @udata: pointer to user's input output buffer information need by
3447  *         provider driver.
3448  *
3449  * It returns 0 on success and returns appropriate error code on error.
3450  * The address handle is used to reference a local or global destination
3451  * in all UD QP post sends.
3452  */
3453 struct ib_ah *rdma_create_user_ah(struct ib_pd *pd,
3454                                   struct rdma_ah_attr *ah_attr,
3455                                   struct ib_udata *udata);
3456 /**
3457  * ib_get_gids_from_rdma_hdr - Get sgid and dgid from GRH or IPv4 header
3458  *   work completion.
3459  * @hdr: the L3 header to parse
3460  * @net_type: type of header to parse
3461  * @sgid: place to store source gid
3462  * @dgid: place to store destination gid
3463  */
3464 int ib_get_gids_from_rdma_hdr(const union rdma_network_hdr *hdr,
3465                               enum rdma_network_type net_type,
3466                               union ib_gid *sgid, union ib_gid *dgid);
3467
3468 /**
3469  * ib_get_rdma_header_version - Get the header version
3470  * @hdr: the L3 header to parse
3471  */
3472 int ib_get_rdma_header_version(const union rdma_network_hdr *hdr);
3473
3474 /**
3475  * ib_init_ah_attr_from_wc - Initializes address handle attributes from a
3476  *   work completion.
3477  * @device: Device on which the received message arrived.
3478  * @port_num: Port on which the received message arrived.
3479  * @wc: Work completion associated with the received message.
3480  * @grh: References the received global route header.  This parameter is
3481  *   ignored unless the work completion indicates that the GRH is valid.
3482  * @ah_attr: Returned attributes that can be used when creating an address
3483  *   handle for replying to the message.
3484  * When ib_init_ah_attr_from_wc() returns success,
3485  * (a) for IB link layer it optionally contains a reference to SGID attribute
3486  * when GRH is present for IB link layer.
3487  * (b) for RoCE link layer it contains a reference to SGID attribute.
3488  * User must invoke rdma_cleanup_ah_attr_gid_attr() to release reference to SGID
3489  * attributes which are initialized using ib_init_ah_attr_from_wc().
3490  *
3491  */
3492 int ib_init_ah_attr_from_wc(struct ib_device *device, u8 port_num,
3493                             const struct ib_wc *wc, const struct ib_grh *grh,
3494                             struct rdma_ah_attr *ah_attr);
3495
3496 /**
3497  * ib_create_ah_from_wc - Creates an address handle associated with the
3498  *   sender of the specified work completion.
3499  * @pd: The protection domain associated with the address handle.
3500  * @wc: Work completion information associated with a received message.
3501  * @grh: References the received global route header.  This parameter is
3502  *   ignored unless the work completion indicates that the GRH is valid.
3503  * @port_num: The outbound port number to associate with the address.
3504  *
3505  * The address handle is used to reference a local or global destination
3506  * in all UD QP post sends.
3507  */
3508 struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, const struct ib_wc *wc,
3509                                    const struct ib_grh *grh, u8 port_num);
3510
3511 /**
3512  * rdma_modify_ah - Modifies the address vector associated with an address
3513  *   handle.
3514  * @ah: The address handle to modify.
3515  * @ah_attr: The new address vector attributes to associate with the
3516  *   address handle.
3517  */
3518 int rdma_modify_ah(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
3519
3520 /**
3521  * rdma_query_ah - Queries the address vector associated with an address
3522  *   handle.
3523  * @ah: The address handle to query.
3524  * @ah_attr: The address vector attributes associated with the address
3525  *   handle.
3526  */
3527 int rdma_query_ah(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
3528
3529 enum rdma_destroy_ah_flags {
3530         /* In a sleepable context */
3531         RDMA_DESTROY_AH_SLEEPABLE = BIT(0),
3532 };
3533
3534 /**
3535  * rdma_destroy_ah_user - Destroys an address handle.
3536  * @ah: The address handle to destroy.
3537  * @flags: Destroy address handle flags (see enum rdma_destroy_ah_flags).
3538  * @udata: Valid user data or NULL for kernel objects
3539  */
3540 int rdma_destroy_ah_user(struct ib_ah *ah, u32 flags, struct ib_udata *udata);
3541
3542 /**
3543  * rdma_destroy_ah - Destroys an kernel address handle.
3544  * @ah: The address handle to destroy.
3545  * @flags: Destroy address handle flags (see enum rdma_destroy_ah_flags).
3546  *
3547  * NOTE: for user ah use rdma_destroy_ah_user with valid udata!
3548  */
3549 static inline int rdma_destroy_ah(struct ib_ah *ah, u32 flags)
3550 {
3551         return rdma_destroy_ah_user(ah, flags, NULL);
3552 }
3553
3554 /**
3555  * ib_create_srq - Creates a SRQ associated with the specified protection
3556  *   domain.
3557  * @pd: The protection domain associated with the SRQ.
3558  * @srq_init_attr: A list of initial attributes required to create the
3559  *   SRQ.  If SRQ creation succeeds, then the attributes are updated to
3560  *   the actual capabilities of the created SRQ.
3561  *
3562  * srq_attr->max_wr and srq_attr->max_sge are read the determine the
3563  * requested size of the SRQ, and set to the actual values allocated
3564  * on return.  If ib_create_srq() succeeds, then max_wr and max_sge
3565  * will always be at least as large as the requested values.
3566  */
3567 struct ib_srq *ib_create_srq(struct ib_pd *pd,
3568                              struct ib_srq_init_attr *srq_init_attr);
3569
3570 /**
3571  * ib_modify_srq - Modifies the attributes for the specified SRQ.
3572  * @srq: The SRQ to modify.
3573  * @srq_attr: On input, specifies the SRQ attributes to modify.  On output,
3574  *   the current values of selected SRQ attributes are returned.
3575  * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ
3576  *   are being modified.
3577  *
3578  * The mask may contain IB_SRQ_MAX_WR to resize the SRQ and/or
3579  * IB_SRQ_LIMIT to set the SRQ's limit and request notification when
3580  * the number of receives queued drops below the limit.
3581  */
3582 int ib_modify_srq(struct ib_srq *srq,
3583                   struct ib_srq_attr *srq_attr,
3584                   enum ib_srq_attr_mask srq_attr_mask);
3585
3586 /**
3587  * ib_query_srq - Returns the attribute list and current values for the
3588  *   specified SRQ.
3589  * @srq: The SRQ to query.
3590  * @srq_attr: The attributes of the specified SRQ.
3591  */
3592 int ib_query_srq(struct ib_srq *srq,
3593                  struct ib_srq_attr *srq_attr);
3594
3595 /**
3596  * ib_destroy_srq_user - Destroys the specified SRQ.
3597  * @srq: The SRQ to destroy.
3598  * @udata: Valid user data or NULL for kernel objects
3599  */
3600 int ib_destroy_srq_user(struct ib_srq *srq, struct ib_udata *udata);
3601
3602 /**
3603  * ib_destroy_srq - Destroys the specified kernel SRQ.
3604  * @srq: The SRQ to destroy.
3605  *
3606  * NOTE: for user srq use ib_destroy_srq_user with valid udata!
3607  */
3608 static inline int ib_destroy_srq(struct ib_srq *srq)
3609 {
3610         return ib_destroy_srq_user(srq, NULL);
3611 }
3612
3613 /**
3614  * ib_post_srq_recv - Posts a list of work requests to the specified SRQ.
3615  * @srq: The SRQ to post the work request on.
3616  * @recv_wr: A list of work requests to post on the receive queue.
3617  * @bad_recv_wr: On an immediate failure, this parameter will reference
3618  *   the work request that failed to be posted on the QP.
3619  */
3620 static inline int ib_post_srq_recv(struct ib_srq *srq,
3621                                    const struct ib_recv_wr *recv_wr,
3622                                    const struct ib_recv_wr **bad_recv_wr)
3623 {
3624         const struct ib_recv_wr *dummy;
3625
3626         return srq->device->ops.post_srq_recv(srq, recv_wr,
3627                                               bad_recv_wr ? : &dummy);
3628 }
3629
3630 struct ib_qp *ib_create_qp(struct ib_pd *pd,
3631                            struct ib_qp_init_attr *qp_init_attr);
3632
3633 /**
3634  * ib_modify_qp_with_udata - Modifies the attributes for the specified QP.
3635  * @qp: The QP to modify.
3636  * @attr: On input, specifies the QP attributes to modify.  On output,
3637  *   the current values of selected QP attributes are returned.
3638  * @attr_mask: A bit-mask used to specify which attributes of the QP
3639  *   are being modified.
3640  * @udata: pointer to user's input output buffer information
3641  *   are being modified.
3642  * It returns 0 on success and returns appropriate error code on error.
3643  */
3644 int ib_modify_qp_with_udata(struct ib_qp *qp,
3645                             struct ib_qp_attr *attr,
3646                             int attr_mask,
3647                             struct ib_udata *udata);
3648
3649 /**
3650  * ib_modify_qp - Modifies the attributes for the specified QP and then
3651  *   transitions the QP to the given state.
3652  * @qp: The QP to modify.
3653  * @qp_attr: On input, specifies the QP attributes to modify.  On output,
3654  *   the current values of selected QP attributes are returned.
3655  * @qp_attr_mask: A bit-mask used to specify which attributes of the QP
3656  *   are being modified.
3657  */
3658 int ib_modify_qp(struct ib_qp *qp,
3659                  struct ib_qp_attr *qp_attr,
3660                  int qp_attr_mask);
3661
3662 /**
3663  * ib_query_qp - Returns the attribute list and current values for the
3664  *   specified QP.
3665  * @qp: The QP to query.
3666  * @qp_attr: The attributes of the specified QP.
3667  * @qp_attr_mask: A bit-mask used to select specific attributes to query.
3668  * @qp_init_attr: Additional attributes of the selected QP.
3669  *
3670  * The qp_attr_mask may be used to limit the query to gathering only the
3671  * selected attributes.
3672  */
3673 int ib_query_qp(struct ib_qp *qp,
3674                 struct ib_qp_attr *qp_attr,
3675                 int qp_attr_mask,
3676                 struct ib_qp_init_attr *qp_init_attr);
3677
3678 /**
3679  * ib_destroy_qp - Destroys the specified QP.
3680  * @qp: The QP to destroy.
3681  * @udata: Valid udata or NULL for kernel objects
3682  */
3683 int ib_destroy_qp_user(struct ib_qp *qp, struct ib_udata *udata);
3684
3685 /**
3686  * ib_destroy_qp - Destroys the specified kernel QP.
3687  * @qp: The QP to destroy.
3688  *
3689  * NOTE: for user qp use ib_destroy_qp_user with valid udata!
3690  */
3691 static inline int ib_destroy_qp(struct ib_qp *qp)
3692 {
3693         return ib_destroy_qp_user(qp, NULL);
3694 }
3695
3696 /**
3697  * ib_open_qp - Obtain a reference to an existing sharable QP.
3698  * @xrcd - XRC domain
3699  * @qp_open_attr: Attributes identifying the QP to open.
3700  *
3701  * Returns a reference to a sharable QP.
3702  */
3703 struct ib_qp *ib_open_qp(struct ib_xrcd *xrcd,
3704                          struct ib_qp_open_attr *qp_open_attr);
3705
3706 /**
3707  * ib_close_qp - Release an external reference to a QP.
3708  * @qp: The QP handle to release
3709  *
3710  * The opened QP handle is released by the caller.  The underlying
3711  * shared QP is not destroyed until all internal references are released.
3712  */
3713 int ib_close_qp(struct ib_qp *qp);
3714
3715 /**
3716  * ib_post_send - Posts a list of work requests to the send queue of
3717  *   the specified QP.
3718  * @qp: The QP to post the work request on.
3719  * @send_wr: A list of work requests to post on the send queue.
3720  * @bad_send_wr: On an immediate failure, this parameter will reference
3721  *   the work request that failed to be posted on the QP.
3722  *
3723  * While IBA Vol. 1 section 11.4.1.1 specifies that if an immediate
3724  * error is returned, the QP state shall not be affected,
3725  * ib_post_send() will return an immediate error after queueing any
3726  * earlier work requests in the list.
3727  */
3728 static inline int ib_post_send(struct ib_qp *qp,
3729                                const struct ib_send_wr *send_wr,
3730                                const struct ib_send_wr **bad_send_wr)
3731 {
3732         const struct ib_send_wr *dummy;
3733
3734         return qp->device->ops.post_send(qp, send_wr, bad_send_wr ? : &dummy);
3735 }
3736
3737 /**
3738  * ib_post_recv - Posts a list of work requests to the receive queue of
3739  *   the specified QP.
3740  * @qp: The QP to post the work request on.
3741  * @recv_wr: A list of work requests to post on the receive queue.
3742  * @bad_recv_wr: On an immediate failure, this parameter will reference
3743  *   the work request that failed to be posted on the QP.
3744  */
3745 static inline int ib_post_recv(struct ib_qp *qp,
3746                                const struct ib_recv_wr *recv_wr,
3747                                const struct ib_recv_wr **bad_recv_wr)
3748 {
3749         const struct ib_recv_wr *dummy;
3750
3751         return qp->device->ops.post_recv(qp, recv_wr, bad_recv_wr ? : &dummy);
3752 }
3753
3754 struct ib_cq *__ib_alloc_cq_user(struct ib_device *dev, void *private,
3755                                  int nr_cqe, int comp_vector,
3756                                  enum ib_poll_context poll_ctx,
3757                                  const char *caller, struct ib_udata *udata);
3758
3759 /**
3760  * ib_alloc_cq_user: Allocate kernel/user CQ
3761  * @dev: The IB device
3762  * @private: Private data attached to the CQE
3763  * @nr_cqe: Number of CQEs in the CQ
3764  * @comp_vector: Completion vector used for the IRQs
3765  * @poll_ctx: Context used for polling the CQ
3766  * @udata: Valid user data or NULL for kernel objects
3767  */
3768 static inline struct ib_cq *ib_alloc_cq_user(struct ib_device *dev,
3769                                              void *private, int nr_cqe,
3770                                              int comp_vector,
3771                                              enum ib_poll_context poll_ctx,
3772                                              struct ib_udata *udata)
3773 {
3774         return __ib_alloc_cq_user(dev, private, nr_cqe, comp_vector, poll_ctx,
3775                                   KBUILD_MODNAME, udata);
3776 }
3777
3778 /**
3779  * ib_alloc_cq: Allocate kernel CQ
3780  * @dev: The IB device
3781  * @private: Private data attached to the CQE
3782  * @nr_cqe: Number of CQEs in the CQ
3783  * @comp_vector: Completion vector used for the IRQs
3784  * @poll_ctx: Context used for polling the CQ
3785  *
3786  * NOTE: for user cq use ib_alloc_cq_user with valid udata!
3787  */
3788 static inline struct ib_cq *ib_alloc_cq(struct ib_device *dev, void *private,
3789                                         int nr_cqe, int comp_vector,
3790                                         enum ib_poll_context poll_ctx)
3791 {
3792         return ib_alloc_cq_user(dev, private, nr_cqe, comp_vector, poll_ctx,
3793                                 NULL);
3794 }
3795
3796 struct ib_cq *__ib_alloc_cq_any(struct ib_device *dev, void *private,
3797                                 int nr_cqe, enum ib_poll_context poll_ctx,
3798                                 const char *caller);
3799
3800 /**
3801  * ib_alloc_cq_any: Allocate kernel CQ
3802  * @dev: The IB device
3803  * @private: Private data attached to the CQE
3804  * @nr_cqe: Number of CQEs in the CQ
3805  * @poll_ctx: Context used for polling the CQ
3806  */
3807 static inline struct ib_cq *ib_alloc_cq_any(struct ib_device *dev,
3808                                             void *private, int nr_cqe,
3809                                             enum ib_poll_context poll_ctx)
3810 {
3811         return __ib_alloc_cq_any(dev, private, nr_cqe, poll_ctx,
3812                                  KBUILD_MODNAME);
3813 }
3814
3815 /**
3816  * ib_free_cq_user - Free kernel/user CQ
3817  * @cq: The CQ to free
3818  * @udata: Valid user data or NULL for kernel objects
3819  */
3820 void ib_free_cq_user(struct ib_cq *cq, struct ib_udata *udata);
3821
3822 /**
3823  * ib_free_cq - Free kernel CQ
3824  * @cq: The CQ to free
3825  *
3826  * NOTE: for user cq use ib_free_cq_user with valid udata!
3827  */
3828 static inline void ib_free_cq(struct ib_cq *cq)
3829 {
3830         ib_free_cq_user(cq, NULL);
3831 }
3832
3833 int ib_process_cq_direct(struct ib_cq *cq, int budget);
3834
3835 /**
3836  * ib_create_cq - Creates a CQ on the specified device.
3837  * @device: The device on which to create the CQ.
3838  * @comp_handler: A user-specified callback that is invoked when a
3839  *   completion event occurs on the CQ.
3840  * @event_handler: A user-specified callback that is invoked when an
3841  *   asynchronous event not associated with a completion occurs on the CQ.
3842  * @cq_context: Context associated with the CQ returned to the user via
3843  *   the associated completion and event handlers.
3844  * @cq_attr: The attributes the CQ should be created upon.
3845  *
3846  * Users can examine the cq structure to determine the actual CQ size.
3847  */
3848 struct ib_cq *__ib_create_cq(struct ib_device *device,
3849                              ib_comp_handler comp_handler,
3850                              void (*event_handler)(struct ib_event *, void *),
3851                              void *cq_context,
3852                              const struct ib_cq_init_attr *cq_attr,
3853                              const char *caller);
3854 #define ib_create_cq(device, cmp_hndlr, evt_hndlr, cq_ctxt, cq_attr) \
3855         __ib_create_cq((device), (cmp_hndlr), (evt_hndlr), (cq_ctxt), (cq_attr), KBUILD_MODNAME)
3856
3857 /**
3858  * ib_resize_cq - Modifies the capacity of the CQ.
3859  * @cq: The CQ to resize.
3860  * @cqe: The minimum size of the CQ.
3861  *
3862  * Users can examine the cq structure to determine the actual CQ size.
3863  */
3864 int ib_resize_cq(struct ib_cq *cq, int cqe);
3865
3866 /**
3867  * rdma_set_cq_moderation - Modifies moderation params of the CQ
3868  * @cq: The CQ to modify.
3869  * @cq_count: number of CQEs that will trigger an event
3870  * @cq_period: max period of time in usec before triggering an event
3871  *
3872  */
3873 int rdma_set_cq_moderation(struct ib_cq *cq, u16 cq_count, u16 cq_period);
3874
3875 /**
3876  * ib_destroy_cq_user - Destroys the specified CQ.
3877  * @cq: The CQ to destroy.
3878  * @udata: Valid user data or NULL for kernel objects
3879  */
3880 int ib_destroy_cq_user(struct ib_cq *cq, struct ib_udata *udata);
3881
3882 /**
3883  * ib_destroy_cq - Destroys the specified kernel CQ.
3884  * @cq: The CQ to destroy.
3885  *
3886  * NOTE: for user cq use ib_destroy_cq_user with valid udata!
3887  */
3888 static inline void ib_destroy_cq(struct ib_cq *cq)
3889 {
3890         ib_destroy_cq_user(cq, NULL);
3891 }
3892
3893 /**
3894  * ib_poll_cq - poll a CQ for completion(s)
3895  * @cq:the CQ being polled
3896  * @num_entries:maximum number of completions to return
3897  * @wc:array of at least @num_entries &struct ib_wc where completions
3898  *   will be returned
3899  *
3900  * Poll a CQ for (possibly multiple) completions.  If the return value
3901  * is < 0, an error occurred.  If the return value is >= 0, it is the
3902  * number of completions returned.  If the return value is
3903  * non-negative and < num_entries, then the CQ was emptied.
3904  */
3905 static inline int ib_poll_cq(struct ib_cq *cq, int num_entries,
3906                              struct ib_wc *wc)
3907 {
3908         return cq->device->ops.poll_cq(cq, num_entries, wc);
3909 }
3910
3911 /**
3912  * ib_req_notify_cq - Request completion notification on a CQ.
3913  * @cq: The CQ to generate an event for.
3914  * @flags:
3915  *   Must contain exactly one of %IB_CQ_SOLICITED or %IB_CQ_NEXT_COMP
3916  *   to request an event on the next solicited event or next work
3917  *   completion at any type, respectively. %IB_CQ_REPORT_MISSED_EVENTS
3918  *   may also be |ed in to request a hint about missed events, as
3919  *   described below.
3920  *
3921  * Return Value:
3922  *    < 0 means an error occurred while requesting notification
3923  *   == 0 means notification was requested successfully, and if
3924  *        IB_CQ_REPORT_MISSED_EVENTS was passed in, then no events
3925  *        were missed and it is safe to wait for another event.  In
3926  *        this case is it guaranteed that any work completions added
3927  *        to the CQ since the last CQ poll will trigger a completion
3928  *        notification event.
3929  *    > 0 is only returned if IB_CQ_REPORT_MISSED_EVENTS was passed
3930  *        in.  It means that the consumer must poll the CQ again to
3931  *        make sure it is empty to avoid missing an event because of a
3932  *        race between requesting notification and an entry being
3933  *        added to the CQ.  This return value means it is possible
3934  *        (but not guaranteed) that a work completion has been added
3935  *        to the CQ since the last poll without triggering a
3936  *        completion notification event.
3937  */
3938 static inline int ib_req_notify_cq(struct ib_cq *cq,
3939                                    enum ib_cq_notify_flags flags)
3940 {
3941         return cq->device->ops.req_notify_cq(cq, flags);
3942 }
3943
3944 /**
3945  * ib_req_ncomp_notif - Request completion notification when there are
3946  *   at least the specified number of unreaped completions on the CQ.
3947  * @cq: The CQ to generate an event for.
3948  * @wc_cnt: The number of unreaped completions that should be on the
3949  *   CQ before an event is generated.
3950  */
3951 static inline int ib_req_ncomp_notif(struct ib_cq *cq, int wc_cnt)
3952 {
3953         return cq->device->ops.req_ncomp_notif ?
3954                 cq->device->ops.req_ncomp_notif(cq, wc_cnt) :
3955                 -ENOSYS;
3956 }
3957
3958 /**
3959  * ib_dma_mapping_error - check a DMA addr for error
3960  * @dev: The device for which the dma_addr was created
3961  * @dma_addr: The DMA address to check
3962  */
3963 static inline int ib_dma_mapping_error(struct ib_device *dev, u64 dma_addr)
3964 {
3965         return dma_mapping_error(dev->dma_device, dma_addr);
3966 }
3967
3968 /**
3969  * ib_dma_map_single - Map a kernel virtual address to DMA address
3970  * @dev: The device for which the dma_addr is to be created
3971  * @cpu_addr: The kernel virtual address
3972  * @size: The size of the region in bytes
3973  * @direction: The direction of the DMA
3974  */
3975 static inline u64 ib_dma_map_single(struct ib_device *dev,
3976                                     void *cpu_addr, size_t size,
3977                                     enum dma_data_direction direction)
3978 {
3979         return dma_map_single(dev->dma_device, cpu_addr, size, direction);
3980 }
3981
3982 /**
3983  * ib_dma_unmap_single - Destroy a mapping created by ib_dma_map_single()
3984  * @dev: The device for which the DMA address was created
3985  * @addr: The DMA address
3986  * @size: The size of the region in bytes
3987  * @direction: The direction of the DMA
3988  */
3989 static inline void ib_dma_unmap_single(struct ib_device *dev,
3990                                        u64 addr, size_t size,
3991                                        enum dma_data_direction direction)
3992 {
3993         dma_unmap_single(dev->dma_device, addr, size, direction);
3994 }
3995
3996 /**
3997  * ib_dma_map_page - Map a physical page to DMA address
3998  * @dev: The device for which the dma_addr is to be created
3999  * @page: The page to be mapped
4000  * @offset: The offset within the page
4001  * @size: The size of the region in bytes
4002  * @direction: The direction of the DMA
4003  */
4004 static inline u64 ib_dma_map_page(struct ib_device *dev,
4005                                   struct page *page,
4006                                   unsigned long offset,
4007                                   size_t size,
4008                                          enum dma_data_direction direction)
4009 {
4010         return dma_map_page(dev->dma_device, page, offset, size, direction);
4011 }
4012
4013 /**
4014  * ib_dma_unmap_page - Destroy a mapping created by ib_dma_map_page()
4015  * @dev: The device for which the DMA address was created
4016  * @addr: The DMA address
4017  * @size: The size of the region in bytes
4018  * @direction: The direction of the DMA
4019  */
4020 static inline void ib_dma_unmap_page(struct ib_device *dev,
4021                                      u64 addr, size_t size,
4022                                      enum dma_data_direction direction)
4023 {
4024         dma_unmap_page(dev->dma_device, addr, size, direction);
4025 }
4026
4027 /**
4028  * ib_dma_map_sg - Map a scatter/gather list to DMA addresses
4029  * @dev: The device for which the DMA addresses are to be created
4030  * @sg: The array of scatter/gather entries
4031  * @nents: The number of scatter/gather entries
4032  * @direction: The direction of the DMA
4033  */
4034 static inline int ib_dma_map_sg(struct ib_device *dev,
4035                                 struct scatterlist *sg, int nents,
4036                                 enum dma_data_direction direction)
4037 {
4038         return dma_map_sg(dev->dma_device, sg, nents, direction);
4039 }
4040
4041 /**
4042  * ib_dma_unmap_sg - Unmap a scatter/gather list of DMA addresses
4043  * @dev: The device for which the DMA addresses were created
4044  * @sg: The array of scatter/gather entries
4045  * @nents: The number of scatter/gather entries
4046  * @direction: The direction of the DMA
4047  */
4048 static inline void ib_dma_unmap_sg(struct ib_device *dev,
4049                                    struct scatterlist *sg, int nents,
4050                                    enum dma_data_direction direction)
4051 {
4052         dma_unmap_sg(dev->dma_device, sg, nents, direction);
4053 }
4054
4055 static inline int ib_dma_map_sg_attrs(struct ib_device *dev,
4056                                       struct scatterlist *sg, int nents,
4057                                       enum dma_data_direction direction,
4058                                       unsigned long dma_attrs)
4059 {
4060         return dma_map_sg_attrs(dev->dma_device, sg, nents, direction,
4061                                 dma_attrs);
4062 }
4063
4064 static inline void ib_dma_unmap_sg_attrs(struct ib_device *dev,
4065                                          struct scatterlist *sg, int nents,
4066                                          enum dma_data_direction direction,
4067                                          unsigned long dma_attrs)
4068 {
4069         dma_unmap_sg_attrs(dev->dma_device, sg, nents, direction, dma_attrs);
4070 }
4071
4072 /**
4073  * ib_dma_max_seg_size - Return the size limit of a single DMA transfer
4074  * @dev: The device to query
4075  *
4076  * The returned value represents a size in bytes.
4077  */
4078 static inline unsigned int ib_dma_max_seg_size(struct ib_device *dev)
4079 {
4080         return dma_get_max_seg_size(dev->dma_device);
4081 }
4082
4083 /**
4084  * ib_dma_sync_single_for_cpu - Prepare DMA region to be accessed by CPU
4085  * @dev: The device for which the DMA address was created
4086  * @addr: The DMA address
4087  * @size: The size of the region in bytes
4088  * @dir: The direction of the DMA
4089  */
4090 static inline void ib_dma_sync_single_for_cpu(struct ib_device *dev,
4091                                               u64 addr,
4092                                               size_t size,
4093                                               enum dma_data_direction dir)
4094 {
4095         dma_sync_single_for_cpu(dev->dma_device, addr, size, dir);
4096 }
4097
4098 /**
4099  * ib_dma_sync_single_for_device - Prepare DMA region to be accessed by device
4100  * @dev: The device for which the DMA address was created
4101  * @addr: The DMA address
4102  * @size: The size of the region in bytes
4103  * @dir: The direction of the DMA
4104  */
4105 static inline void ib_dma_sync_single_for_device(struct ib_device *dev,
4106                                                  u64 addr,
4107                                                  size_t size,
4108                                                  enum dma_data_direction dir)
4109 {
4110         dma_sync_single_for_device(dev->dma_device, addr, size, dir);
4111 }
4112
4113 /**
4114  * ib_dma_alloc_coherent - Allocate memory and map it for DMA
4115  * @dev: The device for which the DMA address is requested
4116  * @size: The size of the region to allocate in bytes
4117  * @dma_handle: A pointer for returning the DMA address of the region
4118  * @flag: memory allocator flags
4119  */
4120 static inline void *ib_dma_alloc_coherent(struct ib_device *dev,
4121                                            size_t size,
4122                                            dma_addr_t *dma_handle,
4123                                            gfp_t flag)
4124 {
4125         return dma_alloc_coherent(dev->dma_device, size, dma_handle, flag);
4126 }
4127
4128 /**
4129  * ib_dma_free_coherent - Free memory allocated by ib_dma_alloc_coherent()
4130  * @dev: The device for which the DMA addresses were allocated
4131  * @size: The size of the region
4132  * @cpu_addr: the address returned by ib_dma_alloc_coherent()
4133  * @dma_handle: the DMA address returned by ib_dma_alloc_coherent()
4134  */
4135 static inline void ib_dma_free_coherent(struct ib_device *dev,
4136                                         size_t size, void *cpu_addr,
4137                                         dma_addr_t dma_handle)
4138 {
4139         dma_free_coherent(dev->dma_device, size, cpu_addr, dma_handle);
4140 }
4141
4142 /* ib_reg_user_mr - register a memory region for virtual addresses from kernel
4143  * space. This function should be called when 'current' is the owning MM.
4144  */
4145 struct ib_mr *ib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
4146                              u64 virt_addr, int mr_access_flags);
4147
4148 /* ib_advise_mr -  give an advice about an address range in a memory region */
4149 int ib_advise_mr(struct ib_pd *pd, enum ib_uverbs_advise_mr_advice advice,
4150                  u32 flags, struct ib_sge *sg_list, u32 num_sge);
4151 /**
4152  * ib_dereg_mr_user - Deregisters a memory region and removes it from the
4153  *   HCA translation table.
4154  * @mr: The memory region to deregister.
4155  * @udata: Valid user data or NULL for kernel object
4156  *
4157  * This function can fail, if the memory region has memory windows bound to it.
4158  */
4159 int ib_dereg_mr_user(struct ib_mr *mr, struct ib_udata *udata);
4160
4161 /**
4162  * ib_dereg_mr - Deregisters a kernel memory region and removes it from the
4163  *   HCA translation table.
4164  * @mr: The memory region to deregister.
4165  *
4166  * This function can fail, if the memory region has memory windows bound to it.
4167  *
4168  * NOTE: for user mr use ib_dereg_mr_user with valid udata!
4169  */
4170 static inline int ib_dereg_mr(struct ib_mr *mr)
4171 {
4172         return ib_dereg_mr_user(mr, NULL);
4173 }
4174
4175 struct ib_mr *ib_alloc_mr_user(struct ib_pd *pd, enum ib_mr_type mr_type,
4176                                u32 max_num_sg, struct ib_udata *udata);
4177
4178 static inline struct ib_mr *ib_alloc_mr(struct ib_pd *pd,
4179                                         enum ib_mr_type mr_type, u32 max_num_sg)
4180 {
4181         return ib_alloc_mr_user(pd, mr_type, max_num_sg, NULL);
4182 }
4183
4184 struct ib_mr *ib_alloc_mr_integrity(struct ib_pd *pd,
4185                                     u32 max_num_data_sg,
4186                                     u32 max_num_meta_sg);
4187
4188 /**
4189  * ib_update_fast_reg_key - updates the key portion of the fast_reg MR
4190  *   R_Key and L_Key.
4191  * @mr - struct ib_mr pointer to be updated.
4192  * @newkey - new key to be used.
4193  */
4194 static inline void ib_update_fast_reg_key(struct ib_mr *mr, u8 newkey)
4195 {
4196         mr->lkey = (mr->lkey & 0xffffff00) | newkey;
4197         mr->rkey = (mr->rkey & 0xffffff00) | newkey;
4198 }
4199
4200 /**
4201  * ib_inc_rkey - increments the key portion of the given rkey. Can be used
4202  * for calculating a new rkey for type 2 memory windows.
4203  * @rkey - the rkey to increment.
4204  */
4205 static inline u32 ib_inc_rkey(u32 rkey)
4206 {
4207         const u32 mask = 0x000000ff;
4208         return ((rkey + 1) & mask) | (rkey & ~mask);
4209 }
4210
4211 /**
4212  * ib_alloc_fmr - Allocates a unmapped fast memory region.
4213  * @pd: The protection domain associated with the unmapped region.
4214  * @mr_access_flags: Specifies the memory access rights.
4215  * @fmr_attr: Attributes of the unmapped region.
4216  *
4217  * A fast memory region must be mapped before it can be used as part of
4218  * a work request.
4219  */
4220 struct ib_fmr *ib_alloc_fmr(struct ib_pd *pd,
4221                             int mr_access_flags,
4222                             struct ib_fmr_attr *fmr_attr);
4223
4224 /**
4225  * ib_map_phys_fmr - Maps a list of physical pages to a fast memory region.
4226  * @fmr: The fast memory region to associate with the pages.
4227  * @page_list: An array of physical pages to map to the fast memory region.
4228  * @list_len: The number of pages in page_list.
4229  * @iova: The I/O virtual address to use with the mapped region.
4230  */
4231 static inline int ib_map_phys_fmr(struct ib_fmr *fmr,
4232                                   u64 *page_list, int list_len,
4233                                   u64 iova)
4234 {
4235         return fmr->device->ops.map_phys_fmr(fmr, page_list, list_len, iova);
4236 }
4237
4238 /**
4239  * ib_unmap_fmr - Removes the mapping from a list of fast memory regions.
4240  * @fmr_list: A linked list of fast memory regions to unmap.
4241  */
4242 int ib_unmap_fmr(struct list_head *fmr_list);
4243
4244 /**
4245  * ib_dealloc_fmr - Deallocates a fast memory region.
4246  * @fmr: The fast memory region to deallocate.
4247  */
4248 int ib_dealloc_fmr(struct ib_fmr *fmr);
4249
4250 /**
4251  * ib_attach_mcast - Attaches the specified QP to a multicast group.
4252  * @qp: QP to attach to the multicast group.  The QP must be type
4253  *   IB_QPT_UD.
4254  * @gid: Multicast group GID.
4255  * @lid: Multicast group LID in host byte order.
4256  *
4257  * In order to send and receive multicast packets, subnet
4258  * administration must have created the multicast group and configured
4259  * the fabric appropriately.  The port associated with the specified
4260  * QP must also be a member of the multicast group.
4261  */
4262 int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
4263
4264 /**
4265  * ib_detach_mcast - Detaches the specified QP from a multicast group.
4266  * @qp: QP to detach from the multicast group.
4267  * @gid: Multicast group GID.
4268  * @lid: Multicast group LID in host byte order.
4269  */
4270 int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
4271
4272 /**
4273  * ib_alloc_xrcd - Allocates an XRC domain.
4274  * @device: The device on which to allocate the XRC domain.
4275  * @caller: Module name for kernel consumers
4276  */
4277 struct ib_xrcd *__ib_alloc_xrcd(struct ib_device *device, const char *caller);
4278 #define ib_alloc_xrcd(device) \
4279         __ib_alloc_xrcd((device), KBUILD_MODNAME)
4280
4281 /**
4282  * ib_dealloc_xrcd - Deallocates an XRC domain.
4283  * @xrcd: The XRC domain to deallocate.
4284  * @udata: Valid user data or NULL for kernel object
4285  */
4286 int ib_dealloc_xrcd(struct ib_xrcd *xrcd, struct ib_udata *udata);
4287
4288 static inline int ib_check_mr_access(int flags)
4289 {
4290         /*
4291          * Local write permission is required if remote write or
4292          * remote atomic permission is also requested.
4293          */
4294         if (flags & (IB_ACCESS_REMOTE_ATOMIC | IB_ACCESS_REMOTE_WRITE) &&
4295             !(flags & IB_ACCESS_LOCAL_WRITE))
4296                 return -EINVAL;
4297
4298         if (flags & ~IB_ACCESS_SUPPORTED)
4299                 return -EINVAL;
4300
4301         return 0;
4302 }
4303
4304 static inline bool ib_access_writable(int access_flags)
4305 {
4306         /*
4307          * We have writable memory backing the MR if any of the following
4308          * access flags are set.  "Local write" and "remote write" obviously
4309          * require write access.  "Remote atomic" can do things like fetch and
4310          * add, which will modify memory, and "MW bind" can change permissions
4311          * by binding a window.
4312          */
4313         return access_flags &
4314                 (IB_ACCESS_LOCAL_WRITE   | IB_ACCESS_REMOTE_WRITE |
4315                  IB_ACCESS_REMOTE_ATOMIC | IB_ACCESS_MW_BIND);
4316 }
4317
4318 /**
4319  * ib_check_mr_status: lightweight check of MR status.
4320  *     This routine may provide status checks on a selected
4321  *     ib_mr. first use is for signature status check.
4322  *
4323  * @mr: A memory region.
4324  * @check_mask: Bitmask of which checks to perform from
4325  *     ib_mr_status_check enumeration.
4326  * @mr_status: The container of relevant status checks.
4327  *     failed checks will be indicated in the status bitmask
4328  *     and the relevant info shall be in the error item.
4329  */
4330 int ib_check_mr_status(struct ib_mr *mr, u32 check_mask,
4331                        struct ib_mr_status *mr_status);
4332
4333 /**
4334  * ib_device_try_get: Hold a registration lock
4335  * device: The device to lock
4336  *
4337  * A device under an active registration lock cannot become unregistered. It
4338  * is only possible to obtain a registration lock on a device that is fully
4339  * registered, otherwise this function returns false.
4340  *
4341  * The registration lock is only necessary for actions which require the
4342  * device to still be registered. Uses that only require the device pointer to
4343  * be valid should use get_device(&ibdev->dev) to hold the memory.
4344  *
4345  */
4346 static inline bool ib_device_try_get(struct ib_device *dev)
4347 {
4348         return refcount_inc_not_zero(&dev->refcount);
4349 }
4350
4351 void ib_device_put(struct ib_device *device);
4352 struct ib_device *ib_device_get_by_netdev(struct net_device *ndev,
4353                                           enum rdma_driver_id driver_id);
4354 struct ib_device *ib_device_get_by_name(const char *name,
4355                                         enum rdma_driver_id driver_id);
4356 struct net_device *ib_get_net_dev_by_params(struct ib_device *dev, u8 port,
4357                                             u16 pkey, const union ib_gid *gid,
4358                                             const struct sockaddr *addr);
4359 int ib_device_set_netdev(struct ib_device *ib_dev, struct net_device *ndev,
4360                          unsigned int port);
4361 struct net_device *ib_device_netdev(struct ib_device *dev, u8 port);
4362
4363 struct ib_wq *ib_create_wq(struct ib_pd *pd,
4364                            struct ib_wq_init_attr *init_attr);
4365 int ib_destroy_wq(struct ib_wq *wq, struct ib_udata *udata);
4366 int ib_modify_wq(struct ib_wq *wq, struct ib_wq_attr *attr,
4367                  u32 wq_attr_mask);
4368 struct ib_rwq_ind_table *ib_create_rwq_ind_table(struct ib_device *device,
4369                                                  struct ib_rwq_ind_table_init_attr*
4370                                                  wq_ind_table_init_attr);
4371 int ib_destroy_rwq_ind_table(struct ib_rwq_ind_table *wq_ind_table);
4372
4373 int ib_map_mr_sg(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
4374                  unsigned int *sg_offset, unsigned int page_size);
4375 int ib_map_mr_sg_pi(struct ib_mr *mr, struct scatterlist *data_sg,
4376                     int data_sg_nents, unsigned int *data_sg_offset,
4377                     struct scatterlist *meta_sg, int meta_sg_nents,
4378                     unsigned int *meta_sg_offset, unsigned int page_size);
4379
4380 static inline int
4381 ib_map_mr_sg_zbva(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
4382                   unsigned int *sg_offset, unsigned int page_size)
4383 {
4384         int n;
4385
4386         n = ib_map_mr_sg(mr, sg, sg_nents, sg_offset, page_size);
4387         mr->iova = 0;
4388
4389         return n;
4390 }
4391
4392 int ib_sg_to_pages(struct ib_mr *mr, struct scatterlist *sgl, int sg_nents,
4393                 unsigned int *sg_offset, int (*set_page)(struct ib_mr *, u64));
4394
4395 void ib_drain_rq(struct ib_qp *qp);
4396 void ib_drain_sq(struct ib_qp *qp);
4397 void ib_drain_qp(struct ib_qp *qp);
4398
4399 int ib_get_eth_speed(struct ib_device *dev, u8 port_num, u8 *speed, u8 *width);
4400
4401 static inline u8 *rdma_ah_retrieve_dmac(struct rdma_ah_attr *attr)
4402 {
4403         if (attr->type == RDMA_AH_ATTR_TYPE_ROCE)
4404                 return attr->roce.dmac;
4405         return NULL;
4406 }
4407
4408 static inline void rdma_ah_set_dlid(struct rdma_ah_attr *attr, u32 dlid)
4409 {
4410         if (attr->type == RDMA_AH_ATTR_TYPE_IB)
4411                 attr->ib.dlid = (u16)dlid;
4412         else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4413                 attr->opa.dlid = dlid;
4414 }
4415
4416 static inline u32 rdma_ah_get_dlid(const struct rdma_ah_attr *attr)
4417 {
4418         if (attr->type == RDMA_AH_ATTR_TYPE_IB)
4419                 return attr->ib.dlid;
4420         else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4421                 return attr->opa.dlid;
4422         return 0;
4423 }
4424
4425 static inline void rdma_ah_set_sl(struct rdma_ah_attr *attr, u8 sl)
4426 {
4427         attr->sl = sl;
4428 }
4429
4430 static inline u8 rdma_ah_get_sl(const struct rdma_ah_attr *attr)
4431 {
4432         return attr->sl;
4433 }
4434
4435 static inline void rdma_ah_set_path_bits(struct rdma_ah_attr *attr,
4436                                          u8 src_path_bits)
4437 {
4438         if (attr->type == RDMA_AH_ATTR_TYPE_IB)
4439                 attr->ib.src_path_bits = src_path_bits;
4440         else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4441                 attr->opa.src_path_bits = src_path_bits;
4442 }
4443
4444 static inline u8 rdma_ah_get_path_bits(const struct rdma_ah_attr *attr)
4445 {
4446         if (attr->type == RDMA_AH_ATTR_TYPE_IB)
4447                 return attr->ib.src_path_bits;
4448         else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4449                 return attr->opa.src_path_bits;
4450         return 0;
4451 }
4452
4453 static inline void rdma_ah_set_make_grd(struct rdma_ah_attr *attr,
4454                                         bool make_grd)
4455 {
4456         if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4457                 attr->opa.make_grd = make_grd;
4458 }
4459
4460 static inline bool rdma_ah_get_make_grd(const struct rdma_ah_attr *attr)
4461 {
4462         if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4463                 return attr->opa.make_grd;
4464         return false;
4465 }
4466
4467 static inline void rdma_ah_set_port_num(struct rdma_ah_attr *attr, u8 port_num)
4468 {
4469         attr->port_num = port_num;
4470 }
4471
4472 static inline u8 rdma_ah_get_port_num(const struct rdma_ah_attr *attr)
4473 {
4474         return attr->port_num;
4475 }
4476
4477 static inline void rdma_ah_set_static_rate(struct rdma_ah_attr *attr,
4478                                            u8 static_rate)
4479 {
4480         attr->static_rate = static_rate;
4481 }
4482
4483 static inline u8 rdma_ah_get_static_rate(const struct rdma_ah_attr *attr)
4484 {
4485         return attr->static_rate;
4486 }
4487
4488 static inline void rdma_ah_set_ah_flags(struct rdma_ah_attr *attr,
4489                                         enum ib_ah_flags flag)
4490 {
4491         attr->ah_flags = flag;
4492 }
4493
4494 static inline enum ib_ah_flags
4495                 rdma_ah_get_ah_flags(const struct rdma_ah_attr *attr)
4496 {
4497         return attr->ah_flags;
4498 }
4499
4500 static inline const struct ib_global_route
4501                 *rdma_ah_read_grh(const struct rdma_ah_attr *attr)
4502 {
4503         return &attr->grh;
4504 }
4505
4506 /*To retrieve and modify the grh */
4507 static inline struct ib_global_route
4508                 *rdma_ah_retrieve_grh(struct rdma_ah_attr *attr)
4509 {
4510         return &attr->grh;
4511 }
4512
4513 static inline void rdma_ah_set_dgid_raw(struct rdma_ah_attr *attr, void *dgid)
4514 {
4515         struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
4516
4517         memcpy(grh->dgid.raw, dgid, sizeof(grh->dgid));
4518 }
4519
4520 static inline void rdma_ah_set_subnet_prefix(struct rdma_ah_attr *attr,
4521                                              __be64 prefix)
4522 {
4523         struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
4524
4525         grh->dgid.global.subnet_prefix = prefix;
4526 }
4527
4528 static inline void rdma_ah_set_interface_id(struct rdma_ah_attr *attr,
4529                                             __be64 if_id)
4530 {
4531         struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
4532
4533         grh->dgid.global.interface_id = if_id;
4534 }
4535
4536 static inline void rdma_ah_set_grh(struct rdma_ah_attr *attr,
4537                                    union ib_gid *dgid, u32 flow_label,
4538                                    u8 sgid_index, u8 hop_limit,
4539                                    u8 traffic_class)
4540 {
4541         struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
4542
4543         attr->ah_flags = IB_AH_GRH;
4544         if (dgid)
4545                 grh->dgid = *dgid;
4546         grh->flow_label = flow_label;
4547         grh->sgid_index = sgid_index;
4548         grh->hop_limit = hop_limit;
4549         grh->traffic_class = traffic_class;
4550         grh->sgid_attr = NULL;
4551 }
4552
4553 void rdma_destroy_ah_attr(struct rdma_ah_attr *ah_attr);
4554 void rdma_move_grh_sgid_attr(struct rdma_ah_attr *attr, union ib_gid *dgid,
4555                              u32 flow_label, u8 hop_limit, u8 traffic_class,
4556                              const struct ib_gid_attr *sgid_attr);
4557 void rdma_copy_ah_attr(struct rdma_ah_attr *dest,
4558                        const struct rdma_ah_attr *src);
4559 void rdma_replace_ah_attr(struct rdma_ah_attr *old,
4560                           const struct rdma_ah_attr *new);
4561 void rdma_move_ah_attr(struct rdma_ah_attr *dest, struct rdma_ah_attr *src);
4562
4563 /**
4564  * rdma_ah_find_type - Return address handle type.
4565  *
4566  * @dev: Device to be checked
4567  * @port_num: Port number
4568  */
4569 static inline enum rdma_ah_attr_type rdma_ah_find_type(struct ib_device *dev,
4570                                                        u8 port_num)
4571 {
4572         if (rdma_protocol_roce(dev, port_num))
4573                 return RDMA_AH_ATTR_TYPE_ROCE;
4574         if (rdma_protocol_ib(dev, port_num)) {
4575                 if (rdma_cap_opa_ah(dev, port_num))
4576                         return RDMA_AH_ATTR_TYPE_OPA;
4577                 return RDMA_AH_ATTR_TYPE_IB;
4578         }
4579
4580         return RDMA_AH_ATTR_TYPE_UNDEFINED;
4581 }
4582
4583 /**
4584  * ib_lid_cpu16 - Return lid in 16bit CPU encoding.
4585  *     In the current implementation the only way to get
4586  *     get the 32bit lid is from other sources for OPA.
4587  *     For IB, lids will always be 16bits so cast the
4588  *     value accordingly.
4589  *
4590  * @lid: A 32bit LID
4591  */
4592 static inline u16 ib_lid_cpu16(u32 lid)
4593 {
4594         WARN_ON_ONCE(lid & 0xFFFF0000);
4595         return (u16)lid;
4596 }
4597
4598 /**
4599  * ib_lid_be16 - Return lid in 16bit BE encoding.
4600  *
4601  * @lid: A 32bit LID
4602  */
4603 static inline __be16 ib_lid_be16(u32 lid)
4604 {
4605         WARN_ON_ONCE(lid & 0xFFFF0000);
4606         return cpu_to_be16((u16)lid);
4607 }
4608
4609 /**
4610  * ib_get_vector_affinity - Get the affinity mappings of a given completion
4611  *   vector
4612  * @device:         the rdma device
4613  * @comp_vector:    index of completion vector
4614  *
4615  * Returns NULL on failure, otherwise a corresponding cpu map of the
4616  * completion vector (returns all-cpus map if the device driver doesn't
4617  * implement get_vector_affinity).
4618  */
4619 static inline const struct cpumask *
4620 ib_get_vector_affinity(struct ib_device *device, int comp_vector)
4621 {
4622         if (comp_vector < 0 || comp_vector >= device->num_comp_vectors ||
4623             !device->ops.get_vector_affinity)
4624                 return NULL;
4625
4626         return device->ops.get_vector_affinity(device, comp_vector);
4627
4628 }
4629
4630 /**
4631  * rdma_roce_rescan_device - Rescan all of the network devices in the system
4632  * and add their gids, as needed, to the relevant RoCE devices.
4633  *
4634  * @device:         the rdma device
4635  */
4636 void rdma_roce_rescan_device(struct ib_device *ibdev);
4637
4638 struct ib_ucontext *ib_uverbs_get_ucontext_file(struct ib_uverbs_file *ufile);
4639
4640 int uverbs_destroy_def_handler(struct uverbs_attr_bundle *attrs);
4641
4642 struct net_device *rdma_alloc_netdev(struct ib_device *device, u8 port_num,
4643                                      enum rdma_netdev_t type, const char *name,
4644                                      unsigned char name_assign_type,
4645                                      void (*setup)(struct net_device *));
4646
4647 int rdma_init_netdev(struct ib_device *device, u8 port_num,
4648                      enum rdma_netdev_t type, const char *name,
4649                      unsigned char name_assign_type,
4650                      void (*setup)(struct net_device *),
4651                      struct net_device *netdev);
4652
4653 /**
4654  * rdma_set_device_sysfs_group - Set device attributes group to have
4655  *                               driver specific sysfs entries at
4656  *                               for infiniband class.
4657  *
4658  * @device:     device pointer for which attributes to be created
4659  * @group:      Pointer to group which should be added when device
4660  *              is registered with sysfs.
4661  * rdma_set_device_sysfs_group() allows existing drivers to expose one
4662  * group per device to have sysfs attributes.
4663  *
4664  * NOTE: New drivers should not make use of this API; instead new device
4665  * parameter should be exposed via netlink command. This API and mechanism
4666  * exist only for existing drivers.
4667  */
4668 static inline void
4669 rdma_set_device_sysfs_group(struct ib_device *dev,
4670                             const struct attribute_group *group)
4671 {
4672         dev->groups[1] = group;
4673 }
4674
4675 /**
4676  * rdma_device_to_ibdev - Get ib_device pointer from device pointer
4677  *
4678  * @device:     device pointer for which ib_device pointer to retrieve
4679  *
4680  * rdma_device_to_ibdev() retrieves ib_device pointer from device.
4681  *
4682  */
4683 static inline struct ib_device *rdma_device_to_ibdev(struct device *device)
4684 {
4685         struct ib_core_device *coredev =
4686                 container_of(device, struct ib_core_device, dev);
4687
4688         return coredev->owner;
4689 }
4690
4691 /**
4692  * rdma_device_to_drv_device - Helper macro to reach back to driver's
4693  *                             ib_device holder structure from device pointer.
4694  *
4695  * NOTE: New drivers should not make use of this API; This API is only for
4696  * existing drivers who have exposed sysfs entries using
4697  * rdma_set_device_sysfs_group().
4698  */
4699 #define rdma_device_to_drv_device(dev, drv_dev_struct, ibdev_member)           \
4700         container_of(rdma_device_to_ibdev(dev), drv_dev_struct, ibdev_member)
4701
4702 bool rdma_dev_access_netns(const struct ib_device *device,
4703                            const struct net *net);
4704 #endif /* IB_VERBS_H */