1 /* linux/drivers/cdrom/cdrom.c
2 Copyright (c) 1996, 1997 David A. van Leeuwen.
3 Copyright (c) 1997, 1998 Erik Andersen <andersee@debian.org>
4 Copyright (c) 1998, 1999 Jens Axboe <axboe@image.dk>
6 May be copied or modified under the terms of the GNU General Public
7 License. See linux/COPYING for more information.
9 Uniform CD-ROM driver for Linux.
10 See Documentation/cdrom/cdrom-standard.tex for usage information.
12 The routines in the file provide a uniform interface between the
13 software that uses CD-ROMs and the various low-level drivers that
14 actually talk to the hardware. Suggestions are welcome.
15 Patches that work are more welcome though. ;-)
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>
286 #include <asm/uaccess.h>
288 /* used to tell the module to turn on full debugging messages */
290 /* default compatibility mode */
291 static bool autoclose=1;
292 static bool autoeject;
293 static bool lockdoor = 1;
294 /* will we ever get to use this... sigh. */
295 static bool check_media_type;
296 /* automatically restart mrw format */
297 static bool mrw_format_restart = 1;
298 module_param(debug, bool, 0);
299 module_param(autoclose, bool, 0);
300 module_param(autoeject, bool, 0);
301 module_param(lockdoor, bool, 0);
302 module_param(check_media_type, bool, 0);
303 module_param(mrw_format_restart, bool, 0);
305 static DEFINE_MUTEX(cdrom_mutex);
307 static const char *mrw_format_status[] = {
314 static const char *mrw_address_space[] = { "DMA", "GAA" };
316 #if (ERRLOGMASK != CD_NOTHING)
317 #define cd_dbg(type, fmt, ...) \
319 if ((ERRLOGMASK & type) || debug == 1) \
320 pr_debug(fmt, ##__VA_ARGS__); \
323 #define cd_dbg(type, fmt, ...) \
325 if (0 && (ERRLOGMASK & type) || debug == 1) \
326 pr_debug(fmt, ##__VA_ARGS__); \
330 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
331 a lot of places. This macro makes the code more clear. */
332 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
335 * Another popular OS uses 7 seconds as the hard timeout for default
336 * commands, so it is a good choice for us as well.
338 #define CDROM_DEF_TIMEOUT (7 * HZ)
340 /* Not-exported routines. */
342 static void cdrom_sysctl_register(void);
344 static LIST_HEAD(cdrom_list);
346 static int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
347 struct packet_command *cgc)
350 cgc->sense->sense_key = 0x05;
351 cgc->sense->asc = 0x20;
352 cgc->sense->ascq = 0x00;
359 static int cdrom_flush_cache(struct cdrom_device_info *cdi)
361 struct packet_command cgc;
363 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
364 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
366 cgc.timeout = 5 * 60 * HZ;
368 return cdi->ops->generic_packet(cdi, &cgc);
371 /* requires CD R/RW */
372 static int cdrom_get_disc_info(struct cdrom_device_info *cdi,
373 disc_information *di)
375 struct cdrom_device_ops *cdo = cdi->ops;
376 struct packet_command cgc;
379 /* set up command and get the disc info */
380 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
381 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
382 cgc.cmd[8] = cgc.buflen = 2;
385 ret = cdo->generic_packet(cdi, &cgc);
389 /* not all drives have the same disc_info length, so requeue
390 * packet with the length the drive tells us it can supply
392 buflen = be16_to_cpu(di->disc_information_length) +
393 sizeof(di->disc_information_length);
395 if (buflen > sizeof(disc_information))
396 buflen = sizeof(disc_information);
398 cgc.cmd[8] = cgc.buflen = buflen;
399 ret = cdo->generic_packet(cdi, &cgc);
403 /* return actual fill size */
407 /* This macro makes sure we don't have to check on cdrom_device_ops
408 * existence in the run-time routines below. Change_capability is a
409 * hack to have the capability flags defined const, while we can still
410 * change it here without gcc complaining at every line.
412 #define ENSURE(call, bits) \
414 if (cdo->call == NULL) \
415 *change_capability &= ~(bits); \
419 * the first prototypes used 0x2c as the page code for the mrw mode page,
420 * subsequently this was changed to 0x03. probe the one used by this drive
422 static int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
424 struct packet_command cgc;
427 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
432 if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
433 cdi->mrw_mode_page = MRW_MODE_PC;
435 } else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
436 cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
443 static int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
445 struct packet_command cgc;
446 struct mrw_feature_desc *mfd;
447 unsigned char buffer[16];
452 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
454 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
455 cgc.cmd[3] = CDF_MRW;
456 cgc.cmd[8] = sizeof(buffer);
459 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
462 mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
463 if (be16_to_cpu(mfd->feature_code) != CDF_MRW)
467 if ((ret = cdrom_mrw_probe_pc(cdi))) {
475 static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
477 struct packet_command cgc;
478 unsigned char buffer[12];
481 pr_info("%sstarting format\n", cont ? "Re" : "");
484 * FmtData bit set (bit 4), format type is 1
486 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
487 cgc.cmd[0] = GPCMD_FORMAT_UNIT;
488 cgc.cmd[1] = (1 << 4) | 1;
490 cgc.timeout = 5 * 60 * HZ;
493 * 4 byte format list header, 8 byte format list descriptor
506 buffer[8] = 0x24 << 2;
509 ret = cdi->ops->generic_packet(cdi, &cgc);
511 pr_info("bgformat failed\n");
516 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
518 struct packet_command cgc;
520 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
521 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
524 * Session = 1, Track = 0
526 cgc.cmd[1] = !!immed;
529 cgc.timeout = 5 * 60 * HZ;
531 return cdi->ops->generic_packet(cdi, &cgc);
534 static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
539 ret = cdrom_get_disc_info(cdi, &di);
540 if (ret < 0 || ret < (int)offsetof(typeof(di),disc_type))
544 if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
545 pr_info("issuing MRW background format suspend\n");
546 ret = cdrom_mrw_bgformat_susp(cdi, 0);
549 if (!ret && cdi->media_written)
550 ret = cdrom_flush_cache(cdi);
555 static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
557 struct packet_command cgc;
558 struct mode_page_header *mph;
560 int ret, offset, size;
562 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
565 cgc.buflen = sizeof(buffer);
567 ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0);
571 mph = (struct mode_page_header *)buffer;
572 offset = be16_to_cpu(mph->desc_length);
573 size = be16_to_cpu(mph->mode_data_length) + 2;
575 buffer[offset + 3] = space;
578 ret = cdrom_mode_select(cdi, &cgc);
582 pr_info("%s: mrw address space %s selected\n",
583 cdi->name, mrw_address_space[space]);
587 int register_cdrom(struct cdrom_device_info *cdi)
589 static char banner_printed;
590 struct cdrom_device_ops *cdo = cdi->ops;
591 int *change_capability = (int *)&cdo->capability; /* hack */
593 cd_dbg(CD_OPEN, "entering register_cdrom\n");
595 if (cdo->open == NULL || cdo->release == NULL)
597 if (!banner_printed) {
598 pr_info("Uniform CD-ROM driver " REVISION "\n");
600 cdrom_sysctl_register();
603 ENSURE(drive_status, CDC_DRIVE_STATUS);
604 if (cdo->check_events == NULL && cdo->media_changed == NULL)
605 *change_capability = ~(CDC_MEDIA_CHANGED | CDC_SELECT_DISC);
606 ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
607 ENSURE(lock_door, CDC_LOCK);
608 ENSURE(select_speed, CDC_SELECT_SPEED);
609 ENSURE(get_last_session, CDC_MULTI_SESSION);
610 ENSURE(get_mcn, CDC_MCN);
611 ENSURE(reset, CDC_RESET);
612 ENSURE(generic_packet, CDC_GENERIC_PACKET);
615 cdi->options = CDO_USE_FFLAGS;
617 if (autoclose == 1 && CDROM_CAN(CDC_CLOSE_TRAY))
618 cdi->options |= (int) CDO_AUTO_CLOSE;
619 if (autoeject == 1 && CDROM_CAN(CDC_OPEN_TRAY))
620 cdi->options |= (int) CDO_AUTO_EJECT;
622 cdi->options |= (int) CDO_LOCK;
623 if (check_media_type == 1)
624 cdi->options |= (int) CDO_CHECK_TYPE;
626 if (CDROM_CAN(CDC_MRW_W))
627 cdi->exit = cdrom_mrw_exit;
630 cdi->cdda_method = CDDA_BPC_FULL;
632 cdi->cdda_method = CDDA_OLD;
634 if (!cdo->generic_packet)
635 cdo->generic_packet = cdrom_dummy_generic_packet;
637 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
638 mutex_lock(&cdrom_mutex);
639 list_add(&cdi->list, &cdrom_list);
640 mutex_unlock(&cdrom_mutex);
645 void unregister_cdrom(struct cdrom_device_info *cdi)
647 cd_dbg(CD_OPEN, "entering unregister_cdrom\n");
649 mutex_lock(&cdrom_mutex);
650 list_del(&cdi->list);
651 mutex_unlock(&cdrom_mutex);
656 cdi->ops->n_minors--;
657 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
660 int cdrom_get_media_event(struct cdrom_device_info *cdi,
661 struct media_event_desc *med)
663 struct packet_command cgc;
664 unsigned char buffer[8];
665 struct event_header *eh = (struct event_header *)buffer;
667 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
668 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
669 cgc.cmd[1] = 1; /* IMMED */
670 cgc.cmd[4] = 1 << 4; /* media event */
671 cgc.cmd[8] = sizeof(buffer);
674 if (cdi->ops->generic_packet(cdi, &cgc))
677 if (be16_to_cpu(eh->data_len) < sizeof(*med))
680 if (eh->nea || eh->notification_class != 0x4)
683 memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
687 static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
688 struct rwrt_feature_desc *rfd)
690 struct packet_command cgc;
694 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
696 cgc.cmd[0] = GPCMD_GET_CONFIGURATION; /* often 0x46 */
697 cgc.cmd[3] = CDF_RWRT; /* often 0x0020 */
698 cgc.cmd[8] = sizeof(buffer); /* often 0x18 */
701 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
704 memcpy(rfd, &buffer[sizeof(struct feature_header)], sizeof (*rfd));
708 static int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
710 struct packet_command cgc;
712 __be16 *feature_code;
715 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
717 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
718 cgc.cmd[3] = CDF_HWDM;
719 cgc.cmd[8] = sizeof(buffer);
722 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
725 feature_code = (__be16 *) &buffer[sizeof(struct feature_header)];
726 if (be16_to_cpu(*feature_code) == CDF_HWDM)
733 static int cdrom_is_random_writable(struct cdrom_device_info *cdi, int *write)
735 struct rwrt_feature_desc rfd;
740 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
743 if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
749 static int cdrom_media_erasable(struct cdrom_device_info *cdi)
754 ret = cdrom_get_disc_info(cdi, &di);
755 if (ret < 0 || ret < offsetof(typeof(di), n_first_track))
762 * FIXME: check RO bit
764 static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
766 int ret = cdrom_media_erasable(cdi);
769 * allow writable open if media info read worked and media is
770 * erasable, _or_ if it fails since not all drives support it
778 static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
784 * always reset to DMA lba space on open
786 if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_DMA)) {
787 pr_err("failed setting lba address space\n");
791 ret = cdrom_get_disc_info(cdi, &di);
792 if (ret < 0 || ret < offsetof(typeof(di),disc_type))
800 * 0 - not MRW formatted
801 * 1 - MRW bgformat started, but not running or complete
802 * 2 - MRW bgformat in progress
803 * 3 - MRW formatting complete
806 pr_info("open: mrw_status '%s'\n", mrw_format_status[di.mrw_status]);
809 else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE &&
811 ret = cdrom_mrw_bgformat(cdi, 1);
816 static int mo_open_write(struct cdrom_device_info *cdi)
818 struct packet_command cgc;
822 init_cdrom_command(&cgc, &buffer, 4, CGC_DATA_READ);
826 * obtain write protect information as per
827 * drivers/scsi/sd.c:sd_read_write_protect_flag
830 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
832 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_VENDOR_PAGE, 0);
835 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
838 /* drive gave us no info, let the user go ahead */
842 return buffer[3] & 0x80;
845 static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
847 struct rwrt_feature_desc rfd;
850 if ((ret = cdrom_has_defect_mgt(cdi)))
853 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
855 else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
858 cd_dbg(CD_OPEN, "can open for random write\n");
862 static void cdrom_mmc3_profile(struct cdrom_device_info *cdi)
864 struct packet_command cgc;
866 int ret, mmc3_profile;
868 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
870 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
872 cgc.cmd[2] = cgc.cmd[3] = 0; /* Starting Feature Number */
873 cgc.cmd[8] = sizeof(buffer); /* Allocation Length */
876 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
877 mmc3_profile = 0xffff;
879 mmc3_profile = (buffer[6] << 8) | buffer[7];
881 cdi->mmc3_profile = mmc3_profile;
884 static int cdrom_is_dvd_rw(struct cdrom_device_info *cdi)
886 switch (cdi->mmc3_profile) {
887 case 0x12: /* DVD-RAM */
888 case 0x1A: /* DVD+RW */
889 case 0x43: /* BD-RE */
897 * returns 0 for ok to open write, non-0 to disallow
899 static int cdrom_open_write(struct cdrom_device_info *cdi)
901 int mrw, mrw_write, ram_write;
905 if (!cdrom_is_mrw(cdi, &mrw_write))
908 if (CDROM_CAN(CDC_MO_DRIVE))
911 (void) cdrom_is_random_writable(cdi, &ram_write);
914 cdi->mask &= ~CDC_MRW;
916 cdi->mask |= CDC_MRW;
919 cdi->mask &= ~CDC_MRW_W;
921 cdi->mask |= CDC_MRW_W;
924 cdi->mask &= ~CDC_RAM;
926 cdi->mask |= CDC_RAM;
928 if (CDROM_CAN(CDC_MRW_W))
929 ret = cdrom_mrw_open_write(cdi);
930 else if (CDROM_CAN(CDC_DVD_RAM))
931 ret = cdrom_dvdram_open_write(cdi);
932 else if (CDROM_CAN(CDC_RAM) &&
933 !CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW|CDC_MO_DRIVE))
934 ret = cdrom_ram_open_write(cdi);
935 else if (CDROM_CAN(CDC_MO_DRIVE))
936 ret = mo_open_write(cdi);
937 else if (!cdrom_is_dvd_rw(cdi))
943 static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
945 struct packet_command cgc;
947 if (cdi->mmc3_profile != 0x1a) {
948 cd_dbg(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
952 if (!cdi->media_written) {
953 cd_dbg(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
957 pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi->name);
959 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
960 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
962 cdi->ops->generic_packet(cdi, &cgc);
964 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
965 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
966 cgc.timeout = 3000*HZ;
968 cdi->ops->generic_packet(cdi, &cgc);
970 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
971 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
972 cgc.cmd[2] = 2; /* Close session */
974 cgc.timeout = 3000*HZ;
975 cdi->ops->generic_packet(cdi, &cgc);
977 cdi->media_written = 0;
980 static int cdrom_close_write(struct cdrom_device_info *cdi)
983 return cdrom_flush_cache(cdi);
989 /* badly broken, I know. Is due for a fixup anytime. */
990 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype *tracks)
992 struct cdrom_tochdr header;
993 struct cdrom_tocentry entry;
1000 cd_dbg(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1002 if (!CDROM_CAN(CDC_PLAY_AUDIO)) {
1003 tracks->error = CDS_NO_INFO;
1007 /* Grab the TOC header so we can see how many tracks there are */
1008 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
1010 if (ret == -ENOMEDIUM)
1011 tracks->error = CDS_NO_DISC;
1013 tracks->error = CDS_NO_INFO;
1016 /* check what type of tracks are on this disc */
1017 entry.cdte_format = CDROM_MSF;
1018 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1019 entry.cdte_track = i;
1020 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1021 tracks->error = CDS_NO_INFO;
1024 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1025 if (entry.cdte_format == 0x10)
1027 else if (entry.cdte_format == 0x20)
1034 cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1035 i, entry.cdte_format, entry.cdte_ctrl);
1037 cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1038 header.cdth_trk1, tracks->audio, tracks->data,
1039 tracks->cdi, tracks->xa);
1043 int open_for_data(struct cdrom_device_info *cdi)
1046 struct cdrom_device_ops *cdo = cdi->ops;
1048 cd_dbg(CD_OPEN, "entering open_for_data\n");
1049 /* Check if the driver can report drive status. If it can, we
1050 can do clever things. If it can't, well, we at least tried! */
1051 if (cdo->drive_status != NULL) {
1052 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1053 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1054 if (ret == CDS_TRAY_OPEN) {
1055 cd_dbg(CD_OPEN, "the tray is open...\n");
1056 /* can/may i close it? */
1057 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1058 cdi->options & CDO_AUTO_CLOSE) {
1059 cd_dbg(CD_OPEN, "trying to close the tray\n");
1060 ret=cdo->tray_move(cdi,0);
1062 cd_dbg(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1063 /* Ignore the error from the low
1064 level driver. We don't care why it
1065 couldn't close the tray. We only care
1066 that there is no disc in the drive,
1067 since that is the _REAL_ problem here.*/
1069 goto clean_up_and_return;
1072 cd_dbg(CD_OPEN, "bummer. this drive can't close the tray.\n");
1074 goto clean_up_and_return;
1076 /* Ok, the door should be closed now.. Check again */
1077 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1078 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1079 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1080 cd_dbg(CD_OPEN, "tray might not contain a medium\n");
1082 goto clean_up_and_return;
1084 cd_dbg(CD_OPEN, "the tray is now closed\n");
1086 /* the door should be closed now, check for the disc */
1087 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1088 if (ret!=CDS_DISC_OK) {
1090 goto clean_up_and_return;
1093 cdrom_count_tracks(cdi, &tracks);
1094 if (tracks.error == CDS_NO_DISC) {
1095 cd_dbg(CD_OPEN, "bummer. no disc.\n");
1097 goto clean_up_and_return;
1099 /* CD-Players which don't use O_NONBLOCK, workman
1100 * for example, need bit CDO_CHECK_TYPE cleared! */
1101 if (tracks.data==0) {
1102 if (cdi->options & CDO_CHECK_TYPE) {
1103 /* give people a warning shot, now that CDO_CHECK_TYPE
1104 is the default case! */
1105 cd_dbg(CD_OPEN, "bummer. wrong media type.\n");
1106 cd_dbg(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1107 (unsigned int)task_pid_nr(current));
1109 goto clean_up_and_return;
1112 cd_dbg(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set\n");
1116 cd_dbg(CD_OPEN, "all seems well, opening the devicen");
1118 /* all seems well, we can open the device */
1119 ret = cdo->open(cdi, 0); /* open for data */
1120 cd_dbg(CD_OPEN, "opening the device gave me %d\n", ret);
1121 /* After all this careful checking, we shouldn't have problems
1122 opening the device, but we don't want the device locked if
1123 this somehow fails... */
1125 cd_dbg(CD_OPEN, "open device failed\n");
1126 goto clean_up_and_return;
1128 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1129 cdo->lock_door(cdi, 1);
1130 cd_dbg(CD_OPEN, "door locked\n");
1132 cd_dbg(CD_OPEN, "device opened successfully\n");
1135 /* Something failed. Try to unlock the drive, because some drivers
1136 (notably ide-cd) lock the drive after every command. This produced
1137 a nasty bug where after mount failed, the drive would remain locked!
1138 This ensures that the drive gets unlocked after a mount fails. This
1139 is a goto to avoid bloating the driver with redundant code. */
1140 clean_up_and_return:
1141 cd_dbg(CD_OPEN, "open failed\n");
1142 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1143 cdo->lock_door(cdi, 0);
1144 cd_dbg(CD_OPEN, "door unlocked\n");
1149 /* We use the open-option O_NONBLOCK to indicate that the
1150 * purpose of opening is only for subsequent ioctl() calls; no device
1151 * integrity checks are performed.
1153 * We hope that all cd-player programs will adopt this convention. It
1154 * is in their own interest: device control becomes a lot easier
1157 int cdrom_open(struct cdrom_device_info *cdi, struct block_device *bdev,
1162 cd_dbg(CD_OPEN, "entering cdrom_open\n");
1164 /* if this was a O_NONBLOCK open and we should honor the flags,
1165 * do a quick open without drive/disc integrity checks. */
1167 if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) {
1168 ret = cdi->ops->open(cdi, 1);
1170 ret = open_for_data(cdi);
1173 if (CDROM_CAN(CDC_GENERIC_PACKET))
1174 cdrom_mmc3_profile(cdi);
1175 if (mode & FMODE_WRITE) {
1177 if (cdrom_open_write(cdi))
1179 if (!CDROM_CAN(CDC_RAM))
1182 cdi->media_written = 0;
1189 cd_dbg(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1190 cdi->name, cdi->use_count);
1193 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1194 cdi->ops->lock_door(cdi, 0);
1195 cd_dbg(CD_OPEN, "door unlocked\n");
1197 cdi->ops->release(cdi);
1203 /* This code is similar to that in open_for_data. The routine is called
1204 whenever an audio play operation is requested.
1206 static int check_for_audio_disc(struct cdrom_device_info * cdi,
1207 struct cdrom_device_ops * cdo)
1211 cd_dbg(CD_OPEN, "entering check_for_audio_disc\n");
1212 if (!(cdi->options & CDO_CHECK_TYPE))
1214 if (cdo->drive_status != NULL) {
1215 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1216 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1217 if (ret == CDS_TRAY_OPEN) {
1218 cd_dbg(CD_OPEN, "the tray is open...\n");
1219 /* can/may i close it? */
1220 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1221 cdi->options & CDO_AUTO_CLOSE) {
1222 cd_dbg(CD_OPEN, "trying to close the tray\n");
1223 ret=cdo->tray_move(cdi,0);
1225 cd_dbg(CD_OPEN, "bummer. tried to close tray but failed.\n");
1226 /* Ignore the error from the low
1227 level driver. We don't care why it
1228 couldn't close the tray. We only care
1229 that there is no disc in the drive,
1230 since that is the _REAL_ problem here.*/
1234 cd_dbg(CD_OPEN, "bummer. this driver can't close the tray.\n");
1237 /* Ok, the door should be closed now.. Check again */
1238 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1239 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1240 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1243 if (ret!=CDS_DISC_OK) {
1244 cd_dbg(CD_OPEN, "bummer. disc isn't ready.\n");
1247 cd_dbg(CD_OPEN, "the tray is now closed\n");
1250 cdrom_count_tracks(cdi, &tracks);
1252 return(tracks.error);
1254 if (tracks.audio==0)
1255 return -EMEDIUMTYPE;
1260 void cdrom_release(struct cdrom_device_info *cdi, fmode_t mode)
1262 struct cdrom_device_ops *cdo = cdi->ops;
1263 int opened_for_data;
1265 cd_dbg(CD_CLOSE, "entering cdrom_release\n");
1267 if (cdi->use_count > 0)
1270 if (cdi->use_count == 0) {
1271 cd_dbg(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n",
1273 cdrom_dvd_rw_close_write(cdi);
1275 if ((cdo->capability & CDC_LOCK) && !cdi->keeplocked) {
1276 cd_dbg(CD_CLOSE, "Unlocking door!\n");
1277 cdo->lock_door(cdi, 0);
1281 opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1282 !(mode & FMODE_NDELAY);
1285 * flush cache on last write release
1287 if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1288 cdrom_close_write(cdi);
1291 if (cdi->use_count == 0) { /* last process that closes dev*/
1292 if (opened_for_data &&
1293 cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1294 cdo->tray_move(cdi, 1);
1298 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1299 struct cdrom_changer_info *buf)
1301 struct packet_command cgc;
1302 struct cdrom_device_ops *cdo = cdi->ops;
1306 * Sanyo changer isn't spec compliant (doesn't use regular change
1307 * LOAD_UNLOAD command, and it doesn't implement the mech status
1310 if (cdi->sanyo_slot) {
1311 buf->hdr.nslots = 3;
1312 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1313 for (length = 0; length < 3; length++) {
1314 buf->slots[length].disc_present = 1;
1315 buf->slots[length].change = 0;
1320 length = sizeof(struct cdrom_mechstat_header) +
1321 cdi->capacity * sizeof(struct cdrom_slot);
1323 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1324 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1325 cgc.cmd[8] = (length >> 8) & 0xff;
1326 cgc.cmd[9] = length & 0xff;
1327 return cdo->generic_packet(cdi, &cgc);
1330 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1332 struct cdrom_changer_info *info;
1335 cd_dbg(CD_CHANGER, "entering cdrom_slot_status()\n");
1336 if (cdi->sanyo_slot)
1339 info = kmalloc(sizeof(*info), GFP_KERNEL);
1343 if ((ret = cdrom_read_mech_status(cdi, info)))
1346 if (info->slots[slot].disc_present)
1356 /* Return the number of slots for an ATAPI/SCSI cdrom,
1357 * return 1 if not a changer.
1359 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1363 struct cdrom_changer_info *info;
1365 cd_dbg(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1366 /* cdrom_read_mech_status requires a valid value for capacity: */
1369 info = kmalloc(sizeof(*info), GFP_KERNEL);
1373 if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1374 nslots = info->hdr.nslots;
1381 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1382 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1384 struct packet_command cgc;
1386 cd_dbg(CD_CHANGER, "entering cdrom_load_unload()\n");
1387 if (cdi->sanyo_slot && slot < 0)
1390 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1391 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1392 cgc.cmd[4] = 2 + (slot >= 0);
1394 cgc.timeout = 60 * HZ;
1396 /* The Sanyo 3 CD changer uses byte 7 of the
1397 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1398 using the GPCMD_LOAD_UNLOAD opcode. */
1399 if (cdi->sanyo_slot && -1 < slot) {
1400 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1402 cgc.cmd[4] = cgc.cmd[8] = 0;
1403 cdi->sanyo_slot = slot ? slot : 3;
1406 return cdi->ops->generic_packet(cdi, &cgc);
1409 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1411 struct cdrom_changer_info *info;
1415 cd_dbg(CD_CHANGER, "entering cdrom_select_disc()\n");
1416 if (!CDROM_CAN(CDC_SELECT_DISC))
1417 return -EDRIVE_CANT_DO_THIS;
1419 if (cdi->ops->check_events)
1420 cdi->ops->check_events(cdi, 0, slot);
1422 cdi->ops->media_changed(cdi, slot);
1424 if (slot == CDSL_NONE) {
1425 /* set media changed bits, on both queues */
1426 cdi->mc_flags = 0x3;
1427 return cdrom_load_unload(cdi, -1);
1430 info = kmalloc(sizeof(*info), GFP_KERNEL);
1434 if ((ret = cdrom_read_mech_status(cdi, info))) {
1439 curslot = info->hdr.curslot;
1442 if (cdi->use_count > 1 || cdi->keeplocked) {
1443 if (slot == CDSL_CURRENT) {
1450 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1451 which is useful if it had been previously unloaded.
1452 Whether it can or not, it returns the current slot.
1453 Similarly, if slot happens to be the current one, we still
1455 if (slot == CDSL_CURRENT)
1458 /* set media changed bits on both queues */
1459 cdi->mc_flags = 0x3;
1460 if ((ret = cdrom_load_unload(cdi, slot)))
1467 * As cdrom implements an extra ioctl consumer for media changed
1468 * event, it needs to buffer ->check_events() output, such that event
1469 * is not lost for both the usual VFS and ioctl paths.
1470 * cdi->{vfs|ioctl}_events are used to buffer pending events for each
1473 * XXX: Locking is non-existent. cdi->ops->check_events() can be
1474 * called in parallel and buffering fields are accessed without any
1475 * exclusion. The original media_changed code had the same problem.
1476 * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1477 * and remove this cruft altogether. It doesn't have much usefulness
1480 static void cdrom_update_events(struct cdrom_device_info *cdi,
1481 unsigned int clearing)
1483 unsigned int events;
1485 events = cdi->ops->check_events(cdi, clearing, CDSL_CURRENT);
1486 cdi->vfs_events |= events;
1487 cdi->ioctl_events |= events;
1490 unsigned int cdrom_check_events(struct cdrom_device_info *cdi,
1491 unsigned int clearing)
1493 unsigned int events;
1495 cdrom_update_events(cdi, clearing);
1496 events = cdi->vfs_events;
1497 cdi->vfs_events = 0;
1500 EXPORT_SYMBOL(cdrom_check_events);
1502 /* We want to make media_changed accessible to the user through an
1503 * ioctl. The main problem now is that we must double-buffer the
1504 * low-level implementation, to assure that the VFS and the user both
1505 * see a medium change once.
1509 int media_changed(struct cdrom_device_info *cdi, int queue)
1511 unsigned int mask = (1 << (queue & 1));
1512 int ret = !!(cdi->mc_flags & mask);
1515 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1518 /* changed since last call? */
1519 if (cdi->ops->check_events) {
1520 BUG_ON(!queue); /* shouldn't be called from VFS path */
1521 cdrom_update_events(cdi, DISK_EVENT_MEDIA_CHANGE);
1522 changed = cdi->ioctl_events & DISK_EVENT_MEDIA_CHANGE;
1523 cdi->ioctl_events = 0;
1525 changed = cdi->ops->media_changed(cdi, CDSL_CURRENT);
1528 cdi->mc_flags = 0x3; /* set bit on both queues */
1530 cdi->media_written = 0;
1533 cdi->mc_flags &= ~mask; /* clear bit */
1537 int cdrom_media_changed(struct cdrom_device_info *cdi)
1539 /* This talks to the VFS, which doesn't like errors - just 1 or 0.
1540 * Returning "0" is always safe (media hasn't been changed). Do that
1541 * if the low-level cdrom driver dosn't support media changed. */
1542 if (cdi == NULL || cdi->ops->media_changed == NULL)
1544 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1546 return media_changed(cdi, 0);
1549 /* Requests to the low-level drivers will /always/ be done in the
1550 following format convention:
1552 CDROM_LBA: all data-related requests.
1553 CDROM_MSF: all audio-related requests.
1555 However, a low-level implementation is allowed to refuse this
1556 request, and return information in its own favorite format.
1558 It doesn't make sense /at all/ to ask for a play_audio in LBA
1559 format, or ask for multi-session info in MSF format. However, for
1560 backward compatibility these format requests will be satisfied, but
1561 the requests to the low-level drivers will be sanitized in the more
1562 meaningful format indicated above.
1566 void sanitize_format(union cdrom_addr *addr,
1567 u_char * curr, u_char requested)
1569 if (*curr == requested)
1570 return; /* nothing to be done! */
1571 if (requested == CDROM_LBA) {
1572 addr->lba = (int) addr->msf.frame +
1573 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1574 } else { /* CDROM_MSF */
1575 int lba = addr->lba;
1576 addr->msf.frame = lba % 75;
1579 addr->msf.second = lba % 60;
1580 addr->msf.minute = lba / 60;
1585 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1588 memset(cgc, 0, sizeof(struct packet_command));
1590 memset(buf, 0, len);
1591 cgc->buffer = (char *) buf;
1593 cgc->data_direction = type;
1594 cgc->timeout = CDROM_DEF_TIMEOUT;
1599 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1600 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1602 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1604 cgc->cmd[0] = GPCMD_REPORT_KEY;
1605 cgc->cmd[10] = type | (agid << 6);
1607 case 0: case 8: case 5: {
1620 cgc->cmd[9] = cgc->buflen;
1621 cgc->data_direction = CGC_DATA_READ;
1624 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1626 cgc->cmd[0] = GPCMD_SEND_KEY;
1627 cgc->cmd[10] = type | (agid << 6);
1642 cgc->cmd[9] = cgc->buflen;
1643 cgc->data_direction = CGC_DATA_WRITE;
1646 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1650 struct packet_command cgc;
1651 struct cdrom_device_ops *cdo = cdi->ops;
1652 rpc_state_t rpc_state;
1654 memset(buf, 0, sizeof(buf));
1655 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1659 case DVD_LU_SEND_AGID:
1660 cd_dbg(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1662 setup_report_key(&cgc, ai->lsa.agid, 0);
1664 if ((ret = cdo->generic_packet(cdi, &cgc)))
1667 ai->lsa.agid = buf[7] >> 6;
1668 /* Returning data, let host change state */
1671 case DVD_LU_SEND_KEY1:
1672 cd_dbg(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1673 setup_report_key(&cgc, ai->lsk.agid, 2);
1675 if ((ret = cdo->generic_packet(cdi, &cgc)))
1678 copy_key(ai->lsk.key, &buf[4]);
1679 /* Returning data, let host change state */
1682 case DVD_LU_SEND_CHALLENGE:
1683 cd_dbg(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1684 setup_report_key(&cgc, ai->lsc.agid, 1);
1686 if ((ret = cdo->generic_packet(cdi, &cgc)))
1689 copy_chal(ai->lsc.chal, &buf[4]);
1690 /* Returning data, let host change state */
1694 case DVD_LU_SEND_TITLE_KEY:
1695 cd_dbg(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1697 setup_report_key(&cgc, ai->lstk.agid, 4);
1698 cgc.cmd[5] = ai->lstk.lba;
1699 cgc.cmd[4] = ai->lstk.lba >> 8;
1700 cgc.cmd[3] = ai->lstk.lba >> 16;
1701 cgc.cmd[2] = ai->lstk.lba >> 24;
1703 if ((ret = cdo->generic_packet(cdi, &cgc)))
1706 ai->lstk.cpm = (buf[4] >> 7) & 1;
1707 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1708 ai->lstk.cgms = (buf[4] >> 4) & 3;
1709 copy_key(ai->lstk.title_key, &buf[5]);
1710 /* Returning data, let host change state */
1713 case DVD_LU_SEND_ASF:
1714 cd_dbg(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1715 setup_report_key(&cgc, ai->lsasf.agid, 5);
1717 if ((ret = cdo->generic_packet(cdi, &cgc)))
1720 ai->lsasf.asf = buf[7] & 1;
1723 /* LU data receive (LU changes state) */
1724 case DVD_HOST_SEND_CHALLENGE:
1725 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1726 setup_send_key(&cgc, ai->hsc.agid, 1);
1728 copy_chal(&buf[4], ai->hsc.chal);
1730 if ((ret = cdo->generic_packet(cdi, &cgc)))
1733 ai->type = DVD_LU_SEND_KEY1;
1736 case DVD_HOST_SEND_KEY2:
1737 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1738 setup_send_key(&cgc, ai->hsk.agid, 3);
1740 copy_key(&buf[4], ai->hsk.key);
1742 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1743 ai->type = DVD_AUTH_FAILURE;
1746 ai->type = DVD_AUTH_ESTABLISHED;
1750 case DVD_INVALIDATE_AGID:
1752 cd_dbg(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1753 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1754 if ((ret = cdo->generic_packet(cdi, &cgc)))
1758 /* Get region settings */
1759 case DVD_LU_SEND_RPC_STATE:
1760 cd_dbg(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1761 setup_report_key(&cgc, 0, 8);
1762 memset(&rpc_state, 0, sizeof(rpc_state_t));
1763 cgc.buffer = (char *) &rpc_state;
1765 if ((ret = cdo->generic_packet(cdi, &cgc)))
1768 ai->lrpcs.type = rpc_state.type_code;
1769 ai->lrpcs.vra = rpc_state.vra;
1770 ai->lrpcs.ucca = rpc_state.ucca;
1771 ai->lrpcs.region_mask = rpc_state.region_mask;
1772 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1775 /* Set region settings */
1776 case DVD_HOST_SEND_RPC_STATE:
1777 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1778 setup_send_key(&cgc, 0, 6);
1780 buf[4] = ai->hrpcs.pdrc;
1782 if ((ret = cdo->generic_packet(cdi, &cgc)))
1787 cd_dbg(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1794 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s,
1795 struct packet_command *cgc)
1797 unsigned char buf[21], *base;
1798 struct dvd_layer *layer;
1799 struct cdrom_device_ops *cdo = cdi->ops;
1800 int ret, layer_num = s->physical.layer_num;
1802 if (layer_num >= DVD_LAYERS)
1805 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1806 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1807 cgc->cmd[6] = layer_num;
1808 cgc->cmd[7] = s->type;
1809 cgc->cmd[9] = cgc->buflen & 0xff;
1812 * refrain from reporting errors on non-existing layers (mainly)
1816 ret = cdo->generic_packet(cdi, cgc);
1821 layer = &s->physical.layer[layer_num];
1824 * place the data... really ugly, but at least we won't have to
1825 * worry about endianess in userspace.
1827 memset(layer, 0, sizeof(*layer));
1828 layer->book_version = base[0] & 0xf;
1829 layer->book_type = base[0] >> 4;
1830 layer->min_rate = base[1] & 0xf;
1831 layer->disc_size = base[1] >> 4;
1832 layer->layer_type = base[2] & 0xf;
1833 layer->track_path = (base[2] >> 4) & 1;
1834 layer->nlayers = (base[2] >> 5) & 3;
1835 layer->track_density = base[3] & 0xf;
1836 layer->linear_density = base[3] >> 4;
1837 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1838 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1839 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1840 layer->bca = base[16] >> 7;
1845 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s,
1846 struct packet_command *cgc)
1850 struct cdrom_device_ops *cdo = cdi->ops;
1852 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1853 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1854 cgc->cmd[6] = s->copyright.layer_num;
1855 cgc->cmd[7] = s->type;
1856 cgc->cmd[8] = cgc->buflen >> 8;
1857 cgc->cmd[9] = cgc->buflen & 0xff;
1859 ret = cdo->generic_packet(cdi, cgc);
1863 s->copyright.cpst = buf[4];
1864 s->copyright.rmi = buf[5];
1869 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s,
1870 struct packet_command *cgc)
1874 struct cdrom_device_ops *cdo = cdi->ops;
1876 size = sizeof(s->disckey.value) + 4;
1878 buf = kmalloc(size, GFP_KERNEL);
1882 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1883 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1884 cgc->cmd[7] = s->type;
1885 cgc->cmd[8] = size >> 8;
1886 cgc->cmd[9] = size & 0xff;
1887 cgc->cmd[10] = s->disckey.agid << 6;
1889 ret = cdo->generic_packet(cdi, cgc);
1891 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1897 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1898 struct packet_command *cgc)
1900 int ret, size = 4 + 188;
1902 struct cdrom_device_ops *cdo = cdi->ops;
1904 buf = kmalloc(size, GFP_KERNEL);
1908 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1909 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1910 cgc->cmd[7] = s->type;
1911 cgc->cmd[9] = cgc->buflen & 0xff;
1913 ret = cdo->generic_packet(cdi, cgc);
1917 s->bca.len = buf[0] << 8 | buf[1];
1918 if (s->bca.len < 12 || s->bca.len > 188) {
1919 cd_dbg(CD_WARNING, "Received invalid BCA length (%d)\n",
1924 memcpy(s->bca.value, &buf[4], s->bca.len);
1931 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1932 struct packet_command *cgc)
1936 struct cdrom_device_ops *cdo = cdi->ops;
1938 size = sizeof(s->manufact.value) + 4;
1940 buf = kmalloc(size, GFP_KERNEL);
1944 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1945 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1946 cgc->cmd[7] = s->type;
1947 cgc->cmd[8] = size >> 8;
1948 cgc->cmd[9] = size & 0xff;
1950 ret = cdo->generic_packet(cdi, cgc);
1954 s->manufact.len = buf[0] << 8 | buf[1];
1955 if (s->manufact.len < 0) {
1956 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d)\n",
1960 if (s->manufact.len > 2048) {
1961 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d): truncating to 2048\n",
1963 s->manufact.len = 2048;
1965 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1973 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1974 struct packet_command *cgc)
1977 case DVD_STRUCT_PHYSICAL:
1978 return dvd_read_physical(cdi, s, cgc);
1980 case DVD_STRUCT_COPYRIGHT:
1981 return dvd_read_copyright(cdi, s, cgc);
1983 case DVD_STRUCT_DISCKEY:
1984 return dvd_read_disckey(cdi, s, cgc);
1986 case DVD_STRUCT_BCA:
1987 return dvd_read_bca(cdi, s, cgc);
1989 case DVD_STRUCT_MANUFACT:
1990 return dvd_read_manufact(cdi, s, cgc);
1993 cd_dbg(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1999 int cdrom_mode_sense(struct cdrom_device_info *cdi,
2000 struct packet_command *cgc,
2001 int page_code, int page_control)
2003 struct cdrom_device_ops *cdo = cdi->ops;
2005 memset(cgc->cmd, 0, sizeof(cgc->cmd));
2007 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
2008 cgc->cmd[2] = page_code | (page_control << 6);
2009 cgc->cmd[7] = cgc->buflen >> 8;
2010 cgc->cmd[8] = cgc->buflen & 0xff;
2011 cgc->data_direction = CGC_DATA_READ;
2012 return cdo->generic_packet(cdi, cgc);
2015 int cdrom_mode_select(struct cdrom_device_info *cdi,
2016 struct packet_command *cgc)
2018 struct cdrom_device_ops *cdo = cdi->ops;
2020 memset(cgc->cmd, 0, sizeof(cgc->cmd));
2021 memset(cgc->buffer, 0, 2);
2022 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
2023 cgc->cmd[1] = 0x10; /* PF */
2024 cgc->cmd[7] = cgc->buflen >> 8;
2025 cgc->cmd[8] = cgc->buflen & 0xff;
2026 cgc->data_direction = CGC_DATA_WRITE;
2027 return cdo->generic_packet(cdi, cgc);
2030 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
2031 struct cdrom_subchnl *subchnl, int mcn)
2033 struct cdrom_device_ops *cdo = cdi->ops;
2034 struct packet_command cgc;
2038 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
2039 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
2040 cgc.cmd[1] = subchnl->cdsc_format;/* MSF or LBA addressing */
2041 cgc.cmd[2] = 0x40; /* request subQ data */
2042 cgc.cmd[3] = mcn ? 2 : 1;
2045 if ((ret = cdo->generic_packet(cdi, &cgc)))
2048 subchnl->cdsc_audiostatus = cgc.buffer[1];
2049 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
2050 subchnl->cdsc_trk = cgc.buffer[6];
2051 subchnl->cdsc_ind = cgc.buffer[7];
2053 if (subchnl->cdsc_format == CDROM_LBA) {
2054 subchnl->cdsc_absaddr.lba = ((cgc.buffer[8] << 24) |
2055 (cgc.buffer[9] << 16) |
2056 (cgc.buffer[10] << 8) |
2058 subchnl->cdsc_reladdr.lba = ((cgc.buffer[12] << 24) |
2059 (cgc.buffer[13] << 16) |
2060 (cgc.buffer[14] << 8) |
2063 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
2064 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
2065 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
2066 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
2067 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
2068 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
2075 * Specific READ_10 interface
2077 static int cdrom_read_cd(struct cdrom_device_info *cdi,
2078 struct packet_command *cgc, int lba,
2079 int blocksize, int nblocks)
2081 struct cdrom_device_ops *cdo = cdi->ops;
2083 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2084 cgc->cmd[0] = GPCMD_READ_10;
2085 cgc->cmd[2] = (lba >> 24) & 0xff;
2086 cgc->cmd[3] = (lba >> 16) & 0xff;
2087 cgc->cmd[4] = (lba >> 8) & 0xff;
2088 cgc->cmd[5] = lba & 0xff;
2089 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2090 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2091 cgc->cmd[8] = nblocks & 0xff;
2092 cgc->buflen = blocksize * nblocks;
2093 return cdo->generic_packet(cdi, cgc);
2096 /* very generic interface for reading the various types of blocks */
2097 static int cdrom_read_block(struct cdrom_device_info *cdi,
2098 struct packet_command *cgc,
2099 int lba, int nblocks, int format, int blksize)
2101 struct cdrom_device_ops *cdo = cdi->ops;
2103 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2104 cgc->cmd[0] = GPCMD_READ_CD;
2105 /* expected sector size - cdda,mode1,etc. */
2106 cgc->cmd[1] = format << 2;
2107 /* starting address */
2108 cgc->cmd[2] = (lba >> 24) & 0xff;
2109 cgc->cmd[3] = (lba >> 16) & 0xff;
2110 cgc->cmd[4] = (lba >> 8) & 0xff;
2111 cgc->cmd[5] = lba & 0xff;
2112 /* number of blocks */
2113 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2114 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2115 cgc->cmd[8] = nblocks & 0xff;
2116 cgc->buflen = blksize * nblocks;
2118 /* set the header info returned */
2120 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
2121 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
2122 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
2123 default : cgc->cmd[9] = 0x10;
2126 return cdo->generic_packet(cdi, cgc);
2129 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2130 int lba, int nframes)
2132 struct packet_command cgc;
2136 cdi->last_sense = 0;
2138 memset(&cgc, 0, sizeof(cgc));
2141 * start with will ra.nframes size, back down if alloc fails
2145 cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2155 cgc.data_direction = CGC_DATA_READ;
2156 while (nframes > 0) {
2160 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2163 if (copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2167 ubuf += CD_FRAMESIZE_RAW * nr;
2175 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2176 int lba, int nframes)
2178 struct request_queue *q = cdi->disk->queue;
2187 cdi->last_sense = 0;
2191 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2193 if (nr * CD_FRAMESIZE_RAW > (queue_max_sectors(q) << 9))
2194 nr = (queue_max_sectors(q) << 9) / CD_FRAMESIZE_RAW;
2196 len = nr * CD_FRAMESIZE_RAW;
2198 rq = blk_get_request(q, READ, GFP_KERNEL);
2203 blk_rq_set_block_pc(rq);
2205 ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL);
2207 blk_put_request(rq);
2211 rq->cmd[0] = GPCMD_READ_CD;
2212 rq->cmd[1] = 1 << 2;
2213 rq->cmd[2] = (lba >> 24) & 0xff;
2214 rq->cmd[3] = (lba >> 16) & 0xff;
2215 rq->cmd[4] = (lba >> 8) & 0xff;
2216 rq->cmd[5] = lba & 0xff;
2217 rq->cmd[6] = (nr >> 16) & 0xff;
2218 rq->cmd[7] = (nr >> 8) & 0xff;
2219 rq->cmd[8] = nr & 0xff;
2223 rq->timeout = 60 * HZ;
2226 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2227 struct request_sense *s = rq->sense;
2229 cdi->last_sense = s->sense_key;
2232 if (blk_rq_unmap_user(bio))
2234 blk_put_request(rq);
2247 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2248 int lba, int nframes)
2252 if (cdi->cdda_method == CDDA_OLD)
2253 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2257 * for anything else than success and io error, we need to retry
2259 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2260 if (!ret || ret != -EIO)
2264 * I've seen drives get sense 4/8/3 udma crc errors on multi
2265 * frame dma, so drop to single frame dma if we need to
2267 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2268 pr_info("dropping to single frame dma\n");
2269 cdi->cdda_method = CDDA_BPC_SINGLE;
2274 * so we have an io error of some sort with multi frame dma. if the
2275 * condition wasn't a hardware error
2276 * problems, not for any error
2278 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2281 pr_info("dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2282 cdi->cdda_method = CDDA_OLD;
2283 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2286 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2289 struct cdrom_multisession ms_info;
2290 u8 requested_format;
2293 cd_dbg(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2295 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2298 if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2301 requested_format = ms_info.addr_format;
2302 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2304 ms_info.addr_format = CDROM_LBA;
2306 ret = cdi->ops->get_last_session(cdi, &ms_info);
2310 sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2312 if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2315 cd_dbg(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2319 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2321 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT\n");
2323 if (!CDROM_CAN(CDC_OPEN_TRAY))
2325 if (cdi->use_count != 1 || cdi->keeplocked)
2327 if (CDROM_CAN(CDC_LOCK)) {
2328 int ret = cdi->ops->lock_door(cdi, 0);
2333 return cdi->ops->tray_move(cdi, 1);
2336 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2338 cd_dbg(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2340 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2342 return cdi->ops->tray_move(cdi, 0);
2345 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2348 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2350 if (!CDROM_CAN(CDC_OPEN_TRAY))
2352 if (cdi->keeplocked)
2355 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2357 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2361 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2364 struct cdrom_changer_info *info;
2367 cd_dbg(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2369 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2372 /* cannot select disc or select current disc */
2373 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2374 return media_changed(cdi, 1);
2376 if (arg >= cdi->capacity)
2379 info = kmalloc(sizeof(*info), GFP_KERNEL);
2383 ret = cdrom_read_mech_status(cdi, info);
2385 ret = info->slots[arg].change;
2390 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2393 cd_dbg(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2396 * Options need to be in sync with capability.
2397 * Too late for that, so we have to check each one separately.
2400 case CDO_USE_FFLAGS:
2401 case CDO_CHECK_TYPE:
2404 if (!CDROM_CAN(CDC_LOCK))
2408 return cdi->options;
2409 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2411 if (!CDROM_CAN(arg))
2414 cdi->options |= (int) arg;
2415 return cdi->options;
2418 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2421 cd_dbg(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2423 cdi->options &= ~(int) arg;
2424 return cdi->options;
2427 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2430 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2432 if (!CDROM_CAN(CDC_SELECT_SPEED))
2434 return cdi->ops->select_speed(cdi, arg);
2437 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2440 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2442 if (!CDROM_CAN(CDC_SELECT_DISC))
2445 if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2446 if (arg >= cdi->capacity)
2451 * ->select_disc is a hook to allow a driver-specific way of
2452 * seleting disc. However, since there is no equivalent hook for
2453 * cdrom_slot_status this may not actually be useful...
2455 if (cdi->ops->select_disc)
2456 return cdi->ops->select_disc(cdi, arg);
2458 cd_dbg(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2459 return cdrom_select_disc(cdi, arg);
2462 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2463 struct block_device *bdev)
2465 cd_dbg(CD_DO_IOCTL, "entering CDROM_RESET\n");
2467 if (!capable(CAP_SYS_ADMIN))
2469 if (!CDROM_CAN(CDC_RESET))
2471 invalidate_bdev(bdev);
2472 return cdi->ops->reset(cdi);
2475 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2478 cd_dbg(CD_DO_IOCTL, "%socking door\n", arg ? "L" : "Unl");
2480 if (!CDROM_CAN(CDC_LOCK))
2481 return -EDRIVE_CANT_DO_THIS;
2483 cdi->keeplocked = arg ? 1 : 0;
2486 * Don't unlock the door on multiple opens by default, but allow
2489 if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2491 return cdi->ops->lock_door(cdi, arg);
2494 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2497 cd_dbg(CD_DO_IOCTL, "%sabling debug\n", arg ? "En" : "Dis");
2499 if (!capable(CAP_SYS_ADMIN))
2501 debug = arg ? 1 : 0;
2505 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2507 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2508 return (cdi->ops->capability & ~cdi->mask);
2512 * The following function is implemented, although very few audio
2513 * discs give Universal Product Code information, which should just be
2514 * the Medium Catalog Number on the box. Note, that the way the code
2515 * is written on the CD is /not/ uniform across all discs!
2517 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2520 struct cdrom_mcn mcn;
2523 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2525 if (!(cdi->ops->capability & CDC_MCN))
2527 ret = cdi->ops->get_mcn(cdi, &mcn);
2531 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2533 cd_dbg(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2537 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2540 cd_dbg(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2542 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2544 if (!CDROM_CAN(CDC_SELECT_DISC) ||
2545 (arg == CDSL_CURRENT || arg == CDSL_NONE))
2546 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2547 if (arg >= cdi->capacity)
2549 return cdrom_slot_status(cdi, arg);
2553 * Ok, this is where problems start. The current interface for the
2554 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2555 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunately, while this
2556 * is often the case, it is also very common for CDs to have some tracks
2557 * with data, and some tracks with audio. Just because I feel like it,
2558 * I declare the following to be the best way to cope. If the CD has ANY
2559 * data tracks on it, it will be returned as a data CD. If it has any XA
2560 * tracks, I will return it as that. Now I could simplify this interface
2561 * by combining these returns with the above, but this more clearly
2562 * demonstrates the problem with the current interface. Too bad this
2563 * wasn't designed to use bitmasks... -Erik
2565 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2566 * User level programmers might feel the ioctl is not very useful.
2569 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2573 cd_dbg(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2575 cdrom_count_tracks(cdi, &tracks);
2577 return tracks.error;
2579 /* Policy mode on */
2580 if (tracks.audio > 0) {
2581 if (!tracks.data && !tracks.cdi && !tracks.xa)
2591 if (tracks.data > 0)
2593 /* Policy mode off */
2595 cd_dbg(CD_WARNING, "This disc doesn't have any tracks I recognize!\n");
2599 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2601 cd_dbg(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2602 return cdi->capacity;
2605 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2608 struct cdrom_subchnl q;
2612 /* cd_dbg(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2614 if (copy_from_user(&q, argp, sizeof(q)))
2617 requested = q.cdsc_format;
2618 if (requested != CDROM_MSF && requested != CDROM_LBA)
2620 q.cdsc_format = CDROM_MSF;
2622 ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2626 back = q.cdsc_format; /* local copy */
2627 sanitize_format(&q.cdsc_absaddr, &back, requested);
2628 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2630 if (copy_to_user(argp, &q, sizeof(q)))
2632 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2636 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2639 struct cdrom_tochdr header;
2642 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2644 if (copy_from_user(&header, argp, sizeof(header)))
2647 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2651 if (copy_to_user(argp, &header, sizeof(header)))
2653 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2657 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2660 struct cdrom_tocentry entry;
2661 u8 requested_format;
2664 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2666 if (copy_from_user(&entry, argp, sizeof(entry)))
2669 requested_format = entry.cdte_format;
2670 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2672 /* make interface to low-level uniform */
2673 entry.cdte_format = CDROM_MSF;
2674 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2677 sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2679 if (copy_to_user(argp, &entry, sizeof(entry)))
2681 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2685 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2688 struct cdrom_msf msf;
2690 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2692 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2694 if (copy_from_user(&msf, argp, sizeof(msf)))
2696 return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2699 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2705 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2707 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2709 if (copy_from_user(&ti, argp, sizeof(ti)))
2712 ret = check_for_audio_disc(cdi, cdi->ops);
2715 return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2717 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2720 struct cdrom_volctrl volume;
2722 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2724 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2726 if (copy_from_user(&volume, argp, sizeof(volume)))
2728 return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2731 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2734 struct cdrom_volctrl volume;
2737 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2739 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2742 ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2746 if (copy_to_user(argp, &volume, sizeof(volume)))
2751 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2756 cd_dbg(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2758 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2760 ret = check_for_audio_disc(cdi, cdi->ops);
2763 return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2767 * Required when we need to use READ_10 to issue other than 2048 block
2770 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2772 struct cdrom_device_ops *cdo = cdi->ops;
2773 struct packet_command cgc;
2774 struct modesel_head mh;
2776 memset(&mh, 0, sizeof(mh));
2777 mh.block_desc_length = 0x08;
2778 mh.block_length_med = (size >> 8) & 0xff;
2779 mh.block_length_lo = size & 0xff;
2781 memset(&cgc, 0, sizeof(cgc));
2783 cgc.cmd[1] = 1 << 4;
2785 cgc.buflen = sizeof(mh);
2786 cgc.buffer = (char *) &mh;
2787 cgc.data_direction = CGC_DATA_WRITE;
2788 mh.block_desc_length = 0x08;
2789 mh.block_length_med = (size >> 8) & 0xff;
2790 mh.block_length_lo = size & 0xff;
2792 return cdo->generic_packet(cdi, &cgc);
2795 static int cdrom_get_track_info(struct cdrom_device_info *cdi,
2796 __u16 track, __u8 type, track_information *ti)
2798 struct cdrom_device_ops *cdo = cdi->ops;
2799 struct packet_command cgc;
2802 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
2803 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
2804 cgc.cmd[1] = type & 3;
2805 cgc.cmd[4] = (track & 0xff00) >> 8;
2806 cgc.cmd[5] = track & 0xff;
2810 ret = cdo->generic_packet(cdi, &cgc);
2814 buflen = be16_to_cpu(ti->track_information_length) +
2815 sizeof(ti->track_information_length);
2817 if (buflen > sizeof(track_information))
2818 buflen = sizeof(track_information);
2820 cgc.cmd[8] = cgc.buflen = buflen;
2821 ret = cdo->generic_packet(cdi, &cgc);
2825 /* return actual fill size */
2829 /* return the last written block on the CD-R media. this is for the udf
2831 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
2833 struct cdrom_tocentry toc;
2834 disc_information di;
2835 track_information ti;
2837 int ret = -1, ti_size;
2839 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2842 ret = cdrom_get_disc_info(cdi, &di);
2843 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
2844 + sizeof(di.last_track_lsb)))
2847 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2848 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2849 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2850 if (ti_size < (int)offsetof(typeof(ti), track_start))
2853 /* if this track is blank, try the previous. */
2855 if (last_track == 1)
2858 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2861 if (ti_size < (int)(offsetof(typeof(ti), track_size)
2862 + sizeof(ti.track_size)))
2865 /* if last recorded field is valid, return it. */
2866 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
2867 + sizeof(ti.last_rec_address))) {
2868 *last_written = be32_to_cpu(ti.last_rec_address);
2870 /* make it up instead */
2871 *last_written = be32_to_cpu(ti.track_start) +
2872 be32_to_cpu(ti.track_size);
2874 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
2878 /* this is where we end up if the drive either can't do a
2879 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
2880 it doesn't give enough information or fails. then we return
2881 the toc contents. */
2883 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2886 toc.cdte_format = CDROM_MSF;
2887 toc.cdte_track = CDROM_LEADOUT;
2888 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
2890 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
2891 *last_written = toc.cdte_addr.lba;
2895 /* return the next writable block. also for udf file system. */
2896 static int cdrom_get_next_writable(struct cdrom_device_info *cdi,
2897 long *next_writable)
2899 disc_information di;
2900 track_information ti;
2904 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2905 goto use_last_written;
2907 ret = cdrom_get_disc_info(cdi, &di);
2908 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
2909 + sizeof(di.last_track_lsb))
2910 goto use_last_written;
2912 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2913 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2914 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2915 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
2916 goto use_last_written;
2918 /* if this track is blank, try the previous. */
2920 if (last_track == 1)
2921 goto use_last_written;
2923 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2925 goto use_last_written;
2928 /* if next recordable address field is valid, use it. */
2929 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
2930 + sizeof(ti.next_writable)) {
2931 *next_writable = be32_to_cpu(ti.next_writable);
2936 ret = cdrom_get_last_written(cdi, next_writable);
2941 *next_writable += 7;
2946 static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2948 struct packet_command *cgc,
2951 struct request_sense sense;
2952 struct cdrom_msf msf;
2953 int blocksize = 0, format = 0, lba;
2958 blocksize = CD_FRAMESIZE_RAW;
2960 case CDROMREADMODE1:
2961 blocksize = CD_FRAMESIZE;
2964 case CDROMREADMODE2:
2965 blocksize = CD_FRAMESIZE_RAW0;
2968 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
2970 lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2971 /* FIXME: we need upper bound checking, too!! */
2975 cgc->buffer = kzalloc(blocksize, GFP_KERNEL);
2976 if (cgc->buffer == NULL)
2979 memset(&sense, 0, sizeof(sense));
2980 cgc->sense = &sense;
2981 cgc->data_direction = CGC_DATA_READ;
2982 ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
2983 if (ret && sense.sense_key == 0x05 &&
2984 sense.asc == 0x20 &&
2985 sense.ascq == 0x00) {
2987 * SCSI-II devices are not required to support
2988 * READ_CD, so let's try switching block size
2990 /* FIXME: switch back again... */
2991 ret = cdrom_switch_blocksize(cdi, blocksize);
2995 ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
2996 ret |= cdrom_switch_blocksize(cdi, blocksize);
2998 if (!ret && copy_to_user(arg, cgc->buffer, blocksize))
3005 static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
3008 struct cdrom_read_audio ra;
3011 if (copy_from_user(&ra, (struct cdrom_read_audio __user *)arg,
3015 if (ra.addr_format == CDROM_MSF)
3016 lba = msf_to_lba(ra.addr.msf.minute,
3019 else if (ra.addr_format == CDROM_LBA)
3024 /* FIXME: we need upper bound checking, too!! */
3025 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
3028 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
3031 static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
3035 struct cdrom_subchnl q;
3036 u_char requested, back;
3037 if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q)))
3039 requested = q.cdsc_format;
3040 if (!((requested == CDROM_MSF) ||
3041 (requested == CDROM_LBA)))
3044 ret = cdrom_read_subchannel(cdi, &q, 0);
3047 back = q.cdsc_format; /* local copy */
3048 sanitize_format(&q.cdsc_absaddr, &back, requested);
3049 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
3050 if (copy_to_user((struct cdrom_subchnl __user *)arg, &q, sizeof(q)))
3052 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
3056 static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
3058 struct packet_command *cgc)
3060 struct cdrom_device_ops *cdo = cdi->ops;
3061 struct cdrom_msf msf;
3062 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
3063 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
3065 cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
3066 cgc->cmd[3] = msf.cdmsf_min0;
3067 cgc->cmd[4] = msf.cdmsf_sec0;
3068 cgc->cmd[5] = msf.cdmsf_frame0;
3069 cgc->cmd[6] = msf.cdmsf_min1;
3070 cgc->cmd[7] = msf.cdmsf_sec1;
3071 cgc->cmd[8] = msf.cdmsf_frame1;
3072 cgc->data_direction = CGC_DATA_NONE;
3073 return cdo->generic_packet(cdi, cgc);
3076 static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
3078 struct packet_command *cgc)
3080 struct cdrom_device_ops *cdo = cdi->ops;
3081 struct cdrom_blk blk;
3082 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
3083 if (copy_from_user(&blk, (struct cdrom_blk __user *)arg, sizeof(blk)))
3085 cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
3086 cgc->cmd[2] = (blk.from >> 24) & 0xff;
3087 cgc->cmd[3] = (blk.from >> 16) & 0xff;
3088 cgc->cmd[4] = (blk.from >> 8) & 0xff;
3089 cgc->cmd[5] = blk.from & 0xff;
3090 cgc->cmd[7] = (blk.len >> 8) & 0xff;
3091 cgc->cmd[8] = blk.len & 0xff;
3092 cgc->data_direction = CGC_DATA_NONE;
3093 return cdo->generic_packet(cdi, cgc);
3096 static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3098 struct packet_command *cgc,
3101 struct cdrom_volctrl volctrl;
3102 unsigned char buffer[32];
3103 char mask[sizeof(buffer)];
3104 unsigned short offset;
3107 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3109 if (copy_from_user(&volctrl, (struct cdrom_volctrl __user *)arg,
3113 cgc->buffer = buffer;
3115 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 0);
3119 /* originally the code depended on buffer[1] to determine
3120 how much data is available for transfer. buffer[1] is
3121 unfortunately ambigious and the only reliable way seem
3122 to be to simply skip over the block descriptor... */
3123 offset = 8 + be16_to_cpu(*(__be16 *)(buffer + 6));
3125 if (offset + 16 > sizeof(buffer))
3128 if (offset + 16 > cgc->buflen) {
3129 cgc->buflen = offset + 16;
3130 ret = cdrom_mode_sense(cdi, cgc,
3131 GPMODE_AUDIO_CTL_PAGE, 0);
3137 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3138 buffer[offset + 1] < 14)
3141 /* now we have the current volume settings. if it was only
3142 a CDROMVOLREAD, return these values */
3143 if (cmd == CDROMVOLREAD) {
3144 volctrl.channel0 = buffer[offset+9];
3145 volctrl.channel1 = buffer[offset+11];
3146 volctrl.channel2 = buffer[offset+13];
3147 volctrl.channel3 = buffer[offset+15];
3148 if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl,
3154 /* get the volume mask */
3156 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 1);
3160 buffer[offset + 9] = volctrl.channel0 & mask[offset + 9];
3161 buffer[offset + 11] = volctrl.channel1 & mask[offset + 11];
3162 buffer[offset + 13] = volctrl.channel2 & mask[offset + 13];
3163 buffer[offset + 15] = volctrl.channel3 & mask[offset + 15];
3166 cgc->buffer = buffer + offset - 8;
3167 memset(cgc->buffer, 0, 8);
3168 return cdrom_mode_select(cdi, cgc);
3171 static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3172 struct packet_command *cgc,
3175 struct cdrom_device_ops *cdo = cdi->ops;
3176 cd_dbg(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3177 cgc->cmd[0] = GPCMD_START_STOP_UNIT;
3179 cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3180 cgc->data_direction = CGC_DATA_NONE;
3181 return cdo->generic_packet(cdi, cgc);
3184 static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3185 struct packet_command *cgc,
3188 struct cdrom_device_ops *cdo = cdi->ops;
3189 cd_dbg(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3190 cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3191 cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3192 cgc->data_direction = CGC_DATA_NONE;
3193 return cdo->generic_packet(cdi, cgc);
3196 static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3198 struct packet_command *cgc)
3202 int size = sizeof(dvd_struct);
3204 if (!CDROM_CAN(CDC_DVD))
3207 s = memdup_user(arg, size);
3211 cd_dbg(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3213 ret = dvd_read_struct(cdi, s, cgc);
3217 if (copy_to_user(arg, s, size))
3224 static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3229 if (!CDROM_CAN(CDC_DVD))
3231 cd_dbg(CD_DO_IOCTL, "entering DVD_AUTH\n");
3232 if (copy_from_user(&ai, (dvd_authinfo __user *)arg, sizeof(ai)))
3234 ret = dvd_do_auth(cdi, &ai);
3237 if (copy_to_user((dvd_authinfo __user *)arg, &ai, sizeof(ai)))
3242 static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3247 cd_dbg(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3248 ret = cdrom_get_next_writable(cdi, &next);
3251 if (copy_to_user((long __user *)arg, &next, sizeof(next)))
3256 static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3261 cd_dbg(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3262 ret = cdrom_get_last_written(cdi, &last);
3265 if (copy_to_user((long __user *)arg, &last, sizeof(last)))
3270 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3273 struct packet_command cgc;
3274 void __user *userptr = (void __user *)arg;
3276 memset(&cgc, 0, sizeof(cgc));
3278 /* build a unified command and queue it through
3279 cdo->generic_packet() */
3282 case CDROMREADMODE1:
3283 case CDROMREADMODE2:
3284 return mmc_ioctl_cdrom_read_data(cdi, userptr, &cgc, cmd);
3285 case CDROMREADAUDIO:
3286 return mmc_ioctl_cdrom_read_audio(cdi, userptr);
3288 return mmc_ioctl_cdrom_subchannel(cdi, userptr);
3290 return mmc_ioctl_cdrom_play_msf(cdi, userptr, &cgc);
3292 return mmc_ioctl_cdrom_play_blk(cdi, userptr, &cgc);
3295 return mmc_ioctl_cdrom_volume(cdi, userptr, &cgc, cmd);
3298 return mmc_ioctl_cdrom_start_stop(cdi, &cgc, cmd);
3301 return mmc_ioctl_cdrom_pause_resume(cdi, &cgc, cmd);
3302 case DVD_READ_STRUCT:
3303 return mmc_ioctl_dvd_read_struct(cdi, userptr, &cgc);
3305 return mmc_ioctl_dvd_auth(cdi, userptr);
3306 case CDROM_NEXT_WRITABLE:
3307 return mmc_ioctl_cdrom_next_writable(cdi, userptr);
3308 case CDROM_LAST_WRITTEN:
3309 return mmc_ioctl_cdrom_last_written(cdi, userptr);
3316 * Just about every imaginable ioctl is supported in the Uniform layer
3318 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
3320 int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
3321 fmode_t mode, unsigned int cmd, unsigned long arg)
3323 void __user *argp = (void __user *)arg;
3327 * Try the generic SCSI command ioctl's first.
3329 ret = scsi_cmd_blk_ioctl(bdev, mode, cmd, argp);
3334 case CDROMMULTISESSION:
3335 return cdrom_ioctl_multisession(cdi, argp);
3337 return cdrom_ioctl_eject(cdi);
3338 case CDROMCLOSETRAY:
3339 return cdrom_ioctl_closetray(cdi);
3341 return cdrom_ioctl_eject_sw(cdi, arg);
3342 case CDROM_MEDIA_CHANGED:
3343 return cdrom_ioctl_media_changed(cdi, arg);
3344 case CDROM_SET_OPTIONS:
3345 return cdrom_ioctl_set_options(cdi, arg);
3346 case CDROM_CLEAR_OPTIONS:
3347 return cdrom_ioctl_clear_options(cdi, arg);
3348 case CDROM_SELECT_SPEED:
3349 return cdrom_ioctl_select_speed(cdi, arg);
3350 case CDROM_SELECT_DISC:
3351 return cdrom_ioctl_select_disc(cdi, arg);
3353 return cdrom_ioctl_reset(cdi, bdev);
3354 case CDROM_LOCKDOOR:
3355 return cdrom_ioctl_lock_door(cdi, arg);
3357 return cdrom_ioctl_debug(cdi, arg);
3358 case CDROM_GET_CAPABILITY:
3359 return cdrom_ioctl_get_capability(cdi);
3361 return cdrom_ioctl_get_mcn(cdi, argp);
3362 case CDROM_DRIVE_STATUS:
3363 return cdrom_ioctl_drive_status(cdi, arg);
3364 case CDROM_DISC_STATUS:
3365 return cdrom_ioctl_disc_status(cdi);
3366 case CDROM_CHANGER_NSLOTS:
3367 return cdrom_ioctl_changer_nslots(cdi);
3371 * Use the ioctls that are implemented through the generic_packet()
3372 * interface. this may look at bit funny, but if -ENOTTY is
3373 * returned that particular ioctl is not implemented and we
3374 * let it go through the device specific ones.
3376 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
3377 ret = mmc_ioctl(cdi, cmd, arg);
3383 * Note: most of the cd_dbg() calls are commented out here,
3384 * because they fill up the sys log when CD players poll
3389 return cdrom_ioctl_get_subchnl(cdi, argp);
3390 case CDROMREADTOCHDR:
3391 return cdrom_ioctl_read_tochdr(cdi, argp);
3392 case CDROMREADTOCENTRY:
3393 return cdrom_ioctl_read_tocentry(cdi, argp);
3395 return cdrom_ioctl_play_msf(cdi, argp);
3396 case CDROMPLAYTRKIND:
3397 return cdrom_ioctl_play_trkind(cdi, argp);
3399 return cdrom_ioctl_volctrl(cdi, argp);
3401 return cdrom_ioctl_volread(cdi, argp);
3406 return cdrom_ioctl_audioctl(cdi, cmd);
3412 EXPORT_SYMBOL(cdrom_get_last_written);
3413 EXPORT_SYMBOL(register_cdrom);
3414 EXPORT_SYMBOL(unregister_cdrom);
3415 EXPORT_SYMBOL(cdrom_open);
3416 EXPORT_SYMBOL(cdrom_release);
3417 EXPORT_SYMBOL(cdrom_ioctl);
3418 EXPORT_SYMBOL(cdrom_media_changed);
3419 EXPORT_SYMBOL(cdrom_number_of_slots);
3420 EXPORT_SYMBOL(cdrom_mode_select);
3421 EXPORT_SYMBOL(cdrom_mode_sense);
3422 EXPORT_SYMBOL(init_cdrom_command);
3423 EXPORT_SYMBOL(cdrom_get_media_event);
3425 #ifdef CONFIG_SYSCTL
3427 #define CDROM_STR_SIZE 1000
3429 static struct cdrom_sysctl_settings {
3430 char info[CDROM_STR_SIZE]; /* general info */
3431 int autoclose; /* close tray upon mount, etc */
3432 int autoeject; /* eject on umount */
3433 int debug; /* turn on debugging messages */
3434 int lock; /* lock the door on device open */
3435 int check; /* check media type */
3436 } cdrom_sysctl_settings;
3438 enum cdrom_print_option {
3445 static int cdrom_print_info(const char *header, int val, char *info,
3446 int *pos, enum cdrom_print_option option)
3448 const int max_size = sizeof(cdrom_sysctl_settings.info);
3449 struct cdrom_device_info *cdi;
3452 ret = scnprintf(info + *pos, max_size - *pos, header);
3458 list_for_each_entry(cdi, &cdrom_list, list) {
3461 ret = scnprintf(info + *pos, max_size - *pos,
3465 ret = scnprintf(info + *pos, max_size - *pos,
3466 "\t%d", cdi->speed);
3469 ret = scnprintf(info + *pos, max_size - *pos,
3470 "\t%d", cdi->capacity);
3472 case CTL_CAPABILITY:
3473 ret = scnprintf(info + *pos, max_size - *pos,
3474 "\t%d", CDROM_CAN(val) != 0);
3477 pr_info("invalid option%d\n", option);
3488 static int cdrom_sysctl_info(struct ctl_table *ctl, int write,
3489 void __user *buffer, size_t *lenp, loff_t *ppos)
3492 char *info = cdrom_sysctl_settings.info;
3493 const int max_size = sizeof(cdrom_sysctl_settings.info);
3495 if (!*lenp || (*ppos && !write)) {
3500 mutex_lock(&cdrom_mutex);
3502 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3504 if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3506 if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3508 if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3510 if (cdrom_print_info("\nCan close tray:\t",
3511 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3513 if (cdrom_print_info("\nCan open tray:\t",
3514 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3516 if (cdrom_print_info("\nCan lock tray:\t",
3517 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3519 if (cdrom_print_info("\nCan change speed:",
3520 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3522 if (cdrom_print_info("\nCan select disk:",
3523 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3525 if (cdrom_print_info("\nCan read multisession:",
3526 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3528 if (cdrom_print_info("\nCan read MCN:\t",
3529 CDC_MCN, info, &pos, CTL_CAPABILITY))
3531 if (cdrom_print_info("\nReports media changed:",
3532 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3534 if (cdrom_print_info("\nCan play audio:\t",
3535 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3537 if (cdrom_print_info("\nCan write CD-R:\t",
3538 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3540 if (cdrom_print_info("\nCan write CD-RW:",
3541 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3543 if (cdrom_print_info("\nCan read DVD:\t",
3544 CDC_DVD, info, &pos, CTL_CAPABILITY))
3546 if (cdrom_print_info("\nCan write DVD-R:",
3547 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3549 if (cdrom_print_info("\nCan write DVD-RAM:",
3550 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3552 if (cdrom_print_info("\nCan read MRW:\t",
3553 CDC_MRW, info, &pos, CTL_CAPABILITY))
3555 if (cdrom_print_info("\nCan write MRW:\t",
3556 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3558 if (cdrom_print_info("\nCan write RAM:\t",
3559 CDC_RAM, info, &pos, CTL_CAPABILITY))
3561 if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3564 mutex_unlock(&cdrom_mutex);
3565 return proc_dostring(ctl, write, buffer, lenp, ppos);
3567 pr_info("info buffer too small\n");
3571 /* Unfortunately, per device settings are not implemented through
3572 procfs/sysctl yet. When they are, this will naturally disappear. For now
3573 just update all drives. Later this will become the template on which
3574 new registered drives will be based. */
3575 static void cdrom_update_settings(void)
3577 struct cdrom_device_info *cdi;
3579 mutex_lock(&cdrom_mutex);
3580 list_for_each_entry(cdi, &cdrom_list, list) {
3581 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3582 cdi->options |= CDO_AUTO_CLOSE;
3583 else if (!autoclose)
3584 cdi->options &= ~CDO_AUTO_CLOSE;
3585 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3586 cdi->options |= CDO_AUTO_EJECT;
3587 else if (!autoeject)
3588 cdi->options &= ~CDO_AUTO_EJECT;
3589 if (lockdoor && CDROM_CAN(CDC_LOCK))
3590 cdi->options |= CDO_LOCK;
3592 cdi->options &= ~CDO_LOCK;
3593 if (check_media_type)
3594 cdi->options |= CDO_CHECK_TYPE;
3596 cdi->options &= ~CDO_CHECK_TYPE;
3598 mutex_unlock(&cdrom_mutex);
3601 static int cdrom_sysctl_handler(struct ctl_table *ctl, int write,
3602 void __user *buffer, size_t *lenp, loff_t *ppos)
3606 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
3610 /* we only care for 1 or 0. */
3611 autoclose = !!cdrom_sysctl_settings.autoclose;
3612 autoeject = !!cdrom_sysctl_settings.autoeject;
3613 debug = !!cdrom_sysctl_settings.debug;
3614 lockdoor = !!cdrom_sysctl_settings.lock;
3615 check_media_type = !!cdrom_sysctl_settings.check;
3617 /* update the option flags according to the changes. we
3618 don't have per device options through sysctl yet,
3619 but we will have and then this will disappear. */
3620 cdrom_update_settings();
3626 /* Place files in /proc/sys/dev/cdrom */
3627 static struct ctl_table cdrom_table[] = {
3630 .data = &cdrom_sysctl_settings.info,
3631 .maxlen = CDROM_STR_SIZE,
3633 .proc_handler = cdrom_sysctl_info,
3636 .procname = "autoclose",
3637 .data = &cdrom_sysctl_settings.autoclose,
3638 .maxlen = sizeof(int),
3640 .proc_handler = cdrom_sysctl_handler,
3643 .procname = "autoeject",
3644 .data = &cdrom_sysctl_settings.autoeject,
3645 .maxlen = sizeof(int),
3647 .proc_handler = cdrom_sysctl_handler,
3650 .procname = "debug",
3651 .data = &cdrom_sysctl_settings.debug,
3652 .maxlen = sizeof(int),
3654 .proc_handler = cdrom_sysctl_handler,
3658 .data = &cdrom_sysctl_settings.lock,
3659 .maxlen = sizeof(int),
3661 .proc_handler = cdrom_sysctl_handler,
3664 .procname = "check_media",
3665 .data = &cdrom_sysctl_settings.check,
3666 .maxlen = sizeof(int),
3668 .proc_handler = cdrom_sysctl_handler
3673 static struct ctl_table cdrom_cdrom_table[] = {
3675 .procname = "cdrom",
3678 .child = cdrom_table,
3683 /* Make sure that /proc/sys/dev is there */
3684 static struct ctl_table cdrom_root_table[] = {
3689 .child = cdrom_cdrom_table,
3693 static struct ctl_table_header *cdrom_sysctl_header;
3695 static void cdrom_sysctl_register(void)
3697 static atomic_t initialized = ATOMIC_INIT(0);
3699 if (!atomic_add_unless(&initialized, 1, 1))
3702 cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3704 /* set the defaults */
3705 cdrom_sysctl_settings.autoclose = autoclose;
3706 cdrom_sysctl_settings.autoeject = autoeject;
3707 cdrom_sysctl_settings.debug = debug;
3708 cdrom_sysctl_settings.lock = lockdoor;
3709 cdrom_sysctl_settings.check = check_media_type;
3712 static void cdrom_sysctl_unregister(void)
3714 if (cdrom_sysctl_header)
3715 unregister_sysctl_table(cdrom_sysctl_header);
3718 #else /* CONFIG_SYSCTL */
3720 static void cdrom_sysctl_register(void)
3724 static void cdrom_sysctl_unregister(void)
3728 #endif /* CONFIG_SYSCTL */
3730 static int __init cdrom_init(void)
3732 cdrom_sysctl_register();
3737 static void __exit cdrom_exit(void)
3739 pr_info("Uniform CD-ROM driver unloaded\n");
3740 cdrom_sysctl_unregister();
3743 module_init(cdrom_init);
3744 module_exit(cdrom_exit);
3745 MODULE_LICENSE("GPL");