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