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