1 /*
2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
3  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
4  * Copyright (c) 2005, 2006 Cisco Systems.  All rights reserved.
5  * Copyright (c) 2005 Mellanox Technologies. All rights reserved.
6  * Copyright (c) 2004 Voltaire, Inc. All rights reserved.
7  *
8  * This software is available to you under a choice of one of two
9  * licenses.  You may choose to be licensed under the terms of the GNU
10  * General Public License (GPL) Version 2, available from the file
11  * COPYING in the main directory of this source tree, or the
12  * OpenIB.org BSD license below:
13  *
14  *     Redistribution and use in source and binary forms, with or
15  *     without modification, are permitted provided that the following
16  *     conditions are met:
17  *
18  *      - Redistributions of source code must retain the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer.
21  *
22  *      - Redistributions in binary form must reproduce the above
23  *        copyright notice, this list of conditions and the following
24  *        disclaimer in the documentation and/or other materials
25  *        provided with the distribution.
26  *
27  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
28  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
29  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
30  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
31  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
32  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
33  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
34  * SOFTWARE.
35  */
36 
37 #include <rdma/ib_smi.h>
38 #include <rdma/ib_umem.h>
39 #include <rdma/ib_user_verbs.h>
40 
41 #include <linux/sched.h>
42 #include <linux/slab.h>
43 #include <linux/stat.h>
44 #include <linux/mm.h>
45 #include <linux/export.h>
46 
47 #include "mthca_dev.h"
48 #include "mthca_cmd.h"
49 #include "mthca_user.h"
50 #include "mthca_memfree.h"
51 
52 static void init_query_mad(struct ib_smp *mad)
53 {
54 	mad->base_version  = 1;
55 	mad->mgmt_class    = IB_MGMT_CLASS_SUBN_LID_ROUTED;
56 	mad->class_version = 1;
57 	mad->method    	   = IB_MGMT_METHOD_GET;
58 }
59 
60 static int mthca_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
61 			      struct ib_udata *uhw)
62 {
63 	struct ib_smp *in_mad  = NULL;
64 	struct ib_smp *out_mad = NULL;
65 	int err = -ENOMEM;
66 	struct mthca_dev *mdev = to_mdev(ibdev);
67 
68 	if (uhw->inlen || uhw->outlen)
69 		return -EINVAL;
70 
71 	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
72 	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
73 	if (!in_mad || !out_mad)
74 		goto out;
75 
76 	memset(props, 0, sizeof *props);
77 
78 	props->fw_ver              = mdev->fw_ver;
79 
80 	init_query_mad(in_mad);
81 	in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
82 
83 	err = mthca_MAD_IFC(mdev, 1, 1,
84 			    1, NULL, NULL, in_mad, out_mad);
85 	if (err)
86 		goto out;
87 
88 	props->device_cap_flags    = mdev->device_cap_flags;
89 	props->vendor_id           = be32_to_cpup((__be32 *) (out_mad->data + 36)) &
90 		0xffffff;
91 	props->vendor_part_id      = be16_to_cpup((__be16 *) (out_mad->data + 30));
92 	props->hw_ver              = be32_to_cpup((__be32 *) (out_mad->data + 32));
93 	memcpy(&props->sys_image_guid, out_mad->data +  4, 8);
94 
95 	props->max_mr_size         = ~0ull;
96 	props->page_size_cap       = mdev->limits.page_size_cap;
97 	props->max_qp              = mdev->limits.num_qps - mdev->limits.reserved_qps;
98 	props->max_qp_wr           = mdev->limits.max_wqes;
99 	props->max_sge             = mdev->limits.max_sg;
100 	props->max_cq              = mdev->limits.num_cqs - mdev->limits.reserved_cqs;
101 	props->max_cqe             = mdev->limits.max_cqes;
102 	props->max_mr              = mdev->limits.num_mpts - mdev->limits.reserved_mrws;
103 	props->max_pd              = mdev->limits.num_pds - mdev->limits.reserved_pds;
104 	props->max_qp_rd_atom      = 1 << mdev->qp_table.rdb_shift;
105 	props->max_qp_init_rd_atom = mdev->limits.max_qp_init_rdma;
106 	props->max_res_rd_atom     = props->max_qp_rd_atom * props->max_qp;
107 	props->max_srq             = mdev->limits.num_srqs - mdev->limits.reserved_srqs;
108 	props->max_srq_wr          = mdev->limits.max_srq_wqes;
109 	props->max_srq_sge         = mdev->limits.max_srq_sge;
110 	props->local_ca_ack_delay  = mdev->limits.local_ca_ack_delay;
111 	props->atomic_cap          = mdev->limits.flags & DEV_LIM_FLAG_ATOMIC ?
112 					IB_ATOMIC_HCA : IB_ATOMIC_NONE;
113 	props->max_pkeys           = mdev->limits.pkey_table_len;
114 	props->max_mcast_grp       = mdev->limits.num_mgms + mdev->limits.num_amgms;
115 	props->max_mcast_qp_attach = MTHCA_QP_PER_MGM;
116 	props->max_total_mcast_qp_attach = props->max_mcast_qp_attach *
117 					   props->max_mcast_grp;
118 	/*
119 	 * If Sinai memory key optimization is being used, then only
120 	 * the 8-bit key portion will change.  For other HCAs, the
121 	 * unused index bits will also be used for FMR remapping.
122 	 */
123 	if (mdev->mthca_flags & MTHCA_FLAG_SINAI_OPT)
124 		props->max_map_per_fmr = 255;
125 	else
126 		props->max_map_per_fmr =
127 			(1 << (32 - ilog2(mdev->limits.num_mpts))) - 1;
128 
129 	err = 0;
130  out:
131 	kfree(in_mad);
132 	kfree(out_mad);
133 	return err;
134 }
135 
136 static int mthca_query_port(struct ib_device *ibdev,
137 			    u8 port, struct ib_port_attr *props)
138 {
139 	struct ib_smp *in_mad  = NULL;
140 	struct ib_smp *out_mad = NULL;
141 	int err = -ENOMEM;
142 
143 	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
144 	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
145 	if (!in_mad || !out_mad)
146 		goto out;
147 
148 	memset(props, 0, sizeof *props);
149 
150 	init_query_mad(in_mad);
151 	in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
152 	in_mad->attr_mod = cpu_to_be32(port);
153 
154 	err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
155 			    port, NULL, NULL, in_mad, out_mad);
156 	if (err)
157 		goto out;
158 
159 	props->lid               = be16_to_cpup((__be16 *) (out_mad->data + 16));
160 	props->lmc               = out_mad->data[34] & 0x7;
161 	props->sm_lid            = be16_to_cpup((__be16 *) (out_mad->data + 18));
162 	props->sm_sl             = out_mad->data[36] & 0xf;
163 	props->state             = out_mad->data[32] & 0xf;
164 	props->phys_state        = out_mad->data[33] >> 4;
165 	props->port_cap_flags    = be32_to_cpup((__be32 *) (out_mad->data + 20));
166 	props->gid_tbl_len       = to_mdev(ibdev)->limits.gid_table_len;
167 	props->max_msg_sz        = 0x80000000;
168 	props->pkey_tbl_len      = to_mdev(ibdev)->limits.pkey_table_len;
169 	props->bad_pkey_cntr     = be16_to_cpup((__be16 *) (out_mad->data + 46));
170 	props->qkey_viol_cntr    = be16_to_cpup((__be16 *) (out_mad->data + 48));
171 	props->active_width      = out_mad->data[31] & 0xf;
172 	props->active_speed      = out_mad->data[35] >> 4;
173 	props->max_mtu           = out_mad->data[41] & 0xf;
174 	props->active_mtu        = out_mad->data[36] >> 4;
175 	props->subnet_timeout    = out_mad->data[51] & 0x1f;
176 	props->max_vl_num        = out_mad->data[37] >> 4;
177 	props->init_type_reply   = out_mad->data[41] >> 4;
178 
179  out:
180 	kfree(in_mad);
181 	kfree(out_mad);
182 	return err;
183 }
184 
185 static int mthca_modify_device(struct ib_device *ibdev,
186 			       int mask,
187 			       struct ib_device_modify *props)
188 {
189 	if (mask & ~IB_DEVICE_MODIFY_NODE_DESC)
190 		return -EOPNOTSUPP;
191 
192 	if (mask & IB_DEVICE_MODIFY_NODE_DESC) {
193 		if (mutex_lock_interruptible(&to_mdev(ibdev)->cap_mask_mutex))
194 			return -ERESTARTSYS;
195 		memcpy(ibdev->node_desc, props->node_desc, 64);
196 		mutex_unlock(&to_mdev(ibdev)->cap_mask_mutex);
197 	}
198 
199 	return 0;
200 }
201 
202 static int mthca_modify_port(struct ib_device *ibdev,
203 			     u8 port, int port_modify_mask,
204 			     struct ib_port_modify *props)
205 {
206 	struct mthca_set_ib_param set_ib;
207 	struct ib_port_attr attr;
208 	int err;
209 
210 	if (mutex_lock_interruptible(&to_mdev(ibdev)->cap_mask_mutex))
211 		return -ERESTARTSYS;
212 
213 	err = mthca_query_port(ibdev, port, &attr);
214 	if (err)
215 		goto out;
216 
217 	set_ib.set_si_guid     = 0;
218 	set_ib.reset_qkey_viol = !!(port_modify_mask & IB_PORT_RESET_QKEY_CNTR);
219 
220 	set_ib.cap_mask = (attr.port_cap_flags | props->set_port_cap_mask) &
221 		~props->clr_port_cap_mask;
222 
223 	err = mthca_SET_IB(to_mdev(ibdev), &set_ib, port);
224 	if (err)
225 		goto out;
226 out:
227 	mutex_unlock(&to_mdev(ibdev)->cap_mask_mutex);
228 	return err;
229 }
230 
231 static int mthca_query_pkey(struct ib_device *ibdev,
232 			    u8 port, u16 index, u16 *pkey)
233 {
234 	struct ib_smp *in_mad  = NULL;
235 	struct ib_smp *out_mad = NULL;
236 	int err = -ENOMEM;
237 
238 	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
239 	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
240 	if (!in_mad || !out_mad)
241 		goto out;
242 
243 	init_query_mad(in_mad);
244 	in_mad->attr_id  = IB_SMP_ATTR_PKEY_TABLE;
245 	in_mad->attr_mod = cpu_to_be32(index / 32);
246 
247 	err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
248 			    port, NULL, NULL, in_mad, out_mad);
249 	if (err)
250 		goto out;
251 
252 	*pkey = be16_to_cpu(((__be16 *) out_mad->data)[index % 32]);
253 
254  out:
255 	kfree(in_mad);
256 	kfree(out_mad);
257 	return err;
258 }
259 
260 static int mthca_query_gid(struct ib_device *ibdev, u8 port,
261 			   int index, union ib_gid *gid)
262 {
263 	struct ib_smp *in_mad  = NULL;
264 	struct ib_smp *out_mad = NULL;
265 	int err = -ENOMEM;
266 
267 	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
268 	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
269 	if (!in_mad || !out_mad)
270 		goto out;
271 
272 	init_query_mad(in_mad);
273 	in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
274 	in_mad->attr_mod = cpu_to_be32(port);
275 
276 	err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
277 			    port, NULL, NULL, in_mad, out_mad);
278 	if (err)
279 		goto out;
280 
281 	memcpy(gid->raw, out_mad->data + 8, 8);
282 
283 	init_query_mad(in_mad);
284 	in_mad->attr_id  = IB_SMP_ATTR_GUID_INFO;
285 	in_mad->attr_mod = cpu_to_be32(index / 8);
286 
287 	err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
288 			    port, NULL, NULL, in_mad, out_mad);
289 	if (err)
290 		goto out;
291 
292 	memcpy(gid->raw + 8, out_mad->data + (index % 8) * 8, 8);
293 
294  out:
295 	kfree(in_mad);
296 	kfree(out_mad);
297 	return err;
298 }
299 
300 static struct ib_ucontext *mthca_alloc_ucontext(struct ib_device *ibdev,
301 						struct ib_udata *udata)
302 {
303 	struct mthca_alloc_ucontext_resp uresp;
304 	struct mthca_ucontext           *context;
305 	int                              err;
306 
307 	if (!(to_mdev(ibdev)->active))
308 		return ERR_PTR(-EAGAIN);
309 
310 	memset(&uresp, 0, sizeof uresp);
311 
312 	uresp.qp_tab_size = to_mdev(ibdev)->limits.num_qps;
313 	if (mthca_is_memfree(to_mdev(ibdev)))
314 		uresp.uarc_size = to_mdev(ibdev)->uar_table.uarc_size;
315 	else
316 		uresp.uarc_size = 0;
317 
318 	context = kmalloc(sizeof *context, GFP_KERNEL);
319 	if (!context)
320 		return ERR_PTR(-ENOMEM);
321 
322 	err = mthca_uar_alloc(to_mdev(ibdev), &context->uar);
323 	if (err) {
324 		kfree(context);
325 		return ERR_PTR(err);
326 	}
327 
328 	context->db_tab = mthca_init_user_db_tab(to_mdev(ibdev));
329 	if (IS_ERR(context->db_tab)) {
330 		err = PTR_ERR(context->db_tab);
331 		mthca_uar_free(to_mdev(ibdev), &context->uar);
332 		kfree(context);
333 		return ERR_PTR(err);
334 	}
335 
336 	if (ib_copy_to_udata(udata, &uresp, sizeof uresp)) {
337 		mthca_cleanup_user_db_tab(to_mdev(ibdev), &context->uar, context->db_tab);
338 		mthca_uar_free(to_mdev(ibdev), &context->uar);
339 		kfree(context);
340 		return ERR_PTR(-EFAULT);
341 	}
342 
343 	context->reg_mr_warned = 0;
344 
345 	return &context->ibucontext;
346 }
347 
348 static int mthca_dealloc_ucontext(struct ib_ucontext *context)
349 {
350 	mthca_cleanup_user_db_tab(to_mdev(context->device), &to_mucontext(context)->uar,
351 				  to_mucontext(context)->db_tab);
352 	mthca_uar_free(to_mdev(context->device), &to_mucontext(context)->uar);
353 	kfree(to_mucontext(context));
354 
355 	return 0;
356 }
357 
358 static int mthca_mmap_uar(struct ib_ucontext *context,
359 			  struct vm_area_struct *vma)
360 {
361 	if (vma->vm_end - vma->vm_start != PAGE_SIZE)
362 		return -EINVAL;
363 
364 	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
365 
366 	if (io_remap_pfn_range(vma, vma->vm_start,
367 			       to_mucontext(context)->uar.pfn,
368 			       PAGE_SIZE, vma->vm_page_prot))
369 		return -EAGAIN;
370 
371 	return 0;
372 }
373 
374 static struct ib_pd *mthca_alloc_pd(struct ib_device *ibdev,
375 				    struct ib_ucontext *context,
376 				    struct ib_udata *udata)
377 {
378 	struct mthca_pd *pd;
379 	int err;
380 
381 	pd = kmalloc(sizeof *pd, GFP_KERNEL);
382 	if (!pd)
383 		return ERR_PTR(-ENOMEM);
384 
385 	err = mthca_pd_alloc(to_mdev(ibdev), !context, pd);
386 	if (err) {
387 		kfree(pd);
388 		return ERR_PTR(err);
389 	}
390 
391 	if (context) {
392 		if (ib_copy_to_udata(udata, &pd->pd_num, sizeof (__u32))) {
393 			mthca_pd_free(to_mdev(ibdev), pd);
394 			kfree(pd);
395 			return ERR_PTR(-EFAULT);
396 		}
397 	}
398 
399 	return &pd->ibpd;
400 }
401 
402 static int mthca_dealloc_pd(struct ib_pd *pd)
403 {
404 	mthca_pd_free(to_mdev(pd->device), to_mpd(pd));
405 	kfree(pd);
406 
407 	return 0;
408 }
409 
410 static struct ib_ah *mthca_ah_create(struct ib_pd *pd,
411 				     struct ib_ah_attr *ah_attr)
412 {
413 	int err;
414 	struct mthca_ah *ah;
415 
416 	ah = kmalloc(sizeof *ah, GFP_ATOMIC);
417 	if (!ah)
418 		return ERR_PTR(-ENOMEM);
419 
420 	err = mthca_create_ah(to_mdev(pd->device), to_mpd(pd), ah_attr, ah);
421 	if (err) {
422 		kfree(ah);
423 		return ERR_PTR(err);
424 	}
425 
426 	return &ah->ibah;
427 }
428 
429 static int mthca_ah_destroy(struct ib_ah *ah)
430 {
431 	mthca_destroy_ah(to_mdev(ah->device), to_mah(ah));
432 	kfree(ah);
433 
434 	return 0;
435 }
436 
437 static struct ib_srq *mthca_create_srq(struct ib_pd *pd,
438 				       struct ib_srq_init_attr *init_attr,
439 				       struct ib_udata *udata)
440 {
441 	struct mthca_create_srq ucmd;
442 	struct mthca_ucontext *context = NULL;
443 	struct mthca_srq *srq;
444 	int err;
445 
446 	if (init_attr->srq_type != IB_SRQT_BASIC)
447 		return ERR_PTR(-ENOSYS);
448 
449 	srq = kmalloc(sizeof *srq, GFP_KERNEL);
450 	if (!srq)
451 		return ERR_PTR(-ENOMEM);
452 
453 	if (pd->uobject) {
454 		context = to_mucontext(pd->uobject->context);
455 
456 		if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd)) {
457 			err = -EFAULT;
458 			goto err_free;
459 		}
460 
461 		err = mthca_map_user_db(to_mdev(pd->device), &context->uar,
462 					context->db_tab, ucmd.db_index,
463 					ucmd.db_page);
464 
465 		if (err)
466 			goto err_free;
467 
468 		srq->mr.ibmr.lkey = ucmd.lkey;
469 		srq->db_index     = ucmd.db_index;
470 	}
471 
472 	err = mthca_alloc_srq(to_mdev(pd->device), to_mpd(pd),
473 			      &init_attr->attr, srq);
474 
475 	if (err && pd->uobject)
476 		mthca_unmap_user_db(to_mdev(pd->device), &context->uar,
477 				    context->db_tab, ucmd.db_index);
478 
479 	if (err)
480 		goto err_free;
481 
482 	if (context && ib_copy_to_udata(udata, &srq->srqn, sizeof (__u32))) {
483 		mthca_free_srq(to_mdev(pd->device), srq);
484 		err = -EFAULT;
485 		goto err_free;
486 	}
487 
488 	return &srq->ibsrq;
489 
490 err_free:
491 	kfree(srq);
492 
493 	return ERR_PTR(err);
494 }
495 
496 static int mthca_destroy_srq(struct ib_srq *srq)
497 {
498 	struct mthca_ucontext *context;
499 
500 	if (srq->uobject) {
501 		context = to_mucontext(srq->uobject->context);
502 
503 		mthca_unmap_user_db(to_mdev(srq->device), &context->uar,
504 				    context->db_tab, to_msrq(srq)->db_index);
505 	}
506 
507 	mthca_free_srq(to_mdev(srq->device), to_msrq(srq));
508 	kfree(srq);
509 
510 	return 0;
511 }
512 
513 static struct ib_qp *mthca_create_qp(struct ib_pd *pd,
514 				     struct ib_qp_init_attr *init_attr,
515 				     struct ib_udata *udata)
516 {
517 	struct mthca_create_qp ucmd;
518 	struct mthca_qp *qp;
519 	int err;
520 
521 	if (init_attr->create_flags)
522 		return ERR_PTR(-EINVAL);
523 
524 	switch (init_attr->qp_type) {
525 	case IB_QPT_RC:
526 	case IB_QPT_UC:
527 	case IB_QPT_UD:
528 	{
529 		struct mthca_ucontext *context;
530 
531 		qp = kmalloc(sizeof *qp, GFP_KERNEL);
532 		if (!qp)
533 			return ERR_PTR(-ENOMEM);
534 
535 		if (pd->uobject) {
536 			context = to_mucontext(pd->uobject->context);
537 
538 			if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd)) {
539 				kfree(qp);
540 				return ERR_PTR(-EFAULT);
541 			}
542 
543 			err = mthca_map_user_db(to_mdev(pd->device), &context->uar,
544 						context->db_tab,
545 						ucmd.sq_db_index, ucmd.sq_db_page);
546 			if (err) {
547 				kfree(qp);
548 				return ERR_PTR(err);
549 			}
550 
551 			err = mthca_map_user_db(to_mdev(pd->device), &context->uar,
552 						context->db_tab,
553 						ucmd.rq_db_index, ucmd.rq_db_page);
554 			if (err) {
555 				mthca_unmap_user_db(to_mdev(pd->device),
556 						    &context->uar,
557 						    context->db_tab,
558 						    ucmd.sq_db_index);
559 				kfree(qp);
560 				return ERR_PTR(err);
561 			}
562 
563 			qp->mr.ibmr.lkey = ucmd.lkey;
564 			qp->sq.db_index  = ucmd.sq_db_index;
565 			qp->rq.db_index  = ucmd.rq_db_index;
566 		}
567 
568 		err = mthca_alloc_qp(to_mdev(pd->device), to_mpd(pd),
569 				     to_mcq(init_attr->send_cq),
570 				     to_mcq(init_attr->recv_cq),
571 				     init_attr->qp_type, init_attr->sq_sig_type,
572 				     &init_attr->cap, qp);
573 
574 		if (err && pd->uobject) {
575 			context = to_mucontext(pd->uobject->context);
576 
577 			mthca_unmap_user_db(to_mdev(pd->device),
578 					    &context->uar,
579 					    context->db_tab,
580 					    ucmd.sq_db_index);
581 			mthca_unmap_user_db(to_mdev(pd->device),
582 					    &context->uar,
583 					    context->db_tab,
584 					    ucmd.rq_db_index);
585 		}
586 
587 		qp->ibqp.qp_num = qp->qpn;
588 		break;
589 	}
590 	case IB_QPT_SMI:
591 	case IB_QPT_GSI:
592 	{
593 		/* Don't allow userspace to create special QPs */
594 		if (pd->uobject)
595 			return ERR_PTR(-EINVAL);
596 
597 		qp = kmalloc(sizeof (struct mthca_sqp), GFP_KERNEL);
598 		if (!qp)
599 			return ERR_PTR(-ENOMEM);
600 
601 		qp->ibqp.qp_num = init_attr->qp_type == IB_QPT_SMI ? 0 : 1;
602 
603 		err = mthca_alloc_sqp(to_mdev(pd->device), to_mpd(pd),
604 				      to_mcq(init_attr->send_cq),
605 				      to_mcq(init_attr->recv_cq),
606 				      init_attr->sq_sig_type, &init_attr->cap,
607 				      qp->ibqp.qp_num, init_attr->port_num,
608 				      to_msqp(qp));
609 		break;
610 	}
611 	default:
612 		/* Don't support raw QPs */
613 		return ERR_PTR(-ENOSYS);
614 	}
615 
616 	if (err) {
617 		kfree(qp);
618 		return ERR_PTR(err);
619 	}
620 
621 	init_attr->cap.max_send_wr     = qp->sq.max;
622 	init_attr->cap.max_recv_wr     = qp->rq.max;
623 	init_attr->cap.max_send_sge    = qp->sq.max_gs;
624 	init_attr->cap.max_recv_sge    = qp->rq.max_gs;
625 	init_attr->cap.max_inline_data = qp->max_inline_data;
626 
627 	return &qp->ibqp;
628 }
629 
630 static int mthca_destroy_qp(struct ib_qp *qp)
631 {
632 	if (qp->uobject) {
633 		mthca_unmap_user_db(to_mdev(qp->device),
634 				    &to_mucontext(qp->uobject->context)->uar,
635 				    to_mucontext(qp->uobject->context)->db_tab,
636 				    to_mqp(qp)->sq.db_index);
637 		mthca_unmap_user_db(to_mdev(qp->device),
638 				    &to_mucontext(qp->uobject->context)->uar,
639 				    to_mucontext(qp->uobject->context)->db_tab,
640 				    to_mqp(qp)->rq.db_index);
641 	}
642 	mthca_free_qp(to_mdev(qp->device), to_mqp(qp));
643 	kfree(qp);
644 	return 0;
645 }
646 
647 static struct ib_cq *mthca_create_cq(struct ib_device *ibdev,
648 				     const struct ib_cq_init_attr *attr,
649 				     struct ib_ucontext *context,
650 				     struct ib_udata *udata)
651 {
652 	int entries = attr->cqe;
653 	struct mthca_create_cq ucmd;
654 	struct mthca_cq *cq;
655 	int nent;
656 	int err;
657 
658 	if (attr->flags)
659 		return ERR_PTR(-EINVAL);
660 
661 	if (entries < 1 || entries > to_mdev(ibdev)->limits.max_cqes)
662 		return ERR_PTR(-EINVAL);
663 
664 	if (context) {
665 		if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd))
666 			return ERR_PTR(-EFAULT);
667 
668 		err = mthca_map_user_db(to_mdev(ibdev), &to_mucontext(context)->uar,
669 					to_mucontext(context)->db_tab,
670 					ucmd.set_db_index, ucmd.set_db_page);
671 		if (err)
672 			return ERR_PTR(err);
673 
674 		err = mthca_map_user_db(to_mdev(ibdev), &to_mucontext(context)->uar,
675 					to_mucontext(context)->db_tab,
676 					ucmd.arm_db_index, ucmd.arm_db_page);
677 		if (err)
678 			goto err_unmap_set;
679 	}
680 
681 	cq = kmalloc(sizeof *cq, GFP_KERNEL);
682 	if (!cq) {
683 		err = -ENOMEM;
684 		goto err_unmap_arm;
685 	}
686 
687 	if (context) {
688 		cq->buf.mr.ibmr.lkey = ucmd.lkey;
689 		cq->set_ci_db_index  = ucmd.set_db_index;
690 		cq->arm_db_index     = ucmd.arm_db_index;
691 	}
692 
693 	for (nent = 1; nent <= entries; nent <<= 1)
694 		; /* nothing */
695 
696 	err = mthca_init_cq(to_mdev(ibdev), nent,
697 			    context ? to_mucontext(context) : NULL,
698 			    context ? ucmd.pdn : to_mdev(ibdev)->driver_pd.pd_num,
699 			    cq);
700 	if (err)
701 		goto err_free;
702 
703 	if (context && ib_copy_to_udata(udata, &cq->cqn, sizeof (__u32))) {
704 		mthca_free_cq(to_mdev(ibdev), cq);
705 		err = -EFAULT;
706 		goto err_free;
707 	}
708 
709 	cq->resize_buf = NULL;
710 
711 	return &cq->ibcq;
712 
713 err_free:
714 	kfree(cq);
715 
716 err_unmap_arm:
717 	if (context)
718 		mthca_unmap_user_db(to_mdev(ibdev), &to_mucontext(context)->uar,
719 				    to_mucontext(context)->db_tab, ucmd.arm_db_index);
720 
721 err_unmap_set:
722 	if (context)
723 		mthca_unmap_user_db(to_mdev(ibdev), &to_mucontext(context)->uar,
724 				    to_mucontext(context)->db_tab, ucmd.set_db_index);
725 
726 	return ERR_PTR(err);
727 }
728 
729 static int mthca_alloc_resize_buf(struct mthca_dev *dev, struct mthca_cq *cq,
730 				  int entries)
731 {
732 	int ret;
733 
734 	spin_lock_irq(&cq->lock);
735 	if (cq->resize_buf) {
736 		ret = -EBUSY;
737 		goto unlock;
738 	}
739 
740 	cq->resize_buf = kmalloc(sizeof *cq->resize_buf, GFP_ATOMIC);
741 	if (!cq->resize_buf) {
742 		ret = -ENOMEM;
743 		goto unlock;
744 	}
745 
746 	cq->resize_buf->state = CQ_RESIZE_ALLOC;
747 
748 	ret = 0;
749 
750 unlock:
751 	spin_unlock_irq(&cq->lock);
752 
753 	if (ret)
754 		return ret;
755 
756 	ret = mthca_alloc_cq_buf(dev, &cq->resize_buf->buf, entries);
757 	if (ret) {
758 		spin_lock_irq(&cq->lock);
759 		kfree(cq->resize_buf);
760 		cq->resize_buf = NULL;
761 		spin_unlock_irq(&cq->lock);
762 		return ret;
763 	}
764 
765 	cq->resize_buf->cqe = entries - 1;
766 
767 	spin_lock_irq(&cq->lock);
768 	cq->resize_buf->state = CQ_RESIZE_READY;
769 	spin_unlock_irq(&cq->lock);
770 
771 	return 0;
772 }
773 
774 static int mthca_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata)
775 {
776 	struct mthca_dev *dev = to_mdev(ibcq->device);
777 	struct mthca_cq *cq = to_mcq(ibcq);
778 	struct mthca_resize_cq ucmd;
779 	u32 lkey;
780 	int ret;
781 
782 	if (entries < 1 || entries > dev->limits.max_cqes)
783 		return -EINVAL;
784 
785 	mutex_lock(&cq->mutex);
786 
787 	entries = roundup_pow_of_two(entries + 1);
788 	if (entries == ibcq->cqe + 1) {
789 		ret = 0;
790 		goto out;
791 	}
792 
793 	if (cq->is_kernel) {
794 		ret = mthca_alloc_resize_buf(dev, cq, entries);
795 		if (ret)
796 			goto out;
797 		lkey = cq->resize_buf->buf.mr.ibmr.lkey;
798 	} else {
799 		if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd)) {
800 			ret = -EFAULT;
801 			goto out;
802 		}
803 		lkey = ucmd.lkey;
804 	}
805 
806 	ret = mthca_RESIZE_CQ(dev, cq->cqn, lkey, ilog2(entries));
807 
808 	if (ret) {
809 		if (cq->resize_buf) {
810 			mthca_free_cq_buf(dev, &cq->resize_buf->buf,
811 					  cq->resize_buf->cqe);
812 			kfree(cq->resize_buf);
813 			spin_lock_irq(&cq->lock);
814 			cq->resize_buf = NULL;
815 			spin_unlock_irq(&cq->lock);
816 		}
817 		goto out;
818 	}
819 
820 	if (cq->is_kernel) {
821 		struct mthca_cq_buf tbuf;
822 		int tcqe;
823 
824 		spin_lock_irq(&cq->lock);
825 		if (cq->resize_buf->state == CQ_RESIZE_READY) {
826 			mthca_cq_resize_copy_cqes(cq);
827 			tbuf         = cq->buf;
828 			tcqe         = cq->ibcq.cqe;
829 			cq->buf      = cq->resize_buf->buf;
830 			cq->ibcq.cqe = cq->resize_buf->cqe;
831 		} else {
832 			tbuf = cq->resize_buf->buf;
833 			tcqe = cq->resize_buf->cqe;
834 		}
835 
836 		kfree(cq->resize_buf);
837 		cq->resize_buf = NULL;
838 		spin_unlock_irq(&cq->lock);
839 
840 		mthca_free_cq_buf(dev, &tbuf, tcqe);
841 	} else
842 		ibcq->cqe = entries - 1;
843 
844 out:
845 	mutex_unlock(&cq->mutex);
846 
847 	return ret;
848 }
849 
850 static int mthca_destroy_cq(struct ib_cq *cq)
851 {
852 	if (cq->uobject) {
853 		mthca_unmap_user_db(to_mdev(cq->device),
854 				    &to_mucontext(cq->uobject->context)->uar,
855 				    to_mucontext(cq->uobject->context)->db_tab,
856 				    to_mcq(cq)->arm_db_index);
857 		mthca_unmap_user_db(to_mdev(cq->device),
858 				    &to_mucontext(cq->uobject->context)->uar,
859 				    to_mucontext(cq->uobject->context)->db_tab,
860 				    to_mcq(cq)->set_ci_db_index);
861 	}
862 	mthca_free_cq(to_mdev(cq->device), to_mcq(cq));
863 	kfree(cq);
864 
865 	return 0;
866 }
867 
868 static inline u32 convert_access(int acc)
869 {
870 	return (acc & IB_ACCESS_REMOTE_ATOMIC ? MTHCA_MPT_FLAG_ATOMIC       : 0) |
871 	       (acc & IB_ACCESS_REMOTE_WRITE  ? MTHCA_MPT_FLAG_REMOTE_WRITE : 0) |
872 	       (acc & IB_ACCESS_REMOTE_READ   ? MTHCA_MPT_FLAG_REMOTE_READ  : 0) |
873 	       (acc & IB_ACCESS_LOCAL_WRITE   ? MTHCA_MPT_FLAG_LOCAL_WRITE  : 0) |
874 	       MTHCA_MPT_FLAG_LOCAL_READ;
875 }
876 
877 static struct ib_mr *mthca_get_dma_mr(struct ib_pd *pd, int acc)
878 {
879 	struct mthca_mr *mr;
880 	int err;
881 
882 	mr = kmalloc(sizeof *mr, GFP_KERNEL);
883 	if (!mr)
884 		return ERR_PTR(-ENOMEM);
885 
886 	err = mthca_mr_alloc_notrans(to_mdev(pd->device),
887 				     to_mpd(pd)->pd_num,
888 				     convert_access(acc), mr);
889 
890 	if (err) {
891 		kfree(mr);
892 		return ERR_PTR(err);
893 	}
894 
895 	mr->umem = NULL;
896 
897 	return &mr->ibmr;
898 }
899 
900 static struct ib_mr *mthca_reg_phys_mr(struct ib_pd       *pd,
901 				       struct ib_phys_buf *buffer_list,
902 				       int                 num_phys_buf,
903 				       int                 acc,
904 				       u64                *iova_start)
905 {
906 	struct mthca_mr *mr;
907 	u64 *page_list;
908 	u64 total_size;
909 	unsigned long mask;
910 	int shift;
911 	int npages;
912 	int err;
913 	int i, j, n;
914 
915 	mask = buffer_list[0].addr ^ *iova_start;
916 	total_size = 0;
917 	for (i = 0; i < num_phys_buf; ++i) {
918 		if (i != 0)
919 			mask |= buffer_list[i].addr;
920 		if (i != num_phys_buf - 1)
921 			mask |= buffer_list[i].addr + buffer_list[i].size;
922 
923 		total_size += buffer_list[i].size;
924 	}
925 
926 	if (mask & ~PAGE_MASK)
927 		return ERR_PTR(-EINVAL);
928 
929 	shift = __ffs(mask | 1 << 31);
930 
931 	buffer_list[0].size += buffer_list[0].addr & ((1ULL << shift) - 1);
932 	buffer_list[0].addr &= ~0ull << shift;
933 
934 	mr = kmalloc(sizeof *mr, GFP_KERNEL);
935 	if (!mr)
936 		return ERR_PTR(-ENOMEM);
937 
938 	npages = 0;
939 	for (i = 0; i < num_phys_buf; ++i)
940 		npages += (buffer_list[i].size + (1ULL << shift) - 1) >> shift;
941 
942 	if (!npages)
943 		return &mr->ibmr;
944 
945 	page_list = kmalloc(npages * sizeof *page_list, GFP_KERNEL);
946 	if (!page_list) {
947 		kfree(mr);
948 		return ERR_PTR(-ENOMEM);
949 	}
950 
951 	n = 0;
952 	for (i = 0; i < num_phys_buf; ++i)
953 		for (j = 0;
954 		     j < (buffer_list[i].size + (1ULL << shift) - 1) >> shift;
955 		     ++j)
956 			page_list[n++] = buffer_list[i].addr + ((u64) j << shift);
957 
958 	mthca_dbg(to_mdev(pd->device), "Registering memory at %llx (iova %llx) "
959 		  "in PD %x; shift %d, npages %d.\n",
960 		  (unsigned long long) buffer_list[0].addr,
961 		  (unsigned long long) *iova_start,
962 		  to_mpd(pd)->pd_num,
963 		  shift, npages);
964 
965 	err = mthca_mr_alloc_phys(to_mdev(pd->device),
966 				  to_mpd(pd)->pd_num,
967 				  page_list, shift, npages,
968 				  *iova_start, total_size,
969 				  convert_access(acc), mr);
970 
971 	if (err) {
972 		kfree(page_list);
973 		kfree(mr);
974 		return ERR_PTR(err);
975 	}
976 
977 	kfree(page_list);
978 	mr->umem = NULL;
979 
980 	return &mr->ibmr;
981 }
982 
983 static struct ib_mr *mthca_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
984 				       u64 virt, int acc, struct ib_udata *udata)
985 {
986 	struct mthca_dev *dev = to_mdev(pd->device);
987 	struct scatterlist *sg;
988 	struct mthca_mr *mr;
989 	struct mthca_reg_mr ucmd;
990 	u64 *pages;
991 	int shift, n, len;
992 	int i, k, entry;
993 	int err = 0;
994 	int write_mtt_size;
995 
996 	if (udata->inlen - sizeof (struct ib_uverbs_cmd_hdr) < sizeof ucmd) {
997 		if (!to_mucontext(pd->uobject->context)->reg_mr_warned) {
998 			mthca_warn(dev, "Process '%s' did not pass in MR attrs.\n",
999 				   current->comm);
1000 			mthca_warn(dev, "  Update libmthca to fix this.\n");
1001 		}
1002 		++to_mucontext(pd->uobject->context)->reg_mr_warned;
1003 		ucmd.mr_attrs = 0;
1004 	} else if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd))
1005 		return ERR_PTR(-EFAULT);
1006 
1007 	mr = kmalloc(sizeof *mr, GFP_KERNEL);
1008 	if (!mr)
1009 		return ERR_PTR(-ENOMEM);
1010 
1011 	mr->umem = ib_umem_get(pd->uobject->context, start, length, acc,
1012 			       ucmd.mr_attrs & MTHCA_MR_DMASYNC);
1013 
1014 	if (IS_ERR(mr->umem)) {
1015 		err = PTR_ERR(mr->umem);
1016 		goto err;
1017 	}
1018 
1019 	shift = ffs(mr->umem->page_size) - 1;
1020 	n = mr->umem->nmap;
1021 
1022 	mr->mtt = mthca_alloc_mtt(dev, n);
1023 	if (IS_ERR(mr->mtt)) {
1024 		err = PTR_ERR(mr->mtt);
1025 		goto err_umem;
1026 	}
1027 
1028 	pages = (u64 *) __get_free_page(GFP_KERNEL);
1029 	if (!pages) {
1030 		err = -ENOMEM;
1031 		goto err_mtt;
1032 	}
1033 
1034 	i = n = 0;
1035 
1036 	write_mtt_size = min(mthca_write_mtt_size(dev), (int) (PAGE_SIZE / sizeof *pages));
1037 
1038 	for_each_sg(mr->umem->sg_head.sgl, sg, mr->umem->nmap, entry) {
1039 		len = sg_dma_len(sg) >> shift;
1040 		for (k = 0; k < len; ++k) {
1041 			pages[i++] = sg_dma_address(sg) +
1042 				mr->umem->page_size * k;
1043 			/*
1044 			 * Be friendly to write_mtt and pass it chunks
1045 			 * of appropriate size.
1046 			 */
1047 			if (i == write_mtt_size) {
1048 				err = mthca_write_mtt(dev, mr->mtt, n, pages, i);
1049 				if (err)
1050 					goto mtt_done;
1051 				n += i;
1052 				i = 0;
1053 			}
1054 		}
1055 	}
1056 
1057 	if (i)
1058 		err = mthca_write_mtt(dev, mr->mtt, n, pages, i);
1059 mtt_done:
1060 	free_page((unsigned long) pages);
1061 	if (err)
1062 		goto err_mtt;
1063 
1064 	err = mthca_mr_alloc(dev, to_mpd(pd)->pd_num, shift, virt, length,
1065 			     convert_access(acc), mr);
1066 
1067 	if (err)
1068 		goto err_mtt;
1069 
1070 	return &mr->ibmr;
1071 
1072 err_mtt:
1073 	mthca_free_mtt(dev, mr->mtt);
1074 
1075 err_umem:
1076 	ib_umem_release(mr->umem);
1077 
1078 err:
1079 	kfree(mr);
1080 	return ERR_PTR(err);
1081 }
1082 
1083 static int mthca_dereg_mr(struct ib_mr *mr)
1084 {
1085 	struct mthca_mr *mmr = to_mmr(mr);
1086 
1087 	mthca_free_mr(to_mdev(mr->device), mmr);
1088 	if (mmr->umem)
1089 		ib_umem_release(mmr->umem);
1090 	kfree(mmr);
1091 
1092 	return 0;
1093 }
1094 
1095 static struct ib_fmr *mthca_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
1096 				      struct ib_fmr_attr *fmr_attr)
1097 {
1098 	struct mthca_fmr *fmr;
1099 	int err;
1100 
1101 	fmr = kmalloc(sizeof *fmr, GFP_KERNEL);
1102 	if (!fmr)
1103 		return ERR_PTR(-ENOMEM);
1104 
1105 	memcpy(&fmr->attr, fmr_attr, sizeof *fmr_attr);
1106 	err = mthca_fmr_alloc(to_mdev(pd->device), to_mpd(pd)->pd_num,
1107 			     convert_access(mr_access_flags), fmr);
1108 
1109 	if (err) {
1110 		kfree(fmr);
1111 		return ERR_PTR(err);
1112 	}
1113 
1114 	return &fmr->ibmr;
1115 }
1116 
1117 static int mthca_dealloc_fmr(struct ib_fmr *fmr)
1118 {
1119 	struct mthca_fmr *mfmr = to_mfmr(fmr);
1120 	int err;
1121 
1122 	err = mthca_free_fmr(to_mdev(fmr->device), mfmr);
1123 	if (err)
1124 		return err;
1125 
1126 	kfree(mfmr);
1127 	return 0;
1128 }
1129 
1130 static int mthca_unmap_fmr(struct list_head *fmr_list)
1131 {
1132 	struct ib_fmr *fmr;
1133 	int err;
1134 	struct mthca_dev *mdev = NULL;
1135 
1136 	list_for_each_entry(fmr, fmr_list, list) {
1137 		if (mdev && to_mdev(fmr->device) != mdev)
1138 			return -EINVAL;
1139 		mdev = to_mdev(fmr->device);
1140 	}
1141 
1142 	if (!mdev)
1143 		return 0;
1144 
1145 	if (mthca_is_memfree(mdev)) {
1146 		list_for_each_entry(fmr, fmr_list, list)
1147 			mthca_arbel_fmr_unmap(mdev, to_mfmr(fmr));
1148 
1149 		wmb();
1150 	} else
1151 		list_for_each_entry(fmr, fmr_list, list)
1152 			mthca_tavor_fmr_unmap(mdev, to_mfmr(fmr));
1153 
1154 	err = mthca_SYNC_TPT(mdev);
1155 	return err;
1156 }
1157 
1158 static ssize_t show_rev(struct device *device, struct device_attribute *attr,
1159 			char *buf)
1160 {
1161 	struct mthca_dev *dev =
1162 		container_of(device, struct mthca_dev, ib_dev.dev);
1163 	return sprintf(buf, "%x\n", dev->rev_id);
1164 }
1165 
1166 static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr,
1167 			   char *buf)
1168 {
1169 	struct mthca_dev *dev =
1170 		container_of(device, struct mthca_dev, ib_dev.dev);
1171 	return sprintf(buf, "%d.%d.%d\n", (int) (dev->fw_ver >> 32),
1172 		       (int) (dev->fw_ver >> 16) & 0xffff,
1173 		       (int) dev->fw_ver & 0xffff);
1174 }
1175 
1176 static ssize_t show_hca(struct device *device, struct device_attribute *attr,
1177 			char *buf)
1178 {
1179 	struct mthca_dev *dev =
1180 		container_of(device, struct mthca_dev, ib_dev.dev);
1181 	switch (dev->pdev->device) {
1182 	case PCI_DEVICE_ID_MELLANOX_TAVOR:
1183 		return sprintf(buf, "MT23108\n");
1184 	case PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT:
1185 		return sprintf(buf, "MT25208 (MT23108 compat mode)\n");
1186 	case PCI_DEVICE_ID_MELLANOX_ARBEL:
1187 		return sprintf(buf, "MT25208\n");
1188 	case PCI_DEVICE_ID_MELLANOX_SINAI:
1189 	case PCI_DEVICE_ID_MELLANOX_SINAI_OLD:
1190 		return sprintf(buf, "MT25204\n");
1191 	default:
1192 		return sprintf(buf, "unknown\n");
1193 	}
1194 }
1195 
1196 static ssize_t show_board(struct device *device, struct device_attribute *attr,
1197 			  char *buf)
1198 {
1199 	struct mthca_dev *dev =
1200 		container_of(device, struct mthca_dev, ib_dev.dev);
1201 	return sprintf(buf, "%.*s\n", MTHCA_BOARD_ID_LEN, dev->board_id);
1202 }
1203 
1204 static DEVICE_ATTR(hw_rev,   S_IRUGO, show_rev,    NULL);
1205 static DEVICE_ATTR(fw_ver,   S_IRUGO, show_fw_ver, NULL);
1206 static DEVICE_ATTR(hca_type, S_IRUGO, show_hca,    NULL);
1207 static DEVICE_ATTR(board_id, S_IRUGO, show_board,  NULL);
1208 
1209 static struct device_attribute *mthca_dev_attributes[] = {
1210 	&dev_attr_hw_rev,
1211 	&dev_attr_fw_ver,
1212 	&dev_attr_hca_type,
1213 	&dev_attr_board_id
1214 };
1215 
1216 static int mthca_init_node_data(struct mthca_dev *dev)
1217 {
1218 	struct ib_smp *in_mad  = NULL;
1219 	struct ib_smp *out_mad = NULL;
1220 	int err = -ENOMEM;
1221 
1222 	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
1223 	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
1224 	if (!in_mad || !out_mad)
1225 		goto out;
1226 
1227 	init_query_mad(in_mad);
1228 	in_mad->attr_id = IB_SMP_ATTR_NODE_DESC;
1229 
1230 	err = mthca_MAD_IFC(dev, 1, 1,
1231 			    1, NULL, NULL, in_mad, out_mad);
1232 	if (err)
1233 		goto out;
1234 
1235 	memcpy(dev->ib_dev.node_desc, out_mad->data, 64);
1236 
1237 	in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
1238 
1239 	err = mthca_MAD_IFC(dev, 1, 1,
1240 			    1, NULL, NULL, in_mad, out_mad);
1241 	if (err)
1242 		goto out;
1243 
1244 	if (mthca_is_memfree(dev))
1245 		dev->rev_id = be32_to_cpup((__be32 *) (out_mad->data + 32));
1246 	memcpy(&dev->ib_dev.node_guid, out_mad->data + 12, 8);
1247 
1248 out:
1249 	kfree(in_mad);
1250 	kfree(out_mad);
1251 	return err;
1252 }
1253 
1254 static int mthca_port_immutable(struct ib_device *ibdev, u8 port_num,
1255 			        struct ib_port_immutable *immutable)
1256 {
1257 	struct ib_port_attr attr;
1258 	int err;
1259 
1260 	err = mthca_query_port(ibdev, port_num, &attr);
1261 	if (err)
1262 		return err;
1263 
1264 	immutable->pkey_tbl_len = attr.pkey_tbl_len;
1265 	immutable->gid_tbl_len = attr.gid_tbl_len;
1266 	immutable->core_cap_flags = RDMA_CORE_PORT_IBA_IB;
1267 	immutable->max_mad_size = IB_MGMT_MAD_SIZE;
1268 
1269 	return 0;
1270 }
1271 
1272 int mthca_register_device(struct mthca_dev *dev)
1273 {
1274 	int ret;
1275 	int i;
1276 
1277 	ret = mthca_init_node_data(dev);
1278 	if (ret)
1279 		return ret;
1280 
1281 	strlcpy(dev->ib_dev.name, "mthca%d", IB_DEVICE_NAME_MAX);
1282 	dev->ib_dev.owner                = THIS_MODULE;
1283 
1284 	dev->ib_dev.uverbs_abi_ver	 = MTHCA_UVERBS_ABI_VERSION;
1285 	dev->ib_dev.uverbs_cmd_mask	 =
1286 		(1ull << IB_USER_VERBS_CMD_GET_CONTEXT)		|
1287 		(1ull << IB_USER_VERBS_CMD_QUERY_DEVICE)	|
1288 		(1ull << IB_USER_VERBS_CMD_QUERY_PORT)		|
1289 		(1ull << IB_USER_VERBS_CMD_ALLOC_PD)		|
1290 		(1ull << IB_USER_VERBS_CMD_DEALLOC_PD)		|
1291 		(1ull << IB_USER_VERBS_CMD_REG_MR)		|
1292 		(1ull << IB_USER_VERBS_CMD_DEREG_MR)		|
1293 		(1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL)	|
1294 		(1ull << IB_USER_VERBS_CMD_CREATE_CQ)		|
1295 		(1ull << IB_USER_VERBS_CMD_RESIZE_CQ)		|
1296 		(1ull << IB_USER_VERBS_CMD_DESTROY_CQ)		|
1297 		(1ull << IB_USER_VERBS_CMD_CREATE_QP)		|
1298 		(1ull << IB_USER_VERBS_CMD_QUERY_QP)		|
1299 		(1ull << IB_USER_VERBS_CMD_MODIFY_QP)		|
1300 		(1ull << IB_USER_VERBS_CMD_DESTROY_QP)		|
1301 		(1ull << IB_USER_VERBS_CMD_ATTACH_MCAST)	|
1302 		(1ull << IB_USER_VERBS_CMD_DETACH_MCAST);
1303 	dev->ib_dev.node_type            = RDMA_NODE_IB_CA;
1304 	dev->ib_dev.phys_port_cnt        = dev->limits.num_ports;
1305 	dev->ib_dev.num_comp_vectors     = 1;
1306 	dev->ib_dev.dma_device           = &dev->pdev->dev;
1307 	dev->ib_dev.query_device         = mthca_query_device;
1308 	dev->ib_dev.query_port           = mthca_query_port;
1309 	dev->ib_dev.modify_device        = mthca_modify_device;
1310 	dev->ib_dev.modify_port          = mthca_modify_port;
1311 	dev->ib_dev.query_pkey           = mthca_query_pkey;
1312 	dev->ib_dev.query_gid            = mthca_query_gid;
1313 	dev->ib_dev.alloc_ucontext       = mthca_alloc_ucontext;
1314 	dev->ib_dev.dealloc_ucontext     = mthca_dealloc_ucontext;
1315 	dev->ib_dev.mmap                 = mthca_mmap_uar;
1316 	dev->ib_dev.alloc_pd             = mthca_alloc_pd;
1317 	dev->ib_dev.dealloc_pd           = mthca_dealloc_pd;
1318 	dev->ib_dev.create_ah            = mthca_ah_create;
1319 	dev->ib_dev.query_ah             = mthca_ah_query;
1320 	dev->ib_dev.destroy_ah           = mthca_ah_destroy;
1321 
1322 	if (dev->mthca_flags & MTHCA_FLAG_SRQ) {
1323 		dev->ib_dev.create_srq           = mthca_create_srq;
1324 		dev->ib_dev.modify_srq           = mthca_modify_srq;
1325 		dev->ib_dev.query_srq            = mthca_query_srq;
1326 		dev->ib_dev.destroy_srq          = mthca_destroy_srq;
1327 		dev->ib_dev.uverbs_cmd_mask	|=
1328 			(1ull << IB_USER_VERBS_CMD_CREATE_SRQ)		|
1329 			(1ull << IB_USER_VERBS_CMD_MODIFY_SRQ)		|
1330 			(1ull << IB_USER_VERBS_CMD_QUERY_SRQ)		|
1331 			(1ull << IB_USER_VERBS_CMD_DESTROY_SRQ);
1332 
1333 		if (mthca_is_memfree(dev))
1334 			dev->ib_dev.post_srq_recv = mthca_arbel_post_srq_recv;
1335 		else
1336 			dev->ib_dev.post_srq_recv = mthca_tavor_post_srq_recv;
1337 	}
1338 
1339 	dev->ib_dev.create_qp            = mthca_create_qp;
1340 	dev->ib_dev.modify_qp            = mthca_modify_qp;
1341 	dev->ib_dev.query_qp             = mthca_query_qp;
1342 	dev->ib_dev.destroy_qp           = mthca_destroy_qp;
1343 	dev->ib_dev.create_cq            = mthca_create_cq;
1344 	dev->ib_dev.resize_cq            = mthca_resize_cq;
1345 	dev->ib_dev.destroy_cq           = mthca_destroy_cq;
1346 	dev->ib_dev.poll_cq              = mthca_poll_cq;
1347 	dev->ib_dev.get_dma_mr           = mthca_get_dma_mr;
1348 	dev->ib_dev.reg_phys_mr          = mthca_reg_phys_mr;
1349 	dev->ib_dev.reg_user_mr          = mthca_reg_user_mr;
1350 	dev->ib_dev.dereg_mr             = mthca_dereg_mr;
1351 	dev->ib_dev.get_port_immutable   = mthca_port_immutable;
1352 
1353 	if (dev->mthca_flags & MTHCA_FLAG_FMR) {
1354 		dev->ib_dev.alloc_fmr            = mthca_alloc_fmr;
1355 		dev->ib_dev.unmap_fmr            = mthca_unmap_fmr;
1356 		dev->ib_dev.dealloc_fmr          = mthca_dealloc_fmr;
1357 		if (mthca_is_memfree(dev))
1358 			dev->ib_dev.map_phys_fmr = mthca_arbel_map_phys_fmr;
1359 		else
1360 			dev->ib_dev.map_phys_fmr = mthca_tavor_map_phys_fmr;
1361 	}
1362 
1363 	dev->ib_dev.attach_mcast         = mthca_multicast_attach;
1364 	dev->ib_dev.detach_mcast         = mthca_multicast_detach;
1365 	dev->ib_dev.process_mad          = mthca_process_mad;
1366 
1367 	if (mthca_is_memfree(dev)) {
1368 		dev->ib_dev.req_notify_cq = mthca_arbel_arm_cq;
1369 		dev->ib_dev.post_send     = mthca_arbel_post_send;
1370 		dev->ib_dev.post_recv     = mthca_arbel_post_receive;
1371 	} else {
1372 		dev->ib_dev.req_notify_cq = mthca_tavor_arm_cq;
1373 		dev->ib_dev.post_send     = mthca_tavor_post_send;
1374 		dev->ib_dev.post_recv     = mthca_tavor_post_receive;
1375 	}
1376 
1377 	mutex_init(&dev->cap_mask_mutex);
1378 
1379 	ret = ib_register_device(&dev->ib_dev, NULL);
1380 	if (ret)
1381 		return ret;
1382 
1383 	for (i = 0; i < ARRAY_SIZE(mthca_dev_attributes); ++i) {
1384 		ret = device_create_file(&dev->ib_dev.dev,
1385 					 mthca_dev_attributes[i]);
1386 		if (ret) {
1387 			ib_unregister_device(&dev->ib_dev);
1388 			return ret;
1389 		}
1390 	}
1391 
1392 	mthca_start_catas_poll(dev);
1393 
1394 	return 0;
1395 }
1396 
1397 void mthca_unregister_device(struct mthca_dev *dev)
1398 {
1399 	mthca_stop_catas_poll(dev);
1400 	ib_unregister_device(&dev->ib_dev);
1401 }
1402