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