drivers/ide/ide-cd.c

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