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