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
36 #include <linux/module.h>
37 #include <linux/moduleparam.h>
38 #include <linux/pci.h>
39 #include <linux/netdevice.h>
40 #include <linux/etherdevice.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>
52 #include <linux/inet.h>
54 #include <linux/route.h>
58 #include <asm/byteorder.h>
59 #include <rdma/ib_smi.h>
63 /* Device capabilities */
64 #define C2_MIN_PAGESIZE 1024
66 #define C2_MAX_MRS 32768
67 #define C2_MAX_QPS 16000
68 #define C2_MAX_WQE_SZ 256
69 #define C2_MAX_QP_WR ((128*1024)/C2_MAX_WQE_SZ)
71 #define C2_MAX_SGE_RD 1
72 #define C2_MAX_CQS 32768
73 #define C2_MAX_CQES 4096
74 #define C2_MAX_PDS 16384
77 * Send the adapter INIT message to the amso1100
79 static int c2_adapter_init(struct c2_dev
*c2dev
)
81 struct c2wr_init_req wr
;
84 memset(&wr
, 0, sizeof(wr
));
85 c2_wr_set_id(&wr
, CCWR_INIT
);
87 wr
.hint_count
= cpu_to_be64(c2dev
->hint_count_dma
);
88 wr
.q0_host_shared
= cpu_to_be64(c2dev
->req_vq
.shared_dma
);
89 wr
.q1_host_shared
= cpu_to_be64(c2dev
->rep_vq
.shared_dma
);
90 wr
.q1_host_msg_pool
= cpu_to_be64(c2dev
->rep_vq
.host_dma
);
91 wr
.q2_host_shared
= cpu_to_be64(c2dev
->aeq
.shared_dma
);
92 wr
.q2_host_msg_pool
= cpu_to_be64(c2dev
->aeq
.host_dma
);
94 /* Post the init message */
95 err
= vq_send_wr(c2dev
, (union c2wr
*) & wr
);
101 * Send the adapter TERM message to the amso1100
103 static void c2_adapter_term(struct c2_dev
*c2dev
)
105 struct c2wr_init_req wr
;
107 memset(&wr
, 0, sizeof(wr
));
108 c2_wr_set_id(&wr
, CCWR_TERM
);
111 /* Post the init message */
112 vq_send_wr(c2dev
, (union c2wr
*) & wr
);
121 static int c2_rnic_query(struct c2_dev
*c2dev
, struct ib_device_attr
*props
)
123 struct c2_vq_req
*vq_req
;
124 struct c2wr_rnic_query_req wr
;
125 struct c2wr_rnic_query_rep
*reply
;
128 vq_req
= vq_req_alloc(c2dev
);
132 c2_wr_set_id(&wr
, CCWR_RNIC_QUERY
);
133 wr
.hdr
.context
= (unsigned long) vq_req
;
134 wr
.rnic_handle
= c2dev
->adapter_handle
;
136 vq_req_get(c2dev
, vq_req
);
138 err
= vq_send_wr(c2dev
, (union c2wr
*) &wr
);
140 vq_req_put(c2dev
, vq_req
);
144 err
= vq_wait_for_reply(c2dev
, vq_req
);
149 (struct c2wr_rnic_query_rep
*) (unsigned long) (vq_req
->reply_msg
);
153 err
= c2_errno(reply
);
158 ((u64
)be32_to_cpu(reply
->fw_ver_major
) << 32) |
159 ((be32_to_cpu(reply
->fw_ver_minor
) && 0xFFFF) << 16) |
160 (be32_to_cpu(reply
->fw_ver_patch
) && 0xFFFF);
161 memcpy(&props
->sys_image_guid
, c2dev
->netdev
->dev_addr
, 6);
162 props
->max_mr_size
= 0xFFFFFFFF;
163 props
->page_size_cap
= ~(C2_MIN_PAGESIZE
-1);
164 props
->vendor_id
= be32_to_cpu(reply
->vendor_id
);
165 props
->vendor_part_id
= be32_to_cpu(reply
->part_number
);
166 props
->hw_ver
= be32_to_cpu(reply
->hw_version
);
167 props
->max_qp
= be32_to_cpu(reply
->max_qps
);
168 props
->max_qp_wr
= be32_to_cpu(reply
->max_qp_depth
);
169 props
->device_cap_flags
= c2dev
->device_cap_flags
;
170 props
->max_sge
= C2_MAX_SGES
;
171 props
->max_sge_rd
= C2_MAX_SGE_RD
;
172 props
->max_cq
= be32_to_cpu(reply
->max_cqs
);
173 props
->max_cqe
= be32_to_cpu(reply
->max_cq_depth
);
174 props
->max_mr
= be32_to_cpu(reply
->max_mrs
);
175 props
->max_pd
= be32_to_cpu(reply
->max_pds
);
176 props
->max_qp_rd_atom
= be32_to_cpu(reply
->max_qp_ird
);
177 props
->max_ee_rd_atom
= 0;
178 props
->max_res_rd_atom
= be32_to_cpu(reply
->max_global_ird
);
179 props
->max_qp_init_rd_atom
= be32_to_cpu(reply
->max_qp_ord
);
180 props
->max_ee_init_rd_atom
= 0;
181 props
->atomic_cap
= IB_ATOMIC_NONE
;
184 props
->max_mw
= be32_to_cpu(reply
->max_mws
);
185 props
->max_raw_ipv6_qp
= 0;
186 props
->max_raw_ethy_qp
= 0;
187 props
->max_mcast_grp
= 0;
188 props
->max_mcast_qp_attach
= 0;
189 props
->max_total_mcast_qp_attach
= 0;
192 props
->max_map_per_fmr
= 0;
194 props
->max_srq_wr
= 0;
195 props
->max_srq_sge
= 0;
196 props
->max_pkeys
= 0;
197 props
->local_ca_ack_delay
= 0;
200 vq_repbuf_free(c2dev
, reply
);
203 vq_req_free(c2dev
, vq_req
);
208 * Add an IP address to the RNIC interface
210 int c2_add_addr(struct c2_dev
*c2dev
, u32 inaddr
, u32 inmask
)
212 struct c2_vq_req
*vq_req
;
213 struct c2wr_rnic_setconfig_req
*wr
;
214 struct c2wr_rnic_setconfig_rep
*reply
;
215 struct c2_netaddr netaddr
;
218 vq_req
= vq_req_alloc(c2dev
);
222 len
= sizeof(struct c2_netaddr
);
223 wr
= kmalloc(c2dev
->req_vq
.msg_size
, GFP_KERNEL
);
229 c2_wr_set_id(wr
, CCWR_RNIC_SETCONFIG
);
230 wr
->hdr
.context
= (unsigned long) vq_req
;
231 wr
->rnic_handle
= c2dev
->adapter_handle
;
232 wr
->option
= cpu_to_be32(C2_CFG_ADD_ADDR
);
234 netaddr
.ip_addr
= inaddr
;
235 netaddr
.netmask
= inmask
;
238 memcpy(wr
->data
, &netaddr
, len
);
240 vq_req_get(c2dev
, vq_req
);
242 err
= vq_send_wr(c2dev
, (union c2wr
*) wr
);
244 vq_req_put(c2dev
, vq_req
);
248 err
= vq_wait_for_reply(c2dev
, vq_req
);
253 (struct c2wr_rnic_setconfig_rep
*) (unsigned long) (vq_req
->reply_msg
);
259 err
= c2_errno(reply
);
260 vq_repbuf_free(c2dev
, reply
);
265 vq_req_free(c2dev
, vq_req
);
270 * Delete an IP address from the RNIC interface
272 int c2_del_addr(struct c2_dev
*c2dev
, u32 inaddr
, u32 inmask
)
274 struct c2_vq_req
*vq_req
;
275 struct c2wr_rnic_setconfig_req
*wr
;
276 struct c2wr_rnic_setconfig_rep
*reply
;
277 struct c2_netaddr netaddr
;
280 vq_req
= vq_req_alloc(c2dev
);
284 len
= sizeof(struct c2_netaddr
);
285 wr
= kmalloc(c2dev
->req_vq
.msg_size
, GFP_KERNEL
);
291 c2_wr_set_id(wr
, CCWR_RNIC_SETCONFIG
);
292 wr
->hdr
.context
= (unsigned long) vq_req
;
293 wr
->rnic_handle
= c2dev
->adapter_handle
;
294 wr
->option
= cpu_to_be32(C2_CFG_DEL_ADDR
);
296 netaddr
.ip_addr
= inaddr
;
297 netaddr
.netmask
= inmask
;
300 memcpy(wr
->data
, &netaddr
, len
);
302 vq_req_get(c2dev
, vq_req
);
304 err
= vq_send_wr(c2dev
, (union c2wr
*) wr
);
306 vq_req_put(c2dev
, vq_req
);
310 err
= vq_wait_for_reply(c2dev
, vq_req
);
315 (struct c2wr_rnic_setconfig_rep
*) (unsigned long) (vq_req
->reply_msg
);
321 err
= c2_errno(reply
);
322 vq_repbuf_free(c2dev
, reply
);
327 vq_req_free(c2dev
, vq_req
);
332 * Open a single RNIC instance to use with all
333 * low level openib calls
335 static int c2_rnic_open(struct c2_dev
*c2dev
)
337 struct c2_vq_req
*vq_req
;
339 struct c2wr_rnic_open_rep
*reply
;
342 vq_req
= vq_req_alloc(c2dev
);
343 if (vq_req
== NULL
) {
347 memset(&wr
, 0, sizeof(wr
));
348 c2_wr_set_id(&wr
, CCWR_RNIC_OPEN
);
349 wr
.rnic_open
.req
.hdr
.context
= (unsigned long) (vq_req
);
350 wr
.rnic_open
.req
.flags
= cpu_to_be16(RNIC_PRIV_MODE
);
351 wr
.rnic_open
.req
.port_num
= cpu_to_be16(0);
352 wr
.rnic_open
.req
.user_context
= (unsigned long) c2dev
;
354 vq_req_get(c2dev
, vq_req
);
356 err
= vq_send_wr(c2dev
, &wr
);
358 vq_req_put(c2dev
, vq_req
);
362 err
= vq_wait_for_reply(c2dev
, vq_req
);
367 reply
= (struct c2wr_rnic_open_rep
*) (unsigned long) (vq_req
->reply_msg
);
373 if ((err
= c2_errno(reply
)) != 0) {
377 c2dev
->adapter_handle
= reply
->rnic_handle
;
380 vq_repbuf_free(c2dev
, reply
);
382 vq_req_free(c2dev
, vq_req
);
387 * Close the RNIC instance
389 static int c2_rnic_close(struct c2_dev
*c2dev
)
391 struct c2_vq_req
*vq_req
;
393 struct c2wr_rnic_close_rep
*reply
;
396 vq_req
= vq_req_alloc(c2dev
);
397 if (vq_req
== NULL
) {
401 memset(&wr
, 0, sizeof(wr
));
402 c2_wr_set_id(&wr
, CCWR_RNIC_CLOSE
);
403 wr
.rnic_close
.req
.hdr
.context
= (unsigned long) vq_req
;
404 wr
.rnic_close
.req
.rnic_handle
= c2dev
->adapter_handle
;
406 vq_req_get(c2dev
, vq_req
);
408 err
= vq_send_wr(c2dev
, &wr
);
410 vq_req_put(c2dev
, vq_req
);
414 err
= vq_wait_for_reply(c2dev
, vq_req
);
419 reply
= (struct c2wr_rnic_close_rep
*) (unsigned long) (vq_req
->reply_msg
);
425 if ((err
= c2_errno(reply
)) != 0) {
429 c2dev
->adapter_handle
= 0;
432 vq_repbuf_free(c2dev
, reply
);
434 vq_req_free(c2dev
, vq_req
);
439 * Called by c2_probe to initialize the RNIC. This principally
440 * involves initalizing the various limits and resouce pools that
441 * comprise the RNIC instance.
443 int c2_rnic_init(struct c2_dev
*c2dev
)
449 void __iomem
*mmio_regs
;
451 /* Device capabilities */
452 c2dev
->device_cap_flags
=
453 (IB_DEVICE_RESIZE_MAX_WR
|
454 IB_DEVICE_CURR_QP_STATE_MOD
|
455 IB_DEVICE_SYS_IMAGE_GUID
|
456 IB_DEVICE_ZERO_STAG
|
457 IB_DEVICE_SEND_W_INV
| IB_DEVICE_MEM_WINDOW
);
459 /* Allocate the qptr_array */
460 c2dev
->qptr_array
= vmalloc(C2_MAX_CQS
* sizeof(void *));
461 if (!c2dev
->qptr_array
) {
465 /* Inialize the qptr_array */
466 memset(c2dev
->qptr_array
, 0, C2_MAX_CQS
* sizeof(void *));
467 c2dev
->qptr_array
[0] = (void *) &c2dev
->req_vq
;
468 c2dev
->qptr_array
[1] = (void *) &c2dev
->rep_vq
;
469 c2dev
->qptr_array
[2] = (void *) &c2dev
->aeq
;
471 /* Initialize data structures */
472 init_waitqueue_head(&c2dev
->req_vq_wo
);
473 spin_lock_init(&c2dev
->vqlock
);
474 spin_lock_init(&c2dev
->lock
);
476 /* Allocate MQ shared pointer pool for kernel clients. User
477 * mode client pools are hung off the user context
479 err
= c2_init_mqsp_pool(c2dev
, GFP_KERNEL
, &c2dev
->kern_mqsp_pool
);
484 /* Allocate shared pointers for Q0, Q1, and Q2 from
485 * the shared pointer pool.
488 c2dev
->hint_count
= c2_alloc_mqsp(c2dev
, c2dev
->kern_mqsp_pool
,
489 &c2dev
->hint_count_dma
,
491 c2dev
->req_vq
.shared
= c2_alloc_mqsp(c2dev
, c2dev
->kern_mqsp_pool
,
492 &c2dev
->req_vq
.shared_dma
,
494 c2dev
->rep_vq
.shared
= c2_alloc_mqsp(c2dev
, c2dev
->kern_mqsp_pool
,
495 &c2dev
->rep_vq
.shared_dma
,
497 c2dev
->aeq
.shared
= c2_alloc_mqsp(c2dev
, c2dev
->kern_mqsp_pool
,
498 &c2dev
->aeq
.shared_dma
, GFP_KERNEL
);
499 if (!c2dev
->hint_count
|| !c2dev
->req_vq
.shared
||
500 !c2dev
->rep_vq
.shared
|| !c2dev
->aeq
.shared
) {
505 mmio_regs
= c2dev
->kva
;
506 /* Initialize the Verbs Request Queue */
507 c2_mq_req_init(&c2dev
->req_vq
, 0,
508 be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q0_QSIZE
)),
509 be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q0_MSGSIZE
)),
511 be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q0_POOLSTART
)),
513 be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q0_SHARED
)),
514 C2_MQ_ADAPTER_TARGET
);
516 /* Initialize the Verbs Reply Queue */
517 qsize
= be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q1_QSIZE
));
518 msgsize
= be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q1_MSGSIZE
));
519 q1_pages
= kmalloc(qsize
* msgsize
, GFP_KERNEL
);
524 c2dev
->rep_vq
.host_dma
= dma_map_single(c2dev
->ibdev
.dma_device
,
525 (void *)q1_pages
, qsize
* msgsize
,
527 pci_unmap_addr_set(&c2dev
->rep_vq
, mapping
, c2dev
->rep_vq
.host_dma
);
528 pr_debug("%s rep_vq va %p dma %llx\n", __FUNCTION__
, q1_pages
,
529 (u64
)c2dev
->rep_vq
.host_dma
);
530 c2_mq_rep_init(&c2dev
->rep_vq
,
536 be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q1_SHARED
)),
539 /* Initialize the Asynchronus Event Queue */
540 qsize
= be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q2_QSIZE
));
541 msgsize
= be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q2_MSGSIZE
));
542 q2_pages
= kmalloc(qsize
* msgsize
, GFP_KERNEL
);
547 c2dev
->aeq
.host_dma
= dma_map_single(c2dev
->ibdev
.dma_device
,
548 (void *)q2_pages
, qsize
* msgsize
,
550 pci_unmap_addr_set(&c2dev
->aeq
, mapping
, c2dev
->aeq
.host_dma
);
551 pr_debug("%s aeq va %p dma %llx\n", __FUNCTION__
, q1_pages
,
552 (u64
)c2dev
->rep_vq
.host_dma
);
553 c2_mq_rep_init(&c2dev
->aeq
,
559 be32_to_cpu(readl(mmio_regs
+ C2_REGS_Q2_SHARED
)),
562 /* Initialize the verbs request allocator */
563 err
= vq_init(c2dev
);
567 /* Enable interrupts on the adapter */
568 writel(0, c2dev
->regs
+ C2_IDIS
);
570 /* create the WR init message */
571 err
= c2_adapter_init(c2dev
);
576 /* open an adapter instance */
577 err
= c2_rnic_open(c2dev
);
581 /* Initialize cached the adapter limits */
582 if (c2_rnic_query(c2dev
, &c2dev
->props
))
585 /* Initialize the PD pool */
586 err
= c2_init_pd_table(c2dev
);
590 /* Initialize the QP pool */
591 c2_init_qp_table(c2dev
);
595 c2_rnic_close(c2dev
);
599 dma_unmap_single(c2dev
->ibdev
.dma_device
,
600 pci_unmap_addr(&c2dev
->aeq
, mapping
),
601 c2dev
->aeq
.q_size
* c2dev
->aeq
.msg_size
,
605 dma_unmap_single(c2dev
->ibdev
.dma_device
,
606 pci_unmap_addr(&c2dev
->rep_vq
, mapping
),
607 c2dev
->rep_vq
.q_size
* c2dev
->rep_vq
.msg_size
,
611 c2_free_mqsp_pool(c2dev
, c2dev
->kern_mqsp_pool
);
613 vfree(c2dev
->qptr_array
);
619 * Called by c2_remove to cleanup the RNIC resources.
621 void c2_rnic_term(struct c2_dev
*c2dev
)
624 /* Close the open adapter instance */
625 c2_rnic_close(c2dev
);
627 /* Send the TERM message to the adapter */
628 c2_adapter_term(c2dev
);
630 /* Disable interrupts on the adapter */
631 writel(1, c2dev
->regs
+ C2_IDIS
);
633 /* Free the QP pool */
634 c2_cleanup_qp_table(c2dev
);
636 /* Free the PD pool */
637 c2_cleanup_pd_table(c2dev
);
639 /* Free the verbs request allocator */
642 /* Unmap and free the asynchronus event queue */
643 dma_unmap_single(c2dev
->ibdev
.dma_device
,
644 pci_unmap_addr(&c2dev
->aeq
, mapping
),
645 c2dev
->aeq
.q_size
* c2dev
->aeq
.msg_size
,
647 kfree(c2dev
->aeq
.msg_pool
.host
);
649 /* Unmap and free the verbs reply queue */
650 dma_unmap_single(c2dev
->ibdev
.dma_device
,
651 pci_unmap_addr(&c2dev
->rep_vq
, mapping
),
652 c2dev
->rep_vq
.q_size
* c2dev
->rep_vq
.msg_size
,
654 kfree(c2dev
->rep_vq
.msg_pool
.host
);
656 /* Free the MQ shared pointer pool */
657 c2_free_mqsp_pool(c2dev
, c2dev
->kern_mqsp_pool
);
659 /* Free the qptr_array */
660 vfree(c2dev
->qptr_array
);