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