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