2 * Copyright (c) 2006 Chelsio, Inc. All rights reserved.
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 #include <linux/module.h>
33 #include <linux/moduleparam.h>
34 #include <linux/device.h>
35 #include <linux/netdevice.h>
36 #include <linux/etherdevice.h>
37 #include <linux/delay.h>
38 #include <linux/errno.h>
39 #include <linux/list.h>
40 #include <linux/sched.h>
41 #include <linux/spinlock.h>
42 #include <linux/ethtool.h>
43 #include <linux/rtnetlink.h>
44 #include <linux/inetdevice.h>
45 #include <linux/slab.h>
49 #include <asm/byteorder.h>
51 #include <rdma/iw_cm.h>
52 #include <rdma/ib_verbs.h>
53 #include <rdma/ib_smi.h>
54 #include <rdma/ib_umem.h>
55 #include <rdma/ib_user_verbs.h>
59 #include "iwch_provider.h"
61 #include "iwch_user.h"
64 static struct ib_ah
*iwch_ah_create(struct ib_pd
*pd
,
65 struct ib_ah_attr
*ah_attr
)
67 return ERR_PTR(-ENOSYS
);
70 static int iwch_ah_destroy(struct ib_ah
*ah
)
75 static int iwch_multicast_attach(struct ib_qp
*ibqp
, union ib_gid
*gid
, u16 lid
)
80 static int iwch_multicast_detach(struct ib_qp
*ibqp
, union ib_gid
*gid
, u16 lid
)
85 static int iwch_process_mad(struct ib_device
*ibdev
,
88 const struct ib_wc
*in_wc
,
89 const struct ib_grh
*in_grh
,
90 const struct ib_mad_hdr
*in_mad
,
92 struct ib_mad_hdr
*out_mad
,
94 u16
*out_mad_pkey_index
)
99 static int iwch_dealloc_ucontext(struct ib_ucontext
*context
)
101 struct iwch_dev
*rhp
= to_iwch_dev(context
->device
);
102 struct iwch_ucontext
*ucontext
= to_iwch_ucontext(context
);
103 struct iwch_mm_entry
*mm
, *tmp
;
105 PDBG("%s context %p\n", __func__
, context
);
106 list_for_each_entry_safe(mm
, tmp
, &ucontext
->mmaps
, entry
)
108 cxio_release_ucontext(&rhp
->rdev
, &ucontext
->uctx
);
113 static struct ib_ucontext
*iwch_alloc_ucontext(struct ib_device
*ibdev
,
114 struct ib_udata
*udata
)
116 struct iwch_ucontext
*context
;
117 struct iwch_dev
*rhp
= to_iwch_dev(ibdev
);
119 PDBG("%s ibdev %p\n", __func__
, ibdev
);
120 context
= kzalloc(sizeof(*context
), GFP_KERNEL
);
122 return ERR_PTR(-ENOMEM
);
123 cxio_init_ucontext(&rhp
->rdev
, &context
->uctx
);
124 INIT_LIST_HEAD(&context
->mmaps
);
125 spin_lock_init(&context
->mmap_lock
);
126 return &context
->ibucontext
;
129 static int iwch_destroy_cq(struct ib_cq
*ib_cq
)
133 PDBG("%s ib_cq %p\n", __func__
, ib_cq
);
134 chp
= to_iwch_cq(ib_cq
);
136 remove_handle(chp
->rhp
, &chp
->rhp
->cqidr
, chp
->cq
.cqid
);
137 atomic_dec(&chp
->refcnt
);
138 wait_event(chp
->wait
, !atomic_read(&chp
->refcnt
));
140 cxio_destroy_cq(&chp
->rhp
->rdev
, &chp
->cq
);
145 static struct ib_cq
*iwch_create_cq(struct ib_device
*ibdev
,
146 const struct ib_cq_init_attr
*attr
,
147 struct ib_ucontext
*ib_context
,
148 struct ib_udata
*udata
)
150 int entries
= attr
->cqe
;
151 struct iwch_dev
*rhp
;
153 struct iwch_create_cq_resp uresp
;
154 struct iwch_create_cq_req ureq
;
155 struct iwch_ucontext
*ucontext
= NULL
;
159 PDBG("%s ib_dev %p entries %d\n", __func__
, ibdev
, entries
);
161 return ERR_PTR(-EINVAL
);
163 rhp
= to_iwch_dev(ibdev
);
164 chp
= kzalloc(sizeof(*chp
), GFP_KERNEL
);
166 return ERR_PTR(-ENOMEM
);
169 ucontext
= to_iwch_ucontext(ib_context
);
170 if (!t3a_device(rhp
)) {
171 if (ib_copy_from_udata(&ureq
, udata
, sizeof (ureq
))) {
173 return ERR_PTR(-EFAULT
);
175 chp
->user_rptr_addr
= (u32 __user
*)(unsigned long)ureq
.user_rptr_addr
;
179 if (t3a_device(rhp
)) {
182 * T3A: Add some fluff to handle extra CQEs inserted
183 * for various errors.
184 * Additional CQE possibilities:
186 * incoming RDMA WRITE Failures
187 * incoming RDMA READ REQUEST FAILUREs
188 * NOTE: We cannot ensure the CQ won't overflow.
192 entries
= roundup_pow_of_two(entries
);
193 chp
->cq
.size_log2
= ilog2(entries
);
195 if (cxio_create_cq(&rhp
->rdev
, &chp
->cq
, !ucontext
)) {
197 return ERR_PTR(-ENOMEM
);
200 chp
->ibcq
.cqe
= 1 << chp
->cq
.size_log2
;
201 spin_lock_init(&chp
->lock
);
202 spin_lock_init(&chp
->comp_handler_lock
);
203 atomic_set(&chp
->refcnt
, 1);
204 init_waitqueue_head(&chp
->wait
);
205 if (insert_handle(rhp
, &rhp
->cqidr
, chp
, chp
->cq
.cqid
)) {
206 cxio_destroy_cq(&chp
->rhp
->rdev
, &chp
->cq
);
208 return ERR_PTR(-ENOMEM
);
212 struct iwch_mm_entry
*mm
;
214 mm
= kmalloc(sizeof *mm
, GFP_KERNEL
);
216 iwch_destroy_cq(&chp
->ibcq
);
217 return ERR_PTR(-ENOMEM
);
219 uresp
.cqid
= chp
->cq
.cqid
;
220 uresp
.size_log2
= chp
->cq
.size_log2
;
221 spin_lock(&ucontext
->mmap_lock
);
222 uresp
.key
= ucontext
->key
;
223 ucontext
->key
+= PAGE_SIZE
;
224 spin_unlock(&ucontext
->mmap_lock
);
226 mm
->addr
= virt_to_phys(chp
->cq
.queue
);
227 if (udata
->outlen
< sizeof uresp
) {
229 printk(KERN_WARNING MOD
"Warning - "
230 "downlevel libcxgb3 (non-fatal).\n");
231 mm
->len
= PAGE_ALIGN((1UL << uresp
.size_log2
) *
232 sizeof(struct t3_cqe
));
233 resplen
= sizeof(struct iwch_create_cq_resp_v0
);
235 mm
->len
= PAGE_ALIGN(((1UL << uresp
.size_log2
) + 1) *
236 sizeof(struct t3_cqe
));
237 uresp
.memsize
= mm
->len
;
239 resplen
= sizeof uresp
;
241 if (ib_copy_to_udata(udata
, &uresp
, resplen
)) {
243 iwch_destroy_cq(&chp
->ibcq
);
244 return ERR_PTR(-EFAULT
);
246 insert_mmap(ucontext
, mm
);
248 PDBG("created cqid 0x%0x chp %p size 0x%0x, dma_addr 0x%0llx\n",
249 chp
->cq
.cqid
, chp
, (1 << chp
->cq
.size_log2
),
250 (unsigned long long) chp
->cq
.dma_addr
);
254 static int iwch_resize_cq(struct ib_cq
*cq
, int cqe
, struct ib_udata
*udata
)
257 struct iwch_cq
*chp
= to_iwch_cq(cq
);
258 struct t3_cq oldcq
, newcq
;
261 PDBG("%s ib_cq %p cqe %d\n", __func__
, cq
, cqe
);
263 /* We don't downsize... */
267 /* create new t3_cq with new size */
268 cqe
= roundup_pow_of_two(cqe
+1);
269 newcq
.size_log2
= ilog2(cqe
);
271 /* Dont allow resize to less than the current wce count */
272 if (cqe
< Q_COUNT(chp
->cq
.rptr
, chp
->cq
.wptr
)) {
276 /* Quiesce all QPs using this CQ */
277 ret
= iwch_quiesce_qps(chp
);
282 ret
= cxio_create_cq(&chp
->rhp
->rdev
, &newcq
);
288 memcpy(newcq
.queue
, chp
->cq
.queue
, (1 << chp
->cq
.size_log2
) *
289 sizeof(struct t3_cqe
));
291 /* old iwch_qp gets new t3_cq but keeps old cqid */
294 chp
->cq
.cqid
= oldcq
.cqid
;
296 /* resize new t3_cq to update the HW context */
297 ret
= cxio_resize_cq(&chp
->rhp
->rdev
, &chp
->cq
);
302 chp
->ibcq
.cqe
= (1<<chp
->cq
.size_log2
) - 1;
304 /* destroy old t3_cq */
305 oldcq
.cqid
= newcq
.cqid
;
306 ret
= cxio_destroy_cq(&chp
->rhp
->rdev
, &oldcq
);
308 printk(KERN_ERR MOD
"%s - cxio_destroy_cq failed %d\n",
312 /* add user hooks here */
315 ret
= iwch_resume_qps(chp
);
322 static int iwch_arm_cq(struct ib_cq
*ibcq
, enum ib_cq_notify_flags flags
)
324 struct iwch_dev
*rhp
;
326 enum t3_cq_opcode cq_op
;
331 chp
= to_iwch_cq(ibcq
);
333 if ((flags
& IB_CQ_SOLICITED_MASK
) == IB_CQ_SOLICITED
)
337 if (chp
->user_rptr_addr
) {
338 if (get_user(rptr
, chp
->user_rptr_addr
))
340 spin_lock_irqsave(&chp
->lock
, flag
);
343 spin_lock_irqsave(&chp
->lock
, flag
);
344 PDBG("%s rptr 0x%x\n", __func__
, chp
->cq
.rptr
);
345 err
= cxio_hal_cq_op(&rhp
->rdev
, &chp
->cq
, cq_op
, 0);
346 spin_unlock_irqrestore(&chp
->lock
, flag
);
348 printk(KERN_ERR MOD
"Error %d rearming CQID 0x%x\n", err
,
350 if (err
> 0 && !(flags
& IB_CQ_REPORT_MISSED_EVENTS
))
355 static int iwch_mmap(struct ib_ucontext
*context
, struct vm_area_struct
*vma
)
357 int len
= vma
->vm_end
- vma
->vm_start
;
358 u32 key
= vma
->vm_pgoff
<< PAGE_SHIFT
;
359 struct cxio_rdev
*rdev_p
;
361 struct iwch_mm_entry
*mm
;
362 struct iwch_ucontext
*ucontext
;
365 PDBG("%s pgoff 0x%lx key 0x%x len %d\n", __func__
, vma
->vm_pgoff
,
368 if (vma
->vm_start
& (PAGE_SIZE
-1)) {
372 rdev_p
= &(to_iwch_dev(context
->device
)->rdev
);
373 ucontext
= to_iwch_ucontext(context
);
375 mm
= remove_mmap(ucontext
, key
, len
);
381 if ((addr
>= rdev_p
->rnic_info
.udbell_physbase
) &&
382 (addr
< (rdev_p
->rnic_info
.udbell_physbase
+
383 rdev_p
->rnic_info
.udbell_len
))) {
386 * Map T3 DB register.
388 if (vma
->vm_flags
& VM_READ
) {
392 vma
->vm_page_prot
= pgprot_noncached(vma
->vm_page_prot
);
393 vma
->vm_flags
|= VM_DONTCOPY
| VM_DONTEXPAND
;
394 vma
->vm_flags
&= ~VM_MAYREAD
;
395 ret
= io_remap_pfn_range(vma
, vma
->vm_start
,
397 len
, vma
->vm_page_prot
);
401 * Map WQ or CQ contig dma memory...
403 ret
= remap_pfn_range(vma
, vma
->vm_start
,
405 len
, vma
->vm_page_prot
);
411 static int iwch_deallocate_pd(struct ib_pd
*pd
)
413 struct iwch_dev
*rhp
;
416 php
= to_iwch_pd(pd
);
418 PDBG("%s ibpd %p pdid 0x%x\n", __func__
, pd
, php
->pdid
);
419 cxio_hal_put_pdid(rhp
->rdev
.rscp
, php
->pdid
);
424 static struct ib_pd
*iwch_allocate_pd(struct ib_device
*ibdev
,
425 struct ib_ucontext
*context
,
426 struct ib_udata
*udata
)
430 struct iwch_dev
*rhp
;
432 PDBG("%s ibdev %p\n", __func__
, ibdev
);
433 rhp
= (struct iwch_dev
*) ibdev
;
434 pdid
= cxio_hal_get_pdid(rhp
->rdev
.rscp
);
436 return ERR_PTR(-EINVAL
);
437 php
= kzalloc(sizeof(*php
), GFP_KERNEL
);
439 cxio_hal_put_pdid(rhp
->rdev
.rscp
, pdid
);
440 return ERR_PTR(-ENOMEM
);
445 if (ib_copy_to_udata(udata
, &php
->pdid
, sizeof (__u32
))) {
446 iwch_deallocate_pd(&php
->ibpd
);
447 return ERR_PTR(-EFAULT
);
450 PDBG("%s pdid 0x%0x ptr 0x%p\n", __func__
, pdid
, php
);
454 static int iwch_dereg_mr(struct ib_mr
*ib_mr
)
456 struct iwch_dev
*rhp
;
460 PDBG("%s ib_mr %p\n", __func__
, ib_mr
);
462 mhp
= to_iwch_mr(ib_mr
);
465 mmid
= mhp
->attr
.stag
>> 8;
466 cxio_dereg_mem(&rhp
->rdev
, mhp
->attr
.stag
, mhp
->attr
.pbl_size
,
469 remove_handle(rhp
, &rhp
->mmidr
, mmid
);
471 kfree((void *) (unsigned long) mhp
->kva
);
473 ib_umem_release(mhp
->umem
);
474 PDBG("%s mmid 0x%x ptr %p\n", __func__
, mmid
, mhp
);
479 static struct ib_mr
*iwch_get_dma_mr(struct ib_pd
*pd
, int acc
)
481 const u64 total_size
= 0xffffffff;
482 const u64 mask
= (total_size
+ PAGE_SIZE
- 1) & PAGE_MASK
;
483 struct iwch_pd
*php
= to_iwch_pd(pd
);
484 struct iwch_dev
*rhp
= php
->rhp
;
487 int shift
= 26, npages
, ret
, i
;
489 PDBG("%s ib_pd %p\n", __func__
, pd
);
492 * T3 only supports 32 bits of size.
494 if (sizeof(phys_addr_t
) > 4) {
495 pr_warn_once(MOD
"Cannot support dma_mrs on this platform.\n");
496 return ERR_PTR(-ENOTSUPP
);
499 mhp
= kzalloc(sizeof(*mhp
), GFP_KERNEL
);
501 return ERR_PTR(-ENOMEM
);
505 npages
= (total_size
+ (1ULL << shift
) - 1) >> shift
;
511 page_list
= kmalloc_array(npages
, sizeof(u64
), GFP_KERNEL
);
517 for (i
= 0; i
< npages
; i
++)
518 page_list
[i
] = cpu_to_be64((u64
)i
<< shift
);
520 PDBG("%s mask 0x%llx shift %d len %lld pbl_size %d\n",
521 __func__
, mask
, shift
, total_size
, npages
);
523 ret
= iwch_alloc_pbl(mhp
, npages
);
529 ret
= iwch_write_pbl(mhp
, page_list
, npages
, 0);
534 mhp
->attr
.pdid
= php
->pdid
;
537 mhp
->attr
.perms
= iwch_ib_to_tpt_access(acc
);
538 mhp
->attr
.va_fbo
= 0;
539 mhp
->attr
.page_size
= shift
- 12;
541 mhp
->attr
.len
= (u32
) total_size
;
542 mhp
->attr
.pbl_size
= npages
;
543 ret
= iwch_register_mem(rhp
, php
, mhp
, shift
);
557 static struct ib_mr
*iwch_reg_user_mr(struct ib_pd
*pd
, u64 start
, u64 length
,
558 u64 virt
, int acc
, struct ib_udata
*udata
)
564 struct iwch_dev
*rhp
;
567 struct iwch_reg_user_mr_resp uresp
;
568 struct scatterlist
*sg
;
569 PDBG("%s ib_pd %p\n", __func__
, pd
);
571 php
= to_iwch_pd(pd
);
573 mhp
= kzalloc(sizeof(*mhp
), GFP_KERNEL
);
575 return ERR_PTR(-ENOMEM
);
579 mhp
->umem
= ib_umem_get(pd
->uobject
->context
, start
, length
, acc
, 0);
580 if (IS_ERR(mhp
->umem
)) {
581 err
= PTR_ERR(mhp
->umem
);
586 shift
= ffs(mhp
->umem
->page_size
) - 1;
590 err
= iwch_alloc_pbl(mhp
, n
);
594 pages
= (__be64
*) __get_free_page(GFP_KERNEL
);
602 for_each_sg(mhp
->umem
->sg_head
.sgl
, sg
, mhp
->umem
->nmap
, entry
) {
603 len
= sg_dma_len(sg
) >> shift
;
604 for (k
= 0; k
< len
; ++k
) {
605 pages
[i
++] = cpu_to_be64(sg_dma_address(sg
) +
606 mhp
->umem
->page_size
* k
);
607 if (i
== PAGE_SIZE
/ sizeof *pages
) {
608 err
= iwch_write_pbl(mhp
, pages
, i
, n
);
618 err
= iwch_write_pbl(mhp
, pages
, i
, n
);
621 free_page((unsigned long) pages
);
625 mhp
->attr
.pdid
= php
->pdid
;
627 mhp
->attr
.perms
= iwch_ib_to_tpt_access(acc
);
628 mhp
->attr
.va_fbo
= virt
;
629 mhp
->attr
.page_size
= shift
- 12;
630 mhp
->attr
.len
= (u32
) length
;
632 err
= iwch_register_mem(rhp
, php
, mhp
, shift
);
636 if (udata
&& !t3a_device(rhp
)) {
637 uresp
.pbl_addr
= (mhp
->attr
.pbl_addr
-
638 rhp
->rdev
.rnic_info
.pbl_base
) >> 3;
639 PDBG("%s user resp pbl_addr 0x%x\n", __func__
,
642 if (ib_copy_to_udata(udata
, &uresp
, sizeof (uresp
))) {
643 iwch_dereg_mr(&mhp
->ibmr
);
655 ib_umem_release(mhp
->umem
);
660 static struct ib_mw
*iwch_alloc_mw(struct ib_pd
*pd
, enum ib_mw_type type
,
661 struct ib_udata
*udata
)
663 struct iwch_dev
*rhp
;
670 if (type
!= IB_MW_TYPE_1
)
671 return ERR_PTR(-EINVAL
);
673 php
= to_iwch_pd(pd
);
675 mhp
= kzalloc(sizeof(*mhp
), GFP_KERNEL
);
677 return ERR_PTR(-ENOMEM
);
678 ret
= cxio_allocate_window(&rhp
->rdev
, &stag
, php
->pdid
);
684 mhp
->attr
.pdid
= php
->pdid
;
685 mhp
->attr
.type
= TPT_MW
;
686 mhp
->attr
.stag
= stag
;
688 mhp
->ibmw
.rkey
= stag
;
689 if (insert_handle(rhp
, &rhp
->mmidr
, mhp
, mmid
)) {
690 cxio_deallocate_window(&rhp
->rdev
, mhp
->attr
.stag
);
692 return ERR_PTR(-ENOMEM
);
694 PDBG("%s mmid 0x%x mhp %p stag 0x%x\n", __func__
, mmid
, mhp
, stag
);
698 static int iwch_dealloc_mw(struct ib_mw
*mw
)
700 struct iwch_dev
*rhp
;
704 mhp
= to_iwch_mw(mw
);
706 mmid
= (mw
->rkey
) >> 8;
707 cxio_deallocate_window(&rhp
->rdev
, mhp
->attr
.stag
);
708 remove_handle(rhp
, &rhp
->mmidr
, mmid
);
709 PDBG("%s ib_mw %p mmid 0x%x ptr %p\n", __func__
, mw
, mmid
, mhp
);
714 static struct ib_mr
*iwch_alloc_mr(struct ib_pd
*pd
,
715 enum ib_mr_type mr_type
,
718 struct iwch_dev
*rhp
;
725 if (mr_type
!= IB_MR_TYPE_MEM_REG
||
726 max_num_sg
> T3_MAX_FASTREG_DEPTH
)
727 return ERR_PTR(-EINVAL
);
729 php
= to_iwch_pd(pd
);
731 mhp
= kzalloc(sizeof(*mhp
), GFP_KERNEL
);
735 mhp
->pages
= kcalloc(max_num_sg
, sizeof(u64
), GFP_KERNEL
);
742 ret
= iwch_alloc_pbl(mhp
, max_num_sg
);
745 mhp
->attr
.pbl_size
= max_num_sg
;
746 ret
= cxio_allocate_stag(&rhp
->rdev
, &stag
, php
->pdid
,
747 mhp
->attr
.pbl_size
, mhp
->attr
.pbl_addr
);
750 mhp
->attr
.pdid
= php
->pdid
;
751 mhp
->attr
.type
= TPT_NON_SHARED_MR
;
752 mhp
->attr
.stag
= stag
;
755 mhp
->ibmr
.rkey
= mhp
->ibmr
.lkey
= stag
;
756 if (insert_handle(rhp
, &rhp
->mmidr
, mhp
, mmid
))
759 PDBG("%s mmid 0x%x mhp %p stag 0x%x\n", __func__
, mmid
, mhp
, stag
);
762 cxio_dereg_mem(&rhp
->rdev
, stag
, mhp
->attr
.pbl_size
,
774 static int iwch_set_page(struct ib_mr
*ibmr
, u64 addr
)
776 struct iwch_mr
*mhp
= to_iwch_mr(ibmr
);
778 if (unlikely(mhp
->npages
== mhp
->attr
.pbl_size
))
781 mhp
->pages
[mhp
->npages
++] = addr
;
786 static int iwch_map_mr_sg(struct ib_mr
*ibmr
,
787 struct scatterlist
*sg
,
790 struct iwch_mr
*mhp
= to_iwch_mr(ibmr
);
794 return ib_sg_to_pages(ibmr
, sg
, sg_nents
, iwch_set_page
);
797 static int iwch_destroy_qp(struct ib_qp
*ib_qp
)
799 struct iwch_dev
*rhp
;
801 struct iwch_qp_attributes attrs
;
802 struct iwch_ucontext
*ucontext
;
804 qhp
= to_iwch_qp(ib_qp
);
807 attrs
.next_state
= IWCH_QP_STATE_ERROR
;
808 iwch_modify_qp(rhp
, qhp
, IWCH_QP_ATTR_NEXT_STATE
, &attrs
, 0);
809 wait_event(qhp
->wait
, !qhp
->ep
);
811 remove_handle(rhp
, &rhp
->qpidr
, qhp
->wq
.qpid
);
813 atomic_dec(&qhp
->refcnt
);
814 wait_event(qhp
->wait
, !atomic_read(&qhp
->refcnt
));
816 ucontext
= ib_qp
->uobject
? to_iwch_ucontext(ib_qp
->uobject
->context
)
818 cxio_destroy_qp(&rhp
->rdev
, &qhp
->wq
,
819 ucontext
? &ucontext
->uctx
: &rhp
->rdev
.uctx
);
821 PDBG("%s ib_qp %p qpid 0x%0x qhp %p\n", __func__
,
822 ib_qp
, qhp
->wq
.qpid
, qhp
);
827 static struct ib_qp
*iwch_create_qp(struct ib_pd
*pd
,
828 struct ib_qp_init_attr
*attrs
,
829 struct ib_udata
*udata
)
831 struct iwch_dev
*rhp
;
834 struct iwch_cq
*schp
;
835 struct iwch_cq
*rchp
;
836 struct iwch_create_qp_resp uresp
;
837 int wqsize
, sqsize
, rqsize
;
838 struct iwch_ucontext
*ucontext
;
840 PDBG("%s ib_pd %p\n", __func__
, pd
);
841 if (attrs
->qp_type
!= IB_QPT_RC
)
842 return ERR_PTR(-EINVAL
);
843 php
= to_iwch_pd(pd
);
845 schp
= get_chp(rhp
, ((struct iwch_cq
*) attrs
->send_cq
)->cq
.cqid
);
846 rchp
= get_chp(rhp
, ((struct iwch_cq
*) attrs
->recv_cq
)->cq
.cqid
);
848 return ERR_PTR(-EINVAL
);
850 /* The RQT size must be # of entries + 1 rounded up to a power of two */
851 rqsize
= roundup_pow_of_two(attrs
->cap
.max_recv_wr
);
852 if (rqsize
== attrs
->cap
.max_recv_wr
)
853 rqsize
= roundup_pow_of_two(attrs
->cap
.max_recv_wr
+1);
855 /* T3 doesn't support RQT depth < 16 */
859 if (rqsize
> T3_MAX_RQ_SIZE
)
860 return ERR_PTR(-EINVAL
);
862 if (attrs
->cap
.max_inline_data
> T3_MAX_INLINE
)
863 return ERR_PTR(-EINVAL
);
866 * NOTE: The SQ and total WQ sizes don't need to be
867 * a power of two. However, all the code assumes
868 * they are. EG: Q_FREECNT() and friends.
870 sqsize
= roundup_pow_of_two(attrs
->cap
.max_send_wr
);
871 wqsize
= roundup_pow_of_two(rqsize
+ sqsize
);
874 * Kernel users need more wq space for fastreg WRs which can take
877 ucontext
= pd
->uobject
? to_iwch_ucontext(pd
->uobject
->context
) : NULL
;
878 if (!ucontext
&& wqsize
< (rqsize
+ (2 * sqsize
)))
879 wqsize
= roundup_pow_of_two(rqsize
+
880 roundup_pow_of_two(attrs
->cap
.max_send_wr
* 2));
881 PDBG("%s wqsize %d sqsize %d rqsize %d\n", __func__
,
882 wqsize
, sqsize
, rqsize
);
883 qhp
= kzalloc(sizeof(*qhp
), GFP_KERNEL
);
885 return ERR_PTR(-ENOMEM
);
886 qhp
->wq
.size_log2
= ilog2(wqsize
);
887 qhp
->wq
.rq_size_log2
= ilog2(rqsize
);
888 qhp
->wq
.sq_size_log2
= ilog2(sqsize
);
889 if (cxio_create_qp(&rhp
->rdev
, !udata
, &qhp
->wq
,
890 ucontext
? &ucontext
->uctx
: &rhp
->rdev
.uctx
)) {
892 return ERR_PTR(-ENOMEM
);
895 attrs
->cap
.max_recv_wr
= rqsize
- 1;
896 attrs
->cap
.max_send_wr
= sqsize
;
897 attrs
->cap
.max_inline_data
= T3_MAX_INLINE
;
900 qhp
->attr
.pd
= php
->pdid
;
901 qhp
->attr
.scq
= ((struct iwch_cq
*) attrs
->send_cq
)->cq
.cqid
;
902 qhp
->attr
.rcq
= ((struct iwch_cq
*) attrs
->recv_cq
)->cq
.cqid
;
903 qhp
->attr
.sq_num_entries
= attrs
->cap
.max_send_wr
;
904 qhp
->attr
.rq_num_entries
= attrs
->cap
.max_recv_wr
;
905 qhp
->attr
.sq_max_sges
= attrs
->cap
.max_send_sge
;
906 qhp
->attr
.sq_max_sges_rdma_write
= attrs
->cap
.max_send_sge
;
907 qhp
->attr
.rq_max_sges
= attrs
->cap
.max_recv_sge
;
908 qhp
->attr
.state
= IWCH_QP_STATE_IDLE
;
909 qhp
->attr
.next_state
= IWCH_QP_STATE_IDLE
;
912 * XXX - These don't get passed in from the openib user
913 * at create time. The CM sets them via a QP modify.
914 * Need to fix... I think the CM should
916 qhp
->attr
.enable_rdma_read
= 1;
917 qhp
->attr
.enable_rdma_write
= 1;
918 qhp
->attr
.enable_bind
= 1;
919 qhp
->attr
.max_ord
= 1;
920 qhp
->attr
.max_ird
= 1;
922 spin_lock_init(&qhp
->lock
);
923 init_waitqueue_head(&qhp
->wait
);
924 atomic_set(&qhp
->refcnt
, 1);
926 if (insert_handle(rhp
, &rhp
->qpidr
, qhp
, qhp
->wq
.qpid
)) {
927 cxio_destroy_qp(&rhp
->rdev
, &qhp
->wq
,
928 ucontext
? &ucontext
->uctx
: &rhp
->rdev
.uctx
);
930 return ERR_PTR(-ENOMEM
);
935 struct iwch_mm_entry
*mm1
, *mm2
;
937 mm1
= kmalloc(sizeof *mm1
, GFP_KERNEL
);
939 iwch_destroy_qp(&qhp
->ibqp
);
940 return ERR_PTR(-ENOMEM
);
943 mm2
= kmalloc(sizeof *mm2
, GFP_KERNEL
);
946 iwch_destroy_qp(&qhp
->ibqp
);
947 return ERR_PTR(-ENOMEM
);
950 uresp
.qpid
= qhp
->wq
.qpid
;
951 uresp
.size_log2
= qhp
->wq
.size_log2
;
952 uresp
.sq_size_log2
= qhp
->wq
.sq_size_log2
;
953 uresp
.rq_size_log2
= qhp
->wq
.rq_size_log2
;
954 spin_lock(&ucontext
->mmap_lock
);
955 uresp
.key
= ucontext
->key
;
956 ucontext
->key
+= PAGE_SIZE
;
957 uresp
.db_key
= ucontext
->key
;
958 ucontext
->key
+= PAGE_SIZE
;
959 spin_unlock(&ucontext
->mmap_lock
);
960 if (ib_copy_to_udata(udata
, &uresp
, sizeof (uresp
))) {
963 iwch_destroy_qp(&qhp
->ibqp
);
964 return ERR_PTR(-EFAULT
);
966 mm1
->key
= uresp
.key
;
967 mm1
->addr
= virt_to_phys(qhp
->wq
.queue
);
968 mm1
->len
= PAGE_ALIGN(wqsize
* sizeof (union t3_wr
));
969 insert_mmap(ucontext
, mm1
);
970 mm2
->key
= uresp
.db_key
;
971 mm2
->addr
= qhp
->wq
.udb
& PAGE_MASK
;
972 mm2
->len
= PAGE_SIZE
;
973 insert_mmap(ucontext
, mm2
);
975 qhp
->ibqp
.qp_num
= qhp
->wq
.qpid
;
976 init_timer(&(qhp
->timer
));
977 PDBG("%s sq_num_entries %d, rq_num_entries %d "
978 "qpid 0x%0x qhp %p dma_addr 0x%llx size %d rq_addr 0x%x\n",
979 __func__
, qhp
->attr
.sq_num_entries
, qhp
->attr
.rq_num_entries
,
980 qhp
->wq
.qpid
, qhp
, (unsigned long long) qhp
->wq
.dma_addr
,
981 1 << qhp
->wq
.size_log2
, qhp
->wq
.rq_addr
);
985 static int iwch_ib_modify_qp(struct ib_qp
*ibqp
, struct ib_qp_attr
*attr
,
986 int attr_mask
, struct ib_udata
*udata
)
988 struct iwch_dev
*rhp
;
990 enum iwch_qp_attr_mask mask
= 0;
991 struct iwch_qp_attributes attrs
;
993 PDBG("%s ib_qp %p\n", __func__
, ibqp
);
995 /* iwarp does not support the RTR state */
996 if ((attr_mask
& IB_QP_STATE
) && (attr
->qp_state
== IB_QPS_RTR
))
997 attr_mask
&= ~IB_QP_STATE
;
999 /* Make sure we still have something left to do */
1003 memset(&attrs
, 0, sizeof attrs
);
1004 qhp
= to_iwch_qp(ibqp
);
1007 attrs
.next_state
= iwch_convert_state(attr
->qp_state
);
1008 attrs
.enable_rdma_read
= (attr
->qp_access_flags
&
1009 IB_ACCESS_REMOTE_READ
) ? 1 : 0;
1010 attrs
.enable_rdma_write
= (attr
->qp_access_flags
&
1011 IB_ACCESS_REMOTE_WRITE
) ? 1 : 0;
1012 attrs
.enable_bind
= (attr
->qp_access_flags
& IB_ACCESS_MW_BIND
) ? 1 : 0;
1015 mask
|= (attr_mask
& IB_QP_STATE
) ? IWCH_QP_ATTR_NEXT_STATE
: 0;
1016 mask
|= (attr_mask
& IB_QP_ACCESS_FLAGS
) ?
1017 (IWCH_QP_ATTR_ENABLE_RDMA_READ
|
1018 IWCH_QP_ATTR_ENABLE_RDMA_WRITE
|
1019 IWCH_QP_ATTR_ENABLE_RDMA_BIND
) : 0;
1021 return iwch_modify_qp(rhp
, qhp
, mask
, &attrs
, 0);
1024 void iwch_qp_add_ref(struct ib_qp
*qp
)
1026 PDBG("%s ib_qp %p\n", __func__
, qp
);
1027 atomic_inc(&(to_iwch_qp(qp
)->refcnt
));
1030 void iwch_qp_rem_ref(struct ib_qp
*qp
)
1032 PDBG("%s ib_qp %p\n", __func__
, qp
);
1033 if (atomic_dec_and_test(&(to_iwch_qp(qp
)->refcnt
)))
1034 wake_up(&(to_iwch_qp(qp
)->wait
));
1037 static struct ib_qp
*iwch_get_qp(struct ib_device
*dev
, int qpn
)
1039 PDBG("%s ib_dev %p qpn 0x%x\n", __func__
, dev
, qpn
);
1040 return (struct ib_qp
*)get_qhp(to_iwch_dev(dev
), qpn
);
1044 static int iwch_query_pkey(struct ib_device
*ibdev
,
1045 u8 port
, u16 index
, u16
* pkey
)
1047 PDBG("%s ibdev %p\n", __func__
, ibdev
);
1052 static int iwch_query_gid(struct ib_device
*ibdev
, u8 port
,
1053 int index
, union ib_gid
*gid
)
1055 struct iwch_dev
*dev
;
1057 PDBG("%s ibdev %p, port %d, index %d, gid %p\n",
1058 __func__
, ibdev
, port
, index
, gid
);
1059 dev
= to_iwch_dev(ibdev
);
1060 BUG_ON(port
== 0 || port
> 2);
1061 memset(&(gid
->raw
[0]), 0, sizeof(gid
->raw
));
1062 memcpy(&(gid
->raw
[0]), dev
->rdev
.port_info
.lldevs
[port
-1]->dev_addr
, 6);
1066 static u64
fw_vers_string_to_u64(struct iwch_dev
*iwch_dev
)
1068 struct ethtool_drvinfo info
;
1069 struct net_device
*lldev
= iwch_dev
->rdev
.t3cdev_p
->lldev
;
1071 unsigned fw_maj
, fw_min
, fw_mic
;
1073 lldev
->ethtool_ops
->get_drvinfo(lldev
, &info
);
1075 next
= info
.fw_version
+ 1;
1076 cp
= strsep(&next
, ".");
1077 sscanf(cp
, "%i", &fw_maj
);
1078 cp
= strsep(&next
, ".");
1079 sscanf(cp
, "%i", &fw_min
);
1080 cp
= strsep(&next
, ".");
1081 sscanf(cp
, "%i", &fw_mic
);
1083 return (((u64
)fw_maj
& 0xffff) << 32) | ((fw_min
& 0xffff) << 16) |
1087 static int iwch_query_device(struct ib_device
*ibdev
, struct ib_device_attr
*props
,
1088 struct ib_udata
*uhw
)
1091 struct iwch_dev
*dev
;
1093 PDBG("%s ibdev %p\n", __func__
, ibdev
);
1095 if (uhw
->inlen
|| uhw
->outlen
)
1098 dev
= to_iwch_dev(ibdev
);
1099 memset(props
, 0, sizeof *props
);
1100 memcpy(&props
->sys_image_guid
, dev
->rdev
.t3cdev_p
->lldev
->dev_addr
, 6);
1101 props
->hw_ver
= dev
->rdev
.t3cdev_p
->type
;
1102 props
->fw_ver
= fw_vers_string_to_u64(dev
);
1103 props
->device_cap_flags
= dev
->device_cap_flags
;
1104 props
->page_size_cap
= dev
->attr
.mem_pgsizes_bitmask
;
1105 props
->vendor_id
= (u32
)dev
->rdev
.rnic_info
.pdev
->vendor
;
1106 props
->vendor_part_id
= (u32
)dev
->rdev
.rnic_info
.pdev
->device
;
1107 props
->max_mr_size
= dev
->attr
.max_mr_size
;
1108 props
->max_qp
= dev
->attr
.max_qps
;
1109 props
->max_qp_wr
= dev
->attr
.max_wrs
;
1110 props
->max_sge
= dev
->attr
.max_sge_per_wr
;
1111 props
->max_sge_rd
= 1;
1112 props
->max_qp_rd_atom
= dev
->attr
.max_rdma_reads_per_qp
;
1113 props
->max_qp_init_rd_atom
= dev
->attr
.max_rdma_reads_per_qp
;
1114 props
->max_cq
= dev
->attr
.max_cqs
;
1115 props
->max_cqe
= dev
->attr
.max_cqes_per_cq
;
1116 props
->max_mr
= dev
->attr
.max_mem_regs
;
1117 props
->max_pd
= dev
->attr
.max_pds
;
1118 props
->local_ca_ack_delay
= 0;
1119 props
->max_fast_reg_page_list_len
= T3_MAX_FASTREG_DEPTH
;
1124 static int iwch_query_port(struct ib_device
*ibdev
,
1125 u8 port
, struct ib_port_attr
*props
)
1127 struct iwch_dev
*dev
;
1128 struct net_device
*netdev
;
1129 struct in_device
*inetdev
;
1131 PDBG("%s ibdev %p\n", __func__
, ibdev
);
1133 dev
= to_iwch_dev(ibdev
);
1134 netdev
= dev
->rdev
.port_info
.lldevs
[port
-1];
1136 memset(props
, 0, sizeof(struct ib_port_attr
));
1137 props
->max_mtu
= IB_MTU_4096
;
1138 if (netdev
->mtu
>= 4096)
1139 props
->active_mtu
= IB_MTU_4096
;
1140 else if (netdev
->mtu
>= 2048)
1141 props
->active_mtu
= IB_MTU_2048
;
1142 else if (netdev
->mtu
>= 1024)
1143 props
->active_mtu
= IB_MTU_1024
;
1144 else if (netdev
->mtu
>= 512)
1145 props
->active_mtu
= IB_MTU_512
;
1147 props
->active_mtu
= IB_MTU_256
;
1149 if (!netif_carrier_ok(netdev
))
1150 props
->state
= IB_PORT_DOWN
;
1152 inetdev
= in_dev_get(netdev
);
1154 if (inetdev
->ifa_list
)
1155 props
->state
= IB_PORT_ACTIVE
;
1157 props
->state
= IB_PORT_INIT
;
1158 in_dev_put(inetdev
);
1160 props
->state
= IB_PORT_INIT
;
1163 props
->port_cap_flags
=
1165 IB_PORT_SNMP_TUNNEL_SUP
|
1166 IB_PORT_REINIT_SUP
|
1167 IB_PORT_DEVICE_MGMT_SUP
|
1168 IB_PORT_VENDOR_CLASS_SUP
| IB_PORT_BOOT_MGMT_SUP
;
1169 props
->gid_tbl_len
= 1;
1170 props
->pkey_tbl_len
= 1;
1171 props
->active_width
= 2;
1172 props
->active_speed
= IB_SPEED_DDR
;
1173 props
->max_msg_sz
= -1;
1178 static ssize_t
show_rev(struct device
*dev
, struct device_attribute
*attr
,
1181 struct iwch_dev
*iwch_dev
= container_of(dev
, struct iwch_dev
,
1183 PDBG("%s dev 0x%p\n", __func__
, dev
);
1184 return sprintf(buf
, "%d\n", iwch_dev
->rdev
.t3cdev_p
->type
);
1187 static ssize_t
show_fw_ver(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1189 struct iwch_dev
*iwch_dev
= container_of(dev
, struct iwch_dev
,
1191 struct ethtool_drvinfo info
;
1192 struct net_device
*lldev
= iwch_dev
->rdev
.t3cdev_p
->lldev
;
1194 PDBG("%s dev 0x%p\n", __func__
, dev
);
1195 lldev
->ethtool_ops
->get_drvinfo(lldev
, &info
);
1196 return sprintf(buf
, "%s\n", info
.fw_version
);
1199 static ssize_t
show_hca(struct device
*dev
, struct device_attribute
*attr
,
1202 struct iwch_dev
*iwch_dev
= container_of(dev
, struct iwch_dev
,
1204 struct ethtool_drvinfo info
;
1205 struct net_device
*lldev
= iwch_dev
->rdev
.t3cdev_p
->lldev
;
1207 PDBG("%s dev 0x%p\n", __func__
, dev
);
1208 lldev
->ethtool_ops
->get_drvinfo(lldev
, &info
);
1209 return sprintf(buf
, "%s\n", info
.driver
);
1212 static ssize_t
show_board(struct device
*dev
, struct device_attribute
*attr
,
1215 struct iwch_dev
*iwch_dev
= container_of(dev
, struct iwch_dev
,
1217 PDBG("%s dev 0x%p\n", __func__
, dev
);
1218 return sprintf(buf
, "%x.%x\n", iwch_dev
->rdev
.rnic_info
.pdev
->vendor
,
1219 iwch_dev
->rdev
.rnic_info
.pdev
->device
);
1222 static int iwch_get_mib(struct ib_device
*ibdev
,
1223 union rdma_protocol_stats
*stats
)
1225 struct iwch_dev
*dev
;
1226 struct tp_mib_stats m
;
1229 PDBG("%s ibdev %p\n", __func__
, ibdev
);
1230 dev
= to_iwch_dev(ibdev
);
1231 ret
= dev
->rdev
.t3cdev_p
->ctl(dev
->rdev
.t3cdev_p
, RDMA_GET_MIB
, &m
);
1235 memset(stats
, 0, sizeof *stats
);
1236 stats
->iw
.ipInReceives
= ((u64
) m
.ipInReceive_hi
<< 32) +
1238 stats
->iw
.ipInHdrErrors
= ((u64
) m
.ipInHdrErrors_hi
<< 32) +
1240 stats
->iw
.ipInAddrErrors
= ((u64
) m
.ipInAddrErrors_hi
<< 32) +
1241 m
.ipInAddrErrors_lo
;
1242 stats
->iw
.ipInUnknownProtos
= ((u64
) m
.ipInUnknownProtos_hi
<< 32) +
1243 m
.ipInUnknownProtos_lo
;
1244 stats
->iw
.ipInDiscards
= ((u64
) m
.ipInDiscards_hi
<< 32) +
1246 stats
->iw
.ipInDelivers
= ((u64
) m
.ipInDelivers_hi
<< 32) +
1248 stats
->iw
.ipOutRequests
= ((u64
) m
.ipOutRequests_hi
<< 32) +
1250 stats
->iw
.ipOutDiscards
= ((u64
) m
.ipOutDiscards_hi
<< 32) +
1252 stats
->iw
.ipOutNoRoutes
= ((u64
) m
.ipOutNoRoutes_hi
<< 32) +
1254 stats
->iw
.ipReasmTimeout
= (u64
) m
.ipReasmTimeout
;
1255 stats
->iw
.ipReasmReqds
= (u64
) m
.ipReasmReqds
;
1256 stats
->iw
.ipReasmOKs
= (u64
) m
.ipReasmOKs
;
1257 stats
->iw
.ipReasmFails
= (u64
) m
.ipReasmFails
;
1258 stats
->iw
.tcpActiveOpens
= (u64
) m
.tcpActiveOpens
;
1259 stats
->iw
.tcpPassiveOpens
= (u64
) m
.tcpPassiveOpens
;
1260 stats
->iw
.tcpAttemptFails
= (u64
) m
.tcpAttemptFails
;
1261 stats
->iw
.tcpEstabResets
= (u64
) m
.tcpEstabResets
;
1262 stats
->iw
.tcpOutRsts
= (u64
) m
.tcpOutRsts
;
1263 stats
->iw
.tcpCurrEstab
= (u64
) m
.tcpCurrEstab
;
1264 stats
->iw
.tcpInSegs
= ((u64
) m
.tcpInSegs_hi
<< 32) +
1266 stats
->iw
.tcpOutSegs
= ((u64
) m
.tcpOutSegs_hi
<< 32) +
1268 stats
->iw
.tcpRetransSegs
= ((u64
) m
.tcpRetransSeg_hi
<< 32) +
1270 stats
->iw
.tcpInErrs
= ((u64
) m
.tcpInErrs_hi
<< 32) +
1272 stats
->iw
.tcpRtoMin
= (u64
) m
.tcpRtoMin
;
1273 stats
->iw
.tcpRtoMax
= (u64
) m
.tcpRtoMax
;
1277 static DEVICE_ATTR(hw_rev
, S_IRUGO
, show_rev
, NULL
);
1278 static DEVICE_ATTR(fw_ver
, S_IRUGO
, show_fw_ver
, NULL
);
1279 static DEVICE_ATTR(hca_type
, S_IRUGO
, show_hca
, NULL
);
1280 static DEVICE_ATTR(board_id
, S_IRUGO
, show_board
, NULL
);
1282 static struct device_attribute
*iwch_class_attributes
[] = {
1289 static int iwch_port_immutable(struct ib_device
*ibdev
, u8 port_num
,
1290 struct ib_port_immutable
*immutable
)
1292 struct ib_port_attr attr
;
1295 err
= iwch_query_port(ibdev
, port_num
, &attr
);
1299 immutable
->pkey_tbl_len
= attr
.pkey_tbl_len
;
1300 immutable
->gid_tbl_len
= attr
.gid_tbl_len
;
1301 immutable
->core_cap_flags
= RDMA_CORE_PORT_IWARP
;
1306 int iwch_register_device(struct iwch_dev
*dev
)
1311 PDBG("%s iwch_dev %p\n", __func__
, dev
);
1312 strlcpy(dev
->ibdev
.name
, "cxgb3_%d", IB_DEVICE_NAME_MAX
);
1313 memset(&dev
->ibdev
.node_guid
, 0, sizeof(dev
->ibdev
.node_guid
));
1314 memcpy(&dev
->ibdev
.node_guid
, dev
->rdev
.t3cdev_p
->lldev
->dev_addr
, 6);
1315 dev
->ibdev
.owner
= THIS_MODULE
;
1316 dev
->device_cap_flags
= IB_DEVICE_LOCAL_DMA_LKEY
|
1317 IB_DEVICE_MEM_WINDOW
|
1318 IB_DEVICE_MEM_MGT_EXTENSIONS
;
1320 /* cxgb3 supports STag 0. */
1321 dev
->ibdev
.local_dma_lkey
= 0;
1323 dev
->ibdev
.uverbs_cmd_mask
=
1324 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT
) |
1325 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE
) |
1326 (1ull << IB_USER_VERBS_CMD_QUERY_PORT
) |
1327 (1ull << IB_USER_VERBS_CMD_ALLOC_PD
) |
1328 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD
) |
1329 (1ull << IB_USER_VERBS_CMD_REG_MR
) |
1330 (1ull << IB_USER_VERBS_CMD_DEREG_MR
) |
1331 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL
) |
1332 (1ull << IB_USER_VERBS_CMD_CREATE_CQ
) |
1333 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ
) |
1334 (1ull << IB_USER_VERBS_CMD_REQ_NOTIFY_CQ
) |
1335 (1ull << IB_USER_VERBS_CMD_CREATE_QP
) |
1336 (1ull << IB_USER_VERBS_CMD_MODIFY_QP
) |
1337 (1ull << IB_USER_VERBS_CMD_POLL_CQ
) |
1338 (1ull << IB_USER_VERBS_CMD_DESTROY_QP
) |
1339 (1ull << IB_USER_VERBS_CMD_POST_SEND
) |
1340 (1ull << IB_USER_VERBS_CMD_POST_RECV
);
1341 dev
->ibdev
.node_type
= RDMA_NODE_RNIC
;
1342 memcpy(dev
->ibdev
.node_desc
, IWCH_NODE_DESC
, sizeof(IWCH_NODE_DESC
));
1343 dev
->ibdev
.phys_port_cnt
= dev
->rdev
.port_info
.nports
;
1344 dev
->ibdev
.num_comp_vectors
= 1;
1345 dev
->ibdev
.dma_device
= &(dev
->rdev
.rnic_info
.pdev
->dev
);
1346 dev
->ibdev
.query_device
= iwch_query_device
;
1347 dev
->ibdev
.query_port
= iwch_query_port
;
1348 dev
->ibdev
.query_pkey
= iwch_query_pkey
;
1349 dev
->ibdev
.query_gid
= iwch_query_gid
;
1350 dev
->ibdev
.alloc_ucontext
= iwch_alloc_ucontext
;
1351 dev
->ibdev
.dealloc_ucontext
= iwch_dealloc_ucontext
;
1352 dev
->ibdev
.mmap
= iwch_mmap
;
1353 dev
->ibdev
.alloc_pd
= iwch_allocate_pd
;
1354 dev
->ibdev
.dealloc_pd
= iwch_deallocate_pd
;
1355 dev
->ibdev
.create_ah
= iwch_ah_create
;
1356 dev
->ibdev
.destroy_ah
= iwch_ah_destroy
;
1357 dev
->ibdev
.create_qp
= iwch_create_qp
;
1358 dev
->ibdev
.modify_qp
= iwch_ib_modify_qp
;
1359 dev
->ibdev
.destroy_qp
= iwch_destroy_qp
;
1360 dev
->ibdev
.create_cq
= iwch_create_cq
;
1361 dev
->ibdev
.destroy_cq
= iwch_destroy_cq
;
1362 dev
->ibdev
.resize_cq
= iwch_resize_cq
;
1363 dev
->ibdev
.poll_cq
= iwch_poll_cq
;
1364 dev
->ibdev
.get_dma_mr
= iwch_get_dma_mr
;
1365 dev
->ibdev
.reg_user_mr
= iwch_reg_user_mr
;
1366 dev
->ibdev
.dereg_mr
= iwch_dereg_mr
;
1367 dev
->ibdev
.alloc_mw
= iwch_alloc_mw
;
1368 dev
->ibdev
.dealloc_mw
= iwch_dealloc_mw
;
1369 dev
->ibdev
.alloc_mr
= iwch_alloc_mr
;
1370 dev
->ibdev
.map_mr_sg
= iwch_map_mr_sg
;
1371 dev
->ibdev
.attach_mcast
= iwch_multicast_attach
;
1372 dev
->ibdev
.detach_mcast
= iwch_multicast_detach
;
1373 dev
->ibdev
.process_mad
= iwch_process_mad
;
1374 dev
->ibdev
.req_notify_cq
= iwch_arm_cq
;
1375 dev
->ibdev
.post_send
= iwch_post_send
;
1376 dev
->ibdev
.post_recv
= iwch_post_receive
;
1377 dev
->ibdev
.get_protocol_stats
= iwch_get_mib
;
1378 dev
->ibdev
.uverbs_abi_ver
= IWCH_UVERBS_ABI_VERSION
;
1379 dev
->ibdev
.get_port_immutable
= iwch_port_immutable
;
1381 dev
->ibdev
.iwcm
= kmalloc(sizeof(struct iw_cm_verbs
), GFP_KERNEL
);
1382 if (!dev
->ibdev
.iwcm
)
1385 dev
->ibdev
.iwcm
->connect
= iwch_connect
;
1386 dev
->ibdev
.iwcm
->accept
= iwch_accept_cr
;
1387 dev
->ibdev
.iwcm
->reject
= iwch_reject_cr
;
1388 dev
->ibdev
.iwcm
->create_listen
= iwch_create_listen
;
1389 dev
->ibdev
.iwcm
->destroy_listen
= iwch_destroy_listen
;
1390 dev
->ibdev
.iwcm
->add_ref
= iwch_qp_add_ref
;
1391 dev
->ibdev
.iwcm
->rem_ref
= iwch_qp_rem_ref
;
1392 dev
->ibdev
.iwcm
->get_qp
= iwch_get_qp
;
1394 ret
= ib_register_device(&dev
->ibdev
, NULL
);
1398 for (i
= 0; i
< ARRAY_SIZE(iwch_class_attributes
); ++i
) {
1399 ret
= device_create_file(&dev
->ibdev
.dev
,
1400 iwch_class_attributes
[i
]);
1407 ib_unregister_device(&dev
->ibdev
);
1409 kfree(dev
->ibdev
.iwcm
);
1413 void iwch_unregister_device(struct iwch_dev
*dev
)
1417 PDBG("%s iwch_dev %p\n", __func__
, dev
);
1418 for (i
= 0; i
< ARRAY_SIZE(iwch_class_attributes
); ++i
)
1419 device_remove_file(&dev
->ibdev
.dev
,
1420 iwch_class_attributes
[i
]);
1421 ib_unregister_device(&dev
->ibdev
);
1422 kfree(dev
->ibdev
.iwcm
);