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