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