1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2009-2010 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
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 *******************************************************************/
21 #include <linux/interrupt.h>
22 #include <linux/mempool.h>
23 #include <linux/pci.h>
24 #include <linux/slab.h>
25 #include <linux/delay.h>
27 #include <scsi/scsi.h>
28 #include <scsi/scsi_host.h>
29 #include <scsi/scsi_transport_fc.h>
30 #include <scsi/scsi_bsg_fc.h>
31 #include <scsi/fc/fc_fs.h>
36 #include "lpfc_sli4.h"
39 #include "lpfc_disc.h"
40 #include "lpfc_scsi.h"
42 #include "lpfc_logmsg.h"
43 #include "lpfc_crtn.h"
44 #include "lpfc_vport.h"
45 #include "lpfc_version.h"
47 struct lpfc_bsg_event
{
48 struct list_head node
;
52 /* Event type and waiter identifiers */
57 /* next two flags are here for the auto-delete logic */
58 unsigned long wait_time_stamp
;
61 /* seen and not seen events */
62 struct list_head events_to_get
;
63 struct list_head events_to_see
;
65 /* job waiting for this event to finish */
66 struct fc_bsg_job
*set_job
;
69 struct lpfc_bsg_iocb
{
70 struct lpfc_iocbq
*cmdiocbq
;
71 struct lpfc_iocbq
*rspiocbq
;
72 struct lpfc_dmabuf
*bmp
;
73 struct lpfc_nodelist
*ndlp
;
75 /* job waiting for this iocb to finish */
76 struct fc_bsg_job
*set_job
;
79 struct lpfc_bsg_mbox
{
82 struct lpfc_dmabuf
*rxbmp
; /* for BIU diags */
83 struct lpfc_dmabufext
*dmp
; /* for BIU diags */
84 uint8_t *ext
; /* extended mailbox data */
85 uint32_t mbOffset
; /* from app */
86 uint32_t inExtWLen
; /* from app */
87 uint32_t outExtWLen
; /* from app */
89 /* job waiting for this mbox command to finish */
90 struct fc_bsg_job
*set_job
;
93 #define MENLO_DID 0x0000FC0E
95 struct lpfc_bsg_menlo
{
96 struct lpfc_iocbq
*cmdiocbq
;
97 struct lpfc_iocbq
*rspiocbq
;
98 struct lpfc_dmabuf
*bmp
;
100 /* job waiting for this iocb to finish */
101 struct fc_bsg_job
*set_job
;
108 struct bsg_job_data
{
111 struct lpfc_bsg_event
*evt
;
112 struct lpfc_bsg_iocb iocb
;
113 struct lpfc_bsg_mbox mbox
;
114 struct lpfc_bsg_menlo menlo
;
119 struct list_head node
;
126 #define BUF_SZ_4K 4096
127 #define SLI_CT_ELX_LOOPBACK 0x10
129 enum ELX_LOOPBACK_CMD
{
130 ELX_LOOPBACK_XRI_SETUP
,
134 #define ELX_LOOPBACK_HEADER_SZ \
135 (size_t)(&((struct lpfc_sli_ct_request *)NULL)->un)
137 struct lpfc_dmabufext
{
138 struct lpfc_dmabuf dma
;
144 * lpfc_bsg_send_mgmt_cmd_cmp - lpfc_bsg_send_mgmt_cmd's completion handler
145 * @phba: Pointer to HBA context object.
146 * @cmdiocbq: Pointer to command iocb.
147 * @rspiocbq: Pointer to response iocb.
149 * This function is the completion handler for iocbs issued using
150 * lpfc_bsg_send_mgmt_cmd function. This function is called by the
151 * ring event handler function without any lock held. This function
152 * can be called from both worker thread context and interrupt
153 * context. This function also can be called from another thread which
154 * cleans up the SLI layer objects.
155 * This function copies the contents of the response iocb to the
156 * response iocb memory object provided by the caller of
157 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
158 * sleeps for the iocb completion.
161 lpfc_bsg_send_mgmt_cmd_cmp(struct lpfc_hba
*phba
,
162 struct lpfc_iocbq
*cmdiocbq
,
163 struct lpfc_iocbq
*rspiocbq
)
165 unsigned long iflags
;
166 struct bsg_job_data
*dd_data
;
167 struct fc_bsg_job
*job
;
169 struct lpfc_dmabuf
*bmp
;
170 struct lpfc_nodelist
*ndlp
;
171 struct lpfc_bsg_iocb
*iocb
;
175 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
176 dd_data
= cmdiocbq
->context1
;
178 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
182 iocb
= &dd_data
->context_un
.iocb
;
184 job
->dd_data
= NULL
; /* so timeout handler does not reply */
186 spin_lock_irqsave(&phba
->hbalock
, iflags
);
187 cmdiocbq
->iocb_flag
|= LPFC_IO_WAKE
;
188 if (cmdiocbq
->context2
&& rspiocbq
)
189 memcpy(&((struct lpfc_iocbq
*)cmdiocbq
->context2
)->iocb
,
190 &rspiocbq
->iocb
, sizeof(IOCB_t
));
191 spin_unlock_irqrestore(&phba
->hbalock
, iflags
);
194 rspiocbq
= iocb
->rspiocbq
;
195 rsp
= &rspiocbq
->iocb
;
198 pci_unmap_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
199 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
200 pci_unmap_sg(phba
->pcidev
, job
->reply_payload
.sg_list
,
201 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
203 if (rsp
->ulpStatus
) {
204 if (rsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) {
205 switch (rsp
->un
.ulpWord
[4] & 0xff) {
206 case IOERR_SEQUENCE_TIMEOUT
:
209 case IOERR_INVALID_RPI
:
219 job
->reply
->reply_payload_rcv_len
=
220 rsp
->un
.genreq64
.bdl
.bdeSize
;
222 lpfc_mbuf_free(phba
, bmp
->virt
, bmp
->phys
);
223 lpfc_sli_release_iocbq(phba
, rspiocbq
);
224 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
228 /* make error code available to userspace */
229 job
->reply
->result
= rc
;
230 /* complete the job back to userspace */
232 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
237 * lpfc_bsg_send_mgmt_cmd - send a CT command from a bsg request
238 * @job: fc_bsg_job to handle
241 lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job
*job
)
243 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
244 struct lpfc_hba
*phba
= vport
->phba
;
245 struct lpfc_rport_data
*rdata
= job
->rport
->dd_data
;
246 struct lpfc_nodelist
*ndlp
= rdata
->pnode
;
247 struct ulp_bde64
*bpl
= NULL
;
249 struct lpfc_iocbq
*cmdiocbq
= NULL
;
250 struct lpfc_iocbq
*rspiocbq
= NULL
;
253 struct lpfc_dmabuf
*bmp
= NULL
;
256 struct scatterlist
*sgel
= NULL
;
259 struct bsg_job_data
*dd_data
;
263 /* in case no data is transferred */
264 job
->reply
->reply_payload_rcv_len
= 0;
266 /* allocate our bsg tracking structure */
267 dd_data
= kmalloc(sizeof(struct bsg_job_data
), GFP_KERNEL
);
269 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
270 "2733 Failed allocation of dd_data\n");
275 if (!lpfc_nlp_get(ndlp
)) {
280 bmp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
286 if (ndlp
->nlp_flag
& NLP_ELS_SND_MASK
) {
291 cmdiocbq
= lpfc_sli_get_iocbq(phba
);
297 cmd
= &cmdiocbq
->iocb
;
298 rspiocbq
= lpfc_sli_get_iocbq(phba
);
304 rsp
= &rspiocbq
->iocb
;
305 bmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &bmp
->phys
);
311 INIT_LIST_HEAD(&bmp
->list
);
312 bpl
= (struct ulp_bde64
*) bmp
->virt
;
313 request_nseg
= pci_map_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
314 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
315 for_each_sg(job
->request_payload
.sg_list
, sgel
, request_nseg
, numbde
) {
316 busaddr
= sg_dma_address(sgel
);
317 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
318 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
319 bpl
->tus
.w
= cpu_to_le32(bpl
->tus
.w
);
320 bpl
->addrLow
= cpu_to_le32(putPaddrLow(busaddr
));
321 bpl
->addrHigh
= cpu_to_le32(putPaddrHigh(busaddr
));
325 reply_nseg
= pci_map_sg(phba
->pcidev
, job
->reply_payload
.sg_list
,
326 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
327 for_each_sg(job
->reply_payload
.sg_list
, sgel
, reply_nseg
, numbde
) {
328 busaddr
= sg_dma_address(sgel
);
329 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64I
;
330 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
331 bpl
->tus
.w
= cpu_to_le32(bpl
->tus
.w
);
332 bpl
->addrLow
= cpu_to_le32(putPaddrLow(busaddr
));
333 bpl
->addrHigh
= cpu_to_le32(putPaddrHigh(busaddr
));
337 cmd
->un
.genreq64
.bdl
.ulpIoTag32
= 0;
338 cmd
->un
.genreq64
.bdl
.addrHigh
= putPaddrHigh(bmp
->phys
);
339 cmd
->un
.genreq64
.bdl
.addrLow
= putPaddrLow(bmp
->phys
);
340 cmd
->un
.genreq64
.bdl
.bdeFlags
= BUFF_TYPE_BLP_64
;
341 cmd
->un
.genreq64
.bdl
.bdeSize
=
342 (request_nseg
+ reply_nseg
) * sizeof(struct ulp_bde64
);
343 cmd
->ulpCommand
= CMD_GEN_REQUEST64_CR
;
344 cmd
->un
.genreq64
.w5
.hcsw
.Fctl
= (SI
| LA
);
345 cmd
->un
.genreq64
.w5
.hcsw
.Dfctl
= 0;
346 cmd
->un
.genreq64
.w5
.hcsw
.Rctl
= FC_RCTL_DD_UNSOL_CTL
;
347 cmd
->un
.genreq64
.w5
.hcsw
.Type
= FC_TYPE_CT
;
348 cmd
->ulpBdeCount
= 1;
350 cmd
->ulpClass
= CLASS3
;
351 cmd
->ulpContext
= ndlp
->nlp_rpi
;
352 cmd
->ulpOwner
= OWN_CHIP
;
353 cmdiocbq
->vport
= phba
->pport
;
354 cmdiocbq
->context3
= bmp
;
355 cmdiocbq
->iocb_flag
|= LPFC_IO_LIBDFC
;
356 timeout
= phba
->fc_ratov
* 2;
357 cmd
->ulpTimeout
= timeout
;
359 cmdiocbq
->iocb_cmpl
= lpfc_bsg_send_mgmt_cmd_cmp
;
360 cmdiocbq
->context1
= dd_data
;
361 cmdiocbq
->context2
= rspiocbq
;
362 dd_data
->type
= TYPE_IOCB
;
363 dd_data
->context_un
.iocb
.cmdiocbq
= cmdiocbq
;
364 dd_data
->context_un
.iocb
.rspiocbq
= rspiocbq
;
365 dd_data
->context_un
.iocb
.set_job
= job
;
366 dd_data
->context_un
.iocb
.bmp
= bmp
;
367 dd_data
->context_un
.iocb
.ndlp
= ndlp
;
369 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
) {
370 creg_val
= readl(phba
->HCregaddr
);
371 creg_val
|= (HC_R0INT_ENA
<< LPFC_FCP_RING
);
372 writel(creg_val
, phba
->HCregaddr
);
373 readl(phba
->HCregaddr
); /* flush */
376 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, cmdiocbq
, 0);
378 if (rc
== IOCB_SUCCESS
)
379 return 0; /* done for now */
380 else if (rc
== IOCB_BUSY
)
386 /* iocb failed so cleanup */
387 pci_unmap_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
388 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
389 pci_unmap_sg(phba
->pcidev
, job
->reply_payload
.sg_list
,
390 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
392 lpfc_mbuf_free(phba
, bmp
->virt
, bmp
->phys
);
395 lpfc_sli_release_iocbq(phba
, rspiocbq
);
397 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
405 /* make error code available to userspace */
406 job
->reply
->result
= rc
;
412 * lpfc_bsg_rport_els_cmp - lpfc_bsg_rport_els's completion handler
413 * @phba: Pointer to HBA context object.
414 * @cmdiocbq: Pointer to command iocb.
415 * @rspiocbq: Pointer to response iocb.
417 * This function is the completion handler for iocbs issued using
418 * lpfc_bsg_rport_els_cmp function. This function is called by the
419 * ring event handler function without any lock held. This function
420 * can be called from both worker thread context and interrupt
421 * context. This function also can be called from other thread which
422 * cleans up the SLI layer objects.
423 * This function copies the contents of the response iocb to the
424 * response iocb memory object provided by the caller of
425 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
426 * sleeps for the iocb completion.
429 lpfc_bsg_rport_els_cmp(struct lpfc_hba
*phba
,
430 struct lpfc_iocbq
*cmdiocbq
,
431 struct lpfc_iocbq
*rspiocbq
)
433 struct bsg_job_data
*dd_data
;
434 struct fc_bsg_job
*job
;
436 struct lpfc_nodelist
*ndlp
;
437 struct lpfc_dmabuf
*pbuflist
= NULL
;
438 struct fc_bsg_ctels_reply
*els_reply
;
443 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
444 dd_data
= cmdiocbq
->context1
;
445 /* normal completion and timeout crossed paths, already done */
447 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
451 cmdiocbq
->iocb_flag
|= LPFC_IO_WAKE
;
452 if (cmdiocbq
->context2
&& rspiocbq
)
453 memcpy(&((struct lpfc_iocbq
*)cmdiocbq
->context2
)->iocb
,
454 &rspiocbq
->iocb
, sizeof(IOCB_t
));
456 job
= dd_data
->context_un
.iocb
.set_job
;
457 cmdiocbq
= dd_data
->context_un
.iocb
.cmdiocbq
;
458 rspiocbq
= dd_data
->context_un
.iocb
.rspiocbq
;
459 rsp
= &rspiocbq
->iocb
;
460 ndlp
= dd_data
->context_un
.iocb
.ndlp
;
462 pci_unmap_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
463 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
464 pci_unmap_sg(phba
->pcidev
, job
->reply_payload
.sg_list
,
465 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
467 if (job
->reply
->result
== -EAGAIN
)
469 else if (rsp
->ulpStatus
== IOSTAT_SUCCESS
)
470 job
->reply
->reply_payload_rcv_len
=
471 rsp
->un
.elsreq64
.bdl
.bdeSize
;
472 else if (rsp
->ulpStatus
== IOSTAT_LS_RJT
) {
473 job
->reply
->reply_payload_rcv_len
=
474 sizeof(struct fc_bsg_ctels_reply
);
475 /* LS_RJT data returned in word 4 */
476 rjt_data
= (uint8_t *)&rsp
->un
.ulpWord
[4];
477 els_reply
= &job
->reply
->reply_data
.ctels_reply
;
478 els_reply
->status
= FC_CTELS_STATUS_REJECT
;
479 els_reply
->rjt_data
.action
= rjt_data
[3];
480 els_reply
->rjt_data
.reason_code
= rjt_data
[2];
481 els_reply
->rjt_data
.reason_explanation
= rjt_data
[1];
482 els_reply
->rjt_data
.vendor_unique
= rjt_data
[0];
486 pbuflist
= (struct lpfc_dmabuf
*) cmdiocbq
->context3
;
487 lpfc_mbuf_free(phba
, pbuflist
->virt
, pbuflist
->phys
);
488 lpfc_sli_release_iocbq(phba
, rspiocbq
);
489 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
492 /* make error code available to userspace */
493 job
->reply
->result
= rc
;
495 /* complete the job back to userspace */
497 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
502 * lpfc_bsg_rport_els - send an ELS command from a bsg request
503 * @job: fc_bsg_job to handle
506 lpfc_bsg_rport_els(struct fc_bsg_job
*job
)
508 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
509 struct lpfc_hba
*phba
= vport
->phba
;
510 struct lpfc_rport_data
*rdata
= job
->rport
->dd_data
;
511 struct lpfc_nodelist
*ndlp
= rdata
->pnode
;
515 struct lpfc_iocbq
*rspiocbq
;
516 struct lpfc_iocbq
*cmdiocbq
;
519 struct lpfc_dmabuf
*pcmd
;
520 struct lpfc_dmabuf
*prsp
;
521 struct lpfc_dmabuf
*pbuflist
= NULL
;
522 struct ulp_bde64
*bpl
;
525 struct scatterlist
*sgel
= NULL
;
528 struct bsg_job_data
*dd_data
;
532 /* in case no data is transferred */
533 job
->reply
->reply_payload_rcv_len
= 0;
535 /* allocate our bsg tracking structure */
536 dd_data
= kmalloc(sizeof(struct bsg_job_data
), GFP_KERNEL
);
538 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
539 "2735 Failed allocation of dd_data\n");
544 if (!lpfc_nlp_get(ndlp
)) {
549 elscmd
= job
->request
->rqst_data
.r_els
.els_code
;
550 cmdsize
= job
->request_payload
.payload_len
;
551 rspsize
= job
->reply_payload
.payload_len
;
552 rspiocbq
= lpfc_sli_get_iocbq(phba
);
559 rsp
= &rspiocbq
->iocb
;
562 cmdiocbq
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, 0, ndlp
,
563 ndlp
->nlp_DID
, elscmd
);
569 /* prep els iocb set context1 to the ndlp, context2 to the command
570 * dmabuf, context3 holds the data dmabuf
572 pcmd
= (struct lpfc_dmabuf
*) cmdiocbq
->context2
;
573 prsp
= (struct lpfc_dmabuf
*) pcmd
->list
.next
;
574 lpfc_mbuf_free(phba
, pcmd
->virt
, pcmd
->phys
);
576 lpfc_mbuf_free(phba
, prsp
->virt
, prsp
->phys
);
578 cmdiocbq
->context2
= NULL
;
580 pbuflist
= (struct lpfc_dmabuf
*) cmdiocbq
->context3
;
581 bpl
= (struct ulp_bde64
*) pbuflist
->virt
;
583 request_nseg
= pci_map_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
584 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
585 for_each_sg(job
->request_payload
.sg_list
, sgel
, request_nseg
, numbde
) {
586 busaddr
= sg_dma_address(sgel
);
587 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
588 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
589 bpl
->tus
.w
= cpu_to_le32(bpl
->tus
.w
);
590 bpl
->addrLow
= cpu_to_le32(putPaddrLow(busaddr
));
591 bpl
->addrHigh
= cpu_to_le32(putPaddrHigh(busaddr
));
595 reply_nseg
= pci_map_sg(phba
->pcidev
, job
->reply_payload
.sg_list
,
596 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
597 for_each_sg(job
->reply_payload
.sg_list
, sgel
, reply_nseg
, numbde
) {
598 busaddr
= sg_dma_address(sgel
);
599 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64I
;
600 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
601 bpl
->tus
.w
= cpu_to_le32(bpl
->tus
.w
);
602 bpl
->addrLow
= cpu_to_le32(putPaddrLow(busaddr
));
603 bpl
->addrHigh
= cpu_to_le32(putPaddrHigh(busaddr
));
606 cmdiocbq
->iocb
.un
.elsreq64
.bdl
.bdeSize
=
607 (request_nseg
+ reply_nseg
) * sizeof(struct ulp_bde64
);
608 cmdiocbq
->iocb
.ulpContext
= rpi
;
609 cmdiocbq
->iocb_flag
|= LPFC_IO_LIBDFC
;
610 cmdiocbq
->context1
= NULL
;
611 cmdiocbq
->context2
= NULL
;
613 cmdiocbq
->iocb_cmpl
= lpfc_bsg_rport_els_cmp
;
614 cmdiocbq
->context1
= dd_data
;
615 cmdiocbq
->context2
= rspiocbq
;
616 dd_data
->type
= TYPE_IOCB
;
617 dd_data
->context_un
.iocb
.cmdiocbq
= cmdiocbq
;
618 dd_data
->context_un
.iocb
.rspiocbq
= rspiocbq
;
619 dd_data
->context_un
.iocb
.set_job
= job
;
620 dd_data
->context_un
.iocb
.bmp
= NULL
;;
621 dd_data
->context_un
.iocb
.ndlp
= ndlp
;
623 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
) {
624 creg_val
= readl(phba
->HCregaddr
);
625 creg_val
|= (HC_R0INT_ENA
<< LPFC_FCP_RING
);
626 writel(creg_val
, phba
->HCregaddr
);
627 readl(phba
->HCregaddr
); /* flush */
629 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, cmdiocbq
, 0);
631 if (rc
== IOCB_SUCCESS
)
632 return 0; /* done for now */
633 else if (rc
== IOCB_BUSY
)
638 pci_unmap_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
639 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
640 pci_unmap_sg(phba
->pcidev
, job
->reply_payload
.sg_list
,
641 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
643 lpfc_mbuf_free(phba
, pbuflist
->virt
, pbuflist
->phys
);
645 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
648 lpfc_sli_release_iocbq(phba
, rspiocbq
);
654 /* make error code available to userspace */
655 job
->reply
->result
= rc
;
661 * lpfc_bsg_event_free - frees an allocated event structure
662 * @kref: Pointer to a kref.
664 * Called from kref_put. Back cast the kref into an event structure address.
665 * Free any events to get, delete associated nodes, free any events to see,
666 * free any data then free the event itself.
669 lpfc_bsg_event_free(struct kref
*kref
)
671 struct lpfc_bsg_event
*evt
= container_of(kref
, struct lpfc_bsg_event
,
673 struct event_data
*ed
;
675 list_del(&evt
->node
);
677 while (!list_empty(&evt
->events_to_get
)) {
678 ed
= list_entry(evt
->events_to_get
.next
, typeof(*ed
), node
);
684 while (!list_empty(&evt
->events_to_see
)) {
685 ed
= list_entry(evt
->events_to_see
.next
, typeof(*ed
), node
);
695 * lpfc_bsg_event_ref - increments the kref for an event
696 * @evt: Pointer to an event structure.
699 lpfc_bsg_event_ref(struct lpfc_bsg_event
*evt
)
701 kref_get(&evt
->kref
);
705 * lpfc_bsg_event_unref - Uses kref_put to free an event structure
706 * @evt: Pointer to an event structure.
709 lpfc_bsg_event_unref(struct lpfc_bsg_event
*evt
)
711 kref_put(&evt
->kref
, lpfc_bsg_event_free
);
715 * lpfc_bsg_event_new - allocate and initialize a event structure
716 * @ev_mask: Mask of events.
717 * @ev_reg_id: Event reg id.
718 * @ev_req_id: Event request id.
720 static struct lpfc_bsg_event
*
721 lpfc_bsg_event_new(uint32_t ev_mask
, int ev_reg_id
, uint32_t ev_req_id
)
723 struct lpfc_bsg_event
*evt
= kzalloc(sizeof(*evt
), GFP_KERNEL
);
728 INIT_LIST_HEAD(&evt
->events_to_get
);
729 INIT_LIST_HEAD(&evt
->events_to_see
);
730 evt
->type_mask
= ev_mask
;
731 evt
->req_id
= ev_req_id
;
732 evt
->reg_id
= ev_reg_id
;
733 evt
->wait_time_stamp
= jiffies
;
734 init_waitqueue_head(&evt
->wq
);
735 kref_init(&evt
->kref
);
740 * diag_cmd_data_free - Frees an lpfc dma buffer extension
741 * @phba: Pointer to HBA context object.
742 * @mlist: Pointer to an lpfc dma buffer extension.
745 diag_cmd_data_free(struct lpfc_hba
*phba
, struct lpfc_dmabufext
*mlist
)
747 struct lpfc_dmabufext
*mlast
;
748 struct pci_dev
*pcidev
;
749 struct list_head head
, *curr
, *next
;
751 if ((!mlist
) || (!lpfc_is_link_up(phba
) &&
752 (phba
->link_flag
& LS_LOOPBACK_MODE
))) {
756 pcidev
= phba
->pcidev
;
757 list_add_tail(&head
, &mlist
->dma
.list
);
759 list_for_each_safe(curr
, next
, &head
) {
760 mlast
= list_entry(curr
, struct lpfc_dmabufext
, dma
.list
);
762 dma_free_coherent(&pcidev
->dev
,
772 * lpfc_bsg_ct_unsol_event - process an unsolicited CT command
777 * This function is called when an unsolicited CT command is received. It
778 * forwards the event to any processes registered to receive CT events.
781 lpfc_bsg_ct_unsol_event(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
782 struct lpfc_iocbq
*piocbq
)
784 uint32_t evt_req_id
= 0;
787 struct lpfc_dmabuf
*dmabuf
= NULL
;
788 struct lpfc_bsg_event
*evt
;
789 struct event_data
*evt_dat
= NULL
;
790 struct lpfc_iocbq
*iocbq
;
792 struct list_head head
;
793 struct ulp_bde64
*bde
;
796 struct lpfc_dmabuf
*bdeBuf1
= piocbq
->context2
;
797 struct lpfc_dmabuf
*bdeBuf2
= piocbq
->context3
;
798 struct lpfc_hbq_entry
*hbqe
;
799 struct lpfc_sli_ct_request
*ct_req
;
800 struct fc_bsg_job
*job
= NULL
;
804 INIT_LIST_HEAD(&head
);
805 list_add_tail(&head
, &piocbq
->list
);
807 if (piocbq
->iocb
.ulpBdeCount
== 0 ||
808 piocbq
->iocb
.un
.cont64
[0].tus
.f
.bdeSize
== 0)
809 goto error_ct_unsol_exit
;
811 if (phba
->link_state
== LPFC_HBA_ERROR
||
812 (!(phba
->sli
.sli_flag
& LPFC_SLI_ACTIVE
)))
813 goto error_ct_unsol_exit
;
815 if (phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
)
818 dma_addr
= getPaddr(piocbq
->iocb
.un
.cont64
[0].addrHigh
,
819 piocbq
->iocb
.un
.cont64
[0].addrLow
);
820 dmabuf
= lpfc_sli_ringpostbuf_get(phba
, pring
, dma_addr
);
823 goto error_ct_unsol_exit
;
824 ct_req
= (struct lpfc_sli_ct_request
*)dmabuf
->virt
;
825 evt_req_id
= ct_req
->FsType
;
826 cmd
= ct_req
->CommandResponse
.bits
.CmdRsp
;
827 len
= ct_req
->CommandResponse
.bits
.Size
;
828 if (!(phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
))
829 lpfc_sli_ringpostbuf_put(phba
, pring
, dmabuf
);
831 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
832 list_for_each_entry(evt
, &phba
->ct_ev_waiters
, node
) {
833 if (!(evt
->type_mask
& FC_REG_CT_EVENT
) ||
834 evt
->req_id
!= evt_req_id
)
837 lpfc_bsg_event_ref(evt
);
838 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
839 evt_dat
= kzalloc(sizeof(*evt_dat
), GFP_KERNEL
);
840 if (evt_dat
== NULL
) {
841 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
842 lpfc_bsg_event_unref(evt
);
843 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
844 "2614 Memory allocation failed for "
849 if (phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
) {
850 /* take accumulated byte count from the last iocbq */
851 iocbq
= list_entry(head
.prev
, typeof(*iocbq
), list
);
852 evt_dat
->len
= iocbq
->iocb
.unsli3
.rcvsli3
.acc_len
;
854 list_for_each_entry(iocbq
, &head
, list
) {
855 for (i
= 0; i
< iocbq
->iocb
.ulpBdeCount
; i
++)
857 iocbq
->iocb
.un
.cont64
[i
].tus
.f
.bdeSize
;
861 evt_dat
->data
= kzalloc(evt_dat
->len
, GFP_KERNEL
);
862 if (evt_dat
->data
== NULL
) {
863 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
864 "2615 Memory allocation failed for "
865 "CT event data, size %d\n",
868 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
869 lpfc_bsg_event_unref(evt
);
870 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
871 goto error_ct_unsol_exit
;
874 list_for_each_entry(iocbq
, &head
, list
) {
876 if (phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
) {
877 bdeBuf1
= iocbq
->context2
;
878 bdeBuf2
= iocbq
->context3
;
880 for (i
= 0; i
< iocbq
->iocb
.ulpBdeCount
; i
++) {
881 if (phba
->sli3_options
&
882 LPFC_SLI3_HBQ_ENABLED
) {
884 hbqe
= (struct lpfc_hbq_entry
*)
885 &iocbq
->iocb
.un
.ulpWord
[0];
886 size
= hbqe
->bde
.tus
.f
.bdeSize
;
889 hbqe
= (struct lpfc_hbq_entry
*)
892 size
= hbqe
->bde
.tus
.f
.bdeSize
;
895 if ((offset
+ size
) > evt_dat
->len
)
896 size
= evt_dat
->len
- offset
;
898 size
= iocbq
->iocb
.un
.cont64
[i
].
900 bde
= &iocbq
->iocb
.un
.cont64
[i
];
901 dma_addr
= getPaddr(bde
->addrHigh
,
903 dmabuf
= lpfc_sli_ringpostbuf_get(phba
,
907 lpfc_printf_log(phba
, KERN_ERR
,
908 LOG_LIBDFC
, "2616 No dmabuf "
909 "found for iocbq 0x%p\n",
911 kfree(evt_dat
->data
);
913 spin_lock_irqsave(&phba
->ct_ev_lock
,
915 lpfc_bsg_event_unref(evt
);
916 spin_unlock_irqrestore(
917 &phba
->ct_ev_lock
, flags
);
918 goto error_ct_unsol_exit
;
920 memcpy((char *)(evt_dat
->data
) + offset
,
923 if (evt_req_id
!= SLI_CT_ELX_LOOPBACK
&&
924 !(phba
->sli3_options
&
925 LPFC_SLI3_HBQ_ENABLED
)) {
926 lpfc_sli_ringpostbuf_put(phba
, pring
,
930 case ELX_LOOPBACK_DATA
:
931 diag_cmd_data_free(phba
,
932 (struct lpfc_dmabufext
*)
935 case ELX_LOOPBACK_XRI_SETUP
:
936 if ((phba
->sli_rev
==
938 (phba
->sli3_options
&
939 LPFC_SLI3_HBQ_ENABLED
941 lpfc_in_buf_free(phba
,
944 lpfc_post_buffer(phba
,
950 if (!(phba
->sli3_options
&
951 LPFC_SLI3_HBQ_ENABLED
))
952 lpfc_post_buffer(phba
,
961 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
962 if (phba
->sli_rev
== LPFC_SLI_REV4
) {
963 evt_dat
->immed_dat
= phba
->ctx_idx
;
964 phba
->ctx_idx
= (phba
->ctx_idx
+ 1) % 64;
965 /* Provide warning for over-run of the ct_ctx array */
966 if (phba
->ct_ctx
[evt_dat
->immed_dat
].flags
&
968 lpfc_printf_log(phba
, KERN_WARNING
, LOG_ELS
,
969 "2717 CT context array entry "
970 "[%d] over-run: oxid:x%x, "
971 "sid:x%x\n", phba
->ctx_idx
,
973 evt_dat
->immed_dat
].oxid
,
975 evt_dat
->immed_dat
].SID
);
976 phba
->ct_ctx
[evt_dat
->immed_dat
].oxid
=
977 piocbq
->iocb
.ulpContext
;
978 phba
->ct_ctx
[evt_dat
->immed_dat
].SID
=
979 piocbq
->iocb
.un
.rcvels
.remoteID
;
980 phba
->ct_ctx
[evt_dat
->immed_dat
].flags
= UNSOL_VALID
;
982 evt_dat
->immed_dat
= piocbq
->iocb
.ulpContext
;
984 evt_dat
->type
= FC_REG_CT_EVENT
;
985 list_add(&evt_dat
->node
, &evt
->events_to_see
);
986 if (evt_req_id
== SLI_CT_ELX_LOOPBACK
) {
987 wake_up_interruptible(&evt
->wq
);
988 lpfc_bsg_event_unref(evt
);
992 list_move(evt
->events_to_see
.prev
, &evt
->events_to_get
);
993 lpfc_bsg_event_unref(evt
);
998 job
->reply
->reply_payload_rcv_len
= size
;
999 /* make error code available to userspace */
1000 job
->reply
->result
= 0;
1001 job
->dd_data
= NULL
;
1002 /* complete the job back to userspace */
1003 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1005 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1008 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1010 error_ct_unsol_exit
:
1011 if (!list_empty(&head
))
1013 if (evt_req_id
== SLI_CT_ELX_LOOPBACK
)
1019 * lpfc_bsg_hba_set_event - process a SET_EVENT bsg vendor command
1020 * @job: SET_EVENT fc_bsg_job
1023 lpfc_bsg_hba_set_event(struct fc_bsg_job
*job
)
1025 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
1026 struct lpfc_hba
*phba
= vport
->phba
;
1027 struct set_ct_event
*event_req
;
1028 struct lpfc_bsg_event
*evt
;
1030 struct bsg_job_data
*dd_data
= NULL
;
1032 unsigned long flags
;
1034 if (job
->request_len
<
1035 sizeof(struct fc_bsg_request
) + sizeof(struct set_ct_event
)) {
1036 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
1037 "2612 Received SET_CT_EVENT below minimum "
1043 dd_data
= kmalloc(sizeof(struct bsg_job_data
), GFP_KERNEL
);
1044 if (dd_data
== NULL
) {
1045 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
1046 "2734 Failed allocation of dd_data\n");
1051 event_req
= (struct set_ct_event
*)
1052 job
->request
->rqst_data
.h_vendor
.vendor_cmd
;
1053 ev_mask
= ((uint32_t)(unsigned long)event_req
->type_mask
&
1055 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1056 list_for_each_entry(evt
, &phba
->ct_ev_waiters
, node
) {
1057 if (evt
->reg_id
== event_req
->ev_reg_id
) {
1058 lpfc_bsg_event_ref(evt
);
1059 evt
->wait_time_stamp
= jiffies
;
1063 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1065 if (&evt
->node
== &phba
->ct_ev_waiters
) {
1066 /* no event waiting struct yet - first call */
1067 evt
= lpfc_bsg_event_new(ev_mask
, event_req
->ev_reg_id
,
1068 event_req
->ev_req_id
);
1070 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
1071 "2617 Failed allocation of event "
1077 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1078 list_add(&evt
->node
, &phba
->ct_ev_waiters
);
1079 lpfc_bsg_event_ref(evt
);
1080 evt
->wait_time_stamp
= jiffies
;
1081 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1084 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1086 dd_data
->type
= TYPE_EVT
;
1087 dd_data
->context_un
.evt
= evt
;
1088 evt
->set_job
= job
; /* for unsolicited command */
1089 job
->dd_data
= dd_data
; /* for fc transport timeout callback*/
1090 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1091 return 0; /* call job done later */
1094 if (dd_data
!= NULL
)
1097 job
->dd_data
= NULL
;
1102 * lpfc_bsg_hba_get_event - process a GET_EVENT bsg vendor command
1103 * @job: GET_EVENT fc_bsg_job
1106 lpfc_bsg_hba_get_event(struct fc_bsg_job
*job
)
1108 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
1109 struct lpfc_hba
*phba
= vport
->phba
;
1110 struct get_ct_event
*event_req
;
1111 struct get_ct_event_reply
*event_reply
;
1112 struct lpfc_bsg_event
*evt
;
1113 struct event_data
*evt_dat
= NULL
;
1114 unsigned long flags
;
1117 if (job
->request_len
<
1118 sizeof(struct fc_bsg_request
) + sizeof(struct get_ct_event
)) {
1119 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
1120 "2613 Received GET_CT_EVENT request below "
1126 event_req
= (struct get_ct_event
*)
1127 job
->request
->rqst_data
.h_vendor
.vendor_cmd
;
1129 event_reply
= (struct get_ct_event_reply
*)
1130 job
->reply
->reply_data
.vendor_reply
.vendor_rsp
;
1131 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1132 list_for_each_entry(evt
, &phba
->ct_ev_waiters
, node
) {
1133 if (evt
->reg_id
== event_req
->ev_reg_id
) {
1134 if (list_empty(&evt
->events_to_get
))
1136 lpfc_bsg_event_ref(evt
);
1137 evt
->wait_time_stamp
= jiffies
;
1138 evt_dat
= list_entry(evt
->events_to_get
.prev
,
1139 struct event_data
, node
);
1140 list_del(&evt_dat
->node
);
1144 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1146 /* The app may continue to ask for event data until it gets
1147 * an error indicating that there isn't anymore
1149 if (evt_dat
== NULL
) {
1150 job
->reply
->reply_payload_rcv_len
= 0;
1155 if (evt_dat
->len
> job
->request_payload
.payload_len
) {
1156 evt_dat
->len
= job
->request_payload
.payload_len
;
1157 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
1158 "2618 Truncated event data at %d "
1160 job
->request_payload
.payload_len
);
1163 event_reply
->type
= evt_dat
->type
;
1164 event_reply
->immed_data
= evt_dat
->immed_dat
;
1165 if (evt_dat
->len
> 0)
1166 job
->reply
->reply_payload_rcv_len
=
1167 sg_copy_from_buffer(job
->request_payload
.sg_list
,
1168 job
->request_payload
.sg_cnt
,
1169 evt_dat
->data
, evt_dat
->len
);
1171 job
->reply
->reply_payload_rcv_len
= 0;
1174 kfree(evt_dat
->data
);
1178 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1179 lpfc_bsg_event_unref(evt
);
1180 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1181 job
->dd_data
= NULL
;
1182 job
->reply
->result
= 0;
1187 job
->dd_data
= NULL
;
1188 job
->reply
->result
= rc
;
1193 * lpfc_issue_ct_rsp_cmp - lpfc_issue_ct_rsp's completion handler
1194 * @phba: Pointer to HBA context object.
1195 * @cmdiocbq: Pointer to command iocb.
1196 * @rspiocbq: Pointer to response iocb.
1198 * This function is the completion handler for iocbs issued using
1199 * lpfc_issue_ct_rsp_cmp function. This function is called by the
1200 * ring event handler function without any lock held. This function
1201 * can be called from both worker thread context and interrupt
1202 * context. This function also can be called from other thread which
1203 * cleans up the SLI layer objects.
1204 * This function copy the contents of the response iocb to the
1205 * response iocb memory object provided by the caller of
1206 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
1207 * sleeps for the iocb completion.
1210 lpfc_issue_ct_rsp_cmp(struct lpfc_hba
*phba
,
1211 struct lpfc_iocbq
*cmdiocbq
,
1212 struct lpfc_iocbq
*rspiocbq
)
1214 struct bsg_job_data
*dd_data
;
1215 struct fc_bsg_job
*job
;
1217 struct lpfc_dmabuf
*bmp
;
1218 struct lpfc_nodelist
*ndlp
;
1219 unsigned long flags
;
1222 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1223 dd_data
= cmdiocbq
->context1
;
1224 /* normal completion and timeout crossed paths, already done */
1226 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1230 job
= dd_data
->context_un
.iocb
.set_job
;
1231 bmp
= dd_data
->context_un
.iocb
.bmp
;
1232 rsp
= &rspiocbq
->iocb
;
1233 ndlp
= dd_data
->context_un
.iocb
.ndlp
;
1235 pci_unmap_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
1236 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
1238 if (rsp
->ulpStatus
) {
1239 if (rsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) {
1240 switch (rsp
->un
.ulpWord
[4] & 0xff) {
1241 case IOERR_SEQUENCE_TIMEOUT
:
1244 case IOERR_INVALID_RPI
:
1254 job
->reply
->reply_payload_rcv_len
=
1255 rsp
->un
.genreq64
.bdl
.bdeSize
;
1257 lpfc_mbuf_free(phba
, bmp
->virt
, bmp
->phys
);
1258 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
1262 /* make error code available to userspace */
1263 job
->reply
->result
= rc
;
1264 job
->dd_data
= NULL
;
1265 /* complete the job back to userspace */
1267 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1272 * lpfc_issue_ct_rsp - issue a ct response
1273 * @phba: Pointer to HBA context object.
1274 * @job: Pointer to the job object.
1275 * @tag: tag index value into the ports context exchange array.
1276 * @bmp: Pointer to a dma buffer descriptor.
1277 * @num_entry: Number of enties in the bde.
1280 lpfc_issue_ct_rsp(struct lpfc_hba
*phba
, struct fc_bsg_job
*job
, uint32_t tag
,
1281 struct lpfc_dmabuf
*bmp
, int num_entry
)
1284 struct lpfc_iocbq
*ctiocb
= NULL
;
1286 struct lpfc_nodelist
*ndlp
= NULL
;
1287 struct bsg_job_data
*dd_data
;
1290 /* allocate our bsg tracking structure */
1291 dd_data
= kmalloc(sizeof(struct bsg_job_data
), GFP_KERNEL
);
1293 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
1294 "2736 Failed allocation of dd_data\n");
1299 /* Allocate buffer for command iocb */
1300 ctiocb
= lpfc_sli_get_iocbq(phba
);
1306 icmd
= &ctiocb
->iocb
;
1307 icmd
->un
.xseq64
.bdl
.ulpIoTag32
= 0;
1308 icmd
->un
.xseq64
.bdl
.addrHigh
= putPaddrHigh(bmp
->phys
);
1309 icmd
->un
.xseq64
.bdl
.addrLow
= putPaddrLow(bmp
->phys
);
1310 icmd
->un
.xseq64
.bdl
.bdeFlags
= BUFF_TYPE_BLP_64
;
1311 icmd
->un
.xseq64
.bdl
.bdeSize
= (num_entry
* sizeof(struct ulp_bde64
));
1312 icmd
->un
.xseq64
.w5
.hcsw
.Fctl
= (LS
| LA
);
1313 icmd
->un
.xseq64
.w5
.hcsw
.Dfctl
= 0;
1314 icmd
->un
.xseq64
.w5
.hcsw
.Rctl
= FC_RCTL_DD_SOL_CTL
;
1315 icmd
->un
.xseq64
.w5
.hcsw
.Type
= FC_TYPE_CT
;
1317 /* Fill in rest of iocb */
1318 icmd
->ulpCommand
= CMD_XMIT_SEQUENCE64_CX
;
1319 icmd
->ulpBdeCount
= 1;
1321 icmd
->ulpClass
= CLASS3
;
1322 if (phba
->sli_rev
== LPFC_SLI_REV4
) {
1323 /* Do not issue unsol response if oxid not marked as valid */
1324 if (!(phba
->ct_ctx
[tag
].flags
& UNSOL_VALID
)) {
1326 goto issue_ct_rsp_exit
;
1328 icmd
->ulpContext
= phba
->ct_ctx
[tag
].oxid
;
1329 ndlp
= lpfc_findnode_did(phba
->pport
, phba
->ct_ctx
[tag
].SID
);
1331 lpfc_printf_log(phba
, KERN_WARNING
, LOG_ELS
,
1332 "2721 ndlp null for oxid %x SID %x\n",
1334 phba
->ct_ctx
[tag
].SID
);
1336 goto issue_ct_rsp_exit
;
1339 /* Check if the ndlp is active */
1340 if (!ndlp
|| !NLP_CHK_NODE_ACT(ndlp
)) {
1342 goto issue_ct_rsp_exit
;
1345 /* get a refernece count so the ndlp doesn't go away while
1348 if (!lpfc_nlp_get(ndlp
)) {
1350 goto issue_ct_rsp_exit
;
1353 icmd
->un
.ulpWord
[3] = ndlp
->nlp_rpi
;
1354 /* The exchange is done, mark the entry as invalid */
1355 phba
->ct_ctx
[tag
].flags
&= ~UNSOL_VALID
;
1357 icmd
->ulpContext
= (ushort
) tag
;
1359 icmd
->ulpTimeout
= phba
->fc_ratov
* 2;
1361 /* Xmit CT response on exchange <xid> */
1362 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1363 "2722 Xmit CT response on exchange x%x Data: x%x x%x\n",
1364 icmd
->ulpContext
, icmd
->ulpIoTag
, phba
->link_state
);
1366 ctiocb
->iocb_cmpl
= NULL
;
1367 ctiocb
->iocb_flag
|= LPFC_IO_LIBDFC
;
1368 ctiocb
->vport
= phba
->pport
;
1369 ctiocb
->context3
= bmp
;
1371 ctiocb
->iocb_cmpl
= lpfc_issue_ct_rsp_cmp
;
1372 ctiocb
->context1
= dd_data
;
1373 ctiocb
->context2
= NULL
;
1374 dd_data
->type
= TYPE_IOCB
;
1375 dd_data
->context_un
.iocb
.cmdiocbq
= ctiocb
;
1376 dd_data
->context_un
.iocb
.rspiocbq
= NULL
;
1377 dd_data
->context_un
.iocb
.set_job
= job
;
1378 dd_data
->context_un
.iocb
.bmp
= bmp
;
1379 dd_data
->context_un
.iocb
.ndlp
= ndlp
;
1381 if (phba
->cfg_poll
& DISABLE_FCP_RING_INT
) {
1382 creg_val
= readl(phba
->HCregaddr
);
1383 creg_val
|= (HC_R0INT_ENA
<< LPFC_FCP_RING
);
1384 writel(creg_val
, phba
->HCregaddr
);
1385 readl(phba
->HCregaddr
); /* flush */
1388 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, ctiocb
, 0);
1390 if (rc
== IOCB_SUCCESS
)
1391 return 0; /* done for now */
1394 lpfc_sli_release_iocbq(phba
, ctiocb
);
1402 * lpfc_bsg_send_mgmt_rsp - process a SEND_MGMT_RESP bsg vendor command
1403 * @job: SEND_MGMT_RESP fc_bsg_job
1406 lpfc_bsg_send_mgmt_rsp(struct fc_bsg_job
*job
)
1408 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
1409 struct lpfc_hba
*phba
= vport
->phba
;
1410 struct send_mgmt_resp
*mgmt_resp
= (struct send_mgmt_resp
*)
1411 job
->request
->rqst_data
.h_vendor
.vendor_cmd
;
1412 struct ulp_bde64
*bpl
;
1413 struct lpfc_dmabuf
*bmp
= NULL
;
1414 struct scatterlist
*sgel
= NULL
;
1418 uint32_t tag
= mgmt_resp
->tag
;
1419 unsigned long reqbfrcnt
=
1420 (unsigned long)job
->request_payload
.payload_len
;
1423 /* in case no data is transferred */
1424 job
->reply
->reply_payload_rcv_len
= 0;
1426 if (!reqbfrcnt
|| (reqbfrcnt
> (80 * BUF_SZ_4K
))) {
1428 goto send_mgmt_rsp_exit
;
1431 bmp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
1434 goto send_mgmt_rsp_exit
;
1437 bmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &bmp
->phys
);
1440 goto send_mgmt_rsp_free_bmp
;
1443 INIT_LIST_HEAD(&bmp
->list
);
1444 bpl
= (struct ulp_bde64
*) bmp
->virt
;
1445 request_nseg
= pci_map_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
1446 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
1447 for_each_sg(job
->request_payload
.sg_list
, sgel
, request_nseg
, numbde
) {
1448 busaddr
= sg_dma_address(sgel
);
1449 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
1450 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
1451 bpl
->tus
.w
= cpu_to_le32(bpl
->tus
.w
);
1452 bpl
->addrLow
= cpu_to_le32(putPaddrLow(busaddr
));
1453 bpl
->addrHigh
= cpu_to_le32(putPaddrHigh(busaddr
));
1457 rc
= lpfc_issue_ct_rsp(phba
, job
, tag
, bmp
, request_nseg
);
1459 if (rc
== IOCB_SUCCESS
)
1460 return 0; /* done for now */
1462 /* TBD need to handle a timeout */
1463 pci_unmap_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
1464 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
1466 lpfc_mbuf_free(phba
, bmp
->virt
, bmp
->phys
);
1468 send_mgmt_rsp_free_bmp
:
1471 /* make error code available to userspace */
1472 job
->reply
->result
= rc
;
1473 job
->dd_data
= NULL
;
1478 * lpfc_bsg_diag_mode - process a LPFC_BSG_VENDOR_DIAG_MODE bsg vendor command
1479 * @job: LPFC_BSG_VENDOR_DIAG_MODE
1481 * This function is responsible for placing a port into diagnostic loopback
1482 * mode in order to perform a diagnostic loopback test.
1483 * All new scsi requests are blocked, a small delay is used to allow the
1484 * scsi requests to complete then the link is brought down. If the link is
1485 * is placed in loopback mode then scsi requests are again allowed
1486 * so the scsi mid-layer doesn't give up on the port.
1487 * All of this is done in-line.
1490 lpfc_bsg_diag_mode(struct fc_bsg_job
*job
)
1492 struct Scsi_Host
*shost
= job
->shost
;
1493 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
1494 struct lpfc_hba
*phba
= vport
->phba
;
1495 struct diag_mode_set
*loopback_mode
;
1496 struct lpfc_sli
*psli
= &phba
->sli
;
1497 struct lpfc_sli_ring
*pring
= &psli
->ring
[LPFC_FCP_RING
];
1498 uint32_t link_flags
;
1500 struct lpfc_vport
**vports
;
1501 LPFC_MBOXQ_t
*pmboxq
;
1506 /* no data to return just the return code */
1507 job
->reply
->reply_payload_rcv_len
= 0;
1509 if (job
->request_len
<
1510 sizeof(struct fc_bsg_request
) + sizeof(struct diag_mode_set
)) {
1511 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
1512 "2738 Received DIAG MODE request below minimum "
1518 loopback_mode
= (struct diag_mode_set
*)
1519 job
->request
->rqst_data
.h_vendor
.vendor_cmd
;
1520 link_flags
= loopback_mode
->type
;
1521 timeout
= loopback_mode
->timeout
;
1523 if ((phba
->link_state
== LPFC_HBA_ERROR
) ||
1524 (psli
->sli_flag
& LPFC_BLOCK_MGMT_IO
) ||
1525 (!(psli
->sli_flag
& LPFC_SLI_ACTIVE
))) {
1530 pmboxq
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
1536 vports
= lpfc_create_vport_work_array(phba
);
1538 for (i
= 0; i
<= phba
->max_vpi
&& vports
[i
] != NULL
; i
++) {
1539 shost
= lpfc_shost_from_vport(vports
[i
]);
1540 scsi_block_requests(shost
);
1543 lpfc_destroy_vport_work_array(phba
, vports
);
1545 shost
= lpfc_shost_from_vport(phba
->pport
);
1546 scsi_block_requests(shost
);
1549 while (pring
->txcmplq_cnt
) {
1550 if (i
++ > 500) /* wait up to 5 seconds */
1556 memset((void *)pmboxq
, 0, sizeof(LPFC_MBOXQ_t
));
1557 pmboxq
->u
.mb
.mbxCommand
= MBX_DOWN_LINK
;
1558 pmboxq
->u
.mb
.mbxOwner
= OWN_HOST
;
1560 mbxstatus
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, LPFC_MBOX_TMO
);
1562 if ((mbxstatus
== MBX_SUCCESS
) && (pmboxq
->u
.mb
.mbxStatus
== 0)) {
1563 /* wait for link down before proceeding */
1565 while (phba
->link_state
!= LPFC_LINK_DOWN
) {
1566 if (i
++ > timeout
) {
1568 goto loopback_mode_exit
;
1574 memset((void *)pmboxq
, 0, sizeof(LPFC_MBOXQ_t
));
1575 if (link_flags
== INTERNAL_LOOP_BACK
)
1576 pmboxq
->u
.mb
.un
.varInitLnk
.link_flags
= FLAGS_LOCAL_LB
;
1578 pmboxq
->u
.mb
.un
.varInitLnk
.link_flags
=
1579 FLAGS_TOPOLOGY_MODE_LOOP
;
1581 pmboxq
->u
.mb
.mbxCommand
= MBX_INIT_LINK
;
1582 pmboxq
->u
.mb
.mbxOwner
= OWN_HOST
;
1584 mbxstatus
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
,
1587 if ((mbxstatus
!= MBX_SUCCESS
) || (pmboxq
->u
.mb
.mbxStatus
))
1590 phba
->link_flag
|= LS_LOOPBACK_MODE
;
1591 /* wait for the link attention interrupt */
1595 while (phba
->link_state
!= LPFC_HBA_READY
) {
1596 if (i
++ > timeout
) {
1609 vports
= lpfc_create_vport_work_array(phba
);
1611 for (i
= 0; i
<= phba
->max_vpi
&& vports
[i
] != NULL
; i
++) {
1612 shost
= lpfc_shost_from_vport(vports
[i
]);
1613 scsi_unblock_requests(shost
);
1615 lpfc_destroy_vport_work_array(phba
, vports
);
1617 shost
= lpfc_shost_from_vport(phba
->pport
);
1618 scsi_unblock_requests(shost
);
1622 * Let SLI layer release mboxq if mbox command completed after timeout.
1624 if (mbxstatus
!= MBX_TIMEOUT
)
1625 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
1628 /* make error code available to userspace */
1629 job
->reply
->result
= rc
;
1630 /* complete the job back to userspace if no error */
1637 * lpfcdiag_loop_self_reg - obtains a remote port login id
1638 * @phba: Pointer to HBA context object
1639 * @rpi: Pointer to a remote port login id
1641 * This function obtains a remote port login id so the diag loopback test
1642 * can send and receive its own unsolicited CT command.
1644 static int lpfcdiag_loop_self_reg(struct lpfc_hba
*phba
, uint16_t * rpi
)
1647 struct lpfc_dmabuf
*dmabuff
;
1650 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
1654 status
= lpfc_reg_rpi(phba
, 0, phba
->pport
->fc_myDID
,
1655 (uint8_t *)&phba
->pport
->fc_sparam
, mbox
, 0);
1657 mempool_free(mbox
, phba
->mbox_mem_pool
);
1661 dmabuff
= (struct lpfc_dmabuf
*) mbox
->context1
;
1662 mbox
->context1
= NULL
;
1663 status
= lpfc_sli_issue_mbox_wait(phba
, mbox
, LPFC_MBOX_TMO
);
1665 if ((status
!= MBX_SUCCESS
) || (mbox
->u
.mb
.mbxStatus
)) {
1666 lpfc_mbuf_free(phba
, dmabuff
->virt
, dmabuff
->phys
);
1668 if (status
!= MBX_TIMEOUT
)
1669 mempool_free(mbox
, phba
->mbox_mem_pool
);
1673 *rpi
= mbox
->u
.mb
.un
.varWords
[0];
1675 lpfc_mbuf_free(phba
, dmabuff
->virt
, dmabuff
->phys
);
1677 mempool_free(mbox
, phba
->mbox_mem_pool
);
1682 * lpfcdiag_loop_self_unreg - unregs from the rpi
1683 * @phba: Pointer to HBA context object
1684 * @rpi: Remote port login id
1686 * This function unregisters the rpi obtained in lpfcdiag_loop_self_reg
1688 static int lpfcdiag_loop_self_unreg(struct lpfc_hba
*phba
, uint16_t rpi
)
1693 /* Allocate mboxq structure */
1694 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
1698 lpfc_unreg_login(phba
, 0, rpi
, mbox
);
1699 status
= lpfc_sli_issue_mbox_wait(phba
, mbox
, LPFC_MBOX_TMO
);
1701 if ((status
!= MBX_SUCCESS
) || (mbox
->u
.mb
.mbxStatus
)) {
1702 if (status
!= MBX_TIMEOUT
)
1703 mempool_free(mbox
, phba
->mbox_mem_pool
);
1707 mempool_free(mbox
, phba
->mbox_mem_pool
);
1712 * lpfcdiag_loop_get_xri - obtains the transmit and receive ids
1713 * @phba: Pointer to HBA context object
1714 * @rpi: Remote port login id
1715 * @txxri: Pointer to transmit exchange id
1716 * @rxxri: Pointer to response exchabge id
1718 * This function obtains the transmit and receive ids required to send
1719 * an unsolicited ct command with a payload. A special lpfc FsType and CmdRsp
1720 * flags are used to the unsolicted response handler is able to process
1721 * the ct command sent on the same port.
1723 static int lpfcdiag_loop_get_xri(struct lpfc_hba
*phba
, uint16_t rpi
,
1724 uint16_t *txxri
, uint16_t * rxxri
)
1726 struct lpfc_bsg_event
*evt
;
1727 struct lpfc_iocbq
*cmdiocbq
, *rspiocbq
;
1729 struct lpfc_dmabuf
*dmabuf
;
1730 struct ulp_bde64
*bpl
= NULL
;
1731 struct lpfc_sli_ct_request
*ctreq
= NULL
;
1733 unsigned long flags
;
1737 evt
= lpfc_bsg_event_new(FC_REG_CT_EVENT
, current
->pid
,
1738 SLI_CT_ELX_LOOPBACK
);
1742 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1743 list_add(&evt
->node
, &phba
->ct_ev_waiters
);
1744 lpfc_bsg_event_ref(evt
);
1745 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1747 cmdiocbq
= lpfc_sli_get_iocbq(phba
);
1748 rspiocbq
= lpfc_sli_get_iocbq(phba
);
1750 dmabuf
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
1752 dmabuf
->virt
= lpfc_mbuf_alloc(phba
, 0, &dmabuf
->phys
);
1754 INIT_LIST_HEAD(&dmabuf
->list
);
1755 bpl
= (struct ulp_bde64
*) dmabuf
->virt
;
1756 memset(bpl
, 0, sizeof(*bpl
));
1757 ctreq
= (struct lpfc_sli_ct_request
*)(bpl
+ 1);
1759 le32_to_cpu(putPaddrHigh(dmabuf
->phys
+
1762 le32_to_cpu(putPaddrLow(dmabuf
->phys
+
1764 bpl
->tus
.f
.bdeFlags
= 0;
1765 bpl
->tus
.f
.bdeSize
= ELX_LOOPBACK_HEADER_SZ
;
1766 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
1770 if (cmdiocbq
== NULL
|| rspiocbq
== NULL
||
1771 dmabuf
== NULL
|| bpl
== NULL
|| ctreq
== NULL
||
1772 dmabuf
->virt
== NULL
) {
1774 goto err_get_xri_exit
;
1777 cmd
= &cmdiocbq
->iocb
;
1778 rsp
= &rspiocbq
->iocb
;
1780 memset(ctreq
, 0, ELX_LOOPBACK_HEADER_SZ
);
1782 ctreq
->RevisionId
.bits
.Revision
= SLI_CT_REVISION
;
1783 ctreq
->RevisionId
.bits
.InId
= 0;
1784 ctreq
->FsType
= SLI_CT_ELX_LOOPBACK
;
1785 ctreq
->FsSubType
= 0;
1786 ctreq
->CommandResponse
.bits
.CmdRsp
= ELX_LOOPBACK_XRI_SETUP
;
1787 ctreq
->CommandResponse
.bits
.Size
= 0;
1790 cmd
->un
.xseq64
.bdl
.addrHigh
= putPaddrHigh(dmabuf
->phys
);
1791 cmd
->un
.xseq64
.bdl
.addrLow
= putPaddrLow(dmabuf
->phys
);
1792 cmd
->un
.xseq64
.bdl
.bdeFlags
= BUFF_TYPE_BLP_64
;
1793 cmd
->un
.xseq64
.bdl
.bdeSize
= sizeof(*bpl
);
1795 cmd
->un
.xseq64
.w5
.hcsw
.Fctl
= LA
;
1796 cmd
->un
.xseq64
.w5
.hcsw
.Dfctl
= 0;
1797 cmd
->un
.xseq64
.w5
.hcsw
.Rctl
= FC_RCTL_DD_UNSOL_CTL
;
1798 cmd
->un
.xseq64
.w5
.hcsw
.Type
= FC_TYPE_CT
;
1800 cmd
->ulpCommand
= CMD_XMIT_SEQUENCE64_CR
;
1801 cmd
->ulpBdeCount
= 1;
1803 cmd
->ulpClass
= CLASS3
;
1804 cmd
->ulpContext
= rpi
;
1806 cmdiocbq
->iocb_flag
|= LPFC_IO_LIBDFC
;
1807 cmdiocbq
->vport
= phba
->pport
;
1809 ret_val
= lpfc_sli_issue_iocb_wait(phba
, LPFC_ELS_RING
, cmdiocbq
,
1811 (phba
->fc_ratov
* 2)
1812 + LPFC_DRVR_TIMEOUT
);
1814 goto err_get_xri_exit
;
1816 *txxri
= rsp
->ulpContext
;
1819 evt
->wait_time_stamp
= jiffies
;
1820 ret_val
= wait_event_interruptible_timeout(
1821 evt
->wq
, !list_empty(&evt
->events_to_see
),
1822 ((phba
->fc_ratov
* 2) + LPFC_DRVR_TIMEOUT
) * HZ
);
1823 if (list_empty(&evt
->events_to_see
))
1824 ret_val
= (ret_val
) ? EINTR
: ETIMEDOUT
;
1826 ret_val
= IOCB_SUCCESS
;
1827 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1828 list_move(evt
->events_to_see
.prev
, &evt
->events_to_get
);
1829 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1830 *rxxri
= (list_entry(evt
->events_to_get
.prev
,
1831 typeof(struct event_data
),
1837 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
1838 lpfc_bsg_event_unref(evt
); /* release ref */
1839 lpfc_bsg_event_unref(evt
); /* delete */
1840 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
1844 lpfc_mbuf_free(phba
, dmabuf
->virt
, dmabuf
->phys
);
1848 if (cmdiocbq
&& (ret_val
!= IOCB_TIMEDOUT
))
1849 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
1851 lpfc_sli_release_iocbq(phba
, rspiocbq
);
1856 * diag_cmd_data_alloc - fills in a bde struct with dma buffers
1857 * @phba: Pointer to HBA context object
1858 * @bpl: Pointer to 64 bit bde structure
1859 * @size: Number of bytes to process
1860 * @nocopydata: Flag to copy user data into the allocated buffer
1862 * This function allocates page size buffers and populates an lpfc_dmabufext.
1863 * If allowed the user data pointed to with indataptr is copied into the kernel
1864 * memory. The chained list of page size buffers is returned.
1866 static struct lpfc_dmabufext
*
1867 diag_cmd_data_alloc(struct lpfc_hba
*phba
,
1868 struct ulp_bde64
*bpl
, uint32_t size
,
1871 struct lpfc_dmabufext
*mlist
= NULL
;
1872 struct lpfc_dmabufext
*dmp
;
1873 int cnt
, offset
= 0, i
= 0;
1874 struct pci_dev
*pcidev
;
1876 pcidev
= phba
->pcidev
;
1879 /* We get chunks of 4K */
1880 if (size
> BUF_SZ_4K
)
1885 /* allocate struct lpfc_dmabufext buffer header */
1886 dmp
= kmalloc(sizeof(struct lpfc_dmabufext
), GFP_KERNEL
);
1890 INIT_LIST_HEAD(&dmp
->dma
.list
);
1892 /* Queue it to a linked list */
1894 list_add_tail(&dmp
->dma
.list
, &mlist
->dma
.list
);
1898 /* allocate buffer */
1899 dmp
->dma
.virt
= dma_alloc_coherent(&pcidev
->dev
,
1910 bpl
->tus
.f
.bdeFlags
= 0;
1911 pci_dma_sync_single_for_device(phba
->pcidev
,
1912 dmp
->dma
.phys
, LPFC_BPL_SIZE
, PCI_DMA_TODEVICE
);
1915 memset((uint8_t *)dmp
->dma
.virt
, 0, cnt
);
1916 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64I
;
1919 /* build buffer ptr list for IOCB */
1920 bpl
->addrLow
= le32_to_cpu(putPaddrLow(dmp
->dma
.phys
));
1921 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(dmp
->dma
.phys
));
1922 bpl
->tus
.f
.bdeSize
= (ushort
) cnt
;
1923 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
1934 diag_cmd_data_free(phba
, mlist
);
1939 * lpfcdiag_loop_post_rxbufs - post the receive buffers for an unsol CT cmd
1940 * @phba: Pointer to HBA context object
1941 * @rxxri: Receive exchange id
1942 * @len: Number of data bytes
1944 * This function allocates and posts a data buffer of sufficient size to recieve
1945 * an unsolicted CT command.
1947 static int lpfcdiag_loop_post_rxbufs(struct lpfc_hba
*phba
, uint16_t rxxri
,
1950 struct lpfc_sli
*psli
= &phba
->sli
;
1951 struct lpfc_sli_ring
*pring
= &psli
->ring
[LPFC_ELS_RING
];
1952 struct lpfc_iocbq
*cmdiocbq
;
1954 struct list_head head
, *curr
, *next
;
1955 struct lpfc_dmabuf
*rxbmp
;
1956 struct lpfc_dmabuf
*dmp
;
1957 struct lpfc_dmabuf
*mp
[2] = {NULL
, NULL
};
1958 struct ulp_bde64
*rxbpl
= NULL
;
1960 struct lpfc_dmabufext
*rxbuffer
= NULL
;
1964 cmdiocbq
= lpfc_sli_get_iocbq(phba
);
1965 rxbmp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
1966 if (rxbmp
!= NULL
) {
1967 rxbmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &rxbmp
->phys
);
1969 INIT_LIST_HEAD(&rxbmp
->list
);
1970 rxbpl
= (struct ulp_bde64
*) rxbmp
->virt
;
1971 rxbuffer
= diag_cmd_data_alloc(phba
, rxbpl
, len
, 0);
1975 if (!cmdiocbq
|| !rxbmp
|| !rxbpl
|| !rxbuffer
) {
1977 goto err_post_rxbufs_exit
;
1980 /* Queue buffers for the receive exchange */
1981 num_bde
= (uint32_t)rxbuffer
->flag
;
1982 dmp
= &rxbuffer
->dma
;
1984 cmd
= &cmdiocbq
->iocb
;
1987 INIT_LIST_HEAD(&head
);
1988 list_add_tail(&head
, &dmp
->list
);
1989 list_for_each_safe(curr
, next
, &head
) {
1990 mp
[i
] = list_entry(curr
, struct lpfc_dmabuf
, list
);
1993 if (phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
) {
1994 mp
[i
]->buffer_tag
= lpfc_sli_get_buffer_tag(phba
);
1995 cmd
->un
.quexri64cx
.buff
.bde
.addrHigh
=
1996 putPaddrHigh(mp
[i
]->phys
);
1997 cmd
->un
.quexri64cx
.buff
.bde
.addrLow
=
1998 putPaddrLow(mp
[i
]->phys
);
1999 cmd
->un
.quexri64cx
.buff
.bde
.tus
.f
.bdeSize
=
2000 ((struct lpfc_dmabufext
*)mp
[i
])->size
;
2001 cmd
->un
.quexri64cx
.buff
.buffer_tag
= mp
[i
]->buffer_tag
;
2002 cmd
->ulpCommand
= CMD_QUE_XRI64_CX
;
2005 cmd
->ulpBdeCount
= 1;
2006 cmd
->unsli3
.que_xri64cx_ext_words
.ebde_count
= 0;
2009 cmd
->un
.cont64
[i
].addrHigh
= putPaddrHigh(mp
[i
]->phys
);
2010 cmd
->un
.cont64
[i
].addrLow
= putPaddrLow(mp
[i
]->phys
);
2011 cmd
->un
.cont64
[i
].tus
.f
.bdeSize
=
2012 ((struct lpfc_dmabufext
*)mp
[i
])->size
;
2013 cmd
->ulpBdeCount
= ++i
;
2015 if ((--num_bde
> 0) && (i
< 2))
2018 cmd
->ulpCommand
= CMD_QUE_XRI_BUF64_CX
;
2022 cmd
->ulpClass
= CLASS3
;
2023 cmd
->ulpContext
= rxxri
;
2025 ret_val
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, cmdiocbq
, 0);
2027 if (ret_val
== IOCB_ERROR
) {
2028 diag_cmd_data_free(phba
,
2029 (struct lpfc_dmabufext
*)mp
[0]);
2031 diag_cmd_data_free(phba
,
2032 (struct lpfc_dmabufext
*)mp
[1]);
2033 dmp
= list_entry(next
, struct lpfc_dmabuf
, list
);
2035 goto err_post_rxbufs_exit
;
2038 lpfc_sli_ringpostbuf_put(phba
, pring
, mp
[0]);
2040 lpfc_sli_ringpostbuf_put(phba
, pring
, mp
[1]);
2044 /* The iocb was freed by lpfc_sli_issue_iocb */
2045 cmdiocbq
= lpfc_sli_get_iocbq(phba
);
2047 dmp
= list_entry(next
, struct lpfc_dmabuf
, list
);
2049 goto err_post_rxbufs_exit
;
2052 cmd
= &cmdiocbq
->iocb
;
2057 err_post_rxbufs_exit
:
2061 lpfc_mbuf_free(phba
, rxbmp
->virt
, rxbmp
->phys
);
2066 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
2071 * lpfc_bsg_diag_test - with a port in loopback issues a Ct cmd to itself
2072 * @job: LPFC_BSG_VENDOR_DIAG_TEST fc_bsg_job
2074 * This function receives a user data buffer to be transmitted and received on
2075 * the same port, the link must be up and in loopback mode prior
2077 * 1. A kernel buffer is allocated to copy the user data into.
2078 * 2. The port registers with "itself".
2079 * 3. The transmit and receive exchange ids are obtained.
2080 * 4. The receive exchange id is posted.
2081 * 5. A new els loopback event is created.
2082 * 6. The command and response iocbs are allocated.
2083 * 7. The cmd iocb FsType is set to elx loopback and the CmdRsp to looppback.
2085 * This function is meant to be called n times while the port is in loopback
2086 * so it is the apps responsibility to issue a reset to take the port out
2090 lpfc_bsg_diag_test(struct fc_bsg_job
*job
)
2092 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
2093 struct lpfc_hba
*phba
= vport
->phba
;
2094 struct diag_mode_test
*diag_mode
;
2095 struct lpfc_bsg_event
*evt
;
2096 struct event_data
*evdat
;
2097 struct lpfc_sli
*psli
= &phba
->sli
;
2100 size_t segment_len
= 0, segment_offset
= 0, current_offset
= 0;
2102 struct lpfc_iocbq
*cmdiocbq
, *rspiocbq
;
2104 struct lpfc_sli_ct_request
*ctreq
;
2105 struct lpfc_dmabuf
*txbmp
;
2106 struct ulp_bde64
*txbpl
= NULL
;
2107 struct lpfc_dmabufext
*txbuffer
= NULL
;
2108 struct list_head head
;
2109 struct lpfc_dmabuf
*curr
;
2110 uint16_t txxri
, rxxri
;
2112 uint8_t *ptr
= NULL
, *rx_databuf
= NULL
;
2114 unsigned long flags
;
2115 void *dataout
= NULL
;
2118 /* in case no data is returned return just the return code */
2119 job
->reply
->reply_payload_rcv_len
= 0;
2121 if (job
->request_len
<
2122 sizeof(struct fc_bsg_request
) + sizeof(struct diag_mode_test
)) {
2123 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
2124 "2739 Received DIAG TEST request below minimum "
2127 goto loopback_test_exit
;
2130 if (job
->request_payload
.payload_len
!=
2131 job
->reply_payload
.payload_len
) {
2133 goto loopback_test_exit
;
2136 diag_mode
= (struct diag_mode_test
*)
2137 job
->request
->rqst_data
.h_vendor
.vendor_cmd
;
2139 if ((phba
->link_state
== LPFC_HBA_ERROR
) ||
2140 (psli
->sli_flag
& LPFC_BLOCK_MGMT_IO
) ||
2141 (!(psli
->sli_flag
& LPFC_SLI_ACTIVE
))) {
2143 goto loopback_test_exit
;
2146 if (!lpfc_is_link_up(phba
) || !(phba
->link_flag
& LS_LOOPBACK_MODE
)) {
2148 goto loopback_test_exit
;
2151 size
= job
->request_payload
.payload_len
;
2152 full_size
= size
+ ELX_LOOPBACK_HEADER_SZ
; /* plus the header */
2154 if ((size
== 0) || (size
> 80 * BUF_SZ_4K
)) {
2156 goto loopback_test_exit
;
2159 if (size
>= BUF_SZ_4K
) {
2161 * Allocate memory for ioctl data. If buffer is bigger than 64k,
2162 * then we allocate 64k and re-use that buffer over and over to
2163 * xfer the whole block. This is because Linux kernel has a
2164 * problem allocating more than 120k of kernel space memory. Saw
2165 * problem with GET_FCPTARGETMAPPING...
2167 if (size
<= (64 * 1024))
2170 total_mem
= 64 * 1024;
2172 /* Allocate memory for ioctl data */
2173 total_mem
= BUF_SZ_4K
;
2175 dataout
= kmalloc(total_mem
, GFP_KERNEL
);
2176 if (dataout
== NULL
) {
2178 goto loopback_test_exit
;
2182 ptr
+= ELX_LOOPBACK_HEADER_SZ
;
2183 sg_copy_to_buffer(job
->request_payload
.sg_list
,
2184 job
->request_payload
.sg_cnt
,
2187 rc
= lpfcdiag_loop_self_reg(phba
, &rpi
);
2190 goto loopback_test_exit
;
2193 rc
= lpfcdiag_loop_get_xri(phba
, rpi
, &txxri
, &rxxri
);
2195 lpfcdiag_loop_self_unreg(phba
, rpi
);
2197 goto loopback_test_exit
;
2200 rc
= lpfcdiag_loop_post_rxbufs(phba
, rxxri
, full_size
);
2202 lpfcdiag_loop_self_unreg(phba
, rpi
);
2204 goto loopback_test_exit
;
2207 evt
= lpfc_bsg_event_new(FC_REG_CT_EVENT
, current
->pid
,
2208 SLI_CT_ELX_LOOPBACK
);
2210 lpfcdiag_loop_self_unreg(phba
, rpi
);
2212 goto loopback_test_exit
;
2215 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
2216 list_add(&evt
->node
, &phba
->ct_ev_waiters
);
2217 lpfc_bsg_event_ref(evt
);
2218 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
2220 cmdiocbq
= lpfc_sli_get_iocbq(phba
);
2221 rspiocbq
= lpfc_sli_get_iocbq(phba
);
2222 txbmp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
2225 txbmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &txbmp
->phys
);
2227 INIT_LIST_HEAD(&txbmp
->list
);
2228 txbpl
= (struct ulp_bde64
*) txbmp
->virt
;
2229 txbuffer
= diag_cmd_data_alloc(phba
,
2230 txbpl
, full_size
, 0);
2234 if (!cmdiocbq
|| !rspiocbq
|| !txbmp
|| !txbpl
|| !txbuffer
||
2237 goto err_loopback_test_exit
;
2240 cmd
= &cmdiocbq
->iocb
;
2241 rsp
= &rspiocbq
->iocb
;
2243 INIT_LIST_HEAD(&head
);
2244 list_add_tail(&head
, &txbuffer
->dma
.list
);
2245 list_for_each_entry(curr
, &head
, list
) {
2246 segment_len
= ((struct lpfc_dmabufext
*)curr
)->size
;
2247 if (current_offset
== 0) {
2249 memset(ctreq
, 0, ELX_LOOPBACK_HEADER_SZ
);
2250 ctreq
->RevisionId
.bits
.Revision
= SLI_CT_REVISION
;
2251 ctreq
->RevisionId
.bits
.InId
= 0;
2252 ctreq
->FsType
= SLI_CT_ELX_LOOPBACK
;
2253 ctreq
->FsSubType
= 0;
2254 ctreq
->CommandResponse
.bits
.CmdRsp
= ELX_LOOPBACK_DATA
;
2255 ctreq
->CommandResponse
.bits
.Size
= size
;
2256 segment_offset
= ELX_LOOPBACK_HEADER_SZ
;
2260 BUG_ON(segment_offset
>= segment_len
);
2261 memcpy(curr
->virt
+ segment_offset
,
2262 ptr
+ current_offset
,
2263 segment_len
- segment_offset
);
2265 current_offset
+= segment_len
- segment_offset
;
2266 BUG_ON(current_offset
> size
);
2270 /* Build the XMIT_SEQUENCE iocb */
2272 num_bde
= (uint32_t)txbuffer
->flag
;
2274 cmd
->un
.xseq64
.bdl
.addrHigh
= putPaddrHigh(txbmp
->phys
);
2275 cmd
->un
.xseq64
.bdl
.addrLow
= putPaddrLow(txbmp
->phys
);
2276 cmd
->un
.xseq64
.bdl
.bdeFlags
= BUFF_TYPE_BLP_64
;
2277 cmd
->un
.xseq64
.bdl
.bdeSize
= (num_bde
* sizeof(struct ulp_bde64
));
2279 cmd
->un
.xseq64
.w5
.hcsw
.Fctl
= (LS
| LA
);
2280 cmd
->un
.xseq64
.w5
.hcsw
.Dfctl
= 0;
2281 cmd
->un
.xseq64
.w5
.hcsw
.Rctl
= FC_RCTL_DD_UNSOL_CTL
;
2282 cmd
->un
.xseq64
.w5
.hcsw
.Type
= FC_TYPE_CT
;
2284 cmd
->ulpCommand
= CMD_XMIT_SEQUENCE64_CX
;
2285 cmd
->ulpBdeCount
= 1;
2287 cmd
->ulpClass
= CLASS3
;
2288 cmd
->ulpContext
= txxri
;
2290 cmdiocbq
->iocb_flag
|= LPFC_IO_LIBDFC
;
2291 cmdiocbq
->vport
= phba
->pport
;
2293 rc
= lpfc_sli_issue_iocb_wait(phba
, LPFC_ELS_RING
, cmdiocbq
, rspiocbq
,
2294 (phba
->fc_ratov
* 2) + LPFC_DRVR_TIMEOUT
);
2296 if ((rc
!= IOCB_SUCCESS
) || (rsp
->ulpStatus
!= IOCB_SUCCESS
)) {
2298 goto err_loopback_test_exit
;
2302 rc
= wait_event_interruptible_timeout(
2303 evt
->wq
, !list_empty(&evt
->events_to_see
),
2304 ((phba
->fc_ratov
* 2) + LPFC_DRVR_TIMEOUT
) * HZ
);
2306 if (list_empty(&evt
->events_to_see
))
2307 rc
= (rc
) ? -EINTR
: -ETIMEDOUT
;
2309 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
2310 list_move(evt
->events_to_see
.prev
, &evt
->events_to_get
);
2311 evdat
= list_entry(evt
->events_to_get
.prev
,
2312 typeof(*evdat
), node
);
2313 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
2314 rx_databuf
= evdat
->data
;
2315 if (evdat
->len
!= full_size
) {
2316 lpfc_printf_log(phba
, KERN_ERR
, LOG_LIBDFC
,
2317 "1603 Loopback test did not receive expected "
2318 "data length. actual length 0x%x expected "
2320 evdat
->len
, full_size
);
2322 } else if (rx_databuf
== NULL
)
2326 /* skip over elx loopback header */
2327 rx_databuf
+= ELX_LOOPBACK_HEADER_SZ
;
2328 job
->reply
->reply_payload_rcv_len
=
2329 sg_copy_from_buffer(job
->reply_payload
.sg_list
,
2330 job
->reply_payload
.sg_cnt
,
2332 job
->reply
->reply_payload_rcv_len
= size
;
2336 err_loopback_test_exit
:
2337 lpfcdiag_loop_self_unreg(phba
, rpi
);
2339 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
2340 lpfc_bsg_event_unref(evt
); /* release ref */
2341 lpfc_bsg_event_unref(evt
); /* delete */
2342 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
2344 if (cmdiocbq
!= NULL
)
2345 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
2347 if (rspiocbq
!= NULL
)
2348 lpfc_sli_release_iocbq(phba
, rspiocbq
);
2350 if (txbmp
!= NULL
) {
2351 if (txbpl
!= NULL
) {
2352 if (txbuffer
!= NULL
)
2353 diag_cmd_data_free(phba
, txbuffer
);
2354 lpfc_mbuf_free(phba
, txbmp
->virt
, txbmp
->phys
);
2361 /* make error code available to userspace */
2362 job
->reply
->result
= rc
;
2363 job
->dd_data
= NULL
;
2364 /* complete the job back to userspace if no error */
2371 * lpfc_bsg_get_dfc_rev - process a GET_DFC_REV bsg vendor command
2372 * @job: GET_DFC_REV fc_bsg_job
2375 lpfc_bsg_get_dfc_rev(struct fc_bsg_job
*job
)
2377 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
2378 struct lpfc_hba
*phba
= vport
->phba
;
2379 struct get_mgmt_rev
*event_req
;
2380 struct get_mgmt_rev_reply
*event_reply
;
2383 if (job
->request_len
<
2384 sizeof(struct fc_bsg_request
) + sizeof(struct get_mgmt_rev
)) {
2385 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
2386 "2740 Received GET_DFC_REV request below "
2392 event_req
= (struct get_mgmt_rev
*)
2393 job
->request
->rqst_data
.h_vendor
.vendor_cmd
;
2395 event_reply
= (struct get_mgmt_rev_reply
*)
2396 job
->reply
->reply_data
.vendor_reply
.vendor_rsp
;
2398 if (job
->reply_len
<
2399 sizeof(struct fc_bsg_request
) + sizeof(struct get_mgmt_rev_reply
)) {
2400 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
2401 "2741 Received GET_DFC_REV reply below "
2407 event_reply
->info
.a_Major
= MANAGEMENT_MAJOR_REV
;
2408 event_reply
->info
.a_Minor
= MANAGEMENT_MINOR_REV
;
2410 job
->reply
->result
= rc
;
2417 * lpfc_bsg_wake_mbox_wait - lpfc_bsg_issue_mbox mbox completion handler
2418 * @phba: Pointer to HBA context object.
2419 * @pmboxq: Pointer to mailbox command.
2421 * This is completion handler function for mailbox commands issued from
2422 * lpfc_bsg_issue_mbox function. This function is called by the
2423 * mailbox event handler function with no lock held. This function
2424 * will wake up thread waiting on the wait queue pointed by context1
2428 lpfc_bsg_wake_mbox_wait(struct lpfc_hba
*phba
, LPFC_MBOXQ_t
*pmboxq
)
2430 struct bsg_job_data
*dd_data
;
2431 struct fc_bsg_job
*job
;
2433 unsigned long flags
;
2437 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
2438 dd_data
= pmboxq
->context1
;
2439 /* job already timed out? */
2441 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
2445 /* build the outgoing buffer to do an sg copy
2446 * the format is the response mailbox followed by any extended
2449 from
= (uint8_t *)&pmboxq
->u
.mb
;
2450 to
= (uint8_t *)dd_data
->context_un
.mbox
.mb
;
2451 memcpy(to
, from
, sizeof(MAILBOX_t
));
2452 if (pmboxq
->u
.mb
.mbxStatus
== MBX_SUCCESS
) {
2453 /* copy the extended data if any, count is in words */
2454 if (dd_data
->context_un
.mbox
.outExtWLen
) {
2455 from
= (uint8_t *)dd_data
->context_un
.mbox
.ext
;
2456 to
+= sizeof(MAILBOX_t
);
2457 size
= dd_data
->context_un
.mbox
.outExtWLen
*
2459 memcpy(to
, from
, size
);
2460 } else if (pmboxq
->u
.mb
.mbxCommand
== MBX_RUN_BIU_DIAG64
) {
2461 from
= (uint8_t *)dd_data
->context_un
.mbox
.
2463 to
+= sizeof(MAILBOX_t
);
2464 size
= dd_data
->context_un
.mbox
.dmp
->size
;
2465 memcpy(to
, from
, size
);
2466 } else if ((phba
->sli_rev
== LPFC_SLI_REV4
) &&
2467 (pmboxq
->u
.mb
.mbxCommand
== MBX_DUMP_MEMORY
)) {
2468 from
= (uint8_t *)dd_data
->context_un
.mbox
.dmp
->dma
.
2470 to
+= sizeof(MAILBOX_t
);
2471 size
= pmboxq
->u
.mb
.un
.varWords
[5];
2472 memcpy(to
, from
, size
);
2473 } else if (pmboxq
->u
.mb
.mbxCommand
== MBX_READ_EVENT_LOG
) {
2474 from
= (uint8_t *)dd_data
->context_un
.
2476 to
+= sizeof(MAILBOX_t
);
2477 size
= dd_data
->context_un
.mbox
.dmp
->size
;
2478 memcpy(to
, from
, size
);
2482 from
= (uint8_t *)dd_data
->context_un
.mbox
.mb
;
2483 job
= dd_data
->context_un
.mbox
.set_job
;
2484 size
= job
->reply_payload
.payload_len
;
2485 job
->reply
->reply_payload_rcv_len
=
2486 sg_copy_from_buffer(job
->reply_payload
.sg_list
,
2487 job
->reply_payload
.sg_cnt
,
2489 job
->reply
->result
= 0;
2491 dd_data
->context_un
.mbox
.set_job
= NULL
;
2492 job
->dd_data
= NULL
;
2494 /* need to hold the lock until we call job done to hold off
2495 * the timeout handler returning to the midlayer while
2496 * we are stillprocessing the job
2498 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
2500 kfree(dd_data
->context_un
.mbox
.mb
);
2501 mempool_free(dd_data
->context_un
.mbox
.pmboxq
, phba
->mbox_mem_pool
);
2502 kfree(dd_data
->context_un
.mbox
.ext
);
2503 if (dd_data
->context_un
.mbox
.dmp
) {
2504 dma_free_coherent(&phba
->pcidev
->dev
,
2505 dd_data
->context_un
.mbox
.dmp
->size
,
2506 dd_data
->context_un
.mbox
.dmp
->dma
.virt
,
2507 dd_data
->context_un
.mbox
.dmp
->dma
.phys
);
2508 kfree(dd_data
->context_un
.mbox
.dmp
);
2510 if (dd_data
->context_un
.mbox
.rxbmp
) {
2511 lpfc_mbuf_free(phba
, dd_data
->context_un
.mbox
.rxbmp
->virt
,
2512 dd_data
->context_un
.mbox
.rxbmp
->phys
);
2513 kfree(dd_data
->context_un
.mbox
.rxbmp
);
2520 * lpfc_bsg_check_cmd_access - test for a supported mailbox command
2521 * @phba: Pointer to HBA context object.
2522 * @mb: Pointer to a mailbox object.
2523 * @vport: Pointer to a vport object.
2525 * Some commands require the port to be offline, some may not be called from
2528 static int lpfc_bsg_check_cmd_access(struct lpfc_hba
*phba
,
2529 MAILBOX_t
*mb
, struct lpfc_vport
*vport
)
2531 /* return negative error values for bsg job */
2532 switch (mb
->mbxCommand
) {
2536 case MBX_CONFIG_LINK
:
2537 case MBX_CONFIG_RING
:
2538 case MBX_RESET_RING
:
2539 case MBX_UNREG_LOGIN
:
2541 case MBX_DUMP_CONTEXT
:
2545 if (!(vport
->fc_flag
& FC_OFFLINE_MODE
)) {
2546 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
2547 "2743 Command 0x%x is illegal in on-line "
2553 case MBX_WRITE_VPARMS
:
2556 case MBX_READ_CONFIG
:
2557 case MBX_READ_RCONFIG
:
2558 case MBX_READ_STATUS
:
2561 case MBX_READ_LNK_STAT
:
2562 case MBX_DUMP_MEMORY
:
2564 case MBX_UPDATE_CFG
:
2565 case MBX_KILL_BOARD
:
2567 case MBX_LOAD_EXP_ROM
:
2569 case MBX_DEL_LD_ENTRY
:
2572 case MBX_SLI4_CONFIG
:
2573 case MBX_READ_EVENT_LOG
:
2574 case MBX_READ_EVENT_LOG_STATUS
:
2575 case MBX_WRITE_EVENT_LOG
:
2576 case MBX_PORT_CAPABILITIES
:
2577 case MBX_PORT_IOV_CONTROL
:
2578 case MBX_RUN_BIU_DIAG64
:
2580 case MBX_SET_VARIABLE
:
2581 lpfc_printf_log(phba
, KERN_INFO
, LOG_INIT
,
2582 "1226 mbox: set_variable 0x%x, 0x%x\n",
2584 mb
->un
.varWords
[1]);
2585 if ((mb
->un
.varWords
[0] == SETVAR_MLOMNT
)
2586 && (mb
->un
.varWords
[1] == 1)) {
2587 phba
->wait_4_mlo_maint_flg
= 1;
2588 } else if (mb
->un
.varWords
[0] == SETVAR_MLORST
) {
2589 phba
->link_flag
&= ~LS_LOOPBACK_MODE
;
2590 phba
->fc_topology
= TOPOLOGY_PT_PT
;
2593 case MBX_READ_SPARM64
:
2597 case MBX_REG_LOGIN64
:
2598 case MBX_CONFIG_PORT
:
2599 case MBX_RUN_BIU_DIAG
:
2601 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
2602 "2742 Unknown Command 0x%x\n",
2611 * lpfc_bsg_issue_mbox - issues a mailbox command on behalf of an app
2612 * @phba: Pointer to HBA context object.
2613 * @mb: Pointer to a mailbox object.
2614 * @vport: Pointer to a vport object.
2616 * Allocate a tracking object, mailbox command memory, get a mailbox
2617 * from the mailbox pool, copy the caller mailbox command.
2619 * If offline and the sli is active we need to poll for the command (port is
2620 * being reset) and com-plete the job, otherwise issue the mailbox command and
2621 * let our completion handler finish the command.
2624 lpfc_bsg_issue_mbox(struct lpfc_hba
*phba
, struct fc_bsg_job
*job
,
2625 struct lpfc_vport
*vport
)
2627 LPFC_MBOXQ_t
*pmboxq
= NULL
; /* internal mailbox queue */
2628 MAILBOX_t
*pmb
; /* shortcut to the pmboxq mailbox */
2629 /* a 4k buffer to hold the mb and extended data from/to the bsg */
2630 MAILBOX_t
*mb
= NULL
;
2631 struct bsg_job_data
*dd_data
= NULL
; /* bsg data tracking structure */
2633 struct lpfc_dmabuf
*rxbmp
= NULL
; /* for biu diag */
2634 struct lpfc_dmabufext
*dmp
= NULL
; /* for biu diag */
2635 struct ulp_bde64
*rxbpl
= NULL
;
2636 struct dfc_mbox_req
*mbox_req
= (struct dfc_mbox_req
*)
2637 job
->request
->rqst_data
.h_vendor
.vendor_cmd
;
2638 uint8_t *ext
= NULL
;
2642 /* in case no data is transferred */
2643 job
->reply
->reply_payload_rcv_len
= 0;
2645 /* check if requested extended data lengths are valid */
2646 if ((mbox_req
->inExtWLen
> MAILBOX_EXT_SIZE
) ||
2647 (mbox_req
->outExtWLen
> MAILBOX_EXT_SIZE
)) {
2652 /* allocate our bsg tracking structure */
2653 dd_data
= kmalloc(sizeof(struct bsg_job_data
), GFP_KERNEL
);
2655 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
2656 "2727 Failed allocation of dd_data\n");
2661 mb
= kzalloc(BSG_MBOX_SIZE
, GFP_KERNEL
);
2667 pmboxq
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
2672 memset(pmboxq
, 0, sizeof(LPFC_MBOXQ_t
));
2674 size
= job
->request_payload
.payload_len
;
2675 sg_copy_to_buffer(job
->request_payload
.sg_list
,
2676 job
->request_payload
.sg_cnt
,
2679 rc
= lpfc_bsg_check_cmd_access(phba
, mb
, vport
);
2681 goto job_done
; /* must be negative */
2683 pmb
= &pmboxq
->u
.mb
;
2684 memcpy(pmb
, mb
, sizeof(*pmb
));
2685 pmb
->mbxOwner
= OWN_HOST
;
2686 pmboxq
->vport
= vport
;
2688 /* If HBA encountered an error attention, allow only DUMP
2689 * or RESTART mailbox commands until the HBA is restarted.
2691 if (phba
->pport
->stopped
&&
2692 pmb
->mbxCommand
!= MBX_DUMP_MEMORY
&&
2693 pmb
->mbxCommand
!= MBX_RESTART
&&
2694 pmb
->mbxCommand
!= MBX_WRITE_VPARMS
&&
2695 pmb
->mbxCommand
!= MBX_WRITE_WWN
)
2696 lpfc_printf_log(phba
, KERN_WARNING
, LOG_MBOX
,
2697 "2797 mbox: Issued mailbox cmd "
2698 "0x%x while in stopped state.\n",
2701 /* Don't allow mailbox commands to be sent when blocked
2702 * or when in the middle of discovery
2704 if (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
) {
2709 /* extended mailbox commands will need an extended buffer */
2710 if (mbox_req
->inExtWLen
|| mbox_req
->outExtWLen
) {
2711 ext
= kzalloc(MAILBOX_EXT_SIZE
, GFP_KERNEL
);
2717 /* any data for the device? */
2718 if (mbox_req
->inExtWLen
) {
2719 from
= (uint8_t *)mb
;
2720 from
+= sizeof(MAILBOX_t
);
2721 memcpy((uint8_t *)ext
, from
,
2722 mbox_req
->inExtWLen
* sizeof(uint32_t));
2725 pmboxq
->context2
= ext
;
2726 pmboxq
->in_ext_byte_len
=
2727 mbox_req
->inExtWLen
* sizeof(uint32_t);
2728 pmboxq
->out_ext_byte_len
=
2729 mbox_req
->outExtWLen
* sizeof(uint32_t);
2730 pmboxq
->mbox_offset_word
= mbox_req
->mbOffset
;
2733 /* biu diag will need a kernel buffer to transfer the data
2734 * allocate our own buffer and setup the mailbox command to
2737 if (pmb
->mbxCommand
== MBX_RUN_BIU_DIAG64
) {
2738 uint32_t transmit_length
= pmb
->un
.varWords
[1];
2739 uint32_t receive_length
= pmb
->un
.varWords
[4];
2740 /* transmit length cannot be greater than receive length or
2741 * mailbox extension size
2743 if ((transmit_length
> receive_length
) ||
2744 (transmit_length
> MAILBOX_EXT_SIZE
)) {
2749 rxbmp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
2755 rxbmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &rxbmp
->phys
);
2761 INIT_LIST_HEAD(&rxbmp
->list
);
2762 rxbpl
= (struct ulp_bde64
*) rxbmp
->virt
;
2763 dmp
= diag_cmd_data_alloc(phba
, rxbpl
, transmit_length
, 0);
2769 INIT_LIST_HEAD(&dmp
->dma
.list
);
2770 pmb
->un
.varBIUdiag
.un
.s2
.xmit_bde64
.addrHigh
=
2771 putPaddrHigh(dmp
->dma
.phys
);
2772 pmb
->un
.varBIUdiag
.un
.s2
.xmit_bde64
.addrLow
=
2773 putPaddrLow(dmp
->dma
.phys
);
2775 pmb
->un
.varBIUdiag
.un
.s2
.rcv_bde64
.addrHigh
=
2776 putPaddrHigh(dmp
->dma
.phys
+
2777 pmb
->un
.varBIUdiag
.un
.s2
.
2778 xmit_bde64
.tus
.f
.bdeSize
);
2779 pmb
->un
.varBIUdiag
.un
.s2
.rcv_bde64
.addrLow
=
2780 putPaddrLow(dmp
->dma
.phys
+
2781 pmb
->un
.varBIUdiag
.un
.s2
.
2782 xmit_bde64
.tus
.f
.bdeSize
);
2784 /* copy the transmit data found in the mailbox extension area */
2785 from
= (uint8_t *)mb
;
2786 from
+= sizeof(MAILBOX_t
);
2787 memcpy((uint8_t *)dmp
->dma
.virt
, from
, transmit_length
);
2788 } else if (pmb
->mbxCommand
== MBX_READ_EVENT_LOG
) {
2789 struct READ_EVENT_LOG_VAR
*rdEventLog
=
2790 &pmb
->un
.varRdEventLog
;
2791 uint32_t receive_length
= rdEventLog
->rcv_bde64
.tus
.f
.bdeSize
;
2792 uint32_t mode
= bf_get(lpfc_event_log
, rdEventLog
);
2794 /* receive length cannot be greater than mailbox
2797 if (receive_length
> MAILBOX_EXT_SIZE
) {
2802 /* mode zero uses a bde like biu diags command */
2805 /* rebuild the command for sli4 using our own buffers
2806 * like we do for biu diags
2809 rxbmp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
2815 rxbmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &rxbmp
->phys
);
2816 rxbpl
= (struct ulp_bde64
*) rxbmp
->virt
;
2818 INIT_LIST_HEAD(&rxbmp
->list
);
2819 dmp
= diag_cmd_data_alloc(phba
, rxbpl
,
2828 INIT_LIST_HEAD(&dmp
->dma
.list
);
2829 pmb
->un
.varWords
[3] = putPaddrLow(dmp
->dma
.phys
);
2830 pmb
->un
.varWords
[4] = putPaddrHigh(dmp
->dma
.phys
);
2832 } else if (phba
->sli_rev
== LPFC_SLI_REV4
) {
2833 if (pmb
->mbxCommand
== MBX_DUMP_MEMORY
) {
2834 /* rebuild the command for sli4 using our own buffers
2835 * like we do for biu diags
2837 uint32_t receive_length
= pmb
->un
.varWords
[2];
2838 /* receive length cannot be greater than mailbox
2841 if ((receive_length
== 0) ||
2842 (receive_length
> MAILBOX_EXT_SIZE
)) {
2847 rxbmp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
2853 rxbmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &rxbmp
->phys
);
2859 INIT_LIST_HEAD(&rxbmp
->list
);
2860 rxbpl
= (struct ulp_bde64
*) rxbmp
->virt
;
2861 dmp
= diag_cmd_data_alloc(phba
, rxbpl
, receive_length
,
2868 INIT_LIST_HEAD(&dmp
->dma
.list
);
2869 pmb
->un
.varWords
[3] = putPaddrLow(dmp
->dma
.phys
);
2870 pmb
->un
.varWords
[4] = putPaddrHigh(dmp
->dma
.phys
);
2871 } else if ((pmb
->mbxCommand
== MBX_UPDATE_CFG
) &&
2872 pmb
->un
.varUpdateCfg
.co
) {
2873 struct ulp_bde64
*bde
=
2874 (struct ulp_bde64
*)&pmb
->un
.varWords
[4];
2876 /* bde size cannot be greater than mailbox ext size */
2877 if (bde
->tus
.f
.bdeSize
> MAILBOX_EXT_SIZE
) {
2882 rxbmp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
2888 rxbmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &rxbmp
->phys
);
2894 INIT_LIST_HEAD(&rxbmp
->list
);
2895 rxbpl
= (struct ulp_bde64
*) rxbmp
->virt
;
2896 dmp
= diag_cmd_data_alloc(phba
, rxbpl
,
2897 bde
->tus
.f
.bdeSize
, 0);
2903 INIT_LIST_HEAD(&dmp
->dma
.list
);
2904 bde
->addrHigh
= putPaddrHigh(dmp
->dma
.phys
);
2905 bde
->addrLow
= putPaddrLow(dmp
->dma
.phys
);
2907 /* copy the transmit data found in the mailbox
2910 from
= (uint8_t *)mb
;
2911 from
+= sizeof(MAILBOX_t
);
2912 memcpy((uint8_t *)dmp
->dma
.virt
, from
,
2913 bde
->tus
.f
.bdeSize
);
2917 dd_data
->context_un
.mbox
.rxbmp
= rxbmp
;
2918 dd_data
->context_un
.mbox
.dmp
= dmp
;
2920 /* setup wake call as IOCB callback */
2921 pmboxq
->mbox_cmpl
= lpfc_bsg_wake_mbox_wait
;
2923 /* setup context field to pass wait_queue pointer to wake function */
2924 pmboxq
->context1
= dd_data
;
2925 dd_data
->type
= TYPE_MBOX
;
2926 dd_data
->context_un
.mbox
.pmboxq
= pmboxq
;
2927 dd_data
->context_un
.mbox
.mb
= mb
;
2928 dd_data
->context_un
.mbox
.set_job
= job
;
2929 dd_data
->context_un
.mbox
.ext
= ext
;
2930 dd_data
->context_un
.mbox
.mbOffset
= mbox_req
->mbOffset
;
2931 dd_data
->context_un
.mbox
.inExtWLen
= mbox_req
->inExtWLen
;
2932 dd_data
->context_un
.mbox
.outExtWLen
= mbox_req
->outExtWLen
;
2933 job
->dd_data
= dd_data
;
2935 if ((vport
->fc_flag
& FC_OFFLINE_MODE
) ||
2936 (!(phba
->sli
.sli_flag
& LPFC_SLI_ACTIVE
))) {
2937 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_POLL
);
2938 if (rc
!= MBX_SUCCESS
) {
2939 rc
= (rc
== MBX_TIMEOUT
) ? -ETIME
: -ENODEV
;
2943 /* job finished, copy the data */
2944 memcpy(mb
, pmb
, sizeof(*pmb
));
2945 job
->reply
->reply_payload_rcv_len
=
2946 sg_copy_from_buffer(job
->reply_payload
.sg_list
,
2947 job
->reply_payload
.sg_cnt
,
2949 /* not waiting mbox already done */
2954 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_NOWAIT
);
2955 if ((rc
== MBX_SUCCESS
) || (rc
== MBX_BUSY
))
2956 return 1; /* job started */
2959 /* common exit for error or job completed inline */
2962 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
2965 dma_free_coherent(&phba
->pcidev
->dev
,
2966 dmp
->size
, dmp
->dma
.virt
,
2971 lpfc_mbuf_free(phba
, rxbmp
->virt
, rxbmp
->phys
);
2980 * lpfc_bsg_mbox_cmd - process an fc bsg LPFC_BSG_VENDOR_MBOX command
2981 * @job: MBOX fc_bsg_job for LPFC_BSG_VENDOR_MBOX.
2984 lpfc_bsg_mbox_cmd(struct fc_bsg_job
*job
)
2986 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
2987 struct lpfc_hba
*phba
= vport
->phba
;
2990 /* in case no data is transferred */
2991 job
->reply
->reply_payload_rcv_len
= 0;
2992 if (job
->request_len
<
2993 sizeof(struct fc_bsg_request
) + sizeof(struct dfc_mbox_req
)) {
2994 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
2995 "2737 Received MBOX_REQ request below "
3001 if (job
->request_payload
.payload_len
!= BSG_MBOX_SIZE
) {
3006 if (job
->reply_payload
.payload_len
!= BSG_MBOX_SIZE
) {
3011 if (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
) {
3016 rc
= lpfc_bsg_issue_mbox(phba
, job
, vport
);
3021 job
->reply
->result
= 0;
3022 job
->dd_data
= NULL
;
3025 /* job submitted, will complete later*/
3026 rc
= 0; /* return zero, no error */
3028 /* some error occurred */
3029 job
->reply
->result
= rc
;
3030 job
->dd_data
= NULL
;
3037 * lpfc_bsg_menlo_cmd_cmp - lpfc_menlo_cmd completion handler
3038 * @phba: Pointer to HBA context object.
3039 * @cmdiocbq: Pointer to command iocb.
3040 * @rspiocbq: Pointer to response iocb.
3042 * This function is the completion handler for iocbs issued using
3043 * lpfc_menlo_cmd function. This function is called by the
3044 * ring event handler function without any lock held. This function
3045 * can be called from both worker thread context and interrupt
3046 * context. This function also can be called from another thread which
3047 * cleans up the SLI layer objects.
3048 * This function copies the contents of the response iocb to the
3049 * response iocb memory object provided by the caller of
3050 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
3051 * sleeps for the iocb completion.
3054 lpfc_bsg_menlo_cmd_cmp(struct lpfc_hba
*phba
,
3055 struct lpfc_iocbq
*cmdiocbq
,
3056 struct lpfc_iocbq
*rspiocbq
)
3058 struct bsg_job_data
*dd_data
;
3059 struct fc_bsg_job
*job
;
3061 struct lpfc_dmabuf
*bmp
;
3062 struct lpfc_bsg_menlo
*menlo
;
3063 unsigned long flags
;
3064 struct menlo_response
*menlo_resp
;
3067 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
3068 dd_data
= cmdiocbq
->context1
;
3070 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
3074 menlo
= &dd_data
->context_un
.menlo
;
3075 job
= menlo
->set_job
;
3076 job
->dd_data
= NULL
; /* so timeout handler does not reply */
3078 spin_lock_irqsave(&phba
->hbalock
, flags
);
3079 cmdiocbq
->iocb_flag
|= LPFC_IO_WAKE
;
3080 if (cmdiocbq
->context2
&& rspiocbq
)
3081 memcpy(&((struct lpfc_iocbq
*)cmdiocbq
->context2
)->iocb
,
3082 &rspiocbq
->iocb
, sizeof(IOCB_t
));
3083 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
3086 rspiocbq
= menlo
->rspiocbq
;
3087 rsp
= &rspiocbq
->iocb
;
3089 pci_unmap_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
3090 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
3091 pci_unmap_sg(phba
->pcidev
, job
->reply_payload
.sg_list
,
3092 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
3094 /* always return the xri, this would be used in the case
3095 * of a menlo download to allow the data to be sent as a continuation
3098 menlo_resp
= (struct menlo_response
*)
3099 job
->reply
->reply_data
.vendor_reply
.vendor_rsp
;
3100 menlo_resp
->xri
= rsp
->ulpContext
;
3101 if (rsp
->ulpStatus
) {
3102 if (rsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) {
3103 switch (rsp
->un
.ulpWord
[4] & 0xff) {
3104 case IOERR_SEQUENCE_TIMEOUT
:
3107 case IOERR_INVALID_RPI
:
3117 job
->reply
->reply_payload_rcv_len
=
3118 rsp
->un
.genreq64
.bdl
.bdeSize
;
3120 lpfc_mbuf_free(phba
, bmp
->virt
, bmp
->phys
);
3121 lpfc_sli_release_iocbq(phba
, rspiocbq
);
3122 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
3125 /* make error code available to userspace */
3126 job
->reply
->result
= rc
;
3127 /* complete the job back to userspace */
3129 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
3134 * lpfc_menlo_cmd - send an ioctl for menlo hardware
3135 * @job: fc_bsg_job to handle
3137 * This function issues a gen request 64 CR ioctl for all menlo cmd requests,
3138 * all the command completions will return the xri for the command.
3139 * For menlo data requests a gen request 64 CX is used to continue the exchange
3140 * supplied in the menlo request header xri field.
3143 lpfc_menlo_cmd(struct fc_bsg_job
*job
)
3145 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
3146 struct lpfc_hba
*phba
= vport
->phba
;
3147 struct lpfc_iocbq
*cmdiocbq
, *rspiocbq
;
3150 struct menlo_command
*menlo_cmd
;
3151 struct menlo_response
*menlo_resp
;
3152 struct lpfc_dmabuf
*bmp
= NULL
;
3155 struct scatterlist
*sgel
= NULL
;
3158 struct bsg_job_data
*dd_data
;
3159 struct ulp_bde64
*bpl
= NULL
;
3161 /* in case no data is returned return just the return code */
3162 job
->reply
->reply_payload_rcv_len
= 0;
3164 if (job
->request_len
<
3165 sizeof(struct fc_bsg_request
) +
3166 sizeof(struct menlo_command
)) {
3167 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
3168 "2784 Received MENLO_CMD request below "
3174 if (job
->reply_len
<
3175 sizeof(struct fc_bsg_request
) + sizeof(struct menlo_response
)) {
3176 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
3177 "2785 Received MENLO_CMD reply below "
3183 if (!(phba
->menlo_flag
& HBA_MENLO_SUPPORT
)) {
3184 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
3185 "2786 Adapter does not support menlo "
3191 menlo_cmd
= (struct menlo_command
*)
3192 job
->request
->rqst_data
.h_vendor
.vendor_cmd
;
3194 menlo_resp
= (struct menlo_response
*)
3195 job
->reply
->reply_data
.vendor_reply
.vendor_rsp
;
3197 /* allocate our bsg tracking structure */
3198 dd_data
= kmalloc(sizeof(struct bsg_job_data
), GFP_KERNEL
);
3200 lpfc_printf_log(phba
, KERN_WARNING
, LOG_LIBDFC
,
3201 "2787 Failed allocation of dd_data\n");
3206 bmp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
3212 cmdiocbq
= lpfc_sli_get_iocbq(phba
);
3218 rspiocbq
= lpfc_sli_get_iocbq(phba
);
3224 rsp
= &rspiocbq
->iocb
;
3226 bmp
->virt
= lpfc_mbuf_alloc(phba
, 0, &bmp
->phys
);
3232 INIT_LIST_HEAD(&bmp
->list
);
3233 bpl
= (struct ulp_bde64
*) bmp
->virt
;
3234 request_nseg
= pci_map_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
3235 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
3236 for_each_sg(job
->request_payload
.sg_list
, sgel
, request_nseg
, numbde
) {
3237 busaddr
= sg_dma_address(sgel
);
3238 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
3239 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
3240 bpl
->tus
.w
= cpu_to_le32(bpl
->tus
.w
);
3241 bpl
->addrLow
= cpu_to_le32(putPaddrLow(busaddr
));
3242 bpl
->addrHigh
= cpu_to_le32(putPaddrHigh(busaddr
));
3246 reply_nseg
= pci_map_sg(phba
->pcidev
, job
->reply_payload
.sg_list
,
3247 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
3248 for_each_sg(job
->reply_payload
.sg_list
, sgel
, reply_nseg
, numbde
) {
3249 busaddr
= sg_dma_address(sgel
);
3250 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64I
;
3251 bpl
->tus
.f
.bdeSize
= sg_dma_len(sgel
);
3252 bpl
->tus
.w
= cpu_to_le32(bpl
->tus
.w
);
3253 bpl
->addrLow
= cpu_to_le32(putPaddrLow(busaddr
));
3254 bpl
->addrHigh
= cpu_to_le32(putPaddrHigh(busaddr
));
3258 cmd
= &cmdiocbq
->iocb
;
3259 cmd
->un
.genreq64
.bdl
.ulpIoTag32
= 0;
3260 cmd
->un
.genreq64
.bdl
.addrHigh
= putPaddrHigh(bmp
->phys
);
3261 cmd
->un
.genreq64
.bdl
.addrLow
= putPaddrLow(bmp
->phys
);
3262 cmd
->un
.genreq64
.bdl
.bdeFlags
= BUFF_TYPE_BLP_64
;
3263 cmd
->un
.genreq64
.bdl
.bdeSize
=
3264 (request_nseg
+ reply_nseg
) * sizeof(struct ulp_bde64
);
3265 cmd
->un
.genreq64
.w5
.hcsw
.Fctl
= (SI
| LA
);
3266 cmd
->un
.genreq64
.w5
.hcsw
.Dfctl
= 0;
3267 cmd
->un
.genreq64
.w5
.hcsw
.Rctl
= FC_RCTL_DD_UNSOL_CMD
;
3268 cmd
->un
.genreq64
.w5
.hcsw
.Type
= MENLO_TRANSPORT_TYPE
; /* 0xfe */
3269 cmd
->ulpBdeCount
= 1;
3270 cmd
->ulpClass
= CLASS3
;
3271 cmd
->ulpOwner
= OWN_CHIP
;
3272 cmd
->ulpLe
= 1; /* Limited Edition */
3273 cmdiocbq
->iocb_flag
|= LPFC_IO_LIBDFC
;
3274 cmdiocbq
->vport
= phba
->pport
;
3275 /* We want the firmware to timeout before we do */
3276 cmd
->ulpTimeout
= MENLO_TIMEOUT
- 5;
3277 cmdiocbq
->context3
= bmp
;
3278 cmdiocbq
->context2
= rspiocbq
;
3279 cmdiocbq
->iocb_cmpl
= lpfc_bsg_menlo_cmd_cmp
;
3280 cmdiocbq
->context1
= dd_data
;
3281 cmdiocbq
->context2
= rspiocbq
;
3282 if (menlo_cmd
->cmd
== LPFC_BSG_VENDOR_MENLO_CMD
) {
3283 cmd
->ulpCommand
= CMD_GEN_REQUEST64_CR
;
3284 cmd
->ulpPU
= MENLO_PU
; /* 3 */
3285 cmd
->un
.ulpWord
[4] = MENLO_DID
; /* 0x0000FC0E */
3286 cmd
->ulpContext
= MENLO_CONTEXT
; /* 0 */
3288 cmd
->ulpCommand
= CMD_GEN_REQUEST64_CX
;
3290 cmd
->un
.ulpWord
[4] = 0;
3291 cmd
->ulpContext
= menlo_cmd
->xri
;
3294 dd_data
->type
= TYPE_MENLO
;
3295 dd_data
->context_un
.menlo
.cmdiocbq
= cmdiocbq
;
3296 dd_data
->context_un
.menlo
.rspiocbq
= rspiocbq
;
3297 dd_data
->context_un
.menlo
.set_job
= job
;
3298 dd_data
->context_un
.menlo
.bmp
= bmp
;
3300 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, cmdiocbq
,
3302 if (rc
== IOCB_SUCCESS
)
3303 return 0; /* done for now */
3305 /* iocb failed so cleanup */
3306 pci_unmap_sg(phba
->pcidev
, job
->request_payload
.sg_list
,
3307 job
->request_payload
.sg_cnt
, DMA_TO_DEVICE
);
3308 pci_unmap_sg(phba
->pcidev
, job
->reply_payload
.sg_list
,
3309 job
->reply_payload
.sg_cnt
, DMA_FROM_DEVICE
);
3311 lpfc_mbuf_free(phba
, bmp
->virt
, bmp
->phys
);
3314 lpfc_sli_release_iocbq(phba
, rspiocbq
);
3316 lpfc_sli_release_iocbq(phba
, cmdiocbq
);
3322 /* make error code available to userspace */
3323 job
->reply
->result
= rc
;
3324 job
->dd_data
= NULL
;
3328 * lpfc_bsg_hst_vendor - process a vendor-specific fc_bsg_job
3329 * @job: fc_bsg_job to handle
3332 lpfc_bsg_hst_vendor(struct fc_bsg_job
*job
)
3334 int command
= job
->request
->rqst_data
.h_vendor
.vendor_cmd
[0];
3338 case LPFC_BSG_VENDOR_SET_CT_EVENT
:
3339 rc
= lpfc_bsg_hba_set_event(job
);
3341 case LPFC_BSG_VENDOR_GET_CT_EVENT
:
3342 rc
= lpfc_bsg_hba_get_event(job
);
3344 case LPFC_BSG_VENDOR_SEND_MGMT_RESP
:
3345 rc
= lpfc_bsg_send_mgmt_rsp(job
);
3347 case LPFC_BSG_VENDOR_DIAG_MODE
:
3348 rc
= lpfc_bsg_diag_mode(job
);
3350 case LPFC_BSG_VENDOR_DIAG_TEST
:
3351 rc
= lpfc_bsg_diag_test(job
);
3353 case LPFC_BSG_VENDOR_GET_MGMT_REV
:
3354 rc
= lpfc_bsg_get_dfc_rev(job
);
3356 case LPFC_BSG_VENDOR_MBOX
:
3357 rc
= lpfc_bsg_mbox_cmd(job
);
3359 case LPFC_BSG_VENDOR_MENLO_CMD
:
3360 case LPFC_BSG_VENDOR_MENLO_DATA
:
3361 rc
= lpfc_menlo_cmd(job
);
3365 job
->reply
->reply_payload_rcv_len
= 0;
3366 /* make error code available to userspace */
3367 job
->reply
->result
= rc
;
3375 * lpfc_bsg_request - handle a bsg request from the FC transport
3376 * @job: fc_bsg_job to handle
3379 lpfc_bsg_request(struct fc_bsg_job
*job
)
3384 msgcode
= job
->request
->msgcode
;
3386 case FC_BSG_HST_VENDOR
:
3387 rc
= lpfc_bsg_hst_vendor(job
);
3389 case FC_BSG_RPT_ELS
:
3390 rc
= lpfc_bsg_rport_els(job
);
3393 rc
= lpfc_bsg_send_mgmt_cmd(job
);
3397 job
->reply
->reply_payload_rcv_len
= 0;
3398 /* make error code available to userspace */
3399 job
->reply
->result
= rc
;
3407 * lpfc_bsg_timeout - handle timeout of a bsg request from the FC transport
3408 * @job: fc_bsg_job that has timed out
3410 * This function just aborts the job's IOCB. The aborted IOCB will return to
3411 * the waiting function which will handle passing the error back to userspace
3414 lpfc_bsg_timeout(struct fc_bsg_job
*job
)
3416 struct lpfc_vport
*vport
= (struct lpfc_vport
*)job
->shost
->hostdata
;
3417 struct lpfc_hba
*phba
= vport
->phba
;
3418 struct lpfc_iocbq
*cmdiocb
;
3419 struct lpfc_bsg_event
*evt
;
3420 struct lpfc_bsg_iocb
*iocb
;
3421 struct lpfc_bsg_mbox
*mbox
;
3422 struct lpfc_bsg_menlo
*menlo
;
3423 struct lpfc_sli_ring
*pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
3424 struct bsg_job_data
*dd_data
;
3425 unsigned long flags
;
3427 spin_lock_irqsave(&phba
->ct_ev_lock
, flags
);
3428 dd_data
= (struct bsg_job_data
*)job
->dd_data
;
3429 /* timeout and completion crossed paths if no dd_data */
3431 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
3435 switch (dd_data
->type
) {
3437 iocb
= &dd_data
->context_un
.iocb
;
3438 cmdiocb
= iocb
->cmdiocbq
;
3439 /* hint to completion handler that the job timed out */
3440 job
->reply
->result
= -EAGAIN
;
3441 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
3442 /* this will call our completion handler */
3443 spin_lock_irq(&phba
->hbalock
);
3444 lpfc_sli_issue_abort_iotag(phba
, pring
, cmdiocb
);
3445 spin_unlock_irq(&phba
->hbalock
);
3448 evt
= dd_data
->context_un
.evt
;
3449 /* this event has no job anymore */
3450 evt
->set_job
= NULL
;
3451 job
->dd_data
= NULL
;
3452 job
->reply
->reply_payload_rcv_len
= 0;
3453 /* Return -EAGAIN which is our way of signallying the
3456 job
->reply
->result
= -EAGAIN
;
3457 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
3461 mbox
= &dd_data
->context_un
.mbox
;
3462 /* this mbox has no job anymore */
3463 mbox
->set_job
= NULL
;
3464 job
->dd_data
= NULL
;
3465 job
->reply
->reply_payload_rcv_len
= 0;
3466 job
->reply
->result
= -EAGAIN
;
3467 /* the mbox completion handler can now be run */
3468 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
3472 menlo
= &dd_data
->context_un
.menlo
;
3473 cmdiocb
= menlo
->cmdiocbq
;
3474 /* hint to completion handler that the job timed out */
3475 job
->reply
->result
= -EAGAIN
;
3476 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
3477 /* this will call our completion handler */
3478 spin_lock_irq(&phba
->hbalock
);
3479 lpfc_sli_issue_abort_iotag(phba
, pring
, cmdiocb
);
3480 spin_unlock_irq(&phba
->hbalock
);
3483 spin_unlock_irqrestore(&phba
->ct_ev_lock
, flags
);
3487 /* scsi transport fc fc_bsg_job_timeout expects a zero return code,
3488 * otherwise an error message will be displayed on the console
3489 * so always return success (zero)