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