linux/drivers/scsi/arm/queue.c
<<
>>
Prefs
   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
  30typedef struct queue_entry {
  31        struct list_head   list;
  32        struct 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 */
  58int 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_array(nqueues, sizeof(QE_t), 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 */
  90void 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(Queue_t *queue, struct 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 */
 106int __queue_add(Queue_t *queue, struct 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;
 132empty:
 133        spin_unlock_irqrestore(&queue->queue_lock, flags);
 134        return ret;
 135}
 136
 137static struct 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: struct 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 : struct scsi_cmnd if successful (and a reference), or NULL if no command available
 160 */
 161struct scsi_cmnd *queue_remove_exclude(Queue_t *queue, unsigned long *exclude)
 162{
 163        unsigned long flags;
 164        struct list_head *l;
 165        struct 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 +
 171                              (u8)(q->SCpnt->device->lun & 0x7), exclude)) {
 172                        SCpnt = __queue_remove(queue, l);
 173                        break;
 174                }
 175        }
 176        spin_unlock_irqrestore(&queue->queue_lock, flags);
 177
 178        return SCpnt;
 179}
 180
 181/*
 182 * Function: struct scsi_cmnd *queue_remove (queue)
 183 * Purpose : removes first SCSI command from a queue
 184 * Params  : queue   - queue to remove command from
 185 * Returns : struct scsi_cmnd if successful (and a reference), or NULL if no command available
 186 */
 187struct scsi_cmnd *queue_remove(Queue_t *queue)
 188{
 189        unsigned long flags;
 190        struct scsi_cmnd *SCpnt = NULL;
 191
 192        spin_lock_irqsave(&queue->queue_lock, flags);
 193        if (!list_empty(&queue->head))
 194                SCpnt = __queue_remove(queue, queue->head.next);
 195        spin_unlock_irqrestore(&queue->queue_lock, flags);
 196
 197        return SCpnt;
 198}
 199
 200/*
 201 * Function: struct scsi_cmnd *queue_remove_tgtluntag (queue, target, lun, tag)
 202 * Purpose : remove a SCSI command from the queue for a specified target/lun/tag
 203 * Params  : queue  - queue to remove command from
 204 *           target - target that we want
 205 *           lun    - lun on device
 206 *           tag    - tag on device
 207 * Returns : struct scsi_cmnd if successful, or NULL if no command satisfies requirements
 208 */
 209struct scsi_cmnd *queue_remove_tgtluntag(Queue_t *queue, int target, int lun,
 210                                         int tag)
 211{
 212        unsigned long flags;
 213        struct list_head *l;
 214        struct scsi_cmnd *SCpnt = NULL;
 215
 216        spin_lock_irqsave(&queue->queue_lock, flags);
 217        list_for_each(l, &queue->head) {
 218                QE_t *q = list_entry(l, QE_t, list);
 219                if (q->SCpnt->device->id == target && q->SCpnt->device->lun == lun &&
 220                    q->SCpnt->tag == tag) {
 221                        SCpnt = __queue_remove(queue, l);
 222                        break;
 223                }
 224        }
 225        spin_unlock_irqrestore(&queue->queue_lock, flags);
 226
 227        return SCpnt;
 228}
 229
 230/*
 231 * Function: queue_remove_all_target(queue, target)
 232 * Purpose : remove all SCSI commands from the queue for a specified target
 233 * Params  : queue  - queue to remove command from
 234 *           target - target device id
 235 * Returns : nothing
 236 */
 237void queue_remove_all_target(Queue_t *queue, int target)
 238{
 239        unsigned long flags;
 240        struct list_head *l;
 241
 242        spin_lock_irqsave(&queue->queue_lock, flags);
 243        list_for_each(l, &queue->head) {
 244                QE_t *q = list_entry(l, QE_t, list);
 245                if (q->SCpnt->device->id == target)
 246                        __queue_remove(queue, l);
 247        }
 248        spin_unlock_irqrestore(&queue->queue_lock, flags);
 249}
 250
 251/*
 252 * Function: int queue_probetgtlun (queue, target, lun)
 253 * Purpose : check to see if we have a command in the queue for the specified
 254 *           target/lun.
 255 * Params  : queue  - queue to look in
 256 *           target - target we want to probe
 257 *           lun    - lun on target
 258 * Returns : 0 if not found, != 0 if found
 259 */
 260int queue_probetgtlun (Queue_t *queue, int target, int lun)
 261{
 262        unsigned long flags;
 263        struct list_head *l;
 264        int found = 0;
 265
 266        spin_lock_irqsave(&queue->queue_lock, flags);
 267        list_for_each(l, &queue->head) {
 268                QE_t *q = list_entry(l, QE_t, list);
 269                if (q->SCpnt->device->id == target && q->SCpnt->device->lun == lun) {
 270                        found = 1;
 271                        break;
 272                }
 273        }
 274        spin_unlock_irqrestore(&queue->queue_lock, flags);
 275
 276        return found;
 277}
 278
 279/*
 280 * Function: int queue_remove_cmd(Queue_t *queue, struct scsi_cmnd *SCpnt)
 281 * Purpose : remove a specific command from the queues
 282 * Params  : queue - queue to look in
 283 *           SCpnt - command to find
 284 * Returns : 0 if not found
 285 */
 286int queue_remove_cmd(Queue_t *queue, struct scsi_cmnd *SCpnt)
 287{
 288        unsigned long flags;
 289        struct list_head *l;
 290        int found = 0;
 291
 292        spin_lock_irqsave(&queue->queue_lock, flags);
 293        list_for_each(l, &queue->head) {
 294                QE_t *q = list_entry(l, QE_t, list);
 295                if (q->SCpnt == SCpnt) {
 296                        __queue_remove(queue, l);
 297                        found = 1;
 298                        break;
 299                }
 300        }
 301        spin_unlock_irqrestore(&queue->queue_lock, flags);
 302
 303        return found;
 304}
 305
 306EXPORT_SYMBOL(queue_initialise);
 307EXPORT_SYMBOL(queue_free);
 308EXPORT_SYMBOL(__queue_add);
 309EXPORT_SYMBOL(queue_remove);
 310EXPORT_SYMBOL(queue_remove_exclude);
 311EXPORT_SYMBOL(queue_remove_tgtluntag);
 312EXPORT_SYMBOL(queue_remove_cmd);
 313EXPORT_SYMBOL(queue_remove_all_target);
 314EXPORT_SYMBOL(queue_probetgtlun);
 315
 316MODULE_AUTHOR("Russell King");
 317MODULE_DESCRIPTION("SCSI command queueing");
 318MODULE_LICENSE("GPL");
 319