1 /* 2 * QLogic Fibre Channel HBA Driver 3 * Copyright (c) 2003-2008 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 request_t *qla2x00_req_pkt(scsi_qla_host_t *ha); 15 static void qla2x00_isp_cmd(scsi_qla_host_t *ha); 16 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->ha->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->ha->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(scsi_qla_host_t *ha) 95 { 96 cont_entry_t *cont_pkt; 97 98 /* Adjust ring index. */ 99 ha->req_ring_index++; 100 if (ha->req_ring_index == ha->request_q_length) { 101 ha->req_ring_index = 0; 102 ha->request_ring_ptr = ha->request_ring; 103 } else { 104 ha->request_ring_ptr++; 105 } 106 107 cont_pkt = (cont_entry_t *)ha->request_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 *ha) 124 { 125 cont_a64_entry_t *cont_pkt; 126 127 /* Adjust ring index. */ 128 ha->req_ring_index++; 129 if (ha->req_ring_index == ha->request_q_length) { 130 ha->req_ring_index = 0; 131 ha->request_ring_ptr = ha->request_ring; 132 } else { 133 ha->request_ring_ptr++; 134 } 135 136 cont_pkt = (cont_a64_entry_t *)ha->request_ring_ptr; 137 138 /* Load packet defaults. */ 139 *((uint32_t *)(&cont_pkt->entry_type)) = 140 __constant_cpu_to_le32(CONTINUE_A64_TYPE); 141 142 return (cont_pkt); 143 } 144 145 /** 146 * qla2x00_build_scsi_iocbs_32() - Build IOCB command utilizing 32bit 147 * capable IOCB types. 148 * 149 * @sp: SRB command to process 150 * @cmd_pkt: Command type 2 IOCB 151 * @tot_dsds: Total number of segments to transfer 152 */ 153 void qla2x00_build_scsi_iocbs_32(srb_t *sp, cmd_entry_t *cmd_pkt, 154 uint16_t tot_dsds) 155 { 156 uint16_t avail_dsds; 157 uint32_t *cur_dsd; 158 scsi_qla_host_t *ha; 159 struct scsi_cmnd *cmd; 160 struct scatterlist *sg; 161 int i; 162 163 cmd = sp->cmd; 164 165 /* Update entry type to indicate Command Type 2 IOCB */ 166 *((uint32_t *)(&cmd_pkt->entry_type)) = 167 __constant_cpu_to_le32(COMMAND_TYPE); 168 169 /* No data transfer */ 170 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 171 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 172 return; 173 } 174 175 ha = sp->ha; 176 177 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp)); 178 179 /* Three DSDs are available in the Command Type 2 IOCB */ 180 avail_dsds = 3; 181 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 182 183 /* Load data segments */ 184 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 185 cont_entry_t *cont_pkt; 186 187 /* Allocate additional continuation packets? */ 188 if (avail_dsds == 0) { 189 /* 190 * Seven DSDs are available in the Continuation 191 * Type 0 IOCB. 192 */ 193 cont_pkt = qla2x00_prep_cont_type0_iocb(ha); 194 cur_dsd = (uint32_t *)&cont_pkt->dseg_0_address; 195 avail_dsds = 7; 196 } 197 198 *cur_dsd++ = cpu_to_le32(sg_dma_address(sg)); 199 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 200 avail_dsds--; 201 } 202 } 203 204 /** 205 * qla2x00_build_scsi_iocbs_64() - Build IOCB command utilizing 64bit 206 * capable IOCB types. 207 * 208 * @sp: SRB command to process 209 * @cmd_pkt: Command type 3 IOCB 210 * @tot_dsds: Total number of segments to transfer 211 */ 212 void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt, 213 uint16_t tot_dsds) 214 { 215 uint16_t avail_dsds; 216 uint32_t *cur_dsd; 217 scsi_qla_host_t *ha; 218 struct scsi_cmnd *cmd; 219 struct scatterlist *sg; 220 int i; 221 222 cmd = sp->cmd; 223 224 /* Update entry type to indicate Command Type 3 IOCB */ 225 *((uint32_t *)(&cmd_pkt->entry_type)) = 226 __constant_cpu_to_le32(COMMAND_A64_TYPE); 227 228 /* No data transfer */ 229 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 230 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 231 return; 232 } 233 234 ha = sp->ha; 235 236 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp)); 237 238 /* Two DSDs are available in the Command Type 3 IOCB */ 239 avail_dsds = 2; 240 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 241 242 /* Load data segments */ 243 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 244 dma_addr_t sle_dma; 245 cont_a64_entry_t *cont_pkt; 246 247 /* Allocate additional continuation packets? */ 248 if (avail_dsds == 0) { 249 /* 250 * Five DSDs are available in the Continuation 251 * Type 1 IOCB. 252 */ 253 cont_pkt = qla2x00_prep_cont_type1_iocb(ha); 254 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address; 255 avail_dsds = 5; 256 } 257 258 sle_dma = sg_dma_address(sg); 259 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 260 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 261 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 262 avail_dsds--; 263 } 264 } 265 266 /** 267 * qla2x00_start_scsi() - Send a SCSI command to the ISP 268 * @sp: command to send to the ISP 269 * 270 * Returns non-zero if a failure occurred, else zero. 271 */ 272 int 273 qla2x00_start_scsi(srb_t *sp) 274 { 275 int ret, nseg; 276 unsigned long flags; 277 scsi_qla_host_t *ha; 278 struct scsi_cmnd *cmd; 279 uint32_t *clr_ptr; 280 uint32_t index; 281 uint32_t handle; 282 cmd_entry_t *cmd_pkt; 283 uint16_t cnt; 284 uint16_t req_cnt; 285 uint16_t tot_dsds; 286 struct device_reg_2xxx __iomem *reg; 287 288 /* Setup device pointers. */ 289 ret = 0; 290 ha = sp->ha; 291 reg = &ha->iobase->isp; 292 cmd = sp->cmd; 293 /* So we know we haven't pci_map'ed anything yet */ 294 tot_dsds = 0; 295 296 /* Send marker if required */ 297 if (ha->marker_needed != 0) { 298 if (qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) { 299 return (QLA_FUNCTION_FAILED); 300 } 301 ha->marker_needed = 0; 302 } 303 304 /* Acquire ring specific lock */ 305 spin_lock_irqsave(&ha->hardware_lock, flags); 306 307 /* Check for room in outstanding command list. */ 308 handle = ha->current_outstanding_cmd; 309 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) { 310 handle++; 311 if (handle == MAX_OUTSTANDING_COMMANDS) 312 handle = 1; 313 if (!ha->outstanding_cmds[handle]) 314 break; 315 } 316 if (index == MAX_OUTSTANDING_COMMANDS) 317 goto queuing_error; 318 319 /* Map the sg table so we have an accurate count of sg entries needed */ 320 if (scsi_sg_count(cmd)) { 321 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 322 scsi_sg_count(cmd), cmd->sc_data_direction); 323 if (unlikely(!nseg)) 324 goto queuing_error; 325 } else 326 nseg = 0; 327 328 tot_dsds = nseg; 329 330 /* Calculate the number of request entries needed. */ 331 req_cnt = ha->isp_ops->calc_req_entries(tot_dsds); 332 if (ha->req_q_cnt < (req_cnt + 2)) { 333 cnt = RD_REG_WORD_RELAXED(ISP_REQ_Q_OUT(ha, reg)); 334 if (ha->req_ring_index < cnt) 335 ha->req_q_cnt = cnt - ha->req_ring_index; 336 else 337 ha->req_q_cnt = ha->request_q_length - 338 (ha->req_ring_index - cnt); 339 } 340 if (ha->req_q_cnt < (req_cnt + 2)) 341 goto queuing_error; 342 343 /* Build command packet */ 344 ha->current_outstanding_cmd = handle; 345 ha->outstanding_cmds[handle] = sp; 346 sp->ha = ha; 347 sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle; 348 ha->req_q_cnt -= req_cnt; 349 350 cmd_pkt = (cmd_entry_t *)ha->request_ring_ptr; 351 cmd_pkt->handle = handle; 352 /* Zero out remaining portion of packet. */ 353 clr_ptr = (uint32_t *)cmd_pkt + 2; 354 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 355 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 356 357 /* Set target ID and LUN number*/ 358 SET_TARGET_ID(ha, cmd_pkt->target, sp->fcport->loop_id); 359 cmd_pkt->lun = cpu_to_le16(sp->cmd->device->lun); 360 361 /* Update tagged queuing modifier */ 362 cmd_pkt->control_flags = __constant_cpu_to_le16(CF_SIMPLE_TAG); 363 364 /* Load SCSI command packet. */ 365 memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len); 366 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 367 368 /* Build IOCB segments */ 369 ha->isp_ops->build_iocbs(sp, cmd_pkt, tot_dsds); 370 371 /* Set total data segment count. */ 372 cmd_pkt->entry_count = (uint8_t)req_cnt; 373 wmb(); 374 375 /* Adjust ring index. */ 376 ha->req_ring_index++; 377 if (ha->req_ring_index == ha->request_q_length) { 378 ha->req_ring_index = 0; 379 ha->request_ring_ptr = ha->request_ring; 380 } else 381 ha->request_ring_ptr++; 382 383 sp->flags |= SRB_DMA_VALID; 384 385 /* Set chip new ring index. */ 386 WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), ha->req_ring_index); 387 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, reg)); /* PCI Posting. */ 388 389 /* Manage unprocessed RIO/ZIO commands in response queue. */ 390 if (ha->flags.process_response_queue && 391 ha->response_ring_ptr->signature != RESPONSE_PROCESSED) 392 qla2x00_process_response_queue(ha); 393 394 spin_unlock_irqrestore(&ha->hardware_lock, flags); 395 return (QLA_SUCCESS); 396 397 queuing_error: 398 if (tot_dsds) 399 scsi_dma_unmap(cmd); 400 401 spin_unlock_irqrestore(&ha->hardware_lock, flags); 402 403 return (QLA_FUNCTION_FAILED); 404 } 405 406 /** 407 * qla2x00_marker() - Send a marker IOCB to the firmware. 408 * @ha: HA context 409 * @loop_id: loop ID 410 * @lun: LUN 411 * @type: marker modifier 412 * 413 * Can be called from both normal and interrupt context. 414 * 415 * Returns non-zero if a failure occurred, else zero. 416 */ 417 int 418 __qla2x00_marker(scsi_qla_host_t *ha, uint16_t loop_id, uint16_t lun, 419 uint8_t type) 420 { 421 mrk_entry_t *mrk; 422 struct mrk_entry_24xx *mrk24; 423 scsi_qla_host_t *pha = to_qla_parent(ha); 424 425 mrk24 = NULL; 426 mrk = (mrk_entry_t *)qla2x00_req_pkt(pha); 427 if (mrk == NULL) { 428 DEBUG2_3(printk("%s(%ld): failed to allocate Marker IOCB.\n", 429 __func__, ha->host_no)); 430 431 return (QLA_FUNCTION_FAILED); 432 } 433 434 mrk->entry_type = MARKER_TYPE; 435 mrk->modifier = type; 436 if (type != MK_SYNC_ALL) { 437 if (IS_FWI2_CAPABLE(ha)) { 438 mrk24 = (struct mrk_entry_24xx *) mrk; 439 mrk24->nport_handle = cpu_to_le16(loop_id); 440 mrk24->lun[1] = LSB(lun); 441 mrk24->lun[2] = MSB(lun); 442 host_to_fcp_swap(mrk24->lun, sizeof(mrk24->lun)); 443 mrk24->vp_index = ha->vp_idx; 444 } else { 445 SET_TARGET_ID(ha, mrk->target, loop_id); 446 mrk->lun = cpu_to_le16(lun); 447 } 448 } 449 wmb(); 450 451 qla2x00_isp_cmd(pha); 452 453 return (QLA_SUCCESS); 454 } 455 456 int 457 qla2x00_marker(scsi_qla_host_t *ha, uint16_t loop_id, uint16_t lun, 458 uint8_t type) 459 { 460 int ret; 461 unsigned long flags = 0; 462 scsi_qla_host_t *pha = to_qla_parent(ha); 463 464 spin_lock_irqsave(&pha->hardware_lock, flags); 465 ret = __qla2x00_marker(ha, loop_id, lun, type); 466 spin_unlock_irqrestore(&pha->hardware_lock, flags); 467 468 return (ret); 469 } 470 471 /** 472 * qla2x00_req_pkt() - Retrieve a request packet from the request ring. 473 * @ha: HA context 474 * 475 * Note: The caller must hold the hardware lock before calling this routine. 476 * 477 * Returns NULL if function failed, else, a pointer to the request packet. 478 */ 479 static request_t * 480 qla2x00_req_pkt(scsi_qla_host_t *ha) 481 { 482 device_reg_t __iomem *reg = ha->iobase; 483 request_t *pkt = NULL; 484 uint16_t cnt; 485 uint32_t *dword_ptr; 486 uint32_t timer; 487 uint16_t req_cnt = 1; 488 489 /* Wait 1 second for slot. */ 490 for (timer = HZ; timer; timer--) { 491 if ((req_cnt + 2) >= ha->req_q_cnt) { 492 /* Calculate number of free request entries. */ 493 if (IS_FWI2_CAPABLE(ha)) 494 cnt = (uint16_t)RD_REG_DWORD( 495 ®->isp24.req_q_out); 496 else 497 cnt = qla2x00_debounce_register( 498 ISP_REQ_Q_OUT(ha, ®->isp)); 499 if (ha->req_ring_index < cnt) 500 ha->req_q_cnt = cnt - ha->req_ring_index; 501 else 502 ha->req_q_cnt = ha->request_q_length - 503 (ha->req_ring_index - cnt); 504 } 505 /* If room for request in request ring. */ 506 if ((req_cnt + 2) < ha->req_q_cnt) { 507 ha->req_q_cnt--; 508 pkt = ha->request_ring_ptr; 509 510 /* Zero out packet. */ 511 dword_ptr = (uint32_t *)pkt; 512 for (cnt = 0; cnt < REQUEST_ENTRY_SIZE / 4; cnt++) 513 *dword_ptr++ = 0; 514 515 /* Set system defined field. */ 516 pkt->sys_define = (uint8_t)ha->req_ring_index; 517 518 /* Set entry count. */ 519 pkt->entry_count = 1; 520 521 break; 522 } 523 524 /* Release ring specific lock */ 525 spin_unlock(&ha->hardware_lock); 526 527 udelay(2); /* 2 us */ 528 529 /* Check for pending interrupts. */ 530 /* During init we issue marker directly */ 531 if (!ha->marker_needed && !ha->flags.init_done) 532 qla2x00_poll(ha); 533 534 spin_lock_irq(&ha->hardware_lock); 535 } 536 if (!pkt) { 537 DEBUG2_3(printk("%s(): **** FAILED ****\n", __func__)); 538 } 539 540 return (pkt); 541 } 542 543 /** 544 * qla2x00_isp_cmd() - Modify the request ring pointer. 545 * @ha: HA context 546 * 547 * Note: The caller must hold the hardware lock before calling this routine. 548 */ 549 static void 550 qla2x00_isp_cmd(scsi_qla_host_t *ha) 551 { 552 device_reg_t __iomem *reg = ha->iobase; 553 554 DEBUG5(printk("%s(): IOCB data:\n", __func__)); 555 DEBUG5(qla2x00_dump_buffer( 556 (uint8_t *)ha->request_ring_ptr, REQUEST_ENTRY_SIZE)); 557 558 /* Adjust ring index. */ 559 ha->req_ring_index++; 560 if (ha->req_ring_index == ha->request_q_length) { 561 ha->req_ring_index = 0; 562 ha->request_ring_ptr = ha->request_ring; 563 } else 564 ha->request_ring_ptr++; 565 566 /* Set chip new ring index. */ 567 if (IS_FWI2_CAPABLE(ha)) { 568 WRT_REG_DWORD(®->isp24.req_q_in, ha->req_ring_index); 569 RD_REG_DWORD_RELAXED(®->isp24.req_q_in); 570 } else { 571 WRT_REG_WORD(ISP_REQ_Q_IN(ha, ®->isp), ha->req_ring_index); 572 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, ®->isp)); 573 } 574 575 } 576 577 /** 578 * qla24xx_calc_iocbs() - Determine number of Command Type 3 and 579 * Continuation Type 1 IOCBs to allocate. 580 * 581 * @dsds: number of data segment decriptors needed 582 * 583 * Returns the number of IOCB entries needed to store @dsds. 584 */ 585 static inline uint16_t 586 qla24xx_calc_iocbs(uint16_t dsds) 587 { 588 uint16_t iocbs; 589 590 iocbs = 1; 591 if (dsds > 1) { 592 iocbs += (dsds - 1) / 5; 593 if ((dsds - 1) % 5) 594 iocbs++; 595 } 596 return iocbs; 597 } 598 599 /** 600 * qla24xx_build_scsi_iocbs() - Build IOCB command utilizing Command Type 7 601 * IOCB types. 602 * 603 * @sp: SRB command to process 604 * @cmd_pkt: Command type 3 IOCB 605 * @tot_dsds: Total number of segments to transfer 606 */ 607 static inline void 608 qla24xx_build_scsi_iocbs(srb_t *sp, struct cmd_type_7 *cmd_pkt, 609 uint16_t tot_dsds) 610 { 611 uint16_t avail_dsds; 612 uint32_t *cur_dsd; 613 scsi_qla_host_t *ha; 614 struct scsi_cmnd *cmd; 615 struct scatterlist *sg; 616 int i; 617 618 cmd = sp->cmd; 619 620 /* Update entry type to indicate Command Type 3 IOCB */ 621 *((uint32_t *)(&cmd_pkt->entry_type)) = 622 __constant_cpu_to_le32(COMMAND_TYPE_7); 623 624 /* No data transfer */ 625 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 626 cmd_pkt->byte_count = __constant_cpu_to_le32(0); 627 return; 628 } 629 630 ha = sp->ha; 631 632 /* Set transfer direction */ 633 if (cmd->sc_data_direction == DMA_TO_DEVICE) { 634 cmd_pkt->task_mgmt_flags = 635 __constant_cpu_to_le16(TMF_WRITE_DATA); 636 sp->fcport->ha->qla_stats.output_bytes += 637 scsi_bufflen(sp->cmd); 638 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) { 639 cmd_pkt->task_mgmt_flags = 640 __constant_cpu_to_le16(TMF_READ_DATA); 641 sp->fcport->ha->qla_stats.input_bytes += 642 scsi_bufflen(sp->cmd); 643 } 644 645 /* One DSD is available in the Command Type 3 IOCB */ 646 avail_dsds = 1; 647 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address; 648 649 /* Load data segments */ 650 651 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 652 dma_addr_t sle_dma; 653 cont_a64_entry_t *cont_pkt; 654 655 /* Allocate additional continuation packets? */ 656 if (avail_dsds == 0) { 657 /* 658 * Five DSDs are available in the Continuation 659 * Type 1 IOCB. 660 */ 661 cont_pkt = qla2x00_prep_cont_type1_iocb(ha); 662 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address; 663 avail_dsds = 5; 664 } 665 666 sle_dma = sg_dma_address(sg); 667 *cur_dsd++ = cpu_to_le32(LSD(sle_dma)); 668 *cur_dsd++ = cpu_to_le32(MSD(sle_dma)); 669 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg)); 670 avail_dsds--; 671 } 672 } 673 674 675 /** 676 * qla24xx_start_scsi() - Send a SCSI command to the ISP 677 * @sp: command to send to the ISP 678 * 679 * Returns non-zero if a failure occurred, else zero. 680 */ 681 int 682 qla24xx_start_scsi(srb_t *sp) 683 { 684 int ret, nseg; 685 unsigned long flags; 686 scsi_qla_host_t *ha, *pha; 687 struct scsi_cmnd *cmd; 688 uint32_t *clr_ptr; 689 uint32_t index; 690 uint32_t handle; 691 struct cmd_type_7 *cmd_pkt; 692 uint16_t cnt; 693 uint16_t req_cnt; 694 uint16_t tot_dsds; 695 struct device_reg_24xx __iomem *reg; 696 697 /* Setup device pointers. */ 698 ret = 0; 699 ha = sp->ha; 700 pha = to_qla_parent(ha); 701 reg = &ha->iobase->isp24; 702 cmd = sp->cmd; 703 /* So we know we haven't pci_map'ed anything yet */ 704 tot_dsds = 0; 705 706 /* Send marker if required */ 707 if (ha->marker_needed != 0) { 708 if (qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) { 709 return QLA_FUNCTION_FAILED; 710 } 711 ha->marker_needed = 0; 712 } 713 714 /* Acquire ring specific lock */ 715 spin_lock_irqsave(&pha->hardware_lock, flags); 716 717 /* Check for room in outstanding command list. */ 718 handle = ha->current_outstanding_cmd; 719 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) { 720 handle++; 721 if (handle == MAX_OUTSTANDING_COMMANDS) 722 handle = 1; 723 if (!ha->outstanding_cmds[handle]) 724 break; 725 } 726 if (index == MAX_OUTSTANDING_COMMANDS) 727 goto queuing_error; 728 729 /* Map the sg table so we have an accurate count of sg entries needed */ 730 if (scsi_sg_count(cmd)) { 731 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd), 732 scsi_sg_count(cmd), cmd->sc_data_direction); 733 if (unlikely(!nseg)) 734 goto queuing_error; 735 } else 736 nseg = 0; 737 738 tot_dsds = nseg; 739 740 req_cnt = qla24xx_calc_iocbs(tot_dsds); 741 if (ha->req_q_cnt < (req_cnt + 2)) { 742 cnt = (uint16_t)RD_REG_DWORD_RELAXED(®->req_q_out); 743 if (ha->req_ring_index < cnt) 744 ha->req_q_cnt = cnt - ha->req_ring_index; 745 else 746 ha->req_q_cnt = ha->request_q_length - 747 (ha->req_ring_index - cnt); 748 } 749 if (ha->req_q_cnt < (req_cnt + 2)) 750 goto queuing_error; 751 752 /* Build command packet. */ 753 ha->current_outstanding_cmd = handle; 754 ha->outstanding_cmds[handle] = sp; 755 sp->ha = ha; 756 sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle; 757 ha->req_q_cnt -= req_cnt; 758 759 cmd_pkt = (struct cmd_type_7 *)ha->request_ring_ptr; 760 cmd_pkt->handle = handle; 761 762 /* Zero out remaining portion of packet. */ 763 /* tagged queuing modifier -- default is TSK_SIMPLE (0). */ 764 clr_ptr = (uint32_t *)cmd_pkt + 2; 765 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8); 766 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds); 767 768 /* Set NPORT-ID and LUN number*/ 769 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id); 770 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa; 771 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area; 772 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain; 773 cmd_pkt->vp_index = sp->fcport->vp_idx; 774 775 int_to_scsilun(sp->cmd->device->lun, &cmd_pkt->lun); 776 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun)); 777 778 /* Load SCSI command packet. */ 779 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len); 780 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb)); 781 782 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd)); 783 784 /* Build IOCB segments */ 785 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds); 786 787 /* Set total data segment count. */ 788 cmd_pkt->entry_count = (uint8_t)req_cnt; 789 wmb(); 790 791 /* Adjust ring index. */ 792 ha->req_ring_index++; 793 if (ha->req_ring_index == ha->request_q_length) { 794 ha->req_ring_index = 0; 795 ha->request_ring_ptr = ha->request_ring; 796 } else 797 ha->request_ring_ptr++; 798 799 sp->flags |= SRB_DMA_VALID; 800 801 /* Set chip new ring index. */ 802 WRT_REG_DWORD(®->req_q_in, ha->req_ring_index); 803 RD_REG_DWORD_RELAXED(®->req_q_in); /* PCI Posting. */ 804 805 /* Manage unprocessed RIO/ZIO commands in response queue. */ 806 if (ha->flags.process_response_queue && 807 ha->response_ring_ptr->signature != RESPONSE_PROCESSED) 808 qla24xx_process_response_queue(ha); 809 810 spin_unlock_irqrestore(&pha->hardware_lock, flags); 811 return QLA_SUCCESS; 812 813 queuing_error: 814 if (tot_dsds) 815 scsi_dma_unmap(cmd); 816 817 spin_unlock_irqrestore(&pha->hardware_lock, flags); 818 819 return QLA_FUNCTION_FAILED; 820 } 821