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