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