drivers/block/ide-cd.c

/* */
This source file includes following definitions.
cdrom_in_bytes
cdrom_out_bytes
cdrom_analyze_sense_data
restore_request
cdrom_queue_request_sense
cdrom_end_request
cdrom_saw_media_change
cdrom_decode_status
cdrom_start_packet_command
cdrom_transfer_packet_command
cdrom_buffer_sectors
cdrom_read_check_ireason
cdrom_read_intr
cdrom_read_from_buffer
cdrom_start_read_continuation
cdrom_start_read
cdrom_pc_intr
cdrom_do_pc_continuation
cdrom_do_packet_command
cdrom_sleep
cdrom_queue_packet_command
cdrom_do_drive_cmd
ide_do_rw_cdrom
bin2bcd
bcd2bin
lba_to_msf
msf_to_lba
cdrom_check_status
cdrom_lockdoor
cdrom_eject
cdrom_pause
cdrom_startstop
cdrom_read_capacity
cdrom_read_tocentry
cdrom_read_toc
cdrom_read_subchannel
cdrom_mode_sense
cdrom_mode_select
cdrom_play_lba_range_play12
cdrom_play_lba_range_msf
cdrom_play_lba_range_1
cdrom_play_lba_range
cdrom_get_toc_entry
cdrom_read_block
ide_cdrom_ioctl
ide_cdrom_check_media_change
ide_cdrom_open
ide_cdrom_release
ide_cdrom_setup
   1 /*
   2  * linux/drivers/block/ide-cd.c
   3  *
   4  * 1.00  Oct 31, 1994 -- Initial version.
   5  * 1.01  Nov  2, 1994 -- Fixed problem with starting request in
   6  *                       cdrom_check_status.
   7  * 1.03  Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
   8  * (from mlord)       -- minor changes to cdrom_setup()
   9  *                    -- renamed ide_dev_s to ide_drive_t, enable irq on command
  10  * 2.00  Nov 27, 1994 -- Generalize packet command interface;
  11  *                       add audio ioctls.
  12  * 2.01  Dec  3, 1994 -- Rework packet command interface to handle devices
  13  *                       which send an interrupt when ready for a command.
  14  * 2.02  Dec 11, 1994 -- Cache the TOC in the driver.
  15  *                       Don't use SCMD_PLAYAUDIO_TI; it's not included
  16  *                       in the current version of ATAPI.
  17  *                       Try to use LBA instead of track or MSF addressing
  18  *                       when possible.
  19  *                       Don't wait for READY_STAT.
  20  * 2.03  Jan 10, 1995 -- Rewrite block read routines to handle block sizes
  21  *                       other than 2k and to move multiple sectors in a
  22  *                       single transaction.
  23  * 2.04  Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
  24  *                       Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
  25  *                       help in figuring this out.  Ditto for Acer and
  26  *                       Aztech drives, which seem to have the same problem.
  27  * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
  28  * 2.05  Jun  8, 1995 -- Don't attempt to retry after an illegal request
  29  *                        or data protect error.
  30  *                       Use HWIF and DEV_HWIF macros as in ide.c.
  31  *                       Always try to do a request_sense after
  32  *                        a failed command.
  33  *                       Include an option to give textual descriptions
  34  *                        of ATAPI errors.
  35  *                       Fix a bug in handling the sector cache which
  36  *                        showed up if the drive returned data in 512 byte
  37  *                        blocks (like Pioneer drives).  Thanks to
  38  *                        Richard Hirst <srh@gpt.co.uk> for diagnosing this.
  39  *                       Properly supply the page number field in the
  40  *                        MODE_SELECT command.
  41  *                       PLAYAUDIO12 is broken on the Aztech; work around it.
  42  * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
  43  *                       (my apologies to Scott, but now ide-cd.c is independent)
  44  * 3.00  Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
  45  *                       Implement CDROMREADAUDIO ioctl (UNTESTED).
  46  *                       Use input_ide_data() and output_ide_data().
  47  *                       Add door locking.
  48  *                       Fix usage count leak in cdrom_open, which happened
  49  *                        when a read-write mount was attempted.
  50  *                       Try to load the disk on open.
  51  *                       Implement CDROMEJECT_SW ioctl (off by default).
  52  *                       Read total cdrom capacity during open.
  53  *                       Rearrange logic in cdrom_decode_status.  Issue
  54  *                        request sense commands for failed packet commands
  55  *                        from here instead of from cdrom_queue_packet_command.
  56  *                        Fix a race condition in retrieving error information.
  57  *                       Suppress printing normal unit attention errors and
  58  *                        some drive not ready errors.
  59  *                       Implement CDROMVOLREAD ioctl.
  60  *                       Implement CDROMREADMODE1/2 ioctls.
  61  *                       Fix race condition in setting up interrupt handlers
  62  *                        when the `serialize' option is used.
  63  * 3.01  Sep  2, 1995 -- Fix ordering of reenabling interrupts in
  64  *                        cdrom_queue_request.
  65  *                       Another try at using ide_[input,output]_data.
  66  * 3.02  Sep 16, 1995 -- Stick total disk capacity in partition table as well.
  67  *                       Make VERBOSE_IDE_CD_ERRORS dump failed command again.
  68  *                       Dump out more information for ILLEGAL REQUEST errs.
  69  *                       Fix handling of errors occuring before the
  70  *                        packet command is transferred.
  71  *                       Fix transfers with odd bytelengths.
  72  * 3.03  Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
  73  *                       `DCI-2S10' drives are broken too.
  74  * 3.04  Nov 20, 1995 -- So are Vertos drives.
  75  * 3.05  Dec  1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
  76  * 3.06  Dec 16, 1995 -- Add support needed for partitions.
  77  *                       More workarounds for Vertos bugs (based on patches
  78  *                        from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
  79  *                       Try to eliminate byteorder assumptions.
  80  *                       Use atapi_cdrom_subchnl struct definition.
  81  *                       Add STANDARD_ATAPI compilation option.
  82  * 3.07  Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
  83  *                        Vertos 300.
  84  *                       Add NO_DOOR_LOCKING configuration option.
  85  *                       Handle drive_cmd requests w/NULL args (for hdparm -t).
  86  *                       Work around sporadic Sony55e audio play problem.
  87  * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
  88  *                        problem with "hde=cdrom" with no drive present.  -ml
  89  * 3.08  Mar  6, 1996 -- More Vertos workarounds.
  90  *
  91  * NOTE: Direct audio reads will only work on some types of drive.
  92  * So far, i've received reports of success for Sony and Toshiba drives.
  93  *
  94  * ATAPI cd-rom driver.  To be used with ide.c.
  95  *
  96  * Copyright (C) 1994, 1995, 1996  scott snyder  <snyder@fnald0.fnal.gov>
  97  * May be copied or modified under the terms of the GNU General Public License
  98  * (../../COPYING).
  99  */
 100 
 101 
 102 /***************************************************************************/
 103 
 104 #include <linux/types.h>
 105 #include <linux/kernel.h>
 106 #include <linux/delay.h>
 107 #include <linux/timer.h>
 108 #include <linux/malloc.h>
 109 #include <linux/ioport.h>
 110 #include <linux/interrupt.h>
 111 #include <linux/blkdev.h>
 112 #include <linux/errno.h>
 113 #include <linux/hdreg.h>
 114 #include <linux/cdrom.h>
 115 #include <asm/irq.h>
 116 #include <asm/io.h>
 117 #include <asm/byteorder.h>
 118 #include <asm/segment.h>
 119 #ifdef __alpha__
 120 # include <asm/unaligned.h>
 121 #endif
 122 
 123 #include "ide.h"
 124 
 125 
 126 
 127 /* Turn this on to have the driver print out the meanings of the
 128    ATAPI error codes.  This will use up additional kernel-space
 129    memory, though. */
 130 
 131 #ifndef VERBOSE_IDE_CD_ERRORS
 132 #define VERBOSE_IDE_CD_ERRORS 0
 133 #endif
 134 
 135 
 136 /* Turning this on will remove code to work around various nonstandard
 137    ATAPI implementations.  If you know your drive follows the standard,
 138    this will give you a slightly smaller kernel. */
 139 
 140 #ifndef STANDARD_ATAPI
 141 #define STANDARD_ATAPI 0
 142 #endif
 143 
 144 
 145 /* Turning this on will disable the door-locking functionality.
 146    This is apparently needed for supermount. */
 147 
 148 #ifndef NO_DOOR_LOCKING
 149 #define NO_DOOR_LOCKING 0
 150 #endif
 151 
 152 
 153 /************************************************************************/
 154 
 155 #define SECTOR_SIZE 512
 156 #define SECTOR_BITS 9
 157 #define SECTORS_PER_FRAME (CD_FRAMESIZE / SECTOR_SIZE)
 158 
 159 #define MIN(a,b) ((a) < (b) ? (a) : (b))
 160 
 161 /* special command codes for strategy routine. */
 162 #define PACKET_COMMAND        4315
 163 #define REQUEST_SENSE_COMMAND 4316
 164 #define RESET_DRIVE_COMMAND   4317
 165 
 166 /* Some ATAPI command opcodes (just like SCSI).
 167    (Some other cdrom-specific codes are in cdrom.h.) */
 168 #define TEST_UNIT_READY         0x00
 169 #define REQUEST_SENSE           0x03
 170 #define START_STOP              0x1b
 171 #define ALLOW_MEDIUM_REMOVAL    0x1e
 172 #define READ_CAPACITY           0x25
 173 #define READ_10                 0x28
 174 #define MODE_SENSE_10           0x5a
 175 #define MODE_SELECT_10          0x55
 176 #define READ_CD                 0xbe
 177 
 178 
 179 /* ATAPI sense keys (mostly copied from scsi.h). */
 180 
 181 #define NO_SENSE                0x00
 182 #define RECOVERED_ERROR         0x01
 183 #define NOT_READY               0x02
 184 #define MEDIUM_ERROR            0x03
 185 #define HARDWARE_ERROR          0x04
 186 #define ILLEGAL_REQUEST         0x05
 187 #define UNIT_ATTENTION          0x06
 188 #define DATA_PROTECT            0x07
 189 #define ABORTED_COMMAND         0x0b
 190 #define MISCOMPARE              0x0e
 191 
 192 /* We want some additional flags for cd-rom drives.
 193    To save space in the ide_drive_t struct, use some fields which
 194    doesn't make sense for cd-roms -- `bios_sect' and `bios_head'. */
 195 
 196 /* Configuration flags.  These describe the capabilities of the drive.
 197    They generally do not change after initialization, unless we learn
 198    more about the drive from stuff failing. */
 199 struct ide_cd_config_flags {
 200   __u8 drq_interrupt : 1; /* Device sends an interrupt when ready
 201                                  for a packet command. */
 202   __u8 no_doorlock   : 1; /* Drive cannot lock the door. */
 203 #if ! STANDARD_ATAPI
 204   __u8 no_playaudio12: 1; /* The PLAYAUDIO12 command is not supported. */
 205  
 206   __u8 no_lba_toc    : 1; /* Drive cannot return TOC info in LBA format. */
 207   __u8 playmsf_uses_bcd : 1; /* Drive uses BCD in PLAYAUDIO_MSF. */
 208   __u8 old_readcd    : 1; /* Drive uses old READ CD opcode. */
 209   __u8 vertos_lossage: 1; /* Drive is a Vertos 300,
 210                                  and likes to speak BCD. */
 211 #endif  /* not STANDARD_ATAPI */
 212   __u8 reserved : 1;
 213 };
 214 #define CDROM_CONFIG_FLAGS(drive) ((struct ide_cd_config_flags *)&((drive)->bios_sect))
 215 
 216  
 217 /* State flags.  These give information about the current state of the
 218    drive, and will change during normal operation. */
 219 struct ide_cd_state_flags {
 220   __u8 media_changed : 1; /* Driver has noticed a media change. */
 221   __u8 toc_valid     : 1; /* Saved TOC information is current. */
 222   __u8 door_locked   : 1; /* We think that the drive door is locked. */
 223   __u8 eject_on_close: 1; /* Drive should eject when device is closed. */
 224   __u8 reserved : 4;
 225 };
 226 #define CDROM_STATE_FLAGS(drive)  ((struct ide_cd_state_flags *)&((drive)->bios_head))
 227 
 228 
 229 #define SECTOR_BUFFER_SIZE CD_FRAMESIZE
 230 
 231 
 232 
 233 /****************************************************************************
 234  * Routines to read and write data from/to the drive, using
 235  * the routines input_ide_data() and output_ide_data() from ide.c.
 236  *
 237  * These routines will round up any request for an odd number of bytes,
 238  * so if an odd bytecount is specified, be sure that there's at least one
 239  * extra byte allocated for the buffer.
 240  */
 241 
 242 
 243 static inline
 244 void cdrom_in_bytes (ide_drive_t *drive, void *buffer, uint bytecount)
     /*  */
 245 {
 246   ++bytecount;
 247   ide_input_data (drive, buffer, bytecount / 4);
 248   if ((bytecount & 0x03) >= 2)
 249     {
 250       insw (IDE_DATA_REG, ((byte *)buffer) + (bytecount & ~0x03), 1);
 251     }
 252 }
 253 
 254 
 255 static inline
 256 void cdrom_out_bytes (ide_drive_t *drive, void *buffer, uint bytecount)
     /*  */
 257 {
 258   ++bytecount;
 259   ide_output_data (drive, buffer, bytecount / 4);
 260   if ((bytecount & 0x03) >= 2)
 261     {
 262       outsw (IDE_DATA_REG, ((byte *)buffer) + (bytecount & ~0x03), 1);
 263     }
 264 }
 265 
 266 
 267 
 268 /****************************************************************************
 269  * Descriptions of ATAPI error codes.
 270  */
 271 
 272 #define ARY_LEN(a) ((sizeof(a) / sizeof(a[0])))
 273 
 274 #if VERBOSE_IDE_CD_ERRORS
 275 
 276 /* From Table 124 of the ATAPI 1.2 spec. */
 277 
 278 char *sense_key_texts[16] = {
 279   "No sense data",
 280   "Recovered error",
 281   "Not ready",
 282   "Medium error",
 283   "Hardware error",
 284   "Illegal request",
 285   "Unit attention",
 286   "Data protect",
 287   "(reserved)",
 288   "(reserved)",
 289   "(reserved)",
 290   "Aborted command",
 291   "(reserved)",
 292   "(reserved)",
 293   "Miscompare",
 294   "(reserved)",
 295 };
 296 
 297 
 298 /* From Table 125 of the ATAPI 1.2 spec. */
 299 
 300 struct {
 301   short asc_ascq;
 302   char *text;
 303 } sense_data_texts[] = {
 304   { 0x0000, "No additional sense information" },
 305   { 0x0011, "Audio play operation in progress" },
 306   { 0x0012, "Audio play operation paused" },
 307   { 0x0013, "Audio play operation successfully completed" },
 308   { 0x0014, "Audio play operation stopped due to error" },
 309   { 0x0015, "No current audio status to return" },
 310 
 311   { 0x0200, "No seek complete" },
 312 
 313   { 0x0400, "Logical unit not ready - cause not reportable" },
 314   { 0x0401, "Logical unit not ready - in progress (sic) of becoming ready" },
 315   { 0x0402, "Logical unit not ready - initializing command required" },
 316   { 0x0403, "Logical unit not ready - manual intervention required" },
 317 
 318   { 0x0600, "No reference position found" },
 319 
 320   { 0x0900, "Track following error" },
 321   { 0x0901, "Tracking servo failure" },
 322   { 0x0902, "Focus servo failure" },
 323   { 0x0903, "Spindle servo failure" },
 324 
 325   { 0x1100, "Unrecovered read error" },
 326   { 0x1106, "CIRC unrecovered error" },
 327 
 328   { 0x1500, "Random positioning error" },
 329   { 0x1501, "Mechanical positioning error" },
 330   { 0x1502, "Positioning error detected by read of medium" },
 331 
 332   { 0x1700, "Recovered data with no error correction applied" },
 333   { 0x1701, "Recovered data with retries" },
 334   { 0x1702, "Recovered data with positive head offset" },
 335   { 0x1703, "Recovered data with negative head offset" },
 336   { 0x1704, "Recovered data with retries and/or CIRC applied" },
 337   { 0x1705, "Recovered data using previous sector ID" },
 338 
 339   { 0x1800, "Recovered data with error correction applied" },
 340   { 0x1801, "Recovered data with error correction and retries applied" },
 341   { 0x1802, "Recovered data - the data was auto-reallocated" },
 342   { 0x1803, "Recovered data with CIRC" },
 343   { 0x1804, "Recovered data with L-EC" },
 344   { 0x1805, "Recovered data - recommend reassignment" },
 345   { 0x1806, "Recovered data - recommend rewrite" },
 346 
 347   { 0x1a00, "Parameter list length error" },
 348 
 349   { 0x2000, "Invalid command operation code" },
 350 
 351   { 0x2100, "Logical block address out of range" },
 352 
 353   { 0x2400, "Invalid field in command packet" },
 354 
 355   { 0x2600, "Invalid field in parameter list" },
 356   { 0x2601, "Parameter not supported" },
 357   { 0x2602, "Parameter value invalid" },
 358   { 0x2603, "Threshold parameters not supported" },
 359 
 360   { 0x2800, "Not ready to ready transition, medium may have changed" },
 361 
 362   { 0x2900, "Power on, reset or bus device reset occurred" },
 363 
 364   { 0x2a00, "Parameters changed" },
 365   { 0x2a01, "Mode parameters changed" },
 366 
 367   { 0x3000, "Incompatible medium installed" },
 368   { 0x3001, "Cannot read medium - unknown format" },
 369   { 0x3002, "Cannot read medium - incompatible format" },
 370 
 371   { 0x3700, "Rounded parameter" },
 372 
 373   { 0x3900, "Saving parameters not supported" },
 374 
 375   { 0x3a00, "Medium not present" },
 376 
 377   { 0x3f00, "ATAPI CD-ROM drive operating conditions have changed" },
 378   { 0x3f01, "Microcode has been changed" },
 379   { 0x3f02, "Changed operating definition" },
 380   { 0x3f03, "Inquiry data has changed" },
 381 
 382   { 0x4000, "Diagnostic failure on component (ASCQ)" },
 383 
 384   { 0x4400, "Internal ATAPI CD-ROM drive failure" },
 385 
 386   { 0x4e00, "Overlapped commands attempted" },
 387 
 388   { 0x5300, "Media load or eject failed" },
 389   { 0x5302, "Medium removal prevented" },
 390 
 391   { 0x5700, "Unable to recover table of contents" },
 392 
 393   { 0x5a00, "Operator request or state change input (unspecified)" },
 394   { 0x5a01, "Operator medium removal request" },
 395 
 396   { 0x5b00, "Threshold condition met" },
 397 
 398   { 0x5c00, "Status change" },
 399 
 400   { 0x6300, "End of user area encountered on this track" },
 401 
 402   { 0x6400, "Illegal mode for this track" },
 403 
 404   { 0xbf00, "Loss of streaming" },
 405 };
 406 #endif
 407 
 408 
 409 
 410 /****************************************************************************
 411  * Generic packet command support and error handling routines.
 412  */
 413 
 414 
 415 static
 416 void cdrom_analyze_sense_data (ide_drive_t *drive, 
     /*  */
 417                                struct atapi_request_sense *reqbuf,
 418                                struct packet_command *failed_command)
 419 {
 420   /* Don't print not ready or unit attention errors for READ_SUBCHANNEL.
 421      Workman (and probably other programs) uses this command to poll
 422      the drive, and we don't want to fill the syslog with useless errors. */
 423   if (failed_command &&
 424       failed_command->c[0] == SCMD_READ_SUBCHANNEL &&
 425       (reqbuf->sense_key == NOT_READY || reqbuf->sense_key == UNIT_ATTENTION))
 426     return;
 427 
 428 #if VERBOSE_IDE_CD_ERRORS
 429   {
 430     int i;
 431     char *s;
 432     char buf[80];
 433 
 434     printk ("ATAPI device %s:\n", drive->name);
 435 
 436     printk ("  Error code: 0x%02x\n", reqbuf->error_code);
 437 
 438     if (reqbuf->sense_key >= 0 &&
 439         reqbuf->sense_key < ARY_LEN (sense_key_texts))
 440       s = sense_key_texts[reqbuf->sense_key];
 441     else
 442       s = "(bad sense key)";
 443 
 444     printk ("  Sense key: 0x%02x - %s\n", reqbuf->sense_key, s);
 445 
 446     if (reqbuf->asc == 0x40) {
 447       sprintf (buf, "Diagnostic failure on component 0x%02x", reqbuf->ascq);
 448       s = buf;
 449     }
 450 
 451     else {
 452       int lo, hi;
 453       int key = (reqbuf->asc << 8);
 454       if ( ! (reqbuf->ascq >= 0x80 && reqbuf->ascq <= 0xdd) )
 455         key |= reqbuf->ascq;
 456 
 457       lo = 0;
 458       hi = ARY_LEN (sense_data_texts);
 459       s = NULL;
 460 
 461       while (hi > lo) {
 462         int mid = (lo + hi) / 2;
 463         if (sense_data_texts[mid].asc_ascq == key) {
 464           s = sense_data_texts[mid].text;
 465           break;
 466         }
 467         else if (sense_data_texts[mid].asc_ascq > key)
 468           hi = mid;
 469         else
 470           lo = mid+1;
 471       }
 472     }
 473 
 474     if (s == NULL) {
 475       if (reqbuf->asc > 0x80)
 476         s = "(vendor-specific error)";
 477       else
 478         s = "(reserved error code)";
 479     }
 480 
 481     printk ("  Additional sense data: 0x%02x, 0x%02x  - %s\n",
 482             reqbuf->asc, reqbuf->ascq, s);
 483 
 484     if (failed_command != NULL) {
 485       printk ("  Failed packet command: ");
 486       for (i=0; i<sizeof (failed_command->c); i++)
 487         printk ("%02x ", failed_command->c[i]);
 488       printk ("\n");
 489     }
 490 
 491     if (reqbuf->sense_key == ILLEGAL_REQUEST &&
 492         (reqbuf->sense_key_specific[0] & 0x80) != 0)
 493       {
 494         printk ("  Error in %s byte %d",
 495                 (reqbuf->sense_key_specific[0] & 0x40) != 0
 496                   ? "command packet"
 497                   : "command data",
 498                 (reqbuf->sense_key_specific[1] << 8) +
 499                 reqbuf->sense_key_specific[2]);
 500 
 501         if ((reqbuf->sense_key_specific[0] & 0x40) != 0)
 502           {
 503             printk (" bit %d", reqbuf->sense_key_specific[0] & 0x07);
 504           }
 505 
 506         printk ("\n");
 507       }
 508   }
 509 
 510 #else
 511 
 512   /* Suppress printing unit attention and `in progress of becoming ready'
 513      errors when we're not being verbose. */
 514 
 515   if (reqbuf->sense_key == UNIT_ATTENTION ||
 516       (reqbuf->sense_key == NOT_READY && (reqbuf->asc == 4 ||
 517                                           reqbuf->asc == 0x3a)))
 518     return;
 519 
 520   printk ("%s: code: 0x%02x  key: 0x%02x  asc: 0x%02x  ascq: 0x%02x\n",
 521           drive->name,
 522           reqbuf->error_code, reqbuf->sense_key, reqbuf->asc, reqbuf->ascq);
 523 #endif
 524 }
 525 
 526 
 527 /* Fix up a possibly partially-processed request so that we can
 528    start it over entirely, or even put it back on the request queue. */
 529 static void restore_request (struct request *rq)
     /*  */
 530 {
 531   if (rq->buffer != rq->bh->b_data)
 532     {
 533       int n = (rq->buffer - rq->bh->b_data) / SECTOR_SIZE;
 534       rq->buffer = rq->bh->b_data;
 535       rq->nr_sectors += n;
 536       rq->sector -= n;
 537     }
 538   rq->current_nr_sectors = rq->bh->b_size >> SECTOR_BITS;
 539 }
 540 
 541 
 542 static void cdrom_queue_request_sense (ide_drive_t *drive, 
     /*  */
 543                                        struct semaphore *sem,
 544                                        struct atapi_request_sense *reqbuf,
 545                                        struct packet_command *failed_command)
 546 {
 547   struct request *rq;
 548   struct packet_command *pc;
 549   int len;
 550 
 551   /* If the request didn't explicitly specify where to put the sense data,
 552      use the statically allocated structure. */
 553   if (reqbuf == NULL)
 554     reqbuf = &drive->cdrom_info.sense_data;
 555 
 556   /* Make up a new request to retrieve sense information. */
 557 
 558   pc = &HWIF(drive)->request_sense_pc;
 559   memset (pc, 0, sizeof (*pc));
 560 
 561   /* The request_sense structure has an odd number of (16-bit) words,
 562      which won't work well with 32-bit transfers.  However, we don't care
 563      about the last two bytes, so just truncate the structure down
 564      to an even length. */
 565   len = sizeof (*reqbuf) / 4;
 566   len *= 4;
 567 
 568   pc->c[0] = REQUEST_SENSE;
 569   pc->c[4] = len;
 570   pc->buffer = (char *)reqbuf;
 571   pc->buflen = len;
 572   pc->sense_data = (struct atapi_request_sense *)failed_command;
 573 
 574   /* stuff the sense request in front of our current request */
 575 
 576   rq = &HWIF(drive)->request_sense_request;
 577   ide_init_drive_cmd (rq);
 578   rq->cmd = REQUEST_SENSE_COMMAND;
 579   rq->buffer = (char *)pc;
 580   rq->sem = sem;
 581   (void) ide_do_drive_cmd (drive, rq, ide_preempt);
 582 }
 583 
 584 
 585 static void cdrom_end_request (int uptodate, ide_drive_t *drive)
     /*  */
 586 {
 587   struct request *rq = HWGROUP(drive)->rq;
 588 
 589   /* The code in blk.h can screw us up on error recovery if the block
 590      size is larger than 1k.  Fix that up here. */
 591   if (!uptodate && rq->bh != 0)
 592     {
 593       int adj = rq->current_nr_sectors - 1;
 594       rq->current_nr_sectors -= adj;
 595       rq->sector += adj;
 596     }
 597 
 598   if (rq->cmd == REQUEST_SENSE_COMMAND && uptodate)
 599     {
 600       struct packet_command *pc = (struct packet_command *)rq->buffer;
 601       cdrom_analyze_sense_data (drive,
 602                                 (struct atapi_request_sense *)(pc->buffer - pc->c[4]), 
 603                                 (struct packet_command *)pc->sense_data);
 604     }
 605 
 606   ide_end_request (uptodate, HWGROUP(drive));
 607 }
 608 
 609 
 610 /* Mark that we've seen a media change, and invalidate our internal
 611    buffers. */
 612 static void cdrom_saw_media_change (ide_drive_t *drive)
     /*  */
 613 {
 614   CDROM_STATE_FLAGS (drive)->media_changed = 1;
 615   CDROM_STATE_FLAGS (drive)->toc_valid = 0;
 616   drive->cdrom_info.nsectors_buffered = 0;
 617 }
 618 
 619 
 620 /* Returns 0 if the request should be continued.
 621    Returns 1 if the request was ended. */
 622 static int cdrom_decode_status (ide_drive_t *drive, int good_stat, int *stat_ret)
     /*  */
 623 {
 624   struct request *rq = HWGROUP(drive)->rq;
 625   int stat, err, sense_key, cmd;
 626 
 627   /* Check for errors. */
 628   stat = GET_STAT();
 629   *stat_ret = stat;
 630 
 631   if (OK_STAT (stat, good_stat, BAD_R_STAT))
 632     return 0;
 633 
 634   /* Got an error. */
 635   err = IN_BYTE (IDE_ERROR_REG);
 636   sense_key = err >> 4;
 637 
 638   if (rq == NULL)
 639     printk ("%s : missing request in cdrom_decode_status\n", drive->name);
 640   else
 641     {
 642       cmd = rq->cmd;
 643 
 644       if (cmd == REQUEST_SENSE_COMMAND)
 645         {
 646           /* We got an error trying to get sense info from the drive
 647              (probably while trying to recover from a former error).
 648              Just give up. */
 649 
 650           struct packet_command *pc = (struct packet_command *)rq->buffer;
 651           pc->stat = 1;
 652           cdrom_end_request (1, drive);
 653           ide_error (drive, "request sense failure", stat);
 654           return 1;
 655         }
 656 
 657       else if (cmd == PACKET_COMMAND)
 658         {
 659           /* All other functions, except for READ. */
 660 
 661           struct packet_command *pc = (struct packet_command *)rq->buffer;
 662           struct semaphore *sem = NULL;
 663 
 664           /* Check for tray open. */
 665           if (sense_key == NOT_READY)
 666             {
 667               cdrom_saw_media_change (drive);
 668 
 669               /* Print an error message to the syslog.
 670                  Exception: don't print anything if this is a read subchannel
 671                  command.  This is because workman constantly polls the drive
 672                  with this command, and we don't want to uselessly fill up
 673                  the syslog. */
 674               if (pc->c[0] != SCMD_READ_SUBCHANNEL)
 675                 printk ("%s : tray open or drive not ready\n", drive->name);
 676             }
 677 
 678           /* Check for media change. */
 679           else if (sense_key == UNIT_ATTENTION)
 680             {
 681               cdrom_saw_media_change (drive);
 682               printk ("%s: media changed\n", drive->name);
 683             }
 684 
 685           /* Otherwise, print an error. */
 686           else
 687             {
 688               ide_dump_status (drive, "packet command error", stat);
 689             }
 690 
 691           /* Set the error flag and complete the request.
 692              Then, if we have a CHECK CONDITION status, queue a request
 693              sense command.  We must be careful, though: we don't want
 694              the thread in cdrom_queue_packet_command to wake up until
 695              the request sense has completed.  We do this by transferring
 696              the semaphore from the packet command request to the
 697              request sense request. */
 698 
 699           if ((stat & ERR_STAT) != 0)
 700             {
 701               sem = rq->sem;
 702               rq->sem = NULL;
 703             }
 704 
 705           pc->stat = 1;
 706           cdrom_end_request (1, drive);
 707 
 708           if ((stat & ERR_STAT) != 0)
 709             cdrom_queue_request_sense (drive, sem, pc->sense_data, pc);
 710         }
 711 
 712       else
 713         {
 714           /* Handle errors from READ requests. */
 715 
 716           /* Check for tray open. */
 717           if (sense_key == NOT_READY)
 718             {
 719               cdrom_saw_media_change (drive);
 720 
 721               /* Fail the request. */
 722               printk ("%s : tray open\n", drive->name);
 723               cdrom_end_request (0, drive);
 724             }
 725 
 726           /* Check for media change. */
 727           else if (sense_key == UNIT_ATTENTION)
 728             {
 729               cdrom_saw_media_change (drive);
 730 
 731               /* Arrange to retry the request.
 732                  But be sure to give up if we've retried too many times. */
 733               if (++rq->errors > ERROR_MAX)
 734                 {
 735                   cdrom_end_request (0, drive);
 736                 }
 737             }
 738           /* No point in retrying after an illegal request or
 739              data protect error.*/
 740           else if (sense_key == ILLEGAL_REQUEST || sense_key == DATA_PROTECT)
 741             {
 742               ide_dump_status (drive, "command error", stat);
 743               cdrom_end_request (0, drive);
 744             }
 745 
 746           /* If there were other errors, go to the default handler. */
 747           else if ((err & ~ABRT_ERR) != 0)
 748             {
 749               ide_error (drive, "cdrom_decode_status", stat);
 750               return 1;
 751             }
 752 
 753           /* Else, abort if we've racked up too many retries. */
 754           else if ((++rq->errors > ERROR_MAX))
 755             {
 756               cdrom_end_request (0, drive);
 757             }
 758 
 759           /* If we got a CHECK_CONDITION status, queue a request sense
 760              command. */
 761           if ((stat & ERR_STAT) != 0)
 762             cdrom_queue_request_sense (drive, NULL, NULL, NULL);
 763         }
 764     }
 765 
 766   /* Retry, or handle the next request. */
 767   return 1;
 768 }
 769 
 770 
 771 /* Set up the device registers for transferring a packet command on DEV,
 772    expecting to later transfer XFERLEN bytes.  HANDLER is the routine
 773    which actually transfers the command to the drive.  If this is a
 774    drq_interrupt device, this routine will arrange for HANDLER to be
 775    called when the interrupt from the drive arrives.  Otherwise, HANDLER
 776    will be called immediately after the drive is prepared for the transfer. */
 777 
 778 static int cdrom_start_packet_command (ide_drive_t *drive, int xferlen,
     /*  */
 779                                        ide_handler_t *handler)
 780 {
 781   /* Wait for the controller to be idle. */
 782   if (ide_wait_stat (drive, 0, BUSY_STAT, WAIT_READY)) return 1;
 783 
 784   /* Set up the controller registers. */
 785   OUT_BYTE (0, IDE_FEATURE_REG);
 786   OUT_BYTE (0, IDE_NSECTOR_REG);
 787   OUT_BYTE (0, IDE_SECTOR_REG);
 788 
 789   OUT_BYTE (xferlen & 0xff, IDE_LCYL_REG);
 790   OUT_BYTE (xferlen >> 8  , IDE_HCYL_REG);
 791   OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
 792 
 793   if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt)
 794     {
 795       ide_set_handler (drive, handler, WAIT_CMD);
 796       OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
 797     }
 798   else
 799     {
 800       OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
 801       (*handler) (drive);
 802     }
 803 
 804   return 0;
 805 }
 806 
 807 
 808 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
 809    The device registers must have already been prepared
 810    by cdrom_start_packet_command.
 811    HANDLER is the interrupt handler to call when the command completes
 812    or there's data ready. */
 813 static int cdrom_transfer_packet_command (ide_drive_t *drive,
     /*  */
 814                                           char *cmd_buf, int cmd_len,
 815                                           ide_handler_t *handler)
 816 {
 817   if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt)
 818     {
 819       /* Here we should have been called after receiving an interrupt
 820          from the device.  DRQ should how be set. */
 821       int stat_dum;
 822 
 823       /* Check for errors. */
 824       if (cdrom_decode_status (drive, DRQ_STAT, &stat_dum)) return 1;
 825     }
 826   else
 827     {
 828       /* Otherwise, we must wait for DRQ to get set. */
 829       if (ide_wait_stat (drive, DRQ_STAT, BUSY_STAT, WAIT_READY)) return 1;
 830     }
 831 
 832   /* Arm the interrupt handler. */
 833   ide_set_handler (drive, handler, WAIT_CMD);
 834 
 835   /* Send the command to the device. */
 836   cdrom_out_bytes (drive, cmd_buf, cmd_len);
 837 
 838   return 0;
 839 }
 840 
 841 
 842 
 843 /****************************************************************************
 844  * Block read functions.
 845  */
 846 
 847 /*
 848  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
 849  * buffer.  Once the first sector is added, any subsequent sectors are
 850  * assumed to be continuous (until the buffer is cleared).  For the first
 851  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
 852  * the buffer is cleared.)
 853  */
 854 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
     /*  */
 855                                   int sectors_to_transfer)
 856 {
 857   struct cdrom_info *info = &drive->cdrom_info;
 858 
 859   /* Number of sectors to read into the buffer. */
 860   int sectors_to_buffer = MIN (sectors_to_transfer,
 861                                (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
 862                                  info->nsectors_buffered);
 863 
 864   char *dest;
 865 
 866   /* If we don't yet have a sector buffer, try to allocate one.
 867      If we can't get one atomically, it's not fatal -- we'll just throw
 868      the data away rather than caching it. */
 869   if (info->sector_buffer == NULL)
 870     {
 871       info->sector_buffer = (char *) kmalloc (SECTOR_BUFFER_SIZE, GFP_ATOMIC);
 872 
 873       /* If we couldn't get a buffer, don't try to buffer anything... */
 874       if (info->sector_buffer == NULL)
 875         sectors_to_buffer = 0;
 876     }
 877 
 878   /* If this is the first sector in the buffer, remember its number. */
 879   if (info->nsectors_buffered == 0)
 880     info->sector_buffered = sector;
 881 
 882   /* Read the data into the buffer. */
 883   dest = info->sector_buffer + info->nsectors_buffered * SECTOR_SIZE;
 884   while (sectors_to_buffer > 0)
 885     {
 886       cdrom_in_bytes (drive, dest, SECTOR_SIZE);
 887       --sectors_to_buffer;
 888       --sectors_to_transfer;
 889       ++info->nsectors_buffered;
 890       dest += SECTOR_SIZE;
 891     }
 892 
 893   /* Throw away any remaining data. */
 894   while (sectors_to_transfer > 0)
 895     {
 896       char dum[SECTOR_SIZE];
 897       cdrom_in_bytes (drive, dum, sizeof (dum));
 898       --sectors_to_transfer;
 899     }
 900 }
 901 
 902 
 903 /*
 904  * Check the contents of the interrupt reason register from the cdrom
 905  * and attempt to recover if there are problems.  Returns  0 if everything's
 906  * ok; nonzero if the request has been terminated.
 907  */
 908 static inline
 909 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
     /*  */
 910 {
 911   ireason &= 3;
 912   if (ireason == 2) return 0;
 913 
 914   if (ireason == 0)
 915     {
 916       /* Whoops... The drive is expecting to receive data from us! */
 917       printk ("%s: cdrom_read_intr: "
 918               "Drive wants to transfer data the wrong way!\n",
 919               drive->name);
 920 
 921       /* Throw some data at the drive so it doesn't hang
 922          and quit this request. */
 923       while (len > 0)
 924         {
 925           int dum = 0;
 926           cdrom_out_bytes (drive, &dum, sizeof (dum));
 927           len -= sizeof (dum);
 928         }
 929     }
 930 
 931   else
 932     {
 933       /* Drive wants a command packet, or invalid ireason... */
 934       printk ("%s: cdrom_read_intr: bad interrupt reason %d\n",
 935               drive->name, ireason);
 936     }
 937 
 938   cdrom_end_request (0, drive);
 939   return -1;
 940 }
 941 
 942 
 943 /*
 944  * Interrupt routine.  Called when a read request has completed.
 945  */
 946 static void cdrom_read_intr (ide_drive_t *drive)
     /*  */
 947 {
 948   int stat;
 949   int ireason, len, sectors_to_transfer, nskip;
 950 
 951   struct request *rq = HWGROUP(drive)->rq;
 952 
 953   /* Check for errors. */
 954   if (cdrom_decode_status (drive, 0, &stat)) return;
 955 
 956   /* Read the interrupt reason and the transfer length. */
 957   ireason = IN_BYTE (IDE_NSECTOR_REG);
 958   len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
 959 
 960   /* If DRQ is clear, the command has completed. */
 961   if ((stat & DRQ_STAT) == 0)
 962     {
 963       /* If we're not done filling the current buffer, complain.
 964          Otherwise, complete the command normally. */
 965       if (rq->current_nr_sectors > 0)
 966         {
 967           printk ("%s: cdrom_read_intr: data underrun (%ld blocks)\n",
 968                   drive->name, rq->current_nr_sectors);
 969           cdrom_end_request (0, drive);
 970         }
 971       else
 972         cdrom_end_request (1, drive);
 973 
 974       return;
 975     }
 976 
 977   /* Check that the drive is expecting to do the same thing that we are. */
 978   if (cdrom_read_check_ireason (drive, len, ireason)) return;
 979 
 980   /* Assume that the drive will always provide data in multiples of at least
 981      SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise. */
 982   if ((len % SECTOR_SIZE) != 0)
 983     {
 984       printk ("%s: cdrom_read_intr: Bad transfer size %d\n",
 985               drive->name, len);
 986       printk ("  This drive is not supported by this version of the driver\n");
 987       cdrom_end_request (0, drive);
 988       return;
 989     }
 990 
 991   /* The number of sectors we need to read from the drive. */
 992   sectors_to_transfer = len / SECTOR_SIZE;
 993 
 994   /* First, figure out if we need to bit-bucket any of the leading sectors. */
 995   nskip = MIN ((int)(rq->current_nr_sectors - (rq->bh->b_size >> SECTOR_BITS)),
 996                sectors_to_transfer);
 997 
 998   while (nskip > 0)
 999     {
1000       /* We need to throw away a sector. */
1001       char dum[SECTOR_SIZE];
1002       cdrom_in_bytes (drive, dum, sizeof (dum));
1003 
1004       --rq->current_nr_sectors;
1005       --nskip;
1006       --sectors_to_transfer;
1007     }
1008 
1009   /* Now loop while we still have data to read from the drive. */
1010   while (sectors_to_transfer > 0)
1011     {
1012       int this_transfer;
1013 
1014       /* If we've filled the present buffer but there's another chained
1015          buffer after it, move on. */
1016       if (rq->current_nr_sectors == 0 &&
1017           rq->nr_sectors > 0)
1018         cdrom_end_request (1, drive);
1019 
1020       /* If the buffers are full, cache the rest of the data in our
1021          internal buffer. */
1022       if (rq->current_nr_sectors == 0)
1023         {
1024           cdrom_buffer_sectors (drive, rq->sector, sectors_to_transfer);
1025           sectors_to_transfer = 0;
1026         }
1027       else
1028         {
1029           /* Transfer data to the buffers.
1030              Figure out how many sectors we can transfer
1031              to the current buffer. */
1032           this_transfer = MIN (sectors_to_transfer,
1033                                rq->current_nr_sectors);
1034 
1035           /* Read this_transfer sectors into the current buffer. */
1036           while (this_transfer > 0)
1037             {
1038               cdrom_in_bytes (drive, rq->buffer, SECTOR_SIZE);
1039               rq->buffer += SECTOR_SIZE;
1040               --rq->nr_sectors;
1041               --rq->current_nr_sectors;
1042               ++rq->sector;
1043               --this_transfer;
1044               --sectors_to_transfer;
1045             }
1046         }
1047     }
1048 
1049   /* Done moving data!
1050      Wait for another interrupt. */
1051   ide_set_handler (drive, &cdrom_read_intr, WAIT_CMD);
1052 }
1053 
1054 
1055 /*
1056  * Try to satisfy some of the current read request from our cached data.
1057  * Returns nonzero if the request has been completed, zero otherwise.
1058  */
1059 static int cdrom_read_from_buffer (ide_drive_t *drive)
     /*  */
1060 {
1061   struct cdrom_info *info = &drive->cdrom_info;
1062   struct request *rq = HWGROUP(drive)->rq;
1063 
1064   /* Can't do anything if there's no buffer. */
1065   if (info->sector_buffer == NULL) return 0;
1066 
1067   /* Loop while this request needs data and the next block is present
1068      in our cache. */
1069   while (rq->nr_sectors > 0 &&
1070          rq->sector >= info->sector_buffered &&
1071          rq->sector < info->sector_buffered + info->nsectors_buffered)
1072     {
1073       if (rq->current_nr_sectors == 0)
1074         cdrom_end_request (1, drive);
1075 
1076       memcpy (rq->buffer,
1077               info->sector_buffer +
1078                 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1079               SECTOR_SIZE);
1080       rq->buffer += SECTOR_SIZE;
1081       --rq->current_nr_sectors;
1082       --rq->nr_sectors;
1083       ++rq->sector;
1084     }
1085 
1086   /* If we've satisfied the current request, terminate it successfully. */
1087   if (rq->nr_sectors == 0)
1088     {
1089       cdrom_end_request (1, drive);
1090       return -1;
1091     }
1092 
1093   /* Move on to the next buffer if needed. */
1094   if (rq->current_nr_sectors == 0)
1095     cdrom_end_request (1, drive);
1096 
1097   /* If this condition does not hold, then the kluge i use to
1098      represent the number of sectors to skip at the start of a transfer
1099      will fail.  I think that this will never happen, but let's be
1100      paranoid and check. */
1101   if (rq->current_nr_sectors < (rq->bh->b_size >> SECTOR_BITS) &&
1102       (rq->sector % SECTORS_PER_FRAME) != 0)
1103     {
1104       printk ("%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1105               drive->name, rq->sector);
1106       cdrom_end_request (0, drive);
1107       return -1;
1108     }
1109 
1110   return 0;
1111 }
1112 
1113 
1114 
1115 /*
1116  * Routine to send a read packet command to the drive.
1117  * This is usually called directly from cdrom_start_read.
1118  * However, for drq_interrupt devices, it is called from an interrupt
1119  * when the drive is ready to accept the command.
1120  */
1121 static void cdrom_start_read_continuation (ide_drive_t *drive)
     /*  */
1122 {
1123   struct packet_command pc;
1124   struct request *rq = HWGROUP(drive)->rq;
1125 
1126   int nsect, sector, nframes, frame, nskip;
1127 
1128   /* Number of sectors to transfer. */
1129   nsect = rq->nr_sectors;
1130 
1131   /* Starting sector. */
1132   sector = rq->sector;
1133 
1134   /* If the requested sector doesn't start on a cdrom block boundary,
1135      we must adjust the start of the transfer so that it does,
1136      and remember to skip the first few sectors.  If the CURRENT_NR_SECTORS
1137      field is larger than the size of the buffer, it will mean that
1138      we're to skip a number of sectors equal to the amount by which
1139      CURRENT_NR_SECTORS is larger than the buffer size. */
1140   nskip = (sector % SECTORS_PER_FRAME);
1141   if (nskip > 0)
1142     {
1143       /* Sanity check... */
1144       if (rq->current_nr_sectors != (rq->bh->b_size >> SECTOR_BITS))
1145         {
1146           printk ("%s: cdrom_start_read_continuation: buffer botch (%ld)\n",
1147                   drive->name, rq->current_nr_sectors);
1148           cdrom_end_request (0, drive);
1149           return;
1150         }
1151 
1152       sector -= nskip;
1153       nsect += nskip;
1154       rq->current_nr_sectors += nskip;
1155     }
1156 
1157   /* Convert from sectors to cdrom blocks, rounding up the transfer
1158      length if needed. */
1159   nframes = (nsect + SECTORS_PER_FRAME-1) / SECTORS_PER_FRAME;
1160   frame = sector / SECTORS_PER_FRAME;
1161 
1162   /* Largest number of frames was can transfer at once is 64k-1. */
1163   nframes = MIN (nframes, 65535);
1164 
1165   /* Set up the command */
1166   memset (&pc.c, 0, sizeof (pc.c));
1167   pc.c[0] = READ_10;
1168   pc.c[7] = (nframes >> 8);
1169   pc.c[8] = (nframes & 0xff);
1170 #ifdef __alpha__
1171   stl_u (htonl (frame), (unsigned int *) &pc.c[2]);
1172 #else
1173   *(int *)(&pc.c[2]) = htonl (frame);
1174 #endif
1175 
1176   /* Send the command to the drive and return. */
1177   (void) cdrom_transfer_packet_command (drive, pc.c, sizeof (pc.c),
1178                                         &cdrom_read_intr);
1179 }
1180 
1181 
1182 /*
1183  * Start a read request from the CD-ROM.
1184  */
1185 static void cdrom_start_read (ide_drive_t *drive, unsigned int block)
     /*  */
1186 {
1187   struct request *rq = HWGROUP(drive)->rq;
1188   int minor = MINOR (rq->rq_dev);
1189 
1190   /* If the request is relative to a partition, fix it up to refer to the
1191      absolute address.  */
1192   if ((minor & PARTN_MASK) != 0) {
1193     rq->sector = block;
1194     minor &= ~PARTN_MASK;
1195     rq->rq_dev = MKDEV (MAJOR(rq->rq_dev), minor);
1196   }
1197 
1198   /* We may be retrying this request after an error.
1199      Fix up any weirdness which might be present in the request packet. */
1200   restore_request (rq);
1201 
1202   /* Satisfy whatever we can of this request from our cached sector. */
1203   if (cdrom_read_from_buffer (drive))
1204     return;
1205 
1206   /* Clear the local sector buffer. */
1207   drive->cdrom_info.nsectors_buffered = 0;
1208 
1209   /* Start sending the read request to the drive. */
1210   cdrom_start_packet_command (drive, 32768, cdrom_start_read_continuation);
1211 }
1212 
1213 
1214 
1215 
1216 /****************************************************************************
1217  * Execute all other packet commands.
1218  */
1219 
1220 /* Forward declarations. */
1221 static int
1222 cdrom_lockdoor (ide_drive_t *drive, int lockflag,
1223                 struct atapi_request_sense *reqbuf);
1224 
1225 
1226 
1227 /* Interrupt routine for packet command completion. */
1228 static void cdrom_pc_intr (ide_drive_t *drive)
     /*  */
1229 {
1230   int ireason, len, stat, thislen;
1231   struct request *rq = HWGROUP(drive)->rq;
1232   struct packet_command *pc = (struct packet_command *)rq->buffer;
1233 
1234   /* Check for errors. */
1235   if (cdrom_decode_status (drive, 0, &stat)) return;
1236 
1237   /* Read the interrupt reason and the transfer length. */
1238   ireason = IN_BYTE (IDE_NSECTOR_REG);
1239   len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
1240 
1241   /* If DRQ is clear, the command has completed.
1242      Complain if we still have data left to transfer. */
1243   if ((stat & DRQ_STAT) == 0)
1244     {
1245       /* Some of the trailing request sense fields are optional, and
1246          some drives don't send them.  Sigh. */
1247       if (pc->c[0] == REQUEST_SENSE && pc->buflen > 0 && pc->buflen <= 5) {
1248         while (pc->buflen > 0) {
1249           *pc->buffer++ = 0;
1250           --pc->buflen;
1251         }
1252       }
1253 
1254       if (pc->buflen == 0)
1255         cdrom_end_request (1, drive);
1256       else
1257         {
1258           printk ("%s: cdrom_pc_intr: data underrun %d\n",
1259                   drive->name, pc->buflen);
1260           pc->stat = 1;
1261           cdrom_end_request (1, drive);
1262         }
1263       return;
1264     }
1265 
1266   /* Figure out how much data to transfer. */
1267   thislen = pc->buflen;
1268   if (thislen < 0) thislen = -thislen;
1269   if (thislen > len) thislen = len;
1270 
1271   /* The drive wants to be written to. */
1272   if ((ireason & 3) == 0)
1273     {
1274       /* Check that we want to write. */
1275       if (pc->buflen > 0)
1276         {
1277           printk ("%s: cdrom_pc_intr: Drive wants to transfer data the wrong way!\n",
1278                   drive->name);
1279           pc->stat = 1;
1280           thislen = 0;
1281         }
1282 
1283       /* Transfer the data. */
1284       cdrom_out_bytes (drive, pc->buffer, thislen);
1285 
1286       /* If we haven't moved enough data to satisfy the drive,
1287          add some padding. */
1288       while (len > thislen)
1289         {
1290           int dum = 0;
1291           cdrom_out_bytes (drive, &dum, sizeof (dum));
1292           len -= sizeof (dum);
1293         }
1294 
1295       /* Keep count of how much data we've moved. */
1296       pc->buffer += thislen;
1297       pc->buflen += thislen;
1298     }
1299 
1300   /* Same drill for reading. */
1301   else if ((ireason & 3) == 2)
1302     {
1303       /* Check that we want to read. */
1304       if (pc->buflen < 0)
1305         {
1306           printk ("%s: cdrom_pc_intr: Drive wants to transfer data the wrong way!\n",
1307                   drive->name);
1308           pc->stat = 1;
1309           thislen = 0;
1310         }
1311 
1312       /* Transfer the data. */
1313       cdrom_in_bytes (drive, pc->buffer, thislen);
1314 
1315       /* If we haven't moved enough data to satisfy the drive,
1316          add some padding. */
1317       while (len > thislen)
1318         {
1319           int dum = 0;
1320           cdrom_in_bytes (drive, &dum, sizeof (dum));
1321           len -= sizeof (dum);
1322         }
1323 
1324       /* Keep count of how much data we've moved. */
1325       pc->buffer += thislen;
1326       pc->buflen -= thislen;
1327     }
1328 
1329   else
1330     {
1331       printk ("%s: cdrom_pc_intr: The drive appears confused (ireason = 0x%2x)\n",
1332               drive->name, ireason);
1333       pc->stat = 1;
1334     }
1335 
1336   /* Now we wait for another interrupt. */
1337   ide_set_handler (drive, &cdrom_pc_intr, WAIT_CMD);
1338 }
1339 
1340 
1341 static void cdrom_do_pc_continuation (ide_drive_t *drive)
     /*  */
1342 {
1343   struct request *rq = HWGROUP(drive)->rq;
1344   struct packet_command *pc = (struct packet_command *)rq->buffer;
1345 
1346   /* Send the command to the drive and return. */
1347   cdrom_transfer_packet_command (drive, pc->c, sizeof (pc->c), &cdrom_pc_intr);
1348 }
1349 
1350 
1351 static void cdrom_do_packet_command (ide_drive_t *drive)
     /*  */
1352 {
1353   int len;
1354   struct request *rq = HWGROUP(drive)->rq;
1355   struct packet_command *pc = (struct packet_command *)rq->buffer;
1356 
1357   len = pc->buflen;
1358   if (len < 0) len = -len;
1359 
1360   pc->stat = 0;
1361 
1362   /* Start sending the command to the drive. */
1363   cdrom_start_packet_command (drive, len, cdrom_do_pc_continuation);
1364 }
1365 
1366 
1367 /* Sleep for TIME jiffies.
1368    Not to be called from an interrupt handler. */
1369 static
1370 void cdrom_sleep (int time)
     /*  */
1371 {
1372   current->state = TASK_INTERRUPTIBLE;
1373   current->timeout = jiffies + time;
1374   schedule ();
1375 }
1376 
1377 static
1378 int cdrom_queue_packet_command (ide_drive_t *drive, struct packet_command *pc)
     /*  */
1379 {
1380   struct atapi_request_sense my_reqbuf;
1381   int retries = 10;
1382   struct request req;
1383 
1384   /* If our caller has not provided a place to stick any sense data,
1385      use our own area. */
1386   if (pc->sense_data == NULL)
1387     pc->sense_data = &my_reqbuf;
1388   pc->sense_data->sense_key = 0;
1389 
1390   /* Start of retry loop. */
1391   do {
1392     ide_init_drive_cmd (&req);
1393     req.cmd = PACKET_COMMAND;
1394     req.buffer = (char *)pc;
1395     (void) ide_do_drive_cmd (drive, &req, ide_wait);
1396 
1397     if (pc->stat != 0)
1398       {
1399         /* The request failed.  Retry if it was due to a unit attention status
1400            (usually means media was changed). */
1401         struct atapi_request_sense *reqbuf = pc->sense_data;
1402 
1403         if (reqbuf->sense_key == UNIT_ATTENTION)
1404           ;
1405 
1406         /* Also retry if the drive is in the process of loading a disk.
1407            This time, however, wait a little between retries to give
1408            the drive time. */
1409         else if (reqbuf->sense_key == NOT_READY && reqbuf->asc == 4)
1410           {
1411             cdrom_sleep (HZ);
1412           }
1413 
1414         /* Otherwise, don't retry. */
1415         else
1416           retries = 0;
1417 
1418         --retries;
1419       }
1420 
1421     /* End of retry loop. */
1422   } while (pc->stat != 0 && retries >= 0);
1423 
1424 
1425   /* Return an error if the command failed. */
1426   if (pc->stat != 0)
1427     return -EIO;
1428 
1429   else
1430     {
1431       /* The command succeeded.  If it was anything other than a request sense,
1432          eject, or door lock command, and we think that the door is presently
1433          unlocked, lock it again.  (The door was probably unlocked via
1434          an explicit CDROMEJECT ioctl.) */
1435       if (CDROM_STATE_FLAGS (drive)->door_locked == 0 &&
1436           (pc->c[0] != REQUEST_SENSE &&
1437            pc->c[0] != ALLOW_MEDIUM_REMOVAL &&
1438            pc->c[0] != START_STOP))
1439         {
1440           (void) cdrom_lockdoor (drive, 1, NULL);
1441         }
1442       return 0;
1443     }
1444 }
1445 
1446 
1447 
1448 /****************************************************************************
1449  * drive_cmd handling.
1450  *
1451  * Most of the functions accessed via drive_cmd are not valid for ATAPI
1452  * devices.  Only attempt to execute those which actually should be valid.
1453  */
1454 
1455 static
1456 void cdrom_do_drive_cmd (ide_drive_t *drive)
     /*  */
1457 {
1458   struct request *rq = HWGROUP(drive)->rq;
1459   byte *args = rq->buffer;
1460 
1461   if (args)
1462     {
1463 #if 0  /* This bit isn't done yet... */
1464       if (args[0] == WIN_SETFEATURES &&
1465           (args[2] == 0x66 || args[2] == 0xcc || args[2] == 0x02 ||
1466            args[2] == 0xdd || args[2] == 0x5d))
1467         {
1468           OUT_BYTE (args[2], io_base + IDE_FEATURE_OFFSET);
1469           <send cmd>
1470         }
1471       else
1472 #endif
1473         {
1474           printk ("%s: Unsupported drive command %02x %02x %02x\n",
1475                   drive->name, args[0], args[1], args[2]);
1476           rq->errors = 1;
1477         }
1478     }
1479 
1480   cdrom_end_request (1, drive);
1481 }
1482 
1483 
1484 
1485 /****************************************************************************
1486  * cdrom driver request routine.
1487  */
1488 
1489 void ide_do_rw_cdrom (ide_drive_t *drive, unsigned long block)
     /*  */
1490 {
1491   struct request *rq = HWGROUP(drive)->rq;
1492 
1493   if (rq -> cmd == PACKET_COMMAND || rq -> cmd == REQUEST_SENSE_COMMAND)
1494     cdrom_do_packet_command (drive);
1495 
1496   else if (rq -> cmd == RESET_DRIVE_COMMAND)
1497     {
1498       cdrom_end_request (1, drive);
1499       ide_do_reset (drive);
1500       return;
1501     }
1502 
1503   else if (rq -> cmd == IDE_DRIVE_CMD)
1504     cdrom_do_drive_cmd (drive);
1505 
1506   else if (rq -> cmd != READ)
1507     {
1508       printk ("ide-cd: bad cmd %d\n", rq -> cmd);
1509       cdrom_end_request (0, drive);
1510     }
1511   else
1512     cdrom_start_read (drive, block);
1513 }
1514 
1515 
1516 
1517 /****************************************************************************
1518  * Ioctl handling.
1519  *
1520  * Routines which queue packet commands take as a final argument a pointer
1521  * to an atapi_request_sense struct.  If execution of the command results
1522  * in an error with a CHECK CONDITION status, this structure will be filled
1523  * with the results of the subsequent request sense command.  The pointer
1524  * can also be NULL, in which case no sense information is returned.
1525  */
1526 
1527 #if ! STANDARD_ATAPI
1528 static
1529 int bin2bcd (int x)
     /*  */
1530 {
1531   return (x%10) | ((x/10) << 4);
1532 }
1533 
1534 
1535 static
1536 int bcd2bin (int x)
     /*  */
1537 {
1538   return (x >> 4) * 10 + (x & 0x0f);
1539 }
1540 #endif /* not STANDARD_ATAPI */
1541 
1542 
1543 static inline
1544 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
     /*  */
1545 {
1546   lba += CD_BLOCK_OFFSET;
1547   lba &= 0xffffff;  /* negative lbas use only 24 bits */
1548   *m = lba / (CD_SECS * CD_FRAMES);
1549   lba %= (CD_SECS * CD_FRAMES);
1550   *s = lba / CD_FRAMES;
1551   *f = lba % CD_FRAMES;
1552 }
1553 
1554 
1555 static inline
1556 int msf_to_lba (byte m, byte s, byte f)
     /*  */
1557 {
1558   return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_BLOCK_OFFSET;
1559 }
1560 
1561 
1562 static int
1563 cdrom_check_status (ide_drive_t  *drive,
     /*  */
1564                     struct atapi_request_sense *reqbuf)
1565 {
1566   struct packet_command pc;
1567 
1568   memset (&pc, 0, sizeof (pc));
1569 
1570   pc.sense_data = reqbuf;
1571   pc.c[0] = TEST_UNIT_READY;
1572 
1573   return cdrom_queue_packet_command (drive, &pc);
1574 }
1575 
1576 
1577 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1578 static int
1579 cdrom_lockdoor (ide_drive_t *drive, int lockflag,
     /*  */
1580                 struct atapi_request_sense *reqbuf)
1581 {
1582   struct atapi_request_sense my_reqbuf;
1583   int stat;
1584   struct packet_command pc;
1585 
1586   if (reqbuf == NULL)
1587     reqbuf = &my_reqbuf;
1588 
1589   /* If the drive cannot lock the door, just pretend. */
1590   if (CDROM_CONFIG_FLAGS (drive)->no_doorlock)
1591     stat = 0;
1592   else
1593     {
1594       memset (&pc, 0, sizeof (pc));
1595       pc.sense_data = reqbuf;
1596 
1597       pc.c[0] = ALLOW_MEDIUM_REMOVAL;
1598       pc.c[4] = (lockflag != 0);
1599       stat = cdrom_queue_packet_command (drive, &pc);
1600     }
1601 
1602   if (stat == 0)
1603     CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
1604   else
1605     {
1606       /* If we got an illegal field error, the drive
1607          probably cannot lock the door. */
1608       if (reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x24)
1609         {
1610           printk ("%s: door locking not supported\n", drive->name);
1611           CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
1612           stat = 0;
1613           CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
1614         }
1615     }
1616   return stat;
1617 }
1618 
1619 
1620 /* Eject the disk if EJECTFLAG is 0.
1621    If EJECTFLAG is 1, try to reload the disk. */
1622 static int
1623 cdrom_eject (ide_drive_t *drive, int ejectflag,
     /*  */
1624              struct atapi_request_sense *reqbuf)
1625 {
1626   struct packet_command pc;
1627 
1628   memset (&pc, 0, sizeof (pc));
1629   pc.sense_data = reqbuf;
1630 
1631   pc.c[0] = START_STOP;
1632   pc.c[4] = 2 + (ejectflag != 0);
1633   return cdrom_queue_packet_command (drive, &pc);
1634 }
1635 
1636 
1637 static int
1638 cdrom_pause (ide_drive_t *drive, int pauseflag,
     /*  */
1639              struct atapi_request_sense *reqbuf)
1640 {
1641   struct packet_command pc;
1642 
1643   memset (&pc, 0, sizeof (pc));
1644   pc.sense_data = reqbuf;
1645 
1646   pc.c[0] = SCMD_PAUSE_RESUME;
1647   pc.c[8] = !pauseflag;
1648   return cdrom_queue_packet_command (drive, &pc);
1649 }
1650 
1651 
1652 static int
1653 cdrom_startstop (ide_drive_t *drive, int startflag,
     /*  */
1654                  struct atapi_request_sense *reqbuf)
1655 {
1656   struct packet_command pc;
1657 
1658   memset (&pc, 0, sizeof (pc));
1659   pc.sense_data = reqbuf;
1660 
1661   pc.c[0] = START_STOP;
1662   pc.c[1] = 1;
1663   pc.c[4] = startflag;
1664   return cdrom_queue_packet_command (drive, &pc);
1665 }
1666 
1667 
1668 static int
1669 cdrom_read_capacity (ide_drive_t *drive, unsigned *capacity,
     /*  */
1670                      struct atapi_request_sense *reqbuf)
1671 {
1672   struct {
1673     unsigned lba;
1674     unsigned blocklen;
1675   } capbuf;
1676 
1677   int stat;
1678   struct packet_command pc;
1679 
1680   memset (&pc, 0, sizeof (pc));
1681   pc.sense_data = reqbuf;
1682 
1683   pc.c[0] = READ_CAPACITY;
1684   pc.buffer = (char *)&capbuf;
1685   pc.buflen = sizeof (capbuf);
1686 
1687   stat = cdrom_queue_packet_command (drive, &pc);
1688   if (stat == 0)
1689     {
1690       *capacity = ntohl (capbuf.lba);
1691     }
1692 
1693   return stat;
1694 }
1695 
1696 
1697 static int
1698 cdrom_read_tocentry (ide_drive_t *drive, int trackno, int msf_flag,
     /*  */
1699                      int format, char *buf, int buflen,
1700                      struct atapi_request_sense *reqbuf)
1701 {
1702   struct packet_command pc;
1703 
1704   memset (&pc, 0, sizeof (pc));
1705   pc.sense_data = reqbuf;
1706 
1707   pc.buffer =  buf;
1708   pc.buflen = buflen;
1709   pc.c[0] = SCMD_READ_TOC;
1710   pc.c[6] = trackno;
1711   pc.c[7] = (buflen >> 8);
1712   pc.c[8] = (buflen & 0xff);
1713   pc.c[9] = (format << 6);
1714   if (msf_flag) pc.c[1] = 2;
1715   return cdrom_queue_packet_command (drive, &pc);
1716 }
1717 
1718 
1719 /* Try to read the entire TOC for the disk into our internal buffer. */
1720 static int
1721 cdrom_read_toc (ide_drive_t *drive,
     /*  */
1722                 struct atapi_request_sense *reqbuf)
1723 {
1724   int msf_flag;
1725   int stat, ntracks, i;
1726   struct atapi_toc *toc = drive->cdrom_info.toc;
1727   struct {
1728     struct atapi_toc_header hdr;
1729     struct atapi_toc_entry  ent;
1730   } ms_tmp;
1731 
1732   if (toc == NULL)
1733     {
1734       /* Try to allocate space. */
1735       toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
1736                                           GFP_KERNEL);
1737       drive->cdrom_info.toc = toc;
1738     }
1739 
1740   if (toc == NULL)
1741     {
1742       printk ("%s: No cdrom TOC buffer!\n", drive->name);
1743       return -EIO;
1744     }
1745 
1746   /* Check to see if the existing data is still valid.
1747      If it is, just return. */
1748   if (CDROM_STATE_FLAGS (drive)->toc_valid)
1749     (void) cdrom_check_status (drive, NULL);
1750 
1751   if (CDROM_STATE_FLAGS (drive)->toc_valid) return 0;
1752 
1753 #if STANDARD_ATAPI
1754   msf_flag = 0;
1755 #else  /* not STANDARD_ATAPI */
1756   /* Some drives can't return TOC data in LBA format. */
1757   msf_flag = (CDROM_CONFIG_FLAGS (drive)->no_lba_toc);
1758 #endif  /* not STANDARD_ATAPI */
1759 
1760   /* First read just the header, so we know how long the TOC is. */
1761   stat = cdrom_read_tocentry (drive, 0, msf_flag, 0, (char *)&toc->hdr,
1762                               sizeof (struct atapi_toc_header) +
1763                               sizeof (struct atapi_toc_entry),
1764                               reqbuf);
1765   if (stat) return stat;
1766 
1767 #if ! STANDARD_ATAPI
1768   if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
1769     {
1770       toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
1771       toc->hdr.last_track  = bcd2bin (toc->hdr.last_track);
1772       /* hopefully the length is not BCD, too ;-| */
1773     }
1774 #endif  /* not STANDARD_ATAPI */
1775 
1776   ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1777   if (ntracks <= 0) return -EIO;
1778   if (ntracks > MAX_TRACKS) ntracks = MAX_TRACKS;
1779 
1780   /* Now read the whole schmeer. */
1781   stat = cdrom_read_tocentry (drive, 0, msf_flag, 0, (char *)&toc->hdr,
1782                               sizeof (struct atapi_toc_header) +
1783                               (ntracks+1) * sizeof (struct atapi_toc_entry),
1784                               reqbuf);
1785   if (stat) return stat;
1786   toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1787 
1788 #if ! STANDARD_ATAPI
1789   if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
1790     {
1791       toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
1792       toc->hdr.last_track  = bcd2bin (toc->hdr.last_track);
1793       /* hopefully the length is not BCD, too ;-| */
1794     }
1795 #endif  /* not STANDARD_ATAPI */
1796 
1797   for (i=0; i<=ntracks; i++)
1798     {
1799 #if ! STANDARD_ATAPI
1800       if (msf_flag)
1801         {
1802           if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
1803             {
1804               toc->ent[i].track = bcd2bin (toc->ent[i].track);
1805               toc->ent[i].addr.msf.m = bcd2bin (toc->ent[i].addr.msf.m);
1806               toc->ent[i].addr.msf.s = bcd2bin (toc->ent[i].addr.msf.s);
1807               toc->ent[i].addr.msf.f = bcd2bin (toc->ent[i].addr.msf.f);
1808             }
1809           toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.m,
1810                                              toc->ent[i].addr.msf.s,
1811                                              toc->ent[i].addr.msf.f);
1812         }
1813       else
1814 #endif  /* not STANDARD_ATAPI */
1815         toc->ent[i].addr.lba = ntohl (toc->ent[i].addr.lba);
1816     }
1817 
1818   /* Read the multisession information. */
1819   stat = cdrom_read_tocentry (drive, 0, msf_flag, 1,
1820                               (char *)&ms_tmp, sizeof (ms_tmp),
1821                               reqbuf);
1822   if (stat) return stat;
1823 #if ! STANDARD_ATAPI
1824   if (msf_flag)
1825     toc->last_session_lba = msf_to_lba (ms_tmp.ent.addr.msf.m,
1826                                         ms_tmp.ent.addr.msf.s,
1827                                         ms_tmp.ent.addr.msf.f);
1828   else
1829 #endif  /* not STANDARD_ATAPI */
1830     toc->last_session_lba = ntohl (ms_tmp.ent.addr.lba);
1831 
1832   toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1833 
1834   /* Now try to get the total cdrom capacity. */
1835   stat = cdrom_read_capacity (drive, &toc->capacity, reqbuf);
1836   if (stat) toc->capacity = 0x1fffff;
1837 
1838   HWIF(drive)->gd->sizes[drive->select.b.unit << PARTN_BITS]
1839     = toc->capacity * SECTORS_PER_FRAME;
1840   drive->part[0].nr_sects = toc->capacity * SECTORS_PER_FRAME;
1841 
1842   /* Remember that we've read this stuff. */
1843   CDROM_STATE_FLAGS (drive)->toc_valid = 1;
1844 
1845   return 0;
1846 }
1847 
1848 
1849 static int
1850 cdrom_read_subchannel (ide_drive_t *drive,
     /*  */
1851                        char *buf, int buflen,
1852                        struct atapi_request_sense *reqbuf)
1853 {
1854   struct packet_command pc;
1855 
1856   memset (&pc, 0, sizeof (pc));
1857   pc.sense_data = reqbuf;
1858 
1859   pc.buffer =  buf;
1860   pc.buflen = buflen;
1861   pc.c[0] = SCMD_READ_SUBCHANNEL;
1862   pc.c[2] = 0x40;  /* request subQ data */
1863   pc.c[3] = 0x01;  /* Format 1: current position */
1864   pc.c[7] = (buflen >> 8);
1865   pc.c[8] = (buflen & 0xff);
1866   return cdrom_queue_packet_command (drive, &pc);
1867 }
1868 
1869 
1870 /* modeflag: 0 = current, 1 = changeable mask, 2 = default, 3 = saved */
1871 static int
1872 cdrom_mode_sense (ide_drive_t *drive, int pageno, int modeflag,
     /*  */
1873                   char *buf, int buflen,
1874                   struct atapi_request_sense *reqbuf)
1875 {
1876   struct packet_command pc;
1877 
1878   memset (&pc, 0, sizeof (pc));
1879   pc.sense_data = reqbuf;
1880 
1881   pc.buffer =  buf;
1882   pc.buflen = buflen;
1883   pc.c[0] = MODE_SENSE_10;
1884   pc.c[2] = pageno | (modeflag << 6);
1885   pc.c[7] = (buflen >> 8);
1886   pc.c[8] = (buflen & 0xff);
1887   return cdrom_queue_packet_command (drive, &pc);
1888 }
1889 
1890 
1891 static int
1892 cdrom_mode_select (ide_drive_t *drive, int pageno, char *buf, int buflen,
     /*  */
1893                    struct atapi_request_sense *reqbuf)
1894 {
1895   struct packet_command pc;
1896 
1897   memset (&pc, 0, sizeof (pc));
1898   pc.sense_data = reqbuf;
1899 
1900   pc.buffer =  buf;
1901   pc.buflen = - buflen;
1902   pc.c[0] = MODE_SELECT_10;
1903   pc.c[1] = 0x10;
1904   pc.c[2] = pageno;
1905   pc.c[7] = (buflen >> 8);
1906   pc.c[8] = (buflen & 0xff);
1907   return cdrom_queue_packet_command (drive, &pc);
1908 }
1909 
1910 
1911 static int
1912 cdrom_play_lba_range_play12 (ide_drive_t *drive, int lba_start, int lba_end,
     /*  */
1913                              struct atapi_request_sense *reqbuf)
1914 {
1915   struct packet_command pc;
1916 
1917   memset (&pc, 0, sizeof (pc));
1918   pc.sense_data = reqbuf;
1919 
1920   pc.c[0] = SCMD_PLAYAUDIO12;
1921 #ifdef __alpha__
1922   stq_u(((long) htonl (lba_end - lba_start) << 32) | htonl(lba_start),
1923         (unsigned long *) &pc.c[2]);
1924 #else
1925   *(int *)(&pc.c[2]) = htonl (lba_start);
1926   *(int *)(&pc.c[6]) = htonl (lba_end - lba_start);
1927 #endif
1928 
1929   return cdrom_queue_packet_command (drive, &pc);
1930 }
1931 
1932 
1933 #if !  STANDARD_ATAPI
1934 static int
1935 cdrom_play_lba_range_msf (ide_drive_t *drive, int lba_start, int lba_end,
     /*  */
1936                           struct atapi_request_sense *reqbuf)
1937 {
1938   struct packet_command pc;
1939 
1940   memset (&pc, 0, sizeof (pc));
1941   pc.sense_data = reqbuf;
1942 
1943   pc.c[0] = SCMD_PLAYAUDIO_MSF;
1944   lba_to_msf (lba_start, &pc.c[3], &pc.c[4], &pc.c[5]);
1945   lba_to_msf (lba_end-1, &pc.c[6], &pc.c[7], &pc.c[8]);
1946 
1947   if (CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd)
1948     {
1949       pc.c[3] = bin2bcd (pc.c[3]);
1950       pc.c[4] = bin2bcd (pc.c[4]);
1951       pc.c[5] = bin2bcd (pc.c[5]);
1952       pc.c[6] = bin2bcd (pc.c[6]);
1953       pc.c[7] = bin2bcd (pc.c[7]);
1954       pc.c[8] = bin2bcd (pc.c[8]);
1955     }
1956 
1957   return cdrom_queue_packet_command (drive, &pc);
1958 }
1959 #endif  /* not STANDARD_ATAPI */
1960 
1961 
1962 static int
1963 cdrom_play_lba_range_1 (ide_drive_t *drive, int lba_start, int lba_end,
     /*  */
1964                         struct atapi_request_sense *reqbuf)
1965 {
1966   /* This is rather annoying.
1967      My NEC-260 won't recognize group 5 commands such as PLAYAUDIO12;
1968      the only way to get it to play more than 64k of blocks at once
1969      seems to be the PLAYAUDIO_MSF command.  However, the parameters
1970      the NEC 260 wants for the PLAYMSF command are incompatible with
1971      the new version of the spec.
1972 
1973      So what i'll try is this.  First try for PLAYAUDIO12.  If it works,
1974      great.  Otherwise, if the drive reports an illegal command code,
1975      try PLAYAUDIO_MSF using the NEC 260-style bcd parameters. */
1976 
1977 #if ! STANDARD_ATAPI
1978   if (CDROM_CONFIG_FLAGS (drive)->no_playaudio12)
1979     return cdrom_play_lba_range_msf (drive, lba_start, lba_end, reqbuf);
1980   else
1981 #endif  /* not STANDARD_ATAPI */
1982     {
1983       int stat;
1984       struct atapi_request_sense my_reqbuf;
1985 
1986       if (reqbuf == NULL)
1987         reqbuf = &my_reqbuf;
1988 
1989       stat = cdrom_play_lba_range_play12 (drive, lba_start, lba_end, reqbuf);
1990       if (stat == 0) return 0;
1991 
1992 #if ! STANDARD_ATAPI
1993       /* It failed.  Try to find out why. */
1994       if (reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x20)
1995         {
1996           /* The drive didn't recognize the command.
1997              Retry with the MSF variant. */
1998           printk ("%s: Drive does not support PLAYAUDIO12; "
1999                   "trying PLAYAUDIO_MSF\n", drive->name);
2000           CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
2001           CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd = 1;
2002           return cdrom_play_lba_range_msf (drive, lba_start, lba_end, reqbuf);
2003         }
2004 #endif  /* not STANDARD_ATAPI */
2005 
2006       /* Failed for some other reason.  Give up. */
2007       return stat;
2008     }
2009 }
2010 
2011 
2012 /* Play audio starting at LBA LBA_START and finishing with the
2013    LBA before LBA_END. */
2014 static int
2015 cdrom_play_lba_range (ide_drive_t *drive, int lba_start, int lba_end,
     /*  */
2016                       struct atapi_request_sense *reqbuf)
2017 {
2018   int i, stat;
2019   struct atapi_request_sense my_reqbuf;
2020 
2021   if (reqbuf == NULL)
2022     reqbuf = &my_reqbuf;
2023 
2024   /* Some drives, will, for certain audio cds,
2025      give an error if you ask them to play the entire cd using the
2026      values which are returned in the TOC.  The play will succeed, however,
2027      if the ending address is adjusted downwards by a few frames. */
2028   for (i=0; i<75; i++)
2029     {
2030       stat = cdrom_play_lba_range_1 (drive, lba_start, lba_end, reqbuf);
2031 
2032       if (stat == 0 ||
2033           !(reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x24))
2034         return stat;
2035 
2036       --lba_end;
2037       if (lba_end <= lba_start) break;
2038     }
2039 
2040   return stat;
2041 }
2042 
2043 
2044 static
2045 int cdrom_get_toc_entry (ide_drive_t *drive, int track,
     /*  */
2046                          struct atapi_toc_entry **ent,
2047                          struct atapi_request_sense *reqbuf)
2048 {
2049   int stat, ntracks;
2050   struct atapi_toc *toc;
2051 
2052   /* Make sure our saved TOC is valid. */
2053   stat = cdrom_read_toc (drive, reqbuf);
2054   if (stat) return stat;
2055 
2056   toc = drive->cdrom_info.toc;
2057 
2058   /* Check validity of requested track number. */
2059   ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2060   if (track == CDROM_LEADOUT)
2061     *ent = &toc->ent[ntracks];
2062   else if (track < toc->hdr.first_track ||
2063            track > toc->hdr.last_track)
2064     return -EINVAL;
2065   else
2066     *ent = &toc->ent[track - toc->hdr.first_track];
2067 
2068   return 0;
2069 }
2070 
2071 
2072 static int
2073 cdrom_read_block (ide_drive_t *drive, int format, int lba,
     /*  */
2074                   char *buf, int buflen,
2075                   struct atapi_request_sense *reqbuf)
2076 {
2077   struct packet_command pc;
2078   struct atapi_request_sense my_reqbuf;
2079   int stat;
2080 
2081   if (reqbuf == NULL)
2082     reqbuf = &my_reqbuf;
2083 
2084   memset (&pc, 0, sizeof (pc));
2085   pc.sense_data = reqbuf;
2086 
2087   pc.buffer = buf;
2088   pc.buflen = buflen;
2089 
2090 #if ! STANDARD_ATAPI
2091   if (CDROM_CONFIG_FLAGS (drive)->old_readcd)
2092     pc.c[0] = 0xd4;
2093   else
2094 #endif  /* not STANDARD_ATAPI */
2095     pc.c[0] = READ_CD;
2096 
2097   pc.c[1] = (format << 2);
2098 #ifdef __alpha__
2099   stl_u(htonl (lba), (unsigned int *) &pc.c[2]);
2100 #else
2101   *(int *)(&pc.c[2]) = htonl (lba);
2102 #endif
2103   pc.c[8] = 1;  /* one block */
2104   pc.c[9] = 0x10;
2105 
2106   stat = cdrom_queue_packet_command (drive, &pc);
2107 
2108 #if ! STANDARD_ATAPI
2109   /* If the drive doesn't recognize the READ CD opcode, retry the command
2110      with an older opcode for that command. */
2111   if (stat && reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x20 &&
2112       CDROM_CONFIG_FLAGS (drive)->old_readcd == 0)
2113     {
2114       printk ("%s: Drive does not recognize READ_CD; trying opcode 0xd4\n",
2115               drive->name);
2116       CDROM_CONFIG_FLAGS (drive)->old_readcd = 1;
2117       return cdrom_read_block (drive, format, lba, buf, buflen, reqbuf);
2118     }
2119 #endif  /* not STANDARD_ATAPI */
2120 
2121   return stat;
2122 }
2123 
2124 
2125 int ide_cdrom_ioctl (ide_drive_t *drive, struct inode *inode,
     /*  */
2126                      struct file *file, unsigned int cmd, unsigned long arg)
2127 {
2128   switch (cmd)
2129     {
2130     case CDROMEJECT:
2131       {
2132         int stat;
2133 
2134         if (drive->usage > 1)
2135           return -EBUSY;
2136 
2137         stat = cdrom_lockdoor (drive, 0, NULL);
2138         if (stat) return stat;
2139 
2140         return cdrom_eject (drive, 0, NULL);
2141       }
2142 
2143     case CDROMEJECT_SW:
2144       {
2145         CDROM_STATE_FLAGS (drive)->eject_on_close = arg;
2146         return 0;
2147       }
2148 
2149     case CDROMPAUSE:
2150       return cdrom_pause (drive, 1, NULL);
2151 
2152     case CDROMRESUME:
2153       return cdrom_pause (drive, 0, NULL);
2154 
2155     case CDROMSTART:
2156       return cdrom_startstop (drive, 1, NULL);
2157 
2158     case CDROMSTOP:
2159       {
2160         int stat;
2161 
2162         stat = cdrom_startstop (drive, 0, NULL);
2163         if (stat) return stat;
2164         /* pit says the Dolphin needs this. */
2165         return cdrom_eject (drive, 1, NULL);
2166       }
2167 
2168     case CDROMPLAYMSF:
2169       {
2170         struct cdrom_msf msf;
2171         int stat, lba_start, lba_end;
2172 
2173         stat = verify_area (VERIFY_READ, (void *)arg, sizeof (msf));
2174         if (stat) return stat;
2175 
2176         memcpy_fromfs (&msf, (void *) arg, sizeof(msf));
2177 
2178         lba_start = msf_to_lba (msf.cdmsf_min0, msf.cdmsf_sec0,
2179                                 msf.cdmsf_frame0);
2180         lba_end = msf_to_lba (msf.cdmsf_min1, msf.cdmsf_sec1,
2181                               msf.cdmsf_frame1) + 1;
2182 
2183         if (lba_end <= lba_start) return -EINVAL;
2184 
2185         return cdrom_play_lba_range (drive, lba_start, lba_end, NULL);
2186       }
2187 
2188     /* Like just about every other Linux cdrom driver, we ignore the
2189        index part of the request here. */
2190     case CDROMPLAYTRKIND:
2191       {
2192         int stat, lba_start, lba_end;
2193         struct cdrom_ti ti;
2194         struct atapi_toc_entry *first_toc, *last_toc;
2195 
2196         stat = verify_area (VERIFY_READ, (void *)arg, sizeof (ti));
2197         if (stat) return stat;
2198 
2199         memcpy_fromfs (&ti, (void *) arg, sizeof(ti));
2200 
2201         stat = cdrom_get_toc_entry (drive, ti.cdti_trk0, &first_toc, NULL);
2202         if (stat) return stat;
2203         stat = cdrom_get_toc_entry (drive, ti.cdti_trk1, &last_toc, NULL);
2204         if (stat) return stat;
2205 
2206         if (ti.cdti_trk1 != CDROM_LEADOUT) ++last_toc;
2207         lba_start = first_toc->addr.lba;
2208         lba_end   = last_toc->addr.lba;
2209 
2210         if (lba_end <= lba_start) return -EINVAL;
2211 
2212         return cdrom_play_lba_range (drive, lba_start, lba_end, NULL);
2213       }
2214 
2215     case CDROMREADTOCHDR:
2216       {
2217         int stat;
2218         struct cdrom_tochdr tochdr;
2219         struct atapi_toc *toc;
2220 
2221         stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (tochdr));
2222         if (stat) return stat;
2223 
2224         /* Make sure our saved TOC is valid. */
2225         stat = cdrom_read_toc (drive, NULL);
2226         if (stat) return stat;
2227 
2228         toc = drive->cdrom_info.toc;
2229         tochdr.cdth_trk0 = toc->hdr.first_track;
2230         tochdr.cdth_trk1 = toc->hdr.last_track;
2231 
2232         memcpy_tofs ((void *) arg, &tochdr, sizeof (tochdr));
2233 
2234         return stat;
2235       }
2236 
2237     case CDROMREADTOCENTRY:
2238       {
2239         int stat;
2240         struct cdrom_tocentry tocentry;
2241         struct atapi_toc_entry *toce;
2242 
2243         stat = verify_area (VERIFY_READ, (void *) arg, sizeof (tocentry));
2244         if (stat) return stat;
2245         stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (tocentry));
2246         if (stat) return stat;
2247 
2248         memcpy_fromfs (&tocentry, (void *) arg, sizeof (tocentry));
2249 
2250         stat = cdrom_get_toc_entry (drive, tocentry.cdte_track, &toce, NULL);
2251         if (stat) return stat;
2252 
2253         tocentry.cdte_ctrl = toce->control;
2254         tocentry.cdte_adr  = toce->adr;
2255 
2256         if (tocentry.cdte_format == CDROM_MSF)
2257           {
2258             /* convert to MSF */
2259             lba_to_msf (toce->addr.lba,
2260                         &tocentry.cdte_addr.msf.minute,
2261                         &tocentry.cdte_addr.msf.second,
2262                         &tocentry.cdte_addr.msf.frame);
2263           }
2264         else
2265           tocentry.cdte_addr.lba = toce->addr.lba;
2266 
2267         memcpy_tofs ((void *) arg, &tocentry, sizeof (tocentry));
2268 
2269         return stat;
2270       }
2271 
2272     case CDROMSUBCHNL:
2273       {
2274         struct atapi_cdrom_subchnl scbuf;
2275         int stat, abs_lba, rel_lba;
2276         struct cdrom_subchnl subchnl;
2277 
2278         stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (subchnl));
2279         if (stat) return stat;
2280         stat = verify_area (VERIFY_READ, (void *) arg, sizeof (subchnl));
2281         if (stat) return stat;
2282 
2283         memcpy_fromfs (&subchnl, (void *) arg, sizeof (subchnl));
2284 
2285         stat = cdrom_read_subchannel (drive, (char *)&scbuf, sizeof (scbuf),
2286                                       NULL);
2287         if (stat) return stat;
2288 
2289 #if ! STANDARD_ATAPI
2290         if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
2291           {
2292             abs_lba = msf_to_lba (bcd2bin (scbuf.acdsc_absaddr.msf.minute),
2293                                   bcd2bin (scbuf.acdsc_absaddr.msf.second),
2294                                   bcd2bin (scbuf.acdsc_absaddr.msf.frame));
2295             rel_lba = msf_to_lba (bcd2bin (scbuf.acdsc_reladdr.msf.minute),
2296                                   bcd2bin (scbuf.acdsc_reladdr.msf.second),
2297                                   bcd2bin (scbuf.acdsc_reladdr.msf.frame));
2298             scbuf.acdsc_trk = bcd2bin (scbuf.acdsc_trk);
2299           }
2300         else
2301 #endif /* not STANDARD_ATAPI */
2302           {
2303             abs_lba = ntohl (scbuf.acdsc_absaddr.lba);
2304             rel_lba = ntohl (scbuf.acdsc_reladdr.lba);
2305           }
2306 
2307         if (subchnl.cdsc_format == CDROM_MSF)
2308           {
2309             lba_to_msf (abs_lba,
2310                         &subchnl.cdsc_absaddr.msf.minute,
2311                         &subchnl.cdsc_absaddr.msf.second,
2312                         &subchnl.cdsc_absaddr.msf.frame);
2313             lba_to_msf (rel_lba,
2314                         &subchnl.cdsc_reladdr.msf.minute,
2315                         &subchnl.cdsc_reladdr.msf.second,
2316                         &subchnl.cdsc_reladdr.msf.frame);
2317           }
2318         else
2319           {
2320             subchnl.cdsc_absaddr.lba = abs_lba;
2321             subchnl.cdsc_reladdr.lba = rel_lba;
2322           }
2323 
2324         subchnl.cdsc_audiostatus = scbuf.acdsc_audiostatus;
2325         subchnl.cdsc_ctrl = scbuf.acdsc_ctrl;
2326         subchnl.cdsc_trk  = scbuf.acdsc_trk;
2327         subchnl.cdsc_ind  = scbuf.acdsc_ind;
2328 
2329         memcpy_tofs ((void *) arg, &subchnl, sizeof (subchnl));
2330 
2331         return stat;
2332       }
2333 
2334     case CDROMVOLCTRL:
2335       {
2336         struct cdrom_volctrl volctrl;
2337         char buffer[24], mask[24];
2338         int stat;
2339 
2340         stat = verify_area (VERIFY_READ, (void *) arg, sizeof (volctrl));
2341         if (stat) return stat;
2342         memcpy_fromfs (&volctrl, (void *) arg, sizeof (volctrl));
2343 
2344         stat = cdrom_mode_sense (drive, 0x0e, 0, buffer, sizeof (buffer),NULL);
2345         if (stat) return stat;
2346         stat = cdrom_mode_sense (drive, 0x0e, 1, mask  , sizeof (buffer),NULL);
2347         if (stat) return stat;
2348 
2349         buffer[1] = buffer[2] = 0;
2350 
2351         buffer[17] = volctrl.channel0 & mask[17];
2352         buffer[19] = volctrl.channel1 & mask[19];
2353         buffer[21] = volctrl.channel2 & mask[21];
2354         buffer[23] = volctrl.channel3 & mask[23];
2355 
2356         return cdrom_mode_select (drive, 0x0e, buffer, sizeof (buffer), NULL);
2357       }
2358 
2359     case CDROMVOLREAD:
2360       {
2361         struct cdrom_volctrl volctrl;
2362         char buffer[24];
2363         int stat;
2364 
2365         stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (volctrl));
2366         if (stat) return stat;
2367 
2368         stat = cdrom_mode_sense (drive, 0x0e, 0, buffer, sizeof (buffer), NULL);
2369         if (stat) return stat;
2370 
2371         volctrl.channel0 = buffer[17];
2372         volctrl.channel1 = buffer[19];
2373         volctrl.channel2 = buffer[21];
2374         volctrl.channel3 = buffer[23];
2375 
2376         memcpy_tofs ((void *) arg, &volctrl, sizeof (volctrl));
2377 
2378         return 0;
2379       }
2380 
2381     case CDROMMULTISESSION:
2382       {
2383         struct cdrom_multisession ms_info;
2384         struct atapi_toc *toc;
2385         int stat;
2386 
2387         stat = verify_area (VERIFY_READ,  (void *)arg, sizeof (ms_info));
2388         if (stat) return stat;
2389         stat = verify_area (VERIFY_WRITE, (void *)arg, sizeof (ms_info));
2390         if (stat) return stat;
2391 
2392         memcpy_fromfs (&ms_info, (void *)arg, sizeof (ms_info));
2393 
2394         /* Make sure the TOC information is valid. */
2395         stat = cdrom_read_toc (drive, NULL);
2396         if (stat) return stat;
2397 
2398         toc = drive->cdrom_info.toc;
2399 
2400         if (ms_info.addr_format == CDROM_MSF)
2401           lba_to_msf (toc->last_session_lba,
2402                       &ms_info.addr.msf.minute,
2403                       &ms_info.addr.msf.second,
2404                       &ms_info.addr.msf.frame);
2405 
2406         else if (ms_info.addr_format == CDROM_LBA)
2407           ms_info.addr.lba = toc->last_session_lba;
2408 
2409         else
2410           return -EINVAL;
2411 
2412         ms_info.xa_flag = toc->xa_flag;
2413 
2414         memcpy_tofs ((void *)arg, &ms_info, sizeof (ms_info));
2415 
2416         return 0;
2417       }
2418 
2419     /* Read 2352 byte blocks from audio tracks. */
2420     case CDROMREADAUDIO:
2421       {
2422         int stat, lba;
2423         struct atapi_toc *toc;
2424         struct cdrom_read_audio ra;
2425         char buf[CD_FRAMESIZE_RAW];
2426 
2427         /* Make sure the TOC is up to date. */
2428         stat = cdrom_read_toc (drive, NULL);
2429         if (stat) return stat;
2430 
2431         toc = drive->cdrom_info.toc;
2432 
2433         stat = verify_area (VERIFY_READ, (char *)arg, sizeof (ra));
2434         if (stat) return stat;
2435 
2436         memcpy_fromfs (&ra, (void *)arg, sizeof (ra));
2437 
2438         if (ra.nframes < 0 || ra.nframes > toc->capacity)
2439           return -EINVAL;
2440         else if (ra.nframes == 0)
2441           return 0;
2442 
2443         stat = verify_area (VERIFY_WRITE, (char *)ra.buf,
2444                                           ra.nframes * CD_FRAMESIZE_RAW);
2445         if (stat) return stat;
2446 
2447         if (ra.addr_format == CDROM_MSF)
2448           lba = msf_to_lba (ra.addr.msf.minute, ra.addr.msf.second,
2449                             ra.addr.msf.frame);
2450         
2451         else if (ra.addr_format == CDROM_LBA)
2452           lba = ra.addr.lba;
2453 
2454         else
2455           return -EINVAL;
2456 
2457         if (lba < 0 || lba >= toc->capacity)
2458           return -EINVAL;
2459 
2460         while (ra.nframes > 0)
2461           {
2462             stat = cdrom_read_block (drive, 1, lba, buf,
2463                                      CD_FRAMESIZE_RAW, NULL);
2464             if (stat) return stat;
2465             memcpy_tofs (ra.buf, buf, CD_FRAMESIZE_RAW);
2466             ra.buf += CD_FRAMESIZE_RAW;
2467             --ra.nframes;
2468             ++lba;
2469           }
2470 
2471         return 0;
2472       }
2473 
2474     case CDROMREADMODE1:
2475     case CDROMREADMODE2:
2476       {
2477         struct cdrom_msf msf;
2478         int blocksize, format, stat, lba;
2479         struct atapi_toc *toc;
2480         char buf[CD_FRAMESIZE_RAW0];
2481 
2482         if (cmd == CDROMREADMODE1)
2483           {
2484             blocksize = CD_FRAMESIZE;
2485             format = 2;
2486           }
2487         else
2488           {
2489             blocksize = CD_FRAMESIZE_RAW0;
2490             format = 3;
2491           }
2492 
2493         stat = verify_area (VERIFY_READ, (char *)arg, sizeof (msf));
2494         if (stat) return stat;
2495         stat = verify_area (VERIFY_WRITE, (char *)arg, blocksize);
2496         if (stat) return stat;
2497 
2498         memcpy_fromfs (&msf, (void *)arg, sizeof (msf));
2499 
2500         lba = msf_to_lba (msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2501         
2502         /* Make sure the TOC is up to date. */
2503         stat = cdrom_read_toc (drive, NULL);
2504         if (stat) return stat;
2505 
2506         toc = drive->cdrom_info.toc;
2507 
2508         if (lba < 0 || lba >= toc->capacity)
2509           return -EINVAL;
2510 
2511         stat = cdrom_read_block (drive, format, lba, buf, blocksize, NULL);
2512         if (stat) return stat;
2513 
2514         memcpy_tofs ((char *)arg, buf, blocksize);
2515         return 0;
2516       }
2517 
2518 #if 0 /* Doesn't work reliably yet. */
2519     case CDROMRESET:
2520       {
2521         struct request req;
2522         ide_init_drive_cmd (&req);
2523         req.cmd = RESET_DRIVE_COMMAND;
2524         return ide_do_drive_cmd (drive, &req, ide_wait);
2525       }
2526 #endif
2527 
2528  
2529 #ifdef TEST
2530     case 0x1234:
2531       {
2532         int stat;
2533         struct packet_command pc;
2534         int len, lena;
2535 
2536         memset (&pc, 0, sizeof (pc));
2537 
2538         stat = verify_area (VERIFY_READ, (void *) arg, sizeof (pc.c));
2539         if (stat) return stat;
2540         memcpy_fromfs (&pc.c, (void *) arg, sizeof (pc.c));
2541         arg += sizeof (pc.c);
2542 
2543         stat = verify_area (VERIFY_READ, (void *) arg, sizeof (len));
2544         if (stat) return stat;
2545         memcpy_fromfs (&len, (void *) arg , sizeof (len));
2546         arg += sizeof (len);
2547 
2548         if (len > 0) {
2549           stat = verify_area (VERIFY_WRITE, (void *) arg, len);
2550           if (stat) return stat;
2551         }
2552 
2553         lena = len;
2554         if (lena  < 0) lena = 0;
2555 
2556         {
2557           char buf[lena];
2558           if (len > 0) {
2559             pc.buflen = len;
2560             pc.buffer = buf;
2561           }
2562 
2563           stat = cdrom_queue_packet_command (drive, &pc);
2564 
2565           if (len > 0)
2566             memcpy_tofs ((void *)arg, buf, len);
2567         }
2568 
2569         return stat;
2570       }
2571 #endif
2572 
2573     default:
2574       return -EPERM;
2575     }
2576 
2577 }
2578 
2579 
2580 
2581 /****************************************************************************
2582  * Other driver requests (open, close, check media change).
2583  */
2584 
2585 int ide_cdrom_check_media_change (ide_drive_t *drive)
     /*  */
2586 {
2587   int retval;
2588 
2589   (void) cdrom_check_status (drive, NULL);
2590 
2591   retval = CDROM_STATE_FLAGS (drive)->media_changed;
2592   CDROM_STATE_FLAGS (drive)->media_changed = 0;
2593 
2594   return retval;
2595 }
2596 
2597 
2598 int ide_cdrom_open (struct inode *ip, struct file *fp, ide_drive_t *drive)
     /*  */
2599 {
2600   /* no write access */
2601   if (fp->f_mode & 2)
2602     {
2603       --drive->usage;
2604       return -EROFS;
2605     }
2606 
2607   /* If this is the first open, check the drive status. */
2608   if (drive->usage == 1)
2609     {
2610       int stat;
2611       struct atapi_request_sense my_reqbuf;
2612       my_reqbuf.sense_key = 0;
2613 
2614       /* Get the drive status. */
2615       stat = cdrom_check_status (drive, &my_reqbuf);
2616 
2617       /* If the tray is open, try to close it. */
2618       if (stat && my_reqbuf.sense_key == NOT_READY)
2619         {
2620           cdrom_eject (drive, 1, &my_reqbuf);
2621           stat = cdrom_check_status (drive, &my_reqbuf);
2622         }
2623 
2624       /* Return an error if there are still problems. */
2625       if (stat && my_reqbuf.sense_key != UNIT_ATTENTION)
2626         {
2627           --drive->usage;
2628           return -ENXIO;
2629         }
2630 
2631       /* Now lock the door. */
2632       (void) cdrom_lockdoor (drive, 1, &my_reqbuf);
2633 
2634       /* And try to read the TOC information now. */
2635       (void) cdrom_read_toc (drive, &my_reqbuf);
2636     }
2637 
2638   return 0;
2639 }
2640 
2641 
2642 /*
2643  * Close down the device.  Invalidate all cached blocks.
2644  */
2645 
2646 void ide_cdrom_release (struct inode *inode, struct file *file, ide_drive_t *drive)
     /*  */
2647 {
2648   if (drive->usage == 0)
2649     {
2650       invalidate_buffers (inode->i_rdev);
2651 
2652       /* Unlock the door. */
2653       (void) cdrom_lockdoor (drive, 0, NULL);
2654 
2655       /* Do an eject if we were requested to do so. */
2656       if (CDROM_STATE_FLAGS (drive)->eject_on_close)
2657         (void) cdrom_eject (drive, 0, NULL);
2658     }
2659 }
2660 
2661 
2662 
2663 /****************************************************************************
2664  * Device initialization.
2665  */
2666 
2667 void ide_cdrom_setup (ide_drive_t *drive)
     /*  */
2668 {
2669   blksize_size[HWIF(drive)->major][drive->select.b.unit << PARTN_BITS] = CD_FRAMESIZE;
2670 
2671   drive->special.all = 0;
2672   drive->ready_stat = 0;
2673 
2674   CDROM_STATE_FLAGS (drive)->media_changed = 0;
2675   CDROM_STATE_FLAGS (drive)->toc_valid     = 0;
2676   CDROM_STATE_FLAGS (drive)->door_locked   = 0;
2677 
2678   /* Turn this off by default, since many people don't like it. */
2679   CDROM_STATE_FLAGS (drive)->eject_on_close= 0;
2680 
2681 #if NO_DOOR_LOCKING
2682   CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
2683 #else
2684   CDROM_CONFIG_FLAGS (drive)->no_doorlock = 0;
2685 #endif
2686 
2687   if (drive->id != NULL) {
2688     CDROM_CONFIG_FLAGS (drive)->drq_interrupt =
2689       ((drive->id->config & 0x0060) == 0x20);
2690   } else {
2691     CDROM_CONFIG_FLAGS (drive)->drq_interrupt = 0;
2692   }
2693 
2694 #if ! STANDARD_ATAPI
2695   CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 0;
2696   CDROM_CONFIG_FLAGS (drive)->old_readcd = 0;
2697   CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 0;
2698   CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd = 0;
2699   CDROM_CONFIG_FLAGS (drive)->vertos_lossage = 0;
2700 
2701   if (drive->id != NULL) {
2702     /* Accommodate some broken drives... */
2703     if (strcmp (drive->id->model, "CD220E") == 0 ||
2704         strcmp (drive->id->model, "CD")     == 0)        /* Creative Labs */
2705       CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2706 
2707     else if (strcmp (drive->id->model, "TO-ICSLYAL") == 0 ||  /* Acer CD525E */
2708              strcmp (drive->id->model, "OTI-SCYLLA") == 0)
2709       CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2710 
2711     /* I don't know who makes this.
2712        Francesco Messineo <sidera@ccii.unipi.it> says this one's broken too. */
2713     else if (strcmp (drive->id->model, "DCI-2S10") == 0)
2714       CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2715 
2716     else if (strcmp (drive->id->model, "CDA26803I SE") == 0) /* Aztech */
2717       {
2718         CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2719 
2720         /* This drive _also_ does not implement PLAYAUDIO12 correctly. */
2721         CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
2722       }
2723 
2724     /* Vertos 300. */
2725     else if (strcmp (drive->id->model, "V003S0DS") == 0)
2726       {
2727         CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2728 
2729         /* Some versions of this drive like to talk BCD. */
2730         if (drive->id->fw_rev[4] == '1' &&
2731             drive->id->fw_rev[6] <= '2')
2732           {
2733             CDROM_CONFIG_FLAGS (drive)->vertos_lossage = 1;
2734             CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd = 1;
2735           }
2736       }
2737     else if (strcmp (drive->id->model, "0V300SSD") == 0 ||
2738              strcmp (drive->id->model, "V003M0DP") == 0 ||
2739              strcmp (drive->id->model, "0V300MPD") == 0 ||
2740              strcmp (drive->id->model, "0V300HPD") == 0 ||
2741              strcmp (drive->id->model, "V003H0DP") == 0)
2742       CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2743 
2744     /* Vertos 400. */
2745     else if (strcmp (drive->id->model, "V004E0DT") == 0 ||
2746              strcmp (drive->id->model, "0V400ETD") == 0 ||
2747              strcmp (drive->id->model, "V004H0DT") == 0 ||
2748              strcmp (drive->id->model, "0V400HTD") == 0)
2749       CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2750 
2751     else if ( strcmp (drive->id->model, "CD-ROM CDU55D") == 0) /*sony cdu55d */
2752       CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
2753 
2754    else if (strcmp (drive->id->model, "CD-ROM CDU55E") == 0)
2755         CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
2756   } /* drive-id != NULL */
2757 #endif  /* not STANDARD_ATAPI */
2758 
2759   drive->cdrom_info.toc               = NULL;
2760   drive->cdrom_info.sector_buffer     = NULL;
2761   drive->cdrom_info.sector_buffered   = 0;
2762   drive->cdrom_info.nsectors_buffered = 0;
2763 }
2764 
2765 
2766 
2767 /*
2768  * TODO:
2769  *  CDROM_GET_UPC
2770  *  CDROMRESET
2771  *  Lock the door when a read request completes successfully and the
2772  *   door is not already locked.  Also try to reorganize to reduce
2773  *   duplicated functionality between read and ioctl paths?
2774  *  Establish interfaces for an IDE port driver, and break out the cdrom
2775  *   code into a loadable module.
2776  *  Support changers.
2777  *  Write some real documentation.
2778  */
/* */
root/drivers/block/ide-cd.c

DEFINITIONS
