1 files changed, 85 insertions, 197 deletions

diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index ecacc008fdaf..1c36a8e83d36 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -426,9 +426,6 @@ void ide_map_sg(ide_drive_t *drive, struct request *rq)
         ide_hwif_t *hwif = drive->hwif;
         struct scatterlist *sg = hwif->sg_table;
 
-        if (hwif->sg_mapped)    /* needed by ide-scsi */
-                return;
-
         if (rq->cmd_type != REQ_TYPE_ATA_TASKFILE) {
                 hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
         } else {
@@ -667,85 +664,10 @@ void ide_stall_queue (ide_drive_t *drive, unsigned long timeout)
         drive->sleep = timeout + jiffies;
         drive->dev_flags |= IDE_DFLAG_SLEEPING;
 }
-
 EXPORT_SYMBOL(ide_stall_queue);
 
-#define WAKEUP(drive)   ((drive)->service_start + 2 * (drive)->service_time)
-
-/**
- *      choose_drive            -       select a drive to service
- *      @hwgroup: hardware group to select on
- *
- *      choose_drive() selects the next drive which will be serviced.
- *      This is necessary because the IDE layer can't issue commands
- *      to both drives on the same cable, unlike SCSI.
- */
- 
-static inline ide_drive_t *choose_drive (ide_hwgroup_t *hwgroup)
-{
-        ide_drive_t *drive, *best;
-
-repeat: 
-        best = NULL;
-        drive = hwgroup->drive;
-
-        /*
-         * drive is doing pre-flush, ordered write, post-flush sequence. even
-         * though that is 3 requests, it must be seen as a single transaction.
-         * we must not preempt this drive until that is complete
-         */
-        if (blk_queue_flushing(drive->queue)) {
-                /*
-                 * small race where queue could get replugged during
-                 * the 3-request flush cycle, just yank the plug since
-                 * we want it to finish asap
-                 */
-                blk_remove_plug(drive->queue);
-                return drive;
-        }
-
-        do {
-                u8 dev_s = !!(drive->dev_flags & IDE_DFLAG_SLEEPING);
-                u8 best_s = (best && !!(best->dev_flags & IDE_DFLAG_SLEEPING));
-
-                if ((dev_s == 0 || time_after_eq(jiffies, drive->sleep)) &&
-                    !elv_queue_empty(drive->queue)) {
-                        if (best == NULL ||
-                            (dev_s && (best_s == 0 || time_before(drive->sleep, best->sleep))) ||
-                            (best_s == 0 && time_before(WAKEUP(drive), WAKEUP(best)))) {
-                                if (!blk_queue_plugged(drive->queue))
-                                        best = drive;
-                        }
-                }
-        } while ((drive = drive->next) != hwgroup->drive);
-
-        if (best && (best->dev_flags & IDE_DFLAG_NICE1) &&
-            (best->dev_flags & IDE_DFLAG_SLEEPING) == 0 &&
-            best != hwgroup->drive && best->service_time > WAIT_MIN_SLEEP) {
-                long t = (signed long)(WAKEUP(best) - jiffies);
-                if (t >= WAIT_MIN_SLEEP) {
-                /*
-                 * We *may* have some time to spare, but first let's see if
-                 * someone can potentially benefit from our nice mood today..
-                 */
-                        drive = best->next;
-                        do {
-                                if ((drive->dev_flags & IDE_DFLAG_SLEEPING) == 0
-                                 && time_before(jiffies - best->service_time, WAKEUP(drive))
-                                 && time_before(WAKEUP(drive), jiffies + t))
-                                {
-                                        ide_stall_queue(best, min_t(long, t, 10 * WAIT_MIN_SLEEP));
-                                        goto repeat;
-                                }
-                        } while ((drive = drive->next) != best);
-                }
-        }
-        return best;
-}
-
 /*
  * Issue a new request to a drive from hwgroup
- * Caller must have already done spin_lock_irqsave(&hwgroup->lock, ..);
  *
  * A hwgroup is a serialized group of IDE interfaces.  Usually there is
  * exactly one hwif (interface) per hwgroup, but buggy controllers (eg. CMD640)
@@ -757,8 +679,7 @@ repeat:
  * possibly along with many other devices.  This is especially common in
  * PCI-based systems with off-board IDE controller cards.
  *
- * The IDE driver uses a per-hwgroup spinlock to protect
- * access to the request queues, and to protect the hwgroup->busy flag.
+ * The IDE driver uses a per-hwgroup lock to protect the hwgroup->busy flag.
  *
  * The first thread into the driver for a particular hwgroup sets the
  * hwgroup->busy flag to indicate that this hwgroup is now active,
@@ -778,69 +699,41 @@ repeat:
  * the driver.  This makes the driver much more friendlier to shared IRQs
  * than previous designs, while remaining 100% (?) SMP safe and capable.
  */
-static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
+void do_ide_request(struct request_queue *q)
 {
-        ide_drive_t     *drive;
-        ide_hwif_t      *hwif;
+        ide_drive_t     *drive = q->queuedata;
+        ide_hwif_t      *hwif = drive->hwif;
+        ide_hwgroup_t   *hwgroup = hwif->hwgroup;
         struct request  *rq;
         ide_startstop_t startstop;
-        int             loops = 0;
-
-        /* caller must own hwgroup->lock */
-        BUG_ON(!irqs_disabled());
-
-        while (!hwgroup->busy) {
-                hwgroup->busy = 1;
-                /* for atari only */
-                ide_get_lock(ide_intr, hwgroup);
-                drive = choose_drive(hwgroup);
-                if (drive == NULL) {
-                        int sleeping = 0;
-                        unsigned long sleep = 0; /* shut up, gcc */
-                        hwgroup->rq = NULL;
-                        drive = hwgroup->drive;
-                        do {
-                                if ((drive->dev_flags & IDE_DFLAG_SLEEPING) &&
-                                    (sleeping == 0 ||
-                                     time_before(drive->sleep, sleep))) {
-                                        sleeping = 1;
-                                        sleep = drive->sleep;
-                                }
-                        } while ((drive = drive->next) != hwgroup->drive);
-                        if (sleeping) {
+
+        /*
+         * drive is doing pre-flush, ordered write, post-flush sequence. even
+         * though that is 3 requests, it must be seen as a single transaction.
+         * we must not preempt this drive until that is complete
+         */
+        if (blk_queue_flushing(q))
                 /*
-                 * Take a short snooze, and then wake up this hwgroup again.
-                 * This gives other hwgroups on the same a chance to
-                 * play fairly with us, just in case there are big differences
-                 * in relative throughputs.. don't want to hog the cpu too much.
+                 * small race where queue could get replugged during
+                 * the 3-request flush cycle, just yank the plug since
+                 * we want it to finish asap
                  */
-                                if (time_before(sleep, jiffies + WAIT_MIN_SLEEP))
-                                        sleep = jiffies + WAIT_MIN_SLEEP;
-#if 1
-                                if (timer_pending(&hwgroup->timer))
-                                        printk(KERN_CRIT "ide_set_handler: timer already active\n");
-#endif
-                                /* so that ide_timer_expiry knows what to do */
-                                hwgroup->sleeping = 1;
-                                hwgroup->req_gen_timer = hwgroup->req_gen;
-                                mod_timer(&hwgroup->timer, sleep);
-                                /* we purposely leave hwgroup->busy==1
-                                 * while sleeping */
-                        } else {
-                                /* Ugly, but how can we sleep for the lock
-                                 * otherwise? perhaps from tq_disk?
-                                 */
+                blk_remove_plug(q);
 
-                                /* for atari only */
-                                ide_release_lock();
-                                hwgroup->busy = 0;
-                        }
+        spin_unlock_irq(q->queue_lock);
+        spin_lock_irq(&hwgroup->lock);
+
+        if (!ide_lock_hwgroup(hwgroup)) {
+repeat:
+                hwgroup->rq = NULL;
 
-                        /* no more work for this hwgroup (for now) */
-                        return;
+                if (drive->dev_flags & IDE_DFLAG_SLEEPING) {
+                        if (time_before(drive->sleep, jiffies)) {
+                                ide_unlock_hwgroup(hwgroup);
+                                goto plug_device;
+                        }
                 }
-        again:
-                hwif = HWIF(drive);
+
                 if (hwif != hwgroup->hwif) {
                         /*
                          * set nIEN for previous hwif, drives in the
@@ -852,16 +745,20 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
                 hwgroup->hwif = hwif;
                 hwgroup->drive = drive;
                 drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED);
-                drive->service_start = jiffies;
 
+                spin_unlock_irq(&hwgroup->lock);
+                spin_lock_irq(q->queue_lock);
                 /*
                  * we know that the queue isn't empty, but this can happen
                  * if the q->prep_rq_fn() decides to kill a request
                  */
                 rq = elv_next_request(drive->queue);
+                spin_unlock_irq(q->queue_lock);
+                spin_lock_irq(&hwgroup->lock);
+
                 if (!rq) {
-                        hwgroup->busy = 0;
-                        break;
+                        ide_unlock_hwgroup(hwgroup);
+                        goto out;
                 }
 
                 /*
@@ -876,53 +773,36 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
                  * though. I hope that doesn't happen too much, hopefully not
                  * unless the subdriver triggers such a thing in its own PM
                  * state machine.
-                 *
-                 * We count how many times we loop here to make sure we service
-                 * all drives in the hwgroup without looping for ever
                  */
                 if ((drive->dev_flags & IDE_DFLAG_BLOCKED) &&
                     blk_pm_request(rq) == 0 &&
                     (rq->cmd_flags & REQ_PREEMPT) == 0) {
-                        drive = drive->next ? drive->next : hwgroup->drive;
-                        if (loops++ < 4 && !blk_queue_plugged(drive->queue))
-                                goto again;
-                        /* We clear busy, there should be no pending ATA command at this point. */
-                        hwgroup->busy = 0;
-                        break;
+                        /* there should be no pending command at this point */
+                        ide_unlock_hwgroup(hwgroup);
+                        goto plug_device;
                 }
 
                 hwgroup->rq = rq;
 
-                /*
-                 * Some systems have trouble with IDE IRQs arriving while
-                 * the driver is still setting things up.  So, here we disable
-                 * the IRQ used by this interface while the request is being started.
-                 * This may look bad at first, but pretty much the same thing
-                 * happens anyway when any interrupt comes in, IDE or otherwise
-                 *  -- the kernel masks the IRQ while it is being handled.
-                 */
-                if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq)
-                        disable_irq_nosync(hwif->irq);
-                spin_unlock(&hwgroup->lock);
-                local_irq_enable_in_hardirq();
-                        /* allow other IRQs while we start this request */
+                spin_unlock_irq(&hwgroup->lock);
                 startstop = start_request(drive, rq);
                 spin_lock_irq(&hwgroup->lock);
-                if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq)
-                        enable_irq(hwif->irq);
+
                 if (startstop == ide_stopped)
-                        hwgroup->busy = 0;
-        }
-}
+                        goto repeat;
+        } else
+                goto plug_device;
+out:
+        spin_unlock_irq(&hwgroup->lock);
+        spin_lock_irq(q->queue_lock);
+        return;
 
-/*
- * Passes the stuff to ide_do_request
- */
-void do_ide_request(struct request_queue *q)
-{
-        ide_drive_t *drive = q->queuedata;
+plug_device:
+        spin_unlock_irq(&hwgroup->lock);
+        spin_lock_irq(q->queue_lock);
 
-        ide_do_request(HWGROUP(drive), IDE_NO_IRQ);
+        if (!elv_queue_empty(q))
+                blk_plug_device(q);
 }
 
 /*
@@ -983,6 +863,17 @@ out:
         return ret;
 }
 
+static void ide_plug_device(ide_drive_t *drive)
+{
+        struct request_queue *q = drive->queue;
+        unsigned long flags;
+
+        spin_lock_irqsave(q->queue_lock, flags);
+        if (!elv_queue_empty(q))
+                blk_plug_device(q);
+        spin_unlock_irqrestore(q->queue_lock, flags);
+}
+
 /**
  *      ide_timer_expiry        -       handle lack of an IDE interrupt
  *      @data: timer callback magic (hwgroup)
@@ -1000,10 +891,12 @@ out:
 void ide_timer_expiry (unsigned long data)
 {
         ide_hwgroup_t   *hwgroup = (ide_hwgroup_t *) data;
+        ide_drive_t     *uninitialized_var(drive);
         ide_handler_t   *handler;
         ide_expiry_t    *expiry;
         unsigned long   flags;
         unsigned long   wait = -1;
+        int             plug_device = 0;
 
         spin_lock_irqsave(&hwgroup->lock, flags);
 
@@ -1015,22 +908,15 @@ void ide_timer_expiry (unsigned long data)
                  * or we were "sleeping" to give other devices a chance.
                  * Either way, we don't really want to complain about anything.
                  */
-                if (hwgroup->sleeping) {
-                        hwgroup->sleeping = 0;
-                        hwgroup->busy = 0;
-                }
         } else {
-                ide_drive_t *drive = hwgroup->drive;
+                drive = hwgroup->drive;
                 if (!drive) {
                         printk(KERN_ERR "ide_timer_expiry: hwgroup->drive was NULL\n");
                         hwgroup->handler = NULL;
                 } else {
                         ide_hwif_t *hwif;
                         ide_startstop_t startstop = ide_stopped;
-                        if (!hwgroup->busy) {
-                                hwgroup->busy = 1;      /* paranoia */
-                                printk(KERN_ERR "%s: ide_timer_expiry: hwgroup->busy was 0 ??\n", drive->name);
-                        }
+
                         if ((expiry = hwgroup->expiry) != NULL) {
                                 /* continue */
                                 if ((wait = expiry(drive)) > 0) {
@@ -1071,15 +957,18 @@ void ide_timer_expiry (unsigned long data)
                                         ide_error(drive, "irq timeout",
                                                   hwif->tp_ops->read_status(hwif));
                         }
-                        drive->service_time = jiffies - drive->service_start;
                         spin_lock_irq(&hwgroup->lock);
                         enable_irq(hwif->irq);
-                        if (startstop == ide_stopped)
-                                hwgroup->busy = 0;
+                        if (startstop == ide_stopped) {
+                                ide_unlock_hwgroup(hwgroup);
+                                plug_device = 1;
+                        }
                 }
         }
-        ide_do_request(hwgroup, IDE_NO_IRQ);
         spin_unlock_irqrestore(&hwgroup->lock, flags);
+
+        if (plug_device)
+                ide_plug_device(drive);
 }
 
 /**
@@ -1173,10 +1062,11 @@ irqreturn_t ide_intr (int irq, void *dev_id)
         unsigned long flags;
         ide_hwgroup_t *hwgroup = (ide_hwgroup_t *)dev_id;
         ide_hwif_t *hwif = hwgroup->hwif;
-        ide_drive_t *drive;
+        ide_drive_t *uninitialized_var(drive);
         ide_handler_t *handler;
         ide_startstop_t startstop;
         irqreturn_t irq_ret = IRQ_NONE;
+        int plug_device = 0;
 
         spin_lock_irqsave(&hwgroup->lock, flags);
 
@@ -1241,10 +1131,6 @@ irqreturn_t ide_intr (int irq, void *dev_id)
                  */
                 goto out;
 
-        if (!hwgroup->busy) {
-                hwgroup->busy = 1;      /* paranoia */
-                printk(KERN_ERR "%s: ide_intr: hwgroup->busy was 0 ??\n", drive->name);
-        }
         hwgroup->handler = NULL;
         hwgroup->req_gen++;
         del_timer(&hwgroup->timer);
@@ -1267,20 +1153,22 @@ irqreturn_t ide_intr (int irq, void *dev_id)
          * same irq as is currently being serviced here, and Linux
          * won't allow another of the same (on any CPU) until we return.
          */
-        drive->service_time = jiffies - drive->service_start;
         if (startstop == ide_stopped) {
                 if (hwgroup->handler == NULL) { /* paranoia */
-                        hwgroup->busy = 0;
-                        ide_do_request(hwgroup, hwif->irq);
-                } else {
-                        printk(KERN_ERR "%s: ide_intr: huh? expected NULL handler "
-                                "on exit\n", drive->name);
-                }
+                        ide_unlock_hwgroup(hwgroup);
+                        plug_device = 1;
+                } else
+                        printk(KERN_ERR "%s: %s: huh? expected NULL handler "
+                                        "on exit\n", __func__, drive->name);
         }
 out_handled:
         irq_ret = IRQ_HANDLED;
 out:
         spin_unlock_irqrestore(&hwgroup->lock, flags);
+
+        if (plug_device)
+                ide_plug_device(drive);
+
         return irq_ret;
 }