?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'v3.3.7' into 3.3/master
[zen-stable.git] / drivers / scsi / lpfc / lpfc_bsg.c
blob56a86baece5b035cbbb0116f3a790b13a896fc84
1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2009-2011 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 #include <linux/interrupt.h>
22 #include <linux/mempool.h>
23 #include <linux/pci.h>
24 #include <linux/slab.h>
25 #include <linux/delay.h>
26 #include <linux/list.h>
27
28 #include <scsi/scsi.h>
29 #include <scsi/scsi_host.h>
30 #include <scsi/scsi_transport_fc.h>
31 #include <scsi/scsi_bsg_fc.h>
32 #include <scsi/fc/fc_fs.h>
33
34 #include "lpfc_hw4.h"
35 #include "lpfc_hw.h"
36 #include "lpfc_sli.h"
37 #include "lpfc_sli4.h"
38 #include "lpfc_nl.h"
39 #include "lpfc_bsg.h"
40 #include "lpfc_disc.h"
41 #include "lpfc_scsi.h"
42 #include "lpfc.h"
43 #include "lpfc_logmsg.h"
44 #include "lpfc_crtn.h"
45 #include "lpfc_debugfs.h"
46 #include "lpfc_vport.h"
47 #include "lpfc_version.h"
48
49 struct lpfc_bsg_event {
50 struct list_head node;
51 struct kref kref;
52 wait_queue_head_t wq;
53
54 /* Event type and waiter identifiers */
55 uint32_t type_mask;
56 uint32_t req_id;
57 uint32_t reg_id;
58
59 /* next two flags are here for the auto-delete logic */
60 unsigned long wait_time_stamp;
61 int waiting;
62
63 /* seen and not seen events */
64 struct list_head events_to_get;
65 struct list_head events_to_see;
66
67 /* job waiting for this event to finish */
68 struct fc_bsg_job *set_job;
69 };
70
71 struct lpfc_bsg_iocb {
72 struct lpfc_iocbq *cmdiocbq;
73 struct lpfc_iocbq *rspiocbq;
74 struct lpfc_dmabuf *bmp;
75 struct lpfc_nodelist *ndlp;
76
77 /* job waiting for this iocb to finish */
78 struct fc_bsg_job *set_job;
79 };
80
81 struct lpfc_bsg_mbox {
82 LPFC_MBOXQ_t *pmboxq;
83 MAILBOX_t *mb;
84 struct lpfc_dmabuf *dmabuffers; /* for BIU diags */
85 uint8_t *ext; /* extended mailbox data */
86 uint32_t mbOffset; /* from app */
87 uint32_t inExtWLen; /* from app */
88 uint32_t outExtWLen; /* from app */
89
90 /* job waiting for this mbox command to finish */
91 struct fc_bsg_job *set_job;
92 };
93
94 #define MENLO_DID 0x0000FC0E
95
96 struct lpfc_bsg_menlo {
97 struct lpfc_iocbq *cmdiocbq;
98 struct lpfc_iocbq *rspiocbq;
99 struct lpfc_dmabuf *bmp;
100
101 /* job waiting for this iocb to finish */
102 struct fc_bsg_job *set_job;
103 };
104
105 #define TYPE_EVT 1
106 #define TYPE_IOCB 2
107 #define TYPE_MBOX 3
108 #define TYPE_MENLO 4
109 struct bsg_job_data {
110 uint32_t type;
111 union {
112 struct lpfc_bsg_event *evt;
113 struct lpfc_bsg_iocb iocb;
114 struct lpfc_bsg_mbox mbox;
115 struct lpfc_bsg_menlo menlo;
116 } context_un;
117 };
118
119 struct event_data {
120 struct list_head node;
121 uint32_t type;
122 uint32_t immed_dat;
123 void *data;
124 uint32_t len;
125 };
126
127 #define BUF_SZ_4K 4096
128 #define SLI_CT_ELX_LOOPBACK 0x10
129
130 enum ELX_LOOPBACK_CMD {
131 ELX_LOOPBACK_XRI_SETUP,
132 ELX_LOOPBACK_DATA,
133 };
134
135 #define ELX_LOOPBACK_HEADER_SZ \
136 (size_t)(&((struct lpfc_sli_ct_request *)NULL)->un)
137
138 struct lpfc_dmabufext {
139 struct lpfc_dmabuf dma;
140 uint32_t size;
141 uint32_t flag;
142 };
143
144 /**
145 * lpfc_bsg_send_mgmt_cmd_cmp - lpfc_bsg_send_mgmt_cmd's completion handler
146 * @phba: Pointer to HBA context object.
147 * @cmdiocbq: Pointer to command iocb.
148 * @rspiocbq: Pointer to response iocb.
149 *
150 * This function is the completion handler for iocbs issued using
151 * lpfc_bsg_send_mgmt_cmd function. This function is called by the
152 * ring event handler function without any lock held. This function
153 * can be called from both worker thread context and interrupt
154 * context. This function also can be called from another thread which
155 * cleans up the SLI layer objects.
156 * This function copies the contents of the response iocb to the
157 * response iocb memory object provided by the caller of
158 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
159 * sleeps for the iocb completion.
160 **/
161 static void
162 lpfc_bsg_send_mgmt_cmd_cmp(struct lpfc_hba *phba,
163 struct lpfc_iocbq *cmdiocbq,
164 struct lpfc_iocbq *rspiocbq)
165 {
166 struct bsg_job_data *dd_data;
167 struct fc_bsg_job *job;
168 IOCB_t *rsp;
169 struct lpfc_dmabuf *bmp;
170 struct lpfc_nodelist *ndlp;
171 struct lpfc_bsg_iocb *iocb;
172 unsigned long flags;
173 int rc = 0;
174
175 spin_lock_irqsave(&phba->ct_ev_lock, flags);
176 dd_data = cmdiocbq->context2;
177 if (!dd_data) {
178 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
179 lpfc_sli_release_iocbq(phba, cmdiocbq);
180 return;
181 }
182
183 iocb = &dd_data->context_un.iocb;
184 job = iocb->set_job;
185 job->dd_data = NULL; /* so timeout handler does not reply */
186
187 bmp = iocb->bmp;
188 rsp = &rspiocbq->iocb;
189 ndlp = cmdiocbq->context1;
190
191 pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
192 job->request_payload.sg_cnt, DMA_TO_DEVICE);
193 pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
194 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
195
196 if (rsp->ulpStatus) {
197 if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
198 switch (rsp->un.ulpWord[4] & 0xff) {
199 case IOERR_SEQUENCE_TIMEOUT:
200 rc = -ETIMEDOUT;
201 break;
202 case IOERR_INVALID_RPI:
203 rc = -EFAULT;
204 break;
205 default:
206 rc = -EACCES;
207 break;
208 }
209 } else
210 rc = -EACCES;
211 } else
212 job->reply->reply_payload_rcv_len =
213 rsp->un.genreq64.bdl.bdeSize;
214
215 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
216 lpfc_sli_release_iocbq(phba, cmdiocbq);
217 lpfc_nlp_put(ndlp);
218 kfree(bmp);
219 kfree(dd_data);
220 /* make error code available to userspace */
221 job->reply->result = rc;
222 /* complete the job back to userspace */
223 job->job_done(job);
224 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
225 return;
226 }
227
228 /**
229 * lpfc_bsg_send_mgmt_cmd - send a CT command from a bsg request
230 * @job: fc_bsg_job to handle
231 **/
232 static int
233 lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
234 {
235 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
236 struct lpfc_hba *phba = vport->phba;
237 struct lpfc_rport_data *rdata = job->rport->dd_data;
238 struct lpfc_nodelist *ndlp = rdata->pnode;
239 struct ulp_bde64 *bpl = NULL;
240 uint32_t timeout;
241 struct lpfc_iocbq *cmdiocbq = NULL;
242 IOCB_t *cmd;
243 struct lpfc_dmabuf *bmp = NULL;
244 int request_nseg;
245 int reply_nseg;
246 struct scatterlist *sgel = NULL;
247 int numbde;
248 dma_addr_t busaddr;
249 struct bsg_job_data *dd_data;
250 uint32_t creg_val;
251 int rc = 0;
252 int iocb_stat;
253
254 /* in case no data is transferred */
255 job->reply->reply_payload_rcv_len = 0;
256
257 /* allocate our bsg tracking structure */
258 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
259 if (!dd_data) {
260 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
261 "2733 Failed allocation of dd_data\n");
262 rc = -ENOMEM;
263 goto no_dd_data;
264 }
265
266 if (!lpfc_nlp_get(ndlp)) {
267 rc = -ENODEV;
268 goto no_ndlp;
269 }
270
271 bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
272 if (!bmp) {
273 rc = -ENOMEM;
274 goto free_ndlp;
275 }
276
277 if (ndlp->nlp_flag & NLP_ELS_SND_MASK) {
278 rc = -ENODEV;
279 goto free_bmp;
280 }
281
282 cmdiocbq = lpfc_sli_get_iocbq(phba);
283 if (!cmdiocbq) {
284 rc = -ENOMEM;
285 goto free_bmp;
286 }
287
288 cmd = &cmdiocbq->iocb;
289 bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
290 if (!bmp->virt) {
291 rc = -ENOMEM;
292 goto free_cmdiocbq;
293 }
294
295 INIT_LIST_HEAD(&bmp->list);
296 bpl = (struct ulp_bde64 *) bmp->virt;
297 request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
298 job->request_payload.sg_cnt, DMA_TO_DEVICE);
299 for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
300 busaddr = sg_dma_address(sgel);
301 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
302 bpl->tus.f.bdeSize = sg_dma_len(sgel);
303 bpl->tus.w = cpu_to_le32(bpl->tus.w);
304 bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
305 bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
306 bpl++;
307 }
308
309 reply_nseg = pci_map_sg(phba->pcidev, job->reply_payload.sg_list,
310 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
311 for_each_sg(job->reply_payload.sg_list, sgel, reply_nseg, numbde) {
312 busaddr = sg_dma_address(sgel);
313 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
314 bpl->tus.f.bdeSize = sg_dma_len(sgel);
315 bpl->tus.w = cpu_to_le32(bpl->tus.w);
316 bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
317 bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
318 bpl++;
319 }
320
321 cmd->un.genreq64.bdl.ulpIoTag32 = 0;
322 cmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
323 cmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
324 cmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
325 cmd->un.genreq64.bdl.bdeSize =
326 (request_nseg + reply_nseg) * sizeof(struct ulp_bde64);
327 cmd->ulpCommand = CMD_GEN_REQUEST64_CR;
328 cmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
329 cmd->un.genreq64.w5.hcsw.Dfctl = 0;
330 cmd->un.genreq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
331 cmd->un.genreq64.w5.hcsw.Type = FC_TYPE_CT;
332 cmd->ulpBdeCount = 1;
333 cmd->ulpLe = 1;
334 cmd->ulpClass = CLASS3;
335 cmd->ulpContext = ndlp->nlp_rpi;
336 if (phba->sli_rev == LPFC_SLI_REV4)
337 cmd->ulpContext = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
338 cmd->ulpOwner = OWN_CHIP;
339 cmdiocbq->vport = phba->pport;
340 cmdiocbq->context3 = bmp;
341 cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
342 timeout = phba->fc_ratov * 2;
343 cmd->ulpTimeout = timeout;
344
345 cmdiocbq->iocb_cmpl = lpfc_bsg_send_mgmt_cmd_cmp;
346 cmdiocbq->context1 = ndlp;
347 cmdiocbq->context2 = dd_data;
348 dd_data->type = TYPE_IOCB;
349 dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
350 dd_data->context_un.iocb.set_job = job;
351 dd_data->context_un.iocb.bmp = bmp;
352
353 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
354 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
355 rc = -EIO ;
356 goto free_cmdiocbq;
357 }
358 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
359 writel(creg_val, phba->HCregaddr);
360 readl(phba->HCregaddr); /* flush */
361 }
362
363 iocb_stat = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
364 if (iocb_stat == IOCB_SUCCESS)
365 return 0; /* done for now */
366 else if (iocb_stat == IOCB_BUSY)
367 rc = -EAGAIN;
368 else
369 rc = -EIO;
370
371
372 /* iocb failed so cleanup */
373 pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
374 job->request_payload.sg_cnt, DMA_TO_DEVICE);
375 pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
376 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
377
378 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
379
380 free_cmdiocbq:
381 lpfc_sli_release_iocbq(phba, cmdiocbq);
382 free_bmp:
383 kfree(bmp);
384 free_ndlp:
385 lpfc_nlp_put(ndlp);
386 no_ndlp:
387 kfree(dd_data);
388 no_dd_data:
389 /* make error code available to userspace */
390 job->reply->result = rc;
391 job->dd_data = NULL;
392 return rc;
393 }
394
395 /**
396 * lpfc_bsg_rport_els_cmp - lpfc_bsg_rport_els's completion handler
397 * @phba: Pointer to HBA context object.
398 * @cmdiocbq: Pointer to command iocb.
399 * @rspiocbq: Pointer to response iocb.
400 *
401 * This function is the completion handler for iocbs issued using
402 * lpfc_bsg_rport_els_cmp function. This function is called by the
403 * ring event handler function without any lock held. This function
404 * can be called from both worker thread context and interrupt
405 * context. This function also can be called from other thread which
406 * cleans up the SLI layer objects.
407 * This function copies the contents of the response iocb to the
408 * response iocb memory object provided by the caller of
409 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
410 * sleeps for the iocb completion.
411 **/
412 static void
413 lpfc_bsg_rport_els_cmp(struct lpfc_hba *phba,
414 struct lpfc_iocbq *cmdiocbq,
415 struct lpfc_iocbq *rspiocbq)
416 {
417 struct bsg_job_data *dd_data;
418 struct fc_bsg_job *job;
419 IOCB_t *rsp;
420 struct lpfc_nodelist *ndlp;
421 struct lpfc_dmabuf *pbuflist = NULL;
422 struct fc_bsg_ctels_reply *els_reply;
423 uint8_t *rjt_data;
424 unsigned long flags;
425 int rc = 0;
426
427 spin_lock_irqsave(&phba->ct_ev_lock, flags);
428 dd_data = cmdiocbq->context1;
429 /* normal completion and timeout crossed paths, already done */
430 if (!dd_data) {
431 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
432 return;
433 }
434
435 cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
436 if (cmdiocbq->context2 && rspiocbq)
437 memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
438 &rspiocbq->iocb, sizeof(IOCB_t));
439
440 job = dd_data->context_un.iocb.set_job;
441 cmdiocbq = dd_data->context_un.iocb.cmdiocbq;
442 rspiocbq = dd_data->context_un.iocb.rspiocbq;
443 rsp = &rspiocbq->iocb;
444 ndlp = dd_data->context_un.iocb.ndlp;
445
446 pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
447 job->request_payload.sg_cnt, DMA_TO_DEVICE);
448 pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
449 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
450
451 if (job->reply->result == -EAGAIN)
452 rc = -EAGAIN;
453 else if (rsp->ulpStatus == IOSTAT_SUCCESS)
454 job->reply->reply_payload_rcv_len =
455 rsp->un.elsreq64.bdl.bdeSize;
456 else if (rsp->ulpStatus == IOSTAT_LS_RJT) {
457 job->reply->reply_payload_rcv_len =
458 sizeof(struct fc_bsg_ctels_reply);
459 /* LS_RJT data returned in word 4 */
460 rjt_data = (uint8_t *)&rsp->un.ulpWord[4];
461 els_reply = &job->reply->reply_data.ctels_reply;
462 els_reply->status = FC_CTELS_STATUS_REJECT;
463 els_reply->rjt_data.action = rjt_data[3];
464 els_reply->rjt_data.reason_code = rjt_data[2];
465 els_reply->rjt_data.reason_explanation = rjt_data[1];
466 els_reply->rjt_data.vendor_unique = rjt_data[0];
467 } else
468 rc = -EIO;
469
470 pbuflist = (struct lpfc_dmabuf *) cmdiocbq->context3;
471 lpfc_mbuf_free(phba, pbuflist->virt, pbuflist->phys);
472 lpfc_sli_release_iocbq(phba, rspiocbq);
473 lpfc_sli_release_iocbq(phba, cmdiocbq);
474 lpfc_nlp_put(ndlp);
475 kfree(dd_data);
476 /* make error code available to userspace */
477 job->reply->result = rc;
478 job->dd_data = NULL;
479 /* complete the job back to userspace */
480 job->job_done(job);
481 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
482 return;
483 }
484
485 /**
486 * lpfc_bsg_rport_els - send an ELS command from a bsg request
487 * @job: fc_bsg_job to handle
488 **/
489 static int
490 lpfc_bsg_rport_els(struct fc_bsg_job *job)
491 {
492 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
493 struct lpfc_hba *phba = vport->phba;
494 struct lpfc_rport_data *rdata = job->rport->dd_data;
495 struct lpfc_nodelist *ndlp = rdata->pnode;
496 uint32_t elscmd;
497 uint32_t cmdsize;
498 uint32_t rspsize;
499 struct lpfc_iocbq *rspiocbq;
500 struct lpfc_iocbq *cmdiocbq;
501 IOCB_t *rsp;
502 uint16_t rpi = 0;
503 struct lpfc_dmabuf *pcmd;
504 struct lpfc_dmabuf *prsp;
505 struct lpfc_dmabuf *pbuflist = NULL;
506 struct ulp_bde64 *bpl;
507 int request_nseg;
508 int reply_nseg;
509 struct scatterlist *sgel = NULL;
510 int numbde;
511 dma_addr_t busaddr;
512 struct bsg_job_data *dd_data;
513 uint32_t creg_val;
514 int rc = 0;
515
516 /* in case no data is transferred */
517 job->reply->reply_payload_rcv_len = 0;
518
519 /* allocate our bsg tracking structure */
520 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
521 if (!dd_data) {
522 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
523 "2735 Failed allocation of dd_data\n");
524 rc = -ENOMEM;
525 goto no_dd_data;
526 }
527
528 if (!lpfc_nlp_get(ndlp)) {
529 rc = -ENODEV;
530 goto free_dd_data;
531 }
532
533 elscmd = job->request->rqst_data.r_els.els_code;
534 cmdsize = job->request_payload.payload_len;
535 rspsize = job->reply_payload.payload_len;
536 rspiocbq = lpfc_sli_get_iocbq(phba);
537 if (!rspiocbq) {
538 lpfc_nlp_put(ndlp);
539 rc = -ENOMEM;
540 goto free_dd_data;
541 }
542
543 rsp = &rspiocbq->iocb;
544 rpi = ndlp->nlp_rpi;
545
546 cmdiocbq = lpfc_prep_els_iocb(vport, 1, cmdsize, 0, ndlp,
547 ndlp->nlp_DID, elscmd);
548 if (!cmdiocbq) {
549 rc = -EIO;
550 goto free_rspiocbq;
551 }
552
553 /* prep els iocb set context1 to the ndlp, context2 to the command
554 * dmabuf, context3 holds the data dmabuf
555 */
556 pcmd = (struct lpfc_dmabuf *) cmdiocbq->context2;
557 prsp = (struct lpfc_dmabuf *) pcmd->list.next;
558 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
559 kfree(pcmd);
560 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
561 kfree(prsp);
562 cmdiocbq->context2 = NULL;
563
564 pbuflist = (struct lpfc_dmabuf *) cmdiocbq->context3;
565 bpl = (struct ulp_bde64 *) pbuflist->virt;
566
567 request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
568 job->request_payload.sg_cnt, DMA_TO_DEVICE);
569 for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
570 busaddr = sg_dma_address(sgel);
571 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
572 bpl->tus.f.bdeSize = sg_dma_len(sgel);
573 bpl->tus.w = cpu_to_le32(bpl->tus.w);
574 bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
575 bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
576 bpl++;
577 }
578
579 reply_nseg = pci_map_sg(phba->pcidev, job->reply_payload.sg_list,
580 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
581 for_each_sg(job->reply_payload.sg_list, sgel, reply_nseg, numbde) {
582 busaddr = sg_dma_address(sgel);
583 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
584 bpl->tus.f.bdeSize = sg_dma_len(sgel);
585 bpl->tus.w = cpu_to_le32(bpl->tus.w);
586 bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
587 bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
588 bpl++;
589 }
590 cmdiocbq->iocb.un.elsreq64.bdl.bdeSize =
591 (request_nseg + reply_nseg) * sizeof(struct ulp_bde64);
592 cmdiocbq->iocb.ulpContext = rpi;
593 cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
594 cmdiocbq->context1 = NULL;
595 cmdiocbq->context2 = NULL;
596
597 cmdiocbq->iocb_cmpl = lpfc_bsg_rport_els_cmp;
598 cmdiocbq->context1 = dd_data;
599 cmdiocbq->context2 = rspiocbq;
600 dd_data->type = TYPE_IOCB;
601 dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
602 dd_data->context_un.iocb.rspiocbq = rspiocbq;
603 dd_data->context_un.iocb.set_job = job;
604 dd_data->context_un.iocb.bmp = NULL;
605 dd_data->context_un.iocb.ndlp = ndlp;
606
607 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
608 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
609 rc = -EIO;
610 goto linkdown_err;
611 }
612 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
613 writel(creg_val, phba->HCregaddr);
614 readl(phba->HCregaddr); /* flush */
615 }
616 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
617 lpfc_nlp_put(ndlp);
618 if (rc == IOCB_SUCCESS)
619 return 0; /* done for now */
620 else if (rc == IOCB_BUSY)
621 rc = -EAGAIN;
622 else
623 rc = -EIO;
624
625 linkdown_err:
626 pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
627 job->request_payload.sg_cnt, DMA_TO_DEVICE);
628 pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
629 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
630
631 lpfc_mbuf_free(phba, pbuflist->virt, pbuflist->phys);
632
633 lpfc_sli_release_iocbq(phba, cmdiocbq);
634
635 free_rspiocbq:
636 lpfc_sli_release_iocbq(phba, rspiocbq);
637
638 free_dd_data:
639 kfree(dd_data);
640
641 no_dd_data:
642 /* make error code available to userspace */
643 job->reply->result = rc;
644 job->dd_data = NULL;
645 return rc;
646 }
647
648 /**
649 * lpfc_bsg_event_free - frees an allocated event structure
650 * @kref: Pointer to a kref.
651 *
652 * Called from kref_put. Back cast the kref into an event structure address.
653 * Free any events to get, delete associated nodes, free any events to see,
654 * free any data then free the event itself.
655 **/
656 static void
657 lpfc_bsg_event_free(struct kref *kref)
658 {
659 struct lpfc_bsg_event *evt = container_of(kref, struct lpfc_bsg_event,
660 kref);
661 struct event_data *ed;
662
663 list_del(&evt->node);
664
665 while (!list_empty(&evt->events_to_get)) {
666 ed = list_entry(evt->events_to_get.next, typeof(*ed), node);
667 list_del(&ed->node);
668 kfree(ed->data);
669 kfree(ed);
670 }
671
672 while (!list_empty(&evt->events_to_see)) {
673 ed = list_entry(evt->events_to_see.next, typeof(*ed), node);
674 list_del(&ed->node);
675 kfree(ed->data);
676 kfree(ed);
677 }
678
679 kfree(evt);
680 }
681
682 /**
683 * lpfc_bsg_event_ref - increments the kref for an event
684 * @evt: Pointer to an event structure.
685 **/
686 static inline void
687 lpfc_bsg_event_ref(struct lpfc_bsg_event *evt)
688 {
689 kref_get(&evt->kref);
690 }
691
692 /**
693 * lpfc_bsg_event_unref - Uses kref_put to free an event structure
694 * @evt: Pointer to an event structure.
695 **/
696 static inline void
697 lpfc_bsg_event_unref(struct lpfc_bsg_event *evt)
698 {
699 kref_put(&evt->kref, lpfc_bsg_event_free);
700 }
701
702 /**
703 * lpfc_bsg_event_new - allocate and initialize a event structure
704 * @ev_mask: Mask of events.
705 * @ev_reg_id: Event reg id.
706 * @ev_req_id: Event request id.
707 **/
708 static struct lpfc_bsg_event *
709 lpfc_bsg_event_new(uint32_t ev_mask, int ev_reg_id, uint32_t ev_req_id)
710 {
711 struct lpfc_bsg_event *evt = kzalloc(sizeof(*evt), GFP_KERNEL);
712
713 if (!evt)
714 return NULL;
715
716 INIT_LIST_HEAD(&evt->events_to_get);
717 INIT_LIST_HEAD(&evt->events_to_see);
718 evt->type_mask = ev_mask;
719 evt->req_id = ev_req_id;
720 evt->reg_id = ev_reg_id;
721 evt->wait_time_stamp = jiffies;
722 init_waitqueue_head(&evt->wq);
723 kref_init(&evt->kref);
724 return evt;
725 }
726
727 /**
728 * diag_cmd_data_free - Frees an lpfc dma buffer extension
729 * @phba: Pointer to HBA context object.
730 * @mlist: Pointer to an lpfc dma buffer extension.
731 **/
732 static int
733 diag_cmd_data_free(struct lpfc_hba *phba, struct lpfc_dmabufext *mlist)
734 {
735 struct lpfc_dmabufext *mlast;
736 struct pci_dev *pcidev;
737 struct list_head head, *curr, *next;
738
739 if ((!mlist) || (!lpfc_is_link_up(phba) &&
740 (phba->link_flag & LS_LOOPBACK_MODE))) {
741 return 0;
742 }
743
744 pcidev = phba->pcidev;
745 list_add_tail(&head, &mlist->dma.list);
746
747 list_for_each_safe(curr, next, &head) {
748 mlast = list_entry(curr, struct lpfc_dmabufext , dma.list);
749 if (mlast->dma.virt)
750 dma_free_coherent(&pcidev->dev,
751 mlast->size,
752 mlast->dma.virt,
753 mlast->dma.phys);
754 kfree(mlast);
755 }
756 return 0;
757 }
758
759 /**
760 * lpfc_bsg_ct_unsol_event - process an unsolicited CT command
761 * @phba:
762 * @pring:
763 * @piocbq:
764 *
765 * This function is called when an unsolicited CT command is received. It
766 * forwards the event to any processes registered to receive CT events.
767 **/
768 int
769 lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
770 struct lpfc_iocbq *piocbq)
771 {
772 uint32_t evt_req_id = 0;
773 uint32_t cmd;
774 uint32_t len;
775 struct lpfc_dmabuf *dmabuf = NULL;
776 struct lpfc_bsg_event *evt;
777 struct event_data *evt_dat = NULL;
778 struct lpfc_iocbq *iocbq;
779 size_t offset = 0;
780 struct list_head head;
781 struct ulp_bde64 *bde;
782 dma_addr_t dma_addr;
783 int i;
784 struct lpfc_dmabuf *bdeBuf1 = piocbq->context2;
785 struct lpfc_dmabuf *bdeBuf2 = piocbq->context3;
786 struct lpfc_hbq_entry *hbqe;
787 struct lpfc_sli_ct_request *ct_req;
788 struct fc_bsg_job *job = NULL;
789 unsigned long flags;
790 int size = 0;
791
792 INIT_LIST_HEAD(&head);
793 list_add_tail(&head, &piocbq->list);
794
795 if (piocbq->iocb.ulpBdeCount == 0 ||
796 piocbq->iocb.un.cont64[0].tus.f.bdeSize == 0)
797 goto error_ct_unsol_exit;
798
799 if (phba->link_state == LPFC_HBA_ERROR ||
800 (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)))
801 goto error_ct_unsol_exit;
802
803 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
804 dmabuf = bdeBuf1;
805 else {
806 dma_addr = getPaddr(piocbq->iocb.un.cont64[0].addrHigh,
807 piocbq->iocb.un.cont64[0].addrLow);
808 dmabuf = lpfc_sli_ringpostbuf_get(phba, pring, dma_addr);
809 }
810 if (dmabuf == NULL)
811 goto error_ct_unsol_exit;
812 ct_req = (struct lpfc_sli_ct_request *)dmabuf->virt;
813 evt_req_id = ct_req->FsType;
814 cmd = ct_req->CommandResponse.bits.CmdRsp;
815 len = ct_req->CommandResponse.bits.Size;
816 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
817 lpfc_sli_ringpostbuf_put(phba, pring, dmabuf);
818
819 spin_lock_irqsave(&phba->ct_ev_lock, flags);
820 list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
821 if (!(evt->type_mask & FC_REG_CT_EVENT) ||
822 evt->req_id != evt_req_id)
823 continue;
824
825 lpfc_bsg_event_ref(evt);
826 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
827 evt_dat = kzalloc(sizeof(*evt_dat), GFP_KERNEL);
828 if (evt_dat == NULL) {
829 spin_lock_irqsave(&phba->ct_ev_lock, flags);
830 lpfc_bsg_event_unref(evt);
831 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
832 "2614 Memory allocation failed for "
833 "CT event\n");
834 break;
835 }
836
837 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
838 /* take accumulated byte count from the last iocbq */
839 iocbq = list_entry(head.prev, typeof(*iocbq), list);
840 evt_dat->len = iocbq->iocb.unsli3.rcvsli3.acc_len;
841 } else {
842 list_for_each_entry(iocbq, &head, list) {
843 for (i = 0; i < iocbq->iocb.ulpBdeCount; i++)
844 evt_dat->len +=
845 iocbq->iocb.un.cont64[i].tus.f.bdeSize;
846 }
847 }
848
849 evt_dat->data = kzalloc(evt_dat->len, GFP_KERNEL);
850 if (evt_dat->data == NULL) {
851 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
852 "2615 Memory allocation failed for "
853 "CT event data, size %d\n",
854 evt_dat->len);
855 kfree(evt_dat);
856 spin_lock_irqsave(&phba->ct_ev_lock, flags);
857 lpfc_bsg_event_unref(evt);
858 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
859 goto error_ct_unsol_exit;
860 }
861
862 list_for_each_entry(iocbq, &head, list) {
863 size = 0;
864 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
865 bdeBuf1 = iocbq->context2;
866 bdeBuf2 = iocbq->context3;
867 }
868 for (i = 0; i < iocbq->iocb.ulpBdeCount; i++) {
869 if (phba->sli3_options &
870 LPFC_SLI3_HBQ_ENABLED) {
871 if (i == 0) {
872 hbqe = (struct lpfc_hbq_entry *)
873 &iocbq->iocb.un.ulpWord[0];
874 size = hbqe->bde.tus.f.bdeSize;
875 dmabuf = bdeBuf1;
876 } else if (i == 1) {
877 hbqe = (struct lpfc_hbq_entry *)
878 &iocbq->iocb.unsli3.
879 sli3Words[4];
880 size = hbqe->bde.tus.f.bdeSize;
881 dmabuf = bdeBuf2;
882 }
883 if ((offset + size) > evt_dat->len)
884 size = evt_dat->len - offset;
885 } else {
886 size = iocbq->iocb.un.cont64[i].
887 tus.f.bdeSize;
888 bde = &iocbq->iocb.un.cont64[i];
889 dma_addr = getPaddr(bde->addrHigh,
890 bde->addrLow);
891 dmabuf = lpfc_sli_ringpostbuf_get(phba,
892 pring, dma_addr);
893 }
894 if (!dmabuf) {
895 lpfc_printf_log(phba, KERN_ERR,
896 LOG_LIBDFC, "2616 No dmabuf "
897 "found for iocbq 0x%p\n",
898 iocbq);
899 kfree(evt_dat->data);
900 kfree(evt_dat);
901 spin_lock_irqsave(&phba->ct_ev_lock,
902 flags);
903 lpfc_bsg_event_unref(evt);
904 spin_unlock_irqrestore(
905 &phba->ct_ev_lock, flags);
906 goto error_ct_unsol_exit;
907 }
908 memcpy((char *)(evt_dat->data) + offset,
909 dmabuf->virt, size);
910 offset += size;
911 if (evt_req_id != SLI_CT_ELX_LOOPBACK &&
912 !(phba->sli3_options &
913 LPFC_SLI3_HBQ_ENABLED)) {
914 lpfc_sli_ringpostbuf_put(phba, pring,
915 dmabuf);
916 } else {
917 switch (cmd) {
918 case ELX_LOOPBACK_DATA:
919 if (phba->sli_rev <
920 LPFC_SLI_REV4)
921 diag_cmd_data_free(phba,
922 (struct lpfc_dmabufext
923 *)dmabuf);
924 break;
925 case ELX_LOOPBACK_XRI_SETUP:
926 if ((phba->sli_rev ==
927 LPFC_SLI_REV2) ||
928 (phba->sli3_options &
929 LPFC_SLI3_HBQ_ENABLED
930 )) {
931 lpfc_in_buf_free(phba,
932 dmabuf);
933 } else {
934 lpfc_post_buffer(phba,
935 pring,
936 1);
937 }
938 break;
939 default:
940 if (!(phba->sli3_options &
941 LPFC_SLI3_HBQ_ENABLED))
942 lpfc_post_buffer(phba,
943 pring,
944 1);
945 break;
946 }
947 }
948 }
949 }
950
951 spin_lock_irqsave(&phba->ct_ev_lock, flags);
952 if (phba->sli_rev == LPFC_SLI_REV4) {
953 evt_dat->immed_dat = phba->ctx_idx;
954 phba->ctx_idx = (phba->ctx_idx + 1) % 64;
955 /* Provide warning for over-run of the ct_ctx array */
956 if (phba->ct_ctx[evt_dat->immed_dat].flags &
957 UNSOL_VALID)
958 lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
959 "2717 CT context array entry "
960 "[%d] over-run: oxid:x%x, "
961 "sid:x%x\n", phba->ctx_idx,
962 phba->ct_ctx[
963 evt_dat->immed_dat].oxid,
964 phba->ct_ctx[
965 evt_dat->immed_dat].SID);
966 phba->ct_ctx[evt_dat->immed_dat].rxid =
967 piocbq->iocb.ulpContext;
968 phba->ct_ctx[evt_dat->immed_dat].oxid =
969 piocbq->iocb.unsli3.rcvsli3.ox_id;
970 phba->ct_ctx[evt_dat->immed_dat].SID =
971 piocbq->iocb.un.rcvels.remoteID;
972 phba->ct_ctx[evt_dat->immed_dat].flags = UNSOL_VALID;
973 } else
974 evt_dat->immed_dat = piocbq->iocb.ulpContext;
975
976 evt_dat->type = FC_REG_CT_EVENT;
977 list_add(&evt_dat->node, &evt->events_to_see);
978 if (evt_req_id == SLI_CT_ELX_LOOPBACK) {
979 wake_up_interruptible(&evt->wq);
980 lpfc_bsg_event_unref(evt);
981 break;
982 }
983
984 list_move(evt->events_to_see.prev, &evt->events_to_get);
985 lpfc_bsg_event_unref(evt);
986
987 job = evt->set_job;
988 evt->set_job = NULL;
989 if (job) {
990 job->reply->reply_payload_rcv_len = size;
991 /* make error code available to userspace */
992 job->reply->result = 0;
993 job->dd_data = NULL;
994 /* complete the job back to userspace */
995 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
996 job->job_done(job);
997 spin_lock_irqsave(&phba->ct_ev_lock, flags);
998 }
999 }
1000 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1001
1002 error_ct_unsol_exit:
1003 if (!list_empty(&head))
1004 list_del(&head);
1005 if ((phba->sli_rev < LPFC_SLI_REV4) &&
1006 (evt_req_id == SLI_CT_ELX_LOOPBACK))
1007 return 0;
1008 return 1;
1009 }
1010
1011 /**
1012 * lpfc_bsg_hba_set_event - process a SET_EVENT bsg vendor command
1013 * @job: SET_EVENT fc_bsg_job
1014 **/
1015 static int
1016 lpfc_bsg_hba_set_event(struct fc_bsg_job *job)
1017 {
1018 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
1019 struct lpfc_hba *phba = vport->phba;
1020 struct set_ct_event *event_req;
1021 struct lpfc_bsg_event *evt;
1022 int rc = 0;
1023 struct bsg_job_data *dd_data = NULL;
1024 uint32_t ev_mask;
1025 unsigned long flags;
1026
1027 if (job->request_len <
1028 sizeof(struct fc_bsg_request) + sizeof(struct set_ct_event)) {
1029 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1030 "2612 Received SET_CT_EVENT below minimum "
1031 "size\n");
1032 rc = -EINVAL;
1033 goto job_error;
1034 }
1035
1036 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
1037 if (dd_data == NULL) {
1038 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1039 "2734 Failed allocation of dd_data\n");
1040 rc = -ENOMEM;
1041 goto job_error;
1042 }
1043
1044 event_req = (struct set_ct_event *)
1045 job->request->rqst_data.h_vendor.vendor_cmd;
1046 ev_mask = ((uint32_t)(unsigned long)event_req->type_mask &
1047 FC_REG_EVENT_MASK);
1048 spin_lock_irqsave(&phba->ct_ev_lock, flags);
1049 list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
1050 if (evt->reg_id == event_req->ev_reg_id) {
1051 lpfc_bsg_event_ref(evt);
1052 evt->wait_time_stamp = jiffies;
1053 break;
1054 }
1055 }
1056 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1057
1058 if (&evt->node == &phba->ct_ev_waiters) {
1059 /* no event waiting struct yet - first call */
1060 evt = lpfc_bsg_event_new(ev_mask, event_req->ev_reg_id,
1061 event_req->ev_req_id);
1062 if (!evt) {
1063 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1064 "2617 Failed allocation of event "
1065 "waiter\n");
1066 rc = -ENOMEM;
1067 goto job_error;
1068 }
1069
1070 spin_lock_irqsave(&phba->ct_ev_lock, flags);
1071 list_add(&evt->node, &phba->ct_ev_waiters);
1072 lpfc_bsg_event_ref(evt);
1073 evt->wait_time_stamp = jiffies;
1074 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1075 }
1076
1077 spin_lock_irqsave(&phba->ct_ev_lock, flags);
1078 evt->waiting = 1;
1079 dd_data->type = TYPE_EVT;
1080 dd_data->context_un.evt = evt;
1081 evt->set_job = job; /* for unsolicited command */
1082 job->dd_data = dd_data; /* for fc transport timeout callback*/
1083 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1084 return 0; /* call job done later */
1085
1086 job_error:
1087 if (dd_data != NULL)
1088 kfree(dd_data);
1089
1090 job->dd_data = NULL;
1091 return rc;
1092 }
1093
1094 /**
1095 * lpfc_bsg_hba_get_event - process a GET_EVENT bsg vendor command
1096 * @job: GET_EVENT fc_bsg_job
1097 **/
1098 static int
1099 lpfc_bsg_hba_get_event(struct fc_bsg_job *job)
1100 {
1101 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
1102 struct lpfc_hba *phba = vport->phba;
1103 struct get_ct_event *event_req;
1104 struct get_ct_event_reply *event_reply;
1105 struct lpfc_bsg_event *evt;
1106 struct event_data *evt_dat = NULL;
1107 unsigned long flags;
1108 uint32_t rc = 0;
1109
1110 if (job->request_len <
1111 sizeof(struct fc_bsg_request) + sizeof(struct get_ct_event)) {
1112 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1113 "2613 Received GET_CT_EVENT request below "
1114 "minimum size\n");
1115 rc = -EINVAL;
1116 goto job_error;
1117 }
1118
1119 event_req = (struct get_ct_event *)
1120 job->request->rqst_data.h_vendor.vendor_cmd;
1121
1122 event_reply = (struct get_ct_event_reply *)
1123 job->reply->reply_data.vendor_reply.vendor_rsp;
1124 spin_lock_irqsave(&phba->ct_ev_lock, flags);
1125 list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
1126 if (evt->reg_id == event_req->ev_reg_id) {
1127 if (list_empty(&evt->events_to_get))
1128 break;
1129 lpfc_bsg_event_ref(evt);
1130 evt->wait_time_stamp = jiffies;
1131 evt_dat = list_entry(evt->events_to_get.prev,
1132 struct event_data, node);
1133 list_del(&evt_dat->node);
1134 break;
1135 }
1136 }
1137 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1138
1139 /* The app may continue to ask for event data until it gets
1140 * an error indicating that there isn't anymore
1141 */
1142 if (evt_dat == NULL) {
1143 job->reply->reply_payload_rcv_len = 0;
1144 rc = -ENOENT;
1145 goto job_error;
1146 }
1147
1148 if (evt_dat->len > job->request_payload.payload_len) {
1149 evt_dat->len = job->request_payload.payload_len;
1150 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1151 "2618 Truncated event data at %d "
1152 "bytes\n",
1153 job->request_payload.payload_len);
1154 }
1155
1156 event_reply->type = evt_dat->type;
1157 event_reply->immed_data = evt_dat->immed_dat;
1158 if (evt_dat->len > 0)
1159 job->reply->reply_payload_rcv_len =
1160 sg_copy_from_buffer(job->request_payload.sg_list,
1161 job->request_payload.sg_cnt,
1162 evt_dat->data, evt_dat->len);
1163 else
1164 job->reply->reply_payload_rcv_len = 0;
1165
1166 if (evt_dat) {
1167 kfree(evt_dat->data);
1168 kfree(evt_dat);
1169 }
1170
1171 spin_lock_irqsave(&phba->ct_ev_lock, flags);
1172 lpfc_bsg_event_unref(evt);
1173 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1174 job->dd_data = NULL;
1175 job->reply->result = 0;
1176 job->job_done(job);
1177 return 0;
1178
1179 job_error:
1180 job->dd_data = NULL;
1181 job->reply->result = rc;
1182 return rc;
1183 }
1184
1185 /**
1186 * lpfc_issue_ct_rsp_cmp - lpfc_issue_ct_rsp's completion handler
1187 * @phba: Pointer to HBA context object.
1188 * @cmdiocbq: Pointer to command iocb.
1189 * @rspiocbq: Pointer to response iocb.
1190 *
1191 * This function is the completion handler for iocbs issued using
1192 * lpfc_issue_ct_rsp_cmp function. This function is called by the
1193 * ring event handler function without any lock held. This function
1194 * can be called from both worker thread context and interrupt
1195 * context. This function also can be called from other thread which
1196 * cleans up the SLI layer objects.
1197 * This function copy the contents of the response iocb to the
1198 * response iocb memory object provided by the caller of
1199 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
1200 * sleeps for the iocb completion.
1201 **/
1202 static void
1203 lpfc_issue_ct_rsp_cmp(struct lpfc_hba *phba,
1204 struct lpfc_iocbq *cmdiocbq,
1205 struct lpfc_iocbq *rspiocbq)
1206 {
1207 struct bsg_job_data *dd_data;
1208 struct fc_bsg_job *job;
1209 IOCB_t *rsp;
1210 struct lpfc_dmabuf *bmp;
1211 struct lpfc_nodelist *ndlp;
1212 unsigned long flags;
1213 int rc = 0;
1214
1215 spin_lock_irqsave(&phba->ct_ev_lock, flags);
1216 dd_data = cmdiocbq->context2;
1217 /* normal completion and timeout crossed paths, already done */
1218 if (!dd_data) {
1219 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1220 return;
1221 }
1222
1223 job = dd_data->context_un.iocb.set_job;
1224 bmp = dd_data->context_un.iocb.bmp;
1225 rsp = &rspiocbq->iocb;
1226 ndlp = dd_data->context_un.iocb.ndlp;
1227
1228 pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
1229 job->request_payload.sg_cnt, DMA_TO_DEVICE);
1230
1231 if (rsp->ulpStatus) {
1232 if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
1233 switch (rsp->un.ulpWord[4] & 0xff) {
1234 case IOERR_SEQUENCE_TIMEOUT:
1235 rc = -ETIMEDOUT;
1236 break;
1237 case IOERR_INVALID_RPI:
1238 rc = -EFAULT;
1239 break;
1240 default:
1241 rc = -EACCES;
1242 break;
1243 }
1244 } else
1245 rc = -EACCES;
1246 } else
1247 job->reply->reply_payload_rcv_len =
1248 rsp->un.genreq64.bdl.bdeSize;
1249
1250 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1251 lpfc_sli_release_iocbq(phba, cmdiocbq);
1252 lpfc_nlp_put(ndlp);
1253 kfree(bmp);
1254 kfree(dd_data);
1255 /* make error code available to userspace */
1256 job->reply->result = rc;
1257 job->dd_data = NULL;
1258 /* complete the job back to userspace */
1259 job->job_done(job);
1260 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
1261 return;
1262 }
1263
1264 /**
1265 * lpfc_issue_ct_rsp - issue a ct response
1266 * @phba: Pointer to HBA context object.
1267 * @job: Pointer to the job object.
1268 * @tag: tag index value into the ports context exchange array.
1269 * @bmp: Pointer to a dma buffer descriptor.
1270 * @num_entry: Number of enties in the bde.
1271 **/
1272 static int
1273 lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
1274 struct lpfc_dmabuf *bmp, int num_entry)
1275 {
1276 IOCB_t *icmd;
1277 struct lpfc_iocbq *ctiocb = NULL;
1278 int rc = 0;
1279 struct lpfc_nodelist *ndlp = NULL;
1280 struct bsg_job_data *dd_data;
1281 uint32_t creg_val;
1282
1283 /* allocate our bsg tracking structure */
1284 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
1285 if (!dd_data) {
1286 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1287 "2736 Failed allocation of dd_data\n");
1288 rc = -ENOMEM;
1289 goto no_dd_data;
1290 }
1291
1292 /* Allocate buffer for command iocb */
1293 ctiocb = lpfc_sli_get_iocbq(phba);
1294 if (!ctiocb) {
1295 rc = -ENOMEM;
1296 goto no_ctiocb;
1297 }
1298
1299 icmd = &ctiocb->iocb;
1300 icmd->un.xseq64.bdl.ulpIoTag32 = 0;
1301 icmd->un.xseq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
1302 icmd->un.xseq64.bdl.addrLow = putPaddrLow(bmp->phys);
1303 icmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
1304 icmd->un.xseq64.bdl.bdeSize = (num_entry * sizeof(struct ulp_bde64));
1305 icmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
1306 icmd->un.xseq64.w5.hcsw.Dfctl = 0;
1307 icmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_SOL_CTL;
1308 icmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
1309
1310 /* Fill in rest of iocb */
1311 icmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
1312 icmd->ulpBdeCount = 1;
1313 icmd->ulpLe = 1;
1314 icmd->ulpClass = CLASS3;
1315 if (phba->sli_rev == LPFC_SLI_REV4) {
1316 /* Do not issue unsol response if oxid not marked as valid */
1317 if (!(phba->ct_ctx[tag].flags & UNSOL_VALID)) {
1318 rc = IOCB_ERROR;
1319 goto issue_ct_rsp_exit;
1320 }
1321 icmd->ulpContext = phba->ct_ctx[tag].rxid;
1322 icmd->unsli3.rcvsli3.ox_id = phba->ct_ctx[tag].oxid;
1323 ndlp = lpfc_findnode_did(phba->pport, phba->ct_ctx[tag].SID);
1324 if (!ndlp) {
1325 lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
1326 "2721 ndlp null for oxid %x SID %x\n",
1327 icmd->ulpContext,
1328 phba->ct_ctx[tag].SID);
1329 rc = IOCB_ERROR;
1330 goto issue_ct_rsp_exit;
1331 }
1332
1333 /* Check if the ndlp is active */
1334 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
1335 rc = -IOCB_ERROR;
1336 goto issue_ct_rsp_exit;
1337 }
1338
1339 /* get a refernece count so the ndlp doesn't go away while
1340 * we respond
1341 */
1342 if (!lpfc_nlp_get(ndlp)) {
1343 rc = -IOCB_ERROR;
1344 goto issue_ct_rsp_exit;
1345 }
1346
1347 icmd->un.ulpWord[3] =
1348 phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
1349
1350 /* The exchange is done, mark the entry as invalid */
1351 phba->ct_ctx[tag].flags &= ~UNSOL_VALID;
1352 } else
1353 icmd->ulpContext = (ushort) tag;
1354
1355 icmd->ulpTimeout = phba->fc_ratov * 2;
1356
1357 /* Xmit CT response on exchange <xid> */
1358 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1359 "2722 Xmit CT response on exchange x%x Data: x%x x%x x%x\n",
1360 icmd->ulpContext, icmd->ulpIoTag, tag, phba->link_state);
1361
1362 ctiocb->iocb_cmpl = NULL;
1363 ctiocb->iocb_flag |= LPFC_IO_LIBDFC;
1364 ctiocb->vport = phba->pport;
1365 ctiocb->context3 = bmp;
1366
1367 ctiocb->iocb_cmpl = lpfc_issue_ct_rsp_cmp;
1368 ctiocb->context2 = dd_data;
1369 ctiocb->context1 = ndlp;
1370 dd_data->type = TYPE_IOCB;
1371 dd_data->context_un.iocb.cmdiocbq = ctiocb;
1372 dd_data->context_un.iocb.rspiocbq = NULL;
1373 dd_data->context_un.iocb.set_job = job;
1374 dd_data->context_un.iocb.bmp = bmp;
1375 dd_data->context_un.iocb.ndlp = ndlp;
1376
1377 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
1378 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1379 rc = -IOCB_ERROR;
1380 goto issue_ct_rsp_exit;
1381 }
1382 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
1383 writel(creg_val, phba->HCregaddr);
1384 readl(phba->HCregaddr); /* flush */
1385 }
1386
1387 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, ctiocb, 0);
1388
1389 if (rc == IOCB_SUCCESS)
1390 return 0; /* done for now */
1391
1392 issue_ct_rsp_exit:
1393 lpfc_sli_release_iocbq(phba, ctiocb);
1394 no_ctiocb:
1395 kfree(dd_data);
1396 no_dd_data:
1397 return rc;
1398 }
1399
1400 /**
1401 * lpfc_bsg_send_mgmt_rsp - process a SEND_MGMT_RESP bsg vendor command
1402 * @job: SEND_MGMT_RESP fc_bsg_job
1403 **/
1404 static int
1405 lpfc_bsg_send_mgmt_rsp(struct fc_bsg_job *job)
1406 {
1407 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
1408 struct lpfc_hba *phba = vport->phba;
1409 struct send_mgmt_resp *mgmt_resp = (struct send_mgmt_resp *)
1410 job->request->rqst_data.h_vendor.vendor_cmd;
1411 struct ulp_bde64 *bpl;
1412 struct lpfc_dmabuf *bmp = NULL;
1413 struct scatterlist *sgel = NULL;
1414 int request_nseg;
1415 int numbde;
1416 dma_addr_t busaddr;
1417 uint32_t tag = mgmt_resp->tag;
1418 unsigned long reqbfrcnt =
1419 (unsigned long)job->request_payload.payload_len;
1420 int rc = 0;
1421
1422 /* in case no data is transferred */
1423 job->reply->reply_payload_rcv_len = 0;
1424
1425 if (!reqbfrcnt || (reqbfrcnt > (80 * BUF_SZ_4K))) {
1426 rc = -ERANGE;
1427 goto send_mgmt_rsp_exit;
1428 }
1429
1430 bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1431 if (!bmp) {
1432 rc = -ENOMEM;
1433 goto send_mgmt_rsp_exit;
1434 }
1435
1436 bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
1437 if (!bmp->virt) {
1438 rc = -ENOMEM;
1439 goto send_mgmt_rsp_free_bmp;
1440 }
1441
1442 INIT_LIST_HEAD(&bmp->list);
1443 bpl = (struct ulp_bde64 *) bmp->virt;
1444 request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
1445 job->request_payload.sg_cnt, DMA_TO_DEVICE);
1446 for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
1447 busaddr = sg_dma_address(sgel);
1448 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1449 bpl->tus.f.bdeSize = sg_dma_len(sgel);
1450 bpl->tus.w = cpu_to_le32(bpl->tus.w);
1451 bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
1452 bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
1453 bpl++;
1454 }
1455
1456 rc = lpfc_issue_ct_rsp(phba, job, tag, bmp, request_nseg);
1457
1458 if (rc == IOCB_SUCCESS)
1459 return 0; /* done for now */
1460
1461 /* TBD need to handle a timeout */
1462 pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
1463 job->request_payload.sg_cnt, DMA_TO_DEVICE);
1464 rc = -EACCES;
1465 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1466
1467 send_mgmt_rsp_free_bmp:
1468 kfree(bmp);
1469 send_mgmt_rsp_exit:
1470 /* make error code available to userspace */
1471 job->reply->result = rc;
1472 job->dd_data = NULL;
1473 return rc;
1474 }
1475
1476 /**
1477 * lpfc_bsg_diag_mode_enter - process preparing into device diag loopback mode
1478 * @phba: Pointer to HBA context object.
1479 *
1480 * This function is responsible for preparing driver for diag loopback
1481 * on device.
1482 */
1483 static int
1484 lpfc_bsg_diag_mode_enter(struct lpfc_hba *phba)
1485 {
1486 struct lpfc_vport **vports;
1487 struct Scsi_Host *shost;
1488 struct lpfc_sli *psli;
1489 struct lpfc_sli_ring *pring;
1490 int i = 0;
1491
1492 psli = &phba->sli;
1493 if (!psli)
1494 return -ENODEV;
1495
1496 pring = &psli->ring[LPFC_FCP_RING];
1497 if (!pring)
1498 return -ENODEV;
1499
1500 if ((phba->link_state == LPFC_HBA_ERROR) ||
1501 (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
1502 (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
1503 return -EACCES;
1504
1505 vports = lpfc_create_vport_work_array(phba);
1506 if (vports) {
1507 for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1508 shost = lpfc_shost_from_vport(vports[i]);
1509 scsi_block_requests(shost);
1510 }
1511 lpfc_destroy_vport_work_array(phba, vports);
1512 } else {
1513 shost = lpfc_shost_from_vport(phba->pport);
1514 scsi_block_requests(shost);
1515 }
1516
1517 while (pring->txcmplq_cnt) {
1518 if (i++ > 500) /* wait up to 5 seconds */
1519 break;
1520 msleep(10);
1521 }
1522 return 0;
1523 }
1524
1525 /**
1526 * lpfc_bsg_diag_mode_exit - exit process from device diag loopback mode
1527 * @phba: Pointer to HBA context object.
1528 *
1529 * This function is responsible for driver exit processing of setting up
1530 * diag loopback mode on device.
1531 */
1532 static void
1533 lpfc_bsg_diag_mode_exit(struct lpfc_hba *phba)
1534 {
1535 struct Scsi_Host *shost;
1536 struct lpfc_vport **vports;
1537 int i;
1538
1539 vports = lpfc_create_vport_work_array(phba);
1540 if (vports) {
1541 for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1542 shost = lpfc_shost_from_vport(vports[i]);
1543 scsi_unblock_requests(shost);
1544 }
1545 lpfc_destroy_vport_work_array(phba, vports);
1546 } else {
1547 shost = lpfc_shost_from_vport(phba->pport);
1548 scsi_unblock_requests(shost);
1549 }
1550 return;
1551 }
1552
1553 /**
1554 * lpfc_sli3_bsg_diag_loopback_mode - process an sli3 bsg vendor command
1555 * @phba: Pointer to HBA context object.
1556 * @job: LPFC_BSG_VENDOR_DIAG_MODE
1557 *
1558 * This function is responsible for placing an sli3 port into diagnostic
1559 * loopback mode in order to perform a diagnostic loopback test.
1560 * All new scsi requests are blocked, a small delay is used to allow the
1561 * scsi requests to complete then the link is brought down. If the link is
1562 * is placed in loopback mode then scsi requests are again allowed
1563 * so the scsi mid-layer doesn't give up on the port.
1564 * All of this is done in-line.
1565 */
1566 static int
1567 lpfc_sli3_bsg_diag_loopback_mode(struct lpfc_hba *phba, struct fc_bsg_job *job)
1568 {
1569 struct diag_mode_set *loopback_mode;
1570 uint32_t link_flags;
1571 uint32_t timeout;
1572 LPFC_MBOXQ_t *pmboxq = NULL;
1573 int mbxstatus = MBX_SUCCESS;
1574 int i = 0;
1575 int rc = 0;
1576
1577 /* no data to return just the return code */
1578 job->reply->reply_payload_rcv_len = 0;
1579
1580 if (job->request_len < sizeof(struct fc_bsg_request) +
1581 sizeof(struct diag_mode_set)) {
1582 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1583 "2738 Received DIAG MODE request size:%d "
1584 "below the minimum size:%d\n",
1585 job->request_len,
1586 (int)(sizeof(struct fc_bsg_request) +
1587 sizeof(struct diag_mode_set)));
1588 rc = -EINVAL;
1589 goto job_error;
1590 }
1591
1592 rc = lpfc_bsg_diag_mode_enter(phba);
1593 if (rc)
1594 goto job_error;
1595
1596 /* bring the link to diagnostic mode */
1597 loopback_mode = (struct diag_mode_set *)
1598 job->request->rqst_data.h_vendor.vendor_cmd;
1599 link_flags = loopback_mode->type;
1600 timeout = loopback_mode->timeout * 100;
1601
1602 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1603 if (!pmboxq) {
1604 rc = -ENOMEM;
1605 goto loopback_mode_exit;
1606 }
1607 memset((void *)pmboxq, 0, sizeof(LPFC_MBOXQ_t));
1608 pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
1609 pmboxq->u.mb.mbxOwner = OWN_HOST;
1610
1611 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
1612
1613 if ((mbxstatus == MBX_SUCCESS) && (pmboxq->u.mb.mbxStatus == 0)) {
1614 /* wait for link down before proceeding */
1615 i = 0;
1616 while (phba->link_state != LPFC_LINK_DOWN) {
1617 if (i++ > timeout) {
1618 rc = -ETIMEDOUT;
1619 goto loopback_mode_exit;
1620 }
1621 msleep(10);
1622 }
1623
1624 memset((void *)pmboxq, 0, sizeof(LPFC_MBOXQ_t));
1625 if (link_flags == INTERNAL_LOOP_BACK)
1626 pmboxq->u.mb.un.varInitLnk.link_flags = FLAGS_LOCAL_LB;
1627 else
1628 pmboxq->u.mb.un.varInitLnk.link_flags =
1629 FLAGS_TOPOLOGY_MODE_LOOP;
1630
1631 pmboxq->u.mb.mbxCommand = MBX_INIT_LINK;
1632 pmboxq->u.mb.mbxOwner = OWN_HOST;
1633
1634 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
1635 LPFC_MBOX_TMO);
1636
1637 if ((mbxstatus != MBX_SUCCESS) || (pmboxq->u.mb.mbxStatus))
1638 rc = -ENODEV;
1639 else {
1640 spin_lock_irq(&phba->hbalock);
1641 phba->link_flag |= LS_LOOPBACK_MODE;
1642 spin_unlock_irq(&phba->hbalock);
1643 /* wait for the link attention interrupt */
1644 msleep(100);
1645
1646 i = 0;
1647 while (phba->link_state != LPFC_HBA_READY) {
1648 if (i++ > timeout) {
1649 rc = -ETIMEDOUT;
1650 break;
1651 }
1652
1653 msleep(10);
1654 }
1655 }
1656
1657 } else
1658 rc = -ENODEV;
1659
1660 loopback_mode_exit:
1661 lpfc_bsg_diag_mode_exit(phba);
1662
1663 /*
1664 * Let SLI layer release mboxq if mbox command completed after timeout.
1665 */
1666 if (pmboxq && mbxstatus != MBX_TIMEOUT)
1667 mempool_free(pmboxq, phba->mbox_mem_pool);
1668
1669 job_error:
1670 /* make error code available to userspace */
1671 job->reply->result = rc;
1672 /* complete the job back to userspace if no error */
1673 if (rc == 0)
1674 job->job_done(job);
1675 return rc;
1676 }
1677
1678 /**
1679 * lpfc_sli4_bsg_set_link_diag_state - set sli4 link diag state
1680 * @phba: Pointer to HBA context object.
1681 * @diag: Flag for set link to diag or nomral operation state.
1682 *
1683 * This function is responsible for issuing a sli4 mailbox command for setting
1684 * link to either diag state or normal operation state.
1685 */
1686 static int
1687 lpfc_sli4_bsg_set_link_diag_state(struct lpfc_hba *phba, uint32_t diag)
1688 {
1689 LPFC_MBOXQ_t *pmboxq;
1690 struct lpfc_mbx_set_link_diag_state *link_diag_state;
1691 uint32_t req_len, alloc_len;
1692 int mbxstatus = MBX_SUCCESS, rc;
1693
1694 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1695 if (!pmboxq)
1696 return -ENOMEM;
1697
1698 req_len = (sizeof(struct lpfc_mbx_set_link_diag_state) -
1699 sizeof(struct lpfc_sli4_cfg_mhdr));
1700 alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
1701 LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE,
1702 req_len, LPFC_SLI4_MBX_EMBED);
1703 if (alloc_len != req_len) {
1704 rc = -ENOMEM;
1705 goto link_diag_state_set_out;
1706 }
1707 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
1708 "3128 Set link to diagnostic state:x%x (x%x/x%x)\n",
1709 diag, phba->sli4_hba.lnk_info.lnk_tp,
1710 phba->sli4_hba.lnk_info.lnk_no);
1711
1712 link_diag_state = &pmboxq->u.mqe.un.link_diag_state;
1713 bf_set(lpfc_mbx_set_diag_state_link_num, &link_diag_state->u.req,
1714 phba->sli4_hba.lnk_info.lnk_no);
1715 bf_set(lpfc_mbx_set_diag_state_link_type, &link_diag_state->u.req,
1716 phba->sli4_hba.lnk_info.lnk_tp);
1717 if (diag)
1718 bf_set(lpfc_mbx_set_diag_state_diag,
1719 &link_diag_state->u.req, 1);
1720 else
1721 bf_set(lpfc_mbx_set_diag_state_diag,
1722 &link_diag_state->u.req, 0);
1723
1724 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
1725
1726 if ((mbxstatus == MBX_SUCCESS) && (pmboxq->u.mb.mbxStatus == 0))
1727 rc = 0;
1728 else
1729 rc = -ENODEV;
1730
1731 link_diag_state_set_out:
1732 if (pmboxq && (mbxstatus != MBX_TIMEOUT))
1733 mempool_free(pmboxq, phba->mbox_mem_pool);
1734
1735 return rc;
1736 }
1737
1738 /**
1739 * lpfc_sli4_bsg_set_internal_loopback - set sli4 internal loopback diagnostic
1740 * @phba: Pointer to HBA context object.
1741 *
1742 * This function is responsible for issuing a sli4 mailbox command for setting
1743 * up internal loopback diagnostic.
1744 */
1745 static int
1746 lpfc_sli4_bsg_set_internal_loopback(struct lpfc_hba *phba)
1747 {
1748 LPFC_MBOXQ_t *pmboxq;
1749 uint32_t req_len, alloc_len;
1750 struct lpfc_mbx_set_link_diag_loopback *link_diag_loopback;
1751 int mbxstatus = MBX_SUCCESS, rc = 0;
1752
1753 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1754 if (!pmboxq)
1755 return -ENOMEM;
1756 req_len = (sizeof(struct lpfc_mbx_set_link_diag_loopback) -
1757 sizeof(struct lpfc_sli4_cfg_mhdr));
1758 alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
1759 LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_LOOPBACK,
1760 req_len, LPFC_SLI4_MBX_EMBED);
1761 if (alloc_len != req_len) {
1762 mempool_free(pmboxq, phba->mbox_mem_pool);
1763 return -ENOMEM;
1764 }
1765 link_diag_loopback = &pmboxq->u.mqe.un.link_diag_loopback;
1766 bf_set(lpfc_mbx_set_diag_state_link_num,
1767 &link_diag_loopback->u.req, phba->sli4_hba.lnk_info.lnk_no);
1768 bf_set(lpfc_mbx_set_diag_state_link_type,
1769 &link_diag_loopback->u.req, phba->sli4_hba.lnk_info.lnk_tp);
1770 bf_set(lpfc_mbx_set_diag_lpbk_type, &link_diag_loopback->u.req,
1771 LPFC_DIAG_LOOPBACK_TYPE_SERDES);
1772
1773 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
1774 if ((mbxstatus != MBX_SUCCESS) || (pmboxq->u.mb.mbxStatus)) {
1775 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1776 "3127 Failed setup loopback mode mailbox "
1777 "command, rc:x%x, status:x%x\n", mbxstatus,
1778 pmboxq->u.mb.mbxStatus);
1779 rc = -ENODEV;
1780 }
1781 if (pmboxq && (mbxstatus != MBX_TIMEOUT))
1782 mempool_free(pmboxq, phba->mbox_mem_pool);
1783 return rc;
1784 }
1785
1786 /**
1787 * lpfc_sli4_diag_fcport_reg_setup - setup port registrations for diagnostic
1788 * @phba: Pointer to HBA context object.
1789 *
1790 * This function set up SLI4 FC port registrations for diagnostic run, which
1791 * includes all the rpis, vfi, and also vpi.
1792 */
1793 static int
1794 lpfc_sli4_diag_fcport_reg_setup(struct lpfc_hba *phba)
1795 {
1796 int rc;
1797
1798 if (phba->pport->fc_flag & FC_VFI_REGISTERED) {
1799 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1800 "3136 Port still had vfi registered: "
1801 "mydid:x%x, fcfi:%d, vfi:%d, vpi:%d\n",
1802 phba->pport->fc_myDID, phba->fcf.fcfi,
1803 phba->sli4_hba.vfi_ids[phba->pport->vfi],
1804 phba->vpi_ids[phba->pport->vpi]);
1805 return -EINVAL;
1806 }
1807 rc = lpfc_issue_reg_vfi(phba->pport);
1808 return rc;
1809 }
1810
1811 /**
1812 * lpfc_sli4_bsg_diag_loopback_mode - process an sli4 bsg vendor command
1813 * @phba: Pointer to HBA context object.
1814 * @job: LPFC_BSG_VENDOR_DIAG_MODE
1815 *
1816 * This function is responsible for placing an sli4 port into diagnostic
1817 * loopback mode in order to perform a diagnostic loopback test.
1818 */
1819 static int
1820 lpfc_sli4_bsg_diag_loopback_mode(struct lpfc_hba *phba, struct fc_bsg_job *job)
1821 {
1822 struct diag_mode_set *loopback_mode;
1823 uint32_t link_flags, timeout;
1824 int i, rc = 0;
1825
1826 /* no data to return just the return code */
1827 job->reply->reply_payload_rcv_len = 0;
1828
1829 if (job->request_len < sizeof(struct fc_bsg_request) +
1830 sizeof(struct diag_mode_set)) {
1831 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1832 "3011 Received DIAG MODE request size:%d "
1833 "below the minimum size:%d\n",
1834 job->request_len,
1835 (int)(sizeof(struct fc_bsg_request) +
1836 sizeof(struct diag_mode_set)));
1837 rc = -EINVAL;
1838 goto job_error;
1839 }
1840
1841 rc = lpfc_bsg_diag_mode_enter(phba);
1842 if (rc)
1843 goto job_error;
1844
1845 /* indicate we are in loobpack diagnostic mode */
1846 spin_lock_irq(&phba->hbalock);
1847 phba->link_flag |= LS_LOOPBACK_MODE;
1848 spin_unlock_irq(&phba->hbalock);
1849
1850 /* reset port to start frome scratch */
1851 rc = lpfc_selective_reset(phba);
1852 if (rc)
1853 goto job_error;
1854
1855 /* bring the link to diagnostic mode */
1856 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
1857 "3129 Bring link to diagnostic state.\n");
1858 loopback_mode = (struct diag_mode_set *)
1859 job->request->rqst_data.h_vendor.vendor_cmd;
1860 link_flags = loopback_mode->type;
1861 timeout = loopback_mode->timeout * 100;
1862
1863 rc = lpfc_sli4_bsg_set_link_diag_state(phba, 1);
1864 if (rc) {
1865 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1866 "3130 Failed to bring link to diagnostic "
1867 "state, rc:x%x\n", rc);
1868 goto loopback_mode_exit;
1869 }
1870
1871 /* wait for link down before proceeding */
1872 i = 0;
1873 while (phba->link_state != LPFC_LINK_DOWN) {
1874 if (i++ > timeout) {
1875 rc = -ETIMEDOUT;
1876 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
1877 "3131 Timeout waiting for link to "
1878 "diagnostic mode, timeout:%d ms\n",
1879 timeout * 10);
1880 goto loopback_mode_exit;
1881 }
1882 msleep(10);
1883 }
1884
1885 /* set up loopback mode */
1886 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
1887 "3132 Set up loopback mode:x%x\n", link_flags);
1888
1889 if (link_flags == INTERNAL_LOOP_BACK)
1890 rc = lpfc_sli4_bsg_set_internal_loopback(phba);
1891 else if (link_flags == EXTERNAL_LOOP_BACK)
1892 rc = lpfc_hba_init_link_fc_topology(phba,
1893 FLAGS_TOPOLOGY_MODE_PT_PT,
1894 MBX_NOWAIT);
1895 else {
1896 rc = -EINVAL;
1897 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
1898 "3141 Loopback mode:x%x not supported\n",
1899 link_flags);
1900 goto loopback_mode_exit;
1901 }
1902
1903 if (!rc) {
1904 /* wait for the link attention interrupt */
1905 msleep(100);
1906 i = 0;
1907 while (phba->link_state < LPFC_LINK_UP) {
1908 if (i++ > timeout) {
1909 rc = -ETIMEDOUT;
1910 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
1911 "3137 Timeout waiting for link up "
1912 "in loopback mode, timeout:%d ms\n",
1913 timeout * 10);
1914 break;
1915 }
1916 msleep(10);
1917 }
1918 }
1919
1920 /* port resource registration setup for loopback diagnostic */
1921 if (!rc) {
1922 /* set up a none zero myDID for loopback test */
1923 phba->pport->fc_myDID = 1;
1924 rc = lpfc_sli4_diag_fcport_reg_setup(phba);
1925 } else
1926 goto loopback_mode_exit;
1927
1928 if (!rc) {
1929 /* wait for the port ready */
1930 msleep(100);
1931 i = 0;
1932 while (phba->link_state != LPFC_HBA_READY) {
1933 if (i++ > timeout) {
1934 rc = -ETIMEDOUT;
1935 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
1936 "3133 Timeout waiting for port "
1937 "loopback mode ready, timeout:%d ms\n",
1938 timeout * 10);
1939 break;
1940 }
1941 msleep(10);
1942 }
1943 }
1944
1945 loopback_mode_exit:
1946 /* clear loopback diagnostic mode */
1947 if (rc) {
1948 spin_lock_irq(&phba->hbalock);
1949 phba->link_flag &= ~LS_LOOPBACK_MODE;
1950 spin_unlock_irq(&phba->hbalock);
1951 }
1952 lpfc_bsg_diag_mode_exit(phba);
1953
1954 job_error:
1955 /* make error code available to userspace */
1956 job->reply->result = rc;
1957 /* complete the job back to userspace if no error */
1958 if (rc == 0)
1959 job->job_done(job);
1960 return rc;
1961 }
1962
1963 /**
1964 * lpfc_bsg_diag_loopback_mode - bsg vendor command for diag loopback mode
1965 * @job: LPFC_BSG_VENDOR_DIAG_MODE
1966 *
1967 * This function is responsible for responding to check and dispatch bsg diag
1968 * command from the user to proper driver action routines.
1969 */
1970 static int
1971 lpfc_bsg_diag_loopback_mode(struct fc_bsg_job *job)
1972 {
1973 struct Scsi_Host *shost;
1974 struct lpfc_vport *vport;
1975 struct lpfc_hba *phba;
1976 int rc;
1977
1978 shost = job->shost;
1979 if (!shost)
1980 return -ENODEV;
1981 vport = (struct lpfc_vport *)job->shost->hostdata;
1982 if (!vport)
1983 return -ENODEV;
1984 phba = vport->phba;
1985 if (!phba)
1986 return -ENODEV;
1987
1988 if (phba->sli_rev < LPFC_SLI_REV4)
1989 rc = lpfc_sli3_bsg_diag_loopback_mode(phba, job);
1990 else if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
1991 LPFC_SLI_INTF_IF_TYPE_2)
1992 rc = lpfc_sli4_bsg_diag_loopback_mode(phba, job);
1993 else
1994 rc = -ENODEV;
1995
1996 return rc;
1997 }
1998
1999 /**
2000 * lpfc_sli4_bsg_diag_mode_end - sli4 bsg vendor command for ending diag mode
2001 * @job: LPFC_BSG_VENDOR_DIAG_MODE_END
2002 *
2003 * This function is responsible for responding to check and dispatch bsg diag
2004 * command from the user to proper driver action routines.
2005 */
2006 static int
2007 lpfc_sli4_bsg_diag_mode_end(struct fc_bsg_job *job)
2008 {
2009 struct Scsi_Host *shost;
2010 struct lpfc_vport *vport;
2011 struct lpfc_hba *phba;
2012 struct diag_mode_set *loopback_mode_end_cmd;
2013 uint32_t timeout;
2014 int rc, i;
2015
2016 shost = job->shost;
2017 if (!shost)
2018 return -ENODEV;
2019 vport = (struct lpfc_vport *)job->shost->hostdata;
2020 if (!vport)
2021 return -ENODEV;
2022 phba = vport->phba;
2023 if (!phba)
2024 return -ENODEV;
2025
2026 if (phba->sli_rev < LPFC_SLI_REV4)
2027 return -ENODEV;
2028 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
2029 LPFC_SLI_INTF_IF_TYPE_2)
2030 return -ENODEV;
2031
2032 /* clear loopback diagnostic mode */
2033 spin_lock_irq(&phba->hbalock);
2034 phba->link_flag &= ~LS_LOOPBACK_MODE;
2035 spin_unlock_irq(&phba->hbalock);
2036 loopback_mode_end_cmd = (struct diag_mode_set *)
2037 job->request->rqst_data.h_vendor.vendor_cmd;
2038 timeout = loopback_mode_end_cmd->timeout * 100;
2039
2040 rc = lpfc_sli4_bsg_set_link_diag_state(phba, 0);
2041 if (rc) {
2042 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2043 "3139 Failed to bring link to diagnostic "
2044 "state, rc:x%x\n", rc);
2045 goto loopback_mode_end_exit;
2046 }
2047
2048 /* wait for link down before proceeding */
2049 i = 0;
2050 while (phba->link_state != LPFC_LINK_DOWN) {
2051 if (i++ > timeout) {
2052 rc = -ETIMEDOUT;
2053 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
2054 "3140 Timeout waiting for link to "
2055 "diagnostic mode_end, timeout:%d ms\n",
2056 timeout * 10);
2057 /* there is nothing much we can do here */
2058 break;
2059 }
2060 msleep(10);
2061 }
2062
2063 /* reset port resource registrations */
2064 rc = lpfc_selective_reset(phba);
2065 phba->pport->fc_myDID = 0;
2066
2067 loopback_mode_end_exit:
2068 /* make return code available to userspace */
2069 job->reply->result = rc;
2070 /* complete the job back to userspace if no error */
2071 if (rc == 0)
2072 job->job_done(job);
2073 return rc;
2074 }
2075
2076 /**
2077 * lpfc_sli4_bsg_link_diag_test - sli4 bsg vendor command for diag link test
2078 * @job: LPFC_BSG_VENDOR_DIAG_LINK_TEST
2079 *
2080 * This function is to perform SLI4 diag link test request from the user
2081 * applicaiton.
2082 */
2083 static int
2084 lpfc_sli4_bsg_link_diag_test(struct fc_bsg_job *job)
2085 {
2086 struct Scsi_Host *shost;
2087 struct lpfc_vport *vport;
2088 struct lpfc_hba *phba;
2089 LPFC_MBOXQ_t *pmboxq;
2090 struct sli4_link_diag *link_diag_test_cmd;
2091 uint32_t req_len, alloc_len;
2092 uint32_t timeout;
2093 struct lpfc_mbx_run_link_diag_test *run_link_diag_test;
2094 union lpfc_sli4_cfg_shdr *shdr;
2095 uint32_t shdr_status, shdr_add_status;
2096 struct diag_status *diag_status_reply;
2097 int mbxstatus, rc = 0;
2098
2099 shost = job->shost;
2100 if (!shost) {
2101 rc = -ENODEV;
2102 goto job_error;
2103 }
2104 vport = (struct lpfc_vport *)job->shost->hostdata;
2105 if (!vport) {
2106 rc = -ENODEV;
2107 goto job_error;
2108 }
2109 phba = vport->phba;
2110 if (!phba) {
2111 rc = -ENODEV;
2112 goto job_error;
2113 }
2114
2115 if (phba->sli_rev < LPFC_SLI_REV4) {
2116 rc = -ENODEV;
2117 goto job_error;
2118 }
2119 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
2120 LPFC_SLI_INTF_IF_TYPE_2) {
2121 rc = -ENODEV;
2122 goto job_error;
2123 }
2124
2125 if (job->request_len < sizeof(struct fc_bsg_request) +
2126 sizeof(struct sli4_link_diag)) {
2127 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2128 "3013 Received LINK DIAG TEST request "
2129 " size:%d below the minimum size:%d\n",
2130 job->request_len,
2131 (int)(sizeof(struct fc_bsg_request) +
2132 sizeof(struct sli4_link_diag)));
2133 rc = -EINVAL;
2134 goto job_error;
2135 }
2136
2137 rc = lpfc_bsg_diag_mode_enter(phba);
2138 if (rc)
2139 goto job_error;
2140
2141 link_diag_test_cmd = (struct sli4_link_diag *)
2142 job->request->rqst_data.h_vendor.vendor_cmd;
2143 timeout = link_diag_test_cmd->timeout * 100;
2144
2145 rc = lpfc_sli4_bsg_set_link_diag_state(phba, 1);
2146
2147 if (rc)
2148 goto job_error;
2149
2150 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2151 if (!pmboxq) {
2152 rc = -ENOMEM;
2153 goto link_diag_test_exit;
2154 }
2155
2156 req_len = (sizeof(struct lpfc_mbx_set_link_diag_state) -
2157 sizeof(struct lpfc_sli4_cfg_mhdr));
2158 alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
2159 LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE,
2160 req_len, LPFC_SLI4_MBX_EMBED);
2161 if (alloc_len != req_len) {
2162 rc = -ENOMEM;
2163 goto link_diag_test_exit;
2164 }
2165 run_link_diag_test = &pmboxq->u.mqe.un.link_diag_test;
2166 bf_set(lpfc_mbx_run_diag_test_link_num, &run_link_diag_test->u.req,
2167 phba->sli4_hba.lnk_info.lnk_no);
2168 bf_set(lpfc_mbx_run_diag_test_link_type, &run_link_diag_test->u.req,
2169 phba->sli4_hba.lnk_info.lnk_tp);
2170 bf_set(lpfc_mbx_run_diag_test_test_id, &run_link_diag_test->u.req,
2171 link_diag_test_cmd->test_id);
2172 bf_set(lpfc_mbx_run_diag_test_loops, &run_link_diag_test->u.req,
2173 link_diag_test_cmd->loops);
2174 bf_set(lpfc_mbx_run_diag_test_test_ver, &run_link_diag_test->u.req,
2175 link_diag_test_cmd->test_version);
2176 bf_set(lpfc_mbx_run_diag_test_err_act, &run_link_diag_test->u.req,
2177 link_diag_test_cmd->error_action);
2178
2179 mbxstatus = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
2180
2181 shdr = (union lpfc_sli4_cfg_shdr *)
2182 &pmboxq->u.mqe.un.sli4_config.header.cfg_shdr;
2183 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
2184 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
2185 if (shdr_status || shdr_add_status || mbxstatus) {
2186 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
2187 "3010 Run link diag test mailbox failed with "
2188 "mbx_status x%x status x%x, add_status x%x\n",
2189 mbxstatus, shdr_status, shdr_add_status);
2190 }
2191
2192 diag_status_reply = (struct diag_status *)
2193 job->reply->reply_data.vendor_reply.vendor_rsp;
2194
2195 if (job->reply_len <
2196 sizeof(struct fc_bsg_request) + sizeof(struct diag_status)) {
2197 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2198 "3012 Received Run link diag test reply "
2199 "below minimum size (%d): reply_len:%d\n",
2200 (int)(sizeof(struct fc_bsg_request) +
2201 sizeof(struct diag_status)),
2202 job->reply_len);
2203 rc = -EINVAL;
2204 goto job_error;
2205 }
2206
2207 diag_status_reply->mbox_status = mbxstatus;
2208 diag_status_reply->shdr_status = shdr_status;
2209 diag_status_reply->shdr_add_status = shdr_add_status;
2210
2211 link_diag_test_exit:
2212 rc = lpfc_sli4_bsg_set_link_diag_state(phba, 0);
2213
2214 if (pmboxq)
2215 mempool_free(pmboxq, phba->mbox_mem_pool);
2216
2217 lpfc_bsg_diag_mode_exit(phba);
2218
2219 job_error:
2220 /* make error code available to userspace */
2221 job->reply->result = rc;
2222 /* complete the job back to userspace if no error */
2223 if (rc == 0)
2224 job->job_done(job);
2225 return rc;
2226 }
2227
2228 /**
2229 * lpfcdiag_loop_self_reg - obtains a remote port login id
2230 * @phba: Pointer to HBA context object
2231 * @rpi: Pointer to a remote port login id
2232 *
2233 * This function obtains a remote port login id so the diag loopback test
2234 * can send and receive its own unsolicited CT command.
2235 **/
2236 static int lpfcdiag_loop_self_reg(struct lpfc_hba *phba, uint16_t *rpi)
2237 {
2238 LPFC_MBOXQ_t *mbox;
2239 struct lpfc_dmabuf *dmabuff;
2240 int status;
2241
2242 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2243 if (!mbox)
2244 return -ENOMEM;
2245
2246 if (phba->sli_rev < LPFC_SLI_REV4)
2247 status = lpfc_reg_rpi(phba, 0, phba->pport->fc_myDID,
2248 (uint8_t *)&phba->pport->fc_sparam,
2249 mbox, *rpi);
2250 else {
2251 *rpi = lpfc_sli4_alloc_rpi(phba);
2252 status = lpfc_reg_rpi(phba, phba->pport->vpi,
2253 phba->pport->fc_myDID,
2254 (uint8_t *)&phba->pport->fc_sparam,
2255 mbox, *rpi);
2256 }
2257
2258 if (status) {
2259 mempool_free(mbox, phba->mbox_mem_pool);
2260 if (phba->sli_rev == LPFC_SLI_REV4)
2261 lpfc_sli4_free_rpi(phba, *rpi);
2262 return -ENOMEM;
2263 }
2264
2265 dmabuff = (struct lpfc_dmabuf *) mbox->context1;
2266 mbox->context1 = NULL;
2267 mbox->context2 = NULL;
2268 status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
2269
2270 if ((status != MBX_SUCCESS) || (mbox->u.mb.mbxStatus)) {
2271 lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
2272 kfree(dmabuff);
2273 if (status != MBX_TIMEOUT)
2274 mempool_free(mbox, phba->mbox_mem_pool);
2275 if (phba->sli_rev == LPFC_SLI_REV4)
2276 lpfc_sli4_free_rpi(phba, *rpi);
2277 return -ENODEV;
2278 }
2279
2280 if (phba->sli_rev < LPFC_SLI_REV4)
2281 *rpi = mbox->u.mb.un.varWords[0];
2282
2283 lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
2284 kfree(dmabuff);
2285 mempool_free(mbox, phba->mbox_mem_pool);
2286 return 0;
2287 }
2288
2289 /**
2290 * lpfcdiag_loop_self_unreg - unregs from the rpi
2291 * @phba: Pointer to HBA context object
2292 * @rpi: Remote port login id
2293 *
2294 * This function unregisters the rpi obtained in lpfcdiag_loop_self_reg
2295 **/
2296 static int lpfcdiag_loop_self_unreg(struct lpfc_hba *phba, uint16_t rpi)
2297 {
2298 LPFC_MBOXQ_t *mbox;
2299 int status;
2300
2301 /* Allocate mboxq structure */
2302 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2303 if (mbox == NULL)
2304 return -ENOMEM;
2305
2306 if (phba->sli_rev < LPFC_SLI_REV4)
2307 lpfc_unreg_login(phba, 0, rpi, mbox);
2308 else
2309 lpfc_unreg_login(phba, phba->pport->vpi,
2310 phba->sli4_hba.rpi_ids[rpi], mbox);
2311
2312 status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
2313
2314 if ((status != MBX_SUCCESS) || (mbox->u.mb.mbxStatus)) {
2315 if (status != MBX_TIMEOUT)
2316 mempool_free(mbox, phba->mbox_mem_pool);
2317 return -EIO;
2318 }
2319 mempool_free(mbox, phba->mbox_mem_pool);
2320 if (phba->sli_rev == LPFC_SLI_REV4)
2321 lpfc_sli4_free_rpi(phba, rpi);
2322 return 0;
2323 }
2324
2325 /**
2326 * lpfcdiag_loop_get_xri - obtains the transmit and receive ids
2327 * @phba: Pointer to HBA context object
2328 * @rpi: Remote port login id
2329 * @txxri: Pointer to transmit exchange id
2330 * @rxxri: Pointer to response exchabge id
2331 *
2332 * This function obtains the transmit and receive ids required to send
2333 * an unsolicited ct command with a payload. A special lpfc FsType and CmdRsp
2334 * flags are used to the unsolicted response handler is able to process
2335 * the ct command sent on the same port.
2336 **/
2337 static int lpfcdiag_loop_get_xri(struct lpfc_hba *phba, uint16_t rpi,
2338 uint16_t *txxri, uint16_t * rxxri)
2339 {
2340 struct lpfc_bsg_event *evt;
2341 struct lpfc_iocbq *cmdiocbq, *rspiocbq;
2342 IOCB_t *cmd, *rsp;
2343 struct lpfc_dmabuf *dmabuf;
2344 struct ulp_bde64 *bpl = NULL;
2345 struct lpfc_sli_ct_request *ctreq = NULL;
2346 int ret_val = 0;
2347 int time_left;
2348 int iocb_stat = 0;
2349 unsigned long flags;
2350
2351 *txxri = 0;
2352 *rxxri = 0;
2353 evt = lpfc_bsg_event_new(FC_REG_CT_EVENT, current->pid,
2354 SLI_CT_ELX_LOOPBACK);
2355 if (!evt)
2356 return -ENOMEM;
2357
2358 spin_lock_irqsave(&phba->ct_ev_lock, flags);
2359 list_add(&evt->node, &phba->ct_ev_waiters);
2360 lpfc_bsg_event_ref(evt);
2361 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
2362
2363 cmdiocbq = lpfc_sli_get_iocbq(phba);
2364 rspiocbq = lpfc_sli_get_iocbq(phba);
2365
2366 dmabuf = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2367 if (dmabuf) {
2368 dmabuf->virt = lpfc_mbuf_alloc(phba, 0, &dmabuf->phys);
2369 if (dmabuf->virt) {
2370 INIT_LIST_HEAD(&dmabuf->list);
2371 bpl = (struct ulp_bde64 *) dmabuf->virt;
2372 memset(bpl, 0, sizeof(*bpl));
2373 ctreq = (struct lpfc_sli_ct_request *)(bpl + 1);
2374 bpl->addrHigh =
2375 le32_to_cpu(putPaddrHigh(dmabuf->phys +
2376 sizeof(*bpl)));
2377 bpl->addrLow =
2378 le32_to_cpu(putPaddrLow(dmabuf->phys +
2379 sizeof(*bpl)));
2380 bpl->tus.f.bdeFlags = 0;
2381 bpl->tus.f.bdeSize = ELX_LOOPBACK_HEADER_SZ;
2382 bpl->tus.w = le32_to_cpu(bpl->tus.w);
2383 }
2384 }
2385
2386 if (cmdiocbq == NULL || rspiocbq == NULL ||
2387 dmabuf == NULL || bpl == NULL || ctreq == NULL ||
2388 dmabuf->virt == NULL) {
2389 ret_val = -ENOMEM;
2390 goto err_get_xri_exit;
2391 }
2392
2393 cmd = &cmdiocbq->iocb;
2394 rsp = &rspiocbq->iocb;
2395
2396 memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
2397
2398 ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
2399 ctreq->RevisionId.bits.InId = 0;
2400 ctreq->FsType = SLI_CT_ELX_LOOPBACK;
2401 ctreq->FsSubType = 0;
2402 ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_XRI_SETUP;
2403 ctreq->CommandResponse.bits.Size = 0;
2404
2405
2406 cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(dmabuf->phys);
2407 cmd->un.xseq64.bdl.addrLow = putPaddrLow(dmabuf->phys);
2408 cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
2409 cmd->un.xseq64.bdl.bdeSize = sizeof(*bpl);
2410
2411 cmd->un.xseq64.w5.hcsw.Fctl = LA;
2412 cmd->un.xseq64.w5.hcsw.Dfctl = 0;
2413 cmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
2414 cmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
2415
2416 cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CR;
2417 cmd->ulpBdeCount = 1;
2418 cmd->ulpLe = 1;
2419 cmd->ulpClass = CLASS3;
2420 cmd->ulpContext = rpi;
2421
2422 cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
2423 cmdiocbq->vport = phba->pport;
2424
2425 iocb_stat = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq,
2426 rspiocbq,
2427 (phba->fc_ratov * 2)
2428 + LPFC_DRVR_TIMEOUT);
2429 if (iocb_stat) {
2430 ret_val = -EIO;
2431 goto err_get_xri_exit;
2432 }
2433 *txxri = rsp->ulpContext;
2434
2435 evt->waiting = 1;
2436 evt->wait_time_stamp = jiffies;
2437 time_left = wait_event_interruptible_timeout(
2438 evt->wq, !list_empty(&evt->events_to_see),
2439 ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
2440 if (list_empty(&evt->events_to_see))
2441 ret_val = (time_left) ? -EINTR : -ETIMEDOUT;
2442 else {
2443 spin_lock_irqsave(&phba->ct_ev_lock, flags);
2444 list_move(evt->events_to_see.prev, &evt->events_to_get);
2445 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
2446 *rxxri = (list_entry(evt->events_to_get.prev,
2447 typeof(struct event_data),
2448 node))->immed_dat;
2449 }
2450 evt->waiting = 0;
2451
2452 err_get_xri_exit:
2453 spin_lock_irqsave(&phba->ct_ev_lock, flags);
2454 lpfc_bsg_event_unref(evt); /* release ref */
2455 lpfc_bsg_event_unref(evt); /* delete */
2456 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
2457
2458 if (dmabuf) {
2459 if (dmabuf->virt)
2460 lpfc_mbuf_free(phba, dmabuf->virt, dmabuf->phys);
2461 kfree(dmabuf);
2462 }
2463
2464 if (cmdiocbq && (iocb_stat != IOCB_TIMEDOUT))
2465 lpfc_sli_release_iocbq(phba, cmdiocbq);
2466 if (rspiocbq)
2467 lpfc_sli_release_iocbq(phba, rspiocbq);
2468 return ret_val;
2469 }
2470
2471 /**
2472 * lpfc_bsg_dma_page_alloc - allocate a bsg mbox page sized dma buffers
2473 * @phba: Pointer to HBA context object
2474 *
2475 * This function allocates BSG_MBOX_SIZE (4KB) page size dma buffer and.
2476 * retruns the pointer to the buffer.
2477 **/
2478 static struct lpfc_dmabuf *
2479 lpfc_bsg_dma_page_alloc(struct lpfc_hba *phba)
2480 {
2481 struct lpfc_dmabuf *dmabuf;
2482 struct pci_dev *pcidev = phba->pcidev;
2483
2484 /* allocate dma buffer struct */
2485 dmabuf = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2486 if (!dmabuf)
2487 return NULL;
2488
2489 INIT_LIST_HEAD(&dmabuf->list);
2490
2491 /* now, allocate dma buffer */
2492 dmabuf->virt = dma_alloc_coherent(&pcidev->dev, BSG_MBOX_SIZE,
2493 &(dmabuf->phys), GFP_KERNEL);
2494
2495 if (!dmabuf->virt) {
2496 kfree(dmabuf);
2497 return NULL;
2498 }
2499 memset((uint8_t *)dmabuf->virt, 0, BSG_MBOX_SIZE);
2500
2501 return dmabuf;
2502 }
2503
2504 /**
2505 * lpfc_bsg_dma_page_free - free a bsg mbox page sized dma buffer
2506 * @phba: Pointer to HBA context object.
2507 * @dmabuf: Pointer to the bsg mbox page sized dma buffer descriptor.
2508 *
2509 * This routine just simply frees a dma buffer and its associated buffer
2510 * descriptor referred by @dmabuf.
2511 **/
2512 static void
2513 lpfc_bsg_dma_page_free(struct lpfc_hba *phba, struct lpfc_dmabuf *dmabuf)
2514 {
2515 struct pci_dev *pcidev = phba->pcidev;
2516
2517 if (!dmabuf)
2518 return;
2519
2520 if (dmabuf->virt)
2521 dma_free_coherent(&pcidev->dev, BSG_MBOX_SIZE,
2522 dmabuf->virt, dmabuf->phys);
2523 kfree(dmabuf);
2524 return;
2525 }
2526
2527 /**
2528 * lpfc_bsg_dma_page_list_free - free a list of bsg mbox page sized dma buffers
2529 * @phba: Pointer to HBA context object.
2530 * @dmabuf_list: Pointer to a list of bsg mbox page sized dma buffer descs.
2531 *
2532 * This routine just simply frees all dma buffers and their associated buffer
2533 * descriptors referred by @dmabuf_list.
2534 **/
2535 static void
2536 lpfc_bsg_dma_page_list_free(struct lpfc_hba *phba,
2537 struct list_head *dmabuf_list)
2538 {
2539 struct lpfc_dmabuf *dmabuf, *next_dmabuf;
2540
2541 if (list_empty(dmabuf_list))
2542 return;
2543
2544 list_for_each_entry_safe(dmabuf, next_dmabuf, dmabuf_list, list) {
2545 list_del_init(&dmabuf->list);
2546 lpfc_bsg_dma_page_free(phba, dmabuf);
2547 }
2548 return;
2549 }
2550
2551 /**
2552 * diag_cmd_data_alloc - fills in a bde struct with dma buffers
2553 * @phba: Pointer to HBA context object
2554 * @bpl: Pointer to 64 bit bde structure
2555 * @size: Number of bytes to process
2556 * @nocopydata: Flag to copy user data into the allocated buffer
2557 *
2558 * This function allocates page size buffers and populates an lpfc_dmabufext.
2559 * If allowed the user data pointed to with indataptr is copied into the kernel
2560 * memory. The chained list of page size buffers is returned.
2561 **/
2562 static struct lpfc_dmabufext *
2563 diag_cmd_data_alloc(struct lpfc_hba *phba,
2564 struct ulp_bde64 *bpl, uint32_t size,
2565 int nocopydata)
2566 {
2567 struct lpfc_dmabufext *mlist = NULL;
2568 struct lpfc_dmabufext *dmp;
2569 int cnt, offset = 0, i = 0;
2570 struct pci_dev *pcidev;
2571
2572 pcidev = phba->pcidev;
2573
2574 while (size) {
2575 /* We get chunks of 4K */
2576 if (size > BUF_SZ_4K)
2577 cnt = BUF_SZ_4K;
2578 else
2579 cnt = size;
2580
2581 /* allocate struct lpfc_dmabufext buffer header */
2582 dmp = kmalloc(sizeof(struct lpfc_dmabufext), GFP_KERNEL);
2583 if (!dmp)
2584 goto out;
2585
2586 INIT_LIST_HEAD(&dmp->dma.list);
2587
2588 /* Queue it to a linked list */
2589 if (mlist)
2590 list_add_tail(&dmp->dma.list, &mlist->dma.list);
2591 else
2592 mlist = dmp;
2593
2594 /* allocate buffer */
2595 dmp->dma.virt = dma_alloc_coherent(&pcidev->dev,
2596 cnt,
2597 &(dmp->dma.phys),
2598 GFP_KERNEL);
2599
2600 if (!dmp->dma.virt)
2601 goto out;
2602
2603 dmp->size = cnt;
2604
2605 if (nocopydata) {
2606 bpl->tus.f.bdeFlags = 0;
2607 pci_dma_sync_single_for_device(phba->pcidev,
2608 dmp->dma.phys, LPFC_BPL_SIZE, PCI_DMA_TODEVICE);
2609
2610 } else {
2611 memset((uint8_t *)dmp->dma.virt, 0, cnt);
2612 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
2613 }
2614
2615 /* build buffer ptr list for IOCB */
2616 bpl->addrLow = le32_to_cpu(putPaddrLow(dmp->dma.phys));
2617 bpl->addrHigh = le32_to_cpu(putPaddrHigh(dmp->dma.phys));
2618 bpl->tus.f.bdeSize = (ushort) cnt;
2619 bpl->tus.w = le32_to_cpu(bpl->tus.w);
2620 bpl++;
2621
2622 i++;
2623 offset += cnt;
2624 size -= cnt;
2625 }
2626
2627 mlist->flag = i;
2628 return mlist;
2629 out:
2630 diag_cmd_data_free(phba, mlist);
2631 return NULL;
2632 }
2633
2634 /**
2635 * lpfcdiag_loop_post_rxbufs - post the receive buffers for an unsol CT cmd
2636 * @phba: Pointer to HBA context object
2637 * @rxxri: Receive exchange id
2638 * @len: Number of data bytes
2639 *
2640 * This function allocates and posts a data buffer of sufficient size to receive
2641 * an unsolicted CT command.
2642 **/
2643 static int lpfcdiag_loop_post_rxbufs(struct lpfc_hba *phba, uint16_t rxxri,
2644 size_t len)
2645 {
2646 struct lpfc_sli *psli = &phba->sli;
2647 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
2648 struct lpfc_iocbq *cmdiocbq;
2649 IOCB_t *cmd = NULL;
2650 struct list_head head, *curr, *next;
2651 struct lpfc_dmabuf *rxbmp;
2652 struct lpfc_dmabuf *dmp;
2653 struct lpfc_dmabuf *mp[2] = {NULL, NULL};
2654 struct ulp_bde64 *rxbpl = NULL;
2655 uint32_t num_bde;
2656 struct lpfc_dmabufext *rxbuffer = NULL;
2657 int ret_val = 0;
2658 int iocb_stat;
2659 int i = 0;
2660
2661 cmdiocbq = lpfc_sli_get_iocbq(phba);
2662 rxbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2663 if (rxbmp != NULL) {
2664 rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
2665 if (rxbmp->virt) {
2666 INIT_LIST_HEAD(&rxbmp->list);
2667 rxbpl = (struct ulp_bde64 *) rxbmp->virt;
2668 rxbuffer = diag_cmd_data_alloc(phba, rxbpl, len, 0);
2669 }
2670 }
2671
2672 if (!cmdiocbq || !rxbmp || !rxbpl || !rxbuffer) {
2673 ret_val = -ENOMEM;
2674 goto err_post_rxbufs_exit;
2675 }
2676
2677 /* Queue buffers for the receive exchange */
2678 num_bde = (uint32_t)rxbuffer->flag;
2679 dmp = &rxbuffer->dma;
2680
2681 cmd = &cmdiocbq->iocb;
2682 i = 0;
2683
2684 INIT_LIST_HEAD(&head);
2685 list_add_tail(&head, &dmp->list);
2686 list_for_each_safe(curr, next, &head) {
2687 mp[i] = list_entry(curr, struct lpfc_dmabuf, list);
2688 list_del(curr);
2689
2690 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
2691 mp[i]->buffer_tag = lpfc_sli_get_buffer_tag(phba);
2692 cmd->un.quexri64cx.buff.bde.addrHigh =
2693 putPaddrHigh(mp[i]->phys);
2694 cmd->un.quexri64cx.buff.bde.addrLow =
2695 putPaddrLow(mp[i]->phys);
2696 cmd->un.quexri64cx.buff.bde.tus.f.bdeSize =
2697 ((struct lpfc_dmabufext *)mp[i])->size;
2698 cmd->un.quexri64cx.buff.buffer_tag = mp[i]->buffer_tag;
2699 cmd->ulpCommand = CMD_QUE_XRI64_CX;
2700 cmd->ulpPU = 0;
2701 cmd->ulpLe = 1;
2702 cmd->ulpBdeCount = 1;
2703 cmd->unsli3.que_xri64cx_ext_words.ebde_count = 0;
2704
2705 } else {
2706 cmd->un.cont64[i].addrHigh = putPaddrHigh(mp[i]->phys);
2707 cmd->un.cont64[i].addrLow = putPaddrLow(mp[i]->phys);
2708 cmd->un.cont64[i].tus.f.bdeSize =
2709 ((struct lpfc_dmabufext *)mp[i])->size;
2710 cmd->ulpBdeCount = ++i;
2711
2712 if ((--num_bde > 0) && (i < 2))
2713 continue;
2714
2715 cmd->ulpCommand = CMD_QUE_XRI_BUF64_CX;
2716 cmd->ulpLe = 1;
2717 }
2718
2719 cmd->ulpClass = CLASS3;
2720 cmd->ulpContext = rxxri;
2721
2722 iocb_stat = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq,
2723 0);
2724 if (iocb_stat == IOCB_ERROR) {
2725 diag_cmd_data_free(phba,
2726 (struct lpfc_dmabufext *)mp[0]);
2727 if (mp[1])
2728 diag_cmd_data_free(phba,
2729 (struct lpfc_dmabufext *)mp[1]);
2730 dmp = list_entry(next, struct lpfc_dmabuf, list);
2731 ret_val = -EIO;
2732 goto err_post_rxbufs_exit;
2733 }
2734
2735 lpfc_sli_ringpostbuf_put(phba, pring, mp[0]);
2736 if (mp[1]) {
2737 lpfc_sli_ringpostbuf_put(phba, pring, mp[1]);
2738 mp[1] = NULL;
2739 }
2740
2741 /* The iocb was freed by lpfc_sli_issue_iocb */
2742 cmdiocbq = lpfc_sli_get_iocbq(phba);
2743 if (!cmdiocbq) {
2744 dmp = list_entry(next, struct lpfc_dmabuf, list);
2745 ret_val = -EIO;
2746 goto err_post_rxbufs_exit;
2747 }
2748
2749 cmd = &cmdiocbq->iocb;
2750 i = 0;
2751 }
2752 list_del(&head);
2753
2754 err_post_rxbufs_exit:
2755
2756 if (rxbmp) {
2757 if (rxbmp->virt)
2758 lpfc_mbuf_free(phba, rxbmp->virt, rxbmp->phys);
2759 kfree(rxbmp);
2760 }
2761
2762 if (cmdiocbq)
2763 lpfc_sli_release_iocbq(phba, cmdiocbq);
2764 return ret_val;
2765 }
2766
2767 /**
2768 * lpfc_bsg_diag_loopback_run - run loopback on a port by issue ct cmd to itself
2769 * @job: LPFC_BSG_VENDOR_DIAG_TEST fc_bsg_job
2770 *
2771 * This function receives a user data buffer to be transmitted and received on
2772 * the same port, the link must be up and in loopback mode prior
2773 * to being called.
2774 * 1. A kernel buffer is allocated to copy the user data into.
2775 * 2. The port registers with "itself".
2776 * 3. The transmit and receive exchange ids are obtained.
2777 * 4. The receive exchange id is posted.
2778 * 5. A new els loopback event is created.
2779 * 6. The command and response iocbs are allocated.
2780 * 7. The cmd iocb FsType is set to elx loopback and the CmdRsp to looppback.
2781 *
2782 * This function is meant to be called n times while the port is in loopback
2783 * so it is the apps responsibility to issue a reset to take the port out
2784 * of loopback mode.
2785 **/
2786 static int
2787 lpfc_bsg_diag_loopback_run(struct fc_bsg_job *job)
2788 {
2789 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
2790 struct lpfc_hba *phba = vport->phba;
2791 struct diag_mode_test *diag_mode;
2792 struct lpfc_bsg_event *evt;
2793 struct event_data *evdat;
2794 struct lpfc_sli *psli = &phba->sli;
2795 uint32_t size;
2796 uint32_t full_size;
2797 size_t segment_len = 0, segment_offset = 0, current_offset = 0;
2798 uint16_t rpi = 0;
2799 struct lpfc_iocbq *cmdiocbq, *rspiocbq = NULL;
2800 IOCB_t *cmd, *rsp = NULL;
2801 struct lpfc_sli_ct_request *ctreq;
2802 struct lpfc_dmabuf *txbmp;
2803 struct ulp_bde64 *txbpl = NULL;
2804 struct lpfc_dmabufext *txbuffer = NULL;
2805 struct list_head head;
2806 struct lpfc_dmabuf *curr;
2807 uint16_t txxri = 0, rxxri;
2808 uint32_t num_bde;
2809 uint8_t *ptr = NULL, *rx_databuf = NULL;
2810 int rc = 0;
2811 int time_left;
2812 int iocb_stat;
2813 unsigned long flags;
2814 void *dataout = NULL;
2815 uint32_t total_mem;
2816
2817 /* in case no data is returned return just the return code */
2818 job->reply->reply_payload_rcv_len = 0;
2819
2820 if (job->request_len <
2821 sizeof(struct fc_bsg_request) + sizeof(struct diag_mode_test)) {
2822 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
2823 "2739 Received DIAG TEST request below minimum "
2824 "size\n");
2825 rc = -EINVAL;
2826 goto loopback_test_exit;
2827 }
2828
2829 if (job->request_payload.payload_len !=
2830 job->reply_payload.payload_len) {
2831 rc = -EINVAL;
2832 goto loopback_test_exit;
2833 }
2834 diag_mode = (struct diag_mode_test *)
2835 job->request->rqst_data.h_vendor.vendor_cmd;
2836
2837 if ((phba->link_state == LPFC_HBA_ERROR) ||
2838 (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
2839 (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
2840 rc = -EACCES;
2841 goto loopback_test_exit;
2842 }
2843
2844 if (!lpfc_is_link_up(phba) || !(phba->link_flag & LS_LOOPBACK_MODE)) {
2845 rc = -EACCES;
2846 goto loopback_test_exit;
2847 }
2848
2849 size = job->request_payload.payload_len;
2850 full_size = size + ELX_LOOPBACK_HEADER_SZ; /* plus the header */
2851
2852 if ((size == 0) || (size > 80 * BUF_SZ_4K)) {
2853 rc = -ERANGE;
2854 goto loopback_test_exit;
2855 }
2856
2857 if (full_size >= BUF_SZ_4K) {
2858 /*
2859 * Allocate memory for ioctl data. If buffer is bigger than 64k,
2860 * then we allocate 64k and re-use that buffer over and over to
2861 * xfer the whole block. This is because Linux kernel has a
2862 * problem allocating more than 120k of kernel space memory. Saw
2863 * problem with GET_FCPTARGETMAPPING...
2864 */
2865 if (size <= (64 * 1024))
2866 total_mem = full_size;
2867 else
2868 total_mem = 64 * 1024;
2869 } else
2870 /* Allocate memory for ioctl data */
2871 total_mem = BUF_SZ_4K;
2872
2873 dataout = kmalloc(total_mem, GFP_KERNEL);
2874 if (dataout == NULL) {
2875 rc = -ENOMEM;
2876 goto loopback_test_exit;
2877 }
2878
2879 ptr = dataout;
2880 ptr += ELX_LOOPBACK_HEADER_SZ;
2881 sg_copy_to_buffer(job->request_payload.sg_list,
2882 job->request_payload.sg_cnt,
2883 ptr, size);
2884 rc = lpfcdiag_loop_self_reg(phba, &rpi);
2885 if (rc)
2886 goto loopback_test_exit;
2887
2888 if (phba->sli_rev < LPFC_SLI_REV4) {
2889 rc = lpfcdiag_loop_get_xri(phba, rpi, &txxri, &rxxri);
2890 if (rc) {
2891 lpfcdiag_loop_self_unreg(phba, rpi);
2892 goto loopback_test_exit;
2893 }
2894
2895 rc = lpfcdiag_loop_post_rxbufs(phba, rxxri, full_size);
2896 if (rc) {
2897 lpfcdiag_loop_self_unreg(phba, rpi);
2898 goto loopback_test_exit;
2899 }
2900 }
2901 evt = lpfc_bsg_event_new(FC_REG_CT_EVENT, current->pid,
2902 SLI_CT_ELX_LOOPBACK);
2903 if (!evt) {
2904 lpfcdiag_loop_self_unreg(phba, rpi);
2905 rc = -ENOMEM;
2906 goto loopback_test_exit;
2907 }
2908
2909 spin_lock_irqsave(&phba->ct_ev_lock, flags);
2910 list_add(&evt->node, &phba->ct_ev_waiters);
2911 lpfc_bsg_event_ref(evt);
2912 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
2913
2914 cmdiocbq = lpfc_sli_get_iocbq(phba);
2915 if (phba->sli_rev < LPFC_SLI_REV4)
2916 rspiocbq = lpfc_sli_get_iocbq(phba);
2917 txbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2918
2919 if (txbmp) {
2920 txbmp->virt = lpfc_mbuf_alloc(phba, 0, &txbmp->phys);
2921 if (txbmp->virt) {
2922 INIT_LIST_HEAD(&txbmp->list);
2923 txbpl = (struct ulp_bde64 *) txbmp->virt;
2924 txbuffer = diag_cmd_data_alloc(phba,
2925 txbpl, full_size, 0);
2926 }
2927 }
2928
2929 if (!cmdiocbq || !txbmp || !txbpl || !txbuffer || !txbmp->virt) {
2930 rc = -ENOMEM;
2931 goto err_loopback_test_exit;
2932 }
2933 if ((phba->sli_rev < LPFC_SLI_REV4) && !rspiocbq) {
2934 rc = -ENOMEM;
2935 goto err_loopback_test_exit;
2936 }
2937
2938 cmd = &cmdiocbq->iocb;
2939 if (phba->sli_rev < LPFC_SLI_REV4)
2940 rsp = &rspiocbq->iocb;
2941
2942 INIT_LIST_HEAD(&head);
2943 list_add_tail(&head, &txbuffer->dma.list);
2944 list_for_each_entry(curr, &head, list) {
2945 segment_len = ((struct lpfc_dmabufext *)curr)->size;
2946 if (current_offset == 0) {
2947 ctreq = curr->virt;
2948 memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
2949 ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
2950 ctreq->RevisionId.bits.InId = 0;
2951 ctreq->FsType = SLI_CT_ELX_LOOPBACK;
2952 ctreq->FsSubType = 0;
2953 ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_DATA;
2954 ctreq->CommandResponse.bits.Size = size;
2955 segment_offset = ELX_LOOPBACK_HEADER_SZ;
2956 } else
2957 segment_offset = 0;
2958
2959 BUG_ON(segment_offset >= segment_len);
2960 memcpy(curr->virt + segment_offset,
2961 ptr + current_offset,
2962 segment_len - segment_offset);
2963
2964 current_offset += segment_len - segment_offset;
2965 BUG_ON(current_offset > size);
2966 }
2967 list_del(&head);
2968
2969 /* Build the XMIT_SEQUENCE iocb */
2970 num_bde = (uint32_t)txbuffer->flag;
2971
2972 cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(txbmp->phys);
2973 cmd->un.xseq64.bdl.addrLow = putPaddrLow(txbmp->phys);
2974 cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
2975 cmd->un.xseq64.bdl.bdeSize = (num_bde * sizeof(struct ulp_bde64));
2976
2977 cmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
2978 cmd->un.xseq64.w5.hcsw.Dfctl = 0;
2979 cmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
2980 cmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
2981
2982 cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
2983 cmd->ulpBdeCount = 1;
2984 cmd->ulpLe = 1;
2985 cmd->ulpClass = CLASS3;
2986
2987 if (phba->sli_rev < LPFC_SLI_REV4) {
2988 cmd->ulpContext = txxri;
2989 } else {
2990 cmd->un.xseq64.bdl.ulpIoTag32 = 0;
2991 cmd->un.ulpWord[3] = phba->sli4_hba.rpi_ids[rpi];
2992 cmdiocbq->context3 = txbmp;
2993 cmdiocbq->sli4_xritag = NO_XRI;
2994 cmd->unsli3.rcvsli3.ox_id = 0xffff;
2995 }
2996 cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
2997 cmdiocbq->vport = phba->pport;
2998 iocb_stat = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq,
2999 rspiocbq, (phba->fc_ratov * 2) +
3000 LPFC_DRVR_TIMEOUT);
3001
3002 if ((iocb_stat != IOCB_SUCCESS) || ((phba->sli_rev < LPFC_SLI_REV4) &&
3003 (rsp->ulpStatus != IOCB_SUCCESS))) {
3004 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3005 "3126 Failed loopback test issue iocb: "
3006 "iocb_stat:x%x\n", iocb_stat);
3007 rc = -EIO;
3008 goto err_loopback_test_exit;
3009 }
3010
3011 evt->waiting = 1;
3012 time_left = wait_event_interruptible_timeout(
3013 evt->wq, !list_empty(&evt->events_to_see),
3014 ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
3015 evt->waiting = 0;
3016 if (list_empty(&evt->events_to_see)) {
3017 rc = (time_left) ? -EINTR : -ETIMEDOUT;
3018 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3019 "3125 Not receiving unsolicited event, "
3020 "rc:x%x\n", rc);
3021 } else {
3022 spin_lock_irqsave(&phba->ct_ev_lock, flags);
3023 list_move(evt->events_to_see.prev, &evt->events_to_get);
3024 evdat = list_entry(evt->events_to_get.prev,
3025 typeof(*evdat), node);
3026 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3027 rx_databuf = evdat->data;
3028 if (evdat->len != full_size) {
3029 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3030 "1603 Loopback test did not receive expected "
3031 "data length. actual length 0x%x expected "
3032 "length 0x%x\n",
3033 evdat->len, full_size);
3034 rc = -EIO;
3035 } else if (rx_databuf == NULL)
3036 rc = -EIO;
3037 else {
3038 rc = IOCB_SUCCESS;
3039 /* skip over elx loopback header */
3040 rx_databuf += ELX_LOOPBACK_HEADER_SZ;
3041 job->reply->reply_payload_rcv_len =
3042 sg_copy_from_buffer(job->reply_payload.sg_list,
3043 job->reply_payload.sg_cnt,
3044 rx_databuf, size);
3045 job->reply->reply_payload_rcv_len = size;
3046 }
3047 }
3048
3049 err_loopback_test_exit:
3050 lpfcdiag_loop_self_unreg(phba, rpi);
3051
3052 spin_lock_irqsave(&phba->ct_ev_lock, flags);
3053 lpfc_bsg_event_unref(evt); /* release ref */
3054 lpfc_bsg_event_unref(evt); /* delete */
3055 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3056
3057 if (cmdiocbq != NULL)
3058 lpfc_sli_release_iocbq(phba, cmdiocbq);
3059
3060 if (rspiocbq != NULL)
3061 lpfc_sli_release_iocbq(phba, rspiocbq);
3062
3063 if (txbmp != NULL) {
3064 if (txbpl != NULL) {
3065 if (txbuffer != NULL)
3066 diag_cmd_data_free(phba, txbuffer);
3067 lpfc_mbuf_free(phba, txbmp->virt, txbmp->phys);
3068 }
3069 kfree(txbmp);
3070 }
3071
3072 loopback_test_exit:
3073 kfree(dataout);
3074 /* make error code available to userspace */
3075 job->reply->result = rc;
3076 job->dd_data = NULL;
3077 /* complete the job back to userspace if no error */
3078 if (rc == IOCB_SUCCESS)
3079 job->job_done(job);
3080 return rc;
3081 }
3082
3083 /**
3084 * lpfc_bsg_get_dfc_rev - process a GET_DFC_REV bsg vendor command
3085 * @job: GET_DFC_REV fc_bsg_job
3086 **/
3087 static int
3088 lpfc_bsg_get_dfc_rev(struct fc_bsg_job *job)
3089 {
3090 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
3091 struct lpfc_hba *phba = vport->phba;
3092 struct get_mgmt_rev *event_req;
3093 struct get_mgmt_rev_reply *event_reply;
3094 int rc = 0;
3095
3096 if (job->request_len <
3097 sizeof(struct fc_bsg_request) + sizeof(struct get_mgmt_rev)) {
3098 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
3099 "2740 Received GET_DFC_REV request below "
3100 "minimum size\n");
3101 rc = -EINVAL;
3102 goto job_error;
3103 }
3104
3105 event_req = (struct get_mgmt_rev *)
3106 job->request->rqst_data.h_vendor.vendor_cmd;
3107
3108 event_reply = (struct get_mgmt_rev_reply *)
3109 job->reply->reply_data.vendor_reply.vendor_rsp;
3110
3111 if (job->reply_len <
3112 sizeof(struct fc_bsg_request) + sizeof(struct get_mgmt_rev_reply)) {
3113 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
3114 "2741 Received GET_DFC_REV reply below "
3115 "minimum size\n");
3116 rc = -EINVAL;
3117 goto job_error;
3118 }
3119
3120 event_reply->info.a_Major = MANAGEMENT_MAJOR_REV;
3121 event_reply->info.a_Minor = MANAGEMENT_MINOR_REV;
3122 job_error:
3123 job->reply->result = rc;
3124 if (rc == 0)
3125 job->job_done(job);
3126 return rc;
3127 }
3128
3129 /**
3130 * lpfc_bsg_issue_mbox_cmpl - lpfc_bsg_issue_mbox mbox completion handler
3131 * @phba: Pointer to HBA context object.
3132 * @pmboxq: Pointer to mailbox command.
3133 *
3134 * This is completion handler function for mailbox commands issued from
3135 * lpfc_bsg_issue_mbox function. This function is called by the
3136 * mailbox event handler function with no lock held. This function
3137 * will wake up thread waiting on the wait queue pointed by context1
3138 * of the mailbox.
3139 **/
3140 void
3141 lpfc_bsg_issue_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
3142 {
3143 struct bsg_job_data *dd_data;
3144 struct fc_bsg_job *job;
3145 uint32_t size;
3146 unsigned long flags;
3147 uint8_t *pmb, *pmb_buf;
3148
3149 spin_lock_irqsave(&phba->ct_ev_lock, flags);
3150 dd_data = pmboxq->context1;
3151 /* job already timed out? */
3152 if (!dd_data) {
3153 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3154 return;
3155 }
3156
3157 /*
3158 * The outgoing buffer is readily referred from the dma buffer,
3159 * just need to get header part from mailboxq structure.
3160 */
3161 pmb = (uint8_t *)&pmboxq->u.mb;
3162 pmb_buf = (uint8_t *)dd_data->context_un.mbox.mb;
3163 memcpy(pmb_buf, pmb, sizeof(MAILBOX_t));
3164
3165 job = dd_data->context_un.mbox.set_job;
3166 if (job) {
3167 size = job->reply_payload.payload_len;
3168 job->reply->reply_payload_rcv_len =
3169 sg_copy_from_buffer(job->reply_payload.sg_list,
3170 job->reply_payload.sg_cnt,
3171 pmb_buf, size);
3172 /* need to hold the lock until we set job->dd_data to NULL
3173 * to hold off the timeout handler returning to the mid-layer
3174 * while we are still processing the job.
3175 */
3176 job->dd_data = NULL;
3177 dd_data->context_un.mbox.set_job = NULL;
3178 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3179 } else {
3180 dd_data->context_un.mbox.set_job = NULL;
3181 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3182 }
3183
3184 mempool_free(dd_data->context_un.mbox.pmboxq, phba->mbox_mem_pool);
3185 lpfc_bsg_dma_page_free(phba, dd_data->context_un.mbox.dmabuffers);
3186 kfree(dd_data);
3187
3188 if (job) {
3189 job->reply->result = 0;
3190 job->job_done(job);
3191 }
3192 return;
3193 }
3194
3195 /**
3196 * lpfc_bsg_check_cmd_access - test for a supported mailbox command
3197 * @phba: Pointer to HBA context object.
3198 * @mb: Pointer to a mailbox object.
3199 * @vport: Pointer to a vport object.
3200 *
3201 * Some commands require the port to be offline, some may not be called from
3202 * the application.
3203 **/
3204 static int lpfc_bsg_check_cmd_access(struct lpfc_hba *phba,
3205 MAILBOX_t *mb, struct lpfc_vport *vport)
3206 {
3207 /* return negative error values for bsg job */
3208 switch (mb->mbxCommand) {
3209 /* Offline only */
3210 case MBX_INIT_LINK:
3211 case MBX_DOWN_LINK:
3212 case MBX_CONFIG_LINK:
3213 case MBX_CONFIG_RING:
3214 case MBX_RESET_RING:
3215 case MBX_UNREG_LOGIN:
3216 case MBX_CLEAR_LA:
3217 case MBX_DUMP_CONTEXT:
3218 case MBX_RUN_DIAGS:
3219 case MBX_RESTART:
3220 case MBX_SET_MASK:
3221 if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
3222 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
3223 "2743 Command 0x%x is illegal in on-line "
3224 "state\n",
3225 mb->mbxCommand);
3226 return -EPERM;
3227 }
3228 case MBX_WRITE_NV:
3229 case MBX_WRITE_VPARMS:
3230 case MBX_LOAD_SM:
3231 case MBX_READ_NV:
3232 case MBX_READ_CONFIG:
3233 case MBX_READ_RCONFIG:
3234 case MBX_READ_STATUS:
3235 case MBX_READ_XRI:
3236 case MBX_READ_REV:
3237 case MBX_READ_LNK_STAT:
3238 case MBX_DUMP_MEMORY:
3239 case MBX_DOWN_LOAD:
3240 case MBX_UPDATE_CFG:
3241 case MBX_KILL_BOARD:
3242 case MBX_LOAD_AREA:
3243 case MBX_LOAD_EXP_ROM:
3244 case MBX_BEACON:
3245 case MBX_DEL_LD_ENTRY:
3246 case MBX_SET_DEBUG:
3247 case MBX_WRITE_WWN:
3248 case MBX_SLI4_CONFIG:
3249 case MBX_READ_EVENT_LOG:
3250 case MBX_READ_EVENT_LOG_STATUS:
3251 case MBX_WRITE_EVENT_LOG:
3252 case MBX_PORT_CAPABILITIES:
3253 case MBX_PORT_IOV_CONTROL:
3254 case MBX_RUN_BIU_DIAG64:
3255 break;
3256 case MBX_SET_VARIABLE:
3257 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3258 "1226 mbox: set_variable 0x%x, 0x%x\n",
3259 mb->un.varWords[0],
3260 mb->un.varWords[1]);
3261 if ((mb->un.varWords[0] == SETVAR_MLOMNT)
3262 && (mb->un.varWords[1] == 1)) {
3263 phba->wait_4_mlo_maint_flg = 1;
3264 } else if (mb->un.varWords[0] == SETVAR_MLORST) {
3265 spin_lock_irq(&phba->hbalock);
3266 phba->link_flag &= ~LS_LOOPBACK_MODE;
3267 spin_unlock_irq(&phba->hbalock);
3268 phba->fc_topology = LPFC_TOPOLOGY_PT_PT;
3269 }
3270 break;
3271 case MBX_READ_SPARM64:
3272 case MBX_READ_TOPOLOGY:
3273 case MBX_REG_LOGIN:
3274 case MBX_REG_LOGIN64:
3275 case MBX_CONFIG_PORT:
3276 case MBX_RUN_BIU_DIAG:
3277 default:
3278 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
3279 "2742 Unknown Command 0x%x\n",
3280 mb->mbxCommand);
3281 return -EPERM;
3282 }
3283
3284 return 0; /* ok */
3285 }
3286
3287 /**
3288 * lpfc_bsg_mbox_ext_cleanup - clean up context of multi-buffer mbox session
3289 * @phba: Pointer to HBA context object.
3290 *
3291 * This is routine clean up and reset BSG handling of multi-buffer mbox
3292 * command session.
3293 **/
3294 static void
3295 lpfc_bsg_mbox_ext_session_reset(struct lpfc_hba *phba)
3296 {
3297 if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_IDLE)
3298 return;
3299
3300 /* free all memory, including dma buffers */
3301 lpfc_bsg_dma_page_list_free(phba,
3302 &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
3303 lpfc_bsg_dma_page_free(phba, phba->mbox_ext_buf_ctx.mbx_dmabuf);
3304 /* multi-buffer write mailbox command pass-through complete */
3305 memset((char *)&phba->mbox_ext_buf_ctx, 0,
3306 sizeof(struct lpfc_mbox_ext_buf_ctx));
3307 INIT_LIST_HEAD(&phba->mbox_ext_buf_ctx.ext_dmabuf_list);
3308
3309 return;
3310 }
3311
3312 /**
3313 * lpfc_bsg_issue_mbox_ext_handle_job - job handler for multi-buffer mbox cmpl
3314 * @phba: Pointer to HBA context object.
3315 * @pmboxq: Pointer to mailbox command.
3316 *
3317 * This is routine handles BSG job for mailbox commands completions with
3318 * multiple external buffers.
3319 **/
3320 static struct fc_bsg_job *
3321 lpfc_bsg_issue_mbox_ext_handle_job(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
3322 {
3323 struct bsg_job_data *dd_data;
3324 struct fc_bsg_job *job;
3325 uint8_t *pmb, *pmb_buf;
3326 unsigned long flags;
3327 uint32_t size;
3328 int rc = 0;
3329 struct lpfc_dmabuf *dmabuf;
3330 struct lpfc_sli_config_mbox *sli_cfg_mbx;
3331 uint8_t *pmbx;
3332
3333 spin_lock_irqsave(&phba->ct_ev_lock, flags);
3334 dd_data = pmboxq->context1;
3335 /* has the job already timed out? */
3336 if (!dd_data) {
3337 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3338 job = NULL;
3339 goto job_done_out;
3340 }
3341
3342 /*
3343 * The outgoing buffer is readily referred from the dma buffer,
3344 * just need to get header part from mailboxq structure.
3345 */
3346 pmb = (uint8_t *)&pmboxq->u.mb;
3347 pmb_buf = (uint8_t *)dd_data->context_un.mbox.mb;
3348 /* Copy the byte swapped response mailbox back to the user */
3349 memcpy(pmb_buf, pmb, sizeof(MAILBOX_t));
3350 /* if there is any non-embedded extended data copy that too */
3351 dmabuf = phba->mbox_ext_buf_ctx.mbx_dmabuf;
3352 sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
3353 if (!bsg_bf_get(lpfc_mbox_hdr_emb,
3354 &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr)) {
3355 pmbx = (uint8_t *)dmabuf->virt;
3356 /* byte swap the extended data following the mailbox command */
3357 lpfc_sli_pcimem_bcopy(&pmbx[sizeof(MAILBOX_t)],
3358 &pmbx[sizeof(MAILBOX_t)],
3359 sli_cfg_mbx->un.sli_config_emb0_subsys.mse[0].buf_len);
3360 }
3361
3362 job = dd_data->context_un.mbox.set_job;
3363 if (job) {
3364 size = job->reply_payload.payload_len;
3365 job->reply->reply_payload_rcv_len =
3366 sg_copy_from_buffer(job->reply_payload.sg_list,
3367 job->reply_payload.sg_cnt,
3368 pmb_buf, size);
3369 /* result for successful */
3370 job->reply->result = 0;
3371 job->dd_data = NULL;
3372 /* need to hold the lock util we set job->dd_data to NULL
3373 * to hold off the timeout handler from midlayer to take
3374 * any action.
3375 */
3376 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3377 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3378 "2937 SLI_CONFIG ext-buffer maibox command "
3379 "(x%x/x%x) complete bsg job done, bsize:%d\n",
3380 phba->mbox_ext_buf_ctx.nembType,
3381 phba->mbox_ext_buf_ctx.mboxType, size);
3382 lpfc_idiag_mbxacc_dump_bsg_mbox(phba,
3383 phba->mbox_ext_buf_ctx.nembType,
3384 phba->mbox_ext_buf_ctx.mboxType,
3385 dma_ebuf, sta_pos_addr,
3386 phba->mbox_ext_buf_ctx.mbx_dmabuf, 0);
3387 } else
3388 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
3389
3390 job_done_out:
3391 if (!job)
3392 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3393 "2938 SLI_CONFIG ext-buffer maibox "
3394 "command (x%x/x%x) failure, rc:x%x\n",
3395 phba->mbox_ext_buf_ctx.nembType,
3396 phba->mbox_ext_buf_ctx.mboxType, rc);
3397 /* state change */
3398 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_DONE;
3399 kfree(dd_data);
3400
3401 return job;
3402 }
3403
3404 /**
3405 * lpfc_bsg_issue_read_mbox_ext_cmpl - compl handler for multi-buffer read mbox
3406 * @phba: Pointer to HBA context object.
3407 * @pmboxq: Pointer to mailbox command.
3408 *
3409 * This is completion handler function for mailbox read commands with multiple
3410 * external buffers.
3411 **/
3412 static void
3413 lpfc_bsg_issue_read_mbox_ext_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
3414 {
3415 struct fc_bsg_job *job;
3416
3417 /* handle the BSG job with mailbox command */
3418 if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_ABTS)
3419 pmboxq->u.mb.mbxStatus = MBXERR_ERROR;
3420
3421 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3422 "2939 SLI_CONFIG ext-buffer rd maibox command "
3423 "complete, ctxState:x%x, mbxStatus:x%x\n",
3424 phba->mbox_ext_buf_ctx.state, pmboxq->u.mb.mbxStatus);
3425
3426 job = lpfc_bsg_issue_mbox_ext_handle_job(phba, pmboxq);
3427
3428 if (pmboxq->u.mb.mbxStatus || phba->mbox_ext_buf_ctx.numBuf == 1)
3429 lpfc_bsg_mbox_ext_session_reset(phba);
3430
3431 /* free base driver mailbox structure memory */
3432 mempool_free(pmboxq, phba->mbox_mem_pool);
3433
3434 /* complete the bsg job if we have it */
3435 if (job)
3436 job->job_done(job);
3437
3438 return;
3439 }
3440
3441 /**
3442 * lpfc_bsg_issue_write_mbox_ext_cmpl - cmpl handler for multi-buffer write mbox
3443 * @phba: Pointer to HBA context object.
3444 * @pmboxq: Pointer to mailbox command.
3445 *
3446 * This is completion handler function for mailbox write commands with multiple
3447 * external buffers.
3448 **/
3449 static void
3450 lpfc_bsg_issue_write_mbox_ext_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
3451 {
3452 struct fc_bsg_job *job;
3453
3454 /* handle the BSG job with the mailbox command */
3455 if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_ABTS)
3456 pmboxq->u.mb.mbxStatus = MBXERR_ERROR;
3457
3458 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3459 "2940 SLI_CONFIG ext-buffer wr maibox command "
3460 "complete, ctxState:x%x, mbxStatus:x%x\n",
3461 phba->mbox_ext_buf_ctx.state, pmboxq->u.mb.mbxStatus);
3462
3463 job = lpfc_bsg_issue_mbox_ext_handle_job(phba, pmboxq);
3464
3465 /* free all memory, including dma buffers */
3466 mempool_free(pmboxq, phba->mbox_mem_pool);
3467 lpfc_bsg_mbox_ext_session_reset(phba);
3468
3469 /* complete the bsg job if we have it */
3470 if (job)
3471 job->job_done(job);
3472
3473 return;
3474 }
3475
3476 static void
3477 lpfc_bsg_sli_cfg_dma_desc_setup(struct lpfc_hba *phba, enum nemb_type nemb_tp,
3478 uint32_t index, struct lpfc_dmabuf *mbx_dmabuf,
3479 struct lpfc_dmabuf *ext_dmabuf)
3480 {
3481 struct lpfc_sli_config_mbox *sli_cfg_mbx;
3482
3483 /* pointer to the start of mailbox command */
3484 sli_cfg_mbx = (struct lpfc_sli_config_mbox *)mbx_dmabuf->virt;
3485
3486 if (nemb_tp == nemb_mse) {
3487 if (index == 0) {
3488 sli_cfg_mbx->un.sli_config_emb0_subsys.
3489 mse[index].pa_hi =
3490 putPaddrHigh(mbx_dmabuf->phys +
3491 sizeof(MAILBOX_t));
3492 sli_cfg_mbx->un.sli_config_emb0_subsys.
3493 mse[index].pa_lo =
3494 putPaddrLow(mbx_dmabuf->phys +
3495 sizeof(MAILBOX_t));
3496 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3497 "2943 SLI_CONFIG(mse)[%d], "
3498 "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
3499 index,
3500 sli_cfg_mbx->un.sli_config_emb0_subsys.
3501 mse[index].buf_len,
3502 sli_cfg_mbx->un.sli_config_emb0_subsys.
3503 mse[index].pa_hi,
3504 sli_cfg_mbx->un.sli_config_emb0_subsys.
3505 mse[index].pa_lo);
3506 } else {
3507 sli_cfg_mbx->un.sli_config_emb0_subsys.
3508 mse[index].pa_hi =
3509 putPaddrHigh(ext_dmabuf->phys);
3510 sli_cfg_mbx->un.sli_config_emb0_subsys.
3511 mse[index].pa_lo =
3512 putPaddrLow(ext_dmabuf->phys);
3513 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3514 "2944 SLI_CONFIG(mse)[%d], "
3515 "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
3516 index,
3517 sli_cfg_mbx->un.sli_config_emb0_subsys.
3518 mse[index].buf_len,
3519 sli_cfg_mbx->un.sli_config_emb0_subsys.
3520 mse[index].pa_hi,
3521 sli_cfg_mbx->un.sli_config_emb0_subsys.
3522 mse[index].pa_lo);
3523 }
3524 } else {
3525 if (index == 0) {
3526 sli_cfg_mbx->un.sli_config_emb1_subsys.
3527 hbd[index].pa_hi =
3528 putPaddrHigh(mbx_dmabuf->phys +
3529 sizeof(MAILBOX_t));
3530 sli_cfg_mbx->un.sli_config_emb1_subsys.
3531 hbd[index].pa_lo =
3532 putPaddrLow(mbx_dmabuf->phys +
3533 sizeof(MAILBOX_t));
3534 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3535 "3007 SLI_CONFIG(hbd)[%d], "
3536 "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
3537 index,
3538 bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
3539 &sli_cfg_mbx->un.
3540 sli_config_emb1_subsys.hbd[index]),
3541 sli_cfg_mbx->un.sli_config_emb1_subsys.
3542 hbd[index].pa_hi,
3543 sli_cfg_mbx->un.sli_config_emb1_subsys.
3544 hbd[index].pa_lo);
3545
3546 } else {
3547 sli_cfg_mbx->un.sli_config_emb1_subsys.
3548 hbd[index].pa_hi =
3549 putPaddrHigh(ext_dmabuf->phys);
3550 sli_cfg_mbx->un.sli_config_emb1_subsys.
3551 hbd[index].pa_lo =
3552 putPaddrLow(ext_dmabuf->phys);
3553 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3554 "3008 SLI_CONFIG(hbd)[%d], "
3555 "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
3556 index,
3557 bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
3558 &sli_cfg_mbx->un.
3559 sli_config_emb1_subsys.hbd[index]),
3560 sli_cfg_mbx->un.sli_config_emb1_subsys.
3561 hbd[index].pa_hi,
3562 sli_cfg_mbx->un.sli_config_emb1_subsys.
3563 hbd[index].pa_lo);
3564 }
3565 }
3566 return;
3567 }
3568
3569 /**
3570 * lpfc_bsg_sli_cfg_mse_read_cmd_ext - sli_config non-embedded mailbox cmd read
3571 * @phba: Pointer to HBA context object.
3572 * @mb: Pointer to a BSG mailbox object.
3573 * @nemb_tp: Enumerate of non-embedded mailbox command type.
3574 * @dmabuff: Pointer to a DMA buffer descriptor.
3575 *
3576 * This routine performs SLI_CONFIG (0x9B) read mailbox command operation with
3577 * non-embedded external bufffers.
3578 **/
3579 static int
3580 lpfc_bsg_sli_cfg_read_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
3581 enum nemb_type nemb_tp,
3582 struct lpfc_dmabuf *dmabuf)
3583 {
3584 struct lpfc_sli_config_mbox *sli_cfg_mbx;
3585 struct dfc_mbox_req *mbox_req;
3586 struct lpfc_dmabuf *curr_dmabuf, *next_dmabuf;
3587 uint32_t ext_buf_cnt, ext_buf_index;
3588 struct lpfc_dmabuf *ext_dmabuf = NULL;
3589 struct bsg_job_data *dd_data = NULL;
3590 LPFC_MBOXQ_t *pmboxq = NULL;
3591 MAILBOX_t *pmb;
3592 uint8_t *pmbx;
3593 int rc, i;
3594
3595 mbox_req =
3596 (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
3597
3598 /* pointer to the start of mailbox command */
3599 sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
3600
3601 if (nemb_tp == nemb_mse) {
3602 ext_buf_cnt = bsg_bf_get(lpfc_mbox_hdr_mse_cnt,
3603 &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr);
3604 if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_MSE) {
3605 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3606 "2945 Handled SLI_CONFIG(mse) rd, "
3607 "ext_buf_cnt(%d) out of range(%d)\n",
3608 ext_buf_cnt,
3609 LPFC_MBX_SLI_CONFIG_MAX_MSE);
3610 rc = -ERANGE;
3611 goto job_error;
3612 }
3613 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3614 "2941 Handled SLI_CONFIG(mse) rd, "
3615 "ext_buf_cnt:%d\n", ext_buf_cnt);
3616 } else {
3617 /* sanity check on interface type for support */
3618 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
3619 LPFC_SLI_INTF_IF_TYPE_2) {
3620 rc = -ENODEV;
3621 goto job_error;
3622 }
3623 /* nemb_tp == nemb_hbd */
3624 ext_buf_cnt = sli_cfg_mbx->un.sli_config_emb1_subsys.hbd_count;
3625 if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_HBD) {
3626 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3627 "2946 Handled SLI_CONFIG(hbd) rd, "
3628 "ext_buf_cnt(%d) out of range(%d)\n",
3629 ext_buf_cnt,
3630 LPFC_MBX_SLI_CONFIG_MAX_HBD);
3631 rc = -ERANGE;
3632 goto job_error;
3633 }
3634 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3635 "2942 Handled SLI_CONFIG(hbd) rd, "
3636 "ext_buf_cnt:%d\n", ext_buf_cnt);
3637 }
3638
3639 /* before dma descriptor setup */
3640 lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_rd, dma_mbox,
3641 sta_pre_addr, dmabuf, ext_buf_cnt);
3642
3643 /* reject non-embedded mailbox command with none external buffer */
3644 if (ext_buf_cnt == 0) {
3645 rc = -EPERM;
3646 goto job_error;
3647 } else if (ext_buf_cnt > 1) {
3648 /* additional external read buffers */
3649 for (i = 1; i < ext_buf_cnt; i++) {
3650 ext_dmabuf = lpfc_bsg_dma_page_alloc(phba);
3651 if (!ext_dmabuf) {
3652 rc = -ENOMEM;
3653 goto job_error;
3654 }
3655 list_add_tail(&ext_dmabuf->list,
3656 &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
3657 }
3658 }
3659
3660 /* bsg tracking structure */
3661 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
3662 if (!dd_data) {
3663 rc = -ENOMEM;
3664 goto job_error;
3665 }
3666
3667 /* mailbox command structure for base driver */
3668 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3669 if (!pmboxq) {
3670 rc = -ENOMEM;
3671 goto job_error;
3672 }
3673 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
3674
3675 /* for the first external buffer */
3676 lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, 0, dmabuf, dmabuf);
3677
3678 /* for the rest of external buffer descriptors if any */
3679 if (ext_buf_cnt > 1) {
3680 ext_buf_index = 1;
3681 list_for_each_entry_safe(curr_dmabuf, next_dmabuf,
3682 &phba->mbox_ext_buf_ctx.ext_dmabuf_list, list) {
3683 lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp,
3684 ext_buf_index, dmabuf,
3685 curr_dmabuf);
3686 ext_buf_index++;
3687 }
3688 }
3689
3690 /* after dma descriptor setup */
3691 lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_rd, dma_mbox,
3692 sta_pos_addr, dmabuf, ext_buf_cnt);
3693
3694 /* construct base driver mbox command */
3695 pmb = &pmboxq->u.mb;
3696 pmbx = (uint8_t *)dmabuf->virt;
3697 memcpy(pmb, pmbx, sizeof(*pmb));
3698 pmb->mbxOwner = OWN_HOST;
3699 pmboxq->vport = phba->pport;
3700
3701 /* multi-buffer handling context */
3702 phba->mbox_ext_buf_ctx.nembType = nemb_tp;
3703 phba->mbox_ext_buf_ctx.mboxType = mbox_rd;
3704 phba->mbox_ext_buf_ctx.numBuf = ext_buf_cnt;
3705 phba->mbox_ext_buf_ctx.mbxTag = mbox_req->extMboxTag;
3706 phba->mbox_ext_buf_ctx.seqNum = mbox_req->extSeqNum;
3707 phba->mbox_ext_buf_ctx.mbx_dmabuf = dmabuf;
3708
3709 /* callback for multi-buffer read mailbox command */
3710 pmboxq->mbox_cmpl = lpfc_bsg_issue_read_mbox_ext_cmpl;
3711
3712 /* context fields to callback function */
3713 pmboxq->context1 = dd_data;
3714 dd_data->type = TYPE_MBOX;
3715 dd_data->context_un.mbox.pmboxq = pmboxq;
3716 dd_data->context_un.mbox.mb = (MAILBOX_t *)pmbx;
3717 dd_data->context_un.mbox.set_job = job;
3718 job->dd_data = dd_data;
3719
3720 /* state change */
3721 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
3722
3723 /*
3724 * Non-embedded mailbox subcommand data gets byte swapped here because
3725 * the lower level driver code only does the first 64 mailbox words.
3726 */
3727 if ((!bsg_bf_get(lpfc_mbox_hdr_emb,
3728 &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr)) &&
3729 (nemb_tp == nemb_mse))
3730 lpfc_sli_pcimem_bcopy(&pmbx[sizeof(MAILBOX_t)],
3731 &pmbx[sizeof(MAILBOX_t)],
3732 sli_cfg_mbx->un.sli_config_emb0_subsys.
3733 mse[0].buf_len);
3734
3735 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
3736 if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
3737 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3738 "2947 Issued SLI_CONFIG ext-buffer "
3739 "maibox command, rc:x%x\n", rc);
3740 return SLI_CONFIG_HANDLED;
3741 }
3742 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3743 "2948 Failed to issue SLI_CONFIG ext-buffer "
3744 "maibox command, rc:x%x\n", rc);
3745 rc = -EPIPE;
3746
3747 job_error:
3748 if (pmboxq)
3749 mempool_free(pmboxq, phba->mbox_mem_pool);
3750 lpfc_bsg_dma_page_list_free(phba,
3751 &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
3752 kfree(dd_data);
3753 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_IDLE;
3754 return rc;
3755 }
3756
3757 /**
3758 * lpfc_bsg_sli_cfg_write_cmd_ext - sli_config non-embedded mailbox cmd write
3759 * @phba: Pointer to HBA context object.
3760 * @mb: Pointer to a BSG mailbox object.
3761 * @dmabuff: Pointer to a DMA buffer descriptor.
3762 *
3763 * This routine performs SLI_CONFIG (0x9B) write mailbox command operation with
3764 * non-embedded external bufffers.
3765 **/
3766 static int
3767 lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
3768 enum nemb_type nemb_tp,
3769 struct lpfc_dmabuf *dmabuf)
3770 {
3771 struct dfc_mbox_req *mbox_req;
3772 struct lpfc_sli_config_mbox *sli_cfg_mbx;
3773 uint32_t ext_buf_cnt;
3774 struct bsg_job_data *dd_data = NULL;
3775 LPFC_MBOXQ_t *pmboxq = NULL;
3776 MAILBOX_t *pmb;
3777 uint8_t *mbx;
3778 int rc = SLI_CONFIG_NOT_HANDLED, i;
3779
3780 mbox_req =
3781 (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
3782
3783 /* pointer to the start of mailbox command */
3784 sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
3785
3786 if (nemb_tp == nemb_mse) {
3787 ext_buf_cnt = bsg_bf_get(lpfc_mbox_hdr_mse_cnt,
3788 &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr);
3789 if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_MSE) {
3790 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3791 "2953 Failed SLI_CONFIG(mse) wr, "
3792 "ext_buf_cnt(%d) out of range(%d)\n",
3793 ext_buf_cnt,
3794 LPFC_MBX_SLI_CONFIG_MAX_MSE);
3795 return -ERANGE;
3796 }
3797 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3798 "2949 Handled SLI_CONFIG(mse) wr, "
3799 "ext_buf_cnt:%d\n", ext_buf_cnt);
3800 } else {
3801 /* sanity check on interface type for support */
3802 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
3803 LPFC_SLI_INTF_IF_TYPE_2)
3804 return -ENODEV;
3805 /* nemb_tp == nemb_hbd */
3806 ext_buf_cnt = sli_cfg_mbx->un.sli_config_emb1_subsys.hbd_count;
3807 if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_HBD) {
3808 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3809 "2954 Failed SLI_CONFIG(hbd) wr, "
3810 "ext_buf_cnt(%d) out of range(%d)\n",
3811 ext_buf_cnt,
3812 LPFC_MBX_SLI_CONFIG_MAX_HBD);
3813 return -ERANGE;
3814 }
3815 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3816 "2950 Handled SLI_CONFIG(hbd) wr, "
3817 "ext_buf_cnt:%d\n", ext_buf_cnt);
3818 }
3819
3820 /* before dma buffer descriptor setup */
3821 lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_wr, dma_mbox,
3822 sta_pre_addr, dmabuf, ext_buf_cnt);
3823
3824 if (ext_buf_cnt == 0)
3825 return -EPERM;
3826
3827 /* for the first external buffer */
3828 lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, 0, dmabuf, dmabuf);
3829
3830 /* after dma descriptor setup */
3831 lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_wr, dma_mbox,
3832 sta_pos_addr, dmabuf, ext_buf_cnt);
3833
3834 /* log for looking forward */
3835 for (i = 1; i < ext_buf_cnt; i++) {
3836 if (nemb_tp == nemb_mse)
3837 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3838 "2951 SLI_CONFIG(mse), buf[%d]-length:%d\n",
3839 i, sli_cfg_mbx->un.sli_config_emb0_subsys.
3840 mse[i].buf_len);
3841 else
3842 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3843 "2952 SLI_CONFIG(hbd), buf[%d]-length:%d\n",
3844 i, bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
3845 &sli_cfg_mbx->un.sli_config_emb1_subsys.
3846 hbd[i]));
3847 }
3848
3849 /* multi-buffer handling context */
3850 phba->mbox_ext_buf_ctx.nembType = nemb_tp;
3851 phba->mbox_ext_buf_ctx.mboxType = mbox_wr;
3852 phba->mbox_ext_buf_ctx.numBuf = ext_buf_cnt;
3853 phba->mbox_ext_buf_ctx.mbxTag = mbox_req->extMboxTag;
3854 phba->mbox_ext_buf_ctx.seqNum = mbox_req->extSeqNum;
3855 phba->mbox_ext_buf_ctx.mbx_dmabuf = dmabuf;
3856
3857 if (ext_buf_cnt == 1) {
3858 /* bsg tracking structure */
3859 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
3860 if (!dd_data) {
3861 rc = -ENOMEM;
3862 goto job_error;
3863 }
3864
3865 /* mailbox command structure for base driver */
3866 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3867 if (!pmboxq) {
3868 rc = -ENOMEM;
3869 goto job_error;
3870 }
3871 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
3872 pmb = &pmboxq->u.mb;
3873 mbx = (uint8_t *)dmabuf->virt;
3874 memcpy(pmb, mbx, sizeof(*pmb));
3875 pmb->mbxOwner = OWN_HOST;
3876 pmboxq->vport = phba->pport;
3877
3878 /* callback for multi-buffer read mailbox command */
3879 pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;
3880
3881 /* context fields to callback function */
3882 pmboxq->context1 = dd_data;
3883 dd_data->type = TYPE_MBOX;
3884 dd_data->context_un.mbox.pmboxq = pmboxq;
3885 dd_data->context_un.mbox.mb = (MAILBOX_t *)mbx;
3886 dd_data->context_un.mbox.set_job = job;
3887 job->dd_data = dd_data;
3888
3889 /* state change */
3890 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
3891
3892 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
3893 if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
3894 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3895 "2955 Issued SLI_CONFIG ext-buffer "
3896 "maibox command, rc:x%x\n", rc);
3897 return SLI_CONFIG_HANDLED;
3898 }
3899 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
3900 "2956 Failed to issue SLI_CONFIG ext-buffer "
3901 "maibox command, rc:x%x\n", rc);
3902 rc = -EPIPE;
3903 goto job_error;
3904 }
3905
3906 /* wait for additoinal external buffers */
3907 job->reply->result = 0;
3908 job->job_done(job);
3909 return SLI_CONFIG_HANDLED;
3910
3911 job_error:
3912 if (pmboxq)
3913 mempool_free(pmboxq, phba->mbox_mem_pool);
3914 kfree(dd_data);
3915
3916 return rc;
3917 }
3918
3919 /**
3920 * lpfc_bsg_handle_sli_cfg_mbox - handle sli-cfg mailbox cmd with ext buffer
3921 * @phba: Pointer to HBA context object.
3922 * @mb: Pointer to a BSG mailbox object.
3923 * @dmabuff: Pointer to a DMA buffer descriptor.
3924 *
3925 * This routine handles SLI_CONFIG (0x9B) mailbox command with non-embedded
3926 * external bufffers, including both 0x9B with non-embedded MSEs and 0x9B
3927 * with embedded sussystem 0x1 and opcodes with external HBDs.
3928 **/
3929 static int
3930 lpfc_bsg_handle_sli_cfg_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
3931 struct lpfc_dmabuf *dmabuf)
3932 {
3933 struct lpfc_sli_config_mbox *sli_cfg_mbx;
3934 uint32_t subsys;
3935 uint32_t opcode;
3936 int rc = SLI_CONFIG_NOT_HANDLED;
3937
3938 /* state change on new multi-buffer pass-through mailbox command */
3939 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_HOST;
3940
3941 sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
3942
3943 if (!bsg_bf_get(lpfc_mbox_hdr_emb,
3944 &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr)) {
3945 subsys = bsg_bf_get(lpfc_emb0_subcmnd_subsys,
3946 &sli_cfg_mbx->un.sli_config_emb0_subsys);
3947 opcode = bsg_bf_get(lpfc_emb0_subcmnd_opcode,
3948 &sli_cfg_mbx->un.sli_config_emb0_subsys);
3949 if (subsys == SLI_CONFIG_SUBSYS_FCOE) {
3950 switch (opcode) {
3951 case FCOE_OPCODE_READ_FCF:
3952 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3953 "2957 Handled SLI_CONFIG "
3954 "subsys_fcoe, opcode:x%x\n",
3955 opcode);
3956 rc = lpfc_bsg_sli_cfg_read_cmd_ext(phba, job,
3957 nemb_mse, dmabuf);
3958 break;
3959 case FCOE_OPCODE_ADD_FCF:
3960 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3961 "2958 Handled SLI_CONFIG "
3962 "subsys_fcoe, opcode:x%x\n",
3963 opcode);
3964 rc = lpfc_bsg_sli_cfg_write_cmd_ext(phba, job,
3965 nemb_mse, dmabuf);
3966 break;
3967 default:
3968 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3969 "2959 Reject SLI_CONFIG "
3970 "subsys_fcoe, opcode:x%x\n",
3971 opcode);
3972 rc = -EPERM;
3973 break;
3974 }
3975 } else if (subsys == SLI_CONFIG_SUBSYS_COMN) {
3976 switch (opcode) {
3977 case COMN_OPCODE_GET_CNTL_ADDL_ATTRIBUTES:
3978 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3979 "3106 Handled SLI_CONFIG "
3980 "subsys_fcoe, opcode:x%x\n",
3981 opcode);
3982 rc = lpfc_bsg_sli_cfg_read_cmd_ext(phba, job,
3983 nemb_mse, dmabuf);
3984 break;
3985 default:
3986 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3987 "3107 Reject SLI_CONFIG "
3988 "subsys_fcoe, opcode:x%x\n",
3989 opcode);
3990 rc = -EPERM;
3991 break;
3992 }
3993 } else {
3994 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
3995 "2977 Reject SLI_CONFIG "
3996 "subsys:x%d, opcode:x%x\n",
3997 subsys, opcode);
3998 rc = -EPERM;
3999 }
4000 } else {
4001 subsys = bsg_bf_get(lpfc_emb1_subcmnd_subsys,
4002 &sli_cfg_mbx->un.sli_config_emb1_subsys);
4003 opcode = bsg_bf_get(lpfc_emb1_subcmnd_opcode,
4004 &sli_cfg_mbx->un.sli_config_emb1_subsys);
4005 if (subsys == SLI_CONFIG_SUBSYS_COMN) {
4006 switch (opcode) {
4007 case COMN_OPCODE_READ_OBJECT:
4008 case COMN_OPCODE_READ_OBJECT_LIST:
4009 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4010 "2960 Handled SLI_CONFIG "
4011 "subsys_comn, opcode:x%x\n",
4012 opcode);
4013 rc = lpfc_bsg_sli_cfg_read_cmd_ext(phba, job,
4014 nemb_hbd, dmabuf);
4015 break;
4016 case COMN_OPCODE_WRITE_OBJECT:
4017 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4018 "2961 Handled SLI_CONFIG "
4019 "subsys_comn, opcode:x%x\n",
4020 opcode);
4021 rc = lpfc_bsg_sli_cfg_write_cmd_ext(phba, job,
4022 nemb_hbd, dmabuf);
4023 break;
4024 default:
4025 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4026 "2962 Not handled SLI_CONFIG "
4027 "subsys_comn, opcode:x%x\n",
4028 opcode);
4029 rc = SLI_CONFIG_NOT_HANDLED;
4030 break;
4031 }
4032 } else {
4033 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4034 "2978 Not handled SLI_CONFIG "
4035 "subsys:x%d, opcode:x%x\n",
4036 subsys, opcode);
4037 rc = SLI_CONFIG_NOT_HANDLED;
4038 }
4039 }
4040
4041 /* state reset on not handled new multi-buffer mailbox command */
4042 if (rc != SLI_CONFIG_HANDLED)
4043 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_IDLE;
4044
4045 return rc;
4046 }
4047
4048 /**
4049 * lpfc_bsg_mbox_ext_abort_req - request to abort mbox command with ext buffers
4050 * @phba: Pointer to HBA context object.
4051 *
4052 * This routine is for requesting to abort a pass-through mailbox command with
4053 * multiple external buffers due to error condition.
4054 **/
4055 static void
4056 lpfc_bsg_mbox_ext_abort(struct lpfc_hba *phba)
4057 {
4058 if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_PORT)
4059 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_ABTS;
4060 else
4061 lpfc_bsg_mbox_ext_session_reset(phba);
4062 return;
4063 }
4064
4065 /**
4066 * lpfc_bsg_read_ebuf_get - get the next mailbox read external buffer
4067 * @phba: Pointer to HBA context object.
4068 * @dmabuf: Pointer to a DMA buffer descriptor.
4069 *
4070 * This routine extracts the next mailbox read external buffer back to
4071 * user space through BSG.
4072 **/
4073 static int
4074 lpfc_bsg_read_ebuf_get(struct lpfc_hba *phba, struct fc_bsg_job *job)
4075 {
4076 struct lpfc_sli_config_mbox *sli_cfg_mbx;
4077 struct lpfc_dmabuf *dmabuf;
4078 uint8_t *pbuf;
4079 uint32_t size;
4080 uint32_t index;
4081
4082 index = phba->mbox_ext_buf_ctx.seqNum;
4083 phba->mbox_ext_buf_ctx.seqNum++;
4084
4085 sli_cfg_mbx = (struct lpfc_sli_config_mbox *)
4086 phba->mbox_ext_buf_ctx.mbx_dmabuf->virt;
4087
4088 if (phba->mbox_ext_buf_ctx.nembType == nemb_mse) {
4089 size = bsg_bf_get(lpfc_mbox_sli_config_mse_len,
4090 &sli_cfg_mbx->un.sli_config_emb0_subsys.mse[index]);
4091 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4092 "2963 SLI_CONFIG (mse) ext-buffer rd get "
4093 "buffer[%d], size:%d\n", index, size);
4094 } else {
4095 size = bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
4096 &sli_cfg_mbx->un.sli_config_emb1_subsys.hbd[index]);
4097 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4098 "2964 SLI_CONFIG (hbd) ext-buffer rd get "
4099 "buffer[%d], size:%d\n", index, size);
4100 }
4101 if (list_empty(&phba->mbox_ext_buf_ctx.ext_dmabuf_list))
4102 return -EPIPE;
4103 dmabuf = list_first_entry(&phba->mbox_ext_buf_ctx.ext_dmabuf_list,
4104 struct lpfc_dmabuf, list);
4105 list_del_init(&dmabuf->list);
4106
4107 /* after dma buffer descriptor setup */
4108 lpfc_idiag_mbxacc_dump_bsg_mbox(phba, phba->mbox_ext_buf_ctx.nembType,
4109 mbox_rd, dma_ebuf, sta_pos_addr,
4110 dmabuf, index);
4111
4112 pbuf = (uint8_t *)dmabuf->virt;
4113 job->reply->reply_payload_rcv_len =
4114 sg_copy_from_buffer(job->reply_payload.sg_list,
4115 job->reply_payload.sg_cnt,
4116 pbuf, size);
4117
4118 lpfc_bsg_dma_page_free(phba, dmabuf);
4119
4120 if (phba->mbox_ext_buf_ctx.seqNum == phba->mbox_ext_buf_ctx.numBuf) {
4121 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4122 "2965 SLI_CONFIG (hbd) ext-buffer rd mbox "
4123 "command session done\n");
4124 lpfc_bsg_mbox_ext_session_reset(phba);
4125 }
4126
4127 job->reply->result = 0;
4128 job->job_done(job);
4129
4130 return SLI_CONFIG_HANDLED;
4131 }
4132
4133 /**
4134 * lpfc_bsg_write_ebuf_set - set the next mailbox write external buffer
4135 * @phba: Pointer to HBA context object.
4136 * @dmabuf: Pointer to a DMA buffer descriptor.
4137 *
4138 * This routine sets up the next mailbox read external buffer obtained
4139 * from user space through BSG.
4140 **/
4141 static int
4142 lpfc_bsg_write_ebuf_set(struct lpfc_hba *phba, struct fc_bsg_job *job,
4143 struct lpfc_dmabuf *dmabuf)
4144 {
4145 struct lpfc_sli_config_mbox *sli_cfg_mbx;
4146 struct bsg_job_data *dd_data = NULL;
4147 LPFC_MBOXQ_t *pmboxq = NULL;
4148 MAILBOX_t *pmb;
4149 enum nemb_type nemb_tp;
4150 uint8_t *pbuf;
4151 uint32_t size;
4152 uint32_t index;
4153 int rc;
4154
4155 index = phba->mbox_ext_buf_ctx.seqNum;
4156 phba->mbox_ext_buf_ctx.seqNum++;
4157 nemb_tp = phba->mbox_ext_buf_ctx.nembType;
4158
4159 sli_cfg_mbx = (struct lpfc_sli_config_mbox *)
4160 phba->mbox_ext_buf_ctx.mbx_dmabuf->virt;
4161
4162 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
4163 if (!dd_data) {
4164 rc = -ENOMEM;
4165 goto job_error;
4166 }
4167
4168 pbuf = (uint8_t *)dmabuf->virt;
4169 size = job->request_payload.payload_len;
4170 sg_copy_to_buffer(job->request_payload.sg_list,
4171 job->request_payload.sg_cnt,
4172 pbuf, size);
4173
4174 if (phba->mbox_ext_buf_ctx.nembType == nemb_mse) {
4175 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4176 "2966 SLI_CONFIG (mse) ext-buffer wr set "
4177 "buffer[%d], size:%d\n",
4178 phba->mbox_ext_buf_ctx.seqNum, size);
4179
4180 } else {
4181 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4182 "2967 SLI_CONFIG (hbd) ext-buffer wr set "
4183 "buffer[%d], size:%d\n",
4184 phba->mbox_ext_buf_ctx.seqNum, size);
4185
4186 }
4187
4188 /* set up external buffer descriptor and add to external buffer list */
4189 lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, index,
4190 phba->mbox_ext_buf_ctx.mbx_dmabuf,
4191 dmabuf);
4192 list_add_tail(&dmabuf->list, &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
4193
4194 /* after write dma buffer */
4195 lpfc_idiag_mbxacc_dump_bsg_mbox(phba, phba->mbox_ext_buf_ctx.nembType,
4196 mbox_wr, dma_ebuf, sta_pos_addr,
4197 dmabuf, index);
4198
4199 if (phba->mbox_ext_buf_ctx.seqNum == phba->mbox_ext_buf_ctx.numBuf) {
4200 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4201 "2968 SLI_CONFIG ext-buffer wr all %d "
4202 "ebuffers received\n",
4203 phba->mbox_ext_buf_ctx.numBuf);
4204 /* mailbox command structure for base driver */
4205 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4206 if (!pmboxq) {
4207 rc = -ENOMEM;
4208 goto job_error;
4209 }
4210 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
4211 pbuf = (uint8_t *)phba->mbox_ext_buf_ctx.mbx_dmabuf->virt;
4212 pmb = &pmboxq->u.mb;
4213 memcpy(pmb, pbuf, sizeof(*pmb));
4214 pmb->mbxOwner = OWN_HOST;
4215 pmboxq->vport = phba->pport;
4216
4217 /* callback for multi-buffer write mailbox command */
4218 pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;
4219
4220 /* context fields to callback function */
4221 pmboxq->context1 = dd_data;
4222 dd_data->type = TYPE_MBOX;
4223 dd_data->context_un.mbox.pmboxq = pmboxq;
4224 dd_data->context_un.mbox.mb = (MAILBOX_t *)pbuf;
4225 dd_data->context_un.mbox.set_job = job;
4226 job->dd_data = dd_data;
4227
4228 /* state change */
4229 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
4230
4231 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
4232 if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
4233 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4234 "2969 Issued SLI_CONFIG ext-buffer "
4235 "maibox command, rc:x%x\n", rc);
4236 return SLI_CONFIG_HANDLED;
4237 }
4238 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4239 "2970 Failed to issue SLI_CONFIG ext-buffer "
4240 "maibox command, rc:x%x\n", rc);
4241 rc = -EPIPE;
4242 goto job_error;
4243 }
4244
4245 /* wait for additoinal external buffers */
4246 job->reply->result = 0;
4247 job->job_done(job);
4248 return SLI_CONFIG_HANDLED;
4249
4250 job_error:
4251 lpfc_bsg_dma_page_free(phba, dmabuf);
4252 kfree(dd_data);
4253
4254 return rc;
4255 }
4256
4257 /**
4258 * lpfc_bsg_handle_sli_cfg_ebuf - handle ext buffer with sli-cfg mailbox cmd
4259 * @phba: Pointer to HBA context object.
4260 * @mb: Pointer to a BSG mailbox object.
4261 * @dmabuff: Pointer to a DMA buffer descriptor.
4262 *
4263 * This routine handles the external buffer with SLI_CONFIG (0x9B) mailbox
4264 * command with multiple non-embedded external buffers.
4265 **/
4266 static int
4267 lpfc_bsg_handle_sli_cfg_ebuf(struct lpfc_hba *phba, struct fc_bsg_job *job,
4268 struct lpfc_dmabuf *dmabuf)
4269 {
4270 int rc;
4271
4272 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4273 "2971 SLI_CONFIG buffer (type:x%x)\n",
4274 phba->mbox_ext_buf_ctx.mboxType);
4275
4276 if (phba->mbox_ext_buf_ctx.mboxType == mbox_rd) {
4277 if (phba->mbox_ext_buf_ctx.state != LPFC_BSG_MBOX_DONE) {
4278 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4279 "2972 SLI_CONFIG rd buffer state "
4280 "mismatch:x%x\n",
4281 phba->mbox_ext_buf_ctx.state);
4282 lpfc_bsg_mbox_ext_abort(phba);
4283 return -EPIPE;
4284 }
4285 rc = lpfc_bsg_read_ebuf_get(phba, job);
4286 if (rc == SLI_CONFIG_HANDLED)
4287 lpfc_bsg_dma_page_free(phba, dmabuf);
4288 } else { /* phba->mbox_ext_buf_ctx.mboxType == mbox_wr */
4289 if (phba->mbox_ext_buf_ctx.state != LPFC_BSG_MBOX_HOST) {
4290 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4291 "2973 SLI_CONFIG wr buffer state "
4292 "mismatch:x%x\n",
4293 phba->mbox_ext_buf_ctx.state);
4294 lpfc_bsg_mbox_ext_abort(phba);
4295 return -EPIPE;
4296 }
4297 rc = lpfc_bsg_write_ebuf_set(phba, job, dmabuf);
4298 }
4299 return rc;
4300 }
4301
4302 /**
4303 * lpfc_bsg_handle_sli_cfg_ext - handle sli-cfg mailbox with external buffer
4304 * @phba: Pointer to HBA context object.
4305 * @mb: Pointer to a BSG mailbox object.
4306 * @dmabuff: Pointer to a DMA buffer descriptor.
4307 *
4308 * This routine checkes and handles non-embedded multi-buffer SLI_CONFIG
4309 * (0x9B) mailbox commands and external buffers.
4310 **/
4311 static int
4312 lpfc_bsg_handle_sli_cfg_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
4313 struct lpfc_dmabuf *dmabuf)
4314 {
4315 struct dfc_mbox_req *mbox_req;
4316 int rc = SLI_CONFIG_NOT_HANDLED;
4317
4318 mbox_req =
4319 (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
4320
4321 /* mbox command with/without single external buffer */
4322 if (mbox_req->extMboxTag == 0 && mbox_req->extSeqNum == 0)
4323 return rc;
4324
4325 /* mbox command and first external buffer */
4326 if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_IDLE) {
4327 if (mbox_req->extSeqNum == 1) {
4328 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4329 "2974 SLI_CONFIG mailbox: tag:%d, "
4330 "seq:%d\n", mbox_req->extMboxTag,
4331 mbox_req->extSeqNum);
4332 rc = lpfc_bsg_handle_sli_cfg_mbox(phba, job, dmabuf);
4333 return rc;
4334 } else
4335 goto sli_cfg_ext_error;
4336 }
4337
4338 /*
4339 * handle additional external buffers
4340 */
4341
4342 /* check broken pipe conditions */
4343 if (mbox_req->extMboxTag != phba->mbox_ext_buf_ctx.mbxTag)
4344 goto sli_cfg_ext_error;
4345 if (mbox_req->extSeqNum > phba->mbox_ext_buf_ctx.numBuf)
4346 goto sli_cfg_ext_error;
4347 if (mbox_req->extSeqNum != phba->mbox_ext_buf_ctx.seqNum + 1)
4348 goto sli_cfg_ext_error;
4349
4350 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4351 "2975 SLI_CONFIG mailbox external buffer: "
4352 "extSta:x%x, tag:%d, seq:%d\n",
4353 phba->mbox_ext_buf_ctx.state, mbox_req->extMboxTag,
4354 mbox_req->extSeqNum);
4355 rc = lpfc_bsg_handle_sli_cfg_ebuf(phba, job, dmabuf);
4356 return rc;
4357
4358 sli_cfg_ext_error:
4359 /* all other cases, broken pipe */
4360 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4361 "2976 SLI_CONFIG mailbox broken pipe: "
4362 "ctxSta:x%x, ctxNumBuf:%d "
4363 "ctxTag:%d, ctxSeq:%d, tag:%d, seq:%d\n",
4364 phba->mbox_ext_buf_ctx.state,
4365 phba->mbox_ext_buf_ctx.numBuf,
4366 phba->mbox_ext_buf_ctx.mbxTag,
4367 phba->mbox_ext_buf_ctx.seqNum,
4368 mbox_req->extMboxTag, mbox_req->extSeqNum);
4369
4370 lpfc_bsg_mbox_ext_session_reset(phba);
4371
4372 return -EPIPE;
4373 }
4374
4375 /**
4376 * lpfc_bsg_issue_mbox - issues a mailbox command on behalf of an app
4377 * @phba: Pointer to HBA context object.
4378 * @mb: Pointer to a mailbox object.
4379 * @vport: Pointer to a vport object.
4380 *
4381 * Allocate a tracking object, mailbox command memory, get a mailbox
4382 * from the mailbox pool, copy the caller mailbox command.
4383 *
4384 * If offline and the sli is active we need to poll for the command (port is
4385 * being reset) and com-plete the job, otherwise issue the mailbox command and
4386 * let our completion handler finish the command.
4387 **/
4388 static uint32_t
4389 lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
4390 struct lpfc_vport *vport)
4391 {
4392 LPFC_MBOXQ_t *pmboxq = NULL; /* internal mailbox queue */
4393 MAILBOX_t *pmb; /* shortcut to the pmboxq mailbox */
4394 /* a 4k buffer to hold the mb and extended data from/to the bsg */
4395 uint8_t *pmbx = NULL;
4396 struct bsg_job_data *dd_data = NULL; /* bsg data tracking structure */
4397 struct lpfc_dmabuf *dmabuf = NULL;
4398 struct dfc_mbox_req *mbox_req;
4399 struct READ_EVENT_LOG_VAR *rdEventLog;
4400 uint32_t transmit_length, receive_length, mode;
4401 struct lpfc_mbx_sli4_config *sli4_config;
4402 struct lpfc_mbx_nembed_cmd *nembed_sge;
4403 struct mbox_header *header;
4404 struct ulp_bde64 *bde;
4405 uint8_t *ext = NULL;
4406 int rc = 0;
4407 uint8_t *from;
4408 uint32_t size;
4409
4410
4411 /* in case no data is transferred */
4412 job->reply->reply_payload_rcv_len = 0;
4413
4414 /* sanity check to protect driver */
4415 if (job->reply_payload.payload_len > BSG_MBOX_SIZE ||
4416 job->request_payload.payload_len > BSG_MBOX_SIZE) {
4417 rc = -ERANGE;
4418 goto job_done;
4419 }
4420
4421 /*
4422 * Don't allow mailbox commands to be sent when blocked or when in
4423 * the middle of discovery
4424 */
4425 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
4426 rc = -EAGAIN;
4427 goto job_done;
4428 }
4429
4430 mbox_req =
4431 (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
4432
4433 /* check if requested extended data lengths are valid */
4434 if ((mbox_req->inExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t)) ||
4435 (mbox_req->outExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t))) {
4436 rc = -ERANGE;
4437 goto job_done;
4438 }
4439
4440 dmabuf = lpfc_bsg_dma_page_alloc(phba);
4441 if (!dmabuf || !dmabuf->virt) {
4442 rc = -ENOMEM;
4443 goto job_done;
4444 }
4445
4446 /* Get the mailbox command or external buffer from BSG */
4447 pmbx = (uint8_t *)dmabuf->virt;
4448 size = job->request_payload.payload_len;
4449 sg_copy_to_buffer(job->request_payload.sg_list,
4450 job->request_payload.sg_cnt, pmbx, size);
4451
4452 /* Handle possible SLI_CONFIG with non-embedded payloads */
4453 if (phba->sli_rev == LPFC_SLI_REV4) {
4454 rc = lpfc_bsg_handle_sli_cfg_ext(phba, job, dmabuf);
4455 if (rc == SLI_CONFIG_HANDLED)
4456 goto job_cont;
4457 if (rc)
4458 goto job_done;
4459 /* SLI_CONFIG_NOT_HANDLED for other mailbox commands */
4460 }
4461
4462 rc = lpfc_bsg_check_cmd_access(phba, (MAILBOX_t *)pmbx, vport);
4463 if (rc != 0)
4464 goto job_done; /* must be negative */
4465
4466 /* allocate our bsg tracking structure */
4467 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
4468 if (!dd_data) {
4469 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
4470 "2727 Failed allocation of dd_data\n");
4471 rc = -ENOMEM;
4472 goto job_done;
4473 }
4474
4475 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4476 if (!pmboxq) {
4477 rc = -ENOMEM;
4478 goto job_done;
4479 }
4480 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
4481
4482 pmb = &pmboxq->u.mb;
4483 memcpy(pmb, pmbx, sizeof(*pmb));
4484 pmb->mbxOwner = OWN_HOST;
4485 pmboxq->vport = vport;
4486
4487 /* If HBA encountered an error attention, allow only DUMP
4488 * or RESTART mailbox commands until the HBA is restarted.
4489 */
4490 if (phba->pport->stopped &&
4491 pmb->mbxCommand != MBX_DUMP_MEMORY &&
4492 pmb->mbxCommand != MBX_RESTART &&
4493 pmb->mbxCommand != MBX_WRITE_VPARMS &&
4494 pmb->mbxCommand != MBX_WRITE_WWN)
4495 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
4496 "2797 mbox: Issued mailbox cmd "
4497 "0x%x while in stopped state.\n",
4498 pmb->mbxCommand);
4499
4500 /* extended mailbox commands will need an extended buffer */
4501 if (mbox_req->inExtWLen || mbox_req->outExtWLen) {
4502 from = pmbx;
4503 ext = from + sizeof(MAILBOX_t);
4504 pmboxq->context2 = ext;
4505 pmboxq->in_ext_byte_len =
4506 mbox_req->inExtWLen * sizeof(uint32_t);
4507 pmboxq->out_ext_byte_len =
4508 mbox_req->outExtWLen * sizeof(uint32_t);
4509 pmboxq->mbox_offset_word = mbox_req->mbOffset;
4510 }
4511
4512 /* biu diag will need a kernel buffer to transfer the data
4513 * allocate our own buffer and setup the mailbox command to
4514 * use ours
4515 */
4516 if (pmb->mbxCommand == MBX_RUN_BIU_DIAG64) {
4517 transmit_length = pmb->un.varWords[1];
4518 receive_length = pmb->un.varWords[4];
4519 /* transmit length cannot be greater than receive length or
4520 * mailbox extension size
4521 */
4522 if ((transmit_length > receive_length) ||
4523 (transmit_length > BSG_MBOX_SIZE - sizeof(MAILBOX_t))) {
4524 rc = -ERANGE;
4525 goto job_done;
4526 }
4527 pmb->un.varBIUdiag.un.s2.xmit_bde64.addrHigh =
4528 putPaddrHigh(dmabuf->phys + sizeof(MAILBOX_t));
4529 pmb->un.varBIUdiag.un.s2.xmit_bde64.addrLow =
4530 putPaddrLow(dmabuf->phys + sizeof(MAILBOX_t));
4531
4532 pmb->un.varBIUdiag.un.s2.rcv_bde64.addrHigh =
4533 putPaddrHigh(dmabuf->phys + sizeof(MAILBOX_t)
4534 + pmb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeSize);
4535 pmb->un.varBIUdiag.un.s2.rcv_bde64.addrLow =
4536 putPaddrLow(dmabuf->phys + sizeof(MAILBOX_t)
4537 + pmb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeSize);
4538 } else if (pmb->mbxCommand == MBX_READ_EVENT_LOG) {
4539 rdEventLog = &pmb->un.varRdEventLog;
4540 receive_length = rdEventLog->rcv_bde64.tus.f.bdeSize;
4541 mode = bf_get(lpfc_event_log, rdEventLog);
4542
4543 /* receive length cannot be greater than mailbox
4544 * extension size
4545 */
4546 if (receive_length > BSG_MBOX_SIZE - sizeof(MAILBOX_t)) {
4547 rc = -ERANGE;
4548 goto job_done;
4549 }
4550
4551 /* mode zero uses a bde like biu diags command */
4552 if (mode == 0) {
4553 pmb->un.varWords[3] = putPaddrLow(dmabuf->phys
4554 + sizeof(MAILBOX_t));
4555 pmb->un.varWords[4] = putPaddrHigh(dmabuf->phys
4556 + sizeof(MAILBOX_t));
4557 }
4558 } else if (phba->sli_rev == LPFC_SLI_REV4) {
4559 if (pmb->mbxCommand == MBX_DUMP_MEMORY) {
4560 /* rebuild the command for sli4 using our own buffers
4561 * like we do for biu diags
4562 */
4563 receive_length = pmb->un.varWords[2];
4564 /* receive length cannot be greater than mailbox
4565 * extension size
4566 */
4567 if (receive_length == 0) {
4568 rc = -ERANGE;
4569 goto job_done;
4570 }
4571 pmb->un.varWords[3] = putPaddrLow(dmabuf->phys
4572 + sizeof(MAILBOX_t));
4573 pmb->un.varWords[4] = putPaddrHigh(dmabuf->phys
4574 + sizeof(MAILBOX_t));
4575 } else if ((pmb->mbxCommand == MBX_UPDATE_CFG) &&
4576 pmb->un.varUpdateCfg.co) {
4577 bde = (struct ulp_bde64 *)&pmb->un.varWords[4];
4578
4579 /* bde size cannot be greater than mailbox ext size */
4580 if (bde->tus.f.bdeSize >
4581 BSG_MBOX_SIZE - sizeof(MAILBOX_t)) {
4582 rc = -ERANGE;
4583 goto job_done;
4584 }
4585 bde->addrHigh = putPaddrHigh(dmabuf->phys
4586 + sizeof(MAILBOX_t));
4587 bde->addrLow = putPaddrLow(dmabuf->phys
4588 + sizeof(MAILBOX_t));
4589 } else if (pmb->mbxCommand == MBX_SLI4_CONFIG) {
4590 /* Handling non-embedded SLI_CONFIG mailbox command */
4591 sli4_config = &pmboxq->u.mqe.un.sli4_config;
4592 if (!bf_get(lpfc_mbox_hdr_emb,
4593 &sli4_config->header.cfg_mhdr)) {
4594 /* rebuild the command for sli4 using our
4595 * own buffers like we do for biu diags
4596 */
4597 header = (struct mbox_header *)
4598 &pmb->un.varWords[0];
4599 nembed_sge = (struct lpfc_mbx_nembed_cmd *)
4600 &pmb->un.varWords[0];
4601 receive_length = nembed_sge->sge[0].length;
4602
4603 /* receive length cannot be greater than
4604 * mailbox extension size
4605 */
4606 if ((receive_length == 0) ||
4607 (receive_length >
4608 BSG_MBOX_SIZE - sizeof(MAILBOX_t))) {
4609 rc = -ERANGE;
4610 goto job_done;
4611 }
4612
4613 nembed_sge->sge[0].pa_hi =
4614 putPaddrHigh(dmabuf->phys
4615 + sizeof(MAILBOX_t));
4616 nembed_sge->sge[0].pa_lo =
4617 putPaddrLow(dmabuf->phys
4618 + sizeof(MAILBOX_t));
4619 }
4620 }
4621 }
4622
4623 dd_data->context_un.mbox.dmabuffers = dmabuf;
4624
4625 /* setup wake call as IOCB callback */
4626 pmboxq->mbox_cmpl = lpfc_bsg_issue_mbox_cmpl;
4627
4628 /* setup context field to pass wait_queue pointer to wake function */
4629 pmboxq->context1 = dd_data;
4630 dd_data->type = TYPE_MBOX;
4631 dd_data->context_un.mbox.pmboxq = pmboxq;
4632 dd_data->context_un.mbox.mb = (MAILBOX_t *)pmbx;
4633 dd_data->context_un.mbox.set_job = job;
4634 dd_data->context_un.mbox.ext = ext;
4635 dd_data->context_un.mbox.mbOffset = mbox_req->mbOffset;
4636 dd_data->context_un.mbox.inExtWLen = mbox_req->inExtWLen;
4637 dd_data->context_un.mbox.outExtWLen = mbox_req->outExtWLen;
4638 job->dd_data = dd_data;
4639
4640 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4641 (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE))) {
4642 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4643 if (rc != MBX_SUCCESS) {
4644 rc = (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
4645 goto job_done;
4646 }
4647
4648 /* job finished, copy the data */
4649 memcpy(pmbx, pmb, sizeof(*pmb));
4650 job->reply->reply_payload_rcv_len =
4651 sg_copy_from_buffer(job->reply_payload.sg_list,
4652 job->reply_payload.sg_cnt,
4653 pmbx, size);
4654 /* not waiting mbox already done */
4655 rc = 0;
4656 goto job_done;
4657 }
4658
4659 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
4660 if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY))
4661 return 1; /* job started */
4662
4663 job_done:
4664 /* common exit for error or job completed inline */
4665 if (pmboxq)
4666 mempool_free(pmboxq, phba->mbox_mem_pool);
4667 lpfc_bsg_dma_page_free(phba, dmabuf);
4668 kfree(dd_data);
4669
4670 job_cont:
4671 return rc;
4672 }
4673
4674 /**
4675 * lpfc_bsg_mbox_cmd - process an fc bsg LPFC_BSG_VENDOR_MBOX command
4676 * @job: MBOX fc_bsg_job for LPFC_BSG_VENDOR_MBOX.
4677 **/
4678 static int
4679 lpfc_bsg_mbox_cmd(struct fc_bsg_job *job)
4680 {
4681 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
4682 struct lpfc_hba *phba = vport->phba;
4683 struct dfc_mbox_req *mbox_req;
4684 int rc = 0;
4685
4686 /* mix-and-match backward compatibility */
4687 job->reply->reply_payload_rcv_len = 0;
4688 if (job->request_len <
4689 sizeof(struct fc_bsg_request) + sizeof(struct dfc_mbox_req)) {
4690 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4691 "2737 Mix-and-match backward compability "
4692 "between MBOX_REQ old size:%d and "
4693 "new request size:%d\n",
4694 (int)(job->request_len -
4695 sizeof(struct fc_bsg_request)),
4696 (int)sizeof(struct dfc_mbox_req));
4697 mbox_req = (struct dfc_mbox_req *)
4698 job->request->rqst_data.h_vendor.vendor_cmd;
4699 mbox_req->extMboxTag = 0;
4700 mbox_req->extSeqNum = 0;
4701 }
4702
4703 rc = lpfc_bsg_issue_mbox(phba, job, vport);
4704
4705 if (rc == 0) {
4706 /* job done */
4707 job->reply->result = 0;
4708 job->dd_data = NULL;
4709 job->job_done(job);
4710 } else if (rc == 1)
4711 /* job submitted, will complete later*/
4712 rc = 0; /* return zero, no error */
4713 else {
4714 /* some error occurred */
4715 job->reply->result = rc;
4716 job->dd_data = NULL;
4717 }
4718
4719 return rc;
4720 }
4721
4722 /**
4723 * lpfc_bsg_menlo_cmd_cmp - lpfc_menlo_cmd completion handler
4724 * @phba: Pointer to HBA context object.
4725 * @cmdiocbq: Pointer to command iocb.
4726 * @rspiocbq: Pointer to response iocb.
4727 *
4728 * This function is the completion handler for iocbs issued using
4729 * lpfc_menlo_cmd function. This function is called by the
4730 * ring event handler function without any lock held. This function
4731 * can be called from both worker thread context and interrupt
4732 * context. This function also can be called from another thread which
4733 * cleans up the SLI layer objects.
4734 * This function copies the contents of the response iocb to the
4735 * response iocb memory object provided by the caller of
4736 * lpfc_sli_issue_iocb_wait and then wakes up the thread which
4737 * sleeps for the iocb completion.
4738 **/
4739 static void
4740 lpfc_bsg_menlo_cmd_cmp(struct lpfc_hba *phba,
4741 struct lpfc_iocbq *cmdiocbq,
4742 struct lpfc_iocbq *rspiocbq)
4743 {
4744 struct bsg_job_data *dd_data;
4745 struct fc_bsg_job *job;
4746 IOCB_t *rsp;
4747 struct lpfc_dmabuf *bmp;
4748 struct lpfc_bsg_menlo *menlo;
4749 unsigned long flags;
4750 struct menlo_response *menlo_resp;
4751 int rc = 0;
4752
4753 spin_lock_irqsave(&phba->ct_ev_lock, flags);
4754 dd_data = cmdiocbq->context1;
4755 if (!dd_data) {
4756 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
4757 return;
4758 }
4759
4760 menlo = &dd_data->context_un.menlo;
4761 job = menlo->set_job;
4762 job->dd_data = NULL; /* so timeout handler does not reply */
4763
4764 spin_lock(&phba->hbalock);
4765 cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
4766 if (cmdiocbq->context2 && rspiocbq)
4767 memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
4768 &rspiocbq->iocb, sizeof(IOCB_t));
4769 spin_unlock(&phba->hbalock);
4770
4771 bmp = menlo->bmp;
4772 rspiocbq = menlo->rspiocbq;
4773 rsp = &rspiocbq->iocb;
4774
4775 pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
4776 job->request_payload.sg_cnt, DMA_TO_DEVICE);
4777 pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
4778 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
4779
4780 /* always return the xri, this would be used in the case
4781 * of a menlo download to allow the data to be sent as a continuation
4782 * of the exchange.
4783 */
4784 menlo_resp = (struct menlo_response *)
4785 job->reply->reply_data.vendor_reply.vendor_rsp;
4786 menlo_resp->xri = rsp->ulpContext;
4787 if (rsp->ulpStatus) {
4788 if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
4789 switch (rsp->un.ulpWord[4] & 0xff) {
4790 case IOERR_SEQUENCE_TIMEOUT:
4791 rc = -ETIMEDOUT;
4792 break;
4793 case IOERR_INVALID_RPI:
4794 rc = -EFAULT;
4795 break;
4796 default:
4797 rc = -EACCES;
4798 break;
4799 }
4800 } else
4801 rc = -EACCES;
4802 } else
4803 job->reply->reply_payload_rcv_len =
4804 rsp->un.genreq64.bdl.bdeSize;
4805
4806 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
4807 lpfc_sli_release_iocbq(phba, rspiocbq);
4808 lpfc_sli_release_iocbq(phba, cmdiocbq);
4809 kfree(bmp);
4810 kfree(dd_data);
4811 /* make error code available to userspace */
4812 job->reply->result = rc;
4813 /* complete the job back to userspace */
4814 job->job_done(job);
4815 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
4816 return;
4817 }
4818
4819 /**
4820 * lpfc_menlo_cmd - send an ioctl for menlo hardware
4821 * @job: fc_bsg_job to handle
4822 *
4823 * This function issues a gen request 64 CR ioctl for all menlo cmd requests,
4824 * all the command completions will return the xri for the command.
4825 * For menlo data requests a gen request 64 CX is used to continue the exchange
4826 * supplied in the menlo request header xri field.
4827 **/
4828 static int
4829 lpfc_menlo_cmd(struct fc_bsg_job *job)
4830 {
4831 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
4832 struct lpfc_hba *phba = vport->phba;
4833 struct lpfc_iocbq *cmdiocbq, *rspiocbq;
4834 IOCB_t *cmd, *rsp;
4835 int rc = 0;
4836 struct menlo_command *menlo_cmd;
4837 struct menlo_response *menlo_resp;
4838 struct lpfc_dmabuf *bmp = NULL;
4839 int request_nseg;
4840 int reply_nseg;
4841 struct scatterlist *sgel = NULL;
4842 int numbde;
4843 dma_addr_t busaddr;
4844 struct bsg_job_data *dd_data;
4845 struct ulp_bde64 *bpl = NULL;
4846
4847 /* in case no data is returned return just the return code */
4848 job->reply->reply_payload_rcv_len = 0;
4849
4850 if (job->request_len <
4851 sizeof(struct fc_bsg_request) +
4852 sizeof(struct menlo_command)) {
4853 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
4854 "2784 Received MENLO_CMD request below "
4855 "minimum size\n");
4856 rc = -ERANGE;
4857 goto no_dd_data;
4858 }
4859
4860 if (job->reply_len <
4861 sizeof(struct fc_bsg_request) + sizeof(struct menlo_response)) {
4862 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
4863 "2785 Received MENLO_CMD reply below "
4864 "minimum size\n");
4865 rc = -ERANGE;
4866 goto no_dd_data;
4867 }
4868
4869 if (!(phba->menlo_flag & HBA_MENLO_SUPPORT)) {
4870 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
4871 "2786 Adapter does not support menlo "
4872 "commands\n");
4873 rc = -EPERM;
4874 goto no_dd_data;
4875 }
4876
4877 menlo_cmd = (struct menlo_command *)
4878 job->request->rqst_data.h_vendor.vendor_cmd;
4879
4880 menlo_resp = (struct menlo_response *)
4881 job->reply->reply_data.vendor_reply.vendor_rsp;
4882
4883 /* allocate our bsg tracking structure */
4884 dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
4885 if (!dd_data) {
4886 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
4887 "2787 Failed allocation of dd_data\n");
4888 rc = -ENOMEM;
4889 goto no_dd_data;
4890 }
4891
4892 bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4893 if (!bmp) {
4894 rc = -ENOMEM;
4895 goto free_dd;
4896 }
4897
4898 cmdiocbq = lpfc_sli_get_iocbq(phba);
4899 if (!cmdiocbq) {
4900 rc = -ENOMEM;
4901 goto free_bmp;
4902 }
4903
4904 rspiocbq = lpfc_sli_get_iocbq(phba);
4905 if (!rspiocbq) {
4906 rc = -ENOMEM;
4907 goto free_cmdiocbq;
4908 }
4909
4910 rsp = &rspiocbq->iocb;
4911
4912 bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
4913 if (!bmp->virt) {
4914 rc = -ENOMEM;
4915 goto free_rspiocbq;
4916 }
4917
4918 INIT_LIST_HEAD(&bmp->list);
4919 bpl = (struct ulp_bde64 *) bmp->virt;
4920 request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
4921 job->request_payload.sg_cnt, DMA_TO_DEVICE);
4922 for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
4923 busaddr = sg_dma_address(sgel);
4924 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
4925 bpl->tus.f.bdeSize = sg_dma_len(sgel);
4926 bpl->tus.w = cpu_to_le32(bpl->tus.w);
4927 bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
4928 bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
4929 bpl++;
4930 }
4931
4932 reply_nseg = pci_map_sg(phba->pcidev, job->reply_payload.sg_list,
4933 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
4934 for_each_sg(job->reply_payload.sg_list, sgel, reply_nseg, numbde) {
4935 busaddr = sg_dma_address(sgel);
4936 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
4937 bpl->tus.f.bdeSize = sg_dma_len(sgel);
4938 bpl->tus.w = cpu_to_le32(bpl->tus.w);
4939 bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
4940 bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
4941 bpl++;
4942 }
4943
4944 cmd = &cmdiocbq->iocb;
4945 cmd->un.genreq64.bdl.ulpIoTag32 = 0;
4946 cmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
4947 cmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
4948 cmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
4949 cmd->un.genreq64.bdl.bdeSize =
4950 (request_nseg + reply_nseg) * sizeof(struct ulp_bde64);
4951 cmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
4952 cmd->un.genreq64.w5.hcsw.Dfctl = 0;
4953 cmd->un.genreq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CMD;
4954 cmd->un.genreq64.w5.hcsw.Type = MENLO_TRANSPORT_TYPE; /* 0xfe */
4955 cmd->ulpBdeCount = 1;
4956 cmd->ulpClass = CLASS3;
4957 cmd->ulpOwner = OWN_CHIP;
4958 cmd->ulpLe = 1; /* Limited Edition */
4959 cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
4960 cmdiocbq->vport = phba->pport;
4961 /* We want the firmware to timeout before we do */
4962 cmd->ulpTimeout = MENLO_TIMEOUT - 5;
4963 cmdiocbq->context3 = bmp;
4964 cmdiocbq->context2 = rspiocbq;
4965 cmdiocbq->iocb_cmpl = lpfc_bsg_menlo_cmd_cmp;
4966 cmdiocbq->context1 = dd_data;
4967 cmdiocbq->context2 = rspiocbq;
4968 if (menlo_cmd->cmd == LPFC_BSG_VENDOR_MENLO_CMD) {
4969 cmd->ulpCommand = CMD_GEN_REQUEST64_CR;
4970 cmd->ulpPU = MENLO_PU; /* 3 */
4971 cmd->un.ulpWord[4] = MENLO_DID; /* 0x0000FC0E */
4972 cmd->ulpContext = MENLO_CONTEXT; /* 0 */
4973 } else {
4974 cmd->ulpCommand = CMD_GEN_REQUEST64_CX;
4975 cmd->ulpPU = 1;
4976 cmd->un.ulpWord[4] = 0;
4977 cmd->ulpContext = menlo_cmd->xri;
4978 }
4979
4980 dd_data->type = TYPE_MENLO;
4981 dd_data->context_un.menlo.cmdiocbq = cmdiocbq;
4982 dd_data->context_un.menlo.rspiocbq = rspiocbq;
4983 dd_data->context_un.menlo.set_job = job;
4984 dd_data->context_un.menlo.bmp = bmp;
4985
4986 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq,
4987 MENLO_TIMEOUT - 5);
4988 if (rc == IOCB_SUCCESS)
4989 return 0; /* done for now */
4990
4991 /* iocb failed so cleanup */
4992 pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
4993 job->request_payload.sg_cnt, DMA_TO_DEVICE);
4994 pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
4995 job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
4996
4997 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
4998
4999 free_rspiocbq:
5000 lpfc_sli_release_iocbq(phba, rspiocbq);
5001 free_cmdiocbq:
5002 lpfc_sli_release_iocbq(phba, cmdiocbq);
5003 free_bmp:
5004 kfree(bmp);
5005 free_dd:
5006 kfree(dd_data);
5007 no_dd_data:
5008 /* make error code available to userspace */
5009 job->reply->result = rc;
5010 job->dd_data = NULL;
5011 return rc;
5012 }
5013
5014 /**
5015 * lpfc_bsg_hst_vendor - process a vendor-specific fc_bsg_job
5016 * @job: fc_bsg_job to handle
5017 **/
5018 static int
5019 lpfc_bsg_hst_vendor(struct fc_bsg_job *job)
5020 {
5021 int command = job->request->rqst_data.h_vendor.vendor_cmd[0];
5022 int rc;
5023
5024 switch (command) {
5025 case LPFC_BSG_VENDOR_SET_CT_EVENT:
5026 rc = lpfc_bsg_hba_set_event(job);
5027 break;
5028 case LPFC_BSG_VENDOR_GET_CT_EVENT:
5029 rc = lpfc_bsg_hba_get_event(job);
5030 break;
5031 case LPFC_BSG_VENDOR_SEND_MGMT_RESP:
5032 rc = lpfc_bsg_send_mgmt_rsp(job);
5033 break;
5034 case LPFC_BSG_VENDOR_DIAG_MODE:
5035 rc = lpfc_bsg_diag_loopback_mode(job);
5036 break;
5037 case LPFC_BSG_VENDOR_DIAG_MODE_END:
5038 rc = lpfc_sli4_bsg_diag_mode_end(job);
5039 break;
5040 case LPFC_BSG_VENDOR_DIAG_RUN_LOOPBACK:
5041 rc = lpfc_bsg_diag_loopback_run(job);
5042 break;
5043 case LPFC_BSG_VENDOR_LINK_DIAG_TEST:
5044 rc = lpfc_sli4_bsg_link_diag_test(job);
5045 break;
5046 case LPFC_BSG_VENDOR_GET_MGMT_REV:
5047 rc = lpfc_bsg_get_dfc_rev(job);
5048 break;
5049 case LPFC_BSG_VENDOR_MBOX:
5050 rc = lpfc_bsg_mbox_cmd(job);
5051 break;
5052 case LPFC_BSG_VENDOR_MENLO_CMD:
5053 case LPFC_BSG_VENDOR_MENLO_DATA:
5054 rc = lpfc_menlo_cmd(job);
5055 break;
5056 default:
5057 rc = -EINVAL;
5058 job->reply->reply_payload_rcv_len = 0;
5059 /* make error code available to userspace */
5060 job->reply->result = rc;
5061 break;
5062 }
5063
5064 return rc;
5065 }
5066
5067 /**
5068 * lpfc_bsg_request - handle a bsg request from the FC transport
5069 * @job: fc_bsg_job to handle
5070 **/
5071 int
5072 lpfc_bsg_request(struct fc_bsg_job *job)
5073 {
5074 uint32_t msgcode;
5075 int rc;
5076
5077 msgcode = job->request->msgcode;
5078 switch (msgcode) {
5079 case FC_BSG_HST_VENDOR:
5080 rc = lpfc_bsg_hst_vendor(job);
5081 break;
5082 case FC_BSG_RPT_ELS:
5083 rc = lpfc_bsg_rport_els(job);
5084 break;
5085 case FC_BSG_RPT_CT:
5086 rc = lpfc_bsg_send_mgmt_cmd(job);
5087 break;
5088 default:
5089 rc = -EINVAL;
5090 job->reply->reply_payload_rcv_len = 0;
5091 /* make error code available to userspace */
5092 job->reply->result = rc;
5093 break;
5094 }
5095
5096 return rc;
5097 }
5098
5099 /**
5100 * lpfc_bsg_timeout - handle timeout of a bsg request from the FC transport
5101 * @job: fc_bsg_job that has timed out
5102 *
5103 * This function just aborts the job's IOCB. The aborted IOCB will return to
5104 * the waiting function which will handle passing the error back to userspace
5105 **/
5106 int
5107 lpfc_bsg_timeout(struct fc_bsg_job *job)
5108 {
5109 struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
5110 struct lpfc_hba *phba = vport->phba;
5111 struct lpfc_iocbq *cmdiocb;
5112 struct lpfc_bsg_event *evt;
5113 struct lpfc_bsg_iocb *iocb;
5114 struct lpfc_bsg_mbox *mbox;
5115 struct lpfc_bsg_menlo *menlo;
5116 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
5117 struct bsg_job_data *dd_data;
5118 unsigned long flags;
5119
5120 spin_lock_irqsave(&phba->ct_ev_lock, flags);
5121 dd_data = (struct bsg_job_data *)job->dd_data;
5122 /* timeout and completion crossed paths if no dd_data */
5123 if (!dd_data) {
5124 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5125 return 0;
5126 }
5127
5128 switch (dd_data->type) {
5129 case TYPE_IOCB:
5130 iocb = &dd_data->context_un.iocb;
5131 cmdiocb = iocb->cmdiocbq;
5132 /* hint to completion handler that the job timed out */
5133 job->reply->result = -EAGAIN;
5134 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5135 /* this will call our completion handler */
5136 spin_lock_irq(&phba->hbalock);
5137 lpfc_sli_issue_abort_iotag(phba, pring, cmdiocb);
5138 spin_unlock_irq(&phba->hbalock);
5139 break;
5140 case TYPE_EVT:
5141 evt = dd_data->context_un.evt;
5142 /* this event has no job anymore */
5143 evt->set_job = NULL;
5144 job->dd_data = NULL;
5145 job->reply->reply_payload_rcv_len = 0;
5146 /* Return -EAGAIN which is our way of signallying the
5147 * app to retry.
5148 */
5149 job->reply->result = -EAGAIN;
5150 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5151 job->job_done(job);
5152 break;
5153 case TYPE_MBOX:
5154 mbox = &dd_data->context_un.mbox;
5155 /* this mbox has no job anymore */
5156 mbox->set_job = NULL;
5157 job->dd_data = NULL;
5158 job->reply->reply_payload_rcv_len = 0;
5159 job->reply->result = -EAGAIN;
5160 /* the mbox completion handler can now be run */
5161 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5162 job->job_done(job);
5163 if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_PORT)
5164 phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_ABTS;
5165 break;
5166 case TYPE_MENLO:
5167 menlo = &dd_data->context_un.menlo;
5168 cmdiocb = menlo->cmdiocbq;
5169 /* hint to completion handler that the job timed out */
5170 job->reply->result = -EAGAIN;
5171 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5172 /* this will call our completion handler */
5173 spin_lock_irq(&phba->hbalock);
5174 lpfc_sli_issue_abort_iotag(phba, pring, cmdiocb);
5175 spin_unlock_irq(&phba->hbalock);
5176 break;
5177 default:
5178 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
5179 break;
5180 }
5181
5182 /* scsi transport fc fc_bsg_job_timeout expects a zero return code,
5183 * otherwise an error message will be displayed on the console
5184 * so always return success (zero)
5185 */
5186 return 0;
5187 }