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