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