ide-cd: move lba_to_msf() and msf_to_lba() to <linux/cdrom.h>
[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 /* Admittedly, the logic below could be performed in a nicer way. */
1210 int cdrom_release(struct cdrom_device_info *cdi, struct file *fp)
1211 {
1212         struct cdrom_device_ops *cdo = cdi->ops;
1213         int opened_for_data;
1214
1215         cdinfo(CD_CLOSE, "entering cdrom_release\n"); 
1216
1217         if (cdi->use_count > 0)
1218                 cdi->use_count--;
1219         if (cdi->use_count == 0)
1220                 cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
1221         if (cdi->use_count == 0)
1222                 cdrom_dvd_rw_close_write(cdi);
1223         if (cdi->use_count == 0 &&
1224             (cdo->capability & CDC_LOCK) && !keeplocked) {
1225                 cdinfo(CD_CLOSE, "Unlocking door!\n");
1226                 cdo->lock_door(cdi, 0);
1227         }
1228         opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1229                 !(fp && fp->f_flags & O_NONBLOCK);
1230
1231         /*
1232          * flush cache on last write release
1233          */
1234         if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1235                 cdrom_close_write(cdi);
1236
1237         cdo->release(cdi);
1238         if (cdi->use_count == 0) {      /* last process that closes dev*/
1239                 if (opened_for_data &&
1240                     cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1241                         cdo->tray_move(cdi, 1);
1242         }
1243         return 0;
1244 }
1245
1246 static int cdrom_read_mech_status(struct cdrom_device_info *cdi, 
1247                                   struct cdrom_changer_info *buf)
1248 {
1249         struct packet_command cgc;
1250         struct cdrom_device_ops *cdo = cdi->ops;
1251         int length;
1252
1253         /*
1254          * Sanyo changer isn't spec compliant (doesn't use regular change
1255          * LOAD_UNLOAD command, and it doesn't implement the mech status
1256          * command below
1257          */
1258         if (cdi->sanyo_slot) {
1259                 buf->hdr.nslots = 3;
1260                 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1261                 for (length = 0; length < 3; length++) {
1262                         buf->slots[length].disc_present = 1;
1263                         buf->slots[length].change = 0;
1264                 }
1265                 return 0;
1266         }
1267
1268         length = sizeof(struct cdrom_mechstat_header) +
1269                  cdi->capacity * sizeof(struct cdrom_slot);
1270
1271         init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1272         cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1273         cgc.cmd[8] = (length >> 8) & 0xff;
1274         cgc.cmd[9] = length & 0xff;
1275         return cdo->generic_packet(cdi, &cgc);
1276 }
1277
1278 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1279 {
1280         struct cdrom_changer_info *info;
1281         int ret;
1282
1283         cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n"); 
1284         if (cdi->sanyo_slot)
1285                 return CDS_NO_INFO;
1286         
1287         info = kmalloc(sizeof(*info), GFP_KERNEL);
1288         if (!info)
1289                 return -ENOMEM;
1290
1291         if ((ret = cdrom_read_mech_status(cdi, info)))
1292                 goto out_free;
1293
1294         if (info->slots[slot].disc_present)
1295                 ret = CDS_DISC_OK;
1296         else
1297                 ret = CDS_NO_DISC;
1298
1299 out_free:
1300         kfree(info);
1301         return ret;
1302 }
1303
1304 /* Return the number of slots for an ATAPI/SCSI cdrom, 
1305  * return 1 if not a changer. 
1306  */
1307 int cdrom_number_of_slots(struct cdrom_device_info *cdi) 
1308 {
1309         int status;
1310         int nslots = 1;
1311         struct cdrom_changer_info *info;
1312
1313         cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n"); 
1314         /* cdrom_read_mech_status requires a valid value for capacity: */
1315         cdi->capacity = 0; 
1316
1317         info = kmalloc(sizeof(*info), GFP_KERNEL);
1318         if (!info)
1319                 return -ENOMEM;
1320
1321         if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1322                 nslots = info->hdr.nslots;
1323
1324         kfree(info);
1325         return nslots;
1326 }
1327
1328
1329 /* If SLOT < 0, unload the current slot.  Otherwise, try to load SLOT. */
1330 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot) 
1331 {
1332         struct packet_command cgc;
1333
1334         cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n"); 
1335         if (cdi->sanyo_slot && slot < 0)
1336                 return 0;
1337
1338         init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1339         cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1340         cgc.cmd[4] = 2 + (slot >= 0);
1341         cgc.cmd[8] = slot;
1342         cgc.timeout = 60 * HZ;
1343
1344         /* The Sanyo 3 CD changer uses byte 7 of the 
1345         GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1346         using the GPCMD_LOAD_UNLOAD opcode. */
1347         if (cdi->sanyo_slot && -1 < slot) {
1348                 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1349                 cgc.cmd[7] = slot;
1350                 cgc.cmd[4] = cgc.cmd[8] = 0;
1351                 cdi->sanyo_slot = slot ? slot : 3;
1352         }
1353
1354         return cdi->ops->generic_packet(cdi, &cgc);
1355 }
1356
1357 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1358 {
1359         struct cdrom_changer_info *info;
1360         int curslot;
1361         int ret;
1362
1363         cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n"); 
1364         if (!CDROM_CAN(CDC_SELECT_DISC))
1365                 return -EDRIVE_CANT_DO_THIS;
1366
1367         (void) cdi->ops->media_changed(cdi, slot);
1368
1369         if (slot == CDSL_NONE) {
1370                 /* set media changed bits, on both queues */
1371                 cdi->mc_flags = 0x3;
1372                 return cdrom_load_unload(cdi, -1);
1373         }
1374
1375         info = kmalloc(sizeof(*info), GFP_KERNEL);
1376         if (!info)
1377                 return -ENOMEM;
1378
1379         if ((ret = cdrom_read_mech_status(cdi, info))) {
1380                 kfree(info);
1381                 return ret;
1382         }
1383
1384         curslot = info->hdr.curslot;
1385         kfree(info);
1386
1387         if (cdi->use_count > 1 || keeplocked) {
1388                 if (slot == CDSL_CURRENT) {
1389                         return curslot;
1390                 } else {
1391                         return -EBUSY;
1392                 }
1393         }
1394
1395         /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1396         which is useful if it had been previously unloaded.
1397         Whether it can or not, it returns the current slot. 
1398         Similarly,  if slot happens to be the current one, we still
1399         try and load it. */
1400         if (slot == CDSL_CURRENT)
1401                 slot = curslot;
1402
1403         /* set media changed bits on both queues */
1404         cdi->mc_flags = 0x3;
1405         if ((ret = cdrom_load_unload(cdi, slot)))
1406                 return ret;
1407
1408         return slot;
1409 }
1410
1411 /* We want to make media_changed accessible to the user through an
1412  * ioctl. The main problem now is that we must double-buffer the
1413  * low-level implementation, to assure that the VFS and the user both
1414  * see a medium change once.
1415  */
1416
1417 static
1418 int media_changed(struct cdrom_device_info *cdi, int queue)
1419 {
1420         unsigned int mask = (1 << (queue & 1));
1421         int ret = !!(cdi->mc_flags & mask);
1422
1423         if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1424             return ret;
1425         /* changed since last call? */
1426         if (cdi->ops->media_changed(cdi, CDSL_CURRENT)) {
1427                 cdi->mc_flags = 0x3;    /* set bit on both queues */
1428                 ret |= 1;
1429                 cdi->media_written = 0;
1430         }
1431         cdi->mc_flags &= ~mask;         /* clear bit */
1432         return ret;
1433 }
1434
1435 int cdrom_media_changed(struct cdrom_device_info *cdi)
1436 {
1437         /* This talks to the VFS, which doesn't like errors - just 1 or 0.  
1438          * Returning "0" is always safe (media hasn't been changed). Do that 
1439          * if the low-level cdrom driver dosn't support media changed. */ 
1440         if (cdi == NULL || cdi->ops->media_changed == NULL)
1441                 return 0;
1442         if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1443                 return 0;
1444         return media_changed(cdi, 0);
1445 }
1446
1447 /* badly broken, I know. Is due for a fixup anytime. */
1448 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1449 {
1450         struct cdrom_tochdr header;
1451         struct cdrom_tocentry entry;
1452         int ret, i;
1453         tracks->data=0;
1454         tracks->audio=0;
1455         tracks->cdi=0;
1456         tracks->xa=0;
1457         tracks->error=0;
1458         cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n"); 
1459         if (!CDROM_CAN(CDC_PLAY_AUDIO)) { 
1460                 tracks->error=CDS_NO_INFO;
1461                 return;
1462         }        
1463         /* Grab the TOC header so we can see how many tracks there are */
1464         if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1465                 if (ret == -ENOMEDIUM)
1466                         tracks->error = CDS_NO_DISC;
1467                 else
1468                         tracks->error = CDS_NO_INFO;
1469                 return;
1470         }       
1471         /* check what type of tracks are on this disc */
1472         entry.cdte_format = CDROM_MSF;
1473         for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1474                 entry.cdte_track  = i;
1475                 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1476                         tracks->error=CDS_NO_INFO;
1477                         return;
1478                 }       
1479                 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1480                     if (entry.cdte_format == 0x10)
1481                         tracks->cdi++;
1482                     else if (entry.cdte_format == 0x20) 
1483                         tracks->xa++;
1484                     else
1485                         tracks->data++;
1486                 } else
1487                     tracks->audio++;
1488                 cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1489                        i, entry.cdte_format, entry.cdte_ctrl);
1490         }       
1491         cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n", 
1492                 header.cdth_trk1, tracks->audio, tracks->data, 
1493                 tracks->cdi, tracks->xa);
1494 }       
1495
1496 /* Requests to the low-level drivers will /always/ be done in the
1497    following format convention:
1498
1499    CDROM_LBA: all data-related requests.
1500    CDROM_MSF: all audio-related requests.
1501
1502    However, a low-level implementation is allowed to refuse this
1503    request, and return information in its own favorite format.
1504
1505    It doesn't make sense /at all/ to ask for a play_audio in LBA
1506    format, or ask for multi-session info in MSF format. However, for
1507    backward compatibility these format requests will be satisfied, but
1508    the requests to the low-level drivers will be sanitized in the more
1509    meaningful format indicated above.
1510  */
1511
1512 static
1513 void sanitize_format(union cdrom_addr *addr,
1514                      u_char * curr, u_char requested)
1515 {
1516         if (*curr == requested)
1517                 return;                 /* nothing to be done! */
1518         if (requested == CDROM_LBA) {
1519                 addr->lba = (int) addr->msf.frame +
1520                         75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1521         } else {                        /* CDROM_MSF */
1522                 int lba = addr->lba;
1523                 addr->msf.frame = lba % 75;
1524                 lba /= 75;
1525                 lba += 2;
1526                 addr->msf.second = lba % 60;
1527                 addr->msf.minute = lba / 60;
1528         }
1529         *curr = requested;
1530 }
1531
1532 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1533                         int type)
1534 {
1535         memset(cgc, 0, sizeof(struct packet_command));
1536         if (buf)
1537                 memset(buf, 0, len);
1538         cgc->buffer = (char *) buf;
1539         cgc->buflen = len;
1540         cgc->data_direction = type;
1541         cgc->timeout = CDROM_DEF_TIMEOUT;
1542 }
1543
1544 /* DVD handling */
1545
1546 #define copy_key(dest,src)      memcpy((dest), (src), sizeof(dvd_key))
1547 #define copy_chal(dest,src)     memcpy((dest), (src), sizeof(dvd_challenge))
1548
1549 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1550 {
1551         cgc->cmd[0] = GPCMD_REPORT_KEY;
1552         cgc->cmd[10] = type | (agid << 6);
1553         switch (type) {
1554                 case 0: case 8: case 5: {
1555                         cgc->buflen = 8;
1556                         break;
1557                 }
1558                 case 1: {
1559                         cgc->buflen = 16;
1560                         break;
1561                 }
1562                 case 2: case 4: {
1563                         cgc->buflen = 12;
1564                         break;
1565                 }
1566         }
1567         cgc->cmd[9] = cgc->buflen;
1568         cgc->data_direction = CGC_DATA_READ;
1569 }
1570
1571 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1572 {
1573         cgc->cmd[0] = GPCMD_SEND_KEY;
1574         cgc->cmd[10] = type | (agid << 6);
1575         switch (type) {
1576                 case 1: {
1577                         cgc->buflen = 16;
1578                         break;
1579                 }
1580                 case 3: {
1581                         cgc->buflen = 12;
1582                         break;
1583                 }
1584                 case 6: {
1585                         cgc->buflen = 8;
1586                         break;
1587                 }
1588         }
1589         cgc->cmd[9] = cgc->buflen;
1590         cgc->data_direction = CGC_DATA_WRITE;
1591 }
1592
1593 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1594 {
1595         int ret;
1596         u_char buf[20];
1597         struct packet_command cgc;
1598         struct cdrom_device_ops *cdo = cdi->ops;
1599         rpc_state_t rpc_state;
1600
1601         memset(buf, 0, sizeof(buf));
1602         init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1603
1604         switch (ai->type) {
1605         /* LU data send */
1606         case DVD_LU_SEND_AGID:
1607                 cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n"); 
1608                 cgc.quiet = 1;
1609                 setup_report_key(&cgc, ai->lsa.agid, 0);
1610
1611                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1612                         return ret;
1613
1614                 ai->lsa.agid = buf[7] >> 6;
1615                 /* Returning data, let host change state */
1616                 break;
1617
1618         case DVD_LU_SEND_KEY1:
1619                 cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n"); 
1620                 setup_report_key(&cgc, ai->lsk.agid, 2);
1621
1622                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1623                         return ret;
1624
1625                 copy_key(ai->lsk.key, &buf[4]);
1626                 /* Returning data, let host change state */
1627                 break;
1628
1629         case DVD_LU_SEND_CHALLENGE:
1630                 cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n"); 
1631                 setup_report_key(&cgc, ai->lsc.agid, 1);
1632
1633                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1634                         return ret;
1635
1636                 copy_chal(ai->lsc.chal, &buf[4]);
1637                 /* Returning data, let host change state */
1638                 break;
1639
1640         /* Post-auth key */
1641         case DVD_LU_SEND_TITLE_KEY:
1642                 cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n"); 
1643                 cgc.quiet = 1;
1644                 setup_report_key(&cgc, ai->lstk.agid, 4);
1645                 cgc.cmd[5] = ai->lstk.lba;
1646                 cgc.cmd[4] = ai->lstk.lba >> 8;
1647                 cgc.cmd[3] = ai->lstk.lba >> 16;
1648                 cgc.cmd[2] = ai->lstk.lba >> 24;
1649
1650                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1651                         return ret;
1652
1653                 ai->lstk.cpm = (buf[4] >> 7) & 1;
1654                 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1655                 ai->lstk.cgms = (buf[4] >> 4) & 3;
1656                 copy_key(ai->lstk.title_key, &buf[5]);
1657                 /* Returning data, let host change state */
1658                 break;
1659
1660         case DVD_LU_SEND_ASF:
1661                 cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n"); 
1662                 setup_report_key(&cgc, ai->lsasf.agid, 5);
1663                 
1664                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1665                         return ret;
1666
1667                 ai->lsasf.asf = buf[7] & 1;
1668                 break;
1669
1670         /* LU data receive (LU changes state) */
1671         case DVD_HOST_SEND_CHALLENGE:
1672                 cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n"); 
1673                 setup_send_key(&cgc, ai->hsc.agid, 1);
1674                 buf[1] = 0xe;
1675                 copy_chal(&buf[4], ai->hsc.chal);
1676
1677                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1678                         return ret;
1679
1680                 ai->type = DVD_LU_SEND_KEY1;
1681                 break;
1682
1683         case DVD_HOST_SEND_KEY2:
1684                 cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n"); 
1685                 setup_send_key(&cgc, ai->hsk.agid, 3);
1686                 buf[1] = 0xa;
1687                 copy_key(&buf[4], ai->hsk.key);
1688
1689                 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1690                         ai->type = DVD_AUTH_FAILURE;
1691                         return ret;
1692                 }
1693                 ai->type = DVD_AUTH_ESTABLISHED;
1694                 break;
1695
1696         /* Misc */
1697         case DVD_INVALIDATE_AGID:
1698                 cgc.quiet = 1;
1699                 cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n"); 
1700                 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1701                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1702                         return ret;
1703                 break;
1704
1705         /* Get region settings */
1706         case DVD_LU_SEND_RPC_STATE:
1707                 cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1708                 setup_report_key(&cgc, 0, 8);
1709                 memset(&rpc_state, 0, sizeof(rpc_state_t));
1710                 cgc.buffer = (char *) &rpc_state;
1711
1712                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1713                         return ret;
1714
1715                 ai->lrpcs.type = rpc_state.type_code;
1716                 ai->lrpcs.vra = rpc_state.vra;
1717                 ai->lrpcs.ucca = rpc_state.ucca;
1718                 ai->lrpcs.region_mask = rpc_state.region_mask;
1719                 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1720                 break;
1721
1722         /* Set region settings */
1723         case DVD_HOST_SEND_RPC_STATE:
1724                 cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1725                 setup_send_key(&cgc, 0, 6);
1726                 buf[1] = 6;
1727                 buf[4] = ai->hrpcs.pdrc;
1728
1729                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1730                         return ret;
1731                 break;
1732
1733         default:
1734                 cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1735                 return -ENOTTY;
1736         }
1737
1738         return 0;
1739 }
1740
1741 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
1742 {
1743         unsigned char buf[21], *base;
1744         struct dvd_layer *layer;
1745         struct packet_command cgc;
1746         struct cdrom_device_ops *cdo = cdi->ops;
1747         int ret, layer_num = s->physical.layer_num;
1748
1749         if (layer_num >= DVD_LAYERS)
1750                 return -EINVAL;
1751
1752         init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1753         cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1754         cgc.cmd[6] = layer_num;
1755         cgc.cmd[7] = s->type;
1756         cgc.cmd[9] = cgc.buflen & 0xff;
1757
1758         /*
1759          * refrain from reporting errors on non-existing layers (mainly)
1760          */
1761         cgc.quiet = 1;
1762
1763         if ((ret = cdo->generic_packet(cdi, &cgc)))
1764                 return ret;
1765
1766         base = &buf[4];
1767         layer = &s->physical.layer[layer_num];
1768
1769         /*
1770          * place the data... really ugly, but at least we won't have to
1771          * worry about endianess in userspace.
1772          */
1773         memset(layer, 0, sizeof(*layer));
1774         layer->book_version = base[0] & 0xf;
1775         layer->book_type = base[0] >> 4;
1776         layer->min_rate = base[1] & 0xf;
1777         layer->disc_size = base[1] >> 4;
1778         layer->layer_type = base[2] & 0xf;
1779         layer->track_path = (base[2] >> 4) & 1;
1780         layer->nlayers = (base[2] >> 5) & 3;
1781         layer->track_density = base[3] & 0xf;
1782         layer->linear_density = base[3] >> 4;
1783         layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1784         layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1785         layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1786         layer->bca = base[16] >> 7;
1787
1788         return 0;
1789 }
1790
1791 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
1792 {
1793         int ret;
1794         u_char buf[8];
1795         struct packet_command cgc;
1796         struct cdrom_device_ops *cdo = cdi->ops;
1797
1798         init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1799         cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1800         cgc.cmd[6] = s->copyright.layer_num;
1801         cgc.cmd[7] = s->type;
1802         cgc.cmd[8] = cgc.buflen >> 8;
1803         cgc.cmd[9] = cgc.buflen & 0xff;
1804
1805         if ((ret = cdo->generic_packet(cdi, &cgc)))
1806                 return ret;
1807
1808         s->copyright.cpst = buf[4];
1809         s->copyright.rmi = buf[5];
1810
1811         return 0;
1812 }
1813
1814 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s)
1815 {
1816         int ret, size;
1817         u_char *buf;
1818         struct packet_command cgc;
1819         struct cdrom_device_ops *cdo = cdi->ops;
1820
1821         size = sizeof(s->disckey.value) + 4;
1822
1823         if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1824                 return -ENOMEM;
1825
1826         init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1827         cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1828         cgc.cmd[7] = s->type;
1829         cgc.cmd[8] = size >> 8;
1830         cgc.cmd[9] = size & 0xff;
1831         cgc.cmd[10] = s->disckey.agid << 6;
1832
1833         if (!(ret = cdo->generic_packet(cdi, &cgc)))
1834                 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1835
1836         kfree(buf);
1837         return ret;
1838 }
1839
1840 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s)
1841 {
1842         int ret;
1843         u_char buf[4 + 188];
1844         struct packet_command cgc;
1845         struct cdrom_device_ops *cdo = cdi->ops;
1846
1847         init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1848         cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1849         cgc.cmd[7] = s->type;
1850         cgc.cmd[9] = cgc.buflen & 0xff;
1851
1852         if ((ret = cdo->generic_packet(cdi, &cgc)))
1853                 return ret;
1854
1855         s->bca.len = buf[0] << 8 | buf[1];
1856         if (s->bca.len < 12 || s->bca.len > 188) {
1857                 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1858                 return -EIO;
1859         }
1860         memcpy(s->bca.value, &buf[4], s->bca.len);
1861
1862         return 0;
1863 }
1864
1865 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s)
1866 {
1867         int ret = 0, size;
1868         u_char *buf;
1869         struct packet_command cgc;
1870         struct cdrom_device_ops *cdo = cdi->ops;
1871
1872         size = sizeof(s->manufact.value) + 4;
1873
1874         if ((buf = kmalloc(size, GFP_KERNEL)) == NULL)
1875                 return -ENOMEM;
1876
1877         init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1878         cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1879         cgc.cmd[7] = s->type;
1880         cgc.cmd[8] = size >> 8;
1881         cgc.cmd[9] = size & 0xff;
1882
1883         if ((ret = cdo->generic_packet(cdi, &cgc))) {
1884                 kfree(buf);
1885                 return ret;
1886         }
1887
1888         s->manufact.len = buf[0] << 8 | buf[1];
1889         if (s->manufact.len < 0 || s->manufact.len > 2048) {
1890                 cdinfo(CD_WARNING, "Received invalid manufacture info length"
1891                                    " (%d)\n", s->manufact.len);
1892                 ret = -EIO;
1893         } else {
1894                 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1895         }
1896
1897         kfree(buf);
1898         return ret;
1899 }
1900
1901 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s)
1902 {
1903         switch (s->type) {
1904         case DVD_STRUCT_PHYSICAL:
1905                 return dvd_read_physical(cdi, s);
1906
1907         case DVD_STRUCT_COPYRIGHT:
1908                 return dvd_read_copyright(cdi, s);
1909
1910         case DVD_STRUCT_DISCKEY:
1911                 return dvd_read_disckey(cdi, s);
1912
1913         case DVD_STRUCT_BCA:
1914                 return dvd_read_bca(cdi, s);
1915
1916         case DVD_STRUCT_MANUFACT:
1917                 return dvd_read_manufact(cdi, s);
1918                 
1919         default:
1920                 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1921                                         s->type);
1922                 return -EINVAL;
1923         }
1924 }
1925
1926 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1927                      struct packet_command *cgc,
1928                      int page_code, int page_control)
1929 {
1930         struct cdrom_device_ops *cdo = cdi->ops;
1931
1932         memset(cgc->cmd, 0, sizeof(cgc->cmd));
1933
1934         cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1935         cgc->cmd[2] = page_code | (page_control << 6);
1936         cgc->cmd[7] = cgc->buflen >> 8;
1937         cgc->cmd[8] = cgc->buflen & 0xff;
1938         cgc->data_direction = CGC_DATA_READ;
1939         return cdo->generic_packet(cdi, cgc);
1940 }
1941
1942 int cdrom_mode_select(struct cdrom_device_info *cdi,
1943                       struct packet_command *cgc)
1944 {
1945         struct cdrom_device_ops *cdo = cdi->ops;
1946
1947         memset(cgc->cmd, 0, sizeof(cgc->cmd));
1948         memset(cgc->buffer, 0, 2);
1949         cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1950         cgc->cmd[1] = 0x10;             /* PF */
1951         cgc->cmd[7] = cgc->buflen >> 8;
1952         cgc->cmd[8] = cgc->buflen & 0xff;
1953         cgc->data_direction = CGC_DATA_WRITE;
1954         return cdo->generic_packet(cdi, cgc);
1955 }
1956
1957 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
1958                                  struct cdrom_subchnl *subchnl, int mcn)
1959 {
1960         struct cdrom_device_ops *cdo = cdi->ops;
1961         struct packet_command cgc;
1962         char buffer[32];
1963         int ret;
1964
1965         init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1966         cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
1967         cgc.cmd[1] = 2;     /* MSF addressing */
1968         cgc.cmd[2] = 0x40;  /* request subQ data */
1969         cgc.cmd[3] = mcn ? 2 : 1;
1970         cgc.cmd[8] = 16;
1971
1972         if ((ret = cdo->generic_packet(cdi, &cgc)))
1973                 return ret;
1974
1975         subchnl->cdsc_audiostatus = cgc.buffer[1];
1976         subchnl->cdsc_format = CDROM_MSF;
1977         subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
1978         subchnl->cdsc_trk = cgc.buffer[6];
1979         subchnl->cdsc_ind = cgc.buffer[7];
1980
1981         subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
1982         subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
1983         subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
1984         subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
1985         subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
1986         subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
1987
1988         return 0;
1989 }
1990
1991 /*
1992  * Specific READ_10 interface
1993  */
1994 static int cdrom_read_cd(struct cdrom_device_info *cdi,
1995                          struct packet_command *cgc, int lba,
1996                          int blocksize, int nblocks)
1997 {
1998         struct cdrom_device_ops *cdo = cdi->ops;
1999
2000         memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2001         cgc->cmd[0] = GPCMD_READ_10;
2002         cgc->cmd[2] = (lba >> 24) & 0xff;
2003         cgc->cmd[3] = (lba >> 16) & 0xff;
2004         cgc->cmd[4] = (lba >>  8) & 0xff;
2005         cgc->cmd[5] = lba & 0xff;
2006         cgc->cmd[6] = (nblocks >> 16) & 0xff;
2007         cgc->cmd[7] = (nblocks >>  8) & 0xff;
2008         cgc->cmd[8] = nblocks & 0xff;
2009         cgc->buflen = blocksize * nblocks;
2010         return cdo->generic_packet(cdi, cgc);
2011 }
2012
2013 /* very generic interface for reading the various types of blocks */
2014 static int cdrom_read_block(struct cdrom_device_info *cdi,
2015                             struct packet_command *cgc,
2016                             int lba, int nblocks, int format, int blksize)
2017 {
2018         struct cdrom_device_ops *cdo = cdi->ops;
2019
2020         memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2021         cgc->cmd[0] = GPCMD_READ_CD;
2022         /* expected sector size - cdda,mode1,etc. */
2023         cgc->cmd[1] = format << 2;
2024         /* starting address */
2025         cgc->cmd[2] = (lba >> 24) & 0xff;
2026         cgc->cmd[3] = (lba >> 16) & 0xff;
2027         cgc->cmd[4] = (lba >>  8) & 0xff;
2028         cgc->cmd[5] = lba & 0xff;
2029         /* number of blocks */
2030         cgc->cmd[6] = (nblocks >> 16) & 0xff;
2031         cgc->cmd[7] = (nblocks >>  8) & 0xff;
2032         cgc->cmd[8] = nblocks & 0xff;
2033         cgc->buflen = blksize * nblocks;
2034         
2035         /* set the header info returned */
2036         switch (blksize) {
2037         case CD_FRAMESIZE_RAW0  : cgc->cmd[9] = 0x58; break;
2038         case CD_FRAMESIZE_RAW1  : cgc->cmd[9] = 0x78; break;
2039         case CD_FRAMESIZE_RAW   : cgc->cmd[9] = 0xf8; break;
2040         default                 : cgc->cmd[9] = 0x10;
2041         }
2042         
2043         return cdo->generic_packet(cdi, cgc);
2044 }
2045
2046 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2047                                int lba, int nframes)
2048 {
2049         struct packet_command cgc;
2050         int ret = 0;
2051         int nr;
2052
2053         cdi->last_sense = 0;
2054
2055         memset(&cgc, 0, sizeof(cgc));
2056
2057         /*
2058          * start with will ra.nframes size, back down if alloc fails
2059          */
2060         nr = nframes;
2061         do {
2062                 cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2063                 if (cgc.buffer)
2064                         break;
2065
2066                 nr >>= 1;
2067         } while (nr);
2068
2069         if (!nr)
2070                 return -ENOMEM;
2071
2072         if (!access_ok(VERIFY_WRITE, ubuf, nframes * CD_FRAMESIZE_RAW)) {
2073                 ret = -EFAULT;
2074                 goto out;
2075         }
2076
2077         cgc.data_direction = CGC_DATA_READ;
2078         while (nframes > 0) {
2079                 if (nr > nframes)
2080                         nr = nframes;
2081
2082                 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2083                 if (ret)
2084                         break;
2085                 if (__copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2086                         ret = -EFAULT;
2087                         break;
2088                 }
2089                 ubuf += CD_FRAMESIZE_RAW * nr;
2090                 nframes -= nr;
2091                 lba += nr;
2092         }
2093 out:
2094         kfree(cgc.buffer);
2095         return ret;
2096 }
2097
2098 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2099                                int lba, int nframes)
2100 {
2101         struct request_queue *q = cdi->disk->queue;
2102         struct request *rq;
2103         struct bio *bio;
2104         unsigned int len;
2105         int nr, ret = 0;
2106
2107         if (!q)
2108                 return -ENXIO;
2109
2110         rq = blk_get_request(q, READ, GFP_KERNEL);
2111         if (!rq)
2112                 return -ENOMEM;
2113
2114         cdi->last_sense = 0;
2115
2116         while (nframes) {
2117                 nr = nframes;
2118                 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2119                         nr = 1;
2120                 if (nr * CD_FRAMESIZE_RAW > (q->max_sectors << 9))
2121                         nr = (q->max_sectors << 9) / CD_FRAMESIZE_RAW;
2122
2123                 len = nr * CD_FRAMESIZE_RAW;
2124
2125                 ret = blk_rq_map_user(q, rq, ubuf, len);
2126                 if (ret)
2127                         break;
2128
2129                 memset(rq->cmd, 0, sizeof(rq->cmd));
2130                 rq->cmd[0] = GPCMD_READ_CD;
2131                 rq->cmd[1] = 1 << 2;
2132                 rq->cmd[2] = (lba >> 24) & 0xff;
2133                 rq->cmd[3] = (lba >> 16) & 0xff;
2134                 rq->cmd[4] = (lba >>  8) & 0xff;
2135                 rq->cmd[5] = lba & 0xff;
2136                 rq->cmd[6] = (nr >> 16) & 0xff;
2137                 rq->cmd[7] = (nr >>  8) & 0xff;
2138                 rq->cmd[8] = nr & 0xff;
2139                 rq->cmd[9] = 0xf8;
2140
2141                 rq->cmd_len = 12;
2142                 rq->cmd_type = REQ_TYPE_BLOCK_PC;
2143                 rq->timeout = 60 * HZ;
2144                 bio = rq->bio;
2145
2146                 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2147                         struct request_sense *s = rq->sense;
2148                         ret = -EIO;
2149                         cdi->last_sense = s->sense_key;
2150                 }
2151
2152                 if (blk_rq_unmap_user(bio))
2153                         ret = -EFAULT;
2154
2155                 if (ret)
2156                         break;
2157
2158                 nframes -= nr;
2159                 lba += nr;
2160                 ubuf += len;
2161         }
2162
2163         blk_put_request(rq);
2164         return ret;
2165 }
2166
2167 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2168                            int lba, int nframes)
2169 {
2170         int ret;
2171
2172         if (cdi->cdda_method == CDDA_OLD)
2173                 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2174
2175 retry:
2176         /*
2177          * for anything else than success and io error, we need to retry
2178          */
2179         ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2180         if (!ret || ret != -EIO)
2181                 return ret;
2182
2183         /*
2184          * I've seen drives get sense 4/8/3 udma crc errors on multi
2185          * frame dma, so drop to single frame dma if we need to
2186          */
2187         if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2188                 printk("cdrom: dropping to single frame dma\n");
2189                 cdi->cdda_method = CDDA_BPC_SINGLE;
2190                 goto retry;
2191         }
2192
2193         /*
2194          * so we have an io error of some sort with multi frame dma. if the
2195          * condition wasn't a hardware error
2196          * problems, not for any error
2197          */
2198         if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2199                 return ret;
2200
2201         printk("cdrom: dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2202         cdi->cdda_method = CDDA_OLD;
2203         return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);    
2204 }
2205
2206 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2207                 void __user *argp)
2208 {
2209         struct cdrom_multisession ms_info;
2210         u8 requested_format;
2211         int ret;
2212
2213         cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2214
2215         if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2216                 return -ENOSYS;
2217
2218         if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2219                 return -EFAULT;
2220
2221         requested_format = ms_info.addr_format;
2222         if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2223                 return -EINVAL;
2224         ms_info.addr_format = CDROM_LBA;
2225
2226         ret = cdi->ops->get_last_session(cdi, &ms_info);
2227         if (ret)
2228                 return ret;
2229
2230         sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2231
2232         if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2233                 return -EFAULT;
2234
2235         cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2236         return 0;
2237 }
2238
2239 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2240 {
2241         cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2242
2243         if (!CDROM_CAN(CDC_OPEN_TRAY))
2244                 return -ENOSYS;
2245         if (cdi->use_count != 1 || keeplocked)
2246                 return -EBUSY;
2247         if (CDROM_CAN(CDC_LOCK)) {
2248                 int ret = cdi->ops->lock_door(cdi, 0);
2249                 if (ret)
2250                         return ret;
2251         }
2252
2253         return cdi->ops->tray_move(cdi, 1);
2254 }
2255
2256 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2257 {
2258         cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2259
2260         if (!CDROM_CAN(CDC_CLOSE_TRAY))
2261                 return -ENOSYS;
2262         return cdi->ops->tray_move(cdi, 0);
2263 }
2264
2265 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2266                 unsigned long arg)
2267 {
2268         cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2269
2270         if (!CDROM_CAN(CDC_OPEN_TRAY))
2271                 return -ENOSYS;
2272         if (keeplocked)
2273                 return -EBUSY;
2274
2275         cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2276         if (arg)
2277                 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2278         return 0;
2279 }
2280
2281 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2282                 unsigned long arg)
2283 {
2284         struct cdrom_changer_info *info;
2285         int ret;
2286
2287         cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2288
2289         if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2290                 return -ENOSYS;
2291
2292         /* cannot select disc or select current disc */
2293         if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2294                 return media_changed(cdi, 1);
2295
2296         if ((unsigned int)arg >= cdi->capacity)
2297                 return -EINVAL;
2298
2299         info = kmalloc(sizeof(*info), GFP_KERNEL);
2300         if (!info)
2301                 return -ENOMEM;
2302
2303         ret = cdrom_read_mech_status(cdi, info);
2304         if (!ret)
2305                 ret = info->slots[arg].change;
2306         kfree(info);
2307         return ret;
2308 }
2309
2310 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2311                 unsigned long arg)
2312 {
2313         cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2314
2315         /*
2316          * Options need to be in sync with capability.
2317          * Too late for that, so we have to check each one separately.
2318          */
2319         switch (arg) {
2320         case CDO_USE_FFLAGS:
2321         case CDO_CHECK_TYPE:
2322                 break;
2323         case CDO_LOCK:
2324                 if (!CDROM_CAN(CDC_LOCK))
2325                         return -ENOSYS;
2326                 break;
2327         case 0:
2328                 return cdi->options;
2329         /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2330         default:
2331                 if (!CDROM_CAN(arg))
2332                         return -ENOSYS;
2333         }
2334         cdi->options |= (int) arg;
2335         return cdi->options;
2336 }
2337
2338 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2339                 unsigned long arg)
2340 {
2341         cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2342
2343         cdi->options &= ~(int) arg;
2344         return cdi->options;
2345 }
2346
2347 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2348                 unsigned long arg)
2349 {
2350         cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2351
2352         if (!CDROM_CAN(CDC_SELECT_SPEED))
2353                 return -ENOSYS;
2354         return cdi->ops->select_speed(cdi, arg);
2355 }
2356
2357 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2358                 unsigned long arg)
2359 {
2360         cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2361
2362         if (!CDROM_CAN(CDC_SELECT_DISC))
2363                 return -ENOSYS;
2364
2365         if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2366                 if ((int)arg >= cdi->capacity)
2367                         return -EINVAL;
2368         }
2369
2370         /*
2371          * ->select_disc is a hook to allow a driver-specific way of
2372          * seleting disc.  However, since there is no equivalent hook for
2373          * cdrom_slot_status this may not actually be useful...
2374          */
2375         if (cdi->ops->select_disc)
2376                 return cdi->ops->select_disc(cdi, arg);
2377
2378         cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2379         return cdrom_select_disc(cdi, arg);
2380 }
2381
2382 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2383                 struct block_device *bdev)
2384 {
2385         cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2386
2387         if (!capable(CAP_SYS_ADMIN))
2388                 return -EACCES;
2389         if (!CDROM_CAN(CDC_RESET))
2390                 return -ENOSYS;
2391         invalidate_bdev(bdev);
2392         return cdi->ops->reset(cdi);
2393 }
2394
2395 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2396                 unsigned long arg)
2397 {
2398         cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2399
2400         if (!CDROM_CAN(CDC_LOCK))
2401                 return -EDRIVE_CANT_DO_THIS;
2402
2403         keeplocked = arg ? 1 : 0;
2404
2405         /*
2406          * Don't unlock the door on multiple opens by default, but allow
2407          * root to do so.
2408          */
2409         if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2410                 return -EBUSY;
2411         return cdi->ops->lock_door(cdi, arg);
2412 }
2413
2414 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2415                 unsigned long arg)
2416 {
2417         cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2418
2419         if (!capable(CAP_SYS_ADMIN))
2420                 return -EACCES;
2421         debug = arg ? 1 : 0;
2422         return debug;
2423 }
2424
2425 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2426 {
2427         cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2428         return (cdi->ops->capability & ~cdi->mask);
2429 }
2430
2431 /*
2432  * The following function is implemented, although very few audio
2433  * discs give Universal Product Code information, which should just be
2434  * the Medium Catalog Number on the box.  Note, that the way the code
2435  * is written on the CD is /not/ uniform across all discs!
2436  */
2437 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2438                 void __user *argp)
2439 {
2440         struct cdrom_mcn mcn;
2441         int ret;
2442
2443         cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2444
2445         if (!(cdi->ops->capability & CDC_MCN))
2446                 return -ENOSYS;
2447         ret = cdi->ops->get_mcn(cdi, &mcn);
2448         if (ret)
2449                 return ret;
2450
2451         if (copy_to_user(argp, &mcn, sizeof(mcn)))
2452                 return -EFAULT;
2453         cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2454         return 0;
2455 }
2456
2457 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2458                 unsigned long arg)
2459 {
2460         cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2461
2462         if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2463                 return -ENOSYS;
2464         if (!CDROM_CAN(CDC_SELECT_DISC) ||
2465             (arg == CDSL_CURRENT || arg == CDSL_NONE))
2466                 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2467         if (((int)arg >= cdi->capacity))
2468                 return -EINVAL;
2469         return cdrom_slot_status(cdi, arg);
2470 }
2471
2472 /*
2473  * Ok, this is where problems start.  The current interface for the
2474  * CDROM_DISC_STATUS ioctl is flawed.  It makes the false assumption that
2475  * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc.  Unfortunatly, while this
2476  * is often the case, it is also very common for CDs to have some tracks
2477  * with data, and some tracks with audio.  Just because I feel like it,
2478  * I declare the following to be the best way to cope.  If the CD has ANY
2479  * data tracks on it, it will be returned as a data CD.  If it has any XA
2480  * tracks, I will return it as that.  Now I could simplify this interface
2481  * by combining these  returns with the above, but this more clearly
2482  * demonstrates the problem with the current interface.  Too bad this
2483  * wasn't designed to use bitmasks...         -Erik
2484  *
2485  * Well, now we have the option CDS_MIXED: a mixed-type CD.
2486  * User level programmers might feel the ioctl is not very useful.
2487  *                                      ---david
2488  */
2489 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2490 {
2491         tracktype tracks;
2492
2493         cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2494
2495         cdrom_count_tracks(cdi, &tracks);
2496         if (tracks.error)
2497                 return tracks.error;
2498
2499         /* Policy mode on */
2500         if (tracks.audio > 0) {
2501                 if (!tracks.data && !tracks.cdi && !tracks.xa)
2502                         return CDS_AUDIO;
2503                 else
2504                         return CDS_MIXED;
2505         }
2506
2507         if (tracks.cdi > 0)
2508                 return CDS_XA_2_2;
2509         if (tracks.xa > 0)
2510                 return CDS_XA_2_1;
2511         if (tracks.data > 0)
2512                 return CDS_DATA_1;
2513         /* Policy mode off */
2514
2515         cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2516         return CDS_NO_INFO;
2517 }
2518
2519 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2520 {
2521         cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2522         return cdi->capacity;
2523 }
2524
2525 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2526                 void __user *argp)
2527 {
2528         struct cdrom_subchnl q;
2529         u8 requested, back;
2530         int ret;
2531
2532         /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2533
2534         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2535                 return -ENOSYS;
2536         if (copy_from_user(&q, argp, sizeof(q)))
2537                 return -EFAULT;
2538
2539         requested = q.cdsc_format;
2540         if (requested != CDROM_MSF && requested != CDROM_LBA)
2541                 return -EINVAL;
2542         q.cdsc_format = CDROM_MSF;
2543
2544         ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2545         if (ret)
2546                 return ret;
2547
2548         back = q.cdsc_format; /* local copy */
2549         sanitize_format(&q.cdsc_absaddr, &back, requested);
2550         sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2551
2552         if (copy_to_user(argp, &q, sizeof(q)))
2553                 return -EFAULT;
2554         /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2555         return 0;
2556 }
2557
2558 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2559                 void __user *argp)
2560 {
2561         struct cdrom_tochdr header;
2562         int ret;
2563
2564         /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2565
2566         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2567                 return -ENOSYS;
2568         if (copy_from_user(&header, argp, sizeof(header)))
2569                 return -EFAULT;
2570
2571         ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2572         if (ret)
2573                 return ret;
2574
2575         if (copy_to_user(argp, &header, sizeof(header)))
2576                 return -EFAULT;
2577         /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2578         return 0;
2579 }
2580
2581 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2582                 void __user *argp)
2583 {
2584         struct cdrom_tocentry entry;
2585         u8 requested_format;
2586         int ret;
2587
2588         /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2589
2590         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2591                 return -ENOSYS;
2592         if (copy_from_user(&entry, argp, sizeof(entry)))
2593                 return -EFAULT;
2594
2595         requested_format = entry.cdte_format;
2596         if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2597                 return -EINVAL;
2598         /* make interface to low-level uniform */
2599         entry.cdte_format = CDROM_MSF;
2600         ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2601         if (ret)
2602                 return ret;
2603         sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2604
2605         if (copy_to_user(argp, &entry, sizeof(entry)))
2606                 return -EFAULT;
2607         /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2608         return 0;
2609 }
2610
2611 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2612                 void __user *argp)
2613 {
2614         struct cdrom_msf msf;
2615
2616         cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2617
2618         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2619                 return -ENOSYS;
2620         if (copy_from_user(&msf, argp, sizeof(msf)))
2621                 return -EFAULT;
2622         return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2623 }
2624
2625 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2626                 void __user *argp)
2627 {
2628         struct cdrom_ti ti;
2629         int ret;
2630
2631         cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2632
2633         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2634                 return -ENOSYS;
2635         if (copy_from_user(&ti, argp, sizeof(ti)))
2636                 return -EFAULT;
2637
2638         ret = check_for_audio_disc(cdi, cdi->ops);
2639         if (ret)
2640                 return ret;
2641         return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2642 }
2643 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2644                 void __user *argp)
2645 {
2646         struct cdrom_volctrl volume;
2647
2648         cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2649
2650         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2651                 return -ENOSYS;
2652         if (copy_from_user(&volume, argp, sizeof(volume)))
2653                 return -EFAULT;
2654         return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2655 }
2656
2657 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2658                 void __user *argp)
2659 {
2660         struct cdrom_volctrl volume;
2661         int ret;
2662
2663         cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2664
2665         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2666                 return -ENOSYS;
2667
2668         ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2669         if (ret)
2670                 return ret;
2671
2672         if (copy_to_user(argp, &volume, sizeof(volume)))
2673                 return -EFAULT;
2674         return 0;
2675 }
2676
2677 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2678                 unsigned int cmd)
2679 {
2680         int ret;
2681
2682         cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2683
2684         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2685                 return -ENOSYS;
2686         ret = check_for_audio_disc(cdi, cdi->ops);
2687         if (ret)
2688                 return ret;
2689         return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2690 }
2691
2692 /*
2693  * Just about every imaginable ioctl is supported in the Uniform layer
2694  * these days.
2695  * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2696  */
2697 int cdrom_ioctl(struct file * file, struct cdrom_device_info *cdi,
2698                 struct inode *ip, unsigned int cmd, unsigned long arg)
2699 {
2700         void __user *argp = (void __user *)arg;
2701         int ret;
2702         struct gendisk *disk = ip->i_bdev->bd_disk;
2703
2704         /*
2705          * Try the generic SCSI command ioctl's first.
2706          */
2707         ret = scsi_cmd_ioctl(file, disk->queue, disk, cmd, argp);
2708         if (ret != -ENOTTY)
2709                 return ret;
2710
2711         switch (cmd) {
2712         case CDROMMULTISESSION:
2713                 return cdrom_ioctl_multisession(cdi, argp);
2714         case CDROMEJECT:
2715                 return cdrom_ioctl_eject(cdi);
2716         case CDROMCLOSETRAY:
2717                 return cdrom_ioctl_closetray(cdi);
2718         case CDROMEJECT_SW:
2719                 return cdrom_ioctl_eject_sw(cdi, arg);
2720         case CDROM_MEDIA_CHANGED:
2721                 return cdrom_ioctl_media_changed(cdi, arg);
2722         case CDROM_SET_OPTIONS:
2723                 return cdrom_ioctl_set_options(cdi, arg);
2724         case CDROM_CLEAR_OPTIONS:
2725                 return cdrom_ioctl_clear_options(cdi, arg);
2726         case CDROM_SELECT_SPEED:
2727                 return cdrom_ioctl_select_speed(cdi, arg);
2728         case CDROM_SELECT_DISC:
2729                 return cdrom_ioctl_select_disc(cdi, arg);
2730         case CDROMRESET:
2731                 return cdrom_ioctl_reset(cdi, ip->i_bdev);
2732         case CDROM_LOCKDOOR:
2733                 return cdrom_ioctl_lock_door(cdi, arg);
2734         case CDROM_DEBUG:
2735                 return cdrom_ioctl_debug(cdi, arg);
2736         case CDROM_GET_CAPABILITY:
2737                 return cdrom_ioctl_get_capability(cdi);
2738         case CDROM_GET_MCN:
2739                 return cdrom_ioctl_get_mcn(cdi, argp);
2740         case CDROM_DRIVE_STATUS:
2741                 return cdrom_ioctl_drive_status(cdi, arg);
2742         case CDROM_DISC_STATUS:
2743                 return cdrom_ioctl_disc_status(cdi);
2744         case CDROM_CHANGER_NSLOTS:
2745                 return cdrom_ioctl_changer_nslots(cdi);
2746         }
2747
2748         /*
2749          * Use the ioctls that are implemented through the generic_packet()
2750          * interface. this may look at bit funny, but if -ENOTTY is
2751          * returned that particular ioctl is not implemented and we
2752          * let it go through the device specific ones.
2753          */
2754         if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2755                 ret = mmc_ioctl(cdi, cmd, arg);
2756                 if (ret != -ENOTTY)
2757                         return ret;
2758         }
2759
2760         /*
2761          * Note: most of the cdinfo() calls are commented out here,
2762          * because they fill up the sys log when CD players poll
2763          * the drive.
2764          */
2765         switch (cmd) {
2766         case CDROMSUBCHNL:
2767                 return cdrom_ioctl_get_subchnl(cdi, argp);
2768         case CDROMREADTOCHDR:
2769                 return cdrom_ioctl_read_tochdr(cdi, argp);
2770         case CDROMREADTOCENTRY:
2771                 return cdrom_ioctl_read_tocentry(cdi, argp);
2772         case CDROMPLAYMSF:
2773                 return cdrom_ioctl_play_msf(cdi, argp);
2774         case CDROMPLAYTRKIND:
2775                 return cdrom_ioctl_play_trkind(cdi, argp);
2776         case CDROMVOLCTRL:
2777                 return cdrom_ioctl_volctrl(cdi, argp);
2778         case CDROMVOLREAD:
2779                 return cdrom_ioctl_volread(cdi, argp);
2780         case CDROMSTART:
2781         case CDROMSTOP:
2782         case CDROMPAUSE:
2783         case CDROMRESUME:
2784                 return cdrom_ioctl_audioctl(cdi, cmd);
2785         }
2786
2787         return -ENOSYS;
2788 }
2789
2790 /*
2791  * Required when we need to use READ_10 to issue other than 2048 block
2792  * reads
2793  */
2794 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2795 {
2796         struct cdrom_device_ops *cdo = cdi->ops;
2797         struct packet_command cgc;
2798         struct modesel_head mh;
2799
2800         memset(&mh, 0, sizeof(mh));
2801         mh.block_desc_length = 0x08;
2802         mh.block_length_med = (size >> 8) & 0xff;
2803         mh.block_length_lo = size & 0xff;
2804
2805         memset(&cgc, 0, sizeof(cgc));
2806         cgc.cmd[0] = 0x15;
2807         cgc.cmd[1] = 1 << 4;
2808         cgc.cmd[4] = 12;
2809         cgc.buflen = sizeof(mh);
2810         cgc.buffer = (char *) &mh;
2811         cgc.data_direction = CGC_DATA_WRITE;
2812         mh.block_desc_length = 0x08;
2813         mh.block_length_med = (size >> 8) & 0xff;
2814         mh.block_length_lo = size & 0xff;
2815
2816         return cdo->generic_packet(cdi, &cgc);
2817 }
2818
2819 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
2820                      unsigned long arg)
2821 {               
2822         struct cdrom_device_ops *cdo = cdi->ops;
2823         struct packet_command cgc;
2824         struct request_sense sense;
2825         unsigned char buffer[32];
2826         int ret = 0;
2827
2828         memset(&cgc, 0, sizeof(cgc));
2829
2830         /* build a unified command and queue it through
2831            cdo->generic_packet() */
2832         switch (cmd) {
2833         case CDROMREADRAW:
2834         case CDROMREADMODE1:
2835         case CDROMREADMODE2: {
2836                 struct cdrom_msf msf;
2837                 int blocksize = 0, format = 0, lba;
2838                 
2839                 switch (cmd) {
2840                 case CDROMREADRAW:
2841                         blocksize = CD_FRAMESIZE_RAW;
2842                         break;
2843                 case CDROMREADMODE1:
2844                         blocksize = CD_FRAMESIZE;
2845                         format = 2;
2846                         break;
2847                 case CDROMREADMODE2:
2848                         blocksize = CD_FRAMESIZE_RAW0;
2849                         break;
2850                 }
2851                 IOCTL_IN(arg, struct cdrom_msf, msf);
2852                 lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
2853                 /* FIXME: we need upper bound checking, too!! */
2854                 if (lba < 0)
2855                         return -EINVAL;
2856                 cgc.buffer = kmalloc(blocksize, GFP_KERNEL);
2857                 if (cgc.buffer == NULL)
2858                         return -ENOMEM;
2859                 memset(&sense, 0, sizeof(sense));
2860                 cgc.sense = &sense;
2861                 cgc.data_direction = CGC_DATA_READ;
2862                 ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
2863                 if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) {
2864                         /*
2865                          * SCSI-II devices are not required to support
2866                          * READ_CD, so let's try switching block size
2867                          */
2868                         /* FIXME: switch back again... */
2869                         if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
2870                                 kfree(cgc.buffer);
2871                                 return ret;
2872                         }
2873                         cgc.sense = NULL;
2874                         ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
2875                         ret |= cdrom_switch_blocksize(cdi, blocksize);
2876                 }
2877                 if (!ret && copy_to_user((char __user *)arg, cgc.buffer, blocksize))
2878                         ret = -EFAULT;
2879                 kfree(cgc.buffer);
2880                 return ret;
2881                 }
2882         case CDROMREADAUDIO: {
2883                 struct cdrom_read_audio ra;
2884                 int lba;
2885
2886                 IOCTL_IN(arg, struct cdrom_read_audio, ra);
2887
2888                 if (ra.addr_format == CDROM_MSF)
2889                         lba = msf_to_lba(ra.addr.msf.minute,
2890                                          ra.addr.msf.second,
2891                                          ra.addr.msf.frame);
2892                 else if (ra.addr_format == CDROM_LBA)
2893                         lba = ra.addr.lba;
2894                 else
2895                         return -EINVAL;
2896
2897                 /* FIXME: we need upper bound checking, too!! */
2898                 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2899                         return -EINVAL;
2900
2901                 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2902                 }
2903         case CDROMSUBCHNL: {
2904                 struct cdrom_subchnl q;
2905                 u_char requested, back;
2906                 IOCTL_IN(arg, struct cdrom_subchnl, q);
2907                 requested = q.cdsc_format;
2908                 if (!((requested == CDROM_MSF) ||
2909                       (requested == CDROM_LBA)))
2910                         return -EINVAL;
2911                 q.cdsc_format = CDROM_MSF;
2912                 if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
2913                         return ret;
2914                 back = q.cdsc_format; /* local copy */
2915                 sanitize_format(&q.cdsc_absaddr, &back, requested);
2916                 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2917                 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2918                 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */ 
2919                 return 0;
2920                 }
2921         case CDROMPLAYMSF: {
2922                 struct cdrom_msf msf;
2923                 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2924                 IOCTL_IN(arg, struct cdrom_msf, msf);
2925                 cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2926                 cgc.cmd[3] = msf.cdmsf_min0;
2927                 cgc.cmd[4] = msf.cdmsf_sec0;
2928                 cgc.cmd[5] = msf.cdmsf_frame0;
2929                 cgc.cmd[6] = msf.cdmsf_min1;
2930                 cgc.cmd[7] = msf.cdmsf_sec1;
2931                 cgc.cmd[8] = msf.cdmsf_frame1;
2932                 cgc.data_direction = CGC_DATA_NONE;
2933                 return cdo->generic_packet(cdi, &cgc);
2934                 }
2935         case CDROMPLAYBLK: {
2936                 struct cdrom_blk blk;
2937                 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2938                 IOCTL_IN(arg, struct cdrom_blk, blk);
2939                 cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
2940                 cgc.cmd[2] = (blk.from >> 24) & 0xff;
2941                 cgc.cmd[3] = (blk.from >> 16) & 0xff;
2942                 cgc.cmd[4] = (blk.from >>  8) & 0xff;
2943                 cgc.cmd[5] = blk.from & 0xff;
2944                 cgc.cmd[7] = (blk.len >> 8) & 0xff;
2945                 cgc.cmd[8] = blk.len & 0xff;
2946                 cgc.data_direction = CGC_DATA_NONE;
2947                 return cdo->generic_packet(cdi, &cgc);
2948                 }
2949         case CDROMVOLCTRL:
2950         case CDROMVOLREAD: {
2951                 struct cdrom_volctrl volctrl;
2952                 char mask[sizeof(buffer)];
2953                 unsigned short offset;
2954
2955                 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
2956
2957                 IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
2958
2959                 cgc.buffer = buffer;
2960                 cgc.buflen = 24;
2961                 if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
2962                     return ret;
2963                 
2964                 /* originally the code depended on buffer[1] to determine
2965                    how much data is available for transfer. buffer[1] is
2966                    unfortunately ambigious and the only reliable way seem
2967                    to be to simply skip over the block descriptor... */
2968                 offset = 8 + be16_to_cpu(*(__be16 *)(buffer+6));
2969
2970                 if (offset + 16 > sizeof(buffer))
2971                         return -E2BIG;
2972
2973                 if (offset + 16 > cgc.buflen) {
2974                         cgc.buflen = offset+16;
2975                         ret = cdrom_mode_sense(cdi, &cgc,
2976                                                 GPMODE_AUDIO_CTL_PAGE, 0);
2977                         if (ret)
2978                                 return ret;
2979                 }
2980
2981                 /* sanity check */
2982                 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
2983                                 buffer[offset+1] < 14)
2984                         return -EINVAL;
2985
2986                 /* now we have the current volume settings. if it was only
2987                    a CDROMVOLREAD, return these values */
2988                 if (cmd == CDROMVOLREAD) {
2989                         volctrl.channel0 = buffer[offset+9];
2990                         volctrl.channel1 = buffer[offset+11];
2991                         volctrl.channel2 = buffer[offset+13];
2992                         volctrl.channel3 = buffer[offset+15];
2993                         IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
2994                         return 0;
2995                 }
2996                 
2997                 /* get the volume mask */
2998                 cgc.buffer = mask;
2999                 if ((ret = cdrom_mode_sense(cdi, &cgc, 
3000                                 GPMODE_AUDIO_CTL_PAGE, 1)))
3001                         return ret;
3002
3003                 buffer[offset+9] = volctrl.channel0 & mask[offset+9];
3004                 buffer[offset+11] = volctrl.channel1 & mask[offset+11];
3005                 buffer[offset+13] = volctrl.channel2 & mask[offset+13];
3006                 buffer[offset+15] = volctrl.channel3 & mask[offset+15];
3007
3008                 /* set volume */
3009                 cgc.buffer = buffer + offset - 8;
3010                 memset(cgc.buffer, 0, 8);
3011                 return cdrom_mode_select(cdi, &cgc);
3012                 }
3013
3014         case CDROMSTART:
3015         case CDROMSTOP: {
3016                 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n"); 
3017                 cgc.cmd[0] = GPCMD_START_STOP_UNIT;
3018                 cgc.cmd[1] = 1;
3019                 cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3020                 cgc.data_direction = CGC_DATA_NONE;
3021                 return cdo->generic_packet(cdi, &cgc);
3022                 }
3023
3024         case CDROMPAUSE:
3025         case CDROMRESUME: {
3026                 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n"); 
3027                 cgc.cmd[0] = GPCMD_PAUSE_RESUME;
3028                 cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3029                 cgc.data_direction = CGC_DATA_NONE;
3030                 return cdo->generic_packet(cdi, &cgc);
3031                 }
3032
3033         case DVD_READ_STRUCT: {
3034                 dvd_struct *s;
3035                 int size = sizeof(dvd_struct);
3036                 if (!CDROM_CAN(CDC_DVD))
3037                         return -ENOSYS;
3038                 if ((s = kmalloc(size, GFP_KERNEL)) == NULL)
3039                         return -ENOMEM;
3040                 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n"); 
3041                 if (copy_from_user(s, (dvd_struct __user *)arg, size)) {
3042                         kfree(s);
3043                         return -EFAULT;
3044                 }
3045                 if ((ret = dvd_read_struct(cdi, s))) {
3046                         kfree(s);
3047                         return ret;
3048                 }
3049                 if (copy_to_user((dvd_struct __user *)arg, s, size))
3050                         ret = -EFAULT;
3051                 kfree(s);
3052                 return ret;
3053                 }
3054
3055         case DVD_AUTH: {
3056                 dvd_authinfo ai;
3057                 if (!CDROM_CAN(CDC_DVD))
3058                         return -ENOSYS;
3059                 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n"); 
3060                 IOCTL_IN(arg, dvd_authinfo, ai);
3061                 if ((ret = dvd_do_auth (cdi, &ai)))
3062                         return ret;
3063                 IOCTL_OUT(arg, dvd_authinfo, ai);
3064                 return 0;
3065                 }
3066
3067         case CDROM_NEXT_WRITABLE: {
3068                 long next = 0;
3069                 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n"); 
3070                 if ((ret = cdrom_get_next_writable(cdi, &next)))
3071                         return ret;
3072                 IOCTL_OUT(arg, long, next);
3073                 return 0;
3074                 }
3075         case CDROM_LAST_WRITTEN: {
3076                 long last = 0;
3077                 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n"); 
3078                 if ((ret = cdrom_get_last_written(cdi, &last)))
3079                         return ret;
3080                 IOCTL_OUT(arg, long, last);
3081                 return 0;
3082                 }
3083         } /* switch */
3084
3085         return -ENOTTY;
3086 }
3087
3088 static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
3089                          track_information *ti)
3090 {
3091         struct cdrom_device_ops *cdo = cdi->ops;
3092         struct packet_command cgc;
3093         int ret, buflen;
3094
3095         init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3096         cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3097         cgc.cmd[1] = type & 3;
3098         cgc.cmd[4] = (track & 0xff00) >> 8;
3099         cgc.cmd[5] = track & 0xff;
3100         cgc.cmd[8] = 8;
3101         cgc.quiet = 1;
3102
3103         if ((ret = cdo->generic_packet(cdi, &cgc)))
3104                 return ret;
3105         
3106         buflen = be16_to_cpu(ti->track_information_length) +
3107                      sizeof(ti->track_information_length);
3108
3109         if (buflen > sizeof(track_information))
3110                 buflen = sizeof(track_information);
3111
3112         cgc.cmd[8] = cgc.buflen = buflen;
3113         if ((ret = cdo->generic_packet(cdi, &cgc)))
3114                 return ret;
3115
3116         /* return actual fill size */
3117         return buflen;
3118 }
3119
3120 /* requires CD R/RW */
3121 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3122 {
3123         struct cdrom_device_ops *cdo = cdi->ops;
3124         struct packet_command cgc;
3125         int ret, buflen;
3126
3127         /* set up command and get the disc info */
3128         init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3129         cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3130         cgc.cmd[8] = cgc.buflen = 2;
3131         cgc.quiet = 1;
3132
3133         if ((ret = cdo->generic_packet(cdi, &cgc)))
3134                 return ret;
3135
3136         /* not all drives have the same disc_info length, so requeue
3137          * packet with the length the drive tells us it can supply
3138          */
3139         buflen = be16_to_cpu(di->disc_information_length) +
3140                      sizeof(di->disc_information_length);
3141
3142         if (buflen > sizeof(disc_information))
3143                 buflen = sizeof(disc_information);
3144
3145         cgc.cmd[8] = cgc.buflen = buflen;
3146         if ((ret = cdo->generic_packet(cdi, &cgc)))
3147                 return ret;
3148
3149         /* return actual fill size */
3150         return buflen;
3151 }
3152
3153 /* return the last written block on the CD-R media. this is for the udf
3154    file system. */
3155 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
3156 {
3157         struct cdrom_tocentry toc;
3158         disc_information di;
3159         track_information ti;
3160         __u32 last_track;
3161         int ret = -1, ti_size;
3162
3163         if (!CDROM_CAN(CDC_GENERIC_PACKET))
3164                 goto use_toc;
3165
3166         ret = cdrom_get_disc_info(cdi, &di);
3167         if (ret < (int)(offsetof(typeof(di), last_track_lsb)
3168                         + sizeof(di.last_track_lsb)))
3169                 goto use_toc;
3170
3171         /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3172         last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3173         ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3174         if (ti_size < (int)offsetof(typeof(ti), track_start))
3175                 goto use_toc;
3176
3177         /* if this track is blank, try the previous. */
3178         if (ti.blank) {
3179                 if (last_track==1)
3180                         goto use_toc;
3181                 last_track--;
3182                 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3183         }
3184
3185         if (ti_size < (int)(offsetof(typeof(ti), track_size)
3186                                 + sizeof(ti.track_size)))
3187                 goto use_toc;
3188
3189         /* if last recorded field is valid, return it. */
3190         if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3191                                 + sizeof(ti.last_rec_address))) {
3192                 *last_written = be32_to_cpu(ti.last_rec_address);
3193         } else {
3194                 /* make it up instead */
3195                 *last_written = be32_to_cpu(ti.track_start) +
3196                                 be32_to_cpu(ti.track_size);
3197                 if (ti.free_blocks)
3198                         *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3199         }
3200         return 0;
3201
3202         /* this is where we end up if the drive either can't do a
3203            GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3204            it doesn't give enough information or fails. then we return
3205            the toc contents. */
3206 use_toc:
3207         toc.cdte_format = CDROM_MSF;
3208         toc.cdte_track = CDROM_LEADOUT;
3209         if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
3210                 return ret;
3211         sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
3212         *last_written = toc.cdte_addr.lba;
3213         return 0;
3214 }
3215
3216 /* return the next writable block. also for udf file system. */
3217 static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3218 {
3219         disc_information di;
3220         track_information ti;
3221         __u16 last_track;
3222         int ret, ti_size;
3223
3224         if (!CDROM_CAN(CDC_GENERIC_PACKET))
3225                 goto use_last_written;
3226
3227         ret = cdrom_get_disc_info(cdi, &di);
3228         if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3229                                 + sizeof(di.last_track_lsb))
3230                 goto use_last_written;
3231
3232         /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3233         last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3234         ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3235         if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3236                 goto use_last_written;
3237
3238         /* if this track is blank, try the previous. */
3239         if (ti.blank) {
3240                 if (last_track == 1)
3241                         goto use_last_written;
3242                 last_track--;
3243                 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3244                 if (ti_size < 0)
3245                         goto use_last_written;
3246         }
3247
3248         /* if next recordable address field is valid, use it. */
3249         if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
3250                                 + sizeof(ti.next_writable)) {
3251                 *next_writable = be32_to_cpu(ti.next_writable);
3252                 return 0;
3253         }
3254
3255 use_last_written:
3256         if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3257                 *next_writable = 0;
3258                 return ret;
3259         } else {
3260                 *next_writable += 7;
3261                 return 0;
3262         }
3263 }
3264
3265 EXPORT_SYMBOL(cdrom_get_last_written);
3266 EXPORT_SYMBOL(register_cdrom);
3267 EXPORT_SYMBOL(unregister_cdrom);
3268 EXPORT_SYMBOL(cdrom_open);
3269 EXPORT_SYMBOL(cdrom_release);
3270 EXPORT_SYMBOL(cdrom_ioctl);
3271 EXPORT_SYMBOL(cdrom_media_changed);
3272 EXPORT_SYMBOL(cdrom_number_of_slots);
3273 EXPORT_SYMBOL(cdrom_mode_select);
3274 EXPORT_SYMBOL(cdrom_mode_sense);
3275 EXPORT_SYMBOL(init_cdrom_command);
3276 EXPORT_SYMBOL(cdrom_get_media_event);
3277
3278 #ifdef CONFIG_SYSCTL
3279
3280 #define CDROM_STR_SIZE 1000
3281
3282 static struct cdrom_sysctl_settings {
3283         char    info[CDROM_STR_SIZE];   /* general info */
3284         int     autoclose;              /* close tray upon mount, etc */
3285         int     autoeject;              /* eject on umount */
3286         int     debug;                  /* turn on debugging messages */
3287         int     lock;                   /* lock the door on device open */
3288         int     check;                  /* check media type */
3289 } cdrom_sysctl_settings;
3290
3291 enum cdrom_print_option {
3292         CTL_NAME,
3293         CTL_SPEED,
3294         CTL_SLOTS,
3295         CTL_CAPABILITY
3296 };
3297
3298 static int cdrom_print_info(const char *header, int val, char *info,
3299                                 int *pos, enum cdrom_print_option option)
3300 {
3301         const int max_size = sizeof(cdrom_sysctl_settings.info);
3302         struct cdrom_device_info *cdi;
3303         int ret;
3304
3305         ret = scnprintf(info + *pos, max_size - *pos, header);
3306         if (!ret)
3307                 return 1;
3308
3309         *pos += ret;
3310
3311         for (cdi = topCdromPtr; cdi; cdi = cdi->next) {
3312                 switch (option) {
3313                 case CTL_NAME:
3314                         ret = scnprintf(info + *pos, max_size - *pos,
3315                                         "\t%s", cdi->name);
3316                         break;
3317                 case CTL_SPEED:
3318                         ret = scnprintf(info + *pos, max_size - *pos,
3319                                         "\t%d", cdi->speed);
3320                         break;
3321                 case CTL_SLOTS:
3322                         ret = scnprintf(info + *pos, max_size - *pos,
3323                                         "\t%d", cdi->capacity);
3324                         break;
3325                 case CTL_CAPABILITY:
3326                         ret = scnprintf(info + *pos, max_size - *pos,
3327                                         "\t%d", CDROM_CAN(val) != 0);
3328                         break;
3329                 default:
3330                         printk(KERN_INFO "cdrom: invalid option%d\n", option);
3331                         return 1;
3332                 }
3333                 if (!ret)
3334                         return 1;
3335                 *pos += ret;
3336         }
3337
3338         return 0;
3339 }
3340
3341 static int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
3342                            void __user *buffer, size_t *lenp, loff_t *ppos)
3343 {
3344         int pos;
3345         char *info = cdrom_sysctl_settings.info;
3346         const int max_size = sizeof(cdrom_sysctl_settings.info);
3347         
3348         if (!*lenp || (*ppos && !write)) {
3349                 *lenp = 0;
3350                 return 0;
3351         }
3352
3353         mutex_lock(&cdrom_mutex);
3354
3355         pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3356         
3357         if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3358                 goto done;
3359         if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3360                 goto done;
3361         if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3362                 goto done;
3363         if (cdrom_print_info("\nCan close tray:\t",
3364                                 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3365                 goto done;
3366         if (cdrom_print_info("\nCan open tray:\t",
3367                                 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3368                 goto done;
3369         if (cdrom_print_info("\nCan lock tray:\t",
3370                                 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3371                 goto done;
3372         if (cdrom_print_info("\nCan change speed:",
3373                                 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3374                 goto done;
3375         if (cdrom_print_info("\nCan select disk:",
3376                                 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3377                 goto done;
3378         if (cdrom_print_info("\nCan read multisession:",
3379                                 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3380                 goto done;
3381         if (cdrom_print_info("\nCan read MCN:\t",
3382                                 CDC_MCN, info, &pos, CTL_CAPABILITY))
3383                 goto done;
3384         if (cdrom_print_info("\nReports media changed:",
3385                                 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3386                 goto done;
3387         if (cdrom_print_info("\nCan play audio:\t",
3388                                 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3389                 goto done;
3390         if (cdrom_print_info("\nCan write CD-R:\t",
3391                                 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3392                 goto done;
3393         if (cdrom_print_info("\nCan write CD-RW:",
3394                                 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3395                 goto done;
3396         if (cdrom_print_info("\nCan read DVD:\t",
3397                                 CDC_DVD, info, &pos, CTL_CAPABILITY))
3398                 goto done;
3399         if (cdrom_print_info("\nCan write DVD-R:",
3400                                 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3401                 goto done;
3402         if (cdrom_print_info("\nCan write DVD-RAM:",
3403                                 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3404                 goto done;
3405         if (cdrom_print_info("\nCan read MRW:\t",
3406                                 CDC_MRW, info, &pos, CTL_CAPABILITY))
3407                 goto done;
3408         if (cdrom_print_info("\nCan write MRW:\t",
3409                                 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3410                 goto done;
3411         if (cdrom_print_info("\nCan write RAM:\t",
3412                                 CDC_RAM, info, &pos, CTL_CAPABILITY))
3413                 goto done;
3414         if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3415                 goto done;
3416 doit:
3417         mutex_unlock(&cdrom_mutex);
3418         return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
3419 done:
3420         printk(KERN_INFO "cdrom: info buffer too small\n");
3421         goto doit;
3422 }
3423
3424 /* Unfortunately, per device settings are not implemented through
3425    procfs/sysctl yet. When they are, this will naturally disappear. For now
3426    just update all drives. Later this will become the template on which
3427    new registered drives will be based. */
3428 static void cdrom_update_settings(void)
3429 {
3430         struct cdrom_device_info *cdi;
3431
3432         for (cdi = topCdromPtr; cdi != NULL; cdi = cdi->next) {
3433                 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3434                         cdi->options |= CDO_AUTO_CLOSE;
3435                 else if (!autoclose)
3436                         cdi->options &= ~CDO_AUTO_CLOSE;
3437                 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3438                         cdi->options |= CDO_AUTO_EJECT;
3439                 else if (!autoeject)
3440                         cdi->options &= ~CDO_AUTO_EJECT;
3441                 if (lockdoor && CDROM_CAN(CDC_LOCK))
3442                         cdi->options |= CDO_LOCK;
3443                 else if (!lockdoor)
3444                         cdi->options &= ~CDO_LOCK;
3445                 if (check_media_type)
3446                         cdi->options |= CDO_CHECK_TYPE;
3447                 else
3448                         cdi->options &= ~CDO_CHECK_TYPE;
3449         }
3450 }
3451
3452 static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
3453                                 void __user *buffer, size_t *lenp, loff_t *ppos)
3454 {
3455         int ret;
3456         
3457         ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
3458
3459         if (write) {
3460         
3461                 /* we only care for 1 or 0. */
3462                 autoclose        = !!cdrom_sysctl_settings.autoclose;
3463                 autoeject        = !!cdrom_sysctl_settings.autoeject;
3464                 debug            = !!cdrom_sysctl_settings.debug;
3465                 lockdoor         = !!cdrom_sysctl_settings.lock;
3466                 check_media_type = !!cdrom_sysctl_settings.check;
3467
3468                 /* update the option flags according to the changes. we
3469                    don't have per device options through sysctl yet,
3470                    but we will have and then this will disappear. */
3471                 cdrom_update_settings();
3472         }
3473
3474         return ret;
3475 }
3476
3477 /* Place files in /proc/sys/dev/cdrom */
3478 static ctl_table cdrom_table[] = {
3479         {
3480                 .procname       = "info",
3481                 .data           = &cdrom_sysctl_settings.info, 
3482                 .maxlen         = CDROM_STR_SIZE,
3483                 .mode           = 0444,
3484                 .proc_handler   = &cdrom_sysctl_info,
3485         },
3486         {
3487                 .procname       = "autoclose",
3488                 .data           = &cdrom_sysctl_settings.autoclose,
3489                 .maxlen         = sizeof(int),
3490                 .mode           = 0644,
3491                 .proc_handler   = &cdrom_sysctl_handler,
3492         },
3493         {
3494                 .procname       = "autoeject",
3495                 .data           = &cdrom_sysctl_settings.autoeject,
3496                 .maxlen         = sizeof(int),
3497                 .mode           = 0644,
3498                 .proc_handler   = &cdrom_sysctl_handler,
3499         },
3500         {
3501                 .procname       = "debug",
3502                 .data           = &cdrom_sysctl_settings.debug,
3503                 .maxlen         = sizeof(int),
3504                 .mode           = 0644,
3505                 .proc_handler   = &cdrom_sysctl_handler,
3506         },
3507         {
3508                 .procname       = "lock",
3509                 .data           = &cdrom_sysctl_settings.lock,
3510                 .maxlen         = sizeof(int),
3511                 .mode           = 0644,
3512                 .proc_handler   = &cdrom_sysctl_handler,
3513         },
3514         {
3515                 .procname       = "check_media",
3516                 .data           = &cdrom_sysctl_settings.check,
3517                 .maxlen         = sizeof(int),
3518                 .mode           = 0644,
3519                 .proc_handler   = &cdrom_sysctl_handler
3520         },
3521         { .ctl_name = 0 }
3522 };
3523
3524 static ctl_table cdrom_cdrom_table[] = {
3525         {
3526                 .ctl_name       = DEV_CDROM,
3527                 .procname       = "cdrom",
3528                 .maxlen         = 0,
3529                 .mode           = 0555,
3530                 .child          = cdrom_table,
3531         },
3532         { .ctl_name = 0 }
3533 };
3534
3535 /* Make sure that /proc/sys/dev is there */
3536 static ctl_table cdrom_root_table[] = {
3537         {
3538                 .ctl_name       = CTL_DEV,
3539                 .procname       = "dev",
3540                 .maxlen         = 0,
3541                 .mode           = 0555,
3542                 .child          = cdrom_cdrom_table,
3543         },
3544         { .ctl_name = 0 }
3545 };
3546 static struct ctl_table_header *cdrom_sysctl_header;
3547
3548 static void cdrom_sysctl_register(void)
3549 {
3550         static int initialized;
3551
3552         if (initialized == 1)
3553                 return;
3554
3555         cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3556
3557         /* set the defaults */
3558         cdrom_sysctl_settings.autoclose = autoclose;
3559         cdrom_sysctl_settings.autoeject = autoeject;
3560         cdrom_sysctl_settings.debug = debug;
3561         cdrom_sysctl_settings.lock = lockdoor;
3562         cdrom_sysctl_settings.check = check_media_type;
3563
3564         initialized = 1;
3565 }
3566
3567 static void cdrom_sysctl_unregister(void)
3568 {
3569         if (cdrom_sysctl_header)
3570                 unregister_sysctl_table(cdrom_sysctl_header);
3571 }
3572
3573 #endif /* CONFIG_SYSCTL */
3574
3575 static int __init cdrom_init(void)
3576 {
3577 #ifdef CONFIG_SYSCTL
3578         cdrom_sysctl_register();
3579 #endif
3580         return 0;
3581 }
3582
3583 static void __exit cdrom_exit(void)
3584 {
3585         printk(KERN_INFO "Uniform CD-ROM driver unloaded\n");
3586 #ifdef CONFIG_SYSCTL
3587         cdrom_sysctl_unregister();
3588 #endif
3589 }
3590
3591 module_init(cdrom_init);
3592 module_exit(cdrom_exit);
3593 MODULE_LICENSE("GPL");