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