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 /* Admittedly, the logic below could be performed in a nicer way. */
1210 int cdrom_release(struct cdrom_device_info *cdi, struct file *fp)
1212 struct cdrom_device_ops *cdo = cdi->ops;
1213 int opened_for_data;
1215 cdinfo(CD_CLOSE, "entering cdrom_release\n");
1217 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 if (cdi->use_count == 0)
1222 cdrom_dvd_rw_close_write(cdi);
1223 if (cdi->use_count == 0 &&
1224 (cdo->capability & CDC_LOCK) && !keeplocked) {
1225 cdinfo(CD_CLOSE, "Unlocking door!\n");
1226 cdo->lock_door(cdi, 0);
1228 opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1229 !(fp && fp->f_flags & O_NONBLOCK);
1232 * flush cache on last write release
1234 if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1235 cdrom_close_write(cdi);
1238 if (cdi->use_count == 0) { /* last process that closes dev*/
1239 if (opened_for_data &&
1240 cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1241 cdo->tray_move(cdi, 1);
1246 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1247 struct cdrom_changer_info *buf)
1249 struct packet_command cgc;
1250 struct cdrom_device_ops *cdo = cdi->ops;
1254 * Sanyo changer isn't spec compliant (doesn't use regular change
1255 * LOAD_UNLOAD command, and it doesn't implement the mech status
1258 if (cdi->sanyo_slot) {
1259 buf->hdr.nslots = 3;
1260 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1261 for (length = 0; length < 3; length++) {
1262 buf->slots[length].disc_present = 1;
1263 buf->slots[length].change = 0;
1268 length = sizeof(struct cdrom_mechstat_header) +
1269 cdi->capacity * sizeof(struct cdrom_slot);
1271 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1272 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1273 cgc.cmd[8] = (length >> 8) & 0xff;
1274 cgc.cmd[9] = length & 0xff;
1275 return cdo->generic_packet(cdi, &cgc);
1278 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1280 struct cdrom_changer_info *info;
1283 cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n");
1284 if (cdi->sanyo_slot)
1287 info = kmalloc(sizeof(*info), GFP_KERNEL);
1291 if ((ret = cdrom_read_mech_status(cdi, info)))
1294 if (info->slots[slot].disc_present)
1304 /* Return the number of slots for an ATAPI/SCSI cdrom,
1305 * return 1 if not a changer.
1307 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1311 struct cdrom_changer_info *info;
1313 cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1314 /* cdrom_read_mech_status requires a valid value for capacity: */
1317 info = kmalloc(sizeof(*info), GFP_KERNEL);
1321 if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1322 nslots = info->hdr.nslots;
1329 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1330 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1332 struct packet_command cgc;
1334 cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n");
1335 if (cdi->sanyo_slot && slot < 0)
1338 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1339 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1340 cgc.cmd[4] = 2 + (slot >= 0);
1342 cgc.timeout = 60 * HZ;
1344 /* The Sanyo 3 CD changer uses byte 7 of the
1345 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1346 using the GPCMD_LOAD_UNLOAD opcode. */
1347 if (cdi->sanyo_slot && -1 < slot) {
1348 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1350 cgc.cmd[4] = cgc.cmd[8] = 0;
1351 cdi->sanyo_slot = slot ? slot : 3;
1354 return cdi->ops->generic_packet(cdi, &cgc);
1357 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1359 struct cdrom_changer_info *info;
1363 cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n");
1364 if (!CDROM_CAN(CDC_SELECT_DISC))
1365 return -EDRIVE_CANT_DO_THIS;
1367 (void) cdi->ops->media_changed(cdi, slot);
1369 if (slot == CDSL_NONE) {
1370 /* set media changed bits, on both queues */
1371 cdi->mc_flags = 0x3;
1372 return cdrom_load_unload(cdi, -1);
1375 info = kmalloc(sizeof(*info), GFP_KERNEL);
1379 if ((ret = cdrom_read_mech_status(cdi, info))) {
1384 curslot = info->hdr.curslot;
1387 if (cdi->use_count > 1 || keeplocked) {
1388 if (slot == CDSL_CURRENT) {
1395 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1396 which is useful if it had been previously unloaded.
1397 Whether it can or not, it returns the current slot.
1398 Similarly, if slot happens to be the current one, we still
1400 if (slot == CDSL_CURRENT)
1403 /* set media changed bits on both queues */
1404 cdi->mc_flags = 0x3;
1405 if ((ret = cdrom_load_unload(cdi, slot)))
1411 /* We want to make media_changed accessible to the user through an
1412 * ioctl. The main problem now is that we must double-buffer the
1413 * low-level implementation, to assure that the VFS and the user both
1414 * see a medium change once.
1418 int media_changed(struct cdrom_device_info *cdi, int queue)
1420 unsigned int mask = (1 << (queue & 1));
1421 int ret = !!(cdi->mc_flags & mask);
1423 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1425 /* changed since last call? */
1426 if (cdi->ops->media_changed(cdi, CDSL_CURRENT)) {
1427 cdi->mc_flags = 0x3; /* set bit on both queues */
1429 cdi->media_written = 0;
1431 cdi->mc_flags &= ~mask; /* clear bit */
1435 int cdrom_media_changed(struct cdrom_device_info *cdi)
1437 /* This talks to the VFS, which doesn't like errors - just 1 or 0.
1438 * Returning "0" is always safe (media hasn't been changed). Do that
1439 * if the low-level cdrom driver dosn't support media changed. */
1440 if (cdi == NULL || cdi->ops->media_changed == NULL)
1442 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1444 return media_changed(cdi, 0);
1447 /* badly broken, I know. Is due for a fixup anytime. */
1448 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1450 struct cdrom_tochdr header;
1451 struct cdrom_tocentry entry;
1458 cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1459 if (!CDROM_CAN(CDC_PLAY_AUDIO)) {
1460 tracks->error=CDS_NO_INFO;
1463 /* Grab the TOC header so we can see how many tracks there are */
1464 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1465 if (ret == -ENOMEDIUM)
1466 tracks->error = CDS_NO_DISC;
1468 tracks->error = CDS_NO_INFO;
1471 /* check what type of tracks are on this disc */
1472 entry.cdte_format = CDROM_MSF;
1473 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1474 entry.cdte_track = i;
1475 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1476 tracks->error=CDS_NO_INFO;
1479 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1480 if (entry.cdte_format == 0x10)
1482 else if (entry.cdte_format == 0x20)
1488 cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1489 i, entry.cdte_format, entry.cdte_ctrl);
1491 cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1492 header.cdth_trk1, tracks->audio, tracks->data,
1493 tracks->cdi, tracks->xa);
1496 /* Requests to the low-level drivers will /always/ be done in the
1497 following format convention:
1499 CDROM_LBA: all data-related requests.
1500 CDROM_MSF: all audio-related requests.
1502 However, a low-level implementation is allowed to refuse this
1503 request, and return information in its own favorite format.
1505 It doesn't make sense /at all/ to ask for a play_audio in LBA
1506 format, or ask for multi-session info in MSF format. However, for
1507 backward compatibility these format requests will be satisfied, but
1508 the requests to the low-level drivers will be sanitized in the more
1509 meaningful format indicated above.
1513 void sanitize_format(union cdrom_addr *addr,
1514 u_char * curr, u_char requested)
1516 if (*curr == requested)
1517 return; /* nothing to be done! */
1518 if (requested == CDROM_LBA) {
1519 addr->lba = (int) addr->msf.frame +
1520 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1521 } else { /* CDROM_MSF */
1522 int lba = addr->lba;
1523 addr->msf.frame = lba % 75;
1526 addr->msf.second = lba % 60;
1527 addr->msf.minute = lba / 60;
1532 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1535 memset(cgc, 0, sizeof(struct packet_command));
1537 memset(buf, 0, len);
1538 cgc->buffer = (char *) buf;
1540 cgc->data_direction = type;
1541 cgc->timeout = CDROM_DEF_TIMEOUT;
1546 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1547 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1549 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1551 cgc->cmd[0] = GPCMD_REPORT_KEY;
1552 cgc->cmd[10] = type | (agid << 6);
1554 case 0: case 8: case 5: {
1567 cgc->cmd[9] = cgc->buflen;
1568 cgc->data_direction = CGC_DATA_READ;
1571 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1573 cgc->cmd[0] = GPCMD_SEND_KEY;
1574 cgc->cmd[10] = type | (agid << 6);
1589 cgc->cmd[9] = cgc->buflen;
1590 cgc->data_direction = CGC_DATA_WRITE;
1593 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1597 struct packet_command cgc;
1598 struct cdrom_device_ops *cdo = cdi->ops;
1599 rpc_state_t rpc_state;
1601 memset(buf, 0, sizeof(buf));
1602 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1606 case DVD_LU_SEND_AGID:
1607 cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1609 setup_report_key(&cgc, ai->lsa.agid, 0);
1611 if ((ret = cdo->generic_packet(cdi, &cgc)))
1614 ai->lsa.agid = buf[7] >> 6;
1615 /* Returning data, let host change state */
1618 case DVD_LU_SEND_KEY1:
1619 cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1620 setup_report_key(&cgc, ai->lsk.agid, 2);
1622 if ((ret = cdo->generic_packet(cdi, &cgc)))
1625 copy_key(ai->lsk.key, &buf[4]);
1626 /* Returning data, let host change state */
1629 case DVD_LU_SEND_CHALLENGE:
1630 cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1631 setup_report_key(&cgc, ai->lsc.agid, 1);
1633 if ((ret = cdo->generic_packet(cdi, &cgc)))
1636 copy_chal(ai->lsc.chal, &buf[4]);
1637 /* Returning data, let host change state */
1641 case DVD_LU_SEND_TITLE_KEY:
1642 cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1644 setup_report_key(&cgc, ai->lstk.agid, 4);
1645 cgc.cmd[5] = ai->lstk.lba;
1646 cgc.cmd[4] = ai->lstk.lba >> 8;
1647 cgc.cmd[3] = ai->lstk.lba >> 16;
1648 cgc.cmd[2] = ai->lstk.lba >> 24;
1650 if ((ret = cdo->generic_packet(cdi, &cgc)))
1653 ai->lstk.cpm = (buf[4] >> 7) & 1;
1654 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1655 ai->lstk.cgms = (buf[4] >> 4) & 3;
1656 copy_key(ai->lstk.title_key, &buf[5]);
1657 /* Returning data, let host change state */
1660 case DVD_LU_SEND_ASF:
1661 cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1662 setup_report_key(&cgc, ai->lsasf.agid, 5);
1664 if ((ret = cdo->generic_packet(cdi, &cgc)))
1667 ai->lsasf.asf = buf[7] & 1;
1670 /* LU data receive (LU changes state) */
1671 case DVD_HOST_SEND_CHALLENGE:
1672 cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1673 setup_send_key(&cgc, ai->hsc.agid, 1);
1675 copy_chal(&buf[4], ai->hsc.chal);
1677 if ((ret = cdo->generic_packet(cdi, &cgc)))
1680 ai->type = DVD_LU_SEND_KEY1;
1683 case DVD_HOST_SEND_KEY2:
1684 cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1685 setup_send_key(&cgc, ai->hsk.agid, 3);
1687 copy_key(&buf[4], ai->hsk.key);
1689 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1690 ai->type = DVD_AUTH_FAILURE;
1693 ai->type = DVD_AUTH_ESTABLISHED;
1697 case DVD_INVALIDATE_AGID:
1699 cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1700 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1701 if ((ret = cdo->generic_packet(cdi, &cgc)))
1705 /* Get region settings */
1706 case DVD_LU_SEND_RPC_STATE:
1707 cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1708 setup_report_key(&cgc, 0, 8);
1709 memset(&rpc_state, 0, sizeof(rpc_state_t));
1710 cgc.buffer = (char *) &rpc_state;
1712 if ((ret = cdo->generic_packet(cdi, &cgc)))
1715 ai->lrpcs.type = rpc_state.type_code;
1716 ai->lrpcs.vra = rpc_state.vra;
1717 ai->lrpcs.ucca = rpc_state.ucca;
1718 ai->lrpcs.region_mask = rpc_state.region_mask;
1719 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1722 /* Set region settings */
1723 case DVD_HOST_SEND_RPC_STATE:
1724 cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1725 setup_send_key(&cgc, 0, 6);
1727 buf[4] = ai->hrpcs.pdrc;
1729 if ((ret = cdo->generic_packet(cdi, &cgc)))
1734 cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1741 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
1743 unsigned char buf[21], *base;
1744 struct dvd_layer *layer;
1745 struct packet_command cgc;
1746 struct cdrom_device_ops *cdo = cdi->ops;
1747 int ret, layer_num = s->physical.layer_num;
1749 if (layer_num >= DVD_LAYERS)
1752 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1753 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1754 cgc.cmd[6] = layer_num;
1755 cgc.cmd[7] = s->type;
1756 cgc.cmd[9] = cgc.buflen & 0xff;
1759 * refrain from reporting errors on non-existing layers (mainly)
1763 if ((ret = cdo->generic_packet(cdi, &cgc)))
1767 layer = &s->physical.layer[layer_num];
1770 * place the data... really ugly, but at least we won't have to
1771 * worry about endianess in userspace.
1773 memset(layer, 0, sizeof(*layer));
1774 layer->book_version = base[0] & 0xf;
1775 layer->book_type = base[0] >> 4;
1776 layer->min_rate = base[1] & 0xf;
1777 layer->disc_size = base[1] >> 4;
1778 layer->layer_type = base[2] & 0xf;
1779 layer->track_path = (base[2] >> 4) & 1;
1780 layer->nlayers = (base[2] >> 5) & 3;
1781 layer->track_density = base[3] & 0xf;
1782 layer->linear_density = base[3] >> 4;
1783 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1784 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1785 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1786 layer->bca = base[16] >> 7;
1791 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
1795 struct packet_command cgc;
1796 struct cdrom_device_ops *cdo = cdi->ops;
1798 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1799 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1800 cgc.cmd[6] = s->copyright.layer_num;
1801 cgc.cmd[7] = s->type;
1802 cgc.cmd[8] = cgc.buflen >> 8;
1803 cgc.cmd[9] = cgc.buflen & 0xff;
1805 if ((ret = cdo->generic_packet(cdi, &cgc)))
1808 s->copyright.cpst = buf[4];
1809 s->copyright.rmi = buf[5];
1814 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s)
1818 struct packet_command cgc;
1819 struct cdrom_device_ops *cdo = cdi->ops;
1821 size = sizeof(s->disckey.value) + 4;
1823 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1826 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1827 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1828 cgc.cmd[7] = s->type;
1829 cgc.cmd[8] = size >> 8;
1830 cgc.cmd[9] = size & 0xff;
1831 cgc.cmd[10] = s->disckey.agid << 6;
1833 if (!(ret = cdo->generic_packet(cdi, &cgc)))
1834 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1840 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s)
1843 u_char buf[4 + 188];
1844 struct packet_command cgc;
1845 struct cdrom_device_ops *cdo = cdi->ops;
1847 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1848 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1849 cgc.cmd[7] = s->type;
1850 cgc.cmd[9] = cgc.buflen & 0xff;
1852 if ((ret = cdo->generic_packet(cdi, &cgc)))
1855 s->bca.len = buf[0] << 8 | buf[1];
1856 if (s->bca.len < 12 || s->bca.len > 188) {
1857 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1860 memcpy(s->bca.value, &buf[4], s->bca.len);
1865 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s)
1869 struct packet_command cgc;
1870 struct cdrom_device_ops *cdo = cdi->ops;
1872 size = sizeof(s->manufact.value) + 4;
1874 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1877 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1878 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1879 cgc.cmd[7] = s->type;
1880 cgc.cmd[8] = size >> 8;
1881 cgc.cmd[9] = size & 0xff;
1883 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1888 s->manufact.len = buf[0] << 8 | buf[1];
1889 if (s->manufact.len < 0 || s->manufact.len > 2048) {
1890 cdinfo(CD_WARNING, "Received invalid manufacture info length"
1891 " (%d)\n", s->manufact.len);
1894 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1901 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s)
1904 case DVD_STRUCT_PHYSICAL:
1905 return dvd_read_physical(cdi, s);
1907 case DVD_STRUCT_COPYRIGHT:
1908 return dvd_read_copyright(cdi, s);
1910 case DVD_STRUCT_DISCKEY:
1911 return dvd_read_disckey(cdi, s);
1913 case DVD_STRUCT_BCA:
1914 return dvd_read_bca(cdi, s);
1916 case DVD_STRUCT_MANUFACT:
1917 return dvd_read_manufact(cdi, s);
1920 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1926 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1927 struct packet_command *cgc,
1928 int page_code, int page_control)
1930 struct cdrom_device_ops *cdo = cdi->ops;
1932 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1934 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1935 cgc->cmd[2] = page_code | (page_control << 6);
1936 cgc->cmd[7] = cgc->buflen >> 8;
1937 cgc->cmd[8] = cgc->buflen & 0xff;
1938 cgc->data_direction = CGC_DATA_READ;
1939 return cdo->generic_packet(cdi, cgc);
1942 int cdrom_mode_select(struct cdrom_device_info *cdi,
1943 struct packet_command *cgc)
1945 struct cdrom_device_ops *cdo = cdi->ops;
1947 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1948 memset(cgc->buffer, 0, 2);
1949 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1950 cgc->cmd[1] = 0x10; /* PF */
1951 cgc->cmd[7] = cgc->buflen >> 8;
1952 cgc->cmd[8] = cgc->buflen & 0xff;
1953 cgc->data_direction = CGC_DATA_WRITE;
1954 return cdo->generic_packet(cdi, cgc);
1957 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
1958 struct cdrom_subchnl *subchnl, int mcn)
1960 struct cdrom_device_ops *cdo = cdi->ops;
1961 struct packet_command cgc;
1965 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1966 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
1967 cgc.cmd[1] = 2; /* MSF addressing */
1968 cgc.cmd[2] = 0x40; /* request subQ data */
1969 cgc.cmd[3] = mcn ? 2 : 1;
1972 if ((ret = cdo->generic_packet(cdi, &cgc)))
1975 subchnl->cdsc_audiostatus = cgc.buffer[1];
1976 subchnl->cdsc_format = CDROM_MSF;
1977 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
1978 subchnl->cdsc_trk = cgc.buffer[6];
1979 subchnl->cdsc_ind = cgc.buffer[7];
1981 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
1982 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
1983 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
1984 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
1985 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
1986 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
1992 * Specific READ_10 interface
1994 static int cdrom_read_cd(struct cdrom_device_info *cdi,
1995 struct packet_command *cgc, int lba,
1996 int blocksize, int nblocks)
1998 struct cdrom_device_ops *cdo = cdi->ops;
2000 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2001 cgc->cmd[0] = GPCMD_READ_10;
2002 cgc->cmd[2] = (lba >> 24) & 0xff;
2003 cgc->cmd[3] = (lba >> 16) & 0xff;
2004 cgc->cmd[4] = (lba >> 8) & 0xff;
2005 cgc->cmd[5] = lba & 0xff;
2006 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2007 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2008 cgc->cmd[8] = nblocks & 0xff;
2009 cgc->buflen = blocksize * nblocks;
2010 return cdo->generic_packet(cdi, cgc);
2013 /* very generic interface for reading the various types of blocks */
2014 static int cdrom_read_block(struct cdrom_device_info *cdi,
2015 struct packet_command *cgc,
2016 int lba, int nblocks, int format, int blksize)
2018 struct cdrom_device_ops *cdo = cdi->ops;
2020 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2021 cgc->cmd[0] = GPCMD_READ_CD;
2022 /* expected sector size - cdda,mode1,etc. */
2023 cgc->cmd[1] = format << 2;
2024 /* starting address */
2025 cgc->cmd[2] = (lba >> 24) & 0xff;
2026 cgc->cmd[3] = (lba >> 16) & 0xff;
2027 cgc->cmd[4] = (lba >> 8) & 0xff;
2028 cgc->cmd[5] = lba & 0xff;
2029 /* number of blocks */
2030 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2031 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2032 cgc->cmd[8] = nblocks & 0xff;
2033 cgc->buflen = blksize * nblocks;
2035 /* set the header info returned */
2037 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
2038 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
2039 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
2040 default : cgc->cmd[9] = 0x10;
2043 return cdo->generic_packet(cdi, cgc);
2046 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2047 int lba, int nframes)
2049 struct packet_command cgc;
2053 cdi->last_sense = 0;
2055 memset(&cgc, 0, sizeof(cgc));
2058 * start with will ra.nframes size, back down if alloc fails
2062 cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2072 if (!access_ok(VERIFY_WRITE, ubuf, nframes * CD_FRAMESIZE_RAW)) {
2077 cgc.data_direction = CGC_DATA_READ;
2078 while (nframes > 0) {
2082 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2085 if (__copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2089 ubuf += CD_FRAMESIZE_RAW * nr;
2098 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2099 int lba, int nframes)
2101 struct request_queue *q = cdi->disk->queue;
2110 rq = blk_get_request(q, READ, GFP_KERNEL);
2114 cdi->last_sense = 0;
2118 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2120 if (nr * CD_FRAMESIZE_RAW > (q->max_sectors << 9))
2121 nr = (q->max_sectors << 9) / CD_FRAMESIZE_RAW;
2123 len = nr * CD_FRAMESIZE_RAW;
2125 ret = blk_rq_map_user(q, rq, ubuf, len);
2129 memset(rq->cmd, 0, sizeof(rq->cmd));
2130 rq->cmd[0] = GPCMD_READ_CD;
2131 rq->cmd[1] = 1 << 2;
2132 rq->cmd[2] = (lba >> 24) & 0xff;
2133 rq->cmd[3] = (lba >> 16) & 0xff;
2134 rq->cmd[4] = (lba >> 8) & 0xff;
2135 rq->cmd[5] = lba & 0xff;
2136 rq->cmd[6] = (nr >> 16) & 0xff;
2137 rq->cmd[7] = (nr >> 8) & 0xff;
2138 rq->cmd[8] = nr & 0xff;
2142 rq->cmd_type = REQ_TYPE_BLOCK_PC;
2143 rq->timeout = 60 * HZ;
2146 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2147 struct request_sense *s = rq->sense;
2149 cdi->last_sense = s->sense_key;
2152 if (blk_rq_unmap_user(bio))
2163 blk_put_request(rq);
2167 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2168 int lba, int nframes)
2172 if (cdi->cdda_method == CDDA_OLD)
2173 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2177 * for anything else than success and io error, we need to retry
2179 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2180 if (!ret || ret != -EIO)
2184 * I've seen drives get sense 4/8/3 udma crc errors on multi
2185 * frame dma, so drop to single frame dma if we need to
2187 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2188 printk("cdrom: dropping to single frame dma\n");
2189 cdi->cdda_method = CDDA_BPC_SINGLE;
2194 * so we have an io error of some sort with multi frame dma. if the
2195 * condition wasn't a hardware error
2196 * problems, not for any error
2198 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2201 printk("cdrom: dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2202 cdi->cdda_method = CDDA_OLD;
2203 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2206 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2209 struct cdrom_multisession ms_info;
2210 u8 requested_format;
2213 cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2215 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2218 if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2221 requested_format = ms_info.addr_format;
2222 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2224 ms_info.addr_format = CDROM_LBA;
2226 ret = cdi->ops->get_last_session(cdi, &ms_info);
2230 sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2232 if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2235 cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2239 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2241 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2243 if (!CDROM_CAN(CDC_OPEN_TRAY))
2245 if (cdi->use_count != 1 || keeplocked)
2247 if (CDROM_CAN(CDC_LOCK)) {
2248 int ret = cdi->ops->lock_door(cdi, 0);
2253 return cdi->ops->tray_move(cdi, 1);
2256 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2258 cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2260 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2262 return cdi->ops->tray_move(cdi, 0);
2265 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2268 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2270 if (!CDROM_CAN(CDC_OPEN_TRAY))
2275 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2277 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2281 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2284 struct cdrom_changer_info *info;
2287 cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2289 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2292 /* cannot select disc or select current disc */
2293 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2294 return media_changed(cdi, 1);
2296 if ((unsigned int)arg >= cdi->capacity)
2299 info = kmalloc(sizeof(*info), GFP_KERNEL);
2303 ret = cdrom_read_mech_status(cdi, info);
2305 ret = info->slots[arg].change;
2310 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2313 cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2316 * Options need to be in sync with capability.
2317 * Too late for that, so we have to check each one separately.
2320 case CDO_USE_FFLAGS:
2321 case CDO_CHECK_TYPE:
2324 if (!CDROM_CAN(CDC_LOCK))
2328 return cdi->options;
2329 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2331 if (!CDROM_CAN(arg))
2334 cdi->options |= (int) arg;
2335 return cdi->options;
2338 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2341 cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2343 cdi->options &= ~(int) arg;
2344 return cdi->options;
2347 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2350 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2352 if (!CDROM_CAN(CDC_SELECT_SPEED))
2354 return cdi->ops->select_speed(cdi, arg);
2357 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2360 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2362 if (!CDROM_CAN(CDC_SELECT_DISC))
2365 if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2366 if ((int)arg >= cdi->capacity)
2371 * ->select_disc is a hook to allow a driver-specific way of
2372 * seleting disc. However, since there is no equivalent hook for
2373 * cdrom_slot_status this may not actually be useful...
2375 if (cdi->ops->select_disc)
2376 return cdi->ops->select_disc(cdi, arg);
2378 cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2379 return cdrom_select_disc(cdi, arg);
2382 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2383 struct block_device *bdev)
2385 cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2387 if (!capable(CAP_SYS_ADMIN))
2389 if (!CDROM_CAN(CDC_RESET))
2391 invalidate_bdev(bdev);
2392 return cdi->ops->reset(cdi);
2395 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2398 cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2400 if (!CDROM_CAN(CDC_LOCK))
2401 return -EDRIVE_CANT_DO_THIS;
2403 keeplocked = arg ? 1 : 0;
2406 * Don't unlock the door on multiple opens by default, but allow
2409 if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2411 return cdi->ops->lock_door(cdi, arg);
2414 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2417 cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2419 if (!capable(CAP_SYS_ADMIN))
2421 debug = arg ? 1 : 0;
2425 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2427 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2428 return (cdi->ops->capability & ~cdi->mask);
2432 * The following function is implemented, although very few audio
2433 * discs give Universal Product Code information, which should just be
2434 * the Medium Catalog Number on the box. Note, that the way the code
2435 * is written on the CD is /not/ uniform across all discs!
2437 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2440 struct cdrom_mcn mcn;
2443 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2445 if (!(cdi->ops->capability & CDC_MCN))
2447 ret = cdi->ops->get_mcn(cdi, &mcn);
2451 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2453 cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2457 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2460 cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2462 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2464 if (!CDROM_CAN(CDC_SELECT_DISC) ||
2465 (arg == CDSL_CURRENT || arg == CDSL_NONE))
2466 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2467 if (((int)arg >= cdi->capacity))
2469 return cdrom_slot_status(cdi, arg);
2473 * Ok, this is where problems start. The current interface for the
2474 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2475 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunatly, while this
2476 * is often the case, it is also very common for CDs to have some tracks
2477 * with data, and some tracks with audio. Just because I feel like it,
2478 * I declare the following to be the best way to cope. If the CD has ANY
2479 * data tracks on it, it will be returned as a data CD. If it has any XA
2480 * tracks, I will return it as that. Now I could simplify this interface
2481 * by combining these returns with the above, but this more clearly
2482 * demonstrates the problem with the current interface. Too bad this
2483 * wasn't designed to use bitmasks... -Erik
2485 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2486 * User level programmers might feel the ioctl is not very useful.
2489 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2493 cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2495 cdrom_count_tracks(cdi, &tracks);
2497 return tracks.error;
2499 /* Policy mode on */
2500 if (tracks.audio > 0) {
2501 if (!tracks.data && !tracks.cdi && !tracks.xa)
2511 if (tracks.data > 0)
2513 /* Policy mode off */
2515 cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2519 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2521 cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2522 return cdi->capacity;
2525 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2528 struct cdrom_subchnl q;
2532 /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2534 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2536 if (copy_from_user(&q, argp, sizeof(q)))
2539 requested = q.cdsc_format;
2540 if (requested != CDROM_MSF && requested != CDROM_LBA)
2542 q.cdsc_format = CDROM_MSF;
2544 ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2548 back = q.cdsc_format; /* local copy */
2549 sanitize_format(&q.cdsc_absaddr, &back, requested);
2550 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2552 if (copy_to_user(argp, &q, sizeof(q)))
2554 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2558 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2561 struct cdrom_tochdr header;
2564 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2566 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2568 if (copy_from_user(&header, argp, sizeof(header)))
2571 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2575 if (copy_to_user(argp, &header, sizeof(header)))
2577 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2581 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2584 struct cdrom_tocentry entry;
2585 u8 requested_format;
2588 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2590 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2592 if (copy_from_user(&entry, argp, sizeof(entry)))
2595 requested_format = entry.cdte_format;
2596 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2598 /* make interface to low-level uniform */
2599 entry.cdte_format = CDROM_MSF;
2600 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2603 sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2605 if (copy_to_user(argp, &entry, sizeof(entry)))
2607 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2611 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2614 struct cdrom_msf msf;
2616 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2618 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2620 if (copy_from_user(&msf, argp, sizeof(msf)))
2622 return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2625 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2631 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2633 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2635 if (copy_from_user(&ti, argp, sizeof(ti)))
2638 ret = check_for_audio_disc(cdi, cdi->ops);
2641 return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2643 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2646 struct cdrom_volctrl volume;
2648 cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2650 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2652 if (copy_from_user(&volume, argp, sizeof(volume)))
2654 return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2657 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2660 struct cdrom_volctrl volume;
2663 cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2665 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2668 ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2672 if (copy_to_user(argp, &volume, sizeof(volume)))
2677 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2682 cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2684 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2686 ret = check_for_audio_disc(cdi, cdi->ops);
2689 return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2693 * Just about every imaginable ioctl is supported in the Uniform layer
2695 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2697 int cdrom_ioctl(struct file * file, struct cdrom_device_info *cdi,
2698 struct inode *ip, unsigned int cmd, unsigned long arg)
2700 void __user *argp = (void __user *)arg;
2702 struct gendisk *disk = ip->i_bdev->bd_disk;
2705 * Try the generic SCSI command ioctl's first.
2707 ret = scsi_cmd_ioctl(file, disk->queue, disk, cmd, argp);
2712 case CDROMMULTISESSION:
2713 return cdrom_ioctl_multisession(cdi, argp);
2715 return cdrom_ioctl_eject(cdi);
2716 case CDROMCLOSETRAY:
2717 return cdrom_ioctl_closetray(cdi);
2719 return cdrom_ioctl_eject_sw(cdi, arg);
2720 case CDROM_MEDIA_CHANGED:
2721 return cdrom_ioctl_media_changed(cdi, arg);
2722 case CDROM_SET_OPTIONS:
2723 return cdrom_ioctl_set_options(cdi, arg);
2724 case CDROM_CLEAR_OPTIONS:
2725 return cdrom_ioctl_clear_options(cdi, arg);
2726 case CDROM_SELECT_SPEED:
2727 return cdrom_ioctl_select_speed(cdi, arg);
2728 case CDROM_SELECT_DISC:
2729 return cdrom_ioctl_select_disc(cdi, arg);
2731 return cdrom_ioctl_reset(cdi, ip->i_bdev);
2732 case CDROM_LOCKDOOR:
2733 return cdrom_ioctl_lock_door(cdi, arg);
2735 return cdrom_ioctl_debug(cdi, arg);
2736 case CDROM_GET_CAPABILITY:
2737 return cdrom_ioctl_get_capability(cdi);
2739 return cdrom_ioctl_get_mcn(cdi, argp);
2740 case CDROM_DRIVE_STATUS:
2741 return cdrom_ioctl_drive_status(cdi, arg);
2742 case CDROM_DISC_STATUS:
2743 return cdrom_ioctl_disc_status(cdi);
2744 case CDROM_CHANGER_NSLOTS:
2745 return cdrom_ioctl_changer_nslots(cdi);
2749 * Use the ioctls that are implemented through the generic_packet()
2750 * interface. this may look at bit funny, but if -ENOTTY is
2751 * returned that particular ioctl is not implemented and we
2752 * let it go through the device specific ones.
2754 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2755 ret = mmc_ioctl(cdi, cmd, arg);
2761 * Note: most of the cdinfo() calls are commented out here,
2762 * because they fill up the sys log when CD players poll
2767 return cdrom_ioctl_get_subchnl(cdi, argp);
2768 case CDROMREADTOCHDR:
2769 return cdrom_ioctl_read_tochdr(cdi, argp);
2770 case CDROMREADTOCENTRY:
2771 return cdrom_ioctl_read_tocentry(cdi, argp);
2773 return cdrom_ioctl_play_msf(cdi, argp);
2774 case CDROMPLAYTRKIND:
2775 return cdrom_ioctl_play_trkind(cdi, argp);
2777 return cdrom_ioctl_volctrl(cdi, argp);
2779 return cdrom_ioctl_volread(cdi, argp);
2784 return cdrom_ioctl_audioctl(cdi, cmd);
2791 int msf_to_lba(char m, char s, char f)
2793 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2797 * Required when we need to use READ_10 to issue other than 2048 block
2800 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2802 struct cdrom_device_ops *cdo = cdi->ops;
2803 struct packet_command cgc;
2804 struct modesel_head mh;
2806 memset(&mh, 0, sizeof(mh));
2807 mh.block_desc_length = 0x08;
2808 mh.block_length_med = (size >> 8) & 0xff;
2809 mh.block_length_lo = size & 0xff;
2811 memset(&cgc, 0, sizeof(cgc));
2813 cgc.cmd[1] = 1 << 4;
2815 cgc.buflen = sizeof(mh);
2816 cgc.buffer = (char *) &mh;
2817 cgc.data_direction = CGC_DATA_WRITE;
2818 mh.block_desc_length = 0x08;
2819 mh.block_length_med = (size >> 8) & 0xff;
2820 mh.block_length_lo = size & 0xff;
2822 return cdo->generic_packet(cdi, &cgc);
2825 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
2828 struct cdrom_device_ops *cdo = cdi->ops;
2829 struct packet_command cgc;
2830 struct request_sense sense;
2831 unsigned char buffer[32];
2834 memset(&cgc, 0, sizeof(cgc));
2836 /* build a unified command and queue it through
2837 cdo->generic_packet() */
2840 case CDROMREADMODE1:
2841 case CDROMREADMODE2: {
2842 struct cdrom_msf msf;
2843 int blocksize = 0, format = 0, lba;
2847 blocksize = CD_FRAMESIZE_RAW;
2849 case CDROMREADMODE1:
2850 blocksize = CD_FRAMESIZE;
2853 case CDROMREADMODE2:
2854 blocksize = CD_FRAMESIZE_RAW0;
2857 IOCTL_IN(arg, struct cdrom_msf, msf);
2858 lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
2859 /* FIXME: we need upper bound checking, too!! */
2862 cgc.buffer = kmalloc(blocksize, GFP_KERNEL);
2863 if (cgc.buffer == NULL)
2865 memset(&sense, 0, sizeof(sense));
2867 cgc.data_direction = CGC_DATA_READ;
2868 ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
2869 if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) {
2871 * SCSI-II devices are not required to support
2872 * READ_CD, so let's try switching block size
2874 /* FIXME: switch back again... */
2875 if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
2880 ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
2881 ret |= cdrom_switch_blocksize(cdi, blocksize);
2883 if (!ret && copy_to_user((char __user *)arg, cgc.buffer, blocksize))
2888 case CDROMREADAUDIO: {
2889 struct cdrom_read_audio ra;
2892 IOCTL_IN(arg, struct cdrom_read_audio, ra);
2894 if (ra.addr_format == CDROM_MSF)
2895 lba = msf_to_lba(ra.addr.msf.minute,
2898 else if (ra.addr_format == CDROM_LBA)
2903 /* FIXME: we need upper bound checking, too!! */
2904 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2907 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2909 case CDROMSUBCHNL: {
2910 struct cdrom_subchnl q;
2911 u_char requested, back;
2912 IOCTL_IN(arg, struct cdrom_subchnl, q);
2913 requested = q.cdsc_format;
2914 if (!((requested == CDROM_MSF) ||
2915 (requested == CDROM_LBA)))
2917 q.cdsc_format = CDROM_MSF;
2918 if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
2920 back = q.cdsc_format; /* local copy */
2921 sanitize_format(&q.cdsc_absaddr, &back, requested);
2922 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2923 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2924 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2927 case CDROMPLAYMSF: {
2928 struct cdrom_msf msf;
2929 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2930 IOCTL_IN(arg, struct cdrom_msf, msf);
2931 cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2932 cgc.cmd[3] = msf.cdmsf_min0;
2933 cgc.cmd[4] = msf.cdmsf_sec0;
2934 cgc.cmd[5] = msf.cdmsf_frame0;
2935 cgc.cmd[6] = msf.cdmsf_min1;
2936 cgc.cmd[7] = msf.cdmsf_sec1;
2937 cgc.cmd[8] = msf.cdmsf_frame1;
2938 cgc.data_direction = CGC_DATA_NONE;
2939 return cdo->generic_packet(cdi, &cgc);
2941 case CDROMPLAYBLK: {
2942 struct cdrom_blk blk;
2943 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2944 IOCTL_IN(arg, struct cdrom_blk, blk);
2945 cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
2946 cgc.cmd[2] = (blk.from >> 24) & 0xff;
2947 cgc.cmd[3] = (blk.from >> 16) & 0xff;
2948 cgc.cmd[4] = (blk.from >> 8) & 0xff;
2949 cgc.cmd[5] = blk.from & 0xff;
2950 cgc.cmd[7] = (blk.len >> 8) & 0xff;
2951 cgc.cmd[8] = blk.len & 0xff;
2952 cgc.data_direction = CGC_DATA_NONE;
2953 return cdo->generic_packet(cdi, &cgc);
2956 case CDROMVOLREAD: {
2957 struct cdrom_volctrl volctrl;
2958 char mask[sizeof(buffer)];
2959 unsigned short offset;
2961 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
2963 IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
2965 cgc.buffer = buffer;
2967 if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
2970 /* originally the code depended on buffer[1] to determine
2971 how much data is available for transfer. buffer[1] is
2972 unfortunately ambigious and the only reliable way seem
2973 to be to simply skip over the block descriptor... */
2974 offset = 8 + be16_to_cpu(*(__be16 *)(buffer+6));
2976 if (offset + 16 > sizeof(buffer))
2979 if (offset + 16 > cgc.buflen) {
2980 cgc.buflen = offset+16;
2981 ret = cdrom_mode_sense(cdi, &cgc,
2982 GPMODE_AUDIO_CTL_PAGE, 0);
2988 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
2989 buffer[offset+1] < 14)
2992 /* now we have the current volume settings. if it was only
2993 a CDROMVOLREAD, return these values */
2994 if (cmd == CDROMVOLREAD) {
2995 volctrl.channel0 = buffer[offset+9];
2996 volctrl.channel1 = buffer[offset+11];
2997 volctrl.channel2 = buffer[offset+13];
2998 volctrl.channel3 = buffer[offset+15];
2999 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
3003 /* get the volume mask */
3005 if ((ret = cdrom_mode_sense(cdi, &cgc,
3006 GPMODE_AUDIO_CTL_PAGE, 1)))
3009 buffer[offset+9] = volctrl.channel0 & mask[offset+9];
3010 buffer[offset+11] = volctrl.channel1 & mask[offset+11];
3011 buffer[offset+13] = volctrl.channel2 & mask[offset+13];
3012 buffer[offset+15] = volctrl.channel3 & mask[offset+15];
3015 cgc.buffer = buffer + offset - 8;
3016 memset(cgc.buffer, 0, 8);
3017 return cdrom_mode_select(cdi, &cgc);
3022 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3023 cgc.cmd[0] = GPCMD_START_STOP_UNIT;
3025 cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3026 cgc.data_direction = CGC_DATA_NONE;
3027 return cdo->generic_packet(cdi, &cgc);
3032 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3033 cgc.cmd[0] = GPCMD_PAUSE_RESUME;
3034 cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3035 cgc.data_direction = CGC_DATA_NONE;
3036 return cdo->generic_packet(cdi, &cgc);
3039 case DVD_READ_STRUCT: {
3041 int size = sizeof(dvd_struct);
3042 if (!CDROM_CAN(CDC_DVD))
3044 if ((s = kmalloc(size, GFP_KERNEL)) == NULL)
3046 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3047 if (copy_from_user(s, (dvd_struct __user *)arg, size)) {
3051 if ((ret = dvd_read_struct(cdi, s))) {
3055 if (copy_to_user((dvd_struct __user *)arg, s, size))
3063 if (!CDROM_CAN(CDC_DVD))
3065 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
3066 IOCTL_IN(arg, dvd_authinfo, ai);
3067 if ((ret = dvd_do_auth (cdi, &ai)))
3069 IOCTL_OUT(arg, dvd_authinfo, ai);
3073 case CDROM_NEXT_WRITABLE: {
3075 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3076 if ((ret = cdrom_get_next_writable(cdi, &next)))
3078 IOCTL_OUT(arg, long, next);
3081 case CDROM_LAST_WRITTEN: {
3083 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3084 if ((ret = cdrom_get_last_written(cdi, &last)))
3086 IOCTL_OUT(arg, long, last);
3094 static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
3095 track_information *ti)
3097 struct cdrom_device_ops *cdo = cdi->ops;
3098 struct packet_command cgc;
3101 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3102 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3103 cgc.cmd[1] = type & 3;
3104 cgc.cmd[4] = (track & 0xff00) >> 8;
3105 cgc.cmd[5] = track & 0xff;
3109 if ((ret = cdo->generic_packet(cdi, &cgc)))
3112 buflen = be16_to_cpu(ti->track_information_length) +
3113 sizeof(ti->track_information_length);
3115 if (buflen > sizeof(track_information))
3116 buflen = sizeof(track_information);
3118 cgc.cmd[8] = cgc.buflen = buflen;
3119 if ((ret = cdo->generic_packet(cdi, &cgc)))
3122 /* return actual fill size */
3126 /* requires CD R/RW */
3127 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3129 struct cdrom_device_ops *cdo = cdi->ops;
3130 struct packet_command cgc;
3133 /* set up command and get the disc info */
3134 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3135 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3136 cgc.cmd[8] = cgc.buflen = 2;
3139 if ((ret = cdo->generic_packet(cdi, &cgc)))
3142 /* not all drives have the same disc_info length, so requeue
3143 * packet with the length the drive tells us it can supply
3145 buflen = be16_to_cpu(di->disc_information_length) +
3146 sizeof(di->disc_information_length);
3148 if (buflen > sizeof(disc_information))
3149 buflen = sizeof(disc_information);
3151 cgc.cmd[8] = cgc.buflen = buflen;
3152 if ((ret = cdo->generic_packet(cdi, &cgc)))
3155 /* return actual fill size */
3159 /* return the last written block on the CD-R media. this is for the udf
3161 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
3163 struct cdrom_tocentry toc;
3164 disc_information di;
3165 track_information ti;
3167 int ret = -1, ti_size;
3169 if (!CDROM_CAN(CDC_GENERIC_PACKET))
3172 ret = cdrom_get_disc_info(cdi, &di);
3173 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
3174 + sizeof(di.last_track_lsb)))
3177 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3178 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3179 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3180 if (ti_size < (int)offsetof(typeof(ti), track_start))
3183 /* if this track is blank, try the previous. */
3188 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3191 if (ti_size < (int)(offsetof(typeof(ti), track_size)
3192 + sizeof(ti.track_size)))
3195 /* if last recorded field is valid, return it. */
3196 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3197 + sizeof(ti.last_rec_address))) {
3198 *last_written = be32_to_cpu(ti.last_rec_address);
3200 /* make it up instead */
3201 *last_written = be32_to_cpu(ti.track_start) +
3202 be32_to_cpu(ti.track_size);
3204 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3208 /* this is where we end up if the drive either can't do a
3209 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3210 it doesn't give enough information or fails. then we return
3211 the toc contents. */
3213 toc.cdte_format = CDROM_MSF;
3214 toc.cdte_track = CDROM_LEADOUT;
3215 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
3217 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
3218 *last_written = toc.cdte_addr.lba;
3222 /* return the next writable block. also for udf file system. */
3223 static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3225 disc_information di;
3226 track_information ti;
3230 if (!CDROM_CAN(CDC_GENERIC_PACKET))
3231 goto use_last_written;
3233 ret = cdrom_get_disc_info(cdi, &di);
3234 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3235 + sizeof(di.last_track_lsb))
3236 goto use_last_written;
3238 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3239 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3240 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3241 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3242 goto use_last_written;
3244 /* if this track is blank, try the previous. */
3246 if (last_track == 1)
3247 goto use_last_written;
3249 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3251 goto use_last_written;
3254 /* if next recordable address field is valid, use it. */
3255 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
3256 + sizeof(ti.next_writable)) {
3257 *next_writable = be32_to_cpu(ti.next_writable);
3262 if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3266 *next_writable += 7;
3271 EXPORT_SYMBOL(cdrom_get_last_written);
3272 EXPORT_SYMBOL(register_cdrom);
3273 EXPORT_SYMBOL(unregister_cdrom);
3274 EXPORT_SYMBOL(cdrom_open);
3275 EXPORT_SYMBOL(cdrom_release);
3276 EXPORT_SYMBOL(cdrom_ioctl);
3277 EXPORT_SYMBOL(cdrom_media_changed);
3278 EXPORT_SYMBOL(cdrom_number_of_slots);
3279 EXPORT_SYMBOL(cdrom_mode_select);
3280 EXPORT_SYMBOL(cdrom_mode_sense);
3281 EXPORT_SYMBOL(init_cdrom_command);
3282 EXPORT_SYMBOL(cdrom_get_media_event);
3284 #ifdef CONFIG_SYSCTL
3286 #define CDROM_STR_SIZE 1000
3288 static struct cdrom_sysctl_settings {
3289 char info[CDROM_STR_SIZE]; /* general info */
3290 int autoclose; /* close tray upon mount, etc */
3291 int autoeject; /* eject on umount */
3292 int debug; /* turn on debugging messages */
3293 int lock; /* lock the door on device open */
3294 int check; /* check media type */
3295 } cdrom_sysctl_settings;
3297 enum cdrom_print_option {
3304 static int cdrom_print_info(const char *header, int val, char *info,
3305 int *pos, enum cdrom_print_option option)
3307 const int max_size = sizeof(cdrom_sysctl_settings.info);
3308 struct cdrom_device_info *cdi;
3311 ret = scnprintf(info + *pos, max_size - *pos, header);
3317 for (cdi = topCdromPtr; cdi; cdi = cdi->next) {
3320 ret = scnprintf(info + *pos, max_size - *pos,
3324 ret = scnprintf(info + *pos, max_size - *pos,
3325 "\t%d", cdi->speed);
3328 ret = scnprintf(info + *pos, max_size - *pos,
3329 "\t%d", cdi->capacity);
3331 case CTL_CAPABILITY:
3332 ret = scnprintf(info + *pos, max_size - *pos,
3333 "\t%d", CDROM_CAN(val) != 0);
3336 printk(KERN_INFO "cdrom: invalid option%d\n", option);
3347 static int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
3348 void __user *buffer, size_t *lenp, loff_t *ppos)
3351 char *info = cdrom_sysctl_settings.info;
3352 const int max_size = sizeof(cdrom_sysctl_settings.info);
3354 if (!*lenp || (*ppos && !write)) {
3359 mutex_lock(&cdrom_mutex);
3361 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3363 if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3365 if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3367 if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3369 if (cdrom_print_info("\nCan close tray:\t",
3370 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3372 if (cdrom_print_info("\nCan open tray:\t",
3373 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3375 if (cdrom_print_info("\nCan lock tray:\t",
3376 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3378 if (cdrom_print_info("\nCan change speed:",
3379 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3381 if (cdrom_print_info("\nCan select disk:",
3382 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3384 if (cdrom_print_info("\nCan read multisession:",
3385 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3387 if (cdrom_print_info("\nCan read MCN:\t",
3388 CDC_MCN, info, &pos, CTL_CAPABILITY))
3390 if (cdrom_print_info("\nReports media changed:",
3391 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3393 if (cdrom_print_info("\nCan play audio:\t",
3394 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3396 if (cdrom_print_info("\nCan write CD-R:\t",
3397 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3399 if (cdrom_print_info("\nCan write CD-RW:",
3400 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3402 if (cdrom_print_info("\nCan read DVD:\t",
3403 CDC_DVD, info, &pos, CTL_CAPABILITY))
3405 if (cdrom_print_info("\nCan write DVD-R:",
3406 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3408 if (cdrom_print_info("\nCan write DVD-RAM:",
3409 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3411 if (cdrom_print_info("\nCan read MRW:\t",
3412 CDC_MRW, info, &pos, CTL_CAPABILITY))
3414 if (cdrom_print_info("\nCan write MRW:\t",
3415 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3417 if (cdrom_print_info("\nCan write RAM:\t",
3418 CDC_RAM, info, &pos, CTL_CAPABILITY))
3420 if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3423 mutex_unlock(&cdrom_mutex);
3424 return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
3426 printk(KERN_INFO "cdrom: info buffer too small\n");
3430 /* Unfortunately, per device settings are not implemented through
3431 procfs/sysctl yet. When they are, this will naturally disappear. For now
3432 just update all drives. Later this will become the template on which
3433 new registered drives will be based. */
3434 static void cdrom_update_settings(void)
3436 struct cdrom_device_info *cdi;
3438 for (cdi = topCdromPtr; cdi != NULL; cdi = cdi->next) {
3439 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3440 cdi->options |= CDO_AUTO_CLOSE;
3441 else if (!autoclose)
3442 cdi->options &= ~CDO_AUTO_CLOSE;
3443 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3444 cdi->options |= CDO_AUTO_EJECT;
3445 else if (!autoeject)
3446 cdi->options &= ~CDO_AUTO_EJECT;
3447 if (lockdoor && CDROM_CAN(CDC_LOCK))
3448 cdi->options |= CDO_LOCK;
3450 cdi->options &= ~CDO_LOCK;
3451 if (check_media_type)
3452 cdi->options |= CDO_CHECK_TYPE;
3454 cdi->options &= ~CDO_CHECK_TYPE;
3458 static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
3459 void __user *buffer, size_t *lenp, loff_t *ppos)
3463 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
3467 /* we only care for 1 or 0. */
3468 autoclose = !!cdrom_sysctl_settings.autoclose;
3469 autoeject = !!cdrom_sysctl_settings.autoeject;
3470 debug = !!cdrom_sysctl_settings.debug;
3471 lockdoor = !!cdrom_sysctl_settings.lock;
3472 check_media_type = !!cdrom_sysctl_settings.check;
3474 /* update the option flags according to the changes. we
3475 don't have per device options through sysctl yet,
3476 but we will have and then this will disappear. */
3477 cdrom_update_settings();
3483 /* Place files in /proc/sys/dev/cdrom */
3484 static ctl_table cdrom_table[] = {
3487 .data = &cdrom_sysctl_settings.info,
3488 .maxlen = CDROM_STR_SIZE,
3490 .proc_handler = &cdrom_sysctl_info,
3493 .procname = "autoclose",
3494 .data = &cdrom_sysctl_settings.autoclose,
3495 .maxlen = sizeof(int),
3497 .proc_handler = &cdrom_sysctl_handler,
3500 .procname = "autoeject",
3501 .data = &cdrom_sysctl_settings.autoeject,
3502 .maxlen = sizeof(int),
3504 .proc_handler = &cdrom_sysctl_handler,
3507 .procname = "debug",
3508 .data = &cdrom_sysctl_settings.debug,
3509 .maxlen = sizeof(int),
3511 .proc_handler = &cdrom_sysctl_handler,
3515 .data = &cdrom_sysctl_settings.lock,
3516 .maxlen = sizeof(int),
3518 .proc_handler = &cdrom_sysctl_handler,
3521 .procname = "check_media",
3522 .data = &cdrom_sysctl_settings.check,
3523 .maxlen = sizeof(int),
3525 .proc_handler = &cdrom_sysctl_handler
3530 static ctl_table cdrom_cdrom_table[] = {
3532 .ctl_name = DEV_CDROM,
3533 .procname = "cdrom",
3536 .child = cdrom_table,
3541 /* Make sure that /proc/sys/dev is there */
3542 static ctl_table cdrom_root_table[] = {
3544 .ctl_name = CTL_DEV,
3548 .child = cdrom_cdrom_table,
3552 static struct ctl_table_header *cdrom_sysctl_header;
3554 static void cdrom_sysctl_register(void)
3556 static int initialized;
3558 if (initialized == 1)
3561 cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3563 /* set the defaults */
3564 cdrom_sysctl_settings.autoclose = autoclose;
3565 cdrom_sysctl_settings.autoeject = autoeject;
3566 cdrom_sysctl_settings.debug = debug;
3567 cdrom_sysctl_settings.lock = lockdoor;
3568 cdrom_sysctl_settings.check = check_media_type;
3573 static void cdrom_sysctl_unregister(void)
3575 if (cdrom_sysctl_header)
3576 unregister_sysctl_table(cdrom_sysctl_header);
3579 #endif /* CONFIG_SYSCTL */
3581 static int __init cdrom_init(void)
3583 #ifdef CONFIG_SYSCTL
3584 cdrom_sysctl_register();
3589 static void __exit cdrom_exit(void)
3591 printk(KERN_INFO "Uniform CD-ROM driver unloaded\n");
3592 #ifdef CONFIG_SYSCTL
3593 cdrom_sysctl_unregister();
3597 module_init(cdrom_init);
3598 module_exit(cdrom_exit);
3599 MODULE_LICENSE("GPL");
projects / linux-2.6 / blob