1 /* 2 * QLogic Fibre Channel HBA Driver 3 * Copyright (c) 2003-2011 QLogic Corporation 4 * 5 * See LICENSE.qla2xxx for copyright and licensing details. 6 */ 7 #include "qla_def.h" 8 9 #include <linux/blkdev.h> 10 #include <linux/delay.h> 11 12 #include <scsi/scsi_tcq.h> 13 14 static void qla2x00_isp_cmd(struct scsi_qla_host *, struct req_que *); 15 16 static void qla25xx_set_que(srb_t *, struct rsp_que **); 17 /** 18 * qla2x00_get_cmd_direction() - Determine control_flag data direction. 19 * @cmd: SCSI command 20 * 21 * Returns the proper CF_* direction based on CDB. 22 */ 23 static inline uint16_t 24 qla2x00_get_cmd_direction(srb_t *sp) 25 { 26 uint16_t cflags; 27 28 cflags = 0; 29 30 /* Set transfer direction */ 31 if (sp->cmd->sc_data_direction == DMA_TO_DEVICE) { 32 cflags = CF_WRITE; 33 sp->fcport->vha->hw->qla_stats.output_bytes += 34 scsi_bufflen(sp->cmd); 35 } else if (sp->cmd->sc_data_direction == DMA_FROM_DEVICE) { 36 cflags = CF_READ; 37 sp->fcport->vha->hw->qla_stats.input_bytes += 38 scsi_bufflen(sp->cmd); 39 } 40 return (cflags); 41 } 42 43 /** 44 * qla2x00_calc_iocbs_32() - Determine number of Command Type 2 and 45 * Continuation Type 0 IOCBs to allocate. 46 * 47 * @dsds: number of data segment decriptors needed 48 * 49 * Returns the number of IOCB entries needed to store @dsds. 50 */ 51 uint16_t 52 qla2x00_calc_iocbs_32(uint16_t dsds) 53 { 54 uint16_t iocbs; 55 56 iocbs = 1; 57 if (dsds > 3) { 58 iocbs += (dsds - 3) / 7; 59 if ((dsds - 3) % 7) 60 iocbs++; 61 } 62 return (iocbs); 63 } 64 65 /** 66 * qla2x00_calc_iocbs_64() - Determine number of Command Type 3 and 67 * Continuation Type 1 IOCBs to allocate. 68 * 69 * @dsds: number of data segment decriptors needed 70 * 71 * Returns the number of IOCB entries needed to store @dsds. 72 */ 73 uint16_t 74 qla2x00_calc_iocbs_64(uint16_t dsds) 75 { 76 uint16_t iocbs; 77 78 iocbs = 1; 79 if (dsds > 2) { 80 iocbs += (dsds - 2) / 5; 81 if ((dsds - 2) % 5) 82 iocbs++; 83 } 84 return (iocbs); 85 } 86 87 /** 88 * qla2x00_prep_cont_type0_iocb() - Initialize a Continuation Type 0 IOCB. 89 * @ha: HA context 90 * 91 * Returns a pointer to the Continuation Type 0 IOCB packet. 92 */ 93 static inline cont_entry_t * 94 qla2x00_prep_cont_type0_iocb(struct scsi_qla_host *vha) 95 { 96 cont_entry_t *cont_pkt; 97 struct req_que *req = vha->req; 98 /* Adjust ring index. */ 99 req->ring_index++; 100 if (req->ring_index == req->length) { 101 req->ring_index = 0; 102 req->ring_ptr = req->ring; 103 } else { 104 req->ring_ptr++; 105 } 106 107 cont_pkt = (cont_entry_t *)req->ring_ptr; 108 109 /* Load packet defaults. */ 110 *((uint32_t *)(&cont_pkt->entry_type)) = 111 __constant_cpu_to_le32(CONTINUE_TYPE); 112 113 return (cont_pkt); 114 } 115 116 /** 117 * qla2x00_prep_cont_type1_iocb() - Initialize a Continuation Type 1 IOCB. 118 * @ha: HA context 119 * 120 * Returns a pointer to the continuation type 1 IOCB packet. 121 */ 122 static inline cont_a64_entry_t * 123 qla2x00_prep_cont_type1_iocb(scsi_qla_host_t *vha) 124 { 125 cont_a64_entry_t *cont_pkt; 126 127 struct req_que *req = vha->req; 128 /* Adjust ring index. */ 129 req->ring_index++; 130 if (req->ring_index == req->length) { 131 req->ring_index = 0; 132 req->ring_ptr = req->ring; 133 } else { 134 req->ring_ptr++; 135 } 136 137 cont_pkt = (cont_a64_entry_t *)req->ring_ptr; 138 139 /* Load packet defaults. */ 140 *((uint32_t *)(&cont_pkt->entry_type)) = 141 __constant_cpu_to_le32(CONTINUE_A64_TYPE); 142 143 return (cont_pkt); 144 } 145 146 static inline int 147 qla24xx_configure_prot_mode(srb_t *sp, uint16_t *fw_prot_opts) 148 { 149 uint8_t guard = scsi_host_get_guard(sp->cmd->device->host); 150 151 /* We only support T10 DIF right now */ 152 if (guard != SHOST_DIX_GUARD_CRC) { 153 ql_dbg(ql_dbg_io, sp->fcport->vha, 0x3007, 154 "Unsupported guard: %d for cmd=%p.\n", guard, sp->cmd); 155 return 0; 156 } 157 158 /* We always use DIFF Bundling for best performance */ 159 *fw_prot_opts = 0; 160 161 /* Translate SCSI opcode to a protection opcode */ 162 switch (scsi_get_prot_op(sp->cmd)) { 163 case SCSI_PROT_READ_STRIP: 164 *fw_prot_opts |= PO_MODE_DIF_REMOVE; 165 break; 166 case SCSI_PROT_WRITE_INSERT: 167 *fw_prot_opts |= PO_MODE_DIF_INSERT; 168 break; 169 case SCSI_PROT_READ_INSERT: 170 *fw_prot_opts |= PO_MODE_DIF_INSERT; 171 break; 172 case SCSI_PROT_WRITE_STRIP: 173 *fw_prot_opts |= PO_MODE_DIF_REMOVE; 174 break; 175 case SCSI_PROT_READ_PASS: 176 *fw_prot_opts |= PO_MODE_DIF_PASS; 177 break; 178 case SCSI_PROT_WRITE_PASS: 179 *fw_prot_opts |= PO_MODE_DIF_PASS; 180 break; 181 default: /* Normal Request */ 182 *fw_prot_opts |= PO_MODE_DIF_PASS; 183 break; 184 } 185 186 return scsi_prot_sg_count(sp->cmd); 187 } 188 189 /* 190 * qla2x00_build_scsi_iocbs_32() - Build IOCB command utilizing 32bit 191 * capable IOCB types. 192 * 193 * @sp: SRB command to process 194 * @cmd_pkt: Command type 2 IOCB 195 * @tot_dsds: Total number of segments to transfer 196 */ 197 void qla2x00_build_scsi_iocbs_32(srb_t *sp, cmd_entry_t *cmd_pkt, 198 uint16_t tot_dsds) 199 { 200 uint16_t avail_dsds; 201 uint32_t *cur_dsd; 202 scsi_qla_host_t *vha; 203 struct scsi_cmnd *cmd; 204 struct scatterlist *sg; 205 int i; 206 207 cmd = sp->cmd; 208 209 /* Update entry type to indicate Command Type 2 IOCB */ 210 *((uint32_t *)(&cmd_pkt->entry_type)) = 211 __constant_cpu_to_le32(COMMAND_TYPE); 212 213 /* No data transfer */ 214 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 215 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 216 return; 217 } 218 219 vha = sp->fcport->vha; 220 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp)); 221 222 /* Three DSDs are available in the Command Type 2 IOCB */ 223 avail_dsds = 3; 224 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 225 226 /* Load data segments */ 227 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 228 cont_entry_t *cont_pkt; 229 230 /* Allocate additional continuation packets? */ 231 if (avail_dsds == 0) { 232 /* 233 * Seven DSDs are available in the Continuation 234 * Type 0 IOCB. 235 */ 236 cont_pkt = qla2x00_prep_cont_type0_iocb(vha); 237 cur_dsd = (uint32_t *)&cont_pkt->dseg_0_address; 238 avail_dsds = 7; 239 } 240 241 *cur_dsd++ = cpu_to_le32(sg_dma_address(sg)); 242 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 243 avail_dsds--; 244 } 245 } 246 247 /** 248 * qla2x00_build_scsi_iocbs_64() - Build IOCB command utilizing 64bit 249 * capable IOCB types. 250 * 251 * @sp: SRB command to process 252 * @cmd_pkt: Command type 3 IOCB 253 * @tot_dsds: Total number of segments to transfer 254 */ 255 void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt, 256 uint16_t tot_dsds) 257 { 258 uint16_t avail_dsds; 259 uint32_t *cur_dsd; 260 scsi_qla_host_t *vha; 261 struct scsi_cmnd *cmd; 262 struct scatterlist *sg; 263 int i; 264 265 cmd = sp->cmd; 266 267 /* Update entry type to indicate Command Type 3 IOCB */ 268 *((uint32_t *)(&cmd_pkt->entry_type)) = 269 __constant_cpu_to_le32(COMMAND_A64_TYPE); 270 271 /* No data transfer */ 272 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 273 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 274 return; 275 } 276 277 vha = sp->fcport->vha; 278 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp)); 279 280 /* Two DSDs are available in the Command Type 3 IOCB */ 281 avail_dsds = 2; 282 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 283 284 /* Load data segments */ 285 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 286 dma_addr_t sle_dma; 287 cont_a64_entry_t *cont_pkt; 288 289 /* Allocate additional continuation packets? */ 290 if (avail_dsds == 0) { 291 /* 292 * Five DSDs are available in the Continuation 293 * Type 1 IOCB. 294 */ 295 cont_pkt = qla2x00_prep_cont_type1_iocb(vha); 296 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address; 297 avail_dsds = 5; 298 } 299 300 sle_dma = sg_dma_address(sg); 301 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 302 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 303 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 304 avail_dsds--; 305 } 306 } 307 308 /** 309 * qla2x00_start_scsi() - Send a SCSI command to the ISP 310 * @sp: command to send to the ISP 311 * 312 * Returns non-zero if a failure occurred, else zero. 313 */ 314 int 315 qla2x00_start_scsi(srb_t *sp) 316 { 317 int ret, nseg; 318 unsigned long flags; 319 scsi_qla_host_t *vha; 320 struct scsi_cmnd *cmd; 321 uint32_t *clr_ptr; 322 uint32_t index; 323 uint32_t handle; 324 cmd_entry_t *cmd_pkt; 325 uint16_t cnt; 326 uint16_t req_cnt; 327 uint16_t tot_dsds; 328 struct device_reg_2xxx __iomem *reg; 329 struct qla_hw_data *ha; 330 struct req_que *req; 331 struct rsp_que *rsp; 332 char tag[2]; 333 334 /* Setup device pointers. */ 335 ret = 0; 336 vha = sp->fcport->vha; 337 ha = vha->hw; 338 reg = &ha->iobase->isp; 339 cmd = sp->cmd; 340 req = ha->req_q_map[0]; 341 rsp = ha->rsp_q_map[0]; 342 /* So we know we haven't pci_map'ed anything yet */ 343 tot_dsds = 0; 344 345 /* Send marker if required */ 346 if (vha->marker_needed != 0) { 347 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 348 QLA_SUCCESS) { 349 return (QLA_FUNCTION_FAILED); 350 } 351 vha->marker_needed = 0; 352 } 353 354 /* Acquire ring specific lock */ 355 spin_lock_irqsave(&ha->hardware_lock, flags); 356 357 /* Check for room in outstanding command list. */ 358 handle = req->current_outstanding_cmd; 359 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) { 360 handle++; 361 if (handle == MAX_OUTSTANDING_COMMANDS) 362 handle = 1; 363 if (!req->outstanding_cmds[handle]) 364 break; 365 } 366 if (index == MAX_OUTSTANDING_COMMANDS) 367 goto queuing_error; 368 369 /* Map the sg table so we have an accurate count of sg entries needed */ 370 if (scsi_sg_count(cmd)) { 371 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 372 scsi_sg_count(cmd), cmd->sc_data_direction); 373 if (unlikely(!nseg)) 374 goto queuing_error; 375 } else 376 nseg = 0; 377 378 tot_dsds = nseg; 379 380 /* Calculate the number of request entries needed. */ 381 req_cnt = ha->isp_ops->calc_req_entries(tot_dsds); 382 if (req->cnt < (req_cnt + 2)) { 383 cnt = RD_REG_WORD_RELAXED(ISP_REQ_Q_OUT(ha, reg)); 384 if (req->ring_index < cnt) 385 req->cnt = cnt - req->ring_index; 386 else 387 req->cnt = req->length - 388 (req->ring_index - cnt); 389 } 390 if (req->cnt < (req_cnt + 2)) 391 goto queuing_error; 392 393 /* Build command packet */ 394 req->current_outstanding_cmd = handle; 395 req->outstanding_cmds[handle] = sp; 396 sp->handle = handle; 397 sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle; 398 req->cnt -= req_cnt; 399 400 cmd_pkt = (cmd_entry_t *)req->ring_ptr; 401 cmd_pkt->handle = handle; 402 /* Zero out remaining portion of packet. */ 403 clr_ptr = (uint32_t *)cmd_pkt + 2; 404 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 405 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 406 407 /* Set target ID and LUN number*/ 408 SET_TARGET_ID(ha, cmd_pkt->target, sp->fcport->loop_id); 409 cmd_pkt->lun = cpu_to_le16(sp->cmd->device->lun); 410 411 /* Update tagged queuing modifier */ 412 if (scsi_populate_tag_msg(cmd, tag)) { 413 switch (tag[0]) { 414 case HEAD_OF_QUEUE_TAG: 415 cmd_pkt->control_flags = 416 __constant_cpu_to_le16(CF_HEAD_TAG); 417 break; 418 case ORDERED_QUEUE_TAG: 419 cmd_pkt->control_flags = 420 __constant_cpu_to_le16(CF_ORDERED_TAG); 421 break; 422 default: 423 cmd_pkt->control_flags = 424 __constant_cpu_to_le16(CF_SIMPLE_TAG); 425 break; 426 } 427 } 428 429 /* Load SCSI command packet. */ 430 memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len); 431 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 432 433 /* Build IOCB segments */ 434 ha->isp_ops->build_iocbs(sp, cmd_pkt, tot_dsds); 435 436 /* Set total data segment count. */ 437 cmd_pkt->entry_count = (uint8_t)req_cnt; 438 wmb(); 439 440 /* Adjust ring index. */ 441 req->ring_index++; 442 if (req->ring_index == req->length) { 443 req->ring_index = 0; 444 req->ring_ptr = req->ring; 445 } else 446 req->ring_ptr++; 447 448 sp->flags |= SRB_DMA_VALID; 449 450 /* Set chip new ring index. */ 451 WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), req->ring_index); 452 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, reg)); /* PCI Posting. */ 453 454 /* Manage unprocessed RIO/ZIO commands in response queue. */ 455 if (vha->flags.process_response_queue && 456 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 457 qla2x00_process_response_queue(rsp); 458 459 spin_unlock_irqrestore(&ha->hardware_lock, flags); 460 return (QLA_SUCCESS); 461 462 queuing_error: 463 if (tot_dsds) 464 scsi_dma_unmap(cmd); 465 466 spin_unlock_irqrestore(&ha->hardware_lock, flags); 467 468 return (QLA_FUNCTION_FAILED); 469 } 470 471 /** 472 * qla2x00_marker() - Send a marker IOCB to the firmware. 473 * @ha: HA context 474 * @loop_id: loop ID 475 * @lun: LUN 476 * @type: marker modifier 477 * 478 * Can be called from both normal and interrupt context. 479 * 480 * Returns non-zero if a failure occurred, else zero. 481 */ 482 static int 483 __qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req, 484 struct rsp_que *rsp, uint16_t loop_id, 485 uint16_t lun, uint8_t type) 486 { 487 mrk_entry_t *mrk; 488 struct mrk_entry_24xx *mrk24; 489 struct qla_hw_data *ha = vha->hw; 490 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 491 492 mrk24 = NULL; 493 mrk = (mrk_entry_t *)qla2x00_alloc_iocbs(vha, 0); 494 if (mrk == NULL) { 495 ql_log(ql_log_warn, base_vha, 0x3026, 496 "Failed to allocate Marker IOCB.\n"); 497 498 return (QLA_FUNCTION_FAILED); 499 } 500 501 mrk->entry_type = MARKER_TYPE; 502 mrk->modifier = type; 503 if (type != MK_SYNC_ALL) { 504 if (IS_FWI2_CAPABLE(ha)) { 505 mrk24 = (struct mrk_entry_24xx *) mrk; 506 mrk24->nport_handle = cpu_to_le16(loop_id); 507 mrk24->lun[1] = LSB(lun); 508 mrk24->lun[2] = MSB(lun); 509 host_to_fcp_swap(mrk24->lun, sizeof(mrk24->lun)); 510 mrk24->vp_index = vha->vp_idx; 511 mrk24->handle = MAKE_HANDLE(req->id, mrk24->handle); 512 } else { 513 SET_TARGET_ID(ha, mrk->target, loop_id); 514 mrk->lun = cpu_to_le16(lun); 515 } 516 } 517 wmb(); 518 519 qla2x00_isp_cmd(vha, req); 520 521 return (QLA_SUCCESS); 522 } 523 524 int 525 qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req, 526 struct rsp_que *rsp, uint16_t loop_id, uint16_t lun, 527 uint8_t type) 528 { 529 int ret; 530 unsigned long flags = 0; 531 532 spin_lock_irqsave(&vha->hw->hardware_lock, flags); 533 ret = __qla2x00_marker(vha, req, rsp, loop_id, lun, type); 534 spin_unlock_irqrestore(&vha->hw->hardware_lock, flags); 535 536 return (ret); 537 } 538 539 /** 540 * qla2x00_isp_cmd() - Modify the request ring pointer. 541 * @ha: HA context 542 * 543 * Note: The caller must hold the hardware lock before calling this routine. 544 */ 545 static void 546 qla2x00_isp_cmd(struct scsi_qla_host *vha, struct req_que *req) 547 { 548 struct qla_hw_data *ha = vha->hw; 549 device_reg_t __iomem *reg = ISP_QUE_REG(ha, req->id); 550 struct device_reg_2xxx __iomem *ioreg = &ha->iobase->isp; 551 552 ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x302d, 553 "IOCB data:\n"); 554 ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302e, 555 (uint8_t *)req->ring_ptr, REQUEST_ENTRY_SIZE); 556 557 /* Adjust ring index. */ 558 req->ring_index++; 559 if (req->ring_index == req->length) { 560 req->ring_index = 0; 561 req->ring_ptr = req->ring; 562 } else 563 req->ring_ptr++; 564 565 /* Set chip new ring index. */ 566 if (IS_QLA82XX(ha)) { 567 uint32_t dbval = 0x04 | (ha->portnum << 5); 568 569 /* write, read and verify logic */ 570 dbval = dbval | (req->id << 8) | (req->ring_index << 16); 571 if (ql2xdbwr) 572 qla82xx_wr_32(ha, ha->nxdb_wr_ptr, dbval); 573 else { 574 WRT_REG_DWORD( 575 (unsigned long __iomem *)ha->nxdb_wr_ptr, 576 dbval); 577 wmb(); 578 while (RD_REG_DWORD(ha->nxdb_rd_ptr) != dbval) { 579 WRT_REG_DWORD((unsigned long __iomem *) 580 ha->nxdb_wr_ptr, dbval); 581 wmb(); 582 } 583 } 584 } else if (ha->mqenable) { 585 /* Set chip new ring index. */ 586 WRT_REG_DWORD(®->isp25mq.req_q_in, req->ring_index); 587 RD_REG_DWORD(&ioreg->hccr); 588 } else { 589 if (IS_FWI2_CAPABLE(ha)) { 590 WRT_REG_DWORD(®->isp24.req_q_in, req->ring_index); 591 RD_REG_DWORD_RELAXED(®->isp24.req_q_in); 592 } else { 593 WRT_REG_WORD(ISP_REQ_Q_IN(ha, ®->isp), 594 req->ring_index); 595 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, ®->isp)); 596 } 597 } 598 599 } 600 601 /** 602 * qla24xx_calc_iocbs() - Determine number of Command Type 3 and 603 * Continuation Type 1 IOCBs to allocate. 604 * 605 * @dsds: number of data segment decriptors needed 606 * 607 * Returns the number of IOCB entries needed to store @dsds. 608 */ 609 inline uint16_t 610 qla24xx_calc_iocbs(scsi_qla_host_t *vha, uint16_t dsds) 611 { 612 uint16_t iocbs; 613 614 iocbs = 1; 615 if (dsds > 1) { 616 iocbs += (dsds - 1) / 5; 617 if ((dsds - 1) % 5) 618 iocbs++; 619 } 620 return iocbs; 621 } 622 623 /** 624 * qla24xx_build_scsi_iocbs() - Build IOCB command utilizing Command Type 7 625 * IOCB types. 626 * 627 * @sp: SRB command to process 628 * @cmd_pkt: Command type 3 IOCB 629 * @tot_dsds: Total number of segments to transfer 630 */ 631 inline void 632 qla24xx_build_scsi_iocbs(srb_t *sp, struct cmd_type_7 *cmd_pkt, 633 uint16_t tot_dsds) 634 { 635 uint16_t avail_dsds; 636 uint32_t *cur_dsd; 637 scsi_qla_host_t *vha; 638 struct scsi_cmnd *cmd; 639 struct scatterlist *sg; 640 int i; 641 struct req_que *req; 642 643 cmd = sp->cmd; 644 645 /* Update entry type to indicate Command Type 3 IOCB */ 646 *((uint32_t *)(&cmd_pkt->entry_type)) = 647 __constant_cpu_to_le32(COMMAND_TYPE_7); 648 649 /* No data transfer */ 650 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 651 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 652 return; 653 } 654 655 vha = sp->fcport->vha; 656 req = vha->req; 657 658 /* Set transfer direction */ 659 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 660 cmd_pkt->task_mgmt_flags = 661 __constant_cpu_to_le16(TMF_WRITE_DATA); 662 sp->fcport->vha->hw->qla_stats.output_bytes += 663 scsi_bufflen(sp->cmd); 664 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 665 cmd_pkt->task_mgmt_flags = 666 __constant_cpu_to_le16(TMF_READ_DATA); 667 sp->fcport->vha->hw->qla_stats.input_bytes += 668 scsi_bufflen(sp->cmd); 669 } 670 671 /* One DSD is available in the Command Type 3 IOCB */ 672 avail_dsds = 1; 673 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 674 675 /* Load data segments */ 676 677 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 678 dma_addr_t sle_dma; 679 cont_a64_entry_t *cont_pkt; 680 681 /* Allocate additional continuation packets? */ 682 if (avail_dsds == 0) { 683 /* 684 * Five DSDs are available in the Continuation 685 * Type 1 IOCB. 686 */ 687 cont_pkt = qla2x00_prep_cont_type1_iocb(vha); 688 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address; 689 avail_dsds = 5; 690 } 691 692 sle_dma = sg_dma_address(sg); 693 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 694 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 695 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 696 avail_dsds--; 697 } 698 } 699 700 struct fw_dif_context { 701 uint32_t ref_tag; 702 uint16_t app_tag; 703 uint8_t ref_tag_mask[4]; /* Validation/Replacement Mask*/ 704 uint8_t app_tag_mask[2]; /* Validation/Replacement Mask*/ 705 }; 706 707 /* 708 * qla24xx_set_t10dif_tags_from_cmd - Extract Ref and App tags from SCSI command 709 * 710 */ 711 static inline void 712 qla24xx_set_t10dif_tags(srb_t *sp, struct fw_dif_context *pkt, 713 unsigned int protcnt) 714 { 715 struct scsi_cmnd *cmd = sp->cmd; 716 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 717 718 switch (scsi_get_prot_type(cmd)) { 719 case SCSI_PROT_DIF_TYPE0: 720 /* 721 * No check for ql2xenablehba_err_chk, as it would be an 722 * I/O error if hba tag generation is not done. 723 */ 724 pkt->ref_tag = cpu_to_le32((uint32_t) 725 (0xffffffff & scsi_get_lba(cmd))); 726 727 if (!qla2x00_hba_err_chk_enabled(sp)) 728 break; 729 730 pkt->ref_tag_mask[0] = 0xff; 731 pkt->ref_tag_mask[1] = 0xff; 732 pkt->ref_tag_mask[2] = 0xff; 733 pkt->ref_tag_mask[3] = 0xff; 734 break; 735 736 /* 737 * For TYPE 2 protection: 16 bit GUARD + 32 bit REF tag has to 738 * match LBA in CDB + N 739 */ 740 case SCSI_PROT_DIF_TYPE2: 741 pkt->app_tag = __constant_cpu_to_le16(0); 742 pkt->app_tag_mask[0] = 0x0; 743 pkt->app_tag_mask[1] = 0x0; 744 745 pkt->ref_tag = cpu_to_le32((uint32_t) 746 (0xffffffff & scsi_get_lba(cmd))); 747 748 if (!qla2x00_hba_err_chk_enabled(sp)) 749 break; 750 751 /* enable ALL bytes of the ref tag */ 752 pkt->ref_tag_mask[0] = 0xff; 753 pkt->ref_tag_mask[1] = 0xff; 754 pkt->ref_tag_mask[2] = 0xff; 755 pkt->ref_tag_mask[3] = 0xff; 756 break; 757 758 /* For Type 3 protection: 16 bit GUARD only */ 759 case SCSI_PROT_DIF_TYPE3: 760 pkt->ref_tag_mask[0] = pkt->ref_tag_mask[1] = 761 pkt->ref_tag_mask[2] = pkt->ref_tag_mask[3] = 762 0x00; 763 break; 764 765 /* 766 * For TYpe 1 protection: 16 bit GUARD tag, 32 bit REF tag, and 767 * 16 bit app tag. 768 */ 769 case SCSI_PROT_DIF_TYPE1: 770 pkt->ref_tag = cpu_to_le32((uint32_t) 771 (0xffffffff & scsi_get_lba(cmd))); 772 pkt->app_tag = __constant_cpu_to_le16(0); 773 pkt->app_tag_mask[0] = 0x0; 774 pkt->app_tag_mask[1] = 0x0; 775 776 if (!qla2x00_hba_err_chk_enabled(sp)) 777 break; 778 779 /* enable ALL bytes of the ref tag */ 780 pkt->ref_tag_mask[0] = 0xff; 781 pkt->ref_tag_mask[1] = 0xff; 782 pkt->ref_tag_mask[2] = 0xff; 783 pkt->ref_tag_mask[3] = 0xff; 784 break; 785 } 786 787 ql_dbg(ql_dbg_io, vha, 0x3009, 788 "Setting protection Tags: (BIG) ref tag = 0x%x, app tag = 0x%x, " 789 "prot SG count %d, cmd lba 0x%x, prot_type=%u cmd=%p.\n", 790 pkt->ref_tag, pkt->app_tag, protcnt, (int)scsi_get_lba(cmd), 791 scsi_get_prot_type(cmd), cmd); 792 } 793 794 struct qla2_sgx { 795 dma_addr_t dma_addr; /* OUT */ 796 uint32_t dma_len; /* OUT */ 797 798 uint32_t tot_bytes; /* IN */ 799 struct scatterlist *cur_sg; /* IN */ 800 801 /* for book keeping, bzero on initial invocation */ 802 uint32_t bytes_consumed; 803 uint32_t num_bytes; 804 uint32_t tot_partial; 805 806 /* for debugging */ 807 uint32_t num_sg; 808 srb_t *sp; 809 }; 810 811 static int 812 qla24xx_get_one_block_sg(uint32_t blk_sz, struct qla2_sgx *sgx, 813 uint32_t *partial) 814 { 815 struct scatterlist *sg; 816 uint32_t cumulative_partial, sg_len; 817 dma_addr_t sg_dma_addr; 818 819 if (sgx->num_bytes == sgx->tot_bytes) 820 return 0; 821 822 sg = sgx->cur_sg; 823 cumulative_partial = sgx->tot_partial; 824 825 sg_dma_addr = sg_dma_address(sg); 826 sg_len = sg_dma_len(sg); 827 828 sgx->dma_addr = sg_dma_addr + sgx->bytes_consumed; 829 830 if ((cumulative_partial + (sg_len - sgx->bytes_consumed)) >= blk_sz) { 831 sgx->dma_len = (blk_sz - cumulative_partial); 832 sgx->tot_partial = 0; 833 sgx->num_bytes += blk_sz; 834 *partial = 0; 835 } else { 836 sgx->dma_len = sg_len - sgx->bytes_consumed; 837 sgx->tot_partial += sgx->dma_len; 838 *partial = 1; 839 } 840 841 sgx->bytes_consumed += sgx->dma_len; 842 843 if (sg_len == sgx->bytes_consumed) { 844 sg = sg_next(sg); 845 sgx->num_sg++; 846 sgx->cur_sg = sg; 847 sgx->bytes_consumed = 0; 848 } 849 850 return 1; 851 } 852 853 static int 854 qla24xx_walk_and_build_sglist_no_difb(struct qla_hw_data *ha, srb_t *sp, 855 uint32_t *dsd, uint16_t tot_dsds) 856 { 857 void *next_dsd; 858 uint8_t avail_dsds = 0; 859 uint32_t dsd_list_len; 860 struct dsd_dma *dsd_ptr; 861 struct scatterlist *sg_prot; 862 uint32_t *cur_dsd = dsd; 863 uint16_t used_dsds = tot_dsds; 864 865 uint32_t prot_int; 866 uint32_t partial; 867 struct qla2_sgx sgx; 868 dma_addr_t sle_dma; 869 uint32_t sle_dma_len, tot_prot_dma_len = 0; 870 struct scsi_cmnd *cmd = sp->cmd; 871 872 prot_int = cmd->device->sector_size; 873 874 memset(&sgx, 0, sizeof(struct qla2_sgx)); 875 sgx.tot_bytes = scsi_bufflen(sp->cmd); 876 sgx.cur_sg = scsi_sglist(sp->cmd); 877 sgx.sp = sp; 878 879 sg_prot = scsi_prot_sglist(sp->cmd); 880 881 while (qla24xx_get_one_block_sg(prot_int, &sgx, &partial)) { 882 883 sle_dma = sgx.dma_addr; 884 sle_dma_len = sgx.dma_len; 885 alloc_and_fill: 886 /* Allocate additional continuation packets? */ 887 if (avail_dsds == 0) { 888 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ? 889 QLA_DSDS_PER_IOCB : used_dsds; 890 dsd_list_len = (avail_dsds + 1) * 12; 891 used_dsds -= avail_dsds; 892 893 /* allocate tracking DS */ 894 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 895 if (!dsd_ptr) 896 return 1; 897 898 /* allocate new list */ 899 dsd_ptr->dsd_addr = next_dsd = 900 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, 901 &dsd_ptr->dsd_list_dma); 902 903 if (!next_dsd) { 904 /* 905 * Need to cleanup only this dsd_ptr, rest 906 * will be done by sp_free_dma() 907 */ 908 kfree(dsd_ptr); 909 return 1; 910 } 911 912 list_add_tail(&dsd_ptr->list, 913 &((struct crc_context *)sp->ctx)->dsd_list); 914 915 sp->flags |= SRB_CRC_CTX_DSD_VALID; 916 917 /* add new list to cmd iocb or last list */ 918 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 919 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 920 *cur_dsd++ = dsd_list_len; 921 cur_dsd = (uint32_t *)next_dsd; 922 } 923 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 924 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 925 *cur_dsd++ = cpu_to_le32(sle_dma_len); 926 avail_dsds--; 927 928 if (partial == 0) { 929 /* Got a full protection interval */ 930 sle_dma = sg_dma_address(sg_prot) + tot_prot_dma_len; 931 sle_dma_len = 8; 932 933 tot_prot_dma_len += sle_dma_len; 934 if (tot_prot_dma_len == sg_dma_len(sg_prot)) { 935 tot_prot_dma_len = 0; 936 sg_prot = sg_next(sg_prot); 937 } 938 939 partial = 1; /* So as to not re-enter this block */ 940 goto alloc_and_fill; 941 } 942 } 943 /* Null termination */ 944 *cur_dsd++ = 0; 945 *cur_dsd++ = 0; 946 *cur_dsd++ = 0; 947 return 0; 948 } 949 static int 950 qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp, uint32_t *dsd, 951 uint16_t tot_dsds) 952 { 953 void *next_dsd; 954 uint8_t avail_dsds = 0; 955 uint32_t dsd_list_len; 956 struct dsd_dma *dsd_ptr; 957 struct scatterlist *sg; 958 uint32_t *cur_dsd = dsd; 959 int i; 960 uint16_t used_dsds = tot_dsds; 961 scsi_qla_host_t *vha = shost_priv(sp->cmd->device->host); 962 963 uint8_t *cp; 964 965 scsi_for_each_sg(sp->cmd, sg, tot_dsds, i) { 966 dma_addr_t sle_dma; 967 968 /* Allocate additional continuation packets? */ 969 if (avail_dsds == 0) { 970 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ? 971 QLA_DSDS_PER_IOCB : used_dsds; 972 dsd_list_len = (avail_dsds + 1) * 12; 973 used_dsds -= avail_dsds; 974 975 /* allocate tracking DS */ 976 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 977 if (!dsd_ptr) 978 return 1; 979 980 /* allocate new list */ 981 dsd_ptr->dsd_addr = next_dsd = 982 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, 983 &dsd_ptr->dsd_list_dma); 984 985 if (!next_dsd) { 986 /* 987 * Need to cleanup only this dsd_ptr, rest 988 * will be done by sp_free_dma() 989 */ 990 kfree(dsd_ptr); 991 return 1; 992 } 993 994 list_add_tail(&dsd_ptr->list, 995 &((struct crc_context *)sp->ctx)->dsd_list); 996 997 sp->flags |= SRB_CRC_CTX_DSD_VALID; 998 999 /* add new list to cmd iocb or last list */ 1000 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 1001 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 1002 *cur_dsd++ = dsd_list_len; 1003 cur_dsd = (uint32_t *)next_dsd; 1004 } 1005 sle_dma = sg_dma_address(sg); 1006 ql_dbg(ql_dbg_io, vha, 0x300a, 1007 "sg entry %d - addr=0x%x 0x%x, " "len=%d for cmd=%p.\n", 1008 cur_dsd, i, LSD(sle_dma), MSD(sle_dma), sg_dma_len(sg), 1009 sp->cmd); 1010 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 1011 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 1012 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 1013 avail_dsds--; 1014 1015 if (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_PASS) { 1016 cp = page_address(sg_page(sg)) + sg->offset; 1017 ql_dbg(ql_dbg_io, vha, 0x300b, 1018 "User data buffer=%p for cmd=%p.\n", cp, sp->cmd); 1019 } 1020 } 1021 /* Null termination */ 1022 *cur_dsd++ = 0; 1023 *cur_dsd++ = 0; 1024 *cur_dsd++ = 0; 1025 return 0; 1026 } 1027 1028 static int 1029 qla24xx_walk_and_build_prot_sglist(struct qla_hw_data *ha, srb_t *sp, 1030 uint32_t *dsd, 1031 uint16_t tot_dsds) 1032 { 1033 void *next_dsd; 1034 uint8_t avail_dsds = 0; 1035 uint32_t dsd_list_len; 1036 struct dsd_dma *dsd_ptr; 1037 struct scatterlist *sg; 1038 int i; 1039 struct scsi_cmnd *cmd; 1040 uint32_t *cur_dsd = dsd; 1041 uint16_t used_dsds = tot_dsds; 1042 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev); 1043 uint8_t *cp; 1044 1045 1046 cmd = sp->cmd; 1047 scsi_for_each_prot_sg(cmd, sg, tot_dsds, i) { 1048 dma_addr_t sle_dma; 1049 1050 /* Allocate additional continuation packets? */ 1051 if (avail_dsds == 0) { 1052 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ? 1053 QLA_DSDS_PER_IOCB : used_dsds; 1054 dsd_list_len = (avail_dsds + 1) * 12; 1055 used_dsds -= avail_dsds; 1056 1057 /* allocate tracking DS */ 1058 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 1059 if (!dsd_ptr) 1060 return 1; 1061 1062 /* allocate new list */ 1063 dsd_ptr->dsd_addr = next_dsd = 1064 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, 1065 &dsd_ptr->dsd_list_dma); 1066 1067 if (!next_dsd) { 1068 /* 1069 * Need to cleanup only this dsd_ptr, rest 1070 * will be done by sp_free_dma() 1071 */ 1072 kfree(dsd_ptr); 1073 return 1; 1074 } 1075 1076 list_add_tail(&dsd_ptr->list, 1077 &((struct crc_context *)sp->ctx)->dsd_list); 1078 1079 sp->flags |= SRB_CRC_CTX_DSD_VALID; 1080 1081 /* add new list to cmd iocb or last list */ 1082 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 1083 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 1084 *cur_dsd++ = dsd_list_len; 1085 cur_dsd = (uint32_t *)next_dsd; 1086 } 1087 sle_dma = sg_dma_address(sg); 1088 if (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_PASS) { 1089 ql_dbg(ql_dbg_io, vha, 0x3027, 1090 "%s(): %p, sg_entry %d - " 1091 "addr=0x%x0x%x, len=%d.\n", 1092 __func__, cur_dsd, i, 1093 LSD(sle_dma), MSD(sle_dma), sg_dma_len(sg)); 1094 } 1095 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 1096 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 1097 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 1098 1099 if (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_PASS) { 1100 cp = page_address(sg_page(sg)) + sg->offset; 1101 ql_dbg(ql_dbg_io, vha, 0x3028, 1102 "%s(): Protection Data buffer = %p.\n", __func__, 1103 cp); 1104 } 1105 avail_dsds--; 1106 } 1107 /* Null termination */ 1108 *cur_dsd++ = 0; 1109 *cur_dsd++ = 0; 1110 *cur_dsd++ = 0; 1111 return 0; 1112 } 1113 1114 /** 1115 * qla24xx_build_scsi_crc_2_iocbs() - Build IOCB command utilizing Command 1116 * Type 6 IOCB types. 1117 * 1118 * @sp: SRB command to process 1119 * @cmd_pkt: Command type 3 IOCB 1120 * @tot_dsds: Total number of segments to transfer 1121 */ 1122 static inline int 1123 qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt, 1124 uint16_t tot_dsds, uint16_t tot_prot_dsds, uint16_t fw_prot_opts) 1125 { 1126 uint32_t *cur_dsd, *fcp_dl; 1127 scsi_qla_host_t *vha; 1128 struct scsi_cmnd *cmd; 1129 struct scatterlist *cur_seg; 1130 int sgc; 1131 uint32_t total_bytes = 0; 1132 uint32_t data_bytes; 1133 uint32_t dif_bytes; 1134 uint8_t bundling = 1; 1135 uint16_t blk_size; 1136 uint8_t *clr_ptr; 1137 struct crc_context *crc_ctx_pkt = NULL; 1138 struct qla_hw_data *ha; 1139 uint8_t additional_fcpcdb_len; 1140 uint16_t fcp_cmnd_len; 1141 struct fcp_cmnd *fcp_cmnd; 1142 dma_addr_t crc_ctx_dma; 1143 char tag[2]; 1144 1145 cmd = sp->cmd; 1146 1147 sgc = 0; 1148 /* Update entry type to indicate Command Type CRC_2 IOCB */ 1149 *((uint32_t *)(&cmd_pkt->entry_type)) = 1150 __constant_cpu_to_le32(COMMAND_TYPE_CRC_2); 1151 1152 vha = sp->fcport->vha; 1153 ha = vha->hw; 1154 1155 /* No data transfer */ 1156 data_bytes = scsi_bufflen(cmd); 1157 if (!data_bytes || cmd->sc_data_direction == DMA_NONE) { 1158 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 1159 return QLA_SUCCESS; 1160 } 1161 1162 cmd_pkt->vp_index = sp->fcport->vp_idx; 1163 1164 /* Set transfer direction */ 1165 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 1166 cmd_pkt->control_flags = 1167 __constant_cpu_to_le16(CF_WRITE_DATA); 1168 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 1169 cmd_pkt->control_flags = 1170 __constant_cpu_to_le16(CF_READ_DATA); 1171 } 1172 1173 if ((scsi_get_prot_op(sp->cmd) == SCSI_PROT_READ_INSERT) || 1174 (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_STRIP) || 1175 (scsi_get_prot_op(sp->cmd) == SCSI_PROT_READ_STRIP) || 1176 (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_INSERT)) 1177 bundling = 0; 1178 1179 /* Allocate CRC context from global pool */ 1180 crc_ctx_pkt = sp->ctx = dma_pool_alloc(ha->dl_dma_pool, 1181 GFP_ATOMIC, &crc_ctx_dma); 1182 1183 if (!crc_ctx_pkt) 1184 goto crc_queuing_error; 1185 1186 /* Zero out CTX area. */ 1187 clr_ptr = (uint8_t *)crc_ctx_pkt; 1188 memset(clr_ptr, 0, sizeof(*crc_ctx_pkt)); 1189 1190 crc_ctx_pkt->crc_ctx_dma = crc_ctx_dma; 1191 1192 sp->flags |= SRB_CRC_CTX_DMA_VALID; 1193 1194 /* Set handle */ 1195 crc_ctx_pkt->handle = cmd_pkt->handle; 1196 1197 INIT_LIST_HEAD(&crc_ctx_pkt->dsd_list); 1198 1199 qla24xx_set_t10dif_tags(sp, (struct fw_dif_context *) 1200 &crc_ctx_pkt->ref_tag, tot_prot_dsds); 1201 1202 cmd_pkt->crc_context_address[0] = cpu_to_le32(LSD(crc_ctx_dma)); 1203 cmd_pkt->crc_context_address[1] = cpu_to_le32(MSD(crc_ctx_dma)); 1204 cmd_pkt->crc_context_len = CRC_CONTEXT_LEN_FW; 1205 1206 /* Determine SCSI command length -- align to 4 byte boundary */ 1207 if (cmd->cmd_len > 16) { 1208 additional_fcpcdb_len = cmd->cmd_len - 16; 1209 if ((cmd->cmd_len % 4) != 0) { 1210 /* SCSI cmd > 16 bytes must be multiple of 4 */ 1211 goto crc_queuing_error; 1212 } 1213 fcp_cmnd_len = 12 + cmd->cmd_len + 4; 1214 } else { 1215 additional_fcpcdb_len = 0; 1216 fcp_cmnd_len = 12 + 16 + 4; 1217 } 1218 1219 fcp_cmnd = &crc_ctx_pkt->fcp_cmnd; 1220 1221 fcp_cmnd->additional_cdb_len = additional_fcpcdb_len; 1222 if (cmd->sc_data_direction == DMA_TO_DEVICE) 1223 fcp_cmnd->additional_cdb_len |= 1; 1224 else if (cmd->sc_data_direction == DMA_FROM_DEVICE) 1225 fcp_cmnd->additional_cdb_len |= 2; 1226 1227 int_to_scsilun(sp->cmd->device->lun, &fcp_cmnd->lun); 1228 memcpy(fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len); 1229 cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(fcp_cmnd_len); 1230 cmd_pkt->fcp_cmnd_dseg_address[0] = cpu_to_le32( 1231 LSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF)); 1232 cmd_pkt->fcp_cmnd_dseg_address[1] = cpu_to_le32( 1233 MSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF)); 1234 fcp_cmnd->task_management = 0; 1235 1236 /* 1237 * Update tagged queuing modifier if using command tag queuing 1238 */ 1239 if (scsi_populate_tag_msg(cmd, tag)) { 1240 switch (tag[0]) { 1241 case HEAD_OF_QUEUE_TAG: 1242 fcp_cmnd->task_attribute = TSK_HEAD_OF_QUEUE; 1243 break; 1244 case ORDERED_QUEUE_TAG: 1245 fcp_cmnd->task_attribute = TSK_ORDERED; 1246 break; 1247 default: 1248 fcp_cmnd->task_attribute = 0; 1249 break; 1250 } 1251 } else { 1252 fcp_cmnd->task_attribute = 0; 1253 } 1254 1255 cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */ 1256 1257 /* Compute dif len and adjust data len to incude protection */ 1258 dif_bytes = 0; 1259 blk_size = cmd->device->sector_size; 1260 dif_bytes = (data_bytes / blk_size) * 8; 1261 1262 switch (scsi_get_prot_op(sp->cmd)) { 1263 case SCSI_PROT_READ_INSERT: 1264 case SCSI_PROT_WRITE_STRIP: 1265 total_bytes = data_bytes; 1266 data_bytes += dif_bytes; 1267 break; 1268 1269 case SCSI_PROT_READ_STRIP: 1270 case SCSI_PROT_WRITE_INSERT: 1271 case SCSI_PROT_READ_PASS: 1272 case SCSI_PROT_WRITE_PASS: 1273 total_bytes = data_bytes + dif_bytes; 1274 break; 1275 default: 1276 BUG(); 1277 } 1278 1279 if (!qla2x00_hba_err_chk_enabled(sp)) 1280 fw_prot_opts |= 0x10; /* Disable Guard tag checking */ 1281 1282 if (!bundling) { 1283 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.nobundling.data_address; 1284 } else { 1285 /* 1286 * Configure Bundling if we need to fetch interlaving 1287 * protection PCI accesses 1288 */ 1289 fw_prot_opts |= PO_ENABLE_DIF_BUNDLING; 1290 crc_ctx_pkt->u.bundling.dif_byte_count = cpu_to_le32(dif_bytes); 1291 crc_ctx_pkt->u.bundling.dseg_count = cpu_to_le16(tot_dsds - 1292 tot_prot_dsds); 1293 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.bundling.data_address; 1294 } 1295 1296 /* Finish the common fields of CRC pkt */ 1297 crc_ctx_pkt->blk_size = cpu_to_le16(blk_size); 1298 crc_ctx_pkt->prot_opts = cpu_to_le16(fw_prot_opts); 1299 crc_ctx_pkt->byte_count = cpu_to_le32(data_bytes); 1300 crc_ctx_pkt->guard_seed = __constant_cpu_to_le16(0); 1301 /* Fibre channel byte count */ 1302 cmd_pkt->byte_count = cpu_to_le32(total_bytes); 1303 fcp_dl = (uint32_t *)(crc_ctx_pkt->fcp_cmnd.cdb + 16 + 1304 additional_fcpcdb_len); 1305 *fcp_dl = htonl(total_bytes); 1306 1307 if (!data_bytes || cmd->sc_data_direction == DMA_NONE) { 1308 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 1309 return QLA_SUCCESS; 1310 } 1311 /* Walks data segments */ 1312 1313 cmd_pkt->control_flags |= 1314 __constant_cpu_to_le16(CF_DATA_SEG_DESCR_ENABLE); 1315 1316 if (!bundling && tot_prot_dsds) { 1317 if (qla24xx_walk_and_build_sglist_no_difb(ha, sp, 1318 cur_dsd, tot_dsds)) 1319 goto crc_queuing_error; 1320 } else if (qla24xx_walk_and_build_sglist(ha, sp, cur_dsd, 1321 (tot_dsds - tot_prot_dsds))) 1322 goto crc_queuing_error; 1323 1324 if (bundling && tot_prot_dsds) { 1325 /* Walks dif segments */ 1326 cur_seg = scsi_prot_sglist(cmd); 1327 cmd_pkt->control_flags |= 1328 __constant_cpu_to_le16(CF_DIF_SEG_DESCR_ENABLE); 1329 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.bundling.dif_address; 1330 if (qla24xx_walk_and_build_prot_sglist(ha, sp, cur_dsd, 1331 tot_prot_dsds)) 1332 goto crc_queuing_error; 1333 } 1334 return QLA_SUCCESS; 1335 1336 crc_queuing_error: 1337 /* Cleanup will be performed by the caller */ 1338 1339 return QLA_FUNCTION_FAILED; 1340 } 1341 1342 /** 1343 * qla24xx_start_scsi() - Send a SCSI command to the ISP 1344 * @sp: command to send to the ISP 1345 * 1346 * Returns non-zero if a failure occurred, else zero. 1347 */ 1348 int 1349 qla24xx_start_scsi(srb_t *sp) 1350 { 1351 int ret, nseg; 1352 unsigned long flags; 1353 uint32_t *clr_ptr; 1354 uint32_t index; 1355 uint32_t handle; 1356 struct cmd_type_7 *cmd_pkt; 1357 uint16_t cnt; 1358 uint16_t req_cnt; 1359 uint16_t tot_dsds; 1360 struct req_que *req = NULL; 1361 struct rsp_que *rsp = NULL; 1362 struct scsi_cmnd *cmd = sp->cmd; 1363 struct scsi_qla_host *vha = sp->fcport->vha; 1364 struct qla_hw_data *ha = vha->hw; 1365 char tag[2]; 1366 1367 /* Setup device pointers. */ 1368 ret = 0; 1369 1370 qla25xx_set_que(sp, &rsp); 1371 req = vha->req; 1372 1373 /* So we know we haven't pci_map'ed anything yet */ 1374 tot_dsds = 0; 1375 1376 /* Send marker if required */ 1377 if (vha->marker_needed != 0) { 1378 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 1379 QLA_SUCCESS) 1380 return QLA_FUNCTION_FAILED; 1381 vha->marker_needed = 0; 1382 } 1383 1384 /* Acquire ring specific lock */ 1385 spin_lock_irqsave(&ha->hardware_lock, flags); 1386 1387 /* Check for room in outstanding command list. */ 1388 handle = req->current_outstanding_cmd; 1389 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) { 1390 handle++; 1391 if (handle == MAX_OUTSTANDING_COMMANDS) 1392 handle = 1; 1393 if (!req->outstanding_cmds[handle]) 1394 break; 1395 } 1396 if (index == MAX_OUTSTANDING_COMMANDS) { 1397 goto queuing_error; 1398 } 1399 1400 /* Map the sg table so we have an accurate count of sg entries needed */ 1401 if (scsi_sg_count(cmd)) { 1402 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 1403 scsi_sg_count(cmd), cmd->sc_data_direction); 1404 if (unlikely(!nseg)) 1405 goto queuing_error; 1406 } else 1407 nseg = 0; 1408 1409 tot_dsds = nseg; 1410 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds); 1411 if (req->cnt < (req_cnt + 2)) { 1412 cnt = RD_REG_DWORD_RELAXED(req->req_q_out); 1413 1414 if (req->ring_index < cnt) 1415 req->cnt = cnt - req->ring_index; 1416 else 1417 req->cnt = req->length - 1418 (req->ring_index - cnt); 1419 } 1420 if (req->cnt < (req_cnt + 2)) 1421 goto queuing_error; 1422 1423 /* Build command packet. */ 1424 req->current_outstanding_cmd = handle; 1425 req->outstanding_cmds[handle] = sp; 1426 sp->handle = handle; 1427 sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle; 1428 req->cnt -= req_cnt; 1429 1430 cmd_pkt = (struct cmd_type_7 *)req->ring_ptr; 1431 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 1432 1433 /* Zero out remaining portion of packet. */ 1434 /* tagged queuing modifier -- default is TSK_SIMPLE (0). */ 1435 clr_ptr = (uint32_t *)cmd_pkt + 2; 1436 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 1437 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 1438 1439 /* Set NPORT-ID and LUN number*/ 1440 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1441 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 1442 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 1443 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 1444 cmd_pkt->vp_index = sp->fcport->vp_idx; 1445 1446 int_to_scsilun(sp->cmd->device->lun, &cmd_pkt->lun); 1447 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 1448 1449 /* Update tagged queuing modifier -- default is TSK_SIMPLE (0). */ 1450 if (scsi_populate_tag_msg(cmd, tag)) { 1451 switch (tag[0]) { 1452 case HEAD_OF_QUEUE_TAG: 1453 cmd_pkt->task = TSK_HEAD_OF_QUEUE; 1454 break; 1455 case ORDERED_QUEUE_TAG: 1456 cmd_pkt->task = TSK_ORDERED; 1457 break; 1458 } 1459 } 1460 1461 /* Load SCSI command packet. */ 1462 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len); 1463 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb)); 1464 1465 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 1466 1467 /* Build IOCB segments */ 1468 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds); 1469 1470 /* Set total data segment count. */ 1471 cmd_pkt->entry_count = (uint8_t)req_cnt; 1472 /* Specify response queue number where completion should happen */ 1473 cmd_pkt->entry_status = (uint8_t) rsp->id; 1474 wmb(); 1475 /* Adjust ring index. */ 1476 req->ring_index++; 1477 if (req->ring_index == req->length) { 1478 req->ring_index = 0; 1479 req->ring_ptr = req->ring; 1480 } else 1481 req->ring_ptr++; 1482 1483 sp->flags |= SRB_DMA_VALID; 1484 1485 /* Set chip new ring index. */ 1486 WRT_REG_DWORD(req->req_q_in, req->ring_index); 1487 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr); 1488 1489 /* Manage unprocessed RIO/ZIO commands in response queue. */ 1490 if (vha->flags.process_response_queue && 1491 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 1492 qla24xx_process_response_queue(vha, rsp); 1493 1494 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1495 return QLA_SUCCESS; 1496 1497 queuing_error: 1498 if (tot_dsds) 1499 scsi_dma_unmap(cmd); 1500 1501 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1502 1503 return QLA_FUNCTION_FAILED; 1504 } 1505 1506 1507 /** 1508 * qla24xx_dif_start_scsi() - Send a SCSI command to the ISP 1509 * @sp: command to send to the ISP 1510 * 1511 * Returns non-zero if a failure occurred, else zero. 1512 */ 1513 int 1514 qla24xx_dif_start_scsi(srb_t *sp) 1515 { 1516 int nseg; 1517 unsigned long flags; 1518 uint32_t *clr_ptr; 1519 uint32_t index; 1520 uint32_t handle; 1521 uint16_t cnt; 1522 uint16_t req_cnt = 0; 1523 uint16_t tot_dsds; 1524 uint16_t tot_prot_dsds; 1525 uint16_t fw_prot_opts = 0; 1526 struct req_que *req = NULL; 1527 struct rsp_que *rsp = NULL; 1528 struct scsi_cmnd *cmd = sp->cmd; 1529 struct scsi_qla_host *vha = sp->fcport->vha; 1530 struct qla_hw_data *ha = vha->hw; 1531 struct cmd_type_crc_2 *cmd_pkt; 1532 uint32_t status = 0; 1533 1534 #define QDSS_GOT_Q_SPACE BIT_0 1535 1536 /* Only process protection or >16 cdb in this routine */ 1537 if (scsi_get_prot_op(cmd) == SCSI_PROT_NORMAL) { 1538 if (cmd->cmd_len <= 16) 1539 return qla24xx_start_scsi(sp); 1540 } 1541 1542 /* Setup device pointers. */ 1543 1544 qla25xx_set_que(sp, &rsp); 1545 req = vha->req; 1546 1547 /* So we know we haven't pci_map'ed anything yet */ 1548 tot_dsds = 0; 1549 1550 /* Send marker if required */ 1551 if (vha->marker_needed != 0) { 1552 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 1553 QLA_SUCCESS) 1554 return QLA_FUNCTION_FAILED; 1555 vha->marker_needed = 0; 1556 } 1557 1558 /* Acquire ring specific lock */ 1559 spin_lock_irqsave(&ha->hardware_lock, flags); 1560 1561 /* Check for room in outstanding command list. */ 1562 handle = req->current_outstanding_cmd; 1563 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) { 1564 handle++; 1565 if (handle == MAX_OUTSTANDING_COMMANDS) 1566 handle = 1; 1567 if (!req->outstanding_cmds[handle]) 1568 break; 1569 } 1570 1571 if (index == MAX_OUTSTANDING_COMMANDS) 1572 goto queuing_error; 1573 1574 /* Compute number of required data segments */ 1575 /* Map the sg table so we have an accurate count of sg entries needed */ 1576 if (scsi_sg_count(cmd)) { 1577 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 1578 scsi_sg_count(cmd), cmd->sc_data_direction); 1579 if (unlikely(!nseg)) 1580 goto queuing_error; 1581 else 1582 sp->flags |= SRB_DMA_VALID; 1583 1584 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 1585 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) { 1586 struct qla2_sgx sgx; 1587 uint32_t partial; 1588 1589 memset(&sgx, 0, sizeof(struct qla2_sgx)); 1590 sgx.tot_bytes = scsi_bufflen(cmd); 1591 sgx.cur_sg = scsi_sglist(cmd); 1592 sgx.sp = sp; 1593 1594 nseg = 0; 1595 while (qla24xx_get_one_block_sg( 1596 cmd->device->sector_size, &sgx, &partial)) 1597 nseg++; 1598 } 1599 } else 1600 nseg = 0; 1601 1602 /* number of required data segments */ 1603 tot_dsds = nseg; 1604 1605 /* Compute number of required protection segments */ 1606 if (qla24xx_configure_prot_mode(sp, &fw_prot_opts)) { 1607 nseg = dma_map_sg(&ha->pdev->dev, scsi_prot_sglist(cmd), 1608 scsi_prot_sg_count(cmd), cmd->sc_data_direction); 1609 if (unlikely(!nseg)) 1610 goto queuing_error; 1611 else 1612 sp->flags |= SRB_CRC_PROT_DMA_VALID; 1613 1614 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 1615 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) { 1616 nseg = scsi_bufflen(cmd) / cmd->device->sector_size; 1617 } 1618 } else { 1619 nseg = 0; 1620 } 1621 1622 req_cnt = 1; 1623 /* Total Data and protection sg segment(s) */ 1624 tot_prot_dsds = nseg; 1625 tot_dsds += nseg; 1626 if (req->cnt < (req_cnt + 2)) { 1627 cnt = RD_REG_DWORD_RELAXED(req->req_q_out); 1628 1629 if (req->ring_index < cnt) 1630 req->cnt = cnt - req->ring_index; 1631 else 1632 req->cnt = req->length - 1633 (req->ring_index - cnt); 1634 } 1635 1636 if (req->cnt < (req_cnt + 2)) 1637 goto queuing_error; 1638 1639 status |= QDSS_GOT_Q_SPACE; 1640 1641 /* Build header part of command packet (excluding the OPCODE). */ 1642 req->current_outstanding_cmd = handle; 1643 req->outstanding_cmds[handle] = sp; 1644 sp->handle = handle; 1645 sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle; 1646 req->cnt -= req_cnt; 1647 1648 /* Fill-in common area */ 1649 cmd_pkt = (struct cmd_type_crc_2 *)req->ring_ptr; 1650 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 1651 1652 clr_ptr = (uint32_t *)cmd_pkt + 2; 1653 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 1654 1655 /* Set NPORT-ID and LUN number*/ 1656 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1657 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 1658 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 1659 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 1660 1661 int_to_scsilun(sp->cmd->device->lun, &cmd_pkt->lun); 1662 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 1663 1664 /* Total Data and protection segment(s) */ 1665 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 1666 1667 /* Build IOCB segments and adjust for data protection segments */ 1668 if (qla24xx_build_scsi_crc_2_iocbs(sp, (struct cmd_type_crc_2 *) 1669 req->ring_ptr, tot_dsds, tot_prot_dsds, fw_prot_opts) != 1670 QLA_SUCCESS) 1671 goto queuing_error; 1672 1673 cmd_pkt->entry_count = (uint8_t)req_cnt; 1674 /* Specify response queue number where completion should happen */ 1675 cmd_pkt->entry_status = (uint8_t) rsp->id; 1676 cmd_pkt->timeout = __constant_cpu_to_le16(0); 1677 wmb(); 1678 1679 /* Adjust ring index. */ 1680 req->ring_index++; 1681 if (req->ring_index == req->length) { 1682 req->ring_index = 0; 1683 req->ring_ptr = req->ring; 1684 } else 1685 req->ring_ptr++; 1686 1687 /* Set chip new ring index. */ 1688 WRT_REG_DWORD(req->req_q_in, req->ring_index); 1689 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr); 1690 1691 /* Manage unprocessed RIO/ZIO commands in response queue. */ 1692 if (vha->flags.process_response_queue && 1693 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 1694 qla24xx_process_response_queue(vha, rsp); 1695 1696 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1697 1698 return QLA_SUCCESS; 1699 1700 queuing_error: 1701 if (status & QDSS_GOT_Q_SPACE) { 1702 req->outstanding_cmds[handle] = NULL; 1703 req->cnt += req_cnt; 1704 } 1705 /* Cleanup will be performed by the caller (queuecommand) */ 1706 1707 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1708 return QLA_FUNCTION_FAILED; 1709 } 1710 1711 1712 static void qla25xx_set_que(srb_t *sp, struct rsp_que **rsp) 1713 { 1714 struct scsi_cmnd *cmd = sp->cmd; 1715 struct qla_hw_data *ha = sp->fcport->vha->hw; 1716 int affinity = cmd->request->cpu; 1717 1718 if (ha->flags.cpu_affinity_enabled && affinity >= 0 && 1719 affinity < ha->max_rsp_queues - 1) 1720 *rsp = ha->rsp_q_map[affinity + 1]; 1721 else 1722 *rsp = ha->rsp_q_map[0]; 1723 } 1724 1725 /* Generic Control-SRB manipulation functions. */ 1726 void * 1727 qla2x00_alloc_iocbs(scsi_qla_host_t *vha, srb_t *sp) 1728 { 1729 struct qla_hw_data *ha = vha->hw; 1730 struct req_que *req = ha->req_q_map[0]; 1731 device_reg_t __iomem *reg = ISP_QUE_REG(ha, req->id); 1732 uint32_t index, handle; 1733 request_t *pkt; 1734 uint16_t cnt, req_cnt; 1735 1736 pkt = NULL; 1737 req_cnt = 1; 1738 handle = 0; 1739 1740 if (!sp) 1741 goto skip_cmd_array; 1742 1743 /* Check for room in outstanding command list. */ 1744 handle = req->current_outstanding_cmd; 1745 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) { 1746 handle++; 1747 if (handle == MAX_OUTSTANDING_COMMANDS) 1748 handle = 1; 1749 if (!req->outstanding_cmds[handle]) 1750 break; 1751 } 1752 if (index == MAX_OUTSTANDING_COMMANDS) { 1753 ql_log(ql_log_warn, vha, 0x700b, 1754 "No room on oustanding cmd array.\n"); 1755 goto queuing_error; 1756 } 1757 1758 /* Prep command array. */ 1759 req->current_outstanding_cmd = handle; 1760 req->outstanding_cmds[handle] = sp; 1761 sp->handle = handle; 1762 1763 skip_cmd_array: 1764 /* Check for room on request queue. */ 1765 if (req->cnt < req_cnt) { 1766 if (ha->mqenable) 1767 cnt = RD_REG_DWORD(®->isp25mq.req_q_out); 1768 else if (IS_QLA82XX(ha)) 1769 cnt = RD_REG_DWORD(®->isp82.req_q_out); 1770 else if (IS_FWI2_CAPABLE(ha)) 1771 cnt = RD_REG_DWORD(®->isp24.req_q_out); 1772 else 1773 cnt = qla2x00_debounce_register( 1774 ISP_REQ_Q_OUT(ha, ®->isp)); 1775 1776 if (req->ring_index < cnt) 1777 req->cnt = cnt - req->ring_index; 1778 else 1779 req->cnt = req->length - 1780 (req->ring_index - cnt); 1781 } 1782 if (req->cnt < req_cnt) 1783 goto queuing_error; 1784 1785 /* Prep packet */ 1786 req->cnt -= req_cnt; 1787 pkt = req->ring_ptr; 1788 memset(pkt, 0, REQUEST_ENTRY_SIZE); 1789 pkt->entry_count = req_cnt; 1790 pkt->handle = handle; 1791 1792 queuing_error: 1793 return pkt; 1794 } 1795 1796 static void 1797 qla2x00_start_iocbs(srb_t *sp) 1798 { 1799 struct qla_hw_data *ha = sp->fcport->vha->hw; 1800 struct req_que *req = ha->req_q_map[0]; 1801 device_reg_t __iomem *reg = ISP_QUE_REG(ha, req->id); 1802 struct device_reg_2xxx __iomem *ioreg = &ha->iobase->isp; 1803 1804 if (IS_QLA82XX(ha)) { 1805 qla82xx_start_iocbs(sp); 1806 } else { 1807 /* Adjust ring index. */ 1808 req->ring_index++; 1809 if (req->ring_index == req->length) { 1810 req->ring_index = 0; 1811 req->ring_ptr = req->ring; 1812 } else 1813 req->ring_ptr++; 1814 1815 /* Set chip new ring index. */ 1816 if (ha->mqenable) { 1817 WRT_REG_DWORD(®->isp25mq.req_q_in, req->ring_index); 1818 RD_REG_DWORD(&ioreg->hccr); 1819 } else if (IS_QLA82XX(ha)) { 1820 qla82xx_start_iocbs(sp); 1821 } else if (IS_FWI2_CAPABLE(ha)) { 1822 WRT_REG_DWORD(®->isp24.req_q_in, req->ring_index); 1823 RD_REG_DWORD_RELAXED(®->isp24.req_q_in); 1824 } else { 1825 WRT_REG_WORD(ISP_REQ_Q_IN(ha, ®->isp), 1826 req->ring_index); 1827 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, ®->isp)); 1828 } 1829 } 1830 } 1831 1832 static void 1833 qla24xx_login_iocb(srb_t *sp, struct logio_entry_24xx *logio) 1834 { 1835 struct srb_ctx *ctx = sp->ctx; 1836 struct srb_iocb *lio = ctx->u.iocb_cmd; 1837 1838 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1839 logio->control_flags = cpu_to_le16(LCF_COMMAND_PLOGI); 1840 if (lio->u.logio.flags & SRB_LOGIN_COND_PLOGI) 1841 logio->control_flags |= cpu_to_le16(LCF_COND_PLOGI); 1842 if (lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI) 1843 logio->control_flags |= cpu_to_le16(LCF_SKIP_PRLI); 1844 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1845 logio->port_id[0] = sp->fcport->d_id.b.al_pa; 1846 logio->port_id[1] = sp->fcport->d_id.b.area; 1847 logio->port_id[2] = sp->fcport->d_id.b.domain; 1848 logio->vp_index = sp->fcport->vp_idx; 1849 } 1850 1851 static void 1852 qla2x00_login_iocb(srb_t *sp, struct mbx_entry *mbx) 1853 { 1854 struct qla_hw_data *ha = sp->fcport->vha->hw; 1855 struct srb_ctx *ctx = sp->ctx; 1856 struct srb_iocb *lio = ctx->u.iocb_cmd; 1857 uint16_t opts; 1858 1859 mbx->entry_type = MBX_IOCB_TYPE; 1860 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id); 1861 mbx->mb0 = cpu_to_le16(MBC_LOGIN_FABRIC_PORT); 1862 opts = lio->u.logio.flags & SRB_LOGIN_COND_PLOGI ? BIT_0 : 0; 1863 opts |= lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI ? BIT_1 : 0; 1864 if (HAS_EXTENDED_IDS(ha)) { 1865 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id); 1866 mbx->mb10 = cpu_to_le16(opts); 1867 } else { 1868 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | opts); 1869 } 1870 mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain); 1871 mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 | 1872 sp->fcport->d_id.b.al_pa); 1873 mbx->mb9 = cpu_to_le16(sp->fcport->vp_idx); 1874 } 1875 1876 static void 1877 qla24xx_logout_iocb(srb_t *sp, struct logio_entry_24xx *logio) 1878 { 1879 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1880 logio->control_flags = 1881 cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO); 1882 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1883 logio->port_id[0] = sp->fcport->d_id.b.al_pa; 1884 logio->port_id[1] = sp->fcport->d_id.b.area; 1885 logio->port_id[2] = sp->fcport->d_id.b.domain; 1886 logio->vp_index = sp->fcport->vp_idx; 1887 } 1888 1889 static void 1890 qla2x00_logout_iocb(srb_t *sp, struct mbx_entry *mbx) 1891 { 1892 struct qla_hw_data *ha = sp->fcport->vha->hw; 1893 1894 mbx->entry_type = MBX_IOCB_TYPE; 1895 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id); 1896 mbx->mb0 = cpu_to_le16(MBC_LOGOUT_FABRIC_PORT); 1897 mbx->mb1 = HAS_EXTENDED_IDS(ha) ? 1898 cpu_to_le16(sp->fcport->loop_id): 1899 cpu_to_le16(sp->fcport->loop_id << 8); 1900 mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain); 1901 mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 | 1902 sp->fcport->d_id.b.al_pa); 1903 mbx->mb9 = cpu_to_le16(sp->fcport->vp_idx); 1904 /* Implicit: mbx->mbx10 = 0. */ 1905 } 1906 1907 static void 1908 qla24xx_adisc_iocb(srb_t *sp, struct logio_entry_24xx *logio) 1909 { 1910 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1911 logio->control_flags = cpu_to_le16(LCF_COMMAND_ADISC); 1912 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1913 logio->vp_index = sp->fcport->vp_idx; 1914 } 1915 1916 static void 1917 qla2x00_adisc_iocb(srb_t *sp, struct mbx_entry *mbx) 1918 { 1919 struct qla_hw_data *ha = sp->fcport->vha->hw; 1920 1921 mbx->entry_type = MBX_IOCB_TYPE; 1922 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id); 1923 mbx->mb0 = cpu_to_le16(MBC_GET_PORT_DATABASE); 1924 if (HAS_EXTENDED_IDS(ha)) { 1925 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id); 1926 mbx->mb10 = cpu_to_le16(BIT_0); 1927 } else { 1928 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | BIT_0); 1929 } 1930 mbx->mb2 = cpu_to_le16(MSW(ha->async_pd_dma)); 1931 mbx->mb3 = cpu_to_le16(LSW(ha->async_pd_dma)); 1932 mbx->mb6 = cpu_to_le16(MSW(MSD(ha->async_pd_dma))); 1933 mbx->mb7 = cpu_to_le16(LSW(MSD(ha->async_pd_dma))); 1934 mbx->mb9 = cpu_to_le16(sp->fcport->vp_idx); 1935 } 1936 1937 static void 1938 qla24xx_tm_iocb(srb_t *sp, struct tsk_mgmt_entry *tsk) 1939 { 1940 uint32_t flags; 1941 unsigned int lun; 1942 struct fc_port *fcport = sp->fcport; 1943 scsi_qla_host_t *vha = fcport->vha; 1944 struct qla_hw_data *ha = vha->hw; 1945 struct srb_ctx *ctx = sp->ctx; 1946 struct srb_iocb *iocb = ctx->u.iocb_cmd; 1947 struct req_que *req = vha->req; 1948 1949 flags = iocb->u.tmf.flags; 1950 lun = iocb->u.tmf.lun; 1951 1952 tsk->entry_type = TSK_MGMT_IOCB_TYPE; 1953 tsk->entry_count = 1; 1954 tsk->handle = MAKE_HANDLE(req->id, tsk->handle); 1955 tsk->nport_handle = cpu_to_le16(fcport->loop_id); 1956 tsk->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2); 1957 tsk->control_flags = cpu_to_le32(flags); 1958 tsk->port_id[0] = fcport->d_id.b.al_pa; 1959 tsk->port_id[1] = fcport->d_id.b.area; 1960 tsk->port_id[2] = fcport->d_id.b.domain; 1961 tsk->vp_index = fcport->vp_idx; 1962 1963 if (flags == TCF_LUN_RESET) { 1964 int_to_scsilun(lun, &tsk->lun); 1965 host_to_fcp_swap((uint8_t *)&tsk->lun, 1966 sizeof(tsk->lun)); 1967 } 1968 } 1969 1970 static void 1971 qla24xx_els_iocb(srb_t *sp, struct els_entry_24xx *els_iocb) 1972 { 1973 struct fc_bsg_job *bsg_job = ((struct srb_ctx *)sp->ctx)->u.bsg_job; 1974 1975 els_iocb->entry_type = ELS_IOCB_TYPE; 1976 els_iocb->entry_count = 1; 1977 els_iocb->sys_define = 0; 1978 els_iocb->entry_status = 0; 1979 els_iocb->handle = sp->handle; 1980 els_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1981 els_iocb->tx_dsd_count = __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt); 1982 els_iocb->vp_index = sp->fcport->vp_idx; 1983 els_iocb->sof_type = EST_SOFI3; 1984 els_iocb->rx_dsd_count = __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt); 1985 1986 els_iocb->opcode = 1987 (((struct srb_ctx *)sp->ctx)->type == SRB_ELS_CMD_RPT) ? 1988 bsg_job->request->rqst_data.r_els.els_code : 1989 bsg_job->request->rqst_data.h_els.command_code; 1990 els_iocb->port_id[0] = sp->fcport->d_id.b.al_pa; 1991 els_iocb->port_id[1] = sp->fcport->d_id.b.area; 1992 els_iocb->port_id[2] = sp->fcport->d_id.b.domain; 1993 els_iocb->control_flags = 0; 1994 els_iocb->rx_byte_count = 1995 cpu_to_le32(bsg_job->reply_payload.payload_len); 1996 els_iocb->tx_byte_count = 1997 cpu_to_le32(bsg_job->request_payload.payload_len); 1998 1999 els_iocb->tx_address[0] = cpu_to_le32(LSD(sg_dma_address 2000 (bsg_job->request_payload.sg_list))); 2001 els_iocb->tx_address[1] = cpu_to_le32(MSD(sg_dma_address 2002 (bsg_job->request_payload.sg_list))); 2003 els_iocb->tx_len = cpu_to_le32(sg_dma_len 2004 (bsg_job->request_payload.sg_list)); 2005 2006 els_iocb->rx_address[0] = cpu_to_le32(LSD(sg_dma_address 2007 (bsg_job->reply_payload.sg_list))); 2008 els_iocb->rx_address[1] = cpu_to_le32(MSD(sg_dma_address 2009 (bsg_job->reply_payload.sg_list))); 2010 els_iocb->rx_len = cpu_to_le32(sg_dma_len 2011 (bsg_job->reply_payload.sg_list)); 2012 } 2013 2014 static void 2015 qla2x00_ct_iocb(srb_t *sp, ms_iocb_entry_t *ct_iocb) 2016 { 2017 uint16_t avail_dsds; 2018 uint32_t *cur_dsd; 2019 struct scatterlist *sg; 2020 int index; 2021 uint16_t tot_dsds; 2022 scsi_qla_host_t *vha = sp->fcport->vha; 2023 struct qla_hw_data *ha = vha->hw; 2024 struct fc_bsg_job *bsg_job = ((struct srb_ctx *)sp->ctx)->u.bsg_job; 2025 int loop_iterartion = 0; 2026 int cont_iocb_prsnt = 0; 2027 int entry_count = 1; 2028 2029 memset(ct_iocb, 0, sizeof(ms_iocb_entry_t)); 2030 ct_iocb->entry_type = CT_IOCB_TYPE; 2031 ct_iocb->entry_status = 0; 2032 ct_iocb->handle1 = sp->handle; 2033 SET_TARGET_ID(ha, ct_iocb->loop_id, sp->fcport->loop_id); 2034 ct_iocb->status = __constant_cpu_to_le16(0); 2035 ct_iocb->control_flags = __constant_cpu_to_le16(0); 2036 ct_iocb->timeout = 0; 2037 ct_iocb->cmd_dsd_count = 2038 __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt); 2039 ct_iocb->total_dsd_count = 2040 __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt + 1); 2041 ct_iocb->req_bytecount = 2042 cpu_to_le32(bsg_job->request_payload.payload_len); 2043 ct_iocb->rsp_bytecount = 2044 cpu_to_le32(bsg_job->reply_payload.payload_len); 2045 2046 ct_iocb->dseg_req_address[0] = cpu_to_le32(LSD(sg_dma_address 2047 (bsg_job->request_payload.sg_list))); 2048 ct_iocb->dseg_req_address[1] = cpu_to_le32(MSD(sg_dma_address 2049 (bsg_job->request_payload.sg_list))); 2050 ct_iocb->dseg_req_length = ct_iocb->req_bytecount; 2051 2052 ct_iocb->dseg_rsp_address[0] = cpu_to_le32(LSD(sg_dma_address 2053 (bsg_job->reply_payload.sg_list))); 2054 ct_iocb->dseg_rsp_address[1] = cpu_to_le32(MSD(sg_dma_address 2055 (bsg_job->reply_payload.sg_list))); 2056 ct_iocb->dseg_rsp_length = ct_iocb->rsp_bytecount; 2057 2058 avail_dsds = 1; 2059 cur_dsd = (uint32_t *)ct_iocb->dseg_rsp_address; 2060 index = 0; 2061 tot_dsds = bsg_job->reply_payload.sg_cnt; 2062 2063 for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) { 2064 dma_addr_t sle_dma; 2065 cont_a64_entry_t *cont_pkt; 2066 2067 /* Allocate additional continuation packets? */ 2068 if (avail_dsds == 0) { 2069 /* 2070 * Five DSDs are available in the Cont. 2071 * Type 1 IOCB. 2072 */ 2073 cont_pkt = qla2x00_prep_cont_type1_iocb(vha); 2074 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 2075 avail_dsds = 5; 2076 cont_iocb_prsnt = 1; 2077 entry_count++; 2078 } 2079 2080 sle_dma = sg_dma_address(sg); 2081 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 2082 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 2083 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 2084 loop_iterartion++; 2085 avail_dsds--; 2086 } 2087 ct_iocb->entry_count = entry_count; 2088 } 2089 2090 static void 2091 qla24xx_ct_iocb(srb_t *sp, struct ct_entry_24xx *ct_iocb) 2092 { 2093 uint16_t avail_dsds; 2094 uint32_t *cur_dsd; 2095 struct scatterlist *sg; 2096 int index; 2097 uint16_t tot_dsds; 2098 scsi_qla_host_t *vha = sp->fcport->vha; 2099 struct fc_bsg_job *bsg_job = ((struct srb_ctx *)sp->ctx)->u.bsg_job; 2100 int loop_iterartion = 0; 2101 int cont_iocb_prsnt = 0; 2102 int entry_count = 1; 2103 2104 ct_iocb->entry_type = CT_IOCB_TYPE; 2105 ct_iocb->entry_status = 0; 2106 ct_iocb->sys_define = 0; 2107 ct_iocb->handle = sp->handle; 2108 2109 ct_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2110 ct_iocb->vp_index = sp->fcport->vp_idx; 2111 ct_iocb->comp_status = __constant_cpu_to_le16(0); 2112 2113 ct_iocb->cmd_dsd_count = 2114 __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt); 2115 ct_iocb->timeout = 0; 2116 ct_iocb->rsp_dsd_count = 2117 __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt); 2118 ct_iocb->rsp_byte_count = 2119 cpu_to_le32(bsg_job->reply_payload.payload_len); 2120 ct_iocb->cmd_byte_count = 2121 cpu_to_le32(bsg_job->request_payload.payload_len); 2122 ct_iocb->dseg_0_address[0] = cpu_to_le32(LSD(sg_dma_address 2123 (bsg_job->request_payload.sg_list))); 2124 ct_iocb->dseg_0_address[1] = cpu_to_le32(MSD(sg_dma_address 2125 (bsg_job->request_payload.sg_list))); 2126 ct_iocb->dseg_0_len = cpu_to_le32(sg_dma_len 2127 (bsg_job->request_payload.sg_list)); 2128 2129 avail_dsds = 1; 2130 cur_dsd = (uint32_t *)ct_iocb->dseg_1_address; 2131 index = 0; 2132 tot_dsds = bsg_job->reply_payload.sg_cnt; 2133 2134 for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) { 2135 dma_addr_t sle_dma; 2136 cont_a64_entry_t *cont_pkt; 2137 2138 /* Allocate additional continuation packets? */ 2139 if (avail_dsds == 0) { 2140 /* 2141 * Five DSDs are available in the Cont. 2142 * Type 1 IOCB. 2143 */ 2144 cont_pkt = qla2x00_prep_cont_type1_iocb(vha); 2145 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 2146 avail_dsds = 5; 2147 cont_iocb_prsnt = 1; 2148 entry_count++; 2149 } 2150 2151 sle_dma = sg_dma_address(sg); 2152 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 2153 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 2154 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 2155 loop_iterartion++; 2156 avail_dsds--; 2157 } 2158 ct_iocb->entry_count = entry_count; 2159 } 2160 2161 int 2162 qla2x00_start_sp(srb_t *sp) 2163 { 2164 int rval; 2165 struct qla_hw_data *ha = sp->fcport->vha->hw; 2166 void *pkt; 2167 struct srb_ctx *ctx = sp->ctx; 2168 unsigned long flags; 2169 2170 rval = QLA_FUNCTION_FAILED; 2171 spin_lock_irqsave(&ha->hardware_lock, flags); 2172 pkt = qla2x00_alloc_iocbs(sp->fcport->vha, sp); 2173 if (!pkt) { 2174 ql_log(ql_log_warn, sp->fcport->vha, 0x700c, 2175 "qla2x00_alloc_iocbs failed.\n"); 2176 goto done; 2177 } 2178 2179 rval = QLA_SUCCESS; 2180 switch (ctx->type) { 2181 case SRB_LOGIN_CMD: 2182 IS_FWI2_CAPABLE(ha) ? 2183 qla24xx_login_iocb(sp, pkt) : 2184 qla2x00_login_iocb(sp, pkt); 2185 break; 2186 case SRB_LOGOUT_CMD: 2187 IS_FWI2_CAPABLE(ha) ? 2188 qla24xx_logout_iocb(sp, pkt) : 2189 qla2x00_logout_iocb(sp, pkt); 2190 break; 2191 case SRB_ELS_CMD_RPT: 2192 case SRB_ELS_CMD_HST: 2193 qla24xx_els_iocb(sp, pkt); 2194 break; 2195 case SRB_CT_CMD: 2196 IS_FWI2_CAPABLE(ha) ? 2197 qla24xx_ct_iocb(sp, pkt) : 2198 qla2x00_ct_iocb(sp, pkt); 2199 break; 2200 case SRB_ADISC_CMD: 2201 IS_FWI2_CAPABLE(ha) ? 2202 qla24xx_adisc_iocb(sp, pkt) : 2203 qla2x00_adisc_iocb(sp, pkt); 2204 break; 2205 case SRB_TM_CMD: 2206 qla24xx_tm_iocb(sp, pkt); 2207 break; 2208 default: 2209 break; 2210 } 2211 2212 wmb(); 2213 qla2x00_start_iocbs(sp); 2214 done: 2215 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2216 return rval; 2217 } 2218