[PATCH] Split struct request ->flags into two parts

Right now ->flags is a bit of a mess: some are request types, and
others are just modifiers. Clean this up by splitting it into
->cmd_type and ->cmd_flags. This allows introduction of generic
Linux block message types, useful for sending generic Linux commands
to block devices.

Signed-off-by: Jens Axboe <axboe@suse.de>

10 files changed, 78 insertions, 75 deletions

diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 654d4cd09847..69bbb6206a00 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -372,7 +372,7 @@ static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
 {
         int log = 0;
 
-        if (!sense || !rq || (rq->flags & REQ_QUIET))
+        if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
                 return 0;
 
         switch (sense->sense_key) {
@@ -597,7 +597,7 @@ static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
         struct cdrom_info *cd = drive->driver_data;
 
         ide_init_drive_cmd(rq);
-        rq->flags = REQ_PC;
+        rq->cmd_type = REQ_TYPE_BLOCK_PC;
         rq->rq_disk = cd->disk;
 }
 
@@ -617,7 +617,7 @@ static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
         rq->cmd[0] = GPCMD_REQUEST_SENSE;
         rq->cmd[4] = rq->data_len = 18;
 
-        rq->flags = REQ_SENSE;
+        rq->cmd_type = REQ_TYPE_SENSE;
 
         /* NOTE! Save the failed command in "rq->buffer" */
         rq->buffer = (void *) failed_command;
@@ -630,10 +630,10 @@ static void cdrom_end_request (ide_drive_t *drive, int uptodate)
         struct request *rq = HWGROUP(drive)->rq;
         int nsectors = rq->hard_cur_sectors;
 
-        if ((rq->flags & REQ_SENSE) && uptodate) {
+        if (blk_sense_request(rq) && uptodate) {
                 /*
-                 * For REQ_SENSE, "rq->buffer" points to the original failed
-                 * request
+                 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
+                 * failed request
                  */
                 struct request *failed = (struct request *) rq->buffer;
                 struct cdrom_info *info = drive->driver_data;
@@ -706,17 +706,17 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                 return 1;
         }
 
-        if (rq->flags & REQ_SENSE) {
+        if (blk_sense_request(rq)) {
                 /* We got an error trying to get sense info
                    from the drive (probably while trying
                    to recover from a former error).  Just give up. */
 
-                rq->flags |= REQ_FAILED;
+                rq->cmd_flags |= REQ_FAILED;
                 cdrom_end_request(drive, 0);
                 ide_error(drive, "request sense failure", stat);
                 return 1;
 
-        } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
+        } else if (blk_pc_request(rq)) {
                 /* All other functions, except for READ. */
                 unsigned long flags;
 
@@ -724,7 +724,7 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                  * if we have an error, pass back CHECK_CONDITION as the
                  * scsi status byte
                  */
-                if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
+                if (!rq->errors)
                         rq->errors = SAM_STAT_CHECK_CONDITION;
 
                 /* Check for tray open. */
@@ -735,12 +735,12 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                         cdrom_saw_media_change (drive);
                         /*printk("%s: media changed\n",drive->name);*/
                         return 0;
-                } else if (!(rq->flags & REQ_QUIET)) {
+                } else if (!(rq->cmd_flags & REQ_QUIET)) {
                         /* Otherwise, print an error. */
                         ide_dump_status(drive, "packet command error", stat);
                 }
                 
-                rq->flags |= REQ_FAILED;
+                rq->cmd_flags |= REQ_FAILED;
 
                 /*
                  * instead of playing games with moving completions around,
@@ -881,7 +881,7 @@ static int cdrom_timer_expiry(ide_drive_t *drive)
                         wait = ATAPI_WAIT_PC;
                         break;
                 default:
-                        if (!(rq->flags & REQ_QUIET))
+                        if (!(rq->cmd_flags & REQ_QUIET))
                                 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
                         wait = 0;
                         break;
@@ -1124,7 +1124,7 @@ static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
                 if (rq->current_nr_sectors > 0) {
                         printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
                                 drive->name, rq->current_nr_sectors);
-                        rq->flags |= REQ_FAILED;
+                        rq->cmd_flags |= REQ_FAILED;
                         cdrom_end_request(drive, 0);
                 } else
                         cdrom_end_request(drive, 1);
@@ -1456,7 +1456,7 @@ static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
                         printk ("%s: cdrom_pc_intr: data underrun %d\n",
                                 drive->name, pc->buflen);
                         */
-                        rq->flags |= REQ_FAILED;
+                        rq->cmd_flags |= REQ_FAILED;
                         cdrom_end_request(drive, 0);
                 }
                 return ide_stopped;
@@ -1509,7 +1509,7 @@ static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
                 rq->data += thislen;
                 rq->data_len -= thislen;
 
-                if (rq->flags & REQ_SENSE)
+                if (blk_sense_request(rq))
                         rq->sense_len += thislen;
         } else {
 confused:
@@ -1517,7 +1517,7 @@ confused:
                         "appears confused (ireason = 0x%02x). "
                         "Trying to recover by ending request.\n",
                         drive->name, ireason);
-                rq->flags |= REQ_FAILED;
+                rq->cmd_flags |= REQ_FAILED;
                 cdrom_end_request(drive, 0);
                 return ide_stopped;
         }
@@ -1546,7 +1546,7 @@ static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
         struct cdrom_info *info = drive->driver_data;
 
         info->dma = 0;
-        rq->flags &= ~REQ_FAILED;
+        rq->cmd_flags &= ~REQ_FAILED;
         len = rq->data_len;
 
         /* Start sending the command to the drive. */
@@ -1558,7 +1558,7 @@ static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
 {
         struct request_sense sense;
         int retries = 10;
-        unsigned int flags = rq->flags;
+        unsigned int flags = rq->cmd_flags;
 
         if (rq->sense == NULL)
                 rq->sense = &sense;
@@ -1567,14 +1567,14 @@ static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
         do {
                 int error;
                 unsigned long time = jiffies;
-                rq->flags = flags;
+                rq->cmd_flags = flags;
 
                 error = ide_do_drive_cmd(drive, rq, ide_wait);
                 time = jiffies - time;
 
                 /* FIXME: we should probably abort/retry or something 
                  * in case of failure */
-                if (rq->flags & REQ_FAILED) {
+                if (rq->cmd_flags & REQ_FAILED) {
                         /* The request failed.  Retry if it was due to a unit
                            attention status
                            (usually means media was changed). */
@@ -1596,10 +1596,10 @@ static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
                 }
 
                 /* End of retry loop. */
-        } while ((rq->flags & REQ_FAILED) && retries >= 0);
+        } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
 
         /* Return an error if the command failed. */
-        return (rq->flags & REQ_FAILED) ? -EIO : 0;
+        return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
 }
 
 /*
@@ -1963,7 +1963,7 @@ static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
 {
         struct cdrom_info *info = drive->driver_data;
 
-        rq->flags |= REQ_QUIET;
+        rq->cmd_flags |= REQ_QUIET;
 
         info->dma = 0;
 
@@ -2023,11 +2023,11 @@ ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
                 }
                 info->last_block = block;
                 return action;
-        } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
+        } else if (rq->cmd_type == REQ_TYPE_SENSE) {
                 return cdrom_do_packet_command(drive);
-        } else if (rq->flags & REQ_BLOCK_PC) {
+        } else if (blk_pc_request(rq)) {
                 return cdrom_do_block_pc(drive, rq);
-        } else if (rq->flags & REQ_SPECIAL) {
+        } else if (blk_special_request(rq)) {
                 /*
                  * right now this can only be a reset...
                  */
@@ -2105,7 +2105,7 @@ static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
 
         req.sense = sense;
         req.cmd[0] = GPCMD_TEST_UNIT_READY;
-        req.flags |= REQ_QUIET;
+        req.cmd_flags |= REQ_QUIET;
 
 #if ! STANDARD_ATAPI
         /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to 
@@ -2207,7 +2207,7 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
         req.data = (char *)&capbuf;
         req.data_len = sizeof(capbuf);
-        req.flags |= REQ_QUIET;
+        req.cmd_flags |= REQ_QUIET;
 
         stat = cdrom_queue_packet_command(drive, &req);
         if (stat == 0) {
@@ -2230,7 +2230,7 @@ static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
         req.sense = sense;
         req.data =  buf;
         req.data_len = buflen;
-        req.flags |= REQ_QUIET;
+        req.cmd_flags |= REQ_QUIET;
         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
         req.cmd[6] = trackno;
         req.cmd[7] = (buflen >> 8);
@@ -2531,7 +2531,7 @@ static int ide_cdrom_packet(struct cdrom_device_info *cdi,
         req.timeout = cgc->timeout;
 
         if (cgc->quiet)
-                req.flags |= REQ_QUIET;
+                req.cmd_flags |= REQ_QUIET;
 
         req.sense = cgc->sense;
         cgc->stat = cdrom_queue_packet_command(drive, &req);
@@ -2629,7 +2629,8 @@ int ide_cdrom_reset (struct cdrom_device_info *cdi)
         int ret;
 
         cdrom_prepare_request(drive, &req);
-        req.flags = REQ_SPECIAL | REQ_QUIET;
+        req.cmd_type = REQ_TYPE_SPECIAL;
+        req.cmd_flags = REQ_QUIET;
         ret = ide_do_drive_cmd(drive, &req, ide_wait);
 
         /*
@@ -3116,9 +3117,9 @@ static int ide_cdrom_prep_pc(struct request *rq)
 
 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
 {
-        if (rq->flags & REQ_CMD)
+        if (blk_fs_request(rq))
                 return ide_cdrom_prep_fs(q, rq);
-        else if (rq->flags & REQ_BLOCK_PC)
+        else if (blk_pc_request(rq))
                 return ide_cdrom_prep_pc(rq);
 
         return 0;
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 7cf3eb023521..0a05a377d66a 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -699,7 +699,8 @@ static void idedisk_prepare_flush(request_queue_t *q, struct request *rq)
                 rq->cmd[0] = WIN_FLUSH_CACHE;
 
 
-        rq->flags |= REQ_DRIVE_TASK;
+        rq->cmd_type = REQ_TYPE_ATA_TASK;
+        rq->cmd_flags |= REQ_SOFTBARRIER;
         rq->buffer = rq->cmd;
 }
 
@@ -740,7 +741,7 @@ static int set_multcount(ide_drive_t *drive, int arg)
         if (drive->special.b.set_multmode)
                 return -EBUSY;
         ide_init_drive_cmd (&rq);
-        rq.flags = REQ_DRIVE_CMD;
+        rq.cmd_type = REQ_TYPE_ATA_CMD;
         drive->mult_req = arg;
         drive->special.b.set_multmode = 1;
         (void) ide_do_drive_cmd (drive, &rq, ide_wait);
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index 7c3a13e1cf64..c3546fe9af63 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -205,7 +205,7 @@ int ide_build_sglist(ide_drive_t *drive, struct request *rq)
         ide_hwif_t *hwif = HWIF(drive);
         struct scatterlist *sg = hwif->sg_table;
 
-        BUG_ON((rq->flags & REQ_DRIVE_TASKFILE) && rq->nr_sectors > 256);
+        BUG_ON((rq->cmd_type == REQ_TYPE_ATA_TASKFILE) && rq->nr_sectors > 256);
 
         ide_map_sg(drive, rq);
 
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index adbe9f76a505..0edc32204915 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -588,7 +588,7 @@ static int idefloppy_do_end_request(ide_drive_t *drive, int uptodate, int nsecs)
         /* Why does this happen? */
         if (!rq)
                 return 0;
-        if (!(rq->flags & REQ_SPECIAL)) { //if (!IDEFLOPPY_RQ_CMD (rq->cmd)) {
+        if (!blk_special_request(rq)) {
                 /* our real local end request function */
                 ide_end_request(drive, uptodate, nsecs);
                 return 0;
@@ -689,7 +689,7 @@ static void idefloppy_queue_pc_head (ide_drive_t *drive,idefloppy_pc_t *pc,struc
 
         ide_init_drive_cmd(rq);
         rq->buffer = (char *) pc;
-        rq->flags = REQ_SPECIAL;        //rq->cmd = IDEFLOPPY_PC_RQ;
+        rq->cmd_type = REQ_TYPE_SPECIAL;
         rq->rq_disk = floppy->disk;
         (void) ide_do_drive_cmd(drive, rq, ide_preempt);
 }
@@ -1250,7 +1250,7 @@ static void idefloppy_create_rw_cmd (idefloppy_floppy_t *floppy, idefloppy_pc_t
         pc->callback = &idefloppy_rw_callback;
         pc->rq = rq;
         pc->b_count = cmd == READ ? 0 : rq->bio->bi_size;
-        if (rq->flags & REQ_RW)
+        if (rq->cmd_flags & REQ_RW)
                 set_bit(PC_WRITING, &pc->flags);
         pc->buffer = NULL;
         pc->request_transfer = pc->buffer_size = blocks * floppy->block_size;
@@ -1303,7 +1303,7 @@ static ide_startstop_t idefloppy_do_request (ide_drive_t *drive, struct request
                 idefloppy_do_end_request(drive, 0, 0);
                 return ide_stopped;
         }
-        if (rq->flags & REQ_CMD) {
+        if (blk_fs_request(rq)) {
                 if (((long)rq->sector % floppy->bs_factor) ||
                     (rq->nr_sectors % floppy->bs_factor)) {
                         printk("%s: unsupported r/w request size\n",
@@ -1313,9 +1313,9 @@ static ide_startstop_t idefloppy_do_request (ide_drive_t *drive, struct request
                 }
                 pc = idefloppy_next_pc_storage(drive);
                 idefloppy_create_rw_cmd(floppy, pc, rq, block);
-        } else if (rq->flags & REQ_SPECIAL) {
+        } else if (blk_special_request(rq)) {
                 pc = (idefloppy_pc_t *) rq->buffer;
-        } else if (rq->flags & REQ_BLOCK_PC) {
+        } else if (blk_pc_request(rq)) {
                 pc = idefloppy_next_pc_storage(drive);
                 if (idefloppy_blockpc_cmd(floppy, pc, rq)) {
                         idefloppy_do_end_request(drive, 0, 0);
@@ -1343,7 +1343,7 @@ static int idefloppy_queue_pc_tail (ide_drive_t *drive,idefloppy_pc_t *pc)
 
         ide_init_drive_cmd (&rq);
         rq.buffer = (char *) pc;
-        rq.flags = REQ_SPECIAL;         //      rq.cmd = IDEFLOPPY_PC_RQ;
+        rq.cmd_type = REQ_TYPE_SPECIAL;
         rq.rq_disk = floppy->disk;
 
         return ide_do_drive_cmd(drive, &rq, ide_wait);
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index fb6795236e76..3436b1f104eb 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -59,7 +59,7 @@ static int __ide_end_request(ide_drive_t *drive, struct request *rq,
 {
         int ret = 1;
 
-        BUG_ON(!(rq->flags & REQ_STARTED));
+        BUG_ON(!blk_rq_started(rq));
 
         /*
          * if failfast is set on a request, override number of sectors and
@@ -244,7 +244,7 @@ int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
 
         spin_lock_irqsave(&ide_lock, flags);
 
-        BUG_ON(!(rq->flags & REQ_STARTED));
+        BUG_ON(!blk_rq_started(rq));
 
         /*
          * if failfast is set on a request, override number of sectors and
@@ -366,7 +366,7 @@ void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
         rq = HWGROUP(drive)->rq;
         spin_unlock_irqrestore(&ide_lock, flags);
 
-        if (rq->flags & REQ_DRIVE_CMD) {
+        if (rq->cmd_type == REQ_TYPE_ATA_CMD) {
                 u8 *args = (u8 *) rq->buffer;
                 if (rq->errors == 0)
                         rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
@@ -376,7 +376,7 @@ void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
                         args[1] = err;
                         args[2] = hwif->INB(IDE_NSECTOR_REG);
                 }
-        } else if (rq->flags & REQ_DRIVE_TASK) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_TASK) {
                 u8 *args = (u8 *) rq->buffer;
                 if (rq->errors == 0)
                         rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
@@ -390,7 +390,7 @@ void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
                         args[5] = hwif->INB(IDE_HCYL_REG);
                         args[6] = hwif->INB(IDE_SELECT_REG);
                 }
-        } else if (rq->flags & REQ_DRIVE_TASKFILE) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                 ide_task_t *args = (ide_task_t *) rq->special;
                 if (rq->errors == 0)
                         rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
@@ -587,7 +587,7 @@ ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, u8 stat)
                 return ide_stopped;
 
         /* retry only "normal" I/O: */
-        if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK | REQ_DRIVE_TASKFILE)) {
+        if (!blk_fs_request(rq)) {
                 rq->errors = 1;
                 ide_end_drive_cmd(drive, stat, err);
                 return ide_stopped;
@@ -638,7 +638,7 @@ ide_startstop_t ide_abort(ide_drive_t *drive, const char *msg)
                 return ide_stopped;
 
         /* retry only "normal" I/O: */
-        if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK | REQ_DRIVE_TASKFILE)) {
+        if (!blk_fs_request(rq)) {
                 rq->errors = 1;
                 ide_end_drive_cmd(drive, BUSY_STAT, 0);
                 return ide_stopped;
@@ -808,7 +808,7 @@ void ide_map_sg(ide_drive_t *drive, struct request *rq)
         if (hwif->sg_mapped)    /* needed by ide-scsi */
                 return;
 
-        if ((rq->flags & REQ_DRIVE_TASKFILE) == 0) {
+        if (rq->cmd_type != REQ_TYPE_ATA_TASKFILE) {
                 hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
         } else {
                 sg_init_one(sg, rq->buffer, rq->nr_sectors * SECTOR_SIZE);
@@ -844,7 +844,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                 struct request *rq)
 {
         ide_hwif_t *hwif = HWIF(drive);
-        if (rq->flags & REQ_DRIVE_TASKFILE) {
+        if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                 ide_task_t *args = rq->special;
  
                 if (!args)
@@ -866,7 +866,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                 if (args->tf_out_flags.all != 0) 
                         return flagged_taskfile(drive, args);
                 return do_rw_taskfile(drive, args);
-        } else if (rq->flags & REQ_DRIVE_TASK) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_TASK) {
                 u8 *args = rq->buffer;
                 u8 sel;
  
@@ -892,7 +892,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                 hwif->OUTB(sel, IDE_SELECT_REG);
                 ide_cmd(drive, args[0], args[2], &drive_cmd_intr);
                 return ide_started;
-        } else if (rq->flags & REQ_DRIVE_CMD) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_CMD) {
                 u8 *args = rq->buffer;
 
                 if (!args)
@@ -980,7 +980,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
         ide_startstop_t startstop;
         sector_t block;
 
-        BUG_ON(!(rq->flags & REQ_STARTED));
+        BUG_ON(!blk_rq_started(rq));
 
 #ifdef DEBUG
         printk("%s: start_request: current=0x%08lx\n",
@@ -1013,9 +1013,9 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
         if (!drive->special.all) {
                 ide_driver_t *drv;
 
-                if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK))
-                        return execute_drive_cmd(drive, rq);
-                else if (rq->flags & REQ_DRIVE_TASKFILE)
+                if (rq->cmd_type == REQ_TYPE_ATA_CMD ||
+                    rq->cmd_type == REQ_TYPE_ATA_TASK ||
+                    rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
                         return execute_drive_cmd(drive, rq);
                 else if (blk_pm_request(rq)) {
                         struct request_pm_state *pm = rq->end_io_data;
@@ -1264,7 +1264,7 @@ 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->flags & REQ_PREEMPT)) {
+                if (drive->blocked && !blk_pm_request(rq) && !(rq->cmd_flags & REQ_PREEMPT)) {
                         drive = drive->next ? drive->next : hwgroup->drive;
                         if (loops++ < 4 && !blk_queue_plugged(drive->queue))
                                 goto again;
@@ -1670,7 +1670,7 @@ irqreturn_t ide_intr (int irq, void *dev_id, struct pt_regs *regs)
 void ide_init_drive_cmd (struct request *rq)
 {
         memset(rq, 0, sizeof(*rq));
-        rq->flags = REQ_DRIVE_CMD;
+        rq->cmd_type = REQ_TYPE_ATA_CMD;
         rq->ref_count = 1;
 }
 
@@ -1727,7 +1727,7 @@ int ide_do_drive_cmd (ide_drive_t *drive, struct request *rq, ide_action_t actio
                 hwgroup->rq = NULL;
         if (action == ide_preempt || action == ide_head_wait) {
                 where = ELEVATOR_INSERT_FRONT;
-                rq->flags |= REQ_PREEMPT;
+                rq->cmd_flags |= REQ_PREEMPT;
         }
         __elv_add_request(drive->queue, rq, where, 0);
         ide_do_request(hwgroup, IDE_NO_IRQ);
diff --git a/drivers/ide/ide-lib.c b/drivers/ide/ide-lib.c
index 1feff23487d4..850ef63cc986 100644
--- a/drivers/ide/ide-lib.c
+++ b/drivers/ide/ide-lib.c
@@ -456,13 +456,14 @@ static void ide_dump_opcode(ide_drive_t *drive)
         spin_unlock(&ide_lock);
         if (!rq)
                 return;
-        if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK)) {
+        if (rq->cmd_type == REQ_TYPE_ATA_CMD ||
+            rq->cmd_type == REQ_TYPE_ATA_TASK) {
                 char *args = rq->buffer;
                 if (args) {
                         opcode = args[0];
                         found = 1;
                 }
-        } else if (rq->flags & REQ_DRIVE_TASKFILE) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                 ide_task_t *args = rq->special;
                 if (args) {
                         task_struct_t *tf = (task_struct_t *) args->tfRegister;
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 7067ab997927..643e4b9ac651 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -1776,7 +1776,7 @@ static void idetape_create_request_sense_cmd (idetape_pc_t *pc)
 static void idetape_init_rq(struct request *rq, u8 cmd)
 {
         memset(rq, 0, sizeof(*rq));
-        rq->flags = REQ_SPECIAL;
+        rq->cmd_type = REQ_TYPE_SPECIAL;
         rq->cmd[0] = cmd;
 }
 
@@ -2433,12 +2433,12 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
                         rq->sector, rq->nr_sectors, rq->current_nr_sectors);
 #endif /* IDETAPE_DEBUG_LOG */
 
-        if ((rq->flags & REQ_SPECIAL) == 0) {
+        if (!blk_special_request(rq)) {
                 /*
                  * We do not support buffer cache originated requests.
                  */
                 printk(KERN_NOTICE "ide-tape: %s: Unsupported request in "
-                        "request queue (%ld)\n", drive->name, rq->flags);
+                        "request queue (%d)\n", drive->name, rq->cmd_type);
                 ide_end_request(drive, 0, 0);
                 return ide_stopped;
         }
@@ -2768,7 +2768,7 @@ static void idetape_wait_for_request (ide_drive_t *drive, struct request *rq)
         idetape_tape_t *tape = drive->driver_data;
 
 #if IDETAPE_DEBUG_BUGS
-        if (rq == NULL || (rq->flags & REQ_SPECIAL) == 0) {
+        if (rq == NULL || !blk_special_request(rq)) {
                 printk (KERN_ERR "ide-tape: bug: Trying to sleep on non-valid request\n");
                 return;
         }
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index 97a9244312fc..1d0470c1f957 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -363,7 +363,7 @@ static ide_startstop_t task_error(ide_drive_t *drive, struct request *rq,
 
 static void task_end_request(ide_drive_t *drive, struct request *rq, u8 stat)
 {
-        if (rq->flags & REQ_DRIVE_TASKFILE) {
+        if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                 ide_task_t *task = rq->special;
 
                 if (task->tf_out_flags.all) {
@@ -474,7 +474,7 @@ static int ide_diag_taskfile(ide_drive_t *drive, ide_task_t *args, unsigned long
         struct request rq;
 
         memset(&rq, 0, sizeof(rq));
-        rq.flags = REQ_DRIVE_TASKFILE;
+        rq.cmd_type = REQ_TYPE_ATA_TASKFILE;
         rq.buffer = buf;
 
         /*
@@ -499,7 +499,7 @@ static int ide_diag_taskfile(ide_drive_t *drive, ide_task_t *args, unsigned long
                 rq.hard_cur_sectors = rq.current_nr_sectors = rq.nr_sectors;
 
                 if (args->command_type == IDE_DRIVE_TASK_RAW_WRITE)
-                        rq.flags |= REQ_RW;
+                        rq.cmd_flags |= REQ_RW;
         }
 
         rq.special = args;
@@ -737,7 +737,7 @@ static int ide_wait_cmd_task(ide_drive_t *drive, u8 *buf)
         struct request rq;
 
         ide_init_drive_cmd(&rq);
-        rq.flags = REQ_DRIVE_TASK;
+        rq.cmd_type = REQ_TYPE_ATA_TASK;
         rq.buffer = buf;
         return ide_do_drive_cmd(drive, &rq, ide_wait);
 }
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 9c8468de1a75..9384a3fdde6c 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -1217,7 +1217,7 @@ static int generic_ide_suspend(struct device *dev, pm_message_t mesg)
         memset(&rq, 0, sizeof(rq));
         memset(&rqpm, 0, sizeof(rqpm));
         memset(&args, 0, sizeof(args));
-        rq.flags = REQ_PM_SUSPEND;
+        rq.cmd_type = REQ_TYPE_PM_SUSPEND;
         rq.special = &args;
         rq.end_io_data = &rqpm;
         rqpm.pm_step = ide_pm_state_start_suspend;
@@ -1238,7 +1238,7 @@ static int generic_ide_resume(struct device *dev)
         memset(&rq, 0, sizeof(rq));
         memset(&rqpm, 0, sizeof(rqpm));
         memset(&args, 0, sizeof(args));
-        rq.flags = REQ_PM_RESUME;
+        rq.cmd_type = REQ_TYPE_PM_RESUME;
         rq.special = &args;
         rq.end_io_data = &rqpm;
         rqpm.pm_step = ide_pm_state_start_resume;
diff --git a/drivers/ide/legacy/hd.c b/drivers/ide/legacy/hd.c
index aebecd8f51cc..4ab931145673 100644
--- a/drivers/ide/legacy/hd.c
+++ b/drivers/ide/legacy/hd.c
@@ -626,7 +626,7 @@ repeat:
                 req->rq_disk->disk_name, (req->cmd == READ)?"read":"writ",
                 cyl, head, sec, nsect, req->buffer);
 #endif
-        if (req->flags & REQ_CMD) {
+        if (blk_fs_request(req)) {
                 switch (rq_data_dir(req)) {
                 case READ:
                         hd_out(disk,nsect,sec,head,cyl,WIN_READ,&read_intr);