xref: /openbmc/linux/drivers/cdrom/cdrom.c (revision 31b90347)
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>
5 
6    May be copied or modified under the terms of the GNU General Public
7    License.  See linux/COPYING for more information.
8 
9    Uniform CD-ROM driver for Linux.
10    See Documentation/cdrom/cdrom-standard.tex for usage information.
11 
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.  ;-)
16 
17  To Do List:
18  ----------------------------------
19 
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!
24 
25 
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?
31 
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.
36 
37   -- Added (rudimentary) sysctl interface. I realize this is really weak
38   right now, and is _very_ badly implemented. It will be improved...
39 
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.
45 
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.
49 
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).
53 
54   -- Made it so if a function isn't implemented in a low-level driver,
55   ENOSYS is now returned instead of EINVAL.
56 
57   -- Simplified some complex logic so that the source code is easier to read.
58 
59   -- Other stuff I probably forgot to mention (lots of changes).
60 
61 2.01 to 2.11 Dec 1997-Jan 1998
62   -- TO-DO!  Write changelogs for 2.01 to 2.12.
63 
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.
69 
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.
78 
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.
84 
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
89 
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.
94 
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.
103 
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.
113 
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>.
117 
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.
122 
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.
140 
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 :).
146 
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.
155 
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.
166 
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.
180 
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.
189 
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.
193 
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.
202 
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.
213 
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.
218 
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.
223 
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
227 
228    3.12 Oct 18, 2000 - Jens Axboe <axboe@suse.de>
229   -- Use quiet bit on packet commands not known to work
230 
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
236 
237   Nov 5 2001, Aug 8 2002. Modified by Andy Polyakov
238   <appro@fy.chalmers.se> to support MMC-3 compliant DVD+RW units.
239 
240   Modified by Nigel Kukard <nkukard@lbsd.net> - support DVD+RW
241   2.4.x patch by Andy Polyakov <appro@fy.chalmers.se>
242 
243 -------------------------------------------------------------------------*/
244 
245 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
246 
247 #define REVISION "Revision: 3.20"
248 #define VERSION "Id: cdrom.c 3.20 2003/12/17"
249 
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
261 
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) */
267 
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>
284 
285 #include <asm/uaccess.h>
286 
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);
303 
304 static DEFINE_MUTEX(cdrom_mutex);
305 
306 static const char *mrw_format_status[] = {
307 	"not mrw",
308 	"bgformat inactive",
309 	"bgformat active",
310 	"mrw complete",
311 };
312 
313 static const char *mrw_address_space[] = { "DMA", "GAA" };
314 
315 #if (ERRLOGMASK!=CD_NOTHING)
316 #define cdinfo(type, fmt, args...)			\
317 do {							\
318 	if ((ERRLOGMASK & type) || debug == 1)		\
319 		pr_info(fmt, ##args);			\
320 } while (0)
321 #else
322 #define cdinfo(type, fmt, args...)			\
323 do {							\
324 	if (0 && (ERRLOGMASK & type) || debug == 1)	\
325 		pr_info(fmt, ##args);			\
326 } while (0)
327 #endif
328 
329 /* These are used to simplify getting data in from and back to user land */
330 #define IOCTL_IN(arg, type, in)					\
331 	if (copy_from_user(&(in), (type __user *) (arg), sizeof (in)))	\
332 		return -EFAULT;
333 
334 #define IOCTL_OUT(arg, type, out) \
335 	if (copy_to_user((type __user *) (arg), &(out), sizeof (out)))	\
336 		return -EFAULT;
337 
338 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
339    a lot of places. This macro makes the code more clear. */
340 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
341 
342 /* used in the audio ioctls */
343 #define CHECKAUDIO if ((ret=check_for_audio_disc(cdi, cdo))) return ret
344 
345 /*
346  * Another popular OS uses 7 seconds as the hard timeout for default
347  * commands, so it is a good choice for us as well.
348  */
349 #define CDROM_DEF_TIMEOUT	(7 * HZ)
350 
351 /* Not-exported routines. */
352 static int open_for_data(struct cdrom_device_info * cdi);
353 static int check_for_audio_disc(struct cdrom_device_info * cdi,
354 			 struct cdrom_device_ops * cdo);
355 static void sanitize_format(union cdrom_addr *addr,
356 		u_char * curr, u_char requested);
357 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
358 		     unsigned long arg);
359 
360 int cdrom_get_last_written(struct cdrom_device_info *, long *);
361 static int cdrom_get_next_writable(struct cdrom_device_info *, long *);
362 static void cdrom_count_tracks(struct cdrom_device_info *, tracktype*);
363 
364 static int cdrom_mrw_exit(struct cdrom_device_info *cdi);
365 
366 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di);
367 
368 static void cdrom_sysctl_register(void);
369 
370 static LIST_HEAD(cdrom_list);
371 
372 static int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
373 				      struct packet_command *cgc)
374 {
375 	if (cgc->sense) {
376 		cgc->sense->sense_key = 0x05;
377 		cgc->sense->asc = 0x20;
378 		cgc->sense->ascq = 0x00;
379 	}
380 
381 	cgc->stat = -EIO;
382 	return -EIO;
383 }
384 
385 /* This macro makes sure we don't have to check on cdrom_device_ops
386  * existence in the run-time routines below. Change_capability is a
387  * hack to have the capability flags defined const, while we can still
388  * change it here without gcc complaining at every line.
389  */
390 #define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
391 
392 int register_cdrom(struct cdrom_device_info *cdi)
393 {
394 	static char banner_printed;
395         struct cdrom_device_ops *cdo = cdi->ops;
396         int *change_capability = (int *)&cdo->capability; /* hack */
397 
398 	cdinfo(CD_OPEN, "entering register_cdrom\n");
399 
400 	if (cdo->open == NULL || cdo->release == NULL)
401 		return -EINVAL;
402 	if (!banner_printed) {
403 		pr_info("Uniform CD-ROM driver " REVISION "\n");
404 		banner_printed = 1;
405 		cdrom_sysctl_register();
406 	}
407 
408 	ENSURE(drive_status, CDC_DRIVE_STATUS );
409 	if (cdo->check_events == NULL && cdo->media_changed == NULL)
410 		*change_capability = ~(CDC_MEDIA_CHANGED | CDC_SELECT_DISC);
411 	ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
412 	ENSURE(lock_door, CDC_LOCK);
413 	ENSURE(select_speed, CDC_SELECT_SPEED);
414 	ENSURE(get_last_session, CDC_MULTI_SESSION);
415 	ENSURE(get_mcn, CDC_MCN);
416 	ENSURE(reset, CDC_RESET);
417 	ENSURE(generic_packet, CDC_GENERIC_PACKET);
418 	cdi->mc_flags = 0;
419 	cdo->n_minors = 0;
420         cdi->options = CDO_USE_FFLAGS;
421 
422 	if (autoclose==1 && CDROM_CAN(CDC_CLOSE_TRAY))
423 		cdi->options |= (int) CDO_AUTO_CLOSE;
424 	if (autoeject==1 && CDROM_CAN(CDC_OPEN_TRAY))
425 		cdi->options |= (int) CDO_AUTO_EJECT;
426 	if (lockdoor==1)
427 		cdi->options |= (int) CDO_LOCK;
428 	if (check_media_type==1)
429 		cdi->options |= (int) CDO_CHECK_TYPE;
430 
431 	if (CDROM_CAN(CDC_MRW_W))
432 		cdi->exit = cdrom_mrw_exit;
433 
434 	if (cdi->disk)
435 		cdi->cdda_method = CDDA_BPC_FULL;
436 	else
437 		cdi->cdda_method = CDDA_OLD;
438 
439 	if (!cdo->generic_packet)
440 		cdo->generic_packet = cdrom_dummy_generic_packet;
441 
442 	cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
443 	mutex_lock(&cdrom_mutex);
444 	list_add(&cdi->list, &cdrom_list);
445 	mutex_unlock(&cdrom_mutex);
446 	return 0;
447 }
448 #undef ENSURE
449 
450 void unregister_cdrom(struct cdrom_device_info *cdi)
451 {
452 	cdinfo(CD_OPEN, "entering unregister_cdrom\n");
453 
454 	mutex_lock(&cdrom_mutex);
455 	list_del(&cdi->list);
456 	mutex_unlock(&cdrom_mutex);
457 
458 	if (cdi->exit)
459 		cdi->exit(cdi);
460 
461 	cdi->ops->n_minors--;
462 	cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
463 }
464 
465 int cdrom_get_media_event(struct cdrom_device_info *cdi,
466 			  struct media_event_desc *med)
467 {
468 	struct packet_command cgc;
469 	unsigned char buffer[8];
470 	struct event_header *eh = (struct event_header *) buffer;
471 
472 	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
473 	cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
474 	cgc.cmd[1] = 1;		/* IMMED */
475 	cgc.cmd[4] = 1 << 4;	/* media event */
476 	cgc.cmd[8] = sizeof(buffer);
477 	cgc.quiet = 1;
478 
479 	if (cdi->ops->generic_packet(cdi, &cgc))
480 		return 1;
481 
482 	if (be16_to_cpu(eh->data_len) < sizeof(*med))
483 		return 1;
484 
485 	if (eh->nea || eh->notification_class != 0x4)
486 		return 1;
487 
488 	memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
489 	return 0;
490 }
491 
492 /*
493  * the first prototypes used 0x2c as the page code for the mrw mode page,
494  * subsequently this was changed to 0x03. probe the one used by this drive
495  */
496 static int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
497 {
498 	struct packet_command cgc;
499 	char buffer[16];
500 
501 	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
502 
503 	cgc.timeout = HZ;
504 	cgc.quiet = 1;
505 
506 	if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
507 		cdi->mrw_mode_page = MRW_MODE_PC;
508 		return 0;
509 	} else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
510 		cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
511 		return 0;
512 	}
513 
514 	return 1;
515 }
516 
517 static int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
518 {
519 	struct packet_command cgc;
520 	struct mrw_feature_desc *mfd;
521 	unsigned char buffer[16];
522 	int ret;
523 
524 	*write = 0;
525 
526 	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
527 
528 	cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
529 	cgc.cmd[3] = CDF_MRW;
530 	cgc.cmd[8] = sizeof(buffer);
531 	cgc.quiet = 1;
532 
533 	if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
534 		return ret;
535 
536 	mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
537 	if (be16_to_cpu(mfd->feature_code) != CDF_MRW)
538 		return 1;
539 	*write = mfd->write;
540 
541 	if ((ret = cdrom_mrw_probe_pc(cdi))) {
542 		*write = 0;
543 		return ret;
544 	}
545 
546 	return 0;
547 }
548 
549 static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
550 {
551 	struct packet_command cgc;
552 	unsigned char buffer[12];
553 	int ret;
554 
555 	pr_info("%sstarting format\n", cont ? "Re" : "");
556 
557 	/*
558 	 * FmtData bit set (bit 4), format type is 1
559 	 */
560 	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
561 	cgc.cmd[0] = GPCMD_FORMAT_UNIT;
562 	cgc.cmd[1] = (1 << 4) | 1;
563 
564 	cgc.timeout = 5 * 60 * HZ;
565 
566 	/*
567 	 * 4 byte format list header, 8 byte format list descriptor
568 	 */
569 	buffer[1] = 1 << 1;
570 	buffer[3] = 8;
571 
572 	/*
573 	 * nr_blocks field
574 	 */
575 	buffer[4] = 0xff;
576 	buffer[5] = 0xff;
577 	buffer[6] = 0xff;
578 	buffer[7] = 0xff;
579 
580 	buffer[8] = 0x24 << 2;
581 	buffer[11] = cont;
582 
583 	ret = cdi->ops->generic_packet(cdi, &cgc);
584 	if (ret)
585 		pr_info("bgformat failed\n");
586 
587 	return ret;
588 }
589 
590 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
591 {
592 	struct packet_command cgc;
593 
594 	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
595 	cgc.cmd[0] = GPCMD_CLOSE_TRACK;
596 
597 	/*
598 	 * Session = 1, Track = 0
599 	 */
600 	cgc.cmd[1] = !!immed;
601 	cgc.cmd[2] = 1 << 1;
602 
603 	cgc.timeout = 5 * 60 * HZ;
604 
605 	return cdi->ops->generic_packet(cdi, &cgc);
606 }
607 
608 static int cdrom_flush_cache(struct cdrom_device_info *cdi)
609 {
610 	struct packet_command cgc;
611 
612 	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
613 	cgc.cmd[0] = GPCMD_FLUSH_CACHE;
614 
615 	cgc.timeout = 5 * 60 * HZ;
616 
617 	return cdi->ops->generic_packet(cdi, &cgc);
618 }
619 
620 static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
621 {
622 	disc_information di;
623 	int ret;
624 
625 	ret = cdrom_get_disc_info(cdi, &di);
626 	if (ret < 0 || ret < (int)offsetof(typeof(di),disc_type))
627 		return 1;
628 
629 	ret = 0;
630 	if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
631 		pr_info("issuing MRW background format suspend\n");
632 		ret = cdrom_mrw_bgformat_susp(cdi, 0);
633 	}
634 
635 	if (!ret && cdi->media_written)
636 		ret = cdrom_flush_cache(cdi);
637 
638 	return ret;
639 }
640 
641 static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
642 {
643 	struct packet_command cgc;
644 	struct mode_page_header *mph;
645 	char buffer[16];
646 	int ret, offset, size;
647 
648 	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
649 
650 	cgc.buffer = buffer;
651 	cgc.buflen = sizeof(buffer);
652 
653 	if ((ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0)))
654 		return ret;
655 
656 	mph = (struct mode_page_header *) buffer;
657 	offset = be16_to_cpu(mph->desc_length);
658 	size = be16_to_cpu(mph->mode_data_length) + 2;
659 
660 	buffer[offset + 3] = space;
661 	cgc.buflen = size;
662 
663 	if ((ret = cdrom_mode_select(cdi, &cgc)))
664 		return ret;
665 
666 	pr_info("%s: mrw address space %s selected\n",
667 		cdi->name, mrw_address_space[space]);
668 	return 0;
669 }
670 
671 static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
672 			      struct rwrt_feature_desc *rfd)
673 {
674 	struct packet_command cgc;
675 	char buffer[24];
676 	int ret;
677 
678 	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
679 
680 	cgc.cmd[0] = GPCMD_GET_CONFIGURATION;	/* often 0x46 */
681 	cgc.cmd[3] = CDF_RWRT;			/* often 0x0020 */
682 	cgc.cmd[8] = sizeof(buffer);		/* often 0x18 */
683 	cgc.quiet = 1;
684 
685 	if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
686 		return ret;
687 
688 	memcpy(rfd, &buffer[sizeof(struct feature_header)], sizeof (*rfd));
689 	return 0;
690 }
691 
692 static int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
693 {
694 	struct packet_command cgc;
695 	char buffer[16];
696 	__be16 *feature_code;
697 	int ret;
698 
699 	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
700 
701 	cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
702 	cgc.cmd[3] = CDF_HWDM;
703 	cgc.cmd[8] = sizeof(buffer);
704 	cgc.quiet = 1;
705 
706 	if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
707 		return ret;
708 
709 	feature_code = (__be16 *) &buffer[sizeof(struct feature_header)];
710 	if (be16_to_cpu(*feature_code) == CDF_HWDM)
711 		return 0;
712 
713 	return 1;
714 }
715 
716 
717 static int cdrom_is_random_writable(struct cdrom_device_info *cdi, int *write)
718 {
719 	struct rwrt_feature_desc rfd;
720 	int ret;
721 
722 	*write = 0;
723 
724 	if ((ret = cdrom_get_random_writable(cdi, &rfd)))
725 		return ret;
726 
727 	if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
728 		*write = 1;
729 
730 	return 0;
731 }
732 
733 static int cdrom_media_erasable(struct cdrom_device_info *cdi)
734 {
735 	disc_information di;
736 	int ret;
737 
738 	ret = cdrom_get_disc_info(cdi, &di);
739 	if (ret < 0 || ret < offsetof(typeof(di), n_first_track))
740 		return -1;
741 
742 	return di.erasable;
743 }
744 
745 /*
746  * FIXME: check RO bit
747  */
748 static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
749 {
750 	int ret = cdrom_media_erasable(cdi);
751 
752 	/*
753 	 * allow writable open if media info read worked and media is
754 	 * erasable, _or_ if it fails since not all drives support it
755 	 */
756 	if (!ret)
757 		return 1;
758 
759 	return 0;
760 }
761 
762 static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
763 {
764 	disc_information di;
765 	int ret;
766 
767 	/*
768 	 * always reset to DMA lba space on open
769 	 */
770 	if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_DMA)) {
771 		pr_err("failed setting lba address space\n");
772 		return 1;
773 	}
774 
775 	ret = cdrom_get_disc_info(cdi, &di);
776 	if (ret < 0 || ret < offsetof(typeof(di),disc_type))
777 		return 1;
778 
779 	if (!di.erasable)
780 		return 1;
781 
782 	/*
783 	 * mrw_status
784 	 * 0	-	not MRW formatted
785 	 * 1	-	MRW bgformat started, but not running or complete
786 	 * 2	-	MRW bgformat in progress
787 	 * 3	-	MRW formatting complete
788 	 */
789 	ret = 0;
790 	pr_info("open: mrw_status '%s'\n", mrw_format_status[di.mrw_status]);
791 	if (!di.mrw_status)
792 		ret = 1;
793 	else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE &&
794 			mrw_format_restart)
795 		ret = cdrom_mrw_bgformat(cdi, 1);
796 
797 	return ret;
798 }
799 
800 static int mo_open_write(struct cdrom_device_info *cdi)
801 {
802 	struct packet_command cgc;
803 	char buffer[255];
804 	int ret;
805 
806 	init_cdrom_command(&cgc, &buffer, 4, CGC_DATA_READ);
807 	cgc.quiet = 1;
808 
809 	/*
810 	 * obtain write protect information as per
811 	 * drivers/scsi/sd.c:sd_read_write_protect_flag
812 	 */
813 
814 	ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
815 	if (ret)
816 		ret = cdrom_mode_sense(cdi, &cgc, GPMODE_VENDOR_PAGE, 0);
817 	if (ret) {
818 		cgc.buflen = 255;
819 		ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
820 	}
821 
822 	/* drive gave us no info, let the user go ahead */
823 	if (ret)
824 		return 0;
825 
826 	return buffer[3] & 0x80;
827 }
828 
829 static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
830 {
831 	struct rwrt_feature_desc rfd;
832 	int ret;
833 
834 	if ((ret = cdrom_has_defect_mgt(cdi)))
835 		return ret;
836 
837 	if ((ret = cdrom_get_random_writable(cdi, &rfd)))
838 		return ret;
839 	else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
840 		ret = !rfd.curr;
841 
842 	cdinfo(CD_OPEN, "can open for random write\n");
843 	return ret;
844 }
845 
846 static void cdrom_mmc3_profile(struct cdrom_device_info *cdi)
847 {
848 	struct packet_command cgc;
849 	char buffer[32];
850 	int ret, mmc3_profile;
851 
852 	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
853 
854 	cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
855 	cgc.cmd[1] = 0;
856 	cgc.cmd[2] = cgc.cmd[3] = 0;		/* Starting Feature Number */
857 	cgc.cmd[8] = sizeof(buffer);		/* Allocation Length */
858 	cgc.quiet = 1;
859 
860 	if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
861 		mmc3_profile = 0xffff;
862 	else
863 		mmc3_profile = (buffer[6] << 8) | buffer[7];
864 
865 	cdi->mmc3_profile = mmc3_profile;
866 }
867 
868 static int cdrom_is_dvd_rw(struct cdrom_device_info *cdi)
869 {
870 	switch (cdi->mmc3_profile) {
871 	case 0x12:	/* DVD-RAM	*/
872 	case 0x1A:	/* DVD+RW	*/
873 		return 0;
874 	default:
875 		return 1;
876 	}
877 }
878 
879 /*
880  * returns 0 for ok to open write, non-0 to disallow
881  */
882 static int cdrom_open_write(struct cdrom_device_info *cdi)
883 {
884 	int mrw, mrw_write, ram_write;
885 	int ret = 1;
886 
887 	mrw = 0;
888 	if (!cdrom_is_mrw(cdi, &mrw_write))
889 		mrw = 1;
890 
891 	if (CDROM_CAN(CDC_MO_DRIVE))
892 		ram_write = 1;
893 	else
894 		(void) cdrom_is_random_writable(cdi, &ram_write);
895 
896 	if (mrw)
897 		cdi->mask &= ~CDC_MRW;
898 	else
899 		cdi->mask |= CDC_MRW;
900 
901 	if (mrw_write)
902 		cdi->mask &= ~CDC_MRW_W;
903 	else
904 		cdi->mask |= CDC_MRW_W;
905 
906 	if (ram_write)
907 		cdi->mask &= ~CDC_RAM;
908 	else
909 		cdi->mask |= CDC_RAM;
910 
911 	if (CDROM_CAN(CDC_MRW_W))
912 		ret = cdrom_mrw_open_write(cdi);
913 	else if (CDROM_CAN(CDC_DVD_RAM))
914 		ret = cdrom_dvdram_open_write(cdi);
915  	else if (CDROM_CAN(CDC_RAM) &&
916  		 !CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW|CDC_MO_DRIVE))
917  		ret = cdrom_ram_open_write(cdi);
918 	else if (CDROM_CAN(CDC_MO_DRIVE))
919 		ret = mo_open_write(cdi);
920 	else if (!cdrom_is_dvd_rw(cdi))
921 		ret = 0;
922 
923 	return ret;
924 }
925 
926 static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
927 {
928 	struct packet_command cgc;
929 
930 	if (cdi->mmc3_profile != 0x1a) {
931 		cdinfo(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
932 		return;
933 	}
934 
935 	if (!cdi->media_written) {
936 		cdinfo(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
937 		return;
938 	}
939 
940 	pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi->name);
941 
942 	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
943 	cgc.cmd[0] = GPCMD_FLUSH_CACHE;
944 	cgc.timeout = 30*HZ;
945 	cdi->ops->generic_packet(cdi, &cgc);
946 
947 	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
948 	cgc.cmd[0] = GPCMD_CLOSE_TRACK;
949 	cgc.timeout = 3000*HZ;
950 	cgc.quiet = 1;
951 	cdi->ops->generic_packet(cdi, &cgc);
952 
953 	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
954 	cgc.cmd[0] = GPCMD_CLOSE_TRACK;
955 	cgc.cmd[2] = 2;	 /* Close session */
956 	cgc.quiet = 1;
957 	cgc.timeout = 3000*HZ;
958 	cdi->ops->generic_packet(cdi, &cgc);
959 
960 	cdi->media_written = 0;
961 }
962 
963 static int cdrom_close_write(struct cdrom_device_info *cdi)
964 {
965 #if 0
966 	return cdrom_flush_cache(cdi);
967 #else
968 	return 0;
969 #endif
970 }
971 
972 /* We use the open-option O_NONBLOCK to indicate that the
973  * purpose of opening is only for subsequent ioctl() calls; no device
974  * integrity checks are performed.
975  *
976  * We hope that all cd-player programs will adopt this convention. It
977  * is in their own interest: device control becomes a lot easier
978  * this way.
979  */
980 int cdrom_open(struct cdrom_device_info *cdi, struct block_device *bdev, fmode_t mode)
981 {
982 	int ret;
983 
984 	cdinfo(CD_OPEN, "entering cdrom_open\n");
985 
986 	/* open is event synchronization point, check events first */
987 	check_disk_change(bdev);
988 
989 	/* if this was a O_NONBLOCK open and we should honor the flags,
990 	 * do a quick open without drive/disc integrity checks. */
991 	cdi->use_count++;
992 	if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) {
993 		ret = cdi->ops->open(cdi, 1);
994 	} else {
995 		ret = open_for_data(cdi);
996 		if (ret)
997 			goto err;
998 		cdrom_mmc3_profile(cdi);
999 		if (mode & FMODE_WRITE) {
1000 			ret = -EROFS;
1001 			if (cdrom_open_write(cdi))
1002 				goto err_release;
1003 			if (!CDROM_CAN(CDC_RAM))
1004 				goto err_release;
1005 			ret = 0;
1006 			cdi->media_written = 0;
1007 		}
1008 	}
1009 
1010 	if (ret)
1011 		goto err;
1012 
1013 	cdinfo(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1014 			cdi->name, cdi->use_count);
1015 	return 0;
1016 err_release:
1017 	if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1018 		cdi->ops->lock_door(cdi, 0);
1019 		cdinfo(CD_OPEN, "door unlocked.\n");
1020 	}
1021 	cdi->ops->release(cdi);
1022 err:
1023 	cdi->use_count--;
1024 	return ret;
1025 }
1026 
1027 static
1028 int open_for_data(struct cdrom_device_info * cdi)
1029 {
1030 	int ret;
1031 	struct cdrom_device_ops *cdo = cdi->ops;
1032 	tracktype tracks;
1033 	cdinfo(CD_OPEN, "entering open_for_data\n");
1034 	/* Check if the driver can report drive status.  If it can, we
1035 	   can do clever things.  If it can't, well, we at least tried! */
1036 	if (cdo->drive_status != NULL) {
1037 		ret = cdo->drive_status(cdi, CDSL_CURRENT);
1038 		cdinfo(CD_OPEN, "drive_status=%d\n", ret);
1039 		if (ret == CDS_TRAY_OPEN) {
1040 			cdinfo(CD_OPEN, "the tray is open...\n");
1041 			/* can/may i close it? */
1042 			if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1043 			    cdi->options & CDO_AUTO_CLOSE) {
1044 				cdinfo(CD_OPEN, "trying to close the tray.\n");
1045 				ret=cdo->tray_move(cdi,0);
1046 				if (ret) {
1047 					cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1048 					/* Ignore the error from the low
1049 					level driver.  We don't care why it
1050 					couldn't close the tray.  We only care
1051 					that there is no disc in the drive,
1052 					since that is the _REAL_ problem here.*/
1053 					ret=-ENOMEDIUM;
1054 					goto clean_up_and_return;
1055 				}
1056 			} else {
1057 				cdinfo(CD_OPEN, "bummer. this drive can't close the tray.\n");
1058 				ret=-ENOMEDIUM;
1059 				goto clean_up_and_return;
1060 			}
1061 			/* Ok, the door should be closed now.. Check again */
1062 			ret = cdo->drive_status(cdi, CDSL_CURRENT);
1063 			if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1064 				cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
1065 				cdinfo(CD_OPEN, "tray might not contain a medium.\n");
1066 				ret=-ENOMEDIUM;
1067 				goto clean_up_and_return;
1068 			}
1069 			cdinfo(CD_OPEN, "the tray is now closed.\n");
1070 		}
1071 		/* the door should be closed now, check for the disc */
1072 		ret = cdo->drive_status(cdi, CDSL_CURRENT);
1073 		if (ret!=CDS_DISC_OK) {
1074 			ret = -ENOMEDIUM;
1075 			goto clean_up_and_return;
1076 		}
1077 	}
1078 	cdrom_count_tracks(cdi, &tracks);
1079 	if (tracks.error == CDS_NO_DISC) {
1080 		cdinfo(CD_OPEN, "bummer. no disc.\n");
1081 		ret=-ENOMEDIUM;
1082 		goto clean_up_and_return;
1083 	}
1084 	/* CD-Players which don't use O_NONBLOCK, workman
1085 	 * for example, need bit CDO_CHECK_TYPE cleared! */
1086 	if (tracks.data==0) {
1087 		if (cdi->options & CDO_CHECK_TYPE) {
1088 		    /* give people a warning shot, now that CDO_CHECK_TYPE
1089 		       is the default case! */
1090 		    cdinfo(CD_OPEN, "bummer. wrong media type.\n");
1091 		    cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1092 					(unsigned int)task_pid_nr(current));
1093 		    ret=-EMEDIUMTYPE;
1094 		    goto clean_up_and_return;
1095 		}
1096 		else {
1097 		    cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.\n");
1098 		}
1099 	}
1100 
1101 	cdinfo(CD_OPEN, "all seems well, opening the device.\n");
1102 
1103 	/* all seems well, we can open the device */
1104 	ret = cdo->open(cdi, 0); /* open for data */
1105 	cdinfo(CD_OPEN, "opening the device gave me %d.\n", ret);
1106 	/* After all this careful checking, we shouldn't have problems
1107 	   opening the device, but we don't want the device locked if
1108 	   this somehow fails... */
1109 	if (ret) {
1110 		cdinfo(CD_OPEN, "open device failed.\n");
1111 		goto clean_up_and_return;
1112 	}
1113 	if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1114 			cdo->lock_door(cdi, 1);
1115 			cdinfo(CD_OPEN, "door locked.\n");
1116 	}
1117 	cdinfo(CD_OPEN, "device opened successfully.\n");
1118 	return ret;
1119 
1120 	/* Something failed.  Try to unlock the drive, because some drivers
1121 	(notably ide-cd) lock the drive after every command.  This produced
1122 	a nasty bug where after mount failed, the drive would remain locked!
1123 	This ensures that the drive gets unlocked after a mount fails.  This
1124 	is a goto to avoid bloating the driver with redundant code. */
1125 clean_up_and_return:
1126 	cdinfo(CD_OPEN, "open failed.\n");
1127 	if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1128 			cdo->lock_door(cdi, 0);
1129 			cdinfo(CD_OPEN, "door unlocked.\n");
1130 	}
1131 	return ret;
1132 }
1133 
1134 /* This code is similar to that in open_for_data. The routine is called
1135    whenever an audio play operation is requested.
1136 */
1137 static int check_for_audio_disc(struct cdrom_device_info * cdi,
1138 				struct cdrom_device_ops * cdo)
1139 {
1140         int ret;
1141 	tracktype tracks;
1142 	cdinfo(CD_OPEN, "entering check_for_audio_disc\n");
1143 	if (!(cdi->options & CDO_CHECK_TYPE))
1144 		return 0;
1145 	if (cdo->drive_status != NULL) {
1146 		ret = cdo->drive_status(cdi, CDSL_CURRENT);
1147 		cdinfo(CD_OPEN, "drive_status=%d\n", ret);
1148 		if (ret == CDS_TRAY_OPEN) {
1149 			cdinfo(CD_OPEN, "the tray is open...\n");
1150 			/* can/may i close it? */
1151 			if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1152 			    cdi->options & CDO_AUTO_CLOSE) {
1153 				cdinfo(CD_OPEN, "trying to close the tray.\n");
1154 				ret=cdo->tray_move(cdi,0);
1155 				if (ret) {
1156 					cdinfo(CD_OPEN, "bummer. tried to close tray but failed.\n");
1157 					/* Ignore the error from the low
1158 					level driver.  We don't care why it
1159 					couldn't close the tray.  We only care
1160 					that there is no disc in the drive,
1161 					since that is the _REAL_ problem here.*/
1162 					return -ENOMEDIUM;
1163 				}
1164 			} else {
1165 				cdinfo(CD_OPEN, "bummer. this driver can't close the tray.\n");
1166 				return -ENOMEDIUM;
1167 			}
1168 			/* Ok, the door should be closed now.. Check again */
1169 			ret = cdo->drive_status(cdi, CDSL_CURRENT);
1170 			if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1171 				cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
1172 				return -ENOMEDIUM;
1173 			}
1174 			if (ret!=CDS_DISC_OK) {
1175 				cdinfo(CD_OPEN, "bummer. disc isn't ready.\n");
1176 				return -EIO;
1177 			}
1178 			cdinfo(CD_OPEN, "the tray is now closed.\n");
1179 		}
1180 	}
1181 	cdrom_count_tracks(cdi, &tracks);
1182 	if (tracks.error)
1183 		return(tracks.error);
1184 
1185 	if (tracks.audio==0)
1186 		return -EMEDIUMTYPE;
1187 
1188 	return 0;
1189 }
1190 
1191 void cdrom_release(struct cdrom_device_info *cdi, fmode_t mode)
1192 {
1193 	struct cdrom_device_ops *cdo = cdi->ops;
1194 	int opened_for_data;
1195 
1196 	cdinfo(CD_CLOSE, "entering cdrom_release\n");
1197 
1198 	if (cdi->use_count > 0)
1199 		cdi->use_count--;
1200 
1201 	if (cdi->use_count == 0) {
1202 		cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
1203 		cdrom_dvd_rw_close_write(cdi);
1204 
1205 		if ((cdo->capability & CDC_LOCK) && !cdi->keeplocked) {
1206 			cdinfo(CD_CLOSE, "Unlocking door!\n");
1207 			cdo->lock_door(cdi, 0);
1208 		}
1209 	}
1210 
1211 	opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1212 		!(mode & FMODE_NDELAY);
1213 
1214 	/*
1215 	 * flush cache on last write release
1216 	 */
1217 	if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1218 		cdrom_close_write(cdi);
1219 
1220 	cdo->release(cdi);
1221 	if (cdi->use_count == 0) {      /* last process that closes dev*/
1222 		if (opened_for_data &&
1223 		    cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1224 			cdo->tray_move(cdi, 1);
1225 	}
1226 }
1227 
1228 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1229 				  struct cdrom_changer_info *buf)
1230 {
1231 	struct packet_command cgc;
1232 	struct cdrom_device_ops *cdo = cdi->ops;
1233 	int length;
1234 
1235 	/*
1236 	 * Sanyo changer isn't spec compliant (doesn't use regular change
1237 	 * LOAD_UNLOAD command, and it doesn't implement the mech status
1238 	 * command below
1239 	 */
1240 	if (cdi->sanyo_slot) {
1241 		buf->hdr.nslots = 3;
1242 		buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1243 		for (length = 0; length < 3; length++) {
1244 			buf->slots[length].disc_present = 1;
1245 			buf->slots[length].change = 0;
1246 		}
1247 		return 0;
1248 	}
1249 
1250 	length = sizeof(struct cdrom_mechstat_header) +
1251 		 cdi->capacity * sizeof(struct cdrom_slot);
1252 
1253 	init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1254 	cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1255 	cgc.cmd[8] = (length >> 8) & 0xff;
1256 	cgc.cmd[9] = length & 0xff;
1257 	return cdo->generic_packet(cdi, &cgc);
1258 }
1259 
1260 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1261 {
1262 	struct cdrom_changer_info *info;
1263 	int ret;
1264 
1265 	cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n");
1266 	if (cdi->sanyo_slot)
1267 		return CDS_NO_INFO;
1268 
1269 	info = kmalloc(sizeof(*info), GFP_KERNEL);
1270 	if (!info)
1271 		return -ENOMEM;
1272 
1273 	if ((ret = cdrom_read_mech_status(cdi, info)))
1274 		goto out_free;
1275 
1276 	if (info->slots[slot].disc_present)
1277 		ret = CDS_DISC_OK;
1278 	else
1279 		ret = CDS_NO_DISC;
1280 
1281 out_free:
1282 	kfree(info);
1283 	return ret;
1284 }
1285 
1286 /* Return the number of slots for an ATAPI/SCSI cdrom,
1287  * return 1 if not a changer.
1288  */
1289 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1290 {
1291 	int status;
1292 	int nslots = 1;
1293 	struct cdrom_changer_info *info;
1294 
1295 	cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1296 	/* cdrom_read_mech_status requires a valid value for capacity: */
1297 	cdi->capacity = 0;
1298 
1299 	info = kmalloc(sizeof(*info), GFP_KERNEL);
1300 	if (!info)
1301 		return -ENOMEM;
1302 
1303 	if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1304 		nslots = info->hdr.nslots;
1305 
1306 	kfree(info);
1307 	return nslots;
1308 }
1309 
1310 
1311 /* If SLOT < 0, unload the current slot.  Otherwise, try to load SLOT. */
1312 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1313 {
1314 	struct packet_command cgc;
1315 
1316 	cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n");
1317 	if (cdi->sanyo_slot && slot < 0)
1318 		return 0;
1319 
1320 	init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1321 	cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1322 	cgc.cmd[4] = 2 + (slot >= 0);
1323 	cgc.cmd[8] = slot;
1324 	cgc.timeout = 60 * HZ;
1325 
1326 	/* The Sanyo 3 CD changer uses byte 7 of the
1327 	GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1328 	using the GPCMD_LOAD_UNLOAD opcode. */
1329 	if (cdi->sanyo_slot && -1 < slot) {
1330 		cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1331 		cgc.cmd[7] = slot;
1332 		cgc.cmd[4] = cgc.cmd[8] = 0;
1333 		cdi->sanyo_slot = slot ? slot : 3;
1334 	}
1335 
1336 	return cdi->ops->generic_packet(cdi, &cgc);
1337 }
1338 
1339 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1340 {
1341 	struct cdrom_changer_info *info;
1342 	int curslot;
1343 	int ret;
1344 
1345 	cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n");
1346 	if (!CDROM_CAN(CDC_SELECT_DISC))
1347 		return -EDRIVE_CANT_DO_THIS;
1348 
1349 	if (cdi->ops->check_events)
1350 		cdi->ops->check_events(cdi, 0, slot);
1351 	else
1352 		cdi->ops->media_changed(cdi, slot);
1353 
1354 	if (slot == CDSL_NONE) {
1355 		/* set media changed bits, on both queues */
1356 		cdi->mc_flags = 0x3;
1357 		return cdrom_load_unload(cdi, -1);
1358 	}
1359 
1360 	info = kmalloc(sizeof(*info), GFP_KERNEL);
1361 	if (!info)
1362 		return -ENOMEM;
1363 
1364 	if ((ret = cdrom_read_mech_status(cdi, info))) {
1365 		kfree(info);
1366 		return ret;
1367 	}
1368 
1369 	curslot = info->hdr.curslot;
1370 	kfree(info);
1371 
1372 	if (cdi->use_count > 1 || cdi->keeplocked) {
1373 		if (slot == CDSL_CURRENT) {
1374 	    		return curslot;
1375 		} else {
1376 			return -EBUSY;
1377 		}
1378 	}
1379 
1380 	/* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1381 	which is useful if it had been previously unloaded.
1382 	Whether it can or not, it returns the current slot.
1383 	Similarly,  if slot happens to be the current one, we still
1384 	try and load it. */
1385 	if (slot == CDSL_CURRENT)
1386 		slot = curslot;
1387 
1388 	/* set media changed bits on both queues */
1389 	cdi->mc_flags = 0x3;
1390 	if ((ret = cdrom_load_unload(cdi, slot)))
1391 		return ret;
1392 
1393 	return slot;
1394 }
1395 
1396 /*
1397  * As cdrom implements an extra ioctl consumer for media changed
1398  * event, it needs to buffer ->check_events() output, such that event
1399  * is not lost for both the usual VFS and ioctl paths.
1400  * cdi->{vfs|ioctl}_events are used to buffer pending events for each
1401  * path.
1402  *
1403  * XXX: Locking is non-existent.  cdi->ops->check_events() can be
1404  * called in parallel and buffering fields are accessed without any
1405  * exclusion.  The original media_changed code had the same problem.
1406  * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1407  * and remove this cruft altogether.  It doesn't have much usefulness
1408  * at this point.
1409  */
1410 static void cdrom_update_events(struct cdrom_device_info *cdi,
1411 				unsigned int clearing)
1412 {
1413 	unsigned int events;
1414 
1415 	events = cdi->ops->check_events(cdi, clearing, CDSL_CURRENT);
1416 	cdi->vfs_events |= events;
1417 	cdi->ioctl_events |= events;
1418 }
1419 
1420 unsigned int cdrom_check_events(struct cdrom_device_info *cdi,
1421 				unsigned int clearing)
1422 {
1423 	unsigned int events;
1424 
1425 	cdrom_update_events(cdi, clearing);
1426 	events = cdi->vfs_events;
1427 	cdi->vfs_events = 0;
1428 	return events;
1429 }
1430 EXPORT_SYMBOL(cdrom_check_events);
1431 
1432 /* We want to make media_changed accessible to the user through an
1433  * ioctl. The main problem now is that we must double-buffer the
1434  * low-level implementation, to assure that the VFS and the user both
1435  * see a medium change once.
1436  */
1437 
1438 static
1439 int media_changed(struct cdrom_device_info *cdi, int queue)
1440 {
1441 	unsigned int mask = (1 << (queue & 1));
1442 	int ret = !!(cdi->mc_flags & mask);
1443 	bool changed;
1444 
1445 	if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1446 		return ret;
1447 
1448 	/* changed since last call? */
1449 	if (cdi->ops->check_events) {
1450 		BUG_ON(!queue);	/* shouldn't be called from VFS path */
1451 		cdrom_update_events(cdi, DISK_EVENT_MEDIA_CHANGE);
1452 		changed = cdi->ioctl_events & DISK_EVENT_MEDIA_CHANGE;
1453 		cdi->ioctl_events = 0;
1454 	} else
1455 		changed = cdi->ops->media_changed(cdi, CDSL_CURRENT);
1456 
1457 	if (changed) {
1458 		cdi->mc_flags = 0x3;    /* set bit on both queues */
1459 		ret |= 1;
1460 		cdi->media_written = 0;
1461 	}
1462 
1463 	cdi->mc_flags &= ~mask;         /* clear bit */
1464 	return ret;
1465 }
1466 
1467 int cdrom_media_changed(struct cdrom_device_info *cdi)
1468 {
1469 	/* This talks to the VFS, which doesn't like errors - just 1 or 0.
1470 	 * Returning "0" is always safe (media hasn't been changed). Do that
1471 	 * if the low-level cdrom driver dosn't support media changed. */
1472 	if (cdi == NULL || cdi->ops->media_changed == NULL)
1473 		return 0;
1474 	if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1475 		return 0;
1476 	return media_changed(cdi, 0);
1477 }
1478 
1479 /* badly broken, I know. Is due for a fixup anytime. */
1480 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1481 {
1482 	struct cdrom_tochdr header;
1483 	struct cdrom_tocentry entry;
1484 	int ret, i;
1485 	tracks->data=0;
1486 	tracks->audio=0;
1487 	tracks->cdi=0;
1488 	tracks->xa=0;
1489 	tracks->error=0;
1490 	cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1491 	/* Grab the TOC header so we can see how many tracks there are */
1492 	if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1493 		if (ret == -ENOMEDIUM)
1494 			tracks->error = CDS_NO_DISC;
1495 		else
1496 			tracks->error = CDS_NO_INFO;
1497 		return;
1498 	}
1499 	/* check what type of tracks are on this disc */
1500 	entry.cdte_format = CDROM_MSF;
1501 	for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1502 		entry.cdte_track  = i;
1503 		if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1504 			tracks->error=CDS_NO_INFO;
1505 			return;
1506 		}
1507 		if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1508 		    if (entry.cdte_format == 0x10)
1509 			tracks->cdi++;
1510 		    else if (entry.cdte_format == 0x20)
1511 			tracks->xa++;
1512 		    else
1513 			tracks->data++;
1514 		} else
1515 		    tracks->audio++;
1516 		cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1517 		       i, entry.cdte_format, entry.cdte_ctrl);
1518 	}
1519 	cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1520 		header.cdth_trk1, tracks->audio, tracks->data,
1521 		tracks->cdi, tracks->xa);
1522 }
1523 
1524 /* Requests to the low-level drivers will /always/ be done in the
1525    following format convention:
1526 
1527    CDROM_LBA: all data-related requests.
1528    CDROM_MSF: all audio-related requests.
1529 
1530    However, a low-level implementation is allowed to refuse this
1531    request, and return information in its own favorite format.
1532 
1533    It doesn't make sense /at all/ to ask for a play_audio in LBA
1534    format, or ask for multi-session info in MSF format. However, for
1535    backward compatibility these format requests will be satisfied, but
1536    the requests to the low-level drivers will be sanitized in the more
1537    meaningful format indicated above.
1538  */
1539 
1540 static
1541 void sanitize_format(union cdrom_addr *addr,
1542 		     u_char * curr, u_char requested)
1543 {
1544 	if (*curr == requested)
1545 		return;                 /* nothing to be done! */
1546 	if (requested == CDROM_LBA) {
1547 		addr->lba = (int) addr->msf.frame +
1548 			75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1549 	} else {                        /* CDROM_MSF */
1550 		int lba = addr->lba;
1551 		addr->msf.frame = lba % 75;
1552 		lba /= 75;
1553 		lba += 2;
1554 		addr->msf.second = lba % 60;
1555 		addr->msf.minute = lba / 60;
1556 	}
1557 	*curr = requested;
1558 }
1559 
1560 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1561 			int type)
1562 {
1563 	memset(cgc, 0, sizeof(struct packet_command));
1564 	if (buf)
1565 		memset(buf, 0, len);
1566 	cgc->buffer = (char *) buf;
1567 	cgc->buflen = len;
1568 	cgc->data_direction = type;
1569 	cgc->timeout = CDROM_DEF_TIMEOUT;
1570 }
1571 
1572 /* DVD handling */
1573 
1574 #define copy_key(dest,src)	memcpy((dest), (src), sizeof(dvd_key))
1575 #define copy_chal(dest,src)	memcpy((dest), (src), sizeof(dvd_challenge))
1576 
1577 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1578 {
1579 	cgc->cmd[0] = GPCMD_REPORT_KEY;
1580 	cgc->cmd[10] = type | (agid << 6);
1581 	switch (type) {
1582 		case 0: case 8: case 5: {
1583 			cgc->buflen = 8;
1584 			break;
1585 		}
1586 		case 1: {
1587 			cgc->buflen = 16;
1588 			break;
1589 		}
1590 		case 2: case 4: {
1591 			cgc->buflen = 12;
1592 			break;
1593 		}
1594 	}
1595 	cgc->cmd[9] = cgc->buflen;
1596 	cgc->data_direction = CGC_DATA_READ;
1597 }
1598 
1599 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1600 {
1601 	cgc->cmd[0] = GPCMD_SEND_KEY;
1602 	cgc->cmd[10] = type | (agid << 6);
1603 	switch (type) {
1604 		case 1: {
1605 			cgc->buflen = 16;
1606 			break;
1607 		}
1608 		case 3: {
1609 			cgc->buflen = 12;
1610 			break;
1611 		}
1612 		case 6: {
1613 			cgc->buflen = 8;
1614 			break;
1615 		}
1616 	}
1617 	cgc->cmd[9] = cgc->buflen;
1618 	cgc->data_direction = CGC_DATA_WRITE;
1619 }
1620 
1621 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1622 {
1623 	int ret;
1624 	u_char buf[20];
1625 	struct packet_command cgc;
1626 	struct cdrom_device_ops *cdo = cdi->ops;
1627 	rpc_state_t rpc_state;
1628 
1629 	memset(buf, 0, sizeof(buf));
1630 	init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1631 
1632 	switch (ai->type) {
1633 	/* LU data send */
1634 	case DVD_LU_SEND_AGID:
1635 		cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1636 		cgc.quiet = 1;
1637 		setup_report_key(&cgc, ai->lsa.agid, 0);
1638 
1639 		if ((ret = cdo->generic_packet(cdi, &cgc)))
1640 			return ret;
1641 
1642 		ai->lsa.agid = buf[7] >> 6;
1643 		/* Returning data, let host change state */
1644 		break;
1645 
1646 	case DVD_LU_SEND_KEY1:
1647 		cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1648 		setup_report_key(&cgc, ai->lsk.agid, 2);
1649 
1650 		if ((ret = cdo->generic_packet(cdi, &cgc)))
1651 			return ret;
1652 
1653 		copy_key(ai->lsk.key, &buf[4]);
1654 		/* Returning data, let host change state */
1655 		break;
1656 
1657 	case DVD_LU_SEND_CHALLENGE:
1658 		cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1659 		setup_report_key(&cgc, ai->lsc.agid, 1);
1660 
1661 		if ((ret = cdo->generic_packet(cdi, &cgc)))
1662 			return ret;
1663 
1664 		copy_chal(ai->lsc.chal, &buf[4]);
1665 		/* Returning data, let host change state */
1666 		break;
1667 
1668 	/* Post-auth key */
1669 	case DVD_LU_SEND_TITLE_KEY:
1670 		cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1671 		cgc.quiet = 1;
1672 		setup_report_key(&cgc, ai->lstk.agid, 4);
1673 		cgc.cmd[5] = ai->lstk.lba;
1674 		cgc.cmd[4] = ai->lstk.lba >> 8;
1675 		cgc.cmd[3] = ai->lstk.lba >> 16;
1676 		cgc.cmd[2] = ai->lstk.lba >> 24;
1677 
1678 		if ((ret = cdo->generic_packet(cdi, &cgc)))
1679 			return ret;
1680 
1681 		ai->lstk.cpm = (buf[4] >> 7) & 1;
1682 		ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1683 		ai->lstk.cgms = (buf[4] >> 4) & 3;
1684 		copy_key(ai->lstk.title_key, &buf[5]);
1685 		/* Returning data, let host change state */
1686 		break;
1687 
1688 	case DVD_LU_SEND_ASF:
1689 		cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1690 		setup_report_key(&cgc, ai->lsasf.agid, 5);
1691 
1692 		if ((ret = cdo->generic_packet(cdi, &cgc)))
1693 			return ret;
1694 
1695 		ai->lsasf.asf = buf[7] & 1;
1696 		break;
1697 
1698 	/* LU data receive (LU changes state) */
1699 	case DVD_HOST_SEND_CHALLENGE:
1700 		cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1701 		setup_send_key(&cgc, ai->hsc.agid, 1);
1702 		buf[1] = 0xe;
1703 		copy_chal(&buf[4], ai->hsc.chal);
1704 
1705 		if ((ret = cdo->generic_packet(cdi, &cgc)))
1706 			return ret;
1707 
1708 		ai->type = DVD_LU_SEND_KEY1;
1709 		break;
1710 
1711 	case DVD_HOST_SEND_KEY2:
1712 		cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1713 		setup_send_key(&cgc, ai->hsk.agid, 3);
1714 		buf[1] = 0xa;
1715 		copy_key(&buf[4], ai->hsk.key);
1716 
1717 		if ((ret = cdo->generic_packet(cdi, &cgc))) {
1718 			ai->type = DVD_AUTH_FAILURE;
1719 			return ret;
1720 		}
1721 		ai->type = DVD_AUTH_ESTABLISHED;
1722 		break;
1723 
1724 	/* Misc */
1725 	case DVD_INVALIDATE_AGID:
1726 		cgc.quiet = 1;
1727 		cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1728 		setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1729 		if ((ret = cdo->generic_packet(cdi, &cgc)))
1730 			return ret;
1731 		break;
1732 
1733 	/* Get region settings */
1734 	case DVD_LU_SEND_RPC_STATE:
1735 		cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1736 		setup_report_key(&cgc, 0, 8);
1737 		memset(&rpc_state, 0, sizeof(rpc_state_t));
1738 		cgc.buffer = (char *) &rpc_state;
1739 
1740 		if ((ret = cdo->generic_packet(cdi, &cgc)))
1741 			return ret;
1742 
1743 		ai->lrpcs.type = rpc_state.type_code;
1744 		ai->lrpcs.vra = rpc_state.vra;
1745 		ai->lrpcs.ucca = rpc_state.ucca;
1746 		ai->lrpcs.region_mask = rpc_state.region_mask;
1747 		ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1748 		break;
1749 
1750 	/* Set region settings */
1751 	case DVD_HOST_SEND_RPC_STATE:
1752 		cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1753 		setup_send_key(&cgc, 0, 6);
1754 		buf[1] = 6;
1755 		buf[4] = ai->hrpcs.pdrc;
1756 
1757 		if ((ret = cdo->generic_packet(cdi, &cgc)))
1758 			return ret;
1759 		break;
1760 
1761 	default:
1762 		cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1763 		return -ENOTTY;
1764 	}
1765 
1766 	return 0;
1767 }
1768 
1769 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s,
1770 				struct packet_command *cgc)
1771 {
1772 	unsigned char buf[21], *base;
1773 	struct dvd_layer *layer;
1774 	struct cdrom_device_ops *cdo = cdi->ops;
1775 	int ret, layer_num = s->physical.layer_num;
1776 
1777 	if (layer_num >= DVD_LAYERS)
1778 		return -EINVAL;
1779 
1780 	init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1781 	cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1782 	cgc->cmd[6] = layer_num;
1783 	cgc->cmd[7] = s->type;
1784 	cgc->cmd[9] = cgc->buflen & 0xff;
1785 
1786 	/*
1787 	 * refrain from reporting errors on non-existing layers (mainly)
1788 	 */
1789 	cgc->quiet = 1;
1790 
1791 	ret = cdo->generic_packet(cdi, cgc);
1792 	if (ret)
1793 		return ret;
1794 
1795 	base = &buf[4];
1796 	layer = &s->physical.layer[layer_num];
1797 
1798 	/*
1799 	 * place the data... really ugly, but at least we won't have to
1800 	 * worry about endianess in userspace.
1801 	 */
1802 	memset(layer, 0, sizeof(*layer));
1803 	layer->book_version = base[0] & 0xf;
1804 	layer->book_type = base[0] >> 4;
1805 	layer->min_rate = base[1] & 0xf;
1806 	layer->disc_size = base[1] >> 4;
1807 	layer->layer_type = base[2] & 0xf;
1808 	layer->track_path = (base[2] >> 4) & 1;
1809 	layer->nlayers = (base[2] >> 5) & 3;
1810 	layer->track_density = base[3] & 0xf;
1811 	layer->linear_density = base[3] >> 4;
1812 	layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1813 	layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1814 	layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1815 	layer->bca = base[16] >> 7;
1816 
1817 	return 0;
1818 }
1819 
1820 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s,
1821 				struct packet_command *cgc)
1822 {
1823 	int ret;
1824 	u_char buf[8];
1825 	struct cdrom_device_ops *cdo = cdi->ops;
1826 
1827 	init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1828 	cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1829 	cgc->cmd[6] = s->copyright.layer_num;
1830 	cgc->cmd[7] = s->type;
1831 	cgc->cmd[8] = cgc->buflen >> 8;
1832 	cgc->cmd[9] = cgc->buflen & 0xff;
1833 
1834 	ret = cdo->generic_packet(cdi, cgc);
1835 	if (ret)
1836 		return ret;
1837 
1838 	s->copyright.cpst = buf[4];
1839 	s->copyright.rmi = buf[5];
1840 
1841 	return 0;
1842 }
1843 
1844 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s,
1845 				struct packet_command *cgc)
1846 {
1847 	int ret, size;
1848 	u_char *buf;
1849 	struct cdrom_device_ops *cdo = cdi->ops;
1850 
1851 	size = sizeof(s->disckey.value) + 4;
1852 
1853 	buf = kmalloc(size, GFP_KERNEL);
1854 	if (!buf)
1855 		return -ENOMEM;
1856 
1857 	init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1858 	cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1859 	cgc->cmd[7] = s->type;
1860 	cgc->cmd[8] = size >> 8;
1861 	cgc->cmd[9] = size & 0xff;
1862 	cgc->cmd[10] = s->disckey.agid << 6;
1863 
1864 	ret = cdo->generic_packet(cdi, cgc);
1865 	if (!ret)
1866 		memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1867 
1868 	kfree(buf);
1869 	return ret;
1870 }
1871 
1872 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1873 			struct packet_command *cgc)
1874 {
1875 	int ret, size = 4 + 188;
1876 	u_char *buf;
1877 	struct cdrom_device_ops *cdo = cdi->ops;
1878 
1879 	buf = kmalloc(size, GFP_KERNEL);
1880 	if (!buf)
1881 		return -ENOMEM;
1882 
1883 	init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1884 	cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1885 	cgc->cmd[7] = s->type;
1886 	cgc->cmd[9] = cgc->buflen & 0xff;
1887 
1888 	ret = cdo->generic_packet(cdi, cgc);
1889 	if (ret)
1890 		goto out;
1891 
1892 	s->bca.len = buf[0] << 8 | buf[1];
1893 	if (s->bca.len < 12 || s->bca.len > 188) {
1894 		cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1895 		ret = -EIO;
1896 		goto out;
1897 	}
1898 	memcpy(s->bca.value, &buf[4], s->bca.len);
1899 	ret = 0;
1900 out:
1901 	kfree(buf);
1902 	return ret;
1903 }
1904 
1905 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1906 				struct packet_command *cgc)
1907 {
1908 	int ret = 0, size;
1909 	u_char *buf;
1910 	struct cdrom_device_ops *cdo = cdi->ops;
1911 
1912 	size = sizeof(s->manufact.value) + 4;
1913 
1914 	buf = kmalloc(size, GFP_KERNEL);
1915 	if (!buf)
1916 		return -ENOMEM;
1917 
1918 	init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1919 	cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1920 	cgc->cmd[7] = s->type;
1921 	cgc->cmd[8] = size >> 8;
1922 	cgc->cmd[9] = size & 0xff;
1923 
1924 	ret = cdo->generic_packet(cdi, cgc);
1925 	if (ret)
1926 		goto out;
1927 
1928 	s->manufact.len = buf[0] << 8 | buf[1];
1929 	if (s->manufact.len < 0) {
1930 		cdinfo(CD_WARNING, "Received invalid manufacture info length"
1931 				   " (%d)\n", s->manufact.len);
1932 		ret = -EIO;
1933 	} else {
1934 		if (s->manufact.len > 2048) {
1935 			cdinfo(CD_WARNING, "Received invalid manufacture info "
1936 					"length (%d): truncating to 2048\n",
1937 					s->manufact.len);
1938 			s->manufact.len = 2048;
1939 		}
1940 		memcpy(s->manufact.value, &buf[4], s->manufact.len);
1941 	}
1942 
1943 out:
1944 	kfree(buf);
1945 	return ret;
1946 }
1947 
1948 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1949 				struct packet_command *cgc)
1950 {
1951 	switch (s->type) {
1952 	case DVD_STRUCT_PHYSICAL:
1953 		return dvd_read_physical(cdi, s, cgc);
1954 
1955 	case DVD_STRUCT_COPYRIGHT:
1956 		return dvd_read_copyright(cdi, s, cgc);
1957 
1958 	case DVD_STRUCT_DISCKEY:
1959 		return dvd_read_disckey(cdi, s, cgc);
1960 
1961 	case DVD_STRUCT_BCA:
1962 		return dvd_read_bca(cdi, s, cgc);
1963 
1964 	case DVD_STRUCT_MANUFACT:
1965 		return dvd_read_manufact(cdi, s, cgc);
1966 
1967 	default:
1968 		cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1969 					s->type);
1970 		return -EINVAL;
1971 	}
1972 }
1973 
1974 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1975 		     struct packet_command *cgc,
1976 		     int page_code, int page_control)
1977 {
1978 	struct cdrom_device_ops *cdo = cdi->ops;
1979 
1980 	memset(cgc->cmd, 0, sizeof(cgc->cmd));
1981 
1982 	cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1983 	cgc->cmd[2] = page_code | (page_control << 6);
1984 	cgc->cmd[7] = cgc->buflen >> 8;
1985 	cgc->cmd[8] = cgc->buflen & 0xff;
1986 	cgc->data_direction = CGC_DATA_READ;
1987 	return cdo->generic_packet(cdi, cgc);
1988 }
1989 
1990 int cdrom_mode_select(struct cdrom_device_info *cdi,
1991 		      struct packet_command *cgc)
1992 {
1993 	struct cdrom_device_ops *cdo = cdi->ops;
1994 
1995 	memset(cgc->cmd, 0, sizeof(cgc->cmd));
1996 	memset(cgc->buffer, 0, 2);
1997 	cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1998 	cgc->cmd[1] = 0x10;		/* PF */
1999 	cgc->cmd[7] = cgc->buflen >> 8;
2000 	cgc->cmd[8] = cgc->buflen & 0xff;
2001 	cgc->data_direction = CGC_DATA_WRITE;
2002 	return cdo->generic_packet(cdi, cgc);
2003 }
2004 
2005 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
2006 				 struct cdrom_subchnl *subchnl, int mcn)
2007 {
2008 	struct cdrom_device_ops *cdo = cdi->ops;
2009 	struct packet_command cgc;
2010 	char buffer[32];
2011 	int ret;
2012 
2013 	init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
2014 	cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
2015 	cgc.cmd[1] = 2;     /* MSF addressing */
2016 	cgc.cmd[2] = 0x40;  /* request subQ data */
2017 	cgc.cmd[3] = mcn ? 2 : 1;
2018 	cgc.cmd[8] = 16;
2019 
2020 	if ((ret = cdo->generic_packet(cdi, &cgc)))
2021 		return ret;
2022 
2023 	subchnl->cdsc_audiostatus = cgc.buffer[1];
2024 	subchnl->cdsc_format = CDROM_MSF;
2025 	subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
2026 	subchnl->cdsc_trk = cgc.buffer[6];
2027 	subchnl->cdsc_ind = cgc.buffer[7];
2028 
2029 	subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
2030 	subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
2031 	subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
2032 	subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
2033 	subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
2034 	subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
2035 
2036 	return 0;
2037 }
2038 
2039 /*
2040  * Specific READ_10 interface
2041  */
2042 static int cdrom_read_cd(struct cdrom_device_info *cdi,
2043 			 struct packet_command *cgc, int lba,
2044 			 int blocksize, int nblocks)
2045 {
2046 	struct cdrom_device_ops *cdo = cdi->ops;
2047 
2048 	memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2049 	cgc->cmd[0] = GPCMD_READ_10;
2050 	cgc->cmd[2] = (lba >> 24) & 0xff;
2051 	cgc->cmd[3] = (lba >> 16) & 0xff;
2052 	cgc->cmd[4] = (lba >>  8) & 0xff;
2053 	cgc->cmd[5] = lba & 0xff;
2054 	cgc->cmd[6] = (nblocks >> 16) & 0xff;
2055 	cgc->cmd[7] = (nblocks >>  8) & 0xff;
2056 	cgc->cmd[8] = nblocks & 0xff;
2057 	cgc->buflen = blocksize * nblocks;
2058 	return cdo->generic_packet(cdi, cgc);
2059 }
2060 
2061 /* very generic interface for reading the various types of blocks */
2062 static int cdrom_read_block(struct cdrom_device_info *cdi,
2063 			    struct packet_command *cgc,
2064 			    int lba, int nblocks, int format, int blksize)
2065 {
2066 	struct cdrom_device_ops *cdo = cdi->ops;
2067 
2068 	memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2069 	cgc->cmd[0] = GPCMD_READ_CD;
2070 	/* expected sector size - cdda,mode1,etc. */
2071 	cgc->cmd[1] = format << 2;
2072 	/* starting address */
2073 	cgc->cmd[2] = (lba >> 24) & 0xff;
2074 	cgc->cmd[3] = (lba >> 16) & 0xff;
2075 	cgc->cmd[4] = (lba >>  8) & 0xff;
2076 	cgc->cmd[5] = lba & 0xff;
2077 	/* number of blocks */
2078 	cgc->cmd[6] = (nblocks >> 16) & 0xff;
2079 	cgc->cmd[7] = (nblocks >>  8) & 0xff;
2080 	cgc->cmd[8] = nblocks & 0xff;
2081 	cgc->buflen = blksize * nblocks;
2082 
2083 	/* set the header info returned */
2084 	switch (blksize) {
2085 	case CD_FRAMESIZE_RAW0	: cgc->cmd[9] = 0x58; break;
2086 	case CD_FRAMESIZE_RAW1	: cgc->cmd[9] = 0x78; break;
2087 	case CD_FRAMESIZE_RAW	: cgc->cmd[9] = 0xf8; break;
2088 	default			: cgc->cmd[9] = 0x10;
2089 	}
2090 
2091 	return cdo->generic_packet(cdi, cgc);
2092 }
2093 
2094 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2095 			       int lba, int nframes)
2096 {
2097 	struct packet_command cgc;
2098 	int ret = 0;
2099 	int nr;
2100 
2101 	cdi->last_sense = 0;
2102 
2103 	memset(&cgc, 0, sizeof(cgc));
2104 
2105 	/*
2106 	 * start with will ra.nframes size, back down if alloc fails
2107 	 */
2108 	nr = nframes;
2109 	do {
2110 		cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2111 		if (cgc.buffer)
2112 			break;
2113 
2114 		nr >>= 1;
2115 	} while (nr);
2116 
2117 	if (!nr)
2118 		return -ENOMEM;
2119 
2120 	cgc.data_direction = CGC_DATA_READ;
2121 	while (nframes > 0) {
2122 		if (nr > nframes)
2123 			nr = nframes;
2124 
2125 		ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2126 		if (ret)
2127 			break;
2128 		if (copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2129 			ret = -EFAULT;
2130 			break;
2131 		}
2132 		ubuf += CD_FRAMESIZE_RAW * nr;
2133 		nframes -= nr;
2134 		lba += nr;
2135 	}
2136 	kfree(cgc.buffer);
2137 	return ret;
2138 }
2139 
2140 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2141 			       int lba, int nframes)
2142 {
2143 	struct request_queue *q = cdi->disk->queue;
2144 	struct request *rq;
2145 	struct bio *bio;
2146 	unsigned int len;
2147 	int nr, ret = 0;
2148 
2149 	if (!q)
2150 		return -ENXIO;
2151 
2152 	cdi->last_sense = 0;
2153 
2154 	while (nframes) {
2155 		nr = nframes;
2156 		if (cdi->cdda_method == CDDA_BPC_SINGLE)
2157 			nr = 1;
2158 		if (nr * CD_FRAMESIZE_RAW > (queue_max_sectors(q) << 9))
2159 			nr = (queue_max_sectors(q) << 9) / CD_FRAMESIZE_RAW;
2160 
2161 		len = nr * CD_FRAMESIZE_RAW;
2162 
2163 		rq = blk_get_request(q, READ, GFP_KERNEL);
2164 		if (!rq) {
2165 			ret = -ENOMEM;
2166 			break;
2167 		}
2168 
2169 		ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL);
2170 		if (ret) {
2171 			blk_put_request(rq);
2172 			break;
2173 		}
2174 
2175 		rq->cmd[0] = GPCMD_READ_CD;
2176 		rq->cmd[1] = 1 << 2;
2177 		rq->cmd[2] = (lba >> 24) & 0xff;
2178 		rq->cmd[3] = (lba >> 16) & 0xff;
2179 		rq->cmd[4] = (lba >>  8) & 0xff;
2180 		rq->cmd[5] = lba & 0xff;
2181 		rq->cmd[6] = (nr >> 16) & 0xff;
2182 		rq->cmd[7] = (nr >>  8) & 0xff;
2183 		rq->cmd[8] = nr & 0xff;
2184 		rq->cmd[9] = 0xf8;
2185 
2186 		rq->cmd_len = 12;
2187 		rq->cmd_type = REQ_TYPE_BLOCK_PC;
2188 		rq->timeout = 60 * HZ;
2189 		bio = rq->bio;
2190 
2191 		if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2192 			struct request_sense *s = rq->sense;
2193 			ret = -EIO;
2194 			cdi->last_sense = s->sense_key;
2195 		}
2196 
2197 		if (blk_rq_unmap_user(bio))
2198 			ret = -EFAULT;
2199 		blk_put_request(rq);
2200 
2201 		if (ret)
2202 			break;
2203 
2204 		nframes -= nr;
2205 		lba += nr;
2206 		ubuf += len;
2207 	}
2208 
2209 	return ret;
2210 }
2211 
2212 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2213 			   int lba, int nframes)
2214 {
2215 	int ret;
2216 
2217 	if (cdi->cdda_method == CDDA_OLD)
2218 		return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2219 
2220 retry:
2221 	/*
2222 	 * for anything else than success and io error, we need to retry
2223 	 */
2224 	ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2225 	if (!ret || ret != -EIO)
2226 		return ret;
2227 
2228 	/*
2229 	 * I've seen drives get sense 4/8/3 udma crc errors on multi
2230 	 * frame dma, so drop to single frame dma if we need to
2231 	 */
2232 	if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2233 		pr_info("dropping to single frame dma\n");
2234 		cdi->cdda_method = CDDA_BPC_SINGLE;
2235 		goto retry;
2236 	}
2237 
2238 	/*
2239 	 * so we have an io error of some sort with multi frame dma. if the
2240 	 * condition wasn't a hardware error
2241 	 * problems, not for any error
2242 	 */
2243 	if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2244 		return ret;
2245 
2246 	pr_info("dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2247 	cdi->cdda_method = CDDA_OLD;
2248 	return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2249 }
2250 
2251 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2252 		void __user *argp)
2253 {
2254 	struct cdrom_multisession ms_info;
2255 	u8 requested_format;
2256 	int ret;
2257 
2258 	cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2259 
2260 	if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2261 		return -ENOSYS;
2262 
2263 	if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2264 		return -EFAULT;
2265 
2266 	requested_format = ms_info.addr_format;
2267 	if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2268 		return -EINVAL;
2269 	ms_info.addr_format = CDROM_LBA;
2270 
2271 	ret = cdi->ops->get_last_session(cdi, &ms_info);
2272 	if (ret)
2273 		return ret;
2274 
2275 	sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2276 
2277 	if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2278 		return -EFAULT;
2279 
2280 	cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2281 	return 0;
2282 }
2283 
2284 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2285 {
2286 	cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2287 
2288 	if (!CDROM_CAN(CDC_OPEN_TRAY))
2289 		return -ENOSYS;
2290 	if (cdi->use_count != 1 || cdi->keeplocked)
2291 		return -EBUSY;
2292 	if (CDROM_CAN(CDC_LOCK)) {
2293 		int ret = cdi->ops->lock_door(cdi, 0);
2294 		if (ret)
2295 			return ret;
2296 	}
2297 
2298 	return cdi->ops->tray_move(cdi, 1);
2299 }
2300 
2301 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2302 {
2303 	cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2304 
2305 	if (!CDROM_CAN(CDC_CLOSE_TRAY))
2306 		return -ENOSYS;
2307 	return cdi->ops->tray_move(cdi, 0);
2308 }
2309 
2310 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2311 		unsigned long arg)
2312 {
2313 	cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2314 
2315 	if (!CDROM_CAN(CDC_OPEN_TRAY))
2316 		return -ENOSYS;
2317 	if (cdi->keeplocked)
2318 		return -EBUSY;
2319 
2320 	cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2321 	if (arg)
2322 		cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2323 	return 0;
2324 }
2325 
2326 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2327 		unsigned long arg)
2328 {
2329 	struct cdrom_changer_info *info;
2330 	int ret;
2331 
2332 	cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2333 
2334 	if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2335 		return -ENOSYS;
2336 
2337 	/* cannot select disc or select current disc */
2338 	if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2339 		return media_changed(cdi, 1);
2340 
2341 	if ((unsigned int)arg >= cdi->capacity)
2342 		return -EINVAL;
2343 
2344 	info = kmalloc(sizeof(*info), GFP_KERNEL);
2345 	if (!info)
2346 		return -ENOMEM;
2347 
2348 	ret = cdrom_read_mech_status(cdi, info);
2349 	if (!ret)
2350 		ret = info->slots[arg].change;
2351 	kfree(info);
2352 	return ret;
2353 }
2354 
2355 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2356 		unsigned long arg)
2357 {
2358 	cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2359 
2360 	/*
2361 	 * Options need to be in sync with capability.
2362 	 * Too late for that, so we have to check each one separately.
2363 	 */
2364 	switch (arg) {
2365 	case CDO_USE_FFLAGS:
2366 	case CDO_CHECK_TYPE:
2367 		break;
2368 	case CDO_LOCK:
2369 		if (!CDROM_CAN(CDC_LOCK))
2370 			return -ENOSYS;
2371 		break;
2372 	case 0:
2373 		return cdi->options;
2374 	/* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2375 	default:
2376 		if (!CDROM_CAN(arg))
2377 			return -ENOSYS;
2378 	}
2379 	cdi->options |= (int) arg;
2380 	return cdi->options;
2381 }
2382 
2383 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2384 		unsigned long arg)
2385 {
2386 	cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2387 
2388 	cdi->options &= ~(int) arg;
2389 	return cdi->options;
2390 }
2391 
2392 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2393 		unsigned long arg)
2394 {
2395 	cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2396 
2397 	if (!CDROM_CAN(CDC_SELECT_SPEED))
2398 		return -ENOSYS;
2399 	return cdi->ops->select_speed(cdi, arg);
2400 }
2401 
2402 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2403 		unsigned long arg)
2404 {
2405 	cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2406 
2407 	if (!CDROM_CAN(CDC_SELECT_DISC))
2408 		return -ENOSYS;
2409 
2410 	if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2411 		if ((int)arg >= cdi->capacity)
2412 			return -EINVAL;
2413 	}
2414 
2415 	/*
2416 	 * ->select_disc is a hook to allow a driver-specific way of
2417 	 * seleting disc.  However, since there is no equivalent hook for
2418 	 * cdrom_slot_status this may not actually be useful...
2419 	 */
2420 	if (cdi->ops->select_disc)
2421 		return cdi->ops->select_disc(cdi, arg);
2422 
2423 	cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2424 	return cdrom_select_disc(cdi, arg);
2425 }
2426 
2427 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2428 		struct block_device *bdev)
2429 {
2430 	cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2431 
2432 	if (!capable(CAP_SYS_ADMIN))
2433 		return -EACCES;
2434 	if (!CDROM_CAN(CDC_RESET))
2435 		return -ENOSYS;
2436 	invalidate_bdev(bdev);
2437 	return cdi->ops->reset(cdi);
2438 }
2439 
2440 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2441 		unsigned long arg)
2442 {
2443 	cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2444 
2445 	if (!CDROM_CAN(CDC_LOCK))
2446 		return -EDRIVE_CANT_DO_THIS;
2447 
2448 	cdi->keeplocked = arg ? 1 : 0;
2449 
2450 	/*
2451 	 * Don't unlock the door on multiple opens by default, but allow
2452 	 * root to do so.
2453 	 */
2454 	if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2455 		return -EBUSY;
2456 	return cdi->ops->lock_door(cdi, arg);
2457 }
2458 
2459 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2460 		unsigned long arg)
2461 {
2462 	cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2463 
2464 	if (!capable(CAP_SYS_ADMIN))
2465 		return -EACCES;
2466 	debug = arg ? 1 : 0;
2467 	return debug;
2468 }
2469 
2470 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2471 {
2472 	cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2473 	return (cdi->ops->capability & ~cdi->mask);
2474 }
2475 
2476 /*
2477  * The following function is implemented, although very few audio
2478  * discs give Universal Product Code information, which should just be
2479  * the Medium Catalog Number on the box.  Note, that the way the code
2480  * is written on the CD is /not/ uniform across all discs!
2481  */
2482 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2483 		void __user *argp)
2484 {
2485 	struct cdrom_mcn mcn;
2486 	int ret;
2487 
2488 	cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2489 
2490 	if (!(cdi->ops->capability & CDC_MCN))
2491 		return -ENOSYS;
2492 	ret = cdi->ops->get_mcn(cdi, &mcn);
2493 	if (ret)
2494 		return ret;
2495 
2496 	if (copy_to_user(argp, &mcn, sizeof(mcn)))
2497 		return -EFAULT;
2498 	cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2499 	return 0;
2500 }
2501 
2502 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2503 		unsigned long arg)
2504 {
2505 	cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2506 
2507 	if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2508 		return -ENOSYS;
2509 	if (!CDROM_CAN(CDC_SELECT_DISC) ||
2510 	    (arg == CDSL_CURRENT || arg == CDSL_NONE))
2511 		return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2512 	if (((int)arg >= cdi->capacity))
2513 		return -EINVAL;
2514 	return cdrom_slot_status(cdi, arg);
2515 }
2516 
2517 /*
2518  * Ok, this is where problems start.  The current interface for the
2519  * CDROM_DISC_STATUS ioctl is flawed.  It makes the false assumption that
2520  * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc.  Unfortunately, while this
2521  * is often the case, it is also very common for CDs to have some tracks
2522  * with data, and some tracks with audio.  Just because I feel like it,
2523  * I declare the following to be the best way to cope.  If the CD has ANY
2524  * data tracks on it, it will be returned as a data CD.  If it has any XA
2525  * tracks, I will return it as that.  Now I could simplify this interface
2526  * by combining these  returns with the above, but this more clearly
2527  * demonstrates the problem with the current interface.  Too bad this
2528  * wasn't designed to use bitmasks...         -Erik
2529  *
2530  * Well, now we have the option CDS_MIXED: a mixed-type CD.
2531  * User level programmers might feel the ioctl is not very useful.
2532  *					---david
2533  */
2534 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2535 {
2536 	tracktype tracks;
2537 
2538 	cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2539 
2540 	cdrom_count_tracks(cdi, &tracks);
2541 	if (tracks.error)
2542 		return tracks.error;
2543 
2544 	/* Policy mode on */
2545 	if (tracks.audio > 0) {
2546 		if (!tracks.data && !tracks.cdi && !tracks.xa)
2547 			return CDS_AUDIO;
2548 		else
2549 			return CDS_MIXED;
2550 	}
2551 
2552 	if (tracks.cdi > 0)
2553 		return CDS_XA_2_2;
2554 	if (tracks.xa > 0)
2555 		return CDS_XA_2_1;
2556 	if (tracks.data > 0)
2557 		return CDS_DATA_1;
2558 	/* Policy mode off */
2559 
2560 	cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2561 	return CDS_NO_INFO;
2562 }
2563 
2564 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2565 {
2566 	cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2567 	return cdi->capacity;
2568 }
2569 
2570 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2571 		void __user *argp)
2572 {
2573 	struct cdrom_subchnl q;
2574 	u8 requested, back;
2575 	int ret;
2576 
2577 	/* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2578 
2579 	if (copy_from_user(&q, argp, sizeof(q)))
2580 		return -EFAULT;
2581 
2582 	requested = q.cdsc_format;
2583 	if (requested != CDROM_MSF && requested != CDROM_LBA)
2584 		return -EINVAL;
2585 	q.cdsc_format = CDROM_MSF;
2586 
2587 	ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2588 	if (ret)
2589 		return ret;
2590 
2591 	back = q.cdsc_format; /* local copy */
2592 	sanitize_format(&q.cdsc_absaddr, &back, requested);
2593 	sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2594 
2595 	if (copy_to_user(argp, &q, sizeof(q)))
2596 		return -EFAULT;
2597 	/* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2598 	return 0;
2599 }
2600 
2601 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2602 		void __user *argp)
2603 {
2604 	struct cdrom_tochdr header;
2605 	int ret;
2606 
2607 	/* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2608 
2609 	if (copy_from_user(&header, argp, sizeof(header)))
2610 		return -EFAULT;
2611 
2612 	ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2613 	if (ret)
2614 		return ret;
2615 
2616 	if (copy_to_user(argp, &header, sizeof(header)))
2617 		return -EFAULT;
2618 	/* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2619 	return 0;
2620 }
2621 
2622 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2623 		void __user *argp)
2624 {
2625 	struct cdrom_tocentry entry;
2626 	u8 requested_format;
2627 	int ret;
2628 
2629 	/* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2630 
2631 	if (copy_from_user(&entry, argp, sizeof(entry)))
2632 		return -EFAULT;
2633 
2634 	requested_format = entry.cdte_format;
2635 	if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2636 		return -EINVAL;
2637 	/* make interface to low-level uniform */
2638 	entry.cdte_format = CDROM_MSF;
2639 	ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2640 	if (ret)
2641 		return ret;
2642 	sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2643 
2644 	if (copy_to_user(argp, &entry, sizeof(entry)))
2645 		return -EFAULT;
2646 	/* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2647 	return 0;
2648 }
2649 
2650 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2651 		void __user *argp)
2652 {
2653 	struct cdrom_msf msf;
2654 
2655 	cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2656 
2657 	if (!CDROM_CAN(CDC_PLAY_AUDIO))
2658 		return -ENOSYS;
2659 	if (copy_from_user(&msf, argp, sizeof(msf)))
2660 		return -EFAULT;
2661 	return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2662 }
2663 
2664 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2665 		void __user *argp)
2666 {
2667 	struct cdrom_ti ti;
2668 	int ret;
2669 
2670 	cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2671 
2672 	if (!CDROM_CAN(CDC_PLAY_AUDIO))
2673 		return -ENOSYS;
2674 	if (copy_from_user(&ti, argp, sizeof(ti)))
2675 		return -EFAULT;
2676 
2677 	ret = check_for_audio_disc(cdi, cdi->ops);
2678 	if (ret)
2679 		return ret;
2680 	return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2681 }
2682 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2683 		void __user *argp)
2684 {
2685 	struct cdrom_volctrl volume;
2686 
2687 	cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2688 
2689 	if (!CDROM_CAN(CDC_PLAY_AUDIO))
2690 		return -ENOSYS;
2691 	if (copy_from_user(&volume, argp, sizeof(volume)))
2692 		return -EFAULT;
2693 	return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2694 }
2695 
2696 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2697 		void __user *argp)
2698 {
2699 	struct cdrom_volctrl volume;
2700 	int ret;
2701 
2702 	cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2703 
2704 	if (!CDROM_CAN(CDC_PLAY_AUDIO))
2705 		return -ENOSYS;
2706 
2707 	ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2708 	if (ret)
2709 		return ret;
2710 
2711 	if (copy_to_user(argp, &volume, sizeof(volume)))
2712 		return -EFAULT;
2713 	return 0;
2714 }
2715 
2716 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2717 		unsigned int cmd)
2718 {
2719 	int ret;
2720 
2721 	cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2722 
2723 	if (!CDROM_CAN(CDC_PLAY_AUDIO))
2724 		return -ENOSYS;
2725 	ret = check_for_audio_disc(cdi, cdi->ops);
2726 	if (ret)
2727 		return ret;
2728 	return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2729 }
2730 
2731 /*
2732  * Just about every imaginable ioctl is supported in the Uniform layer
2733  * these days.
2734  * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2735  */
2736 int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
2737 		fmode_t mode, unsigned int cmd, unsigned long arg)
2738 {
2739 	void __user *argp = (void __user *)arg;
2740 	int ret;
2741 
2742 	/*
2743 	 * Try the generic SCSI command ioctl's first.
2744 	 */
2745 	ret = scsi_cmd_blk_ioctl(bdev, mode, cmd, argp);
2746 	if (ret != -ENOTTY)
2747 		return ret;
2748 
2749 	switch (cmd) {
2750 	case CDROMMULTISESSION:
2751 		return cdrom_ioctl_multisession(cdi, argp);
2752 	case CDROMEJECT:
2753 		return cdrom_ioctl_eject(cdi);
2754 	case CDROMCLOSETRAY:
2755 		return cdrom_ioctl_closetray(cdi);
2756 	case CDROMEJECT_SW:
2757 		return cdrom_ioctl_eject_sw(cdi, arg);
2758 	case CDROM_MEDIA_CHANGED:
2759 		return cdrom_ioctl_media_changed(cdi, arg);
2760 	case CDROM_SET_OPTIONS:
2761 		return cdrom_ioctl_set_options(cdi, arg);
2762 	case CDROM_CLEAR_OPTIONS:
2763 		return cdrom_ioctl_clear_options(cdi, arg);
2764 	case CDROM_SELECT_SPEED:
2765 		return cdrom_ioctl_select_speed(cdi, arg);
2766 	case CDROM_SELECT_DISC:
2767 		return cdrom_ioctl_select_disc(cdi, arg);
2768 	case CDROMRESET:
2769 		return cdrom_ioctl_reset(cdi, bdev);
2770 	case CDROM_LOCKDOOR:
2771 		return cdrom_ioctl_lock_door(cdi, arg);
2772 	case CDROM_DEBUG:
2773 		return cdrom_ioctl_debug(cdi, arg);
2774 	case CDROM_GET_CAPABILITY:
2775 		return cdrom_ioctl_get_capability(cdi);
2776 	case CDROM_GET_MCN:
2777 		return cdrom_ioctl_get_mcn(cdi, argp);
2778 	case CDROM_DRIVE_STATUS:
2779 		return cdrom_ioctl_drive_status(cdi, arg);
2780 	case CDROM_DISC_STATUS:
2781 		return cdrom_ioctl_disc_status(cdi);
2782 	case CDROM_CHANGER_NSLOTS:
2783 		return cdrom_ioctl_changer_nslots(cdi);
2784 	}
2785 
2786 	/*
2787 	 * Use the ioctls that are implemented through the generic_packet()
2788 	 * interface. this may look at bit funny, but if -ENOTTY is
2789 	 * returned that particular ioctl is not implemented and we
2790 	 * let it go through the device specific ones.
2791 	 */
2792 	if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2793 		ret = mmc_ioctl(cdi, cmd, arg);
2794 		if (ret != -ENOTTY)
2795 			return ret;
2796 	}
2797 
2798 	/*
2799 	 * Note: most of the cdinfo() calls are commented out here,
2800 	 * because they fill up the sys log when CD players poll
2801 	 * the drive.
2802 	 */
2803 	switch (cmd) {
2804 	case CDROMSUBCHNL:
2805 		return cdrom_ioctl_get_subchnl(cdi, argp);
2806 	case CDROMREADTOCHDR:
2807 		return cdrom_ioctl_read_tochdr(cdi, argp);
2808 	case CDROMREADTOCENTRY:
2809 		return cdrom_ioctl_read_tocentry(cdi, argp);
2810 	case CDROMPLAYMSF:
2811 		return cdrom_ioctl_play_msf(cdi, argp);
2812 	case CDROMPLAYTRKIND:
2813 		return cdrom_ioctl_play_trkind(cdi, argp);
2814 	case CDROMVOLCTRL:
2815 		return cdrom_ioctl_volctrl(cdi, argp);
2816 	case CDROMVOLREAD:
2817 		return cdrom_ioctl_volread(cdi, argp);
2818 	case CDROMSTART:
2819 	case CDROMSTOP:
2820 	case CDROMPAUSE:
2821 	case CDROMRESUME:
2822 		return cdrom_ioctl_audioctl(cdi, cmd);
2823 	}
2824 
2825 	return -ENOSYS;
2826 }
2827 
2828 /*
2829  * Required when we need to use READ_10 to issue other than 2048 block
2830  * reads
2831  */
2832 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2833 {
2834 	struct cdrom_device_ops *cdo = cdi->ops;
2835 	struct packet_command cgc;
2836 	struct modesel_head mh;
2837 
2838 	memset(&mh, 0, sizeof(mh));
2839 	mh.block_desc_length = 0x08;
2840 	mh.block_length_med = (size >> 8) & 0xff;
2841 	mh.block_length_lo = size & 0xff;
2842 
2843 	memset(&cgc, 0, sizeof(cgc));
2844 	cgc.cmd[0] = 0x15;
2845 	cgc.cmd[1] = 1 << 4;
2846 	cgc.cmd[4] = 12;
2847 	cgc.buflen = sizeof(mh);
2848 	cgc.buffer = (char *) &mh;
2849 	cgc.data_direction = CGC_DATA_WRITE;
2850 	mh.block_desc_length = 0x08;
2851 	mh.block_length_med = (size >> 8) & 0xff;
2852 	mh.block_length_lo = size & 0xff;
2853 
2854 	return cdo->generic_packet(cdi, &cgc);
2855 }
2856 
2857 static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2858 					void __user *arg,
2859 					struct packet_command *cgc,
2860 					int cmd)
2861 {
2862 	struct request_sense sense;
2863 	struct cdrom_msf msf;
2864 	int blocksize = 0, format = 0, lba;
2865 	int ret;
2866 
2867 	switch (cmd) {
2868 	case CDROMREADRAW:
2869 		blocksize = CD_FRAMESIZE_RAW;
2870 		break;
2871 	case CDROMREADMODE1:
2872 		blocksize = CD_FRAMESIZE;
2873 		format = 2;
2874 		break;
2875 	case CDROMREADMODE2:
2876 		blocksize = CD_FRAMESIZE_RAW0;
2877 		break;
2878 	}
2879 	IOCTL_IN(arg, struct cdrom_msf, msf);
2880 	lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2881 	/* FIXME: we need upper bound checking, too!! */
2882 	if (lba < 0)
2883 		return -EINVAL;
2884 
2885 	cgc->buffer = kzalloc(blocksize, GFP_KERNEL);
2886 	if (cgc->buffer == NULL)
2887 		return -ENOMEM;
2888 
2889 	memset(&sense, 0, sizeof(sense));
2890 	cgc->sense = &sense;
2891 	cgc->data_direction = CGC_DATA_READ;
2892 	ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
2893 	if (ret && sense.sense_key == 0x05 &&
2894 		   sense.asc == 0x20 &&
2895 		   sense.ascq == 0x00) {
2896 		/*
2897 		 * SCSI-II devices are not required to support
2898 		 * READ_CD, so let's try switching block size
2899 		 */
2900 		/* FIXME: switch back again... */
2901 		ret = cdrom_switch_blocksize(cdi, blocksize);
2902 		if (ret)
2903 			goto out;
2904 		cgc->sense = NULL;
2905 		ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
2906 		ret |= cdrom_switch_blocksize(cdi, blocksize);
2907 	}
2908 	if (!ret && copy_to_user(arg, cgc->buffer, blocksize))
2909 		ret = -EFAULT;
2910 out:
2911 	kfree(cgc->buffer);
2912 	return ret;
2913 }
2914 
2915 static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
2916 					void __user *arg)
2917 {
2918 	struct cdrom_read_audio ra;
2919 	int lba;
2920 
2921 	IOCTL_IN(arg, struct cdrom_read_audio, ra);
2922 
2923 	if (ra.addr_format == CDROM_MSF)
2924 		lba = msf_to_lba(ra.addr.msf.minute,
2925 				 ra.addr.msf.second,
2926 				 ra.addr.msf.frame);
2927 	else if (ra.addr_format == CDROM_LBA)
2928 		lba = ra.addr.lba;
2929 	else
2930 		return -EINVAL;
2931 
2932 	/* FIXME: we need upper bound checking, too!! */
2933 	if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2934 		return -EINVAL;
2935 
2936 	return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2937 }
2938 
2939 static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
2940 					void __user *arg)
2941 {
2942 	int ret;
2943 	struct cdrom_subchnl q;
2944 	u_char requested, back;
2945 	IOCTL_IN(arg, struct cdrom_subchnl, q);
2946 	requested = q.cdsc_format;
2947 	if (!((requested == CDROM_MSF) ||
2948 	      (requested == CDROM_LBA)))
2949 		return -EINVAL;
2950 	q.cdsc_format = CDROM_MSF;
2951 	ret = cdrom_read_subchannel(cdi, &q, 0);
2952 	if (ret)
2953 		return ret;
2954 	back = q.cdsc_format; /* local copy */
2955 	sanitize_format(&q.cdsc_absaddr, &back, requested);
2956 	sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2957 	IOCTL_OUT(arg, struct cdrom_subchnl, q);
2958 	/* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2959 	return 0;
2960 }
2961 
2962 static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
2963 					void __user *arg,
2964 					struct packet_command *cgc)
2965 {
2966 	struct cdrom_device_ops *cdo = cdi->ops;
2967 	struct cdrom_msf msf;
2968 	cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2969 	IOCTL_IN(arg, struct cdrom_msf, msf);
2970 	cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2971 	cgc->cmd[3] = msf.cdmsf_min0;
2972 	cgc->cmd[4] = msf.cdmsf_sec0;
2973 	cgc->cmd[5] = msf.cdmsf_frame0;
2974 	cgc->cmd[6] = msf.cdmsf_min1;
2975 	cgc->cmd[7] = msf.cdmsf_sec1;
2976 	cgc->cmd[8] = msf.cdmsf_frame1;
2977 	cgc->data_direction = CGC_DATA_NONE;
2978 	return cdo->generic_packet(cdi, cgc);
2979 }
2980 
2981 static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
2982 					void __user *arg,
2983 					struct packet_command *cgc)
2984 {
2985 	struct cdrom_device_ops *cdo = cdi->ops;
2986 	struct cdrom_blk blk;
2987 	cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2988 	IOCTL_IN(arg, struct cdrom_blk, blk);
2989 	cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
2990 	cgc->cmd[2] = (blk.from >> 24) & 0xff;
2991 	cgc->cmd[3] = (blk.from >> 16) & 0xff;
2992 	cgc->cmd[4] = (blk.from >>  8) & 0xff;
2993 	cgc->cmd[5] = blk.from & 0xff;
2994 	cgc->cmd[7] = (blk.len >> 8) & 0xff;
2995 	cgc->cmd[8] = blk.len & 0xff;
2996 	cgc->data_direction = CGC_DATA_NONE;
2997 	return cdo->generic_packet(cdi, cgc);
2998 }
2999 
3000 static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3001 					void __user *arg,
3002 					struct packet_command *cgc,
3003 					unsigned int cmd)
3004 {
3005 	struct cdrom_volctrl volctrl;
3006 	unsigned char buffer[32];
3007 	char mask[sizeof(buffer)];
3008 	unsigned short offset;
3009 	int ret;
3010 
3011 	cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3012 
3013 	IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
3014 
3015 	cgc->buffer = buffer;
3016 	cgc->buflen = 24;
3017 	ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 0);
3018 	if (ret)
3019 		return ret;
3020 
3021 	/* originally the code depended on buffer[1] to determine
3022 	   how much data is available for transfer. buffer[1] is
3023 	   unfortunately ambigious and the only reliable way seem
3024 	   to be to simply skip over the block descriptor... */
3025 	offset = 8 + be16_to_cpu(*(__be16 *)(buffer + 6));
3026 
3027 	if (offset + 16 > sizeof(buffer))
3028 		return -E2BIG;
3029 
3030 	if (offset + 16 > cgc->buflen) {
3031 		cgc->buflen = offset + 16;
3032 		ret = cdrom_mode_sense(cdi, cgc,
3033 					GPMODE_AUDIO_CTL_PAGE, 0);
3034 		if (ret)
3035 			return ret;
3036 	}
3037 
3038 	/* sanity check */
3039 	if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3040 			buffer[offset + 1] < 14)
3041 		return -EINVAL;
3042 
3043 	/* now we have the current volume settings. if it was only
3044 	   a CDROMVOLREAD, return these values */
3045 	if (cmd == CDROMVOLREAD) {
3046 		volctrl.channel0 = buffer[offset+9];
3047 		volctrl.channel1 = buffer[offset+11];
3048 		volctrl.channel2 = buffer[offset+13];
3049 		volctrl.channel3 = buffer[offset+15];
3050 		IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
3051 		return 0;
3052 	}
3053 
3054 	/* get the volume mask */
3055 	cgc->buffer = mask;
3056 	ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 1);
3057 	if (ret)
3058 		return ret;
3059 
3060 	buffer[offset + 9]  = volctrl.channel0 & mask[offset + 9];
3061 	buffer[offset + 11] = volctrl.channel1 & mask[offset + 11];
3062 	buffer[offset + 13] = volctrl.channel2 & mask[offset + 13];
3063 	buffer[offset + 15] = volctrl.channel3 & mask[offset + 15];
3064 
3065 	/* set volume */
3066 	cgc->buffer = buffer + offset - 8;
3067 	memset(cgc->buffer, 0, 8);
3068 	return cdrom_mode_select(cdi, cgc);
3069 }
3070 
3071 static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3072 					struct packet_command *cgc,
3073 					int cmd)
3074 {
3075 	struct cdrom_device_ops *cdo = cdi->ops;
3076 	cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3077 	cgc->cmd[0] = GPCMD_START_STOP_UNIT;
3078 	cgc->cmd[1] = 1;
3079 	cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3080 	cgc->data_direction = CGC_DATA_NONE;
3081 	return cdo->generic_packet(cdi, cgc);
3082 }
3083 
3084 static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3085 					struct packet_command *cgc,
3086 					int cmd)
3087 {
3088 	struct cdrom_device_ops *cdo = cdi->ops;
3089 	cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3090 	cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3091 	cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3092 	cgc->data_direction = CGC_DATA_NONE;
3093 	return cdo->generic_packet(cdi, cgc);
3094 }
3095 
3096 static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3097 						void __user *arg,
3098 						struct packet_command *cgc)
3099 {
3100 	int ret;
3101 	dvd_struct *s;
3102 	int size = sizeof(dvd_struct);
3103 
3104 	if (!CDROM_CAN(CDC_DVD))
3105 		return -ENOSYS;
3106 
3107 	s = kmalloc(size, GFP_KERNEL);
3108 	if (!s)
3109 		return -ENOMEM;
3110 
3111 	cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3112 	if (copy_from_user(s, arg, size)) {
3113 		kfree(s);
3114 		return -EFAULT;
3115 	}
3116 
3117 	ret = dvd_read_struct(cdi, s, cgc);
3118 	if (ret)
3119 		goto out;
3120 
3121 	if (copy_to_user(arg, s, size))
3122 		ret = -EFAULT;
3123 out:
3124 	kfree(s);
3125 	return ret;
3126 }
3127 
3128 static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3129 					void __user *arg)
3130 {
3131 	int ret;
3132 	dvd_authinfo ai;
3133 	if (!CDROM_CAN(CDC_DVD))
3134 		return -ENOSYS;
3135 	cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
3136 	IOCTL_IN(arg, dvd_authinfo, ai);
3137 	ret = dvd_do_auth(cdi, &ai);
3138 	if (ret)
3139 		return ret;
3140 	IOCTL_OUT(arg, dvd_authinfo, ai);
3141 	return 0;
3142 }
3143 
3144 static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3145 						void __user *arg)
3146 {
3147 	int ret;
3148 	long next = 0;
3149 	cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3150 	ret = cdrom_get_next_writable(cdi, &next);
3151 	if (ret)
3152 		return ret;
3153 	IOCTL_OUT(arg, long, next);
3154 	return 0;
3155 }
3156 
3157 static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3158 						void __user *arg)
3159 {
3160 	int ret;
3161 	long last = 0;
3162 	cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3163 	ret = cdrom_get_last_written(cdi, &last);
3164 	if (ret)
3165 		return ret;
3166 	IOCTL_OUT(arg, long, last);
3167 	return 0;
3168 }
3169 
3170 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3171 		     unsigned long arg)
3172 {
3173 	struct packet_command cgc;
3174 	void __user *userptr = (void __user *)arg;
3175 
3176 	memset(&cgc, 0, sizeof(cgc));
3177 
3178 	/* build a unified command and queue it through
3179 	   cdo->generic_packet() */
3180 	switch (cmd) {
3181 	case CDROMREADRAW:
3182 	case CDROMREADMODE1:
3183 	case CDROMREADMODE2:
3184 		return mmc_ioctl_cdrom_read_data(cdi, userptr, &cgc, cmd);
3185 	case CDROMREADAUDIO:
3186 		return mmc_ioctl_cdrom_read_audio(cdi, userptr);
3187 	case CDROMSUBCHNL:
3188 		return mmc_ioctl_cdrom_subchannel(cdi, userptr);
3189 	case CDROMPLAYMSF:
3190 		return mmc_ioctl_cdrom_play_msf(cdi, userptr, &cgc);
3191 	case CDROMPLAYBLK:
3192 		return mmc_ioctl_cdrom_play_blk(cdi, userptr, &cgc);
3193 	case CDROMVOLCTRL:
3194 	case CDROMVOLREAD:
3195 		return mmc_ioctl_cdrom_volume(cdi, userptr, &cgc, cmd);
3196 	case CDROMSTART:
3197 	case CDROMSTOP:
3198 		return mmc_ioctl_cdrom_start_stop(cdi, &cgc, cmd);
3199 	case CDROMPAUSE:
3200 	case CDROMRESUME:
3201 		return mmc_ioctl_cdrom_pause_resume(cdi, &cgc, cmd);
3202 	case DVD_READ_STRUCT:
3203 		return mmc_ioctl_dvd_read_struct(cdi, userptr, &cgc);
3204 	case DVD_AUTH:
3205 		return mmc_ioctl_dvd_auth(cdi, userptr);
3206 	case CDROM_NEXT_WRITABLE:
3207 		return mmc_ioctl_cdrom_next_writable(cdi, userptr);
3208 	case CDROM_LAST_WRITTEN:
3209 		return mmc_ioctl_cdrom_last_written(cdi, userptr);
3210 	}
3211 
3212 	return -ENOTTY;
3213 }
3214 
3215 static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
3216 			 track_information *ti)
3217 {
3218 	struct cdrom_device_ops *cdo = cdi->ops;
3219 	struct packet_command cgc;
3220 	int ret, buflen;
3221 
3222 	init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3223 	cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3224 	cgc.cmd[1] = type & 3;
3225 	cgc.cmd[4] = (track & 0xff00) >> 8;
3226 	cgc.cmd[5] = track & 0xff;
3227 	cgc.cmd[8] = 8;
3228 	cgc.quiet = 1;
3229 
3230 	if ((ret = cdo->generic_packet(cdi, &cgc)))
3231 		return ret;
3232 
3233 	buflen = be16_to_cpu(ti->track_information_length) +
3234 		     sizeof(ti->track_information_length);
3235 
3236 	if (buflen > sizeof(track_information))
3237 		buflen = sizeof(track_information);
3238 
3239 	cgc.cmd[8] = cgc.buflen = buflen;
3240 	if ((ret = cdo->generic_packet(cdi, &cgc)))
3241 		return ret;
3242 
3243 	/* return actual fill size */
3244 	return buflen;
3245 }
3246 
3247 /* requires CD R/RW */
3248 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3249 {
3250 	struct cdrom_device_ops *cdo = cdi->ops;
3251 	struct packet_command cgc;
3252 	int ret, buflen;
3253 
3254 	/* set up command and get the disc info */
3255 	init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3256 	cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3257 	cgc.cmd[8] = cgc.buflen = 2;
3258 	cgc.quiet = 1;
3259 
3260 	if ((ret = cdo->generic_packet(cdi, &cgc)))
3261 		return ret;
3262 
3263 	/* not all drives have the same disc_info length, so requeue
3264 	 * packet with the length the drive tells us it can supply
3265 	 */
3266 	buflen = be16_to_cpu(di->disc_information_length) +
3267 		     sizeof(di->disc_information_length);
3268 
3269 	if (buflen > sizeof(disc_information))
3270 		buflen = sizeof(disc_information);
3271 
3272 	cgc.cmd[8] = cgc.buflen = buflen;
3273 	if ((ret = cdo->generic_packet(cdi, &cgc)))
3274 		return ret;
3275 
3276 	/* return actual fill size */
3277 	return buflen;
3278 }
3279 
3280 /* return the last written block on the CD-R media. this is for the udf
3281    file system. */
3282 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
3283 {
3284 	struct cdrom_tocentry toc;
3285 	disc_information di;
3286 	track_information ti;
3287 	__u32 last_track;
3288 	int ret = -1, ti_size;
3289 
3290 	if (!CDROM_CAN(CDC_GENERIC_PACKET))
3291 		goto use_toc;
3292 
3293 	ret = cdrom_get_disc_info(cdi, &di);
3294 	if (ret < (int)(offsetof(typeof(di), last_track_lsb)
3295 			+ sizeof(di.last_track_lsb)))
3296 		goto use_toc;
3297 
3298 	/* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3299 	last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3300 	ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3301 	if (ti_size < (int)offsetof(typeof(ti), track_start))
3302 		goto use_toc;
3303 
3304 	/* if this track is blank, try the previous. */
3305 	if (ti.blank) {
3306 		if (last_track==1)
3307 			goto use_toc;
3308 		last_track--;
3309 		ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3310 	}
3311 
3312 	if (ti_size < (int)(offsetof(typeof(ti), track_size)
3313 				+ sizeof(ti.track_size)))
3314 		goto use_toc;
3315 
3316 	/* if last recorded field is valid, return it. */
3317 	if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3318 				+ sizeof(ti.last_rec_address))) {
3319 		*last_written = be32_to_cpu(ti.last_rec_address);
3320 	} else {
3321 		/* make it up instead */
3322 		*last_written = be32_to_cpu(ti.track_start) +
3323 				be32_to_cpu(ti.track_size);
3324 		if (ti.free_blocks)
3325 			*last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3326 	}
3327 	return 0;
3328 
3329 	/* this is where we end up if the drive either can't do a
3330 	   GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3331 	   it doesn't give enough information or fails. then we return
3332 	   the toc contents. */
3333 use_toc:
3334 	toc.cdte_format = CDROM_MSF;
3335 	toc.cdte_track = CDROM_LEADOUT;
3336 	if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
3337 		return ret;
3338 	sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
3339 	*last_written = toc.cdte_addr.lba;
3340 	return 0;
3341 }
3342 
3343 /* return the next writable block. also for udf file system. */
3344 static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3345 {
3346 	disc_information di;
3347 	track_information ti;
3348 	__u16 last_track;
3349 	int ret, ti_size;
3350 
3351 	if (!CDROM_CAN(CDC_GENERIC_PACKET))
3352 		goto use_last_written;
3353 
3354 	ret = cdrom_get_disc_info(cdi, &di);
3355 	if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3356 				+ sizeof(di.last_track_lsb))
3357 		goto use_last_written;
3358 
3359 	/* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3360 	last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3361 	ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3362 	if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3363 		goto use_last_written;
3364 
3365         /* if this track is blank, try the previous. */
3366 	if (ti.blank) {
3367 		if (last_track == 1)
3368 			goto use_last_written;
3369 		last_track--;
3370 		ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3371 		if (ti_size < 0)
3372 			goto use_last_written;
3373 	}
3374 
3375 	/* if next recordable address field is valid, use it. */
3376 	if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
3377 				+ sizeof(ti.next_writable)) {
3378 		*next_writable = be32_to_cpu(ti.next_writable);
3379 		return 0;
3380 	}
3381 
3382 use_last_written:
3383 	if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3384 		*next_writable = 0;
3385 		return ret;
3386 	} else {
3387 		*next_writable += 7;
3388 		return 0;
3389 	}
3390 }
3391 
3392 EXPORT_SYMBOL(cdrom_get_last_written);
3393 EXPORT_SYMBOL(register_cdrom);
3394 EXPORT_SYMBOL(unregister_cdrom);
3395 EXPORT_SYMBOL(cdrom_open);
3396 EXPORT_SYMBOL(cdrom_release);
3397 EXPORT_SYMBOL(cdrom_ioctl);
3398 EXPORT_SYMBOL(cdrom_media_changed);
3399 EXPORT_SYMBOL(cdrom_number_of_slots);
3400 EXPORT_SYMBOL(cdrom_mode_select);
3401 EXPORT_SYMBOL(cdrom_mode_sense);
3402 EXPORT_SYMBOL(init_cdrom_command);
3403 EXPORT_SYMBOL(cdrom_get_media_event);
3404 
3405 #ifdef CONFIG_SYSCTL
3406 
3407 #define CDROM_STR_SIZE 1000
3408 
3409 static struct cdrom_sysctl_settings {
3410 	char	info[CDROM_STR_SIZE];	/* general info */
3411 	int	autoclose;		/* close tray upon mount, etc */
3412 	int	autoeject;		/* eject on umount */
3413 	int	debug;			/* turn on debugging messages */
3414 	int	lock;			/* lock the door on device open */
3415 	int	check;			/* check media type */
3416 } cdrom_sysctl_settings;
3417 
3418 enum cdrom_print_option {
3419 	CTL_NAME,
3420 	CTL_SPEED,
3421 	CTL_SLOTS,
3422 	CTL_CAPABILITY
3423 };
3424 
3425 static int cdrom_print_info(const char *header, int val, char *info,
3426 				int *pos, enum cdrom_print_option option)
3427 {
3428 	const int max_size = sizeof(cdrom_sysctl_settings.info);
3429 	struct cdrom_device_info *cdi;
3430 	int ret;
3431 
3432 	ret = scnprintf(info + *pos, max_size - *pos, header);
3433 	if (!ret)
3434 		return 1;
3435 
3436 	*pos += ret;
3437 
3438 	list_for_each_entry(cdi, &cdrom_list, list) {
3439 		switch (option) {
3440 		case CTL_NAME:
3441 			ret = scnprintf(info + *pos, max_size - *pos,
3442 					"\t%s", cdi->name);
3443 			break;
3444 		case CTL_SPEED:
3445 			ret = scnprintf(info + *pos, max_size - *pos,
3446 					"\t%d", cdi->speed);
3447 			break;
3448 		case CTL_SLOTS:
3449 			ret = scnprintf(info + *pos, max_size - *pos,
3450 					"\t%d", cdi->capacity);
3451 			break;
3452 		case CTL_CAPABILITY:
3453 			ret = scnprintf(info + *pos, max_size - *pos,
3454 					"\t%d", CDROM_CAN(val) != 0);
3455 			break;
3456 		default:
3457 			pr_info("invalid option%d\n", option);
3458 			return 1;
3459 		}
3460 		if (!ret)
3461 			return 1;
3462 		*pos += ret;
3463 	}
3464 
3465 	return 0;
3466 }
3467 
3468 static int cdrom_sysctl_info(ctl_table *ctl, int write,
3469                            void __user *buffer, size_t *lenp, loff_t *ppos)
3470 {
3471 	int pos;
3472 	char *info = cdrom_sysctl_settings.info;
3473 	const int max_size = sizeof(cdrom_sysctl_settings.info);
3474 
3475 	if (!*lenp || (*ppos && !write)) {
3476 		*lenp = 0;
3477 		return 0;
3478 	}
3479 
3480 	mutex_lock(&cdrom_mutex);
3481 
3482 	pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3483 
3484 	if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3485 		goto done;
3486 	if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3487 		goto done;
3488 	if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3489 		goto done;
3490 	if (cdrom_print_info("\nCan close tray:\t",
3491 				CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3492 		goto done;
3493 	if (cdrom_print_info("\nCan open tray:\t",
3494 				CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3495 		goto done;
3496 	if (cdrom_print_info("\nCan lock tray:\t",
3497 				CDC_LOCK, info, &pos, CTL_CAPABILITY))
3498 		goto done;
3499 	if (cdrom_print_info("\nCan change speed:",
3500 				CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3501 		goto done;
3502 	if (cdrom_print_info("\nCan select disk:",
3503 				CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3504 		goto done;
3505 	if (cdrom_print_info("\nCan read multisession:",
3506 				CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3507 		goto done;
3508 	if (cdrom_print_info("\nCan read MCN:\t",
3509 				CDC_MCN, info, &pos, CTL_CAPABILITY))
3510 		goto done;
3511 	if (cdrom_print_info("\nReports media changed:",
3512 				CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3513 		goto done;
3514 	if (cdrom_print_info("\nCan play audio:\t",
3515 				CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3516 		goto done;
3517 	if (cdrom_print_info("\nCan write CD-R:\t",
3518 				CDC_CD_R, info, &pos, CTL_CAPABILITY))
3519 		goto done;
3520 	if (cdrom_print_info("\nCan write CD-RW:",
3521 				CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3522 		goto done;
3523 	if (cdrom_print_info("\nCan read DVD:\t",
3524 				CDC_DVD, info, &pos, CTL_CAPABILITY))
3525 		goto done;
3526 	if (cdrom_print_info("\nCan write DVD-R:",
3527 				CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3528 		goto done;
3529 	if (cdrom_print_info("\nCan write DVD-RAM:",
3530 				CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3531 		goto done;
3532 	if (cdrom_print_info("\nCan read MRW:\t",
3533 				CDC_MRW, info, &pos, CTL_CAPABILITY))
3534 		goto done;
3535 	if (cdrom_print_info("\nCan write MRW:\t",
3536 				CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3537 		goto done;
3538 	if (cdrom_print_info("\nCan write RAM:\t",
3539 				CDC_RAM, info, &pos, CTL_CAPABILITY))
3540 		goto done;
3541 	if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3542 		goto done;
3543 doit:
3544 	mutex_unlock(&cdrom_mutex);
3545 	return proc_dostring(ctl, write, buffer, lenp, ppos);
3546 done:
3547 	pr_info("info buffer too small\n");
3548 	goto doit;
3549 }
3550 
3551 /* Unfortunately, per device settings are not implemented through
3552    procfs/sysctl yet. When they are, this will naturally disappear. For now
3553    just update all drives. Later this will become the template on which
3554    new registered drives will be based. */
3555 static void cdrom_update_settings(void)
3556 {
3557 	struct cdrom_device_info *cdi;
3558 
3559 	mutex_lock(&cdrom_mutex);
3560 	list_for_each_entry(cdi, &cdrom_list, list) {
3561 		if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3562 			cdi->options |= CDO_AUTO_CLOSE;
3563 		else if (!autoclose)
3564 			cdi->options &= ~CDO_AUTO_CLOSE;
3565 		if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3566 			cdi->options |= CDO_AUTO_EJECT;
3567 		else if (!autoeject)
3568 			cdi->options &= ~CDO_AUTO_EJECT;
3569 		if (lockdoor && CDROM_CAN(CDC_LOCK))
3570 			cdi->options |= CDO_LOCK;
3571 		else if (!lockdoor)
3572 			cdi->options &= ~CDO_LOCK;
3573 		if (check_media_type)
3574 			cdi->options |= CDO_CHECK_TYPE;
3575 		else
3576 			cdi->options &= ~CDO_CHECK_TYPE;
3577 	}
3578 	mutex_unlock(&cdrom_mutex);
3579 }
3580 
3581 static int cdrom_sysctl_handler(ctl_table *ctl, int write,
3582 				void __user *buffer, size_t *lenp, loff_t *ppos)
3583 {
3584 	int ret;
3585 
3586 	ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
3587 
3588 	if (write) {
3589 
3590 		/* we only care for 1 or 0. */
3591 		autoclose        = !!cdrom_sysctl_settings.autoclose;
3592 		autoeject        = !!cdrom_sysctl_settings.autoeject;
3593 		debug	         = !!cdrom_sysctl_settings.debug;
3594 		lockdoor         = !!cdrom_sysctl_settings.lock;
3595 		check_media_type = !!cdrom_sysctl_settings.check;
3596 
3597 		/* update the option flags according to the changes. we
3598 		   don't have per device options through sysctl yet,
3599 		   but we will have and then this will disappear. */
3600 		cdrom_update_settings();
3601 	}
3602 
3603         return ret;
3604 }
3605 
3606 /* Place files in /proc/sys/dev/cdrom */
3607 static ctl_table cdrom_table[] = {
3608 	{
3609 		.procname	= "info",
3610 		.data		= &cdrom_sysctl_settings.info,
3611 		.maxlen		= CDROM_STR_SIZE,
3612 		.mode		= 0444,
3613 		.proc_handler	= cdrom_sysctl_info,
3614 	},
3615 	{
3616 		.procname	= "autoclose",
3617 		.data		= &cdrom_sysctl_settings.autoclose,
3618 		.maxlen		= sizeof(int),
3619 		.mode		= 0644,
3620 		.proc_handler	= cdrom_sysctl_handler,
3621 	},
3622 	{
3623 		.procname	= "autoeject",
3624 		.data		= &cdrom_sysctl_settings.autoeject,
3625 		.maxlen		= sizeof(int),
3626 		.mode		= 0644,
3627 		.proc_handler	= cdrom_sysctl_handler,
3628 	},
3629 	{
3630 		.procname	= "debug",
3631 		.data		= &cdrom_sysctl_settings.debug,
3632 		.maxlen		= sizeof(int),
3633 		.mode		= 0644,
3634 		.proc_handler	= cdrom_sysctl_handler,
3635 	},
3636 	{
3637 		.procname	= "lock",
3638 		.data		= &cdrom_sysctl_settings.lock,
3639 		.maxlen		= sizeof(int),
3640 		.mode		= 0644,
3641 		.proc_handler	= cdrom_sysctl_handler,
3642 	},
3643 	{
3644 		.procname	= "check_media",
3645 		.data		= &cdrom_sysctl_settings.check,
3646 		.maxlen		= sizeof(int),
3647 		.mode		= 0644,
3648 		.proc_handler	= cdrom_sysctl_handler
3649 	},
3650 	{ }
3651 };
3652 
3653 static ctl_table cdrom_cdrom_table[] = {
3654 	{
3655 		.procname	= "cdrom",
3656 		.maxlen		= 0,
3657 		.mode		= 0555,
3658 		.child		= cdrom_table,
3659 	},
3660 	{ }
3661 };
3662 
3663 /* Make sure that /proc/sys/dev is there */
3664 static ctl_table cdrom_root_table[] = {
3665 	{
3666 		.procname	= "dev",
3667 		.maxlen		= 0,
3668 		.mode		= 0555,
3669 		.child		= cdrom_cdrom_table,
3670 	},
3671 	{ }
3672 };
3673 static struct ctl_table_header *cdrom_sysctl_header;
3674 
3675 static void cdrom_sysctl_register(void)
3676 {
3677 	static int initialized;
3678 
3679 	if (initialized == 1)
3680 		return;
3681 
3682 	cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3683 
3684 	/* set the defaults */
3685 	cdrom_sysctl_settings.autoclose = autoclose;
3686 	cdrom_sysctl_settings.autoeject = autoeject;
3687 	cdrom_sysctl_settings.debug = debug;
3688 	cdrom_sysctl_settings.lock = lockdoor;
3689 	cdrom_sysctl_settings.check = check_media_type;
3690 
3691 	initialized = 1;
3692 }
3693 
3694 static void cdrom_sysctl_unregister(void)
3695 {
3696 	if (cdrom_sysctl_header)
3697 		unregister_sysctl_table(cdrom_sysctl_header);
3698 }
3699 
3700 #else /* CONFIG_SYSCTL */
3701 
3702 static void cdrom_sysctl_register(void)
3703 {
3704 }
3705 
3706 static void cdrom_sysctl_unregister(void)
3707 {
3708 }
3709 
3710 #endif /* CONFIG_SYSCTL */
3711 
3712 static int __init cdrom_init(void)
3713 {
3714 	cdrom_sysctl_register();
3715 
3716 	return 0;
3717 }
3718 
3719 static void __exit cdrom_exit(void)
3720 {
3721 	pr_info("Uniform CD-ROM driver unloaded\n");
3722 	cdrom_sysctl_unregister();
3723 }
3724 
3725 module_init(cdrom_init);
3726 module_exit(cdrom_exit);
3727 MODULE_LICENSE("GPL");
3728