git.oblomov.eu Git - linux-2.6/blob - drivers/ide/ide-cd.c

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