projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'tracing/hw-branch-tracing' into tracing/core
[deliverable/linux.git] / drivers / scsi / lpfc / lpfc_ct.c
CommitLineData
dea3101e 1/*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
c44ce173 3 * Fibre Channel Host Bus Adapters. *
e47c9093 4 * Copyright (C) 2004-2008 Emulex. All rights reserved. *
c44ce173 5 * EMULEX and SLI are trademarks of Emulex. *
dea3101e 6 * www.emulex.com *
7 * *
8 * This program is free software; you can redistribute it and/or *
c44ce173
JSEC		 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. *
dea3101e 19 *******************************************************************/
20
21/*
09372820 22 * Fibre Channel SCSI LAN Device Driver CT support: FC Generic Services FC-GS
dea3101e 23 */
24
25#include <linux/blkdev.h>
26#include <linux/pci.h>
27#include <linux/interrupt.h>
28#include <linux/utsname.h>
29
91886523 30#include <scsi/scsi.h>
dea3101e 31#include <scsi/scsi_device.h>
32#include <scsi/scsi_host.h>
f888ba3c 33#include <scsi/scsi_transport_fc.h>
dea3101e 34
35#include "lpfc_hw.h"
36#include "lpfc_sli.h"
ea2151b4 37#include "lpfc_nl.h"
dea3101e 38#include "lpfc_disc.h"
39#include "lpfc_scsi.h"
40#include "lpfc.h"
41#include "lpfc_logmsg.h"
42#include "lpfc_crtn.h"
43#include "lpfc_version.h"
92d7f7b0 44#include "lpfc_vport.h"
858c9f6c 45#include "lpfc_debugfs.h"
dea3101e 46
47#define HBA_PORTSPEED_UNKNOWN 0 /* Unknown - transceiver
48 * incapable of reporting */
49#define HBA_PORTSPEED_1GBIT 1 /* 1 GBit/sec */
50#define HBA_PORTSPEED_2GBIT 2 /* 2 GBit/sec */
51#define HBA_PORTSPEED_4GBIT 8 /* 4 GBit/sec */
52#define HBA_PORTSPEED_8GBIT 16 /* 8 GBit/sec */
53#define HBA_PORTSPEED_10GBIT 4 /* 10 GBit/sec */
54#define HBA_PORTSPEED_NOT_NEGOTIATED 5 /* Speed not established */
55
56#define FOURBYTES 4
57
58
59static char *lpfc_release_version = LPFC_DRIVER_VERSION;
60
ed957684 61static void
9c2face6
JS		 62lpfc_ct_ignore_hbq_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
63 struct lpfc_dmabuf *mp, uint32_t size)
ed957684
JS		 64{
65 if (!mp) {
9c2face6 66 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
97eab634 67 "0146 Ignoring unsolicited CT No HBQ "
9c2face6
JS		 68 "status = x%x\n",
69 piocbq->iocb.ulpStatus);
ed957684 70 }
9c2face6
JS		 71 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
72 "0145 Ignoring unsolicted CT HBQ Size:%d "
73 "status = x%x\n",
74 size, piocbq->iocb.ulpStatus);
ed957684
JS		 75}
76
77static void
9c2face6
JS		 78lpfc_ct_unsol_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
79 struct lpfc_dmabuf *mp, uint32_t size)
ed957684 80{
9c2face6 81 lpfc_ct_ignore_hbq_buffer(phba, piocbq, mp, size);
ed957684
JS		 82}
83
dea3101e 84void
2e0fef85
JS		 85lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
86 struct lpfc_iocbq *piocbq)
dea3101e 87{
92d7f7b0 88
ed957684 89 struct lpfc_dmabuf *mp = NULL;
dea3101e 90 IOCB_t *icmd = &piocbq->iocb;
ed957684
JS		 91 int i;
92 struct lpfc_iocbq *iocbq;
93 dma_addr_t paddr;
94 uint32_t size;
9c2face6
JS		 95 struct list_head head;
96 struct lpfc_dmabuf *bdeBuf;
dea3101e 97
92d7f7b0
JS		 98 if (unlikely(icmd->ulpStatus == IOSTAT_NEED_BUFFER)) {
99 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
100 } else if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
101 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) {
dea3101e 102 /* Not enough posted buffers; Try posting more buffers */
103 phba->fc_stat.NoRcvBuf++;
92d7f7b0 104 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
495a714c 105 lpfc_post_buffer(phba, pring, 2);
dea3101e 106 return;
107 }
108
109 /* If there are no BDEs associated with this IOCB,
110 * there is nothing to do.
111 */
112 if (icmd->ulpBdeCount == 0)
113 return;
114
ed957684 115 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
9c2face6
JS		 116 INIT_LIST_HEAD(&head);
117 list_add_tail(&head, &piocbq->list);
118 list_for_each_entry(iocbq, &head, list) {
ed957684 119 icmd = &iocbq->iocb;
9c2face6 120 if (icmd->ulpBdeCount == 0)
ed957684 121 continue;
9c2face6
JS		 122 bdeBuf = iocbq->context2;
123 iocbq->context2 = NULL;
ed957684 124 size = icmd->un.cont64[0].tus.f.bdeSize;
9c2face6
JS		 125 lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf, size);
126 lpfc_in_buf_free(phba, bdeBuf);
ed957684 127 if (icmd->ulpBdeCount == 2) {
9c2face6
JS		 128 bdeBuf = iocbq->context3;
129 iocbq->context3 = NULL;
130 size = icmd->unsli3.rcvsli3.bde2.tus.f.bdeSize;
131 lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf,
132 size);
133 lpfc_in_buf_free(phba, bdeBuf);
ed957684 134 }
dea3101e 135 }
9c2face6 136 list_del(&head);
ed957684 137 } else {
d7c255b2
JS		 138 INIT_LIST_HEAD(&head);
139 list_add_tail(&head, &piocbq->list);
140 list_for_each_entry(iocbq, &head, list) {
ed957684 141 icmd = &iocbq->iocb;
9c2face6 142 if (icmd->ulpBdeCount == 0)
d7c255b2 143 lpfc_ct_unsol_buffer(phba, iocbq, NULL, 0);
ed957684
JS		 144 for (i = 0; i < icmd->ulpBdeCount; i++) {
145 paddr = getPaddr(icmd->un.cont64[i].addrHigh,
146 icmd->un.cont64[i].addrLow);
147 mp = lpfc_sli_ringpostbuf_get(phba, pring,
148 paddr);
149 size = icmd->un.cont64[i].tus.f.bdeSize;
d7c255b2 150 lpfc_ct_unsol_buffer(phba, iocbq, mp, size);
92d7f7b0 151 lpfc_in_buf_free(phba, mp);
ed957684 152 }
495a714c 153 lpfc_post_buffer(phba, pring, i);
dea3101e 154 }
d7c255b2 155 list_del(&head);
dea3101e 156 }
dea3101e 157}
158
159static void
2e0fef85 160lpfc_free_ct_rsp(struct lpfc_hba *phba, struct lpfc_dmabuf *mlist)
dea3101e 161{
162 struct lpfc_dmabuf *mlast, *next_mlast;
163
164 list_for_each_entry_safe(mlast, next_mlast, &mlist->list, list) {
165 lpfc_mbuf_free(phba, mlast->virt, mlast->phys);
166 list_del(&mlast->list);
167 kfree(mlast);
168 }
169 lpfc_mbuf_free(phba, mlist->virt, mlist->phys);
170 kfree(mlist);
171 return;
172}
173
174static struct lpfc_dmabuf *
2e0fef85 175lpfc_alloc_ct_rsp(struct lpfc_hba *phba, int cmdcode, struct ulp_bde64 *bpl,
dea3101e 176 uint32_t size, int *entries)
177{
178 struct lpfc_dmabuf *mlist = NULL;
179 struct lpfc_dmabuf *mp;
180 int cnt, i = 0;
181
09372820 182 /* We get chunks of FCELSSIZE */
dea3101e 183 cnt = size > FCELSSIZE ? FCELSSIZE: size;
184
185 while (size) {
186 /* Allocate buffer for rsp payload */
187 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
188 if (!mp) {
189 if (mlist)
190 lpfc_free_ct_rsp(phba, mlist);
191 return NULL;
192 }
193
194 INIT_LIST_HEAD(&mp->list);
195
92d7f7b0
JS		 196 if (cmdcode == be16_to_cpu(SLI_CTNS_GID_FT) ||
197 cmdcode == be16_to_cpu(SLI_CTNS_GFF_ID))
dea3101e 198 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
199 else
200 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
201
202 if (!mp->virt) {
203 kfree(mp);
0b3a82d3
ES		 204 if (mlist)
205 lpfc_free_ct_rsp(phba, mlist);
dea3101e 206 return NULL;
207 }
208
209 /* Queue it to a linked list */
210 if (!mlist)
211 mlist = mp;
212 else
213 list_add_tail(&mp->list, &mlist->list);
214
34b02dcd 215 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
dea3101e 216 /* build buffer ptr list for IOCB */
92d7f7b0
JS		 217 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
218 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
dea3101e 219 bpl->tus.f.bdeSize = (uint16_t) cnt;
220 bpl->tus.w = le32_to_cpu(bpl->tus.w);
221 bpl++;
222
223 i++;
224 size -= cnt;
225 }
226
227 *entries = i;
228 return mlist;
229}
230
858c9f6c
JS		 231int
232lpfc_ct_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocb)
233{
234 struct lpfc_dmabuf *buf_ptr;
235
51ef4c26
JS		 236 if (ctiocb->context_un.ndlp) {
237 lpfc_nlp_put(ctiocb->context_un.ndlp);
238 ctiocb->context_un.ndlp = NULL;
239 }
858c9f6c
JS		 240 if (ctiocb->context1) {
241 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context1;
242 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
243 kfree(buf_ptr);
244 ctiocb->context1 = NULL;
245 }
246 if (ctiocb->context2) {
247 lpfc_free_ct_rsp(phba, (struct lpfc_dmabuf *) ctiocb->context2);
248 ctiocb->context2 = NULL;
249 }
250
251 if (ctiocb->context3) {
252 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context3;
253 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
254 kfree(buf_ptr);
255 ctiocb->context1 = NULL;
256 }
257 lpfc_sli_release_iocbq(phba, ctiocb);
258 return 0;
259}
260
dea3101e 261static int
2e0fef85 262lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,
dea3101e 263 struct lpfc_dmabuf *inp, struct lpfc_dmabuf *outp,
264 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
265 struct lpfc_iocbq *),
266 struct lpfc_nodelist *ndlp, uint32_t usr_flg, uint32_t num_entry,
92d7f7b0 267 uint32_t tmo, uint8_t retry)
dea3101e 268{
2e0fef85
JS		 269 struct lpfc_hba *phba = vport->phba;
270 struct lpfc_sli *psli = &phba->sli;
dea3101e 271 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
dea3101e 272 IOCB_t *icmd;
0bd4ca25 273 struct lpfc_iocbq *geniocb;
92d7f7b0 274 int rc;
dea3101e 275
276 /* Allocate buffer for command iocb */
0bd4ca25 277 geniocb = lpfc_sli_get_iocbq(phba);
dea3101e 278
279 if (geniocb == NULL)
280 return 1;
dea3101e 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);
34b02dcd 286 icmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
dea3101e 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;
e47c9093 297 geniocb->context_un.ndlp = lpfc_nlp_get(ndlp);
dea3101e 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
c9f8735b
JW		 308 if (!tmo) {
309 /* FC spec states we need 3 * ratov for CT requests */
310 tmo = (3 * phba->fc_ratov);
311 }
dea3101e 312 icmd->ulpTimeout = tmo;
313 icmd->ulpBdeCount = 1;
314 icmd->ulpLe = 1;
315 icmd->ulpClass = CLASS3;
316 icmd->ulpContext = ndlp->nlp_rpi;
317
92d7f7b0
JS		 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
dea3101e 324 /* Issue GEN REQ IOCB for NPORT <did> */
e8b62011
JS		 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);
dea3101e 330 geniocb->iocb_cmpl = cmpl;
331 geniocb->drvrTimeout = icmd->ulpTimeout + LPFC_DRVR_TIMEOUT;
2e0fef85 332 geniocb->vport = vport;
92d7f7b0
JS		 333 geniocb->retry = retry;
334 rc = lpfc_sli_issue_iocb(phba, pring, geniocb, 0);
335
336 if (rc == IOCB_ERROR) {
604a3e30 337 lpfc_sli_release_iocbq(phba, geniocb);
dea3101e 338 return 1;
339 }
dea3101e 340
341 return 0;
342}
343
344static int
2e0fef85 345lpfc_ct_cmd(struct lpfc_vport *vport, struct lpfc_dmabuf *inmp,
dea3101e 346 struct lpfc_dmabuf *bmp, struct lpfc_nodelist *ndlp,
347 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
348 struct lpfc_iocbq *),
92d7f7b0 349 uint32_t rsp_size, uint8_t retry)
dea3101e 350{
2e0fef85 351 struct lpfc_hba *phba = vport->phba;
dea3101e 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
2e0fef85 365 status = lpfc_gen_req(vport, bmp, inmp, outmp, cmpl, ndlp, 0,
92d7f7b0 366 cnt+1, 0, retry);
dea3101e 367 if (status) {
368 lpfc_free_ct_rsp(phba, outmp);
369 return -ENOMEM;
370 }
371 return 0;
372}
373
549e55cd 374struct lpfc_vport *
92d7f7b0 375lpfc_find_vport_by_did(struct lpfc_hba *phba, uint32_t did) {
92d7f7b0 376 struct lpfc_vport *vport_curr;
549e55cd 377 unsigned long flags;
92d7f7b0 378
549e55cd 379 spin_lock_irqsave(&phba->hbalock, flags);
92d7f7b0 380 list_for_each_entry(vport_curr, &phba->port_list, listentry) {
549e55cd
JS		 381 if ((vport_curr->fc_myDID) && (vport_curr->fc_myDID == did)) {
382 spin_unlock_irqrestore(&phba->hbalock, flags);
92d7f7b0 383 return vport_curr;
549e55cd 384 }
92d7f7b0 385 }
549e55cd 386 spin_unlock_irqrestore(&phba->hbalock, flags);
92d7f7b0
JS		 387 return NULL;
388}
389
dea3101e 390static int
2e0fef85 391lpfc_ns_rsp(struct lpfc_vport *vport, struct lpfc_dmabuf *mp, uint32_t Size)
dea3101e 392{
2e0fef85 393 struct lpfc_hba *phba = vport->phba;
dea3101e 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;
2e0fef85 399 uint32_t Did, CTentry;
dea3101e 400 int Cnt;
401 struct list_head head;
402
2e0fef85 403 lpfc_set_disctmo(vport);
92d7f7b0 404 vport->num_disc_nodes = 0;
0ff10d46 405 vport->fc_ns_retry = 0;
dea3101e 406
dea3101e 407
408 list_add_tail(&head, &mp->list);
409 list_for_each_entry_safe(mp, next_mp, &head, list) {
410 mlast = mp;
411
7054a606
JS		 412 Cnt = Size > FCELSSIZE ? FCELSSIZE : Size;
413
dea3101e 414 Size -= Cnt;
415
1dcb58e5 416 if (!ctptr) {
dea3101e 417 ctptr = (uint32_t *) mlast->virt;
1dcb58e5 418 } else
dea3101e 419 Cnt -= 16; /* subtract length of CT header */
420
421 /* Loop through entire NameServer list of DIDs */
7054a606 422 while (Cnt >= sizeof (uint32_t)) {
dea3101e 423 /* Get next DID from NameServer List */
424 CTentry = *ctptr++;
425 Did = ((be32_to_cpu(CTentry)) & Mask_DID);
92d7f7b0 426
dea3101e 427 ndlp = NULL;
92d7f7b0
JS		 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) ||
3de2a653 436 vport->cfg_peer_port_login)) {
92d7f7b0 437 if ((vport->port_type != LPFC_NPIV_PORT) ||
98c9ea5c 438 (!(vport->ct_flags & FC_CT_RFF_ID)) ||
3de2a653 439 (!vport->cfg_restrict_login)) {
92d7f7b0 440 ndlp = lpfc_setup_disc_node(vport, Did);
58da1ffb 441 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
858c9f6c
JS		 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
e8b62011
JS		 449 lpfc_printf_vlog(vport,
450 KERN_INFO,
92d7f7b0 451 LOG_DISCOVERY,
e8b62011 452 "0238 Process "
92d7f7b0
JS		 453 "x%x NameServer Rsp"
454 "Data: x%x x%x x%x\n",
e8b62011 455 Did, ndlp->nlp_flag,
92d7f7b0
JS		 456 vport->fc_flag,
457 vport->fc_rscn_id_cnt);
458 } else {
858c9f6c
JS		 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
e8b62011
JS		 466 lpfc_printf_vlog(vport,
467 KERN_INFO,
92d7f7b0 468 LOG_DISCOVERY,
e8b62011 469 "0239 Skip x%x "
92d7f7b0
JS		 470 "NameServer Rsp Data: "
471 "x%x x%x\n",
e8b62011 472 Did, vport->fc_flag,
92d7f7b0
JS		 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))) {
858c9f6c
JS		 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
0ff10d46
JS		 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);
e47c9093
JS		 492 if (ndlp &&
493 NLP_CHK_NODE_ACT(ndlp)
494 && (ndlp->nlp_type &
495 NLP_FCP_TARGET))
0ff10d46
JS		 496 lpfc_setup_disc_node
497 (vport, Did);
498 else if (lpfc_ns_cmd(vport,
92d7f7b0
JS		 499 SLI_CTNS_GFF_ID,
500 0, Did) == 0)
501 vport->num_disc_nodes++;
502 }
503 else {
858c9f6c
JS		 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
e8b62011
JS		 511 lpfc_printf_vlog(vport,
512 KERN_INFO,
92d7f7b0 513 LOG_DISCOVERY,
e8b62011 514 "0245 Skip x%x "
92d7f7b0
JS		 515 "NameServer Rsp Data: "
516 "x%x x%x\n",
e8b62011 517 Did, vport->fc_flag,
92d7f7b0
JS		 518 vport->fc_rscn_id_cnt);
519 }
520 }
dea3101e 521 }
dea3101e 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
530nsout1:
531 list_del(&head);
dea3101e 532 return 0;
533}
534
dea3101e 535static void
2e0fef85
JS		 536lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
537 struct lpfc_iocbq *rspiocb)
dea3101e 538{
2e0fef85 539 struct lpfc_vport *vport = cmdiocb->vport;
92d7f7b0 540 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e 541 IOCB_t *irsp;
dea3101e 542 struct lpfc_dmabuf *bmp;
dea3101e 543 struct lpfc_dmabuf *outp;
dea3101e 544 struct lpfc_sli_ct_request *CTrsp;
51ef4c26 545 struct lpfc_nodelist *ndlp;
58da1ffb 546 int rc;
dea3101e 547
51ef4c26
JS		 548 /* First save ndlp, before we overwrite it */
549 ndlp = cmdiocb->context_un.ndlp;
550
dea3101e 551 /* we pass cmdiocb to state machine which needs rspiocb as well */
552 cmdiocb->context_un.rsp_iocb = rspiocb;
553
dea3101e 554 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
555 bmp = (struct lpfc_dmabuf *) cmdiocb->context3;
858c9f6c
JS		 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);
dea3101e 561
92d7f7b0 562 /* Don't bother processing response if vport is being torn down. */
eada272d
JS		 563 if (vport->load_flag & FC_UNLOADING) {
564 if (vport->fc_flag & FC_RSCN_MODE)
565 lpfc_els_flush_rscn(vport);
92d7f7b0 566 goto out;
eada272d 567 }
92d7f7b0 568
58da1ffb 569 if (lpfc_els_chk_latt(vport)) {
e8b62011
JS		 570 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
571 "0216 Link event during NS query\n");
eada272d
JS		 572 if (vport->fc_flag & FC_RSCN_MODE)
573 lpfc_els_flush_rscn(vport);
858c9f6c
JS		 574 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
575 goto out;
576 }
58da1ffb
JS		 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");
eada272d
JS		 580 if (vport->fc_flag & FC_RSCN_MODE)
581 lpfc_els_flush_rscn(vport);
58da1ffb
JS		 582 goto out;
583 }
858c9f6c 584 if (irsp->ulpStatus) {
dea3101e 585 /* Check for retry */
2e0fef85 586 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
58da1ffb
JS		 587 if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT ||
588 irsp->un.ulpWord[4] != IOERR_NO_RESOURCES)
858c9f6c 589 vport->fc_ns_retry++;
0ff10d46 590
58da1ffb
JS		 591 /* CT command is being retried */
592 rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT,
92d7f7b0 593 vport->fc_ns_retry, 0);
58da1ffb
JS		 594 if (rc == 0)
595 goto out;
92d7f7b0 596 }
eada272d
JS		 597 if (vport->fc_flag & FC_RSCN_MODE)
598 lpfc_els_flush_rscn(vport);
92d7f7b0 599 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
e8b62011
JS		 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);
dea3101e 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)) {
e8b62011
JS		 608 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
609 "0208 NameServer Rsp Data: x%x\n",
610 vport->fc_flag);
2e0fef85 611 lpfc_ns_rsp(vport, outp,
dea3101e 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 */
a58cbd52
JS		 616 if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ)
617 && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) {
e8b62011
JS		 618 lpfc_printf_vlog(vport, KERN_INFO,
619 LOG_DISCOVERY,
620 "0269 No NameServer Entries "
a58cbd52 621 "Data: x%x x%x x%x x%x\n",
a58cbd52
JS		 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);
e8b62011
JS		 632 } else {
633 lpfc_printf_vlog(vport, KERN_INFO,
634 LOG_DISCOVERY,
635 "0240 NameServer Rsp Error "
dea3101e 636 "Data: x%x x%x x%x x%x\n",
dea3101e 637 CTrsp->CommandResponse.bits.CmdRsp,
638 (uint32_t) CTrsp->ReasonCode,
639 (uint32_t) CTrsp->Explanation,
2e0fef85 640 vport->fc_flag);
858c9f6c 641
a58cbd52 642 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
858c9f6c
JS		 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);
a58cbd52
JS		 647 }
648
858c9f6c 649
dea3101e 650 } else {
651 /* NameServer Rsp Error */
e8b62011
JS		 652 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
653 "0241 NameServer Rsp Error "
dea3101e 654 "Data: x%x x%x x%x x%x\n",
dea3101e 655 CTrsp->CommandResponse.bits.CmdRsp,
656 (uint32_t) CTrsp->ReasonCode,
657 (uint32_t) CTrsp->Explanation,
2e0fef85 658 vport->fc_flag);
858c9f6c
JS		 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);
dea3101e 665 }
666 }
667 /* Link up / RSCN discovery */
92d7f7b0
JS		 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 }
687out:
51ef4c26 688 cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */
858c9f6c 689 lpfc_ct_free_iocb(phba, cmdiocb);
92d7f7b0
JS		 690 return;
691}
692
311464ec 693static void
92d7f7b0
JS		 694lpfc_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;
92d7f7b0
JS		 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;
0ff10d46 703 int did, rc, retry;
92d7f7b0
JS		 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
858c9f6c
JS		 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
92d7f7b0
JS		 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)) {
e8b62011
JS		 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);
92d7f7b0
JS		 729 goto out;
730 }
731 }
732 }
858c9f6c 733 else {
0ff10d46
JS		 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 }
e8b62011
JS		 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],
7f5f3d0d 771 vport->fc_flag, vport->fc_rscn_id_cnt);
858c9f6c
JS		 772 }
773
92d7f7b0
JS		 774 /* This is a target port, unregistered port, or the GFF_ID failed */
775 ndlp = lpfc_setup_disc_node(vport, did);
58da1ffb 776 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
e8b62011
JS		 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);
92d7f7b0 782 } else {
e8b62011
JS		 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);
92d7f7b0 787 }
dea3101e 788out:
92d7f7b0
JS		 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 }
858c9f6c 810 lpfc_ct_free_iocb(phba, cmdiocb);
dea3101e 811 return;
812}
813
92d7f7b0 814
dea3101e 815static void
7ee5d43e
JS		 816lpfc_cmpl_ct(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
817 struct lpfc_iocbq *rspiocb)
dea3101e 818{
92d7f7b0 819 struct lpfc_vport *vport = cmdiocb->vport;
dea3101e 820 struct lpfc_dmabuf *inp;
821 struct lpfc_dmabuf *outp;
822 IOCB_t *irsp;
823 struct lpfc_sli_ct_request *CTrsp;
51ef4c26 824 struct lpfc_nodelist *ndlp;
92d7f7b0
JS		 825 int cmdcode, rc;
826 uint8_t retry;
858c9f6c 827 uint32_t latt;
dea3101e 828
51ef4c26
JS		 829 /* First save ndlp, before we overwrite it */
830 ndlp = cmdiocb->context_un.ndlp;
831
dea3101e 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;
dea3101e 837 irsp = &rspiocb->iocb;
838
92d7f7b0
JS		 839 cmdcode = be16_to_cpu(((struct lpfc_sli_ct_request *) inp->virt)->
840 CommandResponse.bits.CmdRsp);
dea3101e 841 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
842
858c9f6c
JS		 843 latt = lpfc_els_chk_latt(vport);
844
845 /* RFT request completes status <ulpStatus> CmdRsp <CmdRsp> */
e8b62011 846 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
7ee5d43e 847 "0209 CT Request completes, latt %d, "
e8b62011
JS		 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);
dea3101e 852
858c9f6c
JS		 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
92d7f7b0 857 if (irsp->ulpStatus) {
e8b62011
JS		 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]);
858c9f6c 861
92d7f7b0
JS		 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++;
e8b62011 872 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
d7c255b2 873 "0250 Retrying NS cmd %x\n", cmdcode);
92d7f7b0
JS		 874 rc = lpfc_ns_cmd(vport, cmdcode, retry, 0);
875 if (rc == 0)
876 goto out;
877 }
878
879out:
51ef4c26 880 cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */
858c9f6c 881 lpfc_ct_free_iocb(phba, cmdiocb);
dea3101e 882 return;
883}
884
7ee5d43e
JS		 885static void
886lpfc_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
98c9ea5c
JS		 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 }
7ee5d43e
JS		 902 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
903 return;
904}
905
dea3101e 906static void
2e0fef85
JS		 907lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
908 struct lpfc_iocbq *rspiocb)
dea3101e 909{
7ee5d43e
JS		 910 IOCB_t *irsp = &rspiocb->iocb;
911 struct lpfc_vport *vport = cmdiocb->vport;
912
98c9ea5c
JS		 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 }
7ee5d43e 923 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
dea3101e 924 return;
925}
926
92d7f7b0
JS		 927static void
928lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
929 struct lpfc_iocbq *rspiocb)
930{
7ee5d43e
JS		 931 IOCB_t *irsp = &rspiocb->iocb;
932 struct lpfc_vport *vport = cmdiocb->vport;
933
98c9ea5c
JS		 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 }
7ee5d43e 944 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
92d7f7b0
JS		 945 return;
946}
947
dea3101e 948static void
2e0fef85
JS		 949lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
950 struct lpfc_iocbq *rspiocb)
dea3101e 951{
7ee5d43e
JS		 952 IOCB_t *irsp = &rspiocb->iocb;
953 struct lpfc_vport *vport = cmdiocb->vport;
954
98c9ea5c
JS		 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 }
7ee5d43e
JS		 965 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
966 return;
967}
968
969static void
970lpfc_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);
dea3101e 978 return;
979}
980
2fb9bd8b 981static void
92d7f7b0
JS		 982lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
983 struct lpfc_iocbq *rspiocb)
2fb9bd8b 984{
92d7f7b0
JS		 985 IOCB_t *irsp = &rspiocb->iocb;
986 struct lpfc_vport *vport = cmdiocb->vport;
987
98c9ea5c
JS		 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 }
7ee5d43e 998 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
2fb9bd8b
JS		 999 return;
1000}
1001
495a714c 1002int
92d7f7b0
JS		 1003lpfc_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
eada272d
JS		 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);
92d7f7b0
JS		 1024 return n;
1025}
1026
1027int
1028lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol,
1029 size_t size)
dea3101e 1030{
1031 char fwrev[16];
92d7f7b0 1032 int n;
dea3101e 1033
92d7f7b0 1034 lpfc_decode_firmware_rev(vport->phba, fwrev, 0);
dea3101e 1035
92d7f7b0
JS		 1036 n = snprintf(symbol, size, "Emulex %s FV%s DV%s",
1037 vport->phba->ModelName, fwrev, lpfc_release_version);
1038 return n;
dea3101e 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 */
1048int
92d7f7b0
JS		 1049lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode,
1050 uint8_t retry, uint32_t context)
dea3101e 1051{
92d7f7b0 1052 struct lpfc_nodelist * ndlp;
2e0fef85 1053 struct lpfc_hba *phba = vport->phba;
dea3101e 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;
92d7f7b0 1060 size_t size;
858c9f6c 1061 int rc = 0;
92d7f7b0
JS		 1062
1063 ndlp = lpfc_findnode_did(vport, NameServer_DID);
e47c9093
JS		 1064 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)
1065 || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) {
858c9f6c
JS		 1066 rc=1;
1067 goto ns_cmd_exit;
1068 }
dea3101e 1069
1070 /* fill in BDEs for command */
1071 /* Allocate buffer for command payload */
1072 mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
858c9f6c
JS		 1073 if (!mp) {
1074 rc=2;
dea3101e 1075 goto ns_cmd_exit;
858c9f6c 1076 }
dea3101e 1077
1078 INIT_LIST_HEAD(&mp->list);
1079 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
858c9f6c
JS		 1080 if (!mp->virt) {
1081 rc=3;
dea3101e 1082 goto ns_cmd_free_mp;
858c9f6c 1083 }
dea3101e 1084
1085 /* Allocate buffer for Buffer ptr list */
1086 bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
858c9f6c
JS		 1087 if (!bmp) {
1088 rc=4;
dea3101e 1089 goto ns_cmd_free_mpvirt;
858c9f6c 1090 }
dea3101e 1091
1092 INIT_LIST_HEAD(&bmp->list);
1093 bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys));
858c9f6c
JS		 1094 if (!bmp->virt) {
1095 rc=5;
dea3101e 1096 goto ns_cmd_free_bmp;
858c9f6c 1097 }
dea3101e 1098
1099 /* NameServer Req */
e8b62011
JS		 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);
dea3101e 1103
1104 bpl = (struct ulp_bde64 *) bmp->virt;
1105 memset(bpl, 0, sizeof(struct ulp_bde64));
92d7f7b0
JS		 1106 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1107 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
dea3101e 1108 bpl->tus.f.bdeFlags = 0;
1109 if (cmdcode == SLI_CTNS_GID_FT)
1110 bpl->tus.f.bdeSize = GID_REQUEST_SZ;
92d7f7b0
JS		 1111 else if (cmdcode == SLI_CTNS_GFF_ID)
1112 bpl->tus.f.bdeSize = GFF_REQUEST_SZ;
dea3101e 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;
92d7f7b0
JS		 1117 else if (cmdcode == SLI_CTNS_RSPN_ID)
1118 bpl->tus.f.bdeSize = RSPN_REQUEST_SZ;
dea3101e 1119 else if (cmdcode == SLI_CTNS_RSNN_NN)
1120 bpl->tus.f.bdeSize = RSNN_REQUEST_SZ;
7ee5d43e
JS		 1121 else if (cmdcode == SLI_CTNS_DA_ID)
1122 bpl->tus.f.bdeSize = DA_ID_REQUEST_SZ;
2fb9bd8b
JS		 1123 else if (cmdcode == SLI_CTNS_RFF_ID)
1124 bpl->tus.f.bdeSize = RFF_REQUEST_SZ;
dea3101e 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;
92d7f7b0 1141 if (vport->port_state < LPFC_NS_QRY)
2e0fef85
JS		 1142 vport->port_state = LPFC_NS_QRY;
1143 lpfc_set_disctmo(vport);
dea3101e 1144 cmpl = lpfc_cmpl_ct_cmd_gid_ft;
1145 rsp_size = FC_MAX_NS_RSP;
1146 break;
1147
92d7f7b0
JS		 1148 case SLI_CTNS_GFF_ID:
1149 CtReq->CommandResponse.bits.CmdRsp =
1150 be16_to_cpu(SLI_CTNS_GFF_ID);
09372820 1151 CtReq->un.gff.PortId = cpu_to_be32(context);
92d7f7b0
JS		 1152 cmpl = lpfc_cmpl_ct_cmd_gff_id;
1153 break;
1154
dea3101e 1155 case SLI_CTNS_RFT_ID:
7ee5d43e 1156 vport->ct_flags &= ~FC_CT_RFT_ID;
dea3101e 1157 CtReq->CommandResponse.bits.CmdRsp =
1158 be16_to_cpu(SLI_CTNS_RFT_ID);
09372820 1159 CtReq->un.rft.PortId = cpu_to_be32(vport->fc_myDID);
dea3101e 1160 CtReq->un.rft.fcpReg = 1;
1161 cmpl = lpfc_cmpl_ct_cmd_rft_id;
1162 break;
1163
1164 case SLI_CTNS_RNN_ID:
7ee5d43e 1165 vport->ct_flags &= ~FC_CT_RNN_ID;
dea3101e 1166 CtReq->CommandResponse.bits.CmdRsp =
1167 be16_to_cpu(SLI_CTNS_RNN_ID);
09372820 1168 CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID);
2e0fef85 1169 memcpy(CtReq->un.rnn.wwnn, &vport->fc_nodename,
dea3101e 1170 sizeof (struct lpfc_name));
1171 cmpl = lpfc_cmpl_ct_cmd_rnn_id;
1172 break;
1173
92d7f7b0 1174 case SLI_CTNS_RSPN_ID:
7ee5d43e 1175 vport->ct_flags &= ~FC_CT_RSPN_ID;
92d7f7b0
JS		 1176 CtReq->CommandResponse.bits.CmdRsp =
1177 be16_to_cpu(SLI_CTNS_RSPN_ID);
09372820 1178 CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID);
92d7f7b0
JS		 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;
dea3101e 1185 case SLI_CTNS_RSNN_NN:
7ee5d43e 1186 vport->ct_flags &= ~FC_CT_RSNN_NN;
dea3101e 1187 CtReq->CommandResponse.bits.CmdRsp =
1188 be16_to_cpu(SLI_CTNS_RSNN_NN);
2e0fef85 1189 memcpy(CtReq->un.rsnn.wwnn, &vport->fc_nodename,
dea3101e 1190 sizeof (struct lpfc_name));
92d7f7b0
JS		 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);
dea3101e 1195 cmpl = lpfc_cmpl_ct_cmd_rsnn_nn;
1196 break;
7ee5d43e
JS		 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);
09372820 1201 CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID);
7ee5d43e
JS		 1202 cmpl = lpfc_cmpl_ct_cmd_da_id;
1203 break;
92d7f7b0 1204 case SLI_CTNS_RFF_ID:
7ee5d43e 1205 vport->ct_flags &= ~FC_CT_RFF_ID;
92d7f7b0
JS		 1206 CtReq->CommandResponse.bits.CmdRsp =
1207 be16_to_cpu(SLI_CTNS_RFF_ID);
09372820 1208 CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);;
92d7f7b0
JS		 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;
dea3101e 1213 }
e47c9093
JS		 1214 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
1215 * to hold ndlp reference for the corresponding callback function.
1216 */
858c9f6c 1217 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) {
dea3101e 1218 /* On success, The cmpl function will free the buffers */
858c9f6c
JS		 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);
dea3101e 1222 return 0;
858c9f6c 1223 }
858c9f6c 1224 rc=6;
e47c9093
JS		 1225
1226 /* Decrement ndlp reference count to release ndlp reference held
1227 * for the failed command's callback function.
1228 */
51ef4c26 1229 lpfc_nlp_put(ndlp);
e47c9093 1230
dea3101e 1231 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1232ns_cmd_free_bmp:
1233 kfree(bmp);
1234ns_cmd_free_mpvirt:
1235 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1236ns_cmd_free_mp:
1237 kfree(mp);
1238ns_cmd_exit:
e8b62011
JS		 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);
dea3101e 1242 return 1;
1243}
1244
1245static void
2e0fef85
JS		 1246lpfc_cmpl_ct_cmd_fdmi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1247 struct lpfc_iocbq * rspiocb)
dea3101e 1248{
dea3101e 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;
2e0fef85 1256 struct lpfc_vport *vport = cmdiocb->vport;
858c9f6c
JS		 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) {
e8b62011
JS		 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]);
858c9f6c
JS		 1272 lpfc_ct_free_iocb(phba, cmdiocb);
1273 return;
1274 }
dea3101e 1275
2e0fef85 1276 ndlp = lpfc_findnode_did(vport, FDMI_DID);
e47c9093
JS		 1277 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
1278 goto fail_out;
1279
dea3101e 1280 if (fdmi_rsp == be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) {
1281 /* FDMI rsp failed */
e8b62011
JS		 1282 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1283 "0220 FDMI rsp failed Data: x%x\n",
1284 be16_to_cpu(fdmi_cmd));
dea3101e 1285 }
1286
1287 switch (be16_to_cpu(fdmi_cmd)) {
1288 case SLI_MGMT_RHBA:
2e0fef85 1289 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA);
dea3101e 1290 break;
1291
1292 case SLI_MGMT_RPA:
1293 break;
1294
1295 case SLI_MGMT_DHBA:
2e0fef85 1296 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT);
dea3101e 1297 break;
1298
1299 case SLI_MGMT_DPRT:
2e0fef85 1300 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RHBA);
dea3101e 1301 break;
1302 }
e47c9093
JS		 1303
1304fail_out:
858c9f6c 1305 lpfc_ct_free_iocb(phba, cmdiocb);
dea3101e 1306 return;
1307}
2e0fef85 1308
dea3101e 1309int
2e0fef85 1310lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, int cmdcode)
dea3101e 1311{
2e0fef85 1312 struct lpfc_hba *phba = vport->phba;
dea3101e 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 */
e8b62011
JS		 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);
dea3101e 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;
2e0fef85 1373 memcpy(&rh->hi.PortName, &vport->fc_sparam.portName,
dea3101e 1374 sizeof (struct lpfc_name));
1375 /* One entry (port) per adapter */
1376 rh->rpl.EntryCnt = be32_to_cpu(1);
2e0fef85 1377 memcpy(&rh->rpl.pe, &vport->fc_sparam.portName,
dea3101e 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));
2e0fef85 1393 memcpy(&ae->un.NodeName, &vport->fc_sparam.nodeName,
dea3101e 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",
2fb9bd8b
JS		 1494 init_utsname()->sysname,
1495 init_utsname()->release,
96b644bd 1496 init_utsname()->version);
dea3101e 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,
2e0fef85 1531 (uint8_t *) & vport->fc_sparam.portName,
dea3101e 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);
74b72a59
JW		 1548
1549 ae->un.SupportSpeed = 0;
1550 if (phba->lmt & LMT_10Gb)
dea3101e 1551 ae->un.SupportSpeed = HBA_PORTSPEED_10GBIT;
74b72a59
JW		 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
dea3101e 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;
b87eab38
JS		 1578 case LA_8GHZ_LINK:
1579 ae->un.PortSpeed = HBA_PORTSPEED_8GBIT;
1580 break;
dea3101e 1581 default:
1582 ae->un.PortSpeed =
1583 HBA_PORTSPEED_UNKNOWN;
1584 break;
1585 }
1586 pab->ab.EntryCnt++;
1587 size += FOURBYTES + 4;
1588
1589 /* #4 Port attribute entry */
1590 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1591 ae->ad.bits.AttrType = be16_to_cpu(MAX_FRAME_SIZE);
1592 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
2e0fef85 1593 hsp = (struct serv_parm *) & vport->fc_sparam;
dea3101e 1594 ae->un.MaxFrameSize =
1595 (((uint32_t) hsp->cmn.
1596 bbRcvSizeMsb) << 8) | (uint32_t) hsp->cmn.
1597 bbRcvSizeLsb;
1598 pab->ab.EntryCnt++;
1599 size += FOURBYTES + 4;
1600
1601 /* #5 Port attribute entry */
1602 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1603 ae->ad.bits.AttrType = be16_to_cpu(OS_DEVICE_NAME);
1604 strcpy((char *)ae->un.OsDeviceName, LPFC_DRIVER_NAME);
1605 len = strlen((char *)ae->un.OsDeviceName);
1606 len += (len & 3) ? (4 - (len & 3)) : 4;
1607 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1608 pab->ab.EntryCnt++;
1609 size += FOURBYTES + len;
1610
3de2a653 1611 if (vport->cfg_fdmi_on == 2) {
dea3101e 1612 /* #6 Port attribute entry */
1613 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab +
1614 size);
1615 ae->ad.bits.AttrType = be16_to_cpu(HOST_NAME);
1616 sprintf(ae->un.HostName, "%s",
96b644bd 1617 init_utsname()->nodename);
dea3101e 1618 len = strlen(ae->un.HostName);
1619 len += (len & 3) ? (4 - (len & 3)) : 4;
1620 ae->ad.bits.AttrLen =
1621 be16_to_cpu(FOURBYTES + len);
1622 pab->ab.EntryCnt++;
1623 size += FOURBYTES + len;
1624 }
1625
1626 pab->ab.EntryCnt = be32_to_cpu(pab->ab.EntryCnt);
1627 /* Total size */
1628 size = GID_REQUEST_SZ - 4 + size;
1629 }
1630 break;
1631
1632 case SLI_MGMT_DHBA:
1633 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DHBA);
1634 CtReq->CommandResponse.bits.Size = 0;
1635 pe = (PORT_ENTRY *) & CtReq->un.PortID;
1636 memcpy((uint8_t *) & pe->PortName,
2e0fef85 1637 (uint8_t *) & vport->fc_sparam.portName,
dea3101e 1638 sizeof (struct lpfc_name));
1639 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name);
1640 break;
1641
1642 case SLI_MGMT_DPRT:
1643 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DPRT);
1644 CtReq->CommandResponse.bits.Size = 0;
1645 pe = (PORT_ENTRY *) & CtReq->un.PortID;
1646 memcpy((uint8_t *) & pe->PortName,
2e0fef85 1647 (uint8_t *) & vport->fc_sparam.portName,
dea3101e 1648 sizeof (struct lpfc_name));
1649 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name);
1650 break;
1651 }
1652
1653 bpl = (struct ulp_bde64 *) bmp->virt;
92d7f7b0
JS		 1654 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1655 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
dea3101e 1656 bpl->tus.f.bdeFlags = 0;
1657 bpl->tus.f.bdeSize = size;
1658 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1659
1660 cmpl = lpfc_cmpl_ct_cmd_fdmi;
1661
e47c9093
JS		 1662 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
1663 * to hold ndlp reference for the corresponding callback function.
1664 */
92d7f7b0 1665 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, FC_MAX_NS_RSP, 0))
dea3101e 1666 return 0;
1667
e47c9093
JS		 1668 /* Decrement ndlp reference count to release ndlp reference held
1669 * for the failed command's callback function.
1670 */
51ef4c26 1671 lpfc_nlp_put(ndlp);
e47c9093 1672
dea3101e 1673 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1674fdmi_cmd_free_bmp:
1675 kfree(bmp);
1676fdmi_cmd_free_mpvirt:
1677 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1678fdmi_cmd_free_mp:
1679 kfree(mp);
1680fdmi_cmd_exit:
1681 /* Issue FDMI request failed */
e8b62011
JS		 1682 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1683 "0244 Issue FDMI request failed Data: x%x\n",
1684 cmdcode);
dea3101e 1685 return 1;
1686}
1687
1688void
1689lpfc_fdmi_tmo(unsigned long ptr)
1690{
2e0fef85
JS		 1691 struct lpfc_vport *vport = (struct lpfc_vport *)ptr;
1692 struct lpfc_hba *phba = vport->phba;
5e9d9b82 1693 uint32_t tmo_posted;
dea3101e 1694 unsigned long iflag;
1695
2e0fef85 1696 spin_lock_irqsave(&vport->work_port_lock, iflag);
5e9d9b82
JS		 1697 tmo_posted = vport->work_port_events & WORKER_FDMI_TMO;
1698 if (!tmo_posted)
2e0fef85 1699 vport->work_port_events |= WORKER_FDMI_TMO;
5e9d9b82 1700 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
92d7f7b0 1701
5e9d9b82
JS		 1702 if (!tmo_posted)
1703 lpfc_worker_wake_up(phba);
1704 return;
dea3101e 1705}
1706
1707void
2e0fef85 1708lpfc_fdmi_timeout_handler(struct lpfc_vport *vport)
dea3101e 1709{
1710 struct lpfc_nodelist *ndlp;
1711
2e0fef85 1712 ndlp = lpfc_findnode_did(vport, FDMI_DID);
e47c9093 1713 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
2e0fef85
JS		 1714 if (init_utsname()->nodename[0] != '\0')
1715 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA);
1716 else
1717 mod_timer(&vport->fc_fdmitmo, jiffies + HZ * 60);
dea3101e 1718 }
dea3101e 1719 return;
1720}
1721
dea3101e 1722void
2e0fef85 1723lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag)
dea3101e 1724{
1725 struct lpfc_sli *psli = &phba->sli;
1726 lpfc_vpd_t *vp = &phba->vpd;
1727 uint32_t b1, b2, b3, b4, i, rev;
1728 char c;
1729 uint32_t *ptr, str[4];
1730 uint8_t *fwname;
1731
1732 if (vp->rev.rBit) {
1733 if (psli->sli_flag & LPFC_SLI2_ACTIVE)
1734 rev = vp->rev.sli2FwRev;
1735 else
1736 rev = vp->rev.sli1FwRev;
1737
1738 b1 = (rev & 0x0000f000) >> 12;
1739 b2 = (rev & 0x00000f00) >> 8;
1740 b3 = (rev & 0x000000c0) >> 6;
1741 b4 = (rev & 0x00000030) >> 4;
1742
1743 switch (b4) {
1744 case 0:
1745 c = 'N';
1746 break;
1747 case 1:
1748 c = 'A';
1749 break;
1750 case 2:
1751 c = 'B';
1752 break;
1753 default:
1754 c = 0;
1755 break;
1756 }
1757 b4 = (rev & 0x0000000f);
1758
1759 if (psli->sli_flag & LPFC_SLI2_ACTIVE)
1760 fwname = vp->rev.sli2FwName;
1761 else
1762 fwname = vp->rev.sli1FwName;
1763
1764 for (i = 0; i < 16; i++)
1765 if (fwname[i] == 0x20)
1766 fwname[i] = 0;
1767
1768 ptr = (uint32_t*)fwname;
1769
1770 for (i = 0; i < 3; i++)
1771 str[i] = be32_to_cpu(*ptr++);
1772
1773 if (c == 0) {
1774 if (flag)
1775 sprintf(fwrevision, "%d.%d%d (%s)",
1776 b1, b2, b3, (char *)str);
1777 else
1778 sprintf(fwrevision, "%d.%d%d", b1,
1779 b2, b3);
1780 } else {
1781 if (flag)
1782 sprintf(fwrevision, "%d.%d%d%c%d (%s)",
1783 b1, b2, b3, c,
1784 b4, (char *)str);
1785 else
1786 sprintf(fwrevision, "%d.%d%d%c%d",
1787 b1, b2, b3, c, b4);
1788 }
1789 } else {
1790 rev = vp->rev.smFwRev;
1791
1792 b1 = (rev & 0xff000000) >> 24;
1793 b2 = (rev & 0x00f00000) >> 20;
1794 b3 = (rev & 0x000f0000) >> 16;
1795 c = (rev & 0x0000ff00) >> 8;
1796 b4 = (rev & 0x000000ff);
1797
1798 if (flag)
1799 sprintf(fwrevision, "%d.%d%d%c%d ", b1,
1800 b2, b3, c, b4);
1801 else
1802 sprintf(fwrevision, "%d.%d%d%c%d ", b1,
1803 b2, b3, c, b4);
1804 }
1805 return;
1806}
Linux kernel - Deliverables
This page took 0.563641 seconds and 5 git commands to generate.