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