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