2 * Copyright (c) 2004 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005, 2006 Cisco Systems. All rights reserved.
4 * Copyright (c) 2005 Mellanox Technologies. All rights reserved.
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:
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
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.
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
35 #ifndef MTHCA_PROVIDER_H
36 #define MTHCA_PROVIDER_H
38 #include <rdma/ib_verbs.h>
39 #include <rdma/ib_pack.h>
41 #define MTHCA_MPT_FLAG_ATOMIC (1 << 14)
42 #define MTHCA_MPT_FLAG_REMOTE_WRITE (1 << 13)
43 #define MTHCA_MPT_FLAG_REMOTE_READ (1 << 12)
44 #define MTHCA_MPT_FLAG_LOCAL_WRITE (1 << 11)
45 #define MTHCA_MPT_FLAG_LOCAL_READ (1 << 10)
47 struct mthca_buf_list {
49 DEFINE_DMA_UNMAP_ADDR(mapping);
53 struct mthca_buf_list direct;
54 struct mthca_buf_list *page_list;
62 struct mthca_user_db_table;
64 struct mthca_ucontext {
65 struct ib_ucontext ibucontext;
67 struct mthca_user_db_table *db_tab;
76 struct mthca_mtt *mtt;
88 struct mthca_dev *dev;
96 struct mthca_buf_list *page_list;
98 char irq_name[IB_DEVICE_NAME_MAX];
111 enum mthca_ah_type type;
118 * Quick description of our CQ/QP locking scheme:
120 * We have one global lock that protects dev->cq/qp_table. Each
121 * struct mthca_cq/qp also has its own lock. An individual qp lock
122 * may be taken inside of an individual cq lock. Both cqs attached to
123 * a qp may be locked, with the cq with the lower cqn locked first.
124 * No other nesting should be done.
126 * Each struct mthca_cq/qp also has an ref count, protected by the
127 * corresponding table lock. The pointer from the cq/qp_table to the
128 * struct counts as one reference. This reference also is good for
129 * access through the consumer API, so modifying the CQ/QP etc doesn't
130 * need to take another reference. Access to a QP because of a
131 * completion being polled does not need a reference either.
133 * Finally, each struct mthca_cq/qp has a wait_queue_head_t for the
134 * destroy function to sleep on.
136 * This means that access from the consumer API requires nothing but
137 * taking the struct's lock.
139 * Access because of a completion event should go as follows:
140 * - lock cq/qp_table and look up struct
141 * - increment ref count in struct
142 * - drop cq/qp_table lock
143 * - lock struct, do your thing, and unlock struct
144 * - decrement ref count; if zero, wake up waiters
146 * To destroy a CQ/QP, we can do the following:
148 * - remove pointer and decrement ref count
149 * - unlock cq/qp_table lock
150 * - wait_event until ref count is zero
152 * It is the consumer's responsibilty to make sure that no QP
153 * operations (WQE posting or state modification) are pending when a
154 * QP is destroyed. Also, the consumer must make sure that calls to
155 * qp_modify are serialized. Similarly, the consumer is responsible
156 * for ensuring that no CQ resize operations are pending when a CQ
159 * Possible optimizations (wait for profile data to see if/where we
160 * have locks bouncing between CPUs):
161 * - split cq/qp table lock into n separate (cache-aligned) locks,
162 * indexed (say) by the page in the table
163 * - split QP struct lock into three (one for common info, one for the
164 * send queue and one for the receive queue)
167 struct mthca_cq_buf {
168 union mthca_buf queue;
173 struct mthca_cq_resize {
174 struct mthca_cq_buf buf;
189 struct mthca_cq_buf buf;
190 struct mthca_cq_resize *resize_buf;
193 /* Next fields are Arbel only */
200 wait_queue_head_t wait;
214 u16 counter; /* Arbel only */
215 int db_index; /* Arbel only */
216 __be32 *db; /* Arbel only */
221 union mthca_buf queue;
224 wait_queue_head_t wait;
239 int db_index; /* Arbel only */
247 struct ib_ud_header ud_header;
250 dma_addr_t header_dma;
258 u8 port; /* for SQP and memfree use only */
259 u8 alt_port; /* for memfree use only */
269 enum ib_sig_type sq_policy;
274 union mthca_buf queue;
276 wait_queue_head_t wait;
278 struct mthca_sqp *sqp;
281 static inline struct mthca_ucontext *to_mucontext(struct ib_ucontext *ibucontext)
283 return container_of(ibucontext, struct mthca_ucontext, ibucontext);
286 static inline struct mthca_mr *to_mmr(struct ib_mr *ibmr)
288 return container_of(ibmr, struct mthca_mr, ibmr);
291 static inline struct mthca_pd *to_mpd(struct ib_pd *ibpd)
293 return container_of(ibpd, struct mthca_pd, ibpd);
296 static inline struct mthca_ah *to_mah(struct ib_ah *ibah)
298 return container_of(ibah, struct mthca_ah, ibah);
301 static inline struct mthca_cq *to_mcq(struct ib_cq *ibcq)
303 return container_of(ibcq, struct mthca_cq, ibcq);
306 static inline struct mthca_srq *to_msrq(struct ib_srq *ibsrq)
308 return container_of(ibsrq, struct mthca_srq, ibsrq);
311 static inline struct mthca_qp *to_mqp(struct ib_qp *ibqp)
313 return container_of(ibqp, struct mthca_qp, ibqp);
316 #endif /* MTHCA_PROVIDER_H */