PageRenderTime 181ms CodeModel.GetById 13ms app.highlight 146ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/cdrom/cdrom.c

https://bitbucket.org/evzijst/gittest
C | 3397 lines | 2375 code | 467 blank | 555 comment | 502 complexity | 6987ca460554be23112dfc0c58ed2b11 MD5 | raw file
   1/* linux/drivers/cdrom/cdrom.c. 
   2   Copyright (c) 1996, 1997 David A. van Leeuwen.
   3   Copyright (c) 1997, 1998 Erik Andersen <andersee@debian.org>
   4   Copyright (c) 1998, 1999 Jens Axboe <axboe@image.dk>
   5
   6   May be copied or modified under the terms of the GNU General Public
   7   License.  See linux/COPYING for more information.
   8
   9   Uniform CD-ROM driver for Linux.
  10   See Documentation/cdrom/cdrom-standard.tex for usage information.
  11
  12   The routines in the file provide a uniform interface between the
  13   software that uses CD-ROMs and the various low-level drivers that
  14   actually talk to the hardware. Suggestions are welcome.
  15   Patches that work are more welcome though.  ;-)
  16
  17 To Do List:
  18 ----------------------------------
  19
  20 -- Modify sysctl/proc interface. I plan on having one directory per
  21 drive, with entries for outputing general drive information, and sysctl
  22 based tunable parameters such as whether the tray should auto-close for
  23 that drive. Suggestions (or patches) for this welcome!
  24
  25
  26 Revision History
  27 ----------------------------------
  28 1.00  Date Unknown -- David van Leeuwen <david@tm.tno.nl>
  29 -- Initial version by David A. van Leeuwen. I don't have a detailed
  30  changelog for the 1.x series, David?
  31
  322.00  Dec  2, 1997 -- Erik Andersen <andersee@debian.org>
  33  -- New maintainer! As David A. van Leeuwen has been too busy to activly
  34  maintain and improve this driver, I am now carrying on the torch. If
  35  you have a problem with this driver, please feel free to contact me.
  36
  37  -- Added (rudimentary) sysctl interface. I realize this is really weak
  38  right now, and is _very_ badly implemented. It will be improved...
  39
  40  -- Modified CDROM_DISC_STATUS so that it is now incorporated into
  41  the Uniform CD-ROM driver via the cdrom_count_tracks function.
  42  The cdrom_count_tracks function helps resolve some of the false
  43  assumptions of the CDROM_DISC_STATUS ioctl, and is also used to check
  44  for the correct media type when mounting or playing audio from a CD.
  45
  46  -- Remove the calls to verify_area and only use the copy_from_user and
  47  copy_to_user stuff, since these calls now provide their own memory
  48  checking with the 2.1.x kernels.
  49
  50  -- Major update to return codes so that errors from low-level drivers
  51  are passed on through (thanks to Gerd Knorr for pointing out this
  52  problem).
  53
  54  -- Made it so if a function isn't implemented in a low-level driver,
  55  ENOSYS is now returned instead of EINVAL.
  56
  57  -- Simplified some complex logic so that the source code is easier to read.
  58
  59  -- Other stuff I probably forgot to mention (lots of changes).
  60
  612.01 to 2.11 Dec 1997-Jan 1998
  62  -- TO-DO!  Write changelogs for 2.01 to 2.12.
  63
  642.12  Jan  24, 1998 -- Erik Andersen <andersee@debian.org>
  65  -- Fixed a bug in the IOCTL_IN and IOCTL_OUT macros.  It turns out that
  66  copy_*_user does not return EFAULT on error, but instead returns the number 
  67  of bytes not copied.  I was returning whatever non-zero stuff came back from 
  68  the copy_*_user functions directly, which would result in strange errors.
  69
  702.13  July 17, 1998 -- Erik Andersen <andersee@debian.org>
  71  -- Fixed a bug in CDROM_SELECT_SPEED where you couldn't lower the speed
  72  of the drive.  Thanks to Tobias Ringstr|m <tori@prosolvia.se> for pointing
  73  this out and providing a simple fix.
  74  -- Fixed the procfs-unload-module bug with the fill_inode procfs callback.
  75  thanks to Andrea Arcangeli
  76  -- Fixed it so that the /proc entry now also shows up when cdrom is
  77  compiled into the kernel.  Before it only worked when loaded as a module.
  78
  79  2.14 August 17, 1998 -- Erik Andersen <andersee@debian.org>
  80  -- Fixed a bug in cdrom_media_changed and handling of reporting that
  81  the media had changed for devices that _don't_ implement media_changed.  
  82  Thanks to Grant R. Guenther <grant@torque.net> for spotting this bug.
  83  -- Made a few things more pedanticly correct.
  84
  852.50 Oct 19, 1998 - Jens Axboe <axboe@image.dk>
  86  -- New maintainers! Erik was too busy to continue the work on the driver,
  87  so now Chris Zwilling <chris@cloudnet.com> and Jens Axboe <axboe@image.dk>
  88  will do their best to follow in his footsteps
  89  
  90  2.51 Dec 20, 1998 - Jens Axboe <axboe@image.dk>
  91  -- Check if drive is capable of doing what we ask before blindly changing
  92  cdi->options in various ioctl.
  93  -- Added version to proc entry.
  94  
  95  2.52 Jan 16, 1999 - Jens Axboe <axboe@image.dk>
  96  -- Fixed an error in open_for_data where we would sometimes not return
  97  the correct error value. Thanks Huba Gaspar <huba@softcell.hu>.
  98  -- Fixed module usage count - usage was based on /proc/sys/dev
  99  instead of /proc/sys/dev/cdrom. This could lead to an oops when other
 100  modules had entries in dev. Feb 02 - real bug was in sysctl.c where
 101  dev would be removed even though it was used. cdrom.c just illuminated
 102  that bug.
 103  
 104  2.53 Feb 22, 1999 - Jens Axboe <axboe@image.dk>
 105  -- Fixup of several ioctl calls, in particular CDROM_SET_OPTIONS has
 106  been "rewritten" because capabilities and options aren't in sync. They
 107  should be...
 108  -- Added CDROM_LOCKDOOR ioctl. Locks the door and keeps it that way.
 109  -- Added CDROM_RESET ioctl.
 110  -- Added CDROM_DEBUG ioctl. Enable debug messages on-the-fly.
 111  -- Added CDROM_GET_CAPABILITY ioctl. This relieves userspace programs
 112  from parsing /proc/sys/dev/cdrom/info.
 113  
 114  2.54 Mar 15, 1999 - Jens Axboe <axboe@image.dk>
 115  -- Check capability mask from low level driver when counting tracks as
 116  per suggestion from Corey J. Scotts <cstotts@blue.weeg.uiowa.edu>.
 117  
 118  2.55 Apr 25, 1999 - Jens Axboe <axboe@image.dk>
 119  -- autoclose was mistakenly checked against CDC_OPEN_TRAY instead of
 120  CDC_CLOSE_TRAY.
 121  -- proc info didn't mask against capabilities mask.
 122  
 123  3.00 Aug 5, 1999 - Jens Axboe <axboe@image.dk>
 124  -- Unified audio ioctl handling across CD-ROM drivers. A lot of the
 125  code was duplicated before. Drives that support the generic packet
 126  interface are now being fed packets from here instead.
 127  -- First attempt at adding support for MMC2 commands - for DVD and
 128  CD-R(W) drives. Only the DVD parts are in now - the interface used is
 129  the same as for the audio ioctls.
 130  -- ioctl cleanups. if a drive couldn't play audio, it didn't get
 131  a change to perform device specific ioctls as well.
 132  -- Defined CDROM_CAN(CDC_XXX) for checking the capabilities.
 133  -- Put in sysctl files for autoclose, autoeject, check_media, debug,
 134  and lock.
 135  -- /proc/sys/dev/cdrom/info has been updated to also contain info about
 136  CD-Rx and DVD capabilities.
 137  -- Now default to checking media type.
 138  -- CDROM_SEND_PACKET ioctl added. The infrastructure was in place for
 139  doing this anyway, with the generic_packet addition.
 140  
 141  3.01 Aug 6, 1999 - Jens Axboe <axboe@image.dk>
 142  -- Fix up the sysctl handling so that the option flags get set
 143  correctly.
 144  -- Fix up ioctl handling so the device specific ones actually get
 145  called :).
 146  
 147  3.02 Aug 8, 1999 - Jens Axboe <axboe@image.dk>
 148  -- Fixed volume control on SCSI drives (or others with longer audio
 149  page).
 150  -- Fixed a couple of DVD minors. Thanks to Andrew T. Veliath
 151  <andrewtv@usa.net> for telling me and for having defined the various
 152  DVD structures and ioctls in the first place! He designed the original
 153  DVD patches for ide-cd and while I rearranged and unified them, the
 154  interface is still the same.
 155  
 156  3.03 Sep 1, 1999 - Jens Axboe <axboe@image.dk>
 157  -- Moved the rest of the audio ioctls from the CD-ROM drivers here. Only
 158  CDROMREADTOCENTRY and CDROMREADTOCHDR are left.
 159  -- Moved the CDROMREADxxx ioctls in here.
 160  -- Defined the cdrom_get_last_written and cdrom_get_next_block as ioctls
 161  and exported functions.
 162  -- Erik Andersen <andersen@xmission.com> modified all SCMD_ commands
 163  to now read GPCMD_ for the new generic packet interface. All low level
 164  drivers are updated as well.
 165  -- Various other cleanups.
 166
 167  3.04 Sep 12, 1999 - Jens Axboe <axboe@image.dk>
 168  -- Fixed a couple of possible memory leaks (if an operation failed and
 169  we didn't free the buffer before returning the error).
 170  -- Integrated Uniform CD Changer handling from Richard Sharman
 171  <rsharman@pobox.com>.
 172  -- Defined CD_DVD and CD_CHANGER log levels.
 173  -- Fixed the CDROMREADxxx ioctls.
 174  -- CDROMPLAYTRKIND uses the GPCMD_PLAY_AUDIO_MSF command - too few
 175  drives supported it. We lose the index part, however.
 176  -- Small modifications to accommodate opens of /dev/hdc1, required
 177  for ide-cd to handle multisession discs.
 178  -- Export cdrom_mode_sense and cdrom_mode_select.
 179  -- init_cdrom_command() for setting up a cgc command.
 180  
 181  3.05 Oct 24, 1999 - Jens Axboe <axboe@image.dk>
 182  -- Changed the interface for CDROM_SEND_PACKET. Before it was virtually
 183  impossible to send the drive data in a sensible way.
 184  -- Lowered stack usage in mmc_ioctl(), dvd_read_disckey(), and
 185  dvd_read_manufact.
 186  -- Added setup of write mode for packet writing.
 187  -- Fixed CDDA ripping with cdda2wav - accept much larger requests of
 188  number of frames and split the reads in blocks of 8.
 189
 190  3.06 Dec 13, 1999 - Jens Axboe <axboe@image.dk>
 191  -- Added support for changing the region of DVD drives.
 192  -- Added sense data to generic command.
 193
 194  3.07 Feb 2, 2000 - Jens Axboe <axboe@suse.de>
 195  -- Do same "read header length" trick in cdrom_get_disc_info() as
 196  we do in cdrom_get_track_info() -- some drive don't obey specs and
 197  fail if they can't supply the full Mt Fuji size table.
 198  -- Deleted stuff related to setting up write modes. It has a different
 199  home now.
 200  -- Clear header length in mode_select unconditionally.
 201  -- Removed the register_disk() that was added, not needed here.
 202
 203  3.08 May 1, 2000 - Jens Axboe <axboe@suse.de>
 204  -- Fix direction flag in setup_send_key and setup_report_key. This
 205  gave some SCSI adapters problems.
 206  -- Always return -EROFS for write opens
 207  -- Convert to module_init/module_exit style init and remove some
 208  of the #ifdef MODULE stuff
 209  -- Fix several dvd errors - DVD_LU_SEND_ASF should pass agid,
 210  DVD_HOST_SEND_RPC_STATE did not set buffer size in cdb, and
 211  dvd_do_auth passed uninitialized data to drive because init_cdrom_command
 212  did not clear a 0 sized buffer.
 213  
 214  3.09 May 12, 2000 - Jens Axboe <axboe@suse.de>
 215  -- Fix Video-CD on SCSI drives that don't support READ_CD command. In
 216  that case switch block size and issue plain READ_10 again, then switch
 217  back.
 218
 219  3.10 Jun 10, 2000 - Jens Axboe <axboe@suse.de>
 220  -- Fix volume control on CD's - old SCSI-II drives now use their own
 221  code, as doing MODE6 stuff in here is really not my intention.
 222  -- Use READ_DISC_INFO for more reliable end-of-disc.
 223
 224  3.11 Jun 12, 2000 - Jens Axboe <axboe@suse.de>
 225  -- Fix bug in getting rpc phase 2 region info.
 226  -- Reinstate "correct" CDROMPLAYTRKIND
 227
 228   3.12 Oct 18, 2000 - Jens Axboe <axboe@suse.de>
 229  -- Use quiet bit on packet commands not known to work
 230
 231   3.20 Dec 17, 2003 - Jens Axboe <axboe@suse.de>
 232  -- Various fixes and lots of cleanups not listed :-)
 233  -- Locking fixes
 234  -- Mt Rainier support
 235  -- DVD-RAM write open fixes
 236
 237  Nov 5 2001, Aug 8 2002. Modified by Andy Polyakov
 238  <appro@fy.chalmers.se> to support MMC-3 compliant DVD+RW units.
 239
 240  Modified by Nigel Kukard <nkukard@lbsd.net> - support DVD+RW
 241  2.4.x patch by Andy Polyakov <appro@fy.chalmers.se>
 242
 243-------------------------------------------------------------------------*/
 244
 245#define REVISION "Revision: 3.20"
 246#define VERSION "Id: cdrom.c 3.20 2003/12/17"
 247
 248/* I use an error-log mask to give fine grain control over the type of
 249   messages dumped to the system logs.  The available masks include: */
 250#define CD_NOTHING      0x0
 251#define CD_WARNING	0x1
 252#define CD_REG_UNREG	0x2
 253#define CD_DO_IOCTL	0x4
 254#define CD_OPEN		0x8
 255#define CD_CLOSE	0x10
 256#define CD_COUNT_TRACKS 0x20
 257#define CD_CHANGER	0x40
 258#define CD_DVD		0x80
 259
 260/* Define this to remove _all_ the debugging messages */
 261/* #define ERRLOGMASK CD_NOTHING */
 262#define ERRLOGMASK CD_WARNING
 263/* #define ERRLOGMASK (CD_WARNING|CD_OPEN|CD_COUNT_TRACKS|CD_CLOSE) */
 264/* #define ERRLOGMASK (CD_WARNING|CD_REG_UNREG|CD_DO_IOCTL|CD_OPEN|CD_CLOSE|CD_COUNT_TRACKS) */
 265
 266#include <linux/config.h>
 267#include <linux/module.h>
 268#include <linux/fs.h>
 269#include <linux/buffer_head.h>
 270#include <linux/major.h>
 271#include <linux/types.h>
 272#include <linux/errno.h>
 273#include <linux/kernel.h>
 274#include <linux/mm.h>
 275#include <linux/slab.h> 
 276#include <linux/cdrom.h>
 277#include <linux/sysctl.h>
 278#include <linux/proc_fs.h>
 279#include <linux/blkpg.h>
 280#include <linux/init.h>
 281#include <linux/fcntl.h>
 282#include <linux/blkdev.h>
 283#include <linux/times.h>
 284
 285#include <asm/uaccess.h>
 286
 287/* used to tell the module to turn on full debugging messages */
 288static int debug;
 289/* used to keep tray locked at all times */
 290static int keeplocked;
 291/* default compatibility mode */
 292static int autoclose=1;
 293static int autoeject;
 294static int lockdoor = 1;
 295/* will we ever get to use this... sigh. */
 296static int check_media_type;
 297/* automatically restart mrw format */
 298static int mrw_format_restart = 1;
 299module_param(debug, bool, 0);
 300module_param(autoclose, bool, 0);
 301module_param(autoeject, bool, 0);
 302module_param(lockdoor, bool, 0);
 303module_param(check_media_type, bool, 0);
 304module_param(mrw_format_restart, bool, 0);
 305
 306static DEFINE_SPINLOCK(cdrom_lock);
 307
 308static const char *mrw_format_status[] = {
 309	"not mrw",
 310	"bgformat inactive",
 311	"bgformat active",
 312	"mrw complete",
 313};
 314
 315static const char *mrw_address_space[] = { "DMA", "GAA" };
 316
 317#if (ERRLOGMASK!=CD_NOTHING)
 318#define cdinfo(type, fmt, args...) \
 319        if ((ERRLOGMASK & type) || debug==1 ) \
 320            printk(KERN_INFO "cdrom: " fmt, ## args)
 321#else
 322#define cdinfo(type, fmt, args...) 
 323#endif
 324
 325/* These are used to simplify getting data in from and back to user land */
 326#define IOCTL_IN(arg, type, in)					\
 327	if (copy_from_user(&(in), (type __user *) (arg), sizeof (in)))	\
 328		return -EFAULT;
 329
 330#define IOCTL_OUT(arg, type, out) \
 331	if (copy_to_user((type __user *) (arg), &(out), sizeof (out)))	\
 332		return -EFAULT;
 333
 334/* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
 335   a lot of places. This macro makes the code more clear. */
 336#define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
 337
 338/* used in the audio ioctls */
 339#define CHECKAUDIO if ((ret=check_for_audio_disc(cdi, cdo))) return ret
 340
 341/* Not-exported routines. */
 342static int open_for_data(struct cdrom_device_info * cdi);
 343static int check_for_audio_disc(struct cdrom_device_info * cdi,
 344			 struct cdrom_device_ops * cdo);
 345static void sanitize_format(union cdrom_addr *addr, 
 346		u_char * curr, u_char requested);
 347static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
 348		     unsigned long arg);
 349
 350int cdrom_get_last_written(struct cdrom_device_info *, long *);
 351static int cdrom_get_next_writable(struct cdrom_device_info *, long *);
 352static void cdrom_count_tracks(struct cdrom_device_info *, tracktype*);
 353
 354static int cdrom_mrw_exit(struct cdrom_device_info *cdi);
 355
 356static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di);
 357
 358#ifdef CONFIG_SYSCTL
 359static void cdrom_sysctl_register(void);
 360#endif /* CONFIG_SYSCTL */ 
 361static struct cdrom_device_info *topCdromPtr;
 362
 363static int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
 364				      struct packet_command *cgc)
 365{
 366	if (cgc->sense) {
 367		cgc->sense->sense_key = 0x05;
 368		cgc->sense->asc = 0x20;
 369		cgc->sense->ascq = 0x00;
 370	}
 371
 372	cgc->stat = -EIO;
 373	return -EIO;
 374}
 375
 376/* This macro makes sure we don't have to check on cdrom_device_ops
 377 * existence in the run-time routines below. Change_capability is a
 378 * hack to have the capability flags defined const, while we can still
 379 * change it here without gcc complaining at every line.
 380 */
 381#define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
 382
 383int register_cdrom(struct cdrom_device_info *cdi)
 384{
 385	static char banner_printed;
 386        struct cdrom_device_ops *cdo = cdi->ops;
 387        int *change_capability = (int *)&cdo->capability; /* hack */
 388
 389	cdinfo(CD_OPEN, "entering register_cdrom\n"); 
 390
 391	if (cdo->open == NULL || cdo->release == NULL)
 392		return -2;
 393	if (!banner_printed) {
 394		printk(KERN_INFO "Uniform CD-ROM driver " REVISION "\n");
 395		banner_printed = 1;
 396#ifdef CONFIG_SYSCTL
 397		cdrom_sysctl_register();
 398#endif /* CONFIG_SYSCTL */ 
 399	}
 400
 401	ENSURE(drive_status, CDC_DRIVE_STATUS );
 402	ENSURE(media_changed, CDC_MEDIA_CHANGED);
 403	ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
 404	ENSURE(lock_door, CDC_LOCK);
 405	ENSURE(select_speed, CDC_SELECT_SPEED);
 406	ENSURE(get_last_session, CDC_MULTI_SESSION);
 407	ENSURE(get_mcn, CDC_MCN);
 408	ENSURE(reset, CDC_RESET);
 409	ENSURE(audio_ioctl, CDC_PLAY_AUDIO);
 410	ENSURE(dev_ioctl, CDC_IOCTLS);
 411	ENSURE(generic_packet, CDC_GENERIC_PACKET);
 412	cdi->mc_flags = 0;
 413	cdo->n_minors = 0;
 414        cdi->options = CDO_USE_FFLAGS;
 415	
 416	if (autoclose==1 && CDROM_CAN(CDC_CLOSE_TRAY))
 417		cdi->options |= (int) CDO_AUTO_CLOSE;
 418	if (autoeject==1 && CDROM_CAN(CDC_OPEN_TRAY))
 419		cdi->options |= (int) CDO_AUTO_EJECT;
 420	if (lockdoor==1)
 421		cdi->options |= (int) CDO_LOCK;
 422	if (check_media_type==1)
 423		cdi->options |= (int) CDO_CHECK_TYPE;
 424
 425	if (CDROM_CAN(CDC_MRW_W))
 426		cdi->exit = cdrom_mrw_exit;
 427
 428	if (cdi->disk)
 429		cdi->cdda_method = CDDA_BPC_FULL;
 430	else
 431		cdi->cdda_method = CDDA_OLD;
 432
 433	if (!cdo->generic_packet)
 434		cdo->generic_packet = cdrom_dummy_generic_packet;
 435
 436	cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
 437	spin_lock(&cdrom_lock);
 438	cdi->next = topCdromPtr; 	
 439	topCdromPtr = cdi;
 440	spin_unlock(&cdrom_lock);
 441	return 0;
 442}
 443#undef ENSURE
 444
 445int unregister_cdrom(struct cdrom_device_info *unreg)
 446{
 447	struct cdrom_device_info *cdi, *prev;
 448	cdinfo(CD_OPEN, "entering unregister_cdrom\n"); 
 449
 450	prev = NULL;
 451	spin_lock(&cdrom_lock);
 452	cdi = topCdromPtr;
 453	while (cdi && cdi != unreg) {
 454		prev = cdi;
 455		cdi = cdi->next;
 456	}
 457
 458	if (cdi == NULL) {
 459		spin_unlock(&cdrom_lock);
 460		return -2;
 461	}
 462	if (prev)
 463		prev->next = cdi->next;
 464	else
 465		topCdromPtr = cdi->next;
 466
 467	spin_unlock(&cdrom_lock);
 468
 469	if (cdi->exit)
 470		cdi->exit(cdi);
 471
 472	cdi->ops->n_minors--;
 473	cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
 474	return 0;
 475}
 476
 477int cdrom_get_media_event(struct cdrom_device_info *cdi,
 478			  struct media_event_desc *med)
 479{
 480	struct packet_command cgc;
 481	unsigned char buffer[8];
 482	struct event_header *eh = (struct event_header *) buffer;
 483
 484	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 485	cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
 486	cgc.cmd[1] = 1;		/* IMMED */
 487	cgc.cmd[4] = 1 << 4;	/* media event */
 488	cgc.cmd[8] = sizeof(buffer);
 489	cgc.quiet = 1;
 490
 491	if (cdi->ops->generic_packet(cdi, &cgc))
 492		return 1;
 493
 494	if (be16_to_cpu(eh->data_len) < sizeof(*med))
 495		return 1;
 496
 497	if (eh->nea || eh->notification_class != 0x4)
 498		return 1;
 499
 500	memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
 501	return 0;
 502}
 503
 504/*
 505 * the first prototypes used 0x2c as the page code for the mrw mode page,
 506 * subsequently this was changed to 0x03. probe the one used by this drive
 507 */
 508static int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
 509{
 510	struct packet_command cgc;
 511	char buffer[16];
 512
 513	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 514
 515	cgc.timeout = HZ;
 516	cgc.quiet = 1;
 517
 518	if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
 519		cdi->mrw_mode_page = MRW_MODE_PC;
 520		return 0;
 521	} else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
 522		cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
 523		return 0;
 524	}
 525
 526	return 1;
 527}
 528
 529static int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
 530{
 531	struct packet_command cgc;
 532	struct mrw_feature_desc *mfd;
 533	unsigned char buffer[16];
 534	int ret;
 535
 536	*write = 0;
 537
 538	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 539
 540	cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
 541	cgc.cmd[3] = CDF_MRW;
 542	cgc.cmd[8] = sizeof(buffer);
 543	cgc.quiet = 1;
 544
 545	if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
 546		return ret;
 547
 548	mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
 549	if (be16_to_cpu(mfd->feature_code) != CDF_MRW)
 550		return 1;
 551	*write = mfd->write;
 552
 553	if ((ret = cdrom_mrw_probe_pc(cdi))) {
 554		*write = 0;
 555		return ret;
 556	}
 557
 558	return 0;
 559}
 560
 561static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
 562{
 563	struct packet_command cgc;
 564	unsigned char buffer[12];
 565	int ret;
 566
 567	printk(KERN_INFO "cdrom: %sstarting format\n", cont ? "Re" : "");
 568
 569	/*
 570	 * FmtData bit set (bit 4), format type is 1
 571	 */
 572	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
 573	cgc.cmd[0] = GPCMD_FORMAT_UNIT;
 574	cgc.cmd[1] = (1 << 4) | 1;
 575
 576	cgc.timeout = 5 * 60 * HZ;
 577
 578	/*
 579	 * 4 byte format list header, 8 byte format list descriptor
 580	 */
 581	buffer[1] = 1 << 1;
 582	buffer[3] = 8;
 583
 584	/*
 585	 * nr_blocks field
 586	 */
 587	buffer[4] = 0xff;
 588	buffer[5] = 0xff;
 589	buffer[6] = 0xff;
 590	buffer[7] = 0xff;
 591
 592	buffer[8] = 0x24 << 2;
 593	buffer[11] = cont;
 594
 595	ret = cdi->ops->generic_packet(cdi, &cgc);
 596	if (ret)
 597		printk(KERN_INFO "cdrom: bgformat failed\n");
 598
 599	return ret;
 600}
 601
 602static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
 603{
 604	struct packet_command cgc;
 605
 606	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
 607	cgc.cmd[0] = GPCMD_CLOSE_TRACK;
 608
 609	/*
 610	 * Session = 1, Track = 0
 611	 */
 612	cgc.cmd[1] = !!immed;
 613	cgc.cmd[2] = 1 << 1;
 614
 615	cgc.timeout = 5 * 60 * HZ;
 616
 617	return cdi->ops->generic_packet(cdi, &cgc);
 618}
 619
 620static int cdrom_flush_cache(struct cdrom_device_info *cdi)
 621{
 622	struct packet_command cgc;
 623
 624	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
 625	cgc.cmd[0] = GPCMD_FLUSH_CACHE;
 626
 627	cgc.timeout = 5 * 60 * HZ;
 628
 629	return cdi->ops->generic_packet(cdi, &cgc);
 630}
 631
 632static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
 633{
 634	disc_information di;
 635	int ret;
 636
 637	ret = cdrom_get_disc_info(cdi, &di);
 638	if (ret < 0 || ret < (int)offsetof(typeof(di),disc_type))
 639		return 1;
 640
 641	ret = 0;
 642	if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
 643		printk(KERN_INFO "cdrom: issuing MRW back ground "
 644				"format suspend\n");
 645		ret = cdrom_mrw_bgformat_susp(cdi, 0);
 646	}
 647
 648	if (!ret)
 649		ret = cdrom_flush_cache(cdi);
 650
 651	return ret;
 652}
 653
 654static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
 655{
 656	struct packet_command cgc;
 657	struct mode_page_header *mph;
 658	char buffer[16];
 659	int ret, offset, size;
 660
 661	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 662
 663	cgc.buffer = buffer;
 664	cgc.buflen = sizeof(buffer);
 665
 666	if ((ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0)))
 667		return ret;
 668
 669	mph = (struct mode_page_header *) buffer;
 670	offset = be16_to_cpu(mph->desc_length);
 671	size = be16_to_cpu(mph->mode_data_length) + 2;
 672
 673	buffer[offset + 3] = space;
 674	cgc.buflen = size;
 675
 676	if ((ret = cdrom_mode_select(cdi, &cgc)))
 677		return ret;
 678
 679	printk(KERN_INFO "cdrom: %s: mrw address space %s selected\n", cdi->name, mrw_address_space[space]);
 680	return 0;
 681}
 682
 683static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
 684			      struct rwrt_feature_desc *rfd)
 685{
 686	struct packet_command cgc;
 687	char buffer[24];
 688	int ret;
 689
 690	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 691
 692	cgc.cmd[0] = GPCMD_GET_CONFIGURATION;	/* often 0x46 */
 693	cgc.cmd[3] = CDF_RWRT;			/* often 0x0020 */
 694	cgc.cmd[8] = sizeof(buffer);		/* often 0x18 */
 695	cgc.quiet = 1;
 696
 697	if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
 698		return ret;
 699
 700	memcpy(rfd, &buffer[sizeof(struct feature_header)], sizeof (*rfd));
 701	return 0;
 702}
 703
 704static int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
 705{
 706	struct packet_command cgc;
 707	char buffer[16];
 708	__u16 *feature_code;
 709	int ret;
 710
 711	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 712
 713	cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
 714	cgc.cmd[3] = CDF_HWDM;
 715	cgc.cmd[8] = sizeof(buffer);
 716	cgc.quiet = 1;
 717
 718	if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
 719		return ret;
 720
 721	feature_code = (__u16 *) &buffer[sizeof(struct feature_header)];
 722	if (be16_to_cpu(*feature_code) == CDF_HWDM)
 723		return 0;
 724
 725	return 1;
 726}
 727
 728
 729static int cdrom_is_random_writable(struct cdrom_device_info *cdi, int *write)
 730{
 731	struct rwrt_feature_desc rfd;
 732	int ret;
 733
 734	*write = 0;
 735
 736	if ((ret = cdrom_get_random_writable(cdi, &rfd)))
 737		return ret;
 738
 739	if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
 740		*write = 1;
 741
 742	return 0;
 743}
 744
 745static int cdrom_media_erasable(struct cdrom_device_info *cdi)
 746{
 747	disc_information di;
 748	int ret;
 749
 750	ret = cdrom_get_disc_info(cdi, &di);
 751	if (ret < 0 || ret < offsetof(typeof(di), n_first_track))
 752		return -1;
 753
 754	return di.erasable;
 755}
 756
 757/*
 758 * FIXME: check RO bit
 759 */
 760static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
 761{
 762	int ret = cdrom_media_erasable(cdi);
 763
 764	/*
 765	 * allow writable open if media info read worked and media is
 766	 * erasable, _or_ if it fails since not all drives support it
 767	 */
 768	if (!ret)
 769		return 1;
 770
 771	return 0;
 772}
 773
 774static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
 775{
 776	disc_information di;
 777	int ret;
 778
 779	/*
 780	 * always reset to DMA lba space on open
 781	 */
 782	if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_DMA)) {
 783		printk(KERN_ERR "cdrom: failed setting lba address space\n");
 784		return 1;
 785	}
 786
 787	ret = cdrom_get_disc_info(cdi, &di);
 788	if (ret < 0 || ret < offsetof(typeof(di),disc_type))
 789		return 1;
 790
 791	if (!di.erasable)
 792		return 1;
 793
 794	/*
 795	 * mrw_status
 796	 * 0	-	not MRW formatted
 797	 * 1	-	MRW bgformat started, but not running or complete
 798	 * 2	-	MRW bgformat in progress
 799	 * 3	-	MRW formatting complete
 800	 */
 801	ret = 0;
 802	printk(KERN_INFO "cdrom open: mrw_status '%s'\n",
 803			mrw_format_status[di.mrw_status]);
 804	if (!di.mrw_status)
 805		ret = 1;
 806	else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE &&
 807			mrw_format_restart)
 808		ret = cdrom_mrw_bgformat(cdi, 1);
 809
 810	return ret;
 811}
 812
 813static int mo_open_write(struct cdrom_device_info *cdi)
 814{
 815	struct packet_command cgc;
 816	char buffer[255];
 817	int ret;
 818
 819	init_cdrom_command(&cgc, &buffer, 4, CGC_DATA_READ);
 820	cgc.quiet = 1;
 821
 822	/*
 823	 * obtain write protect information as per
 824	 * drivers/scsi/sd.c:sd_read_write_protect_flag
 825	 */
 826
 827	ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
 828	if (ret)
 829		ret = cdrom_mode_sense(cdi, &cgc, GPMODE_VENDOR_PAGE, 0);
 830	if (ret) {
 831		cgc.buflen = 255;
 832		ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
 833	}
 834
 835	/* drive gave us no info, let the user go ahead */
 836	if (ret)
 837		return 0;
 838
 839	return buffer[3] & 0x80;
 840}
 841
 842static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
 843{
 844	struct rwrt_feature_desc rfd;
 845	int ret;
 846
 847	if ((ret = cdrom_has_defect_mgt(cdi)))
 848		return ret;
 849
 850	if ((ret = cdrom_get_random_writable(cdi, &rfd)))
 851		return ret;
 852	else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
 853		ret = !rfd.curr;
 854
 855	cdinfo(CD_OPEN, "can open for random write\n");
 856	return ret;
 857}
 858
 859static void cdrom_mmc3_profile(struct cdrom_device_info *cdi)
 860{
 861	struct packet_command cgc;
 862	char buffer[32];
 863	int ret, mmc3_profile;
 864
 865	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
 866
 867	cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
 868	cgc.cmd[1] = 0;
 869	cgc.cmd[2] = cgc.cmd[3] = 0;		/* Starting Feature Number */
 870	cgc.cmd[8] = sizeof(buffer);		/* Allocation Length */
 871	cgc.quiet = 1;
 872
 873	if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
 874		mmc3_profile = 0xffff;
 875	else
 876		mmc3_profile = (buffer[6] << 8) | buffer[7];
 877
 878	cdi->mmc3_profile = mmc3_profile;
 879}
 880
 881static int cdrom_is_dvd_rw(struct cdrom_device_info *cdi)
 882{
 883	switch (cdi->mmc3_profile) {
 884	case 0x12:	/* DVD-RAM	*/
 885	case 0x1A:	/* DVD+RW	*/
 886		return 0;
 887	default:
 888		return 1;
 889	}
 890}
 891
 892/*
 893 * returns 0 for ok to open write, non-0 to disallow
 894 */
 895static int cdrom_open_write(struct cdrom_device_info *cdi)
 896{
 897	int mrw, mrw_write, ram_write;
 898	int ret = 1;
 899
 900	mrw = 0;
 901	if (!cdrom_is_mrw(cdi, &mrw_write))
 902		mrw = 1;
 903
 904	if (CDROM_CAN(CDC_MO_DRIVE))
 905		ram_write = 1;
 906	else
 907		(void) cdrom_is_random_writable(cdi, &ram_write);
 908	
 909	if (mrw)
 910		cdi->mask &= ~CDC_MRW;
 911	else
 912		cdi->mask |= CDC_MRW;
 913
 914	if (mrw_write)
 915		cdi->mask &= ~CDC_MRW_W;
 916	else
 917		cdi->mask |= CDC_MRW_W;
 918
 919	if (ram_write)
 920		cdi->mask &= ~CDC_RAM;
 921	else
 922		cdi->mask |= CDC_RAM;
 923
 924	if (CDROM_CAN(CDC_MRW_W))
 925		ret = cdrom_mrw_open_write(cdi);
 926	else if (CDROM_CAN(CDC_DVD_RAM))
 927		ret = cdrom_dvdram_open_write(cdi);
 928 	else if (CDROM_CAN(CDC_RAM) &&
 929 		 !CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW|CDC_MO_DRIVE))
 930 		ret = cdrom_ram_open_write(cdi);
 931	else if (CDROM_CAN(CDC_MO_DRIVE))
 932		ret = mo_open_write(cdi);
 933	else if (!cdrom_is_dvd_rw(cdi))
 934		ret = 0;
 935
 936	return ret;
 937}
 938
 939static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
 940{
 941	struct packet_command cgc;
 942
 943	if (cdi->mmc3_profile != 0x1a) {
 944		cdinfo(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
 945		return;
 946	}
 947
 948	if (!cdi->media_written) {
 949		cdinfo(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
 950		return;
 951	}
 952
 953	printk(KERN_INFO "cdrom: %s: dirty DVD+RW media, \"finalizing\"\n",
 954	       cdi->name);
 955
 956	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
 957	cgc.cmd[0] = GPCMD_FLUSH_CACHE;
 958	cgc.timeout = 30*HZ;
 959	cdi->ops->generic_packet(cdi, &cgc);
 960
 961	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
 962	cgc.cmd[0] = GPCMD_CLOSE_TRACK;
 963	cgc.timeout = 3000*HZ;
 964	cgc.quiet = 1;
 965	cdi->ops->generic_packet(cdi, &cgc);
 966
 967	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
 968	cgc.cmd[0] = GPCMD_CLOSE_TRACK;
 969	cgc.cmd[2] = 2;	 /* Close session */
 970	cgc.quiet = 1;
 971	cgc.timeout = 3000*HZ;
 972	cdi->ops->generic_packet(cdi, &cgc);
 973
 974	cdi->media_written = 0;
 975}
 976
 977static int cdrom_close_write(struct cdrom_device_info *cdi)
 978{
 979#if 0
 980	return cdrom_flush_cache(cdi);
 981#else
 982	return 0;
 983#endif
 984}
 985
 986/* We use the open-option O_NONBLOCK to indicate that the
 987 * purpose of opening is only for subsequent ioctl() calls; no device
 988 * integrity checks are performed.
 989 *
 990 * We hope that all cd-player programs will adopt this convention. It
 991 * is in their own interest: device control becomes a lot easier
 992 * this way.
 993 */
 994int cdrom_open(struct cdrom_device_info *cdi, struct inode *ip, struct file *fp)
 995{
 996	int ret;
 997
 998	cdinfo(CD_OPEN, "entering cdrom_open\n"); 
 999
1000	/* if this was a O_NONBLOCK open and we should honor the flags,
1001	 * do a quick open without drive/disc integrity checks. */
1002	cdi->use_count++;
1003	if ((fp->f_flags & O_NONBLOCK) && (cdi->options & CDO_USE_FFLAGS)) {
1004		ret = cdi->ops->open(cdi, 1);
1005	} else {
1006		ret = open_for_data(cdi);
1007		if (ret)
1008			goto err;
1009		cdrom_mmc3_profile(cdi);
1010		if (fp->f_mode & FMODE_WRITE) {
1011			ret = -EROFS;
1012			if (cdrom_open_write(cdi))
1013				goto err;
1014			if (!CDROM_CAN(CDC_RAM))
1015				goto err;
1016			ret = 0;
1017			cdi->media_written = 0;
1018		}
1019	}
1020
1021	if (ret)
1022		goto err;
1023
1024	cdinfo(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1025			cdi->name, cdi->use_count);
1026	/* Do this on open.  Don't wait for mount, because they might
1027	    not be mounting, but opening with O_NONBLOCK */
1028	check_disk_change(ip->i_bdev);
1029	return 0;
1030err:
1031	cdi->use_count--;
1032	return ret;
1033}
1034
1035static
1036int open_for_data(struct cdrom_device_info * cdi)
1037{
1038	int ret;
1039	struct cdrom_device_ops *cdo = cdi->ops;
1040	tracktype tracks;
1041	cdinfo(CD_OPEN, "entering open_for_data\n");
1042	/* Check if the driver can report drive status.  If it can, we
1043	   can do clever things.  If it can't, well, we at least tried! */
1044	if (cdo->drive_status != NULL) {
1045		ret = cdo->drive_status(cdi, CDSL_CURRENT);
1046		cdinfo(CD_OPEN, "drive_status=%d\n", ret); 
1047		if (ret == CDS_TRAY_OPEN) {
1048			cdinfo(CD_OPEN, "the tray is open...\n"); 
1049			/* can/may i close it? */
1050			if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1051			    cdi->options & CDO_AUTO_CLOSE) {
1052				cdinfo(CD_OPEN, "trying to close the tray.\n"); 
1053				ret=cdo->tray_move(cdi,0);
1054				if (ret) {
1055					cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.\n"); 
1056					/* Ignore the error from the low
1057					level driver.  We don't care why it
1058					couldn't close the tray.  We only care 
1059					that there is no disc in the drive, 
1060					since that is the _REAL_ problem here.*/
1061					ret=-ENOMEDIUM;
1062					goto clean_up_and_return;
1063				}
1064			} else {
1065				cdinfo(CD_OPEN, "bummer. this drive can't close the tray.\n"); 
1066				ret=-ENOMEDIUM;
1067				goto clean_up_and_return;
1068			}
1069			/* Ok, the door should be closed now.. Check again */
1070			ret = cdo->drive_status(cdi, CDSL_CURRENT);
1071			if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1072				cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n"); 
1073				cdinfo(CD_OPEN, "tray might not contain a medium.\n");
1074				ret=-ENOMEDIUM;
1075				goto clean_up_and_return;
1076			}
1077			cdinfo(CD_OPEN, "the tray is now closed.\n"); 
1078		}
1079		/* the door should be closed now, check for the disc */
1080		ret = cdo->drive_status(cdi, CDSL_CURRENT);
1081		if (ret!=CDS_DISC_OK) {
1082			ret = -ENOMEDIUM;
1083			goto clean_up_and_return;
1084		}
1085	}
1086	cdrom_count_tracks(cdi, &tracks);
1087	if (tracks.error == CDS_NO_DISC) {
1088		cdinfo(CD_OPEN, "bummer. no disc.\n");
1089		ret=-ENOMEDIUM;
1090		goto clean_up_and_return;
1091	}
1092	/* CD-Players which don't use O_NONBLOCK, workman
1093	 * for example, need bit CDO_CHECK_TYPE cleared! */
1094	if (tracks.data==0) {
1095		if (cdi->options & CDO_CHECK_TYPE) {
1096		    /* give people a warning shot, now that CDO_CHECK_TYPE
1097		       is the default case! */
1098		    cdinfo(CD_OPEN, "bummer. wrong media type.\n"); 
1099		    cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1100					(unsigned int)current->pid); 
1101		    ret=-EMEDIUMTYPE;
1102		    goto clean_up_and_return;
1103		}
1104		else {
1105		    cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.\n");
1106		}
1107	}
1108
1109	cdinfo(CD_OPEN, "all seems well, opening the device.\n"); 
1110
1111	/* all seems well, we can open the device */
1112	ret = cdo->open(cdi, 0); /* open for data */
1113	cdinfo(CD_OPEN, "opening the device gave me %d.\n", ret); 
1114	/* After all this careful checking, we shouldn't have problems
1115	   opening the device, but we don't want the device locked if 
1116	   this somehow fails... */
1117	if (ret) {
1118		cdinfo(CD_OPEN, "open device failed.\n"); 
1119		goto clean_up_and_return;
1120	}
1121	if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1122			cdo->lock_door(cdi, 1);
1123			cdinfo(CD_OPEN, "door locked.\n");
1124	}
1125	cdinfo(CD_OPEN, "device opened successfully.\n"); 
1126	return ret;
1127
1128	/* Something failed.  Try to unlock the drive, because some drivers
1129	(notably ide-cd) lock the drive after every command.  This produced
1130	a nasty bug where after mount failed, the drive would remain locked!  
1131	This ensures that the drive gets unlocked after a mount fails.  This 
1132	is a goto to avoid bloating the driver with redundant code. */ 
1133clean_up_and_return:
1134	cdinfo(CD_WARNING, "open failed.\n"); 
1135	if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1136			cdo->lock_door(cdi, 0);
1137			cdinfo(CD_OPEN, "door unlocked.\n");
1138	}
1139	return ret;
1140}
1141
1142/* This code is similar to that in open_for_data. The routine is called
1143   whenever an audio play operation is requested.
1144*/
1145int check_for_audio_disc(struct cdrom_device_info * cdi,
1146			 struct cdrom_device_ops * cdo)
1147{
1148        int ret;
1149	tracktype tracks;
1150	cdinfo(CD_OPEN, "entering check_for_audio_disc\n");
1151	if (!(cdi->options & CDO_CHECK_TYPE))
1152		return 0;
1153	if (cdo->drive_status != NULL) {
1154		ret = cdo->drive_status(cdi, CDSL_CURRENT);
1155		cdinfo(CD_OPEN, "drive_status=%d\n", ret); 
1156		if (ret == CDS_TRAY_OPEN) {
1157			cdinfo(CD_OPEN, "the tray is open...\n"); 
1158			/* can/may i close it? */
1159			if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1160			    cdi->options & CDO_AUTO_CLOSE) {
1161				cdinfo(CD_OPEN, "trying to close the tray.\n"); 
1162				ret=cdo->tray_move(cdi,0);
1163				if (ret) {
1164					cdinfo(CD_OPEN, "bummer. tried to close tray but failed.\n"); 
1165					/* Ignore the error from the low
1166					level driver.  We don't care why it
1167					couldn't close the tray.  We only care 
1168					that there is no disc in the drive, 
1169					since that is the _REAL_ problem here.*/
1170					return -ENOMEDIUM;
1171				}
1172			} else {
1173				cdinfo(CD_OPEN, "bummer. this driver can't close the tray.\n"); 
1174				return -ENOMEDIUM;
1175			}
1176			/* Ok, the door should be closed now.. Check again */
1177			ret = cdo->drive_status(cdi, CDSL_CURRENT);
1178			if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1179				cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n"); 
1180				return -ENOMEDIUM;
1181			}	
1182			if (ret!=CDS_DISC_OK) {
1183				cdinfo(CD_OPEN, "bummer. disc isn't ready.\n"); 
1184				return -EIO;
1185			}	
1186			cdinfo(CD_OPEN, "the tray is now closed.\n"); 
1187		}	
1188	}
1189	cdrom_count_tracks(cdi, &tracks);
1190	if (tracks.error) 
1191		return(tracks.error);
1192
1193	if (tracks.audio==0)
1194		return -EMEDIUMTYPE;
1195
1196	return 0;
1197}
1198
1199/* Admittedly, the logic below could be performed in a nicer way. */
1200int cdrom_release(struct cdrom_device_info *cdi, struct file *fp)
1201{
1202	struct cdrom_device_ops *cdo = cdi->ops;
1203	int opened_for_data;
1204
1205	cdinfo(CD_CLOSE, "entering cdrom_release\n"); 
1206
1207	if (cdi->use_count > 0)
1208		cdi->use_count--;
1209	if (cdi->use_count == 0)
1210		cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
1211	if (cdi->use_count == 0)
1212		cdrom_dvd_rw_close_write(cdi);
1213	if (cdi->use_count == 0 &&
1214	    (cdo->capability & CDC_LOCK) && !keeplocked) {
1215		cdinfo(CD_CLOSE, "Unlocking door!\n");
1216		cdo->lock_door(cdi, 0);
1217	}
1218	opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1219		!(fp && fp->f_flags & O_NONBLOCK);
1220
1221	/*
1222	 * flush cache on last write release
1223	 */
1224	if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1225		cdrom_close_write(cdi);
1226
1227	cdo->release(cdi);
1228	if (cdi->use_count == 0) {      /* last process that closes dev*/
1229		if (opened_for_data &&
1230		    cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1231			cdo->tray_move(cdi, 1);
1232	}
1233	return 0;
1234}
1235
1236static int cdrom_read_mech_status(struct cdrom_device_info *cdi, 
1237				  struct cdrom_changer_info *buf)
1238{
1239	struct packet_command cgc;
1240	struct cdrom_device_ops *cdo = cdi->ops;
1241	int length;
1242
1243	/*
1244	 * Sanyo changer isn't spec compliant (doesn't use regular change
1245	 * LOAD_UNLOAD command, and it doesn't implement the mech status
1246	 * command below
1247	 */
1248	if (cdi->sanyo_slot) {
1249		buf->hdr.nslots = 3;
1250		buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1251		for (length = 0; length < 3; length++) {
1252			buf->slots[length].disc_present = 1;
1253			buf->slots[length].change = 0;
1254		}
1255		return 0;
1256	}
1257
1258	length = sizeof(struct cdrom_mechstat_header) +
1259		 cdi->capacity * sizeof(struct cdrom_slot);
1260
1261	init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1262	cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1263	cgc.cmd[8] = (length >> 8) & 0xff;
1264	cgc.cmd[9] = length & 0xff;
1265	return cdo->generic_packet(cdi, &cgc);
1266}
1267
1268static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1269{
1270	struct cdrom_changer_info *info;
1271	int ret;
1272
1273	cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n"); 
1274	if (cdi->sanyo_slot)
1275		return CDS_NO_INFO;
1276	
1277	info = kmalloc(sizeof(*info), GFP_KERNEL);
1278	if (!info)
1279		return -ENOMEM;
1280
1281	if ((ret = cdrom_read_mech_status(cdi, info)))
1282		goto out_free;
1283
1284	if (info->slots[slot].disc_present)
1285		ret = CDS_DISC_OK;
1286	else
1287		ret = CDS_NO_DISC;
1288
1289out_free:
1290	kfree(info);
1291	return ret;
1292}
1293
1294/* Return the number of slots for an ATAPI/SCSI cdrom, 
1295 * return 1 if not a changer. 
1296 */
1297int cdrom_number_of_slots(struct cdrom_device_info *cdi) 
1298{
1299	int status;
1300	int nslots = 1;
1301	struct cdrom_changer_info *info;
1302
1303	cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n"); 
1304	/* cdrom_read_mech_status requires a valid value for capacity: */
1305	cdi->capacity = 0; 
1306
1307	info = kmalloc(sizeof(*info), GFP_KERNEL);
1308	if (!info)
1309		return -ENOMEM;
1310
1311	if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1312		nslots = info->hdr.nslots;
1313
1314	kfree(info);
1315	return nslots;
1316}
1317
1318
1319/* If SLOT < 0, unload the current slot.  Otherwise, try to load SLOT. */
1320static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot) 
1321{
1322	struct packet_command cgc;
1323
1324	cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n"); 
1325	if (cdi->sanyo_slot && slot < 0)
1326		return 0;
1327
1328	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1329	cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1330	cgc.cmd[4] = 2 + (slot >= 0);
1331	cgc.cmd[8] = slot;
1332	cgc.timeout = 60 * HZ;
1333
1334	/* The Sanyo 3 CD changer uses byte 7 of the 
1335	GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1336	using the GPCMD_LOAD_UNLOAD opcode. */
1337	if (cdi->sanyo_slot && -1 < slot) {
1338		cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1339		cgc.cmd[7] = slot;
1340		cgc.cmd[4] = cgc.cmd[8] = 0;
1341		cdi->sanyo_slot = slot ? slot : 3;
1342	}
1343
1344	return cdi->ops->generic_packet(cdi, &cgc);
1345}
1346
1347static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1348{
1349	struct cdrom_changer_info *info;
1350	int curslot;
1351	int ret;
1352
1353	cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n"); 
1354	if (!CDROM_CAN(CDC_SELECT_DISC))
1355		return -EDRIVE_CANT_DO_THIS;
1356
1357	(void) cdi->ops->media_changed(cdi, slot);
1358
1359	if (slot == CDSL_NONE) {
1360		/* set media changed bits, on both queues */
1361		cdi->mc_flags = 0x3;
1362		return cdrom_load_unload(cdi, -1);
1363	}
1364
1365	info = kmalloc(sizeof(*info), GFP_KERNEL);
1366	if (!info)
1367		return -ENOMEM;
1368
1369	if ((ret = cdrom_read_mech_status(cdi, info))) {
1370		kfree(info);
1371		return ret;
1372	}
1373
1374	curslot = info->hdr.curslot;
1375	kfree(info);
1376
1377	if (cdi->use_count > 1 || keeplocked) {
1378		if (slot == CDSL_CURRENT) {
1379	    		return curslot;
1380		} else {
1381			return -EBUSY;
1382		}
1383	}
1384
1385	/* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1386	which is useful if it had been previously unloaded.
1387	Whether it can or not, it returns the current slot. 
1388	Similarly,  if slot happens to be the current one, we still
1389	try and load it. */
1390	if (slot == CDSL_CURRENT)
1391		slot = curslot;
1392
1393	/* set media changed bits on both queues */
1394	cdi->mc_flags = 0x3;
1395	if ((ret = cdrom_load_unload(cdi, slot)))
1396		return ret;
1397
1398	return slot;
1399}
1400
1401/* We want to make media_changed accessible to the user through an
1402 * ioctl. The main problem now is that we must double-buffer the
1403 * low-level implementation, to assure that the VFS and the user both
1404 * see a medium change once.
1405 */
1406
1407static
1408int media_changed(struct cdrom_device_info *cdi, int queue)
1409{
1410	unsigned int mask = (1 << (queue & 1));
1411	int ret = !!(cdi->mc_flags & mask);
1412
1413	if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1414	    return ret;
1415	/* changed since last call? */
1416	if (cdi->ops->media_changed(cdi, CDSL_CURRENT)) {
1417		cdi->mc_flags = 0x3;    /* set bit on both queues */
1418		ret |= 1;
1419		cdi->media_written = 0;
1420	}
1421	cdi->mc_flags &= ~mask;         /* clear bit */
1422	return ret;
1423}
1424
1425int cdrom_media_changed(struct cdrom_device_info *cdi)
1426{
1427	/* This talks to the VFS, which doesn't like errors - just 1 or 0.  
1428	 * Returning "0" is always safe (media hasn't been changed). Do that 
1429	 * if the low-level cdrom driver dosn't support media changed. */ 
1430	if (cdi == NULL || cdi->ops->media_changed == NULL)
1431		return 0;
1432	if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1433		return 0;
1434	return media_changed(cdi, 0);
1435}
1436
1437/* badly broken, I know. Is due for a fixup anytime. */
1438static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1439{
1440	struct cdrom_tochdr header;
1441	struct cdrom_tocentry entry;
1442	int ret, i;
1443	tracks->data=0;
1444	tracks->audio=0;
1445	tracks->cdi=0;
1446	tracks->xa=0;
1447	tracks->error=0;
1448	cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n"); 
1449        if (!CDROM_CAN(CDC_PLAY_AUDIO)) { 
1450                tracks->error=CDS_NO_INFO;
1451                return;
1452        }        
1453	/* Grab the TOC header so we can see how many tracks there are */
1454	if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1455		if (ret == -ENOMEDIUM)
1456			tracks->error = CDS_NO_DISC;
1457		else
1458			tracks->error = CDS_NO_INFO;
1459		return;
1460	}	
1461	/* check what type of tracks are on this disc */
1462	entry.cdte_format = CDROM_MSF;
1463	for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1464		entry.cdte_track  = i;
1465		if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1466			tracks->error=CDS_NO_INFO;
1467			return;
1468		}	
1469		if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1470		    if (entry.cdte_format == 0x10)
1471			tracks->cdi++;
1472		    else if (entry.cdte_format == 0x20) 
1473			tracks->xa++;
1474		    else
1475			tracks->data++;
1476		} else
1477		    tracks->audio++;
1478		cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1479		       i, entry.cdte_format, entry.cdte_ctrl);
1480	}	
1481	cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n", 
1482		header.cdth_trk1, tracks->audio, tracks->data, 
1483		tracks->cdi, tracks->xa);
1484}	
1485
1486/* Requests to the low-level drivers will /always/ be done in the
1487   following format convention:
1488
1489   CDROM_LBA: all data-related requests.
1490   CDROM_MSF: all audio-related requests.
1491
1492   However, a low-level implementation is allowed to refuse this
1493   request, and return information in its own favorite format.
1494
1495   It doesn't make sense /at all/ to ask for a play_audio in LBA
1496   format, or ask for multi-session info in MSF format. However, for
1497   backward compatibility these format requests will be satisfied, but
1498   the requests to the low-level drivers will be sanitized in the more
1499   meaningful format indicated above.
1500 */
1501
1502static
1503void sanitize_format(union cdrom_addr *addr,
1504		     u_char * curr, u_char requested)
1505{
1506	if (*curr == requested)
1507		return;                 /* nothing to be done! */
1508	if (requested == CDROM_LBA) {
1509		addr->lba = (int) addr->msf.frame +
1510			75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1511	} else {                        /* CDROM_MSF */
1512		int lba = addr->lba;
1513		addr->msf.frame = lba % 75;
1514		lba /= 75;
1515		lba += 2;
1516		addr->msf.second = lba % 60;
1517		addr->msf.minute = lba / 60;
1518	}
1519	*curr = requested;
1520}
1521
1522void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1523			int type)
1524{
1525	memset(cgc, 0, sizeof(struct packet_command));
1526	if (buf)
1527		memset(buf, 0, len);
1528	cgc->buffer = (char *) buf;
1529	cgc->buflen = len;
1530	cgc->data_direction = type;
1531	cgc->timeout = 5*HZ;
1532}
1533
1534/* DVD handling */
1535
1536#define copy_key(dest,src)	memcpy((dest), (src), sizeof(dvd_key))
1537#define copy_chal(dest,src)	memcpy((dest), (src), sizeof(dvd_challenge))
1538
1539static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1540{
1541	cgc->cmd[0] = GPCMD_REPORT_KEY;
1542	cgc->cmd[10] = type | (agid << 6);
1543	switch (type) {
1544		case 0: case 8: case 5: {
1545			cgc->buflen = 8;
1546			break;
1547		}
1548		case 1: {
1549			cgc->buflen = 16;
1550			break;
1551		}
1552		case 2: case 4: {
1553			cgc->buflen = 12;
1554			break;
1555		}
1556	}
1557	cgc->cmd[9] = cgc->buflen;
1558	cgc->data_direction = CGC_DATA_READ;
1559}
1560
1561static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1562{
1563	cgc->cmd[0] = GPCMD_SEND_KEY;
1564	cgc->cmd[10] = type | (agid << 6);
1565	switch (type) {
1566		case 1: {
1567			cgc->buflen = 16;
1568			break;
1569		}
1570		case 3: {
1571			cgc->buflen = 12;
1572			break;
1573		}
1574		case 6: {
1575			cgc->buflen = 8;
1576			break;
1577		}
1578	}
1579	cgc->cmd[9] = cgc->buflen;
1580	cgc->data_direction = CGC_DATA_WRITE;
1581}
1582
1583static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1584{
1585	int ret;
1586	u_char buf[20];
1587	struct packet_command cgc;
1588	struct cdrom_device_ops *cdo = cdi->ops;
1589	rpc_state_t rpc_state;
1590
1591	memset(buf, 0, sizeof(buf));
1592	init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1593
1594	switch (ai->type) {
1595	/* LU data send */
1596	case DVD_LU_SEND_AGID:
1597		cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n"); 
1598		cgc.quiet = 1;
1599		setup_report_key(&cgc, ai->lsa.agid, 0);
1600
1601		if ((ret = cdo->generic_packet(cdi, &cgc)))
1602			return ret;
1603
1604		ai->lsa.agid = buf[7] >> 6;
1605		/* Returning data, let host change state */
1606		break;
1607
1608	case DVD_LU_SEND_KEY1:
1609		cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n"); 
1610		setup_report_key(&cgc, ai->lsk.agid, 2);
1611
1612		if ((ret = cdo->generic_packet(cdi, &cgc)))
1613			return ret;
1614
1615		copy_key(ai->lsk.key, &buf[4]);
1616		/* Returning data, let host change state */
1617		break;
1618
1619	case DVD_LU_SEND_CHALLENGE:
1620		cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n"); 
1621		setup_report_key(&cgc, ai->lsc.agid, 1);
1622
1623		if ((ret = cdo->generic_packet(cdi, &cgc)))
1624			return ret;
1625
1626		copy_chal(ai->lsc.chal, &buf[4]);
1627		/* Returning data, let host change state */
1628		break;
1629
1630	/* Post-auth key */
1631	case DVD_LU_SEND_TITLE_KEY:
1632		cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n"); 
1633		cgc.quiet = 1;
1634		setup_report_key(&cgc, ai->lstk.agid, 4);
1635		cgc.cmd[5] = ai->lstk.lba;
1636		cgc.cmd[4] = ai->lstk.lba >> 8;
1637		cgc.cmd[3] = ai->lstk.lba >> 16;
1638		cgc.cmd[2] = ai->lstk.lba >> 24;
1639
1640		if ((ret = cdo->generic_packet(cdi, &cgc)))
1641			return ret;
1642
1643		ai->lstk.cpm = (buf[4] >> 7) & 1;
1644		ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1645		ai->lstk.cgms = (buf[4] >> 4) & 3;
1646		copy_key(ai->lstk.title_key, &buf[5]);
1647		/* Returning data, let host change state */
1648		break;
1649
1650	case DVD_LU_SEND_ASF:
1651		cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n"); 
1652		setup_report_key(&cgc, ai->lsasf.agid, 5);
1653		
1654		if ((ret = cdo->generic_packet(cdi, &cgc)))
1655			return ret;
1656
1657		ai->lsasf.asf = buf[7] & 1;
1658		break;
1659
1660	/* LU data receive (LU changes state) */
1661	case DVD_HOST_SEND_CHALLENGE:
1662		cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n"); 
1663		setup_send_key(&cgc, ai->hsc.agid, 1);
1664		buf[1] = 0xe;
1665		copy_chal(&buf[4], ai->hsc.chal);
1666
1667		if ((ret = cdo->generic_packet(cdi, &cgc)))
1668			return ret;
1669
1670		ai->type = DVD_LU_SEND_KEY1;
1671		break;
1672
1673	case DVD_HOST_SEND_KEY2:
1674		cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n"); 
1675		setup_send_key(&cgc, ai->hsk.agid, 3);
1676		buf[1] = 0xa;
1677		copy_key(&buf[4], ai->hsk.key);
1678
1679		if ((ret = cdo->generic_packet(cdi, &cgc))) {
1680			ai->type = DVD_AUTH_FAILURE;
1681			return ret;
1682		}
1683		ai->type = DVD_AUTH_ESTABLISHED;
1684		break;
1685
1686	/* Misc */
1687	case DVD_INVALIDATE_AGID:
1688		cgc.quiet = 1;
1689		cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n"); 
1690		setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1691		if ((ret = cdo->generic_packet(cdi, &cgc)))
1692			return ret;
1693		break;
1694
1695	/* Get region settings */
1696	case DVD_LU_SEND_RPC_STATE:
1697		cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1698		setup_report_key(&cgc, 0, 8);
1699		memset(&rpc_state, 0, sizeof(rpc_state_t));
1700		cgc.buffer = (char *) &rpc_state;
1701
1702		if ((ret = cdo->generic_packet(cdi, &cgc)))
1703			return ret;
1704
1705		ai->lrpcs.type = rpc_state.type_code;
1706		ai->lrpcs.vra = rpc_state.vra;
1707		ai->lrpcs.ucca = rpc_state.ucca;
1708		ai->lrpcs.region_mask = rpc_state.region_mask;
1709		ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1710		break;
1711
1712	/* Set region settings */
1713	case DVD_HOST_SEND_RPC_STATE:
1714		cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1715		setup_send_key(&cgc, 0, 6);
1716		buf[1] = 6;
1717		buf[4] = ai->hrpcs.pdrc;
1718
1719		if ((ret = cdo->generic_packet(cdi, &cgc)))
1720			return ret;
1721		break;
1722
1723	default:
1724		cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1725		return -ENOTTY;
1726	}
1727
1728	return 0;
1729}
1730
1731static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
1732{
1733	unsigned char buf[21], *base;
1734	struct dvd_layer *layer;
1735	struct packet_command cgc;
1736	struct cdrom_device_ops *cdo = cdi->ops;
1737	int ret, layer_num = s->physical.layer_num;
1738
1739	if (layer_num >= DVD_LAYERS)
1740		return -EINVAL;
1741
1742	init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1743	cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1744	cgc.cmd[6] = layer_num;
1745	cgc.cmd[7] = s->type;
1746	cgc.cmd[9] = cgc.buflen & 0xff;
1747
1748	/*
1749	 * refrain from reporting errors on non-existing layers (mainly)
1750	 */
1751	cgc.quiet = 1;
1752
1753	if ((ret = cdo->generic_packet(cdi, &cgc)))
1754		return ret;
1755
1756	base = &buf[4];
1757	layer = &s->physical.layer[layer_num];
1758
1759	/*
1760	 * place the data... really ugly, but at least we won't have to
1761	 * worry about endianess in userspace.
1762	 */
1763	memset(layer, 0, sizeof(*layer));
1764	layer->book_version = base[0] & 0xf;
1765	layer->book_type = base[0] >> 4;
1766	layer->min_rate = base[1] & 0xf;
1767	layer->disc_size = base[1] >> 4;
1768	layer->layer_type = base[2] & 0xf;
1769	layer->track_path = (base[2] >> 4) & 1;
1770	layer->nlayers = (base[2] >> 5) & 3;
1771	layer->track_density = base[3] & 0xf;
1772	layer->linear_density = base[3] >> 4;
1773	layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1774	layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1775	layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1776	layer->bca = base[16] >> 7;
1777
1778	return 0;
1779}
1780
1781static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
1782{
1783	int ret;
1784	u_char buf[8];
1785	struct packet_command cgc;
1786	struct cdrom_device_ops *cdo = cdi->ops;
1787
1788	init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1789	cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1790	cgc.cmd[6] = s->copyright.layer_num;
1791	cgc.cmd[7] = s->type;
1792	cgc.cmd[8] = cgc.buflen >> 8;
1793	cgc.cmd[9] = cgc.buflen & 0xff;
1794
1795	if ((ret = cdo->generic_packet(cdi, &cgc)))
1796		return ret;
1797
1798	s->copyright.cpst = buf[4];
1799	s->copyright.rmi = buf[5];
1800
1801	return 0;
1802}
1803
1804static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s)
1805{
1806	int ret, size;
1807	u_char *buf;
1808	struct packet_command cgc;
1809	struct cdrom_device_ops *cdo = cdi->ops;
1810
1811	size = sizeof(s->disckey.value) + 4;
1812
1813	if ((buf = (u_char *) kmalloc(size, GFP_KERNEL)) == NULL)
1814		return -ENOMEM;
1815
1816	init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1817	cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1818	cgc.cmd[7] = s->type;
1819	cgc.cmd[8] = size >> 8;
1820	cgc.cmd[9] = size & 0xff;
1821	cgc.cmd[10] = s->disckey.agid << 6;
1822
1823	if (!(ret = cdo->generic_packet(cdi, &cgc)))
1824		memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1825
1826	kfree(buf);
1827	return ret;
1828}
1829
1830static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s)
1831{
1832	int ret;
1833	u_char buf[4 + 188];
1834	struct packet_command cgc;
1835	struct cdrom_device_ops *cdo = cdi->ops;
1836
1837	init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1838	cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1839	cgc.cmd[7] = s->type;
1840	cgc.cmd[9] = cgc.buflen = 0xff;
1841
1842	if ((ret = cdo->generic_packet(cdi, &cgc)))
1843		return ret;
1844
1845	s->bca.len = buf[0] << 8 | buf[1];
1846	if (s->bca.len < 12 || s->bca.len > 188) {
1847		cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1848		return -EIO;
1849	}
1850	memcpy(s->bca.value, &buf[4], s->bca.len);
1851
1852	return 0;
1853}
1854
1855static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s)
1856{
1857	int ret = 0, size;
1858	u_char *buf;
1859	struct packet_command cgc;
1860	struct cdrom_device_ops *cdo = cdi->ops;
1861
1862	size = sizeof(s->manufact.value) + 4;
1863
1864	if ((buf = (u_char *) kmalloc(size, GFP_KERNEL)) == NULL)
1865		return -ENOMEM;
1866
1867	init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1868	cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1869	cgc.cmd[7] = s->type;
1870	cgc.cmd[8] = size >> 8;
1871	cgc.cmd[9] = size & 0xff;
1872
1873	if ((ret = cdo->generic_packet(cdi, &cgc))) {
1874		kfree(buf);
1875		return ret;
1876	}
1877
1878	s->manufact.len = buf[0] << 8 | buf[1];
1879	if (s->manufact.len < 0 || s->manufact.len > 2048) {
1880		cdinfo(CD_WARNING, "Received invalid manufacture info length"
1881				   " (%d)\n", s->manufact.len);
1882		ret = -EIO;
1883	} else {
1884		memcpy(s->manufact.value, &buf[4], s->manufact.len);
1885	}
1886
1887	kfree(buf);
1888	return ret;
1889}
1890
1891static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s)
1892{
1893	switch (s->type) {
1894	case DVD_STRUCT_PHYSICAL:
1895		return dvd_read_physical(cdi, s);
1896
1897	case DVD_STRUCT_COPYRIGHT:
1898		return dvd_read_copyright(cdi, s);
1899
1900	case DVD_STRUCT_DISCKEY:
1901		return dvd_read_disckey(cdi, s);
1902
1903	case DVD_STRUCT_BCA:
1904		return dvd_read_bca(cdi, s);
1905
1906	case DVD_STRUCT_MANUFACT:
1907		return dvd_read_manufact(cdi, s);
1908		
1909	default:
1910		cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1911					s->type);
1912		return -EINVAL;
1913	}
1914}
1915
1916int cdrom_mode_sense(struct cdrom_device_info *cdi,
1917		     struct packet_command *cgc,
1918		     int page_code, int page_control)
1919{
1920	struct cdrom_device_ops *cdo = cdi->ops;
1921
1922	memset(cgc->cmd, 0, sizeof(cgc->cmd));
1923
1924	cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1925	cgc->cmd[2] = page_code | (page_control << 6);
1926	cgc->cmd[7] = cgc->buflen >> 8;
1927	cgc->cmd[8] = cgc->buflen & 0xff;
1928	cgc->data_direction = CGC_DATA_READ;
1929	return cdo->generic_packet(cdi, cgc);
1930}
1931
1932int cdrom_mode_select(struct cdrom_device_info *cdi,
1933		      struct packet_command *cgc)
1934{
1935	struct cdrom_device_ops *cdo = cdi->ops;
1936
1937	memset(cgc->cmd, 0, sizeof(cgc->cmd));
1938	memset(cgc->buffer, 0, 2);
1939	cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1940	cgc->cmd[1] = 0x10;		/* PF */
1941	cgc->cmd[7] = cgc->buflen >> 8;
1942	cgc->cmd[8] = cgc->buflen & 0xff;
1943	cgc->data_direction = CGC_DATA_WRITE;
1944	return cdo->generic_packet(cdi, cgc);
1945}
1946
1947static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
1948				 struct cdrom_subchnl *subchnl, int mcn)
1949{
1950	struct cdrom_device_ops *cdo = cdi->ops;
1951	struct packet_command cgc;
1952	char buffer[32];
1953	int ret;
1954
1955	init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1956	cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
1957	cgc.cmd[1] = 2;     /* MSF addressing */
1958	cgc.cmd[2] = 0x40;  /* request subQ data */
1959	cgc.cmd[3] = mcn ? 2 : 1;
1960	cgc.cmd[8] = 16;
1961
1962	if ((ret = cdo->generic_packet(cdi, &cgc)))
1963		return ret;
1964
1965	subchnl->cdsc_audiostatus = cgc.buffer[1];
1966	subchnl->cdsc_format = CDROM_MSF;
1967	subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
1968	subchnl->cdsc_trk = cgc.buffer[6];
1969	subchnl->cdsc_ind = cgc.buffer[7];
1970
1971	subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
1972	subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
1973	subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
1974	subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
1975	subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
1976	subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
1977
1978	return 0;
1979}
1980
1981/*
1982 * Specific READ_10 interface
1983 */
1984static int cdrom_read_cd(struct cdrom_device_info *cdi,
1985			 struct packet_command *cgc, int lba,
1986			 int blocksize, int nblocks)
1987{
1988	struct cdrom_device_ops *cdo = cdi->ops;
1989
1990	memset(&cgc->cmd, 0, sizeof(cgc->cmd));
1991	cgc->cmd[0] = GPCMD_READ_10;
1992	cgc->cmd[2] = (lba >> 24) & 0xff;
1993	cgc->cmd[3] = (lba >> 16) & 0xff;
1994	cgc->cmd[4] = (lba >>  8) & 0xff;
1995	cgc->cmd[5] = lba & 0xff;
1996	cgc->cmd[6] = (nblocks >> 16) & 0xff;
1997	cgc->cmd[7] = (nblocks >>  8) & 0xff;
1998	cgc->cmd[8] = nblocks & 0xff;
1999	cgc->buflen = blocksize * nblocks;
2000	return cdo->generic_packet(cdi, cgc);
2001}
2002
2003/* very generic interface for reading the various types of blocks */
2004static int cdrom_read_block(struct cdrom_device_info *cdi,
2005			    struct packet_command *cgc,
2006			    int lba, int nblocks, int format, int blksize)
2007{
2008	struct cdrom_device_ops *cdo = cdi->ops;
2009
2010	memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2011	cgc->cmd[0] = GPCMD_READ_CD;
2012	/* expected sector size - cdda,mode1,etc. */
2013	cgc->cmd[1] = format << 2;
2014	/* starting address */
2015	cgc->cmd[2] = (lba >> 24) & 0xff;
2016	cgc->cmd[3] = (lba >> 16) & 0xff;
2017	cgc->cmd[4] = (lba >>  8) & 0xff;
2018	cgc->cmd[5] = lba & 0xff;
2019	/* number of blocks */
2020	cgc->cmd[6] = (nblocks >> 16) & 0xff;
2021	cgc->cmd[7] = (nblocks >>  8) & 0xff;
2022	cgc->cmd[8] = nblocks & 0xff;
2023	cgc->buflen = blksize * nblocks;
2024	
2025	/* set the header info returned */
2026	switch (blksize) {
2027	case CD_FRAMESIZE_RAW0	: cgc->cmd[9] = 0x58; break;
2028	case CD_FRAMESIZE_RAW1	: cgc->cmd[9] = 0x78; break;
2029	case CD_FRAMESIZE_RAW	: cgc->cmd[9] = 0xf8; break;
2030	default			: cgc->cmd[9] = 0x10;
2031	}
2032	
2033	return cdo->generic_packet(cdi, cgc);
2034}
2035
2036static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2037			       int lba, int nframes)
2038{
2039	struct packet_command cgc;
2040	int ret = 0;
2041	int nr;
2042
2043	cdi->last_sense = 0;
2044
2045	memset(&cgc, 0, sizeof(cgc));
2046
2047	/*
2048	 * start with will ra.nframes size, back down if alloc fails
2049	 */
2050	nr = nframes;
2051	do {
2052		cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2053		if (cgc.buffer)
2054			break;
2055
2056		nr >>= 1;
2057	} while (nr);
2058
2059	if (!nr)
2060		return -ENOMEM;
2061
2062	if (!access_ok(VERIFY_WRITE, ubuf, nframes * CD_FRAMESIZE_RAW)) {
2063		ret = -EFAULT;
2064		goto out;
2065	}
2066
2067	cgc.data_direction = CGC_DATA_READ;
2068	while (nframes > 0) {
2069		if (nr > nframes)
2070			nr = nframes;
2071
2072		ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2073		if (ret)
2074			break;
2075		if (__copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2076			ret = -EFAULT;
2077			break;
2078		}
2079		ubuf += CD_FRAMESIZE_RAW * nr;
2080		nframes -= nr;
2081		lba += nr;
2082	}
2083out:
2084	kfree(cgc.buffer);
2085	return ret;
2086}
2087
2088static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2089			       int lba, int nframes)
2090{
2091	request_queue_t *q = cdi->disk->queue;
2092	struct request *rq;
2093	struct bio *bio;
2094	unsigned int len;
2095	int nr, ret = 0;
2096
2097	if (!q)
2098		return -ENXIO;
2099
2100	cdi->last_sense = 0;
2101
2102	while (nframes) {
2103		nr = nframes;
2104		if (cdi->cdda_method == CDDA_BPC_SINGLE)
2105			nr = 1;
2106		if (nr * CD_FRAMESIZE_RAW > (q->max_sectors << 9))
2107			nr = (q->max_sectors << 9) / CD_FRAMESIZE_RAW;
2108
2109		len = nr * CD_FRAMESIZE_RAW;
2110
2111		rq = blk_rq_map_user(q, READ, ubuf, len);
2112		if (IS_ERR(rq))
2113			return PTR_ERR(rq);
2114
2115		memset(rq->cmd, 0, sizeof(rq->cmd));
2116		rq->cmd[0] = GPCMD_READ_CD;
2117		rq->cmd[1] = 1 << 2;
2118		rq->cmd[2] = (lba >> 24) & 0xff;
2119		rq->cmd[3] = (lba >> 16) & 0xff;
2120		rq->cmd[4] = (lba >>  8) & 0xff;
2121		rq->cmd[5] = lba & 0xff;
2122		rq->cmd[6] = (nr >> 16) & 0xff;
2123		rq->cmd[7] = (nr >>  8) & 0xff;
2124		rq->cmd[8] = nr & 0xff;
2125		rq->cmd[9] = 0xf8;
2126
2127		rq->cmd_len = 12;
2128		rq->flags |= REQ_BLOCK_PC;
2129		rq->timeout = 60 * HZ;
2130		bio = rq->bio;
2131
2132		if (rq->bio)
2133			blk_queue_bounce(q, &rq->bio);
2134
2135		if (blk_execute_rq(q, cdi->disk, rq)) {
2136			struct request_sense *s = rq->sense;
2137			ret = -EIO;
2138			cdi->last_sense = s->sense_key;
2139		}
2140
2141		if (blk_rq_unmap_user(rq, bio, len))
2142			ret = -EFAULT;
2143
2144		if (ret)
2145			break;
2146
2147		nframes -= nr;
2148		lba += nr;
2149		ubuf += len;
2150	}
2151
2152	return ret;
2153}
2154
2155static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2156			   int lba, int nframes)
2157{
2158	int ret;
2159
2160	if (cdi->cdda_method == CDDA_OLD)
2161		return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2162
2163retry:
2164	/*
2165	 * for anything else than success and io error, we need to retry
2166	 */
2167	ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2168	if (!ret || ret != -EIO)
2169		return ret;
2170
2171	/*
2172	 * I've seen drives get sense 4/8/3 udma crc errors on multi
2173	 * frame dma, so drop to single frame dma if we need to
2174	 */
2175	if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2176		printk("cdrom: dropping to single frame dma\n");
2177		cdi->cdda_method = CDDA_BPC_SINGLE;
2178		goto retry;
2179	}
2180
2181	/*
2182	 * so we have an io error of some sort with multi frame dma. if the
2183	 * condition wasn't a hardware error
2184	 * problems, not for any error
2185	 */
2186	if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2187		return ret;
2188
2189	printk("cdrom: dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2190	cdi->cdda_method = CDDA_OLD;
2191	return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);	
2192}
2193
2194/* Just about every imaginable ioctl is supported in the Uniform layer
2195 * these days. ATAPI / SCSI specific code now mainly resides in
2196 * mmc_ioct().
2197 */
2198int cdrom_ioctl(struct file * file, struct cdrom_device_info *cdi,
2199		struct inode *ip, unsigned int cmd, unsigned long arg)
2200{
2201	struct cdrom_device_ops *cdo = cdi->ops;
2202	int ret;
2203
2204	/* Try the generic SCSI command ioctl's first.. */
2205	ret = scsi_cmd_ioctl(file, ip->i_bdev->bd_disk, cmd, (void __user *)arg);
2206	if (ret != -ENOTTY)
2207		return ret;
2208
2209	/* the first few commands do not deal with audio drive_info, but
2210	   only with routines in cdrom device operations. */
2211	switch (cmd) {
2212	case CDROMMULTISESSION: {
2213		struct cdrom_multisession ms_info;
2214		u_char requested_format;
2215		cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n"); 
2216                if (!(cdo->capability & CDC_MULTI_SESSION))
2217                        return -ENOSYS;
2218		IOCTL_IN(arg, struct cdrom_multisession, ms_info);
2219		requested_format = ms_info.addr_format;
2220		if (!((requested_format == CDROM_MSF) ||
2221			(requested_format == CDROM_LBA)))
2222				return -EINVAL;
2223		ms_info.addr_format = CDROM_LBA;
2224		if ((ret=cdo->get_last_session(cdi, &ms_info)))
2225			return ret;
2226		sanitize_format(&ms_info.addr, &ms_info.addr_format,
2227				requested_format);
2228		IOCTL_OUT(arg, struct cdrom_multisession, ms_info);
2229		cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n"); 
2230		return 0;
2231		}
2232
2233	case CDROMEJECT: {
2234		cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n"); 
2235		if (!CDROM_CAN(CDC_OPEN_TRAY))
2236			return -ENOSYS;
2237		if (cdi->use_count != 1 || keeplocked)
2238			return -EBUSY;
2239		if (CDROM_CAN(CDC_LOCK))
2240			if ((ret=cdo->lock_door(cdi, 0)))
2241				return ret;
2242
2243		return cdo->tray_move(cdi, 1);
2244		}
2245
2246	case CDROMCLOSETRAY: {
2247		cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n"); 
2248		if (!CDROM_CAN(CDC_CLOSE_TRAY))
2249			return -ENOSYS;
2250		return cdo->tray_move(cdi, 0);
2251		}
2252
2253	case CDROMEJECT_SW: {
2254		cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n"); 
2255		if (!CDROM_CAN(CDC_OPEN_TRAY))
2256			return -ENOSYS;
2257		if (keeplocked)
2258			return -EBUSY;
2259		cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2260		if (arg)
2261			cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2262		return 0;
2263		}
2264
2265	case CDROM_MEDIA_CHANGED: {
2266		struct cdrom_changer_info *info;
2267		int changed;
2268
2269		cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n"); 
2270		if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2271			return -ENOSYS;
2272
2273		/* cannot select disc or select current disc */
2274		if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2275			return media_changed(cdi, 1);
2276
2277		if ((unsigned int)arg >= cdi->capacity)
2278			return -EINVAL;
2279
2280		info = kmalloc(sizeof(*info), GFP_KERNEL);
2281		if (!info)
2282			return -ENOMEM;
2283
2284		if ((ret = cdrom_read_mech_status(cdi, info))) {
2285			kfree(info);
2286			return ret;
2287		}
2288
2289		changed = info->slots[arg].change;
2290		kfree(info);
2291		return changed;
2292		}
2293
2294	case CDROM_SET_OPTIONS: {
2295		cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n"); 
2296		/* options need to be in sync with capability. too late for
2297		   that, so we have to check each one separately... */
2298		switch (arg) {
2299		case CDO_USE_FFLAGS:
2300		case CDO_CHECK_TYPE:
2301			break;
2302		case CDO_LOCK:
2303			if (!CDROM_CAN(CDC_LOCK))
2304				return -ENOSYS;
2305			break;
2306		case 0:
2307			return cdi->options;
2308		/* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2309		default:
2310			if (!CDROM_CAN(arg))
2311				return -ENOSYS;
2312		}
2313		cdi->options |= (int) arg;
2314		return cdi->options;
2315		}
2316
2317	case CDROM_CLEAR_OPTIONS: {
2318		cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n"); 
2319		cdi->options &= ~(int) arg;
2320		return cdi->options;
2321		}
2322
2323	case CDROM_SELECT_SPEED: {
2324		cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n"); 
2325		if (!CDROM_CAN(CDC_SELECT_SPEED))
2326			return -ENOSYS;
2327		return cdo->select_speed(cdi, arg);
2328		}
2329
2330	case CDROM_SELECT_DISC: {
2331		cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n"); 
2332		if (!CDROM_CAN(CDC_SELECT_DISC))
2333			return -ENOSYS;
2334
2335                if ((arg != CDSL_CURRENT) && (arg != CDSL_NONE))
2336			if ((int)arg >= cdi->capacity)
2337				return -EINVAL;
2338
2339		/* cdo->select_disc is a hook to allow a driver-specific
2340		 * way of seleting disc.  However, since there is no
2341		 * equiv hook for cdrom_slot_status this may not 
2342		 * actually be useful...
2343		 */
2344		if (cdo->select_disc != NULL)
2345			return cdo->select_disc(cdi, arg);
2346
2347		/* no driver specific select_disc(), call our own */
2348		cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n"); 
2349		return cdrom_select_disc(cdi, arg);
2350		}
2351
2352	case CDROMRESET: {
2353		if (!capable(CAP_SYS_ADMIN))
2354			return -EACCES;
2355		cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2356		if (!CDROM_CAN(CDC_RESET))
2357			return -ENOSYS;
2358		invalidate_bdev(ip->i_bdev, 0);
2359		return cdo->reset(cdi);
2360		}
2361
2362	case CDROM_LOCKDOOR: {
2363		cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2364		if (!CDROM_CAN(CDC_LOCK))
2365			return -EDRIVE_CANT_DO_THIS;
2366		keeplocked = arg ? 1 : 0;
2367		/* don't unlock the door on multiple opens,but allow root
2368		 * to do so */
2369		if ((cdi->use_count != 1) && !arg && !capable(CAP_SYS_ADMIN))
2370			return -EBUSY;
2371		return cdo->lock_door(cdi, arg);
2372		}
2373
2374	case CDROM_DEBUG: {
2375		if (!capable(CAP_SYS_ADMIN))
2376			return -EACCES;
2377		cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2378		debug = arg ? 1 : 0;
2379		return debug;
2380		}
2381
2382	case CDROM_GET_CAPABILITY: {
2383		cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2384		return (cdo->capability & ~cdi->mask);
2385		}
2386
2387/* The following function is implemented, although very few audio
2388 * discs give Universal Product Code information, which should just be
2389 * the Medium Catalog Number on the box.  Note, that the way the code
2390 * is written on the CD is /not/ uniform across all discs!
2391 */
2392	case CDROM_GET_MCN: {
2393		struct cdrom_mcn mcn;
2394		cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n"); 
2395		if (!(cdo->capability & CDC_MCN))
2396			return -ENOSYS;
2397		if ((ret=cdo->get_mcn(cdi, &mcn)))
2398			return ret;
2399		IOCTL_OUT(arg, struct cdrom_mcn, mcn);
2400		cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n"); 
2401		return 0;
2402		}
2403
2404	case CDROM_DRIVE_STATUS: {
2405		cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n"); 
2406		if (!(cdo->capability & CDC_DRIVE_STATUS))
2407			return -ENOSYS;
2408		if (!CDROM_CAN(CDC_SELECT_DISC))
2409			return cdo->drive_status(cdi, CDSL_CURRENT);
2410                if ((arg == CDSL_CURRENT) || (arg == CDSL_NONE)) 
2411			return cdo->drive_status(cdi, CDSL_CURRENT);
2412		if (((int)arg >= cdi->capacity))
2413			return -EINVAL;
2414		return cdrom_slot_status(cdi, arg);
2415		}
2416
2417	/* Ok, this is where problems start.  The current interface for the
2418	   CDROM_DISC_STATUS ioctl is flawed.  It makes the false assumption
2419	   that CDs are all CDS_DATA_1 or all CDS_AUDIO, etc.  Unfortunatly,
2420	   while this is often the case, it is also very common for CDs to
2421	   have some tracks with data, and some tracks with audio.  Just 
2422	   because I feel like it, I declare the following to be the best
2423	   way to cope.  If the CD has ANY data tracks on it, it will be
2424	   returned as a data CD.  If it has any XA tracks, I will return
2425	   it as that.  Now I could simplify this interface by combining these 
2426	   returns with the above, but this more clearly demonstrates
2427	   the problem with the current interface.  Too bad this wasn't 
2428	   designed to use bitmasks...         -Erik 
2429
2430	   Well, now we have the option CDS_MIXED: a mixed-type CD. 
2431	   User level programmers might feel the ioctl is not very useful.
2432	   					---david
2433	*/
2434	case CDROM_DISC_STATUS: {
2435		tracktype tracks;
2436		cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n"); 
2437		cdrom_count_tracks(cdi, &tracks);
2438		if (tracks.error) 
2439			return(tracks.error);
2440
2441		/* Policy mode on */
2442		if (tracks.audio > 0) {
2443			if (tracks.data==0 && tracks.cdi==0 && tracks.xa==0) 
2444				return CDS_AUDIO;
2445			else
2446				return CDS_MIXED;
2447		}
2448		if (tracks.cdi > 0) return CDS_XA_2_2;
2449		if (tracks.xa > 0) return CDS_XA_2_1;
2450		if (tracks.data > 0) return CDS_DATA_1;
2451		/* Policy mode off */
2452
2453		cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2454		return CDS_NO_INFO;
2455		}
2456
2457	case CDROM_CHANGER_NSLOTS: {
2458		cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n"); 
2459		return cdi->capacity;
2460		}
2461	}
2462
2463	/* use the ioctls that are implemented through the generic_packet()
2464	   interface. this may look at bit funny, but if -ENOTTY is
2465	   returned that particular ioctl is not implemented and we
2466	   let it go through the device specific ones. */
2467	if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2468		ret = mmc_ioctl(cdi, cmd, arg);
2469		if (ret != -ENOTTY) {
2470			return ret;
2471		}
2472	}
2473
2474	/* note: most of the cdinfo() calls are commented out here,
2475	   because they fill up the sys log when CD players poll
2476	   the drive. */
2477	switch (cmd) {
2478	case CDROMSUBCHNL: {
2479		struct cdrom_subchnl q;
2480		u_char requested, back;
2481		if (!CDROM_CAN(CDC_PLAY_AUDIO))
2482			return -ENOSYS;
2483		/* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/ 
2484		IOCTL_IN(arg, struct cdrom_subchnl, q);
2485		requested = q.cdsc_format;
2486		if (!((requested == CDROM_MSF) ||
2487		      (requested == CDROM_LBA)))
2488			return -EINVAL;
2489		q.cdsc_format = CDROM_MSF;
2490		if ((ret=cdo->audio_ioctl(cdi, cmd, &q)))
2491			return ret;
2492		back = q.cdsc_format; /* local copy */
2493		sanitize_format(&q.cdsc_absaddr, &back, requested);
2494		sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2495		IOCTL_OUT(arg, struct cdrom_subchnl, q);
2496		/* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */ 
2497		return 0;
2498		}
2499	case CDROMREADTOCHDR: {
2500		struct cdrom_tochdr header;
2501		if (!CDROM_CAN(CDC_PLAY_AUDIO))
2502			return -ENOSYS;
2503		/* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */ 
2504		IOCTL_IN(arg, struct cdrom_tochdr, header);
2505		if ((ret=cdo->audio_ioctl(cdi, cmd, &header)))
2506			return ret;
2507		IOCTL_OUT(arg, struct cdrom_tochdr, header);
2508		/* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */ 
2509		return 0;
2510		}
2511	case CDROMREADTOCENTRY: {
2512		struct cdrom_tocentry entry;
2513		u_char requested_format;
2514		if (!CDROM_CAN(CDC_PLAY_AUDIO))
2515			return -ENOSYS;
2516		/* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */ 
2517		IOCTL_IN(arg, struct cdrom_tocentry, entry);
2518		requested_format = entry.cdte_format;
2519		if (!((requested_format == CDROM_MSF) || 
2520			(requested_format == CDROM_LBA)))
2521				return -EINVAL;
2522		/* make interface to low-level uniform */
2523		entry.cdte_format = CDROM_MSF;
2524		if ((ret=cdo->audio_ioctl(cdi, cmd, &entry)))
2525			return ret;
2526		sanitize_format(&entry.cdte_addr,
2527		&entry.cdte_format, requested_format);
2528		IOCTL_OUT(arg, struct cdrom_tocentry, entry);
2529		/* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */ 
2530		return 0;
2531		}
2532	case CDROMPLAYMSF: {
2533		struct cdrom_msf msf;
2534		if (!CDROM_CAN(CDC_PLAY_AUDIO))
2535			return -ENOSYS;
2536		cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n"); 
2537		IOCTL_IN(arg, struct cdrom_msf, msf);
2538		return cdo->audio_ioctl(cdi, cmd, &msf);
2539		}
2540	case CDROMPLAYTRKIND: {
2541		struct cdrom_ti ti;
2542		if (!CDROM_CAN(CDC_PLAY_AUDIO))
2543			return -ENOSYS;
2544		cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n"); 
2545		IOCTL_IN(arg, struct cdrom_ti, ti);
2546		CHECKAUDIO;
2547		return cdo->audio_ioctl(cdi, cmd, &ti);
2548		}
2549	case CDROMVOLCTRL: {
2550		struct cdrom_volctrl volume;
2551		if (!CDROM_CAN(CDC_PLAY_AUDIO))
2552			return -ENOSYS;
2553		cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n"); 
2554		IOCTL_IN(arg, struct cdrom_volctrl, volume);
2555		return cdo->audio_ioctl(cdi, cmd, &volume);
2556		}
2557	case CDROMVOLREAD: {
2558		struct cdrom_volctrl volume;
2559		if (!CDROM_CAN(CDC_PLAY_AUDIO))
2560			return -ENOSYS;
2561		cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n"); 
2562		if ((ret=cdo->audio_ioctl(cdi, cmd, &volume)))
2563			return ret;
2564		IOCTL_OUT(arg, struct cdrom_volctrl, volume);
2565		return 0;
2566		}
2567	case CDROMSTART:
2568	case CDROMSTOP:
2569	case CDROMPAUSE:
2570	case CDROMRESUME: {
2571		if (!CDROM_CAN(CDC_PLAY_AUDIO))
2572			return -ENOSYS;
2573		cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n"); 
2574		CHECKAUDIO;
2575		return cdo->audio_ioctl(cdi, cmd, NULL);
2576		}
2577	} /* switch */
2578
2579	/* do the device specific ioctls */
2580	if (CDROM_CAN(CDC_IOCTLS))
2581		return cdo->dev_ioctl(cdi, cmd, arg);
2582	
2583	return -ENOSYS;
2584}
2585
2586static inline
2587int msf_to_lba(char m, char s, char f)
2588{
2589	return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2590}
2591
2592/*
2593 * Required when we need to use READ_10 to issue other than 2048 block
2594 * reads
2595 */
2596static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2597{
2598	struct cdrom_device_ops *cdo = cdi->ops;
2599	struct packet_command cgc;
2600	struct modesel_head mh;
2601
2602	memset(&mh, 0, sizeof(mh));
2603	mh.block_desc_length = 0x08;
2604	mh.block_length_med = (size >> 8) & 0xff;
2605	mh.block_length_lo = size & 0xff;
2606
2607	memset(&cgc, 0, sizeof(cgc));
2608	cgc.cmd[0] = 0x15;
2609	cgc.cmd[1] = 1 << 4;
2610	cgc.cmd[4] = 12;
2611	cgc.buflen = sizeof(mh);
2612	cgc.buffer = (char *) &mh;
2613	cgc.data_direction = CGC_DATA_WRITE;
2614	mh.block_desc_length = 0x08;
2615	mh.block_length_med = (size >> 8) & 0xff;
2616	mh.block_length_lo = size & 0xff;
2617
2618	return cdo->generic_packet(cdi, &cgc);
2619}
2620
2621static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
2622		     unsigned long arg)
2623{		
2624	struct cdrom_device_ops *cdo = cdi->ops;
2625	struct packet_command cgc;
2626	struct request_sense sense;
2627	unsigned char buffer[32];
2628	int ret = 0;
2629
2630	memset(&cgc, 0, sizeof(cgc));
2631
2632	/* build a unified command and queue it through
2633	   cdo->generic_packet() */
2634	switch (cmd) {
2635	case CDROMREADRAW:
2636	case CDROMREADMODE1:
2637	case CDROMREADMODE2: {
2638		struct cdrom_msf msf;
2639		int blocksize = 0, format = 0, lba;
2640		
2641		switch (cmd) {
2642		case CDROMREADRAW:
2643			blocksize = CD_FRAMESIZE_RAW;
2644			break;
2645		case CDROMREADMODE1:
2646			blocksize = CD_FRAMESIZE;
2647			format = 2;
2648			break;
2649		case CDROMREADMODE2:
2650			blocksize = CD_FRAMESIZE_RAW0;
2651			break;
2652		}
2653		IOCTL_IN(arg, struct cdrom_msf, msf);
2654		lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
2655		/* FIXME: we need upper bound checking, too!! */
2656		if (lba < 0)
2657			return -EINVAL;
2658		cgc.buffer = (char *) kmalloc(blocksize, GFP_KERNEL);
2659		if (cgc.buffer == NULL)
2660			return -ENOMEM;
2661		memset(&sense, 0, sizeof(sense));
2662		cgc.sense = &sense;
2663		cgc.data_direction = CGC_DATA_READ;
2664		ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
2665		if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) {
2666			/*
2667			 * SCSI-II devices are not required to support
2668			 * READ_CD, so let's try switching block size
2669			 */
2670			/* FIXME: switch back again... */
2671			if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
2672				kfree(cgc.buffer);
2673				return ret;
2674			}
2675			cgc.sense = NULL;
2676			ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
2677			ret |= cdrom_switch_blocksize(cdi, blocksize);
2678		}
2679		if (!ret && copy_to_user((char __user *)arg, cgc.buffer, blocksize))
2680			ret = -EFAULT;
2681		kfree(cgc.buffer);
2682		return ret;
2683		}
2684	case CDROMREADAUDIO: {
2685		struct cdrom_read_audio ra;
2686		int lba;
2687
2688		IOCTL_IN(arg, struct cdrom_read_audio, ra);
2689
2690		if (ra.addr_format == CDROM_MSF)
2691			lba = msf_to_lba(ra.addr.msf.minute,
2692					 ra.addr.msf.second,
2693					 ra.addr.msf.frame);
2694		else if (ra.addr_format == CDROM_LBA)
2695			lba = ra.addr.lba;
2696		else
2697			return -EINVAL;
2698
2699		/* FIXME: we need upper bound checking, too!! */
2700		if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2701			return -EINVAL;
2702
2703		return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2704		}
2705	case CDROMSUBCHNL: {
2706		struct cdrom_subchnl q;
2707		u_char requested, back;
2708		IOCTL_IN(arg, struct cdrom_subchnl, q);
2709		requested = q.cdsc_format;
2710		if (!((requested == CDROM_MSF) ||
2711		      (requested == CDROM_LBA)))
2712			return -EINVAL;
2713		q.cdsc_format = CDROM_MSF;
2714		if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
2715			return ret;
2716		back = q.cdsc_format; /* local copy */
2717		sanitize_format(&q.cdsc_absaddr, &back, requested);
2718		sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2719		IOCTL_OUT(arg, struct cdrom_subchnl, q);
2720		/* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */ 
2721		return 0;
2722		}
2723	case CDROMPLAYMSF: {
2724		struct cdrom_msf msf;
2725		cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2726		IOCTL_IN(arg, struct cdrom_msf, msf);
2727		cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2728		cgc.cmd[3] = msf.cdmsf_min0;
2729		cgc.cmd[4] = msf.cdmsf_sec0;
2730		cgc.cmd[5] = msf.cdmsf_frame0;
2731		cgc.cmd[6] = msf.cdmsf_min1;
2732		cgc.cmd[7] = msf.cdmsf_sec1;
2733		cgc.cmd[8] = msf.cdmsf_frame1;
2734		cgc.data_direction = CGC_DATA_NONE;
2735		return cdo->generic_packet(cdi, &cgc);
2736		}
2737	case CDROMPLAYBLK: {
2738		struct cdrom_blk blk;
2739		cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2740		IOCTL_IN(arg, struct cdrom_blk, blk);
2741		cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
2742		cgc.cmd[2] = (blk.from >> 24) & 0xff;
2743		cgc.cmd[3] = (blk.from >> 16) & 0xff;
2744		cgc.cmd[4] = (blk.from >>  8) & 0xff;
2745		cgc.cmd[5] = blk.from & 0xff;
2746		cgc.cmd[7] = (blk.len >> 8) & 0xff;
2747		cgc.cmd[8] = blk.len & 0xff;
2748		cgc.data_direction = CGC_DATA_NONE;
2749		return cdo->generic_packet(cdi, &cgc);
2750		}
2751	case CDROMVOLCTRL:
2752	case CDROMVOLREAD: {
2753		struct cdrom_volctrl volctrl;
2754		char mask[sizeof(buffer)];
2755		unsigned short offset;
2756
2757		cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
2758
2759		IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
2760
2761		cgc.buffer = buffer;
2762		cgc.buflen = 24;
2763		if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
2764		    return ret;
2765		
2766		/* originally the code depended on buffer[1] to determine
2767		   how much data is available for transfer. buffer[1] is
2768		   unfortunately ambigious and the only reliable way seem
2769		   to be to simply skip over the block descriptor... */
2770		offset = 8 + be16_to_cpu(*(unsigned short *)(buffer+6));
2771
2772		if (offset + 16 > sizeof(buffer))
2773			return -E2BIG;
2774
2775		if (offset + 16 > cgc.buflen) {
2776			cgc.buflen = offset+16;
2777			ret = cdrom_mode_sense(cdi, &cgc,
2778						GPMODE_AUDIO_CTL_PAGE, 0);
2779			if (ret)
2780				return ret;
2781		}
2782
2783		/* sanity check */
2784		if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
2785				buffer[offset+1] < 14)
2786			return -EINVAL;
2787
2788		/* now we have the current volume settings. if it was only
2789		   a CDROMVOLREAD, return these values */
2790		if (cmd == CDROMVOLREAD) {
2791			volctrl.channel0 = buffer[offset+9];
2792			volctrl.channel1 = buffer[offset+11];
2793			volctrl.channel2 = buffer[offset+13];
2794			volctrl.channel3 = buffer[offset+15];
2795			IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
2796			return 0;
2797		}
2798		
2799		/* get the volume mask */
2800		cgc.buffer = mask;
2801		if ((ret = cdrom_mode_sense(cdi, &cgc, 
2802				GPMODE_AUDIO_CTL_PAGE, 1)))
2803			return ret;
2804
2805		buffer[offset+9] = volctrl.channel0 & mask[offset+9];
2806		buffer[offset+11] = volctrl.channel1 & mask[offset+11];
2807		buffer[offset+13] = volctrl.channel2 & mask[offset+13];
2808		buffer[offset+15] = volctrl.channel3 & mask[offset+15];
2809
2810		/* set volume */
2811		cgc.buffer = buffer + offset - 8;
2812		memset(cgc.buffer, 0, 8);
2813		return cdrom_mode_select(cdi, &cgc);
2814		}
2815
2816	case CDROMSTART:
2817	case CDROMSTOP: {
2818		cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n"); 
2819		cgc.cmd[0] = GPCMD_START_STOP_UNIT;
2820		cgc.cmd[1] = 1;
2821		cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
2822		cgc.data_direction = CGC_DATA_NONE;
2823		return cdo->generic_packet(cdi, &cgc);
2824		}
2825
2826	case CDROMPAUSE:
2827	case CDROMRESUME: {
2828		cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n"); 
2829		cgc.cmd[0] = GPCMD_PAUSE_RESUME;
2830		cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
2831		cgc.data_direction = CGC_DATA_NONE;
2832		return cdo->generic_packet(cdi, &cgc);
2833		}
2834
2835	case DVD_READ_STRUCT: {
2836		dvd_struct *s;
2837		int size = sizeof(dvd_struct);
2838		if (!CDROM_CAN(CDC_DVD))
2839			return -ENOSYS;
2840		if ((s = (dvd_struct *) kmalloc(size, GFP_KERNEL)) == NULL)
2841			return -ENOMEM;
2842		cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n"); 
2843		if (copy_from_user(s, (dvd_struct __user *)arg, size)) {
2844			kfree(s);
2845			return -EFAULT;
2846		}
2847		if ((ret = dvd_read_struct(cdi, s))) {
2848			kfree(s);
2849			return ret;
2850		}
2851		if (copy_to_user((dvd_struct __user *)arg, s, size))
2852			ret = -EFAULT;
2853		kfree(s);
2854		return ret;
2855		}
2856
2857	case DVD_AUTH: {
2858		dvd_authinfo ai;
2859		if (!CDROM_CAN(CDC_DVD))
2860			return -ENOSYS;
2861		cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n"); 
2862		IOCTL_IN(arg, dvd_authinfo, ai);
2863		if ((ret = dvd_do_auth (cdi, &ai)))
2864			return ret;
2865		IOCTL_OUT(arg, dvd_authinfo, ai);
2866		return 0;
2867		}
2868
2869	case CDROM_NEXT_WRITABLE: {
2870		long next = 0;
2871		cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n"); 
2872		if ((ret = cdrom_get_next_writable(cdi, &next)))
2873			return ret;
2874		IOCTL_OUT(arg, long, next);
2875		return 0;
2876		}
2877	case CDROM_LAST_WRITTEN: {
2878		long last = 0;
2879		cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n"); 
2880		if ((ret = cdrom_get_last_written(cdi, &last)))
2881			return ret;
2882		IOCTL_OUT(arg, long, last);
2883		return 0;
2884		}
2885	} /* switch */
2886
2887	return -ENOTTY;
2888}
2889
2890static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
2891			 track_information *ti)
2892{
2893	struct cdrom_device_ops *cdo = cdi->ops;
2894	struct packet_command cgc;
2895	int ret, buflen;
2896
2897	init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
2898	cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
2899	cgc.cmd[1] = type & 3;
2900	cgc.cmd[4] = (track & 0xff00) >> 8;
2901	cgc.cmd[5] = track & 0xff;
2902	cgc.cmd[8] = 8;
2903	cgc.quiet = 1;
2904
2905	if ((ret = cdo->generic_packet(cdi, &cgc)))
2906		return ret;
2907	
2908	buflen = be16_to_cpu(ti->track_information_length) +
2909		     sizeof(ti->track_information_length);
2910
2911	if (buflen > sizeof(track_information))
2912		buflen = sizeof(track_information);
2913
2914	cgc.cmd[8] = cgc.buflen = buflen;
2915	if ((ret = cdo->generic_packet(cdi, &cgc)))
2916		return ret;
2917
2918	/* return actual fill size */
2919	return buflen;
2920}
2921
2922/* requires CD R/RW */
2923static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
2924{
2925	struct cdrom_device_ops *cdo = cdi->ops;
2926	struct packet_command cgc;
2927	int ret, buflen;
2928
2929	/* set up command and get the disc info */
2930	init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
2931	cgc.cmd[0] = GPCMD_READ_DISC_INFO;
2932	cgc.cmd[8] = cgc.buflen = 2;
2933	cgc.quiet = 1;
2934
2935	if ((ret = cdo->generic_packet(cdi, &cgc)))
2936		return ret;
2937
2938	/* not all drives have the same disc_info length, so requeue
2939	 * packet with the length the drive tells us it can supply
2940	 */
2941	buflen = be16_to_cpu(di->disc_information_length) +
2942		     sizeof(di->disc_information_length);
2943
2944	if (buflen > sizeof(disc_information))
2945		buflen = sizeof(disc_information);
2946
2947	cgc.cmd[8] = cgc.buflen = buflen;
2948	if ((ret = cdo->generic_packet(cdi, &cgc)))
2949		return ret;
2950
2951	/* return actual fill size */
2952	return buflen;
2953}
2954
2955/* return the last written block on the CD-R media. this is for the udf
2956   file system. */
2957int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
2958{
2959	struct cdrom_tocentry toc;
2960	disc_information di;
2961	track_information ti;
2962	__u32 last_track;
2963	int ret = -1, ti_size;
2964
2965	if (!CDROM_CAN(CDC_GENERIC_PACKET))
2966		goto use_toc;
2967
2968	ret = cdrom_get_disc_info(cdi, &di);
2969	if (ret < (int)(offsetof(typeof(di), last_track_lsb)
2970			+ sizeof(di.last_track_lsb)))
2971		goto use_toc;
2972
2973	/* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2974	last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2975	ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2976	if (ti_size < (int)offsetof(typeof(ti), track_start))
2977		goto use_toc;
2978
2979	/* if this track is blank, try the previous. */
2980	if (ti.blank) {
2981		if (last_track==1)
2982			goto use_toc;
2983		last_track--;
2984		ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2985	}
2986
2987	if (ti_size < (int)(offsetof(typeof(ti), track_size)
2988				+ sizeof(ti.track_size)))
2989		goto use_toc;
2990
2991	/* if last recorded field is valid, return it. */
2992	if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
2993				+ sizeof(ti.last_rec_address))) {
2994		*last_written = be32_to_cpu(ti.last_rec_address);
2995	} else {
2996		/* make it up instead */
2997		*last_written = be32_to_cpu(ti.track_start) +
2998				be32_to_cpu(ti.track_size);
2999		if (ti.free_blocks)
3000			*last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3001	}
3002	return 0;
3003
3004	/* this is where we end up if the drive either can't do a
3005	   GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3006	   it doesn't give enough information or fails. then we return
3007	   the toc contents. */
3008use_toc:
3009	toc.cdte_format = CDROM_MSF;
3010	toc.cdte_track = CDROM_LEADOUT;
3011	if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
3012		return ret;
3013	sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
3014	*last_written = toc.cdte_addr.lba;
3015	return 0;
3016}
3017
3018/* return the next writable block. also for udf file system. */
3019static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3020{
3021	disc_information di;
3022	track_information ti;
3023	__u16 last_track;
3024	int ret, ti_size;
3025
3026	if (!CDROM_CAN(CDC_GENERIC_PACKET))
3027		goto use_last_written;
3028
3029	ret = cdrom_get_disc_info(cdi, &di);
3030	if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3031				+ sizeof(di.last_track_lsb))
3032		goto use_last_written;
3033
3034	/* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3035	last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3036	ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3037	if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3038		goto use_last_written;
3039
3040        /* if this track is blank, try the previous. */
3041	if (ti.blank) {
3042		if (last_track == 1)
3043			goto use_last_written;
3044		last_track--;
3045		ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3046		if (ti_size < 0)
3047			goto use_last_written;
3048	}
3049
3050	/* if next recordable address field is valid, use it. */
3051	if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
3052				+ sizeof(ti.next_writable)) {
3053		*next_writable = be32_to_cpu(ti.next_writable);
3054		return 0;
3055	}
3056
3057use_last_written:
3058	if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3059		*next_writable = 0;
3060		return ret;
3061	} else {
3062		*next_writable += 7;
3063		return 0;
3064	}
3065}
3066
3067EXPORT_SYMBOL(cdrom_get_last_written);
3068EXPORT_SYMBOL(register_cdrom);
3069EXPORT_SYMBOL(unregister_cdrom);
3070EXPORT_SYMBOL(cdrom_open);
3071EXPORT_SYMBOL(cdrom_release);
3072EXPORT_SYMBOL(cdrom_ioctl);
3073EXPORT_SYMBOL(cdrom_media_changed);
3074EXPORT_SYMBOL(cdrom_number_of_slots);
3075EXPORT_SYMBOL(cdrom_mode_select);
3076EXPORT_SYMBOL(cdrom_mode_sense);
3077EXPORT_SYMBOL(init_cdrom_command);
3078EXPORT_SYMBOL(cdrom_get_media_event);
3079
3080#ifdef CONFIG_SYSCTL
3081
3082#define CDROM_STR_SIZE 1000
3083
3084static struct cdrom_sysctl_settings {
3085	char	info[CDROM_STR_SIZE];	/* general info */
3086	int	autoclose;		/* close tray upon mount, etc */
3087	int	autoeject;		/* eject on umount */
3088	int	debug;			/* turn on debugging messages */
3089	int	lock;			/* lock the door on device open */
3090	int	check;			/* check media type */
3091} cdrom_sysctl_settings;
3092
3093static int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
3094                           void __user *buffer, size_t *lenp, loff_t *ppos)
3095{
3096        int pos;
3097	struct cdrom_device_info *cdi;
3098	char *info = cdrom_sysctl_settings.info;
3099	
3100	if (!*lenp || (*ppos && !write)) {
3101		*lenp = 0;
3102		return 0;
3103	}
3104
3105	pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3106	
3107	pos += sprintf(info+pos, "\ndrive name:\t");
3108	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3109	    pos += sprintf(info+pos, "\t%s", cdi->name);
3110
3111	pos += sprintf(info+pos, "\ndrive speed:\t");
3112	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3113	    pos += sprintf(info+pos, "\t%d", cdi->speed);
3114
3115	pos += sprintf(info+pos, "\ndrive # of slots:");
3116	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3117	    pos += sprintf(info+pos, "\t%d", cdi->capacity);
3118
3119	pos += sprintf(info+pos, "\nCan close tray:\t");
3120	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3121	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_CLOSE_TRAY) != 0);
3122
3123	pos += sprintf(info+pos, "\nCan open tray:\t");
3124	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3125	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_OPEN_TRAY) != 0);
3126
3127	pos += sprintf(info+pos, "\nCan lock tray:\t");
3128	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3129	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_LOCK) != 0);
3130
3131	pos += sprintf(info+pos, "\nCan change speed:");
3132	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3133	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_SELECT_SPEED) != 0);
3134
3135	pos += sprintf(info+pos, "\nCan select disk:");
3136	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3137	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_SELECT_DISC) != 0);
3138
3139	pos += sprintf(info+pos, "\nCan read multisession:");
3140	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3141	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MULTI_SESSION) != 0);
3142
3143	pos += sprintf(info+pos, "\nCan read MCN:\t");
3144	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3145	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MCN) != 0);
3146
3147	pos += sprintf(info+pos, "\nReports media changed:");
3148	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3149	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MEDIA_CHANGED) != 0);
3150
3151	pos += sprintf(info+pos, "\nCan play audio:\t");
3152	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3153	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_PLAY_AUDIO) != 0);
3154
3155	pos += sprintf(info+pos, "\nCan write CD-R:\t");
3156	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3157	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_CD_R) != 0);
3158
3159	pos += sprintf(info+pos, "\nCan write CD-RW:");
3160	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3161	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_CD_RW) != 0);
3162
3163	pos += sprintf(info+pos, "\nCan read DVD:\t");
3164	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3165	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD) != 0);
3166
3167	pos += sprintf(info+pos, "\nCan write DVD-R:");
3168	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3169	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD_R) != 0);
3170
3171	pos += sprintf(info+pos, "\nCan write DVD-RAM:");
3172	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3173	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD_RAM) != 0);
3174
3175	pos += sprintf(info+pos, "\nCan read MRW:\t");
3176	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3177	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MRW) != 0);
3178
3179	pos += sprintf(info+pos, "\nCan write MRW:\t");
3180	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3181	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MRW_W) != 0);
3182
3183	pos += sprintf(info+pos, "\nCan write RAM:\t");
3184	for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3185	    pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_RAM) != 0);
3186
3187	strcpy(info+pos,"\n\n");
3188		
3189        return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
3190}
3191
3192/* Unfortunately, per device settings are not implemented through
3193   procfs/sysctl yet. When they are, this will naturally disappear. For now
3194   just update all drives. Later this will become the template on which
3195   new registered drives will be based. */
3196static void cdrom_update_settings(void)
3197{
3198	struct cdrom_device_info *cdi;
3199
3200	for (cdi = topCdromPtr; cdi != NULL; cdi = cdi->next) {
3201		if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3202			cdi->options |= CDO_AUTO_CLOSE;
3203		else if (!autoclose)
3204			cdi->options &= ~CDO_AUTO_CLOSE;
3205		if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3206			cdi->options |= CDO_AUTO_EJECT;
3207		else if (!autoeject)
3208			cdi->options &= ~CDO_AUTO_EJECT;
3209		if (lockdoor && CDROM_CAN(CDC_LOCK))
3210			cdi->options |= CDO_LOCK;
3211		else if (!lockdoor)
3212			cdi->options &= ~CDO_LOCK;
3213		if (check_media_type)
3214			cdi->options |= CDO_CHECK_TYPE;
3215		else
3216			cdi->options &= ~CDO_CHECK_TYPE;
3217	}
3218}
3219
3220static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
3221				void __user *buffer, size_t *lenp, loff_t *ppos)
3222{
3223	int *valp = ctl->data;
3224	int val = *valp;
3225	int ret;
3226	
3227	ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
3228
3229	if (write && *valp != val) {
3230	
3231		/* we only care for 1 or 0. */
3232		if (*valp)
3233			*valp = 1;
3234		else
3235			*valp = 0;
3236
3237		switch (ctl->ctl_name) {
3238		case DEV_CDROM_AUTOCLOSE: {
3239			if (valp == &cdrom_sysctl_settings.autoclose)
3240				autoclose = cdrom_sysctl_settings.autoclose;
3241			break;
3242			}
3243		case DEV_CDROM_AUTOEJECT: {
3244			if (valp == &cdrom_sysctl_settings.autoeject)
3245				autoeject = cdrom_sysctl_settings.autoeject;
3246			break;
3247			}
3248		case DEV_CDROM_DEBUG: {
3249			if (valp == &cdrom_sysctl_settings.debug)
3250				debug = cdrom_sysctl_settings.debug;
3251			break;
3252			}
3253		case DEV_CDROM_LOCK: {
3254			if (valp == &cdrom_sysctl_settings.lock)
3255				lockdoor = cdrom_sysctl_settings.lock;
3256			break;
3257			}
3258		case DEV_CDROM_CHECK_MEDIA: {
3259			if (valp == &cdrom_sysctl_settings.check)
3260				check_media_type = cdrom_sysctl_settings.check;
3261			break;
3262			}
3263		}
3264		/* update the option flags according to the changes. we
3265		   don't have per device options through sysctl yet,
3266		   but we will have and then this will disappear. */
3267		cdrom_update_settings();
3268	}
3269
3270        return ret;
3271}
3272
3273/* Place files in /proc/sys/dev/cdrom */
3274static ctl_table cdrom_table[] = {
3275	{
3276		.ctl_name	= DEV_CDROM_INFO,
3277		.procname	= "info",
3278		.data		= &cdrom_sysctl_settings.info, 
3279		.maxlen		= CDROM_STR_SIZE,
3280		.mode		= 0444,
3281		.proc_handler	= &cdrom_sysctl_info,
3282	},
3283	{
3284		.ctl_name	= DEV_CDROM_AUTOCLOSE,
3285		.procname	= "autoclose",
3286		.data		= &cdrom_sysctl_settings.autoclose,
3287		.maxlen		= sizeof(int),
3288		.mode		= 0644,
3289		.proc_handler	= &cdrom_sysctl_handler,
3290	},
3291	{
3292		.ctl_name	= DEV_CDROM_AUTOEJECT,
3293		.procname	= "autoeject",
3294		.data		= &cdrom_sysctl_settings.autoeject,
3295		.maxlen		= sizeof(int),
3296		.mode		= 0644,
3297		.proc_handler	= &cdrom_sysctl_handler,
3298	},
3299	{
3300		.ctl_name	= DEV_CDROM_DEBUG,
3301		.procname	= "debug",
3302		.data		= &cdrom_sysctl_settings.debug,
3303		.maxlen		= sizeof(int),
3304		.mode		= 0644,
3305		.proc_handler	= &cdrom_sysctl_handler,
3306	},
3307	{
3308		.ctl_name	= DEV_CDROM_LOCK,
3309		.procname	= "lock",
3310		.data		= &cdrom_sysctl_settings.lock,
3311		.maxlen		= sizeof(int),
3312		.mode		= 0644,
3313		.proc_handler	= &cdrom_sysctl_handler,
3314	},
3315	{
3316		.ctl_name	= DEV_CDROM_CHECK_MEDIA,
3317		.procname	= "check_media",
3318		.data		= &cdrom_sysctl_settings.check,
3319		.maxlen		= sizeof(int),
3320		.mode		= 0644,
3321		.proc_handler	= &cdrom_sysctl_handler
3322	},
3323	{ .ctl_name = 0 }
3324};
3325
3326static ctl_table cdrom_cdrom_table[] = {
3327	{
3328		.ctl_name	= DEV_CDROM,
3329		.procname	= "cdrom",
3330		.maxlen		= 0,
3331		.mode		= 0555,
3332		.child		= cdrom_table,
3333	},
3334	{ .ctl_name = 0 }
3335};
3336
3337/* Make sure that /proc/sys/dev is there */
3338static ctl_table cdrom_root_table[] = {
3339	{
3340		.ctl_name	= CTL_DEV,
3341		.procname	= "dev",
3342		.maxlen		= 0,
3343		.mode		= 0555,
3344		.child		= cdrom_cdrom_table,
3345	},
3346	{ .ctl_name = 0 }
3347};
3348static struct ctl_table_header *cdrom_sysctl_header;
3349
3350static void cdrom_sysctl_register(void)
3351{
3352	static int initialized;
3353
3354	if (initialized == 1)
3355		return;
3356
3357	cdrom_sysctl_header = register_sysctl_table(cdrom_root_table, 1);
3358	if (cdrom_root_table->ctl_name && cdrom_root_table->child->de)
3359		cdrom_root_table->child->de->owner = THIS_MODULE;
3360
3361	/* set the defaults */
3362	cdrom_sysctl_settings.autoclose = autoclose;
3363	cdrom_sysctl_settings.autoeject = autoeject;
3364	cdrom_sysctl_settings.debug = debug;
3365	cdrom_sysctl_settings.lock = lockdoor;
3366	cdrom_sysctl_settings.check = check_media_type;
3367
3368	initialized = 1;
3369}
3370
3371static void cdrom_sysctl_unregister(void)
3372{
3373	if (cdrom_sysctl_header)
3374		unregister_sysctl_table(cdrom_sysctl_header);
3375}
3376
3377#endif /* CONFIG_SYSCTL */
3378
3379static int __init cdrom_init(void)
3380{
3381#ifdef CONFIG_SYSCTL
3382	cdrom_sysctl_register();
3383#endif
3384	return 0;
3385}
3386
3387static void __exit cdrom_exit(void)
3388{
3389	printk(KERN_INFO "Uniform CD-ROM driver unloaded\n");
3390#ifdef CONFIG_SYSCTL
3391	cdrom_sysctl_unregister();
3392#endif
3393}
3394
3395module_init(cdrom_init);
3396module_exit(cdrom_exit);
3397MODULE_LICENSE("GPL");