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