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