linux - drivers/cdrom/cdrom.c

3731 lines · 98.7 KiB

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