drivers/cdrom/cdrom.c

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