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 /* 8 * Functions to build and send ELS/CT/BLS commands and responses. 9 */ 10 11 #include "efc.h" 12 #include "efc_els.h" 13 #include "../libefc_sli/sli4.h" 14 15 #define EFC_LOG_ENABLE_ELS_TRACE(efc) \ 16 (((efc) != NULL) ? (((efc)->logmask & (1U << 1)) != 0) : 0) 17 18 #define node_els_trace() \ 19 do { \ 20 if (EFC_LOG_ENABLE_ELS_TRACE(efc)) \ 21 efc_log_info(efc, "[%s] %-20s\n", \ 22 node->display_name, __func__); \ 23 } while (0) 24 25 #define els_io_printf(els, fmt, ...) \ 26 efc_log_err((struct efc *)els->node->efc,\ 27 "[%s] %-8s " fmt, \ 28 els->node->display_name,\ 29 els->display_name, ##__VA_ARGS__) 30 31 #define EFC_ELS_RSP_LEN 1024 32 #define EFC_ELS_GID_PT_RSP_LEN 8096 33 34 struct efc_els_io_req * 35 efc_els_io_alloc(struct efc_node *node, u32 reqlen) 36 { 37 return efc_els_io_alloc_size(node, reqlen, EFC_ELS_RSP_LEN); 38 } 39 40 struct efc_els_io_req * 41 efc_els_io_alloc_size(struct efc_node *node, u32 reqlen, u32 rsplen) 42 { 43 struct efc *efc; 44 struct efc_els_io_req *els; 45 unsigned long flags = 0; 46 47 efc = node->efc; 48 49 if (!node->els_io_enabled) { 50 efc_log_err(efc, "els io alloc disabled\n"); 51 return NULL; 52 } 53 54 els = mempool_alloc(efc->els_io_pool, GFP_ATOMIC); 55 if (!els) { 56 atomic_add_return(1, &efc->els_io_alloc_failed_count); 57 return NULL; 58 } 59 60 /* initialize refcount */ 61 kref_init(&els->ref); 62 els->release = _efc_els_io_free; 63 64 /* populate generic io fields */ 65 els->node = node; 66 67 /* now allocate DMA for request and response */ 68 els->io.req.size = reqlen; 69 els->io.req.virt = dma_alloc_coherent(&efc->pci->dev, els->io.req.size, 70 &els->io.req.phys, GFP_KERNEL); 71 if (!els->io.req.virt) { 72 mempool_free(els, efc->els_io_pool); 73 return NULL; 74 } 75 76 els->io.rsp.size = rsplen; 77 els->io.rsp.virt = dma_alloc_coherent(&efc->pci->dev, els->io.rsp.size, 78 &els->io.rsp.phys, GFP_KERNEL); 79 if (!els->io.rsp.virt) { 80 dma_free_coherent(&efc->pci->dev, els->io.req.size, 81 els->io.req.virt, els->io.req.phys); 82 mempool_free(els, efc->els_io_pool); 83 els = NULL; 84 } 85 86 if (els) { 87 /* initialize fields */ 88 els->els_retries_remaining = EFC_FC_ELS_DEFAULT_RETRIES; 89 90 /* add els structure to ELS IO list */ 91 INIT_LIST_HEAD(&els->list_entry); 92 spin_lock_irqsave(&node->els_ios_lock, flags); 93 list_add_tail(&els->list_entry, &node->els_ios_list); 94 spin_unlock_irqrestore(&node->els_ios_lock, flags); 95 } 96 97 return els; 98 } 99 100 void 101 efc_els_io_free(struct efc_els_io_req *els) 102 { 103 kref_put(&els->ref, els->release); 104 } 105 106 void 107 _efc_els_io_free(struct kref *arg) 108 { 109 struct efc_els_io_req *els = 110 container_of(arg, struct efc_els_io_req, ref); 111 struct efc *efc; 112 struct efc_node *node; 113 int send_empty_event = false; 114 unsigned long flags = 0; 115 116 node = els->node; 117 efc = node->efc; 118 119 spin_lock_irqsave(&node->els_ios_lock, flags); 120 121 list_del(&els->list_entry); 122 /* Send list empty event if the IO allocator 123 * is disabled, and the list is empty 124 * If node->els_io_enabled was not checked, 125 * the event would be posted continually 126 */ 127 send_empty_event = (!node->els_io_enabled && 128 list_empty(&node->els_ios_list)); 129 130 spin_unlock_irqrestore(&node->els_ios_lock, flags); 131 132 /* free ELS request and response buffers */ 133 dma_free_coherent(&efc->pci->dev, els->io.rsp.size, 134 els->io.rsp.virt, els->io.rsp.phys); 135 dma_free_coherent(&efc->pci->dev, els->io.req.size, 136 els->io.req.virt, els->io.req.phys); 137 138 mempool_free(els, efc->els_io_pool); 139 140 if (send_empty_event) 141 efc_scsi_io_list_empty(node->efc, node); 142 } 143 144 static void 145 efc_els_retry(struct efc_els_io_req *els); 146 147 static void 148 efc_els_delay_timer_cb(struct timer_list *t) 149 { 150 struct efc_els_io_req *els = from_timer(els, t, delay_timer); 151 152 /* Retry delay timer expired, retry the ELS request */ 153 efc_els_retry(els); 154 } 155 156 static int 157 efc_els_req_cb(void *arg, u32 length, int status, u32 ext_status) 158 { 159 struct efc_els_io_req *els; 160 struct efc_node *node; 161 struct efc *efc; 162 struct efc_node_cb cbdata; 163 u32 reason_code; 164 165 els = arg; 166 node = els->node; 167 efc = node->efc; 168 169 if (status) 170 els_io_printf(els, "status x%x ext x%x\n", status, ext_status); 171 172 /* set the response len element of els->rsp */ 173 els->io.rsp.len = length; 174 175 cbdata.status = status; 176 cbdata.ext_status = ext_status; 177 cbdata.header = NULL; 178 cbdata.els_rsp = els->io.rsp; 179 180 /* set the response len element of els->rsp */ 181 cbdata.rsp_len = length; 182 183 /* FW returns the number of bytes received on the link in 184 * the WCQE, not the amount placed in the buffer; use this info to 185 * check if there was an overrun. 186 */ 187 if (length > els->io.rsp.size) { 188 efc_log_warn(efc, 189 "ELS response returned len=%d > buflen=%zu\n", 190 length, els->io.rsp.size); 191 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_REQ_FAIL, &cbdata); 192 return 0; 193 } 194 195 /* Post event to ELS IO object */ 196 switch (status) { 197 case SLI4_FC_WCQE_STATUS_SUCCESS: 198 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_REQ_OK, &cbdata); 199 break; 200 201 case SLI4_FC_WCQE_STATUS_LS_RJT: 202 reason_code = (ext_status >> 16) & 0xff; 203 204 /* delay and retry if reason code is Logical Busy */ 205 switch (reason_code) { 206 case ELS_RJT_BUSY: 207 els->node->els_req_cnt--; 208 els_io_printf(els, 209 "LS_RJT Logical Busy, delay and retry\n"); 210 timer_setup(&els->delay_timer, 211 efc_els_delay_timer_cb, 0); 212 mod_timer(&els->delay_timer, 213 jiffies + msecs_to_jiffies(5000)); 214 break; 215 default: 216 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_REQ_RJT, 217 &cbdata); 218 break; 219 } 220 break; 221 222 case SLI4_FC_WCQE_STATUS_LOCAL_REJECT: 223 switch (ext_status) { 224 case SLI4_FC_LOCAL_REJECT_SEQUENCE_TIMEOUT: 225 efc_els_retry(els); 226 break; 227 default: 228 efc_log_err(efc, "LOCAL_REJECT with ext status:%x\n", 229 ext_status); 230 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_REQ_FAIL, 231 &cbdata); 232 break; 233 } 234 break; 235 default: /* Other error */ 236 efc_log_warn(efc, "els req failed status x%x, ext_status x%x\n", 237 status, ext_status); 238 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_REQ_FAIL, &cbdata); 239 break; 240 } 241 242 return 0; 243 } 244 245 void efc_disc_io_complete(struct efc_disc_io *io, u32 len, u32 status, 246 u32 ext_status) 247 { 248 struct efc_els_io_req *els = 249 container_of(io, struct efc_els_io_req, io); 250 251 WARN_ON_ONCE(!els->cb); 252 253 ((efc_hw_srrs_cb_t)els->cb) (els, len, status, ext_status); 254 } 255 256 static int efc_els_send_req(struct efc_node *node, struct efc_els_io_req *els, 257 enum efc_disc_io_type io_type) 258 { 259 int rc = 0; 260 struct efc *efc = node->efc; 261 struct efc_node_cb cbdata; 262 263 /* update ELS request counter */ 264 els->node->els_req_cnt++; 265 266 /* Prepare the IO request details */ 267 els->io.io_type = io_type; 268 els->io.xmit_len = els->io.req.size; 269 els->io.rsp_len = els->io.rsp.size; 270 els->io.rpi = node->rnode.indicator; 271 els->io.vpi = node->nport->indicator; 272 els->io.s_id = node->nport->fc_id; 273 els->io.d_id = node->rnode.fc_id; 274 275 if (node->rnode.attached) 276 els->io.rpi_registered = true; 277 278 els->cb = efc_els_req_cb; 279 280 rc = efc->tt.send_els(efc, &els->io); 281 if (!rc) 282 return rc; 283 284 cbdata.status = EFC_STATUS_INVALID; 285 cbdata.ext_status = EFC_STATUS_INVALID; 286 cbdata.els_rsp = els->io.rsp; 287 efc_log_err(efc, "efc_els_send failed: %d\n", rc); 288 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_REQ_FAIL, &cbdata); 289 290 return rc; 291 } 292 293 static void 294 efc_els_retry(struct efc_els_io_req *els) 295 { 296 struct efc *efc; 297 struct efc_node_cb cbdata; 298 u32 rc; 299 300 efc = els->node->efc; 301 cbdata.status = EFC_STATUS_INVALID; 302 cbdata.ext_status = EFC_STATUS_INVALID; 303 cbdata.els_rsp = els->io.rsp; 304 305 if (els->els_retries_remaining) { 306 els->els_retries_remaining--; 307 rc = efc->tt.send_els(efc, &els->io); 308 } else { 309 rc = -EIO; 310 } 311 312 if (rc) { 313 efc_log_err(efc, "ELS retries exhausted\n"); 314 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_REQ_FAIL, &cbdata); 315 } 316 } 317 318 static int 319 efc_els_acc_cb(void *arg, u32 length, int status, u32 ext_status) 320 { 321 struct efc_els_io_req *els; 322 struct efc_node *node; 323 struct efc *efc; 324 struct efc_node_cb cbdata; 325 326 els = arg; 327 node = els->node; 328 efc = node->efc; 329 330 cbdata.status = status; 331 cbdata.ext_status = ext_status; 332 cbdata.header = NULL; 333 cbdata.els_rsp = els->io.rsp; 334 335 /* Post node event */ 336 switch (status) { 337 case SLI4_FC_WCQE_STATUS_SUCCESS: 338 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_CMPL_OK, &cbdata); 339 break; 340 341 default: /* Other error */ 342 efc_log_warn(efc, "[%s] %-8s failed status x%x, ext x%x\n", 343 node->display_name, els->display_name, 344 status, ext_status); 345 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_CMPL_FAIL, &cbdata); 346 break; 347 } 348 349 return 0; 350 } 351 352 static int 353 efc_els_send_rsp(struct efc_els_io_req *els, u32 rsplen) 354 { 355 int rc = 0; 356 struct efc_node_cb cbdata; 357 struct efc_node *node = els->node; 358 struct efc *efc = node->efc; 359 360 /* increment ELS completion counter */ 361 node->els_cmpl_cnt++; 362 363 els->io.io_type = EFC_DISC_IO_ELS_RESP; 364 els->cb = efc_els_acc_cb; 365 366 /* Prepare the IO request details */ 367 els->io.xmit_len = rsplen; 368 els->io.rsp_len = els->io.rsp.size; 369 els->io.rpi = node->rnode.indicator; 370 els->io.vpi = node->nport->indicator; 371 if (node->nport->fc_id != U32_MAX) 372 els->io.s_id = node->nport->fc_id; 373 else 374 els->io.s_id = els->io.iparam.els.s_id; 375 els->io.d_id = node->rnode.fc_id; 376 377 if (node->attached) 378 els->io.rpi_registered = true; 379 380 rc = efc->tt.send_els(efc, &els->io); 381 if (!rc) 382 return rc; 383 384 cbdata.status = EFC_STATUS_INVALID; 385 cbdata.ext_status = EFC_STATUS_INVALID; 386 cbdata.els_rsp = els->io.rsp; 387 efc_els_io_cleanup(els, EFC_EVT_SRRS_ELS_CMPL_FAIL, &cbdata); 388 389 return rc; 390 } 391 392 int 393 efc_send_plogi(struct efc_node *node) 394 { 395 struct efc_els_io_req *els; 396 struct efc *efc = node->efc; 397 struct fc_els_flogi *plogi; 398 399 node_els_trace(); 400 401 els = efc_els_io_alloc(node, sizeof(*plogi)); 402 if (!els) { 403 efc_log_err(efc, "IO alloc failed\n"); 404 return -EIO; 405 } 406 els->display_name = "plogi"; 407 408 /* Build PLOGI request */ 409 plogi = els->io.req.virt; 410 411 memcpy(plogi, node->nport->service_params, sizeof(*plogi)); 412 413 plogi->fl_cmd = ELS_PLOGI; 414 memset(plogi->_fl_resvd, 0, sizeof(plogi->_fl_resvd)); 415 416 return efc_els_send_req(node, els, EFC_DISC_IO_ELS_REQ); 417 } 418 419 int 420 efc_send_flogi(struct efc_node *node) 421 { 422 struct efc_els_io_req *els; 423 struct efc *efc; 424 struct fc_els_flogi *flogi; 425 426 efc = node->efc; 427 428 node_els_trace(); 429 430 els = efc_els_io_alloc(node, sizeof(*flogi)); 431 if (!els) { 432 efc_log_err(efc, "IO alloc failed\n"); 433 return -EIO; 434 } 435 436 els->display_name = "flogi"; 437 438 /* Build FLOGI request */ 439 flogi = els->io.req.virt; 440 441 memcpy(flogi, node->nport->service_params, sizeof(*flogi)); 442 flogi->fl_cmd = ELS_FLOGI; 443 memset(flogi->_fl_resvd, 0, sizeof(flogi->_fl_resvd)); 444 445 return efc_els_send_req(node, els, EFC_DISC_IO_ELS_REQ); 446 } 447 448 int 449 efc_send_fdisc(struct efc_node *node) 450 { 451 struct efc_els_io_req *els; 452 struct efc *efc; 453 struct fc_els_flogi *fdisc; 454 455 efc = node->efc; 456 457 node_els_trace(); 458 459 els = efc_els_io_alloc(node, sizeof(*fdisc)); 460 if (!els) { 461 efc_log_err(efc, "IO alloc failed\n"); 462 return -EIO; 463 } 464 465 els->display_name = "fdisc"; 466 467 /* Build FDISC request */ 468 fdisc = els->io.req.virt; 469 470 memcpy(fdisc, node->nport->service_params, sizeof(*fdisc)); 471 fdisc->fl_cmd = ELS_FDISC; 472 memset(fdisc->_fl_resvd, 0, sizeof(fdisc->_fl_resvd)); 473 474 return efc_els_send_req(node, els, EFC_DISC_IO_ELS_REQ); 475 } 476 477 int 478 efc_send_prli(struct efc_node *node) 479 { 480 struct efc *efc = node->efc; 481 struct efc_els_io_req *els; 482 struct { 483 struct fc_els_prli prli; 484 struct fc_els_spp spp; 485 } *pp; 486 487 node_els_trace(); 488 489 els = efc_els_io_alloc(node, sizeof(*pp)); 490 if (!els) { 491 efc_log_err(efc, "IO alloc failed\n"); 492 return -EIO; 493 } 494 495 els->display_name = "prli"; 496 497 /* Build PRLI request */ 498 pp = els->io.req.virt; 499 500 memset(pp, 0, sizeof(*pp)); 501 502 pp->prli.prli_cmd = ELS_PRLI; 503 pp->prli.prli_spp_len = 16; 504 pp->prli.prli_len = cpu_to_be16(sizeof(*pp)); 505 pp->spp.spp_type = FC_TYPE_FCP; 506 pp->spp.spp_type_ext = 0; 507 pp->spp.spp_flags = FC_SPP_EST_IMG_PAIR; 508 pp->spp.spp_params = cpu_to_be32(FCP_SPPF_RD_XRDY_DIS | 509 (node->nport->enable_ini ? 510 FCP_SPPF_INIT_FCN : 0) | 511 (node->nport->enable_tgt ? 512 FCP_SPPF_TARG_FCN : 0)); 513 514 return efc_els_send_req(node, els, EFC_DISC_IO_ELS_REQ); 515 } 516 517 int 518 efc_send_logo(struct efc_node *node) 519 { 520 struct efc *efc = node->efc; 521 struct efc_els_io_req *els; 522 struct fc_els_logo *logo; 523 struct fc_els_flogi *sparams; 524 525 node_els_trace(); 526 527 sparams = (struct fc_els_flogi *)node->nport->service_params; 528 529 els = efc_els_io_alloc(node, sizeof(*logo)); 530 if (!els) { 531 efc_log_err(efc, "IO alloc failed\n"); 532 return -EIO; 533 } 534 535 els->display_name = "logo"; 536 537 /* Build LOGO request */ 538 539 logo = els->io.req.virt; 540 541 memset(logo, 0, sizeof(*logo)); 542 logo->fl_cmd = ELS_LOGO; 543 hton24(logo->fl_n_port_id, node->rnode.nport->fc_id); 544 logo->fl_n_port_wwn = sparams->fl_wwpn; 545 546 return efc_els_send_req(node, els, EFC_DISC_IO_ELS_REQ); 547 } 548 549 int 550 efc_send_adisc(struct efc_node *node) 551 { 552 struct efc *efc = node->efc; 553 struct efc_els_io_req *els; 554 struct fc_els_adisc *adisc; 555 struct fc_els_flogi *sparams; 556 struct efc_nport *nport = node->nport; 557 558 node_els_trace(); 559 560 sparams = (struct fc_els_flogi *)node->nport->service_params; 561 562 els = efc_els_io_alloc(node, sizeof(*adisc)); 563 if (!els) { 564 efc_log_err(efc, "IO alloc failed\n"); 565 return -EIO; 566 } 567 568 els->display_name = "adisc"; 569 570 /* Build ADISC request */ 571 572 adisc = els->io.req.virt; 573 574 memset(adisc, 0, sizeof(*adisc)); 575 adisc->adisc_cmd = ELS_ADISC; 576 hton24(adisc->adisc_hard_addr, nport->fc_id); 577 adisc->adisc_wwpn = sparams->fl_wwpn; 578 adisc->adisc_wwnn = sparams->fl_wwnn; 579 hton24(adisc->adisc_port_id, node->rnode.nport->fc_id); 580 581 return efc_els_send_req(node, els, EFC_DISC_IO_ELS_REQ); 582 } 583 584 int 585 efc_send_scr(struct efc_node *node) 586 { 587 struct efc_els_io_req *els; 588 struct efc *efc = node->efc; 589 struct fc_els_scr *req; 590 591 node_els_trace(); 592 593 els = efc_els_io_alloc(node, sizeof(*req)); 594 if (!els) { 595 efc_log_err(efc, "IO alloc failed\n"); 596 return -EIO; 597 } 598 599 els->display_name = "scr"; 600 601 req = els->io.req.virt; 602 603 memset(req, 0, sizeof(*req)); 604 req->scr_cmd = ELS_SCR; 605 req->scr_reg_func = ELS_SCRF_FULL; 606 607 return efc_els_send_req(node, els, EFC_DISC_IO_ELS_REQ); 608 } 609 610 int 611 efc_send_ls_rjt(struct efc_node *node, u32 ox_id, u32 reason_code, 612 u32 reason_code_expl, u32 vendor_unique) 613 { 614 struct efc *efc = node->efc; 615 struct efc_els_io_req *els = NULL; 616 struct fc_els_ls_rjt *rjt; 617 618 els = efc_els_io_alloc(node, sizeof(*rjt)); 619 if (!els) { 620 efc_log_err(efc, "els IO alloc failed\n"); 621 return -EIO; 622 } 623 624 node_els_trace(); 625 626 els->display_name = "ls_rjt"; 627 628 memset(&els->io.iparam, 0, sizeof(els->io.iparam)); 629 els->io.iparam.els.ox_id = ox_id; 630 631 rjt = els->io.req.virt; 632 memset(rjt, 0, sizeof(*rjt)); 633 634 rjt->er_cmd = ELS_LS_RJT; 635 rjt->er_reason = reason_code; 636 rjt->er_explan = reason_code_expl; 637 638 return efc_els_send_rsp(els, sizeof(*rjt)); 639 } 640 641 int 642 efc_send_plogi_acc(struct efc_node *node, u32 ox_id) 643 { 644 struct efc *efc = node->efc; 645 struct efc_els_io_req *els = NULL; 646 struct fc_els_flogi *plogi; 647 struct fc_els_flogi *req = (struct fc_els_flogi *)node->service_params; 648 649 node_els_trace(); 650 651 els = efc_els_io_alloc(node, sizeof(*plogi)); 652 if (!els) { 653 efc_log_err(efc, "els IO alloc failed\n"); 654 return -EIO; 655 } 656 657 els->display_name = "plogi_acc"; 658 659 memset(&els->io.iparam, 0, sizeof(els->io.iparam)); 660 els->io.iparam.els.ox_id = ox_id; 661 662 plogi = els->io.req.virt; 663 664 /* copy our port's service parameters to payload */ 665 memcpy(plogi, node->nport->service_params, sizeof(*plogi)); 666 plogi->fl_cmd = ELS_LS_ACC; 667 memset(plogi->_fl_resvd, 0, sizeof(plogi->_fl_resvd)); 668 669 /* Set Application header support bit if requested */ 670 if (req->fl_csp.sp_features & cpu_to_be16(FC_SP_FT_BCAST)) 671 plogi->fl_csp.sp_features |= cpu_to_be16(FC_SP_FT_BCAST); 672 673 return efc_els_send_rsp(els, sizeof(*plogi)); 674 } 675 676 int 677 efc_send_flogi_p2p_acc(struct efc_node *node, u32 ox_id, u32 s_id) 678 { 679 struct efc *efc = node->efc; 680 struct efc_els_io_req *els = NULL; 681 struct fc_els_flogi *flogi; 682 683 node_els_trace(); 684 685 els = efc_els_io_alloc(node, sizeof(*flogi)); 686 if (!els) { 687 efc_log_err(efc, "els IO alloc failed\n"); 688 return -EIO; 689 } 690 691 els->display_name = "flogi_p2p_acc"; 692 693 memset(&els->io.iparam, 0, sizeof(els->io.iparam)); 694 els->io.iparam.els.ox_id = ox_id; 695 els->io.iparam.els.s_id = s_id; 696 697 flogi = els->io.req.virt; 698 699 /* copy our port's service parameters to payload */ 700 memcpy(flogi, node->nport->service_params, sizeof(*flogi)); 701 flogi->fl_cmd = ELS_LS_ACC; 702 memset(flogi->_fl_resvd, 0, sizeof(flogi->_fl_resvd)); 703 704 memset(flogi->fl_cssp, 0, sizeof(flogi->fl_cssp)); 705 706 return efc_els_send_rsp(els, sizeof(*flogi)); 707 } 708 709 int 710 efc_send_prli_acc(struct efc_node *node, u32 ox_id) 711 { 712 struct efc *efc = node->efc; 713 struct efc_els_io_req *els = NULL; 714 struct { 715 struct fc_els_prli prli; 716 struct fc_els_spp spp; 717 } *pp; 718 719 node_els_trace(); 720 721 els = efc_els_io_alloc(node, sizeof(*pp)); 722 if (!els) { 723 efc_log_err(efc, "els IO alloc failed\n"); 724 return -EIO; 725 } 726 727 els->display_name = "prli_acc"; 728 729 memset(&els->io.iparam, 0, sizeof(els->io.iparam)); 730 els->io.iparam.els.ox_id = ox_id; 731 732 pp = els->io.req.virt; 733 memset(pp, 0, sizeof(*pp)); 734 735 pp->prli.prli_cmd = ELS_LS_ACC; 736 pp->prli.prli_spp_len = 0x10; 737 pp->prli.prli_len = cpu_to_be16(sizeof(*pp)); 738 pp->spp.spp_type = FC_TYPE_FCP; 739 pp->spp.spp_type_ext = 0; 740 pp->spp.spp_flags = FC_SPP_EST_IMG_PAIR | FC_SPP_RESP_ACK; 741 742 pp->spp.spp_params = cpu_to_be32(FCP_SPPF_RD_XRDY_DIS | 743 (node->nport->enable_ini ? 744 FCP_SPPF_INIT_FCN : 0) | 745 (node->nport->enable_tgt ? 746 FCP_SPPF_TARG_FCN : 0)); 747 748 return efc_els_send_rsp(els, sizeof(*pp)); 749 } 750 751 int 752 efc_send_prlo_acc(struct efc_node *node, u32 ox_id) 753 { 754 struct efc *efc = node->efc; 755 struct efc_els_io_req *els = NULL; 756 struct { 757 struct fc_els_prlo prlo; 758 struct fc_els_spp spp; 759 } *pp; 760 761 node_els_trace(); 762 763 els = efc_els_io_alloc(node, sizeof(*pp)); 764 if (!els) { 765 efc_log_err(efc, "els IO alloc failed\n"); 766 return -EIO; 767 } 768 769 els->display_name = "prlo_acc"; 770 771 memset(&els->io.iparam, 0, sizeof(els->io.iparam)); 772 els->io.iparam.els.ox_id = ox_id; 773 774 pp = els->io.req.virt; 775 memset(pp, 0, sizeof(*pp)); 776 pp->prlo.prlo_cmd = ELS_LS_ACC; 777 pp->prlo.prlo_obs = 0x10; 778 pp->prlo.prlo_len = cpu_to_be16(sizeof(*pp)); 779 780 pp->spp.spp_type = FC_TYPE_FCP; 781 pp->spp.spp_type_ext = 0; 782 pp->spp.spp_flags = FC_SPP_RESP_ACK; 783 784 return efc_els_send_rsp(els, sizeof(*pp)); 785 } 786 787 int 788 efc_send_ls_acc(struct efc_node *node, u32 ox_id) 789 { 790 struct efc *efc = node->efc; 791 struct efc_els_io_req *els = NULL; 792 struct fc_els_ls_acc *acc; 793 794 node_els_trace(); 795 796 els = efc_els_io_alloc(node, sizeof(*acc)); 797 if (!els) { 798 efc_log_err(efc, "els IO alloc failed\n"); 799 return -EIO; 800 } 801 802 els->display_name = "ls_acc"; 803 804 memset(&els->io.iparam, 0, sizeof(els->io.iparam)); 805 els->io.iparam.els.ox_id = ox_id; 806 807 acc = els->io.req.virt; 808 memset(acc, 0, sizeof(*acc)); 809 810 acc->la_cmd = ELS_LS_ACC; 811 812 return efc_els_send_rsp(els, sizeof(*acc)); 813 } 814 815 int 816 efc_send_logo_acc(struct efc_node *node, u32 ox_id) 817 { 818 struct efc_els_io_req *els = NULL; 819 struct efc *efc = node->efc; 820 struct fc_els_ls_acc *logo; 821 822 node_els_trace(); 823 824 els = efc_els_io_alloc(node, sizeof(*logo)); 825 if (!els) { 826 efc_log_err(efc, "els IO alloc failed\n"); 827 return -EIO; 828 } 829 830 els->display_name = "logo_acc"; 831 832 memset(&els->io.iparam, 0, sizeof(els->io.iparam)); 833 els->io.iparam.els.ox_id = ox_id; 834 835 logo = els->io.req.virt; 836 memset(logo, 0, sizeof(*logo)); 837 838 logo->la_cmd = ELS_LS_ACC; 839 840 return efc_els_send_rsp(els, sizeof(*logo)); 841 } 842 843 int 844 efc_send_adisc_acc(struct efc_node *node, u32 ox_id) 845 { 846 struct efc *efc = node->efc; 847 struct efc_els_io_req *els = NULL; 848 struct fc_els_adisc *adisc; 849 struct fc_els_flogi *sparams; 850 851 node_els_trace(); 852 853 els = efc_els_io_alloc(node, sizeof(*adisc)); 854 if (!els) { 855 efc_log_err(efc, "els IO alloc failed\n"); 856 return -EIO; 857 } 858 859 els->display_name = "adisc_acc"; 860 861 /* Go ahead and send the ELS_ACC */ 862 memset(&els->io.iparam, 0, sizeof(els->io.iparam)); 863 els->io.iparam.els.ox_id = ox_id; 864 865 sparams = (struct fc_els_flogi *)node->nport->service_params; 866 adisc = els->io.req.virt; 867 memset(adisc, 0, sizeof(*adisc)); 868 adisc->adisc_cmd = ELS_LS_ACC; 869 adisc->adisc_wwpn = sparams->fl_wwpn; 870 adisc->adisc_wwnn = sparams->fl_wwnn; 871 hton24(adisc->adisc_port_id, node->rnode.nport->fc_id); 872 873 return efc_els_send_rsp(els, sizeof(*adisc)); 874 } 875 876 static inline void 877 fcct_build_req_header(struct fc_ct_hdr *hdr, u16 cmd, u16 max_size) 878 { 879 hdr->ct_rev = FC_CT_REV; 880 hdr->ct_fs_type = FC_FST_DIR; 881 hdr->ct_fs_subtype = FC_NS_SUBTYPE; 882 hdr->ct_options = 0; 883 hdr->ct_cmd = cpu_to_be16(cmd); 884 /* words */ 885 hdr->ct_mr_size = cpu_to_be16(max_size / (sizeof(u32))); 886 hdr->ct_reason = 0; 887 hdr->ct_explan = 0; 888 hdr->ct_vendor = 0; 889 } 890 891 int 892 efc_ns_send_rftid(struct efc_node *node) 893 { 894 struct efc *efc = node->efc; 895 struct efc_els_io_req *els; 896 struct { 897 struct fc_ct_hdr hdr; 898 struct fc_ns_rft_id rftid; 899 } *ct; 900 901 node_els_trace(); 902 903 els = efc_els_io_alloc(node, sizeof(*ct)); 904 if (!els) { 905 efc_log_err(efc, "IO alloc failed\n"); 906 return -EIO; 907 } 908 909 els->io.iparam.ct.r_ctl = FC_RCTL_ELS_REQ; 910 els->io.iparam.ct.type = FC_TYPE_CT; 911 els->io.iparam.ct.df_ctl = 0; 912 els->io.iparam.ct.timeout = EFC_FC_ELS_SEND_DEFAULT_TIMEOUT; 913 914 els->display_name = "rftid"; 915 916 ct = els->io.req.virt; 917 memset(ct, 0, sizeof(*ct)); 918 fcct_build_req_header(&ct->hdr, FC_NS_RFT_ID, 919 sizeof(struct fc_ns_rft_id)); 920 921 hton24(ct->rftid.fr_fid.fp_fid, node->rnode.nport->fc_id); 922 ct->rftid.fr_fts.ff_type_map[FC_TYPE_FCP / FC_NS_BPW] = 923 cpu_to_be32(1 << (FC_TYPE_FCP % FC_NS_BPW)); 924 925 return efc_els_send_req(node, els, EFC_DISC_IO_CT_REQ); 926 } 927 928 int 929 efc_ns_send_rffid(struct efc_node *node) 930 { 931 struct efc *efc = node->efc; 932 struct efc_els_io_req *els; 933 struct { 934 struct fc_ct_hdr hdr; 935 struct fc_ns_rff_id rffid; 936 } *ct; 937 938 node_els_trace(); 939 940 els = efc_els_io_alloc(node, sizeof(*ct)); 941 if (!els) { 942 efc_log_err(efc, "IO alloc failed\n"); 943 return -EIO; 944 } 945 946 els->io.iparam.ct.r_ctl = FC_RCTL_ELS_REQ; 947 els->io.iparam.ct.type = FC_TYPE_CT; 948 els->io.iparam.ct.df_ctl = 0; 949 els->io.iparam.ct.timeout = EFC_FC_ELS_SEND_DEFAULT_TIMEOUT; 950 951 els->display_name = "rffid"; 952 ct = els->io.req.virt; 953 954 memset(ct, 0, sizeof(*ct)); 955 fcct_build_req_header(&ct->hdr, FC_NS_RFF_ID, 956 sizeof(struct fc_ns_rff_id)); 957 958 hton24(ct->rffid.fr_fid.fp_fid, node->rnode.nport->fc_id); 959 if (node->nport->enable_ini) 960 ct->rffid.fr_feat |= FCP_FEAT_INIT; 961 if (node->nport->enable_tgt) 962 ct->rffid.fr_feat |= FCP_FEAT_TARG; 963 ct->rffid.fr_type = FC_TYPE_FCP; 964 965 return efc_els_send_req(node, els, EFC_DISC_IO_CT_REQ); 966 } 967 968 int 969 efc_ns_send_gidpt(struct efc_node *node) 970 { 971 struct efc_els_io_req *els = NULL; 972 struct efc *efc = node->efc; 973 struct { 974 struct fc_ct_hdr hdr; 975 struct fc_ns_gid_pt gidpt; 976 } *ct; 977 978 node_els_trace(); 979 980 els = efc_els_io_alloc_size(node, sizeof(*ct), EFC_ELS_GID_PT_RSP_LEN); 981 if (!els) { 982 efc_log_err(efc, "IO alloc failed\n"); 983 return -EIO; 984 } 985 986 els->io.iparam.ct.r_ctl = FC_RCTL_ELS_REQ; 987 els->io.iparam.ct.type = FC_TYPE_CT; 988 els->io.iparam.ct.df_ctl = 0; 989 els->io.iparam.ct.timeout = EFC_FC_ELS_SEND_DEFAULT_TIMEOUT; 990 991 els->display_name = "gidpt"; 992 993 ct = els->io.req.virt; 994 995 memset(ct, 0, sizeof(*ct)); 996 fcct_build_req_header(&ct->hdr, FC_NS_GID_PT, 997 sizeof(struct fc_ns_gid_pt)); 998 999 ct->gidpt.fn_pt_type = FC_TYPE_FCP; 1000 1001 return efc_els_send_req(node, els, EFC_DISC_IO_CT_REQ); 1002 } 1003 1004 void 1005 efc_els_io_cleanup(struct efc_els_io_req *els, int evt, void *arg) 1006 { 1007 /* don't want further events that could come; e.g. abort requests 1008 * from the node state machine; thus, disable state machine 1009 */ 1010 els->els_req_free = true; 1011 efc_node_post_els_resp(els->node, evt, arg); 1012 1013 efc_els_io_free(els); 1014 } 1015 1016 static int 1017 efc_ct_acc_cb(void *arg, u32 length, int status, u32 ext_status) 1018 { 1019 struct efc_els_io_req *els = arg; 1020 1021 efc_els_io_free(els); 1022 1023 return 0; 1024 } 1025 1026 int 1027 efc_send_ct_rsp(struct efc *efc, struct efc_node *node, u16 ox_id, 1028 struct fc_ct_hdr *ct_hdr, u32 cmd_rsp_code, 1029 u32 reason_code, u32 reason_code_explanation) 1030 { 1031 struct efc_els_io_req *els = NULL; 1032 struct fc_ct_hdr *rsp = NULL; 1033 1034 els = efc_els_io_alloc(node, 256); 1035 if (!els) { 1036 efc_log_err(efc, "IO alloc failed\n"); 1037 return -EIO; 1038 } 1039 1040 rsp = els->io.rsp.virt; 1041 1042 *rsp = *ct_hdr; 1043 1044 fcct_build_req_header(rsp, cmd_rsp_code, 0); 1045 rsp->ct_reason = reason_code; 1046 rsp->ct_explan = reason_code_explanation; 1047 1048 els->display_name = "ct_rsp"; 1049 els->cb = efc_ct_acc_cb; 1050 1051 /* Prepare the IO request details */ 1052 els->io.io_type = EFC_DISC_IO_CT_RESP; 1053 els->io.xmit_len = sizeof(*rsp); 1054 1055 els->io.rpi = node->rnode.indicator; 1056 els->io.d_id = node->rnode.fc_id; 1057 1058 memset(&els->io.iparam, 0, sizeof(els->io.iparam)); 1059 1060 els->io.iparam.ct.ox_id = ox_id; 1061 els->io.iparam.ct.r_ctl = 3; 1062 els->io.iparam.ct.type = FC_TYPE_CT; 1063 els->io.iparam.ct.df_ctl = 0; 1064 els->io.iparam.ct.timeout = 5; 1065 1066 if (efc->tt.send_els(efc, &els->io)) { 1067 efc_els_io_free(els); 1068 return -EIO; 1069 } 1070 return 0; 1071 } 1072 1073 int 1074 efc_send_bls_acc(struct efc_node *node, struct fc_frame_header *hdr) 1075 { 1076 struct sli_bls_params bls; 1077 struct fc_ba_acc *acc; 1078 struct efc *efc = node->efc; 1079 1080 memset(&bls, 0, sizeof(bls)); 1081 bls.ox_id = be16_to_cpu(hdr->fh_ox_id); 1082 bls.rx_id = be16_to_cpu(hdr->fh_rx_id); 1083 bls.s_id = ntoh24(hdr->fh_d_id); 1084 bls.d_id = node->rnode.fc_id; 1085 bls.rpi = node->rnode.indicator; 1086 bls.vpi = node->nport->indicator; 1087 1088 acc = (void *)bls.payload; 1089 acc->ba_ox_id = cpu_to_be16(bls.ox_id); 1090 acc->ba_rx_id = cpu_to_be16(bls.rx_id); 1091 acc->ba_high_seq_cnt = cpu_to_be16(U16_MAX); 1092 1093 return efc->tt.send_bls(efc, FC_RCTL_BA_ACC, &bls); 1094 } 1095