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