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