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) 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
));
196 * qla4_8xxx_queue_iocb - Tell ISP it's got new request(s)
197 * @ha: pointer to host adapter structure.
199 * This routine notifies the ISP that one or more new request
200 * queue entries have been placed on the request queue.
202 void qla4_8xxx_queue_iocb(struct scsi_qla_host
*ha
)
207 dbval
= 0x14 | (ha
->func_num
<< 5);
208 dbval
= dbval
| (0 << 8) | (ha
->request_in
<< 16);
209 writel(dbval
, (unsigned long __iomem
*)ha
->nx_db_wr_ptr
);
212 wtime
= jiffies
+ (2 * HZ
);
213 while (readl((void __iomem
*)ha
->nx_db_rd_ptr
) != dbval
&&
214 !time_after_eq(jiffies
, wtime
)) {
215 writel(dbval
, (unsigned long __iomem
*)ha
->nx_db_wr_ptr
);
221 * qla4_8xxx_complete_iocb - Tell ISP we're done with response(s)
222 * @ha: pointer to host adapter structure.
224 * This routine notifies the ISP that one or more response/completion
225 * queue entries have been processed by the driver.
226 * This also clears the interrupt.
228 void qla4_8xxx_complete_iocb(struct scsi_qla_host
*ha
)
230 writel(ha
->response_out
, &ha
->qla4_8xxx_reg
->rsp_q_out
);
231 readl(&ha
->qla4_8xxx_reg
->rsp_q_out
);
235 * qla4xxx_queue_iocb - Tell ISP it's got new request(s)
236 * @ha: pointer to host adapter structure.
238 * This routine is notifies the ISP that one or more new request
239 * queue entries have been placed on the request queue.
241 void qla4xxx_queue_iocb(struct scsi_qla_host
*ha
)
243 writel(ha
->request_in
, &ha
->reg
->req_q_in
);
244 readl(&ha
->reg
->req_q_in
);
248 * qla4xxx_complete_iocb - Tell ISP we're done with response(s)
249 * @ha: pointer to host adapter structure.
251 * This routine is notifies the ISP that one or more response/completion
252 * queue entries have been processed by the driver.
253 * This also clears the interrupt.
255 void qla4xxx_complete_iocb(struct scsi_qla_host
*ha
)
257 writel(ha
->response_out
, &ha
->reg
->rsp_q_out
);
258 readl(&ha
->reg
->rsp_q_out
);
262 * qla4xxx_send_command_to_isp - issues command to HBA
263 * @ha: pointer to host adapter structure.
264 * @srb: pointer to SCSI Request Block to be sent to ISP
266 * This routine is called by qla4xxx_queuecommand to build an ISP
267 * command and pass it to the ISP for execution.
269 int qla4xxx_send_command_to_isp(struct scsi_qla_host
*ha
, struct srb
* srb
)
271 struct scsi_cmnd
*cmd
= srb
->cmd
;
272 struct ddb_entry
*ddb_entry
;
273 struct command_t3_entry
*cmd_entry
;
281 /* Get real lun and adapter */
282 ddb_entry
= srb
->ddb
;
286 /* Acquire hardware specific lock */
287 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
289 index
= (uint32_t)cmd
->request
->tag
;
292 * Check to see if adapter is online before placing request on
293 * request queue. If a reset occurs and a request is in the queue,
294 * the firmware will still attempt to process the request, retrieving
295 * garbage for pointers.
297 if (!test_bit(AF_ONLINE
, &ha
->flags
)) {
298 DEBUG2(printk("scsi%ld: %s: Adapter OFFLINE! "
299 "Do not issue command.\n",
300 ha
->host_no
, __func__
));
304 /* Calculate the number of request entries needed. */
305 nseg
= scsi_dma_map(cmd
);
310 req_cnt
= qla4xxx_calc_request_entries(tot_dsds
);
311 if (!qla4xxx_space_in_req_ring(ha
, req_cnt
))
314 /* total iocbs active */
315 if ((ha
->iocb_cnt
+ req_cnt
) >= REQUEST_QUEUE_DEPTH
)
318 /* Build command packet */
319 cmd_entry
= (struct command_t3_entry
*) ha
->request_ptr
;
320 memset(cmd_entry
, 0, sizeof(struct command_t3_entry
));
321 cmd_entry
->hdr
.entryType
= ET_COMMAND
;
322 cmd_entry
->handle
= cpu_to_le32(index
);
323 cmd_entry
->target
= cpu_to_le16(ddb_entry
->fw_ddb_index
);
324 cmd_entry
->connection_id
= cpu_to_le16(ddb_entry
->connection_id
);
326 int_to_scsilun(cmd
->device
->lun
, &cmd_entry
->lun
);
327 cmd_entry
->cmdSeqNum
= cpu_to_le32(ddb_entry
->CmdSn
);
328 cmd_entry
->ttlByteCnt
= cpu_to_le32(scsi_bufflen(cmd
));
329 memcpy(cmd_entry
->cdb
, cmd
->cmnd
, cmd
->cmd_len
);
330 cmd_entry
->dataSegCnt
= cpu_to_le16(tot_dsds
);
331 cmd_entry
->hdr
.entryCount
= req_cnt
;
333 /* Set data transfer direction control flags
334 * NOTE: Look at data_direction bits iff there is data to be
335 * transferred, as the data direction bit is sometimed filled
336 * in when there is no data to be transferred */
337 cmd_entry
->control_flags
= CF_NO_DATA
;
338 if (scsi_bufflen(cmd
)) {
339 if (cmd
->sc_data_direction
== DMA_TO_DEVICE
)
340 cmd_entry
->control_flags
= CF_WRITE
;
341 else if (cmd
->sc_data_direction
== DMA_FROM_DEVICE
)
342 cmd_entry
->control_flags
= CF_READ
;
344 ha
->bytes_xfered
+= scsi_bufflen(cmd
);
345 if (ha
->bytes_xfered
& ~0xFFFFF){
346 ha
->total_mbytes_xferred
+= ha
->bytes_xfered
>> 20;
347 ha
->bytes_xfered
&= 0xFFFFF;
351 /* Set tagged queueing control flags */
352 cmd_entry
->control_flags
|= CF_SIMPLE_TAG
;
353 if (scsi_populate_tag_msg(cmd
, tag
))
356 cmd_entry
->control_flags
|= CF_HEAD_TAG
;
358 case MSG_ORDERED_TAG
:
359 cmd_entry
->control_flags
|= CF_ORDERED_TAG
;
363 qla4xxx_advance_req_ring_ptr(ha
);
364 qla4xxx_build_scsi_iocbs(srb
, cmd_entry
, tot_dsds
);
367 srb
->cmd
->host_scribble
= (unsigned char *)(unsigned long)index
;
369 /* update counters */
370 srb
->state
= SRB_ACTIVE_STATE
;
371 srb
->flags
|= SRB_DMA_VALID
;
373 /* Track IOCB used */
374 ha
->iocb_cnt
+= req_cnt
;
375 srb
->iocb_cnt
= req_cnt
;
376 ha
->req_q_count
-= req_cnt
;
378 ha
->isp_ops
->queue_iocb(ha
);
379 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
387 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);