drivers/scsi/qla4xxx/ql4_iocb.c

   1 /*
   2  * QLogic iSCSI HBA Driver
   3  * Copyright (c)  2003-2006 QLogic Corporation
   4  *
   5  * See LICENSE.qla4xxx for copyright and licensing details.
   6  */
   7
   8 #include "ql4_def.h"
   9 #include "ql4_glbl.h"
  10 #include "ql4_dbg.h"
  11 #include "ql4_inline.h"
  12
  13 #include <scsi/scsi_tcq.h>
  14
  15 static int
  16 qla4xxx_space_in_req_ring(struct scsi_qla_host *ha, uint16_t req_cnt)
  17 {
  18         uint16_t cnt;
  19
  20         /* Calculate number of free request entries. */
  21         if ((req_cnt + 2) >= ha->req_q_count) {
  22                 cnt = (uint16_t) le32_to_cpu(ha->shadow_regs->req_q_out);
  23                 if (ha->request_in < cnt)
  24                         ha->req_q_count = cnt - ha->request_in;
  25                 else
  26                         ha->req_q_count = REQUEST_QUEUE_DEPTH -
  27                                                 (ha->request_in - cnt);
  28         }
  29
  30         /* Check if room for request in request ring. */
  31         if ((req_cnt + 2) < ha->req_q_count)
  32                 return 1;
  33         else
  34                 return 0;
  35 }
  36
  37 static void qla4xxx_advance_req_ring_ptr(struct scsi_qla_host *ha)
  38 {
  39         /* Advance request queue pointer */
  40         if (ha->request_in == (REQUEST_QUEUE_DEPTH - 1)) {
  41                 ha->request_in = 0;
  42                 ha->request_ptr = ha->request_ring;
  43         } else {
  44                 ha->request_in++;
  45                 ha->request_ptr++;
  46         }
  47 }
  48
  49 /**
  50  * qla4xxx_get_req_pkt - returns a valid entry in request queue.
  51  * @ha: Pointer to host adapter structure.
  52  * @queue_entry: Pointer to pointer to queue entry structure
  53  *
  54  * This routine performs the following tasks:
  55  *      - returns the current request_in pointer (if queue not full)
  56  *      - advances the request_in pointer
  57  *      - checks for queue full
  58  **/
  59 static int qla4xxx_get_req_pkt(struct scsi_qla_host *ha,
  60                                struct queue_entry **queue_entry)
  61 {
  62         uint16_t req_cnt = 1;
  63
  64         if (qla4xxx_space_in_req_ring(ha, req_cnt)) {
  65                 *queue_entry = ha->request_ptr;
  66                 memset(*queue_entry, 0, sizeof(**queue_entry));
  67
  68                 qla4xxx_advance_req_ring_ptr(ha);
  69                 ha->req_q_count -= req_cnt;
  70                 return QLA_SUCCESS;
  71         }
  72
  73         return QLA_ERROR;
  74 }
  75
  76 /**
  77  * qla4xxx_send_marker_iocb - issues marker iocb to HBA
  78  * @ha: Pointer to host adapter structure.
  79  * @ddb_entry: Pointer to device database entry
  80  * @lun: SCSI LUN
  81  * @marker_type: marker identifier
  82  *
  83  * This routine issues a marker IOCB.
  84  **/
  85 int qla4xxx_send_marker_iocb(struct scsi_qla_host *ha,
  86         struct ddb_entry *ddb_entry, int lun, uint16_t mrkr_mod)
  87 {
  88         struct qla4_marker_entry *marker_entry;
  89         unsigned long flags = 0;
  90         uint8_t status = QLA_SUCCESS;
  91
  92         /* Acquire hardware specific lock */
  93         spin_lock_irqsave(&ha->hardware_lock, flags);
  94
  95         /* Get pointer to the queue entry for the marker */
  96         if (qla4xxx_get_req_pkt(ha, (struct queue_entry **) &marker_entry) !=
  97             QLA_SUCCESS) {
  98                 status = QLA_ERROR;
  99                 goto exit_send_marker;
 100         }
 101
 102         /* Put the marker in the request queue */
 103         marker_entry->hdr.entryType = ET_MARKER;
 104         marker_entry->hdr.entryCount = 1;
 105         marker_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index);
 106         marker_entry->modifier = cpu_to_le16(mrkr_mod);
 107         int_to_scsilun(lun, &marker_entry->lun);
 108         wmb();
 109
 110         /* Tell ISP it's got a new I/O request */
 111         writel(ha->request_in, &ha->reg->req_q_in);
 112         readl(&ha->reg->req_q_in);
 113
 114 exit_send_marker:
 115         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 116         return status;
 117 }
 118
 119 static struct continuation_t1_entry *
 120 qla4xxx_alloc_cont_entry(struct scsi_qla_host *ha)
 121 {
 122         struct continuation_t1_entry *cont_entry;
 123
 124         cont_entry = (struct continuation_t1_entry *)ha->request_ptr;
 125
 126         qla4xxx_advance_req_ring_ptr(ha);
 127
 128         /* Load packet defaults */
 129         cont_entry->hdr.entryType = ET_CONTINUE;
 130         cont_entry->hdr.entryCount = 1;
 131         cont_entry->hdr.systemDefined = (uint8_t) cpu_to_le16(ha->request_in);
 132
 133         return cont_entry;
 134 }
 135
 136 static uint16_t qla4xxx_calc_request_entries(uint16_t dsds)
 137 {
 138         uint16_t iocbs;
 139
 140         iocbs = 1;
 141         if (dsds > COMMAND_SEG) {
 142                 iocbs += (dsds - COMMAND_SEG) / CONTINUE_SEG;
 143                 if ((dsds - COMMAND_SEG) % CONTINUE_SEG)
 144                         iocbs++;
 145         }
 146         return iocbs;
 147 }
 148
 149 static void qla4xxx_build_scsi_iocbs(struct srb *srb,
 150                                      struct command_t3_entry *cmd_entry,
 151                                      uint16_t tot_dsds)
 152 {
 153         struct scsi_qla_host *ha;
 154         uint16_t avail_dsds;
 155         struct data_seg_a64 *cur_dsd;
 156         struct scsi_cmnd *cmd;
 157         struct scatterlist *sg;
 158         int i;
 159
 160         cmd = srb->cmd;
 161         ha = srb->ha;
 162
 163         if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
 164                 /* No data being transferred */
 165                 cmd_entry->ttlByteCnt = __constant_cpu_to_le32(0);
 166                 return;
 167         }
 168
 169         avail_dsds = COMMAND_SEG;
 170         cur_dsd = (struct data_seg_a64 *) & (cmd_entry->dataseg[0]);
 171
 172         scsi_for_each_sg(cmd, sg, tot_dsds, i) {
 173                 dma_addr_t sle_dma;
 174
 175                 /* Allocate additional continuation packets? */
 176                 if (avail_dsds == 0) {
 177                         struct continuation_t1_entry *cont_entry;
 178
 179                         cont_entry = qla4xxx_alloc_cont_entry(ha);
 180                         cur_dsd =
 181                                 (struct data_seg_a64 *)
 182                                 &cont_entry->dataseg[0];
 183                         avail_dsds = CONTINUE_SEG;
 184                 }
 185
 186                 sle_dma = sg_dma_address(sg);
 187                 cur_dsd->base.addrLow = cpu_to_le32(LSDW(sle_dma));
 188                 cur_dsd->base.addrHigh = cpu_to_le32(MSDW(sle_dma));
 189                 cur_dsd->count = cpu_to_le32(sg_dma_len(sg));
 190                 avail_dsds--;
 191
 192                 cur_dsd++;
 193         }
 194 }
 195
 196 /**
 197  * qla4xxx_send_command_to_isp - issues command to HBA
 198  * @ha: pointer to host adapter structure.
 199  * @srb: pointer to SCSI Request Block to be sent to ISP
 200  *
 201  * This routine is called by qla4xxx_queuecommand to build an ISP
 202  * command and pass it to the ISP for execution.
 203  **/
 204 int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb)
 205 {
 206         struct scsi_cmnd *cmd = srb->cmd;
 207         struct ddb_entry *ddb_entry;
 208         struct command_t3_entry *cmd_entry;
 209         int nseg;
 210         uint16_t tot_dsds;
 211         uint16_t req_cnt;
 212         unsigned long flags;
 213         uint32_t index;
 214         char tag[2];
 215
 216         /* Get real lun and adapter */
 217         ddb_entry = srb->ddb;
 218
 219         tot_dsds = 0;
 220
 221         /* Acquire hardware specific lock */
 222         spin_lock_irqsave(&ha->hardware_lock, flags);
 223
 224         index = (uint32_t)cmd->request->tag;
 225
 226         /*
 227          * Check to see if adapter is online before placing request on
 228          * request queue.  If a reset occurs and a request is in the queue,
 229          * the firmware will still attempt to process the request, retrieving
 230          * garbage for pointers.
 231          */
 232         if (!test_bit(AF_ONLINE, &ha->flags)) {
 233                 DEBUG2(printk("scsi%ld: %s: Adapter OFFLINE! "
 234                               "Do not issue command.\n",
 235                               ha->host_no, __func__));
 236                 goto queuing_error;
 237         }
 238
 239         /* Calculate the number of request entries needed. */
 240         nseg = scsi_dma_map(cmd);
 241         if (nseg < 0)
 242                 goto queuing_error;
 243         tot_dsds = nseg;
 244
 245         req_cnt = qla4xxx_calc_request_entries(tot_dsds);
 246         if (!qla4xxx_space_in_req_ring(ha, req_cnt))
 247                 goto queuing_error;
 248
 249         /* total iocbs active */
 250         if ((ha->iocb_cnt + req_cnt) >= REQUEST_QUEUE_DEPTH)
 251                 goto queuing_error;
 252
 253         /* Build command packet */
 254         cmd_entry = (struct command_t3_entry *) ha->request_ptr;
 255         memset(cmd_entry, 0, sizeof(struct command_t3_entry));
 256         cmd_entry->hdr.entryType = ET_COMMAND;
 257         cmd_entry->handle = cpu_to_le32(index);
 258         cmd_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index);
 259         cmd_entry->connection_id = cpu_to_le16(ddb_entry->connection_id);
 260
 261         int_to_scsilun(cmd->device->lun, &cmd_entry->lun);
 262         cmd_entry->cmdSeqNum = cpu_to_le32(ddb_entry->CmdSn);
 263         cmd_entry->ttlByteCnt = cpu_to_le32(scsi_bufflen(cmd));
 264         memcpy(cmd_entry->cdb, cmd->cmnd, cmd->cmd_len);
 265         cmd_entry->dataSegCnt = cpu_to_le16(tot_dsds);
 266         cmd_entry->hdr.entryCount = req_cnt;
 267
 268         /* Set data transfer direction control flags
 269          * NOTE: Look at data_direction bits iff there is data to be
 270          *       transferred, as the data direction bit is sometimed filled
 271          *       in when there is no data to be transferred */
 272         cmd_entry->control_flags = CF_NO_DATA;
 273         if (scsi_bufflen(cmd)) {
 274                 if (cmd->sc_data_direction == DMA_TO_DEVICE)
 275                         cmd_entry->control_flags = CF_WRITE;
 276                 else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
 277                         cmd_entry->control_flags = CF_READ;
 278
 279                 ha->bytes_xfered += scsi_bufflen(cmd);
 280                 if (ha->bytes_xfered & ~0xFFFFF){
 281                         ha->total_mbytes_xferred += ha->bytes_xfered >> 20;
 282                         ha->bytes_xfered &= 0xFFFFF;
 283                 }
 284         }
 285
 286         /* Set tagged queueing control flags */
 287         cmd_entry->control_flags |= CF_SIMPLE_TAG;
 288         if (scsi_populate_tag_msg(cmd, tag))
 289                 switch (tag[0]) {
 290                 case MSG_HEAD_TAG:
 291                         cmd_entry->control_flags |= CF_HEAD_TAG;
 292                         break;
 293                 case MSG_ORDERED_TAG:
 294                         cmd_entry->control_flags |= CF_ORDERED_TAG;
 295                         break;
 296                 }
 297
 298         qla4xxx_advance_req_ring_ptr(ha);
 299         qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds);
 300         wmb();
 301
 302         srb->cmd->host_scribble = (unsigned char *)srb;
 303
 304         /* update counters */
 305         srb->state = SRB_ACTIVE_STATE;
 306         srb->flags |= SRB_DMA_VALID;
 307
 308         /* Track IOCB used */
 309         ha->iocb_cnt += req_cnt;
 310         srb->iocb_cnt = req_cnt;
 311         ha->req_q_count -= req_cnt;
 312
 313         /* Debug print statements */
 314         writel(ha->request_in, &ha->reg->req_q_in);
 315         readl(&ha->reg->req_q_in);
 316         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 317
 318         return QLA_SUCCESS;
 319
 320 queuing_error:
 321         if (tot_dsds)
 322                 scsi_dma_unmap(cmd);
 323
 324         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 325
 326         return QLA_ERROR;
 327 }
 328