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_0022");
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;
65 int ehca_scaling_code
= 1;
67 module_param_named(open_aqp1
, ehca_open_aqp1
, int, 0);
68 module_param_named(debug_level
, ehca_debug_level
, int, 0);
69 module_param_named(hw_level
, ehca_hw_level
, int, 0);
70 module_param_named(nr_ports
, ehca_nr_ports
, int, 0);
71 module_param_named(use_hp_mr
, ehca_use_hp_mr
, int, 0);
72 module_param_named(port_act_time
, ehca_port_act_time
, int, 0);
73 module_param_named(poll_all_eqs
, ehca_poll_all_eqs
, int, 0);
74 module_param_named(static_rate
, ehca_static_rate
, int, 0);
75 module_param_named(scaling_code
, ehca_scaling_code
, int, 0);
77 MODULE_PARM_DESC(open_aqp1
,
78 "AQP1 on startup (0: no (default), 1: yes)");
79 MODULE_PARM_DESC(debug_level
,
81 " (0: no debug traces (default), 1: with debug traces)");
82 MODULE_PARM_DESC(hw_level
,
84 " (0: autosensing (default), 1: v. 0.20, 2: v. 0.21)");
85 MODULE_PARM_DESC(nr_ports
,
86 "number of connected ports (default: 2)");
87 MODULE_PARM_DESC(use_hp_mr
,
88 "high performance MRs (0: no (default), 1: yes)");
89 MODULE_PARM_DESC(port_act_time
,
90 "time to wait for port activation (default: 30 sec)");
91 MODULE_PARM_DESC(poll_all_eqs
,
92 "polls all event queues periodically"
93 " (0: no, 1: yes (default))");
94 MODULE_PARM_DESC(static_rate
,
95 "set permanent static rate (default: disabled)");
96 MODULE_PARM_DESC(scaling_code
,
97 "set scaling code (0: disabled, 1: enabled/default)");
99 spinlock_t ehca_qp_idr_lock
;
100 spinlock_t ehca_cq_idr_lock
;
101 DEFINE_IDR(ehca_qp_idr
);
102 DEFINE_IDR(ehca_cq_idr
);
105 static struct list_head shca_list
; /* list of all registered ehcas */
106 static spinlock_t shca_list_lock
;
108 static struct timer_list poll_eqs_timer
;
110 #ifdef CONFIG_PPC_64K_PAGES
111 static struct kmem_cache
*ctblk_cache
= NULL
;
113 void *ehca_alloc_fw_ctrlblock(gfp_t flags
)
115 void *ret
= kmem_cache_zalloc(ctblk_cache
, flags
);
117 ehca_gen_err("Out of memory for ctblk");
121 void ehca_free_fw_ctrlblock(void *ptr
)
124 kmem_cache_free(ctblk_cache
, ptr
);
129 static int ehca_create_slab_caches(void)
133 ret
= ehca_init_pd_cache();
135 ehca_gen_err("Cannot create PD SLAB cache.");
139 ret
= ehca_init_cq_cache();
141 ehca_gen_err("Cannot create CQ SLAB cache.");
142 goto create_slab_caches2
;
145 ret
= ehca_init_qp_cache();
147 ehca_gen_err("Cannot create QP SLAB cache.");
148 goto create_slab_caches3
;
151 ret
= ehca_init_av_cache();
153 ehca_gen_err("Cannot create AV SLAB cache.");
154 goto create_slab_caches4
;
157 ret
= ehca_init_mrmw_cache();
159 ehca_gen_err("Cannot create MR&MW SLAB cache.");
160 goto create_slab_caches5
;
163 #ifdef CONFIG_PPC_64K_PAGES
164 ctblk_cache
= kmem_cache_create("ehca_cache_ctblk",
165 EHCA_PAGESIZE
, H_CB_ALIGNMENT
,
169 ehca_gen_err("Cannot create ctblk SLAB cache.");
170 ehca_cleanup_mrmw_cache();
171 goto create_slab_caches5
;
177 ehca_cleanup_av_cache();
180 ehca_cleanup_qp_cache();
183 ehca_cleanup_cq_cache();
186 ehca_cleanup_pd_cache();
191 static void ehca_destroy_slab_caches(void)
193 ehca_cleanup_mrmw_cache();
194 ehca_cleanup_av_cache();
195 ehca_cleanup_qp_cache();
196 ehca_cleanup_cq_cache();
197 ehca_cleanup_pd_cache();
198 #ifdef CONFIG_PPC_64K_PAGES
200 kmem_cache_destroy(ctblk_cache
);
204 #define EHCA_HCAAVER EHCA_BMASK_IBM(32,39)
205 #define EHCA_REVID EHCA_BMASK_IBM(40,63)
207 int ehca_sense_attributes(struct ehca_shca
*shca
)
211 struct hipz_query_hca
*rblock
;
213 rblock
= ehca_alloc_fw_ctrlblock(GFP_KERNEL
);
215 ehca_gen_err("Cannot allocate rblock memory.");
219 h_ret
= hipz_h_query_hca(shca
->ipz_hca_handle
, rblock
);
220 if (h_ret
!= H_SUCCESS
) {
221 ehca_gen_err("Cannot query device properties. h_ret=%lx",
227 if (ehca_nr_ports
== 1)
230 shca
->num_ports
= (u8
)rblock
->num_ports
;
232 ehca_gen_dbg(" ... found %x ports", rblock
->num_ports
);
234 if (ehca_hw_level
== 0) {
238 hcaaver
= EHCA_BMASK_GET(EHCA_HCAAVER
, rblock
->hw_ver
);
239 revid
= EHCA_BMASK_GET(EHCA_REVID
, rblock
->hw_ver
);
241 ehca_gen_dbg(" ... hardware version=%x:%x", hcaaver
, revid
);
243 if ((hcaaver
== 1) && (revid
== 0))
245 else if ((hcaaver
== 1) && (revid
== 1))
247 else if ((hcaaver
== 1) && (revid
== 2))
250 ehca_gen_dbg(" ... hardware level=%x", shca
->hw_level
);
252 shca
->sport
[0].rate
= IB_RATE_30_GBPS
;
253 shca
->sport
[1].rate
= IB_RATE_30_GBPS
;
256 ehca_free_fw_ctrlblock(rblock
);
260 static int init_node_guid(struct ehca_shca
*shca
)
263 struct hipz_query_hca
*rblock
;
265 rblock
= ehca_alloc_fw_ctrlblock(GFP_KERNEL
);
267 ehca_err(&shca
->ib_device
, "Can't allocate rblock memory.");
271 if (hipz_h_query_hca(shca
->ipz_hca_handle
, rblock
) != H_SUCCESS
) {
272 ehca_err(&shca
->ib_device
, "Can't query device properties");
274 goto init_node_guid1
;
277 memcpy(&shca
->ib_device
.node_guid
, &rblock
->node_guid
, sizeof(u64
));
280 ehca_free_fw_ctrlblock(rblock
);
284 int ehca_init_device(struct ehca_shca
*shca
)
288 ret
= init_node_guid(shca
);
292 strlcpy(shca
->ib_device
.name
, "ehca%d", IB_DEVICE_NAME_MAX
);
293 shca
->ib_device
.owner
= THIS_MODULE
;
295 shca
->ib_device
.uverbs_abi_ver
= 6;
296 shca
->ib_device
.uverbs_cmd_mask
=
297 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT
) |
298 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE
) |
299 (1ull << IB_USER_VERBS_CMD_QUERY_PORT
) |
300 (1ull << IB_USER_VERBS_CMD_ALLOC_PD
) |
301 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD
) |
302 (1ull << IB_USER_VERBS_CMD_REG_MR
) |
303 (1ull << IB_USER_VERBS_CMD_DEREG_MR
) |
304 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL
) |
305 (1ull << IB_USER_VERBS_CMD_CREATE_CQ
) |
306 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ
) |
307 (1ull << IB_USER_VERBS_CMD_CREATE_QP
) |
308 (1ull << IB_USER_VERBS_CMD_MODIFY_QP
) |
309 (1ull << IB_USER_VERBS_CMD_QUERY_QP
) |
310 (1ull << IB_USER_VERBS_CMD_DESTROY_QP
) |
311 (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST
) |
312 (1ull << IB_USER_VERBS_CMD_DETACH_MCAST
);
314 shca
->ib_device
.node_type
= RDMA_NODE_IB_CA
;
315 shca
->ib_device
.phys_port_cnt
= shca
->num_ports
;
316 shca
->ib_device
.dma_device
= &shca
->ibmebus_dev
->ofdev
.dev
;
317 shca
->ib_device
.query_device
= ehca_query_device
;
318 shca
->ib_device
.query_port
= ehca_query_port
;
319 shca
->ib_device
.query_gid
= ehca_query_gid
;
320 shca
->ib_device
.query_pkey
= ehca_query_pkey
;
321 /* shca->in_device.modify_device = ehca_modify_device */
322 shca
->ib_device
.modify_port
= ehca_modify_port
;
323 shca
->ib_device
.alloc_ucontext
= ehca_alloc_ucontext
;
324 shca
->ib_device
.dealloc_ucontext
= ehca_dealloc_ucontext
;
325 shca
->ib_device
.alloc_pd
= ehca_alloc_pd
;
326 shca
->ib_device
.dealloc_pd
= ehca_dealloc_pd
;
327 shca
->ib_device
.create_ah
= ehca_create_ah
;
328 /* shca->ib_device.modify_ah = ehca_modify_ah; */
329 shca
->ib_device
.query_ah
= ehca_query_ah
;
330 shca
->ib_device
.destroy_ah
= ehca_destroy_ah
;
331 shca
->ib_device
.create_qp
= ehca_create_qp
;
332 shca
->ib_device
.modify_qp
= ehca_modify_qp
;
333 shca
->ib_device
.query_qp
= ehca_query_qp
;
334 shca
->ib_device
.destroy_qp
= ehca_destroy_qp
;
335 shca
->ib_device
.post_send
= ehca_post_send
;
336 shca
->ib_device
.post_recv
= ehca_post_recv
;
337 shca
->ib_device
.create_cq
= ehca_create_cq
;
338 shca
->ib_device
.destroy_cq
= ehca_destroy_cq
;
339 shca
->ib_device
.resize_cq
= ehca_resize_cq
;
340 shca
->ib_device
.poll_cq
= ehca_poll_cq
;
341 /* shca->ib_device.peek_cq = ehca_peek_cq; */
342 shca
->ib_device
.req_notify_cq
= ehca_req_notify_cq
;
343 /* shca->ib_device.req_ncomp_notif = ehca_req_ncomp_notif; */
344 shca
->ib_device
.get_dma_mr
= ehca_get_dma_mr
;
345 shca
->ib_device
.reg_phys_mr
= ehca_reg_phys_mr
;
346 shca
->ib_device
.reg_user_mr
= ehca_reg_user_mr
;
347 shca
->ib_device
.query_mr
= ehca_query_mr
;
348 shca
->ib_device
.dereg_mr
= ehca_dereg_mr
;
349 shca
->ib_device
.rereg_phys_mr
= ehca_rereg_phys_mr
;
350 shca
->ib_device
.alloc_mw
= ehca_alloc_mw
;
351 shca
->ib_device
.bind_mw
= ehca_bind_mw
;
352 shca
->ib_device
.dealloc_mw
= ehca_dealloc_mw
;
353 shca
->ib_device
.alloc_fmr
= ehca_alloc_fmr
;
354 shca
->ib_device
.map_phys_fmr
= ehca_map_phys_fmr
;
355 shca
->ib_device
.unmap_fmr
= ehca_unmap_fmr
;
356 shca
->ib_device
.dealloc_fmr
= ehca_dealloc_fmr
;
357 shca
->ib_device
.attach_mcast
= ehca_attach_mcast
;
358 shca
->ib_device
.detach_mcast
= ehca_detach_mcast
;
359 /* shca->ib_device.process_mad = ehca_process_mad; */
360 shca
->ib_device
.mmap
= ehca_mmap
;
365 static int ehca_create_aqp1(struct ehca_shca
*shca
, u32 port
)
367 struct ehca_sport
*sport
= &shca
->sport
[port
- 1];
370 struct ib_qp_init_attr qp_init_attr
;
373 if (sport
->ibcq_aqp1
) {
374 ehca_err(&shca
->ib_device
, "AQP1 CQ is already created.");
378 ibcq
= ib_create_cq(&shca
->ib_device
, NULL
, NULL
, (void*)(-1), 10);
380 ehca_err(&shca
->ib_device
, "Cannot create AQP1 CQ.");
381 return PTR_ERR(ibcq
);
383 sport
->ibcq_aqp1
= ibcq
;
385 if (sport
->ibqp_aqp1
) {
386 ehca_err(&shca
->ib_device
, "AQP1 QP is already created.");
391 memset(&qp_init_attr
, 0, sizeof(struct ib_qp_init_attr
));
392 qp_init_attr
.send_cq
= ibcq
;
393 qp_init_attr
.recv_cq
= ibcq
;
394 qp_init_attr
.sq_sig_type
= IB_SIGNAL_ALL_WR
;
395 qp_init_attr
.cap
.max_send_wr
= 100;
396 qp_init_attr
.cap
.max_recv_wr
= 100;
397 qp_init_attr
.cap
.max_send_sge
= 2;
398 qp_init_attr
.cap
.max_recv_sge
= 1;
399 qp_init_attr
.qp_type
= IB_QPT_GSI
;
400 qp_init_attr
.port_num
= port
;
401 qp_init_attr
.qp_context
= NULL
;
402 qp_init_attr
.event_handler
= NULL
;
403 qp_init_attr
.srq
= NULL
;
405 ibqp
= ib_create_qp(&shca
->pd
->ib_pd
, &qp_init_attr
);
407 ehca_err(&shca
->ib_device
, "Cannot create AQP1 QP.");
411 sport
->ibqp_aqp1
= ibqp
;
416 ib_destroy_cq(sport
->ibcq_aqp1
);
420 static int ehca_destroy_aqp1(struct ehca_sport
*sport
)
424 ret
= ib_destroy_qp(sport
->ibqp_aqp1
);
426 ehca_gen_err("Cannot destroy AQP1 QP. ret=%x", ret
);
430 ret
= ib_destroy_cq(sport
->ibcq_aqp1
);
432 ehca_gen_err("Cannot destroy AQP1 CQ. ret=%x", ret
);
437 static ssize_t
ehca_show_debug_level(struct device_driver
*ddp
, char *buf
)
439 return snprintf(buf
, PAGE_SIZE
, "%d\n",
443 static ssize_t
ehca_store_debug_level(struct device_driver
*ddp
,
444 const char *buf
, size_t count
)
446 int value
= (*buf
) - '0';
447 if (value
>= 0 && value
<= 9)
448 ehca_debug_level
= value
;
452 DRIVER_ATTR(debug_level
, S_IRUSR
| S_IWUSR
,
453 ehca_show_debug_level
, ehca_store_debug_level
);
455 void ehca_create_driver_sysfs(struct ibmebus_driver
*drv
)
457 driver_create_file(&drv
->driver
, &driver_attr_debug_level
);
460 void ehca_remove_driver_sysfs(struct ibmebus_driver
*drv
)
462 driver_remove_file(&drv
->driver
, &driver_attr_debug_level
);
465 #define EHCA_RESOURCE_ATTR(name) \
466 static ssize_t ehca_show_##name(struct device *dev, \
467 struct device_attribute *attr, \
470 struct ehca_shca *shca; \
471 struct hipz_query_hca *rblock; \
474 shca = dev->driver_data; \
476 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL); \
478 dev_err(dev, "Can't allocate rblock memory."); \
482 if (hipz_h_query_hca(shca->ipz_hca_handle, rblock) != H_SUCCESS) { \
483 dev_err(dev, "Can't query device properties"); \
484 ehca_free_fw_ctrlblock(rblock); \
488 data = rblock->name; \
489 ehca_free_fw_ctrlblock(rblock); \
491 if ((strcmp(#name, "num_ports") == 0) && (ehca_nr_ports == 1)) \
492 return snprintf(buf, 256, "1\n"); \
494 return snprintf(buf, 256, "%d\n", data); \
497 static DEVICE_ATTR(name, S_IRUGO, ehca_show_##name, NULL);
499 EHCA_RESOURCE_ATTR(num_ports
);
500 EHCA_RESOURCE_ATTR(hw_ver
);
501 EHCA_RESOURCE_ATTR(max_eq
);
502 EHCA_RESOURCE_ATTR(cur_eq
);
503 EHCA_RESOURCE_ATTR(max_cq
);
504 EHCA_RESOURCE_ATTR(cur_cq
);
505 EHCA_RESOURCE_ATTR(max_qp
);
506 EHCA_RESOURCE_ATTR(cur_qp
);
507 EHCA_RESOURCE_ATTR(max_mr
);
508 EHCA_RESOURCE_ATTR(cur_mr
);
509 EHCA_RESOURCE_ATTR(max_mw
);
510 EHCA_RESOURCE_ATTR(cur_mw
);
511 EHCA_RESOURCE_ATTR(max_pd
);
512 EHCA_RESOURCE_ATTR(max_ah
);
514 static ssize_t
ehca_show_adapter_handle(struct device
*dev
,
515 struct device_attribute
*attr
,
518 struct ehca_shca
*shca
= dev
->driver_data
;
520 return sprintf(buf
, "%lx\n", shca
->ipz_hca_handle
.handle
);
523 static DEVICE_ATTR(adapter_handle
, S_IRUGO
, ehca_show_adapter_handle
, NULL
);
526 void ehca_create_device_sysfs(struct ibmebus_dev
*dev
)
528 device_create_file(&dev
->ofdev
.dev
, &dev_attr_adapter_handle
);
529 device_create_file(&dev
->ofdev
.dev
, &dev_attr_num_ports
);
530 device_create_file(&dev
->ofdev
.dev
, &dev_attr_hw_ver
);
531 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_eq
);
532 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_eq
);
533 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_cq
);
534 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_cq
);
535 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_qp
);
536 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_qp
);
537 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_mr
);
538 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_mr
);
539 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_mw
);
540 device_create_file(&dev
->ofdev
.dev
, &dev_attr_cur_mw
);
541 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_pd
);
542 device_create_file(&dev
->ofdev
.dev
, &dev_attr_max_ah
);
545 void ehca_remove_device_sysfs(struct ibmebus_dev
*dev
)
547 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_adapter_handle
);
548 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_num_ports
);
549 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_hw_ver
);
550 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_eq
);
551 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_eq
);
552 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_cq
);
553 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_cq
);
554 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_qp
);
555 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_qp
);
556 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_mr
);
557 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_mr
);
558 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_mw
);
559 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_cur_mw
);
560 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_pd
);
561 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_max_ah
);
564 static int __devinit
ehca_probe(struct ibmebus_dev
*dev
,
565 const struct of_device_id
*id
)
567 struct ehca_shca
*shca
;
572 handle
= of_get_property(dev
->ofdev
.node
, "ibm,hca-handle", NULL
);
574 ehca_gen_err("Cannot get eHCA handle for adapter: %s.",
575 dev
->ofdev
.node
->full_name
);
580 ehca_gen_err("Wrong eHCA handle for adapter: %s.",
581 dev
->ofdev
.node
->full_name
);
585 shca
= (struct ehca_shca
*)ib_alloc_device(sizeof(*shca
));
587 ehca_gen_err("Cannot allocate shca memory.");
590 mutex_init(&shca
->modify_mutex
);
592 shca
->ibmebus_dev
= dev
;
593 shca
->ipz_hca_handle
.handle
= *handle
;
594 dev
->ofdev
.dev
.driver_data
= shca
;
596 ret
= ehca_sense_attributes(shca
);
598 ehca_gen_err("Cannot sense eHCA attributes.");
602 ret
= ehca_init_device(shca
);
604 ehca_gen_err("Cannot init ehca device struct");
608 /* create event queues */
609 ret
= ehca_create_eq(shca
, &shca
->eq
, EHCA_EQ
, 2048);
611 ehca_err(&shca
->ib_device
, "Cannot create EQ.");
615 ret
= ehca_create_eq(shca
, &shca
->neq
, EHCA_NEQ
, 513);
617 ehca_err(&shca
->ib_device
, "Cannot create NEQ.");
621 /* create internal protection domain */
622 ibpd
= ehca_alloc_pd(&shca
->ib_device
, (void*)(-1), NULL
);
624 ehca_err(&shca
->ib_device
, "Cannot create internal PD.");
629 shca
->pd
= container_of(ibpd
, struct ehca_pd
, ib_pd
);
630 shca
->pd
->ib_pd
.device
= &shca
->ib_device
;
632 /* create internal max MR */
633 ret
= ehca_reg_internal_maxmr(shca
, shca
->pd
, &shca
->maxmr
);
636 ehca_err(&shca
->ib_device
, "Cannot create internal MR ret=%x",
641 ret
= ib_register_device(&shca
->ib_device
);
643 ehca_err(&shca
->ib_device
,
644 "ib_register_device() failed ret=%x", ret
);
648 /* create AQP1 for port 1 */
649 if (ehca_open_aqp1
== 1) {
650 shca
->sport
[0].port_state
= IB_PORT_DOWN
;
651 ret
= ehca_create_aqp1(shca
, 1);
653 ehca_err(&shca
->ib_device
,
654 "Cannot create AQP1 for port 1.");
659 /* create AQP1 for port 2 */
660 if ((ehca_open_aqp1
== 1) && (shca
->num_ports
== 2)) {
661 shca
->sport
[1].port_state
= IB_PORT_DOWN
;
662 ret
= ehca_create_aqp1(shca
, 2);
664 ehca_err(&shca
->ib_device
,
665 "Cannot create AQP1 for port 2.");
670 ehca_create_device_sysfs(dev
);
672 spin_lock(&shca_list_lock
);
673 list_add(&shca
->shca_list
, &shca_list
);
674 spin_unlock(&shca_list_lock
);
679 ret
= ehca_destroy_aqp1(&shca
->sport
[0]);
681 ehca_err(&shca
->ib_device
,
682 "Cannot destroy AQP1 for port 1. ret=%x", ret
);
685 ib_unregister_device(&shca
->ib_device
);
688 ret
= ehca_dereg_internal_maxmr(shca
);
690 ehca_err(&shca
->ib_device
,
691 "Cannot destroy internal MR. ret=%x", ret
);
694 ret
= ehca_dealloc_pd(&shca
->pd
->ib_pd
);
696 ehca_err(&shca
->ib_device
,
697 "Cannot destroy internal PD. ret=%x", ret
);
700 ret
= ehca_destroy_eq(shca
, &shca
->neq
);
702 ehca_err(&shca
->ib_device
,
703 "Cannot destroy NEQ. ret=%x", ret
);
706 ret
= ehca_destroy_eq(shca
, &shca
->eq
);
708 ehca_err(&shca
->ib_device
,
709 "Cannot destroy EQ. ret=%x", ret
);
712 ib_dealloc_device(&shca
->ib_device
);
717 static int __devexit
ehca_remove(struct ibmebus_dev
*dev
)
719 struct ehca_shca
*shca
= dev
->ofdev
.dev
.driver_data
;
722 ehca_remove_device_sysfs(dev
);
724 if (ehca_open_aqp1
== 1) {
726 for (i
= 0; i
< shca
->num_ports
; i
++) {
727 ret
= ehca_destroy_aqp1(&shca
->sport
[i
]);
729 ehca_err(&shca
->ib_device
,
730 "Cannot destroy AQP1 for port %x "
735 ib_unregister_device(&shca
->ib_device
);
737 ret
= ehca_dereg_internal_maxmr(shca
);
739 ehca_err(&shca
->ib_device
,
740 "Cannot destroy internal MR. ret=%x", ret
);
742 ret
= ehca_dealloc_pd(&shca
->pd
->ib_pd
);
744 ehca_err(&shca
->ib_device
,
745 "Cannot destroy internal PD. ret=%x", ret
);
747 ret
= ehca_destroy_eq(shca
, &shca
->eq
);
749 ehca_err(&shca
->ib_device
, "Cannot destroy EQ. ret=%x", ret
);
751 ret
= ehca_destroy_eq(shca
, &shca
->neq
);
753 ehca_err(&shca
->ib_device
, "Canot destroy NEQ. ret=%x", ret
);
755 ib_dealloc_device(&shca
->ib_device
);
757 spin_lock(&shca_list_lock
);
758 list_del(&shca
->shca_list
);
759 spin_unlock(&shca_list_lock
);
764 static struct of_device_id ehca_device_table
[] =
768 .compatible
= "IBM,lhca",
773 static struct ibmebus_driver ehca_driver
= {
775 .id_table
= ehca_device_table
,
777 .remove
= ehca_remove
,
780 void ehca_poll_eqs(unsigned long data
)
782 struct ehca_shca
*shca
;
784 spin_lock(&shca_list_lock
);
785 list_for_each_entry(shca
, &shca_list
, shca_list
) {
786 if (shca
->eq
.is_initialized
) {
787 /* call deadman proc only if eq ptr does not change */
788 struct ehca_eq
*eq
= &shca
->eq
;
790 volatile u64 q_ofs
, q_ofs2
;
792 spin_lock_irqsave(&eq
->spinlock
, flags
);
793 q_ofs
= eq
->ipz_queue
.current_q_offset
;
794 spin_unlock_irqrestore(&eq
->spinlock
, flags
);
796 spin_lock_irqsave(&eq
->spinlock
, flags
);
797 q_ofs2
= eq
->ipz_queue
.current_q_offset
;
798 spin_unlock_irqrestore(&eq
->spinlock
, flags
);
800 } while (q_ofs
== q_ofs2
&& max
> 0);
802 ehca_process_eq(shca
, 0);
805 mod_timer(&poll_eqs_timer
, jiffies
+ HZ
);
806 spin_unlock(&shca_list_lock
);
809 int __init
ehca_module_init(void)
813 printk(KERN_INFO
"eHCA Infiniband Device Driver "
814 "(Rel.: SVNEHCA_0022)\n");
815 idr_init(&ehca_qp_idr
);
816 idr_init(&ehca_cq_idr
);
817 spin_lock_init(&ehca_qp_idr_lock
);
818 spin_lock_init(&ehca_cq_idr_lock
);
820 INIT_LIST_HEAD(&shca_list
);
821 spin_lock_init(&shca_list_lock
);
823 if ((ret
= ehca_create_comp_pool())) {
824 ehca_gen_err("Cannot create comp pool.");
828 if ((ret
= ehca_create_slab_caches())) {
829 ehca_gen_err("Cannot create SLAB caches");
834 if ((ret
= ibmebus_register_driver(&ehca_driver
))) {
835 ehca_gen_err("Cannot register eHCA device driver");
840 ehca_create_driver_sysfs(&ehca_driver
);
842 if (ehca_poll_all_eqs
!= 1) {
843 ehca_gen_err("WARNING!!!");
844 ehca_gen_err("It is possible to lose interrupts.");
846 init_timer(&poll_eqs_timer
);
847 poll_eqs_timer
.function
= ehca_poll_eqs
;
848 poll_eqs_timer
.expires
= jiffies
+ HZ
;
849 add_timer(&poll_eqs_timer
);
855 ehca_destroy_slab_caches();
858 ehca_destroy_comp_pool();
862 void __exit
ehca_module_exit(void)
864 if (ehca_poll_all_eqs
== 1)
865 del_timer_sync(&poll_eqs_timer
);
867 ehca_remove_driver_sysfs(&ehca_driver
);
868 ibmebus_unregister_driver(&ehca_driver
);
870 ehca_destroy_slab_caches();
872 ehca_destroy_comp_pool();
874 idr_destroy(&ehca_cq_idr
);
875 idr_destroy(&ehca_qp_idr
);
878 module_init(ehca_module_init
);
879 module_exit(ehca_module_exit
);