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