1 /* 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. 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 * $Id: mthca_provider.h 1349 2004-12-16 21:09:43Z roland $ 35 */ 36 37 #ifndef MTHCA_PROVIDER_H 38 #define MTHCA_PROVIDER_H 39 40 #include <rdma/ib_verbs.h> 41 #include <rdma/ib_pack.h> 42 43 #define MTHCA_MPT_FLAG_ATOMIC (1 << 14) 44 #define MTHCA_MPT_FLAG_REMOTE_WRITE (1 << 13) 45 #define MTHCA_MPT_FLAG_REMOTE_READ (1 << 12) 46 #define MTHCA_MPT_FLAG_LOCAL_WRITE (1 << 11) 47 #define MTHCA_MPT_FLAG_LOCAL_READ (1 << 10) 48 49 struct mthca_buf_list { 50 void *buf; 51 DECLARE_PCI_UNMAP_ADDR(mapping) 52 }; 53 54 union mthca_buf { 55 struct mthca_buf_list direct; 56 struct mthca_buf_list *page_list; 57 }; 58 59 struct mthca_uar { 60 unsigned long pfn; 61 int index; 62 }; 63 64 struct mthca_user_db_table; 65 66 struct mthca_ucontext { 67 struct ib_ucontext ibucontext; 68 struct mthca_uar uar; 69 struct mthca_user_db_table *db_tab; 70 }; 71 72 struct mthca_mtt; 73 74 struct mthca_mr { 75 struct ib_mr ibmr; 76 struct mthca_mtt *mtt; 77 }; 78 79 struct mthca_fmr { 80 struct ib_fmr ibmr; 81 struct ib_fmr_attr attr; 82 struct mthca_mtt *mtt; 83 int maps; 84 union { 85 struct { 86 struct mthca_mpt_entry __iomem *mpt; 87 u64 __iomem *mtts; 88 } tavor; 89 struct { 90 struct mthca_mpt_entry *mpt; 91 __be64 *mtts; 92 } arbel; 93 } mem; 94 }; 95 96 struct mthca_pd { 97 struct ib_pd ibpd; 98 u32 pd_num; 99 atomic_t sqp_count; 100 struct mthca_mr ntmr; 101 int privileged; 102 }; 103 104 struct mthca_eq { 105 struct mthca_dev *dev; 106 int eqn; 107 u32 eqn_mask; 108 u32 cons_index; 109 u16 msi_x_vector; 110 u16 msi_x_entry; 111 int have_irq; 112 int nent; 113 struct mthca_buf_list *page_list; 114 struct mthca_mr mr; 115 }; 116 117 struct mthca_av; 118 119 enum mthca_ah_type { 120 MTHCA_AH_ON_HCA, 121 MTHCA_AH_PCI_POOL, 122 MTHCA_AH_KMALLOC 123 }; 124 125 struct mthca_ah { 126 struct ib_ah ibah; 127 enum mthca_ah_type type; 128 u32 key; 129 struct mthca_av *av; 130 dma_addr_t avdma; 131 }; 132 133 /* 134 * Quick description of our CQ/QP locking scheme: 135 * 136 * We have one global lock that protects dev->cq/qp_table. Each 137 * struct mthca_cq/qp also has its own lock. An individual qp lock 138 * may be taken inside of an individual cq lock. Both cqs attached to 139 * a qp may be locked, with the send cq locked first. No other 140 * nesting should be done. 141 * 142 * Each struct mthca_cq/qp also has an atomic_t ref count. The 143 * pointer from the cq/qp_table to the struct counts as one reference. 144 * This reference also is good for access through the consumer API, so 145 * modifying the CQ/QP etc doesn't need to take another reference. 146 * Access because of a completion being polled does need a reference. 147 * 148 * Finally, each struct mthca_cq/qp has a wait_queue_head_t for the 149 * destroy function to sleep on. 150 * 151 * This means that access from the consumer API requires nothing but 152 * taking the struct's lock. 153 * 154 * Access because of a completion event should go as follows: 155 * - lock cq/qp_table and look up struct 156 * - increment ref count in struct 157 * - drop cq/qp_table lock 158 * - lock struct, do your thing, and unlock struct 159 * - decrement ref count; if zero, wake up waiters 160 * 161 * To destroy a CQ/QP, we can do the following: 162 * - lock cq/qp_table, remove pointer, unlock cq/qp_table lock 163 * - decrement ref count 164 * - wait_event until ref count is zero 165 * 166 * It is the consumer's responsibilty to make sure that no QP 167 * operations (WQE posting or state modification) are pending when a 168 * QP is destroyed. Also, the consumer must make sure that calls to 169 * qp_modify are serialized. Similarly, the consumer is responsible 170 * for ensuring that no CQ resize operations are pending when a CQ 171 * is destroyed. 172 * 173 * Possible optimizations (wait for profile data to see if/where we 174 * have locks bouncing between CPUs): 175 * - split cq/qp table lock into n separate (cache-aligned) locks, 176 * indexed (say) by the page in the table 177 * - split QP struct lock into three (one for common info, one for the 178 * send queue and one for the receive queue) 179 */ 180 181 struct mthca_cq_buf { 182 union mthca_buf queue; 183 struct mthca_mr mr; 184 int is_direct; 185 }; 186 187 struct mthca_cq_resize { 188 struct mthca_cq_buf buf; 189 int cqe; 190 enum { 191 CQ_RESIZE_ALLOC, 192 CQ_RESIZE_READY, 193 CQ_RESIZE_SWAPPED 194 } state; 195 }; 196 197 struct mthca_cq { 198 struct ib_cq ibcq; 199 spinlock_t lock; 200 atomic_t refcount; 201 int cqn; 202 u32 cons_index; 203 struct mthca_cq_buf buf; 204 struct mthca_cq_resize *resize_buf; 205 int is_kernel; 206 207 /* Next fields are Arbel only */ 208 int set_ci_db_index; 209 __be32 *set_ci_db; 210 int arm_db_index; 211 __be32 *arm_db; 212 int arm_sn; 213 214 wait_queue_head_t wait; 215 }; 216 217 struct mthca_srq { 218 struct ib_srq ibsrq; 219 spinlock_t lock; 220 atomic_t refcount; 221 int srqn; 222 int max; 223 int max_gs; 224 int wqe_shift; 225 int first_free; 226 int last_free; 227 u16 counter; /* Arbel only */ 228 int db_index; /* Arbel only */ 229 __be32 *db; /* Arbel only */ 230 void *last; 231 232 int is_direct; 233 u64 *wrid; 234 union mthca_buf queue; 235 struct mthca_mr mr; 236 237 wait_queue_head_t wait; 238 }; 239 240 struct mthca_wq { 241 spinlock_t lock; 242 int max; 243 unsigned next_ind; 244 unsigned last_comp; 245 unsigned head; 246 unsigned tail; 247 void *last; 248 int max_gs; 249 int wqe_shift; 250 251 int db_index; /* Arbel only */ 252 __be32 *db; 253 }; 254 255 struct mthca_qp { 256 struct ib_qp ibqp; 257 atomic_t refcount; 258 u32 qpn; 259 int is_direct; 260 u8 port; /* for SQP and memfree use only */ 261 u8 alt_port; /* for memfree use only */ 262 u8 transport; 263 u8 state; 264 u8 atomic_rd_en; 265 u8 resp_depth; 266 267 struct mthca_mr mr; 268 269 struct mthca_wq rq; 270 struct mthca_wq sq; 271 enum ib_sig_type sq_policy; 272 int send_wqe_offset; 273 int max_inline_data; 274 275 u64 *wrid; 276 union mthca_buf queue; 277 278 wait_queue_head_t wait; 279 }; 280 281 struct mthca_sqp { 282 struct mthca_qp qp; 283 int pkey_index; 284 u32 qkey; 285 u32 send_psn; 286 struct ib_ud_header ud_header; 287 int header_buf_size; 288 void *header_buf; 289 dma_addr_t header_dma; 290 }; 291 292 static inline struct mthca_ucontext *to_mucontext(struct ib_ucontext *ibucontext) 293 { 294 return container_of(ibucontext, struct mthca_ucontext, ibucontext); 295 } 296 297 static inline struct mthca_fmr *to_mfmr(struct ib_fmr *ibmr) 298 { 299 return container_of(ibmr, struct mthca_fmr, ibmr); 300 } 301 302 static inline struct mthca_mr *to_mmr(struct ib_mr *ibmr) 303 { 304 return container_of(ibmr, struct mthca_mr, ibmr); 305 } 306 307 static inline struct mthca_pd *to_mpd(struct ib_pd *ibpd) 308 { 309 return container_of(ibpd, struct mthca_pd, ibpd); 310 } 311 312 static inline struct mthca_ah *to_mah(struct ib_ah *ibah) 313 { 314 return container_of(ibah, struct mthca_ah, ibah); 315 } 316 317 static inline struct mthca_cq *to_mcq(struct ib_cq *ibcq) 318 { 319 return container_of(ibcq, struct mthca_cq, ibcq); 320 } 321 322 static inline struct mthca_srq *to_msrq(struct ib_srq *ibsrq) 323 { 324 return container_of(ibsrq, struct mthca_srq, ibsrq); 325 } 326 327 static inline struct mthca_qp *to_mqp(struct ib_qp *ibqp) 328 { 329 return container_of(ibqp, struct mthca_qp, ibqp); 330 } 331 332 static inline struct mthca_sqp *to_msqp(struct mthca_qp *qp) 333 { 334 return container_of(qp, struct mthca_sqp, qp); 335 } 336 337 #endif /* MTHCA_PROVIDER_H */ 338