1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2009 Emulex. All rights reserved. * 5 * EMULEX and SLI are trademarks of Emulex. * 6 * www.emulex.com * 7 * * 8 * This program is free software; you can redistribute it and/or * 9 * modify it under the terms of version 2 of the GNU General * 10 * Public License as published by the Free Software Foundation. * 11 * This program is distributed in the hope that it will be useful. * 12 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * 13 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * 14 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * 15 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * 16 * TO BE LEGALLY INVALID. See the GNU General Public License for * 17 * more details, a copy of which can be found in the file COPYING * 18 * included with this package. * 19 *******************************************************************/ 20 21 /* 22 * Fibre Channel SCSI LAN Device Driver CT support: FC Generic Services FC-GS 23 */ 24 25 #include <linux/blkdev.h> 26 #include <linux/pci.h> 27 #include <linux/interrupt.h> 28 #include <linux/utsname.h> 29 30 #include <scsi/scsi.h> 31 #include <scsi/scsi_device.h> 32 #include <scsi/scsi_host.h> 33 #include <scsi/scsi_transport_fc.h> 34 35 #include "lpfc_hw4.h" 36 #include "lpfc_hw.h" 37 #include "lpfc_sli.h" 38 #include "lpfc_sli4.h" 39 #include "lpfc_nl.h" 40 #include "lpfc_disc.h" 41 #include "lpfc_scsi.h" 42 #include "lpfc.h" 43 #include "lpfc_logmsg.h" 44 #include "lpfc_crtn.h" 45 #include "lpfc_version.h" 46 #include "lpfc_vport.h" 47 #include "lpfc_debugfs.h" 48 49 #define HBA_PORTSPEED_UNKNOWN 0 /* Unknown - transceiver 50 * incapable of reporting */ 51 #define HBA_PORTSPEED_1GBIT 1 /* 1 GBit/sec */ 52 #define HBA_PORTSPEED_2GBIT 2 /* 2 GBit/sec */ 53 #define HBA_PORTSPEED_4GBIT 8 /* 4 GBit/sec */ 54 #define HBA_PORTSPEED_8GBIT 16 /* 8 GBit/sec */ 55 #define HBA_PORTSPEED_10GBIT 4 /* 10 GBit/sec */ 56 #define HBA_PORTSPEED_NOT_NEGOTIATED 5 /* Speed not established */ 57 58 #define FOURBYTES 4 59 60 61 static char *lpfc_release_version = LPFC_DRIVER_VERSION; 62 63 static void 64 lpfc_ct_ignore_hbq_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq, 65 struct lpfc_dmabuf *mp, uint32_t size) 66 { 67 if (!mp) { 68 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 69 "0146 Ignoring unsolicited CT No HBQ " 70 "status = x%x\n", 71 piocbq->iocb.ulpStatus); 72 } 73 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 74 "0145 Ignoring unsolicted CT HBQ Size:%d " 75 "status = x%x\n", 76 size, piocbq->iocb.ulpStatus); 77 } 78 79 static void 80 lpfc_ct_unsol_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq, 81 struct lpfc_dmabuf *mp, uint32_t size) 82 { 83 lpfc_ct_ignore_hbq_buffer(phba, piocbq, mp, size); 84 } 85 86 void 87 lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, 88 struct lpfc_iocbq *piocbq) 89 { 90 91 struct lpfc_dmabuf *mp = NULL; 92 IOCB_t *icmd = &piocbq->iocb; 93 int i; 94 struct lpfc_iocbq *iocbq; 95 dma_addr_t paddr; 96 uint32_t size; 97 struct list_head head; 98 struct lpfc_dmabuf *bdeBuf; 99 100 lpfc_bsg_ct_unsol_event(phba, pring, piocbq); 101 102 if (unlikely(icmd->ulpStatus == IOSTAT_NEED_BUFFER)) { 103 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ); 104 } else if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) && 105 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) { 106 /* Not enough posted buffers; Try posting more buffers */ 107 phba->fc_stat.NoRcvBuf++; 108 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)) 109 lpfc_post_buffer(phba, pring, 2); 110 return; 111 } 112 113 /* If there are no BDEs associated with this IOCB, 114 * there is nothing to do. 115 */ 116 if (icmd->ulpBdeCount == 0) 117 return; 118 119 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) { 120 INIT_LIST_HEAD(&head); 121 list_add_tail(&head, &piocbq->list); 122 list_for_each_entry(iocbq, &head, list) { 123 icmd = &iocbq->iocb; 124 if (icmd->ulpBdeCount == 0) 125 continue; 126 bdeBuf = iocbq->context2; 127 iocbq->context2 = NULL; 128 size = icmd->un.cont64[0].tus.f.bdeSize; 129 lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf, size); 130 lpfc_in_buf_free(phba, bdeBuf); 131 if (icmd->ulpBdeCount == 2) { 132 bdeBuf = iocbq->context3; 133 iocbq->context3 = NULL; 134 size = icmd->unsli3.rcvsli3.bde2.tus.f.bdeSize; 135 lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf, 136 size); 137 lpfc_in_buf_free(phba, bdeBuf); 138 } 139 } 140 list_del(&head); 141 } else { 142 INIT_LIST_HEAD(&head); 143 list_add_tail(&head, &piocbq->list); 144 list_for_each_entry(iocbq, &head, list) { 145 icmd = &iocbq->iocb; 146 if (icmd->ulpBdeCount == 0) 147 lpfc_ct_unsol_buffer(phba, iocbq, NULL, 0); 148 for (i = 0; i < icmd->ulpBdeCount; i++) { 149 paddr = getPaddr(icmd->un.cont64[i].addrHigh, 150 icmd->un.cont64[i].addrLow); 151 mp = lpfc_sli_ringpostbuf_get(phba, pring, 152 paddr); 153 size = icmd->un.cont64[i].tus.f.bdeSize; 154 lpfc_ct_unsol_buffer(phba, iocbq, mp, size); 155 lpfc_in_buf_free(phba, mp); 156 } 157 lpfc_post_buffer(phba, pring, i); 158 } 159 list_del(&head); 160 } 161 } 162 163 static void 164 lpfc_free_ct_rsp(struct lpfc_hba *phba, struct lpfc_dmabuf *mlist) 165 { 166 struct lpfc_dmabuf *mlast, *next_mlast; 167 168 list_for_each_entry_safe(mlast, next_mlast, &mlist->list, list) { 169 lpfc_mbuf_free(phba, mlast->virt, mlast->phys); 170 list_del(&mlast->list); 171 kfree(mlast); 172 } 173 lpfc_mbuf_free(phba, mlist->virt, mlist->phys); 174 kfree(mlist); 175 return; 176 } 177 178 static struct lpfc_dmabuf * 179 lpfc_alloc_ct_rsp(struct lpfc_hba *phba, int cmdcode, struct ulp_bde64 *bpl, 180 uint32_t size, int *entries) 181 { 182 struct lpfc_dmabuf *mlist = NULL; 183 struct lpfc_dmabuf *mp; 184 int cnt, i = 0; 185 186 /* We get chunks of FCELSSIZE */ 187 cnt = size > FCELSSIZE ? FCELSSIZE: size; 188 189 while (size) { 190 /* Allocate buffer for rsp payload */ 191 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 192 if (!mp) { 193 if (mlist) 194 lpfc_free_ct_rsp(phba, mlist); 195 return NULL; 196 } 197 198 INIT_LIST_HEAD(&mp->list); 199 200 if (cmdcode == be16_to_cpu(SLI_CTNS_GID_FT) || 201 cmdcode == be16_to_cpu(SLI_CTNS_GFF_ID)) 202 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys)); 203 else 204 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys)); 205 206 if (!mp->virt) { 207 kfree(mp); 208 if (mlist) 209 lpfc_free_ct_rsp(phba, mlist); 210 return NULL; 211 } 212 213 /* Queue it to a linked list */ 214 if (!mlist) 215 mlist = mp; 216 else 217 list_add_tail(&mp->list, &mlist->list); 218 219 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I; 220 /* build buffer ptr list for IOCB */ 221 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) ); 222 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) ); 223 bpl->tus.f.bdeSize = (uint16_t) cnt; 224 bpl->tus.w = le32_to_cpu(bpl->tus.w); 225 bpl++; 226 227 i++; 228 size -= cnt; 229 } 230 231 *entries = i; 232 return mlist; 233 } 234 235 int 236 lpfc_ct_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocb) 237 { 238 struct lpfc_dmabuf *buf_ptr; 239 240 if (ctiocb->context_un.ndlp) { 241 lpfc_nlp_put(ctiocb->context_un.ndlp); 242 ctiocb->context_un.ndlp = NULL; 243 } 244 if (ctiocb->context1) { 245 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context1; 246 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys); 247 kfree(buf_ptr); 248 ctiocb->context1 = NULL; 249 } 250 if (ctiocb->context2) { 251 lpfc_free_ct_rsp(phba, (struct lpfc_dmabuf *) ctiocb->context2); 252 ctiocb->context2 = NULL; 253 } 254 255 if (ctiocb->context3) { 256 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context3; 257 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys); 258 kfree(buf_ptr); 259 ctiocb->context1 = NULL; 260 } 261 lpfc_sli_release_iocbq(phba, ctiocb); 262 return 0; 263 } 264 265 static int 266 lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp, 267 struct lpfc_dmabuf *inp, struct lpfc_dmabuf *outp, 268 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 269 struct lpfc_iocbq *), 270 struct lpfc_nodelist *ndlp, uint32_t usr_flg, uint32_t num_entry, 271 uint32_t tmo, uint8_t retry) 272 { 273 struct lpfc_hba *phba = vport->phba; 274 IOCB_t *icmd; 275 struct lpfc_iocbq *geniocb; 276 int rc; 277 278 /* Allocate buffer for command iocb */ 279 geniocb = lpfc_sli_get_iocbq(phba); 280 281 if (geniocb == NULL) 282 return 1; 283 284 icmd = &geniocb->iocb; 285 icmd->un.genreq64.bdl.ulpIoTag32 = 0; 286 icmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys); 287 icmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys); 288 icmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64; 289 icmd->un.genreq64.bdl.bdeSize = (num_entry * sizeof (struct ulp_bde64)); 290 291 if (usr_flg) 292 geniocb->context3 = NULL; 293 else 294 geniocb->context3 = (uint8_t *) bmp; 295 296 /* Save for completion so we can release these resources */ 297 geniocb->context1 = (uint8_t *) inp; 298 geniocb->context2 = (uint8_t *) outp; 299 geniocb->context_un.ndlp = lpfc_nlp_get(ndlp); 300 301 /* Fill in payload, bp points to frame payload */ 302 icmd->ulpCommand = CMD_GEN_REQUEST64_CR; 303 304 /* Fill in rest of iocb */ 305 icmd->un.genreq64.w5.hcsw.Fctl = (SI | LA); 306 icmd->un.genreq64.w5.hcsw.Dfctl = 0; 307 icmd->un.genreq64.w5.hcsw.Rctl = FC_UNSOL_CTL; 308 icmd->un.genreq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP; 309 310 if (!tmo) { 311 /* FC spec states we need 3 * ratov for CT requests */ 312 tmo = (3 * phba->fc_ratov); 313 } 314 icmd->ulpTimeout = tmo; 315 icmd->ulpBdeCount = 1; 316 icmd->ulpLe = 1; 317 icmd->ulpClass = CLASS3; 318 icmd->ulpContext = ndlp->nlp_rpi; 319 320 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) { 321 /* For GEN_REQUEST64_CR, use the RPI */ 322 icmd->ulpCt_h = 0; 323 icmd->ulpCt_l = 0; 324 } 325 326 /* Issue GEN REQ IOCB for NPORT <did> */ 327 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, 328 "0119 Issue GEN REQ IOCB to NPORT x%x " 329 "Data: x%x x%x\n", 330 ndlp->nlp_DID, icmd->ulpIoTag, 331 vport->port_state); 332 geniocb->iocb_cmpl = cmpl; 333 geniocb->drvrTimeout = icmd->ulpTimeout + LPFC_DRVR_TIMEOUT; 334 geniocb->vport = vport; 335 geniocb->retry = retry; 336 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, geniocb, 0); 337 338 if (rc == IOCB_ERROR) { 339 lpfc_sli_release_iocbq(phba, geniocb); 340 return 1; 341 } 342 343 return 0; 344 } 345 346 static int 347 lpfc_ct_cmd(struct lpfc_vport *vport, struct lpfc_dmabuf *inmp, 348 struct lpfc_dmabuf *bmp, struct lpfc_nodelist *ndlp, 349 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 350 struct lpfc_iocbq *), 351 uint32_t rsp_size, uint8_t retry) 352 { 353 struct lpfc_hba *phba = vport->phba; 354 struct ulp_bde64 *bpl = (struct ulp_bde64 *) bmp->virt; 355 struct lpfc_dmabuf *outmp; 356 int cnt = 0, status; 357 int cmdcode = ((struct lpfc_sli_ct_request *) inmp->virt)-> 358 CommandResponse.bits.CmdRsp; 359 360 bpl++; /* Skip past ct request */ 361 362 /* Put buffer(s) for ct rsp in bpl */ 363 outmp = lpfc_alloc_ct_rsp(phba, cmdcode, bpl, rsp_size, &cnt); 364 if (!outmp) 365 return -ENOMEM; 366 367 status = lpfc_gen_req(vport, bmp, inmp, outmp, cmpl, ndlp, 0, 368 cnt+1, 0, retry); 369 if (status) { 370 lpfc_free_ct_rsp(phba, outmp); 371 return -ENOMEM; 372 } 373 return 0; 374 } 375 376 struct lpfc_vport * 377 lpfc_find_vport_by_did(struct lpfc_hba *phba, uint32_t did) { 378 struct lpfc_vport *vport_curr; 379 unsigned long flags; 380 381 spin_lock_irqsave(&phba->hbalock, flags); 382 list_for_each_entry(vport_curr, &phba->port_list, listentry) { 383 if ((vport_curr->fc_myDID) && (vport_curr->fc_myDID == did)) { 384 spin_unlock_irqrestore(&phba->hbalock, flags); 385 return vport_curr; 386 } 387 } 388 spin_unlock_irqrestore(&phba->hbalock, flags); 389 return NULL; 390 } 391 392 static int 393 lpfc_ns_rsp(struct lpfc_vport *vport, struct lpfc_dmabuf *mp, uint32_t Size) 394 { 395 struct lpfc_hba *phba = vport->phba; 396 struct lpfc_sli_ct_request *Response = 397 (struct lpfc_sli_ct_request *) mp->virt; 398 struct lpfc_nodelist *ndlp = NULL; 399 struct lpfc_dmabuf *mlast, *next_mp; 400 uint32_t *ctptr = (uint32_t *) & Response->un.gid.PortType; 401 uint32_t Did, CTentry; 402 int Cnt; 403 struct list_head head; 404 405 lpfc_set_disctmo(vport); 406 vport->num_disc_nodes = 0; 407 vport->fc_ns_retry = 0; 408 409 410 list_add_tail(&head, &mp->list); 411 list_for_each_entry_safe(mp, next_mp, &head, list) { 412 mlast = mp; 413 414 Cnt = Size > FCELSSIZE ? FCELSSIZE : Size; 415 416 Size -= Cnt; 417 418 if (!ctptr) { 419 ctptr = (uint32_t *) mlast->virt; 420 } else 421 Cnt -= 16; /* subtract length of CT header */ 422 423 /* Loop through entire NameServer list of DIDs */ 424 while (Cnt >= sizeof (uint32_t)) { 425 /* Get next DID from NameServer List */ 426 CTentry = *ctptr++; 427 Did = ((be32_to_cpu(CTentry)) & Mask_DID); 428 429 ndlp = NULL; 430 431 /* 432 * Check for rscn processing or not 433 * To conserve rpi's, filter out addresses for other 434 * vports on the same physical HBAs. 435 */ 436 if ((Did != vport->fc_myDID) && 437 ((lpfc_find_vport_by_did(phba, Did) == NULL) || 438 vport->cfg_peer_port_login)) { 439 if ((vport->port_type != LPFC_NPIV_PORT) || 440 (!(vport->ct_flags & FC_CT_RFF_ID)) || 441 (!vport->cfg_restrict_login)) { 442 ndlp = lpfc_setup_disc_node(vport, Did); 443 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) { 444 lpfc_debugfs_disc_trc(vport, 445 LPFC_DISC_TRC_CT, 446 "Parse GID_FTrsp: " 447 "did:x%x flg:x%x x%x", 448 Did, ndlp->nlp_flag, 449 vport->fc_flag); 450 451 lpfc_printf_vlog(vport, 452 KERN_INFO, 453 LOG_DISCOVERY, 454 "0238 Process " 455 "x%x NameServer Rsp" 456 "Data: x%x x%x x%x\n", 457 Did, ndlp->nlp_flag, 458 vport->fc_flag, 459 vport->fc_rscn_id_cnt); 460 } else { 461 lpfc_debugfs_disc_trc(vport, 462 LPFC_DISC_TRC_CT, 463 "Skip1 GID_FTrsp: " 464 "did:x%x flg:x%x cnt:%d", 465 Did, vport->fc_flag, 466 vport->fc_rscn_id_cnt); 467 468 lpfc_printf_vlog(vport, 469 KERN_INFO, 470 LOG_DISCOVERY, 471 "0239 Skip x%x " 472 "NameServer Rsp Data: " 473 "x%x x%x\n", 474 Did, vport->fc_flag, 475 vport->fc_rscn_id_cnt); 476 } 477 478 } else { 479 if (!(vport->fc_flag & FC_RSCN_MODE) || 480 (lpfc_rscn_payload_check(vport, Did))) { 481 lpfc_debugfs_disc_trc(vport, 482 LPFC_DISC_TRC_CT, 483 "Query GID_FTrsp: " 484 "did:x%x flg:x%x cnt:%d", 485 Did, vport->fc_flag, 486 vport->fc_rscn_id_cnt); 487 488 /* This NPortID was previously 489 * a FCP target, * Don't even 490 * bother to send GFF_ID. 491 */ 492 ndlp = lpfc_findnode_did(vport, 493 Did); 494 if (ndlp && 495 NLP_CHK_NODE_ACT(ndlp) 496 && (ndlp->nlp_type & 497 NLP_FCP_TARGET)) 498 lpfc_setup_disc_node 499 (vport, Did); 500 else if (lpfc_ns_cmd(vport, 501 SLI_CTNS_GFF_ID, 502 0, Did) == 0) 503 vport->num_disc_nodes++; 504 } 505 else { 506 lpfc_debugfs_disc_trc(vport, 507 LPFC_DISC_TRC_CT, 508 "Skip2 GID_FTrsp: " 509 "did:x%x flg:x%x cnt:%d", 510 Did, vport->fc_flag, 511 vport->fc_rscn_id_cnt); 512 513 lpfc_printf_vlog(vport, 514 KERN_INFO, 515 LOG_DISCOVERY, 516 "0245 Skip x%x " 517 "NameServer Rsp Data: " 518 "x%x x%x\n", 519 Did, vport->fc_flag, 520 vport->fc_rscn_id_cnt); 521 } 522 } 523 } 524 if (CTentry & (be32_to_cpu(SLI_CT_LAST_ENTRY))) 525 goto nsout1; 526 Cnt -= sizeof (uint32_t); 527 } 528 ctptr = NULL; 529 530 } 531 532 nsout1: 533 list_del(&head); 534 return 0; 535 } 536 537 static void 538 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 539 struct lpfc_iocbq *rspiocb) 540 { 541 struct lpfc_vport *vport = cmdiocb->vport; 542 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 543 IOCB_t *irsp; 544 struct lpfc_dmabuf *bmp; 545 struct lpfc_dmabuf *outp; 546 struct lpfc_sli_ct_request *CTrsp; 547 struct lpfc_nodelist *ndlp; 548 int rc; 549 550 /* First save ndlp, before we overwrite it */ 551 ndlp = cmdiocb->context_un.ndlp; 552 553 /* we pass cmdiocb to state machine which needs rspiocb as well */ 554 cmdiocb->context_un.rsp_iocb = rspiocb; 555 556 outp = (struct lpfc_dmabuf *) cmdiocb->context2; 557 bmp = (struct lpfc_dmabuf *) cmdiocb->context3; 558 irsp = &rspiocb->iocb; 559 560 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 561 "GID_FT cmpl: status:x%x/x%x rtry:%d", 562 irsp->ulpStatus, irsp->un.ulpWord[4], vport->fc_ns_retry); 563 564 /* Don't bother processing response if vport is being torn down. */ 565 if (vport->load_flag & FC_UNLOADING) { 566 if (vport->fc_flag & FC_RSCN_MODE) 567 lpfc_els_flush_rscn(vport); 568 goto out; 569 } 570 571 if (lpfc_els_chk_latt(vport)) { 572 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 573 "0216 Link event during NS query\n"); 574 if (vport->fc_flag & FC_RSCN_MODE) 575 lpfc_els_flush_rscn(vport); 576 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 577 goto out; 578 } 579 if (lpfc_error_lost_link(irsp)) { 580 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 581 "0226 NS query failed due to link event\n"); 582 if (vport->fc_flag & FC_RSCN_MODE) 583 lpfc_els_flush_rscn(vport); 584 goto out; 585 } 586 if (irsp->ulpStatus) { 587 /* Check for retry */ 588 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) { 589 if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT || 590 irsp->un.ulpWord[4] != IOERR_NO_RESOURCES) 591 vport->fc_ns_retry++; 592 593 /* CT command is being retried */ 594 rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT, 595 vport->fc_ns_retry, 0); 596 if (rc == 0) 597 goto out; 598 } 599 if (vport->fc_flag & FC_RSCN_MODE) 600 lpfc_els_flush_rscn(vport); 601 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 602 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 603 "0257 GID_FT Query error: 0x%x 0x%x\n", 604 irsp->ulpStatus, vport->fc_ns_retry); 605 } else { 606 /* Good status, continue checking */ 607 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 608 if (CTrsp->CommandResponse.bits.CmdRsp == 609 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) { 610 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 611 "0208 NameServer Rsp Data: x%x\n", 612 vport->fc_flag); 613 lpfc_ns_rsp(vport, outp, 614 (uint32_t) (irsp->un.genreq64.bdl.bdeSize)); 615 } else if (CTrsp->CommandResponse.bits.CmdRsp == 616 be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) { 617 /* NameServer Rsp Error */ 618 if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ) 619 && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) { 620 lpfc_printf_vlog(vport, KERN_INFO, 621 LOG_DISCOVERY, 622 "0269 No NameServer Entries " 623 "Data: x%x x%x x%x x%x\n", 624 CTrsp->CommandResponse.bits.CmdRsp, 625 (uint32_t) CTrsp->ReasonCode, 626 (uint32_t) CTrsp->Explanation, 627 vport->fc_flag); 628 629 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 630 "GID_FT no entry cmd:x%x rsn:x%x exp:x%x", 631 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp, 632 (uint32_t) CTrsp->ReasonCode, 633 (uint32_t) CTrsp->Explanation); 634 } else { 635 lpfc_printf_vlog(vport, KERN_INFO, 636 LOG_DISCOVERY, 637 "0240 NameServer Rsp Error " 638 "Data: x%x x%x x%x x%x\n", 639 CTrsp->CommandResponse.bits.CmdRsp, 640 (uint32_t) CTrsp->ReasonCode, 641 (uint32_t) CTrsp->Explanation, 642 vport->fc_flag); 643 644 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 645 "GID_FT rsp err1 cmd:x%x rsn:x%x exp:x%x", 646 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp, 647 (uint32_t) CTrsp->ReasonCode, 648 (uint32_t) CTrsp->Explanation); 649 } 650 651 652 } else { 653 /* NameServer Rsp Error */ 654 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 655 "0241 NameServer Rsp Error " 656 "Data: x%x x%x x%x x%x\n", 657 CTrsp->CommandResponse.bits.CmdRsp, 658 (uint32_t) CTrsp->ReasonCode, 659 (uint32_t) CTrsp->Explanation, 660 vport->fc_flag); 661 662 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 663 "GID_FT rsp err2 cmd:x%x rsn:x%x exp:x%x", 664 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp, 665 (uint32_t) CTrsp->ReasonCode, 666 (uint32_t) CTrsp->Explanation); 667 } 668 } 669 /* Link up / RSCN discovery */ 670 if (vport->num_disc_nodes == 0) { 671 /* 672 * The driver has cycled through all Nports in the RSCN payload. 673 * Complete the handling by cleaning up and marking the 674 * current driver state. 675 */ 676 if (vport->port_state >= LPFC_DISC_AUTH) { 677 if (vport->fc_flag & FC_RSCN_MODE) { 678 lpfc_els_flush_rscn(vport); 679 spin_lock_irq(shost->host_lock); 680 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */ 681 spin_unlock_irq(shost->host_lock); 682 } 683 else 684 lpfc_els_flush_rscn(vport); 685 } 686 687 lpfc_disc_start(vport); 688 } 689 out: 690 cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */ 691 lpfc_ct_free_iocb(phba, cmdiocb); 692 return; 693 } 694 695 static void 696 lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 697 struct lpfc_iocbq *rspiocb) 698 { 699 struct lpfc_vport *vport = cmdiocb->vport; 700 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 701 IOCB_t *irsp = &rspiocb->iocb; 702 struct lpfc_dmabuf *inp = (struct lpfc_dmabuf *) cmdiocb->context1; 703 struct lpfc_dmabuf *outp = (struct lpfc_dmabuf *) cmdiocb->context2; 704 struct lpfc_sli_ct_request *CTrsp; 705 int did, rc, retry; 706 uint8_t fbits; 707 struct lpfc_nodelist *ndlp; 708 709 did = ((struct lpfc_sli_ct_request *) inp->virt)->un.gff.PortId; 710 did = be32_to_cpu(did); 711 712 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 713 "GFF_ID cmpl: status:x%x/x%x did:x%x", 714 irsp->ulpStatus, irsp->un.ulpWord[4], did); 715 716 if (irsp->ulpStatus == IOSTAT_SUCCESS) { 717 /* Good status, continue checking */ 718 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 719 fbits = CTrsp->un.gff_acc.fbits[FCP_TYPE_FEATURE_OFFSET]; 720 721 if (CTrsp->CommandResponse.bits.CmdRsp == 722 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) { 723 if ((fbits & FC4_FEATURE_INIT) && 724 !(fbits & FC4_FEATURE_TARGET)) { 725 lpfc_printf_vlog(vport, KERN_INFO, 726 LOG_DISCOVERY, 727 "0270 Skip x%x GFF " 728 "NameServer Rsp Data: (init) " 729 "x%x x%x\n", did, fbits, 730 vport->fc_rscn_id_cnt); 731 goto out; 732 } 733 } 734 } 735 else { 736 /* Check for retry */ 737 if (cmdiocb->retry < LPFC_MAX_NS_RETRY) { 738 retry = 1; 739 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) { 740 switch (irsp->un.ulpWord[4]) { 741 case IOERR_NO_RESOURCES: 742 /* We don't increment the retry 743 * count for this case. 744 */ 745 break; 746 case IOERR_LINK_DOWN: 747 case IOERR_SLI_ABORTED: 748 case IOERR_SLI_DOWN: 749 retry = 0; 750 break; 751 default: 752 cmdiocb->retry++; 753 } 754 } 755 else 756 cmdiocb->retry++; 757 758 if (retry) { 759 /* CT command is being retried */ 760 rc = lpfc_ns_cmd(vport, SLI_CTNS_GFF_ID, 761 cmdiocb->retry, did); 762 if (rc == 0) { 763 /* success */ 764 lpfc_ct_free_iocb(phba, cmdiocb); 765 return; 766 } 767 } 768 } 769 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 770 "0267 NameServer GFF Rsp " 771 "x%x Error (%d %d) Data: x%x x%x\n", 772 did, irsp->ulpStatus, irsp->un.ulpWord[4], 773 vport->fc_flag, vport->fc_rscn_id_cnt); 774 } 775 776 /* This is a target port, unregistered port, or the GFF_ID failed */ 777 ndlp = lpfc_setup_disc_node(vport, did); 778 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) { 779 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 780 "0242 Process x%x GFF " 781 "NameServer Rsp Data: x%x x%x x%x\n", 782 did, ndlp->nlp_flag, vport->fc_flag, 783 vport->fc_rscn_id_cnt); 784 } else { 785 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 786 "0243 Skip x%x GFF " 787 "NameServer Rsp Data: x%x x%x\n", did, 788 vport->fc_flag, vport->fc_rscn_id_cnt); 789 } 790 out: 791 /* Link up / RSCN discovery */ 792 if (vport->num_disc_nodes) 793 vport->num_disc_nodes--; 794 if (vport->num_disc_nodes == 0) { 795 /* 796 * The driver has cycled through all Nports in the RSCN payload. 797 * Complete the handling by cleaning up and marking the 798 * current driver state. 799 */ 800 if (vport->port_state >= LPFC_DISC_AUTH) { 801 if (vport->fc_flag & FC_RSCN_MODE) { 802 lpfc_els_flush_rscn(vport); 803 spin_lock_irq(shost->host_lock); 804 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */ 805 spin_unlock_irq(shost->host_lock); 806 } 807 else 808 lpfc_els_flush_rscn(vport); 809 } 810 lpfc_disc_start(vport); 811 } 812 lpfc_ct_free_iocb(phba, cmdiocb); 813 return; 814 } 815 816 817 static void 818 lpfc_cmpl_ct(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 819 struct lpfc_iocbq *rspiocb) 820 { 821 struct lpfc_vport *vport = cmdiocb->vport; 822 struct lpfc_dmabuf *inp; 823 struct lpfc_dmabuf *outp; 824 IOCB_t *irsp; 825 struct lpfc_sli_ct_request *CTrsp; 826 struct lpfc_nodelist *ndlp; 827 int cmdcode, rc; 828 uint8_t retry; 829 uint32_t latt; 830 831 /* First save ndlp, before we overwrite it */ 832 ndlp = cmdiocb->context_un.ndlp; 833 834 /* we pass cmdiocb to state machine which needs rspiocb as well */ 835 cmdiocb->context_un.rsp_iocb = rspiocb; 836 837 inp = (struct lpfc_dmabuf *) cmdiocb->context1; 838 outp = (struct lpfc_dmabuf *) cmdiocb->context2; 839 irsp = &rspiocb->iocb; 840 841 cmdcode = be16_to_cpu(((struct lpfc_sli_ct_request *) inp->virt)-> 842 CommandResponse.bits.CmdRsp); 843 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 844 845 latt = lpfc_els_chk_latt(vport); 846 847 /* RFT request completes status <ulpStatus> CmdRsp <CmdRsp> */ 848 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 849 "0209 CT Request completes, latt %d, " 850 "ulpStatus x%x CmdRsp x%x, Context x%x, Tag x%x\n", 851 latt, irsp->ulpStatus, 852 CTrsp->CommandResponse.bits.CmdRsp, 853 cmdiocb->iocb.ulpContext, cmdiocb->iocb.ulpIoTag); 854 855 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 856 "CT cmd cmpl: status:x%x/x%x cmd:x%x", 857 irsp->ulpStatus, irsp->un.ulpWord[4], cmdcode); 858 859 if (irsp->ulpStatus) { 860 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 861 "0268 NS cmd %x Error (%d %d)\n", 862 cmdcode, irsp->ulpStatus, irsp->un.ulpWord[4]); 863 864 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && 865 ((irsp->un.ulpWord[4] == IOERR_SLI_DOWN) || 866 (irsp->un.ulpWord[4] == IOERR_SLI_ABORTED))) 867 goto out; 868 869 retry = cmdiocb->retry; 870 if (retry >= LPFC_MAX_NS_RETRY) 871 goto out; 872 873 retry++; 874 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 875 "0250 Retrying NS cmd %x\n", cmdcode); 876 rc = lpfc_ns_cmd(vport, cmdcode, retry, 0); 877 if (rc == 0) 878 goto out; 879 } 880 881 out: 882 cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */ 883 lpfc_ct_free_iocb(phba, cmdiocb); 884 return; 885 } 886 887 static void 888 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 889 struct lpfc_iocbq *rspiocb) 890 { 891 IOCB_t *irsp = &rspiocb->iocb; 892 struct lpfc_vport *vport = cmdiocb->vport; 893 894 if (irsp->ulpStatus == IOSTAT_SUCCESS) { 895 struct lpfc_dmabuf *outp; 896 struct lpfc_sli_ct_request *CTrsp; 897 898 outp = (struct lpfc_dmabuf *) cmdiocb->context2; 899 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 900 if (CTrsp->CommandResponse.bits.CmdRsp == 901 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 902 vport->ct_flags |= FC_CT_RFT_ID; 903 } 904 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 905 return; 906 } 907 908 static void 909 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 910 struct lpfc_iocbq *rspiocb) 911 { 912 IOCB_t *irsp = &rspiocb->iocb; 913 struct lpfc_vport *vport = cmdiocb->vport; 914 915 if (irsp->ulpStatus == IOSTAT_SUCCESS) { 916 struct lpfc_dmabuf *outp; 917 struct lpfc_sli_ct_request *CTrsp; 918 919 outp = (struct lpfc_dmabuf *) cmdiocb->context2; 920 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 921 if (CTrsp->CommandResponse.bits.CmdRsp == 922 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 923 vport->ct_flags |= FC_CT_RNN_ID; 924 } 925 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 926 return; 927 } 928 929 static void 930 lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 931 struct lpfc_iocbq *rspiocb) 932 { 933 IOCB_t *irsp = &rspiocb->iocb; 934 struct lpfc_vport *vport = cmdiocb->vport; 935 936 if (irsp->ulpStatus == IOSTAT_SUCCESS) { 937 struct lpfc_dmabuf *outp; 938 struct lpfc_sli_ct_request *CTrsp; 939 940 outp = (struct lpfc_dmabuf *) cmdiocb->context2; 941 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 942 if (CTrsp->CommandResponse.bits.CmdRsp == 943 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 944 vport->ct_flags |= FC_CT_RSPN_ID; 945 } 946 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 947 return; 948 } 949 950 static void 951 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 952 struct lpfc_iocbq *rspiocb) 953 { 954 IOCB_t *irsp = &rspiocb->iocb; 955 struct lpfc_vport *vport = cmdiocb->vport; 956 957 if (irsp->ulpStatus == IOSTAT_SUCCESS) { 958 struct lpfc_dmabuf *outp; 959 struct lpfc_sli_ct_request *CTrsp; 960 961 outp = (struct lpfc_dmabuf *) cmdiocb->context2; 962 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 963 if (CTrsp->CommandResponse.bits.CmdRsp == 964 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 965 vport->ct_flags |= FC_CT_RSNN_NN; 966 } 967 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 968 return; 969 } 970 971 static void 972 lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 973 struct lpfc_iocbq *rspiocb) 974 { 975 struct lpfc_vport *vport = cmdiocb->vport; 976 977 /* even if it fails we will act as though it succeeded. */ 978 vport->ct_flags = 0; 979 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 980 return; 981 } 982 983 static void 984 lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 985 struct lpfc_iocbq *rspiocb) 986 { 987 IOCB_t *irsp = &rspiocb->iocb; 988 struct lpfc_vport *vport = cmdiocb->vport; 989 990 if (irsp->ulpStatus == IOSTAT_SUCCESS) { 991 struct lpfc_dmabuf *outp; 992 struct lpfc_sli_ct_request *CTrsp; 993 994 outp = (struct lpfc_dmabuf *) cmdiocb->context2; 995 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 996 if (CTrsp->CommandResponse.bits.CmdRsp == 997 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) 998 vport->ct_flags |= FC_CT_RFF_ID; 999 } 1000 lpfc_cmpl_ct(phba, cmdiocb, rspiocb); 1001 return; 1002 } 1003 1004 int 1005 lpfc_vport_symbolic_port_name(struct lpfc_vport *vport, char *symbol, 1006 size_t size) 1007 { 1008 int n; 1009 uint8_t *wwn = vport->phba->wwpn; 1010 1011 n = snprintf(symbol, size, 1012 "Emulex PPN-%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", 1013 wwn[0], wwn[1], wwn[2], wwn[3], 1014 wwn[4], wwn[5], wwn[6], wwn[7]); 1015 1016 if (vport->port_type == LPFC_PHYSICAL_PORT) 1017 return n; 1018 1019 if (n < size) 1020 n += snprintf(symbol + n, size - n, " VPort-%d", vport->vpi); 1021 1022 if (n < size && 1023 strlen(vport->fc_vport->symbolic_name)) 1024 n += snprintf(symbol + n, size - n, " VName-%s", 1025 vport->fc_vport->symbolic_name); 1026 return n; 1027 } 1028 1029 int 1030 lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol, 1031 size_t size) 1032 { 1033 char fwrev[16]; 1034 int n; 1035 1036 lpfc_decode_firmware_rev(vport->phba, fwrev, 0); 1037 1038 n = snprintf(symbol, size, "Emulex %s FV%s DV%s", 1039 vport->phba->ModelName, fwrev, lpfc_release_version); 1040 return n; 1041 } 1042 1043 /* 1044 * lpfc_ns_cmd 1045 * Description: 1046 * Issue Cmd to NameServer 1047 * SLI_CTNS_GID_FT 1048 * LI_CTNS_RFT_ID 1049 */ 1050 int 1051 lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode, 1052 uint8_t retry, uint32_t context) 1053 { 1054 struct lpfc_nodelist * ndlp; 1055 struct lpfc_hba *phba = vport->phba; 1056 struct lpfc_dmabuf *mp, *bmp; 1057 struct lpfc_sli_ct_request *CtReq; 1058 struct ulp_bde64 *bpl; 1059 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 1060 struct lpfc_iocbq *) = NULL; 1061 uint32_t rsp_size = 1024; 1062 size_t size; 1063 int rc = 0; 1064 1065 ndlp = lpfc_findnode_did(vport, NameServer_DID); 1066 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) 1067 || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) { 1068 rc=1; 1069 goto ns_cmd_exit; 1070 } 1071 1072 /* fill in BDEs for command */ 1073 /* Allocate buffer for command payload */ 1074 mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 1075 if (!mp) { 1076 rc=2; 1077 goto ns_cmd_exit; 1078 } 1079 1080 INIT_LIST_HEAD(&mp->list); 1081 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys)); 1082 if (!mp->virt) { 1083 rc=3; 1084 goto ns_cmd_free_mp; 1085 } 1086 1087 /* Allocate buffer for Buffer ptr list */ 1088 bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 1089 if (!bmp) { 1090 rc=4; 1091 goto ns_cmd_free_mpvirt; 1092 } 1093 1094 INIT_LIST_HEAD(&bmp->list); 1095 bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys)); 1096 if (!bmp->virt) { 1097 rc=5; 1098 goto ns_cmd_free_bmp; 1099 } 1100 1101 /* NameServer Req */ 1102 lpfc_printf_vlog(vport, KERN_INFO ,LOG_DISCOVERY, 1103 "0236 NameServer Req Data: x%x x%x x%x\n", 1104 cmdcode, vport->fc_flag, vport->fc_rscn_id_cnt); 1105 1106 bpl = (struct ulp_bde64 *) bmp->virt; 1107 memset(bpl, 0, sizeof(struct ulp_bde64)); 1108 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) ); 1109 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) ); 1110 bpl->tus.f.bdeFlags = 0; 1111 if (cmdcode == SLI_CTNS_GID_FT) 1112 bpl->tus.f.bdeSize = GID_REQUEST_SZ; 1113 else if (cmdcode == SLI_CTNS_GFF_ID) 1114 bpl->tus.f.bdeSize = GFF_REQUEST_SZ; 1115 else if (cmdcode == SLI_CTNS_RFT_ID) 1116 bpl->tus.f.bdeSize = RFT_REQUEST_SZ; 1117 else if (cmdcode == SLI_CTNS_RNN_ID) 1118 bpl->tus.f.bdeSize = RNN_REQUEST_SZ; 1119 else if (cmdcode == SLI_CTNS_RSPN_ID) 1120 bpl->tus.f.bdeSize = RSPN_REQUEST_SZ; 1121 else if (cmdcode == SLI_CTNS_RSNN_NN) 1122 bpl->tus.f.bdeSize = RSNN_REQUEST_SZ; 1123 else if (cmdcode == SLI_CTNS_DA_ID) 1124 bpl->tus.f.bdeSize = DA_ID_REQUEST_SZ; 1125 else if (cmdcode == SLI_CTNS_RFF_ID) 1126 bpl->tus.f.bdeSize = RFF_REQUEST_SZ; 1127 else 1128 bpl->tus.f.bdeSize = 0; 1129 bpl->tus.w = le32_to_cpu(bpl->tus.w); 1130 1131 CtReq = (struct lpfc_sli_ct_request *) mp->virt; 1132 memset(CtReq, 0, sizeof (struct lpfc_sli_ct_request)); 1133 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION; 1134 CtReq->RevisionId.bits.InId = 0; 1135 CtReq->FsType = SLI_CT_DIRECTORY_SERVICE; 1136 CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER; 1137 CtReq->CommandResponse.bits.Size = 0; 1138 switch (cmdcode) { 1139 case SLI_CTNS_GID_FT: 1140 CtReq->CommandResponse.bits.CmdRsp = 1141 be16_to_cpu(SLI_CTNS_GID_FT); 1142 CtReq->un.gid.Fc4Type = SLI_CTPT_FCP; 1143 if (vport->port_state < LPFC_NS_QRY) 1144 vport->port_state = LPFC_NS_QRY; 1145 lpfc_set_disctmo(vport); 1146 cmpl = lpfc_cmpl_ct_cmd_gid_ft; 1147 rsp_size = FC_MAX_NS_RSP; 1148 break; 1149 1150 case SLI_CTNS_GFF_ID: 1151 CtReq->CommandResponse.bits.CmdRsp = 1152 be16_to_cpu(SLI_CTNS_GFF_ID); 1153 CtReq->un.gff.PortId = cpu_to_be32(context); 1154 cmpl = lpfc_cmpl_ct_cmd_gff_id; 1155 break; 1156 1157 case SLI_CTNS_RFT_ID: 1158 vport->ct_flags &= ~FC_CT_RFT_ID; 1159 CtReq->CommandResponse.bits.CmdRsp = 1160 be16_to_cpu(SLI_CTNS_RFT_ID); 1161 CtReq->un.rft.PortId = cpu_to_be32(vport->fc_myDID); 1162 CtReq->un.rft.fcpReg = 1; 1163 cmpl = lpfc_cmpl_ct_cmd_rft_id; 1164 break; 1165 1166 case SLI_CTNS_RNN_ID: 1167 vport->ct_flags &= ~FC_CT_RNN_ID; 1168 CtReq->CommandResponse.bits.CmdRsp = 1169 be16_to_cpu(SLI_CTNS_RNN_ID); 1170 CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID); 1171 memcpy(CtReq->un.rnn.wwnn, &vport->fc_nodename, 1172 sizeof (struct lpfc_name)); 1173 cmpl = lpfc_cmpl_ct_cmd_rnn_id; 1174 break; 1175 1176 case SLI_CTNS_RSPN_ID: 1177 vport->ct_flags &= ~FC_CT_RSPN_ID; 1178 CtReq->CommandResponse.bits.CmdRsp = 1179 be16_to_cpu(SLI_CTNS_RSPN_ID); 1180 CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID); 1181 size = sizeof(CtReq->un.rspn.symbname); 1182 CtReq->un.rspn.len = 1183 lpfc_vport_symbolic_port_name(vport, 1184 CtReq->un.rspn.symbname, size); 1185 cmpl = lpfc_cmpl_ct_cmd_rspn_id; 1186 break; 1187 case SLI_CTNS_RSNN_NN: 1188 vport->ct_flags &= ~FC_CT_RSNN_NN; 1189 CtReq->CommandResponse.bits.CmdRsp = 1190 be16_to_cpu(SLI_CTNS_RSNN_NN); 1191 memcpy(CtReq->un.rsnn.wwnn, &vport->fc_nodename, 1192 sizeof (struct lpfc_name)); 1193 size = sizeof(CtReq->un.rsnn.symbname); 1194 CtReq->un.rsnn.len = 1195 lpfc_vport_symbolic_node_name(vport, 1196 CtReq->un.rsnn.symbname, size); 1197 cmpl = lpfc_cmpl_ct_cmd_rsnn_nn; 1198 break; 1199 case SLI_CTNS_DA_ID: 1200 /* Implement DA_ID Nameserver request */ 1201 CtReq->CommandResponse.bits.CmdRsp = 1202 be16_to_cpu(SLI_CTNS_DA_ID); 1203 CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID); 1204 cmpl = lpfc_cmpl_ct_cmd_da_id; 1205 break; 1206 case SLI_CTNS_RFF_ID: 1207 vport->ct_flags &= ~FC_CT_RFF_ID; 1208 CtReq->CommandResponse.bits.CmdRsp = 1209 be16_to_cpu(SLI_CTNS_RFF_ID); 1210 CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID); 1211 CtReq->un.rff.fbits = FC4_FEATURE_INIT; 1212 CtReq->un.rff.type_code = FC_FCP_DATA; 1213 cmpl = lpfc_cmpl_ct_cmd_rff_id; 1214 break; 1215 } 1216 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count 1217 * to hold ndlp reference for the corresponding callback function. 1218 */ 1219 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) { 1220 /* On success, The cmpl function will free the buffers */ 1221 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 1222 "Issue CT cmd: cmd:x%x did:x%x", 1223 cmdcode, ndlp->nlp_DID, 0); 1224 return 0; 1225 } 1226 rc=6; 1227 1228 /* Decrement ndlp reference count to release ndlp reference held 1229 * for the failed command's callback function. 1230 */ 1231 lpfc_nlp_put(ndlp); 1232 1233 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 1234 ns_cmd_free_bmp: 1235 kfree(bmp); 1236 ns_cmd_free_mpvirt: 1237 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1238 ns_cmd_free_mp: 1239 kfree(mp); 1240 ns_cmd_exit: 1241 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 1242 "0266 Issue NameServer Req x%x err %d Data: x%x x%x\n", 1243 cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt); 1244 return 1; 1245 } 1246 1247 static void 1248 lpfc_cmpl_ct_cmd_fdmi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1249 struct lpfc_iocbq * rspiocb) 1250 { 1251 struct lpfc_dmabuf *inp = cmdiocb->context1; 1252 struct lpfc_dmabuf *outp = cmdiocb->context2; 1253 struct lpfc_sli_ct_request *CTrsp = outp->virt; 1254 struct lpfc_sli_ct_request *CTcmd = inp->virt; 1255 struct lpfc_nodelist *ndlp; 1256 uint16_t fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp; 1257 uint16_t fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp; 1258 struct lpfc_vport *vport = cmdiocb->vport; 1259 IOCB_t *irsp = &rspiocb->iocb; 1260 uint32_t latt; 1261 1262 latt = lpfc_els_chk_latt(vport); 1263 1264 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT, 1265 "FDMI cmpl: status:x%x/x%x latt:%d", 1266 irsp->ulpStatus, irsp->un.ulpWord[4], latt); 1267 1268 if (latt || irsp->ulpStatus) { 1269 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1270 "0229 FDMI cmd %04x failed, latt = %d " 1271 "ulpStatus: x%x, rid x%x\n", 1272 be16_to_cpu(fdmi_cmd), latt, irsp->ulpStatus, 1273 irsp->un.ulpWord[4]); 1274 lpfc_ct_free_iocb(phba, cmdiocb); 1275 return; 1276 } 1277 1278 ndlp = lpfc_findnode_did(vport, FDMI_DID); 1279 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) 1280 goto fail_out; 1281 1282 if (fdmi_rsp == be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) { 1283 /* FDMI rsp failed */ 1284 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1285 "0220 FDMI rsp failed Data: x%x\n", 1286 be16_to_cpu(fdmi_cmd)); 1287 } 1288 1289 switch (be16_to_cpu(fdmi_cmd)) { 1290 case SLI_MGMT_RHBA: 1291 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA); 1292 break; 1293 1294 case SLI_MGMT_RPA: 1295 break; 1296 1297 case SLI_MGMT_DHBA: 1298 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT); 1299 break; 1300 1301 case SLI_MGMT_DPRT: 1302 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RHBA); 1303 break; 1304 } 1305 1306 fail_out: 1307 lpfc_ct_free_iocb(phba, cmdiocb); 1308 return; 1309 } 1310 1311 int 1312 lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, int cmdcode) 1313 { 1314 struct lpfc_hba *phba = vport->phba; 1315 struct lpfc_dmabuf *mp, *bmp; 1316 struct lpfc_sli_ct_request *CtReq; 1317 struct ulp_bde64 *bpl; 1318 uint32_t size; 1319 REG_HBA *rh; 1320 PORT_ENTRY *pe; 1321 REG_PORT_ATTRIBUTE *pab; 1322 ATTRIBUTE_BLOCK *ab; 1323 ATTRIBUTE_ENTRY *ae; 1324 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 1325 struct lpfc_iocbq *); 1326 1327 1328 /* fill in BDEs for command */ 1329 /* Allocate buffer for command payload */ 1330 mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 1331 if (!mp) 1332 goto fdmi_cmd_exit; 1333 1334 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys)); 1335 if (!mp->virt) 1336 goto fdmi_cmd_free_mp; 1337 1338 /* Allocate buffer for Buffer ptr list */ 1339 bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 1340 if (!bmp) 1341 goto fdmi_cmd_free_mpvirt; 1342 1343 bmp->virt = lpfc_mbuf_alloc(phba, 0, &(bmp->phys)); 1344 if (!bmp->virt) 1345 goto fdmi_cmd_free_bmp; 1346 1347 INIT_LIST_HEAD(&mp->list); 1348 INIT_LIST_HEAD(&bmp->list); 1349 1350 /* FDMI request */ 1351 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1352 "0218 FDMI Request Data: x%x x%x x%x\n", 1353 vport->fc_flag, vport->port_state, cmdcode); 1354 CtReq = (struct lpfc_sli_ct_request *) mp->virt; 1355 1356 memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request)); 1357 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION; 1358 CtReq->RevisionId.bits.InId = 0; 1359 1360 CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE; 1361 CtReq->FsSubType = SLI_CT_FDMI_Subtypes; 1362 size = 0; 1363 1364 switch (cmdcode) { 1365 case SLI_MGMT_RHBA: 1366 { 1367 lpfc_vpd_t *vp = &phba->vpd; 1368 uint32_t i, j, incr; 1369 int len; 1370 1371 CtReq->CommandResponse.bits.CmdRsp = 1372 be16_to_cpu(SLI_MGMT_RHBA); 1373 CtReq->CommandResponse.bits.Size = 0; 1374 rh = (REG_HBA *) & CtReq->un.PortID; 1375 memcpy(&rh->hi.PortName, &vport->fc_sparam.portName, 1376 sizeof (struct lpfc_name)); 1377 /* One entry (port) per adapter */ 1378 rh->rpl.EntryCnt = be32_to_cpu(1); 1379 memcpy(&rh->rpl.pe, &vport->fc_sparam.portName, 1380 sizeof (struct lpfc_name)); 1381 1382 /* point to the HBA attribute block */ 1383 size = 2 * sizeof (struct lpfc_name) + FOURBYTES; 1384 ab = (ATTRIBUTE_BLOCK *) ((uint8_t *) rh + size); 1385 ab->EntryCnt = 0; 1386 1387 /* Point to the beginning of the first HBA attribute 1388 entry */ 1389 /* #1 HBA attribute entry */ 1390 size += FOURBYTES; 1391 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1392 ae->ad.bits.AttrType = be16_to_cpu(NODE_NAME); 1393 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES 1394 + sizeof (struct lpfc_name)); 1395 memcpy(&ae->un.NodeName, &vport->fc_sparam.nodeName, 1396 sizeof (struct lpfc_name)); 1397 ab->EntryCnt++; 1398 size += FOURBYTES + sizeof (struct lpfc_name); 1399 1400 /* #2 HBA attribute entry */ 1401 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1402 ae->ad.bits.AttrType = be16_to_cpu(MANUFACTURER); 1403 strcpy(ae->un.Manufacturer, "Emulex Corporation"); 1404 len = strlen(ae->un.Manufacturer); 1405 len += (len & 3) ? (4 - (len & 3)) : 4; 1406 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1407 ab->EntryCnt++; 1408 size += FOURBYTES + len; 1409 1410 /* #3 HBA attribute entry */ 1411 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1412 ae->ad.bits.AttrType = be16_to_cpu(SERIAL_NUMBER); 1413 strcpy(ae->un.SerialNumber, phba->SerialNumber); 1414 len = strlen(ae->un.SerialNumber); 1415 len += (len & 3) ? (4 - (len & 3)) : 4; 1416 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1417 ab->EntryCnt++; 1418 size += FOURBYTES + len; 1419 1420 /* #4 HBA attribute entry */ 1421 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1422 ae->ad.bits.AttrType = be16_to_cpu(MODEL); 1423 strcpy(ae->un.Model, phba->ModelName); 1424 len = strlen(ae->un.Model); 1425 len += (len & 3) ? (4 - (len & 3)) : 4; 1426 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1427 ab->EntryCnt++; 1428 size += FOURBYTES + len; 1429 1430 /* #5 HBA attribute entry */ 1431 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1432 ae->ad.bits.AttrType = be16_to_cpu(MODEL_DESCRIPTION); 1433 strcpy(ae->un.ModelDescription, phba->ModelDesc); 1434 len = strlen(ae->un.ModelDescription); 1435 len += (len & 3) ? (4 - (len & 3)) : 4; 1436 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1437 ab->EntryCnt++; 1438 size += FOURBYTES + len; 1439 1440 /* #6 HBA attribute entry */ 1441 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1442 ae->ad.bits.AttrType = be16_to_cpu(HARDWARE_VERSION); 1443 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 8); 1444 /* Convert JEDEC ID to ascii for hardware version */ 1445 incr = vp->rev.biuRev; 1446 for (i = 0; i < 8; i++) { 1447 j = (incr & 0xf); 1448 if (j <= 9) 1449 ae->un.HardwareVersion[7 - i] = 1450 (char)((uint8_t) 0x30 + 1451 (uint8_t) j); 1452 else 1453 ae->un.HardwareVersion[7 - i] = 1454 (char)((uint8_t) 0x61 + 1455 (uint8_t) (j - 10)); 1456 incr = (incr >> 4); 1457 } 1458 ab->EntryCnt++; 1459 size += FOURBYTES + 8; 1460 1461 /* #7 HBA attribute entry */ 1462 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1463 ae->ad.bits.AttrType = be16_to_cpu(DRIVER_VERSION); 1464 strcpy(ae->un.DriverVersion, lpfc_release_version); 1465 len = strlen(ae->un.DriverVersion); 1466 len += (len & 3) ? (4 - (len & 3)) : 4; 1467 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1468 ab->EntryCnt++; 1469 size += FOURBYTES + len; 1470 1471 /* #8 HBA attribute entry */ 1472 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1473 ae->ad.bits.AttrType = be16_to_cpu(OPTION_ROM_VERSION); 1474 strcpy(ae->un.OptionROMVersion, phba->OptionROMVersion); 1475 len = strlen(ae->un.OptionROMVersion); 1476 len += (len & 3) ? (4 - (len & 3)) : 4; 1477 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1478 ab->EntryCnt++; 1479 size += FOURBYTES + len; 1480 1481 /* #9 HBA attribute entry */ 1482 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1483 ae->ad.bits.AttrType = be16_to_cpu(FIRMWARE_VERSION); 1484 lpfc_decode_firmware_rev(phba, ae->un.FirmwareVersion, 1485 1); 1486 len = strlen(ae->un.FirmwareVersion); 1487 len += (len & 3) ? (4 - (len & 3)) : 4; 1488 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1489 ab->EntryCnt++; 1490 size += FOURBYTES + len; 1491 1492 /* #10 HBA attribute entry */ 1493 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1494 ae->ad.bits.AttrType = be16_to_cpu(OS_NAME_VERSION); 1495 sprintf(ae->un.OsNameVersion, "%s %s %s", 1496 init_utsname()->sysname, 1497 init_utsname()->release, 1498 init_utsname()->version); 1499 len = strlen(ae->un.OsNameVersion); 1500 len += (len & 3) ? (4 - (len & 3)) : 4; 1501 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1502 ab->EntryCnt++; 1503 size += FOURBYTES + len; 1504 1505 /* #11 HBA attribute entry */ 1506 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 1507 ae->ad.bits.AttrType = be16_to_cpu(MAX_CT_PAYLOAD_LEN); 1508 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4); 1509 ae->un.MaxCTPayloadLen = (65 * 4096); 1510 ab->EntryCnt++; 1511 size += FOURBYTES + 4; 1512 1513 ab->EntryCnt = be32_to_cpu(ab->EntryCnt); 1514 /* Total size */ 1515 size = GID_REQUEST_SZ - 4 + size; 1516 } 1517 break; 1518 1519 case SLI_MGMT_RPA: 1520 { 1521 lpfc_vpd_t *vp; 1522 struct serv_parm *hsp; 1523 int len; 1524 1525 vp = &phba->vpd; 1526 1527 CtReq->CommandResponse.bits.CmdRsp = 1528 be16_to_cpu(SLI_MGMT_RPA); 1529 CtReq->CommandResponse.bits.Size = 0; 1530 pab = (REG_PORT_ATTRIBUTE *) & CtReq->un.PortID; 1531 size = sizeof (struct lpfc_name) + FOURBYTES; 1532 memcpy((uint8_t *) & pab->PortName, 1533 (uint8_t *) & vport->fc_sparam.portName, 1534 sizeof (struct lpfc_name)); 1535 pab->ab.EntryCnt = 0; 1536 1537 /* #1 Port attribute entry */ 1538 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 1539 ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_FC4_TYPES); 1540 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 32); 1541 ae->un.SupportFC4Types[2] = 1; 1542 ae->un.SupportFC4Types[7] = 1; 1543 pab->ab.EntryCnt++; 1544 size += FOURBYTES + 32; 1545 1546 /* #2 Port attribute entry */ 1547 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 1548 ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_SPEED); 1549 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4); 1550 1551 ae->un.SupportSpeed = 0; 1552 if (phba->lmt & LMT_10Gb) 1553 ae->un.SupportSpeed = HBA_PORTSPEED_10GBIT; 1554 if (phba->lmt & LMT_8Gb) 1555 ae->un.SupportSpeed |= HBA_PORTSPEED_8GBIT; 1556 if (phba->lmt & LMT_4Gb) 1557 ae->un.SupportSpeed |= HBA_PORTSPEED_4GBIT; 1558 if (phba->lmt & LMT_2Gb) 1559 ae->un.SupportSpeed |= HBA_PORTSPEED_2GBIT; 1560 if (phba->lmt & LMT_1Gb) 1561 ae->un.SupportSpeed |= HBA_PORTSPEED_1GBIT; 1562 1563 pab->ab.EntryCnt++; 1564 size += FOURBYTES + 4; 1565 1566 /* #3 Port attribute entry */ 1567 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 1568 ae->ad.bits.AttrType = be16_to_cpu(PORT_SPEED); 1569 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4); 1570 switch(phba->fc_linkspeed) { 1571 case LA_1GHZ_LINK: 1572 ae->un.PortSpeed = HBA_PORTSPEED_1GBIT; 1573 break; 1574 case LA_2GHZ_LINK: 1575 ae->un.PortSpeed = HBA_PORTSPEED_2GBIT; 1576 break; 1577 case LA_4GHZ_LINK: 1578 ae->un.PortSpeed = HBA_PORTSPEED_4GBIT; 1579 break; 1580 case LA_8GHZ_LINK: 1581 ae->un.PortSpeed = HBA_PORTSPEED_8GBIT; 1582 break; 1583 case LA_10GHZ_LINK: 1584 ae->un.PortSpeed = HBA_PORTSPEED_10GBIT; 1585 break; 1586 default: 1587 ae->un.PortSpeed = 1588 HBA_PORTSPEED_UNKNOWN; 1589 break; 1590 } 1591 pab->ab.EntryCnt++; 1592 size += FOURBYTES + 4; 1593 1594 /* #4 Port attribute entry */ 1595 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 1596 ae->ad.bits.AttrType = be16_to_cpu(MAX_FRAME_SIZE); 1597 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4); 1598 hsp = (struct serv_parm *) & vport->fc_sparam; 1599 ae->un.MaxFrameSize = 1600 (((uint32_t) hsp->cmn. 1601 bbRcvSizeMsb) << 8) | (uint32_t) hsp->cmn. 1602 bbRcvSizeLsb; 1603 pab->ab.EntryCnt++; 1604 size += FOURBYTES + 4; 1605 1606 /* #5 Port attribute entry */ 1607 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 1608 ae->ad.bits.AttrType = be16_to_cpu(OS_DEVICE_NAME); 1609 strcpy((char *)ae->un.OsDeviceName, LPFC_DRIVER_NAME); 1610 len = strlen((char *)ae->un.OsDeviceName); 1611 len += (len & 3) ? (4 - (len & 3)) : 4; 1612 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1613 pab->ab.EntryCnt++; 1614 size += FOURBYTES + len; 1615 1616 if (vport->cfg_fdmi_on == 2) { 1617 /* #6 Port attribute entry */ 1618 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + 1619 size); 1620 ae->ad.bits.AttrType = be16_to_cpu(HOST_NAME); 1621 sprintf(ae->un.HostName, "%s", 1622 init_utsname()->nodename); 1623 len = strlen(ae->un.HostName); 1624 len += (len & 3) ? (4 - (len & 3)) : 4; 1625 ae->ad.bits.AttrLen = 1626 be16_to_cpu(FOURBYTES + len); 1627 pab->ab.EntryCnt++; 1628 size += FOURBYTES + len; 1629 } 1630 1631 pab->ab.EntryCnt = be32_to_cpu(pab->ab.EntryCnt); 1632 /* Total size */ 1633 size = GID_REQUEST_SZ - 4 + size; 1634 } 1635 break; 1636 1637 case SLI_MGMT_DHBA: 1638 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DHBA); 1639 CtReq->CommandResponse.bits.Size = 0; 1640 pe = (PORT_ENTRY *) & CtReq->un.PortID; 1641 memcpy((uint8_t *) & pe->PortName, 1642 (uint8_t *) & vport->fc_sparam.portName, 1643 sizeof (struct lpfc_name)); 1644 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name); 1645 break; 1646 1647 case SLI_MGMT_DPRT: 1648 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DPRT); 1649 CtReq->CommandResponse.bits.Size = 0; 1650 pe = (PORT_ENTRY *) & CtReq->un.PortID; 1651 memcpy((uint8_t *) & pe->PortName, 1652 (uint8_t *) & vport->fc_sparam.portName, 1653 sizeof (struct lpfc_name)); 1654 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name); 1655 break; 1656 } 1657 1658 bpl = (struct ulp_bde64 *) bmp->virt; 1659 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) ); 1660 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) ); 1661 bpl->tus.f.bdeFlags = 0; 1662 bpl->tus.f.bdeSize = size; 1663 bpl->tus.w = le32_to_cpu(bpl->tus.w); 1664 1665 cmpl = lpfc_cmpl_ct_cmd_fdmi; 1666 1667 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count 1668 * to hold ndlp reference for the corresponding callback function. 1669 */ 1670 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, FC_MAX_NS_RSP, 0)) 1671 return 0; 1672 1673 /* Decrement ndlp reference count to release ndlp reference held 1674 * for the failed command's callback function. 1675 */ 1676 lpfc_nlp_put(ndlp); 1677 1678 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 1679 fdmi_cmd_free_bmp: 1680 kfree(bmp); 1681 fdmi_cmd_free_mpvirt: 1682 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1683 fdmi_cmd_free_mp: 1684 kfree(mp); 1685 fdmi_cmd_exit: 1686 /* Issue FDMI request failed */ 1687 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1688 "0244 Issue FDMI request failed Data: x%x\n", 1689 cmdcode); 1690 return 1; 1691 } 1692 1693 void 1694 lpfc_fdmi_tmo(unsigned long ptr) 1695 { 1696 struct lpfc_vport *vport = (struct lpfc_vport *)ptr; 1697 struct lpfc_hba *phba = vport->phba; 1698 uint32_t tmo_posted; 1699 unsigned long iflag; 1700 1701 spin_lock_irqsave(&vport->work_port_lock, iflag); 1702 tmo_posted = vport->work_port_events & WORKER_FDMI_TMO; 1703 if (!tmo_posted) 1704 vport->work_port_events |= WORKER_FDMI_TMO; 1705 spin_unlock_irqrestore(&vport->work_port_lock, iflag); 1706 1707 if (!tmo_posted) 1708 lpfc_worker_wake_up(phba); 1709 return; 1710 } 1711 1712 void 1713 lpfc_fdmi_timeout_handler(struct lpfc_vport *vport) 1714 { 1715 struct lpfc_nodelist *ndlp; 1716 1717 ndlp = lpfc_findnode_did(vport, FDMI_DID); 1718 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) { 1719 if (init_utsname()->nodename[0] != '\0') 1720 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA); 1721 else 1722 mod_timer(&vport->fc_fdmitmo, jiffies + HZ * 60); 1723 } 1724 return; 1725 } 1726 1727 void 1728 lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag) 1729 { 1730 struct lpfc_sli *psli = &phba->sli; 1731 lpfc_vpd_t *vp = &phba->vpd; 1732 uint32_t b1, b2, b3, b4, i, rev; 1733 char c; 1734 uint32_t *ptr, str[4]; 1735 uint8_t *fwname; 1736 1737 if (phba->sli_rev == LPFC_SLI_REV4) 1738 sprintf(fwrevision, "%s", vp->rev.opFwName); 1739 else if (vp->rev.rBit) { 1740 if (psli->sli_flag & LPFC_SLI_ACTIVE) 1741 rev = vp->rev.sli2FwRev; 1742 else 1743 rev = vp->rev.sli1FwRev; 1744 1745 b1 = (rev & 0x0000f000) >> 12; 1746 b2 = (rev & 0x00000f00) >> 8; 1747 b3 = (rev & 0x000000c0) >> 6; 1748 b4 = (rev & 0x00000030) >> 4; 1749 1750 switch (b4) { 1751 case 0: 1752 c = 'N'; 1753 break; 1754 case 1: 1755 c = 'A'; 1756 break; 1757 case 2: 1758 c = 'B'; 1759 break; 1760 default: 1761 c = 0; 1762 break; 1763 } 1764 b4 = (rev & 0x0000000f); 1765 1766 if (psli->sli_flag & LPFC_SLI_ACTIVE) 1767 fwname = vp->rev.sli2FwName; 1768 else 1769 fwname = vp->rev.sli1FwName; 1770 1771 for (i = 0; i < 16; i++) 1772 if (fwname[i] == 0x20) 1773 fwname[i] = 0; 1774 1775 ptr = (uint32_t*)fwname; 1776 1777 for (i = 0; i < 3; i++) 1778 str[i] = be32_to_cpu(*ptr++); 1779 1780 if (c == 0) { 1781 if (flag) 1782 sprintf(fwrevision, "%d.%d%d (%s)", 1783 b1, b2, b3, (char *)str); 1784 else 1785 sprintf(fwrevision, "%d.%d%d", b1, 1786 b2, b3); 1787 } else { 1788 if (flag) 1789 sprintf(fwrevision, "%d.%d%d%c%d (%s)", 1790 b1, b2, b3, c, 1791 b4, (char *)str); 1792 else 1793 sprintf(fwrevision, "%d.%d%d%c%d", 1794 b1, b2, b3, c, b4); 1795 } 1796 } else { 1797 rev = vp->rev.smFwRev; 1798 1799 b1 = (rev & 0xff000000) >> 24; 1800 b2 = (rev & 0x00f00000) >> 20; 1801 b3 = (rev & 0x000f0000) >> 16; 1802 c = (rev & 0x0000ff00) >> 8; 1803 b4 = (rev & 0x000000ff); 1804 1805 if (flag) 1806 sprintf(fwrevision, "%d.%d%d%c%d ", b1, 1807 b2, b3, c, b4); 1808 else 1809 sprintf(fwrevision, "%d.%d%d%c%d ", b1, 1810 b2, b3, c, b4); 1811 } 1812 return; 1813 } 1814