1 /*
2 * QLogic iSCSI HBA Driver
3 * Copyright (c) 2003-2010 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
qla4xxx_space_in_req_ring(struct scsi_qla_host * ha,uint16_t req_cnt)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
qla4xxx_advance_req_ring_ptr(struct scsi_qla_host * ha)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 **/
qla4xxx_get_req_pkt(struct scsi_qla_host * ha,struct queue_entry ** queue_entry)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 **/
qla4xxx_send_marker_iocb(struct scsi_qla_host * ha,struct ddb_entry * ddb_entry,int lun,uint16_t mrkr_mod)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 *
qla4xxx_alloc_cont_entry(struct scsi_qla_host * ha)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
qla4xxx_calc_request_entries(uint16_t dsds)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
qla4xxx_build_scsi_iocbs(struct srb * srb,struct command_t3_entry * cmd_entry,uint16_t tot_dsds)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 /**
196 * qla4_8xxx_queue_iocb - Tell ISP it's got new request(s)
197 * @ha: pointer to host adapter structure.
198 *
199 * This routine notifies the ISP that one or more new request
200 * queue entries have been placed on the request queue.
201 **/
qla4_8xxx_queue_iocb(struct scsi_qla_host * ha)202 void qla4_8xxx_queue_iocb(struct scsi_qla_host *ha)
203 {
204 uint32_t dbval = 0;
205
206 dbval = 0x14 | (ha->func_num << 5);
207 dbval = dbval | (0 << 8) | (ha->request_in << 16);
208
209 qla4_8xxx_wr_32(ha, ha->nx_db_wr_ptr, ha->request_in);
210 }
211
212 /**
213 * qla4_8xxx_complete_iocb - Tell ISP we're done with response(s)
214 * @ha: pointer to host adapter structure.
215 *
216 * This routine notifies the ISP that one or more response/completion
217 * queue entries have been processed by the driver.
218 * This also clears the interrupt.
219 **/
qla4_8xxx_complete_iocb(struct scsi_qla_host * ha)220 void qla4_8xxx_complete_iocb(struct scsi_qla_host *ha)
221 {
222 writel(ha->response_out, &ha->qla4_8xxx_reg->rsp_q_out);
223 readl(&ha->qla4_8xxx_reg->rsp_q_out);
224 }
225
226 /**
227 * qla4xxx_queue_iocb - Tell ISP it's got new request(s)
228 * @ha: pointer to host adapter structure.
229 *
230 * This routine is notifies the ISP that one or more new request
231 * queue entries have been placed on the request queue.
232 **/
qla4xxx_queue_iocb(struct scsi_qla_host * ha)233 void qla4xxx_queue_iocb(struct scsi_qla_host *ha)
234 {
235 writel(ha->request_in, &ha->reg->req_q_in);
236 readl(&ha->reg->req_q_in);
237 }
238
239 /**
240 * qla4xxx_complete_iocb - Tell ISP we're done with response(s)
241 * @ha: pointer to host adapter structure.
242 *
243 * This routine is notifies the ISP that one or more response/completion
244 * queue entries have been processed by the driver.
245 * This also clears the interrupt.
246 **/
qla4xxx_complete_iocb(struct scsi_qla_host * ha)247 void qla4xxx_complete_iocb(struct scsi_qla_host *ha)
248 {
249 writel(ha->response_out, &ha->reg->rsp_q_out);
250 readl(&ha->reg->rsp_q_out);
251 }
252
253 /**
254 * qla4xxx_send_command_to_isp - issues command to HBA
255 * @ha: pointer to host adapter structure.
256 * @srb: pointer to SCSI Request Block to be sent to ISP
257 *
258 * This routine is called by qla4xxx_queuecommand to build an ISP
259 * command and pass it to the ISP for execution.
260 **/
qla4xxx_send_command_to_isp(struct scsi_qla_host * ha,struct srb * srb)261 int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb)
262 {
263 struct scsi_cmnd *cmd = srb->cmd;
264 struct ddb_entry *ddb_entry;
265 struct command_t3_entry *cmd_entry;
266 int nseg;
267 uint16_t tot_dsds;
268 uint16_t req_cnt;
269 unsigned long flags;
270 uint32_t index;
271 char tag[2];
272
273 /* Get real lun and adapter */
274 ddb_entry = srb->ddb;
275
276 tot_dsds = 0;
277
278 /* Acquire hardware specific lock */
279 spin_lock_irqsave(&ha->hardware_lock, flags);
280
281 index = (uint32_t)cmd->request->tag;
282
283 /*
284 * Check to see if adapter is online before placing request on
285 * request queue. If a reset occurs and a request is in the queue,
286 * the firmware will still attempt to process the request, retrieving
287 * garbage for pointers.
288 */
289 if (!test_bit(AF_ONLINE, &ha->flags)) {
290 DEBUG2(printk("scsi%ld: %s: Adapter OFFLINE! "
291 "Do not issue command.\n",
292 ha->host_no, __func__));
293 goto queuing_error;
294 }
295
296 /* Calculate the number of request entries needed. */
297 nseg = scsi_dma_map(cmd);
298 if (nseg < 0)
299 goto queuing_error;
300 tot_dsds = nseg;
301
302 req_cnt = qla4xxx_calc_request_entries(tot_dsds);
303 if (!qla4xxx_space_in_req_ring(ha, req_cnt))
304 goto queuing_error;
305
306 /* total iocbs active */
307 if ((ha->iocb_cnt + req_cnt) >= REQUEST_QUEUE_DEPTH)
308 goto queuing_error;
309
310 /* Build command packet */
311 cmd_entry = (struct command_t3_entry *) ha->request_ptr;
312 memset(cmd_entry, 0, sizeof(struct command_t3_entry));
313 cmd_entry->hdr.entryType = ET_COMMAND;
314 cmd_entry->handle = cpu_to_le32(index);
315 cmd_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index);
316 cmd_entry->connection_id = cpu_to_le16(ddb_entry->connection_id);
317
318 int_to_scsilun(cmd->device->lun, &cmd_entry->lun);
319 cmd_entry->cmdSeqNum = cpu_to_le32(ddb_entry->CmdSn);
320 cmd_entry->ttlByteCnt = cpu_to_le32(scsi_bufflen(cmd));
321 memcpy(cmd_entry->cdb, cmd->cmnd, cmd->cmd_len);
322 cmd_entry->dataSegCnt = cpu_to_le16(tot_dsds);
323 cmd_entry->hdr.entryCount = req_cnt;
324
325 /* Set data transfer direction control flags
326 * NOTE: Look at data_direction bits iff there is data to be
327 * transferred, as the data direction bit is sometimed filled
328 * in when there is no data to be transferred */
329 cmd_entry->control_flags = CF_NO_DATA;
330 if (scsi_bufflen(cmd)) {
331 if (cmd->sc_data_direction == DMA_TO_DEVICE)
332 cmd_entry->control_flags = CF_WRITE;
333 else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
334 cmd_entry->control_flags = CF_READ;
335
336 ha->bytes_xfered += scsi_bufflen(cmd);
337 if (ha->bytes_xfered & ~0xFFFFF){
338 ha->total_mbytes_xferred += ha->bytes_xfered >> 20;
339 ha->bytes_xfered &= 0xFFFFF;
340 }
341 }
342
343 /* Set tagged queueing control flags */
344 cmd_entry->control_flags |= CF_SIMPLE_TAG;
345 if (scsi_populate_tag_msg(cmd, tag))
346 switch (tag[0]) {
347 case MSG_HEAD_TAG:
348 cmd_entry->control_flags |= CF_HEAD_TAG;
349 break;
350 case MSG_ORDERED_TAG:
351 cmd_entry->control_flags |= CF_ORDERED_TAG;
352 break;
353 }
354
355 qla4xxx_advance_req_ring_ptr(ha);
356 qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds);
357 wmb();
358
359 srb->cmd->host_scribble = (unsigned char *)(unsigned long)index;
360
361 /* update counters */
362 srb->state = SRB_ACTIVE_STATE;
363 srb->flags |= SRB_DMA_VALID;
364
365 /* Track IOCB used */
366 ha->iocb_cnt += req_cnt;
367 srb->iocb_cnt = req_cnt;
368 ha->req_q_count -= req_cnt;
369
370 ha->isp_ops->queue_iocb(ha);
371 spin_unlock_irqrestore(&ha->hardware_lock, flags);
372
373 return QLA_SUCCESS;
374
375 queuing_error:
376 if (tot_dsds)
377 scsi_dma_unmap(cmd);
378
379 spin_unlock_irqrestore(&ha->hardware_lock, flags);
380
381 return QLA_ERROR;
382 }
383
384