1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2005 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 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_hw.h" 36 #include "lpfc_sli.h" 37 #include "lpfc_disc.h" 38 #include "lpfc_scsi.h" 39 #include "lpfc.h" 40 #include "lpfc_logmsg.h" 41 #include "lpfc_crtn.h" 42 #include "lpfc_version.h" 43 44 #define HBA_PORTSPEED_UNKNOWN 0 /* Unknown - transceiver 45 * incapable of reporting */ 46 #define HBA_PORTSPEED_1GBIT 1 /* 1 GBit/sec */ 47 #define HBA_PORTSPEED_2GBIT 2 /* 2 GBit/sec */ 48 #define HBA_PORTSPEED_4GBIT 8 /* 4 GBit/sec */ 49 #define HBA_PORTSPEED_8GBIT 16 /* 8 GBit/sec */ 50 #define HBA_PORTSPEED_10GBIT 4 /* 10 GBit/sec */ 51 #define HBA_PORTSPEED_NOT_NEGOTIATED 5 /* Speed not established */ 52 53 #define FOURBYTES 4 54 55 56 static char *lpfc_release_version = LPFC_DRIVER_VERSION; 57 58 /* 59 * lpfc_ct_unsol_event 60 */ 61 void 62 lpfc_ct_unsol_event(struct lpfc_hba * phba, 63 struct lpfc_sli_ring * pring, struct lpfc_iocbq * piocbq) 64 { 65 66 struct lpfc_iocbq *next_piocbq; 67 struct lpfc_dmabuf *pmbuf = NULL; 68 struct lpfc_dmabuf *matp, *next_matp; 69 uint32_t ctx = 0, size = 0, cnt = 0; 70 IOCB_t *icmd = &piocbq->iocb; 71 IOCB_t *save_icmd = icmd; 72 int i, go_exit = 0; 73 struct list_head head; 74 75 if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) && 76 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) { 77 /* Not enough posted buffers; Try posting more buffers */ 78 phba->fc_stat.NoRcvBuf++; 79 lpfc_post_buffer(phba, pring, 0, 1); 80 return; 81 } 82 83 /* If there are no BDEs associated with this IOCB, 84 * there is nothing to do. 85 */ 86 if (icmd->ulpBdeCount == 0) 87 return; 88 89 INIT_LIST_HEAD(&head); 90 list_add_tail(&head, &piocbq->list); 91 92 list_for_each_entry_safe(piocbq, next_piocbq, &head, list) { 93 icmd = &piocbq->iocb; 94 if (ctx == 0) 95 ctx = (uint32_t) (icmd->ulpContext); 96 if (icmd->ulpBdeCount == 0) 97 continue; 98 99 for (i = 0; i < icmd->ulpBdeCount; i++) { 100 matp = lpfc_sli_ringpostbuf_get(phba, pring, 101 getPaddr(icmd->un. 102 cont64[i]. 103 addrHigh, 104 icmd->un. 105 cont64[i]. 106 addrLow)); 107 if (!matp) { 108 /* Insert lpfc log message here */ 109 lpfc_post_buffer(phba, pring, cnt, 1); 110 go_exit = 1; 111 goto ct_unsol_event_exit_piocbq; 112 } 113 114 /* Typically for Unsolicited CT requests */ 115 if (!pmbuf) { 116 pmbuf = matp; 117 INIT_LIST_HEAD(&pmbuf->list); 118 } else 119 list_add_tail(&matp->list, &pmbuf->list); 120 121 size += icmd->un.cont64[i].tus.f.bdeSize; 122 cnt++; 123 } 124 125 icmd->ulpBdeCount = 0; 126 } 127 128 lpfc_post_buffer(phba, pring, cnt, 1); 129 if (save_icmd->ulpStatus) { 130 go_exit = 1; 131 } 132 133 ct_unsol_event_exit_piocbq: 134 if (pmbuf) { 135 list_for_each_entry_safe(matp, next_matp, &pmbuf->list, list) { 136 lpfc_mbuf_free(phba, matp->virt, matp->phys); 137 list_del(&matp->list); 138 kfree(matp); 139 } 140 lpfc_mbuf_free(phba, pmbuf->virt, pmbuf->phys); 141 kfree(pmbuf); 142 } 143 return; 144 } 145 146 static void 147 lpfc_free_ct_rsp(struct lpfc_hba * phba, struct lpfc_dmabuf * mlist) 148 { 149 struct lpfc_dmabuf *mlast, *next_mlast; 150 151 list_for_each_entry_safe(mlast, next_mlast, &mlist->list, list) { 152 lpfc_mbuf_free(phba, mlast->virt, mlast->phys); 153 list_del(&mlast->list); 154 kfree(mlast); 155 } 156 lpfc_mbuf_free(phba, mlist->virt, mlist->phys); 157 kfree(mlist); 158 return; 159 } 160 161 static struct lpfc_dmabuf * 162 lpfc_alloc_ct_rsp(struct lpfc_hba * phba, int cmdcode, struct ulp_bde64 * bpl, 163 uint32_t size, int *entries) 164 { 165 struct lpfc_dmabuf *mlist = NULL; 166 struct lpfc_dmabuf *mp; 167 int cnt, i = 0; 168 169 /* We get chucks of FCELSSIZE */ 170 cnt = size > FCELSSIZE ? FCELSSIZE: size; 171 172 while (size) { 173 /* Allocate buffer for rsp payload */ 174 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 175 if (!mp) { 176 if (mlist) 177 lpfc_free_ct_rsp(phba, mlist); 178 return NULL; 179 } 180 181 INIT_LIST_HEAD(&mp->list); 182 183 if (cmdcode == be16_to_cpu(SLI_CTNS_GID_FT)) 184 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys)); 185 else 186 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys)); 187 188 if (!mp->virt) { 189 kfree(mp); 190 lpfc_free_ct_rsp(phba, mlist); 191 return NULL; 192 } 193 194 /* Queue it to a linked list */ 195 if (!mlist) 196 mlist = mp; 197 else 198 list_add_tail(&mp->list, &mlist->list); 199 200 bpl->tus.f.bdeFlags = BUFF_USE_RCV; 201 /* build buffer ptr list for IOCB */ 202 bpl->addrLow = le32_to_cpu( putPaddrLow(mp->phys) ); 203 bpl->addrHigh = le32_to_cpu( putPaddrHigh(mp->phys) ); 204 bpl->tus.f.bdeSize = (uint16_t) cnt; 205 bpl->tus.w = le32_to_cpu(bpl->tus.w); 206 bpl++; 207 208 i++; 209 size -= cnt; 210 } 211 212 *entries = i; 213 return mlist; 214 } 215 216 static int 217 lpfc_gen_req(struct lpfc_hba *phba, struct lpfc_dmabuf *bmp, 218 struct lpfc_dmabuf *inp, struct lpfc_dmabuf *outp, 219 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 220 struct lpfc_iocbq *), 221 struct lpfc_nodelist *ndlp, uint32_t usr_flg, uint32_t num_entry, 222 uint32_t tmo) 223 { 224 225 struct lpfc_sli *psli = &phba->sli; 226 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING]; 227 IOCB_t *icmd; 228 struct lpfc_iocbq *geniocb; 229 230 /* Allocate buffer for command iocb */ 231 spin_lock_irq(phba->host->host_lock); 232 geniocb = lpfc_sli_get_iocbq(phba); 233 spin_unlock_irq(phba->host->host_lock); 234 235 if (geniocb == NULL) 236 return 1; 237 238 icmd = &geniocb->iocb; 239 icmd->un.genreq64.bdl.ulpIoTag32 = 0; 240 icmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys); 241 icmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys); 242 icmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BDL; 243 icmd->un.genreq64.bdl.bdeSize = (num_entry * sizeof (struct ulp_bde64)); 244 245 if (usr_flg) 246 geniocb->context3 = NULL; 247 else 248 geniocb->context3 = (uint8_t *) bmp; 249 250 /* Save for completion so we can release these resources */ 251 geniocb->context1 = (uint8_t *) inp; 252 geniocb->context2 = (uint8_t *) outp; 253 254 /* Fill in payload, bp points to frame payload */ 255 icmd->ulpCommand = CMD_GEN_REQUEST64_CR; 256 257 /* Fill in rest of iocb */ 258 icmd->un.genreq64.w5.hcsw.Fctl = (SI | LA); 259 icmd->un.genreq64.w5.hcsw.Dfctl = 0; 260 icmd->un.genreq64.w5.hcsw.Rctl = FC_UNSOL_CTL; 261 icmd->un.genreq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP; 262 263 if (!tmo) 264 tmo = (2 * phba->fc_ratov) + 1; 265 icmd->ulpTimeout = tmo; 266 icmd->ulpBdeCount = 1; 267 icmd->ulpLe = 1; 268 icmd->ulpClass = CLASS3; 269 icmd->ulpContext = ndlp->nlp_rpi; 270 271 /* Issue GEN REQ IOCB for NPORT <did> */ 272 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 273 "%d:0119 Issue GEN REQ IOCB for NPORT x%x " 274 "Data: x%x x%x\n", phba->brd_no, icmd->un.ulpWord[5], 275 icmd->ulpIoTag, phba->hba_state); 276 geniocb->iocb_cmpl = cmpl; 277 geniocb->drvrTimeout = icmd->ulpTimeout + LPFC_DRVR_TIMEOUT; 278 spin_lock_irq(phba->host->host_lock); 279 if (lpfc_sli_issue_iocb(phba, pring, geniocb, 0) == IOCB_ERROR) { 280 lpfc_sli_release_iocbq(phba, geniocb); 281 spin_unlock_irq(phba->host->host_lock); 282 return 1; 283 } 284 spin_unlock_irq(phba->host->host_lock); 285 286 return 0; 287 } 288 289 static int 290 lpfc_ct_cmd(struct lpfc_hba *phba, struct lpfc_dmabuf *inmp, 291 struct lpfc_dmabuf *bmp, struct lpfc_nodelist *ndlp, 292 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 293 struct lpfc_iocbq *), 294 uint32_t rsp_size) 295 { 296 struct ulp_bde64 *bpl = (struct ulp_bde64 *) bmp->virt; 297 struct lpfc_dmabuf *outmp; 298 int cnt = 0, status; 299 int cmdcode = ((struct lpfc_sli_ct_request *) inmp->virt)-> 300 CommandResponse.bits.CmdRsp; 301 302 bpl++; /* Skip past ct request */ 303 304 /* Put buffer(s) for ct rsp in bpl */ 305 outmp = lpfc_alloc_ct_rsp(phba, cmdcode, bpl, rsp_size, &cnt); 306 if (!outmp) 307 return -ENOMEM; 308 309 status = lpfc_gen_req(phba, bmp, inmp, outmp, cmpl, ndlp, 0, 310 cnt+1, 0); 311 if (status) { 312 lpfc_free_ct_rsp(phba, outmp); 313 return -ENOMEM; 314 } 315 return 0; 316 } 317 318 static int 319 lpfc_ns_rsp(struct lpfc_hba * phba, struct lpfc_dmabuf * mp, uint32_t Size) 320 { 321 struct lpfc_sli_ct_request *Response = 322 (struct lpfc_sli_ct_request *) mp->virt; 323 struct lpfc_nodelist *ndlp = NULL; 324 struct lpfc_dmabuf *mlast, *next_mp; 325 uint32_t *ctptr = (uint32_t *) & Response->un.gid.PortType; 326 uint32_t Did; 327 uint32_t CTentry; 328 int Cnt; 329 struct list_head head; 330 331 lpfc_set_disctmo(phba); 332 333 Cnt = Size > FCELSSIZE ? FCELSSIZE : Size; 334 335 list_add_tail(&head, &mp->list); 336 list_for_each_entry_safe(mp, next_mp, &head, list) { 337 mlast = mp; 338 339 Size -= Cnt; 340 341 if (!ctptr) 342 ctptr = (uint32_t *) mlast->virt; 343 else 344 Cnt -= 16; /* subtract length of CT header */ 345 346 /* Loop through entire NameServer list of DIDs */ 347 while (Cnt) { 348 349 /* Get next DID from NameServer List */ 350 CTentry = *ctptr++; 351 Did = ((be32_to_cpu(CTentry)) & Mask_DID); 352 353 ndlp = NULL; 354 if (Did != phba->fc_myDID) { 355 /* Check for rscn processing or not */ 356 ndlp = lpfc_setup_disc_node(phba, Did); 357 } 358 /* Mark all node table entries that are in the 359 Nameserver */ 360 if (ndlp) { 361 /* NameServer Rsp */ 362 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 363 "%d:0238 Process x%x NameServer" 364 " Rsp Data: x%x x%x x%x\n", 365 phba->brd_no, 366 Did, ndlp->nlp_flag, 367 phba->fc_flag, 368 phba->fc_rscn_id_cnt); 369 } else { 370 /* NameServer Rsp */ 371 lpfc_printf_log(phba, 372 KERN_INFO, 373 LOG_DISCOVERY, 374 "%d:0239 Skip x%x NameServer " 375 "Rsp Data: x%x x%x x%x\n", 376 phba->brd_no, 377 Did, Size, phba->fc_flag, 378 phba->fc_rscn_id_cnt); 379 } 380 381 if (CTentry & (be32_to_cpu(SLI_CT_LAST_ENTRY))) 382 goto nsout1; 383 Cnt -= sizeof (uint32_t); 384 } 385 ctptr = NULL; 386 387 } 388 389 nsout1: 390 list_del(&head); 391 392 /* Here we are finished in the case RSCN */ 393 if (phba->hba_state == LPFC_HBA_READY) { 394 lpfc_els_flush_rscn(phba); 395 spin_lock_irq(phba->host->host_lock); 396 phba->fc_flag |= FC_RSCN_MODE; /* we are still in RSCN mode */ 397 spin_unlock_irq(phba->host->host_lock); 398 } 399 return 0; 400 } 401 402 403 404 405 static void 406 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 407 struct lpfc_iocbq * rspiocb) 408 { 409 IOCB_t *irsp; 410 struct lpfc_sli *psli; 411 struct lpfc_dmabuf *bmp; 412 struct lpfc_dmabuf *inp; 413 struct lpfc_dmabuf *outp; 414 struct lpfc_nodelist *ndlp; 415 struct lpfc_sli_ct_request *CTrsp; 416 417 psli = &phba->sli; 418 /* we pass cmdiocb to state machine which needs rspiocb as well */ 419 cmdiocb->context_un.rsp_iocb = rspiocb; 420 421 inp = (struct lpfc_dmabuf *) cmdiocb->context1; 422 outp = (struct lpfc_dmabuf *) cmdiocb->context2; 423 bmp = (struct lpfc_dmabuf *) cmdiocb->context3; 424 425 irsp = &rspiocb->iocb; 426 if (irsp->ulpStatus) { 427 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && 428 ((irsp->un.ulpWord[4] == IOERR_SLI_DOWN) || 429 (irsp->un.ulpWord[4] == IOERR_SLI_ABORTED))) { 430 goto out; 431 } 432 433 /* Check for retry */ 434 if (phba->fc_ns_retry < LPFC_MAX_NS_RETRY) { 435 phba->fc_ns_retry++; 436 /* CT command is being retried */ 437 ndlp = 438 lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED, 439 NameServer_DID); 440 if (ndlp) { 441 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) == 442 0) { 443 goto out; 444 } 445 } 446 } 447 } else { 448 /* Good status, continue checking */ 449 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 450 if (CTrsp->CommandResponse.bits.CmdRsp == 451 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) { 452 lpfc_ns_rsp(phba, outp, 453 (uint32_t) (irsp->un.genreq64.bdl.bdeSize)); 454 } else if (CTrsp->CommandResponse.bits.CmdRsp == 455 be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) { 456 /* NameServer Rsp Error */ 457 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 458 "%d:0240 NameServer Rsp Error " 459 "Data: x%x x%x x%x x%x\n", 460 phba->brd_no, 461 CTrsp->CommandResponse.bits.CmdRsp, 462 (uint32_t) CTrsp->ReasonCode, 463 (uint32_t) CTrsp->Explanation, 464 phba->fc_flag); 465 } else { 466 /* NameServer Rsp Error */ 467 lpfc_printf_log(phba, 468 KERN_INFO, 469 LOG_DISCOVERY, 470 "%d:0241 NameServer Rsp Error " 471 "Data: x%x x%x x%x x%x\n", 472 phba->brd_no, 473 CTrsp->CommandResponse.bits.CmdRsp, 474 (uint32_t) CTrsp->ReasonCode, 475 (uint32_t) CTrsp->Explanation, 476 phba->fc_flag); 477 } 478 } 479 /* Link up / RSCN discovery */ 480 lpfc_disc_start(phba); 481 out: 482 lpfc_free_ct_rsp(phba, outp); 483 lpfc_mbuf_free(phba, inp->virt, inp->phys); 484 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 485 kfree(inp); 486 kfree(bmp); 487 spin_lock_irq(phba->host->host_lock); 488 lpfc_sli_release_iocbq(phba, cmdiocb); 489 spin_unlock_irq(phba->host->host_lock); 490 return; 491 } 492 493 static void 494 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 495 struct lpfc_iocbq * rspiocb) 496 { 497 struct lpfc_sli *psli; 498 struct lpfc_dmabuf *bmp; 499 struct lpfc_dmabuf *inp; 500 struct lpfc_dmabuf *outp; 501 IOCB_t *irsp; 502 struct lpfc_sli_ct_request *CTrsp; 503 504 psli = &phba->sli; 505 /* we pass cmdiocb to state machine which needs rspiocb as well */ 506 cmdiocb->context_un.rsp_iocb = rspiocb; 507 508 inp = (struct lpfc_dmabuf *) cmdiocb->context1; 509 outp = (struct lpfc_dmabuf *) cmdiocb->context2; 510 bmp = (struct lpfc_dmabuf *) cmdiocb->context3; 511 irsp = &rspiocb->iocb; 512 513 CTrsp = (struct lpfc_sli_ct_request *) outp->virt; 514 515 /* RFT request completes status <ulpStatus> CmdRsp <CmdRsp> */ 516 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 517 "%d:0209 RFT request completes ulpStatus x%x " 518 "CmdRsp x%x\n", phba->brd_no, irsp->ulpStatus, 519 CTrsp->CommandResponse.bits.CmdRsp); 520 521 lpfc_free_ct_rsp(phba, outp); 522 lpfc_mbuf_free(phba, inp->virt, inp->phys); 523 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 524 kfree(inp); 525 kfree(bmp); 526 spin_lock_irq(phba->host->host_lock); 527 lpfc_sli_release_iocbq(phba, cmdiocb); 528 spin_unlock_irq(phba->host->host_lock); 529 return; 530 } 531 532 static void 533 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 534 struct lpfc_iocbq * rspiocb) 535 { 536 lpfc_cmpl_ct_cmd_rft_id(phba, cmdiocb, rspiocb); 537 return; 538 } 539 540 static void 541 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 542 struct lpfc_iocbq * rspiocb) 543 { 544 lpfc_cmpl_ct_cmd_rft_id(phba, cmdiocb, rspiocb); 545 return; 546 } 547 548 void 549 lpfc_get_hba_sym_node_name(struct lpfc_hba * phba, uint8_t * symbp) 550 { 551 char fwrev[16]; 552 553 lpfc_decode_firmware_rev(phba, fwrev, 0); 554 555 if (phba->Port[0]) { 556 sprintf(symbp, "Emulex %s Port %s FV%s DV%s", phba->ModelName, 557 phba->Port, fwrev, lpfc_release_version); 558 } else { 559 sprintf(symbp, "Emulex %s FV%s DV%s", phba->ModelName, 560 fwrev, lpfc_release_version); 561 } 562 } 563 564 /* 565 * lpfc_ns_cmd 566 * Description: 567 * Issue Cmd to NameServer 568 * SLI_CTNS_GID_FT 569 * LI_CTNS_RFT_ID 570 */ 571 int 572 lpfc_ns_cmd(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, int cmdcode) 573 { 574 struct lpfc_dmabuf *mp, *bmp; 575 struct lpfc_sli_ct_request *CtReq; 576 struct ulp_bde64 *bpl; 577 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 578 struct lpfc_iocbq *) = NULL; 579 uint32_t rsp_size = 1024; 580 581 /* fill in BDEs for command */ 582 /* Allocate buffer for command payload */ 583 mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 584 if (!mp) 585 goto ns_cmd_exit; 586 587 INIT_LIST_HEAD(&mp->list); 588 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys)); 589 if (!mp->virt) 590 goto ns_cmd_free_mp; 591 592 /* Allocate buffer for Buffer ptr list */ 593 bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 594 if (!bmp) 595 goto ns_cmd_free_mpvirt; 596 597 INIT_LIST_HEAD(&bmp->list); 598 bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys)); 599 if (!bmp->virt) 600 goto ns_cmd_free_bmp; 601 602 /* NameServer Req */ 603 lpfc_printf_log(phba, 604 KERN_INFO, 605 LOG_DISCOVERY, 606 "%d:0236 NameServer Req Data: x%x x%x x%x\n", 607 phba->brd_no, cmdcode, phba->fc_flag, 608 phba->fc_rscn_id_cnt); 609 610 bpl = (struct ulp_bde64 *) bmp->virt; 611 memset(bpl, 0, sizeof(struct ulp_bde64)); 612 bpl->addrHigh = le32_to_cpu( putPaddrHigh(mp->phys) ); 613 bpl->addrLow = le32_to_cpu( putPaddrLow(mp->phys) ); 614 bpl->tus.f.bdeFlags = 0; 615 if (cmdcode == SLI_CTNS_GID_FT) 616 bpl->tus.f.bdeSize = GID_REQUEST_SZ; 617 else if (cmdcode == SLI_CTNS_RFT_ID) 618 bpl->tus.f.bdeSize = RFT_REQUEST_SZ; 619 else if (cmdcode == SLI_CTNS_RNN_ID) 620 bpl->tus.f.bdeSize = RNN_REQUEST_SZ; 621 else if (cmdcode == SLI_CTNS_RSNN_NN) 622 bpl->tus.f.bdeSize = RSNN_REQUEST_SZ; 623 else 624 bpl->tus.f.bdeSize = 0; 625 bpl->tus.w = le32_to_cpu(bpl->tus.w); 626 627 CtReq = (struct lpfc_sli_ct_request *) mp->virt; 628 memset(CtReq, 0, sizeof (struct lpfc_sli_ct_request)); 629 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION; 630 CtReq->RevisionId.bits.InId = 0; 631 CtReq->FsType = SLI_CT_DIRECTORY_SERVICE; 632 CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER; 633 CtReq->CommandResponse.bits.Size = 0; 634 switch (cmdcode) { 635 case SLI_CTNS_GID_FT: 636 CtReq->CommandResponse.bits.CmdRsp = 637 be16_to_cpu(SLI_CTNS_GID_FT); 638 CtReq->un.gid.Fc4Type = SLI_CTPT_FCP; 639 if (phba->hba_state < LPFC_HBA_READY) 640 phba->hba_state = LPFC_NS_QRY; 641 lpfc_set_disctmo(phba); 642 cmpl = lpfc_cmpl_ct_cmd_gid_ft; 643 rsp_size = FC_MAX_NS_RSP; 644 break; 645 646 case SLI_CTNS_RFT_ID: 647 CtReq->CommandResponse.bits.CmdRsp = 648 be16_to_cpu(SLI_CTNS_RFT_ID); 649 CtReq->un.rft.PortId = be32_to_cpu(phba->fc_myDID); 650 CtReq->un.rft.fcpReg = 1; 651 cmpl = lpfc_cmpl_ct_cmd_rft_id; 652 break; 653 654 case SLI_CTNS_RNN_ID: 655 CtReq->CommandResponse.bits.CmdRsp = 656 be16_to_cpu(SLI_CTNS_RNN_ID); 657 CtReq->un.rnn.PortId = be32_to_cpu(phba->fc_myDID); 658 memcpy(CtReq->un.rnn.wwnn, &phba->fc_nodename, 659 sizeof (struct lpfc_name)); 660 cmpl = lpfc_cmpl_ct_cmd_rnn_id; 661 break; 662 663 case SLI_CTNS_RSNN_NN: 664 CtReq->CommandResponse.bits.CmdRsp = 665 be16_to_cpu(SLI_CTNS_RSNN_NN); 666 memcpy(CtReq->un.rsnn.wwnn, &phba->fc_nodename, 667 sizeof (struct lpfc_name)); 668 lpfc_get_hba_sym_node_name(phba, CtReq->un.rsnn.symbname); 669 CtReq->un.rsnn.len = strlen(CtReq->un.rsnn.symbname); 670 cmpl = lpfc_cmpl_ct_cmd_rsnn_nn; 671 break; 672 } 673 674 if (!lpfc_ct_cmd(phba, mp, bmp, ndlp, cmpl, rsp_size)) 675 /* On success, The cmpl function will free the buffers */ 676 return 0; 677 678 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 679 ns_cmd_free_bmp: 680 kfree(bmp); 681 ns_cmd_free_mpvirt: 682 lpfc_mbuf_free(phba, mp->virt, mp->phys); 683 ns_cmd_free_mp: 684 kfree(mp); 685 ns_cmd_exit: 686 return 1; 687 } 688 689 static void 690 lpfc_cmpl_ct_cmd_fdmi(struct lpfc_hba * phba, 691 struct lpfc_iocbq * cmdiocb, struct lpfc_iocbq * rspiocb) 692 { 693 struct lpfc_dmabuf *bmp = cmdiocb->context3; 694 struct lpfc_dmabuf *inp = cmdiocb->context1; 695 struct lpfc_dmabuf *outp = cmdiocb->context2; 696 struct lpfc_sli_ct_request *CTrsp = outp->virt; 697 struct lpfc_sli_ct_request *CTcmd = inp->virt; 698 struct lpfc_nodelist *ndlp; 699 uint16_t fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp; 700 uint16_t fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp; 701 702 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, FDMI_DID); 703 if (fdmi_rsp == be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) { 704 /* FDMI rsp failed */ 705 lpfc_printf_log(phba, 706 KERN_INFO, 707 LOG_DISCOVERY, 708 "%d:0220 FDMI rsp failed Data: x%x\n", 709 phba->brd_no, 710 be16_to_cpu(fdmi_cmd)); 711 } 712 713 switch (be16_to_cpu(fdmi_cmd)) { 714 case SLI_MGMT_RHBA: 715 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_RPA); 716 break; 717 718 case SLI_MGMT_RPA: 719 break; 720 721 case SLI_MGMT_DHBA: 722 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_DPRT); 723 break; 724 725 case SLI_MGMT_DPRT: 726 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_RHBA); 727 break; 728 } 729 730 lpfc_free_ct_rsp(phba, outp); 731 lpfc_mbuf_free(phba, inp->virt, inp->phys); 732 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 733 kfree(inp); 734 kfree(bmp); 735 spin_lock_irq(phba->host->host_lock); 736 lpfc_sli_release_iocbq(phba, cmdiocb); 737 spin_unlock_irq(phba->host->host_lock); 738 return; 739 } 740 int 741 lpfc_fdmi_cmd(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, int cmdcode) 742 { 743 struct lpfc_dmabuf *mp, *bmp; 744 struct lpfc_sli_ct_request *CtReq; 745 struct ulp_bde64 *bpl; 746 uint32_t size; 747 REG_HBA *rh; 748 PORT_ENTRY *pe; 749 REG_PORT_ATTRIBUTE *pab; 750 ATTRIBUTE_BLOCK *ab; 751 ATTRIBUTE_ENTRY *ae; 752 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *, 753 struct lpfc_iocbq *); 754 755 756 /* fill in BDEs for command */ 757 /* Allocate buffer for command payload */ 758 mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 759 if (!mp) 760 goto fdmi_cmd_exit; 761 762 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys)); 763 if (!mp->virt) 764 goto fdmi_cmd_free_mp; 765 766 /* Allocate buffer for Buffer ptr list */ 767 bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 768 if (!bmp) 769 goto fdmi_cmd_free_mpvirt; 770 771 bmp->virt = lpfc_mbuf_alloc(phba, 0, &(bmp->phys)); 772 if (!bmp->virt) 773 goto fdmi_cmd_free_bmp; 774 775 INIT_LIST_HEAD(&mp->list); 776 INIT_LIST_HEAD(&bmp->list); 777 778 /* FDMI request */ 779 lpfc_printf_log(phba, 780 KERN_INFO, 781 LOG_DISCOVERY, 782 "%d:0218 FDMI Request Data: x%x x%x x%x\n", 783 phba->brd_no, 784 phba->fc_flag, phba->hba_state, cmdcode); 785 786 CtReq = (struct lpfc_sli_ct_request *) mp->virt; 787 788 memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request)); 789 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION; 790 CtReq->RevisionId.bits.InId = 0; 791 792 CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE; 793 CtReq->FsSubType = SLI_CT_FDMI_Subtypes; 794 size = 0; 795 796 switch (cmdcode) { 797 case SLI_MGMT_RHBA: 798 { 799 lpfc_vpd_t *vp = &phba->vpd; 800 uint32_t i, j, incr; 801 int len; 802 803 CtReq->CommandResponse.bits.CmdRsp = 804 be16_to_cpu(SLI_MGMT_RHBA); 805 CtReq->CommandResponse.bits.Size = 0; 806 rh = (REG_HBA *) & CtReq->un.PortID; 807 memcpy(&rh->hi.PortName, &phba->fc_sparam.portName, 808 sizeof (struct lpfc_name)); 809 /* One entry (port) per adapter */ 810 rh->rpl.EntryCnt = be32_to_cpu(1); 811 memcpy(&rh->rpl.pe, &phba->fc_sparam.portName, 812 sizeof (struct lpfc_name)); 813 814 /* point to the HBA attribute block */ 815 size = 2 * sizeof (struct lpfc_name) + FOURBYTES; 816 ab = (ATTRIBUTE_BLOCK *) ((uint8_t *) rh + size); 817 ab->EntryCnt = 0; 818 819 /* Point to the beginning of the first HBA attribute 820 entry */ 821 /* #1 HBA attribute entry */ 822 size += FOURBYTES; 823 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 824 ae->ad.bits.AttrType = be16_to_cpu(NODE_NAME); 825 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES 826 + sizeof (struct lpfc_name)); 827 memcpy(&ae->un.NodeName, &phba->fc_sparam.nodeName, 828 sizeof (struct lpfc_name)); 829 ab->EntryCnt++; 830 size += FOURBYTES + sizeof (struct lpfc_name); 831 832 /* #2 HBA attribute entry */ 833 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 834 ae->ad.bits.AttrType = be16_to_cpu(MANUFACTURER); 835 strcpy(ae->un.Manufacturer, "Emulex Corporation"); 836 len = strlen(ae->un.Manufacturer); 837 len += (len & 3) ? (4 - (len & 3)) : 4; 838 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 839 ab->EntryCnt++; 840 size += FOURBYTES + len; 841 842 /* #3 HBA attribute entry */ 843 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 844 ae->ad.bits.AttrType = be16_to_cpu(SERIAL_NUMBER); 845 strcpy(ae->un.SerialNumber, phba->SerialNumber); 846 len = strlen(ae->un.SerialNumber); 847 len += (len & 3) ? (4 - (len & 3)) : 4; 848 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 849 ab->EntryCnt++; 850 size += FOURBYTES + len; 851 852 /* #4 HBA attribute entry */ 853 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 854 ae->ad.bits.AttrType = be16_to_cpu(MODEL); 855 strcpy(ae->un.Model, phba->ModelName); 856 len = strlen(ae->un.Model); 857 len += (len & 3) ? (4 - (len & 3)) : 4; 858 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 859 ab->EntryCnt++; 860 size += FOURBYTES + len; 861 862 /* #5 HBA attribute entry */ 863 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 864 ae->ad.bits.AttrType = be16_to_cpu(MODEL_DESCRIPTION); 865 strcpy(ae->un.ModelDescription, phba->ModelDesc); 866 len = strlen(ae->un.ModelDescription); 867 len += (len & 3) ? (4 - (len & 3)) : 4; 868 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 869 ab->EntryCnt++; 870 size += FOURBYTES + len; 871 872 /* #6 HBA attribute entry */ 873 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 874 ae->ad.bits.AttrType = be16_to_cpu(HARDWARE_VERSION); 875 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 8); 876 /* Convert JEDEC ID to ascii for hardware version */ 877 incr = vp->rev.biuRev; 878 for (i = 0; i < 8; i++) { 879 j = (incr & 0xf); 880 if (j <= 9) 881 ae->un.HardwareVersion[7 - i] = 882 (char)((uint8_t) 0x30 + 883 (uint8_t) j); 884 else 885 ae->un.HardwareVersion[7 - i] = 886 (char)((uint8_t) 0x61 + 887 (uint8_t) (j - 10)); 888 incr = (incr >> 4); 889 } 890 ab->EntryCnt++; 891 size += FOURBYTES + 8; 892 893 /* #7 HBA attribute entry */ 894 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 895 ae->ad.bits.AttrType = be16_to_cpu(DRIVER_VERSION); 896 strcpy(ae->un.DriverVersion, lpfc_release_version); 897 len = strlen(ae->un.DriverVersion); 898 len += (len & 3) ? (4 - (len & 3)) : 4; 899 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 900 ab->EntryCnt++; 901 size += FOURBYTES + len; 902 903 /* #8 HBA attribute entry */ 904 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 905 ae->ad.bits.AttrType = be16_to_cpu(OPTION_ROM_VERSION); 906 strcpy(ae->un.OptionROMVersion, phba->OptionROMVersion); 907 len = strlen(ae->un.OptionROMVersion); 908 len += (len & 3) ? (4 - (len & 3)) : 4; 909 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 910 ab->EntryCnt++; 911 size += FOURBYTES + len; 912 913 /* #9 HBA attribute entry */ 914 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 915 ae->ad.bits.AttrType = be16_to_cpu(FIRMWARE_VERSION); 916 lpfc_decode_firmware_rev(phba, ae->un.FirmwareVersion, 917 1); 918 len = strlen(ae->un.FirmwareVersion); 919 len += (len & 3) ? (4 - (len & 3)) : 4; 920 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 921 ab->EntryCnt++; 922 size += FOURBYTES + len; 923 924 /* #10 HBA attribute entry */ 925 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 926 ae->ad.bits.AttrType = be16_to_cpu(OS_NAME_VERSION); 927 sprintf(ae->un.OsNameVersion, "%s %s %s", 928 system_utsname.sysname, system_utsname.release, 929 system_utsname.version); 930 len = strlen(ae->un.OsNameVersion); 931 len += (len & 3) ? (4 - (len & 3)) : 4; 932 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 933 ab->EntryCnt++; 934 size += FOURBYTES + len; 935 936 /* #11 HBA attribute entry */ 937 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size); 938 ae->ad.bits.AttrType = be16_to_cpu(MAX_CT_PAYLOAD_LEN); 939 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4); 940 ae->un.MaxCTPayloadLen = (65 * 4096); 941 ab->EntryCnt++; 942 size += FOURBYTES + 4; 943 944 ab->EntryCnt = be32_to_cpu(ab->EntryCnt); 945 /* Total size */ 946 size = GID_REQUEST_SZ - 4 + size; 947 } 948 break; 949 950 case SLI_MGMT_RPA: 951 { 952 lpfc_vpd_t *vp; 953 struct serv_parm *hsp; 954 int len; 955 956 vp = &phba->vpd; 957 958 CtReq->CommandResponse.bits.CmdRsp = 959 be16_to_cpu(SLI_MGMT_RPA); 960 CtReq->CommandResponse.bits.Size = 0; 961 pab = (REG_PORT_ATTRIBUTE *) & CtReq->un.PortID; 962 size = sizeof (struct lpfc_name) + FOURBYTES; 963 memcpy((uint8_t *) & pab->PortName, 964 (uint8_t *) & phba->fc_sparam.portName, 965 sizeof (struct lpfc_name)); 966 pab->ab.EntryCnt = 0; 967 968 /* #1 Port attribute entry */ 969 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 970 ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_FC4_TYPES); 971 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 32); 972 ae->un.SupportFC4Types[2] = 1; 973 ae->un.SupportFC4Types[7] = 1; 974 pab->ab.EntryCnt++; 975 size += FOURBYTES + 32; 976 977 /* #2 Port attribute entry */ 978 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 979 ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_SPEED); 980 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4); 981 if (FC_JEDEC_ID(vp->rev.biuRev) == VIPER_JEDEC_ID) 982 ae->un.SupportSpeed = HBA_PORTSPEED_10GBIT; 983 else if (FC_JEDEC_ID(vp->rev.biuRev) == HELIOS_JEDEC_ID) 984 ae->un.SupportSpeed = HBA_PORTSPEED_4GBIT; 985 else if ((FC_JEDEC_ID(vp->rev.biuRev) == 986 CENTAUR_2G_JEDEC_ID) 987 || (FC_JEDEC_ID(vp->rev.biuRev) == 988 PEGASUS_JEDEC_ID) 989 || (FC_JEDEC_ID(vp->rev.biuRev) == 990 THOR_JEDEC_ID)) 991 ae->un.SupportSpeed = HBA_PORTSPEED_2GBIT; 992 else 993 ae->un.SupportSpeed = HBA_PORTSPEED_1GBIT; 994 pab->ab.EntryCnt++; 995 size += FOURBYTES + 4; 996 997 /* #3 Port attribute entry */ 998 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 999 ae->ad.bits.AttrType = be16_to_cpu(PORT_SPEED); 1000 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4); 1001 switch(phba->fc_linkspeed) { 1002 case LA_1GHZ_LINK: 1003 ae->un.PortSpeed = HBA_PORTSPEED_1GBIT; 1004 break; 1005 case LA_2GHZ_LINK: 1006 ae->un.PortSpeed = HBA_PORTSPEED_2GBIT; 1007 break; 1008 case LA_4GHZ_LINK: 1009 ae->un.PortSpeed = HBA_PORTSPEED_4GBIT; 1010 break; 1011 default: 1012 ae->un.PortSpeed = 1013 HBA_PORTSPEED_UNKNOWN; 1014 break; 1015 } 1016 pab->ab.EntryCnt++; 1017 size += FOURBYTES + 4; 1018 1019 /* #4 Port attribute entry */ 1020 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 1021 ae->ad.bits.AttrType = be16_to_cpu(MAX_FRAME_SIZE); 1022 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4); 1023 hsp = (struct serv_parm *) & phba->fc_sparam; 1024 ae->un.MaxFrameSize = 1025 (((uint32_t) hsp->cmn. 1026 bbRcvSizeMsb) << 8) | (uint32_t) hsp->cmn. 1027 bbRcvSizeLsb; 1028 pab->ab.EntryCnt++; 1029 size += FOURBYTES + 4; 1030 1031 /* #5 Port attribute entry */ 1032 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size); 1033 ae->ad.bits.AttrType = be16_to_cpu(OS_DEVICE_NAME); 1034 strcpy((char *)ae->un.OsDeviceName, LPFC_DRIVER_NAME); 1035 len = strlen((char *)ae->un.OsDeviceName); 1036 len += (len & 3) ? (4 - (len & 3)) : 4; 1037 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len); 1038 pab->ab.EntryCnt++; 1039 size += FOURBYTES + len; 1040 1041 if (phba->cfg_fdmi_on == 2) { 1042 /* #6 Port attribute entry */ 1043 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + 1044 size); 1045 ae->ad.bits.AttrType = be16_to_cpu(HOST_NAME); 1046 sprintf(ae->un.HostName, "%s", 1047 system_utsname.nodename); 1048 len = strlen(ae->un.HostName); 1049 len += (len & 3) ? (4 - (len & 3)) : 4; 1050 ae->ad.bits.AttrLen = 1051 be16_to_cpu(FOURBYTES + len); 1052 pab->ab.EntryCnt++; 1053 size += FOURBYTES + len; 1054 } 1055 1056 pab->ab.EntryCnt = be32_to_cpu(pab->ab.EntryCnt); 1057 /* Total size */ 1058 size = GID_REQUEST_SZ - 4 + size; 1059 } 1060 break; 1061 1062 case SLI_MGMT_DHBA: 1063 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DHBA); 1064 CtReq->CommandResponse.bits.Size = 0; 1065 pe = (PORT_ENTRY *) & CtReq->un.PortID; 1066 memcpy((uint8_t *) & pe->PortName, 1067 (uint8_t *) & phba->fc_sparam.portName, 1068 sizeof (struct lpfc_name)); 1069 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name); 1070 break; 1071 1072 case SLI_MGMT_DPRT: 1073 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DPRT); 1074 CtReq->CommandResponse.bits.Size = 0; 1075 pe = (PORT_ENTRY *) & CtReq->un.PortID; 1076 memcpy((uint8_t *) & pe->PortName, 1077 (uint8_t *) & phba->fc_sparam.portName, 1078 sizeof (struct lpfc_name)); 1079 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name); 1080 break; 1081 } 1082 1083 bpl = (struct ulp_bde64 *) bmp->virt; 1084 bpl->addrHigh = le32_to_cpu( putPaddrHigh(mp->phys) ); 1085 bpl->addrLow = le32_to_cpu( putPaddrLow(mp->phys) ); 1086 bpl->tus.f.bdeFlags = 0; 1087 bpl->tus.f.bdeSize = size; 1088 bpl->tus.w = le32_to_cpu(bpl->tus.w); 1089 1090 cmpl = lpfc_cmpl_ct_cmd_fdmi; 1091 1092 if (!lpfc_ct_cmd(phba, mp, bmp, ndlp, cmpl, FC_MAX_NS_RSP)) 1093 return 0; 1094 1095 lpfc_mbuf_free(phba, bmp->virt, bmp->phys); 1096 fdmi_cmd_free_bmp: 1097 kfree(bmp); 1098 fdmi_cmd_free_mpvirt: 1099 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1100 fdmi_cmd_free_mp: 1101 kfree(mp); 1102 fdmi_cmd_exit: 1103 /* Issue FDMI request failed */ 1104 lpfc_printf_log(phba, 1105 KERN_INFO, 1106 LOG_DISCOVERY, 1107 "%d:0244 Issue FDMI request failed Data: x%x\n", 1108 phba->brd_no, 1109 cmdcode); 1110 return 1; 1111 } 1112 1113 void 1114 lpfc_fdmi_tmo(unsigned long ptr) 1115 { 1116 struct lpfc_hba *phba = (struct lpfc_hba *)ptr; 1117 unsigned long iflag; 1118 1119 spin_lock_irqsave(phba->host->host_lock, iflag); 1120 if (!(phba->work_hba_events & WORKER_FDMI_TMO)) { 1121 phba->work_hba_events |= WORKER_FDMI_TMO; 1122 if (phba->work_wait) 1123 wake_up(phba->work_wait); 1124 } 1125 spin_unlock_irqrestore(phba->host->host_lock,iflag); 1126 } 1127 1128 void 1129 lpfc_fdmi_tmo_handler(struct lpfc_hba *phba) 1130 { 1131 struct lpfc_nodelist *ndlp; 1132 1133 spin_lock_irq(phba->host->host_lock); 1134 if (!(phba->work_hba_events & WORKER_FDMI_TMO)) { 1135 spin_unlock_irq(phba->host->host_lock); 1136 return; 1137 } 1138 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, FDMI_DID); 1139 if (ndlp) { 1140 if (system_utsname.nodename[0] != '\0') { 1141 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_DHBA); 1142 } else { 1143 mod_timer(&phba->fc_fdmitmo, jiffies + HZ * 60); 1144 } 1145 } 1146 spin_unlock_irq(phba->host->host_lock); 1147 return; 1148 } 1149 1150 1151 void 1152 lpfc_decode_firmware_rev(struct lpfc_hba * phba, char *fwrevision, int flag) 1153 { 1154 struct lpfc_sli *psli = &phba->sli; 1155 lpfc_vpd_t *vp = &phba->vpd; 1156 uint32_t b1, b2, b3, b4, i, rev; 1157 char c; 1158 uint32_t *ptr, str[4]; 1159 uint8_t *fwname; 1160 1161 if (vp->rev.rBit) { 1162 if (psli->sli_flag & LPFC_SLI2_ACTIVE) 1163 rev = vp->rev.sli2FwRev; 1164 else 1165 rev = vp->rev.sli1FwRev; 1166 1167 b1 = (rev & 0x0000f000) >> 12; 1168 b2 = (rev & 0x00000f00) >> 8; 1169 b3 = (rev & 0x000000c0) >> 6; 1170 b4 = (rev & 0x00000030) >> 4; 1171 1172 switch (b4) { 1173 case 0: 1174 c = 'N'; 1175 break; 1176 case 1: 1177 c = 'A'; 1178 break; 1179 case 2: 1180 c = 'B'; 1181 break; 1182 default: 1183 c = 0; 1184 break; 1185 } 1186 b4 = (rev & 0x0000000f); 1187 1188 if (psli->sli_flag & LPFC_SLI2_ACTIVE) 1189 fwname = vp->rev.sli2FwName; 1190 else 1191 fwname = vp->rev.sli1FwName; 1192 1193 for (i = 0; i < 16; i++) 1194 if (fwname[i] == 0x20) 1195 fwname[i] = 0; 1196 1197 ptr = (uint32_t*)fwname; 1198 1199 for (i = 0; i < 3; i++) 1200 str[i] = be32_to_cpu(*ptr++); 1201 1202 if (c == 0) { 1203 if (flag) 1204 sprintf(fwrevision, "%d.%d%d (%s)", 1205 b1, b2, b3, (char *)str); 1206 else 1207 sprintf(fwrevision, "%d.%d%d", b1, 1208 b2, b3); 1209 } else { 1210 if (flag) 1211 sprintf(fwrevision, "%d.%d%d%c%d (%s)", 1212 b1, b2, b3, c, 1213 b4, (char *)str); 1214 else 1215 sprintf(fwrevision, "%d.%d%d%c%d", 1216 b1, b2, b3, c, b4); 1217 } 1218 } else { 1219 rev = vp->rev.smFwRev; 1220 1221 b1 = (rev & 0xff000000) >> 24; 1222 b2 = (rev & 0x00f00000) >> 20; 1223 b3 = (rev & 0x000f0000) >> 16; 1224 c = (rev & 0x0000ff00) >> 8; 1225 b4 = (rev & 0x000000ff); 1226 1227 if (flag) 1228 sprintf(fwrevision, "%d.%d%d%c%d ", b1, 1229 b2, b3, c, b4); 1230 else 1231 sprintf(fwrevision, "%d.%d%d%c%d ", b1, 1232 b2, b3, c, b4); 1233 } 1234 return; 1235 } 1236