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