pandora: reserve CMA area for c64_tools
[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                 return 0;
877         default:
878                 return 1;
879         }
880 }
881
882 /*
883  * returns 0 for ok to open write, non-0 to disallow
884  */
885 static int cdrom_open_write(struct cdrom_device_info *cdi)
886 {
887         int mrw, mrw_write, ram_write;
888         int ret = 1;
889
890         mrw = 0;
891         if (!cdrom_is_mrw(cdi, &mrw_write))
892                 mrw = 1;
893
894         if (CDROM_CAN(CDC_MO_DRIVE))
895                 ram_write = 1;
896         else
897                 (void) cdrom_is_random_writable(cdi, &ram_write);
898         
899         if (mrw)
900                 cdi->mask &= ~CDC_MRW;
901         else
902                 cdi->mask |= CDC_MRW;
903
904         if (mrw_write)
905                 cdi->mask &= ~CDC_MRW_W;
906         else
907                 cdi->mask |= CDC_MRW_W;
908
909         if (ram_write)
910                 cdi->mask &= ~CDC_RAM;
911         else
912                 cdi->mask |= CDC_RAM;
913
914         if (CDROM_CAN(CDC_MRW_W))
915                 ret = cdrom_mrw_open_write(cdi);
916         else if (CDROM_CAN(CDC_DVD_RAM))
917                 ret = cdrom_dvdram_open_write(cdi);
918         else if (CDROM_CAN(CDC_RAM) &&
919                  !CDROM_CAN(CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_MRW|CDC_MO_DRIVE))
920                 ret = cdrom_ram_open_write(cdi);
921         else if (CDROM_CAN(CDC_MO_DRIVE))
922                 ret = mo_open_write(cdi);
923         else if (!cdrom_is_dvd_rw(cdi))
924                 ret = 0;
925
926         return ret;
927 }
928
929 static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
930 {
931         struct packet_command cgc;
932
933         if (cdi->mmc3_profile != 0x1a) {
934                 cdinfo(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
935                 return;
936         }
937
938         if (!cdi->media_written) {
939                 cdinfo(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
940                 return;
941         }
942
943         pr_info("%s: dirty DVD+RW media, \"finalizing\"\n", cdi->name);
944
945         init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
946         cgc.cmd[0] = GPCMD_FLUSH_CACHE;
947         cgc.timeout = 30*HZ;
948         cdi->ops->generic_packet(cdi, &cgc);
949
950         init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
951         cgc.cmd[0] = GPCMD_CLOSE_TRACK;
952         cgc.timeout = 3000*HZ;
953         cgc.quiet = 1;
954         cdi->ops->generic_packet(cdi, &cgc);
955
956         init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
957         cgc.cmd[0] = GPCMD_CLOSE_TRACK;
958         cgc.cmd[2] = 2;  /* Close session */
959         cgc.quiet = 1;
960         cgc.timeout = 3000*HZ;
961         cdi->ops->generic_packet(cdi, &cgc);
962
963         cdi->media_written = 0;
964 }
965
966 static int cdrom_close_write(struct cdrom_device_info *cdi)
967 {
968 #if 0
969         return cdrom_flush_cache(cdi);
970 #else
971         return 0;
972 #endif
973 }
974
975 /* We use the open-option O_NONBLOCK to indicate that the
976  * purpose of opening is only for subsequent ioctl() calls; no device
977  * integrity checks are performed.
978  *
979  * We hope that all cd-player programs will adopt this convention. It
980  * is in their own interest: device control becomes a lot easier
981  * this way.
982  */
983 int cdrom_open(struct cdrom_device_info *cdi, struct block_device *bdev, fmode_t mode)
984 {
985         int ret;
986
987         cdinfo(CD_OPEN, "entering cdrom_open\n"); 
988
989         /* open is event synchronization point, check events first */
990         check_disk_change(bdev);
991
992         /* if this was a O_NONBLOCK open and we should honor the flags,
993          * do a quick open without drive/disc integrity checks. */
994         cdi->use_count++;
995         if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) {
996                 ret = cdi->ops->open(cdi, 1);
997         } else {
998                 ret = open_for_data(cdi);
999                 if (ret)
1000                         goto err;
1001                 cdrom_mmc3_profile(cdi);
1002                 if (mode & FMODE_WRITE) {
1003                         ret = -EROFS;
1004                         if (cdrom_open_write(cdi))
1005                                 goto err_release;
1006                         if (!CDROM_CAN(CDC_RAM))
1007                                 goto err_release;
1008                         ret = 0;
1009                         cdi->media_written = 0;
1010                 }
1011         }
1012
1013         if (ret)
1014                 goto err;
1015
1016         cdinfo(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1017                         cdi->name, cdi->use_count);
1018         return 0;
1019 err_release:
1020         if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1021                 cdi->ops->lock_door(cdi, 0);
1022                 cdinfo(CD_OPEN, "door unlocked.\n");
1023         }
1024         cdi->ops->release(cdi);
1025 err:
1026         cdi->use_count--;
1027         return ret;
1028 }
1029
1030 static
1031 int open_for_data(struct cdrom_device_info * cdi)
1032 {
1033         int ret;
1034         struct cdrom_device_ops *cdo = cdi->ops;
1035         tracktype tracks;
1036         cdinfo(CD_OPEN, "entering open_for_data\n");
1037         /* Check if the driver can report drive status.  If it can, we
1038            can do clever things.  If it can't, well, we at least tried! */
1039         if (cdo->drive_status != NULL) {
1040                 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1041                 cdinfo(CD_OPEN, "drive_status=%d\n", ret); 
1042                 if (ret == CDS_TRAY_OPEN) {
1043                         cdinfo(CD_OPEN, "the tray is open...\n"); 
1044                         /* can/may i close it? */
1045                         if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1046                             cdi->options & CDO_AUTO_CLOSE) {
1047                                 cdinfo(CD_OPEN, "trying to close the tray.\n"); 
1048                                 ret=cdo->tray_move(cdi,0);
1049                                 if (ret) {
1050                                         cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.\n"); 
1051                                         /* Ignore the error from the low
1052                                         level driver.  We don't care why it
1053                                         couldn't close the tray.  We only care 
1054                                         that there is no disc in the drive, 
1055                                         since that is the _REAL_ problem here.*/
1056                                         ret=-ENOMEDIUM;
1057                                         goto clean_up_and_return;
1058                                 }
1059                         } else {
1060                                 cdinfo(CD_OPEN, "bummer. this drive can't close the tray.\n"); 
1061                                 ret=-ENOMEDIUM;
1062                                 goto clean_up_and_return;
1063                         }
1064                         /* Ok, the door should be closed now.. Check again */
1065                         ret = cdo->drive_status(cdi, CDSL_CURRENT);
1066                         if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1067                                 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n"); 
1068                                 cdinfo(CD_OPEN, "tray might not contain a medium.\n");
1069                                 ret=-ENOMEDIUM;
1070                                 goto clean_up_and_return;
1071                         }
1072                         cdinfo(CD_OPEN, "the tray is now closed.\n"); 
1073                 }
1074                 /* the door should be closed now, check for the disc */
1075                 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1076                 if (ret!=CDS_DISC_OK) {
1077                         ret = -ENOMEDIUM;
1078                         goto clean_up_and_return;
1079                 }
1080         }
1081         cdrom_count_tracks(cdi, &tracks);
1082         if (tracks.error == CDS_NO_DISC) {
1083                 cdinfo(CD_OPEN, "bummer. no disc.\n");
1084                 ret=-ENOMEDIUM;
1085                 goto clean_up_and_return;
1086         }
1087         /* CD-Players which don't use O_NONBLOCK, workman
1088          * for example, need bit CDO_CHECK_TYPE cleared! */
1089         if (tracks.data==0) {
1090                 if (cdi->options & CDO_CHECK_TYPE) {
1091                     /* give people a warning shot, now that CDO_CHECK_TYPE
1092                        is the default case! */
1093                     cdinfo(CD_OPEN, "bummer. wrong media type.\n"); 
1094                     cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1095                                         (unsigned int)task_pid_nr(current));
1096                     ret=-EMEDIUMTYPE;
1097                     goto clean_up_and_return;
1098                 }
1099                 else {
1100                     cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.\n");
1101                 }
1102         }
1103
1104         cdinfo(CD_OPEN, "all seems well, opening the device.\n"); 
1105
1106         /* all seems well, we can open the device */
1107         ret = cdo->open(cdi, 0); /* open for data */
1108         cdinfo(CD_OPEN, "opening the device gave me %d.\n", ret); 
1109         /* After all this careful checking, we shouldn't have problems
1110            opening the device, but we don't want the device locked if 
1111            this somehow fails... */
1112         if (ret) {
1113                 cdinfo(CD_OPEN, "open device failed.\n"); 
1114                 goto clean_up_and_return;
1115         }
1116         if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1117                         cdo->lock_door(cdi, 1);
1118                         cdinfo(CD_OPEN, "door locked.\n");
1119         }
1120         cdinfo(CD_OPEN, "device opened successfully.\n"); 
1121         return ret;
1122
1123         /* Something failed.  Try to unlock the drive, because some drivers
1124         (notably ide-cd) lock the drive after every command.  This produced
1125         a nasty bug where after mount failed, the drive would remain locked!  
1126         This ensures that the drive gets unlocked after a mount fails.  This 
1127         is a goto to avoid bloating the driver with redundant code. */ 
1128 clean_up_and_return:
1129         cdinfo(CD_OPEN, "open failed.\n"); 
1130         if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1131                         cdo->lock_door(cdi, 0);
1132                         cdinfo(CD_OPEN, "door unlocked.\n");
1133         }
1134         return ret;
1135 }
1136
1137 /* This code is similar to that in open_for_data. The routine is called
1138    whenever an audio play operation is requested.
1139 */
1140 static int check_for_audio_disc(struct cdrom_device_info * cdi,
1141                                 struct cdrom_device_ops * cdo)
1142 {
1143         int ret;
1144         tracktype tracks;
1145         cdinfo(CD_OPEN, "entering check_for_audio_disc\n");
1146         if (!(cdi->options & CDO_CHECK_TYPE))
1147                 return 0;
1148         if (cdo->drive_status != NULL) {
1149                 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1150                 cdinfo(CD_OPEN, "drive_status=%d\n", ret); 
1151                 if (ret == CDS_TRAY_OPEN) {
1152                         cdinfo(CD_OPEN, "the tray is open...\n"); 
1153                         /* can/may i close it? */
1154                         if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1155                             cdi->options & CDO_AUTO_CLOSE) {
1156                                 cdinfo(CD_OPEN, "trying to close the tray.\n"); 
1157                                 ret=cdo->tray_move(cdi,0);
1158                                 if (ret) {
1159                                         cdinfo(CD_OPEN, "bummer. tried to close tray but failed.\n"); 
1160                                         /* Ignore the error from the low
1161                                         level driver.  We don't care why it
1162                                         couldn't close the tray.  We only care 
1163                                         that there is no disc in the drive, 
1164                                         since that is the _REAL_ problem here.*/
1165                                         return -ENOMEDIUM;
1166                                 }
1167                         } else {
1168                                 cdinfo(CD_OPEN, "bummer. this driver can't close the tray.\n"); 
1169                                 return -ENOMEDIUM;
1170                         }
1171                         /* Ok, the door should be closed now.. Check again */
1172                         ret = cdo->drive_status(cdi, CDSL_CURRENT);
1173                         if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1174                                 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n"); 
1175                                 return -ENOMEDIUM;
1176                         }       
1177                         if (ret!=CDS_DISC_OK) {
1178                                 cdinfo(CD_OPEN, "bummer. disc isn't ready.\n"); 
1179                                 return -EIO;
1180                         }       
1181                         cdinfo(CD_OPEN, "the tray is now closed.\n"); 
1182                 }       
1183         }
1184         cdrom_count_tracks(cdi, &tracks);
1185         if (tracks.error) 
1186                 return(tracks.error);
1187
1188         if (tracks.audio==0)
1189                 return -EMEDIUMTYPE;
1190
1191         return 0;
1192 }
1193
1194 void cdrom_release(struct cdrom_device_info *cdi, fmode_t mode)
1195 {
1196         struct cdrom_device_ops *cdo = cdi->ops;
1197         int opened_for_data;
1198
1199         cdinfo(CD_CLOSE, "entering cdrom_release\n");
1200
1201         if (cdi->use_count > 0)
1202                 cdi->use_count--;
1203
1204         if (cdi->use_count == 0) {
1205                 cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
1206                 cdrom_dvd_rw_close_write(cdi);
1207
1208                 if ((cdo->capability & CDC_LOCK) && !keeplocked) {
1209                         cdinfo(CD_CLOSE, "Unlocking door!\n");
1210                         cdo->lock_door(cdi, 0);
1211                 }
1212         }
1213
1214         opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
1215                 !(mode & FMODE_NDELAY);
1216
1217         /*
1218          * flush cache on last write release
1219          */
1220         if (CDROM_CAN(CDC_RAM) && !cdi->use_count && cdi->for_data)
1221                 cdrom_close_write(cdi);
1222
1223         cdo->release(cdi);
1224         if (cdi->use_count == 0) {      /* last process that closes dev*/
1225                 if (opened_for_data &&
1226                     cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
1227                         cdo->tray_move(cdi, 1);
1228         }
1229 }
1230
1231 static int cdrom_read_mech_status(struct cdrom_device_info *cdi, 
1232                                   struct cdrom_changer_info *buf)
1233 {
1234         struct packet_command cgc;
1235         struct cdrom_device_ops *cdo = cdi->ops;
1236         int length;
1237
1238         /*
1239          * Sanyo changer isn't spec compliant (doesn't use regular change
1240          * LOAD_UNLOAD command, and it doesn't implement the mech status
1241          * command below
1242          */
1243         if (cdi->sanyo_slot) {
1244                 buf->hdr.nslots = 3;
1245                 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
1246                 for (length = 0; length < 3; length++) {
1247                         buf->slots[length].disc_present = 1;
1248                         buf->slots[length].change = 0;
1249                 }
1250                 return 0;
1251         }
1252
1253         length = sizeof(struct cdrom_mechstat_header) +
1254                  cdi->capacity * sizeof(struct cdrom_slot);
1255
1256         init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
1257         cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
1258         cgc.cmd[8] = (length >> 8) & 0xff;
1259         cgc.cmd[9] = length & 0xff;
1260         return cdo->generic_packet(cdi, &cgc);
1261 }
1262
1263 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1264 {
1265         struct cdrom_changer_info *info;
1266         int ret;
1267
1268         cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n"); 
1269         if (cdi->sanyo_slot)
1270                 return CDS_NO_INFO;
1271         
1272         info = kmalloc(sizeof(*info), GFP_KERNEL);
1273         if (!info)
1274                 return -ENOMEM;
1275
1276         if ((ret = cdrom_read_mech_status(cdi, info)))
1277                 goto out_free;
1278
1279         if (info->slots[slot].disc_present)
1280                 ret = CDS_DISC_OK;
1281         else
1282                 ret = CDS_NO_DISC;
1283
1284 out_free:
1285         kfree(info);
1286         return ret;
1287 }
1288
1289 /* Return the number of slots for an ATAPI/SCSI cdrom, 
1290  * return 1 if not a changer. 
1291  */
1292 int cdrom_number_of_slots(struct cdrom_device_info *cdi) 
1293 {
1294         int status;
1295         int nslots = 1;
1296         struct cdrom_changer_info *info;
1297
1298         cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n"); 
1299         /* cdrom_read_mech_status requires a valid value for capacity: */
1300         cdi->capacity = 0; 
1301
1302         info = kmalloc(sizeof(*info), GFP_KERNEL);
1303         if (!info)
1304                 return -ENOMEM;
1305
1306         if ((status = cdrom_read_mech_status(cdi, info)) == 0)
1307                 nslots = info->hdr.nslots;
1308
1309         kfree(info);
1310         return nslots;
1311 }
1312
1313
1314 /* If SLOT < 0, unload the current slot.  Otherwise, try to load SLOT. */
1315 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot) 
1316 {
1317         struct packet_command cgc;
1318
1319         cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n"); 
1320         if (cdi->sanyo_slot && slot < 0)
1321                 return 0;
1322
1323         init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
1324         cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
1325         cgc.cmd[4] = 2 + (slot >= 0);
1326         cgc.cmd[8] = slot;
1327         cgc.timeout = 60 * HZ;
1328
1329         /* The Sanyo 3 CD changer uses byte 7 of the 
1330         GPCMD_TEST_UNIT_READY to command to switch CDs instead of
1331         using the GPCMD_LOAD_UNLOAD opcode. */
1332         if (cdi->sanyo_slot && -1 < slot) {
1333                 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
1334                 cgc.cmd[7] = slot;
1335                 cgc.cmd[4] = cgc.cmd[8] = 0;
1336                 cdi->sanyo_slot = slot ? slot : 3;
1337         }
1338
1339         return cdi->ops->generic_packet(cdi, &cgc);
1340 }
1341
1342 static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1343 {
1344         struct cdrom_changer_info *info;
1345         int curslot;
1346         int ret;
1347
1348         cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n"); 
1349         if (!CDROM_CAN(CDC_SELECT_DISC))
1350                 return -EDRIVE_CANT_DO_THIS;
1351
1352         if (cdi->ops->check_events)
1353                 cdi->ops->check_events(cdi, 0, slot);
1354         else
1355                 cdi->ops->media_changed(cdi, slot);
1356
1357         if (slot == CDSL_NONE) {
1358                 /* set media changed bits, on both queues */
1359                 cdi->mc_flags = 0x3;
1360                 return cdrom_load_unload(cdi, -1);
1361         }
1362
1363         info = kmalloc(sizeof(*info), GFP_KERNEL);
1364         if (!info)
1365                 return -ENOMEM;
1366
1367         if ((ret = cdrom_read_mech_status(cdi, info))) {
1368                 kfree(info);
1369                 return ret;
1370         }
1371
1372         curslot = info->hdr.curslot;
1373         kfree(info);
1374
1375         if (cdi->use_count > 1 || keeplocked) {
1376                 if (slot == CDSL_CURRENT) {
1377                         return curslot;
1378                 } else {
1379                         return -EBUSY;
1380                 }
1381         }
1382
1383         /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
1384         which is useful if it had been previously unloaded.
1385         Whether it can or not, it returns the current slot. 
1386         Similarly,  if slot happens to be the current one, we still
1387         try and load it. */
1388         if (slot == CDSL_CURRENT)
1389                 slot = curslot;
1390
1391         /* set media changed bits on both queues */
1392         cdi->mc_flags = 0x3;
1393         if ((ret = cdrom_load_unload(cdi, slot)))
1394                 return ret;
1395
1396         return slot;
1397 }
1398
1399 /*
1400  * As cdrom implements an extra ioctl consumer for media changed
1401  * event, it needs to buffer ->check_events() output, such that event
1402  * is not lost for both the usual VFS and ioctl paths.
1403  * cdi->{vfs|ioctl}_events are used to buffer pending events for each
1404  * path.
1405  *
1406  * XXX: Locking is non-existent.  cdi->ops->check_events() can be
1407  * called in parallel and buffering fields are accessed without any
1408  * exclusion.  The original media_changed code had the same problem.
1409  * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
1410  * and remove this cruft altogether.  It doesn't have much usefulness
1411  * at this point.
1412  */
1413 static void cdrom_update_events(struct cdrom_device_info *cdi,
1414                                 unsigned int clearing)
1415 {
1416         unsigned int events;
1417
1418         events = cdi->ops->check_events(cdi, clearing, CDSL_CURRENT);
1419         cdi->vfs_events |= events;
1420         cdi->ioctl_events |= events;
1421 }
1422
1423 unsigned int cdrom_check_events(struct cdrom_device_info *cdi,
1424                                 unsigned int clearing)
1425 {
1426         unsigned int events;
1427
1428         cdrom_update_events(cdi, clearing);
1429         events = cdi->vfs_events;
1430         cdi->vfs_events = 0;
1431         return events;
1432 }
1433 EXPORT_SYMBOL(cdrom_check_events);
1434
1435 /* We want to make media_changed accessible to the user through an
1436  * ioctl. The main problem now is that we must double-buffer the
1437  * low-level implementation, to assure that the VFS and the user both
1438  * see a medium change once.
1439  */
1440
1441 static
1442 int media_changed(struct cdrom_device_info *cdi, int queue)
1443 {
1444         unsigned int mask = (1 << (queue & 1));
1445         int ret = !!(cdi->mc_flags & mask);
1446         bool changed;
1447
1448         if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1449                 return ret;
1450
1451         /* changed since last call? */
1452         if (cdi->ops->check_events) {
1453                 BUG_ON(!queue); /* shouldn't be called from VFS path */
1454                 cdrom_update_events(cdi, DISK_EVENT_MEDIA_CHANGE);
1455                 changed = cdi->ioctl_events & DISK_EVENT_MEDIA_CHANGE;
1456                 cdi->ioctl_events = 0;
1457         } else
1458                 changed = cdi->ops->media_changed(cdi, CDSL_CURRENT);
1459
1460         if (changed) {
1461                 cdi->mc_flags = 0x3;    /* set bit on both queues */
1462                 ret |= 1;
1463                 cdi->media_written = 0;
1464         }
1465
1466         cdi->mc_flags &= ~mask;         /* clear bit */
1467         return ret;
1468 }
1469
1470 int cdrom_media_changed(struct cdrom_device_info *cdi)
1471 {
1472         /* This talks to the VFS, which doesn't like errors - just 1 or 0.  
1473          * Returning "0" is always safe (media hasn't been changed). Do that 
1474          * if the low-level cdrom driver dosn't support media changed. */ 
1475         if (cdi == NULL || cdi->ops->media_changed == NULL)
1476                 return 0;
1477         if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1478                 return 0;
1479         return media_changed(cdi, 0);
1480 }
1481
1482 /* badly broken, I know. Is due for a fixup anytime. */
1483 static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1484 {
1485         struct cdrom_tochdr header;
1486         struct cdrom_tocentry entry;
1487         int ret, i;
1488         tracks->data=0;
1489         tracks->audio=0;
1490         tracks->cdi=0;
1491         tracks->xa=0;
1492         tracks->error=0;
1493         cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n"); 
1494         /* Grab the TOC header so we can see how many tracks there are */
1495         if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1496                 if (ret == -ENOMEDIUM)
1497                         tracks->error = CDS_NO_DISC;
1498                 else
1499                         tracks->error = CDS_NO_INFO;
1500                 return;
1501         }       
1502         /* check what type of tracks are on this disc */
1503         entry.cdte_format = CDROM_MSF;
1504         for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1505                 entry.cdte_track  = i;
1506                 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1507                         tracks->error=CDS_NO_INFO;
1508                         return;
1509                 }       
1510                 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1511                     if (entry.cdte_format == 0x10)
1512                         tracks->cdi++;
1513                     else if (entry.cdte_format == 0x20) 
1514                         tracks->xa++;
1515                     else
1516                         tracks->data++;
1517                 } else
1518                     tracks->audio++;
1519                 cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1520                        i, entry.cdte_format, entry.cdte_ctrl);
1521         }       
1522         cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n", 
1523                 header.cdth_trk1, tracks->audio, tracks->data, 
1524                 tracks->cdi, tracks->xa);
1525 }       
1526
1527 /* Requests to the low-level drivers will /always/ be done in the
1528    following format convention:
1529
1530    CDROM_LBA: all data-related requests.
1531    CDROM_MSF: all audio-related requests.
1532
1533    However, a low-level implementation is allowed to refuse this
1534    request, and return information in its own favorite format.
1535
1536    It doesn't make sense /at all/ to ask for a play_audio in LBA
1537    format, or ask for multi-session info in MSF format. However, for
1538    backward compatibility these format requests will be satisfied, but
1539    the requests to the low-level drivers will be sanitized in the more
1540    meaningful format indicated above.
1541  */
1542
1543 static
1544 void sanitize_format(union cdrom_addr *addr,
1545                      u_char * curr, u_char requested)
1546 {
1547         if (*curr == requested)
1548                 return;                 /* nothing to be done! */
1549         if (requested == CDROM_LBA) {
1550                 addr->lba = (int) addr->msf.frame +
1551                         75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
1552         } else {                        /* CDROM_MSF */
1553                 int lba = addr->lba;
1554                 addr->msf.frame = lba % 75;
1555                 lba /= 75;
1556                 lba += 2;
1557                 addr->msf.second = lba % 60;
1558                 addr->msf.minute = lba / 60;
1559         }
1560         *curr = requested;
1561 }
1562
1563 void init_cdrom_command(struct packet_command *cgc, void *buf, int len,
1564                         int type)
1565 {
1566         memset(cgc, 0, sizeof(struct packet_command));
1567         if (buf)
1568                 memset(buf, 0, len);
1569         cgc->buffer = (char *) buf;
1570         cgc->buflen = len;
1571         cgc->data_direction = type;
1572         cgc->timeout = CDROM_DEF_TIMEOUT;
1573 }
1574
1575 /* DVD handling */
1576
1577 #define copy_key(dest,src)      memcpy((dest), (src), sizeof(dvd_key))
1578 #define copy_chal(dest,src)     memcpy((dest), (src), sizeof(dvd_challenge))
1579
1580 static void setup_report_key(struct packet_command *cgc, unsigned agid, unsigned type)
1581 {
1582         cgc->cmd[0] = GPCMD_REPORT_KEY;
1583         cgc->cmd[10] = type | (agid << 6);
1584         switch (type) {
1585                 case 0: case 8: case 5: {
1586                         cgc->buflen = 8;
1587                         break;
1588                 }
1589                 case 1: {
1590                         cgc->buflen = 16;
1591                         break;
1592                 }
1593                 case 2: case 4: {
1594                         cgc->buflen = 12;
1595                         break;
1596                 }
1597         }
1598         cgc->cmd[9] = cgc->buflen;
1599         cgc->data_direction = CGC_DATA_READ;
1600 }
1601
1602 static void setup_send_key(struct packet_command *cgc, unsigned agid, unsigned type)
1603 {
1604         cgc->cmd[0] = GPCMD_SEND_KEY;
1605         cgc->cmd[10] = type | (agid << 6);
1606         switch (type) {
1607                 case 1: {
1608                         cgc->buflen = 16;
1609                         break;
1610                 }
1611                 case 3: {
1612                         cgc->buflen = 12;
1613                         break;
1614                 }
1615                 case 6: {
1616                         cgc->buflen = 8;
1617                         break;
1618                 }
1619         }
1620         cgc->cmd[9] = cgc->buflen;
1621         cgc->data_direction = CGC_DATA_WRITE;
1622 }
1623
1624 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1625 {
1626         int ret;
1627         u_char buf[20];
1628         struct packet_command cgc;
1629         struct cdrom_device_ops *cdo = cdi->ops;
1630         rpc_state_t rpc_state;
1631
1632         memset(buf, 0, sizeof(buf));
1633         init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1634
1635         switch (ai->type) {
1636         /* LU data send */
1637         case DVD_LU_SEND_AGID:
1638                 cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n"); 
1639                 cgc.quiet = 1;
1640                 setup_report_key(&cgc, ai->lsa.agid, 0);
1641
1642                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1643                         return ret;
1644
1645                 ai->lsa.agid = buf[7] >> 6;
1646                 /* Returning data, let host change state */
1647                 break;
1648
1649         case DVD_LU_SEND_KEY1:
1650                 cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n"); 
1651                 setup_report_key(&cgc, ai->lsk.agid, 2);
1652
1653                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1654                         return ret;
1655
1656                 copy_key(ai->lsk.key, &buf[4]);
1657                 /* Returning data, let host change state */
1658                 break;
1659
1660         case DVD_LU_SEND_CHALLENGE:
1661                 cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n"); 
1662                 setup_report_key(&cgc, ai->lsc.agid, 1);
1663
1664                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1665                         return ret;
1666
1667                 copy_chal(ai->lsc.chal, &buf[4]);
1668                 /* Returning data, let host change state */
1669                 break;
1670
1671         /* Post-auth key */
1672         case DVD_LU_SEND_TITLE_KEY:
1673                 cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n"); 
1674                 cgc.quiet = 1;
1675                 setup_report_key(&cgc, ai->lstk.agid, 4);
1676                 cgc.cmd[5] = ai->lstk.lba;
1677                 cgc.cmd[4] = ai->lstk.lba >> 8;
1678                 cgc.cmd[3] = ai->lstk.lba >> 16;
1679                 cgc.cmd[2] = ai->lstk.lba >> 24;
1680
1681                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1682                         return ret;
1683
1684                 ai->lstk.cpm = (buf[4] >> 7) & 1;
1685                 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1686                 ai->lstk.cgms = (buf[4] >> 4) & 3;
1687                 copy_key(ai->lstk.title_key, &buf[5]);
1688                 /* Returning data, let host change state */
1689                 break;
1690
1691         case DVD_LU_SEND_ASF:
1692                 cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n"); 
1693                 setup_report_key(&cgc, ai->lsasf.agid, 5);
1694                 
1695                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1696                         return ret;
1697
1698                 ai->lsasf.asf = buf[7] & 1;
1699                 break;
1700
1701         /* LU data receive (LU changes state) */
1702         case DVD_HOST_SEND_CHALLENGE:
1703                 cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n"); 
1704                 setup_send_key(&cgc, ai->hsc.agid, 1);
1705                 buf[1] = 0xe;
1706                 copy_chal(&buf[4], ai->hsc.chal);
1707
1708                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1709                         return ret;
1710
1711                 ai->type = DVD_LU_SEND_KEY1;
1712                 break;
1713
1714         case DVD_HOST_SEND_KEY2:
1715                 cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n"); 
1716                 setup_send_key(&cgc, ai->hsk.agid, 3);
1717                 buf[1] = 0xa;
1718                 copy_key(&buf[4], ai->hsk.key);
1719
1720                 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1721                         ai->type = DVD_AUTH_FAILURE;
1722                         return ret;
1723                 }
1724                 ai->type = DVD_AUTH_ESTABLISHED;
1725                 break;
1726
1727         /* Misc */
1728         case DVD_INVALIDATE_AGID:
1729                 cgc.quiet = 1;
1730                 cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n"); 
1731                 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1732                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1733                         return ret;
1734                 break;
1735
1736         /* Get region settings */
1737         case DVD_LU_SEND_RPC_STATE:
1738                 cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1739                 setup_report_key(&cgc, 0, 8);
1740                 memset(&rpc_state, 0, sizeof(rpc_state_t));
1741                 cgc.buffer = (char *) &rpc_state;
1742
1743                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1744                         return ret;
1745
1746                 ai->lrpcs.type = rpc_state.type_code;
1747                 ai->lrpcs.vra = rpc_state.vra;
1748                 ai->lrpcs.ucca = rpc_state.ucca;
1749                 ai->lrpcs.region_mask = rpc_state.region_mask;
1750                 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1751                 break;
1752
1753         /* Set region settings */
1754         case DVD_HOST_SEND_RPC_STATE:
1755                 cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1756                 setup_send_key(&cgc, 0, 6);
1757                 buf[1] = 6;
1758                 buf[4] = ai->hrpcs.pdrc;
1759
1760                 if ((ret = cdo->generic_packet(cdi, &cgc)))
1761                         return ret;
1762                 break;
1763
1764         default:
1765                 cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1766                 return -ENOTTY;
1767         }
1768
1769         return 0;
1770 }
1771
1772 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s,
1773                                 struct packet_command *cgc)
1774 {
1775         unsigned char buf[21], *base;
1776         struct dvd_layer *layer;
1777         struct cdrom_device_ops *cdo = cdi->ops;
1778         int ret, layer_num = s->physical.layer_num;
1779
1780         if (layer_num >= DVD_LAYERS)
1781                 return -EINVAL;
1782
1783         init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1784         cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1785         cgc->cmd[6] = layer_num;
1786         cgc->cmd[7] = s->type;
1787         cgc->cmd[9] = cgc->buflen & 0xff;
1788
1789         /*
1790          * refrain from reporting errors on non-existing layers (mainly)
1791          */
1792         cgc->quiet = 1;
1793
1794         ret = cdo->generic_packet(cdi, cgc);
1795         if (ret)
1796                 return ret;
1797
1798         base = &buf[4];
1799         layer = &s->physical.layer[layer_num];
1800
1801         /*
1802          * place the data... really ugly, but at least we won't have to
1803          * worry about endianess in userspace.
1804          */
1805         memset(layer, 0, sizeof(*layer));
1806         layer->book_version = base[0] & 0xf;
1807         layer->book_type = base[0] >> 4;
1808         layer->min_rate = base[1] & 0xf;
1809         layer->disc_size = base[1] >> 4;
1810         layer->layer_type = base[2] & 0xf;
1811         layer->track_path = (base[2] >> 4) & 1;
1812         layer->nlayers = (base[2] >> 5) & 3;
1813         layer->track_density = base[3] & 0xf;
1814         layer->linear_density = base[3] >> 4;
1815         layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1816         layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1817         layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1818         layer->bca = base[16] >> 7;
1819
1820         return 0;
1821 }
1822
1823 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s,
1824                                 struct packet_command *cgc)
1825 {
1826         int ret;
1827         u_char buf[8];
1828         struct cdrom_device_ops *cdo = cdi->ops;
1829
1830         init_cdrom_command(cgc, buf, sizeof(buf), CGC_DATA_READ);
1831         cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1832         cgc->cmd[6] = s->copyright.layer_num;
1833         cgc->cmd[7] = s->type;
1834         cgc->cmd[8] = cgc->buflen >> 8;
1835         cgc->cmd[9] = cgc->buflen & 0xff;
1836
1837         ret = cdo->generic_packet(cdi, cgc);
1838         if (ret)
1839                 return ret;
1840
1841         s->copyright.cpst = buf[4];
1842         s->copyright.rmi = buf[5];
1843
1844         return 0;
1845 }
1846
1847 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s,
1848                                 struct packet_command *cgc)
1849 {
1850         int ret, size;
1851         u_char *buf;
1852         struct cdrom_device_ops *cdo = cdi->ops;
1853
1854         size = sizeof(s->disckey.value) + 4;
1855
1856         buf = kmalloc(size, GFP_KERNEL);
1857         if (!buf)
1858                 return -ENOMEM;
1859
1860         init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1861         cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1862         cgc->cmd[7] = s->type;
1863         cgc->cmd[8] = size >> 8;
1864         cgc->cmd[9] = size & 0xff;
1865         cgc->cmd[10] = s->disckey.agid << 6;
1866
1867         ret = cdo->generic_packet(cdi, cgc);
1868         if (!ret)
1869                 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1870
1871         kfree(buf);
1872         return ret;
1873 }
1874
1875 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1876                         struct packet_command *cgc)
1877 {
1878         int ret, size = 4 + 188;
1879         u_char *buf;
1880         struct cdrom_device_ops *cdo = cdi->ops;
1881
1882         buf = kmalloc(size, GFP_KERNEL);
1883         if (!buf)
1884                 return -ENOMEM;
1885
1886         init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1887         cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1888         cgc->cmd[7] = s->type;
1889         cgc->cmd[9] = cgc->buflen & 0xff;
1890
1891         ret = cdo->generic_packet(cdi, cgc);
1892         if (ret)
1893                 goto out;
1894
1895         s->bca.len = buf[0] << 8 | buf[1];
1896         if (s->bca.len < 12 || s->bca.len > 188) {
1897                 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1898                 ret = -EIO;
1899                 goto out;
1900         }
1901         memcpy(s->bca.value, &buf[4], s->bca.len);
1902         ret = 0;
1903 out:
1904         kfree(buf);
1905         return ret;
1906 }
1907
1908 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1909                                 struct packet_command *cgc)
1910 {
1911         int ret = 0, size;
1912         u_char *buf;
1913         struct cdrom_device_ops *cdo = cdi->ops;
1914
1915         size = sizeof(s->manufact.value) + 4;
1916
1917         buf = kmalloc(size, GFP_KERNEL);
1918         if (!buf)
1919                 return -ENOMEM;
1920
1921         init_cdrom_command(cgc, buf, size, CGC_DATA_READ);
1922         cgc->cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1923         cgc->cmd[7] = s->type;
1924         cgc->cmd[8] = size >> 8;
1925         cgc->cmd[9] = size & 0xff;
1926
1927         ret = cdo->generic_packet(cdi, cgc);
1928         if (ret)
1929                 goto out;
1930
1931         s->manufact.len = buf[0] << 8 | buf[1];
1932         if (s->manufact.len < 0) {
1933                 cdinfo(CD_WARNING, "Received invalid manufacture info length"
1934                                    " (%d)\n", s->manufact.len);
1935                 ret = -EIO;
1936         } else {
1937                 if (s->manufact.len > 2048) {
1938                         cdinfo(CD_WARNING, "Received invalid manufacture info "
1939                                         "length (%d): truncating to 2048\n",
1940                                         s->manufact.len);
1941                         s->manufact.len = 2048;
1942                 }
1943                 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1944         }
1945
1946 out:
1947         kfree(buf);
1948         return ret;
1949 }
1950
1951 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1952                                 struct packet_command *cgc)
1953 {
1954         switch (s->type) {
1955         case DVD_STRUCT_PHYSICAL:
1956                 return dvd_read_physical(cdi, s, cgc);
1957
1958         case DVD_STRUCT_COPYRIGHT:
1959                 return dvd_read_copyright(cdi, s, cgc);
1960
1961         case DVD_STRUCT_DISCKEY:
1962                 return dvd_read_disckey(cdi, s, cgc);
1963
1964         case DVD_STRUCT_BCA:
1965                 return dvd_read_bca(cdi, s, cgc);
1966
1967         case DVD_STRUCT_MANUFACT:
1968                 return dvd_read_manufact(cdi, s, cgc);
1969                 
1970         default:
1971                 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1972                                         s->type);
1973                 return -EINVAL;
1974         }
1975 }
1976
1977 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1978                      struct packet_command *cgc,
1979                      int page_code, int page_control)
1980 {
1981         struct cdrom_device_ops *cdo = cdi->ops;
1982
1983         memset(cgc->cmd, 0, sizeof(cgc->cmd));
1984
1985         cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1986         cgc->cmd[2] = page_code | (page_control << 6);
1987         cgc->cmd[7] = cgc->buflen >> 8;
1988         cgc->cmd[8] = cgc->buflen & 0xff;
1989         cgc->data_direction = CGC_DATA_READ;
1990         return cdo->generic_packet(cdi, cgc);
1991 }
1992
1993 int cdrom_mode_select(struct cdrom_device_info *cdi,
1994                       struct packet_command *cgc)
1995 {
1996         struct cdrom_device_ops *cdo = cdi->ops;
1997
1998         memset(cgc->cmd, 0, sizeof(cgc->cmd));
1999         memset(cgc->buffer, 0, 2);
2000         cgc->cmd[0] = GPCMD_MODE_SELECT_10;
2001         cgc->cmd[1] = 0x10;             /* PF */
2002         cgc->cmd[7] = cgc->buflen >> 8;
2003         cgc->cmd[8] = cgc->buflen & 0xff;
2004         cgc->data_direction = CGC_DATA_WRITE;
2005         return cdo->generic_packet(cdi, cgc);
2006 }
2007
2008 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
2009                                  struct cdrom_subchnl *subchnl, int mcn)
2010 {
2011         struct cdrom_device_ops *cdo = cdi->ops;
2012         struct packet_command cgc;
2013         char buffer[32];
2014         int ret;
2015
2016         init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
2017         cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
2018         cgc.cmd[1] = 2;     /* MSF addressing */
2019         cgc.cmd[2] = 0x40;  /* request subQ data */
2020         cgc.cmd[3] = mcn ? 2 : 1;
2021         cgc.cmd[8] = 16;
2022
2023         if ((ret = cdo->generic_packet(cdi, &cgc)))
2024                 return ret;
2025
2026         subchnl->cdsc_audiostatus = cgc.buffer[1];
2027         subchnl->cdsc_format = CDROM_MSF;
2028         subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
2029         subchnl->cdsc_trk = cgc.buffer[6];
2030         subchnl->cdsc_ind = cgc.buffer[7];
2031
2032         subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
2033         subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
2034         subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
2035         subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
2036         subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
2037         subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
2038
2039         return 0;
2040 }
2041
2042 /*
2043  * Specific READ_10 interface
2044  */
2045 static int cdrom_read_cd(struct cdrom_device_info *cdi,
2046                          struct packet_command *cgc, int lba,
2047                          int blocksize, int nblocks)
2048 {
2049         struct cdrom_device_ops *cdo = cdi->ops;
2050
2051         memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2052         cgc->cmd[0] = GPCMD_READ_10;
2053         cgc->cmd[2] = (lba >> 24) & 0xff;
2054         cgc->cmd[3] = (lba >> 16) & 0xff;
2055         cgc->cmd[4] = (lba >>  8) & 0xff;
2056         cgc->cmd[5] = lba & 0xff;
2057         cgc->cmd[6] = (nblocks >> 16) & 0xff;
2058         cgc->cmd[7] = (nblocks >>  8) & 0xff;
2059         cgc->cmd[8] = nblocks & 0xff;
2060         cgc->buflen = blocksize * nblocks;
2061         return cdo->generic_packet(cdi, cgc);
2062 }
2063
2064 /* very generic interface for reading the various types of blocks */
2065 static int cdrom_read_block(struct cdrom_device_info *cdi,
2066                             struct packet_command *cgc,
2067                             int lba, int nblocks, int format, int blksize)
2068 {
2069         struct cdrom_device_ops *cdo = cdi->ops;
2070
2071         memset(&cgc->cmd, 0, sizeof(cgc->cmd));
2072         cgc->cmd[0] = GPCMD_READ_CD;
2073         /* expected sector size - cdda,mode1,etc. */
2074         cgc->cmd[1] = format << 2;
2075         /* starting address */
2076         cgc->cmd[2] = (lba >> 24) & 0xff;
2077         cgc->cmd[3] = (lba >> 16) & 0xff;
2078         cgc->cmd[4] = (lba >>  8) & 0xff;
2079         cgc->cmd[5] = lba & 0xff;
2080         /* number of blocks */
2081         cgc->cmd[6] = (nblocks >> 16) & 0xff;
2082         cgc->cmd[7] = (nblocks >>  8) & 0xff;
2083         cgc->cmd[8] = nblocks & 0xff;
2084         cgc->buflen = blksize * nblocks;
2085         
2086         /* set the header info returned */
2087         switch (blksize) {
2088         case CD_FRAMESIZE_RAW0  : cgc->cmd[9] = 0x58; break;
2089         case CD_FRAMESIZE_RAW1  : cgc->cmd[9] = 0x78; break;
2090         case CD_FRAMESIZE_RAW   : cgc->cmd[9] = 0xf8; break;
2091         default                 : cgc->cmd[9] = 0x10;
2092         }
2093         
2094         return cdo->generic_packet(cdi, cgc);
2095 }
2096
2097 static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2098                                int lba, int nframes)
2099 {
2100         struct packet_command cgc;
2101         int ret = 0;
2102         int nr;
2103
2104         cdi->last_sense = 0;
2105
2106         memset(&cgc, 0, sizeof(cgc));
2107
2108         /*
2109          * start with will ra.nframes size, back down if alloc fails
2110          */
2111         nr = nframes;
2112         do {
2113                 cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL);
2114                 if (cgc.buffer)
2115                         break;
2116
2117                 nr >>= 1;
2118         } while (nr);
2119
2120         if (!nr)
2121                 return -ENOMEM;
2122
2123         cgc.data_direction = CGC_DATA_READ;
2124         while (nframes > 0) {
2125                 if (nr > nframes)
2126                         nr = nframes;
2127
2128                 ret = cdrom_read_block(cdi, &cgc, lba, nr, 1, CD_FRAMESIZE_RAW);
2129                 if (ret)
2130                         break;
2131                 if (copy_to_user(ubuf, cgc.buffer, CD_FRAMESIZE_RAW * nr)) {
2132                         ret = -EFAULT;
2133                         break;
2134                 }
2135                 ubuf += CD_FRAMESIZE_RAW * nr;
2136                 nframes -= nr;
2137                 lba += nr;
2138         }
2139         kfree(cgc.buffer);
2140         return ret;
2141 }
2142
2143 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2144                                int lba, int nframes)
2145 {
2146         struct request_queue *q = cdi->disk->queue;
2147         struct request *rq;
2148         struct bio *bio;
2149         unsigned int len;
2150         int nr, ret = 0;
2151
2152         if (!q)
2153                 return -ENXIO;
2154
2155         cdi->last_sense = 0;
2156
2157         while (nframes) {
2158                 nr = nframes;
2159                 if (cdi->cdda_method == CDDA_BPC_SINGLE)
2160                         nr = 1;
2161                 if (nr * CD_FRAMESIZE_RAW > (queue_max_sectors(q) << 9))
2162                         nr = (queue_max_sectors(q) << 9) / CD_FRAMESIZE_RAW;
2163
2164                 len = nr * CD_FRAMESIZE_RAW;
2165
2166                 rq = blk_get_request(q, READ, GFP_KERNEL);
2167                 if (!rq) {
2168                         ret = -ENOMEM;
2169                         break;
2170                 }
2171
2172                 ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL);
2173                 if (ret) {
2174                         blk_put_request(rq);
2175                         break;
2176                 }
2177
2178                 rq->cmd[0] = GPCMD_READ_CD;
2179                 rq->cmd[1] = 1 << 2;
2180                 rq->cmd[2] = (lba >> 24) & 0xff;
2181                 rq->cmd[3] = (lba >> 16) & 0xff;
2182                 rq->cmd[4] = (lba >>  8) & 0xff;
2183                 rq->cmd[5] = lba & 0xff;
2184                 rq->cmd[6] = (nr >> 16) & 0xff;
2185                 rq->cmd[7] = (nr >>  8) & 0xff;
2186                 rq->cmd[8] = nr & 0xff;
2187                 rq->cmd[9] = 0xf8;
2188
2189                 rq->cmd_len = 12;
2190                 rq->cmd_type = REQ_TYPE_BLOCK_PC;
2191                 rq->timeout = 60 * HZ;
2192                 bio = rq->bio;
2193
2194                 if (blk_execute_rq(q, cdi->disk, rq, 0)) {
2195                         struct request_sense *s = rq->sense;
2196                         ret = -EIO;
2197                         cdi->last_sense = s->sense_key;
2198                 }
2199
2200                 if (blk_rq_unmap_user(bio))
2201                         ret = -EFAULT;
2202                 blk_put_request(rq);
2203
2204                 if (ret)
2205                         break;
2206
2207                 nframes -= nr;
2208                 lba += nr;
2209                 ubuf += len;
2210         }
2211
2212         return ret;
2213 }
2214
2215 static int cdrom_read_cdda(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2216                            int lba, int nframes)
2217 {
2218         int ret;
2219
2220         if (cdi->cdda_method == CDDA_OLD)
2221                 return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);
2222
2223 retry:
2224         /*
2225          * for anything else than success and io error, we need to retry
2226          */
2227         ret = cdrom_read_cdda_bpc(cdi, ubuf, lba, nframes);
2228         if (!ret || ret != -EIO)
2229                 return ret;
2230
2231         /*
2232          * I've seen drives get sense 4/8/3 udma crc errors on multi
2233          * frame dma, so drop to single frame dma if we need to
2234          */
2235         if (cdi->cdda_method == CDDA_BPC_FULL && nframes > 1) {
2236                 pr_info("dropping to single frame dma\n");
2237                 cdi->cdda_method = CDDA_BPC_SINGLE;
2238                 goto retry;
2239         }
2240
2241         /*
2242          * so we have an io error of some sort with multi frame dma. if the
2243          * condition wasn't a hardware error
2244          * problems, not for any error
2245          */
2246         if (cdi->last_sense != 0x04 && cdi->last_sense != 0x0b)
2247                 return ret;
2248
2249         pr_info("dropping to old style cdda (sense=%x)\n", cdi->last_sense);
2250         cdi->cdda_method = CDDA_OLD;
2251         return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);    
2252 }
2253
2254 static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2255                 void __user *argp)
2256 {
2257         struct cdrom_multisession ms_info;
2258         u8 requested_format;
2259         int ret;
2260
2261         cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2262
2263         if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2264                 return -ENOSYS;
2265
2266         if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
2267                 return -EFAULT;
2268
2269         requested_format = ms_info.addr_format;
2270         if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2271                 return -EINVAL;
2272         ms_info.addr_format = CDROM_LBA;
2273
2274         ret = cdi->ops->get_last_session(cdi, &ms_info);
2275         if (ret)
2276                 return ret;
2277
2278         sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
2279
2280         if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2281                 return -EFAULT;
2282
2283         cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2284         return 0;
2285 }
2286
2287 static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2288 {
2289         cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
2290
2291         if (!CDROM_CAN(CDC_OPEN_TRAY))
2292                 return -ENOSYS;
2293         if (cdi->use_count != 1 || keeplocked)
2294                 return -EBUSY;
2295         if (CDROM_CAN(CDC_LOCK)) {
2296                 int ret = cdi->ops->lock_door(cdi, 0);
2297                 if (ret)
2298                         return ret;
2299         }
2300
2301         return cdi->ops->tray_move(cdi, 1);
2302 }
2303
2304 static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2305 {
2306         cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2307
2308         if (!CDROM_CAN(CDC_CLOSE_TRAY))
2309                 return -ENOSYS;
2310         return cdi->ops->tray_move(cdi, 0);
2311 }
2312
2313 static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2314                 unsigned long arg)
2315 {
2316         cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2317
2318         if (!CDROM_CAN(CDC_OPEN_TRAY))
2319                 return -ENOSYS;
2320         if (keeplocked)
2321                 return -EBUSY;
2322
2323         cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
2324         if (arg)
2325                 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
2326         return 0;
2327 }
2328
2329 static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2330                 unsigned long arg)
2331 {
2332         struct cdrom_changer_info *info;
2333         int ret;
2334
2335         cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2336
2337         if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2338                 return -ENOSYS;
2339
2340         /* cannot select disc or select current disc */
2341         if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
2342                 return media_changed(cdi, 1);
2343
2344         if ((unsigned int)arg >= cdi->capacity)
2345                 return -EINVAL;
2346
2347         info = kmalloc(sizeof(*info), GFP_KERNEL);
2348         if (!info)
2349                 return -ENOMEM;
2350
2351         ret = cdrom_read_mech_status(cdi, info);
2352         if (!ret)
2353                 ret = info->slots[arg].change;
2354         kfree(info);
2355         return ret;
2356 }
2357
2358 static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2359                 unsigned long arg)
2360 {
2361         cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2362
2363         /*
2364          * Options need to be in sync with capability.
2365          * Too late for that, so we have to check each one separately.
2366          */
2367         switch (arg) {
2368         case CDO_USE_FFLAGS:
2369         case CDO_CHECK_TYPE:
2370                 break;
2371         case CDO_LOCK:
2372                 if (!CDROM_CAN(CDC_LOCK))
2373                         return -ENOSYS;
2374                 break;
2375         case 0:
2376                 return cdi->options;
2377         /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
2378         default:
2379                 if (!CDROM_CAN(arg))
2380                         return -ENOSYS;
2381         }
2382         cdi->options |= (int) arg;
2383         return cdi->options;
2384 }
2385
2386 static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2387                 unsigned long arg)
2388 {
2389         cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2390
2391         cdi->options &= ~(int) arg;
2392         return cdi->options;
2393 }
2394
2395 static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2396                 unsigned long arg)
2397 {
2398         cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2399
2400         if (!CDROM_CAN(CDC_SELECT_SPEED))
2401                 return -ENOSYS;
2402         return cdi->ops->select_speed(cdi, arg);
2403 }
2404
2405 static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2406                 unsigned long arg)
2407 {
2408         cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2409
2410         if (!CDROM_CAN(CDC_SELECT_DISC))
2411                 return -ENOSYS;
2412
2413         if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
2414                 if ((int)arg >= cdi->capacity)
2415                         return -EINVAL;
2416         }
2417
2418         /*
2419          * ->select_disc is a hook to allow a driver-specific way of
2420          * seleting disc.  However, since there is no equivalent hook for
2421          * cdrom_slot_status this may not actually be useful...
2422          */
2423         if (cdi->ops->select_disc)
2424                 return cdi->ops->select_disc(cdi, arg);
2425
2426         cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2427         return cdrom_select_disc(cdi, arg);
2428 }
2429
2430 static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2431                 struct block_device *bdev)
2432 {
2433         cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
2434
2435         if (!capable(CAP_SYS_ADMIN))
2436                 return -EACCES;
2437         if (!CDROM_CAN(CDC_RESET))
2438                 return -ENOSYS;
2439         invalidate_bdev(bdev);
2440         return cdi->ops->reset(cdi);
2441 }
2442
2443 static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2444                 unsigned long arg)
2445 {
2446         cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
2447
2448         if (!CDROM_CAN(CDC_LOCK))
2449                 return -EDRIVE_CANT_DO_THIS;
2450
2451         keeplocked = arg ? 1 : 0;
2452
2453         /*
2454          * Don't unlock the door on multiple opens by default, but allow
2455          * root to do so.
2456          */
2457         if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
2458                 return -EBUSY;
2459         return cdi->ops->lock_door(cdi, arg);
2460 }
2461
2462 static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2463                 unsigned long arg)
2464 {
2465         cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
2466
2467         if (!capable(CAP_SYS_ADMIN))
2468                 return -EACCES;
2469         debug = arg ? 1 : 0;
2470         return debug;
2471 }
2472
2473 static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2474 {
2475         cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2476         return (cdi->ops->capability & ~cdi->mask);
2477 }
2478
2479 /*
2480  * The following function is implemented, although very few audio
2481  * discs give Universal Product Code information, which should just be
2482  * the Medium Catalog Number on the box.  Note, that the way the code
2483  * is written on the CD is /not/ uniform across all discs!
2484  */
2485 static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2486                 void __user *argp)
2487 {
2488         struct cdrom_mcn mcn;
2489         int ret;
2490
2491         cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2492
2493         if (!(cdi->ops->capability & CDC_MCN))
2494                 return -ENOSYS;
2495         ret = cdi->ops->get_mcn(cdi, &mcn);
2496         if (ret)
2497                 return ret;
2498
2499         if (copy_to_user(argp, &mcn, sizeof(mcn)))
2500                 return -EFAULT;
2501         cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2502         return 0;
2503 }
2504
2505 static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2506                 unsigned long arg)
2507 {
2508         cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2509
2510         if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2511                 return -ENOSYS;
2512         if (!CDROM_CAN(CDC_SELECT_DISC) ||
2513             (arg == CDSL_CURRENT || arg == CDSL_NONE))
2514                 return cdi->ops->drive_status(cdi, CDSL_CURRENT);
2515         if (((int)arg >= cdi->capacity))
2516                 return -EINVAL;
2517         return cdrom_slot_status(cdi, arg);
2518 }
2519
2520 /*
2521  * Ok, this is where problems start.  The current interface for the
2522  * CDROM_DISC_STATUS ioctl is flawed.  It makes the false assumption that
2523  * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc.  Unfortunately, while this
2524  * is often the case, it is also very common for CDs to have some tracks
2525  * with data, and some tracks with audio.  Just because I feel like it,
2526  * I declare the following to be the best way to cope.  If the CD has ANY
2527  * data tracks on it, it will be returned as a data CD.  If it has any XA
2528  * tracks, I will return it as that.  Now I could simplify this interface
2529  * by combining these  returns with the above, but this more clearly
2530  * demonstrates the problem with the current interface.  Too bad this
2531  * wasn't designed to use bitmasks...         -Erik
2532  *
2533  * Well, now we have the option CDS_MIXED: a mixed-type CD.
2534  * User level programmers might feel the ioctl is not very useful.
2535  *                                      ---david
2536  */
2537 static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2538 {
2539         tracktype tracks;
2540
2541         cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2542
2543         cdrom_count_tracks(cdi, &tracks);
2544         if (tracks.error)
2545                 return tracks.error;
2546
2547         /* Policy mode on */
2548         if (tracks.audio > 0) {
2549                 if (!tracks.data && !tracks.cdi && !tracks.xa)
2550                         return CDS_AUDIO;
2551                 else
2552                         return CDS_MIXED;
2553         }
2554
2555         if (tracks.cdi > 0)
2556                 return CDS_XA_2_2;
2557         if (tracks.xa > 0)
2558                 return CDS_XA_2_1;
2559         if (tracks.data > 0)
2560                 return CDS_DATA_1;
2561         /* Policy mode off */
2562
2563         cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
2564         return CDS_NO_INFO;
2565 }
2566
2567 static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2568 {
2569         cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2570         return cdi->capacity;
2571 }
2572
2573 static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2574                 void __user *argp)
2575 {
2576         struct cdrom_subchnl q;
2577         u8 requested, back;
2578         int ret;
2579
2580         /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2581
2582         if (copy_from_user(&q, argp, sizeof(q)))
2583                 return -EFAULT;
2584
2585         requested = q.cdsc_format;
2586         if (requested != CDROM_MSF && requested != CDROM_LBA)
2587                 return -EINVAL;
2588         q.cdsc_format = CDROM_MSF;
2589
2590         ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
2591         if (ret)
2592                 return ret;
2593
2594         back = q.cdsc_format; /* local copy */
2595         sanitize_format(&q.cdsc_absaddr, &back, requested);
2596         sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2597
2598         if (copy_to_user(argp, &q, sizeof(q)))
2599                 return -EFAULT;
2600         /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2601         return 0;
2602 }
2603
2604 static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2605                 void __user *argp)
2606 {
2607         struct cdrom_tochdr header;
2608         int ret;
2609
2610         /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2611
2612         if (copy_from_user(&header, argp, sizeof(header)))
2613                 return -EFAULT;
2614
2615         ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
2616         if (ret)
2617                 return ret;
2618
2619         if (copy_to_user(argp, &header, sizeof(header)))
2620                 return -EFAULT;
2621         /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2622         return 0;
2623 }
2624
2625 static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2626                 void __user *argp)
2627 {
2628         struct cdrom_tocentry entry;
2629         u8 requested_format;
2630         int ret;
2631
2632         /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2633
2634         if (copy_from_user(&entry, argp, sizeof(entry)))
2635                 return -EFAULT;
2636
2637         requested_format = entry.cdte_format;
2638         if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
2639                 return -EINVAL;
2640         /* make interface to low-level uniform */
2641         entry.cdte_format = CDROM_MSF;
2642         ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
2643         if (ret)
2644                 return ret;
2645         sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
2646
2647         if (copy_to_user(argp, &entry, sizeof(entry)))
2648                 return -EFAULT;
2649         /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2650         return 0;
2651 }
2652
2653 static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2654                 void __user *argp)
2655 {
2656         struct cdrom_msf msf;
2657
2658         cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2659
2660         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2661                 return -ENOSYS;
2662         if (copy_from_user(&msf, argp, sizeof(msf)))
2663                 return -EFAULT;
2664         return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
2665 }
2666
2667 static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2668                 void __user *argp)
2669 {
2670         struct cdrom_ti ti;
2671         int ret;
2672
2673         cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2674
2675         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2676                 return -ENOSYS;
2677         if (copy_from_user(&ti, argp, sizeof(ti)))
2678                 return -EFAULT;
2679
2680         ret = check_for_audio_disc(cdi, cdi->ops);
2681         if (ret)
2682                 return ret;
2683         return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
2684 }
2685 static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2686                 void __user *argp)
2687 {
2688         struct cdrom_volctrl volume;
2689
2690         cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2691
2692         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2693                 return -ENOSYS;
2694         if (copy_from_user(&volume, argp, sizeof(volume)))
2695                 return -EFAULT;
2696         return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
2697 }
2698
2699 static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2700                 void __user *argp)
2701 {
2702         struct cdrom_volctrl volume;
2703         int ret;
2704
2705         cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2706
2707         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2708                 return -ENOSYS;
2709
2710         ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
2711         if (ret)
2712                 return ret;
2713
2714         if (copy_to_user(argp, &volume, sizeof(volume)))
2715                 return -EFAULT;
2716         return 0;
2717 }
2718
2719 static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2720                 unsigned int cmd)
2721 {
2722         int ret;
2723
2724         cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2725
2726         if (!CDROM_CAN(CDC_PLAY_AUDIO))
2727                 return -ENOSYS;
2728         ret = check_for_audio_disc(cdi, cdi->ops);
2729         if (ret)
2730                 return ret;
2731         return cdi->ops->audio_ioctl(cdi, cmd, NULL);
2732 }
2733
2734 /*
2735  * Just about every imaginable ioctl is supported in the Uniform layer
2736  * these days.
2737  * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2738  */
2739 int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
2740                 fmode_t mode, unsigned int cmd, unsigned long arg)
2741 {
2742         void __user *argp = (void __user *)arg;
2743         int ret;
2744
2745         /*
2746          * Try the generic SCSI command ioctl's first.
2747          */
2748         ret = scsi_cmd_blk_ioctl(bdev, mode, cmd, argp);
2749         if (ret != -ENOTTY)
2750                 return ret;
2751
2752         switch (cmd) {
2753         case CDROMMULTISESSION:
2754                 return cdrom_ioctl_multisession(cdi, argp);
2755         case CDROMEJECT:
2756                 return cdrom_ioctl_eject(cdi);
2757         case CDROMCLOSETRAY:
2758                 return cdrom_ioctl_closetray(cdi);
2759         case CDROMEJECT_SW:
2760                 return cdrom_ioctl_eject_sw(cdi, arg);
2761         case CDROM_MEDIA_CHANGED:
2762                 return cdrom_ioctl_media_changed(cdi, arg);
2763         case CDROM_SET_OPTIONS:
2764                 return cdrom_ioctl_set_options(cdi, arg);
2765         case CDROM_CLEAR_OPTIONS:
2766                 return cdrom_ioctl_clear_options(cdi, arg);
2767         case CDROM_SELECT_SPEED:
2768                 return cdrom_ioctl_select_speed(cdi, arg);
2769         case CDROM_SELECT_DISC:
2770                 return cdrom_ioctl_select_disc(cdi, arg);
2771         case CDROMRESET:
2772                 return cdrom_ioctl_reset(cdi, bdev);
2773         case CDROM_LOCKDOOR:
2774                 return cdrom_ioctl_lock_door(cdi, arg);
2775         case CDROM_DEBUG:
2776                 return cdrom_ioctl_debug(cdi, arg);
2777         case CDROM_GET_CAPABILITY:
2778                 return cdrom_ioctl_get_capability(cdi);
2779         case CDROM_GET_MCN:
2780                 return cdrom_ioctl_get_mcn(cdi, argp);
2781         case CDROM_DRIVE_STATUS:
2782                 return cdrom_ioctl_drive_status(cdi, arg);
2783         case CDROM_DISC_STATUS:
2784                 return cdrom_ioctl_disc_status(cdi);
2785         case CDROM_CHANGER_NSLOTS:
2786                 return cdrom_ioctl_changer_nslots(cdi);
2787         }
2788
2789         /*
2790          * Use the ioctls that are implemented through the generic_packet()
2791          * interface. this may look at bit funny, but if -ENOTTY is
2792          * returned that particular ioctl is not implemented and we
2793          * let it go through the device specific ones.
2794          */
2795         if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2796                 ret = mmc_ioctl(cdi, cmd, arg);
2797                 if (ret != -ENOTTY)
2798                         return ret;
2799         }
2800
2801         /*
2802          * Note: most of the cdinfo() calls are commented out here,
2803          * because they fill up the sys log when CD players poll
2804          * the drive.
2805          */
2806         switch (cmd) {
2807         case CDROMSUBCHNL:
2808                 return cdrom_ioctl_get_subchnl(cdi, argp);
2809         case CDROMREADTOCHDR:
2810                 return cdrom_ioctl_read_tochdr(cdi, argp);
2811         case CDROMREADTOCENTRY:
2812                 return cdrom_ioctl_read_tocentry(cdi, argp);
2813         case CDROMPLAYMSF:
2814                 return cdrom_ioctl_play_msf(cdi, argp);
2815         case CDROMPLAYTRKIND:
2816                 return cdrom_ioctl_play_trkind(cdi, argp);
2817         case CDROMVOLCTRL:
2818                 return cdrom_ioctl_volctrl(cdi, argp);
2819         case CDROMVOLREAD:
2820                 return cdrom_ioctl_volread(cdi, argp);
2821         case CDROMSTART:
2822         case CDROMSTOP:
2823         case CDROMPAUSE:
2824         case CDROMRESUME:
2825                 return cdrom_ioctl_audioctl(cdi, cmd);
2826         }
2827
2828         return -ENOSYS;
2829 }
2830
2831 /*
2832  * Required when we need to use READ_10 to issue other than 2048 block
2833  * reads
2834  */
2835 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2836 {
2837         struct cdrom_device_ops *cdo = cdi->ops;
2838         struct packet_command cgc;
2839         struct modesel_head mh;
2840
2841         memset(&mh, 0, sizeof(mh));
2842         mh.block_desc_length = 0x08;
2843         mh.block_length_med = (size >> 8) & 0xff;
2844         mh.block_length_lo = size & 0xff;
2845
2846         memset(&cgc, 0, sizeof(cgc));
2847         cgc.cmd[0] = 0x15;
2848         cgc.cmd[1] = 1 << 4;
2849         cgc.cmd[4] = 12;
2850         cgc.buflen = sizeof(mh);
2851         cgc.buffer = (char *) &mh;
2852         cgc.data_direction = CGC_DATA_WRITE;
2853         mh.block_desc_length = 0x08;
2854         mh.block_length_med = (size >> 8) & 0xff;
2855         mh.block_length_lo = size & 0xff;
2856
2857         return cdo->generic_packet(cdi, &cgc);
2858 }
2859
2860 static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2861                                         void __user *arg,
2862                                         struct packet_command *cgc,
2863                                         int cmd)
2864 {
2865         struct request_sense sense;
2866         struct cdrom_msf msf;
2867         int blocksize = 0, format = 0, lba;
2868         int ret;
2869
2870         switch (cmd) {
2871         case CDROMREADRAW:
2872                 blocksize = CD_FRAMESIZE_RAW;
2873                 break;
2874         case CDROMREADMODE1:
2875                 blocksize = CD_FRAMESIZE;
2876                 format = 2;
2877                 break;
2878         case CDROMREADMODE2:
2879                 blocksize = CD_FRAMESIZE_RAW0;
2880                 break;
2881         }
2882         IOCTL_IN(arg, struct cdrom_msf, msf);
2883         lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2884         /* FIXME: we need upper bound checking, too!! */
2885         if (lba < 0)
2886                 return -EINVAL;
2887
2888         cgc->buffer = kmalloc(blocksize, GFP_KERNEL);
2889         if (cgc->buffer == NULL)
2890                 return -ENOMEM;
2891
2892         memset(&sense, 0, sizeof(sense));
2893         cgc->sense = &sense;
2894         cgc->data_direction = CGC_DATA_READ;
2895         ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
2896         if (ret && sense.sense_key == 0x05 &&
2897                    sense.asc == 0x20 &&
2898                    sense.ascq == 0x00) {
2899                 /*
2900                  * SCSI-II devices are not required to support
2901                  * READ_CD, so let's try switching block size
2902                  */
2903                 /* FIXME: switch back again... */
2904                 ret = cdrom_switch_blocksize(cdi, blocksize);
2905                 if (ret)
2906                         goto out;
2907                 cgc->sense = NULL;
2908                 ret = cdrom_read_cd(cdi, cgc, lba, blocksize, 1);
2909                 ret |= cdrom_switch_blocksize(cdi, blocksize);
2910         }
2911         if (!ret && copy_to_user(arg, cgc->buffer, blocksize))
2912                 ret = -EFAULT;
2913 out:
2914         kfree(cgc->buffer);
2915         return ret;
2916 }
2917
2918 static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
2919                                         void __user *arg)
2920 {
2921         struct cdrom_read_audio ra;
2922         int lba;
2923
2924         IOCTL_IN(arg, struct cdrom_read_audio, ra);
2925
2926         if (ra.addr_format == CDROM_MSF)
2927                 lba = msf_to_lba(ra.addr.msf.minute,
2928                                  ra.addr.msf.second,
2929                                  ra.addr.msf.frame);
2930         else if (ra.addr_format == CDROM_LBA)
2931                 lba = ra.addr.lba;
2932         else
2933                 return -EINVAL;
2934
2935         /* FIXME: we need upper bound checking, too!! */
2936         if (lba < 0 || ra.nframes <= 0 || ra.nframes > CD_FRAMES)
2937                 return -EINVAL;
2938
2939         return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes);
2940 }
2941
2942 static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
2943                                         void __user *arg)
2944 {
2945         int ret;
2946         struct cdrom_subchnl q;
2947         u_char requested, back;
2948         IOCTL_IN(arg, struct cdrom_subchnl, q);
2949         requested = q.cdsc_format;
2950         if (!((requested == CDROM_MSF) ||
2951               (requested == CDROM_LBA)))
2952                 return -EINVAL;
2953         q.cdsc_format = CDROM_MSF;
2954         ret = cdrom_read_subchannel(cdi, &q, 0);
2955         if (ret)
2956                 return ret;
2957         back = q.cdsc_format; /* local copy */
2958         sanitize_format(&q.cdsc_absaddr, &back, requested);
2959         sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2960         IOCTL_OUT(arg, struct cdrom_subchnl, q);
2961         /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2962         return 0;
2963 }
2964
2965 static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
2966                                         void __user *arg,
2967                                         struct packet_command *cgc)
2968 {
2969         struct cdrom_device_ops *cdo = cdi->ops;
2970         struct cdrom_msf msf;
2971         cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2972         IOCTL_IN(arg, struct cdrom_msf, msf);
2973         cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2974         cgc->cmd[3] = msf.cdmsf_min0;
2975         cgc->cmd[4] = msf.cdmsf_sec0;
2976         cgc->cmd[5] = msf.cdmsf_frame0;
2977         cgc->cmd[6] = msf.cdmsf_min1;
2978         cgc->cmd[7] = msf.cdmsf_sec1;
2979         cgc->cmd[8] = msf.cdmsf_frame1;
2980         cgc->data_direction = CGC_DATA_NONE;
2981         return cdo->generic_packet(cdi, cgc);
2982 }
2983
2984 static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
2985                                         void __user *arg,
2986                                         struct packet_command *cgc)
2987 {
2988         struct cdrom_device_ops *cdo = cdi->ops;
2989         struct cdrom_blk blk;
2990         cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2991         IOCTL_IN(arg, struct cdrom_blk, blk);
2992         cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
2993         cgc->cmd[2] = (blk.from >> 24) & 0xff;
2994         cgc->cmd[3] = (blk.from >> 16) & 0xff;
2995         cgc->cmd[4] = (blk.from >>  8) & 0xff;
2996         cgc->cmd[5] = blk.from & 0xff;
2997         cgc->cmd[7] = (blk.len >> 8) & 0xff;
2998         cgc->cmd[8] = blk.len & 0xff;
2999         cgc->data_direction = CGC_DATA_NONE;
3000         return cdo->generic_packet(cdi, cgc);
3001 }
3002
3003 static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3004                                         void __user *arg,
3005                                         struct packet_command *cgc,
3006                                         unsigned int cmd)
3007 {
3008         struct cdrom_volctrl volctrl;
3009         unsigned char buffer[32];
3010         char mask[sizeof(buffer)];
3011         unsigned short offset;
3012         int ret;
3013
3014         cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3015
3016         IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
3017
3018         cgc->buffer = buffer;
3019         cgc->buflen = 24;
3020         ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 0);
3021         if (ret)
3022                 return ret;
3023                 
3024         /* originally the code depended on buffer[1] to determine
3025            how much data is available for transfer. buffer[1] is
3026            unfortunately ambigious and the only reliable way seem
3027            to be to simply skip over the block descriptor... */
3028         offset = 8 + be16_to_cpu(*(__be16 *)(buffer + 6));
3029
3030         if (offset + 16 > sizeof(buffer))
3031                 return -E2BIG;
3032
3033         if (offset + 16 > cgc->buflen) {
3034                 cgc->buflen = offset + 16;
3035                 ret = cdrom_mode_sense(cdi, cgc,
3036                                         GPMODE_AUDIO_CTL_PAGE, 0);
3037                 if (ret)
3038                         return ret;
3039         }
3040
3041         /* sanity check */
3042         if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3043                         buffer[offset + 1] < 14)
3044                 return -EINVAL;
3045
3046         /* now we have the current volume settings. if it was only
3047            a CDROMVOLREAD, return these values */
3048         if (cmd == CDROMVOLREAD) {
3049                 volctrl.channel0 = buffer[offset+9];
3050                 volctrl.channel1 = buffer[offset+11];
3051                 volctrl.channel2 = buffer[offset+13];
3052                 volctrl.channel3 = buffer[offset+15];
3053                 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
3054                 return 0;
3055         }
3056                 
3057         /* get the volume mask */
3058         cgc->buffer = mask;
3059         ret = cdrom_mode_sense(cdi, cgc, GPMODE_AUDIO_CTL_PAGE, 1);
3060         if (ret)
3061                 return ret;
3062
3063         buffer[offset + 9]  = volctrl.channel0 & mask[offset + 9];
3064         buffer[offset + 11] = volctrl.channel1 & mask[offset + 11];
3065         buffer[offset + 13] = volctrl.channel2 & mask[offset + 13];
3066         buffer[offset + 15] = volctrl.channel3 & mask[offset + 15];
3067
3068         /* set volume */
3069         cgc->buffer = buffer + offset - 8;
3070         memset(cgc->buffer, 0, 8);
3071         return cdrom_mode_select(cdi, cgc);
3072 }
3073
3074 static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3075                                         struct packet_command *cgc,
3076                                         int cmd)
3077 {
3078         struct cdrom_device_ops *cdo = cdi->ops;
3079         cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3080         cgc->cmd[0] = GPCMD_START_STOP_UNIT;
3081         cgc->cmd[1] = 1;
3082         cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
3083         cgc->data_direction = CGC_DATA_NONE;
3084         return cdo->generic_packet(cdi, cgc);
3085 }
3086
3087 static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3088                                         struct packet_command *cgc,
3089                                         int cmd)
3090 {
3091         struct cdrom_device_ops *cdo = cdi->ops;
3092         cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3093         cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3094         cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3095         cgc->data_direction = CGC_DATA_NONE;
3096         return cdo->generic_packet(cdi, cgc);
3097 }
3098
3099 static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3100                                                 void __user *arg,
3101                                                 struct packet_command *cgc)
3102 {
3103         int ret;
3104         dvd_struct *s;
3105         int size = sizeof(dvd_struct);
3106
3107         if (!CDROM_CAN(CDC_DVD))
3108                 return -ENOSYS;
3109
3110         s = kmalloc(size, GFP_KERNEL);
3111         if (!s)
3112                 return -ENOMEM;
3113
3114         cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3115         if (copy_from_user(s, arg, size)) {
3116                 kfree(s);
3117                 return -EFAULT;
3118         }
3119
3120         ret = dvd_read_struct(cdi, s, cgc);
3121         if (ret)
3122                 goto out;
3123
3124         if (copy_to_user(arg, s, size))
3125                 ret = -EFAULT;
3126 out:
3127         kfree(s);
3128         return ret;
3129 }
3130
3131 static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3132                                         void __user *arg)
3133 {
3134         int ret;
3135         dvd_authinfo ai;
3136         if (!CDROM_CAN(CDC_DVD))
3137                 return -ENOSYS;
3138         cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
3139         IOCTL_IN(arg, dvd_authinfo, ai);
3140         ret = dvd_do_auth(cdi, &ai);
3141         if (ret)
3142                 return ret;
3143         IOCTL_OUT(arg, dvd_authinfo, ai);
3144         return 0;
3145 }
3146
3147 static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3148                                                 void __user *arg)
3149 {
3150         int ret;
3151         long next = 0;
3152         cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3153         ret = cdrom_get_next_writable(cdi, &next);
3154         if (ret)
3155                 return ret;
3156         IOCTL_OUT(arg, long, next);
3157         return 0;
3158 }
3159
3160 static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3161                                                 void __user *arg)
3162 {
3163         int ret;
3164         long last = 0;
3165         cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3166         ret = cdrom_get_last_written(cdi, &last);
3167         if (ret)
3168                 return ret;
3169         IOCTL_OUT(arg, long, last);
3170         return 0;
3171 }
3172
3173 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3174                      unsigned long arg)
3175 {
3176         struct packet_command cgc;
3177         void __user *userptr = (void __user *)arg;
3178
3179         memset(&cgc, 0, sizeof(cgc));
3180
3181         /* build a unified command and queue it through
3182            cdo->generic_packet() */
3183         switch (cmd) {
3184         case CDROMREADRAW:
3185         case CDROMREADMODE1:
3186         case CDROMREADMODE2:
3187                 return mmc_ioctl_cdrom_read_data(cdi, userptr, &cgc, cmd);
3188         case CDROMREADAUDIO:
3189                 return mmc_ioctl_cdrom_read_audio(cdi, userptr);
3190         case CDROMSUBCHNL:
3191                 return mmc_ioctl_cdrom_subchannel(cdi, userptr);
3192         case CDROMPLAYMSF:
3193                 return mmc_ioctl_cdrom_play_msf(cdi, userptr, &cgc);
3194         case CDROMPLAYBLK:
3195                 return mmc_ioctl_cdrom_play_blk(cdi, userptr, &cgc);
3196         case CDROMVOLCTRL:
3197         case CDROMVOLREAD:
3198                 return mmc_ioctl_cdrom_volume(cdi, userptr, &cgc, cmd);
3199         case CDROMSTART:
3200         case CDROMSTOP:
3201                 return mmc_ioctl_cdrom_start_stop(cdi, &cgc, cmd);
3202         case CDROMPAUSE:
3203         case CDROMRESUME:
3204                 return mmc_ioctl_cdrom_pause_resume(cdi, &cgc, cmd);
3205         case DVD_READ_STRUCT:
3206                 return mmc_ioctl_dvd_read_struct(cdi, userptr, &cgc);
3207         case DVD_AUTH:
3208                 return mmc_ioctl_dvd_auth(cdi, userptr);
3209         case CDROM_NEXT_WRITABLE:
3210                 return mmc_ioctl_cdrom_next_writable(cdi, userptr);
3211         case CDROM_LAST_WRITTEN:
3212                 return mmc_ioctl_cdrom_last_written(cdi, userptr);
3213         }
3214
3215         return -ENOTTY;
3216 }
3217
3218 static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type,
3219                          track_information *ti)
3220 {
3221         struct cdrom_device_ops *cdo = cdi->ops;
3222         struct packet_command cgc;
3223         int ret, buflen;
3224
3225         init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3226         cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3227         cgc.cmd[1] = type & 3;
3228         cgc.cmd[4] = (track & 0xff00) >> 8;
3229         cgc.cmd[5] = track & 0xff;
3230         cgc.cmd[8] = 8;
3231         cgc.quiet = 1;
3232
3233         if ((ret = cdo->generic_packet(cdi, &cgc)))
3234                 return ret;
3235         
3236         buflen = be16_to_cpu(ti->track_information_length) +
3237                      sizeof(ti->track_information_length);
3238
3239         if (buflen > sizeof(track_information))
3240                 buflen = sizeof(track_information);
3241
3242         cgc.cmd[8] = cgc.buflen = buflen;
3243         if ((ret = cdo->generic_packet(cdi, &cgc)))
3244                 return ret;
3245
3246         /* return actual fill size */
3247         return buflen;
3248 }
3249
3250 /* requires CD R/RW */
3251 static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3252 {
3253         struct cdrom_device_ops *cdo = cdi->ops;
3254         struct packet_command cgc;
3255         int ret, buflen;
3256
3257         /* set up command and get the disc info */
3258         init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3259         cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3260         cgc.cmd[8] = cgc.buflen = 2;
3261         cgc.quiet = 1;
3262
3263         if ((ret = cdo->generic_packet(cdi, &cgc)))
3264                 return ret;
3265
3266         /* not all drives have the same disc_info length, so requeue
3267          * packet with the length the drive tells us it can supply
3268          */
3269         buflen = be16_to_cpu(di->disc_information_length) +
3270                      sizeof(di->disc_information_length);
3271
3272         if (buflen > sizeof(disc_information))
3273                 buflen = sizeof(disc_information);
3274
3275         cgc.cmd[8] = cgc.buflen = buflen;
3276         if ((ret = cdo->generic_packet(cdi, &cgc)))
3277                 return ret;
3278
3279         /* return actual fill size */
3280         return buflen;
3281 }
3282
3283 /* return the last written block on the CD-R media. this is for the udf
3284    file system. */
3285 int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
3286 {
3287         struct cdrom_tocentry toc;
3288         disc_information di;
3289         track_information ti;
3290         __u32 last_track;
3291         int ret = -1, ti_size;
3292
3293         if (!CDROM_CAN(CDC_GENERIC_PACKET))
3294                 goto use_toc;
3295
3296         ret = cdrom_get_disc_info(cdi, &di);
3297         if (ret < (int)(offsetof(typeof(di), last_track_lsb)
3298                         + sizeof(di.last_track_lsb)))
3299                 goto use_toc;
3300
3301         /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3302         last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3303         ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3304         if (ti_size < (int)offsetof(typeof(ti), track_start))
3305                 goto use_toc;
3306
3307         /* if this track is blank, try the previous. */
3308         if (ti.blank) {
3309                 if (last_track==1)
3310                         goto use_toc;
3311                 last_track--;
3312                 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3313         }
3314
3315         if (ti_size < (int)(offsetof(typeof(ti), track_size)
3316                                 + sizeof(ti.track_size)))
3317                 goto use_toc;
3318
3319         /* if last recorded field is valid, return it. */
3320         if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3321                                 + sizeof(ti.last_rec_address))) {
3322                 *last_written = be32_to_cpu(ti.last_rec_address);
3323         } else {
3324                 /* make it up instead */
3325                 *last_written = be32_to_cpu(ti.track_start) +
3326                                 be32_to_cpu(ti.track_size);
3327                 if (ti.free_blocks)
3328                         *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3329         }
3330         return 0;
3331
3332         /* this is where we end up if the drive either can't do a
3333            GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
3334