1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2021 Broadcom. All Rights Reserved. The term 4 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. 5 */ 6 7 #include "efclib.h" 8 #include "../libefc_sli/sli4.h" 9 #include "efc_cmds.h" 10 #include "efc_sm.h" 11 12 static void 13 efc_nport_free_resources(struct efc_nport *nport, int evt, void *data) 14 { 15 struct efc *efc = nport->efc; 16 17 /* Clear the nport attached flag */ 18 nport->attached = false; 19 20 /* Free the service parameters buffer */ 21 if (nport->dma.virt) { 22 dma_free_coherent(&efc->pci->dev, nport->dma.size, 23 nport->dma.virt, nport->dma.phys); 24 memset(&nport->dma, 0, sizeof(struct efc_dma)); 25 } 26 27 /* Free the SLI resources */ 28 sli_resource_free(efc->sli, SLI4_RSRC_VPI, nport->indicator); 29 30 efc_nport_cb(efc, evt, nport); 31 } 32 33 static int 34 efc_nport_get_mbox_status(struct efc_nport *nport, u8 *mqe, int status) 35 { 36 struct efc *efc = nport->efc; 37 struct sli4_mbox_command_header *hdr = 38 (struct sli4_mbox_command_header *)mqe; 39 40 if (status || le16_to_cpu(hdr->status)) { 41 efc_log_debug(efc, "bad status vpi=%#x st=%x hdr=%x\n", 42 nport->indicator, status, le16_to_cpu(hdr->status)); 43 return -EIO; 44 } 45 46 return 0; 47 } 48 49 static int 50 efc_nport_free_unreg_vpi_cb(struct efc *efc, int status, u8 *mqe, void *arg) 51 { 52 struct efc_nport *nport = arg; 53 int evt = EFC_EVT_NPORT_FREE_OK; 54 int rc; 55 56 rc = efc_nport_get_mbox_status(nport, mqe, status); 57 if (rc) 58 evt = EFC_EVT_NPORT_FREE_FAIL; 59 60 efc_nport_free_resources(nport, evt, mqe); 61 return rc; 62 } 63 64 static void 65 efc_nport_free_unreg_vpi(struct efc_nport *nport) 66 { 67 struct efc *efc = nport->efc; 68 int rc; 69 u8 data[SLI4_BMBX_SIZE]; 70 71 rc = sli_cmd_unreg_vpi(efc->sli, data, nport->indicator, 72 SLI4_UNREG_TYPE_PORT); 73 if (rc) { 74 efc_log_err(efc, "UNREG_VPI format failure\n"); 75 efc_nport_free_resources(nport, EFC_EVT_NPORT_FREE_FAIL, data); 76 return; 77 } 78 79 rc = efc->tt.issue_mbox_rqst(efc->base, data, 80 efc_nport_free_unreg_vpi_cb, nport); 81 if (rc) { 82 efc_log_err(efc, "UNREG_VPI command failure\n"); 83 efc_nport_free_resources(nport, EFC_EVT_NPORT_FREE_FAIL, data); 84 } 85 } 86 87 static void 88 efc_nport_send_evt(struct efc_nport *nport, int evt, void *data) 89 { 90 struct efc *efc = nport->efc; 91 92 /* Now inform the registered callbacks */ 93 efc_nport_cb(efc, evt, nport); 94 95 /* Set the nport attached flag */ 96 if (evt == EFC_EVT_NPORT_ATTACH_OK) 97 nport->attached = true; 98 99 /* If there is a pending free request, then handle it now */ 100 if (nport->free_req_pending) 101 efc_nport_free_unreg_vpi(nport); 102 } 103 104 static int 105 efc_nport_alloc_init_vpi_cb(struct efc *efc, int status, u8 *mqe, void *arg) 106 { 107 struct efc_nport *nport = arg; 108 109 if (efc_nport_get_mbox_status(nport, mqe, status)) { 110 efc_nport_free_resources(nport, EFC_EVT_NPORT_ALLOC_FAIL, mqe); 111 return -EIO; 112 } 113 114 efc_nport_send_evt(nport, EFC_EVT_NPORT_ALLOC_OK, mqe); 115 return 0; 116 } 117 118 static void 119 efc_nport_alloc_init_vpi(struct efc_nport *nport) 120 { 121 struct efc *efc = nport->efc; 122 u8 data[SLI4_BMBX_SIZE]; 123 int rc; 124 125 /* If there is a pending free request, then handle it now */ 126 if (nport->free_req_pending) { 127 efc_nport_free_resources(nport, EFC_EVT_NPORT_FREE_OK, data); 128 return; 129 } 130 131 rc = sli_cmd_init_vpi(efc->sli, data, 132 nport->indicator, nport->domain->indicator); 133 if (rc) { 134 efc_log_err(efc, "INIT_VPI format failure\n"); 135 efc_nport_free_resources(nport, EFC_EVT_NPORT_ALLOC_FAIL, data); 136 return; 137 } 138 139 rc = efc->tt.issue_mbox_rqst(efc->base, data, 140 efc_nport_alloc_init_vpi_cb, nport); 141 if (rc) { 142 efc_log_err(efc, "INIT_VPI command failure\n"); 143 efc_nport_free_resources(nport, EFC_EVT_NPORT_ALLOC_FAIL, data); 144 } 145 } 146 147 static int 148 efc_nport_alloc_read_sparm64_cb(struct efc *efc, int status, u8 *mqe, void *arg) 149 { 150 struct efc_nport *nport = arg; 151 u8 *payload = NULL; 152 153 if (efc_nport_get_mbox_status(nport, mqe, status)) { 154 efc_nport_free_resources(nport, EFC_EVT_NPORT_ALLOC_FAIL, mqe); 155 return -EIO; 156 } 157 158 payload = nport->dma.virt; 159 160 memcpy(&nport->sli_wwpn, payload + SLI4_READ_SPARM64_WWPN_OFFSET, 161 sizeof(nport->sli_wwpn)); 162 memcpy(&nport->sli_wwnn, payload + SLI4_READ_SPARM64_WWNN_OFFSET, 163 sizeof(nport->sli_wwnn)); 164 165 dma_free_coherent(&efc->pci->dev, nport->dma.size, nport->dma.virt, 166 nport->dma.phys); 167 memset(&nport->dma, 0, sizeof(struct efc_dma)); 168 efc_nport_alloc_init_vpi(nport); 169 return 0; 170 } 171 172 static void 173 efc_nport_alloc_read_sparm64(struct efc *efc, struct efc_nport *nport) 174 { 175 u8 data[SLI4_BMBX_SIZE]; 176 int rc; 177 178 /* Allocate memory for the service parameters */ 179 nport->dma.size = EFC_SPARAM_DMA_SZ; 180 nport->dma.virt = dma_alloc_coherent(&efc->pci->dev, 181 nport->dma.size, &nport->dma.phys, 182 GFP_KERNEL); 183 if (!nport->dma.virt) { 184 efc_log_err(efc, "Failed to allocate DMA memory\n"); 185 efc_nport_free_resources(nport, EFC_EVT_NPORT_ALLOC_FAIL, data); 186 return; 187 } 188 189 rc = sli_cmd_read_sparm64(efc->sli, data, 190 &nport->dma, nport->indicator); 191 if (rc) { 192 efc_log_err(efc, "READ_SPARM64 format failure\n"); 193 efc_nport_free_resources(nport, EFC_EVT_NPORT_ALLOC_FAIL, data); 194 return; 195 } 196 197 rc = efc->tt.issue_mbox_rqst(efc->base, data, 198 efc_nport_alloc_read_sparm64_cb, nport); 199 if (rc) { 200 efc_log_err(efc, "READ_SPARM64 command failure\n"); 201 efc_nport_free_resources(nport, EFC_EVT_NPORT_ALLOC_FAIL, data); 202 } 203 } 204 205 int 206 efc_cmd_nport_alloc(struct efc *efc, struct efc_nport *nport, 207 struct efc_domain *domain, u8 *wwpn) 208 { 209 u32 index; 210 211 nport->indicator = U32_MAX; 212 nport->free_req_pending = false; 213 214 if (wwpn) 215 memcpy(&nport->sli_wwpn, wwpn, sizeof(nport->sli_wwpn)); 216 217 /* 218 * allocate a VPI object for the port and stores it in the 219 * indicator field of the port object. 220 */ 221 if (sli_resource_alloc(efc->sli, SLI4_RSRC_VPI, 222 &nport->indicator, &index)) { 223 efc_log_err(efc, "VPI allocation failure\n"); 224 return -EIO; 225 } 226 227 if (domain) { 228 /* 229 * If the WWPN is NULL, fetch the default 230 * WWPN and WWNN before initializing the VPI 231 */ 232 if (!wwpn) 233 efc_nport_alloc_read_sparm64(efc, nport); 234 else 235 efc_nport_alloc_init_vpi(nport); 236 } else if (!wwpn) { 237 /* domain NULL and wwpn non-NULL */ 238 efc_log_err(efc, "need WWN for physical port\n"); 239 sli_resource_free(efc->sli, SLI4_RSRC_VPI, nport->indicator); 240 return -EIO; 241 } 242 243 return 0; 244 } 245 246 static int 247 efc_nport_attach_reg_vpi_cb(struct efc *efc, int status, u8 *mqe, 248 void *arg) 249 { 250 struct efc_nport *nport = arg; 251 252 nport->attaching = false; 253 if (efc_nport_get_mbox_status(nport, mqe, status)) { 254 efc_nport_free_resources(nport, EFC_EVT_NPORT_ATTACH_FAIL, mqe); 255 return -EIO; 256 } 257 258 efc_nport_send_evt(nport, EFC_EVT_NPORT_ATTACH_OK, mqe); 259 return 0; 260 } 261 262 int 263 efc_cmd_nport_attach(struct efc *efc, struct efc_nport *nport, u32 fc_id) 264 { 265 u8 buf[SLI4_BMBX_SIZE]; 266 int rc = 0; 267 268 if (!nport) { 269 efc_log_err(efc, "bad param(s) nport=%p\n", nport); 270 return -EIO; 271 } 272 273 nport->fc_id = fc_id; 274 275 /* register previously-allocated VPI with the device */ 276 rc = sli_cmd_reg_vpi(efc->sli, buf, nport->fc_id, 277 nport->sli_wwpn, nport->indicator, 278 nport->domain->indicator, false); 279 if (rc) { 280 efc_log_err(efc, "REG_VPI format failure\n"); 281 efc_nport_free_resources(nport, EFC_EVT_NPORT_ATTACH_FAIL, buf); 282 return rc; 283 } 284 285 rc = efc->tt.issue_mbox_rqst(efc->base, buf, 286 efc_nport_attach_reg_vpi_cb, nport); 287 if (rc) { 288 efc_log_err(efc, "REG_VPI command failure\n"); 289 efc_nport_free_resources(nport, EFC_EVT_NPORT_ATTACH_FAIL, buf); 290 } else { 291 nport->attaching = true; 292 } 293 294 return rc; 295 } 296 297 int 298 efc_cmd_nport_free(struct efc *efc, struct efc_nport *nport) 299 { 300 if (!nport) { 301 efc_log_err(efc, "bad parameter(s) nport=%p\n", nport); 302 return -EIO; 303 } 304 305 /* Issue the UNREG_VPI command to free the assigned VPI context */ 306 if (nport->attached) 307 efc_nport_free_unreg_vpi(nport); 308 else if (nport->attaching) 309 nport->free_req_pending = true; 310 else 311 efc_sm_post_event(&nport->sm, EFC_EVT_NPORT_FREE_OK, NULL); 312 313 return 0; 314 } 315 316 static int 317 efc_domain_get_mbox_status(struct efc_domain *domain, u8 *mqe, int status) 318 { 319 struct efc *efc = domain->efc; 320 struct sli4_mbox_command_header *hdr = 321 (struct sli4_mbox_command_header *)mqe; 322 323 if (status || le16_to_cpu(hdr->status)) { 324 efc_log_debug(efc, "bad status vfi=%#x st=%x hdr=%x\n", 325 domain->indicator, status, 326 le16_to_cpu(hdr->status)); 327 return -EIO; 328 } 329 330 return 0; 331 } 332 333 static void 334 efc_domain_free_resources(struct efc_domain *domain, int evt, void *data) 335 { 336 struct efc *efc = domain->efc; 337 338 /* Free the service parameters buffer */ 339 if (domain->dma.virt) { 340 dma_free_coherent(&efc->pci->dev, 341 domain->dma.size, domain->dma.virt, 342 domain->dma.phys); 343 memset(&domain->dma, 0, sizeof(struct efc_dma)); 344 } 345 346 /* Free the SLI resources */ 347 sli_resource_free(efc->sli, SLI4_RSRC_VFI, domain->indicator); 348 349 efc_domain_cb(efc, evt, domain); 350 } 351 352 static void 353 efc_domain_send_nport_evt(struct efc_domain *domain, 354 int port_evt, int domain_evt, void *data) 355 { 356 struct efc *efc = domain->efc; 357 358 /* Send alloc/attach ok to the physical nport */ 359 efc_nport_send_evt(domain->nport, port_evt, NULL); 360 361 /* Now inform the registered callbacks */ 362 efc_domain_cb(efc, domain_evt, domain); 363 } 364 365 static int 366 efc_domain_alloc_read_sparm64_cb(struct efc *efc, int status, u8 *mqe, 367 void *arg) 368 { 369 struct efc_domain *domain = arg; 370 371 if (efc_domain_get_mbox_status(domain, mqe, status)) { 372 efc_domain_free_resources(domain, 373 EFC_HW_DOMAIN_ALLOC_FAIL, mqe); 374 return -EIO; 375 } 376 377 efc_domain_send_nport_evt(domain, EFC_EVT_NPORT_ALLOC_OK, 378 EFC_HW_DOMAIN_ALLOC_OK, mqe); 379 return 0; 380 } 381 382 static void 383 efc_domain_alloc_read_sparm64(struct efc_domain *domain) 384 { 385 struct efc *efc = domain->efc; 386 u8 data[SLI4_BMBX_SIZE]; 387 int rc; 388 389 rc = sli_cmd_read_sparm64(efc->sli, data, &domain->dma, 0); 390 if (rc) { 391 efc_log_err(efc, "READ_SPARM64 format failure\n"); 392 efc_domain_free_resources(domain, 393 EFC_HW_DOMAIN_ALLOC_FAIL, data); 394 return; 395 } 396 397 rc = efc->tt.issue_mbox_rqst(efc->base, data, 398 efc_domain_alloc_read_sparm64_cb, domain); 399 if (rc) { 400 efc_log_err(efc, "READ_SPARM64 command failure\n"); 401 efc_domain_free_resources(domain, 402 EFC_HW_DOMAIN_ALLOC_FAIL, data); 403 } 404 } 405 406 static int 407 efc_domain_alloc_init_vfi_cb(struct efc *efc, int status, u8 *mqe, 408 void *arg) 409 { 410 struct efc_domain *domain = arg; 411 412 if (efc_domain_get_mbox_status(domain, mqe, status)) { 413 efc_domain_free_resources(domain, 414 EFC_HW_DOMAIN_ALLOC_FAIL, mqe); 415 return -EIO; 416 } 417 418 efc_domain_alloc_read_sparm64(domain); 419 return 0; 420 } 421 422 static void 423 efc_domain_alloc_init_vfi(struct efc_domain *domain) 424 { 425 struct efc *efc = domain->efc; 426 struct efc_nport *nport = domain->nport; 427 u8 data[SLI4_BMBX_SIZE]; 428 int rc; 429 430 /* 431 * For FC, the HW alread registered an FCFI. 432 * Copy FCF information into the domain and jump to INIT_VFI. 433 */ 434 domain->fcf_indicator = efc->fcfi; 435 rc = sli_cmd_init_vfi(efc->sli, data, domain->indicator, 436 domain->fcf_indicator, nport->indicator); 437 if (rc) { 438 efc_log_err(efc, "INIT_VFI format failure\n"); 439 efc_domain_free_resources(domain, 440 EFC_HW_DOMAIN_ALLOC_FAIL, data); 441 return; 442 } 443 444 efc_log_err(efc, "%s issue mbox\n", __func__); 445 rc = efc->tt.issue_mbox_rqst(efc->base, data, 446 efc_domain_alloc_init_vfi_cb, domain); 447 if (rc) { 448 efc_log_err(efc, "INIT_VFI command failure\n"); 449 efc_domain_free_resources(domain, 450 EFC_HW_DOMAIN_ALLOC_FAIL, data); 451 } 452 } 453 454 int 455 efc_cmd_domain_alloc(struct efc *efc, struct efc_domain *domain, u32 fcf) 456 { 457 u32 index; 458 459 if (!domain || !domain->nport) { 460 efc_log_err(efc, "bad parameter(s) domain=%p nport=%p\n", 461 domain, domain ? domain->nport : NULL); 462 return -EIO; 463 } 464 465 /* allocate memory for the service parameters */ 466 domain->dma.size = EFC_SPARAM_DMA_SZ; 467 domain->dma.virt = dma_alloc_coherent(&efc->pci->dev, 468 domain->dma.size, 469 &domain->dma.phys, GFP_KERNEL); 470 if (!domain->dma.virt) { 471 efc_log_err(efc, "Failed to allocate DMA memory\n"); 472 return -EIO; 473 } 474 475 domain->fcf = fcf; 476 domain->fcf_indicator = U32_MAX; 477 domain->indicator = U32_MAX; 478 479 if (sli_resource_alloc(efc->sli, SLI4_RSRC_VFI, &domain->indicator, 480 &index)) { 481 efc_log_err(efc, "VFI allocation failure\n"); 482 483 dma_free_coherent(&efc->pci->dev, 484 domain->dma.size, domain->dma.virt, 485 domain->dma.phys); 486 memset(&domain->dma, 0, sizeof(struct efc_dma)); 487 488 return -EIO; 489 } 490 491 efc_domain_alloc_init_vfi(domain); 492 return 0; 493 } 494 495 static int 496 efc_domain_attach_reg_vfi_cb(struct efc *efc, int status, u8 *mqe, 497 void *arg) 498 { 499 struct efc_domain *domain = arg; 500 501 if (efc_domain_get_mbox_status(domain, mqe, status)) { 502 efc_domain_free_resources(domain, 503 EFC_HW_DOMAIN_ATTACH_FAIL, mqe); 504 return -EIO; 505 } 506 507 efc_domain_send_nport_evt(domain, EFC_EVT_NPORT_ATTACH_OK, 508 EFC_HW_DOMAIN_ATTACH_OK, mqe); 509 return 0; 510 } 511 512 int 513 efc_cmd_domain_attach(struct efc *efc, struct efc_domain *domain, u32 fc_id) 514 { 515 u8 buf[SLI4_BMBX_SIZE]; 516 int rc = 0; 517 518 if (!domain) { 519 efc_log_err(efc, "bad param(s) domain=%p\n", domain); 520 return -EIO; 521 } 522 523 domain->nport->fc_id = fc_id; 524 525 rc = sli_cmd_reg_vfi(efc->sli, buf, SLI4_BMBX_SIZE, domain->indicator, 526 domain->fcf_indicator, domain->dma, 527 domain->nport->indicator, domain->nport->sli_wwpn, 528 domain->nport->fc_id); 529 if (rc) { 530 efc_log_err(efc, "REG_VFI format failure\n"); 531 goto cleanup; 532 } 533 534 rc = efc->tt.issue_mbox_rqst(efc->base, buf, 535 efc_domain_attach_reg_vfi_cb, domain); 536 if (rc) { 537 efc_log_err(efc, "REG_VFI command failure\n"); 538 goto cleanup; 539 } 540 541 return rc; 542 543 cleanup: 544 efc_domain_free_resources(domain, EFC_HW_DOMAIN_ATTACH_FAIL, buf); 545 546 return rc; 547 } 548 549 static int 550 efc_domain_free_unreg_vfi_cb(struct efc *efc, int status, u8 *mqe, void *arg) 551 { 552 struct efc_domain *domain = arg; 553 int evt = EFC_HW_DOMAIN_FREE_OK; 554 int rc; 555 556 rc = efc_domain_get_mbox_status(domain, mqe, status); 557 if (rc) { 558 evt = EFC_HW_DOMAIN_FREE_FAIL; 559 rc = -EIO; 560 } 561 562 efc_domain_free_resources(domain, evt, mqe); 563 return rc; 564 } 565 566 static void 567 efc_domain_free_unreg_vfi(struct efc_domain *domain) 568 { 569 struct efc *efc = domain->efc; 570 int rc; 571 u8 data[SLI4_BMBX_SIZE]; 572 573 rc = sli_cmd_unreg_vfi(efc->sli, data, domain->indicator, 574 SLI4_UNREG_TYPE_DOMAIN); 575 if (rc) { 576 efc_log_err(efc, "UNREG_VFI format failure\n"); 577 goto cleanup; 578 } 579 580 rc = efc->tt.issue_mbox_rqst(efc->base, data, 581 efc_domain_free_unreg_vfi_cb, domain); 582 if (rc) { 583 efc_log_err(efc, "UNREG_VFI command failure\n"); 584 goto cleanup; 585 } 586 587 return; 588 589 cleanup: 590 efc_domain_free_resources(domain, EFC_HW_DOMAIN_FREE_FAIL, data); 591 } 592 593 int 594 efc_cmd_domain_free(struct efc *efc, struct efc_domain *domain) 595 { 596 if (!domain) { 597 efc_log_err(efc, "bad parameter(s) domain=%p\n", domain); 598 return -EIO; 599 } 600 601 efc_domain_free_unreg_vfi(domain); 602 return 0; 603 } 604 605 int 606 efc_cmd_node_alloc(struct efc *efc, struct efc_remote_node *rnode, u32 fc_addr, 607 struct efc_nport *nport) 608 { 609 /* Check for invalid indicator */ 610 if (rnode->indicator != U32_MAX) { 611 efc_log_err(efc, 612 "RPI allocation failure addr=%#x rpi=%#x\n", 613 fc_addr, rnode->indicator); 614 return -EIO; 615 } 616 617 /* NULL SLI port indicates an unallocated remote node */ 618 rnode->nport = NULL; 619 620 if (sli_resource_alloc(efc->sli, SLI4_RSRC_RPI, 621 &rnode->indicator, &rnode->index)) { 622 efc_log_err(efc, "RPI allocation failure addr=%#x\n", 623 fc_addr); 624 return -EIO; 625 } 626 627 rnode->fc_id = fc_addr; 628 rnode->nport = nport; 629 630 return 0; 631 } 632 633 static int 634 efc_cmd_node_attach_cb(struct efc *efc, int status, u8 *mqe, void *arg) 635 { 636 struct efc_remote_node *rnode = arg; 637 struct sli4_mbox_command_header *hdr = 638 (struct sli4_mbox_command_header *)mqe; 639 int evt = 0; 640 641 if (status || le16_to_cpu(hdr->status)) { 642 efc_log_debug(efc, "bad status cqe=%#x mqe=%#x\n", status, 643 le16_to_cpu(hdr->status)); 644 rnode->attached = false; 645 evt = EFC_EVT_NODE_ATTACH_FAIL; 646 } else { 647 rnode->attached = true; 648 evt = EFC_EVT_NODE_ATTACH_OK; 649 } 650 651 efc_remote_node_cb(efc, evt, rnode); 652 653 return 0; 654 } 655 656 int 657 efc_cmd_node_attach(struct efc *efc, struct efc_remote_node *rnode, 658 struct efc_dma *sparms) 659 { 660 int rc = -EIO; 661 u8 buf[SLI4_BMBX_SIZE]; 662 663 if (!rnode || !sparms) { 664 efc_log_err(efc, "bad parameter(s) rnode=%p sparms=%p\n", 665 rnode, sparms); 666 return -EIO; 667 } 668 669 /* 670 * If the attach count is non-zero, this RPI has already been reg'd. 671 * Otherwise, register the RPI 672 */ 673 if (rnode->index == U32_MAX) { 674 efc_log_err(efc, "bad parameter rnode->index invalid\n"); 675 return -EIO; 676 } 677 678 /* Update a remote node object with the remote port's service params */ 679 if (!sli_cmd_reg_rpi(efc->sli, buf, rnode->indicator, 680 rnode->nport->indicator, rnode->fc_id, sparms, 0, 0)) 681 rc = efc->tt.issue_mbox_rqst(efc->base, buf, 682 efc_cmd_node_attach_cb, rnode); 683 684 return rc; 685 } 686 687 int 688 efc_node_free_resources(struct efc *efc, struct efc_remote_node *rnode) 689 { 690 int rc = 0; 691 692 if (!rnode) { 693 efc_log_err(efc, "bad parameter rnode=%p\n", rnode); 694 return -EIO; 695 } 696 697 if (rnode->nport) { 698 if (rnode->attached) { 699 efc_log_err(efc, "rnode is still attached\n"); 700 return -EIO; 701 } 702 if (rnode->indicator != U32_MAX) { 703 if (sli_resource_free(efc->sli, SLI4_RSRC_RPI, 704 rnode->indicator)) { 705 efc_log_err(efc, 706 "RPI free fail RPI %d addr=%#x\n", 707 rnode->indicator, rnode->fc_id); 708 rc = -EIO; 709 } else { 710 rnode->indicator = U32_MAX; 711 rnode->index = U32_MAX; 712 } 713 } 714 } 715 716 return rc; 717 } 718 719 static int 720 efc_cmd_node_free_cb(struct efc *efc, int status, u8 *mqe, void *arg) 721 { 722 struct efc_remote_node *rnode = arg; 723 struct sli4_mbox_command_header *hdr = 724 (struct sli4_mbox_command_header *)mqe; 725 int evt = EFC_EVT_NODE_FREE_FAIL; 726 int rc = 0; 727 728 if (status || le16_to_cpu(hdr->status)) { 729 efc_log_debug(efc, "bad status cqe=%#x mqe=%#x\n", status, 730 le16_to_cpu(hdr->status)); 731 732 /* 733 * In certain cases, a non-zero MQE status is OK (all must be 734 * true): 735 * - node is attached 736 * - status is 0x1400 737 */ 738 if (!rnode->attached || 739 (le16_to_cpu(hdr->status) != SLI4_MBX_STATUS_RPI_NOT_REG)) 740 rc = -EIO; 741 } 742 743 if (!rc) { 744 rnode->attached = false; 745 evt = EFC_EVT_NODE_FREE_OK; 746 } 747 748 efc_remote_node_cb(efc, evt, rnode); 749 750 return rc; 751 } 752 753 int 754 efc_cmd_node_detach(struct efc *efc, struct efc_remote_node *rnode) 755 { 756 u8 buf[SLI4_BMBX_SIZE]; 757 int rc = -EIO; 758 759 if (!rnode) { 760 efc_log_err(efc, "bad parameter rnode=%p\n", rnode); 761 return -EIO; 762 } 763 764 if (rnode->nport) { 765 if (!rnode->attached) 766 return -EIO; 767 768 rc = -EIO; 769 770 if (!sli_cmd_unreg_rpi(efc->sli, buf, rnode->indicator, 771 SLI4_RSRC_RPI, U32_MAX)) 772 rc = efc->tt.issue_mbox_rqst(efc->base, buf, 773 efc_cmd_node_free_cb, rnode); 774 775 if (rc != 0) { 776 efc_log_err(efc, "UNREG_RPI failed\n"); 777 rc = -EIO; 778 } 779 } 780 781 return rc; 782 } 783