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