drivers/scsi/qla2xxx/qla_iocb.c

   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                                     &reg->isp24.req_q_out);
 496                         else
 497                                 cnt = qla2x00_debounce_register(
 498                                     ISP_REQ_Q_OUT(ha, &reg->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(&reg->isp24.req_q_in, ha->req_ring_index);
 569                 RD_REG_DWORD_RELAXED(&reg->isp24.req_q_in);
 570         } else {
 571                 WRT_REG_WORD(ISP_REQ_Q_IN(ha, &reg->isp), ha->req_ring_index);
 572                 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, &reg->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(&reg->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(&reg->req_q_in, ha->req_ring_index);
 803         RD_REG_DWORD_RELAXED(&reg->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 }