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