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