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