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 activly
34 maintain and improve this driver, I am now carrying on the torch. If
35 you have a problem with this driver, please feel free to contact me.
37 -- Added (rudimentary) sysctl interface. I realize this is really weak
38 right now, and is _very_ badly implemented. It will be improved...
40 -- Modified CDROM_DISC_STATUS so that it is now incorporated into
41 the Uniform CD-ROM driver via the cdrom_count_tracks function.
42 The cdrom_count_tracks function helps resolve some of the false
43 assumptions of the CDROM_DISC_STATUS ioctl, and is also used to check
44 for the correct media type when mounting or playing audio from a CD.
46 -- Remove the calls to verify_area and only use the copy_from_user and
47 copy_to_user stuff, since these calls now provide their own memory
48 checking with the 2.1.x kernels.
50 -- Major update to return codes so that errors from low-level drivers
51 are passed on through (thanks to Gerd Knorr for pointing out this
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 REVISION "Revision: 3.20"
246 #define VERSION "Id: cdrom.c 3.20 2003/12/17"
248 /* I use an error-log mask to give fine grain control over the type of
249 messages dumped to the system logs. The available masks include: */
250 #define CD_NOTHING 0x0
251 #define CD_WARNING 0x1
252 #define CD_REG_UNREG 0x2
253 #define CD_DO_IOCTL 0x4
255 #define CD_CLOSE 0x10
256 #define CD_COUNT_TRACKS 0x20
257 #define CD_CHANGER 0x40
260 /* Define this to remove _all_ the debugging messages */
261 /* #define ERRLOGMASK CD_NOTHING */
262 #define ERRLOGMASK CD_WARNING
263 /* #define ERRLOGMASK (CD_WARNING|CD_OPEN|CD_COUNT_TRACKS|CD_CLOSE) */
264 /* #define ERRLOGMASK (CD_WARNING|CD_REG_UNREG|CD_DO_IOCTL|CD_OPEN|CD_CLOSE|CD_COUNT_TRACKS) */
266 #include <linux/module.h>
267 #include <linux/fs.h>
268 #include <linux/buffer_head.h>
269 #include <linux/major.h>
270 #include <linux/types.h>
271 #include <linux/errno.h>
272 #include <linux/kernel.h>
273 #include <linux/mm.h>
274 #include <linux/slab.h>
275 #include <linux/cdrom.h>
276 #include <linux/sysctl.h>
277 #include <linux/proc_fs.h>
278 #include <linux/blkpg.h>
279 #include <linux/init.h>
280 #include <linux/fcntl.h>
281 #include <linux/blkdev.h>
282 #include <linux/times.h>
284 #include <asm/uaccess.h>
286 /* used to tell the module to turn on full debugging messages */
288 /* used to keep tray locked at all times */
289 static int keeplocked;
290 /* default compatibility mode */
291 static int autoclose=1;
292 static int autoeject;
293 static int lockdoor = 1;
294 /* will we ever get to use this... sigh. */
295 static int check_media_type;
296 /* automatically restart mrw format */
297 static int 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 cdinfo(type, fmt, args...) \
318 if ((ERRLOGMASK & type) || debug==1 ) \
319 printk(KERN_INFO "cdrom: " fmt, ## args)
321 #define cdinfo(type, fmt, args...)
324 /* These are used to simplify getting data in from and back to user land */
325 #define IOCTL_IN(arg, type, in) \
326 if (copy_from_user(&(in), (type __user *) (arg), sizeof (in))) \
329 #define IOCTL_OUT(arg, type, out) \
330 if (copy_to_user((type __user *) (arg), &(out), sizeof (out))) \
333 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
334 a lot of places. This macro makes the code more clear. */
335 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
337 /* used in the audio ioctls */
338 #define CHECKAUDIO if ((ret=check_for_audio_disc(cdi, cdo))) return ret
341 * Another popular OS uses 7 seconds as the hard timeout for default
342 * commands, so it is a good choice for us as well.
344 #define CDROM_DEF_TIMEOUT (7 * HZ)
346 /* Not-exported routines. */
347 static int open_for_data(struct cdrom_device_info * cdi);
348 static int check_for_audio_disc(struct cdrom_device_info * cdi,
349 struct cdrom_device_ops * cdo);
350 static void sanitize_format(union cdrom_addr *addr,
351 u_char * curr, u_char requested);
352 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
355 int cdrom_get_last_written(struct cdrom_device_info *, long *);
356 static int cdrom_get_next_writable(struct cdrom_device_info *, long *);
357 static void cdrom_count_tracks(struct cdrom_device_info *, tracktype*);
359 static int cdrom_mrw_exit(struct cdrom_device_info *cdi);
361 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di);
364 static void cdrom_sysctl_register(void);
365 #endif /* CONFIG_SYSCTL */
366 static struct cdrom_device_info *topCdromPtr;
368 static int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
369 struct packet_command *cgc)
372 cgc->sense->sense_key = 0x05;
373 cgc->sense->asc = 0x20;
374 cgc->sense->ascq = 0x00;
381 /* This macro makes sure we don't have to check on cdrom_device_ops
382 * existence in the run-time routines below. Change_capability is a
383 * hack to have the capability flags defined const, while we can still
384 * change it here without gcc complaining at every line.
386 #define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
388 int register_cdrom(struct cdrom_device_info *cdi)
390 static char banner_printed;
391 struct cdrom_device_ops *cdo = cdi->ops;
392 int *change_capability = (int *)&cdo->capability; /* hack */
394 cdinfo(CD_OPEN, "entering register_cdrom\n");
396 if (cdo->open == NULL || cdo->release == NULL)
398 if (!banner_printed) {
399 printk(KERN_INFO "Uniform CD-ROM driver " REVISION "\n");
402 cdrom_sysctl_register();
403 #endif /* CONFIG_SYSCTL */
406 ENSURE(drive_status, CDC_DRIVE_STATUS );
407 ENSURE(media_changed, CDC_MEDIA_CHANGED);
408 ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
409 ENSURE(lock_door, CDC_LOCK);
410 ENSURE(select_speed, CDC_SELECT_SPEED);
411 ENSURE(get_last_session, CDC_MULTI_SESSION);
412 ENSURE(get_mcn, CDC_MCN);
413 ENSURE(reset, CDC_RESET);
414 ENSURE(audio_ioctl, CDC_PLAY_AUDIO);
415 ENSURE(generic_packet, CDC_GENERIC_PACKET);
418 cdi->options = CDO_USE_FFLAGS;
420 if (autoclose==1 && CDROM_CAN(CDC_CLOSE_TRAY))
421 cdi->options |= (int) CDO_AUTO_CLOSE;
422 if (autoeject==1 && CDROM_CAN(CDC_OPEN_TRAY))
423 cdi->options |= (int) CDO_AUTO_EJECT;
425 cdi->options |= (int) CDO_LOCK;
426 if (check_media_type==1)
427 cdi->options |= (int) CDO_CHECK_TYPE;
429 if (CDROM_CAN(CDC_MRW_W))
430 cdi->exit = cdrom_mrw_exit;
433 cdi->cdda_method = CDDA_BPC_FULL;
435 cdi->cdda_method = CDDA_OLD;
437 if (!cdo->generic_packet)
438 cdo->generic_packet = cdrom_dummy_generic_packet;
440 cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
441 mutex_lock(&cdrom_mutex);
442 cdi->next = topCdromPtr;
444 mutex_unlock(&cdrom_mutex);
449 int unregister_cdrom(struct cdrom_device_info *unreg)
451 struct cdrom_device_info *cdi, *prev;
452 cdinfo(CD_OPEN, "entering unregister_cdrom\n");
455 mutex_lock(&cdrom_mutex);
457 while (cdi && cdi != unreg) {
463 mutex_unlock(&cdrom_mutex);
467 prev->next = cdi->next;
469 topCdromPtr = cdi->next;
471 mutex_unlock(&cdrom_mutex);
476 cdi->ops->n_minors--;
477 cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
481 int cdrom_get_media_event(struct cdrom_device_info *cdi,
482 struct media_event_desc *med)
484 struct packet_command cgc;
485 unsigned char buffer[8];
486 struct event_header *eh = (struct event_header *) buffer;
488 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
489 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
490 cgc.cmd[1] = 1; /* IMMED */
491 cgc.cmd[4] = 1 << 4; /* media event */
492 cgc.cmd[8] = sizeof(buffer);
495 if (cdi->ops->generic_packet(cdi, &cgc))
498 if (be16_to_cpu(eh->data_len) < sizeof(*med))
501 if (eh->nea || eh->notification_class != 0x4)
504 memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
509 * the first prototypes used 0x2c as the page code for the mrw mode page,
510 * subsequently this was changed to 0x03. probe the one used by this drive
512 static int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
514 struct packet_command cgc;
517 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
522 if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
523 cdi->mrw_mode_page = MRW_MODE_PC;
525 } else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
526 cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
533 static int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
535 struct packet_command cgc;
536 struct mrw_feature_desc *mfd;
537 unsigned char buffer[16];
542 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
544 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
545 cgc.cmd[3] = CDF_MRW;
546 cgc.cmd[8] = sizeof(buffer);
549 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
552 mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
553 if (be16_to_cpu(mfd->feature_code) != CDF_MRW)
557 if ((ret = cdrom_mrw_probe_pc(cdi))) {
565 static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
567 struct packet_command cgc;
568 unsigned char buffer[12];
571 printk(KERN_INFO "cdrom: %sstarting format\n", cont ? "Re" : "");
574 * FmtData bit set (bit 4), format type is 1
576 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
577 cgc.cmd[0] = GPCMD_FORMAT_UNIT;
578 cgc.cmd[1] = (1 << 4) | 1;
580 cgc.timeout = 5 * 60 * HZ;
583 * 4 byte format list header, 8 byte format list descriptor
596 buffer[8] = 0x24 << 2;
599 ret = cdi->ops->generic_packet(cdi, &cgc);
601 printk(KERN_INFO "cdrom: bgformat failed\n");
606 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
608 struct packet_command cgc;
610 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
611 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
614 * Session = 1, Track = 0
616 cgc.cmd[1] = !!immed;
619 cgc.timeout = 5 * 60 * HZ;
621 return cdi->ops->generic_packet(cdi, &cgc);
624 static int cdrom_flush_cache(struct cdrom_device_info *cdi)
626 struct packet_command cgc;
628 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
629 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
631 cgc.timeout = 5 * 60 * HZ;
633 return cdi->ops->generic_packet(cdi, &cgc);
636 static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
641 ret = cdrom_get_disc_info(cdi, &di);
642 if (ret < 0 || ret < (int)offsetof(typeof(di),disc_type))
646 if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
647 printk(KERN_INFO "cdrom: issuing MRW back ground "
649 ret = cdrom_mrw_bgformat_susp(cdi, 0);
652 if (!ret && cdi->media_written)
653 ret = cdrom_flush_cache(cdi);
658 static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
660 struct packet_command cgc;
661 struct mode_page_header *mph;
663 int ret, offset, size;
665 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
668 cgc.buflen = sizeof(buffer);
670 if ((ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0)))
673 mph = (struct mode_page_header *) buffer;
674 offset = be16_to_cpu(mph->desc_length);
675 size = be16_to_cpu(mph->mode_data_length) + 2;
677 buffer[offset + 3] = space;
680 if ((ret = cdrom_mode_select(cdi, &cgc)))
683 printk(KERN_INFO "cdrom: %s: mrw address space %s selected\n", cdi->name, mrw_address_space[space]);
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 printk(KERN_ERR "cdrom: 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 printk(KERN_INFO "cdrom open: mrw_status '%s'\n",
807 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 cdinfo(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 */
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 cdinfo(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
952 if (!cdi->media_written) {
953 cdinfo(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
957 printk(KERN_INFO "cdrom: %s: dirty DVD+RW media, \"finalizing\"\n",
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 /* We use the open-option O_NONBLOCK to indicate that the
991 * purpose of opening is only for subsequent ioctl() calls; no device
992 * integrity checks are performed.
994 * We hope that all cd-player programs will adopt this convention. It
995 * is in their own interest: device control becomes a lot easier
998 int cdrom_open(struct cdrom_device_info *cdi, struct inode *ip, struct file *fp)
1002 cdinfo(CD_OPEN, "entering cdrom_open\n");
1004 /* if this was a O_NONBLOCK open and we should honor the flags,
1005 * do a quick open without drive/disc integrity checks. */
1007 if ((fp->f_flags & O_NONBLOCK) && (cdi->options & CDO_USE_FFLAGS)) {
1008 ret = cdi->ops->open(cdi, 1);
1010 ret = open_for_data(cdi);
1013 cdrom_mmc3_profile(cdi);
1014 if (fp->f_mode & FMODE_WRITE) {
1016 if (cdrom_open_write(cdi))
1018 if (!CDROM_CAN(CDC_RAM))
1021 cdi->media_written = 0;
1028 cdinfo(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1029 cdi->name, cdi->use_count);
1030 /* Do this on open. Don't wait for mount, because they might
1031 not be mounting, but opening with O_NONBLOCK */
1032 check_disk_change(ip->i_bdev);
1035 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1036 cdi->ops->lock_door(cdi, 0);
1037 cdinfo(CD_OPEN, "door unlocked.\n");
1039 cdi->ops->release(cdi);
1046 int open_for_data(struct cdrom_device_info * cdi)
1049 struct cdrom_device_ops *cdo = cdi->ops;
1051 cdinfo(CD_OPEN, "entering open_for_data\n");
1052 /* Check if the driver can report drive status. If it can, we
1053 can do clever things. If it can't, well, we at least tried! */
1054 if (cdo->drive_status != NULL) {
1055 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1056 cdinfo(CD_OPEN, "drive_status=%d\n", ret);
1057 if (ret == CDS_TRAY_OPEN) {
1058 cdinfo(CD_OPEN, "the tray is open...\n");
1059 /* can/may i close it? */
1060 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1061 cdi->options & CDO_AUTO_CLOSE) {
1062 cdinfo(CD_OPEN, "trying to close the tray.\n");
1063 ret=cdo->tray_move(cdi,0);
1065 cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1066 /* Ignore the error from the low
1067 level driver. We don't care why it
1068 couldn't close the tray. We only care
1069 that there is no disc in the drive,
1070 since that is the _REAL_ problem here.*/
1072 goto clean_up_and_return;
1075 cdinfo(CD_OPEN, "bummer. this drive can't close the tray.\n");
1077 goto clean_up_and_return;
1079 /* Ok, the door should be closed now.. Check again */
1080 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1081 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1082 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
1083 cdinfo(CD_OPEN, "tray might not contain a medium.\n");
1085 goto clean_up_and_return;
1087 cdinfo(CD_OPEN, "the tray is now closed.\n");
1089 /* the door should be closed now, check for the disc */
1090 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1091 if (ret!=CDS_DISC_OK) {
1093 goto clean_up_and_return;
1096 cdrom_count_tracks(cdi, &tracks);
1097 if (tracks.error == CDS_NO_DISC) {
1098 cdinfo(CD_OPEN, "bummer. no disc.\n");
1100 goto clean_up_and_return;
1102 /* CD-Players which don't use O_NONBLOCK, workman
1103 * for example, need bit CDO_CHECK_TYPE cleared! */
1104 if (tracks.data==0) {
1105 if (cdi->options & CDO_CHECK_TYPE) {
1106 /* give people a warning shot, now that CDO_CHECK_TYPE
1107 is the default case! */
1108 cdinfo(CD_OPEN, "bummer. wrong media type.\n");
1109 cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1110 (unsigned int)task_pid_nr(current));
1112 goto clean_up_and_return;
1115 cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.\n");
1119 cdinfo(CD_OPEN, "all seems well, opening the device.\n");
1121 /* all seems well, we can open the device */
1122 ret = cdo->open(cdi, 0); /* open for data */
1123 cdinfo(CD_OPEN, "opening the device gave me %d.\n", ret);
1124 /* After all this careful checking, we shouldn't have problems
1125 opening the device, but we don't want the device locked if
1126 this somehow fails... */
1128 cdinfo(CD_OPEN, "open device failed.\n");
1129 goto clean_up_and_return;
1131 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1132 cdo->lock_door(cdi, 1);
1133 cdinfo(CD_OPEN, "door locked.\n");
1135 cdinfo(CD_OPEN, "device opened successfully.\n");
1138 /* Something failed. Try to unlock the drive, because some drivers
1139 (notably ide-cd) lock the drive after every command. This produced
1140 a nasty bug where after mount failed, the drive would remain locked!
1141 This ensures that the drive gets unlocked after a mount fails. This
1142 is a goto to avoid bloating the driver with redundant code. */
1143 clean_up_and_return:
1144 cdinfo(CD_OPEN, "open failed.\n");
1145 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1146 cdo->lock_door(cdi, 0);
1147 cdinfo(CD_OPEN, "door unlocked.\n");
1152 /* This code is similar to that in open_for_data. The routine is called
1153 whenever an audio play operation is requested.
1155 int check_for_audio_disc(struct cdrom_device_info * cdi,
1156 struct cdrom_device_ops * cdo)
1160 cdinfo(CD_OPEN, "entering check_for_audio_disc\n");
1161 if (!(cdi->options & CDO_CHECK_TYPE))
1163 if (cdo->drive_status != NULL) {
1164 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1165 cdinfo(CD_OPEN, "drive_status=%d\n", ret);
1166 if (ret == CDS_TRAY_OPEN) {
1167 cdinfo(CD_OPEN, "the tray is open...\n");
1168 /* can/may i close it? */
1169 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1170 cdi->options & CDO_AUTO_CLOSE) {
1171 cdinfo(CD_OPEN, "trying to close the tray.\n");
1172 ret=cdo->tray_move(cdi,0);
1174 cdinfo(CD_OPEN, "bummer. tried to close tray but failed.\n");
1175 /* Ignore the error from the low
1176 level driver. We don't care why it
1177 couldn't close the tray. We only care
1178 that there is no disc in the drive,
1179 since that is the _REAL_ problem here.*/
1183 cdinfo(CD_OPEN, "bummer. this driver can't close the tray.\n");
1186 /* Ok, the door should be closed now.. Check again */
1187 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1188 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1189 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
1192 if (ret!=CDS_DISC_OK) {
1193 cdinfo(CD_OPEN, "bummer. disc isn't ready.\n");
1196 cdinfo(CD_OPEN, "the tray is now closed.\n");
1199 cdrom_count_tracks(cdi, &tracks);
1201 return(tracks.error);
1203 if (tracks.audio==0)
1204 return -EMEDIUMTYPE;
1209 int cdrom_release(struct cdrom_device_info *cdi, struct file *fp)
1211 struct cdrom_device_ops *cdo = cdi->ops;
1212 int opened_for_data;
1214 cdinfo(CD_CLOSE, "entering cdrom_release\n");
1216 if (cdi->use_count > 0)
1219 if (cdi->use_count == 0) {
1220 cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
1221 cdrom_dvd_rw_close_write(cdi);
1223 if ((cdo->capability & CDC_LOCK) && !keeplocked) {
1224 cdinfo(CD_CLOSE, "Unlocking door!\n");
1225 cdo->lock_door(cdi, 0);
1229 opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1230 !(fp && fp->f_flags & O_NONBLOCK);
1233 * flush cache on last write release
1235 if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1236 cdrom_close_write(cdi);
1239 if (cdi->use_count == 0) { /* last process that closes dev*/
1240 if (opened_for_data &&
1241 cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1242 cdo->tray_move(cdi, 1);
1247 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1248 struct cdrom_changer_info *buf)
1250 struct packet_command cgc;
1251 struct cdrom_device_ops *cdo = cdi->ops;
1255 * Sanyo changer isn't spec compliant (doesn't use regular change
1256 * LOAD_UNLOAD command, and it doesn't implement the mech status
1259 if (cdi->sanyo_slot) {
1260 buf->hdr.nslots = 3;
1261 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1262 for (length = 0; length < 3; length++) {
1263 buf->slots[length].disc_present = 1;
1264 buf->slots[length].change = 0;
1269 length = sizeof(struct cdrom_mechstat_header) +
1270 cdi->capacity * sizeof(struct cdrom_slot);
1272 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1273 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1274 cgc.cmd[8] = (length >> 8) & 0xff;
1275 cgc.cmd[9] = length & 0xff;
1276 return cdo->generic_packet(cdi, &cgc);
1279 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1281 struct cdrom_changer_info *info;
1284 cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n");
1285 if (cdi->sanyo_slot)
1288 info = kmalloc(sizeof(*info), GFP_KERNEL);
1292 if ((ret = cdrom_read_mech_status(cdi, info)))
1295 if (info->slots[slot].disc_present)
1305 /* Return the number of slots for an ATAPI/SCSI cdrom,
1306 * return 1 if not a changer.
1308 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1312 struct cdrom_changer_info *info;
1314 cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1315 /* cdrom_read_mech_status requires a valid value for capacity: */
1318 info = kmalloc(sizeof(*info), GFP_KERNEL);
1322 if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1323 nslots = info->hdr.nslots;
1330 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1331 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1333 struct packet_command cgc;
1335 cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n");
1336 if (cdi->sanyo_slot && slot < 0)
1339 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1340 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1341 cgc.cmd[4] = 2 + (slot >= 0);
1343 cgc.timeout = 60 * HZ;
1345 /* The Sanyo 3 CD changer uses byte 7 of the
1346 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1347 using the GPCMD_LOAD_UNLOAD opcode. */
1348 if (cdi->sanyo_slot && -1 < slot) {
1349 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1351 cgc.cmd[4] = cgc.cmd[8] = 0;
1352 cdi->sanyo_slot = slot ? slot : 3;
1355 return cdi->ops->generic_packet(cdi, &cgc);
1358 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1360 struct cdrom_changer_info *info;
1364 cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n");
1365 if (!CDROM_CAN(CDC_SELECT_DISC))
1366 return -EDRIVE_CANT_DO_THIS;
1368 (void) cdi->ops->media_changed(cdi, slot);
1370 if (slot == CDSL_NONE) {
1371 /* set media changed bits, on both queues */
1372 cdi->mc_flags = 0x3;
1373 return cdrom_load_unload(cdi, -1);
1376 info = kmalloc(sizeof(*info), GFP_KERNEL);
1380 if ((ret = cdrom_read_mech_status(cdi, info))) {
1385 curslot = info->hdr.curslot;
1388 if (cdi->use_count > 1 || keeplocked) {
1389 if (slot == CDSL_CURRENT) {
1396 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1397 which is useful if it had been previously unloaded.
1398 Whether it can or not, it returns the current slot.
1399 Similarly, if slot happens to be the current one, we still
1401 if (slot == CDSL_CURRENT)
1404 /* set media changed bits on both queues */
1405 cdi->mc_flags = 0x3;
1406 if ((ret = cdrom_load_unload(cdi, slot)))
1412 /* We want to make media_changed accessible to the user through an
1413 * ioctl. The main problem now is that we must double-buffer the
1414 * low-level implementation, to assure that the VFS and the user both
1415 * see a medium change once.
1419 int media_changed(struct cdrom_device_info *cdi, int queue)
1421 unsigned int mask = (1 << (queue & 1));
1422 int ret = !!(cdi->mc_flags & mask);
1424 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1426 /* changed since last call? */
1427 if (cdi->ops->media_changed(cdi, CDSL_CURRENT)) {
1428 cdi->mc_flags = 0x3; /* set bit on both queues */
1430 cdi->media_written = 0;
1432 cdi->mc_flags &= ~mask; /* clear bit */
1436 int cdrom_media_changed(struct cdrom_device_info *cdi)
1438 /* This talks to the VFS, which doesn't like errors - just 1 or 0.
1439 * Returning "0" is always safe (media hasn't been changed). Do that
1440 * if the low-level cdrom driver dosn't support media changed. */
1441 if (cdi == NULL || cdi->ops->media_changed == NULL)
1443 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1445 return media_changed(cdi, 0);
1448 /* badly broken, I know. Is due for a fixup anytime. */
1449 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1451 struct cdrom_tochdr header;
1452 struct cdrom_tocentry entry;
1459 cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1460 if (!CDROM_CAN(CDC_PLAY_AUDIO)) {
1461 tracks->error=CDS_NO_INFO;
1464 /* Grab the TOC header so we can see how many tracks there are */
1465 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1466 if (ret == -ENOMEDIUM)
1467 tracks->error = CDS_NO_DISC;
1469 tracks->error = CDS_NO_INFO;
1472 /* check what type of tracks are on this disc */
1473 entry.cdte_format = CDROM_MSF;
1474 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1475 entry.cdte_track = i;
1476 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1477 tracks->error=CDS_NO_INFO;
1480 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1481 if (entry.cdte_format == 0x10)
1483 else if (entry.cdte_format == 0x20)
1489 cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1490 i, entry.cdte_format, entry.cdte_ctrl);
1492 cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1493 header.cdth_trk1, tracks->audio, tracks->data,
1494 tracks->cdi, tracks->xa);
1497 /* Requests to the low-level drivers will /always/ be done in the
1498 following format convention:
1500 CDROM_LBA: all data-related requests.
1501 CDROM_MSF: all audio-related requests.
1503 However, a low-level implementation is allowed to refuse this
1504 request, and return information in its own favorite format.
1506 It doesn't make sense /at all/ to ask for a play_audio in LBA
1507 format, or ask for multi-session info in MSF format. However, for
1508 backward compatibility these format requests will be satisfied, but
1509 the requests to the low-level drivers will be sanitized in the more
1510 meaningful format indicated above.
1514 void sanitize_format(union cdrom_addr *addr,
1515 u_char * curr, u_char requested)
1517 if (*curr == requested)
1518 return; /* nothing to be done! */
1519 if (requested == CDROM_LBA) {
1520 addr->lba = (int) addr->msf.frame +
1521 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1522 } else { /* CDROM_MSF */
1523 int lba = addr->lba;
1524 addr->msf.frame = lba % 75;
1527 addr->msf.second = lba % 60;
1528 addr->msf.minute = lba / 60;
1533 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1536 memset(cgc, 0, sizeof(struct packet_command));
1538 memset(buf, 0, len);
1539 cgc->buffer = (char *) buf;
1541 cgc->data_direction = type;
1542 cgc->timeout = CDROM_DEF_TIMEOUT;
1547 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1548 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1550 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1552 cgc->cmd[0] = GPCMD_REPORT_KEY;
1553 cgc->cmd[10] = type | (agid << 6);
1555 case 0: case 8: case 5: {
1568 cgc->cmd[9] = cgc->buflen;
1569 cgc->data_direction = CGC_DATA_READ;
1572 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1574 cgc->cmd[0] = GPCMD_SEND_KEY;
1575 cgc->cmd[10] = type | (agid << 6);
1590 cgc->cmd[9] = cgc->buflen;
1591 cgc->data_direction = CGC_DATA_WRITE;
1594 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1598 struct packet_command cgc;
1599 struct cdrom_device_ops *cdo = cdi->ops;
1600 rpc_state_t rpc_state;
1602 memset(buf, 0, sizeof(buf));
1603 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1607 case DVD_LU_SEND_AGID:
1608 cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1610 setup_report_key(&cgc, ai->lsa.agid, 0);
1612 if ((ret = cdo->generic_packet(cdi, &cgc)))
1615 ai->lsa.agid = buf[7] >> 6;
1616 /* Returning data, let host change state */
1619 case DVD_LU_SEND_KEY1:
1620 cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1621 setup_report_key(&cgc, ai->lsk.agid, 2);
1623 if ((ret = cdo->generic_packet(cdi, &cgc)))
1626 copy_key(ai->lsk.key, &buf[4]);
1627 /* Returning data, let host change state */
1630 case DVD_LU_SEND_CHALLENGE:
1631 cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1632 setup_report_key(&cgc, ai->lsc.agid, 1);
1634 if ((ret = cdo->generic_packet(cdi, &cgc)))
1637 copy_chal(ai->lsc.chal, &buf[4]);
1638 /* Returning data, let host change state */
1642 case DVD_LU_SEND_TITLE_KEY:
1643 cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1645 setup_report_key(&cgc, ai->lstk.agid, 4);
1646 cgc.cmd[5] = ai->lstk.lba;
1647 cgc.cmd[4] = ai->lstk.lba >> 8;
1648 cgc.cmd[3] = ai->lstk.lba >> 16;
1649 cgc.cmd[2] = ai->lstk.lba >> 24;
1651 if ((ret = cdo->generic_packet(cdi, &cgc)))
1654 ai->lstk.cpm = (buf[4] >> 7) & 1;
1655 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1656 ai->lstk.cgms = (buf[4] >> 4) & 3;
1657 copy_key(ai->lstk.title_key, &buf[5]);
1658 /* Returning data, let host change state */
1661 case DVD_LU_SEND_ASF:
1662 cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1663 setup_report_key(&cgc, ai->lsasf.agid, 5);
1665 if ((ret = cdo->generic_packet(cdi, &cgc)))
1668 ai->lsasf.asf = buf[7] & 1;
1671 /* LU data receive (LU changes state) */
1672 case DVD_HOST_SEND_CHALLENGE:
1673 cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1674 setup_send_key(&cgc, ai->hsc.agid, 1);
1676 copy_chal(&buf[4], ai->hsc.chal);
1678 if ((ret = cdo->generic_packet(cdi, &cgc)))
1681 ai->type = DVD_LU_SEND_KEY1;
1684 case DVD_HOST_SEND_KEY2:
1685 cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1686 setup_send_key(&cgc, ai->hsk.agid, 3);
1688 copy_key(&buf[4], ai->hsk.key);
1690 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1691 ai->type = DVD_AUTH_FAILURE;
1694 ai->type = DVD_AUTH_ESTABLISHED;
1698 case DVD_INVALIDATE_AGID:
1700 cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1701 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1702 if ((ret = cdo->generic_packet(cdi, &cgc)))
1706 /* Get region settings */
1707 case DVD_LU_SEND_RPC_STATE:
1708 cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1709 setup_report_key(&cgc, 0, 8);
1710 memset(&rpc_state, 0, sizeof(rpc_state_t));
1711 cgc.buffer = (char *) &rpc_state;
1713 if ((ret = cdo->generic_packet(cdi, &cgc)))
1716 ai->lrpcs.type = rpc_state.type_code;
1717 ai->lrpcs.vra = rpc_state.vra;
1718 ai->lrpcs.ucca = rpc_state.ucca;
1719 ai->lrpcs.region_mask = rpc_state.region_mask;
1720 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1723 /* Set region settings */
1724 case DVD_HOST_SEND_RPC_STATE:
1725 cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1726 setup_send_key(&cgc, 0, 6);
1728 buf[4] = ai->hrpcs.pdrc;
1730 if ((ret = cdo->generic_packet(cdi, &cgc)))
1735 cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1742 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
1744 unsigned char buf[21], *base;
1745 struct dvd_layer *layer;
1746 struct packet_command cgc;
1747 struct cdrom_device_ops *cdo = cdi->ops;
1748 int ret, layer_num = s->physical.layer_num;
1750 if (layer_num >= DVD_LAYERS)
1753 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1754 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1755 cgc.cmd[6] = layer_num;
1756 cgc.cmd[7] = s->type;
1757 cgc.cmd[9] = cgc.buflen & 0xff;
1760 * refrain from reporting errors on non-existing layers (mainly)
1764 if ((ret = cdo->generic_packet(cdi, &cgc)))
1768 layer = &s->physical.layer[layer_num];
1771 * place the data... really ugly, but at least we won't have to
1772 * worry about endianess in userspace.
1774 memset(layer, 0, sizeof(*layer));
1775 layer->book_version = base[0] & 0xf;
1776 layer->book_type = base[0] >> 4;
1777 layer->min_rate = base[1] & 0xf;
1778 layer->disc_size = base[1] >> 4;
1779 layer->layer_type = base[2] & 0xf;
1780 layer->track_path = (base[2] >> 4) & 1;
1781 layer->nlayers = (base[2] >> 5) & 3;
1782 layer->track_density = base[3] & 0xf;
1783 layer->linear_density = base[3] >> 4;
1784 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1785 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1786 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1787 layer->bca = base[16] >> 7;
1792 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
1796 struct packet_command cgc;
1797 struct cdrom_device_ops *cdo = cdi->ops;
1799 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1800 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1801 cgc.cmd[6] = s->copyright.layer_num;
1802 cgc.cmd[7] = s->type;
1803 cgc.cmd[8] = cgc.buflen >> 8;
1804 cgc.cmd[9] = cgc.buflen & 0xff;
1806 if ((ret = cdo->generic_packet(cdi, &cgc)))
1809 s->copyright.cpst = buf[4];
1810 s->copyright.rmi = buf[5];
1815 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s)
1819 struct packet_command cgc;
1820 struct cdrom_device_ops *cdo = cdi->ops;
1822 size = sizeof(s->disckey.value) + 4;
1824 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1827 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1828 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1829 cgc.cmd[7] = s->type;
1830 cgc.cmd[8] = size >> 8;
1831 cgc.cmd[9] = size & 0xff;
1832 cgc.cmd[10] = s->disckey.agid << 6;
1834 if (!(ret = cdo->generic_packet(cdi, &cgc)))
1835 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1841 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s)
1844 u_char buf[4 + 188];
1845 struct packet_command cgc;
1846 struct cdrom_device_ops *cdo = cdi->ops;
1848 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1849 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1850 cgc.cmd[7] = s->type;
1851 cgc.cmd[9] = cgc.buflen & 0xff;
1853 if ((ret = cdo->generic_packet(cdi, &cgc)))
1856 s->bca.len = buf[0] << 8 | buf[1];
1857 if (s->bca.len < 12 || s->bca.len > 188) {
1858 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1861 memcpy(s->bca.value, &buf[4], s->bca.len);
1866 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s)
1870 struct packet_command cgc;
1871 struct cdrom_device_ops *cdo = cdi->ops;
1873 size = sizeof(s->manufact.value) + 4;
1875 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1878 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1879 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1880 cgc.cmd[7] = s->type;
1881 cgc.cmd[8] = size >> 8;
1882 cgc.cmd[9] = size & 0xff;
1884 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1889 s->manufact.len = buf[0] << 8 | buf[1];
1890 if (s->manufact.len < 0 || s->manufact.len > 2048) {
1891 cdinfo(CD_WARNING, "Received invalid manufacture info length"
1892 " (%d)\n", s->manufact.len);
1895 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1902 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s)
1905 case DVD_STRUCT_PHYSICAL:
1906 return dvd_read_physical(cdi, s);
1908 case DVD_STRUCT_COPYRIGHT:
1909 return dvd_read_copyright(cdi, s);
1911 case DVD_STRUCT_DISCKEY:
1912 return dvd_read_disckey(cdi, s);
1914 case DVD_STRUCT_BCA:
1915 return dvd_read_bca(cdi, s);
1917 case DVD_STRUCT_MANUFACT:
1918 return dvd_read_manufact(cdi, s);
1921 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1927 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1928 struct packet_command *cgc,
1929 int page_code, int page_control)
1931 struct cdrom_device_ops *cdo = cdi->ops;
1933 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1935 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1936 cgc->cmd[2] = page_code | (page_control << 6);
1937 cgc->cmd[7] = cgc->buflen >> 8;
1938 cgc->cmd[8] = cgc->buflen & 0xff;
1939 cgc->data_direction = CGC_DATA_READ;
1940 return cdo->generic_packet(cdi, cgc);
1943 int cdrom_mode_select(struct cdrom_device_info *cdi,
1944 struct packet_command *cgc)
1946 struct cdrom_device_ops *cdo = cdi->ops;
1948 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1949 memset(cgc->buffer, 0, 2);
1950 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1951 cgc->cmd[1] = 0x10; /* PF */
1952 cgc->cmd[7] = cgc->buflen >> 8;
1953 cgc->cmd[8] = cgc->buflen & 0xff;
1954 cgc->data_direction = CGC_DATA_WRITE;
1955 return cdo->generic_packet(cdi, cgc);
1958 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
1959 struct cdrom_subchnl *subchnl, int mcn)
1961 struct cdrom_device_ops *cdo = cdi->ops;
1962 struct packet_command cgc;
1966 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1967 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
1968 cgc.cmd[1] = 2; /* MSF addressing */
1969 cgc.cmd[2] = 0x40; /* request subQ data */
1970 cgc.cmd[3] = mcn ? 2 : 1;
1973 if ((ret = cdo->generic_packet(cdi, &cgc)))
1976 subchnl->cdsc_audiostatus = cgc.buffer[1];
1977 subchnl->cdsc_format = CDROM_MSF;
1978 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
1979 subchnl->cdsc_trk = cgc.buffer[6];
1980 subchnl->cdsc_ind = cgc.buffer[7];
1982 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
1983 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
1984 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
1985 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
1986 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
1987 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
1993 * Specific READ_10 interface
1995 static int cdrom_read_cd(struct cdrom_device_info *cdi,
1996 struct packet_command *cgc, int lba,
1997 int blocksize, int nblocks)
1999 struct cdrom_device_ops *cdo = cdi->ops;
2001 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2002 cgc->cmd[0] = GPCMD_READ_10;
2003 cgc->cmd[2] = (lba >> 24) & 0xff;
2004 cgc->cmd[3] = (lba >> 16) & 0xff;
2005 cgc->cmd[4] = (lba >> 8) & 0xff;
2006 cgc->cmd[5] = lba & 0xff;
2007 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2008 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2009 cgc->cmd[8] = nblocks & 0xff;
2010 cgc->buflen = blocksize * nblocks;
2011 return cdo->generic_packet(cdi, cgc);
2014 /* very generic interface for reading the various types of blocks */
2015 static int cdrom_read_block(struct cdrom_device_info *cdi,
2016 struct packet_command *cgc,
2017 int lba, int nblocks, int format, int blksize)
2019 struct cdrom_device_ops *cdo = cdi->ops;
2021 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2022 cgc->cmd[0] = GPCMD_READ_CD;
2023 /* expected sector size - cdda,mode1,etc. */
2024 cgc->cmd[1] = format << 2;
2025 /* starting address */
2026 cgc->cmd[2] = (lba >> 24) & 0xff;
2027 cgc->cmd[3] = (lba >> 16) & 0xff;
2028 cgc->cmd[4] = (lba >> 8) & 0xff;
2029 cgc->cmd[5] = lba & 0xff;
2030 /* number of blocks */
2031 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2032 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2033 cgc->cmd[8] = nblocks & 0xff;
2034 cgc->buflen = blksize * nblocks;
2036 /* set the header info returned */
2038 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
2039 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
2040 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
2041 default : cgc->cmd[9] = 0x10;
2044 return cdo->generic_packet(cdi, cgc);
2047 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2048 int lba, int nframes)
2050 struct packet_command cgc;
2054 cdi->last_sense = 0;
2056 memset(&cgc, 0, sizeof(cgc));
2059 * start with will ra.nframes size, back down if alloc fails
2063 cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2073 if (!access_ok(VERIFY_WRITE, ubuf, nframes * CD_FRAMESIZE_RAW)) {
2078 cgc.data_direction = CGC_DATA_READ;
2079 while (nframes > 0) {
2083 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2086 if (__copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2090 ubuf += CD_FRAMESIZE_RAW * nr;
2099 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2100 int lba, int nframes)
2102 struct request_queue *q = cdi->disk->queue;
2111 rq = blk_get_request(q, READ, GFP_KERNEL);
2115 cdi->last_sense = 0;
2119 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2121 if (nr * CD_FRAMESIZE_RAW > (q->max_sectors << 9))
2122 nr = (q->max_sectors << 9) / CD_FRAMESIZE_RAW;
2124 len = nr * CD_FRAMESIZE_RAW;
2126 ret = blk_rq_map_user(q, rq, ubuf, len);
2130 memset(rq->cmd, 0, sizeof(rq->cmd));
2131 rq->cmd[0] = GPCMD_READ_CD;
2132 rq->cmd[1] = 1 << 2;
2133 rq->cmd[2] = (lba >> 24) & 0xff;
2134 rq->cmd[3] = (lba >> 16) & 0xff;
2135 rq->cmd[4] = (lba >> 8) & 0xff;
2136 rq->cmd[5] = lba & 0xff;
2137 rq->cmd[6] = (nr >> 16) & 0xff;
2138 rq->cmd[7] = (nr >> 8) & 0xff;
2139 rq->cmd[8] = nr & 0xff;
2143 rq->cmd_type = REQ_TYPE_BLOCK_PC;
2144 rq->timeout = 60 * HZ;
2147 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2148 struct request_sense *s = rq->sense;
2150 cdi->last_sense = s->sense_key;
2153 if (blk_rq_unmap_user(bio))
2164 blk_put_request(rq);
2168 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2169 int lba, int nframes)
2173 if (cdi->cdda_method == CDDA_OLD)
2174 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2178 * for anything else than success and io error, we need to retry
2180 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2181 if (!ret || ret != -EIO)
2185 * I've seen drives get sense 4/8/3 udma crc errors on multi
2186 * frame dma, so drop to single frame dma if we need to
2188 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2189 printk("cdrom: dropping to single frame dma\n");
2190 cdi->cdda_method = CDDA_BPC_SINGLE;
2195 * so we have an io error of some sort with multi frame dma. if the
2196 * condition wasn't a hardware error
2197 * problems, not for any error
2199 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2202 printk("cdrom: dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2203 cdi->cdda_method = CDDA_OLD;
2204 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2207 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2210 struct cdrom_multisession ms_info;
2211 u8 requested_format;
2214 cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2216 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2219 if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2222 requested_format = ms_info.addr_format;
2223 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2225 ms_info.addr_format = CDROM_LBA;
2227 ret = cdi->ops->get_last_session(cdi, &ms_info);
2231 sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2233 if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2236 cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2240 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2242 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2244 if (!CDROM_CAN(CDC_OPEN_TRAY))
2246 if (cdi->use_count != 1 || keeplocked)
2248 if (CDROM_CAN(CDC_LOCK)) {
2249 int ret = cdi->ops->lock_door(cdi, 0);
2254 return cdi->ops->tray_move(cdi, 1);
2257 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2259 cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2261 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2263 return cdi->ops->tray_move(cdi, 0);
2266 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2269 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2271 if (!CDROM_CAN(CDC_OPEN_TRAY))
2276 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2278 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2282 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2285 struct cdrom_changer_info *info;
2288 cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2290 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2293 /* cannot select disc or select current disc */
2294 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2295 return media_changed(cdi, 1);
2297 if ((unsigned int)arg >= cdi->capacity)
2300 info = kmalloc(sizeof(*info), GFP_KERNEL);
2304 ret = cdrom_read_mech_status(cdi, info);
2306 ret = info->slots[arg].change;
2311 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2314 cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2317 * Options need to be in sync with capability.
2318 * Too late for that, so we have to check each one separately.
2321 case CDO_USE_FFLAGS:
2322 case CDO_CHECK_TYPE:
2325 if (!CDROM_CAN(CDC_LOCK))
2329 return cdi->options;
2330 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2332 if (!CDROM_CAN(arg))
2335 cdi->options |= (int) arg;
2336 return cdi->options;
2339 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2342 cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2344 cdi->options &= ~(int) arg;
2345 return cdi->options;
2348 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2351 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2353 if (!CDROM_CAN(CDC_SELECT_SPEED))
2355 return cdi->ops->select_speed(cdi, arg);
2358 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2361 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2363 if (!CDROM_CAN(CDC_SELECT_DISC))
2366 if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2367 if ((int)arg >= cdi->capacity)
2372 * ->select_disc is a hook to allow a driver-specific way of
2373 * seleting disc. However, since there is no equivalent hook for
2374 * cdrom_slot_status this may not actually be useful...
2376 if (cdi->ops->select_disc)
2377 return cdi->ops->select_disc(cdi, arg);
2379 cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2380 return cdrom_select_disc(cdi, arg);
2383 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2384 struct block_device *bdev)
2386 cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2388 if (!capable(CAP_SYS_ADMIN))
2390 if (!CDROM_CAN(CDC_RESET))
2392 invalidate_bdev(bdev);
2393 return cdi->ops->reset(cdi);
2396 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2399 cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2401 if (!CDROM_CAN(CDC_LOCK))
2402 return -EDRIVE_CANT_DO_THIS;
2404 keeplocked = arg ? 1 : 0;
2407 * Don't unlock the door on multiple opens by default, but allow
2410 if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2412 return cdi->ops->lock_door(cdi, arg);
2415 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2418 cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2420 if (!capable(CAP_SYS_ADMIN))
2422 debug = arg ? 1 : 0;
2426 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2428 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2429 return (cdi->ops->capability & ~cdi->mask);
2433 * The following function is implemented, although very few audio
2434 * discs give Universal Product Code information, which should just be
2435 * the Medium Catalog Number on the box. Note, that the way the code
2436 * is written on the CD is /not/ uniform across all discs!
2438 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2441 struct cdrom_mcn mcn;
2444 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2446 if (!(cdi->ops->capability & CDC_MCN))
2448 ret = cdi->ops->get_mcn(cdi, &mcn);
2452 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2454 cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2458 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2461 cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2463 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2465 if (!CDROM_CAN(CDC_SELECT_DISC) ||
2466 (arg == CDSL_CURRENT || arg == CDSL_NONE))
2467 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2468 if (((int)arg >= cdi->capacity))
2470 return cdrom_slot_status(cdi, arg);
2474 * Ok, this is where problems start. The current interface for the
2475 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2476 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunatly, while this
2477 * is often the case, it is also very common for CDs to have some tracks
2478 * with data, and some tracks with audio. Just because I feel like it,
2479 * I declare the following to be the best way to cope. If the CD has ANY
2480 * data tracks on it, it will be returned as a data CD. If it has any XA
2481 * tracks, I will return it as that. Now I could simplify this interface
2482 * by combining these returns with the above, but this more clearly
2483 * demonstrates the problem with the current interface. Too bad this
2484 * wasn't designed to use bitmasks... -Erik
2486 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2487 * User level programmers might feel the ioctl is not very useful.
2490 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2494 cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2496 cdrom_count_tracks(cdi, &tracks);
2498 return tracks.error;
2500 /* Policy mode on */
2501 if (tracks.audio > 0) {
2502 if (!tracks.data && !tracks.cdi && !tracks.xa)
2512 if (tracks.data > 0)
2514 /* Policy mode off */
2516 cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2520 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2522 cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2523 return cdi->capacity;
2526 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2529 struct cdrom_subchnl q;
2533 /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2535 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2537 if (copy_from_user(&q, argp, sizeof(q)))
2540 requested = q.cdsc_format;
2541 if (requested != CDROM_MSF && requested != CDROM_LBA)
2543 q.cdsc_format = CDROM_MSF;
2545 ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2549 back = q.cdsc_format; /* local copy */
2550 sanitize_format(&q.cdsc_absaddr, &back, requested);
2551 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2553 if (copy_to_user(argp, &q, sizeof(q)))
2555 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2559 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2562 struct cdrom_tochdr header;
2565 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2567 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2569 if (copy_from_user(&header, argp, sizeof(header)))
2572 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2576 if (copy_to_user(argp, &header, sizeof(header)))
2578 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2582 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2585 struct cdrom_tocentry entry;
2586 u8 requested_format;
2589 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2591 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2593 if (copy_from_user(&entry, argp, sizeof(entry)))
2596 requested_format = entry.cdte_format;
2597 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2599 /* make interface to low-level uniform */
2600 entry.cdte_format = CDROM_MSF;
2601 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2604 sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2606 if (copy_to_user(argp, &entry, sizeof(entry)))
2608 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2612 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2615 struct cdrom_msf msf;
2617 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2619 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2621 if (copy_from_user(&msf, argp, sizeof(msf)))
2623 return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2626 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2632 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2634 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2636 if (copy_from_user(&ti, argp, sizeof(ti)))
2639 ret = check_for_audio_disc(cdi, cdi->ops);
2642 return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2644 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2647 struct cdrom_volctrl volume;
2649 cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2651 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2653 if (copy_from_user(&volume, argp, sizeof(volume)))
2655 return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2658 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2661 struct cdrom_volctrl volume;
2664 cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2666 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2669 ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2673 if (copy_to_user(argp, &volume, sizeof(volume)))
2678 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2683 cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2685 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2687 ret = check_for_audio_disc(cdi, cdi->ops);
2690 return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2694 * Just about every imaginable ioctl is supported in the Uniform layer
2696 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2698 int cdrom_ioctl(struct file * file, struct cdrom_device_info *cdi,
2699 struct inode *ip, unsigned int cmd, unsigned long arg)
2701 void __user *argp = (void __user *)arg;
2703 struct gendisk *disk = ip->i_bdev->bd_disk;
2706 * Try the generic SCSI command ioctl's first.
2708 ret = scsi_cmd_ioctl(file, disk->queue, disk, cmd, argp);
2713 case CDROMMULTISESSION:
2714 return cdrom_ioctl_multisession(cdi, argp);
2716 return cdrom_ioctl_eject(cdi);
2717 case CDROMCLOSETRAY:
2718 return cdrom_ioctl_closetray(cdi);
2720 return cdrom_ioctl_eject_sw(cdi, arg);
2721 case CDROM_MEDIA_CHANGED:
2722 return cdrom_ioctl_media_changed(cdi, arg);
2723 case CDROM_SET_OPTIONS:
2724 return cdrom_ioctl_set_options(cdi, arg);
2725 case CDROM_CLEAR_OPTIONS:
2726 return cdrom_ioctl_clear_options(cdi, arg);
2727 case CDROM_SELECT_SPEED:
2728 return cdrom_ioctl_select_speed(cdi, arg);
2729 case CDROM_SELECT_DISC:
2730 return cdrom_ioctl_select_disc(cdi, arg);
2732 return cdrom_ioctl_reset(cdi, ip->i_bdev);
2733 case CDROM_LOCKDOOR:
2734 return cdrom_ioctl_lock_door(cdi, arg);
2736 return cdrom_ioctl_debug(cdi, arg);
2737 case CDROM_GET_CAPABILITY:
2738 return cdrom_ioctl_get_capability(cdi);
2740 return cdrom_ioctl_get_mcn(cdi, argp);
2741 case CDROM_DRIVE_STATUS:
2742 return cdrom_ioctl_drive_status(cdi, arg);
2743 case CDROM_DISC_STATUS:
2744 return cdrom_ioctl_disc_status(cdi);
2745 case CDROM_CHANGER_NSLOTS:
2746 return cdrom_ioctl_changer_nslots(cdi);
2750 * Use the ioctls that are implemented through the generic_packet()
2751 * interface. this may look at bit funny, but if -ENOTTY is
2752 * returned that particular ioctl is not implemented and we
2753 * let it go through the device specific ones.
2755 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2756 ret = mmc_ioctl(cdi, cmd, arg);
2762 * Note: most of the cdinfo() calls are commented out here,
2763 * because they fill up the sys log when CD players poll
2768 return cdrom_ioctl_get_subchnl(cdi, argp);
2769 case CDROMREADTOCHDR:
2770 return cdrom_ioctl_read_tochdr(cdi, argp);
2771 case CDROMREADTOCENTRY:
2772 return cdrom_ioctl_read_tocentry(cdi, argp);
2774 return cdrom_ioctl_play_msf(cdi, argp);
2775 case CDROMPLAYTRKIND:
2776 return cdrom_ioctl_play_trkind(cdi, argp);
2778 return cdrom_ioctl_volctrl(cdi, argp);
2780 return cdrom_ioctl_volread(cdi, argp);
2785 return cdrom_ioctl_audioctl(cdi, cmd);
2792 * Required when we need to use READ_10 to issue other than 2048 block
2795 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2797 struct cdrom_device_ops *cdo = cdi->ops;
2798 struct packet_command cgc;
2799 struct modesel_head mh;
2801 memset(&mh, 0, sizeof(mh));
2802 mh.block_desc_length = 0x08;
2803 mh.block_length_med = (size >> 8) & 0xff;
2804 mh.block_length_lo = size & 0xff;
2806 memset(&cgc, 0, sizeof(cgc));
2808 cgc.cmd[1] = 1 << 4;
2810 cgc.buflen = sizeof(mh);
2811 cgc.buffer = (char *) &mh;
2812 cgc.data_direction = CGC_DATA_WRITE;
2813 mh.block_desc_length = 0x08;
2814 mh.block_length_med = (size >> 8) & 0xff;
2815 mh.block_length_lo = size & 0xff;
2817 return cdo->generic_packet(cdi, &cgc);
2820 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
2823 struct cdrom_device_ops *cdo = cdi->ops;
2824 struct packet_command cgc;
2825 struct request_sense sense;
2826 unsigned char buffer[32];
2829 memset(&cgc, 0, sizeof(cgc));
2831 /* build a unified command and queue it through
2832 cdo->generic_packet() */
2835 case CDROMREADMODE1:
2836 case CDROMREADMODE2: {
2837 struct cdrom_msf msf;
2838 int blocksize = 0, format = 0, lba;
2842 blocksize = CD_FRAMESIZE_RAW;
2844 case CDROMREADMODE1:
2845 blocksize = CD_FRAMESIZE;
2848 case CDROMREADMODE2:
2849 blocksize = CD_FRAMESIZE_RAW0;
2852 IOCTL_IN(arg, struct cdrom_msf, msf);
2853 lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
2854 /* FIXME: we need upper bound checking, too!! */
2857 cgc.buffer = kmalloc(blocksize, GFP_KERNEL);
2858 if (cgc.buffer == NULL)
2860 memset(&sense, 0, sizeof(sense));
2862 cgc.data_direction = CGC_DATA_READ;
2863 ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
2864 if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) {
2866 * SCSI-II devices are not required to support
2867 * READ_CD, so let's try switching block size
2869 /* FIXME: switch back again... */
2870 if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
2875 ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
2876 ret |= cdrom_switch_blocksize(cdi, blocksize);
2878 if (!ret && copy_to_user((char __user *)arg, cgc.buffer, blocksize))
2883 case CDROMREADAUDIO: {
2884 struct cdrom_read_audio ra;
2887 IOCTL_IN(arg, struct cdrom_read_audio, ra);
2889 if (ra.addr_format == CDROM_MSF)
2890 lba = msf_to_lba(ra.addr.msf.minute,
2893 else if (ra.addr_format == CDROM_LBA)
2898 /* FIXME: we need upper bound checking, too!! */
2899 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2902 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2904 case CDROMSUBCHNL: {
2905 struct cdrom_subchnl q;
2906 u_char requested, back;
2907 IOCTL_IN(arg, struct cdrom_subchnl, q);
2908 requested = q.cdsc_format;
2909 if (!((requested == CDROM_MSF) ||
2910 (requested == CDROM_LBA)))
2912 q.cdsc_format = CDROM_MSF;
2913 if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
2915 back = q.cdsc_format; /* local copy */
2916 sanitize_format(&q.cdsc_absaddr, &back, requested);
2917 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2918 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2919 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2922 case CDROMPLAYMSF: {
2923 struct cdrom_msf msf;
2924 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2925 IOCTL_IN(arg, struct cdrom_msf, msf);
2926 cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2927 cgc.cmd[3] = msf.cdmsf_min0;
2928 cgc.cmd[4] = msf.cdmsf_sec0;
2929 cgc.cmd[5] = msf.cdmsf_frame0;
2930 cgc.cmd[6] = msf.cdmsf_min1;
2931 cgc.cmd[7] = msf.cdmsf_sec1;
2932 cgc.cmd[8] = msf.cdmsf_frame1;
2933 cgc.data_direction = CGC_DATA_NONE;
2934 return cdo->generic_packet(cdi, &cgc);
2936 case CDROMPLAYBLK: {
2937 struct cdrom_blk blk;
2938 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2939 IOCTL_IN(arg, struct cdrom_blk, blk);
2940 cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
2941 cgc.cmd[2] = (blk.from >> 24) & 0xff;
2942 cgc.cmd[3] = (blk.from >> 16) & 0xff;
2943 cgc.cmd[4] = (blk.from >> 8) & 0xff;
2944 cgc.cmd[5] = blk.from & 0xff;
2945 cgc.cmd[7] = (blk.len >> 8) & 0xff;
2946 cgc.cmd[8] = blk.len & 0xff;
2947 cgc.data_direction = CGC_DATA_NONE;
2948 return cdo->generic_packet(cdi, &cgc);
2951 case CDROMVOLREAD: {
2952 struct cdrom_volctrl volctrl;
2953 char mask[sizeof(buffer)];
2954 unsigned short offset;
2956 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
2958 IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
2960 cgc.buffer = buffer;
2962 if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
2965 /* originally the code depended on buffer[1] to determine
2966 how much data is available for transfer. buffer[1] is
2967 unfortunately ambigious and the only reliable way seem
2968 to be to simply skip over the block descriptor... */
2969 offset = 8 + be16_to_cpu(*(__be16 *)(buffer+6));
2971 if (offset + 16 > sizeof(buffer))
2974 if (offset + 16 > cgc.buflen) {
2975 cgc.buflen = offset+16;
2976 ret = cdrom_mode_sense(cdi, &cgc,
2977 GPMODE_AUDIO_CTL_PAGE, 0);
2983 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
2984 buffer[offset+1] < 14)
2987 /* now we have the current volume settings. if it was only
2988 a CDROMVOLREAD, return these values */
2989 if (cmd == CDROMVOLREAD) {
2990 volctrl.channel0 = buffer[offset+9];
2991 volctrl.channel1 = buffer[offset+11];
2992 volctrl.channel2 = buffer[offset+13];
2993 volctrl.channel3 = buffer[offset+15];
2994 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
2998 /* get the volume mask */
3000 if ((ret = cdrom_mode_sense(cdi, &cgc,
3001 GPMODE_AUDIO_CTL_PAGE, 1)))
3004 buffer[offset+9] = volctrl.channel0 & mask[offset+9];
3005 buffer[offset+11] = volctrl.channel1 & mask[offset+11];
3006 buffer[offset+13] = volctrl.channel2 & mask[offset+13];
3007 buffer[offset+15] = volctrl.channel3 & mask[offset+15];
3010 cgc.buffer = buffer + offset - 8;
3011 memset(cgc.buffer, 0, 8);
3012 return cdrom_mode_select(cdi, &cgc);
3017 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3018 cgc.cmd[0] = GPCMD_START_STOP_UNIT;
3020 cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3021 cgc.data_direction = CGC_DATA_NONE;
3022 return cdo->generic_packet(cdi, &cgc);
3027 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3028 cgc.cmd[0] = GPCMD_PAUSE_RESUME;
3029 cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3030 cgc.data_direction = CGC_DATA_NONE;
3031 return cdo->generic_packet(cdi, &cgc);
3034 case DVD_READ_STRUCT: {
3036 int size = sizeof(dvd_struct);
3037 if (!CDROM_CAN(CDC_DVD))
3039 if ((s = kmalloc(size, GFP_KERNEL)) == NULL)
3041 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3042 if (copy_from_user(s, (dvd_struct __user *)arg, size)) {
3046 if ((ret = dvd_read_struct(cdi, s))) {
3050 if (copy_to_user((dvd_struct __user *)arg, s, size))
3058 if (!CDROM_CAN(CDC_DVD))
3060 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
3061 IOCTL_IN(arg, dvd_authinfo, ai);
3062 if ((ret = dvd_do_auth (cdi, &ai)))
3064 IOCTL_OUT(arg, dvd_authinfo, ai);
3068 case CDROM_NEXT_WRITABLE: {
3070 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3071 if ((ret = cdrom_get_next_writable(cdi, &next)))
3073 IOCTL_OUT(arg, long, next);
3076 case CDROM_LAST_WRITTEN: {
3078 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3079 if ((ret = cdrom_get_last_written(cdi, &last)))
3081 IOCTL_OUT(arg, long, last);
3089 static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
3090 track_information *ti)
3092 struct cdrom_device_ops *cdo = cdi->ops;
3093 struct packet_command cgc;
3096 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3097 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3098 cgc.cmd[1] = type & 3;
3099 cgc.cmd[4] = (track & 0xff00) >> 8;
3100 cgc.cmd[5] = track & 0xff;
3104 if ((ret = cdo->generic_packet(cdi, &cgc)))
3107 buflen = be16_to_cpu(ti->track_information_length) +
3108 sizeof(ti->track_information_length);
3110 if (buflen > sizeof(track_information))
3111 buflen = sizeof(track_information);
3113 cgc.cmd[8] = cgc.buflen = buflen;
3114 if ((ret = cdo->generic_packet(cdi, &cgc)))
3117 /* return actual fill size */
3121 /* requires CD R/RW */
3122 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3124 struct cdrom_device_ops *cdo = cdi->ops;
3125 struct packet_command cgc;
3128 /* set up command and get the disc info */
3129 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3130 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3131 cgc.cmd[8] = cgc.buflen = 2;
3134 if ((ret = cdo->generic_packet(cdi, &cgc)))
3137 /* not all drives have the same disc_info length, so requeue
3138 * packet with the length the drive tells us it can supply
3140 buflen = be16_to_cpu(di->disc_information_length) +
3141 sizeof(di->disc_information_length);
3143 if (buflen > sizeof(disc_information))
3144 buflen = sizeof(disc_information);
3146 cgc.cmd[8] = cgc.buflen = buflen;
3147 if ((ret = cdo->generic_packet(cdi, &cgc)))
3150 /* return actual fill size */
3154 /* return the last written block on the CD-R media. this is for the udf
3156 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
3158 struct cdrom_tocentry toc;
3159 disc_information di;
3160 track_information ti;
3162 int ret = -1, ti_size;
3164 if (!CDROM_CAN(CDC_GENERIC_PACKET))
3167 ret = cdrom_get_disc_info(cdi, &di);
3168 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
3169 + sizeof(di.last_track_lsb)))
3172 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3173 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3174 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3175 if (ti_size < (int)offsetof(typeof(ti), track_start))
3178 /* if this track is blank, try the previous. */
3183 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3186 if (ti_size < (int)(offsetof(typeof(ti), track_size)
3187 + sizeof(ti.track_size)))
3190 /* if last recorded field is valid, return it. */
3191 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3192 + sizeof(ti.last_rec_address))) {
3193 *last_written = be32_to_cpu(ti.last_rec_address);
3195 /* make it up instead */
3196 *last_written = be32_to_cpu(ti.track_start) +
3197 be32_to_cpu(ti.track_size);
3199 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3203 /* this is where we end up if the drive either can't do a
3204 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3205 it doesn't give enough information or fails. then we return
3206 the toc contents. */
3208 toc.cdte_format = CDROM_MSF;
3209 toc.cdte_track = CDROM_LEADOUT;
3210 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
3212 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
3213 *last_written = toc.cdte_addr.lba;
3217 /* return the next writable block. also for udf file system. */
3218 static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3220 disc_information di;
3221 track_information ti;
3225 if (!CDROM_CAN(CDC_GENERIC_PACKET))
3226 goto use_last_written;
3228 ret = cdrom_get_disc_info(cdi, &di);
3229 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3230 + sizeof(di.last_track_lsb))
3231 goto use_last_written;
3233 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3234 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3235 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3236 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3237 goto use_last_written;
3239 /* if this track is blank, try the previous. */
3241 if (last_track == 1)
3242 goto use_last_written;
3244 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3246 goto use_last_written;
3249 /* if next recordable address field is valid, use it. */
3250 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
3251 + sizeof(ti.next_writable)) {
3252 *next_writable = be32_to_cpu(ti.next_writable);
3257 if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3261 *next_writable += 7;
3266 EXPORT_SYMBOL(cdrom_get_last_written);
3267 EXPORT_SYMBOL(register_cdrom);
3268 EXPORT_SYMBOL(unregister_cdrom);
3269 EXPORT_SYMBOL(cdrom_open);
3270 EXPORT_SYMBOL(cdrom_release);
3271 EXPORT_SYMBOL(cdrom_ioctl);
3272 EXPORT_SYMBOL(cdrom_media_changed);
3273 EXPORT_SYMBOL(cdrom_number_of_slots);
3274 EXPORT_SYMBOL(cdrom_mode_select);
3275 EXPORT_SYMBOL(cdrom_mode_sense);
3276 EXPORT_SYMBOL(init_cdrom_command);
3277 EXPORT_SYMBOL(cdrom_get_media_event);
3279 #ifdef CONFIG_SYSCTL
3281 #define CDROM_STR_SIZE 1000
3283 static struct cdrom_sysctl_settings {
3284 char info[CDROM_STR_SIZE]; /* general info */
3285 int autoclose; /* close tray upon mount, etc */
3286 int autoeject; /* eject on umount */
3287 int debug; /* turn on debugging messages */
3288 int lock; /* lock the door on device open */
3289 int check; /* check media type */
3290 } cdrom_sysctl_settings;
3292 enum cdrom_print_option {
3299 static int cdrom_print_info(const char *header, int val, char *info,
3300 int *pos, enum cdrom_print_option option)
3302 const int max_size = sizeof(cdrom_sysctl_settings.info);
3303 struct cdrom_device_info *cdi;
3306 ret = scnprintf(info + *pos, max_size - *pos, header);
3312 for (cdi = topCdromPtr; cdi; cdi = cdi->next) {
3315 ret = scnprintf(info + *pos, max_size - *pos,
3319 ret = scnprintf(info + *pos, max_size - *pos,
3320 "\t%d", cdi->speed);
3323 ret = scnprintf(info + *pos, max_size - *pos,
3324 "\t%d", cdi->capacity);
3326 case CTL_CAPABILITY:
3327 ret = scnprintf(info + *pos, max_size - *pos,
3328 "\t%d", CDROM_CAN(val) != 0);
3331 printk(KERN_INFO "cdrom: invalid option%d\n", option);
3342 static int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
3343 void __user *buffer, size_t *lenp, loff_t *ppos)
3346 char *info = cdrom_sysctl_settings.info;
3347 const int max_size = sizeof(cdrom_sysctl_settings.info);
3349 if (!*lenp || (*ppos && !write)) {
3354 mutex_lock(&cdrom_mutex);
3356 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3358 if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3360 if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3362 if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3364 if (cdrom_print_info("\nCan close tray:\t",
3365 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3367 if (cdrom_print_info("\nCan open tray:\t",
3368 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3370 if (cdrom_print_info("\nCan lock tray:\t",
3371 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3373 if (cdrom_print_info("\nCan change speed:",
3374 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3376 if (cdrom_print_info("\nCan select disk:",
3377 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3379 if (cdrom_print_info("\nCan read multisession:",
3380 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3382 if (cdrom_print_info("\nCan read MCN:\t",
3383 CDC_MCN, info, &pos, CTL_CAPABILITY))
3385 if (cdrom_print_info("\nReports media changed:",
3386 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3388 if (cdrom_print_info("\nCan play audio:\t",
3389 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3391 if (cdrom_print_info("\nCan write CD-R:\t",
3392 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3394 if (cdrom_print_info("\nCan write CD-RW:",
3395 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3397 if (cdrom_print_info("\nCan read DVD:\t",
3398 CDC_DVD, info, &pos, CTL_CAPABILITY))
3400 if (cdrom_print_info("\nCan write DVD-R:",
3401 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3403 if (cdrom_print_info("\nCan write DVD-RAM:",
3404 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3406 if (cdrom_print_info("\nCan read MRW:\t",
3407 CDC_MRW, info, &pos, CTL_CAPABILITY))
3409 if (cdrom_print_info("\nCan write MRW:\t",
3410 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3412 if (cdrom_print_info("\nCan write RAM:\t",
3413 CDC_RAM, info, &pos, CTL_CAPABILITY))
3415 if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3418 mutex_unlock(&cdrom_mutex);
3419 return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
3421 printk(KERN_INFO "cdrom: info buffer too small\n");
3425 /* Unfortunately, per device settings are not implemented through
3426 procfs/sysctl yet. When they are, this will naturally disappear. For now
3427 just update all drives. Later this will become the template on which
3428 new registered drives will be based. */
3429 static void cdrom_update_settings(void)
3431 struct cdrom_device_info *cdi;
3433 for (cdi = topCdromPtr; cdi != NULL; cdi = cdi->next) {
3434 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3435 cdi->options |= CDO_AUTO_CLOSE;
3436 else if (!autoclose)
3437 cdi->options &= ~CDO_AUTO_CLOSE;
3438 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3439 cdi->options |= CDO_AUTO_EJECT;
3440 else if (!autoeject)
3441 cdi->options &= ~CDO_AUTO_EJECT;
3442 if (lockdoor && CDROM_CAN(CDC_LOCK))
3443 cdi->options |= CDO_LOCK;
3445 cdi->options &= ~CDO_LOCK;
3446 if (check_media_type)
3447 cdi->options |= CDO_CHECK_TYPE;
3449 cdi->options &= ~CDO_CHECK_TYPE;
3453 static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
3454 void __user *buffer, size_t *lenp, loff_t *ppos)
3458 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
3462 /* we only care for 1 or 0. */
3463 autoclose = !!cdrom_sysctl_settings.autoclose;
3464 autoeject = !!cdrom_sysctl_settings.autoeject;
3465 debug = !!cdrom_sysctl_settings.debug;
3466 lockdoor = !!cdrom_sysctl_settings.lock;
3467 check_media_type = !!cdrom_sysctl_settings.check;
3469 /* update the option flags according to the changes. we
3470 don't have per device options through sysctl yet,
3471 but we will have and then this will disappear. */
3472 cdrom_update_settings();
3478 /* Place files in /proc/sys/dev/cdrom */
3479 static ctl_table cdrom_table[] = {
3482 .data = &cdrom_sysctl_settings.info,
3483 .maxlen = CDROM_STR_SIZE,
3485 .proc_handler = &cdrom_sysctl_info,
3488 .procname = "autoclose",
3489 .data = &cdrom_sysctl_settings.autoclose,
3490 .maxlen = sizeof(int),
3492 .proc_handler = &cdrom_sysctl_handler,
3495 .procname = "autoeject",
3496 .data = &cdrom_sysctl_settings.autoeject,
3497 .maxlen = sizeof(int),
3499 .proc_handler = &cdrom_sysctl_handler,
3502 .procname = "debug",
3503 .data = &cdrom_sysctl_settings.debug,
3504 .maxlen = sizeof(int),
3506 .proc_handler = &cdrom_sysctl_handler,
3510 .data = &cdrom_sysctl_settings.lock,
3511 .maxlen = sizeof(int),
3513 .proc_handler = &cdrom_sysctl_handler,
3516 .procname = "check_media",
3517 .data = &cdrom_sysctl_settings.check,
3518 .maxlen = sizeof(int),
3520 .proc_handler = &cdrom_sysctl_handler
3525 static ctl_table cdrom_cdrom_table[] = {
3527 .ctl_name = DEV_CDROM,
3528 .procname = "cdrom",
3531 .child = cdrom_table,
3536 /* Make sure that /proc/sys/dev is there */
3537 static ctl_table cdrom_root_table[] = {
3539 .ctl_name = CTL_DEV,
3543 .child = cdrom_cdrom_table,
3547 static struct ctl_table_header *cdrom_sysctl_header;
3549 static void cdrom_sysctl_register(void)
3551 static int initialized;
3553 if (initialized == 1)
3556 cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3558 /* set the defaults */
3559 cdrom_sysctl_settings.autoclose = autoclose;
3560 cdrom_sysctl_settings.autoeject = autoeject;
3561 cdrom_sysctl_settings.debug = debug;
3562 cdrom_sysctl_settings.lock = lockdoor;
3563 cdrom_sysctl_settings.check = check_media_type;
3568 static void cdrom_sysctl_unregister(void)
3570 if (cdrom_sysctl_header)
3571 unregister_sysctl_table(cdrom_sysctl_header);
3574 #endif /* CONFIG_SYSCTL */
3576 static int __init cdrom_init(void)
3578 #ifdef CONFIG_SYSCTL
3579 cdrom_sysctl_register();
3584 static void __exit cdrom_exit(void)
3586 printk(KERN_INFO "Uniform CD-ROM driver unloaded\n");
3587 #ifdef CONFIG_SYSCTL
3588 cdrom_sysctl_unregister();
3592 module_init(cdrom_init);
3593 module_exit(cdrom_exit);
3594 MODULE_LICENSE("GPL");
projects / linux-2.6 / blob