Pileus Git - ~andy/linux/blob - drivers/ide/ide-cd.c

   1 /*
   2  * linux/drivers/ide/ide-cd.c
   3  *
   4  * Copyright (C) 1994, 1995, 1996  scott snyder  <snyder@fnald0.fnal.gov>
   5  * Copyright (C) 1996-1998  Erik Andersen <andersee@debian.org>
   6  * Copyright (C) 1998-2000  Jens Axboe <axboe@suse.de>
   7  *
   8  * May be copied or modified under the terms of the GNU General Public
   9  * License.  See linux/COPYING for more information.
  10  *
  11  * ATAPI CD-ROM driver.  To be used with ide.c.
  12  * See Documentation/cdrom/ide-cd for usage information.
  13  *
  14  * Suggestions are welcome. Patches that work are more welcome though. ;-)
  15  * For those wishing to work on this driver, please be sure you download
  16  * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
  17  * (SFF-8020i rev 2.6) standards. These documents can be obtained by
  18  * anonymous ftp from:
  19  * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
  20  * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
  21  *
  22  * Drives that deviate from these standards will be accommodated as much
  23  * as possible via compile time or command-line options.  Since I only have
  24  * a few drives, you generally need to send me patches...
  25  *
  26  * ----------------------------------
  27  * TO DO LIST:
  28  * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
  29  *   boot
  30  *
  31  * For historical changelog please see:
  32  *      Documentation/ide/ChangeLog.ide-cd.1994-2004
  33  */
  34
  35 #define IDECD_VERSION "4.61"
  36
  37 #include <linux/module.h>
  38 #include <linux/types.h>
  39 #include <linux/kernel.h>
  40 #include <linux/delay.h>
  41 #include <linux/timer.h>
  42 #include <linux/slab.h>
  43 #include <linux/interrupt.h>
  44 #include <linux/errno.h>
  45 #include <linux/cdrom.h>
  46 #include <linux/ide.h>
  47 #include <linux/completion.h>
  48 #include <linux/mutex.h>
  49 #include <linux/bcd.h>
  50
  51 #include <scsi/scsi.h>  /* For SCSI -> ATAPI command conversion */
  52
  53 #include <asm/irq.h>
  54 #include <asm/io.h>
  55 #include <asm/byteorder.h>
  56 #include <asm/uaccess.h>
  57 #include <asm/unaligned.h>
  58
  59 #include "ide-cd.h"
  60
  61 static DEFINE_MUTEX(idecd_ref_mutex);
  62
  63 #define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
  64
  65 #define ide_cd_g(disk) \
  66         container_of((disk)->private_data, struct cdrom_info, driver)
  67
  68 static struct cdrom_info *ide_cd_get(struct gendisk *disk)
  69 {
  70         struct cdrom_info *cd = NULL;
  71
  72         mutex_lock(&idecd_ref_mutex);
  73         cd = ide_cd_g(disk);
  74         if (cd)
  75                 kref_get(&cd->kref);
  76         mutex_unlock(&idecd_ref_mutex);
  77         return cd;
  78 }
  79
  80 static void ide_cd_release(struct kref *);
  81
  82 static void ide_cd_put(struct cdrom_info *cd)
  83 {
  84         mutex_lock(&idecd_ref_mutex);
  85         kref_put(&cd->kref, ide_cd_release);
  86         mutex_unlock(&idecd_ref_mutex);
  87 }
  88
  89 /****************************************************************************
  90  * Generic packet command support and error handling routines.
  91  */
  92
  93 /* Mark that we've seen a media change, and invalidate our internal
  94    buffers. */
  95 static void cdrom_saw_media_change (ide_drive_t *drive)
  96 {
  97         struct cdrom_info *cd = drive->driver_data;
  98
  99         cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
 100         cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
 101         cd->nsectors_buffered = 0;
 102 }
 103
 104 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
 105                            struct request_sense *sense)
 106 {
 107         int log = 0;
 108
 109         if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
 110                 return 0;
 111
 112         switch (sense->sense_key) {
 113                 case NO_SENSE: case RECOVERED_ERROR:
 114                         break;
 115                 case NOT_READY:
 116                         /*
 117                          * don't care about tray state messages for
 118                          * e.g. capacity commands or in-progress or
 119                          * becoming ready
 120                          */
 121                         if (sense->asc == 0x3a || sense->asc == 0x04)
 122                                 break;
 123                         log = 1;
 124                         break;
 125                 case ILLEGAL_REQUEST:
 126                         /*
 127                          * don't log START_STOP unit with LoEj set, since
 128                          * we cannot reliably check if drive can auto-close
 129                          */
 130                         if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
 131                                 break;
 132                         log = 1;
 133                         break;
 134                 case UNIT_ATTENTION:
 135                         /*
 136                          * Make good and sure we've seen this potential media
 137                          * change. Some drives (i.e. Creative) fail to present
 138                          * the correct sense key in the error register.
 139                          */
 140                         cdrom_saw_media_change(drive);
 141                         break;
 142                 default:
 143                         log = 1;
 144                         break;
 145         }
 146         return log;
 147 }
 148
 149 static
 150 void cdrom_analyze_sense_data(ide_drive_t *drive,
 151                               struct request *failed_command,
 152                               struct request_sense *sense)
 153 {
 154         unsigned long sector;
 155         unsigned long bio_sectors;
 156         unsigned long valid;
 157         struct cdrom_info *info = drive->driver_data;
 158
 159         if (!cdrom_log_sense(drive, failed_command, sense))
 160                 return;
 161
 162         /*
 163          * If a read toc is executed for a CD-R or CD-RW medium where
 164          * the first toc has not been recorded yet, it will fail with
 165          * 05/24/00 (which is a confusing error)
 166          */
 167         if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
 168                 if (sense->sense_key == 0x05 && sense->asc == 0x24)
 169                         return;
 170
 171         if (sense->error_code == 0x70) {        /* Current Error */
 172                 switch(sense->sense_key) {
 173                 case MEDIUM_ERROR:
 174                 case VOLUME_OVERFLOW:
 175                 case ILLEGAL_REQUEST:
 176                         if (!sense->valid)
 177                                 break;
 178                         if (failed_command == NULL ||
 179                                         !blk_fs_request(failed_command))
 180                                 break;
 181                         sector = (sense->information[0] << 24) |
 182                                  (sense->information[1] << 16) |
 183                                  (sense->information[2] <<  8) |
 184                                  (sense->information[3]);
 185
 186                         bio_sectors = bio_sectors(failed_command->bio);
 187                         if (bio_sectors < 4)
 188                                 bio_sectors = 4;
 189                         if (drive->queue->hardsect_size == 2048)
 190                                 sector <<= 2;   /* Device sector size is 2K */
 191                         sector &= ~(bio_sectors -1);
 192                         valid = (sector - failed_command->sector) << 9;
 193
 194                         if (valid < 0)
 195                                 valid = 0;
 196                         if (sector < get_capacity(info->disk) &&
 197                                 drive->probed_capacity - sector < 4 * 75) {
 198                                 set_capacity(info->disk, sector);
 199                         }
 200                 }
 201         }
 202
 203         ide_cd_log_error(drive->name, failed_command, sense);
 204 }
 205
 206 /*
 207  * Initialize a ide-cd packet command request
 208  */
 209 void ide_cd_init_rq(ide_drive_t *drive, struct request *rq)
 210 {
 211         struct cdrom_info *cd = drive->driver_data;
 212
 213         ide_init_drive_cmd(rq);
 214         rq->cmd_type = REQ_TYPE_ATA_PC;
 215         rq->rq_disk = cd->disk;
 216 }
 217
 218 static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
 219                                       struct request *failed_command)
 220 {
 221         struct cdrom_info *info         = drive->driver_data;
 222         struct request *rq              = &info->request_sense_request;
 223
 224         if (sense == NULL)
 225                 sense = &info->sense_data;
 226
 227         /* stuff the sense request in front of our current request */
 228         ide_cd_init_rq(drive, rq);
 229
 230         rq->data = sense;
 231         rq->cmd[0] = GPCMD_REQUEST_SENSE;
 232         rq->cmd[4] = rq->data_len = 18;
 233
 234         rq->cmd_type = REQ_TYPE_SENSE;
 235
 236         /* NOTE! Save the failed command in "rq->buffer" */
 237         rq->buffer = (void *) failed_command;
 238
 239         (void) ide_do_drive_cmd(drive, rq, ide_preempt);
 240 }
 241
 242 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
 243 {
 244         struct request *rq = HWGROUP(drive)->rq;
 245         int nsectors = rq->hard_cur_sectors;
 246
 247         if (blk_sense_request(rq) && uptodate) {
 248                 /*
 249                  * For REQ_TYPE_SENSE, "rq->buffer" points to the original
 250                  * failed request
 251                  */
 252                 struct request *failed = (struct request *) rq->buffer;
 253                 struct cdrom_info *info = drive->driver_data;
 254                 void *sense = &info->sense_data;
 255                 unsigned long flags;
 256
 257                 if (failed) {
 258                         if (failed->sense) {
 259                                 sense = failed->sense;
 260                                 failed->sense_len = rq->sense_len;
 261                         }
 262                         cdrom_analyze_sense_data(drive, failed, sense);
 263                         /*
 264                          * now end failed request
 265                          */
 266                         if (blk_fs_request(failed)) {
 267                                 if (ide_end_dequeued_request(drive, failed, 0,
 268                                                 failed->hard_nr_sectors))
 269                                         BUG();
 270                         } else {
 271                                 spin_lock_irqsave(&ide_lock, flags);
 272                                 if (__blk_end_request(failed, -EIO,
 273                                                       failed->data_len))
 274                                         BUG();
 275                                 spin_unlock_irqrestore(&ide_lock, flags);
 276                         }
 277                 } else
 278                         cdrom_analyze_sense_data(drive, NULL, sense);
 279         }
 280
 281         if (!rq->current_nr_sectors && blk_fs_request(rq))
 282                 uptodate = 1;
 283         /* make sure it's fully ended */
 284         if (blk_pc_request(rq))
 285                 nsectors = (rq->data_len + 511) >> 9;
 286         if (!nsectors)
 287                 nsectors = 1;
 288
 289         ide_end_request(drive, uptodate, nsectors);
 290 }
 291
 292 static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
 293 {
 294         if (stat & 0x80)
 295                 return;
 296         ide_dump_status(drive, msg, stat);
 297 }
 298
 299 /* Returns 0 if the request should be continued.
 300    Returns 1 if the request was ended. */
 301 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
 302 {
 303         struct request *rq = HWGROUP(drive)->rq;
 304         int stat, err, sense_key;
 305
 306         /* Check for errors. */
 307         stat = HWIF(drive)->INB(IDE_STATUS_REG);
 308         if (stat_ret)
 309                 *stat_ret = stat;
 310
 311         if (OK_STAT(stat, good_stat, BAD_R_STAT))
 312                 return 0;
 313
 314         /* Get the IDE error register. */
 315         err = HWIF(drive)->INB(IDE_ERROR_REG);
 316         sense_key = err >> 4;
 317
 318         if (rq == NULL) {
 319                 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
 320                 return 1;
 321         }
 322
 323         if (blk_sense_request(rq)) {
 324                 /* We got an error trying to get sense info
 325                    from the drive (probably while trying
 326                    to recover from a former error).  Just give up. */
 327
 328                 rq->cmd_flags |= REQ_FAILED;
 329                 cdrom_end_request(drive, 0);
 330                 ide_error(drive, "request sense failure", stat);
 331                 return 1;
 332
 333         } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
 334                 /* All other functions, except for READ. */
 335                 unsigned long flags;
 336
 337                 /*
 338                  * if we have an error, pass back CHECK_CONDITION as the
 339                  * scsi status byte
 340                  */
 341                 if (blk_pc_request(rq) && !rq->errors)
 342                         rq->errors = SAM_STAT_CHECK_CONDITION;
 343
 344                 /* Check for tray open. */
 345                 if (sense_key == NOT_READY) {
 346                         cdrom_saw_media_change (drive);
 347                 } else if (sense_key == UNIT_ATTENTION) {
 348                         /* Check for media change. */
 349                         cdrom_saw_media_change (drive);
 350                         /*printk("%s: media changed\n",drive->name);*/
 351                         return 0;
 352                 } else if ((sense_key == ILLEGAL_REQUEST) &&
 353                            (rq->cmd[0] == GPCMD_START_STOP_UNIT)) {
 354                         /*
 355                          * Don't print error message for this condition--
 356                          * SFF8090i indicates that 5/24/00 is the correct
 357                          * response to a request to close the tray if the
 358                          * drive doesn't have that capability.
 359                          * cdrom_log_sense() knows this!
 360                          */
 361                 } else if (!(rq->cmd_flags & REQ_QUIET)) {
 362                         /* Otherwise, print an error. */
 363                         ide_dump_status(drive, "packet command error", stat);
 364                 }
 365
 366                 rq->cmd_flags |= REQ_FAILED;
 367
 368                 /*
 369                  * instead of playing games with moving completions around,
 370                  * remove failed request completely and end it when the
 371                  * request sense has completed
 372                  */
 373                 if (stat & ERR_STAT) {
 374                         spin_lock_irqsave(&ide_lock, flags);
 375                         blkdev_dequeue_request(rq);
 376                         HWGROUP(drive)->rq = NULL;
 377                         spin_unlock_irqrestore(&ide_lock, flags);
 378
 379                         cdrom_queue_request_sense(drive, rq->sense, rq);
 380                 } else
 381                         cdrom_end_request(drive, 0);
 382
 383         } else if (blk_fs_request(rq)) {
 384                 int do_end_request = 0;
 385
 386                 /* Handle errors from READ and WRITE requests. */
 387
 388                 if (blk_noretry_request(rq))
 389                         do_end_request = 1;
 390
 391                 if (sense_key == NOT_READY) {
 392                         /* Tray open. */
 393                         if (rq_data_dir(rq) == READ) {
 394                                 cdrom_saw_media_change (drive);
 395
 396                                 /* Fail the request. */
 397                                 printk ("%s: tray open\n", drive->name);
 398                                 do_end_request = 1;
 399                         } else {
 400                                 struct cdrom_info *info = drive->driver_data;
 401
 402                                 /* allow the drive 5 seconds to recover, some
 403                                  * devices will return this error while flushing
 404                                  * data from cache */
 405                                 if (!rq->errors)
 406                                         info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
 407                                 rq->errors = 1;
 408                                 if (time_after(jiffies, info->write_timeout))
 409                                         do_end_request = 1;
 410                                 else {
 411                                         unsigned long flags;
 412
 413                                         /*
 414                                          * take a breather relying on the
 415                                          * unplug timer to kick us again
 416                                          */
 417                                         spin_lock_irqsave(&ide_lock, flags);
 418                                         blk_plug_device(drive->queue);
 419                                         spin_unlock_irqrestore(&ide_lock,flags);
 420                                         return 1;
 421                                 }
 422                         }
 423                 } else if (sense_key == UNIT_ATTENTION) {
 424                         /* Media change. */
 425                         cdrom_saw_media_change (drive);
 426
 427                         /* Arrange to retry the request.
 428                            But be sure to give up if we've retried
 429                            too many times. */
 430                         if (++rq->errors > ERROR_MAX)
 431                                 do_end_request = 1;
 432                 } else if (sense_key == ILLEGAL_REQUEST ||
 433                            sense_key == DATA_PROTECT) {
 434                         /* No point in retrying after an illegal
 435                            request or data protect error.*/
 436                         ide_dump_status_no_sense (drive, "command error", stat);
 437                         do_end_request = 1;
 438                 } else if (sense_key == MEDIUM_ERROR) {
 439                         /* No point in re-trying a zillion times on a bad
 440                          * sector...  If we got here the error is not correctable */
 441                         ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
 442                         do_end_request = 1;
 443                 } else if (sense_key == BLANK_CHECK) {
 444                         /* Disk appears blank ?? */
 445                         ide_dump_status_no_sense (drive, "media error (blank)", stat);
 446                         do_end_request = 1;
 447                 } else if ((err & ~ABRT_ERR) != 0) {
 448                         /* Go to the default handler
 449                            for other errors. */
 450                         ide_error(drive, "cdrom_decode_status", stat);
 451                         return 1;
 452                 } else if ((++rq->errors > ERROR_MAX)) {
 453                         /* We've racked up too many retries.  Abort. */
 454                         do_end_request = 1;
 455                 }
 456
 457                 /* End a request through request sense analysis when we have
 458                    sense data. We need this in order to perform end of media
 459                    processing */
 460
 461                 if (do_end_request) {
 462                         if (stat & ERR_STAT) {
 463                                 unsigned long flags;
 464                                 spin_lock_irqsave(&ide_lock, flags);
 465                                 blkdev_dequeue_request(rq);
 466                                 HWGROUP(drive)->rq = NULL;
 467                                 spin_unlock_irqrestore(&ide_lock, flags);
 468
 469                                 cdrom_queue_request_sense(drive, rq->sense, rq);
 470                         } else
 471                                 cdrom_end_request(drive, 0);
 472                 } else {
 473                         /* If we got a CHECK_CONDITION status,
 474                            queue a request sense command. */
 475                         if (stat & ERR_STAT)
 476                                 cdrom_queue_request_sense(drive, NULL, NULL);
 477                 }
 478         } else {
 479                 blk_dump_rq_flags(rq, "ide-cd: bad rq");
 480                 cdrom_end_request(drive, 0);
 481         }
 482
 483         /* Retry, or handle the next request. */
 484         return 1;
 485 }
 486
 487 static int cdrom_timer_expiry(ide_drive_t *drive)
 488 {
 489         struct request *rq = HWGROUP(drive)->rq;
 490         unsigned long wait = 0;
 491
 492         /*
 493          * Some commands are *slow* and normally take a long time to
 494          * complete. Usually we can use the ATAPI "disconnect" to bypass
 495          * this, but not all commands/drives support that. Let
 496          * ide_timer_expiry keep polling us for these.
 497          */
 498         switch (rq->cmd[0]) {
 499                 case GPCMD_BLANK:
 500                 case GPCMD_FORMAT_UNIT:
 501                 case GPCMD_RESERVE_RZONE_TRACK:
 502                 case GPCMD_CLOSE_TRACK:
 503                 case GPCMD_FLUSH_CACHE:
 504                         wait = ATAPI_WAIT_PC;
 505                         break;
 506                 default:
 507                         if (!(rq->cmd_flags & REQ_QUIET))
 508                                 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
 509                         wait = 0;
 510                         break;
 511         }
 512         return wait;
 513 }
 514
 515 /* Set up the device registers for transferring a packet command on DEV,
 516    expecting to later transfer XFERLEN bytes.  HANDLER is the routine
 517    which actually transfers the command to the drive.  If this is a
 518    drq_interrupt device, this routine will arrange for HANDLER to be
 519    called when the interrupt from the drive arrives.  Otherwise, HANDLER
 520    will be called immediately after the drive is prepared for the transfer. */
 521
 522 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
 523                                                   int xferlen,
 524                                                   ide_handler_t *handler)
 525 {
 526         ide_startstop_t startstop;
 527         struct cdrom_info *info = drive->driver_data;
 528         ide_hwif_t *hwif = drive->hwif;
 529
 530         /* Wait for the controller to be idle. */
 531         if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
 532                 return startstop;
 533
 534         /* FIXME: for Virtual DMA we must check harder */
 535         if (info->dma)
 536                 info->dma = !hwif->dma_setup(drive);
 537
 538         /* Set up the controller registers. */
 539         ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
 540                            IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
 541
 542         if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
 543                 /* waiting for CDB interrupt, not DMA yet. */
 544                 if (info->dma)
 545                         drive->waiting_for_dma = 0;
 546
 547                 /* packet command */
 548                 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
 549                 return ide_started;
 550         } else {
 551                 unsigned long flags;
 552
 553                 /* packet command */
 554                 spin_lock_irqsave(&ide_lock, flags);
 555                 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
 556                 ndelay(400);
 557                 spin_unlock_irqrestore(&ide_lock, flags);
 558
 559                 return (*handler) (drive);
 560         }
 561 }
 562
 563 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
 564    The device registers must have already been prepared
 565    by cdrom_start_packet_command.
 566    HANDLER is the interrupt handler to call when the command completes
 567    or there's data ready. */
 568 #define ATAPI_MIN_CDB_BYTES 12
 569 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
 570                                           struct request *rq,
 571                                           ide_handler_t *handler)
 572 {
 573         ide_hwif_t *hwif = drive->hwif;
 574         int cmd_len;
 575         struct cdrom_info *info = drive->driver_data;
 576         ide_startstop_t startstop;
 577
 578         if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
 579                 /* Here we should have been called after receiving an interrupt
 580                    from the device.  DRQ should how be set. */
 581
 582                 /* Check for errors. */
 583                 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
 584                         return ide_stopped;
 585
 586                 /* Ok, next interrupt will be DMA interrupt. */
 587                 if (info->dma)
 588                         drive->waiting_for_dma = 1;
 589         } else {
 590                 /* Otherwise, we must wait for DRQ to get set. */
 591                 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
 592                                 BUSY_STAT, WAIT_READY))
 593                         return startstop;
 594         }
 595
 596         /* Arm the interrupt handler. */
 597         ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
 598
 599         /* ATAPI commands get padded out to 12 bytes minimum */
 600         cmd_len = COMMAND_SIZE(rq->cmd[0]);
 601         if (cmd_len < ATAPI_MIN_CDB_BYTES)
 602                 cmd_len = ATAPI_MIN_CDB_BYTES;
 603
 604         /* Send the command to the device. */
 605         HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
 606
 607         /* Start the DMA if need be */
 608         if (info->dma)
 609                 hwif->dma_start(drive);
 610
 611         return ide_started;
 612 }
 613
 614 /****************************************************************************
 615  * Block read functions.
 616  */
 617
 618 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
 619
 620 static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
 621 {
 622         while (len > 0) {
 623                 int dum = 0;
 624                 xf(drive, &dum, sizeof(dum));
 625                 len -= sizeof(dum);
 626         }
 627 }
 628
 629 static void ide_cd_drain_data(ide_drive_t *drive, int nsects)
 630 {
 631         while (nsects > 0) {
 632                 static char dum[SECTOR_SIZE];
 633
 634                 drive->hwif->atapi_input_bytes(drive, dum, sizeof(dum));
 635                 nsects--;
 636         }
 637 }
 638
 639 /*
 640  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
 641  * buffer.  Once the first sector is added, any subsequent sectors are
 642  * assumed to be continuous (until the buffer is cleared).  For the first
 643  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
 644  * the buffer is cleared.)
 645  */
 646 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
 647                                   int sectors_to_transfer)
 648 {
 649         struct cdrom_info *info = drive->driver_data;
 650
 651         /* Number of sectors to read into the buffer. */
 652         int sectors_to_buffer = min_t(int, sectors_to_transfer,
 653                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
 654                                        info->nsectors_buffered);
 655
 656         char *dest;
 657
 658         /* If we couldn't get a buffer, don't try to buffer anything... */
 659         if (info->buffer == NULL)
 660                 sectors_to_buffer = 0;
 661
 662         /* If this is the first sector in the buffer, remember its number. */
 663         if (info->nsectors_buffered == 0)
 664                 info->sector_buffered = sector;
 665
 666         /* Read the data into the buffer. */
 667         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
 668         while (sectors_to_buffer > 0) {
 669                 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
 670                 --sectors_to_buffer;
 671                 --sectors_to_transfer;
 672                 ++info->nsectors_buffered;
 673                 dest += SECTOR_SIZE;
 674         }
 675
 676         /* Throw away any remaining data. */
 677         ide_cd_drain_data(drive, sectors_to_transfer);
 678 }
 679
 680 /*
 681  * Check the contents of the interrupt reason register from the cdrom
 682  * and attempt to recover if there are problems.  Returns  0 if everything's
 683  * ok; nonzero if the request has been terminated.
 684  */
 685 static
 686 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
 687 {
 688         if (ireason == 2)
 689                 return 0;
 690         else if (ireason == 0) {
 691                 ide_hwif_t *hwif = drive->hwif;
 692
 693                 /* Whoops... The drive is expecting to receive data from us! */
 694                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
 695                                 drive->name, __FUNCTION__);
 696
 697                 /* Throw some data at the drive so it doesn't hang
 698                    and quit this request. */
 699                 ide_cd_pad_transfer(drive, hwif->atapi_output_bytes, len);
 700         } else  if (ireason == 1) {
 701                 /* Some drives (ASUS) seem to tell us that status
 702                  * info is available. just get it and ignore.
 703                  */
 704                 (void) HWIF(drive)->INB(IDE_STATUS_REG);
 705                 return 0;
 706         } else {
 707                 /* Drive wants a command packet, or invalid ireason... */
 708                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
 709                                 drive->name, __FUNCTION__, ireason);
 710         }
 711
 712         cdrom_end_request(drive, 0);
 713         return -1;
 714 }
 715
 716 /*
 717  * Assume that the drive will always provide data in multiples of at least
 718  * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise.
 719  */
 720 static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
 721 {
 722         struct cdrom_info *cd = drive->driver_data;
 723
 724         if ((len % SECTOR_SIZE) == 0)
 725                 return 0;
 726
 727         printk(KERN_ERR "%s: %s: Bad transfer size %d\n",
 728                         drive->name, __FUNCTION__, len);
 729
 730         if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
 731                 printk(KERN_ERR "  This drive is not supported by "
 732                                 "this version of the driver\n");
 733         else {
 734                 printk(KERN_ERR "  Trying to limit transfer sizes\n");
 735                 cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
 736         }
 737
 738         return 1;
 739 }
 740
 741 /*
 742  * Try to satisfy some of the current read request from our cached data.
 743  * Returns nonzero if the request has been completed, zero otherwise.
 744  */
 745 static int cdrom_read_from_buffer (ide_drive_t *drive)
 746 {
 747         struct cdrom_info *info = drive->driver_data;
 748         struct request *rq = HWGROUP(drive)->rq;
 749         unsigned short sectors_per_frame;
 750
 751         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
 752
 753         /* Can't do anything if there's no buffer. */
 754         if (info->buffer == NULL) return 0;
 755
 756         /* Loop while this request needs data and the next block is present
 757            in our cache. */
 758         while (rq->nr_sectors > 0 &&
 759                rq->sector >= info->sector_buffered &&
 760                rq->sector < info->sector_buffered + info->nsectors_buffered) {
 761                 if (rq->current_nr_sectors == 0)
 762                         cdrom_end_request(drive, 1);
 763
 764                 memcpy (rq->buffer,
 765                         info->buffer +
 766                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
 767                         SECTOR_SIZE);
 768                 rq->buffer += SECTOR_SIZE;
 769                 --rq->current_nr_sectors;
 770                 --rq->nr_sectors;
 771                 ++rq->sector;
 772         }
 773
 774         /* If we've satisfied the current request,
 775            terminate it successfully. */
 776         if (rq->nr_sectors == 0) {
 777                 cdrom_end_request(drive, 1);
 778                 return -1;
 779         }
 780
 781         /* Move on to the next buffer if needed. */
 782         if (rq->current_nr_sectors == 0)
 783                 cdrom_end_request(drive, 1);
 784
 785         /* If this condition does not hold, then the kluge i use to
 786            represent the number of sectors to skip at the start of a transfer
 787            will fail.  I think that this will never happen, but let's be
 788            paranoid and check. */
 789         if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
 790             (rq->sector & (sectors_per_frame - 1))) {
 791                 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
 792                         drive->name, (long)rq->sector);
 793                 cdrom_end_request(drive, 0);
 794                 return -1;
 795         }
 796
 797         return 0;
 798 }
 799
 800 static ide_startstop_t cdrom_rw_intr(ide_drive_t *);
 801
 802 /*
 803  * Routine to send a read/write packet command to the drive.
 804  * This is usually called directly from cdrom_start_{read,write}().
 805  * However, for drq_interrupt devices, it is called from an interrupt
 806  * when the drive is ready to accept the command.
 807  */
 808 static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
 809 {
 810         struct request *rq = HWGROUP(drive)->rq;
 811
 812         if (rq_data_dir(rq) == READ) {
 813                 unsigned short sectors_per_frame =
 814                         queue_hardsect_size(drive->queue) >> SECTOR_BITS;
 815                 int nskip = rq->sector & (sectors_per_frame - 1);
 816
 817                 /*
 818                  * If the requested sector doesn't start on a frame boundary,
 819                  * we must adjust the start of the transfer so that it does,
 820                  * and remember to skip the first few sectors.
 821                  *
 822                  * If the rq->current_nr_sectors field is larger than the size
 823                  * of the buffer, it will mean that we're to skip a number of
 824                  * sectors equal to the amount by which rq->current_nr_sectors
 825                  * is larger than the buffer size.
 826                  */
 827                 if (nskip > 0) {
 828                         /* Sanity check... */
 829                         if (rq->current_nr_sectors !=
 830                             bio_cur_sectors(rq->bio)) {
 831                                 printk(KERN_ERR "%s: %s: buffer botch (%u)\n",
 832                                                 drive->name, __FUNCTION__,
 833                                                 rq->current_nr_sectors);
 834                                 cdrom_end_request(drive, 0);
 835                                 return ide_stopped;
 836                         }
 837                         rq->current_nr_sectors += nskip;
 838                 }
 839         }
 840 #if 0
 841         else
 842                 /* the immediate bit */
 843                 rq->cmd[1] = 1 << 3;
 844 #endif
 845         /* Set up the command */
 846         rq->timeout = ATAPI_WAIT_PC;
 847
 848         /* Send the command to the drive and return. */
 849         return cdrom_transfer_packet_command(drive, rq, cdrom_rw_intr);
 850 }
 851
 852 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
 853 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
 854 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
 855
 856 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
 857 {
 858         struct cdrom_info *info = drive->driver_data;
 859         int stat;
 860         static int retry = 10;
 861
 862         if (cdrom_decode_status(drive, 0, &stat))
 863                 return ide_stopped;
 864
 865         info->cd_flags |= IDE_CD_FLAG_SEEKING;
 866
 867         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
 868                 if (--retry == 0) {
 869                         /*
 870                          * this condition is far too common, to bother
 871                          * users about it
 872                          */
 873                         /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
 874                         drive->dsc_overlap = 0;
 875                 }
 876         }
 877         return ide_stopped;
 878 }
 879
 880 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
 881 {
 882         struct request *rq = HWGROUP(drive)->rq;
 883         sector_t frame = rq->sector;
 884
 885         sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
 886
 887         memset(rq->cmd, 0, sizeof(rq->cmd));
 888         rq->cmd[0] = GPCMD_SEEK;
 889         put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
 890
 891         rq->timeout = ATAPI_WAIT_PC;
 892         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
 893 }
 894
 895 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
 896 {
 897         struct cdrom_info *info = drive->driver_data;
 898
 899         info->dma = 0;
 900         info->start_seek = jiffies;
 901         return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
 902 }
 903
 904 /* Fix up a possibly partially-processed request so that we can
 905    start it over entirely, or even put it back on the request queue. */
 906 static void restore_request (struct request *rq)
 907 {
 908         if (rq->buffer != bio_data(rq->bio)) {
 909                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
 910
 911                 rq->buffer = bio_data(rq->bio);
 912                 rq->nr_sectors += n;
 913                 rq->sector -= n;
 914         }
 915         rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
 916         rq->hard_nr_sectors = rq->nr_sectors;
 917         rq->hard_sector = rq->sector;
 918         rq->q->prep_rq_fn(rq->q, rq);
 919 }
 920
 921 /****************************************************************************
 922  * Execute all other packet commands.
 923  */
 924
 925 static void ide_cd_request_sense_fixup(struct request *rq)
 926 {
 927         /*
 928          * Some of the trailing request sense fields are optional,
 929          * and some drives don't send them.  Sigh.
 930          */
 931         if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
 932             rq->data_len > 0 && rq->data_len <= 5)
 933                 while (rq->data_len > 0) {
 934                         *(u8 *)rq->data++ = 0;
 935                         --rq->data_len;
 936                 }
 937 }
 938
 939 int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
 940 {
 941         struct request_sense sense;
 942         int retries = 10;
 943         unsigned int flags = rq->cmd_flags;
 944
 945         if (rq->sense == NULL)
 946                 rq->sense = &sense;
 947
 948         /* Start of retry loop. */
 949         do {
 950                 int error;
 951                 unsigned long time = jiffies;
 952                 rq->cmd_flags = flags;
 953
 954                 error = ide_do_drive_cmd(drive, rq, ide_wait);
 955                 time = jiffies - time;
 956
 957                 /* FIXME: we should probably abort/retry or something
 958                  * in case of failure */
 959                 if (rq->cmd_flags & REQ_FAILED) {
 960                         /* The request failed.  Retry if it was due to a unit
 961                            attention status
 962                            (usually means media was changed). */
 963                         struct request_sense *reqbuf = rq->sense;
 964
 965                         if (reqbuf->sense_key == UNIT_ATTENTION)
 966                                 cdrom_saw_media_change(drive);
 967                         else if (reqbuf->sense_key == NOT_READY &&
 968                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
 969                                 /* The drive is in the process of loading
 970                                    a disk.  Retry, but wait a little to give
 971                                    the drive time to complete the load. */
 972                                 ssleep(2);
 973                         } else {
 974                                 /* Otherwise, don't retry. */
 975                                 retries = 0;
 976                         }
 977                         --retries;
 978                 }
 979
 980                 /* End of retry loop. */
 981         } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
 982
 983         /* Return an error if the command failed. */
 984         return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
 985 }
 986
 987 /*
 988  * Write handling
 989  */
 990 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
 991 {
 992         /* Two notes about IDE interrupt reason here - 0 means that
 993          * the drive wants to receive data from us, 2 means that
 994          * the drive is expecting to transfer data to us.
 995          */
 996         if (ireason == 0)
 997                 return 0;
 998         else if (ireason == 2) {
 999                 ide_hwif_t *hwif = drive->hwif;
1000
1001                 /* Whoops... The drive wants to send data. */
1002                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1003                                 drive->name, __FUNCTION__);
1004
1005                 ide_cd_pad_transfer(drive, hwif->atapi_input_bytes, len);
1006         } else {
1007                 /* Drive wants a command packet, or invalid ireason... */
1008                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1009                                 drive->name, __FUNCTION__, ireason);
1010         }
1011
1012         cdrom_end_request(drive, 0);
1013         return 1;
1014 }
1015
1016 /*
1017  * Called from blk_end_request_callback() after the data of the request
1018  * is completed and before the request is completed.
1019  * By returning value '1', blk_end_request_callback() returns immediately
1020  * without completing the request.
1021  */
1022 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1023 {
1024         return 1;
1025 }
1026
1027 /*
1028  * best way to deal with dma that is not sector aligned right now... note
1029  * that in this path we are not using ->data or ->buffer at all. this irs
1030  * can replace cdrom_rw_intr() in the future.
1031  */
1032 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1033 {
1034         struct cdrom_info *info = drive->driver_data;
1035         struct request *rq = HWGROUP(drive)->rq;
1036         xfer_func_t *xferfunc;
1037         ide_expiry_t *expiry;
1038         int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0;
1039         int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
1040         unsigned int timeout;
1041         u8 lowcyl, highcyl;
1042
1043         /* Check for errors. */
1044         dma = info->dma;
1045         if (dma) {
1046                 info->dma = 0;
1047                 dma_error = HWIF(drive)->ide_dma_end(drive);
1048                 if (dma_error) {
1049                         printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1050                                         write ? "write" : "read");
1051                         ide_dma_off(drive);
1052                 }
1053         }
1054
1055         if (cdrom_decode_status(drive, 0, &stat))
1056                 return ide_stopped;
1057
1058         /*
1059          * using dma, transfer is complete now
1060          */
1061         if (dma) {
1062                 if (dma_error)
1063                         return ide_error(drive, "dma error", stat);
1064                 goto end_request;
1065         }
1066
1067         /*
1068          * ok we fall to pio :/
1069          */
1070         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1071         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1072         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1073
1074         len = lowcyl + (256 * highcyl);
1075         thislen = rq->data_len;
1076         if (thislen > len)
1077                 thislen = len;
1078
1079         /*
1080          * If DRQ is clear, the command has completed.
1081          */
1082         if ((stat & DRQ_STAT) == 0) {
1083                 if (!blk_pc_request(rq)) {
1084                         ide_cd_request_sense_fixup(rq);
1085                         /* Complain if we still have data left to transfer. */
1086                         uptodate = rq->data_len ? 0 : 1;
1087                 }
1088                 goto end_request;
1089         }
1090
1091         /*
1092          * check which way to transfer data
1093          */
1094         if (blk_pc_request(rq) && rq_data_dir(rq) == WRITE) {
1095                 /*
1096                  * write to drive
1097                  */
1098                 if (cdrom_write_check_ireason(drive, len, ireason))
1099                         return ide_stopped;
1100         } else if (blk_pc_request(rq)) {
1101                 /*
1102                  * read from drive
1103                  */
1104                 if (cdrom_read_check_ireason(drive, len, ireason))
1105                         return ide_stopped;
1106         }
1107
1108         if (ireason == 0) {
1109                 write = 1;
1110                 xferfunc = HWIF(drive)->atapi_output_bytes;
1111         } else if (ireason == 2 || (ireason == 1 && blk_pc_request(rq))) {
1112                 write = 0;
1113                 xferfunc = HWIF(drive)->atapi_input_bytes;
1114         } else {
1115                 printk(KERN_ERR "%s: %s: The drive "
1116                                 "appears confused (ireason = 0x%02x). "
1117                                 "Trying to recover by ending request.\n",
1118                                 drive->name, __FUNCTION__, ireason);
1119                 goto end_request;
1120         }
1121
1122         /*
1123          * transfer data
1124          */
1125         while (thislen > 0) {
1126                 u8 *ptr = rq->data;
1127                 int blen = rq->data_len;
1128
1129                 /*
1130                  * bio backed?
1131                  */
1132                 if (rq->bio) {
1133                         ptr = bio_data(rq->bio);
1134                         blen = bio_iovec(rq->bio)->bv_len;
1135                 }
1136
1137                 if (!ptr) {
1138                         printk(KERN_ERR "%s: confused, missing data\n",
1139                                         drive->name);
1140                         blk_dump_rq_flags(rq, rq_data_dir(rq)
1141                                               ? "cdrom_newpc_intr, write"
1142                                               : "cdrom_newpc_intr, read");
1143                         break;
1144                 }
1145
1146                 if (blen > thislen)
1147                         blen = thislen;
1148
1149                 xferfunc(drive, ptr, blen);
1150
1151                 thislen -= blen;
1152                 len -= blen;
1153                 rq->data_len -= blen;
1154
1155                 if (rq->bio)
1156                         /*
1157                          * The request can't be completed until DRQ is cleared.
1158                          * So complete the data, but don't complete the request
1159                          * using the dummy function for the callback feature
1160                          * of blk_end_request_callback().
1161                          */
1162                         blk_end_request_callback(rq, 0, blen,
1163                                                  cdrom_newpc_intr_dummy_cb);
1164                 else
1165                         rq->data += blen;
1166         }
1167
1168         if (write && blk_sense_request(rq))
1169                 rq->sense_len += thislen;
1170
1171         /*
1172          * pad, if necessary
1173          */
1174         if (len > 0)
1175                 ide_cd_pad_transfer(drive, xferfunc, len);
1176
1177         if (blk_pc_request(rq)) {
1178                 timeout = rq->timeout;
1179                 expiry = NULL;
1180         } else {
1181                 timeout = ATAPI_WAIT_PC;
1182                 expiry = cdrom_timer_expiry;
1183         }
1184
1185         ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
1186         return ide_started;
1187
1188 end_request:
1189         if (blk_pc_request(rq)) {
1190                 unsigned long flags;
1191
1192                 spin_lock_irqsave(&ide_lock, flags);
1193                 if (__blk_end_request(rq, 0, rq->data_len))
1194                         BUG();
1195                 HWGROUP(drive)->rq = NULL;
1196                 spin_unlock_irqrestore(&ide_lock, flags);
1197         } else {
1198                 if (!uptodate)
1199                         rq->cmd_flags |= REQ_FAILED;
1200                 cdrom_end_request(drive, uptodate);
1201         }
1202         return ide_stopped;
1203 }
1204
1205 static ide_startstop_t cdrom_rw_intr(ide_drive_t *drive)
1206 {
1207         struct cdrom_info *info = drive->driver_data;
1208         struct request *rq = HWGROUP(drive)->rq;
1209         xfer_func_t *xferfunc;
1210         int stat, ireason, len, thislen, uptodate, nskip;
1211         int dma_error = 0, dma = info->dma, write = rq_data_dir(rq) == WRITE;
1212         u8 lowcyl = 0, highcyl = 0;
1213
1214         /* Check for errors. */
1215         if (dma) {
1216                 info->dma = 0;
1217                 dma_error = HWIF(drive)->ide_dma_end(drive);
1218                 if (dma_error) {
1219                         printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1220                                         write ? "write" : "read");
1221                         ide_dma_off(drive);
1222                 }
1223         }
1224
1225         if (cdrom_decode_status(drive, 0, &stat))
1226                 return ide_stopped;
1227
1228         /*
1229          * using dma, transfer is complete now
1230          */
1231         if (dma) {
1232                 if (dma_error)
1233                         return ide_error(drive, "dma error", stat);
1234
1235                 ide_end_request(drive, 1, rq->nr_sectors);
1236                 return ide_stopped;
1237         }
1238
1239         /* Read the interrupt reason and the transfer length. */
1240         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1241         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1242         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1243
1244         len = lowcyl + (256 * highcyl);
1245
1246         /* If DRQ is clear, the command has completed. */
1247         if ((stat & DRQ_STAT) == 0) {
1248                 /*
1249                  * If we're not done reading/writing, complain.
1250                  * Otherwise, complete the command normally.
1251                  */
1252                 uptodate = 1;
1253                 if (rq->current_nr_sectors > 0) {
1254                         printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1255                                         drive->name, __FUNCTION__,
1256                                         rq->current_nr_sectors);
1257                         if (!write)
1258                                 rq->cmd_flags |= REQ_FAILED;
1259                         uptodate = 0;
1260                 }
1261                 cdrom_end_request(drive, uptodate);
1262                 return ide_stopped;
1263         }
1264
1265         thislen = len;
1266
1267         /* Check that the drive is expecting to do the same thing we are. */
1268         if (write) {
1269                 if (cdrom_write_check_ireason(drive, len, ireason))
1270                         return ide_stopped;
1271
1272                 xferfunc = HWIF(drive)->atapi_output_bytes;
1273         } else {
1274                 if (cdrom_read_check_ireason(drive, len, ireason))
1275                         return ide_stopped;
1276
1277                 if (ide_cd_check_transfer_size(drive, len)) {
1278                         cdrom_end_request(drive, 0);
1279                         return ide_stopped;
1280                 }
1281
1282                 /*
1283                  * First, figure out if we need to bit-bucket
1284                  * any of the leading sectors.
1285                  */
1286                 nskip = min_t(int, rq->current_nr_sectors
1287                                    - bio_cur_sectors(rq->bio),
1288                                    thislen >> 9);
1289
1290                 if (nskip > 0) {
1291                         ide_cd_drain_data(drive, nskip);
1292                         rq->current_nr_sectors -= nskip;
1293                         thislen -= (nskip << 9);
1294                 }
1295
1296                 xferfunc = HWIF(drive)->atapi_input_bytes;
1297         }
1298
1299         /*
1300          * now loop and read/write the data
1301          */
1302         while (thislen > 0) {
1303                 u8 *ptr = NULL;
1304                 int blen;
1305
1306                 if (rq->bio) {
1307                         ptr = rq->buffer;
1308                         blen = rq->current_nr_sectors << 9;
1309                 }
1310
1311                 if (!ptr) {
1312                         if (!write)
1313                                 /*
1314                                  * If the buffers are full, cache the rest
1315                                  * of the data in our internal buffer.
1316                                  */
1317                                 cdrom_buffer_sectors(drive, rq->sector,
1318                                                      thislen >> 9);
1319                         else
1320                                 printk(KERN_ERR "%s: %s: confused, missing "
1321                                                 "data\n",
1322                                                 drive->name, __FUNCTION__);
1323                         break;
1324                 }
1325
1326                 /*
1327                  * Figure out how many sectors we can transfer
1328                  */
1329                 if (blen > thislen)
1330                         blen = thislen;
1331
1332                 xferfunc(drive, ptr, blen);
1333
1334                 thislen -= blen;
1335                 rq->buffer += blen;
1336                 rq->nr_sectors -= (blen >> 9);
1337                 rq->current_nr_sectors -= (blen >> 9);
1338                 rq->sector += (blen >> 9);
1339
1340                 /*
1341                  * current buffer complete, move on
1342                  */
1343                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1344                         cdrom_end_request(drive, 1);
1345         }
1346
1347         /* re-arm handler */
1348         ide_set_handler(drive, cdrom_rw_intr, ATAPI_WAIT_PC, NULL);
1349         return ide_started;
1350 }
1351
1352 static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
1353 {
1354         struct cdrom_info *cd = drive->driver_data;
1355         int write = rq_data_dir(rq) == WRITE;
1356         unsigned short sectors_per_frame =
1357                 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1358
1359         if (write) {
1360                 /*
1361                  * disk has become write protected
1362                  */
1363                 if (cd->disk->policy) {
1364                         cdrom_end_request(drive, 0);
1365                         return ide_stopped;
1366                 }
1367         } else {
1368                 /*
1369                  * We may be retrying this request after an error.  Fix up any
1370                  * weirdness which might be present in the request packet.
1371                  */
1372                 restore_request(rq);
1373
1374                 /* Satisfy whatever we can of this request from our cache. */
1375                 if (cdrom_read_from_buffer(drive))
1376                         return ide_stopped;
1377         }
1378
1379         /*
1380          * use DMA, if possible / writes *must* be hardware frame aligned
1381          */
1382         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1383             (rq->sector & (sectors_per_frame - 1))) {
1384                 if (write) {
1385                         cdrom_end_request(drive, 0);
1386                         return ide_stopped;
1387                 }
1388                 cd->dma = 0;
1389         } else
1390                 cd->dma = drive->using_dma;
1391
1392         /* Clear the local sector buffer. */
1393         cd->nsectors_buffered = 0;
1394
1395         if (write)
1396                 cd->devinfo.media_written = 1;
1397
1398         /* Start sending the read/write request to the drive. */
1399         return cdrom_start_packet_command(drive, 32768, cdrom_start_rw_cont);
1400 }
1401
1402 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1403 {
1404         struct request *rq = HWGROUP(drive)->rq;
1405
1406         if (!rq->timeout)
1407                 rq->timeout = ATAPI_WAIT_PC;
1408
1409         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1410 }
1411
1412 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1413 {
1414         struct cdrom_info *info = drive->driver_data;
1415
1416         if (blk_pc_request(rq))
1417                 rq->cmd_flags |= REQ_QUIET;
1418         else
1419                 rq->cmd_flags &= ~REQ_FAILED;
1420
1421         info->dma = 0;
1422
1423         /*
1424          * sg request
1425          */
1426         if (rq->bio) {
1427                 int mask = drive->queue->dma_alignment;
1428                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1429
1430                 info->dma = drive->using_dma;
1431
1432                 /*
1433                  * check if dma is safe
1434                  *
1435                  * NOTE! The "len" and "addr" checks should possibly have
1436                  * separate masks.
1437                  */
1438                 if ((rq->data_len & 15) || (addr & mask))
1439                         info->dma = 0;
1440         }
1441
1442         /* Start sending the command to the drive. */
1443         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1444 }
1445
1446 /****************************************************************************
1447  * cdrom driver request routine.
1448  */
1449 static ide_startstop_t
1450 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1451 {
1452         ide_startstop_t action;
1453         struct cdrom_info *info = drive->driver_data;
1454
1455         if (blk_fs_request(rq)) {
1456                 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1457                         unsigned long elapsed = jiffies - info->start_seek;
1458                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1459
1460                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1461                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1462                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1463                                         return ide_stopped;
1464                                 }
1465                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1466                         }
1467                         info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1468                 }
1469                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1470                         action = cdrom_start_seek(drive, block);
1471                 } else
1472                         action = cdrom_start_rw(drive, rq);
1473                 info->last_block = block;
1474                 return action;
1475         } else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1476                    rq->cmd_type == REQ_TYPE_ATA_PC) {
1477                 return cdrom_do_block_pc(drive, rq);
1478         } else if (blk_special_request(rq)) {
1479                 /*
1480                  * right now this can only be a reset...
1481                  */
1482                 cdrom_end_request(drive, 1);
1483                 return ide_stopped;
1484         }
1485
1486         blk_dump_rq_flags(rq, "ide-cd bad flags");
1487         cdrom_end_request(drive, 0);
1488         return ide_stopped;
1489 }
1490
1491
1492
1493 /****************************************************************************
1494  * Ioctl handling.
1495  *
1496  * Routines which queue packet commands take as a final argument a pointer
1497  * to a request_sense struct.  If execution of the command results
1498  * in an error with a CHECK CONDITION status, this structure will be filled
1499  * with the results of the subsequent request sense command.  The pointer
1500  * can also be NULL, in which case no sense information is returned.
1501  */
1502
1503 static
1504 void msf_from_bcd (struct atapi_msf *msf)
1505 {
1506         msf->minute = BCD2BIN(msf->minute);
1507         msf->second = BCD2BIN(msf->second);
1508         msf->frame  = BCD2BIN(msf->frame);
1509 }
1510
1511 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1512 {
1513         struct request req;
1514         struct cdrom_info *info = drive->driver_data;
1515         struct cdrom_device_info *cdi = &info->devinfo;
1516
1517         ide_cd_init_rq(drive, &req);
1518
1519         req.sense = sense;
1520         req.cmd[0] = GPCMD_TEST_UNIT_READY;
1521         req.cmd_flags |= REQ_QUIET;
1522
1523         /*
1524          * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1525          * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1526          */
1527         req.cmd[7] = cdi->sanyo_slot % 3;
1528
1529         return ide_cd_queue_pc(drive, &req);
1530 }
1531
1532 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1533 int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
1534                     struct request_sense *sense)
1535 {
1536         struct cdrom_info *cd = drive->driver_data;
1537         struct request_sense my_sense;
1538         struct request req;
1539         int stat;
1540
1541         if (sense == NULL)
1542                 sense = &my_sense;
1543
1544         /* If the drive cannot lock the door, just pretend. */
1545         if (cd->cd_flags & IDE_CD_FLAG_NO_DOORLOCK) {
1546                 stat = 0;
1547         } else {
1548                 ide_cd_init_rq(drive, &req);
1549                 req.sense = sense;
1550                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1551                 req.cmd[4] = lockflag ? 1 : 0;
1552                 stat = ide_cd_queue_pc(drive, &req);
1553         }
1554
1555         /* If we got an illegal field error, the drive
1556            probably cannot lock the door. */
1557         if (stat != 0 &&
1558             sense->sense_key == ILLEGAL_REQUEST &&
1559             (sense->asc == 0x24 || sense->asc == 0x20)) {
1560                 printk (KERN_ERR "%s: door locking not supported\n",
1561                         drive->name);
1562                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1563                 stat = 0;
1564         }
1565
1566         /* no medium, that's alright. */
1567         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
1568                 stat = 0;
1569
1570         if (stat == 0) {
1571                 if (lockflag)
1572                         cd->cd_flags |= IDE_CD_FLAG_DOOR_LOCKED;
1573                 else
1574                         cd->cd_flags &= ~IDE_CD_FLAG_DOOR_LOCKED;
1575         }
1576
1577         return stat;
1578 }
1579
1580
1581 /* Eject the disk if EJECTFLAG is 0.
1582    If EJECTFLAG is 1, try to reload the disk. */
1583 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
1584                        struct request_sense *sense)
1585 {
1586         struct cdrom_info *cd = drive->driver_data;
1587         struct cdrom_device_info *cdi = &cd->devinfo;
1588         struct request req;
1589         char loej = 0x02;
1590
1591         if ((cd->cd_flags & IDE_CD_FLAG_NO_EJECT) && !ejectflag)
1592                 return -EDRIVE_CANT_DO_THIS;
1593
1594         /* reload fails on some drives, if the tray is locked */
1595         if ((cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED) && ejectflag)
1596                 return 0;
1597
1598         ide_cd_init_rq(drive, &req);
1599
1600         /* only tell drive to close tray if open, if it can do that */
1601         if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
1602                 loej = 0;
1603
1604         req.sense = sense;
1605         req.cmd[0] = GPCMD_START_STOP_UNIT;
1606         req.cmd[4] = loej | (ejectflag != 0);
1607
1608         return ide_cd_queue_pc(drive, &req);
1609 }
1610
1611 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1612                                unsigned long *sectors_per_frame,
1613                                struct request_sense *sense)
1614 {
1615         struct {
1616                 __u32 lba;
1617                 __u32 blocklen;
1618         } capbuf;
1619
1620         int stat;
1621         struct request req;
1622
1623         ide_cd_init_rq(drive, &req);
1624
1625         req.sense = sense;
1626         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1627         req.data = (char *)&capbuf;
1628         req.data_len = sizeof(capbuf);
1629         req.cmd_flags |= REQ_QUIET;
1630
1631         stat = ide_cd_queue_pc(drive, &req);
1632         if (stat == 0) {
1633                 *capacity = 1 + be32_to_cpu(capbuf.lba);
1634                 *sectors_per_frame =
1635                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1636         }
1637
1638         return stat;
1639 }
1640
1641 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1642                                 int format, char *buf, int buflen,
1643                                 struct request_sense *sense)
1644 {
1645         struct request req;
1646
1647         ide_cd_init_rq(drive, &req);
1648
1649         req.sense = sense;
1650         req.data =  buf;
1651         req.data_len = buflen;
1652         req.cmd_flags |= REQ_QUIET;
1653         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1654         req.cmd[6] = trackno;
1655         req.cmd[7] = (buflen >> 8);
1656         req.cmd[8] = (buflen & 0xff);
1657         req.cmd[9] = (format << 6);
1658
1659         if (msf_flag)
1660                 req.cmd[1] = 2;
1661
1662         return ide_cd_queue_pc(drive, &req);
1663 }
1664
1665 /* Try to read the entire TOC for the disk into our internal buffer. */
1666 int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
1667 {
1668         int stat, ntracks, i;
1669         struct cdrom_info *info = drive->driver_data;
1670         struct cdrom_device_info *cdi = &info->devinfo;
1671         struct atapi_toc *toc = info->toc;
1672         struct {
1673                 struct atapi_toc_header hdr;
1674                 struct atapi_toc_entry  ent;
1675         } ms_tmp;
1676         long last_written;
1677         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1678
1679         if (toc == NULL) {
1680                 /* Try to allocate space. */
1681                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1682                 if (toc == NULL) {
1683                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1684                         return -ENOMEM;
1685                 }
1686                 info->toc = toc;
1687         }
1688
1689         /* Check to see if the existing data is still valid.
1690            If it is, just return. */
1691         (void) cdrom_check_status(drive, sense);
1692
1693         if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
1694                 return 0;
1695
1696         /* Try to get the total cdrom capacity and sector size. */
1697         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
1698                                    sense);
1699         if (stat)
1700                 toc->capacity = 0x1fffff;
1701
1702         set_capacity(info->disk, toc->capacity * sectors_per_frame);
1703         /* Save a private copy of te TOC capacity for error handling */
1704         drive->probed_capacity = toc->capacity * sectors_per_frame;
1705
1706         blk_queue_hardsect_size(drive->queue,
1707                                 sectors_per_frame << SECTOR_BITS);
1708
1709         /* First read just the header, so we know how long the TOC is. */
1710         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1711                                     sizeof(struct atapi_toc_header), sense);
1712         if (stat)
1713                 return stat;
1714
1715         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1716                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1717                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1718         }
1719
1720         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1721         if (ntracks <= 0)
1722                 return -EIO;
1723         if (ntracks > MAX_TRACKS)
1724                 ntracks = MAX_TRACKS;
1725
1726         /* Now read the whole schmeer. */
1727         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1728                                   (char *)&toc->hdr,
1729                                    sizeof(struct atapi_toc_header) +
1730                                    (ntracks + 1) *
1731                                    sizeof(struct atapi_toc_entry), sense);
1732
1733         if (stat && toc->hdr.first_track > 1) {
1734                 /* Cds with CDI tracks only don't have any TOC entries,
1735                    despite of this the returned values are
1736                    first_track == last_track = number of CDI tracks + 1,
1737                    so that this case is indistinguishable from the same
1738                    layout plus an additional audio track.
1739                    If we get an error for the regular case, we assume
1740                    a CDI without additional audio tracks. In this case
1741                    the readable TOC is empty (CDI tracks are not included)
1742                    and only holds the Leadout entry. Heiko Eißfeldt */
1743                 ntracks = 0;
1744                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1745                                            (char *)&toc->hdr,
1746                                            sizeof(struct atapi_toc_header) +
1747                                            (ntracks + 1) *
1748                                            sizeof(struct atapi_toc_entry),
1749                                            sense);
1750                 if (stat)
1751                         return stat;
1752
1753                 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1754                         toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1755                         toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
1756                 } else {
1757                         toc->hdr.first_track = CDROM_LEADOUT;
1758                         toc->hdr.last_track = CDROM_LEADOUT;
1759                 }
1760         }
1761
1762         if (stat)
1763                 return stat;
1764
1765         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1766
1767         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1768                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1769                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1770         }
1771
1772         for (i = 0; i <= ntracks; i++) {
1773                 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1774                         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
1775                                 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
1776                         msf_from_bcd(&toc->ent[i].addr.msf);
1777                 }
1778                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1779                                                    toc->ent[i].addr.msf.second,
1780                                                    toc->ent[i].addr.msf.frame);
1781         }
1782
1783         /* Read the multisession information. */
1784         if (toc->hdr.first_track != CDROM_LEADOUT) {
1785                 /* Read the multisession information. */
1786                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1787                                            sizeof(ms_tmp), sense);
1788                 if (stat)
1789                         return stat;
1790
1791                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1792         } else {
1793                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1794                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1795         }
1796
1797         if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1798                 /* Re-read multisession information using MSF format */
1799                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1800                                            sizeof(ms_tmp), sense);
1801                 if (stat)
1802                         return stat;
1803
1804                 msf_from_bcd (&ms_tmp.ent.addr.msf);
1805                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1806                                                    ms_tmp.ent.addr.msf.second,
1807                                                    ms_tmp.ent.addr.msf.frame);
1808         }
1809
1810         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1811
1812         /* Now try to get the total cdrom capacity. */
1813         stat = cdrom_get_last_written(cdi, &last_written);
1814         if (!stat && (last_written > toc->capacity)) {
1815                 toc->capacity = last_written;
1816                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
1817                 drive->probed_capacity = toc->capacity * sectors_per_frame;
1818         }
1819
1820         /* Remember that we've read this stuff. */
1821         info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
1822
1823         return 0;
1824 }
1825
1826 /* the generic packet interface to cdrom.c */
1827 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
1828                             struct packet_command *cgc)
1829 {
1830         struct request req;
1831         ide_drive_t *drive = cdi->handle;
1832
1833         if (cgc->timeout <= 0)
1834                 cgc->timeout = ATAPI_WAIT_PC;
1835
1836         /* here we queue the commands from the uniform CD-ROM
1837            layer. the packet must be complete, as we do not
1838            touch it at all. */
1839         ide_cd_init_rq(drive, &req);
1840         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
1841         if (cgc->sense)
1842                 memset(cgc->sense, 0, sizeof(struct request_sense));
1843         req.data = cgc->buffer;
1844         req.data_len = cgc->buflen;
1845         req.timeout = cgc->timeout;
1846
1847         if (cgc->quiet)
1848                 req.cmd_flags |= REQ_QUIET;
1849
1850         req.sense = cgc->sense;
1851         cgc->stat = ide_cd_queue_pc(drive, &req);
1852         if (!cgc->stat)
1853                 cgc->buflen -= req.data_len;
1854         return cgc->stat;
1855 }
1856
1857 static
1858 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
1859 {
1860         ide_drive_t *drive = cdi->handle;
1861         struct request_sense sense;
1862
1863         if (position) {
1864                 int stat = ide_cd_lockdoor(drive, 0, &sense);
1865
1866                 if (stat)
1867                         return stat;
1868         }
1869
1870         return cdrom_eject(drive, !position, &sense);
1871 }
1872
1873 int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
1874 {
1875         struct cdrom_info *info = drive->driver_data;
1876         struct cdrom_device_info *cdi = &info->devinfo;
1877         struct packet_command cgc;
1878         int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
1879
1880         if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
1881                 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
1882
1883         init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
1884         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
1885                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
1886                 if (!stat)
1887                         break;
1888         } while (--attempts);
1889         return stat;
1890 }
1891
1892 void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
1893 {
1894         struct cdrom_info *cd = drive->driver_data;
1895         u16 curspeed, maxspeed;
1896
1897         curspeed = *(u16 *)&buf[8 + 14];
1898         maxspeed = *(u16 *)&buf[8 +  8];
1899
1900         if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
1901                 curspeed = le16_to_cpu(curspeed);
1902                 maxspeed = le16_to_cpu(maxspeed);
1903         } else {
1904                 curspeed = be16_to_cpu(curspeed);
1905                 maxspeed = be16_to_cpu(maxspeed);
1906         }
1907
1908         cd->current_speed = (curspeed + (176/2)) / 176;
1909         cd->max_speed = (maxspeed + (176/2)) / 176;
1910 }
1911
1912 /*
1913  * add logic to try GET_EVENT command first to check for media and tray
1914  * status. this should be supported by newer cd-r/w and all DVD etc
1915  * drives
1916  */
1917 static
1918 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
1919 {
1920         ide_drive_t *drive = cdi->handle;
1921         struct media_event_desc med;
1922         struct request_sense sense;
1923         int stat;
1924
1925         if (slot_nr != CDSL_CURRENT)
1926                 return -EINVAL;
1927
1928         stat = cdrom_check_status(drive, &sense);
1929         if (!stat || sense.sense_key == UNIT_ATTENTION)
1930                 return CDS_DISC_OK;
1931
1932         if (!cdrom_get_media_event(cdi, &med)) {
1933                 if (med.media_present)
1934                         return CDS_DISC_OK;
1935                 else if (med.door_open)
1936                         return CDS_TRAY_OPEN;
1937                 else
1938                         return CDS_NO_DISC;
1939         }
1940
1941         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
1942                 return CDS_DISC_OK;
1943
1944         /*
1945          * If not using Mt Fuji extended media tray reports,
1946          * just return TRAY_OPEN since ATAPI doesn't provide
1947          * any other way to detect this...
1948          */
1949         if (sense.sense_key == NOT_READY) {
1950                 if (sense.asc == 0x3a && sense.ascq == 1)
1951                         return CDS_NO_DISC;
1952                 else
1953                         return CDS_TRAY_OPEN;
1954         }
1955         return CDS_DRIVE_NOT_READY;
1956 }
1957
1958 /****************************************************************************
1959  * Other driver requests (open, close, check media change).
1960  */
1961
1962 static
1963 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
1964                                        int slot_nr)
1965 {
1966         ide_drive_t *drive = cdi->handle;
1967         struct cdrom_info *cd = drive->driver_data;
1968         int retval;
1969
1970         if (slot_nr == CDSL_CURRENT) {
1971                 (void) cdrom_check_status(drive, NULL);
1972                 retval = (cd->cd_flags & IDE_CD_FLAG_MEDIA_CHANGED) ? 1 : 0;
1973                 cd->cd_flags &= ~IDE_CD_FLAG_MEDIA_CHANGED;
1974                 return retval;
1975         } else {
1976                 return -EINVAL;
1977         }
1978 }
1979
1980
1981 static
1982 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
1983 {
1984         return 0;
1985 }
1986
1987 /*
1988  * Close down the device.  Invalidate all cached blocks.
1989  */
1990
1991 static
1992 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
1993 {
1994         ide_drive_t *drive = cdi->handle;
1995         struct cdrom_info *cd = drive->driver_data;
1996
1997         if (!cdi->use_count)
1998                 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
1999 }
2000
2001 #define IDE_CD_CAPABILITIES \
2002         (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2003          CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2004          CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2005          CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2006          CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
2007
2008 static struct cdrom_device_ops ide_cdrom_dops = {
2009         .open                   = ide_cdrom_open_real,
2010         .release                = ide_cdrom_release_real,
2011         .drive_status           = ide_cdrom_drive_status,
2012         .media_changed          = ide_cdrom_check_media_change_real,
2013         .tray_move              = ide_cdrom_tray_move,
2014         .lock_door              = ide_cdrom_lock_door,
2015         .select_speed           = ide_cdrom_select_speed,
2016         .get_last_session       = ide_cdrom_get_last_session,
2017         .get_mcn                = ide_cdrom_get_mcn,
2018         .reset                  = ide_cdrom_reset,
2019         .audio_ioctl            = ide_cdrom_audio_ioctl,
2020         .capability             = IDE_CD_CAPABILITIES,
2021         .generic_packet         = ide_cdrom_packet,
2022 };
2023
2024 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2025 {
2026         struct cdrom_info *info = drive->driver_data;
2027         struct cdrom_device_info *devinfo = &info->devinfo;
2028
2029         devinfo->ops = &ide_cdrom_dops;
2030         devinfo->speed = info->current_speed;
2031         devinfo->capacity = nslots;
2032         devinfo->handle = drive;
2033         strcpy(devinfo->name, drive->name);
2034
2035         if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
2036                 devinfo->mask |= CDC_SELECT_SPEED;
2037
2038         devinfo->disk = info->disk;
2039         return register_cdrom(devinfo);
2040 }
2041
2042 static
2043 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2044 {
2045         struct cdrom_info *cd = drive->driver_data;
2046         struct cdrom_device_info *cdi = &cd->devinfo;
2047         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2048         mechtype_t mechtype;
2049         int nslots = 1;
2050
2051         cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
2052                      CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
2053                      CDC_MO_DRIVE | CDC_RAM);
2054
2055         if (drive->media == ide_optical) {
2056                 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
2057                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2058                 return nslots;
2059         }
2060
2061         if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
2062                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2063                 cdi->mask &= ~CDC_PLAY_AUDIO;
2064                 return nslots;
2065         }
2066
2067         /*
2068          * we have to cheat a little here. the packet will eventually
2069          * be queued with ide_cdrom_packet(), which extracts the
2070          * drive from cdi->handle. Since this device hasn't been
2071          * registered with the Uniform layer yet, it can't do this.
2072          * Same goes for cdi->ops.
2073          */
2074         cdi->handle = drive;
2075         cdi->ops = &ide_cdrom_dops;
2076
2077         if (ide_cdrom_get_capabilities(drive, buf))
2078                 return 0;
2079
2080         if ((buf[8 + 6] & 0x01) == 0)
2081                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
2082         if (buf[8 + 6] & 0x08)
2083                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2084         if (buf[8 + 3] & 0x01)
2085                 cdi->mask &= ~CDC_CD_R;
2086         if (buf[8 + 3] & 0x02)
2087                 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
2088         if (buf[8 + 2] & 0x38)
2089                 cdi->mask &= ~CDC_DVD;
2090         if (buf[8 + 3] & 0x20)
2091                 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
2092         if (buf[8 + 3] & 0x10)
2093                 cdi->mask &= ~CDC_DVD_R;
2094         if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
2095                 cdi->mask &= ~CDC_PLAY_AUDIO;
2096
2097         mechtype = buf[8 + 6] >> 5;
2098         if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
2099                 cdi->mask |= CDC_CLOSE_TRAY;
2100
2101         if (cdi->sanyo_slot > 0) {
2102                 cdi->mask &= ~CDC_SELECT_DISC;
2103                 nslots = 3;
2104         } else if (mechtype == mechtype_individual_changer ||
2105                    mechtype == mechtype_cartridge_changer) {
2106                 nslots = cdrom_number_of_slots(cdi);
2107                 if (nslots > 1)
2108                         cdi->mask &= ~CDC_SELECT_DISC;
2109         }
2110
2111         ide_cdrom_update_speed(drive, buf);
2112
2113         printk(KERN_INFO "%s: ATAPI", drive->name);
2114
2115         /* don't print speed if the drive reported 0 */
2116         if (cd->max_speed)
2117                 printk(KERN_CONT " %dX", cd->max_speed);
2118
2119         printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
2120
2121         if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
2122                 printk(KERN_CONT " DVD%s%s",
2123                                  (cdi->mask & CDC_DVD_R) ? "" : "-R",
2124                                  (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
2125
2126         if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
2127                 printk(KERN_CONT " CD%s%s",
2128                                  (cdi->mask & CDC_CD_R) ? "" : "-R",
2129                                  (cdi->mask & CDC_CD_RW) ? "" : "/RW");
2130
2131         if ((cdi->mask & CDC_SELECT_DISC) == 0)
2132                 printk(KERN_CONT " changer w/%d slots", nslots);
2133         else
2134                 printk(KERN_CONT " drive");
2135
2136         printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
2137
2138         return nslots;
2139 }
2140
2141 #ifdef CONFIG_IDE_PROC_FS
2142 static void ide_cdrom_add_settings(ide_drive_t *drive)
2143 {
2144         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
2145 }
2146 #else
2147 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
2148 #endif
2149
2150 /*
2151  * standard prep_rq_fn that builds 10 byte cmds
2152  */
2153 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
2154 {
2155         int hard_sect = queue_hardsect_size(q);
2156         long block = (long)rq->hard_sector / (hard_sect >> 9);
2157         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2158
2159         memset(rq->cmd, 0, sizeof(rq->cmd));
2160
2161         if (rq_data_dir(rq) == READ)
2162                 rq->cmd[0] = GPCMD_READ_10;
2163         else
2164                 rq->cmd[0] = GPCMD_WRITE_10;
2165
2166         /*
2167          * fill in lba
2168          */
2169         rq->cmd[2] = (block >> 24) & 0xff;
2170         rq->cmd[3] = (block >> 16) & 0xff;
2171         rq->cmd[4] = (block >>  8) & 0xff;
2172         rq->cmd[5] = block & 0xff;
2173
2174         /*
2175          * and transfer length
2176          */
2177         rq->cmd[7] = (blocks >> 8) & 0xff;
2178         rq->cmd[8] = blocks & 0xff;
2179         rq->cmd_len = 10;
2180         return BLKPREP_OK;
2181 }
2182
2183 /*
2184  * Most of the SCSI commands are supported directly by ATAPI devices.
2185  * This transform handles the few exceptions.
2186  */
2187 static int ide_cdrom_prep_pc(struct request *rq)
2188 {
2189         u8 *c = rq->cmd;
2190
2191         /*
2192          * Transform 6-byte read/write commands to the 10-byte version
2193          */
2194         if (c[0] == READ_6 || c[0] == WRITE_6) {
2195                 c[8] = c[4];
2196                 c[5] = c[3];
2197                 c[4] = c[2];
2198                 c[3] = c[1] & 0x1f;
2199                 c[2] = 0;
2200                 c[1] &= 0xe0;
2201                 c[0] += (READ_10 - READ_6);
2202                 rq->cmd_len = 10;
2203                 return BLKPREP_OK;
2204         }
2205
2206         /*
2207          * it's silly to pretend we understand 6-byte sense commands, just
2208          * reject with ILLEGAL_REQUEST and the caller should take the
2209          * appropriate action
2210          */
2211         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
2212                 rq->errors = ILLEGAL_REQUEST;
2213                 return BLKPREP_KILL;
2214         }
2215
2216         return BLKPREP_OK;
2217 }
2218
2219 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
2220 {
2221         if (blk_fs_request(rq))
2222                 return ide_cdrom_prep_fs(q, rq);
2223         else if (blk_pc_request(rq))
2224                 return ide_cdrom_prep_pc(rq);
2225
2226         return 0;
2227 }
2228
2229 struct cd_list_entry {
2230         const char      *id_model;
2231         const char      *id_firmware;
2232         unsigned int    cd_flags;
2233 };
2234
2235 static const struct cd_list_entry ide_cd_quirks_list[] = {
2236         /* Limit transfer size per interrupt. */
2237         { "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
2238         { "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
2239         /* SCR-3231 doesn't support the SET_CD_SPEED command. */
2240         { "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_CD_FLAG_NO_SPEED_SELECT    },
2241         /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
2242         { "NEC CD-ROM DRIVE:260",    "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
2243                                              IDE_CD_FLAG_PRE_ATAPI12,       },
2244         /* Vertos 300, some versions of this drive like to talk BCD. */
2245         { "V003S0DS",                NULL,   IDE_CD_FLAG_VERTOS_300_SSD,    },
2246         /* Vertos 600 ESD. */
2247         { "V006E0DS",                NULL,   IDE_CD_FLAG_VERTOS_600_ESD,    },
2248         /*
2249          * Sanyo 3 CD changer uses a non-standard command for CD changing
2250          * (by default standard ATAPI support for CD changers is used).
2251          */
2252         { "CD-ROM CDR-C3 G",         NULL,   IDE_CD_FLAG_SANYO_3CD          },
2253         { "CD-ROM CDR-C3G",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
2254         { "CD-ROM CDR_C36",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
2255         /* Stingray 8X CD-ROM. */
2256         { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
2257         /*
2258          * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
2259          * mode sense page capabilities size, but older drives break.
2260          */
2261         { "ATAPI CD ROM DRIVE 50X MAX", NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
2262         { "WPI CDS-32X",                NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
2263         /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
2264         { "",                        "241N", IDE_CD_FLAG_LE_SPEED_FIELDS    },
2265         /*
2266          * Some drives used by Apple don't advertise audio play
2267          * but they do support reading TOC & audio datas.
2268          */
2269         { "MATSHITADVD-ROM SR-8187", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2270         { "MATSHITADVD-ROM SR-8186", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2271         { "MATSHITADVD-ROM SR-8176", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2272         { "MATSHITADVD-ROM SR-8174", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2273         { NULL, NULL, 0 }
2274 };
2275
2276 static unsigned int ide_cd_flags(struct hd_driveid *id)
2277 {
2278         const struct cd_list_entry *cle = ide_cd_quirks_list;
2279
2280         while (cle->id_model) {
2281                 if (strcmp(cle->id_model, id->model) == 0 &&
2282                     (cle->id_firmware == NULL ||
2283                      strstr(id->fw_rev, cle->id_firmware)))
2284                         return cle->cd_flags;
2285                 cle++;
2286         }
2287
2288         return 0;
2289 }
2290
2291 static
2292 int ide_cdrom_setup (ide_drive_t *drive)
2293 {
2294         struct cdrom_info *cd = drive->driver_data;
2295         struct cdrom_device_info *cdi = &cd->devinfo;
2296         struct hd_driveid *id = drive->id;
2297         int nslots;
2298
2299         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
2300         blk_queue_dma_alignment(drive->queue, 31);
2301         drive->queue->unplug_delay = (1 * HZ) / 1000;
2302         if (!drive->queue->unplug_delay)
2303                 drive->queue->unplug_delay = 1;
2304
2305         drive->special.all      = 0;
2306
2307         cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
2308                        ide_cd_flags(id);
2309
2310         if ((id->config & 0x0060) == 0x20)
2311                 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
2312
2313         if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
2314             id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2315                 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
2316                                  IDE_CD_FLAG_TOCADDR_AS_BCD);
2317         else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
2318                  id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2319                 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
2320         else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
2321                 cdi->sanyo_slot = 3;    /* 3 => use CD in slot 0 */
2322
2323         nslots = ide_cdrom_probe_capabilities (drive);
2324
2325         /*
2326          * set correct block size
2327          */
2328         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
2329
2330         if (drive->autotune == IDE_TUNE_DEFAULT ||
2331             drive->autotune == IDE_TUNE_AUTO)
2332                 drive->dsc_overlap = (drive->next != drive);
2333
2334         if (ide_cdrom_register(drive, nslots)) {
2335                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
2336                 cd->devinfo.handle = NULL;
2337                 return 1;
2338         }
2339         ide_cdrom_add_settings(drive);
2340         return 0;
2341 }
2342
2343 #ifdef CONFIG_IDE_PROC_FS
2344 static
2345 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2346 {
2347         unsigned long capacity, sectors_per_frame;
2348
2349         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2350                 return 0;
2351
2352         return capacity * sectors_per_frame;
2353 }
2354 #endif
2355
2356 static void ide_cd_remove(ide_drive_t *drive)
2357 {
2358         struct cdrom_info *info = drive->driver_data;
2359
2360         ide_proc_unregister_driver(drive, info->driver);
2361
2362         del_gendisk(info->disk);
2363
2364         ide_cd_put(info);
2365 }
2366
2367 static void ide_cd_release(struct kref *kref)
2368 {
2369         struct cdrom_info *info = to_ide_cd(kref);
2370         struct cdrom_device_info *devinfo = &info->devinfo;
2371         ide_drive_t *drive = info->drive;
2372         struct gendisk *g = info->disk;
2373
2374         kfree(info->buffer);
2375         kfree(info->toc);
2376         if (devinfo->handle == drive && unregister_cdrom(devinfo))
2377                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2378                                 "driver.\n", __FUNCTION__, drive->name);
2379         drive->dsc_overlap = 0;
2380         drive->driver_data = NULL;
2381         blk_queue_prep_rq(drive->queue, NULL);
2382         g->private_data = NULL;
2383         put_disk(g);
2384         kfree(info);
2385 }
2386
2387 static int ide_cd_probe(ide_drive_t *);
2388
2389 #ifdef CONFIG_IDE_PROC_FS
2390 static int proc_idecd_read_capacity
2391         (char *page, char **start, off_t off, int count, int *eof, void *data)
2392 {
2393         ide_drive_t *drive = data;
2394         int len;
2395
2396         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2397         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2398 }
2399
2400 static ide_proc_entry_t idecd_proc[] = {
2401         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2402         { NULL, 0, NULL, NULL }
2403 };
2404 #endif
2405
2406 static ide_driver_t ide_cdrom_driver = {
2407         .gen_driver = {
2408                 .owner          = THIS_MODULE,
2409                 .name           = "ide-cdrom",
2410                 .bus            = &ide_bus_type,
2411         },
2412         .probe                  = ide_cd_probe,
2413         .remove                 = ide_cd_remove,
2414         .version                = IDECD_VERSION,
2415         .media                  = ide_cdrom,
2416         .supports_dsc_overlap   = 1,
2417         .do_request             = ide_do_rw_cdrom,
2418         .end_request            = ide_end_request,
2419         .error                  = __ide_error,
2420         .abort                  = __ide_abort,
2421 #ifdef CONFIG_IDE_PROC_FS
2422         .proc                   = idecd_proc,
2423 #endif
2424 };
2425
2426 static int idecd_open(struct inode * inode, struct file * file)
2427 {
2428         struct gendisk *disk = inode->i_bdev->bd_disk;
2429         struct cdrom_info *info;
2430         int rc = -ENOMEM;
2431
2432         if (!(info = ide_cd_get(disk)))
2433                 return -ENXIO;
2434
2435         if (!info->buffer)
2436                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2437
2438         if (info->buffer)
2439                 rc = cdrom_open(&info->devinfo, inode, file);
2440
2441         if (rc < 0)
2442                 ide_cd_put(info);
2443
2444         return rc;
2445 }
2446
2447 static int idecd_release(struct inode * inode, struct file * file)
2448 {
2449         struct gendisk *disk = inode->i_bdev->bd_disk;
2450         struct cdrom_info *info = ide_cd_g(disk);
2451
2452         cdrom_release (&info->devinfo, file);
2453
2454         ide_cd_put(info);
2455
2456         return 0;
2457 }
2458
2459 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2460 {
2461         struct packet_command cgc;
2462         char buffer[16];
2463         int stat;
2464         char spindown;
2465
2466         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2467                 return -EFAULT;
2468
2469         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2470
2471         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2472         if (stat)
2473                 return stat;
2474
2475         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2476         return cdrom_mode_select(cdi, &cgc);
2477 }
2478
2479 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2480 {
2481         struct packet_command cgc;
2482         char buffer[16];
2483         int stat;
2484         char spindown;
2485
2486         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2487
2488         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2489         if (stat)
2490                 return stat;
2491
2492         spindown = buffer[11] & 0x0f;
2493         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2494                 return -EFAULT;
2495         return 0;
2496 }
2497
2498 static int idecd_ioctl (struct inode *inode, struct file *file,
2499                         unsigned int cmd, unsigned long arg)
2500 {
2501         struct block_device *bdev = inode->i_bdev;
2502         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2503         int err;
2504
2505         switch (cmd) {
2506         case CDROMSETSPINDOWN:
2507                 return idecd_set_spindown(&info->devinfo, arg);
2508         case CDROMGETSPINDOWN:
2509                 return idecd_get_spindown(&info->devinfo, arg);
2510         default:
2511                 break;
2512         }
2513
2514         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
2515         if (err == -EINVAL)
2516                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2517
2518         return err;
2519 }
2520
2521 static int idecd_media_changed(struct gendisk *disk)
2522 {
2523         struct cdrom_info *info = ide_cd_g(disk);
2524         return cdrom_media_changed(&info->devinfo);
2525 }
2526
2527 static int idecd_revalidate_disk(struct gendisk *disk)
2528 {
2529         struct cdrom_info *info = ide_cd_g(disk);
2530         struct request_sense sense;
2531
2532         ide_cd_read_toc(info->drive, &sense);
2533
2534         return  0;
2535 }
2536
2537 static struct block_device_operations idecd_ops = {
2538         .owner          = THIS_MODULE,
2539         .open           = idecd_open,
2540         .release        = idecd_release,
2541         .ioctl          = idecd_ioctl,
2542         .media_changed  = idecd_media_changed,
2543         .revalidate_disk= idecd_revalidate_disk
2544 };
2545
2546 /* options */
2547 static char *ignore = NULL;
2548
2549 module_param(ignore, charp, 0400);
2550 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2551
2552 static int ide_cd_probe(ide_drive_t *drive)
2553 {
2554         struct cdrom_info *info;
2555         struct gendisk *g;
2556         struct request_sense sense;
2557
2558         if (!strstr("ide-cdrom", drive->driver_req))
2559                 goto failed;
2560         if (!drive->present)
2561                 goto failed;
2562         if (drive->media != ide_cdrom && drive->media != ide_optical)
2563                 goto failed;
2564         /* skip drives that we were told to ignore */
2565         if (ignore != NULL) {
2566                 if (strstr(ignore, drive->name)) {
2567                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2568                         goto failed;
2569                 }
2570         }
2571         if (drive->scsi) {
2572                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2573                 goto failed;
2574         }
2575         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
2576         if (info == NULL) {
2577                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
2578                 goto failed;
2579         }
2580
2581         g = alloc_disk(1 << PARTN_BITS);
2582         if (!g)
2583                 goto out_free_cd;
2584
2585         ide_init_disk(g, drive);
2586
2587         ide_proc_register_driver(drive, &ide_cdrom_driver);
2588
2589         kref_init(&info->kref);
2590
2591         info->drive = drive;
2592         info->driver = &ide_cdrom_driver;
2593         info->disk = g;
2594
2595         g->private_data = &info->driver;
2596
2597         drive->driver_data = info;
2598
2599         g->minors = 1;
2600         g->driverfs_dev = &drive->gendev;
2601         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
2602         if (ide_cdrom_setup(drive)) {
2603                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
2604                 ide_cd_release(&info->kref);
2605                 goto failed;
2606         }
2607
2608         ide_cd_read_toc(drive, &sense);
2609         g->fops = &idecd_ops;
2610         g->flags |= GENHD_FL_REMOVABLE;
2611         add_disk(g);
2612         return 0;
2613
2614 out_free_cd:
2615         kfree(info);
2616 failed:
2617         return -ENODEV;
2618 }
2619
2620 static void __exit ide_cdrom_exit(void)
2621 {
2622         driver_unregister(&ide_cdrom_driver.gen_driver);
2623 }
2624
2625 static int __init ide_cdrom_init(void)
2626 {
2627         return driver_register(&ide_cdrom_driver.gen_driver);
2628 }
2629
2630 MODULE_ALIAS("ide:*m-cdrom*");
2631 MODULE_ALIAS("ide-cd");
2632 module_init(ide_cdrom_init);
2633 module_exit(ide_cdrom_exit);
2634 MODULE_LICENSE("GPL");