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