1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 /* 26 * ibtl_hca.c 27 * 28 * This file contains Transport API functions related to 29 * Host Channel Adapter (HCA) Verbs. 30 */ 31 32 #include <sys/ib/ibtl/impl/ibtl.h> 33 34 static char ibtf_hca[] = "ibtl_hca"; 35 36 /* Prototype declarations. */ 37 static ibt_status_t ibtl_query_hca_ports(ibtl_hca_devinfo_t *hca_devp, 38 uint8_t port, ibt_hca_portinfo_t **port_info_p, uint_t *ports_p, 39 uint_t *size_p, int use_cache); 40 41 /* 42 * Function: 43 * ibt_open_hca 44 * Input: 45 * ibt_hdl - IBT Client Handle 46 * hca_guid - HCA's node GUID. 47 * Output: 48 * hca_hdl_p - IBT HCA Handle. 49 * Returns: 50 * IBT_SUCCESS 51 * IBT_HCA_IN_USE 52 * IBT_HCA_INVALID 53 * Description: 54 * Open a HCA. HCA can only be opened/closed once. This routine allocates 55 * and returns a unique IBT Client HCA handle. Clients passes this 56 * handle on its subsequent references to this device. Once opened by a 57 * client, a specific HCA cannot be opened again until after it is closed. 58 * The IBT_HCA_IN_USE error is returned if client tries to open multiple 59 * times. In this case, previously allocated IBT HCA handle is returned to 60 * the client. Opening the HCA prepares the HCA for use by the client. 61 */ 62 ibt_status_t 63 ibt_open_hca(ibt_clnt_hdl_t ibt_hdl, ib_guid_t hca_guid, 64 ibt_hca_hdl_t *hca_hdl_p) 65 { 66 ibtl_hca_t *hca_infop; 67 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 68 69 IBTF_DPRINTF_L3(ibtf_hca, "ibt_open_hca(%p, %llX)", ibt_hdl, hca_guid); 70 71 72 /* 73 * Get HCA Device Info Structure, referenced by HCA GUID. 74 */ 75 mutex_enter(&ibtl_clnt_list_mutex); 76 hca_devp = ibtl_get_hcadevinfo(hca_guid); 77 if (hca_devp == NULL) { 78 /* 79 * If we are here, then the requested HCA device is not present. 80 * Return the status as Invalid HCA GUID. 81 */ 82 mutex_exit(&ibtl_clnt_list_mutex); 83 84 IBTF_DPRINTF_L2(ibtf_hca, "ibt_open_hca: " 85 "HCA Device Not Found: Invalid HCA GUID"); 86 87 *hca_hdl_p = NULL; 88 return (IBT_HCA_INVALID); 89 } 90 91 /* 92 * Check whether open is allowed for this dip 93 */ 94 if (ibt_hdl->clnt_dip) { 95 if (ddi_get_parent(ibt_hdl->clnt_dip) == hca_devp->hd_hca_dip) { 96 if (hca_guid != hca_devp->hd_hca_attr->hca_node_guid) { 97 mutex_exit(&ibtl_clnt_list_mutex); 98 return (IBT_FAILURE); 99 } 100 } 101 } 102 103 if (hca_devp->hd_state != IBTL_HCA_DEV_ATTACHED) { 104 /* 105 * If we are here, then the requested HCA device has detached, 106 * or is in the process of detaching. 107 */ 108 mutex_exit(&ibtl_clnt_list_mutex); 109 110 IBTF_DPRINTF_L2(ibtf_hca, "ibt_open_hca: " 111 "HCA is busy trying to detach"); 112 113 *hca_hdl_p = NULL; 114 return (IBT_HCA_BUSY_DETACHING); 115 } 116 117 /* 118 * Yes, we found a HCA Device registered with IBTF, which matches with 119 * the requested HCA_GUID. 120 * 121 * Check out whether this client has already opened this HCA device, 122 * if yes return the status as IBT_HCA_IN_USE. 123 */ 124 hca_infop = hca_devp->hd_clnt_list; 125 126 while (hca_infop != NULL) { 127 if (ibt_hdl == hca_infop->ha_clnt_devp) { 128 IBTF_DPRINTF_L3(ibtf_hca, 129 "ibt_open_hca: Already Open"); 130 131 if (hca_infop->ha_flags & IBTL_HA_CLOSING) { 132 mutex_exit(&ibtl_clnt_list_mutex); 133 *hca_hdl_p = NULL; 134 return (IBT_HCA_BUSY_CLOSING); 135 } 136 mutex_exit(&ibtl_clnt_list_mutex); 137 138 /* Already Opened. Return back old HCA Handle. */ 139 *hca_hdl_p = hca_infop; 140 141 return (IBT_HCA_IN_USE); 142 } 143 hca_infop = hca_infop->ha_clnt_link; 144 } 145 146 /* Create a new HCA Info entity. */ 147 hca_infop = kmem_zalloc(sizeof (ibtl_hca_t), KM_SLEEP); 148 149 /* Update the HCA Info entity */ 150 hca_infop->ha_hca_devp = hca_devp; /* HCA Device Info */ 151 hca_infop->ha_clnt_devp = ibt_hdl; /* Client Info */ 152 153 /* Update the HCA List, to keep track about the clients using it. */ 154 hca_infop->ha_clnt_link = hca_devp->hd_clnt_list; 155 hca_devp->hd_clnt_list = hca_infop; 156 157 158 /* Update the client's list to depict that it uses this HCA device. */ 159 hca_infop->ha_hca_link = ibt_hdl->clnt_hca_list; 160 ibt_hdl->clnt_hca_list = hca_infop; 161 162 mutex_exit(&ibtl_clnt_list_mutex); 163 164 /* 165 * Return back the address of ibtl_hca_t structure as an opaque 166 * IBT HCA handle for the clients, to be used in future calls. 167 */ 168 *hca_hdl_p = hca_infop; 169 170 return (IBT_SUCCESS); 171 } 172 173 static char *ibtl_close_error_fmt = "IBT CLOSE HCA failed: %d '%s' " 174 "resources not yet freed by client '%s'\n"; 175 176 #define IBTL_CLOSE_RESOURCE_CHECK(counter, resource_type) \ 177 if ((cntr = atomic_add_32_nv(&(counter), 0)) != 0) { \ 178 cmn_err(CE_CONT, ibtl_close_error_fmt, \ 179 cntr, resource_type, \ 180 hca_hdl->ha_clnt_devp->clnt_modinfop->mi_clnt_name); \ 181 } \ 182 error |= cntr 183 184 /* 185 * Function: 186 * ibt_close_hca 187 * Input: 188 * hca_hdl - The HCA handle as returned during its open. 189 * Output: 190 * none 191 * Returns: 192 * IBT_SUCCESS 193 * IBT_HCA_HDL_INVALID 194 * IBT_HCA_RESOURCES_NOT_FREED 195 * Description: 196 * Close a HCA. 197 */ 198 ibt_status_t 199 ibt_close_hca(ibt_hca_hdl_t hca_hdl) 200 { 201 ibtl_hca_devinfo_t *hca_devp, *tmp_devp; 202 ibtl_hca_t **hcapp; 203 ibtl_clnt_t *clntp = hca_hdl->ha_clnt_devp; 204 uint32_t cntr, error; 205 206 IBTF_DPRINTF_L3(ibtf_hca, "ibt_close_hca(%p)", hca_hdl); 207 208 /* 209 * Verify the Input HCA Handle, if fake return error as 210 * invalid HCA Handle. 211 */ 212 mutex_enter(&ibtl_clnt_list_mutex); 213 hca_devp = hca_hdl->ha_hca_devp; 214 tmp_devp = ibtl_hca_list; 215 216 for (; tmp_devp != NULL; tmp_devp = tmp_devp->hd_hca_dev_link) 217 if (tmp_devp == hca_devp) 218 break; 219 220 if (tmp_devp == NULL) { 221 mutex_exit(&ibtl_clnt_list_mutex); 222 IBTF_DPRINTF_L2(ibtf_hca, "ibt_close_hca: " 223 "Unable to find this on global HCA list"); 224 return (IBT_HCA_HDL_INVALID); 225 } 226 227 /* Make sure resources have been freed. */ 228 error = 0; 229 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_qp_cnt, "QP/Channel"); 230 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_eec_cnt, "EEC"); 231 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_cq_cnt, "CQ"); 232 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_pd_cnt, "Protection Domain"); 233 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_ah_cnt, "AH"); 234 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_mr_cnt, "Memory Region"); 235 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_mw_cnt, "Memory Window"); 236 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_qpn_cnt, "QPN"); 237 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_srq_cnt, "SRQ"); 238 IBTL_CLOSE_RESOURCE_CHECK(hca_hdl->ha_fmr_pool_cnt, "FMR Pool"); 239 if (error) { 240 mutex_exit(&ibtl_clnt_list_mutex); 241 return (IBT_HCA_RESOURCES_NOT_FREED); 242 } 243 244 /* we are now committed to closing the HCA */ 245 hca_hdl->ha_flags |= IBTL_HA_CLOSING; 246 while (hca_hdl->ha_qpn_cnt > 0) 247 cv_wait(&ibtl_close_hca_cv, &ibtl_clnt_list_mutex); 248 249 /* 250 * Remove this HCA Device entry form Client's current list of HCA 251 * Device Instances being used by it. 252 */ 253 hcapp = &clntp->clnt_hca_list; 254 255 for (; *hcapp != NULL; hcapp = &(*hcapp)->ha_hca_link) 256 if (*hcapp == hca_hdl) 257 break; 258 259 if (*hcapp == NULL) { 260 IBTF_DPRINTF_L2(ibtf_hca, "ibt_close_hca: " 261 "Unable to find this HCA on client list"); 262 mutex_exit(&ibtl_clnt_list_mutex); 263 return (IBT_HCA_HDL_INVALID); 264 } 265 266 /* hcapp now points to a link that points to us */ 267 *hcapp = hca_hdl->ha_hca_link; /* remove us */ 268 269 /* 270 * Remove this Client's entry from this HCA Device's Clients list. 271 */ 272 hcapp = &hca_devp->hd_clnt_list; 273 274 for (; *hcapp != NULL; hcapp = &(*hcapp)->ha_clnt_link) 275 if (*hcapp == hca_hdl) 276 break; 277 278 if (*hcapp == NULL) { 279 mutex_exit(&ibtl_clnt_list_mutex); 280 IBTF_DPRINTF_L2(ibtf_hca, "ibt_close_hca: " 281 "Unable to find this HCA on the client's HCA list"); 282 return (IBT_HCA_HDL_INVALID); 283 } 284 285 /* hcapp now points to a link that points to us */ 286 *hcapp = hca_hdl->ha_clnt_link; /* remove us */ 287 mutex_exit(&ibtl_clnt_list_mutex); 288 289 /* Free memory for this HCA Handle */ 290 ibtl_free_hca_async_check(hca_hdl); 291 292 return (IBT_SUCCESS); 293 } 294 295 void 296 ibtl_close_hca_check(ibt_hca_hdl_t hca_hdl) 297 { 298 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_close_hca_check(%p)", hca_hdl); 299 300 mutex_enter(&ibtl_clnt_list_mutex); 301 if ((--hca_hdl->ha_qpn_cnt == 0) && 302 (hca_hdl->ha_flags & IBTL_HA_CLOSING)) { 303 cv_signal(&ibtl_close_hca_cv); 304 } 305 mutex_exit(&ibtl_clnt_list_mutex); 306 } 307 308 /* 309 * Function: 310 * ibt_get_hca_list 311 * Input: 312 * hca_list_p - Address of pointer updated here. 313 * Output: 314 * hca_list_p - Points to an array of ib_guid_t's allocated here. 315 * Returns: 316 * The actual number of valid ib_guid_t's returned. 317 * Description: 318 * If hca_list_p is not NULL then the memory for the array of GUIDs is 319 * allocated here and should be freed by the caller using 320 * ibt_free_hca_list(). If hca_list_p is NULL then no memory is allocated 321 * by ibt_get_hca_list and only the number of HCAs in a system is returned. 322 */ 323 uint_t 324 ibt_get_hca_list(ib_guid_t **hca_list_p) 325 { 326 uint_t hca_count = 0; 327 ibtl_hca_devinfo_t *hca_devp; 328 ib_guid_t *hca_listp; 329 330 IBTF_DPRINTF_L3(ibtf_hca, "ibt_get_hca_list(%p)", hca_list_p); 331 332 mutex_enter(&ibtl_clnt_list_mutex); 333 334 hca_devp = ibtl_hca_list; 335 while (hca_devp != NULL) { 336 hca_count++; 337 hca_devp = hca_devp->hd_hca_dev_link; 338 } 339 340 if (hca_count == 0) 341 IBTF_DPRINTF_L2(ibtf_hca, "ibt_get_hca_list: " 342 "HCA device not found"); 343 344 if ((hca_count == 0) || (hca_list_p == NULL)) { 345 mutex_exit(&ibtl_clnt_list_mutex); 346 return (hca_count); 347 } 348 349 hca_listp = kmem_alloc(hca_count * sizeof (ib_guid_t), KM_SLEEP); 350 *hca_list_p = hca_listp; 351 352 hca_devp = ibtl_hca_list; 353 while (hca_devp != NULL) { 354 /* Traverse Global HCA List & retrieve HCA Node GUIDs. */ 355 *hca_listp++ = hca_devp->hd_hca_attr->hca_node_guid; 356 hca_devp = hca_devp->hd_hca_dev_link; 357 } 358 mutex_exit(&ibtl_clnt_list_mutex); 359 360 IBTF_DPRINTF_L3(ibtf_hca, "ibt_get_hca_list: " 361 "Returned <%d> entries @0x%p", hca_count, *hca_list_p); 362 363 return (hca_count); 364 } 365 366 /* 367 * Function: 368 * ibt_free_hca_list 369 * Input: 370 * hca_list - The address of an ib_guid_t pointer. 371 * entries - The number of ib_guid_t entries to be freed. 372 * Output: 373 * none. 374 * Returns: 375 * none. 376 * Description: 377 * The memory allocated in ibt_get_hca_list() is freed in this function. 378 */ 379 void 380 ibt_free_hca_list(ib_guid_t *hca_list, uint_t entries) 381 { 382 IBTF_DPRINTF_L3(ibtf_hca, "ibt_free_hca_list: " 383 "Free <%d> entries from 0x%p", entries, hca_list); 384 385 if ((hca_list != NULL) && (entries > 0)) 386 kmem_free(hca_list, entries * sizeof (ib_guid_t)); 387 } 388 389 /* 390 * ibtl_portinfo_locked() is called when the portinfo cache is being 391 * updated. If this port's info update is in progress, we return 0 392 * immediately and have the c 393 * unless it's already in progress (distinguished by return value). 394 * When done updating the portinfo, they call ibtl_portinfo_unlock(). 395 */ 396 397 static int 398 ibtl_portinfo_locked(ibtl_hca_devinfo_t *hca_devp, uint8_t port) 399 { 400 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 401 402 for (;;) { 403 if (hca_devp->hd_portinfo_locked_port == 0) { 404 hca_devp->hd_portinfo_locked_port = port; 405 return (1); /* not busy, so OK to initiate update */ 406 } else if (hca_devp->hd_portinfo_locked_port == port) { 407 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_portinfo_locked: " 408 "HCA %p port %d is already locked", 409 hca_devp, port); 410 hca_devp->hd_portinfo_waiters = 1; 411 cv_wait(&hca_devp->hd_portinfo_cv, 412 &ibtl_clnt_list_mutex); 413 return (0); /* it's now done, so no need to initiate */ 414 } else { 415 /* need to wait for other port before we try again */ 416 hca_devp->hd_portinfo_waiters = 1; 417 cv_wait(&hca_devp->hd_portinfo_cv, 418 &ibtl_clnt_list_mutex); 419 } 420 } 421 } 422 423 static void 424 ibtl_portinfo_unlock(ibtl_hca_devinfo_t *hca_devp, uint8_t port) 425 { 426 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 427 ASSERT(hca_devp->hd_portinfo_locked_port == port); 428 hca_devp->hd_portinfo_locked_port = 0; 429 if (hca_devp->hd_portinfo_waiters) { 430 hca_devp->hd_portinfo_waiters = 0; 431 cv_broadcast(&hca_devp->hd_portinfo_cv); 432 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_portinfo_unlock: " 433 "waking up waiters for port %d info on HCA %p", 434 port, hca_devp); 435 } 436 } 437 438 /* 439 * Function: 440 * ibt_get_port_state 441 * Input: 442 * hca_devp - The HCA Dev Info pointer. 443 * port - Port number to query. 444 * Output: 445 * sgid_p - Returned sgid[0], NULL implies no return value. 446 * base_lid_p - Returned base_lid, NULL implies no return value. 447 * Returns: 448 * IBT_SUCCESS 449 * IBT_HCA_PORT_INVALID 450 * Description: 451 * Returns HCA port attributes for one of the HCA ports. 452 */ 453 static ibt_status_t 454 ibtl_get_port_state(ibtl_hca_devinfo_t *hca_devp, uint8_t port, 455 ib_gid_t *sgid_p, ib_lid_t *base_lid_p) 456 { 457 ibt_hca_portinfo_t *portinfop; 458 459 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 460 461 if ((port < 1) || (port > hca_devp->hd_hca_attr->hca_nports)) { 462 IBTF_DPRINTF_L2(ibtf_hca, "ibtl_get_port_state: " 463 "invalid port %d, nports = %d", port, 464 hca_devp->hd_hca_attr->hca_nports); 465 return (IBT_HCA_PORT_INVALID); 466 } 467 portinfop = hca_devp->hd_portinfop + port - 1; 468 if (portinfop->p_linkstate != IBT_PORT_ACTIVE) 469 ibtl_reinit_hca_portinfo(hca_devp, port); 470 471 if (sgid_p) 472 *sgid_p = portinfop->p_sgid_tbl[0]; 473 if (base_lid_p) 474 *base_lid_p = portinfop->p_base_lid; 475 if (portinfop->p_linkstate != IBT_PORT_ACTIVE) { 476 IBTF_DPRINTF_L2(ibtf_hca, "ibtl_get_port_state: " 477 "port %d, port_state %d, base_lid %d", 478 port, portinfop->p_linkstate, portinfop->p_base_lid); 479 return (IBT_HCA_PORT_NOT_ACTIVE); 480 } 481 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_get_port_state: " 482 "port %d, port_state %d, base_lid %d", 483 port, portinfop->p_linkstate, portinfop->p_base_lid); 484 return (IBT_SUCCESS); 485 } 486 487 /* 488 * Function: 489 * ibt_get_port_state 490 * Input: 491 * hca_hdl - The HCA handle. 492 * port - Port number to query. 493 * Output: 494 * sgid_p - Returned sgid[0], NULL implies no return value. 495 * base_lid_p - Returned base_lid, NULL implies no return value. 496 * Returns: 497 * IBT_SUCCESS 498 * IBT_HCA_PORT_INVALID 499 * Description: 500 * Returns HCA port attributes for one of the HCA ports. 501 */ 502 ibt_status_t 503 ibt_get_port_state(ibt_hca_hdl_t hca_hdl, uint8_t port, 504 ib_gid_t *sgid_p, ib_lid_t *base_lid_p) 505 { 506 ibt_status_t retval; 507 508 IBTF_DPRINTF_L3(ibtf_hca, "ibt_get_port_state(%p, %d, %p, %p)", 509 hca_hdl, port, sgid_p, base_lid_p); 510 mutex_enter(&ibtl_clnt_list_mutex); 511 retval = ibtl_get_port_state(hca_hdl->ha_hca_devp, port, sgid_p, 512 base_lid_p); 513 mutex_exit(&ibtl_clnt_list_mutex); 514 return (retval); 515 } 516 517 518 /* 519 * Function: 520 * ibt_get_port_state_byguid 521 * Input: 522 * hca_guid - The HCA node GUID. 523 * port - Port number to query. 524 * Output: 525 * sgid_p - Returned sgid[0], NULL implies no return value. 526 * base_lid_p - Returned base_lid, NULL implies no return value. 527 * Returns: 528 * IBT_SUCCESS 529 * IBT_HCA_PORT_INVALID 530 * IBT_HCA_INVALID 531 * Description: 532 * Returns HCA port attributes for one of the HCA ports. 533 */ 534 ibt_status_t 535 ibt_get_port_state_byguid(ib_guid_t hca_guid, uint8_t port, 536 ib_gid_t *sgid_p, ib_lid_t *base_lid_p) 537 { 538 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 539 ibt_status_t retval; 540 541 IBTF_DPRINTF_L3(ibtf_hca, "ibt_get_port_state_byguid(%llx, %d, %p, " 542 "%p)", (longlong_t)hca_guid, port, sgid_p, base_lid_p); 543 mutex_enter(&ibtl_clnt_list_mutex); 544 hca_devp = ibtl_get_hcadevinfo(hca_guid); 545 if (hca_devp == NULL) 546 retval = IBT_HCA_INVALID; 547 else 548 retval = ibtl_get_port_state(hca_devp, port, sgid_p, 549 base_lid_p); 550 mutex_exit(&ibtl_clnt_list_mutex); 551 return (retval); 552 } 553 554 555 /* 556 * Function: 557 * ibt_query_hca_byguid 558 * Input: 559 * hca_guid - The HCA node GUID. 560 * Output: 561 * hca_attrs - A pointer to a ibt_hca_attr_t allocated by the caller, 562 * into which the HCA Attributes are copied. 563 * Returns: 564 * IBT_SUCCESS 565 * IBT_INVALID_PARAM 566 * IBT_HCA_INVALID 567 * Description: 568 * Returns the static attributes of the specified HCA. 569 */ 570 ibt_status_t 571 ibt_query_hca_byguid(ib_guid_t hca_guid, ibt_hca_attr_t *hca_attrs) 572 { 573 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info. */ 574 575 IBTF_DPRINTF_L3(ibtf_hca, "ibt_query_hca_byguid(%llX)", hca_guid); 576 577 mutex_enter(&ibtl_clnt_list_mutex); 578 /* Get HCA Dev Info Structure, referenced by HCA GUID. */ 579 hca_devp = ibtl_get_hcadevinfo(hca_guid); 580 if (hca_devp == NULL) { 581 /* 582 * If we are here, then the requested HCA device is not present. 583 */ 584 mutex_exit(&ibtl_clnt_list_mutex); 585 IBTF_DPRINTF_L2(ibtf_hca, "ibt_query_hca_byguid: " 586 "Device Not Found"); 587 return (IBT_HCA_INVALID); 588 } 589 590 /* Return back the static HCA attributes */ 591 bcopy(hca_devp->hd_hca_attr, hca_attrs, sizeof (ibt_hca_attr_t)); 592 593 mutex_exit(&ibtl_clnt_list_mutex); 594 595 return (IBT_SUCCESS); 596 } 597 598 599 /* 600 * Function: 601 * ibt_query_hca 602 * Input: 603 * hca_hdl - The HCA handle. 604 * Output: 605 * hca_attrs - A pointer to a ibt_hca_attr_t allocated by the caller, 606 * into which the HCA Attributes are copied. 607 * Returns: 608 * IBT_SUCCESS 609 * 610 * Description: 611 * Returns the static attributes of the specified HCA. 612 */ 613 ibt_status_t 614 ibt_query_hca(ibt_hca_hdl_t hca_hdl, ibt_hca_attr_t *hca_attrs) 615 { 616 IBTF_DPRINTF_L3(ibtf_hca, "ibt_query_hca(%p)", hca_hdl); 617 618 /* Return back the static HCA attributes */ 619 bcopy(hca_hdl->ha_hca_devp->hd_hca_attr, hca_attrs, 620 sizeof (ibt_hca_attr_t)); 621 622 return (IBT_SUCCESS); 623 } 624 625 #define ROUNDUP(x, y) ((((x)+((y)-1))/(y))*(y)) 626 627 /* 628 * Function: 629 * ibt_query_hca_ports 630 * Input: 631 * hca_hdl - The HCA handle. 632 * port - Port number. If "0", then query ALL Ports. 633 * Output: 634 * port_info_p - The address of a pointer to a ibt_hca_portinfo_t struct. 635 * ports_p - The number of hca ports on the specified HCA. 636 * size_p - Size of the memory allocated by IBTL to get portinfo, 637 * to be freed by calling ibt_free_portinfo(). 638 * Returns: 639 * IBT_SUCCESS 640 * IBT_HCA_HDL_INVALID 641 * IBT_HCA_INVALID 642 * Description: 643 * Returns HCA port attributes for either "one", or "all" of the HCA ports. 644 */ 645 ibt_status_t 646 ibt_query_hca_ports(ibt_hca_hdl_t hca_hdl, uint8_t port, 647 ibt_hca_portinfo_t **port_info_p, uint_t *ports_p, uint_t *size_p) 648 { 649 ibt_status_t retval; 650 651 IBTF_DPRINTF_L3(ibtf_hca, "ibt_query_hca_ports(%p, %d)", 652 hca_hdl, port); 653 654 mutex_enter(&ibtl_clnt_list_mutex); 655 656 retval = ibtl_query_hca_ports(hca_hdl->ha_hca_devp, port, port_info_p, 657 ports_p, size_p, 0); 658 659 mutex_exit(&ibtl_clnt_list_mutex); 660 661 return (retval); 662 } 663 664 /* 665 * Function: 666 * ibt_query_hca_ports_byguid 667 * Input: 668 * hca_guid - The HCA node GUID. 669 * port - Port number. If "0", then query ALL Ports. 670 * Output: 671 * port_info_p - The address of a pointer to a ibt_hca_portinfo_t struct. 672 * ports_p - The number of hca ports on the specified HCA. 673 * size_p - Size of the memory allocated by IBTL to get portinfo, 674 * to be freed by calling ibt_free_portinfo(). 675 * Returns: 676 * IBT_SUCCESS 677 * IBT_HCA_HDL_INVALID 678 * IBT_HCA_INVALID 679 * Description: 680 * Returns HCA port attributes for either "one", or "all" of the HCA ports. 681 */ 682 ibt_status_t 683 ibt_query_hca_ports_byguid(ib_guid_t hca_guid, uint8_t port, 684 ibt_hca_portinfo_t **port_info_p, uint_t *ports_p, uint_t *size_p) 685 { 686 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 687 ibt_status_t retval; 688 689 mutex_enter(&ibtl_clnt_list_mutex); 690 hca_devp = ibtl_get_hcadevinfo(hca_guid); 691 if (hca_devp == NULL) { 692 /* 693 * If we are here, then the requested HCA device is not present. 694 * Return the status as Invalid HCA GUID. 695 */ 696 *ports_p = *size_p = 0; 697 *port_info_p = NULL; 698 mutex_exit(&ibtl_clnt_list_mutex); 699 IBTF_DPRINTF_L2(ibtf_hca, "ibt_query_hca_ports_byguid: " 700 "HCA Device Not Found. "); 701 return (IBT_HCA_INVALID); 702 } 703 704 retval = ibtl_query_hca_ports(hca_devp, port, port_info_p, ports_p, 705 size_p, 0); 706 707 mutex_exit(&ibtl_clnt_list_mutex); 708 709 return (retval); 710 } 711 712 /* 713 * Define the above function for CM's use that uses the cached copy. 714 */ 715 ibt_status_t 716 ibtl_cm_query_hca_ports_byguid(ib_guid_t hca_guid, uint8_t port, 717 ibt_hca_portinfo_t **port_info_p, uint_t *ports_p, uint_t *size_p) 718 { 719 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 720 ibt_status_t retval; 721 722 mutex_enter(&ibtl_clnt_list_mutex); 723 hca_devp = ibtl_get_hcadevinfo(hca_guid); 724 if (hca_devp == NULL) { 725 /* 726 * If we are here, then the requested HCA device is not present. 727 * Return the status as Invalid HCA GUID. 728 */ 729 *ports_p = *size_p = 0; 730 *port_info_p = NULL; 731 mutex_exit(&ibtl_clnt_list_mutex); 732 IBTF_DPRINTF_L2(ibtf_hca, "ibt_query_hca_ports_byguid: " 733 "HCA Device Not Found. "); 734 return (IBT_HCA_INVALID); 735 } 736 737 retval = ibtl_query_hca_ports(hca_devp, port, port_info_p, ports_p, 738 size_p, 1); 739 740 mutex_exit(&ibtl_clnt_list_mutex); 741 742 return (retval); 743 } 744 745 746 /* 747 * ibtl_query_one_port - fill in portinfo for one port. 748 */ 749 static ibt_status_t 750 ibtl_query_one_port(ibtl_hca_devinfo_t *hca_devp, uint8_t port, 751 ibt_hca_portinfo_t **port_info_p, uint_t *ports_p, uint_t *size_p, 752 int use_cache) 753 { 754 ibt_hca_portinfo_t *sp1; /* src */ 755 ibt_hca_portinfo_t *p1; /* dst */ 756 caddr_t p2; 757 uint_t len; 758 uint_t sgid_tbl_len, pkey_tbl_len; 759 760 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 761 762 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_query_one_port(%p, %d)", 763 hca_devp, port); 764 765 if (port > hca_devp->hd_hca_attr->hca_nports) { 766 IBTF_DPRINTF_L2(ibtf_hca, "ibtl_query_one_port: " 767 "invalid port %d", port); 768 return (IBT_HCA_PORT_INVALID); 769 } 770 771 /* If the PORT_UP event is not supported, we need to query */ 772 sp1 = hca_devp->hd_portinfop + port - 1; 773 if (use_cache == 0) 774 ibtl_reinit_hca_portinfo(hca_devp, port); 775 776 *ports_p = 1; 777 778 /* 779 * Calculate how much memory we need for one port, and allocate it. 780 */ 781 sgid_tbl_len = ROUNDUP(sp1->p_sgid_tbl_sz * sizeof (ib_gid_t), 782 _LONG_LONG_ALIGNMENT); 783 pkey_tbl_len = ROUNDUP(sp1->p_pkey_tbl_sz * sizeof (ib_pkey_t), 784 _LONG_LONG_ALIGNMENT); 785 786 len = sizeof (ibt_hca_portinfo_t) + sgid_tbl_len + pkey_tbl_len; 787 *size_p = len; 788 789 p1 = kmem_zalloc(len, KM_SLEEP); 790 *port_info_p = p1; 791 bcopy(sp1, p1, sizeof (ibt_hca_portinfo_t)); 792 793 /* initialize the p_pkey_tbl & p_sgid_tbl pointers. */ 794 p2 = (caddr_t)(p1 + 1); /* pkeys follow the struct ibt_hca_portinfo_s */ 795 bcopy(sp1->p_pkey_tbl, p2, pkey_tbl_len); 796 p1->p_pkey_tbl = (ib_pkey_t *)p2; 797 798 p2 += pkey_tbl_len; /* sgids follow the pkeys */ 799 bcopy(sp1->p_sgid_tbl, p2, sgid_tbl_len); 800 p1->p_sgid_tbl = (ib_gid_t *)p2; 801 802 return (IBT_SUCCESS); 803 } 804 805 /* 806 * ibtl_query_hca_ports - worker routine to get port_info for clients. 807 */ 808 static ibt_status_t 809 ibtl_query_hca_ports(ibtl_hca_devinfo_t *hca_devp, uint8_t port, 810 ibt_hca_portinfo_t **port_info_p, uint_t *ports_p, uint_t *size_p, 811 int use_cache) 812 { 813 ibt_hca_portinfo_t *sp1; /* src */ 814 ibt_hca_portinfo_t *p1; /* dst */ 815 uint_t i, nports; 816 caddr_t p2; 817 uint_t len; 818 uint_t sgid_tbl_len, pkey_tbl_len; 819 820 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 821 822 /* 823 * If user has specified the port num, then query only that port, 824 * else query all ports. 825 */ 826 if (port) 827 return (ibtl_query_one_port(hca_devp, port, port_info_p, 828 ports_p, size_p, use_cache)); 829 830 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_query_hca_ports(%p, ALL)", hca_devp); 831 832 nports = hca_devp->hd_hca_attr->hca_nports; 833 *ports_p = nports; 834 835 /* If the PORT_UP event is not supported, we need to query */ 836 if (use_cache == 0) 837 for (i = 0; i < nports; i++) 838 ibtl_reinit_hca_portinfo(hca_devp, i + 1); 839 840 sp1 = hca_devp->hd_portinfop; 841 842 /* 843 * Calculate how much memory we need for all ports, and allocate it. 844 */ 845 sgid_tbl_len = ROUNDUP(sp1->p_sgid_tbl_sz * sizeof (ib_gid_t), 846 _LONG_LONG_ALIGNMENT); 847 pkey_tbl_len = ROUNDUP(sp1->p_pkey_tbl_sz * sizeof (ib_pkey_t), 848 _LONG_LONG_ALIGNMENT); 849 850 len = (sizeof (ibt_hca_portinfo_t) + sgid_tbl_len + pkey_tbl_len) * 851 nports; 852 *size_p = len; 853 854 ASSERT(len == hca_devp->hd_portinfo_len); 855 856 p1 = kmem_zalloc(len, KM_SLEEP); 857 *port_info_p = p1; 858 bcopy(sp1, p1, len); /* start with an exact copy of our cache */ 859 860 p2 = (caddr_t)(p1 + nports); 861 862 /* For each port, update the p_pkey_tbl & p_sgid_tbl ptrs. */ 863 for (i = 0; i < nports; i++) { 864 p1->p_pkey_tbl = (ib_pkey_t *)p2; 865 p2 += pkey_tbl_len; 866 p1->p_sgid_tbl = (ib_gid_t *)p2; 867 p2 += sgid_tbl_len; 868 p1++; 869 } 870 return (IBT_SUCCESS); 871 } 872 873 /* 874 * Search for a Full pkey. Use the pkey at index 0 if not found. 875 */ 876 static void 877 ibtl_set_default_pkey_ix(ibt_hca_portinfo_t *p1) 878 { 879 uint16_t pkey_ix; 880 881 for (pkey_ix = 0; pkey_ix < p1->p_pkey_tbl_sz; pkey_ix++) { 882 if ((p1->p_pkey_tbl[pkey_ix] & 0x8000) && 883 (p1->p_pkey_tbl[pkey_ix] != IB_PKEY_INVALID_FULL)) { 884 p1->p_def_pkey_ix = pkey_ix; 885 IBTF_DPRINTF_L3(ibtf_hca, 886 "ibtl_set_default_pkey_ix: portinfop %p, " 887 "FULL PKEY 0x%x found, pkey_ix is %d", 888 p1, p1->p_pkey_tbl[pkey_ix], pkey_ix); 889 return; 890 } 891 } 892 IBTF_DPRINTF_L2(ibtf_hca, 893 "ibtl_set_default_pkey_ix: portinfop %p: failed " 894 "to find a default PKEY in the table, using PKey 0x%x", 895 p1, p1->p_pkey_tbl[0]); 896 p1->p_def_pkey_ix = 0; 897 } 898 899 /* 900 * ibtl_reinit_hca_portinfo - update the portinfo cache for use by IBTL. 901 * 902 * We have the HCA driver fill in a temporary portinfo, then we bcopy 903 * it into our cache while holding the appropriate lock. 904 */ 905 void 906 ibtl_reinit_hca_portinfo(ibtl_hca_devinfo_t *hca_devp, uint8_t port) 907 { 908 ibt_status_t status; 909 ibt_hca_portinfo_t *p1, *sp1; 910 ibt_port_state_t old_linkstate; 911 uint_t len, sgid_tbl_len, pkey_tbl_len; 912 ib_pkey_t *saved_pkey_tbl; 913 ib_gid_t *saved_sgid_tbl; 914 ib_sn_prefix_t sn_pfx = 0; 915 uint_t multiSM; 916 int i; 917 918 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_reinit_hca_portinfo(%p, %d)", 919 hca_devp, port); 920 921 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 922 ASSERT(port != 0); 923 924 if (ibtl_portinfo_locked(hca_devp, port)) { 925 /* we got the lock, so we need to do the portinfo update */ 926 927 /* invalidate fast_gid_cache */ 928 ibtl_fast_gid_cache_valid = B_FALSE; 929 930 p1 = hca_devp->hd_portinfop + port - 1; 931 sgid_tbl_len = ROUNDUP(p1->p_sgid_tbl_sz * sizeof (ib_gid_t), 932 _LONG_LONG_ALIGNMENT); 933 pkey_tbl_len = ROUNDUP(p1->p_pkey_tbl_sz * sizeof (ib_pkey_t), 934 _LONG_LONG_ALIGNMENT); 935 len = sizeof (ibt_hca_portinfo_t) + sgid_tbl_len + pkey_tbl_len; 936 937 /* update was NOT in progress, so we do it here */ 938 mutex_exit(&ibtl_clnt_list_mutex); 939 940 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_reinit_hca_portinfo(%p, %d): " 941 "calling ibc_query_hca_ports", hca_devp, port); 942 943 sp1 = kmem_zalloc(len, KM_SLEEP); 944 sp1->p_pkey_tbl = (ib_pkey_t *)(sp1 + 1); 945 sp1->p_sgid_tbl = 946 (ib_gid_t *)((caddr_t)sp1->p_pkey_tbl + pkey_tbl_len); 947 status = IBTL_HDIP2CIHCAOPS_P(hca_devp)->ibc_query_hca_ports( 948 IBTL_HDIP2CIHCA(hca_devp), port, sp1); 949 950 mutex_enter(&ibtl_clnt_list_mutex); 951 if (status != IBT_SUCCESS) { 952 IBTF_DPRINTF_L2(ibtf_hca, 953 "ibtl_reinit_hca_portinfo(%p, %d): " 954 "ibc_query_hca_ports() failed: status = %d", 955 hca_devp, port, status); 956 } else { 957 old_linkstate = p1->p_linkstate; 958 bcopy(sp1->p_pkey_tbl, p1->p_pkey_tbl, pkey_tbl_len); 959 bcopy(sp1->p_sgid_tbl, p1->p_sgid_tbl, sgid_tbl_len); 960 saved_pkey_tbl = p1->p_pkey_tbl; 961 saved_sgid_tbl = p1->p_sgid_tbl; 962 bcopy(sp1, p1, sizeof (ibt_hca_portinfo_t)); 963 p1->p_pkey_tbl = saved_pkey_tbl; 964 p1->p_sgid_tbl = saved_sgid_tbl; 965 if (p1->p_linkstate == IBT_PORT_ACTIVE) { 966 ibtl_set_default_pkey_ix(p1); 967 if (p1->p_linkstate != old_linkstate) 968 IBTF_DPRINTF_L2(ibtf_hca, 969 "ibtl_reinit_hca_portinfo(%p, %d): " 970 "PORT UP", hca_devp, port); 971 } else { 972 if (p1->p_linkstate != IBT_PORT_ARM) 973 p1->p_base_lid = 0; 974 if (p1->p_linkstate != old_linkstate) 975 IBTF_DPRINTF_L2(ibtf_hca, 976 "ibtl_reinit_hca_portinfo(%p, %d): " 977 "PORT DOWN", hca_devp, port); 978 } 979 } 980 kmem_free(sp1, len); 981 982 /* Set multism bit accordingly. */ 983 multiSM = 0; 984 p1 = hca_devp->hd_portinfop; 985 for (i = 0; i < hca_devp->hd_hca_attr->hca_nports; i++) { 986 if (p1->p_linkstate == IBT_PORT_ACTIVE) { 987 if (sn_pfx == 0) { 988 sn_pfx = p1->p_sgid_tbl[0].gid_prefix; 989 } else if (sn_pfx != 990 p1->p_sgid_tbl[0].gid_prefix) { 991 multiSM = 1; 992 IBTF_DPRINTF_L3(ibtf_hca, 993 "ibtl_reinit_hca_portinfo: " 994 "MULTI SM, Port1 SnPfx=0x%llX, " 995 "Port2 SnPfx=0x%llX", sn_pfx, 996 p1->p_sgid_tbl[0].gid_prefix); 997 } 998 } 999 p1++; 1000 } 1001 hca_devp->hd_multism = multiSM; 1002 1003 ibtl_portinfo_unlock(hca_devp, port); 1004 } 1005 } 1006 1007 /* 1008 * ibtl_init_hca_portinfo - fill in the portinfo cache for use by IBTL. 1009 */ 1010 ibt_status_t 1011 ibtl_init_hca_portinfo(ibtl_hca_devinfo_t *hca_devp) 1012 { 1013 ibt_hca_portinfo_t *p1; 1014 ibt_status_t retval; 1015 uint_t i, nports; 1016 caddr_t p2; 1017 uint_t len; 1018 uint_t sgid_tbl_len, pkey_tbl_len; 1019 uint_t sgid_tbl_sz, pkey_tbl_sz; 1020 ib_sn_prefix_t sn_pfx = 0; 1021 uint_t multiSM; 1022 1023 IBTF_DPRINTF_L2(ibtf_hca, "ibtl_init_hca_portinfo(%p)", hca_devp); 1024 1025 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 1026 1027 nports = hca_devp->hd_hca_attr->hca_nports; 1028 1029 /* 1030 * Calculate how much memory we need for all ports, and allocate it. 1031 */ 1032 pkey_tbl_sz = IBTL_HDIP2PKEYTBLSZ(hca_devp); 1033 sgid_tbl_sz = IBTL_HDIP2SGIDTBLSZ(hca_devp); 1034 pkey_tbl_len = ROUNDUP(pkey_tbl_sz * sizeof (ib_pkey_t), 1035 _LONG_LONG_ALIGNMENT); 1036 sgid_tbl_len = ROUNDUP(sgid_tbl_sz * sizeof (ib_gid_t), 1037 _LONG_LONG_ALIGNMENT); 1038 1039 len = (sizeof (ibt_hca_portinfo_t) + sgid_tbl_len + pkey_tbl_len) * 1040 nports; 1041 1042 p1 = kmem_zalloc(len, KM_SLEEP); 1043 p2 = (caddr_t)(p1 + nports); 1044 1045 hca_devp->hd_portinfop = p1; 1046 hca_devp->hd_portinfo_len = len; 1047 1048 /* For each port initialize the p_pkey_tbl & p_sgid_tbl ptrs. */ 1049 for (i = 0; i < nports; i++) { 1050 p1->p_pkey_tbl_sz = pkey_tbl_sz; 1051 p1->p_sgid_tbl_sz = sgid_tbl_sz; 1052 p1->p_pkey_tbl = (ib_pkey_t *)p2; 1053 p2 += pkey_tbl_len; 1054 p1->p_sgid_tbl = (ib_gid_t *)p2; 1055 p2 += sgid_tbl_len; 1056 p1++; 1057 } 1058 p1 = hca_devp->hd_portinfop; 1059 mutex_exit(&ibtl_clnt_list_mutex); 1060 1061 /* re-direct the call to CI's call */ 1062 retval = IBTL_HDIP2CIHCAOPS_P(hca_devp)->ibc_query_hca_ports( 1063 IBTL_HDIP2CIHCA(hca_devp), 0, p1); 1064 1065 mutex_enter(&ibtl_clnt_list_mutex); 1066 if (retval != IBT_SUCCESS) { 1067 IBTF_DPRINTF_L2(ibtf_hca, "ibtl_init_hca_portinfo(%p): " 1068 "ibc_query_hca_ports() failed: status = %d", 1069 hca_devp, retval); 1070 kmem_free(hca_devp->hd_portinfop, len); 1071 hca_devp->hd_portinfop = NULL; 1072 hca_devp->hd_portinfo_len = 0; 1073 return (retval); 1074 } 1075 1076 p1 = hca_devp->hd_portinfop; 1077 multiSM = 0; 1078 for (i = 0; i < nports; i++) { 1079 if (p1->p_linkstate == IBT_PORT_ACTIVE) { 1080 ibtl_set_default_pkey_ix(p1); 1081 if (sn_pfx == 0) { 1082 sn_pfx = p1->p_sgid_tbl[0].gid_prefix; 1083 } else if (p1->p_sgid_tbl[0].gid_prefix != sn_pfx) { 1084 multiSM = 1; 1085 IBTF_DPRINTF_L3(ibtf_hca, 1086 "ibtl_init_hca_portinfo: MULTI SM, " 1087 "Port1 SnPfx=0x%llX, Port2 SnPfx=0x%llX", 1088 sn_pfx, p1->p_sgid_tbl[0].gid_prefix); 1089 } 1090 } else { 1091 if (p1->p_linkstate != IBT_PORT_ARM) 1092 p1->p_base_lid = 0; 1093 } 1094 p1++; 1095 } 1096 hca_devp->hd_multism = multiSM; 1097 1098 return (IBT_SUCCESS); 1099 } 1100 1101 /* 1102 * Function: 1103 * ibt_modify_system_image 1104 * Input: 1105 * hca_hdl - The HCA handle. 1106 * sys_guid - The New system image GUID. 1107 * Description: 1108 * Modify specified HCA's system image GUID. 1109 */ 1110 ibt_status_t 1111 ibt_modify_system_image(ibt_hca_hdl_t hca_hdl, ib_guid_t sys_guid) 1112 { 1113 ibt_status_t retval; 1114 1115 IBTF_DPRINTF_L3(ibtf_hca, "ibt_modify_system_image(%p, %llX)", 1116 hca_hdl, sys_guid); 1117 1118 mutex_enter(&ibtl_clnt_list_mutex); 1119 /* Get HCA Dev Info Structure, referenced by HCA GUID. */ 1120 1121 /* re-direct the call to CI's call */ 1122 retval = IBTL_HCA2CIHCAOPS_P(hca_hdl)->ibc_modify_system_image( 1123 IBTL_HCA2CIHCA(hca_hdl), sys_guid); 1124 1125 mutex_exit(&ibtl_clnt_list_mutex); 1126 return (retval); 1127 } 1128 1129 /* 1130 * Function: 1131 * ibt_modify_system_image_byguid 1132 * 1133 * Input: 1134 * hca_guid - The HCA Node GUID. 1135 * sys_guid - The New system image GUID. 1136 * Description: 1137 * Modify specified HCA's system image GUID. 1138 */ 1139 ibt_status_t 1140 ibt_modify_system_image_byguid(ib_guid_t hca_guid, ib_guid_t sys_guid) 1141 { 1142 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info. */ 1143 ibt_status_t retval; 1144 1145 IBTF_DPRINTF_L3(ibtf_hca, "ibt_modify_system_image_byguid(%llX, %llX)", 1146 hca_guid, sys_guid); 1147 1148 mutex_enter(&ibtl_clnt_list_mutex); 1149 /* Get HCA Dev Info Structure, referenced by HCA GUID. */ 1150 hca_devp = ibtl_get_hcadevinfo(hca_guid); 1151 if (hca_devp == NULL) { 1152 /* 1153 * If we are here, then the requested HCA device is not present. 1154 */ 1155 mutex_exit(&ibtl_clnt_list_mutex); 1156 return (IBT_HCA_INVALID); 1157 } 1158 1159 /* re-direct the call to CI's call */ 1160 retval = IBTL_HDIP2CIHCAOPS_P(hca_devp)->ibc_modify_system_image( 1161 IBTL_HDIP2CIHCA(hca_devp), sys_guid); 1162 1163 mutex_exit(&ibtl_clnt_list_mutex); 1164 return (retval); 1165 } 1166 1167 /* 1168 * Function: 1169 * ibt_modify_port_byguid 1170 * Input: 1171 * hca_guid - The HCA Guid. 1172 * cmds - A pointer to an array of ibt_port_modify_t cmds. The 1173 * pmod_port field specifies the port to modify (all ports if 0) 1174 * and the pmod_flags field specifies which attribute to reset. 1175 * num_cmds - The number of commands in the cmds array. 1176 * Output: 1177 * none. 1178 * Returns: 1179 * IBT_SUCCESS 1180 * IBT_HCA_HDL_INVALID 1181 * IBT_HCA_CNTR_INVALID 1182 * IBT_HCA_CNTR_VAL_INVALID 1183 * Description: 1184 * Reset the specified port, or all ports attribute(s). 1185 */ 1186 ibt_status_t 1187 ibt_modify_port_byguid(ib_guid_t hca_guid, uint8_t port, 1188 ibt_port_modify_flags_t flags, uint8_t init_type) 1189 { 1190 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info. */ 1191 ibt_status_t retval; 1192 1193 IBTF_DPRINTF_L3(ibtf_hca, "ibt_modify_port_byguid(%llX, %d, %X, %X)", 1194 hca_guid, port, flags, init_type); 1195 1196 mutex_enter(&ibtl_clnt_list_mutex); 1197 /* Get HCA Dev Info Structure, referenced by HCA GUID. */ 1198 hca_devp = ibtl_get_hcadevinfo(hca_guid); 1199 if (hca_devp == NULL) { 1200 /* 1201 * If we are here, then the requested HCA device is not present. 1202 */ 1203 mutex_exit(&ibtl_clnt_list_mutex); 1204 return (IBT_HCA_INVALID); 1205 } 1206 1207 /* re-direct the call to CI's call */ 1208 retval = IBTL_HDIP2CIHCAOPS_P(hca_devp)->ibc_modify_ports( 1209 IBTL_HDIP2CIHCA(hca_devp), port, flags, init_type); 1210 1211 mutex_exit(&ibtl_clnt_list_mutex); 1212 return (retval); 1213 } 1214 1215 /* 1216 * Function: 1217 * ibt_modify_port 1218 * Input: 1219 * hca_hdl - The HCA handle. 1220 * cmds - A pointer to an array of ibt_port_modify_t cmds. The 1221 * pmod_port field specifies the port to modify (all ports if 0) 1222 * and the pmod_flags field specifies which attribute to reset. 1223 * num_cmds - The number of commands in the cmds array. 1224 * Output: 1225 * none. 1226 * Returns: 1227 * IBT_SUCCESS 1228 * IBT_HCA_HDL_INVALID 1229 * IBT_HCA_CNTR_INVALID 1230 * IBT_HCA_CNTR_VAL_INVALID 1231 * Description: 1232 * Reset the specified port, or all ports attribute(s). 1233 */ 1234 ibt_status_t 1235 ibt_modify_port(ibt_hca_hdl_t hca_hdl, uint8_t port, 1236 ibt_port_modify_flags_t flags, uint8_t init_type) 1237 1238 { 1239 ibt_status_t retval; 1240 1241 IBTF_DPRINTF_L3(ibtf_hca, "ibt_modify_port(%p, %d, %X, %X)", 1242 hca_hdl, port, flags, init_type); 1243 1244 mutex_enter(&ibtl_clnt_list_mutex); 1245 1246 /* re-direct the call to CI's call */ 1247 retval = IBTL_HCA2CIHCAOPS_P(hca_hdl)->ibc_modify_ports( 1248 IBTL_HCA2CIHCA(hca_hdl), port, flags, init_type); 1249 1250 mutex_exit(&ibtl_clnt_list_mutex); 1251 return (retval); 1252 } 1253 1254 /* 1255 * Function: 1256 * ibt_free_portinfo 1257 * Input: 1258 * port_info - The address of an array to a ibt_hca_portinfo_t struct. 1259 * size - Memory Size as returned from ibt_query_hca_ports(). 1260 * Output: 1261 * none 1262 * Returns: 1263 * none 1264 * Description: 1265 * Frees the memory allocated for a specified ibt_hca_portinfo_t struct. 1266 */ 1267 void 1268 ibt_free_portinfo(ibt_hca_portinfo_t *port_info, uint_t size) 1269 { 1270 IBTF_DPRINTF_L3(ibtf_hca, "ibt_free_portinfo(%p, %d)", 1271 port_info, size); 1272 1273 if ((port_info == NULL) || (size == 0)) { 1274 IBTF_DPRINTF_L2(ibtf_hca, "ibt_free_portinfo: NULL Pointer"); 1275 } else { 1276 kmem_free(port_info, size); 1277 } 1278 } 1279 1280 1281 /* 1282 * Function: 1283 * ibt_get_hcadevinfo 1284 * Input: 1285 * hca_guid - The HCA's node GUID. 1286 * Output: 1287 * none. 1288 * Returns: 1289 * Pointer to HCA Device Info structure whose HCA GUID is requested or NULL 1290 * Description: 1291 * Get a pointer to HCA Device Info Structure for the requested HCA GUID. 1292 * If no matching HCA GUID Device info is found, NULL is returned. 1293 */ 1294 ibtl_hca_devinfo_t * 1295 ibtl_get_hcadevinfo(ib_guid_t hca_guid) 1296 { 1297 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 1298 1299 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_get_hcadevinfo(%llX)", hca_guid); 1300 1301 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 1302 1303 hca_devp = ibtl_hca_list; 1304 1305 /* 1306 * Check whether a HCA device with requested Node GUID is available. 1307 * This is done, by searching the global HCA devinfo list and 1308 * comparing the Node GUID from the device attribute info. 1309 */ 1310 while (hca_devp != NULL) { 1311 if (hca_devp->hd_hca_attr->hca_node_guid == hca_guid) { 1312 /* Match Found. */ 1313 break; 1314 } 1315 hca_devp = hca_devp->hd_hca_dev_link; 1316 } 1317 return (hca_devp); 1318 } 1319 1320 1321 /* 1322 * Function: 1323 * ibtl_pkey2index 1324 * Input: 1325 * hca_devp - The IBTL HCA Device Info. 1326 * port_num - The HCA port number. 1327 * pkey - The input PKey value, whose index we are interested in. 1328 * Output: 1329 * pkey_ix - The PKey index returned for the specified PKey. 1330 * Returns: 1331 * IBT_SUCCESS/IBT_HCA_PORT_INVALID/IBT_INVALID_PARAM 1332 * Description: 1333 * Returns the PKey Index for the specified PKey, the device as specified 1334 * by IBT HCA Handle. 1335 */ 1336 static ibt_status_t 1337 ibtl_pkey2index(ibtl_hca_devinfo_t *hca_devp, uint8_t port_num, 1338 ib_pkey_t pkey, uint16_t *pkey_ix) 1339 { 1340 ibt_hca_portinfo_t *port_infop; 1341 uint_t ports; 1342 uint_t i; 1343 1344 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_pkey2index(%p, %d, %d)", 1345 hca_devp, port_num, pkey); 1346 1347 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 1348 1349 if ((pkey == IB_PKEY_INVALID_FULL) || 1350 (pkey == IB_PKEY_INVALID_LIMITED)) 1351 return (IBT_INVALID_PARAM); 1352 1353 ports = hca_devp->hd_hca_attr->hca_nports; 1354 if ((port_num == 0) || (port_num > ports)) { 1355 IBTF_DPRINTF_L2(ibtf_hca, "ibtl_pkey2index: " 1356 "Invalid port_num %d, range is (1 to %d)", port_num, ports); 1357 return (IBT_HCA_PORT_INVALID); 1358 } 1359 1360 port_infop = hca_devp->hd_portinfop + port_num - 1; 1361 for (i = 0; i < port_infop->p_pkey_tbl_sz; i++) { 1362 if (pkey == port_infop->p_pkey_tbl[i]) { 1363 *pkey_ix = i; 1364 return (IBT_SUCCESS); 1365 } 1366 } 1367 return (IBT_INVALID_PARAM); 1368 } 1369 1370 /* 1371 * Function: 1372 * ibtl_index2pkey 1373 * Input: 1374 * hca_devp - The IBTL HCA Device Info. 1375 * port_num - The HCA port 1376 * pkey_ix - The input PKey index, whose PKey we are interested in. 1377 * Output: 1378 * pkey - The returned PKey value. 1379 * Returns: 1380 * IBT_SUCCESS/IBT_PKEY_IX_ILLEGAL/IBT_PKEY_IX_INVALID/IBT_HCA_PORT_INVALID 1381 * Description: 1382 * Returns the PKey value for the specified PKey index, the device as 1383 * specified by IBT HCA Handle. 1384 */ 1385 static ibt_status_t 1386 ibtl_index2pkey(ibtl_hca_devinfo_t *hca_devp, uint8_t port_num, 1387 uint16_t pkey_ix, ib_pkey_t *pkey) 1388 { 1389 ibt_hca_portinfo_t *port_infop; 1390 uint_t ports; 1391 1392 IBTF_DPRINTF_L3(ibtf_hca, "ibtl_index2pkey(%p, %d, %d)", 1393 hca_devp, port_num, pkey_ix); 1394 1395 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex)); 1396 1397 ports = hca_devp->hd_hca_attr->hca_nports; 1398 if ((port_num == 0) || (port_num > ports)) { 1399 IBTF_DPRINTF_L2(ibtf_hca, "ibtl_index2pkey: " 1400 "Invalid port_num %d, range is (1 to %d)", port_num, ports); 1401 return (IBT_HCA_PORT_INVALID); 1402 } 1403 1404 port_infop = hca_devp->hd_portinfop + port_num - 1; 1405 if (pkey_ix >= port_infop->p_pkey_tbl_sz) { 1406 IBTF_DPRINTF_L2(ibtf_hca, "ibtl_index2pkey: " 1407 "pkey index %d out of range (0, %d)", 1408 pkey_ix, port_infop->p_pkey_tbl_sz - 1); 1409 return (IBT_PKEY_IX_ILLEGAL); 1410 } 1411 1412 *pkey = port_infop->p_pkey_tbl[pkey_ix]; 1413 if ((*pkey == IB_PKEY_INVALID_FULL) || 1414 (*pkey == IB_PKEY_INVALID_LIMITED)) 1415 return (IBT_PKEY_IX_INVALID); 1416 return (IBT_SUCCESS); 1417 } 1418 1419 /* 1420 * Function: 1421 * ibt_pkey2index 1422 * Input: 1423 * hca_hdl - The IBT HCA handle. 1424 * port_num - The HCA port number. 1425 * pkey - The input PKey value, whose index we are interested in. 1426 * Output: 1427 * pkey_ix - The PKey index returned for the specified PKey. 1428 * Returns: 1429 * IBT_SUCCESS/IBT_HCA_PORT_INVALID/IBT_INVALID_PARAM 1430 * Description: 1431 * Returns the PKey Index for the specified PKey, the device as specified 1432 * by IBT HCA Handle. 1433 */ 1434 ibt_status_t 1435 ibt_pkey2index(ibt_hca_hdl_t hca_hdl, uint8_t port_num, ib_pkey_t pkey, 1436 uint16_t *pkey_ix) 1437 { 1438 ibt_status_t retval; 1439 1440 IBTF_DPRINTF_L3(ibtf_hca, "ibt_pkey2index(%p, %d, %d)", 1441 hca_hdl, port_num, pkey); 1442 1443 mutex_enter(&ibtl_clnt_list_mutex); 1444 retval = ibtl_pkey2index(hca_hdl->ha_hca_devp, port_num, pkey, pkey_ix); 1445 mutex_exit(&ibtl_clnt_list_mutex); 1446 1447 return (retval); 1448 } 1449 1450 /* 1451 * Function: 1452 * ibt_pkey2index_byguid 1453 * Input: 1454 * hca_guid - The HCA's node GUID. 1455 * port_num - The HCA port number. 1456 * pkey - The input PKey value, whose index we are interested in. 1457 * Output: 1458 * pkey_ix - The PKey Index returned for the specified PKey. 1459 * Returns: 1460 * IBT_SUCCESS/IBT_HCA_PORT_INVALID/IBT_INVALID_PARAM/IBT_HCA_INVALID 1461 * Description: 1462 * Returns the PKey Index for the specified PKey, the device as specified 1463 * by HCA GUID Info. 1464 */ 1465 ibt_status_t 1466 ibt_pkey2index_byguid(ib_guid_t hca_guid, uint8_t port_num, ib_pkey_t pkey, 1467 uint16_t *pkey_ix) 1468 { 1469 ibt_status_t retval; 1470 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 1471 1472 IBTF_DPRINTF_L3(ibtf_hca, "ibt_pkey2index_byguid(%llX, %d, %d)", 1473 hca_guid, port_num, pkey); 1474 1475 mutex_enter(&ibtl_clnt_list_mutex); 1476 hca_devp = ibtl_get_hcadevinfo(hca_guid); 1477 if (hca_devp == NULL) { 1478 IBTF_DPRINTF_L2(ibtf_hca, "ibt_pkey2index_byguid: " 1479 "Invalid HCA GUID 0x%llx", hca_guid); 1480 mutex_exit(&ibtl_clnt_list_mutex); 1481 return (IBT_HCA_INVALID); 1482 } 1483 retval = ibtl_pkey2index(hca_devp, port_num, pkey, pkey_ix); 1484 mutex_exit(&ibtl_clnt_list_mutex); 1485 1486 return (retval); 1487 } 1488 1489 1490 /* 1491 * Function: 1492 * ibt_index2pkey 1493 * Input: 1494 * hca_hdl - The IBT HCA handle. 1495 * port_num - The HCA port 1496 * pkey_ix - The input PKey index, whose PKey we are interested in. 1497 * Output: 1498 * pkey - The returned PKey value. 1499 * Returns: 1500 * IBT_SUCCESS/IBT_PKEY_IX_ILLEGAL/IBT_PKEY_IX_INVALID/IBT_HCA_PORT_INVALID 1501 * Description: 1502 * Returns the PKey value for the specified PKey index, the device as 1503 * specified by IBT HCA Handle. 1504 */ 1505 ibt_status_t 1506 ibt_index2pkey(ibt_hca_hdl_t hca_hdl, uint8_t port_num, uint16_t pkey_ix, 1507 ib_pkey_t *pkey) 1508 { 1509 ibt_status_t retval; 1510 1511 IBTF_DPRINTF_L3(ibtf_hca, "ibt_index2pkey(%p, %d, %d)", 1512 hca_hdl, port_num, pkey_ix); 1513 1514 mutex_enter(&ibtl_clnt_list_mutex); 1515 retval = ibtl_index2pkey(hca_hdl->ha_hca_devp, port_num, pkey_ix, pkey); 1516 mutex_exit(&ibtl_clnt_list_mutex); 1517 1518 return (retval); 1519 } 1520 1521 /* 1522 * Function: 1523 * ibt_index2pkey_byguid 1524 * Input: 1525 * hca_guid - The HCA's node GUID. 1526 * port_num - The HCA port 1527 * pkey_ix - The input PKey index, whose PKey we are interested in. 1528 * Output: 1529 * pkey - The returned PKey value, for the specified index. 1530 * Returns: 1531 * IBT_SUCCESS/IBT_PKEY_IX_ILLEGAL/IBT_PKEY_IX_INVALID/ 1532 * IBT_HCA_PORT_INVALID/IBT_HCA_INVALID 1533 * Description: 1534 * Returns the PKey Index for the specified PKey, the device as specified 1535 * by HCA GUID Info. 1536 */ 1537 ibt_status_t 1538 ibt_index2pkey_byguid(ib_guid_t hca_guid, uint8_t port_num, uint16_t pkey_ix, 1539 ib_pkey_t *pkey) 1540 { 1541 ibt_status_t retval; 1542 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 1543 1544 IBTF_DPRINTF_L3(ibtf_hca, "ibt_index2pkey_byguid(%llX, %d, %d)", 1545 hca_guid, port_num, pkey_ix); 1546 1547 mutex_enter(&ibtl_clnt_list_mutex); 1548 hca_devp = ibtl_get_hcadevinfo(hca_guid); 1549 if (hca_devp == NULL) { 1550 IBTF_DPRINTF_L2(ibtf_hca, "ibt_index2pkey_byguid: " 1551 "Invalid HCA GUID 0x%llx", hca_guid); 1552 mutex_exit(&ibtl_clnt_list_mutex); 1553 return (IBT_HCA_INVALID); 1554 } 1555 retval = ibtl_index2pkey(hca_devp, port_num, pkey_ix, pkey); 1556 mutex_exit(&ibtl_clnt_list_mutex); 1557 1558 return (retval); 1559 } 1560 1561 1562 _NOTE(SCHEME_PROTECTS_DATA("client managed", ibtl_hca_s::ha_clnt_private)) 1563 1564 /* 1565 * Function: 1566 * ibt_set_hca_private 1567 * Input: 1568 * hca_hdl The ibt_hca_hdl_t of the opened HCA. 1569 * clnt_private The client private data. 1570 * Output: 1571 * none. 1572 * Returns: 1573 * none 1574 * Description: 1575 * Sets the client private data. 1576 */ 1577 void 1578 ibt_set_hca_private(ibt_hca_hdl_t hca_hdl, void *clnt_private) 1579 { 1580 hca_hdl->ha_clnt_private = clnt_private; 1581 } 1582 1583 1584 /* 1585 * Function: 1586 * ibt_get_hca_private 1587 * Input: 1588 * hca_hdl The ibt_hca_hdl_t of the opened HCA. 1589 * Output: 1590 * none 1591 * Returns: 1592 * The client private data. 1593 * Description: 1594 * Retrieves the private data from a specified HCA. 1595 */ 1596 void * 1597 ibt_get_hca_private(ibt_hca_hdl_t hca_hdl) 1598 { 1599 return (hca_hdl->ha_clnt_private); 1600 } 1601 1602 /* 1603 * Function: 1604 * ibt_hca_handle_to_guid 1605 * Input: 1606 * hca HCA Handle. 1607 * Output: 1608 * none. 1609 * Returns: 1610 * hca_guid Returned HCA GUID on which the specified Channel is 1611 * allocated. Valid if it is non-NULL on return. 1612 * Description: 1613 * A helper function to retrieve HCA GUID for the specified handle. 1614 */ 1615 ib_guid_t 1616 ibt_hca_handle_to_guid(ibt_hca_hdl_t hca) 1617 { 1618 IBTF_DPRINTF_L3(ibtf_hca, "ibt_hca_handle_to_guid(%p)", hca); 1619 return (IBTL_HCA2HCAGUID(hca)); 1620 } 1621 1622 /* 1623 * Function: 1624 * ibt_hca_guid_to_handle 1625 * Input: 1626 * ibt_hdl The handle returned to the client by the IBTF from 1627 * an ibt_attach() call. 1628 * hca_guid HCA GUID 1629 * Output: 1630 * hca_hdl Returned ibt_hca_hdl_t. 1631 * Returns: 1632 * IBT_SUCCESS 1633 * IBT_HCA_INVALID 1634 * Description: 1635 * A helper function to retrieve a hca handle from a HCA GUID. 1636 */ 1637 ibt_status_t 1638 ibt_hca_guid_to_handle(ibt_clnt_hdl_t ibt_hdl, ib_guid_t hca_guid, 1639 ibt_hca_hdl_t *hca_hdl) 1640 { 1641 ibtl_hca_t *hca_infop; 1642 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 1643 ibt_status_t rval = IBT_HCA_INVALID; 1644 1645 IBTF_DPRINTF_L3(ibtf_hca, "ibt_hca_guid_to_handle(%p, %llX)", 1646 ibt_hdl, hca_guid); 1647 1648 mutex_enter(&ibtl_clnt_list_mutex); 1649 1650 /* 1651 * Get HCA Device Info Structure, referenced by HCA GUID. 1652 */ 1653 hca_devp = ibtl_get_hcadevinfo(hca_guid); 1654 if (hca_devp == NULL) { 1655 /* 1656 * If we are here, then the requested HCA device is not present. 1657 * Return the status as Invalid HCA GUID. 1658 */ 1659 mutex_exit(&ibtl_clnt_list_mutex); 1660 1661 IBTF_DPRINTF_L2(ibtf_hca, "ibt_hca_guid_to_handle: " 1662 "HCA Device Not Found: Invalid HCA GUID"); 1663 1664 *hca_hdl = NULL; 1665 return (rval); 1666 } 1667 1668 /* 1669 * Yes, we found a HCA Device registered with IBTF, which matches with 1670 * the requested HCA_GUID. 1671 */ 1672 hca_infop = hca_devp->hd_clnt_list; 1673 1674 while (hca_infop != NULL) { 1675 if (ibt_hdl == hca_infop->ha_clnt_devp) { 1676 rval = IBT_SUCCESS; 1677 break; 1678 } 1679 hca_infop = hca_infop->ha_clnt_link; 1680 } 1681 1682 mutex_exit(&ibtl_clnt_list_mutex); 1683 *hca_hdl = hca_infop; 1684 return (rval); 1685 } 1686