drivers/cdrom/cdrom.c

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