Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / drivers / cdrom / cdrom.c
1 /* linux/drivers/cdrom/cdrom.c
2    Copyright (c) 1996, 1997 David A. van Leeuwen.
3    Copyright (c) 1997, 1998 Erik Andersen <andersee@debian.org>
4    Copyright (c) 1998, 1999 Jens Axboe <axboe@image.dk>
5
6    May be copied or modified under the terms of the GNU General Public
7    License.  See linux/COPYING for more information.
8
9    Uniform CD-ROM driver for Linux.
10    See Documentation/cdrom/cdrom-standard.tex for usage information.
11
12    The routines in the file provide a uniform interface between the
13    software that uses CD-ROMs and the various low-level drivers that
14    actually talk to the hardware. Suggestions are welcome.
15    Patches that work are more welcome though.  ;-)
16
17  To Do List:
18  ----------------------------------
19
20  -- Modify sysctl/proc interface. I plan on having one directory per
21  drive, with entries for outputing general drive information, and sysctl
22  based tunable parameters such as whether the tray should auto-close for
23  that drive. Suggestions (or patches) for this welcome!
24
25
26  Revision History
27  ----------------------------------
28  1.00  Date Unknown -- David van Leeuwen <david@tm.tno.nl>
29  -- Initial version by David A. van Leeuwen. I don't have a detailed
30   changelog for the 1.x series, David?
31
32 2.00  Dec  2, 1997 -- Erik Andersen <andersee@debian.org>
33   -- New maintainer! As David A. van Leeuwen has been too busy to activly
34   maintain and improve this driver, I am now carrying on the torch. If
35   you have a problem with this driver, please feel free to contact me.
36
37   -- Added (rudimentary) sysctl interface. I realize this is really weak
38   right now, and is _very_ badly implemented. It will be improved...
39
40   -- Modified CDROM_DISC_STATUS so that it is now incorporated into
41   the Uniform CD-ROM driver via the cdrom_count_tracks function.
42   The cdrom_count_tracks function helps resolve some of the false
43   assumptions of the CDROM_DISC_STATUS ioctl, and is also used to check
44   for the correct media type when mounting or playing audio from a CD.
45
46   -- Remove the calls to verify_area and only use the copy_from_user and
47   copy_to_user stuff, since these calls now provide their own memory
48   checking with the 2.1.x kernels.
49
50   -- Major update to return codes so that errors from low-level drivers
51   are passed on through (thanks to Gerd Knorr for pointing out this
52   problem).
53
54   -- Made it so if a function isn't implemented in a low-level driver,
55   ENOSYS is now returned instead of EINVAL.
56
57   -- Simplified some complex logic so that the source code is easier to read.
58
59   -- Other stuff I probably forgot to mention (lots of changes).
60
61 2.01 to 2.11 Dec 1997-Jan 1998
62   -- TO-DO!  Write changelogs for 2.01 to 2.12.
63
64 2.12  Jan  24, 1998 -- Erik Andersen <andersee@debian.org>
65   -- Fixed a bug in the IOCTL_IN and IOCTL_OUT macros.  It turns out that
66   copy_*_user does not return EFAULT on error, but instead returns the number 
67   of bytes not copied.  I was returning whatever non-zero stuff came back from 
68   the copy_*_user functions directly, which would result in strange errors.
69
70 2.13  July 17, 1998 -- Erik Andersen <andersee@debian.org>
71   -- Fixed a bug in CDROM_SELECT_SPEED where you couldn't lower the speed
72   of the drive.  Thanks to Tobias Ringstr|m <tori@prosolvia.se> for pointing
73   this out and providing a simple fix.
74   -- Fixed the procfs-unload-module bug with the fill_inode procfs callback.
75   thanks to Andrea Arcangeli
76   -- Fixed it so that the /proc entry now also shows up when cdrom is
77   compiled into the kernel.  Before it only worked when loaded as a module.
78
79   2.14 August 17, 1998 -- Erik Andersen <andersee@debian.org>
80   -- Fixed a bug in cdrom_media_changed and handling of reporting that
81   the media had changed for devices that _don't_ implement media_changed.  
82   Thanks to Grant R. Guenther <grant@torque.net> for spotting this bug.
83   -- Made a few things more pedanticly correct.
84
85 2.50 Oct 19, 1998 - Jens Axboe <axboe@image.dk>
86   -- New maintainers! Erik was too busy to continue the work on the driver,
87   so now Chris Zwilling <chris@cloudnet.com> and Jens Axboe <axboe@image.dk>
88   will do their best to follow in his footsteps
89   
90   2.51 Dec 20, 1998 - Jens Axboe <axboe@image.dk>
91   -- Check if drive is capable of doing what we ask before blindly changing
92   cdi->options in various ioctl.
93   -- Added version to proc entry.
94   
95   2.52 Jan 16, 1999 - Jens Axboe <axboe@image.dk>
96   -- Fixed an error in open_for_data where we would sometimes not return
97   the correct error value. Thanks Huba Gaspar <huba@softcell.hu>.
98   -- Fixed module usage count - usage was based on /proc/sys/dev
99   instead of /proc/sys/dev/cdrom. This could lead to an oops when other
100   modules had entries in dev. Feb 02 - real bug was in sysctl.c where
101   dev would be removed even though it was used. cdrom.c just illuminated
102   that bug.
103   
104   2.53 Feb 22, 1999 - Jens Axboe <axboe@image.dk>
105   -- Fixup of several ioctl calls, in particular CDROM_SET_OPTIONS has
106   been "rewritten" because capabilities and options aren't in sync. They
107   should be...
108   -- Added CDROM_LOCKDOOR ioctl. Locks the door and keeps it that way.
109   -- Added CDROM_RESET ioctl.
110   -- Added CDROM_DEBUG ioctl. Enable debug messages on-the-fly.
111   -- Added CDROM_GET_CAPABILITY ioctl. This relieves userspace programs
112   from parsing /proc/sys/dev/cdrom/info.
113   
114   2.54 Mar 15, 1999 - Jens Axboe <axboe@image.dk>
115   -- Check capability mask from low level driver when counting tracks as
116   per suggestion from Corey J. Scotts <cstotts@blue.weeg.uiowa.edu>.
117   
118   2.55 Apr 25, 1999 - Jens Axboe <axboe@image.dk>
119   -- autoclose was mistakenly checked against CDC_OPEN_TRAY instead of
120   CDC_CLOSE_TRAY.
121   -- proc info didn't mask against capabilities mask.
122   
123   3.00 Aug 5, 1999 - Jens Axboe <axboe@image.dk>
124   -- Unified audio ioctl handling across CD-ROM drivers. A lot of the
125   code was duplicated before. Drives that support the generic packet
126   interface are now being fed packets from here instead.
127   -- First attempt at adding support for MMC2 commands - for DVD and
128   CD-R(W) drives. Only the DVD parts are in now - the interface used is
129   the same as for the audio ioctls.
130   -- ioctl cleanups. if a drive couldn't play audio, it didn't get
131   a change to perform device specific ioctls as well.
132   -- Defined CDROM_CAN(CDC_XXX) for checking the capabilities.
133   -- Put in sysctl files for autoclose, autoeject, check_media, debug,
134   and lock.
135   -- /proc/sys/dev/cdrom/info has been updated to also contain info about
136   CD-Rx and DVD capabilities.
137   -- Now default to checking media type.
138   -- CDROM_SEND_PACKET ioctl added. The infrastructure was in place for
139   doing this anyway, with the generic_packet addition.
140   
141   3.01 Aug 6, 1999 - Jens Axboe <axboe@image.dk>
142   -- Fix up the sysctl handling so that the option flags get set
143   correctly.
144   -- Fix up ioctl handling so the device specific ones actually get
145   called :).
146   
147   3.02 Aug 8, 1999 - Jens Axboe <axboe@image.dk>
148   -- Fixed volume control on SCSI drives (or others with longer audio
149   page).
150   -- Fixed a couple of DVD minors. Thanks to Andrew T. Veliath
151   <andrewtv@usa.net> for telling me and for having defined the various
152   DVD structures and ioctls in the first place! He designed the original
153   DVD patches for ide-cd and while I rearranged and unified them, the
154   interface is still the same.
155   
156   3.03 Sep 1, 1999 - Jens Axboe <axboe@image.dk>
157   -- Moved the rest of the audio ioctls from the CD-ROM drivers here. Only
158   CDROMREADTOCENTRY and CDROMREADTOCHDR are left.
159   -- Moved the CDROMREADxxx ioctls in here.
160   -- Defined the cdrom_get_last_written and cdrom_get_next_block as ioctls
161   and exported functions.
162   -- Erik Andersen <andersen@xmission.com> modified all SCMD_ commands
163   to now read GPCMD_ for the new generic packet interface. All low level
164   drivers are updated as well.
165   -- Various other cleanups.
166
167   3.04 Sep 12, 1999 - Jens Axboe <axboe@image.dk>
168   -- Fixed a couple of possible memory leaks (if an operation failed and
169   we didn't free the buffer before returning the error).
170   -- Integrated Uniform CD Changer handling from Richard Sharman
171   <rsharman@pobox.com>.
172   -- Defined CD_DVD and CD_CHANGER log levels.
173   -- Fixed the CDROMREADxxx ioctls.
174   -- CDROMPLAYTRKIND uses the GPCMD_PLAY_AUDIO_MSF command - too few
175   drives supported it. We lose the index part, however.
176   -- Small modifications to accommodate opens of /dev/hdc1, required
177   for ide-cd to handle multisession discs.
178   -- Export cdrom_mode_sense and cdrom_mode_select.
179   -- init_cdrom_command() for setting up a cgc command.
180   
181   3.05 Oct 24, 1999 - Jens Axboe <axboe@image.dk>
182   -- Changed the interface for CDROM_SEND_PACKET. Before it was virtually
183   impossible to send the drive data in a sensible way.
184   -- Lowered stack usage in mmc_ioctl(), dvd_read_disckey(), and
185   dvd_read_manufact.
186   -- Added setup of write mode for packet writing.
187   -- Fixed CDDA ripping with cdda2wav - accept much larger requests of
188   number of frames and split the reads in blocks of 8.
189
190   3.06 Dec 13, 1999 - Jens Axboe <axboe@image.dk>
191   -- Added support for changing the region of DVD drives.
192   -- Added sense data to generic command.
193
194   3.07 Feb 2, 2000 - Jens Axboe <axboe@suse.de>
195   -- Do same "read header length" trick in cdrom_get_disc_info() as
196   we do in cdrom_get_track_info() -- some drive don't obey specs and
197   fail if they can't supply the full Mt Fuji size table.
198   -- Deleted stuff related to setting up write modes. It has a different
199   home now.
200   -- Clear header length in mode_select unconditionally.
201   -- Removed the register_disk() that was added, not needed here.
202
203   3.08 May 1, 2000 - Jens Axboe <axboe@suse.de>
204   -- Fix direction flag in setup_send_key and setup_report_key. This
205   gave some SCSI adapters problems.
206   -- Always return -EROFS for write opens
207   -- Convert to module_init/module_exit style init and remove some
208   of the #ifdef MODULE stuff
209   -- Fix several dvd errors - DVD_LU_SEND_ASF should pass agid,
210   DVD_HOST_SEND_RPC_STATE did not set buffer size in cdb, and
211   dvd_do_auth passed uninitialized data to drive because init_cdrom_command
212   did not clear a 0 sized buffer.
213   
214   3.09 May 12, 2000 - Jens Axboe <axboe@suse.de>
215   -- Fix Video-CD on SCSI drives that don't support READ_CD command. In
216   that case switch block size and issue plain READ_10 again, then switch
217   back.
218
219   3.10 Jun 10, 2000 - Jens Axboe <axboe@suse.de>
220   -- Fix volume control on CD's - old SCSI-II drives now use their own
221   code, as doing MODE6 stuff in here is really not my intention.
222   -- Use READ_DISC_INFO for more reliable end-of-disc.
223
224   3.11 Jun 12, 2000 - Jens Axboe <axboe@suse.de>
225   -- Fix bug in getting rpc phase 2 region info.
226   -- Reinstate "correct" CDROMPLAYTRKIND
227
228    3.12 Oct 18, 2000 - Jens Axboe <axboe@suse.de>
229   -- Use quiet bit on packet commands not known to work
230
231    3.20 Dec 17, 2003 - Jens Axboe <axboe@suse.de>
232   -- Various fixes and lots of cleanups not listed :-)
233   -- Locking fixes
234   -- Mt Rainier support
235   -- DVD-RAM write open fixes
236
237   Nov 5 2001, Aug 8 2002. Modified by Andy Polyakov
238   <appro@fy.chalmers.se> to support MMC-3 compliant DVD+RW units.
239
240   Modified by Nigel Kukard <nkukard@lbsd.net> - support DVD+RW
241   2.4.x patch by Andy Polyakov <appro@fy.chalmers.se>
242
243 -------------------------------------------------------------------------*/
244
245 #define REVISION "Revision: 3.20"
246 #define VERSION "Id: cdrom.c 3.20 2003/12/17"
247
248 /* I use an error-log mask to give fine grain control over the type of
249    messages dumped to the system logs.  The available masks include: */
250 #define CD_NOTHING      0x0
251 #define CD_WARNING      0x1
252 #define CD_REG_UNREG    0x2
253 #define CD_DO_IOCTL     0x4
254 #define CD_OPEN         0x8
255 #define CD_CLOSE        0x10
256 #define CD_COUNT_TRACKS 0x20
257 #define CD_CHANGER      0x40
258 #define CD_DVD          0x80
259
260 /* Define this to remove _all_ the debugging messages */
261 /* #define ERRLOGMASK CD_NOTHING */
262 #define ERRLOGMASK CD_WARNING
263 /* #define ERRLOGMASK (CD_WARNING|CD_OPEN|CD_COUNT_TRACKS|CD_CLOSE) */
264 /* #define ERRLOGMASK (CD_WARNING|CD_REG_UNREG|CD_DO_IOCTL|CD_OPEN|CD_CLOSE|CD_COUNT_TRACKS) */
265
266 #include <linux/module.h>
267 #include <linux/fs.h>
268 #include <linux/buffer_head.h>
269 #include <linux/major.h>
270 #include <linux/types.h>
271 #include <linux/errno.h>
272 #include <linux/kernel.h>
273 #include <linux/mm.h>
274 #include <linux/slab.h> 
275 #include <linux/cdrom.h>
276 #include <linux/sysctl.h>
277 #include <linux/proc_fs.h>
278 #include <linux/blkpg.h>
279 #include <linux/init.h>
280 #include <linux/fcntl.h>
281 #include <linux/blkdev.h>
282 #include <linux/times.h>
283
284 #include <asm/uaccess.h>
285
286 /* used to tell the module to turn on full debugging messages */
287 static int debug;
288 /* used to keep tray locked at all times */
289 static int keeplocked;
290 /* default compatibility mode */
291 static int autoclose=1;
292 static int autoeject;
293 static int lockdoor = 1;
294 /* will we ever get to use this... sigh. */
295 static int check_media_type;
296 /* automatically restart mrw format */
297 static int mrw_format_restart = 1;
298 module_param(debug, bool, 0);
299 module_param(autoclose, bool, 0);
300 module_param(autoeject, bool, 0);
301 module_param(lockdoor, bool, 0);
302 module_param(check_media_type, bool, 0);
303 module_param(mrw_format_restart, bool, 0);
304
305 static DEFINE_MUTEX(cdrom_mutex);
306
307 static const char *mrw_format_status[] = {
308         "not mrw",
309         "bgformat inactive",
310         "bgformat active",
311         "mrw complete",
312 };
313
314 static const char *mrw_address_space[] = { "DMA", "GAA" };
315
316 #if (ERRLOGMASK!=CD_NOTHING)
317 #define cdinfo(type, fmt, args...) \
318         if ((ERRLOGMASK & type) || debug==1 ) \
319             printk(KERN_INFO "cdrom: " fmt, ## args)
320 #else
321 #define cdinfo(type, fmt, args...) 
322 #endif
323
324 /* These are used to simplify getting data in from and back to user land */
325 #define IOCTL_IN(arg, type, in)                                 \
326         if (copy_from_user(&(in), (type __user *) (arg), sizeof (in)))  \
327                 return -EFAULT;
328
329 #define IOCTL_OUT(arg, type, out) \
330         if (copy_to_user((type __user *) (arg), &(out), sizeof (out)))  \
331                 return -EFAULT;
332
333 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
334    a lot of places. This macro makes the code more clear. */
335 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
336
337 /* used in the audio ioctls */
338 #define CHECKAUDIO if ((ret=check_for_audio_disc(cdi, cdo))) return ret
339
340 /*
341  * Another popular OS uses 7 seconds as the hard timeout for default
342  * commands, so it is a good choice for us as well.
343  */
344 #define CDROM_DEF_TIMEOUT       (7 * HZ)
345
346 /* Not-exported routines. */
347 static int open_for_data(struct cdrom_device_info * cdi);
348 static int check_for_audio_disc(struct cdrom_device_info * cdi,
349                          struct cdrom_device_ops * cdo);
350 static void sanitize_format(union cdrom_addr *addr, 
351                 u_char * curr, u_char requested);
352 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
353                      unsigned long arg);
354
355 int cdrom_get_last_written(struct cdrom_device_info *, long *);
356 static int cdrom_get_next_writable(struct cdrom_device_info *, long *);
357 static void cdrom_count_tracks(struct cdrom_device_info *, tracktype*);
358
359 static int cdrom_mrw_exit(struct cdrom_device_info *cdi);
360
361 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di);
362
363 static void cdrom_sysctl_register(void);
364
365 static LIST_HEAD(cdrom_list);
366
367 static int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
368                                       struct packet_command *cgc)
369 {
370         if (cgc->sense) {
371                 cgc->sense->sense_key = 0x05;
372                 cgc->sense->asc = 0x20;
373                 cgc->sense->ascq = 0x00;
374         }
375
376         cgc->stat = -EIO;
377         return -EIO;
378 }
379
380 /* This macro makes sure we don't have to check on cdrom_device_ops
381  * existence in the run-time routines below. Change_capability is a
382  * hack to have the capability flags defined const, while we can still
383  * change it here without gcc complaining at every line.
384  */
385 #define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
386
387 int register_cdrom(struct cdrom_device_info *cdi)
388 {
389         static char banner_printed;
390         struct cdrom_device_ops *cdo = cdi->ops;
391         int *change_capability = (int *)&cdo->capability; /* hack */
392
393         cdinfo(CD_OPEN, "entering register_cdrom\n"); 
394
395         if (cdo->open == NULL || cdo->release == NULL)
396                 return -EINVAL;
397         if (!banner_printed) {
398                 printk(KERN_INFO "Uniform CD-ROM driver " REVISION "\n");
399                 banner_printed = 1;
400                 cdrom_sysctl_register();
401         }
402
403         ENSURE(drive_status, CDC_DRIVE_STATUS );
404         ENSURE(media_changed, CDC_MEDIA_CHANGED);
405         ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
406         ENSURE(lock_door, CDC_LOCK);
407         ENSURE(select_speed, CDC_SELECT_SPEED);
408         ENSURE(get_last_session, CDC_MULTI_SESSION);
409         ENSURE(get_mcn, CDC_MCN);
410         ENSURE(reset, CDC_RESET);
411         ENSURE(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                 memset(rq->cmd, 0, sizeof(rq->cmd));
2198                 rq->cmd[0] = GPCMD_READ_CD;
2199                 rq->cmd[1] = 1 << 2;
2200                 rq->cmd[2] = (lba >> 24) & 0xff;
2201                 rq->cmd[3] = (lba >> 16) & 0xff;
2202                 rq->cmd[4] = (lba >>  8) & 0xff;
2203                 rq->cmd[5] = lba & 0xff;
2204                 rq->cmd[6] = (nr >> 16) & 0xff;
2205                 rq->cmd[7] = (nr >>  8) & 0xff;
2206                 rq->cmd[8] = nr & 0xff;
2207                 rq->cmd[9] = 0xf8;
2208
2209                 rq->cmd_len = 12;
2210                 rq->cmd_type = REQ_TYPE_BLOCK_PC;
2211                 rq->timeout = 60 * HZ;
2212                 bio = rq->bio;
2213
2214                 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2215                         struct request_sense *s = rq->sense;
2216                         ret = -EIO;
2217                         cdi->last_sense = s->sense_key;
2218                 }
2219
2220                 if (blk_rq_unmap_user(bio))
2221                         ret = -EFAULT;
2222
2223                 if (ret)
2224                         break;
2225
2226                 nframes -= nr;
2227                 lba += nr;
2228                 ubuf += len;
2229         }
2230
2231         blk_put_request(rq);
2232         return ret;
2233 }
2234
2235 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2236                            int lba, int nframes)
2237 {
2238         int ret;
2239
2240         if (cdi->cdda_method == CDDA_OLD)
2241                 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2242
2243 retry:
2244         /*
2245          * for anything else than success and io error, we need to retry
2246          */
2247         ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2248         if (!ret || ret != -EIO)
2249                 return ret;
2250
2251         /*
2252          * I've seen drives get sense 4/8/3 udma crc errors on multi
2253          * frame dma, so drop to single frame dma if we need to
2254          */
2255         if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2256                 printk("cdrom: dropping to single frame dma\n");
2257                 cdi->cdda_method = CDDA_BPC_SINGLE;
2258                 goto retry;
2259         }
2260
2261         /*
2262          * so we have an io error of some sort with multi frame dma. if the
2263          * condition wasn't a hardware error
2264          * problems, not for any error
2265          */
2266         if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2267                 return ret;
2268
2269         printk("cdrom: dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2270         cdi->cdda_method = CDDA_OLD;
2271         return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);    
2272 }
2273
2274 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2275                 void __user *argp)
2276 {
2277         struct cdrom_multisession ms_info;
2278         u8 requested_format;
2279         int ret;
2280
2281         cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2282
2283         if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2284                 return -ENOSYS;
2285
2286         if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2287                 return -EFAULT;
2288
2289         requested_format = ms_info.addr_format;
2290         if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2291                 return -EINVAL;
2292         ms_info.addr_format = CDROM_LBA;
2293
2294         ret = cdi->ops->get_last_session(cdi, &ms_info);
2295         if (ret)
2296                 return ret;
2297
2298         sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2299
2300         if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2301                 return -EFAULT;
2302
2303         cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2304         return 0;
2305 }
2306
2307 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2308 {
2309         cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2310
2311         if (!CDROM_CAN(CDC_OPEN_TRAY))
2312                 return -ENOSYS;
2313         if (cdi->use_count != 1 || keeplocked)
2314                 return -EBUSY;
2315         if (CDROM_CAN(CDC_LOCK)) {
2316                 int ret = cdi->ops->lock_door(cdi, 0);
2317                 if (ret)
2318                         return ret;
2319         }
2320
2321         return cdi->ops->tray_move(cdi, 1);
2322 }
2323
2324 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2325 {
2326         cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2327
2328         if (!CDROM_CAN(CDC_CLOSE_TRAY))
2329                 return -ENOSYS;
2330         return cdi->ops->tray_move(cdi, 0);
2331 }
2332
2333 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2334                 unsigned long arg)
2335 {
2336         cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2337
2338         if (!CDROM_CAN(CDC_OPEN_TRAY))
2339                 return -ENOSYS;
2340         if (keeplocked)
2341                 return -EBUSY;
2342
2343         cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2344         if (arg)
2345                 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2346         return 0;
2347 }
2348
2349 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2350                 unsigned long arg)
2351 {
2352         struct cdrom_changer_info *info;
2353         int ret;
2354
2355         cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2356
2357         if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2358                 return -ENOSYS;
2359
2360         /* cannot select disc or select current disc */
2361         if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2362                 return media_changed(cdi, 1);
2363
2364         if ((unsigned int)arg >= cdi->capacity)
2365                 return -EINVAL;
2366
2367         info = kmalloc(sizeof(*info), GFP_KERNEL);
2368         if (!info)
2369                 return -ENOMEM;
2370
2371         ret = cdrom_read_mech_status(cdi, info);
2372         if (!ret)
2373                 ret = info->slots[arg].change;
2374         kfree(info);
2375         return ret;
2376 }
2377
2378 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2379                 unsigned long arg)
2380 {
2381         cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2382
2383         /*
2384          * Options need to be in sync with capability.
2385          * Too late for that, so we have to check each one separately.
2386          */
2387         switch (arg) {
2388         case CDO_USE_FFLAGS:
2389         case CDO_CHECK_TYPE:
2390                 break;
2391         case CDO_LOCK:
2392                 if (!CDROM_CAN(CDC_LOCK))
2393                         return -ENOSYS;
2394                 break;
2395         case 0:
2396                 return cdi->options;
2397         /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2398         default:
2399                 if (!CDROM_CAN(arg))
2400                         return -ENOSYS;
2401         }
2402         cdi->options |= (int) arg;
2403         return cdi->options;
2404 }
2405
2406 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2407                 unsigned long arg)
2408 {
2409         cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2410
2411         cdi->options &= ~(int) arg;
2412         return cdi->options;
2413 }
2414
2415 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2416                 unsigned long arg)
2417 {
2418         cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2419
2420         if (!CDROM_CAN(CDC_SELECT_SPEED))
2421                 return -ENOSYS;
2422         return cdi->ops->select_speed(cdi, arg);
2423 }
2424
2425 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2426                 unsigned long arg)
2427 {
2428         cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2429
2430         if (!CDROM_CAN(CDC_SELECT_DISC))
2431                 return -ENOSYS;
2432
2433         if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2434                 if ((int)arg >= cdi->capacity)
2435                         return -EINVAL;
2436         }
2437
2438         /*
2439          * ->select_disc is a hook to allow a driver-specific way of
2440          * seleting disc.  However, since there is no equivalent hook for
2441          * cdrom_slot_status this may not actually be useful...
2442          */
2443         if (cdi->ops->select_disc)
2444                 return cdi->ops->select_disc(cdi, arg);
2445
2446         cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2447         return cdrom_select_disc(cdi, arg);
2448 }
2449
2450 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2451                 struct block_device *bdev)
2452 {
2453         cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2454
2455         if (!capable(CAP_SYS_ADMIN))
2456                 return -EACCES;
2457         if (!CDROM_CAN(CDC_RESET))
2458                 return -ENOSYS;
2459         invalidate_bdev(bdev);
2460         return cdi->ops->reset(cdi);
2461 }
2462
2463 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2464                 unsigned long arg)
2465 {
2466         cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2467
2468         if (!CDROM_CAN(CDC_LOCK))
2469                 return -EDRIVE_CANT_DO_THIS;
2470
2471         keeplocked = arg ? 1 : 0;
2472
2473         /*
2474          * Don't unlock the door on multiple opens by default, but allow
2475          * root to do so.
2476          */
2477         if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2478                 return -EBUSY;
2479         return cdi->ops->lock_door(cdi, arg);
2480 }
2481
2482 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2483                 unsigned long arg)
2484 {
2485         cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2486
2487         if (!capable(CAP_SYS_ADMIN))
2488                 return -EACCES;
2489         debug = arg ? 1 : 0;
2490         return debug;
2491 }
2492
2493 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2494 {
2495         cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2496         return (cdi->ops->capability & ~cdi->mask);
2497 }
2498
2499 /*
2500  * The following function is implemented, although very few audio
2501  * discs give Universal Product Code information, which should just be
2502  * the Medium Catalog Number on the box.  Note, that the way the code
2503  * is written on the CD is /not/ uniform across all discs!
2504  */
2505 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2506                 void __user *argp)
2507 {
2508         struct cdrom_mcn mcn;
2509         int ret;
2510
2511         cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2512
2513         if (!(cdi->ops->capability & CDC_MCN))
2514                 return -ENOSYS;
2515         ret = cdi->ops->get_mcn(cdi, &mcn);
2516         if (ret)
2517                 return ret;
2518
2519         if (copy_to_user(argp, &mcn, sizeof(mcn)))
2520                 return -EFAULT;
2521         cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2522         return 0;
2523 }
2524
2525 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2526                 unsigned long arg)
2527 {
2528         cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2529
2530         if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2531                 return -ENOSYS;
2532         if (!CDROM_CAN(CDC_SELECT_DISC) ||
2533             (arg == CDSL_CURRENT || arg == CDSL_NONE))
2534                 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2535         if (((int)arg >= cdi->capacity))
2536                 return -EINVAL;
2537         return cdrom_slot_status(cdi, arg);
2538 }
2539
2540 /*
2541  * Ok, this is where problems start.  The current interface for the
2542  * CDROM_DISC_STATUS ioctl is flawed.  It makes the false assumption that
2543  * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc.  Unfortunatly, while this
2544  * is often the case, it is also very common for CDs to have some tracks
2545  * with data, and some tracks with audio.  Just because I feel like it,
2546  * I declare the following to be the best way to cope.  If the CD has ANY
2547  * data tracks on it, it will be returned as a data CD.  If it has any XA
2548  * tracks, I will return it as that.  Now I could simplify this interface
2549  * by combining these  returns with the above, but this more clearly
2550  * demonstrates the problem with the current interface.  Too bad this
2551  * wasn't designed to use bitmasks...         -Erik
2552  *
2553  * Well, now we have the option CDS_MIXED: a mixed-type CD.
2554  * User level programmers might feel the ioctl is not very useful.
2555  *                                      ---david
2556  */
2557 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2558 {
2559         tracktype tracks;
2560
2561         cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2562
2563         cdrom_count_tracks(cdi, &tracks);
2564         if (tracks.error)
2565                 return tracks.error;
2566
2567         /* Policy mode on */
2568         if (tracks.audio > 0) {
2569                 if (!tracks.data && !tracks.cdi && !tracks.xa)
2570                         return CDS_AUDIO;
2571                 else
2572                         return CDS_MIXED;
2573         }
2574
2575         if (tracks.cdi > 0)
2576                 return CDS_XA_2_2;
2577         if (tracks.xa > 0)
2578                 return CDS_XA_2_1;
2579         if (tracks.data > 0)
2580                 return CDS_DATA_1;
2581         /* Policy mode off */
2582
2583         cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2584         return CDS_NO_INFO;
2585 }
2586
2587 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2588 {
2589         cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2590         return cdi->capacity;
2591 }
2592
2593 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2594                 void __user *argp)
2595 {
2596         struct cdrom_subchnl q;
2597         u8 requested, back;
2598         int ret;
2599
2600         /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2601
2602         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2603                 return -ENOSYS;
2604         if (copy_from_user(&q, argp, sizeof(q)))
2605                 return -EFAULT;
2606
2607         requested = q.cdsc_format;
2608         if (requested != CDROM_MSF && requested != CDROM_LBA)
2609                 return -EINVAL;
2610         q.cdsc_format = CDROM_MSF;
2611
2612         ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2613         if (ret)
2614                 return ret;
2615
2616         back = q.cdsc_format; /* local copy */
2617         sanitize_format(&q.cdsc_absaddr, &back, requested);
2618         sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2619
2620         if (copy_to_user(argp, &q, sizeof(q)))
2621                 return -EFAULT;
2622         /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2623         return 0;
2624 }
2625
2626 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2627                 void __user *argp)
2628 {
2629         struct cdrom_tochdr header;
2630         int ret;
2631
2632         /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2633
2634         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2635                 return -ENOSYS;
2636         if (copy_from_user(&header, argp, sizeof(header)))
2637                 return -EFAULT;
2638
2639         ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2640         if (ret)
2641                 return ret;
2642
2643         if (copy_to_user(argp, &header, sizeof(header)))
2644                 return -EFAULT;
2645         /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2646         return 0;
2647 }
2648
2649 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2650                 void __user *argp)
2651 {
2652         struct cdrom_tocentry entry;
2653         u8 requested_format;
2654         int ret;
2655
2656         /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2657
2658         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2659                 return -ENOSYS;
2660         if (copy_from_user(&entry, argp, sizeof(entry)))
2661                 return -EFAULT;
2662
2663         requested_format = entry.cdte_format;
2664         if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2665                 return -EINVAL;
2666         /* make interface to low-level uniform */
2667         entry.cdte_format = CDROM_MSF;
2668         ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2669         if (ret)
2670                 return ret;
2671         sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2672
2673         if (copy_to_user(argp, &entry, sizeof(entry)))
2674                 return -EFAULT;
2675         /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2676         return 0;
2677 }
2678
2679 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2680                 void __user *argp)
2681 {
2682         struct cdrom_msf msf;
2683
2684         cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2685
2686         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2687                 return -ENOSYS;
2688         if (copy_from_user(&msf, argp, sizeof(msf)))
2689                 return -EFAULT;
2690         return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2691 }
2692
2693 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2694                 void __user *argp)
2695 {
2696         struct cdrom_ti ti;
2697         int ret;
2698
2699         cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2700
2701         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2702                 return -ENOSYS;
2703         if (copy_from_user(&ti, argp, sizeof(ti)))
2704                 return -EFAULT;
2705
2706         ret = check_for_audio_disc(cdi, cdi->ops);
2707         if (ret)
2708                 return ret;
2709         return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2710 }
2711 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2712                 void __user *argp)
2713 {
2714         struct cdrom_volctrl volume;
2715
2716         cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2717
2718         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2719                 return -ENOSYS;
2720         if (copy_from_user(&volume, argp, sizeof(volume)))
2721                 return -EFAULT;
2722         return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2723 }
2724
2725 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2726                 void __user *argp)
2727 {
2728         struct cdrom_volctrl volume;
2729         int ret;
2730
2731         cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2732
2733         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2734                 return -ENOSYS;
2735
2736         ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2737         if (ret)
2738                 return ret;
2739
2740         if (copy_to_user(argp, &volume, sizeof(volume)))
2741                 return -EFAULT;
2742         return 0;
2743 }
2744
2745 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2746                 unsigned int cmd)
2747 {
2748         int ret;
2749
2750         cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2751
2752         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2753                 return -ENOSYS;
2754         ret = check_for_audio_disc(cdi, cdi->ops);
2755         if (ret)
2756                 return ret;
2757         return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2758 }
2759
2760 /*
2761  * Just about every imaginable ioctl is supported in the Uniform layer
2762  * these days.
2763  * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2764  */
2765 int cdrom_ioctl(struct file * file, struct cdrom_device_info *cdi,
2766                 struct inode *ip, unsigned int cmd, unsigned long arg)
2767 {
2768         void __user *argp = (void __user *)arg;
2769         int ret;
2770         struct gendisk *disk = ip->i_bdev->bd_disk;
2771
2772         /*
2773          * Try the generic SCSI command ioctl's first.
2774          */
2775         ret = scsi_cmd_ioctl(file, disk->queue, disk, cmd, argp);
2776         if (ret != -ENOTTY)
2777                 return ret;
2778
2779         switch (cmd) {
2780         case CDROMMULTISESSION:
2781                 return cdrom_ioctl_multisession(cdi, argp);
2782         case CDROMEJECT:
2783                 return cdrom_ioctl_eject(cdi);
2784         case CDROMCLOSETRAY:
2785                 return cdrom_ioctl_closetray(cdi);
2786         case CDROMEJECT_SW:
2787                 return cdrom_ioctl_eject_sw(cdi, arg);
2788         case CDROM_MEDIA_CHANGED:
2789                 return cdrom_ioctl_media_changed(cdi, arg);
2790         case CDROM_SET_OPTIONS:
2791                 return cdrom_ioctl_set_options(cdi, arg);
2792         case CDROM_CLEAR_OPTIONS:
2793                 return cdrom_ioctl_clear_options(cdi, arg);
2794         case CDROM_SELECT_SPEED:
2795                 return cdrom_ioctl_select_speed(cdi, arg);
2796         case CDROM_SELECT_DISC:
2797                 return cdrom_ioctl_select_disc(cdi, arg);
2798         case CDROMRESET:
2799                 return cdrom_ioctl_reset(cdi, ip->i_bdev);
2800         case CDROM_LOCKDOOR:
2801                 return cdrom_ioctl_lock_door(cdi, arg);
2802         case CDROM_DEBUG:
2803                 return cdrom_ioctl_debug(cdi, arg);
2804         case CDROM_GET_CAPABILITY:
2805                 return cdrom_ioctl_get_capability(cdi);
2806         case CDROM_GET_MCN:
2807                 return cdrom_ioctl_get_mcn(cdi, argp);
2808         case CDROM_DRIVE_STATUS:
2809                 return cdrom_ioctl_drive_status(cdi, arg);
2810         case CDROM_DISC_STATUS:
2811                 return cdrom_ioctl_disc_status(cdi);
2812         case CDROM_CHANGER_NSLOTS:
2813                 return cdrom_ioctl_changer_nslots(cdi);
2814         }
2815
2816         /*
2817          * Use the ioctls that are implemented through the generic_packet()
2818          * interface. this may look at bit funny, but if -ENOTTY is
2819          * returned that particular ioctl is not implemented and we
2820          * let it go through the device specific ones.
2821          */
2822         if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2823                 ret = mmc_ioctl(cdi, cmd, arg);
2824                 if (ret != -ENOTTY)
2825                         return ret;
2826         }
2827
2828         /*
2829          * Note: most of the cdinfo() calls are commented out here,
2830          * because they fill up the sys log when CD players poll
2831          * the drive.
2832          */
2833         switch (cmd) {
2834         case CDROMSUBCHNL:
2835                 return cdrom_ioctl_get_subchnl(cdi, argp);
2836         case CDROMREADTOCHDR:
2837                 return cdrom_ioctl_read_tochdr(cdi, argp);
2838         case CDROMREADTOCENTRY:
2839                 return cdrom_ioctl_read_tocentry(cdi, argp);
2840         case CDROMPLAYMSF:
2841                 return cdrom_ioctl_play_msf(cdi, argp);
2842         case CDROMPLAYTRKIND:
2843                 return cdrom_ioctl_play_trkind(cdi, argp);
2844         case CDROMVOLCTRL:
2845                 return cdrom_ioctl_volctrl(cdi, argp);
2846         case CDROMVOLREAD:
2847                 return cdrom_ioctl_volread(cdi, argp);
2848         case CDROMSTART:
2849         case CDROMSTOP:
2850         case CDROMPAUSE:
2851         case CDROMRESUME:
2852                 return cdrom_ioctl_audioctl(cdi, cmd);
2853         }
2854
2855         return -ENOSYS;
2856 }
2857
2858 /*
2859  * Required when we need to use READ_10 to issue other than 2048 block
2860  * reads
2861  */
2862 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2863 {
2864         struct cdrom_device_ops *cdo = cdi->ops;
2865         struct packet_command cgc;
2866         struct modesel_head mh;
2867
2868         memset(&mh, 0, sizeof(mh));
2869         mh.block_desc_length = 0x08;
2870         mh.block_length_med = (size >> 8) & 0xff;
2871         mh.block_length_lo = size & 0xff;
2872
2873         memset(&cgc, 0, sizeof(cgc));
2874         cgc.cmd[0] = 0x15;
2875         cgc.cmd[1] = 1 << 4;
2876         cgc.cmd[4] = 12;
2877         cgc.buflen = sizeof(mh);
2878         cgc.buffer = (char *) &mh;
2879         cgc.data_direction = CGC_DATA_WRITE;
2880         mh.block_desc_length = 0x08;
2881         mh.block_length_med = (size >> 8) & 0xff;
2882         mh.block_length_lo = size & 0xff;
2883
2884         return cdo->generic_packet(cdi, &cgc);
2885 }
2886
2887 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
2888                      unsigned long arg)
2889 {               
2890         struct cdrom_device_ops *cdo = cdi->ops;
2891         struct packet_command cgc;
2892         struct request_sense sense;
2893         unsigned char buffer[32];
2894         int ret = 0;
2895
2896         memset(&cgc, 0, sizeof(cgc));
2897
2898         /* build a unified command and queue it through
2899            cdo->generic_packet() */
2900         switch (cmd) {
2901         case CDROMREADRAW:
2902         case CDROMREADMODE1:
2903         case CDROMREADMODE2: {
2904                 struct cdrom_msf msf;
2905                 int blocksize = 0, format = 0, lba;
2906                 
2907                 switch (cmd) {
2908                 case CDROMREADRAW:
2909                         blocksize = CD_FRAMESIZE_RAW;
2910                         break;
2911                 case CDROMREADMODE1:
2912                         blocksize = CD_FRAMESIZE;
2913                         format = 2;
2914                         break;
2915                 case CDROMREADMODE2:
2916                         blocksize = CD_FRAMESIZE_RAW0;
2917                         break;
2918                 }
2919                 IOCTL_IN(arg, struct cdrom_msf, msf);
2920                 lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
2921                 /* FIXME: we need upper bound checking, too!! */
2922                 if (lba < 0)
2923                         return -EINVAL;
2924                 cgc.buffer = kmalloc(blocksize, GFP_KERNEL);
2925                 if (cgc.buffer == NULL)
2926                         return -ENOMEM;
2927                 memset(&sense, 0, sizeof(sense));
2928                 cgc.sense = &sense;
2929                 cgc.data_direction = CGC_DATA_READ;
2930                 ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
2931                 if (ret && sense.sense_key==0x05 && sense.asc==0x20 && sense.ascq==0x00) {
2932                         /*
2933                          * SCSI-II devices are not required to support
2934                          * READ_CD, so let's try switching block size
2935                          */
2936                         /* FIXME: switch back again... */
2937                         if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
2938                                 kfree(cgc.buffer);
2939                                 return ret;
2940                         }
2941                         cgc.sense = NULL;
2942                         ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
2943                         ret |= cdrom_switch_blocksize(cdi, blocksize);
2944                 }
2945                 if (!ret && copy_to_user((char __user *)arg, cgc.buffer, blocksize))
2946                         ret = -EFAULT;
2947                 kfree(cgc.buffer);
2948                 return ret;
2949                 }
2950         case CDROMREADAUDIO: {
2951                 struct cdrom_read_audio ra;
2952                 int lba;
2953
2954                 IOCTL_IN(arg, struct cdrom_read_audio, ra);
2955
2956                 if (ra.addr_format == CDROM_MSF)
2957                         lba = msf_to_lba(ra.addr.msf.minute,
2958                                          ra.addr.msf.second,
2959                                          ra.addr.msf.frame);
2960                 else if (ra.addr_format == CDROM_LBA)
2961                         lba = ra.addr.lba;
2962                 else
2963                         return -EINVAL;
2964
2965                 /* FIXME: we need upper bound checking, too!! */
2966                 if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2967                         return -EINVAL;
2968
2969                 return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2970                 }
2971         case CDROMSUBCHNL: {
2972                 struct cdrom_subchnl q;
2973                 u_char requested, back;
2974                 IOCTL_IN(arg, struct cdrom_subchnl, q);
2975                 requested = q.cdsc_format;
2976                 if (!((requested == CDROM_MSF) ||
2977                       (requested == CDROM_LBA)))
2978                         return -EINVAL;
2979                 q.cdsc_format = CDROM_MSF;
2980                 if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
2981                         return ret;
2982                 back = q.cdsc_format; /* local copy */
2983                 sanitize_format(&q.cdsc_absaddr, &back, requested);
2984                 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2985                 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2986                 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */ 
2987                 return 0;
2988                 }
2989         case CDROMPLAYMSF: {
2990                 struct cdrom_msf msf;
2991                 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2992                 IOCTL_IN(arg, struct cdrom_msf, msf);
2993                 cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2994                 cgc.cmd[3] = msf.cdmsf_min0;
2995                 cgc.cmd[4] = msf.cdmsf_sec0;
2996                 cgc.cmd[5] = msf.cdmsf_frame0;
2997                 cgc.cmd[6] = msf.cdmsf_min1;
2998                 cgc.cmd[7] = msf.cdmsf_sec1;
2999                 cgc.cmd[8] = msf.cdmsf_frame1;
3000                 cgc.data_direction = CGC_DATA_NONE;
3001                 return cdo->generic_packet(cdi, &cgc);
3002                 }
3003         case CDROMPLAYBLK: {
3004                 struct cdrom_blk blk;
3005                 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
3006                 IOCTL_IN(arg, struct cdrom_blk, blk);
3007                 cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
3008                 cgc.cmd[2] = (blk.from >> 24) & 0xff;
3009                 cgc.cmd[3] = (blk.from >> 16) & 0xff;
3010                 cgc.cmd[4] = (blk.from >>  8) & 0xff;
3011                 cgc.cmd[5] = blk.from & 0xff;
3012                 cgc.cmd[7] = (blk.len >> 8) & 0xff;
3013                 cgc.cmd[8] = blk.len & 0xff;
3014                 cgc.data_direction = CGC_DATA_NONE;
3015                 return cdo->generic_packet(cdi, &cgc);
3016                 }
3017         case CDROMVOLCTRL:
3018         case CDROMVOLREAD: {
3019                 struct cdrom_volctrl volctrl;
3020                 char mask[sizeof(buffer)];
3021                 unsigned short offset;
3022
3023                 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3024
3025                 IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
3026
3027                 cgc.buffer = buffer;
3028                 cgc.buflen = 24;
3029                 if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
3030                     return ret;
3031                 
3032                 /* originally the code depended on buffer[1] to determine
3033                    how much data is available for transfer. buffer[1] is
3034                    unfortunately ambigious and the only reliable way seem
3035                    to be to simply skip over the block descriptor... */
3036                 offset = 8 + be16_to_cpu(*(__be16 *)(buffer+6));
3037
3038                 if (offset + 16 > sizeof(buffer))
3039                         return -E2BIG;
3040
3041                 if (offset + 16 > cgc.buflen) {
3042                         cgc.buflen = offset+16;
3043                         ret = cdrom_mode_sense(cdi, &cgc,
3044                                                 GPMODE_AUDIO_CTL_PAGE, 0);
3045                         if (ret)
3046                                 return ret;
3047                 }
3048
3049                 /* sanity check */
3050                 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3051                                 buffer[offset+1] < 14)
3052                         return -EINVAL;
3053
3054                 /* now we have the current volume settings. if it was only
3055                    a CDROMVOLREAD, return these values */
3056                 if (cmd == CDROMVOLREAD) {
3057                         volctrl.channel0 = buffer[offset+9];
3058                         volctrl.channel1 = buffer[offset+11];
3059                         volctrl.channel2 = buffer[offset+13];
3060                         volctrl.channel3 = buffer[offset+15];
3061                         IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
3062                         return 0;
3063                 }
3064                 
3065                 /* get the volume mask */
3066                 cgc.buffer = mask;
3067                 if ((ret = cdrom_mode_sense(cdi, &cgc, 
3068                                 GPMODE_AUDIO_CTL_PAGE, 1)))
3069                         return ret;
3070
3071                 buffer[offset+9] = volctrl.channel0 & mask[offset+9];
3072                 buffer[offset+11] = volctrl.channel1 & mask[offset+11];
3073                 buffer[offset+13] = volctrl.channel2 & mask[offset+13];
3074                 buffer[offset+15] = volctrl.channel3 & mask[offset+15];
3075
3076                 /* set volume */
3077                 cgc.buffer = buffer + offset - 8;
3078                 memset(cgc.buffer, 0, 8);
3079                 return cdrom_mode_select(cdi, &cgc);
3080                 }
3081
3082         case CDROMSTART:
3083         case CDROMSTOP: {
3084                 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n"); 
3085                 cgc.cmd[0] = GPCMD_START_STOP_UNIT;
3086                 cgc.cmd[1] = 1;
3087                 cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3088                 cgc.data_direction = CGC_DATA_NONE;
3089                 return cdo->generic_packet(cdi, &cgc);
3090                 }
3091
3092         case CDROMPAUSE:
3093         case CDROMRESUME: {
3094                 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n"); 
3095                 cgc.cmd[0] = GPCMD_PAUSE_RESUME;
3096                 cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3097                 cgc.data_direction = CGC_DATA_NONE;
3098                 return cdo->generic_packet(cdi, &cgc);
3099                 }
3100
3101         case DVD_READ_STRUCT: {
3102                 dvd_struct *s;
3103                 int size = sizeof(dvd_struct);
3104                 if (!CDROM_CAN(CDC_DVD))
3105                         return -ENOSYS;
3106                 if ((s = kmalloc(size, GFP_KERNEL)) == NULL)
3107                         return -ENOMEM;
3108                 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n"); 
3109                 if (copy_from_user(s, (dvd_struct __user *)arg, size)) {
3110                         kfree(s);
3111                         return -EFAULT;
3112                 }
3113                 if ((ret = dvd_read_struct(cdi, s))) {
3114                         kfree(s);
3115                         return ret;
3116                 }
3117                 if (copy_to_user((dvd_struct __user *)arg, s, size))
3118                         ret = -EFAULT;
3119                 kfree(s);
3120                 return ret;
3121                 }
3122
3123         case DVD_AUTH: {
3124                 dvd_authinfo ai;
3125                 if (!CDROM_CAN(CDC_DVD))
3126                         return -ENOSYS;
3127                 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n"); 
3128                 IOCTL_IN(arg, dvd_authinfo, ai);
3129                 if ((ret = dvd_do_auth (cdi, &ai)))
3130                         return ret;
3131                 IOCTL_OUT(arg, dvd_authinfo, ai);
3132                 return 0;
3133                 }
3134
3135         case CDROM_NEXT_WRITABLE: {
3136                 long next = 0;
3137                 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n"); 
3138                 if ((ret = cdrom_get_next_writable(cdi, &next)))
3139                         return ret;
3140                 IOCTL_OUT(arg, long, next);
3141                 return 0;
3142                 }
3143         case CDROM_LAST_WRITTEN: {
3144                 long last = 0;
3145                 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n"); 
3146                 if ((ret = cdrom_get_last_written(cdi, &last)))
3147                         return ret;
3148                 IOCTL_OUT(arg, long, last);
3149                 return 0;
3150                 }
3151         } /* switch */
3152
3153         return -ENOTTY;
3154 }
3155
3156 static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
3157                          track_information *ti)
3158 {
3159         struct cdrom_device_ops *cdo = cdi->ops;
3160         struct packet_command cgc;
3161         int ret, buflen;
3162
3163         init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3164         cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3165         cgc.cmd[1] = type & 3;
3166         cgc.cmd[4] = (track & 0xff00) >> 8;
3167         cgc.cmd[5] = track & 0xff;
3168         cgc.cmd[8] = 8;
3169         cgc.quiet = 1;
3170
3171         if ((ret = cdo->generic_packet(cdi, &cgc)))
3172                 return ret;
3173         
3174         buflen = be16_to_cpu(ti->track_information_length) +
3175                      sizeof(ti->track_information_length);
3176
3177         if (buflen > sizeof(track_information))
3178                 buflen = sizeof(track_information);
3179
3180         cgc.cmd[8] = cgc.buflen = buflen;
3181         if ((ret = cdo->generic_packet(cdi, &cgc)))
3182                 return ret;
3183
3184         /* return actual fill size */
3185         return buflen;
3186 }
3187
3188 /* requires CD R/RW */
3189 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3190 {
3191         struct cdrom_device_ops *cdo = cdi->ops;
3192         struct packet_command cgc;
3193         int ret, buflen;
3194
3195         /* set up command and get the disc info */
3196         init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3197         cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3198         cgc.cmd[8] = cgc.buflen = 2;
3199         cgc.quiet = 1;
3200
3201         if ((ret = cdo->generic_packet(cdi, &cgc)))
3202                 return ret;
3203
3204         /* not all drives have the same disc_info length, so requeue
3205          * packet with the length the drive tells us it can supply
3206          */
3207         buflen = be16_to_cpu(di->disc_information_length) +
3208                      sizeof(di->disc_information_length);
3209
3210         if (buflen > sizeof(disc_information))
3211                 buflen = sizeof(disc_information);
3212
3213         cgc.cmd[8] = cgc.buflen = buflen;
3214         if ((ret = cdo->generic_packet(cdi, &cgc)))
3215                 return ret;
3216
3217         /* return actual fill size */
3218         return buflen;
3219 }
3220
3221 /* return the last written block on the CD-R media. this is for the udf
3222    file system. */
3223 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
3224 {
3225         struct cdrom_tocentry toc;
3226         disc_information di;
3227         track_information ti;
3228         __u32 last_track;
3229         int ret = -1, ti_size;
3230
3231         if (!CDROM_CAN(CDC_GENERIC_PACKET))
3232                 goto use_toc;
3233
3234         ret = cdrom_get_disc_info(cdi, &di);
3235         if (ret < (int)(offsetof(typeof(di), last_track_lsb)
3236                         + sizeof(di.last_track_lsb)))
3237                 goto use_toc;
3238
3239         /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3240         last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3241         ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3242         if (ti_size < (int)offsetof(typeof(ti), track_start))
3243                 goto use_toc;
3244
3245         /* if this track is blank, try the previous. */
3246         if (ti.blank) {
3247                 if (last_track==1)
3248                         goto use_toc;
3249                 last_track--;
3250                 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3251         }
3252
3253         if (ti_size < (int)(offsetof(typeof(ti), track_size)
3254                                 + sizeof(ti.track_size)))
3255                 goto use_toc;
3256
3257         /* if last recorded field is valid, return it. */
3258         if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3259                                 + sizeof(ti.last_rec_address))) {
3260                 *last_written = be32_to_cpu(ti.last_rec_address);
3261         } else {
3262                 /* make it up instead */
3263                 *last_written = be32_to_cpu(ti.track_start) +
3264                                 be32_to_cpu(ti.track_size);
3265                 if (ti.free_blocks)
3266                         *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3267         }
3268         return 0;
3269
3270         /* this is where we end up if the drive either can't do a
3271            GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3272            it doesn't give enough information or fails. then we return
3273            the toc contents. */
3274 use_toc:
3275         toc.cdte_format = CDROM_MSF;
3276         toc.cdte_track = CDROM_LEADOUT;
3277         if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
3278                 return ret;
3279         sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
3280         *last_written = toc.cdte_addr.lba;
3281         return 0;
3282 }
3283
3284 /* return the next writable block. also for udf file system. */
3285 static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3286 {
3287         disc_information di;
3288         track_information ti;
3289         __u16 last_track;
3290         int ret, ti_size;
3291
3292         if (!CDROM_CAN(CDC_GENERIC_PACKET))
3293                 goto use_last_written;
3294
3295         ret = cdrom_get_disc_info(cdi, &di);
3296         if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3297                                 + sizeof(di.last_track_lsb))
3298                 goto use_last_written;
3299
3300         /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3301         last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3302         ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3303         if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3304                 goto use_last_written;
3305
3306         /* if this track is blank, try the previous. */
3307         if (ti.blank) {
3308                 if (last_track == 1)
3309                         goto use_last_written;
3310                 last_track--;
3311                 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3312                 if (ti_size < 0)
3313                         goto use_last_written;
3314         }
3315
3316         /* if next recordable address field is valid, use it. */
3317         if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
3318                                 + sizeof(ti.next_writable)) {
3319                 *next_writable = be32_to_cpu(ti.next_writable);
3320                 return 0;
3321         }
3322
3323 use_last_written:
3324         if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3325                 *next_writable = 0;
3326                 return ret;
3327         } else {
3328                 *next_writable += 7;
3329                 return 0;
3330         }
3331 }
3332
3333 EXPORT_SYMBOL(cdrom_get_last_written);
3334 EXPORT_SYMBOL(register_cdrom);
3335 EXPORT_SYMBOL(unregister_cdrom);
3336 EXPORT_SYMBOL(cdrom_open);
3337 EXPORT_SYMBOL(cdrom_release);
3338 EXPORT_SYMBOL(cdrom_ioctl);
3339 EXPORT_SYMBOL(cdrom_media_changed);
3340 EXPORT_SYMBOL(cdrom_number_of_slots);
3341 EXPORT_SYMBOL(cdrom_mode_select);
3342 EXPORT_SYMBOL(cdrom_mode_sense);
3343 EXPORT_SYMBOL(init_cdrom_command);
3344 EXPORT_SYMBOL(cdrom_get_media_event);
3345
3346 #ifdef CONFIG_SYSCTL
3347
3348 #define CDROM_STR_SIZE 1000
3349
3350 static struct cdrom_sysctl_settings {
3351         char    info[CDROM_STR_SIZE];   /* general info */
3352         int     autoclose;              /* close tray upon mount, etc */
3353         int     autoeject;              /* eject on umount */
3354         int     debug;                  /* turn on debugging messages */
3355         int     lock;                   /* lock the door on device open */
3356         int     check;                  /* check media type */
3357 } cdrom_sysctl_settings;
3358
3359 enum cdrom_print_option {
3360         CTL_NAME,
3361         CTL_SPEED,
3362         CTL_SLOTS,
3363         CTL_CAPABILITY
3364 };
3365
3366 static int cdrom_print_info(const char *header, int val, char *info,
3367                                 int *pos, enum cdrom_print_option option)
3368 {
3369         const int max_size = sizeof(cdrom_sysctl_settings.info);
3370         struct cdrom_device_info *cdi;
3371         int ret;
3372
3373         ret = scnprintf(info + *pos, max_size - *pos, header);
3374         if (!ret)
3375                 return 1;
3376
3377         *pos += ret;
3378
3379         list_for_each_entry(cdi, &cdrom_list, list) {
3380                 switch (option) {
3381                 case CTL_NAME:
3382                         ret = scnprintf(info + *pos, max_size - *pos,
3383                                         "\t%s", cdi->name);
3384                         break;
3385                 case CTL_SPEED:
3386                         ret = scnprintf(info + *pos, max_size - *pos,
3387                                         "\t%d", cdi->speed);
3388                         break;
3389                 case CTL_SLOTS:
3390                         ret = scnprintf(info + *pos, max_size - *pos,
3391                                         "\t%d", cdi->capacity);
3392                         break;
3393                 case CTL_CAPABILITY:
3394                         ret = scnprintf(info + *pos, max_size - *pos,
3395                                         "\t%d", CDROM_CAN(val) != 0);
3396                         break;
3397                 default:
3398                         printk(KERN_INFO "cdrom: invalid option%d\n", option);
3399                         return 1;
3400                 }
3401                 if (!ret)
3402                         return 1;
3403                 *pos += ret;
3404         }
3405
3406         return 0;
3407 }
3408
3409 static int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
3410                            void __user *buffer, size_t *lenp, loff_t *ppos)
3411 {
3412         int pos;
3413         char *info = cdrom_sysctl_settings.info;
3414         const int max_size = sizeof(cdrom_sysctl_settings.info);
3415         
3416         if (!*lenp || (*ppos && !write)) {
3417                 *lenp = 0;
3418                 return 0;
3419         }
3420
3421         mutex_lock(&cdrom_mutex);
3422
3423         pos = sprintf(info, "CD-ROM information, " VERSION "\n");
3424         
3425         if (cdrom_print_info("\ndrive name:\t", 0, info, &pos, CTL_NAME))
3426                 goto done;
3427         if (cdrom_print_info("\ndrive speed:\t", 0, info, &pos, CTL_SPEED))
3428                 goto done;
3429         if (cdrom_print_info("\ndrive # of slots:", 0, info, &pos, CTL_SLOTS))
3430                 goto done;
3431         if (cdrom_print_info("\nCan close tray:\t",
3432                                 CDC_CLOSE_TRAY, info, &pos, CTL_CAPABILITY))
3433                 goto done;
3434         if (cdrom_print_info("\nCan open tray:\t",
3435                                 CDC_OPEN_TRAY, info, &pos, CTL_CAPABILITY))
3436                 goto done;
3437         if (cdrom_print_info("\nCan lock tray:\t",
3438                                 CDC_LOCK, info, &pos, CTL_CAPABILITY))
3439                 goto done;
3440         if (cdrom_print_info("\nCan change speed:",
3441                                 CDC_SELECT_SPEED, info, &pos, CTL_CAPABILITY))
3442                 goto done;
3443         if (cdrom_print_info("\nCan select disk:",
3444                                 CDC_SELECT_DISC, info, &pos, CTL_CAPABILITY))
3445                 goto done;
3446         if (cdrom_print_info("\nCan read multisession:",
3447                                 CDC_MULTI_SESSION, info, &pos, CTL_CAPABILITY))
3448                 goto done;
3449         if (cdrom_print_info("\nCan read MCN:\t",
3450                                 CDC_MCN, info, &pos, CTL_CAPABILITY))
3451                 goto done;
3452         if (cdrom_print_info("\nReports media changed:",
3453                                 CDC_MEDIA_CHANGED, info, &pos, CTL_CAPABILITY))
3454                 goto done;
3455         if (cdrom_print_info("\nCan play audio:\t",
3456                                 CDC_PLAY_AUDIO, info, &pos, CTL_CAPABILITY))
3457                 goto done;
3458         if (cdrom_print_info("\nCan write CD-R:\t",
3459                                 CDC_CD_R, info, &pos, CTL_CAPABILITY))
3460                 goto done;
3461         if (cdrom_print_info("\nCan write CD-RW:",
3462                                 CDC_CD_RW, info, &pos, CTL_CAPABILITY))
3463                 goto done;
3464         if (cdrom_print_info("\nCan read DVD:\t",
3465                                 CDC_DVD, info, &pos, CTL_CAPABILITY))
3466                 goto done;
3467         if (cdrom_print_info("\nCan write DVD-R:",
3468                                 CDC_DVD_R, info, &pos, CTL_CAPABILITY))
3469                 goto done;
3470         if (cdrom_print_info("\nCan write DVD-RAM:",
3471                                 CDC_DVD_RAM, info, &pos, CTL_CAPABILITY))
3472                 goto done;
3473         if (cdrom_print_info("\nCan read MRW:\t",
3474                                 CDC_MRW, info, &pos, CTL_CAPABILITY))
3475                 goto done;
3476         if (cdrom_print_info("\nCan write MRW:\t",
3477                                 CDC_MRW_W, info, &pos, CTL_CAPABILITY))
3478                 goto done;
3479         if (cdrom_print_info("\nCan write RAM:\t",
3480                                 CDC_RAM, info, &pos, CTL_CAPABILITY))
3481                 goto done;
3482         if (!scnprintf(info + pos, max_size - pos, "\n\n"))
3483                 goto done;
3484 doit:
3485         mutex_unlock(&cdrom_mutex);
3486         return proc_dostring(ctl, write, filp, buffer, lenp, ppos);
3487 done:
3488         printk(KERN_INFO "cdrom: info buffer too small\n");
3489         goto doit;
3490 }
3491
3492 /* Unfortunately, per device settings are not implemented through
3493    procfs/sysctl yet. When they are, this will naturally disappear. For now
3494    just update all drives. Later this will become the template on which
3495    new registered drives will be based. */
3496 static void cdrom_update_settings(void)
3497 {
3498         struct cdrom_device_info *cdi;
3499
3500         mutex_lock(&cdrom_mutex);
3501         list_for_each_entry(cdi, &cdrom_list, list) {
3502                 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
3503                         cdi->options |= CDO_AUTO_CLOSE;
3504                 else if (!autoclose)
3505                         cdi->options &= ~CDO_AUTO_CLOSE;
3506                 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
3507                         cdi->options |= CDO_AUTO_EJECT;
3508                 else if (!autoeject)
3509                         cdi->options &= ~CDO_AUTO_EJECT;
3510                 if (lockdoor && CDROM_CAN(CDC_LOCK))
3511                         cdi->options |= CDO_LOCK;
3512                 else if (!lockdoor)
3513                         cdi->options &= ~CDO_LOCK;
3514                 if (check_media_type)
3515                         cdi->options |= CDO_CHECK_TYPE;
3516                 else
3517                         cdi->options &= ~CDO_CHECK_TYPE;
3518         }
3519         mutex_unlock(&cdrom_mutex);
3520 }
3521
3522 static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
3523                                 void __user *buffer, size_t *lenp, loff_t *ppos)
3524 {
3525         int ret;
3526         
3527         ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
3528
3529         if (write) {
3530         
3531                 /* we only care for 1 or 0. */
3532                 autoclose        = !!cdrom_sysctl_settings.autoclose;
3533                 autoeject        = !!cdrom_sysctl_settings.autoeject;
3534                 debug            = !!cdrom_sysctl_settings.debug;
3535                 lockdoor         = !!cdrom_sysctl_settings.lock;
3536                 check_media_type = !!cdrom_sysctl_settings.check;
3537
3538                 /* update the option flags according to the changes. we
3539                    don't have per device options through sysctl yet,
3540                    but we will have and then this will disappear. */
3541                 cdrom_update_settings();
3542         }
3543
3544         return ret;
3545 }
3546
3547 /* Place files in /proc/sys/dev/cdrom */
3548 static ctl_table cdrom_table[] = {
3549         {
3550                 .procname       = "info",
3551                 .data           = &cdrom_sysctl_settings.info, 
3552                 .maxlen         = CDROM_STR_SIZE,
3553                 .mode           = 0444,
3554                 .proc_handler   = &cdrom_sysctl_info,
3555         },
3556         {
3557                 .procname       = "autoclose",
3558                 .data           = &cdrom_sysctl_settings.autoclose,
3559                 .maxlen         = sizeof(int),
3560                 .mode           = 0644,
3561                 .proc_handler   = &cdrom_sysctl_handler,
3562         },
3563         {
3564                 .procname       = "autoeject",
3565                 .data           = &cdrom_sysctl_settings.autoeject,
3566                 .maxlen         = sizeof(int),
3567                 .mode           = 0644,
3568                 .proc_handler   = &cdrom_sysctl_handler,
3569         },
3570         {
3571                 .procname       = "debug",
3572                 .data           = &cdrom_sysctl_settings.debug,
3573                 .maxlen         = sizeof(int),
3574                 .mode           = 0644,
3575                 .proc_handler   = &cdrom_sysctl_handler,
3576         },
3577         {
3578                 .procname       = "lock",
3579                 .data           = &cdrom_sysctl_settings.lock,
3580                 .maxlen         = sizeof(int),
3581                 .mode           = 0644,
3582                 .proc_handler   = &cdrom_sysctl_handler,
3583         },
3584         {
3585                 .procname       = "check_media",
3586                 .data           = &cdrom_sysctl_settings.check,
3587                 .maxlen         = sizeof(int),
3588                 .mode           = 0644,
3589                 .proc_handler   = &cdrom_sysctl_handler
3590         },
3591         { .ctl_name = 0 }
3592 };
3593
3594 static ctl_table cdrom_cdrom_table[] = {
3595         {
3596                 .ctl_name       = DEV_CDROM,
3597                 .procname       = "cdrom",
3598                 .maxlen         = 0,
3599                 .mode           = 0555,
3600                 .child          = cdrom_table,
3601         },
3602         { .ctl_name = 0 }
3603 };
3604
3605 /* Make sure that /proc/sys/dev is there */
3606 static ctl_table cdrom_root_table[] = {
3607         {
3608                 .ctl_name       = CTL_DEV,
3609                 .procname       = "dev",
3610                 .maxlen         = 0,
3611                 .mode           = 0555,
3612                 .child          = cdrom_cdrom_table,
3613         },
3614         { .ctl_name = 0 }
3615 };
3616 static struct ctl_table_header *cdrom_sysctl_header;
3617
3618 static void cdrom_sysctl_register(void)
3619 {
3620         static int initialized;
3621
3622         if (initialized == 1)
3623                 return;
3624
3625         cdrom_sysctl_header = register_sysctl_table(cdrom_root_table);
3626
3627         /* set the defaults */
3628         cdrom_sysctl_settings.autoclose = autoclose;
3629         cdrom_sysctl_settings.autoeject = autoeject;
3630         cdrom_sysctl_settings.debug = debug;
3631         cdrom_sysctl_settings.lock = lockdoor;
3632         cdrom_sysctl_settings.check = check_media_type;
3633
3634         initialized = 1;
3635 }
3636
3637 static void cdrom_sysctl_unregister(void)
3638 {
3639         if (cdrom_sysctl_header)
3640                 unregister_sysctl_table(cdrom_sysctl_header);
3641 }
3642
3643 #else /* CONFIG_SYSCTL */
3644
3645 static void cdrom_sysctl_register(void)
3646 {
3647 }
3648
3649 static void cdrom_sysctl_unregister(void)
3650 {
3651 }
3652
3653 #endif /* CONFIG_SYSCTL */
3654
3655 static int __init cdrom_init(void)
3656 {
3657         cdrom_sysctl_register();
3658
3659         return 0;
3660 }
3661
3662 static void __exit cdrom_exit(void)
3663 {
3664         printk(KERN_INFO "Uniform CD-ROM driver unloaded\n");
3665         cdrom_sysctl_unregister();
3666 }
3667
3668 module_init(cdrom_init);
3669 module_exit(cdrom_exit);
3670 MODULE_LICENSE("GPL");