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