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