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