mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-28 10:41:38 -04:00
[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 <[email protected]>
This commit is contained in:
Jens Axboe
Jens Axboe
parent
77ed74da26
commit
4aff5e2333
39 changed files with 295 additions and 301 deletions
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
Loading…
Reference in a new issue