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