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 static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
 608 {
 609         while (len > 0) {
 610                 int dum = 0;
 611                 xf(drive, &dum, sizeof(dum));
 612                 len -= sizeof(dum);
 613         }
 614 }
 615
 616 static void ide_cd_drain_data(ide_drive_t *drive, int nsects)
 617 {
 618         while (nsects > 0) {
 619                 static char dum[SECTOR_SIZE];
 620
 621                 drive->hwif->atapi_input_bytes(drive, dum, sizeof(dum));
 622                 nsects--;
 623         }
 624 }
 625
 626 /*
 627  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
 628  * buffer.  Once the first sector is added, any subsequent sectors are
 629  * assumed to be continuous (until the buffer is cleared).  For the first
 630  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
 631  * the buffer is cleared.)
 632  */
 633 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
 634                                   int sectors_to_transfer)
 635 {
 636         struct cdrom_info *info = drive->driver_data;
 637
 638         /* Number of sectors to read into the buffer. */
 639         int sectors_to_buffer = min_t(int, sectors_to_transfer,
 640                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
 641                                        info->nsectors_buffered);
 642
 643         char *dest;
 644
 645         /* If we couldn't get a buffer, don't try to buffer anything... */
 646         if (info->buffer == NULL)
 647                 sectors_to_buffer = 0;
 648
 649         /* If this is the first sector in the buffer, remember its number. */
 650         if (info->nsectors_buffered == 0)
 651                 info->sector_buffered = sector;
 652
 653         /* Read the data into the buffer. */
 654         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
 655         while (sectors_to_buffer > 0) {
 656                 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
 657                 --sectors_to_buffer;
 658                 --sectors_to_transfer;
 659                 ++info->nsectors_buffered;
 660                 dest += SECTOR_SIZE;
 661         }
 662
 663         /* Throw away any remaining data. */
 664         ide_cd_drain_data(drive, sectors_to_transfer);
 665 }
 666
 667 /*
 668  * Check the contents of the interrupt reason register from the cdrom
 669  * and attempt to recover if there are problems.  Returns  0 if everything's
 670  * ok; nonzero if the request has been terminated.
 671  */
 672 static
 673 int ide_cd_check_ireason(ide_drive_t *drive, int len, int ireason, int rw)
 674 {
 675         /*
 676          * ireason == 0: the drive wants to receive data from us
 677          * ireason == 2: the drive is expecting to transfer data to us
 678          */
 679         if (ireason == (!rw << 1))
 680                 return 0;
 681         else if (ireason == (rw << 1)) {
 682                 ide_hwif_t *hwif = drive->hwif;
 683                 xfer_func_t *xf;
 684
 685                 /* Whoops... */
 686                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
 687                                 drive->name, __FUNCTION__);
 688
 689                 xf = rw ? hwif->atapi_output_bytes : hwif->atapi_input_bytes;
 690                 ide_cd_pad_transfer(drive, xf, len);
 691         } else  if (rw == 0 && ireason == 1) {
 692                 /* Some drives (ASUS) seem to tell us that status
 693                  * info is available. just get it and ignore.
 694                  */
 695                 (void) HWIF(drive)->INB(IDE_STATUS_REG);
 696                 return 0;
 697         } else {
 698                 /* Drive wants a command packet, or invalid ireason... */
 699                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
 700                                 drive->name, __FUNCTION__, ireason);
 701         }
 702
 703         cdrom_end_request(drive, 0);
 704         return -1;
 705 }
 706
 707 /*
 708  * Assume that the drive will always provide data in multiples of at least
 709  * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise.
 710  */
 711 static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
 712 {
 713         struct cdrom_info *cd = drive->driver_data;
 714
 715         if ((len % SECTOR_SIZE) == 0)
 716                 return 0;
 717
 718         printk(KERN_ERR "%s: %s: Bad transfer size %d\n",
 719                         drive->name, __FUNCTION__, len);
 720
 721         if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
 722                 printk(KERN_ERR "  This drive is not supported by "
 723                                 "this version of the driver\n");
 724         else {
 725                 printk(KERN_ERR "  Trying to limit transfer sizes\n");
 726                 cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
 727         }
 728
 729         return 1;
 730 }
 731
 732 /*
 733  * Try to satisfy some of the current read request from our cached data.
 734  * Returns nonzero if the request has been completed, zero otherwise.
 735  */
 736 static int cdrom_read_from_buffer (ide_drive_t *drive)
 737 {
 738         struct cdrom_info *info = drive->driver_data;
 739         struct request *rq = HWGROUP(drive)->rq;
 740         unsigned short sectors_per_frame;
 741
 742         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
 743
 744         /* Can't do anything if there's no buffer. */
 745         if (info->buffer == NULL) return 0;
 746
 747         /* Loop while this request needs data and the next block is present
 748            in our cache. */
 749         while (rq->nr_sectors > 0 &&
 750                rq->sector >= info->sector_buffered &&
 751                rq->sector < info->sector_buffered + info->nsectors_buffered) {
 752                 if (rq->current_nr_sectors == 0)
 753                         cdrom_end_request(drive, 1);
 754
 755                 memcpy (rq->buffer,
 756                         info->buffer +
 757                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
 758                         SECTOR_SIZE);
 759                 rq->buffer += SECTOR_SIZE;
 760                 --rq->current_nr_sectors;
 761                 --rq->nr_sectors;
 762                 ++rq->sector;
 763         }
 764
 765         /* If we've satisfied the current request,
 766            terminate it successfully. */
 767         if (rq->nr_sectors == 0) {
 768                 cdrom_end_request(drive, 1);
 769                 return -1;
 770         }
 771
 772         /* Move on to the next buffer if needed. */
 773         if (rq->current_nr_sectors == 0)
 774                 cdrom_end_request(drive, 1);
 775
 776         /* If this condition does not hold, then the kluge i use to
 777            represent the number of sectors to skip at the start of a transfer
 778            will fail.  I think that this will never happen, but let's be
 779            paranoid and check. */
 780         if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
 781             (rq->sector & (sectors_per_frame - 1))) {
 782                 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
 783                         drive->name, (long)rq->sector);
 784                 cdrom_end_request(drive, 0);
 785                 return -1;
 786         }
 787
 788         return 0;
 789 }
 790
 791 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
 792
 793 /*
 794  * Routine to send a read/write packet command to the drive.
 795  * This is usually called directly from cdrom_start_{read,write}().
 796  * However, for drq_interrupt devices, it is called from an interrupt
 797  * when the drive is ready to accept the command.
 798  */
 799 static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
 800 {
 801         struct request *rq = HWGROUP(drive)->rq;
 802
 803         if (rq_data_dir(rq) == READ) {
 804                 unsigned short sectors_per_frame =
 805                         queue_hardsect_size(drive->queue) >> SECTOR_BITS;
 806                 int nskip = rq->sector & (sectors_per_frame - 1);
 807
 808                 /*
 809                  * If the requested sector doesn't start on a frame boundary,
 810                  * we must adjust the start of the transfer so that it does,
 811                  * and remember to skip the first few sectors.
 812                  *
 813                  * If the rq->current_nr_sectors field is larger than the size
 814                  * of the buffer, it will mean that we're to skip a number of
 815                  * sectors equal to the amount by which rq->current_nr_sectors
 816                  * is larger than the buffer size.
 817                  */
 818                 if (nskip > 0) {
 819                         /* Sanity check... */
 820                         if (rq->current_nr_sectors !=
 821                             bio_cur_sectors(rq->bio)) {
 822                                 printk(KERN_ERR "%s: %s: buffer botch (%u)\n",
 823                                                 drive->name, __FUNCTION__,
 824                                                 rq->current_nr_sectors);
 825                                 cdrom_end_request(drive, 0);
 826                                 return ide_stopped;
 827                         }
 828                         rq->current_nr_sectors += nskip;
 829                 }
 830         }
 831 #if 0
 832         else
 833                 /* the immediate bit */
 834                 rq->cmd[1] = 1 << 3;
 835 #endif
 836         /* Set up the command */
 837         rq->timeout = ATAPI_WAIT_PC;
 838
 839         /* Send the command to the drive and return. */
 840         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
 841 }
 842
 843 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
 844 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
 845 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
 846
 847 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
 848 {
 849         struct cdrom_info *info = drive->driver_data;
 850         int stat;
 851         static int retry = 10;
 852
 853         if (cdrom_decode_status(drive, 0, &stat))
 854                 return ide_stopped;
 855
 856         info->cd_flags |= IDE_CD_FLAG_SEEKING;
 857
 858         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
 859                 if (--retry == 0) {
 860                         /*
 861                          * this condition is far too common, to bother
 862                          * users about it
 863                          */
 864                         /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
 865                         drive->dsc_overlap = 0;
 866                 }
 867         }
 868         return ide_stopped;
 869 }
 870
 871 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
 872 {
 873         struct request *rq = HWGROUP(drive)->rq;
 874         sector_t frame = rq->sector;
 875
 876         sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
 877
 878         memset(rq->cmd, 0, sizeof(rq->cmd));
 879         rq->cmd[0] = GPCMD_SEEK;
 880         put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
 881
 882         rq->timeout = ATAPI_WAIT_PC;
 883         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
 884 }
 885
 886 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
 887 {
 888         struct cdrom_info *info = drive->driver_data;
 889
 890         info->dma = 0;
 891         info->start_seek = jiffies;
 892         return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
 893 }
 894
 895 /* Fix up a possibly partially-processed request so that we can
 896    start it over entirely, or even put it back on the request queue. */
 897 static void restore_request (struct request *rq)
 898 {
 899         if (rq->buffer != bio_data(rq->bio)) {
 900                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
 901
 902                 rq->buffer = bio_data(rq->bio);
 903                 rq->nr_sectors += n;
 904                 rq->sector -= n;
 905         }
 906         rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
 907         rq->hard_nr_sectors = rq->nr_sectors;
 908         rq->hard_sector = rq->sector;
 909         rq->q->prep_rq_fn(rq->q, rq);
 910 }
 911
 912 /****************************************************************************
 913  * Execute all other packet commands.
 914  */
 915
 916 static void ide_cd_request_sense_fixup(struct request *rq)
 917 {
 918         /*
 919          * Some of the trailing request sense fields are optional,
 920          * and some drives don't send them.  Sigh.
 921          */
 922         if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
 923             rq->data_len > 0 && rq->data_len <= 5)
 924                 while (rq->data_len > 0) {
 925                         *(u8 *)rq->data++ = 0;
 926                         --rq->data_len;
 927                 }
 928 }
 929
 930 int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
 931 {
 932         struct request_sense sense;
 933         int retries = 10;
 934         unsigned int flags = rq->cmd_flags;
 935
 936         if (rq->sense == NULL)
 937                 rq->sense = &sense;
 938
 939         /* Start of retry loop. */
 940         do {
 941                 int error;
 942                 unsigned long time = jiffies;
 943                 rq->cmd_flags = flags;
 944
 945                 error = ide_do_drive_cmd(drive, rq, ide_wait);
 946                 time = jiffies - time;
 947
 948                 /* FIXME: we should probably abort/retry or something
 949                  * in case of failure */
 950                 if (rq->cmd_flags & REQ_FAILED) {
 951                         /* The request failed.  Retry if it was due to a unit
 952                            attention status
 953                            (usually means media was changed). */
 954                         struct request_sense *reqbuf = rq->sense;
 955
 956                         if (reqbuf->sense_key == UNIT_ATTENTION)
 957                                 cdrom_saw_media_change(drive);
 958                         else if (reqbuf->sense_key == NOT_READY &&
 959                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
 960                                 /* The drive is in the process of loading
 961                                    a disk.  Retry, but wait a little to give
 962                                    the drive time to complete the load. */
 963                                 ssleep(2);
 964                         } else {
 965                                 /* Otherwise, don't retry. */
 966                                 retries = 0;
 967                         }
 968                         --retries;
 969                 }
 970
 971                 /* End of retry loop. */
 972         } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
 973
 974         /* Return an error if the command failed. */
 975         return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
 976 }
 977
 978 /*
 979  * Called from blk_end_request_callback() after the data of the request
 980  * is completed and before the request is completed.
 981  * By returning value '1', blk_end_request_callback() returns immediately
 982  * without completing the request.
 983  */
 984 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
 985 {
 986         return 1;
 987 }
 988
 989 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
 990 {
 991         struct cdrom_info *info = drive->driver_data;
 992         struct request *rq = HWGROUP(drive)->rq;
 993         xfer_func_t *xferfunc;
 994         ide_expiry_t *expiry = NULL;
 995         int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0;
 996         int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
 997         unsigned int timeout;
 998         u8 lowcyl, highcyl;
 999
1000         /* Check for errors. */
1001         dma = info->dma;
1002         if (dma) {
1003                 info->dma = 0;
1004                 dma_error = HWIF(drive)->ide_dma_end(drive);
1005                 if (dma_error) {
1006                         printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1007                                         write ? "write" : "read");
1008                         ide_dma_off(drive);
1009                 }
1010         }
1011
1012         if (cdrom_decode_status(drive, 0, &stat))
1013                 return ide_stopped;
1014
1015         /*
1016          * using dma, transfer is complete now
1017          */
1018         if (dma) {
1019                 if (dma_error)
1020                         return ide_error(drive, "dma error", stat);
1021                 if (blk_fs_request(rq)) {
1022                         ide_end_request(drive, 1, rq->nr_sectors);
1023                         return ide_stopped;
1024                 }
1025                 goto end_request;
1026         }
1027
1028         /*
1029          * ok we fall to pio :/
1030          */
1031         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1032         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1033         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1034
1035         len = lowcyl + (256 * highcyl);
1036
1037         thislen = blk_fs_request(rq) ? len : rq->data_len;
1038         if (thislen > len)
1039                 thislen = len;
1040
1041         /*
1042          * If DRQ is clear, the command has completed.
1043          */
1044         if ((stat & DRQ_STAT) == 0) {
1045                 if (blk_fs_request(rq)) {
1046                         /*
1047                          * If we're not done reading/writing, complain.
1048                          * Otherwise, complete the command normally.
1049                          */
1050                         uptodate = 1;
1051                         if (rq->current_nr_sectors > 0) {
1052                                 printk(KERN_ERR "%s: %s: data underrun "
1053                                                 "(%d blocks)\n",
1054                                                 drive->name, __FUNCTION__,
1055                                                 rq->current_nr_sectors);
1056                                 if (!write)
1057                                         rq->cmd_flags |= REQ_FAILED;
1058                                 uptodate = 0;
1059                         }
1060                         cdrom_end_request(drive, uptodate);
1061                         return ide_stopped;
1062                 } else if (!blk_pc_request(rq)) {
1063                         ide_cd_request_sense_fixup(rq);
1064                         /* Complain if we still have data left to transfer. */
1065                         uptodate = rq->data_len ? 0 : 1;
1066                 }
1067                 goto end_request;
1068         }
1069
1070         /*
1071          * check which way to transfer data
1072          */
1073         if (blk_fs_request(rq) || blk_pc_request(rq)) {
1074                 if (ide_cd_check_ireason(drive, len, ireason, write))
1075                         return ide_stopped;
1076
1077                 if (blk_fs_request(rq) && write == 0) {
1078                         int nskip;
1079
1080                         if (ide_cd_check_transfer_size(drive, len)) {
1081                                 cdrom_end_request(drive, 0);
1082                                 return ide_stopped;
1083                         }
1084
1085                         /*
1086                          * First, figure out if we need to bit-bucket
1087                          * any of the leading sectors.
1088                          */
1089                         nskip = min_t(int, rq->current_nr_sectors
1090                                            - bio_cur_sectors(rq->bio),
1091                                            thislen >> 9);
1092                         if (nskip > 0) {
1093                                 ide_cd_drain_data(drive, nskip);
1094                                 rq->current_nr_sectors -= nskip;
1095                                 thislen -= (nskip << 9);
1096                         }
1097                 }
1098         }
1099
1100         if (ireason == 0) {
1101                 write = 1;
1102                 xferfunc = HWIF(drive)->atapi_output_bytes;
1103         } else if (ireason == 2 || (ireason == 1 &&
1104                    (blk_fs_request(rq) || blk_pc_request(rq)))) {
1105                 write = 0;
1106                 xferfunc = HWIF(drive)->atapi_input_bytes;
1107         } else {
1108                 printk(KERN_ERR "%s: %s: The drive "
1109                                 "appears confused (ireason = 0x%02x). "
1110                                 "Trying to recover by ending request.\n",
1111                                 drive->name, __FUNCTION__, ireason);
1112                 goto end_request;
1113         }
1114
1115         /*
1116          * transfer data
1117          */
1118         while (thislen > 0) {
1119                 u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
1120                 int blen = rq->data_len;
1121
1122                 /*
1123                  * bio backed?
1124                  */
1125                 if (rq->bio) {
1126                         if (blk_fs_request(rq)) {
1127                                 ptr = rq->buffer;
1128                                 blen = rq->current_nr_sectors << 9;
1129                         } else {
1130                                 ptr = bio_data(rq->bio);
1131                                 blen = bio_iovec(rq->bio)->bv_len;
1132                         }
1133                 }
1134
1135                 if (!ptr) {
1136                         if (blk_fs_request(rq) && !write)
1137                                 /*
1138                                  * If the buffers are full, cache the rest
1139                                  * of the data in our internal buffer.
1140                                  */
1141                                 cdrom_buffer_sectors(drive, rq->sector,
1142                                                      thislen >> 9);
1143                         else {
1144                                 printk(KERN_ERR "%s: confused, missing data\n",
1145                                                 drive->name);
1146                                 blk_dump_rq_flags(rq, rq_data_dir(rq)
1147                                                   ? "cdrom_newpc_intr, write"
1148                                                   : "cdrom_newpc_intr, read");
1149                         }
1150                         break;
1151                 }
1152
1153                 if (blen > thislen)
1154                         blen = thislen;
1155
1156                 xferfunc(drive, ptr, blen);
1157
1158                 thislen -= blen;
1159                 len -= blen;
1160
1161                 if (blk_fs_request(rq)) {
1162                         rq->buffer += blen;
1163                         rq->nr_sectors -= (blen >> 9);
1164                         rq->current_nr_sectors -= (blen >> 9);
1165                         rq->sector += (blen >> 9);
1166
1167                         if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1168                                 cdrom_end_request(drive, 1);
1169                 } else {
1170                         rq->data_len -= blen;
1171
1172                         /*
1173                          * The request can't be completed until DRQ is cleared.
1174                          * So complete the data, but don't complete the request
1175                          * using the dummy function for the callback feature
1176                          * of blk_end_request_callback().
1177                          */
1178                         if (rq->bio)
1179                                 blk_end_request_callback(rq, 0, blen,
1180                                                  cdrom_newpc_intr_dummy_cb);
1181                         else
1182                                 rq->data += blen;
1183                 }
1184         }
1185
1186         if (write && blk_sense_request(rq))
1187                 rq->sense_len += thislen;
1188
1189         /*
1190          * pad, if necessary
1191          */
1192         if (!blk_fs_request(rq) && len > 0)
1193                 ide_cd_pad_transfer(drive, xferfunc, len);
1194
1195         if (blk_pc_request(rq)) {
1196                 timeout = rq->timeout;
1197         } else {
1198                 timeout = ATAPI_WAIT_PC;
1199                 if (!blk_fs_request(rq))
1200                         expiry = cdrom_timer_expiry;
1201         }
1202
1203         ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
1204         return ide_started;
1205
1206 end_request:
1207         if (blk_pc_request(rq)) {
1208                 unsigned long flags;
1209
1210                 spin_lock_irqsave(&ide_lock, flags);
1211                 if (__blk_end_request(rq, 0, rq->data_len))
1212                         BUG();
1213                 HWGROUP(drive)->rq = NULL;
1214                 spin_unlock_irqrestore(&ide_lock, flags);
1215         } else {
1216                 if (!uptodate)
1217                         rq->cmd_flags |= REQ_FAILED;
1218                 cdrom_end_request(drive, uptodate);
1219         }
1220         return ide_stopped;
1221 }
1222
1223 static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
1224 {
1225         struct cdrom_info *cd = drive->driver_data;
1226         int write = rq_data_dir(rq) == WRITE;
1227         unsigned short sectors_per_frame =
1228                 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1229
1230         if (write) {
1231                 /*
1232                  * disk has become write protected
1233                  */
1234                 if (cd->disk->policy) {
1235                         cdrom_end_request(drive, 0);
1236                         return ide_stopped;
1237                 }
1238         } else {
1239                 /*
1240                  * We may be retrying this request after an error.  Fix up any
1241                  * weirdness which might be present in the request packet.
1242                  */
1243                 restore_request(rq);
1244
1245                 /* Satisfy whatever we can of this request from our cache. */
1246                 if (cdrom_read_from_buffer(drive))
1247                         return ide_stopped;
1248         }
1249
1250         /*
1251          * use DMA, if possible / writes *must* be hardware frame aligned
1252          */
1253         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1254             (rq->sector & (sectors_per_frame - 1))) {
1255                 if (write) {
1256                         cdrom_end_request(drive, 0);
1257                         return ide_stopped;
1258                 }
1259                 cd->dma = 0;
1260         } else
1261                 cd->dma = drive->using_dma;
1262
1263         /* Clear the local sector buffer. */
1264         cd->nsectors_buffered = 0;
1265
1266         if (write)
1267                 cd->devinfo.media_written = 1;
1268
1269         /* Start sending the read/write request to the drive. */
1270         return cdrom_start_packet_command(drive, 32768, cdrom_start_rw_cont);
1271 }
1272
1273 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1274 {
1275         struct request *rq = HWGROUP(drive)->rq;
1276
1277         if (!rq->timeout)
1278                 rq->timeout = ATAPI_WAIT_PC;
1279
1280         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1281 }
1282
1283 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1284 {
1285         struct cdrom_info *info = drive->driver_data;
1286
1287         if (blk_pc_request(rq))
1288                 rq->cmd_flags |= REQ_QUIET;
1289         else
1290                 rq->cmd_flags &= ~REQ_FAILED;
1291
1292         info->dma = 0;
1293
1294         /*
1295          * sg request
1296          */
1297         if (rq->bio) {
1298                 int mask = drive->queue->dma_alignment;
1299                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1300
1301                 info->dma = drive->using_dma;
1302
1303                 /*
1304                  * check if dma is safe
1305                  *
1306                  * NOTE! The "len" and "addr" checks should possibly have
1307                  * separate masks.
1308                  */
1309                 if ((rq->data_len & 15) || (addr & mask))
1310                         info->dma = 0;
1311         }
1312
1313         /* Start sending the command to the drive. */
1314         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1315 }
1316
1317 /****************************************************************************
1318  * cdrom driver request routine.
1319  */
1320 static ide_startstop_t
1321 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1322 {
1323         ide_startstop_t action;
1324         struct cdrom_info *info = drive->driver_data;
1325
1326         if (blk_fs_request(rq)) {
1327                 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1328                         unsigned long elapsed = jiffies - info->start_seek;
1329                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1330
1331                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1332                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1333                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1334                                         return ide_stopped;
1335                                 }
1336                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1337                         }
1338                         info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1339                 }
1340                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1341                         action = cdrom_start_seek(drive, block);
1342                 } else
1343                         action = cdrom_start_rw(drive, rq);
1344                 info->last_block = block;
1345                 return action;
1346         } else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1347                    rq->cmd_type == REQ_TYPE_ATA_PC) {
1348                 return cdrom_do_block_pc(drive, rq);
1349         } else if (blk_special_request(rq)) {
1350                 /*
1351                  * right now this can only be a reset...
1352                  */
1353                 cdrom_end_request(drive, 1);
1354                 return ide_stopped;
1355         }
1356
1357         blk_dump_rq_flags(rq, "ide-cd bad flags");
1358         cdrom_end_request(drive, 0);
1359         return ide_stopped;
1360 }
1361
1362
1363
1364 /****************************************************************************
1365  * Ioctl handling.
1366  *
1367  * Routines which queue packet commands take as a final argument a pointer
1368  * to a request_sense struct.  If execution of the command results
1369  * in an error with a CHECK CONDITION status, this structure will be filled
1370  * with the results of the subsequent request sense command.  The pointer
1371  * can also be NULL, in which case no sense information is returned.
1372  */
1373
1374 static
1375 void msf_from_bcd (struct atapi_msf *msf)
1376 {
1377         msf->minute = BCD2BIN(msf->minute);
1378         msf->second = BCD2BIN(msf->second);
1379         msf->frame  = BCD2BIN(msf->frame);
1380 }
1381
1382 int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1383 {
1384         struct request req;
1385         struct cdrom_info *info = drive->driver_data;
1386         struct cdrom_device_info *cdi = &info->devinfo;
1387
1388         ide_cd_init_rq(drive, &req);
1389
1390         req.sense = sense;
1391         req.cmd[0] = GPCMD_TEST_UNIT_READY;
1392         req.cmd_flags |= REQ_QUIET;
1393
1394         /*
1395          * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1396          * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1397          */
1398         req.cmd[7] = cdi->sanyo_slot % 3;
1399
1400         return ide_cd_queue_pc(drive, &req);
1401 }
1402
1403 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1404                                unsigned long *sectors_per_frame,
1405                                struct request_sense *sense)
1406 {
1407         struct {
1408                 __u32 lba;
1409                 __u32 blocklen;
1410         } capbuf;
1411
1412         int stat;
1413         struct request req;
1414
1415         ide_cd_init_rq(drive, &req);
1416
1417         req.sense = sense;
1418         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1419         req.data = (char *)&capbuf;
1420         req.data_len = sizeof(capbuf);
1421         req.cmd_flags |= REQ_QUIET;
1422
1423         stat = ide_cd_queue_pc(drive, &req);
1424         if (stat == 0) {
1425                 *capacity = 1 + be32_to_cpu(capbuf.lba);
1426                 *sectors_per_frame =
1427                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1428         }
1429
1430         return stat;
1431 }
1432
1433 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1434                                 int format, char *buf, int buflen,
1435                                 struct request_sense *sense)
1436 {
1437         struct request req;
1438
1439         ide_cd_init_rq(drive, &req);
1440
1441         req.sense = sense;
1442         req.data =  buf;
1443         req.data_len = buflen;
1444         req.cmd_flags |= REQ_QUIET;
1445         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1446         req.cmd[6] = trackno;
1447         req.cmd[7] = (buflen >> 8);
1448         req.cmd[8] = (buflen & 0xff);
1449         req.cmd[9] = (format << 6);
1450
1451         if (msf_flag)
1452                 req.cmd[1] = 2;
1453
1454         return ide_cd_queue_pc(drive, &req);
1455 }
1456
1457 /* Try to read the entire TOC for the disk into our internal buffer. */
1458 int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
1459 {
1460         int stat, ntracks, i;
1461         struct cdrom_info *info = drive->driver_data;
1462         struct cdrom_device_info *cdi = &info->devinfo;
1463         struct atapi_toc *toc = info->toc;
1464         struct {
1465                 struct atapi_toc_header hdr;
1466                 struct atapi_toc_entry  ent;
1467         } ms_tmp;
1468         long last_written;
1469         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1470
1471         if (toc == NULL) {
1472                 /* Try to allocate space. */
1473                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1474                 if (toc == NULL) {
1475                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1476                         return -ENOMEM;
1477                 }
1478                 info->toc = toc;
1479         }
1480
1481         /* Check to see if the existing data is still valid.
1482            If it is, just return. */
1483         (void) cdrom_check_status(drive, sense);
1484
1485         if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
1486                 return 0;
1487
1488         /* Try to get the total cdrom capacity and sector size. */
1489         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
1490                                    sense);
1491         if (stat)
1492                 toc->capacity = 0x1fffff;
1493
1494         set_capacity(info->disk, toc->capacity * sectors_per_frame);
1495         /* Save a private copy of te TOC capacity for error handling */
1496         drive->probed_capacity = toc->capacity * sectors_per_frame;
1497
1498         blk_queue_hardsect_size(drive->queue,
1499                                 sectors_per_frame << SECTOR_BITS);
1500
1501         /* First read just the header, so we know how long the TOC is. */
1502         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1503                                     sizeof(struct atapi_toc_header), sense);
1504         if (stat)
1505                 return stat;
1506
1507         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1508                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1509                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1510         }
1511
1512         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1513         if (ntracks <= 0)
1514                 return -EIO;
1515         if (ntracks > MAX_TRACKS)
1516                 ntracks = MAX_TRACKS;
1517
1518         /* Now read the whole schmeer. */
1519         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1520                                   (char *)&toc->hdr,
1521                                    sizeof(struct atapi_toc_header) +
1522                                    (ntracks + 1) *
1523                                    sizeof(struct atapi_toc_entry), sense);
1524
1525         if (stat && toc->hdr.first_track > 1) {
1526                 /* Cds with CDI tracks only don't have any TOC entries,
1527                    despite of this the returned values are
1528                    first_track == last_track = number of CDI tracks + 1,
1529                    so that this case is indistinguishable from the same
1530                    layout plus an additional audio track.
1531                    If we get an error for the regular case, we assume
1532                    a CDI without additional audio tracks. In this case
1533                    the readable TOC is empty (CDI tracks are not included)
1534                    and only holds the Leadout entry. Heiko Eißfeldt */
1535                 ntracks = 0;
1536                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1537                                            (char *)&toc->hdr,
1538                                            sizeof(struct atapi_toc_header) +
1539                                            (ntracks + 1) *
1540                                            sizeof(struct atapi_toc_entry),
1541                                            sense);
1542                 if (stat)
1543                         return stat;
1544
1545                 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1546                         toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1547                         toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
1548                 } else {
1549                         toc->hdr.first_track = CDROM_LEADOUT;
1550                         toc->hdr.last_track = CDROM_LEADOUT;
1551                 }
1552         }
1553
1554         if (stat)
1555                 return stat;
1556
1557         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1558
1559         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1560                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1561                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1562         }
1563
1564         for (i = 0; i <= ntracks; i++) {
1565                 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1566                         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
1567                                 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
1568                         msf_from_bcd(&toc->ent[i].addr.msf);
1569                 }
1570                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1571                                                    toc->ent[i].addr.msf.second,
1572                                                    toc->ent[i].addr.msf.frame);
1573         }
1574
1575         /* Read the multisession information. */
1576         if (toc->hdr.first_track != CDROM_LEADOUT) {
1577                 /* Read the multisession information. */
1578                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1579                                            sizeof(ms_tmp), sense);
1580                 if (stat)
1581                         return stat;
1582
1583                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1584         } else {
1585                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1586                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1587         }
1588
1589         if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1590                 /* Re-read multisession information using MSF format */
1591                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1592                                            sizeof(ms_tmp), sense);
1593                 if (stat)
1594                         return stat;
1595
1596                 msf_from_bcd (&ms_tmp.ent.addr.msf);
1597                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1598                                                    ms_tmp.ent.addr.msf.second,
1599                                                    ms_tmp.ent.addr.msf.frame);
1600         }
1601
1602         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1603
1604         /* Now try to get the total cdrom capacity. */
1605         stat = cdrom_get_last_written(cdi, &last_written);
1606         if (!stat && (last_written > toc->capacity)) {
1607                 toc->capacity = last_written;
1608                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
1609                 drive->probed_capacity = toc->capacity * sectors_per_frame;
1610         }
1611
1612         /* Remember that we've read this stuff. */
1613         info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
1614
1615         return 0;
1616 }
1617
1618 int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
1619 {
1620         struct cdrom_info *info = drive->driver_data;
1621         struct cdrom_device_info *cdi = &info->devinfo;
1622         struct packet_command cgc;
1623         int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
1624
1625         if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
1626                 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
1627
1628         init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
1629         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
1630                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
1631                 if (!stat)
1632                         break;
1633         } while (--attempts);
1634         return stat;
1635 }
1636
1637 void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
1638 {
1639         struct cdrom_info *cd = drive->driver_data;
1640         u16 curspeed, maxspeed;
1641
1642         curspeed = *(u16 *)&buf[8 + 14];
1643         maxspeed = *(u16 *)&buf[8 +  8];
1644
1645         if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
1646                 curspeed = le16_to_cpu(curspeed);
1647                 maxspeed = le16_to_cpu(maxspeed);
1648         } else {
1649                 curspeed = be16_to_cpu(curspeed);
1650                 maxspeed = be16_to_cpu(maxspeed);
1651         }
1652
1653         cd->current_speed = (curspeed + (176/2)) / 176;
1654         cd->max_speed = (maxspeed + (176/2)) / 176;
1655 }
1656
1657 #define IDE_CD_CAPABILITIES \
1658         (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
1659          CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
1660          CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
1661          CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
1662          CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
1663
1664 static struct cdrom_device_ops ide_cdrom_dops = {
1665         .open                   = ide_cdrom_open_real,
1666         .release                = ide_cdrom_release_real,
1667         .drive_status           = ide_cdrom_drive_status,
1668         .media_changed          = ide_cdrom_check_media_change_real,
1669         .tray_move              = ide_cdrom_tray_move,
1670         .lock_door              = ide_cdrom_lock_door,
1671         .select_speed           = ide_cdrom_select_speed,
1672         .get_last_session       = ide_cdrom_get_last_session,
1673         .get_mcn                = ide_cdrom_get_mcn,
1674         .reset                  = ide_cdrom_reset,
1675         .audio_ioctl            = ide_cdrom_audio_ioctl,
1676         .capability             = IDE_CD_CAPABILITIES,
1677         .generic_packet         = ide_cdrom_packet,
1678 };
1679
1680 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
1681 {
1682         struct cdrom_info *info = drive->driver_data;
1683         struct cdrom_device_info *devinfo = &info->devinfo;
1684
1685         devinfo->ops = &ide_cdrom_dops;
1686         devinfo->speed = info->current_speed;
1687         devinfo->capacity = nslots;
1688         devinfo->handle = drive;
1689         strcpy(devinfo->name, drive->name);
1690
1691         if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
1692                 devinfo->mask |= CDC_SELECT_SPEED;
1693
1694         devinfo->disk = info->disk;
1695         return register_cdrom(devinfo);
1696 }
1697
1698 static
1699 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
1700 {
1701         struct cdrom_info *cd = drive->driver_data;
1702         struct cdrom_device_info *cdi = &cd->devinfo;
1703         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
1704         mechtype_t mechtype;
1705         int nslots = 1;
1706
1707         cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
1708                      CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
1709                      CDC_MO_DRIVE | CDC_RAM);
1710
1711         if (drive->media == ide_optical) {
1712                 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1713                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
1714                 return nslots;
1715         }
1716
1717         if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
1718                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
1719                 cdi->mask &= ~CDC_PLAY_AUDIO;
1720                 return nslots;
1721         }
1722
1723         /*
1724          * we have to cheat a little here. the packet will eventually
1725          * be queued with ide_cdrom_packet(), which extracts the
1726          * drive from cdi->handle. Since this device hasn't been
1727          * registered with the Uniform layer yet, it can't do this.
1728          * Same goes for cdi->ops.
1729          */
1730         cdi->handle = drive;
1731         cdi->ops = &ide_cdrom_dops;
1732
1733         if (ide_cdrom_get_capabilities(drive, buf))
1734                 return 0;
1735
1736         if ((buf[8 + 6] & 0x01) == 0)
1737                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1738         if (buf[8 + 6] & 0x08)
1739                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
1740         if (buf[8 + 3] & 0x01)
1741                 cdi->mask &= ~CDC_CD_R;
1742         if (buf[8 + 3] & 0x02)
1743                 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
1744         if (buf[8 + 2] & 0x38)
1745                 cdi->mask &= ~CDC_DVD;
1746         if (buf[8 + 3] & 0x20)
1747                 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
1748         if (buf[8 + 3] & 0x10)
1749                 cdi->mask &= ~CDC_DVD_R;
1750         if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
1751                 cdi->mask &= ~CDC_PLAY_AUDIO;
1752
1753         mechtype = buf[8 + 6] >> 5;
1754         if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
1755                 cdi->mask |= CDC_CLOSE_TRAY;
1756
1757         if (cdi->sanyo_slot > 0) {
1758                 cdi->mask &= ~CDC_SELECT_DISC;
1759                 nslots = 3;
1760         } else if (mechtype == mechtype_individual_changer ||
1761                    mechtype == mechtype_cartridge_changer) {
1762                 nslots = cdrom_number_of_slots(cdi);
1763                 if (nslots > 1)
1764                         cdi->mask &= ~CDC_SELECT_DISC;
1765         }
1766
1767         ide_cdrom_update_speed(drive, buf);
1768
1769         printk(KERN_INFO "%s: ATAPI", drive->name);
1770
1771         /* don't print speed if the drive reported 0 */
1772         if (cd->max_speed)
1773                 printk(KERN_CONT " %dX", cd->max_speed);
1774
1775         printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
1776
1777         if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
1778                 printk(KERN_CONT " DVD%s%s",
1779                                  (cdi->mask & CDC_DVD_R) ? "" : "-R",
1780                                  (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
1781
1782         if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
1783                 printk(KERN_CONT " CD%s%s",
1784                                  (cdi->mask & CDC_CD_R) ? "" : "-R",
1785                                  (cdi->mask & CDC_CD_RW) ? "" : "/RW");
1786
1787         if ((cdi->mask & CDC_SELECT_DISC) == 0)
1788                 printk(KERN_CONT " changer w/%d slots", nslots);
1789         else
1790                 printk(KERN_CONT " drive");
1791
1792         printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
1793
1794         return nslots;
1795 }
1796
1797 #ifdef CONFIG_IDE_PROC_FS
1798 static void ide_cdrom_add_settings(ide_drive_t *drive)
1799 {
1800         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
1801 }
1802 #else
1803 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
1804 #endif
1805
1806 /*
1807  * standard prep_rq_fn that builds 10 byte cmds
1808  */
1809 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
1810 {
1811         int hard_sect = queue_hardsect_size(q);
1812         long block = (long)rq->hard_sector / (hard_sect >> 9);
1813         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
1814
1815         memset(rq->cmd, 0, sizeof(rq->cmd));
1816
1817         if (rq_data_dir(rq) == READ)
1818                 rq->cmd[0] = GPCMD_READ_10;
1819         else
1820                 rq->cmd[0] = GPCMD_WRITE_10;
1821
1822         /*
1823          * fill in lba
1824          */
1825         rq->cmd[2] = (block >> 24) & 0xff;
1826         rq->cmd[3] = (block >> 16) & 0xff;
1827         rq->cmd[4] = (block >>  8) & 0xff;
1828         rq->cmd[5] = block & 0xff;
1829
1830         /*
1831          * and transfer length
1832          */
1833         rq->cmd[7] = (blocks >> 8) & 0xff;
1834         rq->cmd[8] = blocks & 0xff;
1835         rq->cmd_len = 10;
1836         return BLKPREP_OK;
1837 }
1838
1839 /*
1840  * Most of the SCSI commands are supported directly by ATAPI devices.
1841  * This transform handles the few exceptions.
1842  */
1843 static int ide_cdrom_prep_pc(struct request *rq)
1844 {
1845         u8 *c = rq->cmd;
1846
1847         /*
1848          * Transform 6-byte read/write commands to the 10-byte version
1849          */
1850         if (c[0] == READ_6 || c[0] == WRITE_6) {
1851                 c[8] = c[4];
1852                 c[5] = c[3];
1853                 c[4] = c[2];
1854                 c[3] = c[1] & 0x1f;
1855                 c[2] = 0;
1856                 c[1] &= 0xe0;
1857                 c[0] += (READ_10 - READ_6);
1858                 rq->cmd_len = 10;
1859                 return BLKPREP_OK;
1860         }
1861
1862         /*
1863          * it's silly to pretend we understand 6-byte sense commands, just
1864          * reject with ILLEGAL_REQUEST and the caller should take the
1865          * appropriate action
1866          */
1867         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
1868                 rq->errors = ILLEGAL_REQUEST;
1869                 return BLKPREP_KILL;
1870         }
1871
1872         return BLKPREP_OK;
1873 }
1874
1875 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
1876 {
1877         if (blk_fs_request(rq))
1878                 return ide_cdrom_prep_fs(q, rq);
1879         else if (blk_pc_request(rq))
1880                 return ide_cdrom_prep_pc(rq);
1881
1882         return 0;
1883 }
1884
1885 struct cd_list_entry {
1886         const char      *id_model;
1887         const char      *id_firmware;
1888         unsigned int    cd_flags;
1889 };
1890
1891 static const struct cd_list_entry ide_cd_quirks_list[] = {
1892         /* Limit transfer size per interrupt. */
1893         { "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
1894         { "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
1895         /* SCR-3231 doesn't support the SET_CD_SPEED command. */
1896         { "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_CD_FLAG_NO_SPEED_SELECT    },
1897         /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
1898         { "NEC CD-ROM DRIVE:260",    "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
1899                                              IDE_CD_FLAG_PRE_ATAPI12,       },
1900         /* Vertos 300, some versions of this drive like to talk BCD. */
1901         { "V003S0DS",                NULL,   IDE_CD_FLAG_VERTOS_300_SSD,    },
1902         /* Vertos 600 ESD. */
1903         { "V006E0DS",                NULL,   IDE_CD_FLAG_VERTOS_600_ESD,    },
1904         /*
1905          * Sanyo 3 CD changer uses a non-standard command for CD changing
1906          * (by default standard ATAPI support for CD changers is used).
1907          */
1908         { "CD-ROM CDR-C3 G",         NULL,   IDE_CD_FLAG_SANYO_3CD          },
1909         { "CD-ROM CDR-C3G",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
1910         { "CD-ROM CDR_C36",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
1911         /* Stingray 8X CD-ROM. */
1912         { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
1913         /*
1914          * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
1915          * mode sense page capabilities size, but older drives break.
1916          */
1917         { "ATAPI CD ROM DRIVE 50X MAX", NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
1918         { "WPI CDS-32X",                NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
1919         /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
1920         { "",                        "241N", IDE_CD_FLAG_LE_SPEED_FIELDS    },
1921         /*
1922          * Some drives used by Apple don't advertise audio play
1923          * but they do support reading TOC & audio datas.
1924          */
1925         { "MATSHITADVD-ROM SR-8187", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1926         { "MATSHITADVD-ROM SR-8186", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1927         { "MATSHITADVD-ROM SR-8176", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1928         { "MATSHITADVD-ROM SR-8174", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1929         { NULL, NULL, 0 }
1930 };
1931
1932 static unsigned int ide_cd_flags(struct hd_driveid *id)
1933 {
1934         const struct cd_list_entry *cle = ide_cd_quirks_list;
1935
1936         while (cle->id_model) {
1937                 if (strcmp(cle->id_model, id->model) == 0 &&
1938                     (cle->id_firmware == NULL ||
1939                      strstr(id->fw_rev, cle->id_firmware)))
1940                         return cle->cd_flags;
1941                 cle++;
1942         }
1943
1944         return 0;
1945 }
1946
1947 static
1948 int ide_cdrom_setup (ide_drive_t *drive)
1949 {
1950         struct cdrom_info *cd = drive->driver_data;
1951         struct cdrom_device_info *cdi = &cd->devinfo;
1952         struct hd_driveid *id = drive->id;
1953         int nslots;
1954
1955         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
1956         blk_queue_dma_alignment(drive->queue, 31);
1957         drive->queue->unplug_delay = (1 * HZ) / 1000;
1958         if (!drive->queue->unplug_delay)
1959                 drive->queue->unplug_delay = 1;
1960
1961         drive->special.all      = 0;
1962
1963         cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
1964                        ide_cd_flags(id);
1965
1966         if ((id->config & 0x0060) == 0x20)
1967                 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
1968
1969         if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
1970             id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1971                 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
1972                                  IDE_CD_FLAG_TOCADDR_AS_BCD);
1973         else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
1974                  id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1975                 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
1976         else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
1977                 cdi->sanyo_slot = 3;    /* 3 => use CD in slot 0 */
1978
1979         nslots = ide_cdrom_probe_capabilities (drive);
1980
1981         /*
1982          * set correct block size
1983          */
1984         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
1985
1986         if (drive->autotune == IDE_TUNE_DEFAULT ||
1987             drive->autotune == IDE_TUNE_AUTO)
1988                 drive->dsc_overlap = (drive->next != drive);
1989
1990         if (ide_cdrom_register(drive, nslots)) {
1991                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
1992                 cd->devinfo.handle = NULL;
1993                 return 1;
1994         }
1995         ide_cdrom_add_settings(drive);
1996         return 0;
1997 }
1998
1999 #ifdef CONFIG_IDE_PROC_FS
2000 static
2001 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2002 {
2003         unsigned long capacity, sectors_per_frame;
2004
2005         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2006                 return 0;
2007
2008         return capacity * sectors_per_frame;
2009 }
2010 #endif
2011
2012 static void ide_cd_remove(ide_drive_t *drive)
2013 {
2014         struct cdrom_info *info = drive->driver_data;
2015
2016         ide_proc_unregister_driver(drive, info->driver);
2017
2018         del_gendisk(info->disk);
2019
2020         ide_cd_put(info);
2021 }
2022
2023 static void ide_cd_release(struct kref *kref)
2024 {
2025         struct cdrom_info *info = to_ide_cd(kref);
2026         struct cdrom_device_info *devinfo = &info->devinfo;
2027         ide_drive_t *drive = info->drive;
2028         struct gendisk *g = info->disk;
2029
2030         kfree(info->buffer);
2031         kfree(info->toc);
2032         if (devinfo->handle == drive && unregister_cdrom(devinfo))
2033                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2034                                 "driver.\n", __FUNCTION__, drive->name);
2035         drive->dsc_overlap = 0;
2036         drive->driver_data = NULL;
2037         blk_queue_prep_rq(drive->queue, NULL);
2038         g->private_data = NULL;
2039         put_disk(g);
2040         kfree(info);
2041 }
2042
2043 static int ide_cd_probe(ide_drive_t *);
2044
2045 #ifdef CONFIG_IDE_PROC_FS
2046 static int proc_idecd_read_capacity
2047         (char *page, char **start, off_t off, int count, int *eof, void *data)
2048 {
2049         ide_drive_t *drive = data;
2050         int len;
2051
2052         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2053         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2054 }
2055
2056 static ide_proc_entry_t idecd_proc[] = {
2057         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2058         { NULL, 0, NULL, NULL }
2059 };
2060 #endif
2061
2062 static ide_driver_t ide_cdrom_driver = {
2063         .gen_driver = {
2064                 .owner          = THIS_MODULE,
2065                 .name           = "ide-cdrom",
2066                 .bus            = &ide_bus_type,
2067         },
2068         .probe                  = ide_cd_probe,
2069         .remove                 = ide_cd_remove,
2070         .version                = IDECD_VERSION,
2071         .media                  = ide_cdrom,
2072         .supports_dsc_overlap   = 1,
2073         .do_request             = ide_do_rw_cdrom,
2074         .end_request            = ide_end_request,
2075         .error                  = __ide_error,
2076         .abort                  = __ide_abort,
2077 #ifdef CONFIG_IDE_PROC_FS
2078         .proc                   = idecd_proc,
2079 #endif
2080 };
2081
2082 static int idecd_open(struct inode * inode, struct file * file)
2083 {
2084         struct gendisk *disk = inode->i_bdev->bd_disk;
2085         struct cdrom_info *info;
2086         int rc = -ENOMEM;
2087
2088         if (!(info = ide_cd_get(disk)))
2089                 return -ENXIO;
2090
2091         if (!info->buffer)
2092                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2093
2094         if (info->buffer)
2095                 rc = cdrom_open(&info->devinfo, inode, file);
2096
2097         if (rc < 0)
2098                 ide_cd_put(info);
2099
2100         return rc;
2101 }
2102
2103 static int idecd_release(struct inode * inode, struct file * file)
2104 {
2105         struct gendisk *disk = inode->i_bdev->bd_disk;
2106         struct cdrom_info *info = ide_cd_g(disk);
2107
2108         cdrom_release (&info->devinfo, file);
2109
2110         ide_cd_put(info);
2111
2112         return 0;
2113 }
2114
2115 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2116 {
2117         struct packet_command cgc;
2118         char buffer[16];
2119         int stat;
2120         char spindown;
2121
2122         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2123                 return -EFAULT;
2124
2125         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2126
2127         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2128         if (stat)
2129                 return stat;
2130
2131         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2132         return cdrom_mode_select(cdi, &cgc);
2133 }
2134
2135 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2136 {
2137         struct packet_command cgc;
2138         char buffer[16];
2139         int stat;
2140         char spindown;
2141
2142         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2143
2144         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2145         if (stat)
2146                 return stat;
2147
2148         spindown = buffer[11] & 0x0f;
2149         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2150                 return -EFAULT;
2151         return 0;
2152 }
2153
2154 static int idecd_ioctl (struct inode *inode, struct file *file,
2155                         unsigned int cmd, unsigned long arg)
2156 {
2157         struct block_device *bdev = inode->i_bdev;
2158         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2159         int err;
2160
2161         switch (cmd) {
2162         case CDROMSETSPINDOWN:
2163                 return idecd_set_spindown(&info->devinfo, arg);
2164         case CDROMGETSPINDOWN:
2165                 return idecd_get_spindown(&info->devinfo, arg);
2166         default:
2167                 break;
2168         }
2169
2170         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
2171         if (err == -EINVAL)
2172                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2173
2174         return err;
2175 }
2176
2177 static int idecd_media_changed(struct gendisk *disk)
2178 {
2179         struct cdrom_info *info = ide_cd_g(disk);
2180         return cdrom_media_changed(&info->devinfo);
2181 }
2182
2183 static int idecd_revalidate_disk(struct gendisk *disk)
2184 {
2185         struct cdrom_info *info = ide_cd_g(disk);
2186         struct request_sense sense;
2187
2188         ide_cd_read_toc(info->drive, &sense);
2189
2190         return  0;
2191 }
2192
2193 static struct block_device_operations idecd_ops = {
2194         .owner          = THIS_MODULE,
2195         .open           = idecd_open,
2196         .release        = idecd_release,
2197         .ioctl          = idecd_ioctl,
2198         .media_changed  = idecd_media_changed,
2199         .revalidate_disk= idecd_revalidate_disk
2200 };
2201
2202 /* options */
2203 static char *ignore = NULL;
2204
2205 module_param(ignore, charp, 0400);
2206 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2207
2208 static int ide_cd_probe(ide_drive_t *drive)
2209 {
2210         struct cdrom_info *info;
2211         struct gendisk *g;
2212         struct request_sense sense;
2213
2214         if (!strstr("ide-cdrom", drive->driver_req))
2215                 goto failed;
2216         if (!drive->present)
2217                 goto failed;
2218         if (drive->media != ide_cdrom && drive->media != ide_optical)
2219                 goto failed;
2220         /* skip drives that we were told to ignore */
2221         if (ignore != NULL) {
2222                 if (strstr(ignore, drive->name)) {
2223                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2224                         goto failed;
2225                 }
2226         }
2227         if (drive->scsi) {
2228                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2229                 goto failed;
2230         }
2231         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
2232         if (info == NULL) {
2233                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
2234                 goto failed;
2235         }
2236
2237         g = alloc_disk(1 << PARTN_BITS);
2238         if (!g)
2239                 goto out_free_cd;
2240
2241         ide_init_disk(g, drive);
2242
2243         ide_proc_register_driver(drive, &ide_cdrom_driver);
2244
2245         kref_init(&info->kref);
2246
2247         info->drive = drive;
2248         info->driver = &ide_cdrom_driver;
2249         info->disk = g;
2250
2251         g->private_data = &info->driver;
2252
2253         drive->driver_data = info;
2254
2255         g->minors = 1;
2256         g->driverfs_dev = &drive->gendev;
2257         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
2258         if (ide_cdrom_setup(drive)) {
2259                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
2260                 ide_cd_release(&info->kref);
2261                 goto failed;
2262         }
2263
2264         ide_cd_read_toc(drive, &sense);
2265         g->fops = &idecd_ops;
2266         g->flags |= GENHD_FL_REMOVABLE;
2267         add_disk(g);
2268         return 0;
2269
2270 out_free_cd:
2271         kfree(info);
2272 failed:
2273         return -ENODEV;
2274 }
2275
2276 static void __exit ide_cdrom_exit(void)
2277 {
2278         driver_unregister(&ide_cdrom_driver.gen_driver);
2279 }
2280
2281 static int __init ide_cdrom_init(void)
2282 {
2283         return driver_register(&ide_cdrom_driver.gen_driver);
2284 }
2285
2286 MODULE_ALIAS("ide:*m-cdrom*");
2287 MODULE_ALIAS("ide-cd");
2288 module_init(ide_cdrom_init);
2289 module_exit(ide_cdrom_exit);
2290 MODULE_LICENSE("GPL");