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