2 * IBM eServer eHCA Infiniband device driver for Linux on POWER
4 * module start stop, hca detection
6 * Authors: Heiko J Schick <schickhj@de.ibm.com>
7 * Hoang-Nam Nguyen <hnguyen@de.ibm.com>
8 * Joachim Fenkes <fenkes@de.ibm.com>
10 * Copyright (c) 2005 IBM Corporation
12 * All rights reserved.
14 * This source code is distributed under a dual license of GPL v2.0 and OpenIB
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions are met:
22 * Redistributions of source code must retain the above copyright notice, this
23 * list of conditions and the following disclaimer.
25 * Redistributions in binary form must reproduce the above copyright notice,
26 * this list of conditions and the following disclaimer in the documentation
27 * and/or other materials
28 * provided with the distribution.
30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
31 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
34 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
35 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
36 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
37 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
38 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
39 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40 * POSSIBILITY OF SUCH DAMAGE.
43 #ifdef CONFIG_PPC_64K_PAGES
44 #include <linux/slab.h>
46 #include "ehca_classes.h"
47 #include "ehca_iverbs.h"
48 #include "ehca_mrmw.h"
49 #include "ehca_tools.h"
52 MODULE_LICENSE("Dual BSD/GPL");
53 MODULE_AUTHOR("Christoph Raisch <raisch@de.ibm.com>");
54 MODULE_DESCRIPTION("IBM eServer HCA InfiniBand Device Driver");
55 MODULE_VERSION("SVNEHCA_0018");
57 int ehca_open_aqp1
= 0;
58 int ehca_debug_level
= 0;
59 int ehca_hw_level
= 0;
60 int ehca_nr_ports
= 2;
61 int ehca_use_hp_mr
= 0;
62 int ehca_port_act_time
= 30;
63 int ehca_poll_all_eqs
= 1;
64 int ehca_static_rate
= -1;
66 module_param_named(open_aqp1
, ehca_open_aqp1
, int, 0);
67 module_param_named(debug_level
, ehca_debug_level
, int, 0);
68 module_param_named(hw_level
, ehca_hw_level
, int, 0);
69 module_param_named(nr_ports
, ehca_nr_ports
, int, 0);
70 module_param_named(use_hp_mr
, ehca_use_hp_mr
, int, 0);
71 module_param_named(port_act_time
, ehca_port_act_time
, int, 0);
72 module_param_named(poll_all_eqs
, ehca_poll_all_eqs
, int, 0);
73 module_param_named(static_rate
, ehca_static_rate
, int, 0);
75 MODULE_PARM_DESC(open_aqp1
,
76 "AQP1 on startup (0: no (default), 1: yes)");
77 MODULE_PARM_DESC(debug_level
,
79 " (0: no debug traces (default), 1: with debug traces)");
80 MODULE_PARM_DESC(hw_level
,
82 " (0: autosensing (default), 1: v. 0.20, 2: v. 0.21)");
83 MODULE_PARM_DESC(nr_ports
,
84 "number of connected ports (default: 2)");
85 MODULE_PARM_DESC(use_hp_mr
,
86 "high performance MRs (0: no (default), 1: yes)");
87 MODULE_PARM_DESC(port_act_time
,
88 "time to wait for port activation (default: 30 sec)");
89 MODULE_PARM_DESC(poll_all_eqs
,
90 "polls all event queues periodically"
91 " (0: no, 1: yes (default))");
92 MODULE_PARM_DESC(static_rate
,
93 "set permanent static rate (default: disabled)");
95 spinlock_t ehca_qp_idr_lock
;
96 spinlock_t ehca_cq_idr_lock
;
97 DEFINE_IDR(ehca_qp_idr
);
98 DEFINE_IDR(ehca_cq_idr
);
101 static struct list_head shca_list
; /* list of all registered ehcas */
102 static spinlock_t shca_list_lock
;
104 static struct timer_list poll_eqs_timer
;
106 #ifdef CONFIG_PPC_64K_PAGES
107 static struct kmem_cache
*ctblk_cache
= NULL
;
109 void *ehca_alloc_fw_ctrlblock(void)
111 void *ret
= kmem_cache_zalloc(ctblk_cache
, SLAB_KERNEL
);
113 ehca_gen_err("Out of memory for ctblk");
117 void ehca_free_fw_ctrlblock(void *ptr
)
120 kmem_cache_free(ctblk_cache
, ptr
);
125 static int ehca_create_slab_caches(void)
129 ret
= ehca_init_pd_cache();
131 ehca_gen_err("Cannot create PD SLAB cache.");
135 ret
= ehca_init_cq_cache();
137 ehca_gen_err("Cannot create CQ SLAB cache.");
138 goto create_slab_caches2
;
141 ret
= ehca_init_qp_cache();
143 ehca_gen_err("Cannot create QP SLAB cache.");
144 goto create_slab_caches3
;
147 ret
= ehca_init_av_cache();
149 ehca_gen_err("Cannot create AV SLAB cache.");
150 goto create_slab_caches4
;
153 ret
= ehca_init_mrmw_cache();
155 ehca_gen_err("Cannot create MR&MW SLAB cache.");
156 goto create_slab_caches5
;
159 #ifdef CONFIG_PPC_64K_PAGES
160 ctblk_cache
= kmem_cache_create("ehca_cache_ctblk",
161 EHCA_PAGESIZE
, H_CB_ALIGNMENT
,
165 ehca_gen_err("Cannot create ctblk SLAB cache.");
166 ehca_cleanup_mrmw_cache();
167 goto create_slab_caches5
;
173 ehca_cleanup_av_cache();
176 ehca_cleanup_qp_cache();
179 ehca_cleanup_cq_cache();
182 ehca_cleanup_pd_cache();
187 static void ehca_destroy_slab_caches(void)
189 ehca_cleanup_mrmw_cache();
190 ehca_cleanup_av_cache();
191 ehca_cleanup_qp_cache();
192 ehca_cleanup_cq_cache();
193 ehca_cleanup_pd_cache();
194 #ifdef CONFIG_PPC_64K_PAGES
196 kmem_cache_destroy(ctblk_cache
);
200 #define EHCA_HCAAVER EHCA_BMASK_IBM(32,39)
201 #define EHCA_REVID EHCA_BMASK_IBM(40,63)
203 int ehca_sense_attributes(struct ehca_shca
*shca
)
207 struct hipz_query_hca
*rblock
;
209 rblock
= ehca_alloc_fw_ctrlblock();
211 ehca_gen_err("Cannot allocate rblock memory.");
215 h_ret
= hipz_h_query_hca(shca
->ipz_hca_handle
, rblock
);
216 if (h_ret
!= H_SUCCESS
) {
217 ehca_gen_err("Cannot query device properties. h_ret=%lx",
223 if (ehca_nr_ports
== 1)
226 shca
->num_ports
= (u8
)rblock
->num_ports
;
228 ehca_gen_dbg(" ... found %x ports", rblock
->num_ports
);
230 if (ehca_hw_level
== 0) {
234 hcaaver
= EHCA_BMASK_GET(EHCA_HCAAVER
, rblock
->hw_ver
);
235 revid
= EHCA_BMASK_GET(EHCA_REVID
, rblock
->hw_ver
);
237 ehca_gen_dbg(" ... hardware version=%x:%x", hcaaver
, revid
);
239 if ((hcaaver
== 1) && (revid
== 0))
241 else if ((hcaaver
== 1) && (revid
== 1))
243 else if ((hcaaver
== 1) && (revid
== 2))
246 ehca_gen_dbg(" ... hardware level=%x", shca
->hw_level
);
248 shca
->sport
[0].rate
= IB_RATE_30_GBPS
;
249 shca
->sport
[1].rate
= IB_RATE_30_GBPS
;
252 ehca_free_fw_ctrlblock(rblock
);
256 static int init_node_guid(struct ehca_shca
*shca
)
259 struct hipz_query_hca
*rblock
;
261 rblock
= ehca_alloc_fw_ctrlblock();
263 ehca_err(&shca
->ib_device
, "Can't allocate rblock memory.");
267 if (hipz_h_query_hca(shca
->ipz_hca_handle
, rblock
) != H_SUCCESS
) {
268 ehca_err(&shca
->ib_device
, "Can't query device properties");
270 goto init_node_guid1
;
273 memcpy(&shca
->ib_device
.node_guid
, &rblock
->node_guid
, sizeof(u64
));
276 ehca_free_fw_ctrlblock(rblock
);
280 int ehca_init_device(struct ehca_shca
*shca
)
284 ret
= init_node_guid(shca
);
288 strlcpy(shca
->ib_device
.name
, "ehca%d", IB_DEVICE_NAME_MAX
);
289 shca
->ib_device
.owner
= THIS_MODULE
;
291 shca
->ib_device
.uverbs_abi_ver
= 5;
292 shca
->ib_device
.uverbs_cmd_mask
=
293 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT
) |
294 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE
) |
295 (1ull << IB_USER_VERBS_CMD_QUERY_PORT
) |
296 (1ull << IB_USER_VERBS_CMD_ALLOC_PD
) |
297 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD
) |
298 (1ull << IB_USER_VERBS_CMD_REG_MR
) |
299 (1ull << IB_USER_VERBS_CMD_DEREG_MR
) |
300 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL
) |
301 (1ull << IB_USER_VERBS_CMD_CREATE_CQ
) |
302 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ
) |
303 (1ull << IB_USER_VERBS_CMD_CREATE_QP
) |
304 (1ull << IB_USER_VERBS_CMD_MODIFY_QP
) |
305 (1ull << IB_USER_VERBS_CMD_QUERY_QP
) |
306 (1ull << IB_USER_VERBS_CMD_DESTROY_QP
) |
307 (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST
) |
308 (1ull << IB_USER_VERBS_CMD_DETACH_MCAST
);
310 shca
->ib_device
.node_type
= RDMA_NODE_IB_CA
;
311 shca
->ib_device
.phys_port_cnt
= shca
->num_ports
;
312 shca
->ib_device
.dma_device
= &shca
->ibmebus_dev
->ofdev
.dev
;
313 shca
->ib_device
.query_device
= ehca_query_device
;
314 shca
->ib_device
.query_port
= ehca_query_port
;
315 shca
->ib_device
.query_gid
= ehca_query_gid
;
316 shca
->ib_device
.query_pkey
= ehca_query_pkey
;
317 /* shca->in_device.modify_device = ehca_modify_device */
318 shca
->ib_device
.modify_port
= ehca_modify_port
;
319 shca
->ib_device
.alloc_ucontext
= ehca_alloc_ucontext
;
320 shca
->ib_device
.dealloc_ucontext
= ehca_dealloc_ucontext
;
321 shca
->ib_device
.alloc_pd
= ehca_alloc_pd
;
322 shca
->ib_device
.dealloc_pd
= ehca_dealloc_pd
;
323 shca
->ib_device
.create_ah
= ehca_create_ah
;
324 /* shca->ib_device.modify_ah = ehca_modify_ah; */
325 shca
->ib_device
.query_ah
= ehca_query_ah
;
326 shca
->ib_device
.destroy_ah
= ehca_destroy_ah
;
327 shca
->ib_device
.create_qp
= ehca_create_qp
;
328 shca
->ib_device
.modify_qp
= ehca_modify_qp
;
329 shca
->ib_device
.query_qp
= ehca_query_qp
;
330 shca
->ib_device
.destroy_qp
= ehca_destroy_qp
;
331 shca
->ib_device
.post_send
= ehca_post_send
;
332 shca
->ib_device
.post_recv
= ehca_post_recv
;
333 shca
->ib_device
.create_cq
= ehca_create_cq
;
334 shca
->ib_device
.destroy_cq
= ehca_destroy_cq
;
335 shca
->ib_device
.resize_cq
= ehca_resize_cq
;
336 shca
->ib_device
.poll_cq
= ehca_poll_cq
;
337 /* shca->ib_device.peek_cq = ehca_peek_cq; */
338 shca
->ib_device
.req_notify_cq
= ehca_req_notify_cq
;
339 /* shca->ib_device.req_ncomp_notif = ehca_req_ncomp_notif; */
340 shca
->ib_device
.get_dma_mr
= ehca_get_dma_mr
;
341 shca
->ib_device
.reg_phys_mr
= ehca_reg_phys_mr
;
342 shca
->ib_device
.reg_user_mr
= ehca_reg_user_mr
;
343 shca
->ib_device
.query_mr
= ehca_query_mr
;
344 shca
->ib_device
.dereg_mr
= ehca_dereg_mr
;
345 shca
->ib_device
.rereg_phys_mr
= ehca_rereg_phys_mr
;
346 shca
->ib_device
.alloc_mw
= ehca_alloc_mw
;
347 shca
->ib_device
.bind_mw
= ehca_bind_mw
;
348 shca
->ib_device
.dealloc_mw
= ehca_dealloc_mw
;
349 shca
->ib_device
.alloc_fmr
= ehca_alloc_fmr
;
350 shca
->ib_device
.map_phys_fmr
= ehca_map_phys_fmr
;
351 shca
->ib_device
.unmap_fmr
= ehca_unmap_fmr
;
352 shca
->ib_device
.dealloc_fmr
= ehca_dealloc_fmr
;
353 shca
->ib_device
.attach_mcast
= ehca_attach_mcast
;
354 shca
->ib_device
.detach_mcast
= ehca_detach_mcast
;
355 /* shca->ib_device.process_mad = ehca_process_mad; */
356 shca
->ib_device
.mmap
= ehca_mmap
;
361 static int ehca_create_aqp1(struct ehca_shca
*shca
, u32 port
)
363 struct ehca_sport
*sport
= &shca
->sport
[port
- 1];
366 struct ib_qp_init_attr qp_init_attr
;
369 if (sport
->ibcq_aqp1
) {
370 ehca_err(&shca
->ib_device
, "AQP1 CQ is already created.");
374 ibcq
= ib_create_cq(&shca
->ib_device
, NULL
, NULL
, (void*)(-1), 10);
376 ehca_err(&shca
->ib_device
, "Cannot create AQP1 CQ.");
377 return PTR_ERR(ibcq
);
379 sport
->ibcq_aqp1
= ibcq
;
381 if (sport
->ibqp_aqp1
) {
382 ehca_err(&shca
->ib_device
, "AQP1 QP is already created.");
387 memset(&qp_init_attr
, 0, sizeof(struct ib_qp_init_attr
));
388 qp_init_attr
.send_cq
= ibcq
;
389 qp_init_attr
.recv_cq
= ibcq
;
390 qp_init_attr
.sq_sig_type
= IB_SIGNAL_ALL_WR
;
391 qp_init_attr
.cap
.max_send_wr
= 100;
392 qp_init_attr
.cap
.max_recv_wr
= 100;
393 qp_init_attr
.cap
.max_send_sge
= 2;
394 qp_init_attr
.cap
.max_recv_sge
= 1;
395 qp_init_attr
.qp_type
= IB_QPT_GSI
;
396 qp_init_attr
.port_num
= port
;
397 qp_init_attr
.qp_context
= NULL
;
398 qp_init_attr
.event_handler
= NULL
;
399 qp_init_attr
.srq
= NULL
;
401 ibqp
= ib_create_qp(&shca
->pd
->ib_pd
, &qp_init_attr
);
403 ehca_err(&shca
->ib_device
, "Cannot create AQP1 QP.");
407 sport
->ibqp_aqp1
= ibqp
;
412 ib_destroy_cq(sport
->ibcq_aqp1
);
416 static int ehca_destroy_aqp1(struct ehca_sport
*sport
)
420 ret
= ib_destroy_qp(sport
->ibqp_aqp1
);
422 ehca_gen_err("Cannot destroy AQP1 QP. ret=%x", ret
);
426 ret
= ib_destroy_cq(sport
->ibcq_aqp1
);
428 ehca_gen_err("Cannot destroy AQP1 CQ. ret=%x", ret
);
433 static ssize_t
ehca_show_debug_level(struct device_driver
*ddp
, char *buf
)
435 return snprintf(buf
, PAGE_SIZE
, "%d\n",
439 static ssize_t
ehca_store_debug_level(struct device_driver
*ddp
,
440 const char *buf
, size_t count
)
442 int value
= (*buf
) - '0';
443 if (value
>= 0 && value
<= 9)
444 ehca_debug_level
= value
;
448 DRIVER_ATTR(debug_level
, S_IRUSR
| S_IWUSR
,
449 ehca_show_debug_level
, ehca_store_debug_level
);
451 void ehca_create_driver_sysfs(struct ibmebus_driver
*drv
)
453 driver_create_file(&drv
->driver
, &driver_attr_debug_level
);
456 void ehca_remove_driver_sysfs(struct ibmebus_driver
*drv
)
458 driver_remove_file(&drv
->driver
, &driver_attr_debug_level
);
461 #define EHCA_RESOURCE_ATTR(name) \
462 static ssize_t ehca_show_##name(struct device *dev, \
463 struct device_attribute *attr, \
466 struct ehca_shca *shca; \
467 struct hipz_query_hca *rblock; \
470 shca = dev->driver_data; \
472 rblock = ehca_alloc_fw_ctrlblock(); \
474 dev_err(dev, "Can't allocate rblock memory."); \
478 if (hipz_h_query_hca(shca->ipz_hca_handle, rblock) != H_SUCCESS) { \
479 dev_err(dev, "Can't query device properties"); \
480 ehca_free_fw_ctrlblock(rblock); \
484 data = rblock->name; \
485 ehca_free_fw_ctrlblock(rblock); \
487 if ((strcmp(#name, "num_ports") == 0) && (ehca_nr_ports == 1)) \
488 return snprintf(buf, 256, "1\n"); \
490 return snprintf(buf, 256, "%d\n", data); \
493 static DEVICE_ATTR(name, S_IRUGO, ehca_show_##name, NULL);
495 EHCA_RESOURCE_ATTR(num_ports
);
496 EHCA_RESOURCE_ATTR(hw_ver
);
497 EHCA_RESOURCE_ATTR(max_eq
);
498 EHCA_RESOURCE_ATTR(cur_eq
);
499 EHCA_RESOURCE_ATTR(max_cq
);
500 EHCA_RESOURCE_ATTR(cur_cq
);
501 EHCA_RESOURCE_ATTR(max_qp
);
502 EHCA_RESOURCE_ATTR(cur_qp
);
503 EHCA_RESOURCE_ATTR(max_mr
);
504 EHCA_RESOURCE_ATTR(cur_mr
);
505 EHCA_RESOURCE_ATTR(max_mw
);
506 EHCA_RESOURCE_ATTR(cur_mw
);
507 EHCA_RESOURCE_ATTR(max_pd
);
508 EHCA_RESOURCE_ATTR(max_ah
);
510 static ssize_t
ehca_show_adapter_handle(struct device
*dev
,
511 struct device_attribute
*attr
,
514 struct ehca_shca
*shca
= dev
->driver_data
;
516 return sprintf(buf
, "%lx\n", shca
->ipz_hca_handle
.handle
);
519 static DEVICE_ATTR(adapter_handle
, S_IRUGO
, ehca_show_adapter_handle
, NULL
);
522 void ehca_create_device_sysfs(struct ibmebus_dev
*dev
)
524 device_create_file(&dev
->ofdev
.dev
, &dev_attr_adapter_handle
);
525 device_create_file(&dev
->ofdev
.dev
, &dev_attr_num_ports
);
526 device_create_file(&dev
->ofdev
.dev
, &dev_attr_hw_ver
);
527 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_eq
);
528 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_eq
);
529 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_cq
);
530 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_cq
);
531 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_qp
);
532 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_qp
);
533 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_mr
);
534 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_mr
);
535 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_mw
);
536 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_mw
);
537 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_pd
);
538 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_ah
);
541 void ehca_remove_device_sysfs(struct ibmebus_dev
*dev
)
543 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_adapter_handle
);
544 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_num_ports
);
545 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_hw_ver
);
546 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_eq
);
547 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_eq
);
548 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_cq
);
549 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_cq
);
550 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_qp
);
551 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_qp
);
552 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_mr
);
553 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_mr
);
554 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_mw
);
555 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_mw
);
556 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_pd
);
557 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_ah
);
560 static int __devinit
ehca_probe(struct ibmebus_dev
*dev
,
561 const struct of_device_id
*id
)
563 struct ehca_shca
*shca
;
568 handle
= (u64
*)get_property(dev
->ofdev
.node
, "ibm,hca-handle", NULL
);
570 ehca_gen_err("Cannot get eHCA handle for adapter: %s.",
571 dev
->ofdev
.node
->full_name
);
576 ehca_gen_err("Wrong eHCA handle for adapter: %s.",
577 dev
->ofdev
.node
->full_name
);
581 shca
= (struct ehca_shca
*)ib_alloc_device(sizeof(*shca
));
583 ehca_gen_err("Cannot allocate shca memory.");
587 shca
->ibmebus_dev
= dev
;
588 shca
->ipz_hca_handle
.handle
= *handle
;
589 dev
->ofdev
.dev
.driver_data
= shca
;
591 ret
= ehca_sense_attributes(shca
);
593 ehca_gen_err("Cannot sense eHCA attributes.");
597 ret
= ehca_init_device(shca
);
599 ehca_gen_err("Cannot init ehca device struct");
603 /* create event queues */
604 ret
= ehca_create_eq(shca
, &shca
->eq
, EHCA_EQ
, 2048);
606 ehca_err(&shca
->ib_device
, "Cannot create EQ.");
610 ret
= ehca_create_eq(shca
, &shca
->neq
, EHCA_NEQ
, 513);
612 ehca_err(&shca
->ib_device
, "Cannot create NEQ.");
616 /* create internal protection domain */
617 ibpd
= ehca_alloc_pd(&shca
->ib_device
, (void*)(-1), NULL
);
619 ehca_err(&shca
->ib_device
, "Cannot create internal PD.");
624 shca
->pd
= container_of(ibpd
, struct ehca_pd
, ib_pd
);
625 shca
->pd
->ib_pd
.device
= &shca
->ib_device
;
627 /* create internal max MR */
628 ret
= ehca_reg_internal_maxmr(shca
, shca
->pd
, &shca
->maxmr
);
631 ehca_err(&shca
->ib_device
, "Cannot create internal MR ret=%x",
636 ret
= ib_register_device(&shca
->ib_device
);
638 ehca_err(&shca
->ib_device
,
639 "ib_register_device() failed ret=%x", ret
);
643 /* create AQP1 for port 1 */
644 if (ehca_open_aqp1
== 1) {
645 shca
->sport
[0].port_state
= IB_PORT_DOWN
;
646 ret
= ehca_create_aqp1(shca
, 1);
648 ehca_err(&shca
->ib_device
,
649 "Cannot create AQP1 for port 1.");
654 /* create AQP1 for port 2 */
655 if ((ehca_open_aqp1
== 1) && (shca
->num_ports
== 2)) {
656 shca
->sport
[1].port_state
= IB_PORT_DOWN
;
657 ret
= ehca_create_aqp1(shca
, 2);
659 ehca_err(&shca
->ib_device
,
660 "Cannot create AQP1 for port 2.");
665 ehca_create_device_sysfs(dev
);
667 spin_lock(&shca_list_lock
);
668 list_add(&shca
->shca_list
, &shca_list
);
669 spin_unlock(&shca_list_lock
);
674 ret
= ehca_destroy_aqp1(&shca
->sport
[0]);
676 ehca_err(&shca
->ib_device
,
677 "Cannot destroy AQP1 for port 1. ret=%x", ret
);
680 ib_unregister_device(&shca
->ib_device
);
683 ret
= ehca_dereg_internal_maxmr(shca
);
685 ehca_err(&shca
->ib_device
,
686 "Cannot destroy internal MR. ret=%x", ret
);
689 ret
= ehca_dealloc_pd(&shca
->pd
->ib_pd
);
691 ehca_err(&shca
->ib_device
,
692 "Cannot destroy internal PD. ret=%x", ret
);
695 ret
= ehca_destroy_eq(shca
, &shca
->neq
);
697 ehca_err(&shca
->ib_device
,
698 "Cannot destroy NEQ. ret=%x", ret
);
701 ret
= ehca_destroy_eq(shca
, &shca
->eq
);
703 ehca_err(&shca
->ib_device
,
704 "Cannot destroy EQ. ret=%x", ret
);
707 ib_dealloc_device(&shca
->ib_device
);
712 static int __devexit
ehca_remove(struct ibmebus_dev
*dev
)
714 struct ehca_shca
*shca
= dev
->ofdev
.dev
.driver_data
;
717 ehca_remove_device_sysfs(dev
);
719 if (ehca_open_aqp1
== 1) {
721 for (i
= 0; i
< shca
->num_ports
; i
++) {
722 ret
= ehca_destroy_aqp1(&shca
->sport
[i
]);
724 ehca_err(&shca
->ib_device
,
725 "Cannot destroy AQP1 for port %x "
730 ib_unregister_device(&shca
->ib_device
);
732 ret
= ehca_dereg_internal_maxmr(shca
);
734 ehca_err(&shca
->ib_device
,
735 "Cannot destroy internal MR. ret=%x", ret
);
737 ret
= ehca_dealloc_pd(&shca
->pd
->ib_pd
);
739 ehca_err(&shca
->ib_device
,
740 "Cannot destroy internal PD. ret=%x", ret
);
742 ret
= ehca_destroy_eq(shca
, &shca
->eq
);
744 ehca_err(&shca
->ib_device
, "Cannot destroy EQ. ret=%x", ret
);
746 ret
= ehca_destroy_eq(shca
, &shca
->neq
);
748 ehca_err(&shca
->ib_device
, "Canot destroy NEQ. ret=%x", ret
);
750 ib_dealloc_device(&shca
->ib_device
);
752 spin_lock(&shca_list_lock
);
753 list_del(&shca
->shca_list
);
754 spin_unlock(&shca_list_lock
);
759 static struct of_device_id ehca_device_table
[] =
763 .compatible
= "IBM,lhca",
768 static struct ibmebus_driver ehca_driver
= {
770 .id_table
= ehca_device_table
,
772 .remove
= ehca_remove
,
775 void ehca_poll_eqs(unsigned long data
)
777 struct ehca_shca
*shca
;
779 spin_lock(&shca_list_lock
);
780 list_for_each_entry(shca
, &shca_list
, shca_list
) {
781 if (shca
->eq
.is_initialized
)
782 ehca_tasklet_eq((unsigned long)(void*)shca
);
784 mod_timer(&poll_eqs_timer
, jiffies
+ HZ
);
785 spin_unlock(&shca_list_lock
);
788 int __init
ehca_module_init(void)
792 printk(KERN_INFO
"eHCA Infiniband Device Driver "
793 "(Rel.: SVNEHCA_0018)\n");
794 idr_init(&ehca_qp_idr
);
795 idr_init(&ehca_cq_idr
);
796 spin_lock_init(&ehca_qp_idr_lock
);
797 spin_lock_init(&ehca_cq_idr_lock
);
799 INIT_LIST_HEAD(&shca_list
);
800 spin_lock_init(&shca_list_lock
);
802 if ((ret
= ehca_create_comp_pool())) {
803 ehca_gen_err("Cannot create comp pool.");
807 if ((ret
= ehca_create_slab_caches())) {
808 ehca_gen_err("Cannot create SLAB caches");
813 if ((ret
= ibmebus_register_driver(&ehca_driver
))) {
814 ehca_gen_err("Cannot register eHCA device driver");
819 ehca_create_driver_sysfs(&ehca_driver
);
821 if (ehca_poll_all_eqs
!= 1) {
822 ehca_gen_err("WARNING!!!");
823 ehca_gen_err("It is possible to lose interrupts.");
825 init_timer(&poll_eqs_timer
);
826 poll_eqs_timer
.function
= ehca_poll_eqs
;
827 poll_eqs_timer
.expires
= jiffies
+ HZ
;
828 add_timer(&poll_eqs_timer
);
834 ehca_destroy_slab_caches();
837 ehca_destroy_comp_pool();
841 void __exit
ehca_module_exit(void)
843 if (ehca_poll_all_eqs
== 1)
844 del_timer_sync(&poll_eqs_timer
);
846 ehca_remove_driver_sysfs(&ehca_driver
);
847 ibmebus_unregister_driver(&ehca_driver
);
849 ehca_destroy_slab_caches();
851 ehca_destroy_comp_pool();
853 idr_destroy(&ehca_cq_idr
);
854 idr_destroy(&ehca_qp_idr
);
857 module_init(ehca_module_init
);
858 module_exit(ehca_module_exit
);