dm thin metadata: fix __udivdi3 undefined on 32-bit
[linux/fpc-iii.git] / drivers / cdrom / cdrom.c
blob1012b2cb6a165f0bbdc4966f9874def4969535dc
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. ;-)
17 To Do List:
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!
26 Revision History
27 ----------------------------------
28 1.00 Date Unknown -- David van Leeuwen <david@tm.tno.nl>
29 -- Initial version by David A. van Leeuwen. I don't have a detailed
30 changelog for the 1.x series, David?
32 2.00 Dec 2, 1997 -- Erik Andersen <andersee@debian.org>
33 -- New maintainer! As David A. van Leeuwen has been too busy to actively
34 maintain and improve this driver, I am now carrying on the torch. If
35 you have a problem with this driver, please feel free to contact me.
37 -- Added (rudimentary) sysctl interface. I realize this is really weak
38 right now, and is _very_ badly implemented. It will be improved...
40 -- Modified CDROM_DISC_STATUS so that it is now incorporated into
41 the Uniform CD-ROM driver via the cdrom_count_tracks function.
42 The cdrom_count_tracks function helps resolve some of the false
43 assumptions of the CDROM_DISC_STATUS ioctl, and is also used to check
44 for the correct media type when mounting or playing audio from a CD.
46 -- Remove the calls to verify_area and only use the copy_from_user and
47 copy_to_user stuff, since these calls now provide their own memory
48 checking with the 2.1.x kernels.
50 -- Major update to return codes so that errors from low-level drivers
51 are passed on through (thanks to Gerd Knorr for pointing out this
52 problem).
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
102 that bug.
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
107 should be...
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
120 CDC_CLOSE_TRAY.
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,
134 and lock.
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
143 correctly.
144 -- Fix up ioctl handling so the device specific ones actually get
145 called :).
147 3.02 Aug 8, 1999 - Jens Axboe <axboe@image.dk>
148 -- Fixed volume control on SCSI drives (or others with longer audio
149 page).
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
185 dvd_read_manufact.
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
199 home now.
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
217 back.
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 :-)
233 -- Locking fixes
234 -- Mt Rainier support
235 -- DVD-RAM write open fixes
237 Nov 5 2001, Aug 8 2002. Modified by Andy Polyakov
238 <appro@fy.chalmers.se> to support MMC-3 compliant DVD+RW units.
240 Modified by Nigel Kukard <nkukard@lbsd.net> - support DVD+RW
241 2.4.x patch by Andy Polyakov <appro@fy.chalmers.se>
243 -------------------------------------------------------------------------*/
245 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
247 #define REVISION "Revision: 3.20"
248 #define VERSION "Id: cdrom.c 3.20 2003/12/17"
250 /* I use an error-log mask to give fine grain control over the type of
251 messages dumped to the system logs. The available masks include: */
252 #define CD_NOTHING 0x0
253 #define CD_WARNING 0x1
254 #define CD_REG_UNREG 0x2
255 #define CD_DO_IOCTL 0x4
256 #define CD_OPEN 0x8
257 #define CD_CLOSE 0x10
258 #define CD_COUNT_TRACKS 0x20
259 #define CD_CHANGER 0x40
260 #define CD_DVD 0x80
262 /* Define this to remove _all_ the debugging messages */
263 /* #define ERRLOGMASK CD_NOTHING */
264 #define ERRLOGMASK CD_WARNING
265 /* #define ERRLOGMASK (CD_WARNING|CD_OPEN|CD_COUNT_TRACKS|CD_CLOSE) */
266 /* #define ERRLOGMASK (CD_WARNING|CD_REG_UNREG|CD_DO_IOCTL|CD_OPEN|CD_CLOSE|CD_COUNT_TRACKS) */
268 #include <linux/module.h>
269 #include <linux/fs.h>
270 #include <linux/major.h>
271 #include <linux/types.h>
272 #include <linux/errno.h>
273 #include <linux/kernel.h>
274 #include <linux/mm.h>
275 #include <linux/slab.h>
276 #include <linux/cdrom.h>
277 #include <linux/sysctl.h>
278 #include <linux/proc_fs.h>
279 #include <linux/blkpg.h>
280 #include <linux/init.h>
281 #include <linux/fcntl.h>
282 #include <linux/blkdev.h>
283 #include <linux/times.h>
285 #include <asm/uaccess.h>
287 /* used to tell the module to turn on full debugging messages */
288 static bool debug;
289 /* default compatibility mode */
290 static bool autoclose=1;
291 static bool autoeject;
292 static bool lockdoor = 1;
293 /* will we ever get to use this... sigh. */
294 static bool check_media_type;
295 /* automatically restart mrw format */
296 static bool mrw_format_restart = 1;
297 module_param(debug, bool, 0);
298 module_param(autoclose, bool, 0);
299 module_param(autoeject, bool, 0);
300 module_param(lockdoor, bool, 0);
301 module_param(check_media_type, bool, 0);
302 module_param(mrw_format_restart, bool, 0);
304 static DEFINE_MUTEX(cdrom_mutex);
306 static const char *mrw_format_status[] = {
307 "not mrw",
308 "bgformat inactive",
309 "bgformat active",
310 "mrw complete",
313 static const char *mrw_address_space[] = { "DMA", "GAA" };
315 #if (ERRLOGMASK != CD_NOTHING)
316 #define cd_dbg(type, fmt, ...) \
317 do { \
318 if ((ERRLOGMASK & type) || debug == 1) \
319 pr_debug(fmt, ##__VA_ARGS__); \
320 } while (0)
321 #else
322 #define cd_dbg(type, fmt, ...) \
323 do { \
324 if (0 && (ERRLOGMASK & type) || debug == 1) \
325 pr_debug(fmt, ##__VA_ARGS__); \
326 } while (0)
327 #endif
329 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
330 a lot of places. This macro makes the code more clear. */
331 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
334 * Another popular OS uses 7 seconds as the hard timeout for default
335 * commands, so it is a good choice for us as well.
337 #define CDROM_DEF_TIMEOUT (7 * HZ)
339 /* Not-exported routines. */
341 static void cdrom_sysctl_register(void);
343 static LIST_HEAD(cdrom_list);
345 static int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
346 struct packet_command *cgc)
348 if (cgc->sense) {
349 cgc->sense->sense_key = 0x05;
350 cgc->sense->asc = 0x20;
351 cgc->sense->ascq = 0x00;
354 cgc->stat = -EIO;
355 return -EIO;
358 static int cdrom_flush_cache(struct cdrom_device_info *cdi)
360 struct packet_command cgc;
362 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
363 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
365 cgc.timeout = 5 * 60 * HZ;
367 return cdi->ops->generic_packet(cdi, &cgc);
370 /* requires CD R/RW */
371 static int cdrom_get_disc_info(struct cdrom_device_info *cdi,
372 disc_information *di)
374 struct cdrom_device_ops *cdo = cdi->ops;
375 struct packet_command cgc;
376 int ret, buflen;
378 /* set up command and get the disc info */
379 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
380 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
381 cgc.cmd[8] = cgc.buflen = 2;
382 cgc.quiet = 1;
384 ret = cdo->generic_packet(cdi, &cgc);
385 if (ret)
386 return ret;
388 /* not all drives have the same disc_info length, so requeue
389 * packet with the length the drive tells us it can supply
391 buflen = be16_to_cpu(di->disc_information_length) +
392 sizeof(di->disc_information_length);
394 if (buflen > sizeof(disc_information))
395 buflen = sizeof(disc_information);
397 cgc.cmd[8] = cgc.buflen = buflen;
398 ret = cdo->generic_packet(cdi, &cgc);
399 if (ret)
400 return ret;
402 /* return actual fill size */
403 return buflen;
406 /* This macro makes sure we don't have to check on cdrom_device_ops
407 * existence in the run-time routines below. Change_capability is a
408 * hack to have the capability flags defined const, while we can still
409 * change it here without gcc complaining at every line.
411 #define ENSURE(call, bits) \
412 do { \
413 if (cdo->call == NULL) \
414 *change_capability &= ~(bits); \
415 } while (0)
418 * the first prototypes used 0x2c as the page code for the mrw mode page,
419 * subsequently this was changed to 0x03. probe the one used by this drive
421 static int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
423 struct packet_command cgc;
424 char buffer[16];
426 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
428 cgc.timeout = HZ;
429 cgc.quiet = 1;
431 if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
432 cdi->mrw_mode_page = MRW_MODE_PC;
433 return 0;
434 } else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
435 cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
436 return 0;
439 return 1;
442 static int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
444 struct packet_command cgc;
445 struct mrw_feature_desc *mfd;
446 unsigned char buffer[16];
447 int ret;
449 *write = 0;
451 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
453 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
454 cgc.cmd[3] = CDF_MRW;
455 cgc.cmd[8] = sizeof(buffer);
456 cgc.quiet = 1;
458 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
459 return ret;
461 mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
462 if (be16_to_cpu(mfd->feature_code) != CDF_MRW)
463 return 1;
464 *write = mfd->write;
466 if ((ret = cdrom_mrw_probe_pc(cdi))) {
467 *write = 0;
468 return ret;
471 return 0;
474 static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
476 struct packet_command cgc;
477 unsigned char buffer[12];
478 int ret;
480 pr_info("%sstarting format\n", cont ? "Re" : "");
483 * FmtData bit set (bit 4), format type is 1
485 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
486 cgc.cmd[0] = GPCMD_FORMAT_UNIT;
487 cgc.cmd[1] = (1 << 4) | 1;
489 cgc.timeout = 5 * 60 * HZ;
492 * 4 byte format list header, 8 byte format list descriptor
494 buffer[1] = 1 << 1;
495 buffer[3] = 8;
498 * nr_blocks field
500 buffer[4] = 0xff;
501 buffer[5] = 0xff;
502 buffer[6] = 0xff;
503 buffer[7] = 0xff;
505 buffer[8] = 0x24 << 2;
506 buffer[11] = cont;
508 ret = cdi->ops->generic_packet(cdi, &cgc);
509 if (ret)
510 pr_info("bgformat failed\n");
512 return ret;
515 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
517 struct packet_command cgc;
519 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
520 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
523 * Session = 1, Track = 0
525 cgc.cmd[1] = !!immed;
526 cgc.cmd[2] = 1 << 1;
528 cgc.timeout = 5 * 60 * HZ;
530 return cdi->ops->generic_packet(cdi, &cgc);
533 static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
535 disc_information di;
536 int ret;
538 ret = cdrom_get_disc_info(cdi, &di);
539 if (ret < 0 || ret < (int)offsetof(typeof(di),disc_type))
540 return 1;
542 ret = 0;
543 if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
544 pr_info("issuing MRW background format suspend\n");
545 ret = cdrom_mrw_bgformat_susp(cdi, 0);
548 if (!ret && cdi->media_written)
549 ret = cdrom_flush_cache(cdi);
551 return ret;
554 static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
556 struct packet_command cgc;
557 struct mode_page_header *mph;
558 char buffer[16];
559 int ret, offset, size;
561 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
563 cgc.buffer = buffer;
564 cgc.buflen = sizeof(buffer);
566 ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0);
567 if (ret)
568 return ret;
570 mph = (struct mode_page_header *)buffer;
571 offset = be16_to_cpu(mph->desc_length);
572 size = be16_to_cpu(mph->mode_data_length) + 2;
574 buffer[offset + 3] = space;
575 cgc.buflen = size;
577 ret = cdrom_mode_select(cdi, &cgc);
578 if (ret)
579 return ret;
581 pr_info("%s: mrw address space %s selected\n",
582 cdi->name, mrw_address_space[space]);
583 return 0;
586 int register_cdrom(struct cdrom_device_info *cdi)
588 static char banner_printed;
589 struct cdrom_device_ops *cdo = cdi->ops;
590 int *change_capability = (int *)&cdo->capability; /* hack */
592 cd_dbg(CD_OPEN, "entering register_cdrom\n");
594 if (cdo->open == NULL || cdo->release == NULL)
595 return -EINVAL;
596 if (!banner_printed) {
597 pr_info("Uniform CD-ROM driver " REVISION "\n");
598 banner_printed = 1;
599 cdrom_sysctl_register();
602 ENSURE(drive_status, CDC_DRIVE_STATUS);
603 if (cdo->check_events == NULL && cdo->media_changed == NULL)
604 *change_capability = ~(CDC_MEDIA_CHANGED | CDC_SELECT_DISC);
605 ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
606 ENSURE(lock_door, CDC_LOCK);
607 ENSURE(select_speed, CDC_SELECT_SPEED);
608 ENSURE(get_last_session, CDC_MULTI_SESSION);
609 ENSURE(get_mcn, CDC_MCN);
610 ENSURE(reset, CDC_RESET);
611 ENSURE(generic_packet, CDC_GENERIC_PACKET);
612 cdi->mc_flags = 0;
613 cdo->n_minors = 0;
614 cdi->options = CDO_USE_FFLAGS;
616 if (autoclose == 1 && CDROM_CAN(CDC_CLOSE_TRAY))
617 cdi->options |= (int) CDO_AUTO_CLOSE;
618 if (autoeject == 1 && CDROM_CAN(CDC_OPEN_TRAY))
619 cdi->options |= (int) CDO_AUTO_EJECT;
620 if (lockdoor == 1)
621 cdi->options |= (int) CDO_LOCK;
622 if (check_media_type == 1)
623 cdi->options |= (int) CDO_CHECK_TYPE;
625 if (CDROM_CAN(CDC_MRW_W))
626 cdi->exit = cdrom_mrw_exit;
628 if (cdi->disk)
629 cdi->cdda_method = CDDA_BPC_FULL;
630 else
631 cdi->cdda_method = CDDA_OLD;
633 if (!cdo->generic_packet)
634 cdo->generic_packet = cdrom_dummy_generic_packet;
636 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
637 mutex_lock(&cdrom_mutex);
638 list_add(&cdi->list, &cdrom_list);
639 mutex_unlock(&cdrom_mutex);
640 return 0;
642 #undef ENSURE
644 void unregister_cdrom(struct cdrom_device_info *cdi)
646 cd_dbg(CD_OPEN, "entering unregister_cdrom\n");
648 mutex_lock(&cdrom_mutex);
649 list_del(&cdi->list);
650 mutex_unlock(&cdrom_mutex);
652 if (cdi->exit)
653 cdi->exit(cdi);
655 cdi->ops->n_minors--;
656 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
659 int cdrom_get_media_event(struct cdrom_device_info *cdi,
660 struct media_event_desc *med)
662 struct packet_command cgc;
663 unsigned char buffer[8];
664 struct event_header *eh = (struct event_header *)buffer;
666 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
667 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
668 cgc.cmd[1] = 1; /* IMMED */
669 cgc.cmd[4] = 1 << 4; /* media event */
670 cgc.cmd[8] = sizeof(buffer);
671 cgc.quiet = 1;
673 if (cdi->ops->generic_packet(cdi, &cgc))
674 return 1;
676 if (be16_to_cpu(eh->data_len) < sizeof(*med))
677 return 1;
679 if (eh->nea || eh->notification_class != 0x4)
680 return 1;
682 memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
683 return 0;
686 static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
687 struct rwrt_feature_desc *rfd)
689 struct packet_command cgc;
690 char buffer[24];
691 int ret;
693 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
695 cgc.cmd[0] = GPCMD_GET_CONFIGURATION; /* often 0x46 */
696 cgc.cmd[3] = CDF_RWRT; /* often 0x0020 */
697 cgc.cmd[8] = sizeof(buffer); /* often 0x18 */
698 cgc.quiet = 1;
700 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
701 return ret;
703 memcpy(rfd, &buffer[sizeof(struct feature_header)], sizeof (*rfd));
704 return 0;
707 static int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
709 struct packet_command cgc;
710 char buffer[16];
711 __be16 *feature_code;
712 int ret;
714 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
716 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
717 cgc.cmd[3] = CDF_HWDM;
718 cgc.cmd[8] = sizeof(buffer);
719 cgc.quiet = 1;
721 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
722 return ret;
724 feature_code = (__be16 *) &buffer[sizeof(struct feature_header)];
725 if (be16_to_cpu(*feature_code) == CDF_HWDM)
726 return 0;
728 return 1;
732 static int cdrom_is_random_writable(struct cdrom_device_info *cdi, int *write)
734 struct rwrt_feature_desc rfd;
735 int ret;
737 *write = 0;
739 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
740 return ret;
742 if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
743 *write = 1;
745 return 0;
748 static int cdrom_media_erasable(struct cdrom_device_info *cdi)
750 disc_information di;
751 int ret;
753 ret = cdrom_get_disc_info(cdi, &di);
754 if (ret < 0 || ret < offsetof(typeof(di), n_first_track))
755 return -1;
757 return di.erasable;
761 * FIXME: check RO bit
763 static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
765 int ret = cdrom_media_erasable(cdi);
768 * allow writable open if media info read worked and media is
769 * erasable, _or_ if it fails since not all drives support it
771 if (!ret)
772 return 1;
774 return 0;
777 static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
779 disc_information di;
780 int ret;
783 * always reset to DMA lba space on open
785 if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_DMA)) {
786 pr_err("failed setting lba address space\n");
787 return 1;
790 ret = cdrom_get_disc_info(cdi, &di);
791 if (ret < 0 || ret < offsetof(typeof(di),disc_type))
792 return 1;
794 if (!di.erasable)
795 return 1;
798 * mrw_status
799 * 0 - not MRW formatted
800 * 1 - MRW bgformat started, but not running or complete
801 * 2 - MRW bgformat in progress
802 * 3 - MRW formatting complete
804 ret = 0;
805 pr_info("open: mrw_status '%s'\n", mrw_format_status[di.mrw_status]);
806 if (!di.mrw_status)
807 ret = 1;
808 else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE &&
809 mrw_format_restart)
810 ret = cdrom_mrw_bgformat(cdi, 1);
812 return ret;
815 static int mo_open_write(struct cdrom_device_info *cdi)
817 struct packet_command cgc;
818 char buffer[255];
819 int ret;
821 init_cdrom_command(&cgc, &buffer, 4, CGC_DATA_READ);
822 cgc.quiet = 1;
825 * obtain write protect information as per
826 * drivers/scsi/sd.c:sd_read_write_protect_flag
829 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
830 if (ret)
831 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_VENDOR_PAGE, 0);
832 if (ret) {
833 cgc.buflen = 255;
834 ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
837 /* drive gave us no info, let the user go ahead */
838 if (ret)
839 return 0;
841 return buffer[3] & 0x80;
844 static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
846 struct rwrt_feature_desc rfd;
847 int ret;
849 if ((ret = cdrom_has_defect_mgt(cdi)))
850 return ret;
852 if ((ret = cdrom_get_random_writable(cdi, &rfd)))
853 return ret;
854 else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
855 ret = !rfd.curr;
857 cd_dbg(CD_OPEN, "can open for random write\n");
858 return ret;
861 static void cdrom_mmc3_profile(struct cdrom_device_info *cdi)
863 struct packet_command cgc;
864 char buffer[32];
865 int ret, mmc3_profile;
867 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
869 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
870 cgc.cmd[1] = 0;
871 cgc.cmd[2] = cgc.cmd[3] = 0; /* Starting Feature Number */
872 cgc.cmd[8] = sizeof(buffer); /* Allocation Length */
873 cgc.quiet = 1;
875 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
876 mmc3_profile = 0xffff;
877 else
878 mmc3_profile = (buffer[6] << 8) | buffer[7];
880 cdi->mmc3_profile = mmc3_profile;
883 static int cdrom_is_dvd_rw(struct cdrom_device_info *cdi)
885 switch (cdi->mmc3_profile) {
886 case 0x12: /* DVD-RAM */
887 case 0x1A: /* DVD+RW */
888 case 0x43: /* BD-RE */
889 return 0;
890 default:
891 return 1;
896 * returns 0 for ok to open write, non-0 to disallow
898 static int cdrom_open_write(struct cdrom_device_info *cdi)
900 int mrw, mrw_write, ram_write;
901 int ret = 1;
903 mrw = 0;
904 if (!cdrom_is_mrw(cdi, &mrw_write))
905 mrw = 1;
907 if (CDROM_CAN(CDC_MO_DRIVE))
908 ram_write = 1;
909 else
910 (void) cdrom_is_random_writable(cdi, &ram_write);
912 if (mrw)
913 cdi->mask &= ~CDC_MRW;
914 else
915 cdi->mask |= CDC_MRW;
917 if (mrw_write)
918 cdi->mask &= ~CDC_MRW_W;
919 else
920 cdi->mask |= CDC_MRW_W;
922 if (ram_write)
923 cdi->mask &= ~CDC_RAM;
924 else
925 cdi->mask |= CDC_RAM;
927 if (CDROM_CAN(CDC_MRW_W))
928 ret = cdrom_mrw_open_write(cdi);
929 else if (CDROM_CAN(CDC_DVD_RAM))
930 ret = cdrom_dvdram_open_write(cdi);
931 else if (CDROM_CAN(CDC_RAM) &&
932 !CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW|CDC_MO_DRIVE))
933 ret = cdrom_ram_open_write(cdi);
934 else if (CDROM_CAN(CDC_MO_DRIVE))
935 ret = mo_open_write(cdi);
936 else if (!cdrom_is_dvd_rw(cdi))
937 ret = 0;
939 return ret;
942 static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
944 struct packet_command cgc;
946 if (cdi->mmc3_profile != 0x1a) {
947 cd_dbg(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
948 return;
951 if (!cdi->media_written) {
952 cd_dbg(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
953 return;
956 pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi->name);
958 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
959 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
960 cgc.timeout = 30*HZ;
961 cdi->ops->generic_packet(cdi, &cgc);
963 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
964 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
965 cgc.timeout = 3000*HZ;
966 cgc.quiet = 1;
967 cdi->ops->generic_packet(cdi, &cgc);
969 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
970 cgc.cmd[0] = GPCMD_CLOSE_TRACK;
971 cgc.cmd[2] = 2; /* Close session */
972 cgc.quiet = 1;
973 cgc.timeout = 3000*HZ;
974 cdi->ops->generic_packet(cdi, &cgc);
976 cdi->media_written = 0;
979 static int cdrom_close_write(struct cdrom_device_info *cdi)
981 #if 0
982 return cdrom_flush_cache(cdi);
983 #else
984 return 0;
985 #endif
988 /* badly broken, I know. Is due for a fixup anytime. */
989 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype *tracks)
991 struct cdrom_tochdr header;
992 struct cdrom_tocentry entry;
993 int ret, i;
994 tracks->data = 0;
995 tracks->audio = 0;
996 tracks->cdi = 0;
997 tracks->xa = 0;
998 tracks->error = 0;
999 cd_dbg(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1000 /* Grab the TOC header so we can see how many tracks there are */
1001 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
1002 if (ret) {
1003 if (ret == -ENOMEDIUM)
1004 tracks->error = CDS_NO_DISC;
1005 else
1006 tracks->error = CDS_NO_INFO;
1007 return;
1009 /* check what type of tracks are on this disc */
1010 entry.cdte_format = CDROM_MSF;
1011 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1012 entry.cdte_track = i;
1013 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1014 tracks->error = CDS_NO_INFO;
1015 return;
1017 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1018 if (entry.cdte_format == 0x10)
1019 tracks->cdi++;
1020 else if (entry.cdte_format == 0x20)
1021 tracks->xa++;
1022 else
1023 tracks->data++;
1024 } else {
1025 tracks->audio++;
1027 cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1028 i, entry.cdte_format, entry.cdte_ctrl);
1030 cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1031 header.cdth_trk1, tracks->audio, tracks->data,
1032 tracks->cdi, tracks->xa);
1035 static
1036 int open_for_data(struct cdrom_device_info *cdi)
1038 int ret;
1039 struct cdrom_device_ops *cdo = cdi->ops;
1040 tracktype tracks;
1041 cd_dbg(CD_OPEN, "entering open_for_data\n");
1042 /* Check if the driver can report drive status. If it can, we
1043 can do clever things. If it can't, well, we at least tried! */
1044 if (cdo->drive_status != NULL) {
1045 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1046 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1047 if (ret == CDS_TRAY_OPEN) {
1048 cd_dbg(CD_OPEN, "the tray is open...\n");
1049 /* can/may i close it? */
1050 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1051 cdi->options & CDO_AUTO_CLOSE) {
1052 cd_dbg(CD_OPEN, "trying to close the tray\n");
1053 ret=cdo->tray_move(cdi,0);
1054 if (ret) {
1055 cd_dbg(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1056 /* Ignore the error from the low
1057 level driver. We don't care why it
1058 couldn't close the tray. We only care
1059 that there is no disc in the drive,
1060 since that is the _REAL_ problem here.*/
1061 ret=-ENOMEDIUM;
1062 goto clean_up_and_return;
1064 } else {
1065 cd_dbg(CD_OPEN, "bummer. this drive can't close the tray.\n");
1066 ret=-ENOMEDIUM;
1067 goto clean_up_and_return;
1069 /* Ok, the door should be closed now.. Check again */
1070 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1071 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1072 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1073 cd_dbg(CD_OPEN, "tray might not contain a medium\n");
1074 ret=-ENOMEDIUM;
1075 goto clean_up_and_return;
1077 cd_dbg(CD_OPEN, "the tray is now closed\n");
1079 /* the door should be closed now, check for the disc */
1080 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1081 if (ret!=CDS_DISC_OK) {
1082 ret = -ENOMEDIUM;
1083 goto clean_up_and_return;
1086 cdrom_count_tracks(cdi, &tracks);
1087 if (tracks.error == CDS_NO_DISC) {
1088 cd_dbg(CD_OPEN, "bummer. no disc.\n");
1089 ret=-ENOMEDIUM;
1090 goto clean_up_and_return;
1092 /* CD-Players which don't use O_NONBLOCK, workman
1093 * for example, need bit CDO_CHECK_TYPE cleared! */
1094 if (tracks.data==0) {
1095 if (cdi->options & CDO_CHECK_TYPE) {
1096 /* give people a warning shot, now that CDO_CHECK_TYPE
1097 is the default case! */
1098 cd_dbg(CD_OPEN, "bummer. wrong media type.\n");
1099 cd_dbg(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1100 (unsigned int)task_pid_nr(current));
1101 ret=-EMEDIUMTYPE;
1102 goto clean_up_and_return;
1104 else {
1105 cd_dbg(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set\n");
1109 cd_dbg(CD_OPEN, "all seems well, opening the devicen");
1111 /* all seems well, we can open the device */
1112 ret = cdo->open(cdi, 0); /* open for data */
1113 cd_dbg(CD_OPEN, "opening the device gave me %d\n", ret);
1114 /* After all this careful checking, we shouldn't have problems
1115 opening the device, but we don't want the device locked if
1116 this somehow fails... */
1117 if (ret) {
1118 cd_dbg(CD_OPEN, "open device failed\n");
1119 goto clean_up_and_return;
1121 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1122 cdo->lock_door(cdi, 1);
1123 cd_dbg(CD_OPEN, "door locked\n");
1125 cd_dbg(CD_OPEN, "device opened successfully\n");
1126 return ret;
1128 /* Something failed. Try to unlock the drive, because some drivers
1129 (notably ide-cd) lock the drive after every command. This produced
1130 a nasty bug where after mount failed, the drive would remain locked!
1131 This ensures that the drive gets unlocked after a mount fails. This
1132 is a goto to avoid bloating the driver with redundant code. */
1133 clean_up_and_return:
1134 cd_dbg(CD_OPEN, "open failed\n");
1135 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1136 cdo->lock_door(cdi, 0);
1137 cd_dbg(CD_OPEN, "door unlocked\n");
1139 return ret;
1142 /* We use the open-option O_NONBLOCK to indicate that the
1143 * purpose of opening is only for subsequent ioctl() calls; no device
1144 * integrity checks are performed.
1146 * We hope that all cd-player programs will adopt this convention. It
1147 * is in their own interest: device control becomes a lot easier
1148 * this way.
1150 int cdrom_open(struct cdrom_device_info *cdi, struct block_device *bdev,
1151 fmode_t mode)
1153 int ret;
1155 cd_dbg(CD_OPEN, "entering cdrom_open\n");
1157 /* if this was a O_NONBLOCK open and we should honor the flags,
1158 * do a quick open without drive/disc integrity checks. */
1159 cdi->use_count++;
1160 if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) {
1161 ret = cdi->ops->open(cdi, 1);
1162 } else {
1163 ret = open_for_data(cdi);
1164 if (ret)
1165 goto err;
1166 cdrom_mmc3_profile(cdi);
1167 if (mode & FMODE_WRITE) {
1168 ret = -EROFS;
1169 if (cdrom_open_write(cdi))
1170 goto err_release;
1171 if (!CDROM_CAN(CDC_RAM))
1172 goto err_release;
1173 ret = 0;
1174 cdi->media_written = 0;
1178 if (ret)
1179 goto err;
1181 cd_dbg(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1182 cdi->name, cdi->use_count);
1183 return 0;
1184 err_release:
1185 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1186 cdi->ops->lock_door(cdi, 0);
1187 cd_dbg(CD_OPEN, "door unlocked\n");
1189 cdi->ops->release(cdi);
1190 err:
1191 cdi->use_count--;
1192 return ret;
1195 /* This code is similar to that in open_for_data. The routine is called
1196 whenever an audio play operation is requested.
1198 static int check_for_audio_disc(struct cdrom_device_info * cdi,
1199 struct cdrom_device_ops * cdo)
1201 int ret;
1202 tracktype tracks;
1203 cd_dbg(CD_OPEN, "entering check_for_audio_disc\n");
1204 if (!(cdi->options & CDO_CHECK_TYPE))
1205 return 0;
1206 if (cdo->drive_status != NULL) {
1207 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1208 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1209 if (ret == CDS_TRAY_OPEN) {
1210 cd_dbg(CD_OPEN, "the tray is open...\n");
1211 /* can/may i close it? */
1212 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1213 cdi->options & CDO_AUTO_CLOSE) {
1214 cd_dbg(CD_OPEN, "trying to close the tray\n");
1215 ret=cdo->tray_move(cdi,0);
1216 if (ret) {
1217 cd_dbg(CD_OPEN, "bummer. tried to close tray but failed.\n");
1218 /* Ignore the error from the low
1219 level driver. We don't care why it
1220 couldn't close the tray. We only care
1221 that there is no disc in the drive,
1222 since that is the _REAL_ problem here.*/
1223 return -ENOMEDIUM;
1225 } else {
1226 cd_dbg(CD_OPEN, "bummer. this driver can't close the tray.\n");
1227 return -ENOMEDIUM;
1229 /* Ok, the door should be closed now.. Check again */
1230 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1231 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1232 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1233 return -ENOMEDIUM;
1235 if (ret!=CDS_DISC_OK) {
1236 cd_dbg(CD_OPEN, "bummer. disc isn't ready.\n");
1237 return -EIO;
1239 cd_dbg(CD_OPEN, "the tray is now closed\n");
1242 cdrom_count_tracks(cdi, &tracks);
1243 if (tracks.error)
1244 return(tracks.error);
1246 if (tracks.audio==0)
1247 return -EMEDIUMTYPE;
1249 return 0;
1252 void cdrom_release(struct cdrom_device_info *cdi, fmode_t mode)
1254 struct cdrom_device_ops *cdo = cdi->ops;
1255 int opened_for_data;
1257 cd_dbg(CD_CLOSE, "entering cdrom_release\n");
1259 if (cdi->use_count > 0)
1260 cdi->use_count--;
1262 if (cdi->use_count == 0) {
1263 cd_dbg(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n",
1264 cdi->name);
1265 cdrom_dvd_rw_close_write(cdi);
1267 if ((cdo->capability & CDC_LOCK) && !cdi->keeplocked) {
1268 cd_dbg(CD_CLOSE, "Unlocking door!\n");
1269 cdo->lock_door(cdi, 0);
1273 opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1274 !(mode & FMODE_NDELAY);
1277 * flush cache on last write release
1279 if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1280 cdrom_close_write(cdi);
1282 cdo->release(cdi);
1283 if (cdi->use_count == 0) { /* last process that closes dev*/
1284 if (opened_for_data &&
1285 cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1286 cdo->tray_move(cdi, 1);
1290 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1291 struct cdrom_changer_info *buf)
1293 struct packet_command cgc;
1294 struct cdrom_device_ops *cdo = cdi->ops;
1295 int length;
1298 * Sanyo changer isn't spec compliant (doesn't use regular change
1299 * LOAD_UNLOAD command, and it doesn't implement the mech status
1300 * command below
1302 if (cdi->sanyo_slot) {
1303 buf->hdr.nslots = 3;
1304 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1305 for (length = 0; length < 3; length++) {
1306 buf->slots[length].disc_present = 1;
1307 buf->slots[length].change = 0;
1309 return 0;
1312 length = sizeof(struct cdrom_mechstat_header) +
1313 cdi->capacity * sizeof(struct cdrom_slot);
1315 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1316 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1317 cgc.cmd[8] = (length >> 8) & 0xff;
1318 cgc.cmd[9] = length & 0xff;
1319 return cdo->generic_packet(cdi, &cgc);
1322 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1324 struct cdrom_changer_info *info;
1325 int ret;
1327 cd_dbg(CD_CHANGER, "entering cdrom_slot_status()\n");
1328 if (cdi->sanyo_slot)
1329 return CDS_NO_INFO;
1331 info = kmalloc(sizeof(*info), GFP_KERNEL);
1332 if (!info)
1333 return -ENOMEM;
1335 if ((ret = cdrom_read_mech_status(cdi, info)))
1336 goto out_free;
1338 if (info->slots[slot].disc_present)
1339 ret = CDS_DISC_OK;
1340 else
1341 ret = CDS_NO_DISC;
1343 out_free:
1344 kfree(info);
1345 return ret;
1348 /* Return the number of slots for an ATAPI/SCSI cdrom,
1349 * return 1 if not a changer.
1351 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1353 int status;
1354 int nslots = 1;
1355 struct cdrom_changer_info *info;
1357 cd_dbg(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1358 /* cdrom_read_mech_status requires a valid value for capacity: */
1359 cdi->capacity = 0;
1361 info = kmalloc(sizeof(*info), GFP_KERNEL);
1362 if (!info)
1363 return -ENOMEM;
1365 if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1366 nslots = info->hdr.nslots;
1368 kfree(info);
1369 return nslots;
1373 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1374 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1376 struct packet_command cgc;
1378 cd_dbg(CD_CHANGER, "entering cdrom_load_unload()\n");
1379 if (cdi->sanyo_slot && slot < 0)
1380 return 0;
1382 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1383 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1384 cgc.cmd[4] = 2 + (slot >= 0);
1385 cgc.cmd[8] = slot;
1386 cgc.timeout = 60 * HZ;
1388 /* The Sanyo 3 CD changer uses byte 7 of the
1389 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1390 using the GPCMD_LOAD_UNLOAD opcode. */
1391 if (cdi->sanyo_slot && -1 < slot) {
1392 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1393 cgc.cmd[7] = slot;
1394 cgc.cmd[4] = cgc.cmd[8] = 0;
1395 cdi->sanyo_slot = slot ? slot : 3;
1398 return cdi->ops->generic_packet(cdi, &cgc);
1401 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1403 struct cdrom_changer_info *info;
1404 int curslot;
1405 int ret;
1407 cd_dbg(CD_CHANGER, "entering cdrom_select_disc()\n");
1408 if (!CDROM_CAN(CDC_SELECT_DISC))
1409 return -EDRIVE_CANT_DO_THIS;
1411 if (cdi->ops->check_events)
1412 cdi->ops->check_events(cdi, 0, slot);
1413 else
1414 cdi->ops->media_changed(cdi, slot);
1416 if (slot == CDSL_NONE) {
1417 /* set media changed bits, on both queues */
1418 cdi->mc_flags = 0x3;
1419 return cdrom_load_unload(cdi, -1);
1422 info = kmalloc(sizeof(*info), GFP_KERNEL);
1423 if (!info)
1424 return -ENOMEM;
1426 if ((ret = cdrom_read_mech_status(cdi, info))) {
1427 kfree(info);
1428 return ret;
1431 curslot = info->hdr.curslot;
1432 kfree(info);
1434 if (cdi->use_count > 1 || cdi->keeplocked) {
1435 if (slot == CDSL_CURRENT) {
1436 return curslot;
1437 } else {
1438 return -EBUSY;
1442 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1443 which is useful if it had been previously unloaded.
1444 Whether it can or not, it returns the current slot.
1445 Similarly, if slot happens to be the current one, we still
1446 try and load it. */
1447 if (slot == CDSL_CURRENT)
1448 slot = curslot;
1450 /* set media changed bits on both queues */
1451 cdi->mc_flags = 0x3;
1452 if ((ret = cdrom_load_unload(cdi, slot)))
1453 return ret;
1455 return slot;
1459 * As cdrom implements an extra ioctl consumer for media changed
1460 * event, it needs to buffer ->check_events() output, such that event
1461 * is not lost for both the usual VFS and ioctl paths.
1462 * cdi->{vfs|ioctl}_events are used to buffer pending events for each
1463 * path.
1465 * XXX: Locking is non-existent. cdi->ops->check_events() can be
1466 * called in parallel and buffering fields are accessed without any
1467 * exclusion. The original media_changed code had the same problem.
1468 * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1469 * and remove this cruft altogether. It doesn't have much usefulness
1470 * at this point.
1472 static void cdrom_update_events(struct cdrom_device_info *cdi,
1473 unsigned int clearing)
1475 unsigned int events;
1477 events = cdi->ops->check_events(cdi, clearing, CDSL_CURRENT);
1478 cdi->vfs_events |= events;
1479 cdi->ioctl_events |= events;
1482 unsigned int cdrom_check_events(struct cdrom_device_info *cdi,
1483 unsigned int clearing)
1485 unsigned int events;
1487 cdrom_update_events(cdi, clearing);
1488 events = cdi->vfs_events;
1489 cdi->vfs_events = 0;
1490 return events;
1492 EXPORT_SYMBOL(cdrom_check_events);
1494 /* We want to make media_changed accessible to the user through an
1495 * ioctl. The main problem now is that we must double-buffer the
1496 * low-level implementation, to assure that the VFS and the user both
1497 * see a medium change once.
1500 static
1501 int media_changed(struct cdrom_device_info *cdi, int queue)
1503 unsigned int mask = (1 << (queue & 1));
1504 int ret = !!(cdi->mc_flags & mask);
1505 bool changed;
1507 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1508 return ret;
1510 /* changed since last call? */
1511 if (cdi->ops->check_events) {
1512 BUG_ON(!queue); /* shouldn't be called from VFS path */
1513 cdrom_update_events(cdi, DISK_EVENT_MEDIA_CHANGE);
1514 changed = cdi->ioctl_events & DISK_EVENT_MEDIA_CHANGE;
1515 cdi->ioctl_events = 0;
1516 } else
1517 changed = cdi->ops->media_changed(cdi, CDSL_CURRENT);
1519 if (changed) {
1520 cdi->mc_flags = 0x3; /* set bit on both queues */
1521 ret |= 1;
1522 cdi->media_written = 0;
1525 cdi->mc_flags &= ~mask; /* clear bit */
1526 return ret;
1529 int cdrom_media_changed(struct cdrom_device_info *cdi)
1531 /* This talks to the VFS, which doesn't like errors - just 1 or 0.
1532 * Returning "0" is always safe (media hasn't been changed). Do that
1533 * if the low-level cdrom driver dosn't support media changed. */
1534 if (cdi == NULL || cdi->ops->media_changed == NULL)
1535 return 0;
1536 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1537 return 0;
1538 return media_changed(cdi, 0);
1541 /* Requests to the low-level drivers will /always/ be done in the
1542 following format convention:
1544 CDROM_LBA: all data-related requests.
1545 CDROM_MSF: all audio-related requests.
1547 However, a low-level implementation is allowed to refuse this
1548 request, and return information in its own favorite format.
1550 It doesn't make sense /at all/ to ask for a play_audio in LBA
1551 format, or ask for multi-session info in MSF format. However, for
1552 backward compatibility these format requests will be satisfied, but
1553 the requests to the low-level drivers will be sanitized in the more
1554 meaningful format indicated above.
1557 static
1558 void sanitize_format(union cdrom_addr *addr,
1559 u_char * curr, u_char requested)
1561 if (*curr == requested)
1562 return; /* nothing to be done! */
1563 if (requested == CDROM_LBA) {
1564 addr->lba = (int) addr->msf.frame +
1565 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1566 } else { /* CDROM_MSF */
1567 int lba = addr->lba;
1568 addr->msf.frame = lba % 75;
1569 lba /= 75;
1570 lba += 2;
1571 addr->msf.second = lba % 60;
1572 addr->msf.minute = lba / 60;
1574 *curr = requested;
1577 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1578 int type)
1580 memset(cgc, 0, sizeof(struct packet_command));
1581 if (buf)
1582 memset(buf, 0, len);
1583 cgc->buffer = (char *) buf;
1584 cgc->buflen = len;
1585 cgc->data_direction = type;
1586 cgc->timeout = CDROM_DEF_TIMEOUT;
1589 /* DVD handling */
1591 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1592 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1594 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1596 cgc->cmd[0] = GPCMD_REPORT_KEY;
1597 cgc->cmd[10] = type | (agid << 6);
1598 switch (type) {
1599 case 0: case 8: case 5: {
1600 cgc->buflen = 8;
1601 break;
1603 case 1: {
1604 cgc->buflen = 16;
1605 break;
1607 case 2: case 4: {
1608 cgc->buflen = 12;
1609 break;
1612 cgc->cmd[9] = cgc->buflen;
1613 cgc->data_direction = CGC_DATA_READ;
1616 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1618 cgc->cmd[0] = GPCMD_SEND_KEY;
1619 cgc->cmd[10] = type | (agid << 6);
1620 switch (type) {
1621 case 1: {
1622 cgc->buflen = 16;
1623 break;
1625 case 3: {
1626 cgc->buflen = 12;
1627 break;
1629 case 6: {
1630 cgc->buflen = 8;
1631 break;
1634 cgc->cmd[9] = cgc->buflen;
1635 cgc->data_direction = CGC_DATA_WRITE;
1638 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1640 int ret;
1641 u_char buf[20];
1642 struct packet_command cgc;
1643 struct cdrom_device_ops *cdo = cdi->ops;
1644 rpc_state_t rpc_state;
1646 memset(buf, 0, sizeof(buf));
1647 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1649 switch (ai->type) {
1650 /* LU data send */
1651 case DVD_LU_SEND_AGID:
1652 cd_dbg(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1653 cgc.quiet = 1;
1654 setup_report_key(&cgc, ai->lsa.agid, 0);
1656 if ((ret = cdo->generic_packet(cdi, &cgc)))
1657 return ret;
1659 ai->lsa.agid = buf[7] >> 6;
1660 /* Returning data, let host change state */
1661 break;
1663 case DVD_LU_SEND_KEY1:
1664 cd_dbg(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1665 setup_report_key(&cgc, ai->lsk.agid, 2);
1667 if ((ret = cdo->generic_packet(cdi, &cgc)))
1668 return ret;
1670 copy_key(ai->lsk.key, &buf[4]);
1671 /* Returning data, let host change state */
1672 break;
1674 case DVD_LU_SEND_CHALLENGE:
1675 cd_dbg(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1676 setup_report_key(&cgc, ai->lsc.agid, 1);
1678 if ((ret = cdo->generic_packet(cdi, &cgc)))
1679 return ret;
1681 copy_chal(ai->lsc.chal, &buf[4]);
1682 /* Returning data, let host change state */
1683 break;
1685 /* Post-auth key */
1686 case DVD_LU_SEND_TITLE_KEY:
1687 cd_dbg(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1688 cgc.quiet = 1;
1689 setup_report_key(&cgc, ai->lstk.agid, 4);
1690 cgc.cmd[5] = ai->lstk.lba;
1691 cgc.cmd[4] = ai->lstk.lba >> 8;
1692 cgc.cmd[3] = ai->lstk.lba >> 16;
1693 cgc.cmd[2] = ai->lstk.lba >> 24;
1695 if ((ret = cdo->generic_packet(cdi, &cgc)))
1696 return ret;
1698 ai->lstk.cpm = (buf[4] >> 7) & 1;
1699 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1700 ai->lstk.cgms = (buf[4] >> 4) & 3;
1701 copy_key(ai->lstk.title_key, &buf[5]);
1702 /* Returning data, let host change state */
1703 break;
1705 case DVD_LU_SEND_ASF:
1706 cd_dbg(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1707 setup_report_key(&cgc, ai->lsasf.agid, 5);
1709 if ((ret = cdo->generic_packet(cdi, &cgc)))
1710 return ret;
1712 ai->lsasf.asf = buf[7] & 1;
1713 break;
1715 /* LU data receive (LU changes state) */
1716 case DVD_HOST_SEND_CHALLENGE:
1717 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1718 setup_send_key(&cgc, ai->hsc.agid, 1);
1719 buf[1] = 0xe;
1720 copy_chal(&buf[4], ai->hsc.chal);
1722 if ((ret = cdo->generic_packet(cdi, &cgc)))
1723 return ret;
1725 ai->type = DVD_LU_SEND_KEY1;
1726 break;
1728 case DVD_HOST_SEND_KEY2:
1729 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1730 setup_send_key(&cgc, ai->hsk.agid, 3);
1731 buf[1] = 0xa;
1732 copy_key(&buf[4], ai->hsk.key);
1734 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1735 ai->type = DVD_AUTH_FAILURE;
1736 return ret;
1738 ai->type = DVD_AUTH_ESTABLISHED;
1739 break;
1741 /* Misc */
1742 case DVD_INVALIDATE_AGID:
1743 cgc.quiet = 1;
1744 cd_dbg(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1745 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1746 if ((ret = cdo->generic_packet(cdi, &cgc)))
1747 return ret;
1748 break;
1750 /* Get region settings */
1751 case DVD_LU_SEND_RPC_STATE:
1752 cd_dbg(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1753 setup_report_key(&cgc, 0, 8);
1754 memset(&rpc_state, 0, sizeof(rpc_state_t));
1755 cgc.buffer = (char *) &rpc_state;
1757 if ((ret = cdo->generic_packet(cdi, &cgc)))
1758 return ret;
1760 ai->lrpcs.type = rpc_state.type_code;
1761 ai->lrpcs.vra = rpc_state.vra;
1762 ai->lrpcs.ucca = rpc_state.ucca;
1763 ai->lrpcs.region_mask = rpc_state.region_mask;
1764 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1765 break;
1767 /* Set region settings */
1768 case DVD_HOST_SEND_RPC_STATE:
1769 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1770 setup_send_key(&cgc, 0, 6);
1771 buf[1] = 6;
1772 buf[4] = ai->hrpcs.pdrc;
1774 if ((ret = cdo->generic_packet(cdi, &cgc)))
1775 return ret;
1776 break;
1778 default:
1779 cd_dbg(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1780 return -ENOTTY;
1783 return 0;
1786 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s,
1787 struct packet_command *cgc)
1789 unsigned char buf[21], *base;
1790 struct dvd_layer *layer;
1791 struct cdrom_device_ops *cdo = cdi->ops;
1792 int ret, layer_num = s->physical.layer_num;
1794 if (layer_num >= DVD_LAYERS)
1795 return -EINVAL;
1797 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1798 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1799 cgc->cmd[6] = layer_num;
1800 cgc->cmd[7] = s->type;
1801 cgc->cmd[9] = cgc->buflen & 0xff;
1804 * refrain from reporting errors on non-existing layers (mainly)
1806 cgc->quiet = 1;
1808 ret = cdo->generic_packet(cdi, cgc);
1809 if (ret)
1810 return ret;
1812 base = &buf[4];
1813 layer = &s->physical.layer[layer_num];
1816 * place the data... really ugly, but at least we won't have to
1817 * worry about endianess in userspace.
1819 memset(layer, 0, sizeof(*layer));
1820 layer->book_version = base[0] & 0xf;
1821 layer->book_type = base[0] >> 4;
1822 layer->min_rate = base[1] & 0xf;
1823 layer->disc_size = base[1] >> 4;
1824 layer->layer_type = base[2] & 0xf;
1825 layer->track_path = (base[2] >> 4) & 1;
1826 layer->nlayers = (base[2] >> 5) & 3;
1827 layer->track_density = base[3] & 0xf;
1828 layer->linear_density = base[3] >> 4;
1829 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1830 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1831 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1832 layer->bca = base[16] >> 7;
1834 return 0;
1837 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s,
1838 struct packet_command *cgc)
1840 int ret;
1841 u_char buf[8];
1842 struct cdrom_device_ops *cdo = cdi->ops;
1844 init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1845 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1846 cgc->cmd[6] = s->copyright.layer_num;
1847 cgc->cmd[7] = s->type;
1848 cgc->cmd[8] = cgc->buflen >> 8;
1849 cgc->cmd[9] = cgc->buflen & 0xff;
1851 ret = cdo->generic_packet(cdi, cgc);
1852 if (ret)
1853 return ret;
1855 s->copyright.cpst = buf[4];
1856 s->copyright.rmi = buf[5];
1858 return 0;
1861 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s,
1862 struct packet_command *cgc)
1864 int ret, size;
1865 u_char *buf;
1866 struct cdrom_device_ops *cdo = cdi->ops;
1868 size = sizeof(s->disckey.value) + 4;
1870 buf = kmalloc(size, GFP_KERNEL);
1871 if (!buf)
1872 return -ENOMEM;
1874 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1875 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1876 cgc->cmd[7] = s->type;
1877 cgc->cmd[8] = size >> 8;
1878 cgc->cmd[9] = size & 0xff;
1879 cgc->cmd[10] = s->disckey.agid << 6;
1881 ret = cdo->generic_packet(cdi, cgc);
1882 if (!ret)
1883 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1885 kfree(buf);
1886 return ret;
1889 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1890 struct packet_command *cgc)
1892 int ret, size = 4 + 188;
1893 u_char *buf;
1894 struct cdrom_device_ops *cdo = cdi->ops;
1896 buf = kmalloc(size, GFP_KERNEL);
1897 if (!buf)
1898 return -ENOMEM;
1900 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1901 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1902 cgc->cmd[7] = s->type;
1903 cgc->cmd[9] = cgc->buflen & 0xff;
1905 ret = cdo->generic_packet(cdi, cgc);
1906 if (ret)
1907 goto out;
1909 s->bca.len = buf[0] << 8 | buf[1];
1910 if (s->bca.len < 12 || s->bca.len > 188) {
1911 cd_dbg(CD_WARNING, "Received invalid BCA length (%d)\n",
1912 s->bca.len);
1913 ret = -EIO;
1914 goto out;
1916 memcpy(s->bca.value, &buf[4], s->bca.len);
1917 ret = 0;
1918 out:
1919 kfree(buf);
1920 return ret;
1923 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1924 struct packet_command *cgc)
1926 int ret = 0, size;
1927 u_char *buf;
1928 struct cdrom_device_ops *cdo = cdi->ops;
1930 size = sizeof(s->manufact.value) + 4;
1932 buf = kmalloc(size, GFP_KERNEL);
1933 if (!buf)
1934 return -ENOMEM;
1936 init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1937 cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1938 cgc->cmd[7] = s->type;
1939 cgc->cmd[8] = size >> 8;
1940 cgc->cmd[9] = size & 0xff;
1942 ret = cdo->generic_packet(cdi, cgc);
1943 if (ret)
1944 goto out;
1946 s->manufact.len = buf[0] << 8 | buf[1];
1947 if (s->manufact.len < 0) {
1948 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d)\n",
1949 s->manufact.len);
1950 ret = -EIO;
1951 } else {
1952 if (s->manufact.len > 2048) {
1953 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d): truncating to 2048\n",
1954 s->manufact.len);
1955 s->manufact.len = 2048;
1957 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1960 out:
1961 kfree(buf);
1962 return ret;
1965 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1966 struct packet_command *cgc)
1968 switch (s->type) {
1969 case DVD_STRUCT_PHYSICAL:
1970 return dvd_read_physical(cdi, s, cgc);
1972 case DVD_STRUCT_COPYRIGHT:
1973 return dvd_read_copyright(cdi, s, cgc);
1975 case DVD_STRUCT_DISCKEY:
1976 return dvd_read_disckey(cdi, s, cgc);
1978 case DVD_STRUCT_BCA:
1979 return dvd_read_bca(cdi, s, cgc);
1981 case DVD_STRUCT_MANUFACT:
1982 return dvd_read_manufact(cdi, s, cgc);
1984 default:
1985 cd_dbg(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1986 s->type);
1987 return -EINVAL;
1991 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1992 struct packet_command *cgc,
1993 int page_code, int page_control)
1995 struct cdrom_device_ops *cdo = cdi->ops;
1997 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1999 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
2000 cgc->cmd[2] = page_code | (page_control << 6);
2001 cgc->cmd[7] = cgc->buflen >> 8;
2002 cgc->cmd[8] = cgc->buflen & 0xff;
2003 cgc->data_direction = CGC_DATA_READ;
2004 return cdo->generic_packet(cdi, cgc);
2007 int cdrom_mode_select(struct cdrom_device_info *cdi,
2008 struct packet_command *cgc)
2010 struct cdrom_device_ops *cdo = cdi->ops;
2012 memset(cgc->cmd, 0, sizeof(cgc->cmd));
2013 memset(cgc->buffer, 0, 2);
2014 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
2015 cgc->cmd[1] = 0x10; /* PF */
2016 cgc->cmd[7] = cgc->buflen >> 8;
2017 cgc->cmd[8] = cgc->buflen & 0xff;
2018 cgc->data_direction = CGC_DATA_WRITE;
2019 return cdo->generic_packet(cdi, cgc);
2022 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
2023 struct cdrom_subchnl *subchnl, int mcn)
2025 struct cdrom_device_ops *cdo = cdi->ops;
2026 struct packet_command cgc;
2027 char buffer[32];
2028 int ret;
2030 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
2031 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
2032 cgc.cmd[1] = 2; /* MSF addressing */
2033 cgc.cmd[2] = 0x40; /* request subQ data */
2034 cgc.cmd[3] = mcn ? 2 : 1;
2035 cgc.cmd[8] = 16;
2037 if ((ret = cdo->generic_packet(cdi, &cgc)))
2038 return ret;
2040 subchnl->cdsc_audiostatus = cgc.buffer[1];
2041 subchnl->cdsc_format = CDROM_MSF;
2042 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
2043 subchnl->cdsc_trk = cgc.buffer[6];
2044 subchnl->cdsc_ind = cgc.buffer[7];
2046 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
2047 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
2048 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
2049 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
2050 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
2051 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
2053 return 0;
2057 * Specific READ_10 interface
2059 static int cdrom_read_cd(struct cdrom_device_info *cdi,
2060 struct packet_command *cgc, int lba,
2061 int blocksize, int nblocks)
2063 struct cdrom_device_ops *cdo = cdi->ops;
2065 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2066 cgc->cmd[0] = GPCMD_READ_10;
2067 cgc->cmd[2] = (lba >> 24) & 0xff;
2068 cgc->cmd[3] = (lba >> 16) & 0xff;
2069 cgc->cmd[4] = (lba >> 8) & 0xff;
2070 cgc->cmd[5] = lba & 0xff;
2071 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2072 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2073 cgc->cmd[8] = nblocks & 0xff;
2074 cgc->buflen = blocksize * nblocks;
2075 return cdo->generic_packet(cdi, cgc);
2078 /* very generic interface for reading the various types of blocks */
2079 static int cdrom_read_block(struct cdrom_device_info *cdi,
2080 struct packet_command *cgc,
2081 int lba, int nblocks, int format, int blksize)
2083 struct cdrom_device_ops *cdo = cdi->ops;
2085 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2086 cgc->cmd[0] = GPCMD_READ_CD;
2087 /* expected sector size - cdda,mode1,etc. */
2088 cgc->cmd[1] = format << 2;
2089 /* starting address */
2090 cgc->cmd[2] = (lba >> 24) & 0xff;
2091 cgc->cmd[3] = (lba >> 16) & 0xff;
2092 cgc->cmd[4] = (lba >> 8) & 0xff;
2093 cgc->cmd[5] = lba & 0xff;
2094 /* number of blocks */
2095 cgc->cmd[6] = (nblocks >> 16) & 0xff;
2096 cgc->cmd[7] = (nblocks >> 8) & 0xff;
2097 cgc->cmd[8] = nblocks & 0xff;
2098 cgc->buflen = blksize * nblocks;
2100 /* set the header info returned */
2101 switch (blksize) {
2102 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
2103 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
2104 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
2105 default : cgc->cmd[9] = 0x10;
2108 return cdo->generic_packet(cdi, cgc);
2111 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2112 int lba, int nframes)
2114 struct packet_command cgc;
2115 int ret = 0;
2116 int nr;
2118 cdi->last_sense = 0;
2120 memset(&cgc, 0, sizeof(cgc));
2123 * start with will ra.nframes size, back down if alloc fails
2125 nr = nframes;
2126 do {
2127 cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2128 if (cgc.buffer)
2129 break;
2131 nr >>= 1;
2132 } while (nr);
2134 if (!nr)
2135 return -ENOMEM;
2137 cgc.data_direction = CGC_DATA_READ;
2138 while (nframes > 0) {
2139 if (nr > nframes)
2140 nr = nframes;
2142 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2143 if (ret)
2144 break;
2145 if (copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2146 ret = -EFAULT;
2147 break;
2149 ubuf += CD_FRAMESIZE_RAW * nr;
2150 nframes -= nr;
2151 lba += nr;
2153 kfree(cgc.buffer);
2154 return ret;
2157 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2158 int lba, int nframes)
2160 struct request_queue *q = cdi->disk->queue;
2161 struct request *rq;
2162 struct bio *bio;
2163 unsigned int len;
2164 int nr, ret = 0;
2166 if (!q)
2167 return -ENXIO;
2169 cdi->last_sense = 0;
2171 while (nframes) {
2172 nr = nframes;
2173 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2174 nr = 1;
2175 if (nr * CD_FRAMESIZE_RAW > (queue_max_sectors(q) << 9))
2176 nr = (queue_max_sectors(q) << 9) / CD_FRAMESIZE_RAW;
2178 len = nr * CD_FRAMESIZE_RAW;
2180 rq = blk_get_request(q, READ, GFP_KERNEL);
2181 if (IS_ERR(rq)) {
2182 ret = PTR_ERR(rq);
2183 break;
2185 blk_rq_set_block_pc(rq);
2187 ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL);
2188 if (ret) {
2189 blk_put_request(rq);
2190 break;
2193 rq->cmd[0] = GPCMD_READ_CD;
2194 rq->cmd[1] = 1 << 2;
2195 rq->cmd[2] = (lba >> 24) & 0xff;
2196 rq->cmd[3] = (lba >> 16) & 0xff;
2197 rq->cmd[4] = (lba >> 8) & 0xff;
2198 rq->cmd[5] = lba & 0xff;
2199 rq->cmd[6] = (nr >> 16) & 0xff;
2200 rq->cmd[7] = (nr >> 8) & 0xff;
2201 rq->cmd[8] = nr & 0xff;
2202 rq->cmd[9] = 0xf8;
2204 rq->cmd_len = 12;
2205 rq->timeout = 60 * HZ;
2206 bio = rq->bio;
2208 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2209 struct request_sense *s = rq->sense;
2210 ret = -EIO;
2211 cdi->last_sense = s->sense_key;
2214 if (blk_rq_unmap_user(bio))
2215 ret = -EFAULT;
2216 blk_put_request(rq);
2218 if (ret)
2219 break;
2221 nframes -= nr;
2222 lba += nr;
2223 ubuf += len;
2226 return ret;
2229 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2230 int lba, int nframes)
2232 int ret;
2234 if (cdi->cdda_method == CDDA_OLD)
2235 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2237 retry:
2239 * for anything else than success and io error, we need to retry
2241 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2242 if (!ret || ret != -EIO)
2243 return ret;
2246 * I've seen drives get sense 4/8/3 udma crc errors on multi
2247 * frame dma, so drop to single frame dma if we need to
2249 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2250 pr_info("dropping to single frame dma\n");
2251 cdi->cdda_method = CDDA_BPC_SINGLE;
2252 goto retry;
2256 * so we have an io error of some sort with multi frame dma. if the
2257 * condition wasn't a hardware error
2258 * problems, not for any error
2260 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2261 return ret;
2263 pr_info("dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2264 cdi->cdda_method = CDDA_OLD;
2265 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2268 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2269 void __user *argp)
2271 struct cdrom_multisession ms_info;
2272 u8 requested_format;
2273 int ret;
2275 cd_dbg(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2277 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2278 return -ENOSYS;
2280 if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2281 return -EFAULT;
2283 requested_format = ms_info.addr_format;
2284 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2285 return -EINVAL;
2286 ms_info.addr_format = CDROM_LBA;
2288 ret = cdi->ops->get_last_session(cdi, &ms_info);
2289 if (ret)
2290 return ret;
2292 sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2294 if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2295 return -EFAULT;
2297 cd_dbg(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2298 return 0;
2301 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2303 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT\n");
2305 if (!CDROM_CAN(CDC_OPEN_TRAY))
2306 return -ENOSYS;
2307 if (cdi->use_count != 1 || cdi->keeplocked)
2308 return -EBUSY;
2309 if (CDROM_CAN(CDC_LOCK)) {
2310 int ret = cdi->ops->lock_door(cdi, 0);
2311 if (ret)
2312 return ret;
2315 return cdi->ops->tray_move(cdi, 1);
2318 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2320 cd_dbg(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2322 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2323 return -ENOSYS;
2324 return cdi->ops->tray_move(cdi, 0);
2327 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2328 unsigned long arg)
2330 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2332 if (!CDROM_CAN(CDC_OPEN_TRAY))
2333 return -ENOSYS;
2334 if (cdi->keeplocked)
2335 return -EBUSY;
2337 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2338 if (arg)
2339 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2340 return 0;
2343 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2344 unsigned long arg)
2346 struct cdrom_changer_info *info;
2347 int ret;
2349 cd_dbg(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2351 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2352 return -ENOSYS;
2354 /* cannot select disc or select current disc */
2355 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2356 return media_changed(cdi, 1);
2358 if (arg >= cdi->capacity)
2359 return -EINVAL;
2361 info = kmalloc(sizeof(*info), GFP_KERNEL);
2362 if (!info)
2363 return -ENOMEM;
2365 ret = cdrom_read_mech_status(cdi, info);
2366 if (!ret)
2367 ret = info->slots[arg].change;
2368 kfree(info);
2369 return ret;
2372 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2373 unsigned long arg)
2375 cd_dbg(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2378 * Options need to be in sync with capability.
2379 * Too late for that, so we have to check each one separately.
2381 switch (arg) {
2382 case CDO_USE_FFLAGS:
2383 case CDO_CHECK_TYPE:
2384 break;
2385 case CDO_LOCK:
2386 if (!CDROM_CAN(CDC_LOCK))
2387 return -ENOSYS;
2388 break;
2389 case 0:
2390 return cdi->options;
2391 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2392 default:
2393 if (!CDROM_CAN(arg))
2394 return -ENOSYS;
2396 cdi->options |= (int) arg;
2397 return cdi->options;
2400 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2401 unsigned long arg)
2403 cd_dbg(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2405 cdi->options &= ~(int) arg;
2406 return cdi->options;
2409 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2410 unsigned long arg)
2412 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2414 if (!CDROM_CAN(CDC_SELECT_SPEED))
2415 return -ENOSYS;
2416 return cdi->ops->select_speed(cdi, arg);
2419 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2420 unsigned long arg)
2422 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2424 if (!CDROM_CAN(CDC_SELECT_DISC))
2425 return -ENOSYS;
2427 if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2428 if ((int)arg >= cdi->capacity)
2429 return -EINVAL;
2433 * ->select_disc is a hook to allow a driver-specific way of
2434 * seleting disc. However, since there is no equivalent hook for
2435 * cdrom_slot_status this may not actually be useful...
2437 if (cdi->ops->select_disc)
2438 return cdi->ops->select_disc(cdi, arg);
2440 cd_dbg(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2441 return cdrom_select_disc(cdi, arg);
2444 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2445 struct block_device *bdev)
2447 cd_dbg(CD_DO_IOCTL, "entering CDROM_RESET\n");
2449 if (!capable(CAP_SYS_ADMIN))
2450 return -EACCES;
2451 if (!CDROM_CAN(CDC_RESET))
2452 return -ENOSYS;
2453 invalidate_bdev(bdev);
2454 return cdi->ops->reset(cdi);
2457 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2458 unsigned long arg)
2460 cd_dbg(CD_DO_IOCTL, "%socking door\n", arg ? "L" : "Unl");
2462 if (!CDROM_CAN(CDC_LOCK))
2463 return -EDRIVE_CANT_DO_THIS;
2465 cdi->keeplocked = arg ? 1 : 0;
2468 * Don't unlock the door on multiple opens by default, but allow
2469 * root to do so.
2471 if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2472 return -EBUSY;
2473 return cdi->ops->lock_door(cdi, arg);
2476 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2477 unsigned long arg)
2479 cd_dbg(CD_DO_IOCTL, "%sabling debug\n", arg ? "En" : "Dis");
2481 if (!capable(CAP_SYS_ADMIN))
2482 return -EACCES;
2483 debug = arg ? 1 : 0;
2484 return debug;
2487 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2489 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2490 return (cdi->ops->capability & ~cdi->mask);
2494 * The following function is implemented, although very few audio
2495 * discs give Universal Product Code information, which should just be
2496 * the Medium Catalog Number on the box. Note, that the way the code
2497 * is written on the CD is /not/ uniform across all discs!
2499 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2500 void __user *argp)
2502 struct cdrom_mcn mcn;
2503 int ret;
2505 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2507 if (!(cdi->ops->capability & CDC_MCN))
2508 return -ENOSYS;
2509 ret = cdi->ops->get_mcn(cdi, &mcn);
2510 if (ret)
2511 return ret;
2513 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2514 return -EFAULT;
2515 cd_dbg(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2516 return 0;
2519 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2520 unsigned long arg)
2522 cd_dbg(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2524 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2525 return -ENOSYS;
2526 if (!CDROM_CAN(CDC_SELECT_DISC) ||
2527 (arg == CDSL_CURRENT || arg == CDSL_NONE))
2528 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2529 if (arg >= cdi->capacity)
2530 return -EINVAL;
2531 return cdrom_slot_status(cdi, arg);
2535 * Ok, this is where problems start. The current interface for the
2536 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2537 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunately, while this
2538 * is often the case, it is also very common for CDs to have some tracks
2539 * with data, and some tracks with audio. Just because I feel like it,
2540 * I declare the following to be the best way to cope. If the CD has ANY
2541 * data tracks on it, it will be returned as a data CD. If it has any XA
2542 * tracks, I will return it as that. Now I could simplify this interface
2543 * by combining these returns with the above, but this more clearly
2544 * demonstrates the problem with the current interface. Too bad this
2545 * wasn't designed to use bitmasks... -Erik
2547 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2548 * User level programmers might feel the ioctl is not very useful.
2549 * ---david
2551 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2553 tracktype tracks;
2555 cd_dbg(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2557 cdrom_count_tracks(cdi, &tracks);
2558 if (tracks.error)
2559 return tracks.error;
2561 /* Policy mode on */
2562 if (tracks.audio > 0) {
2563 if (!tracks.data && !tracks.cdi && !tracks.xa)
2564 return CDS_AUDIO;
2565 else
2566 return CDS_MIXED;
2569 if (tracks.cdi > 0)
2570 return CDS_XA_2_2;
2571 if (tracks.xa > 0)
2572 return CDS_XA_2_1;
2573 if (tracks.data > 0)
2574 return CDS_DATA_1;
2575 /* Policy mode off */
2577 cd_dbg(CD_WARNING, "This disc doesn't have any tracks I recognize!\n");
2578 return CDS_NO_INFO;
2581 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2583 cd_dbg(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2584 return cdi->capacity;
2587 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2588 void __user *argp)
2590 struct cdrom_subchnl q;
2591 u8 requested, back;
2592 int ret;
2594 /* cd_dbg(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2596 if (copy_from_user(&q, argp, sizeof(q)))
2597 return -EFAULT;
2599 requested = q.cdsc_format;
2600 if (requested != CDROM_MSF && requested != CDROM_LBA)
2601 return -EINVAL;
2602 q.cdsc_format = CDROM_MSF;
2604 ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2605 if (ret)
2606 return ret;
2608 back = q.cdsc_format; /* local copy */
2609 sanitize_format(&q.cdsc_absaddr, &back, requested);
2610 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2612 if (copy_to_user(argp, &q, sizeof(q)))
2613 return -EFAULT;
2614 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2615 return 0;
2618 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2619 void __user *argp)
2621 struct cdrom_tochdr header;
2622 int ret;
2624 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2626 if (copy_from_user(&header, argp, sizeof(header)))
2627 return -EFAULT;
2629 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2630 if (ret)
2631 return ret;
2633 if (copy_to_user(argp, &header, sizeof(header)))
2634 return -EFAULT;
2635 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2636 return 0;
2639 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2640 void __user *argp)
2642 struct cdrom_tocentry entry;
2643 u8 requested_format;
2644 int ret;
2646 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2648 if (copy_from_user(&entry, argp, sizeof(entry)))
2649 return -EFAULT;
2651 requested_format = entry.cdte_format;
2652 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2653 return -EINVAL;
2654 /* make interface to low-level uniform */
2655 entry.cdte_format = CDROM_MSF;
2656 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2657 if (ret)
2658 return ret;
2659 sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2661 if (copy_to_user(argp, &entry, sizeof(entry)))
2662 return -EFAULT;
2663 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2664 return 0;
2667 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2668 void __user *argp)
2670 struct cdrom_msf msf;
2672 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2674 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2675 return -ENOSYS;
2676 if (copy_from_user(&msf, argp, sizeof(msf)))
2677 return -EFAULT;
2678 return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2681 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2682 void __user *argp)
2684 struct cdrom_ti ti;
2685 int ret;
2687 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2689 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2690 return -ENOSYS;
2691 if (copy_from_user(&ti, argp, sizeof(ti)))
2692 return -EFAULT;
2694 ret = check_for_audio_disc(cdi, cdi->ops);
2695 if (ret)
2696 return ret;
2697 return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2699 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2700 void __user *argp)
2702 struct cdrom_volctrl volume;
2704 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2706 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2707 return -ENOSYS;
2708 if (copy_from_user(&volume, argp, sizeof(volume)))
2709 return -EFAULT;
2710 return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2713 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2714 void __user *argp)
2716 struct cdrom_volctrl volume;
2717 int ret;
2719 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2721 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2722 return -ENOSYS;
2724 ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2725 if (ret)
2726 return ret;
2728 if (copy_to_user(argp, &volume, sizeof(volume)))
2729 return -EFAULT;
2730 return 0;
2733 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2734 unsigned int cmd)
2736 int ret;
2738 cd_dbg(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2740 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2741 return -ENOSYS;
2742 ret = check_for_audio_disc(cdi, cdi->ops);
2743 if (ret)
2744 return ret;
2745 return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2749 * Required when we need to use READ_10 to issue other than 2048 block
2750 * reads
2752 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2754 struct cdrom_device_ops *cdo = cdi->ops;
2755 struct packet_command cgc;
2756 struct modesel_head mh;
2758 memset(&mh, 0, sizeof(mh));
2759 mh.block_desc_length = 0x08;
2760 mh.block_length_med = (size >> 8) & 0xff;
2761 mh.block_length_lo = size & 0xff;
2763 memset(&cgc, 0, sizeof(cgc));
2764 cgc.cmd[0] = 0x15;
2765 cgc.cmd[1] = 1 << 4;
2766 cgc.cmd[4] = 12;
2767 cgc.buflen = sizeof(mh);
2768 cgc.buffer = (char *) &mh;
2769 cgc.data_direction = CGC_DATA_WRITE;
2770 mh.block_desc_length = 0x08;
2771 mh.block_length_med = (size >> 8) & 0xff;
2772 mh.block_length_lo = size & 0xff;
2774 return cdo->generic_packet(cdi, &cgc);
2777 static int cdrom_get_track_info(struct cdrom_device_info *cdi,
2778 __u16 track, __u8 type, track_information *ti)
2780 struct cdrom_device_ops *cdo = cdi->ops;
2781 struct packet_command cgc;
2782 int ret, buflen;
2784 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
2785 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
2786 cgc.cmd[1] = type & 3;
2787 cgc.cmd[4] = (track & 0xff00) >> 8;
2788 cgc.cmd[5] = track & 0xff;
2789 cgc.cmd[8] = 8;
2790 cgc.quiet = 1;
2792 ret = cdo->generic_packet(cdi, &cgc);
2793 if (ret)
2794 return ret;
2796 buflen = be16_to_cpu(ti->track_information_length) +
2797 sizeof(ti->track_information_length);
2799 if (buflen > sizeof(track_information))
2800 buflen = sizeof(track_information);
2802 cgc.cmd[8] = cgc.buflen = buflen;
2803 ret = cdo->generic_packet(cdi, &cgc);
2804 if (ret)
2805 return ret;
2807 /* return actual fill size */
2808 return buflen;
2811 /* return the last written block on the CD-R media. this is for the udf
2812 file system. */
2813 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
2815 struct cdrom_tocentry toc;
2816 disc_information di;
2817 track_information ti;
2818 __u32 last_track;
2819 int ret = -1, ti_size;
2821 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2822 goto use_toc;
2824 ret = cdrom_get_disc_info(cdi, &di);
2825 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
2826 + sizeof(di.last_track_lsb)))
2827 goto use_toc;
2829 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2830 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2831 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2832 if (ti_size < (int)offsetof(typeof(ti), track_start))
2833 goto use_toc;
2835 /* if this track is blank, try the previous. */
2836 if (ti.blank) {
2837 if (last_track == 1)
2838 goto use_toc;
2839 last_track--;
2840 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2843 if (ti_size < (int)(offsetof(typeof(ti), track_size)
2844 + sizeof(ti.track_size)))
2845 goto use_toc;
2847 /* if last recorded field is valid, return it. */
2848 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
2849 + sizeof(ti.last_rec_address))) {
2850 *last_written = be32_to_cpu(ti.last_rec_address);
2851 } else {
2852 /* make it up instead */
2853 *last_written = be32_to_cpu(ti.track_start) +
2854 be32_to_cpu(ti.track_size);
2855 if (ti.free_blocks)
2856 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
2858 return 0;
2860 /* this is where we end up if the drive either can't do a
2861 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
2862 it doesn't give enough information or fails. then we return
2863 the toc contents. */
2864 use_toc:
2865 toc.cdte_format = CDROM_MSF;
2866 toc.cdte_track = CDROM_LEADOUT;
2867 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
2868 return ret;
2869 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
2870 *last_written = toc.cdte_addr.lba;
2871 return 0;
2874 /* return the next writable block. also for udf file system. */
2875 static int cdrom_get_next_writable(struct cdrom_device_info *cdi,
2876 long *next_writable)
2878 disc_information di;
2879 track_information ti;
2880 __u16 last_track;
2881 int ret, ti_size;
2883 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2884 goto use_last_written;
2886 ret = cdrom_get_disc_info(cdi, &di);
2887 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
2888 + sizeof(di.last_track_lsb))
2889 goto use_last_written;
2891 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2892 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2893 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2894 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
2895 goto use_last_written;
2897 /* if this track is blank, try the previous. */
2898 if (ti.blank) {
2899 if (last_track == 1)
2900 goto use_last_written;
2901 last_track--;
2902 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2903 if (ti_size < 0)
2904 goto use_last_written;
2907 /* if next recordable address field is valid, use it. */
2908 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
2909 + sizeof(ti.next_writable)) {
2910 *next_writable = be32_to_cpu(ti.next_writable);
2911 return 0;
2914 use_last_written:
2915 ret = cdrom_get_last_written(cdi, next_writable);
2916 if (ret) {
2917 *next_writable = 0;
2918 return ret;
2919 } else {
2920 *next_writable += 7;
2921 return 0;
2925 static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2926 void __user *arg,
2927 struct packet_command *cgc,
2928 int cmd)
2930 struct request_sense sense;
2931 struct cdrom_msf msf;
2932 int blocksize = 0, format = 0, lba;
2933 int ret;
2935 switch (cmd) {
2936 case CDROMREADRAW:
2937 blocksize = CD_FRAMESIZE_RAW;
2938 break;
2939 case CDROMREADMODE1:
2940 blocksize = CD_FRAMESIZE;
2941 format = 2;
2942 break;
2943 case CDROMREADMODE2:
2944 blocksize = CD_FRAMESIZE_RAW0;
2945 break;
2947 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
2948 return -EFAULT;
2949 lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2950 /* FIXME: we need upper bound checking, too!! */
2951 if (lba < 0)
2952 return -EINVAL;
2954 cgc->buffer = kzalloc(blocksize, GFP_KERNEL);
2955 if (cgc->buffer == NULL)
2956 return -ENOMEM;
2958 memset(&sense, 0, sizeof(sense));
2959 cgc->sense = &sense;
2960 cgc->data_direction = CGC_DATA_READ;
2961 ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
2962 if (ret && sense.sense_key == 0x05 &&
2963 sense.asc == 0x20 &&
2964 sense.ascq == 0x00) {
2966 * SCSI-II devices are not required to support
2967 * READ_CD, so let's try switching block size
2969 /* FIXME: switch back again... */
2970 ret = cdrom_switch_blocksize(cdi, blocksize);
2971 if (ret)
2972 goto out;
2973 cgc->sense = NULL;
2974 ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
2975 ret |= cdrom_switch_blocksize(cdi, blocksize);
2977 if (!ret && copy_to_user(arg, cgc->buffer, blocksize))
2978 ret = -EFAULT;
2979 out:
2980 kfree(cgc->buffer);
2981 return ret;
2984 static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
2985 void __user *arg)
2987 struct cdrom_read_audio ra;
2988 int lba;
2990 if (copy_from_user(&ra, (struct cdrom_read_audio __user *)arg,
2991 sizeof(ra)))
2992 return -EFAULT;
2994 if (ra.addr_format == CDROM_MSF)
2995 lba = msf_to_lba(ra.addr.msf.minute,
2996 ra.addr.msf.second,
2997 ra.addr.msf.frame);
2998 else if (ra.addr_format == CDROM_LBA)
2999 lba = ra.addr.lba;
3000 else
3001 return -EINVAL;
3003 /* FIXME: we need upper bound checking, too!! */
3004 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
3005 return -EINVAL;
3007 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
3010 static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
3011 void __user *arg)
3013 int ret;
3014 struct cdrom_subchnl q;
3015 u_char requested, back;
3016 if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q)))
3017 return -EFAULT;
3018 requested = q.cdsc_format;
3019 if (!((requested == CDROM_MSF) ||
3020 (requested == CDROM_LBA)))
3021 return -EINVAL;
3022 q.cdsc_format = CDROM_MSF;
3023 ret = cdrom_read_subchannel(cdi, &q, 0);
3024 if (ret)
3025 return ret;
3026 back = q.cdsc_format; /* local copy */
3027 sanitize_format(&q.cdsc_absaddr, &back, requested);
3028 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
3029 if (copy_to_user((struct cdrom_subchnl __user *)arg, &q, sizeof(q)))
3030 return -EFAULT;
3031 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
3032 return 0;
3035 static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
3036 void __user *arg,
3037 struct packet_command *cgc)
3039 struct cdrom_device_ops *cdo = cdi->ops;
3040 struct cdrom_msf msf;
3041 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
3042 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
3043 return -EFAULT;
3044 cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
3045 cgc->cmd[3] = msf.cdmsf_min0;
3046 cgc->cmd[4] = msf.cdmsf_sec0;
3047 cgc->cmd[5] = msf.cdmsf_frame0;
3048 cgc->cmd[6] = msf.cdmsf_min1;
3049 cgc->cmd[7] = msf.cdmsf_sec1;
3050 cgc->cmd[8] = msf.cdmsf_frame1;
3051 cgc->data_direction = CGC_DATA_NONE;
3052 return cdo->generic_packet(cdi, cgc);
3055 static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
3056 void __user *arg,
3057 struct packet_command *cgc)
3059 struct cdrom_device_ops *cdo = cdi->ops;
3060 struct cdrom_blk blk;
3061 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
3062 if (copy_from_user(&blk, (struct cdrom_blk __user *)arg, sizeof(blk)))
3063 return -EFAULT;
3064 cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
3065 cgc->cmd[2] = (blk.from >> 24) & 0xff;
3066 cgc->cmd[3] = (blk.from >> 16) & 0xff;
3067 cgc->cmd[4] = (blk.from >> 8) & 0xff;
3068 cgc->cmd[5] = blk.from & 0xff;
3069 cgc->cmd[7] = (blk.len >> 8) & 0xff;
3070 cgc->cmd[8] = blk.len & 0xff;
3071 cgc->data_direction = CGC_DATA_NONE;
3072 return cdo->generic_packet(cdi, cgc);
3075 static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3076 void __user *arg,
3077 struct packet_command *cgc,
3078 unsigned int cmd)
3080 struct cdrom_volctrl volctrl;
3081 unsigned char buffer[32];
3082 char mask[sizeof(buffer)];
3083 unsigned short offset;
3084 int ret;
3086 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3088 if (copy_from_user(&volctrl, (struct cdrom_volctrl __user *)arg,
3089 sizeof(volctrl)))
3090 return -EFAULT;
3092 cgc->buffer = buffer;
3093 cgc->buflen = 24;
3094 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 0);
3095 if (ret)
3096 return ret;
3098 /* originally the code depended on buffer[1] to determine
3099 how much data is available for transfer. buffer[1] is
3100 unfortunately ambigious and the only reliable way seem
3101 to be to simply skip over the block descriptor... */
3102 offset = 8 + be16_to_cpu(*(__be16 *)(buffer + 6));
3104 if (offset + 16 > sizeof(buffer))
3105 return -E2BIG;
3107 if (offset + 16 > cgc->buflen) {
3108 cgc->buflen = offset + 16;
3109 ret = cdrom_mode_sense(cdi, cgc,
3110 GPMODE_AUDIO_CTL_PAGE, 0);
3111 if (ret)
3112 return ret;
3115 /* sanity check */
3116 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3117 buffer[offset + 1] < 14)
3118 return -EINVAL;
3120 /* now we have the current volume settings. if it was only
3121 a CDROMVOLREAD, return these values */
3122 if (cmd == CDROMVOLREAD) {
3123 volctrl.channel0 = buffer[offset+9];
3124 volctrl.channel1 = buffer[offset+11];
3125 volctrl.channel2 = buffer[offset+13];
3126 volctrl.channel3 = buffer[offset+15];
3127 if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl,
3128 sizeof(volctrl)))
3129 return -EFAULT;
3130 return 0;
3133 /* get the volume mask */
3134 cgc->buffer = mask;
3135 ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 1);
3136 if (ret)
3137 return ret;
3139 buffer[offset + 9] = volctrl.channel0 & mask[offset + 9];
3140 buffer[offset + 11] = volctrl.channel1 & mask[offset + 11];
3141 buffer[offset + 13] = volctrl.channel2 & mask[offset + 13];
3142 buffer[offset + 15] = volctrl.channel3 & mask[offset + 15];
3144 /* set volume */
3145 cgc->buffer = buffer + offset - 8;
3146 memset(cgc->buffer, 0, 8);
3147 return cdrom_mode_select(cdi, cgc);
3150 static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3151 struct packet_command *cgc,
3152 int cmd)
3154 struct cdrom_device_ops *cdo = cdi->ops;
3155 cd_dbg(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3156 cgc->cmd[0] = GPCMD_START_STOP_UNIT;
3157 cgc->cmd[1] = 1;
3158 cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3159 cgc->data_direction = CGC_DATA_NONE;
3160 return cdo->generic_packet(cdi, cgc);
3163 static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3164 struct packet_command *cgc,
3165 int cmd)
3167 struct cdrom_device_ops *cdo = cdi->ops;
3168 cd_dbg(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3169 cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3170 cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3171 cgc->data_direction = CGC_DATA_NONE;
3172 return cdo->generic_packet(cdi, cgc);
3175 static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3176 void __user *arg,
3177 struct packet_command *cgc)
3179 int ret;
3180 dvd_struct *s;
3181 int size = sizeof(dvd_struct);
3183 if (!CDROM_CAN(CDC_DVD))
3184 return -ENOSYS;
3186 s = kmalloc(size, GFP_KERNEL);
3187 if (!s)
3188 return -ENOMEM;
3190 cd_dbg(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3191 if (copy_from_user(s, arg, size)) {
3192 kfree(s);
3193 return -EFAULT;
3196 ret = dvd_read_struct(cdi, s, cgc);
3197 if (ret)
3198 goto out;
3200 if (copy_to_user(arg, s, size))
3201 ret = -EFAULT;
3202 out:
3203 kfree(s);
3204 return ret;
3207 static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3208 void __user *arg)
3210 int ret;
3211 dvd_authinfo ai;
3212 if (!CDROM_CAN(CDC_DVD))
3213 return -ENOSYS;
3214 cd_dbg(CD_DO_IOCTL, "entering DVD_AUTH\n");
3215 if (copy_from_user(&ai, (dvd_authinfo __user *)arg, sizeof(ai)))
3216 return -EFAULT;
3217 ret = dvd_do_auth(cdi, &ai);
3218 if (ret)
3219 return ret;
3220 if (copy_to_user((dvd_authinfo __user *)arg, &ai, sizeof(ai)))
3221 return -EFAULT;
3222 return 0;
3225 static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3226 void __user *arg)
3228 int ret;
3229 long next = 0;
3230 cd_dbg(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3231 ret = cdrom_get_next_writable(cdi, &next);
3232 if (ret)
3233 return ret;
3234 if (copy_to_user((long __user *)arg, &next, sizeof(next)))
3235 return -EFAULT;
3236 return 0;
3239 static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3240 void __user *arg)
3242 int ret;
3243 long last = 0;
3244 cd_dbg(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3245 ret = cdrom_get_last_written(cdi, &last);
3246 if (ret)
3247 return ret;
3248 if (copy_to_user((long __user *)arg, &last, sizeof(last)))
3249 return -EFAULT;
3250 return 0;
3253 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3254 unsigned long arg)
3256 struct packet_command cgc;
3257 void __user *userptr = (void __user *)arg;
3259 memset(&cgc, 0, sizeof(cgc));
3261 /* build a unified command and queue it through
3262 cdo->generic_packet() */
3263 switch (cmd) {
3264 case CDROMREADRAW:
3265 case CDROMREADMODE1:
3266 case CDROMREADMODE2:
3267 return mmc_ioctl_cdrom_read_data(cdi, userptr, &cgc, cmd);
3268 case CDROMREADAUDIO:
3269 return mmc_ioctl_cdrom_read_audio(cdi, userptr);
3270 case CDROMSUBCHNL:
3271 return mmc_ioctl_cdrom_subchannel(cdi, userptr);
3272 case CDROMPLAYMSF:
3273 return mmc_ioctl_cdrom_play_msf(cdi, userptr, &cgc);
3274 case CDROMPLAYBLK:
3275 return mmc_ioctl_cdrom_play_blk(cdi, userptr, &cgc);
3276 case CDROMVOLCTRL:
3277 case CDROMVOLREAD:
3278 return mmc_ioctl_cdrom_volume(cdi, userptr, &cgc, cmd);
3279 case CDROMSTART:
3280 case CDROMSTOP:
3281 return mmc_ioctl_cdrom_start_stop(cdi, &cgc, cmd);
3282 case CDROMPAUSE:
3283 case CDROMRESUME:
3284 return mmc_ioctl_cdrom_pause_resume(cdi, &cgc, cmd);
3285 case DVD_READ_STRUCT:
3286 return mmc_ioctl_dvd_read_struct(cdi, userptr, &cgc);
3287 case DVD_AUTH:
3288 return mmc_ioctl_dvd_auth(cdi, userptr);
3289 case CDROM_NEXT_WRITABLE:
3290 return mmc_ioctl_cdrom_next_writable(cdi, userptr);
3291 case CDROM_LAST_WRITTEN:
3292 return mmc_ioctl_cdrom_last_written(cdi, userptr);
3295 return -ENOTTY;
3299 * Just about every imaginable ioctl is supported in the Uniform layer
3300 * these days.
3301 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
3303 int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
3304 fmode_t mode, unsigned int cmd, unsigned long arg)
3306 void __user *argp = (void __user *)arg;
3307 int ret;
3310 * Try the generic SCSI command ioctl's first.
3312 ret = scsi_cmd_blk_ioctl(bdev, mode, cmd, argp);
3313 if (ret != -ENOTTY)
3314 return ret;
3316 switch (cmd) {
3317 case CDROMMULTISESSION:
3318 return cdrom_ioctl_multisession(cdi, argp);
3319 case CDROMEJECT:
3320 return cdrom_ioctl_eject(cdi);
3321 case CDROMCLOSETRAY:
3322 return cdrom_ioctl_closetray(cdi);
3323 case CDROMEJECT_SW:
3324 return cdrom_ioctl_eject_sw(cdi, arg);
3325 case CDROM_MEDIA_CHANGED:
3326 return cdrom_ioctl_media_changed(cdi, arg);
3327 case CDROM_SET_OPTIONS:
3328 return cdrom_ioctl_set_options(cdi, arg);
3329 case CDROM_CLEAR_OPTIONS:
3330 return cdrom_ioctl_clear_options(cdi, arg);
3331 case CDROM_SELECT_SPEED:
3332 return cdrom_ioctl_select_speed(cdi, arg);
3333 case CDROM_SELECT_DISC:
3334 return cdrom_ioctl_select_disc(cdi, arg);
3335 case CDROMRESET:
3336 return cdrom_ioctl_reset(cdi, bdev);
3337 case CDROM_LOCKDOOR:
3338 return cdrom_ioctl_lock_door(cdi, arg);
3339 case CDROM_DEBUG:
3340 return cdrom_ioctl_debug(cdi, arg);
3341 case CDROM_GET_CAPABILITY:
3342 return cdrom_ioctl_get_capability(cdi);
3343 case CDROM_GET_MCN:
3344 return cdrom_ioctl_get_mcn(cdi, argp);
3345 case CDROM_DRIVE_STATUS:
3346 return cdrom_ioctl_drive_status(cdi, arg);
3347 case CDROM_DISC_STATUS:
3348 return cdrom_ioctl_disc_status(cdi);
3349 case CDROM_CHANGER_NSLOTS:
3350 return cdrom_ioctl_changer_nslots(cdi);
3354 * Use the ioctls that are implemented through the generic_packet()
3355 * interface. this may look at bit funny, but if -ENOTTY is
3356 * returned that particular ioctl is not implemented and we
3357 * let it go through the device specific ones.
3359 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
3360 ret = mmc_ioctl(cdi, cmd, arg);
3361 if (ret != -ENOTTY)
3362 return ret;
3366 * Note: most of the cd_dbg() calls are commented out here,
3367 * because they fill up the sys log when CD players poll
3368 * the drive.
3370 switch (cmd) {
3371 case CDROMSUBCHNL:
3372 return cdrom_ioctl_get_subchnl(cdi, argp);
3373 case CDROMREADTOCHDR:
3374 return cdrom_ioctl_read_tochdr(cdi, argp);
3375 case CDROMREADTOCENTRY:
3376 return cdrom_ioctl_read_tocentry(cdi, argp);
3377 case CDROMPLAYMSF:
3378 return cdrom_ioctl_play_msf(cdi, argp);
3379 case CDROMPLAYTRKIND:
3380 return cdrom_ioctl_play_trkind(cdi, argp);
3381 case CDROMVOLCTRL:
3382 return cdrom_ioctl_volctrl(cdi, argp);
3383 case CDROMVOLREAD:
3384 return cdrom_ioctl_volread(cdi, argp);
3385 case CDROMSTART:
3386 case CDROMSTOP:
3387 case CDROMPAUSE:
3388 case CDROMRESUME:
3389 return cdrom_ioctl_audioctl(cdi, cmd);
3392 return -ENOSYS;
3395 EXPORT_SYMBOL(cdrom_get_last_written);
3396 EXPORT_SYMBOL(register_cdrom);
3397 EXPORT_SYMBOL(unregister_cdrom);
3398 EXPORT_SYMBOL(cdrom_open);
3399 EXPORT_SYMBOL(cdrom_release);
3400 EXPORT_SYMBOL(cdrom_ioctl);
3401 EXPORT_SYMBOL(cdrom_media_changed);
3402 EXPORT_SYMBOL(cdrom_number_of_slots);
3403 EXPORT_SYMBOL(cdrom_mode_select);
3404 EXPORT_SYMBOL(cdrom_mode_sense);
3405 EXPORT_SYMBOL(init_cdrom_command);
3406 EXPORT_SYMBOL(cdrom_get_media_event);
3408 #ifdef CONFIG_SYSCTL
3410 #define CDROM_STR_SIZE 1000
3412 static struct cdrom_sysctl_settings {
3413 char info[CDROM_STR_SIZE]; /* general info */
3414 int autoclose; /* close tray upon mount, etc */
3415 int autoeject; /* eject on umount */
3416 int debug; /* turn on debugging messages */
3417 int lock; /* lock the door on device open */
3418 int check; /* check media type */
3419 } cdrom_sysctl_settings;
3421 enum cdrom_print_option {
3422 CTL_NAME,
3423 CTL_SPEED,
3424 CTL_SLOTS,
3425 CTL_CAPABILITY
3428 static int cdrom_print_info(const char *header, int val, char *info,
3429 int *pos, enum cdrom_print_option option)
3431 const int max_size = sizeof(cdrom_sysctl_settings.info);
3432 struct cdrom_device_info *cdi;
3433 int ret;
3435 ret = scnprintf(info + *pos, max_size - *pos, header);
3436 if (!ret)
3437 return 1;
3439 *pos += ret;
3441 list_for_each_entry(cdi, &cdrom_list, list) {
3442 switch (option) {
3443 case CTL_NAME:
3444 ret = scnprintf(info + *pos, max_size - *pos,
3445 "\t%s", cdi->name);
3446 break;
3447 case CTL_SPEED:
3448 ret = scnprintf(info + *pos, max_size - *pos,
3449 "\t%d", cdi->speed);
3450 break;
3451 case CTL_SLOTS:
3452 ret = scnprintf(info + *pos, max_size - *pos,
3453 "\t%d", cdi->capacity);
3454 break;
3455 case CTL_CAPABILITY:
3456 ret = scnprintf(info + *pos, max_size - *pos,
3457 "\t%d", CDROM_CAN(val) != 0);
3458 break;
3459 default:
3460 pr_info("invalid option%d\n", option);
3461 return 1;
3463 if (!ret)
3464 return 1;
3465 *pos += ret;
3468 return 0;
3471 static int cdrom_sysctl_info(struct ctl_table *ctl, int write,
3472 void __user *buffer, size_t *lenp, loff_t *ppos)
3474 int pos;
3475 char *info = cdrom_sysctl_settings.info;
3476 const int max_size = sizeof(cdrom_sysctl_settings.info);
3478 if (!*lenp || (*ppos && !write)) {
3479 *lenp = 0;
3480 return 0;
3483 mutex_lock(&cdrom_mutex);
3485 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3487 if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3488 goto done;
3489 if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3490 goto done;
3491 if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3492 goto done;
3493 if (cdrom_print_info("\nCan close tray:\t",
3494 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3495 goto done;
3496 if (cdrom_print_info("\nCan open tray:\t",
3497 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3498 goto done;
3499 if (cdrom_print_info("\nCan lock tray:\t",
3500 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3501 goto done;
3502 if (cdrom_print_info("\nCan change speed:",
3503 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3504 goto done;
3505 if (cdrom_print_info("\nCan select disk:",
3506 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3507 goto done;
3508 if (cdrom_print_info("\nCan read multisession:",
3509 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3510 goto done;
3511 if (cdrom_print_info("\nCan read MCN:\t",
3512 CDC_MCN, info, &pos, CTL_CAPABILITY))
3513 goto done;
3514 if (cdrom_print_info("\nReports media changed:",
3515 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3516 goto done;
3517 if (cdrom_print_info("\nCan play audio:\t",
3518 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3519 goto done;
3520 if (cdrom_print_info("\nCan write CD-R:\t",
3521 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3522 goto done;
3523 if (cdrom_print_info("\nCan write CD-RW:",
3524 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3525 goto done;
3526 if (cdrom_print_info("\nCan read DVD:\t",
3527 CDC_DVD, info, &pos, CTL_CAPABILITY))
3528 goto done;
3529 if (cdrom_print_info("\nCan write DVD-R:",
3530 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3531 goto done;
3532 if (cdrom_print_info("\nCan write DVD-RAM:",
3533 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3534 goto done;
3535 if (cdrom_print_info("\nCan read MRW:\t",
3536 CDC_MRW, info, &pos, CTL_CAPABILITY))
3537 goto done;
3538 if (cdrom_print_info("\nCan write MRW:\t",
3539 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3540 goto done;
3541 if (cdrom_print_info("\nCan write RAM:\t",
3542 CDC_RAM, info, &pos, CTL_CAPABILITY))
3543 goto done;
3544 if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3545 goto done;
3546 doit:
3547 mutex_unlock(&cdrom_mutex);
3548 return proc_dostring(ctl, write, buffer, lenp, ppos);
3549 done:
3550 pr_info("info buffer too small\n");
3551 goto doit;
3554 /* Unfortunately, per device settings are not implemented through
3555 procfs/sysctl yet. When they are, this will naturally disappear. For now
3556 just update all drives. Later this will become the template on which
3557 new registered drives will be based. */
3558 static void cdrom_update_settings(void)
3560 struct cdrom_device_info *cdi;
3562 mutex_lock(&cdrom_mutex);
3563 list_for_each_entry(cdi, &cdrom_list, list) {
3564 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3565 cdi->options |= CDO_AUTO_CLOSE;
3566 else if (!autoclose)
3567 cdi->options &= ~CDO_AUTO_CLOSE;
3568 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3569 cdi->options |= CDO_AUTO_EJECT;
3570 else if (!autoeject)
3571 cdi->options &= ~CDO_AUTO_EJECT;
3572 if (lockdoor && CDROM_CAN(CDC_LOCK))
3573 cdi->options |= CDO_LOCK;
3574 else if (!lockdoor)
3575 cdi->options &= ~CDO_LOCK;
3576 if (check_media_type)
3577 cdi->options |= CDO_CHECK_TYPE;
3578 else
3579 cdi->options &= ~CDO_CHECK_TYPE;
3581 mutex_unlock(&cdrom_mutex);
3584 static int cdrom_sysctl_handler(struct ctl_table *ctl, int write,
3585 void __user *buffer, size_t *lenp, loff_t *ppos)
3587 int ret;
3589 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
3591 if (write) {
3593 /* we only care for 1 or 0. */
3594 autoclose = !!cdrom_sysctl_settings.autoclose;
3595 autoeject = !!cdrom_sysctl_settings.autoeject;
3596 debug = !!cdrom_sysctl_settings.debug;
3597 lockdoor = !!cdrom_sysctl_settings.lock;
3598 check_media_type = !!cdrom_sysctl_settings.check;
3600 /* update the option flags according to the changes. we
3601 don't have per device options through sysctl yet,
3602 but we will have and then this will disappear. */
3603 cdrom_update_settings();
3606 return ret;
3609 /* Place files in /proc/sys/dev/cdrom */
3610 static struct ctl_table cdrom_table[] = {
3612 .procname = "info",
3613 .data = &cdrom_sysctl_settings.info,
3614 .maxlen = CDROM_STR_SIZE,
3615 .mode = 0444,
3616 .proc_handler = cdrom_sysctl_info,
3619 .procname = "autoclose",
3620 .data = &cdrom_sysctl_settings.autoclose,
3621 .maxlen = sizeof(int),
3622 .mode = 0644,
3623 .proc_handler = cdrom_sysctl_handler,
3626 .procname = "autoeject",
3627 .data = &cdrom_sysctl_settings.autoeject,
3628 .maxlen = sizeof(int),
3629 .mode = 0644,
3630 .proc_handler = cdrom_sysctl_handler,
3633 .procname = "debug",
3634 .data = &cdrom_sysctl_settings.debug,
3635 .maxlen = sizeof(int),
3636 .mode = 0644,
3637 .proc_handler = cdrom_sysctl_handler,
3640 .procname = "lock",
3641 .data = &cdrom_sysctl_settings.lock,
3642 .maxlen = sizeof(int),
3643 .mode = 0644,
3644 .proc_handler = cdrom_sysctl_handler,
3647 .procname = "check_media",
3648 .data = &cdrom_sysctl_settings.check,
3649 .maxlen = sizeof(int),
3650 .mode = 0644,
3651 .proc_handler = cdrom_sysctl_handler
3656 static struct ctl_table cdrom_cdrom_table[] = {
3658 .procname = "cdrom",
3659 .maxlen = 0,
3660 .mode = 0555,
3661 .child = cdrom_table,
3666 /* Make sure that /proc/sys/dev is there */
3667 static struct ctl_table cdrom_root_table[] = {
3669 .procname = "dev",
3670 .maxlen = 0,
3671 .mode = 0555,
3672 .child = cdrom_cdrom_table,
3676 static struct ctl_table_header *cdrom_sysctl_header;
3678 static void cdrom_sysctl_register(void)
3680 static int initialized;
3682 if (initialized == 1)
3683 return;
3685 cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3687 /* set the defaults */
3688 cdrom_sysctl_settings.autoclose = autoclose;
3689 cdrom_sysctl_settings.autoeject = autoeject;
3690 cdrom_sysctl_settings.debug = debug;
3691 cdrom_sysctl_settings.lock = lockdoor;
3692 cdrom_sysctl_settings.check = check_media_type;
3694 initialized = 1;
3697 static void cdrom_sysctl_unregister(void)
3699 if (cdrom_sysctl_header)
3700 unregister_sysctl_table(cdrom_sysctl_header);
3703 #else /* CONFIG_SYSCTL */
3705 static void cdrom_sysctl_register(void)
3709 static void cdrom_sysctl_unregister(void)
3713 #endif /* CONFIG_SYSCTL */
3715 static int __init cdrom_init(void)
3717 cdrom_sysctl_register();
3719 return 0;
3722 static void __exit cdrom_exit(void)
3724 pr_info("Uniform CD-ROM driver unloaded\n");
3725 cdrom_sysctl_unregister();
3728 module_init(cdrom_init);
3729 module_exit(cdrom_exit);
3730 MODULE_LICENSE("GPL");