1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2007 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
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 *******************************************************************/
22 * Fibre Channel SCSI LAN Device Driver CT support
25 #include <linux/blkdev.h>
26 #include <linux/pci.h>
27 #include <linux/interrupt.h>
28 #include <linux/utsname.h>
30 #include <scsi/scsi.h>
31 #include <scsi/scsi_device.h>
32 #include <scsi/scsi_host.h>
33 #include <scsi/scsi_transport_fc.h>
37 #include "lpfc_disc.h"
38 #include "lpfc_scsi.h"
40 #include "lpfc_logmsg.h"
41 #include "lpfc_crtn.h"
42 #include "lpfc_version.h"
43 #include "lpfc_vport.h"
44 #include "lpfc_debugfs.h"
46 #define HBA_PORTSPEED_UNKNOWN 0 /* Unknown - transceiver
47 * incapable of reporting */
48 #define HBA_PORTSPEED_1GBIT 1 /* 1 GBit/sec */
49 #define HBA_PORTSPEED_2GBIT 2 /* 2 GBit/sec */
50 #define HBA_PORTSPEED_4GBIT 8 /* 4 GBit/sec */
51 #define HBA_PORTSPEED_8GBIT 16 /* 8 GBit/sec */
52 #define HBA_PORTSPEED_10GBIT 4 /* 10 GBit/sec */
53 #define HBA_PORTSPEED_NOT_NEGOTIATED 5 /* Speed not established */
58 static char *lpfc_release_version
= LPFC_DRIVER_VERSION
;
64 lpfc_ct_unsol_buffer(struct lpfc_hba
*phba
, struct lpfc_iocbq
*piocbq
,
65 struct lpfc_dmabuf
*mp
, uint32_t size
)
68 printk(KERN_ERR
"%s (%d): Unsolited CT, no buffer, "
69 "piocbq = %p, status = x%x, mp = %p, size = %d\n",
70 __FUNCTION__
, __LINE__
,
71 piocbq
, piocbq
->iocb
.ulpStatus
, mp
, size
);
74 printk(KERN_ERR
"%s (%d): Ignoring unsolicted CT piocbq = %p, "
75 "buffer = %p, size = %d, status = x%x\n",
76 __FUNCTION__
, __LINE__
,
78 piocbq
->iocb
.ulpStatus
);
83 lpfc_ct_ignore_hbq_buffer(struct lpfc_hba
*phba
, struct lpfc_iocbq
*piocbq
,
84 struct lpfc_dmabuf
*mp
, uint32_t size
)
87 printk(KERN_ERR
"%s (%d): Unsolited CT, no "
88 "HBQ buffer, piocbq = %p, status = x%x\n",
89 __FUNCTION__
, __LINE__
,
90 piocbq
, piocbq
->iocb
.ulpStatus
);
92 lpfc_ct_unsol_buffer(phba
, piocbq
, mp
, size
);
93 printk(KERN_ERR
"%s (%d): Ignoring unsolicted CT "
94 "piocbq = %p, buffer = %p, size = %d, "
96 __FUNCTION__
, __LINE__
,
97 piocbq
, mp
, size
, piocbq
->iocb
.ulpStatus
);
102 lpfc_ct_unsol_event(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
103 struct lpfc_iocbq
*piocbq
)
106 struct lpfc_dmabuf
*mp
= NULL
;
107 IOCB_t
*icmd
= &piocbq
->iocb
;
109 struct lpfc_iocbq
*iocbq
;
112 struct lpfc_dmabuf
*bdeBuf1
= piocbq
->context2
;
113 struct lpfc_dmabuf
*bdeBuf2
= piocbq
->context3
;
115 piocbq
->context2
= NULL
;
116 piocbq
->context3
= NULL
;
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] & 0xff) == IOERR_RCV_BUFFER_WAITING
)) {
122 /* Not enough posted buffers; Try posting more buffers */
123 phba
->fc_stat
.NoRcvBuf
++;
124 if (!(phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
))
125 lpfc_post_buffer(phba
, pring
, 0, 1);
129 /* If there are no BDEs associated with this IOCB,
130 * there is nothing to do.
132 if (icmd
->ulpBdeCount
== 0)
135 if (phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
) {
136 list_for_each_entry(iocbq
, &piocbq
->list
, list
) {
138 if (icmd
->ulpBdeCount
== 0) {
139 printk(KERN_ERR
"%s (%d): Unsolited CT, no "
140 "BDE, iocbq = %p, status = x%x\n",
141 __FUNCTION__
, __LINE__
,
142 iocbq
, iocbq
->iocb
.ulpStatus
);
146 size
= icmd
->un
.cont64
[0].tus
.f
.bdeSize
;
147 lpfc_ct_ignore_hbq_buffer(phba
, piocbq
, bdeBuf1
, size
);
148 lpfc_in_buf_free(phba
, bdeBuf1
);
149 if (icmd
->ulpBdeCount
== 2) {
150 lpfc_ct_ignore_hbq_buffer(phba
, piocbq
, bdeBuf2
,
152 lpfc_in_buf_free(phba
, bdeBuf2
);
156 struct lpfc_iocbq
*next
;
158 list_for_each_entry_safe(iocbq
, next
, &piocbq
->list
, list
) {
160 if (icmd
->ulpBdeCount
== 0) {
161 printk(KERN_ERR
"%s (%d): Unsolited CT, no "
162 "BDE, iocbq = %p, status = x%x\n",
163 __FUNCTION__
, __LINE__
,
164 iocbq
, iocbq
->iocb
.ulpStatus
);
168 for (i
= 0; i
< icmd
->ulpBdeCount
; i
++) {
169 paddr
= getPaddr(icmd
->un
.cont64
[i
].addrHigh
,
170 icmd
->un
.cont64
[i
].addrLow
);
171 mp
= lpfc_sli_ringpostbuf_get(phba
, pring
,
173 size
= icmd
->un
.cont64
[i
].tus
.f
.bdeSize
;
174 lpfc_ct_unsol_buffer(phba
, piocbq
, mp
, size
);
175 lpfc_in_buf_free(phba
, mp
);
177 list_del(&iocbq
->list
);
178 lpfc_sli_release_iocbq(phba
, iocbq
);
184 lpfc_free_ct_rsp(struct lpfc_hba
*phba
, struct lpfc_dmabuf
*mlist
)
186 struct lpfc_dmabuf
*mlast
, *next_mlast
;
188 list_for_each_entry_safe(mlast
, next_mlast
, &mlist
->list
, list
) {
189 lpfc_mbuf_free(phba
, mlast
->virt
, mlast
->phys
);
190 list_del(&mlast
->list
);
193 lpfc_mbuf_free(phba
, mlist
->virt
, mlist
->phys
);
198 static struct lpfc_dmabuf
*
199 lpfc_alloc_ct_rsp(struct lpfc_hba
*phba
, int cmdcode
, struct ulp_bde64
*bpl
,
200 uint32_t size
, int *entries
)
202 struct lpfc_dmabuf
*mlist
= NULL
;
203 struct lpfc_dmabuf
*mp
;
206 /* We get chucks of FCELSSIZE */
207 cnt
= size
> FCELSSIZE
? FCELSSIZE
: size
;
210 /* Allocate buffer for rsp payload */
211 mp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
214 lpfc_free_ct_rsp(phba
, mlist
);
218 INIT_LIST_HEAD(&mp
->list
);
220 if (cmdcode
== be16_to_cpu(SLI_CTNS_GID_FT
) ||
221 cmdcode
== be16_to_cpu(SLI_CTNS_GFF_ID
))
222 mp
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
, &(mp
->phys
));
224 mp
->virt
= lpfc_mbuf_alloc(phba
, 0, &(mp
->phys
));
229 lpfc_free_ct_rsp(phba
, mlist
);
233 /* Queue it to a linked list */
237 list_add_tail(&mp
->list
, &mlist
->list
);
239 bpl
->tus
.f
.bdeFlags
= BUFF_USE_RCV
;
240 /* build buffer ptr list for IOCB */
241 bpl
->addrLow
= le32_to_cpu(putPaddrLow(mp
->phys
) );
242 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(mp
->phys
) );
243 bpl
->tus
.f
.bdeSize
= (uint16_t) cnt
;
244 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
256 lpfc_ct_free_iocb(struct lpfc_hba
*phba
, struct lpfc_iocbq
*ctiocb
)
258 struct lpfc_dmabuf
*buf_ptr
;
260 if (ctiocb
->context1
) {
261 buf_ptr
= (struct lpfc_dmabuf
*) ctiocb
->context1
;
262 lpfc_mbuf_free(phba
, buf_ptr
->virt
, buf_ptr
->phys
);
264 ctiocb
->context1
= NULL
;
266 if (ctiocb
->context2
) {
267 lpfc_free_ct_rsp(phba
, (struct lpfc_dmabuf
*) ctiocb
->context2
);
268 ctiocb
->context2
= NULL
;
271 if (ctiocb
->context3
) {
272 buf_ptr
= (struct lpfc_dmabuf
*) ctiocb
->context3
;
273 lpfc_mbuf_free(phba
, buf_ptr
->virt
, buf_ptr
->phys
);
275 ctiocb
->context1
= NULL
;
277 lpfc_sli_release_iocbq(phba
, ctiocb
);
282 lpfc_gen_req(struct lpfc_vport
*vport
, struct lpfc_dmabuf
*bmp
,
283 struct lpfc_dmabuf
*inp
, struct lpfc_dmabuf
*outp
,
284 void (*cmpl
) (struct lpfc_hba
*, struct lpfc_iocbq
*,
285 struct lpfc_iocbq
*),
286 struct lpfc_nodelist
*ndlp
, uint32_t usr_flg
, uint32_t num_entry
,
287 uint32_t tmo
, uint8_t retry
)
289 struct lpfc_hba
*phba
= vport
->phba
;
290 struct lpfc_sli
*psli
= &phba
->sli
;
291 struct lpfc_sli_ring
*pring
= &psli
->ring
[LPFC_ELS_RING
];
293 struct lpfc_iocbq
*geniocb
;
296 /* Allocate buffer for command iocb */
297 geniocb
= lpfc_sli_get_iocbq(phba
);
302 icmd
= &geniocb
->iocb
;
303 icmd
->un
.genreq64
.bdl
.ulpIoTag32
= 0;
304 icmd
->un
.genreq64
.bdl
.addrHigh
= putPaddrHigh(bmp
->phys
);
305 icmd
->un
.genreq64
.bdl
.addrLow
= putPaddrLow(bmp
->phys
);
306 icmd
->un
.genreq64
.bdl
.bdeFlags
= BUFF_TYPE_BDL
;
307 icmd
->un
.genreq64
.bdl
.bdeSize
= (num_entry
* sizeof (struct ulp_bde64
));
310 geniocb
->context3
= NULL
;
312 geniocb
->context3
= (uint8_t *) bmp
;
314 /* Save for completion so we can release these resources */
315 geniocb
->context1
= (uint8_t *) inp
;
316 geniocb
->context2
= (uint8_t *) outp
;
318 /* Fill in payload, bp points to frame payload */
319 icmd
->ulpCommand
= CMD_GEN_REQUEST64_CR
;
321 /* Fill in rest of iocb */
322 icmd
->un
.genreq64
.w5
.hcsw
.Fctl
= (SI
| LA
);
323 icmd
->un
.genreq64
.w5
.hcsw
.Dfctl
= 0;
324 icmd
->un
.genreq64
.w5
.hcsw
.Rctl
= FC_UNSOL_CTL
;
325 icmd
->un
.genreq64
.w5
.hcsw
.Type
= FC_COMMON_TRANSPORT_ULP
;
328 /* FC spec states we need 3 * ratov for CT requests */
329 tmo
= (3 * phba
->fc_ratov
);
331 icmd
->ulpTimeout
= tmo
;
332 icmd
->ulpBdeCount
= 1;
334 icmd
->ulpClass
= CLASS3
;
335 icmd
->ulpContext
= ndlp
->nlp_rpi
;
337 if (phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) {
338 /* For GEN_REQUEST64_CR, use the RPI */
343 /* Issue GEN REQ IOCB for NPORT <did> */
344 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
345 "%d (%d):0119 Issue GEN REQ IOCB to NPORT x%x "
346 "Data: x%x x%x\n", phba
->brd_no
, vport
->vpi
,
347 ndlp
->nlp_DID
, icmd
->ulpIoTag
,
349 geniocb
->iocb_cmpl
= cmpl
;
350 geniocb
->drvrTimeout
= icmd
->ulpTimeout
+ LPFC_DRVR_TIMEOUT
;
351 geniocb
->vport
= vport
;
352 geniocb
->retry
= retry
;
353 rc
= lpfc_sli_issue_iocb(phba
, pring
, geniocb
, 0);
355 if (rc
== IOCB_ERROR
) {
356 lpfc_sli_release_iocbq(phba
, geniocb
);
364 lpfc_ct_cmd(struct lpfc_vport
*vport
, struct lpfc_dmabuf
*inmp
,
365 struct lpfc_dmabuf
*bmp
, struct lpfc_nodelist
*ndlp
,
366 void (*cmpl
) (struct lpfc_hba
*, struct lpfc_iocbq
*,
367 struct lpfc_iocbq
*),
368 uint32_t rsp_size
, uint8_t retry
)
370 struct lpfc_hba
*phba
= vport
->phba
;
371 struct ulp_bde64
*bpl
= (struct ulp_bde64
*) bmp
->virt
;
372 struct lpfc_dmabuf
*outmp
;
374 int cmdcode
= ((struct lpfc_sli_ct_request
*) inmp
->virt
)->
375 CommandResponse
.bits
.CmdRsp
;
377 bpl
++; /* Skip past ct request */
379 /* Put buffer(s) for ct rsp in bpl */
380 outmp
= lpfc_alloc_ct_rsp(phba
, cmdcode
, bpl
, rsp_size
, &cnt
);
384 status
= lpfc_gen_req(vport
, bmp
, inmp
, outmp
, cmpl
, ndlp
, 0,
387 lpfc_free_ct_rsp(phba
, outmp
);
393 static struct lpfc_vport
*
394 lpfc_find_vport_by_did(struct lpfc_hba
*phba
, uint32_t did
) {
396 struct lpfc_vport
*vport_curr
;
398 list_for_each_entry(vport_curr
, &phba
->port_list
, listentry
) {
399 if ((vport_curr
->fc_myDID
) &&
400 (vport_curr
->fc_myDID
== did
))
408 lpfc_ns_rsp(struct lpfc_vport
*vport
, struct lpfc_dmabuf
*mp
, uint32_t Size
)
410 struct lpfc_hba
*phba
= vport
->phba
;
411 struct lpfc_sli_ct_request
*Response
=
412 (struct lpfc_sli_ct_request
*) mp
->virt
;
413 struct lpfc_nodelist
*ndlp
= NULL
;
414 struct lpfc_dmabuf
*mlast
, *next_mp
;
415 uint32_t *ctptr
= (uint32_t *) & Response
->un
.gid
.PortType
;
416 uint32_t Did
, CTentry
;
418 struct list_head head
;
420 lpfc_set_disctmo(vport
);
421 vport
->num_disc_nodes
= 0;
424 list_add_tail(&head
, &mp
->list
);
425 list_for_each_entry_safe(mp
, next_mp
, &head
, list
) {
428 Cnt
= Size
> FCELSSIZE
? FCELSSIZE
: Size
;
433 ctptr
= (uint32_t *) mlast
->virt
;
435 Cnt
-= 16; /* subtract length of CT header */
437 /* Loop through entire NameServer list of DIDs */
438 while (Cnt
>= sizeof (uint32_t)) {
439 /* Get next DID from NameServer List */
441 Did
= ((be32_to_cpu(CTentry
)) & Mask_DID
);
446 * Check for rscn processing or not
447 * To conserve rpi's, filter out addresses for other
448 * vports on the same physical HBAs.
450 if ((Did
!= vport
->fc_myDID
) &&
451 ((lpfc_find_vport_by_did(phba
, Did
) == NULL
) ||
452 phba
->cfg_peer_port_login
)) {
453 if ((vport
->port_type
!= LPFC_NPIV_PORT
) ||
454 (vport
->fc_flag
& FC_RFF_NOT_SUPPORTED
) ||
455 (!phba
->cfg_vport_restrict_login
)) {
456 ndlp
= lpfc_setup_disc_node(vport
, Did
);
458 lpfc_debugfs_disc_trc(vport
,
461 "did:x%x flg:x%x x%x",
465 lpfc_printf_log(phba
, KERN_INFO
,
467 "%d (%d):0238 Process "
469 "Data: x%x x%x x%x\n",
474 vport
->fc_rscn_id_cnt
);
476 lpfc_debugfs_disc_trc(vport
,
479 "did:x%x flg:x%x cnt:%d",
481 vport
->fc_rscn_id_cnt
);
483 lpfc_printf_log(phba
, KERN_INFO
,
485 "%d (%d):0239 Skip x%x "
486 "NameServer Rsp Data: "
491 vport
->fc_rscn_id_cnt
);
495 if (!(vport
->fc_flag
& FC_RSCN_MODE
) ||
496 (lpfc_rscn_payload_check(vport
, Did
))) {
497 lpfc_debugfs_disc_trc(vport
,
500 "did:x%x flg:x%x cnt:%d",
502 vport
->fc_rscn_id_cnt
);
504 if (lpfc_ns_cmd(vport
,
507 vport
->num_disc_nodes
++;
510 lpfc_debugfs_disc_trc(vport
,
513 "did:x%x flg:x%x cnt:%d",
515 vport
->fc_rscn_id_cnt
);
517 lpfc_printf_log(phba
, KERN_INFO
,
519 "%d (%d):0245 Skip x%x "
520 "NameServer Rsp Data: "
525 vport
->fc_rscn_id_cnt
);
529 if (CTentry
& (be32_to_cpu(SLI_CT_LAST_ENTRY
)))
531 Cnt
-= sizeof (uint32_t);
543 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
544 struct lpfc_iocbq
*rspiocb
)
546 struct lpfc_vport
*vport
= cmdiocb
->vport
;
547 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
549 struct lpfc_dmabuf
*bmp
;
550 struct lpfc_dmabuf
*outp
;
551 struct lpfc_sli_ct_request
*CTrsp
;
554 /* we pass cmdiocb to state machine which needs rspiocb as well */
555 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
557 outp
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
558 bmp
= (struct lpfc_dmabuf
*) cmdiocb
->context3
;
559 irsp
= &rspiocb
->iocb
;
561 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_CT
,
562 "GID_FT cmpl: status:x%x/x%x rtry:%d",
563 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4], vport
->fc_ns_retry
);
565 /* Don't bother processing response if vport is being torn down. */
566 if (vport
->load_flag
& FC_UNLOADING
)
570 if (lpfc_els_chk_latt(vport
) || lpfc_error_lost_link(irsp
)) {
571 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
572 "%d (%d):0216 Link event during NS query\n",
573 phba
->brd_no
, vport
->vpi
);
574 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
578 if (irsp
->ulpStatus
) {
579 /* Check for retry */
580 if (vport
->fc_ns_retry
< LPFC_MAX_NS_RETRY
) {
581 if ((irsp
->ulpStatus
!= IOSTAT_LOCAL_REJECT
) ||
582 (irsp
->un
.ulpWord
[4] != IOERR_NO_RESOURCES
))
583 vport
->fc_ns_retry
++;
584 /* CT command is being retried */
585 rc
= lpfc_ns_cmd(vport
, SLI_CTNS_GID_FT
,
586 vport
->fc_ns_retry
, 0);
590 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
591 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
592 "%d (%d):0257 GID_FT Query error: 0x%x 0x%x\n",
593 phba
->brd_no
, vport
->vpi
, irsp
->ulpStatus
,
596 /* Good status, continue checking */
597 CTrsp
= (struct lpfc_sli_ct_request
*) outp
->virt
;
598 if (CTrsp
->CommandResponse
.bits
.CmdRsp
==
599 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC
)) {
600 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
601 "%d (%d):0208 NameServer Rsp "
603 phba
->brd_no
, vport
->vpi
,
605 lpfc_ns_rsp(vport
, outp
,
606 (uint32_t) (irsp
->un
.genreq64
.bdl
.bdeSize
));
607 } else if (CTrsp
->CommandResponse
.bits
.CmdRsp
==
608 be16_to_cpu(SLI_CT_RESPONSE_FS_RJT
)) {
609 /* NameServer Rsp Error */
610 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
611 "%d (%d):0240 NameServer Rsp Error "
612 "Data: x%x x%x x%x x%x\n",
613 phba
->brd_no
, vport
->vpi
,
614 CTrsp
->CommandResponse
.bits
.CmdRsp
,
615 (uint32_t) CTrsp
->ReasonCode
,
616 (uint32_t) CTrsp
->Explanation
,
619 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_CT
,
620 "GID_FT rsp err1 cmd:x%x rsn:x%x exp:x%x",
621 (uint32_t)CTrsp
->CommandResponse
.bits
.CmdRsp
,
622 (uint32_t) CTrsp
->ReasonCode
,
623 (uint32_t) CTrsp
->Explanation
);
626 /* NameServer Rsp Error */
627 lpfc_printf_log(phba
, KERN_ERR
, LOG_DISCOVERY
,
628 "%d (%d):0241 NameServer Rsp Error "
629 "Data: x%x x%x x%x x%x\n",
630 phba
->brd_no
, vport
->vpi
,
631 CTrsp
->CommandResponse
.bits
.CmdRsp
,
632 (uint32_t) CTrsp
->ReasonCode
,
633 (uint32_t) CTrsp
->Explanation
,
636 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_CT
,
637 "GID_FT rsp err2 cmd:x%x rsn:x%x exp:x%x",
638 (uint32_t)CTrsp
->CommandResponse
.bits
.CmdRsp
,
639 (uint32_t) CTrsp
->ReasonCode
,
640 (uint32_t) CTrsp
->Explanation
);
643 /* Link up / RSCN discovery */
644 if (vport
->num_disc_nodes
== 0) {
646 * The driver has cycled through all Nports in the RSCN payload.
647 * Complete the handling by cleaning up and marking the
648 * current driver state.
650 if (vport
->port_state
>= LPFC_DISC_AUTH
) {
651 if (vport
->fc_flag
& FC_RSCN_MODE
) {
652 lpfc_els_flush_rscn(vport
);
653 spin_lock_irq(shost
->host_lock
);
654 vport
->fc_flag
|= FC_RSCN_MODE
; /* RSCN still */
655 spin_unlock_irq(shost
->host_lock
);
658 lpfc_els_flush_rscn(vport
);
661 lpfc_disc_start(vport
);
664 lpfc_ct_free_iocb(phba
, cmdiocb
);
669 lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
670 struct lpfc_iocbq
*rspiocb
)
672 struct lpfc_vport
*vport
= cmdiocb
->vport
;
673 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
674 IOCB_t
*irsp
= &rspiocb
->iocb
;
675 struct lpfc_dmabuf
*inp
= (struct lpfc_dmabuf
*) cmdiocb
->context1
;
676 struct lpfc_dmabuf
*outp
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
677 struct lpfc_sli_ct_request
*CTrsp
;
680 struct lpfc_nodelist
*ndlp
;
682 did
= ((struct lpfc_sli_ct_request
*) inp
->virt
)->un
.gff
.PortId
;
683 did
= be32_to_cpu(did
);
685 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_CT
,
686 "GFF_ID cmpl: status:x%x/x%x did:x%x",
687 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4], did
);
689 if (irsp
->ulpStatus
== IOSTAT_SUCCESS
) {
690 /* Good status, continue checking */
691 CTrsp
= (struct lpfc_sli_ct_request
*) outp
->virt
;
692 fbits
= CTrsp
->un
.gff_acc
.fbits
[FCP_TYPE_FEATURE_OFFSET
];
694 if (CTrsp
->CommandResponse
.bits
.CmdRsp
==
695 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC
)) {
696 if ((fbits
& FC4_FEATURE_INIT
) &&
697 !(fbits
& FC4_FEATURE_TARGET
)) {
698 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
699 "%d (%d):0245 Skip x%x GFF "
700 "NameServer Rsp Data: (init) "
701 "x%x x%x\n", phba
->brd_no
,
702 vport
->vpi
, did
, fbits
,
703 vport
->fc_rscn_id_cnt
);
709 lpfc_printf_log(phba
, KERN_ERR
, LOG_DISCOVERY
,
710 "%d (%d):0267 NameServer GFF Rsp"
711 " x%x Error (%d %d) Data: x%x x%x\n",
712 phba
->brd_no
, vport
->vpi
, did
,
713 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
714 vport
->fc_flag
, vport
->fc_rscn_id_cnt
)
717 /* This is a target port, unregistered port, or the GFF_ID failed */
718 ndlp
= lpfc_setup_disc_node(vport
, did
);
720 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
721 "%d (%d):0242 Process x%x GFF "
722 "NameServer Rsp Data: x%x x%x x%x\n",
723 phba
->brd_no
, vport
->vpi
,
724 did
, ndlp
->nlp_flag
, vport
->fc_flag
,
725 vport
->fc_rscn_id_cnt
);
727 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
728 "%d (%d):0243 Skip x%x GFF "
729 "NameServer Rsp Data: x%x x%x\n",
730 phba
->brd_no
, vport
->vpi
, did
,
731 vport
->fc_flag
, vport
->fc_rscn_id_cnt
);
734 /* Link up / RSCN discovery */
735 if (vport
->num_disc_nodes
)
736 vport
->num_disc_nodes
--;
737 if (vport
->num_disc_nodes
== 0) {
739 * The driver has cycled through all Nports in the RSCN payload.
740 * Complete the handling by cleaning up and marking the
741 * current driver state.
743 if (vport
->port_state
>= LPFC_DISC_AUTH
) {
744 if (vport
->fc_flag
& FC_RSCN_MODE
) {
745 lpfc_els_flush_rscn(vport
);
746 spin_lock_irq(shost
->host_lock
);
747 vport
->fc_flag
|= FC_RSCN_MODE
; /* RSCN still */
748 spin_unlock_irq(shost
->host_lock
);
751 lpfc_els_flush_rscn(vport
);
753 lpfc_disc_start(vport
);
755 lpfc_ct_free_iocb(phba
, cmdiocb
);
761 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
762 struct lpfc_iocbq
*rspiocb
)
764 struct lpfc_vport
*vport
= cmdiocb
->vport
;
765 struct lpfc_dmabuf
*inp
;
766 struct lpfc_dmabuf
*outp
;
768 struct lpfc_sli_ct_request
*CTrsp
;
773 /* we pass cmdiocb to state machine which needs rspiocb as well */
774 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
776 inp
= (struct lpfc_dmabuf
*) cmdiocb
->context1
;
777 outp
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
778 irsp
= &rspiocb
->iocb
;
780 cmdcode
= be16_to_cpu(((struct lpfc_sli_ct_request
*) inp
->virt
)->
781 CommandResponse
.bits
.CmdRsp
);
782 CTrsp
= (struct lpfc_sli_ct_request
*) outp
->virt
;
784 latt
= lpfc_els_chk_latt(vport
);
786 /* RFT request completes status <ulpStatus> CmdRsp <CmdRsp> */
787 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
788 "%d (%d):0209 RFT request completes, latt %d, "
789 "ulpStatus x%x CmdRsp x%x, Context x%x, Tag x%x\n",
790 phba
->brd_no
, vport
->vpi
, latt
, irsp
->ulpStatus
,
791 CTrsp
->CommandResponse
.bits
.CmdRsp
,
792 cmdiocb
->iocb
.ulpContext
, cmdiocb
->iocb
.ulpIoTag
);
794 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_CT
,
795 "CT cmd cmpl: status:x%x/x%x cmd:x%x",
796 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4], cmdcode
);
798 if (irsp
->ulpStatus
) {
799 lpfc_printf_log(phba
, KERN_ERR
, LOG_DISCOVERY
,
800 "%d (%d):0268 NS cmd %x Error (%d %d)\n",
801 phba
->brd_no
, vport
->vpi
, cmdcode
,
802 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4]);
804 if ((irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
805 ((irsp
->un
.ulpWord
[4] == IOERR_SLI_DOWN
) ||
806 (irsp
->un
.ulpWord
[4] == IOERR_SLI_ABORTED
)))
809 retry
= cmdiocb
->retry
;
810 if (retry
>= LPFC_MAX_NS_RETRY
)
814 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
815 "%d (%d):0216 Retrying NS cmd %x\n",
816 phba
->brd_no
, vport
->vpi
, cmdcode
);
817 rc
= lpfc_ns_cmd(vport
, cmdcode
, retry
, 0);
823 lpfc_ct_free_iocb(phba
, cmdiocb
);
828 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
829 struct lpfc_iocbq
*rspiocb
)
831 lpfc_cmpl_ct_cmd_rft_id(phba
, cmdiocb
, rspiocb
);
836 lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
837 struct lpfc_iocbq
*rspiocb
)
839 lpfc_cmpl_ct_cmd_rft_id(phba
, cmdiocb
, rspiocb
);
844 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
845 struct lpfc_iocbq
*rspiocb
)
847 lpfc_cmpl_ct_cmd_rft_id(phba
, cmdiocb
, rspiocb
);
852 lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
853 struct lpfc_iocbq
*rspiocb
)
855 IOCB_t
*irsp
= &rspiocb
->iocb
;
856 struct lpfc_vport
*vport
= cmdiocb
->vport
;
858 if (irsp
->ulpStatus
!= IOSTAT_SUCCESS
)
859 vport
->fc_flag
|= FC_RFF_NOT_SUPPORTED
;
861 lpfc_cmpl_ct_cmd_rft_id(phba
, cmdiocb
, rspiocb
);
866 lpfc_vport_symbolic_port_name(struct lpfc_vport
*vport
, char *symbol
,
870 uint8_t *wwn
= vport
->phba
->wwpn
;
872 n
= snprintf(symbol
, size
,
873 "Emulex PPN-%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
874 wwn
[0], wwn
[1], wwn
[2], wwn
[3],
875 wwn
[4], wwn
[5], wwn
[6], wwn
[7]);
877 if (vport
->port_type
== LPFC_PHYSICAL_PORT
)
881 n
+= snprintf(symbol
+ n
, size
- n
, " VPort-%d", vport
->vpi
);
883 if (n
< size
&& vport
->vname
)
884 n
+= snprintf(symbol
+ n
, size
- n
, " VName-%s", vport
->vname
);
889 lpfc_vport_symbolic_node_name(struct lpfc_vport
*vport
, char *symbol
,
895 lpfc_decode_firmware_rev(vport
->phba
, fwrev
, 0);
897 n
= snprintf(symbol
, size
, "Emulex %s FV%s DV%s",
898 vport
->phba
->ModelName
, fwrev
, lpfc_release_version
);
905 * Issue Cmd to NameServer
910 lpfc_ns_cmd(struct lpfc_vport
*vport
, int cmdcode
,
911 uint8_t retry
, uint32_t context
)
913 struct lpfc_nodelist
* ndlp
;
914 struct lpfc_hba
*phba
= vport
->phba
;
915 struct lpfc_dmabuf
*mp
, *bmp
;
916 struct lpfc_sli_ct_request
*CtReq
;
917 struct ulp_bde64
*bpl
;
918 void (*cmpl
) (struct lpfc_hba
*, struct lpfc_iocbq
*,
919 struct lpfc_iocbq
*) = NULL
;
920 uint32_t rsp_size
= 1024;
924 ndlp
= lpfc_findnode_did(vport
, NameServer_DID
);
925 if (ndlp
== NULL
|| ndlp
->nlp_state
!= NLP_STE_UNMAPPED_NODE
) {
930 /* fill in BDEs for command */
931 /* Allocate buffer for command payload */
932 mp
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
938 INIT_LIST_HEAD(&mp
->list
);
939 mp
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
, &(mp
->phys
));
945 /* Allocate buffer for Buffer ptr list */
946 bmp
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
949 goto ns_cmd_free_mpvirt
;
952 INIT_LIST_HEAD(&bmp
->list
);
953 bmp
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
, &(bmp
->phys
));
956 goto ns_cmd_free_bmp
;
960 lpfc_printf_log(phba
, KERN_INFO
,LOG_DISCOVERY
,
961 "%d (%d):0236 NameServer Req Data: x%x x%x x%x\n",
962 phba
->brd_no
, vport
->vpi
, cmdcode
, vport
->fc_flag
,
963 vport
->fc_rscn_id_cnt
);
965 bpl
= (struct ulp_bde64
*) bmp
->virt
;
966 memset(bpl
, 0, sizeof(struct ulp_bde64
));
967 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(mp
->phys
) );
968 bpl
->addrLow
= le32_to_cpu(putPaddrLow(mp
->phys
) );
969 bpl
->tus
.f
.bdeFlags
= 0;
970 if (cmdcode
== SLI_CTNS_GID_FT
)
971 bpl
->tus
.f
.bdeSize
= GID_REQUEST_SZ
;
972 else if (cmdcode
== SLI_CTNS_GFF_ID
)
973 bpl
->tus
.f
.bdeSize
= GFF_REQUEST_SZ
;
974 else if (cmdcode
== SLI_CTNS_RFT_ID
)
975 bpl
->tus
.f
.bdeSize
= RFT_REQUEST_SZ
;
976 else if (cmdcode
== SLI_CTNS_RNN_ID
)
977 bpl
->tus
.f
.bdeSize
= RNN_REQUEST_SZ
;
978 else if (cmdcode
== SLI_CTNS_RSPN_ID
)
979 bpl
->tus
.f
.bdeSize
= RSPN_REQUEST_SZ
;
980 else if (cmdcode
== SLI_CTNS_RSNN_NN
)
981 bpl
->tus
.f
.bdeSize
= RSNN_REQUEST_SZ
;
982 else if (cmdcode
== SLI_CTNS_RFF_ID
)
983 bpl
->tus
.f
.bdeSize
= RFF_REQUEST_SZ
;
985 bpl
->tus
.f
.bdeSize
= 0;
986 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
988 CtReq
= (struct lpfc_sli_ct_request
*) mp
->virt
;
989 memset(CtReq
, 0, sizeof (struct lpfc_sli_ct_request
));
990 CtReq
->RevisionId
.bits
.Revision
= SLI_CT_REVISION
;
991 CtReq
->RevisionId
.bits
.InId
= 0;
992 CtReq
->FsType
= SLI_CT_DIRECTORY_SERVICE
;
993 CtReq
->FsSubType
= SLI_CT_DIRECTORY_NAME_SERVER
;
994 CtReq
->CommandResponse
.bits
.Size
= 0;
996 case SLI_CTNS_GID_FT
:
997 CtReq
->CommandResponse
.bits
.CmdRsp
=
998 be16_to_cpu(SLI_CTNS_GID_FT
);
999 CtReq
->un
.gid
.Fc4Type
= SLI_CTPT_FCP
;
1000 if (vport
->port_state
< LPFC_NS_QRY
)
1001 vport
->port_state
= LPFC_NS_QRY
;
1002 lpfc_set_disctmo(vport
);
1003 cmpl
= lpfc_cmpl_ct_cmd_gid_ft
;
1004 rsp_size
= FC_MAX_NS_RSP
;
1007 case SLI_CTNS_GFF_ID
:
1008 CtReq
->CommandResponse
.bits
.CmdRsp
=
1009 be16_to_cpu(SLI_CTNS_GFF_ID
);
1010 CtReq
->un
.gff
.PortId
= be32_to_cpu(context
);
1011 cmpl
= lpfc_cmpl_ct_cmd_gff_id
;
1014 case SLI_CTNS_RFT_ID
:
1015 CtReq
->CommandResponse
.bits
.CmdRsp
=
1016 be16_to_cpu(SLI_CTNS_RFT_ID
);
1017 CtReq
->un
.rft
.PortId
= be32_to_cpu(vport
->fc_myDID
);
1018 CtReq
->un
.rft
.fcpReg
= 1;
1019 cmpl
= lpfc_cmpl_ct_cmd_rft_id
;
1022 case SLI_CTNS_RNN_ID
:
1023 CtReq
->CommandResponse
.bits
.CmdRsp
=
1024 be16_to_cpu(SLI_CTNS_RNN_ID
);
1025 CtReq
->un
.rnn
.PortId
= be32_to_cpu(vport
->fc_myDID
);
1026 memcpy(CtReq
->un
.rnn
.wwnn
, &vport
->fc_nodename
,
1027 sizeof (struct lpfc_name
));
1028 cmpl
= lpfc_cmpl_ct_cmd_rnn_id
;
1031 case SLI_CTNS_RSPN_ID
:
1032 CtReq
->CommandResponse
.bits
.CmdRsp
=
1033 be16_to_cpu(SLI_CTNS_RSPN_ID
);
1034 CtReq
->un
.rspn
.PortId
= be32_to_cpu(vport
->fc_myDID
);
1035 size
= sizeof(CtReq
->un
.rspn
.symbname
);
1036 CtReq
->un
.rspn
.len
=
1037 lpfc_vport_symbolic_port_name(vport
,
1038 CtReq
->un
.rspn
.symbname
, size
);
1039 cmpl
= lpfc_cmpl_ct_cmd_rspn_id
;
1041 case SLI_CTNS_RSNN_NN
:
1042 CtReq
->CommandResponse
.bits
.CmdRsp
=
1043 be16_to_cpu(SLI_CTNS_RSNN_NN
);
1044 memcpy(CtReq
->un
.rsnn
.wwnn
, &vport
->fc_nodename
,
1045 sizeof (struct lpfc_name
));
1046 size
= sizeof(CtReq
->un
.rsnn
.symbname
);
1047 CtReq
->un
.rsnn
.len
=
1048 lpfc_vport_symbolic_node_name(vport
,
1049 CtReq
->un
.rsnn
.symbname
, size
);
1050 cmpl
= lpfc_cmpl_ct_cmd_rsnn_nn
;
1052 case SLI_CTNS_RFF_ID
:
1053 vport
->fc_flag
&= ~FC_RFF_NOT_SUPPORTED
;
1054 CtReq
->CommandResponse
.bits
.CmdRsp
=
1055 be16_to_cpu(SLI_CTNS_RFF_ID
);
1056 CtReq
->un
.rff
.PortId
= be32_to_cpu(vport
->fc_myDID
);;
1057 CtReq
->un
.rff
.fbits
= FC4_FEATURE_INIT
;
1058 CtReq
->un
.rff
.type_code
= FC_FCP_DATA
;
1059 cmpl
= lpfc_cmpl_ct_cmd_rff_id
;
1063 if (!lpfc_ct_cmd(vport
, mp
, bmp
, ndlp
, cmpl
, rsp_size
, retry
)) {
1064 /* On success, The cmpl function will free the buffers */
1065 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_CT
,
1066 "Issue CT cmd: cmd:x%x did:x%x",
1067 cmdcode
, ndlp
->nlp_DID
, 0);
1072 lpfc_mbuf_free(phba
, bmp
->virt
, bmp
->phys
);
1076 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
1080 lpfc_printf_log(phba
, KERN_ERR
, LOG_DISCOVERY
,
1081 "%d (%d):0266 Issue NameServer Req x%x err %d Data: x%x x%x\n",
1082 phba
->brd_no
, vport
->vpi
, cmdcode
, rc
, vport
->fc_flag
,
1083 vport
->fc_rscn_id_cnt
);
1088 lpfc_cmpl_ct_cmd_fdmi(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
1089 struct lpfc_iocbq
* rspiocb
)
1091 struct lpfc_dmabuf
*inp
= cmdiocb
->context1
;
1092 struct lpfc_dmabuf
*outp
= cmdiocb
->context2
;
1093 struct lpfc_sli_ct_request
*CTrsp
= outp
->virt
;
1094 struct lpfc_sli_ct_request
*CTcmd
= inp
->virt
;
1095 struct lpfc_nodelist
*ndlp
;
1096 uint16_t fdmi_cmd
= CTcmd
->CommandResponse
.bits
.CmdRsp
;
1097 uint16_t fdmi_rsp
= CTrsp
->CommandResponse
.bits
.CmdRsp
;
1098 struct lpfc_vport
*vport
= cmdiocb
->vport
;
1099 IOCB_t
*irsp
= &rspiocb
->iocb
;
1102 latt
= lpfc_els_chk_latt(vport
);
1104 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_CT
,
1105 "FDMI cmpl: status:x%x/x%x latt:%d",
1106 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4], latt
);
1108 if (latt
|| irsp
->ulpStatus
) {
1109 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
1110 "%d (%d):0229 FDMI cmd %04x failed, latt = %d "
1111 "ulpStatus: x%x, rid x%x\n",
1112 phba
->brd_no
, vport
->vpi
,
1113 be16_to_cpu(fdmi_cmd
), latt
, irsp
->ulpStatus
,
1114 irsp
->un
.ulpWord
[4]);
1115 lpfc_ct_free_iocb(phba
, cmdiocb
);
1119 ndlp
= lpfc_findnode_did(vport
, FDMI_DID
);
1120 if (fdmi_rsp
== be16_to_cpu(SLI_CT_RESPONSE_FS_RJT
)) {
1121 /* FDMI rsp failed */
1122 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
1123 "%d (%d):0220 FDMI rsp failed Data: x%x\n",
1124 phba
->brd_no
, vport
->vpi
,
1125 be16_to_cpu(fdmi_cmd
));
1128 switch (be16_to_cpu(fdmi_cmd
)) {
1130 lpfc_fdmi_cmd(vport
, ndlp
, SLI_MGMT_RPA
);
1137 lpfc_fdmi_cmd(vport
, ndlp
, SLI_MGMT_DPRT
);
1141 lpfc_fdmi_cmd(vport
, ndlp
, SLI_MGMT_RHBA
);
1144 lpfc_ct_free_iocb(phba
, cmdiocb
);
1149 lpfc_fdmi_cmd(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
, int cmdcode
)
1151 struct lpfc_hba
*phba
= vport
->phba
;
1152 struct lpfc_dmabuf
*mp
, *bmp
;
1153 struct lpfc_sli_ct_request
*CtReq
;
1154 struct ulp_bde64
*bpl
;
1158 REG_PORT_ATTRIBUTE
*pab
;
1159 ATTRIBUTE_BLOCK
*ab
;
1160 ATTRIBUTE_ENTRY
*ae
;
1161 void (*cmpl
) (struct lpfc_hba
*, struct lpfc_iocbq
*,
1162 struct lpfc_iocbq
*);
1165 /* fill in BDEs for command */
1166 /* Allocate buffer for command payload */
1167 mp
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
1171 mp
->virt
= lpfc_mbuf_alloc(phba
, 0, &(mp
->phys
));
1173 goto fdmi_cmd_free_mp
;
1175 /* Allocate buffer for Buffer ptr list */
1176 bmp
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
1178 goto fdmi_cmd_free_mpvirt
;
1180 bmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &(bmp
->phys
));
1182 goto fdmi_cmd_free_bmp
;
1184 INIT_LIST_HEAD(&mp
->list
);
1185 INIT_LIST_HEAD(&bmp
->list
);
1188 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
1189 "%d (%d):0218 FDMI Request Data: x%x x%x x%x\n",
1190 phba
->brd_no
, vport
->vpi
, vport
->fc_flag
,
1191 vport
->port_state
, cmdcode
);
1193 CtReq
= (struct lpfc_sli_ct_request
*) mp
->virt
;
1195 memset(CtReq
, 0, sizeof(struct lpfc_sli_ct_request
));
1196 CtReq
->RevisionId
.bits
.Revision
= SLI_CT_REVISION
;
1197 CtReq
->RevisionId
.bits
.InId
= 0;
1199 CtReq
->FsType
= SLI_CT_MANAGEMENT_SERVICE
;
1200 CtReq
->FsSubType
= SLI_CT_FDMI_Subtypes
;
1206 lpfc_vpd_t
*vp
= &phba
->vpd
;
1207 uint32_t i
, j
, incr
;
1210 CtReq
->CommandResponse
.bits
.CmdRsp
=
1211 be16_to_cpu(SLI_MGMT_RHBA
);
1212 CtReq
->CommandResponse
.bits
.Size
= 0;
1213 rh
= (REG_HBA
*) & CtReq
->un
.PortID
;
1214 memcpy(&rh
->hi
.PortName
, &vport
->fc_sparam
.portName
,
1215 sizeof (struct lpfc_name
));
1216 /* One entry (port) per adapter */
1217 rh
->rpl
.EntryCnt
= be32_to_cpu(1);
1218 memcpy(&rh
->rpl
.pe
, &vport
->fc_sparam
.portName
,
1219 sizeof (struct lpfc_name
));
1221 /* point to the HBA attribute block */
1222 size
= 2 * sizeof (struct lpfc_name
) + FOURBYTES
;
1223 ab
= (ATTRIBUTE_BLOCK
*) ((uint8_t *) rh
+ size
);
1226 /* Point to the beginning of the first HBA attribute
1228 /* #1 HBA attribute entry */
1230 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1231 ae
->ad
.bits
.AttrType
= be16_to_cpu(NODE_NAME
);
1232 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
1233 + sizeof (struct lpfc_name
));
1234 memcpy(&ae
->un
.NodeName
, &vport
->fc_sparam
.nodeName
,
1235 sizeof (struct lpfc_name
));
1237 size
+= FOURBYTES
+ sizeof (struct lpfc_name
);
1239 /* #2 HBA attribute entry */
1240 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1241 ae
->ad
.bits
.AttrType
= be16_to_cpu(MANUFACTURER
);
1242 strcpy(ae
->un
.Manufacturer
, "Emulex Corporation");
1243 len
= strlen(ae
->un
.Manufacturer
);
1244 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1245 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ len
);
1247 size
+= FOURBYTES
+ len
;
1249 /* #3 HBA attribute entry */
1250 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1251 ae
->ad
.bits
.AttrType
= be16_to_cpu(SERIAL_NUMBER
);
1252 strcpy(ae
->un
.SerialNumber
, phba
->SerialNumber
);
1253 len
= strlen(ae
->un
.SerialNumber
);
1254 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1255 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ len
);
1257 size
+= FOURBYTES
+ len
;
1259 /* #4 HBA attribute entry */
1260 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1261 ae
->ad
.bits
.AttrType
= be16_to_cpu(MODEL
);
1262 strcpy(ae
->un
.Model
, phba
->ModelName
);
1263 len
= strlen(ae
->un
.Model
);
1264 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1265 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ len
);
1267 size
+= FOURBYTES
+ len
;
1269 /* #5 HBA attribute entry */
1270 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1271 ae
->ad
.bits
.AttrType
= be16_to_cpu(MODEL_DESCRIPTION
);
1272 strcpy(ae
->un
.ModelDescription
, phba
->ModelDesc
);
1273 len
= strlen(ae
->un
.ModelDescription
);
1274 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1275 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ len
);
1277 size
+= FOURBYTES
+ len
;
1279 /* #6 HBA attribute entry */
1280 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1281 ae
->ad
.bits
.AttrType
= be16_to_cpu(HARDWARE_VERSION
);
1282 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ 8);
1283 /* Convert JEDEC ID to ascii for hardware version */
1284 incr
= vp
->rev
.biuRev
;
1285 for (i
= 0; i
< 8; i
++) {
1288 ae
->un
.HardwareVersion
[7 - i
] =
1289 (char)((uint8_t) 0x30 +
1292 ae
->un
.HardwareVersion
[7 - i
] =
1293 (char)((uint8_t) 0x61 +
1294 (uint8_t) (j
- 10));
1298 size
+= FOURBYTES
+ 8;
1300 /* #7 HBA attribute entry */
1301 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1302 ae
->ad
.bits
.AttrType
= be16_to_cpu(DRIVER_VERSION
);
1303 strcpy(ae
->un
.DriverVersion
, lpfc_release_version
);
1304 len
= strlen(ae
->un
.DriverVersion
);
1305 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1306 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ len
);
1308 size
+= FOURBYTES
+ len
;
1310 /* #8 HBA attribute entry */
1311 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1312 ae
->ad
.bits
.AttrType
= be16_to_cpu(OPTION_ROM_VERSION
);
1313 strcpy(ae
->un
.OptionROMVersion
, phba
->OptionROMVersion
);
1314 len
= strlen(ae
->un
.OptionROMVersion
);
1315 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1316 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ len
);
1318 size
+= FOURBYTES
+ len
;
1320 /* #9 HBA attribute entry */
1321 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1322 ae
->ad
.bits
.AttrType
= be16_to_cpu(FIRMWARE_VERSION
);
1323 lpfc_decode_firmware_rev(phba
, ae
->un
.FirmwareVersion
,
1325 len
= strlen(ae
->un
.FirmwareVersion
);
1326 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1327 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ len
);
1329 size
+= FOURBYTES
+ len
;
1331 /* #10 HBA attribute entry */
1332 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1333 ae
->ad
.bits
.AttrType
= be16_to_cpu(OS_NAME_VERSION
);
1334 sprintf(ae
->un
.OsNameVersion
, "%s %s %s",
1335 init_utsname()->sysname
,
1336 init_utsname()->release
,
1337 init_utsname()->version
);
1338 len
= strlen(ae
->un
.OsNameVersion
);
1339 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1340 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ len
);
1342 size
+= FOURBYTES
+ len
;
1344 /* #11 HBA attribute entry */
1345 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) rh
+ size
);
1346 ae
->ad
.bits
.AttrType
= be16_to_cpu(MAX_CT_PAYLOAD_LEN
);
1347 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ 4);
1348 ae
->un
.MaxCTPayloadLen
= (65 * 4096);
1350 size
+= FOURBYTES
+ 4;
1352 ab
->EntryCnt
= be32_to_cpu(ab
->EntryCnt
);
1354 size
= GID_REQUEST_SZ
- 4 + size
;
1361 struct serv_parm
*hsp
;
1366 CtReq
->CommandResponse
.bits
.CmdRsp
=
1367 be16_to_cpu(SLI_MGMT_RPA
);
1368 CtReq
->CommandResponse
.bits
.Size
= 0;
1369 pab
= (REG_PORT_ATTRIBUTE
*) & CtReq
->un
.PortID
;
1370 size
= sizeof (struct lpfc_name
) + FOURBYTES
;
1371 memcpy((uint8_t *) & pab
->PortName
,
1372 (uint8_t *) & vport
->fc_sparam
.portName
,
1373 sizeof (struct lpfc_name
));
1374 pab
->ab
.EntryCnt
= 0;
1376 /* #1 Port attribute entry */
1377 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) pab
+ size
);
1378 ae
->ad
.bits
.AttrType
= be16_to_cpu(SUPPORTED_FC4_TYPES
);
1379 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ 32);
1380 ae
->un
.SupportFC4Types
[2] = 1;
1381 ae
->un
.SupportFC4Types
[7] = 1;
1383 size
+= FOURBYTES
+ 32;
1385 /* #2 Port attribute entry */
1386 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) pab
+ size
);
1387 ae
->ad
.bits
.AttrType
= be16_to_cpu(SUPPORTED_SPEED
);
1388 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ 4);
1390 ae
->un
.SupportSpeed
= 0;
1391 if (phba
->lmt
& LMT_10Gb
)
1392 ae
->un
.SupportSpeed
= HBA_PORTSPEED_10GBIT
;
1393 if (phba
->lmt
& LMT_8Gb
)
1394 ae
->un
.SupportSpeed
|= HBA_PORTSPEED_8GBIT
;
1395 if (phba
->lmt
& LMT_4Gb
)
1396 ae
->un
.SupportSpeed
|= HBA_PORTSPEED_4GBIT
;
1397 if (phba
->lmt
& LMT_2Gb
)
1398 ae
->un
.SupportSpeed
|= HBA_PORTSPEED_2GBIT
;
1399 if (phba
->lmt
& LMT_1Gb
)
1400 ae
->un
.SupportSpeed
|= HBA_PORTSPEED_1GBIT
;
1403 size
+= FOURBYTES
+ 4;
1405 /* #3 Port attribute entry */
1406 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) pab
+ size
);
1407 ae
->ad
.bits
.AttrType
= be16_to_cpu(PORT_SPEED
);
1408 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ 4);
1409 switch(phba
->fc_linkspeed
) {
1411 ae
->un
.PortSpeed
= HBA_PORTSPEED_1GBIT
;
1414 ae
->un
.PortSpeed
= HBA_PORTSPEED_2GBIT
;
1417 ae
->un
.PortSpeed
= HBA_PORTSPEED_4GBIT
;
1420 ae
->un
.PortSpeed
= HBA_PORTSPEED_8GBIT
;
1424 HBA_PORTSPEED_UNKNOWN
;
1428 size
+= FOURBYTES
+ 4;
1430 /* #4 Port attribute entry */
1431 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) pab
+ size
);
1432 ae
->ad
.bits
.AttrType
= be16_to_cpu(MAX_FRAME_SIZE
);
1433 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ 4);
1434 hsp
= (struct serv_parm
*) & vport
->fc_sparam
;
1435 ae
->un
.MaxFrameSize
=
1436 (((uint32_t) hsp
->cmn
.
1437 bbRcvSizeMsb
) << 8) | (uint32_t) hsp
->cmn
.
1440 size
+= FOURBYTES
+ 4;
1442 /* #5 Port attribute entry */
1443 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) pab
+ size
);
1444 ae
->ad
.bits
.AttrType
= be16_to_cpu(OS_DEVICE_NAME
);
1445 strcpy((char *)ae
->un
.OsDeviceName
, LPFC_DRIVER_NAME
);
1446 len
= strlen((char *)ae
->un
.OsDeviceName
);
1447 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1448 ae
->ad
.bits
.AttrLen
= be16_to_cpu(FOURBYTES
+ len
);
1450 size
+= FOURBYTES
+ len
;
1452 if (phba
->cfg_fdmi_on
== 2) {
1453 /* #6 Port attribute entry */
1454 ae
= (ATTRIBUTE_ENTRY
*) ((uint8_t *) pab
+
1456 ae
->ad
.bits
.AttrType
= be16_to_cpu(HOST_NAME
);
1457 sprintf(ae
->un
.HostName
, "%s",
1458 init_utsname()->nodename
);
1459 len
= strlen(ae
->un
.HostName
);
1460 len
+= (len
& 3) ? (4 - (len
& 3)) : 4;
1461 ae
->ad
.bits
.AttrLen
=
1462 be16_to_cpu(FOURBYTES
+ len
);
1464 size
+= FOURBYTES
+ len
;
1467 pab
->ab
.EntryCnt
= be32_to_cpu(pab
->ab
.EntryCnt
);
1469 size
= GID_REQUEST_SZ
- 4 + size
;
1474 CtReq
->CommandResponse
.bits
.CmdRsp
= be16_to_cpu(SLI_MGMT_DHBA
);
1475 CtReq
->CommandResponse
.bits
.Size
= 0;
1476 pe
= (PORT_ENTRY
*) & CtReq
->un
.PortID
;
1477 memcpy((uint8_t *) & pe
->PortName
,
1478 (uint8_t *) & vport
->fc_sparam
.portName
,
1479 sizeof (struct lpfc_name
));
1480 size
= GID_REQUEST_SZ
- 4 + sizeof (struct lpfc_name
);
1484 CtReq
->CommandResponse
.bits
.CmdRsp
= be16_to_cpu(SLI_MGMT_DPRT
);
1485 CtReq
->CommandResponse
.bits
.Size
= 0;
1486 pe
= (PORT_ENTRY
*) & CtReq
->un
.PortID
;
1487 memcpy((uint8_t *) & pe
->PortName
,
1488 (uint8_t *) & vport
->fc_sparam
.portName
,
1489 sizeof (struct lpfc_name
));
1490 size
= GID_REQUEST_SZ
- 4 + sizeof (struct lpfc_name
);
1494 bpl
= (struct ulp_bde64
*) bmp
->virt
;
1495 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(mp
->phys
) );
1496 bpl
->addrLow
= le32_to_cpu(putPaddrLow(mp
->phys
) );
1497 bpl
->tus
.f
.bdeFlags
= 0;
1498 bpl
->tus
.f
.bdeSize
= size
;
1499 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
1501 cmpl
= lpfc_cmpl_ct_cmd_fdmi
;
1503 if (!lpfc_ct_cmd(vport
, mp
, bmp
, ndlp
, cmpl
, FC_MAX_NS_RSP
, 0))
1506 lpfc_mbuf_free(phba
, bmp
->virt
, bmp
->phys
);
1509 fdmi_cmd_free_mpvirt
:
1510 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
1514 /* Issue FDMI request failed */
1515 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
1516 "%d (%d):0244 Issue FDMI request failed Data: x%x\n",
1517 phba
->brd_no
, vport
->vpi
, cmdcode
);
1522 lpfc_fdmi_tmo(unsigned long ptr
)
1524 struct lpfc_vport
*vport
= (struct lpfc_vport
*)ptr
;
1525 struct lpfc_hba
*phba
= vport
->phba
;
1526 unsigned long iflag
;
1528 spin_lock_irqsave(&vport
->work_port_lock
, iflag
);
1529 if (!(vport
->work_port_events
& WORKER_FDMI_TMO
)) {
1530 vport
->work_port_events
|= WORKER_FDMI_TMO
;
1531 spin_unlock_irqrestore(&vport
->work_port_lock
, iflag
);
1533 spin_lock_irqsave(&phba
->hbalock
, iflag
);
1534 if (phba
->work_wait
)
1535 lpfc_worker_wake_up(phba
);
1536 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
1539 spin_unlock_irqrestore(&vport
->work_port_lock
, iflag
);
1543 lpfc_fdmi_timeout_handler(struct lpfc_vport
*vport
)
1545 struct lpfc_nodelist
*ndlp
;
1547 ndlp
= lpfc_findnode_did(vport
, FDMI_DID
);
1549 if (init_utsname()->nodename
[0] != '\0')
1550 lpfc_fdmi_cmd(vport
, ndlp
, SLI_MGMT_DHBA
);
1552 mod_timer(&vport
->fc_fdmitmo
, jiffies
+ HZ
* 60);
1558 lpfc_decode_firmware_rev(struct lpfc_hba
*phba
, char *fwrevision
, int flag
)
1560 struct lpfc_sli
*psli
= &phba
->sli
;
1561 lpfc_vpd_t
*vp
= &phba
->vpd
;
1562 uint32_t b1
, b2
, b3
, b4
, i
, rev
;
1564 uint32_t *ptr
, str
[4];
1568 if (psli
->sli_flag
& LPFC_SLI2_ACTIVE
)
1569 rev
= vp
->rev
.sli2FwRev
;
1571 rev
= vp
->rev
.sli1FwRev
;
1573 b1
= (rev
& 0x0000f000) >> 12;
1574 b2
= (rev
& 0x00000f00) >> 8;
1575 b3
= (rev
& 0x000000c0) >> 6;
1576 b4
= (rev
& 0x00000030) >> 4;
1592 b4
= (rev
& 0x0000000f);
1594 if (psli
->sli_flag
& LPFC_SLI2_ACTIVE
)
1595 fwname
= vp
->rev
.sli2FwName
;
1597 fwname
= vp
->rev
.sli1FwName
;
1599 for (i
= 0; i
< 16; i
++)
1600 if (fwname
[i
] == 0x20)
1603 ptr
= (uint32_t*)fwname
;
1605 for (i
= 0; i
< 3; i
++)
1606 str
[i
] = be32_to_cpu(*ptr
++);
1610 sprintf(fwrevision
, "%d.%d%d (%s)",
1611 b1
, b2
, b3
, (char *)str
);
1613 sprintf(fwrevision
, "%d.%d%d", b1
,
1617 sprintf(fwrevision
, "%d.%d%d%c%d (%s)",
1621 sprintf(fwrevision
, "%d.%d%d%c%d",
1625 rev
= vp
->rev
.smFwRev
;
1627 b1
= (rev
& 0xff000000) >> 24;
1628 b2
= (rev
& 0x00f00000) >> 20;
1629 b3
= (rev
& 0x000f0000) >> 16;
1630 c
= (rev
& 0x0000ff00) >> 8;
1631 b4
= (rev
& 0x000000ff);
1634 sprintf(fwrevision
, "%d.%d%d%c%d ", b1
,
1637 sprintf(fwrevision
, "%d.%d%d%c%d ", b1
,