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