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