projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
/spare/repo/netdev-2.6 branch 'master'
[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-2005 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
23 */
24
25 #include <linux/blkdev.h>
26 #include <linux/pci.h>
27 #include <linux/interrupt.h>
28 #include <linux/utsname.h>
29
30 #include <scsi/scsi_device.h>
31 #include <scsi/scsi_host.h>
32
33 #include "lpfc_hw.h"
34 #include "lpfc_sli.h"
35 #include "lpfc_disc.h"
36 #include "lpfc_scsi.h"
37 #include "lpfc.h"
38 #include "lpfc_logmsg.h"
39 #include "lpfc_crtn.h"
40 #include "lpfc_version.h"
41
42 #define HBA_PORTSPEED_UNKNOWN 0 /* Unknown - transceiver
43 * incapable of reporting */
44 #define HBA_PORTSPEED_1GBIT 1 /* 1 GBit/sec */
45 #define HBA_PORTSPEED_2GBIT 2 /* 2 GBit/sec */
46 #define HBA_PORTSPEED_4GBIT 8 /* 4 GBit/sec */
47 #define HBA_PORTSPEED_8GBIT 16 /* 8 GBit/sec */
48 #define HBA_PORTSPEED_10GBIT 4 /* 10 GBit/sec */
49 #define HBA_PORTSPEED_NOT_NEGOTIATED 5 /* Speed not established */
50
51 #define FOURBYTES 4
52
53
54 static char *lpfc_release_version = LPFC_DRIVER_VERSION;
55
56 /*
57 * lpfc_ct_unsol_event
58 */
59 void
60 lpfc_ct_unsol_event(struct lpfc_hba * phba,
61 struct lpfc_sli_ring * pring, struct lpfc_iocbq * piocbq)
62 {
63
64 struct lpfc_iocbq *next_piocbq;
65 struct lpfc_dmabuf *pmbuf = NULL;
66 struct lpfc_dmabuf *matp, *next_matp;
67 uint32_t ctx = 0, size = 0, cnt = 0;
68 IOCB_t *icmd = &piocbq->iocb;
69 IOCB_t *save_icmd = icmd;
70 int i, go_exit = 0;
71 struct list_head head;
72
73 if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
74 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) {
75 /* Not enough posted buffers; Try posting more buffers */
76 phba->fc_stat.NoRcvBuf++;
77 lpfc_post_buffer(phba, pring, 0, 1);
78 return;
79 }
80
81 /* If there are no BDEs associated with this IOCB,
82 * there is nothing to do.
83 */
84 if (icmd->ulpBdeCount == 0)
85 return;
86
87 INIT_LIST_HEAD(&head);
88 list_add_tail(&head, &piocbq->list);
89
90 list_for_each_entry_safe(piocbq, next_piocbq, &head, list) {
91 icmd = &piocbq->iocb;
92 if (ctx == 0)
93 ctx = (uint32_t) (icmd->ulpContext);
94 if (icmd->ulpBdeCount == 0)
95 continue;
96
97 for (i = 0; i < icmd->ulpBdeCount; i++) {
98 matp = lpfc_sli_ringpostbuf_get(phba, pring,
99 getPaddr(icmd->un.
100 cont64[i].
101 addrHigh,
102 icmd->un.
103 cont64[i].
104 addrLow));
105 if (!matp) {
106 /* Insert lpfc log message here */
107 lpfc_post_buffer(phba, pring, cnt, 1);
108 go_exit = 1;
109 goto ct_unsol_event_exit_piocbq;
110 }
111
112 /* Typically for Unsolicited CT requests */
113 if (!pmbuf) {
114 pmbuf = matp;
115 INIT_LIST_HEAD(&pmbuf->list);
116 } else
117 list_add_tail(&matp->list, &pmbuf->list);
118
119 size += icmd->un.cont64[i].tus.f.bdeSize;
120 cnt++;
121 }
122
123 icmd->ulpBdeCount = 0;
124 }
125
126 lpfc_post_buffer(phba, pring, cnt, 1);
127 if (save_icmd->ulpStatus) {
128 go_exit = 1;
129 }
130
131 ct_unsol_event_exit_piocbq:
132 if (pmbuf) {
133 list_for_each_entry_safe(matp, next_matp, &pmbuf->list, list) {
134 lpfc_mbuf_free(phba, matp->virt, matp->phys);
135 list_del(&matp->list);
136 kfree(matp);
137 }
138 lpfc_mbuf_free(phba, pmbuf->virt, pmbuf->phys);
139 kfree(pmbuf);
140 }
141 return;
142 }
143
144 static void
145 lpfc_free_ct_rsp(struct lpfc_hba * phba, struct lpfc_dmabuf * mlist)
146 {
147 struct lpfc_dmabuf *mlast, *next_mlast;
148
149 list_for_each_entry_safe(mlast, next_mlast, &mlist->list, list) {
150 lpfc_mbuf_free(phba, mlast->virt, mlast->phys);
151 list_del(&mlast->list);
152 kfree(mlast);
153 }
154 lpfc_mbuf_free(phba, mlist->virt, mlist->phys);
155 kfree(mlist);
156 return;
157 }
158
159 static struct lpfc_dmabuf *
160 lpfc_alloc_ct_rsp(struct lpfc_hba * phba, int cmdcode, struct ulp_bde64 * bpl,
161 uint32_t size, int *entries)
162 {
163 struct lpfc_dmabuf *mlist = NULL;
164 struct lpfc_dmabuf *mp;
165 int cnt, i = 0;
166
167 /* We get chucks of FCELSSIZE */
168 cnt = size > FCELSSIZE ? FCELSSIZE: size;
169
170 while (size) {
171 /* Allocate buffer for rsp payload */
172 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
173 if (!mp) {
174 if (mlist)
175 lpfc_free_ct_rsp(phba, mlist);
176 return NULL;
177 }
178
179 INIT_LIST_HEAD(&mp->list);
180
181 if (cmdcode == be16_to_cpu(SLI_CTNS_GID_FT))
182 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
183 else
184 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
185
186 if (!mp->virt) {
187 kfree(mp);
188 lpfc_free_ct_rsp(phba, mlist);
189 return NULL;
190 }
191
192 /* Queue it to a linked list */
193 if (!mlist)
194 mlist = mp;
195 else
196 list_add_tail(&mp->list, &mlist->list);
197
198 bpl->tus.f.bdeFlags = BUFF_USE_RCV;
199 /* build buffer ptr list for IOCB */
200 bpl->addrLow = le32_to_cpu( putPaddrLow(mp->phys) );
201 bpl->addrHigh = le32_to_cpu( putPaddrHigh(mp->phys) );
202 bpl->tus.f.bdeSize = (uint16_t) cnt;
203 bpl->tus.w = le32_to_cpu(bpl->tus.w);
204 bpl++;
205
206 i++;
207 size -= cnt;
208 }
209
210 *entries = i;
211 return mlist;
212 }
213
214 static int
215 lpfc_gen_req(struct lpfc_hba *phba, struct lpfc_dmabuf *bmp,
216 struct lpfc_dmabuf *inp, struct lpfc_dmabuf *outp,
217 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
218 struct lpfc_iocbq *),
219 struct lpfc_nodelist *ndlp, uint32_t usr_flg, uint32_t num_entry,
220 uint32_t tmo)
221 {
222
223 struct lpfc_sli *psli = &phba->sli;
224 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
225 struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
226 IOCB_t *icmd;
227 struct lpfc_iocbq *geniocb = NULL;
228
229 /* Allocate buffer for command iocb */
230 spin_lock_irq(phba->host->host_lock);
231 list_remove_head(lpfc_iocb_list, geniocb, struct lpfc_iocbq, list);
232 spin_unlock_irq(phba->host->host_lock);
233
234 if (geniocb == NULL)
235 return 1;
236 memset(geniocb, 0, sizeof (struct lpfc_iocbq));
237
238 icmd = &geniocb->iocb;
239 icmd->un.genreq64.bdl.ulpIoTag32 = 0;
240 icmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
241 icmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
242 icmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
243 icmd->un.genreq64.bdl.bdeSize = (num_entry * sizeof (struct ulp_bde64));
244
245 if (usr_flg)
246 geniocb->context3 = NULL;
247 else
248 geniocb->context3 = (uint8_t *) bmp;
249
250 /* Save for completion so we can release these resources */
251 geniocb->context1 = (uint8_t *) inp;
252 geniocb->context2 = (uint8_t *) outp;
253
254 /* Fill in payload, bp points to frame payload */
255 icmd->ulpCommand = CMD_GEN_REQUEST64_CR;
256
257 /* Fill in rest of iocb */
258 icmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
259 icmd->un.genreq64.w5.hcsw.Dfctl = 0;
260 icmd->un.genreq64.w5.hcsw.Rctl = FC_UNSOL_CTL;
261 icmd->un.genreq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP;
262
263 if (!tmo)
264 tmo = (2 * phba->fc_ratov) + 1;
265 icmd->ulpTimeout = tmo;
266 icmd->ulpBdeCount = 1;
267 icmd->ulpLe = 1;
268 icmd->ulpClass = CLASS3;
269 icmd->ulpContext = ndlp->nlp_rpi;
270
271 /* Issue GEN REQ IOCB for NPORT <did> */
272 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
273 "%d:0119 Issue GEN REQ IOCB for NPORT x%x "
274 "Data: x%x x%x\n", phba->brd_no, icmd->un.ulpWord[5],
275 icmd->ulpIoTag, phba->hba_state);
276 geniocb->iocb_cmpl = cmpl;
277 geniocb->drvrTimeout = icmd->ulpTimeout + LPFC_DRVR_TIMEOUT;
278 spin_lock_irq(phba->host->host_lock);
279 if (lpfc_sli_issue_iocb(phba, pring, geniocb, 0) == IOCB_ERROR) {
280 list_add_tail(&geniocb->list, lpfc_iocb_list);
281 spin_unlock_irq(phba->host->host_lock);
282 return 1;
283 }
284 spin_unlock_irq(phba->host->host_lock);
285
286 return 0;
287 }
288
289 static int
290 lpfc_ct_cmd(struct lpfc_hba *phba, struct lpfc_dmabuf *inmp,
291 struct lpfc_dmabuf *bmp, struct lpfc_nodelist *ndlp,
292 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
293 struct lpfc_iocbq *),
294 uint32_t rsp_size)
295 {
296 struct ulp_bde64 *bpl = (struct ulp_bde64 *) bmp->virt;
297 struct lpfc_dmabuf *outmp;
298 int cnt = 0, status;
299 int cmdcode = ((struct lpfc_sli_ct_request *) inmp->virt)->
300 CommandResponse.bits.CmdRsp;
301
302 bpl++; /* Skip past ct request */
303
304 /* Put buffer(s) for ct rsp in bpl */
305 outmp = lpfc_alloc_ct_rsp(phba, cmdcode, bpl, rsp_size, &cnt);
306 if (!outmp)
307 return -ENOMEM;
308
309 status = lpfc_gen_req(phba, bmp, inmp, outmp, cmpl, ndlp, 0,
310 cnt+1, 0);
311 if (status) {
312 lpfc_free_ct_rsp(phba, outmp);
313 return -ENOMEM;
314 }
315 return 0;
316 }
317
318 static int
319 lpfc_ns_rsp(struct lpfc_hba * phba, struct lpfc_dmabuf * mp, uint32_t Size)
320 {
321 struct lpfc_sli_ct_request *Response =
322 (struct lpfc_sli_ct_request *) mp->virt;
323 struct lpfc_nodelist *ndlp = NULL;
324 struct lpfc_dmabuf *mlast, *next_mp;
325 uint32_t *ctptr = (uint32_t *) & Response->un.gid.PortType;
326 uint32_t Did;
327 uint32_t CTentry;
328 int Cnt;
329 struct list_head head;
330
331 lpfc_set_disctmo(phba);
332
333 Cnt = Size > FCELSSIZE ? FCELSSIZE : Size;
334
335 list_add_tail(&head, &mp->list);
336 list_for_each_entry_safe(mp, next_mp, &head, list) {
337 mlast = mp;
338
339 Size -= Cnt;
340
341 if (!ctptr)
342 ctptr = (uint32_t *) mlast->virt;
343 else
344 Cnt -= 16; /* subtract length of CT header */
345
346 /* Loop through entire NameServer list of DIDs */
347 while (Cnt) {
348
349 /* Get next DID from NameServer List */
350 CTentry = *ctptr++;
351 Did = ((be32_to_cpu(CTentry)) & Mask_DID);
352
353 ndlp = NULL;
354 if (Did != phba->fc_myDID) {
355 /* Check for rscn processing or not */
356 ndlp = lpfc_setup_disc_node(phba, Did);
357 }
358 /* Mark all node table entries that are in the
359 Nameserver */
360 if (ndlp) {
361 /* NameServer Rsp */
362 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
363 "%d:0238 Process x%x NameServer"
364 " Rsp Data: x%x x%x x%x\n",
365 phba->brd_no,
366 Did, ndlp->nlp_flag,
367 phba->fc_flag,
368 phba->fc_rscn_id_cnt);
369 } else {
370 /* NameServer Rsp */
371 lpfc_printf_log(phba,
372 KERN_INFO,
373 LOG_DISCOVERY,
374 "%d:0239 Skip x%x NameServer "
375 "Rsp Data: x%x x%x x%x\n",
376 phba->brd_no,
377 Did, Size, phba->fc_flag,
378 phba->fc_rscn_id_cnt);
379 }
380
381 if (CTentry & (be32_to_cpu(SLI_CT_LAST_ENTRY)))
382 goto nsout1;
383 Cnt -= sizeof (uint32_t);
384 }
385 ctptr = NULL;
386
387 }
388
389 nsout1:
390 list_del(&head);
391
392 /* Here we are finished in the case RSCN */
393 if (phba->hba_state == LPFC_HBA_READY) {
394 lpfc_els_flush_rscn(phba);
395 spin_lock_irq(phba->host->host_lock);
396 phba->fc_flag |= FC_RSCN_MODE; /* we are still in RSCN mode */
397 spin_unlock_irq(phba->host->host_lock);
398 }
399 return 0;
400 }
401
402
403
404
405 static void
406 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
407 struct lpfc_iocbq * rspiocb)
408 {
409 IOCB_t *irsp;
410 struct lpfc_sli *psli;
411 struct lpfc_dmabuf *bmp;
412 struct lpfc_dmabuf *inp;
413 struct lpfc_dmabuf *outp;
414 struct lpfc_nodelist *ndlp;
415 struct lpfc_sli_ct_request *CTrsp;
416
417 psli = &phba->sli;
418 /* we pass cmdiocb to state machine which needs rspiocb as well */
419 cmdiocb->context_un.rsp_iocb = rspiocb;
420
421 inp = (struct lpfc_dmabuf *) cmdiocb->context1;
422 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
423 bmp = (struct lpfc_dmabuf *) cmdiocb->context3;
424
425 irsp = &rspiocb->iocb;
426 if (irsp->ulpStatus) {
427 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
428 ((irsp->un.ulpWord[4] == IOERR_SLI_DOWN) ||
429 (irsp->un.ulpWord[4] == IOERR_SLI_ABORTED))) {
430 goto out;
431 }
432
433 /* Check for retry */
434 if (phba->fc_ns_retry < LPFC_MAX_NS_RETRY) {
435 phba->fc_ns_retry++;
436 /* CT command is being retried */
437 ndlp =
438 lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED,
439 NameServer_DID);
440 if (ndlp) {
441 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) ==
442 0) {
443 goto out;
444 }
445 }
446 }
447 } else {
448 /* Good status, continue checking */
449 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
450 if (CTrsp->CommandResponse.bits.CmdRsp ==
451 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) {
452 lpfc_ns_rsp(phba, outp,
453 (uint32_t) (irsp->un.genreq64.bdl.bdeSize));
454 } else if (CTrsp->CommandResponse.bits.CmdRsp ==
455 be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) {
456 /* NameServer Rsp Error */
457 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
458 "%d:0240 NameServer Rsp Error "
459 "Data: x%x x%x x%x x%x\n",
460 phba->brd_no,
461 CTrsp->CommandResponse.bits.CmdRsp,
462 (uint32_t) CTrsp->ReasonCode,
463 (uint32_t) CTrsp->Explanation,
464 phba->fc_flag);
465 } else {
466 /* NameServer Rsp Error */
467 lpfc_printf_log(phba,
468 KERN_INFO,
469 LOG_DISCOVERY,
470 "%d:0241 NameServer Rsp Error "
471 "Data: x%x x%x x%x x%x\n",
472 phba->brd_no,
473 CTrsp->CommandResponse.bits.CmdRsp,
474 (uint32_t) CTrsp->ReasonCode,
475 (uint32_t) CTrsp->Explanation,
476 phba->fc_flag);
477 }
478 }
479 /* Link up / RSCN discovery */
480 lpfc_disc_start(phba);
481 out:
482 lpfc_free_ct_rsp(phba, outp);
483 lpfc_mbuf_free(phba, inp->virt, inp->phys);
484 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
485 kfree(inp);
486 kfree(bmp);
487 spin_lock_irq(phba->host->host_lock);
488 list_add_tail(&cmdiocb->list, &phba->lpfc_iocb_list);
489 spin_unlock_irq(phba->host->host_lock);
490 return;
491 }
492
493 static void
494 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
495 struct lpfc_iocbq * rspiocb)
496 {
497 struct lpfc_sli *psli;
498 struct lpfc_dmabuf *bmp;
499 struct lpfc_dmabuf *inp;
500 struct lpfc_dmabuf *outp;
501 IOCB_t *irsp;
502 struct lpfc_sli_ct_request *CTrsp;
503
504 psli = &phba->sli;
505 /* we pass cmdiocb to state machine which needs rspiocb as well */
506 cmdiocb->context_un.rsp_iocb = rspiocb;
507
508 inp = (struct lpfc_dmabuf *) cmdiocb->context1;
509 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
510 bmp = (struct lpfc_dmabuf *) cmdiocb->context3;
511 irsp = &rspiocb->iocb;
512
513 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
514
515 /* RFT request completes status <ulpStatus> CmdRsp <CmdRsp> */
516 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
517 "%d:0209 RFT request completes ulpStatus x%x "
518 "CmdRsp x%x\n", phba->brd_no, irsp->ulpStatus,
519 CTrsp->CommandResponse.bits.CmdRsp);
520
521 lpfc_free_ct_rsp(phba, outp);
522 lpfc_mbuf_free(phba, inp->virt, inp->phys);
523 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
524 kfree(inp);
525 kfree(bmp);
526 spin_lock_irq(phba->host->host_lock);
527 list_add_tail(&cmdiocb->list, &phba->lpfc_iocb_list);
528 spin_unlock_irq(phba->host->host_lock);
529 return;
530 }
531
532 static void
533 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
534 struct lpfc_iocbq * rspiocb)
535 {
536 lpfc_cmpl_ct_cmd_rft_id(phba, cmdiocb, rspiocb);
537 return;
538 }
539
540 static void
541 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
542 struct lpfc_iocbq * rspiocb)
543 {
544 lpfc_cmpl_ct_cmd_rft_id(phba, cmdiocb, rspiocb);
545 return;
546 }
547
548 void
549 lpfc_get_hba_sym_node_name(struct lpfc_hba * phba, uint8_t * symbp)
550 {
551 char fwrev[16];
552
553 lpfc_decode_firmware_rev(phba, fwrev, 0);
554
555 if (phba->Port[0]) {
556 sprintf(symbp, "Emulex %s Port %s FV%s DV%s", phba->ModelName,
557 phba->Port, fwrev, lpfc_release_version);
558 } else {
559 sprintf(symbp, "Emulex %s FV%s DV%s", phba->ModelName,
560 fwrev, lpfc_release_version);
561 }
562 }
563
564 /*
565 * lpfc_ns_cmd
566 * Description:
567 * Issue Cmd to NameServer
568 * SLI_CTNS_GID_FT
569 * LI_CTNS_RFT_ID
570 */
571 int
572 lpfc_ns_cmd(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, int cmdcode)
573 {
574 struct lpfc_dmabuf *mp, *bmp;
575 struct lpfc_sli_ct_request *CtReq;
576 struct ulp_bde64 *bpl;
577 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
578 struct lpfc_iocbq *) = NULL;
579 uint32_t rsp_size = 1024;
580
581 /* fill in BDEs for command */
582 /* Allocate buffer for command payload */
583 mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
584 if (!mp)
585 goto ns_cmd_exit;
586
587 INIT_LIST_HEAD(&mp->list);
588 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
589 if (!mp->virt)
590 goto ns_cmd_free_mp;
591
592 /* Allocate buffer for Buffer ptr list */
593 bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
594 if (!bmp)
595 goto ns_cmd_free_mpvirt;
596
597 INIT_LIST_HEAD(&bmp->list);
598 bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys));
599 if (!bmp->virt)
600 goto ns_cmd_free_bmp;
601
602 /* NameServer Req */
603 lpfc_printf_log(phba,
604 KERN_INFO,
605 LOG_DISCOVERY,
606 "%d:0236 NameServer Req Data: x%x x%x x%x\n",
607 phba->brd_no, cmdcode, phba->fc_flag,
608 phba->fc_rscn_id_cnt);
609
610 bpl = (struct ulp_bde64 *) bmp->virt;
611 memset(bpl, 0, sizeof(struct ulp_bde64));
612 bpl->addrHigh = le32_to_cpu( putPaddrHigh(mp->phys) );
613 bpl->addrLow = le32_to_cpu( putPaddrLow(mp->phys) );
614 bpl->tus.f.bdeFlags = 0;
615 if (cmdcode == SLI_CTNS_GID_FT)
616 bpl->tus.f.bdeSize = GID_REQUEST_SZ;
617 else if (cmdcode == SLI_CTNS_RFT_ID)
618 bpl->tus.f.bdeSize = RFT_REQUEST_SZ;
619 else if (cmdcode == SLI_CTNS_RNN_ID)
620 bpl->tus.f.bdeSize = RNN_REQUEST_SZ;
621 else if (cmdcode == SLI_CTNS_RSNN_NN)
622 bpl->tus.f.bdeSize = RSNN_REQUEST_SZ;
623 else
624 bpl->tus.f.bdeSize = 0;
625 bpl->tus.w = le32_to_cpu(bpl->tus.w);
626
627 CtReq = (struct lpfc_sli_ct_request *) mp->virt;
628 memset(CtReq, 0, sizeof (struct lpfc_sli_ct_request));
629 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
630 CtReq->RevisionId.bits.InId = 0;
631 CtReq->FsType = SLI_CT_DIRECTORY_SERVICE;
632 CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;
633 CtReq->CommandResponse.bits.Size = 0;
634 switch (cmdcode) {
635 case SLI_CTNS_GID_FT:
636 CtReq->CommandResponse.bits.CmdRsp =
637 be16_to_cpu(SLI_CTNS_GID_FT);
638 CtReq->un.gid.Fc4Type = SLI_CTPT_FCP;
639 if (phba->hba_state < LPFC_HBA_READY)
640 phba->hba_state = LPFC_NS_QRY;
641 lpfc_set_disctmo(phba);
642 cmpl = lpfc_cmpl_ct_cmd_gid_ft;
643 rsp_size = FC_MAX_NS_RSP;
644 break;
645
646 case SLI_CTNS_RFT_ID:
647 CtReq->CommandResponse.bits.CmdRsp =
648 be16_to_cpu(SLI_CTNS_RFT_ID);
649 CtReq->un.rft.PortId = be32_to_cpu(phba->fc_myDID);
650 CtReq->un.rft.fcpReg = 1;
651 cmpl = lpfc_cmpl_ct_cmd_rft_id;
652 break;
653
654 case SLI_CTNS_RNN_ID:
655 CtReq->CommandResponse.bits.CmdRsp =
656 be16_to_cpu(SLI_CTNS_RNN_ID);
657 CtReq->un.rnn.PortId = be32_to_cpu(phba->fc_myDID);
658 memcpy(CtReq->un.rnn.wwnn, &phba->fc_nodename,
659 sizeof (struct lpfc_name));
660 cmpl = lpfc_cmpl_ct_cmd_rnn_id;
661 break;
662
663 case SLI_CTNS_RSNN_NN:
664 CtReq->CommandResponse.bits.CmdRsp =
665 be16_to_cpu(SLI_CTNS_RSNN_NN);
666 memcpy(CtReq->un.rsnn.wwnn, &phba->fc_nodename,
667 sizeof (struct lpfc_name));
668 lpfc_get_hba_sym_node_name(phba, CtReq->un.rsnn.symbname);
669 CtReq->un.rsnn.len = strlen(CtReq->un.rsnn.symbname);
670 cmpl = lpfc_cmpl_ct_cmd_rsnn_nn;
671 break;
672 }
673
674 if (!lpfc_ct_cmd(phba, mp, bmp, ndlp, cmpl, rsp_size))
675 /* On success, The cmpl function will free the buffers */
676 return 0;
677
678 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
679 ns_cmd_free_bmp:
680 kfree(bmp);
681 ns_cmd_free_mpvirt:
682 lpfc_mbuf_free(phba, mp->virt, mp->phys);
683 ns_cmd_free_mp:
684 kfree(mp);
685 ns_cmd_exit:
686 return 1;
687 }
688
689 static void
690 lpfc_cmpl_ct_cmd_fdmi(struct lpfc_hba * phba,
691 struct lpfc_iocbq * cmdiocb, struct lpfc_iocbq * rspiocb)
692 {
693 struct lpfc_dmabuf *bmp = cmdiocb->context3;
694 struct lpfc_dmabuf *inp = cmdiocb->context1;
695 struct lpfc_dmabuf *outp = cmdiocb->context2;
696 struct lpfc_sli_ct_request *CTrsp = outp->virt;
697 struct lpfc_sli_ct_request *CTcmd = inp->virt;
698 struct lpfc_nodelist *ndlp;
699 uint16_t fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp;
700 uint16_t fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp;
701
702 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, FDMI_DID);
703 if (fdmi_rsp == be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) {
704 /* FDMI rsp failed */
705 lpfc_printf_log(phba,
706 KERN_INFO,
707 LOG_DISCOVERY,
708 "%d:0220 FDMI rsp failed Data: x%x\n",
709 phba->brd_no,
710 be16_to_cpu(fdmi_cmd));
711 }
712
713 switch (be16_to_cpu(fdmi_cmd)) {
714 case SLI_MGMT_RHBA:
715 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_RPA);
716 break;
717
718 case SLI_MGMT_RPA:
719 break;
720
721 case SLI_MGMT_DHBA:
722 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_DPRT);
723 break;
724
725 case SLI_MGMT_DPRT:
726 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_RHBA);
727 break;
728 }
729
730 lpfc_free_ct_rsp(phba, outp);
731 lpfc_mbuf_free(phba, inp->virt, inp->phys);
732 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
733 kfree(inp);
734 kfree(bmp);
735 spin_lock_irq(phba->host->host_lock);
736 list_add_tail(&cmdiocb->list, &phba->lpfc_iocb_list);
737 spin_unlock_irq(phba->host->host_lock);
738 return;
739 }
740 int
741 lpfc_fdmi_cmd(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, int cmdcode)
742 {
743 struct lpfc_dmabuf *mp, *bmp;
744 struct lpfc_sli_ct_request *CtReq;
745 struct ulp_bde64 *bpl;
746 uint32_t size;
747 REG_HBA *rh;
748 PORT_ENTRY *pe;
749 REG_PORT_ATTRIBUTE *pab;
750 ATTRIBUTE_BLOCK *ab;
751 ATTRIBUTE_ENTRY *ae;
752 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
753 struct lpfc_iocbq *);
754
755
756 /* fill in BDEs for command */
757 /* Allocate buffer for command payload */
758 mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
759 if (!mp)
760 goto fdmi_cmd_exit;
761
762 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
763 if (!mp->virt)
764 goto fdmi_cmd_free_mp;
765
766 /* Allocate buffer for Buffer ptr list */
767 bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
768 if (!bmp)
769 goto fdmi_cmd_free_mpvirt;
770
771 bmp->virt = lpfc_mbuf_alloc(phba, 0, &(bmp->phys));
772 if (!bmp->virt)
773 goto fdmi_cmd_free_bmp;
774
775 INIT_LIST_HEAD(&mp->list);
776 INIT_LIST_HEAD(&bmp->list);
777
778 /* FDMI request */
779 lpfc_printf_log(phba,
780 KERN_INFO,
781 LOG_DISCOVERY,
782 "%d:0218 FDMI Request Data: x%x x%x x%x\n",
783 phba->brd_no,
784 phba->fc_flag, phba->hba_state, cmdcode);
785
786 CtReq = (struct lpfc_sli_ct_request *) mp->virt;
787
788 memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request));
789 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
790 CtReq->RevisionId.bits.InId = 0;
791
792 CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE;
793 CtReq->FsSubType = SLI_CT_FDMI_Subtypes;
794 size = 0;
795
796 switch (cmdcode) {
797 case SLI_MGMT_RHBA:
798 {
799 lpfc_vpd_t *vp = &phba->vpd;
800 uint32_t i, j, incr;
801 int len;
802
803 CtReq->CommandResponse.bits.CmdRsp =
804 be16_to_cpu(SLI_MGMT_RHBA);
805 CtReq->CommandResponse.bits.Size = 0;
806 rh = (REG_HBA *) & CtReq->un.PortID;
807 memcpy(&rh->hi.PortName, &phba->fc_sparam.portName,
808 sizeof (struct lpfc_name));
809 /* One entry (port) per adapter */
810 rh->rpl.EntryCnt = be32_to_cpu(1);
811 memcpy(&rh->rpl.pe, &phba->fc_sparam.portName,
812 sizeof (struct lpfc_name));
813
814 /* point to the HBA attribute block */
815 size = 2 * sizeof (struct lpfc_name) + FOURBYTES;
816 ab = (ATTRIBUTE_BLOCK *) ((uint8_t *) rh + size);
817 ab->EntryCnt = 0;
818
819 /* Point to the beginning of the first HBA attribute
820 entry */
821 /* #1 HBA attribute entry */
822 size += FOURBYTES;
823 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
824 ae->ad.bits.AttrType = be16_to_cpu(NODE_NAME);
825 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES
826 + sizeof (struct lpfc_name));
827 memcpy(&ae->un.NodeName, &phba->fc_sparam.nodeName,
828 sizeof (struct lpfc_name));
829 ab->EntryCnt++;
830 size += FOURBYTES + sizeof (struct lpfc_name);
831
832 /* #2 HBA attribute entry */
833 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
834 ae->ad.bits.AttrType = be16_to_cpu(MANUFACTURER);
835 strcpy(ae->un.Manufacturer, "Emulex Corporation");
836 len = strlen(ae->un.Manufacturer);
837 len += (len & 3) ? (4 - (len & 3)) : 4;
838 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
839 ab->EntryCnt++;
840 size += FOURBYTES + len;
841
842 /* #3 HBA attribute entry */
843 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
844 ae->ad.bits.AttrType = be16_to_cpu(SERIAL_NUMBER);
845 strcpy(ae->un.SerialNumber, phba->SerialNumber);
846 len = strlen(ae->un.SerialNumber);
847 len += (len & 3) ? (4 - (len & 3)) : 4;
848 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
849 ab->EntryCnt++;
850 size += FOURBYTES + len;
851
852 /* #4 HBA attribute entry */
853 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
854 ae->ad.bits.AttrType = be16_to_cpu(MODEL);
855 strcpy(ae->un.Model, phba->ModelName);
856 len = strlen(ae->un.Model);
857 len += (len & 3) ? (4 - (len & 3)) : 4;
858 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
859 ab->EntryCnt++;
860 size += FOURBYTES + len;
861
862 /* #5 HBA attribute entry */
863 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
864 ae->ad.bits.AttrType = be16_to_cpu(MODEL_DESCRIPTION);
865 strcpy(ae->un.ModelDescription, phba->ModelDesc);
866 len = strlen(ae->un.ModelDescription);
867 len += (len & 3) ? (4 - (len & 3)) : 4;
868 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
869 ab->EntryCnt++;
870 size += FOURBYTES + len;
871
872 /* #6 HBA attribute entry */
873 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
874 ae->ad.bits.AttrType = be16_to_cpu(HARDWARE_VERSION);
875 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 8);
876 /* Convert JEDEC ID to ascii for hardware version */
877 incr = vp->rev.biuRev;
878 for (i = 0; i < 8; i++) {
879 j = (incr & 0xf);
880 if (j <= 9)
881 ae->un.HardwareVersion[7 - i] =
882 (char)((uint8_t) 0x30 +
883 (uint8_t) j);
884 else
885 ae->un.HardwareVersion[7 - i] =
886 (char)((uint8_t) 0x61 +
887 (uint8_t) (j - 10));
888 incr = (incr >> 4);
889 }
890 ab->EntryCnt++;
891 size += FOURBYTES + 8;
892
893 /* #7 HBA attribute entry */
894 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
895 ae->ad.bits.AttrType = be16_to_cpu(DRIVER_VERSION);
896 strcpy(ae->un.DriverVersion, lpfc_release_version);
897 len = strlen(ae->un.DriverVersion);
898 len += (len & 3) ? (4 - (len & 3)) : 4;
899 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
900 ab->EntryCnt++;
901 size += FOURBYTES + len;
902
903 /* #8 HBA attribute entry */
904 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
905 ae->ad.bits.AttrType = be16_to_cpu(OPTION_ROM_VERSION);
906 strcpy(ae->un.OptionROMVersion, phba->OptionROMVersion);
907 len = strlen(ae->un.OptionROMVersion);
908 len += (len & 3) ? (4 - (len & 3)) : 4;
909 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
910 ab->EntryCnt++;
911 size += FOURBYTES + len;
912
913 /* #9 HBA attribute entry */
914 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
915 ae->ad.bits.AttrType = be16_to_cpu(FIRMWARE_VERSION);
916 lpfc_decode_firmware_rev(phba, ae->un.FirmwareVersion,
917 1);
918 len = strlen(ae->un.FirmwareVersion);
919 len += (len & 3) ? (4 - (len & 3)) : 4;
920 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
921 ab->EntryCnt++;
922 size += FOURBYTES + len;
923
924 /* #10 HBA attribute entry */
925 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
926 ae->ad.bits.AttrType = be16_to_cpu(OS_NAME_VERSION);
927 sprintf(ae->un.OsNameVersion, "%s %s %s",
928 system_utsname.sysname, system_utsname.release,
929 system_utsname.version);
930 len = strlen(ae->un.OsNameVersion);
931 len += (len & 3) ? (4 - (len & 3)) : 4;
932 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
933 ab->EntryCnt++;
934 size += FOURBYTES + len;
935
936 /* #11 HBA attribute entry */
937 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
938 ae->ad.bits.AttrType = be16_to_cpu(MAX_CT_PAYLOAD_LEN);
939 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
940 ae->un.MaxCTPayloadLen = (65 * 4096);
941 ab->EntryCnt++;
942 size += FOURBYTES + 4;
943
944 ab->EntryCnt = be32_to_cpu(ab->EntryCnt);
945 /* Total size */
946 size = GID_REQUEST_SZ - 4 + size;
947 }
948 break;
949
950 case SLI_MGMT_RPA:
951 {
952 lpfc_vpd_t *vp;
953 struct serv_parm *hsp;
954 int len;
955
956 vp = &phba->vpd;
957
958 CtReq->CommandResponse.bits.CmdRsp =
959 be16_to_cpu(SLI_MGMT_RPA);
960 CtReq->CommandResponse.bits.Size = 0;
961 pab = (REG_PORT_ATTRIBUTE *) & CtReq->un.PortID;
962 size = sizeof (struct lpfc_name) + FOURBYTES;
963 memcpy((uint8_t *) & pab->PortName,
964 (uint8_t *) & phba->fc_sparam.portName,
965 sizeof (struct lpfc_name));
966 pab->ab.EntryCnt = 0;
967
968 /* #1 Port attribute entry */
969 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
970 ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_FC4_TYPES);
971 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 32);
972 ae->un.SupportFC4Types[2] = 1;
973 ae->un.SupportFC4Types[7] = 1;
974 pab->ab.EntryCnt++;
975 size += FOURBYTES + 32;
976
977 /* #2 Port attribute entry */
978 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
979 ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_SPEED);
980 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
981 if (FC_JEDEC_ID(vp->rev.biuRev) == VIPER_JEDEC_ID)
982 ae->un.SupportSpeed = HBA_PORTSPEED_10GBIT;
983 else if (FC_JEDEC_ID(vp->rev.biuRev) == HELIOS_JEDEC_ID)
984 ae->un.SupportSpeed = HBA_PORTSPEED_4GBIT;
985 else if ((FC_JEDEC_ID(vp->rev.biuRev) ==
986 CENTAUR_2G_JEDEC_ID)
987 || (FC_JEDEC_ID(vp->rev.biuRev) ==
988 PEGASUS_JEDEC_ID)
989 || (FC_JEDEC_ID(vp->rev.biuRev) ==
990 THOR_JEDEC_ID))
991 ae->un.SupportSpeed = HBA_PORTSPEED_2GBIT;
992 else
993 ae->un.SupportSpeed = HBA_PORTSPEED_1GBIT;
994 pab->ab.EntryCnt++;
995 size += FOURBYTES + 4;
996
997 /* #3 Port attribute entry */
998 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
999 ae->ad.bits.AttrType = be16_to_cpu(PORT_SPEED);
1000 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1001 switch(phba->fc_linkspeed) {
1002 case LA_1GHZ_LINK:
1003 ae->un.PortSpeed = HBA_PORTSPEED_1GBIT;
1004 break;
1005 case LA_2GHZ_LINK:
1006 ae->un.PortSpeed = HBA_PORTSPEED_2GBIT;
1007 break;
1008 case LA_4GHZ_LINK:
1009 ae->un.PortSpeed = HBA_PORTSPEED_4GBIT;
1010 break;
1011 default:
1012 ae->un.PortSpeed =
1013 HBA_PORTSPEED_UNKNOWN;
1014 break;
1015 }
1016 pab->ab.EntryCnt++;
1017 size += FOURBYTES + 4;
1018
1019 /* #4 Port attribute entry */
1020 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1021 ae->ad.bits.AttrType = be16_to_cpu(MAX_FRAME_SIZE);
1022 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1023 hsp = (struct serv_parm *) & phba->fc_sparam;
1024 ae->un.MaxFrameSize =
1025 (((uint32_t) hsp->cmn.
1026 bbRcvSizeMsb) << 8) | (uint32_t) hsp->cmn.
1027 bbRcvSizeLsb;
1028 pab->ab.EntryCnt++;
1029 size += FOURBYTES + 4;
1030
1031 /* #5 Port attribute entry */
1032 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1033 ae->ad.bits.AttrType = be16_to_cpu(OS_DEVICE_NAME);
1034 strcpy((char *)ae->un.OsDeviceName, LPFC_DRIVER_NAME);
1035 len = strlen((char *)ae->un.OsDeviceName);
1036 len += (len & 3) ? (4 - (len & 3)) : 4;
1037 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1038 pab->ab.EntryCnt++;
1039 size += FOURBYTES + len;
1040
1041 if (phba->cfg_fdmi_on == 2) {
1042 /* #6 Port attribute entry */
1043 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab +
1044 size);
1045 ae->ad.bits.AttrType = be16_to_cpu(HOST_NAME);
1046 sprintf(ae->un.HostName, "%s",
1047 system_utsname.nodename);
1048 len = strlen(ae->un.HostName);
1049 len += (len & 3) ? (4 - (len & 3)) : 4;
1050 ae->ad.bits.AttrLen =
1051 be16_to_cpu(FOURBYTES + len);
1052 pab->ab.EntryCnt++;
1053 size += FOURBYTES + len;
1054 }
1055
1056 pab->ab.EntryCnt = be32_to_cpu(pab->ab.EntryCnt);
1057 /* Total size */
1058 size = GID_REQUEST_SZ - 4 + size;
1059 }
1060 break;
1061
1062 case SLI_MGMT_DHBA:
1063 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DHBA);
1064 CtReq->CommandResponse.bits.Size = 0;
1065 pe = (PORT_ENTRY *) & CtReq->un.PortID;
1066 memcpy((uint8_t *) & pe->PortName,
1067 (uint8_t *) & phba->fc_sparam.portName,
1068 sizeof (struct lpfc_name));
1069 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name);
1070 break;
1071
1072 case SLI_MGMT_DPRT:
1073 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DPRT);
1074 CtReq->CommandResponse.bits.Size = 0;
1075 pe = (PORT_ENTRY *) & CtReq->un.PortID;
1076 memcpy((uint8_t *) & pe->PortName,
1077 (uint8_t *) & phba->fc_sparam.portName,
1078 sizeof (struct lpfc_name));
1079 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name);
1080 break;
1081 }
1082
1083 bpl = (struct ulp_bde64 *) bmp->virt;
1084 bpl->addrHigh = le32_to_cpu( putPaddrHigh(mp->phys) );
1085 bpl->addrLow = le32_to_cpu( putPaddrLow(mp->phys) );
1086 bpl->tus.f.bdeFlags = 0;
1087 bpl->tus.f.bdeSize = size;
1088 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1089
1090 cmpl = lpfc_cmpl_ct_cmd_fdmi;
1091
1092 if (!lpfc_ct_cmd(phba, mp, bmp, ndlp, cmpl, FC_MAX_NS_RSP))
1093 return 0;
1094
1095 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1096 fdmi_cmd_free_bmp:
1097 kfree(bmp);
1098 fdmi_cmd_free_mpvirt:
1099 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1100 fdmi_cmd_free_mp:
1101 kfree(mp);
1102 fdmi_cmd_exit:
1103 /* Issue FDMI request failed */
1104 lpfc_printf_log(phba,
1105 KERN_INFO,
1106 LOG_DISCOVERY,
1107 "%d:0244 Issue FDMI request failed Data: x%x\n",
1108 phba->brd_no,
1109 cmdcode);
1110 return 1;
1111 }
1112
1113 void
1114 lpfc_fdmi_tmo(unsigned long ptr)
1115 {
1116 struct lpfc_hba *phba = (struct lpfc_hba *)ptr;
1117 unsigned long iflag;
1118
1119 spin_lock_irqsave(phba->host->host_lock, iflag);
1120 if (!(phba->work_hba_events & WORKER_FDMI_TMO)) {
1121 phba->work_hba_events |= WORKER_FDMI_TMO;
1122 if (phba->work_wait)
1123 wake_up(phba->work_wait);
1124 }
1125 spin_unlock_irqrestore(phba->host->host_lock,iflag);
1126 }
1127
1128 void
1129 lpfc_fdmi_tmo_handler(struct lpfc_hba *phba)
1130 {
1131 struct lpfc_nodelist *ndlp;
1132
1133 spin_lock_irq(phba->host->host_lock);
1134 if (!(phba->work_hba_events & WORKER_FDMI_TMO)) {
1135 spin_unlock_irq(phba->host->host_lock);
1136 return;
1137 }
1138 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, FDMI_DID);
1139 if (ndlp) {
1140 if (system_utsname.nodename[0] != '\0') {
1141 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_DHBA);
1142 } else {
1143 mod_timer(&phba->fc_fdmitmo, jiffies + HZ * 60);
1144 }
1145 }
1146 spin_unlock_irq(phba->host->host_lock);
1147 return;
1148 }
1149
1150
1151 void
1152 lpfc_decode_firmware_rev(struct lpfc_hba * phba, char *fwrevision, int flag)
1153 {
1154 struct lpfc_sli *psli = &phba->sli;
1155 lpfc_vpd_t *vp = &phba->vpd;
1156 uint32_t b1, b2, b3, b4, i, rev;
1157 char c;
1158 uint32_t *ptr, str[4];
1159 uint8_t *fwname;
1160
1161 if (vp->rev.rBit) {
1162 if (psli->sli_flag & LPFC_SLI2_ACTIVE)
1163 rev = vp->rev.sli2FwRev;
1164 else
1165 rev = vp->rev.sli1FwRev;
1166
1167 b1 = (rev & 0x0000f000) >> 12;
1168 b2 = (rev & 0x00000f00) >> 8;
1169 b3 = (rev & 0x000000c0) >> 6;
1170 b4 = (rev & 0x00000030) >> 4;
1171
1172 switch (b4) {
1173 case 0:
1174 c = 'N';
1175 break;
1176 case 1:
1177 c = 'A';
1178 break;
1179 case 2:
1180 c = 'B';
1181 break;
1182 default:
1183 c = 0;
1184 break;
1185 }
1186 b4 = (rev & 0x0000000f);
1187
1188 if (psli->sli_flag & LPFC_SLI2_ACTIVE)
1189 fwname = vp->rev.sli2FwName;
1190 else
1191 fwname = vp->rev.sli1FwName;
1192
1193 for (i = 0; i < 16; i++)
1194 if (fwname[i] == 0x20)
1195 fwname[i] = 0;
1196
1197 ptr = (uint32_t*)fwname;
1198
1199 for (i = 0; i < 3; i++)
1200 str[i] = be32_to_cpu(*ptr++);
1201
1202 if (c == 0) {
1203 if (flag)
1204 sprintf(fwrevision, "%d.%d%d (%s)",
1205 b1, b2, b3, (char *)str);
1206 else
1207 sprintf(fwrevision, "%d.%d%d", b1,
1208 b2, b3);
1209 } else {
1210 if (flag)
1211 sprintf(fwrevision, "%d.%d%d%c%d (%s)",
1212 b1, b2, b3, c,
1213 b4, (char *)str);
1214 else
1215 sprintf(fwrevision, "%d.%d%d%c%d",
1216 b1, b2, b3, c, b4);
1217 }
1218 } else {
1219 rev = vp->rev.smFwRev;
1220
1221 b1 = (rev & 0xff000000) >> 24;
1222 b2 = (rev & 0x00f00000) >> 20;
1223 b3 = (rev & 0x000f0000) >> 16;
1224 c = (rev & 0x0000ff00) >> 8;
1225 b4 = (rev & 0x000000ff);
1226
1227 if (flag)
1228 sprintf(fwrevision, "%d.%d%d%c%d ", b1,
1229 b2, b3, c, b4);
1230 else
1231 sprintf(fwrevision, "%d.%d%d%c%d ", b1,
1232 b2, b3, c, b4);
1233 }
1234 return;
1235 }
Linux kernel - Deliverables
This page took 0.136596 seconds and 5 git commands to generate.