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