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