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