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                 int blen = blen = rq->data_len;
1127                 char *ptr = rq->data;
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, sectors_to_transfer, 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         sectors_to_transfer = len / SECTOR_SIZE;
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                                    sectors_to_transfer);
1289
1290                 if (nskip > 0) {
1291                         ide_cd_drain_data(drive, nskip);
1292                         rq->current_nr_sectors -= nskip;
1293                         sectors_to_transfer -= nskip;
1294                 }
1295
1296                 xferfunc = HWIF(drive)->atapi_input_bytes;
1297         }
1298
1299         /*
1300          * now loop and read/write the data
1301          */
1302         while (sectors_to_transfer > 0) {
1303                 int this_transfer;
1304
1305                 if (!rq->current_nr_sectors) {
1306                         if (!write)
1307                                 /*
1308                                  * If the buffers are full, cache the rest
1309                                  * of the data in our internal buffer.
1310                                  */
1311                                 cdrom_buffer_sectors(drive, rq->sector,
1312                                                      sectors_to_transfer);
1313                         else
1314                                 printk(KERN_ERR "%s: %s: confused, missing "
1315                                                 "data\n",
1316                                                 drive->name, __FUNCTION__);
1317                         break;
1318                 }
1319
1320                 /*
1321                  * Figure out how many sectors we can transfer
1322                  */
1323                 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1324
1325                 while (this_transfer > 0) {
1326                         xferfunc(drive, rq->buffer, SECTOR_SIZE);
1327                         rq->buffer += SECTOR_SIZE;
1328                         --rq->nr_sectors;
1329                         --rq->current_nr_sectors;
1330                         ++rq->sector;
1331                         --this_transfer;
1332                         --sectors_to_transfer;
1333                 }
1334
1335                 /*
1336                  * current buffer complete, move on
1337                  */
1338                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1339                         cdrom_end_request(drive, 1);
1340         }
1341
1342         /* re-arm handler */
1343         ide_set_handler(drive, cdrom_rw_intr, ATAPI_WAIT_PC, NULL);
1344         return ide_started;
1345 }
1346
1347 static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
1348 {
1349         struct cdrom_info *cd = drive->driver_data;
1350         int write = rq_data_dir(rq) == WRITE;
1351         unsigned short sectors_per_frame =
1352                 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1353
1354         if (write) {
1355                 /*
1356                  * disk has become write protected
1357                  */
1358                 if (cd->disk->policy) {
1359                         cdrom_end_request(drive, 0);
1360                         return ide_stopped;
1361                 }
1362         } else {
1363                 /*
1364                  * We may be retrying this request after an error.  Fix up any
1365                  * weirdness which might be present in the request packet.
1366                  */
1367                 restore_request(rq);
1368
1369                 /* Satisfy whatever we can of this request from our cache. */
1370                 if (cdrom_read_from_buffer(drive))
1371                         return ide_stopped;
1372         }
1373
1374         /*
1375          * use DMA, if possible / writes *must* be hardware frame aligned
1376          */
1377         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1378             (rq->sector & (sectors_per_frame - 1))) {
1379                 if (write) {
1380                         cdrom_end_request(drive, 0);
1381                         return ide_stopped;
1382                 }
1383                 cd->dma = 0;
1384         } else
1385                 cd->dma = drive->using_dma;
1386
1387         /* Clear the local sector buffer. */
1388         cd->nsectors_buffered = 0;
1389
1390         if (write)
1391                 cd->devinfo.media_written = 1;
1392
1393         /* Start sending the read/write request to the drive. */
1394         return cdrom_start_packet_command(drive, 32768, cdrom_start_rw_cont);
1395 }
1396
1397 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1398 {
1399         struct request *rq = HWGROUP(drive)->rq;
1400
1401         if (!rq->timeout)
1402                 rq->timeout = ATAPI_WAIT_PC;
1403
1404         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1405 }
1406
1407 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1408 {
1409         struct cdrom_info *info = drive->driver_data;
1410
1411         if (blk_pc_request(rq))
1412                 rq->cmd_flags |= REQ_QUIET;
1413         else
1414                 rq->cmd_flags &= ~REQ_FAILED;
1415
1416         info->dma = 0;
1417
1418         /*
1419          * sg request
1420          */
1421         if (rq->bio) {
1422                 int mask = drive->queue->dma_alignment;
1423                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1424
1425                 info->dma = drive->using_dma;
1426
1427                 /*
1428                  * check if dma is safe
1429                  *
1430                  * NOTE! The "len" and "addr" checks should possibly have
1431                  * separate masks.
1432                  */
1433                 if ((rq->data_len & 15) || (addr & mask))
1434                         info->dma = 0;
1435         }
1436
1437         /* Start sending the command to the drive. */
1438         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1439 }
1440
1441 /****************************************************************************
1442  * cdrom driver request routine.
1443  */
1444 static ide_startstop_t
1445 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1446 {
1447         ide_startstop_t action;
1448         struct cdrom_info *info = drive->driver_data;
1449
1450         if (blk_fs_request(rq)) {
1451                 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1452                         unsigned long elapsed = jiffies - info->start_seek;
1453                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1454
1455                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1456                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1457                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1458                                         return ide_stopped;
1459                                 }
1460                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1461                         }
1462                         info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1463                 }
1464                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1465                         action = cdrom_start_seek(drive, block);
1466                 } else
1467                         action = cdrom_start_rw(drive, rq);
1468                 info->last_block = block;
1469                 return action;
1470         } else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1471                    rq->cmd_type == REQ_TYPE_ATA_PC) {
1472                 return cdrom_do_block_pc(drive, rq);
1473         } else if (blk_special_request(rq)) {
1474                 /*
1475                  * right now this can only be a reset...
1476                  */
1477                 cdrom_end_request(drive, 1);
1478                 return ide_stopped;
1479         }
1480
1481         blk_dump_rq_flags(rq, "ide-cd bad flags");
1482         cdrom_end_request(drive, 0);
1483         return ide_stopped;
1484 }
1485
1486
1487
1488 /****************************************************************************
1489  * Ioctl handling.
1490  *
1491  * Routines which queue packet commands take as a final argument a pointer
1492  * to a request_sense struct.  If execution of the command results
1493  * in an error with a CHECK CONDITION status, this structure will be filled
1494  * with the results of the subsequent request sense command.  The pointer
1495  * can also be NULL, in which case no sense information is returned.
1496  */
1497
1498 static
1499 void msf_from_bcd (struct atapi_msf *msf)
1500 {
1501         msf->minute = BCD2BIN(msf->minute);
1502         msf->second = BCD2BIN(msf->second);
1503         msf->frame  = BCD2BIN(msf->frame);
1504 }
1505
1506 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1507 {
1508         struct request req;
1509         struct cdrom_info *info = drive->driver_data;
1510         struct cdrom_device_info *cdi = &info->devinfo;
1511
1512         ide_cd_init_rq(drive, &req);
1513
1514         req.sense = sense;
1515         req.cmd[0] = GPCMD_TEST_UNIT_READY;
1516         req.cmd_flags |= REQ_QUIET;
1517
1518         /*
1519          * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1520          * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1521          */
1522         req.cmd[7] = cdi->sanyo_slot % 3;
1523
1524         return ide_cd_queue_pc(drive, &req);
1525 }
1526
1527 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1528 int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
1529                     struct request_sense *sense)
1530 {
1531         struct cdrom_info *cd = drive->driver_data;
1532         struct request_sense my_sense;
1533         struct request req;
1534         int stat;
1535
1536         if (sense == NULL)
1537                 sense = &my_sense;
1538
1539         /* If the drive cannot lock the door, just pretend. */
1540         if (cd->cd_flags & IDE_CD_FLAG_NO_DOORLOCK) {
1541                 stat = 0;
1542         } else {
1543                 ide_cd_init_rq(drive, &req);
1544                 req.sense = sense;
1545                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1546                 req.cmd[4] = lockflag ? 1 : 0;
1547                 stat = ide_cd_queue_pc(drive, &req);
1548         }
1549
1550         /* If we got an illegal field error, the drive
1551            probably cannot lock the door. */
1552         if (stat != 0 &&
1553             sense->sense_key == ILLEGAL_REQUEST &&
1554             (sense->asc == 0x24 || sense->asc == 0x20)) {
1555                 printk (KERN_ERR "%s: door locking not supported\n",
1556                         drive->name);
1557                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1558                 stat = 0;
1559         }
1560
1561         /* no medium, that's alright. */
1562         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
1563                 stat = 0;
1564
1565         if (stat == 0) {
1566                 if (lockflag)
1567                         cd->cd_flags |= IDE_CD_FLAG_DOOR_LOCKED;
1568                 else
1569                         cd->cd_flags &= ~IDE_CD_FLAG_DOOR_LOCKED;
1570         }
1571
1572         return stat;
1573 }
1574
1575
1576 /* Eject the disk if EJECTFLAG is 0.
1577    If EJECTFLAG is 1, try to reload the disk. */
1578 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
1579                        struct request_sense *sense)
1580 {
1581         struct cdrom_info *cd = drive->driver_data;
1582         struct cdrom_device_info *cdi = &cd->devinfo;
1583         struct request req;
1584         char loej = 0x02;
1585
1586         if ((cd->cd_flags & IDE_CD_FLAG_NO_EJECT) && !ejectflag)
1587                 return -EDRIVE_CANT_DO_THIS;
1588
1589         /* reload fails on some drives, if the tray is locked */
1590         if ((cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED) && ejectflag)
1591                 return 0;
1592
1593         ide_cd_init_rq(drive, &req);
1594
1595         /* only tell drive to close tray if open, if it can do that */
1596         if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
1597                 loej = 0;
1598
1599         req.sense = sense;
1600         req.cmd[0] = GPCMD_START_STOP_UNIT;
1601         req.cmd[4] = loej | (ejectflag != 0);
1602
1603         return ide_cd_queue_pc(drive, &req);
1604 }
1605
1606 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1607                                unsigned long *sectors_per_frame,
1608                                struct request_sense *sense)
1609 {
1610         struct {
1611                 __u32 lba;
1612                 __u32 blocklen;
1613         } capbuf;
1614
1615         int stat;
1616         struct request req;
1617
1618         ide_cd_init_rq(drive, &req);
1619
1620         req.sense = sense;
1621         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1622         req.data = (char *)&capbuf;
1623         req.data_len = sizeof(capbuf);
1624         req.cmd_flags |= REQ_QUIET;
1625
1626         stat = ide_cd_queue_pc(drive, &req);
1627         if (stat == 0) {
1628                 *capacity = 1 + be32_to_cpu(capbuf.lba);
1629                 *sectors_per_frame =
1630                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1631         }
1632
1633         return stat;
1634 }
1635
1636 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1637                                 int format, char *buf, int buflen,
1638                                 struct request_sense *sense)
1639 {
1640         struct request req;
1641
1642         ide_cd_init_rq(drive, &req);
1643
1644         req.sense = sense;
1645         req.data =  buf;
1646         req.data_len = buflen;
1647         req.cmd_flags |= REQ_QUIET;
1648         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1649         req.cmd[6] = trackno;
1650         req.cmd[7] = (buflen >> 8);
1651         req.cmd[8] = (buflen & 0xff);
1652         req.cmd[9] = (format << 6);
1653
1654         if (msf_flag)
1655                 req.cmd[1] = 2;
1656
1657         return ide_cd_queue_pc(drive, &req);
1658 }
1659
1660 /* Try to read the entire TOC for the disk into our internal buffer. */
1661 int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
1662 {
1663         int stat, ntracks, i;
1664         struct cdrom_info *info = drive->driver_data;
1665         struct cdrom_device_info *cdi = &info->devinfo;
1666         struct atapi_toc *toc = info->toc;
1667         struct {
1668                 struct atapi_toc_header hdr;
1669                 struct atapi_toc_entry  ent;
1670         } ms_tmp;
1671         long last_written;
1672         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1673
1674         if (toc == NULL) {
1675                 /* Try to allocate space. */
1676                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1677                 if (toc == NULL) {
1678                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1679                         return -ENOMEM;
1680                 }
1681                 info->toc = toc;
1682         }
1683
1684         /* Check to see if the existing data is still valid.
1685            If it is, just return. */
1686         (void) cdrom_check_status(drive, sense);
1687
1688         if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
1689                 return 0;
1690
1691         /* Try to get the total cdrom capacity and sector size. */
1692         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
1693                                    sense);
1694         if (stat)
1695                 toc->capacity = 0x1fffff;
1696
1697         set_capacity(info->disk, toc->capacity * sectors_per_frame);
1698         /* Save a private copy of te TOC capacity for error handling */
1699         drive->probed_capacity = toc->capacity * sectors_per_frame;
1700
1701         blk_queue_hardsect_size(drive->queue,
1702                                 sectors_per_frame << SECTOR_BITS);
1703
1704         /* First read just the header, so we know how long the TOC is. */
1705         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1706                                     sizeof(struct atapi_toc_header), sense);
1707         if (stat)
1708                 return stat;
1709
1710         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1711                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1712                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1713         }
1714
1715         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1716         if (ntracks <= 0)
1717                 return -EIO;
1718         if (ntracks > MAX_TRACKS)
1719                 ntracks = MAX_TRACKS;
1720
1721         /* Now read the whole schmeer. */
1722         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1723                                   (char *)&toc->hdr,
1724                                    sizeof(struct atapi_toc_header) +
1725                                    (ntracks + 1) *
1726                                    sizeof(struct atapi_toc_entry), sense);
1727
1728         if (stat && toc->hdr.first_track > 1) {
1729                 /* Cds with CDI tracks only don't have any TOC entries,
1730                    despite of this the returned values are
1731                    first_track == last_track = number of CDI tracks + 1,
1732                    so that this case is indistinguishable from the same
1733                    layout plus an additional audio track.
1734                    If we get an error for the regular case, we assume
1735                    a CDI without additional audio tracks. In this case
1736                    the readable TOC is empty (CDI tracks are not included)
1737                    and only holds the Leadout entry. Heiko Eißfeldt */
1738                 ntracks = 0;
1739                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1740                                            (char *)&toc->hdr,
1741                                            sizeof(struct atapi_toc_header) +
1742                                            (ntracks + 1) *
1743                                            sizeof(struct atapi_toc_entry),
1744                                            sense);
1745                 if (stat)
1746                         return stat;
1747
1748                 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1749                         toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1750                         toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
1751                 } else {
1752                         toc->hdr.first_track = CDROM_LEADOUT;
1753                         toc->hdr.last_track = CDROM_LEADOUT;
1754                 }
1755         }
1756
1757         if (stat)
1758                 return stat;
1759
1760         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1761
1762         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1763                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1764                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1765         }
1766
1767         for (i = 0; i <= ntracks; i++) {
1768                 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1769                         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
1770                                 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
1771                         msf_from_bcd(&toc->ent[i].addr.msf);
1772                 }
1773                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1774                                                    toc->ent[i].addr.msf.second,
1775                                                    toc->ent[i].addr.msf.frame);
1776         }
1777
1778         /* Read the multisession information. */
1779         if (toc->hdr.first_track != CDROM_LEADOUT) {
1780                 /* Read the multisession information. */
1781                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1782                                            sizeof(ms_tmp), sense);
1783                 if (stat)
1784                         return stat;
1785
1786                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1787         } else {
1788                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1789                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1790         }
1791
1792         if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1793                 /* Re-read multisession information using MSF format */
1794                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1795                                            sizeof(ms_tmp), sense);
1796                 if (stat)
1797                         return stat;
1798
1799                 msf_from_bcd (&ms_tmp.ent.addr.msf);
1800                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1801                                                    ms_tmp.ent.addr.msf.second,
1802                                                    ms_tmp.ent.addr.msf.frame);
1803         }
1804
1805         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1806
1807         /* Now try to get the total cdrom capacity. */
1808         stat = cdrom_get_last_written(cdi, &last_written);
1809         if (!stat && (last_written > toc->capacity)) {
1810                 toc->capacity = last_written;
1811                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
1812                 drive->probed_capacity = toc->capacity * sectors_per_frame;
1813         }
1814
1815         /* Remember that we've read this stuff. */
1816         info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
1817
1818         return 0;
1819 }
1820
1821 /* the generic packet interface to cdrom.c */
1822 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
1823                             struct packet_command *cgc)
1824 {
1825         struct request req;
1826         ide_drive_t *drive = cdi->handle;
1827
1828         if (cgc->timeout <= 0)
1829                 cgc->timeout = ATAPI_WAIT_PC;
1830
1831         /* here we queue the commands from the uniform CD-ROM
1832            layer. the packet must be complete, as we do not
1833            touch it at all. */
1834         ide_cd_init_rq(drive, &req);
1835         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
1836         if (cgc->sense)
1837                 memset(cgc->sense, 0, sizeof(struct request_sense));
1838         req.data = cgc->buffer;
1839         req.data_len = cgc->buflen;
1840         req.timeout = cgc->timeout;
1841
1842         if (cgc->quiet)
1843                 req.cmd_flags |= REQ_QUIET;
1844
1845         req.sense = cgc->sense;
1846         cgc->stat = ide_cd_queue_pc(drive, &req);
1847         if (!cgc->stat)
1848                 cgc->buflen -= req.data_len;
1849         return cgc->stat;
1850 }
1851
1852 static
1853 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
1854 {
1855         ide_drive_t *drive = cdi->handle;
1856         struct request_sense sense;
1857
1858         if (position) {
1859                 int stat = ide_cd_lockdoor(drive, 0, &sense);
1860
1861                 if (stat)
1862                         return stat;
1863         }
1864
1865         return cdrom_eject(drive, !position, &sense);
1866 }
1867
1868 int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
1869 {
1870         struct cdrom_info *info = drive->driver_data;
1871         struct cdrom_device_info *cdi = &info->devinfo;
1872         struct packet_command cgc;
1873         int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
1874
1875         if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
1876                 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
1877
1878         init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
1879         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
1880                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
1881                 if (!stat)
1882                         break;
1883         } while (--attempts);
1884         return stat;
1885 }
1886
1887 void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
1888 {
1889         struct cdrom_info *cd = drive->driver_data;
1890         u16 curspeed, maxspeed;
1891
1892         curspeed = *(u16 *)&buf[8 + 14];
1893         maxspeed = *(u16 *)&buf[8 +  8];
1894
1895         if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
1896                 curspeed = le16_to_cpu(curspeed);
1897                 maxspeed = le16_to_cpu(maxspeed);
1898         } else {
1899                 curspeed = be16_to_cpu(curspeed);
1900                 maxspeed = be16_to_cpu(maxspeed);
1901         }
1902
1903         cd->current_speed = (curspeed + (176/2)) / 176;
1904         cd->max_speed = (maxspeed + (176/2)) / 176;
1905 }
1906
1907 /*
1908  * add logic to try GET_EVENT command first to check for media and tray
1909  * status. this should be supported by newer cd-r/w and all DVD etc
1910  * drives
1911  */
1912 static
1913 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
1914 {
1915         ide_drive_t *drive = cdi->handle;
1916         struct media_event_desc med;
1917         struct request_sense sense;
1918         int stat;
1919
1920         if (slot_nr != CDSL_CURRENT)
1921                 return -EINVAL;
1922
1923         stat = cdrom_check_status(drive, &sense);
1924         if (!stat || sense.sense_key == UNIT_ATTENTION)
1925                 return CDS_DISC_OK;
1926
1927         if (!cdrom_get_media_event(cdi, &med)) {
1928                 if (med.media_present)
1929                         return CDS_DISC_OK;
1930                 else if (med.door_open)
1931                         return CDS_TRAY_OPEN;
1932                 else
1933                         return CDS_NO_DISC;
1934         }
1935
1936         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
1937                 return CDS_DISC_OK;
1938
1939         /*
1940          * If not using Mt Fuji extended media tray reports,
1941          * just return TRAY_OPEN since ATAPI doesn't provide
1942          * any other way to detect this...
1943          */
1944         if (sense.sense_key == NOT_READY) {
1945                 if (sense.asc == 0x3a && sense.ascq == 1)
1946                         return CDS_NO_DISC;
1947                 else
1948                         return CDS_TRAY_OPEN;
1949         }
1950         return CDS_DRIVE_NOT_READY;
1951 }
1952
1953 /****************************************************************************
1954  * Other driver requests (open, close, check media change).
1955  */
1956
1957 static
1958 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
1959                                        int slot_nr)
1960 {
1961         ide_drive_t *drive = cdi->handle;
1962         struct cdrom_info *cd = drive->driver_data;
1963         int retval;
1964
1965         if (slot_nr == CDSL_CURRENT) {
1966                 (void) cdrom_check_status(drive, NULL);
1967                 retval = (cd->cd_flags & IDE_CD_FLAG_MEDIA_CHANGED) ? 1 : 0;
1968                 cd->cd_flags &= ~IDE_CD_FLAG_MEDIA_CHANGED;
1969                 return retval;
1970         } else {
1971                 return -EINVAL;
1972         }
1973 }
1974
1975
1976 static
1977 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
1978 {
1979         return 0;
1980 }
1981
1982 /*
1983  * Close down the device.  Invalidate all cached blocks.
1984  */
1985
1986 static
1987 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
1988 {
1989         ide_drive_t *drive = cdi->handle;
1990         struct cdrom_info *cd = drive->driver_data;
1991
1992         if (!cdi->use_count)
1993                 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
1994 }
1995
1996 #define IDE_CD_CAPABILITIES \
1997         (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
1998          CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
1999          CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2000          CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2001          CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
2002
2003 static struct cdrom_device_ops ide_cdrom_dops = {
2004         .open                   = ide_cdrom_open_real,
2005         .release                = ide_cdrom_release_real,
2006         .drive_status           = ide_cdrom_drive_status,
2007         .media_changed          = ide_cdrom_check_media_change_real,
2008         .tray_move              = ide_cdrom_tray_move,
2009         .lock_door              = ide_cdrom_lock_door,
2010         .select_speed           = ide_cdrom_select_speed,
2011         .get_last_session       = ide_cdrom_get_last_session,
2012         .get_mcn                = ide_cdrom_get_mcn,
2013         .reset                  = ide_cdrom_reset,
2014         .audio_ioctl            = ide_cdrom_audio_ioctl,
2015         .capability             = IDE_CD_CAPABILITIES,
2016         .generic_packet         = ide_cdrom_packet,
2017 };
2018
2019 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2020 {
2021         struct cdrom_info *info = drive->driver_data;
2022         struct cdrom_device_info *devinfo = &info->devinfo;
2023
2024         devinfo->ops = &ide_cdrom_dops;
2025         devinfo->speed = info->current_speed;
2026         devinfo->capacity = nslots;
2027         devinfo->handle = drive;
2028         strcpy(devinfo->name, drive->name);
2029
2030         if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
2031                 devinfo->mask |= CDC_SELECT_SPEED;
2032
2033         devinfo->disk = info->disk;
2034         return register_cdrom(devinfo);
2035 }
2036
2037 static
2038 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2039 {
2040         struct cdrom_info *cd = drive->driver_data;
2041         struct cdrom_device_info *cdi = &cd->devinfo;
2042         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2043         mechtype_t mechtype;
2044         int nslots = 1;
2045
2046         cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
2047                      CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
2048                      CDC_MO_DRIVE | CDC_RAM);
2049
2050         if (drive->media == ide_optical) {
2051                 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
2052                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2053                 return nslots;
2054         }
2055
2056         if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
2057                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2058                 cdi->mask &= ~CDC_PLAY_AUDIO;
2059                 return nslots;
2060         }
2061
2062         /*
2063          * we have to cheat a little here. the packet will eventually
2064          * be queued with ide_cdrom_packet(), which extracts the
2065          * drive from cdi->handle. Since this device hasn't been
2066          * registered with the Uniform layer yet, it can't do this.
2067          * Same goes for cdi->ops.
2068          */
2069         cdi->handle = drive;
2070         cdi->ops = &ide_cdrom_dops;
2071
2072         if (ide_cdrom_get_capabilities(drive, buf))
2073                 return 0;
2074
2075         if ((buf[8 + 6] & 0x01) == 0)
2076                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
2077         if (buf[8 + 6] & 0x08)
2078                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2079         if (buf[8 + 3] & 0x01)
2080                 cdi->mask &= ~CDC_CD_R;
2081         if (buf[8 + 3] & 0x02)
2082                 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
2083         if (buf[8 + 2] & 0x38)
2084                 cdi->mask &= ~CDC_DVD;
2085         if (buf[8 + 3] & 0x20)
2086                 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
2087         if (buf[8 + 3] & 0x10)
2088                 cdi->mask &= ~CDC_DVD_R;
2089         if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
2090                 cdi->mask &= ~CDC_PLAY_AUDIO;
2091
2092         mechtype = buf[8 + 6] >> 5;
2093         if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
2094                 cdi->mask |= CDC_CLOSE_TRAY;
2095
2096         if (cdi->sanyo_slot > 0) {
2097                 cdi->mask &= ~CDC_SELECT_DISC;
2098                 nslots = 3;
2099         } else if (mechtype == mechtype_individual_changer ||
2100                    mechtype == mechtype_cartridge_changer) {
2101                 nslots = cdrom_number_of_slots(cdi);
2102                 if (nslots > 1)
2103                         cdi->mask &= ~CDC_SELECT_DISC;
2104         }
2105
2106         ide_cdrom_update_speed(drive, buf);
2107
2108         printk(KERN_INFO "%s: ATAPI", drive->name);
2109
2110         /* don't print speed if the drive reported 0 */
2111         if (cd->max_speed)
2112                 printk(KERN_CONT " %dX", cd->max_speed);
2113
2114         printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
2115
2116         if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
2117                 printk(KERN_CONT " DVD%s%s",
2118                                  (cdi->mask & CDC_DVD_R) ? "" : "-R",
2119                                  (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
2120
2121         if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
2122                 printk(KERN_CONT " CD%s%s",
2123                                  (cdi->mask & CDC_CD_R) ? "" : "-R",
2124                                  (cdi->mask & CDC_CD_RW) ? "" : "/RW");
2125
2126         if ((cdi->mask & CDC_SELECT_DISC) == 0)
2127                 printk(KERN_CONT " changer w/%d slots", nslots);
2128         else
2129                 printk(KERN_CONT " drive");
2130
2131         printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
2132
2133         return nslots;
2134 }
2135
2136 #ifdef CONFIG_IDE_PROC_FS
2137 static void ide_cdrom_add_settings(ide_drive_t *drive)
2138 {
2139         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
2140 }
2141 #else
2142 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
2143 #endif
2144
2145 /*
2146  * standard prep_rq_fn that builds 10 byte cmds
2147  */
2148 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
2149 {
2150         int hard_sect = queue_hardsect_size(q);
2151         long block = (long)rq->hard_sector / (hard_sect >> 9);
2152         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2153
2154         memset(rq->cmd, 0, sizeof(rq->cmd));
2155
2156         if (rq_data_dir(rq) == READ)
2157                 rq->cmd[0] = GPCMD_READ_10;
2158         else
2159                 rq->cmd[0] = GPCMD_WRITE_10;
2160
2161         /*
2162          * fill in lba
2163          */
2164         rq->cmd[2] = (block >> 24) & 0xff;
2165         rq->cmd[3] = (block >> 16) & 0xff;
2166         rq->cmd[4] = (block >>  8) & 0xff;
2167         rq->cmd[5] = block & 0xff;
2168
2169         /*
2170          * and transfer length
2171          */
2172         rq->cmd[7] = (blocks >> 8) & 0xff;
2173         rq->cmd[8] = blocks & 0xff;
2174         rq->cmd_len = 10;
2175         return BLKPREP_OK;
2176 }
2177
2178 /*
2179  * Most of the SCSI commands are supported directly by ATAPI devices.
2180  * This transform handles the few exceptions.
2181  */
2182 static int ide_cdrom_prep_pc(struct request *rq)
2183 {
2184         u8 *c = rq->cmd;
2185
2186         /*
2187          * Transform 6-byte read/write commands to the 10-byte version
2188          */
2189         if (c[0] == READ_6 || c[0] == WRITE_6) {
2190                 c[8] = c[4];
2191                 c[5] = c[3];
2192                 c[4] = c[2];
2193                 c[3] = c[1] & 0x1f;
2194                 c[2] = 0;
2195                 c[1] &= 0xe0;
2196                 c[0] += (READ_10 - READ_6);
2197                 rq->cmd_len = 10;
2198                 return BLKPREP_OK;
2199         }
2200
2201         /*
2202          * it's silly to pretend we understand 6-byte sense commands, just
2203          * reject with ILLEGAL_REQUEST and the caller should take the
2204          * appropriate action
2205          */
2206         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
2207                 rq->errors = ILLEGAL_REQUEST;
2208                 return BLKPREP_KILL;
2209         }
2210
2211         return BLKPREP_OK;
2212 }
2213
2214 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
2215 {
2216         if (blk_fs_request(rq))
2217                 return ide_cdrom_prep_fs(q, rq);
2218         else if (blk_pc_request(rq))
2219                 return ide_cdrom_prep_pc(rq);
2220
2221         return 0;
2222 }
2223
2224 struct cd_list_entry {
2225         const char      *id_model;
2226         const char      *id_firmware;
2227         unsigned int    cd_flags;
2228 };
2229
2230 static const struct cd_list_entry ide_cd_quirks_list[] = {
2231         /* Limit transfer size per interrupt. */
2232         { "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
2233         { "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
2234         /* SCR-3231 doesn't support the SET_CD_SPEED command. */
2235         { "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_CD_FLAG_NO_SPEED_SELECT    },
2236         /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
2237         { "NEC CD-ROM DRIVE:260",    "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
2238                                              IDE_CD_FLAG_PRE_ATAPI12,       },
2239         /* Vertos 300, some versions of this drive like to talk BCD. */
2240         { "V003S0DS",                NULL,   IDE_CD_FLAG_VERTOS_300_SSD,    },
2241         /* Vertos 600 ESD. */
2242         { "V006E0DS",                NULL,   IDE_CD_FLAG_VERTOS_600_ESD,    },
2243         /*
2244          * Sanyo 3 CD changer uses a non-standard command for CD changing
2245          * (by default standard ATAPI support for CD changers is used).
2246          */
2247         { "CD-ROM CDR-C3 G",         NULL,   IDE_CD_FLAG_SANYO_3CD          },
2248         { "CD-ROM CDR-C3G",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
2249         { "CD-ROM CDR_C36",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
2250         /* Stingray 8X CD-ROM. */
2251         { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
2252         /*
2253          * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
2254          * mode sense page capabilities size, but older drives break.
2255          */
2256         { "ATAPI CD ROM DRIVE 50X MAX", NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
2257         { "WPI CDS-32X",                NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
2258         /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
2259         { "",                        "241N", IDE_CD_FLAG_LE_SPEED_FIELDS    },
2260         /*
2261          * Some drives used by Apple don't advertise audio play
2262          * but they do support reading TOC & audio datas.
2263          */
2264         { "MATSHITADVD-ROM SR-8187", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2265         { "MATSHITADVD-ROM SR-8186", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2266         { "MATSHITADVD-ROM SR-8176", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2267         { "MATSHITADVD-ROM SR-8174", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2268         { NULL, NULL, 0 }
2269 };
2270
2271 static unsigned int ide_cd_flags(struct hd_driveid *id)
2272 {
2273         const struct cd_list_entry *cle = ide_cd_quirks_list;
2274
2275         while (cle->id_model) {
2276                 if (strcmp(cle->id_model, id->model) == 0 &&
2277                     (cle->id_firmware == NULL ||
2278                      strstr(id->fw_rev, cle->id_firmware)))
2279                         return cle->cd_flags;
2280                 cle++;
2281         }
2282
2283         return 0;
2284 }
2285
2286 static
2287 int ide_cdrom_setup (ide_drive_t *drive)
2288 {
2289         struct cdrom_info *cd = drive->driver_data;
2290         struct cdrom_device_info *cdi = &cd->devinfo;
2291         struct hd_driveid *id = drive->id;
2292         int nslots;
2293
2294         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
2295         blk_queue_dma_alignment(drive->queue, 31);
2296         drive->queue->unplug_delay = (1 * HZ) / 1000;
2297         if (!drive->queue->unplug_delay)
2298                 drive->queue->unplug_delay = 1;
2299
2300         drive->special.all      = 0;
2301
2302         cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
2303                        ide_cd_flags(id);
2304
2305         if ((id->config & 0x0060) == 0x20)
2306                 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
2307
2308         if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
2309             id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2310                 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
2311                                  IDE_CD_FLAG_TOCADDR_AS_BCD);
2312         else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
2313                  id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2314                 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
2315         else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
2316                 cdi->sanyo_slot = 3;    /* 3 => use CD in slot 0 */
2317
2318         nslots = ide_cdrom_probe_capabilities (drive);
2319
2320         /*
2321          * set correct block size
2322          */
2323         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
2324
2325         if (drive->autotune == IDE_TUNE_DEFAULT ||
2326             drive->autotune == IDE_TUNE_AUTO)
2327                 drive->dsc_overlap = (drive->next != drive);
2328
2329         if (ide_cdrom_register(drive, nslots)) {
2330                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
2331                 cd->devinfo.handle = NULL;
2332                 return 1;
2333         }
2334         ide_cdrom_add_settings(drive);
2335         return 0;
2336 }
2337
2338 #ifdef CONFIG_IDE_PROC_FS
2339 static
2340 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2341 {
2342         unsigned long capacity, sectors_per_frame;
2343
2344         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2345                 return 0;
2346
2347         return capacity * sectors_per_frame;
2348 }
2349 #endif
2350
2351 static void ide_cd_remove(ide_drive_t *drive)
2352 {
2353         struct cdrom_info *info = drive->driver_data;
2354
2355         ide_proc_unregister_driver(drive, info->driver);
2356
2357         del_gendisk(info->disk);
2358
2359         ide_cd_put(info);
2360 }
2361
2362 static void ide_cd_release(struct kref *kref)
2363 {
2364         struct cdrom_info *info = to_ide_cd(kref);
2365         struct cdrom_device_info *devinfo = &info->devinfo;
2366         ide_drive_t *drive = info->drive;
2367         struct gendisk *g = info->disk;
2368
2369         kfree(info->buffer);
2370         kfree(info->toc);
2371         if (devinfo->handle == drive && unregister_cdrom(devinfo))
2372                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2373                                 "driver.\n", __FUNCTION__, drive->name);
2374         drive->dsc_overlap = 0;
2375         drive->driver_data = NULL;
2376         blk_queue_prep_rq(drive->queue, NULL);
2377         g->private_data = NULL;
2378         put_disk(g);
2379         kfree(info);
2380 }
2381
2382 static int ide_cd_probe(ide_drive_t *);
2383
2384 #ifdef CONFIG_IDE_PROC_FS
2385 static int proc_idecd_read_capacity
2386         (char *page, char **start, off_t off, int count, int *eof, void *data)
2387 {
2388         ide_drive_t *drive = data;
2389         int len;
2390
2391         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2392         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2393 }
2394
2395 static ide_proc_entry_t idecd_proc[] = {
2396         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2397         { NULL, 0, NULL, NULL }
2398 };
2399 #endif
2400
2401 static ide_driver_t ide_cdrom_driver = {
2402         .gen_driver = {
2403                 .owner          = THIS_MODULE,
2404                 .name           = "ide-cdrom",
2405                 .bus            = &ide_bus_type,
2406         },
2407         .probe                  = ide_cd_probe,
2408         .remove                 = ide_cd_remove,
2409         .version                = IDECD_VERSION,
2410         .media                  = ide_cdrom,
2411         .supports_dsc_overlap   = 1,
2412         .do_request             = ide_do_rw_cdrom,
2413         .end_request            = ide_end_request,
2414         .error                  = __ide_error,
2415         .abort                  = __ide_abort,
2416 #ifdef CONFIG_IDE_PROC_FS
2417         .proc                   = idecd_proc,
2418 #endif
2419 };
2420
2421 static int idecd_open(struct inode * inode, struct file * file)
2422 {
2423         struct gendisk *disk = inode->i_bdev->bd_disk;
2424         struct cdrom_info *info;
2425         int rc = -ENOMEM;
2426
2427         if (!(info = ide_cd_get(disk)))
2428                 return -ENXIO;
2429
2430         if (!info->buffer)
2431                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2432
2433         if (info->buffer)
2434                 rc = cdrom_open(&info->devinfo, inode, file);
2435
2436         if (rc < 0)
2437                 ide_cd_put(info);
2438
2439         return rc;
2440 }
2441
2442 static int idecd_release(struct inode * inode, struct file * file)
2443 {
2444         struct gendisk *disk = inode->i_bdev->bd_disk;
2445         struct cdrom_info *info = ide_cd_g(disk);
2446
2447         cdrom_release (&info->devinfo, file);
2448
2449         ide_cd_put(info);
2450
2451         return 0;
2452 }
2453
2454 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2455 {
2456         struct packet_command cgc;
2457         char buffer[16];
2458         int stat;
2459         char spindown;
2460
2461         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2462                 return -EFAULT;
2463
2464         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2465
2466         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2467         if (stat)
2468                 return stat;
2469
2470         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2471         return cdrom_mode_select(cdi, &cgc);
2472 }
2473
2474 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2475 {
2476         struct packet_command cgc;
2477         char buffer[16];
2478         int stat;
2479         char spindown;
2480
2481         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2482
2483         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2484         if (stat)
2485                 return stat;
2486
2487         spindown = buffer[11] & 0x0f;
2488         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2489                 return -EFAULT;
2490         return 0;
2491 }
2492
2493 static int idecd_ioctl (struct inode *inode, struct file *file,
2494                         unsigned int cmd, unsigned long arg)
2495 {
2496         struct block_device *bdev = inode->i_bdev;
2497         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2498         int err;
2499
2500         switch (cmd) {
2501         case CDROMSETSPINDOWN:
2502                 return idecd_set_spindown(&info->devinfo, arg);
2503         case CDROMGETSPINDOWN:
2504                 return idecd_get_spindown(&info->devinfo, arg);
2505         default:
2506                 break;
2507         }
2508
2509         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
2510         if (err == -EINVAL)
2511                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2512
2513         return err;
2514 }
2515
2516 static int idecd_media_changed(struct gendisk *disk)
2517 {
2518         struct cdrom_info *info = ide_cd_g(disk);
2519         return cdrom_media_changed(&info->devinfo);
2520 }
2521
2522 static int idecd_revalidate_disk(struct gendisk *disk)
2523 {
2524         struct cdrom_info *info = ide_cd_g(disk);
2525         struct request_sense sense;
2526
2527         ide_cd_read_toc(info->drive, &sense);
2528
2529         return  0;
2530 }
2531
2532 static struct block_device_operations idecd_ops = {
2533         .owner          = THIS_MODULE,
2534         .open           = idecd_open,
2535         .release        = idecd_release,
2536         .ioctl          = idecd_ioctl,
2537         .media_changed  = idecd_media_changed,
2538         .revalidate_disk= idecd_revalidate_disk
2539 };
2540
2541 /* options */
2542 static char *ignore = NULL;
2543
2544 module_param(ignore, charp, 0400);
2545 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2546
2547 static int ide_cd_probe(ide_drive_t *drive)
2548 {
2549         struct cdrom_info *info;
2550         struct gendisk *g;
2551         struct request_sense sense;
2552
2553         if (!strstr("ide-cdrom", drive->driver_req))
2554                 goto failed;
2555         if (!drive->present)
2556                 goto failed;
2557         if (drive->media != ide_cdrom && drive->media != ide_optical)
2558                 goto failed;
2559         /* skip drives that we were told to ignore */
2560         if (ignore != NULL) {
2561                 if (strstr(ignore, drive->name)) {
2562                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2563                         goto failed;
2564                 }
2565         }
2566         if (drive->scsi) {
2567                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2568                 goto failed;
2569         }
2570         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
2571         if (info == NULL) {
2572                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
2573                 goto failed;
2574         }
2575
2576         g = alloc_disk(1 << PARTN_BITS);
2577         if (!g)
2578                 goto out_free_cd;
2579
2580         ide_init_disk(g, drive);
2581
2582         ide_proc_register_driver(drive, &ide_cdrom_driver);
2583
2584         kref_init(&info->kref);
2585
2586         info->drive = drive;
2587         info->driver = &ide_cdrom_driver;
2588         info->disk = g;
2589
2590         g->private_data = &info->driver;
2591
2592         drive->driver_data = info;
2593
2594         g->minors = 1;
2595         g->driverfs_dev = &drive->gendev;
2596         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
2597         if (ide_cdrom_setup(drive)) {
2598                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
2599                 ide_cd_release(&info->kref);
2600                 goto failed;
2601         }
2602
2603         ide_cd_read_toc(drive, &sense);
2604         g->fops = &idecd_ops;
2605         g->flags |= GENHD_FL_REMOVABLE;
2606         add_disk(g);
2607         return 0;
2608
2609 out_free_cd:
2610         kfree(info);
2611 failed:
2612         return -ENODEV;
2613 }
2614
2615 static void __exit ide_cdrom_exit(void)
2616 {
2617         driver_unregister(&ide_cdrom_driver.gen_driver);
2618 }
2619
2620 static int __init ide_cdrom_init(void)
2621 {
2622         return driver_register(&ide_cdrom_driver.gen_driver);
2623 }
2624
2625 MODULE_ALIAS("ide:*m-cdrom*");
2626 MODULE_ALIAS("ide-cd");
2627 module_init(ide_cdrom_init);
2628 module_exit(ide_cdrom_exit);
2629 MODULE_LICENSE("GPL");