1 /* 2 * QLogic Fibre Channel HBA Driver 3 * Copyright (c) 2003-2013 QLogic Corporation 4 * 5 * See LICENSE.qla2xxx for copyright and licensing details. 6 */ 7 #include "qla_def.h" 8 #include "qla_target.h" 9 10 #include <linux/blkdev.h> 11 #include <linux/delay.h> 12 13 #include <scsi/scsi_tcq.h> 14 15 static void qla25xx_set_que(srb_t *, struct rsp_que **); 16 /** 17 * qla2x00_get_cmd_direction() - Determine control_flag data direction. 18 * @cmd: SCSI command 19 * 20 * Returns the proper CF_* direction based on CDB. 21 */ 22 static inline uint16_t 23 qla2x00_get_cmd_direction(srb_t *sp) 24 { 25 uint16_t cflags; 26 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 27 struct scsi_qla_host *vha = sp->fcport->vha; 28 29 cflags = 0; 30 31 /* Set transfer direction */ 32 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 33 cflags = CF_WRITE; 34 vha->qla_stats.output_bytes += scsi_bufflen(cmd); 35 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 36 cflags = CF_READ; 37 vha->qla_stats.input_bytes += scsi_bufflen(cmd); 38 } 39 return (cflags); 40 } 41 42 /** 43 * qla2x00_calc_iocbs_32() - Determine number of Command Type 2 and 44 * Continuation Type 0 IOCBs to allocate. 45 * 46 * @dsds: number of data segment decriptors needed 47 * 48 * Returns the number of IOCB entries needed to store @dsds. 49 */ 50 uint16_t 51 qla2x00_calc_iocbs_32(uint16_t dsds) 52 { 53 uint16_t iocbs; 54 55 iocbs = 1; 56 if (dsds > 3) { 57 iocbs += (dsds - 3) / 7; 58 if ((dsds - 3) % 7) 59 iocbs++; 60 } 61 return (iocbs); 62 } 63 64 /** 65 * qla2x00_calc_iocbs_64() - Determine number of Command Type 3 and 66 * Continuation Type 1 IOCBs to allocate. 67 * 68 * @dsds: number of data segment decriptors needed 69 * 70 * Returns the number of IOCB entries needed to store @dsds. 71 */ 72 uint16_t 73 qla2x00_calc_iocbs_64(uint16_t dsds) 74 { 75 uint16_t iocbs; 76 77 iocbs = 1; 78 if (dsds > 2) { 79 iocbs += (dsds - 2) / 5; 80 if ((dsds - 2) % 5) 81 iocbs++; 82 } 83 return (iocbs); 84 } 85 86 /** 87 * qla2x00_prep_cont_type0_iocb() - Initialize a Continuation Type 0 IOCB. 88 * @ha: HA context 89 * 90 * Returns a pointer to the Continuation Type 0 IOCB packet. 91 */ 92 static inline cont_entry_t * 93 qla2x00_prep_cont_type0_iocb(struct scsi_qla_host *vha) 94 { 95 cont_entry_t *cont_pkt; 96 struct req_que *req = vha->req; 97 /* Adjust ring index. */ 98 req->ring_index++; 99 if (req->ring_index == req->length) { 100 req->ring_index = 0; 101 req->ring_ptr = req->ring; 102 } else { 103 req->ring_ptr++; 104 } 105 106 cont_pkt = (cont_entry_t *)req->ring_ptr; 107 108 /* Load packet defaults. */ 109 *((uint32_t *)(&cont_pkt->entry_type)) = 110 __constant_cpu_to_le32(CONTINUE_TYPE); 111 112 return (cont_pkt); 113 } 114 115 /** 116 * qla2x00_prep_cont_type1_iocb() - Initialize a Continuation Type 1 IOCB. 117 * @ha: HA context 118 * 119 * Returns a pointer to the continuation type 1 IOCB packet. 120 */ 121 static inline cont_a64_entry_t * 122 qla2x00_prep_cont_type1_iocb(scsi_qla_host_t *vha, struct req_que *req) 123 { 124 cont_a64_entry_t *cont_pkt; 125 126 /* Adjust ring index. */ 127 req->ring_index++; 128 if (req->ring_index == req->length) { 129 req->ring_index = 0; 130 req->ring_ptr = req->ring; 131 } else { 132 req->ring_ptr++; 133 } 134 135 cont_pkt = (cont_a64_entry_t *)req->ring_ptr; 136 137 /* Load packet defaults. */ 138 *((uint32_t *)(&cont_pkt->entry_type)) = 139 __constant_cpu_to_le32(CONTINUE_A64_TYPE); 140 141 return (cont_pkt); 142 } 143 144 static inline int 145 qla24xx_configure_prot_mode(srb_t *sp, uint16_t *fw_prot_opts) 146 { 147 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 148 uint8_t guard = scsi_host_get_guard(cmd->device->host); 149 150 /* We always use DIFF Bundling for best performance */ 151 *fw_prot_opts = 0; 152 153 /* Translate SCSI opcode to a protection opcode */ 154 switch (scsi_get_prot_op(cmd)) { 155 case SCSI_PROT_READ_STRIP: 156 *fw_prot_opts |= PO_MODE_DIF_REMOVE; 157 break; 158 case SCSI_PROT_WRITE_INSERT: 159 *fw_prot_opts |= PO_MODE_DIF_INSERT; 160 break; 161 case SCSI_PROT_READ_INSERT: 162 *fw_prot_opts |= PO_MODE_DIF_INSERT; 163 break; 164 case SCSI_PROT_WRITE_STRIP: 165 *fw_prot_opts |= PO_MODE_DIF_REMOVE; 166 break; 167 case SCSI_PROT_READ_PASS: 168 case SCSI_PROT_WRITE_PASS: 169 if (guard & SHOST_DIX_GUARD_IP) 170 *fw_prot_opts |= PO_MODE_DIF_TCP_CKSUM; 171 else 172 *fw_prot_opts |= PO_MODE_DIF_PASS; 173 break; 174 default: /* Normal Request */ 175 *fw_prot_opts |= PO_MODE_DIF_PASS; 176 break; 177 } 178 179 return scsi_prot_sg_count(cmd); 180 } 181 182 /* 183 * qla2x00_build_scsi_iocbs_32() - Build IOCB command utilizing 32bit 184 * capable IOCB types. 185 * 186 * @sp: SRB command to process 187 * @cmd_pkt: Command type 2 IOCB 188 * @tot_dsds: Total number of segments to transfer 189 */ 190 void qla2x00_build_scsi_iocbs_32(srb_t *sp, cmd_entry_t *cmd_pkt, 191 uint16_t tot_dsds) 192 { 193 uint16_t avail_dsds; 194 uint32_t *cur_dsd; 195 scsi_qla_host_t *vha; 196 struct scsi_cmnd *cmd; 197 struct scatterlist *sg; 198 int i; 199 200 cmd = GET_CMD_SP(sp); 201 202 /* Update entry type to indicate Command Type 2 IOCB */ 203 *((uint32_t *)(&cmd_pkt->entry_type)) = 204 __constant_cpu_to_le32(COMMAND_TYPE); 205 206 /* No data transfer */ 207 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 208 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 209 return; 210 } 211 212 vha = sp->fcport->vha; 213 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp)); 214 215 /* Three DSDs are available in the Command Type 2 IOCB */ 216 avail_dsds = 3; 217 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 218 219 /* Load data segments */ 220 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 221 cont_entry_t *cont_pkt; 222 223 /* Allocate additional continuation packets? */ 224 if (avail_dsds == 0) { 225 /* 226 * Seven DSDs are available in the Continuation 227 * Type 0 IOCB. 228 */ 229 cont_pkt = qla2x00_prep_cont_type0_iocb(vha); 230 cur_dsd = (uint32_t *)&cont_pkt->dseg_0_address; 231 avail_dsds = 7; 232 } 233 234 *cur_dsd++ = cpu_to_le32(sg_dma_address(sg)); 235 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 236 avail_dsds--; 237 } 238 } 239 240 /** 241 * qla2x00_build_scsi_iocbs_64() - Build IOCB command utilizing 64bit 242 * capable IOCB types. 243 * 244 * @sp: SRB command to process 245 * @cmd_pkt: Command type 3 IOCB 246 * @tot_dsds: Total number of segments to transfer 247 */ 248 void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt, 249 uint16_t tot_dsds) 250 { 251 uint16_t avail_dsds; 252 uint32_t *cur_dsd; 253 scsi_qla_host_t *vha; 254 struct scsi_cmnd *cmd; 255 struct scatterlist *sg; 256 int i; 257 258 cmd = GET_CMD_SP(sp); 259 260 /* Update entry type to indicate Command Type 3 IOCB */ 261 *((uint32_t *)(&cmd_pkt->entry_type)) = 262 __constant_cpu_to_le32(COMMAND_A64_TYPE); 263 264 /* No data transfer */ 265 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 266 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 267 return; 268 } 269 270 vha = sp->fcport->vha; 271 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp)); 272 273 /* Two DSDs are available in the Command Type 3 IOCB */ 274 avail_dsds = 2; 275 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 276 277 /* Load data segments */ 278 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 279 dma_addr_t sle_dma; 280 cont_a64_entry_t *cont_pkt; 281 282 /* Allocate additional continuation packets? */ 283 if (avail_dsds == 0) { 284 /* 285 * Five DSDs are available in the Continuation 286 * Type 1 IOCB. 287 */ 288 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req); 289 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address; 290 avail_dsds = 5; 291 } 292 293 sle_dma = sg_dma_address(sg); 294 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 295 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 296 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 297 avail_dsds--; 298 } 299 } 300 301 /** 302 * qla2x00_start_scsi() - Send a SCSI command to the ISP 303 * @sp: command to send to the ISP 304 * 305 * Returns non-zero if a failure occurred, else zero. 306 */ 307 int 308 qla2x00_start_scsi(srb_t *sp) 309 { 310 int ret, nseg; 311 unsigned long flags; 312 scsi_qla_host_t *vha; 313 struct scsi_cmnd *cmd; 314 uint32_t *clr_ptr; 315 uint32_t index; 316 uint32_t handle; 317 cmd_entry_t *cmd_pkt; 318 uint16_t cnt; 319 uint16_t req_cnt; 320 uint16_t tot_dsds; 321 struct device_reg_2xxx __iomem *reg; 322 struct qla_hw_data *ha; 323 struct req_que *req; 324 struct rsp_que *rsp; 325 char tag[2]; 326 327 /* Setup device pointers. */ 328 ret = 0; 329 vha = sp->fcport->vha; 330 ha = vha->hw; 331 reg = &ha->iobase->isp; 332 cmd = GET_CMD_SP(sp); 333 req = ha->req_q_map[0]; 334 rsp = ha->rsp_q_map[0]; 335 /* So we know we haven't pci_map'ed anything yet */ 336 tot_dsds = 0; 337 338 /* Send marker if required */ 339 if (vha->marker_needed != 0) { 340 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 341 QLA_SUCCESS) { 342 return (QLA_FUNCTION_FAILED); 343 } 344 vha->marker_needed = 0; 345 } 346 347 /* Acquire ring specific lock */ 348 spin_lock_irqsave(&ha->hardware_lock, flags); 349 350 /* Check for room in outstanding command list. */ 351 handle = req->current_outstanding_cmd; 352 for (index = 1; index < req->num_outstanding_cmds; index++) { 353 handle++; 354 if (handle == req->num_outstanding_cmds) 355 handle = 1; 356 if (!req->outstanding_cmds[handle]) 357 break; 358 } 359 if (index == req->num_outstanding_cmds) 360 goto queuing_error; 361 362 /* Map the sg table so we have an accurate count of sg entries needed */ 363 if (scsi_sg_count(cmd)) { 364 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 365 scsi_sg_count(cmd), cmd->sc_data_direction); 366 if (unlikely(!nseg)) 367 goto queuing_error; 368 } else 369 nseg = 0; 370 371 tot_dsds = nseg; 372 373 /* Calculate the number of request entries needed. */ 374 req_cnt = ha->isp_ops->calc_req_entries(tot_dsds); 375 if (req->cnt < (req_cnt + 2)) { 376 cnt = RD_REG_WORD_RELAXED(ISP_REQ_Q_OUT(ha, reg)); 377 if (req->ring_index < cnt) 378 req->cnt = cnt - req->ring_index; 379 else 380 req->cnt = req->length - 381 (req->ring_index - cnt); 382 /* If still no head room then bail out */ 383 if (req->cnt < (req_cnt + 2)) 384 goto queuing_error; 385 } 386 387 /* Build command packet */ 388 req->current_outstanding_cmd = handle; 389 req->outstanding_cmds[handle] = sp; 390 sp->handle = handle; 391 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 392 req->cnt -= req_cnt; 393 394 cmd_pkt = (cmd_entry_t *)req->ring_ptr; 395 cmd_pkt->handle = handle; 396 /* Zero out remaining portion of packet. */ 397 clr_ptr = (uint32_t *)cmd_pkt + 2; 398 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 399 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 400 401 /* Set target ID and LUN number*/ 402 SET_TARGET_ID(ha, cmd_pkt->target, sp->fcport->loop_id); 403 cmd_pkt->lun = cpu_to_le16(cmd->device->lun); 404 405 /* Update tagged queuing modifier */ 406 if (scsi_populate_tag_msg(cmd, tag)) { 407 switch (tag[0]) { 408 case HEAD_OF_QUEUE_TAG: 409 cmd_pkt->control_flags = 410 __constant_cpu_to_le16(CF_HEAD_TAG); 411 break; 412 case ORDERED_QUEUE_TAG: 413 cmd_pkt->control_flags = 414 __constant_cpu_to_le16(CF_ORDERED_TAG); 415 break; 416 default: 417 cmd_pkt->control_flags = 418 __constant_cpu_to_le16(CF_SIMPLE_TAG); 419 break; 420 } 421 } 422 423 /* Load SCSI command packet. */ 424 memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len); 425 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 426 427 /* Build IOCB segments */ 428 ha->isp_ops->build_iocbs(sp, cmd_pkt, tot_dsds); 429 430 /* Set total data segment count. */ 431 cmd_pkt->entry_count = (uint8_t)req_cnt; 432 wmb(); 433 434 /* Adjust ring index. */ 435 req->ring_index++; 436 if (req->ring_index == req->length) { 437 req->ring_index = 0; 438 req->ring_ptr = req->ring; 439 } else 440 req->ring_ptr++; 441 442 sp->flags |= SRB_DMA_VALID; 443 444 /* Set chip new ring index. */ 445 WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), req->ring_index); 446 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, reg)); /* PCI Posting. */ 447 448 /* Manage unprocessed RIO/ZIO commands in response queue. */ 449 if (vha->flags.process_response_queue && 450 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 451 qla2x00_process_response_queue(rsp); 452 453 spin_unlock_irqrestore(&ha->hardware_lock, flags); 454 return (QLA_SUCCESS); 455 456 queuing_error: 457 if (tot_dsds) 458 scsi_dma_unmap(cmd); 459 460 spin_unlock_irqrestore(&ha->hardware_lock, flags); 461 462 return (QLA_FUNCTION_FAILED); 463 } 464 465 /** 466 * qla2x00_start_iocbs() - Execute the IOCB command 467 */ 468 void 469 qla2x00_start_iocbs(struct scsi_qla_host *vha, struct req_que *req) 470 { 471 struct qla_hw_data *ha = vha->hw; 472 device_reg_t __iomem *reg = ISP_QUE_REG(ha, req->id); 473 474 if (IS_QLA82XX(ha)) { 475 qla82xx_start_iocbs(vha); 476 } else { 477 /* Adjust ring index. */ 478 req->ring_index++; 479 if (req->ring_index == req->length) { 480 req->ring_index = 0; 481 req->ring_ptr = req->ring; 482 } else 483 req->ring_ptr++; 484 485 /* Set chip new ring index. */ 486 if (ha->mqenable || IS_QLA83XX(ha)) { 487 WRT_REG_DWORD(req->req_q_in, req->ring_index); 488 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr); 489 } else if (IS_FWI2_CAPABLE(ha)) { 490 WRT_REG_DWORD(®->isp24.req_q_in, req->ring_index); 491 RD_REG_DWORD_RELAXED(®->isp24.req_q_in); 492 } else { 493 WRT_REG_WORD(ISP_REQ_Q_IN(ha, ®->isp), 494 req->ring_index); 495 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, ®->isp)); 496 } 497 } 498 } 499 500 /** 501 * qla2x00_marker() - Send a marker IOCB to the firmware. 502 * @ha: HA context 503 * @loop_id: loop ID 504 * @lun: LUN 505 * @type: marker modifier 506 * 507 * Can be called from both normal and interrupt context. 508 * 509 * Returns non-zero if a failure occurred, else zero. 510 */ 511 static int 512 __qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req, 513 struct rsp_que *rsp, uint16_t loop_id, 514 uint16_t lun, uint8_t type) 515 { 516 mrk_entry_t *mrk; 517 struct mrk_entry_24xx *mrk24; 518 struct qla_hw_data *ha = vha->hw; 519 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 520 521 mrk24 = NULL; 522 req = ha->req_q_map[0]; 523 mrk = (mrk_entry_t *)qla2x00_alloc_iocbs(vha, NULL); 524 if (mrk == NULL) { 525 ql_log(ql_log_warn, base_vha, 0x3026, 526 "Failed to allocate Marker IOCB.\n"); 527 528 return (QLA_FUNCTION_FAILED); 529 } 530 531 mrk->entry_type = MARKER_TYPE; 532 mrk->modifier = type; 533 if (type != MK_SYNC_ALL) { 534 if (IS_FWI2_CAPABLE(ha)) { 535 mrk24 = (struct mrk_entry_24xx *) mrk; 536 mrk24->nport_handle = cpu_to_le16(loop_id); 537 mrk24->lun[1] = LSB(lun); 538 mrk24->lun[2] = MSB(lun); 539 host_to_fcp_swap(mrk24->lun, sizeof(mrk24->lun)); 540 mrk24->vp_index = vha->vp_idx; 541 mrk24->handle = MAKE_HANDLE(req->id, mrk24->handle); 542 } else { 543 SET_TARGET_ID(ha, mrk->target, loop_id); 544 mrk->lun = cpu_to_le16(lun); 545 } 546 } 547 wmb(); 548 549 qla2x00_start_iocbs(vha, req); 550 551 return (QLA_SUCCESS); 552 } 553 554 int 555 qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req, 556 struct rsp_que *rsp, uint16_t loop_id, uint16_t lun, 557 uint8_t type) 558 { 559 int ret; 560 unsigned long flags = 0; 561 562 spin_lock_irqsave(&vha->hw->hardware_lock, flags); 563 ret = __qla2x00_marker(vha, req, rsp, loop_id, lun, type); 564 spin_unlock_irqrestore(&vha->hw->hardware_lock, flags); 565 566 return (ret); 567 } 568 569 /* 570 * qla2x00_issue_marker 571 * 572 * Issue marker 573 * Caller CAN have hardware lock held as specified by ha_locked parameter. 574 * Might release it, then reaquire. 575 */ 576 int qla2x00_issue_marker(scsi_qla_host_t *vha, int ha_locked) 577 { 578 if (ha_locked) { 579 if (__qla2x00_marker(vha, vha->req, vha->req->rsp, 0, 0, 580 MK_SYNC_ALL) != QLA_SUCCESS) 581 return QLA_FUNCTION_FAILED; 582 } else { 583 if (qla2x00_marker(vha, vha->req, vha->req->rsp, 0, 0, 584 MK_SYNC_ALL) != QLA_SUCCESS) 585 return QLA_FUNCTION_FAILED; 586 } 587 vha->marker_needed = 0; 588 589 return QLA_SUCCESS; 590 } 591 592 /** 593 * qla24xx_calc_iocbs() - Determine number of Command Type 3 and 594 * Continuation Type 1 IOCBs to allocate. 595 * 596 * @dsds: number of data segment decriptors needed 597 * 598 * Returns the number of IOCB entries needed to store @dsds. 599 */ 600 inline uint16_t 601 qla24xx_calc_iocbs(scsi_qla_host_t *vha, uint16_t dsds) 602 { 603 uint16_t iocbs; 604 605 iocbs = 1; 606 if (dsds > 1) { 607 iocbs += (dsds - 1) / 5; 608 if ((dsds - 1) % 5) 609 iocbs++; 610 } 611 return iocbs; 612 } 613 614 static inline int 615 qla24xx_build_scsi_type_6_iocbs(srb_t *sp, struct cmd_type_6 *cmd_pkt, 616 uint16_t tot_dsds) 617 { 618 uint32_t *cur_dsd = NULL; 619 scsi_qla_host_t *vha; 620 struct qla_hw_data *ha; 621 struct scsi_cmnd *cmd; 622 struct scatterlist *cur_seg; 623 uint32_t *dsd_seg; 624 void *next_dsd; 625 uint8_t avail_dsds; 626 uint8_t first_iocb = 1; 627 uint32_t dsd_list_len; 628 struct dsd_dma *dsd_ptr; 629 struct ct6_dsd *ctx; 630 631 cmd = GET_CMD_SP(sp); 632 633 /* Update entry type to indicate Command Type 3 IOCB */ 634 *((uint32_t *)(&cmd_pkt->entry_type)) = 635 __constant_cpu_to_le32(COMMAND_TYPE_6); 636 637 /* No data transfer */ 638 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 639 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 640 return 0; 641 } 642 643 vha = sp->fcport->vha; 644 ha = vha->hw; 645 646 /* Set transfer direction */ 647 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 648 cmd_pkt->control_flags = 649 __constant_cpu_to_le16(CF_WRITE_DATA); 650 vha->qla_stats.output_bytes += scsi_bufflen(cmd); 651 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 652 cmd_pkt->control_flags = 653 __constant_cpu_to_le16(CF_READ_DATA); 654 vha->qla_stats.input_bytes += scsi_bufflen(cmd); 655 } 656 657 cur_seg = scsi_sglist(cmd); 658 ctx = GET_CMD_CTX_SP(sp); 659 660 while (tot_dsds) { 661 avail_dsds = (tot_dsds > QLA_DSDS_PER_IOCB) ? 662 QLA_DSDS_PER_IOCB : tot_dsds; 663 tot_dsds -= avail_dsds; 664 dsd_list_len = (avail_dsds + 1) * QLA_DSD_SIZE; 665 666 dsd_ptr = list_first_entry(&ha->gbl_dsd_list, 667 struct dsd_dma, list); 668 next_dsd = dsd_ptr->dsd_addr; 669 list_del(&dsd_ptr->list); 670 ha->gbl_dsd_avail--; 671 list_add_tail(&dsd_ptr->list, &ctx->dsd_list); 672 ctx->dsd_use_cnt++; 673 ha->gbl_dsd_inuse++; 674 675 if (first_iocb) { 676 first_iocb = 0; 677 dsd_seg = (uint32_t *)&cmd_pkt->fcp_data_dseg_address; 678 *dsd_seg++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 679 *dsd_seg++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 680 cmd_pkt->fcp_data_dseg_len = cpu_to_le32(dsd_list_len); 681 } else { 682 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 683 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 684 *cur_dsd++ = cpu_to_le32(dsd_list_len); 685 } 686 cur_dsd = (uint32_t *)next_dsd; 687 while (avail_dsds) { 688 dma_addr_t sle_dma; 689 690 sle_dma = sg_dma_address(cur_seg); 691 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 692 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 693 *cur_dsd++ = cpu_to_le32(sg_dma_len(cur_seg)); 694 cur_seg = sg_next(cur_seg); 695 avail_dsds--; 696 } 697 } 698 699 /* Null termination */ 700 *cur_dsd++ = 0; 701 *cur_dsd++ = 0; 702 *cur_dsd++ = 0; 703 cmd_pkt->control_flags |= CF_DATA_SEG_DESCR_ENABLE; 704 return 0; 705 } 706 707 /* 708 * qla24xx_calc_dsd_lists() - Determine number of DSD list required 709 * for Command Type 6. 710 * 711 * @dsds: number of data segment decriptors needed 712 * 713 * Returns the number of dsd list needed to store @dsds. 714 */ 715 inline uint16_t 716 qla24xx_calc_dsd_lists(uint16_t dsds) 717 { 718 uint16_t dsd_lists = 0; 719 720 dsd_lists = (dsds/QLA_DSDS_PER_IOCB); 721 if (dsds % QLA_DSDS_PER_IOCB) 722 dsd_lists++; 723 return dsd_lists; 724 } 725 726 727 /** 728 * qla24xx_build_scsi_iocbs() - Build IOCB command utilizing Command Type 7 729 * IOCB types. 730 * 731 * @sp: SRB command to process 732 * @cmd_pkt: Command type 3 IOCB 733 * @tot_dsds: Total number of segments to transfer 734 */ 735 inline void 736 qla24xx_build_scsi_iocbs(srb_t *sp, struct cmd_type_7 *cmd_pkt, 737 uint16_t tot_dsds) 738 { 739 uint16_t avail_dsds; 740 uint32_t *cur_dsd; 741 scsi_qla_host_t *vha; 742 struct scsi_cmnd *cmd; 743 struct scatterlist *sg; 744 int i; 745 struct req_que *req; 746 747 cmd = GET_CMD_SP(sp); 748 749 /* Update entry type to indicate Command Type 3 IOCB */ 750 *((uint32_t *)(&cmd_pkt->entry_type)) = 751 __constant_cpu_to_le32(COMMAND_TYPE_7); 752 753 /* No data transfer */ 754 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 755 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 756 return; 757 } 758 759 vha = sp->fcport->vha; 760 req = vha->req; 761 762 /* Set transfer direction */ 763 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 764 cmd_pkt->task_mgmt_flags = 765 __constant_cpu_to_le16(TMF_WRITE_DATA); 766 vha->qla_stats.output_bytes += scsi_bufflen(cmd); 767 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 768 cmd_pkt->task_mgmt_flags = 769 __constant_cpu_to_le16(TMF_READ_DATA); 770 vha->qla_stats.input_bytes += scsi_bufflen(cmd); 771 } 772 773 /* One DSD is available in the Command Type 3 IOCB */ 774 avail_dsds = 1; 775 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 776 777 /* Load data segments */ 778 779 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 780 dma_addr_t sle_dma; 781 cont_a64_entry_t *cont_pkt; 782 783 /* Allocate additional continuation packets? */ 784 if (avail_dsds == 0) { 785 /* 786 * Five DSDs are available in the Continuation 787 * Type 1 IOCB. 788 */ 789 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req); 790 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address; 791 avail_dsds = 5; 792 } 793 794 sle_dma = sg_dma_address(sg); 795 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 796 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 797 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 798 avail_dsds--; 799 } 800 } 801 802 struct fw_dif_context { 803 uint32_t ref_tag; 804 uint16_t app_tag; 805 uint8_t ref_tag_mask[4]; /* Validation/Replacement Mask*/ 806 uint8_t app_tag_mask[2]; /* Validation/Replacement Mask*/ 807 }; 808 809 /* 810 * qla24xx_set_t10dif_tags_from_cmd - Extract Ref and App tags from SCSI command 811 * 812 */ 813 static inline void 814 qla24xx_set_t10dif_tags(srb_t *sp, struct fw_dif_context *pkt, 815 unsigned int protcnt) 816 { 817 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 818 819 switch (scsi_get_prot_type(cmd)) { 820 case SCSI_PROT_DIF_TYPE0: 821 /* 822 * No check for ql2xenablehba_err_chk, as it would be an 823 * I/O error if hba tag generation is not done. 824 */ 825 pkt->ref_tag = cpu_to_le32((uint32_t) 826 (0xffffffff & scsi_get_lba(cmd))); 827 828 if (!qla2x00_hba_err_chk_enabled(sp)) 829 break; 830 831 pkt->ref_tag_mask[0] = 0xff; 832 pkt->ref_tag_mask[1] = 0xff; 833 pkt->ref_tag_mask[2] = 0xff; 834 pkt->ref_tag_mask[3] = 0xff; 835 break; 836 837 /* 838 * For TYPE 2 protection: 16 bit GUARD + 32 bit REF tag has to 839 * match LBA in CDB + N 840 */ 841 case SCSI_PROT_DIF_TYPE2: 842 pkt->app_tag = __constant_cpu_to_le16(0); 843 pkt->app_tag_mask[0] = 0x0; 844 pkt->app_tag_mask[1] = 0x0; 845 846 pkt->ref_tag = cpu_to_le32((uint32_t) 847 (0xffffffff & scsi_get_lba(cmd))); 848 849 if (!qla2x00_hba_err_chk_enabled(sp)) 850 break; 851 852 /* enable ALL bytes of the ref tag */ 853 pkt->ref_tag_mask[0] = 0xff; 854 pkt->ref_tag_mask[1] = 0xff; 855 pkt->ref_tag_mask[2] = 0xff; 856 pkt->ref_tag_mask[3] = 0xff; 857 break; 858 859 /* For Type 3 protection: 16 bit GUARD only */ 860 case SCSI_PROT_DIF_TYPE3: 861 pkt->ref_tag_mask[0] = pkt->ref_tag_mask[1] = 862 pkt->ref_tag_mask[2] = pkt->ref_tag_mask[3] = 863 0x00; 864 break; 865 866 /* 867 * For TYpe 1 protection: 16 bit GUARD tag, 32 bit REF tag, and 868 * 16 bit app tag. 869 */ 870 case SCSI_PROT_DIF_TYPE1: 871 pkt->ref_tag = cpu_to_le32((uint32_t) 872 (0xffffffff & scsi_get_lba(cmd))); 873 pkt->app_tag = __constant_cpu_to_le16(0); 874 pkt->app_tag_mask[0] = 0x0; 875 pkt->app_tag_mask[1] = 0x0; 876 877 if (!qla2x00_hba_err_chk_enabled(sp)) 878 break; 879 880 /* enable ALL bytes of the ref tag */ 881 pkt->ref_tag_mask[0] = 0xff; 882 pkt->ref_tag_mask[1] = 0xff; 883 pkt->ref_tag_mask[2] = 0xff; 884 pkt->ref_tag_mask[3] = 0xff; 885 break; 886 } 887 } 888 889 struct qla2_sgx { 890 dma_addr_t dma_addr; /* OUT */ 891 uint32_t dma_len; /* OUT */ 892 893 uint32_t tot_bytes; /* IN */ 894 struct scatterlist *cur_sg; /* IN */ 895 896 /* for book keeping, bzero on initial invocation */ 897 uint32_t bytes_consumed; 898 uint32_t num_bytes; 899 uint32_t tot_partial; 900 901 /* for debugging */ 902 uint32_t num_sg; 903 srb_t *sp; 904 }; 905 906 static int 907 qla24xx_get_one_block_sg(uint32_t blk_sz, struct qla2_sgx *sgx, 908 uint32_t *partial) 909 { 910 struct scatterlist *sg; 911 uint32_t cumulative_partial, sg_len; 912 dma_addr_t sg_dma_addr; 913 914 if (sgx->num_bytes == sgx->tot_bytes) 915 return 0; 916 917 sg = sgx->cur_sg; 918 cumulative_partial = sgx->tot_partial; 919 920 sg_dma_addr = sg_dma_address(sg); 921 sg_len = sg_dma_len(sg); 922 923 sgx->dma_addr = sg_dma_addr + sgx->bytes_consumed; 924 925 if ((cumulative_partial + (sg_len - sgx->bytes_consumed)) >= blk_sz) { 926 sgx->dma_len = (blk_sz - cumulative_partial); 927 sgx->tot_partial = 0; 928 sgx->num_bytes += blk_sz; 929 *partial = 0; 930 } else { 931 sgx->dma_len = sg_len - sgx->bytes_consumed; 932 sgx->tot_partial += sgx->dma_len; 933 *partial = 1; 934 } 935 936 sgx->bytes_consumed += sgx->dma_len; 937 938 if (sg_len == sgx->bytes_consumed) { 939 sg = sg_next(sg); 940 sgx->num_sg++; 941 sgx->cur_sg = sg; 942 sgx->bytes_consumed = 0; 943 } 944 945 return 1; 946 } 947 948 static int 949 qla24xx_walk_and_build_sglist_no_difb(struct qla_hw_data *ha, srb_t *sp, 950 uint32_t *dsd, uint16_t tot_dsds) 951 { 952 void *next_dsd; 953 uint8_t avail_dsds = 0; 954 uint32_t dsd_list_len; 955 struct dsd_dma *dsd_ptr; 956 struct scatterlist *sg_prot; 957 uint32_t *cur_dsd = dsd; 958 uint16_t used_dsds = tot_dsds; 959 960 uint32_t prot_int; 961 uint32_t partial; 962 struct qla2_sgx sgx; 963 dma_addr_t sle_dma; 964 uint32_t sle_dma_len, tot_prot_dma_len = 0; 965 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 966 967 prot_int = cmd->device->sector_size; 968 969 memset(&sgx, 0, sizeof(struct qla2_sgx)); 970 sgx.tot_bytes = scsi_bufflen(cmd); 971 sgx.cur_sg = scsi_sglist(cmd); 972 sgx.sp = sp; 973 974 sg_prot = scsi_prot_sglist(cmd); 975 976 while (qla24xx_get_one_block_sg(prot_int, &sgx, &partial)) { 977 978 sle_dma = sgx.dma_addr; 979 sle_dma_len = sgx.dma_len; 980 alloc_and_fill: 981 /* Allocate additional continuation packets? */ 982 if (avail_dsds == 0) { 983 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ? 984 QLA_DSDS_PER_IOCB : used_dsds; 985 dsd_list_len = (avail_dsds + 1) * 12; 986 used_dsds -= avail_dsds; 987 988 /* allocate tracking DS */ 989 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 990 if (!dsd_ptr) 991 return 1; 992 993 /* allocate new list */ 994 dsd_ptr->dsd_addr = next_dsd = 995 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, 996 &dsd_ptr->dsd_list_dma); 997 998 if (!next_dsd) { 999 /* 1000 * Need to cleanup only this dsd_ptr, rest 1001 * will be done by sp_free_dma() 1002 */ 1003 kfree(dsd_ptr); 1004 return 1; 1005 } 1006 1007 list_add_tail(&dsd_ptr->list, 1008 &((struct crc_context *)sp->u.scmd.ctx)->dsd_list); 1009 1010 sp->flags |= SRB_CRC_CTX_DSD_VALID; 1011 1012 /* add new list to cmd iocb or last list */ 1013 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 1014 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 1015 *cur_dsd++ = dsd_list_len; 1016 cur_dsd = (uint32_t *)next_dsd; 1017 } 1018 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 1019 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 1020 *cur_dsd++ = cpu_to_le32(sle_dma_len); 1021 avail_dsds--; 1022 1023 if (partial == 0) { 1024 /* Got a full protection interval */ 1025 sle_dma = sg_dma_address(sg_prot) + tot_prot_dma_len; 1026 sle_dma_len = 8; 1027 1028 tot_prot_dma_len += sle_dma_len; 1029 if (tot_prot_dma_len == sg_dma_len(sg_prot)) { 1030 tot_prot_dma_len = 0; 1031 sg_prot = sg_next(sg_prot); 1032 } 1033 1034 partial = 1; /* So as to not re-enter this block */ 1035 goto alloc_and_fill; 1036 } 1037 } 1038 /* Null termination */ 1039 *cur_dsd++ = 0; 1040 *cur_dsd++ = 0; 1041 *cur_dsd++ = 0; 1042 return 0; 1043 } 1044 1045 static int 1046 qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp, uint32_t *dsd, 1047 uint16_t tot_dsds) 1048 { 1049 void *next_dsd; 1050 uint8_t avail_dsds = 0; 1051 uint32_t dsd_list_len; 1052 struct dsd_dma *dsd_ptr; 1053 struct scatterlist *sg; 1054 uint32_t *cur_dsd = dsd; 1055 int i; 1056 uint16_t used_dsds = tot_dsds; 1057 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 1058 1059 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 1060 dma_addr_t sle_dma; 1061 1062 /* Allocate additional continuation packets? */ 1063 if (avail_dsds == 0) { 1064 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ? 1065 QLA_DSDS_PER_IOCB : used_dsds; 1066 dsd_list_len = (avail_dsds + 1) * 12; 1067 used_dsds -= avail_dsds; 1068 1069 /* allocate tracking DS */ 1070 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 1071 if (!dsd_ptr) 1072 return 1; 1073 1074 /* allocate new list */ 1075 dsd_ptr->dsd_addr = next_dsd = 1076 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, 1077 &dsd_ptr->dsd_list_dma); 1078 1079 if (!next_dsd) { 1080 /* 1081 * Need to cleanup only this dsd_ptr, rest 1082 * will be done by sp_free_dma() 1083 */ 1084 kfree(dsd_ptr); 1085 return 1; 1086 } 1087 1088 list_add_tail(&dsd_ptr->list, 1089 &((struct crc_context *)sp->u.scmd.ctx)->dsd_list); 1090 1091 sp->flags |= SRB_CRC_CTX_DSD_VALID; 1092 1093 /* add new list to cmd iocb or last list */ 1094 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 1095 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 1096 *cur_dsd++ = dsd_list_len; 1097 cur_dsd = (uint32_t *)next_dsd; 1098 } 1099 sle_dma = sg_dma_address(sg); 1100 1101 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 1102 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 1103 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 1104 avail_dsds--; 1105 1106 } 1107 /* Null termination */ 1108 *cur_dsd++ = 0; 1109 *cur_dsd++ = 0; 1110 *cur_dsd++ = 0; 1111 return 0; 1112 } 1113 1114 static int 1115 qla24xx_walk_and_build_prot_sglist(struct qla_hw_data *ha, srb_t *sp, 1116 uint32_t *dsd, 1117 uint16_t tot_dsds) 1118 { 1119 void *next_dsd; 1120 uint8_t avail_dsds = 0; 1121 uint32_t dsd_list_len; 1122 struct dsd_dma *dsd_ptr; 1123 struct scatterlist *sg; 1124 int i; 1125 struct scsi_cmnd *cmd; 1126 uint32_t *cur_dsd = dsd; 1127 uint16_t used_dsds = tot_dsds; 1128 1129 cmd = GET_CMD_SP(sp); 1130 scsi_for_each_prot_sg(cmd, sg, tot_dsds, i) { 1131 dma_addr_t sle_dma; 1132 1133 /* Allocate additional continuation packets? */ 1134 if (avail_dsds == 0) { 1135 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ? 1136 QLA_DSDS_PER_IOCB : used_dsds; 1137 dsd_list_len = (avail_dsds + 1) * 12; 1138 used_dsds -= avail_dsds; 1139 1140 /* allocate tracking DS */ 1141 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 1142 if (!dsd_ptr) 1143 return 1; 1144 1145 /* allocate new list */ 1146 dsd_ptr->dsd_addr = next_dsd = 1147 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, 1148 &dsd_ptr->dsd_list_dma); 1149 1150 if (!next_dsd) { 1151 /* 1152 * Need to cleanup only this dsd_ptr, rest 1153 * will be done by sp_free_dma() 1154 */ 1155 kfree(dsd_ptr); 1156 return 1; 1157 } 1158 1159 list_add_tail(&dsd_ptr->list, 1160 &((struct crc_context *)sp->u.scmd.ctx)->dsd_list); 1161 1162 sp->flags |= SRB_CRC_CTX_DSD_VALID; 1163 1164 /* add new list to cmd iocb or last list */ 1165 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 1166 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 1167 *cur_dsd++ = dsd_list_len; 1168 cur_dsd = (uint32_t *)next_dsd; 1169 } 1170 sle_dma = sg_dma_address(sg); 1171 1172 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 1173 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 1174 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 1175 1176 avail_dsds--; 1177 } 1178 /* Null termination */ 1179 *cur_dsd++ = 0; 1180 *cur_dsd++ = 0; 1181 *cur_dsd++ = 0; 1182 return 0; 1183 } 1184 1185 /** 1186 * qla24xx_build_scsi_crc_2_iocbs() - Build IOCB command utilizing Command 1187 * Type 6 IOCB types. 1188 * 1189 * @sp: SRB command to process 1190 * @cmd_pkt: Command type 3 IOCB 1191 * @tot_dsds: Total number of segments to transfer 1192 */ 1193 static inline int 1194 qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt, 1195 uint16_t tot_dsds, uint16_t tot_prot_dsds, uint16_t fw_prot_opts) 1196 { 1197 uint32_t *cur_dsd, *fcp_dl; 1198 scsi_qla_host_t *vha; 1199 struct scsi_cmnd *cmd; 1200 struct scatterlist *cur_seg; 1201 int sgc; 1202 uint32_t total_bytes = 0; 1203 uint32_t data_bytes; 1204 uint32_t dif_bytes; 1205 uint8_t bundling = 1; 1206 uint16_t blk_size; 1207 uint8_t *clr_ptr; 1208 struct crc_context *crc_ctx_pkt = NULL; 1209 struct qla_hw_data *ha; 1210 uint8_t additional_fcpcdb_len; 1211 uint16_t fcp_cmnd_len; 1212 struct fcp_cmnd *fcp_cmnd; 1213 dma_addr_t crc_ctx_dma; 1214 char tag[2]; 1215 1216 cmd = GET_CMD_SP(sp); 1217 1218 sgc = 0; 1219 /* Update entry type to indicate Command Type CRC_2 IOCB */ 1220 *((uint32_t *)(&cmd_pkt->entry_type)) = 1221 __constant_cpu_to_le32(COMMAND_TYPE_CRC_2); 1222 1223 vha = sp->fcport->vha; 1224 ha = vha->hw; 1225 1226 /* No data transfer */ 1227 data_bytes = scsi_bufflen(cmd); 1228 if (!data_bytes || cmd->sc_data_direction == DMA_NONE) { 1229 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 1230 return QLA_SUCCESS; 1231 } 1232 1233 cmd_pkt->vp_index = sp->fcport->vha->vp_idx; 1234 1235 /* Set transfer direction */ 1236 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 1237 cmd_pkt->control_flags = 1238 __constant_cpu_to_le16(CF_WRITE_DATA); 1239 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 1240 cmd_pkt->control_flags = 1241 __constant_cpu_to_le16(CF_READ_DATA); 1242 } 1243 1244 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 1245 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP) || 1246 (scsi_get_prot_op(cmd) == SCSI_PROT_READ_STRIP) || 1247 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_INSERT)) 1248 bundling = 0; 1249 1250 /* Allocate CRC context from global pool */ 1251 crc_ctx_pkt = sp->u.scmd.ctx = 1252 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, &crc_ctx_dma); 1253 1254 if (!crc_ctx_pkt) 1255 goto crc_queuing_error; 1256 1257 /* Zero out CTX area. */ 1258 clr_ptr = (uint8_t *)crc_ctx_pkt; 1259 memset(clr_ptr, 0, sizeof(*crc_ctx_pkt)); 1260 1261 crc_ctx_pkt->crc_ctx_dma = crc_ctx_dma; 1262 1263 sp->flags |= SRB_CRC_CTX_DMA_VALID; 1264 1265 /* Set handle */ 1266 crc_ctx_pkt->handle = cmd_pkt->handle; 1267 1268 INIT_LIST_HEAD(&crc_ctx_pkt->dsd_list); 1269 1270 qla24xx_set_t10dif_tags(sp, (struct fw_dif_context *) 1271 &crc_ctx_pkt->ref_tag, tot_prot_dsds); 1272 1273 cmd_pkt->crc_context_address[0] = cpu_to_le32(LSD(crc_ctx_dma)); 1274 cmd_pkt->crc_context_address[1] = cpu_to_le32(MSD(crc_ctx_dma)); 1275 cmd_pkt->crc_context_len = CRC_CONTEXT_LEN_FW; 1276 1277 /* Determine SCSI command length -- align to 4 byte boundary */ 1278 if (cmd->cmd_len > 16) { 1279 additional_fcpcdb_len = cmd->cmd_len - 16; 1280 if ((cmd->cmd_len % 4) != 0) { 1281 /* SCSI cmd > 16 bytes must be multiple of 4 */ 1282 goto crc_queuing_error; 1283 } 1284 fcp_cmnd_len = 12 + cmd->cmd_len + 4; 1285 } else { 1286 additional_fcpcdb_len = 0; 1287 fcp_cmnd_len = 12 + 16 + 4; 1288 } 1289 1290 fcp_cmnd = &crc_ctx_pkt->fcp_cmnd; 1291 1292 fcp_cmnd->additional_cdb_len = additional_fcpcdb_len; 1293 if (cmd->sc_data_direction == DMA_TO_DEVICE) 1294 fcp_cmnd->additional_cdb_len |= 1; 1295 else if (cmd->sc_data_direction == DMA_FROM_DEVICE) 1296 fcp_cmnd->additional_cdb_len |= 2; 1297 1298 int_to_scsilun(cmd->device->lun, &fcp_cmnd->lun); 1299 memcpy(fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len); 1300 cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(fcp_cmnd_len); 1301 cmd_pkt->fcp_cmnd_dseg_address[0] = cpu_to_le32( 1302 LSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF)); 1303 cmd_pkt->fcp_cmnd_dseg_address[1] = cpu_to_le32( 1304 MSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF)); 1305 fcp_cmnd->task_management = 0; 1306 1307 /* 1308 * Update tagged queuing modifier if using command tag queuing 1309 */ 1310 if (scsi_populate_tag_msg(cmd, tag)) { 1311 switch (tag[0]) { 1312 case HEAD_OF_QUEUE_TAG: 1313 fcp_cmnd->task_attribute = TSK_HEAD_OF_QUEUE; 1314 break; 1315 case ORDERED_QUEUE_TAG: 1316 fcp_cmnd->task_attribute = TSK_ORDERED; 1317 break; 1318 default: 1319 fcp_cmnd->task_attribute = 0; 1320 break; 1321 } 1322 } else { 1323 fcp_cmnd->task_attribute = 0; 1324 } 1325 1326 cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */ 1327 1328 /* Compute dif len and adjust data len to incude protection */ 1329 dif_bytes = 0; 1330 blk_size = cmd->device->sector_size; 1331 dif_bytes = (data_bytes / blk_size) * 8; 1332 1333 switch (scsi_get_prot_op(GET_CMD_SP(sp))) { 1334 case SCSI_PROT_READ_INSERT: 1335 case SCSI_PROT_WRITE_STRIP: 1336 total_bytes = data_bytes; 1337 data_bytes += dif_bytes; 1338 break; 1339 1340 case SCSI_PROT_READ_STRIP: 1341 case SCSI_PROT_WRITE_INSERT: 1342 case SCSI_PROT_READ_PASS: 1343 case SCSI_PROT_WRITE_PASS: 1344 total_bytes = data_bytes + dif_bytes; 1345 break; 1346 default: 1347 BUG(); 1348 } 1349 1350 if (!qla2x00_hba_err_chk_enabled(sp)) 1351 fw_prot_opts |= 0x10; /* Disable Guard tag checking */ 1352 /* HBA error checking enabled */ 1353 else if (IS_PI_UNINIT_CAPABLE(ha)) { 1354 if ((scsi_get_prot_type(GET_CMD_SP(sp)) == SCSI_PROT_DIF_TYPE1) 1355 || (scsi_get_prot_type(GET_CMD_SP(sp)) == 1356 SCSI_PROT_DIF_TYPE2)) 1357 fw_prot_opts |= BIT_10; 1358 else if (scsi_get_prot_type(GET_CMD_SP(sp)) == 1359 SCSI_PROT_DIF_TYPE3) 1360 fw_prot_opts |= BIT_11; 1361 } 1362 1363 if (!bundling) { 1364 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.nobundling.data_address; 1365 } else { 1366 /* 1367 * Configure Bundling if we need to fetch interlaving 1368 * protection PCI accesses 1369 */ 1370 fw_prot_opts |= PO_ENABLE_DIF_BUNDLING; 1371 crc_ctx_pkt->u.bundling.dif_byte_count = cpu_to_le32(dif_bytes); 1372 crc_ctx_pkt->u.bundling.dseg_count = cpu_to_le16(tot_dsds - 1373 tot_prot_dsds); 1374 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.bundling.data_address; 1375 } 1376 1377 /* Finish the common fields of CRC pkt */ 1378 crc_ctx_pkt->blk_size = cpu_to_le16(blk_size); 1379 crc_ctx_pkt->prot_opts = cpu_to_le16(fw_prot_opts); 1380 crc_ctx_pkt->byte_count = cpu_to_le32(data_bytes); 1381 crc_ctx_pkt->guard_seed = __constant_cpu_to_le16(0); 1382 /* Fibre channel byte count */ 1383 cmd_pkt->byte_count = cpu_to_le32(total_bytes); 1384 fcp_dl = (uint32_t *)(crc_ctx_pkt->fcp_cmnd.cdb + 16 + 1385 additional_fcpcdb_len); 1386 *fcp_dl = htonl(total_bytes); 1387 1388 if (!data_bytes || cmd->sc_data_direction == DMA_NONE) { 1389 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 1390 return QLA_SUCCESS; 1391 } 1392 /* Walks data segments */ 1393 1394 cmd_pkt->control_flags |= 1395 __constant_cpu_to_le16(CF_DATA_SEG_DESCR_ENABLE); 1396 1397 if (!bundling && tot_prot_dsds) { 1398 if (qla24xx_walk_and_build_sglist_no_difb(ha, sp, 1399 cur_dsd, tot_dsds)) 1400 goto crc_queuing_error; 1401 } else if (qla24xx_walk_and_build_sglist(ha, sp, cur_dsd, 1402 (tot_dsds - tot_prot_dsds))) 1403 goto crc_queuing_error; 1404 1405 if (bundling && tot_prot_dsds) { 1406 /* Walks dif segments */ 1407 cur_seg = scsi_prot_sglist(cmd); 1408 cmd_pkt->control_flags |= 1409 __constant_cpu_to_le16(CF_DIF_SEG_DESCR_ENABLE); 1410 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.bundling.dif_address; 1411 if (qla24xx_walk_and_build_prot_sglist(ha, sp, cur_dsd, 1412 tot_prot_dsds)) 1413 goto crc_queuing_error; 1414 } 1415 return QLA_SUCCESS; 1416 1417 crc_queuing_error: 1418 /* Cleanup will be performed by the caller */ 1419 1420 return QLA_FUNCTION_FAILED; 1421 } 1422 1423 /** 1424 * qla24xx_start_scsi() - Send a SCSI command to the ISP 1425 * @sp: command to send to the ISP 1426 * 1427 * Returns non-zero if a failure occurred, else zero. 1428 */ 1429 int 1430 qla24xx_start_scsi(srb_t *sp) 1431 { 1432 int ret, nseg; 1433 unsigned long flags; 1434 uint32_t *clr_ptr; 1435 uint32_t index; 1436 uint32_t handle; 1437 struct cmd_type_7 *cmd_pkt; 1438 uint16_t cnt; 1439 uint16_t req_cnt; 1440 uint16_t tot_dsds; 1441 struct req_que *req = NULL; 1442 struct rsp_que *rsp = NULL; 1443 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 1444 struct scsi_qla_host *vha = sp->fcport->vha; 1445 struct qla_hw_data *ha = vha->hw; 1446 char tag[2]; 1447 1448 /* Setup device pointers. */ 1449 ret = 0; 1450 1451 qla25xx_set_que(sp, &rsp); 1452 req = vha->req; 1453 1454 /* So we know we haven't pci_map'ed anything yet */ 1455 tot_dsds = 0; 1456 1457 /* Send marker if required */ 1458 if (vha->marker_needed != 0) { 1459 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 1460 QLA_SUCCESS) 1461 return QLA_FUNCTION_FAILED; 1462 vha->marker_needed = 0; 1463 } 1464 1465 /* Acquire ring specific lock */ 1466 spin_lock_irqsave(&ha->hardware_lock, flags); 1467 1468 /* Check for room in outstanding command list. */ 1469 handle = req->current_outstanding_cmd; 1470 for (index = 1; index < req->num_outstanding_cmds; index++) { 1471 handle++; 1472 if (handle == req->num_outstanding_cmds) 1473 handle = 1; 1474 if (!req->outstanding_cmds[handle]) 1475 break; 1476 } 1477 if (index == req->num_outstanding_cmds) 1478 goto queuing_error; 1479 1480 /* Map the sg table so we have an accurate count of sg entries needed */ 1481 if (scsi_sg_count(cmd)) { 1482 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 1483 scsi_sg_count(cmd), cmd->sc_data_direction); 1484 if (unlikely(!nseg)) 1485 goto queuing_error; 1486 } else 1487 nseg = 0; 1488 1489 tot_dsds = nseg; 1490 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds); 1491 if (req->cnt < (req_cnt + 2)) { 1492 cnt = RD_REG_DWORD_RELAXED(req->req_q_out); 1493 1494 if (req->ring_index < cnt) 1495 req->cnt = cnt - req->ring_index; 1496 else 1497 req->cnt = req->length - 1498 (req->ring_index - cnt); 1499 if (req->cnt < (req_cnt + 2)) 1500 goto queuing_error; 1501 } 1502 1503 /* Build command packet. */ 1504 req->current_outstanding_cmd = handle; 1505 req->outstanding_cmds[handle] = sp; 1506 sp->handle = handle; 1507 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 1508 req->cnt -= req_cnt; 1509 1510 cmd_pkt = (struct cmd_type_7 *)req->ring_ptr; 1511 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 1512 1513 /* Zero out remaining portion of packet. */ 1514 /* tagged queuing modifier -- default is TSK_SIMPLE (0). */ 1515 clr_ptr = (uint32_t *)cmd_pkt + 2; 1516 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 1517 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 1518 1519 /* Set NPORT-ID and LUN number*/ 1520 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1521 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 1522 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 1523 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 1524 cmd_pkt->vp_index = sp->fcport->vha->vp_idx; 1525 1526 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 1527 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 1528 1529 /* Update tagged queuing modifier -- default is TSK_SIMPLE (0). */ 1530 if (scsi_populate_tag_msg(cmd, tag)) { 1531 switch (tag[0]) { 1532 case HEAD_OF_QUEUE_TAG: 1533 cmd_pkt->task = TSK_HEAD_OF_QUEUE; 1534 break; 1535 case ORDERED_QUEUE_TAG: 1536 cmd_pkt->task = TSK_ORDERED; 1537 break; 1538 } 1539 } 1540 1541 /* Load SCSI command packet. */ 1542 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len); 1543 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb)); 1544 1545 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 1546 1547 /* Build IOCB segments */ 1548 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds); 1549 1550 /* Set total data segment count. */ 1551 cmd_pkt->entry_count = (uint8_t)req_cnt; 1552 /* Specify response queue number where completion should happen */ 1553 cmd_pkt->entry_status = (uint8_t) rsp->id; 1554 wmb(); 1555 /* Adjust ring index. */ 1556 req->ring_index++; 1557 if (req->ring_index == req->length) { 1558 req->ring_index = 0; 1559 req->ring_ptr = req->ring; 1560 } else 1561 req->ring_ptr++; 1562 1563 sp->flags |= SRB_DMA_VALID; 1564 1565 /* Set chip new ring index. */ 1566 WRT_REG_DWORD(req->req_q_in, req->ring_index); 1567 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr); 1568 1569 /* Manage unprocessed RIO/ZIO commands in response queue. */ 1570 if (vha->flags.process_response_queue && 1571 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 1572 qla24xx_process_response_queue(vha, rsp); 1573 1574 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1575 return QLA_SUCCESS; 1576 1577 queuing_error: 1578 if (tot_dsds) 1579 scsi_dma_unmap(cmd); 1580 1581 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1582 1583 return QLA_FUNCTION_FAILED; 1584 } 1585 1586 1587 /** 1588 * qla24xx_dif_start_scsi() - Send a SCSI command to the ISP 1589 * @sp: command to send to the ISP 1590 * 1591 * Returns non-zero if a failure occurred, else zero. 1592 */ 1593 int 1594 qla24xx_dif_start_scsi(srb_t *sp) 1595 { 1596 int nseg; 1597 unsigned long flags; 1598 uint32_t *clr_ptr; 1599 uint32_t index; 1600 uint32_t handle; 1601 uint16_t cnt; 1602 uint16_t req_cnt = 0; 1603 uint16_t tot_dsds; 1604 uint16_t tot_prot_dsds; 1605 uint16_t fw_prot_opts = 0; 1606 struct req_que *req = NULL; 1607 struct rsp_que *rsp = NULL; 1608 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 1609 struct scsi_qla_host *vha = sp->fcport->vha; 1610 struct qla_hw_data *ha = vha->hw; 1611 struct cmd_type_crc_2 *cmd_pkt; 1612 uint32_t status = 0; 1613 1614 #define QDSS_GOT_Q_SPACE BIT_0 1615 1616 /* Only process protection or >16 cdb in this routine */ 1617 if (scsi_get_prot_op(cmd) == SCSI_PROT_NORMAL) { 1618 if (cmd->cmd_len <= 16) 1619 return qla24xx_start_scsi(sp); 1620 } 1621 1622 /* Setup device pointers. */ 1623 1624 qla25xx_set_que(sp, &rsp); 1625 req = vha->req; 1626 1627 /* So we know we haven't pci_map'ed anything yet */ 1628 tot_dsds = 0; 1629 1630 /* Send marker if required */ 1631 if (vha->marker_needed != 0) { 1632 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 1633 QLA_SUCCESS) 1634 return QLA_FUNCTION_FAILED; 1635 vha->marker_needed = 0; 1636 } 1637 1638 /* Acquire ring specific lock */ 1639 spin_lock_irqsave(&ha->hardware_lock, flags); 1640 1641 /* Check for room in outstanding command list. */ 1642 handle = req->current_outstanding_cmd; 1643 for (index = 1; index < req->num_outstanding_cmds; index++) { 1644 handle++; 1645 if (handle == req->num_outstanding_cmds) 1646 handle = 1; 1647 if (!req->outstanding_cmds[handle]) 1648 break; 1649 } 1650 1651 if (index == req->num_outstanding_cmds) 1652 goto queuing_error; 1653 1654 /* Compute number of required data segments */ 1655 /* Map the sg table so we have an accurate count of sg entries needed */ 1656 if (scsi_sg_count(cmd)) { 1657 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 1658 scsi_sg_count(cmd), cmd->sc_data_direction); 1659 if (unlikely(!nseg)) 1660 goto queuing_error; 1661 else 1662 sp->flags |= SRB_DMA_VALID; 1663 1664 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 1665 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) { 1666 struct qla2_sgx sgx; 1667 uint32_t partial; 1668 1669 memset(&sgx, 0, sizeof(struct qla2_sgx)); 1670 sgx.tot_bytes = scsi_bufflen(cmd); 1671 sgx.cur_sg = scsi_sglist(cmd); 1672 sgx.sp = sp; 1673 1674 nseg = 0; 1675 while (qla24xx_get_one_block_sg( 1676 cmd->device->sector_size, &sgx, &partial)) 1677 nseg++; 1678 } 1679 } else 1680 nseg = 0; 1681 1682 /* number of required data segments */ 1683 tot_dsds = nseg; 1684 1685 /* Compute number of required protection segments */ 1686 if (qla24xx_configure_prot_mode(sp, &fw_prot_opts)) { 1687 nseg = dma_map_sg(&ha->pdev->dev, scsi_prot_sglist(cmd), 1688 scsi_prot_sg_count(cmd), cmd->sc_data_direction); 1689 if (unlikely(!nseg)) 1690 goto queuing_error; 1691 else 1692 sp->flags |= SRB_CRC_PROT_DMA_VALID; 1693 1694 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 1695 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) { 1696 nseg = scsi_bufflen(cmd) / cmd->device->sector_size; 1697 } 1698 } else { 1699 nseg = 0; 1700 } 1701 1702 req_cnt = 1; 1703 /* Total Data and protection sg segment(s) */ 1704 tot_prot_dsds = nseg; 1705 tot_dsds += nseg; 1706 if (req->cnt < (req_cnt + 2)) { 1707 cnt = RD_REG_DWORD_RELAXED(req->req_q_out); 1708 1709 if (req->ring_index < cnt) 1710 req->cnt = cnt - req->ring_index; 1711 else 1712 req->cnt = req->length - 1713 (req->ring_index - cnt); 1714 if (req->cnt < (req_cnt + 2)) 1715 goto queuing_error; 1716 } 1717 1718 status |= QDSS_GOT_Q_SPACE; 1719 1720 /* Build header part of command packet (excluding the OPCODE). */ 1721 req->current_outstanding_cmd = handle; 1722 req->outstanding_cmds[handle] = sp; 1723 sp->handle = handle; 1724 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 1725 req->cnt -= req_cnt; 1726 1727 /* Fill-in common area */ 1728 cmd_pkt = (struct cmd_type_crc_2 *)req->ring_ptr; 1729 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 1730 1731 clr_ptr = (uint32_t *)cmd_pkt + 2; 1732 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 1733 1734 /* Set NPORT-ID and LUN number*/ 1735 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1736 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 1737 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 1738 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 1739 1740 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 1741 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 1742 1743 /* Total Data and protection segment(s) */ 1744 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 1745 1746 /* Build IOCB segments and adjust for data protection segments */ 1747 if (qla24xx_build_scsi_crc_2_iocbs(sp, (struct cmd_type_crc_2 *) 1748 req->ring_ptr, tot_dsds, tot_prot_dsds, fw_prot_opts) != 1749 QLA_SUCCESS) 1750 goto queuing_error; 1751 1752 cmd_pkt->entry_count = (uint8_t)req_cnt; 1753 /* Specify response queue number where completion should happen */ 1754 cmd_pkt->entry_status = (uint8_t) rsp->id; 1755 cmd_pkt->timeout = __constant_cpu_to_le16(0); 1756 wmb(); 1757 1758 /* Adjust ring index. */ 1759 req->ring_index++; 1760 if (req->ring_index == req->length) { 1761 req->ring_index = 0; 1762 req->ring_ptr = req->ring; 1763 } else 1764 req->ring_ptr++; 1765 1766 /* Set chip new ring index. */ 1767 WRT_REG_DWORD(req->req_q_in, req->ring_index); 1768 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr); 1769 1770 /* Manage unprocessed RIO/ZIO commands in response queue. */ 1771 if (vha->flags.process_response_queue && 1772 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 1773 qla24xx_process_response_queue(vha, rsp); 1774 1775 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1776 1777 return QLA_SUCCESS; 1778 1779 queuing_error: 1780 if (status & QDSS_GOT_Q_SPACE) { 1781 req->outstanding_cmds[handle] = NULL; 1782 req->cnt += req_cnt; 1783 } 1784 /* Cleanup will be performed by the caller (queuecommand) */ 1785 1786 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1787 return QLA_FUNCTION_FAILED; 1788 } 1789 1790 1791 static void qla25xx_set_que(srb_t *sp, struct rsp_que **rsp) 1792 { 1793 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 1794 struct qla_hw_data *ha = sp->fcport->vha->hw; 1795 int affinity = cmd->request->cpu; 1796 1797 if (ha->flags.cpu_affinity_enabled && affinity >= 0 && 1798 affinity < ha->max_rsp_queues - 1) 1799 *rsp = ha->rsp_q_map[affinity + 1]; 1800 else 1801 *rsp = ha->rsp_q_map[0]; 1802 } 1803 1804 /* Generic Control-SRB manipulation functions. */ 1805 void * 1806 qla2x00_alloc_iocbs(scsi_qla_host_t *vha, srb_t *sp) 1807 { 1808 struct qla_hw_data *ha = vha->hw; 1809 struct req_que *req = ha->req_q_map[0]; 1810 device_reg_t __iomem *reg = ISP_QUE_REG(ha, req->id); 1811 uint32_t index, handle; 1812 request_t *pkt; 1813 uint16_t cnt, req_cnt; 1814 1815 pkt = NULL; 1816 req_cnt = 1; 1817 handle = 0; 1818 1819 if (!sp) 1820 goto skip_cmd_array; 1821 1822 /* Check for room in outstanding command list. */ 1823 handle = req->current_outstanding_cmd; 1824 for (index = 1; req->num_outstanding_cmds; index++) { 1825 handle++; 1826 if (handle == req->num_outstanding_cmds) 1827 handle = 1; 1828 if (!req->outstanding_cmds[handle]) 1829 break; 1830 } 1831 if (index == req->num_outstanding_cmds) { 1832 ql_log(ql_log_warn, vha, 0x700b, 1833 "No room on outstanding cmd array.\n"); 1834 goto queuing_error; 1835 } 1836 1837 /* Prep command array. */ 1838 req->current_outstanding_cmd = handle; 1839 req->outstanding_cmds[handle] = sp; 1840 sp->handle = handle; 1841 1842 /* Adjust entry-counts as needed. */ 1843 if (sp->type != SRB_SCSI_CMD) 1844 req_cnt = sp->iocbs; 1845 1846 skip_cmd_array: 1847 /* Check for room on request queue. */ 1848 if (req->cnt < req_cnt) { 1849 if (ha->mqenable || IS_QLA83XX(ha)) 1850 cnt = RD_REG_DWORD(®->isp25mq.req_q_out); 1851 else if (IS_QLA82XX(ha)) 1852 cnt = RD_REG_DWORD(®->isp82.req_q_out); 1853 else if (IS_FWI2_CAPABLE(ha)) 1854 cnt = RD_REG_DWORD(®->isp24.req_q_out); 1855 else 1856 cnt = qla2x00_debounce_register( 1857 ISP_REQ_Q_OUT(ha, ®->isp)); 1858 1859 if (req->ring_index < cnt) 1860 req->cnt = cnt - req->ring_index; 1861 else 1862 req->cnt = req->length - 1863 (req->ring_index - cnt); 1864 } 1865 if (req->cnt < req_cnt) 1866 goto queuing_error; 1867 1868 /* Prep packet */ 1869 req->cnt -= req_cnt; 1870 pkt = req->ring_ptr; 1871 memset(pkt, 0, REQUEST_ENTRY_SIZE); 1872 pkt->entry_count = req_cnt; 1873 pkt->handle = handle; 1874 1875 queuing_error: 1876 return pkt; 1877 } 1878 1879 static void 1880 qla24xx_login_iocb(srb_t *sp, struct logio_entry_24xx *logio) 1881 { 1882 struct srb_iocb *lio = &sp->u.iocb_cmd; 1883 1884 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1885 logio->control_flags = cpu_to_le16(LCF_COMMAND_PLOGI); 1886 if (lio->u.logio.flags & SRB_LOGIN_COND_PLOGI) 1887 logio->control_flags |= cpu_to_le16(LCF_COND_PLOGI); 1888 if (lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI) 1889 logio->control_flags |= cpu_to_le16(LCF_SKIP_PRLI); 1890 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1891 logio->port_id[0] = sp->fcport->d_id.b.al_pa; 1892 logio->port_id[1] = sp->fcport->d_id.b.area; 1893 logio->port_id[2] = sp->fcport->d_id.b.domain; 1894 logio->vp_index = sp->fcport->vha->vp_idx; 1895 } 1896 1897 static void 1898 qla2x00_login_iocb(srb_t *sp, struct mbx_entry *mbx) 1899 { 1900 struct qla_hw_data *ha = sp->fcport->vha->hw; 1901 struct srb_iocb *lio = &sp->u.iocb_cmd; 1902 uint16_t opts; 1903 1904 mbx->entry_type = MBX_IOCB_TYPE; 1905 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id); 1906 mbx->mb0 = cpu_to_le16(MBC_LOGIN_FABRIC_PORT); 1907 opts = lio->u.logio.flags & SRB_LOGIN_COND_PLOGI ? BIT_0 : 0; 1908 opts |= lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI ? BIT_1 : 0; 1909 if (HAS_EXTENDED_IDS(ha)) { 1910 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id); 1911 mbx->mb10 = cpu_to_le16(opts); 1912 } else { 1913 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | opts); 1914 } 1915 mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain); 1916 mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 | 1917 sp->fcport->d_id.b.al_pa); 1918 mbx->mb9 = cpu_to_le16(sp->fcport->vha->vp_idx); 1919 } 1920 1921 static void 1922 qla24xx_logout_iocb(srb_t *sp, struct logio_entry_24xx *logio) 1923 { 1924 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1925 logio->control_flags = 1926 cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO); 1927 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1928 logio->port_id[0] = sp->fcport->d_id.b.al_pa; 1929 logio->port_id[1] = sp->fcport->d_id.b.area; 1930 logio->port_id[2] = sp->fcport->d_id.b.domain; 1931 logio->vp_index = sp->fcport->vha->vp_idx; 1932 } 1933 1934 static void 1935 qla2x00_logout_iocb(srb_t *sp, struct mbx_entry *mbx) 1936 { 1937 struct qla_hw_data *ha = sp->fcport->vha->hw; 1938 1939 mbx->entry_type = MBX_IOCB_TYPE; 1940 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id); 1941 mbx->mb0 = cpu_to_le16(MBC_LOGOUT_FABRIC_PORT); 1942 mbx->mb1 = HAS_EXTENDED_IDS(ha) ? 1943 cpu_to_le16(sp->fcport->loop_id): 1944 cpu_to_le16(sp->fcport->loop_id << 8); 1945 mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain); 1946 mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 | 1947 sp->fcport->d_id.b.al_pa); 1948 mbx->mb9 = cpu_to_le16(sp->fcport->vha->vp_idx); 1949 /* Implicit: mbx->mbx10 = 0. */ 1950 } 1951 1952 static void 1953 qla24xx_adisc_iocb(srb_t *sp, struct logio_entry_24xx *logio) 1954 { 1955 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 1956 logio->control_flags = cpu_to_le16(LCF_COMMAND_ADISC); 1957 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1958 logio->vp_index = sp->fcport->vha->vp_idx; 1959 } 1960 1961 static void 1962 qla2x00_adisc_iocb(srb_t *sp, struct mbx_entry *mbx) 1963 { 1964 struct qla_hw_data *ha = sp->fcport->vha->hw; 1965 1966 mbx->entry_type = MBX_IOCB_TYPE; 1967 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id); 1968 mbx->mb0 = cpu_to_le16(MBC_GET_PORT_DATABASE); 1969 if (HAS_EXTENDED_IDS(ha)) { 1970 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id); 1971 mbx->mb10 = cpu_to_le16(BIT_0); 1972 } else { 1973 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | BIT_0); 1974 } 1975 mbx->mb2 = cpu_to_le16(MSW(ha->async_pd_dma)); 1976 mbx->mb3 = cpu_to_le16(LSW(ha->async_pd_dma)); 1977 mbx->mb6 = cpu_to_le16(MSW(MSD(ha->async_pd_dma))); 1978 mbx->mb7 = cpu_to_le16(LSW(MSD(ha->async_pd_dma))); 1979 mbx->mb9 = cpu_to_le16(sp->fcport->vha->vp_idx); 1980 } 1981 1982 static void 1983 qla24xx_tm_iocb(srb_t *sp, struct tsk_mgmt_entry *tsk) 1984 { 1985 uint32_t flags; 1986 unsigned int lun; 1987 struct fc_port *fcport = sp->fcport; 1988 scsi_qla_host_t *vha = fcport->vha; 1989 struct qla_hw_data *ha = vha->hw; 1990 struct srb_iocb *iocb = &sp->u.iocb_cmd; 1991 struct req_que *req = vha->req; 1992 1993 flags = iocb->u.tmf.flags; 1994 lun = iocb->u.tmf.lun; 1995 1996 tsk->entry_type = TSK_MGMT_IOCB_TYPE; 1997 tsk->entry_count = 1; 1998 tsk->handle = MAKE_HANDLE(req->id, tsk->handle); 1999 tsk->nport_handle = cpu_to_le16(fcport->loop_id); 2000 tsk->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2); 2001 tsk->control_flags = cpu_to_le32(flags); 2002 tsk->port_id[0] = fcport->d_id.b.al_pa; 2003 tsk->port_id[1] = fcport->d_id.b.area; 2004 tsk->port_id[2] = fcport->d_id.b.domain; 2005 tsk->vp_index = fcport->vha->vp_idx; 2006 2007 if (flags == TCF_LUN_RESET) { 2008 int_to_scsilun(lun, &tsk->lun); 2009 host_to_fcp_swap((uint8_t *)&tsk->lun, 2010 sizeof(tsk->lun)); 2011 } 2012 } 2013 2014 static void 2015 qla24xx_els_iocb(srb_t *sp, struct els_entry_24xx *els_iocb) 2016 { 2017 struct fc_bsg_job *bsg_job = sp->u.bsg_job; 2018 2019 els_iocb->entry_type = ELS_IOCB_TYPE; 2020 els_iocb->entry_count = 1; 2021 els_iocb->sys_define = 0; 2022 els_iocb->entry_status = 0; 2023 els_iocb->handle = sp->handle; 2024 els_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2025 els_iocb->tx_dsd_count = __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt); 2026 els_iocb->vp_index = sp->fcport->vha->vp_idx; 2027 els_iocb->sof_type = EST_SOFI3; 2028 els_iocb->rx_dsd_count = __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt); 2029 2030 els_iocb->opcode = 2031 sp->type == SRB_ELS_CMD_RPT ? 2032 bsg_job->request->rqst_data.r_els.els_code : 2033 bsg_job->request->rqst_data.h_els.command_code; 2034 els_iocb->port_id[0] = sp->fcport->d_id.b.al_pa; 2035 els_iocb->port_id[1] = sp->fcport->d_id.b.area; 2036 els_iocb->port_id[2] = sp->fcport->d_id.b.domain; 2037 els_iocb->control_flags = 0; 2038 els_iocb->rx_byte_count = 2039 cpu_to_le32(bsg_job->reply_payload.payload_len); 2040 els_iocb->tx_byte_count = 2041 cpu_to_le32(bsg_job->request_payload.payload_len); 2042 2043 els_iocb->tx_address[0] = cpu_to_le32(LSD(sg_dma_address 2044 (bsg_job->request_payload.sg_list))); 2045 els_iocb->tx_address[1] = cpu_to_le32(MSD(sg_dma_address 2046 (bsg_job->request_payload.sg_list))); 2047 els_iocb->tx_len = cpu_to_le32(sg_dma_len 2048 (bsg_job->request_payload.sg_list)); 2049 2050 els_iocb->rx_address[0] = cpu_to_le32(LSD(sg_dma_address 2051 (bsg_job->reply_payload.sg_list))); 2052 els_iocb->rx_address[1] = cpu_to_le32(MSD(sg_dma_address 2053 (bsg_job->reply_payload.sg_list))); 2054 els_iocb->rx_len = cpu_to_le32(sg_dma_len 2055 (bsg_job->reply_payload.sg_list)); 2056 } 2057 2058 static void 2059 qla2x00_ct_iocb(srb_t *sp, ms_iocb_entry_t *ct_iocb) 2060 { 2061 uint16_t avail_dsds; 2062 uint32_t *cur_dsd; 2063 struct scatterlist *sg; 2064 int index; 2065 uint16_t tot_dsds; 2066 scsi_qla_host_t *vha = sp->fcport->vha; 2067 struct qla_hw_data *ha = vha->hw; 2068 struct fc_bsg_job *bsg_job = sp->u.bsg_job; 2069 int loop_iterartion = 0; 2070 int cont_iocb_prsnt = 0; 2071 int entry_count = 1; 2072 2073 memset(ct_iocb, 0, sizeof(ms_iocb_entry_t)); 2074 ct_iocb->entry_type = CT_IOCB_TYPE; 2075 ct_iocb->entry_status = 0; 2076 ct_iocb->handle1 = sp->handle; 2077 SET_TARGET_ID(ha, ct_iocb->loop_id, sp->fcport->loop_id); 2078 ct_iocb->status = __constant_cpu_to_le16(0); 2079 ct_iocb->control_flags = __constant_cpu_to_le16(0); 2080 ct_iocb->timeout = 0; 2081 ct_iocb->cmd_dsd_count = 2082 __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt); 2083 ct_iocb->total_dsd_count = 2084 __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt + 1); 2085 ct_iocb->req_bytecount = 2086 cpu_to_le32(bsg_job->request_payload.payload_len); 2087 ct_iocb->rsp_bytecount = 2088 cpu_to_le32(bsg_job->reply_payload.payload_len); 2089 2090 ct_iocb->dseg_req_address[0] = cpu_to_le32(LSD(sg_dma_address 2091 (bsg_job->request_payload.sg_list))); 2092 ct_iocb->dseg_req_address[1] = cpu_to_le32(MSD(sg_dma_address 2093 (bsg_job->request_payload.sg_list))); 2094 ct_iocb->dseg_req_length = ct_iocb->req_bytecount; 2095 2096 ct_iocb->dseg_rsp_address[0] = cpu_to_le32(LSD(sg_dma_address 2097 (bsg_job->reply_payload.sg_list))); 2098 ct_iocb->dseg_rsp_address[1] = cpu_to_le32(MSD(sg_dma_address 2099 (bsg_job->reply_payload.sg_list))); 2100 ct_iocb->dseg_rsp_length = ct_iocb->rsp_bytecount; 2101 2102 avail_dsds = 1; 2103 cur_dsd = (uint32_t *)ct_iocb->dseg_rsp_address; 2104 index = 0; 2105 tot_dsds = bsg_job->reply_payload.sg_cnt; 2106 2107 for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) { 2108 dma_addr_t sle_dma; 2109 cont_a64_entry_t *cont_pkt; 2110 2111 /* Allocate additional continuation packets? */ 2112 if (avail_dsds == 0) { 2113 /* 2114 * Five DSDs are available in the Cont. 2115 * Type 1 IOCB. 2116 */ 2117 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, 2118 vha->hw->req_q_map[0]); 2119 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 2120 avail_dsds = 5; 2121 cont_iocb_prsnt = 1; 2122 entry_count++; 2123 } 2124 2125 sle_dma = sg_dma_address(sg); 2126 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 2127 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 2128 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 2129 loop_iterartion++; 2130 avail_dsds--; 2131 } 2132 ct_iocb->entry_count = entry_count; 2133 } 2134 2135 static void 2136 qla24xx_ct_iocb(srb_t *sp, struct ct_entry_24xx *ct_iocb) 2137 { 2138 uint16_t avail_dsds; 2139 uint32_t *cur_dsd; 2140 struct scatterlist *sg; 2141 int index; 2142 uint16_t tot_dsds; 2143 scsi_qla_host_t *vha = sp->fcport->vha; 2144 struct qla_hw_data *ha = vha->hw; 2145 struct fc_bsg_job *bsg_job = sp->u.bsg_job; 2146 int loop_iterartion = 0; 2147 int cont_iocb_prsnt = 0; 2148 int entry_count = 1; 2149 2150 ct_iocb->entry_type = CT_IOCB_TYPE; 2151 ct_iocb->entry_status = 0; 2152 ct_iocb->sys_define = 0; 2153 ct_iocb->handle = sp->handle; 2154 2155 ct_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2156 ct_iocb->vp_index = sp->fcport->vha->vp_idx; 2157 ct_iocb->comp_status = __constant_cpu_to_le16(0); 2158 2159 ct_iocb->cmd_dsd_count = 2160 __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt); 2161 ct_iocb->timeout = 0; 2162 ct_iocb->rsp_dsd_count = 2163 __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt); 2164 ct_iocb->rsp_byte_count = 2165 cpu_to_le32(bsg_job->reply_payload.payload_len); 2166 ct_iocb->cmd_byte_count = 2167 cpu_to_le32(bsg_job->request_payload.payload_len); 2168 ct_iocb->dseg_0_address[0] = cpu_to_le32(LSD(sg_dma_address 2169 (bsg_job->request_payload.sg_list))); 2170 ct_iocb->dseg_0_address[1] = cpu_to_le32(MSD(sg_dma_address 2171 (bsg_job->request_payload.sg_list))); 2172 ct_iocb->dseg_0_len = cpu_to_le32(sg_dma_len 2173 (bsg_job->request_payload.sg_list)); 2174 2175 avail_dsds = 1; 2176 cur_dsd = (uint32_t *)ct_iocb->dseg_1_address; 2177 index = 0; 2178 tot_dsds = bsg_job->reply_payload.sg_cnt; 2179 2180 for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) { 2181 dma_addr_t sle_dma; 2182 cont_a64_entry_t *cont_pkt; 2183 2184 /* Allocate additional continuation packets? */ 2185 if (avail_dsds == 0) { 2186 /* 2187 * Five DSDs are available in the Cont. 2188 * Type 1 IOCB. 2189 */ 2190 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, 2191 ha->req_q_map[0]); 2192 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 2193 avail_dsds = 5; 2194 cont_iocb_prsnt = 1; 2195 entry_count++; 2196 } 2197 2198 sle_dma = sg_dma_address(sg); 2199 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 2200 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 2201 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 2202 loop_iterartion++; 2203 avail_dsds--; 2204 } 2205 ct_iocb->entry_count = entry_count; 2206 } 2207 2208 /* 2209 * qla82xx_start_scsi() - Send a SCSI command to the ISP 2210 * @sp: command to send to the ISP 2211 * 2212 * Returns non-zero if a failure occurred, else zero. 2213 */ 2214 int 2215 qla82xx_start_scsi(srb_t *sp) 2216 { 2217 int ret, nseg; 2218 unsigned long flags; 2219 struct scsi_cmnd *cmd; 2220 uint32_t *clr_ptr; 2221 uint32_t index; 2222 uint32_t handle; 2223 uint16_t cnt; 2224 uint16_t req_cnt; 2225 uint16_t tot_dsds; 2226 struct device_reg_82xx __iomem *reg; 2227 uint32_t dbval; 2228 uint32_t *fcp_dl; 2229 uint8_t additional_cdb_len; 2230 struct ct6_dsd *ctx; 2231 struct scsi_qla_host *vha = sp->fcport->vha; 2232 struct qla_hw_data *ha = vha->hw; 2233 struct req_que *req = NULL; 2234 struct rsp_que *rsp = NULL; 2235 char tag[2]; 2236 2237 /* Setup device pointers. */ 2238 ret = 0; 2239 reg = &ha->iobase->isp82; 2240 cmd = GET_CMD_SP(sp); 2241 req = vha->req; 2242 rsp = ha->rsp_q_map[0]; 2243 2244 /* So we know we haven't pci_map'ed anything yet */ 2245 tot_dsds = 0; 2246 2247 dbval = 0x04 | (ha->portnum << 5); 2248 2249 /* Send marker if required */ 2250 if (vha->marker_needed != 0) { 2251 if (qla2x00_marker(vha, req, 2252 rsp, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) { 2253 ql_log(ql_log_warn, vha, 0x300c, 2254 "qla2x00_marker failed for cmd=%p.\n", cmd); 2255 return QLA_FUNCTION_FAILED; 2256 } 2257 vha->marker_needed = 0; 2258 } 2259 2260 /* Acquire ring specific lock */ 2261 spin_lock_irqsave(&ha->hardware_lock, flags); 2262 2263 /* Check for room in outstanding command list. */ 2264 handle = req->current_outstanding_cmd; 2265 for (index = 1; index < req->num_outstanding_cmds; index++) { 2266 handle++; 2267 if (handle == req->num_outstanding_cmds) 2268 handle = 1; 2269 if (!req->outstanding_cmds[handle]) 2270 break; 2271 } 2272 if (index == req->num_outstanding_cmds) 2273 goto queuing_error; 2274 2275 /* Map the sg table so we have an accurate count of sg entries needed */ 2276 if (scsi_sg_count(cmd)) { 2277 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 2278 scsi_sg_count(cmd), cmd->sc_data_direction); 2279 if (unlikely(!nseg)) 2280 goto queuing_error; 2281 } else 2282 nseg = 0; 2283 2284 tot_dsds = nseg; 2285 2286 if (tot_dsds > ql2xshiftctondsd) { 2287 struct cmd_type_6 *cmd_pkt; 2288 uint16_t more_dsd_lists = 0; 2289 struct dsd_dma *dsd_ptr; 2290 uint16_t i; 2291 2292 more_dsd_lists = qla24xx_calc_dsd_lists(tot_dsds); 2293 if ((more_dsd_lists + ha->gbl_dsd_inuse) >= NUM_DSD_CHAIN) { 2294 ql_dbg(ql_dbg_io, vha, 0x300d, 2295 "Num of DSD list %d is than %d for cmd=%p.\n", 2296 more_dsd_lists + ha->gbl_dsd_inuse, NUM_DSD_CHAIN, 2297 cmd); 2298 goto queuing_error; 2299 } 2300 2301 if (more_dsd_lists <= ha->gbl_dsd_avail) 2302 goto sufficient_dsds; 2303 else 2304 more_dsd_lists -= ha->gbl_dsd_avail; 2305 2306 for (i = 0; i < more_dsd_lists; i++) { 2307 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 2308 if (!dsd_ptr) { 2309 ql_log(ql_log_fatal, vha, 0x300e, 2310 "Failed to allocate memory for dsd_dma " 2311 "for cmd=%p.\n", cmd); 2312 goto queuing_error; 2313 } 2314 2315 dsd_ptr->dsd_addr = dma_pool_alloc(ha->dl_dma_pool, 2316 GFP_ATOMIC, &dsd_ptr->dsd_list_dma); 2317 if (!dsd_ptr->dsd_addr) { 2318 kfree(dsd_ptr); 2319 ql_log(ql_log_fatal, vha, 0x300f, 2320 "Failed to allocate memory for dsd_addr " 2321 "for cmd=%p.\n", cmd); 2322 goto queuing_error; 2323 } 2324 list_add_tail(&dsd_ptr->list, &ha->gbl_dsd_list); 2325 ha->gbl_dsd_avail++; 2326 } 2327 2328 sufficient_dsds: 2329 req_cnt = 1; 2330 2331 if (req->cnt < (req_cnt + 2)) { 2332 cnt = (uint16_t)RD_REG_DWORD_RELAXED( 2333 ®->req_q_out[0]); 2334 if (req->ring_index < cnt) 2335 req->cnt = cnt - req->ring_index; 2336 else 2337 req->cnt = req->length - 2338 (req->ring_index - cnt); 2339 if (req->cnt < (req_cnt + 2)) 2340 goto queuing_error; 2341 } 2342 2343 ctx = sp->u.scmd.ctx = 2344 mempool_alloc(ha->ctx_mempool, GFP_ATOMIC); 2345 if (!ctx) { 2346 ql_log(ql_log_fatal, vha, 0x3010, 2347 "Failed to allocate ctx for cmd=%p.\n", cmd); 2348 goto queuing_error; 2349 } 2350 2351 memset(ctx, 0, sizeof(struct ct6_dsd)); 2352 ctx->fcp_cmnd = dma_pool_alloc(ha->fcp_cmnd_dma_pool, 2353 GFP_ATOMIC, &ctx->fcp_cmnd_dma); 2354 if (!ctx->fcp_cmnd) { 2355 ql_log(ql_log_fatal, vha, 0x3011, 2356 "Failed to allocate fcp_cmnd for cmd=%p.\n", cmd); 2357 goto queuing_error; 2358 } 2359 2360 /* Initialize the DSD list and dma handle */ 2361 INIT_LIST_HEAD(&ctx->dsd_list); 2362 ctx->dsd_use_cnt = 0; 2363 2364 if (cmd->cmd_len > 16) { 2365 additional_cdb_len = cmd->cmd_len - 16; 2366 if ((cmd->cmd_len % 4) != 0) { 2367 /* SCSI command bigger than 16 bytes must be 2368 * multiple of 4 2369 */ 2370 ql_log(ql_log_warn, vha, 0x3012, 2371 "scsi cmd len %d not multiple of 4 " 2372 "for cmd=%p.\n", cmd->cmd_len, cmd); 2373 goto queuing_error_fcp_cmnd; 2374 } 2375 ctx->fcp_cmnd_len = 12 + cmd->cmd_len + 4; 2376 } else { 2377 additional_cdb_len = 0; 2378 ctx->fcp_cmnd_len = 12 + 16 + 4; 2379 } 2380 2381 cmd_pkt = (struct cmd_type_6 *)req->ring_ptr; 2382 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 2383 2384 /* Zero out remaining portion of packet. */ 2385 /* tagged queuing modifier -- default is TSK_SIMPLE (0). */ 2386 clr_ptr = (uint32_t *)cmd_pkt + 2; 2387 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 2388 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 2389 2390 /* Set NPORT-ID and LUN number*/ 2391 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2392 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 2393 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 2394 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 2395 cmd_pkt->vp_index = sp->fcport->vha->vp_idx; 2396 2397 /* Build IOCB segments */ 2398 if (qla24xx_build_scsi_type_6_iocbs(sp, cmd_pkt, tot_dsds)) 2399 goto queuing_error_fcp_cmnd; 2400 2401 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 2402 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 2403 2404 /* build FCP_CMND IU */ 2405 memset(ctx->fcp_cmnd, 0, sizeof(struct fcp_cmnd)); 2406 int_to_scsilun(cmd->device->lun, &ctx->fcp_cmnd->lun); 2407 ctx->fcp_cmnd->additional_cdb_len = additional_cdb_len; 2408 2409 if (cmd->sc_data_direction == DMA_TO_DEVICE) 2410 ctx->fcp_cmnd->additional_cdb_len |= 1; 2411 else if (cmd->sc_data_direction == DMA_FROM_DEVICE) 2412 ctx->fcp_cmnd->additional_cdb_len |= 2; 2413 2414 /* 2415 * Update tagged queuing modifier -- default is TSK_SIMPLE (0). 2416 */ 2417 if (scsi_populate_tag_msg(cmd, tag)) { 2418 switch (tag[0]) { 2419 case HEAD_OF_QUEUE_TAG: 2420 ctx->fcp_cmnd->task_attribute = 2421 TSK_HEAD_OF_QUEUE; 2422 break; 2423 case ORDERED_QUEUE_TAG: 2424 ctx->fcp_cmnd->task_attribute = 2425 TSK_ORDERED; 2426 break; 2427 } 2428 } 2429 2430 /* Populate the FCP_PRIO. */ 2431 if (ha->flags.fcp_prio_enabled) 2432 ctx->fcp_cmnd->task_attribute |= 2433 sp->fcport->fcp_prio << 3; 2434 2435 memcpy(ctx->fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len); 2436 2437 fcp_dl = (uint32_t *)(ctx->fcp_cmnd->cdb + 16 + 2438 additional_cdb_len); 2439 *fcp_dl = htonl((uint32_t)scsi_bufflen(cmd)); 2440 2441 cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(ctx->fcp_cmnd_len); 2442 cmd_pkt->fcp_cmnd_dseg_address[0] = 2443 cpu_to_le32(LSD(ctx->fcp_cmnd_dma)); 2444 cmd_pkt->fcp_cmnd_dseg_address[1] = 2445 cpu_to_le32(MSD(ctx->fcp_cmnd_dma)); 2446 2447 sp->flags |= SRB_FCP_CMND_DMA_VALID; 2448 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 2449 /* Set total data segment count. */ 2450 cmd_pkt->entry_count = (uint8_t)req_cnt; 2451 /* Specify response queue number where 2452 * completion should happen 2453 */ 2454 cmd_pkt->entry_status = (uint8_t) rsp->id; 2455 } else { 2456 struct cmd_type_7 *cmd_pkt; 2457 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds); 2458 if (req->cnt < (req_cnt + 2)) { 2459 cnt = (uint16_t)RD_REG_DWORD_RELAXED( 2460 ®->req_q_out[0]); 2461 if (req->ring_index < cnt) 2462 req->cnt = cnt - req->ring_index; 2463 else 2464 req->cnt = req->length - 2465 (req->ring_index - cnt); 2466 } 2467 if (req->cnt < (req_cnt + 2)) 2468 goto queuing_error; 2469 2470 cmd_pkt = (struct cmd_type_7 *)req->ring_ptr; 2471 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 2472 2473 /* Zero out remaining portion of packet. */ 2474 /* tagged queuing modifier -- default is TSK_SIMPLE (0).*/ 2475 clr_ptr = (uint32_t *)cmd_pkt + 2; 2476 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 2477 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 2478 2479 /* Set NPORT-ID and LUN number*/ 2480 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2481 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 2482 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 2483 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 2484 cmd_pkt->vp_index = sp->fcport->vha->vp_idx; 2485 2486 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 2487 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, 2488 sizeof(cmd_pkt->lun)); 2489 2490 /* 2491 * Update tagged queuing modifier -- default is TSK_SIMPLE (0). 2492 */ 2493 if (scsi_populate_tag_msg(cmd, tag)) { 2494 switch (tag[0]) { 2495 case HEAD_OF_QUEUE_TAG: 2496 cmd_pkt->task = TSK_HEAD_OF_QUEUE; 2497 break; 2498 case ORDERED_QUEUE_TAG: 2499 cmd_pkt->task = TSK_ORDERED; 2500 break; 2501 } 2502 } 2503 2504 /* Populate the FCP_PRIO. */ 2505 if (ha->flags.fcp_prio_enabled) 2506 cmd_pkt->task |= sp->fcport->fcp_prio << 3; 2507 2508 /* Load SCSI command packet. */ 2509 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len); 2510 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb)); 2511 2512 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 2513 2514 /* Build IOCB segments */ 2515 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds); 2516 2517 /* Set total data segment count. */ 2518 cmd_pkt->entry_count = (uint8_t)req_cnt; 2519 /* Specify response queue number where 2520 * completion should happen. 2521 */ 2522 cmd_pkt->entry_status = (uint8_t) rsp->id; 2523 2524 } 2525 /* Build command packet. */ 2526 req->current_outstanding_cmd = handle; 2527 req->outstanding_cmds[handle] = sp; 2528 sp->handle = handle; 2529 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 2530 req->cnt -= req_cnt; 2531 wmb(); 2532 2533 /* Adjust ring index. */ 2534 req->ring_index++; 2535 if (req->ring_index == req->length) { 2536 req->ring_index = 0; 2537 req->ring_ptr = req->ring; 2538 } else 2539 req->ring_ptr++; 2540 2541 sp->flags |= SRB_DMA_VALID; 2542 2543 /* Set chip new ring index. */ 2544 /* write, read and verify logic */ 2545 dbval = dbval | (req->id << 8) | (req->ring_index << 16); 2546 if (ql2xdbwr) 2547 qla82xx_wr_32(ha, ha->nxdb_wr_ptr, dbval); 2548 else { 2549 WRT_REG_DWORD( 2550 (unsigned long __iomem *)ha->nxdb_wr_ptr, 2551 dbval); 2552 wmb(); 2553 while (RD_REG_DWORD((void __iomem *)ha->nxdb_rd_ptr) != dbval) { 2554 WRT_REG_DWORD( 2555 (unsigned long __iomem *)ha->nxdb_wr_ptr, 2556 dbval); 2557 wmb(); 2558 } 2559 } 2560 2561 /* Manage unprocessed RIO/ZIO commands in response queue. */ 2562 if (vha->flags.process_response_queue && 2563 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 2564 qla24xx_process_response_queue(vha, rsp); 2565 2566 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2567 return QLA_SUCCESS; 2568 2569 queuing_error_fcp_cmnd: 2570 dma_pool_free(ha->fcp_cmnd_dma_pool, ctx->fcp_cmnd, ctx->fcp_cmnd_dma); 2571 queuing_error: 2572 if (tot_dsds) 2573 scsi_dma_unmap(cmd); 2574 2575 if (sp->u.scmd.ctx) { 2576 mempool_free(sp->u.scmd.ctx, ha->ctx_mempool); 2577 sp->u.scmd.ctx = NULL; 2578 } 2579 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2580 2581 return QLA_FUNCTION_FAILED; 2582 } 2583 2584 int 2585 qla2x00_start_sp(srb_t *sp) 2586 { 2587 int rval; 2588 struct qla_hw_data *ha = sp->fcport->vha->hw; 2589 void *pkt; 2590 unsigned long flags; 2591 2592 rval = QLA_FUNCTION_FAILED; 2593 spin_lock_irqsave(&ha->hardware_lock, flags); 2594 pkt = qla2x00_alloc_iocbs(sp->fcport->vha, sp); 2595 if (!pkt) { 2596 ql_log(ql_log_warn, sp->fcport->vha, 0x700c, 2597 "qla2x00_alloc_iocbs failed.\n"); 2598 goto done; 2599 } 2600 2601 rval = QLA_SUCCESS; 2602 switch (sp->type) { 2603 case SRB_LOGIN_CMD: 2604 IS_FWI2_CAPABLE(ha) ? 2605 qla24xx_login_iocb(sp, pkt) : 2606 qla2x00_login_iocb(sp, pkt); 2607 break; 2608 case SRB_LOGOUT_CMD: 2609 IS_FWI2_CAPABLE(ha) ? 2610 qla24xx_logout_iocb(sp, pkt) : 2611 qla2x00_logout_iocb(sp, pkt); 2612 break; 2613 case SRB_ELS_CMD_RPT: 2614 case SRB_ELS_CMD_HST: 2615 qla24xx_els_iocb(sp, pkt); 2616 break; 2617 case SRB_CT_CMD: 2618 IS_FWI2_CAPABLE(ha) ? 2619 qla24xx_ct_iocb(sp, pkt) : 2620 qla2x00_ct_iocb(sp, pkt); 2621 break; 2622 case SRB_ADISC_CMD: 2623 IS_FWI2_CAPABLE(ha) ? 2624 qla24xx_adisc_iocb(sp, pkt) : 2625 qla2x00_adisc_iocb(sp, pkt); 2626 break; 2627 case SRB_TM_CMD: 2628 qla24xx_tm_iocb(sp, pkt); 2629 break; 2630 default: 2631 break; 2632 } 2633 2634 wmb(); 2635 qla2x00_start_iocbs(sp->fcport->vha, ha->req_q_map[0]); 2636 done: 2637 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2638 return rval; 2639 } 2640 2641 static void 2642 qla25xx_build_bidir_iocb(srb_t *sp, struct scsi_qla_host *vha, 2643 struct cmd_bidir *cmd_pkt, uint32_t tot_dsds) 2644 { 2645 uint16_t avail_dsds; 2646 uint32_t *cur_dsd; 2647 uint32_t req_data_len = 0; 2648 uint32_t rsp_data_len = 0; 2649 struct scatterlist *sg; 2650 int index; 2651 int entry_count = 1; 2652 struct fc_bsg_job *bsg_job = sp->u.bsg_job; 2653 2654 /*Update entry type to indicate bidir command */ 2655 *((uint32_t *)(&cmd_pkt->entry_type)) = 2656 __constant_cpu_to_le32(COMMAND_BIDIRECTIONAL); 2657 2658 /* Set the transfer direction, in this set both flags 2659 * Also set the BD_WRAP_BACK flag, firmware will take care 2660 * assigning DID=SID for outgoing pkts. 2661 */ 2662 cmd_pkt->wr_dseg_count = cpu_to_le16(bsg_job->request_payload.sg_cnt); 2663 cmd_pkt->rd_dseg_count = cpu_to_le16(bsg_job->reply_payload.sg_cnt); 2664 cmd_pkt->control_flags = 2665 __constant_cpu_to_le16(BD_WRITE_DATA | BD_READ_DATA | 2666 BD_WRAP_BACK); 2667 2668 req_data_len = rsp_data_len = bsg_job->request_payload.payload_len; 2669 cmd_pkt->wr_byte_count = cpu_to_le32(req_data_len); 2670 cmd_pkt->rd_byte_count = cpu_to_le32(rsp_data_len); 2671 cmd_pkt->timeout = cpu_to_le16(qla2x00_get_async_timeout(vha) + 2); 2672 2673 vha->bidi_stats.transfer_bytes += req_data_len; 2674 vha->bidi_stats.io_count++; 2675 2676 /* Only one dsd is available for bidirectional IOCB, remaining dsds 2677 * are bundled in continuation iocb 2678 */ 2679 avail_dsds = 1; 2680 cur_dsd = (uint32_t *)&cmd_pkt->fcp_data_dseg_address; 2681 2682 index = 0; 2683 2684 for_each_sg(bsg_job->request_payload.sg_list, sg, 2685 bsg_job->request_payload.sg_cnt, index) { 2686 dma_addr_t sle_dma; 2687 cont_a64_entry_t *cont_pkt; 2688 2689 /* Allocate additional continuation packets */ 2690 if (avail_dsds == 0) { 2691 /* Continuation type 1 IOCB can accomodate 2692 * 5 DSDS 2693 */ 2694 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req); 2695 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 2696 avail_dsds = 5; 2697 entry_count++; 2698 } 2699 sle_dma = sg_dma_address(sg); 2700 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 2701 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 2702 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 2703 avail_dsds--; 2704 } 2705 /* For read request DSD will always goes to continuation IOCB 2706 * and follow the write DSD. If there is room on the current IOCB 2707 * then it is added to that IOCB else new continuation IOCB is 2708 * allocated. 2709 */ 2710 for_each_sg(bsg_job->reply_payload.sg_list, sg, 2711 bsg_job->reply_payload.sg_cnt, index) { 2712 dma_addr_t sle_dma; 2713 cont_a64_entry_t *cont_pkt; 2714 2715 /* Allocate additional continuation packets */ 2716 if (avail_dsds == 0) { 2717 /* Continuation type 1 IOCB can accomodate 2718 * 5 DSDS 2719 */ 2720 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req); 2721 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 2722 avail_dsds = 5; 2723 entry_count++; 2724 } 2725 sle_dma = sg_dma_address(sg); 2726 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 2727 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 2728 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 2729 avail_dsds--; 2730 } 2731 /* This value should be same as number of IOCB required for this cmd */ 2732 cmd_pkt->entry_count = entry_count; 2733 } 2734 2735 int 2736 qla2x00_start_bidir(srb_t *sp, struct scsi_qla_host *vha, uint32_t tot_dsds) 2737 { 2738 2739 struct qla_hw_data *ha = vha->hw; 2740 unsigned long flags; 2741 uint32_t handle; 2742 uint32_t index; 2743 uint16_t req_cnt; 2744 uint16_t cnt; 2745 uint32_t *clr_ptr; 2746 struct cmd_bidir *cmd_pkt = NULL; 2747 struct rsp_que *rsp; 2748 struct req_que *req; 2749 int rval = EXT_STATUS_OK; 2750 2751 rval = QLA_SUCCESS; 2752 2753 rsp = ha->rsp_q_map[0]; 2754 req = vha->req; 2755 2756 /* Send marker if required */ 2757 if (vha->marker_needed != 0) { 2758 if (qla2x00_marker(vha, req, 2759 rsp, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) 2760 return EXT_STATUS_MAILBOX; 2761 vha->marker_needed = 0; 2762 } 2763 2764 /* Acquire ring specific lock */ 2765 spin_lock_irqsave(&ha->hardware_lock, flags); 2766 2767 /* Check for room in outstanding command list. */ 2768 handle = req->current_outstanding_cmd; 2769 for (index = 1; index < req->num_outstanding_cmds; index++) { 2770 handle++; 2771 if (handle == req->num_outstanding_cmds) 2772 handle = 1; 2773 if (!req->outstanding_cmds[handle]) 2774 break; 2775 } 2776 2777 if (index == req->num_outstanding_cmds) { 2778 rval = EXT_STATUS_BUSY; 2779 goto queuing_error; 2780 } 2781 2782 /* Calculate number of IOCB required */ 2783 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds); 2784 2785 /* Check for room on request queue. */ 2786 if (req->cnt < req_cnt + 2) { 2787 cnt = RD_REG_DWORD_RELAXED(req->req_q_out); 2788 2789 if (req->ring_index < cnt) 2790 req->cnt = cnt - req->ring_index; 2791 else 2792 req->cnt = req->length - 2793 (req->ring_index - cnt); 2794 } 2795 if (req->cnt < req_cnt + 2) { 2796 rval = EXT_STATUS_BUSY; 2797 goto queuing_error; 2798 } 2799 2800 cmd_pkt = (struct cmd_bidir *)req->ring_ptr; 2801 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 2802 2803 /* Zero out remaining portion of packet. */ 2804 /* tagged queuing modifier -- default is TSK_SIMPLE (0).*/ 2805 clr_ptr = (uint32_t *)cmd_pkt + 2; 2806 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 2807 2808 /* Set NPORT-ID (of vha)*/ 2809 cmd_pkt->nport_handle = cpu_to_le16(vha->self_login_loop_id); 2810 cmd_pkt->port_id[0] = vha->d_id.b.al_pa; 2811 cmd_pkt->port_id[1] = vha->d_id.b.area; 2812 cmd_pkt->port_id[2] = vha->d_id.b.domain; 2813 2814 qla25xx_build_bidir_iocb(sp, vha, cmd_pkt, tot_dsds); 2815 cmd_pkt->entry_status = (uint8_t) rsp->id; 2816 /* Build command packet. */ 2817 req->current_outstanding_cmd = handle; 2818 req->outstanding_cmds[handle] = sp; 2819 sp->handle = handle; 2820 req->cnt -= req_cnt; 2821 2822 /* Send the command to the firmware */ 2823 wmb(); 2824 qla2x00_start_iocbs(vha, req); 2825 queuing_error: 2826 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2827 return rval; 2828 } 2829