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