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 47#include <linux/notifier.h> 48#include <linux/memory.h> 49#include "ehca_classes.h" 50#include "ehca_iverbs.h" 51#include "ehca_mrmw.h" 52#include "ehca_tools.h" 53#include "hcp_if.h" 54 55#define HCAD_VERSION "0029" 56 57MODULE_LICENSE("Dual BSD/GPL"); 58MODULE_AUTHOR("Christoph Raisch <raisch@de.ibm.com>"); 59MODULE_DESCRIPTION("IBM eServer HCA InfiniBand Device Driver"); 60MODULE_VERSION(HCAD_VERSION); 61 62static bool ehca_open_aqp1 = 0; 63static int ehca_hw_level = 0; 64static bool ehca_poll_all_eqs = 1; 65 66int ehca_debug_level = 0; 67int ehca_nr_ports = -1; 68bool ehca_use_hp_mr = 0; 69int ehca_port_act_time = 30; 70int ehca_static_rate = -1; 71bool ehca_scaling_code = 0; 72int ehca_lock_hcalls = -1; 73int ehca_max_cq = -1; 74int ehca_max_qp = -1; 75 76module_param_named(open_aqp1, ehca_open_aqp1, bool, S_IRUGO); 77module_param_named(debug_level, ehca_debug_level, int, S_IRUGO); 78module_param_named(hw_level, ehca_hw_level, int, S_IRUGO); 79module_param_named(nr_ports, ehca_nr_ports, int, S_IRUGO); 80module_param_named(use_hp_mr, ehca_use_hp_mr, bool, S_IRUGO); 81module_param_named(port_act_time, ehca_port_act_time, int, S_IRUGO); 82module_param_named(poll_all_eqs, ehca_poll_all_eqs, bool, S_IRUGO); 83module_param_named(static_rate, ehca_static_rate, int, S_IRUGO); 84module_param_named(scaling_code, ehca_scaling_code, bool, S_IRUGO); 85module_param_named(lock_hcalls, ehca_lock_hcalls, bint, S_IRUGO); 86module_param_named(number_of_cqs, ehca_max_cq, int, S_IRUGO); 87module_param_named(number_of_qps, ehca_max_qp, int, S_IRUGO); 88 89MODULE_PARM_DESC(open_aqp1, 90 "Open AQP1 on startup (default: no)"); 91MODULE_PARM_DESC(debug_level, 92 "Amount of debug output (0: none (default), 1: traces, " 93 "2: some dumps, 3: lots)"); 94MODULE_PARM_DESC(hw_level, 95 "Hardware level (0: autosensing (default), " 96 "0x10..0x14: eHCA, 0x20..0x23: eHCA2)"); 97MODULE_PARM_DESC(nr_ports, 98 "number of connected ports (-1: autodetect (default), " 99 "1: port one only, 2: two ports)"); 100MODULE_PARM_DESC(use_hp_mr, 101 "Use high performance MRs (default: no)"); 102MODULE_PARM_DESC(port_act_time, 103 "Time to wait for port activation (default: 30 sec)"); 104MODULE_PARM_DESC(poll_all_eqs, 105 "Poll all event queues periodically (default: yes)"); 106MODULE_PARM_DESC(static_rate, 107 "Set permanent static rate (default: no static rate)"); 108MODULE_PARM_DESC(scaling_code, 109 "Enable scaling code (default: no)"); 110MODULE_PARM_DESC(lock_hcalls, 111 "Serialize all hCalls made by the driver " 112 "(default: autodetect)"); 113MODULE_PARM_DESC(number_of_cqs, 114 "Max number of CQs which can be allocated " 115 "(default: autodetect)"); 116MODULE_PARM_DESC(number_of_qps, 117 "Max number of QPs which can be allocated " 118 "(default: autodetect)"); 119 120DEFINE_RWLOCK(ehca_qp_idr_lock); 121DEFINE_RWLOCK(ehca_cq_idr_lock); 122DEFINE_IDR(ehca_qp_idr); 123DEFINE_IDR(ehca_cq_idr); 124 125static LIST_HEAD(shca_list); /* list of all registered ehcas */ 126DEFINE_SPINLOCK(shca_list_lock); 127 128static struct timer_list poll_eqs_timer; 129 130#ifdef CONFIG_PPC_64K_PAGES 131static struct kmem_cache *ctblk_cache; 132 133void *ehca_alloc_fw_ctrlblock(gfp_t flags) 134{ 135 void *ret = kmem_cache_zalloc(ctblk_cache, flags); 136 if (!ret) 137 ehca_gen_err("Out of memory for ctblk"); 138 return ret; 139} 140 141void ehca_free_fw_ctrlblock(void *ptr) 142{ 143 if (ptr) 144 kmem_cache_free(ctblk_cache, ptr); 145 146} 147#endif 148 149int ehca2ib_return_code(u64 ehca_rc) 150{ 151 switch (ehca_rc) { 152 case H_SUCCESS: 153 return 0; 154 case H_RESOURCE: /* Resource in use */ 155 case H_BUSY: 156 return -EBUSY; 157 case H_NOT_ENOUGH_RESOURCES: /* insufficient resources */ 158 case H_CONSTRAINED: /* resource constraint */ 159 case H_NO_MEM: 160 return -ENOMEM; 161 default: 162 return -EINVAL; 163 } 164} 165 166static int ehca_create_slab_caches(void) 167{ 168 int ret; 169 170 ret = ehca_init_pd_cache(); 171 if (ret) { 172 ehca_gen_err("Cannot create PD SLAB cache."); 173 return ret; 174 } 175 176 ret = ehca_init_cq_cache(); 177 if (ret) { 178 ehca_gen_err("Cannot create CQ SLAB cache."); 179 goto create_slab_caches2; 180 } 181 182 ret = ehca_init_qp_cache(); 183 if (ret) { 184 ehca_gen_err("Cannot create QP SLAB cache."); 185 goto create_slab_caches3; 186 } 187 188 ret = ehca_init_av_cache(); 189 if (ret) { 190 ehca_gen_err("Cannot create AV SLAB cache."); 191 goto create_slab_caches4; 192 } 193 194 ret = ehca_init_mrmw_cache(); 195 if (ret) { 196 ehca_gen_err("Cannot create MR&MW SLAB cache."); 197 goto create_slab_caches5; 198 } 199 200 ret = ehca_init_small_qp_cache(); 201 if (ret) { 202 ehca_gen_err("Cannot create small queue SLAB cache."); 203 goto create_slab_caches6; 204 } 205 206#ifdef CONFIG_PPC_64K_PAGES 207 ctblk_cache = kmem_cache_create("ehca_cache_ctblk", 208 EHCA_PAGESIZE, H_CB_ALIGNMENT, 209 SLAB_HWCACHE_ALIGN, 210 NULL); 211 if (!ctblk_cache) { 212 ehca_gen_err("Cannot create ctblk SLAB cache."); 213 ehca_cleanup_small_qp_cache(); 214 goto create_slab_caches6; 215 } 216#endif 217 return 0; 218 219create_slab_caches6: 220 ehca_cleanup_mrmw_cache(); 221 222create_slab_caches5: 223 ehca_cleanup_av_cache(); 224 225create_slab_caches4: 226 ehca_cleanup_qp_cache(); 227 228create_slab_caches3: 229 ehca_cleanup_cq_cache(); 230 231create_slab_caches2: 232 ehca_cleanup_pd_cache(); 233 234 return ret; 235} 236 237static void ehca_destroy_slab_caches(void) 238{ 239 ehca_cleanup_small_qp_cache(); 240 ehca_cleanup_mrmw_cache(); 241 ehca_cleanup_av_cache(); 242 ehca_cleanup_qp_cache(); 243 ehca_cleanup_cq_cache(); 244 ehca_cleanup_pd_cache(); 245#ifdef CONFIG_PPC_64K_PAGES 246 if (ctblk_cache) 247 kmem_cache_destroy(ctblk_cache); 248#endif 249} 250 251#define EHCA_HCAAVER EHCA_BMASK_IBM(32, 39) 252#define EHCA_REVID EHCA_BMASK_IBM(40, 63) 253 254static struct cap_descr { 255 u64 mask; 256 char *descr; 257} hca_cap_descr[] = { 258 { HCA_CAP_AH_PORT_NR_CHECK, "HCA_CAP_AH_PORT_NR_CHECK" }, 259 { HCA_CAP_ATOMIC, "HCA_CAP_ATOMIC" }, 260 { HCA_CAP_AUTO_PATH_MIG, "HCA_CAP_AUTO_PATH_MIG" }, 261 { HCA_CAP_BAD_P_KEY_CTR, "HCA_CAP_BAD_P_KEY_CTR" }, 262 { HCA_CAP_SQD_RTS_PORT_CHANGE, "HCA_CAP_SQD_RTS_PORT_CHANGE" }, 263 { HCA_CAP_CUR_QP_STATE_MOD, "HCA_CAP_CUR_QP_STATE_MOD" }, 264 { HCA_CAP_INIT_TYPE, "HCA_CAP_INIT_TYPE" }, 265 { HCA_CAP_PORT_ACTIVE_EVENT, "HCA_CAP_PORT_ACTIVE_EVENT" }, 266 { HCA_CAP_Q_KEY_VIOL_CTR, "HCA_CAP_Q_KEY_VIOL_CTR" }, 267 { HCA_CAP_WQE_RESIZE, "HCA_CAP_WQE_RESIZE" }, 268 { HCA_CAP_RAW_PACKET_MCAST, "HCA_CAP_RAW_PACKET_MCAST" }, 269 { HCA_CAP_SHUTDOWN_PORT, "HCA_CAP_SHUTDOWN_PORT" }, 270 { HCA_CAP_RC_LL_QP, "HCA_CAP_RC_LL_QP" }, 271 { HCA_CAP_SRQ, "HCA_CAP_SRQ" }, 272 { HCA_CAP_UD_LL_QP, "HCA_CAP_UD_LL_QP" }, 273 { HCA_CAP_RESIZE_MR, "HCA_CAP_RESIZE_MR" }, 274 { HCA_CAP_MINI_QP, "HCA_CAP_MINI_QP" }, 275 { HCA_CAP_H_ALLOC_RES_SYNC, "HCA_CAP_H_ALLOC_RES_SYNC" }, 276}; 277 278static int ehca_sense_attributes(struct ehca_shca *shca) 279{ 280 int i, ret = 0; 281 u64 h_ret; 282 struct hipz_query_hca *rblock; 283 struct hipz_query_port *port; 284 const char *loc_code; 285 286 static const u32 pgsize_map[] = { 287 HCA_CAP_MR_PGSIZE_4K, 0x1000, 288 HCA_CAP_MR_PGSIZE_64K, 0x10000, 289 HCA_CAP_MR_PGSIZE_1M, 0x100000, 290 HCA_CAP_MR_PGSIZE_16M, 0x1000000, 291 }; 292 293 ehca_gen_dbg("Probing adapter %s...", 294 shca->ofdev->dev.of_node->full_name); 295 loc_code = of_get_property(shca->ofdev->dev.of_node, "ibm,loc-code", 296 NULL); 297 if (loc_code) 298 ehca_gen_dbg(" ... location lode=%s", loc_code); 299 300 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL); 301 if (!rblock) { 302 ehca_gen_err("Cannot allocate rblock memory."); 303 return -ENOMEM; 304 } 305 306 h_ret = hipz_h_query_hca(shca->ipz_hca_handle, rblock); 307 if (h_ret != H_SUCCESS) { 308 ehca_gen_err("Cannot query device properties. h_ret=%lli", 309 h_ret); 310 ret = -EPERM; 311 goto sense_attributes1; 312 } 313 314 if (ehca_nr_ports == 1) 315 shca->num_ports = 1; 316 else 317 shca->num_ports = (u8)rblock->num_ports; 318 319 ehca_gen_dbg(" ... found %x ports", rblock->num_ports); 320 321 if (ehca_hw_level == 0) { 322 u32 hcaaver; 323 u32 revid; 324 325 hcaaver = EHCA_BMASK_GET(EHCA_HCAAVER, rblock->hw_ver); 326 revid = EHCA_BMASK_GET(EHCA_REVID, rblock->hw_ver); 327 328 ehca_gen_dbg(" ... hardware version=%x:%x", hcaaver, revid); 329 330 if (hcaaver == 1) { 331 if (revid <= 3) 332 shca->hw_level = 0x10 | (revid + 1); 333 else 334 shca->hw_level = 0x14; 335 } else if (hcaaver == 2) { 336 if (revid == 0) 337 shca->hw_level = 0x21; 338 else if (revid == 0x10) 339 shca->hw_level = 0x22; 340 else if (revid == 0x20 || revid == 0x21) 341 shca->hw_level = 0x23; 342 } 343 344 if (!shca->hw_level) { 345 ehca_gen_warn("unknown hardware version" 346 " - assuming default level"); 347 shca->hw_level = 0x22; 348 } 349 } else 350 shca->hw_level = ehca_hw_level; 351 ehca_gen_dbg(" ... hardware level=%x", shca->hw_level); 352 353 shca->hca_cap = rblock->hca_cap_indicators; 354 ehca_gen_dbg(" ... HCA capabilities:"); 355 for (i = 0; i < ARRAY_SIZE(hca_cap_descr); i++) 356 if (EHCA_BMASK_GET(hca_cap_descr[i].mask, shca->hca_cap)) 357 ehca_gen_dbg(" %s", hca_cap_descr[i].descr); 358 359 /* Autodetect hCall locking -- the "H_ALLOC_RESOURCE synced" flag is 360 * a firmware property, so it's valid across all adapters 361 */ 362 if (ehca_lock_hcalls == -1) 363 ehca_lock_hcalls = !EHCA_BMASK_GET(HCA_CAP_H_ALLOC_RES_SYNC, 364 shca->hca_cap); 365 366 /* translate supported MR page sizes; always support 4K */ 367 shca->hca_cap_mr_pgsize = EHCA_PAGESIZE; 368 for (i = 0; i < ARRAY_SIZE(pgsize_map); i += 2) 369 if (rblock->memory_page_size_supported & pgsize_map[i]) 370 shca->hca_cap_mr_pgsize |= pgsize_map[i + 1]; 371 372 /* Set maximum number of CQs and QPs to calculate EQ size */ 373 if (shca->max_num_qps == -1) 374 shca->max_num_qps = min_t(int, rblock->max_qp, 375 EHCA_MAX_NUM_QUEUES); 376 else if (shca->max_num_qps < 1 || shca->max_num_qps > rblock->max_qp) { 377 ehca_gen_warn("The requested number of QPs is out of range " 378 "(1 - %i) specified by HW. Value is set to %i", 379 rblock->max_qp, rblock->max_qp); 380 shca->max_num_qps = rblock->max_qp; 381 } 382 383 if (shca->max_num_cqs == -1) 384 shca->max_num_cqs = min_t(int, rblock->max_cq, 385 EHCA_MAX_NUM_QUEUES); 386 else if (shca->max_num_cqs < 1 || shca->max_num_cqs > rblock->max_cq) { 387 ehca_gen_warn("The requested number of CQs is out of range " 388 "(1 - %i) specified by HW. Value is set to %i", 389 rblock->max_cq, rblock->max_cq); 390 } 391 392 /* query max MTU from first port -- it's the same for all ports */ 393 port = (struct hipz_query_port *)rblock; 394 h_ret = hipz_h_query_port(shca->ipz_hca_handle, 1, port); 395 if (h_ret != H_SUCCESS) { 396 ehca_gen_err("Cannot query port properties. h_ret=%lli", 397 h_ret); 398 ret = -EPERM; 399 goto sense_attributes1; 400 } 401 402 shca->max_mtu = port->max_mtu; 403 404sense_attributes1: 405 ehca_free_fw_ctrlblock(rblock); 406 return ret; 407} 408 409static int init_node_guid(struct ehca_shca *shca) 410{ 411 int ret = 0; 412 struct hipz_query_hca *rblock; 413 414 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL); 415 if (!rblock) { 416 ehca_err(&shca->ib_device, "Can't allocate rblock memory."); 417 return -ENOMEM; 418 } 419 420 if (hipz_h_query_hca(shca->ipz_hca_handle, rblock) != H_SUCCESS) { 421 ehca_err(&shca->ib_device, "Can't query device properties"); 422 ret = -EINVAL; 423 goto init_node_guid1; 424 } 425 426 memcpy(&shca->ib_device.node_guid, &rblock->node_guid, sizeof(u64)); 427 428init_node_guid1: 429 ehca_free_fw_ctrlblock(rblock); 430 return ret; 431} 432 433static int ehca_init_device(struct ehca_shca *shca) 434{ 435 int ret; 436 437 ret = init_node_guid(shca); 438 if (ret) 439 return ret; 440 441 strlcpy(shca->ib_device.name, "ehca%d", IB_DEVICE_NAME_MAX); 442 shca->ib_device.owner = THIS_MODULE; 443 444 shca->ib_device.uverbs_abi_ver = 8; 445 shca->ib_device.uverbs_cmd_mask = 446 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT) | 447 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE) | 448 (1ull << IB_USER_VERBS_CMD_QUERY_PORT) | 449 (1ull << IB_USER_VERBS_CMD_ALLOC_PD) | 450 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD) | 451 (1ull << IB_USER_VERBS_CMD_REG_MR) | 452 (1ull << IB_USER_VERBS_CMD_DEREG_MR) | 453 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) | 454 (1ull << IB_USER_VERBS_CMD_CREATE_CQ) | 455 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ) | 456 (1ull << IB_USER_VERBS_CMD_CREATE_QP) | 457 (1ull << IB_USER_VERBS_CMD_MODIFY_QP) | 458 (1ull << IB_USER_VERBS_CMD_QUERY_QP) | 459 (1ull << IB_USER_VERBS_CMD_DESTROY_QP) | 460 (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST) | 461 (1ull << IB_USER_VERBS_CMD_DETACH_MCAST); 462 463 shca->ib_device.node_type = RDMA_NODE_IB_CA; 464 shca->ib_device.phys_port_cnt = shca->num_ports; 465 shca->ib_device.num_comp_vectors = 1; 466 shca->ib_device.dma_device = &shca->ofdev->dev; 467 shca->ib_device.query_device = ehca_query_device; 468 shca->ib_device.query_port = ehca_query_port; 469 shca->ib_device.query_gid = ehca_query_gid; 470 shca->ib_device.query_pkey = ehca_query_pkey; 471 /* shca->in_device.modify_device = ehca_modify_device */ 472 shca->ib_device.modify_port = ehca_modify_port; 473 shca->ib_device.alloc_ucontext = ehca_alloc_ucontext; 474 shca->ib_device.dealloc_ucontext = ehca_dealloc_ucontext; 475 shca->ib_device.alloc_pd = ehca_alloc_pd; 476 shca->ib_device.dealloc_pd = ehca_dealloc_pd; 477 shca->ib_device.create_ah = ehca_create_ah; 478 /* shca->ib_device.modify_ah = ehca_modify_ah; */ 479 shca->ib_device.query_ah = ehca_query_ah; 480 shca->ib_device.destroy_ah = ehca_destroy_ah; 481 shca->ib_device.create_qp = ehca_create_qp; 482 shca->ib_device.modify_qp = ehca_modify_qp; 483 shca->ib_device.query_qp = ehca_query_qp; 484 shca->ib_device.destroy_qp = ehca_destroy_qp; 485 shca->ib_device.post_send = ehca_post_send; 486 shca->ib_device.post_recv = ehca_post_recv; 487 shca->ib_device.create_cq = ehca_create_cq; 488 shca->ib_device.destroy_cq = ehca_destroy_cq; 489 shca->ib_device.resize_cq = ehca_resize_cq; 490 shca->ib_device.poll_cq = ehca_poll_cq; 491 /* shca->ib_device.peek_cq = ehca_peek_cq; */ 492 shca->ib_device.req_notify_cq = ehca_req_notify_cq; 493 /* shca->ib_device.req_ncomp_notif = ehca_req_ncomp_notif; */ 494 shca->ib_device.get_dma_mr = ehca_get_dma_mr; 495 shca->ib_device.reg_phys_mr = ehca_reg_phys_mr; 496 shca->ib_device.reg_user_mr = ehca_reg_user_mr; 497 shca->ib_device.query_mr = ehca_query_mr; 498 shca->ib_device.dereg_mr = ehca_dereg_mr; 499 shca->ib_device.rereg_phys_mr = ehca_rereg_phys_mr; 500 shca->ib_device.alloc_mw = ehca_alloc_mw; 501 shca->ib_device.bind_mw = ehca_bind_mw; 502 shca->ib_device.dealloc_mw = ehca_dealloc_mw; 503 shca->ib_device.alloc_fmr = ehca_alloc_fmr; 504 shca->ib_device.map_phys_fmr = ehca_map_phys_fmr; 505 shca->ib_device.unmap_fmr = ehca_unmap_fmr; 506 shca->ib_device.dealloc_fmr = ehca_dealloc_fmr; 507 shca->ib_device.attach_mcast = ehca_attach_mcast; 508 shca->ib_device.detach_mcast = ehca_detach_mcast; 509 shca->ib_device.process_mad = ehca_process_mad; 510 shca->ib_device.mmap = ehca_mmap; 511 shca->ib_device.dma_ops = &ehca_dma_mapping_ops; 512 513 if (EHCA_BMASK_GET(HCA_CAP_SRQ, shca->hca_cap)) { 514 shca->ib_device.uverbs_cmd_mask |= 515 (1ull << IB_USER_VERBS_CMD_CREATE_SRQ) | 516 (1ull << IB_USER_VERBS_CMD_MODIFY_SRQ) | 517 (1ull << IB_USER_VERBS_CMD_QUERY_SRQ) | 518 (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ); 519 520 shca->ib_device.create_srq = ehca_create_srq; 521 shca->ib_device.modify_srq = ehca_modify_srq; 522 shca->ib_device.query_srq = ehca_query_srq; 523 shca->ib_device.destroy_srq = ehca_destroy_srq; 524 shca->ib_device.post_srq_recv = ehca_post_srq_recv; 525 } 526 527 return ret; 528} 529 530static int ehca_create_aqp1(struct ehca_shca *shca, u32 port) 531{ 532 struct ehca_sport *sport = &shca->sport[port - 1]; 533 struct ib_cq *ibcq; 534 struct ib_qp *ibqp; 535 struct ib_qp_init_attr qp_init_attr; 536 int ret; 537 538 if (sport->ibcq_aqp1) { 539 ehca_err(&shca->ib_device, "AQP1 CQ is already created."); 540 return -EPERM; 541 } 542 543 ibcq = ib_create_cq(&shca->ib_device, NULL, NULL, (void *)(-1), 10, 0); 544 if (IS_ERR(ibcq)) { 545 ehca_err(&shca->ib_device, "Cannot create AQP1 CQ."); 546 return PTR_ERR(ibcq); 547 } 548 sport->ibcq_aqp1 = ibcq; 549 550 if (sport->ibqp_sqp[IB_QPT_GSI]) { 551 ehca_err(&shca->ib_device, "AQP1 QP is already created."); 552 ret = -EPERM; 553 goto create_aqp1; 554 } 555 556 memset(&qp_init_attr, 0, sizeof(struct ib_qp_init_attr)); 557 qp_init_attr.send_cq = ibcq; 558 qp_init_attr.recv_cq = ibcq; 559 qp_init_attr.sq_sig_type = IB_SIGNAL_ALL_WR; 560 qp_init_attr.cap.max_send_wr = 100; 561 qp_init_attr.cap.max_recv_wr = 100; 562 qp_init_attr.cap.max_send_sge = 2; 563 qp_init_attr.cap.max_recv_sge = 1; 564 qp_init_attr.qp_type = IB_QPT_GSI; 565 qp_init_attr.port_num = port; 566 qp_init_attr.qp_context = NULL; 567 qp_init_attr.event_handler = NULL; 568 qp_init_attr.srq = NULL; 569 570 ibqp = ib_create_qp(&shca->pd->ib_pd, &qp_init_attr); 571 if (IS_ERR(ibqp)) { 572 ehca_err(&shca->ib_device, "Cannot create AQP1 QP."); 573 ret = PTR_ERR(ibqp); 574 goto create_aqp1; 575 } 576 sport->ibqp_sqp[IB_QPT_GSI] = ibqp; 577 578 return 0; 579 580create_aqp1: 581 ib_destroy_cq(sport->ibcq_aqp1); 582 return ret; 583} 584 585static int ehca_destroy_aqp1(struct ehca_sport *sport) 586{ 587 int ret; 588 589 ret = ib_destroy_qp(sport->ibqp_sqp[IB_QPT_GSI]); 590 if (ret) { 591 ehca_gen_err("Cannot destroy AQP1 QP. ret=%i", ret); 592 return ret; 593 } 594 595 ret = ib_destroy_cq(sport->ibcq_aqp1); 596 if (ret) 597 ehca_gen_err("Cannot destroy AQP1 CQ. ret=%i", ret); 598 599 return ret; 600} 601 602static ssize_t ehca_show_debug_level(struct device_driver *ddp, char *buf) 603{ 604 return snprintf(buf, PAGE_SIZE, "%d\n", ehca_debug_level); 605} 606 607static ssize_t ehca_store_debug_level(struct device_driver *ddp, 608 const char *buf, size_t count) 609{ 610 int value = (*buf) - '0'; 611 if (value >= 0 && value <= 9) 612 ehca_debug_level = value; 613 return 1; 614} 615 616static DRIVER_ATTR(debug_level, S_IRUSR | S_IWUSR, 617 ehca_show_debug_level, ehca_store_debug_level); 618 619static struct attribute *ehca_drv_attrs[] = { 620 &driver_attr_debug_level.attr, 621 NULL 622}; 623 624static struct attribute_group ehca_drv_attr_grp = { 625 .attrs = ehca_drv_attrs 626}; 627 628static const struct attribute_group *ehca_drv_attr_groups[] = { 629 &ehca_drv_attr_grp, 630 NULL, 631}; 632 633#define EHCA_RESOURCE_ATTR(name) \ 634static ssize_t ehca_show_##name(struct device *dev, \ 635 struct device_attribute *attr, \ 636 char *buf) \ 637{ \ 638 struct ehca_shca *shca; \ 639 struct hipz_query_hca *rblock; \ 640 int data; \ 641 \ 642 shca = dev_get_drvdata(dev); \ 643 \ 644 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL); \ 645 if (!rblock) { \ 646 dev_err(dev, "Can't allocate rblock memory.\n"); \ 647 return 0; \ 648 } \ 649 \ 650 if (hipz_h_query_hca(shca->ipz_hca_handle, rblock) != H_SUCCESS) { \ 651 dev_err(dev, "Can't query device properties\n"); \ 652 ehca_free_fw_ctrlblock(rblock); \ 653 return 0; \ 654 } \ 655 \ 656 data = rblock->name; \ 657 ehca_free_fw_ctrlblock(rblock); \ 658 \ 659 if ((strcmp(#name, "num_ports") == 0) && (ehca_nr_ports == 1)) \ 660 return snprintf(buf, 256, "1\n"); \ 661 else \ 662 return snprintf(buf, 256, "%d\n", data); \ 663 \ 664} \ 665static DEVICE_ATTR(name, S_IRUGO, ehca_show_##name, NULL); 666 667EHCA_RESOURCE_ATTR(num_ports); 668EHCA_RESOURCE_ATTR(hw_ver); 669EHCA_RESOURCE_ATTR(max_eq); 670EHCA_RESOURCE_ATTR(cur_eq); 671EHCA_RESOURCE_ATTR(max_cq); 672EHCA_RESOURCE_ATTR(cur_cq); 673EHCA_RESOURCE_ATTR(max_qp); 674EHCA_RESOURCE_ATTR(cur_qp); 675EHCA_RESOURCE_ATTR(max_mr); 676EHCA_RESOURCE_ATTR(cur_mr); 677EHCA_RESOURCE_ATTR(max_mw); 678EHCA_RESOURCE_ATTR(cur_mw); 679EHCA_RESOURCE_ATTR(max_pd); 680EHCA_RESOURCE_ATTR(max_ah); 681 682static ssize_t ehca_show_adapter_handle(struct device *dev, 683 struct device_attribute *attr, 684 char *buf) 685{ 686 struct ehca_shca *shca = dev_get_drvdata(dev); 687 688 return sprintf(buf, "%llx\n", shca->ipz_hca_handle.handle); 689 690} 691static DEVICE_ATTR(adapter_handle, S_IRUGO, ehca_show_adapter_handle, NULL); 692 693static struct attribute *ehca_dev_attrs[] = { 694 &dev_attr_adapter_handle.attr, 695 &dev_attr_num_ports.attr, 696 &dev_attr_hw_ver.attr, 697 &dev_attr_max_eq.attr, 698 &dev_attr_cur_eq.attr, 699 &dev_attr_max_cq.attr, 700 &dev_attr_cur_cq.attr, 701 &dev_attr_max_qp.attr, 702 &dev_attr_cur_qp.attr, 703 &dev_attr_max_mr.attr, 704 &dev_attr_cur_mr.attr, 705 &dev_attr_max_mw.attr, 706 &dev_attr_cur_mw.attr, 707 &dev_attr_max_pd.attr, 708 &dev_attr_max_ah.attr, 709 NULL 710}; 711 712static struct attribute_group ehca_dev_attr_grp = { 713 .attrs = ehca_dev_attrs 714}; 715 716static int __devinit ehca_probe(struct platform_device *dev, 717 const struct of_device_id *id) 718{ 719 struct ehca_shca *shca; 720 const u64 *handle; 721 struct ib_pd *ibpd; 722 int ret, i, eq_size; 723 unsigned long flags; 724 725 handle = of_get_property(dev->dev.of_node, "ibm,hca-handle", NULL); 726 if (!handle) { 727 ehca_gen_err("Cannot get eHCA handle for adapter: %s.", 728 dev->dev.of_node->full_name); 729 return -ENODEV; 730 } 731 732 if (!(*handle)) { 733 ehca_gen_err("Wrong eHCA handle for adapter: %s.", 734 dev->dev.of_node->full_name); 735 return -ENODEV; 736 } 737 738 shca = (struct ehca_shca *)ib_alloc_device(sizeof(*shca)); 739 if (!shca) { 740 ehca_gen_err("Cannot allocate shca memory."); 741 return -ENOMEM; 742 } 743 744 mutex_init(&shca->modify_mutex); 745 atomic_set(&shca->num_cqs, 0); 746 atomic_set(&shca->num_qps, 0); 747 shca->max_num_qps = ehca_max_qp; 748 shca->max_num_cqs = ehca_max_cq; 749 750 for (i = 0; i < ARRAY_SIZE(shca->sport); i++) 751 spin_lock_init(&shca->sport[i].mod_sqp_lock); 752 753 shca->ofdev = dev; 754 shca->ipz_hca_handle.handle = *handle; 755 dev_set_drvdata(&dev->dev, shca); 756 757 ret = ehca_sense_attributes(shca); 758 if (ret < 0) { 759 ehca_gen_err("Cannot sense eHCA attributes."); 760 goto probe1; 761 } 762 763 ret = ehca_init_device(shca); 764 if (ret) { 765 ehca_gen_err("Cannot init ehca device struct"); 766 goto probe1; 767 } 768 769 eq_size = 2 * shca->max_num_cqs + 4 * shca->max_num_qps; 770 /* create event queues */ 771 ret = ehca_create_eq(shca, &shca->eq, EHCA_EQ, eq_size); 772 if (ret) { 773 ehca_err(&shca->ib_device, "Cannot create EQ."); 774 goto probe1; 775 } 776 777 ret = ehca_create_eq(shca, &shca->neq, EHCA_NEQ, 513); 778 if (ret) { 779 ehca_err(&shca->ib_device, "Cannot create NEQ."); 780 goto probe3; 781 } 782 783 /* create internal protection domain */ 784 ibpd = ehca_alloc_pd(&shca->ib_device, (void *)(-1), NULL); 785 if (IS_ERR(ibpd)) { 786 ehca_err(&shca->ib_device, "Cannot create internal PD."); 787 ret = PTR_ERR(ibpd); 788 goto probe4; 789 } 790 791 shca->pd = container_of(ibpd, struct ehca_pd, ib_pd); 792 shca->pd->ib_pd.device = &shca->ib_device; 793 794 /* create internal max MR */ 795 ret = ehca_reg_internal_maxmr(shca, shca->pd, &shca->maxmr); 796 797 if (ret) { 798 ehca_err(&shca->ib_device, "Cannot create internal MR ret=%i", 799 ret); 800 goto probe5; 801 } 802 803 ret = ib_register_device(&shca->ib_device, NULL); 804 if (ret) { 805 ehca_err(&shca->ib_device, 806 "ib_register_device() failed ret=%i", ret); 807 goto probe6; 808 } 809 810 /* create AQP1 for port 1 */ 811 if (ehca_open_aqp1 == 1) { 812 shca->sport[0].port_state = IB_PORT_DOWN; 813 ret = ehca_create_aqp1(shca, 1); 814 if (ret) { 815 ehca_err(&shca->ib_device, 816 "Cannot create AQP1 for port 1."); 817 goto probe7; 818 } 819 } 820 821 /* create AQP1 for port 2 */ 822 if ((ehca_open_aqp1 == 1) && (shca->num_ports == 2)) { 823 shca->sport[1].port_state = IB_PORT_DOWN; 824 ret = ehca_create_aqp1(shca, 2); 825 if (ret) { 826 ehca_err(&shca->ib_device, 827 "Cannot create AQP1 for port 2."); 828 goto probe8; 829 } 830 } 831 832 ret = sysfs_create_group(&dev->dev.kobj, &ehca_dev_attr_grp); 833 if (ret) /* only complain; we can live without attributes */ 834 ehca_err(&shca->ib_device, 835 "Cannot create device attributes ret=%d", ret); 836 837 spin_lock_irqsave(&shca_list_lock, flags); 838 list_add(&shca->shca_list, &shca_list); 839 spin_unlock_irqrestore(&shca_list_lock, flags); 840 841 return 0; 842 843probe8: 844 ret = ehca_destroy_aqp1(&shca->sport[0]); 845 if (ret) 846 ehca_err(&shca->ib_device, 847 "Cannot destroy AQP1 for port 1. ret=%i", ret); 848 849probe7: 850 ib_unregister_device(&shca->ib_device); 851 852probe6: 853 ret = ehca_dereg_internal_maxmr(shca); 854 if (ret) 855 ehca_err(&shca->ib_device, 856 "Cannot destroy internal MR. ret=%x", ret); 857 858probe5: 859 ret = ehca_dealloc_pd(&shca->pd->ib_pd); 860 if (ret) 861 ehca_err(&shca->ib_device, 862 "Cannot destroy internal PD. ret=%x", ret); 863 864probe4: 865 ret = ehca_destroy_eq(shca, &shca->neq); 866 if (ret) 867 ehca_err(&shca->ib_device, 868 "Cannot destroy NEQ. ret=%x", ret); 869 870probe3: 871 ret = ehca_destroy_eq(shca, &shca->eq); 872 if (ret) 873 ehca_err(&shca->ib_device, 874 "Cannot destroy EQ. ret=%x", ret); 875 876probe1: 877 ib_dealloc_device(&shca->ib_device); 878 879 return -EINVAL; 880} 881 882static int __devexit ehca_remove(struct platform_device *dev) 883{ 884 struct ehca_shca *shca = dev_get_drvdata(&dev->dev); 885 unsigned long flags; 886 int ret; 887 888 sysfs_remove_group(&dev->dev.kobj, &ehca_dev_attr_grp); 889 890 if (ehca_open_aqp1 == 1) { 891 int i; 892 for (i = 0; i < shca->num_ports; i++) { 893 ret = ehca_destroy_aqp1(&shca->sport[i]); 894 if (ret) 895 ehca_err(&shca->ib_device, 896 "Cannot destroy AQP1 for port %x " 897 "ret=%i", ret, i); 898 } 899 } 900 901 ib_unregister_device(&shca->ib_device); 902 903 ret = ehca_dereg_internal_maxmr(shca); 904 if (ret) 905 ehca_err(&shca->ib_device, 906 "Cannot destroy internal MR. ret=%i", ret); 907 908 ret = ehca_dealloc_pd(&shca->pd->ib_pd); 909 if (ret) 910 ehca_err(&shca->ib_device, 911 "Cannot destroy internal PD. ret=%i", ret); 912 913 ret = ehca_destroy_eq(shca, &shca->eq); 914 if (ret) 915 ehca_err(&shca->ib_device, "Cannot destroy EQ. ret=%i", ret); 916 917 ret = ehca_destroy_eq(shca, &shca->neq); 918 if (ret) 919 ehca_err(&shca->ib_device, "Canot destroy NEQ. ret=%i", ret); 920 921 ib_dealloc_device(&shca->ib_device); 922 923 spin_lock_irqsave(&shca_list_lock, flags); 924 list_del(&shca->shca_list); 925 spin_unlock_irqrestore(&shca_list_lock, flags); 926 927 return ret; 928} 929 930static struct of_device_id ehca_device_table[] = 931{ 932 { 933 .name = "lhca", 934 .compatible = "IBM,lhca", 935 }, 936 {}, 937}; 938MODULE_DEVICE_TABLE(of, ehca_device_table); 939 940static struct of_platform_driver ehca_driver = { 941 .probe = ehca_probe, 942 .remove = ehca_remove, 943 .driver = { 944 .name = "ehca", 945 .owner = THIS_MODULE, 946 .groups = ehca_drv_attr_groups, 947 .of_match_table = ehca_device_table, 948 }, 949}; 950 951void ehca_poll_eqs(unsigned long data) 952{ 953 struct ehca_shca *shca; 954 955 spin_lock(&shca_list_lock); 956 list_for_each_entry(shca, &shca_list, shca_list) { 957 if (shca->eq.is_initialized) { 958 /* call deadman proc only if eq ptr does not change */ 959 struct ehca_eq *eq = &shca->eq; 960 int max = 3; 961 volatile u64 q_ofs, q_ofs2; 962 unsigned long flags; 963 spin_lock_irqsave(&eq->spinlock, flags); 964 q_ofs = eq->ipz_queue.current_q_offset; 965 spin_unlock_irqrestore(&eq->spinlock, flags); 966 do { 967 spin_lock_irqsave(&eq->spinlock, flags); 968 q_ofs2 = eq->ipz_queue.current_q_offset; 969 spin_unlock_irqrestore(&eq->spinlock, flags); 970 max--; 971 } while (q_ofs == q_ofs2 && max > 0); 972 if (q_ofs == q_ofs2) 973 ehca_process_eq(shca, 0); 974 } 975 } 976 mod_timer(&poll_eqs_timer, round_jiffies(jiffies + HZ)); 977 spin_unlock(&shca_list_lock); 978} 979 980static int ehca_mem_notifier(struct notifier_block *nb, 981 unsigned long action, void *data) 982{ 983 static unsigned long ehca_dmem_warn_time; 984 unsigned long flags; 985 986 switch (action) { 987 case MEM_CANCEL_OFFLINE: 988 case MEM_CANCEL_ONLINE: 989 case MEM_ONLINE: 990 case MEM_OFFLINE: 991 return NOTIFY_OK; 992 case MEM_GOING_ONLINE: 993 case MEM_GOING_OFFLINE: 994 /* only ok if no hca is attached to the lpar */ 995 spin_lock_irqsave(&shca_list_lock, flags); 996 if (list_empty(&shca_list)) { 997 spin_unlock_irqrestore(&shca_list_lock, flags); 998 return NOTIFY_OK; 999 } else { 1000 spin_unlock_irqrestore(&shca_list_lock, flags); 1001 if (printk_timed_ratelimit(&ehca_dmem_warn_time, 1002 30 * 1000)) 1003 ehca_gen_err("DMEM operations are not allowed" 1004 "in conjunction with eHCA"); 1005 return NOTIFY_BAD; 1006 } 1007 } 1008 return NOTIFY_OK; 1009} 1010 1011static struct notifier_block ehca_mem_nb = { 1012 .notifier_call = ehca_mem_notifier, 1013}; 1014 1015static int __init ehca_module_init(void) 1016{ 1017 int ret; 1018 1019 printk(KERN_INFO "eHCA Infiniband Device Driver " 1020 "(Version " HCAD_VERSION ")\n"); 1021 1022 ret = ehca_create_comp_pool(); 1023 if (ret) { 1024 ehca_gen_err("Cannot create comp pool."); 1025 return ret; 1026 } 1027 1028 ret = ehca_create_slab_caches(); 1029 if (ret) { 1030 ehca_gen_err("Cannot create SLAB caches"); 1031 ret = -ENOMEM; 1032 goto module_init1; 1033 } 1034 1035 ret = ehca_create_busmap(); 1036 if (ret) { 1037 ehca_gen_err("Cannot create busmap."); 1038 goto module_init2; 1039 } 1040 1041 ret = ibmebus_register_driver(&ehca_driver); 1042 if (ret) { 1043 ehca_gen_err("Cannot register eHCA device driver"); 1044 ret = -EINVAL; 1045 goto module_init3; 1046 } 1047 1048 ret = register_memory_notifier(&ehca_mem_nb); 1049 if (ret) { 1050 ehca_gen_err("Failed registering memory add/remove notifier"); 1051 goto module_init4; 1052 } 1053 1054 if (ehca_poll_all_eqs != 1) { 1055 ehca_gen_err("WARNING!!!"); 1056 ehca_gen_err("It is possible to lose interrupts."); 1057 } else { 1058 init_timer(&poll_eqs_timer); 1059 poll_eqs_timer.function = ehca_poll_eqs; 1060 poll_eqs_timer.expires = jiffies + HZ; 1061 add_timer(&poll_eqs_timer); 1062 } 1063 1064 return 0; 1065 1066module_init4: 1067 ibmebus_unregister_driver(&ehca_driver); 1068 1069module_init3: 1070 ehca_destroy_busmap(); 1071 1072module_init2: 1073 ehca_destroy_slab_caches(); 1074 1075module_init1: 1076 ehca_destroy_comp_pool(); 1077 return ret; 1078}; 1079 1080static void __exit ehca_module_exit(void) 1081{ 1082 if (ehca_poll_all_eqs == 1) 1083 del_timer_sync(&poll_eqs_timer); 1084 1085 ibmebus_unregister_driver(&ehca_driver); 1086 1087 unregister_memory_notifier(&ehca_mem_nb); 1088 1089 ehca_destroy_busmap(); 1090 1091 ehca_destroy_slab_caches(); 1092 1093 ehca_destroy_comp_pool(); 1094 1095 idr_destroy(&ehca_cq_idr); 1096 idr_destroy(&ehca_qp_idr); 1097}; 1098 1099module_init(ehca_module_init); 1100module_exit(ehca_module_exit); 1101