/*
* linux/drivers/ide/ide-cd.c
*
* Copyright (C) 1994, 1995, 1996 scott snyder <snyder@fnald0.fnal.gov>
* Copyright (C) 1996-1998 Erik Andersen <andersee@debian.org>
* Copyright (C) 1998-2000 Jens Axboe <axboe@suse.de>
*
* May be copied or modified under the terms of the GNU General Public
* License. See linux/COPYING for more information.
*
* ATAPI CD-ROM driver. To be used with ide.c.
* See Documentation/cdrom/ide-cd for usage information.
*
* Suggestions are welcome. Patches that work are more welcome though. ;-)
* For those wishing to work on this driver, please be sure you download
* and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
* (SFF-8020i rev 2.6) standards. These documents can be obtained by
* anonymous ftp from:
* ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
* ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
*
* Drives that deviate from these standards will be accomodated as much
* as possible via compile time or command-line options. Since I only have
* a few drives, you generally need to send me patches...
*
* ----------------------------------
* TO DO LIST:
* -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
* boot
*
* ----------------------------------
* 1.00 Oct 31, 1994 -- Initial version.
* 1.01 Nov 2, 1994 -- Fixed problem with starting request in
* cdrom_check_status.
* 1.03 Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
* (from mlord) -- minor changes to cdrom_setup()
* -- renamed ide_dev_s to ide_drive_t, enable irq on command
* 2.00 Nov 27, 1994 -- Generalize packet command interface;
* add audio ioctls.
* 2.01 Dec 3, 1994 -- Rework packet command interface to handle devices
* which send an interrupt when ready for a command.
* 2.02 Dec 11, 1994 -- Cache the TOC in the driver.
* Don't use SCMD_PLAYAUDIO_TI; it's not included
* in the current version of ATAPI.
* Try to use LBA instead of track or MSF addressing
* when possible.
* Don't wait for READY_STAT.
* 2.03 Jan 10, 1995 -- Rewrite block read routines to handle block sizes
* other than 2k and to move multiple sectors in a
* single transaction.
* 2.04 Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
* Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
* help in figuring this out. Ditto for Acer and
* Aztech drives, which seem to have the same problem.
* 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
* 2.05 Jun 8, 1995 -- Don't attempt to retry after an illegal request
* or data protect error.
* Use HWIF and DEV_HWIF macros as in ide.c.
* Always try to do a request_sense after
* a failed command.
* Include an option to give textual descriptions
* of ATAPI errors.
* Fix a bug in handling the sector cache which
* showed up if the drive returned data in 512 byte
* blocks (like Pioneer drives). Thanks to
* Richard Hirst <srh@gpt.co.uk> for diagnosing this.
* Properly supply the page number field in the
* MODE_SELECT command.
* PLAYAUDIO12 is broken on the Aztech; work around it.
* 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
* (my apologies to Scott, but now ide-cd.c is independent)
* 3.00 Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
* Implement CDROMREADAUDIO ioctl (UNTESTED).
* Use input_ide_data() and output_ide_data().
* Add door locking.
* Fix usage count leak in cdrom_open, which happened
* when a read-write mount was attempted.
* Try to load the disk on open.
* Implement CDROMEJECT_SW ioctl (off by default).
* Read total cdrom capacity during open.
* Rearrange logic in cdrom_decode_status. Issue
* request sense commands for failed packet commands
* from here instead of from cdrom_queue_packet_command.
* Fix a race condition in retrieving error information.
* Suppress printing normal unit attention errors and
* some drive not ready errors.
* Implement CDROMVOLREAD ioctl.
* Implement CDROMREADMODE1/2 ioctls.
* Fix race condition in setting up interrupt handlers
* when the `serialize' option is used.
* 3.01 Sep 2, 1995 -- Fix ordering of reenabling interrupts in
* cdrom_queue_request.
* Another try at using ide_[input,output]_data.
* 3.02 Sep 16, 1995 -- Stick total disk capacity in partition table as well.
* Make VERBOSE_IDE_CD_ERRORS dump failed command again.
* Dump out more information for ILLEGAL REQUEST errs.
* Fix handling of errors occurring before the
* packet command is transferred.
* Fix transfers with odd bytelengths.
* 3.03 Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
* `DCI-2S10' drives are broken too.
* 3.04 Nov 20, 1995 -- So are Vertos drives.
* 3.05 Dec 1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
* 3.06 Dec 16, 1995 -- Add support needed for partitions.
* More workarounds for Vertos bugs (based on patches
* from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
* Try to eliminate byteorder assumptions.
* Use atapi_cdrom_subchnl struct definition.
* Add STANDARD_ATAPI compilation option.
* 3.07 Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
* Vertos 300.
* Add NO_DOOR_LOCKING configuration option.
* Handle drive_cmd requests w/NULL args (for hdparm -t).
* Work around sporadic Sony55e audio play problem.
* 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
* problem with "hde=cdrom" with no drive present. -ml
* 3.08 Mar 6, 1996 -- More Vertos workarounds.
* 3.09 Apr 5, 1996 -- Add CDROMCLOSETRAY ioctl.
* Switch to using MSF addressing for audio commands.
* Reformat to match kernel tabbing style.
* Add CDROM_GET_UPC ioctl.
* 3.10 Apr 10, 1996 -- Fix compilation error with STANDARD_ATAPI.
* 3.11 Apr 29, 1996 -- Patch from Heiko Eissfeldt <heiko@colossus.escape.de>
* to remove redundant verify_area calls.
* 3.12 May 7, 1996 -- Rudimentary changer support. Based on patches
* from Gerhard Zuber <zuber@berlin.snafu.de>.
* Let open succeed even if there's no loaded disc.
* 3.13 May 19, 1996 -- Fixes for changer code.
* 3.14 May 29, 1996 -- Add work-around for Vertos 600.
* (From Hennus Bergman <hennus@sky.ow.nl>.)
* 3.15 July 2, 1996 -- Added support for Sanyo 3 CD changers
* from Ben Galliart <bgallia@luc.edu> with
* special help from Jeff Lightfoot
* <jeffml@pobox.com>
* 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
* 3.16 Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
* 3.17 Sep 17, 1996 -- Tweak audio reads for some drives.
* Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
* 3.18 Oct 31, 1996 -- Added module and DMA support.
*
*
* 4.00 Nov 5, 1996 -- New ide-cd maintainer,
* Erik B. Andersen <andersee@debian.org>
* -- Newer Creative drives don't always set the error
* register correctly. Make sure we see media changes
* regardless.
* -- Integrate with generic cdrom driver.
* -- CDROMGETSPINDOWN and CDROMSETSPINDOWN ioctls, based on
* a patch from Ciro Cattuto <>.
* -- Call set_device_ro.
* -- Implement CDROMMECHANISMSTATUS and CDROMSLOTTABLE
* ioctls, based on patch by Erik Andersen
* -- Add some probes of drive capability during setup.
*
* 4.01 Nov 11, 1996 -- Split into ide-cd.c and ide-cd.h
* -- Removed CDROMMECHANISMSTATUS and CDROMSLOTTABLE
* ioctls in favor of a generalized approach
* using the generic cdrom driver.
* -- Fully integrated with the 2.1.X kernel.
* -- Other stuff that I forgot (lots of changes)
*
* 4.02 Dec 01, 1996 -- Applied patch from Gadi Oxman <gadio@netvision.net.il>
* to fix the drive door locking problems.
*
* 4.03 Dec 04, 1996 -- Added DSC overlap support.
* 4.04 Dec 29, 1996 -- Added CDROMREADRAW ioclt based on patch
* by Ales Makarov (xmakarov@sun.felk.cvut.cz)
*
* 4.05 Nov 20, 1997 -- Modified to print more drive info on init
* Minor other changes
* Fix errors on CDROMSTOP (If you have a "Dolphin",
* you must define IHAVEADOLPHIN)
* Added identifier so new Sanyo CD-changer works
* Better detection if door locking isn't supported
*
* 4.06 Dec 17, 1997 -- fixed endless "tray open" messages -ml
* 4.07 Dec 17, 1997 -- fallback to set pc->stat on "tray open"
* 4.08 Dec 18, 1997 -- spew less noise when tray is empty
* -- fix speed display for ACER 24X, 18X
* 4.09 Jan 04, 1998 -- fix handling of the last block so we return
* an end of file instead of an I/O error (Gadi)
* 4.10 Jan 24, 1998 -- fixed a bug so now changers can change to a new
* slot when there is no disc in the current slot.
* -- Fixed a memory leak where info->changer_info was
* malloc'ed but never free'd when closing the device.
* -- Cleaned up the global namespace a bit by making more
* functions static that should already have been.
* 4.11 Mar 12, 1998 -- Added support for the CDROM_SELECT_SPEED ioctl
* based on a patch for 2.0.33 by Jelle Foks
* <jelle@scintilla.utwente.nl>, a patch for 2.0.33
* by Toni Giorgino <toni@pcape2.pi.infn.it>, the SCSI
* version, and my own efforts. -erik
* -- Fixed a stupid bug which egcs was kind enough to
* inform me of where "Illegal mode for this track"
* was never returned due to a comparison on data
* types of limited range.
* 4.12 Mar 29, 1998 -- Fixed bug in CDROM_SELECT_SPEED so write speed is
* now set ionly for CD-R and CD-RW drives. I had
* removed this support because it produced errors.
* It produced errors _only_ for non-writers. duh.
* 4.13 May 05, 1998 -- Suppress useless "in progress of becoming ready"
* messages, since this is not an error.
* -- Change error messages to be const
* -- Remove a "\t" which looks ugly in the syslogs
* 4.14 July 17, 1998 -- Change to pointing to .ps version of ATAPI spec
* since the .pdf version doesn't seem to work...
* -- Updated the TODO list to something more current.
*
* 4.15 Aug 25, 1998 -- Updated ide-cd.h to respect mechine endianess,
* patch thanks to "Eddie C. Dost" <ecd@skynet.be>
*
* 4.50 Oct 19, 1998 -- New maintainers!
* Jens Axboe <axboe@image.dk>
* Chris Zwilling <chris@cloudnet.com>
*
* 4.51 Dec 23, 1998 -- Jens Axboe <axboe@image.dk>
* - ide_cdrom_reset enabled since the ide subsystem
* handles resets fine now. <axboe@image.dk>
* - Transfer size fix for Samsung CD-ROMs, thanks to
* "Ville Hallik" <ville.hallik@mail.ee>.
* - other minor stuff.
*
* 4.52 Jan 19, 1999 -- Jens Axboe <axboe@image.dk>
* - Detect DVD-ROM/RAM drives
*
* 4.53 Feb 22, 1999 - Include other model Samsung and one Goldstar
* drive in transfer size limit.
* - Fix the I/O error when doing eject without a medium
* loaded on some drives.
* - CDROMREADMODE2 is now implemented through
* CDROMREADRAW, since many drives don't support
* MODE2 (even though ATAPI 2.6 says they must).
* - Added ignore parameter to ide-cd (as a module), eg
* insmod ide-cd ignore='hda hdb'
* Useful when using ide-cd in conjunction with
* ide-scsi. TODO: non-modular way of doing the
* same.
*
* 4.54 Aug 5, 1999 - Support for MMC2 class commands through the generic
* packet interface to cdrom.c.
* - Unified audio ioctl support, most of it.
* - cleaned up various deprecated verify_area().
* - Added ide_cdrom_packet() as the interface for
* the Uniform generic_packet().
* - bunch of other stuff, will fill in logs later.
* - report 1 slot for non-changers, like the other
* cd-rom drivers. don't report select disc for
* non-changers as well.
* - mask out audio playing, if the device can't do it.
*
* 4.55 Sep 1, 1999 - Eliminated the rest of the audio ioctls, except
* for CDROMREADTOC[ENTRY|HEADER]. Some of the drivers
* use this independently of the actual audio handling.
* They will disappear later when I get the time to
* do it cleanly.
* - Minimize the TOC reading - only do it when we
* know a media change has occured.
* - Moved all the CDROMREADx ioctls to the Uniform layer.
* - Heiko Eissfeldt <heiko@colossus.escape.de> supplied
* some fixes for CDI.
* - CD-ROM leaving door locked fix from Andries
* Brouwer <Andries.Brouwer@cwi.nl>
* - Erik Andersen <andersen@xmission.com> unified
* commands across the various drivers and how
* sense errors are handled.
*
* 4.56 Sep 12, 1999 - Removed changer support - it is now in the
* Uniform layer.
* - Added partition based multisession handling.
* - Mode sense and mode select moved to the
* Uniform layer.
* - Fixed a problem with WPI CDS-32X drive - it
* failed the capabilities
*
* 4.57 Apr 7, 2000 - Fixed sense reporting.
* - Fixed possible oops in ide_cdrom_get_last_session()
* - Fix locking mania and make ide_cdrom_reset relock
* - Stop spewing errors to log when magicdev polls with
* TEST_UNIT_READY on some drives.
* - Various fixes from Tobias Ringstrom:
* tray if it was locked prior to the reset.
* - cdrom_read_capacity returns one frame too little.
* - Fix real capacity reporting.
*
* 4.58 May 1, 2000 - Clean up ACER50 stuff.
* - Fix small problem with ide_cdrom_capacity
*
* 4.59 Aug 11, 2000 - Fix changer problem in cdrom_read_toc, we weren't
* correctly sensing a disc change.
* - Rearranged some code
*
*************************************************************************/
#define IDECD_VERSION "4.59"
#include <linux/config.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/malloc.h>
#include <linux/interrupt.h>
#include <linux/errno.h>
#include <linux/cdrom.h>
#include <linux/ide.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/byteorder.h>
#include <asm/uaccess.h>
#include <asm/unaligned.h>
#include "ide-cd.h"
/****************************************************************************
* Generic packet command support and error handling routines.
*/
/* Mark that we've seen a media change, and invalidate our internal
buffers. */
322 static void cdrom_saw_media_change (ide_drive_t *drive)
{
struct cdrom_info *info = drive->driver_data;
CDROM_STATE_FLAGS (drive)->media_changed = 1;
CDROM_STATE_FLAGS (drive)->toc_valid = 0;
info->nsectors_buffered = 0;
}
331 static int cdrom_log_sense(ide_drive_t *drive, struct packet_command *pc,
struct request_sense *sense)
{
int log = 0;
336 if (sense == NULL || pc == NULL || pc->quiet)
337 return 0;
339 switch (sense->sense_key) {
340 case NO_SENSE: case RECOVERED_ERROR:
341 break;
342 case NOT_READY:
/*
* don't care about tray state messages for
* e.g. capacity commands or in-progress or
* becoming ready
*/
348 if (sense->asc == 0x3a || sense->asc == 0x04)
349 break;
log = 1;
351 break;
352 case UNIT_ATTENTION:
/*
* Make good and sure we've seen this potential media
* change. Some drives (i.e. Creative) fail to present
* the correct sense key in the error register.
*/
cdrom_saw_media_change(drive);
359 break;
360 default:
log = 1;
362 break;
}
364 return log;
}
static
368 void cdrom_analyze_sense_data(ide_drive_t *drive,
struct packet_command *failed_command,
struct request_sense *sense)
{
373 if (!cdrom_log_sense(drive, failed_command, sense))
374 return;
/*
* If a read toc is executed for a CD-R or CD-RW medium where
* the first toc has not been recorded yet, it will fail with
* 05/24/00 (which is a confusing error)
*/
381 if (failed_command && failed_command->c[0] == GPCMD_READ_TOC_PMA_ATIP)
382 if (sense->sense_key == 0x05 && sense->asc == 0x24)
383 return;
#if VERBOSE_IDE_CD_ERRORS
{
int i;
const char *s;
char buf[80];
printk ("ATAPI device %s:\n", drive->name);
392 if (sense->error_code==0x70)
printk(" Error: ");
394 else if (sense->error_code==0x71)
printk(" Deferred Error: ");
396 else if (sense->error_code == 0x7f)
printk(" Vendor-specific Error: ");
398 else
printk(" Unknown Error Type: ");
401 if (sense->sense_key < ARY_LEN(sense_key_texts))
s = sense_key_texts[sense->sense_key];
403 else
s = "bad sense key!";
printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
408 if (sense->asc == 0x40) {
sprintf(buf, "Diagnostic failure on component 0x%02x",
sense->ascq);
s = buf;
412 } else {
int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
unsigned long key = (sense->sense_key << 16);
key |= (sense->asc << 8);
416 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
key |= sense->ascq;
s = NULL;
420 while (hi > lo) {
mid = (lo + hi) / 2;
if (sense_data_texts[mid].asc_ascq == key ||
423 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
s = sense_data_texts[mid].text;
425 break;
}
427 else if (sense_data_texts[mid].asc_ascq > key)
hi = mid;
429 else
lo = mid+1;
}
}
434 if (s == NULL) {
435 if (sense->asc > 0x80)
s = "(vendor-specific error)";
437 else
s = "(reserved error code)";
}
printk(" %s -- (asc=0x%02x, ascq=0x%02x)\n",
s, sense->asc, sense->ascq);
444 if (failed_command != NULL) {
int lo=0, mid, hi= ARY_LEN (packet_command_texts);
s = NULL;
449 while (hi > lo) {
mid = (lo + hi) / 2;
if (packet_command_texts[mid].packet_command ==
452 failed_command->c[0]) {
s = packet_command_texts[mid].text;
454 break;
}
if (packet_command_texts[mid].packet_command >
457 failed_command->c[0])
hi = mid;
459 else
lo = mid+1;
}
printk (" The failed \"%s\" packet command was: \n \"", s);
464 for (i=0; i<sizeof (failed_command->c); i++)
printk ("%02x ", failed_command->c[i]);
printk ("\"\n");
}
/* The SKSV bit specifies validity of the sense_key_specific
* in the next two commands. It is bit 7 of the first byte.
* In the case of NOT_READY, if SKSV is set the drive can
* give us nice ETA readings.
*/
474 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
printk(" Command is %02d%% complete\n", progress / 0xffff);
}
if (sense->sense_key == ILLEGAL_REQUEST &&
481 (sense->sks[0] & 0x80) != 0) {
printk(" Error in %s byte %d",
(sense->sks[0] & 0x40) != 0 ?
"command packet" : "command data",
(sense->sks[1] << 8) + sense->sks[2]);
487 if ((sense->sks[0] & 0x40) != 0)
printk (" bit %d", sense->sks[0] & 0x07);
printk ("\n");
}
}
#else /* not VERBOSE_IDE_CD_ERRORS */
/* Suppress printing unit attention and `in progress of becoming ready'
errors when we're not being verbose. */
if (sense->sense_key == UNIT_ATTENTION ||
(sense->sense_key == NOT_READY && (sense->asc == 4 ||
sense->asc == 0x3a)))
return;
printk("%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
drive->name,
sense->error_code, sense->sense_key,
sense->asc, sense->ascq);
#endif /* not VERBOSE_IDE_CD_ERRORS */
}
511 static void cdrom_queue_request_sense(ide_drive_t *drive,
struct semaphore *sem,
struct request_sense *sense,
struct packet_command *failed_command)
{
struct cdrom_info *info = drive->driver_data;
struct packet_command *pc = &info->request_sense_pc;
struct request *rq;
520 if (sense == NULL)
sense = &info->sense_data;
memset(pc, 0, sizeof(struct packet_command));
pc->c[0] = GPCMD_REQUEST_SENSE;
pc->c[4] = pc->buflen = 18;
pc->buffer = (char *) sense;
pc->sense = (struct request_sense *) failed_command;
/* stuff the sense request in front of our current request */
rq = &info->request_sense_request;
ide_init_drive_cmd(rq);
rq->cmd = REQUEST_SENSE_COMMAND;
rq->buffer = (char *) pc;
rq->sem = sem;
(void) ide_do_drive_cmd(drive, rq, ide_preempt);
}
539 static void cdrom_end_request (int uptodate, ide_drive_t *drive)
{
struct request *rq = HWGROUP(drive)->rq;
543 if (rq->cmd == REQUEST_SENSE_COMMAND && uptodate) {
struct packet_command *pc = (struct packet_command *) rq->buffer;
cdrom_analyze_sense_data(drive,
(struct packet_command *) pc->sense,
(struct request_sense *) (pc->buffer - pc->c[4]));
}
549 if (rq->cmd == READ || rq->cmd == WRITE)
550 if (!rq->current_nr_sectors)
uptodate = 1;
ide_end_request (uptodate, HWGROUP(drive));
}
/* Returns 0 if the request should be continued.
Returns 1 if the request was ended. */
559 static int cdrom_decode_status (ide_startstop_t *startstop, ide_drive_t *drive,
int good_stat, int *stat_ret)
{
struct request *rq = HWGROUP(drive)->rq;
int stat, err, sense_key;
struct packet_command *pc;
/* Check for errors. */
stat = GET_STAT();
*stat_ret = stat;
570 if (OK_STAT (stat, good_stat, BAD_R_STAT))
571 return 0;
/* Get the IDE error register. */
err = GET_ERR();
sense_key = err >> 4;
577 if (rq == NULL) {
printk("%s: missing rq in cdrom_decode_status\n", drive->name);
*startstop = ide_stopped;
580 return 1;
}
583 if (rq->cmd == REQUEST_SENSE_COMMAND) {
/* We got an error trying to get sense info
from the drive (probably while trying
to recover from a former error). Just give up. */
pc = (struct packet_command *) rq->buffer;
pc->stat = 1;
cdrom_end_request (1, drive);
*startstop = ide_error (drive, "request sense failure", stat);
592 return 1;
594 } else if (rq->cmd == PACKET_COMMAND) {
/* All other functions, except for READ. */
struct semaphore *sem = NULL;
pc = (struct packet_command *) rq->buffer;
/* Check for tray open. */
600 if (sense_key == NOT_READY) {
cdrom_saw_media_change (drive);
602 } else if (sense_key == UNIT_ATTENTION) {
/* Check for media change. */
cdrom_saw_media_change (drive);
/*printk("%s: media changed\n",drive->name);*/
606 return 0;
607 } else if (!pc->quiet) {
/* Otherwise, print an error. */
ide_dump_status(drive, "packet command error", stat);
}
/* Set the error flag and complete the request.
Then, if we have a CHECK CONDITION status,
queue a request sense command. We must be careful,
though: we don't want the thread in
cdrom_queue_packet_command to wake up until
the request sense has completed. We do this
by transferring the semaphore from the packet
command request to the request sense request. */
621 if ((stat & ERR_STAT) != 0) {
sem = rq->sem;
rq->sem = NULL;
}
pc->stat = 1;
cdrom_end_request (1, drive);
629 if ((stat & ERR_STAT) != 0)
cdrom_queue_request_sense(drive, sem, pc->sense, pc);
631 } else {
/* Handle errors from READ and WRITE requests. */
634 if (sense_key == NOT_READY) {
/* Tray open. */
cdrom_saw_media_change (drive);
/* Fail the request. */
printk ("%s: tray open\n", drive->name);
cdrom_end_request (0, drive);
641 } else if (sense_key == UNIT_ATTENTION) {
/* Media change. */
cdrom_saw_media_change (drive);
/* Arrange to retry the request.
But be sure to give up if we've retried
too many times. */
648 if (++rq->errors > ERROR_MAX)
cdrom_end_request (0, drive);
} else if (sense_key == ILLEGAL_REQUEST ||
651 sense_key == DATA_PROTECT) {
/* No point in retrying after an illegal
request or data protect error.*/
ide_dump_status (drive, "command error", stat);
cdrom_end_request (0, drive);
656 } else if ((err & ~ABRT_ERR) != 0) {
/* Go to the default handler
for other errors. */
*startstop = ide_error (drive, "cdrom_decode_status", stat);
660 return 1;
661 } else if ((++rq->errors > ERROR_MAX)) {
/* We've racked up too many retries. Abort. */
cdrom_end_request (0, drive);
}
/* If we got a CHECK_CONDITION status,
queue a request sense command. */
668 if ((stat & ERR_STAT) != 0)
cdrom_queue_request_sense(drive, NULL, NULL, NULL);
}
/* Retry, or handle the next request. */
*startstop = ide_stopped;
674 return 1;
}
677 static int cdrom_timer_expiry(ide_drive_t *drive)
{
struct request *rq = HWGROUP(drive)->rq;
struct packet_command *pc = (struct packet_command *) rq->buffer;
unsigned long wait = 0;
/*
* Some commands are *slow* and normally take a long time to
* complete. Usually we can use the ATAPI "disconnect" to bypass
* this, but not all commands/drives support that. Let
* ide_timer_expiry keep polling us for these.
*/
689 switch (pc->c[0]) {
690 case GPCMD_BLANK:
691 case GPCMD_FORMAT_UNIT:
692 case GPCMD_RESERVE_RZONE_TRACK:
wait = WAIT_CMD;
694 break;
695 default:
wait = 0;
697 break;
}
699 return wait;
}
/* Set up the device registers for transferring a packet command on DEV,
expecting to later transfer XFERLEN bytes. HANDLER is the routine
which actually transfers the command to the drive. If this is a
drq_interrupt device, this routine will arrange for HANDLER to be
called when the interrupt from the drive arrives. Otherwise, HANDLER
will be called immediately after the drive is prepared for the transfer. */
709 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
int xferlen,
ide_handler_t *handler)
{
ide_startstop_t startstop;
struct cdrom_info *info = drive->driver_data;
/* Wait for the controller to be idle. */
717 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
718 return startstop;
720 if (info->dma) {
721 if (info->cmd == READ) {
info->dma = !HWIF(drive)->dmaproc(ide_dma_read, drive);
723 } else if (info->cmd == WRITE) {
info->dma = !HWIF(drive)->dmaproc(ide_dma_write, drive);
725 } else {
printk("ide-cd: DMA set, but not allowed\n");
}
}
/* Set up the controller registers. */
OUT_BYTE (info->dma, IDE_FEATURE_REG);
OUT_BYTE (0, IDE_NSECTOR_REG);
OUT_BYTE (0, IDE_SECTOR_REG);
OUT_BYTE (xferlen & 0xff, IDE_LCYL_REG);
OUT_BYTE (xferlen >> 8 , IDE_HCYL_REG);
737 if (IDE_CONTROL_REG)
OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
740 if (info->dma)
(void) (HWIF(drive)->dmaproc(ide_dma_begin, drive));
743 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
ide_set_handler (drive, handler, WAIT_CMD, cdrom_timer_expiry);
OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
746 return ide_started;
747 } else {
OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
749 return (*handler) (drive);
}
}
/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
The device registers must have already been prepared
by cdrom_start_packet_command.
HANDLER is the interrupt handler to call when the command completes
or there's data ready. */
/*
* changed 5 parameters to 3 for dvd-ram
* struct packet_command *pc; now packet_command_t *pc;
*/
#undef CLASSIC_PACKET_STRUCT
763 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
struct packet_command *pc,
ide_handler_t *handler)
{
#ifdef CLASSIC_PACKET_STRUCT
unsigned char *cmd_buf = pc->c;
int cmd_len = sizeof(pc->c);
unsigned int timeout = pc->timeout;
#endif
ide_startstop_t startstop;
774 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
/* Here we should have been called after receiving an interrupt
from the device. DRQ should how be set. */
int stat_dum;
/* Check for errors. */
780 if (cdrom_decode_status (&startstop, drive, DRQ_STAT, &stat_dum))
781 return startstop;
782 } else {
/* Otherwise, we must wait for DRQ to get set. */
784 if (ide_wait_stat (&startstop, drive, DRQ_STAT, BUSY_STAT, WAIT_READY))
785 return startstop;
}
/* Arm the interrupt handler. */
#ifdef CLASSIC_PACKET_STRUCT
/* Arm the interrupt handler. */
ide_set_handler (drive, handler, timeout, cdrom_timer_expiry);
/* Send the command to the device. */
atapi_output_bytes (drive, cmd_buf, cmd_len);
#else /* !CLASSIC_PACKET_STRUCT */
/* Arm the interrupt handler. */
// ide_set_handler (drive, handler, (unsigned int) pc->timeout, cdrom_timer_expiry);
ide_set_handler (drive, handler, pc->timeout, cdrom_timer_expiry);
/* Send the command to the device. */
// atapi_output_bytes (drive, (void *)pc->c, (unsigned int) sizeof(pc->c));
atapi_output_bytes (drive, pc->c, sizeof(pc->c));
#endif /* CLASSIC_PACKET_STRUCT */
805 return ide_started;
}
/****************************************************************************
* Block read functions.
*/
/*
* Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
* buffer. Once the first sector is added, any subsequent sectors are
* assumed to be continuous (until the buffer is cleared). For the first
* sector added, SECTOR is its sector number. (SECTOR is then ignored until
* the buffer is cleared.)
*/
819 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
int sectors_to_transfer)
{
struct cdrom_info *info = drive->driver_data;
/* Number of sectors to read into the buffer. */
int sectors_to_buffer = MIN (sectors_to_transfer,
(SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
info->nsectors_buffered);
char *dest;
/* If we couldn't get a buffer, don't try to buffer anything... */
832 if (info->buffer == NULL)
sectors_to_buffer = 0;
/* If this is the first sector in the buffer, remember its number. */
836 if (info->nsectors_buffered == 0)
info->sector_buffered = sector;
/* Read the data into the buffer. */
dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
841 while (sectors_to_buffer > 0) {
atapi_input_bytes (drive, dest, SECTOR_SIZE);
--sectors_to_buffer;
--sectors_to_transfer;
++info->nsectors_buffered;
dest += SECTOR_SIZE;
}
/* Throw away any remaining data. */
850 while (sectors_to_transfer > 0) {
char dum[SECTOR_SIZE];
atapi_input_bytes (drive, dum, sizeof (dum));
--sectors_to_transfer;
}
}
/*
* Check the contents of the interrupt reason register from the cdrom
* and attempt to recover if there are problems. Returns 0 if everything's
* ok; nonzero if the request has been terminated.
*/
static inline
863 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
{
ireason &= 3;
866 if (ireason == 2) return 0;
868 if (ireason == 0) {
/* Whoops... The drive is expecting to receive data from us! */
printk ("%s: cdrom_read_intr: "
"Drive wants to transfer data the wrong way!\n",
drive->name);
/* Throw some data at the drive so it doesn't hang
and quit this request. */
876 while (len > 0) {
int dum = 0;
atapi_output_bytes (drive, &dum, sizeof (dum));
len -= sizeof (dum);
}
881 } else if (ireason == 1) {
/* Some drives (ASUS) seem to tell us that status
* info is available. just get it and ignore.
*/
GET_STAT();
886 return 0;
887 } else {
/* Drive wants a command packet, or invalid ireason... */
printk ("%s: cdrom_read_intr: bad interrupt reason %d\n",
drive->name, ireason);
}
cdrom_end_request (0, drive);
894 return -1;
}
/*
* Interrupt routine. Called when a read request has completed.
*/
900 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
{
int stat;
int ireason, len, sectors_to_transfer, nskip;
struct cdrom_info *info = drive->driver_data;
int i, dma = info->dma, dma_error = 0;
ide_startstop_t startstop;
struct request *rq = HWGROUP(drive)->rq;
/* Check for errors. */
911 if (dma) {
info->dma = 0;
913 if ((dma_error = HWIF(drive)->dmaproc(ide_dma_end, drive)))
HWIF(drive)->dmaproc(ide_dma_off, drive);
}
917 if (cdrom_decode_status (&startstop, drive, 0, &stat))
918 return startstop;
920 if (dma) {
921 if (!dma_error) {
922 for (i = rq->nr_sectors; i > 0;) {
i -= rq->current_nr_sectors;
ide_end_request(1, HWGROUP(drive));
}
926 return ide_stopped;
927 } else
928 return ide_error (drive, "dma error", stat);
}
/* Read the interrupt reason and the transfer length. */
ireason = IN_BYTE (IDE_NSECTOR_REG);
len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
/* If DRQ is clear, the command has completed. */
936 if ((stat & DRQ_STAT) == 0) {
/* If we're not done filling the current buffer, complain.
Otherwise, complete the command normally. */
939 if (rq->current_nr_sectors > 0) {
printk ("%s: cdrom_read_intr: data underrun (%ld blocks)\n",
drive->name, rq->current_nr_sectors);
cdrom_end_request (0, drive);
943 } else
cdrom_end_request (1, drive);
945 return ide_stopped;
}
/* Check that the drive is expecting to do the same thing we are. */
949 if (cdrom_read_check_ireason (drive, len, ireason))
950 return ide_stopped;
/* Assume that the drive will always provide data in multiples
of at least SECTOR_SIZE, as it gets hairy to keep track
of the transfers otherwise. */
955 if ((len % SECTOR_SIZE) != 0) {
printk ("%s: cdrom_read_intr: Bad transfer size %d\n",
drive->name, len);
958 if (CDROM_CONFIG_FLAGS (drive)->limit_nframes)
printk (" This drive is not supported by this version of the driver\n");
960 else {
printk (" Trying to limit transfer sizes\n");
CDROM_CONFIG_FLAGS (drive)->limit_nframes = 1;
}
cdrom_end_request (0, drive);
965 return ide_stopped;
}
/* The number of sectors we need to read from the drive. */
sectors_to_transfer = len / SECTOR_SIZE;
/* First, figure out if we need to bit-bucket
any of the leading sectors. */
nskip = MIN ((int)(rq->current_nr_sectors - (rq->bh->b_size >> SECTOR_BITS)),
sectors_to_transfer);
976 while (nskip > 0) {
/* We need to throw away a sector. */
char dum[SECTOR_SIZE];
atapi_input_bytes (drive, dum, sizeof (dum));
--rq->current_nr_sectors;
--nskip;
--sectors_to_transfer;
}
/* Now loop while we still have data to read from the drive. */
987 while (sectors_to_transfer > 0) {
int this_transfer;
/* If we've filled the present buffer but there's another
chained buffer after it, move on. */
if (rq->current_nr_sectors == 0 &&
993 rq->nr_sectors > 0)
cdrom_end_request (1, drive);
/* If the buffers are full, cache the rest of the data in our
internal buffer. */
998 if (rq->current_nr_sectors == 0) {
cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
sectors_to_transfer = 0;
1001 } else {
/* Transfer data to the buffers.
Figure out how many sectors we can transfer
to the current buffer. */
this_transfer = MIN (sectors_to_transfer,
rq->current_nr_sectors);
/* Read this_transfer sectors
into the current buffer. */
1010 while (this_transfer > 0) {
atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
rq->buffer += SECTOR_SIZE;
--rq->nr_sectors;
--rq->current_nr_sectors;
++rq->sector;
--this_transfer;
--sectors_to_transfer;
}
}
}
/* Done moving data!
Wait for another interrupt. */
ide_set_handler(drive, &cdrom_read_intr, WAIT_CMD, NULL);
1025 return ide_started;
}
/*
* Try to satisfy some of the current read request from our cached data.
* Returns nonzero if the request has been completed, zero otherwise.
*/
1032 static int cdrom_read_from_buffer (ide_drive_t *drive)
{
struct cdrom_info *info = drive->driver_data;
struct request *rq = HWGROUP(drive)->rq;
/* Can't do anything if there's no buffer. */
1038 if (info->buffer == NULL) return 0;
/* Loop while this request needs data and the next block is present
in our cache. */
while (rq->nr_sectors > 0 &&
rq->sector >= info->sector_buffered &&
1044 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1045 if (rq->current_nr_sectors == 0)
cdrom_end_request (1, drive);
memcpy (rq->buffer,
info->buffer +
(rq->sector - info->sector_buffered) * SECTOR_SIZE,
SECTOR_SIZE);
rq->buffer += SECTOR_SIZE;
--rq->current_nr_sectors;
--rq->nr_sectors;
++rq->sector;
}
/* If we've satisfied the current request,
terminate it successfully. */
1060 if (rq->nr_sectors == 0) {
cdrom_end_request (1, drive);
1062 return -1;
}
/* Move on to the next buffer if needed. */
1066 if (rq->current_nr_sectors == 0)
cdrom_end_request (1, drive);
/* If this condition does not hold, then the kluge i use to
represent the number of sectors to skip at the start of a transfer
will fail. I think that this will never happen, but let's be
paranoid and check. */
if (rq->current_nr_sectors < (rq->bh->b_size >> SECTOR_BITS) &&
1074 (rq->sector % SECTORS_PER_FRAME) != 0) {
printk ("%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
drive->name, rq->sector);
cdrom_end_request (0, drive);
1078 return -1;
}
1081 return 0;
}
/*
* Routine to send a read packet command to the drive.
* This is usually called directly from cdrom_start_read.
* However, for drq_interrupt devices, it is called from an interrupt
* when the drive is ready to accept the command.
*/
1090 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
{
struct packet_command pc;
struct request *rq = HWGROUP(drive)->rq;
int nsect, sector, nframes, frame, nskip;
/* Number of sectors to transfer. */
nsect = rq->nr_sectors;
/* Starting sector. */
sector = rq->sector;
/* If the requested sector doesn't start on a cdrom block boundary,
we must adjust the start of the transfer so that it does,
and remember to skip the first few sectors.
If the CURRENT_NR_SECTORS field is larger than the size
of the buffer, it will mean that we're to skip a number
of sectors equal to the amount by which CURRENT_NR_SECTORS
is larger than the buffer size. */
nskip = (sector % SECTORS_PER_FRAME);
1110 if (nskip > 0) {
/* Sanity check... */
if (rq->current_nr_sectors != (rq->bh->b_size >> SECTOR_BITS) &&
1113 (rq->sector % CD_FRAMESIZE != 0)) {
printk ("%s: cdrom_start_read_continuation: buffer botch (%lu)\n",
drive->name, rq->current_nr_sectors);
cdrom_end_request (0, drive);
1117 return ide_stopped;
}
sector -= nskip;
nsect += nskip;
rq->current_nr_sectors += nskip;
}
/* Convert from sectors to cdrom blocks, rounding up the transfer
length if needed. */
nframes = (nsect + SECTORS_PER_FRAME-1) / SECTORS_PER_FRAME;
frame = sector / SECTORS_PER_FRAME;
/* Largest number of frames was can transfer at once is 64k-1. For
some drives we need to limit this even more. */
nframes = MIN (nframes, (CDROM_CONFIG_FLAGS (drive)->limit_nframes) ?
(65534 / CD_FRAMESIZE) : 65535);
/* Set up the command */
memset (&pc.c, 0, sizeof (pc.c));
pc.c[0] = GPCMD_READ_10;
pc.c[7] = (nframes >> 8);
pc.c[8] = (nframes & 0xff);
put_unaligned(cpu_to_be32(frame), (unsigned int *) &pc.c[2]);
pc.timeout = WAIT_CMD;
/* Send the command to the drive and return. */
1143 return cdrom_transfer_packet_command(drive, &pc, &cdrom_read_intr);
}
#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
#define IDECD_SEEK_TIMEOUT WAIT_CMD /* 10 sec */
1151 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
{
struct cdrom_info *info = drive->driver_data;
int stat;
static int retry = 10;
ide_startstop_t startstop;
1158 if (cdrom_decode_status (&startstop, drive, 0, &stat))
1159 return startstop;
CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1162 if (retry && jiffies - info->start_seek > IDECD_SEEK_TIMER) {
1163 if (--retry == 0) {
/*
* this condition is far too common, to bother
* users about it
*/
#if 0
printk("%s: disabled DSC seek overlap\n", drive->name);
#endif
drive->dsc_overlap = 0;
}
}
1174 return ide_stopped;
}
1177 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
{
struct packet_command pc;
struct request *rq = HWGROUP(drive)->rq;
int sector, frame, nskip;
sector = rq->sector;
nskip = (sector % SECTORS_PER_FRAME);
1185 if (nskip > 0)
sector -= nskip;
frame = sector / SECTORS_PER_FRAME;
memset (&pc.c, 0, sizeof (pc.c));
pc.c[0] = GPCMD_SEEK;
put_unaligned(cpu_to_be32(frame), (unsigned int *) &pc.c[2]);
pc.timeout = WAIT_CMD;
1194 return cdrom_transfer_packet_command(drive, &pc, &cdrom_seek_intr);
}
1197 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
{
struct cdrom_info *info = drive->driver_data;
info->dma = 0;
info->cmd = 0;
info->start_seek = jiffies;
1204 return cdrom_start_packet_command (drive, 0, cdrom_start_seek_continuation);
}
/* Fix up a possibly partially-processed request so that we can
start it over entirely, or even put it back on the request queue. */
1209 static void restore_request (struct request *rq)
{
1211 if (rq->buffer != rq->bh->b_data) {
int n = (rq->buffer - rq->bh->b_data) / SECTOR_SIZE;
rq->buffer = rq->bh->b_data;
rq->nr_sectors += n;
rq->sector -= n;
}
rq->current_nr_sectors = rq->bh->b_size >> SECTOR_BITS;
}
/*
* Start a read request from the CD-ROM.
*/
1223 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
{
struct cdrom_info *info = drive->driver_data;
struct request *rq = HWGROUP(drive)->rq;
int minor = MINOR (rq->rq_dev);
/* If the request is relative to a partition, fix it up to refer to the
absolute address. */
1231 if ((minor & PARTN_MASK) != 0) {
rq->sector = block;
minor &= ~PARTN_MASK;
rq->rq_dev = MKDEV (MAJOR(rq->rq_dev), minor);
}
/* We may be retrying this request after an error. Fix up
any weirdness which might be present in the request packet. */
restore_request (rq);
/* Satisfy whatever we can of this request from our cached sector. */
1242 if (cdrom_read_from_buffer(drive))
1243 return ide_stopped;
/* Clear the local sector buffer. */
info->nsectors_buffered = 0;
/* use dma, if possible. */
if (drive->using_dma && (rq->sector % SECTORS_PER_FRAME == 0) &&
1250 (rq->nr_sectors % SECTORS_PER_FRAME == 0))
info->dma = 1;
1252 else
info->dma = 0;
info->cmd = READ;
/* Start sending the read request to the drive. */
1257 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
}
/****************************************************************************
* Execute all other packet commands.
*/
/* Forward declarations. */
static int cdrom_lockdoor(ide_drive_t *drive, int lockflag,
struct request_sense *sense);
/* Interrupt routine for packet command completion. */
1269 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
{
int ireason, len, stat, thislen;
struct request *rq = HWGROUP(drive)->rq;
struct packet_command *pc = (struct packet_command *)rq->buffer;
ide_startstop_t startstop;
/* Check for errors. */
1277 if (cdrom_decode_status (&startstop, drive, 0, &stat))
1278 return startstop;
/* Read the interrupt reason and the transfer length. */
ireason = IN_BYTE (IDE_NSECTOR_REG);
len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
/* If DRQ is clear, the command has completed.
Complain if we still have data left to transfer. */
1286 if ((stat & DRQ_STAT) == 0) {
/* Some of the trailing request sense fields are optional, and
some drives don't send them. Sigh. */
if (pc->c[0] == GPCMD_REQUEST_SENSE &&
pc->buflen > 0 &&
1291 pc->buflen <= 5) {
1292 while (pc->buflen > 0) {
*pc->buffer++ = 0;
--pc->buflen;
}
}
1298 if (pc->buflen == 0)
cdrom_end_request (1, drive);
1300 else {
/* Comment this out, because this always happens
right after a reset occurs, and it is annoying to
always print expected stuff. */
/*
printk ("%s: cdrom_pc_intr: data underrun %d\n",
drive->name, pc->buflen);
*/
pc->stat = 1;
cdrom_end_request (1, drive);
}
1311 return ide_stopped;
}
/* Figure out how much data to transfer. */
thislen = pc->buflen;
1316 if (thislen > len) thislen = len;
/* The drive wants to be written to. */
1319 if ((ireason & 3) == 0) {
/* Transfer the data. */
atapi_output_bytes (drive, pc->buffer, thislen);
/* If we haven't moved enough data to satisfy the drive,
add some padding. */
1325 while (len > thislen) {
int dum = 0;
atapi_output_bytes (drive, &dum, sizeof (dum));
len -= sizeof (dum);
}
/* Keep count of how much data we've moved. */
pc->buffer += thislen;
pc->buflen -= thislen;
}
/* Same drill for reading. */
1337 else if ((ireason & 3) == 2) {
/* Transfer the data. */
atapi_input_bytes (drive, pc->buffer, thislen);
/* If we haven't moved enough data to satisfy the drive,
add some padding. */
1344 while (len > thislen) {
int dum = 0;
atapi_input_bytes (drive, &dum, sizeof (dum));
len -= sizeof (dum);
}
/* Keep count of how much data we've moved. */
pc->buffer += thislen;
pc->buflen -= thislen;
1353 } else {
printk ("%s: cdrom_pc_intr: The drive "
"appears confused (ireason = 0x%2x)\n",
drive->name, ireason);
pc->stat = 1;
}
/* Now we wait for another interrupt. */
ide_set_handler (drive, &cdrom_pc_intr, WAIT_CMD, cdrom_timer_expiry);
1362 return ide_started;
}
1366 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
{
struct request *rq = HWGROUP(drive)->rq;
struct packet_command *pc = (struct packet_command *)rq->buffer;
1371 if (!pc->timeout)
pc->timeout = WAIT_CMD;
/* Send the command to the drive and return. */
1375 return cdrom_transfer_packet_command(drive, pc, &cdrom_pc_intr);
}
1379 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
{
int len;
struct request *rq = HWGROUP(drive)->rq;
struct packet_command *pc = (struct packet_command *)rq->buffer;
struct cdrom_info *info = drive->driver_data;
info->dma = 0;
info->cmd = 0;
pc->stat = 0;
len = pc->buflen;
/* Start sending the command to the drive. */
1392 return cdrom_start_packet_command (drive, len, cdrom_do_pc_continuation);
}
/* Sleep for TIME jiffies.
Not to be called from an interrupt handler. */
static
1399 void cdrom_sleep (int time)
{
int sleep = time;
1403 do {
1404 set_current_state(TASK_INTERRUPTIBLE);
sleep = schedule_timeout(sleep);
1406 } while (sleep);
}
static
1410 int cdrom_queue_packet_command(ide_drive_t *drive, struct packet_command *pc)
{
struct request_sense sense;
struct request req;
int retries = 10;
1416 if (pc->sense == NULL)
pc->sense = &sense;
/* Start of retry loop. */
1420 do {
ide_init_drive_cmd (&req);
req.cmd = PACKET_COMMAND;
req.buffer = (char *)pc;
1424 if (ide_do_drive_cmd (drive, &req, ide_wait)) {
printk("%s: do_drive_cmd returned stat=%02x,err=%02x\n",
drive->name, req.buffer[0], req.buffer[1]);
/* FIXME: we should probably abort/retry or something */
}
1429 if (pc->stat != 0) {
/* The request failed. Retry if it was due to a unit
attention status
(usually means media was changed). */
struct request_sense *reqbuf = pc->sense;
1435 if (reqbuf->sense_key == UNIT_ATTENTION)
cdrom_saw_media_change (drive);
else if (reqbuf->sense_key == NOT_READY &&
1438 reqbuf->asc == 4 && reqbuf->ascq != 4) {
/* The drive is in the process of loading
a disk. Retry, but wait a little to give
the drive time to complete the load. */
cdrom_sleep(2 * HZ);
1443 } else {
/* Otherwise, don't retry. */
retries = 0;
}
--retries;
}
/* End of retry loop. */
1451 } while (pc->stat != 0 && retries >= 0);
/* Return an error if the command failed. */
1454 return pc->stat ? -EIO : 0;
}
/*
* Write handling
*/
1460 static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
{
/* Two notes about IDE interrupt reason here - 0 means that
* the drive wants to receive data from us, 2 means that
* the drive is expecting data from us.
*/
ireason &= 3;
1468 if (ireason == 2) {
/* Whoops... The drive wants to send data. */
printk("%s: cdrom_write_intr: wrong transfer direction!\n",
drive->name);
/* Throw some data at the drive so it doesn't hang
and quit this request. */
1475 while (len > 0) {
int dum = 0;
atapi_output_bytes(drive, &dum, sizeof(dum));
len -= sizeof(dum);
}
1480 } else {
/* Drive wants a command packet, or invalid ireason... */
printk("%s: cdrom_write_intr: bad interrupt reason %d\n",
drive->name, ireason);
}
cdrom_end_request(0, drive);
1487 return 1;
}
1490 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
{
int stat, ireason, len, sectors_to_transfer;
struct cdrom_info *info = drive->driver_data;
int i, dma_error = 0, dma = info->dma;
ide_startstop_t startstop;
struct request *rq = HWGROUP(drive)->rq;
/* Check for errors. */
1500 if (dma) {
info->dma = 0;
1502 if ((dma_error = HWIF(drive)->dmaproc(ide_dma_end, drive))) {
printk("ide-cd: write dma error\n");
HWIF(drive)->dmaproc(ide_dma_off, drive);
}
}
1508 if (cdrom_decode_status(&startstop, drive, 0, &stat)) {
printk("ide-cd: write_intr decode_status bad\n");
1510 return startstop;
}
1513 if (dma) {
1514 if (dma_error)
1515 return ide_error(drive, "dma error", stat);
rq = HWGROUP(drive)->rq;
1518 for (i = rq->nr_sectors; i > 0;) {
i -= rq->current_nr_sectors;
ide_end_request(1, HWGROUP(drive));
}
1522 return ide_stopped;
}
/* Read the interrupt reason and the transfer length. */
ireason = IN_BYTE(IDE_NSECTOR_REG);
len = IN_BYTE(IDE_LCYL_REG) + 256 * IN_BYTE(IDE_HCYL_REG);
/* If DRQ is clear, the command has completed. */
1530 if ((stat & DRQ_STAT) == 0) {
/* If we're not done writing, complain.
* Otherwise, complete the command normally.
*/
1534 if (rq->current_nr_sectors > 0) {
printk("%s: write_intr: data underrun (%ld blocks)\n",
drive->name, rq->current_nr_sectors);
cdrom_end_request(0, drive);
1538 } else
cdrom_end_request(1, drive);
1540 return ide_stopped;
}
/* Check that the drive is expecting to do the same thing we are. */
1544 if (ireason & 3)
1545 if (cdrom_write_check_ireason(drive, len, ireason))
1546 return ide_stopped;
/* The number of sectors we need to read from the drive. */
sectors_to_transfer = len / SECTOR_SIZE;
/* Now loop while we still have data to read from the drive. DMA
* transfers will already have been complete
*/
1554 while (sectors_to_transfer > 0) {
/* If we've filled the present buffer but there's another
chained buffer after it, move on. */
1557 if (rq->current_nr_sectors == 0 && rq->nr_sectors > 0)
cdrom_end_request(1, drive);
atapi_output_bytes(drive, rq->buffer, rq->current_nr_sectors);
rq->nr_sectors -= rq->current_nr_sectors;
rq->current_nr_sectors = 0;
rq->sector += rq->current_nr_sectors;
sectors_to_transfer -= rq->current_nr_sectors;
}
/* arm handler */
ide_set_handler(drive, &cdrom_write_intr, 5 * WAIT_CMD, NULL);
1569 return ide_started;
}
1572 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
{
struct packet_command pc; /* packet_command_t pc; */
struct request *rq = HWGROUP(drive)->rq;
unsigned nframes, frame;
nframes = rq->nr_sectors >> 2;
frame = rq->sector >> 2;
memset(&pc.c, 0, sizeof(pc.c));
/*
* we might as well use WRITE_12, but none of the device I have
* support the streaming feature anyway, so who cares.
*/
pc.c[0] = GPCMD_WRITE_10;
#if 0 /* the immediate bit */
pc.c[1] = 1 << 3;
#endif
pc.c[7] = (nframes >> 8) & 0xff;
pc.c[8] = nframes & 0xff;
put_unaligned(cpu_to_be32(frame), (unsigned int *)&pc.c[2]);
pc.timeout = 2 * WAIT_CMD;
1595 return cdrom_transfer_packet_command(drive, &pc, cdrom_write_intr);
}
1598 static ide_startstop_t cdrom_start_write(ide_drive_t *drive)
{
struct cdrom_info *info = drive->driver_data;
info->nsectors_buffered = 0;
/* use dma, if possible. we don't need to check more, since we
* know that the transfer is always (at least!) 2KB aligned */
info->dma = drive->using_dma ? 1 : 0;
info->cmd = WRITE;
/* Start sending the read request to the drive. */
1610 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
}
/****************************************************************************
* cdrom driver request routine.
*/
static ide_startstop_t
1617 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, unsigned long block)
{
ide_startstop_t action;
struct cdrom_info *info = drive->driver_data;
1622 switch (rq->cmd) {
1623 case WRITE:
1624 case READ: {
1625 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
unsigned long elpased = jiffies - info->start_seek;
int stat = GET_STAT();
1629 if ((stat & SEEK_STAT) != SEEK_STAT) {
1630 if (elpased < IDECD_SEEK_TIMEOUT) {
ide_stall_queue(drive, IDECD_SEEK_TIMER);
1632 return ide_stopped;
}
printk ("%s: DSC timeout\n", drive->name);
}
CDROM_CONFIG_FLAGS(drive)->seeking = 0;
}
1638 if (IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap)
action = cdrom_start_seek (drive, block);
1640 else {
1641 if (rq->cmd == READ)
action = cdrom_start_read(drive, block);
1643 else
action = cdrom_start_write(drive);
}
info->last_block = block;
1647 return action;
}
1650 case PACKET_COMMAND:
1651 case REQUEST_SENSE_COMMAND: {
1652 return cdrom_do_packet_command(drive);
}
1655 case RESET_DRIVE_COMMAND: {
cdrom_end_request(1, drive);
1657 return ide_do_reset(drive);
}
1660 default: {
printk("ide-cd: bad cmd %d\n", rq->cmd);
cdrom_end_request(0, drive);
1663 return ide_stopped;
}
}
}
/****************************************************************************
* Ioctl handling.
*
* Routines which queue packet commands take as a final argument a pointer
* to a request_sense struct. If execution of the command results
* in an error with a CHECK CONDITION status, this structure will be filled
* with the results of the subsequent request sense command. The pointer
* can also be NULL, in which case no sense information is returned.
*/
#if ! STANDARD_ATAPI
static inline
1682 int bin2bcd (int x)
{
1684 return (x%10) | ((x/10) << 4);
}
static inline
1689 int bcd2bin (int x)
{
1691 return (x >> 4) * 10 + (x & 0x0f);
}
static
1695 void msf_from_bcd (struct atapi_msf *msf)
{
msf->minute = bcd2bin (msf->minute);
msf->second = bcd2bin (msf->second);
msf->frame = bcd2bin (msf->frame);
}
#endif /* not STANDARD_ATAPI */
static inline
1706 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
{
lba += CD_MSF_OFFSET;
lba &= 0xffffff; /* negative lbas use only 24 bits */
*m = lba / (CD_SECS * CD_FRAMES);
lba %= (CD_SECS * CD_FRAMES);
*s = lba / CD_FRAMES;
*f = lba % CD_FRAMES;
}
static inline
1718 int msf_to_lba (byte m, byte s, byte f)
{
1720 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
}
1723 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
{
struct packet_command pc;
struct cdrom_info *info = drive->driver_data;
struct cdrom_device_info *cdi = &info->devinfo;
memset(&pc, 0, sizeof(pc));
pc.sense = sense;
pc.c[0] = GPCMD_TEST_UNIT_READY;
#if ! STANDARD_ATAPI
/* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
switch CDs instead of supporting the LOAD_UNLOAD opcode */
pc.c[7] = cdi->sanyo_slot % 3;
#endif /* not STANDARD_ATAPI */
1741 return cdrom_queue_packet_command(drive, &pc);
}
/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
static int
1747 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
{
struct request_sense my_sense;
struct packet_command pc;
int stat;
1753 if (sense == NULL)
sense = &my_sense;
/* If the drive cannot lock the door, just pretend. */
1757 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
stat = 0;
1759 } else {
memset(&pc, 0, sizeof(pc));
pc.sense = sense;
pc.c[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
pc.c[4] = lockflag ? 1 : 0;
stat = cdrom_queue_packet_command (drive, &pc);
}
/* If we got an illegal field error, the drive
probably cannot lock the door. */
if (stat != 0 &&
sense->sense_key == ILLEGAL_REQUEST &&
1771 (sense->asc == 0x24 || sense->asc == 0x20)) {
printk ("%s: door locking not supported\n",
drive->name);
CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
stat = 0;
}
/* no medium, that's alright. */
1779 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
stat = 0;
1782 if (stat == 0)
CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
1785 return stat;
}
/* Eject the disk if EJECTFLAG is 0.
If EJECTFLAG is 1, try to reload the disk. */
1791 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
struct request_sense *sense)
{
struct packet_command pc;
1796 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
1797 return -EDRIVE_CANT_DO_THIS;
/* reload fails on some drives, if the tray is locked */
1800 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
1801 return 0;
memset(&pc, 0, sizeof (pc));
pc.sense = sense;
pc.c[0] = GPCMD_START_STOP_UNIT;
pc.c[4] = 0x02 + (ejectflag != 0);
1808 return cdrom_queue_packet_command (drive, &pc);
}
1811 static int cdrom_read_capacity(ide_drive_t *drive, unsigned *capacity,
struct request_sense *sense)
{
struct {
__u32 lba;
__u32 blocklen;
} capbuf;
int stat;
struct packet_command pc;
memset(&pc, 0, sizeof(pc));
pc.sense = sense;
pc.c[0] = GPCMD_READ_CDVD_CAPACITY;
pc.buffer = (char *)&capbuf;
pc.buflen = sizeof(capbuf);
stat = cdrom_queue_packet_command(drive, &pc);
1830 if (stat == 0)
*capacity = 1 + be32_to_cpu(capbuf.lba);
1833 return stat;
}
1836 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
int format, char *buf, int buflen,
struct request_sense *sense)
{
struct packet_command pc;
memset(&pc, 0, sizeof(pc));
pc.sense = sense;
pc.buffer = buf;
pc.buflen = buflen;
pc.c[0] = GPCMD_READ_TOC_PMA_ATIP;
pc.c[6] = trackno;
pc.c[7] = (buflen >> 8);
pc.c[8] = (buflen & 0xff);
pc.c[9] = (format << 6);
1853 if (msf_flag)
pc.c[1] = 2;
1856 return cdrom_queue_packet_command (drive, &pc);
}
/* Try to read the entire TOC for the disk into our internal buffer. */
1861 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
{
int minor, stat, ntracks, i;
kdev_t dev;
struct cdrom_info *info = drive->driver_data;
struct atapi_toc *toc = info->toc;
struct {
struct atapi_toc_header hdr;
struct atapi_toc_entry ent;
} ms_tmp;
1872 if (toc == NULL) {
/* Try to allocate space. */
toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
GFP_KERNEL);
info->toc = toc;
1877 if (toc == NULL) {
printk ("%s: No cdrom TOC buffer!\n", drive->name);
1879 return -ENOMEM;
}
}
/* Check to see if the existing data is still valid.
If it is, just return. */
(void) cdrom_check_status(drive, sense);
1887 if (CDROM_STATE_FLAGS(drive)->toc_valid)
1888 return 0;
/* First read just the header, so we know how long the TOC is. */
stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
sizeof(struct atapi_toc_header), sense);
1893 if (stat) return stat;
#if ! STANDARD_ATAPI
1896 if (CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd) {
toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
toc->hdr.last_track = bcd2bin (toc->hdr.last_track);
}
#endif /* not STANDARD_ATAPI */
ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1903 if (ntracks <= 0)
1904 return -EIO;
1905 if (ntracks > MAX_TRACKS)
ntracks = MAX_TRACKS;
/* Now read the whole schmeer. */
stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
(char *)&toc->hdr,
sizeof(struct atapi_toc_header) +
(ntracks + 1) *
sizeof(struct atapi_toc_entry), sense);
1915 if (stat && toc->hdr.first_track > 1) {
/* Cds with CDI tracks only don't have any TOC entries,
despite of this the returned values are
first_track == last_track = number of CDI tracks + 1,
so that this case is indistinguishable from the same
layout plus an additional audio track.
If we get an error for the regular case, we assume
a CDI without additional audio tracks. In this case
the readable TOC is empty (CDI tracks are not included)
and only holds the Leadout entry. Heiko Eißfeldt */
ntracks = 0;
stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
(char *)&toc->hdr,
sizeof(struct atapi_toc_header) +
(ntracks + 1) *
sizeof(struct atapi_toc_entry),
sense);
1932 if (stat) {
1933 return stat;
}
#if ! STANDARD_ATAPI
1936 if (CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd) {
toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
1939 } else
#endif /* not STANDARD_ATAPI */
{
toc->hdr.first_track = CDROM_LEADOUT;
toc->hdr.last_track = CDROM_LEADOUT;
}
}
1947 if (stat)
1948 return stat;
toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
#if ! STANDARD_ATAPI
1953 if (CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd) {
toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
toc->hdr.last_track = bcd2bin (toc->hdr.last_track);
}
#endif /* not STANDARD_ATAPI */
1959 for (i=0; i<=ntracks; i++) {
#if ! STANDARD_ATAPI
1961 if (CDROM_CONFIG_FLAGS (drive)->tocaddr_as_bcd) {
1962 if (CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd)
toc->ent[i].track = bcd2bin (toc->ent[i].track);
msf_from_bcd (&toc->ent[i].addr.msf);
}
#endif /* not STANDARD_ATAPI */
toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
toc->ent[i].addr.msf.second,
toc->ent[i].addr.msf.frame);
}
/* Read the multisession information. */
1973 if (toc->hdr.first_track != CDROM_LEADOUT) {
/* Read the multisession information. */
stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
sizeof(ms_tmp), sense);
1977 if (stat) return stat;
1978 } else {
ms_tmp.ent.addr.msf.minute = 0;
ms_tmp.ent.addr.msf.second = 2;
ms_tmp.ent.addr.msf.frame = 0;
ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
}
#if ! STANDARD_ATAPI
1986 if (CDROM_CONFIG_FLAGS (drive)->tocaddr_as_bcd)
msf_from_bcd (&ms_tmp.ent.addr.msf);
#endif /* not STANDARD_ATAPI */
toc->last_session_lba = msf_to_lba (ms_tmp.ent.addr.msf.minute,
ms_tmp.ent.addr.msf.second,
ms_tmp.ent.addr.msf.frame);
toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
/* Now try to get the total cdrom capacity. */
minor = (drive->select.b.unit) << PARTN_BITS;
dev = MKDEV(HWIF(drive)->major, minor);
stat = cdrom_get_last_written(dev, (long *)&toc->capacity);
2000 if (stat)
stat = cdrom_read_capacity(drive, &toc->capacity, sense);
2002 if (stat)
toc->capacity = 0x1fffff;
HWIF(drive)->gd->sizes[drive->select.b.unit << PARTN_BITS] = (toc->capacity * SECTORS_PER_FRAME) >> (BLOCK_SIZE_BITS - 9);
drive->part[0].nr_sects = toc->capacity * SECTORS_PER_FRAME;
/* Remember that we've read this stuff. */
CDROM_STATE_FLAGS (drive)->toc_valid = 1;
2011 return 0;
}
2015 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
int buflen, struct request_sense *sense)
{
struct packet_command pc;
memset(&pc, 0, sizeof(pc));
pc.sense = sense;
pc.buffer = buf;
pc.buflen = buflen;
pc.c[0] = GPCMD_READ_SUBCHANNEL;
pc.c[1] = 2; /* MSF addressing */
pc.c[2] = 0x40; /* request subQ data */
pc.c[3] = format;
pc.c[7] = (buflen >> 8);
pc.c[8] = (buflen & 0xff);
2031 return cdrom_queue_packet_command(drive, &pc);
}
/* ATAPI cdrom drives are free to select the speed you request or any slower
rate :-( Requesting too fast a speed will _not_ produce an error. */
2036 static int cdrom_select_speed(ide_drive_t *drive, int speed,
struct request_sense *sense)
{
struct packet_command pc;
memset(&pc, 0, sizeof(pc));
pc.sense = sense;
2043 if (speed == 0)
speed = 0xffff; /* set to max */
2045 else
speed *= 177; /* Nx to kbytes/s */
pc.c[0] = GPCMD_SET_SPEED;
/* Read Drive speed in kbytes/second MSB */
pc.c[2] = (speed >> 8) & 0xff;
/* Read Drive speed in kbytes/second LSB */
pc.c[3] = speed & 0xff;
if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2055 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
/* Write Drive speed in kbytes/second MSB */
pc.c[4] = (speed >> 8) & 0xff;
/* Write Drive speed in kbytes/second LSB */
pc.c[5] = speed & 0xff;
}
2062 return cdrom_queue_packet_command(drive, &pc);
}
2065 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
{
struct request_sense sense;
struct packet_command pc;
memset(&pc, 0, sizeof (pc));
pc.sense = &sense;
pc.c[0] = GPCMD_PLAY_AUDIO_MSF;
lba_to_msf(lba_start, &pc.c[3], &pc.c[4], &pc.c[5]);
lba_to_msf(lba_end-1, &pc.c[6], &pc.c[7], &pc.c[8]);
2077 return cdrom_queue_packet_command(drive, &pc);
}
2080 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
struct atapi_toc_entry **ent)
{
struct cdrom_info *info = drive->driver_data;
struct atapi_toc *toc = info->toc;
int ntracks;
/*
* don't serve cached data, if the toc isn't valid
*/
2090 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2091 return -EINVAL;
/* Check validity of requested track number. */
ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2095 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2096 if (track == CDROM_LEADOUT)
*ent = &toc->ent[ntracks];
else if (track < toc->hdr.first_track ||
2099 track > toc->hdr.last_track)
2100 return -EINVAL;
2101 else
*ent = &toc->ent[track - toc->hdr.first_track];
2104 return 0;
}
/* the generic packet interface to cdrom.c */
2108 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
struct cdrom_generic_command *cgc)
{
struct packet_command pc;
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2114 if (cgc->timeout <= 0)
cgc->timeout = WAIT_CMD;
/* here we queue the commands from the uniform CD-ROM
layer. the packet must be complete, as we do not
touch it at all. */
memset(&pc, 0, sizeof(pc));
memcpy(pc.c, cgc->cmd, CDROM_PACKET_SIZE);
pc.buffer = cgc->buffer;
pc.buflen = cgc->buflen;
pc.quiet = cgc->quiet;
pc.timeout = cgc->timeout;
pc.sense = cgc->sense;
2127 return cgc->stat = cdrom_queue_packet_command(drive, &pc);
}
static
2131 int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
unsigned int cmd, unsigned long arg)
{
struct cdrom_generic_command cgc;
char buffer[16];
int stat;
init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
/* These will be moved into the Uniform layer shortly... */
2141 switch (cmd) {
2142 case CDROMSETSPINDOWN: {
char spindown;
2145 if (copy_from_user(&spindown, (void *) arg, sizeof(char)))
2146 return -EFAULT;
2148 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2149 return stat;
buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2153 return cdrom_mode_select(cdi, &cgc);
}
2156 case CDROMGETSPINDOWN: {
char spindown;
2159 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2160 return stat;
spindown = buffer[11] & 0x0f;
2164 if (copy_to_user((void *) arg, &spindown, sizeof (char)))
2165 return -EFAULT;
2167 return 0;
}
2170 default:
2171 return -EINVAL;
}
}
static
2177 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
unsigned int cmd, void *arg)
{
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
struct cdrom_info *info = drive->driver_data;
int stat;
2185 switch (cmd) {
/*
* emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
* atapi doesn't support it
*/
2190 case CDROMPLAYTRKIND: {
unsigned long lba_start, lba_end;
struct cdrom_ti *ti = (struct cdrom_ti *)arg;
struct atapi_toc_entry *first_toc, *last_toc;
stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2196 if (stat)
2197 return stat;
stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2200 if (stat)
2201 return stat;
2203 if (ti->cdti_trk1 != CDROM_LEADOUT)
++last_toc;
lba_start = first_toc->addr.lba;
lba_end = last_toc->addr.lba;
2208 if (lba_end <= lba_start)
2209 return -EINVAL;
2211 return cdrom_play_audio(drive, lba_start, lba_end);
}
2214 case CDROMREADTOCHDR: {
struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
struct atapi_toc *toc;
/* Make sure our saved TOC is valid. */
stat = cdrom_read_toc(drive, NULL);
2220 if (stat) return stat;
toc = info->toc;
tochdr->cdth_trk0 = toc->hdr.first_track;
tochdr->cdth_trk1 = toc->hdr.last_track;
2226 return 0;
}
2229 case CDROMREADTOCENTRY: {
struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
struct atapi_toc_entry *toce;
stat = cdrom_get_toc_entry (drive, tocentry->cdte_track, &toce);
2234 if (stat) return stat;
tocentry->cdte_ctrl = toce->control;
tocentry->cdte_adr = toce->adr;
2238 if (tocentry->cdte_format == CDROM_MSF) {
lba_to_msf (toce->addr.lba,
&tocentry->cdte_addr.msf.minute,
&tocentry->cdte_addr.msf.second,
&tocentry->cdte_addr.msf.frame);
2243 } else
tocentry->cdte_addr.lba = toce->addr.lba;
2246 return 0;
}
2249 default:
2250 return -EINVAL;
}
}
static
2255 int ide_cdrom_reset (struct cdrom_device_info *cdi)
{
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
struct request_sense sense;
struct request req;
int ret;
ide_init_drive_cmd (&req);
req.cmd = RESET_DRIVE_COMMAND;
ret = ide_do_drive_cmd(drive, &req, ide_wait);
/*
* A reset will unlock the door. If it was previously locked,
* lock it again.
*/
2270 if (CDROM_STATE_FLAGS(drive)->door_locked)
(void) cdrom_lockdoor(drive, 1, &sense);
2273 return ret;
}
static
2278 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
{
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
struct request_sense sense;
2283 if (position) {
int stat = cdrom_lockdoor(drive, 0, &sense);
2285 if (stat) return stat;
}
2288 return cdrom_eject(drive, !position, &sense);
}
static
2292 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
{
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2295 return cdrom_lockdoor(drive, lock, NULL);
}
static
2299 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
{
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
struct request_sense sense;
int stat;
2305 if ((stat = cdrom_select_speed (drive, speed, &sense)) < 0)
2306 return stat;
cdi->speed = CDROM_STATE_FLAGS (drive)->current_speed;
2309 return 0;
}
static
2313 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
{
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2317 if (slot_nr == CDSL_CURRENT) {
struct request_sense sense;
int stat = cdrom_check_status(drive, &sense);
2320 if (stat == 0 || sense.sense_key == UNIT_ATTENTION)
2321 return CDS_DISC_OK;
if (sense.sense_key == NOT_READY && sense.asc == 0x04 &&
2324 sense.ascq == 0x04)
2325 return CDS_DISC_OK;
2327 if (sense.sense_key == NOT_READY) {
/* ATAPI doesn't have anything that can help
us decide whether the drive is really
emtpy or the tray is just open. irk. */
2331 return CDS_TRAY_OPEN;
}
2334 return CDS_DRIVE_NOT_READY;
}
2336 return -EINVAL;
}
static
2340 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
struct cdrom_multisession *ms_info)
{
struct atapi_toc *toc;
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
struct cdrom_info *info = drive->driver_data;
struct request_sense sense;
int ret;
2349 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2350 if ((ret = cdrom_read_toc(drive, &sense)))
2351 return ret;
toc = info->toc;
ms_info->addr.lba = toc->last_session_lba;
ms_info->xa_flag = toc->xa_flag;
2357 return 0;
}
static
2361 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
struct cdrom_mcn *mcn_info)
{
int stat;
char mcnbuf[24];
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
/* get MCN */
2369 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2370 return stat;
memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
sizeof (mcn_info->medium_catalog_number)-1);
mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
= '\0';
2377 return 0;
}
/****************************************************************************
* Other driver requests (open, close, check media change).
*/
static
2387 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
int slot_nr)
{
ide_drive_t *drive = (ide_drive_t*) cdi->handle;
int retval;
2393 if (slot_nr == CDSL_CURRENT) {
(void) cdrom_check_status(drive, NULL);
retval = CDROM_STATE_FLAGS (drive)->media_changed;
CDROM_STATE_FLAGS (drive)->media_changed = 0;
2397 return retval;
2398 } else {
2399 return -EINVAL;
}
}
static
2405 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
{
2407 return 0;
}
/*
* Close down the device. Invalidate all cached blocks.
*/
static
2416 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
{
}
/****************************************************************************
* Device initialization.
*/
static struct cdrom_device_ops ide_cdrom_dops = {
open: ide_cdrom_open_real,
release: ide_cdrom_release_real,
drive_status: ide_cdrom_drive_status,
media_changed: ide_cdrom_check_media_change_real,
tray_move: ide_cdrom_tray_move,
lock_door: ide_cdrom_lock_door,
select_speed: ide_cdrom_select_speed,
get_last_session: ide_cdrom_get_last_session,
get_mcn: ide_cdrom_get_mcn,
reset: ide_cdrom_reset,
audio_ioctl: ide_cdrom_audio_ioctl,
dev_ioctl: ide_cdrom_dev_ioctl,
capability: CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
CDC_SELECT_SPEED | CDC_SELECT_DISC |
CDC_MULTI_SESSION | CDC_MCN |
CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
CDC_GENERIC_PACKET,
generic_packet: ide_cdrom_packet,
};
2448 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
{
struct cdrom_info *info = drive->driver_data;
struct cdrom_device_info *devinfo = &info->devinfo;
int minor = (drive->select.b.unit) << PARTN_BITS;
devinfo->dev = MKDEV (HWIF(drive)->major, minor);
devinfo->ops = &ide_cdrom_dops;
devinfo->mask = 0;
*(int *)&devinfo->speed = CDROM_STATE_FLAGS (drive)->current_speed;
*(int *)&devinfo->capacity = nslots;
devinfo->handle = (void *) drive;
strcpy(devinfo->name, drive->name);
/* set capability mask to match the probe. */
2463 if (!CDROM_CONFIG_FLAGS (drive)->cd_r)
devinfo->mask |= CDC_CD_R;
2465 if (!CDROM_CONFIG_FLAGS (drive)->cd_rw)
devinfo->mask |= CDC_CD_RW;
2467 if (!CDROM_CONFIG_FLAGS (drive)->dvd)
devinfo->mask |= CDC_DVD;
2469 if (!CDROM_CONFIG_FLAGS (drive)->dvd_r)
devinfo->mask |= CDC_DVD_R;
2471 if (!CDROM_CONFIG_FLAGS (drive)->dvd_ram)
devinfo->mask |= CDC_DVD_RAM;
2473 if (!CDROM_CONFIG_FLAGS (drive)->is_changer)
devinfo->mask |= CDC_SELECT_DISC;
2475 if (!CDROM_CONFIG_FLAGS (drive)->audio_play)
devinfo->mask |= CDC_PLAY_AUDIO;
2477 if (!CDROM_CONFIG_FLAGS (drive)->close_tray)
devinfo->mask |= CDC_CLOSE_TRAY;
devinfo->de = devfs_register(drive->de, "cd", DEVFS_FL_DEFAULT,
HWIF(drive)->major, minor,
S_IFBLK | S_IRUGO | S_IWUGO,
ide_fops, NULL);
2485 return register_cdrom(devinfo);
}
static
2489 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
{
struct cdrom_info *info = drive->driver_data;
struct cdrom_device_info *cdi = &info->devinfo;
struct cdrom_generic_command cgc;
int stat, attempts = 3, size = sizeof(*cap);
/*
* ACER50 (and others?) require the full spec length mode sense
* page capabilities size, but older drives break.
*/
2500 if (drive->id) {
if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2502 !strcmp(drive->id->model, "WPI CDS-32X")))
size -= sizeof(cap->pad);
}
/* we have to cheat a little here. the packet will eventually
* be queued with ide_cdrom_packet(), which extracts the
* drive from cdi->handle. Since this device hasn't been
* registered with the Uniform layer yet, it can't do this.
* Same goes for cdi->ops.
*/
cdi->handle = (ide_drive_t *) drive;
cdi->ops = &ide_cdrom_dops;
init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2515 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2517 if (!stat)
2518 break;
2519 } while (--attempts);
2520 return stat;
}
static
2524 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
{
struct cdrom_info *info = drive->driver_data;
struct cdrom_device_info *cdi = &info->devinfo;
struct atapi_capabilities_page cap;
int nslots = 1;
2531 if (CDROM_CONFIG_FLAGS (drive)->nec260) {
CDROM_CONFIG_FLAGS (drive)->no_eject = 0;
CDROM_CONFIG_FLAGS (drive)->audio_play = 1;
2534 return nslots;
}
2537 if (ide_cdrom_get_capabilities(drive, &cap))
2538 return 0;
2540 if (cap.lock == 0)
CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
2542 if (cap.eject)
CDROM_CONFIG_FLAGS (drive)->no_eject = 0;
2544 if (cap.cd_r_write)
CDROM_CONFIG_FLAGS (drive)->cd_r = 1;
2546 if (cap.cd_rw_write)
CDROM_CONFIG_FLAGS (drive)->cd_rw = 1;
2548 if (cap.test_write)
CDROM_CONFIG_FLAGS (drive)->test_write = 1;
2550 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
CDROM_CONFIG_FLAGS (drive)->dvd = 1;
2552 if (cap.dvd_ram_write)
CDROM_CONFIG_FLAGS (drive)->dvd_ram = 1;
2554 if (cap.dvd_r_write)
CDROM_CONFIG_FLAGS (drive)->dvd_r = 1;
2556 if (cap.audio_play)
CDROM_CONFIG_FLAGS (drive)->audio_play = 1;
2558 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
CDROM_CONFIG_FLAGS (drive)->close_tray = 0;
#if ! STANDARD_ATAPI
2562 if (cdi->sanyo_slot > 0) {
CDROM_CONFIG_FLAGS (drive)->is_changer = 1;
nslots = 3;
}
else
#endif /* not STANDARD_ATAPI */
if (cap.mechtype == mechtype_individual_changer ||
2570 cap.mechtype == mechtype_cartridge_changer) {
2571 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
CDROM_CONFIG_FLAGS (drive)->is_changer = 1;
CDROM_CONFIG_FLAGS (drive)->supp_disc_present = 1;
}
}
/* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2578 if (drive->id && !drive->id->model[0] && !strncmp(drive->id->fw_rev, "241N", 4)) {
CDROM_STATE_FLAGS (drive)->current_speed =
(((unsigned int)cap.curspeed) + (176/2)) / 176;
CDROM_CONFIG_FLAGS (drive)->max_speed =
(((unsigned int)cap.maxspeed) + (176/2)) / 176;
2583 } else {
CDROM_STATE_FLAGS (drive)->current_speed =
(ntohs(cap.curspeed) + (176/2)) / 176;
CDROM_CONFIG_FLAGS (drive)->max_speed =
(ntohs(cap.maxspeed) + (176/2)) / 176;
}
/* don't print speed if the drive reported 0.
*/
printk("%s: ATAPI", drive->name);
2593 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
2597 if (CDROM_CONFIG_FLAGS (drive)->dvd_r|CDROM_CONFIG_FLAGS (drive)->dvd_ram)
printk (" DVD%s%s",
(CDROM_CONFIG_FLAGS (drive)->dvd_r)? "-R" : "",
(CDROM_CONFIG_FLAGS (drive)->dvd_ram)? "AM" : "");
2602 if (CDROM_CONFIG_FLAGS (drive)->cd_r|CDROM_CONFIG_FLAGS (drive)->cd_rw)
printk (" CD%s%s",
(CDROM_CONFIG_FLAGS (drive)->cd_r)? "-R" : "",
(CDROM_CONFIG_FLAGS (drive)->cd_rw)? "/RW" : "");
2607 if (CDROM_CONFIG_FLAGS (drive)->is_changer)
printk (" changer w/%d slots", nslots);
2609 else
printk (" drive");
printk (", %dkB Cache", be16_to_cpu(cap.buffer_size));
#ifdef CONFIG_BLK_DEV_IDEDMA
if (drive->using_dma)
(void) HWIF(drive)->dmaproc(ide_dma_verbose, drive);
#endif /* CONFIG_BLK_DEV_IDEDMA */
printk("\n");
2620 return nslots;
}
2623 static void ide_cdrom_add_settings(ide_drive_t *drive)
{
int major = HWIF(drive)->major;
int minor = drive->select.b.unit << PARTN_BITS;
ide_add_setting(drive, "breada_readahead", SETTING_RW, BLKRAGET, BLKRASET, TYPE_INT, 0, 255, 1, 2, &read_ahead[major], NULL);
ide_add_setting(drive, "file_readahead", SETTING_RW, BLKFRAGET, BLKFRASET, TYPE_INTA, 0, INT_MAX, 1, 1024, &max_readahead[major][minor], NULL);
ide_add_setting(drive, "max_kb_per_request", SETTING_RW, BLKSECTGET, BLKSECTSET, TYPE_INTA, 1, 255, 1, 2, &max_sectors[major][minor], NULL);
ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
}
static
2635 int ide_cdrom_setup (ide_drive_t *drive)
{
struct cdrom_info *info = drive->driver_data;
struct cdrom_device_info *cdi = &info->devinfo;
int minor = drive->select.b.unit << PARTN_BITS;
int nslots;
/*
* default to read-only always and fix latter at the bottom
*/
set_device_ro(MKDEV(HWIF(drive)->major, minor), 1);
set_blocksize(MKDEV(HWIF(drive)->major, minor), CD_FRAMESIZE);
drive->special.all = 0;
drive->ready_stat = 0;
CDROM_STATE_FLAGS (drive)->media_changed = 1;
CDROM_STATE_FLAGS (drive)->toc_valid = 0;
CDROM_STATE_FLAGS (drive)->door_locked = 0;
#if NO_DOOR_LOCKING
CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
#else
CDROM_CONFIG_FLAGS (drive)->no_doorlock = 0;
#endif
2661 if (drive->id != NULL)
CDROM_CONFIG_FLAGS (drive)->drq_interrupt =
((drive->id->config & 0x0060) == 0x20);
2664 else
CDROM_CONFIG_FLAGS (drive)->drq_interrupt = 0;
CDROM_CONFIG_FLAGS (drive)->is_changer = 0;
CDROM_CONFIG_FLAGS (drive)->cd_r = 0;
CDROM_CONFIG_FLAGS (drive)->cd_rw = 0;
CDROM_CONFIG_FLAGS (drive)->test_write = 0;
CDROM_CONFIG_FLAGS (drive)->dvd = 0;
CDROM_CONFIG_FLAGS (drive)->dvd_r = 0;
CDROM_CONFIG_FLAGS (drive)->dvd_ram = 0;
CDROM_CONFIG_FLAGS (drive)->no_eject = 1;
CDROM_CONFIG_FLAGS (drive)->supp_disc_present = 0;
CDROM_CONFIG_FLAGS (drive)->audio_play = 0;
CDROM_CONFIG_FLAGS (drive)->close_tray = 1;
/* limit transfer size per interrupt. */
CDROM_CONFIG_FLAGS (drive)->limit_nframes = 0;
2681 if (drive->id != NULL) {
/* a testament to the nice quality of Samsung drives... */
2683 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
CDROM_CONFIG_FLAGS (drive)->limit_nframes = 1;
2685 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
CDROM_CONFIG_FLAGS (drive)->limit_nframes = 1;
/* the 3231 model does not support the SET_CD_SPEED command */
2688 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
cdi->mask |= CDC_SELECT_SPEED;
}
#if ! STANDARD_ATAPI
/* by default Sanyo 3 CD changer support is turned off and
ATAPI Rev 2.2+ standard support for CD changers is used */
cdi->sanyo_slot = 0;
CDROM_CONFIG_FLAGS (drive)->nec260 = 0;
CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd = 0;
CDROM_CONFIG_FLAGS (drive)->tocaddr_as_bcd = 0;
CDROM_CONFIG_FLAGS (drive)->playmsf_as_bcd = 0;
CDROM_CONFIG_FLAGS (drive)->subchan_as_bcd = 0;
2703 if (drive->id != NULL) {
if (strcmp (drive->id->model, "V003S0DS") == 0 &&
drive->id->fw_rev[4] == '1' &&
2706 drive->id->fw_rev[6] <= '2') {
/* Vertos 300.
Some versions of this drive like to talk BCD. */
CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd = 1;
CDROM_CONFIG_FLAGS (drive)->tocaddr_as_bcd = 1;
CDROM_CONFIG_FLAGS (drive)->playmsf_as_bcd = 1;
CDROM_CONFIG_FLAGS (drive)->subchan_as_bcd = 1;
}
else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
drive->id->fw_rev[4] == '1' &&
2717 drive->id->fw_rev[6] <= '2') {
/* Vertos 600 ESD. */
CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd = 1;
}
else if (strcmp (drive->id->model,
"NEC CD-ROM DRIVE:260") == 0 &&
2724 strncmp (drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
/* Old NEC260 (not R).
This drive was released before the 1.2 version
of the spec. */
CDROM_CONFIG_FLAGS (drive)->tocaddr_as_bcd = 1;
CDROM_CONFIG_FLAGS (drive)->playmsf_as_bcd = 1;
CDROM_CONFIG_FLAGS (drive)->subchan_as_bcd = 1;
CDROM_CONFIG_FLAGS (drive)->nec260 = 1;
}
else if (strcmp (drive->id->model, "WEARNES CDD-120") == 0 &&
2735 strncmp (drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
/* Wearnes */
CDROM_CONFIG_FLAGS (drive)->playmsf_as_bcd = 1;
CDROM_CONFIG_FLAGS (drive)->subchan_as_bcd = 1;
}
/* Sanyo 3 CD changer uses a non-standard command
for CD changing */
else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
(strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
2745 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
/* uses CD in slot 0 when value is set to 3 */
cdi->sanyo_slot = 3;
}
}
#endif /* not STANDARD_ATAPI */
info->toc = NULL;
info->buffer = NULL;
info->sector_buffered = 0;
info->nsectors_buffered = 0;
info->changer_info = NULL;
info->last_block = 0;
info->start_seek = 0;
nslots = ide_cdrom_probe_capabilities (drive);
2764 if (CDROM_CONFIG_FLAGS(drive)->dvd_ram)
set_device_ro(MKDEV(HWIF(drive)->major, minor), 0);
2767 if (ide_cdrom_register (drive, nslots)) {
printk ("%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
info->devinfo.handle = NULL;
2770 return 1;
}
ide_cdrom_add_settings(drive);
2773 return 0;
}
/* Forwarding functions to generic routines. */
static
2778 int ide_cdrom_ioctl (ide_drive_t *drive,
struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
2782 return cdrom_fops.ioctl (inode, file, cmd, arg);
}
static
2786 int ide_cdrom_open (struct inode *ip, struct file *fp, ide_drive_t *drive)
{
struct cdrom_info *info = drive->driver_data;
int rc;
2791 MOD_INC_USE_COUNT;
2792 if (info->buffer == NULL)
info->buffer = (char *) kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL);
2794 if ((rc = cdrom_fops.open(ip, fp))) {
drive->usage--;
2796 MOD_DEC_USE_COUNT;
}
2798 return rc;
}
static
2802 void ide_cdrom_release (struct inode *inode, struct file *file,
ide_drive_t *drive)
{
cdrom_fops.release (inode, file);
2806 MOD_DEC_USE_COUNT;
}
static
2810 int ide_cdrom_check_media_change (ide_drive_t *drive)
{
return cdrom_fops.check_media_change(MKDEV (HWIF (drive)->major,
2813 (drive->select.b.unit) << PARTN_BITS));
}
static
2817 void ide_cdrom_revalidate (ide_drive_t *drive)
{
struct cdrom_info *info = drive->driver_data;
struct atapi_toc *toc;
int minor = drive->select.b.unit << PARTN_BITS;
struct request_sense sense;
cdrom_read_toc(drive, &sense);
2826 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2827 return;
toc = info->toc;
/* for general /dev/cdrom like mounting, one big disc */
drive->part[0].nr_sects = toc->capacity * SECTORS_PER_FRAME;
HWIF(drive)->gd->sizes[minor] = toc->capacity * BLOCKS_PER_FRAME;
blk_size[HWIF(drive)->major] = HWIF(drive)->gd->sizes;
}
static
2839 unsigned long ide_cdrom_capacity (ide_drive_t *drive)
{
unsigned capacity;
2843 if (cdrom_read_capacity(drive, &capacity, NULL))
2844 return 0;
2846 return capacity * SECTORS_PER_FRAME;
}
static
2850 int ide_cdrom_cleanup(ide_drive_t *drive)
{
struct cdrom_info *info = drive->driver_data;
struct cdrom_device_info *devinfo = &info->devinfo;
2855 if (ide_unregister_subdriver (drive))
2856 return 1;
2857 if (info->buffer != NULL)
kfree(info->buffer);
2859 if (info->toc != NULL)
kfree(info->toc);
2861 if (info->changer_info != NULL)
kfree(info->changer_info);
2863 if (devinfo->handle == drive && unregister_cdrom (devinfo))
printk ("%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
kfree(info);
drive->driver_data = NULL;
2867 return 0;
}
static ide_driver_t ide_cdrom_driver = {
name: "ide-cdrom",
version: IDECD_VERSION,
media: ide_cdrom,
supports_dma: 1,
supports_dsc_overlap: 1,
cleanup: ide_cdrom_cleanup,
do_request: ide_do_rw_cdrom,
ioctl: ide_cdrom_ioctl,
open: ide_cdrom_open,
release: ide_cdrom_release,
media_change: ide_cdrom_check_media_change,
revalidate: ide_cdrom_revalidate,
capacity: ide_cdrom_capacity,
};
int ide_cdrom_init(void);
static ide_module_t ide_cdrom_module = {
IDE_DRIVER_MODULE,
ide_cdrom_init,
&ide_cdrom_driver,
NULL
};
/* options */
char *ignore = NULL;
MODULE_PARM(ignore, "s");
MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2900 static void __exit ide_cdrom_exit(void)
{
ide_drive_t *drive;
int failed = 0;
2905 while ((drive = ide_scan_devices (ide_cdrom, ide_cdrom_driver.name, &ide_cdrom_driver, failed)) != NULL)
2906 if (ide_cdrom_cleanup (drive)) {
printk ("%s: cleanup_module() called while still busy\n", drive->name);
failed++;
}
ide_unregister_module (&ide_cdrom_module);
}
2913 int ide_cdrom_init(void)
{
ide_drive_t *drive;
struct cdrom_info *info;
int failed = 0;
2919 MOD_INC_USE_COUNT;
2920 while ((drive = ide_scan_devices (ide_cdrom, ide_cdrom_driver.name, NULL, failed++)) != NULL) {
/* skip drives that we were told to ignore */
2922 if (ignore != NULL) {
2923 if (strstr(ignore, drive->name)) {
printk("ide-cd: ignoring drive %s\n", drive->name);
2925 continue;
}
}
2928 if (drive->scsi) {
printk("ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2930 continue;
}
info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
2933 if (info == NULL) {
printk ("%s: Can't allocate a cdrom structure\n", drive->name);
2935 continue;
}
2937 if (ide_register_subdriver (drive, &ide_cdrom_driver, IDE_SUBDRIVER_VERSION)) {
printk ("%s: Failed to register the driver with ide.c\n", drive->name);
kfree (info);
2940 continue;
}
memset (info, 0, sizeof (struct cdrom_info));
drive->driver_data = info;
DRIVER(drive)->busy++;
2945 if (ide_cdrom_setup (drive)) {
DRIVER(drive)->busy--;
2947 if (ide_cdrom_cleanup (drive))
printk ("%s: ide_cdrom_cleanup failed in ide_cdrom_init\n", drive->name);
2949 continue;
}
DRIVER(drive)->busy--;
failed--;
}
ide_register_module(&ide_cdrom_module);
2955 MOD_DEC_USE_COUNT;
2956 return 0;
}
module_init(ide_cdrom_init);
module_exit(ide_cdrom_exit);