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