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