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