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>
53 #include <linux/vmalloc.h>
54 #include <linux/slab.h>
56 #include <linux/route.h>
60 #include <asm/byteorder.h>
61 #include <rdma/ib_smi.h>
65 /* Device capabilities */
66 #define C2_MIN_PAGESIZE 1024
68 #define C2_MAX_MRS 32768
69 #define C2_MAX_QPS 16000
70 #define C2_MAX_WQE_SZ 256
71 #define C2_MAX_QP_WR ((128*1024)/C2_MAX_WQE_SZ)
73 #define C2_MAX_SGE_RD 1
74 #define C2_MAX_CQS 32768
75 #define C2_MAX_CQES 4096
76 #define C2_MAX_PDS 16384
79 * Send the adapter INIT message to the amso1100
81 static int c2_adapter_init(struct c2_dev
*c2dev
)
83 struct c2wr_init_req wr
;
85 memset(&wr
, 0, sizeof(wr
));
86 c2_wr_set_id(&wr
, CCWR_INIT
);
88 wr
.hint_count
= cpu_to_be64(c2dev
->hint_count_dma
);
89 wr
.q0_host_shared
= cpu_to_be64(c2dev
->req_vq
.shared_dma
);
90 wr
.q1_host_shared
= cpu_to_be64(c2dev
->rep_vq
.shared_dma
);
91 wr
.q1_host_msg_pool
= cpu_to_be64(c2dev
->rep_vq
.host_dma
);
92 wr
.q2_host_shared
= cpu_to_be64(c2dev
->aeq
.shared_dma
);
93 wr
.q2_host_msg_pool
= cpu_to_be64(c2dev
->aeq
.host_dma
);
95 /* Post the init message */
96 return vq_send_wr(c2dev
, (union c2wr
*) & wr
);
100 * Send the adapter TERM message to the amso1100
102 static void c2_adapter_term(struct c2_dev
*c2dev
)
104 struct c2wr_init_req wr
;
106 memset(&wr
, 0, sizeof(wr
));
107 c2_wr_set_id(&wr
, CCWR_TERM
);
110 /* Post the init message */
111 vq_send_wr(c2dev
, (union c2wr
*) & wr
);
120 static int c2_rnic_query(struct c2_dev
*c2dev
, struct ib_device_attr
*props
)
122 struct c2_vq_req
*vq_req
;
123 struct c2wr_rnic_query_req wr
;
124 struct c2wr_rnic_query_rep
*reply
;
127 vq_req
= vq_req_alloc(c2dev
);
131 c2_wr_set_id(&wr
, CCWR_RNIC_QUERY
);
132 wr
.hdr
.context
= (unsigned long) vq_req
;
133 wr
.rnic_handle
= c2dev
->adapter_handle
;
135 vq_req_get(c2dev
, vq_req
);
137 err
= vq_send_wr(c2dev
, (union c2wr
*) &wr
);
139 vq_req_put(c2dev
, vq_req
);
143 err
= vq_wait_for_reply(c2dev
, vq_req
);
148 (struct c2wr_rnic_query_rep
*) (unsigned long) (vq_req
->reply_msg
);
152 err
= c2_errno(reply
);
157 ((u64
)be32_to_cpu(reply
->fw_ver_major
) << 32) |
158 ((be32_to_cpu(reply
->fw_ver_minor
) & 0xFFFF) << 16) |
159 (be32_to_cpu(reply
->fw_ver_patch
) & 0xFFFF);
160 memcpy(&props
->sys_image_guid
, c2dev
->netdev
->dev_addr
, 6);
161 props
->max_mr_size
= 0xFFFFFFFF;
162 props
->page_size_cap
= ~(C2_MIN_PAGESIZE
-1);
163 props
->vendor_id
= be32_to_cpu(reply
->vendor_id
);
164 props
->vendor_part_id
= be32_to_cpu(reply
->part_number
);
165 props
->hw_ver
= be32_to_cpu(reply
->hw_version
);
166 props
->max_qp
= be32_to_cpu(reply
->max_qps
);
167 props
->max_qp_wr
= be32_to_cpu(reply
->max_qp_depth
);
168 props
->device_cap_flags
= c2dev
->device_cap_flags
;
169 props
->max_sge
= C2_MAX_SGES
;
170 props
->max_sge_rd
= C2_MAX_SGE_RD
;
171 props
->max_cq
= be32_to_cpu(reply
->max_cqs
);
172 props
->max_cqe
= be32_to_cpu(reply
->max_cq_depth
);
173 props
->max_mr
= be32_to_cpu(reply
->max_mrs
);
174 props
->max_pd
= be32_to_cpu(reply
->max_pds
);
175 props
->max_qp_rd_atom
= be32_to_cpu(reply
->max_qp_ird
);
176 props
->max_ee_rd_atom
= 0;
177 props
->max_res_rd_atom
= be32_to_cpu(reply
->max_global_ird
);
178 props
->max_qp_init_rd_atom
= be32_to_cpu(reply
->max_qp_ord
);
179 props
->max_ee_init_rd_atom
= 0;
180 props
->atomic_cap
= IB_ATOMIC_NONE
;
183 props
->max_mw
= be32_to_cpu(reply
->max_mws
);
184 props
->max_raw_ipv6_qp
= 0;
185 props
->max_raw_ethy_qp
= 0;
186 props
->max_mcast_grp
= 0;
187 props
->max_mcast_qp_attach
= 0;
188 props
->max_total_mcast_qp_attach
= 0;
191 props
->max_map_per_fmr
= 0;
193 props
->max_srq_wr
= 0;
194 props
->max_srq_sge
= 0;
195 props
->max_pkeys
= 0;
196 props
->local_ca_ack_delay
= 0;
199 vq_repbuf_free(c2dev
, reply
);
202 vq_req_free(c2dev
, vq_req
);
207 * Add an IP address to the RNIC interface
209 int c2_add_addr(struct c2_dev
*c2dev
, __be32 inaddr
, __be32 inmask
)
211 struct c2_vq_req
*vq_req
;
212 struct c2wr_rnic_setconfig_req
*wr
;
213 struct c2wr_rnic_setconfig_rep
*reply
;
214 struct c2_netaddr netaddr
;
217 vq_req
= vq_req_alloc(c2dev
);
221 len
= sizeof(struct c2_netaddr
);
222 wr
= kmalloc(c2dev
->req_vq
.msg_size
, GFP_KERNEL
);
228 c2_wr_set_id(wr
, CCWR_RNIC_SETCONFIG
);
229 wr
->hdr
.context
= (unsigned long) vq_req
;
230 wr
->rnic_handle
= c2dev
->adapter_handle
;
231 wr
->option
= cpu_to_be32(C2_CFG_ADD_ADDR
);
233 netaddr
.ip_addr
= inaddr
;
234 netaddr
.netmask
= inmask
;
237 memcpy(wr
->data
, &netaddr
, len
);
239 vq_req_get(c2dev
, vq_req
);
241 err
= vq_send_wr(c2dev
, (union c2wr
*) wr
);
243 vq_req_put(c2dev
, vq_req
);
247 err
= vq_wait_for_reply(c2dev
, vq_req
);
252 (struct c2wr_rnic_setconfig_rep
*) (unsigned long) (vq_req
->reply_msg
);
258 err
= c2_errno(reply
);
259 vq_repbuf_free(c2dev
, reply
);
264 vq_req_free(c2dev
, vq_req
);
269 * Delete an IP address from the RNIC interface
271 int c2_del_addr(struct c2_dev
*c2dev
, __be32 inaddr
, __be32 inmask
)
273 struct c2_vq_req
*vq_req
;
274 struct c2wr_rnic_setconfig_req
*wr
;
275 struct c2wr_rnic_setconfig_rep
*reply
;
276 struct c2_netaddr netaddr
;
279 vq_req
= vq_req_alloc(c2dev
);
283 len
= sizeof(struct c2_netaddr
);
284 wr
= kmalloc(c2dev
->req_vq
.msg_size
, GFP_KERNEL
);
290 c2_wr_set_id(wr
, CCWR_RNIC_SETCONFIG
);
291 wr
->hdr
.context
= (unsigned long) vq_req
;
292 wr
->rnic_handle
= c2dev
->adapter_handle
;
293 wr
->option
= cpu_to_be32(C2_CFG_DEL_ADDR
);
295 netaddr
.ip_addr
= inaddr
;
296 netaddr
.netmask
= inmask
;
299 memcpy(wr
->data
, &netaddr
, len
);
301 vq_req_get(c2dev
, vq_req
);
303 err
= vq_send_wr(c2dev
, (union c2wr
*) wr
);
305 vq_req_put(c2dev
, vq_req
);
309 err
= vq_wait_for_reply(c2dev
, vq_req
);
314 (struct c2wr_rnic_setconfig_rep
*) (unsigned long) (vq_req
->reply_msg
);
320 err
= c2_errno(reply
);
321 vq_repbuf_free(c2dev
, reply
);
326 vq_req_free(c2dev
, vq_req
);
331 * Open a single RNIC instance to use with all
332 * low level openib calls
334 static int c2_rnic_open(struct c2_dev
*c2dev
)
336 struct c2_vq_req
*vq_req
;
338 struct c2wr_rnic_open_rep
*reply
;
341 vq_req
= vq_req_alloc(c2dev
);
342 if (vq_req
== NULL
) {
346 memset(&wr
, 0, sizeof(wr
));
347 c2_wr_set_id(&wr
, CCWR_RNIC_OPEN
);
348 wr
.rnic_open
.req
.hdr
.context
= (unsigned long) (vq_req
);
349 wr
.rnic_open
.req
.flags
= cpu_to_be16(RNIC_PRIV_MODE
);
350 wr
.rnic_open
.req
.port_num
= cpu_to_be16(0);
351 wr
.rnic_open
.req
.user_context
= (unsigned long) c2dev
;
353 vq_req_get(c2dev
, vq_req
);
355 err
= vq_send_wr(c2dev
, &wr
);
357 vq_req_put(c2dev
, vq_req
);
361 err
= vq_wait_for_reply(c2dev
, vq_req
);
366 reply
= (struct c2wr_rnic_open_rep
*) (unsigned long) (vq_req
->reply_msg
);
372 if ((err
= c2_errno(reply
)) != 0) {
376 c2dev
->adapter_handle
= reply
->rnic_handle
;
379 vq_repbuf_free(c2dev
, reply
);
381 vq_req_free(c2dev
, vq_req
);
386 * Close the RNIC instance
388 static int c2_rnic_close(struct c2_dev
*c2dev
)
390 struct c2_vq_req
*vq_req
;
392 struct c2wr_rnic_close_rep
*reply
;
395 vq_req
= vq_req_alloc(c2dev
);
396 if (vq_req
== NULL
) {
400 memset(&wr
, 0, sizeof(wr
));
401 c2_wr_set_id(&wr
, CCWR_RNIC_CLOSE
);
402 wr
.rnic_close
.req
.hdr
.context
= (unsigned long) vq_req
;
403 wr
.rnic_close
.req
.rnic_handle
= c2dev
->adapter_handle
;
405 vq_req_get(c2dev
, vq_req
);
407 err
= vq_send_wr(c2dev
, &wr
);
409 vq_req_put(c2dev
, vq_req
);
413 err
= vq_wait_for_reply(c2dev
, vq_req
);
418 reply
= (struct c2wr_rnic_close_rep
*) (unsigned long) (vq_req
->reply_msg
);
424 if ((err
= c2_errno(reply
)) != 0) {
428 c2dev
->adapter_handle
= 0;
431 vq_repbuf_free(c2dev
, reply
);
433 vq_req_free(c2dev
, vq_req
);
438 * Called by c2_probe to initialize the RNIC. This principally
439 * involves initializing the various limits and resource pools that
440 * comprise the RNIC instance.
442 int c2_rnic_init(struct c2_dev
*c2dev
)
448 void __iomem
*mmio_regs
;
450 /* Device capabilities */
451 c2dev
->device_cap_flags
=
452 (IB_DEVICE_RESIZE_MAX_WR
|
453 IB_DEVICE_CURR_QP_STATE_MOD
|
454 IB_DEVICE_SYS_IMAGE_GUID
|
455 IB_DEVICE_LOCAL_DMA_LKEY
|
456 IB_DEVICE_MEM_WINDOW
);
458 /* Allocate the qptr_array */
459 c2dev
->qptr_array
= vzalloc(C2_MAX_CQS
* sizeof(void *));
460 if (!c2dev
->qptr_array
) {
464 /* Initialize the qptr_array */
465 c2dev
->qptr_array
[0] = (void *) &c2dev
->req_vq
;
466 c2dev
->qptr_array
[1] = (void *) &c2dev
->rep_vq
;
467 c2dev
->qptr_array
[2] = (void *) &c2dev
->aeq
;
469 /* Initialize data structures */
470 init_waitqueue_head(&c2dev
->req_vq_wo
);
471 spin_lock_init(&c2dev
->vqlock
);
472 spin_lock_init(&c2dev
->lock
);
474 /* Allocate MQ shared pointer pool for kernel clients. User
475 * mode client pools are hung off the user context
477 err
= c2_init_mqsp_pool(c2dev
, GFP_KERNEL
, &c2dev
->kern_mqsp_pool
);
482 /* Allocate shared pointers for Q0, Q1, and Q2 from
483 * the shared pointer pool.
486 c2dev
->hint_count
= c2_alloc_mqsp(c2dev
, c2dev
->kern_mqsp_pool
,
487 &c2dev
->hint_count_dma
,
489 c2dev
->req_vq
.shared
= c2_alloc_mqsp(c2dev
, c2dev
->kern_mqsp_pool
,
490 &c2dev
->req_vq
.shared_dma
,
492 c2dev
->rep_vq
.shared
= c2_alloc_mqsp(c2dev
, c2dev
->kern_mqsp_pool
,
493 &c2dev
->rep_vq
.shared_dma
,
495 c2dev
->aeq
.shared
= c2_alloc_mqsp(c2dev
, c2dev
->kern_mqsp_pool
,
496 &c2dev
->aeq
.shared_dma
, GFP_KERNEL
);
497 if (!c2dev
->hint_count
|| !c2dev
->req_vq
.shared
||
498 !c2dev
->rep_vq
.shared
|| !c2dev
->aeq
.shared
) {
503 mmio_regs
= c2dev
->kva
;
504 /* Initialize the Verbs Request Queue */
505 c2_mq_req_init(&c2dev
->req_vq
, 0,
506 be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q0_QSIZE
)),
507 be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q0_MSGSIZE
)),
509 be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q0_POOLSTART
)),
511 be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q0_SHARED
)),
512 C2_MQ_ADAPTER_TARGET
);
514 /* Initialize the Verbs Reply Queue */
515 qsize
= be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q1_QSIZE
));
516 msgsize
= be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q1_MSGSIZE
));
517 q1_pages
= dma_alloc_coherent(&c2dev
->pcidev
->dev
, qsize
* msgsize
,
518 &c2dev
->rep_vq
.host_dma
, GFP_KERNEL
);
523 dma_unmap_addr_set(&c2dev
->rep_vq
, mapping
, c2dev
->rep_vq
.host_dma
);
524 pr_debug("%s rep_vq va %p dma %llx\n", __func__
, q1_pages
,
525 (unsigned long long) c2dev
->rep_vq
.host_dma
);
526 c2_mq_rep_init(&c2dev
->rep_vq
,
532 be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q1_SHARED
)),
535 /* Initialize the Asynchronus Event Queue */
536 qsize
= be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q2_QSIZE
));
537 msgsize
= be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q2_MSGSIZE
));
538 q2_pages
= dma_alloc_coherent(&c2dev
->pcidev
->dev
, qsize
* msgsize
,
539 &c2dev
->aeq
.host_dma
, GFP_KERNEL
);
544 dma_unmap_addr_set(&c2dev
->aeq
, mapping
, c2dev
->aeq
.host_dma
);
545 pr_debug("%s aeq va %p dma %llx\n", __func__
, q2_pages
,
546 (unsigned long long) c2dev
->aeq
.host_dma
);
547 c2_mq_rep_init(&c2dev
->aeq
,
553 be32_to_cpu((__force __be32
) readl(mmio_regs
+ C2_REGS_Q2_SHARED
)),
556 /* Initialize the verbs request allocator */
557 err
= vq_init(c2dev
);
561 /* Enable interrupts on the adapter */
562 writel(0, c2dev
->regs
+ C2_IDIS
);
564 /* create the WR init message */
565 err
= c2_adapter_init(c2dev
);
570 /* open an adapter instance */
571 err
= c2_rnic_open(c2dev
);
575 /* Initialize cached the adapter limits */
576 err
= c2_rnic_query(c2dev
, &c2dev
->props
);
580 /* Initialize the PD pool */
581 err
= c2_init_pd_table(c2dev
);
585 /* Initialize the QP pool */
586 c2_init_qp_table(c2dev
);
590 c2_rnic_close(c2dev
);
594 dma_free_coherent(&c2dev
->pcidev
->dev
,
595 c2dev
->aeq
.q_size
* c2dev
->aeq
.msg_size
,
596 q2_pages
, dma_unmap_addr(&c2dev
->aeq
, mapping
));
598 dma_free_coherent(&c2dev
->pcidev
->dev
,
599 c2dev
->rep_vq
.q_size
* c2dev
->rep_vq
.msg_size
,
600 q1_pages
, dma_unmap_addr(&c2dev
->rep_vq
, mapping
));
602 c2_free_mqsp_pool(c2dev
, c2dev
->kern_mqsp_pool
);
604 vfree(c2dev
->qptr_array
);
610 * Called by c2_remove to cleanup the RNIC resources.
612 void c2_rnic_term(struct c2_dev
*c2dev
)
615 /* Close the open adapter instance */
616 c2_rnic_close(c2dev
);
618 /* Send the TERM message to the adapter */
619 c2_adapter_term(c2dev
);
621 /* Disable interrupts on the adapter */
622 writel(1, c2dev
->regs
+ C2_IDIS
);
624 /* Free the QP pool */
625 c2_cleanup_qp_table(c2dev
);
627 /* Free the PD pool */
628 c2_cleanup_pd_table(c2dev
);
630 /* Free the verbs request allocator */
633 /* Free the asynchronus event queue */
634 dma_free_coherent(&c2dev
->pcidev
->dev
,
635 c2dev
->aeq
.q_size
* c2dev
->aeq
.msg_size
,
636 c2dev
->aeq
.msg_pool
.host
,
637 dma_unmap_addr(&c2dev
->aeq
, mapping
));
639 /* Free the verbs reply queue */
640 dma_free_coherent(&c2dev
->pcidev
->dev
,
641 c2dev
->rep_vq
.q_size
* c2dev
->rep_vq
.msg_size
,
642 c2dev
->rep_vq
.msg_pool
.host
,
643 dma_unmap_addr(&c2dev
->rep_vq
, mapping
));
645 /* Free the MQ shared pointer pool */
646 c2_free_mqsp_pool(c2dev
, c2dev
->kern_mqsp_pool
);
648 /* Free the qptr_array */
649 vfree(c2dev
->qptr_array
);