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