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