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