1 /* 2 * QLogic Fibre Channel HBA Driver 3 * Copyright (c) 2003-2014 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 /** 16 * qla2x00_get_cmd_direction() - Determine control_flag data direction. 17 * @cmd: SCSI command 18 * 19 * Returns the proper CF_* direction based on CDB. 20 */ 21 static inline uint16_t 22 qla2x00_get_cmd_direction(srb_t *sp) 23 { 24 uint16_t cflags; 25 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 26 struct scsi_qla_host *vha = sp->vha; 27 28 cflags = 0; 29 30 /* Set transfer direction */ 31 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 32 cflags = CF_WRITE; 33 vha->qla_stats.output_bytes += scsi_bufflen(cmd); 34 vha->qla_stats.output_requests++; 35 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 36 cflags = CF_READ; 37 vha->qla_stats.input_bytes += scsi_bufflen(cmd); 38 vha->qla_stats.input_requests++; 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)) = 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)) = IS_QLAFX00(vha->hw) ? 139 cpu_to_le32(CONTINUE_A64_TYPE_FX00) : 140 cpu_to_le32(CONTINUE_A64_TYPE); 141 142 return (cont_pkt); 143 } 144 145 inline int 146 qla24xx_configure_prot_mode(srb_t *sp, uint16_t *fw_prot_opts) 147 { 148 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 149 uint8_t guard = scsi_host_get_guard(cmd->device->host); 150 151 /* We always use DIFF Bundling for best performance */ 152 *fw_prot_opts = 0; 153 154 /* Translate SCSI opcode to a protection opcode */ 155 switch (scsi_get_prot_op(cmd)) { 156 case SCSI_PROT_READ_STRIP: 157 *fw_prot_opts |= PO_MODE_DIF_REMOVE; 158 break; 159 case SCSI_PROT_WRITE_INSERT: 160 *fw_prot_opts |= PO_MODE_DIF_INSERT; 161 break; 162 case SCSI_PROT_READ_INSERT: 163 *fw_prot_opts |= PO_MODE_DIF_INSERT; 164 break; 165 case SCSI_PROT_WRITE_STRIP: 166 *fw_prot_opts |= PO_MODE_DIF_REMOVE; 167 break; 168 case SCSI_PROT_READ_PASS: 169 case SCSI_PROT_WRITE_PASS: 170 if (guard & SHOST_DIX_GUARD_IP) 171 *fw_prot_opts |= PO_MODE_DIF_TCP_CKSUM; 172 else 173 *fw_prot_opts |= PO_MODE_DIF_PASS; 174 break; 175 default: /* Normal Request */ 176 *fw_prot_opts |= PO_MODE_DIF_PASS; 177 break; 178 } 179 180 return scsi_prot_sg_count(cmd); 181 } 182 183 /* 184 * qla2x00_build_scsi_iocbs_32() - Build IOCB command utilizing 32bit 185 * capable IOCB types. 186 * 187 * @sp: SRB command to process 188 * @cmd_pkt: Command type 2 IOCB 189 * @tot_dsds: Total number of segments to transfer 190 */ 191 void qla2x00_build_scsi_iocbs_32(srb_t *sp, cmd_entry_t *cmd_pkt, 192 uint16_t tot_dsds) 193 { 194 uint16_t avail_dsds; 195 uint32_t *cur_dsd; 196 scsi_qla_host_t *vha; 197 struct scsi_cmnd *cmd; 198 struct scatterlist *sg; 199 int i; 200 201 cmd = GET_CMD_SP(sp); 202 203 /* Update entry type to indicate Command Type 2 IOCB */ 204 *((uint32_t *)(&cmd_pkt->entry_type)) = 205 cpu_to_le32(COMMAND_TYPE); 206 207 /* No data transfer */ 208 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 209 cmd_pkt->byte_count = cpu_to_le32(0); 210 return; 211 } 212 213 vha = sp->vha; 214 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp)); 215 216 /* Three DSDs are available in the Command Type 2 IOCB */ 217 avail_dsds = 3; 218 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 219 220 /* Load data segments */ 221 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 222 cont_entry_t *cont_pkt; 223 224 /* Allocate additional continuation packets? */ 225 if (avail_dsds == 0) { 226 /* 227 * Seven DSDs are available in the Continuation 228 * Type 0 IOCB. 229 */ 230 cont_pkt = qla2x00_prep_cont_type0_iocb(vha); 231 cur_dsd = (uint32_t *)&cont_pkt->dseg_0_address; 232 avail_dsds = 7; 233 } 234 235 *cur_dsd++ = cpu_to_le32(sg_dma_address(sg)); 236 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 237 avail_dsds--; 238 } 239 } 240 241 /** 242 * qla2x00_build_scsi_iocbs_64() - Build IOCB command utilizing 64bit 243 * capable IOCB types. 244 * 245 * @sp: SRB command to process 246 * @cmd_pkt: Command type 3 IOCB 247 * @tot_dsds: Total number of segments to transfer 248 */ 249 void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt, 250 uint16_t tot_dsds) 251 { 252 uint16_t avail_dsds; 253 uint32_t *cur_dsd; 254 scsi_qla_host_t *vha; 255 struct scsi_cmnd *cmd; 256 struct scatterlist *sg; 257 int i; 258 259 cmd = GET_CMD_SP(sp); 260 261 /* Update entry type to indicate Command Type 3 IOCB */ 262 *((uint32_t *)(&cmd_pkt->entry_type)) = 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 = cpu_to_le32(0); 267 return; 268 } 269 270 vha = sp->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 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 326 /* Setup device pointers. */ 327 vha = sp->vha; 328 ha = vha->hw; 329 reg = &ha->iobase->isp; 330 cmd = GET_CMD_SP(sp); 331 req = ha->req_q_map[0]; 332 rsp = ha->rsp_q_map[0]; 333 /* So we know we haven't pci_map'ed anything yet */ 334 tot_dsds = 0; 335 336 /* Send marker if required */ 337 if (vha->marker_needed != 0) { 338 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 339 QLA_SUCCESS) { 340 return (QLA_FUNCTION_FAILED); 341 } 342 vha->marker_needed = 0; 343 } 344 345 /* Acquire ring specific lock */ 346 spin_lock_irqsave(&ha->hardware_lock, flags); 347 348 /* Check for room in outstanding command list. */ 349 handle = req->current_outstanding_cmd; 350 for (index = 1; index < req->num_outstanding_cmds; index++) { 351 handle++; 352 if (handle == req->num_outstanding_cmds) 353 handle = 1; 354 if (!req->outstanding_cmds[handle]) 355 break; 356 } 357 if (index == req->num_outstanding_cmds) 358 goto queuing_error; 359 360 /* Map the sg table so we have an accurate count of sg entries needed */ 361 if (scsi_sg_count(cmd)) { 362 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 363 scsi_sg_count(cmd), cmd->sc_data_direction); 364 if (unlikely(!nseg)) 365 goto queuing_error; 366 } else 367 nseg = 0; 368 369 tot_dsds = nseg; 370 371 /* Calculate the number of request entries needed. */ 372 req_cnt = ha->isp_ops->calc_req_entries(tot_dsds); 373 if (req->cnt < (req_cnt + 2)) { 374 cnt = RD_REG_WORD_RELAXED(ISP_REQ_Q_OUT(ha, reg)); 375 if (req->ring_index < cnt) 376 req->cnt = cnt - req->ring_index; 377 else 378 req->cnt = req->length - 379 (req->ring_index - cnt); 380 /* If still no head room then bail out */ 381 if (req->cnt < (req_cnt + 2)) 382 goto queuing_error; 383 } 384 385 /* Build command packet */ 386 req->current_outstanding_cmd = handle; 387 req->outstanding_cmds[handle] = sp; 388 sp->handle = handle; 389 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 390 req->cnt -= req_cnt; 391 392 cmd_pkt = (cmd_entry_t *)req->ring_ptr; 393 cmd_pkt->handle = handle; 394 /* Zero out remaining portion of packet. */ 395 clr_ptr = (uint32_t *)cmd_pkt + 2; 396 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 397 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 398 399 /* Set target ID and LUN number*/ 400 SET_TARGET_ID(ha, cmd_pkt->target, sp->fcport->loop_id); 401 cmd_pkt->lun = cpu_to_le16(cmd->device->lun); 402 cmd_pkt->control_flags = cpu_to_le16(CF_SIMPLE_TAG); 403 404 /* Load SCSI command packet. */ 405 memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len); 406 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 407 408 /* Build IOCB segments */ 409 ha->isp_ops->build_iocbs(sp, cmd_pkt, tot_dsds); 410 411 /* Set total data segment count. */ 412 cmd_pkt->entry_count = (uint8_t)req_cnt; 413 wmb(); 414 415 /* Adjust ring index. */ 416 req->ring_index++; 417 if (req->ring_index == req->length) { 418 req->ring_index = 0; 419 req->ring_ptr = req->ring; 420 } else 421 req->ring_ptr++; 422 423 sp->flags |= SRB_DMA_VALID; 424 425 /* Set chip new ring index. */ 426 WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), req->ring_index); 427 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, reg)); /* PCI Posting. */ 428 429 /* Manage unprocessed RIO/ZIO commands in response queue. */ 430 if (vha->flags.process_response_queue && 431 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 432 qla2x00_process_response_queue(rsp); 433 434 spin_unlock_irqrestore(&ha->hardware_lock, flags); 435 return (QLA_SUCCESS); 436 437 queuing_error: 438 if (tot_dsds) 439 scsi_dma_unmap(cmd); 440 441 spin_unlock_irqrestore(&ha->hardware_lock, flags); 442 443 return (QLA_FUNCTION_FAILED); 444 } 445 446 /** 447 * qla2x00_start_iocbs() - Execute the IOCB command 448 */ 449 void 450 qla2x00_start_iocbs(struct scsi_qla_host *vha, struct req_que *req) 451 { 452 struct qla_hw_data *ha = vha->hw; 453 device_reg_t *reg = ISP_QUE_REG(ha, req->id); 454 455 if (IS_P3P_TYPE(ha)) { 456 qla82xx_start_iocbs(vha); 457 } else { 458 /* Adjust ring index. */ 459 req->ring_index++; 460 if (req->ring_index == req->length) { 461 req->ring_index = 0; 462 req->ring_ptr = req->ring; 463 } else 464 req->ring_ptr++; 465 466 /* Set chip new ring index. */ 467 if (ha->mqenable || IS_QLA27XX(ha)) { 468 WRT_REG_DWORD(req->req_q_in, req->ring_index); 469 } else if (IS_QLA83XX(ha)) { 470 WRT_REG_DWORD(req->req_q_in, req->ring_index); 471 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr); 472 } else if (IS_QLAFX00(ha)) { 473 WRT_REG_DWORD(®->ispfx00.req_q_in, req->ring_index); 474 RD_REG_DWORD_RELAXED(®->ispfx00.req_q_in); 475 QLAFX00_SET_HST_INTR(ha, ha->rqstq_intr_code); 476 } else if (IS_FWI2_CAPABLE(ha)) { 477 WRT_REG_DWORD(®->isp24.req_q_in, req->ring_index); 478 RD_REG_DWORD_RELAXED(®->isp24.req_q_in); 479 } else { 480 WRT_REG_WORD(ISP_REQ_Q_IN(ha, ®->isp), 481 req->ring_index); 482 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, ®->isp)); 483 } 484 } 485 } 486 487 /** 488 * qla2x00_marker() - Send a marker IOCB to the firmware. 489 * @ha: HA context 490 * @loop_id: loop ID 491 * @lun: LUN 492 * @type: marker modifier 493 * 494 * Can be called from both normal and interrupt context. 495 * 496 * Returns non-zero if a failure occurred, else zero. 497 */ 498 static int 499 __qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req, 500 struct rsp_que *rsp, uint16_t loop_id, 501 uint64_t lun, uint8_t type) 502 { 503 mrk_entry_t *mrk; 504 struct mrk_entry_24xx *mrk24 = NULL; 505 506 struct qla_hw_data *ha = vha->hw; 507 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 508 509 req = ha->req_q_map[0]; 510 mrk = (mrk_entry_t *)qla2x00_alloc_iocbs(vha, NULL); 511 if (mrk == NULL) { 512 ql_log(ql_log_warn, base_vha, 0x3026, 513 "Failed to allocate Marker IOCB.\n"); 514 515 return (QLA_FUNCTION_FAILED); 516 } 517 518 mrk->entry_type = MARKER_TYPE; 519 mrk->modifier = type; 520 if (type != MK_SYNC_ALL) { 521 if (IS_FWI2_CAPABLE(ha)) { 522 mrk24 = (struct mrk_entry_24xx *) mrk; 523 mrk24->nport_handle = cpu_to_le16(loop_id); 524 int_to_scsilun(lun, (struct scsi_lun *)&mrk24->lun); 525 host_to_fcp_swap(mrk24->lun, sizeof(mrk24->lun)); 526 mrk24->vp_index = vha->vp_idx; 527 mrk24->handle = MAKE_HANDLE(req->id, mrk24->handle); 528 } else { 529 SET_TARGET_ID(ha, mrk->target, loop_id); 530 mrk->lun = cpu_to_le16((uint16_t)lun); 531 } 532 } 533 wmb(); 534 535 qla2x00_start_iocbs(vha, req); 536 537 return (QLA_SUCCESS); 538 } 539 540 int 541 qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req, 542 struct rsp_que *rsp, uint16_t loop_id, uint64_t lun, 543 uint8_t type) 544 { 545 int ret; 546 unsigned long flags = 0; 547 548 spin_lock_irqsave(&vha->hw->hardware_lock, flags); 549 ret = __qla2x00_marker(vha, req, rsp, loop_id, lun, type); 550 spin_unlock_irqrestore(&vha->hw->hardware_lock, flags); 551 552 return (ret); 553 } 554 555 /* 556 * qla2x00_issue_marker 557 * 558 * Issue marker 559 * Caller CAN have hardware lock held as specified by ha_locked parameter. 560 * Might release it, then reaquire. 561 */ 562 int qla2x00_issue_marker(scsi_qla_host_t *vha, int ha_locked) 563 { 564 if (ha_locked) { 565 if (__qla2x00_marker(vha, vha->req, vha->req->rsp, 0, 0, 566 MK_SYNC_ALL) != QLA_SUCCESS) 567 return QLA_FUNCTION_FAILED; 568 } else { 569 if (qla2x00_marker(vha, vha->req, vha->req->rsp, 0, 0, 570 MK_SYNC_ALL) != QLA_SUCCESS) 571 return QLA_FUNCTION_FAILED; 572 } 573 vha->marker_needed = 0; 574 575 return QLA_SUCCESS; 576 } 577 578 static inline int 579 qla24xx_build_scsi_type_6_iocbs(srb_t *sp, struct cmd_type_6 *cmd_pkt, 580 uint16_t tot_dsds) 581 { 582 uint32_t *cur_dsd = NULL; 583 scsi_qla_host_t *vha; 584 struct qla_hw_data *ha; 585 struct scsi_cmnd *cmd; 586 struct scatterlist *cur_seg; 587 uint32_t *dsd_seg; 588 void *next_dsd; 589 uint8_t avail_dsds; 590 uint8_t first_iocb = 1; 591 uint32_t dsd_list_len; 592 struct dsd_dma *dsd_ptr; 593 struct ct6_dsd *ctx; 594 595 cmd = GET_CMD_SP(sp); 596 597 /* Update entry type to indicate Command Type 3 IOCB */ 598 *((uint32_t *)(&cmd_pkt->entry_type)) = cpu_to_le32(COMMAND_TYPE_6); 599 600 /* No data transfer */ 601 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 602 cmd_pkt->byte_count = cpu_to_le32(0); 603 return 0; 604 } 605 606 vha = sp->vha; 607 ha = vha->hw; 608 609 /* Set transfer direction */ 610 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 611 cmd_pkt->control_flags = cpu_to_le16(CF_WRITE_DATA); 612 vha->qla_stats.output_bytes += scsi_bufflen(cmd); 613 vha->qla_stats.output_requests++; 614 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 615 cmd_pkt->control_flags = cpu_to_le16(CF_READ_DATA); 616 vha->qla_stats.input_bytes += scsi_bufflen(cmd); 617 vha->qla_stats.input_requests++; 618 } 619 620 cur_seg = scsi_sglist(cmd); 621 ctx = GET_CMD_CTX_SP(sp); 622 623 while (tot_dsds) { 624 avail_dsds = (tot_dsds > QLA_DSDS_PER_IOCB) ? 625 QLA_DSDS_PER_IOCB : tot_dsds; 626 tot_dsds -= avail_dsds; 627 dsd_list_len = (avail_dsds + 1) * QLA_DSD_SIZE; 628 629 dsd_ptr = list_first_entry(&ha->gbl_dsd_list, 630 struct dsd_dma, list); 631 next_dsd = dsd_ptr->dsd_addr; 632 list_del(&dsd_ptr->list); 633 ha->gbl_dsd_avail--; 634 list_add_tail(&dsd_ptr->list, &ctx->dsd_list); 635 ctx->dsd_use_cnt++; 636 ha->gbl_dsd_inuse++; 637 638 if (first_iocb) { 639 first_iocb = 0; 640 dsd_seg = (uint32_t *)&cmd_pkt->fcp_data_dseg_address; 641 *dsd_seg++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 642 *dsd_seg++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 643 cmd_pkt->fcp_data_dseg_len = cpu_to_le32(dsd_list_len); 644 } else { 645 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 646 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 647 *cur_dsd++ = cpu_to_le32(dsd_list_len); 648 } 649 cur_dsd = (uint32_t *)next_dsd; 650 while (avail_dsds) { 651 dma_addr_t sle_dma; 652 653 sle_dma = sg_dma_address(cur_seg); 654 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 655 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 656 *cur_dsd++ = cpu_to_le32(sg_dma_len(cur_seg)); 657 cur_seg = sg_next(cur_seg); 658 avail_dsds--; 659 } 660 } 661 662 /* Null termination */ 663 *cur_dsd++ = 0; 664 *cur_dsd++ = 0; 665 *cur_dsd++ = 0; 666 cmd_pkt->control_flags |= CF_DATA_SEG_DESCR_ENABLE; 667 return 0; 668 } 669 670 /* 671 * qla24xx_calc_dsd_lists() - Determine number of DSD list required 672 * for Command Type 6. 673 * 674 * @dsds: number of data segment decriptors needed 675 * 676 * Returns the number of dsd list needed to store @dsds. 677 */ 678 static inline uint16_t 679 qla24xx_calc_dsd_lists(uint16_t dsds) 680 { 681 uint16_t dsd_lists = 0; 682 683 dsd_lists = (dsds/QLA_DSDS_PER_IOCB); 684 if (dsds % QLA_DSDS_PER_IOCB) 685 dsd_lists++; 686 return dsd_lists; 687 } 688 689 690 /** 691 * qla24xx_build_scsi_iocbs() - Build IOCB command utilizing Command Type 7 692 * IOCB types. 693 * 694 * @sp: SRB command to process 695 * @cmd_pkt: Command type 3 IOCB 696 * @tot_dsds: Total number of segments to transfer 697 * @req: pointer to request queue 698 */ 699 inline void 700 qla24xx_build_scsi_iocbs(srb_t *sp, struct cmd_type_7 *cmd_pkt, 701 uint16_t tot_dsds, struct req_que *req) 702 { 703 uint16_t avail_dsds; 704 uint32_t *cur_dsd; 705 scsi_qla_host_t *vha; 706 struct scsi_cmnd *cmd; 707 struct scatterlist *sg; 708 int i; 709 710 cmd = GET_CMD_SP(sp); 711 712 /* Update entry type to indicate Command Type 3 IOCB */ 713 *((uint32_t *)(&cmd_pkt->entry_type)) = cpu_to_le32(COMMAND_TYPE_7); 714 715 /* No data transfer */ 716 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 717 cmd_pkt->byte_count = cpu_to_le32(0); 718 return; 719 } 720 721 vha = sp->vha; 722 723 /* Set transfer direction */ 724 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 725 cmd_pkt->task_mgmt_flags = cpu_to_le16(TMF_WRITE_DATA); 726 vha->qla_stats.output_bytes += scsi_bufflen(cmd); 727 vha->qla_stats.output_requests++; 728 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 729 cmd_pkt->task_mgmt_flags = cpu_to_le16(TMF_READ_DATA); 730 vha->qla_stats.input_bytes += scsi_bufflen(cmd); 731 vha->qla_stats.input_requests++; 732 } 733 734 /* One DSD is available in the Command Type 3 IOCB */ 735 avail_dsds = 1; 736 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 737 738 /* Load data segments */ 739 740 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 741 dma_addr_t sle_dma; 742 cont_a64_entry_t *cont_pkt; 743 744 /* Allocate additional continuation packets? */ 745 if (avail_dsds == 0) { 746 /* 747 * Five DSDs are available in the Continuation 748 * Type 1 IOCB. 749 */ 750 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, req); 751 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address; 752 avail_dsds = 5; 753 } 754 755 sle_dma = sg_dma_address(sg); 756 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 757 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 758 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 759 avail_dsds--; 760 } 761 } 762 763 struct fw_dif_context { 764 uint32_t ref_tag; 765 uint16_t app_tag; 766 uint8_t ref_tag_mask[4]; /* Validation/Replacement Mask*/ 767 uint8_t app_tag_mask[2]; /* Validation/Replacement Mask*/ 768 }; 769 770 /* 771 * qla24xx_set_t10dif_tags_from_cmd - Extract Ref and App tags from SCSI command 772 * 773 */ 774 static inline void 775 qla24xx_set_t10dif_tags(srb_t *sp, struct fw_dif_context *pkt, 776 unsigned int protcnt) 777 { 778 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 779 780 switch (scsi_get_prot_type(cmd)) { 781 case SCSI_PROT_DIF_TYPE0: 782 /* 783 * No check for ql2xenablehba_err_chk, as it would be an 784 * I/O error if hba tag generation is not done. 785 */ 786 pkt->ref_tag = cpu_to_le32((uint32_t) 787 (0xffffffff & scsi_get_lba(cmd))); 788 789 if (!qla2x00_hba_err_chk_enabled(sp)) 790 break; 791 792 pkt->ref_tag_mask[0] = 0xff; 793 pkt->ref_tag_mask[1] = 0xff; 794 pkt->ref_tag_mask[2] = 0xff; 795 pkt->ref_tag_mask[3] = 0xff; 796 break; 797 798 /* 799 * For TYPE 2 protection: 16 bit GUARD + 32 bit REF tag has to 800 * match LBA in CDB + N 801 */ 802 case SCSI_PROT_DIF_TYPE2: 803 pkt->app_tag = cpu_to_le16(0); 804 pkt->app_tag_mask[0] = 0x0; 805 pkt->app_tag_mask[1] = 0x0; 806 807 pkt->ref_tag = cpu_to_le32((uint32_t) 808 (0xffffffff & scsi_get_lba(cmd))); 809 810 if (!qla2x00_hba_err_chk_enabled(sp)) 811 break; 812 813 /* enable ALL bytes of the ref tag */ 814 pkt->ref_tag_mask[0] = 0xff; 815 pkt->ref_tag_mask[1] = 0xff; 816 pkt->ref_tag_mask[2] = 0xff; 817 pkt->ref_tag_mask[3] = 0xff; 818 break; 819 820 /* For Type 3 protection: 16 bit GUARD only */ 821 case SCSI_PROT_DIF_TYPE3: 822 pkt->ref_tag_mask[0] = pkt->ref_tag_mask[1] = 823 pkt->ref_tag_mask[2] = pkt->ref_tag_mask[3] = 824 0x00; 825 break; 826 827 /* 828 * For TYpe 1 protection: 16 bit GUARD tag, 32 bit REF tag, and 829 * 16 bit app tag. 830 */ 831 case SCSI_PROT_DIF_TYPE1: 832 pkt->ref_tag = cpu_to_le32((uint32_t) 833 (0xffffffff & scsi_get_lba(cmd))); 834 pkt->app_tag = cpu_to_le16(0); 835 pkt->app_tag_mask[0] = 0x0; 836 pkt->app_tag_mask[1] = 0x0; 837 838 if (!qla2x00_hba_err_chk_enabled(sp)) 839 break; 840 841 /* enable ALL bytes of the ref tag */ 842 pkt->ref_tag_mask[0] = 0xff; 843 pkt->ref_tag_mask[1] = 0xff; 844 pkt->ref_tag_mask[2] = 0xff; 845 pkt->ref_tag_mask[3] = 0xff; 846 break; 847 } 848 } 849 850 int 851 qla24xx_get_one_block_sg(uint32_t blk_sz, struct qla2_sgx *sgx, 852 uint32_t *partial) 853 { 854 struct scatterlist *sg; 855 uint32_t cumulative_partial, sg_len; 856 dma_addr_t sg_dma_addr; 857 858 if (sgx->num_bytes == sgx->tot_bytes) 859 return 0; 860 861 sg = sgx->cur_sg; 862 cumulative_partial = sgx->tot_partial; 863 864 sg_dma_addr = sg_dma_address(sg); 865 sg_len = sg_dma_len(sg); 866 867 sgx->dma_addr = sg_dma_addr + sgx->bytes_consumed; 868 869 if ((cumulative_partial + (sg_len - sgx->bytes_consumed)) >= blk_sz) { 870 sgx->dma_len = (blk_sz - cumulative_partial); 871 sgx->tot_partial = 0; 872 sgx->num_bytes += blk_sz; 873 *partial = 0; 874 } else { 875 sgx->dma_len = sg_len - sgx->bytes_consumed; 876 sgx->tot_partial += sgx->dma_len; 877 *partial = 1; 878 } 879 880 sgx->bytes_consumed += sgx->dma_len; 881 882 if (sg_len == sgx->bytes_consumed) { 883 sg = sg_next(sg); 884 sgx->num_sg++; 885 sgx->cur_sg = sg; 886 sgx->bytes_consumed = 0; 887 } 888 889 return 1; 890 } 891 892 int 893 qla24xx_walk_and_build_sglist_no_difb(struct qla_hw_data *ha, srb_t *sp, 894 uint32_t *dsd, uint16_t tot_dsds, struct qla_tc_param *tc) 895 { 896 void *next_dsd; 897 uint8_t avail_dsds = 0; 898 uint32_t dsd_list_len; 899 struct dsd_dma *dsd_ptr; 900 struct scatterlist *sg_prot; 901 uint32_t *cur_dsd = dsd; 902 uint16_t used_dsds = tot_dsds; 903 uint32_t prot_int; /* protection interval */ 904 uint32_t partial; 905 struct qla2_sgx sgx; 906 dma_addr_t sle_dma; 907 uint32_t sle_dma_len, tot_prot_dma_len = 0; 908 struct scsi_cmnd *cmd; 909 910 memset(&sgx, 0, sizeof(struct qla2_sgx)); 911 if (sp) { 912 cmd = GET_CMD_SP(sp); 913 prot_int = cmd->device->sector_size; 914 915 sgx.tot_bytes = scsi_bufflen(cmd); 916 sgx.cur_sg = scsi_sglist(cmd); 917 sgx.sp = sp; 918 919 sg_prot = scsi_prot_sglist(cmd); 920 } else if (tc) { 921 prot_int = tc->blk_sz; 922 sgx.tot_bytes = tc->bufflen; 923 sgx.cur_sg = tc->sg; 924 sg_prot = tc->prot_sg; 925 } else { 926 BUG(); 927 return 1; 928 } 929 930 while (qla24xx_get_one_block_sg(prot_int, &sgx, &partial)) { 931 932 sle_dma = sgx.dma_addr; 933 sle_dma_len = sgx.dma_len; 934 alloc_and_fill: 935 /* Allocate additional continuation packets? */ 936 if (avail_dsds == 0) { 937 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ? 938 QLA_DSDS_PER_IOCB : used_dsds; 939 dsd_list_len = (avail_dsds + 1) * 12; 940 used_dsds -= avail_dsds; 941 942 /* allocate tracking DS */ 943 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 944 if (!dsd_ptr) 945 return 1; 946 947 /* allocate new list */ 948 dsd_ptr->dsd_addr = next_dsd = 949 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, 950 &dsd_ptr->dsd_list_dma); 951 952 if (!next_dsd) { 953 /* 954 * Need to cleanup only this dsd_ptr, rest 955 * will be done by sp_free_dma() 956 */ 957 kfree(dsd_ptr); 958 return 1; 959 } 960 961 if (sp) { 962 list_add_tail(&dsd_ptr->list, 963 &((struct crc_context *) 964 sp->u.scmd.ctx)->dsd_list); 965 966 sp->flags |= SRB_CRC_CTX_DSD_VALID; 967 } else { 968 list_add_tail(&dsd_ptr->list, 969 &(tc->ctx->dsd_list)); 970 *tc->ctx_dsd_alloced = 1; 971 } 972 973 974 /* add new list to cmd iocb or last list */ 975 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 976 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 977 *cur_dsd++ = dsd_list_len; 978 cur_dsd = (uint32_t *)next_dsd; 979 } 980 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 981 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 982 *cur_dsd++ = cpu_to_le32(sle_dma_len); 983 avail_dsds--; 984 985 if (partial == 0) { 986 /* Got a full protection interval */ 987 sle_dma = sg_dma_address(sg_prot) + tot_prot_dma_len; 988 sle_dma_len = 8; 989 990 tot_prot_dma_len += sle_dma_len; 991 if (tot_prot_dma_len == sg_dma_len(sg_prot)) { 992 tot_prot_dma_len = 0; 993 sg_prot = sg_next(sg_prot); 994 } 995 996 partial = 1; /* So as to not re-enter this block */ 997 goto alloc_and_fill; 998 } 999 } 1000 /* Null termination */ 1001 *cur_dsd++ = 0; 1002 *cur_dsd++ = 0; 1003 *cur_dsd++ = 0; 1004 return 0; 1005 } 1006 1007 int 1008 qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp, uint32_t *dsd, 1009 uint16_t tot_dsds, struct qla_tc_param *tc) 1010 { 1011 void *next_dsd; 1012 uint8_t avail_dsds = 0; 1013 uint32_t dsd_list_len; 1014 struct dsd_dma *dsd_ptr; 1015 struct scatterlist *sg, *sgl; 1016 uint32_t *cur_dsd = dsd; 1017 int i; 1018 uint16_t used_dsds = tot_dsds; 1019 struct scsi_cmnd *cmd; 1020 1021 if (sp) { 1022 cmd = GET_CMD_SP(sp); 1023 sgl = scsi_sglist(cmd); 1024 } else if (tc) { 1025 sgl = tc->sg; 1026 } else { 1027 BUG(); 1028 return 1; 1029 } 1030 1031 1032 for_each_sg(sgl, sg, tot_dsds, i) { 1033 dma_addr_t sle_dma; 1034 1035 /* Allocate additional continuation packets? */ 1036 if (avail_dsds == 0) { 1037 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ? 1038 QLA_DSDS_PER_IOCB : used_dsds; 1039 dsd_list_len = (avail_dsds + 1) * 12; 1040 used_dsds -= avail_dsds; 1041 1042 /* allocate tracking DS */ 1043 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 1044 if (!dsd_ptr) 1045 return 1; 1046 1047 /* allocate new list */ 1048 dsd_ptr->dsd_addr = next_dsd = 1049 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, 1050 &dsd_ptr->dsd_list_dma); 1051 1052 if (!next_dsd) { 1053 /* 1054 * Need to cleanup only this dsd_ptr, rest 1055 * will be done by sp_free_dma() 1056 */ 1057 kfree(dsd_ptr); 1058 return 1; 1059 } 1060 1061 if (sp) { 1062 list_add_tail(&dsd_ptr->list, 1063 &((struct crc_context *) 1064 sp->u.scmd.ctx)->dsd_list); 1065 1066 sp->flags |= SRB_CRC_CTX_DSD_VALID; 1067 } else { 1068 list_add_tail(&dsd_ptr->list, 1069 &(tc->ctx->dsd_list)); 1070 *tc->ctx_dsd_alloced = 1; 1071 } 1072 1073 /* add new list to cmd iocb or last list */ 1074 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 1075 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 1076 *cur_dsd++ = dsd_list_len; 1077 cur_dsd = (uint32_t *)next_dsd; 1078 } 1079 sle_dma = sg_dma_address(sg); 1080 1081 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 1082 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 1083 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 1084 avail_dsds--; 1085 1086 } 1087 /* Null termination */ 1088 *cur_dsd++ = 0; 1089 *cur_dsd++ = 0; 1090 *cur_dsd++ = 0; 1091 return 0; 1092 } 1093 1094 int 1095 qla24xx_walk_and_build_prot_sglist(struct qla_hw_data *ha, srb_t *sp, 1096 uint32_t *dsd, uint16_t tot_dsds, struct qla_tc_param *tc) 1097 { 1098 void *next_dsd; 1099 uint8_t avail_dsds = 0; 1100 uint32_t dsd_list_len; 1101 struct dsd_dma *dsd_ptr; 1102 struct scatterlist *sg, *sgl; 1103 int i; 1104 struct scsi_cmnd *cmd; 1105 uint32_t *cur_dsd = dsd; 1106 uint16_t used_dsds = tot_dsds; 1107 struct scsi_qla_host *vha; 1108 1109 if (sp) { 1110 cmd = GET_CMD_SP(sp); 1111 sgl = scsi_prot_sglist(cmd); 1112 vha = sp->vha; 1113 } else if (tc) { 1114 vha = tc->vha; 1115 sgl = tc->prot_sg; 1116 } else { 1117 BUG(); 1118 return 1; 1119 } 1120 1121 ql_dbg(ql_dbg_tgt, vha, 0xe021, 1122 "%s: enter\n", __func__); 1123 1124 for_each_sg(sgl, sg, tot_dsds, i) { 1125 dma_addr_t sle_dma; 1126 1127 /* Allocate additional continuation packets? */ 1128 if (avail_dsds == 0) { 1129 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ? 1130 QLA_DSDS_PER_IOCB : used_dsds; 1131 dsd_list_len = (avail_dsds + 1) * 12; 1132 used_dsds -= avail_dsds; 1133 1134 /* allocate tracking DS */ 1135 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 1136 if (!dsd_ptr) 1137 return 1; 1138 1139 /* allocate new list */ 1140 dsd_ptr->dsd_addr = next_dsd = 1141 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, 1142 &dsd_ptr->dsd_list_dma); 1143 1144 if (!next_dsd) { 1145 /* 1146 * Need to cleanup only this dsd_ptr, rest 1147 * will be done by sp_free_dma() 1148 */ 1149 kfree(dsd_ptr); 1150 return 1; 1151 } 1152 1153 if (sp) { 1154 list_add_tail(&dsd_ptr->list, 1155 &((struct crc_context *) 1156 sp->u.scmd.ctx)->dsd_list); 1157 1158 sp->flags |= SRB_CRC_CTX_DSD_VALID; 1159 } else { 1160 list_add_tail(&dsd_ptr->list, 1161 &(tc->ctx->dsd_list)); 1162 *tc->ctx_dsd_alloced = 1; 1163 } 1164 1165 /* add new list to cmd iocb or last list */ 1166 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma)); 1167 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma)); 1168 *cur_dsd++ = dsd_list_len; 1169 cur_dsd = (uint32_t *)next_dsd; 1170 } 1171 sle_dma = sg_dma_address(sg); 1172 1173 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 1174 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 1175 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 1176 1177 avail_dsds--; 1178 } 1179 /* Null termination */ 1180 *cur_dsd++ = 0; 1181 *cur_dsd++ = 0; 1182 *cur_dsd++ = 0; 1183 return 0; 1184 } 1185 1186 /** 1187 * qla24xx_build_scsi_crc_2_iocbs() - Build IOCB command utilizing Command 1188 * Type 6 IOCB types. 1189 * 1190 * @sp: SRB command to process 1191 * @cmd_pkt: Command type 3 IOCB 1192 * @tot_dsds: Total number of segments to transfer 1193 */ 1194 inline int 1195 qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt, 1196 uint16_t tot_dsds, uint16_t tot_prot_dsds, uint16_t fw_prot_opts) 1197 { 1198 uint32_t *cur_dsd, *fcp_dl; 1199 scsi_qla_host_t *vha; 1200 struct scsi_cmnd *cmd; 1201 uint32_t total_bytes = 0; 1202 uint32_t data_bytes; 1203 uint32_t dif_bytes; 1204 uint8_t bundling = 1; 1205 uint16_t blk_size; 1206 uint8_t *clr_ptr; 1207 struct crc_context *crc_ctx_pkt = NULL; 1208 struct qla_hw_data *ha; 1209 uint8_t additional_fcpcdb_len; 1210 uint16_t fcp_cmnd_len; 1211 struct fcp_cmnd *fcp_cmnd; 1212 dma_addr_t crc_ctx_dma; 1213 1214 cmd = GET_CMD_SP(sp); 1215 1216 /* Update entry type to indicate Command Type CRC_2 IOCB */ 1217 *((uint32_t *)(&cmd_pkt->entry_type)) = cpu_to_le32(COMMAND_TYPE_CRC_2); 1218 1219 vha = sp->vha; 1220 ha = vha->hw; 1221 1222 /* No data transfer */ 1223 data_bytes = scsi_bufflen(cmd); 1224 if (!data_bytes || cmd->sc_data_direction == DMA_NONE) { 1225 cmd_pkt->byte_count = cpu_to_le32(0); 1226 return QLA_SUCCESS; 1227 } 1228 1229 cmd_pkt->vp_index = sp->vha->vp_idx; 1230 1231 /* Set transfer direction */ 1232 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 1233 cmd_pkt->control_flags = 1234 cpu_to_le16(CF_WRITE_DATA); 1235 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 1236 cmd_pkt->control_flags = 1237 cpu_to_le16(CF_READ_DATA); 1238 } 1239 1240 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 1241 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP) || 1242 (scsi_get_prot_op(cmd) == SCSI_PROT_READ_STRIP) || 1243 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_INSERT)) 1244 bundling = 0; 1245 1246 /* Allocate CRC context from global pool */ 1247 crc_ctx_pkt = sp->u.scmd.ctx = 1248 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, &crc_ctx_dma); 1249 1250 if (!crc_ctx_pkt) 1251 goto crc_queuing_error; 1252 1253 /* Zero out CTX area. */ 1254 clr_ptr = (uint8_t *)crc_ctx_pkt; 1255 memset(clr_ptr, 0, sizeof(*crc_ctx_pkt)); 1256 1257 crc_ctx_pkt->crc_ctx_dma = crc_ctx_dma; 1258 1259 sp->flags |= SRB_CRC_CTX_DMA_VALID; 1260 1261 /* Set handle */ 1262 crc_ctx_pkt->handle = cmd_pkt->handle; 1263 1264 INIT_LIST_HEAD(&crc_ctx_pkt->dsd_list); 1265 1266 qla24xx_set_t10dif_tags(sp, (struct fw_dif_context *) 1267 &crc_ctx_pkt->ref_tag, tot_prot_dsds); 1268 1269 cmd_pkt->crc_context_address[0] = cpu_to_le32(LSD(crc_ctx_dma)); 1270 cmd_pkt->crc_context_address[1] = cpu_to_le32(MSD(crc_ctx_dma)); 1271 cmd_pkt->crc_context_len = CRC_CONTEXT_LEN_FW; 1272 1273 /* Determine SCSI command length -- align to 4 byte boundary */ 1274 if (cmd->cmd_len > 16) { 1275 additional_fcpcdb_len = cmd->cmd_len - 16; 1276 if ((cmd->cmd_len % 4) != 0) { 1277 /* SCSI cmd > 16 bytes must be multiple of 4 */ 1278 goto crc_queuing_error; 1279 } 1280 fcp_cmnd_len = 12 + cmd->cmd_len + 4; 1281 } else { 1282 additional_fcpcdb_len = 0; 1283 fcp_cmnd_len = 12 + 16 + 4; 1284 } 1285 1286 fcp_cmnd = &crc_ctx_pkt->fcp_cmnd; 1287 1288 fcp_cmnd->additional_cdb_len = additional_fcpcdb_len; 1289 if (cmd->sc_data_direction == DMA_TO_DEVICE) 1290 fcp_cmnd->additional_cdb_len |= 1; 1291 else if (cmd->sc_data_direction == DMA_FROM_DEVICE) 1292 fcp_cmnd->additional_cdb_len |= 2; 1293 1294 int_to_scsilun(cmd->device->lun, &fcp_cmnd->lun); 1295 memcpy(fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len); 1296 cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(fcp_cmnd_len); 1297 cmd_pkt->fcp_cmnd_dseg_address[0] = cpu_to_le32( 1298 LSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF)); 1299 cmd_pkt->fcp_cmnd_dseg_address[1] = cpu_to_le32( 1300 MSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF)); 1301 fcp_cmnd->task_management = 0; 1302 fcp_cmnd->task_attribute = TSK_SIMPLE; 1303 1304 cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */ 1305 1306 /* Compute dif len and adjust data len to incude protection */ 1307 dif_bytes = 0; 1308 blk_size = cmd->device->sector_size; 1309 dif_bytes = (data_bytes / blk_size) * 8; 1310 1311 switch (scsi_get_prot_op(GET_CMD_SP(sp))) { 1312 case SCSI_PROT_READ_INSERT: 1313 case SCSI_PROT_WRITE_STRIP: 1314 total_bytes = data_bytes; 1315 data_bytes += dif_bytes; 1316 break; 1317 1318 case SCSI_PROT_READ_STRIP: 1319 case SCSI_PROT_WRITE_INSERT: 1320 case SCSI_PROT_READ_PASS: 1321 case SCSI_PROT_WRITE_PASS: 1322 total_bytes = data_bytes + dif_bytes; 1323 break; 1324 default: 1325 BUG(); 1326 } 1327 1328 if (!qla2x00_hba_err_chk_enabled(sp)) 1329 fw_prot_opts |= 0x10; /* Disable Guard tag checking */ 1330 /* HBA error checking enabled */ 1331 else if (IS_PI_UNINIT_CAPABLE(ha)) { 1332 if ((scsi_get_prot_type(GET_CMD_SP(sp)) == SCSI_PROT_DIF_TYPE1) 1333 || (scsi_get_prot_type(GET_CMD_SP(sp)) == 1334 SCSI_PROT_DIF_TYPE2)) 1335 fw_prot_opts |= BIT_10; 1336 else if (scsi_get_prot_type(GET_CMD_SP(sp)) == 1337 SCSI_PROT_DIF_TYPE3) 1338 fw_prot_opts |= BIT_11; 1339 } 1340 1341 if (!bundling) { 1342 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.nobundling.data_address; 1343 } else { 1344 /* 1345 * Configure Bundling if we need to fetch interlaving 1346 * protection PCI accesses 1347 */ 1348 fw_prot_opts |= PO_ENABLE_DIF_BUNDLING; 1349 crc_ctx_pkt->u.bundling.dif_byte_count = cpu_to_le32(dif_bytes); 1350 crc_ctx_pkt->u.bundling.dseg_count = cpu_to_le16(tot_dsds - 1351 tot_prot_dsds); 1352 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.bundling.data_address; 1353 } 1354 1355 /* Finish the common fields of CRC pkt */ 1356 crc_ctx_pkt->blk_size = cpu_to_le16(blk_size); 1357 crc_ctx_pkt->prot_opts = cpu_to_le16(fw_prot_opts); 1358 crc_ctx_pkt->byte_count = cpu_to_le32(data_bytes); 1359 crc_ctx_pkt->guard_seed = cpu_to_le16(0); 1360 /* Fibre channel byte count */ 1361 cmd_pkt->byte_count = cpu_to_le32(total_bytes); 1362 fcp_dl = (uint32_t *)(crc_ctx_pkt->fcp_cmnd.cdb + 16 + 1363 additional_fcpcdb_len); 1364 *fcp_dl = htonl(total_bytes); 1365 1366 if (!data_bytes || cmd->sc_data_direction == DMA_NONE) { 1367 cmd_pkt->byte_count = cpu_to_le32(0); 1368 return QLA_SUCCESS; 1369 } 1370 /* Walks data segments */ 1371 1372 cmd_pkt->control_flags |= cpu_to_le16(CF_DATA_SEG_DESCR_ENABLE); 1373 1374 if (!bundling && tot_prot_dsds) { 1375 if (qla24xx_walk_and_build_sglist_no_difb(ha, sp, 1376 cur_dsd, tot_dsds, NULL)) 1377 goto crc_queuing_error; 1378 } else if (qla24xx_walk_and_build_sglist(ha, sp, cur_dsd, 1379 (tot_dsds - tot_prot_dsds), NULL)) 1380 goto crc_queuing_error; 1381 1382 if (bundling && tot_prot_dsds) { 1383 /* Walks dif segments */ 1384 cmd_pkt->control_flags |= cpu_to_le16(CF_DIF_SEG_DESCR_ENABLE); 1385 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.bundling.dif_address; 1386 if (qla24xx_walk_and_build_prot_sglist(ha, sp, cur_dsd, 1387 tot_prot_dsds, NULL)) 1388 goto crc_queuing_error; 1389 } 1390 return QLA_SUCCESS; 1391 1392 crc_queuing_error: 1393 /* Cleanup will be performed by the caller */ 1394 1395 return QLA_FUNCTION_FAILED; 1396 } 1397 1398 /** 1399 * qla24xx_start_scsi() - Send a SCSI command to the ISP 1400 * @sp: command to send to the ISP 1401 * 1402 * Returns non-zero if a failure occurred, else zero. 1403 */ 1404 int 1405 qla24xx_start_scsi(srb_t *sp) 1406 { 1407 int nseg; 1408 unsigned long flags; 1409 uint32_t *clr_ptr; 1410 uint32_t index; 1411 uint32_t handle; 1412 struct cmd_type_7 *cmd_pkt; 1413 uint16_t cnt; 1414 uint16_t req_cnt; 1415 uint16_t tot_dsds; 1416 struct req_que *req = NULL; 1417 struct rsp_que *rsp = NULL; 1418 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 1419 struct scsi_qla_host *vha = sp->vha; 1420 struct qla_hw_data *ha = vha->hw; 1421 1422 /* Setup device pointers. */ 1423 req = vha->req; 1424 rsp = req->rsp; 1425 1426 /* So we know we haven't pci_map'ed anything yet */ 1427 tot_dsds = 0; 1428 1429 /* Send marker if required */ 1430 if (vha->marker_needed != 0) { 1431 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 1432 QLA_SUCCESS) 1433 return QLA_FUNCTION_FAILED; 1434 vha->marker_needed = 0; 1435 } 1436 1437 /* Acquire ring specific lock */ 1438 spin_lock_irqsave(&ha->hardware_lock, flags); 1439 1440 /* Check for room in outstanding command list. */ 1441 handle = req->current_outstanding_cmd; 1442 for (index = 1; index < req->num_outstanding_cmds; index++) { 1443 handle++; 1444 if (handle == req->num_outstanding_cmds) 1445 handle = 1; 1446 if (!req->outstanding_cmds[handle]) 1447 break; 1448 } 1449 if (index == req->num_outstanding_cmds) 1450 goto queuing_error; 1451 1452 /* Map the sg table so we have an accurate count of sg entries needed */ 1453 if (scsi_sg_count(cmd)) { 1454 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 1455 scsi_sg_count(cmd), cmd->sc_data_direction); 1456 if (unlikely(!nseg)) 1457 goto queuing_error; 1458 } else 1459 nseg = 0; 1460 1461 tot_dsds = nseg; 1462 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds); 1463 if (req->cnt < (req_cnt + 2)) { 1464 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr : 1465 RD_REG_DWORD_RELAXED(req->req_q_out); 1466 if (req->ring_index < cnt) 1467 req->cnt = cnt - req->ring_index; 1468 else 1469 req->cnt = req->length - 1470 (req->ring_index - cnt); 1471 if (req->cnt < (req_cnt + 2)) 1472 goto queuing_error; 1473 } 1474 1475 /* Build command packet. */ 1476 req->current_outstanding_cmd = handle; 1477 req->outstanding_cmds[handle] = sp; 1478 sp->handle = handle; 1479 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 1480 req->cnt -= req_cnt; 1481 1482 cmd_pkt = (struct cmd_type_7 *)req->ring_ptr; 1483 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 1484 1485 /* Zero out remaining portion of packet. */ 1486 /* tagged queuing modifier -- default is TSK_SIMPLE (0). */ 1487 clr_ptr = (uint32_t *)cmd_pkt + 2; 1488 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 1489 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 1490 1491 /* Set NPORT-ID and LUN number*/ 1492 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1493 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 1494 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 1495 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 1496 cmd_pkt->vp_index = sp->vha->vp_idx; 1497 1498 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 1499 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 1500 1501 cmd_pkt->task = TSK_SIMPLE; 1502 1503 /* Load SCSI command packet. */ 1504 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len); 1505 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb)); 1506 1507 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 1508 1509 /* Build IOCB segments */ 1510 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds, req); 1511 1512 /* Set total data segment count. */ 1513 cmd_pkt->entry_count = (uint8_t)req_cnt; 1514 wmb(); 1515 /* Adjust ring index. */ 1516 req->ring_index++; 1517 if (req->ring_index == req->length) { 1518 req->ring_index = 0; 1519 req->ring_ptr = req->ring; 1520 } else 1521 req->ring_ptr++; 1522 1523 sp->flags |= SRB_DMA_VALID; 1524 1525 /* Set chip new ring index. */ 1526 WRT_REG_DWORD(req->req_q_in, req->ring_index); 1527 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr); 1528 1529 /* Manage unprocessed RIO/ZIO commands in response queue. */ 1530 if (vha->flags.process_response_queue && 1531 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 1532 qla24xx_process_response_queue(vha, rsp); 1533 1534 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1535 return QLA_SUCCESS; 1536 1537 queuing_error: 1538 if (tot_dsds) 1539 scsi_dma_unmap(cmd); 1540 1541 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1542 1543 return QLA_FUNCTION_FAILED; 1544 } 1545 1546 /** 1547 * qla24xx_dif_start_scsi() - Send a SCSI command to the ISP 1548 * @sp: command to send to the ISP 1549 * 1550 * Returns non-zero if a failure occurred, else zero. 1551 */ 1552 int 1553 qla24xx_dif_start_scsi(srb_t *sp) 1554 { 1555 int nseg; 1556 unsigned long flags; 1557 uint32_t *clr_ptr; 1558 uint32_t index; 1559 uint32_t handle; 1560 uint16_t cnt; 1561 uint16_t req_cnt = 0; 1562 uint16_t tot_dsds; 1563 uint16_t tot_prot_dsds; 1564 uint16_t fw_prot_opts = 0; 1565 struct req_que *req = NULL; 1566 struct rsp_que *rsp = NULL; 1567 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 1568 struct scsi_qla_host *vha = sp->vha; 1569 struct qla_hw_data *ha = vha->hw; 1570 struct cmd_type_crc_2 *cmd_pkt; 1571 uint32_t status = 0; 1572 1573 #define QDSS_GOT_Q_SPACE BIT_0 1574 1575 /* Only process protection or >16 cdb in this routine */ 1576 if (scsi_get_prot_op(cmd) == SCSI_PROT_NORMAL) { 1577 if (cmd->cmd_len <= 16) 1578 return qla24xx_start_scsi(sp); 1579 } 1580 1581 /* Setup device pointers. */ 1582 req = vha->req; 1583 rsp = req->rsp; 1584 1585 /* So we know we haven't pci_map'ed anything yet */ 1586 tot_dsds = 0; 1587 1588 /* Send marker if required */ 1589 if (vha->marker_needed != 0) { 1590 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 1591 QLA_SUCCESS) 1592 return QLA_FUNCTION_FAILED; 1593 vha->marker_needed = 0; 1594 } 1595 1596 /* Acquire ring specific lock */ 1597 spin_lock_irqsave(&ha->hardware_lock, flags); 1598 1599 /* Check for room in outstanding command list. */ 1600 handle = req->current_outstanding_cmd; 1601 for (index = 1; index < req->num_outstanding_cmds; index++) { 1602 handle++; 1603 if (handle == req->num_outstanding_cmds) 1604 handle = 1; 1605 if (!req->outstanding_cmds[handle]) 1606 break; 1607 } 1608 1609 if (index == req->num_outstanding_cmds) 1610 goto queuing_error; 1611 1612 /* Compute number of required data segments */ 1613 /* Map the sg table so we have an accurate count of sg entries needed */ 1614 if (scsi_sg_count(cmd)) { 1615 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 1616 scsi_sg_count(cmd), cmd->sc_data_direction); 1617 if (unlikely(!nseg)) 1618 goto queuing_error; 1619 else 1620 sp->flags |= SRB_DMA_VALID; 1621 1622 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 1623 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) { 1624 struct qla2_sgx sgx; 1625 uint32_t partial; 1626 1627 memset(&sgx, 0, sizeof(struct qla2_sgx)); 1628 sgx.tot_bytes = scsi_bufflen(cmd); 1629 sgx.cur_sg = scsi_sglist(cmd); 1630 sgx.sp = sp; 1631 1632 nseg = 0; 1633 while (qla24xx_get_one_block_sg( 1634 cmd->device->sector_size, &sgx, &partial)) 1635 nseg++; 1636 } 1637 } else 1638 nseg = 0; 1639 1640 /* number of required data segments */ 1641 tot_dsds = nseg; 1642 1643 /* Compute number of required protection segments */ 1644 if (qla24xx_configure_prot_mode(sp, &fw_prot_opts)) { 1645 nseg = dma_map_sg(&ha->pdev->dev, scsi_prot_sglist(cmd), 1646 scsi_prot_sg_count(cmd), cmd->sc_data_direction); 1647 if (unlikely(!nseg)) 1648 goto queuing_error; 1649 else 1650 sp->flags |= SRB_CRC_PROT_DMA_VALID; 1651 1652 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 1653 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) { 1654 nseg = scsi_bufflen(cmd) / cmd->device->sector_size; 1655 } 1656 } else { 1657 nseg = 0; 1658 } 1659 1660 req_cnt = 1; 1661 /* Total Data and protection sg segment(s) */ 1662 tot_prot_dsds = nseg; 1663 tot_dsds += nseg; 1664 if (req->cnt < (req_cnt + 2)) { 1665 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr : 1666 RD_REG_DWORD_RELAXED(req->req_q_out); 1667 if (req->ring_index < cnt) 1668 req->cnt = cnt - req->ring_index; 1669 else 1670 req->cnt = req->length - 1671 (req->ring_index - cnt); 1672 if (req->cnt < (req_cnt + 2)) 1673 goto queuing_error; 1674 } 1675 1676 status |= QDSS_GOT_Q_SPACE; 1677 1678 /* Build header part of command packet (excluding the OPCODE). */ 1679 req->current_outstanding_cmd = handle; 1680 req->outstanding_cmds[handle] = sp; 1681 sp->handle = handle; 1682 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 1683 req->cnt -= req_cnt; 1684 1685 /* Fill-in common area */ 1686 cmd_pkt = (struct cmd_type_crc_2 *)req->ring_ptr; 1687 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 1688 1689 clr_ptr = (uint32_t *)cmd_pkt + 2; 1690 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 1691 1692 /* Set NPORT-ID and LUN number*/ 1693 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1694 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 1695 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 1696 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 1697 1698 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 1699 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 1700 1701 /* Total Data and protection segment(s) */ 1702 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 1703 1704 /* Build IOCB segments and adjust for data protection segments */ 1705 if (qla24xx_build_scsi_crc_2_iocbs(sp, (struct cmd_type_crc_2 *) 1706 req->ring_ptr, tot_dsds, tot_prot_dsds, fw_prot_opts) != 1707 QLA_SUCCESS) 1708 goto queuing_error; 1709 1710 cmd_pkt->entry_count = (uint8_t)req_cnt; 1711 /* Specify response queue number where completion should happen */ 1712 cmd_pkt->entry_status = (uint8_t) rsp->id; 1713 cmd_pkt->timeout = cpu_to_le16(0); 1714 wmb(); 1715 1716 /* Adjust ring index. */ 1717 req->ring_index++; 1718 if (req->ring_index == req->length) { 1719 req->ring_index = 0; 1720 req->ring_ptr = req->ring; 1721 } else 1722 req->ring_ptr++; 1723 1724 /* Set chip new ring index. */ 1725 WRT_REG_DWORD(req->req_q_in, req->ring_index); 1726 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr); 1727 1728 /* Manage unprocessed RIO/ZIO commands in response queue. */ 1729 if (vha->flags.process_response_queue && 1730 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 1731 qla24xx_process_response_queue(vha, rsp); 1732 1733 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1734 1735 return QLA_SUCCESS; 1736 1737 queuing_error: 1738 if (status & QDSS_GOT_Q_SPACE) { 1739 req->outstanding_cmds[handle] = NULL; 1740 req->cnt += req_cnt; 1741 } 1742 /* Cleanup will be performed by the caller (queuecommand) */ 1743 1744 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1745 return QLA_FUNCTION_FAILED; 1746 } 1747 1748 /** 1749 * qla2xxx_start_scsi_mq() - Send a SCSI command to the ISP 1750 * @sp: command to send to the ISP 1751 * 1752 * Returns non-zero if a failure occurred, else zero. 1753 */ 1754 static int 1755 qla2xxx_start_scsi_mq(srb_t *sp) 1756 { 1757 int nseg; 1758 unsigned long flags; 1759 uint32_t *clr_ptr; 1760 uint32_t index; 1761 uint32_t handle; 1762 struct cmd_type_7 *cmd_pkt; 1763 uint16_t cnt; 1764 uint16_t req_cnt; 1765 uint16_t tot_dsds; 1766 struct req_que *req = NULL; 1767 struct rsp_que *rsp = NULL; 1768 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 1769 struct scsi_qla_host *vha = sp->fcport->vha; 1770 struct qla_hw_data *ha = vha->hw; 1771 struct qla_qpair *qpair = sp->qpair; 1772 1773 /* Acquire qpair specific lock */ 1774 spin_lock_irqsave(&qpair->qp_lock, flags); 1775 1776 /* Setup qpair pointers */ 1777 rsp = qpair->rsp; 1778 req = qpair->req; 1779 1780 /* So we know we haven't pci_map'ed anything yet */ 1781 tot_dsds = 0; 1782 1783 /* Send marker if required */ 1784 if (vha->marker_needed != 0) { 1785 if (__qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 1786 QLA_SUCCESS) { 1787 spin_unlock_irqrestore(&qpair->qp_lock, flags); 1788 return QLA_FUNCTION_FAILED; 1789 } 1790 vha->marker_needed = 0; 1791 } 1792 1793 /* Check for room in outstanding command list. */ 1794 handle = req->current_outstanding_cmd; 1795 for (index = 1; index < req->num_outstanding_cmds; index++) { 1796 handle++; 1797 if (handle == req->num_outstanding_cmds) 1798 handle = 1; 1799 if (!req->outstanding_cmds[handle]) 1800 break; 1801 } 1802 if (index == req->num_outstanding_cmds) 1803 goto queuing_error; 1804 1805 /* Map the sg table so we have an accurate count of sg entries needed */ 1806 if (scsi_sg_count(cmd)) { 1807 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 1808 scsi_sg_count(cmd), cmd->sc_data_direction); 1809 if (unlikely(!nseg)) 1810 goto queuing_error; 1811 } else 1812 nseg = 0; 1813 1814 tot_dsds = nseg; 1815 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds); 1816 if (req->cnt < (req_cnt + 2)) { 1817 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr : 1818 RD_REG_DWORD_RELAXED(req->req_q_out); 1819 if (req->ring_index < cnt) 1820 req->cnt = cnt - req->ring_index; 1821 else 1822 req->cnt = req->length - 1823 (req->ring_index - cnt); 1824 if (req->cnt < (req_cnt + 2)) 1825 goto queuing_error; 1826 } 1827 1828 /* Build command packet. */ 1829 req->current_outstanding_cmd = handle; 1830 req->outstanding_cmds[handle] = sp; 1831 sp->handle = handle; 1832 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 1833 req->cnt -= req_cnt; 1834 1835 cmd_pkt = (struct cmd_type_7 *)req->ring_ptr; 1836 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 1837 1838 /* Zero out remaining portion of packet. */ 1839 /* tagged queuing modifier -- default is TSK_SIMPLE (0). */ 1840 clr_ptr = (uint32_t *)cmd_pkt + 2; 1841 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 1842 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 1843 1844 /* Set NPORT-ID and LUN number*/ 1845 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 1846 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 1847 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 1848 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 1849 cmd_pkt->vp_index = sp->fcport->vha->vp_idx; 1850 1851 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 1852 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 1853 1854 cmd_pkt->task = TSK_SIMPLE; 1855 1856 /* Load SCSI command packet. */ 1857 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len); 1858 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb)); 1859 1860 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 1861 1862 /* Build IOCB segments */ 1863 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds, req); 1864 1865 /* Set total data segment count. */ 1866 cmd_pkt->entry_count = (uint8_t)req_cnt; 1867 wmb(); 1868 /* Adjust ring index. */ 1869 req->ring_index++; 1870 if (req->ring_index == req->length) { 1871 req->ring_index = 0; 1872 req->ring_ptr = req->ring; 1873 } else 1874 req->ring_ptr++; 1875 1876 sp->flags |= SRB_DMA_VALID; 1877 1878 /* Set chip new ring index. */ 1879 WRT_REG_DWORD(req->req_q_in, req->ring_index); 1880 1881 /* Manage unprocessed RIO/ZIO commands in response queue. */ 1882 if (vha->flags.process_response_queue && 1883 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 1884 qla24xx_process_response_queue(vha, rsp); 1885 1886 spin_unlock_irqrestore(&qpair->qp_lock, flags); 1887 return QLA_SUCCESS; 1888 1889 queuing_error: 1890 if (tot_dsds) 1891 scsi_dma_unmap(cmd); 1892 1893 spin_unlock_irqrestore(&qpair->qp_lock, flags); 1894 1895 return QLA_FUNCTION_FAILED; 1896 } 1897 1898 1899 /** 1900 * qla2xxx_dif_start_scsi_mq() - Send a SCSI command to the ISP 1901 * @sp: command to send to the ISP 1902 * 1903 * Returns non-zero if a failure occurred, else zero. 1904 */ 1905 int 1906 qla2xxx_dif_start_scsi_mq(srb_t *sp) 1907 { 1908 int nseg; 1909 unsigned long flags; 1910 uint32_t *clr_ptr; 1911 uint32_t index; 1912 uint32_t handle; 1913 uint16_t cnt; 1914 uint16_t req_cnt = 0; 1915 uint16_t tot_dsds; 1916 uint16_t tot_prot_dsds; 1917 uint16_t fw_prot_opts = 0; 1918 struct req_que *req = NULL; 1919 struct rsp_que *rsp = NULL; 1920 struct scsi_cmnd *cmd = GET_CMD_SP(sp); 1921 struct scsi_qla_host *vha = sp->fcport->vha; 1922 struct qla_hw_data *ha = vha->hw; 1923 struct cmd_type_crc_2 *cmd_pkt; 1924 uint32_t status = 0; 1925 struct qla_qpair *qpair = sp->qpair; 1926 1927 #define QDSS_GOT_Q_SPACE BIT_0 1928 1929 /* Check for host side state */ 1930 if (!qpair->online) { 1931 cmd->result = DID_NO_CONNECT << 16; 1932 return QLA_INTERFACE_ERROR; 1933 } 1934 1935 if (!qpair->difdix_supported && 1936 scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) { 1937 cmd->result = DID_NO_CONNECT << 16; 1938 return QLA_INTERFACE_ERROR; 1939 } 1940 1941 /* Only process protection or >16 cdb in this routine */ 1942 if (scsi_get_prot_op(cmd) == SCSI_PROT_NORMAL) { 1943 if (cmd->cmd_len <= 16) 1944 return qla2xxx_start_scsi_mq(sp); 1945 } 1946 1947 spin_lock_irqsave(&qpair->qp_lock, flags); 1948 1949 /* Setup qpair pointers */ 1950 rsp = qpair->rsp; 1951 req = qpair->req; 1952 1953 /* So we know we haven't pci_map'ed anything yet */ 1954 tot_dsds = 0; 1955 1956 /* Send marker if required */ 1957 if (vha->marker_needed != 0) { 1958 if (__qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) != 1959 QLA_SUCCESS) { 1960 spin_unlock_irqrestore(&qpair->qp_lock, flags); 1961 return QLA_FUNCTION_FAILED; 1962 } 1963 vha->marker_needed = 0; 1964 } 1965 1966 /* Check for room in outstanding command list. */ 1967 handle = req->current_outstanding_cmd; 1968 for (index = 1; index < req->num_outstanding_cmds; index++) { 1969 handle++; 1970 if (handle == req->num_outstanding_cmds) 1971 handle = 1; 1972 if (!req->outstanding_cmds[handle]) 1973 break; 1974 } 1975 1976 if (index == req->num_outstanding_cmds) 1977 goto queuing_error; 1978 1979 /* Compute number of required data segments */ 1980 /* Map the sg table so we have an accurate count of sg entries needed */ 1981 if (scsi_sg_count(cmd)) { 1982 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 1983 scsi_sg_count(cmd), cmd->sc_data_direction); 1984 if (unlikely(!nseg)) 1985 goto queuing_error; 1986 else 1987 sp->flags |= SRB_DMA_VALID; 1988 1989 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 1990 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) { 1991 struct qla2_sgx sgx; 1992 uint32_t partial; 1993 1994 memset(&sgx, 0, sizeof(struct qla2_sgx)); 1995 sgx.tot_bytes = scsi_bufflen(cmd); 1996 sgx.cur_sg = scsi_sglist(cmd); 1997 sgx.sp = sp; 1998 1999 nseg = 0; 2000 while (qla24xx_get_one_block_sg( 2001 cmd->device->sector_size, &sgx, &partial)) 2002 nseg++; 2003 } 2004 } else 2005 nseg = 0; 2006 2007 /* number of required data segments */ 2008 tot_dsds = nseg; 2009 2010 /* Compute number of required protection segments */ 2011 if (qla24xx_configure_prot_mode(sp, &fw_prot_opts)) { 2012 nseg = dma_map_sg(&ha->pdev->dev, scsi_prot_sglist(cmd), 2013 scsi_prot_sg_count(cmd), cmd->sc_data_direction); 2014 if (unlikely(!nseg)) 2015 goto queuing_error; 2016 else 2017 sp->flags |= SRB_CRC_PROT_DMA_VALID; 2018 2019 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) || 2020 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) { 2021 nseg = scsi_bufflen(cmd) / cmd->device->sector_size; 2022 } 2023 } else { 2024 nseg = 0; 2025 } 2026 2027 req_cnt = 1; 2028 /* Total Data and protection sg segment(s) */ 2029 tot_prot_dsds = nseg; 2030 tot_dsds += nseg; 2031 if (req->cnt < (req_cnt + 2)) { 2032 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr : 2033 RD_REG_DWORD_RELAXED(req->req_q_out); 2034 if (req->ring_index < cnt) 2035 req->cnt = cnt - req->ring_index; 2036 else 2037 req->cnt = req->length - 2038 (req->ring_index - cnt); 2039 if (req->cnt < (req_cnt + 2)) 2040 goto queuing_error; 2041 } 2042 2043 status |= QDSS_GOT_Q_SPACE; 2044 2045 /* Build header part of command packet (excluding the OPCODE). */ 2046 req->current_outstanding_cmd = handle; 2047 req->outstanding_cmds[handle] = sp; 2048 sp->handle = handle; 2049 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 2050 req->cnt -= req_cnt; 2051 2052 /* Fill-in common area */ 2053 cmd_pkt = (struct cmd_type_crc_2 *)req->ring_ptr; 2054 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 2055 2056 clr_ptr = (uint32_t *)cmd_pkt + 2; 2057 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 2058 2059 /* Set NPORT-ID and LUN number*/ 2060 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2061 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 2062 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 2063 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 2064 2065 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 2066 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 2067 2068 /* Total Data and protection segment(s) */ 2069 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 2070 2071 /* Build IOCB segments and adjust for data protection segments */ 2072 if (qla24xx_build_scsi_crc_2_iocbs(sp, (struct cmd_type_crc_2 *) 2073 req->ring_ptr, tot_dsds, tot_prot_dsds, fw_prot_opts) != 2074 QLA_SUCCESS) 2075 goto queuing_error; 2076 2077 cmd_pkt->entry_count = (uint8_t)req_cnt; 2078 cmd_pkt->timeout = cpu_to_le16(0); 2079 wmb(); 2080 2081 /* Adjust ring index. */ 2082 req->ring_index++; 2083 if (req->ring_index == req->length) { 2084 req->ring_index = 0; 2085 req->ring_ptr = req->ring; 2086 } else 2087 req->ring_ptr++; 2088 2089 /* Set chip new ring index. */ 2090 WRT_REG_DWORD(req->req_q_in, req->ring_index); 2091 2092 /* Manage unprocessed RIO/ZIO commands in response queue. */ 2093 if (vha->flags.process_response_queue && 2094 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 2095 qla24xx_process_response_queue(vha, rsp); 2096 2097 spin_unlock_irqrestore(&qpair->qp_lock, flags); 2098 2099 return QLA_SUCCESS; 2100 2101 queuing_error: 2102 if (status & QDSS_GOT_Q_SPACE) { 2103 req->outstanding_cmds[handle] = NULL; 2104 req->cnt += req_cnt; 2105 } 2106 /* Cleanup will be performed by the caller (queuecommand) */ 2107 2108 spin_unlock_irqrestore(&qpair->qp_lock, flags); 2109 return QLA_FUNCTION_FAILED; 2110 } 2111 2112 /* Generic Control-SRB manipulation functions. */ 2113 2114 /* hardware_lock assumed to be held. */ 2115 2116 void * 2117 __qla2x00_alloc_iocbs(struct qla_qpair *qpair, srb_t *sp) 2118 { 2119 scsi_qla_host_t *vha = qpair->vha; 2120 struct qla_hw_data *ha = vha->hw; 2121 struct req_que *req = qpair->req; 2122 device_reg_t *reg = ISP_QUE_REG(ha, req->id); 2123 uint32_t index, handle; 2124 request_t *pkt; 2125 uint16_t cnt, req_cnt; 2126 2127 pkt = NULL; 2128 req_cnt = 1; 2129 handle = 0; 2130 2131 if (!sp) 2132 goto skip_cmd_array; 2133 2134 /* Check for room in outstanding command list. */ 2135 handle = req->current_outstanding_cmd; 2136 for (index = 1; index < req->num_outstanding_cmds; index++) { 2137 handle++; 2138 if (handle == req->num_outstanding_cmds) 2139 handle = 1; 2140 if (!req->outstanding_cmds[handle]) 2141 break; 2142 } 2143 if (index == req->num_outstanding_cmds) { 2144 ql_log(ql_log_warn, vha, 0x700b, 2145 "No room on outstanding cmd array.\n"); 2146 goto queuing_error; 2147 } 2148 2149 /* Prep command array. */ 2150 req->current_outstanding_cmd = handle; 2151 req->outstanding_cmds[handle] = sp; 2152 sp->handle = handle; 2153 2154 /* Adjust entry-counts as needed. */ 2155 if (sp->type != SRB_SCSI_CMD) 2156 req_cnt = sp->iocbs; 2157 2158 skip_cmd_array: 2159 /* Check for room on request queue. */ 2160 if (req->cnt < req_cnt + 2) { 2161 if (ha->mqenable || IS_QLA83XX(ha) || IS_QLA27XX(ha)) 2162 cnt = RD_REG_DWORD(®->isp25mq.req_q_out); 2163 else if (IS_P3P_TYPE(ha)) 2164 cnt = RD_REG_DWORD(®->isp82.req_q_out); 2165 else if (IS_FWI2_CAPABLE(ha)) 2166 cnt = RD_REG_DWORD(®->isp24.req_q_out); 2167 else if (IS_QLAFX00(ha)) 2168 cnt = RD_REG_DWORD(®->ispfx00.req_q_out); 2169 else 2170 cnt = qla2x00_debounce_register( 2171 ISP_REQ_Q_OUT(ha, ®->isp)); 2172 2173 if (req->ring_index < cnt) 2174 req->cnt = cnt - req->ring_index; 2175 else 2176 req->cnt = req->length - 2177 (req->ring_index - cnt); 2178 } 2179 if (req->cnt < req_cnt + 2) 2180 goto queuing_error; 2181 2182 /* Prep packet */ 2183 req->cnt -= req_cnt; 2184 pkt = req->ring_ptr; 2185 memset(pkt, 0, REQUEST_ENTRY_SIZE); 2186 if (IS_QLAFX00(ha)) { 2187 WRT_REG_BYTE((void __iomem *)&pkt->entry_count, req_cnt); 2188 WRT_REG_WORD((void __iomem *)&pkt->handle, handle); 2189 } else { 2190 pkt->entry_count = req_cnt; 2191 pkt->handle = handle; 2192 } 2193 2194 queuing_error: 2195 qpair->tgt_counters.num_alloc_iocb_failed++; 2196 return pkt; 2197 } 2198 2199 void * 2200 qla2x00_alloc_iocbs_ready(struct qla_qpair *qpair, srb_t *sp) 2201 { 2202 scsi_qla_host_t *vha = qpair->vha; 2203 2204 if (qla2x00_reset_active(vha)) 2205 return NULL; 2206 2207 return __qla2x00_alloc_iocbs(qpair, sp); 2208 } 2209 2210 void * 2211 qla2x00_alloc_iocbs(struct scsi_qla_host *vha, srb_t *sp) 2212 { 2213 return __qla2x00_alloc_iocbs(vha->hw->base_qpair, sp); 2214 } 2215 2216 static void 2217 qla24xx_prli_iocb(srb_t *sp, struct logio_entry_24xx *logio) 2218 { 2219 struct srb_iocb *lio = &sp->u.iocb_cmd; 2220 2221 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 2222 logio->control_flags = cpu_to_le16(LCF_COMMAND_PRLI); 2223 if (lio->u.logio.flags & SRB_LOGIN_NVME_PRLI) 2224 logio->control_flags |= LCF_NVME_PRLI; 2225 2226 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2227 logio->port_id[0] = sp->fcport->d_id.b.al_pa; 2228 logio->port_id[1] = sp->fcport->d_id.b.area; 2229 logio->port_id[2] = sp->fcport->d_id.b.domain; 2230 logio->vp_index = sp->vha->vp_idx; 2231 } 2232 2233 static void 2234 qla24xx_login_iocb(srb_t *sp, struct logio_entry_24xx *logio) 2235 { 2236 struct srb_iocb *lio = &sp->u.iocb_cmd; 2237 2238 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 2239 logio->control_flags = cpu_to_le16(LCF_COMMAND_PLOGI); 2240 2241 if (lio->u.logio.flags & SRB_LOGIN_COND_PLOGI) 2242 logio->control_flags |= cpu_to_le16(LCF_COND_PLOGI); 2243 if (lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI) 2244 logio->control_flags |= cpu_to_le16(LCF_SKIP_PRLI); 2245 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2246 logio->port_id[0] = sp->fcport->d_id.b.al_pa; 2247 logio->port_id[1] = sp->fcport->d_id.b.area; 2248 logio->port_id[2] = sp->fcport->d_id.b.domain; 2249 logio->vp_index = sp->vha->vp_idx; 2250 } 2251 2252 static void 2253 qla2x00_login_iocb(srb_t *sp, struct mbx_entry *mbx) 2254 { 2255 struct qla_hw_data *ha = sp->vha->hw; 2256 struct srb_iocb *lio = &sp->u.iocb_cmd; 2257 uint16_t opts; 2258 2259 mbx->entry_type = MBX_IOCB_TYPE; 2260 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id); 2261 mbx->mb0 = cpu_to_le16(MBC_LOGIN_FABRIC_PORT); 2262 opts = lio->u.logio.flags & SRB_LOGIN_COND_PLOGI ? BIT_0 : 0; 2263 opts |= lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI ? BIT_1 : 0; 2264 if (HAS_EXTENDED_IDS(ha)) { 2265 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id); 2266 mbx->mb10 = cpu_to_le16(opts); 2267 } else { 2268 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | opts); 2269 } 2270 mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain); 2271 mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 | 2272 sp->fcport->d_id.b.al_pa); 2273 mbx->mb9 = cpu_to_le16(sp->vha->vp_idx); 2274 } 2275 2276 static void 2277 qla24xx_logout_iocb(srb_t *sp, struct logio_entry_24xx *logio) 2278 { 2279 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 2280 logio->control_flags = 2281 cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO); 2282 if (!sp->fcport->se_sess || 2283 !sp->fcport->keep_nport_handle) 2284 logio->control_flags |= cpu_to_le16(LCF_FREE_NPORT); 2285 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2286 logio->port_id[0] = sp->fcport->d_id.b.al_pa; 2287 logio->port_id[1] = sp->fcport->d_id.b.area; 2288 logio->port_id[2] = sp->fcport->d_id.b.domain; 2289 logio->vp_index = sp->vha->vp_idx; 2290 } 2291 2292 static void 2293 qla2x00_logout_iocb(srb_t *sp, struct mbx_entry *mbx) 2294 { 2295 struct qla_hw_data *ha = sp->vha->hw; 2296 2297 mbx->entry_type = MBX_IOCB_TYPE; 2298 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id); 2299 mbx->mb0 = cpu_to_le16(MBC_LOGOUT_FABRIC_PORT); 2300 mbx->mb1 = HAS_EXTENDED_IDS(ha) ? 2301 cpu_to_le16(sp->fcport->loop_id): 2302 cpu_to_le16(sp->fcport->loop_id << 8); 2303 mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain); 2304 mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 | 2305 sp->fcport->d_id.b.al_pa); 2306 mbx->mb9 = cpu_to_le16(sp->vha->vp_idx); 2307 /* Implicit: mbx->mbx10 = 0. */ 2308 } 2309 2310 static void 2311 qla24xx_adisc_iocb(srb_t *sp, struct logio_entry_24xx *logio) 2312 { 2313 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE; 2314 logio->control_flags = cpu_to_le16(LCF_COMMAND_ADISC); 2315 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2316 logio->vp_index = sp->vha->vp_idx; 2317 } 2318 2319 static void 2320 qla2x00_adisc_iocb(srb_t *sp, struct mbx_entry *mbx) 2321 { 2322 struct qla_hw_data *ha = sp->vha->hw; 2323 2324 mbx->entry_type = MBX_IOCB_TYPE; 2325 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id); 2326 mbx->mb0 = cpu_to_le16(MBC_GET_PORT_DATABASE); 2327 if (HAS_EXTENDED_IDS(ha)) { 2328 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id); 2329 mbx->mb10 = cpu_to_le16(BIT_0); 2330 } else { 2331 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | BIT_0); 2332 } 2333 mbx->mb2 = cpu_to_le16(MSW(ha->async_pd_dma)); 2334 mbx->mb3 = cpu_to_le16(LSW(ha->async_pd_dma)); 2335 mbx->mb6 = cpu_to_le16(MSW(MSD(ha->async_pd_dma))); 2336 mbx->mb7 = cpu_to_le16(LSW(MSD(ha->async_pd_dma))); 2337 mbx->mb9 = cpu_to_le16(sp->vha->vp_idx); 2338 } 2339 2340 static void 2341 qla24xx_tm_iocb(srb_t *sp, struct tsk_mgmt_entry *tsk) 2342 { 2343 uint32_t flags; 2344 uint64_t lun; 2345 struct fc_port *fcport = sp->fcport; 2346 scsi_qla_host_t *vha = fcport->vha; 2347 struct qla_hw_data *ha = vha->hw; 2348 struct srb_iocb *iocb = &sp->u.iocb_cmd; 2349 struct req_que *req = vha->req; 2350 2351 flags = iocb->u.tmf.flags; 2352 lun = iocb->u.tmf.lun; 2353 2354 tsk->entry_type = TSK_MGMT_IOCB_TYPE; 2355 tsk->entry_count = 1; 2356 tsk->handle = MAKE_HANDLE(req->id, tsk->handle); 2357 tsk->nport_handle = cpu_to_le16(fcport->loop_id); 2358 tsk->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2); 2359 tsk->control_flags = cpu_to_le32(flags); 2360 tsk->port_id[0] = fcport->d_id.b.al_pa; 2361 tsk->port_id[1] = fcport->d_id.b.area; 2362 tsk->port_id[2] = fcport->d_id.b.domain; 2363 tsk->vp_index = fcport->vha->vp_idx; 2364 2365 if (flags == TCF_LUN_RESET) { 2366 int_to_scsilun(lun, &tsk->lun); 2367 host_to_fcp_swap((uint8_t *)&tsk->lun, 2368 sizeof(tsk->lun)); 2369 } 2370 } 2371 2372 static void 2373 qla2x00_els_dcmd_sp_free(void *data) 2374 { 2375 srb_t *sp = data; 2376 struct srb_iocb *elsio = &sp->u.iocb_cmd; 2377 2378 kfree(sp->fcport); 2379 2380 if (elsio->u.els_logo.els_logo_pyld) 2381 dma_free_coherent(&sp->vha->hw->pdev->dev, DMA_POOL_SIZE, 2382 elsio->u.els_logo.els_logo_pyld, 2383 elsio->u.els_logo.els_logo_pyld_dma); 2384 2385 del_timer(&elsio->timer); 2386 qla2x00_rel_sp(sp); 2387 } 2388 2389 static void 2390 qla2x00_els_dcmd_iocb_timeout(void *data) 2391 { 2392 srb_t *sp = data; 2393 fc_port_t *fcport = sp->fcport; 2394 struct scsi_qla_host *vha = sp->vha; 2395 struct qla_hw_data *ha = vha->hw; 2396 struct srb_iocb *lio = &sp->u.iocb_cmd; 2397 unsigned long flags = 0; 2398 2399 ql_dbg(ql_dbg_io, vha, 0x3069, 2400 "%s Timeout, hdl=%x, portid=%02x%02x%02x\n", 2401 sp->name, sp->handle, fcport->d_id.b.domain, fcport->d_id.b.area, 2402 fcport->d_id.b.al_pa); 2403 2404 /* Abort the exchange */ 2405 spin_lock_irqsave(&ha->hardware_lock, flags); 2406 if (ha->isp_ops->abort_command(sp)) { 2407 ql_dbg(ql_dbg_io, vha, 0x3070, 2408 "mbx abort_command failed.\n"); 2409 } else { 2410 ql_dbg(ql_dbg_io, vha, 0x3071, 2411 "mbx abort_command success.\n"); 2412 } 2413 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2414 2415 complete(&lio->u.els_logo.comp); 2416 } 2417 2418 static void 2419 qla2x00_els_dcmd_sp_done(void *ptr, int res) 2420 { 2421 srb_t *sp = ptr; 2422 fc_port_t *fcport = sp->fcport; 2423 struct srb_iocb *lio = &sp->u.iocb_cmd; 2424 struct scsi_qla_host *vha = sp->vha; 2425 2426 ql_dbg(ql_dbg_io, vha, 0x3072, 2427 "%s hdl=%x, portid=%02x%02x%02x done\n", 2428 sp->name, sp->handle, fcport->d_id.b.domain, 2429 fcport->d_id.b.area, fcport->d_id.b.al_pa); 2430 2431 complete(&lio->u.els_logo.comp); 2432 } 2433 2434 int 2435 qla24xx_els_dcmd_iocb(scsi_qla_host_t *vha, int els_opcode, 2436 port_id_t remote_did) 2437 { 2438 srb_t *sp; 2439 fc_port_t *fcport = NULL; 2440 struct srb_iocb *elsio = NULL; 2441 struct qla_hw_data *ha = vha->hw; 2442 struct els_logo_payload logo_pyld; 2443 int rval = QLA_SUCCESS; 2444 2445 fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL); 2446 if (!fcport) { 2447 ql_log(ql_log_info, vha, 0x70e5, "fcport allocation failed\n"); 2448 return -ENOMEM; 2449 } 2450 2451 /* Alloc SRB structure */ 2452 sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL); 2453 if (!sp) { 2454 kfree(fcport); 2455 ql_log(ql_log_info, vha, 0x70e6, 2456 "SRB allocation failed\n"); 2457 return -ENOMEM; 2458 } 2459 2460 elsio = &sp->u.iocb_cmd; 2461 fcport->loop_id = 0xFFFF; 2462 fcport->d_id.b.domain = remote_did.b.domain; 2463 fcport->d_id.b.area = remote_did.b.area; 2464 fcport->d_id.b.al_pa = remote_did.b.al_pa; 2465 2466 ql_dbg(ql_dbg_io, vha, 0x3073, "portid=%02x%02x%02x done\n", 2467 fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa); 2468 2469 sp->type = SRB_ELS_DCMD; 2470 sp->name = "ELS_DCMD"; 2471 sp->fcport = fcport; 2472 qla2x00_init_timer(sp, ELS_DCMD_TIMEOUT); 2473 elsio->timeout = qla2x00_els_dcmd_iocb_timeout; 2474 sp->done = qla2x00_els_dcmd_sp_done; 2475 sp->free = qla2x00_els_dcmd_sp_free; 2476 2477 elsio->u.els_logo.els_logo_pyld = dma_alloc_coherent(&ha->pdev->dev, 2478 DMA_POOL_SIZE, &elsio->u.els_logo.els_logo_pyld_dma, 2479 GFP_KERNEL); 2480 2481 if (!elsio->u.els_logo.els_logo_pyld) { 2482 sp->free(sp); 2483 return QLA_FUNCTION_FAILED; 2484 } 2485 2486 memset(&logo_pyld, 0, sizeof(struct els_logo_payload)); 2487 2488 elsio->u.els_logo.els_cmd = els_opcode; 2489 logo_pyld.opcode = els_opcode; 2490 logo_pyld.s_id[0] = vha->d_id.b.al_pa; 2491 logo_pyld.s_id[1] = vha->d_id.b.area; 2492 logo_pyld.s_id[2] = vha->d_id.b.domain; 2493 host_to_fcp_swap(logo_pyld.s_id, sizeof(uint32_t)); 2494 memcpy(&logo_pyld.wwpn, vha->port_name, WWN_SIZE); 2495 2496 memcpy(elsio->u.els_logo.els_logo_pyld, &logo_pyld, 2497 sizeof(struct els_logo_payload)); 2498 2499 rval = qla2x00_start_sp(sp); 2500 if (rval != QLA_SUCCESS) { 2501 sp->free(sp); 2502 return QLA_FUNCTION_FAILED; 2503 } 2504 2505 ql_dbg(ql_dbg_io, vha, 0x3074, 2506 "%s LOGO sent, hdl=%x, loopid=%x, portid=%02x%02x%02x.\n", 2507 sp->name, sp->handle, fcport->loop_id, fcport->d_id.b.domain, 2508 fcport->d_id.b.area, fcport->d_id.b.al_pa); 2509 2510 wait_for_completion(&elsio->u.els_logo.comp); 2511 2512 sp->free(sp); 2513 return rval; 2514 } 2515 2516 static void 2517 qla24xx_els_logo_iocb(srb_t *sp, struct els_entry_24xx *els_iocb) 2518 { 2519 scsi_qla_host_t *vha = sp->vha; 2520 struct srb_iocb *elsio = &sp->u.iocb_cmd; 2521 2522 els_iocb->entry_type = ELS_IOCB_TYPE; 2523 els_iocb->entry_count = 1; 2524 els_iocb->sys_define = 0; 2525 els_iocb->entry_status = 0; 2526 els_iocb->handle = sp->handle; 2527 els_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2528 els_iocb->tx_dsd_count = 1; 2529 els_iocb->vp_index = vha->vp_idx; 2530 els_iocb->sof_type = EST_SOFI3; 2531 els_iocb->rx_dsd_count = 0; 2532 els_iocb->opcode = elsio->u.els_logo.els_cmd; 2533 2534 els_iocb->port_id[0] = sp->fcport->d_id.b.al_pa; 2535 els_iocb->port_id[1] = sp->fcport->d_id.b.area; 2536 els_iocb->port_id[2] = sp->fcport->d_id.b.domain; 2537 els_iocb->control_flags = 0; 2538 2539 els_iocb->tx_byte_count = sizeof(struct els_logo_payload); 2540 els_iocb->tx_address[0] = 2541 cpu_to_le32(LSD(elsio->u.els_logo.els_logo_pyld_dma)); 2542 els_iocb->tx_address[1] = 2543 cpu_to_le32(MSD(elsio->u.els_logo.els_logo_pyld_dma)); 2544 els_iocb->tx_len = cpu_to_le32(sizeof(struct els_logo_payload)); 2545 2546 els_iocb->rx_byte_count = 0; 2547 els_iocb->rx_address[0] = 0; 2548 els_iocb->rx_address[1] = 0; 2549 els_iocb->rx_len = 0; 2550 2551 sp->vha->qla_stats.control_requests++; 2552 } 2553 2554 static void 2555 qla24xx_els_iocb(srb_t *sp, struct els_entry_24xx *els_iocb) 2556 { 2557 struct bsg_job *bsg_job = sp->u.bsg_job; 2558 struct fc_bsg_request *bsg_request = bsg_job->request; 2559 2560 els_iocb->entry_type = ELS_IOCB_TYPE; 2561 els_iocb->entry_count = 1; 2562 els_iocb->sys_define = 0; 2563 els_iocb->entry_status = 0; 2564 els_iocb->handle = sp->handle; 2565 els_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2566 els_iocb->tx_dsd_count = cpu_to_le16(bsg_job->request_payload.sg_cnt); 2567 els_iocb->vp_index = sp->vha->vp_idx; 2568 els_iocb->sof_type = EST_SOFI3; 2569 els_iocb->rx_dsd_count = cpu_to_le16(bsg_job->reply_payload.sg_cnt); 2570 2571 els_iocb->opcode = 2572 sp->type == SRB_ELS_CMD_RPT ? 2573 bsg_request->rqst_data.r_els.els_code : 2574 bsg_request->rqst_data.h_els.command_code; 2575 els_iocb->port_id[0] = sp->fcport->d_id.b.al_pa; 2576 els_iocb->port_id[1] = sp->fcport->d_id.b.area; 2577 els_iocb->port_id[2] = sp->fcport->d_id.b.domain; 2578 els_iocb->control_flags = 0; 2579 els_iocb->rx_byte_count = 2580 cpu_to_le32(bsg_job->reply_payload.payload_len); 2581 els_iocb->tx_byte_count = 2582 cpu_to_le32(bsg_job->request_payload.payload_len); 2583 2584 els_iocb->tx_address[0] = cpu_to_le32(LSD(sg_dma_address 2585 (bsg_job->request_payload.sg_list))); 2586 els_iocb->tx_address[1] = cpu_to_le32(MSD(sg_dma_address 2587 (bsg_job->request_payload.sg_list))); 2588 els_iocb->tx_len = cpu_to_le32(sg_dma_len 2589 (bsg_job->request_payload.sg_list)); 2590 2591 els_iocb->rx_address[0] = cpu_to_le32(LSD(sg_dma_address 2592 (bsg_job->reply_payload.sg_list))); 2593 els_iocb->rx_address[1] = cpu_to_le32(MSD(sg_dma_address 2594 (bsg_job->reply_payload.sg_list))); 2595 els_iocb->rx_len = cpu_to_le32(sg_dma_len 2596 (bsg_job->reply_payload.sg_list)); 2597 2598 sp->vha->qla_stats.control_requests++; 2599 } 2600 2601 static void 2602 qla2x00_ct_iocb(srb_t *sp, ms_iocb_entry_t *ct_iocb) 2603 { 2604 uint16_t avail_dsds; 2605 uint32_t *cur_dsd; 2606 struct scatterlist *sg; 2607 int index; 2608 uint16_t tot_dsds; 2609 scsi_qla_host_t *vha = sp->vha; 2610 struct qla_hw_data *ha = vha->hw; 2611 struct bsg_job *bsg_job = sp->u.bsg_job; 2612 int loop_iterartion = 0; 2613 int entry_count = 1; 2614 2615 memset(ct_iocb, 0, sizeof(ms_iocb_entry_t)); 2616 ct_iocb->entry_type = CT_IOCB_TYPE; 2617 ct_iocb->entry_status = 0; 2618 ct_iocb->handle1 = sp->handle; 2619 SET_TARGET_ID(ha, ct_iocb->loop_id, sp->fcport->loop_id); 2620 ct_iocb->status = cpu_to_le16(0); 2621 ct_iocb->control_flags = cpu_to_le16(0); 2622 ct_iocb->timeout = 0; 2623 ct_iocb->cmd_dsd_count = 2624 cpu_to_le16(bsg_job->request_payload.sg_cnt); 2625 ct_iocb->total_dsd_count = 2626 cpu_to_le16(bsg_job->request_payload.sg_cnt + 1); 2627 ct_iocb->req_bytecount = 2628 cpu_to_le32(bsg_job->request_payload.payload_len); 2629 ct_iocb->rsp_bytecount = 2630 cpu_to_le32(bsg_job->reply_payload.payload_len); 2631 2632 ct_iocb->dseg_req_address[0] = cpu_to_le32(LSD(sg_dma_address 2633 (bsg_job->request_payload.sg_list))); 2634 ct_iocb->dseg_req_address[1] = cpu_to_le32(MSD(sg_dma_address 2635 (bsg_job->request_payload.sg_list))); 2636 ct_iocb->dseg_req_length = ct_iocb->req_bytecount; 2637 2638 ct_iocb->dseg_rsp_address[0] = cpu_to_le32(LSD(sg_dma_address 2639 (bsg_job->reply_payload.sg_list))); 2640 ct_iocb->dseg_rsp_address[1] = cpu_to_le32(MSD(sg_dma_address 2641 (bsg_job->reply_payload.sg_list))); 2642 ct_iocb->dseg_rsp_length = ct_iocb->rsp_bytecount; 2643 2644 avail_dsds = 1; 2645 cur_dsd = (uint32_t *)ct_iocb->dseg_rsp_address; 2646 index = 0; 2647 tot_dsds = bsg_job->reply_payload.sg_cnt; 2648 2649 for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) { 2650 dma_addr_t sle_dma; 2651 cont_a64_entry_t *cont_pkt; 2652 2653 /* Allocate additional continuation packets? */ 2654 if (avail_dsds == 0) { 2655 /* 2656 * Five DSDs are available in the Cont. 2657 * Type 1 IOCB. 2658 */ 2659 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, 2660 vha->hw->req_q_map[0]); 2661 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 2662 avail_dsds = 5; 2663 entry_count++; 2664 } 2665 2666 sle_dma = sg_dma_address(sg); 2667 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 2668 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 2669 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 2670 loop_iterartion++; 2671 avail_dsds--; 2672 } 2673 ct_iocb->entry_count = entry_count; 2674 2675 sp->vha->qla_stats.control_requests++; 2676 } 2677 2678 static void 2679 qla24xx_ct_iocb(srb_t *sp, struct ct_entry_24xx *ct_iocb) 2680 { 2681 uint16_t avail_dsds; 2682 uint32_t *cur_dsd; 2683 struct scatterlist *sg; 2684 int index; 2685 uint16_t tot_dsds; 2686 scsi_qla_host_t *vha = sp->vha; 2687 struct qla_hw_data *ha = vha->hw; 2688 struct bsg_job *bsg_job = sp->u.bsg_job; 2689 int loop_iterartion = 0; 2690 int entry_count = 1; 2691 2692 ct_iocb->entry_type = CT_IOCB_TYPE; 2693 ct_iocb->entry_status = 0; 2694 ct_iocb->sys_define = 0; 2695 ct_iocb->handle = sp->handle; 2696 2697 ct_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2698 ct_iocb->vp_index = sp->vha->vp_idx; 2699 ct_iocb->comp_status = cpu_to_le16(0); 2700 2701 ct_iocb->cmd_dsd_count = 2702 cpu_to_le16(bsg_job->request_payload.sg_cnt); 2703 ct_iocb->timeout = 0; 2704 ct_iocb->rsp_dsd_count = 2705 cpu_to_le16(bsg_job->reply_payload.sg_cnt); 2706 ct_iocb->rsp_byte_count = 2707 cpu_to_le32(bsg_job->reply_payload.payload_len); 2708 ct_iocb->cmd_byte_count = 2709 cpu_to_le32(bsg_job->request_payload.payload_len); 2710 ct_iocb->dseg_0_address[0] = cpu_to_le32(LSD(sg_dma_address 2711 (bsg_job->request_payload.sg_list))); 2712 ct_iocb->dseg_0_address[1] = cpu_to_le32(MSD(sg_dma_address 2713 (bsg_job->request_payload.sg_list))); 2714 ct_iocb->dseg_0_len = cpu_to_le32(sg_dma_len 2715 (bsg_job->request_payload.sg_list)); 2716 2717 avail_dsds = 1; 2718 cur_dsd = (uint32_t *)ct_iocb->dseg_1_address; 2719 index = 0; 2720 tot_dsds = bsg_job->reply_payload.sg_cnt; 2721 2722 for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) { 2723 dma_addr_t sle_dma; 2724 cont_a64_entry_t *cont_pkt; 2725 2726 /* Allocate additional continuation packets? */ 2727 if (avail_dsds == 0) { 2728 /* 2729 * Five DSDs are available in the Cont. 2730 * Type 1 IOCB. 2731 */ 2732 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, 2733 ha->req_q_map[0]); 2734 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 2735 avail_dsds = 5; 2736 entry_count++; 2737 } 2738 2739 sle_dma = sg_dma_address(sg); 2740 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 2741 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 2742 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 2743 loop_iterartion++; 2744 avail_dsds--; 2745 } 2746 ct_iocb->entry_count = entry_count; 2747 } 2748 2749 /* 2750 * qla82xx_start_scsi() - Send a SCSI command to the ISP 2751 * @sp: command to send to the ISP 2752 * 2753 * Returns non-zero if a failure occurred, else zero. 2754 */ 2755 int 2756 qla82xx_start_scsi(srb_t *sp) 2757 { 2758 int nseg; 2759 unsigned long flags; 2760 struct scsi_cmnd *cmd; 2761 uint32_t *clr_ptr; 2762 uint32_t index; 2763 uint32_t handle; 2764 uint16_t cnt; 2765 uint16_t req_cnt; 2766 uint16_t tot_dsds; 2767 struct device_reg_82xx __iomem *reg; 2768 uint32_t dbval; 2769 uint32_t *fcp_dl; 2770 uint8_t additional_cdb_len; 2771 struct ct6_dsd *ctx; 2772 struct scsi_qla_host *vha = sp->vha; 2773 struct qla_hw_data *ha = vha->hw; 2774 struct req_que *req = NULL; 2775 struct rsp_que *rsp = NULL; 2776 2777 /* Setup device pointers. */ 2778 reg = &ha->iobase->isp82; 2779 cmd = GET_CMD_SP(sp); 2780 req = vha->req; 2781 rsp = ha->rsp_q_map[0]; 2782 2783 /* So we know we haven't pci_map'ed anything yet */ 2784 tot_dsds = 0; 2785 2786 dbval = 0x04 | (ha->portnum << 5); 2787 2788 /* Send marker if required */ 2789 if (vha->marker_needed != 0) { 2790 if (qla2x00_marker(vha, req, 2791 rsp, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) { 2792 ql_log(ql_log_warn, vha, 0x300c, 2793 "qla2x00_marker failed for cmd=%p.\n", cmd); 2794 return QLA_FUNCTION_FAILED; 2795 } 2796 vha->marker_needed = 0; 2797 } 2798 2799 /* Acquire ring specific lock */ 2800 spin_lock_irqsave(&ha->hardware_lock, flags); 2801 2802 /* Check for room in outstanding command list. */ 2803 handle = req->current_outstanding_cmd; 2804 for (index = 1; index < req->num_outstanding_cmds; index++) { 2805 handle++; 2806 if (handle == req->num_outstanding_cmds) 2807 handle = 1; 2808 if (!req->outstanding_cmds[handle]) 2809 break; 2810 } 2811 if (index == req->num_outstanding_cmds) 2812 goto queuing_error; 2813 2814 /* Map the sg table so we have an accurate count of sg entries needed */ 2815 if (scsi_sg_count(cmd)) { 2816 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 2817 scsi_sg_count(cmd), cmd->sc_data_direction); 2818 if (unlikely(!nseg)) 2819 goto queuing_error; 2820 } else 2821 nseg = 0; 2822 2823 tot_dsds = nseg; 2824 2825 if (tot_dsds > ql2xshiftctondsd) { 2826 struct cmd_type_6 *cmd_pkt; 2827 uint16_t more_dsd_lists = 0; 2828 struct dsd_dma *dsd_ptr; 2829 uint16_t i; 2830 2831 more_dsd_lists = qla24xx_calc_dsd_lists(tot_dsds); 2832 if ((more_dsd_lists + ha->gbl_dsd_inuse) >= NUM_DSD_CHAIN) { 2833 ql_dbg(ql_dbg_io, vha, 0x300d, 2834 "Num of DSD list %d is than %d for cmd=%p.\n", 2835 more_dsd_lists + ha->gbl_dsd_inuse, NUM_DSD_CHAIN, 2836 cmd); 2837 goto queuing_error; 2838 } 2839 2840 if (more_dsd_lists <= ha->gbl_dsd_avail) 2841 goto sufficient_dsds; 2842 else 2843 more_dsd_lists -= ha->gbl_dsd_avail; 2844 2845 for (i = 0; i < more_dsd_lists; i++) { 2846 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC); 2847 if (!dsd_ptr) { 2848 ql_log(ql_log_fatal, vha, 0x300e, 2849 "Failed to allocate memory for dsd_dma " 2850 "for cmd=%p.\n", cmd); 2851 goto queuing_error; 2852 } 2853 2854 dsd_ptr->dsd_addr = dma_pool_alloc(ha->dl_dma_pool, 2855 GFP_ATOMIC, &dsd_ptr->dsd_list_dma); 2856 if (!dsd_ptr->dsd_addr) { 2857 kfree(dsd_ptr); 2858 ql_log(ql_log_fatal, vha, 0x300f, 2859 "Failed to allocate memory for dsd_addr " 2860 "for cmd=%p.\n", cmd); 2861 goto queuing_error; 2862 } 2863 list_add_tail(&dsd_ptr->list, &ha->gbl_dsd_list); 2864 ha->gbl_dsd_avail++; 2865 } 2866 2867 sufficient_dsds: 2868 req_cnt = 1; 2869 2870 if (req->cnt < (req_cnt + 2)) { 2871 cnt = (uint16_t)RD_REG_DWORD_RELAXED( 2872 ®->req_q_out[0]); 2873 if (req->ring_index < cnt) 2874 req->cnt = cnt - req->ring_index; 2875 else 2876 req->cnt = req->length - 2877 (req->ring_index - cnt); 2878 if (req->cnt < (req_cnt + 2)) 2879 goto queuing_error; 2880 } 2881 2882 ctx = sp->u.scmd.ctx = 2883 mempool_alloc(ha->ctx_mempool, GFP_ATOMIC); 2884 if (!ctx) { 2885 ql_log(ql_log_fatal, vha, 0x3010, 2886 "Failed to allocate ctx for cmd=%p.\n", cmd); 2887 goto queuing_error; 2888 } 2889 2890 memset(ctx, 0, sizeof(struct ct6_dsd)); 2891 ctx->fcp_cmnd = dma_pool_alloc(ha->fcp_cmnd_dma_pool, 2892 GFP_ATOMIC, &ctx->fcp_cmnd_dma); 2893 if (!ctx->fcp_cmnd) { 2894 ql_log(ql_log_fatal, vha, 0x3011, 2895 "Failed to allocate fcp_cmnd for cmd=%p.\n", cmd); 2896 goto queuing_error; 2897 } 2898 2899 /* Initialize the DSD list and dma handle */ 2900 INIT_LIST_HEAD(&ctx->dsd_list); 2901 ctx->dsd_use_cnt = 0; 2902 2903 if (cmd->cmd_len > 16) { 2904 additional_cdb_len = cmd->cmd_len - 16; 2905 if ((cmd->cmd_len % 4) != 0) { 2906 /* SCSI command bigger than 16 bytes must be 2907 * multiple of 4 2908 */ 2909 ql_log(ql_log_warn, vha, 0x3012, 2910 "scsi cmd len %d not multiple of 4 " 2911 "for cmd=%p.\n", cmd->cmd_len, cmd); 2912 goto queuing_error_fcp_cmnd; 2913 } 2914 ctx->fcp_cmnd_len = 12 + cmd->cmd_len + 4; 2915 } else { 2916 additional_cdb_len = 0; 2917 ctx->fcp_cmnd_len = 12 + 16 + 4; 2918 } 2919 2920 cmd_pkt = (struct cmd_type_6 *)req->ring_ptr; 2921 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 2922 2923 /* Zero out remaining portion of packet. */ 2924 /* tagged queuing modifier -- default is TSK_SIMPLE (0). */ 2925 clr_ptr = (uint32_t *)cmd_pkt + 2; 2926 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 2927 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 2928 2929 /* Set NPORT-ID and LUN number*/ 2930 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 2931 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 2932 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 2933 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 2934 cmd_pkt->vp_index = sp->vha->vp_idx; 2935 2936 /* Build IOCB segments */ 2937 if (qla24xx_build_scsi_type_6_iocbs(sp, cmd_pkt, tot_dsds)) 2938 goto queuing_error_fcp_cmnd; 2939 2940 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 2941 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 2942 2943 /* build FCP_CMND IU */ 2944 memset(ctx->fcp_cmnd, 0, sizeof(struct fcp_cmnd)); 2945 int_to_scsilun(cmd->device->lun, &ctx->fcp_cmnd->lun); 2946 ctx->fcp_cmnd->additional_cdb_len = additional_cdb_len; 2947 2948 if (cmd->sc_data_direction == DMA_TO_DEVICE) 2949 ctx->fcp_cmnd->additional_cdb_len |= 1; 2950 else if (cmd->sc_data_direction == DMA_FROM_DEVICE) 2951 ctx->fcp_cmnd->additional_cdb_len |= 2; 2952 2953 /* Populate the FCP_PRIO. */ 2954 if (ha->flags.fcp_prio_enabled) 2955 ctx->fcp_cmnd->task_attribute |= 2956 sp->fcport->fcp_prio << 3; 2957 2958 memcpy(ctx->fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len); 2959 2960 fcp_dl = (uint32_t *)(ctx->fcp_cmnd->cdb + 16 + 2961 additional_cdb_len); 2962 *fcp_dl = htonl((uint32_t)scsi_bufflen(cmd)); 2963 2964 cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(ctx->fcp_cmnd_len); 2965 cmd_pkt->fcp_cmnd_dseg_address[0] = 2966 cpu_to_le32(LSD(ctx->fcp_cmnd_dma)); 2967 cmd_pkt->fcp_cmnd_dseg_address[1] = 2968 cpu_to_le32(MSD(ctx->fcp_cmnd_dma)); 2969 2970 sp->flags |= SRB_FCP_CMND_DMA_VALID; 2971 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 2972 /* Set total data segment count. */ 2973 cmd_pkt->entry_count = (uint8_t)req_cnt; 2974 /* Specify response queue number where 2975 * completion should happen 2976 */ 2977 cmd_pkt->entry_status = (uint8_t) rsp->id; 2978 } else { 2979 struct cmd_type_7 *cmd_pkt; 2980 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds); 2981 if (req->cnt < (req_cnt + 2)) { 2982 cnt = (uint16_t)RD_REG_DWORD_RELAXED( 2983 ®->req_q_out[0]); 2984 if (req->ring_index < cnt) 2985 req->cnt = cnt - req->ring_index; 2986 else 2987 req->cnt = req->length - 2988 (req->ring_index - cnt); 2989 } 2990 if (req->cnt < (req_cnt + 2)) 2991 goto queuing_error; 2992 2993 cmd_pkt = (struct cmd_type_7 *)req->ring_ptr; 2994 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 2995 2996 /* Zero out remaining portion of packet. */ 2997 /* tagged queuing modifier -- default is TSK_SIMPLE (0).*/ 2998 clr_ptr = (uint32_t *)cmd_pkt + 2; 2999 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 3000 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 3001 3002 /* Set NPORT-ID and LUN number*/ 3003 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 3004 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 3005 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 3006 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 3007 cmd_pkt->vp_index = sp->vha->vp_idx; 3008 3009 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun); 3010 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, 3011 sizeof(cmd_pkt->lun)); 3012 3013 /* Populate the FCP_PRIO. */ 3014 if (ha->flags.fcp_prio_enabled) 3015 cmd_pkt->task |= sp->fcport->fcp_prio << 3; 3016 3017 /* Load SCSI command packet. */ 3018 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len); 3019 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb)); 3020 3021 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 3022 3023 /* Build IOCB segments */ 3024 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds, req); 3025 3026 /* Set total data segment count. */ 3027 cmd_pkt->entry_count = (uint8_t)req_cnt; 3028 /* Specify response queue number where 3029 * completion should happen. 3030 */ 3031 cmd_pkt->entry_status = (uint8_t) rsp->id; 3032 3033 } 3034 /* Build command packet. */ 3035 req->current_outstanding_cmd = handle; 3036 req->outstanding_cmds[handle] = sp; 3037 sp->handle = handle; 3038 cmd->host_scribble = (unsigned char *)(unsigned long)handle; 3039 req->cnt -= req_cnt; 3040 wmb(); 3041 3042 /* Adjust ring index. */ 3043 req->ring_index++; 3044 if (req->ring_index == req->length) { 3045 req->ring_index = 0; 3046 req->ring_ptr = req->ring; 3047 } else 3048 req->ring_ptr++; 3049 3050 sp->flags |= SRB_DMA_VALID; 3051 3052 /* Set chip new ring index. */ 3053 /* write, read and verify logic */ 3054 dbval = dbval | (req->id << 8) | (req->ring_index << 16); 3055 if (ql2xdbwr) 3056 qla82xx_wr_32(ha, (uintptr_t __force)ha->nxdb_wr_ptr, dbval); 3057 else { 3058 WRT_REG_DWORD(ha->nxdb_wr_ptr, dbval); 3059 wmb(); 3060 while (RD_REG_DWORD(ha->nxdb_rd_ptr) != dbval) { 3061 WRT_REG_DWORD(ha->nxdb_wr_ptr, dbval); 3062 wmb(); 3063 } 3064 } 3065 3066 /* Manage unprocessed RIO/ZIO commands in response queue. */ 3067 if (vha->flags.process_response_queue && 3068 rsp->ring_ptr->signature != RESPONSE_PROCESSED) 3069 qla24xx_process_response_queue(vha, rsp); 3070 3071 spin_unlock_irqrestore(&ha->hardware_lock, flags); 3072 return QLA_SUCCESS; 3073 3074 queuing_error_fcp_cmnd: 3075 dma_pool_free(ha->fcp_cmnd_dma_pool, ctx->fcp_cmnd, ctx->fcp_cmnd_dma); 3076 queuing_error: 3077 if (tot_dsds) 3078 scsi_dma_unmap(cmd); 3079 3080 if (sp->u.scmd.ctx) { 3081 mempool_free(sp->u.scmd.ctx, ha->ctx_mempool); 3082 sp->u.scmd.ctx = NULL; 3083 } 3084 spin_unlock_irqrestore(&ha->hardware_lock, flags); 3085 3086 return QLA_FUNCTION_FAILED; 3087 } 3088 3089 static void 3090 qla24xx_abort_iocb(srb_t *sp, struct abort_entry_24xx *abt_iocb) 3091 { 3092 struct srb_iocb *aio = &sp->u.iocb_cmd; 3093 scsi_qla_host_t *vha = sp->vha; 3094 struct req_que *req = vha->req; 3095 3096 memset(abt_iocb, 0, sizeof(struct abort_entry_24xx)); 3097 abt_iocb->entry_type = ABORT_IOCB_TYPE; 3098 abt_iocb->entry_count = 1; 3099 abt_iocb->handle = cpu_to_le32(MAKE_HANDLE(req->id, sp->handle)); 3100 abt_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id); 3101 abt_iocb->handle_to_abort = 3102 cpu_to_le32(MAKE_HANDLE(req->id, aio->u.abt.cmd_hndl)); 3103 abt_iocb->port_id[0] = sp->fcport->d_id.b.al_pa; 3104 abt_iocb->port_id[1] = sp->fcport->d_id.b.area; 3105 abt_iocb->port_id[2] = sp->fcport->d_id.b.domain; 3106 abt_iocb->vp_index = vha->vp_idx; 3107 abt_iocb->req_que_no = cpu_to_le16(req->id); 3108 /* Send the command to the firmware */ 3109 wmb(); 3110 } 3111 3112 static void 3113 qla2x00_mb_iocb(srb_t *sp, struct mbx_24xx_entry *mbx) 3114 { 3115 int i, sz; 3116 3117 mbx->entry_type = MBX_IOCB_TYPE; 3118 mbx->handle = sp->handle; 3119 sz = min(ARRAY_SIZE(mbx->mb), ARRAY_SIZE(sp->u.iocb_cmd.u.mbx.out_mb)); 3120 3121 for (i = 0; i < sz; i++) 3122 mbx->mb[i] = cpu_to_le16(sp->u.iocb_cmd.u.mbx.out_mb[i]); 3123 } 3124 3125 static void 3126 qla2x00_ctpthru_cmd_iocb(srb_t *sp, struct ct_entry_24xx *ct_pkt) 3127 { 3128 sp->u.iocb_cmd.u.ctarg.iocb = ct_pkt; 3129 qla24xx_prep_ms_iocb(sp->vha, &sp->u.iocb_cmd.u.ctarg); 3130 ct_pkt->handle = sp->handle; 3131 } 3132 3133 static void qla2x00_send_notify_ack_iocb(srb_t *sp, 3134 struct nack_to_isp *nack) 3135 { 3136 struct imm_ntfy_from_isp *ntfy = sp->u.iocb_cmd.u.nack.ntfy; 3137 3138 nack->entry_type = NOTIFY_ACK_TYPE; 3139 nack->entry_count = 1; 3140 nack->ox_id = ntfy->ox_id; 3141 3142 nack->u.isp24.handle = sp->handle; 3143 nack->u.isp24.nport_handle = ntfy->u.isp24.nport_handle; 3144 if (le16_to_cpu(ntfy->u.isp24.status) == IMM_NTFY_ELS) { 3145 nack->u.isp24.flags = ntfy->u.isp24.flags & 3146 cpu_to_le32(NOTIFY24XX_FLAGS_PUREX_IOCB); 3147 } 3148 nack->u.isp24.srr_rx_id = ntfy->u.isp24.srr_rx_id; 3149 nack->u.isp24.status = ntfy->u.isp24.status; 3150 nack->u.isp24.status_subcode = ntfy->u.isp24.status_subcode; 3151 nack->u.isp24.fw_handle = ntfy->u.isp24.fw_handle; 3152 nack->u.isp24.exchange_address = ntfy->u.isp24.exchange_address; 3153 nack->u.isp24.srr_rel_offs = ntfy->u.isp24.srr_rel_offs; 3154 nack->u.isp24.srr_ui = ntfy->u.isp24.srr_ui; 3155 nack->u.isp24.srr_flags = 0; 3156 nack->u.isp24.srr_reject_code = 0; 3157 nack->u.isp24.srr_reject_code_expl = 0; 3158 nack->u.isp24.vp_index = ntfy->u.isp24.vp_index; 3159 } 3160 3161 /* 3162 * Build NVME LS request 3163 */ 3164 static int 3165 qla_nvme_ls(srb_t *sp, struct pt_ls4_request *cmd_pkt) 3166 { 3167 struct srb_iocb *nvme; 3168 int rval = QLA_SUCCESS; 3169 3170 nvme = &sp->u.iocb_cmd; 3171 cmd_pkt->entry_type = PT_LS4_REQUEST; 3172 cmd_pkt->entry_count = 1; 3173 cmd_pkt->control_flags = CF_LS4_ORIGINATOR << CF_LS4_SHIFT; 3174 3175 cmd_pkt->timeout = cpu_to_le16(nvme->u.nvme.timeout_sec); 3176 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 3177 cmd_pkt->vp_index = sp->fcport->vha->vp_idx; 3178 3179 cmd_pkt->tx_dseg_count = 1; 3180 cmd_pkt->tx_byte_count = nvme->u.nvme.cmd_len; 3181 cmd_pkt->dseg0_len = nvme->u.nvme.cmd_len; 3182 cmd_pkt->dseg0_address[0] = cpu_to_le32(LSD(nvme->u.nvme.cmd_dma)); 3183 cmd_pkt->dseg0_address[1] = cpu_to_le32(MSD(nvme->u.nvme.cmd_dma)); 3184 3185 cmd_pkt->rx_dseg_count = 1; 3186 cmd_pkt->rx_byte_count = nvme->u.nvme.rsp_len; 3187 cmd_pkt->dseg1_len = nvme->u.nvme.rsp_len; 3188 cmd_pkt->dseg1_address[0] = cpu_to_le32(LSD(nvme->u.nvme.rsp_dma)); 3189 cmd_pkt->dseg1_address[1] = cpu_to_le32(MSD(nvme->u.nvme.rsp_dma)); 3190 3191 return rval; 3192 } 3193 3194 int 3195 qla2x00_start_sp(srb_t *sp) 3196 { 3197 int rval; 3198 scsi_qla_host_t *vha = sp->vha; 3199 struct qla_hw_data *ha = vha->hw; 3200 void *pkt; 3201 unsigned long flags; 3202 3203 rval = QLA_FUNCTION_FAILED; 3204 spin_lock_irqsave(&ha->hardware_lock, flags); 3205 pkt = qla2x00_alloc_iocbs(vha, sp); 3206 if (!pkt) { 3207 ql_log(ql_log_warn, vha, 0x700c, 3208 "qla2x00_alloc_iocbs failed.\n"); 3209 goto done; 3210 } 3211 3212 rval = QLA_SUCCESS; 3213 switch (sp->type) { 3214 case SRB_LOGIN_CMD: 3215 IS_FWI2_CAPABLE(ha) ? 3216 qla24xx_login_iocb(sp, pkt) : 3217 qla2x00_login_iocb(sp, pkt); 3218 break; 3219 case SRB_PRLI_CMD: 3220 qla24xx_prli_iocb(sp, pkt); 3221 break; 3222 case SRB_LOGOUT_CMD: 3223 IS_FWI2_CAPABLE(ha) ? 3224 qla24xx_logout_iocb(sp, pkt) : 3225 qla2x00_logout_iocb(sp, pkt); 3226 break; 3227 case SRB_ELS_CMD_RPT: 3228 case SRB_ELS_CMD_HST: 3229 qla24xx_els_iocb(sp, pkt); 3230 break; 3231 case SRB_CT_CMD: 3232 IS_FWI2_CAPABLE(ha) ? 3233 qla24xx_ct_iocb(sp, pkt) : 3234 qla2x00_ct_iocb(sp, pkt); 3235 break; 3236 case SRB_ADISC_CMD: 3237 IS_FWI2_CAPABLE(ha) ? 3238 qla24xx_adisc_iocb(sp, pkt) : 3239 qla2x00_adisc_iocb(sp, pkt); 3240 break; 3241 case SRB_TM_CMD: 3242 IS_QLAFX00(ha) ? 3243 qlafx00_tm_iocb(sp, pkt) : 3244 qla24xx_tm_iocb(sp, pkt); 3245 break; 3246 case SRB_FXIOCB_DCMD: 3247 case SRB_FXIOCB_BCMD: 3248 qlafx00_fxdisc_iocb(sp, pkt); 3249 break; 3250 case SRB_NVME_LS: 3251 qla_nvme_ls(sp, pkt); 3252 break; 3253 case SRB_ABT_CMD: 3254 IS_QLAFX00(ha) ? 3255 qlafx00_abort_iocb(sp, pkt) : 3256 qla24xx_abort_iocb(sp, pkt); 3257 break; 3258 case SRB_ELS_DCMD: 3259 qla24xx_els_logo_iocb(sp, pkt); 3260 break; 3261 case SRB_CT_PTHRU_CMD: 3262 qla2x00_ctpthru_cmd_iocb(sp, pkt); 3263 break; 3264 case SRB_MB_IOCB: 3265 qla2x00_mb_iocb(sp, pkt); 3266 break; 3267 case SRB_NACK_PLOGI: 3268 case SRB_NACK_PRLI: 3269 case SRB_NACK_LOGO: 3270 qla2x00_send_notify_ack_iocb(sp, pkt); 3271 break; 3272 default: 3273 break; 3274 } 3275 3276 wmb(); 3277 qla2x00_start_iocbs(vha, ha->req_q_map[0]); 3278 done: 3279 spin_unlock_irqrestore(&ha->hardware_lock, flags); 3280 return rval; 3281 } 3282 3283 static void 3284 qla25xx_build_bidir_iocb(srb_t *sp, struct scsi_qla_host *vha, 3285 struct cmd_bidir *cmd_pkt, uint32_t tot_dsds) 3286 { 3287 uint16_t avail_dsds; 3288 uint32_t *cur_dsd; 3289 uint32_t req_data_len = 0; 3290 uint32_t rsp_data_len = 0; 3291 struct scatterlist *sg; 3292 int index; 3293 int entry_count = 1; 3294 struct bsg_job *bsg_job = sp->u.bsg_job; 3295 3296 /*Update entry type to indicate bidir command */ 3297 *((uint32_t *)(&cmd_pkt->entry_type)) = 3298 cpu_to_le32(COMMAND_BIDIRECTIONAL); 3299 3300 /* Set the transfer direction, in this set both flags 3301 * Also set the BD_WRAP_BACK flag, firmware will take care 3302 * assigning DID=SID for outgoing pkts. 3303 */ 3304 cmd_pkt->wr_dseg_count = cpu_to_le16(bsg_job->request_payload.sg_cnt); 3305 cmd_pkt->rd_dseg_count = cpu_to_le16(bsg_job->reply_payload.sg_cnt); 3306 cmd_pkt->control_flags = cpu_to_le16(BD_WRITE_DATA | BD_READ_DATA | 3307 BD_WRAP_BACK); 3308 3309 req_data_len = rsp_data_len = bsg_job->request_payload.payload_len; 3310 cmd_pkt->wr_byte_count = cpu_to_le32(req_data_len); 3311 cmd_pkt->rd_byte_count = cpu_to_le32(rsp_data_len); 3312 cmd_pkt->timeout = cpu_to_le16(qla2x00_get_async_timeout(vha) + 2); 3313 3314 vha->bidi_stats.transfer_bytes += req_data_len; 3315 vha->bidi_stats.io_count++; 3316 3317 vha->qla_stats.output_bytes += req_data_len; 3318 vha->qla_stats.output_requests++; 3319 3320 /* Only one dsd is available for bidirectional IOCB, remaining dsds 3321 * are bundled in continuation iocb 3322 */ 3323 avail_dsds = 1; 3324 cur_dsd = (uint32_t *)&cmd_pkt->fcp_data_dseg_address; 3325 3326 index = 0; 3327 3328 for_each_sg(bsg_job->request_payload.sg_list, sg, 3329 bsg_job->request_payload.sg_cnt, index) { 3330 dma_addr_t sle_dma; 3331 cont_a64_entry_t *cont_pkt; 3332 3333 /* Allocate additional continuation packets */ 3334 if (avail_dsds == 0) { 3335 /* Continuation type 1 IOCB can accomodate 3336 * 5 DSDS 3337 */ 3338 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req); 3339 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 3340 avail_dsds = 5; 3341 entry_count++; 3342 } 3343 sle_dma = sg_dma_address(sg); 3344 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 3345 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 3346 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 3347 avail_dsds--; 3348 } 3349 /* For read request DSD will always goes to continuation IOCB 3350 * and follow the write DSD. If there is room on the current IOCB 3351 * then it is added to that IOCB else new continuation IOCB is 3352 * allocated. 3353 */ 3354 for_each_sg(bsg_job->reply_payload.sg_list, sg, 3355 bsg_job->reply_payload.sg_cnt, index) { 3356 dma_addr_t sle_dma; 3357 cont_a64_entry_t *cont_pkt; 3358 3359 /* Allocate additional continuation packets */ 3360 if (avail_dsds == 0) { 3361 /* Continuation type 1 IOCB can accomodate 3362 * 5 DSDS 3363 */ 3364 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req); 3365 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address; 3366 avail_dsds = 5; 3367 entry_count++; 3368 } 3369 sle_dma = sg_dma_address(sg); 3370 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 3371 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 3372 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 3373 avail_dsds--; 3374 } 3375 /* This value should be same as number of IOCB required for this cmd */ 3376 cmd_pkt->entry_count = entry_count; 3377 } 3378 3379 int 3380 qla2x00_start_bidir(srb_t *sp, struct scsi_qla_host *vha, uint32_t tot_dsds) 3381 { 3382 3383 struct qla_hw_data *ha = vha->hw; 3384 unsigned long flags; 3385 uint32_t handle; 3386 uint32_t index; 3387 uint16_t req_cnt; 3388 uint16_t cnt; 3389 uint32_t *clr_ptr; 3390 struct cmd_bidir *cmd_pkt = NULL; 3391 struct rsp_que *rsp; 3392 struct req_que *req; 3393 int rval = EXT_STATUS_OK; 3394 3395 rval = QLA_SUCCESS; 3396 3397 rsp = ha->rsp_q_map[0]; 3398 req = vha->req; 3399 3400 /* Send marker if required */ 3401 if (vha->marker_needed != 0) { 3402 if (qla2x00_marker(vha, req, 3403 rsp, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) 3404 return EXT_STATUS_MAILBOX; 3405 vha->marker_needed = 0; 3406 } 3407 3408 /* Acquire ring specific lock */ 3409 spin_lock_irqsave(&ha->hardware_lock, flags); 3410 3411 /* Check for room in outstanding command list. */ 3412 handle = req->current_outstanding_cmd; 3413 for (index = 1; index < req->num_outstanding_cmds; index++) { 3414 handle++; 3415 if (handle == req->num_outstanding_cmds) 3416 handle = 1; 3417 if (!req->outstanding_cmds[handle]) 3418 break; 3419 } 3420 3421 if (index == req->num_outstanding_cmds) { 3422 rval = EXT_STATUS_BUSY; 3423 goto queuing_error; 3424 } 3425 3426 /* Calculate number of IOCB required */ 3427 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds); 3428 3429 /* Check for room on request queue. */ 3430 if (req->cnt < req_cnt + 2) { 3431 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr : 3432 RD_REG_DWORD_RELAXED(req->req_q_out); 3433 if (req->ring_index < cnt) 3434 req->cnt = cnt - req->ring_index; 3435 else 3436 req->cnt = req->length - 3437 (req->ring_index - cnt); 3438 } 3439 if (req->cnt < req_cnt + 2) { 3440 rval = EXT_STATUS_BUSY; 3441 goto queuing_error; 3442 } 3443 3444 cmd_pkt = (struct cmd_bidir *)req->ring_ptr; 3445 cmd_pkt->handle = MAKE_HANDLE(req->id, handle); 3446 3447 /* Zero out remaining portion of packet. */ 3448 /* tagged queuing modifier -- default is TSK_SIMPLE (0).*/ 3449 clr_ptr = (uint32_t *)cmd_pkt + 2; 3450 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 3451 3452 /* Set NPORT-ID (of vha)*/ 3453 cmd_pkt->nport_handle = cpu_to_le16(vha->self_login_loop_id); 3454 cmd_pkt->port_id[0] = vha->d_id.b.al_pa; 3455 cmd_pkt->port_id[1] = vha->d_id.b.area; 3456 cmd_pkt->port_id[2] = vha->d_id.b.domain; 3457 3458 qla25xx_build_bidir_iocb(sp, vha, cmd_pkt, tot_dsds); 3459 cmd_pkt->entry_status = (uint8_t) rsp->id; 3460 /* Build command packet. */ 3461 req->current_outstanding_cmd = handle; 3462 req->outstanding_cmds[handle] = sp; 3463 sp->handle = handle; 3464 req->cnt -= req_cnt; 3465 3466 /* Send the command to the firmware */ 3467 wmb(); 3468 qla2x00_start_iocbs(vha, req); 3469 queuing_error: 3470 spin_unlock_irqrestore(&ha->hardware_lock, flags); 3471 return rval; 3472 } 3473