kernel/drivers/infiniband/hw/qib/qib_verbs.h

   1 /*
   2  * Copyright (c) 2012, 2013 Intel Corporation.  All rights reserved.
   3  * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
   4  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
   5  *
   6  * This software is available to you under a choice of one of two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        provided with the distribution.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * SOFTWARE.
  33  */
  34
  35 #ifndef QIB_VERBS_H
  36 #define QIB_VERBS_H
  37
  38 #include <linux/types.h>
  39 #include <linux/spinlock.h>
  40 #include <linux/kernel.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/kref.h>
  43 #include <linux/workqueue.h>
  44 #include <linux/kthread.h>
  45 #include <linux/completion.h>
  46 #include <rdma/ib_pack.h>
  47 #include <rdma/ib_user_verbs.h>
  48
  49 struct qib_ctxtdata;
  50 struct qib_pportdata;
  51 struct qib_devdata;
  52 struct qib_verbs_txreq;
  53
  54 #define QIB_MAX_RDMA_ATOMIC     16
  55 #define QIB_GUIDS_PER_PORT      5
  56
  57 #define QPN_MAX                 (1 << 24)
  58 #define QPNMAP_ENTRIES          (QPN_MAX / PAGE_SIZE / BITS_PER_BYTE)
  59
  60 /*
  61  * Increment this value if any changes that break userspace ABI
  62  * compatibility are made.
  63  */
  64 #define QIB_UVERBS_ABI_VERSION       2
  65
  66 /*
  67  * Define an ib_cq_notify value that is not valid so we know when CQ
  68  * notifications are armed.
  69  */
  70 #define IB_CQ_NONE      (IB_CQ_NEXT_COMP + 1)
  71
  72 #define IB_SEQ_NAK      (3 << 29)
  73
  74 /* AETH NAK opcode values */
  75 #define IB_RNR_NAK                      0x20
  76 #define IB_NAK_PSN_ERROR                0x60
  77 #define IB_NAK_INVALID_REQUEST          0x61
  78 #define IB_NAK_REMOTE_ACCESS_ERROR      0x62
  79 #define IB_NAK_REMOTE_OPERATIONAL_ERROR 0x63
  80 #define IB_NAK_INVALID_RD_REQUEST       0x64
  81
  82 /* Flags for checking QP state (see ib_qib_state_ops[]) */
  83 #define QIB_POST_SEND_OK                0x01
  84 #define QIB_POST_RECV_OK                0x02
  85 #define QIB_PROCESS_RECV_OK             0x04
  86 #define QIB_PROCESS_SEND_OK             0x08
  87 #define QIB_PROCESS_NEXT_SEND_OK        0x10
  88 #define QIB_FLUSH_SEND                  0x20
  89 #define QIB_FLUSH_RECV                  0x40
  90 #define QIB_PROCESS_OR_FLUSH_SEND \
  91         (QIB_PROCESS_SEND_OK | QIB_FLUSH_SEND)
  92
  93 /* IB Performance Manager status values */
  94 #define IB_PMA_SAMPLE_STATUS_DONE       0x00
  95 #define IB_PMA_SAMPLE_STATUS_STARTED    0x01
  96 #define IB_PMA_SAMPLE_STATUS_RUNNING    0x02
  97
  98 /* Mandatory IB performance counter select values. */
  99 #define IB_PMA_PORT_XMIT_DATA   cpu_to_be16(0x0001)
 100 #define IB_PMA_PORT_RCV_DATA    cpu_to_be16(0x0002)
 101 #define IB_PMA_PORT_XMIT_PKTS   cpu_to_be16(0x0003)
 102 #define IB_PMA_PORT_RCV_PKTS    cpu_to_be16(0x0004)
 103 #define IB_PMA_PORT_XMIT_WAIT   cpu_to_be16(0x0005)
 104
 105 #define QIB_VENDOR_IPG          cpu_to_be16(0xFFA0)
 106
 107 #define IB_BTH_REQ_ACK          (1 << 31)
 108 #define IB_BTH_SOLICITED        (1 << 23)
 109 #define IB_BTH_MIG_REQ          (1 << 22)
 110
 111 /* XXX Should be defined in ib_verbs.h enum ib_port_cap_flags */
 112 #define IB_PORT_OTHER_LOCAL_CHANGES_SUP (1 << 26)
 113
 114 #define IB_GRH_VERSION          6
 115 #define IB_GRH_VERSION_MASK     0xF
 116 #define IB_GRH_VERSION_SHIFT    28
 117 #define IB_GRH_TCLASS_MASK      0xFF
 118 #define IB_GRH_TCLASS_SHIFT     20
 119 #define IB_GRH_FLOW_MASK        0xFFFFF
 120 #define IB_GRH_FLOW_SHIFT       0
 121 #define IB_GRH_NEXT_HDR         0x1B
 122
 123 #define IB_DEFAULT_GID_PREFIX   cpu_to_be64(0xfe80000000000000ULL)
 124
 125 /* Values for set/get portinfo VLCap OperationalVLs */
 126 #define IB_VL_VL0       1
 127 #define IB_VL_VL0_1     2
 128 #define IB_VL_VL0_3     3
 129 #define IB_VL_VL0_7     4
 130 #define IB_VL_VL0_14    5
 131
 132 static inline int qib_num_vls(int vls)
 133 {
 134         switch (vls) {
 135         default:
 136         case IB_VL_VL0:
 137                 return 1;
 138         case IB_VL_VL0_1:
 139                 return 2;
 140         case IB_VL_VL0_3:
 141                 return 4;
 142         case IB_VL_VL0_7:
 143                 return 8;
 144         case IB_VL_VL0_14:
 145                 return 15;
 146         }
 147 }
 148
 149 struct ib_reth {
 150         __be64 vaddr;
 151         __be32 rkey;
 152         __be32 length;
 153 } __packed;
 154
 155 struct ib_atomic_eth {
 156         __be32 vaddr[2];        /* unaligned so access as 2 32-bit words */
 157         __be32 rkey;
 158         __be64 swap_data;
 159         __be64 compare_data;
 160 } __packed;
 161
 162 struct qib_other_headers {
 163         __be32 bth[3];
 164         union {
 165                 struct {
 166                         __be32 deth[2];
 167                         __be32 imm_data;
 168                 } ud;
 169                 struct {
 170                         struct ib_reth reth;
 171                         __be32 imm_data;
 172                 } rc;
 173                 struct {
 174                         __be32 aeth;
 175                         __be32 atomic_ack_eth[2];
 176                 } at;
 177                 __be32 imm_data;
 178                 __be32 aeth;
 179                 struct ib_atomic_eth atomic_eth;
 180         } u;
 181 } __packed;
 182
 183 /*
 184  * Note that UD packets with a GRH header are 8+40+12+8 = 68 bytes
 185  * long (72 w/ imm_data).  Only the first 56 bytes of the IB header
 186  * will be in the eager header buffer.  The remaining 12 or 16 bytes
 187  * are in the data buffer.
 188  */
 189 struct qib_ib_header {
 190         __be16 lrh[4];
 191         union {
 192                 struct {
 193                         struct ib_grh grh;
 194                         struct qib_other_headers oth;
 195                 } l;
 196                 struct qib_other_headers oth;
 197         } u;
 198 } __packed;
 199
 200 struct qib_pio_header {
 201         __le32 pbc[2];
 202         struct qib_ib_header hdr;
 203 } __packed;
 204
 205 /*
 206  * There is one struct qib_mcast for each multicast GID.
 207  * All attached QPs are then stored as a list of
 208  * struct qib_mcast_qp.
 209  */
 210 struct qib_mcast_qp {
 211         struct list_head list;
 212         struct qib_qp *qp;
 213 };
 214
 215 struct qib_mcast {
 216         struct rb_node rb_node;
 217         union ib_gid mgid;
 218         struct list_head qp_list;
 219         wait_queue_head_t wait;
 220         atomic_t refcount;
 221         int n_attached;
 222 };
 223
 224 /* Protection domain */
 225 struct qib_pd {
 226         struct ib_pd ibpd;
 227         int user;               /* non-zero if created from user space */
 228 };
 229
 230 /* Address Handle */
 231 struct qib_ah {
 232         struct ib_ah ibah;
 233         struct ib_ah_attr attr;
 234         atomic_t refcount;
 235 };
 236
 237 /*
 238  * This structure is used by qib_mmap() to validate an offset
 239  * when an mmap() request is made.  The vm_area_struct then uses
 240  * this as its vm_private_data.
 241  */
 242 struct qib_mmap_info {
 243         struct list_head pending_mmaps;
 244         struct ib_ucontext *context;
 245         void *obj;
 246         __u64 offset;
 247         struct kref ref;
 248         unsigned size;
 249 };
 250
 251 /*
 252  * This structure is used to contain the head pointer, tail pointer,
 253  * and completion queue entries as a single memory allocation so
 254  * it can be mmap'ed into user space.
 255  */
 256 struct qib_cq_wc {
 257         u32 head;               /* index of next entry to fill */
 258         u32 tail;               /* index of next ib_poll_cq() entry */
 259         union {
 260                 /* these are actually size ibcq.cqe + 1 */
 261                 struct ib_uverbs_wc uqueue[0];
 262                 struct ib_wc kqueue[0];
 263         };
 264 };
 265
 266 /*
 267  * The completion queue structure.
 268  */
 269 struct qib_cq {
 270         struct ib_cq ibcq;
 271         struct kthread_work comptask;
 272         struct qib_devdata *dd;
 273         spinlock_t lock; /* protect changes in this struct */
 274         u8 notify;
 275         u8 triggered;
 276         struct qib_cq_wc *queue;
 277         struct qib_mmap_info *ip;
 278 };
 279
 280 /*
 281  * A segment is a linear region of low physical memory.
 282  * XXX Maybe we should use phys addr here and kmap()/kunmap().
 283  * Used by the verbs layer.
 284  */
 285 struct qib_seg {
 286         void *vaddr;
 287         size_t length;
 288 };
 289
 290 /* The number of qib_segs that fit in a page. */
 291 #define QIB_SEGSZ     (PAGE_SIZE / sizeof(struct qib_seg))
 292
 293 struct qib_segarray {
 294         struct qib_seg segs[QIB_SEGSZ];
 295 };
 296
 297 struct qib_mregion {
 298         struct ib_pd *pd;       /* shares refcnt of ibmr.pd */
 299         u64 user_base;          /* User's address for this region */
 300         u64 iova;               /* IB start address of this region */
 301         size_t length;
 302         u32 lkey;
 303         u32 offset;             /* offset (bytes) to start of region */
 304         int access_flags;
 305         u32 max_segs;           /* number of qib_segs in all the arrays */
 306         u32 mapsz;              /* size of the map array */
 307         u8  page_shift;         /* 0 - non unform/non powerof2 sizes */
 308         u8  lkey_published;     /* in global table */
 309         struct completion comp; /* complete when refcount goes to zero */
 310         struct rcu_head list;
 311         atomic_t refcount;
 312         struct qib_segarray *map[0];    /* the segments */
 313 };
 314
 315 /*
 316  * These keep track of the copy progress within a memory region.
 317  * Used by the verbs layer.
 318  */
 319 struct qib_sge {
 320         struct qib_mregion *mr;
 321         void *vaddr;            /* kernel virtual address of segment */
 322         u32 sge_length;         /* length of the SGE */
 323         u32 length;             /* remaining length of the segment */
 324         u16 m;                  /* current index: mr->map[m] */
 325         u16 n;                  /* current index: mr->map[m]->segs[n] */
 326 };
 327
 328 /* Memory region */
 329 struct qib_mr {
 330         struct ib_mr ibmr;
 331         struct ib_umem *umem;
 332         u64 *pages;
 333         u32 npages;
 334         struct qib_mregion mr;  /* must be last */
 335 };
 336
 337 /*
 338  * Send work request queue entry.
 339  * The size of the sg_list is determined when the QP is created and stored
 340  * in qp->s_max_sge.
 341  */
 342 struct qib_swqe {
 343         union {
 344                 struct ib_send_wr wr;   /* don't use wr.sg_list */
 345                 struct ib_ud_wr ud_wr;
 346                 struct ib_reg_wr reg_wr;
 347                 struct ib_rdma_wr rdma_wr;
 348                 struct ib_atomic_wr atomic_wr;
 349         };
 350         u32 psn;                /* first packet sequence number */
 351         u32 lpsn;               /* last packet sequence number */
 352         u32 ssn;                /* send sequence number */
 353         u32 length;             /* total length of data in sg_list */
 354         struct qib_sge sg_list[0];
 355 };
 356
 357 /*
 358  * Receive work request queue entry.
 359  * The size of the sg_list is determined when the QP (or SRQ) is created
 360  * and stored in qp->r_rq.max_sge (or srq->rq.max_sge).
 361  */
 362 struct qib_rwqe {
 363         u64 wr_id;
 364         u8 num_sge;
 365         struct ib_sge sg_list[0];
 366 };
 367
 368 /*
 369  * This structure is used to contain the head pointer, tail pointer,
 370  * and receive work queue entries as a single memory allocation so
 371  * it can be mmap'ed into user space.
 372  * Note that the wq array elements are variable size so you can't
 373  * just index into the array to get the N'th element;
 374  * use get_rwqe_ptr() instead.
 375  */
 376 struct qib_rwq {
 377         u32 head;               /* new work requests posted to the head */
 378         u32 tail;               /* receives pull requests from here. */
 379         struct qib_rwqe wq[0];
 380 };
 381
 382 struct qib_rq {
 383         struct qib_rwq *wq;
 384         u32 size;               /* size of RWQE array */
 385         u8 max_sge;
 386         spinlock_t lock /* protect changes in this struct */
 387                 ____cacheline_aligned_in_smp;
 388 };
 389
 390 struct qib_srq {
 391         struct ib_srq ibsrq;
 392         struct qib_rq rq;
 393         struct qib_mmap_info *ip;
 394         /* send signal when number of RWQEs < limit */
 395         u32 limit;
 396 };
 397
 398 struct qib_sge_state {
 399         struct qib_sge *sg_list;      /* next SGE to be used if any */
 400         struct qib_sge sge;   /* progress state for the current SGE */
 401         u32 total_len;
 402         u8 num_sge;
 403 };
 404
 405 /*
 406  * This structure holds the information that the send tasklet needs
 407  * to send a RDMA read response or atomic operation.
 408  */
 409 struct qib_ack_entry {
 410         u8 opcode;
 411         u8 sent;
 412         u32 psn;
 413         u32 lpsn;
 414         union {
 415                 struct qib_sge rdma_sge;
 416                 u64 atomic_data;
 417         };
 418 };
 419
 420 /*
 421  * Variables prefixed with s_ are for the requester (sender).
 422  * Variables prefixed with r_ are for the responder (receiver).
 423  * Variables prefixed with ack_ are for responder replies.
 424  *
 425  * Common variables are protected by both r_rq.lock and s_lock in that order
 426  * which only happens in modify_qp() or changing the QP 'state'.
 427  */
 428 struct qib_qp {
 429         struct ib_qp ibqp;
 430         /* read mostly fields above and below */
 431         struct ib_ah_attr remote_ah_attr;
 432         struct ib_ah_attr alt_ah_attr;
 433         struct qib_qp __rcu *next;            /* link list for QPN hash table */
 434         struct qib_swqe *s_wq;  /* send work queue */
 435         struct qib_mmap_info *ip;
 436         struct qib_ib_header *s_hdr;     /* next packet header to send */
 437         unsigned long timeout_jiffies;  /* computed from timeout */
 438
 439         enum ib_mtu path_mtu;
 440         u32 remote_qpn;
 441         u32 pmtu;               /* decoded from path_mtu */
 442         u32 qkey;               /* QKEY for this QP (for UD or RD) */
 443         u32 s_size;             /* send work queue size */
 444         u32 s_rnr_timeout;      /* number of milliseconds for RNR timeout */
 445
 446         u8 state;               /* QP state */
 447         u8 qp_access_flags;
 448         u8 alt_timeout;         /* Alternate path timeout for this QP */
 449         u8 timeout;             /* Timeout for this QP */
 450         u8 s_srate;
 451         u8 s_mig_state;
 452         u8 port_num;
 453         u8 s_pkey_index;        /* PKEY index to use */
 454         u8 s_alt_pkey_index;    /* Alternate path PKEY index to use */
 455         u8 r_max_rd_atomic;     /* max number of RDMA read/atomic to receive */
 456         u8 s_max_rd_atomic;     /* max number of RDMA read/atomic to send */
 457         u8 s_retry_cnt;         /* number of times to retry */
 458         u8 s_rnr_retry_cnt;
 459         u8 r_min_rnr_timer;     /* retry timeout value for RNR NAKs */
 460         u8 s_max_sge;           /* size of s_wq->sg_list */
 461         u8 s_draining;
 462
 463         /* start of read/write fields */
 464
 465         atomic_t refcount ____cacheline_aligned_in_smp;
 466         wait_queue_head_t wait;
 467
 468
 469         struct qib_ack_entry s_ack_queue[QIB_MAX_RDMA_ATOMIC + 1]
 470                 ____cacheline_aligned_in_smp;
 471         struct qib_sge_state s_rdma_read_sge;
 472
 473         spinlock_t r_lock ____cacheline_aligned_in_smp;      /* used for APM */
 474         unsigned long r_aflags;
 475         u64 r_wr_id;            /* ID for current receive WQE */
 476         u32 r_ack_psn;          /* PSN for next ACK or atomic ACK */
 477         u32 r_len;              /* total length of r_sge */
 478         u32 r_rcv_len;          /* receive data len processed */
 479         u32 r_psn;              /* expected rcv packet sequence number */
 480         u32 r_msn;              /* message sequence number */
 481
 482         u8 r_state;             /* opcode of last packet received */
 483         u8 r_flags;
 484         u8 r_head_ack_queue;    /* index into s_ack_queue[] */
 485
 486         struct list_head rspwait;       /* link for waititing to respond */
 487
 488         struct qib_sge_state r_sge;     /* current receive data */
 489         struct qib_rq r_rq;             /* receive work queue */
 490
 491         spinlock_t s_lock ____cacheline_aligned_in_smp;
 492         struct qib_sge_state *s_cur_sge;
 493         u32 s_flags;
 494         struct qib_verbs_txreq *s_tx;
 495         struct qib_swqe *s_wqe;
 496         struct qib_sge_state s_sge;     /* current send request data */
 497         struct qib_mregion *s_rdma_mr;
 498         atomic_t s_dma_busy;
 499         u32 s_cur_size;         /* size of send packet in bytes */
 500         u32 s_len;              /* total length of s_sge */
 501         u32 s_rdma_read_len;    /* total length of s_rdma_read_sge */
 502         u32 s_next_psn;         /* PSN for next request */
 503         u32 s_last_psn;         /* last response PSN processed */
 504         u32 s_sending_psn;      /* lowest PSN that is being sent */
 505         u32 s_sending_hpsn;     /* highest PSN that is being sent */
 506         u32 s_psn;              /* current packet sequence number */
 507         u32 s_ack_rdma_psn;     /* PSN for sending RDMA read responses */
 508         u32 s_ack_psn;          /* PSN for acking sends and RDMA writes */
 509         u32 s_head;             /* new entries added here */
 510         u32 s_tail;             /* next entry to process */
 511         u32 s_cur;              /* current work queue entry */
 512         u32 s_acked;            /* last un-ACK'ed entry */
 513         u32 s_last;             /* last completed entry */
 514         u32 s_ssn;              /* SSN of tail entry */
 515         u32 s_lsn;              /* limit sequence number (credit) */
 516         u16 s_hdrwords;         /* size of s_hdr in 32 bit words */
 517         u16 s_rdma_ack_cnt;
 518         u8 s_state;             /* opcode of last packet sent */
 519         u8 s_ack_state;         /* opcode of packet to ACK */
 520         u8 s_nak_state;         /* non-zero if NAK is pending */
 521         u8 r_nak_state;         /* non-zero if NAK is pending */
 522         u8 s_retry;             /* requester retry counter */
 523         u8 s_rnr_retry;         /* requester RNR retry counter */
 524         u8 s_num_rd_atomic;     /* number of RDMA read/atomic pending */
 525         u8 s_tail_ack_queue;    /* index into s_ack_queue[] */
 526
 527         struct qib_sge_state s_ack_rdma_sge;
 528         struct timer_list s_timer;
 529         struct list_head iowait;        /* link for wait PIO buf */
 530
 531         struct work_struct s_work;
 532
 533         wait_queue_head_t wait_dma;
 534
 535         struct qib_sge r_sg_list[0] /* verified SGEs */
 536                 ____cacheline_aligned_in_smp;
 537 };
 538
 539 /*
 540  * Atomic bit definitions for r_aflags.
 541  */
 542 #define QIB_R_WRID_VALID        0
 543 #define QIB_R_REWIND_SGE        1
 544
 545 /*
 546  * Bit definitions for r_flags.
 547  */
 548 #define QIB_R_REUSE_SGE 0x01
 549 #define QIB_R_RDMAR_SEQ 0x02
 550 #define QIB_R_RSP_NAK   0x04
 551 #define QIB_R_RSP_SEND  0x08
 552 #define QIB_R_COMM_EST  0x10
 553
 554 /*
 555  * Bit definitions for s_flags.
 556  *
 557  * QIB_S_SIGNAL_REQ_WR - set if QP send WRs contain completion signaled
 558  * QIB_S_BUSY - send tasklet is processing the QP
 559  * QIB_S_TIMER - the RC retry timer is active
 560  * QIB_S_ACK_PENDING - an ACK is waiting to be sent after RDMA read/atomics
 561  * QIB_S_WAIT_FENCE - waiting for all prior RDMA read or atomic SWQEs
 562  *                         before processing the next SWQE
 563  * QIB_S_WAIT_RDMAR - waiting for a RDMA read or atomic SWQE to complete
 564  *                         before processing the next SWQE
 565  * QIB_S_WAIT_RNR - waiting for RNR timeout
 566  * QIB_S_WAIT_SSN_CREDIT - waiting for RC credits to process next SWQE
 567  * QIB_S_WAIT_DMA - waiting for send DMA queue to drain before generating
 568  *                  next send completion entry not via send DMA
 569  * QIB_S_WAIT_PIO - waiting for a send buffer to be available
 570  * QIB_S_WAIT_TX - waiting for a struct qib_verbs_txreq to be available
 571  * QIB_S_WAIT_DMA_DESC - waiting for DMA descriptors to be available
 572  * QIB_S_WAIT_KMEM - waiting for kernel memory to be available
 573  * QIB_S_WAIT_PSN - waiting for a packet to exit the send DMA queue
 574  * QIB_S_WAIT_ACK - waiting for an ACK packet before sending more requests
 575  * QIB_S_SEND_ONE - send one packet, request ACK, then wait for ACK
 576  */
 577 #define QIB_S_SIGNAL_REQ_WR     0x0001
 578 #define QIB_S_BUSY              0x0002
 579 #define QIB_S_TIMER             0x0004
 580 #define QIB_S_RESP_PENDING      0x0008
 581 #define QIB_S_ACK_PENDING       0x0010
 582 #define QIB_S_WAIT_FENCE        0x0020
 583 #define QIB_S_WAIT_RDMAR        0x0040
 584 #define QIB_S_WAIT_RNR          0x0080
 585 #define QIB_S_WAIT_SSN_CREDIT   0x0100
 586 #define QIB_S_WAIT_DMA          0x0200
 587 #define QIB_S_WAIT_PIO          0x0400
 588 #define QIB_S_WAIT_TX           0x0800
 589 #define QIB_S_WAIT_DMA_DESC     0x1000
 590 #define QIB_S_WAIT_KMEM         0x2000
 591 #define QIB_S_WAIT_PSN          0x4000
 592 #define QIB_S_WAIT_ACK          0x8000
 593 #define QIB_S_SEND_ONE          0x10000
 594 #define QIB_S_UNLIMITED_CREDIT  0x20000
 595
 596 /*
 597  * Wait flags that would prevent any packet type from being sent.
 598  */
 599 #define QIB_S_ANY_WAIT_IO (QIB_S_WAIT_PIO | QIB_S_WAIT_TX | \
 600         QIB_S_WAIT_DMA_DESC | QIB_S_WAIT_KMEM)
 601
 602 /*
 603  * Wait flags that would prevent send work requests from making progress.
 604  */
 605 #define QIB_S_ANY_WAIT_SEND (QIB_S_WAIT_FENCE | QIB_S_WAIT_RDMAR | \
 606         QIB_S_WAIT_RNR | QIB_S_WAIT_SSN_CREDIT | QIB_S_WAIT_DMA | \
 607         QIB_S_WAIT_PSN | QIB_S_WAIT_ACK)
 608
 609 #define QIB_S_ANY_WAIT (QIB_S_ANY_WAIT_IO | QIB_S_ANY_WAIT_SEND)
 610
 611 #define QIB_PSN_CREDIT  16
 612
 613 /*
 614  * Since struct qib_swqe is not a fixed size, we can't simply index into
 615  * struct qib_qp.s_wq.  This function does the array index computation.
 616  */
 617 static inline struct qib_swqe *get_swqe_ptr(struct qib_qp *qp,
 618                                               unsigned n)
 619 {
 620         return (struct qib_swqe *)((char *)qp->s_wq +
 621                                      (sizeof(struct qib_swqe) +
 622                                       qp->s_max_sge *
 623                                       sizeof(struct qib_sge)) * n);
 624 }
 625
 626 /*
 627  * Since struct qib_rwqe is not a fixed size, we can't simply index into
 628  * struct qib_rwq.wq.  This function does the array index computation.
 629  */
 630 static inline struct qib_rwqe *get_rwqe_ptr(struct qib_rq *rq, unsigned n)
 631 {
 632         return (struct qib_rwqe *)
 633                 ((char *) rq->wq->wq +
 634                  (sizeof(struct qib_rwqe) +
 635                   rq->max_sge * sizeof(struct ib_sge)) * n);
 636 }
 637
 638 /*
 639  * QPN-map pages start out as NULL, they get allocated upon
 640  * first use and are never deallocated. This way,
 641  * large bitmaps are not allocated unless large numbers of QPs are used.
 642  */
 643 struct qpn_map {
 644         void *page;
 645 };
 646
 647 struct qib_qpn_table {
 648         spinlock_t lock; /* protect changes in this struct */
 649         unsigned flags;         /* flags for QP0/1 allocated for each port */
 650         u32 last;               /* last QP number allocated */
 651         u32 nmaps;              /* size of the map table */
 652         u16 limit;
 653         u16 mask;
 654         /* bit map of free QP numbers other than 0/1 */
 655         struct qpn_map map[QPNMAP_ENTRIES];
 656 };
 657
 658 #define MAX_LKEY_TABLE_BITS 23
 659
 660 struct qib_lkey_table {
 661         spinlock_t lock; /* protect changes in this struct */
 662         u32 next;               /* next unused index (speeds search) */
 663         u32 gen;                /* generation count */
 664         u32 max;                /* size of the table */
 665         struct qib_mregion __rcu **table;
 666 };
 667
 668 struct qib_opcode_stats {
 669         u64 n_packets;          /* number of packets */
 670         u64 n_bytes;            /* total number of bytes */
 671 };
 672
 673 struct qib_opcode_stats_perctx {
 674         struct qib_opcode_stats stats[128];
 675 };
 676
 677 struct qib_pma_counters {
 678         u64 n_unicast_xmit;     /* total unicast packets sent */
 679         u64 n_unicast_rcv;      /* total unicast packets received */
 680         u64 n_multicast_xmit;   /* total multicast packets sent */
 681         u64 n_multicast_rcv;    /* total multicast packets received */
 682 };
 683
 684 struct qib_ibport {
 685         struct qib_qp __rcu *qp0;
 686         struct qib_qp __rcu *qp1;
 687         struct ib_mad_agent *send_agent;        /* agent for SMI (traps) */
 688         struct qib_ah *sm_ah;
 689         struct qib_ah *smi_ah;
 690         struct rb_root mcast_tree;
 691         spinlock_t lock;                /* protect changes in this struct */
 692
 693         /* non-zero when timer is set */
 694         unsigned long mkey_lease_timeout;
 695         unsigned long trap_timeout;
 696         __be64 gid_prefix;      /* in network order */
 697         __be64 mkey;
 698         __be64 guids[QIB_GUIDS_PER_PORT - 1];   /* writable GUIDs */
 699         u64 tid;                /* TID for traps */
 700         struct qib_pma_counters __percpu *pmastats;
 701         u64 z_unicast_xmit;     /* starting count for PMA */
 702         u64 z_unicast_rcv;      /* starting count for PMA */
 703         u64 z_multicast_xmit;   /* starting count for PMA */
 704         u64 z_multicast_rcv;    /* starting count for PMA */
 705         u64 z_symbol_error_counter;             /* starting count for PMA */
 706         u64 z_link_error_recovery_counter;      /* starting count for PMA */
 707         u64 z_link_downed_counter;              /* starting count for PMA */
 708         u64 z_port_rcv_errors;                  /* starting count for PMA */
 709         u64 z_port_rcv_remphys_errors;          /* starting count for PMA */
 710         u64 z_port_xmit_discards;               /* starting count for PMA */
 711         u64 z_port_xmit_data;                   /* starting count for PMA */
 712         u64 z_port_rcv_data;                    /* starting count for PMA */
 713         u64 z_port_xmit_packets;                /* starting count for PMA */
 714         u64 z_port_rcv_packets;                 /* starting count for PMA */
 715         u32 z_local_link_integrity_errors;      /* starting count for PMA */
 716         u32 z_excessive_buffer_overrun_errors;  /* starting count for PMA */
 717         u32 z_vl15_dropped;                     /* starting count for PMA */
 718         u32 n_rc_resends;
 719         u32 n_rc_acks;
 720         u32 n_rc_qacks;
 721         u32 n_rc_delayed_comp;
 722         u32 n_seq_naks;
 723         u32 n_rdma_seq;
 724         u32 n_rnr_naks;
 725         u32 n_other_naks;
 726         u32 n_loop_pkts;
 727         u32 n_pkt_drops;
 728         u32 n_vl15_dropped;
 729         u32 n_rc_timeouts;
 730         u32 n_dmawait;
 731         u32 n_unaligned;
 732         u32 n_rc_dupreq;
 733         u32 n_rc_seqnak;
 734         u32 port_cap_flags;
 735         u32 pma_sample_start;
 736         u32 pma_sample_interval;
 737         __be16 pma_counter_select[5];
 738         u16 pma_tag;
 739         u16 pkey_violations;
 740         u16 qkey_violations;
 741         u16 mkey_violations;
 742         u16 mkey_lease_period;
 743         u16 sm_lid;
 744         u16 repress_traps;
 745         u8 sm_sl;
 746         u8 mkeyprot;
 747         u8 subnet_timeout;
 748         u8 vl_high_limit;
 749         u8 sl_to_vl[16];
 750
 751 };
 752
 753
 754 struct qib_ibdev {
 755         struct ib_device ibdev;
 756         struct list_head pending_mmaps;
 757         spinlock_t mmap_offset_lock; /* protect mmap_offset */
 758         u32 mmap_offset;
 759         struct qib_mregion __rcu *dma_mr;
 760
 761         /* QP numbers are shared by all IB ports */
 762         struct qib_qpn_table qpn_table;
 763         struct qib_lkey_table lk_table;
 764         struct list_head piowait;       /* list for wait PIO buf */
 765         struct list_head dmawait;       /* list for wait DMA */
 766         struct list_head txwait;        /* list for wait qib_verbs_txreq */
 767         struct list_head memwait;       /* list for wait kernel memory */
 768         struct list_head txreq_free;
 769         struct timer_list mem_timer;
 770         struct qib_qp __rcu **qp_table;
 771         struct qib_pio_header *pio_hdrs;
 772         dma_addr_t pio_hdrs_phys;
 773         /* list of QPs waiting for RNR timer */
 774         spinlock_t pending_lock; /* protect wait lists, PMA counters, etc. */
 775         u32 qp_table_size; /* size of the hash table */
 776         u32 qp_rnd; /* random bytes for hash */
 777         spinlock_t qpt_lock;
 778
 779         u32 n_piowait;
 780         u32 n_txwait;
 781
 782         u32 n_pds_allocated;    /* number of PDs allocated for device */
 783         spinlock_t n_pds_lock;
 784         u32 n_ahs_allocated;    /* number of AHs allocated for device */
 785         spinlock_t n_ahs_lock;
 786         u32 n_cqs_allocated;    /* number of CQs allocated for device */
 787         spinlock_t n_cqs_lock;
 788         u32 n_qps_allocated;    /* number of QPs allocated for device */
 789         spinlock_t n_qps_lock;
 790         u32 n_srqs_allocated;   /* number of SRQs allocated for device */
 791         spinlock_t n_srqs_lock;
 792         u32 n_mcast_grps_allocated; /* number of mcast groups allocated */
 793         spinlock_t n_mcast_grps_lock;
 794 #ifdef CONFIG_DEBUG_FS
 795         /* per HCA debugfs */
 796         struct dentry *qib_ibdev_dbg;
 797 #endif
 798 };
 799
 800 struct qib_verbs_counters {
 801         u64 symbol_error_counter;
 802         u64 link_error_recovery_counter;
 803         u64 link_downed_counter;
 804         u64 port_rcv_errors;
 805         u64 port_rcv_remphys_errors;
 806         u64 port_xmit_discards;
 807         u64 port_xmit_data;
 808         u64 port_rcv_data;
 809         u64 port_xmit_packets;
 810         u64 port_rcv_packets;
 811         u32 local_link_integrity_errors;
 812         u32 excessive_buffer_overrun_errors;
 813         u32 vl15_dropped;
 814 };
 815
 816 static inline struct qib_mr *to_imr(struct ib_mr *ibmr)
 817 {
 818         return container_of(ibmr, struct qib_mr, ibmr);
 819 }
 820
 821 static inline struct qib_pd *to_ipd(struct ib_pd *ibpd)
 822 {
 823         return container_of(ibpd, struct qib_pd, ibpd);
 824 }
 825
 826 static inline struct qib_ah *to_iah(struct ib_ah *ibah)
 827 {
 828         return container_of(ibah, struct qib_ah, ibah);
 829 }
 830
 831 static inline struct qib_cq *to_icq(struct ib_cq *ibcq)
 832 {
 833         return container_of(ibcq, struct qib_cq, ibcq);
 834 }
 835
 836 static inline struct qib_srq *to_isrq(struct ib_srq *ibsrq)
 837 {
 838         return container_of(ibsrq, struct qib_srq, ibsrq);
 839 }
 840
 841 static inline struct qib_qp *to_iqp(struct ib_qp *ibqp)
 842 {
 843         return container_of(ibqp, struct qib_qp, ibqp);
 844 }
 845
 846 static inline struct qib_ibdev *to_idev(struct ib_device *ibdev)
 847 {
 848         return container_of(ibdev, struct qib_ibdev, ibdev);
 849 }
 850
 851 /*
 852  * Send if not busy or waiting for I/O and either
 853  * a RC response is pending or we can process send work requests.
 854  */
 855 static inline int qib_send_ok(struct qib_qp *qp)
 856 {
 857         return !(qp->s_flags & (QIB_S_BUSY | QIB_S_ANY_WAIT_IO)) &&
 858                 (qp->s_hdrwords || (qp->s_flags & QIB_S_RESP_PENDING) ||
 859                  !(qp->s_flags & QIB_S_ANY_WAIT_SEND));
 860 }
 861
 862 /*
 863  * This must be called with s_lock held.
 864  */
 865 void qib_schedule_send(struct qib_qp *qp);
 866
 867 static inline int qib_pkey_ok(u16 pkey1, u16 pkey2)
 868 {
 869         u16 p1 = pkey1 & 0x7FFF;
 870         u16 p2 = pkey2 & 0x7FFF;
 871
 872         /*
 873          * Low 15 bits must be non-zero and match, and
 874          * one of the two must be a full member.
 875          */
 876         return p1 && p1 == p2 && ((__s16)pkey1 < 0 || (__s16)pkey2 < 0);
 877 }
 878
 879 void qib_bad_pqkey(struct qib_ibport *ibp, __be16 trap_num, u32 key, u32 sl,
 880                    u32 qp1, u32 qp2, __be16 lid1, __be16 lid2);
 881 void qib_cap_mask_chg(struct qib_ibport *ibp);
 882 void qib_sys_guid_chg(struct qib_ibport *ibp);
 883 void qib_node_desc_chg(struct qib_ibport *ibp);
 884 int qib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
 885                     const struct ib_wc *in_wc, const struct ib_grh *in_grh,
 886                     const struct ib_mad_hdr *in, size_t in_mad_size,
 887                     struct ib_mad_hdr *out, size_t *out_mad_size,
 888                     u16 *out_mad_pkey_index);
 889 int qib_create_agents(struct qib_ibdev *dev);
 890 void qib_free_agents(struct qib_ibdev *dev);
 891
 892 /*
 893  * Compare the lower 24 bits of the two values.
 894  * Returns an integer <, ==, or > than zero.
 895  */
 896 static inline int qib_cmp24(u32 a, u32 b)
 897 {
 898         return (((int) a) - ((int) b)) << 8;
 899 }
 900
 901 struct qib_mcast *qib_mcast_find(struct qib_ibport *ibp, union ib_gid *mgid);
 902
 903 int qib_snapshot_counters(struct qib_pportdata *ppd, u64 *swords,
 904                           u64 *rwords, u64 *spkts, u64 *rpkts,
 905                           u64 *xmit_wait);
 906
 907 int qib_get_counters(struct qib_pportdata *ppd,
 908                      struct qib_verbs_counters *cntrs);
 909
 910 int qib_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid);
 911
 912 int qib_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid);
 913
 914 int qib_mcast_tree_empty(struct qib_ibport *ibp);
 915
 916 __be32 qib_compute_aeth(struct qib_qp *qp);
 917
 918 struct qib_qp *qib_lookup_qpn(struct qib_ibport *ibp, u32 qpn);
 919
 920 struct ib_qp *qib_create_qp(struct ib_pd *ibpd,
 921                             struct ib_qp_init_attr *init_attr,
 922                             struct ib_udata *udata);
 923
 924 int qib_destroy_qp(struct ib_qp *ibqp);
 925
 926 int qib_error_qp(struct qib_qp *qp, enum ib_wc_status err);
 927
 928 int qib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
 929                   int attr_mask, struct ib_udata *udata);
 930
 931 int qib_query_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
 932                  int attr_mask, struct ib_qp_init_attr *init_attr);
 933
 934 unsigned qib_free_all_qps(struct qib_devdata *dd);
 935
 936 void qib_init_qpn_table(struct qib_devdata *dd, struct qib_qpn_table *qpt);
 937
 938 void qib_free_qpn_table(struct qib_qpn_table *qpt);
 939
 940 #ifdef CONFIG_DEBUG_FS
 941
 942 struct qib_qp_iter;
 943
 944 struct qib_qp_iter *qib_qp_iter_init(struct qib_ibdev *dev);
 945
 946 int qib_qp_iter_next(struct qib_qp_iter *iter);
 947
 948 void qib_qp_iter_print(struct seq_file *s, struct qib_qp_iter *iter);
 949
 950 #endif
 951
 952 void qib_get_credit(struct qib_qp *qp, u32 aeth);
 953
 954 unsigned qib_pkt_delay(u32 plen, u8 snd_mult, u8 rcv_mult);
 955
 956 void qib_verbs_sdma_desc_avail(struct qib_pportdata *ppd, unsigned avail);
 957
 958 void qib_put_txreq(struct qib_verbs_txreq *tx);
 959
 960 int qib_verbs_send(struct qib_qp *qp, struct qib_ib_header *hdr,
 961                    u32 hdrwords, struct qib_sge_state *ss, u32 len);
 962
 963 void qib_copy_sge(struct qib_sge_state *ss, void *data, u32 length,
 964                   int release);
 965
 966 void qib_skip_sge(struct qib_sge_state *ss, u32 length, int release);
 967
 968 void qib_uc_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
 969                 int has_grh, void *data, u32 tlen, struct qib_qp *qp);
 970
 971 void qib_rc_rcv(struct qib_ctxtdata *rcd, struct qib_ib_header *hdr,
 972                 int has_grh, void *data, u32 tlen, struct qib_qp *qp);
 973
 974 int qib_check_ah(struct ib_device *ibdev, struct ib_ah_attr *ah_attr);
 975
 976 struct ib_ah *qib_create_qp0_ah(struct qib_ibport *ibp, u16 dlid);
 977
 978 void qib_rc_rnr_retry(unsigned long arg);
 979
 980 void qib_rc_send_complete(struct qib_qp *qp, struct qib_ib_header *hdr);
 981
 982 void qib_rc_error(struct qib_qp *qp, enum ib_wc_status err);
 983
 984 int qib_post_ud_send(struct qib_qp *qp, struct ib_send_wr *wr);
 985
 986 void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
 987                 int has_grh, void *data, u32 tlen, struct qib_qp *qp);
 988
 989 int qib_alloc_lkey(struct qib_mregion *mr, int dma_region);
 990
 991 void qib_free_lkey(struct qib_mregion *mr);
 992
 993 int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
 994                 struct qib_sge *isge, struct ib_sge *sge, int acc);
 995
 996 int qib_rkey_ok(struct qib_qp *qp, struct qib_sge *sge,
 997                 u32 len, u64 vaddr, u32 rkey, int acc);
 998
 999 int qib_post_srq_receive(struct ib_srq *ibsrq, struct ib_recv_wr *wr,
1000                          struct ib_recv_wr **bad_wr);
1001
1002 struct ib_srq *qib_create_srq(struct ib_pd *ibpd,
1003                               struct ib_srq_init_attr *srq_init_attr,
1004                               struct ib_udata *udata);
1005
1006 int qib_modify_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr,
1007                    enum ib_srq_attr_mask attr_mask,
1008                    struct ib_udata *udata);
1009
1010 int qib_query_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr);
1011
1012 int qib_destroy_srq(struct ib_srq *ibsrq);
1013
1014 int qib_cq_init(struct qib_devdata *dd);
1015
1016 void qib_cq_exit(struct qib_devdata *dd);
1017
1018 void qib_cq_enter(struct qib_cq *cq, struct ib_wc *entry, int sig);
1019
1020 int qib_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry);
1021
1022 struct ib_cq *qib_create_cq(struct ib_device *ibdev,
1023                             const struct ib_cq_init_attr *attr,
1024                             struct ib_ucontext *context,
1025                             struct ib_udata *udata);
1026
1027 int qib_destroy_cq(struct ib_cq *ibcq);
1028
1029 int qib_req_notify_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags notify_flags);
1030
1031 int qib_resize_cq(struct ib_cq *ibcq, int cqe, struct ib_udata *udata);
1032
1033 struct ib_mr *qib_get_dma_mr(struct ib_pd *pd, int acc);
1034
1035 struct ib_mr *qib_reg_phys_mr(struct ib_pd *pd,
1036                               struct ib_phys_buf *buffer_list,
1037                               int num_phys_buf, int acc, u64 *iova_start);
1038
1039 struct ib_mr *qib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
1040                               u64 virt_addr, int mr_access_flags,
1041                               struct ib_udata *udata);
1042
1043 int qib_dereg_mr(struct ib_mr *ibmr);
1044
1045 struct ib_mr *qib_alloc_mr(struct ib_pd *pd,
1046                            enum ib_mr_type mr_type,
1047                            u32 max_entries);
1048
1049 int qib_map_mr_sg(struct ib_mr *ibmr,
1050                   struct scatterlist *sg,
1051                   int sg_nents);
1052
1053 int qib_reg_mr(struct qib_qp *qp, struct ib_reg_wr *wr);
1054
1055 struct ib_fmr *qib_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
1056                              struct ib_fmr_attr *fmr_attr);
1057
1058 int qib_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
1059                      int list_len, u64 iova);
1060
1061 int qib_unmap_fmr(struct list_head *fmr_list);
1062
1063 int qib_dealloc_fmr(struct ib_fmr *ibfmr);
1064
1065 static inline void qib_get_mr(struct qib_mregion *mr)
1066 {
1067         atomic_inc(&mr->refcount);
1068 }
1069
1070 void mr_rcu_callback(struct rcu_head *list);
1071
1072 static inline void qib_put_mr(struct qib_mregion *mr)
1073 {
1074         if (unlikely(atomic_dec_and_test(&mr->refcount)))
1075                 call_rcu(&mr->list, mr_rcu_callback);
1076 }
1077
1078 static inline void qib_put_ss(struct qib_sge_state *ss)
1079 {
1080         while (ss->num_sge) {
1081                 qib_put_mr(ss->sge.mr);
1082                 if (--ss->num_sge)
1083                         ss->sge = *ss->sg_list++;
1084         }
1085 }
1086
1087
1088 void qib_release_mmap_info(struct kref *ref);
1089
1090 struct qib_mmap_info *qib_create_mmap_info(struct qib_ibdev *dev, u32 size,
1091                                            struct ib_ucontext *context,
1092                                            void *obj);
1093
1094 void qib_update_mmap_info(struct qib_ibdev *dev, struct qib_mmap_info *ip,
1095                           u32 size, void *obj);
1096
1097 int qib_mmap(struct ib_ucontext *context, struct vm_area_struct *vma);
1098
1099 int qib_get_rwqe(struct qib_qp *qp, int wr_id_only);
1100
1101 void qib_migrate_qp(struct qib_qp *qp);
1102
1103 int qib_ruc_check_hdr(struct qib_ibport *ibp, struct qib_ib_header *hdr,
1104                       int has_grh, struct qib_qp *qp, u32 bth0);
1105
1106 u32 qib_make_grh(struct qib_ibport *ibp, struct ib_grh *hdr,
1107                  struct ib_global_route *grh, u32 hwords, u32 nwords);
1108
1109 void qib_make_ruc_header(struct qib_qp *qp, struct qib_other_headers *ohdr,
1110                          u32 bth0, u32 bth2);
1111
1112 void qib_do_send(struct work_struct *work);
1113
1114 void qib_send_complete(struct qib_qp *qp, struct qib_swqe *wqe,
1115                        enum ib_wc_status status);
1116
1117 void qib_send_rc_ack(struct qib_qp *qp);
1118
1119 int qib_make_rc_req(struct qib_qp *qp);
1120
1121 int qib_make_uc_req(struct qib_qp *qp);
1122
1123 int qib_make_ud_req(struct qib_qp *qp);
1124
1125 int qib_register_ib_device(struct qib_devdata *);
1126
1127 void qib_unregister_ib_device(struct qib_devdata *);
1128
1129 void qib_ib_rcv(struct qib_ctxtdata *, void *, void *, u32);
1130
1131 void qib_ib_piobufavail(struct qib_devdata *);
1132
1133 unsigned qib_get_npkeys(struct qib_devdata *);
1134
1135 unsigned qib_get_pkey(struct qib_ibport *, unsigned);
1136
1137 extern const enum ib_wc_opcode ib_qib_wc_opcode[];
1138
1139 /*
1140  * Below  HCA-independent IB PhysPortState values, returned
1141  * by the f_ibphys_portstate() routine.
1142  */
1143 #define IB_PHYSPORTSTATE_SLEEP 1
1144 #define IB_PHYSPORTSTATE_POLL 2
1145 #define IB_PHYSPORTSTATE_DISABLED 3
1146 #define IB_PHYSPORTSTATE_CFG_TRAIN 4
1147 #define IB_PHYSPORTSTATE_LINKUP 5
1148 #define IB_PHYSPORTSTATE_LINK_ERR_RECOVER 6
1149 #define IB_PHYSPORTSTATE_CFG_DEBOUNCE 8
1150 #define IB_PHYSPORTSTATE_CFG_IDLE 0xB
1151 #define IB_PHYSPORTSTATE_RECOVERY_RETRAIN 0xC
1152 #define IB_PHYSPORTSTATE_RECOVERY_WAITRMT 0xE
1153 #define IB_PHYSPORTSTATE_RECOVERY_IDLE 0xF
1154 #define IB_PHYSPORTSTATE_CFG_ENH 0x10
1155 #define IB_PHYSPORTSTATE_CFG_WAIT_ENH 0x13
1156
1157 extern const int ib_qib_state_ops[];
1158
1159 extern __be64 ib_qib_sys_image_guid;    /* in network order */
1160
1161 extern unsigned int ib_qib_lkey_table_size;
1162
1163 extern unsigned int ib_qib_max_cqes;
1164
1165 extern unsigned int ib_qib_max_cqs;
1166
1167 extern unsigned int ib_qib_max_qp_wrs;
1168
1169 extern unsigned int ib_qib_max_qps;
1170
1171 extern unsigned int ib_qib_max_sges;
1172
1173 extern unsigned int ib_qib_max_mcast_grps;
1174
1175 extern unsigned int ib_qib_max_mcast_qp_attached;
1176
1177 extern unsigned int ib_qib_max_srqs;
1178
1179 extern unsigned int ib_qib_max_srq_sges;
1180
1181 extern unsigned int ib_qib_max_srq_wrs;
1182
1183 extern const u32 ib_qib_rnr_table[];
1184
1185 extern struct ib_dma_mapping_ops qib_dma_mapping_ops;
1186
1187 #endif                          /* QIB_VERBS_H */