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 static 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 /*
 630  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
 631  * buffer.  Once the first sector is added, any subsequent sectors are
 632  * assumed to be continuous (until the buffer is cleared).  For the first
 633  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
 634  * the buffer is cleared.)
 635  */
 636 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
 637                                   int sectors_to_transfer)
 638 {
 639         struct cdrom_info *info = drive->driver_data;
 640
 641         /* Number of sectors to read into the buffer. */
 642         int sectors_to_buffer = min_t(int, sectors_to_transfer,
 643                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
 644                                        info->nsectors_buffered);
 645
 646         char *dest;
 647
 648         /* If we couldn't get a buffer, don't try to buffer anything... */
 649         if (info->buffer == NULL)
 650                 sectors_to_buffer = 0;
 651
 652         /* If this is the first sector in the buffer, remember its number. */
 653         if (info->nsectors_buffered == 0)
 654                 info->sector_buffered = sector;
 655
 656         /* Read the data into the buffer. */
 657         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
 658         while (sectors_to_buffer > 0) {
 659                 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
 660                 --sectors_to_buffer;
 661                 --sectors_to_transfer;
 662                 ++info->nsectors_buffered;
 663                 dest += SECTOR_SIZE;
 664         }
 665
 666         /* Throw away any remaining data. */
 667         while (sectors_to_transfer > 0) {
 668                 static char dum[SECTOR_SIZE];
 669                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
 670                 --sectors_to_transfer;
 671         }
 672 }
 673
 674 /*
 675  * Check the contents of the interrupt reason register from the cdrom
 676  * and attempt to recover if there are problems.  Returns  0 if everything's
 677  * ok; nonzero if the request has been terminated.
 678  */
 679 static
 680 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
 681 {
 682         if (ireason == 2)
 683                 return 0;
 684         else if (ireason == 0) {
 685                 ide_hwif_t *hwif = drive->hwif;
 686
 687                 /* Whoops... The drive is expecting to receive data from us! */
 688                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
 689                                 drive->name, __FUNCTION__);
 690
 691                 /* Throw some data at the drive so it doesn't hang
 692                    and quit this request. */
 693                 ide_cd_pad_transfer(drive, hwif->atapi_output_bytes, len);
 694         } else  if (ireason == 1) {
 695                 /* Some drives (ASUS) seem to tell us that status
 696                  * info is available. just get it and ignore.
 697                  */
 698                 (void) HWIF(drive)->INB(IDE_STATUS_REG);
 699                 return 0;
 700         } else {
 701                 /* Drive wants a command packet, or invalid ireason... */
 702                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
 703                                 drive->name, __FUNCTION__, ireason);
 704         }
 705
 706         cdrom_end_request(drive, 0);
 707         return -1;
 708 }
 709
 710 /*
 711  * Interrupt routine.  Called when a read request has completed.
 712  */
 713 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
 714 {
 715         int stat;
 716         int ireason, len, sectors_to_transfer, nskip;
 717         struct cdrom_info *info = drive->driver_data;
 718         u8 lowcyl = 0, highcyl = 0;
 719         int dma = info->dma, dma_error = 0;
 720
 721         struct request *rq = HWGROUP(drive)->rq;
 722
 723         /*
 724          * handle dma case
 725          */
 726         if (dma) {
 727                 info->dma = 0;
 728                 dma_error = HWIF(drive)->ide_dma_end(drive);
 729                 if (dma_error) {
 730                         printk(KERN_ERR "%s: DMA read error\n", drive->name);
 731                         ide_dma_off(drive);
 732                 }
 733         }
 734
 735         if (cdrom_decode_status(drive, 0, &stat))
 736                 return ide_stopped;
 737
 738         if (dma) {
 739                 if (!dma_error) {
 740                         ide_end_request(drive, 1, rq->nr_sectors);
 741                         return ide_stopped;
 742                 } else
 743                         return ide_error(drive, "dma error", stat);
 744         }
 745
 746         /* Read the interrupt reason and the transfer length. */
 747         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
 748         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
 749         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
 750
 751         len = lowcyl + (256 * highcyl);
 752
 753         /* If DRQ is clear, the command has completed. */
 754         if ((stat & DRQ_STAT) == 0) {
 755                 /* If we're not done filling the current buffer, complain.
 756                    Otherwise, complete the command normally. */
 757                 if (rq->current_nr_sectors > 0) {
 758                         printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
 759                                 drive->name, rq->current_nr_sectors);
 760                         rq->cmd_flags |= REQ_FAILED;
 761                         cdrom_end_request(drive, 0);
 762                 } else
 763                         cdrom_end_request(drive, 1);
 764                 return ide_stopped;
 765         }
 766
 767         /* Check that the drive is expecting to do the same thing we are. */
 768         if (cdrom_read_check_ireason (drive, len, ireason))
 769                 return ide_stopped;
 770
 771         /* Assume that the drive will always provide data in multiples
 772            of at least SECTOR_SIZE, as it gets hairy to keep track
 773            of the transfers otherwise. */
 774         if ((len % SECTOR_SIZE) != 0) {
 775                 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
 776                         drive->name, len);
 777                 if (info->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
 778                         printk (KERN_ERR "  This drive is not supported by this version of the driver\n");
 779                 else {
 780                         printk (KERN_ERR "  Trying to limit transfer sizes\n");
 781                         info->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
 782                 }
 783                 cdrom_end_request(drive, 0);
 784                 return ide_stopped;
 785         }
 786
 787         /* The number of sectors we need to read from the drive. */
 788         sectors_to_transfer = len / SECTOR_SIZE;
 789
 790         /* First, figure out if we need to bit-bucket
 791            any of the leading sectors. */
 792         nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
 793
 794         while (nskip > 0) {
 795                 /* We need to throw away a sector. */
 796                 static char dum[SECTOR_SIZE];
 797                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
 798
 799                 --rq->current_nr_sectors;
 800                 --nskip;
 801                 --sectors_to_transfer;
 802         }
 803
 804         /* Now loop while we still have data to read from the drive. */
 805         while (sectors_to_transfer > 0) {
 806                 int this_transfer;
 807
 808                 /* If we've filled the present buffer but there's another
 809                    chained buffer after it, move on. */
 810                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
 811                         cdrom_end_request(drive, 1);
 812
 813                 /* If the buffers are full, cache the rest of the data in our
 814                    internal buffer. */
 815                 if (rq->current_nr_sectors == 0) {
 816                         cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
 817                         sectors_to_transfer = 0;
 818                 } else {
 819                         /* Transfer data to the buffers.
 820                            Figure out how many sectors we can transfer
 821                            to the current buffer. */
 822                         this_transfer = min_t(int, sectors_to_transfer,
 823                                              rq->current_nr_sectors);
 824
 825                         /* Read this_transfer sectors
 826                            into the current buffer. */
 827                         while (this_transfer > 0) {
 828                                 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
 829                                 rq->buffer += SECTOR_SIZE;
 830                                 --rq->nr_sectors;
 831                                 --rq->current_nr_sectors;
 832                                 ++rq->sector;
 833                                 --this_transfer;
 834                                 --sectors_to_transfer;
 835                         }
 836                 }
 837         }
 838
 839         /* Done moving data!  Wait for another interrupt. */
 840         ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
 841         return ide_started;
 842 }
 843
 844 /*
 845  * Try to satisfy some of the current read request from our cached data.
 846  * Returns nonzero if the request has been completed, zero otherwise.
 847  */
 848 static int cdrom_read_from_buffer (ide_drive_t *drive)
 849 {
 850         struct cdrom_info *info = drive->driver_data;
 851         struct request *rq = HWGROUP(drive)->rq;
 852         unsigned short sectors_per_frame;
 853
 854         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
 855
 856         /* Can't do anything if there's no buffer. */
 857         if (info->buffer == NULL) return 0;
 858
 859         /* Loop while this request needs data and the next block is present
 860            in our cache. */
 861         while (rq->nr_sectors > 0 &&
 862                rq->sector >= info->sector_buffered &&
 863                rq->sector < info->sector_buffered + info->nsectors_buffered) {
 864                 if (rq->current_nr_sectors == 0)
 865                         cdrom_end_request(drive, 1);
 866
 867                 memcpy (rq->buffer,
 868                         info->buffer +
 869                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
 870                         SECTOR_SIZE);
 871                 rq->buffer += SECTOR_SIZE;
 872                 --rq->current_nr_sectors;
 873                 --rq->nr_sectors;
 874                 ++rq->sector;
 875         }
 876
 877         /* If we've satisfied the current request,
 878            terminate it successfully. */
 879         if (rq->nr_sectors == 0) {
 880                 cdrom_end_request(drive, 1);
 881                 return -1;
 882         }
 883
 884         /* Move on to the next buffer if needed. */
 885         if (rq->current_nr_sectors == 0)
 886                 cdrom_end_request(drive, 1);
 887
 888         /* If this condition does not hold, then the kluge i use to
 889            represent the number of sectors to skip at the start of a transfer
 890            will fail.  I think that this will never happen, but let's be
 891            paranoid and check. */
 892         if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
 893             (rq->sector & (sectors_per_frame - 1))) {
 894                 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
 895                         drive->name, (long)rq->sector);
 896                 cdrom_end_request(drive, 0);
 897                 return -1;
 898         }
 899
 900         return 0;
 901 }
 902
 903 /*
 904  * Routine to send a read packet command to the drive.
 905  * This is usually called directly from cdrom_start_read.
 906  * However, for drq_interrupt devices, it is called from an interrupt
 907  * when the drive is ready to accept the command.
 908  */
 909 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
 910 {
 911         struct request *rq = HWGROUP(drive)->rq;
 912         unsigned short sectors_per_frame;
 913         int nskip;
 914
 915         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
 916
 917         /* If the requested sector doesn't start on a cdrom block boundary,
 918            we must adjust the start of the transfer so that it does,
 919            and remember to skip the first few sectors.
 920            If the CURRENT_NR_SECTORS field is larger than the size
 921            of the buffer, it will mean that we're to skip a number
 922            of sectors equal to the amount by which CURRENT_NR_SECTORS
 923            is larger than the buffer size. */
 924         nskip = rq->sector & (sectors_per_frame - 1);
 925         if (nskip > 0) {
 926                 /* Sanity check... */
 927                 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
 928                         (rq->sector & (sectors_per_frame - 1))) {
 929                         printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
 930                                 drive->name, rq->current_nr_sectors);
 931                         cdrom_end_request(drive, 0);
 932                         return ide_stopped;
 933                 }
 934                 rq->current_nr_sectors += nskip;
 935         }
 936
 937         /* Set up the command */
 938         rq->timeout = ATAPI_WAIT_PC;
 939
 940         /* Send the command to the drive and return. */
 941         return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
 942 }
 943
 944
 945 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
 946 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
 947 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
 948
 949 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
 950 {
 951         struct cdrom_info *info = drive->driver_data;
 952         int stat;
 953         static int retry = 10;
 954
 955         if (cdrom_decode_status(drive, 0, &stat))
 956                 return ide_stopped;
 957
 958         info->cd_flags |= IDE_CD_FLAG_SEEKING;
 959
 960         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
 961                 if (--retry == 0) {
 962                         /*
 963                          * this condition is far too common, to bother
 964                          * users about it
 965                          */
 966                         /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
 967                         drive->dsc_overlap = 0;
 968                 }
 969         }
 970         return ide_stopped;
 971 }
 972
 973 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
 974 {
 975         struct request *rq = HWGROUP(drive)->rq;
 976         sector_t frame = rq->sector;
 977
 978         sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
 979
 980         memset(rq->cmd, 0, sizeof(rq->cmd));
 981         rq->cmd[0] = GPCMD_SEEK;
 982         put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
 983
 984         rq->timeout = ATAPI_WAIT_PC;
 985         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
 986 }
 987
 988 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
 989 {
 990         struct cdrom_info *info = drive->driver_data;
 991
 992         info->dma = 0;
 993         info->start_seek = jiffies;
 994         return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
 995 }
 996
 997 /* Fix up a possibly partially-processed request so that we can
 998    start it over entirely, or even put it back on the request queue. */
 999 static void restore_request (struct request *rq)
1000 {
1001         if (rq->buffer != bio_data(rq->bio)) {
1002                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1003
1004                 rq->buffer = bio_data(rq->bio);
1005                 rq->nr_sectors += n;
1006                 rq->sector -= n;
1007         }
1008         rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1009         rq->hard_nr_sectors = rq->nr_sectors;
1010         rq->hard_sector = rq->sector;
1011         rq->q->prep_rq_fn(rq->q, rq);
1012 }
1013
1014 /*
1015  * Start a read request from the CD-ROM.
1016  */
1017 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1018 {
1019         struct cdrom_info *info = drive->driver_data;
1020         struct request *rq = HWGROUP(drive)->rq;
1021         unsigned short sectors_per_frame;
1022
1023         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1024
1025         /* We may be retrying this request after an error.  Fix up
1026            any weirdness which might be present in the request packet. */
1027         restore_request(rq);
1028
1029         /* Satisfy whatever we can of this request from our cached sector. */
1030         if (cdrom_read_from_buffer(drive))
1031                 return ide_stopped;
1032
1033         /* Clear the local sector buffer. */
1034         info->nsectors_buffered = 0;
1035
1036         /* use dma, if possible. */
1037         info->dma = drive->using_dma;
1038         if ((rq->sector & (sectors_per_frame - 1)) ||
1039             (rq->nr_sectors & (sectors_per_frame - 1)))
1040                 info->dma = 0;
1041
1042         /* Start sending the read request to the drive. */
1043         return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1044 }
1045
1046 /****************************************************************************
1047  * Execute all other packet commands.
1048  */
1049
1050 /* Interrupt routine for packet command completion. */
1051 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1052 {
1053         struct request *rq = HWGROUP(drive)->rq;
1054         xfer_func_t *xferfunc = NULL;
1055         int stat, ireason, len, thislen, write;
1056         u8 lowcyl = 0, highcyl = 0;
1057
1058         /* Check for errors. */
1059         if (cdrom_decode_status(drive, 0, &stat))
1060                 return ide_stopped;
1061
1062         /* Read the interrupt reason and the transfer length. */
1063         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1064         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1065         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1066
1067         len = lowcyl + (256 * highcyl);
1068
1069         /* If DRQ is clear, the command has completed.
1070            Complain if we still have data left to transfer. */
1071         if ((stat & DRQ_STAT) == 0) {
1072                 /* Some of the trailing request sense fields are optional, and
1073                    some drives don't send them.  Sigh. */
1074                 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1075                     rq->data_len > 0 &&
1076                     rq->data_len <= 5) {
1077                         while (rq->data_len > 0) {
1078                                 *(unsigned char *)rq->data++ = 0;
1079                                 --rq->data_len;
1080                         }
1081                 }
1082
1083                 if (rq->data_len == 0)
1084                         cdrom_end_request(drive, 1);
1085                 else {
1086                         rq->cmd_flags |= REQ_FAILED;
1087                         cdrom_end_request(drive, 0);
1088                 }
1089                 return ide_stopped;
1090         }
1091
1092         /* Figure out how much data to transfer. */
1093         thislen = rq->data_len;
1094         if (thislen > len)
1095                 thislen = len;
1096
1097         if (ireason == 0) {
1098                 write = 1;
1099                 xferfunc = HWIF(drive)->atapi_output_bytes;
1100         } else if (ireason == 2) {
1101                 write = 0;
1102                 xferfunc = HWIF(drive)->atapi_input_bytes;
1103         }
1104
1105         if (xferfunc) {
1106                 if (!rq->data) {
1107                         printk(KERN_ERR "%s: confused, missing data\n",
1108                                         drive->name);
1109                         blk_dump_rq_flags(rq, write ? "cdrom_pc_intr, write"
1110                                                     : "cdrom_pc_intr, read");
1111                         goto pad;
1112                 }
1113                 /* Transfer the data. */
1114                 xferfunc(drive, rq->data, thislen);
1115
1116                 /* Keep count of how much data we've moved. */
1117                 len -= thislen;
1118                 rq->data += thislen;
1119                 rq->data_len -= thislen;
1120
1121                 if (write && blk_sense_request(rq))
1122                         rq->sense_len += thislen;
1123         } else {
1124                 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1125                         "appears confused (ireason = 0x%02x). "
1126                         "Trying to recover by ending request.\n",
1127                         drive->name, ireason);
1128                 rq->cmd_flags |= REQ_FAILED;
1129                 cdrom_end_request(drive, 0);
1130                 return ide_stopped;
1131         }
1132 pad:
1133         /*
1134          * If we haven't moved enough data to satisfy the drive,
1135          * add some padding.
1136          */
1137         if (len > 0)
1138                 ide_cd_pad_transfer(drive, xferfunc, len);
1139
1140         /* Now we wait for another interrupt. */
1141         ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1142         return ide_started;
1143 }
1144
1145 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1146 {
1147         struct request *rq = HWGROUP(drive)->rq;
1148
1149         if (!rq->timeout)
1150                 rq->timeout = ATAPI_WAIT_PC;
1151
1152         /* Send the command to the drive and return. */
1153         return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1154 }
1155
1156
1157 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1158 {
1159         int len;
1160         struct request *rq = HWGROUP(drive)->rq;
1161         struct cdrom_info *info = drive->driver_data;
1162
1163         info->dma = 0;
1164         rq->cmd_flags &= ~REQ_FAILED;
1165         len = rq->data_len;
1166
1167         /* Start sending the command to the drive. */
1168         return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1169 }
1170
1171 static int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
1172 {
1173         struct request_sense sense;
1174         int retries = 10;
1175         unsigned int flags = rq->cmd_flags;
1176
1177         if (rq->sense == NULL)
1178                 rq->sense = &sense;
1179
1180         /* Start of retry loop. */
1181         do {
1182                 int error;
1183                 unsigned long time = jiffies;
1184                 rq->cmd_flags = flags;
1185
1186                 error = ide_do_drive_cmd(drive, rq, ide_wait);
1187                 time = jiffies - time;
1188
1189                 /* FIXME: we should probably abort/retry or something
1190                  * in case of failure */
1191                 if (rq->cmd_flags & REQ_FAILED) {
1192                         /* The request failed.  Retry if it was due to a unit
1193                            attention status
1194                            (usually means media was changed). */
1195                         struct request_sense *reqbuf = rq->sense;
1196
1197                         if (reqbuf->sense_key == UNIT_ATTENTION)
1198                                 cdrom_saw_media_change(drive);
1199                         else if (reqbuf->sense_key == NOT_READY &&
1200                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
1201                                 /* The drive is in the process of loading
1202                                    a disk.  Retry, but wait a little to give
1203                                    the drive time to complete the load. */
1204                                 ssleep(2);
1205                         } else {
1206                                 /* Otherwise, don't retry. */
1207                                 retries = 0;
1208                         }
1209                         --retries;
1210                 }
1211
1212                 /* End of retry loop. */
1213         } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
1214
1215         /* Return an error if the command failed. */
1216         return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
1217 }
1218
1219 /*
1220  * Write handling
1221  */
1222 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1223 {
1224         /* Two notes about IDE interrupt reason here - 0 means that
1225          * the drive wants to receive data from us, 2 means that
1226          * the drive is expecting to transfer data to us.
1227          */
1228         if (ireason == 0)
1229                 return 0;
1230         else if (ireason == 2) {
1231                 ide_hwif_t *hwif = drive->hwif;
1232
1233                 /* Whoops... The drive wants to send data. */
1234                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1235                                 drive->name, __FUNCTION__);
1236
1237                 ide_cd_pad_transfer(drive, hwif->atapi_input_bytes, len);
1238         } else {
1239                 /* Drive wants a command packet, or invalid ireason... */
1240                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1241                                 drive->name, __FUNCTION__, ireason);
1242         }
1243
1244         cdrom_end_request(drive, 0);
1245         return 1;
1246 }
1247
1248 /*
1249  * Called from blk_end_request_callback() after the data of the request
1250  * is completed and before the request is completed.
1251  * By returning value '1', blk_end_request_callback() returns immediately
1252  * without completing the request.
1253  */
1254 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1255 {
1256         return 1;
1257 }
1258
1259 /*
1260  * best way to deal with dma that is not sector aligned right now... note
1261  * that in this path we are not using ->data or ->buffer at all. this irs
1262  * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1263  * future.
1264  */
1265 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1266 {
1267         struct cdrom_info *info = drive->driver_data;
1268         struct request *rq = HWGROUP(drive)->rq;
1269         int dma_error, dma, stat, ireason, len, thislen;
1270         u8 lowcyl, highcyl;
1271         xfer_func_t *xferfunc;
1272         unsigned long flags;
1273
1274         /* Check for errors. */
1275         dma_error = 0;
1276         dma = info->dma;
1277         if (dma) {
1278                 info->dma = 0;
1279                 dma_error = HWIF(drive)->ide_dma_end(drive);
1280                 if (dma_error) {
1281                         printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1282                                         rq_data_dir(rq) ? "write" : "read");
1283                         ide_dma_off(drive);
1284                 }
1285         }
1286
1287         if (cdrom_decode_status(drive, 0, &stat))
1288                 return ide_stopped;
1289
1290         /*
1291          * using dma, transfer is complete now
1292          */
1293         if (dma) {
1294                 if (dma_error)
1295                         return ide_error(drive, "dma error", stat);
1296
1297                 spin_lock_irqsave(&ide_lock, flags);
1298                 if (__blk_end_request(rq, 0, rq->data_len))
1299                         BUG();
1300                 HWGROUP(drive)->rq = NULL;
1301                 spin_unlock_irqrestore(&ide_lock, flags);
1302
1303                 return ide_stopped;
1304         }
1305
1306         /*
1307          * ok we fall to pio :/
1308          */
1309         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1310         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1311         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1312
1313         len = lowcyl + (256 * highcyl);
1314         thislen = rq->data_len;
1315         if (thislen > len)
1316                 thislen = len;
1317
1318         /*
1319          * If DRQ is clear, the command has completed.
1320          */
1321         if ((stat & DRQ_STAT) == 0) {
1322                 spin_lock_irqsave(&ide_lock, flags);
1323                 if (__blk_end_request(rq, 0, rq->data_len))
1324                         BUG();
1325                 HWGROUP(drive)->rq = NULL;
1326                 spin_unlock_irqrestore(&ide_lock, flags);
1327
1328                 return ide_stopped;
1329         }
1330
1331         /*
1332          * check which way to transfer data
1333          */
1334         if (rq_data_dir(rq) == WRITE) {
1335                 /*
1336                  * write to drive
1337                  */
1338                 if (cdrom_write_check_ireason(drive, len, ireason))
1339                         return ide_stopped;
1340
1341                 xferfunc = HWIF(drive)->atapi_output_bytes;
1342         } else  {
1343                 /*
1344                  * read from drive
1345                  */
1346                 if (cdrom_read_check_ireason(drive, len, ireason))
1347                         return ide_stopped;
1348
1349                 xferfunc = HWIF(drive)->atapi_input_bytes;
1350         }
1351
1352         /*
1353          * transfer data
1354          */
1355         while (thislen > 0) {
1356                 int blen = blen = rq->data_len;
1357                 char *ptr = rq->data;
1358
1359                 /*
1360                  * bio backed?
1361                  */
1362                 if (rq->bio) {
1363                         ptr = bio_data(rq->bio);
1364                         blen = bio_iovec(rq->bio)->bv_len;
1365                 }
1366
1367                 if (!ptr) {
1368                         printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1369                         break;
1370                 }
1371
1372                 if (blen > thislen)
1373                         blen = thislen;
1374
1375                 xferfunc(drive, ptr, blen);
1376
1377                 thislen -= blen;
1378                 len -= blen;
1379                 rq->data_len -= blen;
1380
1381                 if (rq->bio)
1382                         /*
1383                          * The request can't be completed until DRQ is cleared.
1384                          * So complete the data, but don't complete the request
1385                          * using the dummy function for the callback feature
1386                          * of blk_end_request_callback().
1387                          */
1388                         blk_end_request_callback(rq, 0, blen,
1389                                                  cdrom_newpc_intr_dummy_cb);
1390                 else
1391                         rq->data += blen;
1392         }
1393
1394         /*
1395          * pad, if necessary
1396          */
1397         if (len > 0)
1398                 ide_cd_pad_transfer(drive, xferfunc, len);
1399
1400         BUG_ON(HWGROUP(drive)->handler != NULL);
1401
1402         ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1403         return ide_started;
1404 }
1405
1406 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1407 {
1408         int stat, ireason, len, sectors_to_transfer, uptodate;
1409         struct cdrom_info *info = drive->driver_data;
1410         int dma_error = 0, dma = info->dma;
1411         u8 lowcyl = 0, highcyl = 0;
1412
1413         struct request *rq = HWGROUP(drive)->rq;
1414
1415         /* Check for errors. */
1416         if (dma) {
1417                 info->dma = 0;
1418                 dma_error = HWIF(drive)->ide_dma_end(drive);
1419                 if (dma_error) {
1420                         printk(KERN_ERR "%s: DMA write error\n", drive->name);
1421                         ide_dma_off(drive);
1422                 }
1423         }
1424
1425         if (cdrom_decode_status(drive, 0, &stat))
1426                 return ide_stopped;
1427
1428         /*
1429          * using dma, transfer is complete now
1430          */
1431         if (dma) {
1432                 if (dma_error)
1433                         return ide_error(drive, "dma error", stat);
1434
1435                 ide_end_request(drive, 1, rq->nr_sectors);
1436                 return ide_stopped;
1437         }
1438
1439         /* Read the interrupt reason and the transfer length. */
1440         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1441         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1442         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1443
1444         len = lowcyl + (256 * highcyl);
1445
1446         /* If DRQ is clear, the command has completed. */
1447         if ((stat & DRQ_STAT) == 0) {
1448                 /* If we're not done writing, complain.
1449                  * Otherwise, complete the command normally.
1450                  */
1451                 uptodate = 1;
1452                 if (rq->current_nr_sectors > 0) {
1453                         printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1454                                         drive->name, __FUNCTION__,
1455                                         rq->current_nr_sectors);
1456                         uptodate = 0;
1457                 }
1458                 cdrom_end_request(drive, uptodate);
1459                 return ide_stopped;
1460         }
1461
1462         /* Check that the drive is expecting to do the same thing we are. */
1463         if (cdrom_write_check_ireason(drive, len, ireason))
1464                 return ide_stopped;
1465
1466         sectors_to_transfer = len / SECTOR_SIZE;
1467
1468         /*
1469          * now loop and write out the data
1470          */
1471         while (sectors_to_transfer > 0) {
1472                 int this_transfer;
1473
1474                 if (!rq->current_nr_sectors) {
1475                         printk(KERN_ERR "%s: %s: confused, missing data\n",
1476                                         drive->name, __FUNCTION__);
1477                         break;
1478                 }
1479
1480                 /*
1481                  * Figure out how many sectors we can transfer
1482                  */
1483                 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1484
1485                 while (this_transfer > 0) {
1486                         HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1487                         rq->buffer += SECTOR_SIZE;
1488                         --rq->nr_sectors;
1489                         --rq->current_nr_sectors;
1490                         ++rq->sector;
1491                         --this_transfer;
1492                         --sectors_to_transfer;
1493                 }
1494
1495                 /*
1496                  * current buffer complete, move on
1497                  */
1498                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1499                         cdrom_end_request(drive, 1);
1500         }
1501
1502         /* re-arm handler */
1503         ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1504         return ide_started;
1505 }
1506
1507 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1508 {
1509         struct request *rq = HWGROUP(drive)->rq;
1510
1511 #if 0   /* the immediate bit */
1512         rq->cmd[1] = 1 << 3;
1513 #endif
1514         rq->timeout = ATAPI_WAIT_PC;
1515
1516         return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1517 }
1518
1519 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1520 {
1521         struct cdrom_info *info = drive->driver_data;
1522         struct gendisk *g = info->disk;
1523         unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1524
1525         /*
1526          * writes *must* be hardware frame aligned
1527          */
1528         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1529             (rq->sector & (sectors_per_frame - 1))) {
1530                 cdrom_end_request(drive, 0);
1531                 return ide_stopped;
1532         }
1533
1534         /*
1535          * disk has become write protected
1536          */
1537         if (g->policy) {
1538                 cdrom_end_request(drive, 0);
1539                 return ide_stopped;
1540         }
1541
1542         info->nsectors_buffered = 0;
1543
1544         /* use dma, if possible. we don't need to check more, since we
1545          * know that the transfer is always (at least!) frame aligned */
1546         info->dma = drive->using_dma ? 1 : 0;
1547
1548         info->devinfo.media_written = 1;
1549
1550         /* Start sending the write request to the drive. */
1551         return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1552 }
1553
1554 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1555 {
1556         struct request *rq = HWGROUP(drive)->rq;
1557
1558         if (!rq->timeout)
1559                 rq->timeout = ATAPI_WAIT_PC;
1560
1561         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1562 }
1563
1564 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1565 {
1566         struct cdrom_info *info = drive->driver_data;
1567
1568         rq->cmd_flags |= REQ_QUIET;
1569
1570         info->dma = 0;
1571
1572         /*
1573          * sg request
1574          */
1575         if (rq->bio) {
1576                 int mask = drive->queue->dma_alignment;
1577                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1578
1579                 info->dma = drive->using_dma;
1580
1581                 /*
1582                  * check if dma is safe
1583                  *
1584                  * NOTE! The "len" and "addr" checks should possibly have
1585                  * separate masks.
1586                  */
1587                 if ((rq->data_len & 15) || (addr & mask))
1588                         info->dma = 0;
1589         }
1590
1591         /* Start sending the command to the drive. */
1592         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1593 }
1594
1595 /****************************************************************************
1596  * cdrom driver request routine.
1597  */
1598 static ide_startstop_t
1599 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1600 {
1601         ide_startstop_t action;
1602         struct cdrom_info *info = drive->driver_data;
1603
1604         if (blk_fs_request(rq)) {
1605                 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1606                         unsigned long elapsed = jiffies - info->start_seek;
1607                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1608
1609                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1610                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1611                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1612                                         return ide_stopped;
1613                                 }
1614                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1615                         }
1616                         info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1617                 }
1618                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1619                         action = cdrom_start_seek(drive, block);
1620                 } else {
1621                         if (rq_data_dir(rq) == READ)
1622                                 action = cdrom_start_read(drive, block);
1623                         else
1624                                 action = cdrom_start_write(drive, rq);
1625                 }
1626                 info->last_block = block;
1627                 return action;
1628         } else if (rq->cmd_type == REQ_TYPE_SENSE ||
1629                    rq->cmd_type == REQ_TYPE_ATA_PC) {
1630                 return cdrom_do_packet_command(drive);
1631         } else if (blk_pc_request(rq)) {
1632                 return cdrom_do_block_pc(drive, rq);
1633         } else if (blk_special_request(rq)) {
1634                 /*
1635                  * right now this can only be a reset...
1636                  */
1637                 cdrom_end_request(drive, 1);
1638                 return ide_stopped;
1639         }
1640
1641         blk_dump_rq_flags(rq, "ide-cd bad flags");
1642         cdrom_end_request(drive, 0);
1643         return ide_stopped;
1644 }
1645
1646
1647
1648 /****************************************************************************
1649  * Ioctl handling.
1650  *
1651  * Routines which queue packet commands take as a final argument a pointer
1652  * to a request_sense struct.  If execution of the command results
1653  * in an error with a CHECK CONDITION status, this structure will be filled
1654  * with the results of the subsequent request sense command.  The pointer
1655  * can also be NULL, in which case no sense information is returned.
1656  */
1657
1658 static
1659 void msf_from_bcd (struct atapi_msf *msf)
1660 {
1661         msf->minute = BCD2BIN(msf->minute);
1662         msf->second = BCD2BIN(msf->second);
1663         msf->frame  = BCD2BIN(msf->frame);
1664 }
1665
1666 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1667 {
1668         struct request req;
1669         struct cdrom_info *info = drive->driver_data;
1670         struct cdrom_device_info *cdi = &info->devinfo;
1671
1672         ide_cd_init_rq(drive, &req);
1673
1674         req.sense = sense;
1675         req.cmd[0] = GPCMD_TEST_UNIT_READY;
1676         req.cmd_flags |= REQ_QUIET;
1677
1678         /*
1679          * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1680          * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1681          */
1682         req.cmd[7] = cdi->sanyo_slot % 3;
1683
1684         return ide_cd_queue_pc(drive, &req);
1685 }
1686
1687 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1688 static int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
1689                            struct request_sense *sense)
1690 {
1691         struct cdrom_info *cd = drive->driver_data;
1692         struct request_sense my_sense;
1693         struct request req;
1694         int stat;
1695
1696         if (sense == NULL)
1697                 sense = &my_sense;
1698
1699         /* If the drive cannot lock the door, just pretend. */
1700         if (cd->cd_flags & IDE_CD_FLAG_NO_DOORLOCK) {
1701                 stat = 0;
1702         } else {
1703                 ide_cd_init_rq(drive, &req);
1704                 req.sense = sense;
1705                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1706                 req.cmd[4] = lockflag ? 1 : 0;
1707                 stat = ide_cd_queue_pc(drive, &req);
1708         }
1709
1710         /* If we got an illegal field error, the drive
1711            probably cannot lock the door. */
1712         if (stat != 0 &&
1713             sense->sense_key == ILLEGAL_REQUEST &&
1714             (sense->asc == 0x24 || sense->asc == 0x20)) {
1715                 printk (KERN_ERR "%s: door locking not supported\n",
1716                         drive->name);
1717                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1718                 stat = 0;
1719         }
1720
1721         /* no medium, that's alright. */
1722         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
1723                 stat = 0;
1724
1725         if (stat == 0) {
1726                 if (lockflag)
1727                         cd->cd_flags |= IDE_CD_FLAG_DOOR_LOCKED;
1728                 else
1729                         cd->cd_flags &= ~IDE_CD_FLAG_DOOR_LOCKED;
1730         }
1731
1732         return stat;
1733 }
1734
1735
1736 /* Eject the disk if EJECTFLAG is 0.
1737    If EJECTFLAG is 1, try to reload the disk. */
1738 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
1739                        struct request_sense *sense)
1740 {
1741         struct cdrom_info *cd = drive->driver_data;
1742         struct cdrom_device_info *cdi = &cd->devinfo;
1743         struct request req;
1744         char loej = 0x02;
1745
1746         if ((cd->cd_flags & IDE_CD_FLAG_NO_EJECT) && !ejectflag)
1747                 return -EDRIVE_CANT_DO_THIS;
1748
1749         /* reload fails on some drives, if the tray is locked */
1750         if ((cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED) && ejectflag)
1751                 return 0;
1752
1753         ide_cd_init_rq(drive, &req);
1754
1755         /* only tell drive to close tray if open, if it can do that */
1756         if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
1757                 loej = 0;
1758
1759         req.sense = sense;
1760         req.cmd[0] = GPCMD_START_STOP_UNIT;
1761         req.cmd[4] = loej | (ejectflag != 0);
1762
1763         return ide_cd_queue_pc(drive, &req);
1764 }
1765
1766 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1767                                unsigned long *sectors_per_frame,
1768                                struct request_sense *sense)
1769 {
1770         struct {
1771                 __u32 lba;
1772                 __u32 blocklen;
1773         } capbuf;
1774
1775         int stat;
1776         struct request req;
1777
1778         ide_cd_init_rq(drive, &req);
1779
1780         req.sense = sense;
1781         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1782         req.data = (char *)&capbuf;
1783         req.data_len = sizeof(capbuf);
1784         req.cmd_flags |= REQ_QUIET;
1785
1786         stat = ide_cd_queue_pc(drive, &req);
1787         if (stat == 0) {
1788                 *capacity = 1 + be32_to_cpu(capbuf.lba);
1789                 *sectors_per_frame =
1790                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1791         }
1792
1793         return stat;
1794 }
1795
1796 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1797                                 int format, char *buf, int buflen,
1798                                 struct request_sense *sense)
1799 {
1800         struct request req;
1801
1802         ide_cd_init_rq(drive, &req);
1803
1804         req.sense = sense;
1805         req.data =  buf;
1806         req.data_len = buflen;
1807         req.cmd_flags |= REQ_QUIET;
1808         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1809         req.cmd[6] = trackno;
1810         req.cmd[7] = (buflen >> 8);
1811         req.cmd[8] = (buflen & 0xff);
1812         req.cmd[9] = (format << 6);
1813
1814         if (msf_flag)
1815                 req.cmd[1] = 2;
1816
1817         return ide_cd_queue_pc(drive, &req);
1818 }
1819
1820
1821 /* Try to read the entire TOC for the disk into our internal buffer. */
1822 static int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
1823 {
1824         int stat, ntracks, i;
1825         struct cdrom_info *info = drive->driver_data;
1826         struct cdrom_device_info *cdi = &info->devinfo;
1827         struct atapi_toc *toc = info->toc;
1828         struct {
1829                 struct atapi_toc_header hdr;
1830                 struct atapi_toc_entry  ent;
1831         } ms_tmp;
1832         long last_written;
1833         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1834
1835         if (toc == NULL) {
1836                 /* Try to allocate space. */
1837                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1838                 if (toc == NULL) {
1839                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1840                         return -ENOMEM;
1841                 }
1842                 info->toc = toc;
1843         }
1844
1845         /* Check to see if the existing data is still valid.
1846            If it is, just return. */
1847         (void) cdrom_check_status(drive, sense);
1848
1849         if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
1850                 return 0;
1851
1852         /* Try to get the total cdrom capacity and sector size. */
1853         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
1854                                    sense);
1855         if (stat)
1856                 toc->capacity = 0x1fffff;
1857
1858         set_capacity(info->disk, toc->capacity * sectors_per_frame);
1859         /* Save a private copy of te TOC capacity for error handling */
1860         drive->probed_capacity = toc->capacity * sectors_per_frame;
1861
1862         blk_queue_hardsect_size(drive->queue,
1863                                 sectors_per_frame << SECTOR_BITS);
1864
1865         /* First read just the header, so we know how long the TOC is. */
1866         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1867                                     sizeof(struct atapi_toc_header), sense);
1868         if (stat)
1869                 return stat;
1870
1871         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1872                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1873                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1874         }
1875
1876         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1877         if (ntracks <= 0)
1878                 return -EIO;
1879         if (ntracks > MAX_TRACKS)
1880                 ntracks = MAX_TRACKS;
1881
1882         /* Now read the whole schmeer. */
1883         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1884                                   (char *)&toc->hdr,
1885                                    sizeof(struct atapi_toc_header) +
1886                                    (ntracks + 1) *
1887                                    sizeof(struct atapi_toc_entry), sense);
1888
1889         if (stat && toc->hdr.first_track > 1) {
1890                 /* Cds with CDI tracks only don't have any TOC entries,
1891                    despite of this the returned values are
1892                    first_track == last_track = number of CDI tracks + 1,
1893                    so that this case is indistinguishable from the same
1894                    layout plus an additional audio track.
1895                    If we get an error for the regular case, we assume
1896                    a CDI without additional audio tracks. In this case
1897                    the readable TOC is empty (CDI tracks are not included)
1898                    and only holds the Leadout entry. Heiko Eißfeldt */
1899                 ntracks = 0;
1900                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1901                                            (char *)&toc->hdr,
1902                                            sizeof(struct atapi_toc_header) +
1903                                            (ntracks + 1) *
1904                                            sizeof(struct atapi_toc_entry),
1905                                            sense);
1906                 if (stat)
1907                         return stat;
1908
1909                 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1910                         toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1911                         toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
1912                 } else {
1913                         toc->hdr.first_track = CDROM_LEADOUT;
1914                         toc->hdr.last_track = CDROM_LEADOUT;
1915                 }
1916         }
1917
1918         if (stat)
1919                 return stat;
1920
1921         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1922
1923         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1924                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1925                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1926         }
1927
1928         for (i = 0; i <= ntracks; i++) {
1929                 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1930                         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
1931                                 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
1932                         msf_from_bcd(&toc->ent[i].addr.msf);
1933                 }
1934                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1935                                                    toc->ent[i].addr.msf.second,
1936                                                    toc->ent[i].addr.msf.frame);
1937         }
1938
1939         /* Read the multisession information. */
1940         if (toc->hdr.first_track != CDROM_LEADOUT) {
1941                 /* Read the multisession information. */
1942                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1943                                            sizeof(ms_tmp), sense);
1944                 if (stat)
1945                         return stat;
1946
1947                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1948         } else {
1949                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1950                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1951         }
1952
1953         if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1954                 /* Re-read multisession information using MSF format */
1955                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1956                                            sizeof(ms_tmp), sense);
1957                 if (stat)
1958                         return stat;
1959
1960                 msf_from_bcd (&ms_tmp.ent.addr.msf);
1961                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1962                                                    ms_tmp.ent.addr.msf.second,
1963                                                    ms_tmp.ent.addr.msf.frame);
1964         }
1965
1966         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1967
1968         /* Now try to get the total cdrom capacity. */
1969         stat = cdrom_get_last_written(cdi, &last_written);
1970         if (!stat && (last_written > toc->capacity)) {
1971                 toc->capacity = last_written;
1972                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
1973                 drive->probed_capacity = toc->capacity * sectors_per_frame;
1974         }
1975
1976         /* Remember that we've read this stuff. */
1977         info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
1978
1979         return 0;
1980 }
1981
1982 static int ide_cd_read_tochdr(ide_drive_t *drive, void *arg)
1983 {
1984         struct cdrom_info *cd = drive->driver_data;
1985         struct cdrom_tochdr *tochdr = arg;
1986         struct atapi_toc *toc;
1987         int stat;
1988
1989         /* Make sure our saved TOC is valid. */
1990         stat = ide_cd_read_toc(drive, NULL);
1991         if (stat)
1992                 return stat;
1993
1994         toc = cd->toc;
1995         tochdr->cdth_trk0 = toc->hdr.first_track;
1996         tochdr->cdth_trk1 = toc->hdr.last_track;
1997
1998         return 0;
1999 }
2000
2001 static int ide_cd_get_toc_entry(ide_drive_t *drive, int track,
2002                                 struct atapi_toc_entry **ent)
2003 {
2004         struct cdrom_info *info = drive->driver_data;
2005         struct atapi_toc *toc = info->toc;
2006         int ntracks;
2007
2008         /*
2009          * don't serve cached data, if the toc isn't valid
2010          */
2011         if ((info->cd_flags & IDE_CD_FLAG_TOC_VALID) == 0)
2012                 return -EINVAL;
2013
2014         /* Check validity of requested track number. */
2015         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2016
2017         if (toc->hdr.first_track == CDROM_LEADOUT)
2018                 ntracks = 0;
2019
2020         if (track == CDROM_LEADOUT)
2021                 *ent = &toc->ent[ntracks];
2022         else if (track < toc->hdr.first_track || track > toc->hdr.last_track)
2023                 return -EINVAL;
2024         else
2025                 *ent = &toc->ent[track - toc->hdr.first_track];
2026
2027         return 0;
2028 }
2029
2030 static int ide_cd_read_tocentry(ide_drive_t *drive, void *arg)
2031 {
2032         struct cdrom_tocentry *tocentry = arg;
2033         struct atapi_toc_entry *toce;
2034         int stat;
2035
2036         stat = ide_cd_get_toc_entry(drive, tocentry->cdte_track, &toce);
2037         if (stat)
2038                 return stat;
2039
2040         tocentry->cdte_ctrl = toce->control;
2041         tocentry->cdte_adr  = toce->adr;
2042         if (tocentry->cdte_format == CDROM_MSF) {
2043                 lba_to_msf(toce->addr.lba,
2044                            &tocentry->cdte_addr.msf.minute,
2045                            &tocentry->cdte_addr.msf.second,
2046                            &tocentry->cdte_addr.msf.frame);
2047         } else
2048                 tocentry->cdte_addr.lba = toce->addr.lba;
2049
2050         return 0;
2051 }
2052
2053 static int ide_cd_fake_play_trkind(ide_drive_t *drive, void *arg)
2054 {
2055         struct cdrom_ti *ti = arg;
2056         struct atapi_toc_entry *first_toc, *last_toc;
2057         unsigned long lba_start, lba_end;
2058         int stat;
2059         struct request rq;
2060         struct request_sense sense;
2061
2062         stat = ide_cd_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2063         if (stat)
2064                 return stat;
2065
2066         stat = ide_cd_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2067         if (stat)
2068                 return stat;
2069
2070         if (ti->cdti_trk1 != CDROM_LEADOUT)
2071                 ++last_toc;
2072         lba_start = first_toc->addr.lba;
2073         lba_end   = last_toc->addr.lba;
2074
2075         if (lba_end <= lba_start)
2076                 return -EINVAL;
2077
2078         ide_cd_init_rq(drive, &rq);
2079
2080         rq.sense = &sense;
2081         rq.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2082         lba_to_msf(lba_start,   &rq.cmd[3], &rq.cmd[4], &rq.cmd[5]);
2083         lba_to_msf(lba_end - 1, &rq.cmd[6], &rq.cmd[7], &rq.cmd[8]);
2084
2085         return ide_cd_queue_pc(drive, &rq);
2086 }
2087
2088 /* the generic packet interface to cdrom.c */
2089 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2090                             struct packet_command *cgc)
2091 {
2092         struct request req;
2093         ide_drive_t *drive = cdi->handle;
2094
2095         if (cgc->timeout <= 0)
2096                 cgc->timeout = ATAPI_WAIT_PC;
2097
2098         /* here we queue the commands from the uniform CD-ROM
2099            layer. the packet must be complete, as we do not
2100            touch it at all. */
2101         ide_cd_init_rq(drive, &req);
2102         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2103         if (cgc->sense)
2104                 memset(cgc->sense, 0, sizeof(struct request_sense));
2105         req.data = cgc->buffer;
2106         req.data_len = cgc->buflen;
2107         req.timeout = cgc->timeout;
2108
2109         if (cgc->quiet)
2110                 req.cmd_flags |= REQ_QUIET;
2111
2112         req.sense = cgc->sense;
2113         cgc->stat = ide_cd_queue_pc(drive, &req);
2114         if (!cgc->stat)
2115                 cgc->buflen -= req.data_len;
2116         return cgc->stat;
2117 }
2118
2119 static int ide_cdrom_audio_ioctl(struct cdrom_device_info *cdi,
2120                                  unsigned int cmd, void *arg)
2121 {
2122         ide_drive_t *drive = cdi->handle;
2123
2124         switch (cmd) {
2125         /*
2126          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2127          * atapi doesn't support it
2128          */
2129         case CDROMPLAYTRKIND:
2130                 return ide_cd_fake_play_trkind(drive, arg);
2131         case CDROMREADTOCHDR:
2132                 return ide_cd_read_tochdr(drive, arg);
2133         case CDROMREADTOCENTRY:
2134                 return ide_cd_read_tocentry(drive, arg);
2135         default:
2136                 return -EINVAL;
2137         }
2138 }
2139
2140 static
2141 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2142 {
2143         ide_drive_t *drive = cdi->handle;
2144         struct cdrom_info *cd = drive->driver_data;
2145         struct request_sense sense;
2146         struct request req;
2147         int ret;
2148
2149         ide_cd_init_rq(drive, &req);
2150         req.cmd_type = REQ_TYPE_SPECIAL;
2151         req.cmd_flags = REQ_QUIET;
2152         ret = ide_do_drive_cmd(drive, &req, ide_wait);
2153
2154         /*
2155          * A reset will unlock the door. If it was previously locked,
2156          * lock it again.
2157          */
2158         if (cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED)
2159                 (void)ide_cd_lockdoor(drive, 1, &sense);
2160
2161         return ret;
2162 }
2163
2164
2165 static
2166 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2167 {
2168         ide_drive_t *drive = cdi->handle;
2169         struct request_sense sense;
2170
2171         if (position) {
2172                 int stat = ide_cd_lockdoor(drive, 0, &sense);
2173
2174                 if (stat)
2175                         return stat;
2176         }
2177
2178         return cdrom_eject(drive, !position, &sense);
2179 }
2180
2181 static
2182 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2183 {
2184         ide_drive_t *drive = cdi->handle;
2185
2186         return ide_cd_lockdoor(drive, lock, NULL);
2187 }
2188
2189 static int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
2190 {
2191         struct cdrom_info *info = drive->driver_data;
2192         struct cdrom_device_info *cdi = &info->devinfo;
2193         struct packet_command cgc;
2194         int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
2195
2196         if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
2197                 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
2198
2199         init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
2200         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2201                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2202                 if (!stat)
2203                         break;
2204         } while (--attempts);
2205         return stat;
2206 }
2207
2208 static void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
2209 {
2210         struct cdrom_info *cd = drive->driver_data;
2211         u16 curspeed, maxspeed;
2212
2213         curspeed = *(u16 *)&buf[8 + 14];
2214         maxspeed = *(u16 *)&buf[8 +  8];
2215
2216         if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
2217                 curspeed = le16_to_cpu(curspeed);
2218                 maxspeed = le16_to_cpu(maxspeed);
2219         } else {
2220                 curspeed = be16_to_cpu(curspeed);
2221                 maxspeed = be16_to_cpu(maxspeed);
2222         }
2223
2224         cd->current_speed = (curspeed + (176/2)) / 176;
2225         cd->max_speed = (maxspeed + (176/2)) / 176;
2226 }
2227
2228 /*
2229  * ATAPI devices are free to select the speed you request or any slower
2230  * rate. :-(  Requesting too fast a speed will _not_ produce an error.
2231  */
2232 static int ide_cdrom_select_speed(struct cdrom_device_info *cdi, int speed)
2233 {
2234         ide_drive_t *drive = cdi->handle;
2235         struct cdrom_info *cd = drive->driver_data;
2236         struct request rq;
2237         struct request_sense sense;
2238         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2239         int stat;
2240
2241         ide_cd_init_rq(drive, &rq);
2242
2243         rq.sense = &sense;
2244
2245         if (speed == 0)
2246                 speed = 0xffff; /* set to max */
2247         else
2248                 speed *= 177;   /* Nx to kbytes/s */
2249
2250         rq.cmd[0] = GPCMD_SET_SPEED;
2251         /* Read Drive speed in kbytes/second MSB/LSB */
2252         rq.cmd[2] = (speed >> 8) & 0xff;
2253         rq.cmd[3] = speed & 0xff;
2254         if ((cdi->mask & (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) !=
2255             (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) {
2256                 /* Write Drive speed in kbytes/second MSB/LSB */
2257                 rq.cmd[4] = (speed >> 8) & 0xff;
2258                 rq.cmd[5] = speed & 0xff;
2259         }
2260
2261         stat = ide_cd_queue_pc(drive, &rq);
2262
2263         if (!ide_cdrom_get_capabilities(drive, buf)) {
2264                 ide_cdrom_update_speed(drive, buf);
2265                 cdi->speed = cd->current_speed;
2266         }
2267
2268         return 0;
2269 }
2270
2271 /*
2272  * add logic to try GET_EVENT command first to check for media and tray
2273  * status. this should be supported by newer cd-r/w and all DVD etc
2274  * drives
2275  */
2276 static
2277 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2278 {
2279         ide_drive_t *drive = cdi->handle;
2280         struct media_event_desc med;
2281         struct request_sense sense;
2282         int stat;
2283
2284         if (slot_nr != CDSL_CURRENT)
2285                 return -EINVAL;
2286
2287         stat = cdrom_check_status(drive, &sense);
2288         if (!stat || sense.sense_key == UNIT_ATTENTION)
2289                 return CDS_DISC_OK;
2290
2291         if (!cdrom_get_media_event(cdi, &med)) {
2292                 if (med.media_present)
2293                         return CDS_DISC_OK;
2294                 else if (med.door_open)
2295                         return CDS_TRAY_OPEN;
2296                 else
2297                         return CDS_NO_DISC;
2298         }
2299
2300         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2301                 return CDS_DISC_OK;
2302
2303         /*
2304          * If not using Mt Fuji extended media tray reports,
2305          * just return TRAY_OPEN since ATAPI doesn't provide
2306          * any other way to detect this...
2307          */
2308         if (sense.sense_key == NOT_READY) {
2309                 if (sense.asc == 0x3a && sense.ascq == 1)
2310                         return CDS_NO_DISC;
2311                 else
2312                         return CDS_TRAY_OPEN;
2313         }
2314         return CDS_DRIVE_NOT_READY;
2315 }
2316
2317 static
2318 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2319                                 struct cdrom_multisession *ms_info)
2320 {
2321         struct atapi_toc *toc;
2322         ide_drive_t *drive = cdi->handle;
2323         struct cdrom_info *info = drive->driver_data;
2324         struct request_sense sense;
2325         int ret;
2326
2327         if ((info->cd_flags & IDE_CD_FLAG_TOC_VALID) == 0 || !info->toc) {
2328                 ret = ide_cd_read_toc(drive, &sense);
2329                 if (ret)
2330                         return ret;
2331         }
2332
2333         toc = info->toc;
2334         ms_info->addr.lba = toc->last_session_lba;
2335         ms_info->xa_flag = toc->xa_flag;
2336
2337         return 0;
2338 }
2339
2340 static int ide_cdrom_get_mcn(struct cdrom_device_info *cdi,
2341                              struct cdrom_mcn *mcn_info)
2342 {
2343         ide_drive_t *drive = cdi->handle;
2344         int stat, mcnlen;
2345         struct request rq;
2346         char buf[24];
2347
2348         ide_cd_init_rq(drive, &rq);
2349
2350         rq.data = buf;
2351         rq.data_len = sizeof(buf);
2352
2353         rq.cmd[0] = GPCMD_READ_SUBCHANNEL;
2354         rq.cmd[1] = 2;          /* MSF addressing */
2355         rq.cmd[2] = 0x40;       /* request subQ data */
2356         rq.cmd[3] = 2;          /* format */
2357         rq.cmd[8] = sizeof(buf);
2358
2359         stat = ide_cd_queue_pc(drive, &rq);
2360         if (stat)
2361                 return stat;
2362
2363         mcnlen = sizeof(mcn_info->medium_catalog_number) - 1;
2364         memcpy(mcn_info->medium_catalog_number, buf + 9, mcnlen);
2365         mcn_info->medium_catalog_number[mcnlen] = '\0';
2366
2367         return 0;
2368 }
2369
2370 /****************************************************************************
2371  * Other driver requests (open, close, check media change).
2372  */
2373
2374 static
2375 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2376                                        int slot_nr)
2377 {
2378         ide_drive_t *drive = cdi->handle;
2379         struct cdrom_info *cd = drive->driver_data;
2380         int retval;
2381
2382         if (slot_nr == CDSL_CURRENT) {
2383                 (void) cdrom_check_status(drive, NULL);
2384                 retval = (cd->cd_flags & IDE_CD_FLAG_MEDIA_CHANGED) ? 1 : 0;
2385                 cd->cd_flags &= ~IDE_CD_FLAG_MEDIA_CHANGED;
2386                 return retval;
2387         } else {
2388                 return -EINVAL;
2389         }
2390 }
2391
2392
2393 static
2394 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2395 {
2396         return 0;
2397 }
2398
2399 /*
2400  * Close down the device.  Invalidate all cached blocks.
2401  */
2402
2403 static
2404 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2405 {
2406         ide_drive_t *drive = cdi->handle;
2407         struct cdrom_info *cd = drive->driver_data;
2408
2409         if (!cdi->use_count)
2410                 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
2411 }
2412
2413 #define IDE_CD_CAPABILITIES \
2414         (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2415          CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2416          CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2417          CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2418          CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
2419
2420 static struct cdrom_device_ops ide_cdrom_dops = {
2421         .open                   = ide_cdrom_open_real,
2422         .release                = ide_cdrom_release_real,
2423         .drive_status           = ide_cdrom_drive_status,
2424         .media_changed          = ide_cdrom_check_media_change_real,
2425         .tray_move              = ide_cdrom_tray_move,
2426         .lock_door              = ide_cdrom_lock_door,
2427         .select_speed           = ide_cdrom_select_speed,
2428         .get_last_session       = ide_cdrom_get_last_session,
2429         .get_mcn                = ide_cdrom_get_mcn,
2430         .reset                  = ide_cdrom_reset,
2431         .audio_ioctl            = ide_cdrom_audio_ioctl,
2432         .capability             = IDE_CD_CAPABILITIES,
2433         .generic_packet         = ide_cdrom_packet,
2434 };
2435
2436 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2437 {
2438         struct cdrom_info *info = drive->driver_data;
2439         struct cdrom_device_info *devinfo = &info->devinfo;
2440
2441         devinfo->ops = &ide_cdrom_dops;
2442         devinfo->speed = info->current_speed;
2443         devinfo->capacity = nslots;
2444         devinfo->handle = drive;
2445         strcpy(devinfo->name, drive->name);
2446
2447         if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
2448                 devinfo->mask |= CDC_SELECT_SPEED;
2449
2450         devinfo->disk = info->disk;
2451         return register_cdrom(devinfo);
2452 }
2453
2454 static
2455 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2456 {
2457         struct cdrom_info *cd = drive->driver_data;
2458         struct cdrom_device_info *cdi = &cd->devinfo;
2459         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2460         mechtype_t mechtype;
2461         int nslots = 1;
2462
2463         cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
2464                      CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
2465                      CDC_MO_DRIVE | CDC_RAM);
2466
2467         if (drive->media == ide_optical) {
2468                 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
2469                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2470                 return nslots;
2471         }
2472
2473         if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
2474                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2475                 cdi->mask &= ~CDC_PLAY_AUDIO;
2476                 return nslots;
2477         }
2478
2479         /*
2480          * we have to cheat a little here. the packet will eventually
2481          * be queued with ide_cdrom_packet(), which extracts the
2482          * drive from cdi->handle. Since this device hasn't been
2483          * registered with the Uniform layer yet, it can't do this.
2484          * Same goes for cdi->ops.
2485          */
2486         cdi->handle = drive;
2487         cdi->ops = &ide_cdrom_dops;
2488
2489         if (ide_cdrom_get_capabilities(drive, buf))
2490                 return 0;
2491
2492         if ((buf[8 + 6] & 0x01) == 0)
2493                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
2494         if (buf[8 + 6] & 0x08)
2495                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2496         if (buf[8 + 3] & 0x01)
2497                 cdi->mask &= ~CDC_CD_R;
2498         if (buf[8 + 3] & 0x02)
2499                 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
2500         if (buf[8 + 2] & 0x38)
2501                 cdi->mask &= ~CDC_DVD;
2502         if (buf[8 + 3] & 0x20)
2503                 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
2504         if (buf[8 + 3] & 0x10)
2505                 cdi->mask &= ~CDC_DVD_R;
2506         if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
2507                 cdi->mask &= ~CDC_PLAY_AUDIO;
2508
2509         mechtype = buf[8 + 6] >> 5;
2510         if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
2511                 cdi->mask |= CDC_CLOSE_TRAY;
2512
2513         if (cdi->sanyo_slot > 0) {
2514                 cdi->mask &= ~CDC_SELECT_DISC;
2515                 nslots = 3;
2516         } else if (mechtype == mechtype_individual_changer ||
2517                    mechtype == mechtype_cartridge_changer) {
2518                 nslots = cdrom_number_of_slots(cdi);
2519                 if (nslots > 1)
2520                         cdi->mask &= ~CDC_SELECT_DISC;
2521         }
2522
2523         ide_cdrom_update_speed(drive, buf);
2524
2525         printk(KERN_INFO "%s: ATAPI", drive->name);
2526
2527         /* don't print speed if the drive reported 0 */
2528         if (cd->max_speed)
2529                 printk(KERN_CONT " %dX", cd->max_speed);
2530
2531         printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
2532
2533         if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
2534                 printk(KERN_CONT " DVD%s%s",
2535                                  (cdi->mask & CDC_DVD_R) ? "" : "-R",
2536                                  (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
2537
2538         if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
2539                 printk(KERN_CONT " CD%s%s",
2540                                  (cdi->mask & CDC_CD_R) ? "" : "-R",
2541                                  (cdi->mask & CDC_CD_RW) ? "" : "/RW");
2542
2543         if ((cdi->mask & CDC_SELECT_DISC) == 0)
2544                 printk(KERN_CONT " changer w/%d slots", nslots);
2545         else
2546                 printk(KERN_CONT " drive");
2547
2548         printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
2549
2550         return nslots;
2551 }
2552
2553 #ifdef CONFIG_IDE_PROC_FS
2554 static void ide_cdrom_add_settings(ide_drive_t *drive)
2555 {
2556         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
2557 }
2558 #else
2559 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
2560 #endif
2561
2562 /*
2563  * standard prep_rq_fn that builds 10 byte cmds
2564  */
2565 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
2566 {
2567         int hard_sect = queue_hardsect_size(q);
2568         long block = (long)rq->hard_sector / (hard_sect >> 9);
2569         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2570
2571         memset(rq->cmd, 0, sizeof(rq->cmd));
2572
2573         if (rq_data_dir(rq) == READ)
2574                 rq->cmd[0] = GPCMD_READ_10;
2575         else
2576                 rq->cmd[0] = GPCMD_WRITE_10;
2577
2578         /*
2579          * fill in lba
2580          */
2581         rq->cmd[2] = (block >> 24) & 0xff;
2582         rq->cmd[3] = (block >> 16) & 0xff;
2583         rq->cmd[4] = (block >>  8) & 0xff;
2584         rq->cmd[5] = block & 0xff;
2585
2586         /*
2587          * and transfer length
2588          */
2589         rq->cmd[7] = (blocks >> 8) & 0xff;
2590         rq->cmd[8] = blocks & 0xff;
2591         rq->cmd_len = 10;
2592         return BLKPREP_OK;
2593 }
2594
2595 /*
2596  * Most of the SCSI commands are supported directly by ATAPI devices.
2597  * This transform handles the few exceptions.
2598  */
2599 static int ide_cdrom_prep_pc(struct request *rq)
2600 {
2601         u8 *c = rq->cmd;
2602
2603         /*
2604          * Transform 6-byte read/write commands to the 10-byte version
2605          */
2606         if (c[0] == READ_6 || c[0] == WRITE_6) {
2607                 c[8] = c[4];
2608                 c[5] = c[3];
2609                 c[4] = c[2];
2610                 c[3] = c[1] & 0x1f;
2611                 c[2] = 0;
2612                 c[1] &= 0xe0;
2613                 c[0] += (READ_10 - READ_6);
2614                 rq->cmd_len = 10;
2615                 return BLKPREP_OK;
2616         }
2617
2618         /*
2619          * it's silly to pretend we understand 6-byte sense commands, just
2620          * reject with ILLEGAL_REQUEST and the caller should take the
2621          * appropriate action
2622          */
2623         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
2624                 rq->errors = ILLEGAL_REQUEST;
2625                 return BLKPREP_KILL;
2626         }
2627
2628         return BLKPREP_OK;
2629 }
2630
2631 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
2632 {
2633         if (blk_fs_request(rq))
2634                 return ide_cdrom_prep_fs(q, rq);
2635         else if (blk_pc_request(rq))
2636                 return ide_cdrom_prep_pc(rq);
2637
2638         return 0;
2639 }
2640
2641 struct cd_list_entry {
2642         const char      *id_model;
2643         const char      *id_firmware;
2644         unsigned int    cd_flags;
2645 };
2646
2647 static const struct cd_list_entry ide_cd_quirks_list[] = {
2648         /* Limit transfer size per interrupt. */
2649         { "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
2650         { "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
2651         /* SCR-3231 doesn't support the SET_CD_SPEED command. */
2652         { "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_CD_FLAG_NO_SPEED_SELECT    },
2653         /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
2654         { "NEC CD-ROM DRIVE:260",    "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
2655                                              IDE_CD_FLAG_PRE_ATAPI12,       },
2656         /* Vertos 300, some versions of this drive like to talk BCD. */
2657         { "V003S0DS",                NULL,   IDE_CD_FLAG_VERTOS_300_SSD,    },
2658         /* Vertos 600 ESD. */
2659         { "V006E0DS",                NULL,   IDE_CD_FLAG_VERTOS_600_ESD,    },
2660         /*
2661          * Sanyo 3 CD changer uses a non-standard command for CD changing
2662          * (by default standard ATAPI support for CD changers is used).
2663          */
2664         { "CD-ROM CDR-C3 G",         NULL,   IDE_CD_FLAG_SANYO_3CD          },
2665         { "CD-ROM CDR-C3G",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
2666         { "CD-ROM CDR_C36",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
2667         /* Stingray 8X CD-ROM. */
2668         { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
2669         /*
2670          * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
2671          * mode sense page capabilities size, but older drives break.
2672          */
2673         { "ATAPI CD ROM DRIVE 50X MAX", NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
2674         { "WPI CDS-32X",                NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
2675         /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
2676         { "",                        "241N", IDE_CD_FLAG_LE_SPEED_FIELDS    },
2677         /*
2678          * Some drives used by Apple don't advertise audio play
2679          * but they do support reading TOC & audio datas.
2680          */
2681         { "MATSHITADVD-ROM SR-8187", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2682         { "MATSHITADVD-ROM SR-8186", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2683         { "MATSHITADVD-ROM SR-8176", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2684         { "MATSHITADVD-ROM SR-8174", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2685         { NULL, NULL, 0 }
2686 };
2687
2688 static unsigned int ide_cd_flags(struct hd_driveid *id)
2689 {
2690         const struct cd_list_entry *cle = ide_cd_quirks_list;
2691
2692         while (cle->id_model) {
2693                 if (strcmp(cle->id_model, id->model) == 0 &&
2694                     (cle->id_firmware == NULL ||
2695                      strstr(id->fw_rev, cle->id_firmware)))
2696                         return cle->cd_flags;
2697                 cle++;
2698         }
2699
2700         return 0;
2701 }
2702
2703 static
2704 int ide_cdrom_setup (ide_drive_t *drive)
2705 {
2706         struct cdrom_info *cd = drive->driver_data;
2707         struct cdrom_device_info *cdi = &cd->devinfo;
2708         struct hd_driveid *id = drive->id;
2709         int nslots;
2710
2711         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
2712         blk_queue_dma_alignment(drive->queue, 31);
2713         drive->queue->unplug_delay = (1 * HZ) / 1000;
2714         if (!drive->queue->unplug_delay)
2715                 drive->queue->unplug_delay = 1;
2716
2717         drive->special.all      = 0;
2718
2719         cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
2720                        ide_cd_flags(id);
2721
2722         if ((id->config & 0x0060) == 0x20)
2723                 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
2724
2725         if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
2726             id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2727                 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
2728                                  IDE_CD_FLAG_TOCADDR_AS_BCD);
2729         else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
2730                  id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2731                 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
2732         else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
2733                 cdi->sanyo_slot = 3;    /* 3 => use CD in slot 0 */
2734
2735         nslots = ide_cdrom_probe_capabilities (drive);
2736
2737         /*
2738          * set correct block size
2739          */
2740         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
2741
2742         if (drive->autotune == IDE_TUNE_DEFAULT ||
2743             drive->autotune == IDE_TUNE_AUTO)
2744                 drive->dsc_overlap = (drive->next != drive);
2745
2746         if (ide_cdrom_register(drive, nslots)) {
2747                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
2748                 cd->devinfo.handle = NULL;
2749                 return 1;
2750         }
2751         ide_cdrom_add_settings(drive);
2752         return 0;
2753 }
2754
2755 #ifdef CONFIG_IDE_PROC_FS
2756 static
2757 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2758 {
2759         unsigned long capacity, sectors_per_frame;
2760
2761         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2762                 return 0;
2763
2764         return capacity * sectors_per_frame;
2765 }
2766 #endif
2767
2768 static void ide_cd_remove(ide_drive_t *drive)
2769 {
2770         struct cdrom_info *info = drive->driver_data;
2771
2772         ide_proc_unregister_driver(drive, info->driver);
2773
2774         del_gendisk(info->disk);
2775
2776         ide_cd_put(info);
2777 }
2778
2779 static void ide_cd_release(struct kref *kref)
2780 {
2781         struct cdrom_info *info = to_ide_cd(kref);
2782         struct cdrom_device_info *devinfo = &info->devinfo;
2783         ide_drive_t *drive = info->drive;
2784         struct gendisk *g = info->disk;
2785
2786         kfree(info->buffer);
2787         kfree(info->toc);
2788         if (devinfo->handle == drive && unregister_cdrom(devinfo))
2789                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2790                                 "driver.\n", __FUNCTION__, drive->name);
2791         drive->dsc_overlap = 0;
2792         drive->driver_data = NULL;
2793         blk_queue_prep_rq(drive->queue, NULL);
2794         g->private_data = NULL;
2795         put_disk(g);
2796         kfree(info);
2797 }
2798
2799 static int ide_cd_probe(ide_drive_t *);
2800
2801 #ifdef CONFIG_IDE_PROC_FS
2802 static int proc_idecd_read_capacity
2803         (char *page, char **start, off_t off, int count, int *eof, void *data)
2804 {
2805         ide_drive_t *drive = data;
2806         int len;
2807
2808         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2809         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2810 }
2811
2812 static ide_proc_entry_t idecd_proc[] = {
2813         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2814         { NULL, 0, NULL, NULL }
2815 };
2816 #endif
2817
2818 static ide_driver_t ide_cdrom_driver = {
2819         .gen_driver = {
2820                 .owner          = THIS_MODULE,
2821                 .name           = "ide-cdrom",
2822                 .bus            = &ide_bus_type,
2823         },
2824         .probe                  = ide_cd_probe,
2825         .remove                 = ide_cd_remove,
2826         .version                = IDECD_VERSION,
2827         .media                  = ide_cdrom,
2828         .supports_dsc_overlap   = 1,
2829         .do_request             = ide_do_rw_cdrom,
2830         .end_request            = ide_end_request,
2831         .error                  = __ide_error,
2832         .abort                  = __ide_abort,
2833 #ifdef CONFIG_IDE_PROC_FS
2834         .proc                   = idecd_proc,
2835 #endif
2836 };
2837
2838 static int idecd_open(struct inode * inode, struct file * file)
2839 {
2840         struct gendisk *disk = inode->i_bdev->bd_disk;
2841         struct cdrom_info *info;
2842         int rc = -ENOMEM;
2843
2844         if (!(info = ide_cd_get(disk)))
2845                 return -ENXIO;
2846
2847         if (!info->buffer)
2848                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2849
2850         if (info->buffer)
2851                 rc = cdrom_open(&info->devinfo, inode, file);
2852
2853         if (rc < 0)
2854                 ide_cd_put(info);
2855
2856         return rc;
2857 }
2858
2859 static int idecd_release(struct inode * inode, struct file * file)
2860 {
2861         struct gendisk *disk = inode->i_bdev->bd_disk;
2862         struct cdrom_info *info = ide_cd_g(disk);
2863
2864         cdrom_release (&info->devinfo, file);
2865
2866         ide_cd_put(info);
2867
2868         return 0;
2869 }
2870
2871 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2872 {
2873         struct packet_command cgc;
2874         char buffer[16];
2875         int stat;
2876         char spindown;
2877
2878         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2879                 return -EFAULT;
2880
2881         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2882
2883         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2884         if (stat)
2885                 return stat;
2886
2887         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2888         return cdrom_mode_select(cdi, &cgc);
2889 }
2890
2891 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2892 {
2893         struct packet_command cgc;
2894         char buffer[16];
2895         int stat;
2896         char spindown;
2897
2898         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2899
2900         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2901         if (stat)
2902                 return stat;
2903
2904         spindown = buffer[11] & 0x0f;
2905         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2906                 return -EFAULT;
2907         return 0;
2908 }
2909
2910 static int idecd_ioctl (struct inode *inode, struct file *file,
2911                         unsigned int cmd, unsigned long arg)
2912 {
2913         struct block_device *bdev = inode->i_bdev;
2914         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2915         int err;
2916
2917         switch (cmd) {
2918         case CDROMSETSPINDOWN:
2919                 return idecd_set_spindown(&info->devinfo, arg);
2920         case CDROMGETSPINDOWN:
2921                 return idecd_get_spindown(&info->devinfo, arg);
2922         default:
2923                 break;
2924         }
2925
2926         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
2927         if (err == -EINVAL)
2928                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2929
2930         return err;
2931 }
2932
2933 static int idecd_media_changed(struct gendisk *disk)
2934 {
2935         struct cdrom_info *info = ide_cd_g(disk);
2936         return cdrom_media_changed(&info->devinfo);
2937 }
2938
2939 static int idecd_revalidate_disk(struct gendisk *disk)
2940 {
2941         struct cdrom_info *info = ide_cd_g(disk);
2942         struct request_sense sense;
2943
2944         ide_cd_read_toc(info->drive, &sense);
2945
2946         return  0;
2947 }
2948
2949 static struct block_device_operations idecd_ops = {
2950         .owner          = THIS_MODULE,
2951         .open           = idecd_open,
2952         .release        = idecd_release,
2953         .ioctl          = idecd_ioctl,
2954         .media_changed  = idecd_media_changed,
2955         .revalidate_disk= idecd_revalidate_disk
2956 };
2957
2958 /* options */
2959 static char *ignore = NULL;
2960
2961 module_param(ignore, charp, 0400);
2962 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2963
2964 static int ide_cd_probe(ide_drive_t *drive)
2965 {
2966         struct cdrom_info *info;
2967         struct gendisk *g;
2968         struct request_sense sense;
2969
2970         if (!strstr("ide-cdrom", drive->driver_req))
2971                 goto failed;
2972         if (!drive->present)
2973                 goto failed;
2974         if (drive->media != ide_cdrom && drive->media != ide_optical)
2975                 goto failed;
2976         /* skip drives that we were told to ignore */
2977         if (ignore != NULL) {
2978                 if (strstr(ignore, drive->name)) {
2979                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2980                         goto failed;
2981                 }
2982         }
2983         if (drive->scsi) {
2984                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2985                 goto failed;
2986         }
2987         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
2988         if (info == NULL) {
2989                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
2990                 goto failed;
2991         }
2992
2993         g = alloc_disk(1 << PARTN_BITS);
2994         if (!g)
2995                 goto out_free_cd;
2996
2997         ide_init_disk(g, drive);
2998
2999         ide_proc_register_driver(drive, &ide_cdrom_driver);
3000
3001         kref_init(&info->kref);
3002
3003         info->drive = drive;
3004         info->driver = &ide_cdrom_driver;
3005         info->disk = g;
3006
3007         g->private_data = &info->driver;
3008
3009         drive->driver_data = info;
3010
3011         g->minors = 1;
3012         g->driverfs_dev = &drive->gendev;
3013         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3014         if (ide_cdrom_setup(drive)) {
3015                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
3016                 ide_cd_release(&info->kref);
3017                 goto failed;
3018         }
3019
3020         ide_cd_read_toc(drive, &sense);
3021         g->fops = &idecd_ops;
3022         g->flags |= GENHD_FL_REMOVABLE;
3023         add_disk(g);
3024         return 0;
3025
3026 out_free_cd:
3027         kfree(info);
3028 failed:
3029         return -ENODEV;
3030 }
3031
3032 static void __exit ide_cdrom_exit(void)
3033 {
3034         driver_unregister(&ide_cdrom_driver.gen_driver);
3035 }
3036
3037 static int __init ide_cdrom_init(void)
3038 {
3039         return driver_register(&ide_cdrom_driver.gen_driver);
3040 }
3041
3042 MODULE_ALIAS("ide:*m-cdrom*");
3043 MODULE_ALIAS("ide-cd");
3044 module_init(ide_cdrom_init);
3045 module_exit(ide_cdrom_exit);
3046 MODULE_LICENSE("GPL");