1/* 2 * IBM eServer eHCA Infiniband device driver for Linux on POWER 3 * 4 * module start stop, hca detection 5 * 6 * Authors: Heiko J Schick <schickhj@de.ibm.com> 7 * Hoang-Nam Nguyen <hnguyen@de.ibm.com> 8 * Joachim Fenkes <fenkes@de.ibm.com> 9 * 10 * Copyright (c) 2005 IBM Corporation 11 * 12 * All rights reserved. 13 * 14 * This source code is distributed under a dual license of GPL v2.0 and OpenIB 15 * BSD. 16 * 17 * OpenIB BSD License 18 * 19 * Redistribution and use in source and binary forms, with or without 20 * modification, are permitted provided that the following conditions are met: 21 * 22 * Redistributions of source code must retain the above copyright notice, this 23 * list of conditions and the following disclaimer. 24 * 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. 29 * 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. 41 */ 42 43#ifdef CONFIG_PPC_64K_PAGES 44#include <linux/slab.h> 45#endif 46#include "ehca_classes.h" 47#include "ehca_iverbs.h" 48#include "ehca_mrmw.h" 49#include "ehca_tools.h" 50#include "hcp_if.h" 51 52MODULE_LICENSE("Dual BSD/GPL"); 53MODULE_AUTHOR("Christoph Raisch <raisch@de.ibm.com>"); 54MODULE_DESCRIPTION("IBM eServer HCA InfiniBand Device Driver"); 55MODULE_VERSION("SVNEHCA_0023"); 56 57int ehca_open_aqp1 = 0; 58int ehca_debug_level = 0; 59int ehca_hw_level = 0; 60int ehca_nr_ports = 2; 61int ehca_use_hp_mr = 0; 62int ehca_port_act_time = 30; 63int ehca_poll_all_eqs = 1; 64int ehca_static_rate = -1; 65int ehca_scaling_code = 0; 66 67module_param_named(open_aqp1, ehca_open_aqp1, int, 0); 68module_param_named(debug_level, ehca_debug_level, int, 0); 69module_param_named(hw_level, ehca_hw_level, int, 0); 70module_param_named(nr_ports, ehca_nr_ports, int, 0); 71module_param_named(use_hp_mr, ehca_use_hp_mr, int, 0); 72module_param_named(port_act_time, ehca_port_act_time, int, 0); 73module_param_named(poll_all_eqs, ehca_poll_all_eqs, int, 0); 74module_param_named(static_rate, ehca_static_rate, int, 0); 75module_param_named(scaling_code, ehca_scaling_code, int, 0); 76 77MODULE_PARM_DESC(open_aqp1, 78 "AQP1 on startup (0: no (default), 1: yes)"); 79MODULE_PARM_DESC(debug_level, 80 "debug level" 81 " (0: no debug traces (default), 1: with debug traces)"); 82MODULE_PARM_DESC(hw_level, 83 "hardware level" 84 " (0: autosensing (default), 1: v. 0.20, 2: v. 0.21)"); 85MODULE_PARM_DESC(nr_ports, 86 "number of connected ports (default: 2)"); 87MODULE_PARM_DESC(use_hp_mr, 88 "high performance MRs (0: no (default), 1: yes)"); 89MODULE_PARM_DESC(port_act_time, 90 "time to wait for port activation (default: 30 sec)"); 91MODULE_PARM_DESC(poll_all_eqs, 92 "polls all event queues periodically" 93 " (0: no, 1: yes (default))"); 94MODULE_PARM_DESC(static_rate, 95 "set permanent static rate (default: disabled)"); 96MODULE_PARM_DESC(scaling_code, 97 "set scaling code (0: disabled, 1: enabled/default)"); 98 99spinlock_t ehca_qp_idr_lock; 100spinlock_t ehca_cq_idr_lock; 101spinlock_t hcall_lock; 102DEFINE_IDR(ehca_qp_idr); 103DEFINE_IDR(ehca_cq_idr); 104 105 106static struct list_head shca_list; /* list of all registered ehcas */ 107static spinlock_t shca_list_lock; 108 109static struct timer_list poll_eqs_timer; 110 111#ifdef CONFIG_PPC_64K_PAGES 112static struct kmem_cache *ctblk_cache = NULL; 113 114void *ehca_alloc_fw_ctrlblock(gfp_t flags) 115{ 116 void *ret = kmem_cache_zalloc(ctblk_cache, flags); 117 if (!ret) 118 ehca_gen_err("Out of memory for ctblk"); 119 return ret; 120} 121 122void ehca_free_fw_ctrlblock(void *ptr) 123{ 124 if (ptr) 125 kmem_cache_free(ctblk_cache, ptr); 126 127} 128#endif 129 130static int ehca_create_slab_caches(void) 131{ 132 int ret; 133 134 ret = ehca_init_pd_cache(); 135 if (ret) { 136 ehca_gen_err("Cannot create PD SLAB cache."); 137 return ret; 138 } 139 140 ret = ehca_init_cq_cache(); 141 if (ret) { 142 ehca_gen_err("Cannot create CQ SLAB cache."); 143 goto create_slab_caches2; 144 } 145 146 ret = ehca_init_qp_cache(); 147 if (ret) { 148 ehca_gen_err("Cannot create QP SLAB cache."); 149 goto create_slab_caches3; 150 } 151 152 ret = ehca_init_av_cache(); 153 if (ret) { 154 ehca_gen_err("Cannot create AV SLAB cache."); 155 goto create_slab_caches4; 156 } 157 158 ret = ehca_init_mrmw_cache(); 159 if (ret) { 160 ehca_gen_err("Cannot create MR&MW SLAB cache."); 161 goto create_slab_caches5; 162 } 163 164#ifdef CONFIG_PPC_64K_PAGES 165 ctblk_cache = kmem_cache_create("ehca_cache_ctblk", 166 EHCA_PAGESIZE, H_CB_ALIGNMENT, 167 SLAB_HWCACHE_ALIGN, 168 NULL, NULL); 169 if (!ctblk_cache) { 170 ehca_gen_err("Cannot create ctblk SLAB cache."); 171 ehca_cleanup_mrmw_cache(); 172 goto create_slab_caches5; 173 } 174#endif 175 return 0; 176 177create_slab_caches5: 178 ehca_cleanup_av_cache(); 179 180create_slab_caches4: 181 ehca_cleanup_qp_cache(); 182 183create_slab_caches3: 184 ehca_cleanup_cq_cache(); 185 186create_slab_caches2: 187 ehca_cleanup_pd_cache(); 188 189 return ret; 190} 191 192static void ehca_destroy_slab_caches(void) 193{ 194 ehca_cleanup_mrmw_cache(); 195 ehca_cleanup_av_cache(); 196 ehca_cleanup_qp_cache(); 197 ehca_cleanup_cq_cache(); 198 ehca_cleanup_pd_cache(); 199#ifdef CONFIG_PPC_64K_PAGES 200 if (ctblk_cache) 201 kmem_cache_destroy(ctblk_cache); 202#endif 203} 204 205#define EHCA_HCAAVER EHCA_BMASK_IBM(32,39) 206#define EHCA_REVID EHCA_BMASK_IBM(40,63) 207 208int ehca_sense_attributes(struct ehca_shca *shca) 209{ 210 int ret = 0; 211 u64 h_ret; 212 struct hipz_query_hca *rblock; 213 214 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL); 215 if (!rblock) { 216 ehca_gen_err("Cannot allocate rblock memory."); 217 return -ENOMEM; 218 } 219 220 h_ret = hipz_h_query_hca(shca->ipz_hca_handle, rblock); 221 if (h_ret != H_SUCCESS) { 222 ehca_gen_err("Cannot query device properties. h_ret=%lx", 223 h_ret); 224 ret = -EPERM; 225 goto num_ports1; 226 } 227 228 if (ehca_nr_ports == 1) 229 shca->num_ports = 1; 230 else 231 shca->num_ports = (u8)rblock->num_ports; 232 233 ehca_gen_dbg(" ... found %x ports", rblock->num_ports); 234 235 if (ehca_hw_level == 0) { 236 u32 hcaaver; 237 u32 revid; 238 239 hcaaver = EHCA_BMASK_GET(EHCA_HCAAVER, rblock->hw_ver); 240 revid = EHCA_BMASK_GET(EHCA_REVID, rblock->hw_ver); 241 242 ehca_gen_dbg(" ... hardware version=%x:%x", hcaaver, revid); 243 244 if ((hcaaver == 1) && (revid == 0)) 245 shca->hw_level = 0; 246 else if ((hcaaver == 1) && (revid == 1)) 247 shca->hw_level = 1; 248 else if ((hcaaver == 1) && (revid == 2)) 249 shca->hw_level = 2; 250 } 251 ehca_gen_dbg(" ... hardware level=%x", shca->hw_level); 252 253 shca->sport[0].rate = IB_RATE_30_GBPS; 254 shca->sport[1].rate = IB_RATE_30_GBPS; 255 256num_ports1: 257 ehca_free_fw_ctrlblock(rblock); 258 return ret; 259} 260 261static int init_node_guid(struct ehca_shca *shca) 262{ 263 int ret = 0; 264 struct hipz_query_hca *rblock; 265 266 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL); 267 if (!rblock) { 268 ehca_err(&shca->ib_device, "Can't allocate rblock memory."); 269 return -ENOMEM; 270 } 271 272 if (hipz_h_query_hca(shca->ipz_hca_handle, rblock) != H_SUCCESS) { 273 ehca_err(&shca->ib_device, "Can't query device properties"); 274 ret = -EINVAL; 275 goto init_node_guid1; 276 } 277 278 memcpy(&shca->ib_device.node_guid, &rblock->node_guid, sizeof(u64)); 279 280init_node_guid1: 281 ehca_free_fw_ctrlblock(rblock); 282 return ret; 283} 284 285int ehca_init_device(struct ehca_shca *shca) 286{ 287 int ret; 288 289 ret = init_node_guid(shca); 290 if (ret) 291 return ret; 292 293 strlcpy(shca->ib_device.name, "ehca%d", IB_DEVICE_NAME_MAX); 294 shca->ib_device.owner = THIS_MODULE; 295 296 shca->ib_device.uverbs_abi_ver = 6; 297 shca->ib_device.uverbs_cmd_mask = 298 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT) | 299 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE) | 300 (1ull << IB_USER_VERBS_CMD_QUERY_PORT) | 301 (1ull << IB_USER_VERBS_CMD_ALLOC_PD) | 302 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD) | 303 (1ull << IB_USER_VERBS_CMD_REG_MR) | 304 (1ull << IB_USER_VERBS_CMD_DEREG_MR) | 305 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) | 306 (1ull << IB_USER_VERBS_CMD_CREATE_CQ) | 307 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ) | 308 (1ull << IB_USER_VERBS_CMD_CREATE_QP) | 309 (1ull << IB_USER_VERBS_CMD_MODIFY_QP) | 310 (1ull << IB_USER_VERBS_CMD_QUERY_QP) | 311 (1ull << IB_USER_VERBS_CMD_DESTROY_QP) | 312 (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST) | 313 (1ull << IB_USER_VERBS_CMD_DETACH_MCAST); 314 315 shca->ib_device.node_type = RDMA_NODE_IB_CA; 316 shca->ib_device.phys_port_cnt = shca->num_ports; 317 shca->ib_device.num_comp_vectors = 1; 318 shca->ib_device.dma_device = &shca->ibmebus_dev->ofdev.dev; 319 shca->ib_device.query_device = ehca_query_device; 320 shca->ib_device.query_port = ehca_query_port; 321 shca->ib_device.query_gid = ehca_query_gid; 322 shca->ib_device.query_pkey = ehca_query_pkey; 323 /* shca->in_device.modify_device = ehca_modify_device */ 324 shca->ib_device.modify_port = ehca_modify_port; 325 shca->ib_device.alloc_ucontext = ehca_alloc_ucontext; 326 shca->ib_device.dealloc_ucontext = ehca_dealloc_ucontext; 327 shca->ib_device.alloc_pd = ehca_alloc_pd; 328 shca->ib_device.dealloc_pd = ehca_dealloc_pd; 329 shca->ib_device.create_ah = ehca_create_ah; 330 /* shca->ib_device.modify_ah = ehca_modify_ah; */ 331 shca->ib_device.query_ah = ehca_query_ah; 332 shca->ib_device.destroy_ah = ehca_destroy_ah; 333 shca->ib_device.create_qp = ehca_create_qp; 334 shca->ib_device.modify_qp = ehca_modify_qp; 335 shca->ib_device.query_qp = ehca_query_qp; 336 shca->ib_device.destroy_qp = ehca_destroy_qp; 337 shca->ib_device.post_send = ehca_post_send; 338 shca->ib_device.post_recv = ehca_post_recv; 339 shca->ib_device.create_cq = ehca_create_cq; 340 shca->ib_device.destroy_cq = ehca_destroy_cq; 341 shca->ib_device.resize_cq = ehca_resize_cq; 342 shca->ib_device.poll_cq = ehca_poll_cq; 343 /* shca->ib_device.peek_cq = ehca_peek_cq; */ 344 shca->ib_device.req_notify_cq = ehca_req_notify_cq; 345 /* shca->ib_device.req_ncomp_notif = ehca_req_ncomp_notif; */ 346 shca->ib_device.get_dma_mr = ehca_get_dma_mr; 347 shca->ib_device.reg_phys_mr = ehca_reg_phys_mr; 348 shca->ib_device.reg_user_mr = ehca_reg_user_mr; 349 shca->ib_device.query_mr = ehca_query_mr; 350 shca->ib_device.dereg_mr = ehca_dereg_mr; 351 shca->ib_device.rereg_phys_mr = ehca_rereg_phys_mr; 352 shca->ib_device.alloc_mw = ehca_alloc_mw; 353 shca->ib_device.bind_mw = ehca_bind_mw; 354 shca->ib_device.dealloc_mw = ehca_dealloc_mw; 355 shca->ib_device.alloc_fmr = ehca_alloc_fmr; 356 shca->ib_device.map_phys_fmr = ehca_map_phys_fmr; 357 shca->ib_device.unmap_fmr = ehca_unmap_fmr; 358 shca->ib_device.dealloc_fmr = ehca_dealloc_fmr; 359 shca->ib_device.attach_mcast = ehca_attach_mcast; 360 shca->ib_device.detach_mcast = ehca_detach_mcast; 361 /* shca->ib_device.process_mad = ehca_process_mad; */ 362 shca->ib_device.mmap = ehca_mmap; 363 364 return ret; 365} 366 367static int ehca_create_aqp1(struct ehca_shca *shca, u32 port) 368{ 369 struct ehca_sport *sport = &shca->sport[port - 1]; 370 struct ib_cq *ibcq; 371 struct ib_qp *ibqp; 372 struct ib_qp_init_attr qp_init_attr; 373 int ret; 374 375 if (sport->ibcq_aqp1) { 376 ehca_err(&shca->ib_device, "AQP1 CQ is already created."); 377 return -EPERM; 378 } 379 380 ibcq = ib_create_cq(&shca->ib_device, NULL, NULL, (void*)(-1), 10, 0); 381 if (IS_ERR(ibcq)) { 382 ehca_err(&shca->ib_device, "Cannot create AQP1 CQ."); 383 return PTR_ERR(ibcq); 384 } 385 sport->ibcq_aqp1 = ibcq; 386 387 if (sport->ibqp_aqp1) { 388 ehca_err(&shca->ib_device, "AQP1 QP is already created."); 389 ret = -EPERM; 390 goto create_aqp1; 391 } 392 393 memset(&qp_init_attr, 0, sizeof(struct ib_qp_init_attr)); 394 qp_init_attr.send_cq = ibcq; 395 qp_init_attr.recv_cq = ibcq; 396 qp_init_attr.sq_sig_type = IB_SIGNAL_ALL_WR; 397 qp_init_attr.cap.max_send_wr = 100; 398 qp_init_attr.cap.max_recv_wr = 100; 399 qp_init_attr.cap.max_send_sge = 2; 400 qp_init_attr.cap.max_recv_sge = 1; 401 qp_init_attr.qp_type = IB_QPT_GSI; 402 qp_init_attr.port_num = port; 403 qp_init_attr.qp_context = NULL; 404 qp_init_attr.event_handler = NULL; 405 qp_init_attr.srq = NULL; 406 407 ibqp = ib_create_qp(&shca->pd->ib_pd, &qp_init_attr); 408 if (IS_ERR(ibqp)) { 409 ehca_err(&shca->ib_device, "Cannot create AQP1 QP."); 410 ret = PTR_ERR(ibqp); 411 goto create_aqp1; 412 } 413 sport->ibqp_aqp1 = ibqp; 414 415 return 0; 416 417create_aqp1: 418 ib_destroy_cq(sport->ibcq_aqp1); 419 return ret; 420} 421 422static int ehca_destroy_aqp1(struct ehca_sport *sport) 423{ 424 int ret; 425 426 ret = ib_destroy_qp(sport->ibqp_aqp1); 427 if (ret) { 428 ehca_gen_err("Cannot destroy AQP1 QP. ret=%x", ret); 429 return ret; 430 } 431 432 ret = ib_destroy_cq(sport->ibcq_aqp1); 433 if (ret) 434 ehca_gen_err("Cannot destroy AQP1 CQ. ret=%x", ret); 435 436 return ret; 437} 438 439static ssize_t ehca_show_debug_level(struct device_driver *ddp, char *buf) 440{ 441 return snprintf(buf, PAGE_SIZE, "%d\n", 442 ehca_debug_level); 443} 444 445static ssize_t ehca_store_debug_level(struct device_driver *ddp, 446 const char *buf, size_t count) 447{ 448 int value = (*buf) - '0'; 449 if (value >= 0 && value <= 9) 450 ehca_debug_level = value; 451 return 1; 452} 453 454DRIVER_ATTR(debug_level, S_IRUSR | S_IWUSR, 455 ehca_show_debug_level, ehca_store_debug_level); 456 457static struct attribute *ehca_drv_attrs[] = { 458 &driver_attr_debug_level.attr, 459 NULL 460}; 461 462static struct attribute_group ehca_drv_attr_grp = { 463 .attrs = ehca_drv_attrs 464}; 465 466#define EHCA_RESOURCE_ATTR(name) \ 467static ssize_t ehca_show_##name(struct device *dev, \ 468 struct device_attribute *attr, \ 469 char *buf) \ 470{ \ 471 struct ehca_shca *shca; \ 472 struct hipz_query_hca *rblock; \ 473 int data; \ 474 \ 475 shca = dev->driver_data; \ 476 \ 477 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL); \ 478 if (!rblock) { \ 479 dev_err(dev, "Can't allocate rblock memory."); \ 480 return 0; \ 481 } \ 482 \ 483 if (hipz_h_query_hca(shca->ipz_hca_handle, rblock) != H_SUCCESS) { \ 484 dev_err(dev, "Can't query device properties"); \ 485 ehca_free_fw_ctrlblock(rblock); \ 486 return 0; \ 487 } \ 488 \ 489 data = rblock->name; \ 490 ehca_free_fw_ctrlblock(rblock); \ 491 \ 492 if ((strcmp(#name, "num_ports") == 0) && (ehca_nr_ports == 1)) \ 493 return snprintf(buf, 256, "1\n"); \ 494 else \ 495 return snprintf(buf, 256, "%d\n", data); \ 496 \ 497} \ 498static DEVICE_ATTR(name, S_IRUGO, ehca_show_##name, NULL); 499 500EHCA_RESOURCE_ATTR(num_ports); 501EHCA_RESOURCE_ATTR(hw_ver); 502EHCA_RESOURCE_ATTR(max_eq); 503EHCA_RESOURCE_ATTR(cur_eq); 504EHCA_RESOURCE_ATTR(max_cq); 505EHCA_RESOURCE_ATTR(cur_cq); 506EHCA_RESOURCE_ATTR(max_qp); 507EHCA_RESOURCE_ATTR(cur_qp); 508EHCA_RESOURCE_ATTR(max_mr); 509EHCA_RESOURCE_ATTR(cur_mr); 510EHCA_RESOURCE_ATTR(max_mw); 511EHCA_RESOURCE_ATTR(cur_mw); 512EHCA_RESOURCE_ATTR(max_pd); 513EHCA_RESOURCE_ATTR(max_ah); 514 515static ssize_t ehca_show_adapter_handle(struct device *dev, 516 struct device_attribute *attr, 517 char *buf) 518{ 519 struct ehca_shca *shca = dev->driver_data; 520 521 return sprintf(buf, "%lx\n", shca->ipz_hca_handle.handle); 522 523} 524static DEVICE_ATTR(adapter_handle, S_IRUGO, ehca_show_adapter_handle, NULL); 525 526static struct attribute *ehca_dev_attrs[] = { 527 &dev_attr_adapter_handle.attr, 528 &dev_attr_num_ports.attr, 529 &dev_attr_hw_ver.attr, 530 &dev_attr_max_eq.attr, 531 &dev_attr_cur_eq.attr, 532 &dev_attr_max_cq.attr, 533 &dev_attr_cur_cq.attr, 534 &dev_attr_max_qp.attr, 535 &dev_attr_cur_qp.attr, 536 &dev_attr_max_mr.attr, 537 &dev_attr_cur_mr.attr, 538 &dev_attr_max_mw.attr, 539 &dev_attr_cur_mw.attr, 540 &dev_attr_max_pd.attr, 541 &dev_attr_max_ah.attr, 542 NULL 543}; 544 545static struct attribute_group ehca_dev_attr_grp = { 546 .attrs = ehca_dev_attrs 547}; 548 549static int __devinit ehca_probe(struct ibmebus_dev *dev, 550 const struct of_device_id *id) 551{ 552 struct ehca_shca *shca; 553 const u64 *handle; 554 struct ib_pd *ibpd; 555 int ret; 556 557 handle = of_get_property(dev->ofdev.node, "ibm,hca-handle", NULL); 558 if (!handle) { 559 ehca_gen_err("Cannot get eHCA handle for adapter: %s.", 560 dev->ofdev.node->full_name); 561 return -ENODEV; 562 } 563 564 if (!(*handle)) { 565 ehca_gen_err("Wrong eHCA handle for adapter: %s.", 566 dev->ofdev.node->full_name); 567 return -ENODEV; 568 } 569 570 shca = (struct ehca_shca *)ib_alloc_device(sizeof(*shca)); 571 if (!shca) { 572 ehca_gen_err("Cannot allocate shca memory."); 573 return -ENOMEM; 574 } 575 mutex_init(&shca->modify_mutex); 576 577 shca->ibmebus_dev = dev; 578 shca->ipz_hca_handle.handle = *handle; 579 dev->ofdev.dev.driver_data = shca; 580 581 ret = ehca_sense_attributes(shca); 582 if (ret < 0) { 583 ehca_gen_err("Cannot sense eHCA attributes."); 584 goto probe1; 585 } 586 587 ret = ehca_init_device(shca); 588 if (ret) { 589 ehca_gen_err("Cannot init ehca device struct"); 590 goto probe1; 591 } 592 593 /* create event queues */ 594 ret = ehca_create_eq(shca, &shca->eq, EHCA_EQ, 2048); 595 if (ret) { 596 ehca_err(&shca->ib_device, "Cannot create EQ."); 597 goto probe1; 598 } 599 600 ret = ehca_create_eq(shca, &shca->neq, EHCA_NEQ, 513); 601 if (ret) { 602 ehca_err(&shca->ib_device, "Cannot create NEQ."); 603 goto probe3; 604 } 605 606 /* create internal protection domain */ 607 ibpd = ehca_alloc_pd(&shca->ib_device, (void*)(-1), NULL); 608 if (IS_ERR(ibpd)) { 609 ehca_err(&shca->ib_device, "Cannot create internal PD."); 610 ret = PTR_ERR(ibpd); 611 goto probe4; 612 } 613 614 shca->pd = container_of(ibpd, struct ehca_pd, ib_pd); 615 shca->pd->ib_pd.device = &shca->ib_device; 616 617 /* create internal max MR */ 618 ret = ehca_reg_internal_maxmr(shca, shca->pd, &shca->maxmr); 619 620 if (ret) { 621 ehca_err(&shca->ib_device, "Cannot create internal MR ret=%x", 622 ret); 623 goto probe5; 624 } 625 626 ret = ib_register_device(&shca->ib_device); 627 if (ret) { 628 ehca_err(&shca->ib_device, 629 "ib_register_device() failed ret=%x", ret); 630 goto probe6; 631 } 632 633 /* create AQP1 for port 1 */ 634 if (ehca_open_aqp1 == 1) { 635 shca->sport[0].port_state = IB_PORT_DOWN; 636 ret = ehca_create_aqp1(shca, 1); 637 if (ret) { 638 ehca_err(&shca->ib_device, 639 "Cannot create AQP1 for port 1."); 640 goto probe7; 641 } 642 } 643 644 /* create AQP1 for port 2 */ 645 if ((ehca_open_aqp1 == 1) && (shca->num_ports == 2)) { 646 shca->sport[1].port_state = IB_PORT_DOWN; 647 ret = ehca_create_aqp1(shca, 2); 648 if (ret) { 649 ehca_err(&shca->ib_device, 650 "Cannot create AQP1 for port 2."); 651 goto probe8; 652 } 653 } 654 655 ret = sysfs_create_group(&dev->ofdev.dev.kobj, &ehca_dev_attr_grp); 656 if (ret) /* only complain; we can live without attributes */ 657 ehca_err(&shca->ib_device, 658 "Cannot create device attributes ret=%d", ret); 659 660 spin_lock(&shca_list_lock); 661 list_add(&shca->shca_list, &shca_list); 662 spin_unlock(&shca_list_lock); 663 664 return 0; 665 666probe8: 667 ret = ehca_destroy_aqp1(&shca->sport[0]); 668 if (ret) 669 ehca_err(&shca->ib_device, 670 "Cannot destroy AQP1 for port 1. ret=%x", ret); 671 672probe7: 673 ib_unregister_device(&shca->ib_device); 674 675probe6: 676 ret = ehca_dereg_internal_maxmr(shca); 677 if (ret) 678 ehca_err(&shca->ib_device, 679 "Cannot destroy internal MR. ret=%x", ret); 680 681probe5: 682 ret = ehca_dealloc_pd(&shca->pd->ib_pd); 683 if (ret) 684 ehca_err(&shca->ib_device, 685 "Cannot destroy internal PD. ret=%x", ret); 686 687probe4: 688 ret = ehca_destroy_eq(shca, &shca->neq); 689 if (ret) 690 ehca_err(&shca->ib_device, 691 "Cannot destroy NEQ. ret=%x", ret); 692 693probe3: 694 ret = ehca_destroy_eq(shca, &shca->eq); 695 if (ret) 696 ehca_err(&shca->ib_device, 697 "Cannot destroy EQ. ret=%x", ret); 698 699probe1: 700 ib_dealloc_device(&shca->ib_device); 701 702 return -EINVAL; 703} 704 705static int __devexit ehca_remove(struct ibmebus_dev *dev) 706{ 707 struct ehca_shca *shca = dev->ofdev.dev.driver_data; 708 int ret; 709 710 sysfs_remove_group(&dev->ofdev.dev.kobj, &ehca_dev_attr_grp); 711 712 if (ehca_open_aqp1 == 1) { 713 int i; 714 for (i = 0; i < shca->num_ports; i++) { 715 ret = ehca_destroy_aqp1(&shca->sport[i]); 716 if (ret) 717 ehca_err(&shca->ib_device, 718 "Cannot destroy AQP1 for port %x " 719 "ret=%x", ret, i); 720 } 721 } 722 723 ib_unregister_device(&shca->ib_device); 724 725 ret = ehca_dereg_internal_maxmr(shca); 726 if (ret) 727 ehca_err(&shca->ib_device, 728 "Cannot destroy internal MR. ret=%x", ret); 729 730 ret = ehca_dealloc_pd(&shca->pd->ib_pd); 731 if (ret) 732 ehca_err(&shca->ib_device, 733 "Cannot destroy internal PD. ret=%x", ret); 734 735 ret = ehca_destroy_eq(shca, &shca->eq); 736 if (ret) 737 ehca_err(&shca->ib_device, "Cannot destroy EQ. ret=%x", ret); 738 739 ret = ehca_destroy_eq(shca, &shca->neq); 740 if (ret) 741 ehca_err(&shca->ib_device, "Canot destroy NEQ. ret=%x", ret); 742 743 ib_dealloc_device(&shca->ib_device); 744 745 spin_lock(&shca_list_lock); 746 list_del(&shca->shca_list); 747 spin_unlock(&shca_list_lock); 748 749 return ret; 750} 751 752static struct of_device_id ehca_device_table[] = 753{ 754 { 755 .name = "lhca", 756 .compatible = "IBM,lhca", 757 }, 758 {}, 759}; 760 761static struct ibmebus_driver ehca_driver = { 762 .name = "ehca", 763 .id_table = ehca_device_table, 764 .probe = ehca_probe, 765 .remove = ehca_remove, 766}; 767 768void ehca_poll_eqs(unsigned long data) 769{ 770 struct ehca_shca *shca; 771 772 spin_lock(&shca_list_lock); 773 list_for_each_entry(shca, &shca_list, shca_list) { 774 if (shca->eq.is_initialized) { 775 /* call deadman proc only if eq ptr does not change */ 776 struct ehca_eq *eq = &shca->eq; 777 int max = 3; 778 volatile u64 q_ofs, q_ofs2; 779 u64 flags; 780 spin_lock_irqsave(&eq->spinlock, flags); 781 q_ofs = eq->ipz_queue.current_q_offset; 782 spin_unlock_irqrestore(&eq->spinlock, flags); 783 do { 784 spin_lock_irqsave(&eq->spinlock, flags); 785 q_ofs2 = eq->ipz_queue.current_q_offset; 786 spin_unlock_irqrestore(&eq->spinlock, flags); 787 max--; 788 } while (q_ofs == q_ofs2 && max > 0); 789 if (q_ofs == q_ofs2) 790 ehca_process_eq(shca, 0); 791 } 792 } 793 mod_timer(&poll_eqs_timer, jiffies + HZ); 794 spin_unlock(&shca_list_lock); 795} 796 797int __init ehca_module_init(void) 798{ 799 int ret; 800 801 printk(KERN_INFO "eHCA Infiniband Device Driver " 802 "(Rel.: SVNEHCA_0023)\n"); 803 idr_init(&ehca_qp_idr); 804 idr_init(&ehca_cq_idr); 805 spin_lock_init(&ehca_qp_idr_lock); 806 spin_lock_init(&ehca_cq_idr_lock); 807 spin_lock_init(&hcall_lock); 808 809 INIT_LIST_HEAD(&shca_list); 810 spin_lock_init(&shca_list_lock); 811 812 if ((ret = ehca_create_comp_pool())) { 813 ehca_gen_err("Cannot create comp pool."); 814 return ret; 815 } 816 817 if ((ret = ehca_create_slab_caches())) { 818 ehca_gen_err("Cannot create SLAB caches"); 819 ret = -ENOMEM; 820 goto module_init1; 821 } 822 823 if ((ret = ibmebus_register_driver(&ehca_driver))) { 824 ehca_gen_err("Cannot register eHCA device driver"); 825 ret = -EINVAL; 826 goto module_init2; 827 } 828 829 ret = sysfs_create_group(&ehca_driver.driver.kobj, &ehca_drv_attr_grp); 830 if (ret) /* only complain; we can live without attributes */ 831 ehca_gen_err("Cannot create driver attributes ret=%d", ret); 832 833 if (ehca_poll_all_eqs != 1) { 834 ehca_gen_err("WARNING!!!"); 835 ehca_gen_err("It is possible to lose interrupts."); 836 } else { 837 init_timer(&poll_eqs_timer); 838 poll_eqs_timer.function = ehca_poll_eqs; 839 poll_eqs_timer.expires = jiffies + HZ; 840 add_timer(&poll_eqs_timer); 841 } 842 843 return 0; 844 845module_init2: 846 ehca_destroy_slab_caches(); 847 848module_init1: 849 ehca_destroy_comp_pool(); 850 return ret; 851}; 852 853void __exit ehca_module_exit(void) 854{ 855 if (ehca_poll_all_eqs == 1) 856 del_timer_sync(&poll_eqs_timer); 857 858 sysfs_remove_group(&ehca_driver.driver.kobj, &ehca_drv_attr_grp); 859 ibmebus_unregister_driver(&ehca_driver); 860 861 ehca_destroy_slab_caches(); 862 863 ehca_destroy_comp_pool(); 864 865 idr_destroy(&ehca_cq_idr); 866 idr_destroy(&ehca_qp_idr); 867}; 868 869module_init(ehca_module_init); 870module_exit(ehca_module_exit); 871