?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
IB/mthca: kzalloc conversions
[linux-2.6/libata-dev.git] / drivers / infiniband / hw / mthca / mthca_provider.c
blob0ae27fa26c7add03a137f1ce18dae9c34434cc96
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 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 * $Id: mthca_provider.c 1397 2004-12-28 05:09:00Z roland $
37 */
38
39 #include <rdma/ib_smi.h>
40 #include <rdma/ib_user_verbs.h>
41 #include <linux/mm.h>
42
43 #include "mthca_dev.h"
44 #include "mthca_cmd.h"
45 #include "mthca_user.h"
46 #include "mthca_memfree.h"
47
48 static int mthca_query_device(struct ib_device *ibdev,
49 struct ib_device_attr *props)
50 {
51 struct ib_smp *in_mad = NULL;
52 struct ib_smp *out_mad = NULL;
53 int err = -ENOMEM;
54 struct mthca_dev* mdev = to_mdev(ibdev);
55
56 u8 status;
57
58 in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
59 out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
60 if (!in_mad || !out_mad)
61 goto out;
62
63 memset(props, 0, sizeof *props);
64
65 props->fw_ver = mdev->fw_ver;
66
67 in_mad->base_version = 1;
68 in_mad->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
69 in_mad->class_version = 1;
70 in_mad->method = IB_MGMT_METHOD_GET;
71 in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
72
73 err = mthca_MAD_IFC(mdev, 1, 1,
74 1, NULL, NULL, in_mad, out_mad,
75 &status);
76 if (err)
77 goto out;
78 if (status) {
79 err = -EINVAL;
80 goto out;
81 }
82
83 props->device_cap_flags = mdev->device_cap_flags;
84 props->vendor_id = be32_to_cpup((__be32 *) (out_mad->data + 36)) &
85 0xffffff;
86 props->vendor_part_id = be16_to_cpup((__be16 *) (out_mad->data + 30));
87 props->hw_ver = be32_to_cpup((__be32 *) (out_mad->data + 32));
88 memcpy(&props->sys_image_guid, out_mad->data + 4, 8);
89 memcpy(&props->node_guid, out_mad->data + 12, 8);
90
91 props->max_mr_size = ~0ull;
92 props->page_size_cap = mdev->limits.page_size_cap;
93 props->max_qp = mdev->limits.num_qps - mdev->limits.reserved_qps;
94 props->max_qp_wr = mdev->limits.max_wqes;
95 props->max_sge = mdev->limits.max_sg;
96 props->max_cq = mdev->limits.num_cqs - mdev->limits.reserved_cqs;
97 props->max_cqe = mdev->limits.max_cqes;
98 props->max_mr = mdev->limits.num_mpts - mdev->limits.reserved_mrws;
99 props->max_pd = mdev->limits.num_pds - mdev->limits.reserved_pds;
100 props->max_qp_rd_atom = 1 << mdev->qp_table.rdb_shift;
101 props->max_qp_init_rd_atom = mdev->limits.max_qp_init_rdma;
102 props->max_res_rd_atom = props->max_qp_rd_atom * props->max_qp;
103 props->max_srq = mdev->limits.num_srqs - mdev->limits.reserved_srqs;
104 props->max_srq_wr = mdev->limits.max_srq_wqes;
105 props->max_srq_sge = mdev->limits.max_sg;
106 props->local_ca_ack_delay = mdev->limits.local_ca_ack_delay;
107 props->atomic_cap = mdev->limits.flags & DEV_LIM_FLAG_ATOMIC ?
108 IB_ATOMIC_HCA : IB_ATOMIC_NONE;
109 props->max_pkeys = mdev->limits.pkey_table_len;
110 props->max_mcast_grp = mdev->limits.num_mgms + mdev->limits.num_amgms;
111 props->max_mcast_qp_attach = MTHCA_QP_PER_MGM;
112 props->max_total_mcast_qp_attach = props->max_mcast_qp_attach *
113 props->max_mcast_grp;
114
115 err = 0;
116 out:
117 kfree(in_mad);
118 kfree(out_mad);
119 return err;
120 }
121
122 static int mthca_query_port(struct ib_device *ibdev,
123 u8 port, struct ib_port_attr *props)
124 {
125 struct ib_smp *in_mad = NULL;
126 struct ib_smp *out_mad = NULL;
127 int err = -ENOMEM;
128 u8 status;
129
130 in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
131 out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
132 if (!in_mad || !out_mad)
133 goto out;
134
135 memset(props, 0, sizeof *props);
136
137 in_mad->base_version = 1;
138 in_mad->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
139 in_mad->class_version = 1;
140 in_mad->method = IB_MGMT_METHOD_GET;
141 in_mad->attr_id = IB_SMP_ATTR_PORT_INFO;
142 in_mad->attr_mod = cpu_to_be32(port);
143
144 err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
145 port, NULL, NULL, in_mad, out_mad,
146 &status);
147 if (err)
148 goto out;
149 if (status) {
150 err = -EINVAL;
151 goto out;
152 }
153
154 props->lid = be16_to_cpup((__be16 *) (out_mad->data + 16));
155 props->lmc = out_mad->data[34] & 0x7;
156 props->sm_lid = be16_to_cpup((__be16 *) (out_mad->data + 18));
157 props->sm_sl = out_mad->data[36] & 0xf;
158 props->state = out_mad->data[32] & 0xf;
159 props->phys_state = out_mad->data[33] >> 4;
160 props->port_cap_flags = be32_to_cpup((__be32 *) (out_mad->data + 20));
161 props->gid_tbl_len = to_mdev(ibdev)->limits.gid_table_len;
162 props->max_msg_sz = 0x80000000;
163 props->pkey_tbl_len = to_mdev(ibdev)->limits.pkey_table_len;
164 props->bad_pkey_cntr = be16_to_cpup((__be16 *) (out_mad->data + 46));
165 props->qkey_viol_cntr = be16_to_cpup((__be16 *) (out_mad->data + 48));
166 props->active_width = out_mad->data[31] & 0xf;
167 props->active_speed = out_mad->data[35] >> 4;
168 props->max_mtu = out_mad->data[41] & 0xf;
169 props->active_mtu = out_mad->data[36] >> 4;
170 props->subnet_timeout = out_mad->data[51] & 0x1f;
171
172 out:
173 kfree(in_mad);
174 kfree(out_mad);
175 return err;
176 }
177
178 static int mthca_modify_port(struct ib_device *ibdev,
179 u8 port, int port_modify_mask,
180 struct ib_port_modify *props)
181 {
182 struct mthca_set_ib_param set_ib;
183 struct ib_port_attr attr;
184 int err;
185 u8 status;
186
187 if (down_interruptible(&to_mdev(ibdev)->cap_mask_mutex))
188 return -ERESTARTSYS;
189
190 err = mthca_query_port(ibdev, port, &attr);
191 if (err)
192 goto out;
193
194 set_ib.set_si_guid = 0;
195 set_ib.reset_qkey_viol = !!(port_modify_mask & IB_PORT_RESET_QKEY_CNTR);
196
197 set_ib.cap_mask = (attr.port_cap_flags | props->set_port_cap_mask) &
198 ~props->clr_port_cap_mask;
199
200 err = mthca_SET_IB(to_mdev(ibdev), &set_ib, port, &status);
201 if (err)
202 goto out;
203 if (status) {
204 err = -EINVAL;
205 goto out;
206 }
207
208 out:
209 up(&to_mdev(ibdev)->cap_mask_mutex);
210 return err;
211 }
212
213 static int mthca_query_pkey(struct ib_device *ibdev,
214 u8 port, u16 index, u16 *pkey)
215 {
216 struct ib_smp *in_mad = NULL;
217 struct ib_smp *out_mad = NULL;
218 int err = -ENOMEM;
219 u8 status;
220
221 in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
222 out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
223 if (!in_mad || !out_mad)
224 goto out;
225
226 in_mad->base_version = 1;
227 in_mad->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
228 in_mad->class_version = 1;
229 in_mad->method = IB_MGMT_METHOD_GET;
230 in_mad->attr_id = IB_SMP_ATTR_PKEY_TABLE;
231 in_mad->attr_mod = cpu_to_be32(index / 32);
232
233 err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
234 port, NULL, NULL, in_mad, out_mad,
235 &status);
236 if (err)
237 goto out;
238 if (status) {
239 err = -EINVAL;
240 goto out;
241 }
242
243 *pkey = be16_to_cpu(((__be16 *) out_mad->data)[index % 32]);
244
245 out:
246 kfree(in_mad);
247 kfree(out_mad);
248 return err;
249 }
250
251 static int mthca_query_gid(struct ib_device *ibdev, u8 port,
252 int index, union ib_gid *gid)
253 {
254 struct ib_smp *in_mad = NULL;
255 struct ib_smp *out_mad = NULL;
256 int err = -ENOMEM;
257 u8 status;
258
259 in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
260 out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
261 if (!in_mad || !out_mad)
262 goto out;
263
264 in_mad->base_version = 1;
265 in_mad->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
266 in_mad->class_version = 1;
267 in_mad->method = IB_MGMT_METHOD_GET;
268 in_mad->attr_id = IB_SMP_ATTR_PORT_INFO;
269 in_mad->attr_mod = cpu_to_be32(port);
270
271 err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
272 port, NULL, NULL, in_mad, out_mad,
273 &status);
274 if (err)
275 goto out;
276 if (status) {
277 err = -EINVAL;
278 goto out;
279 }
280
281 memcpy(gid->raw, out_mad->data + 8, 8);
282
283 memset(in_mad, 0, sizeof *in_mad);
284 in_mad->base_version = 1;
285 in_mad->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
286 in_mad->class_version = 1;
287 in_mad->method = IB_MGMT_METHOD_GET;
288 in_mad->attr_id = IB_SMP_ATTR_GUID_INFO;
289 in_mad->attr_mod = cpu_to_be32(index / 8);
290
291 err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
292 port, NULL, NULL, in_mad, out_mad,
293 &status);
294 if (err)
295 goto out;
296 if (status) {
297 err = -EINVAL;
298 goto out;
299 }
300
301 memcpy(gid->raw + 8, out_mad->data + (index % 8) * 16, 8);
302
303 out:
304 kfree(in_mad);
305 kfree(out_mad);
306 return err;
307 }
308
309 static struct ib_ucontext *mthca_alloc_ucontext(struct ib_device *ibdev,
310 struct ib_udata *udata)
311 {
312 struct mthca_alloc_ucontext_resp uresp;
313 struct mthca_ucontext *context;
314 int err;
315
316 memset(&uresp, 0, sizeof uresp);
317
318 uresp.qp_tab_size = to_mdev(ibdev)->limits.num_qps;
319 if (mthca_is_memfree(to_mdev(ibdev)))
320 uresp.uarc_size = to_mdev(ibdev)->uar_table.uarc_size;
321 else
322 uresp.uarc_size = 0;
323
324 context = kmalloc(sizeof *context, GFP_KERNEL);
325 if (!context)
326 return ERR_PTR(-ENOMEM);
327
328 err = mthca_uar_alloc(to_mdev(ibdev), &context->uar);
329 if (err) {
330 kfree(context);
331 return ERR_PTR(err);
332 }
333
334 context->db_tab = mthca_init_user_db_tab(to_mdev(ibdev));
335 if (IS_ERR(context->db_tab)) {
336 err = PTR_ERR(context->db_tab);
337 mthca_uar_free(to_mdev(ibdev), &context->uar);
338 kfree(context);
339 return ERR_PTR(err);
340 }
341
342 if (ib_copy_to_udata(udata, &uresp, sizeof uresp)) {
343 mthca_cleanup_user_db_tab(to_mdev(ibdev), &context->uar, context->db_tab);
344 mthca_uar_free(to_mdev(ibdev), &context->uar);
345 kfree(context);
346 return ERR_PTR(-EFAULT);
347 }
348
349 return &context->ibucontext;
350 }
351
352 static int mthca_dealloc_ucontext(struct ib_ucontext *context)
353 {
354 mthca_cleanup_user_db_tab(to_mdev(context->device), &to_mucontext(context)->uar,
355 to_mucontext(context)->db_tab);
356 mthca_uar_free(to_mdev(context->device), &to_mucontext(context)->uar);
357 kfree(to_mucontext(context));
358
359 return 0;
360 }
361
362 static int mthca_mmap_uar(struct ib_ucontext *context,
363 struct vm_area_struct *vma)
364 {
365 if (vma->vm_end - vma->vm_start != PAGE_SIZE)
366 return -EINVAL;
367
368 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
369
370 if (io_remap_pfn_range(vma, vma->vm_start,
371 to_mucontext(context)->uar.pfn,
372 PAGE_SIZE, vma->vm_page_prot))
373 return -EAGAIN;
374
375 return 0;
376 }
377
378 static struct ib_pd *mthca_alloc_pd(struct ib_device *ibdev,
379 struct ib_ucontext *context,
380 struct ib_udata *udata)
381 {
382 struct mthca_pd *pd;
383 int err;
384
385 pd = kmalloc(sizeof *pd, GFP_KERNEL);
386 if (!pd)
387 return ERR_PTR(-ENOMEM);
388
389 err = mthca_pd_alloc(to_mdev(ibdev), !context, pd);
390 if (err) {
391 kfree(pd);
392 return ERR_PTR(err);
393 }
394
395 if (context) {
396 if (ib_copy_to_udata(udata, &pd->pd_num, sizeof (__u32))) {
397 mthca_pd_free(to_mdev(ibdev), pd);
398 kfree(pd);
399 return ERR_PTR(-EFAULT);
400 }
401 }
402
403 return &pd->ibpd;
404 }
405
406 static int mthca_dealloc_pd(struct ib_pd *pd)
407 {
408 mthca_pd_free(to_mdev(pd->device), to_mpd(pd));
409 kfree(pd);
410
411 return 0;
412 }
413
414 static struct ib_ah *mthca_ah_create(struct ib_pd *pd,
415 struct ib_ah_attr *ah_attr)
416 {
417 int err;
418 struct mthca_ah *ah;
419
420 ah = kmalloc(sizeof *ah, GFP_ATOMIC);
421 if (!ah)
422 return ERR_PTR(-ENOMEM);
423
424 err = mthca_create_ah(to_mdev(pd->device), to_mpd(pd), ah_attr, ah);
425 if (err) {
426 kfree(ah);
427 return ERR_PTR(err);
428 }
429
430 return &ah->ibah;
431 }
432
433 static int mthca_ah_destroy(struct ib_ah *ah)
434 {
435 mthca_destroy_ah(to_mdev(ah->device), to_mah(ah));
436 kfree(ah);
437
438 return 0;
439 }
440
441 static struct ib_srq *mthca_create_srq(struct ib_pd *pd,
442 struct ib_srq_init_attr *init_attr,
443 struct ib_udata *udata)
444 {
445 struct mthca_create_srq ucmd;
446 struct mthca_ucontext *context = NULL;
447 struct mthca_srq *srq;
448 int err;
449
450 srq = kmalloc(sizeof *srq, GFP_KERNEL);
451 if (!srq)
452 return ERR_PTR(-ENOMEM);
453
454 if (pd->uobject) {
455 context = to_mucontext(pd->uobject->context);
456
457 if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd))
458 return ERR_PTR(-EFAULT);
459
460 err = mthca_map_user_db(to_mdev(pd->device), &context->uar,
461 context->db_tab, ucmd.db_index,
462 ucmd.db_page);
463
464 if (err)
465 goto err_free;
466
467 srq->mr.ibmr.lkey = ucmd.lkey;
468 srq->db_index = ucmd.db_index;
469 }
470
471 err = mthca_alloc_srq(to_mdev(pd->device), to_mpd(pd),
472 &init_attr->attr, srq);
473
474 if (err && pd->uobject)
475 mthca_unmap_user_db(to_mdev(pd->device), &context->uar,
476 context->db_tab, ucmd.db_index);
477
478 if (err)
479 goto err_free;
480
481 if (context && ib_copy_to_udata(udata, &srq->srqn, sizeof (__u32))) {
482 mthca_free_srq(to_mdev(pd->device), srq);
483 err = -EFAULT;
484 goto err_free;
485 }
486
487 return &srq->ibsrq;
488
489 err_free:
490 kfree(srq);
491
492 return ERR_PTR(err);
493 }
494
495 static int mthca_destroy_srq(struct ib_srq *srq)
496 {
497 struct mthca_ucontext *context;
498
499 if (srq->uobject) {
500 context = to_mucontext(srq->uobject->context);
501
502 mthca_unmap_user_db(to_mdev(srq->device), &context->uar,
503 context->db_tab, to_msrq(srq)->db_index);
504 }
505
506 mthca_free_srq(to_mdev(srq->device), to_msrq(srq));
507 kfree(srq);
508
509 return 0;
510 }
511
512 static struct ib_qp *mthca_create_qp(struct ib_pd *pd,
513 struct ib_qp_init_attr *init_attr,
514 struct ib_udata *udata)
515 {
516 struct mthca_create_qp ucmd;
517 struct mthca_qp *qp;
518 int err;
519
520 switch (init_attr->qp_type) {
521 case IB_QPT_RC:
522 case IB_QPT_UC:
523 case IB_QPT_UD:
524 {
525 struct mthca_ucontext *context;
526
527 qp = kmalloc(sizeof *qp, GFP_KERNEL);
528 if (!qp)
529 return ERR_PTR(-ENOMEM);
530
531 if (pd->uobject) {
532 context = to_mucontext(pd->uobject->context);
533
534 if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd))
535 return ERR_PTR(-EFAULT);
536
537 err = mthca_map_user_db(to_mdev(pd->device), &context->uar,
538 context->db_tab,
539 ucmd.sq_db_index, ucmd.sq_db_page);
540 if (err) {
541 kfree(qp);
542 return ERR_PTR(err);
543 }
544
545 err = mthca_map_user_db(to_mdev(pd->device), &context->uar,
546 context->db_tab,
547 ucmd.rq_db_index, ucmd.rq_db_page);
548 if (err) {
549 mthca_unmap_user_db(to_mdev(pd->device),
550 &context->uar,
551 context->db_tab,
552 ucmd.sq_db_index);
553 kfree(qp);
554 return ERR_PTR(err);
555 }
556
557 qp->mr.ibmr.lkey = ucmd.lkey;
558 qp->sq.db_index = ucmd.sq_db_index;
559 qp->rq.db_index = ucmd.rq_db_index;
560 }
561
562 err = mthca_alloc_qp(to_mdev(pd->device), to_mpd(pd),
563 to_mcq(init_attr->send_cq),
564 to_mcq(init_attr->recv_cq),
565 init_attr->qp_type, init_attr->sq_sig_type,
566 &init_attr->cap, qp);
567
568 if (err && pd->uobject) {
569 context = to_mucontext(pd->uobject->context);
570
571 mthca_unmap_user_db(to_mdev(pd->device),
572 &context->uar,
573 context->db_tab,
574 ucmd.sq_db_index);
575 mthca_unmap_user_db(to_mdev(pd->device),
576 &context->uar,
577 context->db_tab,
578 ucmd.rq_db_index);
579 }
580
581 qp->ibqp.qp_num = qp->qpn;
582 break;
583 }
584 case IB_QPT_SMI:
585 case IB_QPT_GSI:
586 {
587 /* Don't allow userspace to create special QPs */
588 if (pd->uobject)
589 return ERR_PTR(-EINVAL);
590
591 qp = kmalloc(sizeof (struct mthca_sqp), GFP_KERNEL);
592 if (!qp)
593 return ERR_PTR(-ENOMEM);
594
595 qp->ibqp.qp_num = init_attr->qp_type == IB_QPT_SMI ? 0 : 1;
596
597 err = mthca_alloc_sqp(to_mdev(pd->device), to_mpd(pd),
598 to_mcq(init_attr->send_cq),
599 to_mcq(init_attr->recv_cq),
600 init_attr->sq_sig_type, &init_attr->cap,
601 qp->ibqp.qp_num, init_attr->port_num,
602 to_msqp(qp));
603 break;
604 }
605 default:
606 /* Don't support raw QPs */
607 return ERR_PTR(-ENOSYS);
608 }
609
610 if (err) {
611 kfree(qp);
612 return ERR_PTR(err);
613 }
614
615 init_attr->cap.max_send_wr = qp->sq.max;
616 init_attr->cap.max_recv_wr = qp->rq.max;
617 init_attr->cap.max_send_sge = qp->sq.max_gs;
618 init_attr->cap.max_recv_sge = qp->rq.max_gs;
619 init_attr->cap.max_inline_data = qp->max_inline_data;
620
621 return &qp->ibqp;
622 }
623
624 static int mthca_destroy_qp(struct ib_qp *qp)
625 {
626 if (qp->uobject) {
627 mthca_unmap_user_db(to_mdev(qp->device),
628 &to_mucontext(qp->uobject->context)->uar,
629 to_mucontext(qp->uobject->context)->db_tab,
630 to_mqp(qp)->sq.db_index);
631 mthca_unmap_user_db(to_mdev(qp->device),
632 &to_mucontext(qp->uobject->context)->uar,
633 to_mucontext(qp->uobject->context)->db_tab,
634 to_mqp(qp)->rq.db_index);
635 }
636 mthca_free_qp(to_mdev(qp->device), to_mqp(qp));
637 kfree(qp);
638 return 0;
639 }
640
641 static struct ib_cq *mthca_create_cq(struct ib_device *ibdev, int entries,
642 struct ib_ucontext *context,
643 struct ib_udata *udata)
644 {
645 struct mthca_create_cq ucmd;
646 struct mthca_cq *cq;
647 int nent;
648 int err;
649
650 if (entries < 1 || entries > to_mdev(ibdev)->limits.max_cqes)
651 return ERR_PTR(-EINVAL);
652
653 if (context) {
654 if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd))
655 return ERR_PTR(-EFAULT);
656
657 err = mthca_map_user_db(to_mdev(ibdev), &to_mucontext(context)->uar,
658 to_mucontext(context)->db_tab,
659 ucmd.set_db_index, ucmd.set_db_page);
660 if (err)
661 return ERR_PTR(err);
662
663 err = mthca_map_user_db(to_mdev(ibdev), &to_mucontext(context)->uar,
664 to_mucontext(context)->db_tab,
665 ucmd.arm_db_index, ucmd.arm_db_page);
666 if (err)
667 goto err_unmap_set;
668 }
669
670 cq = kmalloc(sizeof *cq, GFP_KERNEL);
671 if (!cq) {
672 err = -ENOMEM;
673 goto err_unmap_arm;
674 }
675
676 if (context) {
677 cq->mr.ibmr.lkey = ucmd.lkey;
678 cq->set_ci_db_index = ucmd.set_db_index;
679 cq->arm_db_index = ucmd.arm_db_index;
680 }
681
682 for (nent = 1; nent <= entries; nent <<= 1)
683 ; /* nothing */
684
685 err = mthca_init_cq(to_mdev(ibdev), nent,
686 context ? to_mucontext(context) : NULL,
687 context ? ucmd.pdn : to_mdev(ibdev)->driver_pd.pd_num,
688 cq);
689 if (err)
690 goto err_free;
691
692 if (context && ib_copy_to_udata(udata, &cq->cqn, sizeof (__u32))) {
693 mthca_free_cq(to_mdev(ibdev), cq);
694 goto err_free;
695 }
696
697 return &cq->ibcq;
698
699 err_free:
700 kfree(cq);
701
702 err_unmap_arm:
703 if (context)
704 mthca_unmap_user_db(to_mdev(ibdev), &to_mucontext(context)->uar,
705 to_mucontext(context)->db_tab, ucmd.arm_db_index);
706
707 err_unmap_set:
708 if (context)
709 mthca_unmap_user_db(to_mdev(ibdev), &to_mucontext(context)->uar,
710 to_mucontext(context)->db_tab, ucmd.set_db_index);
711
712 return ERR_PTR(err);
713 }
714
715 static int mthca_destroy_cq(struct ib_cq *cq)
716 {
717 if (cq->uobject) {
718 mthca_unmap_user_db(to_mdev(cq->device),
719 &to_mucontext(cq->uobject->context)->uar,
720 to_mucontext(cq->uobject->context)->db_tab,
721 to_mcq(cq)->arm_db_index);
722 mthca_unmap_user_db(to_mdev(cq->device),
723 &to_mucontext(cq->uobject->context)->uar,
724 to_mucontext(cq->uobject->context)->db_tab,
725 to_mcq(cq)->set_ci_db_index);
726 }
727 mthca_free_cq(to_mdev(cq->device), to_mcq(cq));
728 kfree(cq);
729
730 return 0;
731 }
732
733 static inline u32 convert_access(int acc)
734 {
735 return (acc & IB_ACCESS_REMOTE_ATOMIC ? MTHCA_MPT_FLAG_ATOMIC : 0) |
736 (acc & IB_ACCESS_REMOTE_WRITE ? MTHCA_MPT_FLAG_REMOTE_WRITE : 0) |
737 (acc & IB_ACCESS_REMOTE_READ ? MTHCA_MPT_FLAG_REMOTE_READ : 0) |
738 (acc & IB_ACCESS_LOCAL_WRITE ? MTHCA_MPT_FLAG_LOCAL_WRITE : 0) |
739 MTHCA_MPT_FLAG_LOCAL_READ;
740 }
741
742 static struct ib_mr *mthca_get_dma_mr(struct ib_pd *pd, int acc)
743 {
744 struct mthca_mr *mr;
745 int err;
746
747 mr = kmalloc(sizeof *mr, GFP_KERNEL);
748 if (!mr)
749 return ERR_PTR(-ENOMEM);
750
751 err = mthca_mr_alloc_notrans(to_mdev(pd->device),
752 to_mpd(pd)->pd_num,
753 convert_access(acc), mr);
754
755 if (err) {
756 kfree(mr);
757 return ERR_PTR(err);
758 }
759
760 return &mr->ibmr;
761 }
762
763 static struct ib_mr *mthca_reg_phys_mr(struct ib_pd *pd,
764 struct ib_phys_buf *buffer_list,
765 int num_phys_buf,
766 int acc,
767 u64 *iova_start)
768 {
769 struct mthca_mr *mr;
770 u64 *page_list;
771 u64 total_size;
772 u64 mask;
773 int shift;
774 int npages;
775 int err;
776 int i, j, n;
777
778 /* First check that we have enough alignment */
779 if ((*iova_start & ~PAGE_MASK) != (buffer_list[0].addr & ~PAGE_MASK))
780 return ERR_PTR(-EINVAL);
781
782 mask = 0;
783 total_size = 0;
784 for (i = 0; i < num_phys_buf; ++i) {
785 if (i != 0)
786 mask |= buffer_list[i].addr;
787 if (i != num_phys_buf - 1)
788 mask |= buffer_list[i].addr + buffer_list[i].size;
789
790 total_size += buffer_list[i].size;
791 }
792
793 if (mask & ~PAGE_MASK)
794 return ERR_PTR(-EINVAL);
795
796 /* Find largest page shift we can use to cover buffers */
797 for (shift = PAGE_SHIFT; shift < 31; ++shift)
798 if (num_phys_buf > 1) {
799 if ((1ULL << shift) & mask)
800 break;
801 } else {
802 if (1ULL << shift >=
803 buffer_list[0].size +
804 (buffer_list[0].addr & ((1ULL << shift) - 1)))
805 break;
806 }
807
808 buffer_list[0].size += buffer_list[0].addr & ((1ULL << shift) - 1);
809 buffer_list[0].addr &= ~0ull << shift;
810
811 mr = kmalloc(sizeof *mr, GFP_KERNEL);
812 if (!mr)
813 return ERR_PTR(-ENOMEM);
814
815 npages = 0;
816 for (i = 0; i < num_phys_buf; ++i)
817 npages += (buffer_list[i].size + (1ULL << shift) - 1) >> shift;
818
819 if (!npages)
820 return &mr->ibmr;
821
822 page_list = kmalloc(npages * sizeof *page_list, GFP_KERNEL);
823 if (!page_list) {
824 kfree(mr);
825 return ERR_PTR(-ENOMEM);
826 }
827
828 n = 0;
829 for (i = 0; i < num_phys_buf; ++i)
830 for (j = 0;
831 j < (buffer_list[i].size + (1ULL << shift) - 1) >> shift;
832 ++j)
833 page_list[n++] = buffer_list[i].addr + ((u64) j << shift);
834
835 mthca_dbg(to_mdev(pd->device), "Registering memory at %llx (iova %llx) "
836 "in PD %x; shift %d, npages %d.\n",
837 (unsigned long long) buffer_list[0].addr,
838 (unsigned long long) *iova_start,
839 to_mpd(pd)->pd_num,
840 shift, npages);
841
842 err = mthca_mr_alloc_phys(to_mdev(pd->device),
843 to_mpd(pd)->pd_num,
844 page_list, shift, npages,
845 *iova_start, total_size,
846 convert_access(acc), mr);
847
848 if (err) {
849 kfree(page_list);
850 kfree(mr);
851 return ERR_PTR(err);
852 }
853
854 kfree(page_list);
855 return &mr->ibmr;
856 }
857
858 static struct ib_mr *mthca_reg_user_mr(struct ib_pd *pd, struct ib_umem *region,
859 int acc, struct ib_udata *udata)
860 {
861 struct mthca_dev *dev = to_mdev(pd->device);
862 struct ib_umem_chunk *chunk;
863 struct mthca_mr *mr;
864 u64 *pages;
865 int shift, n, len;
866 int i, j, k;
867 int err = 0;
868
869 shift = ffs(region->page_size) - 1;
870
871 mr = kmalloc(sizeof *mr, GFP_KERNEL);
872 if (!mr)
873 return ERR_PTR(-ENOMEM);
874
875 n = 0;
876 list_for_each_entry(chunk, &region->chunk_list, list)
877 n += chunk->nents;
878
879 mr->mtt = mthca_alloc_mtt(dev, n);
880 if (IS_ERR(mr->mtt)) {
881 err = PTR_ERR(mr->mtt);
882 goto err;
883 }
884
885 pages = (u64 *) __get_free_page(GFP_KERNEL);
886 if (!pages) {
887 err = -ENOMEM;
888 goto err_mtt;
889 }
890
891 i = n = 0;
892
893 list_for_each_entry(chunk, &region->chunk_list, list)
894 for (j = 0; j < chunk->nmap; ++j) {
895 len = sg_dma_len(&chunk->page_list[j]) >> shift;
896 for (k = 0; k < len; ++k) {
897 pages[i++] = sg_dma_address(&chunk->page_list[j]) +
898 region->page_size * k;
899 /*
900 * Be friendly to WRITE_MTT command
901 * and leave two empty slots for the
902 * index and reserved fields of the
903 * mailbox.
904 */
905 if (i == PAGE_SIZE / sizeof (u64) - 2) {
906 err = mthca_write_mtt(dev, mr->mtt,
907 n, pages, i);
908 if (err)
909 goto mtt_done;
910 n += i;
911 i = 0;
912 }
913 }
914 }
915
916 if (i)
917 err = mthca_write_mtt(dev, mr->mtt, n, pages, i);
918 mtt_done:
919 free_page((unsigned long) pages);
920 if (err)
921 goto err_mtt;
922
923 err = mthca_mr_alloc(dev, to_mpd(pd)->pd_num, shift, region->virt_base,
924 region->length, convert_access(acc), mr);
925
926 if (err)
927 goto err_mtt;
928
929 return &mr->ibmr;
930
931 err_mtt:
932 mthca_free_mtt(dev, mr->mtt);
933
934 err:
935 kfree(mr);
936 return ERR_PTR(err);
937 }
938
939 static int mthca_dereg_mr(struct ib_mr *mr)
940 {
941 struct mthca_mr *mmr = to_mmr(mr);
942 mthca_free_mr(to_mdev(mr->device), mmr);
943 kfree(mmr);
944 return 0;
945 }
946
947 static struct ib_fmr *mthca_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
948 struct ib_fmr_attr *fmr_attr)
949 {
950 struct mthca_fmr *fmr;
951 int err;
952
953 fmr = kmalloc(sizeof *fmr, GFP_KERNEL);
954 if (!fmr)
955 return ERR_PTR(-ENOMEM);
956
957 memcpy(&fmr->attr, fmr_attr, sizeof *fmr_attr);
958 err = mthca_fmr_alloc(to_mdev(pd->device), to_mpd(pd)->pd_num,
959 convert_access(mr_access_flags), fmr);
960
961 if (err) {
962 kfree(fmr);
963 return ERR_PTR(err);
964 }
965
966 return &fmr->ibmr;
967 }
968
969 static int mthca_dealloc_fmr(struct ib_fmr *fmr)
970 {
971 struct mthca_fmr *mfmr = to_mfmr(fmr);
972 int err;
973
974 err = mthca_free_fmr(to_mdev(fmr->device), mfmr);
975 if (err)
976 return err;
977
978 kfree(mfmr);
979 return 0;
980 }
981
982 static int mthca_unmap_fmr(struct list_head *fmr_list)
983 {
984 struct ib_fmr *fmr;
985 int err;
986 u8 status;
987 struct mthca_dev *mdev = NULL;
988
989 list_for_each_entry(fmr, fmr_list, list) {
990 if (mdev && to_mdev(fmr->device) != mdev)
991 return -EINVAL;
992 mdev = to_mdev(fmr->device);
993 }
994
995 if (!mdev)
996 return 0;
997
998 if (mthca_is_memfree(mdev)) {
999 list_for_each_entry(fmr, fmr_list, list)
1000 mthca_arbel_fmr_unmap(mdev, to_mfmr(fmr));
1001
1002 wmb();
1003 } else
1004 list_for_each_entry(fmr, fmr_list, list)
1005 mthca_tavor_fmr_unmap(mdev, to_mfmr(fmr));
1006
1007 err = mthca_SYNC_TPT(mdev, &status);
1008 if (err)
1009 return err;
1010 if (status)
1011 return -EINVAL;
1012 return 0;
1013 }
1014
1015 static ssize_t show_rev(struct class_device *cdev, char *buf)
1016 {
1017 struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev);
1018 return sprintf(buf, "%x\n", dev->rev_id);
1019 }
1020
1021 static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
1022 {
1023 struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev);
1024 return sprintf(buf, "%d.%d.%d\n", (int) (dev->fw_ver >> 32),
1025 (int) (dev->fw_ver >> 16) & 0xffff,
1026 (int) dev->fw_ver & 0xffff);
1027 }
1028
1029 static ssize_t show_hca(struct class_device *cdev, char *buf)
1030 {
1031 struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev);
1032 switch (dev->pdev->device) {
1033 case PCI_DEVICE_ID_MELLANOX_TAVOR:
1034 return sprintf(buf, "MT23108\n");
1035 case PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT:
1036 return sprintf(buf, "MT25208 (MT23108 compat mode)\n");
1037 case PCI_DEVICE_ID_MELLANOX_ARBEL:
1038 return sprintf(buf, "MT25208\n");
1039 case PCI_DEVICE_ID_MELLANOX_SINAI:
1040 case PCI_DEVICE_ID_MELLANOX_SINAI_OLD:
1041 return sprintf(buf, "MT25204\n");
1042 default:
1043 return sprintf(buf, "unknown\n");
1044 }
1045 }
1046
1047 static ssize_t show_board(struct class_device *cdev, char *buf)
1048 {
1049 struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev);
1050 return sprintf(buf, "%.*s\n", MTHCA_BOARD_ID_LEN, dev->board_id);
1051 }
1052
1053 static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
1054 static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
1055 static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
1056 static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL);
1057
1058 static struct class_device_attribute *mthca_class_attributes[] = {
1059 &class_device_attr_hw_rev,
1060 &class_device_attr_fw_ver,
1061 &class_device_attr_hca_type,
1062 &class_device_attr_board_id
1063 };
1064
1065 int mthca_register_device(struct mthca_dev *dev)
1066 {
1067 int ret;
1068 int i;
1069
1070 strlcpy(dev->ib_dev.name, "mthca%d", IB_DEVICE_NAME_MAX);
1071 dev->ib_dev.owner = THIS_MODULE;
1072
1073 dev->ib_dev.uverbs_abi_ver = MTHCA_UVERBS_ABI_VERSION;
1074 dev->ib_dev.uverbs_cmd_mask =
1075 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT) |
1076 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE) |
1077 (1ull << IB_USER_VERBS_CMD_QUERY_PORT) |
1078 (1ull << IB_USER_VERBS_CMD_ALLOC_PD) |
1079 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD) |
1080 (1ull << IB_USER_VERBS_CMD_REG_MR) |
1081 (1ull << IB_USER_VERBS_CMD_DEREG_MR) |
1082 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) |
1083 (1ull << IB_USER_VERBS_CMD_CREATE_CQ) |
1084 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ) |
1085 (1ull << IB_USER_VERBS_CMD_CREATE_QP) |
1086 (1ull << IB_USER_VERBS_CMD_MODIFY_QP) |
1087 (1ull << IB_USER_VERBS_CMD_DESTROY_QP) |
1088 (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST) |
1089 (1ull << IB_USER_VERBS_CMD_DETACH_MCAST) |
1090 (1ull << IB_USER_VERBS_CMD_CREATE_SRQ) |
1091 (1ull << IB_USER_VERBS_CMD_MODIFY_SRQ) |
1092 (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ);
1093 dev->ib_dev.node_type = IB_NODE_CA;
1094 dev->ib_dev.phys_port_cnt = dev->limits.num_ports;
1095 dev->ib_dev.dma_device = &dev->pdev->dev;
1096 dev->ib_dev.class_dev.dev = &dev->pdev->dev;
1097 dev->ib_dev.query_device = mthca_query_device;
1098 dev->ib_dev.query_port = mthca_query_port;
1099 dev->ib_dev.modify_port = mthca_modify_port;
1100 dev->ib_dev.query_pkey = mthca_query_pkey;
1101 dev->ib_dev.query_gid = mthca_query_gid;
1102 dev->ib_dev.alloc_ucontext = mthca_alloc_ucontext;
1103 dev->ib_dev.dealloc_ucontext = mthca_dealloc_ucontext;
1104 dev->ib_dev.mmap = mthca_mmap_uar;
1105 dev->ib_dev.alloc_pd = mthca_alloc_pd;
1106 dev->ib_dev.dealloc_pd = mthca_dealloc_pd;
1107 dev->ib_dev.create_ah = mthca_ah_create;
1108 dev->ib_dev.destroy_ah = mthca_ah_destroy;
1109
1110 if (dev->mthca_flags & MTHCA_FLAG_SRQ) {
1111 dev->ib_dev.create_srq = mthca_create_srq;
1112 dev->ib_dev.modify_srq = mthca_modify_srq;
1113 dev->ib_dev.destroy_srq = mthca_destroy_srq;
1114
1115 if (mthca_is_memfree(dev))
1116 dev->ib_dev.post_srq_recv = mthca_arbel_post_srq_recv;
1117 else
1118 dev->ib_dev.post_srq_recv = mthca_tavor_post_srq_recv;
1119 }
1120
1121 dev->ib_dev.create_qp = mthca_create_qp;
1122 dev->ib_dev.modify_qp = mthca_modify_qp;
1123 dev->ib_dev.destroy_qp = mthca_destroy_qp;
1124 dev->ib_dev.create_cq = mthca_create_cq;
1125 dev->ib_dev.destroy_cq = mthca_destroy_cq;
1126 dev->ib_dev.poll_cq = mthca_poll_cq;
1127 dev->ib_dev.get_dma_mr = mthca_get_dma_mr;
1128 dev->ib_dev.reg_phys_mr = mthca_reg_phys_mr;
1129 dev->ib_dev.reg_user_mr = mthca_reg_user_mr;
1130 dev->ib_dev.dereg_mr = mthca_dereg_mr;
1131
1132 if (dev->mthca_flags & MTHCA_FLAG_FMR) {
1133 dev->ib_dev.alloc_fmr = mthca_alloc_fmr;
1134 dev->ib_dev.unmap_fmr = mthca_unmap_fmr;
1135 dev->ib_dev.dealloc_fmr = mthca_dealloc_fmr;
1136 if (mthca_is_memfree(dev))
1137 dev->ib_dev.map_phys_fmr = mthca_arbel_map_phys_fmr;
1138 else
1139 dev->ib_dev.map_phys_fmr = mthca_tavor_map_phys_fmr;
1140 }
1141
1142 dev->ib_dev.attach_mcast = mthca_multicast_attach;
1143 dev->ib_dev.detach_mcast = mthca_multicast_detach;
1144 dev->ib_dev.process_mad = mthca_process_mad;
1145
1146 if (mthca_is_memfree(dev)) {
1147 dev->ib_dev.req_notify_cq = mthca_arbel_arm_cq;
1148 dev->ib_dev.post_send = mthca_arbel_post_send;
1149 dev->ib_dev.post_recv = mthca_arbel_post_receive;
1150 } else {
1151 dev->ib_dev.req_notify_cq = mthca_tavor_arm_cq;
1152 dev->ib_dev.post_send = mthca_tavor_post_send;
1153 dev->ib_dev.post_recv = mthca_tavor_post_receive;
1154 }
1155
1156 init_MUTEX(&dev->cap_mask_mutex);
1157
1158 ret = ib_register_device(&dev->ib_dev);
1159 if (ret)
1160 return ret;
1161
1162 for (i = 0; i < ARRAY_SIZE(mthca_class_attributes); ++i) {
1163 ret = class_device_create_file(&dev->ib_dev.class_dev,
1164 mthca_class_attributes[i]);
1165 if (ret) {
1166 ib_unregister_device(&dev->ib_dev);
1167 return ret;
1168 }
1169 }
1170
1171 mthca_start_catas_poll(dev);
1172
1173 return 0;
1174 }
1175
1176 void mthca_unregister_device(struct mthca_dev *dev)
1177 {
1178 mthca_stop_catas_poll(dev);
1179 ib_unregister_device(&dev->ib_dev);
1180 }
Linux 2.6 libata-dev (mirror)