2 * Adaptec AAC series RAID controller driver
3 * (c) Copyright 2001 Red Hat Inc. <alan@redhat.com>
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
8 * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; see the file COPYING. If not, write to
22 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
27 * Abstract: All DPC processing routines for the cyclone board occur here.
32 #include <linux/kernel.h>
33 #include <linux/init.h>
34 #include <linux/types.h>
35 #include <linux/spinlock.h>
36 #include <linux/slab.h>
37 #include <linux/completion.h>
38 #include <linux/blkdev.h>
39 #include <asm/semaphore.h>
44 * aac_response_normal - Handle command replies
45 * @q: Queue to read from
47 * This DPC routine will be run when the adapter interrupts us to let us
48 * know there is a response on our normal priority queue. We will pull off
49 * all QE there are and wake up all the waiters before exiting. We will
50 * take a spinlock out on the queue before operating on it.
53 unsigned int aac_response_normal(struct aac_queue
* q
)
55 struct aac_dev
* dev
= q
->dev
;
56 struct aac_entry
*entry
;
57 struct hw_fib
* hwfib
;
62 spin_lock_irqsave(q
->lock
, flags
);
64 * Keep pulling response QEs off the response queue and waking
65 * up the waiters until there are no more QEs. We then return
66 * back to the system. If no response was requesed we just
67 * deallocate the Fib here and continue.
69 while(aac_consumer_get(dev
, q
, &entry
))
72 u32 index
= le32_to_cpu(entry
->addr
);
74 fib
= &dev
->fibs
[index
>> 2];
77 aac_consumer_free(dev
, q
, HostNormRespQueue
);
79 * Remove this fib from the Outstanding I/O queue.
80 * But only if it has not already been timed out.
82 * If the fib has been timed out already, then just
83 * continue. The caller has already been notified that
86 if (!(fib
->flags
& FIB_CONTEXT_FLAG_TIMED_OUT
))
87 dev
->queues
->queue
[AdapNormCmdQueue
].numpending
--;
89 printk(KERN_WARNING
"aacraid: FIB timeout (%x).\n", fib
->flags
);
90 printk(KERN_DEBUG
"aacraid: hwfib=%p fib index=%i fib=%p\n",hwfib
, hwfib
->header
.SenderData
,fib
);
93 spin_unlock_irqrestore(q
->lock
, flags
);
99 *(__le32
*)hwfib
->data
= cpu_to_le32(ST_OK
);
100 hwfib
->header
.XferState
|= cpu_to_le32(AdapterProcessed
);
103 FIB_COUNTER_INCREMENT(aac_config
.FibRecved
);
105 if (hwfib
->header
.Command
== cpu_to_le16(NuFileSystem
))
107 __le32
*pstatus
= (__le32
*)hwfib
->data
;
108 if (*pstatus
& cpu_to_le32(0xffff0000))
109 *pstatus
= cpu_to_le32(ST_OK
);
111 if (hwfib
->header
.XferState
& cpu_to_le32(NoResponseExpected
| Async
))
113 if (hwfib
->header
.XferState
& cpu_to_le32(NoResponseExpected
))
114 FIB_COUNTER_INCREMENT(aac_config
.NoResponseRecved
);
116 FIB_COUNTER_INCREMENT(aac_config
.AsyncRecved
);
118 * NOTE: we cannot touch the fib after this
119 * call, because it may have been deallocated.
121 fib
->callback(fib
->callback_data
, fib
);
124 spin_lock_irqsave(&fib
->event_lock
, flagv
);
127 up(&fib
->event_wait
);
128 spin_unlock_irqrestore(&fib
->event_lock
, flagv
);
129 FIB_COUNTER_INCREMENT(aac_config
.NormalRecved
);
130 if (fib
->done
== 2) {
131 aac_fib_complete(fib
);
136 spin_lock_irqsave(q
->lock
, flags
);
139 if (consumed
> aac_config
.peak_fibs
)
140 aac_config
.peak_fibs
= consumed
;
142 aac_config
.zero_fibs
++;
144 spin_unlock_irqrestore(q
->lock
, flags
);
150 * aac_command_normal - handle commands
151 * @q: queue to process
153 * This DPC routine will be queued when the adapter interrupts us to
154 * let us know there is a command on our normal priority queue. We will
155 * pull off all QE there are and wake up all the waiters before exiting.
156 * We will take a spinlock out on the queue before operating on it.
159 unsigned int aac_command_normal(struct aac_queue
*q
)
161 struct aac_dev
* dev
= q
->dev
;
162 struct aac_entry
*entry
;
165 spin_lock_irqsave(q
->lock
, flags
);
168 * Keep pulling response QEs off the response queue and waking
169 * up the waiters until there are no more QEs. We then return
170 * back to the system.
172 while(aac_consumer_get(dev
, q
, &entry
))
175 struct hw_fib
* hw_fib
;
177 struct fib
*fib
= &fibctx
;
179 index
= le32_to_cpu(entry
->addr
) / sizeof(struct hw_fib
);
180 hw_fib
= &dev
->aif_base_va
[index
];
183 * Allocate a FIB at all costs. For non queued stuff
184 * we can just use the stack so we are happy. We need
185 * a fib object in order to manage the linked lists
188 if((fib
= kmalloc(sizeof(struct fib
), GFP_ATOMIC
)) == NULL
)
191 memset(fib
, 0, sizeof(struct fib
));
192 INIT_LIST_HEAD(&fib
->fiblink
);
193 fib
->type
= FSAFS_NTC_FIB_CONTEXT
;
194 fib
->size
= sizeof(struct fib
);
195 fib
->hw_fib
= hw_fib
;
196 fib
->data
= hw_fib
->data
;
200 if (dev
->aif_thread
&& fib
!= &fibctx
) {
201 list_add_tail(&fib
->fiblink
, &q
->cmdq
);
202 aac_consumer_free(dev
, q
, HostNormCmdQueue
);
203 wake_up_interruptible(&q
->cmdready
);
205 aac_consumer_free(dev
, q
, HostNormCmdQueue
);
206 spin_unlock_irqrestore(q
->lock
, flags
);
208 * Set the status of this FIB
210 *(__le32
*)hw_fib
->data
= cpu_to_le32(ST_OK
);
211 aac_fib_adapter_complete(fib
, sizeof(u32
));
212 spin_lock_irqsave(q
->lock
, flags
);
215 spin_unlock_irqrestore(q
->lock
, flags
);
221 * aac_intr_normal - Handle command replies
223 * @index: completion reference
225 * This DPC routine will be run when the adapter interrupts us to let us
226 * know there is a response on our normal priority queue. We will pull off
227 * all QE there are and wake up all the waiters before exiting.
230 unsigned int aac_intr_normal(struct aac_dev
* dev
, u32 Index
)
232 u32 index
= le32_to_cpu(Index
);
234 dprintk((KERN_INFO
"aac_intr_normal(%p,%x)\n", dev
, Index
));
235 if ((index
& 0x00000002L
)) {
236 struct hw_fib
* hw_fib
;
238 struct aac_queue
*q
= &dev
->queues
->queue
[HostNormCmdQueue
];
241 if (index
== 0xFFFFFFFEL
) /* Special Case */
242 return 0; /* Do nothing */
244 * Allocate a FIB. For non queued stuff we can just use
245 * the stack so we are happy. We need a fib object in order to
246 * manage the linked lists.
248 if ((!dev
->aif_thread
)
249 || (!(fib
= kmalloc(sizeof(struct fib
),GFP_ATOMIC
))))
251 if (!(hw_fib
= kmalloc(sizeof(struct hw_fib
),GFP_ATOMIC
))) {
255 memset(hw_fib
, 0, sizeof(struct hw_fib
));
256 memcpy(hw_fib
, (struct hw_fib
*)(((unsigned long)(dev
->regs
.sa
)) + (index
& ~0x00000002L
)), sizeof(struct hw_fib
));
257 memset(fib
, 0, sizeof(struct fib
));
258 INIT_LIST_HEAD(&fib
->fiblink
);
259 fib
->type
= FSAFS_NTC_FIB_CONTEXT
;
260 fib
->size
= sizeof(struct fib
);
261 fib
->hw_fib
= hw_fib
;
262 fib
->data
= hw_fib
->data
;
265 spin_lock_irqsave(q
->lock
, flags
);
266 list_add_tail(&fib
->fiblink
, &q
->cmdq
);
267 wake_up_interruptible(&q
->cmdready
);
268 spin_unlock_irqrestore(q
->lock
, flags
);
271 int fast
= index
& 0x01;
272 struct fib
* fib
= &dev
->fibs
[index
>> 2];
273 struct hw_fib
* hwfib
= fib
->hw_fib
;
276 * Remove this fib from the Outstanding I/O queue.
277 * But only if it has not already been timed out.
279 * If the fib has been timed out already, then just
280 * continue. The caller has already been notified that
283 if ((fib
->flags
& FIB_CONTEXT_FLAG_TIMED_OUT
)) {
284 printk(KERN_WARNING
"aacraid: FIB timeout (%x).\n", fib
->flags
);
285 printk(KERN_DEBUG
"aacraid: hwfib=%p index=%i fib=%p\n",hwfib
, hwfib
->header
.SenderData
,fib
);
289 dev
->queues
->queue
[AdapNormCmdQueue
].numpending
--;
295 *(__le32
*)hwfib
->data
= cpu_to_le32(ST_OK
);
296 hwfib
->header
.XferState
|= cpu_to_le32(AdapterProcessed
);
299 FIB_COUNTER_INCREMENT(aac_config
.FibRecved
);
301 if (hwfib
->header
.Command
== cpu_to_le16(NuFileSystem
))
303 u32
*pstatus
= (u32
*)hwfib
->data
;
304 if (*pstatus
& cpu_to_le32(0xffff0000))
305 *pstatus
= cpu_to_le32(ST_OK
);
307 if (hwfib
->header
.XferState
& cpu_to_le32(NoResponseExpected
| Async
))
309 if (hwfib
->header
.XferState
& cpu_to_le32(NoResponseExpected
))
310 FIB_COUNTER_INCREMENT(aac_config
.NoResponseRecved
);
312 FIB_COUNTER_INCREMENT(aac_config
.AsyncRecved
);
314 * NOTE: we cannot touch the fib after this
315 * call, because it may have been deallocated.
317 fib
->callback(fib
->callback_data
, fib
);
320 dprintk((KERN_INFO
"event_wait up\n"));
321 spin_lock_irqsave(&fib
->event_lock
, flagv
);
324 up(&fib
->event_wait
);
325 spin_unlock_irqrestore(&fib
->event_lock
, flagv
);
326 FIB_COUNTER_INCREMENT(aac_config
.NormalRecved
);