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 Cisco Systems. All rights reserved.
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:
16 * Redistribution and use in source and binary forms, with or
17 * without modification, are permitted provided that the following
20 * - Redistributions of source code must retain the above
21 * copyright notice, this list of conditions and the following
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.
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
38 * $Id: verbs.c 1349 2004-12-16 21:09:43Z roland $
41 #include <linux/errno.h>
42 #include <linux/err.h>
47 /* Protection domains */
49 struct ib_pd *ib_alloc_pd(struct ib_device *device)
53 pd = device->alloc_pd(device, NULL, NULL);
58 atomic_set(&pd->usecnt, 0);
63 EXPORT_SYMBOL(ib_alloc_pd);
65 int ib_dealloc_pd(struct ib_pd *pd)
67 if (atomic_read(&pd->usecnt))
70 return pd->device->dealloc_pd(pd);
72 EXPORT_SYMBOL(ib_dealloc_pd);
76 struct ib_ah *ib_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr)
80 ah = pd->device->create_ah(pd, ah_attr);
83 ah->device = pd->device;
86 atomic_inc(&pd->usecnt);
91 EXPORT_SYMBOL(ib_create_ah);
93 struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, struct ib_wc *wc,
94 struct ib_grh *grh, u8 port_num)
96 struct ib_ah_attr ah_attr;
101 memset(&ah_attr, 0, sizeof ah_attr);
102 ah_attr.dlid = wc->slid;
104 ah_attr.src_path_bits = wc->dlid_path_bits;
105 ah_attr.port_num = port_num;
107 if (wc->wc_flags & IB_WC_GRH) {
108 ah_attr.ah_flags = IB_AH_GRH;
109 ah_attr.grh.dgid = grh->dgid;
111 ret = ib_find_cached_gid(pd->device, &grh->sgid, &port_num,
116 ah_attr.grh.sgid_index = (u8) gid_index;
117 flow_class = be32_to_cpu(grh->version_tclass_flow);
118 ah_attr.grh.flow_label = flow_class & 0xFFFFF;
119 ah_attr.grh.traffic_class = (flow_class >> 20) & 0xFF;
120 ah_attr.grh.hop_limit = grh->hop_limit;
123 return ib_create_ah(pd, &ah_attr);
125 EXPORT_SYMBOL(ib_create_ah_from_wc);
127 int ib_modify_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr)
129 return ah->device->modify_ah ?
130 ah->device->modify_ah(ah, ah_attr) :
133 EXPORT_SYMBOL(ib_modify_ah);
135 int ib_query_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr)
137 return ah->device->query_ah ?
138 ah->device->query_ah(ah, ah_attr) :
141 EXPORT_SYMBOL(ib_query_ah);
143 int ib_destroy_ah(struct ib_ah *ah)
149 ret = ah->device->destroy_ah(ah);
151 atomic_dec(&pd->usecnt);
155 EXPORT_SYMBOL(ib_destroy_ah);
159 struct ib_qp *ib_create_qp(struct ib_pd *pd,
160 struct ib_qp_init_attr *qp_init_attr)
164 qp = pd->device->create_qp(pd, qp_init_attr, NULL);
167 qp->device = pd->device;
169 qp->send_cq = qp_init_attr->send_cq;
170 qp->recv_cq = qp_init_attr->recv_cq;
171 qp->srq = qp_init_attr->srq;
173 qp->event_handler = qp_init_attr->event_handler;
174 qp->qp_context = qp_init_attr->qp_context;
175 qp->qp_type = qp_init_attr->qp_type;
176 atomic_inc(&pd->usecnt);
177 atomic_inc(&qp_init_attr->send_cq->usecnt);
178 atomic_inc(&qp_init_attr->recv_cq->usecnt);
179 if (qp_init_attr->srq)
180 atomic_inc(&qp_init_attr->srq->usecnt);
185 EXPORT_SYMBOL(ib_create_qp);
187 int ib_modify_qp(struct ib_qp *qp,
188 struct ib_qp_attr *qp_attr,
191 return qp->device->modify_qp(qp, qp_attr, qp_attr_mask);
193 EXPORT_SYMBOL(ib_modify_qp);
195 int ib_query_qp(struct ib_qp *qp,
196 struct ib_qp_attr *qp_attr,
198 struct ib_qp_init_attr *qp_init_attr)
200 return qp->device->query_qp ?
201 qp->device->query_qp(qp, qp_attr, qp_attr_mask, qp_init_attr) :
204 EXPORT_SYMBOL(ib_query_qp);
206 int ib_destroy_qp(struct ib_qp *qp)
209 struct ib_cq *scq, *rcq;
218 ret = qp->device->destroy_qp(qp);
220 atomic_dec(&pd->usecnt);
221 atomic_dec(&scq->usecnt);
222 atomic_dec(&rcq->usecnt);
224 atomic_dec(&srq->usecnt);
229 EXPORT_SYMBOL(ib_destroy_qp);
231 /* Completion queues */
233 struct ib_cq *ib_create_cq(struct ib_device *device,
234 ib_comp_handler comp_handler,
235 void (*event_handler)(struct ib_event *, void *),
236 void *cq_context, int cqe)
240 cq = device->create_cq(device, cqe, NULL, NULL);
245 cq->comp_handler = comp_handler;
246 cq->event_handler = event_handler;
247 cq->cq_context = cq_context;
248 atomic_set(&cq->usecnt, 0);
253 EXPORT_SYMBOL(ib_create_cq);
255 int ib_destroy_cq(struct ib_cq *cq)
257 if (atomic_read(&cq->usecnt))
260 return cq->device->destroy_cq(cq);
262 EXPORT_SYMBOL(ib_destroy_cq);
264 int ib_resize_cq(struct ib_cq *cq,
269 if (!cq->device->resize_cq)
272 ret = cq->device->resize_cq(cq, &cqe);
278 EXPORT_SYMBOL(ib_resize_cq);
282 struct ib_mr *ib_get_dma_mr(struct ib_pd *pd, int mr_access_flags)
286 mr = pd->device->get_dma_mr(pd, mr_access_flags);
289 mr->device = pd->device;
292 atomic_inc(&pd->usecnt);
293 atomic_set(&mr->usecnt, 0);
298 EXPORT_SYMBOL(ib_get_dma_mr);
300 struct ib_mr *ib_reg_phys_mr(struct ib_pd *pd,
301 struct ib_phys_buf *phys_buf_array,
308 mr = pd->device->reg_phys_mr(pd, phys_buf_array, num_phys_buf,
309 mr_access_flags, iova_start);
312 mr->device = pd->device;
315 atomic_inc(&pd->usecnt);
316 atomic_set(&mr->usecnt, 0);
321 EXPORT_SYMBOL(ib_reg_phys_mr);
323 int ib_rereg_phys_mr(struct ib_mr *mr,
326 struct ib_phys_buf *phys_buf_array,
331 struct ib_pd *old_pd;
334 if (!mr->device->rereg_phys_mr)
337 if (atomic_read(&mr->usecnt))
342 ret = mr->device->rereg_phys_mr(mr, mr_rereg_mask, pd,
343 phys_buf_array, num_phys_buf,
344 mr_access_flags, iova_start);
346 if (!ret && (mr_rereg_mask & IB_MR_REREG_PD)) {
347 atomic_dec(&old_pd->usecnt);
348 atomic_inc(&pd->usecnt);
353 EXPORT_SYMBOL(ib_rereg_phys_mr);
355 int ib_query_mr(struct ib_mr *mr, struct ib_mr_attr *mr_attr)
357 return mr->device->query_mr ?
358 mr->device->query_mr(mr, mr_attr) : -ENOSYS;
360 EXPORT_SYMBOL(ib_query_mr);
362 int ib_dereg_mr(struct ib_mr *mr)
367 if (atomic_read(&mr->usecnt))
371 ret = mr->device->dereg_mr(mr);
373 atomic_dec(&pd->usecnt);
377 EXPORT_SYMBOL(ib_dereg_mr);
381 struct ib_mw *ib_alloc_mw(struct ib_pd *pd)
385 if (!pd->device->alloc_mw)
386 return ERR_PTR(-ENOSYS);
388 mw = pd->device->alloc_mw(pd);
390 mw->device = pd->device;
393 atomic_inc(&pd->usecnt);
398 EXPORT_SYMBOL(ib_alloc_mw);
400 int ib_dealloc_mw(struct ib_mw *mw)
406 ret = mw->device->dealloc_mw(mw);
408 atomic_dec(&pd->usecnt);
412 EXPORT_SYMBOL(ib_dealloc_mw);
414 /* "Fast" memory regions */
416 struct ib_fmr *ib_alloc_fmr(struct ib_pd *pd,
418 struct ib_fmr_attr *fmr_attr)
422 if (!pd->device->alloc_fmr)
423 return ERR_PTR(-ENOSYS);
425 fmr = pd->device->alloc_fmr(pd, mr_access_flags, fmr_attr);
427 fmr->device = pd->device;
429 atomic_inc(&pd->usecnt);
434 EXPORT_SYMBOL(ib_alloc_fmr);
436 int ib_unmap_fmr(struct list_head *fmr_list)
440 if (list_empty(fmr_list))
443 fmr = list_entry(fmr_list->next, struct ib_fmr, list);
444 return fmr->device->unmap_fmr(fmr_list);
446 EXPORT_SYMBOL(ib_unmap_fmr);
448 int ib_dealloc_fmr(struct ib_fmr *fmr)
454 ret = fmr->device->dealloc_fmr(fmr);
456 atomic_dec(&pd->usecnt);
460 EXPORT_SYMBOL(ib_dealloc_fmr);
462 /* Multicast groups */
464 int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
466 return qp->device->attach_mcast ?
467 qp->device->attach_mcast(qp, gid, lid) :
470 EXPORT_SYMBOL(ib_attach_mcast);
472 int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
474 return qp->device->detach_mcast ?
475 qp->device->detach_mcast(qp, gid, lid) :
478 EXPORT_SYMBOL(ib_detach_mcast);