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