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