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 loose the index part, however.
176 -- Small modifications to accomodate 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 -------------------------------------------------------------------------*/
232
233 #define REVISION "Revision: 3.12"
234 #define VERSION "Id: cdrom.c 3.12 2000/10/18"
235
236 /* I use an error-log mask to give fine grain control over the type of
237 messages dumped to the system logs. The available masks include: */
238 #define CD_NOTHING 0x0
239 #define CD_WARNING 0x1
240 #define CD_REG_UNREG 0x2
241 #define CD_DO_IOCTL 0x4
242 #define CD_OPEN 0x8
243 #define CD_CLOSE 0x10
244 #define CD_COUNT_TRACKS 0x20
245 #define CD_CHANGER 0x40
246 #define CD_DVD 0x80
247
248 /* Define this to remove _all_ the debugging messages */
249 /* #define ERRLOGMASK CD_NOTHING */
250 #define ERRLOGMASK (CD_WARNING)
251 /* #define ERRLOGMASK (CD_WARNING|CD_OPEN|CD_COUNT_TRACKS|CD_CLOSE) */
252 /* #define ERRLOGMASK (CD_WARNING|CD_REG_UNREG|CD_DO_IOCTL|CD_OPEN|CD_CLOSE|CD_COUNT_TRACKS) */
253
254 #include <linux/config.h>
255 #include <linux/module.h>
256 #include <linux/fs.h>
257 #include <linux/major.h>
258 #include <linux/types.h>
259 #include <linux/errno.h>
260 #include <linux/kernel.h>
261 #include <linux/mm.h>
262 #include <linux/malloc.h>
263 #include <linux/cdrom.h>
264 #include <linux/sysctl.h>
265 #include <linux/proc_fs.h>
266 #include <linux/init.h>
267
268 #include <asm/fcntl.h>
269 #include <asm/segment.h>
270 #include <asm/uaccess.h>
271
272 /* used to tell the module to turn on full debugging messages */
273 static int debug;
274 /* used to keep tray locked at all times */
275 static int keeplocked;
276 /* default compatibility mode */
277 static int autoclose=1;
278 static int autoeject;
279 static int lockdoor = 1;
280 /* will we ever get to use this... sigh. */
281 static int check_media_type;
282 MODULE_PARM(debug, "i");
283 MODULE_PARM(autoclose, "i");
284 MODULE_PARM(autoeject, "i");
285 MODULE_PARM(lockdoor, "i");
286 MODULE_PARM(check_media_type, "i");
287
288 #if (ERRLOGMASK!=CD_NOTHING)
289 #define cdinfo(type, fmt, args...) \
290 if ((ERRLOGMASK & type) || debug==1 ) \
291 printk(KERN_INFO "cdrom: " fmt, ## args)
292 #else
293 #define cdinfo(type, fmt, args...)
294 #endif
295
296 /* These are used to simplify getting data in from and back to user land */
297 #define IOCTL_IN(arg, type, in) \
298 if (copy_from_user(&in, (type *) arg, sizeof in)) \
299 return -EFAULT;
300
301 #define IOCTL_OUT(arg, type, out) \
302 if (copy_to_user((type *) arg, &out, sizeof out)) \
303 return -EFAULT;
304
305 /* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
306 a lot of places. This macro makes the code more clear. */
307 #define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
308
309 /* used in the audio ioctls */
310 #define CHECKAUDIO if ((ret=check_for_audio_disc(cdi, cdo))) return ret
311
312 /* Not-exported routines. */
313 static int cdrom_open(struct inode *ip, struct file *fp);
314 static int cdrom_release(struct inode *ip, struct file *fp);
315 static int cdrom_ioctl(struct inode *ip, struct file *fp,
316 unsigned int cmd, unsigned long arg);
317 static int cdrom_media_changed(kdev_t dev);
318 static int open_for_data(struct cdrom_device_info * cdi);
319 static int check_for_audio_disc(struct cdrom_device_info * cdi,
320 struct cdrom_device_ops * cdo);
321 static void sanitize_format(union cdrom_addr *addr,
322 u_char * curr, u_char requested);
323 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
324 unsigned long arg);
325
326 int cdrom_get_last_written(kdev_t dev, long *last_written);
327 int cdrom_get_next_writable(kdev_t dev, long *next_writable);
328
329 #ifdef CONFIG_SYSCTL
330 static void cdrom_sysctl_register(void);
331 #endif /* CONFIG_SYSCTL */
332 static struct cdrom_device_info *topCdromPtr;
333 static devfs_handle_t devfs_handle;
334
335 struct block_device_operations cdrom_fops =
336 {
337 open: cdrom_open,
338 release: cdrom_release,
339 ioctl: cdrom_ioctl,
340 check_media_change: cdrom_media_changed,
341 };
342
343 /* This macro makes sure we don't have to check on cdrom_device_ops
344 * existence in the run-time routines below. Change_capability is a
345 * hack to have the capability flags defined const, while we can still
346 * change it here without gcc complaining at every line.
347 */
348 #define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
349
350 int register_cdrom(struct cdrom_device_info *cdi)
351 {
352 static char banner_printed;
353 int major = MAJOR(cdi->dev);
354 struct cdrom_device_ops *cdo = cdi->ops;
355 int *change_capability = (int *)&cdo->capability; /* hack */
356 char vname[16];
357 static unsigned int cdrom_counter;
358
359 cdinfo(CD_OPEN, "entering register_cdrom\n");
360
361 if (major < 0 || major >= MAX_BLKDEV)
362 return -1;
363 if (cdo->open == NULL || cdo->release == NULL)
364 return -2;
365 if ( !banner_printed ) {
366 printk(KERN_INFO "Uniform CD-ROM driver " REVISION "\n");
367 banner_printed = 1;
368 #ifdef CONFIG_SYSCTL
369 cdrom_sysctl_register();
370 #endif /* CONFIG_SYSCTL */
371 }
372 ENSURE(drive_status, CDC_DRIVE_STATUS );
373 ENSURE(media_changed, CDC_MEDIA_CHANGED);
374 ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
375 ENSURE(lock_door, CDC_LOCK);
376 ENSURE(select_speed, CDC_SELECT_SPEED);
377 ENSURE(get_last_session, CDC_MULTI_SESSION);
378 ENSURE(get_mcn, CDC_MCN);
379 ENSURE(reset, CDC_RESET);
380 ENSURE(audio_ioctl, CDC_PLAY_AUDIO);
381 ENSURE(dev_ioctl, CDC_IOCTLS);
382 ENSURE(generic_packet, CDC_GENERIC_PACKET);
383 cdi->mc_flags = 0;
384 cdo->n_minors = 0;
385 cdi->options = CDO_USE_FFLAGS;
386
387 if (autoclose==1 && CDROM_CAN(CDC_CLOSE_TRAY))
388 cdi->options |= (int) CDO_AUTO_CLOSE;
389 if (autoeject==1 && CDROM_CAN(CDC_OPEN_TRAY))
390 cdi->options |= (int) CDO_AUTO_EJECT;
391 if (lockdoor==1)
392 cdi->options |= (int) CDO_LOCK;
393 if (check_media_type==1)
394 cdi->options |= (int) CDO_CHECK_TYPE;
395
396 if (!devfs_handle)
397 devfs_handle = devfs_mk_dir (NULL, "cdroms", NULL);
398 sprintf (vname, "cdrom%u", cdrom_counter++);
399 if (cdi->de) {
400 int pos;
401 devfs_handle_t slave;
402 char rname[64];
403
404 pos = devfs_generate_path (cdi->de, rname + 3,
405 sizeof rname - 3);
406 if (pos >= 0) {
407 strncpy (rname + pos, "../", 3);
408 devfs_mk_symlink (devfs_handle, vname,
409 DEVFS_FL_DEFAULT,
410 rname + pos, &slave, NULL);
411 devfs_auto_unregister (cdi->de, slave);
412 }
413 }
414 else {
415 cdi->de =
416 devfs_register (devfs_handle, vname, DEVFS_FL_DEFAULT,
417 MAJOR (cdi->dev), MINOR (cdi->dev),
418 S_IFBLK | S_IRUGO | S_IWUGO,
419 &cdrom_fops, NULL);
420 }
421 cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
422 cdi->next = topCdromPtr;
423 topCdromPtr = cdi;
424 return 0;
425 }
426 #undef ENSURE
427
428 int unregister_cdrom(struct cdrom_device_info *unreg)
429 {
430 struct cdrom_device_info *cdi, *prev;
431 int major = MAJOR(unreg->dev);
432
433 cdinfo(CD_OPEN, "entering unregister_cdrom\n");
434
435 if (major < 0 || major >= MAX_BLKDEV)
436 return -1;
437
438 prev = NULL;
439 cdi = topCdromPtr;
440 while (cdi != NULL && cdi->dev != unreg->dev) {
441 prev = cdi;
442 cdi = cdi->next;
443 }
444
445 if (cdi == NULL)
446 return -2;
447 if (prev)
448 prev->next = cdi->next;
449 else
450 topCdromPtr = cdi->next;
451 cdi->ops->n_minors--;
452 devfs_unregister (cdi->de);
453 cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
454 return 0;
455 }
456
457 struct cdrom_device_info *cdrom_find_device(kdev_t dev)
458 {
459 struct cdrom_device_info *cdi;
460
461 cdi = topCdromPtr;
462 while (cdi != NULL && cdi->dev != dev)
463 cdi = cdi->next;
464
465 return cdi;
466 }
467
468 /* We use the open-option O_NONBLOCK to indicate that the
469 * purpose of opening is only for subsequent ioctl() calls; no device
470 * integrity checks are performed.
471 *
472 * We hope that all cd-player programs will adopt this convention. It
473 * is in their own interest: device control becomes a lot easier
474 * this way.
475 */
476 static
477 int cdrom_open(struct inode *ip, struct file *fp)
478 {
479 struct cdrom_device_info *cdi;
480 kdev_t dev = ip->i_rdev;
481 int ret;
482
483 cdinfo(CD_OPEN, "entering cdrom_open\n");
484 if ((cdi = cdrom_find_device(dev)) == NULL)
485 return -ENODEV;
486
487 if ((fp->f_mode & FMODE_WRITE) && !CDROM_CAN(CDC_DVD_RAM))
488 return -EROFS;
489
490 /* if this was a O_NONBLOCK open and we should honor the flags,
491 * do a quick open without drive/disc integrity checks. */
492 if ((fp->f_flags & O_NONBLOCK) && (cdi->options & CDO_USE_FFLAGS))
493 ret = cdi->ops->open(cdi, 1);
494 else
495 ret = open_for_data(cdi);
496
497 if (!ret) cdi->use_count++;
498
499 cdinfo(CD_OPEN, "Use count for \"/dev/%s\" now %d\n", cdi->name, cdi->use_count);
500 /* Do this on open. Don't wait for mount, because they might
501 not be mounting, but opening with O_NONBLOCK */
502 check_disk_change(dev);
503 return ret;
504 }
505
506 static
507 int open_for_data(struct cdrom_device_info * cdi)
508 {
509 int ret;
510 struct cdrom_device_ops *cdo = cdi->ops;
511 tracktype tracks;
512 cdinfo(CD_OPEN, "entering open_for_data\n");
513 /* Check if the driver can report drive status. If it can, we
514 can do clever things. If it can't, well, we at least tried! */
515 if (cdo->drive_status != NULL) {
516 ret = cdo->drive_status(cdi, CDSL_CURRENT);
517 cdinfo(CD_OPEN, "drive_status=%d\n", ret);
518 if (ret == CDS_TRAY_OPEN) {
519 cdinfo(CD_OPEN, "the tray is open...\n");
520 /* can/may i close it? */
521 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
522 cdi->options & CDO_AUTO_CLOSE) {
523 cdinfo(CD_OPEN, "trying to close the tray.\n");
524 ret=cdo->tray_move(cdi,0);
525 if (ret) {
526 cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.\n");
527 /* Ignore the error from the low
528 level driver. We don't care why it
529 couldn't close the tray. We only care
530 that there is no disc in the drive,
531 since that is the _REAL_ problem here.*/
532 ret=-ENOMEDIUM;
533 goto clean_up_and_return;
534 }
535 } else {
536 cdinfo(CD_OPEN, "bummer. this drive can't close the tray.\n");
537 ret=-ENOMEDIUM;
538 goto clean_up_and_return;
539 }
540 /* Ok, the door should be closed now.. Check again */
541 ret = cdo->drive_status(cdi, CDSL_CURRENT);
542 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
543 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
544 cdinfo(CD_OPEN, "tray might not contain a medium.\n");
545 ret=-ENOMEDIUM;
546 goto clean_up_and_return;
547 }
548 cdinfo(CD_OPEN, "the tray is now closed.\n");
549 }
550 if (ret!=CDS_DISC_OK) {
551 ret = -ENOMEDIUM;
552 goto clean_up_and_return;
553 }
554 }
555 cdrom_count_tracks(cdi, &tracks);
556 if (tracks.error == CDS_NO_DISC) {
557 cdinfo(CD_OPEN, "bummer. no disc.\n");
558 ret=-ENOMEDIUM;
559 goto clean_up_and_return;
560 }
561 /* CD-Players which don't use O_NONBLOCK, workman
562 * for example, need bit CDO_CHECK_TYPE cleared! */
563 if (tracks.data==0) {
564 if (cdi->options & CDO_CHECK_TYPE) {
565 /* give people a warning shot, now that CDO_CHECK_TYPE
566 is the default case! */
567 cdinfo(CD_OPEN, "bummer. wrong media type.\n");
568 cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
569 (unsigned int)current->pid);
570 ret=-EMEDIUMTYPE;
571 goto clean_up_and_return;
572 }
573 else {
574 cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.\n");
575 }
576 }
577
578 cdinfo(CD_OPEN, "all seems well, opening the device.\n");
579
580 /* all seems well, we can open the device */
581 ret = cdo->open(cdi, 0); /* open for data */
582 cdinfo(CD_OPEN, "opening the device gave me %d.\n", ret);
583 /* After all this careful checking, we shouldn't have problems
584 opening the device, but we don't want the device locked if
585 this somehow fails... */
586 if (ret) {
587 cdinfo(CD_OPEN, "open device failed.\n");
588 goto clean_up_and_return;
589 }
590 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
591 cdo->lock_door(cdi, 1);
592 cdinfo(CD_OPEN, "door locked.\n");
593 }
594 cdinfo(CD_OPEN, "device opened successfully.\n");
595 return ret;
596
597 /* Something failed. Try to unlock the drive, because some drivers
598 (notably ide-cd) lock the drive after every command. This produced
599 a nasty bug where after mount failed, the drive would remain locked!
600 This ensures that the drive gets unlocked after a mount fails. This
601 is a goto to avoid bloating the driver with redundant code. */
602 clean_up_and_return:
603 cdinfo(CD_WARNING, "open failed.\n");
604 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
605 cdo->lock_door(cdi, 0);
606 cdinfo(CD_OPEN, "door unlocked.\n");
607 }
608 return ret;
609 }
610
611 /* This code is similar to that in open_for_data. The routine is called
612 whenever an audio play operation is requested.
613 */
614 int check_for_audio_disc(struct cdrom_device_info * cdi,
615 struct cdrom_device_ops * cdo)
616 {
617 int ret;
618 tracktype tracks;
619 cdinfo(CD_OPEN, "entering check_for_audio_disc\n");
620 if (!(cdi->options & CDO_CHECK_TYPE))
621 return 0;
622 if (cdo->drive_status != NULL) {
623 ret = cdo->drive_status(cdi, CDSL_CURRENT);
624 cdinfo(CD_OPEN, "drive_status=%d\n", ret);
625 if (ret == CDS_TRAY_OPEN) {
626 cdinfo(CD_OPEN, "the tray is open...\n");
627 /* can/may i close it? */
628 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
629 cdi->options & CDO_AUTO_CLOSE) {
630 cdinfo(CD_OPEN, "trying to close the tray.\n");
631 ret=cdo->tray_move(cdi,0);
632 if (ret) {
633 cdinfo(CD_OPEN, "bummer. tried to close tray but failed.\n");
634 /* Ignore the error from the low
635 level driver. We don't care why it
636 couldn't close the tray. We only care
637 that there is no disc in the drive,
638 since that is the _REAL_ problem here.*/
639 return -ENOMEDIUM;
640 }
641 } else {
642 cdinfo(CD_OPEN, "bummer. this driver can't close the tray.\n");
643 return -ENOMEDIUM;
644 }
645 /* Ok, the door should be closed now.. Check again */
646 ret = cdo->drive_status(cdi, CDSL_CURRENT);
647 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
648 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n");
649 return -ENOMEDIUM;
650 }
651 if (ret!=CDS_DISC_OK) {
652 cdinfo(CD_OPEN, "bummer. disc isn't ready.\n");
653 return -EIO;
654 }
655 cdinfo(CD_OPEN, "the tray is now closed.\n");
656 }
657 }
658 cdrom_count_tracks(cdi, &tracks);
659 if (tracks.error)
660 return(tracks.error);
661
662 if (tracks.audio==0)
663 return -EMEDIUMTYPE;
664
665 return 0;
666 }
667
668
669 /* Admittedly, the logic below could be performed in a nicer way. */
670 static
671 int cdrom_release(struct inode *ip, struct file *fp)
672 {
673 kdev_t dev = ip->i_rdev;
674 struct cdrom_device_info *cdi = cdrom_find_device(dev);
675 struct cdrom_device_ops *cdo = cdi->ops;
676 int opened_for_data;
677
678 cdinfo(CD_CLOSE, "entering cdrom_release\n");
679
680 if (cdi->use_count > 0)
681 cdi->use_count--;
682 if (cdi->use_count == 0)
683 cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name);
684 if (cdi->use_count == 0 &&
685 cdo->capability & CDC_LOCK && !keeplocked) {
686 cdinfo(CD_CLOSE, "Unlocking door!\n");
687 cdo->lock_door(cdi, 0);
688 }
689 opened_for_data = !(cdi->options & CDO_USE_FFLAGS) ||
690 !(fp && fp->f_flags & O_NONBLOCK);
691 cdo->release(cdi);
692 if (cdi->use_count == 0) { /* last process that closes dev*/
693 if (opened_for_data &&
694 cdi->options & CDO_AUTO_EJECT && CDROM_CAN(CDC_OPEN_TRAY))
695 cdo->tray_move(cdi, 1);
696 }
697 return 0;
698 }
699
700 static int cdrom_read_mech_status(struct cdrom_device_info *cdi,
701 struct cdrom_changer_info *buf)
702 {
703 struct cdrom_generic_command cgc;
704 struct cdrom_device_ops *cdo = cdi->ops;
705 int length;
706
707 /*
708 * Sanyo changer isn't spec compliant (doesn't use regular change
709 * LOAD_UNLOAD command, and it doesn't implement the mech status
710 * command below
711 */
712 if (cdi->sanyo_slot) {
713 buf->hdr.nslots = 3;
714 buf->hdr.curslot = cdi->sanyo_slot == 3 ? 0 : cdi->sanyo_slot;
715 for (length = 0; length < 3; length++) {
716 buf->slots[length].disc_present = 1;
717 buf->slots[length].change = 0;
718 }
719 return 0;
720 }
721
722 length = sizeof(struct cdrom_mechstat_header) +
723 cdi->capacity * sizeof(struct cdrom_slot);
724
725 init_cdrom_command(&cgc, buf, length, CGC_DATA_READ);
726 cgc.cmd[0] = GPCMD_MECHANISM_STATUS;
727 cgc.cmd[8] = (length >> 8) & 0xff;
728 cgc.cmd[9] = length & 0xff;
729 return cdo->generic_packet(cdi, &cgc);
730 }
731
732 static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
733 {
734 struct cdrom_changer_info info;
735 int ret;
736
737 cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n");
738 if (cdi->sanyo_slot)
739 return CDS_NO_INFO;
740
741 if ((ret = cdrom_read_mech_status(cdi, &info)))
742 return ret;
743
744 if (info.slots[slot].disc_present)
745 return CDS_DISC_OK;
746 else
747 return CDS_NO_DISC;
748
749 }
750
751 /* Return the number of slots for an ATAPI/SCSI cdrom,
752 * return 1 if not a changer.
753 */
754 int cdrom_number_of_slots(struct cdrom_device_info *cdi)
755 {
756 int status;
757 int nslots = 1;
758 struct cdrom_changer_info info;
759
760 cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n");
761 /* cdrom_read_mech_status requires a valid value for capacity: */
762 cdi->capacity = 0;
763
764 if ((status = cdrom_read_mech_status(cdi, &info)) == 0)
765 nslots = info.hdr.nslots;
766
767 return nslots;
768 }
769
770
771 /* If SLOT < 0, unload the current slot. Otherwise, try to load SLOT. */
772 static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
773 {
774 struct cdrom_generic_command cgc;
775
776 cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n");
777 if (cdi->sanyo_slot && slot < 0)
778 return 0;
779
780 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
781 cgc.cmd[0] = GPCMD_LOAD_UNLOAD;
782 cgc.cmd[4] = 2 + (slot >= 0);
783 cgc.cmd[8] = slot;
784
785 /* The Sanyo 3 CD changer uses byte 7 of the
786 GPCMD_TEST_UNIT_READY to command to switch CDs instead of
787 using the GPCMD_LOAD_UNLOAD opcode. */
788 if (cdi->sanyo_slot && -1 < slot) {
789 cgc.cmd[0] = GPCMD_TEST_UNIT_READY;
790 cgc.cmd[7] = slot;
791 cgc.cmd[4] = cgc.cmd[8] = 0;
792 cdi->sanyo_slot = slot ? slot : 3;
793 }
794
795 return cdi->ops->generic_packet(cdi, &cgc);
796 }
797
798 int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
799 {
800 struct cdrom_changer_info info;
801 int curslot;
802 int ret;
803
804 cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n");
805 if (!CDROM_CAN(CDC_SELECT_DISC))
806 return -EDRIVE_CANT_DO_THIS;
807
808 (void) cdi->ops->media_changed(cdi, slot);
809
810 if (slot == CDSL_NONE) {
811 /* set media changed bits, on both queues */
812 cdi->mc_flags = 0x3;
813 return cdrom_load_unload(cdi, -1);
814 }
815
816 if ((ret = cdrom_read_mech_status(cdi, &info)))
817 return ret;
818
819 curslot = info.hdr.curslot;
820
821 if (cdi->use_count > 1 || keeplocked) {
822 if (slot == CDSL_CURRENT) {
823 return curslot;
824 } else {
825 return -EBUSY;
826 }
827 }
828
829 /* Specifying CDSL_CURRENT will attempt to load the currnet slot,
830 which is useful if it had been previously unloaded.
831 Whether it can or not, it returns the current slot.
832 Similarly, if slot happens to be the current one, we still
833 try and load it. */
834 if (slot == CDSL_CURRENT)
835 slot = curslot;
836
837 /* set media changed bits on both queues */
838 cdi->mc_flags = 0x3;
839 if ((ret = cdrom_load_unload(cdi, slot)))
840 return ret;
841
842 return slot;
843 }
844
845 /* We want to make media_changed accessible to the user through an
846 * ioctl. The main problem now is that we must double-buffer the
847 * low-level implementation, to assure that the VFS and the user both
848 * see a medium change once.
849 */
850
851 static
852 int media_changed(struct cdrom_device_info *cdi, int queue)
853 {
854 unsigned int mask = (1 << (queue & 1));
855 int ret = !!(cdi->mc_flags & mask);
856
857 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
858 return ret;
859 /* changed since last call? */
860 if (cdi->ops->media_changed(cdi, CDSL_CURRENT)) {
861 cdi->mc_flags = 0x3; /* set bit on both queues */
862 ret |= 1;
863 }
864 cdi->mc_flags &= ~mask; /* clear bit */
865 return ret;
866 }
867
868 static int cdrom_media_changed(kdev_t dev)
869 {
870 struct cdrom_device_info *cdi = cdrom_find_device(dev);
871 /* This talks to the VFS, which doesn't like errors - just 1 or 0.
872 * Returning "" is always safe (media hasn't been changed). Do that
873 * if the low-level cdrom driver dosn't support media changed. */
874 if (cdi == NULL || cdi->ops->media_changed == NULL)
875 return 0;
876 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
877 return 0;
878 return media_changed(cdi, 0);
879 }
880
881 /* badly broken, I know. Is due for a fixup anytime. */
882 void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
883 {
884 struct cdrom_tochdr header;
885 struct cdrom_tocentry entry;
886 int ret, i;
887 tracks->data=0;
888 tracks->audio=0;
889 tracks->cdi=0;
890 tracks->xa=0;
891 tracks->error=0;
892 cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
893 if (!CDROM_CAN(CDC_PLAY_AUDIO)) {
894 tracks->error=CDS_NO_INFO;
895 return;
896 }
897 /* Grab the TOC header so we can see how many tracks there are */
898 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
899 if (ret == -ENOMEDIUM)
900 tracks->error = CDS_NO_DISC;
901 else
902 tracks->error = CDS_NO_INFO;
903 return;
904 }
905 /* check what type of tracks are on this disc */
906 entry.cdte_format = CDROM_MSF;
907 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
908 entry.cdte_track = i;
909 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
910 tracks->error=CDS_NO_INFO;
911 return;
912 }
913 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
914 if (entry.cdte_format == 0x10)
915 tracks->cdi++;
916 else if (entry.cdte_format == 0x20)
917 tracks->xa++;
918 else
919 tracks->data++;
920 } else
921 tracks->audio++;
922 cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
923 i, entry.cdte_format, entry.cdte_ctrl);
924 }
925 cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
926 header.cdth_trk1, tracks->audio, tracks->data,
927 tracks->cdi, tracks->xa);
928 }
929
930 /* Requests to the low-level drivers will /always/ be done in the
931 following format convention:
932
933 CDROM_LBA: all data-related requests.
934 CDROM_MSF: all audio-related requests.
935
936 However, a low-level implementation is allowed to refuse this
937 request, and return information in its own favorite format.
938
939 It doesn't make sense /at all/ to ask for a play_audio in LBA
940 format, or ask for multi-session info in MSF format. However, for
941 backward compatibility these format requests will be satisfied, but
942 the requests to the low-level drivers will be sanitized in the more
943 meaningful format indicated above.
944 */
945
946 static
947 void sanitize_format(union cdrom_addr *addr,
948 u_char * curr, u_char requested)
949 {
950 if (*curr == requested)
951 return; /* nothing to be done! */
952 if (requested == CDROM_LBA) {
953 addr->lba = (int) addr->msf.frame +
954 75 * (addr->msf.second - 2 + 60 * addr->msf.minute);
955 } else { /* CDROM_MSF */
956 int lba = addr->lba;
957 addr->msf.frame = lba % 75;
958 lba /= 75;
959 lba += 2;
960 addr->msf.second = lba % 60;
961 addr->msf.minute = lba / 60;
962 }
963 *curr = requested;
964 }
965
966 void init_cdrom_command(struct cdrom_generic_command *cgc, void *buf, int len,
967 int type)
968 {
969 memset(cgc, 0, sizeof(struct cdrom_generic_command));
970 if (buf)
971 memset(buf, 0, len);
972 cgc->buffer = (char *) buf;
973 cgc->buflen = len;
974 cgc->data_direction = type;
975 cgc->timeout = 5*HZ;
976 }
977
978 /* DVD handling */
979
980 #define copy_key(dest,src) memcpy((dest), (src), sizeof(dvd_key))
981 #define copy_chal(dest,src) memcpy((dest), (src), sizeof(dvd_challenge))
982
983 static void setup_report_key(struct cdrom_generic_command *cgc, unsigned agid, unsigned type)
984 {
985 cgc->cmd[0] = GPCMD_REPORT_KEY;
986 cgc->cmd[10] = type | (agid << 6);
987 switch (type) {
988 case 0: case 8: case 5: {
989 cgc->buflen = 8;
990 break;
991 }
992 case 1: {
993 cgc->buflen = 16;
994 break;
995 }
996 case 2: case 4: {
997 cgc->buflen = 12;
998 break;
999 }
1000 }
1001 cgc->cmd[9] = cgc->buflen;
1002 cgc->data_direction = CGC_DATA_READ;
1003 }
1004
1005 static void setup_send_key(struct cdrom_generic_command *cgc, unsigned agid, unsigned type)
1006 {
1007 cgc->cmd[0] = GPCMD_SEND_KEY;
1008 cgc->cmd[10] = type | (agid << 6);
1009 switch (type) {
1010 case 1: {
1011 cgc->buflen = 16;
1012 break;
1013 }
1014 case 3: {
1015 cgc->buflen = 12;
1016 break;
1017 }
1018 case 6: {
1019 cgc->buflen = 8;
1020 break;
1021 }
1022 }
1023 cgc->cmd[9] = cgc->buflen;
1024 cgc->data_direction = CGC_DATA_WRITE;
1025 }
1026
1027 static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1028 {
1029 int ret;
1030 u_char buf[20];
1031 struct cdrom_generic_command cgc;
1032 struct cdrom_device_ops *cdo = cdi->ops;
1033 rpc_state_t rpc_state;
1034
1035 memset(buf, 0, sizeof(buf));
1036 init_cdrom_command(&cgc, buf, 0, CGC_DATA_READ);
1037
1038 switch (ai->type) {
1039 /* LU data send */
1040 case DVD_LU_SEND_AGID:
1041 cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1042 setup_report_key(&cgc, ai->lsa.agid, 0);
1043
1044 if ((ret = cdo->generic_packet(cdi, &cgc)))
1045 return ret;
1046
1047 ai->lsa.agid = buf[7] >> 6;
1048 /* Returning data, let host change state */
1049 break;
1050
1051 case DVD_LU_SEND_KEY1:
1052 cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1053 setup_report_key(&cgc, ai->lsk.agid, 2);
1054
1055 if ((ret = cdo->generic_packet(cdi, &cgc)))
1056 return ret;
1057
1058 copy_key(ai->lsk.key, &buf[4]);
1059 /* Returning data, let host change state */
1060 break;
1061
1062 case DVD_LU_SEND_CHALLENGE:
1063 cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1064 setup_report_key(&cgc, ai->lsc.agid, 1);
1065
1066 if ((ret = cdo->generic_packet(cdi, &cgc)))
1067 return ret;
1068
1069 copy_chal(ai->lsc.chal, &buf[4]);
1070 /* Returning data, let host change state */
1071 break;
1072
1073 /* Post-auth key */
1074 case DVD_LU_SEND_TITLE_KEY:
1075 cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1076 setup_report_key(&cgc, ai->lstk.agid, 4);
1077 cgc.cmd[5] = ai->lstk.lba;
1078 cgc.cmd[4] = ai->lstk.lba >> 8;
1079 cgc.cmd[3] = ai->lstk.lba >> 16;
1080 cgc.cmd[2] = ai->lstk.lba >> 24;
1081
1082 if ((ret = cdo->generic_packet(cdi, &cgc)))
1083 return ret;
1084
1085 ai->lstk.cpm = (buf[4] >> 7) & 1;
1086 ai->lstk.cp_sec = (buf[4] >> 6) & 1;
1087 ai->lstk.cgms = (buf[4] >> 4) & 3;
1088 copy_key(ai->lstk.title_key, &buf[5]);
1089 /* Returning data, let host change state */
1090 break;
1091
1092 case DVD_LU_SEND_ASF:
1093 cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1094 setup_report_key(&cgc, ai->lsasf.agid, 5);
1095
1096 if ((ret = cdo->generic_packet(cdi, &cgc)))
1097 return ret;
1098
1099 ai->lsasf.asf = buf[7] & 1;
1100 break;
1101
1102 /* LU data receive (LU changes state) */
1103 case DVD_HOST_SEND_CHALLENGE:
1104 cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1105 setup_send_key(&cgc, ai->hsc.agid, 1);
1106 buf[1] = 0xe;
1107 copy_chal(&buf[4], ai->hsc.chal);
1108
1109 if ((ret = cdo->generic_packet(cdi, &cgc)))
1110 return ret;
1111
1112 ai->type = DVD_LU_SEND_KEY1;
1113 break;
1114
1115 case DVD_HOST_SEND_KEY2:
1116 cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1117 setup_send_key(&cgc, ai->hsk.agid, 3);
1118 buf[1] = 0xa;
1119 copy_key(&buf[4], ai->hsk.key);
1120
1121 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1122 ai->type = DVD_AUTH_FAILURE;
1123 return ret;
1124 }
1125 ai->type = DVD_AUTH_ESTABLISHED;
1126 break;
1127
1128 /* Misc */
1129 case DVD_INVALIDATE_AGID:
1130 cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1131 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1132 if ((ret = cdo->generic_packet(cdi, &cgc)))
1133 return ret;
1134 break;
1135
1136 /* Get region settings */
1137 case DVD_LU_SEND_RPC_STATE:
1138 cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1139 setup_report_key(&cgc, 0, 8);
1140 memset(&rpc_state, 0, sizeof(rpc_state_t));
1141 cgc.buffer = (char *) &rpc_state;
1142
1143 if ((ret = cdo->generic_packet(cdi, &cgc)))
1144 return ret;
1145
1146 ai->lrpcs.type = rpc_state.type_code;
1147 ai->lrpcs.vra = rpc_state.vra;
1148 ai->lrpcs.ucca = rpc_state.ucca;
1149 ai->lrpcs.region_mask = rpc_state.region_mask;
1150 ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme;
1151 break;
1152
1153 /* Set region settings */
1154 case DVD_HOST_SEND_RPC_STATE:
1155 cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1156 setup_send_key(&cgc, 0, 6);
1157 buf[1] = 6;
1158 buf[4] = ai->hrpcs.pdrc;
1159
1160 if ((ret = cdo->generic_packet(cdi, &cgc)))
1161 return ret;
1162 break;
1163
1164 default:
1165 cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1166 return -ENOTTY;
1167 }
1168
1169 return 0;
1170 }
1171
1172 static int dvd_read_physical(struct cdrom_device_info *cdi, dvd_struct *s)
1173 {
1174 int ret, i;
1175 u_char buf[4 + 4 * 20], *base;
1176 struct dvd_layer *layer;
1177 struct cdrom_generic_command cgc;
1178 struct cdrom_device_ops *cdo = cdi->ops;
1179
1180 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1181 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1182 cgc.cmd[6] = s->physical.layer_num;
1183 cgc.cmd[7] = s->type;
1184 cgc.cmd[9] = cgc.buflen & 0xff;
1185
1186 if ((ret = cdo->generic_packet(cdi, &cgc)))
1187 return ret;
1188
1189 base = &buf[4];
1190 layer = &s->physical.layer[0];
1191
1192 /* place the data... really ugly, but at least we won't have to
1193 worry about endianess in userspace or here. */
1194 for (i = 0; i < 4; ++i, base += 20, ++layer) {
1195 memset(layer, 0, sizeof(*layer));
1196 layer->book_version = base[0] & 0xf;
1197 layer->book_type = base[0] >> 4;
1198 layer->min_rate = base[1] & 0xf;
1199 layer->disc_size = base[1] >> 4;
1200 layer->layer_type = base[2] & 0xf;
1201 layer->track_path = (base[2] >> 4) & 1;
1202 layer->nlayers = (base[2] >> 5) & 3;
1203 layer->track_density = base[3] & 0xf;
1204 layer->linear_density = base[3] >> 4;
1205 layer->start_sector = base[5] << 16 | base[6] << 8 | base[7];
1206 layer->end_sector = base[9] << 16 | base[10] << 8 | base[11];
1207 layer->end_sector_l0 = base[13] << 16 | base[14] << 8 | base[15];
1208 layer->bca = base[16] >> 7;
1209 }
1210
1211 return 0;
1212 }
1213
1214 static int dvd_read_copyright(struct cdrom_device_info *cdi, dvd_struct *s)
1215 {
1216 int ret;
1217 u_char buf[8];
1218 struct cdrom_generic_command cgc;
1219 struct cdrom_device_ops *cdo = cdi->ops;
1220
1221 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1222 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1223 cgc.cmd[6] = s->copyright.layer_num;
1224 cgc.cmd[7] = s->type;
1225 cgc.cmd[8] = cgc.buflen >> 8;
1226 cgc.cmd[9] = cgc.buflen & 0xff;
1227
1228 if ((ret = cdo->generic_packet(cdi, &cgc)))
1229 return ret;
1230
1231 s->copyright.cpst = buf[4];
1232 s->copyright.rmi = buf[5];
1233
1234 return 0;
1235 }
1236
1237 static int dvd_read_disckey(struct cdrom_device_info *cdi, dvd_struct *s)
1238 {
1239 int ret, size;
1240 u_char *buf;
1241 struct cdrom_generic_command cgc;
1242 struct cdrom_device_ops *cdo = cdi->ops;
1243
1244 size = sizeof(s->disckey.value) + 4;
1245
1246 if ((buf = (u_char *) kmalloc(size, GFP_KERNEL)) == NULL)
1247 return -ENOMEM;
1248
1249 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1250 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1251 cgc.cmd[7] = s->type;
1252 cgc.cmd[8] = size >> 8;
1253 cgc.cmd[9] = size & 0xff;
1254 cgc.cmd[10] = s->disckey.agid << 6;
1255
1256 if (!(ret = cdo->generic_packet(cdi, &cgc)))
1257 memcpy(s->disckey.value, &buf[4], sizeof(s->disckey.value));
1258
1259 kfree(buf);
1260 return ret;
1261 }
1262
1263 static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s)
1264 {
1265 int ret;
1266 u_char buf[4 + 188];
1267 struct cdrom_generic_command cgc;
1268 struct cdrom_device_ops *cdo = cdi->ops;
1269
1270 init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
1271 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1272 cgc.cmd[7] = s->type;
1273 cgc.cmd[9] = cgc.buflen = 0xff;
1274
1275 if ((ret = cdo->generic_packet(cdi, &cgc)))
1276 return ret;
1277
1278 s->bca.len = buf[0] << 8 | buf[1];
1279 if (s->bca.len < 12 || s->bca.len > 188) {
1280 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len);
1281 return -EIO;
1282 }
1283 memcpy(s->bca.value, &buf[4], s->bca.len);
1284
1285 return 0;
1286 }
1287
1288 static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s)
1289 {
1290 int ret = 0, size;
1291 u_char *buf;
1292 struct cdrom_generic_command cgc;
1293 struct cdrom_device_ops *cdo = cdi->ops;
1294
1295 size = sizeof(s->manufact.value) + 4;
1296
1297 if ((buf = (u_char *) kmalloc(size, GFP_KERNEL)) == NULL)
1298 return -ENOMEM;
1299
1300 init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
1301 cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
1302 cgc.cmd[7] = s->type;
1303 cgc.cmd[8] = size >> 8;
1304 cgc.cmd[9] = size & 0xff;
1305
1306 if ((ret = cdo->generic_packet(cdi, &cgc))) {
1307 kfree(buf);
1308 return ret;
1309 }
1310
1311 s->manufact.len = buf[0] << 8 | buf[1];
1312 if (s->manufact.len < 0 || s->manufact.len > 2048) {
1313 cdinfo(CD_WARNING, "Received invalid manufacture info length"
1314 " (%d)\n", s->bca.len);
1315 ret = -EIO;
1316 } else {
1317 memcpy(s->manufact.value, &buf[4], s->manufact.len);
1318 }
1319
1320 kfree(buf);
1321 return ret;
1322 }
1323
1324 static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s)
1325 {
1326 switch (s->type) {
1327 case DVD_STRUCT_PHYSICAL:
1328 return dvd_read_physical(cdi, s);
1329
1330 case DVD_STRUCT_COPYRIGHT:
1331 return dvd_read_copyright(cdi, s);
1332
1333 case DVD_STRUCT_DISCKEY:
1334 return dvd_read_disckey(cdi, s);
1335
1336 case DVD_STRUCT_BCA:
1337 return dvd_read_bca(cdi, s);
1338
1339 case DVD_STRUCT_MANUFACT:
1340 return dvd_read_manufact(cdi, s);
1341
1342 default:
1343 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1344 s->type);
1345 return -EINVAL;
1346 }
1347 }
1348
1349 int cdrom_mode_sense(struct cdrom_device_info *cdi,
1350 struct cdrom_generic_command *cgc,
1351 int page_code, int page_control)
1352 {
1353 struct cdrom_device_ops *cdo = cdi->ops;
1354
1355 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1356
1357 cgc->cmd[0] = GPCMD_MODE_SENSE_10;
1358 cgc->cmd[2] = page_code | (page_control << 6);
1359 cgc->cmd[7] = cgc->buflen >> 8;
1360 cgc->cmd[8] = cgc->buflen & 0xff;
1361 cgc->data_direction = CGC_DATA_READ;
1362 return cdo->generic_packet(cdi, cgc);
1363 }
1364
1365 int cdrom_mode_select(struct cdrom_device_info *cdi,
1366 struct cdrom_generic_command *cgc)
1367 {
1368 struct cdrom_device_ops *cdo = cdi->ops;
1369
1370 memset(cgc->cmd, 0, sizeof(cgc->cmd));
1371 memset(cgc->buffer, 0, 2);
1372 cgc->cmd[0] = GPCMD_MODE_SELECT_10;
1373 cgc->cmd[1] = 0x10; /* PF */
1374 cgc->cmd[7] = cgc->buflen >> 8;
1375 cgc->cmd[8] = cgc->buflen & 0xff;
1376 cgc->data_direction = CGC_DATA_WRITE;
1377 return cdo->generic_packet(cdi, cgc);
1378 }
1379
1380 static int cdrom_read_subchannel(struct cdrom_device_info *cdi,
1381 struct cdrom_subchnl *subchnl, int mcn)
1382 {
1383 struct cdrom_device_ops *cdo = cdi->ops;
1384 struct cdrom_generic_command cgc;
1385 char buffer[32];
1386 int ret;
1387
1388 init_cdrom_command(&cgc, buffer, 16, CGC_DATA_READ);
1389 cgc.cmd[0] = GPCMD_READ_SUBCHANNEL;
1390 cgc.cmd[1] = 2; /* MSF addressing */
1391 cgc.cmd[2] = 0x40; /* request subQ data */
1392 cgc.cmd[3] = mcn ? 2 : 1;
1393 cgc.cmd[8] = 16;
1394
1395 if ((ret = cdo->generic_packet(cdi, &cgc)))
1396 return ret;
1397
1398 subchnl->cdsc_audiostatus = cgc.buffer[1];
1399 subchnl->cdsc_format = CDROM_MSF;
1400 subchnl->cdsc_ctrl = cgc.buffer[5] & 0xf;
1401 subchnl->cdsc_trk = cgc.buffer[6];
1402 subchnl->cdsc_ind = cgc.buffer[7];
1403
1404 subchnl->cdsc_reladdr.msf.minute = cgc.buffer[13];
1405 subchnl->cdsc_reladdr.msf.second = cgc.buffer[14];
1406 subchnl->cdsc_reladdr.msf.frame = cgc.buffer[15];
1407 subchnl->cdsc_absaddr.msf.minute = cgc.buffer[9];
1408 subchnl->cdsc_absaddr.msf.second = cgc.buffer[10];
1409 subchnl->cdsc_absaddr.msf.frame = cgc.buffer[11];
1410
1411 return 0;
1412 }
1413
1414 /*
1415 * Specific READ_10 interface
1416 */
1417 static int cdrom_read_cd(struct cdrom_device_info *cdi,
1418 struct cdrom_generic_command *cgc, int lba,
1419 int blocksize, int nblocks)
1420 {
1421 struct cdrom_device_ops *cdo = cdi->ops;
1422
1423 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
1424 cgc->cmd[0] = GPCMD_READ_10;
1425 cgc->cmd[2] = (lba >> 24) & 0xff;
1426 cgc->cmd[3] = (lba >> 16) & 0xff;
1427 cgc->cmd[4] = (lba >> 8) & 0xff;
1428 cgc->cmd[5] = lba & 0xff;
1429 cgc->cmd[6] = (nblocks >> 16) & 0xff;
1430 cgc->cmd[7] = (nblocks >> 8) & 0xff;
1431 cgc->cmd[8] = nblocks & 0xff;
1432 cgc->buflen = blocksize * nblocks;
1433 return cdo->generic_packet(cdi, cgc);
1434 }
1435
1436 /* very generic interface for reading the various types of blocks */
1437 static int cdrom_read_block(struct cdrom_device_info *cdi,
1438 struct cdrom_generic_command *cgc,
1439 int lba, int nblocks, int format, int blksize)
1440 {
1441 struct cdrom_device_ops *cdo = cdi->ops;
1442
1443 memset(&cgc->cmd, 0, sizeof(cgc->cmd));
1444 cgc->cmd[0] = GPCMD_READ_CD;
1445 /* expected sector size - cdda,mode1,etc. */
1446 cgc->cmd[1] = format << 2;
1447 /* starting address */
1448 cgc->cmd[2] = (lba >> 24) & 0xff;
1449 cgc->cmd[3] = (lba >> 16) & 0xff;
1450 cgc->cmd[4] = (lba >> 8) & 0xff;
1451 cgc->cmd[5] = lba & 0xff;
1452 /* number of blocks */
1453 cgc->cmd[6] = (nblocks >> 16) & 0xff;
1454 cgc->cmd[7] = (nblocks >> 8) & 0xff;
1455 cgc->cmd[8] = nblocks & 0xff;
1456 cgc->buflen = blksize * nblocks;
1457
1458 /* set the header info returned */
1459 switch (blksize) {
1460 case CD_FRAMESIZE_RAW0 : cgc->cmd[9] = 0x58; break;
1461 case CD_FRAMESIZE_RAW1 : cgc->cmd[9] = 0x78; break;
1462 case CD_FRAMESIZE_RAW : cgc->cmd[9] = 0xf8; break;
1463 default : cgc->cmd[9] = 0x10;
1464 }
1465
1466 return cdo->generic_packet(cdi, cgc);
1467 }
1468
1469 /* Just about every imaginable ioctl is supported in the Uniform layer
1470 * these days. ATAPI / SCSI specific code now mainly resides in
1471 * mmc_ioct().
1472 */
1473 static int cdrom_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
1474 unsigned long arg)
1475 {
1476 kdev_t dev = ip->i_rdev;
1477 struct cdrom_device_info *cdi = cdrom_find_device(dev);
1478 struct cdrom_device_ops *cdo = cdi->ops;
1479 int ret;
1480
1481 /* the first few commands do not deal with audio drive_info, but
1482 only with routines in cdrom device operations. */
1483 switch (cmd) {
1484 case CDROMMULTISESSION: {
1485 struct cdrom_multisession ms_info;
1486 u_char requested_format;
1487 cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
1488 if (!(cdo->capability & CDC_MULTI_SESSION))
1489 return -ENOSYS;
1490 IOCTL_IN(arg, struct cdrom_multisession, ms_info);
1491 requested_format = ms_info.addr_format;
1492 if (!((requested_format == CDROM_MSF) ||
1493 (requested_format == CDROM_LBA)))
1494 return -EINVAL;
1495 ms_info.addr_format = CDROM_LBA;
1496 if ((ret=cdo->get_last_session(cdi, &ms_info)))
1497 return ret;
1498 sanitize_format(&ms_info.addr, &ms_info.addr_format,
1499 requested_format);
1500 IOCTL_OUT(arg, struct cdrom_multisession, ms_info);
1501 cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
1502 return 0;
1503 }
1504
1505 case CDROMEJECT: {
1506 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
1507 if (!CDROM_CAN(CDC_OPEN_TRAY))
1508 return -ENOSYS;
1509 if (cdi->use_count != 1 || keeplocked)
1510 return -EBUSY;
1511 if (CDROM_CAN(CDC_LOCK))
1512 if ((ret=cdo->lock_door(cdi, 0)))
1513 return ret;
1514
1515 return cdo->tray_move(cdi, 1);
1516 }
1517
1518 case CDROMCLOSETRAY: {
1519 cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
1520 if (!CDROM_CAN(CDC_CLOSE_TRAY))
1521 return -ENOSYS;
1522 return cdo->tray_move(cdi, 0);
1523 }
1524
1525 case CDROMEJECT_SW: {
1526 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
1527 if (!CDROM_CAN(CDC_OPEN_TRAY))
1528 return -ENOSYS;
1529 if (keeplocked)
1530 return -EBUSY;
1531 cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
1532 if (arg)
1533 cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
1534 return 0;
1535 }
1536
1537 case CDROM_MEDIA_CHANGED: {
1538 struct cdrom_changer_info info;
1539
1540 cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
1541 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
1542 return -ENOSYS;
1543
1544 /* cannot select disc or select current disc */
1545 if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
1546 return media_changed(cdi, 1);
1547
1548 if ((unsigned int)arg >= cdi->capacity)
1549 return -EINVAL;
1550
1551 if ((ret = cdrom_read_mech_status(cdi, &info)))
1552 return ret;
1553
1554 return info.slots[arg].change;
1555 }
1556
1557 case CDROM_SET_OPTIONS: {
1558 cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
1559 /* options need to be in sync with capability. too late for
1560 that, so we have to check each one separately... */
1561 switch (arg) {
1562 case CDO_USE_FFLAGS:
1563 case CDO_CHECK_TYPE:
1564 break;
1565 case CDO_LOCK:
1566 if (!CDROM_CAN(CDC_LOCK))
1567 return -ENOSYS;
1568 break;
1569 case 0:
1570 return cdi->options;
1571 /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
1572 default:
1573 if (!CDROM_CAN(arg))
1574 return -ENOSYS;
1575 }
1576 cdi->options |= (int) arg;
1577 return cdi->options;
1578 }
1579
1580 case CDROM_CLEAR_OPTIONS: {
1581 cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
1582 cdi->options &= ~(int) arg;
1583 return cdi->options;
1584 }
1585
1586 case CDROM_SELECT_SPEED: {
1587 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
1588 if (!CDROM_CAN(CDC_SELECT_SPEED))
1589 return -ENOSYS;
1590 return cdo->select_speed(cdi, arg);
1591 }
1592
1593 case CDROM_SELECT_DISC: {
1594 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
1595 if (!CDROM_CAN(CDC_SELECT_DISC))
1596 return -ENOSYS;
1597
1598 if ((arg != CDSL_CURRENT) && (arg != CDSL_NONE))
1599 if ((int)arg >= cdi->capacity)
1600 return -EINVAL;
1601
1602 /* cdo->select_disc is a hook to allow a driver-specific
1603 * way of seleting disc. However, since there is no
1604 * equiv hook for cdrom_slot_status this may not
1605 * actually be useful...
1606 */
1607 if (cdo->select_disc != NULL)
1608 return cdo->select_disc(cdi, arg);
1609
1610 /* no driver specific select_disc(), call our own */
1611 cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
1612 return cdrom_select_disc(cdi, arg);
1613 }
1614
1615 case CDROMRESET: {
1616 if (!capable(CAP_SYS_ADMIN))
1617 return -EACCES;
1618 cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
1619 if (!CDROM_CAN(CDC_RESET))
1620 return -ENOSYS;
1621 return cdo->reset(cdi);
1622 }
1623
1624 case CDROM_LOCKDOOR: {
1625 cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
1626 if (!CDROM_CAN(CDC_LOCK))
1627 return -EDRIVE_CANT_DO_THIS;
1628 keeplocked = arg ? 1 : 0;
1629 /* don't unlock the door on multiple opens,but allow root
1630 * to do so */
1631 if ((cdi->use_count != 1) && !arg && !capable(CAP_SYS_ADMIN))
1632 return -EBUSY;
1633 return cdo->lock_door(cdi, arg);
1634 }
1635
1636 case CDROM_DEBUG: {
1637 if (!capable(CAP_SYS_ADMIN))
1638 return -EACCES;
1639 cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
1640 debug = arg ? 1 : 0;
1641 return debug;
1642 }
1643
1644 case CDROM_GET_CAPABILITY: {
1645 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
1646 return (cdo->capability & ~cdi->mask);
1647 }
1648
1649 /* The following function is implemented, although very few audio
1650 * discs give Universal Product Code information, which should just be
1651 * the Medium Catalog Number on the box. Note, that the way the code
1652 * is written on the CD is /not/ uniform across all discs!
1653 */
1654 case CDROM_GET_MCN: {
1655 struct cdrom_mcn mcn;
1656 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
1657 if (!(cdo->capability & CDC_MCN))
1658 return -ENOSYS;
1659 if ((ret=cdo->get_mcn(cdi, &mcn)))
1660 return ret;
1661 IOCTL_OUT(arg, struct cdrom_mcn, mcn);
1662 cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
1663 return 0;
1664 }
1665
1666 case CDROM_DRIVE_STATUS: {
1667 cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
1668 if (!(cdo->capability & CDC_DRIVE_STATUS))
1669 return -ENOSYS;
1670 if (!CDROM_CAN(CDC_SELECT_DISC))
1671 return cdo->drive_status(cdi, CDSL_CURRENT);
1672 if ((arg == CDSL_CURRENT) || (arg == CDSL_NONE))
1673 return cdo->drive_status(cdi, CDSL_CURRENT);
1674 if (((int)arg >= cdi->capacity))
1675 return -EINVAL;
1676 return cdrom_slot_status(cdi, arg);
1677 }
1678
1679 /* Ok, this is where problems start. The current interface for the
1680 CDROM_DISC_STATUS ioctl is flawed. It makes the false assumption
1681 that CDs are all CDS_DATA_1 or all CDS_AUDIO, etc. Unfortunatly,
1682 while this is often the case, it is also very common for CDs to
1683 have some tracks with data, and some tracks with audio. Just
1684 because I feel like it, I declare the following to be the best
1685 way to cope. If the CD has ANY data tracks on it, it will be
1686 returned as a data CD. If it has any XA tracks, I will return
1687 it as that. Now I could simplify this interface by combining these
1688 returns with the above, but this more clearly demonstrates
1689 the problem with the current interface. Too bad this wasn't
1690 designed to use bitmasks... -Erik
1691
1692 Well, now we have the option CDS_MIXED: a mixed-type CD.
1693 User level programmers might feel the ioctl is not very useful.
1694 ---david
1695 */
1696 case CDROM_DISC_STATUS: {
1697 tracktype tracks;
1698 cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
1699 cdrom_count_tracks(cdi, &tracks);
1700 if (tracks.error)
1701 return(tracks.error);
1702
1703 /* Policy mode on */
1704 if (tracks.audio > 0) {
1705 if (tracks.data==0 && tracks.cdi==0 && tracks.xa==0)
1706 return CDS_AUDIO;
1707 else
1708 return CDS_MIXED;
1709 }
1710 if (tracks.cdi > 0) return CDS_XA_2_2;
1711 if (tracks.xa > 0) return CDS_XA_2_1;
1712 if (tracks.data > 0) return CDS_DATA_1;
1713 /* Policy mode off */
1714
1715 cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
1716 return CDS_NO_INFO;
1717 }
1718
1719 case CDROM_CHANGER_NSLOTS: {
1720 cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
1721 return cdi->capacity;
1722 }
1723 }
1724
1725 /* use the ioctls that are implemented through the generic_packet()
1726 interface. this may look at bit funny, but if -ENOTTY is
1727 returned that particular ioctl is not implemented and we
1728 let it go through the device specific ones. */
1729 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
1730 ret = mmc_ioctl(cdi, cmd, arg);
1731 if (ret != -ENOTTY) {
1732 return ret;
1733 }
1734 }
1735
1736 /* note: most of the cdinfo() calls are commented out here,
1737 because they fill up the sys log when CD players poll
1738 the drive. */
1739 switch (cmd) {
1740 case CDROMSUBCHNL: {
1741 struct cdrom_subchnl q;
1742 u_char requested, back;
1743 if (!CDROM_CAN(CDC_PLAY_AUDIO))
1744 return -ENOSYS;
1745 /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
1746 IOCTL_IN(arg, struct cdrom_subchnl, q);
1747 requested = q.cdsc_format;
1748 if (!((requested == CDROM_MSF) ||
1749 (requested == CDROM_LBA)))
1750 return -EINVAL;
1751 q.cdsc_format = CDROM_MSF;
1752 if ((ret=cdo->audio_ioctl(cdi, cmd, &q)))
1753 return ret;
1754 back = q.cdsc_format; /* local copy */
1755 sanitize_format(&q.cdsc_absaddr, &back, requested);
1756 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
1757 IOCTL_OUT(arg, struct cdrom_subchnl, q);
1758 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
1759 return 0;
1760 }
1761 case CDROMREADTOCHDR: {
1762 struct cdrom_tochdr header;
1763 if (!CDROM_CAN(CDC_PLAY_AUDIO))
1764 return -ENOSYS;
1765 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
1766 IOCTL_IN(arg, struct cdrom_tochdr, header);
1767 if ((ret=cdo->audio_ioctl(cdi, cmd, &header)))
1768 return ret;
1769 IOCTL_OUT(arg, struct cdrom_tochdr, header);
1770 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
1771 return 0;
1772 }
1773 case CDROMREADTOCENTRY: {
1774 struct cdrom_tocentry entry;
1775 u_char requested_format;
1776 if (!CDROM_CAN(CDC_PLAY_AUDIO))
1777 return -ENOSYS;
1778 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
1779 IOCTL_IN(arg, struct cdrom_tocentry, entry);
1780 requested_format = entry.cdte_format;
1781 if (!((requested_format == CDROM_MSF) ||
1782 (requested_format == CDROM_LBA)))
1783 return -EINVAL;
1784 /* make interface to low-level uniform */
1785 entry.cdte_format = CDROM_MSF;
1786 if ((ret=cdo->audio_ioctl(cdi, cmd, &entry)))
1787 return ret;
1788 sanitize_format(&entry.cdte_addr,
1789 &entry.cdte_format, requested_format);
1790 IOCTL_OUT(arg, struct cdrom_tocentry, entry);
1791 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
1792 return 0;
1793 }
1794 case CDROMPLAYMSF: {
1795 struct cdrom_msf msf;
1796 if (!CDROM_CAN(CDC_PLAY_AUDIO))
1797 return -ENOSYS;
1798 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
1799 IOCTL_IN(arg, struct cdrom_msf, msf);
1800 return cdo->audio_ioctl(cdi, cmd, &msf);
1801 }
1802 case CDROMPLAYTRKIND: {
1803 struct cdrom_ti ti;
1804 if (!CDROM_CAN(CDC_PLAY_AUDIO))
1805 return -ENOSYS;
1806 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
1807 IOCTL_IN(arg, struct cdrom_ti, ti);
1808 CHECKAUDIO;
1809 return cdo->audio_ioctl(cdi, cmd, &ti);
1810 }
1811 case CDROMVOLCTRL: {
1812 struct cdrom_volctrl volume;
1813 if (!CDROM_CAN(CDC_PLAY_AUDIO))
1814 return -ENOSYS;
1815 cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
1816 IOCTL_IN(arg, struct cdrom_volctrl, volume);
1817 return cdo->audio_ioctl(cdi, cmd, &volume);
1818 }
1819 case CDROMVOLREAD: {
1820 struct cdrom_volctrl volume;
1821 if (!CDROM_CAN(CDC_PLAY_AUDIO))
1822 return -ENOSYS;
1823 cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
1824 if ((ret=cdo->audio_ioctl(cdi, cmd, &volume)))
1825 return ret;
1826 IOCTL_OUT(arg, struct cdrom_volctrl, volume);
1827 return 0;
1828 }
1829 case CDROMSTART:
1830 case CDROMSTOP:
1831 case CDROMPAUSE:
1832 case CDROMRESUME: {
1833 if (!CDROM_CAN(CDC_PLAY_AUDIO))
1834 return -ENOSYS;
1835 cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
1836 CHECKAUDIO;
1837 return cdo->audio_ioctl(cdi, cmd, NULL);
1838 }
1839 } /* switch */
1840
1841 /* do the device specific ioctls */
1842 if (CDROM_CAN(CDC_IOCTLS))
1843 return cdo->dev_ioctl(cdi, cmd, arg);
1844
1845 return -ENOSYS;
1846 }
1847
1848 static inline
1849 int msf_to_lba(char m, char s, char f)
1850 {
1851 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
1852 }
1853
1854 /*
1855 * Required when we need to use READ_10 to issue other than 2048 block
1856 * reads
1857 */
1858 static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
1859 {
1860 struct cdrom_device_ops *cdo = cdi->ops;
1861 struct cdrom_generic_command cgc;
1862 struct modesel_head mh;
1863
1864 memset(&mh, 0, sizeof(mh));
1865 mh.block_desc_length = 0x08;
1866 mh.block_length_med = (size >> 8) & 0xff;
1867 mh.block_length_lo = size & 0xff;
1868
1869 memset(&cgc, 0, sizeof(cgc));
1870 cgc.cmd[0] = 0x15;
1871 cgc.cmd[1] = 1 << 4;
1872 cgc.cmd[4] = 12;
1873 cgc.buflen = sizeof(mh);
1874 cgc.buffer = (char *) &mh;
1875 cgc.data_direction = CGC_DATA_WRITE;
1876 mh.block_desc_length = 0x08;
1877 mh.block_length_med = (size >> 8) & 0xff;
1878 mh.block_length_lo = size & 0xff;
1879
1880 return cdo->generic_packet(cdi, &cgc);
1881 }
1882
1883 static int cdrom_do_cmd(struct cdrom_device_info *cdi,
1884 struct cdrom_generic_command *cgc)
1885 {
1886 struct request_sense *usense, sense;
1887 unsigned char *ubuf;
1888 int ret;
1889
1890 if (cgc->data_direction == CGC_DATA_UNKNOWN)
1891 return -EINVAL;
1892
1893 if (cgc->buflen < 0 || cgc->buflen >= 131072)
1894 return -EINVAL;
1895
1896 if ((ubuf = cgc->buffer)) {
1897 cgc->buffer = kmalloc(cgc->buflen, GFP_KERNEL);
1898 if (cgc->buffer == NULL)
1899 return -ENOMEM;
1900 }
1901
1902 usense = cgc->sense;
1903 cgc->sense = &sense;
1904 if (usense && !access_ok(VERIFY_WRITE, usense, sizeof(*usense)))
1905 return -EFAULT;
1906
1907 if (cgc->data_direction == CGC_DATA_READ) {
1908 if (!access_ok(VERIFY_READ, ubuf, cgc->buflen))
1909 return -EFAULT;
1910 } else if (cgc->data_direction == CGC_DATA_WRITE) {
1911 if (copy_from_user(cgc->buffer, ubuf, cgc->buflen)) {
1912 kfree(cgc->buffer);
1913 return -EFAULT;
1914 }
1915 }
1916
1917 ret = cdi->ops->generic_packet(cdi, cgc);
1918 __copy_to_user(usense, cgc->sense, sizeof(*usense));
1919 if (!ret && cgc->data_direction == CGC_DATA_READ)
1920 __copy_to_user(ubuf, cgc->buffer, cgc->buflen);
1921 kfree(cgc->buffer);
1922 return ret;
1923 }
1924
1925 static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
1926 unsigned long arg)
1927 {
1928 struct cdrom_device_ops *cdo = cdi->ops;
1929 struct cdrom_generic_command cgc;
1930 kdev_t dev = cdi->dev;
1931 char buffer[32];
1932 int ret = 0;
1933
1934 memset(&cgc, 0, sizeof(cgc));
1935
1936 /* build a unified command and queue it through
1937 cdo->generic_packet() */
1938 switch (cmd) {
1939 case CDROMREADRAW:
1940 case CDROMREADMODE1:
1941 case CDROMREADMODE2: {
1942 struct cdrom_msf msf;
1943 int blocksize = 0, format = 0, lba;
1944
1945 switch (cmd) {
1946 case CDROMREADRAW:
1947 blocksize = CD_FRAMESIZE_RAW;
1948 break;
1949 case CDROMREADMODE1:
1950 blocksize = CD_FRAMESIZE;
1951 format = 2;
1952 break;
1953 case CDROMREADMODE2:
1954 blocksize = CD_FRAMESIZE_RAW0;
1955 break;
1956 }
1957 IOCTL_IN(arg, struct cdrom_msf, msf);
1958 lba = msf_to_lba(msf.cdmsf_min0,msf.cdmsf_sec0,msf.cdmsf_frame0);
1959 /* FIXME: we need upper bound checking, too!! */
1960 if (lba < 0)
1961 return -EINVAL;
1962 cgc.buffer = (char *) kmalloc(blocksize, GFP_KERNEL);
1963 if (cgc.buffer == NULL)
1964 return -ENOMEM;
1965 cgc.data_direction = CGC_DATA_READ;
1966 ret = cdrom_read_block(cdi, &cgc, lba, 1, format, blocksize);
1967 if (ret) {
1968 /*
1969 * SCSI-II devices are not required to support
1970 * READ_CD, so let's try switching block size
1971 */
1972 /* FIXME: switch back again... */
1973 if ((ret = cdrom_switch_blocksize(cdi, blocksize))) {
1974 kfree(cgc.buffer);
1975 return ret;
1976 }
1977 cgc.sense = NULL;
1978 ret = cdrom_read_cd(cdi, &cgc, lba, blocksize, 1);
1979 ret |= cdrom_switch_blocksize(cdi, blocksize);
1980 }
1981 if (!ret && copy_to_user((char *)arg, cgc.buffer, blocksize))
1982 ret = -EFAULT;
1983 kfree(cgc.buffer);
1984 return ret;
1985 }
1986 case CDROMREADAUDIO: {
1987 struct cdrom_read_audio ra;
1988 int lba;
1989
1990 IOCTL_IN(arg, struct cdrom_read_audio, ra);
1991
1992 if (ra.addr_format == CDROM_MSF)
1993 lba = msf_to_lba(ra.addr.msf.minute,
1994 ra.addr.msf.second,
1995 ra.addr.msf.frame);
1996 else if (ra.addr_format == CDROM_LBA)
1997 lba = ra.addr.lba;
1998 else
1999 return -EINVAL;
2000
2001 /* FIXME: we need upper bound checking, too!! */
2002 if (lba < 0 || ra.nframes <= 0)
2003 return -EINVAL;
2004
2005 if ((cgc.buffer = (char *) kmalloc(CD_FRAMESIZE_RAW, GFP_KERNEL)) == NULL)
2006 return -ENOMEM;
2007
2008 if (!access_ok(VERIFY_WRITE, ra.buf, ra.nframes*CD_FRAMESIZE_RAW)) {
2009 kfree(cgc.buffer);
2010 return -EFAULT;
2011 }
2012 cgc.data_direction = CGC_DATA_READ;
2013 while (ra.nframes > 0) {
2014 ret = cdrom_read_block(cdi, &cgc, lba, 1, 1, CD_FRAMESIZE_RAW);
2015 if (ret) break;
2016 __copy_to_user(ra.buf, cgc.buffer, CD_FRAMESIZE_RAW);
2017 ra.buf += CD_FRAMESIZE_RAW;
2018 ra.nframes--;
2019 lba++;
2020 }
2021 kfree(cgc.buffer);
2022 return ret;
2023 }
2024 case CDROMSUBCHNL: {
2025 struct cdrom_subchnl q;
2026 u_char requested, back;
2027 IOCTL_IN(arg, struct cdrom_subchnl, q);
2028 requested = q.cdsc_format;
2029 if (!((requested == CDROM_MSF) ||
2030 (requested == CDROM_LBA)))
2031 return -EINVAL;
2032 q.cdsc_format = CDROM_MSF;
2033 if ((ret = cdrom_read_subchannel(cdi, &q, 0)))
2034 return ret;
2035 back = q.cdsc_format; /* local copy */
2036 sanitize_format(&q.cdsc_absaddr, &back, requested);
2037 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2038 IOCTL_OUT(arg, struct cdrom_subchnl, q);
2039 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2040 return 0;
2041 }
2042 case CDROMPLAYMSF: {
2043 struct cdrom_msf msf;
2044 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2045 IOCTL_IN(arg, struct cdrom_msf, msf);
2046 cgc.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2047 cgc.cmd[3] = msf.cdmsf_min0;
2048 cgc.cmd[4] = msf.cdmsf_sec0;
2049 cgc.cmd[5] = msf.cdmsf_frame0;
2050 cgc.cmd[6] = msf.cdmsf_min1;
2051 cgc.cmd[7] = msf.cdmsf_sec1;
2052 cgc.cmd[8] = msf.cdmsf_frame1;
2053 cgc.data_direction = CGC_DATA_NONE;
2054 return cdo->generic_packet(cdi, &cgc);
2055 }
2056 case CDROMPLAYBLK: {
2057 struct cdrom_blk blk;
2058 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2059 IOCTL_IN(arg, struct cdrom_blk, blk);
2060 cgc.cmd[0] = GPCMD_PLAY_AUDIO_10;
2061 cgc.cmd[2] = (blk.from >> 24) & 0xff;
2062 cgc.cmd[3] = (blk.from >> 16) & 0xff;
2063 cgc.cmd[4] = (blk.from >> 8) & 0xff;
2064 cgc.cmd[5] = blk.from & 0xff;
2065 cgc.cmd[7] = (blk.len >> 8) & 0xff;
2066 cgc.cmd[8] = blk.len & 0xff;
2067 cgc.data_direction = CGC_DATA_NONE;
2068 return cdo->generic_packet(cdi, &cgc);
2069 }
2070 case CDROMVOLCTRL:
2071 case CDROMVOLREAD: {
2072 struct cdrom_volctrl volctrl;
2073 char mask[32];
2074 unsigned short offset;
2075 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n");
2076
2077 IOCTL_IN(arg, struct cdrom_volctrl, volctrl);
2078
2079 cgc.buffer = buffer;
2080 cgc.buflen = 24;
2081 if ((ret = cdrom_mode_sense(cdi, &cgc, GPMODE_AUDIO_CTL_PAGE, 0)))
2082 return ret;
2083
2084 /* some drives have longer pages, adjust and reread. */
2085 if (buffer[1] > cgc.buflen) {
2086 cgc.buflen = buffer[1] + 2;
2087 if ((ret = cdrom_mode_sense(cdi, &cgc,
2088 GPMODE_AUDIO_CTL_PAGE, 0)))
2089 return ret;
2090 }
2091
2092 /* get the offset from the length of the page. length
2093 is measure from byte 2 an on, thus the 14. */
2094 offset = buffer[1] - 14;
2095
2096 /* now we have the current volume settings. if it was only
2097 a CDROMVOLREAD, return these values */
2098 if (cmd == CDROMVOLREAD) {
2099 volctrl.channel0 = buffer[offset+9];
2100 volctrl.channel1 = buffer[offset+11];
2101 volctrl.channel2 = buffer[offset+13];
2102 volctrl.channel3 = buffer[offset+15];
2103 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl);
2104 return 0;
2105 }
2106
2107 /* get the volume mask */
2108 cgc.buffer = mask;
2109 if ((ret = cdrom_mode_sense(cdi, &cgc,
2110 GPMODE_AUDIO_CTL_PAGE, 1)))
2111 return ret;
2112
2113 buffer[offset+9] = volctrl.channel0 & mask[offset+9];
2114 buffer[offset+11] = volctrl.channel1 & mask[offset+11];
2115 buffer[offset+13] = volctrl.channel2 & mask[offset+13];
2116 buffer[offset+15] = volctrl.channel3 & mask[offset+15];
2117
2118 /* set volume */
2119 cgc.buffer = buffer;
2120 return cdrom_mode_select(cdi, &cgc);
2121 }
2122
2123 case CDROMSTART:
2124 case CDROMSTOP: {
2125 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
2126 cgc.cmd[0] = GPCMD_START_STOP_UNIT;
2127 cgc.cmd[1] = 1;
2128 cgc.cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
2129 cgc.data_direction = CGC_DATA_NONE;
2130 return cdo->generic_packet(cdi, &cgc);
2131 }
2132
2133 case CDROMPAUSE:
2134 case CDROMRESUME: {
2135 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
2136 cgc.cmd[0] = GPCMD_PAUSE_RESUME;
2137 cgc.cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
2138 cgc.data_direction = CGC_DATA_NONE;
2139 return cdo->generic_packet(cdi, &cgc);
2140 }
2141
2142 case DVD_READ_STRUCT: {
2143 dvd_struct *s;
2144 int size = sizeof(dvd_struct);
2145 if (!CDROM_CAN(CDC_DVD))
2146 return -ENOSYS;
2147 if ((s = (dvd_struct *) kmalloc(size, GFP_KERNEL)) == NULL)
2148 return -ENOMEM;
2149 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
2150 if (copy_from_user(s, (dvd_struct *)arg, size)) {
2151 kfree(s);
2152 return -EFAULT;
2153 }
2154 if ((ret = dvd_read_struct(cdi, s))) {
2155 kfree(s);
2156 return ret;
2157 }
2158 if (copy_to_user((dvd_struct *)arg, s, size))
2159 ret = -EFAULT;
2160 kfree(s);
2161 return ret;
2162 }
2163
2164 case DVD_AUTH: {
2165 dvd_authinfo ai;
2166 if (!CDROM_CAN(CDC_DVD))
2167 return -ENOSYS;
2168 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n");
2169 IOCTL_IN(arg, dvd_authinfo, ai);
2170 if ((ret = dvd_do_auth (cdi, &ai)))
2171 return ret;
2172 IOCTL_OUT(arg, dvd_authinfo, ai);
2173 return 0;
2174 }
2175
2176 case CDROM_SEND_PACKET: {
2177 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2178 return -ENOSYS;
2179 cdinfo(CD_DO_IOCTL, "entering CDROM_SEND_PACKET\n");
2180 IOCTL_IN(arg, struct cdrom_generic_command, cgc);
2181 return cdrom_do_cmd(cdi, &cgc);
2182 }
2183 case CDROM_NEXT_WRITABLE: {
2184 long next = 0;
2185 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
2186 if ((ret = cdrom_get_next_writable(dev, &next)))
2187 return ret;
2188 IOCTL_OUT(arg, long, next);
2189 return 0;
2190 }
2191 case CDROM_LAST_WRITTEN: {
2192 long last = 0;
2193 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
2194 if ((ret = cdrom_get_last_written(dev, &last)))
2195 return ret;
2196 IOCTL_OUT(arg, long, last);
2197 return 0;
2198 }
2199 } /* switch */
2200
2201 return -ENOTTY;
2202 }
2203
2204 int cdrom_get_track_info(kdev_t dev, __u16 track, __u8 type,
2205 track_information *ti)
2206 {
2207 struct cdrom_device_info *cdi = cdrom_find_device(dev);
2208 struct cdrom_device_ops *cdo = cdi->ops;
2209 struct cdrom_generic_command cgc;
2210 int ret;
2211
2212 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
2213 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
2214 cgc.cmd[1] = type & 3;
2215 cgc.cmd[4] = (track & 0xff00) >> 8;
2216 cgc.cmd[5] = track & 0xff;
2217 cgc.cmd[8] = 8;
2218 cgc.quiet = 1;
2219
2220 if ((ret = cdo->generic_packet(cdi, &cgc)))
2221 return ret;
2222
2223 cgc.cmd[8] = cgc.buflen = be16_to_cpu(ti->track_information_length) +
2224 sizeof(ti->track_information_length);
2225 return cdo->generic_packet(cdi, &cgc);
2226 }
2227
2228 /* requires CD R/RW */
2229 int cdrom_get_disc_info(kdev_t dev, disc_information *di)
2230 {
2231 struct cdrom_device_info *cdi = cdrom_find_device(dev);
2232 struct cdrom_device_ops *cdo = cdi->ops;
2233 struct cdrom_generic_command cgc;
2234 int ret;
2235
2236 /* set up command and get the disc info */
2237 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
2238 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
2239 cgc.cmd[8] = cgc.buflen = 2;
2240 cgc.quiet = 1;
2241
2242 if ((ret = cdo->generic_packet(cdi, &cgc)))
2243 return ret;
2244
2245 /* not all drives have the same disc_info length, so requeue
2246 * packet with the length the drive tells us it can supply
2247 */
2248 cgc.buflen = be16_to_cpu(di->disc_information_length) +
2249 sizeof(di->disc_information_length);
2250
2251 if (cgc.buflen > sizeof(disc_information))
2252 cgc.buflen = sizeof(disc_information);
2253
2254 cgc.cmd[8] = cgc.buflen;
2255 return cdo->generic_packet(cdi, &cgc);
2256 }
2257
2258
2259 /* return the last written block on the CD-R media. this is for the udf
2260 file system. */
2261 int cdrom_get_last_written(kdev_t dev, long *last_written)
2262 {
2263 struct cdrom_device_info *cdi = cdrom_find_device(dev);
2264 struct cdrom_tocentry toc;
2265 disc_information di;
2266 track_information ti;
2267 __u32 last_track;
2268 int ret = -1;
2269
2270 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2271 goto use_toc;
2272
2273 if ((ret = cdrom_get_disc_info(dev, &di)))
2274 goto use_toc;
2275
2276 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2277 if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti)))
2278 goto use_toc;
2279
2280 /* if this track is blank, try the previous. */
2281 if (ti.blank) {
2282 last_track--;
2283 if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti)))
2284 goto use_toc;
2285 }
2286
2287 /* if last recorded field is valid, return it. */
2288 if (ti.lra_v) {
2289 *last_written = be32_to_cpu(ti.last_rec_address);
2290 } else {
2291 /* make it up instead */
2292 *last_written = be32_to_cpu(ti.track_start) +
2293 be32_to_cpu(ti.track_size);
2294 if (ti.free_blocks)
2295 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
2296 }
2297 return 0;
2298
2299 /* this is where we end up if the drive either can't do a
2300 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
2301 it fails. then we return the toc contents. */
2302 use_toc:
2303 toc.cdte_format = CDROM_MSF;
2304 toc.cdte_track = CDROM_LEADOUT;
2305 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc))
2306 return ret;
2307 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
2308 *last_written = toc.cdte_addr.lba;
2309 return 0;
2310 }
2311
2312 /* return the next writable block. also for udf file system. */
2313 int cdrom_get_next_writable(kdev_t dev, long *next_writable)
2314 {
2315 struct cdrom_device_info *cdi = cdrom_find_device(dev);
2316 disc_information di;
2317 track_information ti;
2318 __u16 last_track;
2319 int ret = -1;
2320
2321 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2322 goto use_last_written;
2323
2324 if ((ret = cdrom_get_disc_info(dev, &di)))
2325 goto use_last_written;
2326
2327 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2328 if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti)))
2329 goto use_last_written;
2330
2331 /* if this track is blank, try the previous. */
2332 if (ti.blank) {
2333 last_track--;
2334 if ((ret = cdrom_get_track_info(dev, last_track, 1, &ti)))
2335 goto use_last_written;
2336 }
2337
2338 /* if next recordable address field is valid, use it. */
2339 if (ti.nwa_v)
2340 *next_writable = be32_to_cpu(ti.next_writable);
2341 else
2342 goto use_last_written;
2343
2344 return 0;
2345
2346 use_last_written:
2347 if ((ret = cdrom_get_last_written(dev, next_writable))) {
2348 *next_writable = 0;
2349 return ret;
2350 } else {
2351 *next_writable += 7;
2352 return 0;
2353 }
2354 }
2355
2356 EXPORT_SYMBOL(cdrom_get_disc_info);
2357 EXPORT_SYMBOL(cdrom_get_track_info);
2358 EXPORT_SYMBOL(cdrom_get_next_writable);
2359 EXPORT_SYMBOL(cdrom_get_last_written);
2360 EXPORT_SYMBOL(cdrom_count_tracks);
2361 EXPORT_SYMBOL(register_cdrom);
2362 EXPORT_SYMBOL(unregister_cdrom);
2363 EXPORT_SYMBOL(cdrom_fops);
2364 EXPORT_SYMBOL(cdrom_number_of_slots);
2365 EXPORT_SYMBOL(cdrom_select_disc);
2366 EXPORT_SYMBOL(cdrom_mode_select);
2367 EXPORT_SYMBOL(cdrom_mode_sense);
2368 EXPORT_SYMBOL(init_cdrom_command);
2369 EXPORT_SYMBOL(cdrom_find_device);
2370
2371 #ifdef CONFIG_SYSCTL
2372
2373 #define CDROM_STR_SIZE 1000
2374
2375 struct cdrom_sysctl_settings {
2376 char info[CDROM_STR_SIZE]; /* general info */
2377 int autoclose; /* close tray upon mount, etc */
2378 int autoeject; /* eject on umount */
2379 int debug; /* turn on debugging messages */
2380 int lock; /* lock the door on device open */
2381 int check; /* check media type */
2382 } cdrom_sysctl_settings;
2383
2384 int cdrom_sysctl_info(ctl_table *ctl, int write, struct file * filp,
2385 void *buffer, size_t *lenp)
2386 {
2387 int pos;
2388 struct cdrom_device_info *cdi;
2389 char *info = cdrom_sysctl_settings.info;
2390
2391 if (!*lenp || (filp->f_pos && !write)) {
2392 *lenp = 0;
2393 return 0;
2394 }
2395
2396 pos = sprintf(info, "CD-ROM information, " VERSION "\n");
2397
2398 pos += sprintf(info+pos, "\ndrive name:\t");
2399 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2400 pos += sprintf(info+pos, "\t%s", cdi->name);
2401
2402 pos += sprintf(info+pos, "\ndrive speed:\t");
2403 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2404 pos += sprintf(info+pos, "\t%d", cdi->speed);
2405
2406 pos += sprintf(info+pos, "\ndrive # of slots:");
2407 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2408 pos += sprintf(info+pos, "\t%d", cdi->capacity);
2409
2410 pos += sprintf(info+pos, "\nCan close tray:\t");
2411 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2412 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_CLOSE_TRAY) != 0);
2413
2414 pos += sprintf(info+pos, "\nCan open tray:\t");
2415 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2416 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_OPEN_TRAY) != 0);
2417
2418 pos += sprintf(info+pos, "\nCan lock tray:\t");
2419 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2420 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_LOCK) != 0);
2421
2422 pos += sprintf(info+pos, "\nCan change speed:");
2423 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2424 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_SELECT_SPEED) != 0);
2425
2426 pos += sprintf(info+pos, "\nCan select disk:");
2427 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2428 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_SELECT_DISC) != 0);
2429
2430 pos += sprintf(info+pos, "\nCan read multisession:");
2431 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2432 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MULTI_SESSION) != 0);
2433
2434 pos += sprintf(info+pos, "\nCan read MCN:\t");
2435 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2436 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MCN) != 0);
2437
2438 pos += sprintf(info+pos, "\nReports media changed:");
2439 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2440 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_MEDIA_CHANGED) != 0);
2441
2442 pos += sprintf(info+pos, "\nCan play audio:\t");
2443 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2444 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_PLAY_AUDIO) != 0);
2445
2446 pos += sprintf(info+pos, "\nCan write CD-R:\t");
2447 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2448 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_CD_R) != 0);
2449
2450 pos += sprintf(info+pos, "\nCan write CD-RW:");
2451 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2452 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_CD_RW) != 0);
2453
2454 pos += sprintf(info+pos, "\nCan read DVD:\t");
2455 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2456 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD) != 0);
2457
2458 pos += sprintf(info+pos, "\nCan write DVD-R:");
2459 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2460 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD_R) != 0);
2461
2462 pos += sprintf(info+pos, "\nCan write DVD-RAM:");
2463 for (cdi=topCdromPtr;cdi!=NULL;cdi=cdi->next)
2464 pos += sprintf(info+pos, "\t%d", CDROM_CAN(CDC_DVD_RAM) != 0);
2465
2466 strcpy(info+pos,"\n\n");
2467
2468 return proc_dostring(ctl, write, filp, buffer, lenp);
2469 }
2470
2471 /* Unfortunately, per device settings are not implemented through
2472 procfs/sysctl yet. When they are, this will naturally disappear. For now
2473 just update all drives. Later this will become the template on which
2474 new registered drives will be based. */
2475 void cdrom_update_settings(void)
2476 {
2477 struct cdrom_device_info *cdi;
2478
2479 for (cdi = topCdromPtr; cdi != NULL; cdi = cdi->next) {
2480 if (autoclose && CDROM_CAN(CDC_CLOSE_TRAY))
2481 cdi->options |= CDO_AUTO_CLOSE;
2482 else if (!autoclose)
2483 cdi->options &= ~CDO_AUTO_CLOSE;
2484 if (autoeject && CDROM_CAN(CDC_OPEN_TRAY))
2485 cdi->options |= CDO_AUTO_EJECT;
2486 else if (!autoeject)
2487 cdi->options &= ~CDO_AUTO_EJECT;
2488 if (lockdoor && CDROM_CAN(CDC_LOCK))
2489 cdi->options |= CDO_LOCK;
2490 else if (!lockdoor)
2491 cdi->options &= ~CDO_LOCK;
2492 if (check_media_type)
2493 cdi->options |= CDO_CHECK_TYPE;
2494 else
2495 cdi->options &= ~CDO_CHECK_TYPE;
2496 }
2497 }
2498
2499 static int cdrom_sysctl_handler(ctl_table *ctl, int write, struct file * filp,
2500 void *buffer, size_t *lenp)
2501 {
2502 int *valp = ctl->data;
2503 int val = *valp;
2504 int ret;
2505
2506 ret = proc_dointvec(ctl, write, filp, buffer, lenp);
2507
2508 if (write && *valp != val) {
2509
2510 /* we only care for 1 or 0. */
2511 if (*valp)
2512 *valp = 1;
2513 else
2514 *valp = 0;
2515
2516 switch (ctl->ctl_name) {
2517 case DEV_CDROM_AUTOCLOSE: {
2518 if (valp == &cdrom_sysctl_settings.autoclose)
2519 autoclose = cdrom_sysctl_settings.autoclose;
2520 break;
2521 }
2522 case DEV_CDROM_AUTOEJECT: {
2523 if (valp == &cdrom_sysctl_settings.autoeject)
2524 autoeject = cdrom_sysctl_settings.autoeject;
2525 break;
2526 }
2527 case DEV_CDROM_DEBUG: {
2528 if (valp == &cdrom_sysctl_settings.debug)
2529 debug = cdrom_sysctl_settings.debug;
2530 break;
2531 }
2532 case DEV_CDROM_LOCK: {
2533 if (valp == &cdrom_sysctl_settings.lock)
2534 lockdoor = cdrom_sysctl_settings.lock;
2535 break;
2536 }
2537 case DEV_CDROM_CHECK_MEDIA: {
2538 if (valp == &cdrom_sysctl_settings.check)
2539 check_media_type = cdrom_sysctl_settings.check;
2540 break;
2541 }
2542 }
2543 /* update the option flags according to the changes. we
2544 don't have per device options through sysctl yet,
2545 but we will have and then this will disappear. */
2546 cdrom_update_settings();
2547 }
2548
2549 return ret;
2550 }
2551
2552 /* Place files in /proc/sys/dev/cdrom */
2553 ctl_table cdrom_table[] = {
2554 {DEV_CDROM_INFO, "info", &cdrom_sysctl_settings.info,
2555 CDROM_STR_SIZE, 0444, NULL, &cdrom_sysctl_info},
2556 {DEV_CDROM_AUTOCLOSE, "autoclose", &cdrom_sysctl_settings.autoclose,
2557 sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
2558 {DEV_CDROM_AUTOEJECT, "autoeject", &cdrom_sysctl_settings.autoeject,
2559 sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
2560 {DEV_CDROM_DEBUG, "debug", &cdrom_sysctl_settings.debug,
2561 sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
2562 {DEV_CDROM_LOCK, "lock", &cdrom_sysctl_settings.lock,
2563 sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
2564 {DEV_CDROM_CHECK_MEDIA, "check_media", &cdrom_sysctl_settings.check,
2565 sizeof(int), 0644, NULL, &cdrom_sysctl_handler },
2566 {0}
2567 };
2568
2569 ctl_table cdrom_cdrom_table[] = {
2570 {DEV_CDROM, "cdrom", NULL, 0, 0555, cdrom_table},
2571 {0}
2572 };
2573
2574 /* Make sure that /proc/sys/dev is there */
2575 ctl_table cdrom_root_table[] = {
2576 #ifdef CONFIG_PROC_FS
2577 {CTL_DEV, "dev", NULL, 0, 0555, cdrom_cdrom_table},
2578 #endif /* CONFIG_PROC_FS */
2579 {0}
2580 };
2581 static struct ctl_table_header *cdrom_sysctl_header;
2582
2583 static void cdrom_sysctl_register(void)
2584 {
2585 static int initialized;
2586
2587 if (initialized == 1)
2588 return;
2589
2590 cdrom_sysctl_header = register_sysctl_table(cdrom_root_table, 1);
2591 cdrom_root_table->child->de->owner = THIS_MODULE;
2592
2593 /* set the defaults */
2594 cdrom_sysctl_settings.autoclose = autoclose;
2595 cdrom_sysctl_settings.autoeject = autoeject;
2596 cdrom_sysctl_settings.debug = debug;
2597 cdrom_sysctl_settings.lock = lockdoor;
2598 cdrom_sysctl_settings.check = check_media_type;
2599
2600 initialized = 1;
2601 }
2602
2603 static void cdrom_sysctl_unregister(void)
2604 {
2605 unregister_sysctl_table(cdrom_sysctl_header);
2606 }
2607
2608 #endif /* CONFIG_SYSCTL */
2609
2610 static int __init cdrom_init(void)
2611 {
2612 #ifdef CONFIG_SYSCTL
2613 cdrom_sysctl_register();
2614 #endif
2615 devfs_handle = devfs_mk_dir(NULL, "cdroms", NULL);
2616 return 0;
2617 }
2618
2619 static void __exit cdrom_exit(void)
2620 {
2621 printk(KERN_INFO "Uniform CD-ROM driver unloaded\n");
2622 #ifdef CONFIG_SYSCTL
2623 cdrom_sysctl_unregister();
2624 #endif
2625 devfs_unregister(devfs_handle);
2626 }
2627
2628 module_init(cdrom_init);
2629 module_exit(cdrom_exit);
2630
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.