2 * QLogic iSCSI HBA Driver
3 * Copyright (c) 2003-2006 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) le32_to_cpu(ha->shadow_regs->req_q_out);
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 writel(ha->request_in, &ha->reg->req_q_in);
112 readl(&ha->reg->req_q_in);
115 spin_unlock_irqrestore(&ha->hardware_lock, flags);
119 static struct continuation_t1_entry *
120 qla4xxx_alloc_cont_entry(struct scsi_qla_host *ha)
122 struct continuation_t1_entry *cont_entry;
124 cont_entry = (struct continuation_t1_entry *)ha->request_ptr;
126 qla4xxx_advance_req_ring_ptr(ha);
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);
136 static uint16_t qla4xxx_calc_request_entries(uint16_t dsds)
141 if (dsds > COMMAND_SEG) {
142 iocbs += (dsds - COMMAND_SEG) / CONTINUE_SEG;
143 if ((dsds - COMMAND_SEG) % CONTINUE_SEG)
149 static void qla4xxx_build_scsi_iocbs(struct srb *srb,
150 struct command_t3_entry *cmd_entry,
153 struct scsi_qla_host *ha;
155 struct data_seg_a64 *cur_dsd;
156 struct scsi_cmnd *cmd;
157 struct scatterlist *sg;
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);
169 avail_dsds = COMMAND_SEG;
170 cur_dsd = (struct data_seg_a64 *) & (cmd_entry->dataseg[0]);
172 scsi_for_each_sg(cmd, sg, tot_dsds, i) {
175 /* Allocate additional continuation packets? */
176 if (avail_dsds == 0) {
177 struct continuation_t1_entry *cont_entry;
179 cont_entry = qla4xxx_alloc_cont_entry(ha);
181 (struct data_seg_a64 *)
182 &cont_entry->dataseg[0];
183 avail_dsds = CONTINUE_SEG;
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));
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
201 * This routine is called by qla4xxx_queuecommand to build an ISP
202 * command and pass it to the ISP for execution.
204 int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb)
206 struct scsi_cmnd *cmd = srb->cmd;
207 struct ddb_entry *ddb_entry;
208 struct command_t3_entry *cmd_entry;
216 /* Get real lun and adapter */
217 ddb_entry = srb->ddb;
221 /* Acquire hardware specific lock */
222 spin_lock_irqsave(&ha->hardware_lock, flags);
224 index = (uint32_t)cmd->request->tag;
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.
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__));
239 /* Calculate the number of request entries needed. */
240 nseg = scsi_dma_map(cmd);
245 req_cnt = qla4xxx_calc_request_entries(tot_dsds);
246 if (!qla4xxx_space_in_req_ring(ha, req_cnt))
249 /* total iocbs active */
250 if ((ha->iocb_cnt + req_cnt) >= REQUEST_QUEUE_DEPTH)
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);
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;
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;
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;
286 /* Set tagged queueing control flags */
287 cmd_entry->control_flags |= CF_SIMPLE_TAG;
288 if (scsi_populate_tag_msg(cmd, tag))
291 cmd_entry->control_flags |= CF_HEAD_TAG;
293 case MSG_ORDERED_TAG:
294 cmd_entry->control_flags |= CF_ORDERED_TAG;
298 qla4xxx_advance_req_ring_ptr(ha);
299 qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds);
302 srb->cmd->host_scribble = (unsigned char *)srb;
304 /* update counters */
305 srb->state = SRB_ACTIVE_STATE;
306 srb->flags |= SRB_DMA_VALID;
308 /* Track IOCB used */
309 ha->iocb_cnt += req_cnt;
310 srb->iocb_cnt = req_cnt;
311 ha->req_q_count -= req_cnt;
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);
324 spin_unlock_irqrestore(&ha->hardware_lock, flags);