ide-cd: convert ide_cd_queue_pc to use blk_execute_rq
authorFUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Tue, 15 Jul 2008 19:21:42 +0000 (21:21 +0200)
committerBartlomiej Zolnierkiewicz <bzolnier@gmail.com>
Tue, 15 Jul 2008 19:21:42 +0000 (21:21 +0200)
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>
drivers/ide/ide-cd.c
drivers/ide/ide-cd.h
drivers/ide/ide-cd_ioctl.c

index ff8815937d32862f4b60a88d6a7459cbc0559667..792a3cf73d6ead20e86ef795d8d279c5a45a06d8 100644 (file)
@@ -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);
@@ -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;
 }
 
 /*
@@ -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,
@@ -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 =
@@ -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. */
index a58801c4484d309177afe8b7d32aa77c7ac7f91f..df01cfd797cf2dcb4376a963e9276c58dd39a065 100644 (file)
@@ -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 *);
index 6d147ce6782f17b8d8f1b2667891bc6dd3ff8076..851277074302ed258a688ceee7369fe384e90d54 100644 (file)
@@ -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;
@@ -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. */
@@ -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)
@@ -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
@@ -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);
@@ -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;
 
@@ -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)
@@ -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)
@@ -447,8 +444,9 @@ 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;
@@ -456,24 +454,21 @@ int ide_cdrom_packet(struct cdrom_device_info *cdi,
        /* 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;
 }