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