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