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