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