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 ----------------------------------
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!
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 actively
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
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
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.
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
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
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.
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>.
118 2.55 Apr 25, 1999 - Jens Axboe <axboe@image.dk>
119 -- autoclose was mistakenly checked against CDC_OPEN_TRAY instead of
121 -- proc info didn't mask against capabilities mask.
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,
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.
141 3.01 Aug 6, 1999 - Jens Axboe <axboe@image.dk>
142 -- Fix up the sysctl handling so that the option flags get set
144 -- Fix up ioctl handling so the device specific ones actually get
147 3.02 Aug 8, 1999 - Jens Axboe <axboe@image.dk>
148 -- Fixed volume control on SCSI drives (or others with longer audio
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.
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 lose the index part, however.
176 -- Small modifications to accommodate opens of /dev/hdc1, required
177 for ide-cd to handle multisession discs.
178 -- Export cdrom_mode_sense and cdrom_mode_select.
179 -- init_cdrom_command() for setting up a cgc command.
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
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
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.
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
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 3.20 Dec 17, 2003 - Jens Axboe <axboe@suse.de>
232 -- Various fixes and lots of cleanups not listed :-)
234 -- Mt Rainier support
235 -- DVD-RAM write open fixes
237 Nov 5 2001, Aug 8 2002. Modified by Andy Polyakov
238 <appro@fy.chalmers.se> to support MMC-3 compliant DVD+RW units.
240 Modified by Nigel Kukard <nkukard@lbsd.net> - support DVD+RW
241 2.4.x patch by Andy Polyakov <appro@fy.chalmers.se>
243 -------------------------------------------------------------------------*/
245 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
247 #define REVISION "Revision: 3.20"
248 #define VERSION "Id: cdrom.c 3.20 2003/12/17"
250 /* I use an error-log mask to give fine grain control over the type of
251 messages dumped to the system logs. The available masks include: */
252 #define CD_NOTHING 0x0
253 #define CD_WARNING 0x1
254 #define CD_REG_UNREG 0x2
255 #define CD_DO_IOCTL 0x4
257 #define CD_CLOSE 0x10
258 #define CD_COUNT_TRACKS 0x20
259 #define CD_CHANGER 0x40
262 /* Define this to remove _all_ the debugging messages */
263 /* #define ERRLOGMASK CD_NOTHING */
264 #define ERRLOGMASK CD_WARNING
265 /* #define ERRLOGMASK (CD_WARNING|CD_OPEN|CD_COUNT_TRACKS|CD_CLOSE) */
266 /* #define ERRLOGMASK (CD_WARNING|CD_REG_UNREG|CD_DO_IOCTL|CD_OPEN|CD_CLOSE|CD_COUNT_TRACKS) */
268 #include <linux/atomic.h>
269 #include <linux/module.h>
270 #include <linux/fs.h>
271 #include <linux/major.h>
272 #include <linux/types.h>
273 #include <linux/errno.h>
274 #include <linux/kernel.h>
275 #include <linux/mm.h>
276 #include <linux/slab.h>
277 #include <linux/cdrom.h>
278 #include <linux/sysctl.h>
279 #include <linux/proc_fs.h>
280 #include <linux/blkpg.h>
281 #include <linux/init.h>
282 #include <linux/fcntl.h>
283 #include <linux/blkdev.h>
284 #include <linux/times.h>
285 #include <linux/uaccess.h>
286 #include <scsi/scsi_common.h>
288 /* used to tell the module to turn on full debugging messages */
290 /* default compatibility mode */
291 static bool autoclose=1;
292 static bool autoeject;
293 static bool lockdoor = 1;
294 /* will we ever get to use this... sigh. */
295 static bool check_media_type;
296 /* automatically restart mrw format */
297 static bool mrw_format_restart = 1;
298 module_param(debug, bool, 0);
299 module_param(autoclose, bool, 0);
300 module_param(autoeject, bool, 0);
301 module_param(lockdoor, bool, 0);
302 module_param(check_media_type, bool, 0);
303 module_param(mrw_format_restart, bool, 0);
305 static DEFINE_MUTEX(cdrom_mutex);
307 static const char *mrw_format_status[] = {
314 static const char *mrw_address_space[] = { "DMA", "GAA" };
316 #if (ERRLOGMASK != CD_NOTHING)
317 #define cd_dbg(type, fmt, ...) \
319 if ((ERRLOGMASK & type) || debug == 1) \
320 pr_debug(fmt, ##__VA_ARGS__); \
323 #define cd_dbg(type, fmt, ...) \
325 if (0 && (ERRLOGMASK & type) || debug == 1) \
326 pr_debug(fmt, ##__VA_ARGS__); \
330 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
331 a lot of places. This macro makes the code more clear. */
332 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
335 * Another popular OS uses 7 seconds as the hard timeout for default
336 * commands, so it is a good choice for us as well.
338 #define CDROM_DEF_TIMEOUT (7 * HZ)
340 /* Not-exported routines. */
342 static void cdrom_sysctl_register(void);
344 static LIST_HEAD(cdrom_list);
346 static void signal_media_change(struct cdrom_device_info *cdi)
348 cdi->mc_flags = 0x3; /* set media changed bits, on both queues */
349 cdi->last_media_change_ms = ktime_to_ms(ktime_get());
352 int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
353 struct packet_command *cgc)
356 cgc->sshdr->sense_key = 0x05;
357 cgc->sshdr->asc = 0x20;
358 cgc->sshdr->ascq = 0x00;
364 EXPORT_SYMBOL(cdrom_dummy_generic_packet);
366 static int cdrom_flush_cache(struct cdrom_device_info *cdi)
368 struct packet_command cgc;
370 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
371 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
373 cgc.timeout = 5 * 60 * HZ;
375 return cdi->ops->generic_packet(cdi, &cgc);
378 /* requires CD R/RW */
379 static int cdrom_get_disc_info(struct cdrom_device_info *cdi,
380 disc_information *di)
382 const struct cdrom_device_ops *cdo = cdi->ops;
383 struct packet_command cgc;
386 /* set up command and get the disc info */
387 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
388 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
389 cgc.cmd[8] = cgc.buflen = 2;
392 ret = cdo->generic_packet(cdi, &cgc);
396 /* not all drives have the same disc_info length, so requeue
397 * packet with the length the drive tells us it can supply
399 buflen = be16_to_cpu(di->disc_information_length) +
400 sizeof(di->disc_information_length);
402 if (buflen > sizeof(disc_information))
403 buflen = sizeof(disc_information);
405 cgc.cmd[8] = cgc.buflen = buflen;
406 ret = cdo->generic_packet(cdi, &cgc);
410 /* return actual fill size */
414 /* This macro makes sure we don't have to check on cdrom_device_ops
415 * existence in the run-time routines below. Change_capability is a
416 * hack to have the capability flags defined const, while we can still
417 * change it here without gcc complaining at every line.
419 #define ENSURE(cdo, call, bits) \
421 if (cdo->call == NULL) \
422 WARN_ON_ONCE((cdo)->capability & (bits)); \
426 * the first prototypes used 0x2c as the page code for the mrw mode page,
427 * subsequently this was changed to 0x03. probe the one used by this drive
429 static int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
431 struct packet_command cgc;
434 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
439 if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
440 cdi->mrw_mode_page = MRW_MODE_PC;
442 } else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
443 cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
450 static int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
452 struct packet_command cgc;
453 struct mrw_feature_desc *mfd;
454 unsigned char buffer[16];
459 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
461 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
462 cgc.cmd[3] = CDF_MRW;
463 cgc.cmd[8] = sizeof(buffer);
466 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
469 mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
470 if (be16_to_cpu(mfd->feature_code) != CDF_MRW)
474 if ((ret = cdrom_mrw_probe_pc(cdi))) {
482 static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
484 struct packet_command cgc;
485 unsigned char buffer[12];
488 pr_info("%sstarting format\n", cont ? "Re" : "");
491 * FmtData bit set (bit 4), format type is 1
493 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
494 cgc.cmd[0] = GPCMD_FORMAT_UNIT;
495 cgc.cmd[1] = (1 << 4) | 1;
497 cgc.timeout = 5 * 60 * HZ;
500 * 4 byte format list header, 8 byte format list descriptor
513 buffer[8] = 0x24 << 2;
516 ret = cdi->ops->generic_packet(cdi, &cgc);
518 pr_info("bgformat failed\n");
523 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
525 struct packet_command cgc;
527 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
528 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
531 * Session = 1, Track = 0
533 cgc.cmd[1] = !!immed;
536 cgc.timeout = 5 * 60 * HZ;
538 return cdi->ops->generic_packet(cdi, &cgc);
541 static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
546 ret = cdrom_get_disc_info(cdi, &di);
547 if (ret < 0 || ret < (int)offsetof(typeof(di),disc_type))
551 if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
552 pr_info("issuing MRW background format suspend\n");
553 ret = cdrom_mrw_bgformat_susp(cdi, 0);
556 if (!ret && cdi->media_written)
557 ret = cdrom_flush_cache(cdi);
562 static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
564 struct packet_command cgc;
565 struct mode_page_header *mph;
567 int ret, offset, size;
569 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
572 cgc.buflen = sizeof(buffer);
574 ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0);
578 mph = (struct mode_page_header *)buffer;
579 offset = be16_to_cpu(mph->desc_length);
580 size = be16_to_cpu(mph->mode_data_length) + 2;
582 buffer[offset + 3] = space;
585 ret = cdrom_mode_select(cdi, &cgc);
589 pr_info("%s: mrw address space %s selected\n",
590 cdi->name, mrw_address_space[space]);
594 int register_cdrom(struct gendisk *disk, struct cdrom_device_info *cdi)
596 static char banner_printed;
597 const struct cdrom_device_ops *cdo = cdi->ops;
599 cd_dbg(CD_OPEN, "entering register_cdrom\n");
601 if (cdo->open == NULL || cdo->release == NULL)
603 if (!banner_printed) {
604 pr_info("Uniform CD-ROM driver " REVISION "\n");
606 cdrom_sysctl_register();
612 ENSURE(cdo, drive_status, CDC_DRIVE_STATUS);
613 if (cdo->check_events == NULL)
614 WARN_ON_ONCE(cdo->capability & (CDC_MEDIA_CHANGED | CDC_SELECT_DISC));
615 ENSURE(cdo, tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
616 ENSURE(cdo, lock_door, CDC_LOCK);
617 ENSURE(cdo, select_speed, CDC_SELECT_SPEED);
618 ENSURE(cdo, get_last_session, CDC_MULTI_SESSION);
619 ENSURE(cdo, get_mcn, CDC_MCN);
620 ENSURE(cdo, reset, CDC_RESET);
621 ENSURE(cdo, generic_packet, CDC_GENERIC_PACKET);
623 cdi->options = CDO_USE_FFLAGS;
624 cdi->last_media_change_ms = ktime_to_ms(ktime_get());
626 if (autoclose == 1 && CDROM_CAN(CDC_CLOSE_TRAY))
627 cdi->options |= (int) CDO_AUTO_CLOSE;
628 if (autoeject == 1 && CDROM_CAN(CDC_OPEN_TRAY))
629 cdi->options |= (int) CDO_AUTO_EJECT;
631 cdi->options |= (int) CDO_LOCK;
632 if (check_media_type == 1)
633 cdi->options |= (int) CDO_CHECK_TYPE;
635 if (CDROM_CAN(CDC_MRW_W))
636 cdi->exit = cdrom_mrw_exit;
638 if (cdi->ops->read_cdda_bpc)
639 cdi->cdda_method = CDDA_BPC_FULL;
641 cdi->cdda_method = CDDA_OLD;
643 WARN_ON(!cdo->generic_packet);
645 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
646 mutex_lock(&cdrom_mutex);
647 list_add(&cdi->list, &cdrom_list);
648 mutex_unlock(&cdrom_mutex);
653 void unregister_cdrom(struct cdrom_device_info *cdi)
655 cd_dbg(CD_OPEN, "entering unregister_cdrom\n");
657 mutex_lock(&cdrom_mutex);
658 list_del(&cdi->list);
659 mutex_unlock(&cdrom_mutex);
664 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
667 int cdrom_get_media_event(struct cdrom_device_info *cdi,
668 struct media_event_desc *med)
670 struct packet_command cgc;
671 unsigned char buffer[8];
672 struct event_header *eh = (struct event_header *)buffer;
674 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
675 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
676 cgc.cmd[1] = 1; /* IMMED */
677 cgc.cmd[4] = 1 << 4; /* media event */
678 cgc.cmd[8] = sizeof(buffer);
681 if (cdi->ops->generic_packet(cdi, &cgc))
684 if (be16_to_cpu(eh->data_len) < sizeof(*med))
687 if (eh->nea || eh->notification_class != 0x4)
690 memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
694 static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
695 struct rwrt_feature_desc *rfd)
697 struct packet_command cgc;
701 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
703 cgc.cmd[0] = GPCMD_GET_CONFIGURATION; /* often 0x46 */
704 cgc.cmd[3] = CDF_RWRT; /* often 0x0020 */
705 cgc.cmd[8] = sizeof(buffer); /* often 0x18 */
708 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
711 memcpy(rfd, &buffer[sizeof(struct feature_header)], sizeof (*rfd));
715 static int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
717 struct packet_command cgc;
719 __be16 *feature_code;
722 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
724 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
725 cgc.cmd[3] = CDF_HWDM;
726 cgc.cmd[8] = sizeof(buffer);
729 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
732 feature_code = (__be16 *) &buffer[sizeof(struct feature_header)];
733 if (be16_to_cpu(*feature_code) == CDF_HWDM)
740 static int cdrom_is_random_writable(struct cdrom_device_info *cdi, int *write)
742 struct rwrt_feature_desc rfd;
747 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
750 if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
756 static int cdrom_media_erasable(struct cdrom_device_info *cdi)
761 ret = cdrom_get_disc_info(cdi, &di);
762 if (ret < 0 || ret < offsetof(typeof(di), n_first_track))
769 * FIXME: check RO bit
771 static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
773 int ret = cdrom_media_erasable(cdi);
776 * allow writable open if media info read worked and media is
777 * erasable, _or_ if it fails since not all drives support it
785 static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
791 * always reset to DMA lba space on open
793 if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_DMA)) {
794 pr_err("failed setting lba address space\n");
798 ret = cdrom_get_disc_info(cdi, &di);
799 if (ret < 0 || ret < offsetof(typeof(di),disc_type))
807 * 0 - not MRW formatted
808 * 1 - MRW bgformat started, but not running or complete
809 * 2 - MRW bgformat in progress
810 * 3 - MRW formatting complete
813 pr_info("open: mrw_status '%s'\n", mrw_format_status[di.mrw_status]);
816 else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE &&
818 ret = cdrom_mrw_bgformat(cdi, 1);
823 static int mo_open_write(struct cdrom_device_info *cdi)
825 struct packet_command cgc;
829 init_cdrom_command(&cgc, &buffer, 4, CGC_DATA_READ);
833 * obtain write protect information as per
834 * drivers/scsi/sd.c:sd_read_write_protect_flag
837 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
839 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_VENDOR_PAGE, 0);
842 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
845 /* drive gave us no info, let the user go ahead */
849 return buffer[3] & 0x80;
852 static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
854 struct rwrt_feature_desc rfd;
857 if ((ret = cdrom_has_defect_mgt(cdi)))
860 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
862 else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
865 cd_dbg(CD_OPEN, "can open for random write\n");
869 static void cdrom_mmc3_profile(struct cdrom_device_info *cdi)
871 struct packet_command cgc;
875 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
877 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
879 cgc.cmd[2] = cgc.cmd[3] = 0; /* Starting Feature Number */
880 cgc.cmd[8] = sizeof(buffer); /* Allocation Length */
883 if (cdi->ops->generic_packet(cdi, &cgc))
884 mmc3_profile = 0xffff;
886 mmc3_profile = (buffer[6] << 8) | buffer[7];
888 cdi->mmc3_profile = mmc3_profile;
891 static int cdrom_is_dvd_rw(struct cdrom_device_info *cdi)
893 switch (cdi->mmc3_profile) {
894 case 0x12: /* DVD-RAM */
895 case 0x1A: /* DVD+RW */
896 case 0x43: /* BD-RE */
904 * returns 0 for ok to open write, non-0 to disallow
906 static int cdrom_open_write(struct cdrom_device_info *cdi)
908 int mrw, mrw_write, ram_write;
912 if (!cdrom_is_mrw(cdi, &mrw_write))
915 if (CDROM_CAN(CDC_MO_DRIVE))
918 (void) cdrom_is_random_writable(cdi, &ram_write);
921 cdi->mask &= ~CDC_MRW;
923 cdi->mask |= CDC_MRW;
926 cdi->mask &= ~CDC_MRW_W;
928 cdi->mask |= CDC_MRW_W;
931 cdi->mask &= ~CDC_RAM;
933 cdi->mask |= CDC_RAM;
935 if (CDROM_CAN(CDC_MRW_W))
936 ret = cdrom_mrw_open_write(cdi);
937 else if (CDROM_CAN(CDC_DVD_RAM))
938 ret = cdrom_dvdram_open_write(cdi);
939 else if (CDROM_CAN(CDC_RAM) &&
940 !CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW|CDC_MO_DRIVE))
941 ret = cdrom_ram_open_write(cdi);
942 else if (CDROM_CAN(CDC_MO_DRIVE))
943 ret = mo_open_write(cdi);
944 else if (!cdrom_is_dvd_rw(cdi))
950 static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
952 struct packet_command cgc;
954 if (cdi->mmc3_profile != 0x1a) {
955 cd_dbg(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
959 if (!cdi->media_written) {
960 cd_dbg(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
964 pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi->name);
966 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
967 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
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.timeout = 3000*HZ;
975 cdi->ops->generic_packet(cdi, &cgc);
977 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
978 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
979 cgc.cmd[2] = 2; /* Close session */
981 cgc.timeout = 3000*HZ;
982 cdi->ops->generic_packet(cdi, &cgc);
984 cdi->media_written = 0;
987 static int cdrom_close_write(struct cdrom_device_info *cdi)
990 return cdrom_flush_cache(cdi);
996 /* badly broken, I know. Is due for a fixup anytime. */
997 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype *tracks)
999 struct cdrom_tochdr header;
1000 struct cdrom_tocentry entry;
1007 cd_dbg(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1009 if (!CDROM_CAN(CDC_PLAY_AUDIO)) {
1010 tracks->error = CDS_NO_INFO;
1014 /* Grab the TOC header so we can see how many tracks there are */
1015 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
1017 if (ret == -ENOMEDIUM)
1018 tracks->error = CDS_NO_DISC;
1020 tracks->error = CDS_NO_INFO;
1023 /* check what type of tracks are on this disc */
1024 entry.cdte_format = CDROM_MSF;
1025 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1026 entry.cdte_track = i;
1027 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1028 tracks->error = CDS_NO_INFO;
1031 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1032 if (entry.cdte_format == 0x10)
1034 else if (entry.cdte_format == 0x20)
1041 cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1042 i, entry.cdte_format, entry.cdte_ctrl);
1044 cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1045 header.cdth_trk1, tracks->audio, tracks->data,
1046 tracks->cdi, tracks->xa);
1050 int open_for_data(struct cdrom_device_info *cdi)
1053 const struct cdrom_device_ops *cdo = cdi->ops;
1055 cd_dbg(CD_OPEN, "entering open_for_data\n");
1056 /* Check if the driver can report drive status. If it can, we
1057 can do clever things. If it can't, well, we at least tried! */
1058 if (cdo->drive_status != NULL) {
1059 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1060 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1061 if (ret == CDS_TRAY_OPEN) {
1062 cd_dbg(CD_OPEN, "the tray is open...\n");
1063 /* can/may i close it? */
1064 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1065 cdi->options & CDO_AUTO_CLOSE) {
1066 cd_dbg(CD_OPEN, "trying to close the tray\n");
1067 ret=cdo->tray_move(cdi,0);
1069 cd_dbg(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1070 /* Ignore the error from the low
1071 level driver. We don't care why it
1072 couldn't close the tray. We only care
1073 that there is no disc in the drive,
1074 since that is the _REAL_ problem here.*/
1076 goto clean_up_and_return;
1079 cd_dbg(CD_OPEN, "bummer. this drive can't close the tray.\n");
1081 goto clean_up_and_return;
1083 /* Ok, the door should be closed now.. Check again */
1084 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1085 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1086 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1087 cd_dbg(CD_OPEN, "tray might not contain a medium\n");
1089 goto clean_up_and_return;
1091 cd_dbg(CD_OPEN, "the tray is now closed\n");
1093 /* the door should be closed now, check for the disc */
1094 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1095 if (ret!=CDS_DISC_OK) {
1097 goto clean_up_and_return;
1100 cdrom_count_tracks(cdi, &tracks);
1101 if (tracks.error == CDS_NO_DISC) {
1102 cd_dbg(CD_OPEN, "bummer. no disc.\n");
1104 goto clean_up_and_return;
1106 /* CD-Players which don't use O_NONBLOCK, workman
1107 * for example, need bit CDO_CHECK_TYPE cleared! */
1108 if (tracks.data==0) {
1109 if (cdi->options & CDO_CHECK_TYPE) {
1110 /* give people a warning shot, now that CDO_CHECK_TYPE
1111 is the default case! */
1112 cd_dbg(CD_OPEN, "bummer. wrong media type.\n");
1113 cd_dbg(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1114 (unsigned int)task_pid_nr(current));
1116 goto clean_up_and_return;
1119 cd_dbg(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set\n");
1123 cd_dbg(CD_OPEN, "all seems well, opening the devicen");
1125 /* all seems well, we can open the device */
1126 ret = cdo->open(cdi, 0); /* open for data */
1127 cd_dbg(CD_OPEN, "opening the device gave me %d\n", ret);
1128 /* After all this careful checking, we shouldn't have problems
1129 opening the device, but we don't want the device locked if
1130 this somehow fails... */
1132 cd_dbg(CD_OPEN, "open device failed\n");
1133 goto clean_up_and_return;
1135 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1136 cdo->lock_door(cdi, 1);
1137 cd_dbg(CD_OPEN, "door locked\n");
1139 cd_dbg(CD_OPEN, "device opened successfully\n");
1142 /* Something failed. Try to unlock the drive, because some drivers
1143 (notably ide-cd) lock the drive after every command. This produced
1144 a nasty bug where after mount failed, the drive would remain locked!
1145 This ensures that the drive gets unlocked after a mount fails. This
1146 is a goto to avoid bloating the driver with redundant code. */
1147 clean_up_and_return:
1148 cd_dbg(CD_OPEN, "open failed\n");
1149 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1150 cdo->lock_door(cdi, 0);
1151 cd_dbg(CD_OPEN, "door unlocked\n");
1156 /* We use the open-option O_NONBLOCK to indicate that the
1157 * purpose of opening is only for subsequent ioctl() calls; no device
1158 * integrity checks are performed.
1160 * We hope that all cd-player programs will adopt this convention. It
1161 * is in their own interest: device control becomes a lot easier
1164 int cdrom_open(struct cdrom_device_info *cdi, struct block_device *bdev,
1169 cd_dbg(CD_OPEN, "entering cdrom_open\n");
1171 /* if this was a O_NONBLOCK open and we should honor the flags,
1172 * do a quick open without drive/disc integrity checks. */
1174 if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) {
1175 ret = cdi->ops->open(cdi, 1);
1177 ret = open_for_data(cdi);
1180 if (CDROM_CAN(CDC_GENERIC_PACKET))
1181 cdrom_mmc3_profile(cdi);
1182 if (mode & FMODE_WRITE) {
1184 if (cdrom_open_write(cdi))
1186 if (!CDROM_CAN(CDC_RAM))
1189 cdi->media_written = 0;
1196 cd_dbg(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1197 cdi->name, cdi->use_count);
1200 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1201 cdi->ops->lock_door(cdi, 0);
1202 cd_dbg(CD_OPEN, "door unlocked\n");
1204 cdi->ops->release(cdi);
1210 /* This code is similar to that in open_for_data. The routine is called
1211 whenever an audio play operation is requested.
1213 static int check_for_audio_disc(struct cdrom_device_info *cdi,
1214 const struct cdrom_device_ops *cdo)
1218 cd_dbg(CD_OPEN, "entering check_for_audio_disc\n");
1219 if (!(cdi->options & CDO_CHECK_TYPE))
1221 if (cdo->drive_status != NULL) {
1222 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1223 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1224 if (ret == CDS_TRAY_OPEN) {
1225 cd_dbg(CD_OPEN, "the tray is open...\n");
1226 /* can/may i close it? */
1227 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1228 cdi->options & CDO_AUTO_CLOSE) {
1229 cd_dbg(CD_OPEN, "trying to close the tray\n");
1230 ret=cdo->tray_move(cdi,0);
1232 cd_dbg(CD_OPEN, "bummer. tried to close tray but failed.\n");
1233 /* Ignore the error from the low
1234 level driver. We don't care why it
1235 couldn't close the tray. We only care
1236 that there is no disc in the drive,
1237 since that is the _REAL_ problem here.*/
1241 cd_dbg(CD_OPEN, "bummer. this driver can't close the tray.\n");
1244 /* Ok, the door should be closed now.. Check again */
1245 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1246 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1247 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1250 if (ret!=CDS_DISC_OK) {
1251 cd_dbg(CD_OPEN, "bummer. disc isn't ready.\n");
1254 cd_dbg(CD_OPEN, "the tray is now closed\n");
1257 cdrom_count_tracks(cdi, &tracks);
1259 return(tracks.error);
1261 if (tracks.audio==0)
1262 return -EMEDIUMTYPE;
1267 void cdrom_release(struct cdrom_device_info *cdi, fmode_t mode)
1269 const struct cdrom_device_ops *cdo = cdi->ops;
1270 int opened_for_data;
1272 cd_dbg(CD_CLOSE, "entering cdrom_release\n");
1274 if (cdi->use_count > 0)
1277 if (cdi->use_count == 0) {
1278 cd_dbg(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n",
1280 cdrom_dvd_rw_close_write(cdi);
1282 if ((cdo->capability & CDC_LOCK) && !cdi->keeplocked) {
1283 cd_dbg(CD_CLOSE, "Unlocking door!\n");
1284 cdo->lock_door(cdi, 0);
1288 opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1289 !(mode & FMODE_NDELAY);
1292 * flush cache on last write release
1294 if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1295 cdrom_close_write(cdi);
1298 if (cdi->use_count == 0) { /* last process that closes dev*/
1299 if (opened_for_data &&
1300 cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1301 cdo->tray_move(cdi, 1);
1305 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1306 struct cdrom_changer_info *buf)
1308 struct packet_command cgc;
1309 const struct cdrom_device_ops *cdo = cdi->ops;
1313 * Sanyo changer isn't spec compliant (doesn't use regular change
1314 * LOAD_UNLOAD command, and it doesn't implement the mech status
1317 if (cdi->sanyo_slot) {
1318 buf->hdr.nslots = 3;
1319 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1320 for (length = 0; length < 3; length++) {
1321 buf->slots[length].disc_present = 1;
1322 buf->slots[length].change = 0;
1327 length = sizeof(struct cdrom_mechstat_header) +
1328 cdi->capacity * sizeof(struct cdrom_slot);
1330 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1331 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1332 cgc.cmd[8] = (length >> 8) & 0xff;
1333 cgc.cmd[9] = length & 0xff;
1334 return cdo->generic_packet(cdi, &cgc);
1337 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1339 struct cdrom_changer_info *info;
1342 cd_dbg(CD_CHANGER, "entering cdrom_slot_status()\n");
1343 if (cdi->sanyo_slot)
1346 info = kmalloc(sizeof(*info), GFP_KERNEL);
1350 if ((ret = cdrom_read_mech_status(cdi, info)))
1353 if (info->slots[slot].disc_present)
1363 /* Return the number of slots for an ATAPI/SCSI cdrom,
1364 * return 1 if not a changer.
1366 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1369 struct cdrom_changer_info *info;
1371 cd_dbg(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1372 /* cdrom_read_mech_status requires a valid value for capacity: */
1375 info = kmalloc(sizeof(*info), GFP_KERNEL);
1379 if (cdrom_read_mech_status(cdi, info) == 0)
1380 nslots = info->hdr.nslots;
1387 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1388 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1390 struct packet_command cgc;
1392 cd_dbg(CD_CHANGER, "entering cdrom_load_unload()\n");
1393 if (cdi->sanyo_slot && slot < 0)
1396 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1397 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1398 cgc.cmd[4] = 2 + (slot >= 0);
1400 cgc.timeout = 60 * HZ;
1402 /* The Sanyo 3 CD changer uses byte 7 of the
1403 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1404 using the GPCMD_LOAD_UNLOAD opcode. */
1405 if (cdi->sanyo_slot && -1 < slot) {
1406 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1408 cgc.cmd[4] = cgc.cmd[8] = 0;
1409 cdi->sanyo_slot = slot ? slot : 3;
1412 return cdi->ops->generic_packet(cdi, &cgc);
1415 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1417 struct cdrom_changer_info *info;
1421 cd_dbg(CD_CHANGER, "entering cdrom_select_disc()\n");
1422 if (!CDROM_CAN(CDC_SELECT_DISC))
1423 return -EDRIVE_CANT_DO_THIS;
1425 if (cdi->ops->check_events)
1426 cdi->ops->check_events(cdi, 0, slot);
1428 if (slot == CDSL_NONE) {
1429 signal_media_change(cdi);
1430 return cdrom_load_unload(cdi, -1);
1433 info = kmalloc(sizeof(*info), GFP_KERNEL);
1437 if ((ret = cdrom_read_mech_status(cdi, info))) {
1442 curslot = info->hdr.curslot;
1445 if (cdi->use_count > 1 || cdi->keeplocked) {
1446 if (slot == CDSL_CURRENT) {
1453 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1454 which is useful if it had been previously unloaded.
1455 Whether it can or not, it returns the current slot.
1456 Similarly, if slot happens to be the current one, we still
1458 if (slot == CDSL_CURRENT)
1461 /* set media changed bits on both queues */
1462 signal_media_change(cdi);
1463 if ((ret = cdrom_load_unload(cdi, slot)))
1470 * As cdrom implements an extra ioctl consumer for media changed
1471 * event, it needs to buffer ->check_events() output, such that event
1472 * is not lost for both the usual VFS and ioctl paths.
1473 * cdi->{vfs|ioctl}_events are used to buffer pending events for each
1476 * XXX: Locking is non-existent. cdi->ops->check_events() can be
1477 * called in parallel and buffering fields are accessed without any
1478 * exclusion. The original media_changed code had the same problem.
1479 * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1480 * and remove this cruft altogether. It doesn't have much usefulness
1483 static void cdrom_update_events(struct cdrom_device_info *cdi,
1484 unsigned int clearing)
1486 unsigned int events;
1488 events = cdi->ops->check_events(cdi, clearing, CDSL_CURRENT);
1489 cdi->vfs_events |= events;
1490 cdi->ioctl_events |= events;
1493 unsigned int cdrom_check_events(struct cdrom_device_info *cdi,
1494 unsigned int clearing)
1496 unsigned int events;
1498 cdrom_update_events(cdi, clearing);
1499 events = cdi->vfs_events;
1500 cdi->vfs_events = 0;
1503 EXPORT_SYMBOL(cdrom_check_events);
1505 /* We want to make media_changed accessible to the user through an
1506 * ioctl. The main problem now is that we must double-buffer the
1507 * low-level implementation, to assure that the VFS and the user both
1508 * see a medium change once.
1512 int media_changed(struct cdrom_device_info *cdi, int queue)
1514 unsigned int mask = (1 << (queue & 1));
1515 int ret = !!(cdi->mc_flags & mask);
1518 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1521 /* changed since last call? */
1522 BUG_ON(!queue); /* shouldn't be called from VFS path */
1523 cdrom_update_events(cdi, DISK_EVENT_MEDIA_CHANGE);
1524 changed = cdi->ioctl_events & DISK_EVENT_MEDIA_CHANGE;
1525 cdi->ioctl_events = 0;
1528 signal_media_change(cdi);
1530 cdi->media_written = 0;
1533 cdi->mc_flags &= ~mask; /* clear bit */
1537 /* Requests to the low-level drivers will /always/ be done in the
1538 following format convention:
1540 CDROM_LBA: all data-related requests.
1541 CDROM_MSF: all audio-related requests.
1543 However, a low-level implementation is allowed to refuse this
1544 request, and return information in its own favorite format.
1546 It doesn't make sense /at all/ to ask for a play_audio in LBA
1547 format, or ask for multi-session info in MSF format. However, for
1548 backward compatibility these format requests will be satisfied, but
1549 the requests to the low-level drivers will be sanitized in the more
1550 meaningful format indicated above.
1554 void sanitize_format(union cdrom_addr *addr,
1555 u_char * curr, u_char requested)
1557 if (*curr == requested)
1558 return; /* nothing to be done! */
1559 if (requested == CDROM_LBA) {
1560 addr->lba = (int) addr->msf.frame +
1561 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1562 } else { /* CDROM_MSF */
1563 int lba = addr->lba;
1564 addr->msf.frame = lba % 75;
1567 addr->msf.second = lba % 60;
1568 addr->msf.minute = lba / 60;
1573 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1576 memset(cgc, 0, sizeof(struct packet_command));
1578 memset(buf, 0, len);
1579 cgc->buffer = (char *) buf;
1581 cgc->data_direction = type;
1582 cgc->timeout = CDROM_DEF_TIMEOUT;
1587 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1588 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1590 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1592 cgc->cmd[0] = GPCMD_REPORT_KEY;
1593 cgc->cmd[10] = type | (agid << 6);
1595 case 0: case 8: case 5: {
1608 cgc->cmd[9] = cgc->buflen;
1609 cgc->data_direction = CGC_DATA_READ;
1612 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1614 cgc->cmd[0] = GPCMD_SEND_KEY;
1615 cgc->cmd[10] = type | (agid << 6);
1630 cgc->cmd[9] = cgc->buflen;
1631 cgc->data_direction = CGC_DATA_WRITE;
1634 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1638 struct packet_command cgc;
1639 const struct cdrom_device_ops *cdo = cdi->ops;
1640 rpc_state_t rpc_state;
1642 memset(buf, 0, sizeof(buf));
1643 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1647 case DVD_LU_SEND_AGID:
1648 cd_dbg(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1650 setup_report_key(&cgc, ai->lsa.agid, 0);
1652 if ((ret = cdo->generic_packet(cdi, &cgc)))
1655 ai->lsa.agid = buf[7] >> 6;
1656 /* Returning data, let host change state */
1659 case DVD_LU_SEND_KEY1:
1660 cd_dbg(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1661 setup_report_key(&cgc, ai->lsk.agid, 2);
1663 if ((ret = cdo->generic_packet(cdi, &cgc)))
1666 copy_key(ai->lsk.key, &buf[4]);
1667 /* Returning data, let host change state */
1670 case DVD_LU_SEND_CHALLENGE:
1671 cd_dbg(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1672 setup_report_key(&cgc, ai->lsc.agid, 1);
1674 if ((ret = cdo->generic_packet(cdi, &cgc)))
1677 copy_chal(ai->lsc.chal, &buf[4]);
1678 /* Returning data, let host change state */
1682 case DVD_LU_SEND_TITLE_KEY:
1683 cd_dbg(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1685 setup_report_key(&cgc, ai->lstk.agid, 4);
1686 cgc.cmd[5] = ai->lstk.lba;
1687 cgc.cmd[4] = ai->lstk.lba >> 8;
1688 cgc.cmd[3] = ai->lstk.lba >> 16;
1689 cgc.cmd[2] = ai->lstk.lba >> 24;
1691 if ((ret = cdo->generic_packet(cdi, &cgc)))
1694 ai->lstk.cpm = (buf[4] >> 7) & 1;
1695 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1696 ai->lstk.cgms = (buf[4] >> 4) & 3;
1697 copy_key(ai->lstk.title_key, &buf[5]);
1698 /* Returning data, let host change state */
1701 case DVD_LU_SEND_ASF:
1702 cd_dbg(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1703 setup_report_key(&cgc, ai->lsasf.agid, 5);
1705 if ((ret = cdo->generic_packet(cdi, &cgc)))
1708 ai->lsasf.asf = buf[7] & 1;
1711 /* LU data receive (LU changes state) */
1712 case DVD_HOST_SEND_CHALLENGE:
1713 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1714 setup_send_key(&cgc, ai->hsc.agid, 1);
1716 copy_chal(&buf[4], ai->hsc.chal);
1718 if ((ret = cdo->generic_packet(cdi, &cgc)))
1721 ai->type = DVD_LU_SEND_KEY1;
1724 case DVD_HOST_SEND_KEY2:
1725 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1726 setup_send_key(&cgc, ai->hsk.agid, 3);
1728 copy_key(&buf[4], ai->hsk.key);
1730 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1731 ai->type = DVD_AUTH_FAILURE;
1734 ai->type = DVD_AUTH_ESTABLISHED;
1738 case DVD_INVALIDATE_AGID:
1740 cd_dbg(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1741 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1742 if ((ret = cdo->generic_packet(cdi, &cgc)))
1746 /* Get region settings */
1747 case DVD_LU_SEND_RPC_STATE:
1748 cd_dbg(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1749 setup_report_key(&cgc, 0, 8);
1750 memset(&rpc_state, 0, sizeof(rpc_state_t));
1751 cgc.buffer = (char *) &rpc_state;
1753 if ((ret = cdo->generic_packet(cdi, &cgc)))
1756 ai->lrpcs.type = rpc_state.type_code;
1757 ai->lrpcs.vra = rpc_state.vra;
1758 ai->lrpcs.ucca = rpc_state.ucca;
1759 ai->lrpcs.region_mask = rpc_state.region_mask;
1760 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1763 /* Set region settings */
1764 case DVD_HOST_SEND_RPC_STATE:
1765 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1766 setup_send_key(&cgc, 0, 6);
1768 buf[4] = ai->hrpcs.pdrc;
1770 if ((ret = cdo->generic_packet(cdi, &cgc)))
1775 cd_dbg(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1782 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s,
1783 struct packet_command *cgc)
1785 unsigned char buf[21], *base;
1786 struct dvd_layer *layer;
1787 const struct cdrom_device_ops *cdo = cdi->ops;
1788 int ret, layer_num = s->physical.layer_num;
1790 if (layer_num >= DVD_LAYERS)
1793 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1794 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1795 cgc->cmd[6] = layer_num;
1796 cgc->cmd[7] = s->type;
1797 cgc->cmd[9] = cgc->buflen & 0xff;
1800 * refrain from reporting errors on non-existing layers (mainly)
1804 ret = cdo->generic_packet(cdi, cgc);
1809 layer = &s->physical.layer[layer_num];
1812 * place the data... really ugly, but at least we won't have to
1813 * worry about endianess in userspace.
1815 memset(layer, 0, sizeof(*layer));
1816 layer->book_version = base[0] & 0xf;
1817 layer->book_type = base[0] >> 4;
1818 layer->min_rate = base[1] & 0xf;
1819 layer->disc_size = base[1] >> 4;
1820 layer->layer_type = base[2] & 0xf;
1821 layer->track_path = (base[2] >> 4) & 1;
1822 layer->nlayers = (base[2] >> 5) & 3;
1823 layer->track_density = base[3] & 0xf;
1824 layer->linear_density = base[3] >> 4;
1825 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1826 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1827 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1828 layer->bca = base[16] >> 7;
1833 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s,
1834 struct packet_command *cgc)
1838 const struct cdrom_device_ops *cdo = cdi->ops;
1840 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1841 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1842 cgc->cmd[6] = s->copyright.layer_num;
1843 cgc->cmd[7] = s->type;
1844 cgc->cmd[8] = cgc->buflen >> 8;
1845 cgc->cmd[9] = cgc->buflen & 0xff;
1847 ret = cdo->generic_packet(cdi, cgc);
1851 s->copyright.cpst = buf[4];
1852 s->copyright.rmi = buf[5];
1857 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s,
1858 struct packet_command *cgc)
1862 const struct cdrom_device_ops *cdo = cdi->ops;
1864 size = sizeof(s->disckey.value) + 4;
1866 buf = kmalloc(size, GFP_KERNEL);
1870 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1871 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1872 cgc->cmd[7] = s->type;
1873 cgc->cmd[8] = size >> 8;
1874 cgc->cmd[9] = size & 0xff;
1875 cgc->cmd[10] = s->disckey.agid << 6;
1877 ret = cdo->generic_packet(cdi, cgc);
1879 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1885 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1886 struct packet_command *cgc)
1888 int ret, size = 4 + 188;
1890 const struct cdrom_device_ops *cdo = cdi->ops;
1892 buf = kmalloc(size, GFP_KERNEL);
1896 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1897 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1898 cgc->cmd[7] = s->type;
1899 cgc->cmd[9] = cgc->buflen & 0xff;
1901 ret = cdo->generic_packet(cdi, cgc);
1905 s->bca.len = buf[0] << 8 | buf[1];
1906 if (s->bca.len < 12 || s->bca.len > 188) {
1907 cd_dbg(CD_WARNING, "Received invalid BCA length (%d)\n",
1912 memcpy(s->bca.value, &buf[4], s->bca.len);
1919 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1920 struct packet_command *cgc)
1924 const struct cdrom_device_ops *cdo = cdi->ops;
1926 size = sizeof(s->manufact.value) + 4;
1928 buf = kmalloc(size, GFP_KERNEL);
1932 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1933 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1934 cgc->cmd[7] = s->type;
1935 cgc->cmd[8] = size >> 8;
1936 cgc->cmd[9] = size & 0xff;
1938 ret = cdo->generic_packet(cdi, cgc);
1942 s->manufact.len = buf[0] << 8 | buf[1];
1943 if (s->manufact.len < 0) {
1944 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d)\n",
1948 if (s->manufact.len > 2048) {
1949 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d): truncating to 2048\n",
1951 s->manufact.len = 2048;
1953 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1961 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1962 struct packet_command *cgc)
1965 case DVD_STRUCT_PHYSICAL:
1966 return dvd_read_physical(cdi, s, cgc);
1968 case DVD_STRUCT_COPYRIGHT:
1969 return dvd_read_copyright(cdi, s, cgc);
1971 case DVD_STRUCT_DISCKEY:
1972 return dvd_read_disckey(cdi, s, cgc);
1974 case DVD_STRUCT_BCA:
1975 return dvd_read_bca(cdi, s, cgc);
1977 case DVD_STRUCT_MANUFACT:
1978 return dvd_read_manufact(cdi, s, cgc);
1981 cd_dbg(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1987 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1988 struct packet_command *cgc,
1989 int page_code, int page_control)
1991 const struct cdrom_device_ops *cdo = cdi->ops;
1993 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1995 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1996 cgc->cmd[2] = page_code | (page_control << 6);
1997 cgc->cmd[7] = cgc->buflen >> 8;
1998 cgc->cmd[8] = cgc->buflen & 0xff;
1999 cgc->data_direction = CGC_DATA_READ;
2000 return cdo->generic_packet(cdi, cgc);
2003 int cdrom_mode_select(struct cdrom_device_info *cdi,
2004 struct packet_command *cgc)
2006 const struct cdrom_device_ops *cdo = cdi->ops;
2008 memset(cgc->cmd, 0, sizeof(cgc->cmd));
2009 memset(cgc->buffer, 0, 2);
2010 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
2011 cgc->cmd[1] = 0x10; /* PF */
2012 cgc->cmd[7] = cgc->buflen >> 8;
2013 cgc->cmd[8] = cgc->buflen & 0xff;
2014 cgc->data_direction = CGC_DATA_WRITE;
2015 return cdo->generic_packet(cdi, cgc);
2018 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
2019 struct cdrom_subchnl *subchnl, int mcn)
2021 const struct cdrom_device_ops *cdo = cdi->ops;
2022 struct packet_command cgc;
2026 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
2027 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
2028 cgc.cmd[1] = subchnl->cdsc_format;/* MSF or LBA addressing */
2029 cgc.cmd[2] = 0x40; /* request subQ data */
2030 cgc.cmd[3] = mcn ? 2 : 1;
2033 if ((ret = cdo->generic_packet(cdi, &cgc)))
2036 subchnl->cdsc_audiostatus = cgc.buffer[1];
2037 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
2038 subchnl->cdsc_trk = cgc.buffer[6];
2039 subchnl->cdsc_ind = cgc.buffer[7];
2041 if (subchnl->cdsc_format == CDROM_LBA) {
2042 subchnl->cdsc_absaddr.lba = ((cgc.buffer[8] << 24) |
2043 (cgc.buffer[9] << 16) |
2044 (cgc.buffer[10] << 8) |
2046 subchnl->cdsc_reladdr.lba = ((cgc.buffer[12] << 24) |
2047 (cgc.buffer[13] << 16) |
2048 (cgc.buffer[14] << 8) |
2051 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
2052 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
2053 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
2054 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
2055 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
2056 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
2063 * Specific READ_10 interface
2065 static int cdrom_read_cd(struct cdrom_device_info *cdi,
2066 struct packet_command *cgc, int lba,
2067 int blocksize, int nblocks)
2069 const struct cdrom_device_ops *cdo = cdi->ops;
2071 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2072 cgc->cmd[0] = GPCMD_READ_10;
2073 cgc->cmd[2] = (lba >> 24) & 0xff;
2074 cgc->cmd[3] = (lba >> 16) & 0xff;
2075 cgc->cmd[4] = (lba >> 8) & 0xff;
2076 cgc->cmd[5] = lba & 0xff;
2077 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2078 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2079 cgc->cmd[8] = nblocks & 0xff;
2080 cgc->buflen = blocksize * nblocks;
2081 return cdo->generic_packet(cdi, cgc);
2084 /* very generic interface for reading the various types of blocks */
2085 static int cdrom_read_block(struct cdrom_device_info *cdi,
2086 struct packet_command *cgc,
2087 int lba, int nblocks, int format, int blksize)
2089 const struct cdrom_device_ops *cdo = cdi->ops;
2091 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2092 cgc->cmd[0] = GPCMD_READ_CD;
2093 /* expected sector size - cdda,mode1,etc. */
2094 cgc->cmd[1] = format << 2;
2095 /* starting address */
2096 cgc->cmd[2] = (lba >> 24) & 0xff;
2097 cgc->cmd[3] = (lba >> 16) & 0xff;
2098 cgc->cmd[4] = (lba >> 8) & 0xff;
2099 cgc->cmd[5] = lba & 0xff;
2100 /* number of blocks */
2101 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2102 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2103 cgc->cmd[8] = nblocks & 0xff;
2104 cgc->buflen = blksize * nblocks;
2106 /* set the header info returned */
2108 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
2109 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
2110 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
2111 default : cgc->cmd[9] = 0x10;
2114 return cdo->generic_packet(cdi, cgc);
2117 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2118 int lba, int nframes)
2120 struct packet_command cgc;
2124 cdi->last_sense = 0;
2126 memset(&cgc, 0, sizeof(cgc));
2129 * start with will ra.nframes size, back down if alloc fails
2133 cgc.buffer = kmalloc_array(nr, CD_FRAMESIZE_RAW, GFP_KERNEL);
2143 cgc.data_direction = CGC_DATA_READ;
2144 while (nframes > 0) {
2148 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2151 if (copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2155 ubuf += CD_FRAMESIZE_RAW * nr;
2163 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2164 int lba, int nframes)
2166 int max_frames = (queue_max_sectors(cdi->disk->queue) << 9) /
2170 cdi->last_sense = 0;
2173 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2176 nr = min(nframes, max_frames);
2178 ret = cdi->ops->read_cdda_bpc(cdi, ubuf, lba, nr,
2185 ubuf += (nr * CD_FRAMESIZE_RAW);
2191 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2192 int lba, int nframes)
2196 if (cdi->cdda_method == CDDA_OLD)
2197 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2201 * for anything else than success and io error, we need to retry
2203 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2204 if (!ret || ret != -EIO)
2208 * I've seen drives get sense 4/8/3 udma crc errors on multi
2209 * frame dma, so drop to single frame dma if we need to
2211 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2212 pr_info("dropping to single frame dma\n");
2213 cdi->cdda_method = CDDA_BPC_SINGLE;
2218 * so we have an io error of some sort with multi frame dma. if the
2219 * condition wasn't a hardware error
2220 * problems, not for any error
2222 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2225 pr_info("dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2226 cdi->cdda_method = CDDA_OLD;
2227 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2230 int cdrom_multisession(struct cdrom_device_info *cdi,
2231 struct cdrom_multisession *info)
2233 u8 requested_format;
2236 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2239 requested_format = info->addr_format;
2240 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2242 info->addr_format = CDROM_LBA;
2244 ret = cdi->ops->get_last_session(cdi, info);
2246 sanitize_format(&info->addr, &info->addr_format,
2250 EXPORT_SYMBOL_GPL(cdrom_multisession);
2252 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2255 struct cdrom_multisession info;
2258 cd_dbg(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2260 if (copy_from_user(&info, argp, sizeof(info)))
2262 ret = cdrom_multisession(cdi, &info);
2265 if (copy_to_user(argp, &info, sizeof(info)))
2268 cd_dbg(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2272 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2274 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT\n");
2276 if (!CDROM_CAN(CDC_OPEN_TRAY))
2278 if (cdi->use_count != 1 || cdi->keeplocked)
2280 if (CDROM_CAN(CDC_LOCK)) {
2281 int ret = cdi->ops->lock_door(cdi, 0);
2286 return cdi->ops->tray_move(cdi, 1);
2289 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2291 cd_dbg(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2293 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2295 return cdi->ops->tray_move(cdi, 0);
2298 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2301 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2303 if (!CDROM_CAN(CDC_OPEN_TRAY))
2305 if (cdi->keeplocked)
2308 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2310 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2314 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2317 struct cdrom_changer_info *info;
2320 cd_dbg(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2322 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2325 /* cannot select disc or select current disc */
2326 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2327 return media_changed(cdi, 1);
2329 if (arg >= cdi->capacity)
2332 info = kmalloc(sizeof(*info), GFP_KERNEL);
2336 ret = cdrom_read_mech_status(cdi, info);
2338 ret = info->slots[arg].change;
2344 * Media change detection with timing information.
2346 * arg is a pointer to a cdrom_timed_media_change_info struct.
2347 * arg->last_media_change may be set by calling code to signal
2348 * the timestamp (in ms) of the last known media change (by the caller).
2349 * Upon successful return, ioctl call will set arg->last_media_change
2350 * to the latest media change timestamp known by the kernel/driver
2351 * and set arg->has_changed to 1 if that timestamp is more recent
2352 * than the timestamp set by the caller.
2354 static int cdrom_ioctl_timed_media_change(struct cdrom_device_info *cdi,
2358 struct cdrom_timed_media_change_info __user *info;
2359 struct cdrom_timed_media_change_info tmp_info;
2361 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2364 info = (struct cdrom_timed_media_change_info __user *)arg;
2365 cd_dbg(CD_DO_IOCTL, "entering CDROM_TIMED_MEDIA_CHANGE\n");
2367 ret = cdrom_ioctl_media_changed(cdi, CDSL_CURRENT);
2371 if (copy_from_user(&tmp_info, info, sizeof(tmp_info)) != 0)
2374 tmp_info.media_flags = 0;
2375 if (tmp_info.last_media_change - cdi->last_media_change_ms < 0)
2376 tmp_info.media_flags |= MEDIA_CHANGED_FLAG;
2378 tmp_info.last_media_change = cdi->last_media_change_ms;
2380 if (copy_to_user(info, &tmp_info, sizeof(*info)) != 0)
2386 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2389 cd_dbg(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2392 * Options need to be in sync with capability.
2393 * Too late for that, so we have to check each one separately.
2396 case CDO_USE_FFLAGS:
2397 case CDO_CHECK_TYPE:
2400 if (!CDROM_CAN(CDC_LOCK))
2404 return cdi->options;
2405 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2407 if (!CDROM_CAN(arg))
2410 cdi->options |= (int) arg;
2411 return cdi->options;
2414 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2417 cd_dbg(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2419 cdi->options &= ~(int) arg;
2420 return cdi->options;
2423 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2426 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2428 if (!CDROM_CAN(CDC_SELECT_SPEED))
2430 return cdi->ops->select_speed(cdi, arg);
2433 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2436 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2438 if (!CDROM_CAN(CDC_SELECT_DISC))
2441 if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2442 if (arg >= cdi->capacity)
2447 * ->select_disc is a hook to allow a driver-specific way of
2448 * seleting disc. However, since there is no equivalent hook for
2449 * cdrom_slot_status this may not actually be useful...
2451 if (cdi->ops->select_disc)
2452 return cdi->ops->select_disc(cdi, arg);
2454 cd_dbg(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2455 return cdrom_select_disc(cdi, arg);
2458 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2459 struct block_device *bdev)
2461 cd_dbg(CD_DO_IOCTL, "entering CDROM_RESET\n");
2463 if (!capable(CAP_SYS_ADMIN))
2465 if (!CDROM_CAN(CDC_RESET))
2467 invalidate_bdev(bdev);
2468 return cdi->ops->reset(cdi);
2471 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2474 cd_dbg(CD_DO_IOCTL, "%socking door\n", arg ? "L" : "Unl");
2476 if (!CDROM_CAN(CDC_LOCK))
2477 return -EDRIVE_CANT_DO_THIS;
2479 cdi->keeplocked = arg ? 1 : 0;
2482 * Don't unlock the door on multiple opens by default, but allow
2485 if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2487 return cdi->ops->lock_door(cdi, arg);
2490 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2493 cd_dbg(CD_DO_IOCTL, "%sabling debug\n", arg ? "En" : "Dis");
2495 if (!capable(CAP_SYS_ADMIN))
2497 debug = arg ? 1 : 0;
2501 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2503 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2504 return (cdi->ops->capability & ~cdi->mask);
2508 * The following function is implemented, although very few audio
2509 * discs give Universal Product Code information, which should just be
2510 * the Medium Catalog Number on the box. Note, that the way the code
2511 * is written on the CD is /not/ uniform across all discs!
2513 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2516 struct cdrom_mcn mcn;
2519 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2521 if (!(cdi->ops->capability & CDC_MCN))
2523 ret = cdi->ops->get_mcn(cdi, &mcn);
2527 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2529 cd_dbg(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2533 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2536 cd_dbg(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2538 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2540 if (!CDROM_CAN(CDC_SELECT_DISC) ||
2541 (arg == CDSL_CURRENT || arg == CDSL_NONE))
2542 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2543 if (arg >= cdi->capacity)
2545 return cdrom_slot_status(cdi, arg);
2549 * Ok, this is where problems start. The current interface for the
2550 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2551 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunately, while this
2552 * is often the case, it is also very common for CDs to have some tracks
2553 * with data, and some tracks with audio. Just because I feel like it,
2554 * I declare the following to be the best way to cope. If the CD has ANY
2555 * data tracks on it, it will be returned as a data CD. If it has any XA
2556 * tracks, I will return it as that. Now I could simplify this interface
2557 * by combining these returns with the above, but this more clearly
2558 * demonstrates the problem with the current interface. Too bad this
2559 * wasn't designed to use bitmasks... -Erik
2561 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2562 * User level programmers might feel the ioctl is not very useful.
2565 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2569 cd_dbg(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2571 cdrom_count_tracks(cdi, &tracks);
2573 return tracks.error;
2575 /* Policy mode on */
2576 if (tracks.audio > 0) {
2577 if (!tracks.data && !tracks.cdi && !tracks.xa)
2587 if (tracks.data > 0)
2589 /* Policy mode off */
2591 cd_dbg(CD_WARNING, "This disc doesn't have any tracks I recognize!\n");
2595 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2597 cd_dbg(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2598 return cdi->capacity;
2601 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2604 struct cdrom_subchnl q;
2608 /* cd_dbg(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2610 if (copy_from_user(&q, argp, sizeof(q)))
2613 requested = q.cdsc_format;
2614 if (requested != CDROM_MSF && requested != CDROM_LBA)
2616 q.cdsc_format = CDROM_MSF;
2618 ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2622 back = q.cdsc_format; /* local copy */
2623 sanitize_format(&q.cdsc_absaddr, &back, requested);
2624 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2626 if (copy_to_user(argp, &q, sizeof(q)))
2628 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2632 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2635 struct cdrom_tochdr header;
2638 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2640 if (copy_from_user(&header, argp, sizeof(header)))
2643 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2647 if (copy_to_user(argp, &header, sizeof(header)))
2649 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2653 int cdrom_read_tocentry(struct cdrom_device_info *cdi,
2654 struct cdrom_tocentry *entry)
2656 u8 requested_format = entry->cdte_format;
2659 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2662 /* make interface to low-level uniform */
2663 entry->cdte_format = CDROM_MSF;
2664 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, entry);
2666 sanitize_format(&entry->cdte_addr, &entry->cdte_format,
2670 EXPORT_SYMBOL_GPL(cdrom_read_tocentry);
2672 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2675 struct cdrom_tocentry entry;
2678 if (copy_from_user(&entry, argp, sizeof(entry)))
2680 ret = cdrom_read_tocentry(cdi, &entry);
2681 if (!ret && copy_to_user(argp, &entry, sizeof(entry)))
2686 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2689 struct cdrom_msf msf;
2691 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2693 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2695 if (copy_from_user(&msf, argp, sizeof(msf)))
2697 return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2700 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2706 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2708 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2710 if (copy_from_user(&ti, argp, sizeof(ti)))
2713 ret = check_for_audio_disc(cdi, cdi->ops);
2716 return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2718 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2721 struct cdrom_volctrl volume;
2723 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2725 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2727 if (copy_from_user(&volume, argp, sizeof(volume)))
2729 return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2732 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2735 struct cdrom_volctrl volume;
2738 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2740 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2743 ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2747 if (copy_to_user(argp, &volume, sizeof(volume)))
2752 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2757 cd_dbg(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2759 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2761 ret = check_for_audio_disc(cdi, cdi->ops);
2764 return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2768 * Required when we need to use READ_10 to issue other than 2048 block
2771 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2773 const struct cdrom_device_ops *cdo = cdi->ops;
2774 struct packet_command cgc;
2775 struct modesel_head mh;
2777 memset(&mh, 0, sizeof(mh));
2778 mh.block_desc_length = 0x08;
2779 mh.block_length_med = (size >> 8) & 0xff;
2780 mh.block_length_lo = size & 0xff;
2782 memset(&cgc, 0, sizeof(cgc));
2784 cgc.cmd[1] = 1 << 4;
2786 cgc.buflen = sizeof(mh);
2787 cgc.buffer = (char *) &mh;
2788 cgc.data_direction = CGC_DATA_WRITE;
2789 mh.block_desc_length = 0x08;
2790 mh.block_length_med = (size >> 8) & 0xff;
2791 mh.block_length_lo = size & 0xff;
2793 return cdo->generic_packet(cdi, &cgc);
2796 static int cdrom_get_track_info(struct cdrom_device_info *cdi,
2797 __u16 track, __u8 type, track_information *ti)
2799 const struct cdrom_device_ops *cdo = cdi->ops;
2800 struct packet_command cgc;
2803 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
2804 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
2805 cgc.cmd[1] = type & 3;
2806 cgc.cmd[4] = (track & 0xff00) >> 8;
2807 cgc.cmd[5] = track & 0xff;
2811 ret = cdo->generic_packet(cdi, &cgc);
2815 buflen = be16_to_cpu(ti->track_information_length) +
2816 sizeof(ti->track_information_length);
2818 if (buflen > sizeof(track_information))
2819 buflen = sizeof(track_information);
2821 cgc.cmd[8] = cgc.buflen = buflen;
2822 ret = cdo->generic_packet(cdi, &cgc);
2826 /* return actual fill size */
2830 /* return the last written block on the CD-R media. this is for the udf
2832 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
2834 struct cdrom_tocentry toc;
2835 disc_information di;
2836 track_information ti;
2838 int ret = -1, ti_size;
2840 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2843 ret = cdrom_get_disc_info(cdi, &di);
2844 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
2845 + sizeof(di.last_track_lsb)))
2848 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2849 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2850 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2851 if (ti_size < (int)offsetof(typeof(ti), track_start))
2854 /* if this track is blank, try the previous. */
2856 if (last_track == 1)
2859 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2862 if (ti_size < (int)(offsetof(typeof(ti), track_size)
2863 + sizeof(ti.track_size)))
2866 /* if last recorded field is valid, return it. */
2867 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
2868 + sizeof(ti.last_rec_address))) {
2869 *last_written = be32_to_cpu(ti.last_rec_address);
2871 /* make it up instead */
2872 *last_written = be32_to_cpu(ti.track_start) +
2873 be32_to_cpu(ti.track_size);
2875 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
2879 /* this is where we end up if the drive either can't do a
2880 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
2881 it doesn't give enough information or fails. then we return
2882 the toc contents. */
2884 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2887 toc.cdte_format = CDROM_MSF;
2888 toc.cdte_track = CDROM_LEADOUT;
2889 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
2891 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
2892 *last_written = toc.cdte_addr.lba;
2896 /* return the next writable block. also for udf file system. */
2897 static int cdrom_get_next_writable(struct cdrom_device_info *cdi,
2898 long *next_writable)
2900 disc_information di;
2901 track_information ti;
2905 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2906 goto use_last_written;
2908 ret = cdrom_get_disc_info(cdi, &di);
2909 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
2910 + sizeof(di.last_track_lsb))
2911 goto use_last_written;
2913 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2914 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2915 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2916 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
2917 goto use_last_written;
2919 /* if this track is blank, try the previous. */
2921 if (last_track == 1)
2922 goto use_last_written;
2924 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2926 goto use_last_written;
2929 /* if next recordable address field is valid, use it. */
2930 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
2931 + sizeof(ti.next_writable)) {
2932 *next_writable = be32_to_cpu(ti.next_writable);
2937 ret = cdrom_get_last_written(cdi, next_writable);
2942 *next_writable += 7;
2947 static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2949 struct packet_command *cgc,
2952 struct scsi_sense_hdr sshdr;
2953 struct cdrom_msf msf;
2954 int blocksize = 0, format = 0, lba;
2959 blocksize = CD_FRAMESIZE_RAW;
2961 case CDROMREADMODE1:
2962 blocksize = CD_FRAMESIZE;
2965 case CDROMREADMODE2:
2966 blocksize = CD_FRAMESIZE_RAW0;
2969 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
2971 lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2972 /* FIXME: we need upper bound checking, too!! */
2976 cgc->buffer = kzalloc(blocksize, GFP_KERNEL);
2977 if (cgc->buffer == NULL)
2980 memset(&sshdr, 0, sizeof(sshdr));
2981 cgc->sshdr = &sshdr;
2982 cgc->data_direction = CGC_DATA_READ;
2983 ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
2984 if (ret && sshdr.sense_key == 0x05 &&
2985 sshdr.asc == 0x20 &&
2986 sshdr.ascq == 0x00) {
2988 * SCSI-II devices are not required to support
2989 * READ_CD, so let's try switching block size
2991 if (blocksize != CD_FRAMESIZE) {
2992 ret = cdrom_switch_blocksize(cdi, blocksize);
2997 ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
2998 if (blocksize != CD_FRAMESIZE)
2999 ret |= cdrom_switch_blocksize(cdi, CD_FRAMESIZE);
3001 if (!ret && copy_to_user(arg, cgc->buffer, blocksize))
3008 static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
3011 struct cdrom_read_audio ra;
3014 #ifdef CONFIG_COMPAT
3015 if (in_compat_syscall()) {
3016 struct compat_cdrom_read_audio {
3017 union cdrom_addr addr;
3019 compat_int_t nframes;
3023 if (copy_from_user(&ra32, arg, sizeof(ra32)))
3026 ra = (struct cdrom_read_audio) {
3028 .addr_format = ra32.addr_format,
3029 .nframes = ra32.nframes,
3030 .buf = compat_ptr(ra32.buf),
3035 if (copy_from_user(&ra, (struct cdrom_read_audio __user *)arg,
3040 if (ra.addr_format == CDROM_MSF)
3041 lba = msf_to_lba(ra.addr.msf.minute,
3044 else if (ra.addr_format == CDROM_LBA)
3049 /* FIXME: we need upper bound checking, too!! */
3050 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
3053 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
3056 static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
3060 struct cdrom_subchnl q;
3061 u_char requested, back;
3062 if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q)))
3064 requested = q.cdsc_format;
3065 if (!((requested == CDROM_MSF) ||
3066 (requested == CDROM_LBA)))
3069 ret = cdrom_read_subchannel(cdi, &q, 0);
3072 back = q.cdsc_format; /* local copy */
3073 sanitize_format(&q.cdsc_absaddr, &back, requested);
3074 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
3075 if (copy_to_user((struct cdrom_subchnl __user *)arg, &q, sizeof(q)))
3077 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
3081 static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
3083 struct packet_command *cgc)
3085 const struct cdrom_device_ops *cdo = cdi->ops;
3086 struct cdrom_msf msf;
3087 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
3088 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
3090 cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
3091 cgc->cmd[3] = msf.cdmsf_min0;
3092 cgc->cmd[4] = msf.cdmsf_sec0;
3093 cgc->cmd[5] = msf.cdmsf_frame0;
3094 cgc->cmd[6] = msf.cdmsf_min1;
3095 cgc->cmd[7] = msf.cdmsf_sec1;
3096 cgc->cmd[8] = msf.cdmsf_frame1;
3097 cgc->data_direction = CGC_DATA_NONE;
3098 return cdo->generic_packet(cdi, cgc);
3101 static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
3103 struct packet_command *cgc)
3105 const struct cdrom_device_ops *cdo = cdi->ops;
3106 struct cdrom_blk blk;
3107 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
3108 if (copy_from_user(&blk, (struct cdrom_blk __user *)arg, sizeof(blk)))
3110 cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
3111 cgc->cmd[2] = (blk.from >> 24) & 0xff;
3112 cgc->cmd[3] = (blk.from >> 16) & 0xff;
3113 cgc->cmd[4] = (blk.from >> 8) & 0xff;
3114 cgc->cmd[5] = blk.from & 0xff;
3115 cgc->cmd[7] = (blk.len >> 8) & 0xff;
3116 cgc->cmd[8] = blk.len & 0xff;
3117 cgc->data_direction = CGC_DATA_NONE;
3118 return cdo->generic_packet(cdi, cgc);
3121 static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3123 struct packet_command *cgc,
3126 struct cdrom_volctrl volctrl;
3127 unsigned char buffer[32];
3128 char mask[sizeof(buffer)];
3129 unsigned short offset;
3132 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3134 if (copy_from_user(&volctrl, (struct cdrom_volctrl __user *)arg,
3138 cgc->buffer = buffer;
3140 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 0);
3144 /* originally the code depended on buffer[1] to determine
3145 how much data is available for transfer. buffer[1] is
3146 unfortunately ambigious and the only reliable way seem
3147 to be to simply skip over the block descriptor... */
3148 offset = 8 + be16_to_cpu(*(__be16 *)(buffer + 6));
3150 if (offset + 16 > sizeof(buffer))
3153 if (offset + 16 > cgc->buflen) {
3154 cgc->buflen = offset + 16;
3155 ret = cdrom_mode_sense(cdi, cgc,
3156 GPMODE_AUDIO_CTL_PAGE, 0);
3162 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3163 buffer[offset + 1] < 14)
3166 /* now we have the current volume settings. if it was only
3167 a CDROMVOLREAD, return these values */
3168 if (cmd == CDROMVOLREAD) {
3169 volctrl.channel0 = buffer[offset+9];
3170 volctrl.channel1 = buffer[offset+11];
3171 volctrl.channel2 = buffer[offset+13];
3172 volctrl.channel3 = buffer[offset+15];
3173 if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl,
3179 /* get the volume mask */
3181 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 1);
3185 buffer[offset + 9] = volctrl.channel0 & mask[offset + 9];
3186 buffer[offset + 11] = volctrl.channel1 & mask[offset + 11];
3187 buffer[offset + 13] = volctrl.channel2 & mask[offset + 13];
3188 buffer[offset + 15] = volctrl.channel3 & mask[offset + 15];
3191 cgc->buffer = buffer + offset - 8;
3192 memset(cgc->buffer, 0, 8);
3193 return cdrom_mode_select(cdi, cgc);
3196 static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3197 struct packet_command *cgc,
3200 const struct cdrom_device_ops *cdo = cdi->ops;
3201 cd_dbg(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3202 cgc->cmd[0] = GPCMD_START_STOP_UNIT;
3204 cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3205 cgc->data_direction = CGC_DATA_NONE;
3206 return cdo->generic_packet(cdi, cgc);
3209 static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3210 struct packet_command *cgc,
3213 const struct cdrom_device_ops *cdo = cdi->ops;
3214 cd_dbg(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3215 cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3216 cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3217 cgc->data_direction = CGC_DATA_NONE;
3218 return cdo->generic_packet(cdi, cgc);
3221 static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3223 struct packet_command *cgc)
3227 int size = sizeof(dvd_struct);
3229 if (!CDROM_CAN(CDC_DVD))
3232 s = memdup_user(arg, size);
3236 cd_dbg(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3238 ret = dvd_read_struct(cdi, s, cgc);
3242 if (copy_to_user(arg, s, size))
3249 static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3254 if (!CDROM_CAN(CDC_DVD))
3256 cd_dbg(CD_DO_IOCTL, "entering DVD_AUTH\n");
3257 if (copy_from_user(&ai, (dvd_authinfo __user *)arg, sizeof(ai)))
3259 ret = dvd_do_auth(cdi, &ai);
3262 if (copy_to_user((dvd_authinfo __user *)arg, &ai, sizeof(ai)))
3267 static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3272 cd_dbg(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3273 ret = cdrom_get_next_writable(cdi, &next);
3276 if (copy_to_user((long __user *)arg, &next, sizeof(next)))
3281 static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3286 cd_dbg(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3287 ret = cdrom_get_last_written(cdi, &last);
3290 if (in_compat_syscall())
3291 return put_user(last, (__s32 __user *)arg);
3293 return put_user(last, (long __user *)arg);
3296 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3299 struct packet_command cgc;
3300 void __user *userptr = (void __user *)arg;
3302 memset(&cgc, 0, sizeof(cgc));
3304 /* build a unified command and queue it through
3305 cdo->generic_packet() */
3308 case CDROMREADMODE1:
3309 case CDROMREADMODE2:
3310 return mmc_ioctl_cdrom_read_data(cdi, userptr, &cgc, cmd);
3311 case CDROMREADAUDIO:
3312 return mmc_ioctl_cdrom_read_audio(cdi, userptr);
3314 return mmc_ioctl_cdrom_subchannel(cdi, userptr);
3316 return mmc_ioctl_cdrom_play_msf(cdi, userptr, &cgc);
3318 return mmc_ioctl_cdrom_play_blk(cdi, userptr, &cgc);
3321 return mmc_ioctl_cdrom_volume(cdi, userptr, &cgc, cmd);
3324 return mmc_ioctl_cdrom_start_stop(cdi, &cgc, cmd);
3327 return mmc_ioctl_cdrom_pause_resume(cdi, &cgc, cmd);
3328 case DVD_READ_STRUCT:
3329 return mmc_ioctl_dvd_read_struct(cdi, userptr, &cgc);
3331 return mmc_ioctl_dvd_auth(cdi, userptr);
3332 case CDROM_NEXT_WRITABLE:
3333 return mmc_ioctl_cdrom_next_writable(cdi, userptr);
3334 case CDROM_LAST_WRITTEN:
3335 return mmc_ioctl_cdrom_last_written(cdi, userptr);
3342 * Just about every imaginable ioctl is supported in the Uniform layer
3344 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
3346 int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
3347 fmode_t mode, unsigned int cmd, unsigned long arg)
3349 void __user *argp = (void __user *)arg;
3353 case CDROMMULTISESSION:
3354 return cdrom_ioctl_multisession(cdi, argp);
3356 return cdrom_ioctl_eject(cdi);
3357 case CDROMCLOSETRAY:
3358 return cdrom_ioctl_closetray(cdi);
3360 return cdrom_ioctl_eject_sw(cdi, arg);
3361 case CDROM_MEDIA_CHANGED:
3362 return cdrom_ioctl_media_changed(cdi, arg);
3363 case CDROM_TIMED_MEDIA_CHANGE:
3364 return cdrom_ioctl_timed_media_change(cdi, arg);
3365 case CDROM_SET_OPTIONS:
3366 return cdrom_ioctl_set_options(cdi, arg);
3367 case CDROM_CLEAR_OPTIONS:
3368 return cdrom_ioctl_clear_options(cdi, arg);
3369 case CDROM_SELECT_SPEED:
3370 return cdrom_ioctl_select_speed(cdi, arg);
3371 case CDROM_SELECT_DISC:
3372 return cdrom_ioctl_select_disc(cdi, arg);
3374 return cdrom_ioctl_reset(cdi, bdev);
3375 case CDROM_LOCKDOOR:
3376 return cdrom_ioctl_lock_door(cdi, arg);
3378 return cdrom_ioctl_debug(cdi, arg);
3379 case CDROM_GET_CAPABILITY:
3380 return cdrom_ioctl_get_capability(cdi);
3382 return cdrom_ioctl_get_mcn(cdi, argp);
3383 case CDROM_DRIVE_STATUS:
3384 return cdrom_ioctl_drive_status(cdi, arg);
3385 case CDROM_DISC_STATUS:
3386 return cdrom_ioctl_disc_status(cdi);
3387 case CDROM_CHANGER_NSLOTS:
3388 return cdrom_ioctl_changer_nslots(cdi);
3392 * Use the ioctls that are implemented through the generic_packet()
3393 * interface. this may look at bit funny, but if -ENOTTY is
3394 * returned that particular ioctl is not implemented and we
3395 * let it go through the device specific ones.
3397 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
3398 ret = mmc_ioctl(cdi, cmd, arg);
3404 * Note: most of the cd_dbg() calls are commented out here,
3405 * because they fill up the sys log when CD players poll
3410 return cdrom_ioctl_get_subchnl(cdi, argp);
3411 case CDROMREADTOCHDR:
3412 return cdrom_ioctl_read_tochdr(cdi, argp);
3413 case CDROMREADTOCENTRY:
3414 return cdrom_ioctl_read_tocentry(cdi, argp);
3416 return cdrom_ioctl_play_msf(cdi, argp);
3417 case CDROMPLAYTRKIND:
3418 return cdrom_ioctl_play_trkind(cdi, argp);
3420 return cdrom_ioctl_volctrl(cdi, argp);
3422 return cdrom_ioctl_volread(cdi, argp);
3427 return cdrom_ioctl_audioctl(cdi, cmd);
3433 EXPORT_SYMBOL(cdrom_get_last_written);
3434 EXPORT_SYMBOL(register_cdrom);
3435 EXPORT_SYMBOL(unregister_cdrom);
3436 EXPORT_SYMBOL(cdrom_open);
3437 EXPORT_SYMBOL(cdrom_release);
3438 EXPORT_SYMBOL(cdrom_ioctl);
3439 EXPORT_SYMBOL(cdrom_number_of_slots);
3440 EXPORT_SYMBOL(cdrom_mode_select);
3441 EXPORT_SYMBOL(cdrom_mode_sense);
3442 EXPORT_SYMBOL(init_cdrom_command);
3443 EXPORT_SYMBOL(cdrom_get_media_event);
3445 #ifdef CONFIG_SYSCTL
3447 #define CDROM_STR_SIZE 1000
3449 static struct cdrom_sysctl_settings {
3450 char info[CDROM_STR_SIZE]; /* general info */
3451 int autoclose; /* close tray upon mount, etc */
3452 int autoeject; /* eject on umount */
3453 int debug; /* turn on debugging messages */
3454 int lock; /* lock the door on device open */
3455 int check; /* check media type */
3456 } cdrom_sysctl_settings;
3458 enum cdrom_print_option {
3465 static int cdrom_print_info(const char *header, int val, char *info,
3466 int *pos, enum cdrom_print_option option)
3468 const int max_size = sizeof(cdrom_sysctl_settings.info);
3469 struct cdrom_device_info *cdi;
3472 ret = scnprintf(info + *pos, max_size - *pos, header);
3478 list_for_each_entry(cdi, &cdrom_list, list) {
3481 ret = scnprintf(info + *pos, max_size - *pos,
3485 ret = scnprintf(info + *pos, max_size - *pos,
3486 "\t%d", cdi->speed);
3489 ret = scnprintf(info + *pos, max_size - *pos,
3490 "\t%d", cdi->capacity);
3492 case CTL_CAPABILITY:
3493 ret = scnprintf(info + *pos, max_size - *pos,
3494 "\t%d", CDROM_CAN(val) != 0);
3497 pr_info("invalid option%d\n", option);
3508 static int cdrom_sysctl_info(struct ctl_table *ctl, int write,
3509 void *buffer, size_t *lenp, loff_t *ppos)
3512 char *info = cdrom_sysctl_settings.info;
3513 const int max_size = sizeof(cdrom_sysctl_settings.info);
3515 if (!*lenp || (*ppos && !write)) {
3520 mutex_lock(&cdrom_mutex);
3522 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3524 if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3526 if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3528 if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3530 if (cdrom_print_info("\nCan close tray:\t",
3531 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3533 if (cdrom_print_info("\nCan open tray:\t",
3534 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3536 if (cdrom_print_info("\nCan lock tray:\t",
3537 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3539 if (cdrom_print_info("\nCan change speed:",
3540 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3542 if (cdrom_print_info("\nCan select disk:",
3543 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3545 if (cdrom_print_info("\nCan read multisession:",
3546 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3548 if (cdrom_print_info("\nCan read MCN:\t",
3549 CDC_MCN, info, &pos, CTL_CAPABILITY))
3551 if (cdrom_print_info("\nReports media changed:",
3552 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3554 if (cdrom_print_info("\nCan play audio:\t",
3555 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3557 if (cdrom_print_info("\nCan write CD-R:\t",
3558 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3560 if (cdrom_print_info("\nCan write CD-RW:",
3561 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3563 if (cdrom_print_info("\nCan read DVD:\t",
3564 CDC_DVD, info, &pos, CTL_CAPABILITY))
3566 if (cdrom_print_info("\nCan write DVD-R:",
3567 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3569 if (cdrom_print_info("\nCan write DVD-RAM:",
3570 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3572 if (cdrom_print_info("\nCan read MRW:\t",
3573 CDC_MRW, info, &pos, CTL_CAPABILITY))
3575 if (cdrom_print_info("\nCan write MRW:\t",
3576 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3578 if (cdrom_print_info("\nCan write RAM:\t",
3579 CDC_RAM, info, &pos, CTL_CAPABILITY))
3581 if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3584 mutex_unlock(&cdrom_mutex);
3585 return proc_dostring(ctl, write, buffer, lenp, ppos);
3587 pr_info("info buffer too small\n");
3591 /* Unfortunately, per device settings are not implemented through
3592 procfs/sysctl yet. When they are, this will naturally disappear. For now
3593 just update all drives. Later this will become the template on which
3594 new registered drives will be based. */
3595 static void cdrom_update_settings(void)
3597 struct cdrom_device_info *cdi;
3599 mutex_lock(&cdrom_mutex);
3600 list_for_each_entry(cdi, &cdrom_list, list) {
3601 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3602 cdi->options |= CDO_AUTO_CLOSE;
3603 else if (!autoclose)
3604 cdi->options &= ~CDO_AUTO_CLOSE;
3605 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3606 cdi->options |= CDO_AUTO_EJECT;
3607 else if (!autoeject)
3608 cdi->options &= ~CDO_AUTO_EJECT;
3609 if (lockdoor && CDROM_CAN(CDC_LOCK))
3610 cdi->options |= CDO_LOCK;
3612 cdi->options &= ~CDO_LOCK;
3613 if (check_media_type)
3614 cdi->options |= CDO_CHECK_TYPE;
3616 cdi->options &= ~CDO_CHECK_TYPE;
3618 mutex_unlock(&cdrom_mutex);
3621 static int cdrom_sysctl_handler(struct ctl_table *ctl, int write,
3622 void *buffer, size_t *lenp, loff_t *ppos)
3626 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
3630 /* we only care for 1 or 0. */
3631 autoclose = !!cdrom_sysctl_settings.autoclose;
3632 autoeject = !!cdrom_sysctl_settings.autoeject;
3633 debug = !!cdrom_sysctl_settings.debug;
3634 lockdoor = !!cdrom_sysctl_settings.lock;
3635 check_media_type = !!cdrom_sysctl_settings.check;
3637 /* update the option flags according to the changes. we
3638 don't have per device options through sysctl yet,
3639 but we will have and then this will disappear. */
3640 cdrom_update_settings();
3646 /* Place files in /proc/sys/dev/cdrom */
3647 static struct ctl_table cdrom_table[] = {
3650 .data = &cdrom_sysctl_settings.info,
3651 .maxlen = CDROM_STR_SIZE,
3653 .proc_handler = cdrom_sysctl_info,
3656 .procname = "autoclose",
3657 .data = &cdrom_sysctl_settings.autoclose,
3658 .maxlen = sizeof(int),
3660 .proc_handler = cdrom_sysctl_handler,
3663 .procname = "autoeject",
3664 .data = &cdrom_sysctl_settings.autoeject,
3665 .maxlen = sizeof(int),
3667 .proc_handler = cdrom_sysctl_handler,
3670 .procname = "debug",
3671 .data = &cdrom_sysctl_settings.debug,
3672 .maxlen = sizeof(int),
3674 .proc_handler = cdrom_sysctl_handler,
3678 .data = &cdrom_sysctl_settings.lock,
3679 .maxlen = sizeof(int),
3681 .proc_handler = cdrom_sysctl_handler,
3684 .procname = "check_media",
3685 .data = &cdrom_sysctl_settings.check,
3686 .maxlen = sizeof(int),
3688 .proc_handler = cdrom_sysctl_handler
3692 static struct ctl_table_header *cdrom_sysctl_header;
3694 static void cdrom_sysctl_register(void)
3696 static atomic_t initialized = ATOMIC_INIT(0);
3698 if (!atomic_add_unless(&initialized, 1, 1))
3701 cdrom_sysctl_header = register_sysctl("dev/cdrom", cdrom_table);
3703 /* set the defaults */
3704 cdrom_sysctl_settings.autoclose = autoclose;
3705 cdrom_sysctl_settings.autoeject = autoeject;
3706 cdrom_sysctl_settings.debug = debug;
3707 cdrom_sysctl_settings.lock = lockdoor;
3708 cdrom_sysctl_settings.check = check_media_type;
3711 static void cdrom_sysctl_unregister(void)
3713 if (cdrom_sysctl_header)
3714 unregister_sysctl_table(cdrom_sysctl_header);
3717 #else /* CONFIG_SYSCTL */
3719 static void cdrom_sysctl_register(void)
3723 static void cdrom_sysctl_unregister(void)
3727 #endif /* CONFIG_SYSCTL */
3729 static int __init cdrom_init(void)
3731 cdrom_sysctl_register();
3736 static void __exit cdrom_exit(void)
3738 pr_info("Uniform CD-ROM driver unloaded\n");
3739 cdrom_sysctl_unregister();
3742 module_init(cdrom_init);
3743 module_exit(cdrom_exit);
3744 MODULE_LICENSE("GPL");