ide: add device flags

Add 'unsigned long dev_flags' to ide_drive_t and convert bitfields
to IDE_DFLAG_* flags.

While at it:
- IDE_DFLAG_ADDRESSING -> IDE_DFLAG_LBA48
- fixup some comments
- remove needless g->flags zeroing from ide*_probe()

There should be no functional changes caused by this patch.

Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>

1 files changed, 34 insertions, 21 deletions

diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 1c51949833be..5f0ed59bac6b 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -184,7 +184,8 @@ static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *
                 if (drive->media != ide_disk)
                         break;
                 /* Not supported? Switch to next step now. */
-                if (!drive->wcache || ata_id_flush_enabled(drive->id) == 0) {
+                if (ata_id_flush_enabled(drive->id) == 0 ||
+                    (drive->dev_flags & IDE_DFLAG_WCACHE) == 0) {
                         ide_complete_power_step(drive, rq, 0, 0);
                         return ide_stopped;
                 }
@@ -222,7 +223,7 @@ static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *
                 if (drive->hwif->dma_ops == NULL)
                         break;
                 /*
-                 * TODO: respect ->using_dma setting
+                 * TODO: respect IDE_DFLAG_USING_DMA
                  */
                 ide_set_dma(drive);
                 break;
@@ -287,7 +288,7 @@ static void ide_complete_pm_request (ide_drive_t *drive, struct request *rq)
         if (blk_pm_suspend_request(rq)) {
                 blk_stop_queue(drive->queue);
         } else {
-                drive->blocked = 0;
+                drive->dev_flags &= ~IDE_DFLAG_BLOCKED;
                 blk_start_queue(drive->queue);
         }
         HWGROUP(drive)->rq = NULL;
@@ -374,7 +375,8 @@ static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq, u8
 {
         ide_hwif_t *hwif = drive->hwif;
 
-        if ((stat & ATA_BUSY) || ((stat & ATA_DF) && !drive->nowerr)) {
+        if ((stat & ATA_BUSY) ||
+            ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
                 /* other bits are useless when BUSY */
                 rq->errors |= ERROR_RESET;
         } else if (stat & ATA_ERR) {
@@ -428,7 +430,8 @@ static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq, u
 {
         ide_hwif_t *hwif = drive->hwif;
 
-        if ((stat & ATA_BUSY) || ((stat & ATA_DF) && !drive->nowerr)) {
+        if ((stat & ATA_BUSY) ||
+            ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
                 /* other bits are useless when BUSY */
                 rq->errors |= ERROR_RESET;
         } else {
@@ -607,7 +610,7 @@ static ide_startstop_t do_special (ide_drive_t *drive)
 
                 if (set_pio_mode_abuse(drive->hwif, req_pio)) {
                         /*
-                         * take ide_lock for drive->[no_]unmask/[no_]io_32bit
+                         * take ide_lock for IDE_DFLAG_[NO_]UNMASK/[NO_]IO_32BIT
                          */
                         if (req_pio == 8 || req_pio == 9) {
                                 unsigned long flags;
@@ -618,7 +621,8 @@ static ide_startstop_t do_special (ide_drive_t *drive)
                         } else
                                 port_ops->set_pio_mode(drive, req_pio);
                 } else {
-                        int keep_dma = drive->using_dma;
+                        int keep_dma =
+                                !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
 
                         ide_set_pio(drive, req_pio);
 
@@ -775,7 +779,7 @@ static void ide_check_pm_state(ide_drive_t *drive, struct request *rq)
         if (blk_pm_suspend_request(rq) &&
             pm->pm_step == ide_pm_state_start_suspend)
                 /* Mark drive blocked when starting the suspend sequence. */
-                drive->blocked = 1;
+                drive->dev_flags |= IDE_DFLAG_BLOCKED;
         else if (blk_pm_resume_request(rq) &&
                  pm->pm_step == ide_pm_state_start_resume) {
                 /* 
@@ -895,7 +899,7 @@ void ide_stall_queue (ide_drive_t *drive, unsigned long timeout)
         if (timeout > WAIT_WORSTCASE)
                 timeout = WAIT_WORSTCASE;
         drive->sleep = timeout + jiffies;
-        drive->sleeping = 1;
+        drive->dev_flags |= IDE_DFLAG_SLEEPING;
 }
 
 EXPORT_SYMBOL(ide_stall_queue);
@@ -935,18 +939,23 @@ repeat:
         }
 
         do {
-                if ((!drive->sleeping || time_after_eq(jiffies, drive->sleep))
-                    && !elv_queue_empty(drive->queue)) {
-                        if (!best
-                         || (drive->sleeping && (!best->sleeping || time_before(drive->sleep, best->sleep)))
-                         || (!best->sleeping && time_before(WAKEUP(drive), WAKEUP(best))))
-                        {
+                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->nice1 && !best->sleeping && best != hwgroup->drive && best->service_time > WAIT_MIN_SLEEP) {
+
+        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) {
                 /*
@@ -955,7 +964,7 @@ repeat:
                  */
                         drive = best->next;
                         do {
-                                if (!drive->sleeping
+                                if ((drive->dev_flags & IDE_DFLAG_SLEEPING) == 0
                                  && time_before(jiffies - best->service_time, WAKEUP(drive))
                                  && time_before(WAKEUP(drive), jiffies + t))
                                 {
@@ -1026,7 +1035,9 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
                         hwgroup->rq = NULL;
                         drive = hwgroup->drive;
                         do {
-                                if (drive->sleeping && (!sleeping || time_before(drive->sleep, sleep))) {
+                                if ((drive->dev_flags & IDE_DFLAG_SLEEPING) &&
+                                    (sleeping == 0 ||
+                                     time_before(drive->sleep, sleep))) {
                                         sleeping = 1;
                                         sleep = drive->sleep;
                                 }
@@ -1075,7 +1086,7 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
                 }
                 hwgroup->hwif = hwif;
                 hwgroup->drive = drive;
-                drive->sleeping = 0;
+                drive->dev_flags &= ~IDE_DFLAG_SLEEPING;
                 drive->service_start = jiffies;
 
                 if (blk_queue_plugged(drive->queue)) {
@@ -1109,7 +1120,9 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
                  * We count how many times we loop here to make sure we service
                  * all drives in the hwgroup without looping for ever
                  */
-                if (drive->blocked && !blk_pm_request(rq) && !(rq->cmd_flags & REQ_PREEMPT)) {
+                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;
@@ -1491,7 +1504,7 @@ irqreturn_t ide_intr (int irq, void *dev_id)
                  */
                 hwif->ide_dma_clear_irq(drive);
 
-        if (drive->unmask)
+        if (drive->dev_flags & IDE_DFLAG_UNMASK)
                 local_irq_enable_in_hardirq();
         /* service this interrupt, may set handler for next interrupt */
         startstop = handler(drive);