2 * Copyright (c) 2005 Ammasso, Inc. All rights reserved.
3 * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
35 #include <linux/module.h>
36 #include <linux/moduleparam.h>
37 #include <linux/pci.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
40 #include <linux/inetdevice.h>
41 #include <linux/delay.h>
42 #include <linux/ethtool.h>
43 #include <linux/mii.h>
44 #include <linux/if_vlan.h>
45 #include <linux/crc32.h>
48 #include <linux/tcp.h>
49 #include <linux/init.h>
50 #include <linux/dma-mapping.h>
51 #include <linux/if_arp.h>
52 #include <linux/vmalloc.h>
53 #include <linux/slab.h>
57 #include <asm/byteorder.h>
59 #include <rdma/ib_smi.h>
60 #include <rdma/ib_umem.h>
61 #include <rdma/ib_user_verbs.h>
63 #include "c2_provider.h"
66 static int c2_query_device(struct ib_device
*ibdev
, struct ib_device_attr
*props
,
69 struct c2_dev
*c2dev
= to_c2dev(ibdev
);
71 pr_debug("%s:%u\n", __func__
, __LINE__
);
73 if (uhw
->inlen
|| uhw
->outlen
)
76 *props
= c2dev
->props
;
80 static int c2_query_port(struct ib_device
*ibdev
,
81 u8 port
, struct ib_port_attr
*props
)
83 pr_debug("%s:%u\n", __func__
, __LINE__
);
85 props
->max_mtu
= IB_MTU_4096
;
90 props
->state
= IB_PORT_ACTIVE
;
91 props
->phys_state
= 0;
92 props
->port_cap_flags
=
95 IB_PORT_VENDOR_CLASS_SUP
| IB_PORT_BOOT_MGMT_SUP
;
96 props
->gid_tbl_len
= 1;
97 props
->pkey_tbl_len
= 1;
98 props
->qkey_viol_cntr
= 0;
99 props
->active_width
= 1;
100 props
->active_speed
= IB_SPEED_SDR
;
105 static int c2_query_pkey(struct ib_device
*ibdev
,
106 u8 port
, u16 index
, u16
* pkey
)
108 pr_debug("%s:%u\n", __func__
, __LINE__
);
113 static int c2_query_gid(struct ib_device
*ibdev
, u8 port
,
114 int index
, union ib_gid
*gid
)
116 struct c2_dev
*c2dev
= to_c2dev(ibdev
);
118 pr_debug("%s:%u\n", __func__
, __LINE__
);
119 memset(&(gid
->raw
[0]), 0, sizeof(gid
->raw
));
120 memcpy(&(gid
->raw
[0]), c2dev
->pseudo_netdev
->dev_addr
, 6);
125 /* Allocate the user context data structure. This keeps track
126 * of all objects associated with a particular user-mode client.
128 static struct ib_ucontext
*c2_alloc_ucontext(struct ib_device
*ibdev
,
129 struct ib_udata
*udata
)
131 struct c2_ucontext
*context
;
133 pr_debug("%s:%u\n", __func__
, __LINE__
);
134 context
= kmalloc(sizeof(*context
), GFP_KERNEL
);
136 return ERR_PTR(-ENOMEM
);
138 return &context
->ibucontext
;
141 static int c2_dealloc_ucontext(struct ib_ucontext
*context
)
143 pr_debug("%s:%u\n", __func__
, __LINE__
);
148 static int c2_mmap_uar(struct ib_ucontext
*context
, struct vm_area_struct
*vma
)
150 pr_debug("%s:%u\n", __func__
, __LINE__
);
154 static struct ib_pd
*c2_alloc_pd(struct ib_device
*ibdev
,
155 struct ib_ucontext
*context
,
156 struct ib_udata
*udata
)
161 pr_debug("%s:%u\n", __func__
, __LINE__
);
163 pd
= kmalloc(sizeof(*pd
), GFP_KERNEL
);
165 return ERR_PTR(-ENOMEM
);
167 err
= c2_pd_alloc(to_c2dev(ibdev
), !context
, pd
);
174 if (ib_copy_to_udata(udata
, &pd
->pd_id
, sizeof(__u32
))) {
175 c2_pd_free(to_c2dev(ibdev
), pd
);
177 return ERR_PTR(-EFAULT
);
184 static int c2_dealloc_pd(struct ib_pd
*pd
)
186 pr_debug("%s:%u\n", __func__
, __LINE__
);
187 c2_pd_free(to_c2dev(pd
->device
), to_c2pd(pd
));
193 static struct ib_ah
*c2_ah_create(struct ib_pd
*pd
, struct ib_ah_attr
*ah_attr
)
195 pr_debug("%s:%u\n", __func__
, __LINE__
);
196 return ERR_PTR(-ENOSYS
);
199 static int c2_ah_destroy(struct ib_ah
*ah
)
201 pr_debug("%s:%u\n", __func__
, __LINE__
);
205 static void c2_add_ref(struct ib_qp
*ibqp
)
210 atomic_inc(&qp
->refcount
);
213 static void c2_rem_ref(struct ib_qp
*ibqp
)
218 if (atomic_dec_and_test(&qp
->refcount
))
222 struct ib_qp
*c2_get_qp(struct ib_device
*device
, int qpn
)
224 struct c2_dev
* c2dev
= to_c2dev(device
);
227 qp
= c2_find_qpn(c2dev
, qpn
);
228 pr_debug("%s Returning QP=%p for QPN=%d, device=%p, refcount=%d\n",
229 __func__
, qp
, qpn
, device
,
230 (qp
?atomic_read(&qp
->refcount
):0));
232 return (qp
?&qp
->ibqp
:NULL
);
235 static struct ib_qp
*c2_create_qp(struct ib_pd
*pd
,
236 struct ib_qp_init_attr
*init_attr
,
237 struct ib_udata
*udata
)
242 pr_debug("%s:%u\n", __func__
, __LINE__
);
244 if (init_attr
->create_flags
)
245 return ERR_PTR(-EINVAL
);
247 switch (init_attr
->qp_type
) {
249 qp
= kzalloc(sizeof(*qp
), GFP_KERNEL
);
251 pr_debug("%s: Unable to allocate QP\n", __func__
);
252 return ERR_PTR(-ENOMEM
);
254 spin_lock_init(&qp
->lock
);
256 /* userspace specific */
259 err
= c2_alloc_qp(to_c2dev(pd
->device
),
260 to_c2pd(pd
), init_attr
, qp
);
262 if (err
&& pd
->uobject
) {
263 /* userspace specific */
268 pr_debug("%s: Invalid QP type: %d\n", __func__
,
270 return ERR_PTR(-EINVAL
);
281 static int c2_destroy_qp(struct ib_qp
*ib_qp
)
283 struct c2_qp
*qp
= to_c2qp(ib_qp
);
285 pr_debug("%s:%u qp=%p,qp->state=%d\n",
286 __func__
, __LINE__
, ib_qp
, qp
->state
);
287 c2_free_qp(to_c2dev(ib_qp
->device
), qp
);
292 static struct ib_cq
*c2_create_cq(struct ib_device
*ibdev
,
293 const struct ib_cq_init_attr
*attr
,
294 struct ib_ucontext
*context
,
295 struct ib_udata
*udata
)
297 int entries
= attr
->cqe
;
302 return ERR_PTR(-EINVAL
);
304 cq
= kmalloc(sizeof(*cq
), GFP_KERNEL
);
306 pr_debug("%s: Unable to allocate CQ\n", __func__
);
307 return ERR_PTR(-ENOMEM
);
310 err
= c2_init_cq(to_c2dev(ibdev
), entries
, NULL
, cq
);
312 pr_debug("%s: error initializing CQ\n", __func__
);
320 static int c2_destroy_cq(struct ib_cq
*ib_cq
)
322 struct c2_cq
*cq
= to_c2cq(ib_cq
);
324 pr_debug("%s:%u\n", __func__
, __LINE__
);
326 c2_free_cq(to_c2dev(ib_cq
->device
), cq
);
332 static inline u32
c2_convert_access(int acc
)
334 return (acc
& IB_ACCESS_REMOTE_WRITE
? C2_ACF_REMOTE_WRITE
: 0) |
335 (acc
& IB_ACCESS_REMOTE_READ
? C2_ACF_REMOTE_READ
: 0) |
336 (acc
& IB_ACCESS_LOCAL_WRITE
? C2_ACF_LOCAL_WRITE
: 0) |
337 C2_ACF_LOCAL_READ
| C2_ACF_WINDOW_BIND
;
340 static struct ib_mr
*c2_reg_phys_mr(struct ib_pd
*ib_pd
,
341 struct ib_phys_buf
*buffer_list
,
342 int num_phys_buf
, int acc
, u64
* iova_start
)
347 int err
, i
, j
, k
, page_shift
, pbl_depth
;
352 page_shift
= PAGE_SHIFT
;
354 * If there is only 1 buffer we assume this could
355 * be a map of all phy mem...use a 32k page_shift.
357 if (num_phys_buf
== 1)
360 for (i
= 0; i
< num_phys_buf
; i
++) {
362 if (offset_in_page(buffer_list
[i
].addr
)) {
363 pr_debug("Unaligned Memory Buffer: 0x%x\n",
364 (unsigned int) buffer_list
[i
].addr
);
365 return ERR_PTR(-EINVAL
);
368 if (!buffer_list
[i
].size
) {
369 pr_debug("Invalid Buffer Size\n");
370 return ERR_PTR(-EINVAL
);
373 total_len
+= buffer_list
[i
].size
;
374 pbl_depth
+= ALIGN(buffer_list
[i
].size
,
375 BIT(page_shift
)) >> page_shift
;
378 page_list
= vmalloc(sizeof(u64
) * pbl_depth
);
380 pr_debug("couldn't vmalloc page_list of size %zd\n",
381 (sizeof(u64
) * pbl_depth
));
382 return ERR_PTR(-ENOMEM
);
385 for (i
= 0, j
= 0; i
< num_phys_buf
; i
++) {
389 naddrs
= ALIGN(buffer_list
[i
].size
,
390 BIT(page_shift
)) >> page_shift
;
391 for (k
= 0; k
< naddrs
; k
++)
392 page_list
[j
++] = (buffer_list
[i
].addr
+
396 mr
= kmalloc(sizeof(*mr
), GFP_KERNEL
);
399 return ERR_PTR(-ENOMEM
);
402 mr
->pd
= to_c2pd(ib_pd
);
404 pr_debug("%s - page shift %d, pbl_depth %d, total_len %u, "
405 "*iova_start %llx, first pa %llx, last pa %llx\n",
406 __func__
, page_shift
, pbl_depth
, total_len
,
407 (unsigned long long) *iova_start
,
408 (unsigned long long) page_list
[0],
409 (unsigned long long) page_list
[pbl_depth
-1]);
410 err
= c2_nsmr_register_phys_kern(to_c2dev(ib_pd
->device
), page_list
,
411 BIT(page_shift
), pbl_depth
,
412 total_len
, 0, iova_start
,
413 c2_convert_access(acc
), mr
);
423 static struct ib_mr
*c2_get_dma_mr(struct ib_pd
*pd
, int acc
)
425 struct ib_phys_buf bl
;
428 pr_debug("%s:%u\n", __func__
, __LINE__
);
431 bl
.size
= 0xffffffff;
433 return c2_reg_phys_mr(pd
, &bl
, 1, acc
, &kva
);
436 static struct ib_mr
*c2_reg_user_mr(struct ib_pd
*pd
, u64 start
, u64 length
,
437 u64 virt
, int acc
, struct ib_udata
*udata
)
444 struct scatterlist
*sg
;
445 struct c2_pd
*c2pd
= to_c2pd(pd
);
448 pr_debug("%s:%u\n", __func__
, __LINE__
);
450 c2mr
= kmalloc(sizeof(*c2mr
), GFP_KERNEL
);
452 return ERR_PTR(-ENOMEM
);
455 c2mr
->umem
= ib_umem_get(pd
->uobject
->context
, start
, length
, acc
, 0);
456 if (IS_ERR(c2mr
->umem
)) {
457 err
= PTR_ERR(c2mr
->umem
);
462 shift
= ffs(c2mr
->umem
->page_size
) - 1;
463 n
= c2mr
->umem
->nmap
;
465 pages
= kmalloc_array(n
, sizeof(u64
), GFP_KERNEL
);
472 for_each_sg(c2mr
->umem
->sg_head
.sgl
, sg
, c2mr
->umem
->nmap
, entry
) {
473 len
= sg_dma_len(sg
) >> shift
;
474 for (k
= 0; k
< len
; ++k
) {
477 (c2mr
->umem
->page_size
* k
);
482 err
= c2_nsmr_register_phys_kern(to_c2dev(pd
->device
),
484 c2mr
->umem
->page_size
,
487 ib_umem_offset(c2mr
->umem
),
489 c2_convert_access(acc
),
497 ib_umem_release(c2mr
->umem
);
502 static int c2_dereg_mr(struct ib_mr
*ib_mr
)
504 struct c2_mr
*mr
= to_c2mr(ib_mr
);
507 pr_debug("%s:%u\n", __func__
, __LINE__
);
509 err
= c2_stag_dealloc(to_c2dev(ib_mr
->device
), ib_mr
->lkey
);
511 pr_debug("c2_stag_dealloc failed: %d\n", err
);
514 ib_umem_release(mr
->umem
);
521 static ssize_t
show_rev(struct device
*dev
, struct device_attribute
*attr
,
524 struct c2_dev
*c2dev
= container_of(dev
, struct c2_dev
, ibdev
.dev
);
525 pr_debug("%s:%u\n", __func__
, __LINE__
);
526 return sprintf(buf
, "%x\n", c2dev
->props
.hw_ver
);
529 static ssize_t
show_fw_ver(struct device
*dev
, struct device_attribute
*attr
,
532 struct c2_dev
*c2dev
= container_of(dev
, struct c2_dev
, ibdev
.dev
);
533 pr_debug("%s:%u\n", __func__
, __LINE__
);
534 return sprintf(buf
, "%x.%x.%x\n",
535 (int) (c2dev
->props
.fw_ver
>> 32),
536 (int) (c2dev
->props
.fw_ver
>> 16) & 0xffff,
537 (int) (c2dev
->props
.fw_ver
& 0xffff));
540 static ssize_t
show_hca(struct device
*dev
, struct device_attribute
*attr
,
543 pr_debug("%s:%u\n", __func__
, __LINE__
);
544 return sprintf(buf
, "AMSO1100\n");
547 static ssize_t
show_board(struct device
*dev
, struct device_attribute
*attr
,
550 pr_debug("%s:%u\n", __func__
, __LINE__
);
551 return sprintf(buf
, "%.*s\n", 32, "AMSO1100 Board ID");
554 static DEVICE_ATTR(hw_rev
, S_IRUGO
, show_rev
, NULL
);
555 static DEVICE_ATTR(fw_ver
, S_IRUGO
, show_fw_ver
, NULL
);
556 static DEVICE_ATTR(hca_type
, S_IRUGO
, show_hca
, NULL
);
557 static DEVICE_ATTR(board_id
, S_IRUGO
, show_board
, NULL
);
559 static struct device_attribute
*c2_dev_attributes
[] = {
566 static int c2_modify_qp(struct ib_qp
*ibqp
, struct ib_qp_attr
*attr
,
567 int attr_mask
, struct ib_udata
*udata
)
572 c2_qp_modify(to_c2dev(ibqp
->device
), to_c2qp(ibqp
), attr
,
578 static int c2_multicast_attach(struct ib_qp
*ibqp
, union ib_gid
*gid
, u16 lid
)
580 pr_debug("%s:%u\n", __func__
, __LINE__
);
584 static int c2_multicast_detach(struct ib_qp
*ibqp
, union ib_gid
*gid
, u16 lid
)
586 pr_debug("%s:%u\n", __func__
, __LINE__
);
590 static int c2_process_mad(struct ib_device
*ibdev
,
593 const struct ib_wc
*in_wc
,
594 const struct ib_grh
*in_grh
,
595 const struct ib_mad_hdr
*in_mad
,
597 struct ib_mad_hdr
*out_mad
,
598 size_t *out_mad_size
,
599 u16
*out_mad_pkey_index
)
601 pr_debug("%s:%u\n", __func__
, __LINE__
);
605 static int c2_connect(struct iw_cm_id
*cm_id
, struct iw_cm_conn_param
*iw_param
)
607 pr_debug("%s:%u\n", __func__
, __LINE__
);
609 /* Request a connection */
610 return c2_llp_connect(cm_id
, iw_param
);
613 static int c2_accept(struct iw_cm_id
*cm_id
, struct iw_cm_conn_param
*iw_param
)
615 pr_debug("%s:%u\n", __func__
, __LINE__
);
617 /* Accept the new connection */
618 return c2_llp_accept(cm_id
, iw_param
);
621 static int c2_reject(struct iw_cm_id
*cm_id
, const void *pdata
, u8 pdata_len
)
625 pr_debug("%s:%u\n", __func__
, __LINE__
);
627 err
= c2_llp_reject(cm_id
, pdata
, pdata_len
);
631 static int c2_service_create(struct iw_cm_id
*cm_id
, int backlog
)
635 pr_debug("%s:%u\n", __func__
, __LINE__
);
636 err
= c2_llp_service_create(cm_id
, backlog
);
637 pr_debug("%s:%u err=%d\n",
643 static int c2_service_destroy(struct iw_cm_id
*cm_id
)
646 pr_debug("%s:%u\n", __func__
, __LINE__
);
648 err
= c2_llp_service_destroy(cm_id
);
653 static int c2_pseudo_up(struct net_device
*netdev
)
655 struct in_device
*ind
;
656 struct c2_dev
*c2dev
= netdev
->ml_priv
;
658 ind
= in_dev_get(netdev
);
662 pr_debug("adding...\n");
665 u8
*ip
= (u8
*) & ifa
->ifa_address
;
667 pr_debug("%s: %d.%d.%d.%d\n",
668 ifa
->ifa_label
, ip
[0], ip
[1], ip
[2], ip
[3]);
670 c2_add_addr(c2dev
, ifa
->ifa_address
, ifa
->ifa_mask
);
678 static int c2_pseudo_down(struct net_device
*netdev
)
680 struct in_device
*ind
;
681 struct c2_dev
*c2dev
= netdev
->ml_priv
;
683 ind
= in_dev_get(netdev
);
687 pr_debug("deleting...\n");
690 u8
*ip
= (u8
*) & ifa
->ifa_address
;
692 pr_debug("%s: %d.%d.%d.%d\n",
693 ifa
->ifa_label
, ip
[0], ip
[1], ip
[2], ip
[3]);
695 c2_del_addr(c2dev
, ifa
->ifa_address
, ifa
->ifa_mask
);
703 static int c2_pseudo_xmit_frame(struct sk_buff
*skb
, struct net_device
*netdev
)
709 static int c2_pseudo_change_mtu(struct net_device
*netdev
, int new_mtu
)
711 if (new_mtu
< ETH_ZLEN
|| new_mtu
> ETH_JUMBO_MTU
)
714 netdev
->mtu
= new_mtu
;
716 /* TODO: Tell rnic about new rmda interface mtu */
720 static const struct net_device_ops c2_pseudo_netdev_ops
= {
721 .ndo_open
= c2_pseudo_up
,
722 .ndo_stop
= c2_pseudo_down
,
723 .ndo_start_xmit
= c2_pseudo_xmit_frame
,
724 .ndo_change_mtu
= c2_pseudo_change_mtu
,
725 .ndo_validate_addr
= eth_validate_addr
,
728 static void setup(struct net_device
*netdev
)
730 netdev
->netdev_ops
= &c2_pseudo_netdev_ops
;
732 netdev
->watchdog_timeo
= 0;
733 netdev
->type
= ARPHRD_ETHER
;
735 netdev
->hard_header_len
= ETH_HLEN
;
736 netdev
->addr_len
= ETH_ALEN
;
737 netdev
->tx_queue_len
= 0;
738 netdev
->flags
|= IFF_NOARP
;
741 static struct net_device
*c2_pseudo_netdev_init(struct c2_dev
*c2dev
)
744 struct net_device
*netdev
;
746 /* change ethxxx to iwxxx */
748 strcat(name
, &c2dev
->netdev
->name
[3]);
749 netdev
= alloc_netdev(0, name
, NET_NAME_UNKNOWN
, setup
);
751 printk(KERN_ERR PFX
"%s - etherdev alloc failed",
756 netdev
->ml_priv
= c2dev
;
758 SET_NETDEV_DEV(netdev
, &c2dev
->pcidev
->dev
);
760 memcpy_fromio(netdev
->dev_addr
, c2dev
->kva
+ C2_REGS_RDMA_ENADDR
, 6);
762 /* Print out the MAC address */
763 pr_debug("%s: MAC %pM\n", netdev
->name
, netdev
->dev_addr
);
766 /* Disable network packets */
767 netif_stop_queue(netdev
);
772 static int c2_port_immutable(struct ib_device
*ibdev
, u8 port_num
,
773 struct ib_port_immutable
*immutable
)
775 struct ib_port_attr attr
;
778 err
= c2_query_port(ibdev
, port_num
, &attr
);
782 immutable
->pkey_tbl_len
= attr
.pkey_tbl_len
;
783 immutable
->gid_tbl_len
= attr
.gid_tbl_len
;
784 immutable
->core_cap_flags
= RDMA_CORE_PORT_IWARP
;
789 int c2_register_device(struct c2_dev
*dev
)
794 /* Register pseudo network device */
795 dev
->pseudo_netdev
= c2_pseudo_netdev_init(dev
);
796 if (!dev
->pseudo_netdev
)
799 ret
= register_netdev(dev
->pseudo_netdev
);
801 goto out_free_netdev
;
803 pr_debug("%s:%u\n", __func__
, __LINE__
);
804 strlcpy(dev
->ibdev
.name
, "amso%d", IB_DEVICE_NAME_MAX
);
805 dev
->ibdev
.owner
= THIS_MODULE
;
806 dev
->ibdev
.uverbs_cmd_mask
=
807 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT
) |
808 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE
) |
809 (1ull << IB_USER_VERBS_CMD_QUERY_PORT
) |
810 (1ull << IB_USER_VERBS_CMD_ALLOC_PD
) |
811 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD
) |
812 (1ull << IB_USER_VERBS_CMD_REG_MR
) |
813 (1ull << IB_USER_VERBS_CMD_DEREG_MR
) |
814 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL
) |
815 (1ull << IB_USER_VERBS_CMD_CREATE_CQ
) |
816 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ
) |
817 (1ull << IB_USER_VERBS_CMD_REQ_NOTIFY_CQ
) |
818 (1ull << IB_USER_VERBS_CMD_CREATE_QP
) |
819 (1ull << IB_USER_VERBS_CMD_MODIFY_QP
) |
820 (1ull << IB_USER_VERBS_CMD_POLL_CQ
) |
821 (1ull << IB_USER_VERBS_CMD_DESTROY_QP
) |
822 (1ull << IB_USER_VERBS_CMD_POST_SEND
) |
823 (1ull << IB_USER_VERBS_CMD_POST_RECV
);
825 dev
->ibdev
.node_type
= RDMA_NODE_RNIC
;
826 memset(&dev
->ibdev
.node_guid
, 0, sizeof(dev
->ibdev
.node_guid
));
827 memcpy(&dev
->ibdev
.node_guid
, dev
->pseudo_netdev
->dev_addr
, 6);
828 dev
->ibdev
.phys_port_cnt
= 1;
829 dev
->ibdev
.num_comp_vectors
= 1;
830 dev
->ibdev
.dma_device
= &dev
->pcidev
->dev
;
831 dev
->ibdev
.query_device
= c2_query_device
;
832 dev
->ibdev
.query_port
= c2_query_port
;
833 dev
->ibdev
.query_pkey
= c2_query_pkey
;
834 dev
->ibdev
.query_gid
= c2_query_gid
;
835 dev
->ibdev
.alloc_ucontext
= c2_alloc_ucontext
;
836 dev
->ibdev
.dealloc_ucontext
= c2_dealloc_ucontext
;
837 dev
->ibdev
.mmap
= c2_mmap_uar
;
838 dev
->ibdev
.alloc_pd
= c2_alloc_pd
;
839 dev
->ibdev
.dealloc_pd
= c2_dealloc_pd
;
840 dev
->ibdev
.create_ah
= c2_ah_create
;
841 dev
->ibdev
.destroy_ah
= c2_ah_destroy
;
842 dev
->ibdev
.create_qp
= c2_create_qp
;
843 dev
->ibdev
.modify_qp
= c2_modify_qp
;
844 dev
->ibdev
.destroy_qp
= c2_destroy_qp
;
845 dev
->ibdev
.create_cq
= c2_create_cq
;
846 dev
->ibdev
.destroy_cq
= c2_destroy_cq
;
847 dev
->ibdev
.poll_cq
= c2_poll_cq
;
848 dev
->ibdev
.get_dma_mr
= c2_get_dma_mr
;
849 dev
->ibdev
.reg_phys_mr
= c2_reg_phys_mr
;
850 dev
->ibdev
.reg_user_mr
= c2_reg_user_mr
;
851 dev
->ibdev
.dereg_mr
= c2_dereg_mr
;
852 dev
->ibdev
.get_port_immutable
= c2_port_immutable
;
854 dev
->ibdev
.alloc_fmr
= NULL
;
855 dev
->ibdev
.unmap_fmr
= NULL
;
856 dev
->ibdev
.dealloc_fmr
= NULL
;
857 dev
->ibdev
.map_phys_fmr
= NULL
;
859 dev
->ibdev
.attach_mcast
= c2_multicast_attach
;
860 dev
->ibdev
.detach_mcast
= c2_multicast_detach
;
861 dev
->ibdev
.process_mad
= c2_process_mad
;
863 dev
->ibdev
.req_notify_cq
= c2_arm_cq
;
864 dev
->ibdev
.post_send
= c2_post_send
;
865 dev
->ibdev
.post_recv
= c2_post_receive
;
867 dev
->ibdev
.iwcm
= kmalloc(sizeof(*dev
->ibdev
.iwcm
), GFP_KERNEL
);
868 if (dev
->ibdev
.iwcm
== NULL
) {
870 goto out_unregister_netdev
;
872 dev
->ibdev
.iwcm
->add_ref
= c2_add_ref
;
873 dev
->ibdev
.iwcm
->rem_ref
= c2_rem_ref
;
874 dev
->ibdev
.iwcm
->get_qp
= c2_get_qp
;
875 dev
->ibdev
.iwcm
->connect
= c2_connect
;
876 dev
->ibdev
.iwcm
->accept
= c2_accept
;
877 dev
->ibdev
.iwcm
->reject
= c2_reject
;
878 dev
->ibdev
.iwcm
->create_listen
= c2_service_create
;
879 dev
->ibdev
.iwcm
->destroy_listen
= c2_service_destroy
;
881 ret
= ib_register_device(&dev
->ibdev
, NULL
);
885 for (i
= 0; i
< ARRAY_SIZE(c2_dev_attributes
); ++i
) {
886 ret
= device_create_file(&dev
->ibdev
.dev
,
887 c2_dev_attributes
[i
]);
889 goto out_unregister_ibdev
;
893 out_unregister_ibdev
:
894 ib_unregister_device(&dev
->ibdev
);
896 kfree(dev
->ibdev
.iwcm
);
897 out_unregister_netdev
:
898 unregister_netdev(dev
->pseudo_netdev
);
900 free_netdev(dev
->pseudo_netdev
);
902 pr_debug("%s:%u ret=%d\n", __func__
, __LINE__
, ret
);
906 void c2_unregister_device(struct c2_dev
*dev
)
908 pr_debug("%s:%u\n", __func__
, __LINE__
);
909 unregister_netdev(dev
->pseudo_netdev
);
910 free_netdev(dev
->pseudo_netdev
);
911 ib_unregister_device(&dev
->ibdev
);