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