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