698396778f001ed8a6d0666ab8a30c12c451d813
[linux-3.10.git] / drivers / infiniband / hw / ipath / ipath_verbs.h
1 /*
2  * Copyright (c) 2006 QLogic, Inc. All rights reserved.
3  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *        copyright notice, this list of conditions and the following
17  *        disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer in the documentation and/or other materials
22  *        provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33
34 #ifndef IPATH_VERBS_H
35 #define IPATH_VERBS_H
36
37 #include <linux/types.h>
38 #include <linux/spinlock.h>
39 #include <linux/kernel.h>
40 #include <linux/interrupt.h>
41 #include <rdma/ib_pack.h>
42
43 #include "ipath_layer.h"
44 #include "verbs_debug.h"
45
46 #define QPN_MAX                 (1 << 24)
47 #define QPNMAP_ENTRIES          (QPN_MAX / PAGE_SIZE / BITS_PER_BYTE)
48
49 /*
50  * Increment this value if any changes that break userspace ABI
51  * compatibility are made.
52  */
53 #define IPATH_UVERBS_ABI_VERSION       1
54
55 /*
56  * Define an ib_cq_notify value that is not valid so we know when CQ
57  * notifications are armed.
58  */
59 #define IB_CQ_NONE      (IB_CQ_NEXT_COMP + 1)
60
61 #define IB_RNR_NAK                      0x20
62 #define IB_NAK_PSN_ERROR                0x60
63 #define IB_NAK_INVALID_REQUEST          0x61
64 #define IB_NAK_REMOTE_ACCESS_ERROR      0x62
65 #define IB_NAK_REMOTE_OPERATIONAL_ERROR 0x63
66 #define IB_NAK_INVALID_RD_REQUEST       0x64
67
68 #define IPATH_POST_SEND_OK              0x01
69 #define IPATH_POST_RECV_OK              0x02
70 #define IPATH_PROCESS_RECV_OK           0x04
71 #define IPATH_PROCESS_SEND_OK           0x08
72
73 /* IB Performance Manager status values */
74 #define IB_PMA_SAMPLE_STATUS_DONE       0x00
75 #define IB_PMA_SAMPLE_STATUS_STARTED    0x01
76 #define IB_PMA_SAMPLE_STATUS_RUNNING    0x02
77
78 /* Mandatory IB performance counter select values. */
79 #define IB_PMA_PORT_XMIT_DATA   __constant_htons(0x0001)
80 #define IB_PMA_PORT_RCV_DATA    __constant_htons(0x0002)
81 #define IB_PMA_PORT_XMIT_PKTS   __constant_htons(0x0003)
82 #define IB_PMA_PORT_RCV_PKTS    __constant_htons(0x0004)
83 #define IB_PMA_PORT_XMIT_WAIT   __constant_htons(0x0005)
84
85 struct ib_reth {
86         __be64 vaddr;
87         __be32 rkey;
88         __be32 length;
89 } __attribute__ ((packed));
90
91 struct ib_atomic_eth {
92         __be64 vaddr;
93         __be32 rkey;
94         __be64 swap_data;
95         __be64 compare_data;
96 } __attribute__ ((packed));
97
98 struct ipath_other_headers {
99         __be32 bth[3];
100         union {
101                 struct {
102                         __be32 deth[2];
103                         __be32 imm_data;
104                 } ud;
105                 struct {
106                         struct ib_reth reth;
107                         __be32 imm_data;
108                 } rc;
109                 struct {
110                         __be32 aeth;
111                         __be64 atomic_ack_eth;
112                 } at;
113                 __be32 imm_data;
114                 __be32 aeth;
115                 struct ib_atomic_eth atomic_eth;
116         } u;
117 } __attribute__ ((packed));
118
119 /*
120  * Note that UD packets with a GRH header are 8+40+12+8 = 68 bytes
121  * long (72 w/ imm_data).  Only the first 56 bytes of the IB header
122  * will be in the eager header buffer.  The remaining 12 or 16 bytes
123  * are in the data buffer.
124  */
125 struct ipath_ib_header {
126         __be16 lrh[4];
127         union {
128                 struct {
129                         struct ib_grh grh;
130                         struct ipath_other_headers oth;
131                 } l;
132                 struct ipath_other_headers oth;
133         } u;
134 } __attribute__ ((packed));
135
136 /*
137  * There is one struct ipath_mcast for each multicast GID.
138  * All attached QPs are then stored as a list of
139  * struct ipath_mcast_qp.
140  */
141 struct ipath_mcast_qp {
142         struct list_head list;
143         struct ipath_qp *qp;
144 };
145
146 struct ipath_mcast {
147         struct rb_node rb_node;
148         union ib_gid mgid;
149         struct list_head qp_list;
150         wait_queue_head_t wait;
151         atomic_t refcount;
152         int n_attached;
153 };
154
155 /* Memory region */
156 struct ipath_mr {
157         struct ib_mr ibmr;
158         struct ipath_mregion mr;        /* must be last */
159 };
160
161 /* Fast memory region */
162 struct ipath_fmr {
163         struct ib_fmr ibfmr;
164         u8 page_shift;
165         struct ipath_mregion mr;        /* must be last */
166 };
167
168 /* Protection domain */
169 struct ipath_pd {
170         struct ib_pd ibpd;
171         int user;               /* non-zero if created from user space */
172 };
173
174 /* Address Handle */
175 struct ipath_ah {
176         struct ib_ah ibah;
177         struct ib_ah_attr attr;
178 };
179
180 /*
181  * Quick description of our CQ/QP locking scheme:
182  *
183  * We have one global lock that protects dev->cq/qp_table.  Each
184  * struct ipath_cq/qp also has its own lock.  An individual qp lock
185  * may be taken inside of an individual cq lock.  Both cqs attached to
186  * a qp may be locked, with the send cq locked first.  No other
187  * nesting should be done.
188  *
189  * Each struct ipath_cq/qp also has an atomic_t ref count.  The
190  * pointer from the cq/qp_table to the struct counts as one reference.
191  * This reference also is good for access through the consumer API, so
192  * modifying the CQ/QP etc doesn't need to take another reference.
193  * Access because of a completion being polled does need a reference.
194  *
195  * Finally, each struct ipath_cq/qp has a wait_queue_head_t for the
196  * destroy function to sleep on.
197  *
198  * This means that access from the consumer API requires nothing but
199  * taking the struct's lock.
200  *
201  * Access because of a completion event should go as follows:
202  * - lock cq/qp_table and look up struct
203  * - increment ref count in struct
204  * - drop cq/qp_table lock
205  * - lock struct, do your thing, and unlock struct
206  * - decrement ref count; if zero, wake up waiters
207  *
208  * To destroy a CQ/QP, we can do the following:
209  * - lock cq/qp_table, remove pointer, unlock cq/qp_table lock
210  * - decrement ref count
211  * - wait_event until ref count is zero
212  *
213  * It is the consumer's responsibilty to make sure that no QP
214  * operations (WQE posting or state modification) are pending when the
215  * QP is destroyed.  Also, the consumer must make sure that calls to
216  * qp_modify are serialized.
217  *
218  * Possible optimizations (wait for profile data to see if/where we
219  * have locks bouncing between CPUs):
220  * - split cq/qp table lock into n separate (cache-aligned) locks,
221  *   indexed (say) by the page in the table
222  */
223
224 struct ipath_cq {
225         struct ib_cq ibcq;
226         struct tasklet_struct comptask;
227         spinlock_t lock;
228         u8 notify;
229         u8 triggered;
230         u32 head;               /* new records added to the head */
231         u32 tail;               /* poll_cq() reads from here. */
232         struct ib_wc *queue;    /* this is actually ibcq.cqe + 1 */
233 };
234
235 /*
236  * Send work request queue entry.
237  * The size of the sg_list is determined when the QP is created and stored
238  * in qp->s_max_sge.
239  */
240 struct ipath_swqe {
241         struct ib_send_wr wr;   /* don't use wr.sg_list */
242         u32 psn;                /* first packet sequence number */
243         u32 lpsn;               /* last packet sequence number */
244         u32 ssn;                /* send sequence number */
245         u32 length;             /* total length of data in sg_list */
246         struct ipath_sge sg_list[0];
247 };
248
249 /*
250  * Receive work request queue entry.
251  * The size of the sg_list is determined when the QP is created and stored
252  * in qp->r_max_sge.
253  */
254 struct ipath_rwqe {
255         u64 wr_id;
256         u32 length;             /* total length of data in sg_list */
257         u8 num_sge;
258         struct ipath_sge sg_list[0];
259 };
260
261 struct ipath_rq {
262         spinlock_t lock;
263         u32 head;               /* new work requests posted to the head */
264         u32 tail;               /* receives pull requests from here. */
265         u32 size;               /* size of RWQE array */
266         u8 max_sge;
267         struct ipath_rwqe *wq;  /* RWQE array */
268 };
269
270 struct ipath_srq {
271         struct ib_srq ibsrq;
272         struct ipath_rq rq;
273         /* send signal when number of RWQEs < limit */
274         u32 limit;
275 };
276
277 /*
278  * Variables prefixed with s_ are for the requester (sender).
279  * Variables prefixed with r_ are for the responder (receiver).
280  * Variables prefixed with ack_ are for responder replies.
281  *
282  * Common variables are protected by both r_rq.lock and s_lock in that order
283  * which only happens in modify_qp() or changing the QP 'state'.
284  */
285 struct ipath_qp {
286         struct ib_qp ibqp;
287         struct ipath_qp *next;          /* link list for QPN hash table */
288         struct ipath_qp *timer_next;    /* link list for ipath_ib_timer() */
289         struct list_head piowait;       /* link for wait PIO buf */
290         struct list_head timerwait;     /* link for waiting for timeouts */
291         struct ib_ah_attr remote_ah_attr;
292         struct ipath_ib_header s_hdr;   /* next packet header to send */
293         atomic_t refcount;
294         wait_queue_head_t wait;
295         struct tasklet_struct s_task;
296         struct ipath_sge_state *s_cur_sge;
297         struct ipath_sge_state s_sge;   /* current send request data */
298         /* current RDMA read send data */
299         struct ipath_sge_state s_rdma_sge;
300         struct ipath_sge_state r_sge;   /* current receive data */
301         spinlock_t s_lock;
302         unsigned long s_flags;
303         u32 s_hdrwords;         /* size of s_hdr in 32 bit words */
304         u32 s_cur_size;         /* size of send packet in bytes */
305         u32 s_len;              /* total length of s_sge */
306         u32 s_rdma_len;         /* total length of s_rdma_sge */
307         u32 s_next_psn;         /* PSN for next request */
308         u32 s_last_psn;         /* last response PSN processed */
309         u32 s_psn;              /* current packet sequence number */
310         u32 s_ack_psn;          /* PSN for RDMA_READ */
311         u32 s_rnr_timeout;      /* number of milliseconds for RNR timeout */
312         u32 r_ack_psn;          /* PSN for next ACK or atomic ACK */
313         u64 r_wr_id;            /* ID for current receive WQE */
314         u64 r_atomic_data;      /* data for last atomic op */
315         u32 r_atomic_psn;       /* PSN of last atomic op */
316         u32 r_len;              /* total length of r_sge */
317         u32 r_rcv_len;          /* receive data len processed */
318         u32 r_psn;              /* expected rcv packet sequence number */
319         u32 r_msn;              /* message sequence number */
320         u8 state;               /* QP state */
321         u8 s_state;             /* opcode of last packet sent */
322         u8 s_ack_state;         /* opcode of packet to ACK */
323         u8 s_nak_state;         /* non-zero if NAK is pending */
324         u8 r_state;             /* opcode of last packet received */
325         u8 r_ack_state;         /* opcode of packet to ACK */
326         u8 r_nak_state;         /* non-zero if NAK is pending */
327         u8 r_min_rnr_timer;     /* retry timeout value for RNR NAKs */
328         u8 r_reuse_sge;         /* for UC receive errors */
329         u8 r_sge_inx;           /* current index into sg_list */
330         u8 qp_access_flags;
331         u8 s_max_sge;           /* size of s_wq->sg_list */
332         u8 s_retry_cnt;         /* number of times to retry */
333         u8 s_rnr_retry_cnt;
334         u8 s_retry;             /* requester retry counter */
335         u8 s_rnr_retry;         /* requester RNR retry counter */
336         u8 s_pkey_index;        /* PKEY index to use */
337         enum ib_mtu path_mtu;
338         u32 remote_qpn;
339         u32 qkey;               /* QKEY for this QP (for UD or RD) */
340         u32 s_size;             /* send work queue size */
341         u32 s_head;             /* new entries added here */
342         u32 s_tail;             /* next entry to process */
343         u32 s_cur;              /* current work queue entry */
344         u32 s_last;             /* last un-ACK'ed entry */
345         u32 s_ssn;              /* SSN of tail entry */
346         u32 s_lsn;              /* limit sequence number (credit) */
347         struct ipath_swqe *s_wq;        /* send work queue */
348         struct ipath_rq r_rq;   /* receive work queue */
349 };
350
351 /*
352  * Bit definitions for s_flags.
353  */
354 #define IPATH_S_BUSY            0
355 #define IPATH_S_SIGNAL_REQ_WR   1
356
357 /*
358  * Since struct ipath_swqe is not a fixed size, we can't simply index into
359  * struct ipath_qp.s_wq.  This function does the array index computation.
360  */
361 static inline struct ipath_swqe *get_swqe_ptr(struct ipath_qp *qp,
362                                               unsigned n)
363 {
364         return (struct ipath_swqe *)((char *)qp->s_wq +
365                                      (sizeof(struct ipath_swqe) +
366                                       qp->s_max_sge *
367                                       sizeof(struct ipath_sge)) * n);
368 }
369
370 /*
371  * Since struct ipath_rwqe is not a fixed size, we can't simply index into
372  * struct ipath_rq.wq.  This function does the array index computation.
373  */
374 static inline struct ipath_rwqe *get_rwqe_ptr(struct ipath_rq *rq,
375                                               unsigned n)
376 {
377         return (struct ipath_rwqe *)
378                 ((char *) rq->wq +
379                  (sizeof(struct ipath_rwqe) +
380                   rq->max_sge * sizeof(struct ipath_sge)) * n);
381 }
382
383 /*
384  * QPN-map pages start out as NULL, they get allocated upon
385  * first use and are never deallocated. This way,
386  * large bitmaps are not allocated unless large numbers of QPs are used.
387  */
388 struct qpn_map {
389         atomic_t n_free;
390         void *page;
391 };
392
393 struct ipath_qp_table {
394         spinlock_t lock;
395         u32 last;               /* last QP number allocated */
396         u32 max;                /* size of the hash table */
397         u32 nmaps;              /* size of the map table */
398         struct ipath_qp **table;
399         /* bit map of free numbers */
400         struct qpn_map map[QPNMAP_ENTRIES];
401 };
402
403 struct ipath_lkey_table {
404         spinlock_t lock;
405         u32 next;               /* next unused index (speeds search) */
406         u32 gen;                /* generation count */
407         u32 max;                /* size of the table */
408         struct ipath_mregion **table;
409 };
410
411 struct ipath_opcode_stats {
412         u64 n_packets;          /* number of packets */
413         u64 n_bytes;            /* total number of bytes */
414 };
415
416 struct ipath_ibdev {
417         struct ib_device ibdev;
418         struct list_head dev_list;
419         struct ipath_devdata *dd;
420         int ib_unit;            /* This is the device number */
421         u16 sm_lid;             /* in host order */
422         u8 sm_sl;
423         u8 mkeyprot_resv_lmc;
424         /* non-zero when timer is set */
425         unsigned long mkey_lease_timeout;
426
427         /* The following fields are really per port. */
428         struct ipath_qp_table qp_table;
429         struct ipath_lkey_table lk_table;
430         struct list_head pending[3];    /* FIFO of QPs waiting for ACKs */
431         struct list_head piowait;       /* list for wait PIO buf */
432         /* list of QPs waiting for RNR timer */
433         struct list_head rnrwait;
434         spinlock_t pending_lock;
435         __be64 sys_image_guid;  /* in network order */
436         __be64 gid_prefix;      /* in network order */
437         __be64 mkey;
438         u32 n_pds_allocated;    /* number of PDs allocated for device */
439         u32 n_ahs_allocated;    /* number of AHs allocated for device */
440         u32 n_cqs_allocated;    /* number of CQs allocated for device */
441         u32 n_srqs_allocated;   /* number of SRQs allocated for device */
442         u32 n_mcast_grps_allocated; /* number of mcast groups allocated */
443         u64 ipath_sword;        /* total dwords sent (sample result) */
444         u64 ipath_rword;        /* total dwords received (sample result) */
445         u64 ipath_spkts;        /* total packets sent (sample result) */
446         u64 ipath_rpkts;        /* total packets received (sample result) */
447         /* # of ticks no data sent (sample result) */
448         u64 ipath_xmit_wait;
449         u64 rcv_errors;         /* # of packets with SW detected rcv errs */
450         u64 n_unicast_xmit;     /* total unicast packets sent */
451         u64 n_unicast_rcv;      /* total unicast packets received */
452         u64 n_multicast_xmit;   /* total multicast packets sent */
453         u64 n_multicast_rcv;    /* total multicast packets received */
454         u64 z_symbol_error_counter;             /* starting count for PMA */
455         u64 z_link_error_recovery_counter;      /* starting count for PMA */
456         u64 z_link_downed_counter;              /* starting count for PMA */
457         u64 z_port_rcv_errors;                  /* starting count for PMA */
458         u64 z_port_rcv_remphys_errors;          /* starting count for PMA */
459         u64 z_port_xmit_discards;               /* starting count for PMA */
460         u64 z_port_xmit_data;                   /* starting count for PMA */
461         u64 z_port_rcv_data;                    /* starting count for PMA */
462         u64 z_port_xmit_packets;                /* starting count for PMA */
463         u64 z_port_rcv_packets;                 /* starting count for PMA */
464         u32 z_pkey_violations;                  /* starting count for PMA */
465         u32 z_local_link_integrity_errors;      /* starting count for PMA */
466         u32 z_excessive_buffer_overrun_errors;  /* starting count for PMA */
467         u32 n_rc_resends;
468         u32 n_rc_acks;
469         u32 n_rc_qacks;
470         u32 n_seq_naks;
471         u32 n_rdma_seq;
472         u32 n_rnr_naks;
473         u32 n_other_naks;
474         u32 n_timeouts;
475         u32 n_pkt_drops;
476         u32 n_vl15_dropped;
477         u32 n_wqe_errs;
478         u32 n_rdma_dup_busy;
479         u32 n_piowait;
480         u32 n_no_piobuf;
481         u32 port_cap_flags;
482         u32 pma_sample_start;
483         u32 pma_sample_interval;
484         __be16 pma_counter_select[5];
485         u16 pma_tag;
486         u16 qkey_violations;
487         u16 mkey_violations;
488         u16 mkey_lease_period;
489         u16 pending_index;      /* which pending queue is active */
490         u8 pma_sample_status;
491         u8 subnet_timeout;
492         u8 link_width_enabled;
493         u8 vl_high_limit;
494         struct ipath_opcode_stats opstats[128];
495 };
496
497 struct ipath_ucontext {
498         struct ib_ucontext ibucontext;
499 };
500
501 static inline struct ipath_mr *to_imr(struct ib_mr *ibmr)
502 {
503         return container_of(ibmr, struct ipath_mr, ibmr);
504 }
505
506 static inline struct ipath_fmr *to_ifmr(struct ib_fmr *ibfmr)
507 {
508         return container_of(ibfmr, struct ipath_fmr, ibfmr);
509 }
510
511 static inline struct ipath_pd *to_ipd(struct ib_pd *ibpd)
512 {
513         return container_of(ibpd, struct ipath_pd, ibpd);
514 }
515
516 static inline struct ipath_ah *to_iah(struct ib_ah *ibah)
517 {
518         return container_of(ibah, struct ipath_ah, ibah);
519 }
520
521 static inline struct ipath_cq *to_icq(struct ib_cq *ibcq)
522 {
523         return container_of(ibcq, struct ipath_cq, ibcq);
524 }
525
526 static inline struct ipath_srq *to_isrq(struct ib_srq *ibsrq)
527 {
528         return container_of(ibsrq, struct ipath_srq, ibsrq);
529 }
530
531 static inline struct ipath_qp *to_iqp(struct ib_qp *ibqp)
532 {
533         return container_of(ibqp, struct ipath_qp, ibqp);
534 }
535
536 static inline struct ipath_ibdev *to_idev(struct ib_device *ibdev)
537 {
538         return container_of(ibdev, struct ipath_ibdev, ibdev);
539 }
540
541 int ipath_process_mad(struct ib_device *ibdev,
542                       int mad_flags,
543                       u8 port_num,
544                       struct ib_wc *in_wc,
545                       struct ib_grh *in_grh,
546                       struct ib_mad *in_mad, struct ib_mad *out_mad);
547
548 static inline struct ipath_ucontext *to_iucontext(struct ib_ucontext
549                                                   *ibucontext)
550 {
551         return container_of(ibucontext, struct ipath_ucontext, ibucontext);
552 }
553
554 /*
555  * Compare the lower 24 bits of the two values.
556  * Returns an integer <, ==, or > than zero.
557  */
558 static inline int ipath_cmp24(u32 a, u32 b)
559 {
560         return (((int) a) - ((int) b)) << 8;
561 }
562
563 struct ipath_mcast *ipath_mcast_find(union ib_gid *mgid);
564
565 int ipath_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid);
566
567 int ipath_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid);
568
569 int ipath_mcast_tree_empty(void);
570
571 __be32 ipath_compute_aeth(struct ipath_qp *qp);
572
573 struct ipath_qp *ipath_lookup_qpn(struct ipath_qp_table *qpt, u32 qpn);
574
575 struct ib_qp *ipath_create_qp(struct ib_pd *ibpd,
576                               struct ib_qp_init_attr *init_attr,
577                               struct ib_udata *udata);
578
579 int ipath_destroy_qp(struct ib_qp *ibqp);
580
581 int ipath_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
582                     int attr_mask, struct ib_udata *udata);
583
584 int ipath_query_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
585                    int attr_mask, struct ib_qp_init_attr *init_attr);
586
587 void ipath_free_all_qps(struct ipath_qp_table *qpt);
588
589 int ipath_init_qp_table(struct ipath_ibdev *idev, int size);
590
591 void ipath_sqerror_qp(struct ipath_qp *qp, struct ib_wc *wc);
592
593 void ipath_get_credit(struct ipath_qp *qp, u32 aeth);
594
595 void ipath_cq_enter(struct ipath_cq *cq, struct ib_wc *entry, int sig);
596
597 int ipath_rkey_ok(struct ipath_ibdev *dev, struct ipath_sge_state *ss,
598                   u32 len, u64 vaddr, u32 rkey, int acc);
599
600 int ipath_lkey_ok(struct ipath_lkey_table *rkt, struct ipath_sge *isge,
601                   struct ib_sge *sge, int acc);
602
603 void ipath_copy_sge(struct ipath_sge_state *ss, void *data, u32 length);
604
605 void ipath_skip_sge(struct ipath_sge_state *ss, u32 length);
606
607 int ipath_post_ruc_send(struct ipath_qp *qp, struct ib_send_wr *wr);
608
609 void ipath_uc_rcv(struct ipath_ibdev *dev, struct ipath_ib_header *hdr,
610                   int has_grh, void *data, u32 tlen, struct ipath_qp *qp);
611
612 void ipath_rc_rcv(struct ipath_ibdev *dev, struct ipath_ib_header *hdr,
613                   int has_grh, void *data, u32 tlen, struct ipath_qp *qp);
614
615 void ipath_restart_rc(struct ipath_qp *qp, u32 psn, struct ib_wc *wc);
616
617 int ipath_post_ud_send(struct ipath_qp *qp, struct ib_send_wr *wr);
618
619 void ipath_ud_rcv(struct ipath_ibdev *dev, struct ipath_ib_header *hdr,
620                   int has_grh, void *data, u32 tlen, struct ipath_qp *qp);
621
622 int ipath_alloc_lkey(struct ipath_lkey_table *rkt,
623                      struct ipath_mregion *mr);
624
625 void ipath_free_lkey(struct ipath_lkey_table *rkt, u32 lkey);
626
627 int ipath_lkey_ok(struct ipath_lkey_table *rkt, struct ipath_sge *isge,
628                   struct ib_sge *sge, int acc);
629
630 int ipath_rkey_ok(struct ipath_ibdev *dev, struct ipath_sge_state *ss,
631                   u32 len, u64 vaddr, u32 rkey, int acc);
632
633 int ipath_post_srq_receive(struct ib_srq *ibsrq, struct ib_recv_wr *wr,
634                            struct ib_recv_wr **bad_wr);
635
636 struct ib_srq *ipath_create_srq(struct ib_pd *ibpd,
637                                 struct ib_srq_init_attr *srq_init_attr,
638                                 struct ib_udata *udata);
639
640 int ipath_modify_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr,
641                      enum ib_srq_attr_mask attr_mask,
642                      struct ib_udata *udata);
643
644 int ipath_query_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr);
645
646 int ipath_destroy_srq(struct ib_srq *ibsrq);
647
648 void ipath_cq_enter(struct ipath_cq *cq, struct ib_wc *entry, int sig);
649
650 int ipath_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry);
651
652 struct ib_cq *ipath_create_cq(struct ib_device *ibdev, int entries,
653                               struct ib_ucontext *context,
654                               struct ib_udata *udata);
655
656 int ipath_destroy_cq(struct ib_cq *ibcq);
657
658 int ipath_req_notify_cq(struct ib_cq *ibcq, enum ib_cq_notify notify);
659
660 int ipath_resize_cq(struct ib_cq *ibcq, int cqe, struct ib_udata *udata);
661
662 struct ib_mr *ipath_get_dma_mr(struct ib_pd *pd, int acc);
663
664 struct ib_mr *ipath_reg_phys_mr(struct ib_pd *pd,
665                                 struct ib_phys_buf *buffer_list,
666                                 int num_phys_buf, int acc, u64 *iova_start);
667
668 struct ib_mr *ipath_reg_user_mr(struct ib_pd *pd, struct ib_umem *region,
669                                 int mr_access_flags,
670                                 struct ib_udata *udata);
671
672 int ipath_dereg_mr(struct ib_mr *ibmr);
673
674 struct ib_fmr *ipath_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
675                                struct ib_fmr_attr *fmr_attr);
676
677 int ipath_map_phys_fmr(struct ib_fmr *ibfmr, u64 * page_list,
678                        int list_len, u64 iova);
679
680 int ipath_unmap_fmr(struct list_head *fmr_list);
681
682 int ipath_dealloc_fmr(struct ib_fmr *ibfmr);
683
684 void ipath_no_bufs_available(struct ipath_qp *qp, struct ipath_ibdev *dev);
685
686 void ipath_insert_rnr_queue(struct ipath_qp *qp);
687
688 int ipath_get_rwqe(struct ipath_qp *qp, int wr_id_only);
689
690 u32 ipath_make_grh(struct ipath_ibdev *dev, struct ib_grh *hdr,
691                    struct ib_global_route *grh, u32 hwords, u32 nwords);
692
693 void ipath_do_ruc_send(unsigned long data);
694
695 u32 ipath_make_rc_ack(struct ipath_qp *qp, struct ipath_other_headers *ohdr,
696                       u32 pmtu);
697
698 int ipath_make_rc_req(struct ipath_qp *qp, struct ipath_other_headers *ohdr,
699                       u32 pmtu, u32 *bth0p, u32 *bth2p);
700
701 int ipath_make_uc_req(struct ipath_qp *qp, struct ipath_other_headers *ohdr,
702                       u32 pmtu, u32 *bth0p, u32 *bth2p);
703
704 extern const enum ib_wc_opcode ib_ipath_wc_opcode[];
705
706 extern const u8 ipath_cvt_physportstate[];
707
708 extern const int ib_ipath_state_ops[];
709
710 extern unsigned int ib_ipath_lkey_table_size;
711
712 extern unsigned int ib_ipath_max_cqes;
713
714 extern unsigned int ib_ipath_max_cqs;
715
716 extern unsigned int ib_ipath_max_qp_wrs;
717
718 extern unsigned int ib_ipath_max_sges;
719
720 extern unsigned int ib_ipath_max_mcast_grps;
721
722 extern unsigned int ib_ipath_max_mcast_qp_attached;
723
724 extern unsigned int ib_ipath_max_srqs;
725
726 extern unsigned int ib_ipath_max_srq_sges;
727
728 extern unsigned int ib_ipath_max_srq_wrs;
729
730 extern const u32 ib_ipath_rnr_table[];
731
732 #endif                          /* IPATH_VERBS_H */