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.rst 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. ;-)
18 ----------------------------------
19 1.00 Date Unknown -- David van Leeuwen <david@tm.tno.nl>
20 -- Initial version by David A. van Leeuwen. I don't have a detailed
21 changelog for the 1.x series, David?
23 2.00 Dec 2, 1997 -- Erik Andersen <andersee@debian.org>
24 -- New maintainer! As David A. van Leeuwen has been too busy to actively
25 maintain and improve this driver, I am now carrying on the torch. If
26 you have a problem with this driver, please feel free to contact me.
28 -- Added (rudimentary) sysctl interface. I realize this is really weak
29 right now, and is _very_ badly implemented. It will be improved...
31 -- Modified CDROM_DISC_STATUS so that it is now incorporated into
32 the Uniform CD-ROM driver via the cdrom_count_tracks function.
33 The cdrom_count_tracks function helps resolve some of the false
34 assumptions of the CDROM_DISC_STATUS ioctl, and is also used to check
35 for the correct media type when mounting or playing audio from a CD.
37 -- Remove the calls to verify_area and only use the copy_from_user and
38 copy_to_user stuff, since these calls now provide their own memory
39 checking with the 2.1.x kernels.
41 -- Major update to return codes so that errors from low-level drivers
42 are passed on through (thanks to Gerd Knorr for pointing out this
45 -- Made it so if a function isn't implemented in a low-level driver,
46 ENOSYS is now returned instead of EINVAL.
48 -- Simplified some complex logic so that the source code is easier to read.
50 -- Other stuff I probably forgot to mention (lots of changes).
52 2.01 to 2.11 Dec 1997-Jan 1998
53 -- TO-DO! Write changelogs for 2.01 to 2.12.
55 2.12 Jan 24, 1998 -- Erik Andersen <andersee@debian.org>
56 -- Fixed a bug in the IOCTL_IN and IOCTL_OUT macros. It turns out that
57 copy_*_user does not return EFAULT on error, but instead returns the number
58 of bytes not copied. I was returning whatever non-zero stuff came back from
59 the copy_*_user functions directly, which would result in strange errors.
61 2.13 July 17, 1998 -- Erik Andersen <andersee@debian.org>
62 -- Fixed a bug in CDROM_SELECT_SPEED where you couldn't lower the speed
63 of the drive. Thanks to Tobias Ringstr|m <tori@prosolvia.se> for pointing
64 this out and providing a simple fix.
65 -- Fixed the procfs-unload-module bug with the fill_inode procfs callback.
66 thanks to Andrea Arcangeli
67 -- Fixed it so that the /proc entry now also shows up when cdrom is
68 compiled into the kernel. Before it only worked when loaded as a module.
70 2.14 August 17, 1998 -- Erik Andersen <andersee@debian.org>
71 -- Fixed a bug in cdrom_media_changed and handling of reporting that
72 the media had changed for devices that _don't_ implement media_changed.
73 Thanks to Grant R. Guenther <grant@torque.net> for spotting this bug.
74 -- Made a few things more pedanticly correct.
76 2.50 Oct 19, 1998 - Jens Axboe <axboe@image.dk>
77 -- New maintainers! Erik was too busy to continue the work on the driver,
78 so now Chris Zwilling <chris@cloudnet.com> and Jens Axboe <axboe@image.dk>
79 will do their best to follow in his footsteps
81 2.51 Dec 20, 1998 - Jens Axboe <axboe@image.dk>
82 -- Check if drive is capable of doing what we ask before blindly changing
83 cdi->options in various ioctl.
84 -- Added version to proc entry.
86 2.52 Jan 16, 1999 - Jens Axboe <axboe@image.dk>
87 -- Fixed an error in open_for_data where we would sometimes not return
88 the correct error value. Thanks Huba Gaspar <huba@softcell.hu>.
89 -- Fixed module usage count - usage was based on /proc/sys/dev
90 instead of /proc/sys/dev/cdrom. This could lead to an oops when other
91 modules had entries in dev. Feb 02 - real bug was in sysctl.c where
92 dev would be removed even though it was used. cdrom.c just illuminated
95 2.53 Feb 22, 1999 - Jens Axboe <axboe@image.dk>
96 -- Fixup of several ioctl calls, in particular CDROM_SET_OPTIONS has
97 been "rewritten" because capabilities and options aren't in sync. They
99 -- Added CDROM_LOCKDOOR ioctl. Locks the door and keeps it that way.
100 -- Added CDROM_RESET ioctl.
101 -- Added CDROM_DEBUG ioctl. Enable debug messages on-the-fly.
102 -- Added CDROM_GET_CAPABILITY ioctl. This relieves userspace programs
103 from parsing /proc/sys/dev/cdrom/info.
105 2.54 Mar 15, 1999 - Jens Axboe <axboe@image.dk>
106 -- Check capability mask from low level driver when counting tracks as
107 per suggestion from Corey J. Scotts <cstotts@blue.weeg.uiowa.edu>.
109 2.55 Apr 25, 1999 - Jens Axboe <axboe@image.dk>
110 -- autoclose was mistakenly checked against CDC_OPEN_TRAY instead of
112 -- proc info didn't mask against capabilities mask.
114 3.00 Aug 5, 1999 - Jens Axboe <axboe@image.dk>
115 -- Unified audio ioctl handling across CD-ROM drivers. A lot of the
116 code was duplicated before. Drives that support the generic packet
117 interface are now being fed packets from here instead.
118 -- First attempt at adding support for MMC2 commands - for DVD and
119 CD-R(W) drives. Only the DVD parts are in now - the interface used is
120 the same as for the audio ioctls.
121 -- ioctl cleanups. if a drive couldn't play audio, it didn't get
122 a change to perform device specific ioctls as well.
123 -- Defined CDROM_CAN(CDC_XXX) for checking the capabilities.
124 -- Put in sysctl files for autoclose, autoeject, check_media, debug,
126 -- /proc/sys/dev/cdrom/info has been updated to also contain info about
127 CD-Rx and DVD capabilities.
128 -- Now default to checking media type.
129 -- CDROM_SEND_PACKET ioctl added. The infrastructure was in place for
130 doing this anyway, with the generic_packet addition.
132 3.01 Aug 6, 1999 - Jens Axboe <axboe@image.dk>
133 -- Fix up the sysctl handling so that the option flags get set
135 -- Fix up ioctl handling so the device specific ones actually get
138 3.02 Aug 8, 1999 - Jens Axboe <axboe@image.dk>
139 -- Fixed volume control on SCSI drives (or others with longer audio
141 -- Fixed a couple of DVD minors. Thanks to Andrew T. Veliath
142 <andrewtv@usa.net> for telling me and for having defined the various
143 DVD structures and ioctls in the first place! He designed the original
144 DVD patches for ide-cd and while I rearranged and unified them, the
145 interface is still the same.
147 3.03 Sep 1, 1999 - Jens Axboe <axboe@image.dk>
148 -- Moved the rest of the audio ioctls from the CD-ROM drivers here. Only
149 CDROMREADTOCENTRY and CDROMREADTOCHDR are left.
150 -- Moved the CDROMREADxxx ioctls in here.
151 -- Defined the cdrom_get_last_written and cdrom_get_next_block as ioctls
152 and exported functions.
153 -- Erik Andersen <andersen@xmission.com> modified all SCMD_ commands
154 to now read GPCMD_ for the new generic packet interface. All low level
155 drivers are updated as well.
156 -- Various other cleanups.
158 3.04 Sep 12, 1999 - Jens Axboe <axboe@image.dk>
159 -- Fixed a couple of possible memory leaks (if an operation failed and
160 we didn't free the buffer before returning the error).
161 -- Integrated Uniform CD Changer handling from Richard Sharman
162 <rsharman@pobox.com>.
163 -- Defined CD_DVD and CD_CHANGER log levels.
164 -- Fixed the CDROMREADxxx ioctls.
165 -- CDROMPLAYTRKIND uses the GPCMD_PLAY_AUDIO_MSF command - too few
166 drives supported it. We lose the index part, however.
167 -- Small modifications to accommodate opens of /dev/hdc1, required
168 for ide-cd to handle multisession discs.
169 -- Export cdrom_mode_sense and cdrom_mode_select.
170 -- init_cdrom_command() for setting up a cgc command.
172 3.05 Oct 24, 1999 - Jens Axboe <axboe@image.dk>
173 -- Changed the interface for CDROM_SEND_PACKET. Before it was virtually
174 impossible to send the drive data in a sensible way.
175 -- Lowered stack usage in mmc_ioctl(), dvd_read_disckey(), and
177 -- Added setup of write mode for packet writing.
178 -- Fixed CDDA ripping with cdda2wav - accept much larger requests of
179 number of frames and split the reads in blocks of 8.
181 3.06 Dec 13, 1999 - Jens Axboe <axboe@image.dk>
182 -- Added support for changing the region of DVD drives.
183 -- Added sense data to generic command.
185 3.07 Feb 2, 2000 - Jens Axboe <axboe@suse.de>
186 -- Do same "read header length" trick in cdrom_get_disc_info() as
187 we do in cdrom_get_track_info() -- some drive don't obey specs and
188 fail if they can't supply the full Mt Fuji size table.
189 -- Deleted stuff related to setting up write modes. It has a different
191 -- Clear header length in mode_select unconditionally.
192 -- Removed the register_disk() that was added, not needed here.
194 3.08 May 1, 2000 - Jens Axboe <axboe@suse.de>
195 -- Fix direction flag in setup_send_key and setup_report_key. This
196 gave some SCSI adapters problems.
197 -- Always return -EROFS for write opens
198 -- Convert to module_init/module_exit style init and remove some
199 of the #ifdef MODULE stuff
200 -- Fix several dvd errors - DVD_LU_SEND_ASF should pass agid,
201 DVD_HOST_SEND_RPC_STATE did not set buffer size in cdb, and
202 dvd_do_auth passed uninitialized data to drive because init_cdrom_command
203 did not clear a 0 sized buffer.
205 3.09 May 12, 2000 - Jens Axboe <axboe@suse.de>
206 -- Fix Video-CD on SCSI drives that don't support READ_CD command. In
207 that case switch block size and issue plain READ_10 again, then switch
210 3.10 Jun 10, 2000 - Jens Axboe <axboe@suse.de>
211 -- Fix volume control on CD's - old SCSI-II drives now use their own
212 code, as doing MODE6 stuff in here is really not my intention.
213 -- Use READ_DISC_INFO for more reliable end-of-disc.
215 3.11 Jun 12, 2000 - Jens Axboe <axboe@suse.de>
216 -- Fix bug in getting rpc phase 2 region info.
217 -- Reinstate "correct" CDROMPLAYTRKIND
219 3.12 Oct 18, 2000 - Jens Axboe <axboe@suse.de>
220 -- Use quiet bit on packet commands not known to work
222 3.20 Dec 17, 2003 - Jens Axboe <axboe@suse.de>
223 -- Various fixes and lots of cleanups not listed :-)
225 -- Mt Rainier support
226 -- DVD-RAM write open fixes
228 Nov 5 2001, Aug 8 2002. Modified by Andy Polyakov
229 <appro@fy.chalmers.se> to support MMC-3 compliant DVD+RW units.
231 Modified by Nigel Kukard <nkukard@lbsd.net> - support DVD+RW
232 2.4.x patch by Andy Polyakov <appro@fy.chalmers.se>
234 -------------------------------------------------------------------------*/
236 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
238 #define REVISION "Revision: 3.20"
239 #define VERSION "Id: cdrom.c 3.20 2003/12/17"
241 /* I use an error-log mask to give fine grain control over the type of
242 messages dumped to the system logs. The available masks include: */
243 #define CD_NOTHING 0x0
244 #define CD_WARNING 0x1
245 #define CD_REG_UNREG 0x2
246 #define CD_DO_IOCTL 0x4
248 #define CD_CLOSE 0x10
249 #define CD_COUNT_TRACKS 0x20
250 #define CD_CHANGER 0x40
253 /* Define this to remove _all_ the debugging messages */
254 /* #define ERRLOGMASK CD_NOTHING */
255 #define ERRLOGMASK CD_WARNING
256 /* #define ERRLOGMASK (CD_WARNING|CD_OPEN|CD_COUNT_TRACKS|CD_CLOSE) */
257 /* #define ERRLOGMASK (CD_WARNING|CD_REG_UNREG|CD_DO_IOCTL|CD_OPEN|CD_CLOSE|CD_COUNT_TRACKS) */
259 #include <linux/atomic.h>
260 #include <linux/module.h>
261 #include <linux/fs.h>
262 #include <linux/major.h>
263 #include <linux/types.h>
264 #include <linux/errno.h>
265 #include <linux/kernel.h>
266 #include <linux/mm.h>
267 #include <linux/slab.h>
268 #include <linux/cdrom.h>
269 #include <linux/sysctl.h>
270 #include <linux/proc_fs.h>
271 #include <linux/blkpg.h>
272 #include <linux/init.h>
273 #include <linux/fcntl.h>
274 #include <linux/blkdev.h>
275 #include <linux/times.h>
276 #include <linux/uaccess.h>
277 #include <scsi/scsi_common.h>
279 /* used to tell the module to turn on full debugging messages */
281 /* default compatibility mode */
282 static bool autoclose=1;
283 static bool autoeject;
284 static bool lockdoor = 1;
285 /* will we ever get to use this... sigh. */
286 static bool check_media_type;
287 /* automatically restart mrw format */
288 static bool mrw_format_restart = 1;
289 module_param(debug, bool, 0);
290 module_param(autoclose, bool, 0);
291 module_param(autoeject, bool, 0);
292 module_param(lockdoor, bool, 0);
293 module_param(check_media_type, bool, 0);
294 module_param(mrw_format_restart, bool, 0);
296 static DEFINE_MUTEX(cdrom_mutex);
298 static const char *mrw_format_status[] = {
305 static const char *mrw_address_space[] = { "DMA", "GAA" };
307 #if (ERRLOGMASK != CD_NOTHING)
308 #define cd_dbg(type, fmt, ...) \
310 if ((ERRLOGMASK & type) || debug == 1) \
311 pr_debug(fmt, ##__VA_ARGS__); \
314 #define cd_dbg(type, fmt, ...) \
316 if (0 && (ERRLOGMASK & type) || debug == 1) \
317 pr_debug(fmt, ##__VA_ARGS__); \
321 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
322 a lot of places. This macro makes the code more clear. */
323 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
326 * Another popular OS uses 7 seconds as the hard timeout for default
327 * commands, so it is a good choice for us as well.
329 #define CDROM_DEF_TIMEOUT (7 * HZ)
331 /* Not-exported routines. */
333 static void cdrom_sysctl_register(void);
335 static LIST_HEAD(cdrom_list);
337 static void signal_media_change(struct cdrom_device_info *cdi)
339 cdi->mc_flags = 0x3; /* set media changed bits, on both queues */
340 cdi->last_media_change_ms = ktime_to_ms(ktime_get());
343 int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
344 struct packet_command *cgc)
347 cgc->sshdr->sense_key = 0x05;
348 cgc->sshdr->asc = 0x20;
349 cgc->sshdr->ascq = 0x00;
355 EXPORT_SYMBOL(cdrom_dummy_generic_packet);
357 static int cdrom_flush_cache(struct cdrom_device_info *cdi)
359 struct packet_command cgc;
361 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
362 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
364 cgc.timeout = 5 * 60 * HZ;
366 return cdi->ops->generic_packet(cdi, &cgc);
369 /* requires CD R/RW */
370 static int cdrom_get_disc_info(struct cdrom_device_info *cdi,
371 disc_information *di)
373 const struct cdrom_device_ops *cdo = cdi->ops;
374 struct packet_command cgc;
377 /* set up command and get the disc info */
378 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
379 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
380 cgc.cmd[8] = cgc.buflen = 2;
383 ret = cdo->generic_packet(cdi, &cgc);
387 /* not all drives have the same disc_info length, so requeue
388 * packet with the length the drive tells us it can supply
390 buflen = be16_to_cpu(di->disc_information_length) +
391 sizeof(di->disc_information_length);
393 if (buflen > sizeof(disc_information))
394 buflen = sizeof(disc_information);
396 cgc.cmd[8] = cgc.buflen = buflen;
397 ret = cdo->generic_packet(cdi, &cgc);
401 /* return actual fill size */
405 /* This macro makes sure we don't have to check on cdrom_device_ops
406 * existence in the run-time routines below. Change_capability is a
407 * hack to have the capability flags defined const, while we can still
408 * change it here without gcc complaining at every line.
410 #define ENSURE(cdo, call, bits) \
412 if (cdo->call == NULL) \
413 WARN_ON_ONCE((cdo)->capability & (bits)); \
417 * the first prototypes used 0x2c as the page code for the mrw mode page,
418 * subsequently this was changed to 0x03. probe the one used by this drive
420 static int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
422 struct packet_command cgc;
425 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
430 if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
431 cdi->mrw_mode_page = MRW_MODE_PC;
433 } else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
434 cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
441 static int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
443 struct packet_command cgc;
444 struct mrw_feature_desc *mfd;
445 unsigned char buffer[16];
450 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
452 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
453 cgc.cmd[3] = CDF_MRW;
454 cgc.cmd[8] = sizeof(buffer);
457 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
460 mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
461 if (be16_to_cpu(mfd->feature_code) != CDF_MRW)
465 if ((ret = cdrom_mrw_probe_pc(cdi))) {
473 static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
475 struct packet_command cgc;
476 unsigned char buffer[12];
479 pr_info("%sstarting format\n", cont ? "Re" : "");
482 * FmtData bit set (bit 4), format type is 1
484 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
485 cgc.cmd[0] = GPCMD_FORMAT_UNIT;
486 cgc.cmd[1] = (1 << 4) | 1;
488 cgc.timeout = 5 * 60 * HZ;
491 * 4 byte format list header, 8 byte format list descriptor
504 buffer[8] = 0x24 << 2;
507 ret = cdi->ops->generic_packet(cdi, &cgc);
509 pr_info("bgformat failed\n");
514 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
516 struct packet_command cgc;
518 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
519 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
522 * Session = 1, Track = 0
524 cgc.cmd[1] = !!immed;
527 cgc.timeout = 5 * 60 * HZ;
529 return cdi->ops->generic_packet(cdi, &cgc);
532 static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
537 ret = cdrom_get_disc_info(cdi, &di);
538 if (ret < 0 || ret < (int)offsetof(typeof(di),disc_type))
542 if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
543 pr_info("issuing MRW background format suspend\n");
544 ret = cdrom_mrw_bgformat_susp(cdi, 0);
547 if (!ret && cdi->media_written)
548 ret = cdrom_flush_cache(cdi);
553 static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
555 struct packet_command cgc;
556 struct mode_page_header *mph;
558 int ret, offset, size;
560 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
563 cgc.buflen = sizeof(buffer);
565 ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0);
569 mph = (struct mode_page_header *)buffer;
570 offset = be16_to_cpu(mph->desc_length);
571 size = be16_to_cpu(mph->mode_data_length) + 2;
573 buffer[offset + 3] = space;
576 ret = cdrom_mode_select(cdi, &cgc);
580 pr_info("%s: mrw address space %s selected\n",
581 cdi->name, mrw_address_space[space]);
585 int register_cdrom(struct gendisk *disk, struct cdrom_device_info *cdi)
587 static char banner_printed;
588 const struct cdrom_device_ops *cdo = cdi->ops;
590 cd_dbg(CD_OPEN, "entering register_cdrom\n");
592 if (cdo->open == NULL || cdo->release == NULL)
594 if (!banner_printed) {
595 pr_info("Uniform CD-ROM driver " REVISION "\n");
597 cdrom_sysctl_register();
603 ENSURE(cdo, drive_status, CDC_DRIVE_STATUS);
604 if (cdo->check_events == NULL)
605 WARN_ON_ONCE(cdo->capability & (CDC_MEDIA_CHANGED | CDC_SELECT_DISC));
606 ENSURE(cdo, tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
607 ENSURE(cdo, lock_door, CDC_LOCK);
608 ENSURE(cdo, select_speed, CDC_SELECT_SPEED);
609 ENSURE(cdo, get_last_session, CDC_MULTI_SESSION);
610 ENSURE(cdo, get_mcn, CDC_MCN);
611 ENSURE(cdo, reset, CDC_RESET);
612 ENSURE(cdo, generic_packet, CDC_GENERIC_PACKET);
614 cdi->options = CDO_USE_FFLAGS;
615 cdi->last_media_change_ms = ktime_to_ms(ktime_get());
617 if (autoclose == 1 && CDROM_CAN(CDC_CLOSE_TRAY))
618 cdi->options |= (int) CDO_AUTO_CLOSE;
619 if (autoeject == 1 && CDROM_CAN(CDC_OPEN_TRAY))
620 cdi->options |= (int) CDO_AUTO_EJECT;
622 cdi->options |= (int) CDO_LOCK;
623 if (check_media_type == 1)
624 cdi->options |= (int) CDO_CHECK_TYPE;
626 if (CDROM_CAN(CDC_MRW_W))
627 cdi->exit = cdrom_mrw_exit;
629 if (cdi->ops->read_cdda_bpc)
630 cdi->cdda_method = CDDA_BPC_FULL;
632 cdi->cdda_method = CDDA_OLD;
634 WARN_ON(!cdo->generic_packet);
636 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
637 mutex_lock(&cdrom_mutex);
638 list_add(&cdi->list, &cdrom_list);
639 mutex_unlock(&cdrom_mutex);
642 EXPORT_SYMBOL(register_cdrom);
645 void unregister_cdrom(struct cdrom_device_info *cdi)
647 cd_dbg(CD_OPEN, "entering unregister_cdrom\n");
649 mutex_lock(&cdrom_mutex);
650 list_del(&cdi->list);
651 mutex_unlock(&cdrom_mutex);
656 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
658 EXPORT_SYMBOL(unregister_cdrom);
660 int cdrom_get_media_event(struct cdrom_device_info *cdi,
661 struct media_event_desc *med)
663 struct packet_command cgc;
664 unsigned char buffer[8];
665 struct event_header *eh = (struct event_header *)buffer;
667 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
668 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
669 cgc.cmd[1] = 1; /* IMMED */
670 cgc.cmd[4] = 1 << 4; /* media event */
671 cgc.cmd[8] = sizeof(buffer);
674 if (cdi->ops->generic_packet(cdi, &cgc))
677 if (be16_to_cpu(eh->data_len) < sizeof(*med))
680 if (eh->nea || eh->notification_class != 0x4)
683 memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
686 EXPORT_SYMBOL(cdrom_get_media_event);
688 static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
689 struct rwrt_feature_desc *rfd)
691 struct packet_command cgc;
695 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
697 cgc.cmd[0] = GPCMD_GET_CONFIGURATION; /* often 0x46 */
698 cgc.cmd[3] = CDF_RWRT; /* often 0x0020 */
699 cgc.cmd[8] = sizeof(buffer); /* often 0x18 */
702 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
705 memcpy(rfd, &buffer[sizeof(struct feature_header)], sizeof (*rfd));
709 static int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
711 struct packet_command cgc;
713 __be16 *feature_code;
716 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
718 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
719 cgc.cmd[3] = CDF_HWDM;
720 cgc.cmd[8] = sizeof(buffer);
723 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
726 feature_code = (__be16 *) &buffer[sizeof(struct feature_header)];
727 if (be16_to_cpu(*feature_code) == CDF_HWDM)
734 static int cdrom_is_random_writable(struct cdrom_device_info *cdi, int *write)
736 struct rwrt_feature_desc rfd;
741 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
744 if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
750 static int cdrom_media_erasable(struct cdrom_device_info *cdi)
755 ret = cdrom_get_disc_info(cdi, &di);
756 if (ret < 0 || ret < offsetof(typeof(di), n_first_track))
763 * FIXME: check RO bit
765 static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
767 int ret = cdrom_media_erasable(cdi);
770 * allow writable open if media info read worked and media is
771 * erasable, _or_ if it fails since not all drives support it
779 static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
785 * always reset to DMA lba space on open
787 if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_DMA)) {
788 pr_err("failed setting lba address space\n");
792 ret = cdrom_get_disc_info(cdi, &di);
793 if (ret < 0 || ret < offsetof(typeof(di),disc_type))
801 * 0 - not MRW formatted
802 * 1 - MRW bgformat started, but not running or complete
803 * 2 - MRW bgformat in progress
804 * 3 - MRW formatting complete
807 pr_info("open: mrw_status '%s'\n", mrw_format_status[di.mrw_status]);
810 else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE &&
812 ret = cdrom_mrw_bgformat(cdi, 1);
817 static int mo_open_write(struct cdrom_device_info *cdi)
819 struct packet_command cgc;
823 init_cdrom_command(&cgc, &buffer, 4, CGC_DATA_READ);
827 * obtain write protect information as per
828 * drivers/scsi/sd.c:sd_read_write_protect_flag
831 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
833 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_VENDOR_PAGE, 0);
836 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
839 /* drive gave us no info, let the user go ahead */
843 return buffer[3] & 0x80;
846 static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
848 struct rwrt_feature_desc rfd;
851 if ((ret = cdrom_has_defect_mgt(cdi)))
854 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
856 else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
859 cd_dbg(CD_OPEN, "can open for random write\n");
863 static void cdrom_mmc3_profile(struct cdrom_device_info *cdi)
865 struct packet_command cgc;
869 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
871 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
873 cgc.cmd[2] = cgc.cmd[3] = 0; /* Starting Feature Number */
874 cgc.cmd[8] = sizeof(buffer); /* Allocation Length */
877 if (cdi->ops->generic_packet(cdi, &cgc))
878 mmc3_profile = 0xffff;
880 mmc3_profile = (buffer[6] << 8) | buffer[7];
882 cdi->mmc3_profile = mmc3_profile;
885 static int cdrom_is_dvd_rw(struct cdrom_device_info *cdi)
887 switch (cdi->mmc3_profile) {
888 case 0x12: /* DVD-RAM */
889 case 0x1A: /* DVD+RW */
890 case 0x43: /* BD-RE */
898 * returns 0 for ok to open write, non-0 to disallow
900 static int cdrom_open_write(struct cdrom_device_info *cdi)
902 int mrw, mrw_write, ram_write;
906 if (!cdrom_is_mrw(cdi, &mrw_write))
909 if (CDROM_CAN(CDC_MO_DRIVE))
912 (void) cdrom_is_random_writable(cdi, &ram_write);
915 cdi->mask &= ~CDC_MRW;
917 cdi->mask |= CDC_MRW;
920 cdi->mask &= ~CDC_MRW_W;
922 cdi->mask |= CDC_MRW_W;
925 cdi->mask &= ~CDC_RAM;
927 cdi->mask |= CDC_RAM;
929 if (CDROM_CAN(CDC_MRW_W))
930 ret = cdrom_mrw_open_write(cdi);
931 else if (CDROM_CAN(CDC_DVD_RAM))
932 ret = cdrom_dvdram_open_write(cdi);
933 else if (CDROM_CAN(CDC_RAM) &&
934 !CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW|CDC_MO_DRIVE))
935 ret = cdrom_ram_open_write(cdi);
936 else if (CDROM_CAN(CDC_MO_DRIVE))
937 ret = mo_open_write(cdi);
938 else if (!cdrom_is_dvd_rw(cdi))
944 static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
946 struct packet_command cgc;
948 if (cdi->mmc3_profile != 0x1a) {
949 cd_dbg(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
953 if (!cdi->media_written) {
954 cd_dbg(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
958 pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi->name);
960 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
961 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
963 cdi->ops->generic_packet(cdi, &cgc);
965 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
966 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
967 cgc.timeout = 3000*HZ;
969 cdi->ops->generic_packet(cdi, &cgc);
971 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
972 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
973 cgc.cmd[2] = 2; /* Close session */
975 cgc.timeout = 3000*HZ;
976 cdi->ops->generic_packet(cdi, &cgc);
978 cdi->media_written = 0;
981 /* badly broken, I know. Is due for a fixup anytime. */
982 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype *tracks)
984 struct cdrom_tochdr header;
985 struct cdrom_tocentry entry;
992 cd_dbg(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
994 if (!CDROM_CAN(CDC_PLAY_AUDIO)) {
995 tracks->error = CDS_NO_INFO;
999 /* Grab the TOC header so we can see how many tracks there are */
1000 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
1002 if (ret == -ENOMEDIUM)
1003 tracks->error = CDS_NO_DISC;
1005 tracks->error = CDS_NO_INFO;
1008 /* check what type of tracks are on this disc */
1009 entry.cdte_format = CDROM_MSF;
1010 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1011 entry.cdte_track = i;
1012 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1013 tracks->error = CDS_NO_INFO;
1016 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1017 if (entry.cdte_format == 0x10)
1019 else if (entry.cdte_format == 0x20)
1026 cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1027 i, entry.cdte_format, entry.cdte_ctrl);
1029 cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1030 header.cdth_trk1, tracks->audio, tracks->data,
1031 tracks->cdi, tracks->xa);
1035 int open_for_data(struct cdrom_device_info *cdi)
1038 const struct cdrom_device_ops *cdo = cdi->ops;
1040 cd_dbg(CD_OPEN, "entering open_for_data\n");
1041 /* Check if the driver can report drive status. If it can, we
1042 can do clever things. If it can't, well, we at least tried! */
1043 if (cdo->drive_status != NULL) {
1044 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1045 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1046 if (ret == CDS_TRAY_OPEN) {
1047 cd_dbg(CD_OPEN, "the tray is open...\n");
1048 /* can/may i close it? */
1049 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1050 cdi->options & CDO_AUTO_CLOSE) {
1051 cd_dbg(CD_OPEN, "trying to close the tray\n");
1052 ret=cdo->tray_move(cdi,0);
1054 cd_dbg(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1055 /* Ignore the error from the low
1056 level driver. We don't care why it
1057 couldn't close the tray. We only care
1058 that there is no disc in the drive,
1059 since that is the _REAL_ problem here.*/
1061 goto clean_up_and_return;
1064 cd_dbg(CD_OPEN, "bummer. this drive can't close the tray.\n");
1066 goto clean_up_and_return;
1068 /* Ok, the door should be closed now.. Check again */
1069 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1070 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1071 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1072 cd_dbg(CD_OPEN, "tray might not contain a medium\n");
1074 goto clean_up_and_return;
1076 cd_dbg(CD_OPEN, "the tray is now closed\n");
1078 /* the door should be closed now, check for the disc */
1079 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1080 if (ret!=CDS_DISC_OK) {
1082 goto clean_up_and_return;
1085 cdrom_count_tracks(cdi, &tracks);
1086 if (tracks.error == CDS_NO_DISC) {
1087 cd_dbg(CD_OPEN, "bummer. no disc.\n");
1089 goto clean_up_and_return;
1091 /* CD-Players which don't use O_NONBLOCK, workman
1092 * for example, need bit CDO_CHECK_TYPE cleared! */
1093 if (tracks.data==0) {
1094 if (cdi->options & CDO_CHECK_TYPE) {
1095 /* give people a warning shot, now that CDO_CHECK_TYPE
1096 is the default case! */
1097 cd_dbg(CD_OPEN, "bummer. wrong media type.\n");
1098 cd_dbg(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1099 (unsigned int)task_pid_nr(current));
1101 goto clean_up_and_return;
1104 cd_dbg(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set\n");
1108 cd_dbg(CD_OPEN, "all seems well, opening the devicen");
1110 /* all seems well, we can open the device */
1111 ret = cdo->open(cdi, 0); /* open for data */
1112 cd_dbg(CD_OPEN, "opening the device gave me %d\n", ret);
1113 /* After all this careful checking, we shouldn't have problems
1114 opening the device, but we don't want the device locked if
1115 this somehow fails... */
1117 cd_dbg(CD_OPEN, "open device failed\n");
1118 goto clean_up_and_return;
1120 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1121 cdo->lock_door(cdi, 1);
1122 cd_dbg(CD_OPEN, "door locked\n");
1124 cd_dbg(CD_OPEN, "device opened successfully\n");
1127 /* Something failed. Try to unlock the drive, because some drivers
1128 (notably ide-cd) lock the drive after every command. This produced
1129 a nasty bug where after mount failed, the drive would remain locked!
1130 This ensures that the drive gets unlocked after a mount fails. This
1131 is a goto to avoid bloating the driver with redundant code. */
1132 clean_up_and_return:
1133 cd_dbg(CD_OPEN, "open failed\n");
1134 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1135 cdo->lock_door(cdi, 0);
1136 cd_dbg(CD_OPEN, "door unlocked\n");
1141 /* We use the open-option O_NONBLOCK to indicate that the
1142 * purpose of opening is only for subsequent ioctl() calls; no device
1143 * integrity checks are performed.
1145 * We hope that all cd-player programs will adopt this convention. It
1146 * is in their own interest: device control becomes a lot easier
1149 int cdrom_open(struct cdrom_device_info *cdi, fmode_t mode)
1153 cd_dbg(CD_OPEN, "entering cdrom_open\n");
1155 /* if this was a O_NONBLOCK open and we should honor the flags,
1156 * do a quick open without drive/disc integrity checks. */
1158 if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) {
1159 ret = cdi->ops->open(cdi, 1);
1161 ret = open_for_data(cdi);
1164 if (CDROM_CAN(CDC_GENERIC_PACKET))
1165 cdrom_mmc3_profile(cdi);
1166 if (mode & FMODE_WRITE) {
1168 if (cdrom_open_write(cdi))
1170 if (!CDROM_CAN(CDC_RAM))
1173 cdi->media_written = 0;
1175 cdi->opened_for_data = true;
1181 cd_dbg(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1182 cdi->name, cdi->use_count);
1185 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1186 cdi->ops->lock_door(cdi, 0);
1187 cd_dbg(CD_OPEN, "door unlocked\n");
1189 cdi->ops->release(cdi);
1194 EXPORT_SYMBOL(cdrom_open);
1196 /* This code is similar to that in open_for_data. The routine is called
1197 whenever an audio play operation is requested.
1199 static int check_for_audio_disc(struct cdrom_device_info *cdi,
1200 const struct cdrom_device_ops *cdo)
1204 cd_dbg(CD_OPEN, "entering check_for_audio_disc\n");
1205 if (!(cdi->options & CDO_CHECK_TYPE))
1207 if (cdo->drive_status != NULL) {
1208 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1209 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1210 if (ret == CDS_TRAY_OPEN) {
1211 cd_dbg(CD_OPEN, "the tray is open...\n");
1212 /* can/may i close it? */
1213 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1214 cdi->options & CDO_AUTO_CLOSE) {
1215 cd_dbg(CD_OPEN, "trying to close the tray\n");
1216 ret=cdo->tray_move(cdi,0);
1218 cd_dbg(CD_OPEN, "bummer. tried to close tray but failed.\n");
1219 /* Ignore the error from the low
1220 level driver. We don't care why it
1221 couldn't close the tray. We only care
1222 that there is no disc in the drive,
1223 since that is the _REAL_ problem here.*/
1227 cd_dbg(CD_OPEN, "bummer. this driver can't close the tray.\n");
1230 /* Ok, the door should be closed now.. Check again */
1231 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1232 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1233 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1236 if (ret!=CDS_DISC_OK) {
1237 cd_dbg(CD_OPEN, "bummer. disc isn't ready.\n");
1240 cd_dbg(CD_OPEN, "the tray is now closed\n");
1243 cdrom_count_tracks(cdi, &tracks);
1245 return(tracks.error);
1247 if (tracks.audio==0)
1248 return -EMEDIUMTYPE;
1253 void cdrom_release(struct cdrom_device_info *cdi, fmode_t mode)
1255 const struct cdrom_device_ops *cdo = cdi->ops;
1257 cd_dbg(CD_CLOSE, "entering cdrom_release\n");
1259 if (cdi->use_count > 0)
1262 if (cdi->use_count == 0) {
1263 cd_dbg(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n",
1265 cdrom_dvd_rw_close_write(cdi);
1267 if ((cdo->capability & CDC_LOCK) && !cdi->keeplocked) {
1268 cd_dbg(CD_CLOSE, "Unlocking door!\n");
1269 cdo->lock_door(cdi, 0);
1275 if (cdi->use_count == 0 && cdi->opened_for_data) {
1276 if (cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1277 cdo->tray_move(cdi, 1);
1278 cdi->opened_for_data = false;
1281 EXPORT_SYMBOL(cdrom_release);
1283 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1284 struct cdrom_changer_info *buf)
1286 struct packet_command cgc;
1287 const struct cdrom_device_ops *cdo = cdi->ops;
1291 * Sanyo changer isn't spec compliant (doesn't use regular change
1292 * LOAD_UNLOAD command, and it doesn't implement the mech status
1295 if (cdi->sanyo_slot) {
1296 buf->hdr.nslots = 3;
1297 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1298 for (length = 0; length < 3; length++) {
1299 buf->slots[length].disc_present = 1;
1300 buf->slots[length].change = 0;
1305 length = sizeof(struct cdrom_mechstat_header) +
1306 cdi->capacity * sizeof(struct cdrom_slot);
1308 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1309 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1310 cgc.cmd[8] = (length >> 8) & 0xff;
1311 cgc.cmd[9] = length & 0xff;
1312 return cdo->generic_packet(cdi, &cgc);
1315 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1317 struct cdrom_changer_info *info;
1320 cd_dbg(CD_CHANGER, "entering cdrom_slot_status()\n");
1321 if (cdi->sanyo_slot)
1324 info = kmalloc(sizeof(*info), GFP_KERNEL);
1328 if ((ret = cdrom_read_mech_status(cdi, info)))
1331 if (info->slots[slot].disc_present)
1341 /* Return the number of slots for an ATAPI/SCSI cdrom,
1342 * return 1 if not a changer.
1344 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1347 struct cdrom_changer_info *info;
1349 cd_dbg(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1350 /* cdrom_read_mech_status requires a valid value for capacity: */
1353 info = kmalloc(sizeof(*info), GFP_KERNEL);
1357 if (cdrom_read_mech_status(cdi, info) == 0)
1358 nslots = info->hdr.nslots;
1363 EXPORT_SYMBOL(cdrom_number_of_slots);
1366 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1367 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1369 struct packet_command cgc;
1371 cd_dbg(CD_CHANGER, "entering cdrom_load_unload()\n");
1372 if (cdi->sanyo_slot && slot < 0)
1375 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1376 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1377 cgc.cmd[4] = 2 + (slot >= 0);
1379 cgc.timeout = 60 * HZ;
1381 /* The Sanyo 3 CD changer uses byte 7 of the
1382 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1383 using the GPCMD_LOAD_UNLOAD opcode. */
1384 if (cdi->sanyo_slot && -1 < slot) {
1385 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1387 cgc.cmd[4] = cgc.cmd[8] = 0;
1388 cdi->sanyo_slot = slot ? slot : 3;
1391 return cdi->ops->generic_packet(cdi, &cgc);
1394 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1396 struct cdrom_changer_info *info;
1400 cd_dbg(CD_CHANGER, "entering cdrom_select_disc()\n");
1401 if (!CDROM_CAN(CDC_SELECT_DISC))
1402 return -EDRIVE_CANT_DO_THIS;
1404 if (cdi->ops->check_events)
1405 cdi->ops->check_events(cdi, 0, slot);
1407 if (slot == CDSL_NONE) {
1408 signal_media_change(cdi);
1409 return cdrom_load_unload(cdi, -1);
1412 info = kmalloc(sizeof(*info), GFP_KERNEL);
1416 if ((ret = cdrom_read_mech_status(cdi, info))) {
1421 curslot = info->hdr.curslot;
1424 if (cdi->use_count > 1 || cdi->keeplocked) {
1425 if (slot == CDSL_CURRENT) {
1432 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1433 which is useful if it had been previously unloaded.
1434 Whether it can or not, it returns the current slot.
1435 Similarly, if slot happens to be the current one, we still
1437 if (slot == CDSL_CURRENT)
1440 /* set media changed bits on both queues */
1441 signal_media_change(cdi);
1442 if ((ret = cdrom_load_unload(cdi, slot)))
1449 * As cdrom implements an extra ioctl consumer for media changed
1450 * event, it needs to buffer ->check_events() output, such that event
1451 * is not lost for both the usual VFS and ioctl paths.
1452 * cdi->{vfs|ioctl}_events are used to buffer pending events for each
1455 * XXX: Locking is non-existent. cdi->ops->check_events() can be
1456 * called in parallel and buffering fields are accessed without any
1457 * exclusion. The original media_changed code had the same problem.
1458 * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1459 * and remove this cruft altogether. It doesn't have much usefulness
1462 static void cdrom_update_events(struct cdrom_device_info *cdi,
1463 unsigned int clearing)
1465 unsigned int events;
1467 events = cdi->ops->check_events(cdi, clearing, CDSL_CURRENT);
1468 cdi->vfs_events |= events;
1469 cdi->ioctl_events |= events;
1472 unsigned int cdrom_check_events(struct cdrom_device_info *cdi,
1473 unsigned int clearing)
1475 unsigned int events;
1477 cdrom_update_events(cdi, clearing);
1478 events = cdi->vfs_events;
1479 cdi->vfs_events = 0;
1482 EXPORT_SYMBOL(cdrom_check_events);
1484 /* We want to make media_changed accessible to the user through an
1485 * ioctl. The main problem now is that we must double-buffer the
1486 * low-level implementation, to assure that the VFS and the user both
1487 * see a medium change once.
1491 int media_changed(struct cdrom_device_info *cdi, int queue)
1493 unsigned int mask = (1 << (queue & 1));
1494 int ret = !!(cdi->mc_flags & mask);
1497 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1500 /* changed since last call? */
1501 BUG_ON(!queue); /* shouldn't be called from VFS path */
1502 cdrom_update_events(cdi, DISK_EVENT_MEDIA_CHANGE);
1503 changed = cdi->ioctl_events & DISK_EVENT_MEDIA_CHANGE;
1504 cdi->ioctl_events = 0;
1507 signal_media_change(cdi);
1509 cdi->media_written = 0;
1512 cdi->mc_flags &= ~mask; /* clear bit */
1516 /* Requests to the low-level drivers will /always/ be done in the
1517 following format convention:
1519 CDROM_LBA: all data-related requests.
1520 CDROM_MSF: all audio-related requests.
1522 However, a low-level implementation is allowed to refuse this
1523 request, and return information in its own favorite format.
1525 It doesn't make sense /at all/ to ask for a play_audio in LBA
1526 format, or ask for multi-session info in MSF format. However, for
1527 backward compatibility these format requests will be satisfied, but
1528 the requests to the low-level drivers will be sanitized in the more
1529 meaningful format indicated above.
1533 void sanitize_format(union cdrom_addr *addr,
1534 u_char * curr, u_char requested)
1536 if (*curr == requested)
1537 return; /* nothing to be done! */
1538 if (requested == CDROM_LBA) {
1539 addr->lba = (int) addr->msf.frame +
1540 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1541 } else { /* CDROM_MSF */
1542 int lba = addr->lba;
1543 addr->msf.frame = lba % 75;
1546 addr->msf.second = lba % 60;
1547 addr->msf.minute = lba / 60;
1552 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1555 memset(cgc, 0, sizeof(struct packet_command));
1557 memset(buf, 0, len);
1558 cgc->buffer = (char *) buf;
1560 cgc->data_direction = type;
1561 cgc->timeout = CDROM_DEF_TIMEOUT;
1563 EXPORT_SYMBOL(init_cdrom_command);
1567 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1568 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1570 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1572 cgc->cmd[0] = GPCMD_REPORT_KEY;
1573 cgc->cmd[10] = type | (agid << 6);
1575 case 0: case 8: case 5: {
1588 cgc->cmd[9] = cgc->buflen;
1589 cgc->data_direction = CGC_DATA_READ;
1592 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1594 cgc->cmd[0] = GPCMD_SEND_KEY;
1595 cgc->cmd[10] = type | (agid << 6);
1610 cgc->cmd[9] = cgc->buflen;
1611 cgc->data_direction = CGC_DATA_WRITE;
1614 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1618 struct packet_command cgc;
1619 const struct cdrom_device_ops *cdo = cdi->ops;
1620 rpc_state_t rpc_state;
1622 memset(buf, 0, sizeof(buf));
1623 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1627 case DVD_LU_SEND_AGID:
1628 cd_dbg(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1630 setup_report_key(&cgc, ai->lsa.agid, 0);
1632 if ((ret = cdo->generic_packet(cdi, &cgc)))
1635 ai->lsa.agid = buf[7] >> 6;
1636 /* Returning data, let host change state */
1639 case DVD_LU_SEND_KEY1:
1640 cd_dbg(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1641 setup_report_key(&cgc, ai->lsk.agid, 2);
1643 if ((ret = cdo->generic_packet(cdi, &cgc)))
1646 copy_key(ai->lsk.key, &buf[4]);
1647 /* Returning data, let host change state */
1650 case DVD_LU_SEND_CHALLENGE:
1651 cd_dbg(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1652 setup_report_key(&cgc, ai->lsc.agid, 1);
1654 if ((ret = cdo->generic_packet(cdi, &cgc)))
1657 copy_chal(ai->lsc.chal, &buf[4]);
1658 /* Returning data, let host change state */
1662 case DVD_LU_SEND_TITLE_KEY:
1663 cd_dbg(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1665 setup_report_key(&cgc, ai->lstk.agid, 4);
1666 cgc.cmd[5] = ai->lstk.lba;
1667 cgc.cmd[4] = ai->lstk.lba >> 8;
1668 cgc.cmd[3] = ai->lstk.lba >> 16;
1669 cgc.cmd[2] = ai->lstk.lba >> 24;
1671 if ((ret = cdo->generic_packet(cdi, &cgc)))
1674 ai->lstk.cpm = (buf[4] >> 7) & 1;
1675 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1676 ai->lstk.cgms = (buf[4] >> 4) & 3;
1677 copy_key(ai->lstk.title_key, &buf[5]);
1678 /* Returning data, let host change state */
1681 case DVD_LU_SEND_ASF:
1682 cd_dbg(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1683 setup_report_key(&cgc, ai->lsasf.agid, 5);
1685 if ((ret = cdo->generic_packet(cdi, &cgc)))
1688 ai->lsasf.asf = buf[7] & 1;
1691 /* LU data receive (LU changes state) */
1692 case DVD_HOST_SEND_CHALLENGE:
1693 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1694 setup_send_key(&cgc, ai->hsc.agid, 1);
1696 copy_chal(&buf[4], ai->hsc.chal);
1698 if ((ret = cdo->generic_packet(cdi, &cgc)))
1701 ai->type = DVD_LU_SEND_KEY1;
1704 case DVD_HOST_SEND_KEY2:
1705 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1706 setup_send_key(&cgc, ai->hsk.agid, 3);
1708 copy_key(&buf[4], ai->hsk.key);
1710 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1711 ai->type = DVD_AUTH_FAILURE;
1714 ai->type = DVD_AUTH_ESTABLISHED;
1718 case DVD_INVALIDATE_AGID:
1720 cd_dbg(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1721 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1722 if ((ret = cdo->generic_packet(cdi, &cgc)))
1726 /* Get region settings */
1727 case DVD_LU_SEND_RPC_STATE:
1728 cd_dbg(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1729 setup_report_key(&cgc, 0, 8);
1730 memset(&rpc_state, 0, sizeof(rpc_state_t));
1731 cgc.buffer = (char *) &rpc_state;
1733 if ((ret = cdo->generic_packet(cdi, &cgc)))
1736 ai->lrpcs.type = rpc_state.type_code;
1737 ai->lrpcs.vra = rpc_state.vra;
1738 ai->lrpcs.ucca = rpc_state.ucca;
1739 ai->lrpcs.region_mask = rpc_state.region_mask;
1740 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1743 /* Set region settings */
1744 case DVD_HOST_SEND_RPC_STATE:
1745 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1746 setup_send_key(&cgc, 0, 6);
1748 buf[4] = ai->hrpcs.pdrc;
1750 if ((ret = cdo->generic_packet(cdi, &cgc)))
1755 cd_dbg(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1762 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s,
1763 struct packet_command *cgc)
1765 unsigned char buf[21], *base;
1766 struct dvd_layer *layer;
1767 const struct cdrom_device_ops *cdo = cdi->ops;
1768 int ret, layer_num = s->physical.layer_num;
1770 if (layer_num >= DVD_LAYERS)
1773 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1774 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1775 cgc->cmd[6] = layer_num;
1776 cgc->cmd[7] = s->type;
1777 cgc->cmd[9] = cgc->buflen & 0xff;
1780 * refrain from reporting errors on non-existing layers (mainly)
1784 ret = cdo->generic_packet(cdi, cgc);
1789 layer = &s->physical.layer[layer_num];
1792 * place the data... really ugly, but at least we won't have to
1793 * worry about endianess in userspace.
1795 memset(layer, 0, sizeof(*layer));
1796 layer->book_version = base[0] & 0xf;
1797 layer->book_type = base[0] >> 4;
1798 layer->min_rate = base[1] & 0xf;
1799 layer->disc_size = base[1] >> 4;
1800 layer->layer_type = base[2] & 0xf;
1801 layer->track_path = (base[2] >> 4) & 1;
1802 layer->nlayers = (base[2] >> 5) & 3;
1803 layer->track_density = base[3] & 0xf;
1804 layer->linear_density = base[3] >> 4;
1805 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1806 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1807 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1808 layer->bca = base[16] >> 7;
1813 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s,
1814 struct packet_command *cgc)
1818 const struct cdrom_device_ops *cdo = cdi->ops;
1820 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1821 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1822 cgc->cmd[6] = s->copyright.layer_num;
1823 cgc->cmd[7] = s->type;
1824 cgc->cmd[8] = cgc->buflen >> 8;
1825 cgc->cmd[9] = cgc->buflen & 0xff;
1827 ret = cdo->generic_packet(cdi, cgc);
1831 s->copyright.cpst = buf[4];
1832 s->copyright.rmi = buf[5];
1837 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s,
1838 struct packet_command *cgc)
1842 const struct cdrom_device_ops *cdo = cdi->ops;
1844 size = sizeof(s->disckey.value) + 4;
1846 buf = kmalloc(size, GFP_KERNEL);
1850 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1851 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1852 cgc->cmd[7] = s->type;
1853 cgc->cmd[8] = size >> 8;
1854 cgc->cmd[9] = size & 0xff;
1855 cgc->cmd[10] = s->disckey.agid << 6;
1857 ret = cdo->generic_packet(cdi, cgc);
1859 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1865 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1866 struct packet_command *cgc)
1868 int ret, size = 4 + 188;
1870 const struct cdrom_device_ops *cdo = cdi->ops;
1872 buf = kmalloc(size, GFP_KERNEL);
1876 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1877 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1878 cgc->cmd[7] = s->type;
1879 cgc->cmd[9] = cgc->buflen & 0xff;
1881 ret = cdo->generic_packet(cdi, cgc);
1885 s->bca.len = buf[0] << 8 | buf[1];
1886 if (s->bca.len < 12 || s->bca.len > 188) {
1887 cd_dbg(CD_WARNING, "Received invalid BCA length (%d)\n",
1892 memcpy(s->bca.value, &buf[4], s->bca.len);
1899 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1900 struct packet_command *cgc)
1904 const struct cdrom_device_ops *cdo = cdi->ops;
1906 size = sizeof(s->manufact.value) + 4;
1908 buf = kmalloc(size, GFP_KERNEL);
1912 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1913 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1914 cgc->cmd[7] = s->type;
1915 cgc->cmd[8] = size >> 8;
1916 cgc->cmd[9] = size & 0xff;
1918 ret = cdo->generic_packet(cdi, cgc);
1922 s->manufact.len = buf[0] << 8 | buf[1];
1923 if (s->manufact.len < 0) {
1924 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d)\n",
1928 if (s->manufact.len > 2048) {
1929 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d): truncating to 2048\n",
1931 s->manufact.len = 2048;
1933 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1941 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1942 struct packet_command *cgc)
1945 case DVD_STRUCT_PHYSICAL:
1946 return dvd_read_physical(cdi, s, cgc);
1948 case DVD_STRUCT_COPYRIGHT:
1949 return dvd_read_copyright(cdi, s, cgc);
1951 case DVD_STRUCT_DISCKEY:
1952 return dvd_read_disckey(cdi, s, cgc);
1954 case DVD_STRUCT_BCA:
1955 return dvd_read_bca(cdi, s, cgc);
1957 case DVD_STRUCT_MANUFACT:
1958 return dvd_read_manufact(cdi, s, cgc);
1961 cd_dbg(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1967 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1968 struct packet_command *cgc,
1969 int page_code, int page_control)
1971 const struct cdrom_device_ops *cdo = cdi->ops;
1973 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1975 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1976 cgc->cmd[2] = page_code | (page_control << 6);
1977 cgc->cmd[7] = cgc->buflen >> 8;
1978 cgc->cmd[8] = cgc->buflen & 0xff;
1979 cgc->data_direction = CGC_DATA_READ;
1980 return cdo->generic_packet(cdi, cgc);
1982 EXPORT_SYMBOL(cdrom_mode_sense);
1984 int cdrom_mode_select(struct cdrom_device_info *cdi,
1985 struct packet_command *cgc)
1987 const struct cdrom_device_ops *cdo = cdi->ops;
1989 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1990 memset(cgc->buffer, 0, 2);
1991 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1992 cgc->cmd[1] = 0x10; /* PF */
1993 cgc->cmd[7] = cgc->buflen >> 8;
1994 cgc->cmd[8] = cgc->buflen & 0xff;
1995 cgc->data_direction = CGC_DATA_WRITE;
1996 return cdo->generic_packet(cdi, cgc);
1998 EXPORT_SYMBOL(cdrom_mode_select);
2000 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
2001 struct cdrom_subchnl *subchnl, int mcn)
2003 const struct cdrom_device_ops *cdo = cdi->ops;
2004 struct packet_command cgc;
2008 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
2009 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
2010 cgc.cmd[1] = subchnl->cdsc_format;/* MSF or LBA addressing */
2011 cgc.cmd[2] = 0x40; /* request subQ data */
2012 cgc.cmd[3] = mcn ? 2 : 1;
2015 if ((ret = cdo->generic_packet(cdi, &cgc)))
2018 subchnl->cdsc_audiostatus = cgc.buffer[1];
2019 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
2020 subchnl->cdsc_trk = cgc.buffer[6];
2021 subchnl->cdsc_ind = cgc.buffer[7];
2023 if (subchnl->cdsc_format == CDROM_LBA) {
2024 subchnl->cdsc_absaddr.lba = ((cgc.buffer[8] << 24) |
2025 (cgc.buffer[9] << 16) |
2026 (cgc.buffer[10] << 8) |
2028 subchnl->cdsc_reladdr.lba = ((cgc.buffer[12] << 24) |
2029 (cgc.buffer[13] << 16) |
2030 (cgc.buffer[14] << 8) |
2033 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
2034 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
2035 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
2036 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
2037 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
2038 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
2045 * Specific READ_10 interface
2047 static int cdrom_read_cd(struct cdrom_device_info *cdi,
2048 struct packet_command *cgc, int lba,
2049 int blocksize, int nblocks)
2051 const struct cdrom_device_ops *cdo = cdi->ops;
2053 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2054 cgc->cmd[0] = GPCMD_READ_10;
2055 cgc->cmd[2] = (lba >> 24) & 0xff;
2056 cgc->cmd[3] = (lba >> 16) & 0xff;
2057 cgc->cmd[4] = (lba >> 8) & 0xff;
2058 cgc->cmd[5] = lba & 0xff;
2059 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2060 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2061 cgc->cmd[8] = nblocks & 0xff;
2062 cgc->buflen = blocksize * nblocks;
2063 return cdo->generic_packet(cdi, cgc);
2066 /* very generic interface for reading the various types of blocks */
2067 static int cdrom_read_block(struct cdrom_device_info *cdi,
2068 struct packet_command *cgc,
2069 int lba, int nblocks, int format, int blksize)
2071 const struct cdrom_device_ops *cdo = cdi->ops;
2073 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2074 cgc->cmd[0] = GPCMD_READ_CD;
2075 /* expected sector size - cdda,mode1,etc. */
2076 cgc->cmd[1] = format << 2;
2077 /* starting address */
2078 cgc->cmd[2] = (lba >> 24) & 0xff;
2079 cgc->cmd[3] = (lba >> 16) & 0xff;
2080 cgc->cmd[4] = (lba >> 8) & 0xff;
2081 cgc->cmd[5] = lba & 0xff;
2082 /* number of blocks */
2083 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2084 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2085 cgc->cmd[8] = nblocks & 0xff;
2086 cgc->buflen = blksize * nblocks;
2088 /* set the header info returned */
2090 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
2091 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
2092 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
2093 default : cgc->cmd[9] = 0x10;
2096 return cdo->generic_packet(cdi, cgc);
2099 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2100 int lba, int nframes)
2102 struct packet_command cgc;
2106 cdi->last_sense = 0;
2108 memset(&cgc, 0, sizeof(cgc));
2111 * start with will ra.nframes size, back down if alloc fails
2115 cgc.buffer = kmalloc_array(nr, CD_FRAMESIZE_RAW, GFP_KERNEL);
2125 cgc.data_direction = CGC_DATA_READ;
2126 while (nframes > 0) {
2130 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2133 if (copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2137 ubuf += CD_FRAMESIZE_RAW * nr;
2145 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2146 int lba, int nframes)
2148 int max_frames = (queue_max_sectors(cdi->disk->queue) << 9) /
2152 cdi->last_sense = 0;
2155 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2158 nr = min(nframes, max_frames);
2160 ret = cdi->ops->read_cdda_bpc(cdi, ubuf, lba, nr,
2167 ubuf += (nr * CD_FRAMESIZE_RAW);
2173 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2174 int lba, int nframes)
2178 if (cdi->cdda_method == CDDA_OLD)
2179 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2183 * for anything else than success and io error, we need to retry
2185 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2186 if (!ret || ret != -EIO)
2190 * I've seen drives get sense 4/8/3 udma crc errors on multi
2191 * frame dma, so drop to single frame dma if we need to
2193 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2194 pr_info("dropping to single frame dma\n");
2195 cdi->cdda_method = CDDA_BPC_SINGLE;
2200 * so we have an io error of some sort with multi frame dma. if the
2201 * condition wasn't a hardware error
2202 * problems, not for any error
2204 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2207 pr_info("dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2208 cdi->cdda_method = CDDA_OLD;
2209 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2212 int cdrom_multisession(struct cdrom_device_info *cdi,
2213 struct cdrom_multisession *info)
2215 u8 requested_format;
2218 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2221 requested_format = info->addr_format;
2222 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2224 info->addr_format = CDROM_LBA;
2226 ret = cdi->ops->get_last_session(cdi, info);
2228 sanitize_format(&info->addr, &info->addr_format,
2232 EXPORT_SYMBOL_GPL(cdrom_multisession);
2234 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2237 struct cdrom_multisession info;
2240 cd_dbg(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2242 if (copy_from_user(&info, argp, sizeof(info)))
2244 ret = cdrom_multisession(cdi, &info);
2247 if (copy_to_user(argp, &info, sizeof(info)))
2250 cd_dbg(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2254 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2256 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT\n");
2258 if (!CDROM_CAN(CDC_OPEN_TRAY))
2260 if (cdi->use_count != 1 || cdi->keeplocked)
2262 if (CDROM_CAN(CDC_LOCK)) {
2263 int ret = cdi->ops->lock_door(cdi, 0);
2268 return cdi->ops->tray_move(cdi, 1);
2271 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2273 cd_dbg(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2275 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2277 return cdi->ops->tray_move(cdi, 0);
2280 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2283 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2285 if (!CDROM_CAN(CDC_OPEN_TRAY))
2287 if (cdi->keeplocked)
2290 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2292 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2296 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2299 struct cdrom_changer_info *info;
2302 cd_dbg(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2304 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2307 /* cannot select disc or select current disc */
2308 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2309 return media_changed(cdi, 1);
2311 if (arg >= cdi->capacity)
2314 info = kmalloc(sizeof(*info), GFP_KERNEL);
2318 ret = cdrom_read_mech_status(cdi, info);
2320 ret = info->slots[arg].change;
2326 * Media change detection with timing information.
2328 * arg is a pointer to a cdrom_timed_media_change_info struct.
2329 * arg->last_media_change may be set by calling code to signal
2330 * the timestamp (in ms) of the last known media change (by the caller).
2331 * Upon successful return, ioctl call will set arg->last_media_change
2332 * to the latest media change timestamp known by the kernel/driver
2333 * and set arg->has_changed to 1 if that timestamp is more recent
2334 * than the timestamp set by the caller.
2336 static int cdrom_ioctl_timed_media_change(struct cdrom_device_info *cdi,
2340 struct cdrom_timed_media_change_info __user *info;
2341 struct cdrom_timed_media_change_info tmp_info;
2343 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2346 info = (struct cdrom_timed_media_change_info __user *)arg;
2347 cd_dbg(CD_DO_IOCTL, "entering CDROM_TIMED_MEDIA_CHANGE\n");
2349 ret = cdrom_ioctl_media_changed(cdi, CDSL_CURRENT);
2353 if (copy_from_user(&tmp_info, info, sizeof(tmp_info)) != 0)
2356 tmp_info.media_flags = 0;
2357 if (tmp_info.last_media_change - cdi->last_media_change_ms < 0)
2358 tmp_info.media_flags |= MEDIA_CHANGED_FLAG;
2360 tmp_info.last_media_change = cdi->last_media_change_ms;
2362 if (copy_to_user(info, &tmp_info, sizeof(*info)) != 0)
2368 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2371 cd_dbg(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2374 * Options need to be in sync with capability.
2375 * Too late for that, so we have to check each one separately.
2378 case CDO_USE_FFLAGS:
2379 case CDO_CHECK_TYPE:
2382 if (!CDROM_CAN(CDC_LOCK))
2386 return cdi->options;
2387 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2389 if (!CDROM_CAN(arg))
2392 cdi->options |= (int) arg;
2393 return cdi->options;
2396 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2399 cd_dbg(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2401 cdi->options &= ~(int) arg;
2402 return cdi->options;
2405 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2408 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2410 if (!CDROM_CAN(CDC_SELECT_SPEED))
2412 return cdi->ops->select_speed(cdi, arg);
2415 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2418 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2420 if (!CDROM_CAN(CDC_SELECT_DISC))
2423 if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2424 if (arg >= cdi->capacity)
2428 cd_dbg(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2429 return cdrom_select_disc(cdi, arg);
2432 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2433 struct block_device *bdev)
2435 cd_dbg(CD_DO_IOCTL, "entering CDROM_RESET\n");
2437 if (!capable(CAP_SYS_ADMIN))
2439 if (!CDROM_CAN(CDC_RESET))
2441 invalidate_bdev(bdev);
2442 return cdi->ops->reset(cdi);
2445 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2448 cd_dbg(CD_DO_IOCTL, "%socking door\n", arg ? "L" : "Unl");
2450 if (!CDROM_CAN(CDC_LOCK))
2451 return -EDRIVE_CANT_DO_THIS;
2453 cdi->keeplocked = arg ? 1 : 0;
2456 * Don't unlock the door on multiple opens by default, but allow
2459 if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2461 return cdi->ops->lock_door(cdi, arg);
2464 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2467 cd_dbg(CD_DO_IOCTL, "%sabling debug\n", arg ? "En" : "Dis");
2469 if (!capable(CAP_SYS_ADMIN))
2471 debug = arg ? 1 : 0;
2475 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2477 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2478 return (cdi->ops->capability & ~cdi->mask);
2482 * The following function is implemented, although very few audio
2483 * discs give Universal Product Code information, which should just be
2484 * the Medium Catalog Number on the box. Note, that the way the code
2485 * is written on the CD is /not/ uniform across all discs!
2487 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2490 struct cdrom_mcn mcn;
2493 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2495 if (!(cdi->ops->capability & CDC_MCN))
2497 ret = cdi->ops->get_mcn(cdi, &mcn);
2501 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2503 cd_dbg(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2507 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2510 cd_dbg(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2512 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2514 if (!CDROM_CAN(CDC_SELECT_DISC) ||
2515 (arg == CDSL_CURRENT || arg == CDSL_NONE))
2516 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2517 if (arg >= cdi->capacity)
2519 return cdrom_slot_status(cdi, arg);
2523 * Ok, this is where problems start. The current interface for the
2524 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2525 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunately, while this
2526 * is often the case, it is also very common for CDs to have some tracks
2527 * with data, and some tracks with audio. Just because I feel like it,
2528 * I declare the following to be the best way to cope. If the CD has ANY
2529 * data tracks on it, it will be returned as a data CD. If it has any XA
2530 * tracks, I will return it as that. Now I could simplify this interface
2531 * by combining these returns with the above, but this more clearly
2532 * demonstrates the problem with the current interface. Too bad this
2533 * wasn't designed to use bitmasks... -Erik
2535 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2536 * User level programmers might feel the ioctl is not very useful.
2539 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2543 cd_dbg(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2545 cdrom_count_tracks(cdi, &tracks);
2547 return tracks.error;
2549 /* Policy mode on */
2550 if (tracks.audio > 0) {
2551 if (!tracks.data && !tracks.cdi && !tracks.xa)
2561 if (tracks.data > 0)
2563 /* Policy mode off */
2565 cd_dbg(CD_WARNING, "This disc doesn't have any tracks I recognize!\n");
2569 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2571 cd_dbg(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2572 return cdi->capacity;
2575 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2578 struct cdrom_subchnl q;
2582 /* cd_dbg(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2584 if (copy_from_user(&q, argp, sizeof(q)))
2587 requested = q.cdsc_format;
2588 if (requested != CDROM_MSF && requested != CDROM_LBA)
2590 q.cdsc_format = CDROM_MSF;
2592 ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2596 back = q.cdsc_format; /* local copy */
2597 sanitize_format(&q.cdsc_absaddr, &back, requested);
2598 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2600 if (copy_to_user(argp, &q, sizeof(q)))
2602 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2606 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2609 struct cdrom_tochdr header;
2612 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2614 if (copy_from_user(&header, argp, sizeof(header)))
2617 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2621 if (copy_to_user(argp, &header, sizeof(header)))
2623 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2627 int cdrom_read_tocentry(struct cdrom_device_info *cdi,
2628 struct cdrom_tocentry *entry)
2630 u8 requested_format = entry->cdte_format;
2633 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2636 /* make interface to low-level uniform */
2637 entry->cdte_format = CDROM_MSF;
2638 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, entry);
2640 sanitize_format(&entry->cdte_addr, &entry->cdte_format,
2644 EXPORT_SYMBOL_GPL(cdrom_read_tocentry);
2646 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2649 struct cdrom_tocentry entry;
2652 if (copy_from_user(&entry, argp, sizeof(entry)))
2654 ret = cdrom_read_tocentry(cdi, &entry);
2655 if (!ret && copy_to_user(argp, &entry, sizeof(entry)))
2660 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2663 struct cdrom_msf msf;
2665 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2667 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2669 if (copy_from_user(&msf, argp, sizeof(msf)))
2671 return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2674 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2680 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2682 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2684 if (copy_from_user(&ti, argp, sizeof(ti)))
2687 ret = check_for_audio_disc(cdi, cdi->ops);
2690 return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2692 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2695 struct cdrom_volctrl volume;
2697 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2699 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2701 if (copy_from_user(&volume, argp, sizeof(volume)))
2703 return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2706 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2709 struct cdrom_volctrl volume;
2712 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2714 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2717 ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2721 if (copy_to_user(argp, &volume, sizeof(volume)))
2726 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2731 cd_dbg(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2733 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2735 ret = check_for_audio_disc(cdi, cdi->ops);
2738 return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2742 * Required when we need to use READ_10 to issue other than 2048 block
2745 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2747 const struct cdrom_device_ops *cdo = cdi->ops;
2748 struct packet_command cgc;
2749 struct modesel_head mh;
2751 memset(&mh, 0, sizeof(mh));
2752 mh.block_desc_length = 0x08;
2753 mh.block_length_med = (size >> 8) & 0xff;
2754 mh.block_length_lo = size & 0xff;
2756 memset(&cgc, 0, sizeof(cgc));
2758 cgc.cmd[1] = 1 << 4;
2760 cgc.buflen = sizeof(mh);
2761 cgc.buffer = (char *) &mh;
2762 cgc.data_direction = CGC_DATA_WRITE;
2763 mh.block_desc_length = 0x08;
2764 mh.block_length_med = (size >> 8) & 0xff;
2765 mh.block_length_lo = size & 0xff;
2767 return cdo->generic_packet(cdi, &cgc);
2770 static int cdrom_get_track_info(struct cdrom_device_info *cdi,
2771 __u16 track, __u8 type, track_information *ti)
2773 const struct cdrom_device_ops *cdo = cdi->ops;
2774 struct packet_command cgc;
2777 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
2778 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
2779 cgc.cmd[1] = type & 3;
2780 cgc.cmd[4] = (track & 0xff00) >> 8;
2781 cgc.cmd[5] = track & 0xff;
2785 ret = cdo->generic_packet(cdi, &cgc);
2789 buflen = be16_to_cpu(ti->track_information_length) +
2790 sizeof(ti->track_information_length);
2792 if (buflen > sizeof(track_information))
2793 buflen = sizeof(track_information);
2795 cgc.cmd[8] = cgc.buflen = buflen;
2796 ret = cdo->generic_packet(cdi, &cgc);
2800 /* return actual fill size */
2804 /* return the last written block on the CD-R media. this is for the udf
2806 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
2808 struct cdrom_tocentry toc;
2809 disc_information di;
2810 track_information ti;
2812 int ret = -1, ti_size;
2814 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2817 ret = cdrom_get_disc_info(cdi, &di);
2818 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
2819 + sizeof(di.last_track_lsb)))
2822 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2823 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2824 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2825 if (ti_size < (int)offsetof(typeof(ti), track_start))
2828 /* if this track is blank, try the previous. */
2830 if (last_track == 1)
2833 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2836 if (ti_size < (int)(offsetof(typeof(ti), track_size)
2837 + sizeof(ti.track_size)))
2840 /* if last recorded field is valid, return it. */
2841 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
2842 + sizeof(ti.last_rec_address))) {
2843 *last_written = be32_to_cpu(ti.last_rec_address);
2845 /* make it up instead */
2846 *last_written = be32_to_cpu(ti.track_start) +
2847 be32_to_cpu(ti.track_size);
2849 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
2853 /* this is where we end up if the drive either can't do a
2854 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
2855 it doesn't give enough information or fails. then we return
2856 the toc contents. */
2858 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2861 toc.cdte_format = CDROM_MSF;
2862 toc.cdte_track = CDROM_LEADOUT;
2863 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
2865 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
2866 *last_written = toc.cdte_addr.lba;
2869 EXPORT_SYMBOL(cdrom_get_last_written);
2871 /* return the next writable block. also for udf file system. */
2872 static int cdrom_get_next_writable(struct cdrom_device_info *cdi,
2873 long *next_writable)
2875 disc_information di;
2876 track_information ti;
2880 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2881 goto use_last_written;
2883 ret = cdrom_get_disc_info(cdi, &di);
2884 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
2885 + sizeof(di.last_track_lsb))
2886 goto use_last_written;
2888 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2889 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2890 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2891 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
2892 goto use_last_written;
2894 /* if this track is blank, try the previous. */
2896 if (last_track == 1)
2897 goto use_last_written;
2899 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2901 goto use_last_written;
2904 /* if next recordable address field is valid, use it. */
2905 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
2906 + sizeof(ti.next_writable)) {
2907 *next_writable = be32_to_cpu(ti.next_writable);
2912 ret = cdrom_get_last_written(cdi, next_writable);
2917 *next_writable += 7;
2922 static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2924 struct packet_command *cgc,
2927 struct scsi_sense_hdr sshdr;
2928 struct cdrom_msf msf;
2929 int blocksize = 0, format = 0, lba;
2934 blocksize = CD_FRAMESIZE_RAW;
2936 case CDROMREADMODE1:
2937 blocksize = CD_FRAMESIZE;
2940 case CDROMREADMODE2:
2941 blocksize = CD_FRAMESIZE_RAW0;
2944 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
2946 lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2947 /* FIXME: we need upper bound checking, too!! */
2951 cgc->buffer = kzalloc(blocksize, GFP_KERNEL);
2952 if (cgc->buffer == NULL)
2955 memset(&sshdr, 0, sizeof(sshdr));
2956 cgc->sshdr = &sshdr;
2957 cgc->data_direction = CGC_DATA_READ;
2958 ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
2959 if (ret && sshdr.sense_key == 0x05 &&
2960 sshdr.asc == 0x20 &&
2961 sshdr.ascq == 0x00) {
2963 * SCSI-II devices are not required to support
2964 * READ_CD, so let's try switching block size
2966 if (blocksize != CD_FRAMESIZE) {
2967 ret = cdrom_switch_blocksize(cdi, blocksize);
2972 ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
2973 if (blocksize != CD_FRAMESIZE)
2974 ret |= cdrom_switch_blocksize(cdi, CD_FRAMESIZE);
2976 if (!ret && copy_to_user(arg, cgc->buffer, blocksize))
2983 static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
2986 struct cdrom_read_audio ra;
2989 #ifdef CONFIG_COMPAT
2990 if (in_compat_syscall()) {
2991 struct compat_cdrom_read_audio {
2992 union cdrom_addr addr;
2994 compat_int_t nframes;
2998 if (copy_from_user(&ra32, arg, sizeof(ra32)))
3001 ra = (struct cdrom_read_audio) {
3003 .addr_format = ra32.addr_format,
3004 .nframes = ra32.nframes,
3005 .buf = compat_ptr(ra32.buf),
3010 if (copy_from_user(&ra, (struct cdrom_read_audio __user *)arg,
3015 if (ra.addr_format == CDROM_MSF)
3016 lba = msf_to_lba(ra.addr.msf.minute,
3019 else if (ra.addr_format == CDROM_LBA)
3024 /* FIXME: we need upper bound checking, too!! */
3025 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
3028 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
3031 static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
3035 struct cdrom_subchnl q;
3036 u_char requested, back;
3037 if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q)))
3039 requested = q.cdsc_format;
3040 if (!((requested == CDROM_MSF) ||
3041 (requested == CDROM_LBA)))
3044 ret = cdrom_read_subchannel(cdi, &q, 0);
3047 back = q.cdsc_format; /* local copy */
3048 sanitize_format(&q.cdsc_absaddr, &back, requested);
3049 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
3050 if (copy_to_user((struct cdrom_subchnl __user *)arg, &q, sizeof(q)))
3052 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
3056 static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
3058 struct packet_command *cgc)
3060 const struct cdrom_device_ops *cdo = cdi->ops;
3061 struct cdrom_msf msf;
3062 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
3063 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
3065 cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
3066 cgc->cmd[3] = msf.cdmsf_min0;
3067 cgc->cmd[4] = msf.cdmsf_sec0;
3068 cgc->cmd[5] = msf.cdmsf_frame0;
3069 cgc->cmd[6] = msf.cdmsf_min1;
3070 cgc->cmd[7] = msf.cdmsf_sec1;
3071 cgc->cmd[8] = msf.cdmsf_frame1;
3072 cgc->data_direction = CGC_DATA_NONE;
3073 return cdo->generic_packet(cdi, cgc);
3076 static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
3078 struct packet_command *cgc)
3080 const struct cdrom_device_ops *cdo = cdi->ops;
3081 struct cdrom_blk blk;
3082 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
3083 if (copy_from_user(&blk, (struct cdrom_blk __user *)arg, sizeof(blk)))
3085 cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
3086 cgc->cmd[2] = (blk.from >> 24) & 0xff;
3087 cgc->cmd[3] = (blk.from >> 16) & 0xff;
3088 cgc->cmd[4] = (blk.from >> 8) & 0xff;
3089 cgc->cmd[5] = blk.from & 0xff;
3090 cgc->cmd[7] = (blk.len >> 8) & 0xff;
3091 cgc->cmd[8] = blk.len & 0xff;
3092 cgc->data_direction = CGC_DATA_NONE;
3093 return cdo->generic_packet(cdi, cgc);
3096 static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3098 struct packet_command *cgc,
3101 struct cdrom_volctrl volctrl;
3102 unsigned char buffer[32];
3103 char mask[sizeof(buffer)];
3104 unsigned short offset;
3107 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3109 if (copy_from_user(&volctrl, (struct cdrom_volctrl __user *)arg,
3113 cgc->buffer = buffer;
3115 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 0);
3119 /* originally the code depended on buffer[1] to determine
3120 how much data is available for transfer. buffer[1] is
3121 unfortunately ambigious and the only reliable way seem
3122 to be to simply skip over the block descriptor... */
3123 offset = 8 + be16_to_cpu(*(__be16 *)(buffer + 6));
3125 if (offset + 16 > sizeof(buffer))
3128 if (offset + 16 > cgc->buflen) {
3129 cgc->buflen = offset + 16;
3130 ret = cdrom_mode_sense(cdi, cgc,
3131 GPMODE_AUDIO_CTL_PAGE, 0);
3137 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3138 buffer[offset + 1] < 14)
3141 /* now we have the current volume settings. if it was only
3142 a CDROMVOLREAD, return these values */
3143 if (cmd == CDROMVOLREAD) {
3144 volctrl.channel0 = buffer[offset+9];
3145 volctrl.channel1 = buffer[offset+11];
3146 volctrl.channel2 = buffer[offset+13];
3147 volctrl.channel3 = buffer[offset+15];
3148 if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl,
3154 /* get the volume mask */
3156 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 1);
3160 buffer[offset + 9] = volctrl.channel0 & mask[offset + 9];
3161 buffer[offset + 11] = volctrl.channel1 & mask[offset + 11];
3162 buffer[offset + 13] = volctrl.channel2 & mask[offset + 13];
3163 buffer[offset + 15] = volctrl.channel3 & mask[offset + 15];
3166 cgc->buffer = buffer + offset - 8;
3167 memset(cgc->buffer, 0, 8);
3168 return cdrom_mode_select(cdi, cgc);
3171 static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3172 struct packet_command *cgc,
3175 const struct cdrom_device_ops *cdo = cdi->ops;
3176 cd_dbg(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3177 cgc->cmd[0] = GPCMD_START_STOP_UNIT;
3179 cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3180 cgc->data_direction = CGC_DATA_NONE;
3181 return cdo->generic_packet(cdi, cgc);
3184 static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3185 struct packet_command *cgc,
3188 const struct cdrom_device_ops *cdo = cdi->ops;
3189 cd_dbg(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3190 cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3191 cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3192 cgc->data_direction = CGC_DATA_NONE;
3193 return cdo->generic_packet(cdi, cgc);
3196 static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3198 struct packet_command *cgc)
3202 int size = sizeof(dvd_struct);
3204 if (!CDROM_CAN(CDC_DVD))
3207 s = memdup_user(arg, size);
3211 cd_dbg(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3213 ret = dvd_read_struct(cdi, s, cgc);
3217 if (copy_to_user(arg, s, size))
3224 static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3229 if (!CDROM_CAN(CDC_DVD))
3231 cd_dbg(CD_DO_IOCTL, "entering DVD_AUTH\n");
3232 if (copy_from_user(&ai, (dvd_authinfo __user *)arg, sizeof(ai)))
3234 ret = dvd_do_auth(cdi, &ai);
3237 if (copy_to_user((dvd_authinfo __user *)arg, &ai, sizeof(ai)))
3242 static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3247 cd_dbg(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3248 ret = cdrom_get_next_writable(cdi, &next);
3251 if (copy_to_user((long __user *)arg, &next, sizeof(next)))
3256 static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3261 cd_dbg(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3262 ret = cdrom_get_last_written(cdi, &last);
3265 if (in_compat_syscall())
3266 return put_user(last, (__s32 __user *)arg);
3268 return put_user(last, (long __user *)arg);
3271 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3274 struct packet_command cgc;
3275 void __user *userptr = (void __user *)arg;
3277 memset(&cgc, 0, sizeof(cgc));
3279 /* build a unified command and queue it through
3280 cdo->generic_packet() */
3283 case CDROMREADMODE1:
3284 case CDROMREADMODE2:
3285 return mmc_ioctl_cdrom_read_data(cdi, userptr, &cgc, cmd);
3286 case CDROMREADAUDIO:
3287 return mmc_ioctl_cdrom_read_audio(cdi, userptr);
3289 return mmc_ioctl_cdrom_subchannel(cdi, userptr);
3291 return mmc_ioctl_cdrom_play_msf(cdi, userptr, &cgc);
3293 return mmc_ioctl_cdrom_play_blk(cdi, userptr, &cgc);
3296 return mmc_ioctl_cdrom_volume(cdi, userptr, &cgc, cmd);
3299 return mmc_ioctl_cdrom_start_stop(cdi, &cgc, cmd);
3302 return mmc_ioctl_cdrom_pause_resume(cdi, &cgc, cmd);
3303 case DVD_READ_STRUCT:
3304 return mmc_ioctl_dvd_read_struct(cdi, userptr, &cgc);
3306 return mmc_ioctl_dvd_auth(cdi, userptr);
3307 case CDROM_NEXT_WRITABLE:
3308 return mmc_ioctl_cdrom_next_writable(cdi, userptr);
3309 case CDROM_LAST_WRITTEN:
3310 return mmc_ioctl_cdrom_last_written(cdi, userptr);
3317 * Just about every imaginable ioctl is supported in the Uniform layer
3319 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
3321 int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
3322 unsigned int cmd, unsigned long arg)
3324 void __user *argp = (void __user *)arg;
3328 case CDROMMULTISESSION:
3329 return cdrom_ioctl_multisession(cdi, argp);
3331 return cdrom_ioctl_eject(cdi);
3332 case CDROMCLOSETRAY:
3333 return cdrom_ioctl_closetray(cdi);
3335 return cdrom_ioctl_eject_sw(cdi, arg);
3336 case CDROM_MEDIA_CHANGED:
3337 return cdrom_ioctl_media_changed(cdi, arg);
3338 case CDROM_TIMED_MEDIA_CHANGE:
3339 return cdrom_ioctl_timed_media_change(cdi, arg);
3340 case CDROM_SET_OPTIONS:
3341 return cdrom_ioctl_set_options(cdi, arg);
3342 case CDROM_CLEAR_OPTIONS:
3343 return cdrom_ioctl_clear_options(cdi, arg);
3344 case CDROM_SELECT_SPEED:
3345 return cdrom_ioctl_select_speed(cdi, arg);
3346 case CDROM_SELECT_DISC:
3347 return cdrom_ioctl_select_disc(cdi, arg);
3349 return cdrom_ioctl_reset(cdi, bdev);
3350 case CDROM_LOCKDOOR:
3351 return cdrom_ioctl_lock_door(cdi, arg);
3353 return cdrom_ioctl_debug(cdi, arg);
3354 case CDROM_GET_CAPABILITY:
3355 return cdrom_ioctl_get_capability(cdi);
3357 return cdrom_ioctl_get_mcn(cdi, argp);
3358 case CDROM_DRIVE_STATUS:
3359 return cdrom_ioctl_drive_status(cdi, arg);
3360 case CDROM_DISC_STATUS:
3361 return cdrom_ioctl_disc_status(cdi);
3362 case CDROM_CHANGER_NSLOTS:
3363 return cdrom_ioctl_changer_nslots(cdi);
3367 * Use the ioctls that are implemented through the generic_packet()
3368 * interface. this may look at bit funny, but if -ENOTTY is
3369 * returned that particular ioctl is not implemented and we
3370 * let it go through the device specific ones.
3372 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
3373 ret = mmc_ioctl(cdi, cmd, arg);
3379 * Note: most of the cd_dbg() calls are commented out here,
3380 * because they fill up the sys log when CD players poll
3385 return cdrom_ioctl_get_subchnl(cdi, argp);
3386 case CDROMREADTOCHDR:
3387 return cdrom_ioctl_read_tochdr(cdi, argp);
3388 case CDROMREADTOCENTRY:
3389 return cdrom_ioctl_read_tocentry(cdi, argp);
3391 return cdrom_ioctl_play_msf(cdi, argp);
3392 case CDROMPLAYTRKIND:
3393 return cdrom_ioctl_play_trkind(cdi, argp);
3395 return cdrom_ioctl_volctrl(cdi, argp);
3397 return cdrom_ioctl_volread(cdi, argp);
3402 return cdrom_ioctl_audioctl(cdi, cmd);
3407 EXPORT_SYMBOL(cdrom_ioctl);
3409 #ifdef CONFIG_SYSCTL
3411 #define CDROM_STR_SIZE 1000
3413 static struct cdrom_sysctl_settings {
3414 char info[CDROM_STR_SIZE]; /* general info */
3415 int autoclose; /* close tray upon mount, etc */
3416 int autoeject; /* eject on umount */
3417 int debug; /* turn on debugging messages */
3418 int lock; /* lock the door on device open */
3419 int check; /* check media type */
3420 } cdrom_sysctl_settings;
3422 enum cdrom_print_option {
3429 static int cdrom_print_info(const char *header, int val, char *info,
3430 int *pos, enum cdrom_print_option option)
3432 const int max_size = sizeof(cdrom_sysctl_settings.info);
3433 struct cdrom_device_info *cdi;
3436 ret = scnprintf(info + *pos, max_size - *pos, header);
3442 list_for_each_entry(cdi, &cdrom_list, list) {
3445 ret = scnprintf(info + *pos, max_size - *pos,
3449 ret = scnprintf(info + *pos, max_size - *pos,
3450 "\t%d", cdi->speed);
3453 ret = scnprintf(info + *pos, max_size - *pos,
3454 "\t%d", cdi->capacity);
3456 case CTL_CAPABILITY:
3457 ret = scnprintf(info + *pos, max_size - *pos,
3458 "\t%d", CDROM_CAN(val) != 0);
3461 pr_info("invalid option%d\n", option);
3472 static int cdrom_sysctl_info(struct ctl_table *ctl, int write,
3473 void *buffer, size_t *lenp, loff_t *ppos)
3476 char *info = cdrom_sysctl_settings.info;
3477 const int max_size = sizeof(cdrom_sysctl_settings.info);
3479 if (!*lenp || (*ppos && !write)) {
3484 mutex_lock(&cdrom_mutex);
3486 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3488 if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3490 if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3492 if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3494 if (cdrom_print_info("\nCan close tray:\t",
3495 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3497 if (cdrom_print_info("\nCan open tray:\t",
3498 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3500 if (cdrom_print_info("\nCan lock tray:\t",
3501 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3503 if (cdrom_print_info("\nCan change speed:",
3504 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3506 if (cdrom_print_info("\nCan select disk:",
3507 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3509 if (cdrom_print_info("\nCan read multisession:",
3510 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3512 if (cdrom_print_info("\nCan read MCN:\t",
3513 CDC_MCN, info, &pos, CTL_CAPABILITY))
3515 if (cdrom_print_info("\nReports media changed:",
3516 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3518 if (cdrom_print_info("\nCan play audio:\t",
3519 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3521 if (cdrom_print_info("\nCan write CD-R:\t",
3522 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3524 if (cdrom_print_info("\nCan write CD-RW:",
3525 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3527 if (cdrom_print_info("\nCan read DVD:\t",
3528 CDC_DVD, info, &pos, CTL_CAPABILITY))
3530 if (cdrom_print_info("\nCan write DVD-R:",
3531 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3533 if (cdrom_print_info("\nCan write DVD-RAM:",
3534 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3536 if (cdrom_print_info("\nCan read MRW:\t",
3537 CDC_MRW, info, &pos, CTL_CAPABILITY))
3539 if (cdrom_print_info("\nCan write MRW:\t",
3540 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3542 if (cdrom_print_info("\nCan write RAM:\t",
3543 CDC_RAM, info, &pos, CTL_CAPABILITY))
3545 if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3548 mutex_unlock(&cdrom_mutex);
3549 return proc_dostring(ctl, write, buffer, lenp, ppos);
3551 pr_info("info buffer too small\n");
3555 /* Unfortunately, per device settings are not implemented through
3556 procfs/sysctl yet. When they are, this will naturally disappear. For now
3557 just update all drives. Later this will become the template on which
3558 new registered drives will be based. */
3559 static void cdrom_update_settings(void)
3561 struct cdrom_device_info *cdi;
3563 mutex_lock(&cdrom_mutex);
3564 list_for_each_entry(cdi, &cdrom_list, list) {
3565 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3566 cdi->options |= CDO_AUTO_CLOSE;
3567 else if (!autoclose)
3568 cdi->options &= ~CDO_AUTO_CLOSE;
3569 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3570 cdi->options |= CDO_AUTO_EJECT;
3571 else if (!autoeject)
3572 cdi->options &= ~CDO_AUTO_EJECT;
3573 if (lockdoor && CDROM_CAN(CDC_LOCK))
3574 cdi->options |= CDO_LOCK;
3576 cdi->options &= ~CDO_LOCK;
3577 if (check_media_type)
3578 cdi->options |= CDO_CHECK_TYPE;
3580 cdi->options &= ~CDO_CHECK_TYPE;
3582 mutex_unlock(&cdrom_mutex);
3585 static int cdrom_sysctl_handler(struct ctl_table *ctl, int write,
3586 void *buffer, size_t *lenp, loff_t *ppos)
3590 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
3594 /* we only care for 1 or 0. */
3595 autoclose = !!cdrom_sysctl_settings.autoclose;
3596 autoeject = !!cdrom_sysctl_settings.autoeject;
3597 debug = !!cdrom_sysctl_settings.debug;
3598 lockdoor = !!cdrom_sysctl_settings.lock;
3599 check_media_type = !!cdrom_sysctl_settings.check;
3601 /* update the option flags according to the changes. we
3602 don't have per device options through sysctl yet,
3603 but we will have and then this will disappear. */
3604 cdrom_update_settings();
3610 /* Place files in /proc/sys/dev/cdrom */
3611 static struct ctl_table cdrom_table[] = {
3614 .data = &cdrom_sysctl_settings.info,
3615 .maxlen = CDROM_STR_SIZE,
3617 .proc_handler = cdrom_sysctl_info,
3620 .procname = "autoclose",
3621 .data = &cdrom_sysctl_settings.autoclose,
3622 .maxlen = sizeof(int),
3624 .proc_handler = cdrom_sysctl_handler,
3627 .procname = "autoeject",
3628 .data = &cdrom_sysctl_settings.autoeject,
3629 .maxlen = sizeof(int),
3631 .proc_handler = cdrom_sysctl_handler,
3634 .procname = "debug",
3635 .data = &cdrom_sysctl_settings.debug,
3636 .maxlen = sizeof(int),
3638 .proc_handler = cdrom_sysctl_handler,
3642 .data = &cdrom_sysctl_settings.lock,
3643 .maxlen = sizeof(int),
3645 .proc_handler = cdrom_sysctl_handler,
3648 .procname = "check_media",
3649 .data = &cdrom_sysctl_settings.check,
3650 .maxlen = sizeof(int),
3652 .proc_handler = cdrom_sysctl_handler
3656 static struct ctl_table_header *cdrom_sysctl_header;
3658 static void cdrom_sysctl_register(void)
3660 static atomic_t initialized = ATOMIC_INIT(0);
3662 if (!atomic_add_unless(&initialized, 1, 1))
3665 cdrom_sysctl_header = register_sysctl("dev/cdrom", cdrom_table);
3667 /* set the defaults */
3668 cdrom_sysctl_settings.autoclose = autoclose;
3669 cdrom_sysctl_settings.autoeject = autoeject;
3670 cdrom_sysctl_settings.debug = debug;
3671 cdrom_sysctl_settings.lock = lockdoor;
3672 cdrom_sysctl_settings.check = check_media_type;
3675 static void cdrom_sysctl_unregister(void)
3677 if (cdrom_sysctl_header)
3678 unregister_sysctl_table(cdrom_sysctl_header);
3681 #else /* CONFIG_SYSCTL */
3683 static void cdrom_sysctl_register(void)
3687 static void cdrom_sysctl_unregister(void)
3691 #endif /* CONFIG_SYSCTL */
3693 static int __init cdrom_init(void)
3695 cdrom_sysctl_register();
3700 static void __exit cdrom_exit(void)
3702 pr_info("Uniform CD-ROM driver unloaded\n");
3703 cdrom_sysctl_unregister();
3706 module_init(cdrom_init);
3707 module_exit(cdrom_exit);
3708 MODULE_LICENSE("GPL");