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>
6 May be copied or modified under the terms of the GNU General Public
7 License. See linux/COPYING for more information.
9 Uniform CD-ROM driver for Linux.
10 See Documentation/cdrom/cdrom-standard.rst for usage information.
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. ;-)
18 ----------------------------------
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!
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?
32 2.00 Dec 2, 1997 -- Erik Andersen <andersee@debian.org>
33 -- New maintainer! As David A. van Leeuwen has been too busy to actively
34 maintain and improve this driver, I am now carrying on the torch. If
35 you have a problem with this driver, please feel free to contact me.
37 -- Added (rudimentary) sysctl interface. I realize this is really weak
38 right now, and is _very_ badly implemented. It will be improved...
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.
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.
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
54 -- Made it so if a function isn't implemented in a low-level driver,
55 ENOSYS is now returned instead of EINVAL.
57 -- Simplified some complex logic so that the source code is easier to read.
59 -- Other stuff I probably forgot to mention (lots of changes).
61 2.01 to 2.11 Dec 1997-Jan 1998
62 -- TO-DO! Write changelogs for 2.01 to 2.12.
64 2.12 Jan 24, 1998 -- Erik Andersen <andersee@debian.org>
65 -- Fixed a bug in the IOCTL_IN and IOCTL_OUT macros. It turns out that
66 copy_*_user does not return EFAULT on error, but instead returns the number
67 of bytes not copied. I was returning whatever non-zero stuff came back from
68 the copy_*_user functions directly, which would result in strange errors.
70 2.13 July 17, 1998 -- Erik Andersen <andersee@debian.org>
71 -- Fixed a bug in CDROM_SELECT_SPEED where you couldn't lower the speed
72 of the drive. Thanks to Tobias Ringstr|m <tori@prosolvia.se> for pointing
73 this out and providing a simple fix.
74 -- Fixed the procfs-unload-module bug with the fill_inode procfs callback.
75 thanks to Andrea Arcangeli
76 -- Fixed it so that the /proc entry now also shows up when cdrom is
77 compiled into the kernel. Before it only worked when loaded as a module.
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.
85 2.50 Oct 19, 1998 - Jens Axboe <axboe@image.dk>
86 -- New maintainers! Erik was too busy to continue the work on the driver,
87 so now Chris Zwilling <chris@cloudnet.com> and Jens Axboe <axboe@image.dk>
88 will do their best to follow in his footsteps
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.
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
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
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.
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>.
118 2.55 Apr 25, 1999 - Jens Axboe <axboe@image.dk>
119 -- autoclose was mistakenly checked against CDC_OPEN_TRAY instead of
121 -- proc info didn't mask against capabilities mask.
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,
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.
141 3.01 Aug 6, 1999 - Jens Axboe <axboe@image.dk>
142 -- Fix up the sysctl handling so that the option flags get set
144 -- Fix up ioctl handling so the device specific ones actually get
147 3.02 Aug 8, 1999 - Jens Axboe <axboe@image.dk>
148 -- Fixed volume control on SCSI drives (or others with longer audio
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.
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.
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.
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
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.
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.
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
200 -- Clear header length in mode_select unconditionally.
201 -- Removed the register_disk() that was added, not needed here.
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.
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
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.
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
228 3.12 Oct 18, 2000 - Jens Axboe <axboe@suse.de>
229 -- Use quiet bit on packet commands not known to work
231 3.20 Dec 17, 2003 - Jens Axboe <axboe@suse.de>
232 -- Various fixes and lots of cleanups not listed :-)
234 -- Mt Rainier support
235 -- DVD-RAM write open fixes
237 Nov 5 2001, Aug 8 2002. Modified by Andy Polyakov
238 <appro@fy.chalmers.se> to support MMC-3 compliant DVD+RW units.
240 Modified by Nigel Kukard <nkukard@lbsd.net> - support DVD+RW
241 2.4.x patch by Andy Polyakov <appro@fy.chalmers.se>
243 -------------------------------------------------------------------------*/
245 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
247 #define REVISION "Revision: 3.20"
248 #define VERSION "Id: cdrom.c 3.20 2003/12/17"
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
257 #define CD_CLOSE 0x10
258 #define CD_COUNT_TRACKS 0x20
259 #define CD_CHANGER 0x40
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) */
268 #include <linux/atomic.h>
269 #include <linux/module.h>
270 #include <linux/fs.h>
271 #include <linux/major.h>
272 #include <linux/types.h>
273 #include <linux/errno.h>
274 #include <linux/kernel.h>
275 #include <linux/mm.h>
276 #include <linux/slab.h>
277 #include <linux/cdrom.h>
278 #include <linux/sysctl.h>
279 #include <linux/proc_fs.h>
280 #include <linux/blkpg.h>
281 #include <linux/init.h>
282 #include <linux/fcntl.h>
283 #include <linux/blkdev.h>
284 #include <linux/times.h>
285 #include <linux/uaccess.h>
286 #include <scsi/scsi_common.h>
287 #include <scsi/scsi_request.h>
289 /* used to tell the module to turn on full debugging messages */
291 /* default compatibility mode */
292 static bool autoclose
=1;
293 static bool autoeject
;
294 static bool lockdoor
= 1;
295 /* will we ever get to use this... sigh. */
296 static bool check_media_type
;
297 /* automatically restart mrw format */
298 static bool mrw_format_restart
= 1;
299 module_param(debug
, bool, 0);
300 module_param(autoclose
, bool, 0);
301 module_param(autoeject
, bool, 0);
302 module_param(lockdoor
, bool, 0);
303 module_param(check_media_type
, bool, 0);
304 module_param(mrw_format_restart
, bool, 0);
306 static DEFINE_MUTEX(cdrom_mutex
);
308 static const char *mrw_format_status
[] = {
315 static const char *mrw_address_space
[] = { "DMA", "GAA" };
317 #if (ERRLOGMASK != CD_NOTHING)
318 #define cd_dbg(type, fmt, ...) \
320 if ((ERRLOGMASK & type) || debug == 1) \
321 pr_debug(fmt, ##__VA_ARGS__); \
324 #define cd_dbg(type, fmt, ...) \
326 if (0 && (ERRLOGMASK & type) || debug == 1) \
327 pr_debug(fmt, ##__VA_ARGS__); \
331 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
332 a lot of places. This macro makes the code more clear. */
333 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
336 * Another popular OS uses 7 seconds as the hard timeout for default
337 * commands, so it is a good choice for us as well.
339 #define CDROM_DEF_TIMEOUT (7 * HZ)
341 /* Not-exported routines. */
343 static void cdrom_sysctl_register(void);
345 static LIST_HEAD(cdrom_list
);
347 static void signal_media_change(struct cdrom_device_info
*cdi
)
349 cdi
->mc_flags
= 0x3; /* set media changed bits, on both queues */
350 cdi
->last_media_change_ms
= ktime_to_ms(ktime_get());
353 int cdrom_dummy_generic_packet(struct cdrom_device_info
*cdi
,
354 struct packet_command
*cgc
)
357 cgc
->sshdr
->sense_key
= 0x05;
358 cgc
->sshdr
->asc
= 0x20;
359 cgc
->sshdr
->ascq
= 0x00;
365 EXPORT_SYMBOL(cdrom_dummy_generic_packet
);
367 static int cdrom_flush_cache(struct cdrom_device_info
*cdi
)
369 struct packet_command cgc
;
371 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
372 cgc
.cmd
[0] = GPCMD_FLUSH_CACHE
;
374 cgc
.timeout
= 5 * 60 * HZ
;
376 return cdi
->ops
->generic_packet(cdi
, &cgc
);
379 /* requires CD R/RW */
380 static int cdrom_get_disc_info(struct cdrom_device_info
*cdi
,
381 disc_information
*di
)
383 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
384 struct packet_command cgc
;
387 /* set up command and get the disc info */
388 init_cdrom_command(&cgc
, di
, sizeof(*di
), CGC_DATA_READ
);
389 cgc
.cmd
[0] = GPCMD_READ_DISC_INFO
;
390 cgc
.cmd
[8] = cgc
.buflen
= 2;
393 ret
= cdo
->generic_packet(cdi
, &cgc
);
397 /* not all drives have the same disc_info length, so requeue
398 * packet with the length the drive tells us it can supply
400 buflen
= be16_to_cpu(di
->disc_information_length
) +
401 sizeof(di
->disc_information_length
);
403 if (buflen
> sizeof(disc_information
))
404 buflen
= sizeof(disc_information
);
406 cgc
.cmd
[8] = cgc
.buflen
= buflen
;
407 ret
= cdo
->generic_packet(cdi
, &cgc
);
411 /* return actual fill size */
415 /* This macro makes sure we don't have to check on cdrom_device_ops
416 * existence in the run-time routines below. Change_capability is a
417 * hack to have the capability flags defined const, while we can still
418 * change it here without gcc complaining at every line.
420 #define ENSURE(cdo, call, bits) \
422 if (cdo->call == NULL) \
423 WARN_ON_ONCE((cdo)->capability & (bits)); \
427 * the first prototypes used 0x2c as the page code for the mrw mode page,
428 * subsequently this was changed to 0x03. probe the one used by this drive
430 static int cdrom_mrw_probe_pc(struct cdrom_device_info
*cdi
)
432 struct packet_command cgc
;
435 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
440 if (!cdrom_mode_sense(cdi
, &cgc
, MRW_MODE_PC
, 0)) {
441 cdi
->mrw_mode_page
= MRW_MODE_PC
;
443 } else if (!cdrom_mode_sense(cdi
, &cgc
, MRW_MODE_PC_PRE1
, 0)) {
444 cdi
->mrw_mode_page
= MRW_MODE_PC_PRE1
;
451 static int cdrom_is_mrw(struct cdrom_device_info
*cdi
, int *write
)
453 struct packet_command cgc
;
454 struct mrw_feature_desc
*mfd
;
455 unsigned char buffer
[16];
460 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
462 cgc
.cmd
[0] = GPCMD_GET_CONFIGURATION
;
463 cgc
.cmd
[3] = CDF_MRW
;
464 cgc
.cmd
[8] = sizeof(buffer
);
467 if ((ret
= cdi
->ops
->generic_packet(cdi
, &cgc
)))
470 mfd
= (struct mrw_feature_desc
*)&buffer
[sizeof(struct feature_header
)];
471 if (be16_to_cpu(mfd
->feature_code
) != CDF_MRW
)
475 if ((ret
= cdrom_mrw_probe_pc(cdi
))) {
483 static int cdrom_mrw_bgformat(struct cdrom_device_info
*cdi
, int cont
)
485 struct packet_command cgc
;
486 unsigned char buffer
[12];
489 pr_info("%sstarting format\n", cont
? "Re" : "");
492 * FmtData bit set (bit 4), format type is 1
494 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_WRITE
);
495 cgc
.cmd
[0] = GPCMD_FORMAT_UNIT
;
496 cgc
.cmd
[1] = (1 << 4) | 1;
498 cgc
.timeout
= 5 * 60 * HZ
;
501 * 4 byte format list header, 8 byte format list descriptor
514 buffer
[8] = 0x24 << 2;
517 ret
= cdi
->ops
->generic_packet(cdi
, &cgc
);
519 pr_info("bgformat failed\n");
524 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info
*cdi
, int immed
)
526 struct packet_command cgc
;
528 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
529 cgc
.cmd
[0] = GPCMD_CLOSE_TRACK
;
532 * Session = 1, Track = 0
534 cgc
.cmd
[1] = !!immed
;
537 cgc
.timeout
= 5 * 60 * HZ
;
539 return cdi
->ops
->generic_packet(cdi
, &cgc
);
542 static int cdrom_mrw_exit(struct cdrom_device_info
*cdi
)
547 ret
= cdrom_get_disc_info(cdi
, &di
);
548 if (ret
< 0 || ret
< (int)offsetof(typeof(di
),disc_type
))
552 if (di
.mrw_status
== CDM_MRW_BGFORMAT_ACTIVE
) {
553 pr_info("issuing MRW background format suspend\n");
554 ret
= cdrom_mrw_bgformat_susp(cdi
, 0);
557 if (!ret
&& cdi
->media_written
)
558 ret
= cdrom_flush_cache(cdi
);
563 static int cdrom_mrw_set_lba_space(struct cdrom_device_info
*cdi
, int space
)
565 struct packet_command cgc
;
566 struct mode_page_header
*mph
;
568 int ret
, offset
, size
;
570 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
573 cgc
.buflen
= sizeof(buffer
);
575 ret
= cdrom_mode_sense(cdi
, &cgc
, cdi
->mrw_mode_page
, 0);
579 mph
= (struct mode_page_header
*)buffer
;
580 offset
= be16_to_cpu(mph
->desc_length
);
581 size
= be16_to_cpu(mph
->mode_data_length
) + 2;
583 buffer
[offset
+ 3] = space
;
586 ret
= cdrom_mode_select(cdi
, &cgc
);
590 pr_info("%s: mrw address space %s selected\n",
591 cdi
->name
, mrw_address_space
[space
]);
595 int register_cdrom(struct gendisk
*disk
, struct cdrom_device_info
*cdi
)
597 static char banner_printed
;
598 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
600 cd_dbg(CD_OPEN
, "entering register_cdrom\n");
602 if (cdo
->open
== NULL
|| cdo
->release
== NULL
)
604 if (!banner_printed
) {
605 pr_info("Uniform CD-ROM driver " REVISION
"\n");
607 cdrom_sysctl_register();
613 ENSURE(cdo
, drive_status
, CDC_DRIVE_STATUS
);
614 if (cdo
->check_events
== NULL
)
615 WARN_ON_ONCE(cdo
->capability
& (CDC_MEDIA_CHANGED
| CDC_SELECT_DISC
));
616 ENSURE(cdo
, tray_move
, CDC_CLOSE_TRAY
| CDC_OPEN_TRAY
);
617 ENSURE(cdo
, lock_door
, CDC_LOCK
);
618 ENSURE(cdo
, select_speed
, CDC_SELECT_SPEED
);
619 ENSURE(cdo
, get_last_session
, CDC_MULTI_SESSION
);
620 ENSURE(cdo
, get_mcn
, CDC_MCN
);
621 ENSURE(cdo
, reset
, CDC_RESET
);
622 ENSURE(cdo
, generic_packet
, CDC_GENERIC_PACKET
);
624 cdi
->options
= CDO_USE_FFLAGS
;
625 cdi
->last_media_change_ms
= ktime_to_ms(ktime_get());
627 if (autoclose
== 1 && CDROM_CAN(CDC_CLOSE_TRAY
))
628 cdi
->options
|= (int) CDO_AUTO_CLOSE
;
629 if (autoeject
== 1 && CDROM_CAN(CDC_OPEN_TRAY
))
630 cdi
->options
|= (int) CDO_AUTO_EJECT
;
632 cdi
->options
|= (int) CDO_LOCK
;
633 if (check_media_type
== 1)
634 cdi
->options
|= (int) CDO_CHECK_TYPE
;
636 if (CDROM_CAN(CDC_MRW_W
))
637 cdi
->exit
= cdrom_mrw_exit
;
639 if (cdi
->ops
->read_cdda_bpc
)
640 cdi
->cdda_method
= CDDA_BPC_FULL
;
642 cdi
->cdda_method
= CDDA_OLD
;
644 WARN_ON(!cdo
->generic_packet
);
646 cd_dbg(CD_REG_UNREG
, "drive \"/dev/%s\" registered\n", cdi
->name
);
647 mutex_lock(&cdrom_mutex
);
648 list_add(&cdi
->list
, &cdrom_list
);
649 mutex_unlock(&cdrom_mutex
);
654 void unregister_cdrom(struct cdrom_device_info
*cdi
)
656 cd_dbg(CD_OPEN
, "entering unregister_cdrom\n");
658 mutex_lock(&cdrom_mutex
);
659 list_del(&cdi
->list
);
660 mutex_unlock(&cdrom_mutex
);
665 cd_dbg(CD_REG_UNREG
, "drive \"/dev/%s\" unregistered\n", cdi
->name
);
668 int cdrom_get_media_event(struct cdrom_device_info
*cdi
,
669 struct media_event_desc
*med
)
671 struct packet_command cgc
;
672 unsigned char buffer
[8];
673 struct event_header
*eh
= (struct event_header
*)buffer
;
675 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
676 cgc
.cmd
[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION
;
677 cgc
.cmd
[1] = 1; /* IMMED */
678 cgc
.cmd
[4] = 1 << 4; /* media event */
679 cgc
.cmd
[8] = sizeof(buffer
);
682 if (cdi
->ops
->generic_packet(cdi
, &cgc
))
685 if (be16_to_cpu(eh
->data_len
) < sizeof(*med
))
688 if (eh
->nea
|| eh
->notification_class
!= 0x4)
691 memcpy(med
, &buffer
[sizeof(*eh
)], sizeof(*med
));
695 static int cdrom_get_random_writable(struct cdrom_device_info
*cdi
,
696 struct rwrt_feature_desc
*rfd
)
698 struct packet_command cgc
;
702 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
704 cgc
.cmd
[0] = GPCMD_GET_CONFIGURATION
; /* often 0x46 */
705 cgc
.cmd
[3] = CDF_RWRT
; /* often 0x0020 */
706 cgc
.cmd
[8] = sizeof(buffer
); /* often 0x18 */
709 if ((ret
= cdi
->ops
->generic_packet(cdi
, &cgc
)))
712 memcpy(rfd
, &buffer
[sizeof(struct feature_header
)], sizeof (*rfd
));
716 static int cdrom_has_defect_mgt(struct cdrom_device_info
*cdi
)
718 struct packet_command cgc
;
720 __be16
*feature_code
;
723 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
725 cgc
.cmd
[0] = GPCMD_GET_CONFIGURATION
;
726 cgc
.cmd
[3] = CDF_HWDM
;
727 cgc
.cmd
[8] = sizeof(buffer
);
730 if ((ret
= cdi
->ops
->generic_packet(cdi
, &cgc
)))
733 feature_code
= (__be16
*) &buffer
[sizeof(struct feature_header
)];
734 if (be16_to_cpu(*feature_code
) == CDF_HWDM
)
741 static int cdrom_is_random_writable(struct cdrom_device_info
*cdi
, int *write
)
743 struct rwrt_feature_desc rfd
;
748 if ((ret
= cdrom_get_random_writable(cdi
, &rfd
)))
751 if (CDF_RWRT
== be16_to_cpu(rfd
.feature_code
))
757 static int cdrom_media_erasable(struct cdrom_device_info
*cdi
)
762 ret
= cdrom_get_disc_info(cdi
, &di
);
763 if (ret
< 0 || ret
< offsetof(typeof(di
), n_first_track
))
770 * FIXME: check RO bit
772 static int cdrom_dvdram_open_write(struct cdrom_device_info
*cdi
)
774 int ret
= cdrom_media_erasable(cdi
);
777 * allow writable open if media info read worked and media is
778 * erasable, _or_ if it fails since not all drives support it
786 static int cdrom_mrw_open_write(struct cdrom_device_info
*cdi
)
792 * always reset to DMA lba space on open
794 if (cdrom_mrw_set_lba_space(cdi
, MRW_LBA_DMA
)) {
795 pr_err("failed setting lba address space\n");
799 ret
= cdrom_get_disc_info(cdi
, &di
);
800 if (ret
< 0 || ret
< offsetof(typeof(di
),disc_type
))
808 * 0 - not MRW formatted
809 * 1 - MRW bgformat started, but not running or complete
810 * 2 - MRW bgformat in progress
811 * 3 - MRW formatting complete
814 pr_info("open: mrw_status '%s'\n", mrw_format_status
[di
.mrw_status
]);
817 else if (di
.mrw_status
== CDM_MRW_BGFORMAT_INACTIVE
&&
819 ret
= cdrom_mrw_bgformat(cdi
, 1);
824 static int mo_open_write(struct cdrom_device_info
*cdi
)
826 struct packet_command cgc
;
830 init_cdrom_command(&cgc
, &buffer
, 4, CGC_DATA_READ
);
834 * obtain write protect information as per
835 * drivers/scsi/sd.c:sd_read_write_protect_flag
838 ret
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_ALL_PAGES
, 0);
840 ret
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_VENDOR_PAGE
, 0);
843 ret
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_ALL_PAGES
, 0);
846 /* drive gave us no info, let the user go ahead */
850 return buffer
[3] & 0x80;
853 static int cdrom_ram_open_write(struct cdrom_device_info
*cdi
)
855 struct rwrt_feature_desc rfd
;
858 if ((ret
= cdrom_has_defect_mgt(cdi
)))
861 if ((ret
= cdrom_get_random_writable(cdi
, &rfd
)))
863 else if (CDF_RWRT
== be16_to_cpu(rfd
.feature_code
))
866 cd_dbg(CD_OPEN
, "can open for random write\n");
870 static void cdrom_mmc3_profile(struct cdrom_device_info
*cdi
)
872 struct packet_command cgc
;
876 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
878 cgc
.cmd
[0] = GPCMD_GET_CONFIGURATION
;
880 cgc
.cmd
[2] = cgc
.cmd
[3] = 0; /* Starting Feature Number */
881 cgc
.cmd
[8] = sizeof(buffer
); /* Allocation Length */
884 if (cdi
->ops
->generic_packet(cdi
, &cgc
))
885 mmc3_profile
= 0xffff;
887 mmc3_profile
= (buffer
[6] << 8) | buffer
[7];
889 cdi
->mmc3_profile
= mmc3_profile
;
892 static int cdrom_is_dvd_rw(struct cdrom_device_info
*cdi
)
894 switch (cdi
->mmc3_profile
) {
895 case 0x12: /* DVD-RAM */
896 case 0x1A: /* DVD+RW */
897 case 0x43: /* BD-RE */
905 * returns 0 for ok to open write, non-0 to disallow
907 static int cdrom_open_write(struct cdrom_device_info
*cdi
)
909 int mrw
, mrw_write
, ram_write
;
913 if (!cdrom_is_mrw(cdi
, &mrw_write
))
916 if (CDROM_CAN(CDC_MO_DRIVE
))
919 (void) cdrom_is_random_writable(cdi
, &ram_write
);
922 cdi
->mask
&= ~CDC_MRW
;
924 cdi
->mask
|= CDC_MRW
;
927 cdi
->mask
&= ~CDC_MRW_W
;
929 cdi
->mask
|= CDC_MRW_W
;
932 cdi
->mask
&= ~CDC_RAM
;
934 cdi
->mask
|= CDC_RAM
;
936 if (CDROM_CAN(CDC_MRW_W
))
937 ret
= cdrom_mrw_open_write(cdi
);
938 else if (CDROM_CAN(CDC_DVD_RAM
))
939 ret
= cdrom_dvdram_open_write(cdi
);
940 else if (CDROM_CAN(CDC_RAM
) &&
941 !CDROM_CAN(CDC_CD_R
|CDC_CD_RW
|CDC_DVD
|CDC_DVD_R
|CDC_MRW
|CDC_MO_DRIVE
))
942 ret
= cdrom_ram_open_write(cdi
);
943 else if (CDROM_CAN(CDC_MO_DRIVE
))
944 ret
= mo_open_write(cdi
);
945 else if (!cdrom_is_dvd_rw(cdi
))
951 static void cdrom_dvd_rw_close_write(struct cdrom_device_info
*cdi
)
953 struct packet_command cgc
;
955 if (cdi
->mmc3_profile
!= 0x1a) {
956 cd_dbg(CD_CLOSE
, "%s: No DVD+RW\n", cdi
->name
);
960 if (!cdi
->media_written
) {
961 cd_dbg(CD_CLOSE
, "%s: DVD+RW media clean\n", cdi
->name
);
965 pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi
->name
);
967 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
968 cgc
.cmd
[0] = GPCMD_FLUSH_CACHE
;
970 cdi
->ops
->generic_packet(cdi
, &cgc
);
972 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
973 cgc
.cmd
[0] = GPCMD_CLOSE_TRACK
;
974 cgc
.timeout
= 3000*HZ
;
976 cdi
->ops
->generic_packet(cdi
, &cgc
);
978 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
979 cgc
.cmd
[0] = GPCMD_CLOSE_TRACK
;
980 cgc
.cmd
[2] = 2; /* Close session */
982 cgc
.timeout
= 3000*HZ
;
983 cdi
->ops
->generic_packet(cdi
, &cgc
);
985 cdi
->media_written
= 0;
988 static int cdrom_close_write(struct cdrom_device_info
*cdi
)
991 return cdrom_flush_cache(cdi
);
997 /* badly broken, I know. Is due for a fixup anytime. */
998 static void cdrom_count_tracks(struct cdrom_device_info
*cdi
, tracktype
*tracks
)
1000 struct cdrom_tochdr header
;
1001 struct cdrom_tocentry entry
;
1008 cd_dbg(CD_COUNT_TRACKS
, "entering cdrom_count_tracks\n");
1010 if (!CDROM_CAN(CDC_PLAY_AUDIO
)) {
1011 tracks
->error
= CDS_NO_INFO
;
1015 /* Grab the TOC header so we can see how many tracks there are */
1016 ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCHDR
, &header
);
1018 if (ret
== -ENOMEDIUM
)
1019 tracks
->error
= CDS_NO_DISC
;
1021 tracks
->error
= CDS_NO_INFO
;
1024 /* check what type of tracks are on this disc */
1025 entry
.cdte_format
= CDROM_MSF
;
1026 for (i
= header
.cdth_trk0
; i
<= header
.cdth_trk1
; i
++) {
1027 entry
.cdte_track
= i
;
1028 if (cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCENTRY
, &entry
)) {
1029 tracks
->error
= CDS_NO_INFO
;
1032 if (entry
.cdte_ctrl
& CDROM_DATA_TRACK
) {
1033 if (entry
.cdte_format
== 0x10)
1035 else if (entry
.cdte_format
== 0x20)
1042 cd_dbg(CD_COUNT_TRACKS
, "track %d: format=%d, ctrl=%d\n",
1043 i
, entry
.cdte_format
, entry
.cdte_ctrl
);
1045 cd_dbg(CD_COUNT_TRACKS
, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1046 header
.cdth_trk1
, tracks
->audio
, tracks
->data
,
1047 tracks
->cdi
, tracks
->xa
);
1051 int open_for_data(struct cdrom_device_info
*cdi
)
1054 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1056 cd_dbg(CD_OPEN
, "entering open_for_data\n");
1057 /* Check if the driver can report drive status. If it can, we
1058 can do clever things. If it can't, well, we at least tried! */
1059 if (cdo
->drive_status
!= NULL
) {
1060 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
1061 cd_dbg(CD_OPEN
, "drive_status=%d\n", ret
);
1062 if (ret
== CDS_TRAY_OPEN
) {
1063 cd_dbg(CD_OPEN
, "the tray is open...\n");
1064 /* can/may i close it? */
1065 if (CDROM_CAN(CDC_CLOSE_TRAY
) &&
1066 cdi
->options
& CDO_AUTO_CLOSE
) {
1067 cd_dbg(CD_OPEN
, "trying to close the tray\n");
1068 ret
=cdo
->tray_move(cdi
,0);
1070 cd_dbg(CD_OPEN
, "bummer. tried to close the tray but failed.\n");
1071 /* Ignore the error from the low
1072 level driver. We don't care why it
1073 couldn't close the tray. We only care
1074 that there is no disc in the drive,
1075 since that is the _REAL_ problem here.*/
1077 goto clean_up_and_return
;
1080 cd_dbg(CD_OPEN
, "bummer. this drive can't close the tray.\n");
1082 goto clean_up_and_return
;
1084 /* Ok, the door should be closed now.. Check again */
1085 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
1086 if ((ret
== CDS_NO_DISC
) || (ret
==CDS_TRAY_OPEN
)) {
1087 cd_dbg(CD_OPEN
, "bummer. the tray is still not closed.\n");
1088 cd_dbg(CD_OPEN
, "tray might not contain a medium\n");
1090 goto clean_up_and_return
;
1092 cd_dbg(CD_OPEN
, "the tray is now closed\n");
1094 /* the door should be closed now, check for the disc */
1095 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
1096 if (ret
!=CDS_DISC_OK
) {
1098 goto clean_up_and_return
;
1101 cdrom_count_tracks(cdi
, &tracks
);
1102 if (tracks
.error
== CDS_NO_DISC
) {
1103 cd_dbg(CD_OPEN
, "bummer. no disc.\n");
1105 goto clean_up_and_return
;
1107 /* CD-Players which don't use O_NONBLOCK, workman
1108 * for example, need bit CDO_CHECK_TYPE cleared! */
1109 if (tracks
.data
==0) {
1110 if (cdi
->options
& CDO_CHECK_TYPE
) {
1111 /* give people a warning shot, now that CDO_CHECK_TYPE
1112 is the default case! */
1113 cd_dbg(CD_OPEN
, "bummer. wrong media type.\n");
1114 cd_dbg(CD_WARNING
, "pid %d must open device O_NONBLOCK!\n",
1115 (unsigned int)task_pid_nr(current
));
1117 goto clean_up_and_return
;
1120 cd_dbg(CD_OPEN
, "wrong media type, but CDO_CHECK_TYPE not set\n");
1124 cd_dbg(CD_OPEN
, "all seems well, opening the devicen");
1126 /* all seems well, we can open the device */
1127 ret
= cdo
->open(cdi
, 0); /* open for data */
1128 cd_dbg(CD_OPEN
, "opening the device gave me %d\n", ret
);
1129 /* After all this careful checking, we shouldn't have problems
1130 opening the device, but we don't want the device locked if
1131 this somehow fails... */
1133 cd_dbg(CD_OPEN
, "open device failed\n");
1134 goto clean_up_and_return
;
1136 if (CDROM_CAN(CDC_LOCK
) && (cdi
->options
& CDO_LOCK
)) {
1137 cdo
->lock_door(cdi
, 1);
1138 cd_dbg(CD_OPEN
, "door locked\n");
1140 cd_dbg(CD_OPEN
, "device opened successfully\n");
1143 /* Something failed. Try to unlock the drive, because some drivers
1144 (notably ide-cd) lock the drive after every command. This produced
1145 a nasty bug where after mount failed, the drive would remain locked!
1146 This ensures that the drive gets unlocked after a mount fails. This
1147 is a goto to avoid bloating the driver with redundant code. */
1148 clean_up_and_return
:
1149 cd_dbg(CD_OPEN
, "open failed\n");
1150 if (CDROM_CAN(CDC_LOCK
) && cdi
->options
& CDO_LOCK
) {
1151 cdo
->lock_door(cdi
, 0);
1152 cd_dbg(CD_OPEN
, "door unlocked\n");
1157 /* We use the open-option O_NONBLOCK to indicate that the
1158 * purpose of opening is only for subsequent ioctl() calls; no device
1159 * integrity checks are performed.
1161 * We hope that all cd-player programs will adopt this convention. It
1162 * is in their own interest: device control becomes a lot easier
1165 int cdrom_open(struct cdrom_device_info
*cdi
, struct block_device
*bdev
,
1170 cd_dbg(CD_OPEN
, "entering cdrom_open\n");
1172 /* if this was a O_NONBLOCK open and we should honor the flags,
1173 * do a quick open without drive/disc integrity checks. */
1175 if ((mode
& FMODE_NDELAY
) && (cdi
->options
& CDO_USE_FFLAGS
)) {
1176 ret
= cdi
->ops
->open(cdi
, 1);
1178 ret
= open_for_data(cdi
);
1181 if (CDROM_CAN(CDC_GENERIC_PACKET
))
1182 cdrom_mmc3_profile(cdi
);
1183 if (mode
& FMODE_WRITE
) {
1185 if (cdrom_open_write(cdi
))
1187 if (!CDROM_CAN(CDC_RAM
))
1190 cdi
->media_written
= 0;
1197 cd_dbg(CD_OPEN
, "Use count for \"/dev/%s\" now %d\n",
1198 cdi
->name
, cdi
->use_count
);
1201 if (CDROM_CAN(CDC_LOCK
) && cdi
->options
& CDO_LOCK
) {
1202 cdi
->ops
->lock_door(cdi
, 0);
1203 cd_dbg(CD_OPEN
, "door unlocked\n");
1205 cdi
->ops
->release(cdi
);
1211 /* This code is similar to that in open_for_data. The routine is called
1212 whenever an audio play operation is requested.
1214 static int check_for_audio_disc(struct cdrom_device_info
*cdi
,
1215 const struct cdrom_device_ops
*cdo
)
1219 cd_dbg(CD_OPEN
, "entering check_for_audio_disc\n");
1220 if (!(cdi
->options
& CDO_CHECK_TYPE
))
1222 if (cdo
->drive_status
!= NULL
) {
1223 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
1224 cd_dbg(CD_OPEN
, "drive_status=%d\n", ret
);
1225 if (ret
== CDS_TRAY_OPEN
) {
1226 cd_dbg(CD_OPEN
, "the tray is open...\n");
1227 /* can/may i close it? */
1228 if (CDROM_CAN(CDC_CLOSE_TRAY
) &&
1229 cdi
->options
& CDO_AUTO_CLOSE
) {
1230 cd_dbg(CD_OPEN
, "trying to close the tray\n");
1231 ret
=cdo
->tray_move(cdi
,0);
1233 cd_dbg(CD_OPEN
, "bummer. tried to close tray but failed.\n");
1234 /* Ignore the error from the low
1235 level driver. We don't care why it
1236 couldn't close the tray. We only care
1237 that there is no disc in the drive,
1238 since that is the _REAL_ problem here.*/
1242 cd_dbg(CD_OPEN
, "bummer. this driver can't close the tray.\n");
1245 /* Ok, the door should be closed now.. Check again */
1246 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
1247 if ((ret
== CDS_NO_DISC
) || (ret
==CDS_TRAY_OPEN
)) {
1248 cd_dbg(CD_OPEN
, "bummer. the tray is still not closed.\n");
1251 if (ret
!=CDS_DISC_OK
) {
1252 cd_dbg(CD_OPEN
, "bummer. disc isn't ready.\n");
1255 cd_dbg(CD_OPEN
, "the tray is now closed\n");
1258 cdrom_count_tracks(cdi
, &tracks
);
1260 return(tracks
.error
);
1262 if (tracks
.audio
==0)
1263 return -EMEDIUMTYPE
;
1268 void cdrom_release(struct cdrom_device_info
*cdi
, fmode_t mode
)
1270 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1271 int opened_for_data
;
1273 cd_dbg(CD_CLOSE
, "entering cdrom_release\n");
1275 if (cdi
->use_count
> 0)
1278 if (cdi
->use_count
== 0) {
1279 cd_dbg(CD_CLOSE
, "Use count for \"/dev/%s\" now zero\n",
1281 cdrom_dvd_rw_close_write(cdi
);
1283 if ((cdo
->capability
& CDC_LOCK
) && !cdi
->keeplocked
) {
1284 cd_dbg(CD_CLOSE
, "Unlocking door!\n");
1285 cdo
->lock_door(cdi
, 0);
1289 opened_for_data
= !(cdi
->options
& CDO_USE_FFLAGS
) ||
1290 !(mode
& FMODE_NDELAY
);
1293 * flush cache on last write release
1295 if (CDROM_CAN(CDC_RAM
) && !cdi
->use_count
&& cdi
->for_data
)
1296 cdrom_close_write(cdi
);
1299 if (cdi
->use_count
== 0) { /* last process that closes dev*/
1300 if (opened_for_data
&&
1301 cdi
->options
& CDO_AUTO_EJECT
&& CDROM_CAN(CDC_OPEN_TRAY
))
1302 cdo
->tray_move(cdi
, 1);
1306 static int cdrom_read_mech_status(struct cdrom_device_info
*cdi
,
1307 struct cdrom_changer_info
*buf
)
1309 struct packet_command cgc
;
1310 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1314 * Sanyo changer isn't spec compliant (doesn't use regular change
1315 * LOAD_UNLOAD command, and it doesn't implement the mech status
1318 if (cdi
->sanyo_slot
) {
1319 buf
->hdr
.nslots
= 3;
1320 buf
->hdr
.curslot
= cdi
->sanyo_slot
== 3 ? 0 : cdi
->sanyo_slot
;
1321 for (length
= 0; length
< 3; length
++) {
1322 buf
->slots
[length
].disc_present
= 1;
1323 buf
->slots
[length
].change
= 0;
1328 length
= sizeof(struct cdrom_mechstat_header
) +
1329 cdi
->capacity
* sizeof(struct cdrom_slot
);
1331 init_cdrom_command(&cgc
, buf
, length
, CGC_DATA_READ
);
1332 cgc
.cmd
[0] = GPCMD_MECHANISM_STATUS
;
1333 cgc
.cmd
[8] = (length
>> 8) & 0xff;
1334 cgc
.cmd
[9] = length
& 0xff;
1335 return cdo
->generic_packet(cdi
, &cgc
);
1338 static int cdrom_slot_status(struct cdrom_device_info
*cdi
, int slot
)
1340 struct cdrom_changer_info
*info
;
1343 cd_dbg(CD_CHANGER
, "entering cdrom_slot_status()\n");
1344 if (cdi
->sanyo_slot
)
1347 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
1351 if ((ret
= cdrom_read_mech_status(cdi
, info
)))
1354 if (info
->slots
[slot
].disc_present
)
1364 /* Return the number of slots for an ATAPI/SCSI cdrom,
1365 * return 1 if not a changer.
1367 int cdrom_number_of_slots(struct cdrom_device_info
*cdi
)
1371 struct cdrom_changer_info
*info
;
1373 cd_dbg(CD_CHANGER
, "entering cdrom_number_of_slots()\n");
1374 /* cdrom_read_mech_status requires a valid value for capacity: */
1377 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
1381 if ((status
= cdrom_read_mech_status(cdi
, info
)) == 0)
1382 nslots
= info
->hdr
.nslots
;
1389 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1390 static int cdrom_load_unload(struct cdrom_device_info
*cdi
, int slot
)
1392 struct packet_command cgc
;
1394 cd_dbg(CD_CHANGER
, "entering cdrom_load_unload()\n");
1395 if (cdi
->sanyo_slot
&& slot
< 0)
1398 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
1399 cgc
.cmd
[0] = GPCMD_LOAD_UNLOAD
;
1400 cgc
.cmd
[4] = 2 + (slot
>= 0);
1402 cgc
.timeout
= 60 * HZ
;
1404 /* The Sanyo 3 CD changer uses byte 7 of the
1405 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1406 using the GPCMD_LOAD_UNLOAD opcode. */
1407 if (cdi
->sanyo_slot
&& -1 < slot
) {
1408 cgc
.cmd
[0] = GPCMD_TEST_UNIT_READY
;
1410 cgc
.cmd
[4] = cgc
.cmd
[8] = 0;
1411 cdi
->sanyo_slot
= slot
? slot
: 3;
1414 return cdi
->ops
->generic_packet(cdi
, &cgc
);
1417 static int cdrom_select_disc(struct cdrom_device_info
*cdi
, int slot
)
1419 struct cdrom_changer_info
*info
;
1423 cd_dbg(CD_CHANGER
, "entering cdrom_select_disc()\n");
1424 if (!CDROM_CAN(CDC_SELECT_DISC
))
1425 return -EDRIVE_CANT_DO_THIS
;
1427 if (cdi
->ops
->check_events
)
1428 cdi
->ops
->check_events(cdi
, 0, slot
);
1430 if (slot
== CDSL_NONE
) {
1431 signal_media_change(cdi
);
1432 return cdrom_load_unload(cdi
, -1);
1435 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
1439 if ((ret
= cdrom_read_mech_status(cdi
, info
))) {
1444 curslot
= info
->hdr
.curslot
;
1447 if (cdi
->use_count
> 1 || cdi
->keeplocked
) {
1448 if (slot
== CDSL_CURRENT
) {
1455 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1456 which is useful if it had been previously unloaded.
1457 Whether it can or not, it returns the current slot.
1458 Similarly, if slot happens to be the current one, we still
1460 if (slot
== CDSL_CURRENT
)
1463 /* set media changed bits on both queues */
1464 signal_media_change(cdi
);
1465 if ((ret
= cdrom_load_unload(cdi
, slot
)))
1472 * As cdrom implements an extra ioctl consumer for media changed
1473 * event, it needs to buffer ->check_events() output, such that event
1474 * is not lost for both the usual VFS and ioctl paths.
1475 * cdi->{vfs|ioctl}_events are used to buffer pending events for each
1478 * XXX: Locking is non-existent. cdi->ops->check_events() can be
1479 * called in parallel and buffering fields are accessed without any
1480 * exclusion. The original media_changed code had the same problem.
1481 * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1482 * and remove this cruft altogether. It doesn't have much usefulness
1485 static void cdrom_update_events(struct cdrom_device_info
*cdi
,
1486 unsigned int clearing
)
1488 unsigned int events
;
1490 events
= cdi
->ops
->check_events(cdi
, clearing
, CDSL_CURRENT
);
1491 cdi
->vfs_events
|= events
;
1492 cdi
->ioctl_events
|= events
;
1495 unsigned int cdrom_check_events(struct cdrom_device_info
*cdi
,
1496 unsigned int clearing
)
1498 unsigned int events
;
1500 cdrom_update_events(cdi
, clearing
);
1501 events
= cdi
->vfs_events
;
1502 cdi
->vfs_events
= 0;
1505 EXPORT_SYMBOL(cdrom_check_events
);
1507 /* We want to make media_changed accessible to the user through an
1508 * ioctl. The main problem now is that we must double-buffer the
1509 * low-level implementation, to assure that the VFS and the user both
1510 * see a medium change once.
1514 int media_changed(struct cdrom_device_info
*cdi
, int queue
)
1516 unsigned int mask
= (1 << (queue
& 1));
1517 int ret
= !!(cdi
->mc_flags
& mask
);
1520 if (!CDROM_CAN(CDC_MEDIA_CHANGED
))
1523 /* changed since last call? */
1524 BUG_ON(!queue
); /* shouldn't be called from VFS path */
1525 cdrom_update_events(cdi
, DISK_EVENT_MEDIA_CHANGE
);
1526 changed
= cdi
->ioctl_events
& DISK_EVENT_MEDIA_CHANGE
;
1527 cdi
->ioctl_events
= 0;
1530 signal_media_change(cdi
);
1532 cdi
->media_written
= 0;
1535 cdi
->mc_flags
&= ~mask
; /* clear bit */
1539 /* Requests to the low-level drivers will /always/ be done in the
1540 following format convention:
1542 CDROM_LBA: all data-related requests.
1543 CDROM_MSF: all audio-related requests.
1545 However, a low-level implementation is allowed to refuse this
1546 request, and return information in its own favorite format.
1548 It doesn't make sense /at all/ to ask for a play_audio in LBA
1549 format, or ask for multi-session info in MSF format. However, for
1550 backward compatibility these format requests will be satisfied, but
1551 the requests to the low-level drivers will be sanitized in the more
1552 meaningful format indicated above.
1556 void sanitize_format(union cdrom_addr
*addr
,
1557 u_char
* curr
, u_char requested
)
1559 if (*curr
== requested
)
1560 return; /* nothing to be done! */
1561 if (requested
== CDROM_LBA
) {
1562 addr
->lba
= (int) addr
->msf
.frame
+
1563 75 * (addr
->msf
.second
- 2 + 60 * addr
->msf
.minute
);
1564 } else { /* CDROM_MSF */
1565 int lba
= addr
->lba
;
1566 addr
->msf
.frame
= lba
% 75;
1569 addr
->msf
.second
= lba
% 60;
1570 addr
->msf
.minute
= lba
/ 60;
1575 void init_cdrom_command(struct packet_command
*cgc
, void *buf
, int len
,
1578 memset(cgc
, 0, sizeof(struct packet_command
));
1580 memset(buf
, 0, len
);
1581 cgc
->buffer
= (char *) buf
;
1583 cgc
->data_direction
= type
;
1584 cgc
->timeout
= CDROM_DEF_TIMEOUT
;
1589 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1590 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1592 static void setup_report_key(struct packet_command
*cgc
, unsigned agid
, unsigned type
)
1594 cgc
->cmd
[0] = GPCMD_REPORT_KEY
;
1595 cgc
->cmd
[10] = type
| (agid
<< 6);
1597 case 0: case 8: case 5: {
1610 cgc
->cmd
[9] = cgc
->buflen
;
1611 cgc
->data_direction
= CGC_DATA_READ
;
1614 static void setup_send_key(struct packet_command
*cgc
, unsigned agid
, unsigned type
)
1616 cgc
->cmd
[0] = GPCMD_SEND_KEY
;
1617 cgc
->cmd
[10] = type
| (agid
<< 6);
1632 cgc
->cmd
[9] = cgc
->buflen
;
1633 cgc
->data_direction
= CGC_DATA_WRITE
;
1636 static int dvd_do_auth(struct cdrom_device_info
*cdi
, dvd_authinfo
*ai
)
1640 struct packet_command cgc
;
1641 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1642 rpc_state_t rpc_state
;
1644 memset(buf
, 0, sizeof(buf
));
1645 init_cdrom_command(&cgc
, buf
, 0, CGC_DATA_READ
);
1649 case DVD_LU_SEND_AGID
:
1650 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_AGID\n");
1652 setup_report_key(&cgc
, ai
->lsa
.agid
, 0);
1654 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1657 ai
->lsa
.agid
= buf
[7] >> 6;
1658 /* Returning data, let host change state */
1661 case DVD_LU_SEND_KEY1
:
1662 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_KEY1\n");
1663 setup_report_key(&cgc
, ai
->lsk
.agid
, 2);
1665 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1668 copy_key(ai
->lsk
.key
, &buf
[4]);
1669 /* Returning data, let host change state */
1672 case DVD_LU_SEND_CHALLENGE
:
1673 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_CHALLENGE\n");
1674 setup_report_key(&cgc
, ai
->lsc
.agid
, 1);
1676 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1679 copy_chal(ai
->lsc
.chal
, &buf
[4]);
1680 /* Returning data, let host change state */
1684 case DVD_LU_SEND_TITLE_KEY
:
1685 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_TITLE_KEY\n");
1687 setup_report_key(&cgc
, ai
->lstk
.agid
, 4);
1688 cgc
.cmd
[5] = ai
->lstk
.lba
;
1689 cgc
.cmd
[4] = ai
->lstk
.lba
>> 8;
1690 cgc
.cmd
[3] = ai
->lstk
.lba
>> 16;
1691 cgc
.cmd
[2] = ai
->lstk
.lba
>> 24;
1693 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1696 ai
->lstk
.cpm
= (buf
[4] >> 7) & 1;
1697 ai
->lstk
.cp_sec
= (buf
[4] >> 6) & 1;
1698 ai
->lstk
.cgms
= (buf
[4] >> 4) & 3;
1699 copy_key(ai
->lstk
.title_key
, &buf
[5]);
1700 /* Returning data, let host change state */
1703 case DVD_LU_SEND_ASF
:
1704 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_ASF\n");
1705 setup_report_key(&cgc
, ai
->lsasf
.agid
, 5);
1707 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1710 ai
->lsasf
.asf
= buf
[7] & 1;
1713 /* LU data receive (LU changes state) */
1714 case DVD_HOST_SEND_CHALLENGE
:
1715 cd_dbg(CD_DVD
, "entering DVD_HOST_SEND_CHALLENGE\n");
1716 setup_send_key(&cgc
, ai
->hsc
.agid
, 1);
1718 copy_chal(&buf
[4], ai
->hsc
.chal
);
1720 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1723 ai
->type
= DVD_LU_SEND_KEY1
;
1726 case DVD_HOST_SEND_KEY2
:
1727 cd_dbg(CD_DVD
, "entering DVD_HOST_SEND_KEY2\n");
1728 setup_send_key(&cgc
, ai
->hsk
.agid
, 3);
1730 copy_key(&buf
[4], ai
->hsk
.key
);
1732 if ((ret
= cdo
->generic_packet(cdi
, &cgc
))) {
1733 ai
->type
= DVD_AUTH_FAILURE
;
1736 ai
->type
= DVD_AUTH_ESTABLISHED
;
1740 case DVD_INVALIDATE_AGID
:
1742 cd_dbg(CD_DVD
, "entering DVD_INVALIDATE_AGID\n");
1743 setup_report_key(&cgc
, ai
->lsa
.agid
, 0x3f);
1744 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1748 /* Get region settings */
1749 case DVD_LU_SEND_RPC_STATE
:
1750 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_RPC_STATE\n");
1751 setup_report_key(&cgc
, 0, 8);
1752 memset(&rpc_state
, 0, sizeof(rpc_state_t
));
1753 cgc
.buffer
= (char *) &rpc_state
;
1755 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1758 ai
->lrpcs
.type
= rpc_state
.type_code
;
1759 ai
->lrpcs
.vra
= rpc_state
.vra
;
1760 ai
->lrpcs
.ucca
= rpc_state
.ucca
;
1761 ai
->lrpcs
.region_mask
= rpc_state
.region_mask
;
1762 ai
->lrpcs
.rpc_scheme
= rpc_state
.rpc_scheme
;
1765 /* Set region settings */
1766 case DVD_HOST_SEND_RPC_STATE
:
1767 cd_dbg(CD_DVD
, "entering DVD_HOST_SEND_RPC_STATE\n");
1768 setup_send_key(&cgc
, 0, 6);
1770 buf
[4] = ai
->hrpcs
.pdrc
;
1772 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1777 cd_dbg(CD_WARNING
, "Invalid DVD key ioctl (%d)\n", ai
->type
);
1784 static int dvd_read_physical(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1785 struct packet_command
*cgc
)
1787 unsigned char buf
[21], *base
;
1788 struct dvd_layer
*layer
;
1789 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1790 int ret
, layer_num
= s
->physical
.layer_num
;
1792 if (layer_num
>= DVD_LAYERS
)
1795 init_cdrom_command(cgc
, buf
, sizeof(buf
), CGC_DATA_READ
);
1796 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1797 cgc
->cmd
[6] = layer_num
;
1798 cgc
->cmd
[7] = s
->type
;
1799 cgc
->cmd
[9] = cgc
->buflen
& 0xff;
1802 * refrain from reporting errors on non-existing layers (mainly)
1806 ret
= cdo
->generic_packet(cdi
, cgc
);
1811 layer
= &s
->physical
.layer
[layer_num
];
1814 * place the data... really ugly, but at least we won't have to
1815 * worry about endianess in userspace.
1817 memset(layer
, 0, sizeof(*layer
));
1818 layer
->book_version
= base
[0] & 0xf;
1819 layer
->book_type
= base
[0] >> 4;
1820 layer
->min_rate
= base
[1] & 0xf;
1821 layer
->disc_size
= base
[1] >> 4;
1822 layer
->layer_type
= base
[2] & 0xf;
1823 layer
->track_path
= (base
[2] >> 4) & 1;
1824 layer
->nlayers
= (base
[2] >> 5) & 3;
1825 layer
->track_density
= base
[3] & 0xf;
1826 layer
->linear_density
= base
[3] >> 4;
1827 layer
->start_sector
= base
[5] << 16 | base
[6] << 8 | base
[7];
1828 layer
->end_sector
= base
[9] << 16 | base
[10] << 8 | base
[11];
1829 layer
->end_sector_l0
= base
[13] << 16 | base
[14] << 8 | base
[15];
1830 layer
->bca
= base
[16] >> 7;
1835 static int dvd_read_copyright(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1836 struct packet_command
*cgc
)
1840 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1842 init_cdrom_command(cgc
, buf
, sizeof(buf
), CGC_DATA_READ
);
1843 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1844 cgc
->cmd
[6] = s
->copyright
.layer_num
;
1845 cgc
->cmd
[7] = s
->type
;
1846 cgc
->cmd
[8] = cgc
->buflen
>> 8;
1847 cgc
->cmd
[9] = cgc
->buflen
& 0xff;
1849 ret
= cdo
->generic_packet(cdi
, cgc
);
1853 s
->copyright
.cpst
= buf
[4];
1854 s
->copyright
.rmi
= buf
[5];
1859 static int dvd_read_disckey(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1860 struct packet_command
*cgc
)
1864 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1866 size
= sizeof(s
->disckey
.value
) + 4;
1868 buf
= kmalloc(size
, GFP_KERNEL
);
1872 init_cdrom_command(cgc
, buf
, size
, CGC_DATA_READ
);
1873 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1874 cgc
->cmd
[7] = s
->type
;
1875 cgc
->cmd
[8] = size
>> 8;
1876 cgc
->cmd
[9] = size
& 0xff;
1877 cgc
->cmd
[10] = s
->disckey
.agid
<< 6;
1879 ret
= cdo
->generic_packet(cdi
, cgc
);
1881 memcpy(s
->disckey
.value
, &buf
[4], sizeof(s
->disckey
.value
));
1887 static int dvd_read_bca(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1888 struct packet_command
*cgc
)
1890 int ret
, size
= 4 + 188;
1892 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1894 buf
= kmalloc(size
, GFP_KERNEL
);
1898 init_cdrom_command(cgc
, buf
, size
, CGC_DATA_READ
);
1899 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1900 cgc
->cmd
[7] = s
->type
;
1901 cgc
->cmd
[9] = cgc
->buflen
& 0xff;
1903 ret
= cdo
->generic_packet(cdi
, cgc
);
1907 s
->bca
.len
= buf
[0] << 8 | buf
[1];
1908 if (s
->bca
.len
< 12 || s
->bca
.len
> 188) {
1909 cd_dbg(CD_WARNING
, "Received invalid BCA length (%d)\n",
1914 memcpy(s
->bca
.value
, &buf
[4], s
->bca
.len
);
1921 static int dvd_read_manufact(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1922 struct packet_command
*cgc
)
1926 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1928 size
= sizeof(s
->manufact
.value
) + 4;
1930 buf
= kmalloc(size
, GFP_KERNEL
);
1934 init_cdrom_command(cgc
, buf
, size
, CGC_DATA_READ
);
1935 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1936 cgc
->cmd
[7] = s
->type
;
1937 cgc
->cmd
[8] = size
>> 8;
1938 cgc
->cmd
[9] = size
& 0xff;
1940 ret
= cdo
->generic_packet(cdi
, cgc
);
1944 s
->manufact
.len
= buf
[0] << 8 | buf
[1];
1945 if (s
->manufact
.len
< 0) {
1946 cd_dbg(CD_WARNING
, "Received invalid manufacture info length (%d)\n",
1950 if (s
->manufact
.len
> 2048) {
1951 cd_dbg(CD_WARNING
, "Received invalid manufacture info length (%d): truncating to 2048\n",
1953 s
->manufact
.len
= 2048;
1955 memcpy(s
->manufact
.value
, &buf
[4], s
->manufact
.len
);
1963 static int dvd_read_struct(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1964 struct packet_command
*cgc
)
1967 case DVD_STRUCT_PHYSICAL
:
1968 return dvd_read_physical(cdi
, s
, cgc
);
1970 case DVD_STRUCT_COPYRIGHT
:
1971 return dvd_read_copyright(cdi
, s
, cgc
);
1973 case DVD_STRUCT_DISCKEY
:
1974 return dvd_read_disckey(cdi
, s
, cgc
);
1976 case DVD_STRUCT_BCA
:
1977 return dvd_read_bca(cdi
, s
, cgc
);
1979 case DVD_STRUCT_MANUFACT
:
1980 return dvd_read_manufact(cdi
, s
, cgc
);
1983 cd_dbg(CD_WARNING
, ": Invalid DVD structure read requested (%d)\n",
1989 int cdrom_mode_sense(struct cdrom_device_info
*cdi
,
1990 struct packet_command
*cgc
,
1991 int page_code
, int page_control
)
1993 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
1995 memset(cgc
->cmd
, 0, sizeof(cgc
->cmd
));
1997 cgc
->cmd
[0] = GPCMD_MODE_SENSE_10
;
1998 cgc
->cmd
[2] = page_code
| (page_control
<< 6);
1999 cgc
->cmd
[7] = cgc
->buflen
>> 8;
2000 cgc
->cmd
[8] = cgc
->buflen
& 0xff;
2001 cgc
->data_direction
= CGC_DATA_READ
;
2002 return cdo
->generic_packet(cdi
, cgc
);
2005 int cdrom_mode_select(struct cdrom_device_info
*cdi
,
2006 struct packet_command
*cgc
)
2008 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
2010 memset(cgc
->cmd
, 0, sizeof(cgc
->cmd
));
2011 memset(cgc
->buffer
, 0, 2);
2012 cgc
->cmd
[0] = GPCMD_MODE_SELECT_10
;
2013 cgc
->cmd
[1] = 0x10; /* PF */
2014 cgc
->cmd
[7] = cgc
->buflen
>> 8;
2015 cgc
->cmd
[8] = cgc
->buflen
& 0xff;
2016 cgc
->data_direction
= CGC_DATA_WRITE
;
2017 return cdo
->generic_packet(cdi
, cgc
);
2020 static int cdrom_read_subchannel(struct cdrom_device_info
*cdi
,
2021 struct cdrom_subchnl
*subchnl
, int mcn
)
2023 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
2024 struct packet_command cgc
;
2028 init_cdrom_command(&cgc
, buffer
, 16, CGC_DATA_READ
);
2029 cgc
.cmd
[0] = GPCMD_READ_SUBCHANNEL
;
2030 cgc
.cmd
[1] = subchnl
->cdsc_format
;/* MSF or LBA addressing */
2031 cgc
.cmd
[2] = 0x40; /* request subQ data */
2032 cgc
.cmd
[3] = mcn
? 2 : 1;
2035 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
2038 subchnl
->cdsc_audiostatus
= cgc
.buffer
[1];
2039 subchnl
->cdsc_ctrl
= cgc
.buffer
[5] & 0xf;
2040 subchnl
->cdsc_trk
= cgc
.buffer
[6];
2041 subchnl
->cdsc_ind
= cgc
.buffer
[7];
2043 if (subchnl
->cdsc_format
== CDROM_LBA
) {
2044 subchnl
->cdsc_absaddr
.lba
= ((cgc
.buffer
[8] << 24) |
2045 (cgc
.buffer
[9] << 16) |
2046 (cgc
.buffer
[10] << 8) |
2048 subchnl
->cdsc_reladdr
.lba
= ((cgc
.buffer
[12] << 24) |
2049 (cgc
.buffer
[13] << 16) |
2050 (cgc
.buffer
[14] << 8) |
2053 subchnl
->cdsc_reladdr
.msf
.minute
= cgc
.buffer
[13];
2054 subchnl
->cdsc_reladdr
.msf
.second
= cgc
.buffer
[14];
2055 subchnl
->cdsc_reladdr
.msf
.frame
= cgc
.buffer
[15];
2056 subchnl
->cdsc_absaddr
.msf
.minute
= cgc
.buffer
[9];
2057 subchnl
->cdsc_absaddr
.msf
.second
= cgc
.buffer
[10];
2058 subchnl
->cdsc_absaddr
.msf
.frame
= cgc
.buffer
[11];
2065 * Specific READ_10 interface
2067 static int cdrom_read_cd(struct cdrom_device_info
*cdi
,
2068 struct packet_command
*cgc
, int lba
,
2069 int blocksize
, int nblocks
)
2071 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
2073 memset(&cgc
->cmd
, 0, sizeof(cgc
->cmd
));
2074 cgc
->cmd
[0] = GPCMD_READ_10
;
2075 cgc
->cmd
[2] = (lba
>> 24) & 0xff;
2076 cgc
->cmd
[3] = (lba
>> 16) & 0xff;
2077 cgc
->cmd
[4] = (lba
>> 8) & 0xff;
2078 cgc
->cmd
[5] = lba
& 0xff;
2079 cgc
->cmd
[6] = (nblocks
>> 16) & 0xff;
2080 cgc
->cmd
[7] = (nblocks
>> 8) & 0xff;
2081 cgc
->cmd
[8] = nblocks
& 0xff;
2082 cgc
->buflen
= blocksize
* nblocks
;
2083 return cdo
->generic_packet(cdi
, cgc
);
2086 /* very generic interface for reading the various types of blocks */
2087 static int cdrom_read_block(struct cdrom_device_info
*cdi
,
2088 struct packet_command
*cgc
,
2089 int lba
, int nblocks
, int format
, int blksize
)
2091 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
2093 memset(&cgc
->cmd
, 0, sizeof(cgc
->cmd
));
2094 cgc
->cmd
[0] = GPCMD_READ_CD
;
2095 /* expected sector size - cdda,mode1,etc. */
2096 cgc
->cmd
[1] = format
<< 2;
2097 /* starting address */
2098 cgc
->cmd
[2] = (lba
>> 24) & 0xff;
2099 cgc
->cmd
[3] = (lba
>> 16) & 0xff;
2100 cgc
->cmd
[4] = (lba
>> 8) & 0xff;
2101 cgc
->cmd
[5] = lba
& 0xff;
2102 /* number of blocks */
2103 cgc
->cmd
[6] = (nblocks
>> 16) & 0xff;
2104 cgc
->cmd
[7] = (nblocks
>> 8) & 0xff;
2105 cgc
->cmd
[8] = nblocks
& 0xff;
2106 cgc
->buflen
= blksize
* nblocks
;
2108 /* set the header info returned */
2110 case CD_FRAMESIZE_RAW0
: cgc
->cmd
[9] = 0x58; break;
2111 case CD_FRAMESIZE_RAW1
: cgc
->cmd
[9] = 0x78; break;
2112 case CD_FRAMESIZE_RAW
: cgc
->cmd
[9] = 0xf8; break;
2113 default : cgc
->cmd
[9] = 0x10;
2116 return cdo
->generic_packet(cdi
, cgc
);
2119 static int cdrom_read_cdda_old(struct cdrom_device_info
*cdi
, __u8 __user
*ubuf
,
2120 int lba
, int nframes
)
2122 struct packet_command cgc
;
2126 cdi
->last_sense
= 0;
2128 memset(&cgc
, 0, sizeof(cgc
));
2131 * start with will ra.nframes size, back down if alloc fails
2135 cgc
.buffer
= kmalloc_array(nr
, CD_FRAMESIZE_RAW
, GFP_KERNEL
);
2145 cgc
.data_direction
= CGC_DATA_READ
;
2146 while (nframes
> 0) {
2150 ret
= cdrom_read_block(cdi
, &cgc
, lba
, nr
, 1, CD_FRAMESIZE_RAW
);
2153 if (copy_to_user(ubuf
, cgc
.buffer
, CD_FRAMESIZE_RAW
* nr
)) {
2157 ubuf
+= CD_FRAMESIZE_RAW
* nr
;
2165 static int cdrom_read_cdda_bpc(struct cdrom_device_info
*cdi
, __u8 __user
*ubuf
,
2166 int lba
, int nframes
)
2168 int max_frames
= (queue_max_sectors(cdi
->disk
->queue
) << 9) /
2172 cdi
->last_sense
= 0;
2175 if (cdi
->cdda_method
== CDDA_BPC_SINGLE
)
2178 nr
= min(nframes
, max_frames
);
2180 ret
= cdi
->ops
->read_cdda_bpc(cdi
, ubuf
, lba
, nr
,
2187 ubuf
+= (nr
* CD_FRAMESIZE_RAW
);
2193 static int cdrom_read_cdda(struct cdrom_device_info
*cdi
, __u8 __user
*ubuf
,
2194 int lba
, int nframes
)
2198 if (cdi
->cdda_method
== CDDA_OLD
)
2199 return cdrom_read_cdda_old(cdi
, ubuf
, lba
, nframes
);
2203 * for anything else than success and io error, we need to retry
2205 ret
= cdrom_read_cdda_bpc(cdi
, ubuf
, lba
, nframes
);
2206 if (!ret
|| ret
!= -EIO
)
2210 * I've seen drives get sense 4/8/3 udma crc errors on multi
2211 * frame dma, so drop to single frame dma if we need to
2213 if (cdi
->cdda_method
== CDDA_BPC_FULL
&& nframes
> 1) {
2214 pr_info("dropping to single frame dma\n");
2215 cdi
->cdda_method
= CDDA_BPC_SINGLE
;
2220 * so we have an io error of some sort with multi frame dma. if the
2221 * condition wasn't a hardware error
2222 * problems, not for any error
2224 if (cdi
->last_sense
!= 0x04 && cdi
->last_sense
!= 0x0b)
2227 pr_info("dropping to old style cdda (sense=%x)\n", cdi
->last_sense
);
2228 cdi
->cdda_method
= CDDA_OLD
;
2229 return cdrom_read_cdda_old(cdi
, ubuf
, lba
, nframes
);
2232 int cdrom_multisession(struct cdrom_device_info
*cdi
,
2233 struct cdrom_multisession
*info
)
2235 u8 requested_format
;
2238 if (!(cdi
->ops
->capability
& CDC_MULTI_SESSION
))
2241 requested_format
= info
->addr_format
;
2242 if (requested_format
!= CDROM_MSF
&& requested_format
!= CDROM_LBA
)
2244 info
->addr_format
= CDROM_LBA
;
2246 ret
= cdi
->ops
->get_last_session(cdi
, info
);
2248 sanitize_format(&info
->addr
, &info
->addr_format
,
2252 EXPORT_SYMBOL_GPL(cdrom_multisession
);
2254 static int cdrom_ioctl_multisession(struct cdrom_device_info
*cdi
,
2257 struct cdrom_multisession info
;
2260 cd_dbg(CD_DO_IOCTL
, "entering CDROMMULTISESSION\n");
2262 if (copy_from_user(&info
, argp
, sizeof(info
)))
2264 ret
= cdrom_multisession(cdi
, &info
);
2267 if (copy_to_user(argp
, &info
, sizeof(info
)))
2270 cd_dbg(CD_DO_IOCTL
, "CDROMMULTISESSION successful\n");
2274 static int cdrom_ioctl_eject(struct cdrom_device_info
*cdi
)
2276 cd_dbg(CD_DO_IOCTL
, "entering CDROMEJECT\n");
2278 if (!CDROM_CAN(CDC_OPEN_TRAY
))
2280 if (cdi
->use_count
!= 1 || cdi
->keeplocked
)
2282 if (CDROM_CAN(CDC_LOCK
)) {
2283 int ret
= cdi
->ops
->lock_door(cdi
, 0);
2288 return cdi
->ops
->tray_move(cdi
, 1);
2291 static int cdrom_ioctl_closetray(struct cdrom_device_info
*cdi
)
2293 cd_dbg(CD_DO_IOCTL
, "entering CDROMCLOSETRAY\n");
2295 if (!CDROM_CAN(CDC_CLOSE_TRAY
))
2297 return cdi
->ops
->tray_move(cdi
, 0);
2300 static int cdrom_ioctl_eject_sw(struct cdrom_device_info
*cdi
,
2303 cd_dbg(CD_DO_IOCTL
, "entering CDROMEJECT_SW\n");
2305 if (!CDROM_CAN(CDC_OPEN_TRAY
))
2307 if (cdi
->keeplocked
)
2310 cdi
->options
&= ~(CDO_AUTO_CLOSE
| CDO_AUTO_EJECT
);
2312 cdi
->options
|= CDO_AUTO_CLOSE
| CDO_AUTO_EJECT
;
2316 static int cdrom_ioctl_media_changed(struct cdrom_device_info
*cdi
,
2319 struct cdrom_changer_info
*info
;
2322 cd_dbg(CD_DO_IOCTL
, "entering CDROM_MEDIA_CHANGED\n");
2324 if (!CDROM_CAN(CDC_MEDIA_CHANGED
))
2327 /* cannot select disc or select current disc */
2328 if (!CDROM_CAN(CDC_SELECT_DISC
) || arg
== CDSL_CURRENT
)
2329 return media_changed(cdi
, 1);
2331 if (arg
>= cdi
->capacity
)
2334 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
2338 ret
= cdrom_read_mech_status(cdi
, info
);
2340 ret
= info
->slots
[arg
].change
;
2346 * Media change detection with timing information.
2348 * arg is a pointer to a cdrom_timed_media_change_info struct.
2349 * arg->last_media_change may be set by calling code to signal
2350 * the timestamp (in ms) of the last known media change (by the caller).
2351 * Upon successful return, ioctl call will set arg->last_media_change
2352 * to the latest media change timestamp known by the kernel/driver
2353 * and set arg->has_changed to 1 if that timestamp is more recent
2354 * than the timestamp set by the caller.
2356 static int cdrom_ioctl_timed_media_change(struct cdrom_device_info
*cdi
,
2360 struct cdrom_timed_media_change_info __user
*info
;
2361 struct cdrom_timed_media_change_info tmp_info
;
2363 if (!CDROM_CAN(CDC_MEDIA_CHANGED
))
2366 info
= (struct cdrom_timed_media_change_info __user
*)arg
;
2367 cd_dbg(CD_DO_IOCTL
, "entering CDROM_TIMED_MEDIA_CHANGE\n");
2369 ret
= cdrom_ioctl_media_changed(cdi
, CDSL_CURRENT
);
2373 if (copy_from_user(&tmp_info
, info
, sizeof(tmp_info
)) != 0)
2376 tmp_info
.media_flags
= 0;
2377 if (tmp_info
.last_media_change
- cdi
->last_media_change_ms
< 0)
2378 tmp_info
.media_flags
|= MEDIA_CHANGED_FLAG
;
2380 tmp_info
.last_media_change
= cdi
->last_media_change_ms
;
2382 if (copy_to_user(info
, &tmp_info
, sizeof(*info
)) != 0)
2388 static int cdrom_ioctl_set_options(struct cdrom_device_info
*cdi
,
2391 cd_dbg(CD_DO_IOCTL
, "entering CDROM_SET_OPTIONS\n");
2394 * Options need to be in sync with capability.
2395 * Too late for that, so we have to check each one separately.
2398 case CDO_USE_FFLAGS
:
2399 case CDO_CHECK_TYPE
:
2402 if (!CDROM_CAN(CDC_LOCK
))
2406 return cdi
->options
;
2407 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2409 if (!CDROM_CAN(arg
))
2412 cdi
->options
|= (int) arg
;
2413 return cdi
->options
;
2416 static int cdrom_ioctl_clear_options(struct cdrom_device_info
*cdi
,
2419 cd_dbg(CD_DO_IOCTL
, "entering CDROM_CLEAR_OPTIONS\n");
2421 cdi
->options
&= ~(int) arg
;
2422 return cdi
->options
;
2425 static int cdrom_ioctl_select_speed(struct cdrom_device_info
*cdi
,
2428 cd_dbg(CD_DO_IOCTL
, "entering CDROM_SELECT_SPEED\n");
2430 if (!CDROM_CAN(CDC_SELECT_SPEED
))
2432 return cdi
->ops
->select_speed(cdi
, arg
);
2435 static int cdrom_ioctl_select_disc(struct cdrom_device_info
*cdi
,
2438 cd_dbg(CD_DO_IOCTL
, "entering CDROM_SELECT_DISC\n");
2440 if (!CDROM_CAN(CDC_SELECT_DISC
))
2443 if (arg
!= CDSL_CURRENT
&& arg
!= CDSL_NONE
) {
2444 if (arg
>= cdi
->capacity
)
2449 * ->select_disc is a hook to allow a driver-specific way of
2450 * seleting disc. However, since there is no equivalent hook for
2451 * cdrom_slot_status this may not actually be useful...
2453 if (cdi
->ops
->select_disc
)
2454 return cdi
->ops
->select_disc(cdi
, arg
);
2456 cd_dbg(CD_CHANGER
, "Using generic cdrom_select_disc()\n");
2457 return cdrom_select_disc(cdi
, arg
);
2460 static int cdrom_ioctl_reset(struct cdrom_device_info
*cdi
,
2461 struct block_device
*bdev
)
2463 cd_dbg(CD_DO_IOCTL
, "entering CDROM_RESET\n");
2465 if (!capable(CAP_SYS_ADMIN
))
2467 if (!CDROM_CAN(CDC_RESET
))
2469 invalidate_bdev(bdev
);
2470 return cdi
->ops
->reset(cdi
);
2473 static int cdrom_ioctl_lock_door(struct cdrom_device_info
*cdi
,
2476 cd_dbg(CD_DO_IOCTL
, "%socking door\n", arg
? "L" : "Unl");
2478 if (!CDROM_CAN(CDC_LOCK
))
2479 return -EDRIVE_CANT_DO_THIS
;
2481 cdi
->keeplocked
= arg
? 1 : 0;
2484 * Don't unlock the door on multiple opens by default, but allow
2487 if (cdi
->use_count
!= 1 && !arg
&& !capable(CAP_SYS_ADMIN
))
2489 return cdi
->ops
->lock_door(cdi
, arg
);
2492 static int cdrom_ioctl_debug(struct cdrom_device_info
*cdi
,
2495 cd_dbg(CD_DO_IOCTL
, "%sabling debug\n", arg
? "En" : "Dis");
2497 if (!capable(CAP_SYS_ADMIN
))
2499 debug
= arg
? 1 : 0;
2503 static int cdrom_ioctl_get_capability(struct cdrom_device_info
*cdi
)
2505 cd_dbg(CD_DO_IOCTL
, "entering CDROM_GET_CAPABILITY\n");
2506 return (cdi
->ops
->capability
& ~cdi
->mask
);
2510 * The following function is implemented, although very few audio
2511 * discs give Universal Product Code information, which should just be
2512 * the Medium Catalog Number on the box. Note, that the way the code
2513 * is written on the CD is /not/ uniform across all discs!
2515 static int cdrom_ioctl_get_mcn(struct cdrom_device_info
*cdi
,
2518 struct cdrom_mcn mcn
;
2521 cd_dbg(CD_DO_IOCTL
, "entering CDROM_GET_MCN\n");
2523 if (!(cdi
->ops
->capability
& CDC_MCN
))
2525 ret
= cdi
->ops
->get_mcn(cdi
, &mcn
);
2529 if (copy_to_user(argp
, &mcn
, sizeof(mcn
)))
2531 cd_dbg(CD_DO_IOCTL
, "CDROM_GET_MCN successful\n");
2535 static int cdrom_ioctl_drive_status(struct cdrom_device_info
*cdi
,
2538 cd_dbg(CD_DO_IOCTL
, "entering CDROM_DRIVE_STATUS\n");
2540 if (!(cdi
->ops
->capability
& CDC_DRIVE_STATUS
))
2542 if (!CDROM_CAN(CDC_SELECT_DISC
) ||
2543 (arg
== CDSL_CURRENT
|| arg
== CDSL_NONE
))
2544 return cdi
->ops
->drive_status(cdi
, CDSL_CURRENT
);
2545 if (arg
>= cdi
->capacity
)
2547 return cdrom_slot_status(cdi
, arg
);
2551 * Ok, this is where problems start. The current interface for the
2552 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2553 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunately, while this
2554 * is often the case, it is also very common for CDs to have some tracks
2555 * with data, and some tracks with audio. Just because I feel like it,
2556 * I declare the following to be the best way to cope. If the CD has ANY
2557 * data tracks on it, it will be returned as a data CD. If it has any XA
2558 * tracks, I will return it as that. Now I could simplify this interface
2559 * by combining these returns with the above, but this more clearly
2560 * demonstrates the problem with the current interface. Too bad this
2561 * wasn't designed to use bitmasks... -Erik
2563 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2564 * User level programmers might feel the ioctl is not very useful.
2567 static int cdrom_ioctl_disc_status(struct cdrom_device_info
*cdi
)
2571 cd_dbg(CD_DO_IOCTL
, "entering CDROM_DISC_STATUS\n");
2573 cdrom_count_tracks(cdi
, &tracks
);
2575 return tracks
.error
;
2577 /* Policy mode on */
2578 if (tracks
.audio
> 0) {
2579 if (!tracks
.data
&& !tracks
.cdi
&& !tracks
.xa
)
2589 if (tracks
.data
> 0)
2591 /* Policy mode off */
2593 cd_dbg(CD_WARNING
, "This disc doesn't have any tracks I recognize!\n");
2597 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info
*cdi
)
2599 cd_dbg(CD_DO_IOCTL
, "entering CDROM_CHANGER_NSLOTS\n");
2600 return cdi
->capacity
;
2603 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info
*cdi
,
2606 struct cdrom_subchnl q
;
2610 /* cd_dbg(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2612 if (copy_from_user(&q
, argp
, sizeof(q
)))
2615 requested
= q
.cdsc_format
;
2616 if (requested
!= CDROM_MSF
&& requested
!= CDROM_LBA
)
2618 q
.cdsc_format
= CDROM_MSF
;
2620 ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMSUBCHNL
, &q
);
2624 back
= q
.cdsc_format
; /* local copy */
2625 sanitize_format(&q
.cdsc_absaddr
, &back
, requested
);
2626 sanitize_format(&q
.cdsc_reladdr
, &q
.cdsc_format
, requested
);
2628 if (copy_to_user(argp
, &q
, sizeof(q
)))
2630 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2634 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info
*cdi
,
2637 struct cdrom_tochdr header
;
2640 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2642 if (copy_from_user(&header
, argp
, sizeof(header
)))
2645 ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCHDR
, &header
);
2649 if (copy_to_user(argp
, &header
, sizeof(header
)))
2651 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2655 int cdrom_read_tocentry(struct cdrom_device_info
*cdi
,
2656 struct cdrom_tocentry
*entry
)
2658 u8 requested_format
= entry
->cdte_format
;
2661 if (requested_format
!= CDROM_MSF
&& requested_format
!= CDROM_LBA
)
2664 /* make interface to low-level uniform */
2665 entry
->cdte_format
= CDROM_MSF
;
2666 ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCENTRY
, entry
);
2668 sanitize_format(&entry
->cdte_addr
, &entry
->cdte_format
,
2672 EXPORT_SYMBOL_GPL(cdrom_read_tocentry
);
2674 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info
*cdi
,
2677 struct cdrom_tocentry entry
;
2680 if (copy_from_user(&entry
, argp
, sizeof(entry
)))
2682 ret
= cdrom_read_tocentry(cdi
, &entry
);
2683 if (!ret
&& copy_to_user(argp
, &entry
, sizeof(entry
)))
2688 static int cdrom_ioctl_play_msf(struct cdrom_device_info
*cdi
,
2691 struct cdrom_msf msf
;
2693 cd_dbg(CD_DO_IOCTL
, "entering CDROMPLAYMSF\n");
2695 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2697 if (copy_from_user(&msf
, argp
, sizeof(msf
)))
2699 return cdi
->ops
->audio_ioctl(cdi
, CDROMPLAYMSF
, &msf
);
2702 static int cdrom_ioctl_play_trkind(struct cdrom_device_info
*cdi
,
2708 cd_dbg(CD_DO_IOCTL
, "entering CDROMPLAYTRKIND\n");
2710 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2712 if (copy_from_user(&ti
, argp
, sizeof(ti
)))
2715 ret
= check_for_audio_disc(cdi
, cdi
->ops
);
2718 return cdi
->ops
->audio_ioctl(cdi
, CDROMPLAYTRKIND
, &ti
);
2720 static int cdrom_ioctl_volctrl(struct cdrom_device_info
*cdi
,
2723 struct cdrom_volctrl volume
;
2725 cd_dbg(CD_DO_IOCTL
, "entering CDROMVOLCTRL\n");
2727 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2729 if (copy_from_user(&volume
, argp
, sizeof(volume
)))
2731 return cdi
->ops
->audio_ioctl(cdi
, CDROMVOLCTRL
, &volume
);
2734 static int cdrom_ioctl_volread(struct cdrom_device_info
*cdi
,
2737 struct cdrom_volctrl volume
;
2740 cd_dbg(CD_DO_IOCTL
, "entering CDROMVOLREAD\n");
2742 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2745 ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMVOLREAD
, &volume
);
2749 if (copy_to_user(argp
, &volume
, sizeof(volume
)))
2754 static int cdrom_ioctl_audioctl(struct cdrom_device_info
*cdi
,
2759 cd_dbg(CD_DO_IOCTL
, "doing audio ioctl (start/stop/pause/resume)\n");
2761 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2763 ret
= check_for_audio_disc(cdi
, cdi
->ops
);
2766 return cdi
->ops
->audio_ioctl(cdi
, cmd
, NULL
);
2770 * Required when we need to use READ_10 to issue other than 2048 block
2773 static int cdrom_switch_blocksize(struct cdrom_device_info
*cdi
, int size
)
2775 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
2776 struct packet_command cgc
;
2777 struct modesel_head mh
;
2779 memset(&mh
, 0, sizeof(mh
));
2780 mh
.block_desc_length
= 0x08;
2781 mh
.block_length_med
= (size
>> 8) & 0xff;
2782 mh
.block_length_lo
= size
& 0xff;
2784 memset(&cgc
, 0, sizeof(cgc
));
2786 cgc
.cmd
[1] = 1 << 4;
2788 cgc
.buflen
= sizeof(mh
);
2789 cgc
.buffer
= (char *) &mh
;
2790 cgc
.data_direction
= CGC_DATA_WRITE
;
2791 mh
.block_desc_length
= 0x08;
2792 mh
.block_length_med
= (size
>> 8) & 0xff;
2793 mh
.block_length_lo
= size
& 0xff;
2795 return cdo
->generic_packet(cdi
, &cgc
);
2798 static int cdrom_get_track_info(struct cdrom_device_info
*cdi
,
2799 __u16 track
, __u8 type
, track_information
*ti
)
2801 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
2802 struct packet_command cgc
;
2805 init_cdrom_command(&cgc
, ti
, 8, CGC_DATA_READ
);
2806 cgc
.cmd
[0] = GPCMD_READ_TRACK_RZONE_INFO
;
2807 cgc
.cmd
[1] = type
& 3;
2808 cgc
.cmd
[4] = (track
& 0xff00) >> 8;
2809 cgc
.cmd
[5] = track
& 0xff;
2813 ret
= cdo
->generic_packet(cdi
, &cgc
);
2817 buflen
= be16_to_cpu(ti
->track_information_length
) +
2818 sizeof(ti
->track_information_length
);
2820 if (buflen
> sizeof(track_information
))
2821 buflen
= sizeof(track_information
);
2823 cgc
.cmd
[8] = cgc
.buflen
= buflen
;
2824 ret
= cdo
->generic_packet(cdi
, &cgc
);
2828 /* return actual fill size */
2832 /* return the last written block on the CD-R media. this is for the udf
2834 int cdrom_get_last_written(struct cdrom_device_info
*cdi
, long *last_written
)
2836 struct cdrom_tocentry toc
;
2837 disc_information di
;
2838 track_information ti
;
2840 int ret
= -1, ti_size
;
2842 if (!CDROM_CAN(CDC_GENERIC_PACKET
))
2845 ret
= cdrom_get_disc_info(cdi
, &di
);
2846 if (ret
< (int)(offsetof(typeof(di
), last_track_lsb
)
2847 + sizeof(di
.last_track_lsb
)))
2850 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2851 last_track
= (di
.last_track_msb
<< 8) | di
.last_track_lsb
;
2852 ti_size
= cdrom_get_track_info(cdi
, last_track
, 1, &ti
);
2853 if (ti_size
< (int)offsetof(typeof(ti
), track_start
))
2856 /* if this track is blank, try the previous. */
2858 if (last_track
== 1)
2861 ti_size
= cdrom_get_track_info(cdi
, last_track
, 1, &ti
);
2864 if (ti_size
< (int)(offsetof(typeof(ti
), track_size
)
2865 + sizeof(ti
.track_size
)))
2868 /* if last recorded field is valid, return it. */
2869 if (ti
.lra_v
&& ti_size
>= (int)(offsetof(typeof(ti
), last_rec_address
)
2870 + sizeof(ti
.last_rec_address
))) {
2871 *last_written
= be32_to_cpu(ti
.last_rec_address
);
2873 /* make it up instead */
2874 *last_written
= be32_to_cpu(ti
.track_start
) +
2875 be32_to_cpu(ti
.track_size
);
2877 *last_written
-= (be32_to_cpu(ti
.free_blocks
) + 7);
2881 /* this is where we end up if the drive either can't do a
2882 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
2883 it doesn't give enough information or fails. then we return
2884 the toc contents. */
2886 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2889 toc
.cdte_format
= CDROM_MSF
;
2890 toc
.cdte_track
= CDROM_LEADOUT
;
2891 if ((ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCENTRY
, &toc
)))
2893 sanitize_format(&toc
.cdte_addr
, &toc
.cdte_format
, CDROM_LBA
);
2894 *last_written
= toc
.cdte_addr
.lba
;
2898 /* return the next writable block. also for udf file system. */
2899 static int cdrom_get_next_writable(struct cdrom_device_info
*cdi
,
2900 long *next_writable
)
2902 disc_information di
;
2903 track_information ti
;
2907 if (!CDROM_CAN(CDC_GENERIC_PACKET
))
2908 goto use_last_written
;
2910 ret
= cdrom_get_disc_info(cdi
, &di
);
2911 if (ret
< 0 || ret
< offsetof(typeof(di
), last_track_lsb
)
2912 + sizeof(di
.last_track_lsb
))
2913 goto use_last_written
;
2915 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2916 last_track
= (di
.last_track_msb
<< 8) | di
.last_track_lsb
;
2917 ti_size
= cdrom_get_track_info(cdi
, last_track
, 1, &ti
);
2918 if (ti_size
< 0 || ti_size
< offsetof(typeof(ti
), track_start
))
2919 goto use_last_written
;
2921 /* if this track is blank, try the previous. */
2923 if (last_track
== 1)
2924 goto use_last_written
;
2926 ti_size
= cdrom_get_track_info(cdi
, last_track
, 1, &ti
);
2928 goto use_last_written
;
2931 /* if next recordable address field is valid, use it. */
2932 if (ti
.nwa_v
&& ti_size
>= offsetof(typeof(ti
), next_writable
)
2933 + sizeof(ti
.next_writable
)) {
2934 *next_writable
= be32_to_cpu(ti
.next_writable
);
2939 ret
= cdrom_get_last_written(cdi
, next_writable
);
2944 *next_writable
+= 7;
2949 static noinline
int mmc_ioctl_cdrom_read_data(struct cdrom_device_info
*cdi
,
2951 struct packet_command
*cgc
,
2954 struct scsi_sense_hdr sshdr
;
2955 struct cdrom_msf msf
;
2956 int blocksize
= 0, format
= 0, lba
;
2961 blocksize
= CD_FRAMESIZE_RAW
;
2963 case CDROMREADMODE1
:
2964 blocksize
= CD_FRAMESIZE
;
2967 case CDROMREADMODE2
:
2968 blocksize
= CD_FRAMESIZE_RAW0
;
2971 if (copy_from_user(&msf
, (struct cdrom_msf __user
*)arg
, sizeof(msf
)))
2973 lba
= msf_to_lba(msf
.cdmsf_min0
, msf
.cdmsf_sec0
, msf
.cdmsf_frame0
);
2974 /* FIXME: we need upper bound checking, too!! */
2978 cgc
->buffer
= kzalloc(blocksize
, GFP_KERNEL
);
2979 if (cgc
->buffer
== NULL
)
2982 memset(&sshdr
, 0, sizeof(sshdr
));
2983 cgc
->sshdr
= &sshdr
;
2984 cgc
->data_direction
= CGC_DATA_READ
;
2985 ret
= cdrom_read_block(cdi
, cgc
, lba
, 1, format
, blocksize
);
2986 if (ret
&& sshdr
.sense_key
== 0x05 &&
2987 sshdr
.asc
== 0x20 &&
2988 sshdr
.ascq
== 0x00) {
2990 * SCSI-II devices are not required to support
2991 * READ_CD, so let's try switching block size
2993 if (blocksize
!= CD_FRAMESIZE
) {
2994 ret
= cdrom_switch_blocksize(cdi
, blocksize
);
2999 ret
= cdrom_read_cd(cdi
, cgc
, lba
, blocksize
, 1);
3000 if (blocksize
!= CD_FRAMESIZE
)
3001 ret
|= cdrom_switch_blocksize(cdi
, CD_FRAMESIZE
);
3003 if (!ret
&& copy_to_user(arg
, cgc
->buffer
, blocksize
))
3010 static noinline
int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info
*cdi
,
3013 struct cdrom_read_audio ra
;
3016 #ifdef CONFIG_COMPAT
3017 if (in_compat_syscall()) {
3018 struct compat_cdrom_read_audio
{
3019 union cdrom_addr addr
;
3021 compat_int_t nframes
;
3025 if (copy_from_user(&ra32
, arg
, sizeof(ra32
)))
3028 ra
= (struct cdrom_read_audio
) {
3030 .addr_format
= ra32
.addr_format
,
3031 .nframes
= ra32
.nframes
,
3032 .buf
= compat_ptr(ra32
.buf
),
3037 if (copy_from_user(&ra
, (struct cdrom_read_audio __user
*)arg
,
3042 if (ra
.addr_format
== CDROM_MSF
)
3043 lba
= msf_to_lba(ra
.addr
.msf
.minute
,
3046 else if (ra
.addr_format
== CDROM_LBA
)
3051 /* FIXME: we need upper bound checking, too!! */
3052 if (lba
< 0 || ra
.nframes
<= 0 || ra
.nframes
> CD_FRAMES
)
3055 return cdrom_read_cdda(cdi
, ra
.buf
, lba
, ra
.nframes
);
3058 static noinline
int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info
*cdi
,
3062 struct cdrom_subchnl q
;
3063 u_char requested
, back
;
3064 if (copy_from_user(&q
, (struct cdrom_subchnl __user
*)arg
, sizeof(q
)))
3066 requested
= q
.cdsc_format
;
3067 if (!((requested
== CDROM_MSF
) ||
3068 (requested
== CDROM_LBA
)))
3071 ret
= cdrom_read_subchannel(cdi
, &q
, 0);
3074 back
= q
.cdsc_format
; /* local copy */
3075 sanitize_format(&q
.cdsc_absaddr
, &back
, requested
);
3076 sanitize_format(&q
.cdsc_reladdr
, &q
.cdsc_format
, requested
);
3077 if (copy_to_user((struct cdrom_subchnl __user
*)arg
, &q
, sizeof(q
)))
3079 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
3083 static noinline
int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info
*cdi
,
3085 struct packet_command
*cgc
)
3087 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
3088 struct cdrom_msf msf
;
3089 cd_dbg(CD_DO_IOCTL
, "entering CDROMPLAYMSF\n");
3090 if (copy_from_user(&msf
, (struct cdrom_msf __user
*)arg
, sizeof(msf
)))
3092 cgc
->cmd
[0] = GPCMD_PLAY_AUDIO_MSF
;
3093 cgc
->cmd
[3] = msf
.cdmsf_min0
;
3094 cgc
->cmd
[4] = msf
.cdmsf_sec0
;
3095 cgc
->cmd
[5] = msf
.cdmsf_frame0
;
3096 cgc
->cmd
[6] = msf
.cdmsf_min1
;
3097 cgc
->cmd
[7] = msf
.cdmsf_sec1
;
3098 cgc
->cmd
[8] = msf
.cdmsf_frame1
;
3099 cgc
->data_direction
= CGC_DATA_NONE
;
3100 return cdo
->generic_packet(cdi
, cgc
);
3103 static noinline
int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info
*cdi
,
3105 struct packet_command
*cgc
)
3107 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
3108 struct cdrom_blk blk
;
3109 cd_dbg(CD_DO_IOCTL
, "entering CDROMPLAYBLK\n");
3110 if (copy_from_user(&blk
, (struct cdrom_blk __user
*)arg
, sizeof(blk
)))
3112 cgc
->cmd
[0] = GPCMD_PLAY_AUDIO_10
;
3113 cgc
->cmd
[2] = (blk
.from
>> 24) & 0xff;
3114 cgc
->cmd
[3] = (blk
.from
>> 16) & 0xff;
3115 cgc
->cmd
[4] = (blk
.from
>> 8) & 0xff;
3116 cgc
->cmd
[5] = blk
.from
& 0xff;
3117 cgc
->cmd
[7] = (blk
.len
>> 8) & 0xff;
3118 cgc
->cmd
[8] = blk
.len
& 0xff;
3119 cgc
->data_direction
= CGC_DATA_NONE
;
3120 return cdo
->generic_packet(cdi
, cgc
);
3123 static noinline
int mmc_ioctl_cdrom_volume(struct cdrom_device_info
*cdi
,
3125 struct packet_command
*cgc
,
3128 struct cdrom_volctrl volctrl
;
3129 unsigned char buffer
[32];
3130 char mask
[sizeof(buffer
)];
3131 unsigned short offset
;
3134 cd_dbg(CD_DO_IOCTL
, "entering CDROMVOLUME\n");
3136 if (copy_from_user(&volctrl
, (struct cdrom_volctrl __user
*)arg
,
3140 cgc
->buffer
= buffer
;
3142 ret
= cdrom_mode_sense(cdi
, cgc
, GPMODE_AUDIO_CTL_PAGE
, 0);
3146 /* originally the code depended on buffer[1] to determine
3147 how much data is available for transfer. buffer[1] is
3148 unfortunately ambigious and the only reliable way seem
3149 to be to simply skip over the block descriptor... */
3150 offset
= 8 + be16_to_cpu(*(__be16
*)(buffer
+ 6));
3152 if (offset
+ 16 > sizeof(buffer
))
3155 if (offset
+ 16 > cgc
->buflen
) {
3156 cgc
->buflen
= offset
+ 16;
3157 ret
= cdrom_mode_sense(cdi
, cgc
,
3158 GPMODE_AUDIO_CTL_PAGE
, 0);
3164 if ((buffer
[offset
] & 0x3f) != GPMODE_AUDIO_CTL_PAGE
||
3165 buffer
[offset
+ 1] < 14)
3168 /* now we have the current volume settings. if it was only
3169 a CDROMVOLREAD, return these values */
3170 if (cmd
== CDROMVOLREAD
) {
3171 volctrl
.channel0
= buffer
[offset
+9];
3172 volctrl
.channel1
= buffer
[offset
+11];
3173 volctrl
.channel2
= buffer
[offset
+13];
3174 volctrl
.channel3
= buffer
[offset
+15];
3175 if (copy_to_user((struct cdrom_volctrl __user
*)arg
, &volctrl
,
3181 /* get the volume mask */
3183 ret
= cdrom_mode_sense(cdi
, cgc
, GPMODE_AUDIO_CTL_PAGE
, 1);
3187 buffer
[offset
+ 9] = volctrl
.channel0
& mask
[offset
+ 9];
3188 buffer
[offset
+ 11] = volctrl
.channel1
& mask
[offset
+ 11];
3189 buffer
[offset
+ 13] = volctrl
.channel2
& mask
[offset
+ 13];
3190 buffer
[offset
+ 15] = volctrl
.channel3
& mask
[offset
+ 15];
3193 cgc
->buffer
= buffer
+ offset
- 8;
3194 memset(cgc
->buffer
, 0, 8);
3195 return cdrom_mode_select(cdi
, cgc
);
3198 static noinline
int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info
*cdi
,
3199 struct packet_command
*cgc
,
3202 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
3203 cd_dbg(CD_DO_IOCTL
, "entering CDROMSTART/CDROMSTOP\n");
3204 cgc
->cmd
[0] = GPCMD_START_STOP_UNIT
;
3206 cgc
->cmd
[4] = (cmd
== CDROMSTART
) ? 1 : 0;
3207 cgc
->data_direction
= CGC_DATA_NONE
;
3208 return cdo
->generic_packet(cdi
, cgc
);
3211 static noinline
int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info
*cdi
,
3212 struct packet_command
*cgc
,
3215 const struct cdrom_device_ops
*cdo
= cdi
->ops
;
3216 cd_dbg(CD_DO_IOCTL
, "entering CDROMPAUSE/CDROMRESUME\n");
3217 cgc
->cmd
[0] = GPCMD_PAUSE_RESUME
;
3218 cgc
->cmd
[8] = (cmd
== CDROMRESUME
) ? 1 : 0;
3219 cgc
->data_direction
= CGC_DATA_NONE
;
3220 return cdo
->generic_packet(cdi
, cgc
);
3223 static noinline
int mmc_ioctl_dvd_read_struct(struct cdrom_device_info
*cdi
,
3225 struct packet_command
*cgc
)
3229 int size
= sizeof(dvd_struct
);
3231 if (!CDROM_CAN(CDC_DVD
))
3234 s
= memdup_user(arg
, size
);
3238 cd_dbg(CD_DO_IOCTL
, "entering DVD_READ_STRUCT\n");
3240 ret
= dvd_read_struct(cdi
, s
, cgc
);
3244 if (copy_to_user(arg
, s
, size
))
3251 static noinline
int mmc_ioctl_dvd_auth(struct cdrom_device_info
*cdi
,
3256 if (!CDROM_CAN(CDC_DVD
))
3258 cd_dbg(CD_DO_IOCTL
, "entering DVD_AUTH\n");
3259 if (copy_from_user(&ai
, (dvd_authinfo __user
*)arg
, sizeof(ai
)))
3261 ret
= dvd_do_auth(cdi
, &ai
);
3264 if (copy_to_user((dvd_authinfo __user
*)arg
, &ai
, sizeof(ai
)))
3269 static noinline
int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info
*cdi
,
3274 cd_dbg(CD_DO_IOCTL
, "entering CDROM_NEXT_WRITABLE\n");
3275 ret
= cdrom_get_next_writable(cdi
, &next
);
3278 if (copy_to_user((long __user
*)arg
, &next
, sizeof(next
)))
3283 static noinline
int mmc_ioctl_cdrom_last_written(struct cdrom_device_info
*cdi
,
3288 cd_dbg(CD_DO_IOCTL
, "entering CDROM_LAST_WRITTEN\n");
3289 ret
= cdrom_get_last_written(cdi
, &last
);
3292 if (in_compat_syscall())
3293 return put_user(last
, (__s32 __user
*)arg
);
3295 return put_user(last
, (long __user
*)arg
);
3298 static int mmc_ioctl(struct cdrom_device_info
*cdi
, unsigned int cmd
,
3301 struct packet_command cgc
;
3302 void __user
*userptr
= (void __user
*)arg
;
3304 memset(&cgc
, 0, sizeof(cgc
));
3306 /* build a unified command and queue it through
3307 cdo->generic_packet() */
3310 case CDROMREADMODE1
:
3311 case CDROMREADMODE2
:
3312 return mmc_ioctl_cdrom_read_data(cdi
, userptr
, &cgc
, cmd
);
3313 case CDROMREADAUDIO
:
3314 return mmc_ioctl_cdrom_read_audio(cdi
, userptr
);
3316 return mmc_ioctl_cdrom_subchannel(cdi
, userptr
);
3318 return mmc_ioctl_cdrom_play_msf(cdi
, userptr
, &cgc
);
3320 return mmc_ioctl_cdrom_play_blk(cdi
, userptr
, &cgc
);
3323 return mmc_ioctl_cdrom_volume(cdi
, userptr
, &cgc
, cmd
);
3326 return mmc_ioctl_cdrom_start_stop(cdi
, &cgc
, cmd
);
3329 return mmc_ioctl_cdrom_pause_resume(cdi
, &cgc
, cmd
);
3330 case DVD_READ_STRUCT
:
3331 return mmc_ioctl_dvd_read_struct(cdi
, userptr
, &cgc
);
3333 return mmc_ioctl_dvd_auth(cdi
, userptr
);
3334 case CDROM_NEXT_WRITABLE
:
3335 return mmc_ioctl_cdrom_next_writable(cdi
, userptr
);
3336 case CDROM_LAST_WRITTEN
:
3337 return mmc_ioctl_cdrom_last_written(cdi
, userptr
);
3344 * Just about every imaginable ioctl is supported in the Uniform layer
3346 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
3348 int cdrom_ioctl(struct cdrom_device_info
*cdi
, struct block_device
*bdev
,
3349 fmode_t mode
, unsigned int cmd
, unsigned long arg
)
3351 void __user
*argp
= (void __user
*)arg
;
3355 case CDROMMULTISESSION
:
3356 return cdrom_ioctl_multisession(cdi
, argp
);
3358 return cdrom_ioctl_eject(cdi
);
3359 case CDROMCLOSETRAY
:
3360 return cdrom_ioctl_closetray(cdi
);
3362 return cdrom_ioctl_eject_sw(cdi
, arg
);
3363 case CDROM_MEDIA_CHANGED
:
3364 return cdrom_ioctl_media_changed(cdi
, arg
);
3365 case CDROM_TIMED_MEDIA_CHANGE
:
3366 return cdrom_ioctl_timed_media_change(cdi
, arg
);
3367 case CDROM_SET_OPTIONS
:
3368 return cdrom_ioctl_set_options(cdi
, arg
);
3369 case CDROM_CLEAR_OPTIONS
:
3370 return cdrom_ioctl_clear_options(cdi
, arg
);
3371 case CDROM_SELECT_SPEED
:
3372 return cdrom_ioctl_select_speed(cdi
, arg
);
3373 case CDROM_SELECT_DISC
:
3374 return cdrom_ioctl_select_disc(cdi
, arg
);
3376 return cdrom_ioctl_reset(cdi
, bdev
);
3377 case CDROM_LOCKDOOR
:
3378 return cdrom_ioctl_lock_door(cdi
, arg
);
3380 return cdrom_ioctl_debug(cdi
, arg
);
3381 case CDROM_GET_CAPABILITY
:
3382 return cdrom_ioctl_get_capability(cdi
);
3384 return cdrom_ioctl_get_mcn(cdi
, argp
);
3385 case CDROM_DRIVE_STATUS
:
3386 return cdrom_ioctl_drive_status(cdi
, arg
);
3387 case CDROM_DISC_STATUS
:
3388 return cdrom_ioctl_disc_status(cdi
);
3389 case CDROM_CHANGER_NSLOTS
:
3390 return cdrom_ioctl_changer_nslots(cdi
);
3394 * Use the ioctls that are implemented through the generic_packet()
3395 * interface. this may look at bit funny, but if -ENOTTY is
3396 * returned that particular ioctl is not implemented and we
3397 * let it go through the device specific ones.
3399 if (CDROM_CAN(CDC_GENERIC_PACKET
)) {
3400 ret
= mmc_ioctl(cdi
, cmd
, arg
);
3406 * Note: most of the cd_dbg() calls are commented out here,
3407 * because they fill up the sys log when CD players poll
3412 return cdrom_ioctl_get_subchnl(cdi
, argp
);
3413 case CDROMREADTOCHDR
:
3414 return cdrom_ioctl_read_tochdr(cdi
, argp
);
3415 case CDROMREADTOCENTRY
:
3416 return cdrom_ioctl_read_tocentry(cdi
, argp
);
3418 return cdrom_ioctl_play_msf(cdi
, argp
);
3419 case CDROMPLAYTRKIND
:
3420 return cdrom_ioctl_play_trkind(cdi
, argp
);
3422 return cdrom_ioctl_volctrl(cdi
, argp
);
3424 return cdrom_ioctl_volread(cdi
, argp
);
3429 return cdrom_ioctl_audioctl(cdi
, cmd
);
3435 EXPORT_SYMBOL(cdrom_get_last_written
);
3436 EXPORT_SYMBOL(register_cdrom
);
3437 EXPORT_SYMBOL(unregister_cdrom
);
3438 EXPORT_SYMBOL(cdrom_open
);
3439 EXPORT_SYMBOL(cdrom_release
);
3440 EXPORT_SYMBOL(cdrom_ioctl
);
3441 EXPORT_SYMBOL(cdrom_number_of_slots
);
3442 EXPORT_SYMBOL(cdrom_mode_select
);
3443 EXPORT_SYMBOL(cdrom_mode_sense
);
3444 EXPORT_SYMBOL(init_cdrom_command
);
3445 EXPORT_SYMBOL(cdrom_get_media_event
);
3447 #ifdef CONFIG_SYSCTL
3449 #define CDROM_STR_SIZE 1000
3451 static struct cdrom_sysctl_settings
{
3452 char info
[CDROM_STR_SIZE
]; /* general info */
3453 int autoclose
; /* close tray upon mount, etc */
3454 int autoeject
; /* eject on umount */
3455 int debug
; /* turn on debugging messages */
3456 int lock
; /* lock the door on device open */
3457 int check
; /* check media type */
3458 } cdrom_sysctl_settings
;
3460 enum cdrom_print_option
{
3467 static int cdrom_print_info(const char *header
, int val
, char *info
,
3468 int *pos
, enum cdrom_print_option option
)
3470 const int max_size
= sizeof(cdrom_sysctl_settings
.info
);
3471 struct cdrom_device_info
*cdi
;
3474 ret
= scnprintf(info
+ *pos
, max_size
- *pos
, header
);
3480 list_for_each_entry(cdi
, &cdrom_list
, list
) {
3483 ret
= scnprintf(info
+ *pos
, max_size
- *pos
,
3487 ret
= scnprintf(info
+ *pos
, max_size
- *pos
,
3488 "\t%d", cdi
->speed
);
3491 ret
= scnprintf(info
+ *pos
, max_size
- *pos
,
3492 "\t%d", cdi
->capacity
);
3494 case CTL_CAPABILITY
:
3495 ret
= scnprintf(info
+ *pos
, max_size
- *pos
,
3496 "\t%d", CDROM_CAN(val
) != 0);
3499 pr_info("invalid option%d\n", option
);
3510 static int cdrom_sysctl_info(struct ctl_table
*ctl
, int write
,
3511 void *buffer
, size_t *lenp
, loff_t
*ppos
)
3514 char *info
= cdrom_sysctl_settings
.info
;
3515 const int max_size
= sizeof(cdrom_sysctl_settings
.info
);
3517 if (!*lenp
|| (*ppos
&& !write
)) {
3522 mutex_lock(&cdrom_mutex
);
3524 pos
= sprintf(info
, "CD-ROM information, " VERSION
"\n");
3526 if (cdrom_print_info("\ndrive name:\t", 0, info
, &pos
, CTL_NAME
))
3528 if (cdrom_print_info("\ndrive speed:\t", 0, info
, &pos
, CTL_SPEED
))
3530 if (cdrom_print_info("\ndrive # of slots:", 0, info
, &pos
, CTL_SLOTS
))
3532 if (cdrom_print_info("\nCan close tray:\t",
3533 CDC_CLOSE_TRAY
, info
, &pos
, CTL_CAPABILITY
))
3535 if (cdrom_print_info("\nCan open tray:\t",
3536 CDC_OPEN_TRAY
, info
, &pos
, CTL_CAPABILITY
))
3538 if (cdrom_print_info("\nCan lock tray:\t",
3539 CDC_LOCK
, info
, &pos
, CTL_CAPABILITY
))
3541 if (cdrom_print_info("\nCan change speed:",
3542 CDC_SELECT_SPEED
, info
, &pos
, CTL_CAPABILITY
))
3544 if (cdrom_print_info("\nCan select disk:",
3545 CDC_SELECT_DISC
, info
, &pos
, CTL_CAPABILITY
))
3547 if (cdrom_print_info("\nCan read multisession:",
3548 CDC_MULTI_SESSION
, info
, &pos
, CTL_CAPABILITY
))
3550 if (cdrom_print_info("\nCan read MCN:\t",
3551 CDC_MCN
, info
, &pos
, CTL_CAPABILITY
))
3553 if (cdrom_print_info("\nReports media changed:",
3554 CDC_MEDIA_CHANGED
, info
, &pos
, CTL_CAPABILITY
))
3556 if (cdrom_print_info("\nCan play audio:\t",
3557 CDC_PLAY_AUDIO
, info
, &pos
, CTL_CAPABILITY
))
3559 if (cdrom_print_info("\nCan write CD-R:\t",
3560 CDC_CD_R
, info
, &pos
, CTL_CAPABILITY
))
3562 if (cdrom_print_info("\nCan write CD-RW:",
3563 CDC_CD_RW
, info
, &pos
, CTL_CAPABILITY
))
3565 if (cdrom_print_info("\nCan read DVD:\t",
3566 CDC_DVD
, info
, &pos
, CTL_CAPABILITY
))
3568 if (cdrom_print_info("\nCan write DVD-R:",
3569 CDC_DVD_R
, info
, &pos
, CTL_CAPABILITY
))
3571 if (cdrom_print_info("\nCan write DVD-RAM:",
3572 CDC_DVD_RAM
, info
, &pos
, CTL_CAPABILITY
))
3574 if (cdrom_print_info("\nCan read MRW:\t",
3575 CDC_MRW
, info
, &pos
, CTL_CAPABILITY
))
3577 if (cdrom_print_info("\nCan write MRW:\t",
3578 CDC_MRW_W
, info
, &pos
, CTL_CAPABILITY
))
3580 if (cdrom_print_info("\nCan write RAM:\t",
3581 CDC_RAM
, info
, &pos
, CTL_CAPABILITY
))
3583 if (!scnprintf(info
+ pos
, max_size
- pos
, "\n\n"))
3586 mutex_unlock(&cdrom_mutex
);
3587 return proc_dostring(ctl
, write
, buffer
, lenp
, ppos
);
3589 pr_info("info buffer too small\n");
3593 /* Unfortunately, per device settings are not implemented through
3594 procfs/sysctl yet. When they are, this will naturally disappear. For now
3595 just update all drives. Later this will become the template on which
3596 new registered drives will be based. */
3597 static void cdrom_update_settings(void)
3599 struct cdrom_device_info
*cdi
;
3601 mutex_lock(&cdrom_mutex
);
3602 list_for_each_entry(cdi
, &cdrom_list
, list
) {
3603 if (autoclose
&& CDROM_CAN(CDC_CLOSE_TRAY
))
3604 cdi
->options
|= CDO_AUTO_CLOSE
;
3605 else if (!autoclose
)
3606 cdi
->options
&= ~CDO_AUTO_CLOSE
;
3607 if (autoeject
&& CDROM_CAN(CDC_OPEN_TRAY
))
3608 cdi
->options
|= CDO_AUTO_EJECT
;
3609 else if (!autoeject
)
3610 cdi
->options
&= ~CDO_AUTO_EJECT
;
3611 if (lockdoor
&& CDROM_CAN(CDC_LOCK
))
3612 cdi
->options
|= CDO_LOCK
;
3614 cdi
->options
&= ~CDO_LOCK
;
3615 if (check_media_type
)
3616 cdi
->options
|= CDO_CHECK_TYPE
;
3618 cdi
->options
&= ~CDO_CHECK_TYPE
;
3620 mutex_unlock(&cdrom_mutex
);
3623 static int cdrom_sysctl_handler(struct ctl_table
*ctl
, int write
,
3624 void *buffer
, size_t *lenp
, loff_t
*ppos
)
3628 ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
3632 /* we only care for 1 or 0. */
3633 autoclose
= !!cdrom_sysctl_settings
.autoclose
;
3634 autoeject
= !!cdrom_sysctl_settings
.autoeject
;
3635 debug
= !!cdrom_sysctl_settings
.debug
;
3636 lockdoor
= !!cdrom_sysctl_settings
.lock
;
3637 check_media_type
= !!cdrom_sysctl_settings
.check
;
3639 /* update the option flags according to the changes. we
3640 don't have per device options through sysctl yet,
3641 but we will have and then this will disappear. */
3642 cdrom_update_settings();
3648 /* Place files in /proc/sys/dev/cdrom */
3649 static struct ctl_table cdrom_table
[] = {
3652 .data
= &cdrom_sysctl_settings
.info
,
3653 .maxlen
= CDROM_STR_SIZE
,
3655 .proc_handler
= cdrom_sysctl_info
,
3658 .procname
= "autoclose",
3659 .data
= &cdrom_sysctl_settings
.autoclose
,
3660 .maxlen
= sizeof(int),
3662 .proc_handler
= cdrom_sysctl_handler
,
3665 .procname
= "autoeject",
3666 .data
= &cdrom_sysctl_settings
.autoeject
,
3667 .maxlen
= sizeof(int),
3669 .proc_handler
= cdrom_sysctl_handler
,
3672 .procname
= "debug",
3673 .data
= &cdrom_sysctl_settings
.debug
,
3674 .maxlen
= sizeof(int),
3676 .proc_handler
= cdrom_sysctl_handler
,
3680 .data
= &cdrom_sysctl_settings
.lock
,
3681 .maxlen
= sizeof(int),
3683 .proc_handler
= cdrom_sysctl_handler
,
3686 .procname
= "check_media",
3687 .data
= &cdrom_sysctl_settings
.check
,
3688 .maxlen
= sizeof(int),
3690 .proc_handler
= cdrom_sysctl_handler
3695 static struct ctl_table cdrom_cdrom_table
[] = {
3697 .procname
= "cdrom",
3700 .child
= cdrom_table
,
3705 /* Make sure that /proc/sys/dev is there */
3706 static struct ctl_table cdrom_root_table
[] = {
3711 .child
= cdrom_cdrom_table
,
3715 static struct ctl_table_header
*cdrom_sysctl_header
;
3717 static void cdrom_sysctl_register(void)
3719 static atomic_t initialized
= ATOMIC_INIT(0);
3721 if (!atomic_add_unless(&initialized
, 1, 1))
3724 cdrom_sysctl_header
= register_sysctl_table(cdrom_root_table
);
3726 /* set the defaults */
3727 cdrom_sysctl_settings
.autoclose
= autoclose
;
3728 cdrom_sysctl_settings
.autoeject
= autoeject
;
3729 cdrom_sysctl_settings
.debug
= debug
;
3730 cdrom_sysctl_settings
.lock
= lockdoor
;
3731 cdrom_sysctl_settings
.check
= check_media_type
;
3734 static void cdrom_sysctl_unregister(void)
3736 if (cdrom_sysctl_header
)
3737 unregister_sysctl_table(cdrom_sysctl_header
);
3740 #else /* CONFIG_SYSCTL */
3742 static void cdrom_sysctl_register(void)
3746 static void cdrom_sysctl_unregister(void)
3750 #endif /* CONFIG_SYSCTL */
3752 static int __init
cdrom_init(void)
3754 cdrom_sysctl_register();
3759 static void __exit
cdrom_exit(void)
3761 pr_info("Uniform CD-ROM driver unloaded\n");
3762 cdrom_sysctl_unregister();
3765 module_init(cdrom_init
);
3766 module_exit(cdrom_exit
);
3767 MODULE_LICENSE("GPL");