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/buffer_head.h>
271
#include <linux/major.h>
272
#include <linux/types.h>
273
#include <linux/errno.h>
274
#include <linux/kernel.h>
275
#include <linux/mm.h>
276
#include <linux/slab.h>
277
#include <linux/cdrom.h>
278
#include <linux/sysctl.h>
279
#include <linux/proc_fs.h>
280
#include <linux/blkpg.h>
281
#include <linux/init.h>
282
#include <linux/fcntl.h>
283
#include <linux/blkdev.h>
284
#include <linux/times.h>
286
#include <asm/uaccess.h>
288
/* used to tell the module to turn on full debugging messages */
290
/* used to keep tray locked at all times */
291
static int keeplocked;
292
/* default compatibility mode */
293
static int autoclose=1;
294
static int autoeject;
295
static int lockdoor = 1;
296
/* will we ever get to use this... sigh. */
297
static int check_media_type;
298
/* automatically restart mrw format */
299
static int mrw_format_restart = 1;
300
module_param(debug, bool, 0);
301
module_param(autoclose, bool, 0);
302
module_param(autoeject, bool, 0);
303
module_param(lockdoor, bool, 0);
304
module_param(check_media_type, bool, 0);
305
module_param(mrw_format_restart, bool, 0);
307
static DEFINE_MUTEX(cdrom_mutex);
309
static const char *mrw_format_status[] = {
316
static const char *mrw_address_space[] = { "DMA", "GAA" };
318
#if (ERRLOGMASK!=CD_NOTHING)
319
#define cdinfo(type, fmt, args...) \
321
if ((ERRLOGMASK & type) || debug == 1) \
322
pr_info(fmt, ##args); \
325
#define cdinfo(type, fmt, args...) \
327
if (0 && (ERRLOGMASK & type) || debug == 1) \
328
pr_info(fmt, ##args); \
332
/* These are used to simplify getting data in from and back to user land */
333
#define IOCTL_IN(arg, type, in) \
334
if (copy_from_user(&(in), (type __user *) (arg), sizeof (in))) \
337
#define IOCTL_OUT(arg, type, out) \
338
if (copy_to_user((type __user *) (arg), &(out), sizeof (out))) \
341
/* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
342
a lot of places. This macro makes the code more clear. */
343
#define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
345
/* used in the audio ioctls */
346
#define CHECKAUDIO if ((ret=check_for_audio_disc(cdi, cdo))) return ret
349
* Another popular OS uses 7 seconds as the hard timeout for default
350
* commands, so it is a good choice for us as well.
352
#define CDROM_DEF_TIMEOUT (7 * HZ)
354
/* Not-exported routines. */
355
static int open_for_data(struct cdrom_device_info * cdi);
356
static int check_for_audio_disc(struct cdrom_device_info * cdi,
357
struct cdrom_device_ops * cdo);
358
static void sanitize_format(union cdrom_addr *addr,
359
u_char * curr, u_char requested);
360
static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
363
int cdrom_get_last_written(struct cdrom_device_info *, long *);
364
static int cdrom_get_next_writable(struct cdrom_device_info *, long *);
365
static void cdrom_count_tracks(struct cdrom_device_info *, tracktype*);
367
static int cdrom_mrw_exit(struct cdrom_device_info *cdi);
369
static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di);
371
static void cdrom_sysctl_register(void);
373
static LIST_HEAD(cdrom_list);
375
static int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
376
struct packet_command *cgc)
379
cgc->sense->sense_key = 0x05;
380
cgc->sense->asc = 0x20;
381
cgc->sense->ascq = 0x00;
388
/* This macro makes sure we don't have to check on cdrom_device_ops
389
* existence in the run-time routines below. Change_capability is a
390
* hack to have the capability flags defined const, while we can still
391
* change it here without gcc complaining at every line.
393
#define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
395
int register_cdrom(struct cdrom_device_info *cdi)
397
static char banner_printed;
398
struct cdrom_device_ops *cdo = cdi->ops;
399
int *change_capability = (int *)&cdo->capability; /* hack */
401
cdinfo(CD_OPEN, "entering register_cdrom\n");
403
if (cdo->open == NULL || cdo->release == NULL)
405
if (!banner_printed) {
406
pr_info("Uniform CD-ROM driver " REVISION "\n");
408
cdrom_sysctl_register();
411
ENSURE(drive_status, CDC_DRIVE_STATUS );
412
if (cdo->check_events == NULL && cdo->media_changed == NULL)
413
*change_capability = ~(CDC_MEDIA_CHANGED | CDC_SELECT_DISC);
414
ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
415
ENSURE(lock_door, CDC_LOCK);
416
ENSURE(select_speed, CDC_SELECT_SPEED);
417
ENSURE(get_last_session, CDC_MULTI_SESSION);
418
ENSURE(get_mcn, CDC_MCN);
419
ENSURE(reset, CDC_RESET);
420
ENSURE(generic_packet, CDC_GENERIC_PACKET);
423
cdi->options = CDO_USE_FFLAGS;
425
if (autoclose==1 && CDROM_CAN(CDC_CLOSE_TRAY))
426
cdi->options |= (int) CDO_AUTO_CLOSE;
427
if (autoeject==1 && CDROM_CAN(CDC_OPEN_TRAY))
428
cdi->options |= (int) CDO_AUTO_EJECT;
430
cdi->options |= (int) CDO_LOCK;
431
if (check_media_type==1)
432
cdi->options |= (int) CDO_CHECK_TYPE;
434
if (CDROM_CAN(CDC_MRW_W))
435
cdi->exit = cdrom_mrw_exit;
438
cdi->cdda_method = CDDA_BPC_FULL;
440
cdi->cdda_method = CDDA_OLD;
442
if (!cdo->generic_packet)
443
cdo->generic_packet = cdrom_dummy_generic_packet;
445
cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
446
mutex_lock(&cdrom_mutex);
447
list_add(&cdi->list, &cdrom_list);
448
mutex_unlock(&cdrom_mutex);
453
void unregister_cdrom(struct cdrom_device_info *cdi)
455
cdinfo(CD_OPEN, "entering unregister_cdrom\n");
457
mutex_lock(&cdrom_mutex);
458
list_del(&cdi->list);
459
mutex_unlock(&cdrom_mutex);
464
cdi->ops->n_minors--;
465
cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
468
int cdrom_get_media_event(struct cdrom_device_info *cdi,
469
struct media_event_desc *med)
471
struct packet_command cgc;
472
unsigned char buffer[8];
473
struct event_header *eh = (struct event_header *) buffer;
475
init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
476
cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
477
cgc.cmd[1] = 1; /* IMMED */
478
cgc.cmd[4] = 1 << 4; /* media event */
479
cgc.cmd[8] = sizeof(buffer);
482
if (cdi->ops->generic_packet(cdi, &cgc))
485
if (be16_to_cpu(eh->data_len) < sizeof(*med))
488
if (eh->nea || eh->notification_class != 0x4)
491
memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
496
* the first prototypes used 0x2c as the page code for the mrw mode page,
497
* subsequently this was changed to 0x03. probe the one used by this drive
499
static int cdrom_mrw_probe_pc(struct cdrom_device_info *cdi)
501
struct packet_command cgc;
504
init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
509
if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC, 0)) {
510
cdi->mrw_mode_page = MRW_MODE_PC;
512
} else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
513
cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
520
static int cdrom_is_mrw(struct cdrom_device_info *cdi, int *write)
522
struct packet_command cgc;
523
struct mrw_feature_desc *mfd;
524
unsigned char buffer[16];
529
init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
531
cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
532
cgc.cmd[3] = CDF_MRW;
533
cgc.cmd[8] = sizeof(buffer);
536
if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
539
mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
540
if (be16_to_cpu(mfd->feature_code) != CDF_MRW)
544
if ((ret = cdrom_mrw_probe_pc(cdi))) {
552
static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
554
struct packet_command cgc;
555
unsigned char buffer[12];
558
pr_info("%sstarting format\n", cont ? "Re" : "");
561
* FmtData bit set (bit 4), format type is 1
563
init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_WRITE);
564
cgc.cmd[0] = GPCMD_FORMAT_UNIT;
565
cgc.cmd[1] = (1 << 4) | 1;
567
cgc.timeout = 5 * 60 * HZ;
570
* 4 byte format list header, 8 byte format list descriptor
583
buffer[8] = 0x24 << 2;
586
ret = cdi->ops->generic_packet(cdi, &cgc);
588
pr_info("bgformat failed\n");
593
static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
595
struct packet_command cgc;
597
init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
598
cgc.cmd[0] = GPCMD_CLOSE_TRACK;
601
* Session = 1, Track = 0
603
cgc.cmd[1] = !!immed;
606
cgc.timeout = 5 * 60 * HZ;
608
return cdi->ops->generic_packet(cdi, &cgc);
611
static int cdrom_flush_cache(struct cdrom_device_info *cdi)
613
struct packet_command cgc;
615
init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
616
cgc.cmd[0] = GPCMD_FLUSH_CACHE;
618
cgc.timeout = 5 * 60 * HZ;
620
return cdi->ops->generic_packet(cdi, &cgc);
623
static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
628
ret = cdrom_get_disc_info(cdi, &di);
629
if (ret < 0 || ret < (int)offsetof(typeof(di),disc_type))
633
if (di.mrw_status == CDM_MRW_BGFORMAT_ACTIVE) {
634
pr_info("issuing MRW background format suspend\n");
635
ret = cdrom_mrw_bgformat_susp(cdi, 0);
638
if (!ret && cdi->media_written)
639
ret = cdrom_flush_cache(cdi);
644
static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
646
struct packet_command cgc;
647
struct mode_page_header *mph;
649
int ret, offset, size;
651
init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
654
cgc.buflen = sizeof(buffer);
656
if ((ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0)))
659
mph = (struct mode_page_header *) buffer;
660
offset = be16_to_cpu(mph->desc_length);
661
size = be16_to_cpu(mph->mode_data_length) + 2;
663
buffer[offset + 3] = space;
666
if ((ret = cdrom_mode_select(cdi, &cgc)))
669
pr_info("%s: mrw address space %s selected\n",
670
cdi->name, mrw_address_space[space]);
674
static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
675
struct rwrt_feature_desc *rfd)
677
struct packet_command cgc;
681
init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
683
cgc.cmd[0] = GPCMD_GET_CONFIGURATION; /* often 0x46 */
684
cgc.cmd[3] = CDF_RWRT; /* often 0x0020 */
685
cgc.cmd[8] = sizeof(buffer); /* often 0x18 */
688
if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
691
memcpy(rfd, &buffer[sizeof(struct feature_header)], sizeof (*rfd));
695
static int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
697
struct packet_command cgc;
699
__be16 *feature_code;
702
init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
704
cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
705
cgc.cmd[3] = CDF_HWDM;
706
cgc.cmd[8] = sizeof(buffer);
709
if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
712
feature_code = (__be16 *) &buffer[sizeof(struct feature_header)];
713
if (be16_to_cpu(*feature_code) == CDF_HWDM)
720
static int cdrom_is_random_writable(struct cdrom_device_info *cdi, int *write)
722
struct rwrt_feature_desc rfd;
727
if ((ret = cdrom_get_random_writable(cdi, &rfd)))
730
if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
736
static int cdrom_media_erasable(struct cdrom_device_info *cdi)
741
ret = cdrom_get_disc_info(cdi, &di);
742
if (ret < 0 || ret < offsetof(typeof(di), n_first_track))
749
* FIXME: check RO bit
751
static int cdrom_dvdram_open_write(struct cdrom_device_info *cdi)
753
int ret = cdrom_media_erasable(cdi);
756
* allow writable open if media info read worked and media is
757
* erasable, _or_ if it fails since not all drives support it
765
static int cdrom_mrw_open_write(struct cdrom_device_info *cdi)
771
* always reset to DMA lba space on open
773
if (cdrom_mrw_set_lba_space(cdi, MRW_LBA_DMA)) {
774
pr_err("failed setting lba address space\n");
778
ret = cdrom_get_disc_info(cdi, &di);
779
if (ret < 0 || ret < offsetof(typeof(di),disc_type))
787
* 0 - not MRW formatted
788
* 1 - MRW bgformat started, but not running or complete
789
* 2 - MRW bgformat in progress
790
* 3 - MRW formatting complete
793
pr_info("open: mrw_status '%s'\n", mrw_format_status[di.mrw_status]);
796
else if (di.mrw_status == CDM_MRW_BGFORMAT_INACTIVE &&
798
ret = cdrom_mrw_bgformat(cdi, 1);
803
static int mo_open_write(struct cdrom_device_info *cdi)
805
struct packet_command cgc;
809
init_cdrom_command(&cgc, &buffer, 4, CGC_DATA_READ);
813
* obtain write protect information as per
814
* drivers/scsi/sd.c:sd_read_write_protect_flag
817
ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
819
ret = cdrom_mode_sense(cdi, &cgc, GPMODE_VENDOR_PAGE, 0);
822
ret = cdrom_mode_sense(cdi, &cgc, GPMODE_ALL_PAGES, 0);
825
/* drive gave us no info, let the user go ahead */
829
return buffer[3] & 0x80;
832
static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
834
struct rwrt_feature_desc rfd;
837
if ((ret = cdrom_has_defect_mgt(cdi)))
840
if ((ret = cdrom_get_random_writable(cdi, &rfd)))
842
else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
845
cdinfo(CD_OPEN, "can open for random write\n");
849
static void cdrom_mmc3_profile(struct cdrom_device_info *cdi)
851
struct packet_command cgc;
853
int ret, mmc3_profile;
855
init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
857
cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
859
cgc.cmd[2] = cgc.cmd[3] = 0; /* Starting Feature Number */
860
cgc.cmd[8] = sizeof(buffer); /* Allocation Length */
863
if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
864
mmc3_profile = 0xffff;
866
mmc3_profile = (buffer[6] << 8) | buffer[7];
868
cdi->mmc3_profile = mmc3_profile;
871
static int cdrom_is_dvd_rw(struct cdrom_device_info *cdi)
873
switch (cdi->mmc3_profile) {
874
case 0x12: /* DVD-RAM */
875
case 0x1A: /* DVD+RW */
883
* returns 0 for ok to open write, non-0 to disallow
885
static int cdrom_open_write(struct cdrom_device_info *cdi)
887
int mrw, mrw_write, ram_write;
891
if (!cdrom_is_mrw(cdi, &mrw_write))
894
if (CDROM_CAN(CDC_MO_DRIVE))
897
(void) cdrom_is_random_writable(cdi, &ram_write);
900
cdi->mask &= ~CDC_MRW;
902
cdi->mask |= CDC_MRW;
905
cdi->mask &= ~CDC_MRW_W;
907
cdi->mask |= CDC_MRW_W;
910
cdi->mask &= ~CDC_RAM;
912
cdi->mask |= CDC_RAM;
914
if (CDROM_CAN(CDC_MRW_W))
915
ret = cdrom_mrw_open_write(cdi);
916
else if (CDROM_CAN(CDC_DVD_RAM))
917
ret = cdrom_dvdram_open_write(cdi);
918
else if (CDROM_CAN(CDC_RAM) &&
919
!CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW|CDC_MO_DRIVE))
920
ret = cdrom_ram_open_write(cdi);
921
else if (CDROM_CAN(CDC_MO_DRIVE))
922
ret = mo_open_write(cdi);
923
else if (!cdrom_is_dvd_rw(cdi))
929
static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
931
struct packet_command cgc;
933
if (cdi->mmc3_profile != 0x1a) {
934
cdinfo(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
938
if (!cdi->media_written) {
939
cdinfo(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
943
pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi->name);
945
init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
946
cgc.cmd[0] = GPCMD_FLUSH_CACHE;
948
cdi->ops->generic_packet(cdi, &cgc);
950
init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
951
cgc.cmd[0] = GPCMD_CLOSE_TRACK;
952
cgc.timeout = 3000*HZ;
954
cdi->ops->generic_packet(cdi, &cgc);
956
init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
957
cgc.cmd[0] = GPCMD_CLOSE_TRACK;
958
cgc.cmd[2] = 2; /* Close session */
960
cgc.timeout = 3000*HZ;
961
cdi->ops->generic_packet(cdi, &cgc);
963
cdi->media_written = 0;
966
static int cdrom_close_write(struct cdrom_device_info *cdi)
969
return cdrom_flush_cache(cdi);
975
/* We use the open-option O_NONBLOCK to indicate that the
976
* purpose of opening is only for subsequent ioctl() calls; no device
977
* integrity checks are performed.
979
* We hope that all cd-player programs will adopt this convention. It
980
* is in their own interest: device control becomes a lot easier
983
int cdrom_open(struct cdrom_device_info *cdi, struct block_device *bdev, fmode_t mode)
987
cdinfo(CD_OPEN, "entering cdrom_open\n");
989
/* open is event synchronization point, check events first */
990
check_disk_change(bdev);
992
/* if this was a O_NONBLOCK open and we should honor the flags,
993
* do a quick open without drive/disc integrity checks. */
995
if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) {
996
ret = cdi->ops->open(cdi, 1);
998
ret = open_for_data(cdi);
1001
cdrom_mmc3_profile(cdi);
1002
if (mode & FMODE_WRITE) {
1004
if (cdrom_open_write(cdi))
1006
if (!CDROM_CAN(CDC_RAM))
1009
cdi->media_written = 0;
1016
cdinfo(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1017
cdi->name, cdi->use_count);
1020
if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1021
cdi->ops->lock_door(cdi, 0);
1022
cdinfo(CD_OPEN, "door unlocked.\n");
1024
cdi->ops->release(cdi);
1031
int open_for_data(struct cdrom_device_info * cdi)
1034
struct cdrom_device_ops *cdo = cdi->ops;
1036
cdinfo(CD_OPEN, "entering open_for_data\n");
1037
/* Check if the driver can report drive status. If it can, we
1038
can do clever things. If it can't, well, we at least tried! */
1039
if (cdo->drive_status != NULL) {
1040
ret = cdo->drive_status(cdi, CDSL_CURRENT);
1041
cdinfo(CD_OPEN, "drive_status=%d\n", ret);
1042
if (ret == CDS_TRAY_OPEN) {
1043
cdinfo(CD_OPEN, "the tray is open...\n");
1044
/* can/may i close it? */
1045
if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1046
cdi->options & CDO_AUTO_CLOSE) {
1047
cdinfo(CD_OPEN, "trying to close the tray.\n");
1048
ret=cdo->tray_move(cdi,0);
1050
cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1051
/* Ignore the error from the low
1052
level driver. We don't care why it
1053
couldn't close the tray. We only care
1054
that there is no disc in the drive,
1055
since that is the _REAL_ problem here.*/
1057
goto clean_up_and_return;
1060
cdinfo(CD_OPEN, "bummer. this drive can't close the tray.\n");
1062
goto clean_up_and_return;
1064
/* Ok, the door should be closed now.. Check again */
1065
ret = cdo->drive_status(cdi, CDSL_CURRENT);
1066
if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1067
cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
1068
cdinfo(CD_OPEN, "tray might not contain a medium.\n");
1070
goto clean_up_and_return;
1072
cdinfo(CD_OPEN, "the tray is now closed.\n");
1074
/* the door should be closed now, check for the disc */
1075
ret = cdo->drive_status(cdi, CDSL_CURRENT);
1076
if (ret!=CDS_DISC_OK) {
1078
goto clean_up_and_return;
1081
cdrom_count_tracks(cdi, &tracks);
1082
if (tracks.error == CDS_NO_DISC) {
1083
cdinfo(CD_OPEN, "bummer. no disc.\n");
1085
goto clean_up_and_return;
1087
/* CD-Players which don't use O_NONBLOCK, workman
1088
* for example, need bit CDO_CHECK_TYPE cleared! */
1089
if (tracks.data==0) {
1090
if (cdi->options & CDO_CHECK_TYPE) {
1091
/* give people a warning shot, now that CDO_CHECK_TYPE
1092
is the default case! */
1093
cdinfo(CD_OPEN, "bummer. wrong media type.\n");
1094
cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1095
(unsigned int)task_pid_nr(current));
1097
goto clean_up_and_return;
1100
cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.\n");
1104
cdinfo(CD_OPEN, "all seems well, opening the device.\n");
1106
/* all seems well, we can open the device */
1107
ret = cdo->open(cdi, 0); /* open for data */
1108
cdinfo(CD_OPEN, "opening the device gave me %d.\n", ret);
1109
/* After all this careful checking, we shouldn't have problems
1110
opening the device, but we don't want the device locked if
1111
this somehow fails... */
1113
cdinfo(CD_OPEN, "open device failed.\n");
1114
goto clean_up_and_return;
1116
if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1117
cdo->lock_door(cdi, 1);
1118
cdinfo(CD_OPEN, "door locked.\n");
1120
cdinfo(CD_OPEN, "device opened successfully.\n");
1123
/* Something failed. Try to unlock the drive, because some drivers
1124
(notably ide-cd) lock the drive after every command. This produced
1125
a nasty bug where after mount failed, the drive would remain locked!
1126
This ensures that the drive gets unlocked after a mount fails. This
1127
is a goto to avoid bloating the driver with redundant code. */
1128
clean_up_and_return:
1129
cdinfo(CD_OPEN, "open failed.\n");
1130
if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1131
cdo->lock_door(cdi, 0);
1132
cdinfo(CD_OPEN, "door unlocked.\n");
1137
/* This code is similar to that in open_for_data. The routine is called
1138
whenever an audio play operation is requested.
1140
static int check_for_audio_disc(struct cdrom_device_info * cdi,
1141
struct cdrom_device_ops * cdo)
1145
cdinfo(CD_OPEN, "entering check_for_audio_disc\n");
1146
if (!(cdi->options & CDO_CHECK_TYPE))
1148
if (cdo->drive_status != NULL) {
1149
ret = cdo->drive_status(cdi, CDSL_CURRENT);
1150
cdinfo(CD_OPEN, "drive_status=%d\n", ret);
1151
if (ret == CDS_TRAY_OPEN) {
1152
cdinfo(CD_OPEN, "the tray is open...\n");
1153
/* can/may i close it? */
1154
if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1155
cdi->options & CDO_AUTO_CLOSE) {
1156
cdinfo(CD_OPEN, "trying to close the tray.\n");
1157
ret=cdo->tray_move(cdi,0);
1159
cdinfo(CD_OPEN, "bummer. tried to close tray but failed.\n");
1160
/* Ignore the error from the low
1161
level driver. We don't care why it
1162
couldn't close the tray. We only care
1163
that there is no disc in the drive,
1164
since that is the _REAL_ problem here.*/
1168
cdinfo(CD_OPEN, "bummer. this driver can't close the tray.\n");
1171
/* Ok, the door should be closed now.. Check again */
1172
ret = cdo->drive_status(cdi, CDSL_CURRENT);
1173
if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1174
cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
1177
if (ret!=CDS_DISC_OK) {
1178
cdinfo(CD_OPEN, "bummer. disc isn't ready.\n");
1181
cdinfo(CD_OPEN, "the tray is now closed.\n");
1184
cdrom_count_tracks(cdi, &tracks);
1186
return(tracks.error);
1188
if (tracks.audio==0)
1189
return -EMEDIUMTYPE;
1194
void cdrom_release(struct cdrom_device_info *cdi, fmode_t mode)
1196
struct cdrom_device_ops *cdo = cdi->ops;
1197
int opened_for_data;
1199
cdinfo(CD_CLOSE, "entering cdrom_release\n");
1201
if (cdi->use_count > 0)
1204
if (cdi->use_count == 0) {
1205
cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
1206
cdrom_dvd_rw_close_write(cdi);
1208
if ((cdo->capability & CDC_LOCK) && !keeplocked) {
1209
cdinfo(CD_CLOSE, "Unlocking door!\n");
1210
cdo->lock_door(cdi, 0);
1214
opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1215
!(mode & FMODE_NDELAY);
1218
* flush cache on last write release
1220
if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1221
cdrom_close_write(cdi);
1224
if (cdi->use_count == 0) { /* last process that closes dev*/
1225
if (opened_for_data &&
1226
cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1227
cdo->tray_move(cdi, 1);
1231
static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
1232
struct cdrom_changer_info *buf)
1234
struct packet_command cgc;
1235
struct cdrom_device_ops *cdo = cdi->ops;
1239
* Sanyo changer isn't spec compliant (doesn't use regular change
1240
* LOAD_UNLOAD command, and it doesn't implement the mech status
1243
if (cdi->sanyo_slot) {
1244
buf->hdr.nslots = 3;
1245
buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1246
for (length = 0; length < 3; length++) {
1247
buf->slots[length].disc_present = 1;
1248
buf->slots[length].change = 0;
1253
length = sizeof(struct cdrom_mechstat_header) +
1254
cdi->capacity * sizeof(struct cdrom_slot);
1256
init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1257
cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1258
cgc.cmd[8] = (length >> 8) & 0xff;
1259
cgc.cmd[9] = length & 0xff;
1260
return cdo->generic_packet(cdi, &cgc);
1263
static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1265
struct cdrom_changer_info *info;
1268
cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n");
1269
if (cdi->sanyo_slot)
1272
info = kmalloc(sizeof(*info), GFP_KERNEL);
1276
if ((ret = cdrom_read_mech_status(cdi, info)))
1279
if (info->slots[slot].disc_present)
1289
/* Return the number of slots for an ATAPI/SCSI cdrom,
1290
* return 1 if not a changer.
1292
int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1296
struct cdrom_changer_info *info;
1298
cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1299
/* cdrom_read_mech_status requires a valid value for capacity: */
1302
info = kmalloc(sizeof(*info), GFP_KERNEL);
1306
if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1307
nslots = info->hdr.nslots;
1314
/* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
1315
static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1317
struct packet_command cgc;
1319
cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n");
1320
if (cdi->sanyo_slot && slot < 0)
1323
init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1324
cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1325
cgc.cmd[4] = 2 + (slot >= 0);
1327
cgc.timeout = 60 * HZ;
1329
/* The Sanyo 3 CD changer uses byte 7 of the
1330
GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1331
using the GPCMD_LOAD_UNLOAD opcode. */
1332
if (cdi->sanyo_slot && -1 < slot) {
1333
cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1335
cgc.cmd[4] = cgc.cmd[8] = 0;
1336
cdi->sanyo_slot = slot ? slot : 3;
1339
return cdi->ops->generic_packet(cdi, &cgc);
1342
static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1344
struct cdrom_changer_info *info;
1348
cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n");
1349
if (!CDROM_CAN(CDC_SELECT_DISC))
1350
return -EDRIVE_CANT_DO_THIS;
1352
if (cdi->ops->check_events)
1353
cdi->ops->check_events(cdi, 0, slot);
1355
cdi->ops->media_changed(cdi, slot);
1357
if (slot == CDSL_NONE) {
1358
/* set media changed bits, on both queues */
1359
cdi->mc_flags = 0x3;
1360
return cdrom_load_unload(cdi, -1);
1363
info = kmalloc(sizeof(*info), GFP_KERNEL);
1367
if ((ret = cdrom_read_mech_status(cdi, info))) {
1372
curslot = info->hdr.curslot;
1375
if (cdi->use_count > 1 || keeplocked) {
1376
if (slot == CDSL_CURRENT) {
1383
/* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1384
which is useful if it had been previously unloaded.
1385
Whether it can or not, it returns the current slot.
1386
Similarly, if slot happens to be the current one, we still
1388
if (slot == CDSL_CURRENT)
1391
/* set media changed bits on both queues */
1392
cdi->mc_flags = 0x3;
1393
if ((ret = cdrom_load_unload(cdi, slot)))
1400
* As cdrom implements an extra ioctl consumer for media changed
1401
* event, it needs to buffer ->check_events() output, such that event
1402
* is not lost for both the usual VFS and ioctl paths.
1403
* cdi->{vfs|ioctl}_events are used to buffer pending events for each
1406
* XXX: Locking is non-existent. cdi->ops->check_events() can be
1407
* called in parallel and buffering fields are accessed without any
1408
* exclusion. The original media_changed code had the same problem.
1409
* It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1410
* and remove this cruft altogether. It doesn't have much usefulness
1413
static void cdrom_update_events(struct cdrom_device_info *cdi,
1414
unsigned int clearing)
1416
unsigned int events;
1418
events = cdi->ops->check_events(cdi, clearing, CDSL_CURRENT);
1419
cdi->vfs_events |= events;
1420
cdi->ioctl_events |= events;
1423
unsigned int cdrom_check_events(struct cdrom_device_info *cdi,
1424
unsigned int clearing)
1426
unsigned int events;
1428
cdrom_update_events(cdi, clearing);
1429
events = cdi->vfs_events;
1430
cdi->vfs_events = 0;
1433
EXPORT_SYMBOL(cdrom_check_events);
1435
/* We want to make media_changed accessible to the user through an
1436
* ioctl. The main problem now is that we must double-buffer the
1437
* low-level implementation, to assure that the VFS and the user both
1438
* see a medium change once.
1442
int media_changed(struct cdrom_device_info *cdi, int queue)
1444
unsigned int mask = (1 << (queue & 1));
1445
int ret = !!(cdi->mc_flags & mask);
1448
if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1451
/* changed since last call? */
1452
if (cdi->ops->check_events) {
1453
BUG_ON(!queue); /* shouldn't be called from VFS path */
1454
cdrom_update_events(cdi, DISK_EVENT_MEDIA_CHANGE);
1455
changed = cdi->ioctl_events & DISK_EVENT_MEDIA_CHANGE;
1456
cdi->ioctl_events = 0;
1458
changed = cdi->ops->media_changed(cdi, CDSL_CURRENT);
1461
cdi->mc_flags = 0x3; /* set bit on both queues */
1463
cdi->media_written = 0;
1466
cdi->mc_flags &= ~mask; /* clear bit */
1470
int cdrom_media_changed(struct cdrom_device_info *cdi)
1472
/* This talks to the VFS, which doesn't like errors - just 1 or 0.
1473
* Returning "0" is always safe (media hasn't been changed). Do that
1474
* if the low-level cdrom driver dosn't support media changed. */
1475
if (cdi == NULL || cdi->ops->media_changed == NULL)
1477
if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1479
return media_changed(cdi, 0);
1482
/* badly broken, I know. Is due for a fixup anytime. */
1483
static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1485
struct cdrom_tochdr header;
1486
struct cdrom_tocentry entry;
1493
cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1494
/* Grab the TOC header so we can see how many tracks there are */
1495
if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1496
if (ret == -ENOMEDIUM)
1497
tracks->error = CDS_NO_DISC;
1499
tracks->error = CDS_NO_INFO;
1502
/* check what type of tracks are on this disc */
1503
entry.cdte_format = CDROM_MSF;
1504
for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1505
entry.cdte_track = i;
1506
if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1507
tracks->error=CDS_NO_INFO;
1510
if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1511
if (entry.cdte_format == 0x10)
1513
else if (entry.cdte_format == 0x20)
1519
cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1520
i, entry.cdte_format, entry.cdte_ctrl);
1522
cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1523
header.cdth_trk1, tracks->audio, tracks->data,
1524
tracks->cdi, tracks->xa);
1527
/* Requests to the low-level drivers will /always/ be done in the
1528
following format convention:
1530
CDROM_LBA: all data-related requests.
1531
CDROM_MSF: all audio-related requests.
1533
However, a low-level implementation is allowed to refuse this
1534
request, and return information in its own favorite format.
1536
It doesn't make sense /at all/ to ask for a play_audio in LBA
1537
format, or ask for multi-session info in MSF format. However, for
1538
backward compatibility these format requests will be satisfied, but
1539
the requests to the low-level drivers will be sanitized in the more
1540
meaningful format indicated above.
1544
void sanitize_format(union cdrom_addr *addr,
1545
u_char * curr, u_char requested)
1547
if (*curr == requested)
1548
return; /* nothing to be done! */
1549
if (requested == CDROM_LBA) {
1550
addr->lba = (int) addr->msf.frame +
1551
75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1552
} else { /* CDROM_MSF */
1553
int lba = addr->lba;
1554
addr->msf.frame = lba % 75;
1557
addr->msf.second = lba % 60;
1558
addr->msf.minute = lba / 60;
1563
void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1566
memset(cgc, 0, sizeof(struct packet_command));
1568
memset(buf, 0, len);
1569
cgc->buffer = (char *) buf;
1571
cgc->data_direction = type;
1572
cgc->timeout = CDROM_DEF_TIMEOUT;
1577
#define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
1578
#define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
1580
static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1582
cgc->cmd[0] = GPCMD_REPORT_KEY;
1583
cgc->cmd[10] = type | (agid << 6);
1585
case 0: case 8: case 5: {
1598
cgc->cmd[9] = cgc->buflen;
1599
cgc->data_direction = CGC_DATA_READ;
1602
static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1604
cgc->cmd[0] = GPCMD_SEND_KEY;
1605
cgc->cmd[10] = type | (agid << 6);
1620
cgc->cmd[9] = cgc->buflen;
1621
cgc->data_direction = CGC_DATA_WRITE;
1624
static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1628
struct packet_command cgc;
1629
struct cdrom_device_ops *cdo = cdi->ops;
1630
rpc_state_t rpc_state;
1632
memset(buf, 0, sizeof(buf));
1633
init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1637
case DVD_LU_SEND_AGID:
1638
cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1640
setup_report_key(&cgc, ai->lsa.agid, 0);
1642
if ((ret = cdo->generic_packet(cdi, &cgc)))
1645
ai->lsa.agid = buf[7] >> 6;
1646
/* Returning data, let host change state */
1649
case DVD_LU_SEND_KEY1:
1650
cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1651
setup_report_key(&cgc, ai->lsk.agid, 2);
1653
if ((ret = cdo->generic_packet(cdi, &cgc)))
1656
copy_key(ai->lsk.key, &buf[4]);
1657
/* Returning data, let host change state */
1660
case DVD_LU_SEND_CHALLENGE:
1661
cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1662
setup_report_key(&cgc, ai->lsc.agid, 1);
1664
if ((ret = cdo->generic_packet(cdi, &cgc)))
1667
copy_chal(ai->lsc.chal, &buf[4]);
1668
/* Returning data, let host change state */
1672
case DVD_LU_SEND_TITLE_KEY:
1673
cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1675
setup_report_key(&cgc, ai->lstk.agid, 4);
1676
cgc.cmd[5] = ai->lstk.lba;
1677
cgc.cmd[4] = ai->lstk.lba >> 8;
1678
cgc.cmd[3] = ai->lstk.lba >> 16;
1679
cgc.cmd[2] = ai->lstk.lba >> 24;
1681
if ((ret = cdo->generic_packet(cdi, &cgc)))
1684
ai->lstk.cpm = (buf[4] >> 7) & 1;
1685
ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1686
ai->lstk.cgms = (buf[4] >> 4) & 3;
1687
copy_key(ai->lstk.title_key, &buf[5]);
1688
/* Returning data, let host change state */
1691
case DVD_LU_SEND_ASF:
1692
cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1693
setup_report_key(&cgc, ai->lsasf.agid, 5);
1695
if ((ret = cdo->generic_packet(cdi, &cgc)))
1698
ai->lsasf.asf = buf[7] & 1;
1701
/* LU data receive (LU changes state) */
1702
case DVD_HOST_SEND_CHALLENGE:
1703
cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1704
setup_send_key(&cgc, ai->hsc.agid, 1);
1706
copy_chal(&buf[4], ai->hsc.chal);
1708
if ((ret = cdo->generic_packet(cdi, &cgc)))
1711
ai->type = DVD_LU_SEND_KEY1;
1714
case DVD_HOST_SEND_KEY2:
1715
cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1716
setup_send_key(&cgc, ai->hsk.agid, 3);
1718
copy_key(&buf[4], ai->hsk.key);
1720
if ((ret = cdo->generic_packet(cdi, &cgc))) {
1721
ai->type = DVD_AUTH_FAILURE;
1724
ai->type = DVD_AUTH_ESTABLISHED;
1728
case DVD_INVALIDATE_AGID:
1730
cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1731
setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1732
if ((ret = cdo->generic_packet(cdi, &cgc)))
1736
/* Get region settings */
1737
case DVD_LU_SEND_RPC_STATE:
1738
cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1739
setup_report_key(&cgc, 0, 8);
1740
memset(&rpc_state, 0, sizeof(rpc_state_t));
1741
cgc.buffer = (char *) &rpc_state;
1743
if ((ret = cdo->generic_packet(cdi, &cgc)))
1746
ai->lrpcs.type = rpc_state.type_code;
1747
ai->lrpcs.vra = rpc_state.vra;
1748
ai->lrpcs.ucca = rpc_state.ucca;
1749
ai->lrpcs.region_mask = rpc_state.region_mask;
1750
ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1753
/* Set region settings */
1754
case DVD_HOST_SEND_RPC_STATE:
1755
cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1756
setup_send_key(&cgc, 0, 6);
1758
buf[4] = ai->hrpcs.pdrc;
1760
if ((ret = cdo->generic_packet(cdi, &cgc)))
1765
cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1772
static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s,
1773
struct packet_command *cgc)
1775
unsigned char buf[21], *base;
1776
struct dvd_layer *layer;
1777
struct cdrom_device_ops *cdo = cdi->ops;
1778
int ret, layer_num = s->physical.layer_num;
1780
if (layer_num >= DVD_LAYERS)
1783
init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1784
cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1785
cgc->cmd[6] = layer_num;
1786
cgc->cmd[7] = s->type;
1787
cgc->cmd[9] = cgc->buflen & 0xff;
1790
* refrain from reporting errors on non-existing layers (mainly)
1794
ret = cdo->generic_packet(cdi, cgc);
1799
layer = &s->physical.layer[layer_num];
1802
* place the data... really ugly, but at least we won't have to
1803
* worry about endianess in userspace.
1805
memset(layer, 0, sizeof(*layer));
1806
layer->book_version = base[0] & 0xf;
1807
layer->book_type = base[0] >> 4;
1808
layer->min_rate = base[1] & 0xf;
1809
layer->disc_size = base[1] >> 4;
1810
layer->layer_type = base[2] & 0xf;
1811
layer->track_path = (base[2] >> 4) & 1;
1812
layer->nlayers = (base[2] >> 5) & 3;
1813
layer->track_density = base[3] & 0xf;
1814
layer->linear_density = base[3] >> 4;
1815
layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1816
layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1817
layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1818
layer->bca = base[16] >> 7;
1823
static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s,
1824
struct packet_command *cgc)
1828
struct cdrom_device_ops *cdo = cdi->ops;
1830
init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1831
cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1832
cgc->cmd[6] = s->copyright.layer_num;
1833
cgc->cmd[7] = s->type;
1834
cgc->cmd[8] = cgc->buflen >> 8;
1835
cgc->cmd[9] = cgc->buflen & 0xff;
1837
ret = cdo->generic_packet(cdi, cgc);
1841
s->copyright.cpst = buf[4];
1842
s->copyright.rmi = buf[5];
1847
static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s,
1848
struct packet_command *cgc)
1852
struct cdrom_device_ops *cdo = cdi->ops;
1854
size = sizeof(s->disckey.value) + 4;
1856
buf = kmalloc(size, GFP_KERNEL);
1860
init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1861
cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1862
cgc->cmd[7] = s->type;
1863
cgc->cmd[8] = size >> 8;
1864
cgc->cmd[9] = size & 0xff;
1865
cgc->cmd[10] = s->disckey.agid << 6;
1867
ret = cdo->generic_packet(cdi, cgc);
1869
memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1875
static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1876
struct packet_command *cgc)
1878
int ret, size = 4 + 188;
1880
struct cdrom_device_ops *cdo = cdi->ops;
1882
buf = kmalloc(size, GFP_KERNEL);
1886
init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1887
cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1888
cgc->cmd[7] = s->type;
1889
cgc->cmd[9] = cgc->buflen & 0xff;
1891
ret = cdo->generic_packet(cdi, cgc);
1895
s->bca.len = buf[0] << 8 | buf[1];
1896
if (s->bca.len < 12 || s->bca.len > 188) {
1897
cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1901
memcpy(s->bca.value, &buf[4], s->bca.len);
1908
static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1909
struct packet_command *cgc)
1913
struct cdrom_device_ops *cdo = cdi->ops;
1915
size = sizeof(s->manufact.value) + 4;
1917
buf = kmalloc(size, GFP_KERNEL);
1921
init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1922
cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1923
cgc->cmd[7] = s->type;
1924
cgc->cmd[8] = size >> 8;
1925
cgc->cmd[9] = size & 0xff;
1927
ret = cdo->generic_packet(cdi, cgc);
1931
s->manufact.len = buf[0] << 8 | buf[1];
1932
if (s->manufact.len < 0) {
1933
cdinfo(CD_WARNING, "Received invalid manufacture info length"
1934
" (%d)\n", s->manufact.len);
1937
if (s->manufact.len > 2048) {
1938
cdinfo(CD_WARNING, "Received invalid manufacture info "
1939
"length (%d): truncating to 2048\n",
1941
s->manufact.len = 2048;
1943
memcpy(s->manufact.value, &buf[4], s->manufact.len);
1951
static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1952
struct packet_command *cgc)
1955
case DVD_STRUCT_PHYSICAL:
1956
return dvd_read_physical(cdi, s, cgc);
1958
case DVD_STRUCT_COPYRIGHT:
1959
return dvd_read_copyright(cdi, s, cgc);
1961
case DVD_STRUCT_DISCKEY:
1962
return dvd_read_disckey(cdi, s, cgc);
1964
case DVD_STRUCT_BCA:
1965
return dvd_read_bca(cdi, s, cgc);
1967
case DVD_STRUCT_MANUFACT:
1968
return dvd_read_manufact(cdi, s, cgc);
1971
cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1977
int cdrom_mode_sense(struct cdrom_device_info *cdi,
1978
struct packet_command *cgc,
1979
int page_code, int page_control)
1981
struct cdrom_device_ops *cdo = cdi->ops;
1983
memset(cgc->cmd, 0, sizeof(cgc->cmd));
1985
cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1986
cgc->cmd[2] = page_code | (page_control << 6);
1987
cgc->cmd[7] = cgc->buflen >> 8;
1988
cgc->cmd[8] = cgc->buflen & 0xff;
1989
cgc->data_direction = CGC_DATA_READ;
1990
return cdo->generic_packet(cdi, cgc);
1993
int cdrom_mode_select(struct cdrom_device_info *cdi,
1994
struct packet_command *cgc)
1996
struct cdrom_device_ops *cdo = cdi->ops;
1998
memset(cgc->cmd, 0, sizeof(cgc->cmd));
1999
memset(cgc->buffer, 0, 2);
2000
cgc->cmd[0] = GPCMD_MODE_SELECT_10;
2001
cgc->cmd[1] = 0x10; /* PF */
2002
cgc->cmd[7] = cgc->buflen >> 8;
2003
cgc->cmd[8] = cgc->buflen & 0xff;
2004
cgc->data_direction = CGC_DATA_WRITE;
2005
return cdo->generic_packet(cdi, cgc);
2008
static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
2009
struct cdrom_subchnl *subchnl, int mcn)
2011
struct cdrom_device_ops *cdo = cdi->ops;
2012
struct packet_command cgc;
2016
init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
2017
cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
2018
cgc.cmd[1] = 2; /* MSF addressing */
2019
cgc.cmd[2] = 0x40; /* request subQ data */
2020
cgc.cmd[3] = mcn ? 2 : 1;
2023
if ((ret = cdo->generic_packet(cdi, &cgc)))
2026
subchnl->cdsc_audiostatus = cgc.buffer[1];
2027
subchnl->cdsc_format = CDROM_MSF;
2028
subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
2029
subchnl->cdsc_trk = cgc.buffer[6];
2030
subchnl->cdsc_ind = cgc.buffer[7];
2032
subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
2033
subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
2034
subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
2035
subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
2036
subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
2037
subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
2043
* Specific READ_10 interface
2045
static int cdrom_read_cd(struct cdrom_device_info *cdi,
2046
struct packet_command *cgc, int lba,
2047
int blocksize, int nblocks)
2049
struct cdrom_device_ops *cdo = cdi->ops;
2051
memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2052
cgc->cmd[0] = GPCMD_READ_10;
2053
cgc->cmd[2] = (lba >> 24) & 0xff;
2054
cgc->cmd[3] = (lba >> 16) & 0xff;
2055
cgc->cmd[4] = (lba >> 8) & 0xff;
2056
cgc->cmd[5] = lba & 0xff;
2057
cgc->cmd[6] = (nblocks >> 16) & 0xff;
2058
cgc->cmd[7] = (nblocks >> 8) & 0xff;
2059
cgc->cmd[8] = nblocks & 0xff;
2060
cgc->buflen = blocksize * nblocks;
2061
return cdo->generic_packet(cdi, cgc);
2064
/* very generic interface for reading the various types of blocks */
2065
static int cdrom_read_block(struct cdrom_device_info *cdi,
2066
struct packet_command *cgc,
2067
int lba, int nblocks, int format, int blksize)
2069
struct cdrom_device_ops *cdo = cdi->ops;
2071
memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2072
cgc->cmd[0] = GPCMD_READ_CD;
2073
/* expected sector size - cdda,mode1,etc. */
2074
cgc->cmd[1] = format << 2;
2075
/* starting address */
2076
cgc->cmd[2] = (lba >> 24) & 0xff;
2077
cgc->cmd[3] = (lba >> 16) & 0xff;
2078
cgc->cmd[4] = (lba >> 8) & 0xff;
2079
cgc->cmd[5] = lba & 0xff;
2080
/* number of blocks */
2081
cgc->cmd[6] = (nblocks >> 16) & 0xff;
2082
cgc->cmd[7] = (nblocks >> 8) & 0xff;
2083
cgc->cmd[8] = nblocks & 0xff;
2084
cgc->buflen = blksize * nblocks;
2086
/* set the header info returned */
2088
case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
2089
case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
2090
case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
2091
default : cgc->cmd[9] = 0x10;
2094
return cdo->generic_packet(cdi, cgc);
2097
static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2098
int lba, int nframes)
2100
struct packet_command cgc;
2104
cdi->last_sense = 0;
2106
memset(&cgc, 0, sizeof(cgc));
2109
* start with will ra.nframes size, back down if alloc fails
2113
cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2123
if (!access_ok(VERIFY_WRITE, ubuf, nframes * CD_FRAMESIZE_RAW)) {
2128
cgc.data_direction = CGC_DATA_READ;
2129
while (nframes > 0) {
2133
ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2136
if (__copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2140
ubuf += CD_FRAMESIZE_RAW * nr;
2149
static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2150
int lba, int nframes)
2152
struct request_queue *q = cdi->disk->queue;
2161
cdi->last_sense = 0;
2165
if (cdi->cdda_method == CDDA_BPC_SINGLE)
2167
if (nr * CD_FRAMESIZE_RAW > (queue_max_sectors(q) << 9))
2168
nr = (queue_max_sectors(q) << 9) / CD_FRAMESIZE_RAW;
2170
len = nr * CD_FRAMESIZE_RAW;
2172
rq = blk_get_request(q, READ, GFP_KERNEL);
2178
ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL);
2180
blk_put_request(rq);
2184
rq->cmd[0] = GPCMD_READ_CD;
2185
rq->cmd[1] = 1 << 2;
2186
rq->cmd[2] = (lba >> 24) & 0xff;
2187
rq->cmd[3] = (lba >> 16) & 0xff;
2188
rq->cmd[4] = (lba >> 8) & 0xff;
2189
rq->cmd[5] = lba & 0xff;
2190
rq->cmd[6] = (nr >> 16) & 0xff;
2191
rq->cmd[7] = (nr >> 8) & 0xff;
2192
rq->cmd[8] = nr & 0xff;
2196
rq->cmd_type = REQ_TYPE_BLOCK_PC;
2197
rq->timeout = 60 * HZ;
2200
if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2201
struct request_sense *s = rq->sense;
2203
cdi->last_sense = s->sense_key;
2206
if (blk_rq_unmap_user(bio))
2208
blk_put_request(rq);
2221
static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2222
int lba, int nframes)
2226
if (cdi->cdda_method == CDDA_OLD)
2227
return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2231
* for anything else than success and io error, we need to retry
2233
ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2234
if (!ret || ret != -EIO)
2238
* I've seen drives get sense 4/8/3 udma crc errors on multi
2239
* frame dma, so drop to single frame dma if we need to
2241
if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2242
pr_info("dropping to single frame dma\n");
2243
cdi->cdda_method = CDDA_BPC_SINGLE;
2248
* so we have an io error of some sort with multi frame dma. if the
2249
* condition wasn't a hardware error
2250
* problems, not for any error
2252
if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2255
pr_info("dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2256
cdi->cdda_method = CDDA_OLD;
2257
return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2260
static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2263
struct cdrom_multisession ms_info;
2264
u8 requested_format;
2267
cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2269
if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2272
if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2275
requested_format = ms_info.addr_format;
2276
if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2278
ms_info.addr_format = CDROM_LBA;
2280
ret = cdi->ops->get_last_session(cdi, &ms_info);
2284
sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2286
if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2289
cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2293
static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2295
cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2297
if (!CDROM_CAN(CDC_OPEN_TRAY))
2299
if (cdi->use_count != 1 || keeplocked)
2301
if (CDROM_CAN(CDC_LOCK)) {
2302
int ret = cdi->ops->lock_door(cdi, 0);
2307
return cdi->ops->tray_move(cdi, 1);
2310
static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2312
cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2314
if (!CDROM_CAN(CDC_CLOSE_TRAY))
2316
return cdi->ops->tray_move(cdi, 0);
2319
static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2322
cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2324
if (!CDROM_CAN(CDC_OPEN_TRAY))
2329
cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2331
cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2335
static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2338
struct cdrom_changer_info *info;
2341
cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2343
if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2346
/* cannot select disc or select current disc */
2347
if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2348
return media_changed(cdi, 1);
2350
if ((unsigned int)arg >= cdi->capacity)
2353
info = kmalloc(sizeof(*info), GFP_KERNEL);
2357
ret = cdrom_read_mech_status(cdi, info);
2359
ret = info->slots[arg].change;
2364
static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2367
cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2370
* Options need to be in sync with capability.
2371
* Too late for that, so we have to check each one separately.
2374
case CDO_USE_FFLAGS:
2375
case CDO_CHECK_TYPE:
2378
if (!CDROM_CAN(CDC_LOCK))
2382
return cdi->options;
2383
/* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2385
if (!CDROM_CAN(arg))
2388
cdi->options |= (int) arg;
2389
return cdi->options;
2392
static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2395
cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2397
cdi->options &= ~(int) arg;
2398
return cdi->options;
2401
static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2404
cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2406
if (!CDROM_CAN(CDC_SELECT_SPEED))
2408
return cdi->ops->select_speed(cdi, arg);
2411
static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2414
cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2416
if (!CDROM_CAN(CDC_SELECT_DISC))
2419
if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2420
if ((int)arg >= cdi->capacity)
2425
* ->select_disc is a hook to allow a driver-specific way of
2426
* seleting disc. However, since there is no equivalent hook for
2427
* cdrom_slot_status this may not actually be useful...
2429
if (cdi->ops->select_disc)
2430
return cdi->ops->select_disc(cdi, arg);
2432
cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2433
return cdrom_select_disc(cdi, arg);
2436
static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2437
struct block_device *bdev)
2439
cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2441
if (!capable(CAP_SYS_ADMIN))
2443
if (!CDROM_CAN(CDC_RESET))
2445
invalidate_bdev(bdev);
2446
return cdi->ops->reset(cdi);
2449
static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2452
cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2454
if (!CDROM_CAN(CDC_LOCK))
2455
return -EDRIVE_CANT_DO_THIS;
2457
keeplocked = arg ? 1 : 0;
2460
* Don't unlock the door on multiple opens by default, but allow
2463
if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2465
return cdi->ops->lock_door(cdi, arg);
2468
static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2471
cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2473
if (!capable(CAP_SYS_ADMIN))
2475
debug = arg ? 1 : 0;
2479
static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2481
cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2482
return (cdi->ops->capability & ~cdi->mask);
2486
* The following function is implemented, although very few audio
2487
* discs give Universal Product Code information, which should just be
2488
* the Medium Catalog Number on the box. Note, that the way the code
2489
* is written on the CD is /not/ uniform across all discs!
2491
static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2494
struct cdrom_mcn mcn;
2497
cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2499
if (!(cdi->ops->capability & CDC_MCN))
2501
ret = cdi->ops->get_mcn(cdi, &mcn);
2505
if (copy_to_user(argp, &mcn, sizeof(mcn)))
2507
cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2511
static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2514
cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2516
if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2518
if (!CDROM_CAN(CDC_SELECT_DISC) ||
2519
(arg == CDSL_CURRENT || arg == CDSL_NONE))
2520
return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2521
if (((int)arg >= cdi->capacity))
2523
return cdrom_slot_status(cdi, arg);
2527
* Ok, this is where problems start. The current interface for the
2528
* CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2529
* CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunately, while this
2530
* is often the case, it is also very common for CDs to have some tracks
2531
* with data, and some tracks with audio. Just because I feel like it,
2532
* I declare the following to be the best way to cope. If the CD has ANY
2533
* data tracks on it, it will be returned as a data CD. If it has any XA
2534
* tracks, I will return it as that. Now I could simplify this interface
2535
* by combining these returns with the above, but this more clearly
2536
* demonstrates the problem with the current interface. Too bad this
2537
* wasn't designed to use bitmasks... -Erik
2539
* Well, now we have the option CDS_MIXED: a mixed-type CD.
2540
* User level programmers might feel the ioctl is not very useful.
2543
static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2547
cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2549
cdrom_count_tracks(cdi, &tracks);
2551
return tracks.error;
2553
/* Policy mode on */
2554
if (tracks.audio > 0) {
2555
if (!tracks.data && !tracks.cdi && !tracks.xa)
2565
if (tracks.data > 0)
2567
/* Policy mode off */
2569
cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2573
static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2575
cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2576
return cdi->capacity;
2579
static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2582
struct cdrom_subchnl q;
2586
/* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2588
if (copy_from_user(&q, argp, sizeof(q)))
2591
requested = q.cdsc_format;
2592
if (requested != CDROM_MSF && requested != CDROM_LBA)
2594
q.cdsc_format = CDROM_MSF;
2596
ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2600
back = q.cdsc_format; /* local copy */
2601
sanitize_format(&q.cdsc_absaddr, &back, requested);
2602
sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2604
if (copy_to_user(argp, &q, sizeof(q)))
2606
/* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2610
static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2613
struct cdrom_tochdr header;
2616
/* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2618
if (copy_from_user(&header, argp, sizeof(header)))
2621
ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2625
if (copy_to_user(argp, &header, sizeof(header)))
2627
/* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2631
static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2634
struct cdrom_tocentry entry;
2635
u8 requested_format;
2638
/* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2640
if (copy_from_user(&entry, argp, sizeof(entry)))
2643
requested_format = entry.cdte_format;
2644
if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2646
/* make interface to low-level uniform */
2647
entry.cdte_format = CDROM_MSF;
2648
ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2651
sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2653
if (copy_to_user(argp, &entry, sizeof(entry)))
2655
/* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2659
static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2662
struct cdrom_msf msf;
2664
cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2666
if (!CDROM_CAN(CDC_PLAY_AUDIO))
2668
if (copy_from_user(&msf, argp, sizeof(msf)))
2670
return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2673
static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2679
cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2681
if (!CDROM_CAN(CDC_PLAY_AUDIO))
2683
if (copy_from_user(&ti, argp, sizeof(ti)))
2686
ret = check_for_audio_disc(cdi, cdi->ops);
2689
return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2691
static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2694
struct cdrom_volctrl volume;
2696
cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2698
if (!CDROM_CAN(CDC_PLAY_AUDIO))
2700
if (copy_from_user(&volume, argp, sizeof(volume)))
2702
return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2705
static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2708
struct cdrom_volctrl volume;
2711
cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2713
if (!CDROM_CAN(CDC_PLAY_AUDIO))
2716
ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2720
if (copy_to_user(argp, &volume, sizeof(volume)))
2725
static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2730
cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2732
if (!CDROM_CAN(CDC_PLAY_AUDIO))
2734
ret = check_for_audio_disc(cdi, cdi->ops);
2737
return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2741
* Just about every imaginable ioctl is supported in the Uniform layer
2743
* ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2745
int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
2746
fmode_t mode, unsigned int cmd, unsigned long arg)
2748
void __user *argp = (void __user *)arg;
2750
struct gendisk *disk = bdev->bd_disk;
2753
* Try the generic SCSI command ioctl's first.
2755
ret = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, argp);
2760
case CDROMMULTISESSION:
2761
return cdrom_ioctl_multisession(cdi, argp);
2763
return cdrom_ioctl_eject(cdi);
2764
case CDROMCLOSETRAY:
2765
return cdrom_ioctl_closetray(cdi);
2767
return cdrom_ioctl_eject_sw(cdi, arg);
2768
case CDROM_MEDIA_CHANGED:
2769
return cdrom_ioctl_media_changed(cdi, arg);
2770
case CDROM_SET_OPTIONS:
2771
return cdrom_ioctl_set_options(cdi, arg);
2772
case CDROM_CLEAR_OPTIONS:
2773
return cdrom_ioctl_clear_options(cdi, arg);
2774
case CDROM_SELECT_SPEED:
2775
return cdrom_ioctl_select_speed(cdi, arg);
2776
case CDROM_SELECT_DISC:
2777
return cdrom_ioctl_select_disc(cdi, arg);
2779
return cdrom_ioctl_reset(cdi, bdev);
2780
case CDROM_LOCKDOOR:
2781
return cdrom_ioctl_lock_door(cdi, arg);
2783
return cdrom_ioctl_debug(cdi, arg);
2784
case CDROM_GET_CAPABILITY:
2785
return cdrom_ioctl_get_capability(cdi);
2787
return cdrom_ioctl_get_mcn(cdi, argp);
2788
case CDROM_DRIVE_STATUS:
2789
return cdrom_ioctl_drive_status(cdi, arg);
2790
case CDROM_DISC_STATUS:
2791
return cdrom_ioctl_disc_status(cdi);
2792
case CDROM_CHANGER_NSLOTS:
2793
return cdrom_ioctl_changer_nslots(cdi);
2797
* Use the ioctls that are implemented through the generic_packet()
2798
* interface. this may look at bit funny, but if -ENOTTY is
2799
* returned that particular ioctl is not implemented and we
2800
* let it go through the device specific ones.
2802
if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2803
ret = mmc_ioctl(cdi, cmd, arg);
2809
* Note: most of the cdinfo() calls are commented out here,
2810
* because they fill up the sys log when CD players poll
2815
return cdrom_ioctl_get_subchnl(cdi, argp);
2816
case CDROMREADTOCHDR:
2817
return cdrom_ioctl_read_tochdr(cdi, argp);
2818
case CDROMREADTOCENTRY:
2819
return cdrom_ioctl_read_tocentry(cdi, argp);
2821
return cdrom_ioctl_play_msf(cdi, argp);
2822
case CDROMPLAYTRKIND:
2823
return cdrom_ioctl_play_trkind(cdi, argp);
2825
return cdrom_ioctl_volctrl(cdi, argp);
2827
return cdrom_ioctl_volread(cdi, argp);
2832
return cdrom_ioctl_audioctl(cdi, cmd);
2839
* Required when we need to use READ_10 to issue other than 2048 block
2842
static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2844
struct cdrom_device_ops *cdo = cdi->ops;
2845
struct packet_command cgc;
2846
struct modesel_head mh;
2848
memset(&mh, 0, sizeof(mh));
2849
mh.block_desc_length = 0x08;
2850
mh.block_length_med = (size >> 8) & 0xff;
2851
mh.block_length_lo = size & 0xff;
2853
memset(&cgc, 0, sizeof(cgc));
2855
cgc.cmd[1] = 1 << 4;
2857
cgc.buflen = sizeof(mh);
2858
cgc.buffer = (char *) &mh;
2859
cgc.data_direction = CGC_DATA_WRITE;
2860
mh.block_desc_length = 0x08;
2861
mh.block_length_med = (size >> 8) & 0xff;
2862
mh.block_length_lo = size & 0xff;
2864
return cdo->generic_packet(cdi, &cgc);
2867
static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2869
struct packet_command *cgc,
2872
struct request_sense sense;
2873
struct cdrom_msf msf;
2874
int blocksize = 0, format = 0, lba;
2879
blocksize = CD_FRAMESIZE_RAW;
2881
case CDROMREADMODE1:
2882
blocksize = CD_FRAMESIZE;
2885
case CDROMREADMODE2:
2886
blocksize = CD_FRAMESIZE_RAW0;
2889
IOCTL_IN(arg, struct cdrom_msf, msf);
2890
lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2891
/* FIXME: we need upper bound checking, too!! */
2895
cgc->buffer = kmalloc(blocksize, GFP_KERNEL);
2896
if (cgc->buffer == NULL)
2899
memset(&sense, 0, sizeof(sense));
2900
cgc->sense = &sense;
2901
cgc->data_direction = CGC_DATA_READ;
2902
ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
2903
if (ret && sense.sense_key == 0x05 &&
2904
sense.asc == 0x20 &&
2905
sense.ascq == 0x00) {
2907
* SCSI-II devices are not required to support
2908
* READ_CD, so let's try switching block size
2910
/* FIXME: switch back again... */
2911
ret = cdrom_switch_blocksize(cdi, blocksize);
2915
ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
2916
ret |= cdrom_switch_blocksize(cdi, blocksize);
2918
if (!ret && copy_to_user(arg, cgc->buffer, blocksize))
2925
static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
2928
struct cdrom_read_audio ra;
2931
IOCTL_IN(arg, struct cdrom_read_audio, ra);
2933
if (ra.addr_format == CDROM_MSF)
2934
lba = msf_to_lba(ra.addr.msf.minute,
2937
else if (ra.addr_format == CDROM_LBA)
2942
/* FIXME: we need upper bound checking, too!! */
2943
if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2946
return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2949
static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
2953
struct cdrom_subchnl q;
2954
u_char requested, back;
2955
IOCTL_IN(arg, struct cdrom_subchnl, q);
2956
requested = q.cdsc_format;
2957
if (!((requested == CDROM_MSF) ||
2958
(requested == CDROM_LBA)))
2960
q.cdsc_format = CDROM_MSF;
2961
ret = cdrom_read_subchannel(cdi, &q, 0);
2964
back = q.cdsc_format; /* local copy */
2965
sanitize_format(&q.cdsc_absaddr, &back, requested);
2966
sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2967
IOCTL_OUT(arg, struct cdrom_subchnl, q);
2968
/* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2972
static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
2974
struct packet_command *cgc)
2976
struct cdrom_device_ops *cdo = cdi->ops;
2977
struct cdrom_msf msf;
2978
cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2979
IOCTL_IN(arg, struct cdrom_msf, msf);
2980
cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2981
cgc->cmd[3] = msf.cdmsf_min0;
2982
cgc->cmd[4] = msf.cdmsf_sec0;
2983
cgc->cmd[5] = msf.cdmsf_frame0;
2984
cgc->cmd[6] = msf.cdmsf_min1;
2985
cgc->cmd[7] = msf.cdmsf_sec1;
2986
cgc->cmd[8] = msf.cdmsf_frame1;
2987
cgc->data_direction = CGC_DATA_NONE;
2988
return cdo->generic_packet(cdi, cgc);
2991
static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
2993
struct packet_command *cgc)
2995
struct cdrom_device_ops *cdo = cdi->ops;
2996
struct cdrom_blk blk;
2997
cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2998
IOCTL_IN(arg, struct cdrom_blk, blk);
2999
cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
3000
cgc->cmd[2] = (blk.from >> 24) & 0xff;
3001
cgc->cmd[3] = (blk.from >> 16) & 0xff;
3002
cgc->cmd[4] = (blk.from >> 8) & 0xff;
3003
cgc->cmd[5] = blk.from & 0xff;
3004
cgc->cmd[7] = (blk.len >> 8) & 0xff;
3005
cgc->cmd[8] = blk.len & 0xff;
3006
cgc->data_direction = CGC_DATA_NONE;
3007
return cdo->generic_packet(cdi, cgc);
3010
static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3012
struct packet_command *cgc,
3015
struct cdrom_volctrl volctrl;
3016
unsigned char buffer[32];
3017
char mask[sizeof(buffer)];
3018
unsigned short offset;
3021
cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3023
IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
3025
cgc->buffer = buffer;
3027
ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 0);
3031
/* originally the code depended on buffer[1] to determine
3032
how much data is available for transfer. buffer[1] is
3033
unfortunately ambigious and the only reliable way seem
3034
to be to simply skip over the block descriptor... */
3035
offset = 8 + be16_to_cpu(*(__be16 *)(buffer + 6));
3037
if (offset + 16 > sizeof(buffer))
3040
if (offset + 16 > cgc->buflen) {
3041
cgc->buflen = offset + 16;
3042
ret = cdrom_mode_sense(cdi, cgc,
3043
GPMODE_AUDIO_CTL_PAGE, 0);
3049
if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3050
buffer[offset + 1] < 14)
3053
/* now we have the current volume settings. if it was only
3054
a CDROMVOLREAD, return these values */
3055
if (cmd == CDROMVOLREAD) {
3056
volctrl.channel0 = buffer[offset+9];
3057
volctrl.channel1 = buffer[offset+11];
3058
volctrl.channel2 = buffer[offset+13];
3059
volctrl.channel3 = buffer[offset+15];
3060
IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
3064
/* get the volume mask */
3066
ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 1);
3070
buffer[offset + 9] = volctrl.channel0 & mask[offset + 9];
3071
buffer[offset + 11] = volctrl.channel1 & mask[offset + 11];
3072
buffer[offset + 13] = volctrl.channel2 & mask[offset + 13];
3073
buffer[offset + 15] = volctrl.channel3 & mask[offset + 15];
3076
cgc->buffer = buffer + offset - 8;
3077
memset(cgc->buffer, 0, 8);
3078
return cdrom_mode_select(cdi, cgc);
3081
static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3082
struct packet_command *cgc,
3085
struct cdrom_device_ops *cdo = cdi->ops;
3086
cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3087
cgc->cmd[0] = GPCMD_START_STOP_UNIT;
3089
cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3090
cgc->data_direction = CGC_DATA_NONE;
3091
return cdo->generic_packet(cdi, cgc);
3094
static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3095
struct packet_command *cgc,
3098
struct cdrom_device_ops *cdo = cdi->ops;
3099
cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3100
cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3101
cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3102
cgc->data_direction = CGC_DATA_NONE;
3103
return cdo->generic_packet(cdi, cgc);
3106
static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3108
struct packet_command *cgc)
3112
int size = sizeof(dvd_struct);
3114
if (!CDROM_CAN(CDC_DVD))
3117
s = kmalloc(size, GFP_KERNEL);
3121
cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3122
if (copy_from_user(s, arg, size)) {
3127
ret = dvd_read_struct(cdi, s, cgc);
3131
if (copy_to_user(arg, s, size))
3138
static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3143
if (!CDROM_CAN(CDC_DVD))
3145
cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
3146
IOCTL_IN(arg, dvd_authinfo, ai);
3147
ret = dvd_do_auth(cdi, &ai);
3150
IOCTL_OUT(arg, dvd_authinfo, ai);
3154
static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3159
cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3160
ret = cdrom_get_next_writable(cdi, &next);
3163
IOCTL_OUT(arg, long, next);
3167
static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3172
cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3173
ret = cdrom_get_last_written(cdi, &last);
3176
IOCTL_OUT(arg, long, last);
3180
static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3183
struct packet_command cgc;
3184
void __user *userptr = (void __user *)arg;
3186
memset(&cgc, 0, sizeof(cgc));
3188
/* build a unified command and queue it through
3189
cdo->generic_packet() */
3192
case CDROMREADMODE1:
3193
case CDROMREADMODE2:
3194
return mmc_ioctl_cdrom_read_data(cdi, userptr, &cgc, cmd);
3195
case CDROMREADAUDIO:
3196
return mmc_ioctl_cdrom_read_audio(cdi, userptr);
3198
return mmc_ioctl_cdrom_subchannel(cdi, userptr);
3200
return mmc_ioctl_cdrom_play_msf(cdi, userptr, &cgc);
3202
return mmc_ioctl_cdrom_play_blk(cdi, userptr, &cgc);
3205
return mmc_ioctl_cdrom_volume(cdi, userptr, &cgc, cmd);
3208
return mmc_ioctl_cdrom_start_stop(cdi, &cgc, cmd);
3211
return mmc_ioctl_cdrom_pause_resume(cdi, &cgc, cmd);
3212
case DVD_READ_STRUCT:
3213
return mmc_ioctl_dvd_read_struct(cdi, userptr, &cgc);
3215
return mmc_ioctl_dvd_auth(cdi, userptr);
3216
case CDROM_NEXT_WRITABLE:
3217
return mmc_ioctl_cdrom_next_writable(cdi, userptr);
3218
case CDROM_LAST_WRITTEN:
3219
return mmc_ioctl_cdrom_last_written(cdi, userptr);
3225
static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
3226
track_information *ti)
3228
struct cdrom_device_ops *cdo = cdi->ops;
3229
struct packet_command cgc;
3232
init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3233
cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3234
cgc.cmd[1] = type & 3;
3235
cgc.cmd[4] = (track & 0xff00) >> 8;
3236
cgc.cmd[5] = track & 0xff;
3240
if ((ret = cdo->generic_packet(cdi, &cgc)))
3243
buflen = be16_to_cpu(ti->track_information_length) +
3244
sizeof(ti->track_information_length);
3246
if (buflen > sizeof(track_information))
3247
buflen = sizeof(track_information);
3249
cgc.cmd[8] = cgc.buflen = buflen;
3250
if ((ret = cdo->generic_packet(cdi, &cgc)))
3253
/* return actual fill size */
3257
/* requires CD R/RW */
3258
static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3260
struct cdrom_device_ops *cdo = cdi->ops;
3261
struct packet_command cgc;
3264
/* set up command and get the disc info */
3265
init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3266
cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3267
cgc.cmd[8] = cgc.buflen = 2;
3270
if ((ret = cdo->generic_packet(cdi, &cgc)))
3273
/* not all drives have the same disc_info length, so requeue
3274
* packet with the length the drive tells us it can supply
3276
buflen = be16_to_cpu(di->disc_information_length) +
3277
sizeof(di->disc_information_length);
3279
if (buflen > sizeof(disc_information))
3280
buflen = sizeof(disc_information);
3282
cgc.cmd[8] = cgc.buflen = buflen;
3283
if ((ret = cdo->generic_packet(cdi, &cgc)))
3286
/* return actual fill size */
3290
/* return the last written block on the CD-R media. this is for the udf
3292
int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
3294
struct cdrom_tocentry toc;
3295
disc_information di;
3296
track_information ti;
3298
int ret = -1, ti_size;
3300
if (!CDROM_CAN(CDC_GENERIC_PACKET))
3303
ret = cdrom_get_disc_info(cdi, &di);
3304
if (ret < (int)(offsetof(typeof(di), last_track_lsb)
3305
+ sizeof(di.last_track_lsb)))
3308
/* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3309
last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3310
ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3311
if (ti_size < (int)offsetof(typeof(ti), track_start))
3314
/* if this track is blank, try the previous. */
3319
ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3322
if (ti_size < (int)(offsetof(typeof(ti), track_size)
3323
+ sizeof(ti.track_size)))
3326
/* if last recorded field is valid, return it. */
3327
if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3328
+ sizeof(ti.last_rec_address))) {
3329
*last_written = be32_to_cpu(ti.last_rec_address);
3331
/* make it up instead */
3332
*last_written = be32_to_cpu(ti.track_start) +
3333
be32_to_cpu(ti.track_size);
3335
*last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3339
/* this is where we end up if the drive either can't do a
3340
GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3341
it doesn't give enough information or fails. then we return
3342
the toc contents. */
3344
toc.cdte_format = CDROM_MSF;
3345
toc.cdte_track = CDROM_LEADOUT;
3346
if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
3348
sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
3349
*last_written = toc.cdte_addr.lba;
3353
/* return the next writable block. also for udf file system. */
3354
static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3356
disc_information di;
3357
track_information ti;
3361
if (!CDROM_CAN(CDC_GENERIC_PACKET))
3362
goto use_last_written;
3364
ret = cdrom_get_disc_info(cdi, &di);
3365
if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3366
+ sizeof(di.last_track_lsb))
3367
goto use_last_written;
3369
/* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3370
last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3371
ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3372
if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3373
goto use_last_written;
3375
/* if this track is blank, try the previous. */
3377
if (last_track == 1)
3378
goto use_last_written;
3380
ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3382
goto use_last_written;
3385
/* if next recordable address field is valid, use it. */
3386
if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
3387
+ sizeof(ti.next_writable)) {
3388
*next_writable = be32_to_cpu(ti.next_writable);
3393
if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3397
*next_writable += 7;
3402
EXPORT_SYMBOL(cdrom_get_last_written);
3403
EXPORT_SYMBOL(register_cdrom);
3404
EXPORT_SYMBOL(unregister_cdrom);
3405
EXPORT_SYMBOL(cdrom_open);
3406
EXPORT_SYMBOL(cdrom_release);
3407
EXPORT_SYMBOL(cdrom_ioctl);
3408
EXPORT_SYMBOL(cdrom_media_changed);
3409
EXPORT_SYMBOL(cdrom_number_of_slots);
3410
EXPORT_SYMBOL(cdrom_mode_select);
3411
EXPORT_SYMBOL(cdrom_mode_sense);
3412
EXPORT_SYMBOL(init_cdrom_command);
3413
EXPORT_SYMBOL(cdrom_get_media_event);
3415
#ifdef CONFIG_SYSCTL
3417
#define CDROM_STR_SIZE 1000
3419
static struct cdrom_sysctl_settings {
3420
char info[CDROM_STR_SIZE]; /* general info */
3421
int autoclose; /* close tray upon mount, etc */
3422
int autoeject; /* eject on umount */
3423
int debug; /* turn on debugging messages */
3424
int lock; /* lock the door on device open */
3425
int check; /* check media type */
3426
} cdrom_sysctl_settings;
3428
enum cdrom_print_option {
3435
static int cdrom_print_info(const char *header, int val, char *info,
3436
int *pos, enum cdrom_print_option option)
3438
const int max_size = sizeof(cdrom_sysctl_settings.info);
3439
struct cdrom_device_info *cdi;
3442
ret = scnprintf(info + *pos, max_size - *pos, header);
3448
list_for_each_entry(cdi, &cdrom_list, list) {
3451
ret = scnprintf(info + *pos, max_size - *pos,
3455
ret = scnprintf(info + *pos, max_size - *pos,
3456
"\t%d", cdi->speed);
3459
ret = scnprintf(info + *pos, max_size - *pos,
3460
"\t%d", cdi->capacity);
3462
case CTL_CAPABILITY:
3463
ret = scnprintf(info + *pos, max_size - *pos,
3464
"\t%d", CDROM_CAN(val) != 0);
3467
pr_info("invalid option%d\n", option);
3478
static int cdrom_sysctl_info(ctl_table *ctl, int write,
3479
void __user *buffer, size_t *lenp, loff_t *ppos)
3482
char *info = cdrom_sysctl_settings.info;
3483
const int max_size = sizeof(cdrom_sysctl_settings.info);
3485
if (!*lenp || (*ppos && !write)) {
3490
mutex_lock(&cdrom_mutex);
3492
pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3494
if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3496
if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3498
if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3500
if (cdrom_print_info("\nCan close tray:\t",
3501
CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3503
if (cdrom_print_info("\nCan open tray:\t",
3504
CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3506
if (cdrom_print_info("\nCan lock tray:\t",
3507
CDC_LOCK, info, &pos, CTL_CAPABILITY))
3509
if (cdrom_print_info("\nCan change speed:",
3510
CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3512
if (cdrom_print_info("\nCan select disk:",
3513
CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3515
if (cdrom_print_info("\nCan read multisession:",
3516
CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3518
if (cdrom_print_info("\nCan read MCN:\t",
3519
CDC_MCN, info, &pos, CTL_CAPABILITY))
3521
if (cdrom_print_info("\nReports media changed:",
3522
CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3524
if (cdrom_print_info("\nCan play audio:\t",
3525
CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3527
if (cdrom_print_info("\nCan write CD-R:\t",
3528
CDC_CD_R, info, &pos, CTL_CAPABILITY))
3530
if (cdrom_print_info("\nCan write CD-RW:",
3531
CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3533
if (cdrom_print_info("\nCan read DVD:\t",
3534
CDC_DVD, info, &pos, CTL_CAPABILITY))
3536
if (cdrom_print_info("\nCan write DVD-R:",
3537
CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3539
if (cdrom_print_info("\nCan write DVD-RAM:",
3540
CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3542
if (cdrom_print_info("\nCan read MRW:\t",
3543
CDC_MRW, info, &pos, CTL_CAPABILITY))
3545
if (cdrom_print_info("\nCan write MRW:\t",
3546
CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3548
if (cdrom_print_info("\nCan write RAM:\t",
3549
CDC_RAM, info, &pos, CTL_CAPABILITY))
3551
if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3554
mutex_unlock(&cdrom_mutex);
3555
return proc_dostring(ctl, write, buffer, lenp, ppos);
3557
pr_info("info buffer too small\n");
3561
/* Unfortunately, per device settings are not implemented through
3562
procfs/sysctl yet. When they are, this will naturally disappear. For now
3563
just update all drives. Later this will become the template on which
3564
new registered drives will be based. */
3565
static void cdrom_update_settings(void)
3567
struct cdrom_device_info *cdi;
3569
mutex_lock(&cdrom_mutex);
3570
list_for_each_entry(cdi, &cdrom_list, list) {
3571
if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3572
cdi->options |= CDO_AUTO_CLOSE;
3573
else if (!autoclose)
3574
cdi->options &= ~CDO_AUTO_CLOSE;
3575
if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3576
cdi->options |= CDO_AUTO_EJECT;
3577
else if (!autoeject)
3578
cdi->options &= ~CDO_AUTO_EJECT;
3579
if (lockdoor && CDROM_CAN(CDC_LOCK))
3580
cdi->options |= CDO_LOCK;
3582
cdi->options &= ~CDO_LOCK;
3583
if (check_media_type)
3584
cdi->options |= CDO_CHECK_TYPE;
3586
cdi->options &= ~CDO_CHECK_TYPE;
3588
mutex_unlock(&cdrom_mutex);
3591
static int cdrom_sysctl_handler(ctl_table *ctl, int write,
3592
void __user *buffer, size_t *lenp, loff_t *ppos)
3596
ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
3600
/* we only care for 1 or 0. */
3601
autoclose = !!cdrom_sysctl_settings.autoclose;
3602
autoeject = !!cdrom_sysctl_settings.autoeject;
3603
debug = !!cdrom_sysctl_settings.debug;
3604
lockdoor = !!cdrom_sysctl_settings.lock;
3605
check_media_type = !!cdrom_sysctl_settings.check;
3607
/* update the option flags according to the changes. we
3608
don't have per device options through sysctl yet,
3609
but we will have and then this will disappear. */
3610
cdrom_update_settings();
3616
/* Place files in /proc/sys/dev/cdrom */
3617
static ctl_table cdrom_table[] = {
3620
.data = &cdrom_sysctl_settings.info,
3621
.maxlen = CDROM_STR_SIZE,
3623
.proc_handler = cdrom_sysctl_info,
3626
.procname = "autoclose",
3627
.data = &cdrom_sysctl_settings.autoclose,
3628
.maxlen = sizeof(int),
3630
.proc_handler = cdrom_sysctl_handler,
3633
.procname = "autoeject",
3634
.data = &cdrom_sysctl_settings.autoeject,
3635
.maxlen = sizeof(int),
3637
.proc_handler = cdrom_sysctl_handler,
3640
.procname = "debug",
3641
.data = &cdrom_sysctl_settings.debug,
3642
.maxlen = sizeof(int),
3644
.proc_handler = cdrom_sysctl_handler,
3648
.data = &cdrom_sysctl_settings.lock,
3649
.maxlen = sizeof(int),
3651
.proc_handler = cdrom_sysctl_handler,
3654
.procname = "check_media",
3655
.data = &cdrom_sysctl_settings.check,
3656
.maxlen = sizeof(int),
3658
.proc_handler = cdrom_sysctl_handler
3663
static ctl_table cdrom_cdrom_table[] = {
3665
.procname = "cdrom",
3668
.child = cdrom_table,
3673
/* Make sure that /proc/sys/dev is there */
3674
static ctl_table cdrom_root_table[] = {
3679
.child = cdrom_cdrom_table,
3683
static struct ctl_table_header *cdrom_sysctl_header;
3685
static void cdrom_sysctl_register(void)
3687
static int initialized;
3689
if (initialized == 1)
3692
cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3694
/* set the defaults */
3695
cdrom_sysctl_settings.autoclose = autoclose;
3696
cdrom_sysctl_settings.autoeject = autoeject;
3697
cdrom_sysctl_settings.debug = debug;
3698
cdrom_sysctl_settings.lock = lockdoor;
3699
cdrom_sysctl_settings.check = check_media_type;
3704
static void cdrom_sysctl_unregister(void)
3706
if (cdrom_sysctl_header)
3707
unregister_sysctl_table(cdrom_sysctl_header);
3710
#else /* CONFIG_SYSCTL */
3712
static void cdrom_sysctl_register(void)
3716
static void cdrom_sysctl_unregister(void)
3720
#endif /* CONFIG_SYSCTL */
3722
static int __init cdrom_init(void)
3724
cdrom_sysctl_register();
3729
static void __exit cdrom_exit(void)
3731
pr_info("Uniform CD-ROM driver unloaded\n");
3732
cdrom_sysctl_unregister();
3735
module_init(cdrom_init);
3736
module_exit(cdrom_exit);
3737
MODULE_LICENSE("GPL");