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 -------------------------------------------------------------------------*/
239 #define REVISION "Revision: 3.20"
240 #define VERSION "Id: cdrom.c 3.20 2003/12/17"
242 /* I use an error-log mask to give fine grain control over the type of
243 messages dumped to the system logs. The available masks include: */
244 #define CD_NOTHING 0x0
245 #define CD_WARNING 0x1
246 #define CD_REG_UNREG 0x2
247 #define CD_DO_IOCTL 0x4
249 #define CD_CLOSE 0x10
250 #define CD_COUNT_TRACKS 0x20
251 #define CD_CHANGER 0x40
254 /* Define this to remove _all_ the debugging messages */
255 /* #define ERRLOGMASK CD_NOTHING */
256 #define ERRLOGMASK CD_WARNING
257 /* #define ERRLOGMASK (CD_WARNING|CD_OPEN|CD_COUNT_TRACKS|CD_CLOSE) */
258 /* #define ERRLOGMASK (CD_WARNING|CD_REG_UNREG|CD_DO_IOCTL|CD_OPEN|CD_CLOSE|CD_COUNT_TRACKS) */
260 #include <linux/config.h>
261 #include <linux/module.h>
262 #include <linux/fs.h>
263 #include <linux/buffer_head.h>
264 #include <linux/major.h>
265 #include <linux/types.h>
266 #include <linux/errno.h>
267 #include <linux/kernel.h>
268 #include <linux/mm.h>
269 #include <linux/slab.h>
270 #include <linux/cdrom.h>
271 #include <linux/sysctl.h>
272 #include <linux/proc_fs.h>
273 #include <linux/blkpg.h>
274 #include <linux/init.h>
275 #include <linux/fcntl.h>
276 #include <linux/blkdev.h>
277 #include <linux/times.h>
279 #include <asm/uaccess.h>
281 /* used to tell the module to turn on full debugging messages */
283 /* used to keep tray locked at all times */
284 static int keeplocked;
285 /* default compatibility mode */
286 static int autoclose=1;
287 static int autoeject;
288 static int lockdoor = 1;
289 /* will we ever get to use this... sigh. */
290 static int check_media_type;
291 /* automatically restart mrw format */
292 static int mrw_format_restart = 1;
293 MODULE_PARM(debug, "i");
294 MODULE_PARM(autoclose, "i");
295 MODULE_PARM(autoeject, "i");
296 MODULE_PARM(lockdoor, "i");
297 MODULE_PARM(check_media_type, "i");
298 MODULE_PARM(mrw_format_restart, "i");
300 static spinlock_t cdrom_lock = SPIN_LOCK_UNLOCKED;
302 static const char *mrw_format_status[] = {
309 static const char *mrw_address_space[] = { "DMA", "GAA" };
311 #if (ERRLOGMASK!=CD_NOTHING)
312 #define cdinfo(type, fmt, args...) \
313 if ((ERRLOGMASK & type) || debug==1 ) \
314 printk(KERN_INFO "cdrom: " fmt, ## args)
316 #define cdinfo(type, fmt, args...)
319 /* These are used to simplify getting data in from and back to user land */
320 #define IOCTL_IN(arg, type, in) \
321 if (copy_from_user(&(in), (type *) (arg), sizeof (in))) \
324 #define IOCTL_OUT(arg, type, out) \
325 if (copy_to_user((type *) (arg), &(out), sizeof (out))) \
328 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
329 a lot of places. This macro makes the code more clear. */
330 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
332 /* used in the audio ioctls */
333 #define CHECKAUDIO if ((ret=check_for_audio_disc(cdi, cdo))) return ret
335 /* Not-exported routines. */
336 static int open_for_data(struct cdrom_device_info * cdi);
337 static int check_for_audio_disc(struct cdrom_device_info * cdi,
338 struct cdrom_device_ops * cdo);
339 static void sanitize_format(union cdrom_addr *addr,
340 u_char * curr, u_char requested);
341 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
344 int cdrom_get_last_written(struct cdrom_device_info *, long *);
345 static int cdrom_get_next_writable(struct cdrom_device_info *, long *);
346 static void cdrom_count_tracks(struct cdrom_device_info *, tracktype*);
348 static int cdrom_mrw_exit(struct cdrom_device_info *cdi);
350 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di);
353 static void cdrom_sysctl_register(void);
354 #endif /* CONFIG_SYSCTL */
355 static struct cdrom_device_info *topCdromPtr;
357 /* This macro makes sure we don't have to check on cdrom_device_ops
358 * existence in the run-time routines below. Change_capability is a
359 * hack to have the capability flags defined const, while we can still
360 * change it here without gcc complaining at every line.
362 #define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
364 int register_cdrom(struct cdrom_device_info *cdi)
366 static char banner_printed;
367 struct cdrom_device_ops *cdo = cdi->ops;
368 int *change_capability = (int *)&cdo->capability; /* hack */
370 cdinfo(CD_OPEN, "entering register_cdrom\n");
372 if (cdo->open == NULL || cdo->release == NULL)
374 if (!banner_printed) {
375 printk(KERN_INFO "Uniform CD-ROM driver " REVISION "\n");
378 cdrom_sysctl_register();
379 #endif /* CONFIG_SYSCTL */
382 ENSURE(drive_status, CDC_DRIVE_STATUS );
383 ENSURE(media_changed, CDC_MEDIA_CHANGED);
384 ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
385 ENSURE(lock_door, CDC_LOCK);
386 ENSURE(select_speed, CDC_SELECT_SPEED);
387 ENSURE(get_last_session, CDC_MULTI_SESSION);
388 ENSURE(get_mcn, CDC_MCN);
389 ENSURE(reset, CDC_RESET);
390 ENSURE(audio_ioctl, CDC_PLAY_AUDIO);
391 ENSURE(dev_ioctl, CDC_IOCTLS);
392 ENSURE(generic_packet, CDC_GENERIC_PACKET);
395 cdi->options = CDO_USE_FFLAGS;
397 if (autoclose==1 && CDROM_CAN(CDC_CLOSE_TRAY))
398 cdi->options |= (int) CDO_AUTO_CLOSE;
399 if (autoeject==1 && CDROM_CAN(CDC_OPEN_TRAY))
400 cdi->options |= (int) CDO_AUTO_EJECT;
402 cdi->options |= (int) CDO_LOCK;
403 if (check_media_type==1)
404 cdi->options |= (int) CDO_CHECK_TYPE;
406 if (CDROM_CAN(CDC_MRW_W))
407 cdi->exit = cdrom_mrw_exit;
410 cdi->cdda_method = CDDA_BPC_FULL;
412 cdi->cdda_method = CDDA_OLD;
414 cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
415 spin_lock(&cdrom_lock);
416 cdi->next = topCdromPtr;
418 spin_unlock(&cdrom_lock);
423 int unregister_cdrom(struct cdrom_device_info *unreg)
425 struct cdrom_device_info *cdi, *prev;
426 cdinfo(CD_OPEN, "entering unregister_cdrom\n");
429 spin_lock(&cdrom_lock);
431 while (cdi && cdi != unreg) {
437 spin_unlock(&cdrom_lock);
441 prev->next = cdi->next;
443 topCdromPtr = cdi->next;
445 spin_unlock(&cdrom_lock);
450 cdi->ops->n_minors--;
451 cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
455 int cdrom_get_media_event(struct cdrom_device_info *cdi,
456 struct media_event_desc *med)
458 struct cdrom_generic_command cgc;
459 unsigned char buffer[8];
460 struct event_header *eh = (struct event_header *) buffer;
462 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
463 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
464 cgc.cmd[1] = 1; /* IMMED */
465 cgc.cmd[4] = 1 << 4; /* media event */
466 cgc.cmd[8] = sizeof(buffer);
469 if (cdi->ops->generic_packet(cdi, &cgc))
472 if (be16_to_cpu(eh->data_len) < sizeof(*med))
475 memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
480 * the first prototypes used 0x2c as the page code for the mrw mode page,
481 * subsequently this was changed to 0x03. probe the one used by this drive
483 int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
485 struct cdrom_generic_command cgc;
488 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
493 if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
494 cdi->mrw_mode_page = MRW_MODE_PC;
496 } else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
497 cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
504 int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
506 struct cdrom_generic_command cgc;
507 struct mrw_feature_desc *mfd;
508 unsigned char buffer[16];
511 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
513 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
514 cgc.cmd[3] = CDF_MRW;
515 cgc.cmd[8] = sizeof(buffer);
518 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
521 mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
524 if ((ret = cdrom_mrw_probe_pc(cdi)))
530 static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
532 struct cdrom_generic_command cgc;
533 unsigned char buffer[12];
536 printk(KERN_INFO "cdrom: %sstarting format\n", cont ? "Re" : "");
539 * FmtData bit set (bit 4), format type is 1
541 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
542 cgc.cmd[0] = GPCMD_FORMAT_UNIT;
543 cgc.cmd[1] = (1 << 4) | 1;
545 cgc.timeout = 5 * 60 * HZ;
548 * 4 byte format list header, 8 byte format list descriptor
561 buffer[8] = 0x24 << 2;
564 ret = cdi->ops->generic_packet(cdi, &cgc);
566 printk(KERN_INFO "cdrom: bgformat failed\n");
571 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
573 struct cdrom_generic_command cgc;
575 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
576 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
579 * Session = 1, Track = 0
581 cgc.cmd[1] = !!immed;
584 cgc.timeout = 5 * 60 * HZ;
586 return cdi->ops->generic_packet(cdi, &cgc);
589 static int cdrom_flush_cache(struct cdrom_device_info *cdi)
591 struct cdrom_generic_command cgc;
593 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
594 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
596 cgc.timeout = 5 * 60 * HZ;
598 return cdi->ops->generic_packet(cdi, &cgc);
601 static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
606 if (cdrom_get_disc_info(cdi, &di))
609 if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
610 printk(KERN_INFO "cdrom: issuing MRW back ground format suspend\n");
611 ret = cdrom_mrw_bgformat_susp(cdi, 0);
615 ret = cdrom_flush_cache(cdi);
620 static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
622 struct cdrom_generic_command cgc;
623 struct mode_page_header *mph;
625 int ret, offset, size;
627 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
630 cgc.buflen = sizeof(buffer);
632 if ((ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0)))
635 mph = (struct mode_page_header *) buffer;
636 offset = be16_to_cpu(mph->desc_length);
637 size = be16_to_cpu(mph->mode_data_length) + 2;
639 buffer[offset + 3] = space;
642 if ((ret = cdrom_mode_select(cdi, &cgc)))
645 printk(KERN_INFO "cdrom: %s: mrw address space %s selected\n", cdi->name, mrw_address_space[space]);
649 int cdrom_get_random_writable(struct cdrom_device_info *cdi,
650 struct rwrt_feature_desc *rfd)
652 struct cdrom_generic_command cgc;
654 struct feature_header *fh;
657 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
659 cgc.cmd[0] = GPCMD_GET_CONFIGURATION; /* often 0x46 */
660 cgc.cmd[3] = CDF_RWRT; /* often 0x0020 */
661 cgc.cmd[8] = sizeof(buffer); /* often 0x18 */
664 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
667 fh = (struct feature_header *)&buffer[0];
668 if (be32_to_cpu(fh->data_len) >= (sizeof(struct feature_header)+
669 sizeof(struct rwrt_feature_desc)))
670 memcpy(rfd, &buffer[sizeof(struct feature_header)],
673 memset(rfd, 0, sizeof(*rfd));
678 int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
680 struct cdrom_generic_command cgc;
682 struct feature_header *fh;
686 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
688 cgc.cmd[0] = GPCMD_GET_CONFIGURATION; /* often 0x46 */
689 cgc.cmd[3] = CDF_HWDM; /* often 0x0024 */
690 cgc.cmd[8] = sizeof(buffer); /* often 0x10 */
693 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
696 fh = (struct feature_header *)&buffer[0];
698 if (be32_to_cpu(fh->data_len) >= (sizeof(struct feature_header)+8)) {
699 feature_code = (__u16 *)&buffer[sizeof(struct feature_header)];
700 if (CDF_HWDM == be16_to_cpu(*feature_code))
707 int cdrom_is_random_writable(struct cdrom_device_info *cdi, int *write)
709 struct rwrt_feature_desc rfd;
714 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
717 if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
723 static int cdrom_media_erasable(struct cdrom_device_info *cdi)
727 if (cdrom_get_disc_info(cdi, &di))
734 * FIXME: check RO bit
736 static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
738 int ret = cdrom_media_erasable(cdi);
741 * allow writable open if media info read worked and media is
742 * erasable, _or_ if it fails since not all drives support it
750 static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
756 * always reset to DMA lba space on open
758 if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_DMA)) {
759 printk(KERN_ERR "cdrom: failed setting lba address space\n");
763 if (cdrom_get_disc_info(cdi, &di))
771 * 0 - not MRW formatted
772 * 1 - MRW bgformat started, but not running or complete
773 * 2 - MRW bgformat in progress
774 * 3 - MRW formatting complete
777 printk(KERN_INFO "cdrom open: mrw_status '%s'\n", mrw_format_status[di.mrw_status]);
780 else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE && mrw_format_restart)
781 ret = cdrom_mrw_bgformat(cdi, 1);
786 static int mo_open_write(struct cdrom_device_info *cdi)
788 struct cdrom_generic_command cgc;
792 init_cdrom_command(&cgc, &buffer, 4, CGC_DATA_READ);
796 * obtain write protect information as per
797 * drivers/scsi/sd.c:sd_read_write_protect_flag
800 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
802 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_VENDOR_PAGE, 0);
805 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
808 /* drive gave us no info, let the user go ahead */
812 return buffer[3] & 0x80;
815 static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
817 struct rwrt_feature_desc rfd;
820 if ((ret = cdrom_has_defect_mgt(cdi)))
823 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
825 else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
828 cdinfo(CD_OPEN, "can open for random write\n");
833 * returns 0 for ok to open write, non-0 to disallow
835 static int cdrom_open_write(struct cdrom_device_info *cdi)
839 if (CDROM_CAN(CDC_MRW_W))
840 ret = cdrom_mrw_open_write(cdi);
841 else if (CDROM_CAN(CDC_DVD_RAM))
842 ret = cdrom_dvdram_open_write(cdi);
843 else if (CDROM_CAN(CDC_RAM) &&
844 !CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW))
845 ret = cdrom_ram_open_write(cdi);
846 else if (CDROM_CAN(CDC_MO_DRIVE))
847 ret = mo_open_write(cdi);
852 static int cdrom_close_write(struct cdrom_device_info *cdi)
855 return cdrom_flush_cache(cdi);
861 /* We use the open-option O_NONBLOCK to indicate that the
862 * purpose of opening is only for subsequent ioctl() calls; no device
863 * integrity checks are performed.
865 * We hope that all cd-player programs will adopt this convention. It
866 * is in their own interest: device control becomes a lot easier
869 int cdrom_open(struct cdrom_device_info *cdi, struct inode *ip, struct file *fp)
873 cdinfo(CD_OPEN, "entering cdrom_open\n");
875 /* if this was a O_NONBLOCK open and we should honor the flags,
876 * do a quick open without drive/disc integrity checks. */
878 if ((fp->f_flags & O_NONBLOCK) && (cdi->options & CDO_USE_FFLAGS)) {
879 ret = cdi->ops->open(cdi, 1);
881 if (fp->f_mode & FMODE_WRITE) {
883 if (!CDROM_CAN(CDC_RAM))
885 if (cdrom_open_write(cdi))
888 ret = open_for_data(cdi);
894 cdinfo(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
895 cdi->name, cdi->use_count);
896 /* Do this on open. Don't wait for mount, because they might
897 not be mounting, but opening with O_NONBLOCK */
898 check_disk_change(ip->i_bdev);
906 int open_for_data(struct cdrom_device_info * cdi)
909 struct cdrom_device_ops *cdo = cdi->ops;
911 cdinfo(CD_OPEN, "entering open_for_data\n");
912 /* Check if the driver can report drive status. If it can, we
913 can do clever things. If it can't, well, we at least tried! */
914 if (cdo->drive_status != NULL) {
915 ret = cdo->drive_status(cdi, CDSL_CURRENT);
916 cdinfo(CD_OPEN, "drive_status=%d\n", ret);
917 if (ret == CDS_TRAY_OPEN) {
918 cdinfo(CD_OPEN, "the tray is open...\n");
919 /* can/may i close it? */
920 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
921 cdi->options & CDO_AUTO_CLOSE) {
922 cdinfo(CD_OPEN, "trying to close the tray.\n");
923 ret=cdo->tray_move(cdi,0);
925 cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.\n");
926 /* Ignore the error from the low
927 level driver. We don't care why it
928 couldn't close the tray. We only care
929 that there is no disc in the drive,
930 since that is the _REAL_ problem here.*/
932 goto clean_up_and_return;
935 cdinfo(CD_OPEN, "bummer. this drive can't close the tray.\n");
937 goto clean_up_and_return;
939 /* Ok, the door should be closed now.. Check again */
940 ret = cdo->drive_status(cdi, CDSL_CURRENT);
941 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
942 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
943 cdinfo(CD_OPEN, "tray might not contain a medium.\n");
945 goto clean_up_and_return;
947 cdinfo(CD_OPEN, "the tray is now closed.\n");
949 if (ret!=CDS_DISC_OK) {
951 goto clean_up_and_return;
954 cdrom_count_tracks(cdi, &tracks);
955 if (tracks.error == CDS_NO_DISC) {
956 cdinfo(CD_OPEN, "bummer. no disc.\n");
958 goto clean_up_and_return;
960 /* CD-Players which don't use O_NONBLOCK, workman
961 * for example, need bit CDO_CHECK_TYPE cleared! */
962 if (tracks.data==0) {
963 if (cdi->options & CDO_CHECK_TYPE) {
964 /* give people a warning shot, now that CDO_CHECK_TYPE
965 is the default case! */
966 cdinfo(CD_OPEN, "bummer. wrong media type.\n");
967 cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
968 (unsigned int)current->pid);
970 goto clean_up_and_return;
973 cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.\n");
977 cdinfo(CD_OPEN, "all seems well, opening the device.\n");
979 /* all seems well, we can open the device */
980 ret = cdo->open(cdi, 0); /* open for data */
981 cdinfo(CD_OPEN, "opening the device gave me %d.\n", ret);
982 /* After all this careful checking, we shouldn't have problems
983 opening the device, but we don't want the device locked if
984 this somehow fails... */
986 cdinfo(CD_OPEN, "open device failed.\n");
987 goto clean_up_and_return;
989 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
990 cdo->lock_door(cdi, 1);
991 cdinfo(CD_OPEN, "door locked.\n");
993 cdinfo(CD_OPEN, "device opened successfully.\n");
996 /* Something failed. Try to unlock the drive, because some drivers
997 (notably ide-cd) lock the drive after every command. This produced
998 a nasty bug where after mount failed, the drive would remain locked!
999 This ensures that the drive gets unlocked after a mount fails. This
1000 is a goto to avoid bloating the driver with redundant code. */
1001 clean_up_and_return:
1002 cdinfo(CD_WARNING, "open failed.\n");
1003 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1004 cdo->lock_door(cdi, 0);
1005 cdinfo(CD_OPEN, "door unlocked.\n");
1010 /* This code is similar to that in open_for_data. The routine is called
1011 whenever an audio play operation is requested.
1013 int check_for_audio_disc(struct cdrom_device_info * cdi,
1014 struct cdrom_device_ops * cdo)
1018 cdinfo(CD_OPEN, "entering check_for_audio_disc\n");
1019 if (!(cdi->options & CDO_CHECK_TYPE))
1021 if (cdo->drive_status != NULL) {
1022 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1023 cdinfo(CD_OPEN, "drive_status=%d\n", ret);
1024 if (ret == CDS_TRAY_OPEN) {
1025 cdinfo(CD_OPEN, "the tray is open...\n");
1026 /* can/may i close it? */
1027 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1028 cdi->options & CDO_AUTO_CLOSE) {
1029 cdinfo(CD_OPEN, "trying to close the tray.\n");
1030 ret=cdo->tray_move(cdi,0);
1032 cdinfo(CD_OPEN, "bummer. tried to close tray but failed.\n");
1033 /* Ignore the error from the low
1034 level driver. We don't care why it
1035 couldn't close the tray. We only care
1036 that there is no disc in the drive,
1037 since that is the _REAL_ problem here.*/
1041 cdinfo(CD_OPEN, "bummer. this driver can't close the tray.\n");
1044 /* Ok, the door should be closed now.. Check again */
1045 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1046 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1047 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
1050 if (ret!=CDS_DISC_OK) {
1051 cdinfo(CD_OPEN, "bummer. disc isn't ready.\n");
1054 cdinfo(CD_OPEN, "the tray is now closed.\n");
1057 cdrom_count_tracks(cdi, &tracks);
1059 return(tracks.error);
1061 if (tracks.audio==0)
1062 return -EMEDIUMTYPE;
1067 /* Admittedly, the logic below could be performed in a nicer way. */
1068 int cdrom_release(struct cdrom_device_info *cdi, struct file *fp)
1070 struct cdrom_device_ops *cdo = cdi->ops;
1071 int opened_for_data;
1073 cdinfo(CD_CLOSE, "entering cdrom_release\n");
1075 if (cdi->use_count > 0)
1077 if (cdi->use_count == 0)
1078 cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
1079 if (cdi->use_count == 0 &&
1080 (cdo->capability & CDC_LOCK) && !keeplocked) {
1081 cdinfo(CD_CLOSE, "Unlocking door!\n");
1082 cdo->lock_door(cdi, 0);
1084 opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1085 !(fp && fp->f_flags & O_NONBLOCK);
1088 * flush cache on last write release
1090 if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1091 cdrom_close_write(cdi);
1094 if (cdi->use_count == 0) { /* last process that closes dev*/
1095 if (opened_for_data &&
1096 cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1097 cdo->tray_move(cdi, 1);
1102 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1103 struct cdrom_changer_info *buf)
1105 struct cdrom_generic_command cgc;
1106 struct cdrom_device_ops *cdo = cdi->ops;
1110 * Sanyo changer isn't spec compliant (doesn't use regular change
1111 * LOAD_UNLOAD command, and it doesn't implement the mech status
1114 if (cdi->sanyo_slot) {
1115 buf->hdr.nslots = 3;
1116 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1117 for (length = 0; length < 3; length++) {
1118 buf->slots[length].disc_present = 1;
1119 buf->slots[length].change = 0;
1124 length = sizeof(struct cdrom_mechstat_header) +
1125 cdi->capacity * sizeof(struct cdrom_slot);
1127 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1128 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1129 cgc.cmd[8] = (length >> 8) & 0xff;
1130 cgc.cmd[9] = length & 0xff;
1131 return cdo->generic_packet(cdi, &cgc);
1134 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1136 struct cdrom_changer_info *info;
1139 cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n");
1140 if (cdi->sanyo_slot)
1143 info = kmalloc(sizeof(*info), GFP_KERNEL);
1147 if ((ret = cdrom_read_mech_status(cdi, info)))
1150 if (info->slots[slot].disc_present)
1160 /* Return the number of slots for an ATAPI/SCSI cdrom,
1161 * return 1 if not a changer.
1163 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1167 struct cdrom_changer_info *info;
1169 cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1170 /* cdrom_read_mech_status requires a valid value for capacity: */
1173 info = kmalloc(sizeof(*info), GFP_KERNEL);
1177 if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1178 nslots = info->hdr.nslots;
1185 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1186 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1188 struct cdrom_generic_command cgc;
1190 cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n");
1191 if (cdi->sanyo_slot && slot < 0)
1194 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1195 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1196 cgc.cmd[4] = 2 + (slot >= 0);
1198 cgc.timeout = 60 * HZ;
1200 /* The Sanyo 3 CD changer uses byte 7 of the
1201 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1202 using the GPCMD_LOAD_UNLOAD opcode. */
1203 if (cdi->sanyo_slot && -1 < slot) {
1204 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1206 cgc.cmd[4] = cgc.cmd[8] = 0;
1207 cdi->sanyo_slot = slot ? slot : 3;
1210 return cdi->ops->generic_packet(cdi, &cgc);
1213 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1215 struct cdrom_changer_info *info;
1219 cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n");
1220 if (!CDROM_CAN(CDC_SELECT_DISC))
1221 return -EDRIVE_CANT_DO_THIS;
1223 (void) cdi->ops->media_changed(cdi, slot);
1225 if (slot == CDSL_NONE) {
1226 /* set media changed bits, on both queues */
1227 cdi->mc_flags = 0x3;
1228 return cdrom_load_unload(cdi, -1);
1231 info = kmalloc(sizeof(*info), GFP_KERNEL);
1235 if ((ret = cdrom_read_mech_status(cdi, info))) {
1240 curslot = info->hdr.curslot;
1243 if (cdi->use_count > 1 || keeplocked) {
1244 if (slot == CDSL_CURRENT) {
1251 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1252 which is useful if it had been previously unloaded.
1253 Whether it can or not, it returns the current slot.
1254 Similarly, if slot happens to be the current one, we still
1256 if (slot == CDSL_CURRENT)
1259 /* set media changed bits on both queues */
1260 cdi->mc_flags = 0x3;
1261 if ((ret = cdrom_load_unload(cdi, slot)))
1267 /* We want to make media_changed accessible to the user through an
1268 * ioctl. The main problem now is that we must double-buffer the
1269 * low-level implementation, to assure that the VFS and the user both
1270 * see a medium change once.
1274 int media_changed(struct cdrom_device_info *cdi, int queue)
1276 unsigned int mask = (1 << (queue & 1));
1277 int ret = !!(cdi->mc_flags & mask);
1279 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1281 /* changed since last call? */
1282 if (cdi->ops->media_changed(cdi, CDSL_CURRENT)) {
1283 cdi->mc_flags = 0x3; /* set bit on both queues */
1286 cdi->mc_flags &= ~mask; /* clear bit */
1290 int cdrom_media_changed(struct cdrom_device_info *cdi)
1292 /* This talks to the VFS, which doesn't like errors - just 1 or 0.
1293 * Returning "0" is always safe (media hasn't been changed). Do that
1294 * if the low-level cdrom driver dosn't support media changed. */
1295 if (cdi == NULL || cdi->ops->media_changed == NULL)
1297 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1299 return media_changed(cdi, 0);
1302 /* badly broken, I know. Is due for a fixup anytime. */
1303 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1305 struct cdrom_tochdr header;
1306 struct cdrom_tocentry entry;
1313 cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1314 if (!CDROM_CAN(CDC_PLAY_AUDIO)) {
1315 tracks->error=CDS_NO_INFO;
1318 /* Grab the TOC header so we can see how many tracks there are */
1319 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1320 if (ret == -ENOMEDIUM)
1321 tracks->error = CDS_NO_DISC;
1323 tracks->error = CDS_NO_INFO;
1326 /* check what type of tracks are on this disc */
1327 entry.cdte_format = CDROM_MSF;
1328 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1329 entry.cdte_track = i;
1330 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1331 tracks->error=CDS_NO_INFO;
1334 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1335 if (entry.cdte_format == 0x10)
1337 else if (entry.cdte_format == 0x20)
1343 cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1344 i, entry.cdte_format, entry.cdte_ctrl);
1346 cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1347 header.cdth_trk1, tracks->audio, tracks->data,
1348 tracks->cdi, tracks->xa);
1351 /* Requests to the low-level drivers will /always/ be done in the
1352 following format convention:
1354 CDROM_LBA: all data-related requests.
1355 CDROM_MSF: all audio-related requests.
1357 However, a low-level implementation is allowed to refuse this
1358 request, and return information in its own favorite format.
1360 It doesn't make sense /at all/ to ask for a play_audio in LBA
1361 format, or ask for multi-session info in MSF format. However, for
1362 backward compatibility these format requests will be satisfied, but
1363 the requests to the low-level drivers will be sanitized in the more
1364 meaningful format indicated above.
1368 void sanitize_format(union cdrom_addr *addr,
1369 u_char * curr, u_char requested)
1371 if (*curr == requested)
1372 return; /* nothing to be done! */
1373 if (requested == CDROM_LBA) {
1374 addr->lba = (int) addr->msf.frame +
1375 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1376 } else { /* CDROM_MSF */
1377 int lba = addr->lba;
1378 addr->msf.frame = lba % 75;
1381 addr->msf.second = lba % 60;
1382 addr->msf.minute = lba / 60;
1387 void init_cdrom_command(struct cdrom_generic_command *cgc, void *buf, int len,
1390 memset(cgc, 0, sizeof(struct cdrom_generic_command));
1392 memset(buf, 0, len);
1393 cgc->buffer = (char *) buf;
1395 cgc->data_direction = type;
1396 cgc->timeout = 5*HZ;
1401 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1402 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1404 static void setup_report_key(struct cdrom_generic_command *cgc, unsigned agid, unsigned type)
1406 cgc->cmd[0] = GPCMD_REPORT_KEY;
1407 cgc->cmd[10] = type | (agid << 6);
1409 case 0: case 8: case 5: {
1422 cgc->cmd[9] = cgc->buflen;
1423 cgc->data_direction = CGC_DATA_READ;
1426 static void setup_send_key(struct cdrom_generic_command *cgc, unsigned agid, unsigned type)
1428 cgc->cmd[0] = GPCMD_SEND_KEY;
1429 cgc->cmd[10] = type | (agid << 6);
1444 cgc->cmd[9] = cgc->buflen;
1445 cgc->data_direction = CGC_DATA_WRITE;
1448 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1452 struct cdrom_generic_command cgc;
1453 struct cdrom_device_ops *cdo = cdi->ops;
1454 rpc_state_t rpc_state;
1456 memset(buf, 0, sizeof(buf));
1457 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1461 case DVD_LU_SEND_AGID:
1462 cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1463 setup_report_key(&cgc, ai->lsa.agid, 0);
1465 if ((ret = cdo->generic_packet(cdi, &cgc)))
1468 ai->lsa.agid = buf[7] >> 6;
1469 /* Returning data, let host change state */
1472 case DVD_LU_SEND_KEY1:
1473 cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1474 setup_report_key(&cgc, ai->lsk.agid, 2);
1476 if ((ret = cdo->generic_packet(cdi, &cgc)))
1479 copy_key(ai->lsk.key, &buf[4]);
1480 /* Returning data, let host change state */
1483 case DVD_LU_SEND_CHALLENGE:
1484 cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1485 setup_report_key(&cgc, ai->lsc.agid, 1);
1487 if ((ret = cdo->generic_packet(cdi, &cgc)))
1490 copy_chal(ai->lsc.chal, &buf[4]);
1491 /* Returning data, let host change state */
1495 case DVD_LU_SEND_TITLE_KEY:
1496 cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1497 setup_report_key(&cgc, ai->lstk.agid, 4);
1498 cgc.cmd[5] = ai->lstk.lba;
1499 cgc.cmd[4] = ai->lstk.lba >> 8;
1500 cgc.cmd[3] = ai->lstk.lba >> 16;
1501 cgc.cmd[2] = ai->lstk.lba >> 24;
1503 if ((ret = cdo->generic_packet(cdi, &cgc)))
1506 ai->lstk.cpm = (buf[4] >> 7) & 1;
1507 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1508 ai->lstk.cgms = (buf[4] >> 4) & 3;
1509 copy_key(ai->lstk.title_key, &buf[5]);
1510 /* Returning data, let host change state */
1513 case DVD_LU_SEND_ASF:
1514 cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1515 setup_report_key(&cgc, ai->lsasf.agid, 5);
1517 if ((ret = cdo->generic_packet(cdi, &cgc)))
1520 ai->lsasf.asf = buf[7] & 1;
1523 /* LU data receive (LU changes state) */
1524 case DVD_HOST_SEND_CHALLENGE:
1525 cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1526 setup_send_key(&cgc, ai->hsc.agid, 1);
1528 copy_chal(&buf[4], ai->hsc.chal);
1530 if ((ret = cdo->generic_packet(cdi, &cgc)))
1533 ai->type = DVD_LU_SEND_KEY1;
1536 case DVD_HOST_SEND_KEY2:
1537 cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1538 setup_send_key(&cgc, ai->hsk.agid, 3);
1540 copy_key(&buf[4], ai->hsk.key);
1542 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1543 ai->type = DVD_AUTH_FAILURE;
1546 ai->type = DVD_AUTH_ESTABLISHED;
1550 case DVD_INVALIDATE_AGID:
1552 cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1553 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1554 if ((ret = cdo->generic_packet(cdi, &cgc)))
1558 /* Get region settings */
1559 case DVD_LU_SEND_RPC_STATE:
1560 cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1561 setup_report_key(&cgc, 0, 8);
1562 memset(&rpc_state, 0, sizeof(rpc_state_t));
1563 cgc.buffer = (char *) &rpc_state;
1565 if ((ret = cdo->generic_packet(cdi, &cgc)))
1568 ai->lrpcs.type = rpc_state.type_code;
1569 ai->lrpcs.vra = rpc_state.vra;
1570 ai->lrpcs.ucca = rpc_state.ucca;
1571 ai->lrpcs.region_mask = rpc_state.region_mask;
1572 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1575 /* Set region settings */
1576 case DVD_HOST_SEND_RPC_STATE:
1577 cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1578 setup_send_key(&cgc, 0, 6);
1580 buf[4] = ai->hrpcs.pdrc;
1582 if ((ret = cdo->generic_packet(cdi, &cgc)))
1587 cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1594 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
1596 unsigned char buf[21], *base;
1597 struct dvd_layer *layer;
1598 struct cdrom_generic_command cgc;
1599 struct cdrom_device_ops *cdo = cdi->ops;
1600 int ret, layer_num = s->physical.layer_num;
1602 if (layer_num >= DVD_LAYERS)
1605 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1606 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1607 cgc.cmd[6] = layer_num;
1608 cgc.cmd[7] = s->type;
1609 cgc.cmd[9] = cgc.buflen & 0xff;
1612 * refrain from reporting errors on non-existing layers (mainly)
1616 if ((ret = cdo->generic_packet(cdi, &cgc)))
1620 layer = &s->physical.layer[layer_num];
1623 * place the data... really ugly, but at least we won't have to
1624 * worry about endianess in userspace.
1626 memset(layer, 0, sizeof(*layer));
1627 layer->book_version = base[0] & 0xf;
1628 layer->book_type = base[0] >> 4;
1629 layer->min_rate = base[1] & 0xf;
1630 layer->disc_size = base[1] >> 4;
1631 layer->layer_type = base[2] & 0xf;
1632 layer->track_path = (base[2] >> 4) & 1;
1633 layer->nlayers = (base[2] >> 5) & 3;
1634 layer->track_density = base[3] & 0xf;
1635 layer->linear_density = base[3] >> 4;
1636 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1637 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1638 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1639 layer->bca = base[16] >> 7;
1644 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
1648 struct cdrom_generic_command cgc;
1649 struct cdrom_device_ops *cdo = cdi->ops;
1651 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1652 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1653 cgc.cmd[6] = s->copyright.layer_num;
1654 cgc.cmd[7] = s->type;
1655 cgc.cmd[8] = cgc.buflen >> 8;
1656 cgc.cmd[9] = cgc.buflen & 0xff;
1658 if ((ret = cdo->generic_packet(cdi, &cgc)))
1661 s->copyright.cpst = buf[4];
1662 s->copyright.rmi = buf[5];
1667 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s)
1671 struct cdrom_generic_command cgc;
1672 struct cdrom_device_ops *cdo = cdi->ops;
1674 size = sizeof(s->disckey.value) + 4;
1676 if ((buf = (u_char *) kmalloc(size, GFP_KERNEL)) == NULL)
1679 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1680 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1681 cgc.cmd[7] = s->type;
1682 cgc.cmd[8] = size >> 8;
1683 cgc.cmd[9] = size & 0xff;
1684 cgc.cmd[10] = s->disckey.agid << 6;
1686 if (!(ret = cdo->generic_packet(cdi, &cgc)))
1687 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1693 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s)
1696 u_char buf[4 + 188];
1697 struct cdrom_generic_command cgc;
1698 struct cdrom_device_ops *cdo = cdi->ops;
1700 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1701 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1702 cgc.cmd[7] = s->type;
1703 cgc.cmd[9] = cgc.buflen = 0xff;
1705 if ((ret = cdo->generic_packet(cdi, &cgc)))
1708 s->bca.len = buf[0] << 8 | buf[1];
1709 if (s->bca.len < 12 || s->bca.len > 188) {
1710 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1713 memcpy(s->bca.value, &buf[4], s->bca.len);
1718 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s)
1722 struct cdrom_generic_command cgc;
1723 struct cdrom_device_ops *cdo = cdi->ops;
1725 size = sizeof(s->manufact.value) + 4;
1727 if ((buf = (u_char *) kmalloc(size, GFP_KERNEL)) == NULL)
1730 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1731 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1732 cgc.cmd[7] = s->type;
1733 cgc.cmd[8] = size >> 8;
1734 cgc.cmd[9] = size & 0xff;
1736 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1741 s->manufact.len = buf[0] << 8 | buf[1];
1742 if (s->manufact.len < 0 || s->manufact.len > 2048) {
1743 cdinfo(CD_WARNING, "Received invalid manufacture info length"
1744 " (%d)\n", s->bca.len);
1747 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1754 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s)
1757 case DVD_STRUCT_PHYSICAL:
1758 return dvd_read_physical(cdi, s);
1760 case DVD_STRUCT_COPYRIGHT:
1761 return dvd_read_copyright(cdi, s);
1763 case DVD_STRUCT_DISCKEY:
1764 return dvd_read_disckey(cdi, s);
1766 case DVD_STRUCT_BCA:
1767 return dvd_read_bca(cdi, s);
1769 case DVD_STRUCT_MANUFACT:
1770 return dvd_read_manufact(cdi, s);
1773 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1779 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1780 struct cdrom_generic_command *cgc,
1781 int page_code, int page_control)
1783 struct cdrom_device_ops *cdo = cdi->ops;
1785 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1787 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1788 cgc->cmd[2] = page_code | (page_control << 6);
1789 cgc->cmd[7] = cgc->buflen >> 8;
1790 cgc->cmd[8] = cgc->buflen & 0xff;
1791 cgc->data_direction = CGC_DATA_READ;
1792 return cdo->generic_packet(cdi, cgc);
1795 int cdrom_mode_select(struct cdrom_device_info *cdi,
1796 struct cdrom_generic_command *cgc)
1798 struct cdrom_device_ops *cdo = cdi->ops;
1800 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1801 memset(cgc->buffer, 0, 2);
1802 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1803 cgc->cmd[1] = 0x10; /* PF */
1804 cgc->cmd[7] = cgc->buflen >> 8;
1805 cgc->cmd[8] = cgc->buflen & 0xff;
1806 cgc->data_direction = CGC_DATA_WRITE;
1807 return cdo->generic_packet(cdi, cgc);
1810 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
1811 struct cdrom_subchnl *subchnl, int mcn)
1813 struct cdrom_device_ops *cdo = cdi->ops;
1814 struct cdrom_generic_command cgc;
1818 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1819 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
1820 cgc.cmd[1] = 2; /* MSF addressing */
1821 cgc.cmd[2] = 0x40; /* request subQ data */
1822 cgc.cmd[3] = mcn ? 2 : 1;
1825 if ((ret = cdo->generic_packet(cdi, &cgc)))
1828 subchnl->cdsc_audiostatus = cgc.buffer[1];
1829 subchnl->cdsc_format = CDROM_MSF;
1830 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
1831 subchnl->cdsc_trk = cgc.buffer[6];
1832 subchnl->cdsc_ind = cgc.buffer[7];
1834 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
1835 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
1836 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
1837 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
1838 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
1839 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
1845 * Specific READ_10 interface
1847 static int cdrom_read_cd(struct cdrom_device_info *cdi,
1848 struct cdrom_generic_command *cgc, int lba,
1849 int blocksize, int nblocks)
1851 struct cdrom_device_ops *cdo = cdi->ops;
1853 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
1854 cgc->cmd[0] = GPCMD_READ_10;
1855 cgc->cmd[2] = (lba >> 24) & 0xff;
1856 cgc->cmd[3] = (lba >> 16) & 0xff;
1857 cgc->cmd[4] = (lba >> 8) & 0xff;
1858 cgc->cmd[5] = lba & 0xff;
1859 cgc->cmd[6] = (nblocks >> 16) & 0xff;
1860 cgc->cmd[7] = (nblocks >> 8) & 0xff;
1861 cgc->cmd[8] = nblocks & 0xff;
1862 cgc->buflen = blocksize * nblocks;
1863 return cdo->generic_packet(cdi, cgc);
1866 /* very generic interface for reading the various types of blocks */
1867 static int cdrom_read_block(struct cdrom_device_info *cdi,
1868 struct cdrom_generic_command *cgc,
1869 int lba, int nblocks, int format, int blksize)
1871 struct cdrom_device_ops *cdo = cdi->ops;
1873 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
1874 cgc->cmd[0] = GPCMD_READ_CD;
1875 /* expected sector size - cdda,mode1,etc. */
1876 cgc->cmd[1] = format << 2;
1877 /* starting address */
1878 cgc->cmd[2] = (lba >> 24) & 0xff;
1879 cgc->cmd[3] = (lba >> 16) & 0xff;
1880 cgc->cmd[4] = (lba >> 8) & 0xff;
1881 cgc->cmd[5] = lba & 0xff;
1882 /* number of blocks */
1883 cgc->cmd[6] = (nblocks >> 16) & 0xff;
1884 cgc->cmd[7] = (nblocks >> 8) & 0xff;
1885 cgc->cmd[8] = nblocks & 0xff;
1886 cgc->buflen = blksize * nblocks;
1888 /* set the header info returned */
1890 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
1891 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
1892 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
1893 default : cgc->cmd[9] = 0x10;
1896 return cdo->generic_packet(cdi, cgc);
1899 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
1900 int lba, int nframes)
1902 struct cdrom_generic_command cgc;
1905 memset(&cgc, 0, sizeof(cgc));
1908 * start with will ra.nframes size, back down if alloc fails
1912 cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
1922 if (!access_ok(VERIFY_WRITE, ubuf, nframes * CD_FRAMESIZE_RAW)) {
1927 cgc.data_direction = CGC_DATA_READ;
1928 while (nframes > 0) {
1932 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
1935 __copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr);
1936 ubuf += CD_FRAMESIZE_RAW * nr;
1944 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
1945 int lba, int nframes)
1947 request_queue_t *q = cdi->disk->queue;
1958 if (cdi->cdda_method == CDDA_BPC_SINGLE)
1960 if (nr * CD_FRAMESIZE_RAW > (q->max_sectors << 9))
1961 nr = (q->max_sectors << 9) / CD_FRAMESIZE_RAW;
1963 len = nr * CD_FRAMESIZE_RAW;
1965 rq = blk_rq_map_user(q, READ, ubuf, len);
1969 memset(rq->cmd, 0, sizeof(rq->cmd));
1970 rq->cmd[0] = GPCMD_READ_CD;
1971 rq->cmd[1] = 1 << 2;
1972 rq->cmd[2] = (lba >> 24) & 0xff;
1973 rq->cmd[3] = (lba >> 16) & 0xff;
1974 rq->cmd[4] = (lba >> 8) & 0xff;
1975 rq->cmd[5] = lba & 0xff;
1976 rq->cmd[6] = (nr >> 16) & 0xff;
1977 rq->cmd[7] = (nr >> 8) & 0xff;
1978 rq->cmd[8] = nr & 0xff;
1982 rq->flags |= REQ_BLOCK_PC;
1983 rq->timeout = 60 * HZ;
1986 if (blk_execute_rq(q, cdi->disk, rq)) {
1987 struct request_sense *s = rq->sense;
1989 cdi->last_sense = s->sense_key;
1992 if (blk_rq_unmap_user(rq, ubuf, bio, len))
2005 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2006 int lba, int nframes)
2010 if (cdi->cdda_method == CDDA_OLD)
2011 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2015 * for anything else than success and io error, we need to retry
2017 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2018 if (!ret || ret != -EIO)
2022 * I've seen drives get sense 4/8/3 udma crc errors on multi
2023 * frame dma, so drop to single frame dma if we need to
2025 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2026 printk("cdrom: dropping to single frame dma\n");
2027 cdi->cdda_method = CDDA_BPC_SINGLE;
2032 * so we have an io error of some sort with multi frame dma. if the
2033 * condition wasn't a hardware error
2034 * problems, not for any error
2036 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2039 printk("cdrom: dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2040 cdi->cdda_method = CDDA_OLD;
2041 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2044 /* Just about every imaginable ioctl is supported in the Uniform layer
2045 * these days. ATAPI / SCSI specific code now mainly resides in
2048 int cdrom_ioctl(struct cdrom_device_info *cdi, struct inode *ip,
2049 unsigned int cmd, unsigned long arg)
2051 struct cdrom_device_ops *cdo = cdi->ops;
2054 /* Try the generic SCSI command ioctl's first.. */
2055 ret = scsi_cmd_ioctl(ip->i_bdev->bd_disk, cmd, arg);
2059 /* the first few commands do not deal with audio drive_info, but
2060 only with routines in cdrom device operations. */
2062 case CDROMMULTISESSION: {
2063 struct cdrom_multisession ms_info;
2064 u_char requested_format;
2065 cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2066 if (!(cdo->capability & CDC_MULTI_SESSION))
2068 IOCTL_IN(arg, struct cdrom_multisession, ms_info);
2069 requested_format = ms_info.addr_format;
2070 if (!((requested_format == CDROM_MSF) ||
2071 (requested_format == CDROM_LBA)))
2073 ms_info.addr_format = CDROM_LBA;
2074 if ((ret=cdo->get_last_session(cdi, &ms_info)))
2076 sanitize_format(&ms_info.addr, &ms_info.addr_format,
2078 IOCTL_OUT(arg, struct cdrom_multisession, ms_info);
2079 cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2084 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2085 if (!CDROM_CAN(CDC_OPEN_TRAY))
2087 if (cdi->use_count != 1 || keeplocked)
2089 if (CDROM_CAN(CDC_LOCK))
2090 if ((ret=cdo->lock_door(cdi, 0)))
2093 return cdo->tray_move(cdi, 1);
2096 case CDROMCLOSETRAY: {
2097 cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2098 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2100 return cdo->tray_move(cdi, 0);
2103 case CDROMEJECT_SW: {
2104 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2105 if (!CDROM_CAN(CDC_OPEN_TRAY))
2109 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2111 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2115 case CDROM_MEDIA_CHANGED: {
2116 struct cdrom_changer_info *info;
2119 cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2120 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2123 /* cannot select disc or select current disc */
2124 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2125 return media_changed(cdi, 1);
2127 if ((unsigned int)arg >= cdi->capacity)
2130 info = kmalloc(sizeof(*info), GFP_KERNEL);
2134 if ((ret = cdrom_read_mech_status(cdi, info))) {
2139 changed = info->slots[arg].change;
2144 case CDROM_SET_OPTIONS: {
2145 cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2146 /* options need to be in sync with capability. too late for
2147 that, so we have to check each one separately... */
2149 case CDO_USE_FFLAGS:
2150 case CDO_CHECK_TYPE:
2153 if (!CDROM_CAN(CDC_LOCK))
2157 return cdi->options;
2158 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2160 if (!CDROM_CAN(arg))
2163 cdi->options |= (int) arg;
2164 return cdi->options;
2167 case CDROM_CLEAR_OPTIONS: {
2168 cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2169 cdi->options &= ~(int) arg;
2170 return cdi->options;
2173 case CDROM_SELECT_SPEED: {
2174 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2175 if (!CDROM_CAN(CDC_SELECT_SPEED))
2177 return cdo->select_speed(cdi, arg);
2180 case CDROM_SELECT_DISC: {
2181 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2182 if (!CDROM_CAN(CDC_SELECT_DISC))
2185 if ((arg != CDSL_CURRENT) && (arg != CDSL_NONE))
2186 if ((int)arg >= cdi->capacity)
2189 /* cdo->select_disc is a hook to allow a driver-specific
2190 * way of seleting disc. However, since there is no
2191 * equiv hook for cdrom_slot_status this may not
2192 * actually be useful...
2194 if (cdo->select_disc != NULL)
2195 return cdo->select_disc(cdi, arg);
2197 /* no driver specific select_disc(), call our own */
2198 cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2199 return cdrom_select_disc(cdi, arg);
2203 if (!capable(CAP_SYS_ADMIN))
2205 cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2206 if (!CDROM_CAN(CDC_RESET))
2208 invalidate_bdev(ip->i_bdev, 0);
2209 return cdo->reset(cdi);
2212 case CDROM_LOCKDOOR: {
2213 cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2214 if (!CDROM_CAN(CDC_LOCK))
2215 return -EDRIVE_CANT_DO_THIS;
2216 keeplocked = arg ? 1 : 0;
2217 /* don't unlock the door on multiple opens,but allow root
2219 if ((cdi->use_count != 1) && !arg && !capable(CAP_SYS_ADMIN))
2221 return cdo->lock_door(cdi, arg);
2225 if (!capable(CAP_SYS_ADMIN))
2227 cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2228 debug = arg ? 1 : 0;
2232 case CDROM_GET_CAPABILITY: {
2233 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2234 return (cdo->capability & ~cdi->mask);
2237 /* The following function is implemented, although very few audio
2238 * discs give Universal Product Code information, which should just be
2239 * the Medium Catalog Number on the box. Note, that the way the code
2240 * is written on the CD is /not/ uniform across all discs!
2242 case CDROM_GET_MCN: {
2243 struct cdrom_mcn mcn;
2244 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2245 if (!(cdo->capability & CDC_MCN))
2247 if ((ret=cdo->get_mcn(cdi, &mcn)))
2249 IOCTL_OUT(arg, struct cdrom_mcn, mcn);
2250 cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2254 case CDROM_DRIVE_STATUS: {
2255 cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2256 if (!(cdo->capability & CDC_DRIVE_STATUS))
2258 if (!CDROM_CAN(CDC_SELECT_DISC))
2259 return cdo->drive_status(cdi, CDSL_CURRENT);
2260 if ((arg == CDSL_CURRENT) || (arg == CDSL_NONE))
2261 return cdo->drive_status(cdi, CDSL_CURRENT);
2262 if (((int)arg >= cdi->capacity))
2264 return cdrom_slot_status(cdi, arg);
2267 /* Ok, this is where problems start. The current interface for the
2268 CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption
2269 that CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunatly,
2270 while this is often the case, it is also very common for CDs to
2271 have some tracks with data, and some tracks with audio. Just
2272 because I feel like it, I declare the following to be the best
2273 way to cope. If the CD has ANY data tracks on it, it will be
2274 returned as a data CD. If it has any XA tracks, I will return
2275 it as that. Now I could simplify this interface by combining these
2276 returns with the above, but this more clearly demonstrates
2277 the problem with the current interface. Too bad this wasn't
2278 designed to use bitmasks... -Erik
2280 Well, now we have the option CDS_MIXED: a mixed-type CD.
2281 User level programmers might feel the ioctl is not very useful.
2284 case CDROM_DISC_STATUS: {
2286 cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2287 cdrom_count_tracks(cdi, &tracks);
2289 return(tracks.error);
2291 /* Policy mode on */
2292 if (tracks.audio > 0) {
2293 if (tracks.data==0 && tracks.cdi==0 && tracks.xa==0)
2298 if (tracks.cdi > 0) return CDS_XA_2_2;
2299 if (tracks.xa > 0) return CDS_XA_2_1;
2300 if (tracks.data > 0) return CDS_DATA_1;
2301 /* Policy mode off */
2303 cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2307 case CDROM_CHANGER_NSLOTS: {
2308 cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2309 return cdi->capacity;
2313 /* use the ioctls that are implemented through the generic_packet()
2314 interface. this may look at bit funny, but if -ENOTTY is
2315 returned that particular ioctl is not implemented and we
2316 let it go through the device specific ones. */
2317 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2318 ret = mmc_ioctl(cdi, cmd, arg);
2319 if (ret != -ENOTTY) {
2324 /* note: most of the cdinfo() calls are commented out here,
2325 because they fill up the sys log when CD players poll
2328 case CDROMSUBCHNL: {
2329 struct cdrom_subchnl q;
2330 u_char requested, back;
2331 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2333 /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2334 IOCTL_IN(arg, struct cdrom_subchnl, q);
2335 requested = q.cdsc_format;
2336 if (!((requested == CDROM_MSF) ||
2337 (requested == CDROM_LBA)))
2339 q.cdsc_format = CDROM_MSF;
2340 if ((ret=cdo->audio_ioctl(cdi, cmd, &q)))
2342 back = q.cdsc_format; /* local copy */
2343 sanitize_format(&q.cdsc_absaddr, &back, requested);
2344 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2345 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2346 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2349 case CDROMREADTOCHDR: {
2350 struct cdrom_tochdr header;
2351 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2353 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2354 IOCTL_IN(arg, struct cdrom_tochdr, header);
2355 if ((ret=cdo->audio_ioctl(cdi, cmd, &header)))
2357 IOCTL_OUT(arg, struct cdrom_tochdr, header);
2358 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2361 case CDROMREADTOCENTRY: {
2362 struct cdrom_tocentry entry;
2363 u_char requested_format;
2364 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2366 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2367 IOCTL_IN(arg, struct cdrom_tocentry, entry);
2368 requested_format = entry.cdte_format;
2369 if (!((requested_format == CDROM_MSF) ||
2370 (requested_format == CDROM_LBA)))
2372 /* make interface to low-level uniform */
2373 entry.cdte_format = CDROM_MSF;
2374 if ((ret=cdo->audio_ioctl(cdi, cmd, &entry)))
2376 sanitize_format(&entry.cdte_addr,
2377 &entry.cdte_format, requested_format);
2378 IOCTL_OUT(arg, struct cdrom_tocentry, entry);
2379 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2382 case CDROMPLAYMSF: {
2383 struct cdrom_msf msf;
2384 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2386 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2387 IOCTL_IN(arg, struct cdrom_msf, msf);
2388 return cdo->audio_ioctl(cdi, cmd, &msf);
2390 case CDROMPLAYTRKIND: {
2392 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2394 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2395 IOCTL_IN(arg, struct cdrom_ti, ti);
2397 return cdo->audio_ioctl(cdi, cmd, &ti);
2399 case CDROMVOLCTRL: {
2400 struct cdrom_volctrl volume;
2401 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2403 cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2404 IOCTL_IN(arg, struct cdrom_volctrl, volume);
2405 return cdo->audio_ioctl(cdi, cmd, &volume);
2407 case CDROMVOLREAD: {
2408 struct cdrom_volctrl volume;
2409 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2411 cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2412 if ((ret=cdo->audio_ioctl(cdi, cmd, &volume)))
2414 IOCTL_OUT(arg, struct cdrom_volctrl, volume);
2421 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2423 cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2425 return cdo->audio_ioctl(cdi, cmd, NULL);
2429 /* do the device specific ioctls */
2430 if (CDROM_CAN(CDC_IOCTLS))
2431 return cdo->dev_ioctl(cdi, cmd, arg);
2437 int msf_to_lba(char m, char s, char f)
2439 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2443 * Required when we need to use READ_10 to issue other than 2048 block
2446 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2448 struct cdrom_device_ops *cdo = cdi->ops;
2449 struct cdrom_generic_command cgc;
2450 struct modesel_head mh;
2452 memset(&mh, 0, sizeof(mh));
2453 mh.block_desc_length = 0x08;
2454 mh.block_length_med = (size >> 8) & 0xff;
2455 mh.block_length_lo = size & 0xff;
2457 memset(&cgc, 0, sizeof(cgc));
2459 cgc.cmd[1] = 1 << 4;
2461 cgc.buflen = sizeof(mh);
2462 cgc.buffer = (char *) &mh;
2463 cgc.data_direction = CGC_DATA_WRITE;
2464 mh.block_desc_length = 0x08;
2465 mh.block_length_med = (size >> 8) & 0xff;
2466 mh.block_length_lo = size & 0xff;
2468 return cdo->generic_packet(cdi, &cgc);
2471 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
2474 struct cdrom_device_ops *cdo = cdi->ops;
2475 struct cdrom_generic_command cgc;
2476 struct request_sense sense;
2480 memset(&cgc, 0, sizeof(cgc));
2482 /* build a unified command and queue it through
2483 cdo->generic_packet() */
2486 case CDROMREADMODE1:
2487 case CDROMREADMODE2: {
2488 struct cdrom_msf msf;
2489 int blocksize = 0, format = 0, lba;
2493 blocksize = CD_FRAMESIZE_RAW;
2495 case CDROMREADMODE1:
2496 blocksize = CD_FRAMESIZE;
2499 case CDROMREADMODE2:
2500 blocksize = CD_FRAMESIZE_RAW0;
2503 IOCTL_IN(arg, struct cdrom_msf, msf);
2504 lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
2505 /* FIXME: we need upper bound checking, too!! */
2508 cgc.buffer = (char *) kmalloc(blocksize, GFP_KERNEL);
2509 if (cgc.buffer == NULL)
2511 memset(&sense, 0, sizeof(sense));
2513 cgc.data_direction = CGC_DATA_READ;
2514 ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
2515 if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) {
2517 * SCSI-II devices are not required to support
2518 * READ_CD, so let's try switching block size
2520 /* FIXME: switch back again... */
2521 if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
2526 ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
2527 ret |= cdrom_switch_blocksize(cdi, blocksize);
2529 if (!ret && copy_to_user((char *)arg, cgc.buffer, blocksize))
2534 case CDROMREADAUDIO: {
2535 struct cdrom_read_audio ra;
2538 IOCTL_IN(arg, struct cdrom_read_audio, ra);
2540 if (ra.addr_format == CDROM_MSF)
2541 lba = msf_to_lba(ra.addr.msf.minute,
2544 else if (ra.addr_format == CDROM_LBA)
2549 /* FIXME: we need upper bound checking, too!! */
2550 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2553 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2555 case CDROMSUBCHNL: {
2556 struct cdrom_subchnl q;
2557 u_char requested, back;
2558 IOCTL_IN(arg, struct cdrom_subchnl, q);
2559 requested = q.cdsc_format;
2560 if (!((requested == CDROM_MSF) ||
2561 (requested == CDROM_LBA)))
2563 q.cdsc_format = CDROM_MSF;
2564 if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
2566 back = q.cdsc_format; /* local copy */
2567 sanitize_format(&q.cdsc_absaddr, &back, requested);
2568 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2569 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2570 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2573 case CDROMPLAYMSF: {
2574 struct cdrom_msf msf;
2575 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2576 IOCTL_IN(arg, struct cdrom_msf, msf);
2577 cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2578 cgc.cmd[3] = msf.cdmsf_min0;
2579 cgc.cmd[4] = msf.cdmsf_sec0;
2580 cgc.cmd[5] = msf.cdmsf_frame0;
2581 cgc.cmd[6] = msf.cdmsf_min1;
2582 cgc.cmd[7] = msf.cdmsf_sec1;
2583 cgc.cmd[8] = msf.cdmsf_frame1;
2584 cgc.data_direction = CGC_DATA_NONE;
2585 return cdo->generic_packet(cdi, &cgc);
2587 case CDROMPLAYBLK: {
2588 struct cdrom_blk blk;
2589 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2590 IOCTL_IN(arg, struct cdrom_blk, blk);
2591 cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
2592 cgc.cmd[2] = (blk.from >> 24) & 0xff;
2593 cgc.cmd[3] = (blk.from >> 16) & 0xff;
2594 cgc.cmd[4] = (blk.from >> 8) & 0xff;
2595 cgc.cmd[5] = blk.from & 0xff;
2596 cgc.cmd[7] = (blk.len >> 8) & 0xff;
2597 cgc.cmd[8] = blk.len & 0xff;
2598 cgc.data_direction = CGC_DATA_NONE;
2599 return cdo->generic_packet(cdi, &cgc);
2602 case CDROMVOLREAD: {
2603 struct cdrom_volctrl volctrl;
2605 unsigned short offset;
2606 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
2608 IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
2610 cgc.buffer = buffer;
2612 if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
2615 /* some drives have longer pages, adjust and reread. */
2616 if (buffer[1] > cgc.buflen) {
2617 cgc.buflen = buffer[1] + 2;
2618 if ((ret = cdrom_mode_sense(cdi, &cgc,
2619 GPMODE_AUDIO_CTL_PAGE, 0)))
2623 /* get the offset from the length of the page. length
2624 is measure from byte 2 an on, thus the 14. */
2625 offset = buffer[1] - 14;
2627 /* now we have the current volume settings. if it was only
2628 a CDROMVOLREAD, return these values */
2629 if (cmd == CDROMVOLREAD) {
2630 volctrl.channel0 = buffer[offset+9];
2631 volctrl.channel1 = buffer[offset+11];
2632 volctrl.channel2 = buffer[offset+13];
2633 volctrl.channel3 = buffer[offset+15];
2634 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
2638 /* get the volume mask */
2640 if ((ret = cdrom_mode_sense(cdi, &cgc,
2641 GPMODE_AUDIO_CTL_PAGE, 1)))
2644 buffer[offset+9] = volctrl.channel0 & mask[offset+9];
2645 buffer[offset+11] = volctrl.channel1 & mask[offset+11];
2646 buffer[offset+13] = volctrl.channel2 & mask[offset+13];
2647 buffer[offset+15] = volctrl.channel3 & mask[offset+15];
2650 cgc.buffer = buffer;
2651 return cdrom_mode_select(cdi, &cgc);
2656 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
2657 cgc.cmd[0] = GPCMD_START_STOP_UNIT;
2659 cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
2660 cgc.data_direction = CGC_DATA_NONE;
2661 return cdo->generic_packet(cdi, &cgc);
2666 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
2667 cgc.cmd[0] = GPCMD_PAUSE_RESUME;
2668 cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
2669 cgc.data_direction = CGC_DATA_NONE;
2670 return cdo->generic_packet(cdi, &cgc);
2673 case DVD_READ_STRUCT: {
2675 int size = sizeof(dvd_struct);
2676 if (!CDROM_CAN(CDC_DVD))
2678 if ((s = (dvd_struct *) kmalloc(size, GFP_KERNEL)) == NULL)
2680 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
2681 if (copy_from_user(s, (dvd_struct *)arg, size)) {
2685 if ((ret = dvd_read_struct(cdi, s))) {
2689 if (copy_to_user((dvd_struct *)arg, s, size))
2697 if (!CDROM_CAN(CDC_DVD))
2699 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
2700 IOCTL_IN(arg, dvd_authinfo, ai);
2701 if ((ret = dvd_do_auth (cdi, &ai)))
2703 IOCTL_OUT(arg, dvd_authinfo, ai);
2707 case CDROM_NEXT_WRITABLE: {
2709 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
2710 if ((ret = cdrom_get_next_writable(cdi, &next)))
2712 IOCTL_OUT(arg, long, next);
2715 case CDROM_LAST_WRITTEN: {
2717 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
2718 if ((ret = cdrom_get_last_written(cdi, &last)))
2720 IOCTL_OUT(arg, long, last);
2728 static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
2729 track_information *ti)
2731 struct cdrom_device_ops *cdo = cdi->ops;
2732 struct cdrom_generic_command cgc;
2735 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
2736 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
2737 cgc.cmd[1] = type & 3;
2738 cgc.cmd[4] = (track & 0xff00) >> 8;
2739 cgc.cmd[5] = track & 0xff;
2743 if ((ret = cdo->generic_packet(cdi, &cgc)))
2746 cgc.buflen = be16_to_cpu(ti->track_information_length) +
2747 sizeof(ti->track_information_length);
2749 if (cgc.buflen > sizeof(track_information))
2750 cgc.buflen = sizeof(track_information);
2752 cgc.cmd[8] = cgc.buflen;
2753 return cdo->generic_packet(cdi, &cgc);
2756 /* requires CD R/RW */
2757 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
2759 struct cdrom_device_ops *cdo = cdi->ops;
2760 struct cdrom_generic_command cgc;
2763 /* set up command and get the disc info */
2764 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
2765 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
2766 cgc.cmd[8] = cgc.buflen = 2;
2769 if ((ret = cdo->generic_packet(cdi, &cgc)))
2772 /* not all drives have the same disc_info length, so requeue
2773 * packet with the length the drive tells us it can supply
2775 cgc.buflen = be16_to_cpu(di->disc_information_length) +
2776 sizeof(di->disc_information_length);
2778 if (cgc.buflen > sizeof(disc_information))
2779 cgc.buflen = sizeof(disc_information);
2781 cgc.cmd[8] = cgc.buflen;
2782 return cdo->generic_packet(cdi, &cgc);
2785 /* return the last written block on the CD-R media. this is for the udf
2787 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
2789 struct cdrom_tocentry toc;
2790 disc_information di;
2791 track_information ti;
2795 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2798 if ((ret = cdrom_get_disc_info(cdi, &di)))
2801 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2802 if ((ret = cdrom_get_track_info(cdi, last_track, 1, &ti)))
2805 /* if this track is blank, try the previous. */
2808 if ((ret = cdrom_get_track_info(cdi, last_track, 1, &ti)))
2812 /* if last recorded field is valid, return it. */
2814 *last_written = be32_to_cpu(ti.last_rec_address);
2816 /* make it up instead */
2817 *last_written = be32_to_cpu(ti.track_start) +
2818 be32_to_cpu(ti.track_size);
2820 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
2824 /* this is where we end up if the drive either can't do a
2825 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
2826 it fails. then we return the toc contents. */
2828 toc.cdte_format = CDROM_MSF;
2829 toc.cdte_track = CDROM_LEADOUT;
2830 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc))
2832 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
2833 *last_written = toc.cdte_addr.lba;
2837 /* return the next writable block. also for udf file system. */
2838 static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
2840 disc_information di;
2841 track_information ti;
2845 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2846 goto use_last_written;
2848 if ((ret = cdrom_get_disc_info(cdi, &di)))
2849 goto use_last_written;
2851 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2852 if ((ret = cdrom_get_track_info(cdi, last_track, 1, &ti)))
2853 goto use_last_written;
2855 /* if this track is blank, try the previous. */
2858 if ((ret = cdrom_get_track_info(cdi, last_track, 1, &ti)))
2859 goto use_last_written;
2862 /* if next recordable address field is valid, use it. */
2864 *next_writable = be32_to_cpu(ti.next_writable);
2866 goto use_last_written;
2871 if ((ret = cdrom_get_last_written(cdi, next_writable))) {
2875 *next_writable += 7;
2880 EXPORT_SYMBOL(cdrom_get_last_written);
2881 EXPORT_SYMBOL(register_cdrom);
2882 EXPORT_SYMBOL(unregister_cdrom);
2883 EXPORT_SYMBOL(cdrom_open);
2884 EXPORT_SYMBOL(cdrom_release);
2885 EXPORT_SYMBOL(cdrom_ioctl);
2886 EXPORT_SYMBOL(cdrom_media_changed);
2887 EXPORT_SYMBOL(cdrom_number_of_slots);
2888 EXPORT_SYMBOL(cdrom_mode_select);
2889 EXPORT_SYMBOL(cdrom_mode_sense);
2890 EXPORT_SYMBOL(init_cdrom_command);
2891 EXPORT_SYMBOL(cdrom_get_media_event);
2892 EXPORT_SYMBOL(cdrom_is_mrw);
2893 EXPORT_SYMBOL(cdrom_is_random_writable);
2895 #ifdef CONFIG_SYSCTL
2897 #define CDROM_STR_SIZE 1000
2899 struct cdrom_sysctl_settings {
2900 char info[CDROM_STR_SIZE]; /* general info */
2901 int autoclose; /* close tray upon mount, etc */
2902 int autoeject; /* eject on umount */
2903 int debug; /* turn on debugging messages */
2904 int lock; /* lock the door on device open */
2905 int check; /* check media type */
2906 } cdrom_sysctl_settings;
2908 int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
2909 void *buffer, size_t *lenp)
2912 struct cdrom_device_info *cdi;
2913 char *info = cdrom_sysctl_settings.info;
2915 if (!*lenp || (filp->f_pos && !write)) {
2920 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
2922 pos += sprintf(info+pos, "\ndrive name:\t");
2923 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2924 pos += sprintf(info+pos, "\t%s", cdi->name);
2926 pos += sprintf(info+pos, "\ndrive speed:\t");
2927 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2928 pos += sprintf(info+pos, "\t%d", cdi->speed);
2930 pos += sprintf(info+pos, "\ndrive # of slots:");
2931 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2932 pos += sprintf(info+pos, "\t%d", cdi->capacity);
2934 pos += sprintf(info+pos, "\nCan close tray:\t");
2935 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2936 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_CLOSE_TRAY) != 0);
2938 pos += sprintf(info+pos, "\nCan open tray:\t");
2939 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2940 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_OPEN_TRAY) != 0);
2942 pos += sprintf(info+pos, "\nCan lock tray:\t");
2943 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2944 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_LOCK) != 0);
2946 pos += sprintf(info+pos, "\nCan change speed:");
2947 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2948 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_SELECT_SPEED) != 0);
2950 pos += sprintf(info+pos, "\nCan select disk:");
2951 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2952 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_SELECT_DISC) != 0);
2954 pos += sprintf(info+pos, "\nCan read multisession:");
2955 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2956 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MULTI_SESSION) != 0);
2958 pos += sprintf(info+pos, "\nCan read MCN:\t");
2959 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2960 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MCN) != 0);
2962 pos += sprintf(info+pos, "\nReports media changed:");
2963 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2964 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MEDIA_CHANGED) != 0);
2966 pos += sprintf(info+pos, "\nCan play audio:\t");
2967 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2968 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_PLAY_AUDIO) != 0);
2970 pos += sprintf(info+pos, "\nCan write CD-R:\t");
2971 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2972 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_CD_R) != 0);
2974 pos += sprintf(info+pos, "\nCan write CD-RW:");
2975 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2976 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_CD_RW) != 0);
2978 pos += sprintf(info+pos, "\nCan read DVD:\t");
2979 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2980 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD) != 0);
2982 pos += sprintf(info+pos, "\nCan write DVD-R:");
2983 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2984 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD_R) != 0);
2986 pos += sprintf(info+pos, "\nCan write DVD-RAM:");
2987 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2988 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD_RAM) != 0);
2990 pos += sprintf(info+pos, "\nCan read MRW:\t");
2991 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2992 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MRW) != 0);
2994 pos += sprintf(info+pos, "\nCan write MRW:\t");
2995 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2996 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MRW_W) != 0);
2998 pos += sprintf(info+pos, "\nCan write RAM:\t");
2999 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
3000 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_RAM) != 0);
3002 strcpy(info+pos,"\n\n");
3004 return proc_dostring(ctl, write, filp, buffer, lenp);
3007 /* Unfortunately, per device settings are not implemented through
3008 procfs/sysctl yet. When they are, this will naturally disappear. For now
3009 just update all drives. Later this will become the template on which
3010 new registered drives will be based. */
3011 void cdrom_update_settings(void)
3013 struct cdrom_device_info *cdi;
3015 for (cdi = topCdromPtr; cdi != NULL; cdi = cdi->next) {
3016 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3017 cdi->options |= CDO_AUTO_CLOSE;
3018 else if (!autoclose)
3019 cdi->options &= ~CDO_AUTO_CLOSE;
3020 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3021 cdi->options |= CDO_AUTO_EJECT;
3022 else if (!autoeject)
3023 cdi->options &= ~CDO_AUTO_EJECT;
3024 if (lockdoor && CDROM_CAN(CDC_LOCK))
3025 cdi->options |= CDO_LOCK;
3027 cdi->options &= ~CDO_LOCK;
3028 if (check_media_type)
3029 cdi->options |= CDO_CHECK_TYPE;
3031 cdi->options &= ~CDO_CHECK_TYPE;
3035 static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
3036 void *buffer, size_t *lenp)
3038 int *valp = ctl->data;
3042 ret = proc_dointvec(ctl, write, filp, buffer, lenp);
3044 if (write && *valp != val) {
3046 /* we only care for 1 or 0. */
3052 switch (ctl->ctl_name) {
3053 case DEV_CDROM_AUTOCLOSE: {
3054 if (valp == &cdrom_sysctl_settings.autoclose)
3055 autoclose = cdrom_sysctl_settings.autoclose;
3058 case DEV_CDROM_AUTOEJECT: {
3059 if (valp == &cdrom_sysctl_settings.autoeject)
3060 autoeject = cdrom_sysctl_settings.autoeject;
3063 case DEV_CDROM_DEBUG: {
3064 if (valp == &cdrom_sysctl_settings.debug)
3065 debug = cdrom_sysctl_settings.debug;
3068 case DEV_CDROM_LOCK: {
3069 if (valp == &cdrom_sysctl_settings.lock)
3070 lockdoor = cdrom_sysctl_settings.lock;
3073 case DEV_CDROM_CHECK_MEDIA: {
3074 if (valp == &cdrom_sysctl_settings.check)
3075 check_media_type = cdrom_sysctl_settings.check;
3079 /* update the option flags according to the changes. we
3080 don't have per device options through sysctl yet,
3081 but we will have and then this will disappear. */
3082 cdrom_update_settings();
3088 /* Place files in /proc/sys/dev/cdrom */
3089 ctl_table cdrom_table[] = {
3091 .ctl_name = DEV_CDROM_INFO,
3093 .data = &cdrom_sysctl_settings.info,
3094 .maxlen = CDROM_STR_SIZE,
3096 .proc_handler = &cdrom_sysctl_info,
3099 .ctl_name = DEV_CDROM_AUTOCLOSE,
3100 .procname = "autoclose",
3101 .data = &cdrom_sysctl_settings.autoclose,
3102 .maxlen = sizeof(int),
3104 .proc_handler = &cdrom_sysctl_handler,
3107 .ctl_name = DEV_CDROM_AUTOEJECT,
3108 .procname = "autoeject",
3109 .data = &cdrom_sysctl_settings.autoeject,
3110 .maxlen = sizeof(int),
3112 .proc_handler = &cdrom_sysctl_handler,
3115 .ctl_name = DEV_CDROM_DEBUG,
3116 .procname = "debug",
3117 .data = &cdrom_sysctl_settings.debug,
3118 .maxlen = sizeof(int),
3120 .proc_handler = &cdrom_sysctl_handler,
3123 .ctl_name = DEV_CDROM_LOCK,
3125 .data = &cdrom_sysctl_settings.lock,
3126 .maxlen = sizeof(int),
3128 .proc_handler = &cdrom_sysctl_handler,
3131 .ctl_name = DEV_CDROM_CHECK_MEDIA,
3132 .procname = "check_media",
3133 .data = &cdrom_sysctl_settings.check,
3134 .maxlen = sizeof(int),
3136 .proc_handler = &cdrom_sysctl_handler
3141 ctl_table cdrom_cdrom_table[] = {
3143 .ctl_name = DEV_CDROM,
3144 .procname = "cdrom",
3147 .child = cdrom_table,
3152 /* Make sure that /proc/sys/dev is there */
3153 ctl_table cdrom_root_table[] = {
3154 #ifdef CONFIG_PROC_FS
3156 .ctl_name = CTL_DEV,
3160 .child = cdrom_cdrom_table,
3162 #endif /* CONFIG_PROC_FS */
3165 static struct ctl_table_header *cdrom_sysctl_header;
3167 static void cdrom_sysctl_register(void)
3169 static int initialized;
3171 if (initialized == 1)
3174 cdrom_sysctl_header = register_sysctl_table(cdrom_root_table, 1);
3175 if (cdrom_root_table->ctl_name && cdrom_root_table->child->de)
3176 cdrom_root_table->child->de->owner = THIS_MODULE;
3178 /* set the defaults */
3179 cdrom_sysctl_settings.autoclose = autoclose;
3180 cdrom_sysctl_settings.autoeject = autoeject;
3181 cdrom_sysctl_settings.debug = debug;
3182 cdrom_sysctl_settings.lock = lockdoor;
3183 cdrom_sysctl_settings.check = check_media_type;
3188 static void cdrom_sysctl_unregister(void)
3190 if (cdrom_sysctl_header)
3191 unregister_sysctl_table(cdrom_sysctl_header);
3194 #endif /* CONFIG_SYSCTL */
3196 static int __init cdrom_init(void)
3198 #ifdef CONFIG_SYSCTL
3199 cdrom_sysctl_register();
3204 static void __exit cdrom_exit(void)
3206 printk(KERN_INFO "Uniform CD-ROM driver unloaded\n");
3207 #ifdef CONFIG_SYSCTL
3208 cdrom_sysctl_unregister();
3212 module_init(cdrom_init);
3213 module_exit(cdrom_exit);
3214 MODULE_LICENSE("GPL");