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