drivers/scsi/qla2xxx/qla_iocb.c

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