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