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