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>
287 #include <scsi/scsi_request.h>
289 /* used to tell the module to turn on full debugging messages */
291 /* default compatibility mode */
292 static bool autoclose=1;
293 static bool autoeject;
294 static bool lockdoor = 1;
295 /* will we ever get to use this... sigh. */
296 static bool check_media_type;
297 /* automatically restart mrw format */
298 static bool mrw_format_restart = 1;
299 module_param(debug, bool, 0);
300 module_param(autoclose, bool, 0);
301 module_param(autoeject, bool, 0);
302 module_param(lockdoor, bool, 0);
303 module_param(check_media_type, bool, 0);
304 module_param(mrw_format_restart, bool, 0);
306 static DEFINE_MUTEX(cdrom_mutex);
308 static const char *mrw_format_status[] = {
315 static const char *mrw_address_space[] = { "DMA", "GAA" };
317 #if (ERRLOGMASK != CD_NOTHING)
318 #define cd_dbg(type, fmt, ...) \
320 if ((ERRLOGMASK & type) || debug == 1) \
321 pr_debug(fmt, ##__VA_ARGS__); \
324 #define cd_dbg(type, fmt, ...) \
326 if (0 && (ERRLOGMASK & type) || debug == 1) \
327 pr_debug(fmt, ##__VA_ARGS__); \
331 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
332 a lot of places. This macro makes the code more clear. */
333 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
336 * Another popular OS uses 7 seconds as the hard timeout for default
337 * commands, so it is a good choice for us as well.
339 #define CDROM_DEF_TIMEOUT (7 * HZ)
341 /* Not-exported routines. */
343 static void cdrom_sysctl_register(void);
345 static LIST_HEAD(cdrom_list);
347 int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
348 struct packet_command *cgc)
351 cgc->sshdr->sense_key = 0x05;
352 cgc->sshdr->asc = 0x20;
353 cgc->sshdr->ascq = 0x00;
359 EXPORT_SYMBOL(cdrom_dummy_generic_packet);
361 static int cdrom_flush_cache(struct cdrom_device_info *cdi)
363 struct packet_command cgc;
365 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
366 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
368 cgc.timeout = 5 * 60 * HZ;
370 return cdi->ops->generic_packet(cdi, &cgc);
373 /* requires CD R/RW */
374 static int cdrom_get_disc_info(struct cdrom_device_info *cdi,
375 disc_information *di)
377 const struct cdrom_device_ops *cdo = cdi->ops;
378 struct packet_command cgc;
381 /* set up command and get the disc info */
382 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
383 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
384 cgc.cmd[8] = cgc.buflen = 2;
387 ret = cdo->generic_packet(cdi, &cgc);
391 /* not all drives have the same disc_info length, so requeue
392 * packet with the length the drive tells us it can supply
394 buflen = be16_to_cpu(di->disc_information_length) +
395 sizeof(di->disc_information_length);
397 if (buflen > sizeof(disc_information))
398 buflen = sizeof(disc_information);
400 cgc.cmd[8] = cgc.buflen = buflen;
401 ret = cdo->generic_packet(cdi, &cgc);
405 /* return actual fill size */
409 /* This macro makes sure we don't have to check on cdrom_device_ops
410 * existence in the run-time routines below. Change_capability is a
411 * hack to have the capability flags defined const, while we can still
412 * change it here without gcc complaining at every line.
414 #define ENSURE(cdo, call, bits) \
416 if (cdo->call == NULL) \
417 WARN_ON_ONCE((cdo)->capability & (bits)); \
421 * the first prototypes used 0x2c as the page code for the mrw mode page,
422 * subsequently this was changed to 0x03. probe the one used by this drive
424 static int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
426 struct packet_command cgc;
429 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
434 if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
435 cdi->mrw_mode_page = MRW_MODE_PC;
437 } else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
438 cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
445 static int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
447 struct packet_command cgc;
448 struct mrw_feature_desc *mfd;
449 unsigned char buffer[16];
454 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
456 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
457 cgc.cmd[3] = CDF_MRW;
458 cgc.cmd[8] = sizeof(buffer);
461 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
464 mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
465 if (be16_to_cpu(mfd->feature_code) != CDF_MRW)
469 if ((ret = cdrom_mrw_probe_pc(cdi))) {
477 static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
479 struct packet_command cgc;
480 unsigned char buffer[12];
483 pr_info("%sstarting format\n", cont ? "Re" : "");
486 * FmtData bit set (bit 4), format type is 1
488 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
489 cgc.cmd[0] = GPCMD_FORMAT_UNIT;
490 cgc.cmd[1] = (1 << 4) | 1;
492 cgc.timeout = 5 * 60 * HZ;
495 * 4 byte format list header, 8 byte format list descriptor
508 buffer[8] = 0x24 << 2;
511 ret = cdi->ops->generic_packet(cdi, &cgc);
513 pr_info("bgformat failed\n");
518 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
520 struct packet_command cgc;
522 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
523 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
526 * Session = 1, Track = 0
528 cgc.cmd[1] = !!immed;
531 cgc.timeout = 5 * 60 * HZ;
533 return cdi->ops->generic_packet(cdi, &cgc);
536 static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
541 ret = cdrom_get_disc_info(cdi, &di);
542 if (ret < 0 || ret < (int)offsetof(typeof(di),disc_type))
546 if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
547 pr_info("issuing MRW background format suspend\n");
548 ret = cdrom_mrw_bgformat_susp(cdi, 0);
551 if (!ret && cdi->media_written)
552 ret = cdrom_flush_cache(cdi);
557 static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
559 struct packet_command cgc;
560 struct mode_page_header *mph;
562 int ret, offset, size;
564 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
567 cgc.buflen = sizeof(buffer);
569 ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0);
573 mph = (struct mode_page_header *)buffer;
574 offset = be16_to_cpu(mph->desc_length);
575 size = be16_to_cpu(mph->mode_data_length) + 2;
577 buffer[offset + 3] = space;
580 ret = cdrom_mode_select(cdi, &cgc);
584 pr_info("%s: mrw address space %s selected\n",
585 cdi->name, mrw_address_space[space]);
589 int register_cdrom(struct gendisk *disk, struct cdrom_device_info *cdi)
591 static char banner_printed;
592 const struct cdrom_device_ops *cdo = cdi->ops;
594 cd_dbg(CD_OPEN, "entering register_cdrom\n");
596 if (cdo->open == NULL || cdo->release == NULL)
598 if (!banner_printed) {
599 pr_info("Uniform CD-ROM driver " REVISION "\n");
601 cdrom_sysctl_register();
607 ENSURE(cdo, drive_status, CDC_DRIVE_STATUS);
608 if (cdo->check_events == NULL && cdo->media_changed == NULL)
609 WARN_ON_ONCE(cdo->capability & (CDC_MEDIA_CHANGED | CDC_SELECT_DISC));
610 ENSURE(cdo, tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
611 ENSURE(cdo, lock_door, CDC_LOCK);
612 ENSURE(cdo, select_speed, CDC_SELECT_SPEED);
613 ENSURE(cdo, get_last_session, CDC_MULTI_SESSION);
614 ENSURE(cdo, get_mcn, CDC_MCN);
615 ENSURE(cdo, reset, CDC_RESET);
616 ENSURE(cdo, generic_packet, CDC_GENERIC_PACKET);
618 cdi->options = CDO_USE_FFLAGS;
620 if (autoclose == 1 && CDROM_CAN(CDC_CLOSE_TRAY))
621 cdi->options |= (int) CDO_AUTO_CLOSE;
622 if (autoeject == 1 && CDROM_CAN(CDC_OPEN_TRAY))
623 cdi->options |= (int) CDO_AUTO_EJECT;
625 cdi->options |= (int) CDO_LOCK;
626 if (check_media_type == 1)
627 cdi->options |= (int) CDO_CHECK_TYPE;
629 if (CDROM_CAN(CDC_MRW_W))
630 cdi->exit = cdrom_mrw_exit;
633 cdi->cdda_method = CDDA_BPC_FULL;
635 cdi->cdda_method = CDDA_OLD;
637 WARN_ON(!cdo->generic_packet);
639 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
640 mutex_lock(&cdrom_mutex);
641 list_add(&cdi->list, &cdrom_list);
642 mutex_unlock(&cdrom_mutex);
647 void unregister_cdrom(struct cdrom_device_info *cdi)
649 cd_dbg(CD_OPEN, "entering unregister_cdrom\n");
651 mutex_lock(&cdrom_mutex);
652 list_del(&cdi->list);
653 mutex_unlock(&cdrom_mutex);
658 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
661 int cdrom_get_media_event(struct cdrom_device_info *cdi,
662 struct media_event_desc *med)
664 struct packet_command cgc;
665 unsigned char buffer[8];
666 struct event_header *eh = (struct event_header *)buffer;
668 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
669 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
670 cgc.cmd[1] = 1; /* IMMED */
671 cgc.cmd[4] = 1 << 4; /* media event */
672 cgc.cmd[8] = sizeof(buffer);
675 if (cdi->ops->generic_packet(cdi, &cgc))
678 if (be16_to_cpu(eh->data_len) < sizeof(*med))
681 if (eh->nea || eh->notification_class != 0x4)
684 memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
688 static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
689 struct rwrt_feature_desc *rfd)
691 struct packet_command cgc;
695 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
697 cgc.cmd[0] = GPCMD_GET_CONFIGURATION; /* often 0x46 */
698 cgc.cmd[3] = CDF_RWRT; /* often 0x0020 */
699 cgc.cmd[8] = sizeof(buffer); /* often 0x18 */
702 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
705 memcpy(rfd, &buffer[sizeof(struct feature_header)], sizeof (*rfd));
709 static int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
711 struct packet_command cgc;
713 __be16 *feature_code;
716 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
718 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
719 cgc.cmd[3] = CDF_HWDM;
720 cgc.cmd[8] = sizeof(buffer);
723 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
726 feature_code = (__be16 *) &buffer[sizeof(struct feature_header)];
727 if (be16_to_cpu(*feature_code) == CDF_HWDM)
734 static int cdrom_is_random_writable(struct cdrom_device_info *cdi, int *write)
736 struct rwrt_feature_desc rfd;
741 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
744 if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
750 static int cdrom_media_erasable(struct cdrom_device_info *cdi)
755 ret = cdrom_get_disc_info(cdi, &di);
756 if (ret < 0 || ret < offsetof(typeof(di), n_first_track))
763 * FIXME: check RO bit
765 static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
767 int ret = cdrom_media_erasable(cdi);
770 * allow writable open if media info read worked and media is
771 * erasable, _or_ if it fails since not all drives support it
779 static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
785 * always reset to DMA lba space on open
787 if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_DMA)) {
788 pr_err("failed setting lba address space\n");
792 ret = cdrom_get_disc_info(cdi, &di);
793 if (ret < 0 || ret < offsetof(typeof(di),disc_type))
801 * 0 - not MRW formatted
802 * 1 - MRW bgformat started, but not running or complete
803 * 2 - MRW bgformat in progress
804 * 3 - MRW formatting complete
807 pr_info("open: mrw_status '%s'\n", mrw_format_status[di.mrw_status]);
810 else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE &&
812 ret = cdrom_mrw_bgformat(cdi, 1);
817 static int mo_open_write(struct cdrom_device_info *cdi)
819 struct packet_command cgc;
823 init_cdrom_command(&cgc, &buffer, 4, CGC_DATA_READ);
827 * obtain write protect information as per
828 * drivers/scsi/sd.c:sd_read_write_protect_flag
831 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
833 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_VENDOR_PAGE, 0);
836 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
839 /* drive gave us no info, let the user go ahead */
843 return buffer[3] & 0x80;
846 static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
848 struct rwrt_feature_desc rfd;
851 if ((ret = cdrom_has_defect_mgt(cdi)))
854 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
856 else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
859 cd_dbg(CD_OPEN, "can open for random write\n");
863 static void cdrom_mmc3_profile(struct cdrom_device_info *cdi)
865 struct packet_command cgc;
867 int ret, mmc3_profile;
869 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
871 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
873 cgc.cmd[2] = cgc.cmd[3] = 0; /* Starting Feature Number */
874 cgc.cmd[8] = sizeof(buffer); /* Allocation Length */
877 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
878 mmc3_profile = 0xffff;
880 mmc3_profile = (buffer[6] << 8) | buffer[7];
882 cdi->mmc3_profile = mmc3_profile;
885 static int cdrom_is_dvd_rw(struct cdrom_device_info *cdi)
887 switch (cdi->mmc3_profile) {
888 case 0x12: /* DVD-RAM */
889 case 0x1A: /* DVD+RW */
890 case 0x43: /* BD-RE */
898 * returns 0 for ok to open write, non-0 to disallow
900 static int cdrom_open_write(struct cdrom_device_info *cdi)
902 int mrw, mrw_write, ram_write;
906 if (!cdrom_is_mrw(cdi, &mrw_write))
909 if (CDROM_CAN(CDC_MO_DRIVE))
912 (void) cdrom_is_random_writable(cdi, &ram_write);
915 cdi->mask &= ~CDC_MRW;
917 cdi->mask |= CDC_MRW;
920 cdi->mask &= ~CDC_MRW_W;
922 cdi->mask |= CDC_MRW_W;
925 cdi->mask &= ~CDC_RAM;
927 cdi->mask |= CDC_RAM;
929 if (CDROM_CAN(CDC_MRW_W))
930 ret = cdrom_mrw_open_write(cdi);
931 else if (CDROM_CAN(CDC_DVD_RAM))
932 ret = cdrom_dvdram_open_write(cdi);
933 else if (CDROM_CAN(CDC_RAM) &&
934 !CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW|CDC_MO_DRIVE))
935 ret = cdrom_ram_open_write(cdi);
936 else if (CDROM_CAN(CDC_MO_DRIVE))
937 ret = mo_open_write(cdi);
938 else if (!cdrom_is_dvd_rw(cdi))
944 static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
946 struct packet_command cgc;
948 if (cdi->mmc3_profile != 0x1a) {
949 cd_dbg(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
953 if (!cdi->media_written) {
954 cd_dbg(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
958 pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi->name);
960 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
961 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
963 cdi->ops->generic_packet(cdi, &cgc);
965 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
966 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
967 cgc.timeout = 3000*HZ;
969 cdi->ops->generic_packet(cdi, &cgc);
971 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
972 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
973 cgc.cmd[2] = 2; /* Close session */
975 cgc.timeout = 3000*HZ;
976 cdi->ops->generic_packet(cdi, &cgc);
978 cdi->media_written = 0;
981 static int cdrom_close_write(struct cdrom_device_info *cdi)
984 return cdrom_flush_cache(cdi);
990 /* badly broken, I know. Is due for a fixup anytime. */
991 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype *tracks)
993 struct cdrom_tochdr header;
994 struct cdrom_tocentry entry;
1001 cd_dbg(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1003 if (!CDROM_CAN(CDC_PLAY_AUDIO)) {
1004 tracks->error = CDS_NO_INFO;
1008 /* Grab the TOC header so we can see how many tracks there are */
1009 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
1011 if (ret == -ENOMEDIUM)
1012 tracks->error = CDS_NO_DISC;
1014 tracks->error = CDS_NO_INFO;
1017 /* check what type of tracks are on this disc */
1018 entry.cdte_format = CDROM_MSF;
1019 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1020 entry.cdte_track = i;
1021 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1022 tracks->error = CDS_NO_INFO;
1025 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1026 if (entry.cdte_format == 0x10)
1028 else if (entry.cdte_format == 0x20)
1035 cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1036 i, entry.cdte_format, entry.cdte_ctrl);
1038 cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1039 header.cdth_trk1, tracks->audio, tracks->data,
1040 tracks->cdi, tracks->xa);
1044 int open_for_data(struct cdrom_device_info *cdi)
1047 const struct cdrom_device_ops *cdo = cdi->ops;
1049 cd_dbg(CD_OPEN, "entering open_for_data\n");
1050 /* Check if the driver can report drive status. If it can, we
1051 can do clever things. If it can't, well, we at least tried! */
1052 if (cdo->drive_status != NULL) {
1053 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1054 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1055 if (ret == CDS_TRAY_OPEN) {
1056 cd_dbg(CD_OPEN, "the tray is open...\n");
1057 /* can/may i close it? */
1058 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1059 cdi->options & CDO_AUTO_CLOSE) {
1060 cd_dbg(CD_OPEN, "trying to close the tray\n");
1061 ret=cdo->tray_move(cdi,0);
1063 cd_dbg(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1064 /* Ignore the error from the low
1065 level driver. We don't care why it
1066 couldn't close the tray. We only care
1067 that there is no disc in the drive,
1068 since that is the _REAL_ problem here.*/
1070 goto clean_up_and_return;
1073 cd_dbg(CD_OPEN, "bummer. this drive can't close the tray.\n");
1075 goto clean_up_and_return;
1077 /* Ok, the door should be closed now.. Check again */
1078 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1079 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1080 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1081 cd_dbg(CD_OPEN, "tray might not contain a medium\n");
1083 goto clean_up_and_return;
1085 cd_dbg(CD_OPEN, "the tray is now closed\n");
1087 /* the door should be closed now, check for the disc */
1088 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1089 if (ret!=CDS_DISC_OK) {
1091 goto clean_up_and_return;
1094 cdrom_count_tracks(cdi, &tracks);
1095 if (tracks.error == CDS_NO_DISC) {
1096 cd_dbg(CD_OPEN, "bummer. no disc.\n");
1098 goto clean_up_and_return;
1100 /* CD-Players which don't use O_NONBLOCK, workman
1101 * for example, need bit CDO_CHECK_TYPE cleared! */
1102 if (tracks.data==0) {
1103 if (cdi->options & CDO_CHECK_TYPE) {
1104 /* give people a warning shot, now that CDO_CHECK_TYPE
1105 is the default case! */
1106 cd_dbg(CD_OPEN, "bummer. wrong media type.\n");
1107 cd_dbg(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1108 (unsigned int)task_pid_nr(current));
1110 goto clean_up_and_return;
1113 cd_dbg(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set\n");
1117 cd_dbg(CD_OPEN, "all seems well, opening the devicen");
1119 /* all seems well, we can open the device */
1120 ret = cdo->open(cdi, 0); /* open for data */
1121 cd_dbg(CD_OPEN, "opening the device gave me %d\n", ret);
1122 /* After all this careful checking, we shouldn't have problems
1123 opening the device, but we don't want the device locked if
1124 this somehow fails... */
1126 cd_dbg(CD_OPEN, "open device failed\n");
1127 goto clean_up_and_return;
1129 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1130 cdo->lock_door(cdi, 1);
1131 cd_dbg(CD_OPEN, "door locked\n");
1133 cd_dbg(CD_OPEN, "device opened successfully\n");
1136 /* Something failed. Try to unlock the drive, because some drivers
1137 (notably ide-cd) lock the drive after every command. This produced
1138 a nasty bug where after mount failed, the drive would remain locked!
1139 This ensures that the drive gets unlocked after a mount fails. This
1140 is a goto to avoid bloating the driver with redundant code. */
1141 clean_up_and_return:
1142 cd_dbg(CD_OPEN, "open failed\n");
1143 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1144 cdo->lock_door(cdi, 0);
1145 cd_dbg(CD_OPEN, "door unlocked\n");
1150 /* We use the open-option O_NONBLOCK to indicate that the
1151 * purpose of opening is only for subsequent ioctl() calls; no device
1152 * integrity checks are performed.
1154 * We hope that all cd-player programs will adopt this convention. It
1155 * is in their own interest: device control becomes a lot easier
1158 int cdrom_open(struct cdrom_device_info *cdi, struct block_device *bdev,
1163 cd_dbg(CD_OPEN, "entering cdrom_open\n");
1165 /* if this was a O_NONBLOCK open and we should honor the flags,
1166 * do a quick open without drive/disc integrity checks. */
1168 if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) {
1169 ret = cdi->ops->open(cdi, 1);
1171 ret = open_for_data(cdi);
1174 if (CDROM_CAN(CDC_GENERIC_PACKET))
1175 cdrom_mmc3_profile(cdi);
1176 if (mode & FMODE_WRITE) {
1178 if (cdrom_open_write(cdi))
1180 if (!CDROM_CAN(CDC_RAM))
1183 cdi->media_written = 0;
1190 cd_dbg(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1191 cdi->name, cdi->use_count);
1194 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1195 cdi->ops->lock_door(cdi, 0);
1196 cd_dbg(CD_OPEN, "door unlocked\n");
1198 cdi->ops->release(cdi);
1204 /* This code is similar to that in open_for_data. The routine is called
1205 whenever an audio play operation is requested.
1207 static int check_for_audio_disc(struct cdrom_device_info *cdi,
1208 const struct cdrom_device_ops *cdo)
1212 cd_dbg(CD_OPEN, "entering check_for_audio_disc\n");
1213 if (!(cdi->options & CDO_CHECK_TYPE))
1215 if (cdo->drive_status != NULL) {
1216 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1217 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1218 if (ret == CDS_TRAY_OPEN) {
1219 cd_dbg(CD_OPEN, "the tray is open...\n");
1220 /* can/may i close it? */
1221 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1222 cdi->options & CDO_AUTO_CLOSE) {
1223 cd_dbg(CD_OPEN, "trying to close the tray\n");
1224 ret=cdo->tray_move(cdi,0);
1226 cd_dbg(CD_OPEN, "bummer. tried to close tray but failed.\n");
1227 /* Ignore the error from the low
1228 level driver. We don't care why it
1229 couldn't close the tray. We only care
1230 that there is no disc in the drive,
1231 since that is the _REAL_ problem here.*/
1235 cd_dbg(CD_OPEN, "bummer. this driver can't close the tray.\n");
1238 /* Ok, the door should be closed now.. Check again */
1239 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1240 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1241 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1244 if (ret!=CDS_DISC_OK) {
1245 cd_dbg(CD_OPEN, "bummer. disc isn't ready.\n");
1248 cd_dbg(CD_OPEN, "the tray is now closed\n");
1251 cdrom_count_tracks(cdi, &tracks);
1253 return(tracks.error);
1255 if (tracks.audio==0)
1256 return -EMEDIUMTYPE;
1261 void cdrom_release(struct cdrom_device_info *cdi, fmode_t mode)
1263 const struct cdrom_device_ops *cdo = cdi->ops;
1264 int opened_for_data;
1266 cd_dbg(CD_CLOSE, "entering cdrom_release\n");
1268 if (cdi->use_count > 0)
1271 if (cdi->use_count == 0) {
1272 cd_dbg(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n",
1274 cdrom_dvd_rw_close_write(cdi);
1276 if ((cdo->capability & CDC_LOCK) && !cdi->keeplocked) {
1277 cd_dbg(CD_CLOSE, "Unlocking door!\n");
1278 cdo->lock_door(cdi, 0);
1282 opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1283 !(mode & FMODE_NDELAY);
1286 * flush cache on last write release
1288 if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1289 cdrom_close_write(cdi);
1292 if (cdi->use_count == 0) { /* last process that closes dev*/
1293 if (opened_for_data &&
1294 cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1295 cdo->tray_move(cdi, 1);
1299 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1300 struct cdrom_changer_info *buf)
1302 struct packet_command cgc;
1303 const struct cdrom_device_ops *cdo = cdi->ops;
1307 * Sanyo changer isn't spec compliant (doesn't use regular change
1308 * LOAD_UNLOAD command, and it doesn't implement the mech status
1311 if (cdi->sanyo_slot) {
1312 buf->hdr.nslots = 3;
1313 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1314 for (length = 0; length < 3; length++) {
1315 buf->slots[length].disc_present = 1;
1316 buf->slots[length].change = 0;
1321 length = sizeof(struct cdrom_mechstat_header) +
1322 cdi->capacity * sizeof(struct cdrom_slot);
1324 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1325 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1326 cgc.cmd[8] = (length >> 8) & 0xff;
1327 cgc.cmd[9] = length & 0xff;
1328 return cdo->generic_packet(cdi, &cgc);
1331 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1333 struct cdrom_changer_info *info;
1336 cd_dbg(CD_CHANGER, "entering cdrom_slot_status()\n");
1337 if (cdi->sanyo_slot)
1340 info = kmalloc(sizeof(*info), GFP_KERNEL);
1344 if ((ret = cdrom_read_mech_status(cdi, info)))
1347 if (info->slots[slot].disc_present)
1357 /* Return the number of slots for an ATAPI/SCSI cdrom,
1358 * return 1 if not a changer.
1360 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1364 struct cdrom_changer_info *info;
1366 cd_dbg(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1367 /* cdrom_read_mech_status requires a valid value for capacity: */
1370 info = kmalloc(sizeof(*info), GFP_KERNEL);
1374 if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1375 nslots = info->hdr.nslots;
1382 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1383 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1385 struct packet_command cgc;
1387 cd_dbg(CD_CHANGER, "entering cdrom_load_unload()\n");
1388 if (cdi->sanyo_slot && slot < 0)
1391 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1392 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1393 cgc.cmd[4] = 2 + (slot >= 0);
1395 cgc.timeout = 60 * HZ;
1397 /* The Sanyo 3 CD changer uses byte 7 of the
1398 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1399 using the GPCMD_LOAD_UNLOAD opcode. */
1400 if (cdi->sanyo_slot && -1 < slot) {
1401 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1403 cgc.cmd[4] = cgc.cmd[8] = 0;
1404 cdi->sanyo_slot = slot ? slot : 3;
1407 return cdi->ops->generic_packet(cdi, &cgc);
1410 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1412 struct cdrom_changer_info *info;
1416 cd_dbg(CD_CHANGER, "entering cdrom_select_disc()\n");
1417 if (!CDROM_CAN(CDC_SELECT_DISC))
1418 return -EDRIVE_CANT_DO_THIS;
1420 if (cdi->ops->check_events)
1421 cdi->ops->check_events(cdi, 0, slot);
1423 cdi->ops->media_changed(cdi, slot);
1425 if (slot == CDSL_NONE) {
1426 /* set media changed bits, on both queues */
1427 cdi->mc_flags = 0x3;
1428 return cdrom_load_unload(cdi, -1);
1431 info = kmalloc(sizeof(*info), GFP_KERNEL);
1435 if ((ret = cdrom_read_mech_status(cdi, info))) {
1440 curslot = info->hdr.curslot;
1443 if (cdi->use_count > 1 || cdi->keeplocked) {
1444 if (slot == CDSL_CURRENT) {
1451 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1452 which is useful if it had been previously unloaded.
1453 Whether it can or not, it returns the current slot.
1454 Similarly, if slot happens to be the current one, we still
1456 if (slot == CDSL_CURRENT)
1459 /* set media changed bits on both queues */
1460 cdi->mc_flags = 0x3;
1461 if ((ret = cdrom_load_unload(cdi, slot)))
1468 * As cdrom implements an extra ioctl consumer for media changed
1469 * event, it needs to buffer ->check_events() output, such that event
1470 * is not lost for both the usual VFS and ioctl paths.
1471 * cdi->{vfs|ioctl}_events are used to buffer pending events for each
1474 * XXX: Locking is non-existent. cdi->ops->check_events() can be
1475 * called in parallel and buffering fields are accessed without any
1476 * exclusion. The original media_changed code had the same problem.
1477 * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1478 * and remove this cruft altogether. It doesn't have much usefulness
1481 static void cdrom_update_events(struct cdrom_device_info *cdi,
1482 unsigned int clearing)
1484 unsigned int events;
1486 events = cdi->ops->check_events(cdi, clearing, CDSL_CURRENT);
1487 cdi->vfs_events |= events;
1488 cdi->ioctl_events |= events;
1491 unsigned int cdrom_check_events(struct cdrom_device_info *cdi,
1492 unsigned int clearing)
1494 unsigned int events;
1496 cdrom_update_events(cdi, clearing);
1497 events = cdi->vfs_events;
1498 cdi->vfs_events = 0;
1501 EXPORT_SYMBOL(cdrom_check_events);
1503 /* We want to make media_changed accessible to the user through an
1504 * ioctl. The main problem now is that we must double-buffer the
1505 * low-level implementation, to assure that the VFS and the user both
1506 * see a medium change once.
1510 int media_changed(struct cdrom_device_info *cdi, int queue)
1512 unsigned int mask = (1 << (queue & 1));
1513 int ret = !!(cdi->mc_flags & mask);
1516 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1519 /* changed since last call? */
1520 if (cdi->ops->check_events) {
1521 BUG_ON(!queue); /* shouldn't be called from VFS path */
1522 cdrom_update_events(cdi, DISK_EVENT_MEDIA_CHANGE);
1523 changed = cdi->ioctl_events & DISK_EVENT_MEDIA_CHANGE;
1524 cdi->ioctl_events = 0;
1526 changed = cdi->ops->media_changed(cdi, CDSL_CURRENT);
1529 cdi->mc_flags = 0x3; /* set bit on both queues */
1531 cdi->media_written = 0;
1534 cdi->mc_flags &= ~mask; /* clear bit */
1538 int cdrom_media_changed(struct cdrom_device_info *cdi)
1540 /* This talks to the VFS, which doesn't like errors - just 1 or 0.
1541 * Returning "0" is always safe (media hasn't been changed). Do that
1542 * if the low-level cdrom driver dosn't support media changed. */
1543 if (cdi == NULL || cdi->ops->media_changed == NULL)
1545 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1547 return media_changed(cdi, 0);
1550 /* Requests to the low-level drivers will /always/ be done in the
1551 following format convention:
1553 CDROM_LBA: all data-related requests.
1554 CDROM_MSF: all audio-related requests.
1556 However, a low-level implementation is allowed to refuse this
1557 request, and return information in its own favorite format.
1559 It doesn't make sense /at all/ to ask for a play_audio in LBA
1560 format, or ask for multi-session info in MSF format. However, for
1561 backward compatibility these format requests will be satisfied, but
1562 the requests to the low-level drivers will be sanitized in the more
1563 meaningful format indicated above.
1567 void sanitize_format(union cdrom_addr *addr,
1568 u_char * curr, u_char requested)
1570 if (*curr == requested)
1571 return; /* nothing to be done! */
1572 if (requested == CDROM_LBA) {
1573 addr->lba = (int) addr->msf.frame +
1574 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1575 } else { /* CDROM_MSF */
1576 int lba = addr->lba;
1577 addr->msf.frame = lba % 75;
1580 addr->msf.second = lba % 60;
1581 addr->msf.minute = lba / 60;
1586 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1589 memset(cgc, 0, sizeof(struct packet_command));
1591 memset(buf, 0, len);
1592 cgc->buffer = (char *) buf;
1594 cgc->data_direction = type;
1595 cgc->timeout = CDROM_DEF_TIMEOUT;
1600 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1601 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1603 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1605 cgc->cmd[0] = GPCMD_REPORT_KEY;
1606 cgc->cmd[10] = type | (agid << 6);
1608 case 0: case 8: case 5: {
1621 cgc->cmd[9] = cgc->buflen;
1622 cgc->data_direction = CGC_DATA_READ;
1625 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1627 cgc->cmd[0] = GPCMD_SEND_KEY;
1628 cgc->cmd[10] = type | (agid << 6);
1643 cgc->cmd[9] = cgc->buflen;
1644 cgc->data_direction = CGC_DATA_WRITE;
1647 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1651 struct packet_command cgc;
1652 const struct cdrom_device_ops *cdo = cdi->ops;
1653 rpc_state_t rpc_state;
1655 memset(buf, 0, sizeof(buf));
1656 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1660 case DVD_LU_SEND_AGID:
1661 cd_dbg(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1663 setup_report_key(&cgc, ai->lsa.agid, 0);
1665 if ((ret = cdo->generic_packet(cdi, &cgc)))
1668 ai->lsa.agid = buf[7] >> 6;
1669 /* Returning data, let host change state */
1672 case DVD_LU_SEND_KEY1:
1673 cd_dbg(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1674 setup_report_key(&cgc, ai->lsk.agid, 2);
1676 if ((ret = cdo->generic_packet(cdi, &cgc)))
1679 copy_key(ai->lsk.key, &buf[4]);
1680 /* Returning data, let host change state */
1683 case DVD_LU_SEND_CHALLENGE:
1684 cd_dbg(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1685 setup_report_key(&cgc, ai->lsc.agid, 1);
1687 if ((ret = cdo->generic_packet(cdi, &cgc)))
1690 copy_chal(ai->lsc.chal, &buf[4]);
1691 /* Returning data, let host change state */
1695 case DVD_LU_SEND_TITLE_KEY:
1696 cd_dbg(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1698 setup_report_key(&cgc, ai->lstk.agid, 4);
1699 cgc.cmd[5] = ai->lstk.lba;
1700 cgc.cmd[4] = ai->lstk.lba >> 8;
1701 cgc.cmd[3] = ai->lstk.lba >> 16;
1702 cgc.cmd[2] = ai->lstk.lba >> 24;
1704 if ((ret = cdo->generic_packet(cdi, &cgc)))
1707 ai->lstk.cpm = (buf[4] >> 7) & 1;
1708 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1709 ai->lstk.cgms = (buf[4] >> 4) & 3;
1710 copy_key(ai->lstk.title_key, &buf[5]);
1711 /* Returning data, let host change state */
1714 case DVD_LU_SEND_ASF:
1715 cd_dbg(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1716 setup_report_key(&cgc, ai->lsasf.agid, 5);
1718 if ((ret = cdo->generic_packet(cdi, &cgc)))
1721 ai->lsasf.asf = buf[7] & 1;
1724 /* LU data receive (LU changes state) */
1725 case DVD_HOST_SEND_CHALLENGE:
1726 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1727 setup_send_key(&cgc, ai->hsc.agid, 1);
1729 copy_chal(&buf[4], ai->hsc.chal);
1731 if ((ret = cdo->generic_packet(cdi, &cgc)))
1734 ai->type = DVD_LU_SEND_KEY1;
1737 case DVD_HOST_SEND_KEY2:
1738 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1739 setup_send_key(&cgc, ai->hsk.agid, 3);
1741 copy_key(&buf[4], ai->hsk.key);
1743 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1744 ai->type = DVD_AUTH_FAILURE;
1747 ai->type = DVD_AUTH_ESTABLISHED;
1751 case DVD_INVALIDATE_AGID:
1753 cd_dbg(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1754 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1755 if ((ret = cdo->generic_packet(cdi, &cgc)))
1759 /* Get region settings */
1760 case DVD_LU_SEND_RPC_STATE:
1761 cd_dbg(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1762 setup_report_key(&cgc, 0, 8);
1763 memset(&rpc_state, 0, sizeof(rpc_state_t));
1764 cgc.buffer = (char *) &rpc_state;
1766 if ((ret = cdo->generic_packet(cdi, &cgc)))
1769 ai->lrpcs.type = rpc_state.type_code;
1770 ai->lrpcs.vra = rpc_state.vra;
1771 ai->lrpcs.ucca = rpc_state.ucca;
1772 ai->lrpcs.region_mask = rpc_state.region_mask;
1773 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1776 /* Set region settings */
1777 case DVD_HOST_SEND_RPC_STATE:
1778 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1779 setup_send_key(&cgc, 0, 6);
1781 buf[4] = ai->hrpcs.pdrc;
1783 if ((ret = cdo->generic_packet(cdi, &cgc)))
1788 cd_dbg(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1795 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s,
1796 struct packet_command *cgc)
1798 unsigned char buf[21], *base;
1799 struct dvd_layer *layer;
1800 const struct cdrom_device_ops *cdo = cdi->ops;
1801 int ret, layer_num = s->physical.layer_num;
1803 if (layer_num >= DVD_LAYERS)
1806 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1807 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1808 cgc->cmd[6] = layer_num;
1809 cgc->cmd[7] = s->type;
1810 cgc->cmd[9] = cgc->buflen & 0xff;
1813 * refrain from reporting errors on non-existing layers (mainly)
1817 ret = cdo->generic_packet(cdi, cgc);
1822 layer = &s->physical.layer[layer_num];
1825 * place the data... really ugly, but at least we won't have to
1826 * worry about endianess in userspace.
1828 memset(layer, 0, sizeof(*layer));
1829 layer->book_version = base[0] & 0xf;
1830 layer->book_type = base[0] >> 4;
1831 layer->min_rate = base[1] & 0xf;
1832 layer->disc_size = base[1] >> 4;
1833 layer->layer_type = base[2] & 0xf;
1834 layer->track_path = (base[2] >> 4) & 1;
1835 layer->nlayers = (base[2] >> 5) & 3;
1836 layer->track_density = base[3] & 0xf;
1837 layer->linear_density = base[3] >> 4;
1838 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1839 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1840 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1841 layer->bca = base[16] >> 7;
1846 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s,
1847 struct packet_command *cgc)
1851 const struct cdrom_device_ops *cdo = cdi->ops;
1853 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1854 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1855 cgc->cmd[6] = s->copyright.layer_num;
1856 cgc->cmd[7] = s->type;
1857 cgc->cmd[8] = cgc->buflen >> 8;
1858 cgc->cmd[9] = cgc->buflen & 0xff;
1860 ret = cdo->generic_packet(cdi, cgc);
1864 s->copyright.cpst = buf[4];
1865 s->copyright.rmi = buf[5];
1870 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s,
1871 struct packet_command *cgc)
1875 const struct cdrom_device_ops *cdo = cdi->ops;
1877 size = sizeof(s->disckey.value) + 4;
1879 buf = kmalloc(size, GFP_KERNEL);
1883 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1884 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1885 cgc->cmd[7] = s->type;
1886 cgc->cmd[8] = size >> 8;
1887 cgc->cmd[9] = size & 0xff;
1888 cgc->cmd[10] = s->disckey.agid << 6;
1890 ret = cdo->generic_packet(cdi, cgc);
1892 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1898 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1899 struct packet_command *cgc)
1901 int ret, size = 4 + 188;
1903 const struct cdrom_device_ops *cdo = cdi->ops;
1905 buf = kmalloc(size, GFP_KERNEL);
1909 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1910 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1911 cgc->cmd[7] = s->type;
1912 cgc->cmd[9] = cgc->buflen & 0xff;
1914 ret = cdo->generic_packet(cdi, cgc);
1918 s->bca.len = buf[0] << 8 | buf[1];
1919 if (s->bca.len < 12 || s->bca.len > 188) {
1920 cd_dbg(CD_WARNING, "Received invalid BCA length (%d)\n",
1925 memcpy(s->bca.value, &buf[4], s->bca.len);
1932 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1933 struct packet_command *cgc)
1937 const struct cdrom_device_ops *cdo = cdi->ops;
1939 size = sizeof(s->manufact.value) + 4;
1941 buf = kmalloc(size, GFP_KERNEL);
1945 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1946 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1947 cgc->cmd[7] = s->type;
1948 cgc->cmd[8] = size >> 8;
1949 cgc->cmd[9] = size & 0xff;
1951 ret = cdo->generic_packet(cdi, cgc);
1955 s->manufact.len = buf[0] << 8 | buf[1];
1956 if (s->manufact.len < 0) {
1957 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d)\n",
1961 if (s->manufact.len > 2048) {
1962 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d): truncating to 2048\n",
1964 s->manufact.len = 2048;
1966 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1974 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1975 struct packet_command *cgc)
1978 case DVD_STRUCT_PHYSICAL:
1979 return dvd_read_physical(cdi, s, cgc);
1981 case DVD_STRUCT_COPYRIGHT:
1982 return dvd_read_copyright(cdi, s, cgc);
1984 case DVD_STRUCT_DISCKEY:
1985 return dvd_read_disckey(cdi, s, cgc);
1987 case DVD_STRUCT_BCA:
1988 return dvd_read_bca(cdi, s, cgc);
1990 case DVD_STRUCT_MANUFACT:
1991 return dvd_read_manufact(cdi, s, cgc);
1994 cd_dbg(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
2000 int cdrom_mode_sense(struct cdrom_device_info *cdi,
2001 struct packet_command *cgc,
2002 int page_code, int page_control)
2004 const struct cdrom_device_ops *cdo = cdi->ops;
2006 memset(cgc->cmd, 0, sizeof(cgc->cmd));
2008 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
2009 cgc->cmd[2] = page_code | (page_control << 6);
2010 cgc->cmd[7] = cgc->buflen >> 8;
2011 cgc->cmd[8] = cgc->buflen & 0xff;
2012 cgc->data_direction = CGC_DATA_READ;
2013 return cdo->generic_packet(cdi, cgc);
2016 int cdrom_mode_select(struct cdrom_device_info *cdi,
2017 struct packet_command *cgc)
2019 const struct cdrom_device_ops *cdo = cdi->ops;
2021 memset(cgc->cmd, 0, sizeof(cgc->cmd));
2022 memset(cgc->buffer, 0, 2);
2023 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
2024 cgc->cmd[1] = 0x10; /* PF */
2025 cgc->cmd[7] = cgc->buflen >> 8;
2026 cgc->cmd[8] = cgc->buflen & 0xff;
2027 cgc->data_direction = CGC_DATA_WRITE;
2028 return cdo->generic_packet(cdi, cgc);
2031 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
2032 struct cdrom_subchnl *subchnl, int mcn)
2034 const struct cdrom_device_ops *cdo = cdi->ops;
2035 struct packet_command cgc;
2039 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
2040 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
2041 cgc.cmd[1] = subchnl->cdsc_format;/* MSF or LBA addressing */
2042 cgc.cmd[2] = 0x40; /* request subQ data */
2043 cgc.cmd[3] = mcn ? 2 : 1;
2046 if ((ret = cdo->generic_packet(cdi, &cgc)))
2049 subchnl->cdsc_audiostatus = cgc.buffer[1];
2050 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
2051 subchnl->cdsc_trk = cgc.buffer[6];
2052 subchnl->cdsc_ind = cgc.buffer[7];
2054 if (subchnl->cdsc_format == CDROM_LBA) {
2055 subchnl->cdsc_absaddr.lba = ((cgc.buffer[8] << 24) |
2056 (cgc.buffer[9] << 16) |
2057 (cgc.buffer[10] << 8) |
2059 subchnl->cdsc_reladdr.lba = ((cgc.buffer[12] << 24) |
2060 (cgc.buffer[13] << 16) |
2061 (cgc.buffer[14] << 8) |
2064 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
2065 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
2066 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
2067 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
2068 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
2069 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
2076 * Specific READ_10 interface
2078 static int cdrom_read_cd(struct cdrom_device_info *cdi,
2079 struct packet_command *cgc, int lba,
2080 int blocksize, int nblocks)
2082 const struct cdrom_device_ops *cdo = cdi->ops;
2084 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2085 cgc->cmd[0] = GPCMD_READ_10;
2086 cgc->cmd[2] = (lba >> 24) & 0xff;
2087 cgc->cmd[3] = (lba >> 16) & 0xff;
2088 cgc->cmd[4] = (lba >> 8) & 0xff;
2089 cgc->cmd[5] = lba & 0xff;
2090 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2091 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2092 cgc->cmd[8] = nblocks & 0xff;
2093 cgc->buflen = blocksize * nblocks;
2094 return cdo->generic_packet(cdi, cgc);
2097 /* very generic interface for reading the various types of blocks */
2098 static int cdrom_read_block(struct cdrom_device_info *cdi,
2099 struct packet_command *cgc,
2100 int lba, int nblocks, int format, int blksize)
2102 const struct cdrom_device_ops *cdo = cdi->ops;
2104 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2105 cgc->cmd[0] = GPCMD_READ_CD;
2106 /* expected sector size - cdda,mode1,etc. */
2107 cgc->cmd[1] = format << 2;
2108 /* starting address */
2109 cgc->cmd[2] = (lba >> 24) & 0xff;
2110 cgc->cmd[3] = (lba >> 16) & 0xff;
2111 cgc->cmd[4] = (lba >> 8) & 0xff;
2112 cgc->cmd[5] = lba & 0xff;
2113 /* number of blocks */
2114 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2115 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2116 cgc->cmd[8] = nblocks & 0xff;
2117 cgc->buflen = blksize * nblocks;
2119 /* set the header info returned */
2121 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
2122 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
2123 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
2124 default : cgc->cmd[9] = 0x10;
2127 return cdo->generic_packet(cdi, cgc);
2130 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2131 int lba, int nframes)
2133 struct packet_command cgc;
2137 cdi->last_sense = 0;
2139 memset(&cgc, 0, sizeof(cgc));
2142 * start with will ra.nframes size, back down if alloc fails
2146 cgc.buffer = kmalloc_array(nr, CD_FRAMESIZE_RAW, GFP_KERNEL);
2156 cgc.data_direction = CGC_DATA_READ;
2157 while (nframes > 0) {
2161 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2164 if (copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2168 ubuf += CD_FRAMESIZE_RAW * nr;
2176 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2177 int lba, int nframes)
2179 struct request_queue *q = cdi->disk->queue;
2181 struct scsi_request *req;
2189 if (!blk_queue_scsi_passthrough(q)) {
2191 "Attempt read CDDA info through a non-SCSI queue\n");
2195 cdi->last_sense = 0;
2199 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2201 if (nr * CD_FRAMESIZE_RAW > (queue_max_sectors(q) << 9))
2202 nr = (queue_max_sectors(q) << 9) / CD_FRAMESIZE_RAW;
2204 len = nr * CD_FRAMESIZE_RAW;
2206 rq = blk_get_request(q, REQ_OP_SCSI_IN, 0);
2213 ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL);
2215 blk_put_request(rq);
2219 req->cmd[0] = GPCMD_READ_CD;
2220 req->cmd[1] = 1 << 2;
2221 req->cmd[2] = (lba >> 24) & 0xff;
2222 req->cmd[3] = (lba >> 16) & 0xff;
2223 req->cmd[4] = (lba >> 8) & 0xff;
2224 req->cmd[5] = lba & 0xff;
2225 req->cmd[6] = (nr >> 16) & 0xff;
2226 req->cmd[7] = (nr >> 8) & 0xff;
2227 req->cmd[8] = nr & 0xff;
2231 rq->timeout = 60 * HZ;
2234 blk_execute_rq(q, cdi->disk, rq, 0);
2235 if (scsi_req(rq)->result) {
2236 struct scsi_sense_hdr sshdr;
2239 scsi_normalize_sense(req->sense, req->sense_len,
2241 cdi->last_sense = sshdr.sense_key;
2244 if (blk_rq_unmap_user(bio))
2246 blk_put_request(rq);
2259 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2260 int lba, int nframes)
2264 if (cdi->cdda_method == CDDA_OLD)
2265 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2269 * for anything else than success and io error, we need to retry
2271 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2272 if (!ret || ret != -EIO)
2276 * I've seen drives get sense 4/8/3 udma crc errors on multi
2277 * frame dma, so drop to single frame dma if we need to
2279 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2280 pr_info("dropping to single frame dma\n");
2281 cdi->cdda_method = CDDA_BPC_SINGLE;
2286 * so we have an io error of some sort with multi frame dma. if the
2287 * condition wasn't a hardware error
2288 * problems, not for any error
2290 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2293 pr_info("dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2294 cdi->cdda_method = CDDA_OLD;
2295 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2298 int cdrom_multisession(struct cdrom_device_info *cdi,
2299 struct cdrom_multisession *info)
2301 u8 requested_format;
2304 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2307 requested_format = info->addr_format;
2308 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2310 info->addr_format = CDROM_LBA;
2312 ret = cdi->ops->get_last_session(cdi, info);
2314 sanitize_format(&info->addr, &info->addr_format,
2318 EXPORT_SYMBOL_GPL(cdrom_multisession);
2320 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2323 struct cdrom_multisession info;
2326 cd_dbg(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2328 if (copy_from_user(&info, argp, sizeof(info)))
2330 ret = cdrom_multisession(cdi, &info);
2333 if (copy_to_user(argp, &info, sizeof(info)))
2336 cd_dbg(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2340 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2342 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT\n");
2344 if (!CDROM_CAN(CDC_OPEN_TRAY))
2346 if (cdi->use_count != 1 || cdi->keeplocked)
2348 if (CDROM_CAN(CDC_LOCK)) {
2349 int ret = cdi->ops->lock_door(cdi, 0);
2354 return cdi->ops->tray_move(cdi, 1);
2357 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2359 cd_dbg(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2361 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2363 return cdi->ops->tray_move(cdi, 0);
2366 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2369 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2371 if (!CDROM_CAN(CDC_OPEN_TRAY))
2373 if (cdi->keeplocked)
2376 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2378 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2382 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2385 struct cdrom_changer_info *info;
2388 cd_dbg(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2390 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2393 /* cannot select disc or select current disc */
2394 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2395 return media_changed(cdi, 1);
2397 if (arg >= cdi->capacity)
2400 info = kmalloc(sizeof(*info), GFP_KERNEL);
2404 ret = cdrom_read_mech_status(cdi, info);
2406 ret = info->slots[arg].change;
2411 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2414 cd_dbg(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2417 * Options need to be in sync with capability.
2418 * Too late for that, so we have to check each one separately.
2421 case CDO_USE_FFLAGS:
2422 case CDO_CHECK_TYPE:
2425 if (!CDROM_CAN(CDC_LOCK))
2429 return cdi->options;
2430 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2432 if (!CDROM_CAN(arg))
2435 cdi->options |= (int) arg;
2436 return cdi->options;
2439 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2442 cd_dbg(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2444 cdi->options &= ~(int) arg;
2445 return cdi->options;
2448 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2451 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2453 if (!CDROM_CAN(CDC_SELECT_SPEED))
2455 return cdi->ops->select_speed(cdi, arg);
2458 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2461 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2463 if (!CDROM_CAN(CDC_SELECT_DISC))
2466 if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2467 if (arg >= cdi->capacity)
2472 * ->select_disc is a hook to allow a driver-specific way of
2473 * seleting disc. However, since there is no equivalent hook for
2474 * cdrom_slot_status this may not actually be useful...
2476 if (cdi->ops->select_disc)
2477 return cdi->ops->select_disc(cdi, arg);
2479 cd_dbg(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2480 return cdrom_select_disc(cdi, arg);
2483 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2484 struct block_device *bdev)
2486 cd_dbg(CD_DO_IOCTL, "entering CDROM_RESET\n");
2488 if (!capable(CAP_SYS_ADMIN))
2490 if (!CDROM_CAN(CDC_RESET))
2492 invalidate_bdev(bdev);
2493 return cdi->ops->reset(cdi);
2496 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2499 cd_dbg(CD_DO_IOCTL, "%socking door\n", arg ? "L" : "Unl");
2501 if (!CDROM_CAN(CDC_LOCK))
2502 return -EDRIVE_CANT_DO_THIS;
2504 cdi->keeplocked = arg ? 1 : 0;
2507 * Don't unlock the door on multiple opens by default, but allow
2510 if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2512 return cdi->ops->lock_door(cdi, arg);
2515 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2518 cd_dbg(CD_DO_IOCTL, "%sabling debug\n", arg ? "En" : "Dis");
2520 if (!capable(CAP_SYS_ADMIN))
2522 debug = arg ? 1 : 0;
2526 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2528 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2529 return (cdi->ops->capability & ~cdi->mask);
2533 * The following function is implemented, although very few audio
2534 * discs give Universal Product Code information, which should just be
2535 * the Medium Catalog Number on the box. Note, that the way the code
2536 * is written on the CD is /not/ uniform across all discs!
2538 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2541 struct cdrom_mcn mcn;
2544 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2546 if (!(cdi->ops->capability & CDC_MCN))
2548 ret = cdi->ops->get_mcn(cdi, &mcn);
2552 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2554 cd_dbg(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2558 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2561 cd_dbg(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2563 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2565 if (!CDROM_CAN(CDC_SELECT_DISC) ||
2566 (arg == CDSL_CURRENT || arg == CDSL_NONE))
2567 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2568 if (arg >= cdi->capacity)
2570 return cdrom_slot_status(cdi, arg);
2574 * Ok, this is where problems start. The current interface for the
2575 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2576 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunately, while this
2577 * is often the case, it is also very common for CDs to have some tracks
2578 * with data, and some tracks with audio. Just because I feel like it,
2579 * I declare the following to be the best way to cope. If the CD has ANY
2580 * data tracks on it, it will be returned as a data CD. If it has any XA
2581 * tracks, I will return it as that. Now I could simplify this interface
2582 * by combining these returns with the above, but this more clearly
2583 * demonstrates the problem with the current interface. Too bad this
2584 * wasn't designed to use bitmasks... -Erik
2586 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2587 * User level programmers might feel the ioctl is not very useful.
2590 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2594 cd_dbg(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2596 cdrom_count_tracks(cdi, &tracks);
2598 return tracks.error;
2600 /* Policy mode on */
2601 if (tracks.audio > 0) {
2602 if (!tracks.data && !tracks.cdi && !tracks.xa)
2612 if (tracks.data > 0)
2614 /* Policy mode off */
2616 cd_dbg(CD_WARNING, "This disc doesn't have any tracks I recognize!\n");
2620 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2622 cd_dbg(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2623 return cdi->capacity;
2626 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2629 struct cdrom_subchnl q;
2633 /* cd_dbg(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2635 if (copy_from_user(&q, argp, sizeof(q)))
2638 requested = q.cdsc_format;
2639 if (requested != CDROM_MSF && requested != CDROM_LBA)
2641 q.cdsc_format = CDROM_MSF;
2643 ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2647 back = q.cdsc_format; /* local copy */
2648 sanitize_format(&q.cdsc_absaddr, &back, requested);
2649 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2651 if (copy_to_user(argp, &q, sizeof(q)))
2653 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2657 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2660 struct cdrom_tochdr header;
2663 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2665 if (copy_from_user(&header, argp, sizeof(header)))
2668 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2672 if (copy_to_user(argp, &header, sizeof(header)))
2674 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2678 int cdrom_read_tocentry(struct cdrom_device_info *cdi,
2679 struct cdrom_tocentry *entry)
2681 u8 requested_format = entry->cdte_format;
2684 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2687 /* make interface to low-level uniform */
2688 entry->cdte_format = CDROM_MSF;
2689 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, entry);
2691 sanitize_format(&entry->cdte_addr, &entry->cdte_format,
2695 EXPORT_SYMBOL_GPL(cdrom_read_tocentry);
2697 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2700 struct cdrom_tocentry entry;
2703 if (copy_from_user(&entry, argp, sizeof(entry)))
2705 ret = cdrom_read_tocentry(cdi, &entry);
2706 if (!ret && copy_to_user(argp, &entry, sizeof(entry)))
2711 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2714 struct cdrom_msf msf;
2716 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2718 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2720 if (copy_from_user(&msf, argp, sizeof(msf)))
2722 return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2725 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2731 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2733 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2735 if (copy_from_user(&ti, argp, sizeof(ti)))
2738 ret = check_for_audio_disc(cdi, cdi->ops);
2741 return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2743 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2746 struct cdrom_volctrl volume;
2748 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2750 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2752 if (copy_from_user(&volume, argp, sizeof(volume)))
2754 return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2757 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2760 struct cdrom_volctrl volume;
2763 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2765 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2768 ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2772 if (copy_to_user(argp, &volume, sizeof(volume)))
2777 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2782 cd_dbg(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2784 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2786 ret = check_for_audio_disc(cdi, cdi->ops);
2789 return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2793 * Required when we need to use READ_10 to issue other than 2048 block
2796 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2798 const struct cdrom_device_ops *cdo = cdi->ops;
2799 struct packet_command cgc;
2800 struct modesel_head mh;
2802 memset(&mh, 0, sizeof(mh));
2803 mh.block_desc_length = 0x08;
2804 mh.block_length_med = (size >> 8) & 0xff;
2805 mh.block_length_lo = size & 0xff;
2807 memset(&cgc, 0, sizeof(cgc));
2809 cgc.cmd[1] = 1 << 4;
2811 cgc.buflen = sizeof(mh);
2812 cgc.buffer = (char *) &mh;
2813 cgc.data_direction = CGC_DATA_WRITE;
2814 mh.block_desc_length = 0x08;
2815 mh.block_length_med = (size >> 8) & 0xff;
2816 mh.block_length_lo = size & 0xff;
2818 return cdo->generic_packet(cdi, &cgc);
2821 static int cdrom_get_track_info(struct cdrom_device_info *cdi,
2822 __u16 track, __u8 type, track_information *ti)
2824 const struct cdrom_device_ops *cdo = cdi->ops;
2825 struct packet_command cgc;
2828 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
2829 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
2830 cgc.cmd[1] = type & 3;
2831 cgc.cmd[4] = (track & 0xff00) >> 8;
2832 cgc.cmd[5] = track & 0xff;
2836 ret = cdo->generic_packet(cdi, &cgc);
2840 buflen = be16_to_cpu(ti->track_information_length) +
2841 sizeof(ti->track_information_length);
2843 if (buflen > sizeof(track_information))
2844 buflen = sizeof(track_information);
2846 cgc.cmd[8] = cgc.buflen = buflen;
2847 ret = cdo->generic_packet(cdi, &cgc);
2851 /* return actual fill size */
2855 /* return the last written block on the CD-R media. this is for the udf
2857 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
2859 struct cdrom_tocentry toc;
2860 disc_information di;
2861 track_information ti;
2863 int ret = -1, ti_size;
2865 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2868 ret = cdrom_get_disc_info(cdi, &di);
2869 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
2870 + sizeof(di.last_track_lsb)))
2873 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2874 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2875 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2876 if (ti_size < (int)offsetof(typeof(ti), track_start))
2879 /* if this track is blank, try the previous. */
2881 if (last_track == 1)
2884 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2887 if (ti_size < (int)(offsetof(typeof(ti), track_size)
2888 + sizeof(ti.track_size)))
2891 /* if last recorded field is valid, return it. */
2892 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
2893 + sizeof(ti.last_rec_address))) {
2894 *last_written = be32_to_cpu(ti.last_rec_address);
2896 /* make it up instead */
2897 *last_written = be32_to_cpu(ti.track_start) +
2898 be32_to_cpu(ti.track_size);
2900 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
2904 /* this is where we end up if the drive either can't do a
2905 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
2906 it doesn't give enough information or fails. then we return
2907 the toc contents. */
2909 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2912 toc.cdte_format = CDROM_MSF;
2913 toc.cdte_track = CDROM_LEADOUT;
2914 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
2916 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
2917 *last_written = toc.cdte_addr.lba;
2921 /* return the next writable block. also for udf file system. */
2922 static int cdrom_get_next_writable(struct cdrom_device_info *cdi,
2923 long *next_writable)
2925 disc_information di;
2926 track_information ti;
2930 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2931 goto use_last_written;
2933 ret = cdrom_get_disc_info(cdi, &di);
2934 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
2935 + sizeof(di.last_track_lsb))
2936 goto use_last_written;
2938 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2939 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2940 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2941 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
2942 goto use_last_written;
2944 /* if this track is blank, try the previous. */
2946 if (last_track == 1)
2947 goto use_last_written;
2949 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2951 goto use_last_written;
2954 /* if next recordable address field is valid, use it. */
2955 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
2956 + sizeof(ti.next_writable)) {
2957 *next_writable = be32_to_cpu(ti.next_writable);
2962 ret = cdrom_get_last_written(cdi, next_writable);
2967 *next_writable += 7;
2972 static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2974 struct packet_command *cgc,
2977 struct scsi_sense_hdr sshdr;
2978 struct cdrom_msf msf;
2979 int blocksize = 0, format = 0, lba;
2984 blocksize = CD_FRAMESIZE_RAW;
2986 case CDROMREADMODE1:
2987 blocksize = CD_FRAMESIZE;
2990 case CDROMREADMODE2:
2991 blocksize = CD_FRAMESIZE_RAW0;
2994 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
2996 lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2997 /* FIXME: we need upper bound checking, too!! */
3001 cgc->buffer = kzalloc(blocksize, GFP_KERNEL);
3002 if (cgc->buffer == NULL)
3005 memset(&sshdr, 0, sizeof(sshdr));
3006 cgc->sshdr = &sshdr;
3007 cgc->data_direction = CGC_DATA_READ;
3008 ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
3009 if (ret && sshdr.sense_key == 0x05 &&
3010 sshdr.asc == 0x20 &&
3011 sshdr.ascq == 0x00) {
3013 * SCSI-II devices are not required to support
3014 * READ_CD, so let's try switching block size
3016 /* FIXME: switch back again... */
3017 ret = cdrom_switch_blocksize(cdi, blocksize);
3021 ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
3022 ret |= cdrom_switch_blocksize(cdi, blocksize);
3024 if (!ret && copy_to_user(arg, cgc->buffer, blocksize))
3031 static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
3034 struct cdrom_read_audio ra;
3037 #ifdef CONFIG_COMPAT
3038 if (in_compat_syscall()) {
3039 struct compat_cdrom_read_audio {
3040 union cdrom_addr addr;
3042 compat_int_t nframes;
3046 if (copy_from_user(&ra32, arg, sizeof(ra32)))
3049 ra = (struct cdrom_read_audio) {
3051 .addr_format = ra32.addr_format,
3052 .nframes = ra32.nframes,
3053 .buf = compat_ptr(ra32.buf),
3058 if (copy_from_user(&ra, (struct cdrom_read_audio __user *)arg,
3063 if (ra.addr_format == CDROM_MSF)
3064 lba = msf_to_lba(ra.addr.msf.minute,
3067 else if (ra.addr_format == CDROM_LBA)
3072 /* FIXME: we need upper bound checking, too!! */
3073 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
3076 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
3079 static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
3083 struct cdrom_subchnl q;
3084 u_char requested, back;
3085 if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q)))
3087 requested = q.cdsc_format;
3088 if (!((requested == CDROM_MSF) ||
3089 (requested == CDROM_LBA)))
3092 ret = cdrom_read_subchannel(cdi, &q, 0);
3095 back = q.cdsc_format; /* local copy */
3096 sanitize_format(&q.cdsc_absaddr, &back, requested);
3097 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
3098 if (copy_to_user((struct cdrom_subchnl __user *)arg, &q, sizeof(q)))
3100 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
3104 static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
3106 struct packet_command *cgc)
3108 const struct cdrom_device_ops *cdo = cdi->ops;
3109 struct cdrom_msf msf;
3110 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
3111 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
3113 cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
3114 cgc->cmd[3] = msf.cdmsf_min0;
3115 cgc->cmd[4] = msf.cdmsf_sec0;
3116 cgc->cmd[5] = msf.cdmsf_frame0;
3117 cgc->cmd[6] = msf.cdmsf_min1;
3118 cgc->cmd[7] = msf.cdmsf_sec1;
3119 cgc->cmd[8] = msf.cdmsf_frame1;
3120 cgc->data_direction = CGC_DATA_NONE;
3121 return cdo->generic_packet(cdi, cgc);
3124 static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
3126 struct packet_command *cgc)
3128 const struct cdrom_device_ops *cdo = cdi->ops;
3129 struct cdrom_blk blk;
3130 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
3131 if (copy_from_user(&blk, (struct cdrom_blk __user *)arg, sizeof(blk)))
3133 cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
3134 cgc->cmd[2] = (blk.from >> 24) & 0xff;
3135 cgc->cmd[3] = (blk.from >> 16) & 0xff;
3136 cgc->cmd[4] = (blk.from >> 8) & 0xff;
3137 cgc->cmd[5] = blk.from & 0xff;
3138 cgc->cmd[7] = (blk.len >> 8) & 0xff;
3139 cgc->cmd[8] = blk.len & 0xff;
3140 cgc->data_direction = CGC_DATA_NONE;
3141 return cdo->generic_packet(cdi, cgc);
3144 static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3146 struct packet_command *cgc,
3149 struct cdrom_volctrl volctrl;
3150 unsigned char buffer[32];
3151 char mask[sizeof(buffer)];
3152 unsigned short offset;
3155 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3157 if (copy_from_user(&volctrl, (struct cdrom_volctrl __user *)arg,
3161 cgc->buffer = buffer;
3163 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 0);
3167 /* originally the code depended on buffer[1] to determine
3168 how much data is available for transfer. buffer[1] is
3169 unfortunately ambigious and the only reliable way seem
3170 to be to simply skip over the block descriptor... */
3171 offset = 8 + be16_to_cpu(*(__be16 *)(buffer + 6));
3173 if (offset + 16 > sizeof(buffer))
3176 if (offset + 16 > cgc->buflen) {
3177 cgc->buflen = offset + 16;
3178 ret = cdrom_mode_sense(cdi, cgc,
3179 GPMODE_AUDIO_CTL_PAGE, 0);
3185 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3186 buffer[offset + 1] < 14)
3189 /* now we have the current volume settings. if it was only
3190 a CDROMVOLREAD, return these values */
3191 if (cmd == CDROMVOLREAD) {
3192 volctrl.channel0 = buffer[offset+9];
3193 volctrl.channel1 = buffer[offset+11];
3194 volctrl.channel2 = buffer[offset+13];
3195 volctrl.channel3 = buffer[offset+15];
3196 if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl,
3202 /* get the volume mask */
3204 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 1);
3208 buffer[offset + 9] = volctrl.channel0 & mask[offset + 9];
3209 buffer[offset + 11] = volctrl.channel1 & mask[offset + 11];
3210 buffer[offset + 13] = volctrl.channel2 & mask[offset + 13];
3211 buffer[offset + 15] = volctrl.channel3 & mask[offset + 15];
3214 cgc->buffer = buffer + offset - 8;
3215 memset(cgc->buffer, 0, 8);
3216 return cdrom_mode_select(cdi, cgc);
3219 static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3220 struct packet_command *cgc,
3223 const struct cdrom_device_ops *cdo = cdi->ops;
3224 cd_dbg(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3225 cgc->cmd[0] = GPCMD_START_STOP_UNIT;
3227 cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3228 cgc->data_direction = CGC_DATA_NONE;
3229 return cdo->generic_packet(cdi, cgc);
3232 static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3233 struct packet_command *cgc,
3236 const struct cdrom_device_ops *cdo = cdi->ops;
3237 cd_dbg(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3238 cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3239 cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3240 cgc->data_direction = CGC_DATA_NONE;
3241 return cdo->generic_packet(cdi, cgc);
3244 static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3246 struct packet_command *cgc)
3250 int size = sizeof(dvd_struct);
3252 if (!CDROM_CAN(CDC_DVD))
3255 s = memdup_user(arg, size);
3259 cd_dbg(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3261 ret = dvd_read_struct(cdi, s, cgc);
3265 if (copy_to_user(arg, s, size))
3272 static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3277 if (!CDROM_CAN(CDC_DVD))
3279 cd_dbg(CD_DO_IOCTL, "entering DVD_AUTH\n");
3280 if (copy_from_user(&ai, (dvd_authinfo __user *)arg, sizeof(ai)))
3282 ret = dvd_do_auth(cdi, &ai);
3285 if (copy_to_user((dvd_authinfo __user *)arg, &ai, sizeof(ai)))
3290 static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3295 cd_dbg(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3296 ret = cdrom_get_next_writable(cdi, &next);
3299 if (copy_to_user((long __user *)arg, &next, sizeof(next)))
3304 static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3309 cd_dbg(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3310 ret = cdrom_get_last_written(cdi, &last);
3313 if (in_compat_syscall())
3314 return put_user(last, (__s32 __user *)arg);
3316 return put_user(last, (long __user *)arg);
3319 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3322 struct packet_command cgc;
3323 void __user *userptr = (void __user *)arg;
3325 memset(&cgc, 0, sizeof(cgc));
3327 /* build a unified command and queue it through
3328 cdo->generic_packet() */
3331 case CDROMREADMODE1:
3332 case CDROMREADMODE2:
3333 return mmc_ioctl_cdrom_read_data(cdi, userptr, &cgc, cmd);
3334 case CDROMREADAUDIO:
3335 return mmc_ioctl_cdrom_read_audio(cdi, userptr);
3337 return mmc_ioctl_cdrom_subchannel(cdi, userptr);
3339 return mmc_ioctl_cdrom_play_msf(cdi, userptr, &cgc);
3341 return mmc_ioctl_cdrom_play_blk(cdi, userptr, &cgc);
3344 return mmc_ioctl_cdrom_volume(cdi, userptr, &cgc, cmd);
3347 return mmc_ioctl_cdrom_start_stop(cdi, &cgc, cmd);
3350 return mmc_ioctl_cdrom_pause_resume(cdi, &cgc, cmd);
3351 case DVD_READ_STRUCT:
3352 return mmc_ioctl_dvd_read_struct(cdi, userptr, &cgc);
3354 return mmc_ioctl_dvd_auth(cdi, userptr);
3355 case CDROM_NEXT_WRITABLE:
3356 return mmc_ioctl_cdrom_next_writable(cdi, userptr);
3357 case CDROM_LAST_WRITTEN:
3358 return mmc_ioctl_cdrom_last_written(cdi, userptr);
3365 * Just about every imaginable ioctl is supported in the Uniform layer
3367 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
3369 int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
3370 fmode_t mode, unsigned int cmd, unsigned long arg)
3372 void __user *argp = (void __user *)arg;
3376 * Try the generic SCSI command ioctl's first.
3378 ret = scsi_cmd_blk_ioctl(bdev, mode, cmd, argp);
3383 case CDROMMULTISESSION:
3384 return cdrom_ioctl_multisession(cdi, argp);
3386 return cdrom_ioctl_eject(cdi);
3387 case CDROMCLOSETRAY:
3388 return cdrom_ioctl_closetray(cdi);
3390 return cdrom_ioctl_eject_sw(cdi, arg);
3391 case CDROM_MEDIA_CHANGED:
3392 return cdrom_ioctl_media_changed(cdi, arg);
3393 case CDROM_SET_OPTIONS:
3394 return cdrom_ioctl_set_options(cdi, arg);
3395 case CDROM_CLEAR_OPTIONS:
3396 return cdrom_ioctl_clear_options(cdi, arg);
3397 case CDROM_SELECT_SPEED:
3398 return cdrom_ioctl_select_speed(cdi, arg);
3399 case CDROM_SELECT_DISC:
3400 return cdrom_ioctl_select_disc(cdi, arg);
3402 return cdrom_ioctl_reset(cdi, bdev);
3403 case CDROM_LOCKDOOR:
3404 return cdrom_ioctl_lock_door(cdi, arg);
3406 return cdrom_ioctl_debug(cdi, arg);
3407 case CDROM_GET_CAPABILITY:
3408 return cdrom_ioctl_get_capability(cdi);
3410 return cdrom_ioctl_get_mcn(cdi, argp);
3411 case CDROM_DRIVE_STATUS:
3412 return cdrom_ioctl_drive_status(cdi, arg);
3413 case CDROM_DISC_STATUS:
3414 return cdrom_ioctl_disc_status(cdi);
3415 case CDROM_CHANGER_NSLOTS:
3416 return cdrom_ioctl_changer_nslots(cdi);
3420 * Use the ioctls that are implemented through the generic_packet()
3421 * interface. this may look at bit funny, but if -ENOTTY is
3422 * returned that particular ioctl is not implemented and we
3423 * let it go through the device specific ones.
3425 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
3426 ret = mmc_ioctl(cdi, cmd, arg);
3432 * Note: most of the cd_dbg() calls are commented out here,
3433 * because they fill up the sys log when CD players poll
3438 return cdrom_ioctl_get_subchnl(cdi, argp);
3439 case CDROMREADTOCHDR:
3440 return cdrom_ioctl_read_tochdr(cdi, argp);
3441 case CDROMREADTOCENTRY:
3442 return cdrom_ioctl_read_tocentry(cdi, argp);
3444 return cdrom_ioctl_play_msf(cdi, argp);
3445 case CDROMPLAYTRKIND:
3446 return cdrom_ioctl_play_trkind(cdi, argp);
3448 return cdrom_ioctl_volctrl(cdi, argp);
3450 return cdrom_ioctl_volread(cdi, argp);
3455 return cdrom_ioctl_audioctl(cdi, cmd);
3461 EXPORT_SYMBOL(cdrom_get_last_written);
3462 EXPORT_SYMBOL(register_cdrom);
3463 EXPORT_SYMBOL(unregister_cdrom);
3464 EXPORT_SYMBOL(cdrom_open);
3465 EXPORT_SYMBOL(cdrom_release);
3466 EXPORT_SYMBOL(cdrom_ioctl);
3467 EXPORT_SYMBOL(cdrom_media_changed);
3468 EXPORT_SYMBOL(cdrom_number_of_slots);
3469 EXPORT_SYMBOL(cdrom_mode_select);
3470 EXPORT_SYMBOL(cdrom_mode_sense);
3471 EXPORT_SYMBOL(init_cdrom_command);
3472 EXPORT_SYMBOL(cdrom_get_media_event);
3474 #ifdef CONFIG_SYSCTL
3476 #define CDROM_STR_SIZE 1000
3478 static struct cdrom_sysctl_settings {
3479 char info[CDROM_STR_SIZE]; /* general info */
3480 int autoclose; /* close tray upon mount, etc */
3481 int autoeject; /* eject on umount */
3482 int debug; /* turn on debugging messages */
3483 int lock; /* lock the door on device open */
3484 int check; /* check media type */
3485 } cdrom_sysctl_settings;
3487 enum cdrom_print_option {
3494 static int cdrom_print_info(const char *header, int val, char *info,
3495 int *pos, enum cdrom_print_option option)
3497 const int max_size = sizeof(cdrom_sysctl_settings.info);
3498 struct cdrom_device_info *cdi;
3501 ret = scnprintf(info + *pos, max_size - *pos, header);
3507 list_for_each_entry(cdi, &cdrom_list, list) {
3510 ret = scnprintf(info + *pos, max_size - *pos,
3514 ret = scnprintf(info + *pos, max_size - *pos,
3515 "\t%d", cdi->speed);
3518 ret = scnprintf(info + *pos, max_size - *pos,
3519 "\t%d", cdi->capacity);
3521 case CTL_CAPABILITY:
3522 ret = scnprintf(info + *pos, max_size - *pos,
3523 "\t%d", CDROM_CAN(val) != 0);
3526 pr_info("invalid option%d\n", option);
3537 static int cdrom_sysctl_info(struct ctl_table *ctl, int write,
3538 void __user *buffer, size_t *lenp, loff_t *ppos)
3541 char *info = cdrom_sysctl_settings.info;
3542 const int max_size = sizeof(cdrom_sysctl_settings.info);
3544 if (!*lenp || (*ppos && !write)) {
3549 mutex_lock(&cdrom_mutex);
3551 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3553 if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3555 if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3557 if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3559 if (cdrom_print_info("\nCan close tray:\t",
3560 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3562 if (cdrom_print_info("\nCan open tray:\t",
3563 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3565 if (cdrom_print_info("\nCan lock tray:\t",
3566 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3568 if (cdrom_print_info("\nCan change speed:",
3569 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3571 if (cdrom_print_info("\nCan select disk:",
3572 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3574 if (cdrom_print_info("\nCan read multisession:",
3575 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3577 if (cdrom_print_info("\nCan read MCN:\t",
3578 CDC_MCN, info, &pos, CTL_CAPABILITY))
3580 if (cdrom_print_info("\nReports media changed:",
3581 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3583 if (cdrom_print_info("\nCan play audio:\t",
3584 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3586 if (cdrom_print_info("\nCan write CD-R:\t",
3587 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3589 if (cdrom_print_info("\nCan write CD-RW:",
3590 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3592 if (cdrom_print_info("\nCan read DVD:\t",
3593 CDC_DVD, info, &pos, CTL_CAPABILITY))
3595 if (cdrom_print_info("\nCan write DVD-R:",
3596 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3598 if (cdrom_print_info("\nCan write DVD-RAM:",
3599 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3601 if (cdrom_print_info("\nCan read MRW:\t",
3602 CDC_MRW, info, &pos, CTL_CAPABILITY))
3604 if (cdrom_print_info("\nCan write MRW:\t",
3605 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3607 if (cdrom_print_info("\nCan write RAM:\t",
3608 CDC_RAM, info, &pos, CTL_CAPABILITY))
3610 if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3613 mutex_unlock(&cdrom_mutex);
3614 return proc_dostring(ctl, write, buffer, lenp, ppos);
3616 pr_info("info buffer too small\n");
3620 /* Unfortunately, per device settings are not implemented through
3621 procfs/sysctl yet. When they are, this will naturally disappear. For now
3622 just update all drives. Later this will become the template on which
3623 new registered drives will be based. */
3624 static void cdrom_update_settings(void)
3626 struct cdrom_device_info *cdi;
3628 mutex_lock(&cdrom_mutex);
3629 list_for_each_entry(cdi, &cdrom_list, list) {
3630 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3631 cdi->options |= CDO_AUTO_CLOSE;
3632 else if (!autoclose)
3633 cdi->options &= ~CDO_AUTO_CLOSE;
3634 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3635 cdi->options |= CDO_AUTO_EJECT;
3636 else if (!autoeject)
3637 cdi->options &= ~CDO_AUTO_EJECT;
3638 if (lockdoor && CDROM_CAN(CDC_LOCK))
3639 cdi->options |= CDO_LOCK;
3641 cdi->options &= ~CDO_LOCK;
3642 if (check_media_type)
3643 cdi->options |= CDO_CHECK_TYPE;
3645 cdi->options &= ~CDO_CHECK_TYPE;
3647 mutex_unlock(&cdrom_mutex);
3650 static int cdrom_sysctl_handler(struct ctl_table *ctl, int write,
3651 void *buffer, size_t *lenp, loff_t *ppos)
3655 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
3659 /* we only care for 1 or 0. */
3660 autoclose = !!cdrom_sysctl_settings.autoclose;
3661 autoeject = !!cdrom_sysctl_settings.autoeject;
3662 debug = !!cdrom_sysctl_settings.debug;
3663 lockdoor = !!cdrom_sysctl_settings.lock;
3664 check_media_type = !!cdrom_sysctl_settings.check;
3666 /* update the option flags according to the changes. we
3667 don't have per device options through sysctl yet,
3668 but we will have and then this will disappear. */
3669 cdrom_update_settings();
3675 /* Place files in /proc/sys/dev/cdrom */
3676 static struct ctl_table cdrom_table[] = {
3679 .data = &cdrom_sysctl_settings.info,
3680 .maxlen = CDROM_STR_SIZE,
3682 .proc_handler = cdrom_sysctl_info,
3685 .procname = "autoclose",
3686 .data = &cdrom_sysctl_settings.autoclose,
3687 .maxlen = sizeof(int),
3689 .proc_handler = cdrom_sysctl_handler,
3692 .procname = "autoeject",
3693 .data = &cdrom_sysctl_settings.autoeject,
3694 .maxlen = sizeof(int),
3696 .proc_handler = cdrom_sysctl_handler,
3699 .procname = "debug",
3700 .data = &cdrom_sysctl_settings.debug,
3701 .maxlen = sizeof(int),
3703 .proc_handler = cdrom_sysctl_handler,
3707 .data = &cdrom_sysctl_settings.lock,
3708 .maxlen = sizeof(int),
3710 .proc_handler = cdrom_sysctl_handler,
3713 .procname = "check_media",
3714 .data = &cdrom_sysctl_settings.check,
3715 .maxlen = sizeof(int),
3717 .proc_handler = cdrom_sysctl_handler
3722 static struct ctl_table cdrom_cdrom_table[] = {
3724 .procname = "cdrom",
3727 .child = cdrom_table,
3732 /* Make sure that /proc/sys/dev is there */
3733 static struct ctl_table cdrom_root_table[] = {
3738 .child = cdrom_cdrom_table,
3742 static struct ctl_table_header *cdrom_sysctl_header;
3744 static void cdrom_sysctl_register(void)
3746 static atomic_t initialized = ATOMIC_INIT(0);
3748 if (!atomic_add_unless(&initialized, 1, 1))
3751 cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3753 /* set the defaults */
3754 cdrom_sysctl_settings.autoclose = autoclose;
3755 cdrom_sysctl_settings.autoeject = autoeject;
3756 cdrom_sysctl_settings.debug = debug;
3757 cdrom_sysctl_settings.lock = lockdoor;
3758 cdrom_sysctl_settings.check = check_media_type;
3761 static void cdrom_sysctl_unregister(void)
3763 if (cdrom_sysctl_header)
3764 unregister_sysctl_table(cdrom_sysctl_header);
3767 #else /* CONFIG_SYSCTL */
3769 static void cdrom_sysctl_register(void)
3773 static void cdrom_sysctl_unregister(void)
3777 #endif /* CONFIG_SYSCTL */
3779 static int __init cdrom_init(void)
3781 cdrom_sysctl_register();
3786 static void __exit cdrom_exit(void)
3788 pr_info("Uniform CD-ROM driver unloaded\n");
3789 cdrom_sysctl_unregister();
3792 module_init(cdrom_init);
3793 module_exit(cdrom_exit);
3794 MODULE_LICENSE("GPL");