Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / drivers / scsi / arm / queue.c
1 /*
2  *  linux/drivers/acorn/scsi/queue.c: queue handling primitives
3  *
4  *  Copyright (C) 1997-2000 Russell King
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  *  Changelog:
11  *   15-Sep-1997 RMK    Created.
12  *   11-Oct-1997 RMK    Corrected problem with queue_remove_exclude
13  *                      not updating internal linked list properly
14  *                      (was causing commands to go missing).
15  *   30-Aug-2000 RMK    Use Linux list handling and spinlocks
16  */
17 #include <linux/module.h>
18 #include <linux/blkdev.h>
19 #include <linux/kernel.h>
20 #include <linux/string.h>
21 #include <linux/slab.h>
22 #include <linux/spinlock.h>
23 #include <linux/list.h>
24 #include <linux/init.h>
25
26 #include "../scsi.h"
27
28 #define DEBUG
29
30 typedef struct queue_entry {
31         struct list_head   list;
32         Scsi_Cmnd          *SCpnt;
33 #ifdef DEBUG
34         unsigned long      magic;
35 #endif
36 } QE_t;
37
38 #ifdef DEBUG
39 #define QUEUE_MAGIC_FREE        0xf7e1c9a3
40 #define QUEUE_MAGIC_USED        0xf7e1cc33
41
42 #define SET_MAGIC(q,m)  ((q)->magic = (m))
43 #define BAD_MAGIC(q,m)  ((q)->magic != (m))
44 #else
45 #define SET_MAGIC(q,m)  do { } while (0)
46 #define BAD_MAGIC(q,m)  (0)
47 #endif
48
49 #include "queue.h"
50
51 #define NR_QE   32
52
53 /*
54  * Function: void queue_initialise (Queue_t *queue)
55  * Purpose : initialise a queue
56  * Params  : queue - queue to initialise
57  */
58 int queue_initialise (Queue_t *queue)
59 {
60         unsigned int nqueues = NR_QE;
61         QE_t *q;
62
63         spin_lock_init(&queue->queue_lock);
64         INIT_LIST_HEAD(&queue->head);
65         INIT_LIST_HEAD(&queue->free);
66
67         /*
68          * If life was easier, then SCpnt would have a
69          * host-available list head, and we wouldn't
70          * need to keep free lists or allocate this
71          * memory.
72          */
73         queue->alloc = q = kmalloc(sizeof(QE_t) * nqueues, GFP_KERNEL);
74         if (q) {
75                 for (; nqueues; q++, nqueues--) {
76                         SET_MAGIC(q, QUEUE_MAGIC_FREE);
77                         q->SCpnt = NULL;
78                         list_add(&q->list, &queue->free);
79                 }
80         }
81
82         return queue->alloc != NULL;
83 }
84
85 /*
86  * Function: void queue_free (Queue_t *queue)
87  * Purpose : free a queue
88  * Params  : queue - queue to free
89  */
90 void queue_free (Queue_t *queue)
91 {
92         if (!list_empty(&queue->head))
93                 printk(KERN_WARNING "freeing non-empty queue %p\n", queue);
94         kfree(queue->alloc);
95 }
96      
97
98 /*
99  * Function: int queue_add_cmd(Queue_t *queue, Scsi_Cmnd *SCpnt, int head)
100  * Purpose : Add a new command onto a queue, adding REQUEST_SENSE to head.
101  * Params  : queue - destination queue
102  *           SCpnt - command to add
103  *           head  - add command to head of queue
104  * Returns : 0 on error, !0 on success
105  */
106 int __queue_add(Queue_t *queue, Scsi_Cmnd *SCpnt, int head)
107 {
108         unsigned long flags;
109         struct list_head *l;
110         QE_t *q;
111         int ret = 0;
112
113         spin_lock_irqsave(&queue->queue_lock, flags);
114         if (list_empty(&queue->free))
115                 goto empty;
116
117         l = queue->free.next;
118         list_del(l);
119
120         q = list_entry(l, QE_t, list);
121         BUG_ON(BAD_MAGIC(q, QUEUE_MAGIC_FREE));
122
123         SET_MAGIC(q, QUEUE_MAGIC_USED);
124         q->SCpnt = SCpnt;
125
126         if (head)
127                 list_add(l, &queue->head);
128         else
129                 list_add_tail(l, &queue->head);
130
131         ret = 1;
132 empty:
133         spin_unlock_irqrestore(&queue->queue_lock, flags);
134         return ret;
135 }
136
137 static Scsi_Cmnd *__queue_remove(Queue_t *queue, struct list_head *ent)
138 {
139         QE_t *q;
140
141         /*
142          * Move the entry from the "used" list onto the "free" list
143          */
144         list_del(ent);
145         q = list_entry(ent, QE_t, list);
146         BUG_ON(BAD_MAGIC(q, QUEUE_MAGIC_USED));
147
148         SET_MAGIC(q, QUEUE_MAGIC_FREE);
149         list_add(ent, &queue->free);
150
151         return q->SCpnt;
152 }
153
154 /*
155  * Function: Scsi_Cmnd *queue_remove_exclude (queue, exclude)
156  * Purpose : remove a SCSI command from a queue
157  * Params  : queue   - queue to remove command from
158  *           exclude - bit array of target&lun which is busy
159  * Returns : Scsi_Cmnd if successful (and a reference), or NULL if no command available
160  */
161 Scsi_Cmnd *queue_remove_exclude(Queue_t *queue, unsigned long *exclude)
162 {
163         unsigned long flags;
164         struct list_head *l;
165         Scsi_Cmnd *SCpnt = NULL;
166
167         spin_lock_irqsave(&queue->queue_lock, flags);
168         list_for_each(l, &queue->head) {
169                 QE_t *q = list_entry(l, QE_t, list);
170                 if (!test_bit(q->SCpnt->device->id * 8 + q->SCpnt->device->lun, exclude)) {
171                         SCpnt = __queue_remove(queue, l);
172                         break;
173                 }
174         }
175         spin_unlock_irqrestore(&queue->queue_lock, flags);
176
177         return SCpnt;
178 }
179
180 /*
181  * Function: Scsi_Cmnd *queue_remove (queue)
182  * Purpose : removes first SCSI command from a queue
183  * Params  : queue   - queue to remove command from
184  * Returns : Scsi_Cmnd if successful (and a reference), or NULL if no command available
185  */
186 Scsi_Cmnd *queue_remove(Queue_t *queue)
187 {
188         unsigned long flags;
189         Scsi_Cmnd *SCpnt = NULL;
190
191         spin_lock_irqsave(&queue->queue_lock, flags);
192         if (!list_empty(&queue->head))
193                 SCpnt = __queue_remove(queue, queue->head.next);
194         spin_unlock_irqrestore(&queue->queue_lock, flags);
195
196         return SCpnt;
197 }
198
199 /*
200  * Function: Scsi_Cmnd *queue_remove_tgtluntag (queue, target, lun, tag)
201  * Purpose : remove a SCSI command from the queue for a specified target/lun/tag
202  * Params  : queue  - queue to remove command from
203  *           target - target that we want
204  *           lun    - lun on device
205  *           tag    - tag on device
206  * Returns : Scsi_Cmnd if successful, or NULL if no command satisfies requirements
207  */
208 Scsi_Cmnd *queue_remove_tgtluntag (Queue_t *queue, int target, int lun, int tag)
209 {
210         unsigned long flags;
211         struct list_head *l;
212         Scsi_Cmnd *SCpnt = NULL;
213
214         spin_lock_irqsave(&queue->queue_lock, flags);
215         list_for_each(l, &queue->head) {
216                 QE_t *q = list_entry(l, QE_t, list);
217                 if (q->SCpnt->device->id == target && q->SCpnt->device->lun == lun &&
218                     q->SCpnt->tag == tag) {
219                         SCpnt = __queue_remove(queue, l);
220                         break;
221                 }
222         }
223         spin_unlock_irqrestore(&queue->queue_lock, flags);
224
225         return SCpnt;
226 }
227
228 /*
229  * Function: queue_remove_all_target(queue, target)
230  * Purpose : remove all SCSI commands from the queue for a specified target
231  * Params  : queue  - queue to remove command from
232  *           target - target device id
233  * Returns : nothing
234  */
235 void queue_remove_all_target(Queue_t *queue, int target)
236 {
237         unsigned long flags;
238         struct list_head *l;
239
240         spin_lock_irqsave(&queue->queue_lock, flags);
241         list_for_each(l, &queue->head) {
242                 QE_t *q = list_entry(l, QE_t, list);
243                 if (q->SCpnt->device->id == target)
244                         __queue_remove(queue, l);
245         }
246         spin_unlock_irqrestore(&queue->queue_lock, flags);
247 }
248
249 /*
250  * Function: int queue_probetgtlun (queue, target, lun)
251  * Purpose : check to see if we have a command in the queue for the specified
252  *           target/lun.
253  * Params  : queue  - queue to look in
254  *           target - target we want to probe
255  *           lun    - lun on target
256  * Returns : 0 if not found, != 0 if found
257  */
258 int queue_probetgtlun (Queue_t *queue, int target, int lun)
259 {
260         unsigned long flags;
261         struct list_head *l;
262         int found = 0;
263
264         spin_lock_irqsave(&queue->queue_lock, flags);
265         list_for_each(l, &queue->head) {
266                 QE_t *q = list_entry(l, QE_t, list);
267                 if (q->SCpnt->device->id == target && q->SCpnt->device->lun == lun) {
268                         found = 1;
269                         break;
270                 }
271         }
272         spin_unlock_irqrestore(&queue->queue_lock, flags);
273
274         return found;
275 }
276
277 /*
278  * Function: int queue_remove_cmd(Queue_t *queue, Scsi_Cmnd *SCpnt)
279  * Purpose : remove a specific command from the queues
280  * Params  : queue - queue to look in
281  *           SCpnt - command to find
282  * Returns : 0 if not found
283  */
284 int queue_remove_cmd(Queue_t *queue, Scsi_Cmnd *SCpnt)
285 {
286         unsigned long flags;
287         struct list_head *l;
288         int found = 0;
289
290         spin_lock_irqsave(&queue->queue_lock, flags);
291         list_for_each(l, &queue->head) {
292                 QE_t *q = list_entry(l, QE_t, list);
293                 if (q->SCpnt == SCpnt) {
294                         __queue_remove(queue, l);
295                         found = 1;
296                         break;
297                 }
298         }
299         spin_unlock_irqrestore(&queue->queue_lock, flags);
300
301         return found;
302 }
303
304 EXPORT_SYMBOL(queue_initialise);
305 EXPORT_SYMBOL(queue_free);
306 EXPORT_SYMBOL(__queue_add);
307 EXPORT_SYMBOL(queue_remove);
308 EXPORT_SYMBOL(queue_remove_exclude);
309 EXPORT_SYMBOL(queue_remove_tgtluntag);
310 EXPORT_SYMBOL(queue_remove_cmd);
311 EXPORT_SYMBOL(queue_remove_all_target);
312 EXPORT_SYMBOL(queue_probetgtlun);
313
314 MODULE_AUTHOR("Russell King");
315 MODULE_DESCRIPTION("SCSI command queueing");
316 MODULE_LICENSE("GPL");