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 cdi->ops->release(cdi);
1042 int open_for_data(struct cdrom_device_info * cdi)
1045 struct cdrom_device_ops *cdo = cdi->ops;
1047 cdinfo(CD_OPEN, "entering open_for_data\n");
1048 /* Check if the driver can report drive status. If it can, we
1049 can do clever things. If it can't, well, we at least tried! */
1050 if (cdo->drive_status != NULL) {
1051 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1052 cdinfo(CD_OPEN, "drive_status=%d\n", ret);
1053 if (ret == CDS_TRAY_OPEN) {
1054 cdinfo(CD_OPEN, "the tray is open...\n");
1055 /* can/may i close it? */
1056 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1057 cdi->options & CDO_AUTO_CLOSE) {
1058 cdinfo(CD_OPEN, "trying to close the tray.\n");
1059 ret=cdo->tray_move(cdi,0);
1061 cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1062 /* Ignore the error from the low
1063 level driver. We don't care why it
1064 couldn't close the tray. We only care
1065 that there is no disc in the drive,
1066 since that is the _REAL_ problem here.*/
1068 goto clean_up_and_return;
1071 cdinfo(CD_OPEN, "bummer. this drive can't close the tray.\n");
1073 goto clean_up_and_return;
1075 /* Ok, the door should be closed now.. Check again */
1076 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1077 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1078 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
1079 cdinfo(CD_OPEN, "tray might not contain a medium.\n");
1081 goto clean_up_and_return;
1083 cdinfo(CD_OPEN, "the tray is now closed.\n");
1085 /* the door should be closed now, check for the disc */
1086 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1087 if (ret!=CDS_DISC_OK) {
1089 goto clean_up_and_return;
1092 cdrom_count_tracks(cdi, &tracks);
1093 if (tracks.error == CDS_NO_DISC) {
1094 cdinfo(CD_OPEN, "bummer. no disc.\n");
1096 goto clean_up_and_return;
1098 /* CD-Players which don't use O_NONBLOCK, workman
1099 * for example, need bit CDO_CHECK_TYPE cleared! */
1100 if (tracks.data==0) {
1101 if (cdi->options & CDO_CHECK_TYPE) {
1102 /* give people a warning shot, now that CDO_CHECK_TYPE
1103 is the default case! */
1104 cdinfo(CD_OPEN, "bummer. wrong media type.\n");
1105 cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1106 (unsigned int)current->pid);
1108 goto clean_up_and_return;
1111 cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.\n");
1115 cdinfo(CD_OPEN, "all seems well, opening the device.\n");
1117 /* all seems well, we can open the device */
1118 ret = cdo->open(cdi, 0); /* open for data */
1119 cdinfo(CD_OPEN, "opening the device gave me %d.\n", ret);
1120 /* After all this careful checking, we shouldn't have problems
1121 opening the device, but we don't want the device locked if
1122 this somehow fails... */
1124 cdinfo(CD_OPEN, "open device failed.\n");
1125 goto clean_up_and_return;
1127 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1128 cdo->lock_door(cdi, 1);
1129 cdinfo(CD_OPEN, "door locked.\n");
1131 cdinfo(CD_OPEN, "device opened successfully.\n");
1134 /* Something failed. Try to unlock the drive, because some drivers
1135 (notably ide-cd) lock the drive after every command. This produced
1136 a nasty bug where after mount failed, the drive would remain locked!
1137 This ensures that the drive gets unlocked after a mount fails. This
1138 is a goto to avoid bloating the driver with redundant code. */
1139 clean_up_and_return:
1140 cdinfo(CD_OPEN, "open failed.\n");
1141 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1142 cdo->lock_door(cdi, 0);
1143 cdinfo(CD_OPEN, "door unlocked.\n");
1148 /* This code is similar to that in open_for_data. The routine is called
1149 whenever an audio play operation is requested.
1151 int check_for_audio_disc(struct cdrom_device_info * cdi,
1152 struct cdrom_device_ops * cdo)
1156 cdinfo(CD_OPEN, "entering check_for_audio_disc\n");
1157 if (!(cdi->options & CDO_CHECK_TYPE))
1159 if (cdo->drive_status != NULL) {
1160 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1161 cdinfo(CD_OPEN, "drive_status=%d\n", ret);
1162 if (ret == CDS_TRAY_OPEN) {
1163 cdinfo(CD_OPEN, "the tray is open...\n");
1164 /* can/may i close it? */
1165 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1166 cdi->options & CDO_AUTO_CLOSE) {
1167 cdinfo(CD_OPEN, "trying to close the tray.\n");
1168 ret=cdo->tray_move(cdi,0);
1170 cdinfo(CD_OPEN, "bummer. tried to close tray but failed.\n");
1171 /* Ignore the error from the low
1172 level driver. We don't care why it
1173 couldn't close the tray. We only care
1174 that there is no disc in the drive,
1175 since that is the _REAL_ problem here.*/
1179 cdinfo(CD_OPEN, "bummer. this driver can't close the tray.\n");
1182 /* Ok, the door should be closed now.. Check again */
1183 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1184 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1185 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
1188 if (ret!=CDS_DISC_OK) {
1189 cdinfo(CD_OPEN, "bummer. disc isn't ready.\n");
1192 cdinfo(CD_OPEN, "the tray is now closed.\n");
1195 cdrom_count_tracks(cdi, &tracks);
1197 return(tracks.error);
1199 if (tracks.audio==0)
1200 return -EMEDIUMTYPE;
1205 /* Admittedly, the logic below could be performed in a nicer way. */
1206 int cdrom_release(struct cdrom_device_info *cdi, struct file *fp)
1208 struct cdrom_device_ops *cdo = cdi->ops;
1209 int opened_for_data;
1211 cdinfo(CD_CLOSE, "entering cdrom_release\n");
1213 if (cdi->use_count > 0)
1215 if (cdi->use_count == 0)
1216 cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
1217 if (cdi->use_count == 0)
1218 cdrom_dvd_rw_close_write(cdi);
1219 if (cdi->use_count == 0 &&
1220 (cdo->capability & CDC_LOCK) && !keeplocked) {
1221 cdinfo(CD_CLOSE, "Unlocking door!\n");
1222 cdo->lock_door(cdi, 0);
1224 opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1225 !(fp && fp->f_flags & O_NONBLOCK);
1228 * flush cache on last write release
1230 if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1231 cdrom_close_write(cdi);
1234 if (cdi->use_count == 0) { /* last process that closes dev*/
1235 if (opened_for_data &&
1236 cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1237 cdo->tray_move(cdi, 1);
1242 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1243 struct cdrom_changer_info *buf)
1245 struct packet_command cgc;
1246 struct cdrom_device_ops *cdo = cdi->ops;
1250 * Sanyo changer isn't spec compliant (doesn't use regular change
1251 * LOAD_UNLOAD command, and it doesn't implement the mech status
1254 if (cdi->sanyo_slot) {
1255 buf->hdr.nslots = 3;
1256 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1257 for (length = 0; length < 3; length++) {
1258 buf->slots[length].disc_present = 1;
1259 buf->slots[length].change = 0;
1264 length = sizeof(struct cdrom_mechstat_header) +
1265 cdi->capacity * sizeof(struct cdrom_slot);
1267 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1268 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1269 cgc.cmd[8] = (length >> 8) & 0xff;
1270 cgc.cmd[9] = length & 0xff;
1271 return cdo->generic_packet(cdi, &cgc);
1274 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1276 struct cdrom_changer_info *info;
1279 cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n");
1280 if (cdi->sanyo_slot)
1283 info = kmalloc(sizeof(*info), GFP_KERNEL);
1287 if ((ret = cdrom_read_mech_status(cdi, info)))
1290 if (info->slots[slot].disc_present)
1300 /* Return the number of slots for an ATAPI/SCSI cdrom,
1301 * return 1 if not a changer.
1303 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1307 struct cdrom_changer_info *info;
1309 cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1310 /* cdrom_read_mech_status requires a valid value for capacity: */
1313 info = kmalloc(sizeof(*info), GFP_KERNEL);
1317 if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1318 nslots = info->hdr.nslots;
1325 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1326 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1328 struct packet_command cgc;
1330 cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n");
1331 if (cdi->sanyo_slot && slot < 0)
1334 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1335 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1336 cgc.cmd[4] = 2 + (slot >= 0);
1338 cgc.timeout = 60 * HZ;
1340 /* The Sanyo 3 CD changer uses byte 7 of the
1341 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1342 using the GPCMD_LOAD_UNLOAD opcode. */
1343 if (cdi->sanyo_slot && -1 < slot) {
1344 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1346 cgc.cmd[4] = cgc.cmd[8] = 0;
1347 cdi->sanyo_slot = slot ? slot : 3;
1350 return cdi->ops->generic_packet(cdi, &cgc);
1353 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1355 struct cdrom_changer_info *info;
1359 cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n");
1360 if (!CDROM_CAN(CDC_SELECT_DISC))
1361 return -EDRIVE_CANT_DO_THIS;
1363 (void) cdi->ops->media_changed(cdi, slot);
1365 if (slot == CDSL_NONE) {
1366 /* set media changed bits, on both queues */
1367 cdi->mc_flags = 0x3;
1368 return cdrom_load_unload(cdi, -1);
1371 info = kmalloc(sizeof(*info), GFP_KERNEL);
1375 if ((ret = cdrom_read_mech_status(cdi, info))) {
1380 curslot = info->hdr.curslot;
1383 if (cdi->use_count > 1 || keeplocked) {
1384 if (slot == CDSL_CURRENT) {
1391 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1392 which is useful if it had been previously unloaded.
1393 Whether it can or not, it returns the current slot.
1394 Similarly, if slot happens to be the current one, we still
1396 if (slot == CDSL_CURRENT)
1399 /* set media changed bits on both queues */
1400 cdi->mc_flags = 0x3;
1401 if ((ret = cdrom_load_unload(cdi, slot)))
1407 /* We want to make media_changed accessible to the user through an
1408 * ioctl. The main problem now is that we must double-buffer the
1409 * low-level implementation, to assure that the VFS and the user both
1410 * see a medium change once.
1414 int media_changed(struct cdrom_device_info *cdi, int queue)
1416 unsigned int mask = (1 << (queue & 1));
1417 int ret = !!(cdi->mc_flags & mask);
1419 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1421 /* changed since last call? */
1422 if (cdi->ops->media_changed(cdi, CDSL_CURRENT)) {
1423 cdi->mc_flags = 0x3; /* set bit on both queues */
1425 cdi->media_written = 0;
1427 cdi->mc_flags &= ~mask; /* clear bit */
1431 int cdrom_media_changed(struct cdrom_device_info *cdi)
1433 /* This talks to the VFS, which doesn't like errors - just 1 or 0.
1434 * Returning "0" is always safe (media hasn't been changed). Do that
1435 * if the low-level cdrom driver dosn't support media changed. */
1436 if (cdi == NULL || cdi->ops->media_changed == NULL)
1438 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1440 return media_changed(cdi, 0);
1443 /* badly broken, I know. Is due for a fixup anytime. */
1444 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1446 struct cdrom_tochdr header;
1447 struct cdrom_tocentry entry;
1454 cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1455 if (!CDROM_CAN(CDC_PLAY_AUDIO)) {
1456 tracks->error=CDS_NO_INFO;
1459 /* Grab the TOC header so we can see how many tracks there are */
1460 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1461 if (ret == -ENOMEDIUM)
1462 tracks->error = CDS_NO_DISC;
1464 tracks->error = CDS_NO_INFO;
1467 /* check what type of tracks are on this disc */
1468 entry.cdte_format = CDROM_MSF;
1469 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1470 entry.cdte_track = i;
1471 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1472 tracks->error=CDS_NO_INFO;
1475 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1476 if (entry.cdte_format == 0x10)
1478 else if (entry.cdte_format == 0x20)
1484 cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1485 i, entry.cdte_format, entry.cdte_ctrl);
1487 cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1488 header.cdth_trk1, tracks->audio, tracks->data,
1489 tracks->cdi, tracks->xa);
1492 /* Requests to the low-level drivers will /always/ be done in the
1493 following format convention:
1495 CDROM_LBA: all data-related requests.
1496 CDROM_MSF: all audio-related requests.
1498 However, a low-level implementation is allowed to refuse this
1499 request, and return information in its own favorite format.
1501 It doesn't make sense /at all/ to ask for a play_audio in LBA
1502 format, or ask for multi-session info in MSF format. However, for
1503 backward compatibility these format requests will be satisfied, but
1504 the requests to the low-level drivers will be sanitized in the more
1505 meaningful format indicated above.
1509 void sanitize_format(union cdrom_addr *addr,
1510 u_char * curr, u_char requested)
1512 if (*curr == requested)
1513 return; /* nothing to be done! */
1514 if (requested == CDROM_LBA) {
1515 addr->lba = (int) addr->msf.frame +
1516 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1517 } else { /* CDROM_MSF */
1518 int lba = addr->lba;
1519 addr->msf.frame = lba % 75;
1522 addr->msf.second = lba % 60;
1523 addr->msf.minute = lba / 60;
1528 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1531 memset(cgc, 0, sizeof(struct packet_command));
1533 memset(buf, 0, len);
1534 cgc->buffer = (char *) buf;
1536 cgc->data_direction = type;
1537 cgc->timeout = CDROM_DEF_TIMEOUT;
1542 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1543 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1545 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1547 cgc->cmd[0] = GPCMD_REPORT_KEY;
1548 cgc->cmd[10] = type | (agid << 6);
1550 case 0: case 8: case 5: {
1563 cgc->cmd[9] = cgc->buflen;
1564 cgc->data_direction = CGC_DATA_READ;
1567 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1569 cgc->cmd[0] = GPCMD_SEND_KEY;
1570 cgc->cmd[10] = type | (agid << 6);
1585 cgc->cmd[9] = cgc->buflen;
1586 cgc->data_direction = CGC_DATA_WRITE;
1589 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1593 struct packet_command cgc;
1594 struct cdrom_device_ops *cdo = cdi->ops;
1595 rpc_state_t rpc_state;
1597 memset(buf, 0, sizeof(buf));
1598 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1602 case DVD_LU_SEND_AGID:
1603 cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1605 setup_report_key(&cgc, ai->lsa.agid, 0);
1607 if ((ret = cdo->generic_packet(cdi, &cgc)))
1610 ai->lsa.agid = buf[7] >> 6;
1611 /* Returning data, let host change state */
1614 case DVD_LU_SEND_KEY1:
1615 cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1616 setup_report_key(&cgc, ai->lsk.agid, 2);
1618 if ((ret = cdo->generic_packet(cdi, &cgc)))
1621 copy_key(ai->lsk.key, &buf[4]);
1622 /* Returning data, let host change state */
1625 case DVD_LU_SEND_CHALLENGE:
1626 cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1627 setup_report_key(&cgc, ai->lsc.agid, 1);
1629 if ((ret = cdo->generic_packet(cdi, &cgc)))
1632 copy_chal(ai->lsc.chal, &buf[4]);
1633 /* Returning data, let host change state */
1637 case DVD_LU_SEND_TITLE_KEY:
1638 cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1640 setup_report_key(&cgc, ai->lstk.agid, 4);
1641 cgc.cmd[5] = ai->lstk.lba;
1642 cgc.cmd[4] = ai->lstk.lba >> 8;
1643 cgc.cmd[3] = ai->lstk.lba >> 16;
1644 cgc.cmd[2] = ai->lstk.lba >> 24;
1646 if ((ret = cdo->generic_packet(cdi, &cgc)))
1649 ai->lstk.cpm = (buf[4] >> 7) & 1;
1650 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1651 ai->lstk.cgms = (buf[4] >> 4) & 3;
1652 copy_key(ai->lstk.title_key, &buf[5]);
1653 /* Returning data, let host change state */
1656 case DVD_LU_SEND_ASF:
1657 cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1658 setup_report_key(&cgc, ai->lsasf.agid, 5);
1660 if ((ret = cdo->generic_packet(cdi, &cgc)))
1663 ai->lsasf.asf = buf[7] & 1;
1666 /* LU data receive (LU changes state) */
1667 case DVD_HOST_SEND_CHALLENGE:
1668 cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1669 setup_send_key(&cgc, ai->hsc.agid, 1);
1671 copy_chal(&buf[4], ai->hsc.chal);
1673 if ((ret = cdo->generic_packet(cdi, &cgc)))
1676 ai->type = DVD_LU_SEND_KEY1;
1679 case DVD_HOST_SEND_KEY2:
1680 cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1681 setup_send_key(&cgc, ai->hsk.agid, 3);
1683 copy_key(&buf[4], ai->hsk.key);
1685 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1686 ai->type = DVD_AUTH_FAILURE;
1689 ai->type = DVD_AUTH_ESTABLISHED;
1693 case DVD_INVALIDATE_AGID:
1695 cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1696 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1697 if ((ret = cdo->generic_packet(cdi, &cgc)))
1701 /* Get region settings */
1702 case DVD_LU_SEND_RPC_STATE:
1703 cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1704 setup_report_key(&cgc, 0, 8);
1705 memset(&rpc_state, 0, sizeof(rpc_state_t));
1706 cgc.buffer = (char *) &rpc_state;
1708 if ((ret = cdo->generic_packet(cdi, &cgc)))
1711 ai->lrpcs.type = rpc_state.type_code;
1712 ai->lrpcs.vra = rpc_state.vra;
1713 ai->lrpcs.ucca = rpc_state.ucca;
1714 ai->lrpcs.region_mask = rpc_state.region_mask;
1715 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1718 /* Set region settings */
1719 case DVD_HOST_SEND_RPC_STATE:
1720 cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1721 setup_send_key(&cgc, 0, 6);
1723 buf[4] = ai->hrpcs.pdrc;
1725 if ((ret = cdo->generic_packet(cdi, &cgc)))
1730 cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1737 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
1739 unsigned char buf[21], *base;
1740 struct dvd_layer *layer;
1741 struct packet_command cgc;
1742 struct cdrom_device_ops *cdo = cdi->ops;
1743 int ret, layer_num = s->physical.layer_num;
1745 if (layer_num >= DVD_LAYERS)
1748 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1749 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1750 cgc.cmd[6] = layer_num;
1751 cgc.cmd[7] = s->type;
1752 cgc.cmd[9] = cgc.buflen & 0xff;
1755 * refrain from reporting errors on non-existing layers (mainly)
1759 if ((ret = cdo->generic_packet(cdi, &cgc)))
1763 layer = &s->physical.layer[layer_num];
1766 * place the data... really ugly, but at least we won't have to
1767 * worry about endianess in userspace.
1769 memset(layer, 0, sizeof(*layer));
1770 layer->book_version = base[0] & 0xf;
1771 layer->book_type = base[0] >> 4;
1772 layer->min_rate = base[1] & 0xf;
1773 layer->disc_size = base[1] >> 4;
1774 layer->layer_type = base[2] & 0xf;
1775 layer->track_path = (base[2] >> 4) & 1;
1776 layer->nlayers = (base[2] >> 5) & 3;
1777 layer->track_density = base[3] & 0xf;
1778 layer->linear_density = base[3] >> 4;
1779 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1780 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1781 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1782 layer->bca = base[16] >> 7;
1787 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
1791 struct packet_command cgc;
1792 struct cdrom_device_ops *cdo = cdi->ops;
1794 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1795 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1796 cgc.cmd[6] = s->copyright.layer_num;
1797 cgc.cmd[7] = s->type;
1798 cgc.cmd[8] = cgc.buflen >> 8;
1799 cgc.cmd[9] = cgc.buflen & 0xff;
1801 if ((ret = cdo->generic_packet(cdi, &cgc)))
1804 s->copyright.cpst = buf[4];
1805 s->copyright.rmi = buf[5];
1810 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s)
1814 struct packet_command cgc;
1815 struct cdrom_device_ops *cdo = cdi->ops;
1817 size = sizeof(s->disckey.value) + 4;
1819 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1822 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1823 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1824 cgc.cmd[7] = s->type;
1825 cgc.cmd[8] = size >> 8;
1826 cgc.cmd[9] = size & 0xff;
1827 cgc.cmd[10] = s->disckey.agid << 6;
1829 if (!(ret = cdo->generic_packet(cdi, &cgc)))
1830 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1836 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s)
1839 u_char buf[4 + 188];
1840 struct packet_command cgc;
1841 struct cdrom_device_ops *cdo = cdi->ops;
1843 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1844 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1845 cgc.cmd[7] = s->type;
1846 cgc.cmd[9] = cgc.buflen & 0xff;
1848 if ((ret = cdo->generic_packet(cdi, &cgc)))
1851 s->bca.len = buf[0] << 8 | buf[1];
1852 if (s->bca.len < 12 || s->bca.len > 188) {
1853 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1856 memcpy(s->bca.value, &buf[4], s->bca.len);
1861 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s)
1865 struct packet_command cgc;
1866 struct cdrom_device_ops *cdo = cdi->ops;
1868 size = sizeof(s->manufact.value) + 4;
1870 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1873 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1874 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1875 cgc.cmd[7] = s->type;
1876 cgc.cmd[8] = size >> 8;
1877 cgc.cmd[9] = size & 0xff;
1879 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1884 s->manufact.len = buf[0] << 8 | buf[1];
1885 if (s->manufact.len < 0 || s->manufact.len > 2048) {
1886 cdinfo(CD_WARNING, "Received invalid manufacture info length"
1887 " (%d)\n", s->manufact.len);
1890 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1897 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s)
1900 case DVD_STRUCT_PHYSICAL:
1901 return dvd_read_physical(cdi, s);
1903 case DVD_STRUCT_COPYRIGHT:
1904 return dvd_read_copyright(cdi, s);
1906 case DVD_STRUCT_DISCKEY:
1907 return dvd_read_disckey(cdi, s);
1909 case DVD_STRUCT_BCA:
1910 return dvd_read_bca(cdi, s);
1912 case DVD_STRUCT_MANUFACT:
1913 return dvd_read_manufact(cdi, s);
1916 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1922 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1923 struct packet_command *cgc,
1924 int page_code, int page_control)
1926 struct cdrom_device_ops *cdo = cdi->ops;
1928 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1930 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1931 cgc->cmd[2] = page_code | (page_control << 6);
1932 cgc->cmd[7] = cgc->buflen >> 8;
1933 cgc->cmd[8] = cgc->buflen & 0xff;
1934 cgc->data_direction = CGC_DATA_READ;
1935 return cdo->generic_packet(cdi, cgc);
1938 int cdrom_mode_select(struct cdrom_device_info *cdi,
1939 struct packet_command *cgc)
1941 struct cdrom_device_ops *cdo = cdi->ops;
1943 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1944 memset(cgc->buffer, 0, 2);
1945 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1946 cgc->cmd[1] = 0x10; /* PF */
1947 cgc->cmd[7] = cgc->buflen >> 8;
1948 cgc->cmd[8] = cgc->buflen & 0xff;
1949 cgc->data_direction = CGC_DATA_WRITE;
1950 return cdo->generic_packet(cdi, cgc);
1953 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
1954 struct cdrom_subchnl *subchnl, int mcn)
1956 struct cdrom_device_ops *cdo = cdi->ops;
1957 struct packet_command cgc;
1961 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1962 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
1963 cgc.cmd[1] = 2; /* MSF addressing */
1964 cgc.cmd[2] = 0x40; /* request subQ data */
1965 cgc.cmd[3] = mcn ? 2 : 1;
1968 if ((ret = cdo->generic_packet(cdi, &cgc)))
1971 subchnl->cdsc_audiostatus = cgc.buffer[1];
1972 subchnl->cdsc_format = CDROM_MSF;
1973 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
1974 subchnl->cdsc_trk = cgc.buffer[6];
1975 subchnl->cdsc_ind = cgc.buffer[7];
1977 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
1978 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
1979 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
1980 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
1981 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
1982 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
1988 * Specific READ_10 interface
1990 static int cdrom_read_cd(struct cdrom_device_info *cdi,
1991 struct packet_command *cgc, int lba,
1992 int blocksize, int nblocks)
1994 struct cdrom_device_ops *cdo = cdi->ops;
1996 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
1997 cgc->cmd[0] = GPCMD_READ_10;
1998 cgc->cmd[2] = (lba >> 24) & 0xff;
1999 cgc->cmd[3] = (lba >> 16) & 0xff;
2000 cgc->cmd[4] = (lba >> 8) & 0xff;
2001 cgc->cmd[5] = lba & 0xff;
2002 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2003 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2004 cgc->cmd[8] = nblocks & 0xff;
2005 cgc->buflen = blocksize * nblocks;
2006 return cdo->generic_packet(cdi, cgc);
2009 /* very generic interface for reading the various types of blocks */
2010 static int cdrom_read_block(struct cdrom_device_info *cdi,
2011 struct packet_command *cgc,
2012 int lba, int nblocks, int format, int blksize)
2014 struct cdrom_device_ops *cdo = cdi->ops;
2016 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2017 cgc->cmd[0] = GPCMD_READ_CD;
2018 /* expected sector size - cdda,mode1,etc. */
2019 cgc->cmd[1] = format << 2;
2020 /* starting address */
2021 cgc->cmd[2] = (lba >> 24) & 0xff;
2022 cgc->cmd[3] = (lba >> 16) & 0xff;
2023 cgc->cmd[4] = (lba >> 8) & 0xff;
2024 cgc->cmd[5] = lba & 0xff;
2025 /* number of blocks */
2026 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2027 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2028 cgc->cmd[8] = nblocks & 0xff;
2029 cgc->buflen = blksize * nblocks;
2031 /* set the header info returned */
2033 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
2034 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
2035 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
2036 default : cgc->cmd[9] = 0x10;
2039 return cdo->generic_packet(cdi, cgc);
2042 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2043 int lba, int nframes)
2045 struct packet_command cgc;
2049 cdi->last_sense = 0;
2051 memset(&cgc, 0, sizeof(cgc));
2054 * start with will ra.nframes size, back down if alloc fails
2058 cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2068 if (!access_ok(VERIFY_WRITE, ubuf, nframes * CD_FRAMESIZE_RAW)) {
2073 cgc.data_direction = CGC_DATA_READ;
2074 while (nframes > 0) {
2078 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2081 if (__copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2085 ubuf += CD_FRAMESIZE_RAW * nr;
2094 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2095 int lba, int nframes)
2097 request_queue_t *q = cdi->disk->queue;
2106 rq = blk_get_request(q, READ, GFP_KERNEL);
2110 cdi->last_sense = 0;
2114 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2116 if (nr * CD_FRAMESIZE_RAW > (q->max_sectors << 9))
2117 nr = (q->max_sectors << 9) / CD_FRAMESIZE_RAW;
2119 len = nr * CD_FRAMESIZE_RAW;
2121 ret = blk_rq_map_user(q, rq, ubuf, len);
2125 memset(rq->cmd, 0, sizeof(rq->cmd));
2126 rq->cmd[0] = GPCMD_READ_CD;
2127 rq->cmd[1] = 1 << 2;
2128 rq->cmd[2] = (lba >> 24) & 0xff;
2129 rq->cmd[3] = (lba >> 16) & 0xff;
2130 rq->cmd[4] = (lba >> 8) & 0xff;
2131 rq->cmd[5] = lba & 0xff;
2132 rq->cmd[6] = (nr >> 16) & 0xff;
2133 rq->cmd[7] = (nr >> 8) & 0xff;
2134 rq->cmd[8] = nr & 0xff;
2138 rq->cmd_type = REQ_TYPE_BLOCK_PC;
2139 rq->timeout = 60 * HZ;
2142 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2143 struct request_sense *s = rq->sense;
2145 cdi->last_sense = s->sense_key;
2148 if (blk_rq_unmap_user(bio))
2159 blk_put_request(rq);
2163 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2164 int lba, int nframes)
2168 if (cdi->cdda_method == CDDA_OLD)
2169 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2173 * for anything else than success and io error, we need to retry
2175 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2176 if (!ret || ret != -EIO)
2180 * I've seen drives get sense 4/8/3 udma crc errors on multi
2181 * frame dma, so drop to single frame dma if we need to
2183 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2184 printk("cdrom: dropping to single frame dma\n");
2185 cdi->cdda_method = CDDA_BPC_SINGLE;
2190 * so we have an io error of some sort with multi frame dma. if the
2191 * condition wasn't a hardware error
2192 * problems, not for any error
2194 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2197 printk("cdrom: dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2198 cdi->cdda_method = CDDA_OLD;
2199 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2202 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2205 struct cdrom_multisession ms_info;
2206 u8 requested_format;
2209 cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2211 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2214 if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2217 requested_format = ms_info.addr_format;
2218 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2220 ms_info.addr_format = CDROM_LBA;
2222 ret = cdi->ops->get_last_session(cdi, &ms_info);
2226 sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2228 if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2231 cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2235 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2237 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2239 if (!CDROM_CAN(CDC_OPEN_TRAY))
2241 if (cdi->use_count != 1 || keeplocked)
2243 if (CDROM_CAN(CDC_LOCK)) {
2244 int ret = cdi->ops->lock_door(cdi, 0);
2249 return cdi->ops->tray_move(cdi, 1);
2252 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2254 cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2256 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2258 return cdi->ops->tray_move(cdi, 0);
2261 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2264 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2266 if (!CDROM_CAN(CDC_OPEN_TRAY))
2271 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2273 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2277 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2280 struct cdrom_changer_info *info;
2283 cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2285 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2288 /* cannot select disc or select current disc */
2289 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2290 return media_changed(cdi, 1);
2292 if ((unsigned int)arg >= cdi->capacity)
2295 info = kmalloc(sizeof(*info), GFP_KERNEL);
2299 ret = cdrom_read_mech_status(cdi, info);
2301 ret = info->slots[arg].change;
2306 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2309 cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2312 * Options need to be in sync with capability.
2313 * Too late for that, so we have to check each one separately.
2316 case CDO_USE_FFLAGS:
2317 case CDO_CHECK_TYPE:
2320 if (!CDROM_CAN(CDC_LOCK))
2324 return cdi->options;
2325 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2327 if (!CDROM_CAN(arg))
2330 cdi->options |= (int) arg;
2331 return cdi->options;
2334 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2337 cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2339 cdi->options &= ~(int) arg;
2340 return cdi->options;
2343 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2346 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2348 if (!CDROM_CAN(CDC_SELECT_SPEED))
2350 return cdi->ops->select_speed(cdi, arg);
2353 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2356 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2358 if (!CDROM_CAN(CDC_SELECT_DISC))
2361 if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2362 if ((int)arg >= cdi->capacity)
2367 * ->select_disc is a hook to allow a driver-specific way of
2368 * seleting disc. However, since there is no equivalent hook for
2369 * cdrom_slot_status this may not actually be useful...
2371 if (cdi->ops->select_disc)
2372 return cdi->ops->select_disc(cdi, arg);
2374 cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2375 return cdrom_select_disc(cdi, arg);
2378 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2379 struct block_device *bdev)
2381 cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2383 if (!capable(CAP_SYS_ADMIN))
2385 if (!CDROM_CAN(CDC_RESET))
2387 invalidate_bdev(bdev);
2388 return cdi->ops->reset(cdi);
2391 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2394 cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2396 if (!CDROM_CAN(CDC_LOCK))
2397 return -EDRIVE_CANT_DO_THIS;
2399 keeplocked = arg ? 1 : 0;
2402 * Don't unlock the door on multiple opens by default, but allow
2405 if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2407 return cdi->ops->lock_door(cdi, arg);
2410 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2413 cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2415 if (!capable(CAP_SYS_ADMIN))
2417 debug = arg ? 1 : 0;
2421 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2423 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2424 return (cdi->ops->capability & ~cdi->mask);
2428 * The following function is implemented, although very few audio
2429 * discs give Universal Product Code information, which should just be
2430 * the Medium Catalog Number on the box. Note, that the way the code
2431 * is written on the CD is /not/ uniform across all discs!
2433 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2436 struct cdrom_mcn mcn;
2439 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2441 if (!(cdi->ops->capability & CDC_MCN))
2443 ret = cdi->ops->get_mcn(cdi, &mcn);
2447 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2449 cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2453 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2456 cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2458 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2460 if (!CDROM_CAN(CDC_SELECT_DISC) ||
2461 (arg == CDSL_CURRENT || arg == CDSL_NONE))
2462 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2463 if (((int)arg >= cdi->capacity))
2465 return cdrom_slot_status(cdi, arg);
2469 * Ok, this is where problems start. The current interface for the
2470 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2471 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunatly, while this
2472 * is often the case, it is also very common for CDs to have some tracks
2473 * with data, and some tracks with audio. Just because I feel like it,
2474 * I declare the following to be the best way to cope. If the CD has ANY
2475 * data tracks on it, it will be returned as a data CD. If it has any XA
2476 * tracks, I will return it as that. Now I could simplify this interface
2477 * by combining these returns with the above, but this more clearly
2478 * demonstrates the problem with the current interface. Too bad this
2479 * wasn't designed to use bitmasks... -Erik
2481 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2482 * User level programmers might feel the ioctl is not very useful.
2485 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2489 cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2491 cdrom_count_tracks(cdi, &tracks);
2493 return tracks.error;
2495 /* Policy mode on */
2496 if (tracks.audio > 0) {
2497 if (!tracks.data && !tracks.cdi && !tracks.xa)
2507 if (tracks.data > 0)
2509 /* Policy mode off */
2511 cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2515 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2517 cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2518 return cdi->capacity;
2521 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2524 struct cdrom_subchnl q;
2528 /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2530 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2532 if (copy_from_user(&q, argp, sizeof(q)))
2535 requested = q.cdsc_format;
2536 if (requested != CDROM_MSF && requested != CDROM_LBA)
2538 q.cdsc_format = CDROM_MSF;
2540 ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2544 back = q.cdsc_format; /* local copy */
2545 sanitize_format(&q.cdsc_absaddr, &back, requested);
2546 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2548 if (copy_to_user(argp, &q, sizeof(q)))
2550 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2554 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2557 struct cdrom_tochdr header;
2560 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2562 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2564 if (copy_from_user(&header, argp, sizeof(header)))
2567 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2571 if (copy_to_user(argp, &header, sizeof(header)))
2573 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2577 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2580 struct cdrom_tocentry entry;
2581 u8 requested_format;
2584 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2586 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2588 if (copy_from_user(&entry, argp, sizeof(entry)))
2591 requested_format = entry.cdte_format;
2592 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2594 /* make interface to low-level uniform */
2595 entry.cdte_format = CDROM_MSF;
2596 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2599 sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2601 if (copy_to_user(argp, &entry, sizeof(entry)))
2603 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2607 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2610 struct cdrom_msf msf;
2612 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2614 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2616 if (copy_from_user(&msf, argp, sizeof(msf)))
2618 return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2621 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2627 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2629 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2631 if (copy_from_user(&ti, argp, sizeof(ti)))
2634 ret = check_for_audio_disc(cdi, cdi->ops);
2637 return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2639 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2642 struct cdrom_volctrl volume;
2644 cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2646 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2648 if (copy_from_user(&volume, argp, sizeof(volume)))
2650 return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2653 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2656 struct cdrom_volctrl volume;
2659 cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2661 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2664 ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2668 if (copy_to_user(argp, &volume, sizeof(volume)))
2673 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2678 cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2680 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2682 ret = check_for_audio_disc(cdi, cdi->ops);
2685 return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2689 * Just about every imaginable ioctl is supported in the Uniform layer
2691 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2693 int cdrom_ioctl(struct file * file, struct cdrom_device_info *cdi,
2694 struct inode *ip, unsigned int cmd, unsigned long arg)
2696 void __user *argp = (void __user *)arg;
2698 struct gendisk *disk = ip->i_bdev->bd_disk;
2701 * Try the generic SCSI command ioctl's first.
2703 ret = scsi_cmd_ioctl(file, disk->queue, disk, cmd, argp);
2708 case CDROMMULTISESSION:
2709 return cdrom_ioctl_multisession(cdi, argp);
2711 return cdrom_ioctl_eject(cdi);
2712 case CDROMCLOSETRAY:
2713 return cdrom_ioctl_closetray(cdi);
2715 return cdrom_ioctl_eject_sw(cdi, arg);
2716 case CDROM_MEDIA_CHANGED:
2717 return cdrom_ioctl_media_changed(cdi, arg);
2718 case CDROM_SET_OPTIONS:
2719 return cdrom_ioctl_set_options(cdi, arg);
2720 case CDROM_CLEAR_OPTIONS:
2721 return cdrom_ioctl_clear_options(cdi, arg);
2722 case CDROM_SELECT_SPEED:
2723 return cdrom_ioctl_select_speed(cdi, arg);
2724 case CDROM_SELECT_DISC:
2725 return cdrom_ioctl_select_disc(cdi, arg);
2727 return cdrom_ioctl_reset(cdi, ip->i_bdev);
2728 case CDROM_LOCKDOOR:
2729 return cdrom_ioctl_lock_door(cdi, arg);
2731 return cdrom_ioctl_debug(cdi, arg);
2732 case CDROM_GET_CAPABILITY:
2733 return cdrom_ioctl_get_capability(cdi);
2735 return cdrom_ioctl_get_mcn(cdi, argp);
2736 case CDROM_DRIVE_STATUS:
2737 return cdrom_ioctl_drive_status(cdi, arg);
2738 case CDROM_DISC_STATUS:
2739 return cdrom_ioctl_disc_status(cdi);
2740 case CDROM_CHANGER_NSLOTS:
2741 return cdrom_ioctl_changer_nslots(cdi);
2745 * Use the ioctls that are implemented through the generic_packet()
2746 * interface. this may look at bit funny, but if -ENOTTY is
2747 * returned that particular ioctl is not implemented and we
2748 * let it go through the device specific ones.
2750 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2751 ret = mmc_ioctl(cdi, cmd, arg);
2757 * Note: most of the cdinfo() calls are commented out here,
2758 * because they fill up the sys log when CD players poll
2763 return cdrom_ioctl_get_subchnl(cdi, argp);
2764 case CDROMREADTOCHDR:
2765 return cdrom_ioctl_read_tochdr(cdi, argp);
2766 case CDROMREADTOCENTRY:
2767 return cdrom_ioctl_read_tocentry(cdi, argp);
2769 return cdrom_ioctl_play_msf(cdi, argp);
2770 case CDROMPLAYTRKIND:
2771 return cdrom_ioctl_play_trkind(cdi, argp);
2773 return cdrom_ioctl_volctrl(cdi, argp);
2775 return cdrom_ioctl_volread(cdi, argp);
2780 return cdrom_ioctl_audioctl(cdi, cmd);
2787 int msf_to_lba(char m, char s, char f)
2789 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2793 * Required when we need to use READ_10 to issue other than 2048 block
2796 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2798 struct cdrom_device_ops *cdo = cdi->ops;
2799 struct packet_command cgc;
2800 struct modesel_head mh;
2802 memset(&mh, 0, sizeof(mh));
2803 mh.block_desc_length = 0x08;
2804 mh.block_length_med = (size >> 8) & 0xff;
2805 mh.block_length_lo = size & 0xff;
2807 memset(&cgc, 0, sizeof(cgc));
2809 cgc.cmd[1] = 1 << 4;
2811 cgc.buflen = sizeof(mh);
2812 cgc.buffer = (char *) &mh;
2813 cgc.data_direction = CGC_DATA_WRITE;
2814 mh.block_desc_length = 0x08;
2815 mh.block_length_med = (size >> 8) & 0xff;
2816 mh.block_length_lo = size & 0xff;
2818 return cdo->generic_packet(cdi, &cgc);
2821 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
2824 struct cdrom_device_ops *cdo = cdi->ops;
2825 struct packet_command cgc;
2826 struct request_sense sense;
2827 unsigned char buffer[32];
2830 memset(&cgc, 0, sizeof(cgc));
2832 /* build a unified command and queue it through
2833 cdo->generic_packet() */
2836 case CDROMREADMODE1:
2837 case CDROMREADMODE2: {
2838 struct cdrom_msf msf;
2839 int blocksize = 0, format = 0, lba;
2843 blocksize = CD_FRAMESIZE_RAW;
2845 case CDROMREADMODE1:
2846 blocksize = CD_FRAMESIZE;
2849 case CDROMREADMODE2:
2850 blocksize = CD_FRAMESIZE_RAW0;
2853 IOCTL_IN(arg, struct cdrom_msf, msf);
2854 lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
2855 /* FIXME: we need upper bound checking, too!! */
2858 cgc.buffer = kmalloc(blocksize, GFP_KERNEL);
2859 if (cgc.buffer == NULL)
2861 memset(&sense, 0, sizeof(sense));
2863 cgc.data_direction = CGC_DATA_READ;
2864 ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
2865 if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) {
2867 * SCSI-II devices are not required to support
2868 * READ_CD, so let's try switching block size
2870 /* FIXME: switch back again... */
2871 if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
2876 ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
2877 ret |= cdrom_switch_blocksize(cdi, blocksize);
2879 if (!ret && copy_to_user((char __user *)arg, cgc.buffer, blocksize))
2884 case CDROMREADAUDIO: {
2885 struct cdrom_read_audio ra;
2888 IOCTL_IN(arg, struct cdrom_read_audio, ra);
2890 if (ra.addr_format == CDROM_MSF)
2891 lba = msf_to_lba(ra.addr.msf.minute,
2894 else if (ra.addr_format == CDROM_LBA)
2899 /* FIXME: we need upper bound checking, too!! */
2900 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2903 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2905 case CDROMSUBCHNL: {
2906 struct cdrom_subchnl q;
2907 u_char requested, back;
2908 IOCTL_IN(arg, struct cdrom_subchnl, q);
2909 requested = q.cdsc_format;
2910 if (!((requested == CDROM_MSF) ||
2911 (requested == CDROM_LBA)))
2913 q.cdsc_format = CDROM_MSF;
2914 if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
2916 back = q.cdsc_format; /* local copy */
2917 sanitize_format(&q.cdsc_absaddr, &back, requested);
2918 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2919 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2920 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2923 case CDROMPLAYMSF: {
2924 struct cdrom_msf msf;
2925 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2926 IOCTL_IN(arg, struct cdrom_msf, msf);
2927 cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2928 cgc.cmd[3] = msf.cdmsf_min0;
2929 cgc.cmd[4] = msf.cdmsf_sec0;
2930 cgc.cmd[5] = msf.cdmsf_frame0;
2931 cgc.cmd[6] = msf.cdmsf_min1;
2932 cgc.cmd[7] = msf.cdmsf_sec1;
2933 cgc.cmd[8] = msf.cdmsf_frame1;
2934 cgc.data_direction = CGC_DATA_NONE;
2935 return cdo->generic_packet(cdi, &cgc);
2937 case CDROMPLAYBLK: {
2938 struct cdrom_blk blk;
2939 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2940 IOCTL_IN(arg, struct cdrom_blk, blk);
2941 cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
2942 cgc.cmd[2] = (blk.from >> 24) & 0xff;
2943 cgc.cmd[3] = (blk.from >> 16) & 0xff;
2944 cgc.cmd[4] = (blk.from >> 8) & 0xff;
2945 cgc.cmd[5] = blk.from & 0xff;
2946 cgc.cmd[7] = (blk.len >> 8) & 0xff;
2947 cgc.cmd[8] = blk.len & 0xff;
2948 cgc.data_direction = CGC_DATA_NONE;
2949 return cdo->generic_packet(cdi, &cgc);
2952 case CDROMVOLREAD: {
2953 struct cdrom_volctrl volctrl;
2954 char mask[sizeof(buffer)];
2955 unsigned short offset;
2957 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
2959 IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
2961 cgc.buffer = buffer;
2963 if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
2966 /* originally the code depended on buffer[1] to determine
2967 how much data is available for transfer. buffer[1] is
2968 unfortunately ambigious and the only reliable way seem
2969 to be to simply skip over the block descriptor... */
2970 offset = 8 + be16_to_cpu(*(__be16 *)(buffer+6));
2972 if (offset + 16 > sizeof(buffer))
2975 if (offset + 16 > cgc.buflen) {
2976 cgc.buflen = offset+16;
2977 ret = cdrom_mode_sense(cdi, &cgc,
2978 GPMODE_AUDIO_CTL_PAGE, 0);
2984 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
2985 buffer[offset+1] < 14)
2988 /* now we have the current volume settings. if it was only
2989 a CDROMVOLREAD, return these values */
2990 if (cmd == CDROMVOLREAD) {
2991 volctrl.channel0 = buffer[offset+9];
2992 volctrl.channel1 = buffer[offset+11];
2993 volctrl.channel2 = buffer[offset+13];
2994 volctrl.channel3 = buffer[offset+15];
2995 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
2999 /* get the volume mask */
3001 if ((ret = cdrom_mode_sense(cdi, &cgc,
3002 GPMODE_AUDIO_CTL_PAGE, 1)))
3005 buffer[offset+9] = volctrl.channel0 & mask[offset+9];
3006 buffer[offset+11] = volctrl.channel1 & mask[offset+11];
3007 buffer[offset+13] = volctrl.channel2 & mask[offset+13];
3008 buffer[offset+15] = volctrl.channel3 & mask[offset+15];
3011 cgc.buffer = buffer + offset - 8;
3012 memset(cgc.buffer, 0, 8);
3013 return cdrom_mode_select(cdi, &cgc);
3018 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3019 cgc.cmd[0] = GPCMD_START_STOP_UNIT;
3021 cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3022 cgc.data_direction = CGC_DATA_NONE;
3023 return cdo->generic_packet(cdi, &cgc);
3028 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3029 cgc.cmd[0] = GPCMD_PAUSE_RESUME;
3030 cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3031 cgc.data_direction = CGC_DATA_NONE;
3032 return cdo->generic_packet(cdi, &cgc);
3035 case DVD_READ_STRUCT: {
3037 int size = sizeof(dvd_struct);
3038 if (!CDROM_CAN(CDC_DVD))
3040 if ((s = kmalloc(size, GFP_KERNEL)) == NULL)
3042 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3043 if (copy_from_user(s, (dvd_struct __user *)arg, size)) {
3047 if ((ret = dvd_read_struct(cdi, s))) {
3051 if (copy_to_user((dvd_struct __user *)arg, s, size))
3059 if (!CDROM_CAN(CDC_DVD))
3061 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
3062 IOCTL_IN(arg, dvd_authinfo, ai);
3063 if ((ret = dvd_do_auth (cdi, &ai)))
3065 IOCTL_OUT(arg, dvd_authinfo, ai);
3069 case CDROM_NEXT_WRITABLE: {
3071 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3072 if ((ret = cdrom_get_next_writable(cdi, &next)))
3074 IOCTL_OUT(arg, long, next);
3077 case CDROM_LAST_WRITTEN: {
3079 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3080 if ((ret = cdrom_get_last_written(cdi, &last)))
3082 IOCTL_OUT(arg, long, last);
3090 static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
3091 track_information *ti)
3093 struct cdrom_device_ops *cdo = cdi->ops;
3094 struct packet_command cgc;
3097 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3098 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3099 cgc.cmd[1] = type & 3;
3100 cgc.cmd[4] = (track & 0xff00) >> 8;
3101 cgc.cmd[5] = track & 0xff;
3105 if ((ret = cdo->generic_packet(cdi, &cgc)))
3108 buflen = be16_to_cpu(ti->track_information_length) +
3109 sizeof(ti->track_information_length);
3111 if (buflen > sizeof(track_information))
3112 buflen = sizeof(track_information);
3114 cgc.cmd[8] = cgc.buflen = buflen;
3115 if ((ret = cdo->generic_packet(cdi, &cgc)))
3118 /* return actual fill size */
3122 /* requires CD R/RW */
3123 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3125 struct cdrom_device_ops *cdo = cdi->ops;
3126 struct packet_command cgc;
3129 /* set up command and get the disc info */
3130 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3131 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3132 cgc.cmd[8] = cgc.buflen = 2;
3135 if ((ret = cdo->generic_packet(cdi, &cgc)))
3138 /* not all drives have the same disc_info length, so requeue
3139 * packet with the length the drive tells us it can supply
3141 buflen = be16_to_cpu(di->disc_information_length) +
3142 sizeof(di->disc_information_length);
3144 if (buflen > sizeof(disc_information))
3145 buflen = sizeof(disc_information);
3147 cgc.cmd[8] = cgc.buflen = buflen;
3148 if ((ret = cdo->generic_packet(cdi, &cgc)))
3151 /* return actual fill size */
3155 /* return the last written block on the CD-R media. this is for the udf
3157 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
3159 struct cdrom_tocentry toc;
3160 disc_information di;
3161 track_information ti;
3163 int ret = -1, ti_size;
3165 if (!CDROM_CAN(CDC_GENERIC_PACKET))
3168 ret = cdrom_get_disc_info(cdi, &di);
3169 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
3170 + sizeof(di.last_track_lsb)))
3173 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3174 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3175 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3176 if (ti_size < (int)offsetof(typeof(ti), track_start))
3179 /* if this track is blank, try the previous. */
3184 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3187 if (ti_size < (int)(offsetof(typeof(ti), track_size)
3188 + sizeof(ti.track_size)))
3191 /* if last recorded field is valid, return it. */
3192 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3193 + sizeof(ti.last_rec_address))) {
3194 *last_written = be32_to_cpu(ti.last_rec_address);
3196 /* make it up instead */
3197 *last_written = be32_to_cpu(ti.track_start) +
3198 be32_to_cpu(ti.track_size);
3200 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3204 /* this is where we end up if the drive either can't do a
3205 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3206 it doesn't give enough information or fails. then we return
3207 the toc contents. */
3209 toc.cdte_format = CDROM_MSF;
3210 toc.cdte_track = CDROM_LEADOUT;
3211 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
3213 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
3214 *last_written = toc.cdte_addr.lba;
3218 /* return the next writable block. also for udf file system. */
3219 static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3221 disc_information di;
3222 track_information ti;
3226 if (!CDROM_CAN(CDC_GENERIC_PACKET))
3227 goto use_last_written;
3229 ret = cdrom_get_disc_info(cdi, &di);
3230 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3231 + sizeof(di.last_track_lsb))
3232 goto use_last_written;
3234 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3235 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3236 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3237 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3238 goto use_last_written;
3240 /* if this track is blank, try the previous. */
3242 if (last_track == 1)
3243 goto use_last_written;
3245 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3247 goto use_last_written;
3250 /* if next recordable address field is valid, use it. */
3251 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
3252 + sizeof(ti.next_writable)) {
3253 *next_writable = be32_to_cpu(ti.next_writable);
3258 if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3262 *next_writable += 7;
3267 EXPORT_SYMBOL(cdrom_get_last_written);
3268 EXPORT_SYMBOL(register_cdrom);
3269 EXPORT_SYMBOL(unregister_cdrom);
3270 EXPORT_SYMBOL(cdrom_open);
3271 EXPORT_SYMBOL(cdrom_release);
3272 EXPORT_SYMBOL(cdrom_ioctl);
3273 EXPORT_SYMBOL(cdrom_media_changed);
3274 EXPORT_SYMBOL(cdrom_number_of_slots);
3275 EXPORT_SYMBOL(cdrom_mode_select);
3276 EXPORT_SYMBOL(cdrom_mode_sense);
3277 EXPORT_SYMBOL(init_cdrom_command);
3278 EXPORT_SYMBOL(cdrom_get_media_event);
3280 #ifdef CONFIG_SYSCTL
3282 #define CDROM_STR_SIZE 1000
3284 static struct cdrom_sysctl_settings {
3285 char info[CDROM_STR_SIZE]; /* general info */
3286 int autoclose; /* close tray upon mount, etc */
3287 int autoeject; /* eject on umount */
3288 int debug; /* turn on debugging messages */
3289 int lock; /* lock the door on device open */
3290 int check; /* check media type */
3291 } cdrom_sysctl_settings;
3293 enum cdrom_print_option {
3300 static int cdrom_print_info(const char *header, int val, char *info,
3301 int *pos, enum cdrom_print_option option)
3303 const int max_size = sizeof(cdrom_sysctl_settings.info);
3304 struct cdrom_device_info *cdi;
3307 ret = scnprintf(info + *pos, max_size - *pos, header);
3313 for (cdi = topCdromPtr; cdi; cdi = cdi->next) {
3316 ret = scnprintf(info + *pos, max_size - *pos,
3320 ret = scnprintf(info + *pos, max_size - *pos,
3321 "\t%d", cdi->speed);
3324 ret = scnprintf(info + *pos, max_size - *pos,
3325 "\t%d", cdi->capacity);
3327 case CTL_CAPABILITY:
3328 ret = scnprintf(info + *pos, max_size - *pos,
3329 "\t%d", CDROM_CAN(val) != 0);
3332 printk(KERN_INFO "cdrom: invalid option%d\n", option);
3343 static int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
3344 void __user *buffer, size_t *lenp, loff_t *ppos)
3347 char *info = cdrom_sysctl_settings.info;
3348 const int max_size = sizeof(cdrom_sysctl_settings.info);
3350 if (!*lenp || (*ppos && !write)) {
3355 mutex_lock(&cdrom_mutex);
3357 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3359 if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3361 if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3363 if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3365 if (cdrom_print_info("\nCan close tray:\t",
3366 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3368 if (cdrom_print_info("\nCan open tray:\t",
3369 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3371 if (cdrom_print_info("\nCan lock tray:\t",
3372 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3374 if (cdrom_print_info("\nCan change speed:",
3375 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3377 if (cdrom_print_info("\nCan select disk:",
3378 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3380 if (cdrom_print_info("\nCan read multisession:",
3381 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3383 if (cdrom_print_info("\nCan read MCN:\t",
3384 CDC_MCN, info, &pos, CTL_CAPABILITY))
3386 if (cdrom_print_info("\nReports media changed:",
3387 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3389 if (cdrom_print_info("\nCan play audio:\t",
3390 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3392 if (cdrom_print_info("\nCan write CD-R:\t",
3393 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3395 if (cdrom_print_info("\nCan write CD-RW:",
3396 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3398 if (cdrom_print_info("\nCan read DVD:\t",
3399 CDC_DVD, info, &pos, CTL_CAPABILITY))
3401 if (cdrom_print_info("\nCan write DVD-R:",
3402 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3404 if (cdrom_print_info("\nCan write DVD-RAM:",
3405 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3407 if (cdrom_print_info("\nCan read MRW:\t",
3408 CDC_MRW, info, &pos, CTL_CAPABILITY))
3410 if (cdrom_print_info("\nCan write MRW:\t",
3411 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3413 if (cdrom_print_info("\nCan write RAM:\t",
3414 CDC_RAM, info, &pos, CTL_CAPABILITY))
3416 if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3419 mutex_unlock(&cdrom_mutex);
3420 return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
3422 printk(KERN_INFO "cdrom: info buffer too small\n");
3426 /* Unfortunately, per device settings are not implemented through
3427 procfs/sysctl yet. When they are, this will naturally disappear. For now
3428 just update all drives. Later this will become the template on which
3429 new registered drives will be based. */
3430 static void cdrom_update_settings(void)
3432 struct cdrom_device_info *cdi;
3434 for (cdi = topCdromPtr; cdi != NULL; cdi = cdi->next) {
3435 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3436 cdi->options |= CDO_AUTO_CLOSE;
3437 else if (!autoclose)
3438 cdi->options &= ~CDO_AUTO_CLOSE;
3439 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3440 cdi->options |= CDO_AUTO_EJECT;
3441 else if (!autoeject)
3442 cdi->options &= ~CDO_AUTO_EJECT;
3443 if (lockdoor && CDROM_CAN(CDC_LOCK))
3444 cdi->options |= CDO_LOCK;
3446 cdi->options &= ~CDO_LOCK;
3447 if (check_media_type)
3448 cdi->options |= CDO_CHECK_TYPE;
3450 cdi->options &= ~CDO_CHECK_TYPE;
3454 static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
3455 void __user *buffer, size_t *lenp, loff_t *ppos)
3457 int *valp = ctl->data;
3461 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
3463 if (write && *valp != val) {
3465 /* we only care for 1 or 0. */
3471 switch (ctl->ctl_name) {
3472 case DEV_CDROM_AUTOCLOSE: {
3473 if (valp == &cdrom_sysctl_settings.autoclose)
3474 autoclose = cdrom_sysctl_settings.autoclose;
3477 case DEV_CDROM_AUTOEJECT: {
3478 if (valp == &cdrom_sysctl_settings.autoeject)
3479 autoeject = cdrom_sysctl_settings.autoeject;
3482 case DEV_CDROM_DEBUG: {
3483 if (valp == &cdrom_sysctl_settings.debug)
3484 debug = cdrom_sysctl_settings.debug;
3487 case DEV_CDROM_LOCK: {
3488 if (valp == &cdrom_sysctl_settings.lock)
3489 lockdoor = cdrom_sysctl_settings.lock;
3492 case DEV_CDROM_CHECK_MEDIA: {
3493 if (valp == &cdrom_sysctl_settings.check)
3494 check_media_type = cdrom_sysctl_settings.check;
3498 /* update the option flags according to the changes. we
3499 don't have per device options through sysctl yet,
3500 but we will have and then this will disappear. */
3501 cdrom_update_settings();
3507 /* Place files in /proc/sys/dev/cdrom */
3508 static ctl_table cdrom_table[] = {
3510 .ctl_name = DEV_CDROM_INFO,
3512 .data = &cdrom_sysctl_settings.info,
3513 .maxlen = CDROM_STR_SIZE,
3515 .proc_handler = &cdrom_sysctl_info,
3518 .ctl_name = DEV_CDROM_AUTOCLOSE,
3519 .procname = "autoclose",
3520 .data = &cdrom_sysctl_settings.autoclose,
3521 .maxlen = sizeof(int),
3523 .proc_handler = &cdrom_sysctl_handler,
3526 .ctl_name = DEV_CDROM_AUTOEJECT,
3527 .procname = "autoeject",
3528 .data = &cdrom_sysctl_settings.autoeject,
3529 .maxlen = sizeof(int),
3531 .proc_handler = &cdrom_sysctl_handler,
3534 .ctl_name = DEV_CDROM_DEBUG,
3535 .procname = "debug",
3536 .data = &cdrom_sysctl_settings.debug,
3537 .maxlen = sizeof(int),
3539 .proc_handler = &cdrom_sysctl_handler,
3542 .ctl_name = DEV_CDROM_LOCK,
3544 .data = &cdrom_sysctl_settings.lock,
3545 .maxlen = sizeof(int),
3547 .proc_handler = &cdrom_sysctl_handler,
3550 .ctl_name = DEV_CDROM_CHECK_MEDIA,
3551 .procname = "check_media",
3552 .data = &cdrom_sysctl_settings.check,
3553 .maxlen = sizeof(int),
3555 .proc_handler = &cdrom_sysctl_handler
3560 static ctl_table cdrom_cdrom_table[] = {
3562 .ctl_name = DEV_CDROM,
3563 .procname = "cdrom",
3566 .child = cdrom_table,
3571 /* Make sure that /proc/sys/dev is there */
3572 static ctl_table cdrom_root_table[] = {
3574 .ctl_name = CTL_DEV,
3578 .child = cdrom_cdrom_table,
3582 static struct ctl_table_header *cdrom_sysctl_header;
3584 static void cdrom_sysctl_register(void)
3586 static int initialized;
3588 if (initialized == 1)
3591 cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3593 /* set the defaults */
3594 cdrom_sysctl_settings.autoclose = autoclose;
3595 cdrom_sysctl_settings.autoeject = autoeject;
3596 cdrom_sysctl_settings.debug = debug;
3597 cdrom_sysctl_settings.lock = lockdoor;
3598 cdrom_sysctl_settings.check = check_media_type;
3603 static void cdrom_sysctl_unregister(void)
3605 if (cdrom_sysctl_header)
3606 unregister_sysctl_table(cdrom_sysctl_header);
3609 #endif /* CONFIG_SYSCTL */
3611 static int __init cdrom_init(void)
3613 #ifdef CONFIG_SYSCTL
3614 cdrom_sysctl_register();
3619 static void __exit cdrom_exit(void)
3621 printk(KERN_INFO "Uniform CD-ROM driver unloaded\n");
3622 #ifdef CONFIG_SYSCTL
3623 cdrom_sysctl_unregister();
3627 module_init(cdrom_init);
3628 module_exit(cdrom_exit);
3629 MODULE_LICENSE("GPL");
projects / linux-2.6 / blob