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