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.
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:
14 * Redistribution and use in source and binary forms, with or
15 * without modification, are permitted provided that the following
18 * - Redistributions of source code must retain the above
19 * copyright notice, this list of conditions and the following
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.
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
36 * $Id: mthca_provider.c 1397 2004-12-28 05:09:00Z roland $
39 #include <rdma/ib_smi.h>
42 #include "mthca_dev.h"
43 #include "mthca_cmd.h"
44 #include "mthca_user.h"
45 #include "mthca_memfree.h"
47 static int mthca_query_device(struct ib_device
*ibdev
,
48 struct ib_device_attr
*props
)
50 struct ib_smp
*in_mad
= NULL
;
51 struct ib_smp
*out_mad
= NULL
;
53 struct mthca_dev
* mdev
= to_mdev(ibdev
);
57 in_mad
= kmalloc(sizeof *in_mad
, GFP_KERNEL
);
58 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
59 if (!in_mad
|| !out_mad
)
62 memset(props
, 0, sizeof *props
);
64 props
->fw_ver
= mdev
->fw_ver
;
66 memset(in_mad
, 0, sizeof *in_mad
);
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
;
73 err
= mthca_MAD_IFC(mdev
, 1, 1,
74 1, NULL
, NULL
, in_mad
, out_mad
,
83 props
->device_cap_flags
= mdev
->device_cap_flags
;
84 props
->vendor_id
= be32_to_cpup((__be32
*) (out_mad
->data
+ 36)) &
86 props
->vendor_part_id
= be16_to_cpup((__be16
*) (out_mad
->data
+ 30));
87 props
->hw_ver
= be16_to_cpup((__be16
*) (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);
91 props
->max_mr_size
= ~0ull;
92 props
->max_qp
= mdev
->limits
.num_qps
- mdev
->limits
.reserved_qps
;
93 props
->max_qp_wr
= 0xffff;
94 props
->max_sge
= mdev
->limits
.max_sg
;
95 props
->max_cq
= mdev
->limits
.num_cqs
- mdev
->limits
.reserved_cqs
;
96 props
->max_cqe
= 0xffff;
97 props
->max_mr
= mdev
->limits
.num_mpts
- mdev
->limits
.reserved_mrws
;
98 props
->max_pd
= mdev
->limits
.num_pds
- mdev
->limits
.reserved_pds
;
99 props
->max_qp_rd_atom
= 1 << mdev
->qp_table
.rdb_shift
;
100 props
->max_qp_init_rd_atom
= 1 << mdev
->qp_table
.rdb_shift
;
101 props
->local_ca_ack_delay
= mdev
->limits
.local_ca_ack_delay
;
110 static int mthca_query_port(struct ib_device
*ibdev
,
111 u8 port
, struct ib_port_attr
*props
)
113 struct ib_smp
*in_mad
= NULL
;
114 struct ib_smp
*out_mad
= NULL
;
118 in_mad
= kmalloc(sizeof *in_mad
, GFP_KERNEL
);
119 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
120 if (!in_mad
|| !out_mad
)
123 memset(props
, 0, sizeof *props
);
125 memset(in_mad
, 0, sizeof *in_mad
);
126 in_mad
->base_version
= 1;
127 in_mad
->mgmt_class
= IB_MGMT_CLASS_SUBN_LID_ROUTED
;
128 in_mad
->class_version
= 1;
129 in_mad
->method
= IB_MGMT_METHOD_GET
;
130 in_mad
->attr_id
= IB_SMP_ATTR_PORT_INFO
;
131 in_mad
->attr_mod
= cpu_to_be32(port
);
133 err
= mthca_MAD_IFC(to_mdev(ibdev
), 1, 1,
134 port
, NULL
, NULL
, in_mad
, out_mad
,
143 props
->lid
= be16_to_cpup((__be16
*) (out_mad
->data
+ 16));
144 props
->lmc
= out_mad
->data
[34] & 0x7;
145 props
->sm_lid
= be16_to_cpup((__be16
*) (out_mad
->data
+ 18));
146 props
->sm_sl
= out_mad
->data
[36] & 0xf;
147 props
->state
= out_mad
->data
[32] & 0xf;
148 props
->phys_state
= out_mad
->data
[33] >> 4;
149 props
->port_cap_flags
= be32_to_cpup((__be32
*) (out_mad
->data
+ 20));
150 props
->gid_tbl_len
= to_mdev(ibdev
)->limits
.gid_table_len
;
151 props
->max_msg_sz
= 0x80000000;
152 props
->pkey_tbl_len
= to_mdev(ibdev
)->limits
.pkey_table_len
;
153 props
->qkey_viol_cntr
= be16_to_cpup((__be16
*) (out_mad
->data
+ 48));
154 props
->active_width
= out_mad
->data
[31] & 0xf;
155 props
->active_speed
= out_mad
->data
[35] >> 4;
163 static int mthca_modify_port(struct ib_device
*ibdev
,
164 u8 port
, int port_modify_mask
,
165 struct ib_port_modify
*props
)
167 struct mthca_set_ib_param set_ib
;
168 struct ib_port_attr attr
;
172 if (down_interruptible(&to_mdev(ibdev
)->cap_mask_mutex
))
175 err
= mthca_query_port(ibdev
, port
, &attr
);
179 set_ib
.set_si_guid
= 0;
180 set_ib
.reset_qkey_viol
= !!(port_modify_mask
& IB_PORT_RESET_QKEY_CNTR
);
182 set_ib
.cap_mask
= (attr
.port_cap_flags
| props
->set_port_cap_mask
) &
183 ~props
->clr_port_cap_mask
;
185 err
= mthca_SET_IB(to_mdev(ibdev
), &set_ib
, port
, &status
);
194 up(&to_mdev(ibdev
)->cap_mask_mutex
);
198 static int mthca_query_pkey(struct ib_device
*ibdev
,
199 u8 port
, u16 index
, u16
*pkey
)
201 struct ib_smp
*in_mad
= NULL
;
202 struct ib_smp
*out_mad
= NULL
;
206 in_mad
= kmalloc(sizeof *in_mad
, GFP_KERNEL
);
207 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
208 if (!in_mad
|| !out_mad
)
211 memset(in_mad
, 0, sizeof *in_mad
);
212 in_mad
->base_version
= 1;
213 in_mad
->mgmt_class
= IB_MGMT_CLASS_SUBN_LID_ROUTED
;
214 in_mad
->class_version
= 1;
215 in_mad
->method
= IB_MGMT_METHOD_GET
;
216 in_mad
->attr_id
= IB_SMP_ATTR_PKEY_TABLE
;
217 in_mad
->attr_mod
= cpu_to_be32(index
/ 32);
219 err
= mthca_MAD_IFC(to_mdev(ibdev
), 1, 1,
220 port
, NULL
, NULL
, in_mad
, out_mad
,
229 *pkey
= be16_to_cpu(((__be16
*) out_mad
->data
)[index
% 32]);
237 static int mthca_query_gid(struct ib_device
*ibdev
, u8 port
,
238 int index
, union ib_gid
*gid
)
240 struct ib_smp
*in_mad
= NULL
;
241 struct ib_smp
*out_mad
= NULL
;
245 in_mad
= kmalloc(sizeof *in_mad
, GFP_KERNEL
);
246 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
247 if (!in_mad
|| !out_mad
)
250 memset(in_mad
, 0, sizeof *in_mad
);
251 in_mad
->base_version
= 1;
252 in_mad
->mgmt_class
= IB_MGMT_CLASS_SUBN_LID_ROUTED
;
253 in_mad
->class_version
= 1;
254 in_mad
->method
= IB_MGMT_METHOD_GET
;
255 in_mad
->attr_id
= IB_SMP_ATTR_PORT_INFO
;
256 in_mad
->attr_mod
= cpu_to_be32(port
);
258 err
= mthca_MAD_IFC(to_mdev(ibdev
), 1, 1,
259 port
, NULL
, NULL
, in_mad
, out_mad
,
268 memcpy(gid
->raw
, out_mad
->data
+ 8, 8);
270 memset(in_mad
, 0, sizeof *in_mad
);
271 in_mad
->base_version
= 1;
272 in_mad
->mgmt_class
= IB_MGMT_CLASS_SUBN_LID_ROUTED
;
273 in_mad
->class_version
= 1;
274 in_mad
->method
= IB_MGMT_METHOD_GET
;
275 in_mad
->attr_id
= IB_SMP_ATTR_GUID_INFO
;
276 in_mad
->attr_mod
= cpu_to_be32(index
/ 8);
278 err
= mthca_MAD_IFC(to_mdev(ibdev
), 1, 1,
279 port
, NULL
, NULL
, in_mad
, out_mad
,
288 memcpy(gid
->raw
+ 8, out_mad
->data
+ (index
% 8) * 16, 8);
296 static struct ib_ucontext
*mthca_alloc_ucontext(struct ib_device
*ibdev
,
297 struct ib_udata
*udata
)
299 struct mthca_alloc_ucontext_resp uresp
;
300 struct mthca_ucontext
*context
;
303 memset(&uresp
, 0, sizeof uresp
);
305 uresp
.qp_tab_size
= to_mdev(ibdev
)->limits
.num_qps
;
306 if (mthca_is_memfree(to_mdev(ibdev
)))
307 uresp
.uarc_size
= to_mdev(ibdev
)->uar_table
.uarc_size
;
311 context
= kmalloc(sizeof *context
, GFP_KERNEL
);
313 return ERR_PTR(-ENOMEM
);
315 err
= mthca_uar_alloc(to_mdev(ibdev
), &context
->uar
);
321 context
->db_tab
= mthca_init_user_db_tab(to_mdev(ibdev
));
322 if (IS_ERR(context
->db_tab
)) {
323 err
= PTR_ERR(context
->db_tab
);
324 mthca_uar_free(to_mdev(ibdev
), &context
->uar
);
329 if (ib_copy_to_udata(udata
, &uresp
, sizeof uresp
)) {
330 mthca_cleanup_user_db_tab(to_mdev(ibdev
), &context
->uar
, context
->db_tab
);
331 mthca_uar_free(to_mdev(ibdev
), &context
->uar
);
333 return ERR_PTR(-EFAULT
);
336 return &context
->ibucontext
;
339 static int mthca_dealloc_ucontext(struct ib_ucontext
*context
)
341 mthca_cleanup_user_db_tab(to_mdev(context
->device
), &to_mucontext(context
)->uar
,
342 to_mucontext(context
)->db_tab
);
343 mthca_uar_free(to_mdev(context
->device
), &to_mucontext(context
)->uar
);
344 kfree(to_mucontext(context
));
349 static int mthca_mmap_uar(struct ib_ucontext
*context
,
350 struct vm_area_struct
*vma
)
352 if (vma
->vm_end
- vma
->vm_start
!= PAGE_SIZE
)
355 vma
->vm_page_prot
= pgprot_noncached(vma
->vm_page_prot
);
357 if (io_remap_pfn_range(vma
, vma
->vm_start
,
358 to_mucontext(context
)->uar
.pfn
,
359 PAGE_SIZE
, vma
->vm_page_prot
))
365 static struct ib_pd
*mthca_alloc_pd(struct ib_device
*ibdev
,
366 struct ib_ucontext
*context
,
367 struct ib_udata
*udata
)
372 pd
= kmalloc(sizeof *pd
, GFP_KERNEL
);
374 return ERR_PTR(-ENOMEM
);
376 err
= mthca_pd_alloc(to_mdev(ibdev
), !context
, pd
);
383 if (ib_copy_to_udata(udata
, &pd
->pd_num
, sizeof (__u32
))) {
384 mthca_pd_free(to_mdev(ibdev
), pd
);
386 return ERR_PTR(-EFAULT
);
393 static int mthca_dealloc_pd(struct ib_pd
*pd
)
395 mthca_pd_free(to_mdev(pd
->device
), to_mpd(pd
));
401 static struct ib_ah
*mthca_ah_create(struct ib_pd
*pd
,
402 struct ib_ah_attr
*ah_attr
)
407 ah
= kmalloc(sizeof *ah
, GFP_ATOMIC
);
409 return ERR_PTR(-ENOMEM
);
411 err
= mthca_create_ah(to_mdev(pd
->device
), to_mpd(pd
), ah_attr
, ah
);
420 static int mthca_ah_destroy(struct ib_ah
*ah
)
422 mthca_destroy_ah(to_mdev(ah
->device
), to_mah(ah
));
428 static struct ib_srq
*mthca_create_srq(struct ib_pd
*pd
,
429 struct ib_srq_init_attr
*init_attr
,
430 struct ib_udata
*udata
)
432 struct mthca_create_srq ucmd
;
433 struct mthca_ucontext
*context
= NULL
;
434 struct mthca_srq
*srq
;
437 srq
= kmalloc(sizeof *srq
, GFP_KERNEL
);
439 return ERR_PTR(-ENOMEM
);
442 context
= to_mucontext(pd
->uobject
->context
);
444 if (ib_copy_from_udata(&ucmd
, udata
, sizeof ucmd
))
445 return ERR_PTR(-EFAULT
);
447 err
= mthca_map_user_db(to_mdev(pd
->device
), &context
->uar
,
448 context
->db_tab
, ucmd
.db_index
,
454 srq
->mr
.ibmr
.lkey
= ucmd
.lkey
;
455 srq
->db_index
= ucmd
.db_index
;
458 err
= mthca_alloc_srq(to_mdev(pd
->device
), to_mpd(pd
),
459 &init_attr
->attr
, srq
);
461 if (err
&& pd
->uobject
)
462 mthca_unmap_user_db(to_mdev(pd
->device
), &context
->uar
,
463 context
->db_tab
, ucmd
.db_index
);
468 if (context
&& ib_copy_to_udata(udata
, &srq
->srqn
, sizeof (__u32
))) {
469 mthca_free_srq(to_mdev(pd
->device
), srq
);
482 static int mthca_destroy_srq(struct ib_srq
*srq
)
484 struct mthca_ucontext
*context
;
487 context
= to_mucontext(srq
->uobject
->context
);
489 mthca_unmap_user_db(to_mdev(srq
->device
), &context
->uar
,
490 context
->db_tab
, to_msrq(srq
)->db_index
);
493 mthca_free_srq(to_mdev(srq
->device
), to_msrq(srq
));
499 static struct ib_qp
*mthca_create_qp(struct ib_pd
*pd
,
500 struct ib_qp_init_attr
*init_attr
,
501 struct ib_udata
*udata
)
503 struct mthca_create_qp ucmd
;
507 switch (init_attr
->qp_type
) {
512 struct mthca_ucontext
*context
;
514 qp
= kmalloc(sizeof *qp
, GFP_KERNEL
);
516 return ERR_PTR(-ENOMEM
);
519 context
= to_mucontext(pd
->uobject
->context
);
521 if (ib_copy_from_udata(&ucmd
, udata
, sizeof ucmd
))
522 return ERR_PTR(-EFAULT
);
524 err
= mthca_map_user_db(to_mdev(pd
->device
), &context
->uar
,
526 ucmd
.sq_db_index
, ucmd
.sq_db_page
);
532 err
= mthca_map_user_db(to_mdev(pd
->device
), &context
->uar
,
534 ucmd
.rq_db_index
, ucmd
.rq_db_page
);
536 mthca_unmap_user_db(to_mdev(pd
->device
),
544 qp
->mr
.ibmr
.lkey
= ucmd
.lkey
;
545 qp
->sq
.db_index
= ucmd
.sq_db_index
;
546 qp
->rq
.db_index
= ucmd
.rq_db_index
;
549 err
= mthca_alloc_qp(to_mdev(pd
->device
), to_mpd(pd
),
550 to_mcq(init_attr
->send_cq
),
551 to_mcq(init_attr
->recv_cq
),
552 init_attr
->qp_type
, init_attr
->sq_sig_type
,
553 &init_attr
->cap
, qp
);
555 if (err
&& pd
->uobject
) {
556 context
= to_mucontext(pd
->uobject
->context
);
558 mthca_unmap_user_db(to_mdev(pd
->device
),
562 mthca_unmap_user_db(to_mdev(pd
->device
),
568 qp
->ibqp
.qp_num
= qp
->qpn
;
574 /* Don't allow userspace to create special QPs */
576 return ERR_PTR(-EINVAL
);
578 qp
= kmalloc(sizeof (struct mthca_sqp
), GFP_KERNEL
);
580 return ERR_PTR(-ENOMEM
);
582 qp
->ibqp
.qp_num
= init_attr
->qp_type
== IB_QPT_SMI
? 0 : 1;
584 err
= mthca_alloc_sqp(to_mdev(pd
->device
), to_mpd(pd
),
585 to_mcq(init_attr
->send_cq
),
586 to_mcq(init_attr
->recv_cq
),
587 init_attr
->sq_sig_type
, &init_attr
->cap
,
588 qp
->ibqp
.qp_num
, init_attr
->port_num
,
593 /* Don't support raw QPs */
594 return ERR_PTR(-ENOSYS
);
602 init_attr
->cap
.max_inline_data
= 0;
603 init_attr
->cap
.max_send_wr
= qp
->sq
.max
;
604 init_attr
->cap
.max_recv_wr
= qp
->rq
.max
;
605 init_attr
->cap
.max_send_sge
= qp
->sq
.max_gs
;
606 init_attr
->cap
.max_recv_sge
= qp
->rq
.max_gs
;
611 static int mthca_destroy_qp(struct ib_qp
*qp
)
614 mthca_unmap_user_db(to_mdev(qp
->device
),
615 &to_mucontext(qp
->uobject
->context
)->uar
,
616 to_mucontext(qp
->uobject
->context
)->db_tab
,
617 to_mqp(qp
)->sq
.db_index
);
618 mthca_unmap_user_db(to_mdev(qp
->device
),
619 &to_mucontext(qp
->uobject
->context
)->uar
,
620 to_mucontext(qp
->uobject
->context
)->db_tab
,
621 to_mqp(qp
)->rq
.db_index
);
623 mthca_free_qp(to_mdev(qp
->device
), to_mqp(qp
));
628 static struct ib_cq
*mthca_create_cq(struct ib_device
*ibdev
, int entries
,
629 struct ib_ucontext
*context
,
630 struct ib_udata
*udata
)
632 struct mthca_create_cq ucmd
;
638 if (ib_copy_from_udata(&ucmd
, udata
, sizeof ucmd
))
639 return ERR_PTR(-EFAULT
);
641 err
= mthca_map_user_db(to_mdev(ibdev
), &to_mucontext(context
)->uar
,
642 to_mucontext(context
)->db_tab
,
643 ucmd
.set_db_index
, ucmd
.set_db_page
);
647 err
= mthca_map_user_db(to_mdev(ibdev
), &to_mucontext(context
)->uar
,
648 to_mucontext(context
)->db_tab
,
649 ucmd
.arm_db_index
, ucmd
.arm_db_page
);
654 cq
= kmalloc(sizeof *cq
, GFP_KERNEL
);
661 cq
->mr
.ibmr
.lkey
= ucmd
.lkey
;
662 cq
->set_ci_db_index
= ucmd
.set_db_index
;
663 cq
->arm_db_index
= ucmd
.arm_db_index
;
666 for (nent
= 1; nent
<= entries
; nent
<<= 1)
669 err
= mthca_init_cq(to_mdev(ibdev
), nent
,
670 context
? to_mucontext(context
) : NULL
,
671 context
? ucmd
.pdn
: to_mdev(ibdev
)->driver_pd
.pd_num
,
676 if (context
&& ib_copy_to_udata(udata
, &cq
->cqn
, sizeof (__u32
))) {
677 mthca_free_cq(to_mdev(ibdev
), cq
);
688 mthca_unmap_user_db(to_mdev(ibdev
), &to_mucontext(context
)->uar
,
689 to_mucontext(context
)->db_tab
, ucmd
.arm_db_index
);
693 mthca_unmap_user_db(to_mdev(ibdev
), &to_mucontext(context
)->uar
,
694 to_mucontext(context
)->db_tab
, ucmd
.set_db_index
);
699 static int mthca_destroy_cq(struct ib_cq
*cq
)
702 mthca_unmap_user_db(to_mdev(cq
->device
),
703 &to_mucontext(cq
->uobject
->context
)->uar
,
704 to_mucontext(cq
->uobject
->context
)->db_tab
,
705 to_mcq(cq
)->arm_db_index
);
706 mthca_unmap_user_db(to_mdev(cq
->device
),
707 &to_mucontext(cq
->uobject
->context
)->uar
,
708 to_mucontext(cq
->uobject
->context
)->db_tab
,
709 to_mcq(cq
)->set_ci_db_index
);
711 mthca_free_cq(to_mdev(cq
->device
), to_mcq(cq
));
717 static inline u32
convert_access(int acc
)
719 return (acc
& IB_ACCESS_REMOTE_ATOMIC
? MTHCA_MPT_FLAG_ATOMIC
: 0) |
720 (acc
& IB_ACCESS_REMOTE_WRITE
? MTHCA_MPT_FLAG_REMOTE_WRITE
: 0) |
721 (acc
& IB_ACCESS_REMOTE_READ
? MTHCA_MPT_FLAG_REMOTE_READ
: 0) |
722 (acc
& IB_ACCESS_LOCAL_WRITE
? MTHCA_MPT_FLAG_LOCAL_WRITE
: 0) |
723 MTHCA_MPT_FLAG_LOCAL_READ
;
726 static struct ib_mr
*mthca_get_dma_mr(struct ib_pd
*pd
, int acc
)
731 mr
= kmalloc(sizeof *mr
, GFP_KERNEL
);
733 return ERR_PTR(-ENOMEM
);
735 err
= mthca_mr_alloc_notrans(to_mdev(pd
->device
),
737 convert_access(acc
), mr
);
747 static struct ib_mr
*mthca_reg_phys_mr(struct ib_pd
*pd
,
748 struct ib_phys_buf
*buffer_list
,
762 /* First check that we have enough alignment */
763 if ((*iova_start
& ~PAGE_MASK
) != (buffer_list
[0].addr
& ~PAGE_MASK
))
764 return ERR_PTR(-EINVAL
);
766 if (num_phys_buf
> 1 &&
767 ((buffer_list
[0].addr
+ buffer_list
[0].size
) & ~PAGE_MASK
))
768 return ERR_PTR(-EINVAL
);
772 for (i
= 0; i
< num_phys_buf
; ++i
) {
773 if (i
!= 0 && buffer_list
[i
].addr
& ~PAGE_MASK
)
774 return ERR_PTR(-EINVAL
);
775 if (i
!= 0 && i
!= num_phys_buf
- 1 &&
776 (buffer_list
[i
].size
& ~PAGE_MASK
))
777 return ERR_PTR(-EINVAL
);
779 total_size
+= buffer_list
[i
].size
;
781 mask
|= buffer_list
[i
].addr
;
784 /* Find largest page shift we can use to cover buffers */
785 for (shift
= PAGE_SHIFT
; shift
< 31; ++shift
)
786 if (num_phys_buf
> 1) {
787 if ((1ULL << shift
) & mask
)
791 buffer_list
[0].size
+
792 (buffer_list
[0].addr
& ((1ULL << shift
) - 1)))
796 buffer_list
[0].size
+= buffer_list
[0].addr
& ((1ULL << shift
) - 1);
797 buffer_list
[0].addr
&= ~0ull << shift
;
799 mr
= kmalloc(sizeof *mr
, GFP_KERNEL
);
801 return ERR_PTR(-ENOMEM
);
804 for (i
= 0; i
< num_phys_buf
; ++i
)
805 npages
+= (buffer_list
[i
].size
+ (1ULL << shift
) - 1) >> shift
;
810 page_list
= kmalloc(npages
* sizeof *page_list
, GFP_KERNEL
);
813 return ERR_PTR(-ENOMEM
);
817 for (i
= 0; i
< num_phys_buf
; ++i
)
819 j
< (buffer_list
[i
].size
+ (1ULL << shift
) - 1) >> shift
;
821 page_list
[n
++] = buffer_list
[i
].addr
+ ((u64
) j
<< shift
);
823 mthca_dbg(to_mdev(pd
->device
), "Registering memory at %llx (iova %llx) "
824 "in PD %x; shift %d, npages %d.\n",
825 (unsigned long long) buffer_list
[0].addr
,
826 (unsigned long long) *iova_start
,
830 err
= mthca_mr_alloc_phys(to_mdev(pd
->device
),
832 page_list
, shift
, npages
,
833 *iova_start
, total_size
,
834 convert_access(acc
), mr
);
846 static struct ib_mr
*mthca_reg_user_mr(struct ib_pd
*pd
, struct ib_umem
*region
,
847 int acc
, struct ib_udata
*udata
)
849 struct mthca_dev
*dev
= to_mdev(pd
->device
);
850 struct ib_umem_chunk
*chunk
;
857 shift
= ffs(region
->page_size
) - 1;
859 mr
= kmalloc(sizeof *mr
, GFP_KERNEL
);
861 return ERR_PTR(-ENOMEM
);
864 list_for_each_entry(chunk
, ®ion
->chunk_list
, list
)
867 mr
->mtt
= mthca_alloc_mtt(dev
, n
);
868 if (IS_ERR(mr
->mtt
)) {
869 err
= PTR_ERR(mr
->mtt
);
873 pages
= (u64
*) __get_free_page(GFP_KERNEL
);
881 list_for_each_entry(chunk
, ®ion
->chunk_list
, list
)
882 for (j
= 0; j
< chunk
->nmap
; ++j
) {
883 len
= sg_dma_len(&chunk
->page_list
[j
]) >> shift
;
884 for (k
= 0; k
< len
; ++k
) {
885 pages
[i
++] = sg_dma_address(&chunk
->page_list
[j
]) +
886 region
->page_size
* k
;
888 * Be friendly to WRITE_MTT command
889 * and leave two empty slots for the
890 * index and reserved fields of the
893 if (i
== PAGE_SIZE
/ sizeof (u64
) - 2) {
894 err
= mthca_write_mtt(dev
, mr
->mtt
,
905 err
= mthca_write_mtt(dev
, mr
->mtt
, n
, pages
, i
);
907 free_page((unsigned long) pages
);
911 err
= mthca_mr_alloc(dev
, to_mpd(pd
)->pd_num
, shift
, region
->virt_base
,
912 region
->length
, convert_access(acc
), mr
);
920 mthca_free_mtt(dev
, mr
->mtt
);
927 static int mthca_dereg_mr(struct ib_mr
*mr
)
929 struct mthca_mr
*mmr
= to_mmr(mr
);
930 mthca_free_mr(to_mdev(mr
->device
), mmr
);
935 static struct ib_fmr
*mthca_alloc_fmr(struct ib_pd
*pd
, int mr_access_flags
,
936 struct ib_fmr_attr
*fmr_attr
)
938 struct mthca_fmr
*fmr
;
941 fmr
= kmalloc(sizeof *fmr
, GFP_KERNEL
);
943 return ERR_PTR(-ENOMEM
);
945 memcpy(&fmr
->attr
, fmr_attr
, sizeof *fmr_attr
);
946 err
= mthca_fmr_alloc(to_mdev(pd
->device
), to_mpd(pd
)->pd_num
,
947 convert_access(mr_access_flags
), fmr
);
957 static int mthca_dealloc_fmr(struct ib_fmr
*fmr
)
959 struct mthca_fmr
*mfmr
= to_mfmr(fmr
);
962 err
= mthca_free_fmr(to_mdev(fmr
->device
), mfmr
);
970 static int mthca_unmap_fmr(struct list_head
*fmr_list
)
975 struct mthca_dev
*mdev
= NULL
;
977 list_for_each_entry(fmr
, fmr_list
, list
) {
978 if (mdev
&& to_mdev(fmr
->device
) != mdev
)
980 mdev
= to_mdev(fmr
->device
);
986 if (mthca_is_memfree(mdev
)) {
987 list_for_each_entry(fmr
, fmr_list
, list
)
988 mthca_arbel_fmr_unmap(mdev
, to_mfmr(fmr
));
992 list_for_each_entry(fmr
, fmr_list
, list
)
993 mthca_tavor_fmr_unmap(mdev
, to_mfmr(fmr
));
995 err
= mthca_SYNC_TPT(mdev
, &status
);
1003 static ssize_t
show_rev(struct class_device
*cdev
, char *buf
)
1005 struct mthca_dev
*dev
= container_of(cdev
, struct mthca_dev
, ib_dev
.class_dev
);
1006 return sprintf(buf
, "%x\n", dev
->rev_id
);
1009 static ssize_t
show_fw_ver(struct class_device
*cdev
, char *buf
)
1011 struct mthca_dev
*dev
= container_of(cdev
, struct mthca_dev
, ib_dev
.class_dev
);
1012 return sprintf(buf
, "%x.%x.%x\n", (int) (dev
->fw_ver
>> 32),
1013 (int) (dev
->fw_ver
>> 16) & 0xffff,
1014 (int) dev
->fw_ver
& 0xffff);
1017 static ssize_t
show_hca(struct class_device
*cdev
, char *buf
)
1019 struct mthca_dev
*dev
= container_of(cdev
, struct mthca_dev
, ib_dev
.class_dev
);
1020 switch (dev
->pdev
->device
) {
1021 case PCI_DEVICE_ID_MELLANOX_TAVOR
:
1022 return sprintf(buf
, "MT23108\n");
1023 case PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT
:
1024 return sprintf(buf
, "MT25208 (MT23108 compat mode)\n");
1025 case PCI_DEVICE_ID_MELLANOX_ARBEL
:
1026 return sprintf(buf
, "MT25208\n");
1027 case PCI_DEVICE_ID_MELLANOX_SINAI
:
1028 case PCI_DEVICE_ID_MELLANOX_SINAI_OLD
:
1029 return sprintf(buf
, "MT25204\n");
1031 return sprintf(buf
, "unknown\n");
1035 static ssize_t
show_board(struct class_device
*cdev
, char *buf
)
1037 struct mthca_dev
*dev
= container_of(cdev
, struct mthca_dev
, ib_dev
.class_dev
);
1038 return sprintf(buf
, "%.*s\n", MTHCA_BOARD_ID_LEN
, dev
->board_id
);
1041 static CLASS_DEVICE_ATTR(hw_rev
, S_IRUGO
, show_rev
, NULL
);
1042 static CLASS_DEVICE_ATTR(fw_ver
, S_IRUGO
, show_fw_ver
, NULL
);
1043 static CLASS_DEVICE_ATTR(hca_type
, S_IRUGO
, show_hca
, NULL
);
1044 static CLASS_DEVICE_ATTR(board_id
, S_IRUGO
, show_board
, NULL
);
1046 static struct class_device_attribute
*mthca_class_attributes
[] = {
1047 &class_device_attr_hw_rev
,
1048 &class_device_attr_fw_ver
,
1049 &class_device_attr_hca_type
,
1050 &class_device_attr_board_id
1053 int mthca_register_device(struct mthca_dev
*dev
)
1058 strlcpy(dev
->ib_dev
.name
, "mthca%d", IB_DEVICE_NAME_MAX
);
1059 dev
->ib_dev
.owner
= THIS_MODULE
;
1061 dev
->ib_dev
.node_type
= IB_NODE_CA
;
1062 dev
->ib_dev
.phys_port_cnt
= dev
->limits
.num_ports
;
1063 dev
->ib_dev
.dma_device
= &dev
->pdev
->dev
;
1064 dev
->ib_dev
.class_dev
.dev
= &dev
->pdev
->dev
;
1065 dev
->ib_dev
.query_device
= mthca_query_device
;
1066 dev
->ib_dev
.query_port
= mthca_query_port
;
1067 dev
->ib_dev
.modify_port
= mthca_modify_port
;
1068 dev
->ib_dev
.query_pkey
= mthca_query_pkey
;
1069 dev
->ib_dev
.query_gid
= mthca_query_gid
;
1070 dev
->ib_dev
.alloc_ucontext
= mthca_alloc_ucontext
;
1071 dev
->ib_dev
.dealloc_ucontext
= mthca_dealloc_ucontext
;
1072 dev
->ib_dev
.mmap
= mthca_mmap_uar
;
1073 dev
->ib_dev
.alloc_pd
= mthca_alloc_pd
;
1074 dev
->ib_dev
.dealloc_pd
= mthca_dealloc_pd
;
1075 dev
->ib_dev
.create_ah
= mthca_ah_create
;
1076 dev
->ib_dev
.destroy_ah
= mthca_ah_destroy
;
1078 if (dev
->mthca_flags
& MTHCA_FLAG_SRQ
) {
1079 dev
->ib_dev
.create_srq
= mthca_create_srq
;
1080 dev
->ib_dev
.destroy_srq
= mthca_destroy_srq
;
1082 if (mthca_is_memfree(dev
))
1083 dev
->ib_dev
.post_srq_recv
= mthca_arbel_post_srq_recv
;
1085 dev
->ib_dev
.post_srq_recv
= mthca_tavor_post_srq_recv
;
1088 dev
->ib_dev
.create_qp
= mthca_create_qp
;
1089 dev
->ib_dev
.modify_qp
= mthca_modify_qp
;
1090 dev
->ib_dev
.destroy_qp
= mthca_destroy_qp
;
1091 dev
->ib_dev
.create_cq
= mthca_create_cq
;
1092 dev
->ib_dev
.destroy_cq
= mthca_destroy_cq
;
1093 dev
->ib_dev
.poll_cq
= mthca_poll_cq
;
1094 dev
->ib_dev
.get_dma_mr
= mthca_get_dma_mr
;
1095 dev
->ib_dev
.reg_phys_mr
= mthca_reg_phys_mr
;
1096 dev
->ib_dev
.reg_user_mr
= mthca_reg_user_mr
;
1097 dev
->ib_dev
.dereg_mr
= mthca_dereg_mr
;
1099 if (dev
->mthca_flags
& MTHCA_FLAG_FMR
) {
1100 dev
->ib_dev
.alloc_fmr
= mthca_alloc_fmr
;
1101 dev
->ib_dev
.unmap_fmr
= mthca_unmap_fmr
;
1102 dev
->ib_dev
.dealloc_fmr
= mthca_dealloc_fmr
;
1103 if (mthca_is_memfree(dev
))
1104 dev
->ib_dev
.map_phys_fmr
= mthca_arbel_map_phys_fmr
;
1106 dev
->ib_dev
.map_phys_fmr
= mthca_tavor_map_phys_fmr
;
1109 dev
->ib_dev
.attach_mcast
= mthca_multicast_attach
;
1110 dev
->ib_dev
.detach_mcast
= mthca_multicast_detach
;
1111 dev
->ib_dev
.process_mad
= mthca_process_mad
;
1113 if (mthca_is_memfree(dev
)) {
1114 dev
->ib_dev
.req_notify_cq
= mthca_arbel_arm_cq
;
1115 dev
->ib_dev
.post_send
= mthca_arbel_post_send
;
1116 dev
->ib_dev
.post_recv
= mthca_arbel_post_receive
;
1118 dev
->ib_dev
.req_notify_cq
= mthca_tavor_arm_cq
;
1119 dev
->ib_dev
.post_send
= mthca_tavor_post_send
;
1120 dev
->ib_dev
.post_recv
= mthca_tavor_post_receive
;
1123 init_MUTEX(&dev
->cap_mask_mutex
);
1125 ret
= ib_register_device(&dev
->ib_dev
);
1129 for (i
= 0; i
< ARRAY_SIZE(mthca_class_attributes
); ++i
) {
1130 ret
= class_device_create_file(&dev
->ib_dev
.class_dev
,
1131 mthca_class_attributes
[i
]);
1133 ib_unregister_device(&dev
->ib_dev
);
1141 void mthca_unregister_device(struct mthca_dev
*dev
)
1143 ib_unregister_device(&dev
->ib_dev
);