2 * QLogic iSCSI HBA Driver
3 * Copyright (c) 2003-2012 QLogic Corporation
5 * See LICENSE.qla4xxx for copyright and licensing details.
11 #include "ql4_inline.h"
13 #include <scsi/scsi_tcq.h>
16 qla4xxx_space_in_req_ring(struct scsi_qla_host *ha, uint16_t req_cnt)
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;
26 ha->req_q_count = REQUEST_QUEUE_DEPTH -
27 (ha->request_in - cnt);
30 /* Check if room for request in request ring. */
31 if ((req_cnt + 2) < ha->req_q_count)
37 static void qla4xxx_advance_req_ring_ptr(struct scsi_qla_host *ha)
39 /* Advance request queue pointer */
40 if (ha->request_in == (REQUEST_QUEUE_DEPTH - 1)) {
42 ha->request_ptr = ha->request_ring;
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
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
59 static int qla4xxx_get_req_pkt(struct scsi_qla_host *ha,
60 struct queue_entry **queue_entry)
64 if (qla4xxx_space_in_req_ring(ha, req_cnt)) {
65 *queue_entry = ha->request_ptr;
66 memset(*queue_entry, 0, sizeof(**queue_entry));
68 qla4xxx_advance_req_ring_ptr(ha);
69 ha->req_q_count -= req_cnt;
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
81 * @marker_type: marker identifier
83 * This routine issues a marker IOCB.
85 int qla4xxx_send_marker_iocb(struct scsi_qla_host *ha,
86 struct ddb_entry *ddb_entry, int lun, uint16_t mrkr_mod)
88 struct qla4_marker_entry *marker_entry;
89 unsigned long flags = 0;
90 uint8_t status = QLA_SUCCESS;
92 /* Acquire hardware specific lock */
93 spin_lock_irqsave(&ha->hardware_lock, flags);
95 /* Get pointer to the queue entry for the marker */
96 if (qla4xxx_get_req_pkt(ha, (struct queue_entry **) &marker_entry) !=
99 goto exit_send_marker;
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);
110 /* Tell ISP it's got a new I/O request */
111 ha->isp_ops->queue_iocb(ha);
114 spin_unlock_irqrestore(&ha->hardware_lock, flags);
118 static struct continuation_t1_entry *
119 qla4xxx_alloc_cont_entry(struct scsi_qla_host *ha)
121 struct continuation_t1_entry *cont_entry;
123 cont_entry = (struct continuation_t1_entry *)ha->request_ptr;
125 qla4xxx_advance_req_ring_ptr(ha);
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);
135 static uint16_t qla4xxx_calc_request_entries(uint16_t dsds)
140 if (dsds > COMMAND_SEG) {
141 iocbs += (dsds - COMMAND_SEG) / CONTINUE_SEG;
142 if ((dsds - COMMAND_SEG) % CONTINUE_SEG)
148 static void qla4xxx_build_scsi_iocbs(struct srb *srb,
149 struct command_t3_entry *cmd_entry,
152 struct scsi_qla_host *ha;
154 struct data_seg_a64 *cur_dsd;
155 struct scsi_cmnd *cmd;
156 struct scatterlist *sg;
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);
168 avail_dsds = COMMAND_SEG;
169 cur_dsd = (struct data_seg_a64 *) & (cmd_entry->dataseg[0]);
171 scsi_for_each_sg(cmd, sg, tot_dsds, i) {
174 /* Allocate additional continuation packets? */
175 if (avail_dsds == 0) {
176 struct continuation_t1_entry *cont_entry;
178 cont_entry = qla4xxx_alloc_cont_entry(ha);
180 (struct data_seg_a64 *)
181 &cont_entry->dataseg[0];
182 avail_dsds = CONTINUE_SEG;
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));
195 void qla4_83xx_queue_iocb(struct scsi_qla_host *ha)
197 writel(ha->request_in, &ha->qla4_83xx_reg->req_q_in);
198 readl(&ha->qla4_83xx_reg->req_q_in);
201 void qla4_83xx_complete_iocb(struct scsi_qla_host *ha)
203 writel(ha->response_out, &ha->qla4_83xx_reg->rsp_q_out);
204 readl(&ha->qla4_83xx_reg->rsp_q_out);
208 * qla4_82xx_queue_iocb - Tell ISP it's got new request(s)
209 * @ha: pointer to host adapter structure.
211 * This routine notifies the ISP that one or more new request
212 * queue entries have been placed on the request queue.
214 void qla4_82xx_queue_iocb(struct scsi_qla_host *ha)
218 dbval = 0x14 | (ha->func_num << 5);
219 dbval = dbval | (0 << 8) | (ha->request_in << 16);
221 qla4_82xx_wr_32(ha, ha->nx_db_wr_ptr, ha->request_in);
225 * qla4_82xx_complete_iocb - Tell ISP we're done with response(s)
226 * @ha: pointer to host adapter structure.
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.
232 void qla4_82xx_complete_iocb(struct scsi_qla_host *ha)
234 writel(ha->response_out, &ha->qla4_82xx_reg->rsp_q_out);
235 readl(&ha->qla4_82xx_reg->rsp_q_out);
239 * qla4xxx_queue_iocb - Tell ISP it's got new request(s)
240 * @ha: pointer to host adapter structure.
242 * This routine is notifies the ISP that one or more new request
243 * queue entries have been placed on the request queue.
245 void qla4xxx_queue_iocb(struct scsi_qla_host *ha)
247 writel(ha->request_in, &ha->reg->req_q_in);
248 readl(&ha->reg->req_q_in);
252 * qla4xxx_complete_iocb - Tell ISP we're done with response(s)
253 * @ha: pointer to host adapter structure.
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.
259 void qla4xxx_complete_iocb(struct scsi_qla_host *ha)
261 writel(ha->response_out, &ha->reg->rsp_q_out);
262 readl(&ha->reg->rsp_q_out);
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
270 * This routine is called by qla4xxx_queuecommand to build an ISP
271 * command and pass it to the ISP for execution.
273 int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb)
275 struct scsi_cmnd *cmd = srb->cmd;
276 struct ddb_entry *ddb_entry;
277 struct command_t3_entry *cmd_entry;
285 /* Get real lun and adapter */
286 ddb_entry = srb->ddb;
290 /* Acquire hardware specific lock */
291 spin_lock_irqsave(&ha->hardware_lock, flags);
293 index = (uint32_t)cmd->request->tag;
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.
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__));
308 /* Calculate the number of request entries needed. */
309 nseg = scsi_dma_map(cmd);
314 req_cnt = qla4xxx_calc_request_entries(tot_dsds);
315 if (!qla4xxx_space_in_req_ring(ha, req_cnt))
318 /* total iocbs active */
319 if ((ha->iocb_cnt + req_cnt) >= ha->iocb_hiwat)
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);
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;
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;
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;
353 /* Set tagged queueing control flags */
354 cmd_entry->control_flags |= CF_SIMPLE_TAG;
355 if (scsi_populate_tag_msg(cmd, tag))
358 cmd_entry->control_flags |= CF_HEAD_TAG;
360 case MSG_ORDERED_TAG:
361 cmd_entry->control_flags |= CF_ORDERED_TAG;
365 qla4xxx_advance_req_ring_ptr(ha);
366 qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds);
369 srb->cmd->host_scribble = (unsigned char *)(unsigned long)index;
371 /* update counters */
372 srb->state = SRB_ACTIVE_STATE;
373 srb->flags |= SRB_DMA_VALID;
375 /* Track IOCB used */
376 ha->iocb_cnt += req_cnt;
377 srb->iocb_cnt = req_cnt;
378 ha->req_q_count -= req_cnt;
380 ha->isp_ops->queue_iocb(ha);
381 spin_unlock_irqrestore(&ha->hardware_lock, flags);
389 spin_unlock_irqrestore(&ha->hardware_lock, flags);
394 int qla4xxx_send_passthru0(struct iscsi_task *task)
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;
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))
411 passthru_iocb = (struct passthru0 *) ha->request_ptr;
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);
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));
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);
443 ctrl_flags |= (PT_FLAG_ISCSI_PDU | PT_FLAG_WAIT_4_RESPONSE);
444 passthru_iocb->control_flags = cpu_to_le16(ctrl_flags);
446 /* Update the request pointer */
447 qla4xxx_advance_req_ring_ptr(ha);
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);
457 spin_unlock_irqrestore(&ha->hardware_lock, flags);
461 static struct mrb *qla4xxx_get_new_mrb(struct scsi_qla_host *ha)
465 mrb = kzalloc(sizeof(*mrb), GFP_KERNEL);
473 static int qla4xxx_send_mbox_iocb(struct scsi_qla_host *ha, struct mrb *mrb,
476 int rval = QLA_SUCCESS;
481 /* Acquire hardware specific lock */
482 spin_lock_irqsave(&ha->hardware_lock, flags);
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)
489 index = ha->mrb_index;
490 /* get valid mrb index*/
491 for (i = 0; i < MAX_MRB; i++) {
493 if (index == MAX_MRB)
495 if (ha->active_mrb_array[index] == NULL) {
496 ha->mrb_index = index;
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];
510 ha->isp_ops->queue_iocb(ha);
512 spin_unlock_irqrestore(&ha->hardware_lock, flags);
516 int qla4xxx_ping_iocb(struct scsi_qla_host *ha, uint32_t options,
517 uint32_t payload_size, uint32_t pid, uint8_t *ipaddr)
520 struct mrb *mrb = NULL;
521 int rval = QLA_SUCCESS;
523 memset(in_mbox, 0, sizeof(in_mbox));
525 mrb = qla4xxx_get_new_mrb(ha);
527 DEBUG2(ql4_printk(KERN_WARNING, ha, "%s: fail to get new mrb\n",
533 in_mbox[0] = MBOX_CMD_PING;
534 in_mbox[1] = options;
535 memcpy(&in_mbox[2], &ipaddr[0], 4);
536 memcpy(&in_mbox[3], &ipaddr[4], 4);
537 memcpy(&in_mbox[4], &ipaddr[8], 4);
538 memcpy(&in_mbox[5], &ipaddr[12], 4);
539 in_mbox[6] = payload_size;
542 rval = qla4xxx_send_mbox_iocb(ha, mrb, in_mbox);
544 if (rval != QLA_SUCCESS)