1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2017-2022 Broadcom. All Rights Reserved. The term * 5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. * 6 * Copyright (C) 2004-2016 Emulex. All rights reserved. * 7 * EMULEX and SLI are trademarks of Emulex. * 8 * www.broadcom.com * 9 * * 10 * This program is free software; you can redistribute it and/or * 11 * modify it under the terms of version 2 of the GNU General * 12 * Public License as published by the Free Software Foundation. * 13 * This program is distributed in the hope that it will be useful. * 14 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * 15 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * 16 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * 17 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * 18 * TO BE LEGALLY INVALID. See the GNU General Public License for * 19 * more details, a copy of which can be found in the file COPYING * 20 * included with this package. * 21 *******************************************************************/ 22 23 /* 24 * Fibre Channel SCSI LAN Device Driver CT support: FC Generic Services FC-GS 25 */ 26 27 #include <linux/blkdev.h> 28 #include <linux/pci.h> 29 #include <linux/interrupt.h> 30 #include <linux/slab.h> 31 #include <linux/utsname.h> 32 33 #include <scsi/scsi.h> 34 #include <scsi/scsi_device.h> 35 #include <scsi/scsi_host.h> 36 #include <scsi/scsi_transport_fc.h> 37 #include <scsi/fc/fc_fs.h> 38 39 #include "lpfc_hw4.h" 40 #include "lpfc_hw.h" 41 #include "lpfc_sli.h" 42 #include "lpfc_sli4.h" 43 #include "lpfc_nl.h" 44 #include "lpfc_disc.h" 45 #include "lpfc.h" 46 #include "lpfc_scsi.h" 47 #include "lpfc_logmsg.h" 48 #include "lpfc_crtn.h" 49 #include "lpfc_version.h" 50 #include "lpfc_vport.h" 51 #include "lpfc_debugfs.h" 52 53 /* FDMI Port Speed definitions - FC-GS-7 */ 54 #define HBA_PORTSPEED_1GFC 0x00000001 /* 1G FC */ 55 #define HBA_PORTSPEED_2GFC 0x00000002 /* 2G FC */ 56 #define HBA_PORTSPEED_4GFC 0x00000008 /* 4G FC */ 57 #define HBA_PORTSPEED_10GFC 0x00000004 /* 10G FC */ 58 #define HBA_PORTSPEED_8GFC 0x00000010 /* 8G FC */ 59 #define HBA_PORTSPEED_16GFC 0x00000020 /* 16G FC */ 60 #define HBA_PORTSPEED_32GFC 0x00000040 /* 32G FC */ 61 #define HBA_PORTSPEED_20GFC 0x00000080 /* 20G FC */ 62 #define HBA_PORTSPEED_40GFC 0x00000100 /* 40G FC */ 63 #define HBA_PORTSPEED_128GFC 0x00000200 /* 128G FC */ 64 #define HBA_PORTSPEED_64GFC 0x00000400 /* 64G FC */ 65 #define HBA_PORTSPEED_256GFC 0x00000800 /* 256G FC */ 66 #define HBA_PORTSPEED_UNKNOWN 0x00008000 /* Unknown */ 67 #define HBA_PORTSPEED_10GE 0x00010000 /* 10G E */ 68 #define HBA_PORTSPEED_40GE 0x00020000 /* 40G E */ 69 #define HBA_PORTSPEED_100GE 0x00040000 /* 100G E */ 70 #define HBA_PORTSPEED_25GE 0x00080000 /* 25G E */ 71 #define HBA_PORTSPEED_50GE 0x00100000 /* 50G E */ 72 #define HBA_PORTSPEED_400GE 0x00200000 /* 400G E */ 73 74 #define FOURBYTES 4 75 76 77 static char *lpfc_release_version = LPFC_DRIVER_VERSION; 78 static void 79 lpfc_cmpl_ct_cmd_vmid(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 80 struct lpfc_iocbq *rspiocb); 81 82 static void 83 lpfc_ct_ignore_hbq_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq, 84 struct lpfc_dmabuf *mp, uint32_t size) 85 { 86 if (!mp) { 87 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 88 "0146 Ignoring unsolicited CT No HBQ " 89 "status = x%x\n", 90 get_job_ulpstatus(phba, piocbq)); 91 } 92 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 93 "0145 Ignoring unsolicted CT HBQ Size:%d " 94 "status = x%x\n", 95 size, get_job_ulpstatus(phba, piocbq)); 96 } 97 98 static void 99 lpfc_ct_unsol_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq, 100 struct lpfc_dmabuf *mp, uint32_t size) 101 { 102 lpfc_ct_ignore_hbq_buffer(phba, piocbq, mp, size); 103 } 104 105 /** 106 * lpfc_ct_unsol_cmpl : Completion callback function for unsol ct commands 107 * @phba : pointer to lpfc hba data structure. 108 * @cmdiocb : pointer to lpfc command iocb data structure. 109 * @rspiocb : pointer to lpfc response iocb data structure. 110 * 111 * This routine is the callback function for issuing unsol ct reject command. 112 * The memory allocated in the reject command path is freed up here. 113 **/ 114 static void 115 lpfc_ct_unsol_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 116 struct lpfc_iocbq *rspiocb) 117 { 118 struct lpfc_nodelist *ndlp; 119 struct lpfc_dmabuf *mp, *bmp; 120 121 ndlp = cmdiocb->ndlp; 122 if (ndlp) 123 lpfc_nlp_put(ndlp); 124 125 mp = cmdiocb->rsp_dmabuf; 126 bmp = cmdiocb->bpl_dmabuf; 127 if (mp) { 128 lpfc_mbuf_free(phba, mp->virt, mp->phys); 129 kfree(mp); 130 cmdiocb->rsp_dmabuf = NULL; 131 } 132 133 if (bmp) { 134 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 135 kfree(bmp); 136 cmdiocb->bpl_dmabuf = NULL; 137 } 138 139 lpfc_sli_release_iocbq(phba, cmdiocb); 140 } 141 142 /** 143 * lpfc_ct_reject_event - Issue reject for unhandled CT MIB commands 144 * @ndlp: pointer to a node-list data structure. 145 * @ct_req: pointer to the CT request data structure. 146 * @ulp_context: context of received UNSOL CT command 147 * @ox_id: ox_id of the UNSOL CT command 148 * 149 * This routine is invoked by the lpfc_ct_handle_mibreq routine for sending 150 * a reject response. Reject response is sent for the unhandled commands. 151 **/ 152 static void 153 lpfc_ct_reject_event(struct lpfc_nodelist *ndlp, 154 struct lpfc_sli_ct_request *ct_req, 155 u16 ulp_context, u16 ox_id) 156 { 157 struct lpfc_vport *vport = ndlp->vport; 158 struct lpfc_hba *phba = vport->phba; 159 struct lpfc_sli_ct_request *ct_rsp; 160 struct lpfc_iocbq *cmdiocbq = NULL; 161 struct lpfc_dmabuf *bmp = NULL; 162 struct lpfc_dmabuf *mp = NULL; 163 struct ulp_bde64 *bpl; 164 u8 rc = 0; 165 u32 tmo; 166 167 /* fill in BDEs for command */ 168 mp = kmalloc(sizeof(*mp), GFP_KERNEL); 169 if (!mp) { 170 rc = 1; 171 goto ct_exit; 172 } 173 174 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp->phys); 175 if (!mp->virt) { 176 rc = 2; 177 goto ct_free_mp; 178 } 179 180 /* Allocate buffer for Buffer ptr list */ 181 bmp = kmalloc(sizeof(*bmp), GFP_KERNEL); 182 if (!bmp) { 183 rc = 3; 184 goto ct_free_mpvirt; 185 } 186 187 bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &bmp->phys); 188 if (!bmp->virt) { 189 rc = 4; 190 goto ct_free_bmp; 191 } 192 193 INIT_LIST_HEAD(&mp->list); 194 INIT_LIST_HEAD(&bmp->list); 195 196 bpl = (struct ulp_bde64 *)bmp->virt; 197 memset(bpl, 0, sizeof(struct ulp_bde64)); 198 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys)); 199 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys)); 200 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64; 201 bpl->tus.f.bdeSize = (LPFC_CT_PREAMBLE - 4); 202 bpl->tus.w = le32_to_cpu(bpl->tus.w); 203 204 ct_rsp = (struct lpfc_sli_ct_request *)mp->virt; 205 memset(ct_rsp, 0, sizeof(struct lpfc_sli_ct_request)); 206 207 ct_rsp->RevisionId.bits.Revision = SLI_CT_REVISION; 208 ct_rsp->RevisionId.bits.InId = 0; 209 ct_rsp->FsType = ct_req->FsType; 210 ct_rsp->FsSubType = ct_req->FsSubType; 211 ct_rsp->CommandResponse.bits.Size = 0; 212 ct_rsp->CommandResponse.bits.CmdRsp = 213 cpu_to_be16(SLI_CT_RESPONSE_FS_RJT); 214 ct_rsp->ReasonCode = SLI_CT_REQ_NOT_SUPPORTED; 215 ct_rsp->Explanation = SLI_CT_NO_ADDITIONAL_EXPL; 216 217 cmdiocbq = lpfc_sli_get_iocbq(phba); 218 if (!cmdiocbq) { 219 rc = 5; 220 goto ct_free_bmpvirt; 221 } 222 223 if (phba->sli_rev == LPFC_SLI_REV4) { 224 lpfc_sli_prep_xmit_seq64(phba, cmdiocbq, bmp, 225 phba->sli4_hba.rpi_ids[ndlp->nlp_rpi], 226 ox_id, 1, FC_RCTL_DD_SOL_CTL, 1, 227 CMD_XMIT_SEQUENCE64_WQE); 228 } else { 229 lpfc_sli_prep_xmit_seq64(phba, cmdiocbq, bmp, 0, ulp_context, 1, 230 FC_RCTL_DD_SOL_CTL, 1, 231 CMD_XMIT_SEQUENCE64_CX); 232 } 233 234 /* Save for completion so we can release these resources */ 235 cmdiocbq->rsp_dmabuf = mp; 236 cmdiocbq->bpl_dmabuf = bmp; 237 cmdiocbq->cmd_cmpl = lpfc_ct_unsol_cmpl; 238 tmo = (3 * phba->fc_ratov); 239 240 cmdiocbq->retry = 0; 241 cmdiocbq->vport = vport; 242 cmdiocbq->drvrTimeout = tmo + LPFC_DRVR_TIMEOUT; 243 244 cmdiocbq->ndlp = lpfc_nlp_get(ndlp); 245 if (!cmdiocbq->ndlp) 246 goto ct_no_ndlp; 247 248 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0); 249 if (rc) { 250 lpfc_nlp_put(ndlp); 251 goto ct_no_ndlp; 252 } 253 return; 254 255 ct_no_ndlp: 256 rc = 6; 257 lpfc_sli_release_iocbq(phba, cmdiocbq); 258 ct_free_bmpvirt: 259 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 260 ct_free_bmp: 261 kfree(bmp); 262 ct_free_mpvirt: 263 lpfc_mbuf_free(phba, mp->virt, mp->phys); 264 ct_free_mp: 265 kfree(mp); 266 ct_exit: 267 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 268 "6440 Unsol CT: Rsp err %d Data: x%x\n", 269 rc, vport->fc_flag); 270 } 271 272 /** 273 * lpfc_ct_handle_mibreq - Process an unsolicited CT MIB request data buffer 274 * @phba: pointer to lpfc hba data structure. 275 * @ctiocbq: pointer to lpfc CT command iocb data structure. 276 * 277 * This routine is used for processing the IOCB associated with a unsolicited 278 * CT MIB request. It first determines whether there is an existing ndlp that 279 * matches the DID from the unsolicited IOCB. If not, it will return. 280 **/ 281 static void 282 lpfc_ct_handle_mibreq(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocbq) 283 { 284 struct lpfc_sli_ct_request *ct_req; 285 struct lpfc_nodelist *ndlp = NULL; 286 struct lpfc_vport *vport = ctiocbq->vport; 287 u32 ulp_status = get_job_ulpstatus(phba, ctiocbq); 288 u32 ulp_word4 = get_job_word4(phba, ctiocbq); 289 u32 did; 290 u32 mi_cmd; 291 292 did = bf_get(els_rsp64_sid, &ctiocbq->wqe.xmit_els_rsp); 293 if (ulp_status) { 294 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, 295 "6438 Unsol CT: status:x%x/x%x did : x%x\n", 296 ulp_status, ulp_word4, did); 297 return; 298 } 299 300 /* Ignore traffic received during vport shutdown */ 301 if (vport->fc_flag & FC_UNLOADING) 302 return; 303 304 ndlp = lpfc_findnode_did(vport, did); 305 if (!ndlp) { 306 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, 307 "6439 Unsol CT: NDLP Not Found for DID : x%x", 308 did); 309 return; 310 } 311 312 ct_req = (struct lpfc_sli_ct_request *)ctiocbq->cmd_dmabuf->virt; 313 314 mi_cmd = ct_req->CommandResponse.bits.CmdRsp; 315 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, 316 "6442 : MI Cmd : x%x Not Supported\n", mi_cmd); 317 lpfc_ct_reject_event(ndlp, ct_req, 318 bf_get(wqe_ctxt_tag, 319 &ctiocbq->wqe.xmit_els_rsp.wqe_com), 320 bf_get(wqe_rcvoxid, 321 &ctiocbq->wqe.xmit_els_rsp.wqe_com)); 322 } 323 324 /** 325 * lpfc_ct_unsol_event - Process an unsolicited event from a ct sli ring 326 * @phba: pointer to lpfc hba data structure. 327 * @pring: pointer to a SLI ring. 328 * @ctiocbq: pointer to lpfc ct iocb data structure. 329 * 330 * This routine is used to process an unsolicited event received from a SLI 331 * (Service Level Interface) ring. The actual processing of the data buffer 332 * associated with the unsolicited event is done by invoking appropriate routine 333 * after properly set up the iocb buffer from the SLI ring on which the 334 * unsolicited event was received. 335 **/ 336 void 337 lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, 338 struct lpfc_iocbq *ctiocbq) 339 { 340 struct lpfc_dmabuf *mp = NULL; 341 IOCB_t *icmd = &ctiocbq->iocb; 342 int i; 343 struct lpfc_iocbq *iocbq; 344 struct lpfc_iocbq *iocb; 345 dma_addr_t dma_addr; 346 uint32_t size; 347 struct list_head head; 348 struct lpfc_sli_ct_request *ct_req; 349 struct lpfc_dmabuf *bdeBuf1 = ctiocbq->cmd_dmabuf; 350 struct lpfc_dmabuf *bdeBuf2 = ctiocbq->bpl_dmabuf; 351 u32 status, parameter, bde_count = 0; 352 struct lpfc_wcqe_complete *wcqe_cmpl = NULL; 353 354 ctiocbq->cmd_dmabuf = NULL; 355 ctiocbq->rsp_dmabuf = NULL; 356 ctiocbq->bpl_dmabuf = NULL; 357 358 wcqe_cmpl = &ctiocbq->wcqe_cmpl; 359 status = get_job_ulpstatus(phba, ctiocbq); 360 parameter = get_job_word4(phba, ctiocbq); 361 if (phba->sli_rev == LPFC_SLI_REV4) 362 bde_count = wcqe_cmpl->word3; 363 else 364 bde_count = icmd->ulpBdeCount; 365 366 if (unlikely(status == IOSTAT_NEED_BUFFER)) { 367 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ); 368 } else if ((status == IOSTAT_LOCAL_REJECT) && 369 ((parameter & IOERR_PARAM_MASK) == 370 IOERR_RCV_BUFFER_WAITING)) { 371 /* Not enough posted buffers; Try posting more buffers */ 372 phba->fc_stat.NoRcvBuf++; 373 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)) 374 lpfc_sli3_post_buffer(phba, pring, 2); 375 return; 376 } 377 378 /* If there are no BDEs associated 379 * with this IOCB, there is nothing to do. 380 */ 381 if (bde_count == 0) 382 return; 383 384 ctiocbq->cmd_dmabuf = bdeBuf1; 385 if (bde_count == 2) 386 ctiocbq->bpl_dmabuf = bdeBuf2; 387 388 ct_req = (struct lpfc_sli_ct_request *)ctiocbq->cmd_dmabuf->virt; 389 390 if (ct_req->FsType == SLI_CT_MANAGEMENT_SERVICE && 391 ct_req->FsSubType == SLI_CT_MIB_Subtypes) { 392 lpfc_ct_handle_mibreq(phba, ctiocbq); 393 } else { 394 if (!lpfc_bsg_ct_unsol_event(phba, pring, ctiocbq)) 395 return; 396 } 397 398 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) { 399 INIT_LIST_HEAD(&head); 400 list_add_tail(&head, &ctiocbq->list); 401 list_for_each_entry(iocb, &head, list) { 402 if (phba->sli_rev == LPFC_SLI_REV4) 403 bde_count = iocb->wcqe_cmpl.word3; 404 else 405 bde_count = iocb->iocb.ulpBdeCount; 406 407 if (!bde_count) 408 continue; 409 bdeBuf1 = iocb->cmd_dmabuf; 410 iocb->cmd_dmabuf = NULL; 411 if (phba->sli_rev == LPFC_SLI_REV4) 412 size = iocb->wqe.gen_req.bde.tus.f.bdeSize; 413 else 414 size = iocb->iocb.un.cont64[0].tus.f.bdeSize; 415 lpfc_ct_unsol_buffer(phba, ctiocbq, bdeBuf1, size); 416 lpfc_in_buf_free(phba, bdeBuf1); 417 if (bde_count == 2) { 418 bdeBuf2 = iocb->bpl_dmabuf; 419 iocb->bpl_dmabuf = NULL; 420 if (phba->sli_rev == LPFC_SLI_REV4) 421 size = iocb->unsol_rcv_len; 422 else 423 size = iocb->iocb.unsli3.rcvsli3.bde2.tus.f.bdeSize; 424 lpfc_ct_unsol_buffer(phba, ctiocbq, bdeBuf2, 425 size); 426 lpfc_in_buf_free(phba, bdeBuf2); 427 } 428 } 429 list_del(&head); 430 } else { 431 INIT_LIST_HEAD(&head); 432 list_add_tail(&head, &ctiocbq->list); 433 list_for_each_entry(iocbq, &head, list) { 434 icmd = &iocbq->iocb; 435 if (icmd->ulpBdeCount == 0) 436 lpfc_ct_unsol_buffer(phba, iocbq, NULL, 0); 437 for (i = 0; i < icmd->ulpBdeCount; i++) { 438 dma_addr = getPaddr(icmd->un.cont64[i].addrHigh, 439 icmd->un.cont64[i].addrLow); 440 mp = lpfc_sli_ringpostbuf_get(phba, pring, 441 dma_addr); 442 size = icmd->un.cont64[i].tus.f.bdeSize; 443 lpfc_ct_unsol_buffer(phba, iocbq, mp, size); 444 lpfc_in_buf_free(phba, mp); 445 } 446 lpfc_sli3_post_buffer(phba, pring, i); 447 } 448 list_del(&head); 449 } 450 } 451 452 /** 453 * lpfc_ct_handle_unsol_abort - ct upper level protocol abort handler 454 * @phba: Pointer to HBA context object. 455 * @dmabuf: pointer to a dmabuf that describes the FC sequence 456 * 457 * This function serves as the upper level protocol abort handler for CT 458 * protocol. 459 * 460 * Return 1 if abort has been handled, 0 otherwise. 461 **/ 462 int 463 lpfc_ct_handle_unsol_abort(struct lpfc_hba *phba, struct hbq_dmabuf *dmabuf) 464 { 465 int handled; 466 467 /* CT upper level goes through BSG */ 468 handled = lpfc_bsg_ct_unsol_abort(phba, dmabuf); 469 470 return handled; 471 } 472 473 static void 474 lpfc_free_ct_rsp(struct lpfc_hba *phba, struct lpfc_dmabuf *mlist) 475 { 476 struct lpfc_dmabuf *mlast, *next_mlast; 477 478 list_for_each_entry_safe(mlast, next_mlast, &mlist->list, list) { 479 lpfc_mbuf_free(phba, mlast->virt, mlast->phys); 480 list_del(&mlast->list); 481 kfree(mlast); 482 } 483 lpfc_mbuf_free(phba, mlist->virt, mlist->phys); 484 kfree(mlist); 485 return; 486 } 487 488 static struct lpfc_dmabuf * 489 lpfc_alloc_ct_rsp(struct lpfc_hba *phba, int cmdcode, struct ulp_bde64 *bpl, 490 uint32_t size, int *entries) 491 { 492 struct lpfc_dmabuf *mlist = NULL; 493 struct lpfc_dmabuf *mp; 494 int cnt, i = 0; 495 496 /* We get chunks of FCELSSIZE */ 497 cnt = size > FCELSSIZE ? FCELSSIZE: size; 498 499 while (size) { 500 /* Allocate buffer for rsp payload */ 501 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 502 if (!mp) { 503 if (mlist) 504 lpfc_free_ct_rsp(phba, mlist); 505 return NULL; 506 } 507 508 INIT_LIST_HEAD(&mp->list); 509 510 if (cmdcode == be16_to_cpu(SLI_CTNS_GID_FT) || 511 cmdcode == be16_to_cpu(SLI_CTNS_GFF_ID)) 512 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys)); 513 else 514 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys)); 515 516 if (!mp->virt) { 517 kfree(mp); 518 if (mlist) 519 lpfc_free_ct_rsp(phba, mlist); 520 return NULL; 521 } 522 523 /* Queue it to a linked list */ 524 if (!mlist) 525 mlist = mp; 526 else 527 list_add_tail(&mp->list, &mlist->list); 528 529 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I; 530 /* build buffer ptr list for IOCB */ 531 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) ); 532 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) ); 533 bpl->tus.f.bdeSize = (uint16_t) cnt; 534 bpl->tus.w = le32_to_cpu(bpl->tus.w); 535 bpl++; 536 537 i++; 538 size -= cnt; 539 } 540 541 *entries = i; 542 return mlist; 543 } 544 545 int 546 lpfc_ct_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocb) 547 { 548 struct lpfc_dmabuf *buf_ptr; 549 550 /* IOCBQ job structure gets cleaned during release. Just release 551 * the dma buffers here. 552 */ 553 if (ctiocb->cmd_dmabuf) { 554 buf_ptr = ctiocb->cmd_dmabuf; 555 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys); 556 kfree(buf_ptr); 557 ctiocb->cmd_dmabuf = NULL; 558 } 559 if (ctiocb->rsp_dmabuf) { 560 lpfc_free_ct_rsp(phba, ctiocb->rsp_dmabuf); 561 ctiocb->rsp_dmabuf = NULL; 562 } 563 564 if (ctiocb->bpl_dmabuf) { 565 buf_ptr = ctiocb->bpl_dmabuf; 566 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys); 567 kfree(buf_ptr); 568 ctiocb->bpl_dmabuf = NULL; 569 } 570 lpfc_sli_release_iocbq(phba, ctiocb); 571 return 0; 572 } 573 574 /* 575 * lpfc_gen_req - Build and issue a GEN_REQUEST command to the SLI Layer 576 * @vport: pointer to a host virtual N_Port data structure. 577 * @bmp: Pointer to BPL for SLI command 578 * @inp: Pointer to data buffer for response data. 579 * @outp: Pointer to data buffer that hold the CT command. 580 * @cmpl: completion routine to call when command completes 581 * @ndlp: Destination NPort nodelist entry 582 * 583 * This function as the final part for issuing a CT command. 584 */ 585 static int 586 lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp, 587 struct lpfc_dmabuf *inp, struct lpfc_dmabuf *outp, 588 void (*cmpl)(struct lpfc_hba *, struct lpfc_iocbq *, 589 struct lpfc_iocbq *), 590 struct lpfc_nodelist *ndlp, uint32_t event_tag, uint32_t num_entry, 591 uint32_t tmo, uint8_t retry) 592 { 593 struct lpfc_hba *phba = vport->phba; 594 struct lpfc_iocbq *geniocb; 595 int rc; 596 u16 ulp_context; 597 598 /* Allocate buffer for command iocb */ 599 geniocb = lpfc_sli_get_iocbq(phba); 600 601 if (geniocb == NULL) 602 return 1; 603 604 /* Update the num_entry bde count */ 605 geniocb->num_bdes = num_entry; 606 607 geniocb->bpl_dmabuf = bmp; 608 609 /* Save for completion so we can release these resources */ 610 geniocb->cmd_dmabuf = inp; 611 geniocb->rsp_dmabuf = outp; 612 613 geniocb->event_tag = event_tag; 614 615 if (!tmo) { 616 /* FC spec states we need 3 * ratov for CT requests */ 617 tmo = (3 * phba->fc_ratov); 618 } 619 620 if (phba->sli_rev == LPFC_SLI_REV4) 621 ulp_context = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]; 622 else 623 ulp_context = ndlp->nlp_rpi; 624 625 lpfc_sli_prep_gen_req(phba, geniocb, bmp, ulp_context, num_entry, tmo); 626 627 /* Issue GEN REQ IOCB for NPORT <did> */ 628 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, 629 "0119 Issue GEN REQ IOCB to NPORT x%x " 630 "Data: x%x x%x\n", 631 ndlp->nlp_DID, geniocb->iotag, 632 vport->port_state); 633 geniocb->cmd_cmpl = cmpl; 634 geniocb->drvrTimeout = tmo + LPFC_DRVR_TIMEOUT; 635 geniocb->vport = vport; 636 geniocb->retry = retry; 637 geniocb->ndlp = lpfc_nlp_get(ndlp); 638 if (!geniocb->ndlp) 639 goto out; 640 641 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, geniocb, 0); 642 if (rc == IOCB_ERROR) { 643 lpfc_nlp_put(ndlp); 644 goto out; 645 } 646 647 return 0; 648 out: 649 lpfc_sli_release_iocbq(phba, geniocb); 650 return 1; 651 } 652 653 /* 654 * lpfc_ct_cmd - Build and issue a CT command 655 * @vport: pointer to a host virtual N_Port data structure. 656 * @inmp: Pointer to data buffer for response data. 657 * @bmp: Pointer to BPL for SLI command 658 * @ndlp: Destination NPort nodelist entry 659 * @cmpl: completion routine to call when command completes 660 * 661 * This function is called for issuing a CT command. 662 */ 663 static int 664 lpfc_ct_cmd(struct lpfc_vport *vport, struct lpfc_dmabuf *inmp, 665 struct lpfc_dmabuf *bmp, struct lpfc_nodelist *ndlp, 666 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 667 struct lpfc_iocbq *), 668 uint32_t rsp_size, uint8_t retry) 669 { 670 struct lpfc_hba *phba = vport->phba; 671 struct ulp_bde64 *bpl = (struct ulp_bde64 *) bmp->virt; 672 struct lpfc_dmabuf *outmp; 673 int cnt = 0, status; 674 int cmdcode = ((struct lpfc_sli_ct_request *) inmp->virt)-> 675 CommandResponse.bits.CmdRsp; 676 677 bpl++; /* Skip past ct request */ 678 679 /* Put buffer(s) for ct rsp in bpl */ 680 outmp = lpfc_alloc_ct_rsp(phba, cmdcode, bpl, rsp_size, &cnt); 681 if (!outmp) 682 return -ENOMEM; 683 /* 684 * Form the CT IOCB. The total number of BDEs in this IOCB 685 * is the single command plus response count from 686 * lpfc_alloc_ct_rsp. 687 */ 688 cnt += 1; 689 status = lpfc_gen_req(vport, bmp, inmp, outmp, cmpl, ndlp, 690 phba->fc_eventTag, cnt, 0, retry); 691 if (status) { 692 lpfc_free_ct_rsp(phba, outmp); 693 return -ENOMEM; 694 } 695 return 0; 696 } 697 698 struct lpfc_vport * 699 lpfc_find_vport_by_did(struct lpfc_hba *phba, uint32_t did) { 700 struct lpfc_vport *vport_curr; 701 unsigned long flags; 702 703 spin_lock_irqsave(&phba->port_list_lock, flags); 704 list_for_each_entry(vport_curr, &phba->port_list, listentry) { 705 if ((vport_curr->fc_myDID) && (vport_curr->fc_myDID == did)) { 706 spin_unlock_irqrestore(&phba->port_list_lock, flags); 707 return vport_curr; 708 } 709 } 710 spin_unlock_irqrestore(&phba->port_list_lock, flags); 711 return NULL; 712 } 713 714 static void 715 lpfc_prep_node_fc4type(struct lpfc_vport *vport, uint32_t Did, uint8_t fc4_type) 716 { 717 struct lpfc_nodelist *ndlp; 718 719 if ((vport->port_type != LPFC_NPIV_PORT) || 720 !(vport->ct_flags & FC_CT_RFF_ID) || !vport->cfg_restrict_login) { 721 722 ndlp = lpfc_setup_disc_node(vport, Did); 723 724 if (ndlp) { 725 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 726 "Parse GID_FTrsp: did:x%x flg:x%x x%x", 727 Did, ndlp->nlp_flag, vport->fc_flag); 728 729 /* By default, the driver expects to support FCP FC4 */ 730 if (fc4_type == FC_TYPE_FCP) 731 ndlp->nlp_fc4_type |= NLP_FC4_FCP; 732 733 if (fc4_type == FC_TYPE_NVME) 734 ndlp->nlp_fc4_type |= NLP_FC4_NVME; 735 736 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 737 "0238 Process x%06x NameServer Rsp " 738 "Data: x%x x%x x%x x%x x%x\n", Did, 739 ndlp->nlp_flag, ndlp->nlp_fc4_type, 740 ndlp->nlp_state, vport->fc_flag, 741 vport->fc_rscn_id_cnt); 742 743 /* if ndlp needs to be discovered and prior 744 * state of ndlp hit devloss, change state to 745 * allow rediscovery. 746 */ 747 if (ndlp->nlp_flag & NLP_NPR_2B_DISC && 748 ndlp->nlp_state == NLP_STE_UNUSED_NODE) { 749 lpfc_nlp_set_state(vport, ndlp, 750 NLP_STE_NPR_NODE); 751 } 752 } else { 753 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 754 "Skip1 GID_FTrsp: did:x%x flg:x%x cnt:%d", 755 Did, vport->fc_flag, vport->fc_rscn_id_cnt); 756 757 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 758 "0239 Skip x%06x NameServer Rsp " 759 "Data: x%x x%x x%px\n", 760 Did, vport->fc_flag, 761 vport->fc_rscn_id_cnt, ndlp); 762 } 763 } else { 764 if (!(vport->fc_flag & FC_RSCN_MODE) || 765 lpfc_rscn_payload_check(vport, Did)) { 766 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 767 "Query GID_FTrsp: did:x%x flg:x%x cnt:%d", 768 Did, vport->fc_flag, vport->fc_rscn_id_cnt); 769 770 /* 771 * This NPortID was previously a FCP/NVMe target, 772 * Don't even bother to send GFF_ID. 773 */ 774 ndlp = lpfc_findnode_did(vport, Did); 775 if (ndlp && 776 (ndlp->nlp_type & 777 (NLP_FCP_TARGET | NLP_NVME_TARGET))) { 778 if (fc4_type == FC_TYPE_FCP) 779 ndlp->nlp_fc4_type |= NLP_FC4_FCP; 780 if (fc4_type == FC_TYPE_NVME) 781 ndlp->nlp_fc4_type |= NLP_FC4_NVME; 782 lpfc_setup_disc_node(vport, Did); 783 } else if (lpfc_ns_cmd(vport, SLI_CTNS_GFF_ID, 784 0, Did) == 0) 785 vport->num_disc_nodes++; 786 else 787 lpfc_setup_disc_node(vport, Did); 788 } else { 789 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 790 "Skip2 GID_FTrsp: did:x%x flg:x%x cnt:%d", 791 Did, vport->fc_flag, vport->fc_rscn_id_cnt); 792 793 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 794 "0245 Skip x%06x NameServer Rsp " 795 "Data: x%x x%x\n", Did, 796 vport->fc_flag, 797 vport->fc_rscn_id_cnt); 798 } 799 } 800 } 801 802 static void 803 lpfc_ns_rsp_audit_did(struct lpfc_vport *vport, uint32_t Did, uint8_t fc4_type) 804 { 805 struct lpfc_hba *phba = vport->phba; 806 struct lpfc_nodelist *ndlp = NULL; 807 char *str; 808 809 if (phba->cfg_ns_query == LPFC_NS_QUERY_GID_FT) 810 str = "GID_FT"; 811 else 812 str = "GID_PT"; 813 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 814 "6430 Process %s rsp for %08x type %x %s %s\n", 815 str, Did, fc4_type, 816 (fc4_type == FC_TYPE_FCP) ? "FCP" : " ", 817 (fc4_type == FC_TYPE_NVME) ? "NVME" : " "); 818 /* 819 * To conserve rpi's, filter out addresses for other 820 * vports on the same physical HBAs. 821 */ 822 if (Did != vport->fc_myDID && 823 (!lpfc_find_vport_by_did(phba, Did) || 824 vport->cfg_peer_port_login)) { 825 if (!phba->nvmet_support) { 826 /* FCPI/NVMEI path. Process Did */ 827 lpfc_prep_node_fc4type(vport, Did, fc4_type); 828 return; 829 } 830 /* NVMET path. NVMET only cares about NVMEI nodes. */ 831 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 832 if (ndlp->nlp_type != NLP_NVME_INITIATOR || 833 ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) 834 continue; 835 spin_lock_irq(&ndlp->lock); 836 if (ndlp->nlp_DID == Did) 837 ndlp->nlp_flag &= ~NLP_NVMET_RECOV; 838 else 839 ndlp->nlp_flag |= NLP_NVMET_RECOV; 840 spin_unlock_irq(&ndlp->lock); 841 } 842 } 843 } 844 845 static int 846 lpfc_ns_rsp(struct lpfc_vport *vport, struct lpfc_dmabuf *mp, uint8_t fc4_type, 847 uint32_t Size) 848 { 849 struct lpfc_sli_ct_request *Response = 850 (struct lpfc_sli_ct_request *) mp->virt; 851 struct lpfc_dmabuf *mlast, *next_mp; 852 uint32_t *ctptr = (uint32_t *) & Response->un.gid.PortType; 853 uint32_t Did, CTentry; 854 int Cnt; 855 struct list_head head; 856 struct lpfc_nodelist *ndlp = NULL; 857 858 lpfc_set_disctmo(vport); 859 vport->num_disc_nodes = 0; 860 vport->fc_ns_retry = 0; 861 862 863 list_add_tail(&head, &mp->list); 864 list_for_each_entry_safe(mp, next_mp, &head, list) { 865 mlast = mp; 866 867 Cnt = Size > FCELSSIZE ? FCELSSIZE : Size; 868 869 Size -= Cnt; 870 871 if (!ctptr) { 872 ctptr = (uint32_t *) mlast->virt; 873 } else 874 Cnt -= 16; /* subtract length of CT header */ 875 876 /* Loop through entire NameServer list of DIDs */ 877 while (Cnt >= sizeof(uint32_t)) { 878 /* Get next DID from NameServer List */ 879 CTentry = *ctptr++; 880 Did = ((be32_to_cpu(CTentry)) & Mask_DID); 881 lpfc_ns_rsp_audit_did(vport, Did, fc4_type); 882 if (CTentry & (cpu_to_be32(SLI_CT_LAST_ENTRY))) 883 goto nsout1; 884 885 Cnt -= sizeof(uint32_t); 886 } 887 ctptr = NULL; 888 889 } 890 891 /* All GID_FT entries processed. If the driver is running in 892 * in target mode, put impacted nodes into recovery and drop 893 * the RPI to flush outstanding IO. 894 */ 895 if (vport->phba->nvmet_support) { 896 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 897 if (!(ndlp->nlp_flag & NLP_NVMET_RECOV)) 898 continue; 899 lpfc_disc_state_machine(vport, ndlp, NULL, 900 NLP_EVT_DEVICE_RECOVERY); 901 spin_lock_irq(&ndlp->lock); 902 ndlp->nlp_flag &= ~NLP_NVMET_RECOV; 903 spin_unlock_irq(&ndlp->lock); 904 } 905 } 906 907 nsout1: 908 list_del(&head); 909 return 0; 910 } 911 912 static void 913 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 914 struct lpfc_iocbq *rspiocb) 915 { 916 struct lpfc_vport *vport = cmdiocb->vport; 917 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 918 struct lpfc_dmabuf *outp; 919 struct lpfc_dmabuf *inp; 920 struct lpfc_sli_ct_request *CTrsp; 921 struct lpfc_sli_ct_request *CTreq; 922 struct lpfc_nodelist *ndlp; 923 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 924 u32 ulp_word4 = get_job_word4(phba, rspiocb); 925 int rc, type; 926 927 /* First save ndlp, before we overwrite it */ 928 ndlp = cmdiocb->ndlp; 929 930 /* we pass cmdiocb to state machine which needs rspiocb as well */ 931 cmdiocb->rsp_iocb = rspiocb; 932 inp = cmdiocb->cmd_dmabuf; 933 outp = cmdiocb->rsp_dmabuf; 934 935 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 936 "GID_FT cmpl: status:x%x/x%x rtry:%d", 937 ulp_status, ulp_word4, vport->fc_ns_retry); 938 939 /* Ignore response if link flipped after this request was made */ 940 if (cmdiocb->event_tag != phba->fc_eventTag) { 941 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 942 "9043 Event tag mismatch. Ignoring NS rsp\n"); 943 goto out; 944 } 945 946 /* Don't bother processing response if vport is being torn down. */ 947 if (vport->load_flag & FC_UNLOADING) { 948 if (vport->fc_flag & FC_RSCN_MODE) 949 lpfc_els_flush_rscn(vport); 950 goto out; 951 } 952 953 if (lpfc_els_chk_latt(vport)) { 954 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 955 "0216 Link event during NS query\n"); 956 if (vport->fc_flag & FC_RSCN_MODE) 957 lpfc_els_flush_rscn(vport); 958 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 959 goto out; 960 } 961 if (lpfc_error_lost_link(ulp_status, ulp_word4)) { 962 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 963 "0226 NS query failed due to link event: " 964 "ulp_status x%x ulp_word4 x%x fc_flag x%x " 965 "port_state x%x gidft_inp x%x\n", 966 ulp_status, ulp_word4, vport->fc_flag, 967 vport->port_state, vport->gidft_inp); 968 if (vport->fc_flag & FC_RSCN_MODE) 969 lpfc_els_flush_rscn(vport); 970 if (vport->gidft_inp) 971 vport->gidft_inp--; 972 goto out; 973 } 974 975 spin_lock_irq(shost->host_lock); 976 if (vport->fc_flag & FC_RSCN_DEFERRED) { 977 vport->fc_flag &= ~FC_RSCN_DEFERRED; 978 spin_unlock_irq(shost->host_lock); 979 980 /* This is a GID_FT completing so the gidft_inp counter was 981 * incremented before the GID_FT was issued to the wire. 982 */ 983 if (vport->gidft_inp) 984 vport->gidft_inp--; 985 986 /* 987 * Skip processing the NS response 988 * Re-issue the NS cmd 989 */ 990 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, 991 "0151 Process Deferred RSCN Data: x%x x%x\n", 992 vport->fc_flag, vport->fc_rscn_id_cnt); 993 lpfc_els_handle_rscn(vport); 994 995 goto out; 996 } 997 spin_unlock_irq(shost->host_lock); 998 999 if (ulp_status) { 1000 /* Check for retry */ 1001 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) { 1002 if (ulp_status != IOSTAT_LOCAL_REJECT || 1003 (ulp_word4 & IOERR_PARAM_MASK) != 1004 IOERR_NO_RESOURCES) 1005 vport->fc_ns_retry++; 1006 1007 type = lpfc_get_gidft_type(vport, cmdiocb); 1008 if (type == 0) 1009 goto out; 1010 1011 /* CT command is being retried */ 1012 rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT, 1013 vport->fc_ns_retry, type); 1014 if (rc == 0) 1015 goto out; 1016 else { /* Unable to send NS cmd */ 1017 if (vport->gidft_inp) 1018 vport->gidft_inp--; 1019 } 1020 } 1021 if (vport->fc_flag & FC_RSCN_MODE) 1022 lpfc_els_flush_rscn(vport); 1023 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 1024 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT, 1025 "0257 GID_FT Query error: 0x%x 0x%x\n", 1026 ulp_status, vport->fc_ns_retry); 1027 } else { 1028 /* Good status, continue checking */ 1029 CTreq = (struct lpfc_sli_ct_request *) inp->virt; 1030 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 1031 if (CTrsp->CommandResponse.bits.CmdRsp == 1032 cpu_to_be16(SLI_CT_RESPONSE_FS_ACC)) { 1033 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1034 "0208 NameServer Rsp Data: x%x x%x " 1035 "x%x x%x sz x%x\n", 1036 vport->fc_flag, 1037 CTreq->un.gid.Fc4Type, 1038 vport->num_disc_nodes, 1039 vport->gidft_inp, 1040 get_job_data_placed(phba, rspiocb)); 1041 1042 lpfc_ns_rsp(vport, 1043 outp, 1044 CTreq->un.gid.Fc4Type, 1045 get_job_data_placed(phba, rspiocb)); 1046 } else if (CTrsp->CommandResponse.bits.CmdRsp == 1047 be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) { 1048 /* NameServer Rsp Error */ 1049 if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ) 1050 && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) { 1051 lpfc_printf_vlog(vport, KERN_INFO, 1052 LOG_DISCOVERY, 1053 "0269 No NameServer Entries " 1054 "Data: x%x x%x x%x x%x\n", 1055 CTrsp->CommandResponse.bits.CmdRsp, 1056 (uint32_t) CTrsp->ReasonCode, 1057 (uint32_t) CTrsp->Explanation, 1058 vport->fc_flag); 1059 1060 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 1061 "GID_FT no entry cmd:x%x rsn:x%x exp:x%x", 1062 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp, 1063 (uint32_t) CTrsp->ReasonCode, 1064 (uint32_t) CTrsp->Explanation); 1065 } else { 1066 lpfc_printf_vlog(vport, KERN_INFO, 1067 LOG_DISCOVERY, 1068 "0240 NameServer Rsp Error " 1069 "Data: x%x x%x x%x x%x\n", 1070 CTrsp->CommandResponse.bits.CmdRsp, 1071 (uint32_t) CTrsp->ReasonCode, 1072 (uint32_t) CTrsp->Explanation, 1073 vport->fc_flag); 1074 1075 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 1076 "GID_FT rsp err1 cmd:x%x rsn:x%x exp:x%x", 1077 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp, 1078 (uint32_t) CTrsp->ReasonCode, 1079 (uint32_t) CTrsp->Explanation); 1080 } 1081 1082 1083 } else { 1084 /* NameServer Rsp Error */ 1085 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT, 1086 "0241 NameServer Rsp Error " 1087 "Data: x%x x%x x%x x%x\n", 1088 CTrsp->CommandResponse.bits.CmdRsp, 1089 (uint32_t) CTrsp->ReasonCode, 1090 (uint32_t) CTrsp->Explanation, 1091 vport->fc_flag); 1092 1093 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 1094 "GID_FT rsp err2 cmd:x%x rsn:x%x exp:x%x", 1095 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp, 1096 (uint32_t) CTrsp->ReasonCode, 1097 (uint32_t) CTrsp->Explanation); 1098 } 1099 if (vport->gidft_inp) 1100 vport->gidft_inp--; 1101 } 1102 1103 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1104 "4216 GID_FT cmpl inp %d disc %d\n", 1105 vport->gidft_inp, vport->num_disc_nodes); 1106 1107 /* Link up / RSCN discovery */ 1108 if ((vport->num_disc_nodes == 0) && 1109 (vport->gidft_inp == 0)) { 1110 /* 1111 * The driver has cycled through all Nports in the RSCN payload. 1112 * Complete the handling by cleaning up and marking the 1113 * current driver state. 1114 */ 1115 if (vport->port_state >= LPFC_DISC_AUTH) { 1116 if (vport->fc_flag & FC_RSCN_MODE) { 1117 lpfc_els_flush_rscn(vport); 1118 spin_lock_irq(shost->host_lock); 1119 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */ 1120 spin_unlock_irq(shost->host_lock); 1121 } 1122 else 1123 lpfc_els_flush_rscn(vport); 1124 } 1125 1126 lpfc_disc_start(vport); 1127 } 1128 out: 1129 lpfc_ct_free_iocb(phba, cmdiocb); 1130 lpfc_nlp_put(ndlp); 1131 return; 1132 } 1133 1134 static void 1135 lpfc_cmpl_ct_cmd_gid_pt(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1136 struct lpfc_iocbq *rspiocb) 1137 { 1138 struct lpfc_vport *vport = cmdiocb->vport; 1139 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1140 struct lpfc_dmabuf *outp; 1141 struct lpfc_dmabuf *inp; 1142 struct lpfc_sli_ct_request *CTrsp; 1143 struct lpfc_sli_ct_request *CTreq; 1144 struct lpfc_nodelist *ndlp; 1145 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 1146 u32 ulp_word4 = get_job_word4(phba, rspiocb); 1147 int rc; 1148 1149 /* First save ndlp, before we overwrite it */ 1150 ndlp = cmdiocb->ndlp; 1151 1152 /* we pass cmdiocb to state machine which needs rspiocb as well */ 1153 cmdiocb->rsp_iocb = rspiocb; 1154 inp = cmdiocb->cmd_dmabuf; 1155 outp = cmdiocb->rsp_dmabuf; 1156 1157 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 1158 "GID_PT cmpl: status:x%x/x%x rtry:%d", 1159 ulp_status, ulp_word4, 1160 vport->fc_ns_retry); 1161 1162 /* Ignore response if link flipped after this request was made */ 1163 if (cmdiocb->event_tag != phba->fc_eventTag) { 1164 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1165 "9044 Event tag mismatch. Ignoring NS rsp\n"); 1166 goto out; 1167 } 1168 1169 /* Don't bother processing response if vport is being torn down. */ 1170 if (vport->load_flag & FC_UNLOADING) { 1171 if (vport->fc_flag & FC_RSCN_MODE) 1172 lpfc_els_flush_rscn(vport); 1173 goto out; 1174 } 1175 1176 if (lpfc_els_chk_latt(vport)) { 1177 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1178 "4108 Link event during NS query\n"); 1179 if (vport->fc_flag & FC_RSCN_MODE) 1180 lpfc_els_flush_rscn(vport); 1181 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 1182 goto out; 1183 } 1184 if (lpfc_error_lost_link(ulp_status, ulp_word4)) { 1185 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1186 "4166 NS query failed due to link event: " 1187 "ulp_status x%x ulp_word4 x%x fc_flag x%x " 1188 "port_state x%x gidft_inp x%x\n", 1189 ulp_status, ulp_word4, vport->fc_flag, 1190 vport->port_state, vport->gidft_inp); 1191 if (vport->fc_flag & FC_RSCN_MODE) 1192 lpfc_els_flush_rscn(vport); 1193 if (vport->gidft_inp) 1194 vport->gidft_inp--; 1195 goto out; 1196 } 1197 1198 spin_lock_irq(shost->host_lock); 1199 if (vport->fc_flag & FC_RSCN_DEFERRED) { 1200 vport->fc_flag &= ~FC_RSCN_DEFERRED; 1201 spin_unlock_irq(shost->host_lock); 1202 1203 /* This is a GID_PT completing so the gidft_inp counter was 1204 * incremented before the GID_PT was issued to the wire. 1205 */ 1206 if (vport->gidft_inp) 1207 vport->gidft_inp--; 1208 1209 /* 1210 * Skip processing the NS response 1211 * Re-issue the NS cmd 1212 */ 1213 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, 1214 "4167 Process Deferred RSCN Data: x%x x%x\n", 1215 vport->fc_flag, vport->fc_rscn_id_cnt); 1216 lpfc_els_handle_rscn(vport); 1217 1218 goto out; 1219 } 1220 spin_unlock_irq(shost->host_lock); 1221 1222 if (ulp_status) { 1223 /* Check for retry */ 1224 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) { 1225 if (ulp_status != IOSTAT_LOCAL_REJECT || 1226 (ulp_word4 & IOERR_PARAM_MASK) != 1227 IOERR_NO_RESOURCES) 1228 vport->fc_ns_retry++; 1229 1230 /* CT command is being retried */ 1231 rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_PT, 1232 vport->fc_ns_retry, GID_PT_N_PORT); 1233 if (rc == 0) 1234 goto out; 1235 else { /* Unable to send NS cmd */ 1236 if (vport->gidft_inp) 1237 vport->gidft_inp--; 1238 } 1239 } 1240 if (vport->fc_flag & FC_RSCN_MODE) 1241 lpfc_els_flush_rscn(vport); 1242 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 1243 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT, 1244 "4103 GID_FT Query error: 0x%x 0x%x\n", 1245 ulp_status, vport->fc_ns_retry); 1246 } else { 1247 /* Good status, continue checking */ 1248 CTreq = (struct lpfc_sli_ct_request *)inp->virt; 1249 CTrsp = (struct lpfc_sli_ct_request *)outp->virt; 1250 if (CTrsp->CommandResponse.bits.CmdRsp == 1251 cpu_to_be16(SLI_CT_RESPONSE_FS_ACC)) { 1252 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1253 "4105 NameServer Rsp Data: x%x x%x " 1254 "x%x x%x sz x%x\n", 1255 vport->fc_flag, 1256 CTreq->un.gid.Fc4Type, 1257 vport->num_disc_nodes, 1258 vport->gidft_inp, 1259 get_job_data_placed(phba, rspiocb)); 1260 1261 lpfc_ns_rsp(vport, 1262 outp, 1263 CTreq->un.gid.Fc4Type, 1264 get_job_data_placed(phba, rspiocb)); 1265 } else if (CTrsp->CommandResponse.bits.CmdRsp == 1266 be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) { 1267 /* NameServer Rsp Error */ 1268 if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ) 1269 && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) { 1270 lpfc_printf_vlog( 1271 vport, KERN_INFO, LOG_DISCOVERY, 1272 "4106 No NameServer Entries " 1273 "Data: x%x x%x x%x x%x\n", 1274 CTrsp->CommandResponse.bits.CmdRsp, 1275 (uint32_t)CTrsp->ReasonCode, 1276 (uint32_t)CTrsp->Explanation, 1277 vport->fc_flag); 1278 1279 lpfc_debugfs_disc_trc( 1280 vport, LPFC_DISC_TRC_CT, 1281 "GID_PT no entry cmd:x%x rsn:x%x exp:x%x", 1282 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp, 1283 (uint32_t)CTrsp->ReasonCode, 1284 (uint32_t)CTrsp->Explanation); 1285 } else { 1286 lpfc_printf_vlog( 1287 vport, KERN_INFO, LOG_DISCOVERY, 1288 "4107 NameServer Rsp Error " 1289 "Data: x%x x%x x%x x%x\n", 1290 CTrsp->CommandResponse.bits.CmdRsp, 1291 (uint32_t)CTrsp->ReasonCode, 1292 (uint32_t)CTrsp->Explanation, 1293 vport->fc_flag); 1294 1295 lpfc_debugfs_disc_trc( 1296 vport, LPFC_DISC_TRC_CT, 1297 "GID_PT rsp err1 cmd:x%x rsn:x%x exp:x%x", 1298 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp, 1299 (uint32_t)CTrsp->ReasonCode, 1300 (uint32_t)CTrsp->Explanation); 1301 } 1302 } else { 1303 /* NameServer Rsp Error */ 1304 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT, 1305 "4109 NameServer Rsp Error " 1306 "Data: x%x x%x x%x x%x\n", 1307 CTrsp->CommandResponse.bits.CmdRsp, 1308 (uint32_t)CTrsp->ReasonCode, 1309 (uint32_t)CTrsp->Explanation, 1310 vport->fc_flag); 1311 1312 lpfc_debugfs_disc_trc( 1313 vport, LPFC_DISC_TRC_CT, 1314 "GID_PT rsp err2 cmd:x%x rsn:x%x exp:x%x", 1315 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp, 1316 (uint32_t)CTrsp->ReasonCode, 1317 (uint32_t)CTrsp->Explanation); 1318 } 1319 if (vport->gidft_inp) 1320 vport->gidft_inp--; 1321 } 1322 1323 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1324 "6450 GID_PT cmpl inp %d disc %d\n", 1325 vport->gidft_inp, vport->num_disc_nodes); 1326 1327 /* Link up / RSCN discovery */ 1328 if ((vport->num_disc_nodes == 0) && 1329 (vport->gidft_inp == 0)) { 1330 /* 1331 * The driver has cycled through all Nports in the RSCN payload. 1332 * Complete the handling by cleaning up and marking the 1333 * current driver state. 1334 */ 1335 if (vport->port_state >= LPFC_DISC_AUTH) { 1336 if (vport->fc_flag & FC_RSCN_MODE) { 1337 lpfc_els_flush_rscn(vport); 1338 spin_lock_irq(shost->host_lock); 1339 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */ 1340 spin_unlock_irq(shost->host_lock); 1341 } else { 1342 lpfc_els_flush_rscn(vport); 1343 } 1344 } 1345 1346 lpfc_disc_start(vport); 1347 } 1348 out: 1349 lpfc_ct_free_iocb(phba, cmdiocb); 1350 lpfc_nlp_put(ndlp); 1351 } 1352 1353 static void 1354 lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1355 struct lpfc_iocbq *rspiocb) 1356 { 1357 struct lpfc_vport *vport = cmdiocb->vport; 1358 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1359 struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf; 1360 struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf; 1361 struct lpfc_sli_ct_request *CTrsp; 1362 int did, rc, retry; 1363 uint8_t fbits; 1364 struct lpfc_nodelist *ndlp = NULL, *free_ndlp = NULL; 1365 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 1366 u32 ulp_word4 = get_job_word4(phba, rspiocb); 1367 1368 did = ((struct lpfc_sli_ct_request *) inp->virt)->un.gff.PortId; 1369 did = be32_to_cpu(did); 1370 1371 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 1372 "GFF_ID cmpl: status:x%x/x%x did:x%x", 1373 ulp_status, ulp_word4, did); 1374 1375 /* Ignore response if link flipped after this request was made */ 1376 if (cmdiocb->event_tag != phba->fc_eventTag) { 1377 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1378 "9045 Event tag mismatch. Ignoring NS rsp\n"); 1379 goto iocb_free; 1380 } 1381 1382 if (ulp_status == IOSTAT_SUCCESS) { 1383 /* Good status, continue checking */ 1384 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 1385 fbits = CTrsp->un.gff_acc.fbits[FCP_TYPE_FEATURE_OFFSET]; 1386 1387 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1388 "6431 Process GFF_ID rsp for %08x " 1389 "fbits %02x %s %s\n", 1390 did, fbits, 1391 (fbits & FC4_FEATURE_INIT) ? "Initiator" : " ", 1392 (fbits & FC4_FEATURE_TARGET) ? "Target" : " "); 1393 1394 if (CTrsp->CommandResponse.bits.CmdRsp == 1395 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) { 1396 if ((fbits & FC4_FEATURE_INIT) && 1397 !(fbits & FC4_FEATURE_TARGET)) { 1398 lpfc_printf_vlog(vport, KERN_INFO, 1399 LOG_DISCOVERY, 1400 "0270 Skip x%x GFF " 1401 "NameServer Rsp Data: (init) " 1402 "x%x x%x\n", did, fbits, 1403 vport->fc_rscn_id_cnt); 1404 goto out; 1405 } 1406 } 1407 } 1408 else { 1409 /* Check for retry */ 1410 if (cmdiocb->retry < LPFC_MAX_NS_RETRY) { 1411 retry = 1; 1412 if (ulp_status == IOSTAT_LOCAL_REJECT) { 1413 switch ((ulp_word4 & 1414 IOERR_PARAM_MASK)) { 1415 1416 case IOERR_NO_RESOURCES: 1417 /* We don't increment the retry 1418 * count for this case. 1419 */ 1420 break; 1421 case IOERR_LINK_DOWN: 1422 case IOERR_SLI_ABORTED: 1423 case IOERR_SLI_DOWN: 1424 retry = 0; 1425 break; 1426 default: 1427 cmdiocb->retry++; 1428 } 1429 } 1430 else 1431 cmdiocb->retry++; 1432 1433 if (retry) { 1434 /* CT command is being retried */ 1435 rc = lpfc_ns_cmd(vport, SLI_CTNS_GFF_ID, 1436 cmdiocb->retry, did); 1437 if (rc == 0) { 1438 /* success */ 1439 free_ndlp = cmdiocb->ndlp; 1440 lpfc_ct_free_iocb(phba, cmdiocb); 1441 lpfc_nlp_put(free_ndlp); 1442 return; 1443 } 1444 } 1445 } 1446 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT, 1447 "0267 NameServer GFF Rsp " 1448 "x%x Error (%d %d) Data: x%x x%x\n", 1449 did, ulp_status, ulp_word4, 1450 vport->fc_flag, vport->fc_rscn_id_cnt); 1451 } 1452 1453 /* This is a target port, unregistered port, or the GFF_ID failed */ 1454 ndlp = lpfc_setup_disc_node(vport, did); 1455 if (ndlp) { 1456 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1457 "0242 Process x%x GFF " 1458 "NameServer Rsp Data: x%x x%x x%x\n", 1459 did, ndlp->nlp_flag, vport->fc_flag, 1460 vport->fc_rscn_id_cnt); 1461 } else { 1462 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1463 "0243 Skip x%x GFF " 1464 "NameServer Rsp Data: x%x x%x\n", did, 1465 vport->fc_flag, vport->fc_rscn_id_cnt); 1466 } 1467 out: 1468 /* Link up / RSCN discovery */ 1469 if (vport->num_disc_nodes) 1470 vport->num_disc_nodes--; 1471 1472 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1473 "6451 GFF_ID cmpl inp %d disc %d\n", 1474 vport->gidft_inp, vport->num_disc_nodes); 1475 1476 if (vport->num_disc_nodes == 0) { 1477 /* 1478 * The driver has cycled through all Nports in the RSCN payload. 1479 * Complete the handling by cleaning up and marking the 1480 * current driver state. 1481 */ 1482 if (vport->port_state >= LPFC_DISC_AUTH) { 1483 if (vport->fc_flag & FC_RSCN_MODE) { 1484 lpfc_els_flush_rscn(vport); 1485 spin_lock_irq(shost->host_lock); 1486 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */ 1487 spin_unlock_irq(shost->host_lock); 1488 } 1489 else 1490 lpfc_els_flush_rscn(vport); 1491 } 1492 lpfc_disc_start(vport); 1493 } 1494 1495 iocb_free: 1496 free_ndlp = cmdiocb->ndlp; 1497 lpfc_ct_free_iocb(phba, cmdiocb); 1498 lpfc_nlp_put(free_ndlp); 1499 return; 1500 } 1501 1502 static void 1503 lpfc_cmpl_ct_cmd_gft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1504 struct lpfc_iocbq *rspiocb) 1505 { 1506 struct lpfc_vport *vport = cmdiocb->vport; 1507 struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf; 1508 struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf; 1509 struct lpfc_sli_ct_request *CTrsp; 1510 int did; 1511 struct lpfc_nodelist *ndlp = NULL; 1512 struct lpfc_nodelist *ns_ndlp = NULL; 1513 uint32_t fc4_data_0, fc4_data_1; 1514 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 1515 u32 ulp_word4 = get_job_word4(phba, rspiocb); 1516 1517 did = ((struct lpfc_sli_ct_request *)inp->virt)->un.gft.PortId; 1518 did = be32_to_cpu(did); 1519 1520 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 1521 "GFT_ID cmpl: status:x%x/x%x did:x%x", 1522 ulp_status, ulp_word4, did); 1523 1524 /* Ignore response if link flipped after this request was made */ 1525 if ((uint32_t) cmdiocb->event_tag != phba->fc_eventTag) { 1526 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1527 "9046 Event tag mismatch. Ignoring NS rsp\n"); 1528 goto out; 1529 } 1530 1531 /* Preserve the nameserver node to release the reference. */ 1532 ns_ndlp = cmdiocb->ndlp; 1533 1534 if (ulp_status == IOSTAT_SUCCESS) { 1535 /* Good status, continue checking */ 1536 CTrsp = (struct lpfc_sli_ct_request *)outp->virt; 1537 fc4_data_0 = be32_to_cpu(CTrsp->un.gft_acc.fc4_types[0]); 1538 fc4_data_1 = be32_to_cpu(CTrsp->un.gft_acc.fc4_types[1]); 1539 1540 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1541 "6432 Process GFT_ID rsp for %08x " 1542 "Data %08x %08x %s %s\n", 1543 did, fc4_data_0, fc4_data_1, 1544 (fc4_data_0 & LPFC_FC4_TYPE_BITMASK) ? 1545 "FCP" : " ", 1546 (fc4_data_1 & LPFC_FC4_TYPE_BITMASK) ? 1547 "NVME" : " "); 1548 1549 /* Lookup the NPort_ID queried in the GFT_ID and find the 1550 * driver's local node. It's an error if the driver 1551 * doesn't have one. 1552 */ 1553 ndlp = lpfc_findnode_did(vport, did); 1554 if (ndlp) { 1555 /* The bitmask value for FCP and NVME FCP types is 1556 * the same because they are 32 bits distant from 1557 * each other in word0 and word0. 1558 */ 1559 if (fc4_data_0 & LPFC_FC4_TYPE_BITMASK) 1560 ndlp->nlp_fc4_type |= NLP_FC4_FCP; 1561 if (fc4_data_1 & LPFC_FC4_TYPE_BITMASK) 1562 ndlp->nlp_fc4_type |= NLP_FC4_NVME; 1563 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1564 "3064 Setting ndlp x%px, DID x%06x " 1565 "with FC4 x%08x, Data: x%08x x%08x " 1566 "%d\n", 1567 ndlp, did, ndlp->nlp_fc4_type, 1568 FC_TYPE_FCP, FC_TYPE_NVME, 1569 ndlp->nlp_state); 1570 1571 if (ndlp->nlp_state == NLP_STE_REG_LOGIN_ISSUE && 1572 ndlp->nlp_fc4_type) { 1573 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE; 1574 1575 lpfc_nlp_set_state(vport, ndlp, 1576 NLP_STE_PRLI_ISSUE); 1577 lpfc_issue_els_prli(vport, ndlp, 0); 1578 } else if (!ndlp->nlp_fc4_type) { 1579 /* If fc4 type is still unknown, then LOGO */ 1580 lpfc_printf_vlog(vport, KERN_INFO, 1581 LOG_DISCOVERY, 1582 "6443 Sending LOGO ndlp x%px," 1583 "DID x%06x with fc4_type: " 1584 "x%08x, state: %d\n", 1585 ndlp, did, ndlp->nlp_fc4_type, 1586 ndlp->nlp_state); 1587 lpfc_issue_els_logo(vport, ndlp, 0); 1588 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE; 1589 lpfc_nlp_set_state(vport, ndlp, 1590 NLP_STE_NPR_NODE); 1591 } 1592 } 1593 } else 1594 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT, 1595 "3065 GFT_ID failed x%08x\n", ulp_status); 1596 1597 out: 1598 lpfc_ct_free_iocb(phba, cmdiocb); 1599 lpfc_nlp_put(ns_ndlp); 1600 } 1601 1602 static void 1603 lpfc_cmpl_ct(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1604 struct lpfc_iocbq *rspiocb) 1605 { 1606 struct lpfc_vport *vport = cmdiocb->vport; 1607 struct lpfc_dmabuf *inp; 1608 struct lpfc_dmabuf *outp; 1609 struct lpfc_sli_ct_request *CTrsp; 1610 struct lpfc_nodelist *ndlp; 1611 int cmdcode, rc; 1612 uint8_t retry; 1613 uint32_t latt; 1614 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 1615 u32 ulp_word4 = get_job_word4(phba, rspiocb); 1616 1617 /* First save ndlp, before we overwrite it */ 1618 ndlp = cmdiocb->ndlp; 1619 1620 /* we pass cmdiocb to state machine which needs rspiocb as well */ 1621 cmdiocb->rsp_iocb = rspiocb; 1622 1623 inp = cmdiocb->cmd_dmabuf; 1624 outp = cmdiocb->rsp_dmabuf; 1625 1626 cmdcode = be16_to_cpu(((struct lpfc_sli_ct_request *) inp->virt)-> 1627 CommandResponse.bits.CmdRsp); 1628 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 1629 1630 latt = lpfc_els_chk_latt(vport); 1631 1632 /* RFT request completes status <ulp_status> CmdRsp <CmdRsp> */ 1633 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1634 "0209 CT Request completes, latt %d, " 1635 "ulp_status x%x CmdRsp x%x, Context x%x, Tag x%x\n", 1636 latt, ulp_status, 1637 CTrsp->CommandResponse.bits.CmdRsp, 1638 get_job_ulpcontext(phba, cmdiocb), cmdiocb->iotag); 1639 1640 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 1641 "CT cmd cmpl: status:x%x/x%x cmd:x%x", 1642 ulp_status, ulp_word4, cmdcode); 1643 1644 if (ulp_status) { 1645 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT, 1646 "0268 NS cmd x%x Error (x%x x%x)\n", 1647 cmdcode, ulp_status, ulp_word4); 1648 1649 if (ulp_status == IOSTAT_LOCAL_REJECT && 1650 (((ulp_word4 & IOERR_PARAM_MASK) == 1651 IOERR_SLI_DOWN) || 1652 ((ulp_word4 & IOERR_PARAM_MASK) == 1653 IOERR_SLI_ABORTED))) 1654 goto out; 1655 1656 retry = cmdiocb->retry; 1657 if (retry >= LPFC_MAX_NS_RETRY) 1658 goto out; 1659 1660 retry++; 1661 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1662 "0250 Retrying NS cmd %x\n", cmdcode); 1663 rc = lpfc_ns_cmd(vport, cmdcode, retry, 0); 1664 if (rc == 0) 1665 goto out; 1666 } 1667 1668 out: 1669 lpfc_ct_free_iocb(phba, cmdiocb); 1670 lpfc_nlp_put(ndlp); 1671 return; 1672 } 1673 1674 static void 1675 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1676 struct lpfc_iocbq *rspiocb) 1677 { 1678 struct lpfc_vport *vport = cmdiocb->vport; 1679 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 1680 1681 if (ulp_status == IOSTAT_SUCCESS) { 1682 struct lpfc_dmabuf *outp; 1683 struct lpfc_sli_ct_request *CTrsp; 1684 1685 outp = cmdiocb->rsp_dmabuf; 1686 CTrsp = (struct lpfc_sli_ct_request *)outp->virt; 1687 if (CTrsp->CommandResponse.bits.CmdRsp == 1688 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 1689 vport->ct_flags |= FC_CT_RFT_ID; 1690 } 1691 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 1692 return; 1693 } 1694 1695 static void 1696 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1697 struct lpfc_iocbq *rspiocb) 1698 { 1699 struct lpfc_vport *vport = cmdiocb->vport; 1700 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 1701 1702 if (ulp_status == IOSTAT_SUCCESS) { 1703 struct lpfc_dmabuf *outp; 1704 struct lpfc_sli_ct_request *CTrsp; 1705 1706 outp = cmdiocb->rsp_dmabuf; 1707 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 1708 if (CTrsp->CommandResponse.bits.CmdRsp == 1709 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 1710 vport->ct_flags |= FC_CT_RNN_ID; 1711 } 1712 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 1713 return; 1714 } 1715 1716 static void 1717 lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1718 struct lpfc_iocbq *rspiocb) 1719 { 1720 struct lpfc_vport *vport = cmdiocb->vport; 1721 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 1722 1723 if (ulp_status == IOSTAT_SUCCESS) { 1724 struct lpfc_dmabuf *outp; 1725 struct lpfc_sli_ct_request *CTrsp; 1726 1727 outp = cmdiocb->rsp_dmabuf; 1728 CTrsp = (struct lpfc_sli_ct_request *)outp->virt; 1729 if (CTrsp->CommandResponse.bits.CmdRsp == 1730 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 1731 vport->ct_flags |= FC_CT_RSPN_ID; 1732 } 1733 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 1734 return; 1735 } 1736 1737 static void 1738 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1739 struct lpfc_iocbq *rspiocb) 1740 { 1741 struct lpfc_vport *vport = cmdiocb->vport; 1742 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 1743 1744 if (ulp_status == IOSTAT_SUCCESS) { 1745 struct lpfc_dmabuf *outp; 1746 struct lpfc_sli_ct_request *CTrsp; 1747 1748 outp = cmdiocb->rsp_dmabuf; 1749 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 1750 if (CTrsp->CommandResponse.bits.CmdRsp == 1751 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 1752 vport->ct_flags |= FC_CT_RSNN_NN; 1753 } 1754 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 1755 return; 1756 } 1757 1758 static void 1759 lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1760 struct lpfc_iocbq *rspiocb) 1761 { 1762 struct lpfc_vport *vport = cmdiocb->vport; 1763 1764 /* even if it fails we will act as though it succeeded. */ 1765 vport->ct_flags = 0; 1766 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 1767 return; 1768 } 1769 1770 static void 1771 lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1772 struct lpfc_iocbq *rspiocb) 1773 { 1774 struct lpfc_vport *vport = cmdiocb->vport; 1775 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 1776 1777 if (ulp_status == IOSTAT_SUCCESS) { 1778 struct lpfc_dmabuf *outp; 1779 struct lpfc_sli_ct_request *CTrsp; 1780 1781 outp = cmdiocb->rsp_dmabuf; 1782 CTrsp = (struct lpfc_sli_ct_request *)outp->virt; 1783 if (CTrsp->CommandResponse.bits.CmdRsp == 1784 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 1785 vport->ct_flags |= FC_CT_RFF_ID; 1786 } 1787 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 1788 return; 1789 } 1790 1791 /* 1792 * Although the symbolic port name is thought to be an integer 1793 * as of January 18, 2016, leave it as a string until more of 1794 * the record state becomes defined. 1795 */ 1796 int 1797 lpfc_vport_symbolic_port_name(struct lpfc_vport *vport, char *symbol, 1798 size_t size) 1799 { 1800 int n; 1801 1802 /* 1803 * Use the lpfc board number as the Symbolic Port 1804 * Name object. NPIV is not in play so this integer 1805 * value is sufficient and unique per FC-ID. 1806 */ 1807 n = scnprintf(symbol, size, "%d", vport->phba->brd_no); 1808 return n; 1809 } 1810 1811 1812 int 1813 lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol, 1814 size_t size) 1815 { 1816 char fwrev[FW_REV_STR_SIZE] = {0}; 1817 char tmp[MAXHOSTNAMELEN] = {0}; 1818 1819 memset(symbol, 0, size); 1820 1821 scnprintf(tmp, sizeof(tmp), "Emulex %s", vport->phba->ModelName); 1822 if (strlcat(symbol, tmp, size) >= size) 1823 goto buffer_done; 1824 1825 lpfc_decode_firmware_rev(vport->phba, fwrev, 0); 1826 scnprintf(tmp, sizeof(tmp), " FV%s", fwrev); 1827 if (strlcat(symbol, tmp, size) >= size) 1828 goto buffer_done; 1829 1830 scnprintf(tmp, sizeof(tmp), " DV%s", lpfc_release_version); 1831 if (strlcat(symbol, tmp, size) >= size) 1832 goto buffer_done; 1833 1834 scnprintf(tmp, sizeof(tmp), " HN:%s", vport->phba->os_host_name); 1835 if (strlcat(symbol, tmp, size) >= size) 1836 goto buffer_done; 1837 1838 /* Note :- OS name is "Linux" */ 1839 scnprintf(tmp, sizeof(tmp), " OS:%s", init_utsname()->sysname); 1840 strlcat(symbol, tmp, size); 1841 1842 buffer_done: 1843 return strnlen(symbol, size); 1844 1845 } 1846 1847 static uint32_t 1848 lpfc_find_map_node(struct lpfc_vport *vport) 1849 { 1850 struct lpfc_nodelist *ndlp, *next_ndlp; 1851 struct Scsi_Host *shost; 1852 uint32_t cnt = 0; 1853 1854 shost = lpfc_shost_from_vport(vport); 1855 spin_lock_irq(shost->host_lock); 1856 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 1857 if (ndlp->nlp_type & NLP_FABRIC) 1858 continue; 1859 if ((ndlp->nlp_state == NLP_STE_MAPPED_NODE) || 1860 (ndlp->nlp_state == NLP_STE_UNMAPPED_NODE)) 1861 cnt++; 1862 } 1863 spin_unlock_irq(shost->host_lock); 1864 return cnt; 1865 } 1866 1867 /* 1868 * This routine will return the FC4 Type associated with the CT 1869 * GID_FT command. 1870 */ 1871 int 1872 lpfc_get_gidft_type(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb) 1873 { 1874 struct lpfc_sli_ct_request *CtReq; 1875 struct lpfc_dmabuf *mp; 1876 uint32_t type; 1877 1878 mp = cmdiocb->cmd_dmabuf; 1879 if (mp == NULL) 1880 return 0; 1881 CtReq = (struct lpfc_sli_ct_request *)mp->virt; 1882 type = (uint32_t)CtReq->un.gid.Fc4Type; 1883 if ((type != SLI_CTPT_FCP) && (type != SLI_CTPT_NVME)) 1884 return 0; 1885 return type; 1886 } 1887 1888 /* 1889 * lpfc_ns_cmd 1890 * Description: 1891 * Issue Cmd to NameServer 1892 * SLI_CTNS_GID_FT 1893 * LI_CTNS_RFT_ID 1894 */ 1895 int 1896 lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode, 1897 uint8_t retry, uint32_t context) 1898 { 1899 struct lpfc_nodelist * ndlp; 1900 struct lpfc_hba *phba = vport->phba; 1901 struct lpfc_dmabuf *mp, *bmp; 1902 struct lpfc_sli_ct_request *CtReq; 1903 struct ulp_bde64 *bpl; 1904 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 1905 struct lpfc_iocbq *) = NULL; 1906 uint32_t *ptr; 1907 uint32_t rsp_size = 1024; 1908 size_t size; 1909 int rc = 0; 1910 1911 ndlp = lpfc_findnode_did(vport, NameServer_DID); 1912 if (!ndlp || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) { 1913 rc=1; 1914 goto ns_cmd_exit; 1915 } 1916 1917 /* fill in BDEs for command */ 1918 /* Allocate buffer for command payload */ 1919 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 1920 if (!mp) { 1921 rc=2; 1922 goto ns_cmd_exit; 1923 } 1924 1925 INIT_LIST_HEAD(&mp->list); 1926 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys)); 1927 if (!mp->virt) { 1928 rc=3; 1929 goto ns_cmd_free_mp; 1930 } 1931 1932 /* Allocate buffer for Buffer ptr list */ 1933 bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 1934 if (!bmp) { 1935 rc=4; 1936 goto ns_cmd_free_mpvirt; 1937 } 1938 1939 INIT_LIST_HEAD(&bmp->list); 1940 bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys)); 1941 if (!bmp->virt) { 1942 rc=5; 1943 goto ns_cmd_free_bmp; 1944 } 1945 1946 /* NameServer Req */ 1947 lpfc_printf_vlog(vport, KERN_INFO ,LOG_DISCOVERY, 1948 "0236 NameServer Req Data: x%x x%x x%x x%x\n", 1949 cmdcode, vport->fc_flag, vport->fc_rscn_id_cnt, 1950 context); 1951 1952 bpl = (struct ulp_bde64 *) bmp->virt; 1953 memset(bpl, 0, sizeof(struct ulp_bde64)); 1954 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) ); 1955 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) ); 1956 bpl->tus.f.bdeFlags = 0; 1957 if (cmdcode == SLI_CTNS_GID_FT) 1958 bpl->tus.f.bdeSize = GID_REQUEST_SZ; 1959 else if (cmdcode == SLI_CTNS_GID_PT) 1960 bpl->tus.f.bdeSize = GID_REQUEST_SZ; 1961 else if (cmdcode == SLI_CTNS_GFF_ID) 1962 bpl->tus.f.bdeSize = GFF_REQUEST_SZ; 1963 else if (cmdcode == SLI_CTNS_GFT_ID) 1964 bpl->tus.f.bdeSize = GFT_REQUEST_SZ; 1965 else if (cmdcode == SLI_CTNS_RFT_ID) 1966 bpl->tus.f.bdeSize = RFT_REQUEST_SZ; 1967 else if (cmdcode == SLI_CTNS_RNN_ID) 1968 bpl->tus.f.bdeSize = RNN_REQUEST_SZ; 1969 else if (cmdcode == SLI_CTNS_RSPN_ID) 1970 bpl->tus.f.bdeSize = RSPN_REQUEST_SZ; 1971 else if (cmdcode == SLI_CTNS_RSNN_NN) 1972 bpl->tus.f.bdeSize = RSNN_REQUEST_SZ; 1973 else if (cmdcode == SLI_CTNS_DA_ID) 1974 bpl->tus.f.bdeSize = DA_ID_REQUEST_SZ; 1975 else if (cmdcode == SLI_CTNS_RFF_ID) 1976 bpl->tus.f.bdeSize = RFF_REQUEST_SZ; 1977 else 1978 bpl->tus.f.bdeSize = 0; 1979 bpl->tus.w = le32_to_cpu(bpl->tus.w); 1980 1981 CtReq = (struct lpfc_sli_ct_request *) mp->virt; 1982 memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request)); 1983 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION; 1984 CtReq->RevisionId.bits.InId = 0; 1985 CtReq->FsType = SLI_CT_DIRECTORY_SERVICE; 1986 CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER; 1987 CtReq->CommandResponse.bits.Size = 0; 1988 switch (cmdcode) { 1989 case SLI_CTNS_GID_FT: 1990 CtReq->CommandResponse.bits.CmdRsp = 1991 cpu_to_be16(SLI_CTNS_GID_FT); 1992 CtReq->un.gid.Fc4Type = context; 1993 1994 if (vport->port_state < LPFC_NS_QRY) 1995 vport->port_state = LPFC_NS_QRY; 1996 lpfc_set_disctmo(vport); 1997 cmpl = lpfc_cmpl_ct_cmd_gid_ft; 1998 rsp_size = FC_MAX_NS_RSP; 1999 break; 2000 2001 case SLI_CTNS_GID_PT: 2002 CtReq->CommandResponse.bits.CmdRsp = 2003 cpu_to_be16(SLI_CTNS_GID_PT); 2004 CtReq->un.gid.PortType = context; 2005 2006 if (vport->port_state < LPFC_NS_QRY) 2007 vport->port_state = LPFC_NS_QRY; 2008 lpfc_set_disctmo(vport); 2009 cmpl = lpfc_cmpl_ct_cmd_gid_pt; 2010 rsp_size = FC_MAX_NS_RSP; 2011 break; 2012 2013 case SLI_CTNS_GFF_ID: 2014 CtReq->CommandResponse.bits.CmdRsp = 2015 cpu_to_be16(SLI_CTNS_GFF_ID); 2016 CtReq->un.gff.PortId = cpu_to_be32(context); 2017 cmpl = lpfc_cmpl_ct_cmd_gff_id; 2018 break; 2019 2020 case SLI_CTNS_GFT_ID: 2021 CtReq->CommandResponse.bits.CmdRsp = 2022 cpu_to_be16(SLI_CTNS_GFT_ID); 2023 CtReq->un.gft.PortId = cpu_to_be32(context); 2024 cmpl = lpfc_cmpl_ct_cmd_gft_id; 2025 break; 2026 2027 case SLI_CTNS_RFT_ID: 2028 vport->ct_flags &= ~FC_CT_RFT_ID; 2029 CtReq->CommandResponse.bits.CmdRsp = 2030 cpu_to_be16(SLI_CTNS_RFT_ID); 2031 CtReq->un.rft.port_id = cpu_to_be32(vport->fc_myDID); 2032 2033 /* Register Application Services type if vmid enabled. */ 2034 if (phba->cfg_vmid_app_header) 2035 CtReq->un.rft.app_serv_reg = 2036 cpu_to_be32(RFT_APP_SERV_REG); 2037 2038 /* Register FC4 FCP type if enabled. */ 2039 if (vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH || 2040 vport->cfg_enable_fc4_type == LPFC_ENABLE_FCP) 2041 CtReq->un.rft.fcp_reg = cpu_to_be32(RFT_FCP_REG); 2042 2043 /* Register NVME type if enabled. */ 2044 if (vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH || 2045 vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME) 2046 CtReq->un.rft.nvme_reg = cpu_to_be32(RFT_NVME_REG); 2047 2048 ptr = (uint32_t *)CtReq; 2049 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 2050 "6433 Issue RFT (%s %s %s): %08x %08x %08x " 2051 "%08x %08x %08x %08x %08x\n", 2052 CtReq->un.rft.fcp_reg ? "FCP" : " ", 2053 CtReq->un.rft.nvme_reg ? "NVME" : " ", 2054 CtReq->un.rft.app_serv_reg ? "APPS" : " ", 2055 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3), 2056 *(ptr + 4), *(ptr + 5), 2057 *(ptr + 6), *(ptr + 7)); 2058 cmpl = lpfc_cmpl_ct_cmd_rft_id; 2059 break; 2060 2061 case SLI_CTNS_RNN_ID: 2062 vport->ct_flags &= ~FC_CT_RNN_ID; 2063 CtReq->CommandResponse.bits.CmdRsp = 2064 cpu_to_be16(SLI_CTNS_RNN_ID); 2065 CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID); 2066 memcpy(CtReq->un.rnn.wwnn, &vport->fc_nodename, 2067 sizeof(struct lpfc_name)); 2068 cmpl = lpfc_cmpl_ct_cmd_rnn_id; 2069 break; 2070 2071 case SLI_CTNS_RSPN_ID: 2072 vport->ct_flags &= ~FC_CT_RSPN_ID; 2073 CtReq->CommandResponse.bits.CmdRsp = 2074 cpu_to_be16(SLI_CTNS_RSPN_ID); 2075 CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID); 2076 size = sizeof(CtReq->un.rspn.symbname); 2077 CtReq->un.rspn.len = 2078 lpfc_vport_symbolic_port_name(vport, 2079 CtReq->un.rspn.symbname, size); 2080 cmpl = lpfc_cmpl_ct_cmd_rspn_id; 2081 break; 2082 case SLI_CTNS_RSNN_NN: 2083 vport->ct_flags &= ~FC_CT_RSNN_NN; 2084 CtReq->CommandResponse.bits.CmdRsp = 2085 cpu_to_be16(SLI_CTNS_RSNN_NN); 2086 memcpy(CtReq->un.rsnn.wwnn, &vport->fc_nodename, 2087 sizeof(struct lpfc_name)); 2088 size = sizeof(CtReq->un.rsnn.symbname); 2089 CtReq->un.rsnn.len = 2090 lpfc_vport_symbolic_node_name(vport, 2091 CtReq->un.rsnn.symbname, size); 2092 cmpl = lpfc_cmpl_ct_cmd_rsnn_nn; 2093 break; 2094 case SLI_CTNS_DA_ID: 2095 /* Implement DA_ID Nameserver request */ 2096 CtReq->CommandResponse.bits.CmdRsp = 2097 cpu_to_be16(SLI_CTNS_DA_ID); 2098 CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID); 2099 cmpl = lpfc_cmpl_ct_cmd_da_id; 2100 break; 2101 case SLI_CTNS_RFF_ID: 2102 vport->ct_flags &= ~FC_CT_RFF_ID; 2103 CtReq->CommandResponse.bits.CmdRsp = 2104 cpu_to_be16(SLI_CTNS_RFF_ID); 2105 CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID); 2106 CtReq->un.rff.fbits = FC4_FEATURE_INIT; 2107 2108 /* The driver always supports FC_TYPE_FCP. However, the 2109 * caller can specify NVME (type x28) as well. But only 2110 * these that FC4 type is supported. 2111 */ 2112 if (((vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) || 2113 (vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME)) && 2114 (context == FC_TYPE_NVME)) { 2115 if ((vport == phba->pport) && phba->nvmet_support) { 2116 CtReq->un.rff.fbits = (FC4_FEATURE_TARGET | 2117 FC4_FEATURE_NVME_DISC); 2118 lpfc_nvmet_update_targetport(phba); 2119 } else { 2120 lpfc_nvme_update_localport(vport); 2121 } 2122 CtReq->un.rff.type_code = context; 2123 2124 } else if (((vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) || 2125 (vport->cfg_enable_fc4_type == LPFC_ENABLE_FCP)) && 2126 (context == FC_TYPE_FCP)) 2127 CtReq->un.rff.type_code = context; 2128 2129 else 2130 goto ns_cmd_free_bmpvirt; 2131 2132 ptr = (uint32_t *)CtReq; 2133 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 2134 "6434 Issue RFF (%s): %08x %08x %08x %08x " 2135 "%08x %08x %08x %08x\n", 2136 (context == FC_TYPE_NVME) ? "NVME" : "FCP", 2137 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3), 2138 *(ptr + 4), *(ptr + 5), 2139 *(ptr + 6), *(ptr + 7)); 2140 cmpl = lpfc_cmpl_ct_cmd_rff_id; 2141 break; 2142 } 2143 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count 2144 * to hold ndlp reference for the corresponding callback function. 2145 */ 2146 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) { 2147 /* On success, The cmpl function will free the buffers */ 2148 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 2149 "Issue CT cmd: cmd:x%x did:x%x", 2150 cmdcode, ndlp->nlp_DID, 0); 2151 return 0; 2152 } 2153 rc=6; 2154 2155 ns_cmd_free_bmpvirt: 2156 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 2157 ns_cmd_free_bmp: 2158 kfree(bmp); 2159 ns_cmd_free_mpvirt: 2160 lpfc_mbuf_free(phba, mp->virt, mp->phys); 2161 ns_cmd_free_mp: 2162 kfree(mp); 2163 ns_cmd_exit: 2164 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT, 2165 "0266 Issue NameServer Req x%x err %d Data: x%x x%x\n", 2166 cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt); 2167 return 1; 2168 } 2169 2170 /** 2171 * lpfc_fdmi_rprt_defer - Check for any deferred FDMI RPRT commands 2172 * @phba: Pointer to HBA context object. 2173 * @mask: Initial port attributes mask 2174 * 2175 * This function checks to see if any vports have deferred their FDMI RPRT. 2176 * A vports RPRT may be deferred if it is issued before the primary ports 2177 * RHBA completes. 2178 */ 2179 static void 2180 lpfc_fdmi_rprt_defer(struct lpfc_hba *phba, uint32_t mask) 2181 { 2182 struct lpfc_vport **vports; 2183 struct lpfc_vport *vport; 2184 struct lpfc_nodelist *ndlp; 2185 int i; 2186 2187 phba->hba_flag |= HBA_RHBA_CMPL; 2188 vports = lpfc_create_vport_work_array(phba); 2189 if (vports) { 2190 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 2191 vport = vports[i]; 2192 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID); 2193 if (!ndlp) 2194 continue; 2195 if (vport->ct_flags & FC_CT_RPRT_DEFER) { 2196 vport->ct_flags &= ~FC_CT_RPRT_DEFER; 2197 vport->fdmi_port_mask = mask; 2198 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 0); 2199 } 2200 } 2201 } 2202 lpfc_destroy_vport_work_array(phba, vports); 2203 } 2204 2205 /** 2206 * lpfc_cmpl_ct_disc_fdmi - Handle a discovery FDMI completion 2207 * @phba: Pointer to HBA context object. 2208 * @cmdiocb: Pointer to the command IOCBQ. 2209 * @rspiocb: Pointer to the response IOCBQ. 2210 * 2211 * This function to handle the completion of a driver initiated FDMI 2212 * CT command issued during discovery. 2213 */ 2214 static void 2215 lpfc_cmpl_ct_disc_fdmi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 2216 struct lpfc_iocbq *rspiocb) 2217 { 2218 struct lpfc_vport *vport = cmdiocb->vport; 2219 struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf; 2220 struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf; 2221 struct lpfc_sli_ct_request *CTcmd = inp->virt; 2222 struct lpfc_sli_ct_request *CTrsp = outp->virt; 2223 uint16_t fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp; 2224 uint16_t fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp; 2225 struct lpfc_nodelist *ndlp, *free_ndlp = NULL; 2226 uint32_t latt, cmd, err; 2227 u32 ulp_status = get_job_ulpstatus(phba, rspiocb); 2228 u32 ulp_word4 = get_job_word4(phba, rspiocb); 2229 2230 latt = lpfc_els_chk_latt(vport); 2231 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 2232 "FDMI cmpl: status:x%x/x%x latt:%d", 2233 ulp_status, ulp_word4, latt); 2234 2235 if (latt || ulp_status) { 2236 2237 /* Look for a retryable error */ 2238 if (ulp_status == IOSTAT_LOCAL_REJECT) { 2239 switch ((ulp_word4 & IOERR_PARAM_MASK)) { 2240 case IOERR_SLI_ABORTED: 2241 case IOERR_SLI_DOWN: 2242 /* Driver aborted this IO. No retry as error 2243 * is likely Offline->Online or some adapter 2244 * error. Recovery will try again. 2245 */ 2246 break; 2247 case IOERR_ABORT_IN_PROGRESS: 2248 case IOERR_SEQUENCE_TIMEOUT: 2249 case IOERR_ILLEGAL_FRAME: 2250 case IOERR_NO_RESOURCES: 2251 case IOERR_ILLEGAL_COMMAND: 2252 cmdiocb->retry++; 2253 if (cmdiocb->retry >= LPFC_FDMI_MAX_RETRY) 2254 break; 2255 2256 /* Retry the same FDMI command */ 2257 err = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, 2258 cmdiocb, 0); 2259 if (err == IOCB_ERROR) 2260 break; 2261 return; 2262 default: 2263 break; 2264 } 2265 } 2266 2267 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 2268 "0229 FDMI cmd %04x failed, latt = %d " 2269 "ulp_status: x%x, rid x%x\n", 2270 be16_to_cpu(fdmi_cmd), latt, ulp_status, 2271 ulp_word4); 2272 } 2273 2274 free_ndlp = cmdiocb->ndlp; 2275 lpfc_ct_free_iocb(phba, cmdiocb); 2276 lpfc_nlp_put(free_ndlp); 2277 2278 ndlp = lpfc_findnode_did(vport, FDMI_DID); 2279 if (!ndlp) 2280 return; 2281 2282 /* Check for a CT LS_RJT response */ 2283 cmd = be16_to_cpu(fdmi_cmd); 2284 if (fdmi_rsp == cpu_to_be16(SLI_CT_RESPONSE_FS_RJT)) { 2285 /* FDMI rsp failed */ 2286 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY | LOG_ELS, 2287 "0220 FDMI cmd failed FS_RJT Data: x%x", cmd); 2288 2289 /* Should we fallback to FDMI-2 / FDMI-1 ? */ 2290 switch (cmd) { 2291 case SLI_MGMT_RHBA: 2292 if (vport->fdmi_hba_mask == LPFC_FDMI2_HBA_ATTR) { 2293 /* Fallback to FDMI-1 for HBA attributes */ 2294 vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR; 2295 2296 /* If HBA attributes are FDMI1, so should 2297 * port attributes be for consistency. 2298 */ 2299 vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR; 2300 /* Start over */ 2301 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0); 2302 } 2303 return; 2304 2305 case SLI_MGMT_RPRT: 2306 if (vport->port_type != LPFC_PHYSICAL_PORT) { 2307 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID); 2308 if (!ndlp) 2309 return; 2310 } 2311 if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) { 2312 /* Fallback to FDMI-1 */ 2313 vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR; 2314 /* Start over */ 2315 lpfc_fdmi_cmd(vport, ndlp, cmd, 0); 2316 return; 2317 } 2318 if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) { 2319 vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR; 2320 /* Retry the same command */ 2321 lpfc_fdmi_cmd(vport, ndlp, cmd, 0); 2322 } 2323 return; 2324 2325 case SLI_MGMT_RPA: 2326 /* No retry on Vendor, RPA only done on physical port */ 2327 if (phba->link_flag & LS_CT_VEN_RPA) { 2328 phba->link_flag &= ~LS_CT_VEN_RPA; 2329 if (phba->cmf_active_mode == LPFC_CFG_OFF) 2330 return; 2331 lpfc_printf_log(phba, KERN_WARNING, 2332 LOG_DISCOVERY | LOG_ELS, 2333 "6460 VEN FDMI RPA RJT\n"); 2334 return; 2335 } 2336 if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) { 2337 /* Fallback to FDMI-1 */ 2338 vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR; 2339 vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR; 2340 /* Start over */ 2341 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0); 2342 return; 2343 } 2344 if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) { 2345 vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR; 2346 /* Retry the same command */ 2347 lpfc_fdmi_cmd(vport, ndlp, cmd, 0); 2348 } 2349 return; 2350 } 2351 } 2352 2353 /* 2354 * On success, need to cycle thru FDMI registration for discovery 2355 * DHBA -> DPRT -> RHBA -> RPA (physical port) 2356 * DPRT -> RPRT (vports) 2357 */ 2358 switch (cmd) { 2359 case SLI_MGMT_RHBA: 2360 /* Check for any RPRTs deferred till after RHBA completes */ 2361 lpfc_fdmi_rprt_defer(phba, vport->fdmi_port_mask); 2362 2363 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA, 0); 2364 break; 2365 2366 case SLI_MGMT_DHBA: 2367 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT, 0); 2368 break; 2369 2370 case SLI_MGMT_DPRT: 2371 if (vport->port_type == LPFC_PHYSICAL_PORT) { 2372 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RHBA, 0); 2373 } else { 2374 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID); 2375 if (!ndlp) 2376 return; 2377 2378 /* Only issue a RPRT for the vport if the RHBA 2379 * for the physical port completes successfully. 2380 * We may have to defer the RPRT accordingly. 2381 */ 2382 if (phba->hba_flag & HBA_RHBA_CMPL) { 2383 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 0); 2384 } else { 2385 lpfc_printf_vlog(vport, KERN_INFO, 2386 LOG_DISCOVERY, 2387 "6078 RPRT deferred\n"); 2388 vport->ct_flags |= FC_CT_RPRT_DEFER; 2389 } 2390 } 2391 break; 2392 case SLI_MGMT_RPA: 2393 if (vport->port_type == LPFC_PHYSICAL_PORT && 2394 phba->sli4_hba.pc_sli4_params.mi_ver) { 2395 /* mi is only for the phyical port, no vports */ 2396 if (phba->link_flag & LS_CT_VEN_RPA) { 2397 lpfc_printf_vlog(vport, KERN_INFO, 2398 LOG_DISCOVERY | LOG_ELS | 2399 LOG_CGN_MGMT, 2400 "6449 VEN RPA FDMI Success\n"); 2401 phba->link_flag &= ~LS_CT_VEN_RPA; 2402 break; 2403 } 2404 2405 lpfc_printf_log(phba, KERN_INFO, 2406 LOG_DISCOVERY | LOG_CGN_MGMT, 2407 "6210 Issue Vendor MI FDMI %x\n", 2408 phba->sli4_hba.pc_sli4_params.mi_ver); 2409 2410 /* CGN is only for the physical port, no vports */ 2411 if (lpfc_fdmi_cmd(vport, ndlp, cmd, 2412 LPFC_FDMI_VENDOR_ATTR_mi) == 0) 2413 phba->link_flag |= LS_CT_VEN_RPA; 2414 lpfc_printf_log(phba, KERN_INFO, 2415 LOG_DISCOVERY | LOG_ELS, 2416 "6458 Send MI FDMI:%x Flag x%x\n", 2417 phba->sli4_hba.pc_sli4_params.mi_ver, 2418 phba->link_flag); 2419 } else { 2420 lpfc_printf_log(phba, KERN_INFO, 2421 LOG_DISCOVERY | LOG_ELS, 2422 "6459 No FDMI VEN MI support - " 2423 "RPA Success\n"); 2424 } 2425 break; 2426 } 2427 return; 2428 } 2429 2430 2431 /** 2432 * lpfc_fdmi_change_check - Check for changed FDMI parameters 2433 * @vport: pointer to a host virtual N_Port data structure. 2434 * 2435 * Check how many mapped NPorts we are connected to 2436 * Check if our hostname changed 2437 * Called from hbeat timeout routine to check if any FDMI parameters 2438 * changed. If so, re-register those Attributes. 2439 */ 2440 void 2441 lpfc_fdmi_change_check(struct lpfc_vport *vport) 2442 { 2443 struct lpfc_hba *phba = vport->phba; 2444 struct lpfc_nodelist *ndlp; 2445 uint16_t cnt; 2446 2447 if (!lpfc_is_link_up(phba)) 2448 return; 2449 2450 /* Must be connected to a Fabric */ 2451 if (!(vport->fc_flag & FC_FABRIC)) 2452 return; 2453 2454 ndlp = lpfc_findnode_did(vport, FDMI_DID); 2455 if (!ndlp) 2456 return; 2457 2458 /* Check if system hostname changed */ 2459 if (strcmp(phba->os_host_name, init_utsname()->nodename)) { 2460 memset(phba->os_host_name, 0, sizeof(phba->os_host_name)); 2461 scnprintf(phba->os_host_name, sizeof(phba->os_host_name), "%s", 2462 init_utsname()->nodename); 2463 lpfc_ns_cmd(vport, SLI_CTNS_RSNN_NN, 0, 0); 2464 2465 /* Since this effects multiple HBA and PORT attributes, we need 2466 * de-register and go thru the whole FDMI registration cycle. 2467 * DHBA -> DPRT -> RHBA -> RPA (physical port) 2468 * DPRT -> RPRT (vports) 2469 */ 2470 if (vport->port_type == LPFC_PHYSICAL_PORT) { 2471 /* For extra Vendor RPA */ 2472 phba->link_flag &= ~LS_CT_VEN_RPA; 2473 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0); 2474 } else { 2475 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID); 2476 if (!ndlp) 2477 return; 2478 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT, 0); 2479 } 2480 2481 /* Since this code path registers all the port attributes 2482 * we can just return without further checking. 2483 */ 2484 return; 2485 } 2486 2487 if (!(vport->fdmi_port_mask & LPFC_FDMI_PORT_ATTR_num_disc)) 2488 return; 2489 2490 /* Check if the number of mapped NPorts changed */ 2491 cnt = lpfc_find_map_node(vport); 2492 if (cnt == vport->fdmi_num_disc) 2493 return; 2494 2495 if (vport->port_type == LPFC_PHYSICAL_PORT) { 2496 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA, 2497 LPFC_FDMI_PORT_ATTR_num_disc); 2498 } else { 2499 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID); 2500 if (!ndlp) 2501 return; 2502 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 2503 LPFC_FDMI_PORT_ATTR_num_disc); 2504 } 2505 } 2506 2507 /* Routines for all individual HBA attributes */ 2508 static int 2509 lpfc_fdmi_hba_attr_wwnn(struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad) 2510 { 2511 struct lpfc_fdmi_attr_entry *ae; 2512 uint32_t size; 2513 2514 ae = &ad->AttrValue; 2515 memset(ae, 0, sizeof(*ae)); 2516 2517 memcpy(&ae->un.AttrWWN, &vport->fc_sparam.nodeName, 2518 sizeof(struct lpfc_name)); 2519 size = FOURBYTES + sizeof(struct lpfc_name); 2520 ad->AttrLen = cpu_to_be16(size); 2521 ad->AttrType = cpu_to_be16(RHBA_NODENAME); 2522 return size; 2523 } 2524 static int 2525 lpfc_fdmi_hba_attr_manufacturer(struct lpfc_vport *vport, 2526 struct lpfc_fdmi_attr_def *ad) 2527 { 2528 struct lpfc_fdmi_attr_entry *ae; 2529 uint32_t len, size; 2530 2531 ae = &ad->AttrValue; 2532 memset(ae, 0, sizeof(*ae)); 2533 2534 /* This string MUST be consistent with other FC platforms 2535 * supported by Broadcom. 2536 */ 2537 strncpy(ae->un.AttrString, 2538 "Emulex Corporation", 2539 sizeof(ae->un.AttrString)); 2540 len = strnlen(ae->un.AttrString, 2541 sizeof(ae->un.AttrString)); 2542 len += (len & 3) ? (4 - (len & 3)) : 4; 2543 size = FOURBYTES + len; 2544 ad->AttrLen = cpu_to_be16(size); 2545 ad->AttrType = cpu_to_be16(RHBA_MANUFACTURER); 2546 return size; 2547 } 2548 2549 static int 2550 lpfc_fdmi_hba_attr_sn(struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad) 2551 { 2552 struct lpfc_hba *phba = vport->phba; 2553 struct lpfc_fdmi_attr_entry *ae; 2554 uint32_t len, size; 2555 2556 ae = &ad->AttrValue; 2557 memset(ae, 0, sizeof(*ae)); 2558 2559 strncpy(ae->un.AttrString, phba->SerialNumber, 2560 sizeof(ae->un.AttrString)); 2561 len = strnlen(ae->un.AttrString, 2562 sizeof(ae->un.AttrString)); 2563 len += (len & 3) ? (4 - (len & 3)) : 4; 2564 size = FOURBYTES + len; 2565 ad->AttrLen = cpu_to_be16(size); 2566 ad->AttrType = cpu_to_be16(RHBA_SERIAL_NUMBER); 2567 return size; 2568 } 2569 2570 static int 2571 lpfc_fdmi_hba_attr_model(struct lpfc_vport *vport, 2572 struct lpfc_fdmi_attr_def *ad) 2573 { 2574 struct lpfc_hba *phba = vport->phba; 2575 struct lpfc_fdmi_attr_entry *ae; 2576 uint32_t len, size; 2577 2578 ae = &ad->AttrValue; 2579 memset(ae, 0, sizeof(*ae)); 2580 2581 strncpy(ae->un.AttrString, phba->ModelName, 2582 sizeof(ae->un.AttrString)); 2583 len = strnlen(ae->un.AttrString, sizeof(ae->un.AttrString)); 2584 len += (len & 3) ? (4 - (len & 3)) : 4; 2585 size = FOURBYTES + len; 2586 ad->AttrLen = cpu_to_be16(size); 2587 ad->AttrType = cpu_to_be16(RHBA_MODEL); 2588 return size; 2589 } 2590 2591 static int 2592 lpfc_fdmi_hba_attr_description(struct lpfc_vport *vport, 2593 struct lpfc_fdmi_attr_def *ad) 2594 { 2595 struct lpfc_hba *phba = vport->phba; 2596 struct lpfc_fdmi_attr_entry *ae; 2597 uint32_t len, size; 2598 2599 ae = &ad->AttrValue; 2600 memset(ae, 0, sizeof(*ae)); 2601 2602 strncpy(ae->un.AttrString, phba->ModelDesc, 2603 sizeof(ae->un.AttrString)); 2604 len = strnlen(ae->un.AttrString, 2605 sizeof(ae->un.AttrString)); 2606 len += (len & 3) ? (4 - (len & 3)) : 4; 2607 size = FOURBYTES + len; 2608 ad->AttrLen = cpu_to_be16(size); 2609 ad->AttrType = cpu_to_be16(RHBA_MODEL_DESCRIPTION); 2610 return size; 2611 } 2612 2613 static int 2614 lpfc_fdmi_hba_attr_hdw_ver(struct lpfc_vport *vport, 2615 struct lpfc_fdmi_attr_def *ad) 2616 { 2617 struct lpfc_hba *phba = vport->phba; 2618 lpfc_vpd_t *vp = &phba->vpd; 2619 struct lpfc_fdmi_attr_entry *ae; 2620 uint32_t i, j, incr, size; 2621 2622 ae = &ad->AttrValue; 2623 memset(ae, 0, sizeof(*ae)); 2624 2625 /* Convert JEDEC ID to ascii for hardware version */ 2626 incr = vp->rev.biuRev; 2627 for (i = 0; i < 8; i++) { 2628 j = (incr & 0xf); 2629 if (j <= 9) 2630 ae->un.AttrString[7 - i] = 2631 (char)((uint8_t) 0x30 + 2632 (uint8_t) j); 2633 else 2634 ae->un.AttrString[7 - i] = 2635 (char)((uint8_t) 0x61 + 2636 (uint8_t) (j - 10)); 2637 incr = (incr >> 4); 2638 } 2639 size = FOURBYTES + 8; 2640 ad->AttrLen = cpu_to_be16(size); 2641 ad->AttrType = cpu_to_be16(RHBA_HARDWARE_VERSION); 2642 return size; 2643 } 2644 2645 static int 2646 lpfc_fdmi_hba_attr_drvr_ver(struct lpfc_vport *vport, 2647 struct lpfc_fdmi_attr_def *ad) 2648 { 2649 struct lpfc_fdmi_attr_entry *ae; 2650 uint32_t len, size; 2651 2652 ae = &ad->AttrValue; 2653 memset(ae, 0, sizeof(*ae)); 2654 2655 strncpy(ae->un.AttrString, lpfc_release_version, 2656 sizeof(ae->un.AttrString)); 2657 len = strnlen(ae->un.AttrString, 2658 sizeof(ae->un.AttrString)); 2659 len += (len & 3) ? (4 - (len & 3)) : 4; 2660 size = FOURBYTES + len; 2661 ad->AttrLen = cpu_to_be16(size); 2662 ad->AttrType = cpu_to_be16(RHBA_DRIVER_VERSION); 2663 return size; 2664 } 2665 2666 static int 2667 lpfc_fdmi_hba_attr_rom_ver(struct lpfc_vport *vport, 2668 struct lpfc_fdmi_attr_def *ad) 2669 { 2670 struct lpfc_hba *phba = vport->phba; 2671 struct lpfc_fdmi_attr_entry *ae; 2672 uint32_t len, size; 2673 2674 ae = &ad->AttrValue; 2675 memset(ae, 0, sizeof(*ae)); 2676 2677 if (phba->sli_rev == LPFC_SLI_REV4) 2678 lpfc_decode_firmware_rev(phba, ae->un.AttrString, 1); 2679 else 2680 strncpy(ae->un.AttrString, phba->OptionROMVersion, 2681 sizeof(ae->un.AttrString)); 2682 len = strnlen(ae->un.AttrString, 2683 sizeof(ae->un.AttrString)); 2684 len += (len & 3) ? (4 - (len & 3)) : 4; 2685 size = FOURBYTES + len; 2686 ad->AttrLen = cpu_to_be16(size); 2687 ad->AttrType = cpu_to_be16(RHBA_OPTION_ROM_VERSION); 2688 return size; 2689 } 2690 2691 static int 2692 lpfc_fdmi_hba_attr_fmw_ver(struct lpfc_vport *vport, 2693 struct lpfc_fdmi_attr_def *ad) 2694 { 2695 struct lpfc_hba *phba = vport->phba; 2696 struct lpfc_fdmi_attr_entry *ae; 2697 uint32_t len, size; 2698 2699 ae = &ad->AttrValue; 2700 memset(ae, 0, sizeof(*ae)); 2701 2702 lpfc_decode_firmware_rev(phba, ae->un.AttrString, 1); 2703 len = strnlen(ae->un.AttrString, 2704 sizeof(ae->un.AttrString)); 2705 len += (len & 3) ? (4 - (len & 3)) : 4; 2706 size = FOURBYTES + len; 2707 ad->AttrLen = cpu_to_be16(size); 2708 ad->AttrType = cpu_to_be16(RHBA_FIRMWARE_VERSION); 2709 return size; 2710 } 2711 2712 static int 2713 lpfc_fdmi_hba_attr_os_ver(struct lpfc_vport *vport, 2714 struct lpfc_fdmi_attr_def *ad) 2715 { 2716 struct lpfc_fdmi_attr_entry *ae; 2717 uint32_t len, size; 2718 2719 ae = &ad->AttrValue; 2720 memset(ae, 0, sizeof(*ae)); 2721 2722 snprintf(ae->un.AttrString, sizeof(ae->un.AttrString), "%s %s %s", 2723 init_utsname()->sysname, 2724 init_utsname()->release, 2725 init_utsname()->version); 2726 2727 len = strnlen(ae->un.AttrString, sizeof(ae->un.AttrString)); 2728 len += (len & 3) ? (4 - (len & 3)) : 4; 2729 size = FOURBYTES + len; 2730 ad->AttrLen = cpu_to_be16(size); 2731 ad->AttrType = cpu_to_be16(RHBA_OS_NAME_VERSION); 2732 return size; 2733 } 2734 2735 static int 2736 lpfc_fdmi_hba_attr_ct_len(struct lpfc_vport *vport, 2737 struct lpfc_fdmi_attr_def *ad) 2738 { 2739 struct lpfc_fdmi_attr_entry *ae; 2740 uint32_t size; 2741 2742 ae = &ad->AttrValue; 2743 2744 ae->un.AttrInt = cpu_to_be32(LPFC_MAX_CT_SIZE); 2745 size = FOURBYTES + sizeof(uint32_t); 2746 ad->AttrLen = cpu_to_be16(size); 2747 ad->AttrType = cpu_to_be16(RHBA_MAX_CT_PAYLOAD_LEN); 2748 return size; 2749 } 2750 2751 static int 2752 lpfc_fdmi_hba_attr_symbolic_name(struct lpfc_vport *vport, 2753 struct lpfc_fdmi_attr_def *ad) 2754 { 2755 struct lpfc_fdmi_attr_entry *ae; 2756 uint32_t len, size; 2757 2758 ae = &ad->AttrValue; 2759 memset(ae, 0, sizeof(*ae)); 2760 2761 len = lpfc_vport_symbolic_node_name(vport, 2762 ae->un.AttrString, 256); 2763 len += (len & 3) ? (4 - (len & 3)) : 4; 2764 size = FOURBYTES + len; 2765 ad->AttrLen = cpu_to_be16(size); 2766 ad->AttrType = cpu_to_be16(RHBA_SYM_NODENAME); 2767 return size; 2768 } 2769 2770 static int 2771 lpfc_fdmi_hba_attr_vendor_info(struct lpfc_vport *vport, 2772 struct lpfc_fdmi_attr_def *ad) 2773 { 2774 struct lpfc_fdmi_attr_entry *ae; 2775 uint32_t size; 2776 2777 ae = &ad->AttrValue; 2778 2779 /* Nothing is defined for this currently */ 2780 ae->un.AttrInt = cpu_to_be32(0); 2781 size = FOURBYTES + sizeof(uint32_t); 2782 ad->AttrLen = cpu_to_be16(size); 2783 ad->AttrType = cpu_to_be16(RHBA_VENDOR_INFO); 2784 return size; 2785 } 2786 2787 static int 2788 lpfc_fdmi_hba_attr_num_ports(struct lpfc_vport *vport, 2789 struct lpfc_fdmi_attr_def *ad) 2790 { 2791 struct lpfc_fdmi_attr_entry *ae; 2792 uint32_t size; 2793 2794 ae = &ad->AttrValue; 2795 2796 /* Each driver instance corresponds to a single port */ 2797 ae->un.AttrInt = cpu_to_be32(1); 2798 size = FOURBYTES + sizeof(uint32_t); 2799 ad->AttrLen = cpu_to_be16(size); 2800 ad->AttrType = cpu_to_be16(RHBA_NUM_PORTS); 2801 return size; 2802 } 2803 2804 static int 2805 lpfc_fdmi_hba_attr_fabric_wwnn(struct lpfc_vport *vport, 2806 struct lpfc_fdmi_attr_def *ad) 2807 { 2808 struct lpfc_fdmi_attr_entry *ae; 2809 uint32_t size; 2810 2811 ae = &ad->AttrValue; 2812 memset(ae, 0, sizeof(*ae)); 2813 2814 memcpy(&ae->un.AttrWWN, &vport->fabric_nodename, 2815 sizeof(struct lpfc_name)); 2816 size = FOURBYTES + sizeof(struct lpfc_name); 2817 ad->AttrLen = cpu_to_be16(size); 2818 ad->AttrType = cpu_to_be16(RHBA_FABRIC_WWNN); 2819 return size; 2820 } 2821 2822 static int 2823 lpfc_fdmi_hba_attr_bios_ver(struct lpfc_vport *vport, 2824 struct lpfc_fdmi_attr_def *ad) 2825 { 2826 struct lpfc_hba *phba = vport->phba; 2827 struct lpfc_fdmi_attr_entry *ae; 2828 uint32_t len, size; 2829 2830 ae = &ad->AttrValue; 2831 memset(ae, 0, sizeof(*ae)); 2832 2833 strlcat(ae->un.AttrString, phba->BIOSVersion, 2834 sizeof(ae->un.AttrString)); 2835 len = strnlen(ae->un.AttrString, 2836 sizeof(ae->un.AttrString)); 2837 len += (len & 3) ? (4 - (len & 3)) : 4; 2838 size = FOURBYTES + len; 2839 ad->AttrLen = cpu_to_be16(size); 2840 ad->AttrType = cpu_to_be16(RHBA_BIOS_VERSION); 2841 return size; 2842 } 2843 2844 static int 2845 lpfc_fdmi_hba_attr_bios_state(struct lpfc_vport *vport, 2846 struct lpfc_fdmi_attr_def *ad) 2847 { 2848 struct lpfc_fdmi_attr_entry *ae; 2849 uint32_t size; 2850 2851 ae = &ad->AttrValue; 2852 2853 /* Driver doesn't have access to this information */ 2854 ae->un.AttrInt = cpu_to_be32(0); 2855 size = FOURBYTES + sizeof(uint32_t); 2856 ad->AttrLen = cpu_to_be16(size); 2857 ad->AttrType = cpu_to_be16(RHBA_BIOS_STATE); 2858 return size; 2859 } 2860 2861 static int 2862 lpfc_fdmi_hba_attr_vendor_id(struct lpfc_vport *vport, 2863 struct lpfc_fdmi_attr_def *ad) 2864 { 2865 struct lpfc_fdmi_attr_entry *ae; 2866 uint32_t len, size; 2867 2868 ae = &ad->AttrValue; 2869 memset(ae, 0, sizeof(*ae)); 2870 2871 strncpy(ae->un.AttrString, "EMULEX", 2872 sizeof(ae->un.AttrString)); 2873 len = strnlen(ae->un.AttrString, 2874 sizeof(ae->un.AttrString)); 2875 len += (len & 3) ? (4 - (len & 3)) : 4; 2876 size = FOURBYTES + len; 2877 ad->AttrLen = cpu_to_be16(size); 2878 ad->AttrType = cpu_to_be16(RHBA_VENDOR_ID); 2879 return size; 2880 } 2881 2882 /* Routines for all individual PORT attributes */ 2883 static int 2884 lpfc_fdmi_port_attr_fc4type(struct lpfc_vport *vport, 2885 struct lpfc_fdmi_attr_def *ad) 2886 { 2887 struct lpfc_hba *phba = vport->phba; 2888 struct lpfc_fdmi_attr_entry *ae; 2889 uint32_t size; 2890 2891 ae = &ad->AttrValue; 2892 memset(ae, 0, sizeof(*ae)); 2893 2894 ae->un.AttrTypes[2] = 0x01; /* Type 0x8 - FCP */ 2895 ae->un.AttrTypes[7] = 0x01; /* Type 0x20 - CT */ 2896 2897 /* Check to see if Firmware supports NVME and on physical port */ 2898 if ((phba->sli_rev == LPFC_SLI_REV4) && (vport == phba->pport) && 2899 phba->sli4_hba.pc_sli4_params.nvme) 2900 ae->un.AttrTypes[6] = 0x01; /* Type 0x28 - NVME */ 2901 2902 size = FOURBYTES + 32; 2903 ad->AttrLen = cpu_to_be16(size); 2904 ad->AttrType = cpu_to_be16(RPRT_SUPPORTED_FC4_TYPES); 2905 return size; 2906 } 2907 2908 static int 2909 lpfc_fdmi_port_attr_support_speed(struct lpfc_vport *vport, 2910 struct lpfc_fdmi_attr_def *ad) 2911 { 2912 struct lpfc_hba *phba = vport->phba; 2913 struct lpfc_fdmi_attr_entry *ae; 2914 uint32_t size; 2915 u32 tcfg; 2916 u8 i, cnt; 2917 2918 ae = &ad->AttrValue; 2919 2920 ae->un.AttrInt = 0; 2921 if (!(phba->hba_flag & HBA_FCOE_MODE)) { 2922 cnt = 0; 2923 if (phba->sli_rev == LPFC_SLI_REV4) { 2924 tcfg = phba->sli4_hba.conf_trunk; 2925 for (i = 0; i < 4; i++, tcfg >>= 1) 2926 if (tcfg & 1) 2927 cnt++; 2928 } 2929 2930 if (cnt > 2) { /* 4 lane trunk group */ 2931 if (phba->lmt & LMT_64Gb) 2932 ae->un.AttrInt |= HBA_PORTSPEED_256GFC; 2933 if (phba->lmt & LMT_32Gb) 2934 ae->un.AttrInt |= HBA_PORTSPEED_128GFC; 2935 if (phba->lmt & LMT_16Gb) 2936 ae->un.AttrInt |= HBA_PORTSPEED_64GFC; 2937 } else if (cnt) { /* 2 lane trunk group */ 2938 if (phba->lmt & LMT_128Gb) 2939 ae->un.AttrInt |= HBA_PORTSPEED_256GFC; 2940 if (phba->lmt & LMT_64Gb) 2941 ae->un.AttrInt |= HBA_PORTSPEED_128GFC; 2942 if (phba->lmt & LMT_32Gb) 2943 ae->un.AttrInt |= HBA_PORTSPEED_64GFC; 2944 if (phba->lmt & LMT_16Gb) 2945 ae->un.AttrInt |= HBA_PORTSPEED_32GFC; 2946 } else { 2947 if (phba->lmt & LMT_256Gb) 2948 ae->un.AttrInt |= HBA_PORTSPEED_256GFC; 2949 if (phba->lmt & LMT_128Gb) 2950 ae->un.AttrInt |= HBA_PORTSPEED_128GFC; 2951 if (phba->lmt & LMT_64Gb) 2952 ae->un.AttrInt |= HBA_PORTSPEED_64GFC; 2953 if (phba->lmt & LMT_32Gb) 2954 ae->un.AttrInt |= HBA_PORTSPEED_32GFC; 2955 if (phba->lmt & LMT_16Gb) 2956 ae->un.AttrInt |= HBA_PORTSPEED_16GFC; 2957 if (phba->lmt & LMT_10Gb) 2958 ae->un.AttrInt |= HBA_PORTSPEED_10GFC; 2959 if (phba->lmt & LMT_8Gb) 2960 ae->un.AttrInt |= HBA_PORTSPEED_8GFC; 2961 if (phba->lmt & LMT_4Gb) 2962 ae->un.AttrInt |= HBA_PORTSPEED_4GFC; 2963 if (phba->lmt & LMT_2Gb) 2964 ae->un.AttrInt |= HBA_PORTSPEED_2GFC; 2965 if (phba->lmt & LMT_1Gb) 2966 ae->un.AttrInt |= HBA_PORTSPEED_1GFC; 2967 } 2968 } else { 2969 /* FCoE links support only one speed */ 2970 switch (phba->fc_linkspeed) { 2971 case LPFC_ASYNC_LINK_SPEED_10GBPS: 2972 ae->un.AttrInt = HBA_PORTSPEED_10GE; 2973 break; 2974 case LPFC_ASYNC_LINK_SPEED_25GBPS: 2975 ae->un.AttrInt = HBA_PORTSPEED_25GE; 2976 break; 2977 case LPFC_ASYNC_LINK_SPEED_40GBPS: 2978 ae->un.AttrInt = HBA_PORTSPEED_40GE; 2979 break; 2980 case LPFC_ASYNC_LINK_SPEED_100GBPS: 2981 ae->un.AttrInt = HBA_PORTSPEED_100GE; 2982 break; 2983 } 2984 } 2985 ae->un.AttrInt = cpu_to_be32(ae->un.AttrInt); 2986 size = FOURBYTES + sizeof(uint32_t); 2987 ad->AttrLen = cpu_to_be16(size); 2988 ad->AttrType = cpu_to_be16(RPRT_SUPPORTED_SPEED); 2989 return size; 2990 } 2991 2992 static int 2993 lpfc_fdmi_port_attr_speed(struct lpfc_vport *vport, 2994 struct lpfc_fdmi_attr_def *ad) 2995 { 2996 struct lpfc_hba *phba = vport->phba; 2997 struct lpfc_fdmi_attr_entry *ae; 2998 uint32_t size; 2999 3000 ae = &ad->AttrValue; 3001 3002 if (!(phba->hba_flag & HBA_FCOE_MODE)) { 3003 switch (phba->fc_linkspeed) { 3004 case LPFC_LINK_SPEED_1GHZ: 3005 ae->un.AttrInt = HBA_PORTSPEED_1GFC; 3006 break; 3007 case LPFC_LINK_SPEED_2GHZ: 3008 ae->un.AttrInt = HBA_PORTSPEED_2GFC; 3009 break; 3010 case LPFC_LINK_SPEED_4GHZ: 3011 ae->un.AttrInt = HBA_PORTSPEED_4GFC; 3012 break; 3013 case LPFC_LINK_SPEED_8GHZ: 3014 ae->un.AttrInt = HBA_PORTSPEED_8GFC; 3015 break; 3016 case LPFC_LINK_SPEED_10GHZ: 3017 ae->un.AttrInt = HBA_PORTSPEED_10GFC; 3018 break; 3019 case LPFC_LINK_SPEED_16GHZ: 3020 ae->un.AttrInt = HBA_PORTSPEED_16GFC; 3021 break; 3022 case LPFC_LINK_SPEED_32GHZ: 3023 ae->un.AttrInt = HBA_PORTSPEED_32GFC; 3024 break; 3025 case LPFC_LINK_SPEED_64GHZ: 3026 ae->un.AttrInt = HBA_PORTSPEED_64GFC; 3027 break; 3028 case LPFC_LINK_SPEED_128GHZ: 3029 ae->un.AttrInt = HBA_PORTSPEED_128GFC; 3030 break; 3031 case LPFC_LINK_SPEED_256GHZ: 3032 ae->un.AttrInt = HBA_PORTSPEED_256GFC; 3033 break; 3034 default: 3035 ae->un.AttrInt = HBA_PORTSPEED_UNKNOWN; 3036 break; 3037 } 3038 } else { 3039 switch (phba->fc_linkspeed) { 3040 case LPFC_ASYNC_LINK_SPEED_10GBPS: 3041 ae->un.AttrInt = HBA_PORTSPEED_10GE; 3042 break; 3043 case LPFC_ASYNC_LINK_SPEED_25GBPS: 3044 ae->un.AttrInt = HBA_PORTSPEED_25GE; 3045 break; 3046 case LPFC_ASYNC_LINK_SPEED_40GBPS: 3047 ae->un.AttrInt = HBA_PORTSPEED_40GE; 3048 break; 3049 case LPFC_ASYNC_LINK_SPEED_100GBPS: 3050 ae->un.AttrInt = HBA_PORTSPEED_100GE; 3051 break; 3052 default: 3053 ae->un.AttrInt = HBA_PORTSPEED_UNKNOWN; 3054 break; 3055 } 3056 } 3057 3058 ae->un.AttrInt = cpu_to_be32(ae->un.AttrInt); 3059 size = FOURBYTES + sizeof(uint32_t); 3060 ad->AttrLen = cpu_to_be16(size); 3061 ad->AttrType = cpu_to_be16(RPRT_PORT_SPEED); 3062 return size; 3063 } 3064 3065 static int 3066 lpfc_fdmi_port_attr_max_frame(struct lpfc_vport *vport, 3067 struct lpfc_fdmi_attr_def *ad) 3068 { 3069 struct serv_parm *hsp; 3070 struct lpfc_fdmi_attr_entry *ae; 3071 uint32_t size; 3072 3073 ae = &ad->AttrValue; 3074 3075 hsp = (struct serv_parm *)&vport->fc_sparam; 3076 ae->un.AttrInt = (((uint32_t) hsp->cmn.bbRcvSizeMsb & 0x0F) << 8) | 3077 (uint32_t) hsp->cmn.bbRcvSizeLsb; 3078 ae->un.AttrInt = cpu_to_be32(ae->un.AttrInt); 3079 size = FOURBYTES + sizeof(uint32_t); 3080 ad->AttrLen = cpu_to_be16(size); 3081 ad->AttrType = cpu_to_be16(RPRT_MAX_FRAME_SIZE); 3082 return size; 3083 } 3084 3085 static int 3086 lpfc_fdmi_port_attr_os_devname(struct lpfc_vport *vport, 3087 struct lpfc_fdmi_attr_def *ad) 3088 { 3089 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 3090 struct lpfc_fdmi_attr_entry *ae; 3091 uint32_t len, size; 3092 3093 ae = &ad->AttrValue; 3094 memset(ae, 0, sizeof(*ae)); 3095 3096 snprintf(ae->un.AttrString, sizeof(ae->un.AttrString), 3097 "/sys/class/scsi_host/host%d", shost->host_no); 3098 len = strnlen((char *)ae->un.AttrString, 3099 sizeof(ae->un.AttrString)); 3100 len += (len & 3) ? (4 - (len & 3)) : 4; 3101 size = FOURBYTES + len; 3102 ad->AttrLen = cpu_to_be16(size); 3103 ad->AttrType = cpu_to_be16(RPRT_OS_DEVICE_NAME); 3104 return size; 3105 } 3106 3107 static int 3108 lpfc_fdmi_port_attr_host_name(struct lpfc_vport *vport, 3109 struct lpfc_fdmi_attr_def *ad) 3110 { 3111 struct lpfc_fdmi_attr_entry *ae; 3112 uint32_t len, size; 3113 3114 ae = &ad->AttrValue; 3115 memset(ae, 0, sizeof(*ae)); 3116 3117 scnprintf(ae->un.AttrString, sizeof(ae->un.AttrString), "%s", 3118 vport->phba->os_host_name); 3119 3120 len = strnlen(ae->un.AttrString, sizeof(ae->un.AttrString)); 3121 len += (len & 3) ? (4 - (len & 3)) : 4; 3122 size = FOURBYTES + len; 3123 ad->AttrLen = cpu_to_be16(size); 3124 ad->AttrType = cpu_to_be16(RPRT_HOST_NAME); 3125 return size; 3126 } 3127 3128 static int 3129 lpfc_fdmi_port_attr_wwnn(struct lpfc_vport *vport, 3130 struct lpfc_fdmi_attr_def *ad) 3131 { 3132 struct lpfc_fdmi_attr_entry *ae; 3133 uint32_t size; 3134 3135 ae = &ad->AttrValue; 3136 memset(ae, 0, sizeof(*ae)); 3137 3138 memcpy(&ae->un.AttrWWN, &vport->fc_sparam.nodeName, 3139 sizeof(struct lpfc_name)); 3140 size = FOURBYTES + sizeof(struct lpfc_name); 3141 ad->AttrLen = cpu_to_be16(size); 3142 ad->AttrType = cpu_to_be16(RPRT_NODENAME); 3143 return size; 3144 } 3145 3146 static int 3147 lpfc_fdmi_port_attr_wwpn(struct lpfc_vport *vport, 3148 struct lpfc_fdmi_attr_def *ad) 3149 { 3150 struct lpfc_fdmi_attr_entry *ae; 3151 uint32_t size; 3152 3153 ae = &ad->AttrValue; 3154 memset(ae, 0, sizeof(*ae)); 3155 3156 memcpy(&ae->un.AttrWWN, &vport->fc_sparam.portName, 3157 sizeof(struct lpfc_name)); 3158 size = FOURBYTES + sizeof(struct lpfc_name); 3159 ad->AttrLen = cpu_to_be16(size); 3160 ad->AttrType = cpu_to_be16(RPRT_PORTNAME); 3161 return size; 3162 } 3163 3164 static int 3165 lpfc_fdmi_port_attr_symbolic_name(struct lpfc_vport *vport, 3166 struct lpfc_fdmi_attr_def *ad) 3167 { 3168 struct lpfc_fdmi_attr_entry *ae; 3169 uint32_t len, size; 3170 3171 ae = &ad->AttrValue; 3172 memset(ae, 0, sizeof(*ae)); 3173 3174 len = lpfc_vport_symbolic_port_name(vport, ae->un.AttrString, 256); 3175 len += (len & 3) ? (4 - (len & 3)) : 4; 3176 size = FOURBYTES + len; 3177 ad->AttrLen = cpu_to_be16(size); 3178 ad->AttrType = cpu_to_be16(RPRT_SYM_PORTNAME); 3179 return size; 3180 } 3181 3182 static int 3183 lpfc_fdmi_port_attr_port_type(struct lpfc_vport *vport, 3184 struct lpfc_fdmi_attr_def *ad) 3185 { 3186 struct lpfc_hba *phba = vport->phba; 3187 struct lpfc_fdmi_attr_entry *ae; 3188 uint32_t size; 3189 3190 ae = &ad->AttrValue; 3191 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) 3192 ae->un.AttrInt = cpu_to_be32(LPFC_FDMI_PORTTYPE_NLPORT); 3193 else 3194 ae->un.AttrInt = cpu_to_be32(LPFC_FDMI_PORTTYPE_NPORT); 3195 size = FOURBYTES + sizeof(uint32_t); 3196 ad->AttrLen = cpu_to_be16(size); 3197 ad->AttrType = cpu_to_be16(RPRT_PORT_TYPE); 3198 return size; 3199 } 3200 3201 static int 3202 lpfc_fdmi_port_attr_class(struct lpfc_vport *vport, 3203 struct lpfc_fdmi_attr_def *ad) 3204 { 3205 struct lpfc_fdmi_attr_entry *ae; 3206 uint32_t size; 3207 3208 ae = &ad->AttrValue; 3209 ae->un.AttrInt = cpu_to_be32(FC_COS_CLASS2 | FC_COS_CLASS3); 3210 size = FOURBYTES + sizeof(uint32_t); 3211 ad->AttrLen = cpu_to_be16(size); 3212 ad->AttrType = cpu_to_be16(RPRT_SUPPORTED_CLASS); 3213 return size; 3214 } 3215 3216 static int 3217 lpfc_fdmi_port_attr_fabric_wwpn(struct lpfc_vport *vport, 3218 struct lpfc_fdmi_attr_def *ad) 3219 { 3220 struct lpfc_fdmi_attr_entry *ae; 3221 uint32_t size; 3222 3223 ae = &ad->AttrValue; 3224 memset(ae, 0, sizeof(*ae)); 3225 3226 memcpy(&ae->un.AttrWWN, &vport->fabric_portname, 3227 sizeof(struct lpfc_name)); 3228 size = FOURBYTES + sizeof(struct lpfc_name); 3229 ad->AttrLen = cpu_to_be16(size); 3230 ad->AttrType = cpu_to_be16(RPRT_FABRICNAME); 3231 return size; 3232 } 3233 3234 static int 3235 lpfc_fdmi_port_attr_active_fc4type(struct lpfc_vport *vport, 3236 struct lpfc_fdmi_attr_def *ad) 3237 { 3238 struct lpfc_hba *phba = vport->phba; 3239 struct lpfc_fdmi_attr_entry *ae; 3240 uint32_t size; 3241 3242 ae = &ad->AttrValue; 3243 memset(ae, 0, sizeof(*ae)); 3244 3245 ae->un.AttrTypes[2] = 0x01; /* Type 0x8 - FCP */ 3246 ae->un.AttrTypes[7] = 0x01; /* Type 0x20 - CT */ 3247 3248 /* Check to see if NVME is configured or not */ 3249 if (vport == phba->pport && 3250 phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) 3251 ae->un.AttrTypes[6] = 0x1; /* Type 0x28 - NVME */ 3252 3253 size = FOURBYTES + 32; 3254 ad->AttrLen = cpu_to_be16(size); 3255 ad->AttrType = cpu_to_be16(RPRT_ACTIVE_FC4_TYPES); 3256 return size; 3257 } 3258 3259 static int 3260 lpfc_fdmi_port_attr_port_state(struct lpfc_vport *vport, 3261 struct lpfc_fdmi_attr_def *ad) 3262 { 3263 struct lpfc_fdmi_attr_entry *ae; 3264 uint32_t size; 3265 3266 ae = &ad->AttrValue; 3267 /* Link Up - operational */ 3268 ae->un.AttrInt = cpu_to_be32(LPFC_FDMI_PORTSTATE_ONLINE); 3269 size = FOURBYTES + sizeof(uint32_t); 3270 ad->AttrLen = cpu_to_be16(size); 3271 ad->AttrType = cpu_to_be16(RPRT_PORT_STATE); 3272 return size; 3273 } 3274 3275 static int 3276 lpfc_fdmi_port_attr_num_disc(struct lpfc_vport *vport, 3277 struct lpfc_fdmi_attr_def *ad) 3278 { 3279 struct lpfc_fdmi_attr_entry *ae; 3280 uint32_t size; 3281 3282 ae = &ad->AttrValue; 3283 vport->fdmi_num_disc = lpfc_find_map_node(vport); 3284 ae->un.AttrInt = cpu_to_be32(vport->fdmi_num_disc); 3285 size = FOURBYTES + sizeof(uint32_t); 3286 ad->AttrLen = cpu_to_be16(size); 3287 ad->AttrType = cpu_to_be16(RPRT_DISC_PORT); 3288 return size; 3289 } 3290 3291 static int 3292 lpfc_fdmi_port_attr_nportid(struct lpfc_vport *vport, 3293 struct lpfc_fdmi_attr_def *ad) 3294 { 3295 struct lpfc_fdmi_attr_entry *ae; 3296 uint32_t size; 3297 3298 ae = &ad->AttrValue; 3299 ae->un.AttrInt = cpu_to_be32(vport->fc_myDID); 3300 size = FOURBYTES + sizeof(uint32_t); 3301 ad->AttrLen = cpu_to_be16(size); 3302 ad->AttrType = cpu_to_be16(RPRT_PORT_ID); 3303 return size; 3304 } 3305 3306 static int 3307 lpfc_fdmi_smart_attr_service(struct lpfc_vport *vport, 3308 struct lpfc_fdmi_attr_def *ad) 3309 { 3310 struct lpfc_fdmi_attr_entry *ae; 3311 uint32_t len, size; 3312 3313 ae = &ad->AttrValue; 3314 memset(ae, 0, sizeof(*ae)); 3315 3316 strncpy(ae->un.AttrString, "Smart SAN Initiator", 3317 sizeof(ae->un.AttrString)); 3318 len = strnlen(ae->un.AttrString, 3319 sizeof(ae->un.AttrString)); 3320 len += (len & 3) ? (4 - (len & 3)) : 4; 3321 size = FOURBYTES + len; 3322 ad->AttrLen = cpu_to_be16(size); 3323 ad->AttrType = cpu_to_be16(RPRT_SMART_SERVICE); 3324 return size; 3325 } 3326 3327 static int 3328 lpfc_fdmi_smart_attr_guid(struct lpfc_vport *vport, 3329 struct lpfc_fdmi_attr_def *ad) 3330 { 3331 struct lpfc_fdmi_attr_entry *ae; 3332 uint32_t size; 3333 3334 ae = &ad->AttrValue; 3335 memset(ae, 0, sizeof(*ae)); 3336 3337 memcpy(&ae->un.AttrString, &vport->fc_sparam.nodeName, 3338 sizeof(struct lpfc_name)); 3339 memcpy((((uint8_t *)&ae->un.AttrString) + 3340 sizeof(struct lpfc_name)), 3341 &vport->fc_sparam.portName, sizeof(struct lpfc_name)); 3342 size = FOURBYTES + (2 * sizeof(struct lpfc_name)); 3343 ad->AttrLen = cpu_to_be16(size); 3344 ad->AttrType = cpu_to_be16(RPRT_SMART_GUID); 3345 return size; 3346 } 3347 3348 static int 3349 lpfc_fdmi_smart_attr_version(struct lpfc_vport *vport, 3350 struct lpfc_fdmi_attr_def *ad) 3351 { 3352 struct lpfc_fdmi_attr_entry *ae; 3353 uint32_t len, size; 3354 3355 ae = &ad->AttrValue; 3356 memset(ae, 0, sizeof(*ae)); 3357 3358 strncpy(ae->un.AttrString, "Smart SAN Version 2.0", 3359 sizeof(ae->un.AttrString)); 3360 len = strnlen(ae->un.AttrString, 3361 sizeof(ae->un.AttrString)); 3362 len += (len & 3) ? (4 - (len & 3)) : 4; 3363 size = FOURBYTES + len; 3364 ad->AttrLen = cpu_to_be16(size); 3365 ad->AttrType = cpu_to_be16(RPRT_SMART_VERSION); 3366 return size; 3367 } 3368 3369 static int 3370 lpfc_fdmi_smart_attr_model(struct lpfc_vport *vport, 3371 struct lpfc_fdmi_attr_def *ad) 3372 { 3373 struct lpfc_hba *phba = vport->phba; 3374 struct lpfc_fdmi_attr_entry *ae; 3375 uint32_t len, size; 3376 3377 ae = &ad->AttrValue; 3378 memset(ae, 0, sizeof(*ae)); 3379 3380 strncpy(ae->un.AttrString, phba->ModelName, 3381 sizeof(ae->un.AttrString)); 3382 len = strnlen(ae->un.AttrString, sizeof(ae->un.AttrString)); 3383 len += (len & 3) ? (4 - (len & 3)) : 4; 3384 size = FOURBYTES + len; 3385 ad->AttrLen = cpu_to_be16(size); 3386 ad->AttrType = cpu_to_be16(RPRT_SMART_MODEL); 3387 return size; 3388 } 3389 3390 static int 3391 lpfc_fdmi_smart_attr_port_info(struct lpfc_vport *vport, 3392 struct lpfc_fdmi_attr_def *ad) 3393 { 3394 struct lpfc_fdmi_attr_entry *ae; 3395 uint32_t size; 3396 3397 ae = &ad->AttrValue; 3398 3399 /* SRIOV (type 3) is not supported */ 3400 if (vport->vpi) 3401 ae->un.AttrInt = cpu_to_be32(2); /* NPIV */ 3402 else 3403 ae->un.AttrInt = cpu_to_be32(1); /* Physical */ 3404 size = FOURBYTES + sizeof(uint32_t); 3405 ad->AttrLen = cpu_to_be16(size); 3406 ad->AttrType = cpu_to_be16(RPRT_SMART_PORT_INFO); 3407 return size; 3408 } 3409 3410 static int 3411 lpfc_fdmi_smart_attr_qos(struct lpfc_vport *vport, 3412 struct lpfc_fdmi_attr_def *ad) 3413 { 3414 struct lpfc_fdmi_attr_entry *ae; 3415 uint32_t size; 3416 3417 ae = &ad->AttrValue; 3418 ae->un.AttrInt = cpu_to_be32(0); 3419 size = FOURBYTES + sizeof(uint32_t); 3420 ad->AttrLen = cpu_to_be16(size); 3421 ad->AttrType = cpu_to_be16(RPRT_SMART_QOS); 3422 return size; 3423 } 3424 3425 static int 3426 lpfc_fdmi_smart_attr_security(struct lpfc_vport *vport, 3427 struct lpfc_fdmi_attr_def *ad) 3428 { 3429 struct lpfc_fdmi_attr_entry *ae; 3430 uint32_t size; 3431 3432 ae = &ad->AttrValue; 3433 ae->un.AttrInt = cpu_to_be32(1); 3434 size = FOURBYTES + sizeof(uint32_t); 3435 ad->AttrLen = cpu_to_be16(size); 3436 ad->AttrType = cpu_to_be16(RPRT_SMART_SECURITY); 3437 return size; 3438 } 3439 3440 static int 3441 lpfc_fdmi_vendor_attr_mi(struct lpfc_vport *vport, 3442 struct lpfc_fdmi_attr_def *ad) 3443 { 3444 struct lpfc_hba *phba = vport->phba; 3445 struct lpfc_fdmi_attr_entry *ae; 3446 uint32_t len, size; 3447 char mibrevision[16]; 3448 3449 ae = (struct lpfc_fdmi_attr_entry *)&ad->AttrValue; 3450 memset(ae, 0, 256); 3451 sprintf(mibrevision, "ELXE2EM:%04d", 3452 phba->sli4_hba.pc_sli4_params.mi_ver); 3453 strncpy(ae->un.AttrString, &mibrevision[0], sizeof(ae->un.AttrString)); 3454 len = strnlen(ae->un.AttrString, sizeof(ae->un.AttrString)); 3455 len += (len & 3) ? (4 - (len & 3)) : 4; 3456 size = FOURBYTES + len; 3457 ad->AttrLen = cpu_to_be16(size); 3458 ad->AttrType = cpu_to_be16(RPRT_VENDOR_MI); 3459 return size; 3460 } 3461 3462 /* RHBA attribute jump table */ 3463 int (*lpfc_fdmi_hba_action[]) 3464 (struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad) = { 3465 /* Action routine Mask bit Attribute type */ 3466 lpfc_fdmi_hba_attr_wwnn, /* bit0 RHBA_NODENAME */ 3467 lpfc_fdmi_hba_attr_manufacturer, /* bit1 RHBA_MANUFACTURER */ 3468 lpfc_fdmi_hba_attr_sn, /* bit2 RHBA_SERIAL_NUMBER */ 3469 lpfc_fdmi_hba_attr_model, /* bit3 RHBA_MODEL */ 3470 lpfc_fdmi_hba_attr_description, /* bit4 RHBA_MODEL_DESCRIPTION */ 3471 lpfc_fdmi_hba_attr_hdw_ver, /* bit5 RHBA_HARDWARE_VERSION */ 3472 lpfc_fdmi_hba_attr_drvr_ver, /* bit6 RHBA_DRIVER_VERSION */ 3473 lpfc_fdmi_hba_attr_rom_ver, /* bit7 RHBA_OPTION_ROM_VERSION */ 3474 lpfc_fdmi_hba_attr_fmw_ver, /* bit8 RHBA_FIRMWARE_VERSION */ 3475 lpfc_fdmi_hba_attr_os_ver, /* bit9 RHBA_OS_NAME_VERSION */ 3476 lpfc_fdmi_hba_attr_ct_len, /* bit10 RHBA_MAX_CT_PAYLOAD_LEN */ 3477 lpfc_fdmi_hba_attr_symbolic_name, /* bit11 RHBA_SYM_NODENAME */ 3478 lpfc_fdmi_hba_attr_vendor_info, /* bit12 RHBA_VENDOR_INFO */ 3479 lpfc_fdmi_hba_attr_num_ports, /* bit13 RHBA_NUM_PORTS */ 3480 lpfc_fdmi_hba_attr_fabric_wwnn, /* bit14 RHBA_FABRIC_WWNN */ 3481 lpfc_fdmi_hba_attr_bios_ver, /* bit15 RHBA_BIOS_VERSION */ 3482 lpfc_fdmi_hba_attr_bios_state, /* bit16 RHBA_BIOS_STATE */ 3483 lpfc_fdmi_hba_attr_vendor_id, /* bit17 RHBA_VENDOR_ID */ 3484 }; 3485 3486 /* RPA / RPRT attribute jump table */ 3487 int (*lpfc_fdmi_port_action[]) 3488 (struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad) = { 3489 /* Action routine Mask bit Attribute type */ 3490 lpfc_fdmi_port_attr_fc4type, /* bit0 RPRT_SUPPORT_FC4_TYPES */ 3491 lpfc_fdmi_port_attr_support_speed, /* bit1 RPRT_SUPPORTED_SPEED */ 3492 lpfc_fdmi_port_attr_speed, /* bit2 RPRT_PORT_SPEED */ 3493 lpfc_fdmi_port_attr_max_frame, /* bit3 RPRT_MAX_FRAME_SIZE */ 3494 lpfc_fdmi_port_attr_os_devname, /* bit4 RPRT_OS_DEVICE_NAME */ 3495 lpfc_fdmi_port_attr_host_name, /* bit5 RPRT_HOST_NAME */ 3496 lpfc_fdmi_port_attr_wwnn, /* bit6 RPRT_NODENAME */ 3497 lpfc_fdmi_port_attr_wwpn, /* bit7 RPRT_PORTNAME */ 3498 lpfc_fdmi_port_attr_symbolic_name, /* bit8 RPRT_SYM_PORTNAME */ 3499 lpfc_fdmi_port_attr_port_type, /* bit9 RPRT_PORT_TYPE */ 3500 lpfc_fdmi_port_attr_class, /* bit10 RPRT_SUPPORTED_CLASS */ 3501 lpfc_fdmi_port_attr_fabric_wwpn, /* bit11 RPRT_FABRICNAME */ 3502 lpfc_fdmi_port_attr_active_fc4type, /* bit12 RPRT_ACTIVE_FC4_TYPES */ 3503 lpfc_fdmi_port_attr_port_state, /* bit13 RPRT_PORT_STATE */ 3504 lpfc_fdmi_port_attr_num_disc, /* bit14 RPRT_DISC_PORT */ 3505 lpfc_fdmi_port_attr_nportid, /* bit15 RPRT_PORT_ID */ 3506 lpfc_fdmi_smart_attr_service, /* bit16 RPRT_SMART_SERVICE */ 3507 lpfc_fdmi_smart_attr_guid, /* bit17 RPRT_SMART_GUID */ 3508 lpfc_fdmi_smart_attr_version, /* bit18 RPRT_SMART_VERSION */ 3509 lpfc_fdmi_smart_attr_model, /* bit19 RPRT_SMART_MODEL */ 3510 lpfc_fdmi_smart_attr_port_info, /* bit20 RPRT_SMART_PORT_INFO */ 3511 lpfc_fdmi_smart_attr_qos, /* bit21 RPRT_SMART_QOS */ 3512 lpfc_fdmi_smart_attr_security, /* bit22 RPRT_SMART_SECURITY */ 3513 lpfc_fdmi_vendor_attr_mi, /* bit23 RPRT_VENDOR_MI */ 3514 }; 3515 3516 /** 3517 * lpfc_fdmi_cmd - Build and send a FDMI cmd to the specified NPort 3518 * @vport: pointer to a host virtual N_Port data structure. 3519 * @ndlp: ndlp to send FDMI cmd to (if NULL use FDMI_DID) 3520 * @cmdcode: FDMI command to send 3521 * @new_mask: Mask of HBA or PORT Attributes to send 3522 * 3523 * Builds and sends a FDMI command using the CT subsystem. 3524 */ 3525 int 3526 lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 3527 int cmdcode, uint32_t new_mask) 3528 { 3529 struct lpfc_hba *phba = vport->phba; 3530 struct lpfc_dmabuf *mp, *bmp; 3531 struct lpfc_sli_ct_request *CtReq; 3532 struct ulp_bde64 *bpl; 3533 uint32_t bit_pos; 3534 uint32_t size; 3535 uint32_t rsp_size; 3536 uint32_t mask; 3537 struct lpfc_fdmi_reg_hba *rh; 3538 struct lpfc_fdmi_port_entry *pe; 3539 struct lpfc_fdmi_reg_portattr *pab = NULL; 3540 struct lpfc_fdmi_attr_block *ab = NULL; 3541 int (*func)(struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad); 3542 void (*cmpl)(struct lpfc_hba *, struct lpfc_iocbq *, 3543 struct lpfc_iocbq *); 3544 3545 if (!ndlp) 3546 return 0; 3547 3548 cmpl = lpfc_cmpl_ct_disc_fdmi; /* called from discovery */ 3549 3550 /* fill in BDEs for command */ 3551 /* Allocate buffer for command payload */ 3552 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 3553 if (!mp) 3554 goto fdmi_cmd_exit; 3555 3556 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys)); 3557 if (!mp->virt) 3558 goto fdmi_cmd_free_mp; 3559 3560 /* Allocate buffer for Buffer ptr list */ 3561 bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 3562 if (!bmp) 3563 goto fdmi_cmd_free_mpvirt; 3564 3565 bmp->virt = lpfc_mbuf_alloc(phba, 0, &(bmp->phys)); 3566 if (!bmp->virt) 3567 goto fdmi_cmd_free_bmp; 3568 3569 INIT_LIST_HEAD(&mp->list); 3570 INIT_LIST_HEAD(&bmp->list); 3571 3572 /* FDMI request */ 3573 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 3574 "0218 FDMI Request x%x mask x%x Data: x%x x%x x%x\n", 3575 cmdcode, new_mask, vport->fdmi_port_mask, 3576 vport->fc_flag, vport->port_state); 3577 3578 CtReq = (struct lpfc_sli_ct_request *)mp->virt; 3579 3580 /* First populate the CT_IU preamble */ 3581 memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request)); 3582 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION; 3583 CtReq->RevisionId.bits.InId = 0; 3584 3585 CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE; 3586 CtReq->FsSubType = SLI_CT_FDMI_Subtypes; 3587 3588 CtReq->CommandResponse.bits.CmdRsp = cpu_to_be16(cmdcode); 3589 rsp_size = LPFC_BPL_SIZE; 3590 size = 0; 3591 3592 /* Next fill in the specific FDMI cmd information */ 3593 switch (cmdcode) { 3594 case SLI_MGMT_RHAT: 3595 case SLI_MGMT_RHBA: 3596 rh = (struct lpfc_fdmi_reg_hba *)&CtReq->un.PortID; 3597 /* HBA Identifier */ 3598 memcpy(&rh->hi.PortName, &phba->pport->fc_sparam.portName, 3599 sizeof(struct lpfc_name)); 3600 3601 if (cmdcode == SLI_MGMT_RHBA) { 3602 /* Registered Port List */ 3603 /* One entry (port) per adapter */ 3604 rh->rpl.EntryCnt = cpu_to_be32(1); 3605 memcpy(&rh->rpl.pe.PortName, 3606 &phba->pport->fc_sparam.portName, 3607 sizeof(struct lpfc_name)); 3608 3609 /* point to the HBA attribute block */ 3610 size = 2 * sizeof(struct lpfc_name) + 3611 FOURBYTES; 3612 } else { 3613 size = sizeof(struct lpfc_name); 3614 } 3615 ab = (struct lpfc_fdmi_attr_block *)((uint8_t *)rh + size); 3616 ab->EntryCnt = 0; 3617 size += FOURBYTES; 3618 bit_pos = 0; 3619 if (new_mask) 3620 mask = new_mask; 3621 else 3622 mask = vport->fdmi_hba_mask; 3623 3624 /* Mask will dictate what attributes to build in the request */ 3625 while (mask) { 3626 if (mask & 0x1) { 3627 func = lpfc_fdmi_hba_action[bit_pos]; 3628 size += func(vport, 3629 (struct lpfc_fdmi_attr_def *) 3630 ((uint8_t *)rh + size)); 3631 ab->EntryCnt++; 3632 if ((size + 256) > 3633 (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE)) 3634 goto hba_out; 3635 } 3636 mask = mask >> 1; 3637 bit_pos++; 3638 } 3639 hba_out: 3640 ab->EntryCnt = cpu_to_be32(ab->EntryCnt); 3641 /* Total size */ 3642 size = GID_REQUEST_SZ - 4 + size; 3643 break; 3644 3645 case SLI_MGMT_RPRT: 3646 if (vport->port_type != LPFC_PHYSICAL_PORT) { 3647 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID); 3648 if (!ndlp) 3649 return 0; 3650 } 3651 fallthrough; 3652 case SLI_MGMT_RPA: 3653 pab = (struct lpfc_fdmi_reg_portattr *)&CtReq->un.PortID; 3654 if (cmdcode == SLI_MGMT_RPRT) { 3655 rh = (struct lpfc_fdmi_reg_hba *)pab; 3656 /* HBA Identifier */ 3657 memcpy(&rh->hi.PortName, 3658 &phba->pport->fc_sparam.portName, 3659 sizeof(struct lpfc_name)); 3660 pab = (struct lpfc_fdmi_reg_portattr *) 3661 ((uint8_t *)pab + sizeof(struct lpfc_name)); 3662 } 3663 3664 memcpy((uint8_t *)&pab->PortName, 3665 (uint8_t *)&vport->fc_sparam.portName, 3666 sizeof(struct lpfc_name)); 3667 size += sizeof(struct lpfc_name) + FOURBYTES; 3668 pab->ab.EntryCnt = 0; 3669 bit_pos = 0; 3670 if (new_mask) 3671 mask = new_mask; 3672 else 3673 mask = vport->fdmi_port_mask; 3674 3675 /* Mask will dictate what attributes to build in the request */ 3676 while (mask) { 3677 if (mask & 0x1) { 3678 func = lpfc_fdmi_port_action[bit_pos]; 3679 size += func(vport, 3680 (struct lpfc_fdmi_attr_def *) 3681 ((uint8_t *)pab + size)); 3682 pab->ab.EntryCnt++; 3683 if ((size + 256) > 3684 (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE)) 3685 goto port_out; 3686 } 3687 mask = mask >> 1; 3688 bit_pos++; 3689 } 3690 port_out: 3691 pab->ab.EntryCnt = cpu_to_be32(pab->ab.EntryCnt); 3692 /* Total size */ 3693 if (cmdcode == SLI_MGMT_RPRT) 3694 size += sizeof(struct lpfc_name); 3695 size = GID_REQUEST_SZ - 4 + size; 3696 break; 3697 3698 case SLI_MGMT_GHAT: 3699 case SLI_MGMT_GRPL: 3700 rsp_size = FC_MAX_NS_RSP; 3701 fallthrough; 3702 case SLI_MGMT_DHBA: 3703 case SLI_MGMT_DHAT: 3704 pe = (struct lpfc_fdmi_port_entry *)&CtReq->un.PortID; 3705 memcpy((uint8_t *)&pe->PortName, 3706 (uint8_t *)&vport->fc_sparam.portName, 3707 sizeof(struct lpfc_name)); 3708 size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name); 3709 break; 3710 3711 case SLI_MGMT_GPAT: 3712 case SLI_MGMT_GPAS: 3713 rsp_size = FC_MAX_NS_RSP; 3714 fallthrough; 3715 case SLI_MGMT_DPRT: 3716 if (vport->port_type != LPFC_PHYSICAL_PORT) { 3717 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID); 3718 if (!ndlp) 3719 return 0; 3720 } 3721 fallthrough; 3722 case SLI_MGMT_DPA: 3723 pe = (struct lpfc_fdmi_port_entry *)&CtReq->un.PortID; 3724 memcpy((uint8_t *)&pe->PortName, 3725 (uint8_t *)&vport->fc_sparam.portName, 3726 sizeof(struct lpfc_name)); 3727 size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name); 3728 break; 3729 case SLI_MGMT_GRHL: 3730 size = GID_REQUEST_SZ - 4; 3731 break; 3732 default: 3733 lpfc_printf_vlog(vport, KERN_WARNING, LOG_DISCOVERY, 3734 "0298 FDMI cmdcode x%x not supported\n", 3735 cmdcode); 3736 goto fdmi_cmd_free_bmpvirt; 3737 } 3738 CtReq->CommandResponse.bits.Size = cpu_to_be16(rsp_size); 3739 3740 bpl = (struct ulp_bde64 *)bmp->virt; 3741 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys)); 3742 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys)); 3743 bpl->tus.f.bdeFlags = 0; 3744 bpl->tus.f.bdeSize = size; 3745 3746 /* 3747 * The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count 3748 * to hold ndlp reference for the corresponding callback function. 3749 */ 3750 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, 0)) 3751 return 0; 3752 3753 fdmi_cmd_free_bmpvirt: 3754 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 3755 fdmi_cmd_free_bmp: 3756 kfree(bmp); 3757 fdmi_cmd_free_mpvirt: 3758 lpfc_mbuf_free(phba, mp->virt, mp->phys); 3759 fdmi_cmd_free_mp: 3760 kfree(mp); 3761 fdmi_cmd_exit: 3762 /* Issue FDMI request failed */ 3763 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 3764 "0244 Issue FDMI request failed Data: x%x\n", 3765 cmdcode); 3766 return 1; 3767 } 3768 3769 /** 3770 * lpfc_delayed_disc_tmo - Timeout handler for delayed discovery timer. 3771 * @t: Context object of the timer. 3772 * 3773 * This function set the WORKER_DELAYED_DISC_TMO flag and wake up 3774 * the worker thread. 3775 **/ 3776 void 3777 lpfc_delayed_disc_tmo(struct timer_list *t) 3778 { 3779 struct lpfc_vport *vport = from_timer(vport, t, delayed_disc_tmo); 3780 struct lpfc_hba *phba = vport->phba; 3781 uint32_t tmo_posted; 3782 unsigned long iflag; 3783 3784 spin_lock_irqsave(&vport->work_port_lock, iflag); 3785 tmo_posted = vport->work_port_events & WORKER_DELAYED_DISC_TMO; 3786 if (!tmo_posted) 3787 vport->work_port_events |= WORKER_DELAYED_DISC_TMO; 3788 spin_unlock_irqrestore(&vport->work_port_lock, iflag); 3789 3790 if (!tmo_posted) 3791 lpfc_worker_wake_up(phba); 3792 return; 3793 } 3794 3795 /** 3796 * lpfc_delayed_disc_timeout_handler - Function called by worker thread to 3797 * handle delayed discovery. 3798 * @vport: pointer to a host virtual N_Port data structure. 3799 * 3800 * This function start nport discovery of the vport. 3801 **/ 3802 void 3803 lpfc_delayed_disc_timeout_handler(struct lpfc_vport *vport) 3804 { 3805 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 3806 3807 spin_lock_irq(shost->host_lock); 3808 if (!(vport->fc_flag & FC_DISC_DELAYED)) { 3809 spin_unlock_irq(shost->host_lock); 3810 return; 3811 } 3812 vport->fc_flag &= ~FC_DISC_DELAYED; 3813 spin_unlock_irq(shost->host_lock); 3814 3815 lpfc_do_scr_ns_plogi(vport->phba, vport); 3816 } 3817 3818 void 3819 lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag) 3820 { 3821 struct lpfc_sli *psli = &phba->sli; 3822 lpfc_vpd_t *vp = &phba->vpd; 3823 uint32_t b1, b2, b3, b4, i, rev; 3824 char c; 3825 uint32_t *ptr, str[4]; 3826 uint8_t *fwname; 3827 3828 if (phba->sli_rev == LPFC_SLI_REV4) 3829 snprintf(fwrevision, FW_REV_STR_SIZE, "%s", vp->rev.opFwName); 3830 else if (vp->rev.rBit) { 3831 if (psli->sli_flag & LPFC_SLI_ACTIVE) 3832 rev = vp->rev.sli2FwRev; 3833 else 3834 rev = vp->rev.sli1FwRev; 3835 3836 b1 = (rev & 0x0000f000) >> 12; 3837 b2 = (rev & 0x00000f00) >> 8; 3838 b3 = (rev & 0x000000c0) >> 6; 3839 b4 = (rev & 0x00000030) >> 4; 3840 3841 switch (b4) { 3842 case 0: 3843 c = 'N'; 3844 break; 3845 case 1: 3846 c = 'A'; 3847 break; 3848 case 2: 3849 c = 'B'; 3850 break; 3851 case 3: 3852 c = 'X'; 3853 break; 3854 default: 3855 c = 0; 3856 break; 3857 } 3858 b4 = (rev & 0x0000000f); 3859 3860 if (psli->sli_flag & LPFC_SLI_ACTIVE) 3861 fwname = vp->rev.sli2FwName; 3862 else 3863 fwname = vp->rev.sli1FwName; 3864 3865 for (i = 0; i < 16; i++) 3866 if (fwname[i] == 0x20) 3867 fwname[i] = 0; 3868 3869 ptr = (uint32_t*)fwname; 3870 3871 for (i = 0; i < 3; i++) 3872 str[i] = be32_to_cpu(*ptr++); 3873 3874 if (c == 0) { 3875 if (flag) 3876 sprintf(fwrevision, "%d.%d%d (%s)", 3877 b1, b2, b3, (char *)str); 3878 else 3879 sprintf(fwrevision, "%d.%d%d", b1, 3880 b2, b3); 3881 } else { 3882 if (flag) 3883 sprintf(fwrevision, "%d.%d%d%c%d (%s)", 3884 b1, b2, b3, c, 3885 b4, (char *)str); 3886 else 3887 sprintf(fwrevision, "%d.%d%d%c%d", 3888 b1, b2, b3, c, b4); 3889 } 3890 } else { 3891 rev = vp->rev.smFwRev; 3892 3893 b1 = (rev & 0xff000000) >> 24; 3894 b2 = (rev & 0x00f00000) >> 20; 3895 b3 = (rev & 0x000f0000) >> 16; 3896 c = (rev & 0x0000ff00) >> 8; 3897 b4 = (rev & 0x000000ff); 3898 3899 sprintf(fwrevision, "%d.%d%d%c%d", b1, b2, b3, c, b4); 3900 } 3901 return; 3902 } 3903 3904 static void 3905 lpfc_cmpl_ct_cmd_vmid(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 3906 struct lpfc_iocbq *rspiocb) 3907 { 3908 struct lpfc_vport *vport = cmdiocb->vport; 3909 struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf; 3910 struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf; 3911 struct lpfc_sli_ct_request *ctcmd = inp->virt; 3912 struct lpfc_sli_ct_request *ctrsp = outp->virt; 3913 u16 rsp = ctrsp->CommandResponse.bits.CmdRsp; 3914 struct app_id_object *app; 3915 u32 cmd, hash, bucket; 3916 struct lpfc_vmid *vmp, *cur; 3917 u8 *data = outp->virt; 3918 int i; 3919 3920 cmd = be16_to_cpu(ctcmd->CommandResponse.bits.CmdRsp); 3921 if (cmd == SLI_CTAS_DALLAPP_ID) 3922 lpfc_ct_free_iocb(phba, cmdiocb); 3923 3924 if (lpfc_els_chk_latt(vport) || get_job_ulpstatus(phba, rspiocb)) { 3925 if (cmd != SLI_CTAS_DALLAPP_ID) 3926 return; 3927 } 3928 /* Check for a CT LS_RJT response */ 3929 if (rsp == be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) { 3930 if (cmd != SLI_CTAS_DALLAPP_ID) 3931 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 3932 "3306 VMID FS_RJT Data: x%x x%x x%x\n", 3933 cmd, ctrsp->ReasonCode, 3934 ctrsp->Explanation); 3935 if ((cmd != SLI_CTAS_DALLAPP_ID) || 3936 (ctrsp->ReasonCode != SLI_CT_UNABLE_TO_PERFORM_REQ) || 3937 (ctrsp->Explanation != SLI_CT_APP_ID_NOT_AVAILABLE)) { 3938 /* If DALLAPP_ID failed retry later */ 3939 if (cmd == SLI_CTAS_DALLAPP_ID) 3940 vport->load_flag |= FC_DEREGISTER_ALL_APP_ID; 3941 return; 3942 } 3943 } 3944 3945 switch (cmd) { 3946 case SLI_CTAS_RAPP_IDENT: 3947 app = (struct app_id_object *)(RAPP_IDENT_OFFSET + data); 3948 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 3949 "6712 RAPP_IDENT app id %d port id x%x id " 3950 "len %d\n", be32_to_cpu(app->app_id), 3951 be32_to_cpu(app->port_id), 3952 app->obj.entity_id_len); 3953 3954 if (app->obj.entity_id_len == 0 || app->port_id == 0) 3955 return; 3956 3957 hash = lpfc_vmid_hash_fn(app->obj.entity_id, 3958 app->obj.entity_id_len); 3959 vmp = lpfc_get_vmid_from_hashtable(vport, hash, 3960 app->obj.entity_id); 3961 if (vmp) { 3962 write_lock(&vport->vmid_lock); 3963 vmp->un.app_id = be32_to_cpu(app->app_id); 3964 vmp->flag |= LPFC_VMID_REGISTERED; 3965 vmp->flag &= ~LPFC_VMID_REQ_REGISTER; 3966 write_unlock(&vport->vmid_lock); 3967 /* Set IN USE flag */ 3968 vport->vmid_flag |= LPFC_VMID_IN_USE; 3969 } else { 3970 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 3971 "6901 No entry found %s hash %d\n", 3972 app->obj.entity_id, hash); 3973 } 3974 break; 3975 case SLI_CTAS_DAPP_IDENT: 3976 app = (struct app_id_object *)(DAPP_IDENT_OFFSET + data); 3977 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 3978 "6713 DAPP_IDENT app id %d port id x%x\n", 3979 be32_to_cpu(app->app_id), 3980 be32_to_cpu(app->port_id)); 3981 break; 3982 case SLI_CTAS_DALLAPP_ID: 3983 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 3984 "8856 Deregistered all app ids\n"); 3985 read_lock(&vport->vmid_lock); 3986 for (i = 0; i < phba->cfg_max_vmid; i++) { 3987 vmp = &vport->vmid[i]; 3988 if (vmp->flag != LPFC_VMID_SLOT_FREE) 3989 memset(vmp, 0, sizeof(struct lpfc_vmid)); 3990 } 3991 read_unlock(&vport->vmid_lock); 3992 /* for all elements in the hash table */ 3993 if (!hash_empty(vport->hash_table)) 3994 hash_for_each(vport->hash_table, bucket, cur, hnode) 3995 hash_del(&cur->hnode); 3996 vport->load_flag |= FC_ALLOW_VMID; 3997 break; 3998 default: 3999 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 4000 "8857 Invalid command code\n"); 4001 } 4002 } 4003 4004 /** 4005 * lpfc_vmid_cmd - Build and send a FDMI cmd to the specified NPort 4006 * @vport: pointer to a host virtual N_Port data structure. 4007 * @cmdcode: application server command code to send 4008 * @vmid: pointer to vmid info structure 4009 * 4010 * Builds and sends a FDMI command using the CT subsystem. 4011 */ 4012 int 4013 lpfc_vmid_cmd(struct lpfc_vport *vport, 4014 int cmdcode, struct lpfc_vmid *vmid) 4015 { 4016 struct lpfc_hba *phba = vport->phba; 4017 struct lpfc_dmabuf *mp, *bmp; 4018 struct lpfc_sli_ct_request *ctreq; 4019 struct ulp_bde64 *bpl; 4020 u32 size; 4021 u32 rsp_size; 4022 u8 *data; 4023 struct lpfc_vmid_rapp_ident_list *rap; 4024 struct lpfc_vmid_dapp_ident_list *dap; 4025 u8 retry = 0; 4026 struct lpfc_nodelist *ndlp; 4027 4028 void (*cmpl)(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 4029 struct lpfc_iocbq *rspiocb); 4030 4031 ndlp = lpfc_findnode_did(vport, FDMI_DID); 4032 if (!ndlp || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) 4033 return 0; 4034 4035 cmpl = lpfc_cmpl_ct_cmd_vmid; 4036 4037 /* fill in BDEs for command */ 4038 /* Allocate buffer for command payload */ 4039 mp = kmalloc(sizeof(*mp), GFP_KERNEL); 4040 if (!mp) 4041 goto vmid_free_mp_exit; 4042 4043 mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys); 4044 if (!mp->virt) 4045 goto vmid_free_mp_virt_exit; 4046 4047 /* Allocate buffer for Buffer ptr list */ 4048 bmp = kmalloc(sizeof(*bmp), GFP_KERNEL); 4049 if (!bmp) 4050 goto vmid_free_bmp_exit; 4051 4052 bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys); 4053 if (!bmp->virt) 4054 goto vmid_free_bmp_virt_exit; 4055 4056 INIT_LIST_HEAD(&mp->list); 4057 INIT_LIST_HEAD(&bmp->list); 4058 4059 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 4060 "3275 VMID Request Data: x%x x%x x%x\n", 4061 vport->fc_flag, vport->port_state, cmdcode); 4062 ctreq = (struct lpfc_sli_ct_request *)mp->virt; 4063 data = mp->virt; 4064 /* First populate the CT_IU preamble */ 4065 memset(data, 0, LPFC_BPL_SIZE); 4066 ctreq->RevisionId.bits.Revision = SLI_CT_REVISION; 4067 ctreq->RevisionId.bits.InId = 0; 4068 4069 ctreq->FsType = SLI_CT_MANAGEMENT_SERVICE; 4070 ctreq->FsSubType = SLI_CT_APP_SEV_Subtypes; 4071 4072 ctreq->CommandResponse.bits.CmdRsp = cpu_to_be16(cmdcode); 4073 rsp_size = LPFC_BPL_SIZE; 4074 size = 0; 4075 4076 switch (cmdcode) { 4077 case SLI_CTAS_RAPP_IDENT: 4078 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 4079 "1329 RAPP_IDENT for %s\n", vmid->host_vmid); 4080 ctreq->un.PortID = cpu_to_be32(vport->fc_myDID); 4081 rap = (struct lpfc_vmid_rapp_ident_list *) 4082 (DAPP_IDENT_OFFSET + data); 4083 rap->no_of_objects = cpu_to_be32(1); 4084 rap->obj[0].entity_id_len = vmid->vmid_len; 4085 memcpy(rap->obj[0].entity_id, vmid->host_vmid, vmid->vmid_len); 4086 size = RAPP_IDENT_OFFSET + 4087 sizeof(struct lpfc_vmid_rapp_ident_list); 4088 retry = 1; 4089 break; 4090 4091 case SLI_CTAS_GALLAPPIA_ID: 4092 ctreq->un.PortID = cpu_to_be32(vport->fc_myDID); 4093 size = GALLAPPIA_ID_SIZE; 4094 break; 4095 4096 case SLI_CTAS_DAPP_IDENT: 4097 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 4098 "1469 DAPP_IDENT for %s\n", vmid->host_vmid); 4099 ctreq->un.PortID = cpu_to_be32(vport->fc_myDID); 4100 dap = (struct lpfc_vmid_dapp_ident_list *) 4101 (DAPP_IDENT_OFFSET + data); 4102 dap->no_of_objects = cpu_to_be32(1); 4103 dap->obj[0].entity_id_len = vmid->vmid_len; 4104 memcpy(dap->obj[0].entity_id, vmid->host_vmid, vmid->vmid_len); 4105 size = DAPP_IDENT_OFFSET + 4106 sizeof(struct lpfc_vmid_dapp_ident_list); 4107 write_lock(&vport->vmid_lock); 4108 vmid->flag &= ~LPFC_VMID_REGISTERED; 4109 write_unlock(&vport->vmid_lock); 4110 retry = 1; 4111 break; 4112 4113 case SLI_CTAS_DALLAPP_ID: 4114 ctreq->un.PortID = cpu_to_be32(vport->fc_myDID); 4115 size = DALLAPP_ID_SIZE; 4116 break; 4117 4118 default: 4119 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 4120 "7062 VMID cmdcode x%x not supported\n", 4121 cmdcode); 4122 goto vmid_free_all_mem; 4123 } 4124 4125 ctreq->CommandResponse.bits.Size = cpu_to_be16(rsp_size); 4126 4127 bpl = (struct ulp_bde64 *)bmp->virt; 4128 bpl->addrHigh = putPaddrHigh(mp->phys); 4129 bpl->addrLow = putPaddrLow(mp->phys); 4130 bpl->tus.f.bdeFlags = 0; 4131 bpl->tus.f.bdeSize = size; 4132 4133 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count 4134 * to hold ndlp reference for the corresponding callback function. 4135 */ 4136 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) 4137 return 0; 4138 4139 vmid_free_all_mem: 4140 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 4141 vmid_free_bmp_virt_exit: 4142 kfree(bmp); 4143 vmid_free_bmp_exit: 4144 lpfc_mbuf_free(phba, mp->virt, mp->phys); 4145 vmid_free_mp_virt_exit: 4146 kfree(mp); 4147 vmid_free_mp_exit: 4148 4149 /* Issue CT request failed */ 4150 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY, 4151 "3276 VMID CT request failed Data: x%x\n", cmdcode); 4152 return -EIO; 4153 } 4154