LCOV - code coverage report
Current view: top level - drivers/cdrom - cdrom.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 38 1993 1.9 %
Date: 2017-01-25 Functions: 4 107 3.7 %

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

Generated by: LCOV version 1.10