Skip to content

Commit

Permalink
ide-cd: convert ide_cd_queue_pc to use blk_execute_rq
Browse files Browse the repository at this point in the history 
This converts ide_cd_queue_pc to use blk_execute_rq, necessitating
changing the ide_cd_queue_pc prototype into a form that doesn't takes
a pointer to request struct. ide_cd_queue_pc works like scsi_execute.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Cc: Borislav Petkov <petkovbb@gmail.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
  • Loading branch information
FUJITA Tomonori authored and Bartlomiej Zolnierkiewicz committed Jul 15, 2008
1 parent c6866a6 commit 5f82854
Show file tree
Hide file tree
Showing 3 changed files with 103 additions and 97 deletions.
96 changes: 53 additions & 43 deletions drivers/ide/ide-cd.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -839,34 +839,54 @@ static void ide_cd_request_sense_fixup(struct request *rq)
}
}

int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
int write, void *buffer, unsigned *bufflen,
struct request_sense *sense, int timeout,
unsigned int cmd_flags)
{
struct request_sense sense;
struct cdrom_info *info = drive->driver_data;
struct request_sense local_sense;
int retries = 10;
unsigned int flags = rq->cmd_flags;
unsigned int flags = 0;

if (rq->sense == NULL)
rq->sense = &sense;
if (!sense)
sense = &local_sense;

/* start of retry loop */
do {
struct request *rq;
int error;
unsigned long time = jiffies;
rq->cmd_flags = flags;

error = ide_do_drive_cmd(drive, rq, ide_wait);
time = jiffies - time;
rq = blk_get_request(drive->queue, write, __GFP_WAIT);

memcpy(rq->cmd, cmd, BLK_MAX_CDB);
rq->cmd_type = REQ_TYPE_ATA_PC;
rq->sense = sense;
rq->cmd_flags |= cmd_flags;
rq->timeout = timeout;
if (buffer) {
rq->data = buffer;
rq->data_len = *bufflen;
}

error = blk_execute_rq(drive->queue, info->disk, rq, 0);

if (buffer)
*bufflen = rq->data_len;

flags = rq->cmd_flags;
blk_put_request(rq);

/*
* FIXME: we should probably abort/retry or something in case of
* failure.
*/
if (rq->cmd_flags & REQ_FAILED) {
if (flags & REQ_FAILED) {
/*
* The request failed. Retry if it was due to a unit
* attention status (usually means media was changed).
*/
struct request_sense *reqbuf = rq->sense;
struct request_sense *reqbuf = sense;

if (reqbuf->sense_key == UNIT_ATTENTION)
cdrom_saw_media_change(drive);
Expand All @@ -886,10 +906,10 @@ int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
}

/* end of retry loop */
} while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
} while ((flags & REQ_FAILED) && retries >= 0);

/* return an error if the command failed */
return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
return (flags & REQ_FAILED) ? -EIO : 0;
}

/*
Expand Down Expand Up @@ -1269,23 +1289,20 @@ static void msf_from_bcd(struct atapi_msf *msf)

int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
{
struct request req;
struct cdrom_info *info = drive->driver_data;
struct cdrom_device_info *cdi = &info->devinfo;
unsigned char cmd[BLK_MAX_CDB];

ide_cd_init_rq(drive, &req);

req.sense = sense;
req.cmd[0] = GPCMD_TEST_UNIT_READY;
req.cmd_flags |= REQ_QUIET;
memset(cmd, 0, BLK_MAX_CDB);
cmd[0] = GPCMD_TEST_UNIT_READY;

/*
* Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to switch CDs
* instead of supporting the LOAD_UNLOAD opcode.
*/
req.cmd[7] = cdi->sanyo_slot % 3;
cmd[7] = cdi->sanyo_slot % 3;

return ide_cd_queue_pc(drive, &req);
return ide_cd_queue_pc(drive, cmd, 0, NULL, 0, sense, 0, REQ_QUIET);
}

static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
Expand All @@ -1298,17 +1315,14 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
} capbuf;

int stat;
struct request req;

ide_cd_init_rq(drive, &req);
unsigned char cmd[BLK_MAX_CDB];
unsigned len = sizeof(capbuf);

req.sense = sense;
req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
req.data = (char *)&capbuf;
req.data_len = sizeof(capbuf);
req.cmd_flags |= REQ_QUIET;
memset(cmd, 0, BLK_MAX_CDB);
cmd[0] = GPCMD_READ_CDVD_CAPACITY;

stat = ide_cd_queue_pc(drive, &req);
stat = ide_cd_queue_pc(drive, cmd, 0, &capbuf, &len, sense, 0,
REQ_QUIET);
if (stat == 0) {
*capacity = 1 + be32_to_cpu(capbuf.lba);
*sectors_per_frame =
Expand All @@ -1322,24 +1336,20 @@ static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
int format, char *buf, int buflen,
struct request_sense *sense)
{
struct request req;
unsigned char cmd[BLK_MAX_CDB];

ide_cd_init_rq(drive, &req);
memset(cmd, 0, BLK_MAX_CDB);

req.sense = sense;
req.data = buf;
req.data_len = buflen;
req.cmd_flags |= REQ_QUIET;
req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
req.cmd[6] = trackno;
req.cmd[7] = (buflen >> 8);
req.cmd[8] = (buflen & 0xff);
req.cmd[9] = (format << 6);
cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
cmd[6] = trackno;
cmd[7] = (buflen >> 8);
cmd[8] = (buflen & 0xff);
cmd[9] = (format << 6);

if (msf_flag)
req.cmd[1] = 2;
cmd[1] = 2;

return ide_cd_queue_pc(drive, &req);
return ide_cd_queue_pc(drive, cmd, 0, buf, &buflen, sense, 0, REQ_QUIET);
}

/* Try to read the entire TOC for the disk into our internal buffer. */
Expand Down
3 changes: 2 additions & 1 deletion drivers/ide/ide-cd.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -144,7 +144,8 @@ void ide_cd_log_error(const char *, struct request *, struct request_sense *);

/* ide-cd.c functions used by ide-cd_ioctl.c */
void ide_cd_init_rq(ide_drive_t *, struct request *);
int ide_cd_queue_pc(ide_drive_t *, struct request *);
int ide_cd_queue_pc(ide_drive_t *, const unsigned char *, int, void *,
unsigned *, struct request_sense *, int, unsigned int);
int ide_cd_read_toc(ide_drive_t *, struct request_sense *);
int ide_cdrom_get_capabilities(ide_drive_t *, u8 *);
void ide_cdrom_update_speed(ide_drive_t *, u8 *);
Expand Down
101 changes: 48 additions & 53 deletions drivers/ide/ide-cd_ioctl.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -104,8 +104,8 @@ int cdrom_eject(ide_drive_t *drive, int ejectflag,
{
struct cdrom_info *cd = drive->driver_data;
struct cdrom_device_info *cdi = &cd->devinfo;
struct request req;
char loej = 0x02;
unsigned char cmd[BLK_MAX_CDB];

if ((cd->cd_flags & IDE_CD_FLAG_NO_EJECT) && !ejectflag)
return -EDRIVE_CANT_DO_THIS;
Expand All @@ -114,17 +114,16 @@ int cdrom_eject(ide_drive_t *drive, int ejectflag,
if ((cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED) && ejectflag)
return 0;

ide_cd_init_rq(drive, &req);

/* only tell drive to close tray if open, if it can do that */
if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
loej = 0;

req.sense = sense;
req.cmd[0] = GPCMD_START_STOP_UNIT;
req.cmd[4] = loej | (ejectflag != 0);
memset(cmd, 0, BLK_MAX_CDB);

cmd[0] = GPCMD_START_STOP_UNIT;
cmd[4] = loej | (ejectflag != 0);

return ide_cd_queue_pc(drive, &req);
return ide_cd_queue_pc(drive, cmd, 0, NULL, 0, sense, 0, 0);
}

/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
Expand All @@ -134,7 +133,6 @@ int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
{
struct cdrom_info *cd = drive->driver_data;
struct request_sense my_sense;
struct request req;
int stat;

if (sense == NULL)
Expand All @@ -144,11 +142,15 @@ int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
if (cd->cd_flags & IDE_CD_FLAG_NO_DOORLOCK) {
stat = 0;
} else {
ide_cd_init_rq(drive, &req);
req.sense = sense;
req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
req.cmd[4] = lockflag ? 1 : 0;
stat = ide_cd_queue_pc(drive, &req);
unsigned char cmd[BLK_MAX_CDB];

memset(cmd, 0, BLK_MAX_CDB);

cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
cmd[4] = lockflag ? 1 : 0;

stat = ide_cd_queue_pc(drive, cmd, 0, NULL, 0,
sense, 0, 0);
}

/* If we got an illegal field error, the drive
Expand Down Expand Up @@ -206,32 +208,30 @@ int ide_cdrom_select_speed(struct cdrom_device_info *cdi, int speed)
{
ide_drive_t *drive = cdi->handle;
struct cdrom_info *cd = drive->driver_data;
struct request rq;
struct request_sense sense;
u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
int stat;

ide_cd_init_rq(drive, &rq);

rq.sense = &sense;
unsigned char cmd[BLK_MAX_CDB];

if (speed == 0)
speed = 0xffff; /* set to max */
else
speed *= 177; /* Nx to kbytes/s */

rq.cmd[0] = GPCMD_SET_SPEED;
memset(cmd, 0, BLK_MAX_CDB);

cmd[0] = GPCMD_SET_SPEED;
/* Read Drive speed in kbytes/second MSB/LSB */
rq.cmd[2] = (speed >> 8) & 0xff;
rq.cmd[3] = speed & 0xff;
cmd[2] = (speed >> 8) & 0xff;
cmd[3] = speed & 0xff;
if ((cdi->mask & (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) !=
(CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) {
/* Write Drive speed in kbytes/second MSB/LSB */
rq.cmd[4] = (speed >> 8) & 0xff;
rq.cmd[5] = speed & 0xff;
cmd[4] = (speed >> 8) & 0xff;
cmd[5] = speed & 0xff;
}

stat = ide_cd_queue_pc(drive, &rq);
stat = ide_cd_queue_pc(drive, cmd, 0, NULL, 0, &sense, 0, 0);

if (!ide_cdrom_get_capabilities(drive, buf)) {
ide_cdrom_update_speed(drive, buf);
Expand Down Expand Up @@ -268,21 +268,19 @@ int ide_cdrom_get_mcn(struct cdrom_device_info *cdi,
{
ide_drive_t *drive = cdi->handle;
int stat, mcnlen;
struct request rq;
char buf[24];
unsigned char cmd[BLK_MAX_CDB];
unsigned len = sizeof(buf);

ide_cd_init_rq(drive, &rq);
memset(cmd, 0, BLK_MAX_CDB);

rq.data = buf;
rq.data_len = sizeof(buf);
cmd[0] = GPCMD_READ_SUBCHANNEL;
cmd[1] = 2; /* MSF addressing */
cmd[2] = 0x40; /* request subQ data */
cmd[3] = 2; /* format */
cmd[8] = len;

rq.cmd[0] = GPCMD_READ_SUBCHANNEL;
rq.cmd[1] = 2; /* MSF addressing */
rq.cmd[2] = 0x40; /* request subQ data */
rq.cmd[3] = 2; /* format */
rq.cmd[8] = sizeof(buf);

stat = ide_cd_queue_pc(drive, &rq);
stat = ide_cd_queue_pc(drive, cmd, 0, buf, &len, NULL, 0, 0);
if (stat)
return stat;

Expand Down Expand Up @@ -351,8 +349,8 @@ static int ide_cd_fake_play_trkind(ide_drive_t *drive, void *arg)
struct atapi_toc_entry *first_toc, *last_toc;
unsigned long lba_start, lba_end;
int stat;
struct request rq;
struct request_sense sense;
unsigned char cmd[BLK_MAX_CDB];

stat = ide_cd_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
if (stat)
Expand All @@ -370,14 +368,13 @@ static int ide_cd_fake_play_trkind(ide_drive_t *drive, void *arg)
if (lba_end <= lba_start)
return -EINVAL;

ide_cd_init_rq(drive, &rq);
memset(cmd, 0, BLK_MAX_CDB);

rq.sense = &sense;
rq.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
lba_to_msf(lba_start, &rq.cmd[3], &rq.cmd[4], &rq.cmd[5]);
lba_to_msf(lba_end - 1, &rq.cmd[6], &rq.cmd[7], &rq.cmd[8]);
cmd[0] = GPCMD_PLAY_AUDIO_MSF;
lba_to_msf(lba_start, &cmd[3], &cmd[4], &cmd[5]);
lba_to_msf(lba_end - 1, &cmd[6], &cmd[7], &cmd[8]);

return ide_cd_queue_pc(drive, &rq);
return ide_cd_queue_pc(drive, cmd, 0, NULL, 0, &sense, 0, 0);
}

static int ide_cd_read_tochdr(ide_drive_t *drive, void *arg)
Expand Down Expand Up @@ -447,33 +444,31 @@ int ide_cdrom_audio_ioctl(struct cdrom_device_info *cdi,
int ide_cdrom_packet(struct cdrom_device_info *cdi,
struct packet_command *cgc)
{
struct request req;
ide_drive_t *drive = cdi->handle;
unsigned int flags = 0;
unsigned len = cgc->buflen;

if (cgc->timeout <= 0)
cgc->timeout = ATAPI_WAIT_PC;

/* here we queue the commands from the uniform CD-ROM
layer. the packet must be complete, as we do not
touch it at all. */
ide_cd_init_rq(drive, &req);

if (cgc->data_direction == CGC_DATA_WRITE)
req.cmd_flags |= REQ_RW;
flags |= REQ_RW;

memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
if (cgc->sense)
memset(cgc->sense, 0, sizeof(struct request_sense));
req.data = cgc->buffer;
req.data_len = cgc->buflen;
req.timeout = cgc->timeout;

if (cgc->quiet)
req.cmd_flags |= REQ_QUIET;
flags |= REQ_QUIET;

req.sense = cgc->sense;
cgc->stat = ide_cd_queue_pc(drive, &req);
cgc->stat = ide_cd_queue_pc(drive, cgc->cmd,
cgc->data_direction == CGC_DATA_WRITE,
cgc->buffer, &len,
cgc->sense, cgc->timeout, flags);
if (!cgc->stat)
cgc->buflen -= req.data_len;
cgc->buflen -= len;
return cgc->stat;
}

0 comments on commit 5f82854

Please sign in to comment.