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