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.tex 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/module.h>
269 #include <linux/fs.h>
270 #include <linux/major.h>
271 #include <linux/types.h>
272 #include <linux/errno.h>
273 #include <linux/kernel.h>
274 #include <linux/mm.h>
275 #include <linux/slab.h>
276 #include <linux/cdrom.h>
277 #include <linux/sysctl.h>
278 #include <linux/proc_fs.h>
279 #include <linux/blkpg.h>
280 #include <linux/init.h>
281 #include <linux/fcntl.h>
282 #include <linux/blkdev.h>
283 #include <linux/times.h>
285 #include <asm/uaccess.h>
287 /* used to tell the module to turn on full debugging messages */
289 /* default compatibility mode */
290 static bool autoclose
=1;
291 static bool autoeject
;
292 static bool lockdoor
= 1;
293 /* will we ever get to use this... sigh. */
294 static bool check_media_type
;
295 /* automatically restart mrw format */
296 static bool mrw_format_restart
= 1;
297 module_param(debug
, bool, 0);
298 module_param(autoclose
, bool, 0);
299 module_param(autoeject
, bool, 0);
300 module_param(lockdoor
, bool, 0);
301 module_param(check_media_type
, bool, 0);
302 module_param(mrw_format_restart
, bool, 0);
304 static DEFINE_MUTEX(cdrom_mutex
);
306 static const char *mrw_format_status
[] = {
313 static const char *mrw_address_space
[] = { "DMA", "GAA" };
315 #if (ERRLOGMASK != CD_NOTHING)
316 #define cd_dbg(type, fmt, ...) \
318 if ((ERRLOGMASK & type) || debug == 1) \
319 pr_debug(fmt, ##__VA_ARGS__); \
322 #define cd_dbg(type, fmt, ...) \
324 if (0 && (ERRLOGMASK & type) || debug == 1) \
325 pr_debug(fmt, ##__VA_ARGS__); \
329 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
330 a lot of places. This macro makes the code more clear. */
331 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
334 * Another popular OS uses 7 seconds as the hard timeout for default
335 * commands, so it is a good choice for us as well.
337 #define CDROM_DEF_TIMEOUT (7 * HZ)
339 /* Not-exported routines. */
340 static void sanitize_format(union cdrom_addr
*addr
,
341 u_char
* curr
, u_char requested
);
342 static int mmc_ioctl(struct cdrom_device_info
*cdi
, unsigned int cmd
,
345 int cdrom_get_last_written(struct cdrom_device_info
*, long *);
346 static int cdrom_get_next_writable(struct cdrom_device_info
*, long *);
347 static void cdrom_count_tracks(struct cdrom_device_info
*, tracktype
*);
349 static int cdrom_mrw_exit(struct cdrom_device_info
*cdi
);
351 static int cdrom_get_disc_info(struct cdrom_device_info
*cdi
, disc_information
*di
);
353 static void cdrom_sysctl_register(void);
355 static LIST_HEAD(cdrom_list
);
357 static int cdrom_dummy_generic_packet(struct cdrom_device_info
*cdi
,
358 struct packet_command
*cgc
)
361 cgc
->sense
->sense_key
= 0x05;
362 cgc
->sense
->asc
= 0x20;
363 cgc
->sense
->ascq
= 0x00;
370 /* This macro makes sure we don't have to check on cdrom_device_ops
371 * existence in the run-time routines below. Change_capability is a
372 * hack to have the capability flags defined const, while we can still
373 * change it here without gcc complaining at every line.
375 #define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
377 int register_cdrom(struct cdrom_device_info
*cdi
)
379 static char banner_printed
;
380 struct cdrom_device_ops
*cdo
= cdi
->ops
;
381 int *change_capability
= (int *)&cdo
->capability
; /* hack */
383 cd_dbg(CD_OPEN
, "entering register_cdrom\n");
385 if (cdo
->open
== NULL
|| cdo
->release
== NULL
)
387 if (!banner_printed
) {
388 pr_info("Uniform CD-ROM driver " REVISION
"\n");
390 cdrom_sysctl_register();
393 ENSURE(drive_status
, CDC_DRIVE_STATUS
);
394 if (cdo
->check_events
== NULL
&& cdo
->media_changed
== NULL
)
395 *change_capability
= ~(CDC_MEDIA_CHANGED
| CDC_SELECT_DISC
);
396 ENSURE(tray_move
, CDC_CLOSE_TRAY
| CDC_OPEN_TRAY
);
397 ENSURE(lock_door
, CDC_LOCK
);
398 ENSURE(select_speed
, CDC_SELECT_SPEED
);
399 ENSURE(get_last_session
, CDC_MULTI_SESSION
);
400 ENSURE(get_mcn
, CDC_MCN
);
401 ENSURE(reset
, CDC_RESET
);
402 ENSURE(generic_packet
, CDC_GENERIC_PACKET
);
405 cdi
->options
= CDO_USE_FFLAGS
;
407 if (autoclose
==1 && CDROM_CAN(CDC_CLOSE_TRAY
))
408 cdi
->options
|= (int) CDO_AUTO_CLOSE
;
409 if (autoeject
==1 && CDROM_CAN(CDC_OPEN_TRAY
))
410 cdi
->options
|= (int) CDO_AUTO_EJECT
;
412 cdi
->options
|= (int) CDO_LOCK
;
413 if (check_media_type
==1)
414 cdi
->options
|= (int) CDO_CHECK_TYPE
;
416 if (CDROM_CAN(CDC_MRW_W
))
417 cdi
->exit
= cdrom_mrw_exit
;
420 cdi
->cdda_method
= CDDA_BPC_FULL
;
422 cdi
->cdda_method
= CDDA_OLD
;
424 if (!cdo
->generic_packet
)
425 cdo
->generic_packet
= cdrom_dummy_generic_packet
;
427 cd_dbg(CD_REG_UNREG
, "drive \"/dev/%s\" registered\n", cdi
->name
);
428 mutex_lock(&cdrom_mutex
);
429 list_add(&cdi
->list
, &cdrom_list
);
430 mutex_unlock(&cdrom_mutex
);
435 void unregister_cdrom(struct cdrom_device_info
*cdi
)
437 cd_dbg(CD_OPEN
, "entering unregister_cdrom\n");
439 mutex_lock(&cdrom_mutex
);
440 list_del(&cdi
->list
);
441 mutex_unlock(&cdrom_mutex
);
446 cdi
->ops
->n_minors
--;
447 cd_dbg(CD_REG_UNREG
, "drive \"/dev/%s\" unregistered\n", cdi
->name
);
450 int cdrom_get_media_event(struct cdrom_device_info
*cdi
,
451 struct media_event_desc
*med
)
453 struct packet_command cgc
;
454 unsigned char buffer
[8];
455 struct event_header
*eh
= (struct event_header
*) buffer
;
457 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
458 cgc
.cmd
[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION
;
459 cgc
.cmd
[1] = 1; /* IMMED */
460 cgc
.cmd
[4] = 1 << 4; /* media event */
461 cgc
.cmd
[8] = sizeof(buffer
);
464 if (cdi
->ops
->generic_packet(cdi
, &cgc
))
467 if (be16_to_cpu(eh
->data_len
) < sizeof(*med
))
470 if (eh
->nea
|| eh
->notification_class
!= 0x4)
473 memcpy(med
, &buffer
[sizeof(*eh
)], sizeof(*med
));
478 * the first prototypes used 0x2c as the page code for the mrw mode page,
479 * subsequently this was changed to 0x03. probe the one used by this drive
481 static int cdrom_mrw_probe_pc(struct cdrom_device_info
*cdi
)
483 struct packet_command cgc
;
486 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
491 if (!cdrom_mode_sense(cdi
, &cgc
, MRW_MODE_PC
, 0)) {
492 cdi
->mrw_mode_page
= MRW_MODE_PC
;
494 } else if (!cdrom_mode_sense(cdi
, &cgc
, MRW_MODE_PC_PRE1
, 0)) {
495 cdi
->mrw_mode_page
= MRW_MODE_PC_PRE1
;
502 static int cdrom_is_mrw(struct cdrom_device_info
*cdi
, int *write
)
504 struct packet_command cgc
;
505 struct mrw_feature_desc
*mfd
;
506 unsigned char buffer
[16];
511 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
513 cgc
.cmd
[0] = GPCMD_GET_CONFIGURATION
;
514 cgc
.cmd
[3] = CDF_MRW
;
515 cgc
.cmd
[8] = sizeof(buffer
);
518 if ((ret
= cdi
->ops
->generic_packet(cdi
, &cgc
)))
521 mfd
= (struct mrw_feature_desc
*)&buffer
[sizeof(struct feature_header
)];
522 if (be16_to_cpu(mfd
->feature_code
) != CDF_MRW
)
526 if ((ret
= cdrom_mrw_probe_pc(cdi
))) {
534 static int cdrom_mrw_bgformat(struct cdrom_device_info
*cdi
, int cont
)
536 struct packet_command cgc
;
537 unsigned char buffer
[12];
540 pr_info("%sstarting format\n", cont
? "Re" : "");
543 * FmtData bit set (bit 4), format type is 1
545 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_WRITE
);
546 cgc
.cmd
[0] = GPCMD_FORMAT_UNIT
;
547 cgc
.cmd
[1] = (1 << 4) | 1;
549 cgc
.timeout
= 5 * 60 * HZ
;
552 * 4 byte format list header, 8 byte format list descriptor
565 buffer
[8] = 0x24 << 2;
568 ret
= cdi
->ops
->generic_packet(cdi
, &cgc
);
570 pr_info("bgformat failed\n");
575 static int cdrom_mrw_bgformat_susp(struct cdrom_device_info
*cdi
, int immed
)
577 struct packet_command cgc
;
579 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
580 cgc
.cmd
[0] = GPCMD_CLOSE_TRACK
;
583 * Session = 1, Track = 0
585 cgc
.cmd
[1] = !!immed
;
588 cgc
.timeout
= 5 * 60 * HZ
;
590 return cdi
->ops
->generic_packet(cdi
, &cgc
);
593 static int cdrom_flush_cache(struct cdrom_device_info
*cdi
)
595 struct packet_command cgc
;
597 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
598 cgc
.cmd
[0] = GPCMD_FLUSH_CACHE
;
600 cgc
.timeout
= 5 * 60 * HZ
;
602 return cdi
->ops
->generic_packet(cdi
, &cgc
);
605 static int cdrom_mrw_exit(struct cdrom_device_info
*cdi
)
610 ret
= cdrom_get_disc_info(cdi
, &di
);
611 if (ret
< 0 || ret
< (int)offsetof(typeof(di
),disc_type
))
615 if (di
.mrw_status
== CDM_MRW_BGFORMAT_ACTIVE
) {
616 pr_info("issuing MRW background format suspend\n");
617 ret
= cdrom_mrw_bgformat_susp(cdi
, 0);
620 if (!ret
&& cdi
->media_written
)
621 ret
= cdrom_flush_cache(cdi
);
626 static int cdrom_mrw_set_lba_space(struct cdrom_device_info
*cdi
, int space
)
628 struct packet_command cgc
;
629 struct mode_page_header
*mph
;
631 int ret
, offset
, size
;
633 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
636 cgc
.buflen
= sizeof(buffer
);
638 if ((ret
= cdrom_mode_sense(cdi
, &cgc
, cdi
->mrw_mode_page
, 0)))
641 mph
= (struct mode_page_header
*) buffer
;
642 offset
= be16_to_cpu(mph
->desc_length
);
643 size
= be16_to_cpu(mph
->mode_data_length
) + 2;
645 buffer
[offset
+ 3] = space
;
648 if ((ret
= cdrom_mode_select(cdi
, &cgc
)))
651 pr_info("%s: mrw address space %s selected\n",
652 cdi
->name
, mrw_address_space
[space
]);
656 static int cdrom_get_random_writable(struct cdrom_device_info
*cdi
,
657 struct rwrt_feature_desc
*rfd
)
659 struct packet_command cgc
;
663 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
665 cgc
.cmd
[0] = GPCMD_GET_CONFIGURATION
; /* often 0x46 */
666 cgc
.cmd
[3] = CDF_RWRT
; /* often 0x0020 */
667 cgc
.cmd
[8] = sizeof(buffer
); /* often 0x18 */
670 if ((ret
= cdi
->ops
->generic_packet(cdi
, &cgc
)))
673 memcpy(rfd
, &buffer
[sizeof(struct feature_header
)], sizeof (*rfd
));
677 static int cdrom_has_defect_mgt(struct cdrom_device_info
*cdi
)
679 struct packet_command cgc
;
681 __be16
*feature_code
;
684 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
686 cgc
.cmd
[0] = GPCMD_GET_CONFIGURATION
;
687 cgc
.cmd
[3] = CDF_HWDM
;
688 cgc
.cmd
[8] = sizeof(buffer
);
691 if ((ret
= cdi
->ops
->generic_packet(cdi
, &cgc
)))
694 feature_code
= (__be16
*) &buffer
[sizeof(struct feature_header
)];
695 if (be16_to_cpu(*feature_code
) == CDF_HWDM
)
702 static int cdrom_is_random_writable(struct cdrom_device_info
*cdi
, int *write
)
704 struct rwrt_feature_desc rfd
;
709 if ((ret
= cdrom_get_random_writable(cdi
, &rfd
)))
712 if (CDF_RWRT
== be16_to_cpu(rfd
.feature_code
))
718 static int cdrom_media_erasable(struct cdrom_device_info
*cdi
)
723 ret
= cdrom_get_disc_info(cdi
, &di
);
724 if (ret
< 0 || ret
< offsetof(typeof(di
), n_first_track
))
731 * FIXME: check RO bit
733 static int cdrom_dvdram_open_write(struct cdrom_device_info
*cdi
)
735 int ret
= cdrom_media_erasable(cdi
);
738 * allow writable open if media info read worked and media is
739 * erasable, _or_ if it fails since not all drives support it
747 static int cdrom_mrw_open_write(struct cdrom_device_info
*cdi
)
753 * always reset to DMA lba space on open
755 if (cdrom_mrw_set_lba_space(cdi
, MRW_LBA_DMA
)) {
756 pr_err("failed setting lba address space\n");
760 ret
= cdrom_get_disc_info(cdi
, &di
);
761 if (ret
< 0 || ret
< offsetof(typeof(di
),disc_type
))
769 * 0 - not MRW formatted
770 * 1 - MRW bgformat started, but not running or complete
771 * 2 - MRW bgformat in progress
772 * 3 - MRW formatting complete
775 pr_info("open: mrw_status '%s'\n", mrw_format_status
[di
.mrw_status
]);
778 else if (di
.mrw_status
== CDM_MRW_BGFORMAT_INACTIVE
&&
780 ret
= cdrom_mrw_bgformat(cdi
, 1);
785 static int mo_open_write(struct cdrom_device_info
*cdi
)
787 struct packet_command cgc
;
791 init_cdrom_command(&cgc
, &buffer
, 4, CGC_DATA_READ
);
795 * obtain write protect information as per
796 * drivers/scsi/sd.c:sd_read_write_protect_flag
799 ret
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_ALL_PAGES
, 0);
801 ret
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_VENDOR_PAGE
, 0);
804 ret
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_ALL_PAGES
, 0);
807 /* drive gave us no info, let the user go ahead */
811 return buffer
[3] & 0x80;
814 static int cdrom_ram_open_write(struct cdrom_device_info
*cdi
)
816 struct rwrt_feature_desc rfd
;
819 if ((ret
= cdrom_has_defect_mgt(cdi
)))
822 if ((ret
= cdrom_get_random_writable(cdi
, &rfd
)))
824 else if (CDF_RWRT
== be16_to_cpu(rfd
.feature_code
))
827 cd_dbg(CD_OPEN
, "can open for random write\n");
831 static void cdrom_mmc3_profile(struct cdrom_device_info
*cdi
)
833 struct packet_command cgc
;
835 int ret
, mmc3_profile
;
837 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_READ
);
839 cgc
.cmd
[0] = GPCMD_GET_CONFIGURATION
;
841 cgc
.cmd
[2] = cgc
.cmd
[3] = 0; /* Starting Feature Number */
842 cgc
.cmd
[8] = sizeof(buffer
); /* Allocation Length */
845 if ((ret
= cdi
->ops
->generic_packet(cdi
, &cgc
)))
846 mmc3_profile
= 0xffff;
848 mmc3_profile
= (buffer
[6] << 8) | buffer
[7];
850 cdi
->mmc3_profile
= mmc3_profile
;
853 static int cdrom_is_dvd_rw(struct cdrom_device_info
*cdi
)
855 switch (cdi
->mmc3_profile
) {
856 case 0x12: /* DVD-RAM */
857 case 0x1A: /* DVD+RW */
865 * returns 0 for ok to open write, non-0 to disallow
867 static int cdrom_open_write(struct cdrom_device_info
*cdi
)
869 int mrw
, mrw_write
, ram_write
;
873 if (!cdrom_is_mrw(cdi
, &mrw_write
))
876 if (CDROM_CAN(CDC_MO_DRIVE
))
879 (void) cdrom_is_random_writable(cdi
, &ram_write
);
882 cdi
->mask
&= ~CDC_MRW
;
884 cdi
->mask
|= CDC_MRW
;
887 cdi
->mask
&= ~CDC_MRW_W
;
889 cdi
->mask
|= CDC_MRW_W
;
892 cdi
->mask
&= ~CDC_RAM
;
894 cdi
->mask
|= CDC_RAM
;
896 if (CDROM_CAN(CDC_MRW_W
))
897 ret
= cdrom_mrw_open_write(cdi
);
898 else if (CDROM_CAN(CDC_DVD_RAM
))
899 ret
= cdrom_dvdram_open_write(cdi
);
900 else if (CDROM_CAN(CDC_RAM
) &&
901 !CDROM_CAN(CDC_CD_R
|CDC_CD_RW
|CDC_DVD
|CDC_DVD_R
|CDC_MRW
|CDC_MO_DRIVE
))
902 ret
= cdrom_ram_open_write(cdi
);
903 else if (CDROM_CAN(CDC_MO_DRIVE
))
904 ret
= mo_open_write(cdi
);
905 else if (!cdrom_is_dvd_rw(cdi
))
911 static void cdrom_dvd_rw_close_write(struct cdrom_device_info
*cdi
)
913 struct packet_command cgc
;
915 if (cdi
->mmc3_profile
!= 0x1a) {
916 cd_dbg(CD_CLOSE
, "%s: No DVD+RW\n", cdi
->name
);
920 if (!cdi
->media_written
) {
921 cd_dbg(CD_CLOSE
, "%s: DVD+RW media clean\n", cdi
->name
);
925 pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi
->name
);
927 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
928 cgc
.cmd
[0] = GPCMD_FLUSH_CACHE
;
930 cdi
->ops
->generic_packet(cdi
, &cgc
);
932 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
933 cgc
.cmd
[0] = GPCMD_CLOSE_TRACK
;
934 cgc
.timeout
= 3000*HZ
;
936 cdi
->ops
->generic_packet(cdi
, &cgc
);
938 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
939 cgc
.cmd
[0] = GPCMD_CLOSE_TRACK
;
940 cgc
.cmd
[2] = 2; /* Close session */
942 cgc
.timeout
= 3000*HZ
;
943 cdi
->ops
->generic_packet(cdi
, &cgc
);
945 cdi
->media_written
= 0;
948 static int cdrom_close_write(struct cdrom_device_info
*cdi
)
951 return cdrom_flush_cache(cdi
);
958 int open_for_data(struct cdrom_device_info
*cdi
)
961 struct cdrom_device_ops
*cdo
= cdi
->ops
;
963 cd_dbg(CD_OPEN
, "entering open_for_data\n");
964 /* Check if the driver can report drive status. If it can, we
965 can do clever things. If it can't, well, we at least tried! */
966 if (cdo
->drive_status
!= NULL
) {
967 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
968 cd_dbg(CD_OPEN
, "drive_status=%d\n", ret
);
969 if (ret
== CDS_TRAY_OPEN
) {
970 cd_dbg(CD_OPEN
, "the tray is open...\n");
971 /* can/may i close it? */
972 if (CDROM_CAN(CDC_CLOSE_TRAY
) &&
973 cdi
->options
& CDO_AUTO_CLOSE
) {
974 cd_dbg(CD_OPEN
, "trying to close the tray\n");
975 ret
=cdo
->tray_move(cdi
,0);
977 cd_dbg(CD_OPEN
, "bummer. tried to close the tray but failed.\n");
978 /* Ignore the error from the low
979 level driver. We don't care why it
980 couldn't close the tray. We only care
981 that there is no disc in the drive,
982 since that is the _REAL_ problem here.*/
984 goto clean_up_and_return
;
987 cd_dbg(CD_OPEN
, "bummer. this drive can't close the tray.\n");
989 goto clean_up_and_return
;
991 /* Ok, the door should be closed now.. Check again */
992 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
993 if ((ret
== CDS_NO_DISC
) || (ret
==CDS_TRAY_OPEN
)) {
994 cd_dbg(CD_OPEN
, "bummer. the tray is still not closed.\n");
995 cd_dbg(CD_OPEN
, "tray might not contain a medium\n");
997 goto clean_up_and_return
;
999 cd_dbg(CD_OPEN
, "the tray is now closed\n");
1001 /* the door should be closed now, check for the disc */
1002 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
1003 if (ret
!=CDS_DISC_OK
) {
1005 goto clean_up_and_return
;
1008 cdrom_count_tracks(cdi
, &tracks
);
1009 if (tracks
.error
== CDS_NO_DISC
) {
1010 cd_dbg(CD_OPEN
, "bummer. no disc.\n");
1012 goto clean_up_and_return
;
1014 /* CD-Players which don't use O_NONBLOCK, workman
1015 * for example, need bit CDO_CHECK_TYPE cleared! */
1016 if (tracks
.data
==0) {
1017 if (cdi
->options
& CDO_CHECK_TYPE
) {
1018 /* give people a warning shot, now that CDO_CHECK_TYPE
1019 is the default case! */
1020 cd_dbg(CD_OPEN
, "bummer. wrong media type.\n");
1021 cd_dbg(CD_WARNING
, "pid %d must open device O_NONBLOCK!\n",
1022 (unsigned int)task_pid_nr(current
));
1024 goto clean_up_and_return
;
1027 cd_dbg(CD_OPEN
, "wrong media type, but CDO_CHECK_TYPE not set\n");
1031 cd_dbg(CD_OPEN
, "all seems well, opening the devicen");
1033 /* all seems well, we can open the device */
1034 ret
= cdo
->open(cdi
, 0); /* open for data */
1035 cd_dbg(CD_OPEN
, "opening the device gave me %d\n", ret
);
1036 /* After all this careful checking, we shouldn't have problems
1037 opening the device, but we don't want the device locked if
1038 this somehow fails... */
1040 cd_dbg(CD_OPEN
, "open device failed\n");
1041 goto clean_up_and_return
;
1043 if (CDROM_CAN(CDC_LOCK
) && (cdi
->options
& CDO_LOCK
)) {
1044 cdo
->lock_door(cdi
, 1);
1045 cd_dbg(CD_OPEN
, "door locked\n");
1047 cd_dbg(CD_OPEN
, "device opened successfully\n");
1050 /* Something failed. Try to unlock the drive, because some drivers
1051 (notably ide-cd) lock the drive after every command. This produced
1052 a nasty bug where after mount failed, the drive would remain locked!
1053 This ensures that the drive gets unlocked after a mount fails. This
1054 is a goto to avoid bloating the driver with redundant code. */
1055 clean_up_and_return
:
1056 cd_dbg(CD_OPEN
, "open failed\n");
1057 if (CDROM_CAN(CDC_LOCK
) && cdi
->options
& CDO_LOCK
) {
1058 cdo
->lock_door(cdi
, 0);
1059 cd_dbg(CD_OPEN
, "door unlocked\n");
1064 /* We use the open-option O_NONBLOCK to indicate that the
1065 * purpose of opening is only for subsequent ioctl() calls; no device
1066 * integrity checks are performed.
1068 * We hope that all cd-player programs will adopt this convention. It
1069 * is in their own interest: device control becomes a lot easier
1072 int cdrom_open(struct cdrom_device_info
*cdi
, struct block_device
*bdev
,
1077 cd_dbg(CD_OPEN
, "entering cdrom_open\n");
1079 /* open is event synchronization point, check events first */
1080 check_disk_change(bdev
);
1082 /* if this was a O_NONBLOCK open and we should honor the flags,
1083 * do a quick open without drive/disc integrity checks. */
1085 if ((mode
& FMODE_NDELAY
) && (cdi
->options
& CDO_USE_FFLAGS
)) {
1086 ret
= cdi
->ops
->open(cdi
, 1);
1088 ret
= open_for_data(cdi
);
1091 cdrom_mmc3_profile(cdi
);
1092 if (mode
& FMODE_WRITE
) {
1094 if (cdrom_open_write(cdi
))
1096 if (!CDROM_CAN(CDC_RAM
))
1099 cdi
->media_written
= 0;
1106 cd_dbg(CD_OPEN
, "Use count for \"/dev/%s\" now %d\n",
1107 cdi
->name
, cdi
->use_count
);
1110 if (CDROM_CAN(CDC_LOCK
) && cdi
->options
& CDO_LOCK
) {
1111 cdi
->ops
->lock_door(cdi
, 0);
1112 cd_dbg(CD_OPEN
, "door unlocked\n");
1114 cdi
->ops
->release(cdi
);
1120 /* This code is similar to that in open_for_data. The routine is called
1121 whenever an audio play operation is requested.
1123 static int check_for_audio_disc(struct cdrom_device_info
* cdi
,
1124 struct cdrom_device_ops
* cdo
)
1128 cd_dbg(CD_OPEN
, "entering check_for_audio_disc\n");
1129 if (!(cdi
->options
& CDO_CHECK_TYPE
))
1131 if (cdo
->drive_status
!= NULL
) {
1132 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
1133 cd_dbg(CD_OPEN
, "drive_status=%d\n", ret
);
1134 if (ret
== CDS_TRAY_OPEN
) {
1135 cd_dbg(CD_OPEN
, "the tray is open...\n");
1136 /* can/may i close it? */
1137 if (CDROM_CAN(CDC_CLOSE_TRAY
) &&
1138 cdi
->options
& CDO_AUTO_CLOSE
) {
1139 cd_dbg(CD_OPEN
, "trying to close the tray\n");
1140 ret
=cdo
->tray_move(cdi
,0);
1142 cd_dbg(CD_OPEN
, "bummer. tried to close tray but failed.\n");
1143 /* Ignore the error from the low
1144 level driver. We don't care why it
1145 couldn't close the tray. We only care
1146 that there is no disc in the drive,
1147 since that is the _REAL_ problem here.*/
1151 cd_dbg(CD_OPEN
, "bummer. this driver can't close the tray.\n");
1154 /* Ok, the door should be closed now.. Check again */
1155 ret
= cdo
->drive_status(cdi
, CDSL_CURRENT
);
1156 if ((ret
== CDS_NO_DISC
) || (ret
==CDS_TRAY_OPEN
)) {
1157 cd_dbg(CD_OPEN
, "bummer. the tray is still not closed.\n");
1160 if (ret
!=CDS_DISC_OK
) {
1161 cd_dbg(CD_OPEN
, "bummer. disc isn't ready.\n");
1164 cd_dbg(CD_OPEN
, "the tray is now closed\n");
1167 cdrom_count_tracks(cdi
, &tracks
);
1169 return(tracks
.error
);
1171 if (tracks
.audio
==0)
1172 return -EMEDIUMTYPE
;
1177 void cdrom_release(struct cdrom_device_info
*cdi
, fmode_t mode
)
1179 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1180 int opened_for_data
;
1182 cd_dbg(CD_CLOSE
, "entering cdrom_release\n");
1184 if (cdi
->use_count
> 0)
1187 if (cdi
->use_count
== 0) {
1188 cd_dbg(CD_CLOSE
, "Use count for \"/dev/%s\" now zero\n",
1190 cdrom_dvd_rw_close_write(cdi
);
1192 if ((cdo
->capability
& CDC_LOCK
) && !cdi
->keeplocked
) {
1193 cd_dbg(CD_CLOSE
, "Unlocking door!\n");
1194 cdo
->lock_door(cdi
, 0);
1198 opened_for_data
= !(cdi
->options
& CDO_USE_FFLAGS
) ||
1199 !(mode
& FMODE_NDELAY
);
1202 * flush cache on last write release
1204 if (CDROM_CAN(CDC_RAM
) && !cdi
->use_count
&& cdi
->for_data
)
1205 cdrom_close_write(cdi
);
1208 if (cdi
->use_count
== 0) { /* last process that closes dev*/
1209 if (opened_for_data
&&
1210 cdi
->options
& CDO_AUTO_EJECT
&& CDROM_CAN(CDC_OPEN_TRAY
))
1211 cdo
->tray_move(cdi
, 1);
1215 static int cdrom_read_mech_status(struct cdrom_device_info
*cdi
,
1216 struct cdrom_changer_info
*buf
)
1218 struct packet_command cgc
;
1219 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1223 * Sanyo changer isn't spec compliant (doesn't use regular change
1224 * LOAD_UNLOAD command, and it doesn't implement the mech status
1227 if (cdi
->sanyo_slot
) {
1228 buf
->hdr
.nslots
= 3;
1229 buf
->hdr
.curslot
= cdi
->sanyo_slot
== 3 ? 0 : cdi
->sanyo_slot
;
1230 for (length
= 0; length
< 3; length
++) {
1231 buf
->slots
[length
].disc_present
= 1;
1232 buf
->slots
[length
].change
= 0;
1237 length
= sizeof(struct cdrom_mechstat_header
) +
1238 cdi
->capacity
* sizeof(struct cdrom_slot
);
1240 init_cdrom_command(&cgc
, buf
, length
, CGC_DATA_READ
);
1241 cgc
.cmd
[0] = GPCMD_MECHANISM_STATUS
;
1242 cgc
.cmd
[8] = (length
>> 8) & 0xff;
1243 cgc
.cmd
[9] = length
& 0xff;
1244 return cdo
->generic_packet(cdi
, &cgc
);
1247 static int cdrom_slot_status(struct cdrom_device_info
*cdi
, int slot
)
1249 struct cdrom_changer_info
*info
;
1252 cd_dbg(CD_CHANGER
, "entering cdrom_slot_status()\n");
1253 if (cdi
->sanyo_slot
)
1256 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
1260 if ((ret
= cdrom_read_mech_status(cdi
, info
)))
1263 if (info
->slots
[slot
].disc_present
)
1273 /* Return the number of slots for an ATAPI/SCSI cdrom,
1274 * return 1 if not a changer.
1276 int cdrom_number_of_slots(struct cdrom_device_info
*cdi
)
1280 struct cdrom_changer_info
*info
;
1282 cd_dbg(CD_CHANGER
, "entering cdrom_number_of_slots()\n");
1283 /* cdrom_read_mech_status requires a valid value for capacity: */
1286 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
1290 if ((status
= cdrom_read_mech_status(cdi
, info
)) == 0)
1291 nslots
= info
->hdr
.nslots
;
1298 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1299 static int cdrom_load_unload(struct cdrom_device_info
*cdi
, int slot
)
1301 struct packet_command cgc
;
1303 cd_dbg(CD_CHANGER
, "entering cdrom_load_unload()\n");
1304 if (cdi
->sanyo_slot
&& slot
< 0)
1307 init_cdrom_command(&cgc
, NULL
, 0, CGC_DATA_NONE
);
1308 cgc
.cmd
[0] = GPCMD_LOAD_UNLOAD
;
1309 cgc
.cmd
[4] = 2 + (slot
>= 0);
1311 cgc
.timeout
= 60 * HZ
;
1313 /* The Sanyo 3 CD changer uses byte 7 of the
1314 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1315 using the GPCMD_LOAD_UNLOAD opcode. */
1316 if (cdi
->sanyo_slot
&& -1 < slot
) {
1317 cgc
.cmd
[0] = GPCMD_TEST_UNIT_READY
;
1319 cgc
.cmd
[4] = cgc
.cmd
[8] = 0;
1320 cdi
->sanyo_slot
= slot
? slot
: 3;
1323 return cdi
->ops
->generic_packet(cdi
, &cgc
);
1326 static int cdrom_select_disc(struct cdrom_device_info
*cdi
, int slot
)
1328 struct cdrom_changer_info
*info
;
1332 cd_dbg(CD_CHANGER
, "entering cdrom_select_disc()\n");
1333 if (!CDROM_CAN(CDC_SELECT_DISC
))
1334 return -EDRIVE_CANT_DO_THIS
;
1336 if (cdi
->ops
->check_events
)
1337 cdi
->ops
->check_events(cdi
, 0, slot
);
1339 cdi
->ops
->media_changed(cdi
, slot
);
1341 if (slot
== CDSL_NONE
) {
1342 /* set media changed bits, on both queues */
1343 cdi
->mc_flags
= 0x3;
1344 return cdrom_load_unload(cdi
, -1);
1347 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
1351 if ((ret
= cdrom_read_mech_status(cdi
, info
))) {
1356 curslot
= info
->hdr
.curslot
;
1359 if (cdi
->use_count
> 1 || cdi
->keeplocked
) {
1360 if (slot
== CDSL_CURRENT
) {
1367 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1368 which is useful if it had been previously unloaded.
1369 Whether it can or not, it returns the current slot.
1370 Similarly, if slot happens to be the current one, we still
1372 if (slot
== CDSL_CURRENT
)
1375 /* set media changed bits on both queues */
1376 cdi
->mc_flags
= 0x3;
1377 if ((ret
= cdrom_load_unload(cdi
, slot
)))
1384 * As cdrom implements an extra ioctl consumer for media changed
1385 * event, it needs to buffer ->check_events() output, such that event
1386 * is not lost for both the usual VFS and ioctl paths.
1387 * cdi->{vfs|ioctl}_events are used to buffer pending events for each
1390 * XXX: Locking is non-existent. cdi->ops->check_events() can be
1391 * called in parallel and buffering fields are accessed without any
1392 * exclusion. The original media_changed code had the same problem.
1393 * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1394 * and remove this cruft altogether. It doesn't have much usefulness
1397 static void cdrom_update_events(struct cdrom_device_info
*cdi
,
1398 unsigned int clearing
)
1400 unsigned int events
;
1402 events
= cdi
->ops
->check_events(cdi
, clearing
, CDSL_CURRENT
);
1403 cdi
->vfs_events
|= events
;
1404 cdi
->ioctl_events
|= events
;
1407 unsigned int cdrom_check_events(struct cdrom_device_info
*cdi
,
1408 unsigned int clearing
)
1410 unsigned int events
;
1412 cdrom_update_events(cdi
, clearing
);
1413 events
= cdi
->vfs_events
;
1414 cdi
->vfs_events
= 0;
1417 EXPORT_SYMBOL(cdrom_check_events
);
1419 /* We want to make media_changed accessible to the user through an
1420 * ioctl. The main problem now is that we must double-buffer the
1421 * low-level implementation, to assure that the VFS and the user both
1422 * see a medium change once.
1426 int media_changed(struct cdrom_device_info
*cdi
, int queue
)
1428 unsigned int mask
= (1 << (queue
& 1));
1429 int ret
= !!(cdi
->mc_flags
& mask
);
1432 if (!CDROM_CAN(CDC_MEDIA_CHANGED
))
1435 /* changed since last call? */
1436 if (cdi
->ops
->check_events
) {
1437 BUG_ON(!queue
); /* shouldn't be called from VFS path */
1438 cdrom_update_events(cdi
, DISK_EVENT_MEDIA_CHANGE
);
1439 changed
= cdi
->ioctl_events
& DISK_EVENT_MEDIA_CHANGE
;
1440 cdi
->ioctl_events
= 0;
1442 changed
= cdi
->ops
->media_changed(cdi
, CDSL_CURRENT
);
1445 cdi
->mc_flags
= 0x3; /* set bit on both queues */
1447 cdi
->media_written
= 0;
1450 cdi
->mc_flags
&= ~mask
; /* clear bit */
1454 int cdrom_media_changed(struct cdrom_device_info
*cdi
)
1456 /* This talks to the VFS, which doesn't like errors - just 1 or 0.
1457 * Returning "0" is always safe (media hasn't been changed). Do that
1458 * if the low-level cdrom driver dosn't support media changed. */
1459 if (cdi
== NULL
|| cdi
->ops
->media_changed
== NULL
)
1461 if (!CDROM_CAN(CDC_MEDIA_CHANGED
))
1463 return media_changed(cdi
, 0);
1466 /* badly broken, I know. Is due for a fixup anytime. */
1467 static void cdrom_count_tracks(struct cdrom_device_info
*cdi
, tracktype
* tracks
)
1469 struct cdrom_tochdr header
;
1470 struct cdrom_tocentry entry
;
1477 cd_dbg(CD_COUNT_TRACKS
, "entering cdrom_count_tracks\n");
1478 /* Grab the TOC header so we can see how many tracks there are */
1479 if ((ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCHDR
, &header
))) {
1480 if (ret
== -ENOMEDIUM
)
1481 tracks
->error
= CDS_NO_DISC
;
1483 tracks
->error
= CDS_NO_INFO
;
1486 /* check what type of tracks are on this disc */
1487 entry
.cdte_format
= CDROM_MSF
;
1488 for (i
= header
.cdth_trk0
; i
<= header
.cdth_trk1
; i
++) {
1489 entry
.cdte_track
= i
;
1490 if (cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCENTRY
, &entry
)) {
1491 tracks
->error
=CDS_NO_INFO
;
1494 if (entry
.cdte_ctrl
& CDROM_DATA_TRACK
) {
1495 if (entry
.cdte_format
== 0x10)
1497 else if (entry
.cdte_format
== 0x20)
1503 cd_dbg(CD_COUNT_TRACKS
, "track %d: format=%d, ctrl=%d\n",
1504 i
, entry
.cdte_format
, entry
.cdte_ctrl
);
1506 cd_dbg(CD_COUNT_TRACKS
, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1507 header
.cdth_trk1
, tracks
->audio
, tracks
->data
,
1508 tracks
->cdi
, tracks
->xa
);
1511 /* Requests to the low-level drivers will /always/ be done in the
1512 following format convention:
1514 CDROM_LBA: all data-related requests.
1515 CDROM_MSF: all audio-related requests.
1517 However, a low-level implementation is allowed to refuse this
1518 request, and return information in its own favorite format.
1520 It doesn't make sense /at all/ to ask for a play_audio in LBA
1521 format, or ask for multi-session info in MSF format. However, for
1522 backward compatibility these format requests will be satisfied, but
1523 the requests to the low-level drivers will be sanitized in the more
1524 meaningful format indicated above.
1528 void sanitize_format(union cdrom_addr
*addr
,
1529 u_char
* curr
, u_char requested
)
1531 if (*curr
== requested
)
1532 return; /* nothing to be done! */
1533 if (requested
== CDROM_LBA
) {
1534 addr
->lba
= (int) addr
->msf
.frame
+
1535 75 * (addr
->msf
.second
- 2 + 60 * addr
->msf
.minute
);
1536 } else { /* CDROM_MSF */
1537 int lba
= addr
->lba
;
1538 addr
->msf
.frame
= lba
% 75;
1541 addr
->msf
.second
= lba
% 60;
1542 addr
->msf
.minute
= lba
/ 60;
1547 void init_cdrom_command(struct packet_command
*cgc
, void *buf
, int len
,
1550 memset(cgc
, 0, sizeof(struct packet_command
));
1552 memset(buf
, 0, len
);
1553 cgc
->buffer
= (char *) buf
;
1555 cgc
->data_direction
= type
;
1556 cgc
->timeout
= CDROM_DEF_TIMEOUT
;
1561 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1562 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1564 static void setup_report_key(struct packet_command
*cgc
, unsigned agid
, unsigned type
)
1566 cgc
->cmd
[0] = GPCMD_REPORT_KEY
;
1567 cgc
->cmd
[10] = type
| (agid
<< 6);
1569 case 0: case 8: case 5: {
1582 cgc
->cmd
[9] = cgc
->buflen
;
1583 cgc
->data_direction
= CGC_DATA_READ
;
1586 static void setup_send_key(struct packet_command
*cgc
, unsigned agid
, unsigned type
)
1588 cgc
->cmd
[0] = GPCMD_SEND_KEY
;
1589 cgc
->cmd
[10] = type
| (agid
<< 6);
1604 cgc
->cmd
[9] = cgc
->buflen
;
1605 cgc
->data_direction
= CGC_DATA_WRITE
;
1608 static int dvd_do_auth(struct cdrom_device_info
*cdi
, dvd_authinfo
*ai
)
1612 struct packet_command cgc
;
1613 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1614 rpc_state_t rpc_state
;
1616 memset(buf
, 0, sizeof(buf
));
1617 init_cdrom_command(&cgc
, buf
, 0, CGC_DATA_READ
);
1621 case DVD_LU_SEND_AGID
:
1622 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_AGID\n");
1624 setup_report_key(&cgc
, ai
->lsa
.agid
, 0);
1626 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1629 ai
->lsa
.agid
= buf
[7] >> 6;
1630 /* Returning data, let host change state */
1633 case DVD_LU_SEND_KEY1
:
1634 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_KEY1\n");
1635 setup_report_key(&cgc
, ai
->lsk
.agid
, 2);
1637 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1640 copy_key(ai
->lsk
.key
, &buf
[4]);
1641 /* Returning data, let host change state */
1644 case DVD_LU_SEND_CHALLENGE
:
1645 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_CHALLENGE\n");
1646 setup_report_key(&cgc
, ai
->lsc
.agid
, 1);
1648 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1651 copy_chal(ai
->lsc
.chal
, &buf
[4]);
1652 /* Returning data, let host change state */
1656 case DVD_LU_SEND_TITLE_KEY
:
1657 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_TITLE_KEY\n");
1659 setup_report_key(&cgc
, ai
->lstk
.agid
, 4);
1660 cgc
.cmd
[5] = ai
->lstk
.lba
;
1661 cgc
.cmd
[4] = ai
->lstk
.lba
>> 8;
1662 cgc
.cmd
[3] = ai
->lstk
.lba
>> 16;
1663 cgc
.cmd
[2] = ai
->lstk
.lba
>> 24;
1665 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1668 ai
->lstk
.cpm
= (buf
[4] >> 7) & 1;
1669 ai
->lstk
.cp_sec
= (buf
[4] >> 6) & 1;
1670 ai
->lstk
.cgms
= (buf
[4] >> 4) & 3;
1671 copy_key(ai
->lstk
.title_key
, &buf
[5]);
1672 /* Returning data, let host change state */
1675 case DVD_LU_SEND_ASF
:
1676 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_ASF\n");
1677 setup_report_key(&cgc
, ai
->lsasf
.agid
, 5);
1679 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1682 ai
->lsasf
.asf
= buf
[7] & 1;
1685 /* LU data receive (LU changes state) */
1686 case DVD_HOST_SEND_CHALLENGE
:
1687 cd_dbg(CD_DVD
, "entering DVD_HOST_SEND_CHALLENGE\n");
1688 setup_send_key(&cgc
, ai
->hsc
.agid
, 1);
1690 copy_chal(&buf
[4], ai
->hsc
.chal
);
1692 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1695 ai
->type
= DVD_LU_SEND_KEY1
;
1698 case DVD_HOST_SEND_KEY2
:
1699 cd_dbg(CD_DVD
, "entering DVD_HOST_SEND_KEY2\n");
1700 setup_send_key(&cgc
, ai
->hsk
.agid
, 3);
1702 copy_key(&buf
[4], ai
->hsk
.key
);
1704 if ((ret
= cdo
->generic_packet(cdi
, &cgc
))) {
1705 ai
->type
= DVD_AUTH_FAILURE
;
1708 ai
->type
= DVD_AUTH_ESTABLISHED
;
1712 case DVD_INVALIDATE_AGID
:
1714 cd_dbg(CD_DVD
, "entering DVD_INVALIDATE_AGID\n");
1715 setup_report_key(&cgc
, ai
->lsa
.agid
, 0x3f);
1716 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1720 /* Get region settings */
1721 case DVD_LU_SEND_RPC_STATE
:
1722 cd_dbg(CD_DVD
, "entering DVD_LU_SEND_RPC_STATE\n");
1723 setup_report_key(&cgc
, 0, 8);
1724 memset(&rpc_state
, 0, sizeof(rpc_state_t
));
1725 cgc
.buffer
= (char *) &rpc_state
;
1727 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1730 ai
->lrpcs
.type
= rpc_state
.type_code
;
1731 ai
->lrpcs
.vra
= rpc_state
.vra
;
1732 ai
->lrpcs
.ucca
= rpc_state
.ucca
;
1733 ai
->lrpcs
.region_mask
= rpc_state
.region_mask
;
1734 ai
->lrpcs
.rpc_scheme
= rpc_state
.rpc_scheme
;
1737 /* Set region settings */
1738 case DVD_HOST_SEND_RPC_STATE
:
1739 cd_dbg(CD_DVD
, "entering DVD_HOST_SEND_RPC_STATE\n");
1740 setup_send_key(&cgc
, 0, 6);
1742 buf
[4] = ai
->hrpcs
.pdrc
;
1744 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
1749 cd_dbg(CD_WARNING
, "Invalid DVD key ioctl (%d)\n", ai
->type
);
1756 static int dvd_read_physical(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1757 struct packet_command
*cgc
)
1759 unsigned char buf
[21], *base
;
1760 struct dvd_layer
*layer
;
1761 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1762 int ret
, layer_num
= s
->physical
.layer_num
;
1764 if (layer_num
>= DVD_LAYERS
)
1767 init_cdrom_command(cgc
, buf
, sizeof(buf
), CGC_DATA_READ
);
1768 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1769 cgc
->cmd
[6] = layer_num
;
1770 cgc
->cmd
[7] = s
->type
;
1771 cgc
->cmd
[9] = cgc
->buflen
& 0xff;
1774 * refrain from reporting errors on non-existing layers (mainly)
1778 ret
= cdo
->generic_packet(cdi
, cgc
);
1783 layer
= &s
->physical
.layer
[layer_num
];
1786 * place the data... really ugly, but at least we won't have to
1787 * worry about endianess in userspace.
1789 memset(layer
, 0, sizeof(*layer
));
1790 layer
->book_version
= base
[0] & 0xf;
1791 layer
->book_type
= base
[0] >> 4;
1792 layer
->min_rate
= base
[1] & 0xf;
1793 layer
->disc_size
= base
[1] >> 4;
1794 layer
->layer_type
= base
[2] & 0xf;
1795 layer
->track_path
= (base
[2] >> 4) & 1;
1796 layer
->nlayers
= (base
[2] >> 5) & 3;
1797 layer
->track_density
= base
[3] & 0xf;
1798 layer
->linear_density
= base
[3] >> 4;
1799 layer
->start_sector
= base
[5] << 16 | base
[6] << 8 | base
[7];
1800 layer
->end_sector
= base
[9] << 16 | base
[10] << 8 | base
[11];
1801 layer
->end_sector_l0
= base
[13] << 16 | base
[14] << 8 | base
[15];
1802 layer
->bca
= base
[16] >> 7;
1807 static int dvd_read_copyright(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1808 struct packet_command
*cgc
)
1812 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1814 init_cdrom_command(cgc
, buf
, sizeof(buf
), CGC_DATA_READ
);
1815 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1816 cgc
->cmd
[6] = s
->copyright
.layer_num
;
1817 cgc
->cmd
[7] = s
->type
;
1818 cgc
->cmd
[8] = cgc
->buflen
>> 8;
1819 cgc
->cmd
[9] = cgc
->buflen
& 0xff;
1821 ret
= cdo
->generic_packet(cdi
, cgc
);
1825 s
->copyright
.cpst
= buf
[4];
1826 s
->copyright
.rmi
= buf
[5];
1831 static int dvd_read_disckey(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1832 struct packet_command
*cgc
)
1836 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1838 size
= sizeof(s
->disckey
.value
) + 4;
1840 buf
= kmalloc(size
, GFP_KERNEL
);
1844 init_cdrom_command(cgc
, buf
, size
, CGC_DATA_READ
);
1845 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1846 cgc
->cmd
[7] = s
->type
;
1847 cgc
->cmd
[8] = size
>> 8;
1848 cgc
->cmd
[9] = size
& 0xff;
1849 cgc
->cmd
[10] = s
->disckey
.agid
<< 6;
1851 ret
= cdo
->generic_packet(cdi
, cgc
);
1853 memcpy(s
->disckey
.value
, &buf
[4], sizeof(s
->disckey
.value
));
1859 static int dvd_read_bca(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1860 struct packet_command
*cgc
)
1862 int ret
, size
= 4 + 188;
1864 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1866 buf
= kmalloc(size
, GFP_KERNEL
);
1870 init_cdrom_command(cgc
, buf
, size
, CGC_DATA_READ
);
1871 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1872 cgc
->cmd
[7] = s
->type
;
1873 cgc
->cmd
[9] = cgc
->buflen
& 0xff;
1875 ret
= cdo
->generic_packet(cdi
, cgc
);
1879 s
->bca
.len
= buf
[0] << 8 | buf
[1];
1880 if (s
->bca
.len
< 12 || s
->bca
.len
> 188) {
1881 cd_dbg(CD_WARNING
, "Received invalid BCA length (%d)\n",
1886 memcpy(s
->bca
.value
, &buf
[4], s
->bca
.len
);
1893 static int dvd_read_manufact(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1894 struct packet_command
*cgc
)
1898 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1900 size
= sizeof(s
->manufact
.value
) + 4;
1902 buf
= kmalloc(size
, GFP_KERNEL
);
1906 init_cdrom_command(cgc
, buf
, size
, CGC_DATA_READ
);
1907 cgc
->cmd
[0] = GPCMD_READ_DVD_STRUCTURE
;
1908 cgc
->cmd
[7] = s
->type
;
1909 cgc
->cmd
[8] = size
>> 8;
1910 cgc
->cmd
[9] = size
& 0xff;
1912 ret
= cdo
->generic_packet(cdi
, cgc
);
1916 s
->manufact
.len
= buf
[0] << 8 | buf
[1];
1917 if (s
->manufact
.len
< 0) {
1918 cd_dbg(CD_WARNING
, "Received invalid manufacture info length (%d)\n",
1922 if (s
->manufact
.len
> 2048) {
1923 cd_dbg(CD_WARNING
, "Received invalid manufacture info length (%d): truncating to 2048\n",
1925 s
->manufact
.len
= 2048;
1927 memcpy(s
->manufact
.value
, &buf
[4], s
->manufact
.len
);
1935 static int dvd_read_struct(struct cdrom_device_info
*cdi
, dvd_struct
*s
,
1936 struct packet_command
*cgc
)
1939 case DVD_STRUCT_PHYSICAL
:
1940 return dvd_read_physical(cdi
, s
, cgc
);
1942 case DVD_STRUCT_COPYRIGHT
:
1943 return dvd_read_copyright(cdi
, s
, cgc
);
1945 case DVD_STRUCT_DISCKEY
:
1946 return dvd_read_disckey(cdi
, s
, cgc
);
1948 case DVD_STRUCT_BCA
:
1949 return dvd_read_bca(cdi
, s
, cgc
);
1951 case DVD_STRUCT_MANUFACT
:
1952 return dvd_read_manufact(cdi
, s
, cgc
);
1955 cd_dbg(CD_WARNING
, ": Invalid DVD structure read requested (%d)\n",
1961 int cdrom_mode_sense(struct cdrom_device_info
*cdi
,
1962 struct packet_command
*cgc
,
1963 int page_code
, int page_control
)
1965 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1967 memset(cgc
->cmd
, 0, sizeof(cgc
->cmd
));
1969 cgc
->cmd
[0] = GPCMD_MODE_SENSE_10
;
1970 cgc
->cmd
[2] = page_code
| (page_control
<< 6);
1971 cgc
->cmd
[7] = cgc
->buflen
>> 8;
1972 cgc
->cmd
[8] = cgc
->buflen
& 0xff;
1973 cgc
->data_direction
= CGC_DATA_READ
;
1974 return cdo
->generic_packet(cdi
, cgc
);
1977 int cdrom_mode_select(struct cdrom_device_info
*cdi
,
1978 struct packet_command
*cgc
)
1980 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1982 memset(cgc
->cmd
, 0, sizeof(cgc
->cmd
));
1983 memset(cgc
->buffer
, 0, 2);
1984 cgc
->cmd
[0] = GPCMD_MODE_SELECT_10
;
1985 cgc
->cmd
[1] = 0x10; /* PF */
1986 cgc
->cmd
[7] = cgc
->buflen
>> 8;
1987 cgc
->cmd
[8] = cgc
->buflen
& 0xff;
1988 cgc
->data_direction
= CGC_DATA_WRITE
;
1989 return cdo
->generic_packet(cdi
, cgc
);
1992 static int cdrom_read_subchannel(struct cdrom_device_info
*cdi
,
1993 struct cdrom_subchnl
*subchnl
, int mcn
)
1995 struct cdrom_device_ops
*cdo
= cdi
->ops
;
1996 struct packet_command cgc
;
2000 init_cdrom_command(&cgc
, buffer
, 16, CGC_DATA_READ
);
2001 cgc
.cmd
[0] = GPCMD_READ_SUBCHANNEL
;
2002 cgc
.cmd
[1] = 2; /* MSF addressing */
2003 cgc
.cmd
[2] = 0x40; /* request subQ data */
2004 cgc
.cmd
[3] = mcn
? 2 : 1;
2007 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
2010 subchnl
->cdsc_audiostatus
= cgc
.buffer
[1];
2011 subchnl
->cdsc_format
= CDROM_MSF
;
2012 subchnl
->cdsc_ctrl
= cgc
.buffer
[5] & 0xf;
2013 subchnl
->cdsc_trk
= cgc
.buffer
[6];
2014 subchnl
->cdsc_ind
= cgc
.buffer
[7];
2016 subchnl
->cdsc_reladdr
.msf
.minute
= cgc
.buffer
[13];
2017 subchnl
->cdsc_reladdr
.msf
.second
= cgc
.buffer
[14];
2018 subchnl
->cdsc_reladdr
.msf
.frame
= cgc
.buffer
[15];
2019 subchnl
->cdsc_absaddr
.msf
.minute
= cgc
.buffer
[9];
2020 subchnl
->cdsc_absaddr
.msf
.second
= cgc
.buffer
[10];
2021 subchnl
->cdsc_absaddr
.msf
.frame
= cgc
.buffer
[11];
2027 * Specific READ_10 interface
2029 static int cdrom_read_cd(struct cdrom_device_info
*cdi
,
2030 struct packet_command
*cgc
, int lba
,
2031 int blocksize
, int nblocks
)
2033 struct cdrom_device_ops
*cdo
= cdi
->ops
;
2035 memset(&cgc
->cmd
, 0, sizeof(cgc
->cmd
));
2036 cgc
->cmd
[0] = GPCMD_READ_10
;
2037 cgc
->cmd
[2] = (lba
>> 24) & 0xff;
2038 cgc
->cmd
[3] = (lba
>> 16) & 0xff;
2039 cgc
->cmd
[4] = (lba
>> 8) & 0xff;
2040 cgc
->cmd
[5] = lba
& 0xff;
2041 cgc
->cmd
[6] = (nblocks
>> 16) & 0xff;
2042 cgc
->cmd
[7] = (nblocks
>> 8) & 0xff;
2043 cgc
->cmd
[8] = nblocks
& 0xff;
2044 cgc
->buflen
= blocksize
* nblocks
;
2045 return cdo
->generic_packet(cdi
, cgc
);
2048 /* very generic interface for reading the various types of blocks */
2049 static int cdrom_read_block(struct cdrom_device_info
*cdi
,
2050 struct packet_command
*cgc
,
2051 int lba
, int nblocks
, int format
, int blksize
)
2053 struct cdrom_device_ops
*cdo
= cdi
->ops
;
2055 memset(&cgc
->cmd
, 0, sizeof(cgc
->cmd
));
2056 cgc
->cmd
[0] = GPCMD_READ_CD
;
2057 /* expected sector size - cdda,mode1,etc. */
2058 cgc
->cmd
[1] = format
<< 2;
2059 /* starting address */
2060 cgc
->cmd
[2] = (lba
>> 24) & 0xff;
2061 cgc
->cmd
[3] = (lba
>> 16) & 0xff;
2062 cgc
->cmd
[4] = (lba
>> 8) & 0xff;
2063 cgc
->cmd
[5] = lba
& 0xff;
2064 /* number of blocks */
2065 cgc
->cmd
[6] = (nblocks
>> 16) & 0xff;
2066 cgc
->cmd
[7] = (nblocks
>> 8) & 0xff;
2067 cgc
->cmd
[8] = nblocks
& 0xff;
2068 cgc
->buflen
= blksize
* nblocks
;
2070 /* set the header info returned */
2072 case CD_FRAMESIZE_RAW0
: cgc
->cmd
[9] = 0x58; break;
2073 case CD_FRAMESIZE_RAW1
: cgc
->cmd
[9] = 0x78; break;
2074 case CD_FRAMESIZE_RAW
: cgc
->cmd
[9] = 0xf8; break;
2075 default : cgc
->cmd
[9] = 0x10;
2078 return cdo
->generic_packet(cdi
, cgc
);
2081 static int cdrom_read_cdda_old(struct cdrom_device_info
*cdi
, __u8 __user
*ubuf
,
2082 int lba
, int nframes
)
2084 struct packet_command cgc
;
2088 cdi
->last_sense
= 0;
2090 memset(&cgc
, 0, sizeof(cgc
));
2093 * start with will ra.nframes size, back down if alloc fails
2097 cgc
.buffer
= kmalloc(CD_FRAMESIZE_RAW
* nr
, GFP_KERNEL
);
2107 cgc
.data_direction
= CGC_DATA_READ
;
2108 while (nframes
> 0) {
2112 ret
= cdrom_read_block(cdi
, &cgc
, lba
, nr
, 1, CD_FRAMESIZE_RAW
);
2115 if (copy_to_user(ubuf
, cgc
.buffer
, CD_FRAMESIZE_RAW
* nr
)) {
2119 ubuf
+= CD_FRAMESIZE_RAW
* nr
;
2127 static int cdrom_read_cdda_bpc(struct cdrom_device_info
*cdi
, __u8 __user
*ubuf
,
2128 int lba
, int nframes
)
2130 struct request_queue
*q
= cdi
->disk
->queue
;
2139 cdi
->last_sense
= 0;
2143 if (cdi
->cdda_method
== CDDA_BPC_SINGLE
)
2145 if (nr
* CD_FRAMESIZE_RAW
> (queue_max_sectors(q
) << 9))
2146 nr
= (queue_max_sectors(q
) << 9) / CD_FRAMESIZE_RAW
;
2148 len
= nr
* CD_FRAMESIZE_RAW
;
2150 rq
= blk_get_request(q
, READ
, GFP_KERNEL
);
2156 ret
= blk_rq_map_user(q
, rq
, NULL
, ubuf
, len
, GFP_KERNEL
);
2158 blk_put_request(rq
);
2162 rq
->cmd
[0] = GPCMD_READ_CD
;
2163 rq
->cmd
[1] = 1 << 2;
2164 rq
->cmd
[2] = (lba
>> 24) & 0xff;
2165 rq
->cmd
[3] = (lba
>> 16) & 0xff;
2166 rq
->cmd
[4] = (lba
>> 8) & 0xff;
2167 rq
->cmd
[5] = lba
& 0xff;
2168 rq
->cmd
[6] = (nr
>> 16) & 0xff;
2169 rq
->cmd
[7] = (nr
>> 8) & 0xff;
2170 rq
->cmd
[8] = nr
& 0xff;
2174 rq
->cmd_type
= REQ_TYPE_BLOCK_PC
;
2175 rq
->timeout
= 60 * HZ
;
2178 if (blk_execute_rq(q
, cdi
->disk
, rq
, 0)) {
2179 struct request_sense
*s
= rq
->sense
;
2181 cdi
->last_sense
= s
->sense_key
;
2184 if (blk_rq_unmap_user(bio
))
2186 blk_put_request(rq
);
2199 static int cdrom_read_cdda(struct cdrom_device_info
*cdi
, __u8 __user
*ubuf
,
2200 int lba
, int nframes
)
2204 if (cdi
->cdda_method
== CDDA_OLD
)
2205 return cdrom_read_cdda_old(cdi
, ubuf
, lba
, nframes
);
2209 * for anything else than success and io error, we need to retry
2211 ret
= cdrom_read_cdda_bpc(cdi
, ubuf
, lba
, nframes
);
2212 if (!ret
|| ret
!= -EIO
)
2216 * I've seen drives get sense 4/8/3 udma crc errors on multi
2217 * frame dma, so drop to single frame dma if we need to
2219 if (cdi
->cdda_method
== CDDA_BPC_FULL
&& nframes
> 1) {
2220 pr_info("dropping to single frame dma\n");
2221 cdi
->cdda_method
= CDDA_BPC_SINGLE
;
2226 * so we have an io error of some sort with multi frame dma. if the
2227 * condition wasn't a hardware error
2228 * problems, not for any error
2230 if (cdi
->last_sense
!= 0x04 && cdi
->last_sense
!= 0x0b)
2233 pr_info("dropping to old style cdda (sense=%x)\n", cdi
->last_sense
);
2234 cdi
->cdda_method
= CDDA_OLD
;
2235 return cdrom_read_cdda_old(cdi
, ubuf
, lba
, nframes
);
2238 static int cdrom_ioctl_multisession(struct cdrom_device_info
*cdi
,
2241 struct cdrom_multisession ms_info
;
2242 u8 requested_format
;
2245 cd_dbg(CD_DO_IOCTL
, "entering CDROMMULTISESSION\n");
2247 if (!(cdi
->ops
->capability
& CDC_MULTI_SESSION
))
2250 if (copy_from_user(&ms_info
, argp
, sizeof(ms_info
)))
2253 requested_format
= ms_info
.addr_format
;
2254 if (requested_format
!= CDROM_MSF
&& requested_format
!= CDROM_LBA
)
2256 ms_info
.addr_format
= CDROM_LBA
;
2258 ret
= cdi
->ops
->get_last_session(cdi
, &ms_info
);
2262 sanitize_format(&ms_info
.addr
, &ms_info
.addr_format
, requested_format
);
2264 if (copy_to_user(argp
, &ms_info
, sizeof(ms_info
)))
2267 cd_dbg(CD_DO_IOCTL
, "CDROMMULTISESSION successful\n");
2271 static int cdrom_ioctl_eject(struct cdrom_device_info
*cdi
)
2273 cd_dbg(CD_DO_IOCTL
, "entering CDROMEJECT\n");
2275 if (!CDROM_CAN(CDC_OPEN_TRAY
))
2277 if (cdi
->use_count
!= 1 || cdi
->keeplocked
)
2279 if (CDROM_CAN(CDC_LOCK
)) {
2280 int ret
= cdi
->ops
->lock_door(cdi
, 0);
2285 return cdi
->ops
->tray_move(cdi
, 1);
2288 static int cdrom_ioctl_closetray(struct cdrom_device_info
*cdi
)
2290 cd_dbg(CD_DO_IOCTL
, "entering CDROMCLOSETRAY\n");
2292 if (!CDROM_CAN(CDC_CLOSE_TRAY
))
2294 return cdi
->ops
->tray_move(cdi
, 0);
2297 static int cdrom_ioctl_eject_sw(struct cdrom_device_info
*cdi
,
2300 cd_dbg(CD_DO_IOCTL
, "entering CDROMEJECT_SW\n");
2302 if (!CDROM_CAN(CDC_OPEN_TRAY
))
2304 if (cdi
->keeplocked
)
2307 cdi
->options
&= ~(CDO_AUTO_CLOSE
| CDO_AUTO_EJECT
);
2309 cdi
->options
|= CDO_AUTO_CLOSE
| CDO_AUTO_EJECT
;
2313 static int cdrom_ioctl_media_changed(struct cdrom_device_info
*cdi
,
2316 struct cdrom_changer_info
*info
;
2319 cd_dbg(CD_DO_IOCTL
, "entering CDROM_MEDIA_CHANGED\n");
2321 if (!CDROM_CAN(CDC_MEDIA_CHANGED
))
2324 /* cannot select disc or select current disc */
2325 if (!CDROM_CAN(CDC_SELECT_DISC
) || arg
== CDSL_CURRENT
)
2326 return media_changed(cdi
, 1);
2328 if ((unsigned int)arg
>= cdi
->capacity
)
2331 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
2335 ret
= cdrom_read_mech_status(cdi
, info
);
2337 ret
= info
->slots
[arg
].change
;
2342 static int cdrom_ioctl_set_options(struct cdrom_device_info
*cdi
,
2345 cd_dbg(CD_DO_IOCTL
, "entering CDROM_SET_OPTIONS\n");
2348 * Options need to be in sync with capability.
2349 * Too late for that, so we have to check each one separately.
2352 case CDO_USE_FFLAGS
:
2353 case CDO_CHECK_TYPE
:
2356 if (!CDROM_CAN(CDC_LOCK
))
2360 return cdi
->options
;
2361 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2363 if (!CDROM_CAN(arg
))
2366 cdi
->options
|= (int) arg
;
2367 return cdi
->options
;
2370 static int cdrom_ioctl_clear_options(struct cdrom_device_info
*cdi
,
2373 cd_dbg(CD_DO_IOCTL
, "entering CDROM_CLEAR_OPTIONS\n");
2375 cdi
->options
&= ~(int) arg
;
2376 return cdi
->options
;
2379 static int cdrom_ioctl_select_speed(struct cdrom_device_info
*cdi
,
2382 cd_dbg(CD_DO_IOCTL
, "entering CDROM_SELECT_SPEED\n");
2384 if (!CDROM_CAN(CDC_SELECT_SPEED
))
2386 return cdi
->ops
->select_speed(cdi
, arg
);
2389 static int cdrom_ioctl_select_disc(struct cdrom_device_info
*cdi
,
2392 cd_dbg(CD_DO_IOCTL
, "entering CDROM_SELECT_DISC\n");
2394 if (!CDROM_CAN(CDC_SELECT_DISC
))
2397 if (arg
!= CDSL_CURRENT
&& arg
!= CDSL_NONE
) {
2398 if ((int)arg
>= cdi
->capacity
)
2403 * ->select_disc is a hook to allow a driver-specific way of
2404 * seleting disc. However, since there is no equivalent hook for
2405 * cdrom_slot_status this may not actually be useful...
2407 if (cdi
->ops
->select_disc
)
2408 return cdi
->ops
->select_disc(cdi
, arg
);
2410 cd_dbg(CD_CHANGER
, "Using generic cdrom_select_disc()\n");
2411 return cdrom_select_disc(cdi
, arg
);
2414 static int cdrom_ioctl_reset(struct cdrom_device_info
*cdi
,
2415 struct block_device
*bdev
)
2417 cd_dbg(CD_DO_IOCTL
, "entering CDROM_RESET\n");
2419 if (!capable(CAP_SYS_ADMIN
))
2421 if (!CDROM_CAN(CDC_RESET
))
2423 invalidate_bdev(bdev
);
2424 return cdi
->ops
->reset(cdi
);
2427 static int cdrom_ioctl_lock_door(struct cdrom_device_info
*cdi
,
2430 cd_dbg(CD_DO_IOCTL
, "%socking door\n", arg
? "L" : "Unl");
2432 if (!CDROM_CAN(CDC_LOCK
))
2433 return -EDRIVE_CANT_DO_THIS
;
2435 cdi
->keeplocked
= arg
? 1 : 0;
2438 * Don't unlock the door on multiple opens by default, but allow
2441 if (cdi
->use_count
!= 1 && !arg
&& !capable(CAP_SYS_ADMIN
))
2443 return cdi
->ops
->lock_door(cdi
, arg
);
2446 static int cdrom_ioctl_debug(struct cdrom_device_info
*cdi
,
2449 cd_dbg(CD_DO_IOCTL
, "%sabling debug\n", arg
? "En" : "Dis");
2451 if (!capable(CAP_SYS_ADMIN
))
2453 debug
= arg
? 1 : 0;
2457 static int cdrom_ioctl_get_capability(struct cdrom_device_info
*cdi
)
2459 cd_dbg(CD_DO_IOCTL
, "entering CDROM_GET_CAPABILITY\n");
2460 return (cdi
->ops
->capability
& ~cdi
->mask
);
2464 * The following function is implemented, although very few audio
2465 * discs give Universal Product Code information, which should just be
2466 * the Medium Catalog Number on the box. Note, that the way the code
2467 * is written on the CD is /not/ uniform across all discs!
2469 static int cdrom_ioctl_get_mcn(struct cdrom_device_info
*cdi
,
2472 struct cdrom_mcn mcn
;
2475 cd_dbg(CD_DO_IOCTL
, "entering CDROM_GET_MCN\n");
2477 if (!(cdi
->ops
->capability
& CDC_MCN
))
2479 ret
= cdi
->ops
->get_mcn(cdi
, &mcn
);
2483 if (copy_to_user(argp
, &mcn
, sizeof(mcn
)))
2485 cd_dbg(CD_DO_IOCTL
, "CDROM_GET_MCN successful\n");
2489 static int cdrom_ioctl_drive_status(struct cdrom_device_info
*cdi
,
2492 cd_dbg(CD_DO_IOCTL
, "entering CDROM_DRIVE_STATUS\n");
2494 if (!(cdi
->ops
->capability
& CDC_DRIVE_STATUS
))
2496 if (!CDROM_CAN(CDC_SELECT_DISC
) ||
2497 (arg
== CDSL_CURRENT
|| arg
== CDSL_NONE
))
2498 return cdi
->ops
->drive_status(cdi
, CDSL_CURRENT
);
2499 if (((int)arg
>= cdi
->capacity
))
2501 return cdrom_slot_status(cdi
, arg
);
2505 * Ok, this is where problems start. The current interface for the
2506 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2507 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunately, while this
2508 * is often the case, it is also very common for CDs to have some tracks
2509 * with data, and some tracks with audio. Just because I feel like it,
2510 * I declare the following to be the best way to cope. If the CD has ANY
2511 * data tracks on it, it will be returned as a data CD. If it has any XA
2512 * tracks, I will return it as that. Now I could simplify this interface
2513 * by combining these returns with the above, but this more clearly
2514 * demonstrates the problem with the current interface. Too bad this
2515 * wasn't designed to use bitmasks... -Erik
2517 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2518 * User level programmers might feel the ioctl is not very useful.
2521 static int cdrom_ioctl_disc_status(struct cdrom_device_info
*cdi
)
2525 cd_dbg(CD_DO_IOCTL
, "entering CDROM_DISC_STATUS\n");
2527 cdrom_count_tracks(cdi
, &tracks
);
2529 return tracks
.error
;
2531 /* Policy mode on */
2532 if (tracks
.audio
> 0) {
2533 if (!tracks
.data
&& !tracks
.cdi
&& !tracks
.xa
)
2543 if (tracks
.data
> 0)
2545 /* Policy mode off */
2547 cd_dbg(CD_WARNING
, "This disc doesn't have any tracks I recognize!\n");
2551 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info
*cdi
)
2553 cd_dbg(CD_DO_IOCTL
, "entering CDROM_CHANGER_NSLOTS\n");
2554 return cdi
->capacity
;
2557 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info
*cdi
,
2560 struct cdrom_subchnl q
;
2564 /* cd_dbg(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2566 if (copy_from_user(&q
, argp
, sizeof(q
)))
2569 requested
= q
.cdsc_format
;
2570 if (requested
!= CDROM_MSF
&& requested
!= CDROM_LBA
)
2572 q
.cdsc_format
= CDROM_MSF
;
2574 ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMSUBCHNL
, &q
);
2578 back
= q
.cdsc_format
; /* local copy */
2579 sanitize_format(&q
.cdsc_absaddr
, &back
, requested
);
2580 sanitize_format(&q
.cdsc_reladdr
, &q
.cdsc_format
, requested
);
2582 if (copy_to_user(argp
, &q
, sizeof(q
)))
2584 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2588 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info
*cdi
,
2591 struct cdrom_tochdr header
;
2594 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2596 if (copy_from_user(&header
, argp
, sizeof(header
)))
2599 ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCHDR
, &header
);
2603 if (copy_to_user(argp
, &header
, sizeof(header
)))
2605 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2609 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info
*cdi
,
2612 struct cdrom_tocentry entry
;
2613 u8 requested_format
;
2616 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2618 if (copy_from_user(&entry
, argp
, sizeof(entry
)))
2621 requested_format
= entry
.cdte_format
;
2622 if (requested_format
!= CDROM_MSF
&& requested_format
!= CDROM_LBA
)
2624 /* make interface to low-level uniform */
2625 entry
.cdte_format
= CDROM_MSF
;
2626 ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCENTRY
, &entry
);
2629 sanitize_format(&entry
.cdte_addr
, &entry
.cdte_format
, requested_format
);
2631 if (copy_to_user(argp
, &entry
, sizeof(entry
)))
2633 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2637 static int cdrom_ioctl_play_msf(struct cdrom_device_info
*cdi
,
2640 struct cdrom_msf msf
;
2642 cd_dbg(CD_DO_IOCTL
, "entering CDROMPLAYMSF\n");
2644 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2646 if (copy_from_user(&msf
, argp
, sizeof(msf
)))
2648 return cdi
->ops
->audio_ioctl(cdi
, CDROMPLAYMSF
, &msf
);
2651 static int cdrom_ioctl_play_trkind(struct cdrom_device_info
*cdi
,
2657 cd_dbg(CD_DO_IOCTL
, "entering CDROMPLAYTRKIND\n");
2659 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2661 if (copy_from_user(&ti
, argp
, sizeof(ti
)))
2664 ret
= check_for_audio_disc(cdi
, cdi
->ops
);
2667 return cdi
->ops
->audio_ioctl(cdi
, CDROMPLAYTRKIND
, &ti
);
2669 static int cdrom_ioctl_volctrl(struct cdrom_device_info
*cdi
,
2672 struct cdrom_volctrl volume
;
2674 cd_dbg(CD_DO_IOCTL
, "entering CDROMVOLCTRL\n");
2676 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2678 if (copy_from_user(&volume
, argp
, sizeof(volume
)))
2680 return cdi
->ops
->audio_ioctl(cdi
, CDROMVOLCTRL
, &volume
);
2683 static int cdrom_ioctl_volread(struct cdrom_device_info
*cdi
,
2686 struct cdrom_volctrl volume
;
2689 cd_dbg(CD_DO_IOCTL
, "entering CDROMVOLREAD\n");
2691 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2694 ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMVOLREAD
, &volume
);
2698 if (copy_to_user(argp
, &volume
, sizeof(volume
)))
2703 static int cdrom_ioctl_audioctl(struct cdrom_device_info
*cdi
,
2708 cd_dbg(CD_DO_IOCTL
, "doing audio ioctl (start/stop/pause/resume)\n");
2710 if (!CDROM_CAN(CDC_PLAY_AUDIO
))
2712 ret
= check_for_audio_disc(cdi
, cdi
->ops
);
2715 return cdi
->ops
->audio_ioctl(cdi
, cmd
, NULL
);
2719 * Just about every imaginable ioctl is supported in the Uniform layer
2721 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2723 int cdrom_ioctl(struct cdrom_device_info
*cdi
, struct block_device
*bdev
,
2724 fmode_t mode
, unsigned int cmd
, unsigned long arg
)
2726 void __user
*argp
= (void __user
*)arg
;
2730 * Try the generic SCSI command ioctl's first.
2732 ret
= scsi_cmd_blk_ioctl(bdev
, mode
, cmd
, argp
);
2737 case CDROMMULTISESSION
:
2738 return cdrom_ioctl_multisession(cdi
, argp
);
2740 return cdrom_ioctl_eject(cdi
);
2741 case CDROMCLOSETRAY
:
2742 return cdrom_ioctl_closetray(cdi
);
2744 return cdrom_ioctl_eject_sw(cdi
, arg
);
2745 case CDROM_MEDIA_CHANGED
:
2746 return cdrom_ioctl_media_changed(cdi
, arg
);
2747 case CDROM_SET_OPTIONS
:
2748 return cdrom_ioctl_set_options(cdi
, arg
);
2749 case CDROM_CLEAR_OPTIONS
:
2750 return cdrom_ioctl_clear_options(cdi
, arg
);
2751 case CDROM_SELECT_SPEED
:
2752 return cdrom_ioctl_select_speed(cdi
, arg
);
2753 case CDROM_SELECT_DISC
:
2754 return cdrom_ioctl_select_disc(cdi
, arg
);
2756 return cdrom_ioctl_reset(cdi
, bdev
);
2757 case CDROM_LOCKDOOR
:
2758 return cdrom_ioctl_lock_door(cdi
, arg
);
2760 return cdrom_ioctl_debug(cdi
, arg
);
2761 case CDROM_GET_CAPABILITY
:
2762 return cdrom_ioctl_get_capability(cdi
);
2764 return cdrom_ioctl_get_mcn(cdi
, argp
);
2765 case CDROM_DRIVE_STATUS
:
2766 return cdrom_ioctl_drive_status(cdi
, arg
);
2767 case CDROM_DISC_STATUS
:
2768 return cdrom_ioctl_disc_status(cdi
);
2769 case CDROM_CHANGER_NSLOTS
:
2770 return cdrom_ioctl_changer_nslots(cdi
);
2774 * Use the ioctls that are implemented through the generic_packet()
2775 * interface. this may look at bit funny, but if -ENOTTY is
2776 * returned that particular ioctl is not implemented and we
2777 * let it go through the device specific ones.
2779 if (CDROM_CAN(CDC_GENERIC_PACKET
)) {
2780 ret
= mmc_ioctl(cdi
, cmd
, arg
);
2786 * Note: most of the cd_dbg() calls are commented out here,
2787 * because they fill up the sys log when CD players poll
2792 return cdrom_ioctl_get_subchnl(cdi
, argp
);
2793 case CDROMREADTOCHDR
:
2794 return cdrom_ioctl_read_tochdr(cdi
, argp
);
2795 case CDROMREADTOCENTRY
:
2796 return cdrom_ioctl_read_tocentry(cdi
, argp
);
2798 return cdrom_ioctl_play_msf(cdi
, argp
);
2799 case CDROMPLAYTRKIND
:
2800 return cdrom_ioctl_play_trkind(cdi
, argp
);
2802 return cdrom_ioctl_volctrl(cdi
, argp
);
2804 return cdrom_ioctl_volread(cdi
, argp
);
2809 return cdrom_ioctl_audioctl(cdi
, cmd
);
2816 * Required when we need to use READ_10 to issue other than 2048 block
2819 static int cdrom_switch_blocksize(struct cdrom_device_info
*cdi
, int size
)
2821 struct cdrom_device_ops
*cdo
= cdi
->ops
;
2822 struct packet_command cgc
;
2823 struct modesel_head mh
;
2825 memset(&mh
, 0, sizeof(mh
));
2826 mh
.block_desc_length
= 0x08;
2827 mh
.block_length_med
= (size
>> 8) & 0xff;
2828 mh
.block_length_lo
= size
& 0xff;
2830 memset(&cgc
, 0, sizeof(cgc
));
2832 cgc
.cmd
[1] = 1 << 4;
2834 cgc
.buflen
= sizeof(mh
);
2835 cgc
.buffer
= (char *) &mh
;
2836 cgc
.data_direction
= CGC_DATA_WRITE
;
2837 mh
.block_desc_length
= 0x08;
2838 mh
.block_length_med
= (size
>> 8) & 0xff;
2839 mh
.block_length_lo
= size
& 0xff;
2841 return cdo
->generic_packet(cdi
, &cgc
);
2844 static noinline
int mmc_ioctl_cdrom_read_data(struct cdrom_device_info
*cdi
,
2846 struct packet_command
*cgc
,
2849 struct request_sense sense
;
2850 struct cdrom_msf msf
;
2851 int blocksize
= 0, format
= 0, lba
;
2856 blocksize
= CD_FRAMESIZE_RAW
;
2858 case CDROMREADMODE1
:
2859 blocksize
= CD_FRAMESIZE
;
2862 case CDROMREADMODE2
:
2863 blocksize
= CD_FRAMESIZE_RAW0
;
2866 if (copy_from_user(&msf
, (struct cdrom_msf __user
*)arg
, sizeof(msf
)))
2868 lba
= msf_to_lba(msf
.cdmsf_min0
, msf
.cdmsf_sec0
, msf
.cdmsf_frame0
);
2869 /* FIXME: we need upper bound checking, too!! */
2873 cgc
->buffer
= kzalloc(blocksize
, GFP_KERNEL
);
2874 if (cgc
->buffer
== NULL
)
2877 memset(&sense
, 0, sizeof(sense
));
2878 cgc
->sense
= &sense
;
2879 cgc
->data_direction
= CGC_DATA_READ
;
2880 ret
= cdrom_read_block(cdi
, cgc
, lba
, 1, format
, blocksize
);
2881 if (ret
&& sense
.sense_key
== 0x05 &&
2882 sense
.asc
== 0x20 &&
2883 sense
.ascq
== 0x00) {
2885 * SCSI-II devices are not required to support
2886 * READ_CD, so let's try switching block size
2888 /* FIXME: switch back again... */
2889 ret
= cdrom_switch_blocksize(cdi
, blocksize
);
2893 ret
= cdrom_read_cd(cdi
, cgc
, lba
, blocksize
, 1);
2894 ret
|= cdrom_switch_blocksize(cdi
, blocksize
);
2896 if (!ret
&& copy_to_user(arg
, cgc
->buffer
, blocksize
))
2903 static noinline
int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info
*cdi
,
2906 struct cdrom_read_audio ra
;
2909 if (copy_from_user(&ra
, (struct cdrom_read_audio __user
*)arg
,
2913 if (ra
.addr_format
== CDROM_MSF
)
2914 lba
= msf_to_lba(ra
.addr
.msf
.minute
,
2917 else if (ra
.addr_format
== CDROM_LBA
)
2922 /* FIXME: we need upper bound checking, too!! */
2923 if (lba
< 0 || ra
.nframes
<= 0 || ra
.nframes
> CD_FRAMES
)
2926 return cdrom_read_cdda(cdi
, ra
.buf
, lba
, ra
.nframes
);
2929 static noinline
int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info
*cdi
,
2933 struct cdrom_subchnl q
;
2934 u_char requested
, back
;
2935 if (copy_from_user(&q
, (struct cdrom_subchnl __user
*)arg
, sizeof(q
)))
2937 requested
= q
.cdsc_format
;
2938 if (!((requested
== CDROM_MSF
) ||
2939 (requested
== CDROM_LBA
)))
2941 q
.cdsc_format
= CDROM_MSF
;
2942 ret
= cdrom_read_subchannel(cdi
, &q
, 0);
2945 back
= q
.cdsc_format
; /* local copy */
2946 sanitize_format(&q
.cdsc_absaddr
, &back
, requested
);
2947 sanitize_format(&q
.cdsc_reladdr
, &q
.cdsc_format
, requested
);
2948 if (copy_to_user((struct cdrom_subchnl __user
*)arg
, &q
, sizeof(q
)))
2950 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2954 static noinline
int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info
*cdi
,
2956 struct packet_command
*cgc
)
2958 struct cdrom_device_ops
*cdo
= cdi
->ops
;
2959 struct cdrom_msf msf
;
2960 cd_dbg(CD_DO_IOCTL
, "entering CDROMPLAYMSF\n");
2961 if (copy_from_user(&msf
, (struct cdrom_msf __user
*)arg
, sizeof(msf
)))
2963 cgc
->cmd
[0] = GPCMD_PLAY_AUDIO_MSF
;
2964 cgc
->cmd
[3] = msf
.cdmsf_min0
;
2965 cgc
->cmd
[4] = msf
.cdmsf_sec0
;
2966 cgc
->cmd
[5] = msf
.cdmsf_frame0
;
2967 cgc
->cmd
[6] = msf
.cdmsf_min1
;
2968 cgc
->cmd
[7] = msf
.cdmsf_sec1
;
2969 cgc
->cmd
[8] = msf
.cdmsf_frame1
;
2970 cgc
->data_direction
= CGC_DATA_NONE
;
2971 return cdo
->generic_packet(cdi
, cgc
);
2974 static noinline
int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info
*cdi
,
2976 struct packet_command
*cgc
)
2978 struct cdrom_device_ops
*cdo
= cdi
->ops
;
2979 struct cdrom_blk blk
;
2980 cd_dbg(CD_DO_IOCTL
, "entering CDROMPLAYBLK\n");
2981 if (copy_from_user(&blk
, (struct cdrom_blk __user
*)arg
, sizeof(blk
)))
2983 cgc
->cmd
[0] = GPCMD_PLAY_AUDIO_10
;
2984 cgc
->cmd
[2] = (blk
.from
>> 24) & 0xff;
2985 cgc
->cmd
[3] = (blk
.from
>> 16) & 0xff;
2986 cgc
->cmd
[4] = (blk
.from
>> 8) & 0xff;
2987 cgc
->cmd
[5] = blk
.from
& 0xff;
2988 cgc
->cmd
[7] = (blk
.len
>> 8) & 0xff;
2989 cgc
->cmd
[8] = blk
.len
& 0xff;
2990 cgc
->data_direction
= CGC_DATA_NONE
;
2991 return cdo
->generic_packet(cdi
, cgc
);
2994 static noinline
int mmc_ioctl_cdrom_volume(struct cdrom_device_info
*cdi
,
2996 struct packet_command
*cgc
,
2999 struct cdrom_volctrl volctrl
;
3000 unsigned char buffer
[32];
3001 char mask
[sizeof(buffer
)];
3002 unsigned short offset
;
3005 cd_dbg(CD_DO_IOCTL
, "entering CDROMVOLUME\n");
3007 if (copy_from_user(&volctrl
, (struct cdrom_volctrl __user
*)arg
,
3011 cgc
->buffer
= buffer
;
3013 ret
= cdrom_mode_sense(cdi
, cgc
, GPMODE_AUDIO_CTL_PAGE
, 0);
3017 /* originally the code depended on buffer[1] to determine
3018 how much data is available for transfer. buffer[1] is
3019 unfortunately ambigious and the only reliable way seem
3020 to be to simply skip over the block descriptor... */
3021 offset
= 8 + be16_to_cpu(*(__be16
*)(buffer
+ 6));
3023 if (offset
+ 16 > sizeof(buffer
))
3026 if (offset
+ 16 > cgc
->buflen
) {
3027 cgc
->buflen
= offset
+ 16;
3028 ret
= cdrom_mode_sense(cdi
, cgc
,
3029 GPMODE_AUDIO_CTL_PAGE
, 0);
3035 if ((buffer
[offset
] & 0x3f) != GPMODE_AUDIO_CTL_PAGE
||
3036 buffer
[offset
+ 1] < 14)
3039 /* now we have the current volume settings. if it was only
3040 a CDROMVOLREAD, return these values */
3041 if (cmd
== CDROMVOLREAD
) {
3042 volctrl
.channel0
= buffer
[offset
+9];
3043 volctrl
.channel1
= buffer
[offset
+11];
3044 volctrl
.channel2
= buffer
[offset
+13];
3045 volctrl
.channel3
= buffer
[offset
+15];
3046 if (copy_to_user((struct cdrom_volctrl __user
*)arg
, &volctrl
,
3052 /* get the volume mask */
3054 ret
= cdrom_mode_sense(cdi
, cgc
, GPMODE_AUDIO_CTL_PAGE
, 1);
3058 buffer
[offset
+ 9] = volctrl
.channel0
& mask
[offset
+ 9];
3059 buffer
[offset
+ 11] = volctrl
.channel1
& mask
[offset
+ 11];
3060 buffer
[offset
+ 13] = volctrl
.channel2
& mask
[offset
+ 13];
3061 buffer
[offset
+ 15] = volctrl
.channel3
& mask
[offset
+ 15];
3064 cgc
->buffer
= buffer
+ offset
- 8;
3065 memset(cgc
->buffer
, 0, 8);
3066 return cdrom_mode_select(cdi
, cgc
);
3069 static noinline
int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info
*cdi
,
3070 struct packet_command
*cgc
,
3073 struct cdrom_device_ops
*cdo
= cdi
->ops
;
3074 cd_dbg(CD_DO_IOCTL
, "entering CDROMSTART/CDROMSTOP\n");
3075 cgc
->cmd
[0] = GPCMD_START_STOP_UNIT
;
3077 cgc
->cmd
[4] = (cmd
== CDROMSTART
) ? 1 : 0;
3078 cgc
->data_direction
= CGC_DATA_NONE
;
3079 return cdo
->generic_packet(cdi
, cgc
);
3082 static noinline
int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info
*cdi
,
3083 struct packet_command
*cgc
,
3086 struct cdrom_device_ops
*cdo
= cdi
->ops
;
3087 cd_dbg(CD_DO_IOCTL
, "entering CDROMPAUSE/CDROMRESUME\n");
3088 cgc
->cmd
[0] = GPCMD_PAUSE_RESUME
;
3089 cgc
->cmd
[8] = (cmd
== CDROMRESUME
) ? 1 : 0;
3090 cgc
->data_direction
= CGC_DATA_NONE
;
3091 return cdo
->generic_packet(cdi
, cgc
);
3094 static noinline
int mmc_ioctl_dvd_read_struct(struct cdrom_device_info
*cdi
,
3096 struct packet_command
*cgc
)
3100 int size
= sizeof(dvd_struct
);
3102 if (!CDROM_CAN(CDC_DVD
))
3105 s
= kmalloc(size
, GFP_KERNEL
);
3109 cd_dbg(CD_DO_IOCTL
, "entering DVD_READ_STRUCT\n");
3110 if (copy_from_user(s
, arg
, size
)) {
3115 ret
= dvd_read_struct(cdi
, s
, cgc
);
3119 if (copy_to_user(arg
, s
, size
))
3126 static noinline
int mmc_ioctl_dvd_auth(struct cdrom_device_info
*cdi
,
3131 if (!CDROM_CAN(CDC_DVD
))
3133 cd_dbg(CD_DO_IOCTL
, "entering DVD_AUTH\n");
3134 if (copy_from_user(&ai
, (dvd_authinfo __user
*)arg
, sizeof(ai
)))
3136 ret
= dvd_do_auth(cdi
, &ai
);
3139 if (copy_to_user((dvd_authinfo __user
*)arg
, &ai
, sizeof(ai
)))
3144 static noinline
int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info
*cdi
,
3149 cd_dbg(CD_DO_IOCTL
, "entering CDROM_NEXT_WRITABLE\n");
3150 ret
= cdrom_get_next_writable(cdi
, &next
);
3153 if (copy_to_user((long __user
*)arg
, &next
, sizeof(next
)))
3158 static noinline
int mmc_ioctl_cdrom_last_written(struct cdrom_device_info
*cdi
,
3163 cd_dbg(CD_DO_IOCTL
, "entering CDROM_LAST_WRITTEN\n");
3164 ret
= cdrom_get_last_written(cdi
, &last
);
3167 if (copy_to_user((long __user
*)arg
, &last
, sizeof(last
)))
3172 static int mmc_ioctl(struct cdrom_device_info
*cdi
, unsigned int cmd
,
3175 struct packet_command cgc
;
3176 void __user
*userptr
= (void __user
*)arg
;
3178 memset(&cgc
, 0, sizeof(cgc
));
3180 /* build a unified command and queue it through
3181 cdo->generic_packet() */
3184 case CDROMREADMODE1
:
3185 case CDROMREADMODE2
:
3186 return mmc_ioctl_cdrom_read_data(cdi
, userptr
, &cgc
, cmd
);
3187 case CDROMREADAUDIO
:
3188 return mmc_ioctl_cdrom_read_audio(cdi
, userptr
);
3190 return mmc_ioctl_cdrom_subchannel(cdi
, userptr
);
3192 return mmc_ioctl_cdrom_play_msf(cdi
, userptr
, &cgc
);
3194 return mmc_ioctl_cdrom_play_blk(cdi
, userptr
, &cgc
);
3197 return mmc_ioctl_cdrom_volume(cdi
, userptr
, &cgc
, cmd
);
3200 return mmc_ioctl_cdrom_start_stop(cdi
, &cgc
, cmd
);
3203 return mmc_ioctl_cdrom_pause_resume(cdi
, &cgc
, cmd
);
3204 case DVD_READ_STRUCT
:
3205 return mmc_ioctl_dvd_read_struct(cdi
, userptr
, &cgc
);
3207 return mmc_ioctl_dvd_auth(cdi
, userptr
);
3208 case CDROM_NEXT_WRITABLE
:
3209 return mmc_ioctl_cdrom_next_writable(cdi
, userptr
);
3210 case CDROM_LAST_WRITTEN
:
3211 return mmc_ioctl_cdrom_last_written(cdi
, userptr
);
3217 static int cdrom_get_track_info(struct cdrom_device_info
*cdi
, __u16 track
, __u8 type
,
3218 track_information
*ti
)
3220 struct cdrom_device_ops
*cdo
= cdi
->ops
;
3221 struct packet_command cgc
;
3224 init_cdrom_command(&cgc
, ti
, 8, CGC_DATA_READ
);
3225 cgc
.cmd
[0] = GPCMD_READ_TRACK_RZONE_INFO
;
3226 cgc
.cmd
[1] = type
& 3;
3227 cgc
.cmd
[4] = (track
& 0xff00) >> 8;
3228 cgc
.cmd
[5] = track
& 0xff;
3232 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
3235 buflen
= be16_to_cpu(ti
->track_information_length
) +
3236 sizeof(ti
->track_information_length
);
3238 if (buflen
> sizeof(track_information
))
3239 buflen
= sizeof(track_information
);
3241 cgc
.cmd
[8] = cgc
.buflen
= buflen
;
3242 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
3245 /* return actual fill size */
3249 /* requires CD R/RW */
3250 static int cdrom_get_disc_info(struct cdrom_device_info
*cdi
, disc_information
*di
)
3252 struct cdrom_device_ops
*cdo
= cdi
->ops
;
3253 struct packet_command cgc
;
3256 /* set up command and get the disc info */
3257 init_cdrom_command(&cgc
, di
, sizeof(*di
), CGC_DATA_READ
);
3258 cgc
.cmd
[0] = GPCMD_READ_DISC_INFO
;
3259 cgc
.cmd
[8] = cgc
.buflen
= 2;
3262 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
3265 /* not all drives have the same disc_info length, so requeue
3266 * packet with the length the drive tells us it can supply
3268 buflen
= be16_to_cpu(di
->disc_information_length
) +
3269 sizeof(di
->disc_information_length
);
3271 if (buflen
> sizeof(disc_information
))
3272 buflen
= sizeof(disc_information
);
3274 cgc
.cmd
[8] = cgc
.buflen
= buflen
;
3275 if ((ret
= cdo
->generic_packet(cdi
, &cgc
)))
3278 /* return actual fill size */
3282 /* return the last written block on the CD-R media. this is for the udf
3284 int cdrom_get_last_written(struct cdrom_device_info
*cdi
, long *last_written
)
3286 struct cdrom_tocentry toc
;
3287 disc_information di
;
3288 track_information ti
;
3290 int ret
= -1, ti_size
;
3292 if (!CDROM_CAN(CDC_GENERIC_PACKET
))
3295 ret
= cdrom_get_disc_info(cdi
, &di
);
3296 if (ret
< (int)(offsetof(typeof(di
), last_track_lsb
)
3297 + sizeof(di
.last_track_lsb
)))
3300 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3301 last_track
= (di
.last_track_msb
<< 8) | di
.last_track_lsb
;
3302 ti_size
= cdrom_get_track_info(cdi
, last_track
, 1, &ti
);
3303 if (ti_size
< (int)offsetof(typeof(ti
), track_start
))
3306 /* if this track is blank, try the previous. */
3311 ti_size
= cdrom_get_track_info(cdi
, last_track
, 1, &ti
);
3314 if (ti_size
< (int)(offsetof(typeof(ti
), track_size
)
3315 + sizeof(ti
.track_size
)))
3318 /* if last recorded field is valid, return it. */
3319 if (ti
.lra_v
&& ti_size
>= (int)(offsetof(typeof(ti
), last_rec_address
)
3320 + sizeof(ti
.last_rec_address
))) {
3321 *last_written
= be32_to_cpu(ti
.last_rec_address
);
3323 /* make it up instead */
3324 *last_written
= be32_to_cpu(ti
.track_start
) +
3325 be32_to_cpu(ti
.track_size
);
3327 *last_written
-= (be32_to_cpu(ti
.free_blocks
) + 7);
3331 /* this is where we end up if the drive either can't do a
3332 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3333 it doesn't give enough information or fails. then we return
3334 the toc contents. */
3336 toc
.cdte_format
= CDROM_MSF
;
3337 toc
.cdte_track
= CDROM_LEADOUT
;
3338 if ((ret
= cdi
->ops
->audio_ioctl(cdi
, CDROMREADTOCENTRY
, &toc
)))
3340 sanitize_format(&toc
.cdte_addr
, &toc
.cdte_format
, CDROM_LBA
);
3341 *last_written
= toc
.cdte_addr
.lba
;
3345 /* return the next writable block. also for udf file system. */
3346 static int cdrom_get_next_writable(struct cdrom_device_info
*cdi
, long *next_writable
)
3348 disc_information di
;
3349 track_information ti
;
3353 if (!CDROM_CAN(CDC_GENERIC_PACKET
))
3354 goto use_last_written
;
3356 ret
= cdrom_get_disc_info(cdi
, &di
);
3357 if (ret
< 0 || ret
< offsetof(typeof(di
), last_track_lsb
)
3358 + sizeof(di
.last_track_lsb
))
3359 goto use_last_written
;
3361 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3362 last_track
= (di
.last_track_msb
<< 8) | di
.last_track_lsb
;
3363 ti_size
= cdrom_get_track_info(cdi
, last_track
, 1, &ti
);
3364 if (ti_size
< 0 || ti_size
< offsetof(typeof(ti
), track_start
))
3365 goto use_last_written
;
3367 /* if this track is blank, try the previous. */
3369 if (last_track
== 1)
3370 goto use_last_written
;
3372 ti_size
= cdrom_get_track_info(cdi
, last_track
, 1, &ti
);
3374 goto use_last_written
;
3377 /* if next recordable address field is valid, use it. */
3378 if (ti
.nwa_v
&& ti_size
>= offsetof(typeof(ti
), next_writable
)
3379 + sizeof(ti
.next_writable
)) {
3380 *next_writable
= be32_to_cpu(ti
.next_writable
);
3385 if ((ret
= cdrom_get_last_written(cdi
, next_writable
))) {
3389 *next_writable
+= 7;
3394 EXPORT_SYMBOL(cdrom_get_last_written
);
3395 EXPORT_SYMBOL(register_cdrom
);
3396 EXPORT_SYMBOL(unregister_cdrom
);
3397 EXPORT_SYMBOL(cdrom_open
);
3398 EXPORT_SYMBOL(cdrom_release
);
3399 EXPORT_SYMBOL(cdrom_ioctl
);
3400 EXPORT_SYMBOL(cdrom_media_changed
);
3401 EXPORT_SYMBOL(cdrom_number_of_slots
);
3402 EXPORT_SYMBOL(cdrom_mode_select
);
3403 EXPORT_SYMBOL(cdrom_mode_sense
);
3404 EXPORT_SYMBOL(init_cdrom_command
);
3405 EXPORT_SYMBOL(cdrom_get_media_event
);
3407 #ifdef CONFIG_SYSCTL
3409 #define CDROM_STR_SIZE 1000
3411 static struct cdrom_sysctl_settings
{
3412 char info
[CDROM_STR_SIZE
]; /* general info */
3413 int autoclose
; /* close tray upon mount, etc */
3414 int autoeject
; /* eject on umount */
3415 int debug
; /* turn on debugging messages */
3416 int lock
; /* lock the door on device open */
3417 int check
; /* check media type */
3418 } cdrom_sysctl_settings
;
3420 enum cdrom_print_option
{
3427 static int cdrom_print_info(const char *header
, int val
, char *info
,
3428 int *pos
, enum cdrom_print_option option
)
3430 const int max_size
= sizeof(cdrom_sysctl_settings
.info
);
3431 struct cdrom_device_info
*cdi
;
3434 ret
= scnprintf(info
+ *pos
, max_size
- *pos
, header
);
3440 list_for_each_entry(cdi
, &cdrom_list
, list
) {
3443 ret
= scnprintf(info
+ *pos
, max_size
- *pos
,
3447 ret
= scnprintf(info
+ *pos
, max_size
- *pos
,
3448 "\t%d", cdi
->speed
);
3451 ret
= scnprintf(info
+ *pos
, max_size
- *pos
,
3452 "\t%d", cdi
->capacity
);
3454 case CTL_CAPABILITY
:
3455 ret
= scnprintf(info
+ *pos
, max_size
- *pos
,
3456 "\t%d", CDROM_CAN(val
) != 0);
3459 pr_info("invalid option%d\n", option
);
3470 static int cdrom_sysctl_info(ctl_table
*ctl
, int write
,
3471 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
3474 char *info
= cdrom_sysctl_settings
.info
;
3475 const int max_size
= sizeof(cdrom_sysctl_settings
.info
);
3477 if (!*lenp
|| (*ppos
&& !write
)) {
3482 mutex_lock(&cdrom_mutex
);
3484 pos
= sprintf(info
, "CD-ROM information, " VERSION
"\n");
3486 if (cdrom_print_info("\ndrive name:\t", 0, info
, &pos
, CTL_NAME
))
3488 if (cdrom_print_info("\ndrive speed:\t", 0, info
, &pos
, CTL_SPEED
))
3490 if (cdrom_print_info("\ndrive # of slots:", 0, info
, &pos
, CTL_SLOTS
))
3492 if (cdrom_print_info("\nCan close tray:\t",
3493 CDC_CLOSE_TRAY
, info
, &pos
, CTL_CAPABILITY
))
3495 if (cdrom_print_info("\nCan open tray:\t",
3496 CDC_OPEN_TRAY
, info
, &pos
, CTL_CAPABILITY
))
3498 if (cdrom_print_info("\nCan lock tray:\t",
3499 CDC_LOCK
, info
, &pos
, CTL_CAPABILITY
))
3501 if (cdrom_print_info("\nCan change speed:",
3502 CDC_SELECT_SPEED
, info
, &pos
, CTL_CAPABILITY
))
3504 if (cdrom_print_info("\nCan select disk:",
3505 CDC_SELECT_DISC
, info
, &pos
, CTL_CAPABILITY
))
3507 if (cdrom_print_info("\nCan read multisession:",
3508 CDC_MULTI_SESSION
, info
, &pos
, CTL_CAPABILITY
))
3510 if (cdrom_print_info("\nCan read MCN:\t",
3511 CDC_MCN
, info
, &pos
, CTL_CAPABILITY
))
3513 if (cdrom_print_info("\nReports media changed:",
3514 CDC_MEDIA_CHANGED
, info
, &pos
, CTL_CAPABILITY
))
3516 if (cdrom_print_info("\nCan play audio:\t",
3517 CDC_PLAY_AUDIO
, info
, &pos
, CTL_CAPABILITY
))
3519 if (cdrom_print_info("\nCan write CD-R:\t",
3520 CDC_CD_R
, info
, &pos
, CTL_CAPABILITY
))
3522 if (cdrom_print_info("\nCan write CD-RW:",
3523 CDC_CD_RW
, info
, &pos
, CTL_CAPABILITY
))
3525 if (cdrom_print_info("\nCan read DVD:\t",
3526 CDC_DVD
, info
, &pos
, CTL_CAPABILITY
))
3528 if (cdrom_print_info("\nCan write DVD-R:",
3529 CDC_DVD_R
, info
, &pos
, CTL_CAPABILITY
))
3531 if (cdrom_print_info("\nCan write DVD-RAM:",
3532 CDC_DVD_RAM
, info
, &pos
, CTL_CAPABILITY
))
3534 if (cdrom_print_info("\nCan read MRW:\t",
3535 CDC_MRW
, info
, &pos
, CTL_CAPABILITY
))
3537 if (cdrom_print_info("\nCan write MRW:\t",
3538 CDC_MRW_W
, info
, &pos
, CTL_CAPABILITY
))
3540 if (cdrom_print_info("\nCan write RAM:\t",
3541 CDC_RAM
, info
, &pos
, CTL_CAPABILITY
))
3543 if (!scnprintf(info
+ pos
, max_size
- pos
, "\n\n"))
3546 mutex_unlock(&cdrom_mutex
);
3547 return proc_dostring(ctl
, write
, buffer
, lenp
, ppos
);
3549 pr_info("info buffer too small\n");
3553 /* Unfortunately, per device settings are not implemented through
3554 procfs/sysctl yet. When they are, this will naturally disappear. For now
3555 just update all drives. Later this will become the template on which
3556 new registered drives will be based. */
3557 static void cdrom_update_settings(void)
3559 struct cdrom_device_info
*cdi
;
3561 mutex_lock(&cdrom_mutex
);
3562 list_for_each_entry(cdi
, &cdrom_list
, list
) {
3563 if (autoclose
&& CDROM_CAN(CDC_CLOSE_TRAY
))
3564 cdi
->options
|= CDO_AUTO_CLOSE
;
3565 else if (!autoclose
)
3566 cdi
->options
&= ~CDO_AUTO_CLOSE
;
3567 if (autoeject
&& CDROM_CAN(CDC_OPEN_TRAY
))
3568 cdi
->options
|= CDO_AUTO_EJECT
;
3569 else if (!autoeject
)
3570 cdi
->options
&= ~CDO_AUTO_EJECT
;
3571 if (lockdoor
&& CDROM_CAN(CDC_LOCK
))
3572 cdi
->options
|= CDO_LOCK
;
3574 cdi
->options
&= ~CDO_LOCK
;
3575 if (check_media_type
)
3576 cdi
->options
|= CDO_CHECK_TYPE
;
3578 cdi
->options
&= ~CDO_CHECK_TYPE
;
3580 mutex_unlock(&cdrom_mutex
);
3583 static int cdrom_sysctl_handler(ctl_table
*ctl
, int write
,
3584 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
3588 ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
3592 /* we only care for 1 or 0. */
3593 autoclose
= !!cdrom_sysctl_settings
.autoclose
;
3594 autoeject
= !!cdrom_sysctl_settings
.autoeject
;
3595 debug
= !!cdrom_sysctl_settings
.debug
;
3596 lockdoor
= !!cdrom_sysctl_settings
.lock
;
3597 check_media_type
= !!cdrom_sysctl_settings
.check
;
3599 /* update the option flags according to the changes. we
3600 don't have per device options through sysctl yet,
3601 but we will have and then this will disappear. */
3602 cdrom_update_settings();
3608 /* Place files in /proc/sys/dev/cdrom */
3609 static ctl_table cdrom_table
[] = {
3612 .data
= &cdrom_sysctl_settings
.info
,
3613 .maxlen
= CDROM_STR_SIZE
,
3615 .proc_handler
= cdrom_sysctl_info
,
3618 .procname
= "autoclose",
3619 .data
= &cdrom_sysctl_settings
.autoclose
,
3620 .maxlen
= sizeof(int),
3622 .proc_handler
= cdrom_sysctl_handler
,
3625 .procname
= "autoeject",
3626 .data
= &cdrom_sysctl_settings
.autoeject
,
3627 .maxlen
= sizeof(int),
3629 .proc_handler
= cdrom_sysctl_handler
,
3632 .procname
= "debug",
3633 .data
= &cdrom_sysctl_settings
.debug
,
3634 .maxlen
= sizeof(int),
3636 .proc_handler
= cdrom_sysctl_handler
,
3640 .data
= &cdrom_sysctl_settings
.lock
,
3641 .maxlen
= sizeof(int),
3643 .proc_handler
= cdrom_sysctl_handler
,
3646 .procname
= "check_media",
3647 .data
= &cdrom_sysctl_settings
.check
,
3648 .maxlen
= sizeof(int),
3650 .proc_handler
= cdrom_sysctl_handler
3655 static ctl_table cdrom_cdrom_table
[] = {
3657 .procname
= "cdrom",
3660 .child
= cdrom_table
,
3665 /* Make sure that /proc/sys/dev is there */
3666 static ctl_table cdrom_root_table
[] = {
3671 .child
= cdrom_cdrom_table
,
3675 static struct ctl_table_header
*cdrom_sysctl_header
;
3677 static void cdrom_sysctl_register(void)
3679 static int initialized
;
3681 if (initialized
== 1)
3684 cdrom_sysctl_header
= register_sysctl_table(cdrom_root_table
);
3686 /* set the defaults */
3687 cdrom_sysctl_settings
.autoclose
= autoclose
;
3688 cdrom_sysctl_settings
.autoeject
= autoeject
;
3689 cdrom_sysctl_settings
.debug
= debug
;
3690 cdrom_sysctl_settings
.lock
= lockdoor
;
3691 cdrom_sysctl_settings
.check
= check_media_type
;
3696 static void cdrom_sysctl_unregister(void)
3698 if (cdrom_sysctl_header
)
3699 unregister_sysctl_table(cdrom_sysctl_header
);
3702 #else /* CONFIG_SYSCTL */
3704 static void cdrom_sysctl_register(void)
3708 static void cdrom_sysctl_unregister(void)
3712 #endif /* CONFIG_SYSCTL */
3714 static int __init
cdrom_init(void)
3716 cdrom_sysctl_register();
3721 static void __exit
cdrom_exit(void)
3723 pr_info("Uniform CD-ROM driver unloaded\n");
3724 cdrom_sysctl_unregister();
3727 module_init(cdrom_init
);
3728 module_exit(cdrom_exit
);
3729 MODULE_LICENSE("GPL");