Just replace it with a field of the same name in struct ide_req.
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
 
        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
        ide_req(rq)->type = ATA_PRIV_MISC;
-       rq->special = (char *)pc;
+       ide_req(rq)->special = pc;
 
        if (buf && bufflen) {
                error = blk_rq_map_kern(drive->queue, rq, buf, bufflen,
                return -ENOMEM;
        }
 
-       sense_rq->special = special;
+       ide_req(sense_rq)->special = special;
        drive->sense_rq_armed = false;
 
        drive->hwif->rq = NULL;
 
 static void ide_cd_complete_failed_rq(ide_drive_t *drive, struct request *rq)
 {
        /*
-        * For ATA_PRIV_SENSE, "rq->special" points to the original
+        * For ATA_PRIV_SENSE, "ide_req(rq)->special" points to the original
         * failed request.  Also, the sense data should be read
         * directly from rq which might be different from the original
         * sense buffer if it got copied during mapping.
         */
-       struct request *failed = (struct request *)rq->special;
+       struct request *failed = ide_req(rq)->special;
        void *sense = bio_data(rq->bio);
 
        if (failed) {
 
        scsi_req(rq)->cmd_len = 5;
        scsi_req(rq)->cmd[0] = REQ_DEVSET_EXEC;
        *(int *)&scsi_req(rq)->cmd[1] = arg;
-       rq->special = setting->set;
+       ide_req(rq)->special = setting->set;
 
        blk_execute_rq(q, NULL, rq, 0);
        ret = scsi_req(rq)->result;
 
 ide_startstop_t ide_do_devset(ide_drive_t *drive, struct request *rq)
 {
-       int err, (*setfunc)(ide_drive_t *, int) = rq->special;
+       int err, (*setfunc)(ide_drive_t *, int) = ide_req(rq)->special;
 
        err = setfunc(drive, *(int *)&scsi_req(rq)->cmd[1]);
        if (err)
 
        if (req_op(rq) != REQ_OP_FLUSH)
                return true;
 
-       if (rq->special) {
-               cmd = rq->special;
+       if (ide_req(rq)->special) {
+               cmd = ide_req(rq)->special;
                memset(cmd, 0, sizeof(*cmd));
        } else {
                cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
        rq->cmd_flags &= ~REQ_OP_MASK;
        rq->cmd_flags |= REQ_OP_DRV_OUT;
        ide_req(rq)->type = ATA_PRIV_TASKFILE;
-       rq->special = cmd;
+       ide_req(rq)->special = cmd;
        cmd->rq = rq;
 
        return true;
 
        /* retry only "normal" I/O: */
        if (blk_rq_is_passthrough(rq)) {
                if (ata_taskfile_request(rq)) {
-                       struct ide_cmd *cmd = rq->special;
+                       struct ide_cmd *cmd = ide_req(rq)->special;
 
                        if (cmd)
                                ide_complete_cmd(drive, cmd, stat, err);
 
                switch (ide_req(rq)->type) {
                case ATA_PRIV_MISC:
                case ATA_PRIV_SENSE:
-                       pc = (struct ide_atapi_pc *)rq->special;
+                       pc = (struct ide_atapi_pc *)ide_req(rq)->special;
                        break;
                default:
                        BUG();
 
        }
 
        if (rq && ata_taskfile_request(rq)) {
-               struct ide_cmd *orig_cmd = rq->special;
+               struct ide_cmd *orig_cmd = ide_req(rq)->special;
 
                if (cmd->tf_flags & IDE_TFLAG_DYN)
                        kfree(orig_cmd);
 static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                struct request *rq)
 {
-       struct ide_cmd *cmd = rq->special;
+       struct ide_cmd *cmd = ide_req(rq)->special;
 
        if (cmd) {
                if (cmd->protocol == ATA_PROT_PIO) {
                if (ata_taskfile_request(rq))
                        return execute_drive_cmd(drive, rq);
                else if (ata_pm_request(rq)) {
-                       struct ide_pm_state *pm = rq->special;
+                       struct ide_pm_state *pm = ide_req(rq)->special;
 #ifdef DEBUG_PM
                        printk("%s: start_power_step(step: %d)\n",
                                drive->name, pm->pm_step);
        ide_drive_t     *drive = hctx->queue->queuedata;
        ide_hwif_t      *hwif = drive->hwif;
        struct ide_host *host = hwif->host;
-       struct request  *rq = NULL;
+       struct request  *rq = bd->rq;
        ide_startstop_t startstop;
 
+       if (!(rq->rq_flags & RQF_DONTPREP)) {
+               rq->rq_flags |= RQF_DONTPREP;
+               ide_req(rq)->special = NULL;
+       }
+
        /* HLD do_request() callback might sleep, make sure it's okay */
        might_sleep();
 
        if (ide_lock_host(host, hwif))
                return BLK_STS_DEV_RESOURCE;
 
-       rq = bd->rq;
        blk_mq_start_request(rq);
 
        spin_lock_irq(&hwif->lock);
 
        scsi_req(rq)->cmd[0] = REQ_PARK_HEADS;
        scsi_req(rq)->cmd_len = 1;
        ide_req(rq)->type = ATA_PRIV_MISC;
-       rq->special = &timeout;
+       ide_req(rq)->special = &timeout;
        blk_execute_rq(q, NULL, rq, 1);
        rc = scsi_req(rq)->result ? -EIO : 0;
        blk_put_request(rq);
 
        memset(&cmd, 0, sizeof(cmd));
        if (scsi_req(rq)->cmd[0] == REQ_PARK_HEADS) {
-               drive->sleep = *(unsigned long *)rq->special;
+               drive->sleep = *(unsigned long *)ide_req(rq)->special;
                drive->dev_flags |= IDE_DFLAG_SLEEPING;
                tf->command = ATA_CMD_IDLEIMMEDIATE;
                tf->feature = 0x44;
 
        memset(&rqpm, 0, sizeof(rqpm));
        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
        ide_req(rq)->type = ATA_PRIV_PM_SUSPEND;
-       rq->special = &rqpm;
+       ide_req(rq)->special = &rqpm;
        rqpm.pm_step = IDE_PM_START_SUSPEND;
        if (mesg.event == PM_EVENT_PRETHAW)
                mesg.event = PM_EVENT_FREEZE;
        memset(&rqpm, 0, sizeof(rqpm));
        rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, BLK_MQ_REQ_PREEMPT);
        ide_req(rq)->type = ATA_PRIV_PM_RESUME;
-       rq->special = &rqpm;
+       ide_req(rq)->special = &rqpm;
        rqpm.pm_step = IDE_PM_START_RESUME;
        rqpm.pm_state = PM_EVENT_ON;
 
 
 void ide_complete_power_step(ide_drive_t *drive, struct request *rq)
 {
-       struct ide_pm_state *pm = rq->special;
+       struct ide_pm_state *pm = ide_req(rq)->special;
 
 #ifdef DEBUG_PM
        printk(KERN_INFO "%s: complete_power_step(step: %d)\n",
 
 ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
 {
-       struct ide_pm_state *pm = rq->special;
+       struct ide_pm_state *pm = ide_req(rq)->special;
        struct ide_cmd cmd = { };
 
        switch (pm->pm_step) {
 void ide_complete_pm_rq(ide_drive_t *drive, struct request *rq)
 {
        struct request_queue *q = drive->queue;
-       struct ide_pm_state *pm = rq->special;
+       struct ide_pm_state *pm = ide_req(rq)->special;
        unsigned long flags;
 
        ide_complete_power_step(drive, rq);
 
 void ide_check_pm_state(ide_drive_t *drive, struct request *rq)
 {
-       struct ide_pm_state *pm = rq->special;
+       struct ide_pm_state *pm = ide_req(rq)->special;
 
        if (blk_rq_is_private(rq) &&
            ide_req(rq)->type == ATA_PRIV_PM_SUSPEND &&
 
                goto out;
        }
        if (req->cmd[13] & REQ_IDETAPE_PC1) {
-               pc = (struct ide_atapi_pc *)rq->special;
+               pc = (struct ide_atapi_pc *)ide_req(rq)->special;
                req->cmd[13] &= ~(REQ_IDETAPE_PC1);
                req->cmd[13] |= REQ_IDETAPE_PC2;
                goto out;
 
                        goto put_req;
        }
 
-       rq->special = cmd;
+       ide_req(rq)->special = cmd;
        cmd->rq = rq;
 
        blk_execute_rq(drive->queue, NULL, rq, 0);
 
        struct scsi_request sreq;
        u8 sense[SCSI_SENSE_BUFFERSIZE];
        u8 type;
+       void *special;
 };
 
 static inline struct ide_request *ide_req(struct request *rq)