4ef9ba112ee87ecd55e4815a6572db9d9bf43106
[linux-2.6.git] / drivers / scsi / qla4xxx / ql4_iocb.c
1 /*
2  * QLogic iSCSI HBA Driver
3  * Copyright (c)  2003-2006 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 /**
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  **/
202 void qla4_8xxx_queue_iocb(struct scsi_qla_host *ha)
203 {
204         uint32_t dbval = 0;
205         unsigned long wtime;
206
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);
210         wmb();
211
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);
216                 wmb();
217         }
218 }
219
220 /**
221  * qla4_8xxx_complete_iocb - Tell ISP we're done with response(s)
222  * @ha: pointer to host adapter structure.
223  *
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.
227  **/
228 void qla4_8xxx_complete_iocb(struct scsi_qla_host *ha)
229 {
230         writel(ha->response_out, &ha->qla4_8xxx_reg->rsp_q_out);
231         readl(&ha->qla4_8xxx_reg->rsp_q_out);
232 }
233
234 /**
235  * qla4xxx_queue_iocb - Tell ISP it's got new request(s)
236  * @ha: pointer to host adapter structure.
237  *
238  * This routine is notifies the ISP that one or more new request
239  * queue entries have been placed on the request queue.
240  **/
241 void qla4xxx_queue_iocb(struct scsi_qla_host *ha)
242 {
243         writel(ha->request_in, &ha->reg->req_q_in);
244         readl(&ha->reg->req_q_in);
245 }
246
247 /**
248  * qla4xxx_complete_iocb - Tell ISP we're done with response(s)
249  * @ha: pointer to host adapter structure.
250  *
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.
254  **/
255 void qla4xxx_complete_iocb(struct scsi_qla_host *ha)
256 {
257         writel(ha->response_out, &ha->reg->rsp_q_out);
258         readl(&ha->reg->rsp_q_out);
259 }
260
261 /**
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
265  *
266  * This routine is called by qla4xxx_queuecommand to build an ISP
267  * command and pass it to the ISP for execution.
268  **/
269 int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb)
270 {
271         struct scsi_cmnd *cmd = srb->cmd;
272         struct ddb_entry *ddb_entry;
273         struct command_t3_entry *cmd_entry;
274         int nseg;
275         uint16_t tot_dsds;
276         uint16_t req_cnt;
277         unsigned long flags;
278         uint32_t index;
279         char tag[2];
280
281         /* Get real lun and adapter */
282         ddb_entry = srb->ddb;
283
284         tot_dsds = 0;
285
286         /* Acquire hardware specific lock */
287         spin_lock_irqsave(&ha->hardware_lock, flags);
288
289         index = (uint32_t)cmd->request->tag;
290
291         /*
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.
296          */
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__));
301                 goto queuing_error;
302         }
303
304         /* Calculate the number of request entries needed. */
305         nseg = scsi_dma_map(cmd);
306         if (nseg < 0)
307                 goto queuing_error;
308         tot_dsds = nseg;
309
310         req_cnt = qla4xxx_calc_request_entries(tot_dsds);
311         if (!qla4xxx_space_in_req_ring(ha, req_cnt))
312                 goto queuing_error;
313
314         /* total iocbs active */
315         if ((ha->iocb_cnt + req_cnt) >= REQUEST_QUEUE_DEPTH)
316                 goto queuing_error;
317
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);
325
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;
332
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;
343
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;
348                 }
349         }
350
351         /* Set tagged queueing control flags */
352         cmd_entry->control_flags |= CF_SIMPLE_TAG;
353         if (scsi_populate_tag_msg(cmd, tag))
354                 switch (tag[0]) {
355                 case MSG_HEAD_TAG:
356                         cmd_entry->control_flags |= CF_HEAD_TAG;
357                         break;
358                 case MSG_ORDERED_TAG:
359                         cmd_entry->control_flags |= CF_ORDERED_TAG;
360                         break;
361                 }
362
363         qla4xxx_advance_req_ring_ptr(ha);
364         qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds);
365         wmb();
366
367         srb->cmd->host_scribble = (unsigned char *)(unsigned long)index;
368
369         /* update counters */
370         srb->state = SRB_ACTIVE_STATE;
371         srb->flags |= SRB_DMA_VALID;
372
373         /* Track IOCB used */
374         ha->iocb_cnt += req_cnt;
375         srb->iocb_cnt = req_cnt;
376         ha->req_q_count -= req_cnt;
377
378         ha->isp_ops->queue_iocb(ha);
379         spin_unlock_irqrestore(&ha->hardware_lock, flags);
380
381         return QLA_SUCCESS;
382
383 queuing_error:
384         if (tot_dsds)
385                 scsi_dma_unmap(cmd);
386
387         spin_unlock_irqrestore(&ha->hardware_lock, flags);
388
389         return QLA_ERROR;
390 }
391