1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2015 Emulex. All rights reserved. * 5 * EMULEX and SLI are trademarks of Emulex. * 6 * www.emulex.com * 7 * Portions Copyright (C) 2004-2005 Christoph Hellwig * 8 * * 9 * This program is free software; you can redistribute it and/or * 10 * modify it under the terms of version 2 of the GNU General * 11 * Public License as published by the Free Software Foundation. * 12 * This program is distributed in the hope that it will be useful. * 13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * 14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * 15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * 16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * 17 * TO BE LEGALLY INVALID. See the GNU General Public License for * 18 * more details, a copy of which can be found in the file COPYING * 19 * included with this package. * 20 *******************************************************************/ 21 #include <linux/pci.h> 22 #include <linux/slab.h> 23 #include <linux/interrupt.h> 24 #include <linux/export.h> 25 #include <linux/delay.h> 26 #include <asm/unaligned.h> 27 #include <linux/crc-t10dif.h> 28 #include <net/checksum.h> 29 30 #include <scsi/scsi.h> 31 #include <scsi/scsi_device.h> 32 #include <scsi/scsi_eh.h> 33 #include <scsi/scsi_host.h> 34 #include <scsi/scsi_tcq.h> 35 #include <scsi/scsi_transport_fc.h> 36 37 #include "lpfc_version.h" 38 #include "lpfc_hw4.h" 39 #include "lpfc_hw.h" 40 #include "lpfc_sli.h" 41 #include "lpfc_sli4.h" 42 #include "lpfc_nl.h" 43 #include "lpfc_disc.h" 44 #include "lpfc.h" 45 #include "lpfc_scsi.h" 46 #include "lpfc_logmsg.h" 47 #include "lpfc_crtn.h" 48 #include "lpfc_vport.h" 49 50 #define LPFC_RESET_WAIT 2 51 #define LPFC_ABORT_WAIT 2 52 53 int _dump_buf_done = 1; 54 55 static char *dif_op_str[] = { 56 "PROT_NORMAL", 57 "PROT_READ_INSERT", 58 "PROT_WRITE_STRIP", 59 "PROT_READ_STRIP", 60 "PROT_WRITE_INSERT", 61 "PROT_READ_PASS", 62 "PROT_WRITE_PASS", 63 }; 64 65 struct scsi_dif_tuple { 66 __be16 guard_tag; /* Checksum */ 67 __be16 app_tag; /* Opaque storage */ 68 __be32 ref_tag; /* Target LBA or indirect LBA */ 69 }; 70 71 static struct lpfc_rport_data * 72 lpfc_rport_data_from_scsi_device(struct scsi_device *sdev) 73 { 74 struct lpfc_vport *vport = (struct lpfc_vport *)sdev->host->hostdata; 75 76 if (vport->phba->cfg_fof) 77 return ((struct lpfc_device_data *)sdev->hostdata)->rport_data; 78 else 79 return (struct lpfc_rport_data *)sdev->hostdata; 80 } 81 82 static void 83 lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb); 84 static void 85 lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb); 86 static int 87 lpfc_prot_group_type(struct lpfc_hba *phba, struct scsi_cmnd *sc); 88 89 static void 90 lpfc_debug_save_data(struct lpfc_hba *phba, struct scsi_cmnd *cmnd) 91 { 92 void *src, *dst; 93 struct scatterlist *sgde = scsi_sglist(cmnd); 94 95 if (!_dump_buf_data) { 96 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 97 "9050 BLKGRD: ERROR %s _dump_buf_data is NULL\n", 98 __func__); 99 return; 100 } 101 102 103 if (!sgde) { 104 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 105 "9051 BLKGRD: ERROR: data scatterlist is null\n"); 106 return; 107 } 108 109 dst = (void *) _dump_buf_data; 110 while (sgde) { 111 src = sg_virt(sgde); 112 memcpy(dst, src, sgde->length); 113 dst += sgde->length; 114 sgde = sg_next(sgde); 115 } 116 } 117 118 static void 119 lpfc_debug_save_dif(struct lpfc_hba *phba, struct scsi_cmnd *cmnd) 120 { 121 void *src, *dst; 122 struct scatterlist *sgde = scsi_prot_sglist(cmnd); 123 124 if (!_dump_buf_dif) { 125 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 126 "9052 BLKGRD: ERROR %s _dump_buf_data is NULL\n", 127 __func__); 128 return; 129 } 130 131 if (!sgde) { 132 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 133 "9053 BLKGRD: ERROR: prot scatterlist is null\n"); 134 return; 135 } 136 137 dst = _dump_buf_dif; 138 while (sgde) { 139 src = sg_virt(sgde); 140 memcpy(dst, src, sgde->length); 141 dst += sgde->length; 142 sgde = sg_next(sgde); 143 } 144 } 145 146 static inline unsigned 147 lpfc_cmd_blksize(struct scsi_cmnd *sc) 148 { 149 return sc->device->sector_size; 150 } 151 152 #define LPFC_CHECK_PROTECT_GUARD 1 153 #define LPFC_CHECK_PROTECT_REF 2 154 static inline unsigned 155 lpfc_cmd_protect(struct scsi_cmnd *sc, int flag) 156 { 157 return 1; 158 } 159 160 static inline unsigned 161 lpfc_cmd_guard_csum(struct scsi_cmnd *sc) 162 { 163 if (lpfc_prot_group_type(NULL, sc) == LPFC_PG_TYPE_NO_DIF) 164 return 0; 165 if (scsi_host_get_guard(sc->device->host) == SHOST_DIX_GUARD_IP) 166 return 1; 167 return 0; 168 } 169 170 /** 171 * lpfc_sli4_set_rsp_sgl_last - Set the last bit in the response sge. 172 * @phba: Pointer to HBA object. 173 * @lpfc_cmd: lpfc scsi command object pointer. 174 * 175 * This function is called from the lpfc_prep_task_mgmt_cmd function to 176 * set the last bit in the response sge entry. 177 **/ 178 static void 179 lpfc_sli4_set_rsp_sgl_last(struct lpfc_hba *phba, 180 struct lpfc_scsi_buf *lpfc_cmd) 181 { 182 struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->fcp_bpl; 183 if (sgl) { 184 sgl += 1; 185 sgl->word2 = le32_to_cpu(sgl->word2); 186 bf_set(lpfc_sli4_sge_last, sgl, 1); 187 sgl->word2 = cpu_to_le32(sgl->word2); 188 } 189 } 190 191 /** 192 * lpfc_update_stats - Update statistical data for the command completion 193 * @phba: Pointer to HBA object. 194 * @lpfc_cmd: lpfc scsi command object pointer. 195 * 196 * This function is called when there is a command completion and this 197 * function updates the statistical data for the command completion. 198 **/ 199 static void 200 lpfc_update_stats(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd) 201 { 202 struct lpfc_rport_data *rdata = lpfc_cmd->rdata; 203 struct lpfc_nodelist *pnode = rdata->pnode; 204 struct scsi_cmnd *cmd = lpfc_cmd->pCmd; 205 unsigned long flags; 206 struct Scsi_Host *shost = cmd->device->host; 207 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 208 unsigned long latency; 209 int i; 210 211 if (cmd->result) 212 return; 213 214 latency = jiffies_to_msecs((long)jiffies - (long)lpfc_cmd->start_time); 215 216 spin_lock_irqsave(shost->host_lock, flags); 217 if (!vport->stat_data_enabled || 218 vport->stat_data_blocked || 219 !pnode || 220 !pnode->lat_data || 221 (phba->bucket_type == LPFC_NO_BUCKET)) { 222 spin_unlock_irqrestore(shost->host_lock, flags); 223 return; 224 } 225 226 if (phba->bucket_type == LPFC_LINEAR_BUCKET) { 227 i = (latency + phba->bucket_step - 1 - phba->bucket_base)/ 228 phba->bucket_step; 229 /* check array subscript bounds */ 230 if (i < 0) 231 i = 0; 232 else if (i >= LPFC_MAX_BUCKET_COUNT) 233 i = LPFC_MAX_BUCKET_COUNT - 1; 234 } else { 235 for (i = 0; i < LPFC_MAX_BUCKET_COUNT-1; i++) 236 if (latency <= (phba->bucket_base + 237 ((1<<i)*phba->bucket_step))) 238 break; 239 } 240 241 pnode->lat_data[i].cmd_count++; 242 spin_unlock_irqrestore(shost->host_lock, flags); 243 } 244 245 /** 246 * lpfc_rampdown_queue_depth - Post RAMP_DOWN_QUEUE event to worker thread 247 * @phba: The Hba for which this call is being executed. 248 * 249 * This routine is called when there is resource error in driver or firmware. 250 * This routine posts WORKER_RAMP_DOWN_QUEUE event for @phba. This routine 251 * posts at most 1 event each second. This routine wakes up worker thread of 252 * @phba to process WORKER_RAM_DOWN_EVENT event. 253 * 254 * This routine should be called with no lock held. 255 **/ 256 void 257 lpfc_rampdown_queue_depth(struct lpfc_hba *phba) 258 { 259 unsigned long flags; 260 uint32_t evt_posted; 261 unsigned long expires; 262 263 spin_lock_irqsave(&phba->hbalock, flags); 264 atomic_inc(&phba->num_rsrc_err); 265 phba->last_rsrc_error_time = jiffies; 266 267 expires = phba->last_ramp_down_time + QUEUE_RAMP_DOWN_INTERVAL; 268 if (time_after(expires, jiffies)) { 269 spin_unlock_irqrestore(&phba->hbalock, flags); 270 return; 271 } 272 273 phba->last_ramp_down_time = jiffies; 274 275 spin_unlock_irqrestore(&phba->hbalock, flags); 276 277 spin_lock_irqsave(&phba->pport->work_port_lock, flags); 278 evt_posted = phba->pport->work_port_events & WORKER_RAMP_DOWN_QUEUE; 279 if (!evt_posted) 280 phba->pport->work_port_events |= WORKER_RAMP_DOWN_QUEUE; 281 spin_unlock_irqrestore(&phba->pport->work_port_lock, flags); 282 283 if (!evt_posted) 284 lpfc_worker_wake_up(phba); 285 return; 286 } 287 288 /** 289 * lpfc_ramp_down_queue_handler - WORKER_RAMP_DOWN_QUEUE event handler 290 * @phba: The Hba for which this call is being executed. 291 * 292 * This routine is called to process WORKER_RAMP_DOWN_QUEUE event for worker 293 * thread.This routine reduces queue depth for all scsi device on each vport 294 * associated with @phba. 295 **/ 296 void 297 lpfc_ramp_down_queue_handler(struct lpfc_hba *phba) 298 { 299 struct lpfc_vport **vports; 300 struct Scsi_Host *shost; 301 struct scsi_device *sdev; 302 unsigned long new_queue_depth; 303 unsigned long num_rsrc_err, num_cmd_success; 304 int i; 305 306 num_rsrc_err = atomic_read(&phba->num_rsrc_err); 307 num_cmd_success = atomic_read(&phba->num_cmd_success); 308 309 /* 310 * The error and success command counters are global per 311 * driver instance. If another handler has already 312 * operated on this error event, just exit. 313 */ 314 if (num_rsrc_err == 0) 315 return; 316 317 vports = lpfc_create_vport_work_array(phba); 318 if (vports != NULL) 319 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 320 shost = lpfc_shost_from_vport(vports[i]); 321 shost_for_each_device(sdev, shost) { 322 new_queue_depth = 323 sdev->queue_depth * num_rsrc_err / 324 (num_rsrc_err + num_cmd_success); 325 if (!new_queue_depth) 326 new_queue_depth = sdev->queue_depth - 1; 327 else 328 new_queue_depth = sdev->queue_depth - 329 new_queue_depth; 330 scsi_change_queue_depth(sdev, new_queue_depth); 331 } 332 } 333 lpfc_destroy_vport_work_array(phba, vports); 334 atomic_set(&phba->num_rsrc_err, 0); 335 atomic_set(&phba->num_cmd_success, 0); 336 } 337 338 /** 339 * lpfc_scsi_dev_block - set all scsi hosts to block state 340 * @phba: Pointer to HBA context object. 341 * 342 * This function walks vport list and set each SCSI host to block state 343 * by invoking fc_remote_port_delete() routine. This function is invoked 344 * with EEH when device's PCI slot has been permanently disabled. 345 **/ 346 void 347 lpfc_scsi_dev_block(struct lpfc_hba *phba) 348 { 349 struct lpfc_vport **vports; 350 struct Scsi_Host *shost; 351 struct scsi_device *sdev; 352 struct fc_rport *rport; 353 int i; 354 355 vports = lpfc_create_vport_work_array(phba); 356 if (vports != NULL) 357 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 358 shost = lpfc_shost_from_vport(vports[i]); 359 shost_for_each_device(sdev, shost) { 360 rport = starget_to_rport(scsi_target(sdev)); 361 fc_remote_port_delete(rport); 362 } 363 } 364 lpfc_destroy_vport_work_array(phba, vports); 365 } 366 367 /** 368 * lpfc_new_scsi_buf_s3 - Scsi buffer allocator for HBA with SLI3 IF spec 369 * @vport: The virtual port for which this call being executed. 370 * @num_to_allocate: The requested number of buffers to allocate. 371 * 372 * This routine allocates a scsi buffer for device with SLI-3 interface spec, 373 * the scsi buffer contains all the necessary information needed to initiate 374 * a SCSI I/O. The non-DMAable buffer region contains information to build 375 * the IOCB. The DMAable region contains memory for the FCP CMND, FCP RSP, 376 * and the initial BPL. In addition to allocating memory, the FCP CMND and 377 * FCP RSP BDEs are setup in the BPL and the BPL BDE is setup in the IOCB. 378 * 379 * Return codes: 380 * int - number of scsi buffers that were allocated. 381 * 0 = failure, less than num_to_alloc is a partial failure. 382 **/ 383 static int 384 lpfc_new_scsi_buf_s3(struct lpfc_vport *vport, int num_to_alloc) 385 { 386 struct lpfc_hba *phba = vport->phba; 387 struct lpfc_scsi_buf *psb; 388 struct ulp_bde64 *bpl; 389 IOCB_t *iocb; 390 dma_addr_t pdma_phys_fcp_cmd; 391 dma_addr_t pdma_phys_fcp_rsp; 392 dma_addr_t pdma_phys_bpl; 393 uint16_t iotag; 394 int bcnt, bpl_size; 395 396 bpl_size = phba->cfg_sg_dma_buf_size - 397 (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp)); 398 399 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 400 "9067 ALLOC %d scsi_bufs: %d (%d + %d + %d)\n", 401 num_to_alloc, phba->cfg_sg_dma_buf_size, 402 (int)sizeof(struct fcp_cmnd), 403 (int)sizeof(struct fcp_rsp), bpl_size); 404 405 for (bcnt = 0; bcnt < num_to_alloc; bcnt++) { 406 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL); 407 if (!psb) 408 break; 409 410 /* 411 * Get memory from the pci pool to map the virt space to pci 412 * bus space for an I/O. The DMA buffer includes space for the 413 * struct fcp_cmnd, struct fcp_rsp and the number of bde's 414 * necessary to support the sg_tablesize. 415 */ 416 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool, 417 GFP_KERNEL, &psb->dma_handle); 418 if (!psb->data) { 419 kfree(psb); 420 break; 421 } 422 423 /* Initialize virtual ptrs to dma_buf region. */ 424 memset(psb->data, 0, phba->cfg_sg_dma_buf_size); 425 426 /* Allocate iotag for psb->cur_iocbq. */ 427 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq); 428 if (iotag == 0) { 429 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, 430 psb->data, psb->dma_handle); 431 kfree(psb); 432 break; 433 } 434 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP; 435 436 psb->fcp_cmnd = psb->data; 437 psb->fcp_rsp = psb->data + sizeof(struct fcp_cmnd); 438 psb->fcp_bpl = psb->data + sizeof(struct fcp_cmnd) + 439 sizeof(struct fcp_rsp); 440 441 /* Initialize local short-hand pointers. */ 442 bpl = psb->fcp_bpl; 443 pdma_phys_fcp_cmd = psb->dma_handle; 444 pdma_phys_fcp_rsp = psb->dma_handle + sizeof(struct fcp_cmnd); 445 pdma_phys_bpl = psb->dma_handle + sizeof(struct fcp_cmnd) + 446 sizeof(struct fcp_rsp); 447 448 /* 449 * The first two bdes are the FCP_CMD and FCP_RSP. The balance 450 * are sg list bdes. Initialize the first two and leave the 451 * rest for queuecommand. 452 */ 453 bpl[0].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_cmd)); 454 bpl[0].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_cmd)); 455 bpl[0].tus.f.bdeSize = sizeof(struct fcp_cmnd); 456 bpl[0].tus.f.bdeFlags = BUFF_TYPE_BDE_64; 457 bpl[0].tus.w = le32_to_cpu(bpl[0].tus.w); 458 459 /* Setup the physical region for the FCP RSP */ 460 bpl[1].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_rsp)); 461 bpl[1].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_rsp)); 462 bpl[1].tus.f.bdeSize = sizeof(struct fcp_rsp); 463 bpl[1].tus.f.bdeFlags = BUFF_TYPE_BDE_64; 464 bpl[1].tus.w = le32_to_cpu(bpl[1].tus.w); 465 466 /* 467 * Since the IOCB for the FCP I/O is built into this 468 * lpfc_scsi_buf, initialize it with all known data now. 469 */ 470 iocb = &psb->cur_iocbq.iocb; 471 iocb->un.fcpi64.bdl.ulpIoTag32 = 0; 472 if ((phba->sli_rev == 3) && 473 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) { 474 /* fill in immediate fcp command BDE */ 475 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_IMMED; 476 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd); 477 iocb->un.fcpi64.bdl.addrLow = offsetof(IOCB_t, 478 unsli3.fcp_ext.icd); 479 iocb->un.fcpi64.bdl.addrHigh = 0; 480 iocb->ulpBdeCount = 0; 481 iocb->ulpLe = 0; 482 /* fill in response BDE */ 483 iocb->unsli3.fcp_ext.rbde.tus.f.bdeFlags = 484 BUFF_TYPE_BDE_64; 485 iocb->unsli3.fcp_ext.rbde.tus.f.bdeSize = 486 sizeof(struct fcp_rsp); 487 iocb->unsli3.fcp_ext.rbde.addrLow = 488 putPaddrLow(pdma_phys_fcp_rsp); 489 iocb->unsli3.fcp_ext.rbde.addrHigh = 490 putPaddrHigh(pdma_phys_fcp_rsp); 491 } else { 492 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BLP_64; 493 iocb->un.fcpi64.bdl.bdeSize = 494 (2 * sizeof(struct ulp_bde64)); 495 iocb->un.fcpi64.bdl.addrLow = 496 putPaddrLow(pdma_phys_bpl); 497 iocb->un.fcpi64.bdl.addrHigh = 498 putPaddrHigh(pdma_phys_bpl); 499 iocb->ulpBdeCount = 1; 500 iocb->ulpLe = 1; 501 } 502 iocb->ulpClass = CLASS3; 503 psb->status = IOSTAT_SUCCESS; 504 /* Put it back into the SCSI buffer list */ 505 psb->cur_iocbq.context1 = psb; 506 lpfc_release_scsi_buf_s3(phba, psb); 507 508 } 509 510 return bcnt; 511 } 512 513 /** 514 * lpfc_sli4_vport_delete_fcp_xri_aborted -Remove all ndlp references for vport 515 * @vport: pointer to lpfc vport data structure. 516 * 517 * This routine is invoked by the vport cleanup for deletions and the cleanup 518 * for an ndlp on removal. 519 **/ 520 void 521 lpfc_sli4_vport_delete_fcp_xri_aborted(struct lpfc_vport *vport) 522 { 523 struct lpfc_hba *phba = vport->phba; 524 struct lpfc_scsi_buf *psb, *next_psb; 525 unsigned long iflag = 0; 526 527 spin_lock_irqsave(&phba->hbalock, iflag); 528 spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock); 529 list_for_each_entry_safe(psb, next_psb, 530 &phba->sli4_hba.lpfc_abts_scsi_buf_list, list) { 531 if (psb->rdata && psb->rdata->pnode 532 && psb->rdata->pnode->vport == vport) 533 psb->rdata = NULL; 534 } 535 spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock); 536 spin_unlock_irqrestore(&phba->hbalock, iflag); 537 } 538 539 /** 540 * lpfc_sli4_fcp_xri_aborted - Fast-path process of fcp xri abort 541 * @phba: pointer to lpfc hba data structure. 542 * @axri: pointer to the fcp xri abort wcqe structure. 543 * 544 * This routine is invoked by the worker thread to process a SLI4 fast-path 545 * FCP aborted xri. 546 **/ 547 void 548 lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba, 549 struct sli4_wcqe_xri_aborted *axri) 550 { 551 uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri); 552 uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri); 553 struct lpfc_scsi_buf *psb, *next_psb; 554 unsigned long iflag = 0; 555 struct lpfc_iocbq *iocbq; 556 int i; 557 struct lpfc_nodelist *ndlp; 558 int rrq_empty = 0; 559 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING]; 560 561 spin_lock_irqsave(&phba->hbalock, iflag); 562 spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock); 563 list_for_each_entry_safe(psb, next_psb, 564 &phba->sli4_hba.lpfc_abts_scsi_buf_list, list) { 565 if (psb->cur_iocbq.sli4_xritag == xri) { 566 list_del(&psb->list); 567 psb->exch_busy = 0; 568 psb->status = IOSTAT_SUCCESS; 569 spin_unlock( 570 &phba->sli4_hba.abts_scsi_buf_list_lock); 571 if (psb->rdata && psb->rdata->pnode) 572 ndlp = psb->rdata->pnode; 573 else 574 ndlp = NULL; 575 576 rrq_empty = list_empty(&phba->active_rrq_list); 577 spin_unlock_irqrestore(&phba->hbalock, iflag); 578 if (ndlp) { 579 lpfc_set_rrq_active(phba, ndlp, 580 psb->cur_iocbq.sli4_lxritag, rxid, 1); 581 lpfc_sli4_abts_err_handler(phba, ndlp, axri); 582 } 583 lpfc_release_scsi_buf_s4(phba, psb); 584 if (rrq_empty) 585 lpfc_worker_wake_up(phba); 586 return; 587 } 588 } 589 spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock); 590 for (i = 1; i <= phba->sli.last_iotag; i++) { 591 iocbq = phba->sli.iocbq_lookup[i]; 592 593 if (!(iocbq->iocb_flag & LPFC_IO_FCP) || 594 (iocbq->iocb_flag & LPFC_IO_LIBDFC)) 595 continue; 596 if (iocbq->sli4_xritag != xri) 597 continue; 598 psb = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq); 599 psb->exch_busy = 0; 600 spin_unlock_irqrestore(&phba->hbalock, iflag); 601 if (!list_empty(&pring->txq)) 602 lpfc_worker_wake_up(phba); 603 return; 604 605 } 606 spin_unlock_irqrestore(&phba->hbalock, iflag); 607 } 608 609 /** 610 * lpfc_sli4_post_scsi_sgl_list - Psot blocks of scsi buffer sgls from a list 611 * @phba: pointer to lpfc hba data structure. 612 * @post_sblist: pointer to the scsi buffer list. 613 * 614 * This routine walks a list of scsi buffers that was passed in. It attempts 615 * to construct blocks of scsi buffer sgls which contains contiguous xris and 616 * uses the non-embedded SGL block post mailbox commands to post to the port. 617 * For single SCSI buffer sgl with non-contiguous xri, if any, it shall use 618 * embedded SGL post mailbox command for posting. The @post_sblist passed in 619 * must be local list, thus no lock is needed when manipulate the list. 620 * 621 * Returns: 0 = failure, non-zero number of successfully posted buffers. 622 **/ 623 static int 624 lpfc_sli4_post_scsi_sgl_list(struct lpfc_hba *phba, 625 struct list_head *post_sblist, int sb_count) 626 { 627 struct lpfc_scsi_buf *psb, *psb_next; 628 int status, sgl_size; 629 int post_cnt = 0, block_cnt = 0, num_posting = 0, num_posted = 0; 630 dma_addr_t pdma_phys_bpl1; 631 int last_xritag = NO_XRI; 632 LIST_HEAD(prep_sblist); 633 LIST_HEAD(blck_sblist); 634 LIST_HEAD(scsi_sblist); 635 636 /* sanity check */ 637 if (sb_count <= 0) 638 return -EINVAL; 639 640 sgl_size = phba->cfg_sg_dma_buf_size - 641 (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp)); 642 643 list_for_each_entry_safe(psb, psb_next, post_sblist, list) { 644 list_del_init(&psb->list); 645 block_cnt++; 646 if ((last_xritag != NO_XRI) && 647 (psb->cur_iocbq.sli4_xritag != last_xritag + 1)) { 648 /* a hole in xri block, form a sgl posting block */ 649 list_splice_init(&prep_sblist, &blck_sblist); 650 post_cnt = block_cnt - 1; 651 /* prepare list for next posting block */ 652 list_add_tail(&psb->list, &prep_sblist); 653 block_cnt = 1; 654 } else { 655 /* prepare list for next posting block */ 656 list_add_tail(&psb->list, &prep_sblist); 657 /* enough sgls for non-embed sgl mbox command */ 658 if (block_cnt == LPFC_NEMBED_MBOX_SGL_CNT) { 659 list_splice_init(&prep_sblist, &blck_sblist); 660 post_cnt = block_cnt; 661 block_cnt = 0; 662 } 663 } 664 num_posting++; 665 last_xritag = psb->cur_iocbq.sli4_xritag; 666 667 /* end of repost sgl list condition for SCSI buffers */ 668 if (num_posting == sb_count) { 669 if (post_cnt == 0) { 670 /* last sgl posting block */ 671 list_splice_init(&prep_sblist, &blck_sblist); 672 post_cnt = block_cnt; 673 } else if (block_cnt == 1) { 674 /* last single sgl with non-contiguous xri */ 675 if (sgl_size > SGL_PAGE_SIZE) 676 pdma_phys_bpl1 = psb->dma_phys_bpl + 677 SGL_PAGE_SIZE; 678 else 679 pdma_phys_bpl1 = 0; 680 status = lpfc_sli4_post_sgl(phba, 681 psb->dma_phys_bpl, 682 pdma_phys_bpl1, 683 psb->cur_iocbq.sli4_xritag); 684 if (status) { 685 /* failure, put on abort scsi list */ 686 psb->exch_busy = 1; 687 } else { 688 /* success, put on SCSI buffer list */ 689 psb->exch_busy = 0; 690 psb->status = IOSTAT_SUCCESS; 691 num_posted++; 692 } 693 /* success, put on SCSI buffer sgl list */ 694 list_add_tail(&psb->list, &scsi_sblist); 695 } 696 } 697 698 /* continue until a nembed page worth of sgls */ 699 if (post_cnt == 0) 700 continue; 701 702 /* post block of SCSI buffer list sgls */ 703 status = lpfc_sli4_post_scsi_sgl_block(phba, &blck_sblist, 704 post_cnt); 705 706 /* don't reset xirtag due to hole in xri block */ 707 if (block_cnt == 0) 708 last_xritag = NO_XRI; 709 710 /* reset SCSI buffer post count for next round of posting */ 711 post_cnt = 0; 712 713 /* put posted SCSI buffer-sgl posted on SCSI buffer sgl list */ 714 while (!list_empty(&blck_sblist)) { 715 list_remove_head(&blck_sblist, psb, 716 struct lpfc_scsi_buf, list); 717 if (status) { 718 /* failure, put on abort scsi list */ 719 psb->exch_busy = 1; 720 } else { 721 /* success, put on SCSI buffer list */ 722 psb->exch_busy = 0; 723 psb->status = IOSTAT_SUCCESS; 724 num_posted++; 725 } 726 list_add_tail(&psb->list, &scsi_sblist); 727 } 728 } 729 /* Push SCSI buffers with sgl posted to the availble list */ 730 while (!list_empty(&scsi_sblist)) { 731 list_remove_head(&scsi_sblist, psb, 732 struct lpfc_scsi_buf, list); 733 lpfc_release_scsi_buf_s4(phba, psb); 734 } 735 return num_posted; 736 } 737 738 /** 739 * lpfc_sli4_repost_scsi_sgl_list - Repsot all the allocated scsi buffer sgls 740 * @phba: pointer to lpfc hba data structure. 741 * 742 * This routine walks the list of scsi buffers that have been allocated and 743 * repost them to the port by using SGL block post. This is needed after a 744 * pci_function_reset/warm_start or start. The lpfc_hba_down_post_s4 routine 745 * is responsible for moving all scsi buffers on the lpfc_abts_scsi_sgl_list 746 * to the lpfc_scsi_buf_list. If the repost fails, reject all scsi buffers. 747 * 748 * Returns: 0 = success, non-zero failure. 749 **/ 750 int 751 lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba) 752 { 753 LIST_HEAD(post_sblist); 754 int num_posted, rc = 0; 755 756 /* get all SCSI buffers need to repost to a local list */ 757 spin_lock_irq(&phba->scsi_buf_list_get_lock); 758 spin_lock(&phba->scsi_buf_list_put_lock); 759 list_splice_init(&phba->lpfc_scsi_buf_list_get, &post_sblist); 760 list_splice(&phba->lpfc_scsi_buf_list_put, &post_sblist); 761 spin_unlock(&phba->scsi_buf_list_put_lock); 762 spin_unlock_irq(&phba->scsi_buf_list_get_lock); 763 764 /* post the list of scsi buffer sgls to port if available */ 765 if (!list_empty(&post_sblist)) { 766 num_posted = lpfc_sli4_post_scsi_sgl_list(phba, &post_sblist, 767 phba->sli4_hba.scsi_xri_cnt); 768 /* failed to post any scsi buffer, return error */ 769 if (num_posted == 0) 770 rc = -EIO; 771 } 772 return rc; 773 } 774 775 /** 776 * lpfc_new_scsi_buf_s4 - Scsi buffer allocator for HBA with SLI4 IF spec 777 * @vport: The virtual port for which this call being executed. 778 * @num_to_allocate: The requested number of buffers to allocate. 779 * 780 * This routine allocates scsi buffers for device with SLI-4 interface spec, 781 * the scsi buffer contains all the necessary information needed to initiate 782 * a SCSI I/O. After allocating up to @num_to_allocate SCSI buffers and put 783 * them on a list, it post them to the port by using SGL block post. 784 * 785 * Return codes: 786 * int - number of scsi buffers that were allocated and posted. 787 * 0 = failure, less than num_to_alloc is a partial failure. 788 **/ 789 static int 790 lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc) 791 { 792 struct lpfc_hba *phba = vport->phba; 793 struct lpfc_scsi_buf *psb; 794 struct sli4_sge *sgl; 795 IOCB_t *iocb; 796 dma_addr_t pdma_phys_fcp_cmd; 797 dma_addr_t pdma_phys_fcp_rsp; 798 dma_addr_t pdma_phys_bpl; 799 uint16_t iotag, lxri = 0; 800 int bcnt, num_posted, sgl_size; 801 LIST_HEAD(prep_sblist); 802 LIST_HEAD(post_sblist); 803 LIST_HEAD(scsi_sblist); 804 805 sgl_size = phba->cfg_sg_dma_buf_size - 806 (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp)); 807 808 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 809 "9068 ALLOC %d scsi_bufs: %d (%d + %d + %d)\n", 810 num_to_alloc, phba->cfg_sg_dma_buf_size, sgl_size, 811 (int)sizeof(struct fcp_cmnd), 812 (int)sizeof(struct fcp_rsp)); 813 814 for (bcnt = 0; bcnt < num_to_alloc; bcnt++) { 815 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL); 816 if (!psb) 817 break; 818 /* 819 * Get memory from the pci pool to map the virt space to 820 * pci bus space for an I/O. The DMA buffer includes space 821 * for the struct fcp_cmnd, struct fcp_rsp and the number 822 * of bde's necessary to support the sg_tablesize. 823 */ 824 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool, 825 GFP_KERNEL, &psb->dma_handle); 826 if (!psb->data) { 827 kfree(psb); 828 break; 829 } 830 memset(psb->data, 0, phba->cfg_sg_dma_buf_size); 831 832 /* 833 * 4K Page alignment is CRITICAL to BlockGuard, double check 834 * to be sure. 835 */ 836 if (phba->cfg_enable_bg && (((unsigned long)(psb->data) & 837 (unsigned long)(SLI4_PAGE_SIZE - 1)) != 0)) { 838 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, 839 psb->data, psb->dma_handle); 840 kfree(psb); 841 break; 842 } 843 844 845 lxri = lpfc_sli4_next_xritag(phba); 846 if (lxri == NO_XRI) { 847 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, 848 psb->data, psb->dma_handle); 849 kfree(psb); 850 break; 851 } 852 853 /* Allocate iotag for psb->cur_iocbq. */ 854 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq); 855 if (iotag == 0) { 856 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, 857 psb->data, psb->dma_handle); 858 kfree(psb); 859 lpfc_printf_log(phba, KERN_ERR, LOG_FCP, 860 "3368 Failed to allocated IOTAG for" 861 " XRI:0x%x\n", lxri); 862 lpfc_sli4_free_xri(phba, lxri); 863 break; 864 } 865 psb->cur_iocbq.sli4_lxritag = lxri; 866 psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri]; 867 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP; 868 psb->fcp_bpl = psb->data; 869 psb->fcp_cmnd = (psb->data + sgl_size); 870 psb->fcp_rsp = (struct fcp_rsp *)((uint8_t *)psb->fcp_cmnd + 871 sizeof(struct fcp_cmnd)); 872 873 /* Initialize local short-hand pointers. */ 874 sgl = (struct sli4_sge *)psb->fcp_bpl; 875 pdma_phys_bpl = psb->dma_handle; 876 pdma_phys_fcp_cmd = (psb->dma_handle + sgl_size); 877 pdma_phys_fcp_rsp = pdma_phys_fcp_cmd + sizeof(struct fcp_cmnd); 878 879 /* 880 * The first two bdes are the FCP_CMD and FCP_RSP. 881 * The balance are sg list bdes. Initialize the 882 * first two and leave the rest for queuecommand. 883 */ 884 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_cmd)); 885 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_cmd)); 886 sgl->word2 = le32_to_cpu(sgl->word2); 887 bf_set(lpfc_sli4_sge_last, sgl, 0); 888 sgl->word2 = cpu_to_le32(sgl->word2); 889 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_cmnd)); 890 sgl++; 891 892 /* Setup the physical region for the FCP RSP */ 893 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_rsp)); 894 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_rsp)); 895 sgl->word2 = le32_to_cpu(sgl->word2); 896 bf_set(lpfc_sli4_sge_last, sgl, 1); 897 sgl->word2 = cpu_to_le32(sgl->word2); 898 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_rsp)); 899 900 /* 901 * Since the IOCB for the FCP I/O is built into this 902 * lpfc_scsi_buf, initialize it with all known data now. 903 */ 904 iocb = &psb->cur_iocbq.iocb; 905 iocb->un.fcpi64.bdl.ulpIoTag32 = 0; 906 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_64; 907 /* setting the BLP size to 2 * sizeof BDE may not be correct. 908 * We are setting the bpl to point to out sgl. An sgl's 909 * entries are 16 bytes, a bpl entries are 12 bytes. 910 */ 911 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd); 912 iocb->un.fcpi64.bdl.addrLow = putPaddrLow(pdma_phys_fcp_cmd); 913 iocb->un.fcpi64.bdl.addrHigh = putPaddrHigh(pdma_phys_fcp_cmd); 914 iocb->ulpBdeCount = 1; 915 iocb->ulpLe = 1; 916 iocb->ulpClass = CLASS3; 917 psb->cur_iocbq.context1 = psb; 918 psb->dma_phys_bpl = pdma_phys_bpl; 919 920 /* add the scsi buffer to a post list */ 921 list_add_tail(&psb->list, &post_sblist); 922 spin_lock_irq(&phba->scsi_buf_list_get_lock); 923 phba->sli4_hba.scsi_xri_cnt++; 924 spin_unlock_irq(&phba->scsi_buf_list_get_lock); 925 } 926 lpfc_printf_log(phba, KERN_INFO, LOG_BG, 927 "3021 Allocate %d out of %d requested new SCSI " 928 "buffers\n", bcnt, num_to_alloc); 929 930 /* post the list of scsi buffer sgls to port if available */ 931 if (!list_empty(&post_sblist)) 932 num_posted = lpfc_sli4_post_scsi_sgl_list(phba, 933 &post_sblist, bcnt); 934 else 935 num_posted = 0; 936 937 return num_posted; 938 } 939 940 /** 941 * lpfc_new_scsi_buf - Wrapper funciton for scsi buffer allocator 942 * @vport: The virtual port for which this call being executed. 943 * @num_to_allocate: The requested number of buffers to allocate. 944 * 945 * This routine wraps the actual SCSI buffer allocator function pointer from 946 * the lpfc_hba struct. 947 * 948 * Return codes: 949 * int - number of scsi buffers that were allocated. 950 * 0 = failure, less than num_to_alloc is a partial failure. 951 **/ 952 static inline int 953 lpfc_new_scsi_buf(struct lpfc_vport *vport, int num_to_alloc) 954 { 955 return vport->phba->lpfc_new_scsi_buf(vport, num_to_alloc); 956 } 957 958 /** 959 * lpfc_get_scsi_buf_s3 - Get a scsi buffer from lpfc_scsi_buf_list of the HBA 960 * @phba: The HBA for which this call is being executed. 961 * 962 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list 963 * and returns to caller. 964 * 965 * Return codes: 966 * NULL - Error 967 * Pointer to lpfc_scsi_buf - Success 968 **/ 969 static struct lpfc_scsi_buf* 970 lpfc_get_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp) 971 { 972 struct lpfc_scsi_buf * lpfc_cmd = NULL; 973 struct list_head *scsi_buf_list_get = &phba->lpfc_scsi_buf_list_get; 974 unsigned long iflag = 0; 975 976 spin_lock_irqsave(&phba->scsi_buf_list_get_lock, iflag); 977 list_remove_head(scsi_buf_list_get, lpfc_cmd, struct lpfc_scsi_buf, 978 list); 979 if (!lpfc_cmd) { 980 spin_lock(&phba->scsi_buf_list_put_lock); 981 list_splice(&phba->lpfc_scsi_buf_list_put, 982 &phba->lpfc_scsi_buf_list_get); 983 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put); 984 list_remove_head(scsi_buf_list_get, lpfc_cmd, 985 struct lpfc_scsi_buf, list); 986 spin_unlock(&phba->scsi_buf_list_put_lock); 987 } 988 spin_unlock_irqrestore(&phba->scsi_buf_list_get_lock, iflag); 989 return lpfc_cmd; 990 } 991 /** 992 * lpfc_get_scsi_buf_s4 - Get a scsi buffer from lpfc_scsi_buf_list of the HBA 993 * @phba: The HBA for which this call is being executed. 994 * 995 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list 996 * and returns to caller. 997 * 998 * Return codes: 999 * NULL - Error 1000 * Pointer to lpfc_scsi_buf - Success 1001 **/ 1002 static struct lpfc_scsi_buf* 1003 lpfc_get_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp) 1004 { 1005 struct lpfc_scsi_buf *lpfc_cmd, *lpfc_cmd_next; 1006 unsigned long iflag = 0; 1007 int found = 0; 1008 1009 spin_lock_irqsave(&phba->scsi_buf_list_get_lock, iflag); 1010 list_for_each_entry_safe(lpfc_cmd, lpfc_cmd_next, 1011 &phba->lpfc_scsi_buf_list_get, list) { 1012 if (lpfc_test_rrq_active(phba, ndlp, 1013 lpfc_cmd->cur_iocbq.sli4_lxritag)) 1014 continue; 1015 list_del(&lpfc_cmd->list); 1016 found = 1; 1017 break; 1018 } 1019 if (!found) { 1020 spin_lock(&phba->scsi_buf_list_put_lock); 1021 list_splice(&phba->lpfc_scsi_buf_list_put, 1022 &phba->lpfc_scsi_buf_list_get); 1023 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put); 1024 spin_unlock(&phba->scsi_buf_list_put_lock); 1025 list_for_each_entry_safe(lpfc_cmd, lpfc_cmd_next, 1026 &phba->lpfc_scsi_buf_list_get, list) { 1027 if (lpfc_test_rrq_active( 1028 phba, ndlp, lpfc_cmd->cur_iocbq.sli4_lxritag)) 1029 continue; 1030 list_del(&lpfc_cmd->list); 1031 found = 1; 1032 break; 1033 } 1034 } 1035 spin_unlock_irqrestore(&phba->scsi_buf_list_get_lock, iflag); 1036 if (!found) 1037 return NULL; 1038 return lpfc_cmd; 1039 } 1040 /** 1041 * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list of the HBA 1042 * @phba: The HBA for which this call is being executed. 1043 * 1044 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list 1045 * and returns to caller. 1046 * 1047 * Return codes: 1048 * NULL - Error 1049 * Pointer to lpfc_scsi_buf - Success 1050 **/ 1051 static struct lpfc_scsi_buf* 1052 lpfc_get_scsi_buf(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp) 1053 { 1054 return phba->lpfc_get_scsi_buf(phba, ndlp); 1055 } 1056 1057 /** 1058 * lpfc_release_scsi_buf - Return a scsi buffer back to hba scsi buf list 1059 * @phba: The Hba for which this call is being executed. 1060 * @psb: The scsi buffer which is being released. 1061 * 1062 * This routine releases @psb scsi buffer by adding it to tail of @phba 1063 * lpfc_scsi_buf_list list. 1064 **/ 1065 static void 1066 lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb) 1067 { 1068 unsigned long iflag = 0; 1069 1070 psb->seg_cnt = 0; 1071 psb->nonsg_phys = 0; 1072 psb->prot_seg_cnt = 0; 1073 1074 spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag); 1075 psb->pCmd = NULL; 1076 psb->cur_iocbq.iocb_flag = LPFC_IO_FCP; 1077 list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list_put); 1078 spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag); 1079 } 1080 1081 /** 1082 * lpfc_release_scsi_buf_s4: Return a scsi buffer back to hba scsi buf list. 1083 * @phba: The Hba for which this call is being executed. 1084 * @psb: The scsi buffer which is being released. 1085 * 1086 * This routine releases @psb scsi buffer by adding it to tail of @phba 1087 * lpfc_scsi_buf_list list. For SLI4 XRI's are tied to the scsi buffer 1088 * and cannot be reused for at least RA_TOV amount of time if it was 1089 * aborted. 1090 **/ 1091 static void 1092 lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb) 1093 { 1094 unsigned long iflag = 0; 1095 1096 psb->seg_cnt = 0; 1097 psb->nonsg_phys = 0; 1098 psb->prot_seg_cnt = 0; 1099 1100 if (psb->exch_busy) { 1101 spin_lock_irqsave(&phba->sli4_hba.abts_scsi_buf_list_lock, 1102 iflag); 1103 psb->pCmd = NULL; 1104 list_add_tail(&psb->list, 1105 &phba->sli4_hba.lpfc_abts_scsi_buf_list); 1106 spin_unlock_irqrestore(&phba->sli4_hba.abts_scsi_buf_list_lock, 1107 iflag); 1108 } else { 1109 psb->pCmd = NULL; 1110 psb->cur_iocbq.iocb_flag = LPFC_IO_FCP; 1111 spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag); 1112 list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list_put); 1113 spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag); 1114 } 1115 } 1116 1117 /** 1118 * lpfc_release_scsi_buf: Return a scsi buffer back to hba scsi buf list. 1119 * @phba: The Hba for which this call is being executed. 1120 * @psb: The scsi buffer which is being released. 1121 * 1122 * This routine releases @psb scsi buffer by adding it to tail of @phba 1123 * lpfc_scsi_buf_list list. 1124 **/ 1125 static void 1126 lpfc_release_scsi_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb) 1127 { 1128 1129 phba->lpfc_release_scsi_buf(phba, psb); 1130 } 1131 1132 /** 1133 * lpfc_scsi_prep_dma_buf_s3 - DMA mapping for scsi buffer to SLI3 IF spec 1134 * @phba: The Hba for which this call is being executed. 1135 * @lpfc_cmd: The scsi buffer which is going to be mapped. 1136 * 1137 * This routine does the pci dma mapping for scatter-gather list of scsi cmnd 1138 * field of @lpfc_cmd for device with SLI-3 interface spec. This routine scans 1139 * through sg elements and format the bdea. This routine also initializes all 1140 * IOCB fields which are dependent on scsi command request buffer. 1141 * 1142 * Return codes: 1143 * 1 - Error 1144 * 0 - Success 1145 **/ 1146 static int 1147 lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd) 1148 { 1149 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd; 1150 struct scatterlist *sgel = NULL; 1151 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd; 1152 struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl; 1153 struct lpfc_iocbq *iocbq = &lpfc_cmd->cur_iocbq; 1154 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb; 1155 struct ulp_bde64 *data_bde = iocb_cmd->unsli3.fcp_ext.dbde; 1156 dma_addr_t physaddr; 1157 uint32_t num_bde = 0; 1158 int nseg, datadir = scsi_cmnd->sc_data_direction; 1159 1160 /* 1161 * There are three possibilities here - use scatter-gather segment, use 1162 * the single mapping, or neither. Start the lpfc command prep by 1163 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first 1164 * data bde entry. 1165 */ 1166 bpl += 2; 1167 if (scsi_sg_count(scsi_cmnd)) { 1168 /* 1169 * The driver stores the segment count returned from pci_map_sg 1170 * because this a count of dma-mappings used to map the use_sg 1171 * pages. They are not guaranteed to be the same for those 1172 * architectures that implement an IOMMU. 1173 */ 1174 1175 nseg = dma_map_sg(&phba->pcidev->dev, scsi_sglist(scsi_cmnd), 1176 scsi_sg_count(scsi_cmnd), datadir); 1177 if (unlikely(!nseg)) 1178 return 1; 1179 1180 lpfc_cmd->seg_cnt = nseg; 1181 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) { 1182 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1183 "9064 BLKGRD: %s: Too many sg segments from " 1184 "dma_map_sg. Config %d, seg_cnt %d\n", 1185 __func__, phba->cfg_sg_seg_cnt, 1186 lpfc_cmd->seg_cnt); 1187 lpfc_cmd->seg_cnt = 0; 1188 scsi_dma_unmap(scsi_cmnd); 1189 return 1; 1190 } 1191 1192 /* 1193 * The driver established a maximum scatter-gather segment count 1194 * during probe that limits the number of sg elements in any 1195 * single scsi command. Just run through the seg_cnt and format 1196 * the bde's. 1197 * When using SLI-3 the driver will try to fit all the BDEs into 1198 * the IOCB. If it can't then the BDEs get added to a BPL as it 1199 * does for SLI-2 mode. 1200 */ 1201 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) { 1202 physaddr = sg_dma_address(sgel); 1203 if (phba->sli_rev == 3 && 1204 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) && 1205 !(iocbq->iocb_flag & DSS_SECURITY_OP) && 1206 nseg <= LPFC_EXT_DATA_BDE_COUNT) { 1207 data_bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64; 1208 data_bde->tus.f.bdeSize = sg_dma_len(sgel); 1209 data_bde->addrLow = putPaddrLow(physaddr); 1210 data_bde->addrHigh = putPaddrHigh(physaddr); 1211 data_bde++; 1212 } else { 1213 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64; 1214 bpl->tus.f.bdeSize = sg_dma_len(sgel); 1215 bpl->tus.w = le32_to_cpu(bpl->tus.w); 1216 bpl->addrLow = 1217 le32_to_cpu(putPaddrLow(physaddr)); 1218 bpl->addrHigh = 1219 le32_to_cpu(putPaddrHigh(physaddr)); 1220 bpl++; 1221 } 1222 } 1223 } 1224 1225 /* 1226 * Finish initializing those IOCB fields that are dependent on the 1227 * scsi_cmnd request_buffer. Note that for SLI-2 the bdeSize is 1228 * explicitly reinitialized and for SLI-3 the extended bde count is 1229 * explicitly reinitialized since all iocb memory resources are reused. 1230 */ 1231 if (phba->sli_rev == 3 && 1232 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) && 1233 !(iocbq->iocb_flag & DSS_SECURITY_OP)) { 1234 if (num_bde > LPFC_EXT_DATA_BDE_COUNT) { 1235 /* 1236 * The extended IOCB format can only fit 3 BDE or a BPL. 1237 * This I/O has more than 3 BDE so the 1st data bde will 1238 * be a BPL that is filled in here. 1239 */ 1240 physaddr = lpfc_cmd->dma_handle; 1241 data_bde->tus.f.bdeFlags = BUFF_TYPE_BLP_64; 1242 data_bde->tus.f.bdeSize = (num_bde * 1243 sizeof(struct ulp_bde64)); 1244 physaddr += (sizeof(struct fcp_cmnd) + 1245 sizeof(struct fcp_rsp) + 1246 (2 * sizeof(struct ulp_bde64))); 1247 data_bde->addrHigh = putPaddrHigh(physaddr); 1248 data_bde->addrLow = putPaddrLow(physaddr); 1249 /* ebde count includes the response bde and data bpl */ 1250 iocb_cmd->unsli3.fcp_ext.ebde_count = 2; 1251 } else { 1252 /* ebde count includes the response bde and data bdes */ 1253 iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1); 1254 } 1255 } else { 1256 iocb_cmd->un.fcpi64.bdl.bdeSize = 1257 ((num_bde + 2) * sizeof(struct ulp_bde64)); 1258 iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1); 1259 } 1260 fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd)); 1261 1262 /* 1263 * Due to difference in data length between DIF/non-DIF paths, 1264 * we need to set word 4 of IOCB here 1265 */ 1266 iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd); 1267 return 0; 1268 } 1269 1270 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 1271 1272 /* Return if if error injection is detected by Initiator */ 1273 #define BG_ERR_INIT 0x1 1274 /* Return if if error injection is detected by Target */ 1275 #define BG_ERR_TGT 0x2 1276 /* Return if if swapping CSUM<-->CRC is required for error injection */ 1277 #define BG_ERR_SWAP 0x10 1278 /* Return if disabling Guard/Ref/App checking is required for error injection */ 1279 #define BG_ERR_CHECK 0x20 1280 1281 /** 1282 * lpfc_bg_err_inject - Determine if we should inject an error 1283 * @phba: The Hba for which this call is being executed. 1284 * @sc: The SCSI command to examine 1285 * @reftag: (out) BlockGuard reference tag for transmitted data 1286 * @apptag: (out) BlockGuard application tag for transmitted data 1287 * @new_guard (in) Value to replace CRC with if needed 1288 * 1289 * Returns BG_ERR_* bit mask or 0 if request ignored 1290 **/ 1291 static int 1292 lpfc_bg_err_inject(struct lpfc_hba *phba, struct scsi_cmnd *sc, 1293 uint32_t *reftag, uint16_t *apptag, uint32_t new_guard) 1294 { 1295 struct scatterlist *sgpe; /* s/g prot entry */ 1296 struct lpfc_scsi_buf *lpfc_cmd = NULL; 1297 struct scsi_dif_tuple *src = NULL; 1298 struct lpfc_nodelist *ndlp; 1299 struct lpfc_rport_data *rdata; 1300 uint32_t op = scsi_get_prot_op(sc); 1301 uint32_t blksize; 1302 uint32_t numblks; 1303 sector_t lba; 1304 int rc = 0; 1305 int blockoff = 0; 1306 1307 if (op == SCSI_PROT_NORMAL) 1308 return 0; 1309 1310 sgpe = scsi_prot_sglist(sc); 1311 lba = scsi_get_lba(sc); 1312 1313 /* First check if we need to match the LBA */ 1314 if (phba->lpfc_injerr_lba != LPFC_INJERR_LBA_OFF) { 1315 blksize = lpfc_cmd_blksize(sc); 1316 numblks = (scsi_bufflen(sc) + blksize - 1) / blksize; 1317 1318 /* Make sure we have the right LBA if one is specified */ 1319 if ((phba->lpfc_injerr_lba < lba) || 1320 (phba->lpfc_injerr_lba >= (lba + numblks))) 1321 return 0; 1322 if (sgpe) { 1323 blockoff = phba->lpfc_injerr_lba - lba; 1324 numblks = sg_dma_len(sgpe) / 1325 sizeof(struct scsi_dif_tuple); 1326 if (numblks < blockoff) 1327 blockoff = numblks; 1328 } 1329 } 1330 1331 /* Next check if we need to match the remote NPortID or WWPN */ 1332 rdata = lpfc_rport_data_from_scsi_device(sc->device); 1333 if (rdata && rdata->pnode) { 1334 ndlp = rdata->pnode; 1335 1336 /* Make sure we have the right NPortID if one is specified */ 1337 if (phba->lpfc_injerr_nportid && 1338 (phba->lpfc_injerr_nportid != ndlp->nlp_DID)) 1339 return 0; 1340 1341 /* 1342 * Make sure we have the right WWPN if one is specified. 1343 * wwn[0] should be a non-zero NAA in a good WWPN. 1344 */ 1345 if (phba->lpfc_injerr_wwpn.u.wwn[0] && 1346 (memcmp(&ndlp->nlp_portname, &phba->lpfc_injerr_wwpn, 1347 sizeof(struct lpfc_name)) != 0)) 1348 return 0; 1349 } 1350 1351 /* Setup a ptr to the protection data if the SCSI host provides it */ 1352 if (sgpe) { 1353 src = (struct scsi_dif_tuple *)sg_virt(sgpe); 1354 src += blockoff; 1355 lpfc_cmd = (struct lpfc_scsi_buf *)sc->host_scribble; 1356 } 1357 1358 /* Should we change the Reference Tag */ 1359 if (reftag) { 1360 if (phba->lpfc_injerr_wref_cnt) { 1361 switch (op) { 1362 case SCSI_PROT_WRITE_PASS: 1363 if (src) { 1364 /* 1365 * For WRITE_PASS, force the error 1366 * to be sent on the wire. It should 1367 * be detected by the Target. 1368 * If blockoff != 0 error will be 1369 * inserted in middle of the IO. 1370 */ 1371 1372 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1373 "9076 BLKGRD: Injecting reftag error: " 1374 "write lba x%lx + x%x oldrefTag x%x\n", 1375 (unsigned long)lba, blockoff, 1376 be32_to_cpu(src->ref_tag)); 1377 1378 /* 1379 * Save the old ref_tag so we can 1380 * restore it on completion. 1381 */ 1382 if (lpfc_cmd) { 1383 lpfc_cmd->prot_data_type = 1384 LPFC_INJERR_REFTAG; 1385 lpfc_cmd->prot_data_segment = 1386 src; 1387 lpfc_cmd->prot_data = 1388 src->ref_tag; 1389 } 1390 src->ref_tag = cpu_to_be32(0xDEADBEEF); 1391 phba->lpfc_injerr_wref_cnt--; 1392 if (phba->lpfc_injerr_wref_cnt == 0) { 1393 phba->lpfc_injerr_nportid = 0; 1394 phba->lpfc_injerr_lba = 1395 LPFC_INJERR_LBA_OFF; 1396 memset(&phba->lpfc_injerr_wwpn, 1397 0, sizeof(struct lpfc_name)); 1398 } 1399 rc = BG_ERR_TGT | BG_ERR_CHECK; 1400 1401 break; 1402 } 1403 /* Drop thru */ 1404 case SCSI_PROT_WRITE_INSERT: 1405 /* 1406 * For WRITE_INSERT, force the error 1407 * to be sent on the wire. It should be 1408 * detected by the Target. 1409 */ 1410 /* DEADBEEF will be the reftag on the wire */ 1411 *reftag = 0xDEADBEEF; 1412 phba->lpfc_injerr_wref_cnt--; 1413 if (phba->lpfc_injerr_wref_cnt == 0) { 1414 phba->lpfc_injerr_nportid = 0; 1415 phba->lpfc_injerr_lba = 1416 LPFC_INJERR_LBA_OFF; 1417 memset(&phba->lpfc_injerr_wwpn, 1418 0, sizeof(struct lpfc_name)); 1419 } 1420 rc = BG_ERR_TGT | BG_ERR_CHECK; 1421 1422 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1423 "9078 BLKGRD: Injecting reftag error: " 1424 "write lba x%lx\n", (unsigned long)lba); 1425 break; 1426 case SCSI_PROT_WRITE_STRIP: 1427 /* 1428 * For WRITE_STRIP and WRITE_PASS, 1429 * force the error on data 1430 * being copied from SLI-Host to SLI-Port. 1431 */ 1432 *reftag = 0xDEADBEEF; 1433 phba->lpfc_injerr_wref_cnt--; 1434 if (phba->lpfc_injerr_wref_cnt == 0) { 1435 phba->lpfc_injerr_nportid = 0; 1436 phba->lpfc_injerr_lba = 1437 LPFC_INJERR_LBA_OFF; 1438 memset(&phba->lpfc_injerr_wwpn, 1439 0, sizeof(struct lpfc_name)); 1440 } 1441 rc = BG_ERR_INIT; 1442 1443 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1444 "9077 BLKGRD: Injecting reftag error: " 1445 "write lba x%lx\n", (unsigned long)lba); 1446 break; 1447 } 1448 } 1449 if (phba->lpfc_injerr_rref_cnt) { 1450 switch (op) { 1451 case SCSI_PROT_READ_INSERT: 1452 case SCSI_PROT_READ_STRIP: 1453 case SCSI_PROT_READ_PASS: 1454 /* 1455 * For READ_STRIP and READ_PASS, force the 1456 * error on data being read off the wire. It 1457 * should force an IO error to the driver. 1458 */ 1459 *reftag = 0xDEADBEEF; 1460 phba->lpfc_injerr_rref_cnt--; 1461 if (phba->lpfc_injerr_rref_cnt == 0) { 1462 phba->lpfc_injerr_nportid = 0; 1463 phba->lpfc_injerr_lba = 1464 LPFC_INJERR_LBA_OFF; 1465 memset(&phba->lpfc_injerr_wwpn, 1466 0, sizeof(struct lpfc_name)); 1467 } 1468 rc = BG_ERR_INIT; 1469 1470 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1471 "9079 BLKGRD: Injecting reftag error: " 1472 "read lba x%lx\n", (unsigned long)lba); 1473 break; 1474 } 1475 } 1476 } 1477 1478 /* Should we change the Application Tag */ 1479 if (apptag) { 1480 if (phba->lpfc_injerr_wapp_cnt) { 1481 switch (op) { 1482 case SCSI_PROT_WRITE_PASS: 1483 if (src) { 1484 /* 1485 * For WRITE_PASS, force the error 1486 * to be sent on the wire. It should 1487 * be detected by the Target. 1488 * If blockoff != 0 error will be 1489 * inserted in middle of the IO. 1490 */ 1491 1492 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1493 "9080 BLKGRD: Injecting apptag error: " 1494 "write lba x%lx + x%x oldappTag x%x\n", 1495 (unsigned long)lba, blockoff, 1496 be16_to_cpu(src->app_tag)); 1497 1498 /* 1499 * Save the old app_tag so we can 1500 * restore it on completion. 1501 */ 1502 if (lpfc_cmd) { 1503 lpfc_cmd->prot_data_type = 1504 LPFC_INJERR_APPTAG; 1505 lpfc_cmd->prot_data_segment = 1506 src; 1507 lpfc_cmd->prot_data = 1508 src->app_tag; 1509 } 1510 src->app_tag = cpu_to_be16(0xDEAD); 1511 phba->lpfc_injerr_wapp_cnt--; 1512 if (phba->lpfc_injerr_wapp_cnt == 0) { 1513 phba->lpfc_injerr_nportid = 0; 1514 phba->lpfc_injerr_lba = 1515 LPFC_INJERR_LBA_OFF; 1516 memset(&phba->lpfc_injerr_wwpn, 1517 0, sizeof(struct lpfc_name)); 1518 } 1519 rc = BG_ERR_TGT | BG_ERR_CHECK; 1520 break; 1521 } 1522 /* Drop thru */ 1523 case SCSI_PROT_WRITE_INSERT: 1524 /* 1525 * For WRITE_INSERT, force the 1526 * error to be sent on the wire. It should be 1527 * detected by the Target. 1528 */ 1529 /* DEAD will be the apptag on the wire */ 1530 *apptag = 0xDEAD; 1531 phba->lpfc_injerr_wapp_cnt--; 1532 if (phba->lpfc_injerr_wapp_cnt == 0) { 1533 phba->lpfc_injerr_nportid = 0; 1534 phba->lpfc_injerr_lba = 1535 LPFC_INJERR_LBA_OFF; 1536 memset(&phba->lpfc_injerr_wwpn, 1537 0, sizeof(struct lpfc_name)); 1538 } 1539 rc = BG_ERR_TGT | BG_ERR_CHECK; 1540 1541 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1542 "0813 BLKGRD: Injecting apptag error: " 1543 "write lba x%lx\n", (unsigned long)lba); 1544 break; 1545 case SCSI_PROT_WRITE_STRIP: 1546 /* 1547 * For WRITE_STRIP and WRITE_PASS, 1548 * force the error on data 1549 * being copied from SLI-Host to SLI-Port. 1550 */ 1551 *apptag = 0xDEAD; 1552 phba->lpfc_injerr_wapp_cnt--; 1553 if (phba->lpfc_injerr_wapp_cnt == 0) { 1554 phba->lpfc_injerr_nportid = 0; 1555 phba->lpfc_injerr_lba = 1556 LPFC_INJERR_LBA_OFF; 1557 memset(&phba->lpfc_injerr_wwpn, 1558 0, sizeof(struct lpfc_name)); 1559 } 1560 rc = BG_ERR_INIT; 1561 1562 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1563 "0812 BLKGRD: Injecting apptag error: " 1564 "write lba x%lx\n", (unsigned long)lba); 1565 break; 1566 } 1567 } 1568 if (phba->lpfc_injerr_rapp_cnt) { 1569 switch (op) { 1570 case SCSI_PROT_READ_INSERT: 1571 case SCSI_PROT_READ_STRIP: 1572 case SCSI_PROT_READ_PASS: 1573 /* 1574 * For READ_STRIP and READ_PASS, force the 1575 * error on data being read off the wire. It 1576 * should force an IO error to the driver. 1577 */ 1578 *apptag = 0xDEAD; 1579 phba->lpfc_injerr_rapp_cnt--; 1580 if (phba->lpfc_injerr_rapp_cnt == 0) { 1581 phba->lpfc_injerr_nportid = 0; 1582 phba->lpfc_injerr_lba = 1583 LPFC_INJERR_LBA_OFF; 1584 memset(&phba->lpfc_injerr_wwpn, 1585 0, sizeof(struct lpfc_name)); 1586 } 1587 rc = BG_ERR_INIT; 1588 1589 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1590 "0814 BLKGRD: Injecting apptag error: " 1591 "read lba x%lx\n", (unsigned long)lba); 1592 break; 1593 } 1594 } 1595 } 1596 1597 1598 /* Should we change the Guard Tag */ 1599 if (new_guard) { 1600 if (phba->lpfc_injerr_wgrd_cnt) { 1601 switch (op) { 1602 case SCSI_PROT_WRITE_PASS: 1603 rc = BG_ERR_CHECK; 1604 /* Drop thru */ 1605 1606 case SCSI_PROT_WRITE_INSERT: 1607 /* 1608 * For WRITE_INSERT, force the 1609 * error to be sent on the wire. It should be 1610 * detected by the Target. 1611 */ 1612 phba->lpfc_injerr_wgrd_cnt--; 1613 if (phba->lpfc_injerr_wgrd_cnt == 0) { 1614 phba->lpfc_injerr_nportid = 0; 1615 phba->lpfc_injerr_lba = 1616 LPFC_INJERR_LBA_OFF; 1617 memset(&phba->lpfc_injerr_wwpn, 1618 0, sizeof(struct lpfc_name)); 1619 } 1620 1621 rc |= BG_ERR_TGT | BG_ERR_SWAP; 1622 /* Signals the caller to swap CRC->CSUM */ 1623 1624 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1625 "0817 BLKGRD: Injecting guard error: " 1626 "write lba x%lx\n", (unsigned long)lba); 1627 break; 1628 case SCSI_PROT_WRITE_STRIP: 1629 /* 1630 * For WRITE_STRIP and WRITE_PASS, 1631 * force the error on data 1632 * being copied from SLI-Host to SLI-Port. 1633 */ 1634 phba->lpfc_injerr_wgrd_cnt--; 1635 if (phba->lpfc_injerr_wgrd_cnt == 0) { 1636 phba->lpfc_injerr_nportid = 0; 1637 phba->lpfc_injerr_lba = 1638 LPFC_INJERR_LBA_OFF; 1639 memset(&phba->lpfc_injerr_wwpn, 1640 0, sizeof(struct lpfc_name)); 1641 } 1642 1643 rc = BG_ERR_INIT | BG_ERR_SWAP; 1644 /* Signals the caller to swap CRC->CSUM */ 1645 1646 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1647 "0816 BLKGRD: Injecting guard error: " 1648 "write lba x%lx\n", (unsigned long)lba); 1649 break; 1650 } 1651 } 1652 if (phba->lpfc_injerr_rgrd_cnt) { 1653 switch (op) { 1654 case SCSI_PROT_READ_INSERT: 1655 case SCSI_PROT_READ_STRIP: 1656 case SCSI_PROT_READ_PASS: 1657 /* 1658 * For READ_STRIP and READ_PASS, force the 1659 * error on data being read off the wire. It 1660 * should force an IO error to the driver. 1661 */ 1662 phba->lpfc_injerr_rgrd_cnt--; 1663 if (phba->lpfc_injerr_rgrd_cnt == 0) { 1664 phba->lpfc_injerr_nportid = 0; 1665 phba->lpfc_injerr_lba = 1666 LPFC_INJERR_LBA_OFF; 1667 memset(&phba->lpfc_injerr_wwpn, 1668 0, sizeof(struct lpfc_name)); 1669 } 1670 1671 rc = BG_ERR_INIT | BG_ERR_SWAP; 1672 /* Signals the caller to swap CRC->CSUM */ 1673 1674 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1675 "0818 BLKGRD: Injecting guard error: " 1676 "read lba x%lx\n", (unsigned long)lba); 1677 } 1678 } 1679 } 1680 1681 return rc; 1682 } 1683 #endif 1684 1685 /** 1686 * lpfc_sc_to_bg_opcodes - Determine the BlockGuard opcodes to be used with 1687 * the specified SCSI command. 1688 * @phba: The Hba for which this call is being executed. 1689 * @sc: The SCSI command to examine 1690 * @txopt: (out) BlockGuard operation for transmitted data 1691 * @rxopt: (out) BlockGuard operation for received data 1692 * 1693 * Returns: zero on success; non-zero if tx and/or rx op cannot be determined 1694 * 1695 **/ 1696 static int 1697 lpfc_sc_to_bg_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc, 1698 uint8_t *txop, uint8_t *rxop) 1699 { 1700 uint8_t ret = 0; 1701 1702 if (lpfc_cmd_guard_csum(sc)) { 1703 switch (scsi_get_prot_op(sc)) { 1704 case SCSI_PROT_READ_INSERT: 1705 case SCSI_PROT_WRITE_STRIP: 1706 *rxop = BG_OP_IN_NODIF_OUT_CSUM; 1707 *txop = BG_OP_IN_CSUM_OUT_NODIF; 1708 break; 1709 1710 case SCSI_PROT_READ_STRIP: 1711 case SCSI_PROT_WRITE_INSERT: 1712 *rxop = BG_OP_IN_CRC_OUT_NODIF; 1713 *txop = BG_OP_IN_NODIF_OUT_CRC; 1714 break; 1715 1716 case SCSI_PROT_READ_PASS: 1717 case SCSI_PROT_WRITE_PASS: 1718 *rxop = BG_OP_IN_CRC_OUT_CSUM; 1719 *txop = BG_OP_IN_CSUM_OUT_CRC; 1720 break; 1721 1722 case SCSI_PROT_NORMAL: 1723 default: 1724 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1725 "9063 BLKGRD: Bad op/guard:%d/IP combination\n", 1726 scsi_get_prot_op(sc)); 1727 ret = 1; 1728 break; 1729 1730 } 1731 } else { 1732 switch (scsi_get_prot_op(sc)) { 1733 case SCSI_PROT_READ_STRIP: 1734 case SCSI_PROT_WRITE_INSERT: 1735 *rxop = BG_OP_IN_CRC_OUT_NODIF; 1736 *txop = BG_OP_IN_NODIF_OUT_CRC; 1737 break; 1738 1739 case SCSI_PROT_READ_PASS: 1740 case SCSI_PROT_WRITE_PASS: 1741 *rxop = BG_OP_IN_CRC_OUT_CRC; 1742 *txop = BG_OP_IN_CRC_OUT_CRC; 1743 break; 1744 1745 case SCSI_PROT_READ_INSERT: 1746 case SCSI_PROT_WRITE_STRIP: 1747 *rxop = BG_OP_IN_NODIF_OUT_CRC; 1748 *txop = BG_OP_IN_CRC_OUT_NODIF; 1749 break; 1750 1751 case SCSI_PROT_NORMAL: 1752 default: 1753 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 1754 "9075 BLKGRD: Bad op/guard:%d/CRC combination\n", 1755 scsi_get_prot_op(sc)); 1756 ret = 1; 1757 break; 1758 } 1759 } 1760 1761 return ret; 1762 } 1763 1764 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 1765 /** 1766 * lpfc_bg_err_opcodes - reDetermine the BlockGuard opcodes to be used with 1767 * the specified SCSI command in order to force a guard tag error. 1768 * @phba: The Hba for which this call is being executed. 1769 * @sc: The SCSI command to examine 1770 * @txopt: (out) BlockGuard operation for transmitted data 1771 * @rxopt: (out) BlockGuard operation for received data 1772 * 1773 * Returns: zero on success; non-zero if tx and/or rx op cannot be determined 1774 * 1775 **/ 1776 static int 1777 lpfc_bg_err_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc, 1778 uint8_t *txop, uint8_t *rxop) 1779 { 1780 uint8_t ret = 0; 1781 1782 if (lpfc_cmd_guard_csum(sc)) { 1783 switch (scsi_get_prot_op(sc)) { 1784 case SCSI_PROT_READ_INSERT: 1785 case SCSI_PROT_WRITE_STRIP: 1786 *rxop = BG_OP_IN_NODIF_OUT_CRC; 1787 *txop = BG_OP_IN_CRC_OUT_NODIF; 1788 break; 1789 1790 case SCSI_PROT_READ_STRIP: 1791 case SCSI_PROT_WRITE_INSERT: 1792 *rxop = BG_OP_IN_CSUM_OUT_NODIF; 1793 *txop = BG_OP_IN_NODIF_OUT_CSUM; 1794 break; 1795 1796 case SCSI_PROT_READ_PASS: 1797 case SCSI_PROT_WRITE_PASS: 1798 *rxop = BG_OP_IN_CSUM_OUT_CRC; 1799 *txop = BG_OP_IN_CRC_OUT_CSUM; 1800 break; 1801 1802 case SCSI_PROT_NORMAL: 1803 default: 1804 break; 1805 1806 } 1807 } else { 1808 switch (scsi_get_prot_op(sc)) { 1809 case SCSI_PROT_READ_STRIP: 1810 case SCSI_PROT_WRITE_INSERT: 1811 *rxop = BG_OP_IN_CSUM_OUT_NODIF; 1812 *txop = BG_OP_IN_NODIF_OUT_CSUM; 1813 break; 1814 1815 case SCSI_PROT_READ_PASS: 1816 case SCSI_PROT_WRITE_PASS: 1817 *rxop = BG_OP_IN_CSUM_OUT_CSUM; 1818 *txop = BG_OP_IN_CSUM_OUT_CSUM; 1819 break; 1820 1821 case SCSI_PROT_READ_INSERT: 1822 case SCSI_PROT_WRITE_STRIP: 1823 *rxop = BG_OP_IN_NODIF_OUT_CSUM; 1824 *txop = BG_OP_IN_CSUM_OUT_NODIF; 1825 break; 1826 1827 case SCSI_PROT_NORMAL: 1828 default: 1829 break; 1830 } 1831 } 1832 1833 return ret; 1834 } 1835 #endif 1836 1837 /** 1838 * lpfc_bg_setup_bpl - Setup BlockGuard BPL with no protection data 1839 * @phba: The Hba for which this call is being executed. 1840 * @sc: pointer to scsi command we're working on 1841 * @bpl: pointer to buffer list for protection groups 1842 * @datacnt: number of segments of data that have been dma mapped 1843 * 1844 * This function sets up BPL buffer list for protection groups of 1845 * type LPFC_PG_TYPE_NO_DIF 1846 * 1847 * This is usually used when the HBA is instructed to generate 1848 * DIFs and insert them into data stream (or strip DIF from 1849 * incoming data stream) 1850 * 1851 * The buffer list consists of just one protection group described 1852 * below: 1853 * +-------------------------+ 1854 * start of prot group --> | PDE_5 | 1855 * +-------------------------+ 1856 * | PDE_6 | 1857 * +-------------------------+ 1858 * | Data BDE | 1859 * +-------------------------+ 1860 * |more Data BDE's ... (opt)| 1861 * +-------------------------+ 1862 * 1863 * 1864 * Note: Data s/g buffers have been dma mapped 1865 * 1866 * Returns the number of BDEs added to the BPL. 1867 **/ 1868 static int 1869 lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc, 1870 struct ulp_bde64 *bpl, int datasegcnt) 1871 { 1872 struct scatterlist *sgde = NULL; /* s/g data entry */ 1873 struct lpfc_pde5 *pde5 = NULL; 1874 struct lpfc_pde6 *pde6 = NULL; 1875 dma_addr_t physaddr; 1876 int i = 0, num_bde = 0, status; 1877 int datadir = sc->sc_data_direction; 1878 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 1879 uint32_t rc; 1880 #endif 1881 uint32_t checking = 1; 1882 uint32_t reftag; 1883 uint8_t txop, rxop; 1884 1885 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop); 1886 if (status) 1887 goto out; 1888 1889 /* extract some info from the scsi command for pde*/ 1890 reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */ 1891 1892 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 1893 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1); 1894 if (rc) { 1895 if (rc & BG_ERR_SWAP) 1896 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop); 1897 if (rc & BG_ERR_CHECK) 1898 checking = 0; 1899 } 1900 #endif 1901 1902 /* setup PDE5 with what we have */ 1903 pde5 = (struct lpfc_pde5 *) bpl; 1904 memset(pde5, 0, sizeof(struct lpfc_pde5)); 1905 bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR); 1906 1907 /* Endianness conversion if necessary for PDE5 */ 1908 pde5->word0 = cpu_to_le32(pde5->word0); 1909 pde5->reftag = cpu_to_le32(reftag); 1910 1911 /* advance bpl and increment bde count */ 1912 num_bde++; 1913 bpl++; 1914 pde6 = (struct lpfc_pde6 *) bpl; 1915 1916 /* setup PDE6 with the rest of the info */ 1917 memset(pde6, 0, sizeof(struct lpfc_pde6)); 1918 bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR); 1919 bf_set(pde6_optx, pde6, txop); 1920 bf_set(pde6_oprx, pde6, rxop); 1921 1922 /* 1923 * We only need to check the data on READs, for WRITEs 1924 * protection data is automatically generated, not checked. 1925 */ 1926 if (datadir == DMA_FROM_DEVICE) { 1927 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD)) 1928 bf_set(pde6_ce, pde6, checking); 1929 else 1930 bf_set(pde6_ce, pde6, 0); 1931 1932 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF)) 1933 bf_set(pde6_re, pde6, checking); 1934 else 1935 bf_set(pde6_re, pde6, 0); 1936 } 1937 bf_set(pde6_ai, pde6, 1); 1938 bf_set(pde6_ae, pde6, 0); 1939 bf_set(pde6_apptagval, pde6, 0); 1940 1941 /* Endianness conversion if necessary for PDE6 */ 1942 pde6->word0 = cpu_to_le32(pde6->word0); 1943 pde6->word1 = cpu_to_le32(pde6->word1); 1944 pde6->word2 = cpu_to_le32(pde6->word2); 1945 1946 /* advance bpl and increment bde count */ 1947 num_bde++; 1948 bpl++; 1949 1950 /* assumption: caller has already run dma_map_sg on command data */ 1951 scsi_for_each_sg(sc, sgde, datasegcnt, i) { 1952 physaddr = sg_dma_address(sgde); 1953 bpl->addrLow = le32_to_cpu(putPaddrLow(physaddr)); 1954 bpl->addrHigh = le32_to_cpu(putPaddrHigh(physaddr)); 1955 bpl->tus.f.bdeSize = sg_dma_len(sgde); 1956 if (datadir == DMA_TO_DEVICE) 1957 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64; 1958 else 1959 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I; 1960 bpl->tus.w = le32_to_cpu(bpl->tus.w); 1961 bpl++; 1962 num_bde++; 1963 } 1964 1965 out: 1966 return num_bde; 1967 } 1968 1969 /** 1970 * lpfc_bg_setup_bpl_prot - Setup BlockGuard BPL with protection data 1971 * @phba: The Hba for which this call is being executed. 1972 * @sc: pointer to scsi command we're working on 1973 * @bpl: pointer to buffer list for protection groups 1974 * @datacnt: number of segments of data that have been dma mapped 1975 * @protcnt: number of segment of protection data that have been dma mapped 1976 * 1977 * This function sets up BPL buffer list for protection groups of 1978 * type LPFC_PG_TYPE_DIF 1979 * 1980 * This is usually used when DIFs are in their own buffers, 1981 * separate from the data. The HBA can then by instructed 1982 * to place the DIFs in the outgoing stream. For read operations, 1983 * The HBA could extract the DIFs and place it in DIF buffers. 1984 * 1985 * The buffer list for this type consists of one or more of the 1986 * protection groups described below: 1987 * +-------------------------+ 1988 * start of first prot group --> | PDE_5 | 1989 * +-------------------------+ 1990 * | PDE_6 | 1991 * +-------------------------+ 1992 * | PDE_7 (Prot BDE) | 1993 * +-------------------------+ 1994 * | Data BDE | 1995 * +-------------------------+ 1996 * |more Data BDE's ... (opt)| 1997 * +-------------------------+ 1998 * start of new prot group --> | PDE_5 | 1999 * +-------------------------+ 2000 * | ... | 2001 * +-------------------------+ 2002 * 2003 * Note: It is assumed that both data and protection s/g buffers have been 2004 * mapped for DMA 2005 * 2006 * Returns the number of BDEs added to the BPL. 2007 **/ 2008 static int 2009 lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc, 2010 struct ulp_bde64 *bpl, int datacnt, int protcnt) 2011 { 2012 struct scatterlist *sgde = NULL; /* s/g data entry */ 2013 struct scatterlist *sgpe = NULL; /* s/g prot entry */ 2014 struct lpfc_pde5 *pde5 = NULL; 2015 struct lpfc_pde6 *pde6 = NULL; 2016 struct lpfc_pde7 *pde7 = NULL; 2017 dma_addr_t dataphysaddr, protphysaddr; 2018 unsigned short curr_data = 0, curr_prot = 0; 2019 unsigned int split_offset; 2020 unsigned int protgroup_len, protgroup_offset = 0, protgroup_remainder; 2021 unsigned int protgrp_blks, protgrp_bytes; 2022 unsigned int remainder, subtotal; 2023 int status; 2024 int datadir = sc->sc_data_direction; 2025 unsigned char pgdone = 0, alldone = 0; 2026 unsigned blksize; 2027 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 2028 uint32_t rc; 2029 #endif 2030 uint32_t checking = 1; 2031 uint32_t reftag; 2032 uint8_t txop, rxop; 2033 int num_bde = 0; 2034 2035 sgpe = scsi_prot_sglist(sc); 2036 sgde = scsi_sglist(sc); 2037 2038 if (!sgpe || !sgde) { 2039 lpfc_printf_log(phba, KERN_ERR, LOG_FCP, 2040 "9020 Invalid s/g entry: data=0x%p prot=0x%p\n", 2041 sgpe, sgde); 2042 return 0; 2043 } 2044 2045 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop); 2046 if (status) 2047 goto out; 2048 2049 /* extract some info from the scsi command */ 2050 blksize = lpfc_cmd_blksize(sc); 2051 reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */ 2052 2053 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 2054 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1); 2055 if (rc) { 2056 if (rc & BG_ERR_SWAP) 2057 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop); 2058 if (rc & BG_ERR_CHECK) 2059 checking = 0; 2060 } 2061 #endif 2062 2063 split_offset = 0; 2064 do { 2065 /* Check to see if we ran out of space */ 2066 if (num_bde >= (phba->cfg_total_seg_cnt - 2)) 2067 return num_bde + 3; 2068 2069 /* setup PDE5 with what we have */ 2070 pde5 = (struct lpfc_pde5 *) bpl; 2071 memset(pde5, 0, sizeof(struct lpfc_pde5)); 2072 bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR); 2073 2074 /* Endianness conversion if necessary for PDE5 */ 2075 pde5->word0 = cpu_to_le32(pde5->word0); 2076 pde5->reftag = cpu_to_le32(reftag); 2077 2078 /* advance bpl and increment bde count */ 2079 num_bde++; 2080 bpl++; 2081 pde6 = (struct lpfc_pde6 *) bpl; 2082 2083 /* setup PDE6 with the rest of the info */ 2084 memset(pde6, 0, sizeof(struct lpfc_pde6)); 2085 bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR); 2086 bf_set(pde6_optx, pde6, txop); 2087 bf_set(pde6_oprx, pde6, rxop); 2088 2089 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD)) 2090 bf_set(pde6_ce, pde6, checking); 2091 else 2092 bf_set(pde6_ce, pde6, 0); 2093 2094 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF)) 2095 bf_set(pde6_re, pde6, checking); 2096 else 2097 bf_set(pde6_re, pde6, 0); 2098 2099 bf_set(pde6_ai, pde6, 1); 2100 bf_set(pde6_ae, pde6, 0); 2101 bf_set(pde6_apptagval, pde6, 0); 2102 2103 /* Endianness conversion if necessary for PDE6 */ 2104 pde6->word0 = cpu_to_le32(pde6->word0); 2105 pde6->word1 = cpu_to_le32(pde6->word1); 2106 pde6->word2 = cpu_to_le32(pde6->word2); 2107 2108 /* advance bpl and increment bde count */ 2109 num_bde++; 2110 bpl++; 2111 2112 /* setup the first BDE that points to protection buffer */ 2113 protphysaddr = sg_dma_address(sgpe) + protgroup_offset; 2114 protgroup_len = sg_dma_len(sgpe) - protgroup_offset; 2115 2116 /* must be integer multiple of the DIF block length */ 2117 BUG_ON(protgroup_len % 8); 2118 2119 pde7 = (struct lpfc_pde7 *) bpl; 2120 memset(pde7, 0, sizeof(struct lpfc_pde7)); 2121 bf_set(pde7_type, pde7, LPFC_PDE7_DESCRIPTOR); 2122 2123 pde7->addrHigh = le32_to_cpu(putPaddrHigh(protphysaddr)); 2124 pde7->addrLow = le32_to_cpu(putPaddrLow(protphysaddr)); 2125 2126 protgrp_blks = protgroup_len / 8; 2127 protgrp_bytes = protgrp_blks * blksize; 2128 2129 /* check if this pde is crossing the 4K boundary; if so split */ 2130 if ((pde7->addrLow & 0xfff) + protgroup_len > 0x1000) { 2131 protgroup_remainder = 0x1000 - (pde7->addrLow & 0xfff); 2132 protgroup_offset += protgroup_remainder; 2133 protgrp_blks = protgroup_remainder / 8; 2134 protgrp_bytes = protgrp_blks * blksize; 2135 } else { 2136 protgroup_offset = 0; 2137 curr_prot++; 2138 } 2139 2140 num_bde++; 2141 2142 /* setup BDE's for data blocks associated with DIF data */ 2143 pgdone = 0; 2144 subtotal = 0; /* total bytes processed for current prot grp */ 2145 while (!pgdone) { 2146 /* Check to see if we ran out of space */ 2147 if (num_bde >= phba->cfg_total_seg_cnt) 2148 return num_bde + 1; 2149 2150 if (!sgde) { 2151 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 2152 "9065 BLKGRD:%s Invalid data segment\n", 2153 __func__); 2154 return 0; 2155 } 2156 bpl++; 2157 dataphysaddr = sg_dma_address(sgde) + split_offset; 2158 bpl->addrLow = le32_to_cpu(putPaddrLow(dataphysaddr)); 2159 bpl->addrHigh = le32_to_cpu(putPaddrHigh(dataphysaddr)); 2160 2161 remainder = sg_dma_len(sgde) - split_offset; 2162 2163 if ((subtotal + remainder) <= protgrp_bytes) { 2164 /* we can use this whole buffer */ 2165 bpl->tus.f.bdeSize = remainder; 2166 split_offset = 0; 2167 2168 if ((subtotal + remainder) == protgrp_bytes) 2169 pgdone = 1; 2170 } else { 2171 /* must split this buffer with next prot grp */ 2172 bpl->tus.f.bdeSize = protgrp_bytes - subtotal; 2173 split_offset += bpl->tus.f.bdeSize; 2174 } 2175 2176 subtotal += bpl->tus.f.bdeSize; 2177 2178 if (datadir == DMA_TO_DEVICE) 2179 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64; 2180 else 2181 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I; 2182 bpl->tus.w = le32_to_cpu(bpl->tus.w); 2183 2184 num_bde++; 2185 curr_data++; 2186 2187 if (split_offset) 2188 break; 2189 2190 /* Move to the next s/g segment if possible */ 2191 sgde = sg_next(sgde); 2192 2193 } 2194 2195 if (protgroup_offset) { 2196 /* update the reference tag */ 2197 reftag += protgrp_blks; 2198 bpl++; 2199 continue; 2200 } 2201 2202 /* are we done ? */ 2203 if (curr_prot == protcnt) { 2204 alldone = 1; 2205 } else if (curr_prot < protcnt) { 2206 /* advance to next prot buffer */ 2207 sgpe = sg_next(sgpe); 2208 bpl++; 2209 2210 /* update the reference tag */ 2211 reftag += protgrp_blks; 2212 } else { 2213 /* if we're here, we have a bug */ 2214 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 2215 "9054 BLKGRD: bug in %s\n", __func__); 2216 } 2217 2218 } while (!alldone); 2219 out: 2220 2221 return num_bde; 2222 } 2223 2224 /** 2225 * lpfc_bg_setup_sgl - Setup BlockGuard SGL with no protection data 2226 * @phba: The Hba for which this call is being executed. 2227 * @sc: pointer to scsi command we're working on 2228 * @sgl: pointer to buffer list for protection groups 2229 * @datacnt: number of segments of data that have been dma mapped 2230 * 2231 * This function sets up SGL buffer list for protection groups of 2232 * type LPFC_PG_TYPE_NO_DIF 2233 * 2234 * This is usually used when the HBA is instructed to generate 2235 * DIFs and insert them into data stream (or strip DIF from 2236 * incoming data stream) 2237 * 2238 * The buffer list consists of just one protection group described 2239 * below: 2240 * +-------------------------+ 2241 * start of prot group --> | DI_SEED | 2242 * +-------------------------+ 2243 * | Data SGE | 2244 * +-------------------------+ 2245 * |more Data SGE's ... (opt)| 2246 * +-------------------------+ 2247 * 2248 * 2249 * Note: Data s/g buffers have been dma mapped 2250 * 2251 * Returns the number of SGEs added to the SGL. 2252 **/ 2253 static int 2254 lpfc_bg_setup_sgl(struct lpfc_hba *phba, struct scsi_cmnd *sc, 2255 struct sli4_sge *sgl, int datasegcnt) 2256 { 2257 struct scatterlist *sgde = NULL; /* s/g data entry */ 2258 struct sli4_sge_diseed *diseed = NULL; 2259 dma_addr_t physaddr; 2260 int i = 0, num_sge = 0, status; 2261 uint32_t reftag; 2262 uint8_t txop, rxop; 2263 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 2264 uint32_t rc; 2265 #endif 2266 uint32_t checking = 1; 2267 uint32_t dma_len; 2268 uint32_t dma_offset = 0; 2269 2270 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop); 2271 if (status) 2272 goto out; 2273 2274 /* extract some info from the scsi command for pde*/ 2275 reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */ 2276 2277 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 2278 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1); 2279 if (rc) { 2280 if (rc & BG_ERR_SWAP) 2281 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop); 2282 if (rc & BG_ERR_CHECK) 2283 checking = 0; 2284 } 2285 #endif 2286 2287 /* setup DISEED with what we have */ 2288 diseed = (struct sli4_sge_diseed *) sgl; 2289 memset(diseed, 0, sizeof(struct sli4_sge_diseed)); 2290 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DISEED); 2291 2292 /* Endianness conversion if necessary */ 2293 diseed->ref_tag = cpu_to_le32(reftag); 2294 diseed->ref_tag_tran = diseed->ref_tag; 2295 2296 /* 2297 * We only need to check the data on READs, for WRITEs 2298 * protection data is automatically generated, not checked. 2299 */ 2300 if (sc->sc_data_direction == DMA_FROM_DEVICE) { 2301 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD)) 2302 bf_set(lpfc_sli4_sge_dif_ce, diseed, checking); 2303 else 2304 bf_set(lpfc_sli4_sge_dif_ce, diseed, 0); 2305 2306 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF)) 2307 bf_set(lpfc_sli4_sge_dif_re, diseed, checking); 2308 else 2309 bf_set(lpfc_sli4_sge_dif_re, diseed, 0); 2310 } 2311 2312 /* setup DISEED with the rest of the info */ 2313 bf_set(lpfc_sli4_sge_dif_optx, diseed, txop); 2314 bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop); 2315 2316 bf_set(lpfc_sli4_sge_dif_ai, diseed, 1); 2317 bf_set(lpfc_sli4_sge_dif_me, diseed, 0); 2318 2319 /* Endianness conversion if necessary for DISEED */ 2320 diseed->word2 = cpu_to_le32(diseed->word2); 2321 diseed->word3 = cpu_to_le32(diseed->word3); 2322 2323 /* advance bpl and increment sge count */ 2324 num_sge++; 2325 sgl++; 2326 2327 /* assumption: caller has already run dma_map_sg on command data */ 2328 scsi_for_each_sg(sc, sgde, datasegcnt, i) { 2329 physaddr = sg_dma_address(sgde); 2330 dma_len = sg_dma_len(sgde); 2331 sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr)); 2332 sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr)); 2333 if ((i + 1) == datasegcnt) 2334 bf_set(lpfc_sli4_sge_last, sgl, 1); 2335 else 2336 bf_set(lpfc_sli4_sge_last, sgl, 0); 2337 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset); 2338 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA); 2339 2340 sgl->sge_len = cpu_to_le32(dma_len); 2341 dma_offset += dma_len; 2342 2343 sgl++; 2344 num_sge++; 2345 } 2346 2347 out: 2348 return num_sge; 2349 } 2350 2351 /** 2352 * lpfc_bg_setup_sgl_prot - Setup BlockGuard SGL with protection data 2353 * @phba: The Hba for which this call is being executed. 2354 * @sc: pointer to scsi command we're working on 2355 * @sgl: pointer to buffer list for protection groups 2356 * @datacnt: number of segments of data that have been dma mapped 2357 * @protcnt: number of segment of protection data that have been dma mapped 2358 * 2359 * This function sets up SGL buffer list for protection groups of 2360 * type LPFC_PG_TYPE_DIF 2361 * 2362 * This is usually used when DIFs are in their own buffers, 2363 * separate from the data. The HBA can then by instructed 2364 * to place the DIFs in the outgoing stream. For read operations, 2365 * The HBA could extract the DIFs and place it in DIF buffers. 2366 * 2367 * The buffer list for this type consists of one or more of the 2368 * protection groups described below: 2369 * +-------------------------+ 2370 * start of first prot group --> | DISEED | 2371 * +-------------------------+ 2372 * | DIF (Prot SGE) | 2373 * +-------------------------+ 2374 * | Data SGE | 2375 * +-------------------------+ 2376 * |more Data SGE's ... (opt)| 2377 * +-------------------------+ 2378 * start of new prot group --> | DISEED | 2379 * +-------------------------+ 2380 * | ... | 2381 * +-------------------------+ 2382 * 2383 * Note: It is assumed that both data and protection s/g buffers have been 2384 * mapped for DMA 2385 * 2386 * Returns the number of SGEs added to the SGL. 2387 **/ 2388 static int 2389 lpfc_bg_setup_sgl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc, 2390 struct sli4_sge *sgl, int datacnt, int protcnt) 2391 { 2392 struct scatterlist *sgde = NULL; /* s/g data entry */ 2393 struct scatterlist *sgpe = NULL; /* s/g prot entry */ 2394 struct sli4_sge_diseed *diseed = NULL; 2395 dma_addr_t dataphysaddr, protphysaddr; 2396 unsigned short curr_data = 0, curr_prot = 0; 2397 unsigned int split_offset; 2398 unsigned int protgroup_len, protgroup_offset = 0, protgroup_remainder; 2399 unsigned int protgrp_blks, protgrp_bytes; 2400 unsigned int remainder, subtotal; 2401 int status; 2402 unsigned char pgdone = 0, alldone = 0; 2403 unsigned blksize; 2404 uint32_t reftag; 2405 uint8_t txop, rxop; 2406 uint32_t dma_len; 2407 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 2408 uint32_t rc; 2409 #endif 2410 uint32_t checking = 1; 2411 uint32_t dma_offset = 0; 2412 int num_sge = 0; 2413 2414 sgpe = scsi_prot_sglist(sc); 2415 sgde = scsi_sglist(sc); 2416 2417 if (!sgpe || !sgde) { 2418 lpfc_printf_log(phba, KERN_ERR, LOG_FCP, 2419 "9082 Invalid s/g entry: data=0x%p prot=0x%p\n", 2420 sgpe, sgde); 2421 return 0; 2422 } 2423 2424 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop); 2425 if (status) 2426 goto out; 2427 2428 /* extract some info from the scsi command */ 2429 blksize = lpfc_cmd_blksize(sc); 2430 reftag = (uint32_t)scsi_get_lba(sc); /* Truncate LBA */ 2431 2432 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 2433 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1); 2434 if (rc) { 2435 if (rc & BG_ERR_SWAP) 2436 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop); 2437 if (rc & BG_ERR_CHECK) 2438 checking = 0; 2439 } 2440 #endif 2441 2442 split_offset = 0; 2443 do { 2444 /* Check to see if we ran out of space */ 2445 if (num_sge >= (phba->cfg_total_seg_cnt - 2)) 2446 return num_sge + 3; 2447 2448 /* setup DISEED with what we have */ 2449 diseed = (struct sli4_sge_diseed *) sgl; 2450 memset(diseed, 0, sizeof(struct sli4_sge_diseed)); 2451 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DISEED); 2452 2453 /* Endianness conversion if necessary */ 2454 diseed->ref_tag = cpu_to_le32(reftag); 2455 diseed->ref_tag_tran = diseed->ref_tag; 2456 2457 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD)) { 2458 bf_set(lpfc_sli4_sge_dif_ce, diseed, checking); 2459 2460 } else { 2461 bf_set(lpfc_sli4_sge_dif_ce, diseed, 0); 2462 /* 2463 * When in this mode, the hardware will replace 2464 * the guard tag from the host with a 2465 * newly generated good CRC for the wire. 2466 * Switch to raw mode here to avoid this 2467 * behavior. What the host sends gets put on the wire. 2468 */ 2469 if (txop == BG_OP_IN_CRC_OUT_CRC) { 2470 txop = BG_OP_RAW_MODE; 2471 rxop = BG_OP_RAW_MODE; 2472 } 2473 } 2474 2475 2476 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF)) 2477 bf_set(lpfc_sli4_sge_dif_re, diseed, checking); 2478 else 2479 bf_set(lpfc_sli4_sge_dif_re, diseed, 0); 2480 2481 /* setup DISEED with the rest of the info */ 2482 bf_set(lpfc_sli4_sge_dif_optx, diseed, txop); 2483 bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop); 2484 2485 bf_set(lpfc_sli4_sge_dif_ai, diseed, 1); 2486 bf_set(lpfc_sli4_sge_dif_me, diseed, 0); 2487 2488 /* Endianness conversion if necessary for DISEED */ 2489 diseed->word2 = cpu_to_le32(diseed->word2); 2490 diseed->word3 = cpu_to_le32(diseed->word3); 2491 2492 /* advance sgl and increment bde count */ 2493 num_sge++; 2494 sgl++; 2495 2496 /* setup the first BDE that points to protection buffer */ 2497 protphysaddr = sg_dma_address(sgpe) + protgroup_offset; 2498 protgroup_len = sg_dma_len(sgpe) - protgroup_offset; 2499 2500 /* must be integer multiple of the DIF block length */ 2501 BUG_ON(protgroup_len % 8); 2502 2503 /* Now setup DIF SGE */ 2504 sgl->word2 = 0; 2505 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DIF); 2506 sgl->addr_hi = le32_to_cpu(putPaddrHigh(protphysaddr)); 2507 sgl->addr_lo = le32_to_cpu(putPaddrLow(protphysaddr)); 2508 sgl->word2 = cpu_to_le32(sgl->word2); 2509 2510 protgrp_blks = protgroup_len / 8; 2511 protgrp_bytes = protgrp_blks * blksize; 2512 2513 /* check if DIF SGE is crossing the 4K boundary; if so split */ 2514 if ((sgl->addr_lo & 0xfff) + protgroup_len > 0x1000) { 2515 protgroup_remainder = 0x1000 - (sgl->addr_lo & 0xfff); 2516 protgroup_offset += protgroup_remainder; 2517 protgrp_blks = protgroup_remainder / 8; 2518 protgrp_bytes = protgrp_blks * blksize; 2519 } else { 2520 protgroup_offset = 0; 2521 curr_prot++; 2522 } 2523 2524 num_sge++; 2525 2526 /* setup SGE's for data blocks associated with DIF data */ 2527 pgdone = 0; 2528 subtotal = 0; /* total bytes processed for current prot grp */ 2529 while (!pgdone) { 2530 /* Check to see if we ran out of space */ 2531 if (num_sge >= phba->cfg_total_seg_cnt) 2532 return num_sge + 1; 2533 2534 if (!sgde) { 2535 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 2536 "9086 BLKGRD:%s Invalid data segment\n", 2537 __func__); 2538 return 0; 2539 } 2540 sgl++; 2541 dataphysaddr = sg_dma_address(sgde) + split_offset; 2542 2543 remainder = sg_dma_len(sgde) - split_offset; 2544 2545 if ((subtotal + remainder) <= protgrp_bytes) { 2546 /* we can use this whole buffer */ 2547 dma_len = remainder; 2548 split_offset = 0; 2549 2550 if ((subtotal + remainder) == protgrp_bytes) 2551 pgdone = 1; 2552 } else { 2553 /* must split this buffer with next prot grp */ 2554 dma_len = protgrp_bytes - subtotal; 2555 split_offset += dma_len; 2556 } 2557 2558 subtotal += dma_len; 2559 2560 sgl->addr_lo = cpu_to_le32(putPaddrLow(dataphysaddr)); 2561 sgl->addr_hi = cpu_to_le32(putPaddrHigh(dataphysaddr)); 2562 bf_set(lpfc_sli4_sge_last, sgl, 0); 2563 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset); 2564 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA); 2565 2566 sgl->sge_len = cpu_to_le32(dma_len); 2567 dma_offset += dma_len; 2568 2569 num_sge++; 2570 curr_data++; 2571 2572 if (split_offset) 2573 break; 2574 2575 /* Move to the next s/g segment if possible */ 2576 sgde = sg_next(sgde); 2577 } 2578 2579 if (protgroup_offset) { 2580 /* update the reference tag */ 2581 reftag += protgrp_blks; 2582 sgl++; 2583 continue; 2584 } 2585 2586 /* are we done ? */ 2587 if (curr_prot == protcnt) { 2588 bf_set(lpfc_sli4_sge_last, sgl, 1); 2589 alldone = 1; 2590 } else if (curr_prot < protcnt) { 2591 /* advance to next prot buffer */ 2592 sgpe = sg_next(sgpe); 2593 sgl++; 2594 2595 /* update the reference tag */ 2596 reftag += protgrp_blks; 2597 } else { 2598 /* if we're here, we have a bug */ 2599 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 2600 "9085 BLKGRD: bug in %s\n", __func__); 2601 } 2602 2603 } while (!alldone); 2604 2605 out: 2606 2607 return num_sge; 2608 } 2609 2610 /** 2611 * lpfc_prot_group_type - Get prtotection group type of SCSI command 2612 * @phba: The Hba for which this call is being executed. 2613 * @sc: pointer to scsi command we're working on 2614 * 2615 * Given a SCSI command that supports DIF, determine composition of protection 2616 * groups involved in setting up buffer lists 2617 * 2618 * Returns: Protection group type (with or without DIF) 2619 * 2620 **/ 2621 static int 2622 lpfc_prot_group_type(struct lpfc_hba *phba, struct scsi_cmnd *sc) 2623 { 2624 int ret = LPFC_PG_TYPE_INVALID; 2625 unsigned char op = scsi_get_prot_op(sc); 2626 2627 switch (op) { 2628 case SCSI_PROT_READ_STRIP: 2629 case SCSI_PROT_WRITE_INSERT: 2630 ret = LPFC_PG_TYPE_NO_DIF; 2631 break; 2632 case SCSI_PROT_READ_INSERT: 2633 case SCSI_PROT_WRITE_STRIP: 2634 case SCSI_PROT_READ_PASS: 2635 case SCSI_PROT_WRITE_PASS: 2636 ret = LPFC_PG_TYPE_DIF_BUF; 2637 break; 2638 default: 2639 if (phba) 2640 lpfc_printf_log(phba, KERN_ERR, LOG_FCP, 2641 "9021 Unsupported protection op:%d\n", 2642 op); 2643 break; 2644 } 2645 return ret; 2646 } 2647 2648 /** 2649 * lpfc_bg_scsi_adjust_dl - Adjust SCSI data length for BlockGuard 2650 * @phba: The Hba for which this call is being executed. 2651 * @lpfc_cmd: The scsi buffer which is going to be adjusted. 2652 * 2653 * Adjust the data length to account for how much data 2654 * is actually on the wire. 2655 * 2656 * returns the adjusted data length 2657 **/ 2658 static int 2659 lpfc_bg_scsi_adjust_dl(struct lpfc_hba *phba, 2660 struct lpfc_scsi_buf *lpfc_cmd) 2661 { 2662 struct scsi_cmnd *sc = lpfc_cmd->pCmd; 2663 int fcpdl; 2664 2665 fcpdl = scsi_bufflen(sc); 2666 2667 /* Check if there is protection data on the wire */ 2668 if (sc->sc_data_direction == DMA_FROM_DEVICE) { 2669 /* Read check for protection data */ 2670 if (scsi_get_prot_op(sc) == SCSI_PROT_READ_INSERT) 2671 return fcpdl; 2672 2673 } else { 2674 /* Write check for protection data */ 2675 if (scsi_get_prot_op(sc) == SCSI_PROT_WRITE_STRIP) 2676 return fcpdl; 2677 } 2678 2679 /* 2680 * If we are in DIF Type 1 mode every data block has a 8 byte 2681 * DIF (trailer) attached to it. Must ajust FCP data length 2682 * to account for the protection data. 2683 */ 2684 fcpdl += (fcpdl / lpfc_cmd_blksize(sc)) * 8; 2685 2686 return fcpdl; 2687 } 2688 2689 /** 2690 * lpfc_bg_scsi_prep_dma_buf_s3 - DMA mapping for scsi buffer to SLI3 IF spec 2691 * @phba: The Hba for which this call is being executed. 2692 * @lpfc_cmd: The scsi buffer which is going to be prep'ed. 2693 * 2694 * This is the protection/DIF aware version of 2695 * lpfc_scsi_prep_dma_buf(). It may be a good idea to combine the 2696 * two functions eventually, but for now, it's here 2697 **/ 2698 static int 2699 lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, 2700 struct lpfc_scsi_buf *lpfc_cmd) 2701 { 2702 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd; 2703 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd; 2704 struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl; 2705 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb; 2706 uint32_t num_bde = 0; 2707 int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction; 2708 int prot_group_type = 0; 2709 int fcpdl; 2710 2711 /* 2712 * Start the lpfc command prep by bumping the bpl beyond fcp_cmnd 2713 * fcp_rsp regions to the first data bde entry 2714 */ 2715 bpl += 2; 2716 if (scsi_sg_count(scsi_cmnd)) { 2717 /* 2718 * The driver stores the segment count returned from pci_map_sg 2719 * because this a count of dma-mappings used to map the use_sg 2720 * pages. They are not guaranteed to be the same for those 2721 * architectures that implement an IOMMU. 2722 */ 2723 datasegcnt = dma_map_sg(&phba->pcidev->dev, 2724 scsi_sglist(scsi_cmnd), 2725 scsi_sg_count(scsi_cmnd), datadir); 2726 if (unlikely(!datasegcnt)) 2727 return 1; 2728 2729 lpfc_cmd->seg_cnt = datasegcnt; 2730 2731 /* First check if data segment count from SCSI Layer is good */ 2732 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) 2733 goto err; 2734 2735 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd); 2736 2737 switch (prot_group_type) { 2738 case LPFC_PG_TYPE_NO_DIF: 2739 2740 /* Here we need to add a PDE5 and PDE6 to the count */ 2741 if ((lpfc_cmd->seg_cnt + 2) > phba->cfg_total_seg_cnt) 2742 goto err; 2743 2744 num_bde = lpfc_bg_setup_bpl(phba, scsi_cmnd, bpl, 2745 datasegcnt); 2746 /* we should have 2 or more entries in buffer list */ 2747 if (num_bde < 2) 2748 goto err; 2749 break; 2750 2751 case LPFC_PG_TYPE_DIF_BUF: 2752 /* 2753 * This type indicates that protection buffers are 2754 * passed to the driver, so that needs to be prepared 2755 * for DMA 2756 */ 2757 protsegcnt = dma_map_sg(&phba->pcidev->dev, 2758 scsi_prot_sglist(scsi_cmnd), 2759 scsi_prot_sg_count(scsi_cmnd), datadir); 2760 if (unlikely(!protsegcnt)) { 2761 scsi_dma_unmap(scsi_cmnd); 2762 return 1; 2763 } 2764 2765 lpfc_cmd->prot_seg_cnt = protsegcnt; 2766 2767 /* 2768 * There is a minimun of 4 BPLs used for every 2769 * protection data segment. 2770 */ 2771 if ((lpfc_cmd->prot_seg_cnt * 4) > 2772 (phba->cfg_total_seg_cnt - 2)) 2773 goto err; 2774 2775 num_bde = lpfc_bg_setup_bpl_prot(phba, scsi_cmnd, bpl, 2776 datasegcnt, protsegcnt); 2777 /* we should have 3 or more entries in buffer list */ 2778 if ((num_bde < 3) || 2779 (num_bde > phba->cfg_total_seg_cnt)) 2780 goto err; 2781 break; 2782 2783 case LPFC_PG_TYPE_INVALID: 2784 default: 2785 scsi_dma_unmap(scsi_cmnd); 2786 lpfc_cmd->seg_cnt = 0; 2787 2788 lpfc_printf_log(phba, KERN_ERR, LOG_FCP, 2789 "9022 Unexpected protection group %i\n", 2790 prot_group_type); 2791 return 1; 2792 } 2793 } 2794 2795 /* 2796 * Finish initializing those IOCB fields that are dependent on the 2797 * scsi_cmnd request_buffer. Note that the bdeSize is explicitly 2798 * reinitialized since all iocb memory resources are used many times 2799 * for transmit, receive, and continuation bpl's. 2800 */ 2801 iocb_cmd->un.fcpi64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64)); 2802 iocb_cmd->un.fcpi64.bdl.bdeSize += (num_bde * sizeof(struct ulp_bde64)); 2803 iocb_cmd->ulpBdeCount = 1; 2804 iocb_cmd->ulpLe = 1; 2805 2806 fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd); 2807 fcp_cmnd->fcpDl = be32_to_cpu(fcpdl); 2808 2809 /* 2810 * Due to difference in data length between DIF/non-DIF paths, 2811 * we need to set word 4 of IOCB here 2812 */ 2813 iocb_cmd->un.fcpi.fcpi_parm = fcpdl; 2814 2815 return 0; 2816 err: 2817 if (lpfc_cmd->seg_cnt) 2818 scsi_dma_unmap(scsi_cmnd); 2819 if (lpfc_cmd->prot_seg_cnt) 2820 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(scsi_cmnd), 2821 scsi_prot_sg_count(scsi_cmnd), 2822 scsi_cmnd->sc_data_direction); 2823 2824 lpfc_printf_log(phba, KERN_ERR, LOG_FCP, 2825 "9023 Cannot setup S/G List for HBA" 2826 "IO segs %d/%d BPL %d SCSI %d: %d %d\n", 2827 lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt, 2828 phba->cfg_total_seg_cnt, phba->cfg_sg_seg_cnt, 2829 prot_group_type, num_bde); 2830 2831 lpfc_cmd->seg_cnt = 0; 2832 lpfc_cmd->prot_seg_cnt = 0; 2833 return 1; 2834 } 2835 2836 /* 2837 * This function calcuates the T10 DIF guard tag 2838 * on the specified data using a CRC algorithmn 2839 * using crc_t10dif. 2840 */ 2841 static uint16_t 2842 lpfc_bg_crc(uint8_t *data, int count) 2843 { 2844 uint16_t crc = 0; 2845 uint16_t x; 2846 2847 crc = crc_t10dif(data, count); 2848 x = cpu_to_be16(crc); 2849 return x; 2850 } 2851 2852 /* 2853 * This function calcuates the T10 DIF guard tag 2854 * on the specified data using a CSUM algorithmn 2855 * using ip_compute_csum. 2856 */ 2857 static uint16_t 2858 lpfc_bg_csum(uint8_t *data, int count) 2859 { 2860 uint16_t ret; 2861 2862 ret = ip_compute_csum(data, count); 2863 return ret; 2864 } 2865 2866 /* 2867 * This function examines the protection data to try to determine 2868 * what type of T10-DIF error occurred. 2869 */ 2870 static void 2871 lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd) 2872 { 2873 struct scatterlist *sgpe; /* s/g prot entry */ 2874 struct scatterlist *sgde; /* s/g data entry */ 2875 struct scsi_cmnd *cmd = lpfc_cmd->pCmd; 2876 struct scsi_dif_tuple *src = NULL; 2877 uint8_t *data_src = NULL; 2878 uint16_t guard_tag; 2879 uint16_t start_app_tag, app_tag; 2880 uint32_t start_ref_tag, ref_tag; 2881 int prot, protsegcnt; 2882 int err_type, len, data_len; 2883 int chk_ref, chk_app, chk_guard; 2884 uint16_t sum; 2885 unsigned blksize; 2886 2887 err_type = BGS_GUARD_ERR_MASK; 2888 sum = 0; 2889 guard_tag = 0; 2890 2891 /* First check to see if there is protection data to examine */ 2892 prot = scsi_get_prot_op(cmd); 2893 if ((prot == SCSI_PROT_READ_STRIP) || 2894 (prot == SCSI_PROT_WRITE_INSERT) || 2895 (prot == SCSI_PROT_NORMAL)) 2896 goto out; 2897 2898 /* Currently the driver just supports ref_tag and guard_tag checking */ 2899 chk_ref = 1; 2900 chk_app = 0; 2901 chk_guard = 0; 2902 2903 /* Setup a ptr to the protection data provided by the SCSI host */ 2904 sgpe = scsi_prot_sglist(cmd); 2905 protsegcnt = lpfc_cmd->prot_seg_cnt; 2906 2907 if (sgpe && protsegcnt) { 2908 2909 /* 2910 * We will only try to verify guard tag if the segment 2911 * data length is a multiple of the blksize. 2912 */ 2913 sgde = scsi_sglist(cmd); 2914 blksize = lpfc_cmd_blksize(cmd); 2915 data_src = (uint8_t *)sg_virt(sgde); 2916 data_len = sgde->length; 2917 if ((data_len & (blksize - 1)) == 0) 2918 chk_guard = 1; 2919 2920 src = (struct scsi_dif_tuple *)sg_virt(sgpe); 2921 start_ref_tag = (uint32_t)scsi_get_lba(cmd); /* Truncate LBA */ 2922 start_app_tag = src->app_tag; 2923 len = sgpe->length; 2924 while (src && protsegcnt) { 2925 while (len) { 2926 2927 /* 2928 * First check to see if a protection data 2929 * check is valid 2930 */ 2931 if ((src->ref_tag == 0xffffffff) || 2932 (src->app_tag == 0xffff)) { 2933 start_ref_tag++; 2934 goto skipit; 2935 } 2936 2937 /* First Guard Tag checking */ 2938 if (chk_guard) { 2939 guard_tag = src->guard_tag; 2940 if (lpfc_cmd_guard_csum(cmd)) 2941 sum = lpfc_bg_csum(data_src, 2942 blksize); 2943 else 2944 sum = lpfc_bg_crc(data_src, 2945 blksize); 2946 if ((guard_tag != sum)) { 2947 err_type = BGS_GUARD_ERR_MASK; 2948 goto out; 2949 } 2950 } 2951 2952 /* Reference Tag checking */ 2953 ref_tag = be32_to_cpu(src->ref_tag); 2954 if (chk_ref && (ref_tag != start_ref_tag)) { 2955 err_type = BGS_REFTAG_ERR_MASK; 2956 goto out; 2957 } 2958 start_ref_tag++; 2959 2960 /* App Tag checking */ 2961 app_tag = src->app_tag; 2962 if (chk_app && (app_tag != start_app_tag)) { 2963 err_type = BGS_APPTAG_ERR_MASK; 2964 goto out; 2965 } 2966 skipit: 2967 len -= sizeof(struct scsi_dif_tuple); 2968 if (len < 0) 2969 len = 0; 2970 src++; 2971 2972 data_src += blksize; 2973 data_len -= blksize; 2974 2975 /* 2976 * Are we at the end of the Data segment? 2977 * The data segment is only used for Guard 2978 * tag checking. 2979 */ 2980 if (chk_guard && (data_len == 0)) { 2981 chk_guard = 0; 2982 sgde = sg_next(sgde); 2983 if (!sgde) 2984 goto out; 2985 2986 data_src = (uint8_t *)sg_virt(sgde); 2987 data_len = sgde->length; 2988 if ((data_len & (blksize - 1)) == 0) 2989 chk_guard = 1; 2990 } 2991 } 2992 2993 /* Goto the next Protection data segment */ 2994 sgpe = sg_next(sgpe); 2995 if (sgpe) { 2996 src = (struct scsi_dif_tuple *)sg_virt(sgpe); 2997 len = sgpe->length; 2998 } else { 2999 src = NULL; 3000 } 3001 protsegcnt--; 3002 } 3003 } 3004 out: 3005 if (err_type == BGS_GUARD_ERR_MASK) { 3006 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST, 3007 0x10, 0x1); 3008 cmd->result = DRIVER_SENSE << 24 3009 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION); 3010 phba->bg_guard_err_cnt++; 3011 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG, 3012 "9069 BLKGRD: LBA %lx grd_tag error %x != %x\n", 3013 (unsigned long)scsi_get_lba(cmd), 3014 sum, guard_tag); 3015 3016 } else if (err_type == BGS_REFTAG_ERR_MASK) { 3017 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST, 3018 0x10, 0x3); 3019 cmd->result = DRIVER_SENSE << 24 3020 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION); 3021 3022 phba->bg_reftag_err_cnt++; 3023 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG, 3024 "9066 BLKGRD: LBA %lx ref_tag error %x != %x\n", 3025 (unsigned long)scsi_get_lba(cmd), 3026 ref_tag, start_ref_tag); 3027 3028 } else if (err_type == BGS_APPTAG_ERR_MASK) { 3029 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST, 3030 0x10, 0x2); 3031 cmd->result = DRIVER_SENSE << 24 3032 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION); 3033 3034 phba->bg_apptag_err_cnt++; 3035 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG, 3036 "9041 BLKGRD: LBA %lx app_tag error %x != %x\n", 3037 (unsigned long)scsi_get_lba(cmd), 3038 app_tag, start_app_tag); 3039 } 3040 } 3041 3042 3043 /* 3044 * This function checks for BlockGuard errors detected by 3045 * the HBA. In case of errors, the ASC/ASCQ fields in the 3046 * sense buffer will be set accordingly, paired with 3047 * ILLEGAL_REQUEST to signal to the kernel that the HBA 3048 * detected corruption. 3049 * 3050 * Returns: 3051 * 0 - No error found 3052 * 1 - BlockGuard error found 3053 * -1 - Internal error (bad profile, ...etc) 3054 */ 3055 static int 3056 lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd, 3057 struct lpfc_iocbq *pIocbOut) 3058 { 3059 struct scsi_cmnd *cmd = lpfc_cmd->pCmd; 3060 struct sli3_bg_fields *bgf = &pIocbOut->iocb.unsli3.sli3_bg; 3061 int ret = 0; 3062 uint32_t bghm = bgf->bghm; 3063 uint32_t bgstat = bgf->bgstat; 3064 uint64_t failing_sector = 0; 3065 3066 spin_lock(&_dump_buf_lock); 3067 if (!_dump_buf_done) { 3068 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9070 BLKGRD: Saving" 3069 " Data for %u blocks to debugfs\n", 3070 (cmd->cmnd[7] << 8 | cmd->cmnd[8])); 3071 lpfc_debug_save_data(phba, cmd); 3072 3073 /* If we have a prot sgl, save the DIF buffer */ 3074 if (lpfc_prot_group_type(phba, cmd) == 3075 LPFC_PG_TYPE_DIF_BUF) { 3076 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9071 BLKGRD: " 3077 "Saving DIF for %u blocks to debugfs\n", 3078 (cmd->cmnd[7] << 8 | cmd->cmnd[8])); 3079 lpfc_debug_save_dif(phba, cmd); 3080 } 3081 3082 _dump_buf_done = 1; 3083 } 3084 spin_unlock(&_dump_buf_lock); 3085 3086 if (lpfc_bgs_get_invalid_prof(bgstat)) { 3087 cmd->result = ScsiResult(DID_ERROR, 0); 3088 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG, 3089 "9072 BLKGRD: Invalid BG Profile in cmd" 3090 " 0x%x lba 0x%llx blk cnt 0x%x " 3091 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0], 3092 (unsigned long long)scsi_get_lba(cmd), 3093 blk_rq_sectors(cmd->request), bgstat, bghm); 3094 ret = (-1); 3095 goto out; 3096 } 3097 3098 if (lpfc_bgs_get_uninit_dif_block(bgstat)) { 3099 cmd->result = ScsiResult(DID_ERROR, 0); 3100 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG, 3101 "9073 BLKGRD: Invalid BG PDIF Block in cmd" 3102 " 0x%x lba 0x%llx blk cnt 0x%x " 3103 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0], 3104 (unsigned long long)scsi_get_lba(cmd), 3105 blk_rq_sectors(cmd->request), bgstat, bghm); 3106 ret = (-1); 3107 goto out; 3108 } 3109 3110 if (lpfc_bgs_get_guard_err(bgstat)) { 3111 ret = 1; 3112 3113 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST, 3114 0x10, 0x1); 3115 cmd->result = DRIVER_SENSE << 24 3116 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION); 3117 phba->bg_guard_err_cnt++; 3118 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG, 3119 "9055 BLKGRD: Guard Tag error in cmd" 3120 " 0x%x lba 0x%llx blk cnt 0x%x " 3121 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0], 3122 (unsigned long long)scsi_get_lba(cmd), 3123 blk_rq_sectors(cmd->request), bgstat, bghm); 3124 } 3125 3126 if (lpfc_bgs_get_reftag_err(bgstat)) { 3127 ret = 1; 3128 3129 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST, 3130 0x10, 0x3); 3131 cmd->result = DRIVER_SENSE << 24 3132 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION); 3133 3134 phba->bg_reftag_err_cnt++; 3135 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG, 3136 "9056 BLKGRD: Ref Tag error in cmd" 3137 " 0x%x lba 0x%llx blk cnt 0x%x " 3138 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0], 3139 (unsigned long long)scsi_get_lba(cmd), 3140 blk_rq_sectors(cmd->request), bgstat, bghm); 3141 } 3142 3143 if (lpfc_bgs_get_apptag_err(bgstat)) { 3144 ret = 1; 3145 3146 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST, 3147 0x10, 0x2); 3148 cmd->result = DRIVER_SENSE << 24 3149 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION); 3150 3151 phba->bg_apptag_err_cnt++; 3152 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG, 3153 "9061 BLKGRD: App Tag error in cmd" 3154 " 0x%x lba 0x%llx blk cnt 0x%x " 3155 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0], 3156 (unsigned long long)scsi_get_lba(cmd), 3157 blk_rq_sectors(cmd->request), bgstat, bghm); 3158 } 3159 3160 if (lpfc_bgs_get_hi_water_mark_present(bgstat)) { 3161 /* 3162 * setup sense data descriptor 0 per SPC-4 as an information 3163 * field, and put the failing LBA in it. 3164 * This code assumes there was also a guard/app/ref tag error 3165 * indication. 3166 */ 3167 cmd->sense_buffer[7] = 0xc; /* Additional sense length */ 3168 cmd->sense_buffer[8] = 0; /* Information descriptor type */ 3169 cmd->sense_buffer[9] = 0xa; /* Additional descriptor length */ 3170 cmd->sense_buffer[10] = 0x80; /* Validity bit */ 3171 3172 /* bghm is a "on the wire" FC frame based count */ 3173 switch (scsi_get_prot_op(cmd)) { 3174 case SCSI_PROT_READ_INSERT: 3175 case SCSI_PROT_WRITE_STRIP: 3176 bghm /= cmd->device->sector_size; 3177 break; 3178 case SCSI_PROT_READ_STRIP: 3179 case SCSI_PROT_WRITE_INSERT: 3180 case SCSI_PROT_READ_PASS: 3181 case SCSI_PROT_WRITE_PASS: 3182 bghm /= (cmd->device->sector_size + 3183 sizeof(struct scsi_dif_tuple)); 3184 break; 3185 } 3186 3187 failing_sector = scsi_get_lba(cmd); 3188 failing_sector += bghm; 3189 3190 /* Descriptor Information */ 3191 put_unaligned_be64(failing_sector, &cmd->sense_buffer[12]); 3192 } 3193 3194 if (!ret) { 3195 /* No error was reported - problem in FW? */ 3196 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG, 3197 "9057 BLKGRD: Unknown error in cmd" 3198 " 0x%x lba 0x%llx blk cnt 0x%x " 3199 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0], 3200 (unsigned long long)scsi_get_lba(cmd), 3201 blk_rq_sectors(cmd->request), bgstat, bghm); 3202 3203 /* Calcuate what type of error it was */ 3204 lpfc_calc_bg_err(phba, lpfc_cmd); 3205 } 3206 out: 3207 return ret; 3208 } 3209 3210 /** 3211 * lpfc_scsi_prep_dma_buf_s4 - DMA mapping for scsi buffer to SLI4 IF spec 3212 * @phba: The Hba for which this call is being executed. 3213 * @lpfc_cmd: The scsi buffer which is going to be mapped. 3214 * 3215 * This routine does the pci dma mapping for scatter-gather list of scsi cmnd 3216 * field of @lpfc_cmd for device with SLI-4 interface spec. 3217 * 3218 * Return codes: 3219 * 1 - Error 3220 * 0 - Success 3221 **/ 3222 static int 3223 lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd) 3224 { 3225 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd; 3226 struct scatterlist *sgel = NULL; 3227 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd; 3228 struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->fcp_bpl; 3229 struct sli4_sge *first_data_sgl; 3230 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb; 3231 dma_addr_t physaddr; 3232 uint32_t num_bde = 0; 3233 uint32_t dma_len; 3234 uint32_t dma_offset = 0; 3235 int nseg; 3236 struct ulp_bde64 *bde; 3237 3238 /* 3239 * There are three possibilities here - use scatter-gather segment, use 3240 * the single mapping, or neither. Start the lpfc command prep by 3241 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first 3242 * data bde entry. 3243 */ 3244 if (scsi_sg_count(scsi_cmnd)) { 3245 /* 3246 * The driver stores the segment count returned from pci_map_sg 3247 * because this a count of dma-mappings used to map the use_sg 3248 * pages. They are not guaranteed to be the same for those 3249 * architectures that implement an IOMMU. 3250 */ 3251 3252 nseg = scsi_dma_map(scsi_cmnd); 3253 if (unlikely(nseg <= 0)) 3254 return 1; 3255 sgl += 1; 3256 /* clear the last flag in the fcp_rsp map entry */ 3257 sgl->word2 = le32_to_cpu(sgl->word2); 3258 bf_set(lpfc_sli4_sge_last, sgl, 0); 3259 sgl->word2 = cpu_to_le32(sgl->word2); 3260 sgl += 1; 3261 first_data_sgl = sgl; 3262 lpfc_cmd->seg_cnt = nseg; 3263 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) { 3264 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9074 BLKGRD:" 3265 " %s: Too many sg segments from " 3266 "dma_map_sg. Config %d, seg_cnt %d\n", 3267 __func__, phba->cfg_sg_seg_cnt, 3268 lpfc_cmd->seg_cnt); 3269 lpfc_cmd->seg_cnt = 0; 3270 scsi_dma_unmap(scsi_cmnd); 3271 return 1; 3272 } 3273 3274 /* 3275 * The driver established a maximum scatter-gather segment count 3276 * during probe that limits the number of sg elements in any 3277 * single scsi command. Just run through the seg_cnt and format 3278 * the sge's. 3279 * When using SLI-3 the driver will try to fit all the BDEs into 3280 * the IOCB. If it can't then the BDEs get added to a BPL as it 3281 * does for SLI-2 mode. 3282 */ 3283 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) { 3284 physaddr = sg_dma_address(sgel); 3285 dma_len = sg_dma_len(sgel); 3286 sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr)); 3287 sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr)); 3288 sgl->word2 = le32_to_cpu(sgl->word2); 3289 if ((num_bde + 1) == nseg) 3290 bf_set(lpfc_sli4_sge_last, sgl, 1); 3291 else 3292 bf_set(lpfc_sli4_sge_last, sgl, 0); 3293 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset); 3294 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA); 3295 sgl->word2 = cpu_to_le32(sgl->word2); 3296 sgl->sge_len = cpu_to_le32(dma_len); 3297 dma_offset += dma_len; 3298 sgl++; 3299 } 3300 /* setup the performance hint (first data BDE) if enabled */ 3301 if (phba->sli3_options & LPFC_SLI4_PERFH_ENABLED) { 3302 bde = (struct ulp_bde64 *) 3303 &(iocb_cmd->unsli3.sli3Words[5]); 3304 bde->addrLow = first_data_sgl->addr_lo; 3305 bde->addrHigh = first_data_sgl->addr_hi; 3306 bde->tus.f.bdeSize = 3307 le32_to_cpu(first_data_sgl->sge_len); 3308 bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64; 3309 bde->tus.w = cpu_to_le32(bde->tus.w); 3310 } 3311 } else { 3312 sgl += 1; 3313 /* clear the last flag in the fcp_rsp map entry */ 3314 sgl->word2 = le32_to_cpu(sgl->word2); 3315 bf_set(lpfc_sli4_sge_last, sgl, 1); 3316 sgl->word2 = cpu_to_le32(sgl->word2); 3317 } 3318 3319 /* 3320 * Finish initializing those IOCB fields that are dependent on the 3321 * scsi_cmnd request_buffer. Note that for SLI-2 the bdeSize is 3322 * explicitly reinitialized. 3323 * all iocb memory resources are reused. 3324 */ 3325 fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd)); 3326 3327 /* 3328 * Due to difference in data length between DIF/non-DIF paths, 3329 * we need to set word 4 of IOCB here 3330 */ 3331 iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd); 3332 3333 /* 3334 * If the OAS driver feature is enabled and the lun is enabled for 3335 * OAS, set the oas iocb related flags. 3336 */ 3337 if ((phba->cfg_fof) && ((struct lpfc_device_data *) 3338 scsi_cmnd->device->hostdata)->oas_enabled) 3339 lpfc_cmd->cur_iocbq.iocb_flag |= (LPFC_IO_OAS | LPFC_IO_FOF); 3340 return 0; 3341 } 3342 3343 /** 3344 * lpfc_bg_scsi_prep_dma_buf_s4 - DMA mapping for scsi buffer to SLI4 IF spec 3345 * @phba: The Hba for which this call is being executed. 3346 * @lpfc_cmd: The scsi buffer which is going to be mapped. 3347 * 3348 * This is the protection/DIF aware version of 3349 * lpfc_scsi_prep_dma_buf(). It may be a good idea to combine the 3350 * two functions eventually, but for now, it's here 3351 **/ 3352 static int 3353 lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, 3354 struct lpfc_scsi_buf *lpfc_cmd) 3355 { 3356 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd; 3357 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd; 3358 struct sli4_sge *sgl = (struct sli4_sge *)(lpfc_cmd->fcp_bpl); 3359 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb; 3360 uint32_t num_sge = 0; 3361 int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction; 3362 int prot_group_type = 0; 3363 int fcpdl; 3364 3365 /* 3366 * Start the lpfc command prep by bumping the sgl beyond fcp_cmnd 3367 * fcp_rsp regions to the first data sge entry 3368 */ 3369 if (scsi_sg_count(scsi_cmnd)) { 3370 /* 3371 * The driver stores the segment count returned from pci_map_sg 3372 * because this a count of dma-mappings used to map the use_sg 3373 * pages. They are not guaranteed to be the same for those 3374 * architectures that implement an IOMMU. 3375 */ 3376 datasegcnt = dma_map_sg(&phba->pcidev->dev, 3377 scsi_sglist(scsi_cmnd), 3378 scsi_sg_count(scsi_cmnd), datadir); 3379 if (unlikely(!datasegcnt)) 3380 return 1; 3381 3382 sgl += 1; 3383 /* clear the last flag in the fcp_rsp map entry */ 3384 sgl->word2 = le32_to_cpu(sgl->word2); 3385 bf_set(lpfc_sli4_sge_last, sgl, 0); 3386 sgl->word2 = cpu_to_le32(sgl->word2); 3387 3388 sgl += 1; 3389 lpfc_cmd->seg_cnt = datasegcnt; 3390 3391 /* First check if data segment count from SCSI Layer is good */ 3392 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) 3393 goto err; 3394 3395 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd); 3396 3397 switch (prot_group_type) { 3398 case LPFC_PG_TYPE_NO_DIF: 3399 /* Here we need to add a DISEED to the count */ 3400 if ((lpfc_cmd->seg_cnt + 1) > phba->cfg_total_seg_cnt) 3401 goto err; 3402 3403 num_sge = lpfc_bg_setup_sgl(phba, scsi_cmnd, sgl, 3404 datasegcnt); 3405 3406 /* we should have 2 or more entries in buffer list */ 3407 if (num_sge < 2) 3408 goto err; 3409 break; 3410 3411 case LPFC_PG_TYPE_DIF_BUF: 3412 /* 3413 * This type indicates that protection buffers are 3414 * passed to the driver, so that needs to be prepared 3415 * for DMA 3416 */ 3417 protsegcnt = dma_map_sg(&phba->pcidev->dev, 3418 scsi_prot_sglist(scsi_cmnd), 3419 scsi_prot_sg_count(scsi_cmnd), datadir); 3420 if (unlikely(!protsegcnt)) { 3421 scsi_dma_unmap(scsi_cmnd); 3422 return 1; 3423 } 3424 3425 lpfc_cmd->prot_seg_cnt = protsegcnt; 3426 /* 3427 * There is a minimun of 3 SGEs used for every 3428 * protection data segment. 3429 */ 3430 if ((lpfc_cmd->prot_seg_cnt * 3) > 3431 (phba->cfg_total_seg_cnt - 2)) 3432 goto err; 3433 3434 num_sge = lpfc_bg_setup_sgl_prot(phba, scsi_cmnd, sgl, 3435 datasegcnt, protsegcnt); 3436 3437 /* we should have 3 or more entries in buffer list */ 3438 if ((num_sge < 3) || 3439 (num_sge > phba->cfg_total_seg_cnt)) 3440 goto err; 3441 break; 3442 3443 case LPFC_PG_TYPE_INVALID: 3444 default: 3445 scsi_dma_unmap(scsi_cmnd); 3446 lpfc_cmd->seg_cnt = 0; 3447 3448 lpfc_printf_log(phba, KERN_ERR, LOG_FCP, 3449 "9083 Unexpected protection group %i\n", 3450 prot_group_type); 3451 return 1; 3452 } 3453 } 3454 3455 switch (scsi_get_prot_op(scsi_cmnd)) { 3456 case SCSI_PROT_WRITE_STRIP: 3457 case SCSI_PROT_READ_STRIP: 3458 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_STRIP; 3459 break; 3460 case SCSI_PROT_WRITE_INSERT: 3461 case SCSI_PROT_READ_INSERT: 3462 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_INSERT; 3463 break; 3464 case SCSI_PROT_WRITE_PASS: 3465 case SCSI_PROT_READ_PASS: 3466 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_PASS; 3467 break; 3468 } 3469 3470 fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd); 3471 fcp_cmnd->fcpDl = be32_to_cpu(fcpdl); 3472 3473 /* 3474 * Due to difference in data length between DIF/non-DIF paths, 3475 * we need to set word 4 of IOCB here 3476 */ 3477 iocb_cmd->un.fcpi.fcpi_parm = fcpdl; 3478 3479 /* 3480 * If the OAS driver feature is enabled and the lun is enabled for 3481 * OAS, set the oas iocb related flags. 3482 */ 3483 if ((phba->cfg_fof) && ((struct lpfc_device_data *) 3484 scsi_cmnd->device->hostdata)->oas_enabled) 3485 lpfc_cmd->cur_iocbq.iocb_flag |= (LPFC_IO_OAS | LPFC_IO_FOF); 3486 3487 return 0; 3488 err: 3489 if (lpfc_cmd->seg_cnt) 3490 scsi_dma_unmap(scsi_cmnd); 3491 if (lpfc_cmd->prot_seg_cnt) 3492 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(scsi_cmnd), 3493 scsi_prot_sg_count(scsi_cmnd), 3494 scsi_cmnd->sc_data_direction); 3495 3496 lpfc_printf_log(phba, KERN_ERR, LOG_FCP, 3497 "9084 Cannot setup S/G List for HBA" 3498 "IO segs %d/%d SGL %d SCSI %d: %d %d\n", 3499 lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt, 3500 phba->cfg_total_seg_cnt, phba->cfg_sg_seg_cnt, 3501 prot_group_type, num_sge); 3502 3503 lpfc_cmd->seg_cnt = 0; 3504 lpfc_cmd->prot_seg_cnt = 0; 3505 return 1; 3506 } 3507 3508 /** 3509 * lpfc_scsi_prep_dma_buf - Wrapper function for DMA mapping of scsi buffer 3510 * @phba: The Hba for which this call is being executed. 3511 * @lpfc_cmd: The scsi buffer which is going to be mapped. 3512 * 3513 * This routine wraps the actual DMA mapping function pointer from the 3514 * lpfc_hba struct. 3515 * 3516 * Return codes: 3517 * 1 - Error 3518 * 0 - Success 3519 **/ 3520 static inline int 3521 lpfc_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd) 3522 { 3523 return phba->lpfc_scsi_prep_dma_buf(phba, lpfc_cmd); 3524 } 3525 3526 /** 3527 * lpfc_bg_scsi_prep_dma_buf - Wrapper function for DMA mapping of scsi buffer 3528 * using BlockGuard. 3529 * @phba: The Hba for which this call is being executed. 3530 * @lpfc_cmd: The scsi buffer which is going to be mapped. 3531 * 3532 * This routine wraps the actual DMA mapping function pointer from the 3533 * lpfc_hba struct. 3534 * 3535 * Return codes: 3536 * 1 - Error 3537 * 0 - Success 3538 **/ 3539 static inline int 3540 lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd) 3541 { 3542 return phba->lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd); 3543 } 3544 3545 /** 3546 * lpfc_send_scsi_error_event - Posts an event when there is SCSI error 3547 * @phba: Pointer to hba context object. 3548 * @vport: Pointer to vport object. 3549 * @lpfc_cmd: Pointer to lpfc scsi command which reported the error. 3550 * @rsp_iocb: Pointer to response iocb object which reported error. 3551 * 3552 * This function posts an event when there is a SCSI command reporting 3553 * error from the scsi device. 3554 **/ 3555 static void 3556 lpfc_send_scsi_error_event(struct lpfc_hba *phba, struct lpfc_vport *vport, 3557 struct lpfc_scsi_buf *lpfc_cmd, struct lpfc_iocbq *rsp_iocb) { 3558 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd; 3559 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp; 3560 uint32_t resp_info = fcprsp->rspStatus2; 3561 uint32_t scsi_status = fcprsp->rspStatus3; 3562 uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm; 3563 struct lpfc_fast_path_event *fast_path_evt = NULL; 3564 struct lpfc_nodelist *pnode = lpfc_cmd->rdata->pnode; 3565 unsigned long flags; 3566 3567 if (!pnode || !NLP_CHK_NODE_ACT(pnode)) 3568 return; 3569 3570 /* If there is queuefull or busy condition send a scsi event */ 3571 if ((cmnd->result == SAM_STAT_TASK_SET_FULL) || 3572 (cmnd->result == SAM_STAT_BUSY)) { 3573 fast_path_evt = lpfc_alloc_fast_evt(phba); 3574 if (!fast_path_evt) 3575 return; 3576 fast_path_evt->un.scsi_evt.event_type = 3577 FC_REG_SCSI_EVENT; 3578 fast_path_evt->un.scsi_evt.subcategory = 3579 (cmnd->result == SAM_STAT_TASK_SET_FULL) ? 3580 LPFC_EVENT_QFULL : LPFC_EVENT_DEVBSY; 3581 fast_path_evt->un.scsi_evt.lun = cmnd->device->lun; 3582 memcpy(&fast_path_evt->un.scsi_evt.wwpn, 3583 &pnode->nlp_portname, sizeof(struct lpfc_name)); 3584 memcpy(&fast_path_evt->un.scsi_evt.wwnn, 3585 &pnode->nlp_nodename, sizeof(struct lpfc_name)); 3586 } else if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen && 3587 ((cmnd->cmnd[0] == READ_10) || (cmnd->cmnd[0] == WRITE_10))) { 3588 fast_path_evt = lpfc_alloc_fast_evt(phba); 3589 if (!fast_path_evt) 3590 return; 3591 fast_path_evt->un.check_cond_evt.scsi_event.event_type = 3592 FC_REG_SCSI_EVENT; 3593 fast_path_evt->un.check_cond_evt.scsi_event.subcategory = 3594 LPFC_EVENT_CHECK_COND; 3595 fast_path_evt->un.check_cond_evt.scsi_event.lun = 3596 cmnd->device->lun; 3597 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwpn, 3598 &pnode->nlp_portname, sizeof(struct lpfc_name)); 3599 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwnn, 3600 &pnode->nlp_nodename, sizeof(struct lpfc_name)); 3601 fast_path_evt->un.check_cond_evt.sense_key = 3602 cmnd->sense_buffer[2] & 0xf; 3603 fast_path_evt->un.check_cond_evt.asc = cmnd->sense_buffer[12]; 3604 fast_path_evt->un.check_cond_evt.ascq = cmnd->sense_buffer[13]; 3605 } else if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) && 3606 fcpi_parm && 3607 ((be32_to_cpu(fcprsp->rspResId) != fcpi_parm) || 3608 ((scsi_status == SAM_STAT_GOOD) && 3609 !(resp_info & (RESID_UNDER | RESID_OVER))))) { 3610 /* 3611 * If status is good or resid does not match with fcp_param and 3612 * there is valid fcpi_parm, then there is a read_check error 3613 */ 3614 fast_path_evt = lpfc_alloc_fast_evt(phba); 3615 if (!fast_path_evt) 3616 return; 3617 fast_path_evt->un.read_check_error.header.event_type = 3618 FC_REG_FABRIC_EVENT; 3619 fast_path_evt->un.read_check_error.header.subcategory = 3620 LPFC_EVENT_FCPRDCHKERR; 3621 memcpy(&fast_path_evt->un.read_check_error.header.wwpn, 3622 &pnode->nlp_portname, sizeof(struct lpfc_name)); 3623 memcpy(&fast_path_evt->un.read_check_error.header.wwnn, 3624 &pnode->nlp_nodename, sizeof(struct lpfc_name)); 3625 fast_path_evt->un.read_check_error.lun = cmnd->device->lun; 3626 fast_path_evt->un.read_check_error.opcode = cmnd->cmnd[0]; 3627 fast_path_evt->un.read_check_error.fcpiparam = 3628 fcpi_parm; 3629 } else 3630 return; 3631 3632 fast_path_evt->vport = vport; 3633 spin_lock_irqsave(&phba->hbalock, flags); 3634 list_add_tail(&fast_path_evt->work_evt.evt_listp, &phba->work_list); 3635 spin_unlock_irqrestore(&phba->hbalock, flags); 3636 lpfc_worker_wake_up(phba); 3637 return; 3638 } 3639 3640 /** 3641 * lpfc_scsi_unprep_dma_buf - Un-map DMA mapping of SG-list for dev 3642 * @phba: The HBA for which this call is being executed. 3643 * @psb: The scsi buffer which is going to be un-mapped. 3644 * 3645 * This routine does DMA un-mapping of scatter gather list of scsi command 3646 * field of @lpfc_cmd for device with SLI-3 interface spec. 3647 **/ 3648 static void 3649 lpfc_scsi_unprep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb) 3650 { 3651 /* 3652 * There are only two special cases to consider. (1) the scsi command 3653 * requested scatter-gather usage or (2) the scsi command allocated 3654 * a request buffer, but did not request use_sg. There is a third 3655 * case, but it does not require resource deallocation. 3656 */ 3657 if (psb->seg_cnt > 0) 3658 scsi_dma_unmap(psb->pCmd); 3659 if (psb->prot_seg_cnt > 0) 3660 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(psb->pCmd), 3661 scsi_prot_sg_count(psb->pCmd), 3662 psb->pCmd->sc_data_direction); 3663 } 3664 3665 /** 3666 * lpfc_handler_fcp_err - FCP response handler 3667 * @vport: The virtual port for which this call is being executed. 3668 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure. 3669 * @rsp_iocb: The response IOCB which contains FCP error. 3670 * 3671 * This routine is called to process response IOCB with status field 3672 * IOSTAT_FCP_RSP_ERROR. This routine sets result field of scsi command 3673 * based upon SCSI and FCP error. 3674 **/ 3675 static void 3676 lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd, 3677 struct lpfc_iocbq *rsp_iocb) 3678 { 3679 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd; 3680 struct fcp_cmnd *fcpcmd = lpfc_cmd->fcp_cmnd; 3681 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp; 3682 uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm; 3683 uint32_t resp_info = fcprsp->rspStatus2; 3684 uint32_t scsi_status = fcprsp->rspStatus3; 3685 uint32_t *lp; 3686 uint32_t host_status = DID_OK; 3687 uint32_t rsplen = 0; 3688 uint32_t logit = LOG_FCP | LOG_FCP_ERROR; 3689 3690 3691 /* 3692 * If this is a task management command, there is no 3693 * scsi packet associated with this lpfc_cmd. The driver 3694 * consumes it. 3695 */ 3696 if (fcpcmd->fcpCntl2) { 3697 scsi_status = 0; 3698 goto out; 3699 } 3700 3701 if (resp_info & RSP_LEN_VALID) { 3702 rsplen = be32_to_cpu(fcprsp->rspRspLen); 3703 if (rsplen != 0 && rsplen != 4 && rsplen != 8) { 3704 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 3705 "2719 Invalid response length: " 3706 "tgt x%x lun x%llx cmnd x%x rsplen x%x\n", 3707 cmnd->device->id, 3708 cmnd->device->lun, cmnd->cmnd[0], 3709 rsplen); 3710 host_status = DID_ERROR; 3711 goto out; 3712 } 3713 if (fcprsp->rspInfo3 != RSP_NO_FAILURE) { 3714 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 3715 "2757 Protocol failure detected during " 3716 "processing of FCP I/O op: " 3717 "tgt x%x lun x%llx cmnd x%x rspInfo3 x%x\n", 3718 cmnd->device->id, 3719 cmnd->device->lun, cmnd->cmnd[0], 3720 fcprsp->rspInfo3); 3721 host_status = DID_ERROR; 3722 goto out; 3723 } 3724 } 3725 3726 if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen) { 3727 uint32_t snslen = be32_to_cpu(fcprsp->rspSnsLen); 3728 if (snslen > SCSI_SENSE_BUFFERSIZE) 3729 snslen = SCSI_SENSE_BUFFERSIZE; 3730 3731 if (resp_info & RSP_LEN_VALID) 3732 rsplen = be32_to_cpu(fcprsp->rspRspLen); 3733 memcpy(cmnd->sense_buffer, &fcprsp->rspInfo0 + rsplen, snslen); 3734 } 3735 lp = (uint32_t *)cmnd->sense_buffer; 3736 3737 /* special handling for under run conditions */ 3738 if (!scsi_status && (resp_info & RESID_UNDER)) { 3739 /* don't log under runs if fcp set... */ 3740 if (vport->cfg_log_verbose & LOG_FCP) 3741 logit = LOG_FCP_ERROR; 3742 /* unless operator says so */ 3743 if (vport->cfg_log_verbose & LOG_FCP_UNDER) 3744 logit = LOG_FCP_UNDER; 3745 } 3746 3747 lpfc_printf_vlog(vport, KERN_WARNING, logit, 3748 "9024 FCP command x%x failed: x%x SNS x%x x%x " 3749 "Data: x%x x%x x%x x%x x%x\n", 3750 cmnd->cmnd[0], scsi_status, 3751 be32_to_cpu(*lp), be32_to_cpu(*(lp + 3)), resp_info, 3752 be32_to_cpu(fcprsp->rspResId), 3753 be32_to_cpu(fcprsp->rspSnsLen), 3754 be32_to_cpu(fcprsp->rspRspLen), 3755 fcprsp->rspInfo3); 3756 3757 scsi_set_resid(cmnd, 0); 3758 if (resp_info & RESID_UNDER) { 3759 scsi_set_resid(cmnd, be32_to_cpu(fcprsp->rspResId)); 3760 3761 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP_UNDER, 3762 "9025 FCP Read Underrun, expected %d, " 3763 "residual %d Data: x%x x%x x%x\n", 3764 be32_to_cpu(fcpcmd->fcpDl), 3765 scsi_get_resid(cmnd), fcpi_parm, cmnd->cmnd[0], 3766 cmnd->underflow); 3767 3768 /* 3769 * If there is an under run check if under run reported by 3770 * storage array is same as the under run reported by HBA. 3771 * If this is not same, there is a dropped frame. 3772 */ 3773 if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) && 3774 fcpi_parm && 3775 (scsi_get_resid(cmnd) != fcpi_parm)) { 3776 lpfc_printf_vlog(vport, KERN_WARNING, 3777 LOG_FCP | LOG_FCP_ERROR, 3778 "9026 FCP Read Check Error " 3779 "and Underrun Data: x%x x%x x%x x%x\n", 3780 be32_to_cpu(fcpcmd->fcpDl), 3781 scsi_get_resid(cmnd), fcpi_parm, 3782 cmnd->cmnd[0]); 3783 scsi_set_resid(cmnd, scsi_bufflen(cmnd)); 3784 host_status = DID_ERROR; 3785 } 3786 /* 3787 * The cmnd->underflow is the minimum number of bytes that must 3788 * be transferred for this command. Provided a sense condition 3789 * is not present, make sure the actual amount transferred is at 3790 * least the underflow value or fail. 3791 */ 3792 if (!(resp_info & SNS_LEN_VALID) && 3793 (scsi_status == SAM_STAT_GOOD) && 3794 (scsi_bufflen(cmnd) - scsi_get_resid(cmnd) 3795 < cmnd->underflow)) { 3796 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 3797 "9027 FCP command x%x residual " 3798 "underrun converted to error " 3799 "Data: x%x x%x x%x\n", 3800 cmnd->cmnd[0], scsi_bufflen(cmnd), 3801 scsi_get_resid(cmnd), cmnd->underflow); 3802 host_status = DID_ERROR; 3803 } 3804 } else if (resp_info & RESID_OVER) { 3805 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 3806 "9028 FCP command x%x residual overrun error. " 3807 "Data: x%x x%x\n", cmnd->cmnd[0], 3808 scsi_bufflen(cmnd), scsi_get_resid(cmnd)); 3809 host_status = DID_ERROR; 3810 3811 /* 3812 * Check SLI validation that all the transfer was actually done 3813 * (fcpi_parm should be zero). Apply check only to reads. 3814 */ 3815 } else if (fcpi_parm && (cmnd->sc_data_direction == DMA_FROM_DEVICE)) { 3816 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP | LOG_FCP_ERROR, 3817 "9029 FCP Read Check Error Data: " 3818 "x%x x%x x%x x%x x%x\n", 3819 be32_to_cpu(fcpcmd->fcpDl), 3820 be32_to_cpu(fcprsp->rspResId), 3821 fcpi_parm, cmnd->cmnd[0], scsi_status); 3822 switch (scsi_status) { 3823 case SAM_STAT_GOOD: 3824 case SAM_STAT_CHECK_CONDITION: 3825 /* Fabric dropped a data frame. Fail any successful 3826 * command in which we detected dropped frames. 3827 * A status of good or some check conditions could 3828 * be considered a successful command. 3829 */ 3830 host_status = DID_ERROR; 3831 break; 3832 } 3833 scsi_set_resid(cmnd, scsi_bufflen(cmnd)); 3834 } 3835 3836 out: 3837 cmnd->result = ScsiResult(host_status, scsi_status); 3838 lpfc_send_scsi_error_event(vport->phba, vport, lpfc_cmd, rsp_iocb); 3839 } 3840 3841 /** 3842 * lpfc_sli4_scmd_to_wqidx_distr - scsi command to SLI4 WQ index distribution 3843 * @phba: Pointer to HBA context object. 3844 * 3845 * This routine performs a roundrobin SCSI command to SLI4 FCP WQ index 3846 * distribution. This is called by __lpfc_sli_issue_iocb_s4() with the hbalock 3847 * held. 3848 * If scsi-mq is enabled, get the default block layer mapping of software queues 3849 * to hardware queues. This information is saved in request tag. 3850 * 3851 * Return: index into SLI4 fast-path FCP queue index. 3852 **/ 3853 int lpfc_sli4_scmd_to_wqidx_distr(struct lpfc_hba *phba, 3854 struct lpfc_scsi_buf *lpfc_cmd) 3855 { 3856 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd; 3857 struct lpfc_vector_map_info *cpup; 3858 int chann, cpu; 3859 uint32_t tag; 3860 uint16_t hwq; 3861 3862 if (shost_use_blk_mq(cmnd->device->host)) { 3863 tag = blk_mq_unique_tag(cmnd->request); 3864 hwq = blk_mq_unique_tag_to_hwq(tag); 3865 3866 return hwq; 3867 } 3868 3869 if (phba->cfg_fcp_io_sched == LPFC_FCP_SCHED_BY_CPU 3870 && phba->cfg_fcp_io_channel > 1) { 3871 cpu = smp_processor_id(); 3872 if (cpu < phba->sli4_hba.num_present_cpu) { 3873 cpup = phba->sli4_hba.cpu_map; 3874 cpup += cpu; 3875 return cpup->channel_id; 3876 } 3877 } 3878 chann = atomic_add_return(1, &phba->fcp_qidx); 3879 chann = (chann % phba->cfg_fcp_io_channel); 3880 return chann; 3881 } 3882 3883 3884 /** 3885 * lpfc_scsi_cmd_iocb_cmpl - Scsi cmnd IOCB completion routine 3886 * @phba: The Hba for which this call is being executed. 3887 * @pIocbIn: The command IOCBQ for the scsi cmnd. 3888 * @pIocbOut: The response IOCBQ for the scsi cmnd. 3889 * 3890 * This routine assigns scsi command result by looking into response IOCB 3891 * status field appropriately. This routine handles QUEUE FULL condition as 3892 * well by ramping down device queue depth. 3893 **/ 3894 static void 3895 lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn, 3896 struct lpfc_iocbq *pIocbOut) 3897 { 3898 struct lpfc_scsi_buf *lpfc_cmd = 3899 (struct lpfc_scsi_buf *) pIocbIn->context1; 3900 struct lpfc_vport *vport = pIocbIn->vport; 3901 struct lpfc_rport_data *rdata = lpfc_cmd->rdata; 3902 struct lpfc_nodelist *pnode = rdata->pnode; 3903 struct scsi_cmnd *cmd; 3904 int depth; 3905 unsigned long flags; 3906 struct lpfc_fast_path_event *fast_path_evt; 3907 struct Scsi_Host *shost; 3908 uint32_t logit = LOG_FCP; 3909 3910 /* Sanity check on return of outstanding command */ 3911 if (!(lpfc_cmd->pCmd)) 3912 return; 3913 cmd = lpfc_cmd->pCmd; 3914 shost = cmd->device->host; 3915 3916 lpfc_cmd->result = (pIocbOut->iocb.un.ulpWord[4] & IOERR_PARAM_MASK); 3917 lpfc_cmd->status = pIocbOut->iocb.ulpStatus; 3918 /* pick up SLI4 exhange busy status from HBA */ 3919 lpfc_cmd->exch_busy = pIocbOut->iocb_flag & LPFC_EXCHANGE_BUSY; 3920 3921 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS 3922 if (lpfc_cmd->prot_data_type) { 3923 struct scsi_dif_tuple *src = NULL; 3924 3925 src = (struct scsi_dif_tuple *)lpfc_cmd->prot_data_segment; 3926 /* 3927 * Used to restore any changes to protection 3928 * data for error injection. 3929 */ 3930 switch (lpfc_cmd->prot_data_type) { 3931 case LPFC_INJERR_REFTAG: 3932 src->ref_tag = 3933 lpfc_cmd->prot_data; 3934 break; 3935 case LPFC_INJERR_APPTAG: 3936 src->app_tag = 3937 (uint16_t)lpfc_cmd->prot_data; 3938 break; 3939 case LPFC_INJERR_GUARD: 3940 src->guard_tag = 3941 (uint16_t)lpfc_cmd->prot_data; 3942 break; 3943 default: 3944 break; 3945 } 3946 3947 lpfc_cmd->prot_data = 0; 3948 lpfc_cmd->prot_data_type = 0; 3949 lpfc_cmd->prot_data_segment = NULL; 3950 } 3951 #endif 3952 if (pnode && NLP_CHK_NODE_ACT(pnode)) 3953 atomic_dec(&pnode->cmd_pending); 3954 3955 if (lpfc_cmd->status) { 3956 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT && 3957 (lpfc_cmd->result & IOERR_DRVR_MASK)) 3958 lpfc_cmd->status = IOSTAT_DRIVER_REJECT; 3959 else if (lpfc_cmd->status >= IOSTAT_CNT) 3960 lpfc_cmd->status = IOSTAT_DEFAULT; 3961 if (lpfc_cmd->status == IOSTAT_FCP_RSP_ERROR && 3962 !lpfc_cmd->fcp_rsp->rspStatus3 && 3963 (lpfc_cmd->fcp_rsp->rspStatus2 & RESID_UNDER) && 3964 !(vport->cfg_log_verbose & LOG_FCP_UNDER)) 3965 logit = 0; 3966 else 3967 logit = LOG_FCP | LOG_FCP_UNDER; 3968 lpfc_printf_vlog(vport, KERN_WARNING, logit, 3969 "9030 FCP cmd x%x failed <%d/%lld> " 3970 "status: x%x result: x%x " 3971 "sid: x%x did: x%x oxid: x%x " 3972 "Data: x%x x%x\n", 3973 cmd->cmnd[0], 3974 cmd->device ? cmd->device->id : 0xffff, 3975 cmd->device ? cmd->device->lun : 0xffff, 3976 lpfc_cmd->status, lpfc_cmd->result, 3977 vport->fc_myDID, 3978 (pnode) ? pnode->nlp_DID : 0, 3979 phba->sli_rev == LPFC_SLI_REV4 ? 3980 lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff, 3981 pIocbOut->iocb.ulpContext, 3982 lpfc_cmd->cur_iocbq.iocb.ulpIoTag); 3983 3984 switch (lpfc_cmd->status) { 3985 case IOSTAT_FCP_RSP_ERROR: 3986 /* Call FCP RSP handler to determine result */ 3987 lpfc_handle_fcp_err(vport, lpfc_cmd, pIocbOut); 3988 break; 3989 case IOSTAT_NPORT_BSY: 3990 case IOSTAT_FABRIC_BSY: 3991 cmd->result = ScsiResult(DID_TRANSPORT_DISRUPTED, 0); 3992 fast_path_evt = lpfc_alloc_fast_evt(phba); 3993 if (!fast_path_evt) 3994 break; 3995 fast_path_evt->un.fabric_evt.event_type = 3996 FC_REG_FABRIC_EVENT; 3997 fast_path_evt->un.fabric_evt.subcategory = 3998 (lpfc_cmd->status == IOSTAT_NPORT_BSY) ? 3999 LPFC_EVENT_PORT_BUSY : LPFC_EVENT_FABRIC_BUSY; 4000 if (pnode && NLP_CHK_NODE_ACT(pnode)) { 4001 memcpy(&fast_path_evt->un.fabric_evt.wwpn, 4002 &pnode->nlp_portname, 4003 sizeof(struct lpfc_name)); 4004 memcpy(&fast_path_evt->un.fabric_evt.wwnn, 4005 &pnode->nlp_nodename, 4006 sizeof(struct lpfc_name)); 4007 } 4008 fast_path_evt->vport = vport; 4009 fast_path_evt->work_evt.evt = 4010 LPFC_EVT_FASTPATH_MGMT_EVT; 4011 spin_lock_irqsave(&phba->hbalock, flags); 4012 list_add_tail(&fast_path_evt->work_evt.evt_listp, 4013 &phba->work_list); 4014 spin_unlock_irqrestore(&phba->hbalock, flags); 4015 lpfc_worker_wake_up(phba); 4016 break; 4017 case IOSTAT_LOCAL_REJECT: 4018 case IOSTAT_REMOTE_STOP: 4019 if (lpfc_cmd->result == IOERR_ELXSEC_KEY_UNWRAP_ERROR || 4020 lpfc_cmd->result == 4021 IOERR_ELXSEC_KEY_UNWRAP_COMPARE_ERROR || 4022 lpfc_cmd->result == IOERR_ELXSEC_CRYPTO_ERROR || 4023 lpfc_cmd->result == 4024 IOERR_ELXSEC_CRYPTO_COMPARE_ERROR) { 4025 cmd->result = ScsiResult(DID_NO_CONNECT, 0); 4026 break; 4027 } 4028 if (lpfc_cmd->result == IOERR_INVALID_RPI || 4029 lpfc_cmd->result == IOERR_NO_RESOURCES || 4030 lpfc_cmd->result == IOERR_ABORT_REQUESTED || 4031 lpfc_cmd->result == IOERR_SLER_CMD_RCV_FAILURE) { 4032 cmd->result = ScsiResult(DID_REQUEUE, 0); 4033 break; 4034 } 4035 if ((lpfc_cmd->result == IOERR_RX_DMA_FAILED || 4036 lpfc_cmd->result == IOERR_TX_DMA_FAILED) && 4037 pIocbOut->iocb.unsli3.sli3_bg.bgstat) { 4038 if (scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) { 4039 /* 4040 * This is a response for a BG enabled 4041 * cmd. Parse BG error 4042 */ 4043 lpfc_parse_bg_err(phba, lpfc_cmd, 4044 pIocbOut); 4045 break; 4046 } else { 4047 lpfc_printf_vlog(vport, KERN_WARNING, 4048 LOG_BG, 4049 "9031 non-zero BGSTAT " 4050 "on unprotected cmd\n"); 4051 } 4052 } 4053 if ((lpfc_cmd->status == IOSTAT_REMOTE_STOP) 4054 && (phba->sli_rev == LPFC_SLI_REV4) 4055 && (pnode && NLP_CHK_NODE_ACT(pnode))) { 4056 /* This IO was aborted by the target, we don't 4057 * know the rxid and because we did not send the 4058 * ABTS we cannot generate and RRQ. 4059 */ 4060 lpfc_set_rrq_active(phba, pnode, 4061 lpfc_cmd->cur_iocbq.sli4_lxritag, 4062 0, 0); 4063 } 4064 /* else: fall through */ 4065 default: 4066 cmd->result = ScsiResult(DID_ERROR, 0); 4067 break; 4068 } 4069 4070 if (!pnode || !NLP_CHK_NODE_ACT(pnode) 4071 || (pnode->nlp_state != NLP_STE_MAPPED_NODE)) 4072 cmd->result = ScsiResult(DID_TRANSPORT_DISRUPTED, 4073 SAM_STAT_BUSY); 4074 } else 4075 cmd->result = ScsiResult(DID_OK, 0); 4076 4077 if (cmd->result || lpfc_cmd->fcp_rsp->rspSnsLen) { 4078 uint32_t *lp = (uint32_t *)cmd->sense_buffer; 4079 4080 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 4081 "0710 Iodone <%d/%llu> cmd %p, error " 4082 "x%x SNS x%x x%x Data: x%x x%x\n", 4083 cmd->device->id, cmd->device->lun, cmd, 4084 cmd->result, *lp, *(lp + 3), cmd->retries, 4085 scsi_get_resid(cmd)); 4086 } 4087 4088 lpfc_update_stats(phba, lpfc_cmd); 4089 if (vport->cfg_max_scsicmpl_time && 4090 time_after(jiffies, lpfc_cmd->start_time + 4091 msecs_to_jiffies(vport->cfg_max_scsicmpl_time))) { 4092 spin_lock_irqsave(shost->host_lock, flags); 4093 if (pnode && NLP_CHK_NODE_ACT(pnode)) { 4094 if (pnode->cmd_qdepth > 4095 atomic_read(&pnode->cmd_pending) && 4096 (atomic_read(&pnode->cmd_pending) > 4097 LPFC_MIN_TGT_QDEPTH) && 4098 ((cmd->cmnd[0] == READ_10) || 4099 (cmd->cmnd[0] == WRITE_10))) 4100 pnode->cmd_qdepth = 4101 atomic_read(&pnode->cmd_pending); 4102 4103 pnode->last_change_time = jiffies; 4104 } 4105 spin_unlock_irqrestore(shost->host_lock, flags); 4106 } else if (pnode && NLP_CHK_NODE_ACT(pnode)) { 4107 if ((pnode->cmd_qdepth < vport->cfg_tgt_queue_depth) && 4108 time_after(jiffies, pnode->last_change_time + 4109 msecs_to_jiffies(LPFC_TGTQ_INTERVAL))) { 4110 spin_lock_irqsave(shost->host_lock, flags); 4111 depth = pnode->cmd_qdepth * LPFC_TGTQ_RAMPUP_PCENT 4112 / 100; 4113 depth = depth ? depth : 1; 4114 pnode->cmd_qdepth += depth; 4115 if (pnode->cmd_qdepth > vport->cfg_tgt_queue_depth) 4116 pnode->cmd_qdepth = vport->cfg_tgt_queue_depth; 4117 pnode->last_change_time = jiffies; 4118 spin_unlock_irqrestore(shost->host_lock, flags); 4119 } 4120 } 4121 4122 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd); 4123 4124 /* The sdev is not guaranteed to be valid post scsi_done upcall. */ 4125 cmd->scsi_done(cmd); 4126 4127 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) { 4128 spin_lock_irqsave(&phba->hbalock, flags); 4129 lpfc_cmd->pCmd = NULL; 4130 spin_unlock_irqrestore(&phba->hbalock, flags); 4131 4132 /* 4133 * If there is a thread waiting for command completion 4134 * wake up the thread. 4135 */ 4136 spin_lock_irqsave(shost->host_lock, flags); 4137 if (lpfc_cmd->waitq) 4138 wake_up(lpfc_cmd->waitq); 4139 spin_unlock_irqrestore(shost->host_lock, flags); 4140 lpfc_release_scsi_buf(phba, lpfc_cmd); 4141 return; 4142 } 4143 4144 spin_lock_irqsave(&phba->hbalock, flags); 4145 lpfc_cmd->pCmd = NULL; 4146 spin_unlock_irqrestore(&phba->hbalock, flags); 4147 4148 /* 4149 * If there is a thread waiting for command completion 4150 * wake up the thread. 4151 */ 4152 spin_lock_irqsave(shost->host_lock, flags); 4153 if (lpfc_cmd->waitq) 4154 wake_up(lpfc_cmd->waitq); 4155 spin_unlock_irqrestore(shost->host_lock, flags); 4156 4157 lpfc_release_scsi_buf(phba, lpfc_cmd); 4158 } 4159 4160 /** 4161 * lpfc_fcpcmd_to_iocb - copy the fcp_cmd data into the IOCB 4162 * @data: A pointer to the immediate command data portion of the IOCB. 4163 * @fcp_cmnd: The FCP Command that is provided by the SCSI layer. 4164 * 4165 * The routine copies the entire FCP command from @fcp_cmnd to @data while 4166 * byte swapping the data to big endian format for transmission on the wire. 4167 **/ 4168 static void 4169 lpfc_fcpcmd_to_iocb(uint8_t *data, struct fcp_cmnd *fcp_cmnd) 4170 { 4171 int i, j; 4172 for (i = 0, j = 0; i < sizeof(struct fcp_cmnd); 4173 i += sizeof(uint32_t), j++) { 4174 ((uint32_t *)data)[j] = cpu_to_be32(((uint32_t *)fcp_cmnd)[j]); 4175 } 4176 } 4177 4178 /** 4179 * lpfc_scsi_prep_cmnd - Wrapper func for convert scsi cmnd to FCP info unit 4180 * @vport: The virtual port for which this call is being executed. 4181 * @lpfc_cmd: The scsi command which needs to send. 4182 * @pnode: Pointer to lpfc_nodelist. 4183 * 4184 * This routine initializes fcp_cmnd and iocb data structure from scsi command 4185 * to transfer for device with SLI3 interface spec. 4186 **/ 4187 static void 4188 lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd, 4189 struct lpfc_nodelist *pnode) 4190 { 4191 struct lpfc_hba *phba = vport->phba; 4192 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd; 4193 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd; 4194 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb; 4195 struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq); 4196 int datadir = scsi_cmnd->sc_data_direction; 4197 uint8_t *ptr; 4198 bool sli4; 4199 uint32_t fcpdl; 4200 4201 if (!pnode || !NLP_CHK_NODE_ACT(pnode)) 4202 return; 4203 4204 lpfc_cmd->fcp_rsp->rspSnsLen = 0; 4205 /* clear task management bits */ 4206 lpfc_cmd->fcp_cmnd->fcpCntl2 = 0; 4207 4208 int_to_scsilun(lpfc_cmd->pCmd->device->lun, 4209 &lpfc_cmd->fcp_cmnd->fcp_lun); 4210 4211 ptr = &fcp_cmnd->fcpCdb[0]; 4212 memcpy(ptr, scsi_cmnd->cmnd, scsi_cmnd->cmd_len); 4213 if (scsi_cmnd->cmd_len < LPFC_FCP_CDB_LEN) { 4214 ptr += scsi_cmnd->cmd_len; 4215 memset(ptr, 0, (LPFC_FCP_CDB_LEN - scsi_cmnd->cmd_len)); 4216 } 4217 4218 fcp_cmnd->fcpCntl1 = SIMPLE_Q; 4219 4220 sli4 = (phba->sli_rev == LPFC_SLI_REV4); 4221 piocbq->iocb.un.fcpi.fcpi_XRdy = 0; 4222 4223 /* 4224 * There are three possibilities here - use scatter-gather segment, use 4225 * the single mapping, or neither. Start the lpfc command prep by 4226 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first 4227 * data bde entry. 4228 */ 4229 if (scsi_sg_count(scsi_cmnd)) { 4230 if (datadir == DMA_TO_DEVICE) { 4231 iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR; 4232 iocb_cmd->ulpPU = PARM_READ_CHECK; 4233 if (vport->cfg_first_burst_size && 4234 (pnode->nlp_flag & NLP_FIRSTBURST)) { 4235 fcpdl = scsi_bufflen(scsi_cmnd); 4236 if (fcpdl < vport->cfg_first_burst_size) 4237 piocbq->iocb.un.fcpi.fcpi_XRdy = fcpdl; 4238 else 4239 piocbq->iocb.un.fcpi.fcpi_XRdy = 4240 vport->cfg_first_burst_size; 4241 } 4242 fcp_cmnd->fcpCntl3 = WRITE_DATA; 4243 phba->fc4OutputRequests++; 4244 } else { 4245 iocb_cmd->ulpCommand = CMD_FCP_IREAD64_CR; 4246 iocb_cmd->ulpPU = PARM_READ_CHECK; 4247 fcp_cmnd->fcpCntl3 = READ_DATA; 4248 phba->fc4InputRequests++; 4249 } 4250 } else { 4251 iocb_cmd->ulpCommand = CMD_FCP_ICMND64_CR; 4252 iocb_cmd->un.fcpi.fcpi_parm = 0; 4253 iocb_cmd->ulpPU = 0; 4254 fcp_cmnd->fcpCntl3 = 0; 4255 phba->fc4ControlRequests++; 4256 } 4257 if (phba->sli_rev == 3 && 4258 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) 4259 lpfc_fcpcmd_to_iocb(iocb_cmd->unsli3.fcp_ext.icd, fcp_cmnd); 4260 /* 4261 * Finish initializing those IOCB fields that are independent 4262 * of the scsi_cmnd request_buffer 4263 */ 4264 piocbq->iocb.ulpContext = pnode->nlp_rpi; 4265 if (sli4) 4266 piocbq->iocb.ulpContext = 4267 phba->sli4_hba.rpi_ids[pnode->nlp_rpi]; 4268 if (pnode->nlp_fcp_info & NLP_FCP_2_DEVICE) 4269 piocbq->iocb.ulpFCP2Rcvy = 1; 4270 else 4271 piocbq->iocb.ulpFCP2Rcvy = 0; 4272 4273 piocbq->iocb.ulpClass = (pnode->nlp_fcp_info & 0x0f); 4274 piocbq->context1 = lpfc_cmd; 4275 piocbq->iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl; 4276 piocbq->iocb.ulpTimeout = lpfc_cmd->timeout; 4277 piocbq->vport = vport; 4278 } 4279 4280 /** 4281 * lpfc_scsi_prep_task_mgmt_cmd - Convert SLI3 scsi TM cmd to FCP info unit 4282 * @vport: The virtual port for which this call is being executed. 4283 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure. 4284 * @lun: Logical unit number. 4285 * @task_mgmt_cmd: SCSI task management command. 4286 * 4287 * This routine creates FCP information unit corresponding to @task_mgmt_cmd 4288 * for device with SLI-3 interface spec. 4289 * 4290 * Return codes: 4291 * 0 - Error 4292 * 1 - Success 4293 **/ 4294 static int 4295 lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport, 4296 struct lpfc_scsi_buf *lpfc_cmd, 4297 uint64_t lun, 4298 uint8_t task_mgmt_cmd) 4299 { 4300 struct lpfc_iocbq *piocbq; 4301 IOCB_t *piocb; 4302 struct fcp_cmnd *fcp_cmnd; 4303 struct lpfc_rport_data *rdata = lpfc_cmd->rdata; 4304 struct lpfc_nodelist *ndlp = rdata->pnode; 4305 4306 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || 4307 ndlp->nlp_state != NLP_STE_MAPPED_NODE) 4308 return 0; 4309 4310 piocbq = &(lpfc_cmd->cur_iocbq); 4311 piocbq->vport = vport; 4312 4313 piocb = &piocbq->iocb; 4314 4315 fcp_cmnd = lpfc_cmd->fcp_cmnd; 4316 /* Clear out any old data in the FCP command area */ 4317 memset(fcp_cmnd, 0, sizeof(struct fcp_cmnd)); 4318 int_to_scsilun(lun, &fcp_cmnd->fcp_lun); 4319 fcp_cmnd->fcpCntl2 = task_mgmt_cmd; 4320 if (vport->phba->sli_rev == 3 && 4321 !(vport->phba->sli3_options & LPFC_SLI3_BG_ENABLED)) 4322 lpfc_fcpcmd_to_iocb(piocb->unsli3.fcp_ext.icd, fcp_cmnd); 4323 piocb->ulpCommand = CMD_FCP_ICMND64_CR; 4324 piocb->ulpContext = ndlp->nlp_rpi; 4325 if (vport->phba->sli_rev == LPFC_SLI_REV4) { 4326 piocb->ulpContext = 4327 vport->phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]; 4328 } 4329 piocb->ulpFCP2Rcvy = (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) ? 1 : 0; 4330 piocb->ulpClass = (ndlp->nlp_fcp_info & 0x0f); 4331 piocb->ulpPU = 0; 4332 piocb->un.fcpi.fcpi_parm = 0; 4333 4334 /* ulpTimeout is only one byte */ 4335 if (lpfc_cmd->timeout > 0xff) { 4336 /* 4337 * Do not timeout the command at the firmware level. 4338 * The driver will provide the timeout mechanism. 4339 */ 4340 piocb->ulpTimeout = 0; 4341 } else 4342 piocb->ulpTimeout = lpfc_cmd->timeout; 4343 4344 if (vport->phba->sli_rev == LPFC_SLI_REV4) 4345 lpfc_sli4_set_rsp_sgl_last(vport->phba, lpfc_cmd); 4346 4347 return 1; 4348 } 4349 4350 /** 4351 * lpfc_scsi_api_table_setup - Set up scsi api function jump table 4352 * @phba: The hba struct for which this call is being executed. 4353 * @dev_grp: The HBA PCI-Device group number. 4354 * 4355 * This routine sets up the SCSI interface API function jump table in @phba 4356 * struct. 4357 * Returns: 0 - success, -ENODEV - failure. 4358 **/ 4359 int 4360 lpfc_scsi_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp) 4361 { 4362 4363 phba->lpfc_scsi_unprep_dma_buf = lpfc_scsi_unprep_dma_buf; 4364 phba->lpfc_scsi_prep_cmnd = lpfc_scsi_prep_cmnd; 4365 4366 switch (dev_grp) { 4367 case LPFC_PCI_DEV_LP: 4368 phba->lpfc_new_scsi_buf = lpfc_new_scsi_buf_s3; 4369 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s3; 4370 phba->lpfc_bg_scsi_prep_dma_buf = lpfc_bg_scsi_prep_dma_buf_s3; 4371 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s3; 4372 phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s3; 4373 break; 4374 case LPFC_PCI_DEV_OC: 4375 phba->lpfc_new_scsi_buf = lpfc_new_scsi_buf_s4; 4376 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s4; 4377 phba->lpfc_bg_scsi_prep_dma_buf = lpfc_bg_scsi_prep_dma_buf_s4; 4378 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s4; 4379 phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s4; 4380 break; 4381 default: 4382 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4383 "1418 Invalid HBA PCI-device group: 0x%x\n", 4384 dev_grp); 4385 return -ENODEV; 4386 break; 4387 } 4388 phba->lpfc_rampdown_queue_depth = lpfc_rampdown_queue_depth; 4389 phba->lpfc_scsi_cmd_iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl; 4390 return 0; 4391 } 4392 4393 /** 4394 * lpfc_taskmgmt_def_cmpl - IOCB completion routine for task management command 4395 * @phba: The Hba for which this call is being executed. 4396 * @cmdiocbq: Pointer to lpfc_iocbq data structure. 4397 * @rspiocbq: Pointer to lpfc_iocbq data structure. 4398 * 4399 * This routine is IOCB completion routine for device reset and target reset 4400 * routine. This routine release scsi buffer associated with lpfc_cmd. 4401 **/ 4402 static void 4403 lpfc_tskmgmt_def_cmpl(struct lpfc_hba *phba, 4404 struct lpfc_iocbq *cmdiocbq, 4405 struct lpfc_iocbq *rspiocbq) 4406 { 4407 struct lpfc_scsi_buf *lpfc_cmd = 4408 (struct lpfc_scsi_buf *) cmdiocbq->context1; 4409 if (lpfc_cmd) 4410 lpfc_release_scsi_buf(phba, lpfc_cmd); 4411 return; 4412 } 4413 4414 /** 4415 * lpfc_info - Info entry point of scsi_host_template data structure 4416 * @host: The scsi host for which this call is being executed. 4417 * 4418 * This routine provides module information about hba. 4419 * 4420 * Reutrn code: 4421 * Pointer to char - Success. 4422 **/ 4423 const char * 4424 lpfc_info(struct Scsi_Host *host) 4425 { 4426 struct lpfc_vport *vport = (struct lpfc_vport *) host->hostdata; 4427 struct lpfc_hba *phba = vport->phba; 4428 int len, link_speed = 0; 4429 static char lpfcinfobuf[384]; 4430 4431 memset(lpfcinfobuf,0,384); 4432 if (phba && phba->pcidev){ 4433 strncpy(lpfcinfobuf, phba->ModelDesc, 256); 4434 len = strlen(lpfcinfobuf); 4435 snprintf(lpfcinfobuf + len, 4436 384-len, 4437 " on PCI bus %02x device %02x irq %d", 4438 phba->pcidev->bus->number, 4439 phba->pcidev->devfn, 4440 phba->pcidev->irq); 4441 len = strlen(lpfcinfobuf); 4442 if (phba->Port[0]) { 4443 snprintf(lpfcinfobuf + len, 4444 384-len, 4445 " port %s", 4446 phba->Port); 4447 } 4448 len = strlen(lpfcinfobuf); 4449 if (phba->sli_rev <= LPFC_SLI_REV3) { 4450 link_speed = lpfc_sli_port_speed_get(phba); 4451 } else { 4452 if (phba->sli4_hba.link_state.logical_speed) 4453 link_speed = 4454 phba->sli4_hba.link_state.logical_speed; 4455 else 4456 link_speed = phba->sli4_hba.link_state.speed; 4457 } 4458 if (link_speed != 0) 4459 snprintf(lpfcinfobuf + len, 384-len, 4460 " Logical Link Speed: %d Mbps", link_speed); 4461 } 4462 return lpfcinfobuf; 4463 } 4464 4465 /** 4466 * lpfc_poll_rearm_time - Routine to modify fcp_poll timer of hba 4467 * @phba: The Hba for which this call is being executed. 4468 * 4469 * This routine modifies fcp_poll_timer field of @phba by cfg_poll_tmo. 4470 * The default value of cfg_poll_tmo is 10 milliseconds. 4471 **/ 4472 static __inline__ void lpfc_poll_rearm_timer(struct lpfc_hba * phba) 4473 { 4474 unsigned long poll_tmo_expires = 4475 (jiffies + msecs_to_jiffies(phba->cfg_poll_tmo)); 4476 4477 if (!list_empty(&phba->sli.ring[LPFC_FCP_RING].txcmplq)) 4478 mod_timer(&phba->fcp_poll_timer, 4479 poll_tmo_expires); 4480 } 4481 4482 /** 4483 * lpfc_poll_start_timer - Routine to start fcp_poll_timer of HBA 4484 * @phba: The Hba for which this call is being executed. 4485 * 4486 * This routine starts the fcp_poll_timer of @phba. 4487 **/ 4488 void lpfc_poll_start_timer(struct lpfc_hba * phba) 4489 { 4490 lpfc_poll_rearm_timer(phba); 4491 } 4492 4493 /** 4494 * lpfc_poll_timeout - Restart polling timer 4495 * @ptr: Map to lpfc_hba data structure pointer. 4496 * 4497 * This routine restarts fcp_poll timer, when FCP ring polling is enable 4498 * and FCP Ring interrupt is disable. 4499 **/ 4500 4501 void lpfc_poll_timeout(unsigned long ptr) 4502 { 4503 struct lpfc_hba *phba = (struct lpfc_hba *) ptr; 4504 4505 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) { 4506 lpfc_sli_handle_fast_ring_event(phba, 4507 &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ); 4508 4509 if (phba->cfg_poll & DISABLE_FCP_RING_INT) 4510 lpfc_poll_rearm_timer(phba); 4511 } 4512 } 4513 4514 /** 4515 * lpfc_queuecommand - scsi_host_template queuecommand entry point 4516 * @cmnd: Pointer to scsi_cmnd data structure. 4517 * @done: Pointer to done routine. 4518 * 4519 * Driver registers this routine to scsi midlayer to submit a @cmd to process. 4520 * This routine prepares an IOCB from scsi command and provides to firmware. 4521 * The @done callback is invoked after driver finished processing the command. 4522 * 4523 * Return value : 4524 * 0 - Success 4525 * SCSI_MLQUEUE_HOST_BUSY - Block all devices served by this host temporarily. 4526 **/ 4527 static int 4528 lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd) 4529 { 4530 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4531 struct lpfc_hba *phba = vport->phba; 4532 struct lpfc_rport_data *rdata; 4533 struct lpfc_nodelist *ndlp; 4534 struct lpfc_scsi_buf *lpfc_cmd; 4535 struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device)); 4536 int err; 4537 4538 rdata = lpfc_rport_data_from_scsi_device(cmnd->device); 4539 err = fc_remote_port_chkready(rport); 4540 if (err) { 4541 cmnd->result = err; 4542 goto out_fail_command; 4543 } 4544 ndlp = rdata->pnode; 4545 4546 if ((scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) && 4547 (!(phba->sli3_options & LPFC_SLI3_BG_ENABLED))) { 4548 4549 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 4550 "9058 BLKGRD: ERROR: rcvd protected cmd:%02x" 4551 " op:%02x str=%s without registering for" 4552 " BlockGuard - Rejecting command\n", 4553 cmnd->cmnd[0], scsi_get_prot_op(cmnd), 4554 dif_op_str[scsi_get_prot_op(cmnd)]); 4555 goto out_fail_command; 4556 } 4557 4558 /* 4559 * Catch race where our node has transitioned, but the 4560 * transport is still transitioning. 4561 */ 4562 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) 4563 goto out_tgt_busy; 4564 if (atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth) 4565 goto out_tgt_busy; 4566 4567 lpfc_cmd = lpfc_get_scsi_buf(phba, ndlp); 4568 if (lpfc_cmd == NULL) { 4569 lpfc_rampdown_queue_depth(phba); 4570 4571 lpfc_printf_vlog(vport, KERN_INFO, LOG_MISC, 4572 "0707 driver's buffer pool is empty, " 4573 "IO busied\n"); 4574 goto out_host_busy; 4575 } 4576 4577 /* 4578 * Store the midlayer's command structure for the completion phase 4579 * and complete the command initialization. 4580 */ 4581 lpfc_cmd->pCmd = cmnd; 4582 lpfc_cmd->rdata = rdata; 4583 lpfc_cmd->timeout = 0; 4584 lpfc_cmd->start_time = jiffies; 4585 cmnd->host_scribble = (unsigned char *)lpfc_cmd; 4586 4587 if (scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) { 4588 if (vport->phba->cfg_enable_bg) { 4589 lpfc_printf_vlog(vport, 4590 KERN_INFO, LOG_SCSI_CMD, 4591 "9033 BLKGRD: rcvd %s cmd:x%x " 4592 "sector x%llx cnt %u pt %x\n", 4593 dif_op_str[scsi_get_prot_op(cmnd)], 4594 cmnd->cmnd[0], 4595 (unsigned long long)scsi_get_lba(cmnd), 4596 blk_rq_sectors(cmnd->request), 4597 (cmnd->cmnd[1]>>5)); 4598 } 4599 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd); 4600 } else { 4601 if (vport->phba->cfg_enable_bg) { 4602 lpfc_printf_vlog(vport, 4603 KERN_INFO, LOG_SCSI_CMD, 4604 "9038 BLKGRD: rcvd PROT_NORMAL cmd: " 4605 "x%x sector x%llx cnt %u pt %x\n", 4606 cmnd->cmnd[0], 4607 (unsigned long long)scsi_get_lba(cmnd), 4608 blk_rq_sectors(cmnd->request), 4609 (cmnd->cmnd[1]>>5)); 4610 } 4611 err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd); 4612 } 4613 4614 if (err) 4615 goto out_host_busy_free_buf; 4616 4617 lpfc_scsi_prep_cmnd(vport, lpfc_cmd, ndlp); 4618 4619 atomic_inc(&ndlp->cmd_pending); 4620 err = lpfc_sli_issue_iocb(phba, LPFC_FCP_RING, 4621 &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB); 4622 if (err) { 4623 atomic_dec(&ndlp->cmd_pending); 4624 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 4625 "3376 FCP could not issue IOCB err %x" 4626 "FCP cmd x%x <%d/%llu> " 4627 "sid: x%x did: x%x oxid: x%x " 4628 "Data: x%x x%x x%x x%x\n", 4629 err, cmnd->cmnd[0], 4630 cmnd->device ? cmnd->device->id : 0xffff, 4631 cmnd->device ? cmnd->device->lun : (u64) -1, 4632 vport->fc_myDID, ndlp->nlp_DID, 4633 phba->sli_rev == LPFC_SLI_REV4 ? 4634 lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff, 4635 lpfc_cmd->cur_iocbq.iocb.ulpContext, 4636 lpfc_cmd->cur_iocbq.iocb.ulpIoTag, 4637 lpfc_cmd->cur_iocbq.iocb.ulpTimeout, 4638 (uint32_t) 4639 (cmnd->request->timeout / 1000)); 4640 4641 4642 goto out_host_busy_free_buf; 4643 } 4644 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) { 4645 lpfc_sli_handle_fast_ring_event(phba, 4646 &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ); 4647 4648 if (phba->cfg_poll & DISABLE_FCP_RING_INT) 4649 lpfc_poll_rearm_timer(phba); 4650 } 4651 4652 return 0; 4653 4654 out_host_busy_free_buf: 4655 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd); 4656 lpfc_release_scsi_buf(phba, lpfc_cmd); 4657 out_host_busy: 4658 return SCSI_MLQUEUE_HOST_BUSY; 4659 4660 out_tgt_busy: 4661 return SCSI_MLQUEUE_TARGET_BUSY; 4662 4663 out_fail_command: 4664 cmnd->scsi_done(cmnd); 4665 return 0; 4666 } 4667 4668 4669 /** 4670 * lpfc_abort_handler - scsi_host_template eh_abort_handler entry point 4671 * @cmnd: Pointer to scsi_cmnd data structure. 4672 * 4673 * This routine aborts @cmnd pending in base driver. 4674 * 4675 * Return code : 4676 * 0x2003 - Error 4677 * 0x2002 - Success 4678 **/ 4679 static int 4680 lpfc_abort_handler(struct scsi_cmnd *cmnd) 4681 { 4682 struct Scsi_Host *shost = cmnd->device->host; 4683 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 4684 struct lpfc_hba *phba = vport->phba; 4685 struct lpfc_iocbq *iocb; 4686 struct lpfc_iocbq *abtsiocb; 4687 struct lpfc_scsi_buf *lpfc_cmd; 4688 IOCB_t *cmd, *icmd; 4689 int ret = SUCCESS, status = 0; 4690 struct lpfc_sli_ring *pring_s4; 4691 int ring_number, ret_val; 4692 unsigned long flags, iflags; 4693 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waitq); 4694 4695 status = fc_block_scsi_eh(cmnd); 4696 if (status != 0 && status != SUCCESS) 4697 return status; 4698 4699 spin_lock_irqsave(&phba->hbalock, flags); 4700 /* driver queued commands are in process of being flushed */ 4701 if (phba->hba_flag & HBA_FCP_IOQ_FLUSH) { 4702 spin_unlock_irqrestore(&phba->hbalock, flags); 4703 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 4704 "3168 SCSI Layer abort requested I/O has been " 4705 "flushed by LLD.\n"); 4706 return FAILED; 4707 } 4708 4709 lpfc_cmd = (struct lpfc_scsi_buf *)cmnd->host_scribble; 4710 if (!lpfc_cmd || !lpfc_cmd->pCmd) { 4711 spin_unlock_irqrestore(&phba->hbalock, flags); 4712 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 4713 "2873 SCSI Layer I/O Abort Request IO CMPL Status " 4714 "x%x ID %d LUN %llu\n", 4715 SUCCESS, cmnd->device->id, cmnd->device->lun); 4716 return SUCCESS; 4717 } 4718 4719 iocb = &lpfc_cmd->cur_iocbq; 4720 /* the command is in process of being cancelled */ 4721 if (!(iocb->iocb_flag & LPFC_IO_ON_TXCMPLQ)) { 4722 spin_unlock_irqrestore(&phba->hbalock, flags); 4723 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 4724 "3169 SCSI Layer abort requested I/O has been " 4725 "cancelled by LLD.\n"); 4726 return FAILED; 4727 } 4728 /* 4729 * If pCmd field of the corresponding lpfc_scsi_buf structure 4730 * points to a different SCSI command, then the driver has 4731 * already completed this command, but the midlayer did not 4732 * see the completion before the eh fired. Just return SUCCESS. 4733 */ 4734 if (lpfc_cmd->pCmd != cmnd) { 4735 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 4736 "3170 SCSI Layer abort requested I/O has been " 4737 "completed by LLD.\n"); 4738 goto out_unlock; 4739 } 4740 4741 BUG_ON(iocb->context1 != lpfc_cmd); 4742 4743 /* abort issued in recovery is still in progress */ 4744 if (iocb->iocb_flag & LPFC_DRIVER_ABORTED) { 4745 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 4746 "3389 SCSI Layer I/O Abort Request is pending\n"); 4747 spin_unlock_irqrestore(&phba->hbalock, flags); 4748 goto wait_for_cmpl; 4749 } 4750 4751 abtsiocb = __lpfc_sli_get_iocbq(phba); 4752 if (abtsiocb == NULL) { 4753 ret = FAILED; 4754 goto out_unlock; 4755 } 4756 4757 /* Indicate the IO is being aborted by the driver. */ 4758 iocb->iocb_flag |= LPFC_DRIVER_ABORTED; 4759 4760 /* 4761 * The scsi command can not be in txq and it is in flight because the 4762 * pCmd is still pointig at the SCSI command we have to abort. There 4763 * is no need to search the txcmplq. Just send an abort to the FW. 4764 */ 4765 4766 cmd = &iocb->iocb; 4767 icmd = &abtsiocb->iocb; 4768 icmd->un.acxri.abortType = ABORT_TYPE_ABTS; 4769 icmd->un.acxri.abortContextTag = cmd->ulpContext; 4770 if (phba->sli_rev == LPFC_SLI_REV4) 4771 icmd->un.acxri.abortIoTag = iocb->sli4_xritag; 4772 else 4773 icmd->un.acxri.abortIoTag = cmd->ulpIoTag; 4774 4775 icmd->ulpLe = 1; 4776 icmd->ulpClass = cmd->ulpClass; 4777 4778 /* ABTS WQE must go to the same WQ as the WQE to be aborted */ 4779 abtsiocb->fcp_wqidx = iocb->fcp_wqidx; 4780 abtsiocb->iocb_flag |= LPFC_USE_FCPWQIDX; 4781 if (iocb->iocb_flag & LPFC_IO_FOF) 4782 abtsiocb->iocb_flag |= LPFC_IO_FOF; 4783 4784 if (lpfc_is_link_up(phba)) 4785 icmd->ulpCommand = CMD_ABORT_XRI_CN; 4786 else 4787 icmd->ulpCommand = CMD_CLOSE_XRI_CN; 4788 4789 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl; 4790 abtsiocb->vport = vport; 4791 if (phba->sli_rev == LPFC_SLI_REV4) { 4792 ring_number = MAX_SLI3_CONFIGURED_RINGS + iocb->fcp_wqidx; 4793 pring_s4 = &phba->sli.ring[ring_number]; 4794 /* Note: both hbalock and ring_lock must be set here */ 4795 spin_lock_irqsave(&pring_s4->ring_lock, iflags); 4796 ret_val = __lpfc_sli_issue_iocb(phba, pring_s4->ringno, 4797 abtsiocb, 0); 4798 spin_unlock_irqrestore(&pring_s4->ring_lock, iflags); 4799 } else { 4800 ret_val = __lpfc_sli_issue_iocb(phba, LPFC_FCP_RING, 4801 abtsiocb, 0); 4802 } 4803 /* no longer need the lock after this point */ 4804 spin_unlock_irqrestore(&phba->hbalock, flags); 4805 4806 4807 if (ret_val == IOCB_ERROR) { 4808 lpfc_sli_release_iocbq(phba, abtsiocb); 4809 ret = FAILED; 4810 goto out; 4811 } 4812 4813 if (phba->cfg_poll & DISABLE_FCP_RING_INT) 4814 lpfc_sli_handle_fast_ring_event(phba, 4815 &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ); 4816 4817 wait_for_cmpl: 4818 lpfc_cmd->waitq = &waitq; 4819 /* Wait for abort to complete */ 4820 wait_event_timeout(waitq, 4821 (lpfc_cmd->pCmd != cmnd), 4822 msecs_to_jiffies(2*vport->cfg_devloss_tmo*1000)); 4823 4824 spin_lock_irqsave(shost->host_lock, flags); 4825 lpfc_cmd->waitq = NULL; 4826 spin_unlock_irqrestore(shost->host_lock, flags); 4827 4828 if (lpfc_cmd->pCmd == cmnd) { 4829 ret = FAILED; 4830 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 4831 "0748 abort handler timed out waiting " 4832 "for abortng I/O (xri:x%x) to complete: " 4833 "ret %#x, ID %d, LUN %llu\n", 4834 iocb->sli4_xritag, ret, 4835 cmnd->device->id, cmnd->device->lun); 4836 } 4837 goto out; 4838 4839 out_unlock: 4840 spin_unlock_irqrestore(&phba->hbalock, flags); 4841 out: 4842 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 4843 "0749 SCSI Layer I/O Abort Request Status x%x ID %d " 4844 "LUN %llu\n", ret, cmnd->device->id, 4845 cmnd->device->lun); 4846 return ret; 4847 } 4848 4849 static char * 4850 lpfc_taskmgmt_name(uint8_t task_mgmt_cmd) 4851 { 4852 switch (task_mgmt_cmd) { 4853 case FCP_ABORT_TASK_SET: 4854 return "ABORT_TASK_SET"; 4855 case FCP_CLEAR_TASK_SET: 4856 return "FCP_CLEAR_TASK_SET"; 4857 case FCP_BUS_RESET: 4858 return "FCP_BUS_RESET"; 4859 case FCP_LUN_RESET: 4860 return "FCP_LUN_RESET"; 4861 case FCP_TARGET_RESET: 4862 return "FCP_TARGET_RESET"; 4863 case FCP_CLEAR_ACA: 4864 return "FCP_CLEAR_ACA"; 4865 case FCP_TERMINATE_TASK: 4866 return "FCP_TERMINATE_TASK"; 4867 default: 4868 return "unknown"; 4869 } 4870 } 4871 4872 4873 /** 4874 * lpfc_check_fcp_rsp - check the returned fcp_rsp to see if task failed 4875 * @vport: The virtual port for which this call is being executed. 4876 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure. 4877 * 4878 * This routine checks the FCP RSP INFO to see if the tsk mgmt command succeded 4879 * 4880 * Return code : 4881 * 0x2003 - Error 4882 * 0x2002 - Success 4883 **/ 4884 static int 4885 lpfc_check_fcp_rsp(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd) 4886 { 4887 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp; 4888 uint32_t rsp_info; 4889 uint32_t rsp_len; 4890 uint8_t rsp_info_code; 4891 int ret = FAILED; 4892 4893 4894 if (fcprsp == NULL) 4895 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 4896 "0703 fcp_rsp is missing\n"); 4897 else { 4898 rsp_info = fcprsp->rspStatus2; 4899 rsp_len = be32_to_cpu(fcprsp->rspRspLen); 4900 rsp_info_code = fcprsp->rspInfo3; 4901 4902 4903 lpfc_printf_vlog(vport, KERN_INFO, 4904 LOG_FCP, 4905 "0706 fcp_rsp valid 0x%x," 4906 " rsp len=%d code 0x%x\n", 4907 rsp_info, 4908 rsp_len, rsp_info_code); 4909 4910 if ((fcprsp->rspStatus2&RSP_LEN_VALID) && (rsp_len == 8)) { 4911 switch (rsp_info_code) { 4912 case RSP_NO_FAILURE: 4913 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 4914 "0715 Task Mgmt No Failure\n"); 4915 ret = SUCCESS; 4916 break; 4917 case RSP_TM_NOT_SUPPORTED: /* TM rejected */ 4918 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 4919 "0716 Task Mgmt Target " 4920 "reject\n"); 4921 break; 4922 case RSP_TM_NOT_COMPLETED: /* TM failed */ 4923 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 4924 "0717 Task Mgmt Target " 4925 "failed TM\n"); 4926 break; 4927 case RSP_TM_INVALID_LU: /* TM to invalid LU! */ 4928 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 4929 "0718 Task Mgmt to invalid " 4930 "LUN\n"); 4931 break; 4932 } 4933 } 4934 } 4935 return ret; 4936 } 4937 4938 4939 /** 4940 * lpfc_send_taskmgmt - Generic SCSI Task Mgmt Handler 4941 * @vport: The virtual port for which this call is being executed. 4942 * @rdata: Pointer to remote port local data 4943 * @tgt_id: Target ID of remote device. 4944 * @lun_id: Lun number for the TMF 4945 * @task_mgmt_cmd: type of TMF to send 4946 * 4947 * This routine builds and sends a TMF (SCSI Task Mgmt Function) to 4948 * a remote port. 4949 * 4950 * Return Code: 4951 * 0x2003 - Error 4952 * 0x2002 - Success. 4953 **/ 4954 static int 4955 lpfc_send_taskmgmt(struct lpfc_vport *vport, struct lpfc_rport_data *rdata, 4956 unsigned tgt_id, uint64_t lun_id, 4957 uint8_t task_mgmt_cmd) 4958 { 4959 struct lpfc_hba *phba = vport->phba; 4960 struct lpfc_scsi_buf *lpfc_cmd; 4961 struct lpfc_iocbq *iocbq; 4962 struct lpfc_iocbq *iocbqrsp; 4963 struct lpfc_nodelist *pnode = rdata->pnode; 4964 int ret; 4965 int status; 4966 4967 if (!pnode || !NLP_CHK_NODE_ACT(pnode)) 4968 return FAILED; 4969 4970 lpfc_cmd = lpfc_get_scsi_buf(phba, rdata->pnode); 4971 if (lpfc_cmd == NULL) 4972 return FAILED; 4973 lpfc_cmd->timeout = phba->cfg_task_mgmt_tmo; 4974 lpfc_cmd->rdata = rdata; 4975 4976 status = lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd, lun_id, 4977 task_mgmt_cmd); 4978 if (!status) { 4979 lpfc_release_scsi_buf(phba, lpfc_cmd); 4980 return FAILED; 4981 } 4982 4983 iocbq = &lpfc_cmd->cur_iocbq; 4984 iocbqrsp = lpfc_sli_get_iocbq(phba); 4985 if (iocbqrsp == NULL) { 4986 lpfc_release_scsi_buf(phba, lpfc_cmd); 4987 return FAILED; 4988 } 4989 iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl; 4990 4991 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 4992 "0702 Issue %s to TGT %d LUN %llu " 4993 "rpi x%x nlp_flag x%x Data: x%x x%x\n", 4994 lpfc_taskmgmt_name(task_mgmt_cmd), tgt_id, lun_id, 4995 pnode->nlp_rpi, pnode->nlp_flag, iocbq->sli4_xritag, 4996 iocbq->iocb_flag); 4997 4998 status = lpfc_sli_issue_iocb_wait(phba, LPFC_FCP_RING, 4999 iocbq, iocbqrsp, lpfc_cmd->timeout); 5000 if ((status != IOCB_SUCCESS) || 5001 (iocbqrsp->iocb.ulpStatus != IOSTAT_SUCCESS)) { 5002 if (status != IOCB_SUCCESS || 5003 iocbqrsp->iocb.ulpStatus != IOSTAT_FCP_RSP_ERROR) 5004 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5005 "0727 TMF %s to TGT %d LUN %llu " 5006 "failed (%d, %d) iocb_flag x%x\n", 5007 lpfc_taskmgmt_name(task_mgmt_cmd), 5008 tgt_id, lun_id, 5009 iocbqrsp->iocb.ulpStatus, 5010 iocbqrsp->iocb.un.ulpWord[4], 5011 iocbq->iocb_flag); 5012 /* if ulpStatus != IOCB_SUCCESS, then status == IOCB_SUCCESS */ 5013 if (status == IOCB_SUCCESS) { 5014 if (iocbqrsp->iocb.ulpStatus == IOSTAT_FCP_RSP_ERROR) 5015 /* Something in the FCP_RSP was invalid. 5016 * Check conditions */ 5017 ret = lpfc_check_fcp_rsp(vport, lpfc_cmd); 5018 else 5019 ret = FAILED; 5020 } else if (status == IOCB_TIMEDOUT) { 5021 ret = TIMEOUT_ERROR; 5022 } else { 5023 ret = FAILED; 5024 } 5025 } else 5026 ret = SUCCESS; 5027 5028 lpfc_sli_release_iocbq(phba, iocbqrsp); 5029 5030 if (ret != TIMEOUT_ERROR) 5031 lpfc_release_scsi_buf(phba, lpfc_cmd); 5032 5033 return ret; 5034 } 5035 5036 /** 5037 * lpfc_chk_tgt_mapped - 5038 * @vport: The virtual port to check on 5039 * @cmnd: Pointer to scsi_cmnd data structure. 5040 * 5041 * This routine delays until the scsi target (aka rport) for the 5042 * command exists (is present and logged in) or we declare it non-existent. 5043 * 5044 * Return code : 5045 * 0x2003 - Error 5046 * 0x2002 - Success 5047 **/ 5048 static int 5049 lpfc_chk_tgt_mapped(struct lpfc_vport *vport, struct scsi_cmnd *cmnd) 5050 { 5051 struct lpfc_rport_data *rdata; 5052 struct lpfc_nodelist *pnode; 5053 unsigned long later; 5054 5055 rdata = lpfc_rport_data_from_scsi_device(cmnd->device); 5056 if (!rdata) { 5057 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 5058 "0797 Tgt Map rport failure: rdata x%p\n", rdata); 5059 return FAILED; 5060 } 5061 pnode = rdata->pnode; 5062 /* 5063 * If target is not in a MAPPED state, delay until 5064 * target is rediscovered or devloss timeout expires. 5065 */ 5066 later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies; 5067 while (time_after(later, jiffies)) { 5068 if (!pnode || !NLP_CHK_NODE_ACT(pnode)) 5069 return FAILED; 5070 if (pnode->nlp_state == NLP_STE_MAPPED_NODE) 5071 return SUCCESS; 5072 schedule_timeout_uninterruptible(msecs_to_jiffies(500)); 5073 rdata = lpfc_rport_data_from_scsi_device(cmnd->device); 5074 if (!rdata) 5075 return FAILED; 5076 pnode = rdata->pnode; 5077 } 5078 if (!pnode || !NLP_CHK_NODE_ACT(pnode) || 5079 (pnode->nlp_state != NLP_STE_MAPPED_NODE)) 5080 return FAILED; 5081 return SUCCESS; 5082 } 5083 5084 /** 5085 * lpfc_reset_flush_io_context - 5086 * @vport: The virtual port (scsi_host) for the flush context 5087 * @tgt_id: If aborting by Target contect - specifies the target id 5088 * @lun_id: If aborting by Lun context - specifies the lun id 5089 * @context: specifies the context level to flush at. 5090 * 5091 * After a reset condition via TMF, we need to flush orphaned i/o 5092 * contexts from the adapter. This routine aborts any contexts 5093 * outstanding, then waits for their completions. The wait is 5094 * bounded by devloss_tmo though. 5095 * 5096 * Return code : 5097 * 0x2003 - Error 5098 * 0x2002 - Success 5099 **/ 5100 static int 5101 lpfc_reset_flush_io_context(struct lpfc_vport *vport, uint16_t tgt_id, 5102 uint64_t lun_id, lpfc_ctx_cmd context) 5103 { 5104 struct lpfc_hba *phba = vport->phba; 5105 unsigned long later; 5106 int cnt; 5107 5108 cnt = lpfc_sli_sum_iocb(vport, tgt_id, lun_id, context); 5109 if (cnt) 5110 lpfc_sli_abort_taskmgmt(vport, 5111 &phba->sli.ring[phba->sli.fcp_ring], 5112 tgt_id, lun_id, context); 5113 later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies; 5114 while (time_after(later, jiffies) && cnt) { 5115 schedule_timeout_uninterruptible(msecs_to_jiffies(20)); 5116 cnt = lpfc_sli_sum_iocb(vport, tgt_id, lun_id, context); 5117 } 5118 if (cnt) { 5119 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5120 "0724 I/O flush failure for context %s : cnt x%x\n", 5121 ((context == LPFC_CTX_LUN) ? "LUN" : 5122 ((context == LPFC_CTX_TGT) ? "TGT" : 5123 ((context == LPFC_CTX_HOST) ? "HOST" : "Unknown"))), 5124 cnt); 5125 return FAILED; 5126 } 5127 return SUCCESS; 5128 } 5129 5130 /** 5131 * lpfc_device_reset_handler - scsi_host_template eh_device_reset entry point 5132 * @cmnd: Pointer to scsi_cmnd data structure. 5133 * 5134 * This routine does a device reset by sending a LUN_RESET task management 5135 * command. 5136 * 5137 * Return code : 5138 * 0x2003 - Error 5139 * 0x2002 - Success 5140 **/ 5141 static int 5142 lpfc_device_reset_handler(struct scsi_cmnd *cmnd) 5143 { 5144 struct Scsi_Host *shost = cmnd->device->host; 5145 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5146 struct lpfc_rport_data *rdata; 5147 struct lpfc_nodelist *pnode; 5148 unsigned tgt_id = cmnd->device->id; 5149 uint64_t lun_id = cmnd->device->lun; 5150 struct lpfc_scsi_event_header scsi_event; 5151 int status; 5152 5153 rdata = lpfc_rport_data_from_scsi_device(cmnd->device); 5154 if (!rdata || !rdata->pnode) { 5155 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5156 "0798 Device Reset rport failure: rdata x%p\n", 5157 rdata); 5158 return FAILED; 5159 } 5160 pnode = rdata->pnode; 5161 status = fc_block_scsi_eh(cmnd); 5162 if (status != 0 && status != SUCCESS) 5163 return status; 5164 5165 status = lpfc_chk_tgt_mapped(vport, cmnd); 5166 if (status == FAILED) { 5167 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5168 "0721 Device Reset rport failure: rdata x%p\n", rdata); 5169 return FAILED; 5170 } 5171 5172 scsi_event.event_type = FC_REG_SCSI_EVENT; 5173 scsi_event.subcategory = LPFC_EVENT_LUNRESET; 5174 scsi_event.lun = lun_id; 5175 memcpy(scsi_event.wwpn, &pnode->nlp_portname, sizeof(struct lpfc_name)); 5176 memcpy(scsi_event.wwnn, &pnode->nlp_nodename, sizeof(struct lpfc_name)); 5177 5178 fc_host_post_vendor_event(shost, fc_get_event_number(), 5179 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID); 5180 5181 status = lpfc_send_taskmgmt(vport, rdata, tgt_id, lun_id, 5182 FCP_LUN_RESET); 5183 5184 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5185 "0713 SCSI layer issued Device Reset (%d, %llu) " 5186 "return x%x\n", tgt_id, lun_id, status); 5187 5188 /* 5189 * We have to clean up i/o as : they may be orphaned by the TMF; 5190 * or if the TMF failed, they may be in an indeterminate state. 5191 * So, continue on. 5192 * We will report success if all the i/o aborts successfully. 5193 */ 5194 if (status == SUCCESS) 5195 status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id, 5196 LPFC_CTX_LUN); 5197 5198 return status; 5199 } 5200 5201 /** 5202 * lpfc_target_reset_handler - scsi_host_template eh_target_reset entry point 5203 * @cmnd: Pointer to scsi_cmnd data structure. 5204 * 5205 * This routine does a target reset by sending a TARGET_RESET task management 5206 * command. 5207 * 5208 * Return code : 5209 * 0x2003 - Error 5210 * 0x2002 - Success 5211 **/ 5212 static int 5213 lpfc_target_reset_handler(struct scsi_cmnd *cmnd) 5214 { 5215 struct Scsi_Host *shost = cmnd->device->host; 5216 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5217 struct lpfc_rport_data *rdata; 5218 struct lpfc_nodelist *pnode; 5219 unsigned tgt_id = cmnd->device->id; 5220 uint64_t lun_id = cmnd->device->lun; 5221 struct lpfc_scsi_event_header scsi_event; 5222 int status; 5223 5224 rdata = lpfc_rport_data_from_scsi_device(cmnd->device); 5225 if (!rdata) { 5226 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5227 "0799 Target Reset rport failure: rdata x%p\n", rdata); 5228 return FAILED; 5229 } 5230 pnode = rdata->pnode; 5231 status = fc_block_scsi_eh(cmnd); 5232 if (status != 0 && status != SUCCESS) 5233 return status; 5234 5235 status = lpfc_chk_tgt_mapped(vport, cmnd); 5236 if (status == FAILED) { 5237 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5238 "0722 Target Reset rport failure: rdata x%p\n", rdata); 5239 if (pnode) { 5240 spin_lock_irq(shost->host_lock); 5241 pnode->nlp_flag &= ~NLP_NPR_ADISC; 5242 pnode->nlp_fcp_info &= ~NLP_FCP_2_DEVICE; 5243 spin_unlock_irq(shost->host_lock); 5244 } 5245 lpfc_reset_flush_io_context(vport, tgt_id, lun_id, 5246 LPFC_CTX_TGT); 5247 return FAST_IO_FAIL; 5248 } 5249 5250 scsi_event.event_type = FC_REG_SCSI_EVENT; 5251 scsi_event.subcategory = LPFC_EVENT_TGTRESET; 5252 scsi_event.lun = 0; 5253 memcpy(scsi_event.wwpn, &pnode->nlp_portname, sizeof(struct lpfc_name)); 5254 memcpy(scsi_event.wwnn, &pnode->nlp_nodename, sizeof(struct lpfc_name)); 5255 5256 fc_host_post_vendor_event(shost, fc_get_event_number(), 5257 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID); 5258 5259 status = lpfc_send_taskmgmt(vport, rdata, tgt_id, lun_id, 5260 FCP_TARGET_RESET); 5261 5262 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5263 "0723 SCSI layer issued Target Reset (%d, %llu) " 5264 "return x%x\n", tgt_id, lun_id, status); 5265 5266 /* 5267 * We have to clean up i/o as : they may be orphaned by the TMF; 5268 * or if the TMF failed, they may be in an indeterminate state. 5269 * So, continue on. 5270 * We will report success if all the i/o aborts successfully. 5271 */ 5272 if (status == SUCCESS) 5273 status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id, 5274 LPFC_CTX_TGT); 5275 return status; 5276 } 5277 5278 /** 5279 * lpfc_bus_reset_handler - scsi_host_template eh_bus_reset_handler entry point 5280 * @cmnd: Pointer to scsi_cmnd data structure. 5281 * 5282 * This routine does target reset to all targets on @cmnd->device->host. 5283 * This emulates Parallel SCSI Bus Reset Semantics. 5284 * 5285 * Return code : 5286 * 0x2003 - Error 5287 * 0x2002 - Success 5288 **/ 5289 static int 5290 lpfc_bus_reset_handler(struct scsi_cmnd *cmnd) 5291 { 5292 struct Scsi_Host *shost = cmnd->device->host; 5293 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5294 struct lpfc_nodelist *ndlp = NULL; 5295 struct lpfc_scsi_event_header scsi_event; 5296 int match; 5297 int ret = SUCCESS, status, i; 5298 5299 scsi_event.event_type = FC_REG_SCSI_EVENT; 5300 scsi_event.subcategory = LPFC_EVENT_BUSRESET; 5301 scsi_event.lun = 0; 5302 memcpy(scsi_event.wwpn, &vport->fc_portname, sizeof(struct lpfc_name)); 5303 memcpy(scsi_event.wwnn, &vport->fc_nodename, sizeof(struct lpfc_name)); 5304 5305 fc_host_post_vendor_event(shost, fc_get_event_number(), 5306 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID); 5307 5308 status = fc_block_scsi_eh(cmnd); 5309 if (status != 0 && status != SUCCESS) 5310 return status; 5311 5312 /* 5313 * Since the driver manages a single bus device, reset all 5314 * targets known to the driver. Should any target reset 5315 * fail, this routine returns failure to the midlayer. 5316 */ 5317 for (i = 0; i < LPFC_MAX_TARGET; i++) { 5318 /* Search for mapped node by target ID */ 5319 match = 0; 5320 spin_lock_irq(shost->host_lock); 5321 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 5322 if (!NLP_CHK_NODE_ACT(ndlp)) 5323 continue; 5324 if (vport->phba->cfg_fcp2_no_tgt_reset && 5325 (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE)) 5326 continue; 5327 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE && 5328 ndlp->nlp_sid == i && 5329 ndlp->rport) { 5330 match = 1; 5331 break; 5332 } 5333 } 5334 spin_unlock_irq(shost->host_lock); 5335 if (!match) 5336 continue; 5337 5338 status = lpfc_send_taskmgmt(vport, ndlp->rport->dd_data, 5339 i, 0, FCP_TARGET_RESET); 5340 5341 if (status != SUCCESS) { 5342 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5343 "0700 Bus Reset on target %d failed\n", 5344 i); 5345 ret = FAILED; 5346 } 5347 } 5348 /* 5349 * We have to clean up i/o as : they may be orphaned by the TMFs 5350 * above; or if any of the TMFs failed, they may be in an 5351 * indeterminate state. 5352 * We will report success if all the i/o aborts successfully. 5353 */ 5354 5355 status = lpfc_reset_flush_io_context(vport, 0, 0, LPFC_CTX_HOST); 5356 if (status != SUCCESS) 5357 ret = FAILED; 5358 5359 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5360 "0714 SCSI layer issued Bus Reset Data: x%x\n", ret); 5361 return ret; 5362 } 5363 5364 /** 5365 * lpfc_host_reset_handler - scsi_host_template eh_host_reset_handler entry pt 5366 * @cmnd: Pointer to scsi_cmnd data structure. 5367 * 5368 * This routine does host reset to the adaptor port. It brings the HBA 5369 * offline, performs a board restart, and then brings the board back online. 5370 * The lpfc_offline calls lpfc_sli_hba_down which will abort and local 5371 * reject all outstanding SCSI commands to the host and error returned 5372 * back to SCSI mid-level. As this will be SCSI mid-level's last resort 5373 * of error handling, it will only return error if resetting of the adapter 5374 * is not successful; in all other cases, will return success. 5375 * 5376 * Return code : 5377 * 0x2003 - Error 5378 * 0x2002 - Success 5379 **/ 5380 static int 5381 lpfc_host_reset_handler(struct scsi_cmnd *cmnd) 5382 { 5383 struct Scsi_Host *shost = cmnd->device->host; 5384 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 5385 struct lpfc_hba *phba = vport->phba; 5386 int rc, ret = SUCCESS; 5387 5388 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5389 "3172 SCSI layer issued Host Reset Data:\n"); 5390 5391 lpfc_offline_prep(phba, LPFC_MBX_WAIT); 5392 lpfc_offline(phba); 5393 rc = lpfc_sli_brdrestart(phba); 5394 if (rc) 5395 ret = FAILED; 5396 rc = lpfc_online(phba); 5397 if (rc) 5398 ret = FAILED; 5399 lpfc_unblock_mgmt_io(phba); 5400 5401 if (ret == FAILED) { 5402 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5403 "3323 Failed host reset, bring it offline\n"); 5404 lpfc_sli4_offline_eratt(phba); 5405 } 5406 return ret; 5407 } 5408 5409 /** 5410 * lpfc_slave_alloc - scsi_host_template slave_alloc entry point 5411 * @sdev: Pointer to scsi_device. 5412 * 5413 * This routine populates the cmds_per_lun count + 2 scsi_bufs into this host's 5414 * globally available list of scsi buffers. This routine also makes sure scsi 5415 * buffer is not allocated more than HBA limit conveyed to midlayer. This list 5416 * of scsi buffer exists for the lifetime of the driver. 5417 * 5418 * Return codes: 5419 * non-0 - Error 5420 * 0 - Success 5421 **/ 5422 static int 5423 lpfc_slave_alloc(struct scsi_device *sdev) 5424 { 5425 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata; 5426 struct lpfc_hba *phba = vport->phba; 5427 struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); 5428 uint32_t total = 0; 5429 uint32_t num_to_alloc = 0; 5430 int num_allocated = 0; 5431 uint32_t sdev_cnt; 5432 struct lpfc_device_data *device_data; 5433 unsigned long flags; 5434 struct lpfc_name target_wwpn; 5435 5436 if (!rport || fc_remote_port_chkready(rport)) 5437 return -ENXIO; 5438 5439 if (phba->cfg_fof) { 5440 5441 /* 5442 * Check to see if the device data structure for the lun 5443 * exists. If not, create one. 5444 */ 5445 5446 u64_to_wwn(rport->port_name, target_wwpn.u.wwn); 5447 spin_lock_irqsave(&phba->devicelock, flags); 5448 device_data = __lpfc_get_device_data(phba, 5449 &phba->luns, 5450 &vport->fc_portname, 5451 &target_wwpn, 5452 sdev->lun); 5453 if (!device_data) { 5454 spin_unlock_irqrestore(&phba->devicelock, flags); 5455 device_data = lpfc_create_device_data(phba, 5456 &vport->fc_portname, 5457 &target_wwpn, 5458 sdev->lun, true); 5459 if (!device_data) 5460 return -ENOMEM; 5461 spin_lock_irqsave(&phba->devicelock, flags); 5462 list_add_tail(&device_data->listentry, &phba->luns); 5463 } 5464 device_data->rport_data = rport->dd_data; 5465 device_data->available = true; 5466 spin_unlock_irqrestore(&phba->devicelock, flags); 5467 sdev->hostdata = device_data; 5468 } else { 5469 sdev->hostdata = rport->dd_data; 5470 } 5471 sdev_cnt = atomic_inc_return(&phba->sdev_cnt); 5472 5473 /* 5474 * Populate the cmds_per_lun count scsi_bufs into this host's globally 5475 * available list of scsi buffers. Don't allocate more than the 5476 * HBA limit conveyed to the midlayer via the host structure. The 5477 * formula accounts for the lun_queue_depth + error handlers + 1 5478 * extra. This list of scsi bufs exists for the lifetime of the driver. 5479 */ 5480 total = phba->total_scsi_bufs; 5481 num_to_alloc = vport->cfg_lun_queue_depth + 2; 5482 5483 /* If allocated buffers are enough do nothing */ 5484 if ((sdev_cnt * (vport->cfg_lun_queue_depth + 2)) < total) 5485 return 0; 5486 5487 /* Allow some exchanges to be available always to complete discovery */ 5488 if (total >= phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) { 5489 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 5490 "0704 At limitation of %d preallocated " 5491 "command buffers\n", total); 5492 return 0; 5493 /* Allow some exchanges to be available always to complete discovery */ 5494 } else if (total + num_to_alloc > 5495 phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) { 5496 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 5497 "0705 Allocation request of %d " 5498 "command buffers will exceed max of %d. " 5499 "Reducing allocation request to %d.\n", 5500 num_to_alloc, phba->cfg_hba_queue_depth, 5501 (phba->cfg_hba_queue_depth - total)); 5502 num_to_alloc = phba->cfg_hba_queue_depth - total; 5503 } 5504 num_allocated = lpfc_new_scsi_buf(vport, num_to_alloc); 5505 if (num_to_alloc != num_allocated) { 5506 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 5507 "0708 Allocation request of %d " 5508 "command buffers did not succeed. " 5509 "Allocated %d buffers.\n", 5510 num_to_alloc, num_allocated); 5511 } 5512 if (num_allocated > 0) 5513 phba->total_scsi_bufs += num_allocated; 5514 return 0; 5515 } 5516 5517 /** 5518 * lpfc_slave_configure - scsi_host_template slave_configure entry point 5519 * @sdev: Pointer to scsi_device. 5520 * 5521 * This routine configures following items 5522 * - Tag command queuing support for @sdev if supported. 5523 * - Enable SLI polling for fcp ring if ENABLE_FCP_RING_POLLING flag is set. 5524 * 5525 * Return codes: 5526 * 0 - Success 5527 **/ 5528 static int 5529 lpfc_slave_configure(struct scsi_device *sdev) 5530 { 5531 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata; 5532 struct lpfc_hba *phba = vport->phba; 5533 5534 scsi_change_queue_depth(sdev, vport->cfg_lun_queue_depth); 5535 5536 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) { 5537 lpfc_sli_handle_fast_ring_event(phba, 5538 &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ); 5539 if (phba->cfg_poll & DISABLE_FCP_RING_INT) 5540 lpfc_poll_rearm_timer(phba); 5541 } 5542 5543 return 0; 5544 } 5545 5546 /** 5547 * lpfc_slave_destroy - slave_destroy entry point of SHT data structure 5548 * @sdev: Pointer to scsi_device. 5549 * 5550 * This routine sets @sdev hostatdata filed to null. 5551 **/ 5552 static void 5553 lpfc_slave_destroy(struct scsi_device *sdev) 5554 { 5555 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata; 5556 struct lpfc_hba *phba = vport->phba; 5557 unsigned long flags; 5558 struct lpfc_device_data *device_data = sdev->hostdata; 5559 5560 atomic_dec(&phba->sdev_cnt); 5561 if ((phba->cfg_fof) && (device_data)) { 5562 spin_lock_irqsave(&phba->devicelock, flags); 5563 device_data->available = false; 5564 if (!device_data->oas_enabled) 5565 lpfc_delete_device_data(phba, device_data); 5566 spin_unlock_irqrestore(&phba->devicelock, flags); 5567 } 5568 sdev->hostdata = NULL; 5569 return; 5570 } 5571 5572 /** 5573 * lpfc_create_device_data - creates and initializes device data structure for OAS 5574 * @pha: Pointer to host bus adapter structure. 5575 * @vport_wwpn: Pointer to vport's wwpn information 5576 * @target_wwpn: Pointer to target's wwpn information 5577 * @lun: Lun on target 5578 * @atomic_create: Flag to indicate if memory should be allocated using the 5579 * GFP_ATOMIC flag or not. 5580 * 5581 * This routine creates a device data structure which will contain identifying 5582 * information for the device (host wwpn, target wwpn, lun), state of OAS, 5583 * whether or not the corresponding lun is available by the system, 5584 * and pointer to the rport data. 5585 * 5586 * Return codes: 5587 * NULL - Error 5588 * Pointer to lpfc_device_data - Success 5589 **/ 5590 struct lpfc_device_data* 5591 lpfc_create_device_data(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn, 5592 struct lpfc_name *target_wwpn, uint64_t lun, 5593 bool atomic_create) 5594 { 5595 5596 struct lpfc_device_data *lun_info; 5597 int memory_flags; 5598 5599 if (unlikely(!phba) || !vport_wwpn || !target_wwpn || 5600 !(phba->cfg_fof)) 5601 return NULL; 5602 5603 /* Attempt to create the device data to contain lun info */ 5604 5605 if (atomic_create) 5606 memory_flags = GFP_ATOMIC; 5607 else 5608 memory_flags = GFP_KERNEL; 5609 lun_info = mempool_alloc(phba->device_data_mem_pool, memory_flags); 5610 if (!lun_info) 5611 return NULL; 5612 INIT_LIST_HEAD(&lun_info->listentry); 5613 lun_info->rport_data = NULL; 5614 memcpy(&lun_info->device_id.vport_wwpn, vport_wwpn, 5615 sizeof(struct lpfc_name)); 5616 memcpy(&lun_info->device_id.target_wwpn, target_wwpn, 5617 sizeof(struct lpfc_name)); 5618 lun_info->device_id.lun = lun; 5619 lun_info->oas_enabled = false; 5620 lun_info->available = false; 5621 return lun_info; 5622 } 5623 5624 /** 5625 * lpfc_delete_device_data - frees a device data structure for OAS 5626 * @pha: Pointer to host bus adapter structure. 5627 * @lun_info: Pointer to device data structure to free. 5628 * 5629 * This routine frees the previously allocated device data structure passed. 5630 * 5631 **/ 5632 void 5633 lpfc_delete_device_data(struct lpfc_hba *phba, 5634 struct lpfc_device_data *lun_info) 5635 { 5636 5637 if (unlikely(!phba) || !lun_info || 5638 !(phba->cfg_fof)) 5639 return; 5640 5641 if (!list_empty(&lun_info->listentry)) 5642 list_del(&lun_info->listentry); 5643 mempool_free(lun_info, phba->device_data_mem_pool); 5644 return; 5645 } 5646 5647 /** 5648 * __lpfc_get_device_data - returns the device data for the specified lun 5649 * @pha: Pointer to host bus adapter structure. 5650 * @list: Point to list to search. 5651 * @vport_wwpn: Pointer to vport's wwpn information 5652 * @target_wwpn: Pointer to target's wwpn information 5653 * @lun: Lun on target 5654 * 5655 * This routine searches the list passed for the specified lun's device data. 5656 * This function does not hold locks, it is the responsibility of the caller 5657 * to ensure the proper lock is held before calling the function. 5658 * 5659 * Return codes: 5660 * NULL - Error 5661 * Pointer to lpfc_device_data - Success 5662 **/ 5663 struct lpfc_device_data* 5664 __lpfc_get_device_data(struct lpfc_hba *phba, struct list_head *list, 5665 struct lpfc_name *vport_wwpn, 5666 struct lpfc_name *target_wwpn, uint64_t lun) 5667 { 5668 5669 struct lpfc_device_data *lun_info; 5670 5671 if (unlikely(!phba) || !list || !vport_wwpn || !target_wwpn || 5672 !phba->cfg_fof) 5673 return NULL; 5674 5675 /* Check to see if the lun is already enabled for OAS. */ 5676 5677 list_for_each_entry(lun_info, list, listentry) { 5678 if ((memcmp(&lun_info->device_id.vport_wwpn, vport_wwpn, 5679 sizeof(struct lpfc_name)) == 0) && 5680 (memcmp(&lun_info->device_id.target_wwpn, target_wwpn, 5681 sizeof(struct lpfc_name)) == 0) && 5682 (lun_info->device_id.lun == lun)) 5683 return lun_info; 5684 } 5685 5686 return NULL; 5687 } 5688 5689 /** 5690 * lpfc_find_next_oas_lun - searches for the next oas lun 5691 * @pha: Pointer to host bus adapter structure. 5692 * @vport_wwpn: Pointer to vport's wwpn information 5693 * @target_wwpn: Pointer to target's wwpn information 5694 * @starting_lun: Pointer to the lun to start searching for 5695 * @found_vport_wwpn: Pointer to the found lun's vport wwpn information 5696 * @found_target_wwpn: Pointer to the found lun's target wwpn information 5697 * @found_lun: Pointer to the found lun. 5698 * @found_lun_status: Pointer to status of the found lun. 5699 * 5700 * This routine searches the luns list for the specified lun 5701 * or the first lun for the vport/target. If the vport wwpn contains 5702 * a zero value then a specific vport is not specified. In this case 5703 * any vport which contains the lun will be considered a match. If the 5704 * target wwpn contains a zero value then a specific target is not specified. 5705 * In this case any target which contains the lun will be considered a 5706 * match. If the lun is found, the lun, vport wwpn, target wwpn and lun status 5707 * are returned. The function will also return the next lun if available. 5708 * If the next lun is not found, starting_lun parameter will be set to 5709 * NO_MORE_OAS_LUN. 5710 * 5711 * Return codes: 5712 * non-0 - Error 5713 * 0 - Success 5714 **/ 5715 bool 5716 lpfc_find_next_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn, 5717 struct lpfc_name *target_wwpn, uint64_t *starting_lun, 5718 struct lpfc_name *found_vport_wwpn, 5719 struct lpfc_name *found_target_wwpn, 5720 uint64_t *found_lun, 5721 uint32_t *found_lun_status) 5722 { 5723 5724 unsigned long flags; 5725 struct lpfc_device_data *lun_info; 5726 struct lpfc_device_id *device_id; 5727 uint64_t lun; 5728 bool found = false; 5729 5730 if (unlikely(!phba) || !vport_wwpn || !target_wwpn || 5731 !starting_lun || !found_vport_wwpn || 5732 !found_target_wwpn || !found_lun || !found_lun_status || 5733 (*starting_lun == NO_MORE_OAS_LUN) || 5734 !phba->cfg_fof) 5735 return false; 5736 5737 lun = *starting_lun; 5738 *found_lun = NO_MORE_OAS_LUN; 5739 *starting_lun = NO_MORE_OAS_LUN; 5740 5741 /* Search for lun or the lun closet in value */ 5742 5743 spin_lock_irqsave(&phba->devicelock, flags); 5744 list_for_each_entry(lun_info, &phba->luns, listentry) { 5745 if (((wwn_to_u64(vport_wwpn->u.wwn) == 0) || 5746 (memcmp(&lun_info->device_id.vport_wwpn, vport_wwpn, 5747 sizeof(struct lpfc_name)) == 0)) && 5748 ((wwn_to_u64(target_wwpn->u.wwn) == 0) || 5749 (memcmp(&lun_info->device_id.target_wwpn, target_wwpn, 5750 sizeof(struct lpfc_name)) == 0)) && 5751 (lun_info->oas_enabled)) { 5752 device_id = &lun_info->device_id; 5753 if ((!found) && 5754 ((lun == FIND_FIRST_OAS_LUN) || 5755 (device_id->lun == lun))) { 5756 *found_lun = device_id->lun; 5757 memcpy(found_vport_wwpn, 5758 &device_id->vport_wwpn, 5759 sizeof(struct lpfc_name)); 5760 memcpy(found_target_wwpn, 5761 &device_id->target_wwpn, 5762 sizeof(struct lpfc_name)); 5763 if (lun_info->available) 5764 *found_lun_status = 5765 OAS_LUN_STATUS_EXISTS; 5766 else 5767 *found_lun_status = 0; 5768 if (phba->cfg_oas_flags & OAS_FIND_ANY_VPORT) 5769 memset(vport_wwpn, 0x0, 5770 sizeof(struct lpfc_name)); 5771 if (phba->cfg_oas_flags & OAS_FIND_ANY_TARGET) 5772 memset(target_wwpn, 0x0, 5773 sizeof(struct lpfc_name)); 5774 found = true; 5775 } else if (found) { 5776 *starting_lun = device_id->lun; 5777 memcpy(vport_wwpn, &device_id->vport_wwpn, 5778 sizeof(struct lpfc_name)); 5779 memcpy(target_wwpn, &device_id->target_wwpn, 5780 sizeof(struct lpfc_name)); 5781 break; 5782 } 5783 } 5784 } 5785 spin_unlock_irqrestore(&phba->devicelock, flags); 5786 return found; 5787 } 5788 5789 /** 5790 * lpfc_enable_oas_lun - enables a lun for OAS operations 5791 * @pha: Pointer to host bus adapter structure. 5792 * @vport_wwpn: Pointer to vport's wwpn information 5793 * @target_wwpn: Pointer to target's wwpn information 5794 * @lun: Lun 5795 * 5796 * This routine enables a lun for oas operations. The routines does so by 5797 * doing the following : 5798 * 5799 * 1) Checks to see if the device data for the lun has been created. 5800 * 2) If found, sets the OAS enabled flag if not set and returns. 5801 * 3) Otherwise, creates a device data structure. 5802 * 4) If successfully created, indicates the device data is for an OAS lun, 5803 * indicates the lun is not available and add to the list of luns. 5804 * 5805 * Return codes: 5806 * false - Error 5807 * true - Success 5808 **/ 5809 bool 5810 lpfc_enable_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn, 5811 struct lpfc_name *target_wwpn, uint64_t lun) 5812 { 5813 5814 struct lpfc_device_data *lun_info; 5815 unsigned long flags; 5816 5817 if (unlikely(!phba) || !vport_wwpn || !target_wwpn || 5818 !phba->cfg_fof) 5819 return false; 5820 5821 spin_lock_irqsave(&phba->devicelock, flags); 5822 5823 /* Check to see if the device data for the lun has been created */ 5824 lun_info = __lpfc_get_device_data(phba, &phba->luns, vport_wwpn, 5825 target_wwpn, lun); 5826 if (lun_info) { 5827 if (!lun_info->oas_enabled) 5828 lun_info->oas_enabled = true; 5829 spin_unlock_irqrestore(&phba->devicelock, flags); 5830 return true; 5831 } 5832 5833 /* Create an lun info structure and add to list of luns */ 5834 lun_info = lpfc_create_device_data(phba, vport_wwpn, target_wwpn, lun, 5835 false); 5836 if (lun_info) { 5837 lun_info->oas_enabled = true; 5838 lun_info->available = false; 5839 list_add_tail(&lun_info->listentry, &phba->luns); 5840 spin_unlock_irqrestore(&phba->devicelock, flags); 5841 return true; 5842 } 5843 spin_unlock_irqrestore(&phba->devicelock, flags); 5844 return false; 5845 } 5846 5847 /** 5848 * lpfc_disable_oas_lun - disables a lun for OAS operations 5849 * @pha: Pointer to host bus adapter structure. 5850 * @vport_wwpn: Pointer to vport's wwpn information 5851 * @target_wwpn: Pointer to target's wwpn information 5852 * @lun: Lun 5853 * 5854 * This routine disables a lun for oas operations. The routines does so by 5855 * doing the following : 5856 * 5857 * 1) Checks to see if the device data for the lun is created. 5858 * 2) If present, clears the flag indicating this lun is for OAS. 5859 * 3) If the lun is not available by the system, the device data is 5860 * freed. 5861 * 5862 * Return codes: 5863 * false - Error 5864 * true - Success 5865 **/ 5866 bool 5867 lpfc_disable_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn, 5868 struct lpfc_name *target_wwpn, uint64_t lun) 5869 { 5870 5871 struct lpfc_device_data *lun_info; 5872 unsigned long flags; 5873 5874 if (unlikely(!phba) || !vport_wwpn || !target_wwpn || 5875 !phba->cfg_fof) 5876 return false; 5877 5878 spin_lock_irqsave(&phba->devicelock, flags); 5879 5880 /* Check to see if the lun is available. */ 5881 lun_info = __lpfc_get_device_data(phba, 5882 &phba->luns, vport_wwpn, 5883 target_wwpn, lun); 5884 if (lun_info) { 5885 lun_info->oas_enabled = false; 5886 if (!lun_info->available) 5887 lpfc_delete_device_data(phba, lun_info); 5888 spin_unlock_irqrestore(&phba->devicelock, flags); 5889 return true; 5890 } 5891 5892 spin_unlock_irqrestore(&phba->devicelock, flags); 5893 return false; 5894 } 5895 5896 struct scsi_host_template lpfc_template_s3 = { 5897 .module = THIS_MODULE, 5898 .name = LPFC_DRIVER_NAME, 5899 .info = lpfc_info, 5900 .queuecommand = lpfc_queuecommand, 5901 .eh_abort_handler = lpfc_abort_handler, 5902 .eh_device_reset_handler = lpfc_device_reset_handler, 5903 .eh_target_reset_handler = lpfc_target_reset_handler, 5904 .eh_bus_reset_handler = lpfc_bus_reset_handler, 5905 .slave_alloc = lpfc_slave_alloc, 5906 .slave_configure = lpfc_slave_configure, 5907 .slave_destroy = lpfc_slave_destroy, 5908 .scan_finished = lpfc_scan_finished, 5909 .this_id = -1, 5910 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT, 5911 .cmd_per_lun = LPFC_CMD_PER_LUN, 5912 .use_clustering = ENABLE_CLUSTERING, 5913 .shost_attrs = lpfc_hba_attrs, 5914 .max_sectors = 0xFFFF, 5915 .vendor_id = LPFC_NL_VENDOR_ID, 5916 .change_queue_depth = scsi_change_queue_depth, 5917 .track_queue_depth = 1, 5918 }; 5919 5920 struct scsi_host_template lpfc_template = { 5921 .module = THIS_MODULE, 5922 .name = LPFC_DRIVER_NAME, 5923 .info = lpfc_info, 5924 .queuecommand = lpfc_queuecommand, 5925 .eh_abort_handler = lpfc_abort_handler, 5926 .eh_device_reset_handler = lpfc_device_reset_handler, 5927 .eh_target_reset_handler = lpfc_target_reset_handler, 5928 .eh_bus_reset_handler = lpfc_bus_reset_handler, 5929 .eh_host_reset_handler = lpfc_host_reset_handler, 5930 .slave_alloc = lpfc_slave_alloc, 5931 .slave_configure = lpfc_slave_configure, 5932 .slave_destroy = lpfc_slave_destroy, 5933 .scan_finished = lpfc_scan_finished, 5934 .this_id = -1, 5935 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT, 5936 .cmd_per_lun = LPFC_CMD_PER_LUN, 5937 .use_clustering = ENABLE_CLUSTERING, 5938 .shost_attrs = lpfc_hba_attrs, 5939 .max_sectors = 0xFFFF, 5940 .vendor_id = LPFC_NL_VENDOR_ID, 5941 .change_queue_depth = scsi_change_queue_depth, 5942 .track_queue_depth = 1, 5943 }; 5944 5945 struct scsi_host_template lpfc_vport_template = { 5946 .module = THIS_MODULE, 5947 .name = LPFC_DRIVER_NAME, 5948 .info = lpfc_info, 5949 .queuecommand = lpfc_queuecommand, 5950 .eh_abort_handler = lpfc_abort_handler, 5951 .eh_device_reset_handler = lpfc_device_reset_handler, 5952 .eh_target_reset_handler = lpfc_target_reset_handler, 5953 .eh_bus_reset_handler = lpfc_bus_reset_handler, 5954 .slave_alloc = lpfc_slave_alloc, 5955 .slave_configure = lpfc_slave_configure, 5956 .slave_destroy = lpfc_slave_destroy, 5957 .scan_finished = lpfc_scan_finished, 5958 .this_id = -1, 5959 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT, 5960 .cmd_per_lun = LPFC_CMD_PER_LUN, 5961 .use_clustering = ENABLE_CLUSTERING, 5962 .shost_attrs = lpfc_vport_attrs, 5963 .max_sectors = 0xFFFF, 5964 .change_queue_depth = scsi_change_queue_depth, 5965 .track_queue_depth = 1, 5966 }; 5967