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

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