]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/cdrom/cdrom.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
scsi: sr avoids useless buffer allocation
[net-next-2.6.git] / drivers / cdrom / cdrom.c
CommitLineData
f30c2269 1/* linux/drivers/cdrom/cdrom.c
1da177e4
LT		 2 Copyright (c) 1996, 1997 David A. van Leeuwen.
3 Copyright (c) 1997, 1998 Erik Andersen <andersee@debian.org>
4 Copyright (c) 1998, 1999 Jens Axboe <axboe@image.dk>
5
6 May be copied or modified under the terms of the GNU General Public
7 License. See linux/COPYING for more information.
8
9 Uniform CD-ROM driver for Linux.
10 See Documentation/cdrom/cdrom-standard.tex for usage information.
11
12 The routines in the file provide a uniform interface between the
13 software that uses CD-ROMs and the various low-level drivers that
14 actually talk to the hardware. Suggestions are welcome.
15 Patches that work are more welcome though. ;-)
16
17 To Do List:
18 ----------------------------------
19
20 -- Modify sysctl/proc interface. I plan on having one directory per
21 drive, with entries for outputing general drive information, and sysctl
22 based tunable parameters such as whether the tray should auto-close for
23 that drive. Suggestions (or patches) for this welcome!
24
25
26 Revision History
27 ----------------------------------
28 1.00 Date Unknown -- David van Leeuwen <david@tm.tno.nl>
29 -- Initial version by David A. van Leeuwen. I don't have a detailed
30 changelog for the 1.x series, David?
31
322.00 Dec 2, 1997 -- Erik Andersen <andersee@debian.org>
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
1da177e4
LT		 266#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
554988d6 305static DEFINE_MUTEX(cdrom_mutex);
1da177e4
LT		 306
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
2e11c207
JA		 340/*
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
1da177e4
LT		 346/* 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
1da177e4 363static void cdrom_sysctl_register(void);
17672cf0 364
7fd097d4 365static LIST_HEAD(cdrom_list);
1da177e4
LT		 366
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)
3c3f4e01 396 return -EINVAL;
1da177e4
LT		 397 if (!banner_printed) {
398 printk(KERN_INFO "Uniform CD-ROM driver " REVISION "\n");
399 banner_printed = 1;
1da177e4 400 cdrom_sysctl_register();
1da177e4
LT		 401 }
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);
1da177e4
LT		 412 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);
554988d6 438 mutex_lock(&cdrom_mutex);
7fd097d4 439 list_add(&cdi->list, &cdrom_list);
554988d6 440 mutex_unlock(&cdrom_mutex);
1da177e4
LT		 441 return 0;
442}
443#undef ENSURE
444
0a0c4114 445void unregister_cdrom(struct cdrom_device_info *cdi)
1da177e4 446{
1da177e4
LT		 447 cdinfo(CD_OPEN, "entering unregister_cdrom\n");
448
554988d6 449 mutex_lock(&cdrom_mutex);
7fd097d4 450 list_del(&cdi->list);
554988d6 451 mutex_unlock(&cdrom_mutex);
1da177e4
LT		 452
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);
1da177e4
LT		 458}
459
460int cdrom_get_media_event(struct cdrom_device_info *cdi,
461 struct media_event_desc *med)
462{
463 struct packet_command cgc;
22a9189f
TB		 464 unsigned char *buffer;
465 struct event_header *eh;
466 int ret = 1;
467
468 buffer = kmalloc(8, GFP_KERNEL);
469 if (!buffer)
470 return -ENOMEM;
1da177e4 471
22a9189f
TB		 472 eh = (struct event_header *)buffer;
473
474 init_cdrom_command(&cgc, buffer, 8, CGC_DATA_READ);
1da177e4
LT		 475 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
476 cgc.cmd[1] = 1; /* IMMED */
477 cgc.cmd[4] = 1 << 4; /* media event */
22a9189f 478 cgc.cmd[8] = 8;
1da177e4
LT		 479 cgc.quiet = 1;
480
481 if (cdi->ops->generic_packet(cdi, &cgc))
22a9189f 482 goto err;
1da177e4
LT		 483
484 if (be16_to_cpu(eh->data_len) < sizeof(*med))
22a9189f 485 goto err;
1da177e4
LT		 486
487 if (eh->nea || eh->notification_class != 0x4)
22a9189f 488 goto err;
1da177e4 489
22a9189f
TB		 490 memcpy(med, buffer + sizeof(*eh), sizeof(*med));
491 ret = 0;
492err:
493 kfree(buffer);
494 return ret;
1da177e4
LT		 495}
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;
22a9189f
TB		 504 char *buffer;
505 int ret = 1;
506
507 buffer = kmalloc(16, GFP_KERNEL);
508 if (!buffer)
509 return -ENOMEM;
1da177e4 510
22a9189f 511 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1da177e4
LT		 512
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;
22a9189f 518 ret = 0;
1da177e4
LT		 519 } else if (!cdrom_mode_sense(cdi, &cgc, MRW_MODE_PC_PRE1, 0)) {
520 cdi->mrw_mode_page = MRW_MODE_PC_PRE1;
22a9189f 521 ret = 0;
1da177e4 522 }
22a9189f
TB		 523 kfree(buffer);
524 return ret;
1da177e4
LT		 525}
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;
22a9189f 531 unsigned char *buffer;
1da177e4
LT		 532 int ret;
533
534 *write = 0;
22a9189f
TB		 535 buffer = kmalloc(16, GFP_KERNEL);
536 if (!buffer)
537 return -ENOMEM;
1da177e4 538
22a9189f 539 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1da177e4
LT		 540
541 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
542 cgc.cmd[3] = CDF_MRW;
22a9189f 543 cgc.cmd[8] = 16;
1da177e4
LT		 544 cgc.quiet = 1;
545
546 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
22a9189f 547 goto err;
1da177e4
LT		 548
549 mfd = (struct mrw_feature_desc *)&buffer[sizeof(struct feature_header)];
22a9189f
TB		 550 if (be16_to_cpu(mfd->feature_code) != CDF_MRW) {
551 ret = 1;
552 goto err;
553 }
1da177e4
LT		 554 *write = mfd->write;
555
556 if ((ret = cdrom_mrw_probe_pc(cdi))) {
557 *write = 0;
1da177e4 558 }
22a9189f
TB		 559err:
560 kfree(buffer);
561 return ret;
1da177e4
LT		 562}
563
564static int cdrom_mrw_bgformat(struct cdrom_device_info *cdi, int cont)
565{
566 struct packet_command cgc;
22a9189f 567 unsigned char *buffer;
1da177e4
LT		 568 int ret;
569
570 printk(KERN_INFO "cdrom: %sstarting format\n", cont ? "Re" : "");
571
22a9189f
TB		 572 buffer = kmalloc(12, GFP_KERNEL);
573 if (!buffer)
574 return -ENOMEM;
575
1da177e4
LT		 576 /*
577 * FmtData bit set (bit 4), format type is 1
578 */
22a9189f 579 init_cdrom_command(&cgc, buffer, 12, CGC_DATA_WRITE);
1da177e4
LT		 580 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
22a9189f 606 kfree(buffer);
1da177e4
LT		 607 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
7da21a02 656 if (!ret && cdi->media_written)
1da177e4
LT		 657 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;
22a9189f 666 char *buffer;
1da177e4
LT		 667 int ret, offset, size;
668
22a9189f
TB		 669 buffer = kmalloc(16, GFP_KERNEL);
670 if (!buffer)
671 return -ENOMEM;
1da177e4 672
22a9189f 673 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1da177e4
LT		 674
675 if ((ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0)))
22a9189f 676 goto err;
1da177e4
LT		 677
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)))
22a9189f 686 goto err;
1da177e4
LT		 687
688 printk(KERN_INFO "cdrom: %s: mrw address space %s selected\n", cdi->name, mrw_address_space[space]);
22a9189f
TB		 689 ret = 0;
690err:
691 kfree(buffer);
692 return ret;
1da177e4
LT		 693}
694
695static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
696 struct rwrt_feature_desc *rfd)
697{
698 struct packet_command cgc;
22a9189f 699 char *buffer;
1da177e4
LT		 700 int ret;
701
22a9189f
TB		 702 buffer = kmalloc(24, GFP_KERNEL);
703 if (!buffer)
704 return -ENOMEM;
705
706 init_cdrom_command(&cgc, buffer, 24, CGC_DATA_READ);
1da177e4
LT		 707
708 cgc.cmd[0] = GPCMD_GET_CONFIGURATION; /* often 0x46 */
709 cgc.cmd[3] = CDF_RWRT; /* often 0x0020 */
22a9189f 710 cgc.cmd[8] = 24; /* often 0x18 */
1da177e4
LT		 711 cgc.quiet = 1;
712
713 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
22a9189f 714 goto err;
1da177e4
LT		 715
716 memcpy(rfd, &buffer[sizeof(struct feature_header)], sizeof (*rfd));
22a9189f
TB		 717 ret = 0;
718err:
719 kfree(buffer);
720 return ret;
1da177e4
LT		 721}
722
723static int cdrom_has_defect_mgt(struct cdrom_device_info *cdi)
724{
725 struct packet_command cgc;
22a9189f 726 char *buffer;
56052d52 727 __be16 *feature_code;
1da177e4
LT		 728 int ret;
729
22a9189f
TB		 730 buffer = kmalloc(16, GFP_KERNEL);
731 if (!buffer)
732 return -ENOMEM;
733
734 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1da177e4
LT		 735
736 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
737 cgc.cmd[3] = CDF_HWDM;
22a9189f 738 cgc.cmd[8] = 16;
1da177e4
LT		 739 cgc.quiet = 1;
740
741 if ((ret = cdi->ops->generic_packet(cdi, &cgc)))
22a9189f 742 goto err;
1da177e4 743
56052d52 744 feature_code = (__be16 *) &buffer[sizeof(struct feature_header)];
1da177e4 745 if (be16_to_cpu(*feature_code) == CDF_HWDM)
22a9189f
TB		 746 ret = 0;
747err:
748 kfree(buffer);
749 return ret;
1da177e4
LT		 750}
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;
22a9189f 840 char *buffer;
1da177e4
LT		 841 int ret;
842
22a9189f
TB		 843 buffer = kmalloc(255, GFP_KERNEL);
844 if (!buffer)
845 return -ENOMEM;
846
847 init_cdrom_command(&cgc, buffer, 4, CGC_DATA_READ);
1da177e4
LT		 848 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 */
22a9189f
TB		 864 if (ret) {
865 ret = 0;
866 goto err;
867 }
1da177e4 868
22a9189f
TB		 869 ret = buffer[3] & 0x80;
870err:
871 kfree(buffer);
872 return ret;
1da177e4
LT		 873}
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;
22a9189f 895 char *buffer;
1da177e4
LT		 896 int ret, mmc3_profile;
897
22a9189f
TB		 898 buffer = kmalloc(32, GFP_KERNEL);
899 if (!buffer)
900 return;
901
902 init_cdrom_command(&cgc, buffer, 32, CGC_DATA_READ);
1da177e4
LT		 903
904 cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
905 cgc.cmd[1] = 0;
906 cgc.cmd[2] = cgc.cmd[3] = 0; /* Starting Feature Number */
22a9189f 907 cgc.cmd[8] = 32; /* Allocation Length */
1da177e4
LT		 908 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;
22a9189f 916 kfree(buffer);
1da177e4
LT		 917}
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))
16070428 1051 goto err_release;
1da177e4 1052 if (!CDROM_CAN(CDC_RAM))
16070428 1053 goto err_release;
1da177e4
LT		 1054 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;
16070428 1068err_release:
ae3ba4fd
AV		 1069 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1070 cdi->ops->lock_door(cdi, 0);
1071 cdinfo(CD_OPEN, "door unlocked.\n");
1072 }
16070428 1073 cdi->ops->release(cdi);
1da177e4
LT		 1074err:
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",
ba25f9dc 1144 (unsigned int)task_pid_nr(current));
1da177e4
LT		 1145 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:
00d6da9b 1178 cdinfo(CD_OPEN, "open failed.\n");
1da177e4
LT		 1179 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*/
ecb80c6a
AB		 1189static int check_for_audio_disc(struct cdrom_device_info * cdi,
1190 struct cdrom_device_ops * cdo)
1da177e4
LT		 1191{
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
1da177e4
LT		 1243int 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
35841f70 1248 cdinfo(CD_CLOSE, "entering cdrom_release\n");
1da177e4
LT		 1249
1250 if (cdi->use_count > 0)
1251 cdi->use_count--;
35841f70
BP		 1252
1253 if (cdi->use_count == 0) {
1da177e4 1254 cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
1da177e4 1255 cdrom_dvd_rw_close_write(cdi);
35841f70
BP		 1256
1257 if ((cdo->capability & CDC_LOCK) && !keeplocked) {
1258 cdinfo(CD_CLOSE, "Unlocking door!\n");
1259 cdo->lock_door(cdi, 0);
1260 }
1da177e4 1261 }
35841f70 1262
1da177e4
LT		 1263 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;
2e11c207 1576 cgc->timeout = CDROM_DEF_TIMEOUT;
1da177e4
LT		 1577}
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;
22a9189f 1631 u_char *buf;
1da177e4
LT		 1632 struct packet_command cgc;
1633 struct cdrom_device_ops *cdo = cdi->ops;
22a9189f
TB		 1634 rpc_state_t *rpc_state;
1635
1636 buf = kzalloc(20, GFP_KERNEL);
1637 if (!buf)
1638 return -ENOMEM;
1da177e4 1639
1da177e4
LT		 1640 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)))
22a9189f 1650 goto err;
1da177e4
LT		 1651
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)))
22a9189f 1661 goto err;
1da177e4
LT		 1662
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)))
22a9189f 1672 goto err;
1da177e4
LT		 1673
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)))
22a9189f 1689 goto err;
1da177e4
LT		 1690
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)))
22a9189f 1703 goto err;
1da177e4
LT		 1704
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)))
22a9189f 1716 goto err;
1da177e4
LT		 1717
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;
22a9189f 1729 goto err;
1da177e4
LT		 1730 }
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)))
22a9189f 1740 goto err;
1da177e4
LT		 1741 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);
1da177e4
LT		 1747
1748 if ((ret = cdo->generic_packet(cdi, &cgc)))
22a9189f 1749 goto err;
1da177e4 1750
22a9189f
TB		 1751 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;
1da177e4
LT		 1757 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)))
22a9189f 1767 goto err;
1da177e4
LT		 1768 break;
1769
1770 default:
1771 cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
22a9189f
TB		 1772 ret = -ENOTTY;
1773 goto err;
1da177e4 1774 }
22a9189f
TB		 1775 ret = 0;
1776err:
1777 kfree(buf);
1778 return ret;
1da177e4
LT		 1779}
1780
1781static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
1782{
22a9189f 1783 unsigned char *buf, *base;
1da177e4
LT		 1784 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
22a9189f
TB		 1792 buf = kmalloc(21, GFP_KERNEL);
1793 if (!buf)
1794 return -ENOMEM;
1795
1796 init_cdrom_command(&cgc, buf, 21, CGC_DATA_READ);
1da177e4
LT		 1797 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)))
22a9189f 1808 goto err;
1da177e4
LT		 1809
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
22a9189f
TB		 1832 ret = 0;
1833err:
1834 kfree(buf);
1835 return ret;
1da177e4
LT		 1836}
1837
1838static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
1839{
1840 int ret;
22a9189f 1841 u_char *buf;
1da177e4
LT		 1842 struct packet_command cgc;
1843 struct cdrom_device_ops *cdo = cdi->ops;
1844
22a9189f
TB		 1845 buf = kmalloc(8, GFP_KERNEL);
1846 if (!buf)
1847 return -ENOMEM;
1848
1849 init_cdrom_command(&cgc, buf, 8, CGC_DATA_READ);
1da177e4
LT		 1850 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)))
22a9189f 1857 goto err;
1da177e4
LT		 1858
1859 s->copyright.cpst = buf[4];
1860 s->copyright.rmi = buf[5];
1861
22a9189f
TB		 1862 ret = 0;
1863err:
1864 kfree(buf);
1865 return ret;
1da177e4
LT		 1866}
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
5cbded58 1877 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1da177e4
LT		 1878 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;
22a9189f 1897 u_char *buf;
1da177e4
LT		 1898 struct packet_command cgc;
1899 struct cdrom_device_ops *cdo = cdi->ops;
1900
22a9189f
TB		 1901 buf = kmalloc(4 + 188, GFP_KERNEL);
1902 if (!buf)
1903 return -ENOMEM;
1904
1905 init_cdrom_command(&cgc, buf, 4 + 188, CGC_DATA_READ);
1da177e4
LT		 1906 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1907 cgc.cmd[7] = s->type;
454d6fbc 1908 cgc.cmd[9] = cgc.buflen & 0xff;
1da177e4
LT		 1909
1910 if ((ret = cdo->generic_packet(cdi, &cgc)))
22a9189f 1911 goto err;
1da177e4
LT		 1912
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);
22a9189f
TB		 1916 ret = -EIO;
1917 goto err;
1da177e4
LT		 1918 }
1919 memcpy(s->bca.value, &buf[4], s->bca.len);
22a9189f
TB		 1920 ret = 0;
1921err:
1922 kfree(buf);
1923 return ret;
1da177e4
LT		 1924}
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
5cbded58 1935 if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1da177e4
LT		 1936 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;
22a9189f 2023 char *buffer;
1da177e4
LT		 2024 int ret;
2025
22a9189f
TB		 2026 buffer = kmalloc(32, GFP_KERNEL);
2027 if (!buffer)
2028 return -ENOMEM;
2029
1da177e4
LT		 2030 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)))
22a9189f 2038 goto err;
1da177e4
LT		 2039
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
22a9189f
TB		 2053 ret = 0;
2054err:
2055 kfree(buffer);
2056 return ret;
1da177e4
LT		 2057}
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{
165125e1 2169 struct request_queue *q = cdi->disk->queue;
1da177e4
LT		 2170 struct request *rq;
2171 struct bio *bio;
2172 unsigned int len;
2173 int nr, ret = 0;
2174
2175 if (!q)
2176 return -ENXIO;
2177
dd1cab95
JA		 2178 rq = blk_get_request(q, READ, GFP_KERNEL);
2179 if (!rq)
2180 return -ENOMEM;
2181
1da177e4
LT		 2182 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
dd1cab95
JA		 2193 ret = blk_rq_map_user(q, rq, ubuf, len);
2194 if (ret)
2195 break;
1da177e4 2196
1da177e4
LT		 2197 rq->cmd[0] = GPCMD_READ_CD;
2198 rq->cmd[1] = 1 << 2;
2199 rq->cmd[2] = (lba >> 24) & 0xff;
2200 rq->cmd[3] = (lba >> 16) & 0xff;
2201 rq->cmd[4] = (lba >> 8) & 0xff;
2202 rq->cmd[5] = lba & 0xff;
2203 rq->cmd[6] = (nr >> 16) & 0xff;
2204 rq->cmd[7] = (nr >> 8) & 0xff;
2205 rq->cmd[8] = nr & 0xff;
2206 rq->cmd[9] = 0xf8;
2207
2208 rq->cmd_len = 12;
4aff5e23 2209 rq->cmd_type = REQ_TYPE_BLOCK_PC;
1da177e4
LT		 2210 rq->timeout = 60 * HZ;
2211 bio = rq->bio;
2212
994ca9a1 2213 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
1da177e4
LT		 2214 struct request_sense *s = rq->sense;
2215 ret = -EIO;
2216 cdi->last_sense = s->sense_key;
2217 }
2218
8e5cfc45 2219 if (blk_rq_unmap_user(bio))
1da177e4
LT		 2220 ret = -EFAULT;
2221
2222 if (ret)
2223 break;
2224
2225 nframes -= nr;
2226 lba += nr;
2227 ubuf += len;
2228 }
2229
dd1cab95 2230 blk_put_request(rq);
1da177e4
LT		 2231 return ret;
2232}
2233
2234static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2235 int lba, int nframes)
2236{
2237 int ret;
2238
2239 if (cdi->cdda_method == CDDA_OLD)
2240 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2241
2242retry:
2243 /*
2244 * for anything else than success and io error, we need to retry
2245 */
2246 ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2247 if (!ret || ret != -EIO)
2248 return ret;
2249
2250 /*
2251 * I've seen drives get sense 4/8/3 udma crc errors on multi
2252 * frame dma, so drop to single frame dma if we need to
2253 */
2254 if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2255 printk("cdrom: dropping to single frame dma\n");
2256 cdi->cdda_method = CDDA_BPC_SINGLE;
2257 goto retry;
2258 }
2259
2260 /*
2261 * so we have an io error of some sort with multi frame dma. if the
2262 * condition wasn't a hardware error
2263 * problems, not for any error
2264 */
2265 if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2266 return ret;
2267
2268 printk("cdrom: dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2269 cdi->cdda_method = CDDA_OLD;
2270 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2271}
2272
d2c5d4fc
CH		 2273static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2274 void __user *argp)
1da177e4 2275{
d2c5d4fc
CH		 2276 struct cdrom_multisession ms_info;
2277 u8 requested_format;
1da177e4
LT		 2278 int ret;
2279
d2c5d4fc
CH		 2280 cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2281
2282 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2283 return -ENOSYS;
2284
2285 if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2286 return -EFAULT;
2287
2288 requested_format = ms_info.addr_format;
2289 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2290 return -EINVAL;
2291 ms_info.addr_format = CDROM_LBA;
2292
2293 ret = cdi->ops->get_last_session(cdi, &ms_info);
2294 if (ret)
1da177e4
LT		 2295 return ret;
2296
d2c5d4fc
CH		 2297 sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2298
2299 if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2300 return -EFAULT;
2301
2302 cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2303 return 0;
2304}
2305
2306static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2307{
2308 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2309
2310 if (!CDROM_CAN(CDC_OPEN_TRAY))
2311 return -ENOSYS;
2312 if (cdi->use_count != 1 || keeplocked)
2313 return -EBUSY;
2314 if (CDROM_CAN(CDC_LOCK)) {
2315 int ret = cdi->ops->lock_door(cdi, 0);
2316 if (ret)
1da177e4 2317 return ret;
d2c5d4fc 2318 }
1da177e4 2319
d2c5d4fc
CH		 2320 return cdi->ops->tray_move(cdi, 1);
2321}
1da177e4 2322
d2c5d4fc
CH		 2323static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2324{
2325 cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
1da177e4 2326
d2c5d4fc
CH		 2327 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2328 return -ENOSYS;
2329 return cdi->ops->tray_move(cdi, 0);
2330}
1da177e4 2331
d2c5d4fc
CH		 2332static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2333 unsigned long arg)
2334{
2335 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
1da177e4 2336
d2c5d4fc
CH		 2337 if (!CDROM_CAN(CDC_OPEN_TRAY))
2338 return -ENOSYS;
2339 if (keeplocked)
2340 return -EBUSY;
1da177e4 2341
d2c5d4fc
CH		 2342 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2343 if (arg)
2344 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2345 return 0;
2346}
1da177e4 2347
d2c5d4fc
CH		 2348static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2349 unsigned long arg)
2350{
2351 struct cdrom_changer_info *info;
2352 int ret;
1da177e4 2353
d2c5d4fc 2354 cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
1da177e4 2355
d2c5d4fc
CH		 2356 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2357 return -ENOSYS;
1da177e4 2358
d2c5d4fc
CH		 2359 /* cannot select disc or select current disc */
2360 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2361 return media_changed(cdi, 1);
1da177e4 2362
d2c5d4fc
CH		 2363 if ((unsigned int)arg >= cdi->capacity)
2364 return -EINVAL;
1da177e4 2365
d2c5d4fc
CH		 2366 info = kmalloc(sizeof(*info), GFP_KERNEL);
2367 if (!info)
2368 return -ENOMEM;
1da177e4 2369
d2c5d4fc
CH		 2370 ret = cdrom_read_mech_status(cdi, info);
2371 if (!ret)
2372 ret = info->slots[arg].change;
2373 kfree(info);
2374 return ret;
2375}
1da177e4 2376
d2c5d4fc
CH		 2377static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2378 unsigned long arg)
2379{
2380 cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
1da177e4 2381
d2c5d4fc
CH		 2382 /*
2383 * Options need to be in sync with capability.
2384 * Too late for that, so we have to check each one separately.
2385 */
2386 switch (arg) {
2387 case CDO_USE_FFLAGS:
2388 case CDO_CHECK_TYPE:
2389 break;
2390 case CDO_LOCK:
2391 if (!CDROM_CAN(CDC_LOCK))
2392 return -ENOSYS;
2393 break;
2394 case 0:
2395 return cdi->options;
2396 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2397 default:
2398 if (!CDROM_CAN(arg))
1da177e4 2399 return -ENOSYS;
d2c5d4fc
CH		 2400 }
2401 cdi->options |= (int) arg;
2402 return cdi->options;
2403}
1da177e4 2404
d2c5d4fc
CH		 2405static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2406 unsigned long arg)
2407{
2408 cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
1da177e4 2409
d2c5d4fc
CH		 2410 cdi->options &= ~(int) arg;
2411 return cdi->options;
2412}
1da177e4 2413
d2c5d4fc
CH		 2414static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2415 unsigned long arg)
2416{
2417 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
1da177e4 2418
d2c5d4fc
CH		 2419 if (!CDROM_CAN(CDC_SELECT_SPEED))
2420 return -ENOSYS;
2421 return cdi->ops->select_speed(cdi, arg);
2422}
1da177e4 2423
d2c5d4fc
CH		 2424static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2425 unsigned long arg)
2426{
2427 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2428
2429 if (!CDROM_CAN(CDC_SELECT_DISC))
2430 return -ENOSYS;
2431
2432 if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2433 if ((int)arg >= cdi->capacity)
2434 return -EINVAL;
2435 }
2436
2437 /*
2438 * ->select_disc is a hook to allow a driver-specific way of
2439 * seleting disc. However, since there is no equivalent hook for
2440 * cdrom_slot_status this may not actually be useful...
2441 */
2442 if (cdi->ops->select_disc)
2443 return cdi->ops->select_disc(cdi, arg);
2444
2445 cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2446 return cdrom_select_disc(cdi, arg);
2447}
2448
2449static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2450 struct block_device *bdev)
2451{
2452 cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2453
2454 if (!capable(CAP_SYS_ADMIN))
2455 return -EACCES;
2456 if (!CDROM_CAN(CDC_RESET))
2457 return -ENOSYS;
f98393a6 2458 invalidate_bdev(bdev);
d2c5d4fc
CH		 2459 return cdi->ops->reset(cdi);
2460}
2461
2462static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2463 unsigned long arg)
2464{
2465 cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2466
2467 if (!CDROM_CAN(CDC_LOCK))
2468 return -EDRIVE_CANT_DO_THIS;
2469
2470 keeplocked = arg ? 1 : 0;
2471
2472 /*
2473 * Don't unlock the door on multiple opens by default, but allow
2474 * root to do so.
2475 */
2476 if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2477 return -EBUSY;
2478 return cdi->ops->lock_door(cdi, arg);
2479}
2480
2481static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2482 unsigned long arg)
2483{
2484 cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2485
2486 if (!capable(CAP_SYS_ADMIN))
2487 return -EACCES;
2488 debug = arg ? 1 : 0;
2489 return debug;
2490}
1da177e4 2491
d2c5d4fc
CH		 2492static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2493{
2494 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2495 return (cdi->ops->capability & ~cdi->mask);
2496}
2497
2498/*
2499 * The following function is implemented, although very few audio
1da177e4
LT		 2500 * discs give Universal Product Code information, which should just be
2501 * the Medium Catalog Number on the box. Note, that the way the code
2502 * is written on the CD is /not/ uniform across all discs!
2503 */
d2c5d4fc
CH		 2504static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2505 void __user *argp)
2506{
2507 struct cdrom_mcn mcn;
2508 int ret;
1da177e4 2509
d2c5d4fc 2510 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
1da177e4 2511
d2c5d4fc
CH		 2512 if (!(cdi->ops->capability & CDC_MCN))
2513 return -ENOSYS;
2514 ret = cdi->ops->get_mcn(cdi, &mcn);
2515 if (ret)
2516 return ret;
1da177e4 2517
d2c5d4fc
CH		 2518 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2519 return -EFAULT;
2520 cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2521 return 0;
2522}
1da177e4 2523
d2c5d4fc
CH		 2524static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2525 unsigned long arg)
2526{
2527 cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2528
2529 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2530 return -ENOSYS;
2531 if (!CDROM_CAN(CDC_SELECT_DISC) ||
2532 (arg == CDSL_CURRENT || arg == CDSL_NONE))
2533 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2534 if (((int)arg >= cdi->capacity))
2535 return -EINVAL;
2536 return cdrom_slot_status(cdi, arg);
2537}
2538
2539/*
2540 * Ok, this is where problems start. The current interface for the
2541 * CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption that
2542 * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunatly, while this
2543 * is often the case, it is also very common for CDs to have some tracks
2544 * with data, and some tracks with audio. Just because I feel like it,
2545 * I declare the following to be the best way to cope. If the CD has ANY
2546 * data tracks on it, it will be returned as a data CD. If it has any XA
2547 * tracks, I will return it as that. Now I could simplify this interface
2548 * by combining these returns with the above, but this more clearly
2549 * demonstrates the problem with the current interface. Too bad this
2550 * wasn't designed to use bitmasks... -Erik
2551 *
2552 * Well, now we have the option CDS_MIXED: a mixed-type CD.
2553 * User level programmers might feel the ioctl is not very useful.
2554 * ---david
2555 */
2556static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2557{
2558 tracktype tracks;
2559
2560 cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2561
2562 cdrom_count_tracks(cdi, &tracks);
2563 if (tracks.error)
2564 return tracks.error;
2565
2566 /* Policy mode on */
2567 if (tracks.audio > 0) {
2568 if (!tracks.data && !tracks.cdi && !tracks.xa)
2569 return CDS_AUDIO;
2570 else
2571 return CDS_MIXED;
1da177e4
LT		 2572 }
2573
d2c5d4fc
CH		 2574 if (tracks.cdi > 0)
2575 return CDS_XA_2_2;
2576 if (tracks.xa > 0)
2577 return CDS_XA_2_1;
2578 if (tracks.data > 0)
2579 return CDS_DATA_1;
2580 /* Policy mode off */
2581
2582 cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2583 return CDS_NO_INFO;
2584}
2585
2586static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2587{
2588 cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2589 return cdi->capacity;
2590}
2591
2592static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2593 void __user *argp)
2594{
2595 struct cdrom_subchnl q;
2596 u8 requested, back;
2597 int ret;
2598
2599 /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2600
2601 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2602 return -ENOSYS;
2603 if (copy_from_user(&q, argp, sizeof(q)))
2604 return -EFAULT;
2605
2606 requested = q.cdsc_format;
2607 if (requested != CDROM_MSF && requested != CDROM_LBA)
2608 return -EINVAL;
2609 q.cdsc_format = CDROM_MSF;
2610
2611 ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2612 if (ret)
2613 return ret;
2614
2615 back = q.cdsc_format; /* local copy */
2616 sanitize_format(&q.cdsc_absaddr, &back, requested);
2617 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2618
2619 if (copy_to_user(argp, &q, sizeof(q)))
2620 return -EFAULT;
2621 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2622 return 0;
2623}
2624
2625static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2626 void __user *argp)
2627{
2628 struct cdrom_tochdr header;
2629 int ret;
2630
2631 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2632
2633 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2634 return -ENOSYS;
2635 if (copy_from_user(&header, argp, sizeof(header)))
2636 return -EFAULT;
2637
2638 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2639 if (ret)
2640 return ret;
2641
2642 if (copy_to_user(argp, &header, sizeof(header)))
2643 return -EFAULT;
2644 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2645 return 0;
2646}
2647
2648static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2649 void __user *argp)
2650{
2651 struct cdrom_tocentry entry;
2652 u8 requested_format;
2653 int ret;
2654
2655 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2656
2657 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2658 return -ENOSYS;
2659 if (copy_from_user(&entry, argp, sizeof(entry)))
2660 return -EFAULT;
2661
2662 requested_format = entry.cdte_format;
2663 if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2664 return -EINVAL;
2665 /* make interface to low-level uniform */
2666 entry.cdte_format = CDROM_MSF;
2667 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2668 if (ret)
2669 return ret;
2670 sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2671
2672 if (copy_to_user(argp, &entry, sizeof(entry)))
2673 return -EFAULT;
2674 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2675 return 0;
2676}
2677
2678static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2679 void __user *argp)
2680{
2681 struct cdrom_msf msf;
2682
2683 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2684
2685 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2686 return -ENOSYS;
2687 if (copy_from_user(&msf, argp, sizeof(msf)))
2688 return -EFAULT;
2689 return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2690}
2691
2692static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2693 void __user *argp)
2694{
2695 struct cdrom_ti ti;
2696 int ret;
2697
2698 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2699
2700 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2701 return -ENOSYS;
2702 if (copy_from_user(&ti, argp, sizeof(ti)))
2703 return -EFAULT;
2704
2705 ret = check_for_audio_disc(cdi, cdi->ops);
2706 if (ret)
2707 return ret;
2708 return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2709}
2710static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2711 void __user *argp)
2712{
2713 struct cdrom_volctrl volume;
2714
2715 cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2716
2717 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2718 return -ENOSYS;
2719 if (copy_from_user(&volume, argp, sizeof(volume)))
2720 return -EFAULT;
2721 return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2722}
2723
2724static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2725 void __user *argp)
2726{
2727 struct cdrom_volctrl volume;
2728 int ret;
2729
2730 cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2731
2732 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2733 return -ENOSYS;
2734
2735 ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2736 if (ret)
2737 return ret;
2738
2739 if (copy_to_user(argp, &volume, sizeof(volume)))
2740 return -EFAULT;
2741 return 0;
2742}
2743
2744static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2745 unsigned int cmd)
2746{
2747 int ret;
2748
2749 cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2750
2751 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2752 return -ENOSYS;
2753 ret = check_for_audio_disc(cdi, cdi->ops);
2754 if (ret)
2755 return ret;
2756 return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2757}
2758
2759/*
2760 * Just about every imaginable ioctl is supported in the Uniform layer
2761 * these days.
2762 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2763 */
2764int cdrom_ioctl(struct file * file, struct cdrom_device_info *cdi,
2765 struct inode *ip, unsigned int cmd, unsigned long arg)
2766{
2767 void __user *argp = (void __user *)arg;
2768 int ret;
45e79a3a 2769 struct gendisk *disk = ip->i_bdev->bd_disk;
d2c5d4fc
CH		 2770
2771 /*
2772 * Try the generic SCSI command ioctl's first.
2773 */
45e79a3a 2774 ret = scsi_cmd_ioctl(file, disk->queue, disk, cmd, argp);
d2c5d4fc
CH		 2775 if (ret != -ENOTTY)
2776 return ret;
2777
2778 switch (cmd) {
2779 case CDROMMULTISESSION:
2780 return cdrom_ioctl_multisession(cdi, argp);
2781 case CDROMEJECT:
2782 return cdrom_ioctl_eject(cdi);
2783 case CDROMCLOSETRAY:
2784 return cdrom_ioctl_closetray(cdi);
2785 case CDROMEJECT_SW:
2786 return cdrom_ioctl_eject_sw(cdi, arg);
2787 case CDROM_MEDIA_CHANGED:
2788 return cdrom_ioctl_media_changed(cdi, arg);
2789 case CDROM_SET_OPTIONS:
2790 return cdrom_ioctl_set_options(cdi, arg);
2791 case CDROM_CLEAR_OPTIONS:
2792 return cdrom_ioctl_clear_options(cdi, arg);
2793 case CDROM_SELECT_SPEED:
2794 return cdrom_ioctl_select_speed(cdi, arg);
2795 case CDROM_SELECT_DISC:
2796 return cdrom_ioctl_select_disc(cdi, arg);
2797 case CDROMRESET:
2798 return cdrom_ioctl_reset(cdi, ip->i_bdev);
2799 case CDROM_LOCKDOOR:
2800 return cdrom_ioctl_lock_door(cdi, arg);
2801 case CDROM_DEBUG:
2802 return cdrom_ioctl_debug(cdi, arg);
2803 case CDROM_GET_CAPABILITY:
2804 return cdrom_ioctl_get_capability(cdi);
2805 case CDROM_GET_MCN:
2806 return cdrom_ioctl_get_mcn(cdi, argp);
2807 case CDROM_DRIVE_STATUS:
2808 return cdrom_ioctl_drive_status(cdi, arg);
2809 case CDROM_DISC_STATUS:
2810 return cdrom_ioctl_disc_status(cdi);
2811 case CDROM_CHANGER_NSLOTS:
2812 return cdrom_ioctl_changer_nslots(cdi);
2813 }
2814
2815 /*
2816 * Use the ioctls that are implemented through the generic_packet()
2817 * interface. this may look at bit funny, but if -ENOTTY is
2818 * returned that particular ioctl is not implemented and we
2819 * let it go through the device specific ones.
2820 */
1da177e4
LT		 2821 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2822 ret = mmc_ioctl(cdi, cmd, arg);
d2c5d4fc 2823 if (ret != -ENOTTY)
1da177e4 2824 return ret;
1da177e4
LT		 2825 }
2826
d2c5d4fc
CH		 2827 /*
2828 * Note: most of the cdinfo() calls are commented out here,
2829 * because they fill up the sys log when CD players poll
2830 * the drive.
2831 */
1da177e4 2832 switch (cmd) {
d2c5d4fc
CH		 2833 case CDROMSUBCHNL:
2834 return cdrom_ioctl_get_subchnl(cdi, argp);
2835 case CDROMREADTOCHDR:
2836 return cdrom_ioctl_read_tochdr(cdi, argp);
2837 case CDROMREADTOCENTRY:
2838 return cdrom_ioctl_read_tocentry(cdi, argp);
2839 case CDROMPLAYMSF:
2840 return cdrom_ioctl_play_msf(cdi, argp);
2841 case CDROMPLAYTRKIND:
2842 return cdrom_ioctl_play_trkind(cdi, argp);
2843 case CDROMVOLCTRL:
2844 return cdrom_ioctl_volctrl(cdi, argp);
2845 case CDROMVOLREAD:
2846 return cdrom_ioctl_volread(cdi, argp);
1da177e4
LT		 2847 case CDROMSTART:
2848 case CDROMSTOP:
2849 case CDROMPAUSE:
d2c5d4fc
CH		 2850 case CDROMRESUME:
2851 return cdrom_ioctl_audioctl(cdi, cmd);
2852 }
1da177e4 2853
1da177e4
LT		 2854 return -ENOSYS;
2855}
2856
1da177e4
LT		 2857/*
2858 * Required when we need to use READ_10 to issue other than 2048 block
2859 * reads
2860 */
2861static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2862{
2863 struct cdrom_device_ops *cdo = cdi->ops;
2864 struct packet_command cgc;
2865 struct modesel_head mh;
2866
2867 memset(&mh, 0, sizeof(mh));
2868 mh.block_desc_length = 0x08;
2869 mh.block_length_med = (size >> 8) & 0xff;
2870 mh.block_length_lo = size & 0xff;
2871
2872 memset(&cgc, 0, sizeof(cgc));
2873 cgc.cmd[0] = 0x15;
2874 cgc.cmd[1] = 1 << 4;
2875 cgc.cmd[4] = 12;
2876 cgc.buflen = sizeof(mh);
2877 cgc.buffer = (char *) &mh;
2878 cgc.data_direction = CGC_DATA_WRITE;
2879 mh.block_desc_length = 0x08;
2880 mh.block_length_med = (size >> 8) & 0xff;
2881 mh.block_length_lo = size & 0xff;
2882
2883 return cdo->generic_packet(cdi, &cgc);
2884}
2885
2886static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
2887 unsigned long arg)
2888{
2889 struct cdrom_device_ops *cdo = cdi->ops;
2890 struct packet_command cgc;
2891 struct request_sense sense;
2892 unsigned char buffer[32];
2893 int ret = 0;
2894
2895 memset(&cgc, 0, sizeof(cgc));
2896
2897 /* build a unified command and queue it through
2898 cdo->generic_packet() */
2899 switch (cmd) {
2900 case CDROMREADRAW:
2901 case CDROMREADMODE1:
2902 case CDROMREADMODE2: {
2903 struct cdrom_msf msf;
2904 int blocksize = 0, format = 0, lba;
2905
2906 switch (cmd) {
2907 case CDROMREADRAW:
2908 blocksize = CD_FRAMESIZE_RAW;
2909 break;
2910 case CDROMREADMODE1:
2911 blocksize = CD_FRAMESIZE;
2912 format = 2;
2913 break;
2914 case CDROMREADMODE2:
2915 blocksize = CD_FRAMESIZE_RAW0;
2916 break;
2917 }
2918 IOCTL_IN(arg, struct cdrom_msf, msf);
2919 lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
2920 /* FIXME: we need upper bound checking, too!! */
2921 if (lba < 0)
2922 return -EINVAL;
5cbded58 2923 cgc.buffer = kmalloc(blocksize, GFP_KERNEL);
1da177e4
LT		 2924 if (cgc.buffer == NULL)
2925 return -ENOMEM;
2926 memset(&sense, 0, sizeof(sense));
2927 cgc.sense = &sense;
2928 cgc.data_direction = CGC_DATA_READ;
2929 ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
2930 if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) {
2931 /*
2932 * SCSI-II devices are not required to support
2933 * READ_CD, so let's try switching block size
2934 */
2935 /* FIXME: switch back again... */
2936 if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
2937 kfree(cgc.buffer);
2938 return ret;
2939 }
2940 cgc.sense = NULL;
2941 ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
2942 ret |= cdrom_switch_blocksize(cdi, blocksize);
2943 }
2944 if (!ret && copy_to_user((char __user *)arg, cgc.buffer, blocksize))
2945 ret = -EFAULT;
2946 kfree(cgc.buffer);
2947 return ret;
2948 }
2949 case CDROMREADAUDIO: {
2950 struct cdrom_read_audio ra;
2951 int lba;
2952
2953 IOCTL_IN(arg, struct cdrom_read_audio, ra);
2954
2955 if (ra.addr_format == CDROM_MSF)
2956 lba = msf_to_lba(ra.addr.msf.minute,
2957 ra.addr.msf.second,
2958 ra.addr.msf.frame);
2959 else if (ra.addr_format == CDROM_LBA)
2960 lba = ra.addr.lba;
2961 else
2962 return -EINVAL;
2963
2964 /* FIXME: we need upper bound checking, too!! */
2965 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2966 return -EINVAL;
2967
2968 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2969 }
2970 case CDROMSUBCHNL: {
2971 struct cdrom_subchnl q;
2972 u_char requested, back;
2973 IOCTL_IN(arg, struct cdrom_subchnl, q);
2974 requested = q.cdsc_format;
2975 if (!((requested == CDROM_MSF) ||
2976 (requested == CDROM_LBA)))
2977 return -EINVAL;
2978 q.cdsc_format = CDROM_MSF;
2979 if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
2980 return ret;
2981 back = q.cdsc_format; /* local copy */
2982 sanitize_format(&q.cdsc_absaddr, &back, requested);
2983 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2984 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2985 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2986 return 0;
2987 }
2988 case CDROMPLAYMSF: {
2989 struct cdrom_msf msf;
2990 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2991 IOCTL_IN(arg, struct cdrom_msf, msf);
2992 cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2993 cgc.cmd[3] = msf.cdmsf_min0;
2994 cgc.cmd[4] = msf.cdmsf_sec0;
2995 cgc.cmd[5] = msf.cdmsf_frame0;
2996 cgc.cmd[6] = msf.cdmsf_min1;
2997 cgc.cmd[7] = msf.cdmsf_sec1;
2998 cgc.cmd[8] = msf.cdmsf_frame1;
2999 cgc.data_direction = CGC_DATA_NONE;
3000 return cdo->generic_packet(cdi, &cgc);
3001 }
3002 case CDROMPLAYBLK: {
3003 struct cdrom_blk blk;
3004 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
3005 IOCTL_IN(arg, struct cdrom_blk, blk);
3006 cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
3007 cgc.cmd[2] = (blk.from >> 24) & 0xff;
3008 cgc.cmd[3] = (blk.from >> 16) & 0xff;
3009 cgc.cmd[4] = (blk.from >> 8) & 0xff;
3010 cgc.cmd[5] = blk.from & 0xff;
3011 cgc.cmd[7] = (blk.len >> 8) & 0xff;
3012 cgc.cmd[8] = blk.len & 0xff;
3013 cgc.data_direction = CGC_DATA_NONE;
3014 return cdo->generic_packet(cdi, &cgc);
3015 }
3016 case CDROMVOLCTRL:
3017 case CDROMVOLREAD: {
3018 struct cdrom_volctrl volctrl;
3019 char mask[sizeof(buffer)];
3020 unsigned short offset;
3021
3022 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3023
3024 IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
3025
3026 cgc.buffer = buffer;
3027 cgc.buflen = 24;
3028 if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
3029 return ret;
3030
3031 /* originally the code depended on buffer[1] to determine
3032 how much data is available for transfer. buffer[1] is
3033 unfortunately ambigious and the only reliable way seem
3034 to be to simply skip over the block descriptor... */
56052d52 3035 offset = 8 + be16_to_cpu(*(__be16 *)(buffer+6));
1da177e4
LT		 3036
3037 if (offset + 16 > sizeof(buffer))
3038 return -E2BIG;
3039
3040 if (offset + 16 > cgc.buflen) {
3041 cgc.buflen = offset+16;
3042 ret = cdrom_mode_sense(cdi, &cgc,
3043 GPMODE_AUDIO_CTL_PAGE, 0);
3044 if (ret)
3045 return ret;
3046 }
3047
3048 /* sanity check */
3049 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3050 buffer[offset+1] < 14)
3051 return -EINVAL;
3052
3053 /* now we have the current volume settings. if it was only
3054 a CDROMVOLREAD, return these values */
3055 if (cmd == CDROMVOLREAD) {
3056 volctrl.channel0 = buffer[offset+9];
3057 volctrl.channel1 = buffer[offset+11];
3058 volctrl.channel2 = buffer[offset+13];
3059 volctrl.channel3 = buffer[offset+15];
3060 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
3061 return 0;
3062 }
3063
3064 /* get the volume mask */
3065 cgc.buffer = mask;
3066 if ((ret = cdrom_mode_sense(cdi, &cgc,
3067 GPMODE_AUDIO_CTL_PAGE, 1)))
3068 return ret;
3069
3070 buffer[offset+9] = volctrl.channel0 & mask[offset+9];
3071 buffer[offset+11] = volctrl.channel1 & mask[offset+11];
3072 buffer[offset+13] = volctrl.channel2 & mask[offset+13];
3073 buffer[offset+15] = volctrl.channel3 & mask[offset+15];
3074
3075 /* set volume */
3076 cgc.buffer = buffer + offset - 8;
3077 memset(cgc.buffer, 0, 8);
3078 return cdrom_mode_select(cdi, &cgc);
3079 }
3080
3081 case CDROMSTART:
3082 case CDROMSTOP: {
3083 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3084 cgc.cmd[0] = GPCMD_START_STOP_UNIT;
3085 cgc.cmd[1] = 1;
3086 cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3087 cgc.data_direction = CGC_DATA_NONE;
3088 return cdo->generic_packet(cdi, &cgc);
3089 }
3090
3091 case CDROMPAUSE:
3092 case CDROMRESUME: {
3093 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3094 cgc.cmd[0] = GPCMD_PAUSE_RESUME;
3095 cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3096 cgc.data_direction = CGC_DATA_NONE;
3097 return cdo->generic_packet(cdi, &cgc);
3098 }
3099
3100 case DVD_READ_STRUCT: {
3101 dvd_struct *s;
3102 int size = sizeof(dvd_struct);
3103 if (!CDROM_CAN(CDC_DVD))
3104 return -ENOSYS;
5cbded58 3105 if ((s = kmalloc(size, GFP_KERNEL)) == NULL)
1da177e4
LT		 3106 return -ENOMEM;
3107 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3108 if (copy_from_user(s, (dvd_struct __user *)arg, size)) {
3109 kfree(s);
3110 return -EFAULT;
3111 }
3112 if ((ret = dvd_read_struct(cdi, s))) {
3113 kfree(s);
3114 return ret;
3115 }
3116 if (copy_to_user((dvd_struct __user *)arg, s, size))
3117 ret = -EFAULT;
3118 kfree(s);
3119 return ret;
3120 }
3121
3122 case DVD_AUTH: {
3123 dvd_authinfo ai;
3124 if (!CDROM_CAN(CDC_DVD))
3125 return -ENOSYS;
3126 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
3127 IOCTL_IN(arg, dvd_authinfo, ai);
3128 if ((ret = dvd_do_auth (cdi, &ai)))
3129 return ret;
3130 IOCTL_OUT(arg, dvd_authinfo, ai);
3131 return 0;
3132 }
3133
3134 case CDROM_NEXT_WRITABLE: {
3135 long next = 0;
3136 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3137 if ((ret = cdrom_get_next_writable(cdi, &next)))
3138 return ret;
3139 IOCTL_OUT(arg, long, next);
3140 return 0;
3141 }
3142 case CDROM_LAST_WRITTEN: {
3143 long last = 0;
3144 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3145 if ((ret = cdrom_get_last_written(cdi, &last)))
3146 return ret;
3147 IOCTL_OUT(arg, long, last);
3148 return 0;
3149 }
3150 } /* switch */
3151
3152 return -ENOTTY;
3153}
3154
3155static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
3156 track_information *ti)
3157{
3158 struct cdrom_device_ops *cdo = cdi->ops;
3159 struct packet_command cgc;
3160 int ret, buflen;
3161
3162 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3163 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3164 cgc.cmd[1] = type & 3;
3165 cgc.cmd[4] = (track & 0xff00) >> 8;
3166 cgc.cmd[5] = track & 0xff;
3167 cgc.cmd[8] = 8;
3168 cgc.quiet = 1;
3169
3170 if ((ret = cdo->generic_packet(cdi, &cgc)))
3171 return ret;
3172
3173 buflen = be16_to_cpu(ti->track_information_length) +
3174 sizeof(ti->track_information_length);
3175
3176 if (buflen > sizeof(track_information))
3177 buflen = sizeof(track_information);
3178
3179 cgc.cmd[8] = cgc.buflen = buflen;
3180 if ((ret = cdo->generic_packet(cdi, &cgc)))
3181 return ret;
3182
3183 /* return actual fill size */
3184 return buflen;
3185}
3186
3187/* requires CD R/RW */
3188static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3189{
3190 struct cdrom_device_ops *cdo = cdi->ops;
3191 struct packet_command cgc;
3192 int ret, buflen;
3193
3194 /* set up command and get the disc info */
3195 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3196 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3197 cgc.cmd[8] = cgc.buflen = 2;
3198 cgc.quiet = 1;
3199
3200 if ((ret = cdo->generic_packet(cdi, &cgc)))
3201 return ret;
3202
3203 /* not all drives have the same disc_info length, so requeue
3204 * packet with the length the drive tells us it can supply
3205 */
3206 buflen = be16_to_cpu(di->disc_information_length) +
3207 sizeof(di->disc_information_length);
3208
3209 if (buflen > sizeof(disc_information))
3210 buflen = sizeof(disc_information);
3211
3212 cgc.cmd[8] = cgc.buflen = buflen;
3213 if ((ret = cdo->generic_packet(cdi, &cgc)))
3214 return ret;
3215
3216 /* return actual fill size */
3217 return buflen;
3218}
3219
3220/* return the last written block on the CD-R media. this is for the udf
3221 file system. */
3222int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
3223{
3224 struct cdrom_tocentry toc;
3225 disc_information di;
3226 track_information ti;
3227 __u32 last_track;
3228 int ret = -1, ti_size;
3229
3230 if (!CDROM_CAN(CDC_GENERIC_PACKET))
3231 goto use_toc;
3232
3233 ret = cdrom_get_disc_info(cdi, &di);
3234 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
3235 + sizeof(di.last_track_lsb)))
3236 goto use_toc;
3237
3238 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3239 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3240 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3241 if (ti_size < (int)offsetof(typeof(ti), track_start))
3242 goto use_toc;
3243
3244 /* if this track is blank, try the previous. */
3245 if (ti.blank) {
3246 if (last_track==1)
3247 goto use_toc;
3248 last_track--;
3249 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3250 }
3251
3252 if (ti_size < (int)(offsetof(typeof(ti), track_size)
3253 + sizeof(ti.track_size)))
3254 goto use_toc;
3255
3256 /* if last recorded field is valid, return it. */
3257 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3258 + sizeof(ti.last_rec_address))) {
3259 *last_written = be32_to_cpu(ti.last_rec_address);
3260 } else {
3261 /* make it up instead */
3262 *last_written = be32_to_cpu(ti.track_start) +
3263 be32_to_cpu(ti.track_size);
3264 if (ti.free_blocks)
3265 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3266 }
3267 return 0;
3268
3269 /* this is where we end up if the drive either can't do a
3270 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3271 it doesn't give enough information or fails. then we return
3272 the toc contents. */
3273use_toc:
3274 toc.cdte_format = CDROM_MSF;
3275 toc.cdte_track = CDROM_LEADOUT;
3276 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
3277 return ret;
3278 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
3279 *last_written = toc.cdte_addr.lba;
3280 return 0;
3281}
3282
3283/* return the next writable block. also for udf file system. */
3284static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3285{
3286 disc_information di;
3287 track_information ti;
3288 __u16 last_track;
3289 int ret, ti_size;
3290
3291 if (!CDROM_CAN(CDC_GENERIC_PACKET))
3292 goto use_last_written;
3293
3294 ret = cdrom_get_disc_info(cdi, &di);
3295 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3296 + sizeof(di.last_track_lsb))
3297 goto use_last_written;
3298
3299 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3300 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3301 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3302 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3303 goto use_last_written;
3304
3305 /* if this track is blank, try the previous. */
3306 if (ti.blank) {
3307 if (last_track == 1)
3308 goto use_last_written;
3309 last_track--;
3310 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3311 if (ti_size < 0)
3312 goto use_last_written;
3313 }
3314
3315 /* if next recordable address field is valid, use it. */
3316 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
3317 + sizeof(ti.next_writable)) {
3318 *next_writable = be32_to_cpu(ti.next_writable);
3319 return 0;
3320 }
3321
3322use_last_written:
3323 if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3324 *next_writable = 0;
3325 return ret;
3326 } else {
3327 *next_writable += 7;
3328 return 0;
3329 }
3330}
3331
3332EXPORT_SYMBOL(cdrom_get_last_written);
3333EXPORT_SYMBOL(register_cdrom);
3334EXPORT_SYMBOL(unregister_cdrom);
3335EXPORT_SYMBOL(cdrom_open);
3336EXPORT_SYMBOL(cdrom_release);
3337EXPORT_SYMBOL(cdrom_ioctl);
3338EXPORT_SYMBOL(cdrom_media_changed);
3339EXPORT_SYMBOL(cdrom_number_of_slots);
3340EXPORT_SYMBOL(cdrom_mode_select);
3341EXPORT_SYMBOL(cdrom_mode_sense);
3342EXPORT_SYMBOL(init_cdrom_command);
3343EXPORT_SYMBOL(cdrom_get_media_event);
3344
3345#ifdef CONFIG_SYSCTL
3346
3347#define CDROM_STR_SIZE 1000
3348
3349static struct cdrom_sysctl_settings {
3350 char info[CDROM_STR_SIZE]; /* general info */
3351 int autoclose; /* close tray upon mount, etc */
3352 int autoeject; /* eject on umount */
3353 int debug; /* turn on debugging messages */
3354 int lock; /* lock the door on device open */
3355 int check; /* check media type */
3356} cdrom_sysctl_settings;
3357
554988d6
DY		 3358enum cdrom_print_option {
3359 CTL_NAME,
3360 CTL_SPEED,
3361 CTL_SLOTS,
3362 CTL_CAPABILITY
3363};
3364
3365static int cdrom_print_info(const char *header, int val, char *info,
3366 int *pos, enum cdrom_print_option option)
3367{
3368 const int max_size = sizeof(cdrom_sysctl_settings.info);
3369 struct cdrom_device_info *cdi;
3370 int ret;
3371
3372 ret = scnprintf(info + *pos, max_size - *pos, header);
3373 if (!ret)
3374 return 1;
3375
3376 *pos += ret;
3377
7fd097d4 3378 list_for_each_entry(cdi, &cdrom_list, list) {
554988d6
DY		 3379 switch (option) {
3380 case CTL_NAME:
3381 ret = scnprintf(info + *pos, max_size - *pos,
3382 "\t%s", cdi->name);
3383 break;
3384 case CTL_SPEED:
3385 ret = scnprintf(info + *pos, max_size - *pos,
3386 "\t%d", cdi->speed);
3387 break;
3388 case CTL_SLOTS:
3389 ret = scnprintf(info + *pos, max_size - *pos,
3390 "\t%d", cdi->capacity);
3391 break;
3392 case CTL_CAPABILITY:
3393 ret = scnprintf(info + *pos, max_size - *pos,
3394 "\t%d", CDROM_CAN(val) != 0);
3395 break;
3396 default:
3397 printk(KERN_INFO "cdrom: invalid option%d\n", option);
3398 return 1;
3399 }
3400 if (!ret)
3401 return 1;
3402 *pos += ret;
3403 }
3404
3405 return 0;
3406}
3407
1da177e4
LT		 3408static int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
3409 void __user *buffer, size_t *lenp, loff_t *ppos)
3410{
554988d6 3411 int pos;
1da177e4 3412 char *info = cdrom_sysctl_settings.info;
554988d6 3413 const int max_size = sizeof(cdrom_sysctl_settings.info);
1da177e4
LT		 3414
3415 if (!*lenp || (*ppos && !write)) {
3416 *lenp = 0;
3417 return 0;
3418 }
3419
554988d6
DY		 3420 mutex_lock(&cdrom_mutex);
3421
1da177e4
LT		 3422 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3423
554988d6
DY		 3424 if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3425 goto done;
3426 if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3427 goto done;
3428 if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3429 goto done;
3430 if (cdrom_print_info("\nCan close tray:\t",
3431 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3432 goto done;
3433 if (cdrom_print_info("\nCan open tray:\t",
3434 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3435 goto done;
3436 if (cdrom_print_info("\nCan lock tray:\t",
3437 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3438 goto done;
3439 if (cdrom_print_info("\nCan change speed:",
3440 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3441 goto done;
3442 if (cdrom_print_info("\nCan select disk:",
3443 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3444 goto done;
3445 if (cdrom_print_info("\nCan read multisession:",
3446 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3447 goto done;
3448 if (cdrom_print_info("\nCan read MCN:\t",
3449 CDC_MCN, info, &pos, CTL_CAPABILITY))
3450 goto done;
3451 if (cdrom_print_info("\nReports media changed:",
3452 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3453 goto done;
3454 if (cdrom_print_info("\nCan play audio:\t",
3455 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3456 goto done;
3457 if (cdrom_print_info("\nCan write CD-R:\t",
3458 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3459 goto done;
3460 if (cdrom_print_info("\nCan write CD-RW:",
3461 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3462 goto done;
3463 if (cdrom_print_info("\nCan read DVD:\t",
3464 CDC_DVD, info, &pos, CTL_CAPABILITY))
3465 goto done;
3466 if (cdrom_print_info("\nCan write DVD-R:",
3467 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3468 goto done;
3469 if (cdrom_print_info("\nCan write DVD-RAM:",
3470 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3471 goto done;
3472 if (cdrom_print_info("\nCan read MRW:\t",
3473 CDC_MRW, info, &pos, CTL_CAPABILITY))
3474 goto done;
3475 if (cdrom_print_info("\nCan write MRW:\t",
3476 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3477 goto done;
3478 if (cdrom_print_info("\nCan write RAM:\t",
3479 CDC_RAM, info, &pos, CTL_CAPABILITY))
3480 goto done;
3481 if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3482 goto done;
3483doit:
3484 mutex_unlock(&cdrom_mutex);
3485 return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
3486done:
3487 printk(KERN_INFO "cdrom: info buffer too small\n");
3488 goto doit;
1da177e4
LT		 3489}
3490
3491/* Unfortunately, per device settings are not implemented through
3492 procfs/sysctl yet. When they are, this will naturally disappear. For now
3493 just update all drives. Later this will become the template on which
3494 new registered drives will be based. */
3495static void cdrom_update_settings(void)
3496{
3497 struct cdrom_device_info *cdi;
3498
032d8d90 3499 mutex_lock(&cdrom_mutex);
7fd097d4 3500 list_for_each_entry(cdi, &cdrom_list, list) {
1da177e4
LT		 3501 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3502 cdi->options |= CDO_AUTO_CLOSE;
3503 else if (!autoclose)
3504 cdi->options &= ~CDO_AUTO_CLOSE;
3505 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3506 cdi->options |= CDO_AUTO_EJECT;
3507 else if (!autoeject)
3508 cdi->options &= ~CDO_AUTO_EJECT;
3509 if (lockdoor && CDROM_CAN(CDC_LOCK))
3510 cdi->options |= CDO_LOCK;
3511 else if (!lockdoor)
3512 cdi->options &= ~CDO_LOCK;
3513 if (check_media_type)
3514 cdi->options |= CDO_CHECK_TYPE;
3515 else
3516 cdi->options &= ~CDO_CHECK_TYPE;
3517 }
032d8d90 3518 mutex_unlock(&cdrom_mutex);
1da177e4
LT		 3519}
3520
3521static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
3522 void __user *buffer, size_t *lenp, loff_t *ppos)
3523{
1da177e4
LT		 3524 int ret;
3525
3526 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
3527
06489b4e 3528 if (write) {
1da177e4
LT		 3529
3530 /* we only care for 1 or 0. */
06489b4e
EB		 3531 autoclose = !!cdrom_sysctl_settings.autoclose;
3532 autoeject = !!cdrom_sysctl_settings.autoeject;
3533 debug = !!cdrom_sysctl_settings.debug;
3534 lockdoor = !!cdrom_sysctl_settings.lock;
3535 check_media_type = !!cdrom_sysctl_settings.check;
1da177e4 3536
1da177e4
LT		 3537 /* update the option flags according to the changes. we
3538 don't have per device options through sysctl yet,
3539 but we will have and then this will disappear. */
3540 cdrom_update_settings();
3541 }
3542
3543 return ret;
3544}
3545
3546/* Place files in /proc/sys/dev/cdrom */
3547static ctl_table cdrom_table[] = {
3548 {
1da177e4
LT		 3549 .procname = "info",
3550 .data = &cdrom_sysctl_settings.info,
3551 .maxlen = CDROM_STR_SIZE,
3552 .mode = 0444,
3553 .proc_handler = &cdrom_sysctl_info,
3554 },
3555 {
1da177e4
LT		 3556 .procname = "autoclose",
3557 .data = &cdrom_sysctl_settings.autoclose,
3558 .maxlen = sizeof(int),
3559 .mode = 0644,
3560 .proc_handler = &cdrom_sysctl_handler,
3561 },
3562 {
1da177e4
LT		 3563 .procname = "autoeject",
3564 .data = &cdrom_sysctl_settings.autoeject,
3565 .maxlen = sizeof(int),
3566 .mode = 0644,
3567 .proc_handler = &cdrom_sysctl_handler,
3568 },
3569 {
1da177e4
LT		 3570 .procname = "debug",
3571 .data = &cdrom_sysctl_settings.debug,
3572 .maxlen = sizeof(int),
3573 .mode = 0644,
3574 .proc_handler = &cdrom_sysctl_handler,
3575 },
3576 {
1da177e4
LT		 3577 .procname = "lock",
3578 .data = &cdrom_sysctl_settings.lock,
3579 .maxlen = sizeof(int),
3580 .mode = 0644,
3581 .proc_handler = &cdrom_sysctl_handler,
3582 },
3583 {
1da177e4
LT		 3584 .procname = "check_media",
3585 .data = &cdrom_sysctl_settings.check,
3586 .maxlen = sizeof(int),
3587 .mode = 0644,
3588 .proc_handler = &cdrom_sysctl_handler
3589 },
3590 { .ctl_name = 0 }
3591};
3592
3593static ctl_table cdrom_cdrom_table[] = {
3594 {
3595 .ctl_name = DEV_CDROM,
3596 .procname = "cdrom",
3597 .maxlen = 0,
3598 .mode = 0555,
3599 .child = cdrom_table,
3600 },
3601 { .ctl_name = 0 }
3602};
3603
3604/* Make sure that /proc/sys/dev is there */
3605static ctl_table cdrom_root_table[] = {
3606 {
3607 .ctl_name = CTL_DEV,
3608 .procname = "dev",
3609 .maxlen = 0,
3610 .mode = 0555,
3611 .child = cdrom_cdrom_table,
3612 },
3613 { .ctl_name = 0 }
3614};
3615static struct ctl_table_header *cdrom_sysctl_header;
3616
3617static void cdrom_sysctl_register(void)
3618{
3619 static int initialized;
3620
3621 if (initialized == 1)
3622 return;
3623
0b4d4147 3624 cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
1da177e4
LT		 3625
3626 /* set the defaults */
3627 cdrom_sysctl_settings.autoclose = autoclose;
3628 cdrom_sysctl_settings.autoeject = autoeject;
3629 cdrom_sysctl_settings.debug = debug;
3630 cdrom_sysctl_settings.lock = lockdoor;
3631 cdrom_sysctl_settings.check = check_media_type;
3632
3633 initialized = 1;
3634}
3635
3636static void cdrom_sysctl_unregister(void)
3637{
3638 if (cdrom_sysctl_header)
3639 unregister_sysctl_table(cdrom_sysctl_header);
3640}
3641
17672cf0
AM		 3642#else /* CONFIG_SYSCTL */
3643
3644static void cdrom_sysctl_register(void)
3645{
3646}
3647
3648static void cdrom_sysctl_unregister(void)
3649{
3650}
3651
1da177e4
LT		 3652#endif /* CONFIG_SYSCTL */
3653
3654static int __init cdrom_init(void)
3655{
1da177e4 3656 cdrom_sysctl_register();
17672cf0 3657
1da177e4
LT		 3658 return 0;
3659}
3660
3661static void __exit cdrom_exit(void)
3662{
3663 printk(KERN_INFO "Uniform CD-ROM driver unloaded\n");
1da177e4 3664 cdrom_sysctl_unregister();
1da177e4
LT		 3665}
3666
3667module_init(cdrom_init);
3668module_exit(cdrom_exit);
3669MODULE_LICENSE("GPL");
Clone of davem's net-next-2.6 tree