开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
cdrom.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：77k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

cdrom.c：源码内容
  1. /* linux/drivers/cdrom/cdrom.c. 
  2.    Copyright (c) 1996, 1997 David A. van Leeuwen.
  3.    Copyright (c) 1997, 1998 Erik Andersen <andersee@debian.org>
  4.    Copyright (c) 1998, 1999 Jens Axboe <axboe@image.dk>
  6.    May be copied or modified under the terms of the GNU General Public
  7.    License.  See linux/COPYING for more information.
  9.    Uniform CD-ROM driver for Linux.
  10.    See Documentation/cdrom/cdrom-standard.tex for usage information.
  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.  ;-)
  17.  To Do List:
  18.  ----------------------------------
  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!
  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?
  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.
  37.   -- Added (rudimentary) sysctl interface. I realize this is really weak
  38.   right now, and is _very_ badly implemented. It will be improved...
  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.
  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.
  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).
  54.   -- Made it so if a function isn't implemented in a low-level driver,
  55.   ENOSYS is now returned instead of EINVAL.
  57.   -- Simplified some complex logic so that the source code is easier to read.
  59.   -- Other stuff I probably forgot to mention (lots of changes).
  61. 2.01 to 2.11 Dec 1997-Jan 1998
  62.   -- TO-DO!  Write changelogs for 2.01 to 2.12.
  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.
  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.
  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.
  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.
  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 loose the index part, however.
  176.   -- Small modifications to accomodate 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.
  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.
  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.
  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.
  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.
  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
  228.    3.12 Oct 18, 2000 - Jens Axboe <axboe@suse.de>
  229.   -- Use quiet bit on packet commands not known to work
  231. -------------------------------------------------------------------------*/
  233. #define REVISION "Revision: 3.12"
  234. #define VERSION "Id: cdrom.c 3.12 2000/10/18"
  236. /* I use an error-log mask to give fine grain control over the type of
  237.    messages dumped to the system logs.  The available masks include: */
  238. #define CD_NOTHING      0x0
  239. #define CD_WARNING 0x1
  240. #define CD_REG_UNREG 0x2
  241. #define CD_DO_IOCTL 0x4
  242. #define CD_OPEN 0x8
  243. #define CD_CLOSE 0x10
  244. #define CD_COUNT_TRACKS 0x20
  245. #define CD_CHANGER 0x40
  246. #define CD_DVD 0x80
  248. /* Define this to remove _all_ the debugging messages */
  249. /* #define ERRLOGMASK CD_NOTHING */
  250. #define ERRLOGMASK (CD_WARNING)
  251. /* #define ERRLOGMASK (CD_WARNING|CD_OPEN|CD_COUNT_TRACKS|CD_CLOSE) */
  252. /* #define ERRLOGMASK (CD_WARNING|CD_REG_UNREG|CD_DO_IOCTL|CD_OPEN|CD_CLOSE|CD_COUNT_TRACKS) */
  254. #include <linux/config.h>
  255. #include <linux/module.h>
  256. #include <linux/fs.h>
  257. #include <linux/major.h>
  258. #include <linux/types.h>
  259. #include <linux/errno.h>
  260. #include <linux/kernel.h>
  261. #include <linux/mm.h>
  262. #include <linux/slab.h> 
  263. #include <linux/cdrom.h>
  264. #include <linux/sysctl.h>
  265. #include <linux/proc_fs.h>
  266. #include <linux/init.h>
  268. #include <asm/fcntl.h>
  269. #include <asm/segment.h>
  270. #include <asm/uaccess.h>
  272. /* used to tell the module to turn on full debugging messages */
  273. static int debug;
  274. /* used to keep tray locked at all times */
  275. static int keeplocked;
  276. /* default compatibility mode */
  277. static int autoclose=1;
  278. static int autoeject;
  279. static int lockdoor = 1;
  280. /* will we ever get to use this... sigh. */
  281. static int check_media_type;
  282. MODULE_PARM(debug, "i");
  283. MODULE_PARM(autoclose, "i");
  284. MODULE_PARM(autoeject, "i");
  285. MODULE_PARM(lockdoor, "i");
  286. MODULE_PARM(check_media_type, "i");
  288. #if (ERRLOGMASK!=CD_NOTHING)
  289. #define cdinfo(type, fmt, args...) 
  290.         if ((ERRLOGMASK & type) || debug==1 ) 
  291.             printk(KERN_INFO "cdrom: " fmt, ## args)
  292. #else
  293. #define cdinfo(type, fmt, args...) 
  294. #endif
  296. /* These are used to simplify getting data in from and back to user land */
  297. #define IOCTL_IN(arg, type, in)
  298. if (copy_from_user(&(in), (type *) (arg), sizeof (in)))
  299. return -EFAULT;
  301. #define IOCTL_OUT(arg, type, out) 
  302. if (copy_to_user((type *) (arg), &(out), sizeof (out)))
  303. return -EFAULT;
  305. /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
  306.    a lot of places. This macro makes the code more clear. */
  307. #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
  309. /* used in the audio ioctls */
  310. #define CHECKAUDIO if ((ret=check_for_audio_disc(cdi, cdo))) return ret
  312. /* Not-exported routines. */
  313. static int open_for_data(struct cdrom_device_info * cdi);
  314. static int check_for_audio_disc(struct cdrom_device_info * cdi,
  315.  struct cdrom_device_ops * cdo);
  316. static void sanitize_format(union cdrom_addr *addr, 
  317. u_char * curr, u_char requested);
  318. static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
  319.      unsigned long arg);
  321. int cdrom_get_last_written(kdev_t dev, long *last_written);
  322. int cdrom_get_next_writable(kdev_t dev, long *next_writable);
  324. #ifdef CONFIG_SYSCTL
  325. static void cdrom_sysctl_register(void);
  326. #endif /* CONFIG_SYSCTL */ 
  327. static struct cdrom_device_info *topCdromPtr;
  328. static devfs_handle_t devfs_handle;
  329. static struct unique_numspace cdrom_numspace = UNIQUE_NUMBERSPACE_INITIALISER;
  331. /* This macro makes sure we don't have to check on cdrom_device_ops
  332.  * existence in the run-time routines below. Change_capability is a
  333.  * hack to have the capability flags defined const, while we can still
  334.  * change it here without gcc complaining at every line.
  335.  */
  336. #define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
  338. int register_cdrom(struct cdrom_device_info *cdi)
  339. {
  340. static char banner_printed;
  341. int major = MAJOR(cdi->dev);
  342.         struct cdrom_device_ops *cdo = cdi->ops;
  343.         int *change_capability = (int *)&cdo->capability; /* hack */
  345. cdinfo(CD_OPEN, "entering register_cdromn"); 
  347. if (major < 0 || major >= MAX_BLKDEV)
  348. return -1;
  349. if (cdo->open == NULL || cdo->release == NULL)
  350. return -2;
  351. if ( !banner_printed ) {
  352. printk(KERN_INFO "Uniform CD-ROM driver " REVISION "n");
  353. banner_printed = 1;
  354. #ifdef CONFIG_SYSCTL
  355. cdrom_sysctl_register();
  356. #endif /* CONFIG_SYSCTL */ 
  357. }
  358. ENSURE(drive_status, CDC_DRIVE_STATUS );
  359. ENSURE(media_changed, CDC_MEDIA_CHANGED);
  360. ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
  361. ENSURE(lock_door, CDC_LOCK);
  362. ENSURE(select_speed, CDC_SELECT_SPEED);
  363. ENSURE(get_last_session, CDC_MULTI_SESSION);
  364. ENSURE(get_mcn, CDC_MCN);
  365. ENSURE(reset, CDC_RESET);
  366. ENSURE(audio_ioctl, CDC_PLAY_AUDIO);
  367. ENSURE(dev_ioctl, CDC_IOCTLS);
  368. ENSURE(generic_packet, CDC_GENERIC_PACKET);
  369. cdi->mc_flags = 0;
  370. cdo->n_minors = 0;
  371.         cdi->options = CDO_USE_FFLAGS;
  373. if (autoclose==1 && CDROM_CAN(CDC_CLOSE_TRAY))
  374. cdi->options |= (int) CDO_AUTO_CLOSE;
  375. if (autoeject==1 && CDROM_CAN(CDC_OPEN_TRAY))
  376. cdi->options |= (int) CDO_AUTO_EJECT;
  377. if (lockdoor==1)
  378. cdi->options |= (int) CDO_LOCK;
  379. if (check_media_type==1)
  380. cdi->options |= (int) CDO_CHECK_TYPE;
  382. if (!devfs_handle)
  383. devfs_handle = devfs_mk_dir (NULL, "cdroms", NULL);
  384. cdi->number = devfs_alloc_unique_number (&cdrom_numspace);
  385. if (cdi->de) {
  386. int pos;
  387. devfs_handle_t slave;
  388. char rname[64];
  390. pos = devfs_generate_path (cdi->de, rname + 3,
  391.    sizeof rname - 3);
  392. if (pos >= 0) {
  393. char vname[16];
  394. sprintf (vname, "cdrom%d", cdi->number);
  395. strncpy (rname + pos, "../", 3);
  396. devfs_mk_symlink (devfs_handle, vname,
  397.   DEVFS_FL_DEFAULT,
  398.   rname + pos, &slave, NULL);
  399. devfs_auto_unregister (cdi->de, slave);
  400. }
  401. }
  402. cdinfo(CD_REG_UNREG, "drive "/dev/%s" registeredn", cdi->name);
  403. cdi->next = topCdromPtr; 
  404. topCdromPtr = cdi;
  405. return 0;
  406. }
  407. #undef ENSURE
  409. int unregister_cdrom(struct cdrom_device_info *unreg)
  410. {
  411. struct cdrom_device_info *cdi, *prev;
  412. int major = MAJOR(unreg->dev);
  414. cdinfo(CD_OPEN, "entering unregister_cdromn"); 
  416. if (major < 0 || major >= MAX_BLKDEV)
  417. return -1;
  419. prev = NULL;
  420. cdi = topCdromPtr;
  421. while (cdi != NULL && cdi->dev != unreg->dev) {
  422. prev = cdi;
  423. cdi = cdi->next;
  424. }
  426. if (cdi == NULL)
  427. return -2;
  428. if (prev)
  429. prev->next = cdi->next;
  430. else
  431. topCdromPtr = cdi->next;
  432. cdi->ops->n_minors--;
  433. devfs_unregister (cdi->de);
  434. devfs_dealloc_unique_number (&cdrom_numspace, cdi->number);
  435. cdinfo(CD_REG_UNREG, "drive "/dev/%s" unregisteredn", cdi->name);
  436. return 0;
  437. }
  439. struct cdrom_device_info *cdrom_find_device(kdev_t dev)
  440. {
  441. struct cdrom_device_info *cdi;
  443. cdi = topCdromPtr;
  444. while (cdi != NULL && cdi->dev != dev)
  445. cdi = cdi->next;
  447. return cdi;
  448. }
  450. /* We use the open-option O_NONBLOCK to indicate that the
  451.  * purpose of opening is only for subsequent ioctl() calls; no device
  452.  * integrity checks are performed.
  453.  *
  454.  * We hope that all cd-player programs will adopt this convention. It
  455.  * is in their own interest: device control becomes a lot easier
  456.  * this way.
  457.  */
  458. int cdrom_open(struct inode *ip, struct file *fp)
  459. {
  460. struct cdrom_device_info *cdi;
  461. kdev_t dev = ip->i_rdev;
  462. int ret;
  464. cdinfo(CD_OPEN, "entering cdrom_openn"); 
  465. if ((cdi = cdrom_find_device(dev)) == NULL)
  466. return -ENODEV;
  468. if ((fp->f_mode & FMODE_WRITE) && !CDROM_CAN(CDC_DVD_RAM))
  469. return -EROFS;
  471. /* if this was a O_NONBLOCK open and we should honor the flags,
  472.  * do a quick open without drive/disc integrity checks. */
  473. if ((fp->f_flags & O_NONBLOCK) && (cdi->options & CDO_USE_FFLAGS))
  474. ret = cdi->ops->open(cdi, 1);
  475. else
  476. ret = open_for_data(cdi);
  478. if (!ret) cdi->use_count++;
  480. cdinfo(CD_OPEN, "Use count for "/dev/%s" now %dn", cdi->name, cdi->use_count);
  481. /* Do this on open.  Don't wait for mount, because they might
  482.     not be mounting, but opening with O_NONBLOCK */
  483. check_disk_change(dev);
  484. return ret;
  485. }
  487. static
  488. int open_for_data(struct cdrom_device_info * cdi)
  489. {
  490. int ret;
  491. struct cdrom_device_ops *cdo = cdi->ops;
  492. tracktype tracks;
  493. cdinfo(CD_OPEN, "entering open_for_datan");
  494. /* Check if the driver can report drive status.  If it can, we
  495.    can do clever things.  If it can't, well, we at least tried! */
  496. if (cdo->drive_status != NULL) {
  497. ret = cdo->drive_status(cdi, CDSL_CURRENT);
  498. cdinfo(CD_OPEN, "drive_status=%dn", ret); 
  499. if (ret == CDS_TRAY_OPEN) {
  500. cdinfo(CD_OPEN, "the tray is open...n"); 
  501. /* can/may i close it? */
  502. if (CDROM_CAN(CDC_CLOSE_TRAY) &&
  503.     cdi->options & CDO_AUTO_CLOSE) {
  504. cdinfo(CD_OPEN, "trying to close the tray.n"); 
  505. ret=cdo->tray_move(cdi,0);
  506. if (ret) {
  507. cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.n"); 
  508. /* Ignore the error from the low
  509. level driver.  We don't care why it
  510. couldn't close the tray.  We only care 
  511. that there is no disc in the drive, 
  512. since that is the _REAL_ problem here.*/
  513. ret=-ENOMEDIUM;
  514. goto clean_up_and_return;
  515. }
  516. } else {
  517. cdinfo(CD_OPEN, "bummer. this drive can't close the tray.n"); 
  518. ret=-ENOMEDIUM;
  519. goto clean_up_and_return;
  520. }
  521. /* Ok, the door should be closed now.. Check again */
  522. ret = cdo->drive_status(cdi, CDSL_CURRENT);
  523. if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
  524. cdinfo(CD_OPEN, "bummer. the tray is still not closed.n"); 
  525. cdinfo(CD_OPEN, "tray might not contain a medium.n");
  526. ret=-ENOMEDIUM;
  527. goto clean_up_and_return;
  528. }
  529. cdinfo(CD_OPEN, "the tray is now closed.n"); 
  530. }
  531. if (ret!=CDS_DISC_OK) {
  532. ret = -ENOMEDIUM;
  533. goto clean_up_and_return;
  534. }
  535. }
  536. cdrom_count_tracks(cdi, &tracks);
  537. if (tracks.error == CDS_NO_DISC) {
  538. cdinfo(CD_OPEN, "bummer. no disc.n");
  539. ret=-ENOMEDIUM;
  540. goto clean_up_and_return;
  541. }
  542. /* CD-Players which don't use O_NONBLOCK, workman
  543.  * for example, need bit CDO_CHECK_TYPE cleared! */
  544. if (tracks.data==0) {
  545. if (cdi->options & CDO_CHECK_TYPE) {
  546.     /* give people a warning shot, now that CDO_CHECK_TYPE
  547.        is the default case! */
  548.     cdinfo(CD_OPEN, "bummer. wrong media type.n"); 
  549.     cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!n",
  550. (unsigned int)current->pid); 
  551.     ret=-EMEDIUMTYPE;
  552.     goto clean_up_and_return;
  553. }
  554. else {
  555.     cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.n");
  556. }
  557. }
  559. cdinfo(CD_OPEN, "all seems well, opening the device.n"); 
  561. /* all seems well, we can open the device */
  562. ret = cdo->open(cdi, 0); /* open for data */
  563. cdinfo(CD_OPEN, "opening the device gave me %d.n", ret); 
  564. /* After all this careful checking, we shouldn't have problems
  565.    opening the device, but we don't want the device locked if 
  566.    this somehow fails... */
  567. if (ret) {
  568. cdinfo(CD_OPEN, "open device failed.n"); 
  569. goto clean_up_and_return;
  570. }
  571. if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
  572. cdo->lock_door(cdi, 1);
  573. cdinfo(CD_OPEN, "door locked.n");
  574. }
  575. cdinfo(CD_OPEN, "device opened successfully.n"); 
  576. return ret;
  578. /* Something failed.  Try to unlock the drive, because some drivers
  579. (notably ide-cd) lock the drive after every command.  This produced
  580. a nasty bug where after mount failed, the drive would remain locked!  
  581. This ensures that the drive gets unlocked after a mount fails.  This 
  582. is a goto to avoid bloating the driver with redundant code. */ 
  583. clean_up_and_return:
  584. cdinfo(CD_WARNING, "open failed.n"); 
  585. if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
  586. cdo->lock_door(cdi, 0);
  587. cdinfo(CD_OPEN, "door unlocked.n");
  588. }
  589. return ret;
  590. }
  592. /* This code is similar to that in open_for_data. The routine is called
  593.    whenever an audio play operation is requested.
  594. */
  595. int check_for_audio_disc(struct cdrom_device_info * cdi,
  596.  struct cdrom_device_ops * cdo)
  597. {
  598.         int ret;
  599. tracktype tracks;
  600. cdinfo(CD_OPEN, "entering check_for_audio_discn");
  601. if (!(cdi->options & CDO_CHECK_TYPE))
  602. return 0;
  603. if (cdo->drive_status != NULL) {
  604. ret = cdo->drive_status(cdi, CDSL_CURRENT);
  605. cdinfo(CD_OPEN, "drive_status=%dn", ret); 
  606. if (ret == CDS_TRAY_OPEN) {
  607. cdinfo(CD_OPEN, "the tray is open...n"); 
  608. /* can/may i close it? */
  609. if (CDROM_CAN(CDC_CLOSE_TRAY) &&
  610.     cdi->options & CDO_AUTO_CLOSE) {
  611. cdinfo(CD_OPEN, "trying to close the tray.n"); 
  612. ret=cdo->tray_move(cdi,0);
  613. if (ret) {
  614. cdinfo(CD_OPEN, "bummer. tried to close tray but failed.n"); 
  615. /* Ignore the error from the low
  616. level driver.  We don't care why it
  617. couldn't close the tray.  We only care 
  618. that there is no disc in the drive, 
  619. since that is the _REAL_ problem here.*/
  620. return -ENOMEDIUM;
  621. }
  622. } else {
  623. cdinfo(CD_OPEN, "bummer. this driver can't close the tray.n"); 
  624. return -ENOMEDIUM;
  625. }
  626. /* Ok, the door should be closed now.. Check again */
  627. ret = cdo->drive_status(cdi, CDSL_CURRENT);
  628. if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
  629. cdinfo(CD_OPEN, "bummer. the tray is still not closed.n"); 
  630. return -ENOMEDIUM;
  631. }
  632. if (ret!=CDS_DISC_OK) {
  633. cdinfo(CD_OPEN, "bummer. disc isn't ready.n"); 
  634. return -EIO;
  635. }
  636. cdinfo(CD_OPEN, "the tray is now closed.n"); 
  637. }
  638. }
  639. cdrom_count_tracks(cdi, &tracks);
  640. if (tracks.error) 
  641. return(tracks.error);
  643. if (tracks.audio==0)
  644. return -EMEDIUMTYPE;
  646. return 0;
  647. }
  650. /* Admittedly, the logic below could be performed in a nicer way. */
  651. int cdrom_release(struct inode *ip, struct file *fp)
  652. {
  653. kdev_t dev = ip->i_rdev;
  654. struct cdrom_device_info *cdi = cdrom_find_device(dev);
  655. struct cdrom_device_ops *cdo = cdi->ops;
  656. int opened_for_data;
  658. cdinfo(CD_CLOSE, "entering cdrom_releasen"); 
  660. if (cdi->use_count > 0)
  661. cdi->use_count--;
  662. if (cdi->use_count == 0)
  663. cdinfo(CD_CLOSE, "Use count for "/dev/%s" now zeron", cdi->name);
  664. if (cdi->use_count == 0 &&
  665.     cdo->capability & CDC_LOCK && !keeplocked) {
  666. cdinfo(CD_CLOSE, "Unlocking door!n");
  667. cdo->lock_door(cdi, 0);
  668. }
  669. opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
  670. !(fp && fp->f_flags & O_NONBLOCK);
  671. cdo->release(cdi);
  672. if (cdi->use_count == 0) {      /* last process that closes dev*/
  673. if (opened_for_data &&
  674.     cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
  675. cdo->tray_move(cdi, 1);
  676. }
  677. return 0;
  678. }
  680. static int cdrom_read_mech_status(struct cdrom_device_info *cdi, 
  681.   struct cdrom_changer_info *buf)
  682. {
  683. struct cdrom_generic_command cgc;
  684. struct cdrom_device_ops *cdo = cdi->ops;
  685. int length;
  687. /*
  688.  * Sanyo changer isn't spec compliant (doesn't use regular change
  689.  * LOAD_UNLOAD command, and it doesn't implement the mech status
  690.  * command below
  691.  */
  692. if (cdi->sanyo_slot) {
  693. buf->hdr.nslots = 3;
  694. buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
  695. for (length = 0; length < 3; length++) {
  696. buf->slots[length].disc_present = 1;
  697. buf->slots[length].change = 0;
  698. }
  699. return 0;
  700. }
  702. length = sizeof(struct cdrom_mechstat_header) +
  703.  cdi->capacity * sizeof(struct cdrom_slot);
  705. init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
  706. cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
  707. cgc.cmd[8] = (length >> 8) & 0xff;
  708. cgc.cmd[9] = length & 0xff;
  709. return cdo->generic_packet(cdi, &cgc);
  710. }
  712. static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
  713. {
  714. struct cdrom_changer_info info;
  715. int ret;
  717. cdinfo(CD_CHANGER, "entering cdrom_slot_status()n"); 
  718. if (cdi->sanyo_slot)
  719. return CDS_NO_INFO;
  721. if ((ret = cdrom_read_mech_status(cdi, &info)))
  722. return ret;
  724. if (info.slots[slot].disc_present)
  725. return CDS_DISC_OK;
  726. else
  727. return CDS_NO_DISC;
  729. }
  731. /* Return the number of slots for an ATAPI/SCSI cdrom, 
  732.  * return 1 if not a changer. 
  733.  */
  734. int cdrom_number_of_slots(struct cdrom_device_info *cdi) 
  735. {
  736. int status;
  737. int nslots = 1;
  738. struct cdrom_changer_info info;
  740. cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()n"); 
  741. /* cdrom_read_mech_status requires a valid value for capacity: */
  742. cdi->capacity = 0; 
  744. if ((status = cdrom_read_mech_status(cdi, &info)) == 0)
  745. nslots = info.hdr.nslots;
  747. return nslots;
  748. }
  751. /* If SLOT < 0, unload the current slot.  Otherwise, try to load SLOT. */
  752. static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot) 
  753. {
  754. struct cdrom_generic_command cgc;
  756. cdinfo(CD_CHANGER, "entering cdrom_load_unload()n"); 
  757. if (cdi->sanyo_slot && slot < 0)
  758. return 0;
  760. init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
  761. cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
  762. cgc.cmd[4] = 2 + (slot >= 0);
  763. cgc.cmd[8] = slot;
  764. cgc.timeout = 60 * HZ;
  766. /* The Sanyo 3 CD changer uses byte 7 of the 
  767. GPCMD_TEST_UNIT_READY to command to switch CDs instead of
  768. using the GPCMD_LOAD_UNLOAD opcode. */
  769. if (cdi->sanyo_slot && -1 < slot) {
  770. cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
  771. cgc.cmd[7] = slot;
  772. cgc.cmd[4] = cgc.cmd[8] = 0;
  773. cdi->sanyo_slot = slot ? slot : 3;
  774. }
  776. return cdi->ops->generic_packet(cdi, &cgc);
  777. }
  779. int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
  780. {
  781. struct cdrom_changer_info info;
  782. int curslot;
  783. int ret;
  785. cdinfo(CD_CHANGER, "entering cdrom_select_disc()n"); 
  786. if (!CDROM_CAN(CDC_SELECT_DISC))
  787. return -EDRIVE_CANT_DO_THIS;
  789. (void) cdi->ops->media_changed(cdi, slot);
  791. if (slot == CDSL_NONE) {
  792. /* set media changed bits, on both queues */
  793. cdi->mc_flags = 0x3;
  794. return cdrom_load_unload(cdi, -1);
  795. }
  797. if ((ret = cdrom_read_mech_status(cdi, &info)))
  798. return ret;
  800. curslot = info.hdr.curslot;
  802. if (cdi->use_count > 1 || keeplocked) {
  803. if (slot == CDSL_CURRENT) {
  804.      return curslot;
  805. } else {
  806. return -EBUSY;
  807. }
  808. }
  810. /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
  811. which is useful if it had been previously unloaded.
  812. Whether it can or not, it returns the current slot. 
  813. Similarly,  if slot happens to be the current one, we still
  814. try and load it. */
  815. if (slot == CDSL_CURRENT)
  816. slot = curslot;
  818. /* set media changed bits on both queues */
  819. cdi->mc_flags = 0x3;
  820. if ((ret = cdrom_load_unload(cdi, slot)))
  821. return ret;
  823. return slot;
  824. }
  826. /* We want to make media_changed accessible to the user through an
  827.  * ioctl. The main problem now is that we must double-buffer the
  828.  * low-level implementation, to assure that the VFS and the user both
  829.  * see a medium change once.
  830.  */
  832. static
  833. int media_changed(struct cdrom_device_info *cdi, int queue)
  834. {
  835. unsigned int mask = (1 << (queue & 1));
  836. int ret = !!(cdi->mc_flags & mask);
  838. if (!CDROM_CAN(CDC_MEDIA_CHANGED))
  839.     return ret;
  840. /* changed since last call? */
  841. if (cdi->ops->media_changed(cdi, CDSL_CURRENT)) {
  842. cdi->mc_flags = 0x3;    /* set bit on both queues */
  843. ret |= 1;
  844. }
  845. cdi->mc_flags &= ~mask;         /* clear bit */
  846. return ret;
  847. }
  849. int cdrom_media_changed(kdev_t dev)
  850. {
  851. struct cdrom_device_info *cdi = cdrom_find_device(dev);
  852. /* This talks to the VFS, which doesn't like errors - just 1 or 0.  
  853.  * Returning "0" is always safe (media hasn't been changed). Do that 
  854.  * if the low-level cdrom driver dosn't support media changed. */ 
  855. if (cdi == NULL || cdi->ops->media_changed == NULL)
  856. return 0;
  857. if (!CDROM_CAN(CDC_MEDIA_CHANGED))
  858. return 0;
  859. return media_changed(cdi, 0);
  860. }
  862. /* badly broken, I know. Is due for a fixup anytime. */
  863. void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
  864. {
  865. struct cdrom_tochdr header;
  866. struct cdrom_tocentry entry;
  867. int ret, i;
  868. tracks->data=0;
  869. tracks->audio=0;
  870. tracks->cdi=0;
  871. tracks->xa=0;
  872. tracks->error=0;
  873. cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracksn"); 
  874.         if (!CDROM_CAN(CDC_PLAY_AUDIO)) { 
  875.                 tracks->error=CDS_NO_INFO;
  876.                 return;
  877.         }        
  878. /* Grab the TOC header so we can see how many tracks there are */
  879. if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
  880. if (ret == -ENOMEDIUM)
  881. tracks->error = CDS_NO_DISC;
  882. else
  883. tracks->error = CDS_NO_INFO;
  884. return;
  885. }
  886. /* check what type of tracks are on this disc */
  887. entry.cdte_format = CDROM_MSF;
  888. for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
  889. entry.cdte_track  = i;
  890. if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
  891. tracks->error=CDS_NO_INFO;
  892. return;
  893. }
  894. if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
  895.     if (entry.cdte_format == 0x10)
  896. tracks->cdi++;
  897.     else if (entry.cdte_format == 0x20) 
  898. tracks->xa++;
  899.     else
  900. tracks->data++;
  901. } else
  902.     tracks->audio++;
  903. cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%dn",
  904.        i, entry.cdte_format, entry.cdte_ctrl);
  905. }
  906. cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XAn", 
  907. header.cdth_trk1, tracks->audio, tracks->data, 
  908. tracks->cdi, tracks->xa);
  909. }
  911. /* Requests to the low-level drivers will /always/ be done in the
  912.    following format convention:
  914.    CDROM_LBA: all data-related requests.
  915.    CDROM_MSF: all audio-related requests.
  917.    However, a low-level implementation is allowed to refuse this
  918.    request, and return information in its own favorite format.
  920.    It doesn't make sense /at all/ to ask for a play_audio in LBA
  921.    format, or ask for multi-session info in MSF format. However, for
  922.    backward compatibility these format requests will be satisfied, but
  923.    the requests to the low-level drivers will be sanitized in the more
  924.    meaningful format indicated above.
  925.  */
  927. static
  928. void sanitize_format(union cdrom_addr *addr,
  929.      u_char * curr, u_char requested)
  930. {
  931. if (*curr == requested)
  932. return;                 /* nothing to be done! */
  933. if (requested == CDROM_LBA) {
  934. addr->lba = (int) addr->msf.frame +
  935. 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
  936. } else {                        /* CDROM_MSF */
  937. int lba = addr->lba;
  938. addr->msf.frame = lba % 75;
  939. lba /= 75;
  940. lba += 2;
  941. addr->msf.second = lba % 60;
  942. addr->msf.minute = lba / 60;
  943. }
  944. *curr = requested;
  945. }
  947. void init_cdrom_command(struct cdrom_generic_command *cgc, void *buf, int len,
  948. int type)
  949. {
  950. memset(cgc, 0, sizeof(struct cdrom_generic_command));
  951. if (buf)
  952. memset(buf, 0, len);
  953. cgc->buffer = (char *) buf;
  954. cgc->buflen = len;
  955. cgc->data_direction = type;
  956. cgc->timeout = 5*HZ;
  957. }
  959. /* DVD handling */
  961. #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
  962. #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
  964. static void setup_report_key(struct cdrom_generic_command *cgc, unsigned agid, unsigned type)
  965. {
  966. cgc->cmd[0] = GPCMD_REPORT_KEY;
  967. cgc->cmd[10] = type | (agid << 6);
  968. switch (type) {
  969. case 0: case 8: case 5: {
  970. cgc->buflen = 8;
  971. break;
  972. }
  973. case 1: {
  974. cgc->buflen = 16;
  975. break;
  976. }
  977. case 2: case 4: {
  978. cgc->buflen = 12;
  979. break;
  980. }
  981. }
  982. cgc->cmd[9] = cgc->buflen;
  983. cgc->data_direction = CGC_DATA_READ;
  984. }
  986. static void setup_send_key(struct cdrom_generic_command *cgc, unsigned agid, unsigned type)
  987. {
  988. cgc->cmd[0] = GPCMD_SEND_KEY;
  989. cgc->cmd[10] = type | (agid << 6);
  990. switch (type) {
  991. case 1: {
  992. cgc->buflen = 16;
  993. break;
  994. }
  995. case 3: {
  996. cgc->buflen = 12;
  997. break;
  998. }
  999. case 6: {
  1000. cgc->buflen = 8;
  1001. break;
  1002. }
  1003. }
  1004. cgc->cmd[9] = cgc->buflen;
  1005. cgc->data_direction = CGC_DATA_WRITE;
  1006. }
  1008. static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
  1009. {
  1010. int ret;
  1011. u_char buf[20];
  1012. struct cdrom_generic_command cgc;
  1013. struct cdrom_device_ops *cdo = cdi->ops;
  1014. rpc_state_t rpc_state;
  1016. memset(buf, 0, sizeof(buf));
  1017. init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
  1019. switch (ai->type) {
  1020. /* LU data send */
  1021. case DVD_LU_SEND_AGID:
  1022. cdinfo(CD_DVD, "entering DVD_LU_SEND_AGIDn"); 
  1023. setup_report_key(&cgc, ai->lsa.agid, 0);
  1025. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1026. return ret;
  1028. ai->lsa.agid = buf[7] >> 6;
  1029. /* Returning data, let host change state */
  1030. break;
  1032. case DVD_LU_SEND_KEY1:
  1033. cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1n"); 
  1034. setup_report_key(&cgc, ai->lsk.agid, 2);
  1036. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1037. return ret;
  1039. copy_key(ai->lsk.key, &buf[4]);
  1040. /* Returning data, let host change state */
  1041. break;
  1043. case DVD_LU_SEND_CHALLENGE:
  1044. cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGEn"); 
  1045. setup_report_key(&cgc, ai->lsc.agid, 1);
  1047. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1048. return ret;
  1050. copy_chal(ai->lsc.chal, &buf[4]);
  1051. /* Returning data, let host change state */
  1052. break;
  1054. /* Post-auth key */
  1055. case DVD_LU_SEND_TITLE_KEY:
  1056. cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEYn"); 
  1057. setup_report_key(&cgc, ai->lstk.agid, 4);
  1058. cgc.cmd[5] = ai->lstk.lba;
  1059. cgc.cmd[4] = ai->lstk.lba >> 8;
  1060. cgc.cmd[3] = ai->lstk.lba >> 16;
  1061. cgc.cmd[2] = ai->lstk.lba >> 24;
  1063. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1064. return ret;
  1066. ai->lstk.cpm = (buf[4] >> 7) & 1;
  1067. ai->lstk.cp_sec = (buf[4] >> 6) & 1;
  1068. ai->lstk.cgms = (buf[4] >> 4) & 3;
  1069. copy_key(ai->lstk.title_key, &buf[5]);
  1070. /* Returning data, let host change state */
  1071. break;
  1073. case DVD_LU_SEND_ASF:
  1074. cdinfo(CD_DVD, "entering DVD_LU_SEND_ASFn"); 
  1075. setup_report_key(&cgc, ai->lsasf.agid, 5);
  1077. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1078. return ret;
  1080. ai->lsasf.asf = buf[7] & 1;
  1081. break;
  1083. /* LU data receive (LU changes state) */
  1084. case DVD_HOST_SEND_CHALLENGE:
  1085. cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGEn"); 
  1086. setup_send_key(&cgc, ai->hsc.agid, 1);
  1087. buf[1] = 0xe;
  1088. copy_chal(&buf[4], ai->hsc.chal);
  1090. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1091. return ret;
  1093. ai->type = DVD_LU_SEND_KEY1;
  1094. break;
  1096. case DVD_HOST_SEND_KEY2:
  1097. cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2n"); 
  1098. setup_send_key(&cgc, ai->hsk.agid, 3);
  1099. buf[1] = 0xa;
  1100. copy_key(&buf[4], ai->hsk.key);
  1102. if ((ret = cdo->generic_packet(cdi, &cgc))) {
  1103. ai->type = DVD_AUTH_FAILURE;
  1104. return ret;
  1105. }
  1106. ai->type = DVD_AUTH_ESTABLISHED;
  1107. break;
  1109. /* Misc */
  1110. case DVD_INVALIDATE_AGID:
  1111. cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGIDn"); 
  1112. setup_report_key(&cgc, ai->lsa.agid, 0x3f);
  1113. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1114. return ret;
  1115. break;
  1117. /* Get region settings */
  1118. case DVD_LU_SEND_RPC_STATE:
  1119. cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATEn");
  1120. setup_report_key(&cgc, 0, 8);
  1121. memset(&rpc_state, 0, sizeof(rpc_state_t));
  1122. cgc.buffer = (char *) &rpc_state;
  1124. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1125. return ret;
  1127. ai->lrpcs.type = rpc_state.type_code;
  1128. ai->lrpcs.vra = rpc_state.vra;
  1129. ai->lrpcs.ucca = rpc_state.ucca;
  1130. ai->lrpcs.region_mask = rpc_state.region_mask;
  1131. ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
  1132. break;
  1134. /* Set region settings */
  1135. case DVD_HOST_SEND_RPC_STATE:
  1136. cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATEn");
  1137. setup_send_key(&cgc, 0, 6);
  1138. buf[1] = 6;
  1139. buf[4] = ai->hrpcs.pdrc;
  1141. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1142. return ret;
  1143. break;
  1145. default:
  1146. cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)n", ai->type);
  1147. return -ENOTTY;
  1148. }
  1150. return 0;
  1151. }
  1153. static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
  1154. {
  1155. unsigned char buf[20], *base;
  1156. struct dvd_layer *layer;
  1157. struct cdrom_generic_command cgc;
  1158. struct cdrom_device_ops *cdo = cdi->ops;
  1159. int ret, layer_num = s->physical.layer_num;
  1161. if (layer_num >= DVD_LAYERS)
  1162. return -EINVAL;
  1164. init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
  1165. cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
  1166. cgc.cmd[6] = layer_num;
  1167. cgc.cmd[7] = s->type;
  1168. cgc.cmd[9] = cgc.buflen & 0xff;
  1170. /*
  1171.  * refrain from reporting errors on non-existing layers (mainly)
  1172.  */
  1173. cgc.quiet = 1;
  1175. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1176. return ret;
  1178. base = &buf[4];
  1179. layer = &s->physical.layer[layer_num];
  1181. /*
  1182.  * place the data... really ugly, but at least we won't have to
  1183.  * worry about endianess in userspace.
  1184.  */
  1185. memset(layer, 0, sizeof(*layer));
  1186. layer->book_version = base[0] & 0xf;
  1187. layer->book_type = base[0] >> 4;
  1188. layer->min_rate = base[1] & 0xf;
  1189. layer->disc_size = base[1] >> 4;
  1190. layer->layer_type = base[2] & 0xf;
  1191. layer->track_path = (base[2] >> 4) & 1;
  1192. layer->nlayers = (base[2] >> 5) & 3;
  1193. layer->track_density = base[3] & 0xf;
  1194. layer->linear_density = base[3] >> 4;
  1195. layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
  1196. layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
  1197. layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
  1198. layer->bca = base[16] >> 7;
  1200. return 0;
  1201. }
  1203. static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
  1204. {
  1205. int ret;
  1206. u_char buf[8];
  1207. struct cdrom_generic_command cgc;
  1208. struct cdrom_device_ops *cdo = cdi->ops;
  1210. init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
  1211. cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
  1212. cgc.cmd[6] = s->copyright.layer_num;
  1213. cgc.cmd[7] = s->type;
  1214. cgc.cmd[8] = cgc.buflen >> 8;
  1215. cgc.cmd[9] = cgc.buflen & 0xff;
  1217. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1218. return ret;
  1220. s->copyright.cpst = buf[4];
  1221. s->copyright.rmi = buf[5];
  1223. return 0;
  1224. }
  1226. static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s)
  1227. {
  1228. int ret, size;
  1229. u_char *buf;
  1230. struct cdrom_generic_command cgc;
  1231. struct cdrom_device_ops *cdo = cdi->ops;
  1233. size = sizeof(s->disckey.value) + 4;
  1235. if ((buf = (u_char *) kmalloc(size, GFP_KERNEL)) == NULL)
  1236. return -ENOMEM;
  1238. init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
  1239. cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
  1240. cgc.cmd[7] = s->type;
  1241. cgc.cmd[8] = size >> 8;
  1242. cgc.cmd[9] = size & 0xff;
  1243. cgc.cmd[10] = s->disckey.agid << 6;
  1245. if (!(ret = cdo->generic_packet(cdi, &cgc)))
  1246. memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
  1248. kfree(buf);
  1249. return ret;
  1250. }
  1252. static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s)
  1253. {
  1254. int ret;
  1255. u_char buf[4 + 188];
  1256. struct cdrom_generic_command cgc;
  1257. struct cdrom_device_ops *cdo = cdi->ops;
  1259. init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
  1260. cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
  1261. cgc.cmd[7] = s->type;
  1262. cgc.cmd[9] = cgc.buflen = 0xff;
  1264. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1265. return ret;
  1267. s->bca.len = buf[0] << 8 | buf[1];
  1268. if (s->bca.len < 12 || s->bca.len > 188) {
  1269. cdinfo(CD_WARNING, "Received invalid BCA length (%d)n", s->bca.len);
  1270. return -EIO;
  1271. }
  1272. memcpy(s->bca.value, &buf[4], s->bca.len);
  1274. return 0;
  1275. }
  1277. static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s)
  1278. {
  1279. int ret = 0, size;
  1280. u_char *buf;
  1281. struct cdrom_generic_command cgc;
  1282. struct cdrom_device_ops *cdo = cdi->ops;
  1284. size = sizeof(s->manufact.value) + 4;
  1286. if ((buf = (u_char *) kmalloc(size, GFP_KERNEL)) == NULL)
  1287. return -ENOMEM;
  1289. init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
  1290. cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
  1291. cgc.cmd[7] = s->type;
  1292. cgc.cmd[8] = size >> 8;
  1293. cgc.cmd[9] = size & 0xff;
  1295. if ((ret = cdo->generic_packet(cdi, &cgc))) {
  1296. kfree(buf);
  1297. return ret;
  1298. }
  1300. s->manufact.len = buf[0] << 8 | buf[1];
  1301. if (s->manufact.len < 0 || s->manufact.len > 2048) {
  1302. cdinfo(CD_WARNING, "Received invalid manufacture info length"
  1303.    " (%d)n", s->bca.len);
  1304. ret = -EIO;
  1305. } else {
  1306. memcpy(s->manufact.value, &buf[4], s->manufact.len);
  1307. }
  1309. kfree(buf);
  1310. return ret;
  1311. }
  1313. static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s)
  1314. {
  1315. switch (s->type) {
  1316. case DVD_STRUCT_PHYSICAL:
  1317. return dvd_read_physical(cdi, s);
  1319. case DVD_STRUCT_COPYRIGHT:
  1320. return dvd_read_copyright(cdi, s);
  1322. case DVD_STRUCT_DISCKEY:
  1323. return dvd_read_disckey(cdi, s);
  1325. case DVD_STRUCT_BCA:
  1326. return dvd_read_bca(cdi, s);
  1328. case DVD_STRUCT_MANUFACT:
  1329. return dvd_read_manufact(cdi, s);
  1331. default:
  1332. cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)n",
  1333. s->type);
  1334. return -EINVAL;
  1335. }
  1336. }
  1338. int cdrom_mode_sense(struct cdrom_device_info *cdi,
  1339.      struct cdrom_generic_command *cgc,
  1340.      int page_code, int page_control)
  1341. {
  1342. struct cdrom_device_ops *cdo = cdi->ops;
  1344. memset(cgc->cmd, 0, sizeof(cgc->cmd));
  1346. cgc->cmd[0] = GPCMD_MODE_SENSE_10;
  1347. cgc->cmd[2] = page_code | (page_control << 6);
  1348. cgc->cmd[7] = cgc->buflen >> 8;
  1349. cgc->cmd[8] = cgc->buflen & 0xff;
  1350. cgc->data_direction = CGC_DATA_READ;
  1351. return cdo->generic_packet(cdi, cgc);
  1352. }
  1354. int cdrom_mode_select(struct cdrom_device_info *cdi,
  1355.       struct cdrom_generic_command *cgc)
  1356. {
  1357. struct cdrom_device_ops *cdo = cdi->ops;
  1359. memset(cgc->cmd, 0, sizeof(cgc->cmd));
  1360. memset(cgc->buffer, 0, 2);
  1361. cgc->cmd[0] = GPCMD_MODE_SELECT_10;
  1362. cgc->cmd[1] = 0x10; /* PF */
  1363. cgc->cmd[7] = cgc->buflen >> 8;
  1364. cgc->cmd[8] = cgc->buflen & 0xff;
  1365. cgc->data_direction = CGC_DATA_WRITE;
  1366. return cdo->generic_packet(cdi, cgc);
  1367. }
  1369. static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
  1370.  struct cdrom_subchnl *subchnl, int mcn)
  1371. {
  1372. struct cdrom_device_ops *cdo = cdi->ops;
  1373. struct cdrom_generic_command cgc;
  1374. char buffer[32];
  1375. int ret;
  1377. init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
  1378. cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
  1379. cgc.cmd[1] = 2;     /* MSF addressing */
  1380. cgc.cmd[2] = 0x40;  /* request subQ data */
  1381. cgc.cmd[3] = mcn ? 2 : 1;
  1382. cgc.cmd[8] = 16;
  1384. if ((ret = cdo->generic_packet(cdi, &cgc)))
  1385. return ret;
  1387. subchnl->cdsc_audiostatus = cgc.buffer[1];
  1388. subchnl->cdsc_format = CDROM_MSF;
  1389. subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
  1390. subchnl->cdsc_trk = cgc.buffer[6];
  1391. subchnl->cdsc_ind = cgc.buffer[7];
  1393. subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
  1394. subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
  1395. subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
  1396. subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
  1397. subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
  1398. subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
  1400. return 0;
  1401. }
  1403. /*
  1404.  * Specific READ_10 interface
  1405.  */
  1406. static int cdrom_read_cd(struct cdrom_device_info *cdi,
  1407.  struct cdrom_generic_command *cgc, int lba,
  1408.  int blocksize, int nblocks)
  1409. {
  1410. struct cdrom_device_ops *cdo = cdi->ops;
  1412. memset(&cgc->cmd, 0, sizeof(cgc->cmd));
  1413. cgc->cmd[0] = GPCMD_READ_10;
  1414. cgc->cmd[2] = (lba >> 24) & 0xff;
  1415. cgc->cmd[3] = (lba >> 16) & 0xff;
  1416. cgc->cmd[4] = (lba >>  8) & 0xff;
  1417. cgc->cmd[5] = lba & 0xff;
  1418. cgc->cmd[6] = (nblocks >> 16) & 0xff;
  1419. cgc->cmd[7] = (nblocks >>  8) & 0xff;
  1420. cgc->cmd[8] = nblocks & 0xff;
  1421. cgc->buflen = blocksize * nblocks;
  1422. return cdo->generic_packet(cdi, cgc);
  1423. }
  1425. /* very generic interface for reading the various types of blocks */
  1426. static int cdrom_read_block(struct cdrom_device_info *cdi,
  1427.     struct cdrom_generic_command *cgc,
  1428.     int lba, int nblocks, int format, int blksize)
  1429. {
  1430. struct cdrom_device_ops *cdo = cdi->ops;
  1432. memset(&cgc->cmd, 0, sizeof(cgc->cmd));
  1433. cgc->cmd[0] = GPCMD_READ_CD;
  1434. /* expected sector size - cdda,mode1,etc. */
  1435. cgc->cmd[1] = format << 2;
  1436. /* starting address */
  1437. cgc->cmd[2] = (lba >> 24) & 0xff;
  1438. cgc->cmd[3] = (lba >> 16) & 0xff;
  1439. cgc->cmd[4] = (lba >>  8) & 0xff;
  1440. cgc->cmd[5] = lba & 0xff;
  1441. /* number of blocks */
  1442. cgc->cmd[6] = (nblocks >> 16) & 0xff;
  1443. cgc->cmd[7] = (nblocks >>  8) & 0xff;
  1444. cgc->cmd[8] = nblocks & 0xff;
  1445. cgc->buflen = blksize * nblocks;
  1447. /* set the header info returned */
  1448. switch (blksize) {
  1449. case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
  1450. case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
  1451. case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
  1452. default : cgc->cmd[9] = 0x10;
  1453. }
  1455. return cdo->generic_packet(cdi, cgc);
  1456. }
  1458. /* Just about every imaginable ioctl is supported in the Uniform layer
  1459.  * these days. ATAPI / SCSI specific code now mainly resides in
  1460.  * mmc_ioct().
  1461.  */
  1462. int cdrom_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
  1463.        unsigned long arg)
  1464. {
  1465. kdev_t dev = ip->i_rdev;
  1466. struct cdrom_device_info *cdi = cdrom_find_device(dev);
  1467. struct cdrom_device_ops *cdo = cdi->ops;
  1468. int ret;
  1470. /* the first few commands do not deal with audio drive_info, but
  1471.    only with routines in cdrom device operations. */
  1472. switch (cmd) {
  1473. case CDROMMULTISESSION: {
  1474. struct cdrom_multisession ms_info;
  1475. u_char requested_format;
  1476. cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSIONn"); 
  1477.                 if (!(cdo->capability & CDC_MULTI_SESSION))
  1478.                         return -ENOSYS;
  1479. IOCTL_IN(arg, struct cdrom_multisession, ms_info);
  1480. requested_format = ms_info.addr_format;
  1481. if (!((requested_format == CDROM_MSF) ||
  1482. (requested_format == CDROM_LBA)))
  1483. return -EINVAL;
  1484. ms_info.addr_format = CDROM_LBA;
  1485. if ((ret=cdo->get_last_session(cdi, &ms_info)))
  1486. return ret;
  1487. sanitize_format(&ms_info.addr, &ms_info.addr_format,
  1488. requested_format);
  1489. IOCTL_OUT(arg, struct cdrom_multisession, ms_info);
  1490. cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successfuln"); 
  1491. return 0;
  1492. }
  1494. case CDROMEJECT: {
  1495. cdinfo(CD_DO_IOCTL, "entering CDROMEJECTn"); 
  1496. if (!CDROM_CAN(CDC_OPEN_TRAY))
  1497. return -ENOSYS;
  1498. if (cdi->use_count != 1 || keeplocked)
  1499. return -EBUSY;
  1500. if (CDROM_CAN(CDC_LOCK))
  1501. if ((ret=cdo->lock_door(cdi, 0)))
  1502. return ret;
  1504. return cdo->tray_move(cdi, 1);
  1505. }
  1507. case CDROMCLOSETRAY: {
  1508. cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAYn"); 
  1509. if (!CDROM_CAN(CDC_CLOSE_TRAY))
  1510. return -ENOSYS;
  1511. return cdo->tray_move(cdi, 0);
  1512. }
  1514. case CDROMEJECT_SW: {
  1515. cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SWn"); 
  1516. if (!CDROM_CAN(CDC_OPEN_TRAY))
  1517. return -ENOSYS;
  1518. if (keeplocked)
  1519. return -EBUSY;
  1520. cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
  1521. if (arg)
  1522. cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
  1523. return 0;
  1524. }
  1526. case CDROM_MEDIA_CHANGED: {
  1527. struct cdrom_changer_info info;
  1529. cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGEDn"); 
  1530. if (!CDROM_CAN(CDC_MEDIA_CHANGED))
  1531. return -ENOSYS;
  1533. /* cannot select disc or select current disc */
  1534. if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
  1535. return media_changed(cdi, 1);
  1537. if ((unsigned int)arg >= cdi->capacity)
  1538. return -EINVAL;
  1540. if ((ret = cdrom_read_mech_status(cdi, &info)))
  1541. return ret;
  1543. return info.slots[arg].change;
  1544. }
  1546. case CDROM_SET_OPTIONS: {
  1547. cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONSn"); 
  1548. /* options need to be in sync with capability. too late for
  1549.    that, so we have to check each one separately... */
  1550. switch (arg) {
  1551. case CDO_USE_FFLAGS:
  1552. case CDO_CHECK_TYPE:
  1553. break;
  1554. case CDO_LOCK:
  1555. if (!CDROM_CAN(CDC_LOCK))
  1556. return -ENOSYS;
  1557. break;
  1558. case 0:
  1559. return cdi->options;
  1560. /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
  1561. default:
  1562. if (!CDROM_CAN(arg))
  1563. return -ENOSYS;
  1564. }
  1565. cdi->options |= (int) arg;
  1566. return cdi->options;
  1567. }
  1569. case CDROM_CLEAR_OPTIONS: {
  1570. cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONSn"); 
  1571. cdi->options &= ~(int) arg;
  1572. return cdi->options;
  1573. }
  1575. case CDROM_SELECT_SPEED: {
  1576. cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEEDn"); 
  1577. if (!CDROM_CAN(CDC_SELECT_SPEED))
  1578. return -ENOSYS;
  1579. return cdo->select_speed(cdi, arg);
  1580. }
  1582. case CDROM_SELECT_DISC: {
  1583. cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISCn"); 
  1584. if (!CDROM_CAN(CDC_SELECT_DISC))
  1585. return -ENOSYS;
  1587.                 if ((arg != CDSL_CURRENT) && (arg != CDSL_NONE))
  1588. if ((int)arg >= cdi->capacity)
  1589. return -EINVAL;
  1591. /* cdo->select_disc is a hook to allow a driver-specific
  1592.  * way of seleting disc.  However, since there is no
  1593.  * equiv hook for cdrom_slot_status this may not 
  1594.  * actually be useful...
  1595.  */
  1596. if (cdo->select_disc != NULL)
  1597. return cdo->select_disc(cdi, arg);
  1599. /* no driver specific select_disc(), call our own */
  1600. cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()n"); 
  1601. return cdrom_select_disc(cdi, arg);
  1602. }
  1604. case CDROMRESET: {
  1605. if (!capable(CAP_SYS_ADMIN))
  1606. return -EACCES;
  1607. cdinfo(CD_DO_IOCTL, "entering CDROM_RESETn");
  1608. if (!CDROM_CAN(CDC_RESET))
  1609. return -ENOSYS;
  1610. return cdo->reset(cdi);
  1611. }
  1613. case CDROM_LOCKDOOR: {
  1614. cdinfo(CD_DO_IOCTL, "%socking door.n", arg ? "L" : "Unl");
  1615. if (!CDROM_CAN(CDC_LOCK))
  1616. return -EDRIVE_CANT_DO_THIS;
  1617. keeplocked = arg ? 1 : 0;
  1618. /* don't unlock the door on multiple opens,but allow root
  1619.  * to do so */
  1620. if ((cdi->use_count != 1) && !arg && !capable(CAP_SYS_ADMIN))
  1621. return -EBUSY;
  1622. return cdo->lock_door(cdi, arg);
  1623. }
  1625. case CDROM_DEBUG: {
  1626. if (!capable(CAP_SYS_ADMIN))
  1627. return -EACCES;
  1628. cdinfo(CD_DO_IOCTL, "%sabling debug.n", arg ? "En" : "Dis");
  1629. debug = arg ? 1 : 0;
  1630. return debug;
  1631. }
  1633. case CDROM_GET_CAPABILITY: {
  1634. cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITYn");
  1635. return (cdo->capability & ~cdi->mask);
  1636. }
  1638. /* The following function is implemented, although very few audio
  1639.  * discs give Universal Product Code information, which should just be
  1640.  * the Medium Catalog Number on the box.  Note, that the way the code
  1641.  * is written on the CD is /not/ uniform across all discs!
  1642.  */
  1643. case CDROM_GET_MCN: {
  1644. struct cdrom_mcn mcn;
  1645. cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCNn"); 
  1646. if (!(cdo->capability & CDC_MCN))
  1647. return -ENOSYS;
  1648. if ((ret=cdo->get_mcn(cdi, &mcn)))
  1649. return ret;
  1650. IOCTL_OUT(arg, struct cdrom_mcn, mcn);
  1651. cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successfuln"); 
  1652. return 0;
  1653. }
  1655. case CDROM_DRIVE_STATUS: {
  1656. cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUSn"); 
  1657. if (!(cdo->capability & CDC_DRIVE_STATUS))
  1658. return -ENOSYS;
  1659. if (!CDROM_CAN(CDC_SELECT_DISC))
  1660. return cdo->drive_status(cdi, CDSL_CURRENT);
  1661.                 if ((arg == CDSL_CURRENT) || (arg == CDSL_NONE)) 
  1662. return cdo->drive_status(cdi, CDSL_CURRENT);
  1663. if (((int)arg >= cdi->capacity))
  1664. return -EINVAL;
  1665. return cdrom_slot_status(cdi, arg);
  1666. }
  1668. /* Ok, this is where problems start.  The current interface for the
  1669.    CDROM_DISC_STATUS ioctl is flawed.  It makes the false assumption
  1670.    that CDs are all CDS_DATA_1 or all CDS_AUDIO, etc.  Unfortunatly,
  1671.    while this is often the case, it is also very common for CDs to
  1672.    have some tracks with data, and some tracks with audio.  Just 
  1673.    because I feel like it, I declare the following to be the best
  1674.    way to cope.  If the CD has ANY data tracks on it, it will be
  1675.    returned as a data CD.  If it has any XA tracks, I will return
  1676.    it as that.  Now I could simplify this interface by combining these 
  1677.    returns with the above, but this more clearly demonstrates
  1678.    the problem with the current interface.  Too bad this wasn't 
  1679.    designed to use bitmasks...         -Erik 
  1681.    Well, now we have the option CDS_MIXED: a mixed-type CD. 
  1682.    User level programmers might feel the ioctl is not very useful.
  1683.     ---david
  1684. */
  1685. case CDROM_DISC_STATUS: {
  1686. tracktype tracks;
  1687. cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUSn"); 
  1688. cdrom_count_tracks(cdi, &tracks);
  1689. if (tracks.error) 
  1690. return(tracks.error);
  1692. /* Policy mode on */
  1693. if (tracks.audio > 0) {
  1694. if (tracks.data==0 && tracks.cdi==0 && tracks.xa==0) 
  1695. return CDS_AUDIO;
  1696. else
  1697. return CDS_MIXED;
  1698. }
  1699. if (tracks.cdi > 0) return CDS_XA_2_2;
  1700. if (tracks.xa > 0) return CDS_XA_2_1;
  1701. if (tracks.data > 0) return CDS_DATA_1;
  1702. /* Policy mode off */
  1704. cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!n");
  1705. return CDS_NO_INFO;
  1706. }
  1708. case CDROM_CHANGER_NSLOTS: {
  1709. cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTSn"); 
  1710. return cdi->capacity;
  1711. }
  1712. }
  1714. /* use the ioctls that are implemented through the generic_packet()
  1715.    interface. this may look at bit funny, but if -ENOTTY is
  1716.    returned that particular ioctl is not implemented and we
  1717.    let it go through the device specific ones. */
  1718. if (CDROM_CAN(CDC_GENERIC_PACKET)) {
  1719. ret = mmc_ioctl(cdi, cmd, arg);
  1720. if (ret != -ENOTTY) {
  1721. return ret;
  1722. }
  1723. }
  1725. /* note: most of the cdinfo() calls are commented out here,
  1726.    because they fill up the sys log when CD players poll
  1727.    the drive. */
  1728. switch (cmd) {
  1729. case CDROMSUBCHNL: {
  1730. struct cdrom_subchnl q;
  1731. u_char requested, back;
  1732. if (!CDROM_CAN(CDC_PLAY_AUDIO))
  1733. return -ENOSYS;
  1734. /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNLn");*/ 
  1735. IOCTL_IN(arg, struct cdrom_subchnl, q);
  1736. requested = q.cdsc_format;
  1737. if (!((requested == CDROM_MSF) ||
  1738.       (requested == CDROM_LBA)))
  1739. return -EINVAL;
  1740. q.cdsc_format = CDROM_MSF;
  1741. if ((ret=cdo->audio_ioctl(cdi, cmd, &q)))
  1742. return ret;
  1743. back = q.cdsc_format; /* local copy */
  1744. sanitize_format(&q.cdsc_absaddr, &back, requested);
  1745. sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
  1746. IOCTL_OUT(arg, struct cdrom_subchnl, q);
  1747. /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successfuln"); */ 
  1748. return 0;
  1749. }
  1750. case CDROMREADTOCHDR: {
  1751. struct cdrom_tochdr header;
  1752. if (!CDROM_CAN(CDC_PLAY_AUDIO))
  1753. return -ENOSYS;
  1754. /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDRn"); */ 
  1755. IOCTL_IN(arg, struct cdrom_tochdr, header);
  1756. if ((ret=cdo->audio_ioctl(cdi, cmd, &header)))
  1757. return ret;
  1758. IOCTL_OUT(arg, struct cdrom_tochdr, header);
  1759. /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successfuln"); */ 
  1760. return 0;
  1761. }
  1762. case CDROMREADTOCENTRY: {
  1763. struct cdrom_tocentry entry;
  1764. u_char requested_format;
  1765. if (!CDROM_CAN(CDC_PLAY_AUDIO))
  1766. return -ENOSYS;
  1767. /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRYn"); */ 
  1768. IOCTL_IN(arg, struct cdrom_tocentry, entry);
  1769. requested_format = entry.cdte_format;
  1770. if (!((requested_format == CDROM_MSF) || 
  1771. (requested_format == CDROM_LBA)))
  1772. return -EINVAL;
  1773. /* make interface to low-level uniform */
  1774. entry.cdte_format = CDROM_MSF;
  1775. if ((ret=cdo->audio_ioctl(cdi, cmd, &entry)))
  1776. return ret;
  1777. sanitize_format(&entry.cdte_addr,
  1778. &entry.cdte_format, requested_format);
  1779. IOCTL_OUT(arg, struct cdrom_tocentry, entry);
  1780. /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successfuln"); */ 
  1781. return 0;
  1782. }
  1783. case CDROMPLAYMSF: {
  1784. struct cdrom_msf msf;
  1785. if (!CDROM_CAN(CDC_PLAY_AUDIO))
  1786. return -ENOSYS;
  1787. cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSFn"); 
  1788. IOCTL_IN(arg, struct cdrom_msf, msf);
  1789. return cdo->audio_ioctl(cdi, cmd, &msf);
  1790. }
  1791. case CDROMPLAYTRKIND: {
  1792. struct cdrom_ti ti;
  1793. if (!CDROM_CAN(CDC_PLAY_AUDIO))
  1794. return -ENOSYS;
  1795. cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKINDn"); 
  1796. IOCTL_IN(arg, struct cdrom_ti, ti);
  1797. CHECKAUDIO;
  1798. return cdo->audio_ioctl(cdi, cmd, &ti);
  1799. }
  1800. case CDROMVOLCTRL: {
  1801. struct cdrom_volctrl volume;
  1802. if (!CDROM_CAN(CDC_PLAY_AUDIO))
  1803. return -ENOSYS;
  1804. cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRLn"); 
  1805. IOCTL_IN(arg, struct cdrom_volctrl, volume);
  1806. return cdo->audio_ioctl(cdi, cmd, &volume);
  1807. }
  1808. case CDROMVOLREAD: {
  1809. struct cdrom_volctrl volume;
  1810. if (!CDROM_CAN(CDC_PLAY_AUDIO))
  1811. return -ENOSYS;
  1812. cdinfo(CD_DO_IOCTL, "entering CDROMVOLREADn"); 
  1813. if ((ret=cdo->audio_ioctl(cdi, cmd, &volume)))
  1814. return ret;
  1815. IOCTL_OUT(arg, struct cdrom_volctrl, volume);
  1816. return 0;
  1817. }
  1818. case CDROMSTART:
  1819. case CDROMSTOP:
  1820. case CDROMPAUSE:
  1821. case CDROMRESUME: {
  1822. if (!CDROM_CAN(CDC_PLAY_AUDIO))
  1823. return -ENOSYS;
  1824. cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)n"); 
  1825. CHECKAUDIO;
  1826. return cdo->audio_ioctl(cdi, cmd, NULL);
  1827. }
  1828. } /* switch */
  1830. /* do the device specific ioctls */
  1831. if (CDROM_CAN(CDC_IOCTLS))
  1832. return cdo->dev_ioctl(cdi, cmd, arg);
  1834. return -ENOSYS;
  1835. }
  1837. static inline
  1838. int msf_to_lba(char m, char s, char f)
  1839. {
  1840. return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
  1841. }
  1843. /*
  1844.  * Required when we need to use READ_10 to issue other than 2048 block
  1845.  * reads
  1846.  */
  1847. static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
  1848. {
  1849. struct cdrom_device_ops *cdo = cdi->ops;
  1850. struct cdrom_generic_command cgc;
  1851. struct modesel_head mh;
  1853. memset(&mh, 0, sizeof(mh));
  1854. mh.block_desc_length = 0x08;
  1855. mh.block_length_med = (size >> 8) & 0xff;
  1856. mh.block_length_lo = size & 0xff;
  1858. memset(&cgc, 0, sizeof(cgc));
  1859. cgc.cmd[0] = 0x15;
  1860. cgc.cmd[1] = 1 << 4;
  1861. cgc.cmd[4] = 12;
  1862. cgc.buflen = sizeof(mh);
  1863. cgc.buffer = (char *) &mh;
  1864. cgc.data_direction = CGC_DATA_WRITE;
  1865. mh.block_desc_length = 0x08;
  1866. mh.block_length_med = (size >> 8) & 0xff;
  1867. mh.block_length_lo = size & 0xff;
  1869. return cdo->generic_packet(cdi, &cgc);
  1870. }
  1872. static int cdrom_do_cmd(struct cdrom_device_info *cdi,
  1873. struct cdrom_generic_command *cgc)
  1874. {
  1875. struct request_sense *usense, sense;
  1876. unsigned char *ubuf;
  1877. int ret;
  1879. if (cgc->data_direction == CGC_DATA_UNKNOWN)
  1880. return -EINVAL;
  1882. if (cgc->buflen < 0 || cgc->buflen >= 131072)
  1883. return -EINVAL;
  1885. if ((ubuf = cgc->buffer)) {
  1886. cgc->buffer = kmalloc(cgc->buflen, GFP_KERNEL);
  1887. if (cgc->buffer == NULL)
  1888. return -ENOMEM;
  1889. }
  1891. usense = cgc->sense;
  1892. cgc->sense = &sense;
  1893. if (usense && !access_ok(VERIFY_WRITE, usense, sizeof(*usense)))
  1894. return -EFAULT;
  1896. if (cgc->data_direction == CGC_DATA_READ) {
  1897. if (!access_ok(VERIFY_READ, ubuf, cgc->buflen))
  1898. return -EFAULT;
  1899. } else if (cgc->data_direction == CGC_DATA_WRITE) {
  1900. if (copy_from_user(cgc->buffer, ubuf, cgc->buflen)) {
  1901. kfree(cgc->buffer);
  1902. return -EFAULT;
  1903. }
  1904. }
  1906. ret = cdi->ops->generic_packet(cdi, cgc);
  1907. __copy_to_user(usense, cgc->sense, sizeof(*usense));
  1908. if (!ret && cgc->data_direction == CGC_DATA_READ)
  1909. __copy_to_user(ubuf, cgc->buffer, cgc->buflen);
  1910. kfree(cgc->buffer);
  1911. return ret;
  1912. }
  1914. static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
  1915.      unsigned long arg)
  1916. {
  1917. struct cdrom_device_ops *cdo = cdi->ops;
  1918. struct cdrom_generic_command cgc;
  1919. struct request_sense sense;
  1920. kdev_t dev = cdi->dev;
  1921. char buffer[32];
  1922. int ret = 0;
  1924. memset(&cgc, 0, sizeof(cgc));
  1926. /* build a unified command and queue it through
  1927.    cdo->generic_packet() */
  1928. switch (cmd) {
  1929. case CDROMREADRAW:
  1930. case CDROMREADMODE1:
  1931. case CDROMREADMODE2: {
  1932. struct cdrom_msf msf;
  1933. int blocksize = 0, format = 0, lba;
  1935. switch (cmd) {
  1936. case CDROMREADRAW:
  1937. blocksize = CD_FRAMESIZE_RAW;
  1938. break;
  1939. case CDROMREADMODE1:
  1940. blocksize = CD_FRAMESIZE;
  1941. format = 2;
  1942. break;
  1943. case CDROMREADMODE2:
  1944. blocksize = CD_FRAMESIZE_RAW0;
  1945. break;
  1946. }
  1947. IOCTL_IN(arg, struct cdrom_msf, msf);
  1948. lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
  1949. /* FIXME: we need upper bound checking, too!! */
  1950. if (lba < 0)
  1951. return -EINVAL;
  1952. cgc.buffer = (char *) kmalloc(blocksize, GFP_KERNEL);
  1953. if (cgc.buffer == NULL)
  1954. return -ENOMEM;
  1955. memset(&sense, 0, sizeof(sense));
  1956. cgc.sense = &sense;
  1957. cgc.data_direction = CGC_DATA_READ;
  1958. ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
  1959. if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) {
  1960. /*
  1961.  * SCSI-II devices are not required to support
  1962.  * READ_CD, so let's try switching block size
  1963.  */
  1964. /* FIXME: switch back again... */
  1965. if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
  1966. kfree(cgc.buffer);
  1967. return ret;
  1968. }
  1969. cgc.sense = NULL;
  1970. ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
  1971. ret |= cdrom_switch_blocksize(cdi, blocksize);
  1972. }
  1973. if (!ret && copy_to_user((char *)arg, cgc.buffer, blocksize))
  1974. ret = -EFAULT;
  1975. kfree(cgc.buffer);
  1976. return ret;
  1977. }
  1978. case CDROMREADAUDIO: {
  1979. struct cdrom_read_audio ra;
  1980. int lba, nr;
  1982. IOCTL_IN(arg, struct cdrom_read_audio, ra);
  1984. if (ra.addr_format == CDROM_MSF)
  1985. lba = msf_to_lba(ra.addr.msf.minute,
  1986.  ra.addr.msf.second,
  1987.  ra.addr.msf.frame);
  1988. else if (ra.addr_format == CDROM_LBA)
  1989. lba = ra.addr.lba;
  1990. else
  1991. return -EINVAL;
  1993. /* FIXME: we need upper bound checking, too!! */
  1994. if (lba < 0 || ra.nframes <= 0)
  1995. return -EINVAL;
  1997. /*
  1998.  * start with will ra.nframes size, back down if alloc fails
  1999.  */
  2000. nr = ra.nframes;
  2001. do {
  2002. cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
  2003. if (cgc.buffer)
  2004. break;
  2006. nr >>= 1;
  2007. } while (nr);
  2009. if (!nr)
  2010. return -ENOMEM;
  2012. if (!access_ok(VERIFY_WRITE, ra.buf, ra.nframes*CD_FRAMESIZE_RAW)) {
  2013. kfree(cgc.buffer);
  2014. return -EFAULT;
  2015. }
  2016. cgc.data_direction = CGC_DATA_READ;
  2017. while (ra.nframes > 0) {
  2018. if (nr > ra.nframes)
  2019. nr = ra.nframes;
  2021. ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
  2022. if (ret)
  2023. break;
  2024. __copy_to_user(ra.buf, cgc.buffer, CD_FRAMESIZE_RAW*nr);
  2025. ra.buf += CD_FRAMESIZE_RAW * nr;
  2026. ra.nframes -= nr;
  2027. lba += nr;
  2028. }
  2029. kfree(cgc.buffer);
  2030. return ret;
  2031. }
  2032. case CDROMSUBCHNL: {
  2033. struct cdrom_subchnl q;
  2034. u_char requested, back;
  2035. IOCTL_IN(arg, struct cdrom_subchnl, q);
  2036. requested = q.cdsc_format;
  2037. if (!((requested == CDROM_MSF) ||
  2038.       (requested == CDROM_LBA)))
  2039. return -EINVAL;
  2040. q.cdsc_format = CDROM_MSF;
  2041. if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
  2042. return ret;
  2043. back = q.cdsc_format; /* local copy */
  2044. sanitize_format(&q.cdsc_absaddr, &back, requested);
  2045. sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
  2046. IOCTL_OUT(arg, struct cdrom_subchnl, q);
  2047. /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successfuln"); */ 
  2048. return 0;
  2049. }
  2050. case CDROMPLAYMSF: {
  2051. struct cdrom_msf msf;
  2052. cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSFn");
  2053. IOCTL_IN(arg, struct cdrom_msf, msf);
  2054. cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
  2055. cgc.cmd[3] = msf.cdmsf_min0;
  2056. cgc.cmd[4] = msf.cdmsf_sec0;
  2057. cgc.cmd[5] = msf.cdmsf_frame0;
  2058. cgc.cmd[6] = msf.cdmsf_min1;
  2059. cgc.cmd[7] = msf.cdmsf_sec1;
  2060. cgc.cmd[8] = msf.cdmsf_frame1;
  2061. cgc.data_direction = CGC_DATA_NONE;
  2062. return cdo->generic_packet(cdi, &cgc);
  2063. }
  2064. case CDROMPLAYBLK: {
  2065. struct cdrom_blk blk;
  2066. cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLKn");
  2067. IOCTL_IN(arg, struct cdrom_blk, blk);
  2068. cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
  2069. cgc.cmd[2] = (blk.from >> 24) & 0xff;
  2070. cgc.cmd[3] = (blk.from >> 16) & 0xff;
  2071. cgc.cmd[4] = (blk.from >>  8) & 0xff;
  2072. cgc.cmd[5] = blk.from & 0xff;
  2073. cgc.cmd[7] = (blk.len >> 8) & 0xff;
  2074. cgc.cmd[8] = blk.len & 0xff;
  2075. cgc.data_direction = CGC_DATA_NONE;
  2076. return cdo->generic_packet(cdi, &cgc);
  2077. }
  2078. case CDROMVOLCTRL:
  2079. case CDROMVOLREAD: {
  2080. struct cdrom_volctrl volctrl;
  2081. char mask[32];
  2082. unsigned short offset;
  2083. cdinfo(CD_DO_IOCTL, "entering CDROMVOLUMEn");
  2085. IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
  2087. cgc.buffer = buffer;
  2088. cgc.buflen = 24;
  2089. if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
  2090.     return ret;
  2092. /* some drives have longer pages, adjust and reread. */
  2093. if (buffer[1] > cgc.buflen) {
  2094. cgc.buflen = buffer[1] + 2;
  2095. if ((ret = cdrom_mode_sense(cdi, &cgc, 
  2096. GPMODE_AUDIO_CTL_PAGE, 0))) 
  2097.     return ret;
  2098. }
  2100. /* get the offset from the length of the page. length
  2101.    is measure from byte 2 an on, thus the 14. */
  2102. offset = buffer[1] - 14;
  2104. /* now we have the current volume settings. if it was only
  2105.    a CDROMVOLREAD, return these values */
  2106. if (cmd == CDROMVOLREAD) {
  2107. volctrl.channel0 = buffer[offset+9];
  2108. volctrl.channel1 = buffer[offset+11];
  2109. volctrl.channel2 = buffer[offset+13];
  2110. volctrl.channel3 = buffer[offset+15];
  2111. IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
  2112. return 0;
  2113. }
  2115. /* get the volume mask */
  2116. cgc.buffer = mask;
  2117. if ((ret = cdrom_mode_sense(cdi, &cgc, 
  2118. GPMODE_AUDIO_CTL_PAGE, 1)))
  2119. return ret;
  2121. buffer[offset+9] = volctrl.channel0 & mask[offset+9];
  2122. buffer[offset+11] = volctrl.channel1 & mask[offset+11];
  2123. buffer[offset+13] = volctrl.channel2 & mask[offset+13];
  2124. buffer[offset+15] = volctrl.channel3 & mask[offset+15];
  2126. /* set volume */
  2127. cgc.buffer = buffer;
  2128. return cdrom_mode_select(cdi, &cgc);
  2129. }
  2131. case CDROMSTART:
  2132. case CDROMSTOP: {
  2133. cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOPn"); 
  2134. cgc.cmd[0] = GPCMD_START_STOP_UNIT;
  2135. cgc.cmd[1] = 1;
  2136. cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
  2137. cgc.data_direction = CGC_DATA_NONE;
  2138. return cdo->generic_packet(cdi, &cgc);
  2139. }
  2141. case CDROMPAUSE:
  2142. case CDROMRESUME: {
  2143. cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUMEn"); 
  2144. cgc.cmd[0] = GPCMD_PAUSE_RESUME;
  2145. cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
  2146. cgc.data_direction = CGC_DATA_NONE;
  2147. return cdo->generic_packet(cdi, &cgc);
  2148. }
  2150. case DVD_READ_STRUCT: {
  2151. dvd_struct *s;
  2152. int size = sizeof(dvd_struct);
  2153. if (!CDROM_CAN(CDC_DVD))
  2154. return -ENOSYS;
  2155. if ((s = (dvd_struct *) kmalloc(size, GFP_KERNEL)) == NULL)
  2156. return -ENOMEM;
  2157. cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCTn"); 
  2158. if (copy_from_user(s, (dvd_struct *)arg, size)) {
  2159. kfree(s);
  2160. return -EFAULT;
  2161. }
  2162. if ((ret = dvd_read_struct(cdi, s))) {
  2163. kfree(s);
  2164. return ret;
  2165. }
  2166. if (copy_to_user((dvd_struct *)arg, s, size))
  2167. ret = -EFAULT;
  2168. kfree(s);
  2169. return ret;
  2170. }
  2172. case DVD_AUTH: {
  2173. dvd_authinfo ai;
  2174. if (!CDROM_CAN(CDC_DVD))
  2175. return -ENOSYS;
  2176. cdinfo(CD_DO_IOCTL, "entering DVD_AUTHn"); 
  2177. IOCTL_IN(arg, dvd_authinfo, ai);
  2178. if ((ret = dvd_do_auth (cdi, &ai)))
  2179. return ret;
  2180. IOCTL_OUT(arg, dvd_authinfo, ai);
  2181. return 0;
  2182. }
  2184. case CDROM_SEND_PACKET: {
  2185. if (!CDROM_CAN(CDC_GENERIC_PACKET))
  2186. return -ENOSYS;
  2187. cdinfo(CD_DO_IOCTL, "entering CDROM_SEND_PACKETn"); 
  2188. IOCTL_IN(arg, struct cdrom_generic_command, cgc);
  2189. return cdrom_do_cmd(cdi, &cgc);
  2190. }
  2191. case CDROM_NEXT_WRITABLE: {
  2192. long next = 0;
  2193. cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLEn"); 
  2194. if ((ret = cdrom_get_next_writable(dev, &next)))
  2195. return ret;
  2196. IOCTL_OUT(arg, long, next);
  2197. return 0;
  2198. }
  2199. case CDROM_LAST_WRITTEN: {
  2200. long last = 0;
  2201. cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTENn"); 
  2202. if ((ret = cdrom_get_last_written(dev, &last)))
  2203. return ret;
  2204. IOCTL_OUT(arg, long, last);
  2205. return 0;
  2206. }
  2207. } /* switch */
  2209. return -ENOTTY;
  2210. }
  2212. int cdrom_get_track_info(kdev_t dev, __u16 track, __u8 type,
  2213.  track_information *ti)
  2214. {
  2215.         struct cdrom_device_info *cdi = cdrom_find_device(dev);
  2216. struct cdrom_device_ops *cdo = cdi->ops;
  2217. struct cdrom_generic_command cgc;
  2218. int ret;
  2220. init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
  2221. cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
  2222. cgc.cmd[1] = type & 3;
  2223. cgc.cmd[4] = (track & 0xff00) >> 8;
  2224. cgc.cmd[5] = track & 0xff;
  2225. cgc.cmd[8] = 8;
  2226. cgc.quiet = 1;
  2228. if ((ret = cdo->generic_packet(cdi, &cgc)))
  2229. return ret;
  2231. cgc.buflen = be16_to_cpu(ti->track_information_length) +
  2232.      sizeof(ti->track_information_length);
  2234. if (cgc.buflen > sizeof(track_information))
  2235. cgc.buflen = sizeof(track_information);
  2237. cgc.cmd[8] = cgc.buflen;
  2238. return cdo->generic_packet(cdi, &cgc);
  2239. }
  2241. /* requires CD R/RW */
  2242. int cdrom_get_disc_info(kdev_t dev, disc_information *di)
  2243. {
  2244. struct cdrom_device_info *cdi = cdrom_find_device(dev);
  2245. struct cdrom_device_ops *cdo = cdi->ops;
  2246. struct cdrom_generic_command cgc;
  2247. int ret;
  2249. /* set up command and get the disc info */
  2250. init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
  2251. cgc.cmd[0] = GPCMD_READ_DISC_INFO;
  2252. cgc.cmd[8] = cgc.buflen = 2;
  2253. cgc.quiet = 1;
  2255. if ((ret = cdo->generic_packet(cdi, &cgc)))
  2256. return ret;
  2258. /* not all drives have the same disc_info length, so requeue
  2259.  * packet with the length the drive tells us it can supply
  2260.  */
  2261. cgc.buflen = be16_to_cpu(di->disc_information_length) +
  2262.      sizeof(di->disc_information_length);
  2264. if (cgc.buflen > sizeof(disc_information))
  2265. cgc.buflen = sizeof(disc_information);
  2267. cgc.cmd[8] = cgc.buflen;
  2268. return cdo->generic_packet(cdi, &cgc);
  2269. }
  2272. /* return the last written block on the CD-R media. this is for the udf
  2273.    file system. */
  2274. int cdrom_get_last_written(kdev_t dev, long *last_written)
  2275. {
  2276. struct cdrom_device_info *cdi = cdrom_find_device(dev);
  2277. struct cdrom_tocentry toc;
  2278. disc_information di;
  2279. track_information ti;
  2280. __u32 last_track;
  2281. int ret = -1;
  2283. if (!CDROM_CAN(CDC_GENERIC_PACKET))
  2284. goto use_toc;
  2286. if ((ret = cdrom_get_disc_info(dev, &di)))
  2287. goto use_toc;
  2289. last_track = (di.last_track_msb << 8) | di.last_track_lsb;
  2290. if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti)))
  2291. goto use_toc;
  2293. /* if this track is blank, try the previous. */
  2294. if (ti.blank) {
  2295. last_track--;
  2296. if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti)))
  2297. goto use_toc;
  2298. }
  2300. /* if last recorded field is valid, return it. */
  2301. if (ti.lra_v) {
  2302. *last_written = be32_to_cpu(ti.last_rec_address);
  2303. } else {
  2304. /* make it up instead */
  2305. *last_written = be32_to_cpu(ti.track_start) +
  2306. be32_to_cpu(ti.track_size);
  2307. if (ti.free_blocks)
  2308. *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
  2309. }
  2310. return 0;
  2312. /* this is where we end up if the drive either can't do a
  2313.    GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
  2314.    it fails. then we return the toc contents. */
  2315. use_toc:
  2316. toc.cdte_format = CDROM_MSF;
  2317. toc.cdte_track = CDROM_LEADOUT;
  2318. if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc))
  2319. return ret;
  2320. sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
  2321. *last_written = toc.cdte_addr.lba;
  2322. return 0;
  2323. }
  2325. /* return the next writable block. also for udf file system. */
  2326. int cdrom_get_next_writable(kdev_t dev, long *next_writable)
  2327. {
  2328. struct cdrom_device_info *cdi = cdrom_find_device(dev);
  2329. disc_information di;
  2330. track_information ti;
  2331. __u16 last_track;
  2332. int ret = -1;
  2334. if (!CDROM_CAN(CDC_GENERIC_PACKET))
  2335. goto use_last_written;
  2337. if ((ret = cdrom_get_disc_info(dev, &di)))
  2338. goto use_last_written;
  2340. last_track = (di.last_track_msb << 8) | di.last_track_lsb;
  2341. if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti)))
  2342. goto use_last_written;
  2344.         /* if this track is blank, try the previous. */
  2345. if (ti.blank) {
  2346. last_track--;
  2347. if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti)))
  2348. goto use_last_written;
  2349. }
  2351. /* if next recordable address field is valid, use it. */
  2352. if (ti.nwa_v)
  2353. *next_writable = be32_to_cpu(ti.next_writable);
  2354. else
  2355. goto use_last_written;
  2357. return 0;
  2359. use_last_written:
  2360. if ((ret = cdrom_get_last_written(dev, next_writable))) {
  2361. *next_writable = 0;
  2362. return ret;
  2363. } else {
  2364. *next_writable += 7;
  2365. return 0;
  2366. }
  2367. }
  2369. EXPORT_SYMBOL(cdrom_get_disc_info);
  2370. EXPORT_SYMBOL(cdrom_get_track_info);
  2371. EXPORT_SYMBOL(cdrom_get_next_writable);
  2372. EXPORT_SYMBOL(cdrom_get_last_written);
  2373. EXPORT_SYMBOL(cdrom_count_tracks);
  2374. EXPORT_SYMBOL(register_cdrom);
  2375. EXPORT_SYMBOL(unregister_cdrom);
  2376. EXPORT_SYMBOL(cdrom_open);
  2377. EXPORT_SYMBOL(cdrom_release);
  2378. EXPORT_SYMBOL(cdrom_ioctl);
  2379. EXPORT_SYMBOL(cdrom_media_changed);
  2380. EXPORT_SYMBOL(cdrom_number_of_slots);
  2381. EXPORT_SYMBOL(cdrom_select_disc);
  2382. EXPORT_SYMBOL(cdrom_mode_select);
  2383. EXPORT_SYMBOL(cdrom_mode_sense);
  2384. EXPORT_SYMBOL(init_cdrom_command);
  2385. EXPORT_SYMBOL(cdrom_find_device);
  2387. #ifdef CONFIG_SYSCTL
  2389. #define CDROM_STR_SIZE 1000
  2391. struct cdrom_sysctl_settings {
  2392. char info[CDROM_STR_SIZE]; /* general info */
  2393. int autoclose; /* close tray upon mount, etc */
  2394. int autoeject; /* eject on umount */
  2395. int debug; /* turn on debugging messages */
  2396. int lock; /* lock the door on device open */
  2397. int check; /* check media type */
  2398. } cdrom_sysctl_settings;
  2400. int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
  2401.                            void *buffer, size_t *lenp)
  2402. {
  2403.         int pos;
  2404. struct cdrom_device_info *cdi;
  2405. char *info = cdrom_sysctl_settings.info;
  2407. if (!*lenp || (filp->f_pos && !write)) {
  2408. *lenp = 0;
  2409. return 0;
  2410. }
  2412. pos = sprintf(info, "CD-ROM information, " VERSION "n");
  2414. pos += sprintf(info+pos, "ndrive name:t");
  2415. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2416.     pos += sprintf(info+pos, "t%s", cdi->name);
  2418. pos += sprintf(info+pos, "ndrive speed:t");
  2419. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2420.     pos += sprintf(info+pos, "t%d", cdi->speed);
  2422. pos += sprintf(info+pos, "ndrive # of slots:");
  2423. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2424.     pos += sprintf(info+pos, "t%d", cdi->capacity);
  2426. pos += sprintf(info+pos, "nCan close tray:t");
  2427. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2428.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_CLOSE_TRAY) != 0);
  2430. pos += sprintf(info+pos, "nCan open tray:t");
  2431. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2432.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_OPEN_TRAY) != 0);
  2434. pos += sprintf(info+pos, "nCan lock tray:t");
  2435. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2436.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_LOCK) != 0);
  2438. pos += sprintf(info+pos, "nCan change speed:");
  2439. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2440.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_SELECT_SPEED) != 0);
  2442. pos += sprintf(info+pos, "nCan select disk:");
  2443. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2444.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_SELECT_DISC) != 0);
  2446. pos += sprintf(info+pos, "nCan read multisession:");
  2447. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2448.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_MULTI_SESSION) != 0);
  2450. pos += sprintf(info+pos, "nCan read MCN:t");
  2451. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2452.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_MCN) != 0);
  2454. pos += sprintf(info+pos, "nReports media changed:");
  2455. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2456.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_MEDIA_CHANGED) != 0);
  2458. pos += sprintf(info+pos, "nCan play audio:t");
  2459. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2460.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_PLAY_AUDIO) != 0);
  2462. pos += sprintf(info+pos, "nCan write CD-R:t");
  2463. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2464.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_CD_R) != 0);
  2466. pos += sprintf(info+pos, "nCan write CD-RW:");
  2467. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2468.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_CD_RW) != 0);
  2470. pos += sprintf(info+pos, "nCan read DVD:t");
  2471. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2472.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_DVD) != 0);
  2474. pos += sprintf(info+pos, "nCan write DVD-R:");
  2475. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2476.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_DVD_R) != 0);
  2478. pos += sprintf(info+pos, "nCan write DVD-RAM:");
  2479. for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
  2480.     pos += sprintf(info+pos, "t%d", CDROM_CAN(CDC_DVD_RAM) != 0);
  2482. strcpy(info+pos,"nn");
  2484.         return proc_dostring(ctl, write, filp, buffer, lenp);
  2485. }
  2487. /* Unfortunately, per device settings are not implemented through
  2488.    procfs/sysctl yet. When they are, this will naturally disappear. For now
  2489.    just update all drives. Later this will become the template on which
  2490.    new registered drives will be based. */
  2491. void cdrom_update_settings(void)
  2492. {
  2493. struct cdrom_device_info *cdi;
  2495. for (cdi = topCdromPtr; cdi != NULL; cdi = cdi->next) {
  2496. if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
  2497. cdi->options |= CDO_AUTO_CLOSE;
  2498. else if (!autoclose)
  2499. cdi->options &= ~CDO_AUTO_CLOSE;
  2500. if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
  2501. cdi->options |= CDO_AUTO_EJECT;
  2502. else if (!autoeject)
  2503. cdi->options &= ~CDO_AUTO_EJECT;
  2504. if (lockdoor && CDROM_CAN(CDC_LOCK))
  2505. cdi->options |= CDO_LOCK;
  2506. else if (!lockdoor)
  2507. cdi->options &= ~CDO_LOCK;
  2508. if (check_media_type)
  2509. cdi->options |= CDO_CHECK_TYPE;
  2510. else
  2511. cdi->options &= ~CDO_CHECK_TYPE;
  2512. }
  2513. }
  2515. static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
  2516. void *buffer, size_t *lenp)
  2517. {
  2518. int *valp = ctl->data;
  2519. int val = *valp;
  2520. int ret;
  2522. ret = proc_dointvec(ctl, write, filp, buffer, lenp);
  2524. if (write && *valp != val) {
  2526. /* we only care for 1 or 0. */
  2527. if (*valp)
  2528. *valp = 1;
  2529. else
  2530. *valp = 0;
  2532. switch (ctl->ctl_name) {
  2533. case DEV_CDROM_AUTOCLOSE: {
  2534. if (valp == &cdrom_sysctl_settings.autoclose)
  2535. autoclose = cdrom_sysctl_settings.autoclose;
  2536. break;
  2537. }
  2538. case DEV_CDROM_AUTOEJECT: {
  2539. if (valp == &cdrom_sysctl_settings.autoeject)
  2540. autoeject = cdrom_sysctl_settings.autoeject;
  2541. break;
  2542. }
  2543. case DEV_CDROM_DEBUG: {
  2544. if (valp == &cdrom_sysctl_settings.debug)
  2545. debug = cdrom_sysctl_settings.debug;
  2546. break;
  2547. }
  2548. case DEV_CDROM_LOCK: {
  2549. if (valp == &cdrom_sysctl_settings.lock)
  2550. lockdoor = cdrom_sysctl_settings.lock;
  2551. break;
  2552. }
  2553. case DEV_CDROM_CHECK_MEDIA: {
  2554. if (valp == &cdrom_sysctl_settings.check)
  2555. check_media_type = cdrom_sysctl_settings.check;
  2556. break;
  2557. }
  2558. }
  2559. /* update the option flags according to the changes. we
  2560.    don't have per device options through sysctl yet,
  2561.    but we will have and then this will disappear. */
  2562. cdrom_update_settings();
  2563. }
  2565.         return ret;
  2566. }
  2568. /* Place files in /proc/sys/dev/cdrom */
  2569. ctl_table cdrom_table[] = {
  2570. {DEV_CDROM_INFO, "info", &cdrom_sysctl_settings.info, 
  2571. CDROM_STR_SIZE, 0444, NULL, &cdrom_sysctl_info},
  2572. {DEV_CDROM_AUTOCLOSE, "autoclose", &cdrom_sysctl_settings.autoclose,
  2573. sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
  2574. {DEV_CDROM_AUTOEJECT, "autoeject", &cdrom_sysctl_settings.autoeject,
  2575. sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
  2576. {DEV_CDROM_DEBUG, "debug", &cdrom_sysctl_settings.debug,
  2577. sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
  2578. {DEV_CDROM_LOCK, "lock", &cdrom_sysctl_settings.lock,
  2579. sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
  2580. {DEV_CDROM_CHECK_MEDIA, "check_media", &cdrom_sysctl_settings.check,
  2581. sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
  2582. {0}
  2583. };
  2585. ctl_table cdrom_cdrom_table[] = {
  2586. {DEV_CDROM, "cdrom", NULL, 0, 0555, cdrom_table},
  2587. {0}
  2588. };
  2590. /* Make sure that /proc/sys/dev is there */
  2591. ctl_table cdrom_root_table[] = {
  2592. #ifdef CONFIG_PROC_FS
  2593. {CTL_DEV, "dev", NULL, 0, 0555, cdrom_cdrom_table},
  2594. #endif /* CONFIG_PROC_FS */
  2595. {0}
  2596. };
  2597. static struct ctl_table_header *cdrom_sysctl_header;
  2599. static void cdrom_sysctl_register(void)
  2600. {
  2601. static int initialized;
  2603. if (initialized == 1)
  2604. return;
  2606. cdrom_sysctl_header = register_sysctl_table(cdrom_root_table, 1);
  2607. cdrom_root_table->child->de->owner = THIS_MODULE;
  2609. /* set the defaults */
  2610. cdrom_sysctl_settings.autoclose = autoclose;
  2611. cdrom_sysctl_settings.autoeject = autoeject;
  2612. cdrom_sysctl_settings.debug = debug;
  2613. cdrom_sysctl_settings.lock = lockdoor;
  2614. cdrom_sysctl_settings.check = check_media_type;
  2616. initialized = 1;
  2617. }
  2619. static void cdrom_sysctl_unregister(void)
  2620. {
  2621. if (cdrom_sysctl_header)
  2622. unregister_sysctl_table(cdrom_sysctl_header);
  2623. }
  2625. #endif /* CONFIG_SYSCTL */
  2627. static int __init cdrom_init(void)
  2628. {
  2629. #ifdef CONFIG_SYSCTL
  2630. cdrom_sysctl_register();
  2631. #endif
  2632. if (!devfs_handle)
  2633. devfs_handle = devfs_mk_dir(NULL, "cdroms", NULL);
  2634. return 0;
  2635. }
  2637. static void __exit cdrom_exit(void)
  2638. {
  2639. printk(KERN_INFO "Uniform CD-ROM driver unloadedn");
  2640. #ifdef CONFIG_SYSCTL
  2641. cdrom_sysctl_unregister();
  2642. #endif
  2643. devfs_unregister(devfs_handle);
  2644. }
  2646. module_init(cdrom_init);
  2647. module_exit(cdrom_exit);
  2648. MODULE_LICENSE("GPL");