drivers/scsi/qla4xxx/ql4_iocb.c

   1 /*
   2  * QLogic iSCSI HBA Driver
   3  * Copyright (c)  2003-2013 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) ha->isp_ops->rd_shdw_req_q_out(ha);
  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         ha->isp_ops->queue_iocb(ha);
 112
 113 exit_send_marker:
 114         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 115         return status;
 116 }
 117
 118 static struct continuation_t1_entry *
 119 qla4xxx_alloc_cont_entry(struct scsi_qla_host *ha)
 120 {
 121         struct continuation_t1_entry *cont_entry;
 122
 123         cont_entry = (struct continuation_t1_entry *)ha->request_ptr;
 124
 125         qla4xxx_advance_req_ring_ptr(ha);
 126
 127         /* Load packet defaults */
 128         cont_entry->hdr.entryType = ET_CONTINUE;
 129         cont_entry->hdr.entryCount = 1;
 130         cont_entry->hdr.systemDefined = (uint8_t) cpu_to_le16(ha->request_in);
 131
 132         return cont_entry;
 133 }
 134
 135 static uint16_t qla4xxx_calc_request_entries(uint16_t dsds)
 136 {
 137         uint16_t iocbs;
 138
 139         iocbs = 1;
 140         if (dsds > COMMAND_SEG) {
 141                 iocbs += (dsds - COMMAND_SEG) / CONTINUE_SEG;
 142                 if ((dsds - COMMAND_SEG) % CONTINUE_SEG)
 143                         iocbs++;
 144         }
 145         return iocbs;
 146 }
 147
 148 static void qla4xxx_build_scsi_iocbs(struct srb *srb,
 149                                      struct command_t3_entry *cmd_entry,
 150                                      uint16_t tot_dsds)
 151 {
 152         struct scsi_qla_host *ha;
 153         uint16_t avail_dsds;
 154         struct data_seg_a64 *cur_dsd;
 155         struct scsi_cmnd *cmd;
 156         struct scatterlist *sg;
 157         int i;
 158
 159         cmd = srb->cmd;
 160         ha = srb->ha;
 161
 162         if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
 163                 /* No data being transferred */
 164                 cmd_entry->ttlByteCnt = __constant_cpu_to_le32(0);
 165                 return;
 166         }
 167
 168         avail_dsds = COMMAND_SEG;
 169         cur_dsd = (struct data_seg_a64 *) & (cmd_entry->dataseg[0]);
 170
 171         scsi_for_each_sg(cmd, sg, tot_dsds, i) {
 172                 dma_addr_t sle_dma;
 173
 174                 /* Allocate additional continuation packets? */
 175                 if (avail_dsds == 0) {
 176                         struct continuation_t1_entry *cont_entry;
 177
 178                         cont_entry = qla4xxx_alloc_cont_entry(ha);
 179                         cur_dsd =
 180                                 (struct data_seg_a64 *)
 181                                 &cont_entry->dataseg[0];
 182                         avail_dsds = CONTINUE_SEG;
 183                 }
 184
 185                 sle_dma = sg_dma_address(sg);
 186                 cur_dsd->base.addrLow = cpu_to_le32(LSDW(sle_dma));
 187                 cur_dsd->base.addrHigh = cpu_to_le32(MSDW(sle_dma));
 188                 cur_dsd->count = cpu_to_le32(sg_dma_len(sg));
 189                 avail_dsds--;
 190
 191                 cur_dsd++;
 192         }
 193 }
 194
 195 void qla4_83xx_queue_iocb(struct scsi_qla_host *ha)
 196 {
 197         writel(ha->request_in, &ha->qla4_83xx_reg->req_q_in);
 198         readl(&ha->qla4_83xx_reg->req_q_in);
 199 }
 200
 201 void qla4_83xx_complete_iocb(struct scsi_qla_host *ha)
 202 {
 203         writel(ha->response_out, &ha->qla4_83xx_reg->rsp_q_out);
 204         readl(&ha->qla4_83xx_reg->rsp_q_out);
 205 }
 206
 207 /**
 208  * qla4_82xx_queue_iocb - Tell ISP it's got new request(s)
 209  * @ha: pointer to host adapter structure.
 210  *
 211  * This routine notifies the ISP that one or more new request
 212  * queue entries have been placed on the request queue.
 213  **/
 214 void qla4_82xx_queue_iocb(struct scsi_qla_host *ha)
 215 {
 216         uint32_t dbval = 0;
 217
 218         dbval = 0x14 | (ha->func_num << 5);
 219         dbval = dbval | (0 << 8) | (ha->request_in << 16);
 220
 221         qla4_82xx_wr_32(ha, ha->nx_db_wr_ptr, ha->request_in);
 222 }
 223
 224 /**
 225  * qla4_82xx_complete_iocb - Tell ISP we're done with response(s)
 226  * @ha: pointer to host adapter structure.
 227  *
 228  * This routine notifies the ISP that one or more response/completion
 229  * queue entries have been processed by the driver.
 230  * This also clears the interrupt.
 231  **/
 232 void qla4_82xx_complete_iocb(struct scsi_qla_host *ha)
 233 {
 234         writel(ha->response_out, &ha->qla4_82xx_reg->rsp_q_out);
 235         readl(&ha->qla4_82xx_reg->rsp_q_out);
 236 }
 237
 238 /**
 239  * qla4xxx_queue_iocb - Tell ISP it's got new request(s)
 240  * @ha: pointer to host adapter structure.
 241  *
 242  * This routine is notifies the ISP that one or more new request
 243  * queue entries have been placed on the request queue.
 244  **/
 245 void qla4xxx_queue_iocb(struct scsi_qla_host *ha)
 246 {
 247         writel(ha->request_in, &ha->reg->req_q_in);
 248         readl(&ha->reg->req_q_in);
 249 }
 250
 251 /**
 252  * qla4xxx_complete_iocb - Tell ISP we're done with response(s)
 253  * @ha: pointer to host adapter structure.
 254  *
 255  * This routine is notifies the ISP that one or more response/completion
 256  * queue entries have been processed by the driver.
 257  * This also clears the interrupt.
 258  **/
 259 void qla4xxx_complete_iocb(struct scsi_qla_host *ha)
 260 {
 261         writel(ha->response_out, &ha->reg->rsp_q_out);
 262         readl(&ha->reg->rsp_q_out);
 263 }
 264
 265 /**
 266  * qla4xxx_send_command_to_isp - issues command to HBA
 267  * @ha: pointer to host adapter structure.
 268  * @srb: pointer to SCSI Request Block to be sent to ISP
 269  *
 270  * This routine is called by qla4xxx_queuecommand to build an ISP
 271  * command and pass it to the ISP for execution.
 272  **/
 273 int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb)
 274 {
 275         struct scsi_cmnd *cmd = srb->cmd;
 276         struct ddb_entry *ddb_entry;
 277         struct command_t3_entry *cmd_entry;
 278         int nseg;
 279         uint16_t tot_dsds;
 280         uint16_t req_cnt;
 281         unsigned long flags;
 282         uint32_t index;
 283         char tag[2];
 284
 285         /* Get real lun and adapter */
 286         ddb_entry = srb->ddb;
 287
 288         tot_dsds = 0;
 289
 290         /* Acquire hardware specific lock */
 291         spin_lock_irqsave(&ha->hardware_lock, flags);
 292
 293         index = (uint32_t)cmd->request->tag;
 294
 295         /*
 296          * Check to see if adapter is online before placing request on
 297          * request queue.  If a reset occurs and a request is in the queue,
 298          * the firmware will still attempt to process the request, retrieving
 299          * garbage for pointers.
 300          */
 301         if (!test_bit(AF_ONLINE, &ha->flags)) {
 302                 DEBUG2(printk("scsi%ld: %s: Adapter OFFLINE! "
 303                               "Do not issue command.\n",
 304                               ha->host_no, __func__));
 305                 goto queuing_error;
 306         }
 307
 308         /* Calculate the number of request entries needed. */
 309         nseg = scsi_dma_map(cmd);
 310         if (nseg < 0)
 311                 goto queuing_error;
 312         tot_dsds = nseg;
 313
 314         req_cnt = qla4xxx_calc_request_entries(tot_dsds);
 315         if (!qla4xxx_space_in_req_ring(ha, req_cnt))
 316                 goto queuing_error;
 317
 318         /* total iocbs active */
 319         if ((ha->iocb_cnt + req_cnt) >= ha->iocb_hiwat)
 320                 goto queuing_error;
 321
 322         /* Build command packet */
 323         cmd_entry = (struct command_t3_entry *) ha->request_ptr;
 324         memset(cmd_entry, 0, sizeof(struct command_t3_entry));
 325         cmd_entry->hdr.entryType = ET_COMMAND;
 326         cmd_entry->handle = cpu_to_le32(index);
 327         cmd_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index);
 328
 329         int_to_scsilun(cmd->device->lun, &cmd_entry->lun);
 330         cmd_entry->ttlByteCnt = cpu_to_le32(scsi_bufflen(cmd));
 331         memcpy(cmd_entry->cdb, cmd->cmnd, cmd->cmd_len);
 332         cmd_entry->dataSegCnt = cpu_to_le16(tot_dsds);
 333         cmd_entry->hdr.entryCount = req_cnt;
 334
 335         /* Set data transfer direction control flags
 336          * NOTE: Look at data_direction bits iff there is data to be
 337          *       transferred, as the data direction bit is sometimed filled
 338          *       in when there is no data to be transferred */
 339         cmd_entry->control_flags = CF_NO_DATA;
 340         if (scsi_bufflen(cmd)) {
 341                 if (cmd->sc_data_direction == DMA_TO_DEVICE)
 342                         cmd_entry->control_flags = CF_WRITE;
 343                 else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
 344                         cmd_entry->control_flags = CF_READ;
 345
 346                 ha->bytes_xfered += scsi_bufflen(cmd);
 347                 if (ha->bytes_xfered & ~0xFFFFF){
 348                         ha->total_mbytes_xferred += ha->bytes_xfered >> 20;
 349                         ha->bytes_xfered &= 0xFFFFF;
 350                 }
 351         }
 352
 353         /* Set tagged queueing control flags */
 354         cmd_entry->control_flags |= CF_SIMPLE_TAG;
 355         if (scsi_populate_tag_msg(cmd, tag))
 356                 switch (tag[0]) {
 357                 case MSG_HEAD_TAG:
 358                         cmd_entry->control_flags |= CF_HEAD_TAG;
 359                         break;
 360                 case MSG_ORDERED_TAG:
 361                         cmd_entry->control_flags |= CF_ORDERED_TAG;
 362                         break;
 363                 }
 364
 365         qla4xxx_advance_req_ring_ptr(ha);
 366         qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds);
 367         wmb();
 368
 369         srb->cmd->host_scribble = (unsigned char *)(unsigned long)index;
 370
 371         /* update counters */
 372         srb->state = SRB_ACTIVE_STATE;
 373         srb->flags |= SRB_DMA_VALID;
 374
 375         /* Track IOCB used */
 376         ha->iocb_cnt += req_cnt;
 377         srb->iocb_cnt = req_cnt;
 378         ha->req_q_count -= req_cnt;
 379
 380         ha->isp_ops->queue_iocb(ha);
 381         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 382
 383         return QLA_SUCCESS;
 384
 385 queuing_error:
 386         if (tot_dsds)
 387                 scsi_dma_unmap(cmd);
 388
 389         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 390
 391         return QLA_ERROR;
 392 }
 393
 394 int qla4xxx_send_passthru0(struct iscsi_task *task)
 395 {
 396         struct passthru0 *passthru_iocb;
 397         struct iscsi_session *sess = task->conn->session;
 398         struct ddb_entry *ddb_entry = sess->dd_data;
 399         struct scsi_qla_host *ha = ddb_entry->ha;
 400         struct ql4_task_data *task_data = task->dd_data;
 401         uint16_t ctrl_flags = 0;
 402         unsigned long flags;
 403         int ret = QLA_ERROR;
 404
 405         spin_lock_irqsave(&ha->hardware_lock, flags);
 406         task_data->iocb_req_cnt = 1;
 407         /* Put the IOCB on the request queue */
 408         if (!qla4xxx_space_in_req_ring(ha, task_data->iocb_req_cnt))
 409                 goto queuing_error;
 410
 411         passthru_iocb = (struct passthru0 *) ha->request_ptr;
 412
 413         memset(passthru_iocb, 0, sizeof(struct passthru0));
 414         passthru_iocb->hdr.entryType = ET_PASSTHRU0;
 415         passthru_iocb->hdr.systemDefined = SD_ISCSI_PDU;
 416         passthru_iocb->hdr.entryCount = task_data->iocb_req_cnt;
 417         passthru_iocb->handle = task->itt;
 418         passthru_iocb->target = cpu_to_le16(ddb_entry->fw_ddb_index);
 419         passthru_iocb->timeout = cpu_to_le16(PT_DEFAULT_TIMEOUT);
 420
 421         /* Setup the out & in DSDs */
 422         if (task_data->req_len) {
 423                 memcpy((uint8_t *)task_data->req_buffer +
 424                        sizeof(struct iscsi_hdr), task->data, task->data_count);
 425                 ctrl_flags |= PT_FLAG_SEND_BUFFER;
 426                 passthru_iocb->out_dsd.base.addrLow =
 427                                         cpu_to_le32(LSDW(task_data->req_dma));
 428                 passthru_iocb->out_dsd.base.addrHigh =
 429                                         cpu_to_le32(MSDW(task_data->req_dma));
 430                 passthru_iocb->out_dsd.count =
 431                                         cpu_to_le32(task->data_count +
 432                                                     sizeof(struct iscsi_hdr));
 433         }
 434         if (task_data->resp_len) {
 435                 passthru_iocb->in_dsd.base.addrLow =
 436                                         cpu_to_le32(LSDW(task_data->resp_dma));
 437                 passthru_iocb->in_dsd.base.addrHigh =
 438                                         cpu_to_le32(MSDW(task_data->resp_dma));
 439                 passthru_iocb->in_dsd.count =
 440                         cpu_to_le32(task_data->resp_len);
 441         }
 442
 443         ctrl_flags |= (PT_FLAG_ISCSI_PDU | PT_FLAG_WAIT_4_RESPONSE);
 444         passthru_iocb->control_flags = cpu_to_le16(ctrl_flags);
 445
 446         /* Update the request pointer */
 447         qla4xxx_advance_req_ring_ptr(ha);
 448         wmb();
 449
 450         /* Track IOCB used */
 451         ha->iocb_cnt += task_data->iocb_req_cnt;
 452         ha->req_q_count -= task_data->iocb_req_cnt;
 453         ha->isp_ops->queue_iocb(ha);
 454         ret = QLA_SUCCESS;
 455
 456 queuing_error:
 457         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 458         return ret;
 459 }
 460
 461 static struct mrb *qla4xxx_get_new_mrb(struct scsi_qla_host *ha)
 462 {
 463         struct mrb *mrb;
 464
 465         mrb = kzalloc(sizeof(*mrb), GFP_KERNEL);
 466         if (!mrb)
 467                 return mrb;
 468
 469         mrb->ha = ha;
 470         return mrb;
 471 }
 472
 473 static int qla4xxx_send_mbox_iocb(struct scsi_qla_host *ha, struct mrb *mrb,
 474                                   uint32_t *in_mbox)
 475 {
 476         int rval = QLA_SUCCESS;
 477         uint32_t i;
 478         unsigned long flags;
 479         uint32_t index = 0;
 480
 481         /* Acquire hardware specific lock */
 482         spin_lock_irqsave(&ha->hardware_lock, flags);
 483
 484         /* Get pointer to the queue entry for the marker */
 485         rval = qla4xxx_get_req_pkt(ha, (struct queue_entry **) &(mrb->mbox));
 486         if (rval != QLA_SUCCESS)
 487                 goto exit_mbox_iocb;
 488
 489         index = ha->mrb_index;
 490         /* get valid mrb index*/
 491         for (i = 0; i < MAX_MRB; i++) {
 492                 index++;
 493                 if (index == MAX_MRB)
 494                         index = 1;
 495                 if (ha->active_mrb_array[index] == NULL) {
 496                         ha->mrb_index = index;
 497                         break;
 498                 }
 499         }
 500
 501         mrb->iocb_cnt = 1;
 502         ha->active_mrb_array[index] = mrb;
 503         mrb->mbox->handle = index;
 504         mrb->mbox->hdr.entryType = ET_MBOX_CMD;
 505         mrb->mbox->hdr.entryCount = mrb->iocb_cnt;
 506         memcpy(mrb->mbox->in_mbox, in_mbox, 32);
 507         mrb->mbox_cmd = in_mbox[0];
 508         wmb();
 509
 510         ha->iocb_cnt += mrb->iocb_cnt;
 511         ha->isp_ops->queue_iocb(ha);
 512 exit_mbox_iocb:
 513         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 514         return rval;
 515 }
 516
 517 int qla4xxx_ping_iocb(struct scsi_qla_host *ha, uint32_t options,
 518                       uint32_t payload_size, uint32_t pid, uint8_t *ipaddr)
 519 {
 520         uint32_t in_mbox[8];
 521         struct mrb *mrb = NULL;
 522         int rval = QLA_SUCCESS;
 523
 524         memset(in_mbox, 0, sizeof(in_mbox));
 525
 526         mrb = qla4xxx_get_new_mrb(ha);
 527         if (!mrb) {
 528                 DEBUG2(ql4_printk(KERN_WARNING, ha, "%s: fail to get new mrb\n",
 529                                   __func__));
 530                 rval = QLA_ERROR;
 531                 goto exit_ping;
 532         }
 533
 534         in_mbox[0] = MBOX_CMD_PING;
 535         in_mbox[1] = options;
 536         memcpy(&in_mbox[2], &ipaddr[0], 4);
 537         memcpy(&in_mbox[3], &ipaddr[4], 4);
 538         memcpy(&in_mbox[4], &ipaddr[8], 4);
 539         memcpy(&in_mbox[5], &ipaddr[12], 4);
 540         in_mbox[6] = payload_size;
 541
 542         mrb->pid = pid;
 543         rval = qla4xxx_send_mbox_iocb(ha, mrb, in_mbox);
 544
 545         if (rval != QLA_SUCCESS)
 546                 goto exit_ping;
 547
 548         return rval;
 549 exit_ping:
 550         kfree(mrb);
 551         return rval;
 552 }