UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

ide: add ide_queue_pc_tail() helper 

* Add ide_queue_pc_tail() and convert ide-{floppy,tape}.c to use it
  instead of ide*_queue_pc_tail().

* Remove no longer used ide*_queue_pc_tail().

There should be no functional changes caused by this patch.

Acked-by: Borislav Petkov <petkovbb@gmail.com>
Acked-by: Sergei Shtylyov <sshtylyov@ru.mvista.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
This commit is contained in:
Bartlomiej Zolnierkiewicz 2008-10-10 22:39:38 +02:00
parent 7645c1514c
commit 2ac07d9206
4 changed files with 69 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
drivers/ide/ide-atapi.c
View File

@ -139,6 +139,29 @@ void ide_queue_pc_head(ide_drive_t *drive, struct gendisk *disk,
} }
EXPORT_SYMBOL_GPL(ide_queue_pc_head); EXPORT_SYMBOL_GPL(ide_queue_pc_head);
/*
* Add a special packet command request to the tail of the request queue,
* and wait for it to be serviced.
*/
int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
struct ide_atapi_pc *pc)
{
struct request *rq;
int error;
rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
rq->cmd_type = REQ_TYPE_SPECIAL;
rq->buffer = (char *)pc;
memcpy(rq->cmd, pc->c, 12);
if (drive->media == ide_tape)
rq->cmd[13] = REQ_IDETAPE_PC1;
error = blk_execute_rq(drive->queue, disk, rq, 0);
blk_put_request(rq);
return error;
}
EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
/* TODO: unify the code thus making some arguments go away */ /* TODO: unify the code thus making some arguments go away */
ide_startstop_t ide_pc_intr(ide_drive_t *drive, struct ide_atapi_pc *pc, ide_startstop_t ide_pc_intr(ide_drive_t *drive, struct ide_atapi_pc *pc,
ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry, ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry,

49
drivers/ide/ide-floppy.c
View File

@ -553,26 +553,6 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
return idefloppy_issue_pc(drive, pc); return idefloppy_issue_pc(drive, pc);
} }
/*
* Add a special packet command request to the tail of the request queue,
* and wait for it to be serviced.
*/
static int idefloppy_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc)
{
struct ide_floppy_obj *floppy = drive->driver_data;
struct request *rq;
int error;
rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
rq->buffer = (char *) pc;
rq->cmd_type = REQ_TYPE_SPECIAL;
memcpy(rq->cmd, pc->c, 12);
error = blk_execute_rq(drive->queue, floppy->disk, rq, 0);
blk_put_request(rq);
return error;
}
/* /*
* Look at the flexible disk page parameters. We ignore the CHS capacity * Look at the flexible disk page parameters. We ignore the CHS capacity
* parameters and use the LBA parameters instead. * parameters and use the LBA parameters instead.
@ -580,6 +560,7 @@ static int idefloppy_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc)
static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive) static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
{ {
idefloppy_floppy_t *floppy = drive->driver_data; idefloppy_floppy_t *floppy = drive->driver_data;
struct gendisk *disk = floppy->disk;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
u8 *page; u8 *page;
int capacity, lba_capacity; int capacity, lba_capacity;
@ -588,13 +569,13 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE); idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE);
if (idefloppy_queue_pc_tail(drive, &pc)) { if (ide_queue_pc_tail(drive, disk, &pc)) {
printk(KERN_ERR "ide-floppy: Can't get flexible disk page" printk(KERN_ERR "ide-floppy: Can't get flexible disk page"
" parameters\n"); " parameters\n");
return 1; return 1;
} }
floppy->wp = !!(pc.buf[3] & 0x80); floppy->wp = !!(pc.buf[3] & 0x80);
set_disk_ro(floppy->disk, floppy->wp); set_disk_ro(disk, floppy->wp);
page = &pc.buf[8]; page = &pc.buf[8];
transfer_rate = be16_to_cpup((__be16 *)&pc.buf[8 + 2]); transfer_rate = be16_to_cpup((__be16 *)&pc.buf[8 + 2]);
@ -638,7 +619,7 @@ static int idefloppy_get_sfrp_bit(ide_drive_t *drive)
idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE); idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE);
pc.flags |= PC_FLAG_SUPPRESS_ERROR; pc.flags |= PC_FLAG_SUPPRESS_ERROR;
if (idefloppy_queue_pc_tail(drive, &pc)) if (ide_queue_pc_tail(drive, floppy->disk, &pc))
return 1; return 1;
floppy->srfp = pc.buf[8 + 2] & 0x40; floppy->srfp = pc.buf[8 + 2] & 0x40;
@ -652,6 +633,7 @@ static int idefloppy_get_sfrp_bit(ide_drive_t *drive)
static int ide_floppy_get_capacity(ide_drive_t *drive) static int ide_floppy_get_capacity(ide_drive_t *drive)
{ {
idefloppy_floppy_t *floppy = drive->driver_data; idefloppy_floppy_t *floppy = drive->driver_data;
struct gendisk *disk = floppy->disk;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
u8 *cap_desc; u8 *cap_desc;
u8 header_len, desc_cnt; u8 header_len, desc_cnt;
@ -664,7 +646,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
set_capacity(floppy->disk, 0); set_capacity(floppy->disk, 0);
idefloppy_create_read_capacity_cmd(&pc); idefloppy_create_read_capacity_cmd(&pc);
if (idefloppy_queue_pc_tail(drive, &pc)) { if (ide_queue_pc_tail(drive, disk, &pc)) {
printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n"); printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
return 1; return 1;
} }
@ -739,7 +721,8 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE)) if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
(void) ide_floppy_get_flexible_disk_page(drive); (void) ide_floppy_get_flexible_disk_page(drive);
set_capacity(floppy->disk, floppy->blocks * floppy->bs_factor); set_capacity(disk, floppy->blocks * floppy->bs_factor);
return rc; return rc;
} }
@ -764,6 +747,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg) static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)
{ {
struct ide_floppy_obj *floppy = drive->driver_data;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
u8 header_len, desc_cnt; u8 header_len, desc_cnt;
int i, blocks, length, u_array_size, u_index; int i, blocks, length, u_array_size, u_index;
@ -776,7 +760,7 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)
return -EINVAL; return -EINVAL;
idefloppy_create_read_capacity_cmd(&pc); idefloppy_create_read_capacity_cmd(&pc);
if (idefloppy_queue_pc_tail(drive, &pc)) { if (ide_queue_pc_tail(drive, floppy->disk, &pc)) {
printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n"); printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
return -EIO; return -EIO;
} }
@ -838,7 +822,7 @@ static int ide_floppy_get_format_progress(ide_drive_t *drive, int __user *arg)
if (floppy->srfp) { if (floppy->srfp) {
idefloppy_create_request_sense_cmd(&pc); idefloppy_create_request_sense_cmd(&pc);
if (idefloppy_queue_pc_tail(drive, &pc)) if (ide_queue_pc_tail(drive, floppy->disk, &pc))
return -EIO; return -EIO;
if (floppy->sense_key == 2 && if (floppy->sense_key == 2 &&
@ -1008,12 +992,13 @@ static ide_driver_t idefloppy_driver = {
static void ide_floppy_set_media_lock(ide_drive_t *drive, int on) static void ide_floppy_set_media_lock(ide_drive_t *drive, int on)
{ {
struct ide_floppy_obj *floppy = drive->driver_data;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
/* IOMEGA Clik! drives do not support lock/unlock commands */ /* IOMEGA Clik! drives do not support lock/unlock commands */
if ((drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE) == 0) { if ((drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE) == 0) {
idefloppy_create_prevent_cmd(&pc, on); idefloppy_create_prevent_cmd(&pc, on);
(void)idefloppy_queue_pc_tail(drive, &pc); (void)ide_queue_pc_tail(drive, floppy->disk, &pc);
} }
} }
@ -1042,9 +1027,9 @@ static int idefloppy_open(struct inode *inode, struct file *filp)
ide_init_pc(&pc); ide_init_pc(&pc);
pc.c[0] = GPCMD_TEST_UNIT_READY; pc.c[0] = GPCMD_TEST_UNIT_READY;
if (idefloppy_queue_pc_tail(drive, &pc)) { if (ide_queue_pc_tail(drive, disk, &pc)) {
idefloppy_create_start_stop_cmd(&pc, 1); idefloppy_create_start_stop_cmd(&pc, 1);
(void) idefloppy_queue_pc_tail(drive, &pc); (void)ide_queue_pc_tail(drive, disk, &pc);
} }
if (ide_floppy_get_capacity(drive) if (ide_floppy_get_capacity(drive)
@ -1123,7 +1108,7 @@ static int ide_floppy_lockdoor(ide_drive_t *drive, struct ide_atapi_pc *pc,
if (cmd == CDROMEJECT) { if (cmd == CDROMEJECT) {
idefloppy_create_start_stop_cmd(pc, 2); idefloppy_create_start_stop_cmd(pc, 2);
(void) idefloppy_queue_pc_tail(floppy->drive, pc); (void)ide_queue_pc_tail(drive, floppy->disk, pc);
} }
return 0; return 0;
@ -1168,7 +1153,7 @@ static int ide_floppy_format_unit(ide_drive_t *drive, int __user *arg)
(void) idefloppy_get_sfrp_bit(drive); (void) idefloppy_get_sfrp_bit(drive);
idefloppy_create_format_unit_cmd(&pc, blocks, length, flags); idefloppy_create_format_unit_cmd(&pc, blocks, length, flags);
if (idefloppy_queue_pc_tail(drive, &pc)) if (ide_queue_pc_tail(drive, floppy->disk, &pc))
err = -EIO; err = -EIO;
out: out:

69
drivers/ide/ide-tape.c
View File

@ -1125,26 +1125,6 @@ static void idetape_create_test_unit_ready_cmd(struct ide_atapi_pc *pc)
pc->c[0] = TEST_UNIT_READY; pc->c[0] = TEST_UNIT_READY;
} }
/*
* We add a special packet command request to the tail of the request queue, and
* wait for it to be serviced.
*/
static int idetape_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc)
{
struct ide_tape_obj *tape = drive->driver_data;
struct request *rq;
int error;
rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
rq->cmd_type = REQ_TYPE_SPECIAL;
rq->cmd[13] = REQ_IDETAPE_PC1;
rq->buffer = (char *)pc;
memcpy(rq->cmd, pc->c, 12);
error = blk_execute_rq(drive->queue, tape->disk, rq, 0);
blk_put_request(rq);
return error;
}
static void idetape_create_load_unload_cmd(ide_drive_t *drive, static void idetape_create_load_unload_cmd(ide_drive_t *drive,
struct ide_atapi_pc *pc, int cmd) struct ide_atapi_pc *pc, int cmd)
{ {
@ -1157,6 +1137,7 @@ static void idetape_create_load_unload_cmd(ide_drive_t *drive,
static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout) static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
{ {
idetape_tape_t *tape = drive->driver_data; idetape_tape_t *tape = drive->driver_data;
struct gendisk *disk = tape->disk;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
int load_attempted = 0; int load_attempted = 0;
@ -1165,7 +1146,7 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
timeout += jiffies; timeout += jiffies;
while (time_before(jiffies, timeout)) { while (time_before(jiffies, timeout)) {
idetape_create_test_unit_ready_cmd(&pc); idetape_create_test_unit_ready_cmd(&pc);
if (!idetape_queue_pc_tail(drive, &pc)) if (!ide_queue_pc_tail(drive, disk, &pc))
return 0; return 0;
if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2) if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2)
|| (tape->asc == 0x3A)) { || (tape->asc == 0x3A)) {
@ -1174,7 +1155,7 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
return -ENOMEDIUM; return -ENOMEDIUM;
idetape_create_load_unload_cmd(drive, &pc, idetape_create_load_unload_cmd(drive, &pc,
IDETAPE_LU_LOAD_MASK); IDETAPE_LU_LOAD_MASK);
idetape_queue_pc_tail(drive, &pc); ide_queue_pc_tail(drive, disk, &pc);
load_attempted = 1; load_attempted = 1;
/* not about to be ready */ /* not about to be ready */
} else if (!(tape->sense_key == 2 && tape->asc == 4 && } else if (!(tape->sense_key == 2 && tape->asc == 4 &&
@ -1187,11 +1168,12 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
static int idetape_flush_tape_buffers(ide_drive_t *drive) static int idetape_flush_tape_buffers(ide_drive_t *drive)
{ {
struct ide_tape_obj *tape = drive->driver_data;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
int rc; int rc;
idetape_create_write_filemark_cmd(drive, &pc, 0); idetape_create_write_filemark_cmd(drive, &pc, 0);
rc = idetape_queue_pc_tail(drive, &pc); rc = ide_queue_pc_tail(drive, tape->disk, &pc);
if (rc) if (rc)
return rc; return rc;
idetape_wait_ready(drive, 60 * 5 * HZ); idetape_wait_ready(drive, 60 * 5 * HZ);
@ -1214,7 +1196,7 @@ static int idetape_read_position(ide_drive_t *drive)
debug_log(DBG_PROCS, "Enter %s\n", __func__); debug_log(DBG_PROCS, "Enter %s\n", __func__);
idetape_create_read_position_cmd(&pc); idetape_create_read_position_cmd(&pc);
if (idetape_queue_pc_tail(drive, &pc)) if (ide_queue_pc_tail(drive, tape->disk, &pc))
return -1; return -1;
position = tape->first_frame; position = tape->first_frame;
return position; return position;
@ -1249,12 +1231,13 @@ static int idetape_create_prevent_cmd(ide_drive_t *drive,
static int ide_tape_set_media_lock(ide_drive_t *drive, int on) static int ide_tape_set_media_lock(ide_drive_t *drive, int on)
{ {
struct ide_tape_obj *tape = drive->driver_data;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
if (!idetape_create_prevent_cmd(drive, &pc, on)) if (!idetape_create_prevent_cmd(drive, &pc, on))
return 0; return 0;
return idetape_queue_pc_tail(drive, &pc); return ide_queue_pc_tail(drive, tape->disk, &pc);
} }
static void __ide_tape_discard_merge_buffer(ide_drive_t *drive) static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)
@ -1284,6 +1267,7 @@ static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
u8 partition, int skip) u8 partition, int skip)
{ {
idetape_tape_t *tape = drive->driver_data; idetape_tape_t *tape = drive->driver_data;
struct gendisk *disk = tape->disk;
int retval; int retval;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
@ -1291,12 +1275,12 @@ static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
__ide_tape_discard_merge_buffer(drive); __ide_tape_discard_merge_buffer(drive);
idetape_wait_ready(drive, 60 * 5 * HZ); idetape_wait_ready(drive, 60 * 5 * HZ);
idetape_create_locate_cmd(drive, &pc, block, partition, skip); idetape_create_locate_cmd(drive, &pc, block, partition, skip);
retval = idetape_queue_pc_tail(drive, &pc); retval = ide_queue_pc_tail(drive, disk, &pc);
if (retval) if (retval)
return (retval); return (retval);
idetape_create_read_position_cmd(&pc); idetape_create_read_position_cmd(&pc);
return (idetape_queue_pc_tail(drive, &pc)); return ide_queue_pc_tail(drive, disk, &pc);
} }
static void ide_tape_discard_merge_buffer(ide_drive_t *drive, static void ide_tape_discard_merge_buffer(ide_drive_t *drive,
@ -1543,20 +1527,20 @@ static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
*/ */
static int idetape_rewind_tape(ide_drive_t *drive) static int idetape_rewind_tape(ide_drive_t *drive)
{ {
struct ide_tape_obj *tape = drive->driver_data;
struct gendisk *disk = tape->disk;
int retval; int retval;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
idetape_tape_t *tape;
tape = drive->driver_data;
debug_log(DBG_SENSE, "Enter %s\n", __func__); debug_log(DBG_SENSE, "Enter %s\n", __func__);
idetape_create_rewind_cmd(drive, &pc); idetape_create_rewind_cmd(drive, &pc);
retval = idetape_queue_pc_tail(drive, &pc); retval = ide_queue_pc_tail(drive, disk, &pc);
if (retval) if (retval)
return retval; return retval;
idetape_create_read_position_cmd(&pc); idetape_create_read_position_cmd(&pc);
retval = idetape_queue_pc_tail(drive, &pc); retval = ide_queue_pc_tail(drive, disk, &pc);
if (retval) if (retval)
return retval; return retval;
return 0; return 0;
@ -1599,6 +1583,7 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
int mt_count) int mt_count)
{ {
idetape_tape_t *tape = drive->driver_data; idetape_tape_t *tape = drive->driver_data;
struct gendisk *disk = tape->disk;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
int retval, count = 0; int retval, count = 0;
int sprev = !!(tape->caps[4] & 0x20); int sprev = !!(tape->caps[4] & 0x20);
@ -1623,7 +1608,7 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
case MTBSF: case MTBSF:
idetape_create_space_cmd(&pc, mt_count - count, idetape_create_space_cmd(&pc, mt_count - count,
IDETAPE_SPACE_OVER_FILEMARK); IDETAPE_SPACE_OVER_FILEMARK);
return idetape_queue_pc_tail(drive, &pc); return ide_queue_pc_tail(drive, disk, &pc);
case MTFSFM: case MTFSFM:
case MTBSFM: case MTBSFM:
if (!sprev) if (!sprev)
@ -1812,11 +1797,12 @@ static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
static int idetape_write_filemark(ide_drive_t *drive) static int idetape_write_filemark(ide_drive_t *drive)
{ {
struct ide_tape_obj *tape = drive->driver_data;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
/* Write a filemark */ /* Write a filemark */
idetape_create_write_filemark_cmd(drive, &pc, 1); idetape_create_write_filemark_cmd(drive, &pc, 1);
if (idetape_queue_pc_tail(drive, &pc)) { if (ide_queue_pc_tail(drive, tape->disk, &pc)) {
printk(KERN_ERR "ide-tape: Couldn't write a filemark\n"); printk(KERN_ERR "ide-tape: Couldn't write a filemark\n");
return -EIO; return -EIO;
} }
@ -1839,6 +1825,7 @@ static int idetape_write_filemark(ide_drive_t *drive)
static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
{ {
idetape_tape_t *tape = drive->driver_data; idetape_tape_t *tape = drive->driver_data;
struct gendisk *disk = tape->disk;
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
int i, retval; int i, retval;
@ -1877,7 +1864,7 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
ide_tape_discard_merge_buffer(drive, 0); ide_tape_discard_merge_buffer(drive, 0);
idetape_create_load_unload_cmd(drive, &pc, idetape_create_load_unload_cmd(drive, &pc,
IDETAPE_LU_LOAD_MASK); IDETAPE_LU_LOAD_MASK);
return idetape_queue_pc_tail(drive, &pc); return ide_queue_pc_tail(drive, disk, &pc);
case MTUNLOAD: case MTUNLOAD:
case MTOFFL: case MTOFFL:
/* /*
@ -1891,7 +1878,7 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
ide_tape_discard_merge_buffer(drive, 0); ide_tape_discard_merge_buffer(drive, 0);
idetape_create_load_unload_cmd(drive, &pc, idetape_create_load_unload_cmd(drive, &pc,
!IDETAPE_LU_LOAD_MASK); !IDETAPE_LU_LOAD_MASK);
retval = idetape_queue_pc_tail(drive, &pc); retval = ide_queue_pc_tail(drive, disk, &pc);
if (!retval) if (!retval)
clear_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags); clear_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags);
return retval; return retval;
@ -1902,14 +1889,14 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
ide_tape_discard_merge_buffer(drive, 0); ide_tape_discard_merge_buffer(drive, 0);
idetape_create_load_unload_cmd(drive, &pc, idetape_create_load_unload_cmd(drive, &pc,
IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK); IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK);
return idetape_queue_pc_tail(drive, &pc); return ide_queue_pc_tail(drive, disk, &pc);
case MTEOM: case MTEOM:
idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD); idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD);
return idetape_queue_pc_tail(drive, &pc); return ide_queue_pc_tail(drive, disk, &pc);
case MTERASE: case MTERASE:
(void)idetape_rewind_tape(drive); (void)idetape_rewind_tape(drive);
idetape_create_erase_cmd(&pc); idetape_create_erase_cmd(&pc);
return idetape_queue_pc_tail(drive, &pc); return ide_queue_pc_tail(drive, disk, &pc);
case MTSETBLK: case MTSETBLK:
if (mt_count) { if (mt_count) {
if (mt_count < tape->blk_size || if (mt_count < tape->blk_size ||
@ -2018,7 +2005,7 @@ static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive)
struct ide_atapi_pc pc; struct ide_atapi_pc pc;
idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR); idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR);
if (idetape_queue_pc_tail(drive, &pc)) { if (ide_queue_pc_tail(drive, tape->disk, &pc)) {
printk(KERN_ERR "ide-tape: Can't get block descriptor\n"); printk(KERN_ERR "ide-tape: Can't get block descriptor\n");
if (tape->blk_size == 0) { if (tape->blk_size == 0) {
printk(KERN_WARNING "ide-tape: Cannot deal with zero " printk(KERN_WARNING "ide-tape: Cannot deal with zero "
@ -2170,7 +2157,7 @@ static void idetape_get_inquiry_results(ide_drive_t *drive)
char fw_rev[4], vendor_id[8], product_id[16]; char fw_rev[4], vendor_id[8], product_id[16];
idetape_create_inquiry_cmd(&pc); idetape_create_inquiry_cmd(&pc);
if (idetape_queue_pc_tail(drive, &pc)) { if (ide_queue_pc_tail(drive, tape->disk, &pc)) {
printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n", printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n",
tape->name); tape->name);
return; return;
@ -2199,7 +2186,7 @@ static void idetape_get_mode_sense_results(ide_drive_t *drive)
u8 speed, max_speed; u8 speed, max_speed;
idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE); idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE);
if (idetape_queue_pc_tail(drive, &pc)) { if (ide_queue_pc_tail(drive, tape->disk, &pc)) {
printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming" printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming"
" some default values\n"); " some default values\n");
tape->blk_size = 512; tape->blk_size = 512;

1
include/linux/ide.h
View File

@ -1136,6 +1136,7 @@ enum {
void ide_queue_pc_head(ide_drive_t *, struct gendisk *, struct ide_atapi_pc *, void ide_queue_pc_head(ide_drive_t *, struct gendisk *, struct ide_atapi_pc *,
struct request *); struct request *);
int ide_queue_pc_tail(ide_drive_t *, struct gendisk *, struct ide_atapi_pc *);
ide_startstop_t ide_pc_intr(ide_drive_t *drive, struct ide_atapi_pc *pc, ide_startstop_t ide_pc_intr(ide_drive_t *drive, struct ide_atapi_pc *pc,
ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry, ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry,