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