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