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