aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/cdrom
diff options
context:
space:
mode:
authorDmitry Torokhov <dmitry.torokhov@gmail.com>2014-08-07 02:36:12 -0400
committerDmitry Torokhov <dmitry.torokhov@gmail.com>2014-08-07 02:36:12 -0400
commit5e2aa2ed08e2e280121dc7cf5609c87d464f12ef (patch)
treeca7d7b1480285e3b617fecc5b41f0ce150a82c32 /drivers/cdrom
parentf62d14a8072b9756db36ba394e2b267470a40240 (diff)
parentfc8104bc5a3f6f49d79f45f2706f79f77a9fb2ae (diff)
Merge branch 'next' into for-linus
Prepare first round of input updates for 3.17.
Diffstat (limited to 'drivers/cdrom')
-rw-r--r--drivers/cdrom/cdrom.c1283
-rw-r--r--drivers/cdrom/gdrom.c2
2 files changed, 645 insertions, 640 deletions
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 8a3aff724d98..898b84bba28a 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -312,36 +312,24 @@ static const char *mrw_format_status[] = {
312 312
313static const char *mrw_address_space[] = { "DMA", "GAA" }; 313static const char *mrw_address_space[] = { "DMA", "GAA" };
314 314
315#if (ERRLOGMASK!=CD_NOTHING) 315#if (ERRLOGMASK != CD_NOTHING)
316#define cdinfo(type, fmt, args...) \ 316#define cd_dbg(type, fmt, ...) \
317do { \ 317do { \
318 if ((ERRLOGMASK & type) || debug == 1) \ 318 if ((ERRLOGMASK & type) || debug == 1) \
319 pr_info(fmt, ##args); \ 319 pr_debug(fmt, ##__VA_ARGS__); \
320} while (0) 320} while (0)
321#else 321#else
322#define cdinfo(type, fmt, args...) \ 322#define cd_dbg(type, fmt, ...) \
323do { \ 323do { \
324 if (0 && (ERRLOGMASK & type) || debug == 1) \ 324 if (0 && (ERRLOGMASK & type) || debug == 1) \
325 pr_info(fmt, ##args); \ 325 pr_debug(fmt, ##__VA_ARGS__); \
326} while (0) 326} while (0)
327#endif 327#endif
328 328
329/* These are used to simplify getting data in from and back to user land */
330#define IOCTL_IN(arg, type, in) \
331 if (copy_from_user(&(in), (type __user *) (arg), sizeof (in))) \
332 return -EFAULT;
333
334#define IOCTL_OUT(arg, type, out) \
335 if (copy_to_user((type __user *) (arg), &(out), sizeof (out))) \
336 return -EFAULT;
337
338/* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in 329/* The (cdo->capability & ~cdi->mask & CDC_XXX) construct was used in
339 a lot of places. This macro makes the code more clear. */ 330 a lot of places. This macro makes the code more clear. */
340#define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type)) 331#define CDROM_CAN(type) (cdi->ops->capability & ~cdi->mask & (type))
341 332
342/* used in the audio ioctls */
343#define CHECKAUDIO if ((ret=check_for_audio_disc(cdi, cdo))) return ret
344
345/* 333/*
346 * Another popular OS uses 7 seconds as the hard timeout for default 334 * Another popular OS uses 7 seconds as the hard timeout for default
347 * commands, so it is a good choice for us as well. 335 * commands, so it is a good choice for us as well.
@@ -349,21 +337,6 @@ do { \
349#define CDROM_DEF_TIMEOUT (7 * HZ) 337#define CDROM_DEF_TIMEOUT (7 * HZ)
350 338
351/* Not-exported routines. */ 339/* Not-exported routines. */
352static int open_for_data(struct cdrom_device_info * cdi);
353static int check_for_audio_disc(struct cdrom_device_info * cdi,
354 struct cdrom_device_ops * cdo);
355static void sanitize_format(union cdrom_addr *addr,
356 u_char * curr, u_char requested);
357static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
358 unsigned long arg);
359
360int cdrom_get_last_written(struct cdrom_device_info *, long *);
361static int cdrom_get_next_writable(struct cdrom_device_info *, long *);
362static void cdrom_count_tracks(struct cdrom_device_info *, tracktype*);
363
364static int cdrom_mrw_exit(struct cdrom_device_info *cdi);
365
366static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di);
367 340
368static void cdrom_sysctl_register(void); 341static void cdrom_sysctl_register(void);
369 342
@@ -382,113 +355,65 @@ static int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
382 return -EIO; 355 return -EIO;
383} 356}
384 357
385/* This macro makes sure we don't have to check on cdrom_device_ops 358static int cdrom_flush_cache(struct cdrom_device_info *cdi)
386 * existence in the run-time routines below. Change_capability is a
387 * hack to have the capability flags defined const, while we can still
388 * change it here without gcc complaining at every line.
389 */
390#define ENSURE(call, bits) if (cdo->call == NULL) *change_capability &= ~(bits)
391
392int register_cdrom(struct cdrom_device_info *cdi)
393{
394 static char banner_printed;
395 struct cdrom_device_ops *cdo = cdi->ops;
396 int *change_capability = (int *)&cdo->capability; /* hack */
397
398 cdinfo(CD_OPEN, "entering register_cdrom\n");
399
400 if (cdo->open == NULL || cdo->release == NULL)
401 return -EINVAL;
402 if (!banner_printed) {
403 pr_info("Uniform CD-ROM driver " REVISION "\n");
404 banner_printed = 1;
405 cdrom_sysctl_register();
406 }
407
408 ENSURE(drive_status, CDC_DRIVE_STATUS );
409 if (cdo->check_events == NULL && cdo->media_changed == NULL)
410 *change_capability = ~(CDC_MEDIA_CHANGED | CDC_SELECT_DISC);
411 ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
412 ENSURE(lock_door, CDC_LOCK);
413 ENSURE(select_speed, CDC_SELECT_SPEED);
414 ENSURE(get_last_session, CDC_MULTI_SESSION);
415 ENSURE(get_mcn, CDC_MCN);
416 ENSURE(reset, CDC_RESET);
417 ENSURE(generic_packet, CDC_GENERIC_PACKET);
418 cdi->mc_flags = 0;
419 cdo->n_minors = 0;
420 cdi->options = CDO_USE_FFLAGS;
421
422 if (autoclose==1 && CDROM_CAN(CDC_CLOSE_TRAY))
423 cdi->options |= (int) CDO_AUTO_CLOSE;
424 if (autoeject==1 && CDROM_CAN(CDC_OPEN_TRAY))
425 cdi->options |= (int) CDO_AUTO_EJECT;
426 if (lockdoor==1)
427 cdi->options |= (int) CDO_LOCK;
428 if (check_media_type==1)
429 cdi->options |= (int) CDO_CHECK_TYPE;
430
431 if (CDROM_CAN(CDC_MRW_W))
432 cdi->exit = cdrom_mrw_exit;
433
434 if (cdi->disk)
435 cdi->cdda_method = CDDA_BPC_FULL;
436 else
437 cdi->cdda_method = CDDA_OLD;
438
439 if (!cdo->generic_packet)
440 cdo->generic_packet = cdrom_dummy_generic_packet;
441
442 cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
443 mutex_lock(&cdrom_mutex);
444 list_add(&cdi->list, &cdrom_list);
445 mutex_unlock(&cdrom_mutex);
446 return 0;
447}
448#undef ENSURE
449
450void unregister_cdrom(struct cdrom_device_info *cdi)
451{ 359{
452 cdinfo(CD_OPEN, "entering unregister_cdrom\n"); 360 struct packet_command cgc;
453 361
454 mutex_lock(&cdrom_mutex); 362 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
455 list_del(&cdi->list); 363 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
456 mutex_unlock(&cdrom_mutex);
457 364
458 if (cdi->exit) 365 cgc.timeout = 5 * 60 * HZ;
459 cdi->exit(cdi);
460 366
461 cdi->ops->n_minors--; 367 return cdi->ops->generic_packet(cdi, &cgc);
462 cdinfo(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
463} 368}
464 369
465int cdrom_get_media_event(struct cdrom_device_info *cdi, 370/* requires CD R/RW */
466 struct media_event_desc *med) 371static int cdrom_get_disc_info(struct cdrom_device_info *cdi,
372 disc_information *di)
467{ 373{
374 struct cdrom_device_ops *cdo = cdi->ops;
468 struct packet_command cgc; 375 struct packet_command cgc;
469 unsigned char buffer[8]; 376 int ret, buflen;
470 struct event_header *eh = (struct event_header *) buffer;
471 377
472 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ); 378 /* set up command and get the disc info */
473 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION; 379 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
474 cgc.cmd[1] = 1; /* IMMED */ 380 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
475 cgc.cmd[4] = 1 << 4; /* media event */ 381 cgc.cmd[8] = cgc.buflen = 2;
476 cgc.cmd[8] = sizeof(buffer);
477 cgc.quiet = 1; 382 cgc.quiet = 1;
478 383
479 if (cdi->ops->generic_packet(cdi, &cgc)) 384 ret = cdo->generic_packet(cdi, &cgc);
480 return 1; 385 if (ret)
386 return ret;
481 387
482 if (be16_to_cpu(eh->data_len) < sizeof(*med)) 388 /* not all drives have the same disc_info length, so requeue
483 return 1; 389 * packet with the length the drive tells us it can supply
390 */
391 buflen = be16_to_cpu(di->disc_information_length) +
392 sizeof(di->disc_information_length);
484 393
485 if (eh->nea || eh->notification_class != 0x4) 394 if (buflen > sizeof(disc_information))
486 return 1; 395 buflen = sizeof(disc_information);
487 396
488 memcpy(med, &buffer[sizeof(*eh)], sizeof(*med)); 397 cgc.cmd[8] = cgc.buflen = buflen;
489 return 0; 398 ret = cdo->generic_packet(cdi, &cgc);
399 if (ret)
400 return ret;
401
402 /* return actual fill size */
403 return buflen;
490} 404}
491 405
406/* This macro makes sure we don't have to check on cdrom_device_ops
407 * existence in the run-time routines below. Change_capability is a
408 * hack to have the capability flags defined const, while we can still
409 * change it here without gcc complaining at every line.
410 */
411#define ENSURE(call, bits) \
412do { \
413 if (cdo->call == NULL) \
414 *change_capability &= ~(bits); \
415} while (0)
416
492/* 417/*
493 * the first prototypes used 0x2c as the page code for the mrw mode page, 418 * the first prototypes used 0x2c as the page code for the mrw mode page,
494 * subsequently this was changed to 0x03. probe the one used by this drive 419 * subsequently this was changed to 0x03. probe the one used by this drive
@@ -605,18 +530,6 @@ static int cdrom_mrw_bgformat_susp(struct cdrom_device_info *cdi, int immed)
605 return cdi->ops->generic_packet(cdi, &cgc); 530 return cdi->ops->generic_packet(cdi, &cgc);
606} 531}
607 532
608static int cdrom_flush_cache(struct cdrom_device_info *cdi)
609{
610 struct packet_command cgc;
611
612 init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
613 cgc.cmd[0] = GPCMD_FLUSH_CACHE;
614
615 cgc.timeout = 5 * 60 * HZ;
616
617 return cdi->ops->generic_packet(cdi, &cgc);
618}
619
620static int cdrom_mrw_exit(struct cdrom_device_info *cdi) 533static int cdrom_mrw_exit(struct cdrom_device_info *cdi)
621{ 534{
622 disc_information di; 535 disc_information di;
@@ -650,17 +563,19 @@ static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
650 cgc.buffer = buffer; 563 cgc.buffer = buffer;
651 cgc.buflen = sizeof(buffer); 564 cgc.buflen = sizeof(buffer);
652 565
653 if ((ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0))) 566 ret = cdrom_mode_sense(cdi, &cgc, cdi->mrw_mode_page, 0);
567 if (ret)
654 return ret; 568 return ret;
655 569
656 mph = (struct mode_page_header *) buffer; 570 mph = (struct mode_page_header *)buffer;
657 offset = be16_to_cpu(mph->desc_length); 571 offset = be16_to_cpu(mph->desc_length);
658 size = be16_to_cpu(mph->mode_data_length) + 2; 572 size = be16_to_cpu(mph->mode_data_length) + 2;
659 573
660 buffer[offset + 3] = space; 574 buffer[offset + 3] = space;
661 cgc.buflen = size; 575 cgc.buflen = size;
662 576
663 if ((ret = cdrom_mode_select(cdi, &cgc))) 577 ret = cdrom_mode_select(cdi, &cgc);
578 if (ret)
664 return ret; 579 return ret;
665 580
666 pr_info("%s: mrw address space %s selected\n", 581 pr_info("%s: mrw address space %s selected\n",
@@ -668,6 +583,106 @@ static int cdrom_mrw_set_lba_space(struct cdrom_device_info *cdi, int space)
668 return 0; 583 return 0;
669} 584}
670 585
586int register_cdrom(struct cdrom_device_info *cdi)
587{
588 static char banner_printed;
589 struct cdrom_device_ops *cdo = cdi->ops;
590 int *change_capability = (int *)&cdo->capability; /* hack */
591
592 cd_dbg(CD_OPEN, "entering register_cdrom\n");
593
594 if (cdo->open == NULL || cdo->release == NULL)
595 return -EINVAL;
596 if (!banner_printed) {
597 pr_info("Uniform CD-ROM driver " REVISION "\n");
598 banner_printed = 1;
599 cdrom_sysctl_register();
600 }
601
602 ENSURE(drive_status, CDC_DRIVE_STATUS);
603 if (cdo->check_events == NULL && cdo->media_changed == NULL)
604 *change_capability = ~(CDC_MEDIA_CHANGED | CDC_SELECT_DISC);
605 ENSURE(tray_move, CDC_CLOSE_TRAY | CDC_OPEN_TRAY);
606 ENSURE(lock_door, CDC_LOCK);
607 ENSURE(select_speed, CDC_SELECT_SPEED);
608 ENSURE(get_last_session, CDC_MULTI_SESSION);
609 ENSURE(get_mcn, CDC_MCN);
610 ENSURE(reset, CDC_RESET);
611 ENSURE(generic_packet, CDC_GENERIC_PACKET);
612 cdi->mc_flags = 0;
613 cdo->n_minors = 0;
614 cdi->options = CDO_USE_FFLAGS;
615
616 if (autoclose == 1 && CDROM_CAN(CDC_CLOSE_TRAY))
617 cdi->options |= (int) CDO_AUTO_CLOSE;
618 if (autoeject == 1 && CDROM_CAN(CDC_OPEN_TRAY))
619 cdi->options |= (int) CDO_AUTO_EJECT;
620 if (lockdoor == 1)
621 cdi->options |= (int) CDO_LOCK;
622 if (check_media_type == 1)
623 cdi->options |= (int) CDO_CHECK_TYPE;
624
625 if (CDROM_CAN(CDC_MRW_W))
626 cdi->exit = cdrom_mrw_exit;
627
628 if (cdi->disk)
629 cdi->cdda_method = CDDA_BPC_FULL;
630 else
631 cdi->cdda_method = CDDA_OLD;
632
633 if (!cdo->generic_packet)
634 cdo->generic_packet = cdrom_dummy_generic_packet;
635
636 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" registered\n", cdi->name);
637 mutex_lock(&cdrom_mutex);
638 list_add(&cdi->list, &cdrom_list);
639 mutex_unlock(&cdrom_mutex);
640 return 0;
641}
642#undef ENSURE
643
644void unregister_cdrom(struct cdrom_device_info *cdi)
645{
646 cd_dbg(CD_OPEN, "entering unregister_cdrom\n");
647
648 mutex_lock(&cdrom_mutex);
649 list_del(&cdi->list);
650 mutex_unlock(&cdrom_mutex);
651
652 if (cdi->exit)
653 cdi->exit(cdi);
654
655 cdi->ops->n_minors--;
656 cd_dbg(CD_REG_UNREG, "drive \"/dev/%s\" unregistered\n", cdi->name);
657}
658
659int cdrom_get_media_event(struct cdrom_device_info *cdi,
660 struct media_event_desc *med)
661{
662 struct packet_command cgc;
663 unsigned char buffer[8];
664 struct event_header *eh = (struct event_header *)buffer;
665
666 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_READ);
667 cgc.cmd[0] = GPCMD_GET_EVENT_STATUS_NOTIFICATION;
668 cgc.cmd[1] = 1; /* IMMED */
669 cgc.cmd[4] = 1 << 4; /* media event */
670 cgc.cmd[8] = sizeof(buffer);
671 cgc.quiet = 1;
672
673 if (cdi->ops->generic_packet(cdi, &cgc))
674 return 1;
675
676 if (be16_to_cpu(eh->data_len) < sizeof(*med))
677 return 1;
678
679 if (eh->nea || eh->notification_class != 0x4)
680 return 1;
681
682 memcpy(med, &buffer[sizeof(*eh)], sizeof(*med));
683 return 0;
684}
685
671static int cdrom_get_random_writable(struct cdrom_device_info *cdi, 686static int cdrom_get_random_writable(struct cdrom_device_info *cdi,
672 struct rwrt_feature_desc *rfd) 687 struct rwrt_feature_desc *rfd)
673{ 688{
@@ -839,7 +854,7 @@ static int cdrom_ram_open_write(struct cdrom_device_info *cdi)
839 else if (CDF_RWRT == be16_to_cpu(rfd.feature_code)) 854 else if (CDF_RWRT == be16_to_cpu(rfd.feature_code))
840 ret = !rfd.curr; 855 ret = !rfd.curr;
841 856
842 cdinfo(CD_OPEN, "can open for random write\n"); 857 cd_dbg(CD_OPEN, "can open for random write\n");
843 return ret; 858 return ret;
844} 859}
845 860
@@ -928,12 +943,12 @@ static void cdrom_dvd_rw_close_write(struct cdrom_device_info *cdi)
928 struct packet_command cgc; 943 struct packet_command cgc;
929 944
930 if (cdi->mmc3_profile != 0x1a) { 945 if (cdi->mmc3_profile != 0x1a) {
931 cdinfo(CD_CLOSE, "%s: No DVD+RW\n", cdi->name); 946 cd_dbg(CD_CLOSE, "%s: No DVD+RW\n", cdi->name);
932 return; 947 return;
933 } 948 }
934 949
935 if (!cdi->media_written) { 950 if (!cdi->media_written) {
936 cdinfo(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name); 951 cd_dbg(CD_CLOSE, "%s: DVD+RW media clean\n", cdi->name);
937 return; 952 return;
938 } 953 }
939 954
@@ -969,82 +984,74 @@ static int cdrom_close_write(struct cdrom_device_info *cdi)
969#endif 984#endif
970} 985}
971 986
972/* We use the open-option O_NONBLOCK to indicate that the 987/* badly broken, I know. Is due for a fixup anytime. */
973 * purpose of opening is only for subsequent ioctl() calls; no device 988static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype *tracks)
974 * integrity checks are performed.
975 *
976 * We hope that all cd-player programs will adopt this convention. It
977 * is in their own interest: device control becomes a lot easier
978 * this way.
979 */
980int cdrom_open(struct cdrom_device_info *cdi, struct block_device *bdev, fmode_t mode)
981{ 989{
982 int ret; 990 struct cdrom_tochdr header;
983 991 struct cdrom_tocentry entry;
984 cdinfo(CD_OPEN, "entering cdrom_open\n"); 992 int ret, i;
985 993 tracks->data = 0;
986 /* open is event synchronization point, check events first */ 994 tracks->audio = 0;
987 check_disk_change(bdev); 995 tracks->cdi = 0;
988 996 tracks->xa = 0;
989 /* if this was a O_NONBLOCK open and we should honor the flags, 997 tracks->error = 0;
990 * do a quick open without drive/disc integrity checks. */ 998 cd_dbg(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
991 cdi->use_count++; 999 /* Grab the TOC header so we can see how many tracks there are */
992 if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) { 1000 ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
993 ret = cdi->ops->open(cdi, 1); 1001 if (ret) {
994 } else { 1002 if (ret == -ENOMEDIUM)
995 ret = open_for_data(cdi); 1003 tracks->error = CDS_NO_DISC;
996 if (ret) 1004 else
997 goto err; 1005 tracks->error = CDS_NO_INFO;
998 cdrom_mmc3_profile(cdi); 1006 return;
999 if (mode & FMODE_WRITE) {
1000 ret = -EROFS;
1001 if (cdrom_open_write(cdi))
1002 goto err_release;
1003 if (!CDROM_CAN(CDC_RAM))
1004 goto err_release;
1005 ret = 0;
1006 cdi->media_written = 0;
1007 }
1008 } 1007 }
1009 1008 /* check what type of tracks are on this disc */
1010 if (ret) 1009 entry.cdte_format = CDROM_MSF;
1011 goto err; 1010 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1012 1011 entry.cdte_track = i;
1013 cdinfo(CD_OPEN, "Use count for \"/dev/%s\" now %d\n", 1012 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1014 cdi->name, cdi->use_count); 1013 tracks->error = CDS_NO_INFO;
1015 return 0; 1014 return;
1016err_release: 1015 }
1017 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) { 1016 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1018 cdi->ops->lock_door(cdi, 0); 1017 if (entry.cdte_format == 0x10)
1019 cdinfo(CD_OPEN, "door unlocked.\n"); 1018 tracks->cdi++;
1019 else if (entry.cdte_format == 0x20)
1020 tracks->xa++;
1021 else
1022 tracks->data++;
1023 } else {
1024 tracks->audio++;
1025 }
1026 cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1027 i, entry.cdte_format, entry.cdte_ctrl);
1020 } 1028 }
1021 cdi->ops->release(cdi); 1029 cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1022err: 1030 header.cdth_trk1, tracks->audio, tracks->data,
1023 cdi->use_count--; 1031 tracks->cdi, tracks->xa);
1024 return ret;
1025} 1032}
1026 1033
1027static 1034static
1028int open_for_data(struct cdrom_device_info * cdi) 1035int open_for_data(struct cdrom_device_info *cdi)
1029{ 1036{
1030 int ret; 1037 int ret;
1031 struct cdrom_device_ops *cdo = cdi->ops; 1038 struct cdrom_device_ops *cdo = cdi->ops;
1032 tracktype tracks; 1039 tracktype tracks;
1033 cdinfo(CD_OPEN, "entering open_for_data\n"); 1040 cd_dbg(CD_OPEN, "entering open_for_data\n");
1034 /* Check if the driver can report drive status. If it can, we 1041 /* Check if the driver can report drive status. If it can, we
1035 can do clever things. If it can't, well, we at least tried! */ 1042 can do clever things. If it can't, well, we at least tried! */
1036 if (cdo->drive_status != NULL) { 1043 if (cdo->drive_status != NULL) {
1037 ret = cdo->drive_status(cdi, CDSL_CURRENT); 1044 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1038 cdinfo(CD_OPEN, "drive_status=%d\n", ret); 1045 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1039 if (ret == CDS_TRAY_OPEN) { 1046 if (ret == CDS_TRAY_OPEN) {
1040 cdinfo(CD_OPEN, "the tray is open...\n"); 1047 cd_dbg(CD_OPEN, "the tray is open...\n");
1041 /* can/may i close it? */ 1048 /* can/may i close it? */
1042 if (CDROM_CAN(CDC_CLOSE_TRAY) && 1049 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1043 cdi->options & CDO_AUTO_CLOSE) { 1050 cdi->options & CDO_AUTO_CLOSE) {
1044 cdinfo(CD_OPEN, "trying to close the tray.\n"); 1051 cd_dbg(CD_OPEN, "trying to close the tray\n");
1045 ret=cdo->tray_move(cdi,0); 1052 ret=cdo->tray_move(cdi,0);
1046 if (ret) { 1053 if (ret) {
1047 cdinfo(CD_OPEN, "bummer. tried to close the tray but failed.\n"); 1054 cd_dbg(CD_OPEN, "bummer. tried to close the tray but failed.\n");
1048 /* Ignore the error from the low 1055 /* Ignore the error from the low
1049 level driver. We don't care why it 1056 level driver. We don't care why it
1050 couldn't close the tray. We only care 1057 couldn't close the tray. We only care
@@ -1054,19 +1061,19 @@ int open_for_data(struct cdrom_device_info * cdi)
1054 goto clean_up_and_return; 1061 goto clean_up_and_return;
1055 } 1062 }
1056 } else { 1063 } else {
1057 cdinfo(CD_OPEN, "bummer. this drive can't close the tray.\n"); 1064 cd_dbg(CD_OPEN, "bummer. this drive can't close the tray.\n");
1058 ret=-ENOMEDIUM; 1065 ret=-ENOMEDIUM;
1059 goto clean_up_and_return; 1066 goto clean_up_and_return;
1060 } 1067 }
1061 /* Ok, the door should be closed now.. Check again */ 1068 /* Ok, the door should be closed now.. Check again */
1062 ret = cdo->drive_status(cdi, CDSL_CURRENT); 1069 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1063 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) { 1070 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1064 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n"); 1071 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1065 cdinfo(CD_OPEN, "tray might not contain a medium.\n"); 1072 cd_dbg(CD_OPEN, "tray might not contain a medium\n");
1066 ret=-ENOMEDIUM; 1073 ret=-ENOMEDIUM;
1067 goto clean_up_and_return; 1074 goto clean_up_and_return;
1068 } 1075 }
1069 cdinfo(CD_OPEN, "the tray is now closed.\n"); 1076 cd_dbg(CD_OPEN, "the tray is now closed\n");
1070 } 1077 }
1071 /* the door should be closed now, check for the disc */ 1078 /* the door should be closed now, check for the disc */
1072 ret = cdo->drive_status(cdi, CDSL_CURRENT); 1079 ret = cdo->drive_status(cdi, CDSL_CURRENT);
@@ -1077,7 +1084,7 @@ int open_for_data(struct cdrom_device_info * cdi)
1077 } 1084 }
1078 cdrom_count_tracks(cdi, &tracks); 1085 cdrom_count_tracks(cdi, &tracks);
1079 if (tracks.error == CDS_NO_DISC) { 1086 if (tracks.error == CDS_NO_DISC) {
1080 cdinfo(CD_OPEN, "bummer. no disc.\n"); 1087 cd_dbg(CD_OPEN, "bummer. no disc.\n");
1081 ret=-ENOMEDIUM; 1088 ret=-ENOMEDIUM;
1082 goto clean_up_and_return; 1089 goto clean_up_and_return;
1083 } 1090 }
@@ -1087,34 +1094,34 @@ int open_for_data(struct cdrom_device_info * cdi)
1087 if (cdi->options & CDO_CHECK_TYPE) { 1094 if (cdi->options & CDO_CHECK_TYPE) {
1088 /* give people a warning shot, now that CDO_CHECK_TYPE 1095 /* give people a warning shot, now that CDO_CHECK_TYPE
1089 is the default case! */ 1096 is the default case! */
1090 cdinfo(CD_OPEN, "bummer. wrong media type.\n"); 1097 cd_dbg(CD_OPEN, "bummer. wrong media type.\n");
1091 cdinfo(CD_WARNING, "pid %d must open device O_NONBLOCK!\n", 1098 cd_dbg(CD_WARNING, "pid %d must open device O_NONBLOCK!\n",
1092 (unsigned int)task_pid_nr(current)); 1099 (unsigned int)task_pid_nr(current));
1093 ret=-EMEDIUMTYPE; 1100 ret=-EMEDIUMTYPE;
1094 goto clean_up_and_return; 1101 goto clean_up_and_return;
1095 } 1102 }
1096 else { 1103 else {
1097 cdinfo(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set.\n"); 1104 cd_dbg(CD_OPEN, "wrong media type, but CDO_CHECK_TYPE not set\n");
1098 } 1105 }
1099 } 1106 }
1100 1107
1101 cdinfo(CD_OPEN, "all seems well, opening the device.\n"); 1108 cd_dbg(CD_OPEN, "all seems well, opening the devicen");
1102 1109
1103 /* all seems well, we can open the device */ 1110 /* all seems well, we can open the device */
1104 ret = cdo->open(cdi, 0); /* open for data */ 1111 ret = cdo->open(cdi, 0); /* open for data */
1105 cdinfo(CD_OPEN, "opening the device gave me %d.\n", ret); 1112 cd_dbg(CD_OPEN, "opening the device gave me %d\n", ret);
1106 /* After all this careful checking, we shouldn't have problems 1113 /* After all this careful checking, we shouldn't have problems
1107 opening the device, but we don't want the device locked if 1114 opening the device, but we don't want the device locked if
1108 this somehow fails... */ 1115 this somehow fails... */
1109 if (ret) { 1116 if (ret) {
1110 cdinfo(CD_OPEN, "open device failed.\n"); 1117 cd_dbg(CD_OPEN, "open device failed\n");
1111 goto clean_up_and_return; 1118 goto clean_up_and_return;
1112 } 1119 }
1113 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) { 1120 if (CDROM_CAN(CDC_LOCK) && (cdi->options & CDO_LOCK)) {
1114 cdo->lock_door(cdi, 1); 1121 cdo->lock_door(cdi, 1);
1115 cdinfo(CD_OPEN, "door locked.\n"); 1122 cd_dbg(CD_OPEN, "door locked\n");
1116 } 1123 }
1117 cdinfo(CD_OPEN, "device opened successfully.\n"); 1124 cd_dbg(CD_OPEN, "device opened successfully\n");
1118 return ret; 1125 return ret;
1119 1126
1120 /* Something failed. Try to unlock the drive, because some drivers 1127 /* Something failed. Try to unlock the drive, because some drivers
@@ -1123,14 +1130,70 @@ int open_for_data(struct cdrom_device_info * cdi)
1123 This ensures that the drive gets unlocked after a mount fails. This 1130 This ensures that the drive gets unlocked after a mount fails. This
1124 is a goto to avoid bloating the driver with redundant code. */ 1131 is a goto to avoid bloating the driver with redundant code. */
1125clean_up_and_return: 1132clean_up_and_return:
1126 cdinfo(CD_OPEN, "open failed.\n"); 1133 cd_dbg(CD_OPEN, "open failed\n");
1127 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) { 1134 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1128 cdo->lock_door(cdi, 0); 1135 cdo->lock_door(cdi, 0);
1129 cdinfo(CD_OPEN, "door unlocked.\n"); 1136 cd_dbg(CD_OPEN, "door unlocked\n");
1130 } 1137 }
1131 return ret; 1138 return ret;
1132} 1139}
1133 1140
1141/* We use the open-option O_NONBLOCK to indicate that the
1142 * purpose of opening is only for subsequent ioctl() calls; no device
1143 * integrity checks are performed.
1144 *
1145 * We hope that all cd-player programs will adopt this convention. It
1146 * is in their own interest: device control becomes a lot easier
1147 * this way.
1148 */
1149int cdrom_open(struct cdrom_device_info *cdi, struct block_device *bdev,
1150 fmode_t mode)
1151{
1152 int ret;
1153
1154 cd_dbg(CD_OPEN, "entering cdrom_open\n");
1155
1156 /* open is event synchronization point, check events first */
1157 check_disk_change(bdev);
1158
1159 /* if this was a O_NONBLOCK open and we should honor the flags,
1160 * do a quick open without drive/disc integrity checks. */
1161 cdi->use_count++;
1162 if ((mode & FMODE_NDELAY) && (cdi->options & CDO_USE_FFLAGS)) {
1163 ret = cdi->ops->open(cdi, 1);
1164 } else {
1165 ret = open_for_data(cdi);
1166 if (ret)
1167 goto err;
1168 cdrom_mmc3_profile(cdi);
1169 if (mode & FMODE_WRITE) {
1170 ret = -EROFS;
1171 if (cdrom_open_write(cdi))
1172 goto err_release;
1173 if (!CDROM_CAN(CDC_RAM))
1174 goto err_release;
1175 ret = 0;
1176 cdi->media_written = 0;
1177 }
1178 }
1179
1180 if (ret)
1181 goto err;
1182
1183 cd_dbg(CD_OPEN, "Use count for \"/dev/%s\" now %d\n",
1184 cdi->name, cdi->use_count);
1185 return 0;
1186err_release:
1187 if (CDROM_CAN(CDC_LOCK) && cdi->options & CDO_LOCK) {
1188 cdi->ops->lock_door(cdi, 0);
1189 cd_dbg(CD_OPEN, "door unlocked\n");
1190 }
1191 cdi->ops->release(cdi);
1192err:
1193 cdi->use_count--;
1194 return ret;
1195}
1196
1134/* This code is similar to that in open_for_data. The routine is called 1197/* This code is similar to that in open_for_data. The routine is called
1135 whenever an audio play operation is requested. 1198 whenever an audio play operation is requested.
1136*/ 1199*/
@@ -1139,21 +1202,21 @@ static int check_for_audio_disc(struct cdrom_device_info * cdi,
1139{ 1202{
1140 int ret; 1203 int ret;
1141 tracktype tracks; 1204 tracktype tracks;
1142 cdinfo(CD_OPEN, "entering check_for_audio_disc\n"); 1205 cd_dbg(CD_OPEN, "entering check_for_audio_disc\n");
1143 if (!(cdi->options & CDO_CHECK_TYPE)) 1206 if (!(cdi->options & CDO_CHECK_TYPE))
1144 return 0; 1207 return 0;
1145 if (cdo->drive_status != NULL) { 1208 if (cdo->drive_status != NULL) {
1146 ret = cdo->drive_status(cdi, CDSL_CURRENT); 1209 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1147 cdinfo(CD_OPEN, "drive_status=%d\n", ret); 1210 cd_dbg(CD_OPEN, "drive_status=%d\n", ret);
1148 if (ret == CDS_TRAY_OPEN) { 1211 if (ret == CDS_TRAY_OPEN) {
1149 cdinfo(CD_OPEN, "the tray is open...\n"); 1212 cd_dbg(CD_OPEN, "the tray is open...\n");
1150 /* can/may i close it? */ 1213 /* can/may i close it? */
1151 if (CDROM_CAN(CDC_CLOSE_TRAY) && 1214 if (CDROM_CAN(CDC_CLOSE_TRAY) &&
1152 cdi->options & CDO_AUTO_CLOSE) { 1215 cdi->options & CDO_AUTO_CLOSE) {
1153 cdinfo(CD_OPEN, "trying to close the tray.\n"); 1216 cd_dbg(CD_OPEN, "trying to close the tray\n");
1154 ret=cdo->tray_move(cdi,0); 1217 ret=cdo->tray_move(cdi,0);
1155 if (ret) { 1218 if (ret) {
1156 cdinfo(CD_OPEN, "bummer. tried to close tray but failed.\n"); 1219 cd_dbg(CD_OPEN, "bummer. tried to close tray but failed.\n");
1157 /* Ignore the error from the low 1220 /* Ignore the error from the low
1158 level driver. We don't care why it 1221 level driver. We don't care why it
1159 couldn't close the tray. We only care 1222 couldn't close the tray. We only care
@@ -1162,20 +1225,20 @@ static int check_for_audio_disc(struct cdrom_device_info * cdi,
1162 return -ENOMEDIUM; 1225 return -ENOMEDIUM;
1163 } 1226 }
1164 } else { 1227 } else {
1165 cdinfo(CD_OPEN, "bummer. this driver can't close the tray.\n"); 1228 cd_dbg(CD_OPEN, "bummer. this driver can't close the tray.\n");
1166 return -ENOMEDIUM; 1229 return -ENOMEDIUM;
1167 } 1230 }
1168 /* Ok, the door should be closed now.. Check again */ 1231 /* Ok, the door should be closed now.. Check again */
1169 ret = cdo->drive_status(cdi, CDSL_CURRENT); 1232 ret = cdo->drive_status(cdi, CDSL_CURRENT);
1170 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) { 1233 if ((ret == CDS_NO_DISC) || (ret==CDS_TRAY_OPEN)) {
1171 cdinfo(CD_OPEN, "bummer. the tray is still not closed.\n"); 1234 cd_dbg(CD_OPEN, "bummer. the tray is still not closed.\n");
1172 return -ENOMEDIUM; 1235 return -ENOMEDIUM;
1173 } 1236 }
1174 if (ret!=CDS_DISC_OK) { 1237 if (ret!=CDS_DISC_OK) {
1175 cdinfo(CD_OPEN, "bummer. disc isn't ready.\n"); 1238 cd_dbg(CD_OPEN, "bummer. disc isn't ready.\n");
1176 return -EIO; 1239 return -EIO;
1177 } 1240 }
1178 cdinfo(CD_OPEN, "the tray is now closed.\n"); 1241 cd_dbg(CD_OPEN, "the tray is now closed\n");
1179 } 1242 }
1180 } 1243 }
1181 cdrom_count_tracks(cdi, &tracks); 1244 cdrom_count_tracks(cdi, &tracks);
@@ -1193,17 +1256,18 @@ void cdrom_release(struct cdrom_device_info *cdi, fmode_t mode)
1193 struct cdrom_device_ops *cdo = cdi->ops; 1256 struct cdrom_device_ops *cdo = cdi->ops;
1194 int opened_for_data; 1257 int opened_for_data;
1195 1258
1196 cdinfo(CD_CLOSE, "entering cdrom_release\n"); 1259 cd_dbg(CD_CLOSE, "entering cdrom_release\n");
1197 1260
1198 if (cdi->use_count > 0) 1261 if (cdi->use_count > 0)
1199 cdi->use_count--; 1262 cdi->use_count--;
1200 1263
1201 if (cdi->use_count == 0) { 1264 if (cdi->use_count == 0) {
1202 cdinfo(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n", cdi->name); 1265 cd_dbg(CD_CLOSE, "Use count for \"/dev/%s\" now zero\n",
1266 cdi->name);
1203 cdrom_dvd_rw_close_write(cdi); 1267 cdrom_dvd_rw_close_write(cdi);
1204 1268
1205 if ((cdo->capability & CDC_LOCK) && !cdi->keeplocked) { 1269 if ((cdo->capability & CDC_LOCK) && !cdi->keeplocked) {
1206 cdinfo(CD_CLOSE, "Unlocking door!\n"); 1270 cd_dbg(CD_CLOSE, "Unlocking door!\n");
1207 cdo->lock_door(cdi, 0); 1271 cdo->lock_door(cdi, 0);
1208 } 1272 }
1209 } 1273 }
@@ -1262,7 +1326,7 @@ static int cdrom_slot_status(struct cdrom_device_info *cdi, int slot)
1262 struct cdrom_changer_info *info; 1326 struct cdrom_changer_info *info;
1263 int ret; 1327 int ret;
1264 1328
1265 cdinfo(CD_CHANGER, "entering cdrom_slot_status()\n"); 1329 cd_dbg(CD_CHANGER, "entering cdrom_slot_status()\n");
1266 if (cdi->sanyo_slot) 1330 if (cdi->sanyo_slot)
1267 return CDS_NO_INFO; 1331 return CDS_NO_INFO;
1268 1332
@@ -1292,7 +1356,7 @@ int cdrom_number_of_slots(struct cdrom_device_info *cdi)
1292 int nslots = 1; 1356 int nslots = 1;
1293 struct cdrom_changer_info *info; 1357 struct cdrom_changer_info *info;
1294 1358
1295 cdinfo(CD_CHANGER, "entering cdrom_number_of_slots()\n"); 1359 cd_dbg(CD_CHANGER, "entering cdrom_number_of_slots()\n");
1296 /* cdrom_read_mech_status requires a valid value for capacity: */ 1360 /* cdrom_read_mech_status requires a valid value for capacity: */
1297 cdi->capacity = 0; 1361 cdi->capacity = 0;
1298 1362
@@ -1313,7 +1377,7 @@ static int cdrom_load_unload(struct cdrom_device_info *cdi, int slot)
1313{ 1377{
1314 struct packet_command cgc; 1378 struct packet_command cgc;
1315 1379
1316 cdinfo(CD_CHANGER, "entering cdrom_load_unload()\n"); 1380 cd_dbg(CD_CHANGER, "entering cdrom_load_unload()\n");
1317 if (cdi->sanyo_slot && slot < 0) 1381 if (cdi->sanyo_slot && slot < 0)
1318 return 0; 1382 return 0;
1319 1383
@@ -1342,7 +1406,7 @@ static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
1342 int curslot; 1406 int curslot;
1343 int ret; 1407 int ret;
1344 1408
1345 cdinfo(CD_CHANGER, "entering cdrom_select_disc()\n"); 1409 cd_dbg(CD_CHANGER, "entering cdrom_select_disc()\n");
1346 if (!CDROM_CAN(CDC_SELECT_DISC)) 1410 if (!CDROM_CAN(CDC_SELECT_DISC))
1347 return -EDRIVE_CANT_DO_THIS; 1411 return -EDRIVE_CANT_DO_THIS;
1348 1412
@@ -1476,51 +1540,6 @@ int cdrom_media_changed(struct cdrom_device_info *cdi)
1476 return media_changed(cdi, 0); 1540 return media_changed(cdi, 0);
1477} 1541}
1478 1542
1479/* badly broken, I know. Is due for a fixup anytime. */
1480static void cdrom_count_tracks(struct cdrom_device_info *cdi, tracktype* tracks)
1481{
1482 struct cdrom_tochdr header;
1483 struct cdrom_tocentry entry;
1484 int ret, i;
1485 tracks->data=0;
1486 tracks->audio=0;
1487 tracks->cdi=0;
1488 tracks->xa=0;
1489 tracks->error=0;
1490 cdinfo(CD_COUNT_TRACKS, "entering cdrom_count_tracks\n");
1491 /* Grab the TOC header so we can see how many tracks there are */
1492 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header))) {
1493 if (ret == -ENOMEDIUM)
1494 tracks->error = CDS_NO_DISC;
1495 else
1496 tracks->error = CDS_NO_INFO;
1497 return;
1498 }
1499 /* check what type of tracks are on this disc */
1500 entry.cdte_format = CDROM_MSF;
1501 for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) {
1502 entry.cdte_track = i;
1503 if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) {
1504 tracks->error=CDS_NO_INFO;
1505 return;
1506 }
1507 if (entry.cdte_ctrl & CDROM_DATA_TRACK) {
1508 if (entry.cdte_format == 0x10)
1509 tracks->cdi++;
1510 else if (entry.cdte_format == 0x20)
1511 tracks->xa++;
1512 else
1513 tracks->data++;
1514 } else
1515 tracks->audio++;
1516 cdinfo(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n",
1517 i, entry.cdte_format, entry.cdte_ctrl);
1518 }
1519 cdinfo(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n",
1520 header.cdth_trk1, tracks->audio, tracks->data,
1521 tracks->cdi, tracks->xa);
1522}
1523
1524/* Requests to the low-level drivers will /always/ be done in the 1543/* Requests to the low-level drivers will /always/ be done in the
1525 following format convention: 1544 following format convention:
1526 1545
@@ -1632,7 +1651,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1632 switch (ai->type) { 1651 switch (ai->type) {
1633 /* LU data send */ 1652 /* LU data send */
1634 case DVD_LU_SEND_AGID: 1653 case DVD_LU_SEND_AGID:
1635 cdinfo(CD_DVD, "entering DVD_LU_SEND_AGID\n"); 1654 cd_dbg(CD_DVD, "entering DVD_LU_SEND_AGID\n");
1636 cgc.quiet = 1; 1655 cgc.quiet = 1;
1637 setup_report_key(&cgc, ai->lsa.agid, 0); 1656 setup_report_key(&cgc, ai->lsa.agid, 0);
1638 1657
@@ -1644,7 +1663,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1644 break; 1663 break;
1645 1664
1646 case DVD_LU_SEND_KEY1: 1665 case DVD_LU_SEND_KEY1:
1647 cdinfo(CD_DVD, "entering DVD_LU_SEND_KEY1\n"); 1666 cd_dbg(CD_DVD, "entering DVD_LU_SEND_KEY1\n");
1648 setup_report_key(&cgc, ai->lsk.agid, 2); 1667 setup_report_key(&cgc, ai->lsk.agid, 2);
1649 1668
1650 if ((ret = cdo->generic_packet(cdi, &cgc))) 1669 if ((ret = cdo->generic_packet(cdi, &cgc)))
@@ -1655,7 +1674,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1655 break; 1674 break;
1656 1675
1657 case DVD_LU_SEND_CHALLENGE: 1676 case DVD_LU_SEND_CHALLENGE:
1658 cdinfo(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n"); 1677 cd_dbg(CD_DVD, "entering DVD_LU_SEND_CHALLENGE\n");
1659 setup_report_key(&cgc, ai->lsc.agid, 1); 1678 setup_report_key(&cgc, ai->lsc.agid, 1);
1660 1679
1661 if ((ret = cdo->generic_packet(cdi, &cgc))) 1680 if ((ret = cdo->generic_packet(cdi, &cgc)))
@@ -1667,7 +1686,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1667 1686
1668 /* Post-auth key */ 1687 /* Post-auth key */
1669 case DVD_LU_SEND_TITLE_KEY: 1688 case DVD_LU_SEND_TITLE_KEY:
1670 cdinfo(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n"); 1689 cd_dbg(CD_DVD, "entering DVD_LU_SEND_TITLE_KEY\n");
1671 cgc.quiet = 1; 1690 cgc.quiet = 1;
1672 setup_report_key(&cgc, ai->lstk.agid, 4); 1691 setup_report_key(&cgc, ai->lstk.agid, 4);
1673 cgc.cmd[5] = ai->lstk.lba; 1692 cgc.cmd[5] = ai->lstk.lba;
@@ -1686,7 +1705,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1686 break; 1705 break;
1687 1706
1688 case DVD_LU_SEND_ASF: 1707 case DVD_LU_SEND_ASF:
1689 cdinfo(CD_DVD, "entering DVD_LU_SEND_ASF\n"); 1708 cd_dbg(CD_DVD, "entering DVD_LU_SEND_ASF\n");
1690 setup_report_key(&cgc, ai->lsasf.agid, 5); 1709 setup_report_key(&cgc, ai->lsasf.agid, 5);
1691 1710
1692 if ((ret = cdo->generic_packet(cdi, &cgc))) 1711 if ((ret = cdo->generic_packet(cdi, &cgc)))
@@ -1697,7 +1716,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1697 1716
1698 /* LU data receive (LU changes state) */ 1717 /* LU data receive (LU changes state) */
1699 case DVD_HOST_SEND_CHALLENGE: 1718 case DVD_HOST_SEND_CHALLENGE:
1700 cdinfo(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n"); 1719 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_CHALLENGE\n");
1701 setup_send_key(&cgc, ai->hsc.agid, 1); 1720 setup_send_key(&cgc, ai->hsc.agid, 1);
1702 buf[1] = 0xe; 1721 buf[1] = 0xe;
1703 copy_chal(&buf[4], ai->hsc.chal); 1722 copy_chal(&buf[4], ai->hsc.chal);
@@ -1709,7 +1728,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1709 break; 1728 break;
1710 1729
1711 case DVD_HOST_SEND_KEY2: 1730 case DVD_HOST_SEND_KEY2:
1712 cdinfo(CD_DVD, "entering DVD_HOST_SEND_KEY2\n"); 1731 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_KEY2\n");
1713 setup_send_key(&cgc, ai->hsk.agid, 3); 1732 setup_send_key(&cgc, ai->hsk.agid, 3);
1714 buf[1] = 0xa; 1733 buf[1] = 0xa;
1715 copy_key(&buf[4], ai->hsk.key); 1734 copy_key(&buf[4], ai->hsk.key);
@@ -1724,7 +1743,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1724 /* Misc */ 1743 /* Misc */
1725 case DVD_INVALIDATE_AGID: 1744 case DVD_INVALIDATE_AGID:
1726 cgc.quiet = 1; 1745 cgc.quiet = 1;
1727 cdinfo(CD_DVD, "entering DVD_INVALIDATE_AGID\n"); 1746 cd_dbg(CD_DVD, "entering DVD_INVALIDATE_AGID\n");
1728 setup_report_key(&cgc, ai->lsa.agid, 0x3f); 1747 setup_report_key(&cgc, ai->lsa.agid, 0x3f);
1729 if ((ret = cdo->generic_packet(cdi, &cgc))) 1748 if ((ret = cdo->generic_packet(cdi, &cgc)))
1730 return ret; 1749 return ret;
@@ -1732,7 +1751,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1732 1751
1733 /* Get region settings */ 1752 /* Get region settings */
1734 case DVD_LU_SEND_RPC_STATE: 1753 case DVD_LU_SEND_RPC_STATE:
1735 cdinfo(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n"); 1754 cd_dbg(CD_DVD, "entering DVD_LU_SEND_RPC_STATE\n");
1736 setup_report_key(&cgc, 0, 8); 1755 setup_report_key(&cgc, 0, 8);
1737 memset(&rpc_state, 0, sizeof(rpc_state_t)); 1756 memset(&rpc_state, 0, sizeof(rpc_state_t));
1738 cgc.buffer = (char *) &rpc_state; 1757 cgc.buffer = (char *) &rpc_state;
@@ -1749,7 +1768,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1749 1768
1750 /* Set region settings */ 1769 /* Set region settings */
1751 case DVD_HOST_SEND_RPC_STATE: 1770 case DVD_HOST_SEND_RPC_STATE:
1752 cdinfo(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n"); 1771 cd_dbg(CD_DVD, "entering DVD_HOST_SEND_RPC_STATE\n");
1753 setup_send_key(&cgc, 0, 6); 1772 setup_send_key(&cgc, 0, 6);
1754 buf[1] = 6; 1773 buf[1] = 6;
1755 buf[4] = ai->hrpcs.pdrc; 1774 buf[4] = ai->hrpcs.pdrc;
@@ -1759,7 +1778,7 @@ static int dvd_do_auth(struct cdrom_device_info *cdi, dvd_authinfo *ai)
1759 break; 1778 break;
1760 1779
1761 default: 1780 default:
1762 cdinfo(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type); 1781 cd_dbg(CD_WARNING, "Invalid DVD key ioctl (%d)\n", ai->type);
1763 return -ENOTTY; 1782 return -ENOTTY;
1764 } 1783 }
1765 1784
@@ -1891,7 +1910,8 @@ static int dvd_read_bca(struct cdrom_device_info *cdi, dvd_struct *s,
1891 1910
1892 s->bca.len = buf[0] << 8 | buf[1]; 1911 s->bca.len = buf[0] << 8 | buf[1];
1893 if (s->bca.len < 12 || s->bca.len > 188) { 1912 if (s->bca.len < 12 || s->bca.len > 188) {
1894 cdinfo(CD_WARNING, "Received invalid BCA length (%d)\n", s->bca.len); 1913 cd_dbg(CD_WARNING, "Received invalid BCA length (%d)\n",
1914 s->bca.len);
1895 ret = -EIO; 1915 ret = -EIO;
1896 goto out; 1916 goto out;
1897 } 1917 }
@@ -1927,14 +1947,13 @@ static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
1927 1947
1928 s->manufact.len = buf[0] << 8 | buf[1]; 1948 s->manufact.len = buf[0] << 8 | buf[1];
1929 if (s->manufact.len < 0) { 1949 if (s->manufact.len < 0) {
1930 cdinfo(CD_WARNING, "Received invalid manufacture info length" 1950 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d)\n",
1931 " (%d)\n", s->manufact.len); 1951 s->manufact.len);
1932 ret = -EIO; 1952 ret = -EIO;
1933 } else { 1953 } else {
1934 if (s->manufact.len > 2048) { 1954 if (s->manufact.len > 2048) {
1935 cdinfo(CD_WARNING, "Received invalid manufacture info " 1955 cd_dbg(CD_WARNING, "Received invalid manufacture info length (%d): truncating to 2048\n",
1936 "length (%d): truncating to 2048\n", 1956 s->manufact.len);
1937 s->manufact.len);
1938 s->manufact.len = 2048; 1957 s->manufact.len = 2048;
1939 } 1958 }
1940 memcpy(s->manufact.value, &buf[4], s->manufact.len); 1959 memcpy(s->manufact.value, &buf[4], s->manufact.len);
@@ -1965,8 +1984,8 @@ static int dvd_read_struct(struct cdrom_device_info *cdi, dvd_struct *s,
1965 return dvd_read_manufact(cdi, s, cgc); 1984 return dvd_read_manufact(cdi, s, cgc);
1966 1985
1967 default: 1986 default:
1968 cdinfo(CD_WARNING, ": Invalid DVD structure read requested (%d)\n", 1987 cd_dbg(CD_WARNING, ": Invalid DVD structure read requested (%d)\n",
1969 s->type); 1988 s->type);
1970 return -EINVAL; 1989 return -EINVAL;
1971 } 1990 }
1972} 1991}
@@ -2165,6 +2184,7 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2165 ret = -ENOMEM; 2184 ret = -ENOMEM;
2166 break; 2185 break;
2167 } 2186 }
2187 blk_rq_set_block_pc(rq);
2168 2188
2169 ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL); 2189 ret = blk_rq_map_user(q, rq, NULL, ubuf, len, GFP_KERNEL);
2170 if (ret) { 2190 if (ret) {
@@ -2184,7 +2204,6 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
2184 rq->cmd[9] = 0xf8; 2204 rq->cmd[9] = 0xf8;
2185 2205
2186 rq->cmd_len = 12; 2206 rq->cmd_len = 12;
2187 rq->cmd_type = REQ_TYPE_BLOCK_PC;
2188 rq->timeout = 60 * HZ; 2207 rq->timeout = 60 * HZ;
2189 bio = rq->bio; 2208 bio = rq->bio;
2190 2209
@@ -2255,7 +2274,7 @@ static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2255 u8 requested_format; 2274 u8 requested_format;
2256 int ret; 2275 int ret;
2257 2276
2258 cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n"); 2277 cd_dbg(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
2259 2278
2260 if (!(cdi->ops->capability & CDC_MULTI_SESSION)) 2279 if (!(cdi->ops->capability & CDC_MULTI_SESSION))
2261 return -ENOSYS; 2280 return -ENOSYS;
@@ -2277,13 +2296,13 @@ static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
2277 if (copy_to_user(argp, &ms_info, sizeof(ms_info))) 2296 if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
2278 return -EFAULT; 2297 return -EFAULT;
2279 2298
2280 cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n"); 2299 cd_dbg(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
2281 return 0; 2300 return 0;
2282} 2301}
2283 2302
2284static int cdrom_ioctl_eject(struct cdrom_device_info *cdi) 2303static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2285{ 2304{
2286 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n"); 2305 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT\n");
2287 2306
2288 if (!CDROM_CAN(CDC_OPEN_TRAY)) 2307 if (!CDROM_CAN(CDC_OPEN_TRAY))
2289 return -ENOSYS; 2308 return -ENOSYS;
@@ -2300,7 +2319,7 @@ static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
2300 2319
2301static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi) 2320static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2302{ 2321{
2303 cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n"); 2322 cd_dbg(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
2304 2323
2305 if (!CDROM_CAN(CDC_CLOSE_TRAY)) 2324 if (!CDROM_CAN(CDC_CLOSE_TRAY))
2306 return -ENOSYS; 2325 return -ENOSYS;
@@ -2310,7 +2329,7 @@ static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
2310static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi, 2329static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
2311 unsigned long arg) 2330 unsigned long arg)
2312{ 2331{
2313 cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n"); 2332 cd_dbg(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
2314 2333
2315 if (!CDROM_CAN(CDC_OPEN_TRAY)) 2334 if (!CDROM_CAN(CDC_OPEN_TRAY))
2316 return -ENOSYS; 2335 return -ENOSYS;
@@ -2329,7 +2348,7 @@ static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2329 struct cdrom_changer_info *info; 2348 struct cdrom_changer_info *info;
2330 int ret; 2349 int ret;
2331 2350
2332 cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n"); 2351 cd_dbg(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
2333 2352
2334 if (!CDROM_CAN(CDC_MEDIA_CHANGED)) 2353 if (!CDROM_CAN(CDC_MEDIA_CHANGED))
2335 return -ENOSYS; 2354 return -ENOSYS;
@@ -2355,7 +2374,7 @@ static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
2355static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi, 2374static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2356 unsigned long arg) 2375 unsigned long arg)
2357{ 2376{
2358 cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n"); 2377 cd_dbg(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
2359 2378
2360 /* 2379 /*
2361 * Options need to be in sync with capability. 2380 * Options need to be in sync with capability.
@@ -2383,7 +2402,7 @@ static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
2383static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi, 2402static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2384 unsigned long arg) 2403 unsigned long arg)
2385{ 2404{
2386 cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n"); 2405 cd_dbg(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
2387 2406
2388 cdi->options &= ~(int) arg; 2407 cdi->options &= ~(int) arg;
2389 return cdi->options; 2408 return cdi->options;
@@ -2392,7 +2411,7 @@ static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
2392static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi, 2411static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2393 unsigned long arg) 2412 unsigned long arg)
2394{ 2413{
2395 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n"); 2414 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
2396 2415
2397 if (!CDROM_CAN(CDC_SELECT_SPEED)) 2416 if (!CDROM_CAN(CDC_SELECT_SPEED))
2398 return -ENOSYS; 2417 return -ENOSYS;
@@ -2402,7 +2421,7 @@ static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
2402static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi, 2421static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2403 unsigned long arg) 2422 unsigned long arg)
2404{ 2423{
2405 cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n"); 2424 cd_dbg(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
2406 2425
2407 if (!CDROM_CAN(CDC_SELECT_DISC)) 2426 if (!CDROM_CAN(CDC_SELECT_DISC))
2408 return -ENOSYS; 2427 return -ENOSYS;
@@ -2420,14 +2439,14 @@ static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
2420 if (cdi->ops->select_disc) 2439 if (cdi->ops->select_disc)
2421 return cdi->ops->select_disc(cdi, arg); 2440 return cdi->ops->select_disc(cdi, arg);
2422 2441
2423 cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n"); 2442 cd_dbg(CD_CHANGER, "Using generic cdrom_select_disc()\n");
2424 return cdrom_select_disc(cdi, arg); 2443 return cdrom_select_disc(cdi, arg);
2425} 2444}
2426 2445
2427static int cdrom_ioctl_reset(struct cdrom_device_info *cdi, 2446static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2428 struct block_device *bdev) 2447 struct block_device *bdev)
2429{ 2448{
2430 cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n"); 2449 cd_dbg(CD_DO_IOCTL, "entering CDROM_RESET\n");
2431 2450
2432 if (!capable(CAP_SYS_ADMIN)) 2451 if (!capable(CAP_SYS_ADMIN))
2433 return -EACCES; 2452 return -EACCES;
@@ -2440,7 +2459,7 @@ static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
2440static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi, 2459static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2441 unsigned long arg) 2460 unsigned long arg)
2442{ 2461{
2443 cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl"); 2462 cd_dbg(CD_DO_IOCTL, "%socking door\n", arg ? "L" : "Unl");
2444 2463
2445 if (!CDROM_CAN(CDC_LOCK)) 2464 if (!CDROM_CAN(CDC_LOCK))
2446 return -EDRIVE_CANT_DO_THIS; 2465 return -EDRIVE_CANT_DO_THIS;
@@ -2459,7 +2478,7 @@ static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
2459static int cdrom_ioctl_debug(struct cdrom_device_info *cdi, 2478static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2460 unsigned long arg) 2479 unsigned long arg)
2461{ 2480{
2462 cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis"); 2481 cd_dbg(CD_DO_IOCTL, "%sabling debug\n", arg ? "En" : "Dis");
2463 2482
2464 if (!capable(CAP_SYS_ADMIN)) 2483 if (!capable(CAP_SYS_ADMIN))
2465 return -EACCES; 2484 return -EACCES;
@@ -2469,7 +2488,7 @@ static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
2469 2488
2470static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi) 2489static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
2471{ 2490{
2472 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n"); 2491 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
2473 return (cdi->ops->capability & ~cdi->mask); 2492 return (cdi->ops->capability & ~cdi->mask);
2474} 2493}
2475 2494
@@ -2485,7 +2504,7 @@ static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2485 struct cdrom_mcn mcn; 2504 struct cdrom_mcn mcn;
2486 int ret; 2505 int ret;
2487 2506
2488 cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n"); 2507 cd_dbg(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
2489 2508
2490 if (!(cdi->ops->capability & CDC_MCN)) 2509 if (!(cdi->ops->capability & CDC_MCN))
2491 return -ENOSYS; 2510 return -ENOSYS;
@@ -2495,14 +2514,14 @@ static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
2495 2514
2496 if (copy_to_user(argp, &mcn, sizeof(mcn))) 2515 if (copy_to_user(argp, &mcn, sizeof(mcn)))
2497 return -EFAULT; 2516 return -EFAULT;
2498 cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n"); 2517 cd_dbg(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
2499 return 0; 2518 return 0;
2500} 2519}
2501 2520
2502static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi, 2521static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
2503 unsigned long arg) 2522 unsigned long arg)
2504{ 2523{
2505 cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n"); 2524 cd_dbg(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
2506 2525
2507 if (!(cdi->ops->capability & CDC_DRIVE_STATUS)) 2526 if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
2508 return -ENOSYS; 2527 return -ENOSYS;
@@ -2535,7 +2554,7 @@ static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2535{ 2554{
2536 tracktype tracks; 2555 tracktype tracks;
2537 2556
2538 cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n"); 2557 cd_dbg(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
2539 2558
2540 cdrom_count_tracks(cdi, &tracks); 2559 cdrom_count_tracks(cdi, &tracks);
2541 if (tracks.error) 2560 if (tracks.error)
@@ -2557,13 +2576,13 @@ static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
2557 return CDS_DATA_1; 2576 return CDS_DATA_1;
2558 /* Policy mode off */ 2577 /* Policy mode off */
2559 2578
2560 cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n"); 2579 cd_dbg(CD_WARNING, "This disc doesn't have any tracks I recognize!\n");
2561 return CDS_NO_INFO; 2580 return CDS_NO_INFO;
2562} 2581}
2563 2582
2564static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi) 2583static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
2565{ 2584{
2566 cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n"); 2585 cd_dbg(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
2567 return cdi->capacity; 2586 return cdi->capacity;
2568} 2587}
2569 2588
@@ -2574,7 +2593,7 @@ static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2574 u8 requested, back; 2593 u8 requested, back;
2575 int ret; 2594 int ret;
2576 2595
2577 /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/ 2596 /* cd_dbg(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
2578 2597
2579 if (copy_from_user(&q, argp, sizeof(q))) 2598 if (copy_from_user(&q, argp, sizeof(q)))
2580 return -EFAULT; 2599 return -EFAULT;
@@ -2594,7 +2613,7 @@ static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
2594 2613
2595 if (copy_to_user(argp, &q, sizeof(q))) 2614 if (copy_to_user(argp, &q, sizeof(q)))
2596 return -EFAULT; 2615 return -EFAULT;
2597 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */ 2616 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2598 return 0; 2617 return 0;
2599} 2618}
2600 2619
@@ -2604,7 +2623,7 @@ static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2604 struct cdrom_tochdr header; 2623 struct cdrom_tochdr header;
2605 int ret; 2624 int ret;
2606 2625
2607 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */ 2626 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
2608 2627
2609 if (copy_from_user(&header, argp, sizeof(header))) 2628 if (copy_from_user(&header, argp, sizeof(header)))
2610 return -EFAULT; 2629 return -EFAULT;
@@ -2615,7 +2634,7 @@ static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
2615 2634
2616 if (copy_to_user(argp, &header, sizeof(header))) 2635 if (copy_to_user(argp, &header, sizeof(header)))
2617 return -EFAULT; 2636 return -EFAULT;
2618 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */ 2637 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
2619 return 0; 2638 return 0;
2620} 2639}
2621 2640
@@ -2626,7 +2645,7 @@ static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2626 u8 requested_format; 2645 u8 requested_format;
2627 int ret; 2646 int ret;
2628 2647
2629 /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */ 2648 /* cd_dbg(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
2630 2649
2631 if (copy_from_user(&entry, argp, sizeof(entry))) 2650 if (copy_from_user(&entry, argp, sizeof(entry)))
2632 return -EFAULT; 2651 return -EFAULT;
@@ -2643,7 +2662,7 @@ static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
2643 2662
2644 if (copy_to_user(argp, &entry, sizeof(entry))) 2663 if (copy_to_user(argp, &entry, sizeof(entry)))
2645 return -EFAULT; 2664 return -EFAULT;
2646 /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */ 2665 /* cd_dbg(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
2647 return 0; 2666 return 0;
2648} 2667}
2649 2668
@@ -2652,7 +2671,7 @@ static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
2652{ 2671{
2653 struct cdrom_msf msf; 2672 struct cdrom_msf msf;
2654 2673
2655 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n"); 2674 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2656 2675
2657 if (!CDROM_CAN(CDC_PLAY_AUDIO)) 2676 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2658 return -ENOSYS; 2677 return -ENOSYS;
@@ -2667,7 +2686,7 @@ static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
2667 struct cdrom_ti ti; 2686 struct cdrom_ti ti;
2668 int ret; 2687 int ret;
2669 2688
2670 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n"); 2689 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
2671 2690
2672 if (!CDROM_CAN(CDC_PLAY_AUDIO)) 2691 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2673 return -ENOSYS; 2692 return -ENOSYS;
@@ -2684,7 +2703,7 @@ static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
2684{ 2703{
2685 struct cdrom_volctrl volume; 2704 struct cdrom_volctrl volume;
2686 2705
2687 cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n"); 2706 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
2688 2707
2689 if (!CDROM_CAN(CDC_PLAY_AUDIO)) 2708 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2690 return -ENOSYS; 2709 return -ENOSYS;
@@ -2699,7 +2718,7 @@ static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
2699 struct cdrom_volctrl volume; 2718 struct cdrom_volctrl volume;
2700 int ret; 2719 int ret;
2701 2720
2702 cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n"); 2721 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
2703 2722
2704 if (!CDROM_CAN(CDC_PLAY_AUDIO)) 2723 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2705 return -ENOSYS; 2724 return -ENOSYS;
@@ -2718,7 +2737,7 @@ static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2718{ 2737{
2719 int ret; 2738 int ret;
2720 2739
2721 cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n"); 2740 cd_dbg(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
2722 2741
2723 if (!CDROM_CAN(CDC_PLAY_AUDIO)) 2742 if (!CDROM_CAN(CDC_PLAY_AUDIO))
2724 return -ENOSYS; 2743 return -ENOSYS;
@@ -2729,103 +2748,6 @@ static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
2729} 2748}
2730 2749
2731/* 2750/*
2732 * Just about every imaginable ioctl is supported in the Uniform layer
2733 * these days.
2734 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
2735 */
2736int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
2737 fmode_t mode, unsigned int cmd, unsigned long arg)
2738{
2739 void __user *argp = (void __user *)arg;
2740 int ret;
2741
2742 /*
2743 * Try the generic SCSI command ioctl's first.
2744 */
2745 ret = scsi_cmd_blk_ioctl(bdev, mode, cmd, argp);
2746 if (ret != -ENOTTY)
2747 return ret;
2748
2749 switch (cmd) {
2750 case CDROMMULTISESSION:
2751 return cdrom_ioctl_multisession(cdi, argp);
2752 case CDROMEJECT:
2753 return cdrom_ioctl_eject(cdi);
2754 case CDROMCLOSETRAY:
2755 return cdrom_ioctl_closetray(cdi);
2756 case CDROMEJECT_SW:
2757 return cdrom_ioctl_eject_sw(cdi, arg);
2758 case CDROM_MEDIA_CHANGED:
2759 return cdrom_ioctl_media_changed(cdi, arg);
2760 case CDROM_SET_OPTIONS:
2761 return cdrom_ioctl_set_options(cdi, arg);
2762 case CDROM_CLEAR_OPTIONS:
2763 return cdrom_ioctl_clear_options(cdi, arg);
2764 case CDROM_SELECT_SPEED:
2765 return cdrom_ioctl_select_speed(cdi, arg);
2766 case CDROM_SELECT_DISC:
2767 return cdrom_ioctl_select_disc(cdi, arg);
2768 case CDROMRESET:
2769 return cdrom_ioctl_reset(cdi, bdev);
2770 case CDROM_LOCKDOOR:
2771 return cdrom_ioctl_lock_door(cdi, arg);
2772 case CDROM_DEBUG:
2773 return cdrom_ioctl_debug(cdi, arg);
2774 case CDROM_GET_CAPABILITY:
2775 return cdrom_ioctl_get_capability(cdi);
2776 case CDROM_GET_MCN:
2777 return cdrom_ioctl_get_mcn(cdi, argp);
2778 case CDROM_DRIVE_STATUS:
2779 return cdrom_ioctl_drive_status(cdi, arg);
2780 case CDROM_DISC_STATUS:
2781 return cdrom_ioctl_disc_status(cdi);
2782 case CDROM_CHANGER_NSLOTS:
2783 return cdrom_ioctl_changer_nslots(cdi);
2784 }
2785
2786 /*
2787 * Use the ioctls that are implemented through the generic_packet()
2788 * interface. this may look at bit funny, but if -ENOTTY is
2789 * returned that particular ioctl is not implemented and we
2790 * let it go through the device specific ones.
2791 */
2792 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
2793 ret = mmc_ioctl(cdi, cmd, arg);
2794 if (ret != -ENOTTY)
2795 return ret;
2796 }
2797
2798 /*
2799 * Note: most of the cdinfo() calls are commented out here,
2800 * because they fill up the sys log when CD players poll
2801 * the drive.
2802 */
2803 switch (cmd) {
2804 case CDROMSUBCHNL:
2805 return cdrom_ioctl_get_subchnl(cdi, argp);
2806 case CDROMREADTOCHDR:
2807 return cdrom_ioctl_read_tochdr(cdi, argp);
2808 case CDROMREADTOCENTRY:
2809 return cdrom_ioctl_read_tocentry(cdi, argp);
2810 case CDROMPLAYMSF:
2811 return cdrom_ioctl_play_msf(cdi, argp);
2812 case CDROMPLAYTRKIND:
2813 return cdrom_ioctl_play_trkind(cdi, argp);
2814 case CDROMVOLCTRL:
2815 return cdrom_ioctl_volctrl(cdi, argp);
2816 case CDROMVOLREAD:
2817 return cdrom_ioctl_volread(cdi, argp);
2818 case CDROMSTART:
2819 case CDROMSTOP:
2820 case CDROMPAUSE:
2821 case CDROMRESUME:
2822 return cdrom_ioctl_audioctl(cdi, cmd);
2823 }
2824
2825 return -ENOSYS;
2826}
2827
2828/*
2829 * Required when we need to use READ_10 to issue other than 2048 block 2751 * Required when we need to use READ_10 to issue other than 2048 block
2830 * reads 2752 * reads
2831 */ 2753 */
@@ -2854,10 +2776,158 @@ static int cdrom_switch_blocksize(struct cdrom_device_info *cdi, int size)
2854 return cdo->generic_packet(cdi, &cgc); 2776 return cdo->generic_packet(cdi, &cgc);
2855} 2777}
2856 2778
2779static int cdrom_get_track_info(struct cdrom_device_info *cdi,
2780 __u16 track, __u8 type, track_information *ti)
2781{
2782 struct cdrom_device_ops *cdo = cdi->ops;
2783 struct packet_command cgc;
2784 int ret, buflen;
2785
2786 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
2787 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
2788 cgc.cmd[1] = type & 3;
2789 cgc.cmd[4] = (track & 0xff00) >> 8;
2790 cgc.cmd[5] = track & 0xff;
2791 cgc.cmd[8] = 8;
2792 cgc.quiet = 1;
2793
2794 ret = cdo->generic_packet(cdi, &cgc);
2795 if (ret)
2796 return ret;
2797
2798 buflen = be16_to_cpu(ti->track_information_length) +
2799 sizeof(ti->track_information_length);
2800
2801 if (buflen > sizeof(track_information))
2802 buflen = sizeof(track_information);
2803
2804 cgc.cmd[8] = cgc.buflen = buflen;
2805 ret = cdo->generic_packet(cdi, &cgc);
2806 if (ret)
2807 return ret;
2808
2809 /* return actual fill size */
2810 return buflen;
2811}
2812
2813/* return the last written block on the CD-R media. this is for the udf
2814 file system. */
2815int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written)
2816{
2817 struct cdrom_tocentry toc;
2818 disc_information di;
2819 track_information ti;
2820 __u32 last_track;
2821 int ret = -1, ti_size;
2822
2823 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2824 goto use_toc;
2825
2826 ret = cdrom_get_disc_info(cdi, &di);
2827 if (ret < (int)(offsetof(typeof(di), last_track_lsb)
2828 + sizeof(di.last_track_lsb)))
2829 goto use_toc;
2830
2831 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2832 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2833 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2834 if (ti_size < (int)offsetof(typeof(ti), track_start))
2835 goto use_toc;
2836
2837 /* if this track is blank, try the previous. */
2838 if (ti.blank) {
2839 if (last_track == 1)
2840 goto use_toc;
2841 last_track--;
2842 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2843 }
2844
2845 if (ti_size < (int)(offsetof(typeof(ti), track_size)
2846 + sizeof(ti.track_size)))
2847 goto use_toc;
2848
2849 /* if last recorded field is valid, return it. */
2850 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
2851 + sizeof(ti.last_rec_address))) {
2852 *last_written = be32_to_cpu(ti.last_rec_address);
2853 } else {
2854 /* make it up instead */
2855 *last_written = be32_to_cpu(ti.track_start) +
2856 be32_to_cpu(ti.track_size);
2857 if (ti.free_blocks)
2858 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
2859 }
2860 return 0;
2861
2862 /* this is where we end up if the drive either can't do a
2863 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if
2864 it doesn't give enough information or fails. then we return
2865 the toc contents. */
2866use_toc:
2867 toc.cdte_format = CDROM_MSF;
2868 toc.cdte_track = CDROM_LEADOUT;
2869 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc)))
2870 return ret;
2871 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA);
2872 *last_written = toc.cdte_addr.lba;
2873 return 0;
2874}
2875
2876/* return the next writable block. also for udf file system. */
2877static int cdrom_get_next_writable(struct cdrom_device_info *cdi,
2878 long *next_writable)
2879{
2880 disc_information di;
2881 track_information ti;
2882 __u16 last_track;
2883 int ret, ti_size;
2884
2885 if (!CDROM_CAN(CDC_GENERIC_PACKET))
2886 goto use_last_written;
2887
2888 ret = cdrom_get_disc_info(cdi, &di);
2889 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
2890 + sizeof(di.last_track_lsb))
2891 goto use_last_written;
2892
2893 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
2894 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
2895 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2896 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
2897 goto use_last_written;
2898
2899 /* if this track is blank, try the previous. */
2900 if (ti.blank) {
2901 if (last_track == 1)
2902 goto use_last_written;
2903 last_track--;
2904 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
2905 if (ti_size < 0)
2906 goto use_last_written;
2907 }
2908
2909 /* if next recordable address field is valid, use it. */
2910 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable)
2911 + sizeof(ti.next_writable)) {
2912 *next_writable = be32_to_cpu(ti.next_writable);
2913 return 0;
2914 }
2915
2916use_last_written:
2917 ret = cdrom_get_last_written(cdi, next_writable);
2918 if (ret) {
2919 *next_writable = 0;
2920 return ret;
2921 } else {
2922 *next_writable += 7;
2923 return 0;
2924 }
2925}
2926
2857static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi, 2927static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2858 void __user *arg, 2928 void __user *arg,
2859 struct packet_command *cgc, 2929 struct packet_command *cgc,
2860 int cmd) 2930 int cmd)
2861{ 2931{
2862 struct request_sense sense; 2932 struct request_sense sense;
2863 struct cdrom_msf msf; 2933 struct cdrom_msf msf;
@@ -2876,7 +2946,8 @@ static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2876 blocksize = CD_FRAMESIZE_RAW0; 2946 blocksize = CD_FRAMESIZE_RAW0;
2877 break; 2947 break;
2878 } 2948 }
2879 IOCTL_IN(arg, struct cdrom_msf, msf); 2949 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
2950 return -EFAULT;
2880 lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); 2951 lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2881 /* FIXME: we need upper bound checking, too!! */ 2952 /* FIXME: we need upper bound checking, too!! */
2882 if (lba < 0) 2953 if (lba < 0)
@@ -2891,8 +2962,8 @@ static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
2891 cgc->data_direction = CGC_DATA_READ; 2962 cgc->data_direction = CGC_DATA_READ;
2892 ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize); 2963 ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
2893 if (ret && sense.sense_key == 0x05 && 2964 if (ret && sense.sense_key == 0x05 &&
2894 sense.asc == 0x20 && 2965 sense.asc == 0x20 &&
2895 sense.ascq == 0x00) { 2966 sense.ascq == 0x00) {
2896 /* 2967 /*
2897 * SCSI-II devices are not required to support 2968 * SCSI-II devices are not required to support
2898 * READ_CD, so let's try switching block size 2969 * READ_CD, so let's try switching block size
@@ -2913,12 +2984,14 @@ out:
2913} 2984}
2914 2985
2915static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi, 2986static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
2916 void __user *arg) 2987 void __user *arg)
2917{ 2988{
2918 struct cdrom_read_audio ra; 2989 struct cdrom_read_audio ra;
2919 int lba; 2990 int lba;
2920 2991
2921 IOCTL_IN(arg, struct cdrom_read_audio, ra); 2992 if (copy_from_user(&ra, (struct cdrom_read_audio __user *)arg,
2993 sizeof(ra)))
2994 return -EFAULT;
2922 2995
2923 if (ra.addr_format == CDROM_MSF) 2996 if (ra.addr_format == CDROM_MSF)
2924 lba = msf_to_lba(ra.addr.msf.minute, 2997 lba = msf_to_lba(ra.addr.msf.minute,
@@ -2937,12 +3010,13 @@ static noinline int mmc_ioctl_cdrom_read_audio(struct cdrom_device_info *cdi,
2937} 3010}
2938 3011
2939static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi, 3012static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
2940 void __user *arg) 3013 void __user *arg)
2941{ 3014{
2942 int ret; 3015 int ret;
2943 struct cdrom_subchnl q; 3016 struct cdrom_subchnl q;
2944 u_char requested, back; 3017 u_char requested, back;
2945 IOCTL_IN(arg, struct cdrom_subchnl, q); 3018 if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q)))
3019 return -EFAULT;
2946 requested = q.cdsc_format; 3020 requested = q.cdsc_format;
2947 if (!((requested == CDROM_MSF) || 3021 if (!((requested == CDROM_MSF) ||
2948 (requested == CDROM_LBA))) 3022 (requested == CDROM_LBA)))
@@ -2954,19 +3028,21 @@ static noinline int mmc_ioctl_cdrom_subchannel(struct cdrom_device_info *cdi,
2954 back = q.cdsc_format; /* local copy */ 3028 back = q.cdsc_format; /* local copy */
2955 sanitize_format(&q.cdsc_absaddr, &back, requested); 3029 sanitize_format(&q.cdsc_absaddr, &back, requested);
2956 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested); 3030 sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
2957 IOCTL_OUT(arg, struct cdrom_subchnl, q); 3031 if (copy_to_user((struct cdrom_subchnl __user *)arg, &q, sizeof(q)))
2958 /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */ 3032 return -EFAULT;
3033 /* cd_dbg(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
2959 return 0; 3034 return 0;
2960} 3035}
2961 3036
2962static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi, 3037static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
2963 void __user *arg, 3038 void __user *arg,
2964 struct packet_command *cgc) 3039 struct packet_command *cgc)
2965{ 3040{
2966 struct cdrom_device_ops *cdo = cdi->ops; 3041 struct cdrom_device_ops *cdo = cdi->ops;
2967 struct cdrom_msf msf; 3042 struct cdrom_msf msf;
2968 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n"); 3043 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
2969 IOCTL_IN(arg, struct cdrom_msf, msf); 3044 if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf)))
3045 return -EFAULT;
2970 cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF; 3046 cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2971 cgc->cmd[3] = msf.cdmsf_min0; 3047 cgc->cmd[3] = msf.cdmsf_min0;
2972 cgc->cmd[4] = msf.cdmsf_sec0; 3048 cgc->cmd[4] = msf.cdmsf_sec0;
@@ -2979,13 +3055,14 @@ static noinline int mmc_ioctl_cdrom_play_msf(struct cdrom_device_info *cdi,
2979} 3055}
2980 3056
2981static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi, 3057static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
2982 void __user *arg, 3058 void __user *arg,
2983 struct packet_command *cgc) 3059 struct packet_command *cgc)
2984{ 3060{
2985 struct cdrom_device_ops *cdo = cdi->ops; 3061 struct cdrom_device_ops *cdo = cdi->ops;
2986 struct cdrom_blk blk; 3062 struct cdrom_blk blk;
2987 cdinfo(CD_DO_IOCTL, "entering CDROMPLAYBLK\n"); 3063 cd_dbg(CD_DO_IOCTL, "entering CDROMPLAYBLK\n");
2988 IOCTL_IN(arg, struct cdrom_blk, blk); 3064 if (copy_from_user(&blk, (struct cdrom_blk __user *)arg, sizeof(blk)))
3065 return -EFAULT;
2989 cgc->cmd[0] = GPCMD_PLAY_AUDIO_10; 3066 cgc->cmd[0] = GPCMD_PLAY_AUDIO_10;
2990 cgc->cmd[2] = (blk.from >> 24) & 0xff; 3067 cgc->cmd[2] = (blk.from >> 24) & 0xff;
2991 cgc->cmd[3] = (blk.from >> 16) & 0xff; 3068 cgc->cmd[3] = (blk.from >> 16) & 0xff;
@@ -2998,9 +3075,9 @@ static noinline int mmc_ioctl_cdrom_play_blk(struct cdrom_device_info *cdi,
2998} 3075}
2999 3076
3000static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi, 3077static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3001 void __user *arg, 3078 void __user *arg,
3002 struct packet_command *cgc, 3079 struct packet_command *cgc,
3003 unsigned int cmd) 3080 unsigned int cmd)
3004{ 3081{
3005 struct cdrom_volctrl volctrl; 3082 struct cdrom_volctrl volctrl;
3006 unsigned char buffer[32]; 3083 unsigned char buffer[32];
@@ -3008,9 +3085,11 @@ static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3008 unsigned short offset; 3085 unsigned short offset;
3009 int ret; 3086 int ret;
3010 3087
3011 cdinfo(CD_DO_IOCTL, "entering CDROMVOLUME\n"); 3088 cd_dbg(CD_DO_IOCTL, "entering CDROMVOLUME\n");
3012 3089
3013 IOCTL_IN(arg, struct cdrom_volctrl, volctrl); 3090 if (copy_from_user(&volctrl, (struct cdrom_volctrl __user *)arg,
3091 sizeof(volctrl)))
3092 return -EFAULT;
3014 3093
3015 cgc->buffer = buffer; 3094 cgc->buffer = buffer;
3016 cgc->buflen = 24; 3095 cgc->buflen = 24;
@@ -3030,14 +3109,14 @@ static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3030 if (offset + 16 > cgc->buflen) { 3109 if (offset + 16 > cgc->buflen) {
3031 cgc->buflen = offset + 16; 3110 cgc->buflen = offset + 16;
3032 ret = cdrom_mode_sense(cdi, cgc, 3111 ret = cdrom_mode_sense(cdi, cgc,
3033 GPMODE_AUDIO_CTL_PAGE, 0); 3112 GPMODE_AUDIO_CTL_PAGE, 0);
3034 if (ret) 3113 if (ret)
3035 return ret; 3114 return ret;
3036 } 3115 }
3037 3116
3038 /* sanity check */ 3117 /* sanity check */
3039 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE || 3118 if ((buffer[offset] & 0x3f) != GPMODE_AUDIO_CTL_PAGE ||
3040 buffer[offset + 1] < 14) 3119 buffer[offset + 1] < 14)
3041 return -EINVAL; 3120 return -EINVAL;
3042 3121
3043 /* now we have the current volume settings. if it was only 3122 /* now we have the current volume settings. if it was only
@@ -3047,7 +3126,9 @@ static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3047 volctrl.channel1 = buffer[offset+11]; 3126 volctrl.channel1 = buffer[offset+11];
3048 volctrl.channel2 = buffer[offset+13]; 3127 volctrl.channel2 = buffer[offset+13];
3049 volctrl.channel3 = buffer[offset+15]; 3128 volctrl.channel3 = buffer[offset+15];
3050 IOCTL_OUT(arg, struct cdrom_volctrl, volctrl); 3129 if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl,
3130 sizeof(volctrl)))
3131 return -EFAULT;
3051 return 0; 3132 return 0;
3052 } 3133 }
3053 3134
@@ -3069,11 +3150,11 @@ static noinline int mmc_ioctl_cdrom_volume(struct cdrom_device_info *cdi,
3069} 3150}
3070 3151
3071static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi, 3152static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3072 struct packet_command *cgc, 3153 struct packet_command *cgc,
3073 int cmd) 3154 int cmd)
3074{ 3155{
3075 struct cdrom_device_ops *cdo = cdi->ops; 3156 struct cdrom_device_ops *cdo = cdi->ops;
3076 cdinfo(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n"); 3157 cd_dbg(CD_DO_IOCTL, "entering CDROMSTART/CDROMSTOP\n");
3077 cgc->cmd[0] = GPCMD_START_STOP_UNIT; 3158 cgc->cmd[0] = GPCMD_START_STOP_UNIT;
3078 cgc->cmd[1] = 1; 3159 cgc->cmd[1] = 1;
3079 cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0; 3160 cgc->cmd[4] = (cmd == CDROMSTART) ? 1 : 0;
@@ -3082,11 +3163,11 @@ static noinline int mmc_ioctl_cdrom_start_stop(struct cdrom_device_info *cdi,
3082} 3163}
3083 3164
3084static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi, 3165static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3085 struct packet_command *cgc, 3166 struct packet_command *cgc,
3086 int cmd) 3167 int cmd)
3087{ 3168{
3088 struct cdrom_device_ops *cdo = cdi->ops; 3169 struct cdrom_device_ops *cdo = cdi->ops;
3089 cdinfo(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n"); 3170 cd_dbg(CD_DO_IOCTL, "entering CDROMPAUSE/CDROMRESUME\n");
3090 cgc->cmd[0] = GPCMD_PAUSE_RESUME; 3171 cgc->cmd[0] = GPCMD_PAUSE_RESUME;
3091 cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0; 3172 cgc->cmd[8] = (cmd == CDROMRESUME) ? 1 : 0;
3092 cgc->data_direction = CGC_DATA_NONE; 3173 cgc->data_direction = CGC_DATA_NONE;
@@ -3094,8 +3175,8 @@ static noinline int mmc_ioctl_cdrom_pause_resume(struct cdrom_device_info *cdi,
3094} 3175}
3095 3176
3096static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi, 3177static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3097 void __user *arg, 3178 void __user *arg,
3098 struct packet_command *cgc) 3179 struct packet_command *cgc)
3099{ 3180{
3100 int ret; 3181 int ret;
3101 dvd_struct *s; 3182 dvd_struct *s;
@@ -3108,7 +3189,7 @@ static noinline int mmc_ioctl_dvd_read_struct(struct cdrom_device_info *cdi,
3108 if (!s) 3189 if (!s)
3109 return -ENOMEM; 3190 return -ENOMEM;
3110 3191
3111 cdinfo(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n"); 3192 cd_dbg(CD_DO_IOCTL, "entering DVD_READ_STRUCT\n");
3112 if (copy_from_user(s, arg, size)) { 3193 if (copy_from_user(s, arg, size)) {
3113 kfree(s); 3194 kfree(s);
3114 return -EFAULT; 3195 return -EFAULT;
@@ -3126,44 +3207,48 @@ out:
3126} 3207}
3127 3208
3128static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi, 3209static noinline int mmc_ioctl_dvd_auth(struct cdrom_device_info *cdi,
3129 void __user *arg) 3210 void __user *arg)
3130{ 3211{
3131 int ret; 3212 int ret;
3132 dvd_authinfo ai; 3213 dvd_authinfo ai;
3133 if (!CDROM_CAN(CDC_DVD)) 3214 if (!CDROM_CAN(CDC_DVD))
3134 return -ENOSYS; 3215 return -ENOSYS;
3135 cdinfo(CD_DO_IOCTL, "entering DVD_AUTH\n"); 3216 cd_dbg(CD_DO_IOCTL, "entering DVD_AUTH\n");
3136 IOCTL_IN(arg, dvd_authinfo, ai); 3217 if (copy_from_user(&ai, (dvd_authinfo __user *)arg, sizeof(ai)))
3218 return -EFAULT;
3137 ret = dvd_do_auth(cdi, &ai); 3219 ret = dvd_do_auth(cdi, &ai);
3138 if (ret) 3220 if (ret)
3139 return ret; 3221 return ret;
3140 IOCTL_OUT(arg, dvd_authinfo, ai); 3222 if (copy_to_user((dvd_authinfo __user *)arg, &ai, sizeof(ai)))
3223 return -EFAULT;
3141 return 0; 3224 return 0;
3142} 3225}
3143 3226
3144static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi, 3227static noinline int mmc_ioctl_cdrom_next_writable(struct cdrom_device_info *cdi,
3145 void __user *arg) 3228 void __user *arg)
3146{ 3229{
3147 int ret; 3230 int ret;
3148 long next = 0; 3231 long next = 0;
3149 cdinfo(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n"); 3232 cd_dbg(CD_DO_IOCTL, "entering CDROM_NEXT_WRITABLE\n");
3150 ret = cdrom_get_next_writable(cdi, &next); 3233 ret = cdrom_get_next_writable(cdi, &next);
3151 if (ret) 3234 if (ret)
3152 return ret; 3235 return ret;
3153 IOCTL_OUT(arg, long, next); 3236 if (copy_to_user((long __user *)arg, &next, sizeof(next)))
3237 return -EFAULT;
3154 return 0; 3238 return 0;
3155} 3239}
3156 3240
3157static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi, 3241static noinline int mmc_ioctl_cdrom_last_written(struct cdrom_device_info *cdi,
3158 void __user *arg) 3242 void __user *arg)
3159{ 3243{
3160 int ret; 3244 int ret;
3161 long last = 0; 3245 long last = 0;
3162 cdinfo(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n"); 3246 cd_dbg(CD_DO_IOCTL, "entering CDROM_LAST_WRITTEN\n");
3163 ret = cdrom_get_last_written(cdi, &last); 3247 ret = cdrom_get_last_written(cdi, &last);
3164 if (ret) 3248 if (ret)
3165 return ret; 3249 return ret;
3166 IOCTL_OUT(arg, long, last); 3250 if (copy_to_user((long __user *)arg, &last, sizeof(last)))
3251 return -EFAULT;
3167 return 0; 3252 return 0;
3168} 3253}
3169 3254
@@ -3212,181 +3297,101 @@ static int mmc_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
3212 return -ENOTTY; 3297 return -ENOTTY;
3213} 3298}
3214 3299
3215static int cdrom_get_track_info(struct cdrom_device_info *cdi, __u16 track, __u8 type, 3300/*
3216 track_information *ti) 3301 * Just about every imaginable ioctl is supported in the Uniform layer
3217{ 3302 * these days.
3218 struct cdrom_device_ops *cdo = cdi->ops; 3303 * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
3219 struct packet_command cgc; 3304 */
3220 int ret, buflen; 3305int cdrom_ioctl(struct cdrom_device_info *cdi, struct block_device *bdev,
3221 3306 fmode_t mode, unsigned int cmd, unsigned long arg)
3222 init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
3223 cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
3224 cgc.cmd[1] = type & 3;
3225 cgc.cmd[4] = (track & 0xff00) >> 8;
3226 cgc.cmd[5] = track & 0xff;
3227 cgc.cmd[8] = 8;
3228 cgc.quiet = 1;
3229
3230 if ((ret = cdo->generic_packet(cdi, &cgc)))
3231 return ret;
3232
3233 buflen = be16_to_cpu(ti->track_information_length) +
3234 sizeof(ti->track_information_length);
3235
3236 if (buflen > sizeof(track_information))
3237 buflen = sizeof(track_information);
3238
3239 cgc.cmd[8] = cgc.buflen = buflen;
3240 if ((ret = cdo->generic_packet(cdi, &cgc)))
3241 return ret;
3242
3243 /* return actual fill size */
3244 return buflen;
3245}
3246
3247/* requires CD R/RW */
3248static int cdrom_get_disc_info(struct cdrom_device_info *cdi, disc_information *di)
3249{ 3307{
3250 struct cdrom_device_ops *cdo = cdi->ops; 3308 void __user *argp = (void __user *)arg;
3251 struct packet_command cgc; 3309 int ret;
3252 int ret, buflen;
3253
3254 /* set up command and get the disc info */
3255 init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
3256 cgc.cmd[0] = GPCMD_READ_DISC_INFO;
3257 cgc.cmd[8] = cgc.buflen = 2;
3258 cgc.quiet = 1;
3259
3260 if ((ret = cdo->generic_packet(cdi, &cgc)))
3261 return ret;
3262 3310
3263 /* not all drives have the same disc_info length, so requeue 3311 /*
3264 * packet with the length the drive tells us it can supply 3312 * Try the generic SCSI command ioctl's first.
3265 */ 3313 */
3266 buflen = be16_to_cpu(di->disc_information_length) + 3314 ret = scsi_cmd_blk_ioctl(bdev, mode, cmd, argp);
3267 sizeof(di->disc_information_length); 3315 if (ret != -ENOTTY)
3268
3269 if (buflen > sizeof(disc_information))
3270 buflen = sizeof(disc_information);
3271
3272 cgc.cmd[8] = cgc.buflen = buflen;
3273 if ((ret = cdo->generic_packet(cdi, &cgc)))
3274 return ret; 3316 return ret;
3275 3317
3276 /* return actual fill size */ 3318 switch (cmd) {
3277 return buflen; 3319 case CDROMMULTISESSION:
3278} 3320 return cdrom_ioctl_multisession(cdi, argp);
3279 3321 case CDROMEJECT:
3280/* return the last written block on the CD-R media. this is for the udf 3322 return cdrom_ioctl_eject(cdi);
3281 file system. */ 3323 case CDROMCLOSETRAY:
3282int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written) 3324 return cdrom_ioctl_closetray(cdi);
3283{ 3325 case CDROMEJECT_SW:
3284 struct cdrom_tocentry toc; 3326 return cdrom_ioctl_eject_sw(cdi, arg);
3285 disc_information di; 3327 case CDROM_MEDIA_CHANGED:
3286 track_information ti; 3328 return cdrom_ioctl_media_changed(cdi, arg);
3287 __u32 last_track; 3329 case CDROM_SET_OPTIONS:
3288 int ret = -1, ti_size; 3330 return cdrom_ioctl_set_options(cdi, arg);
3289 3331 case CDROM_CLEAR_OPTIONS:
3290 if (!CDROM_CAN(CDC_GENERIC_PACKET)) 3332 return cdrom_ioctl_clear_options(cdi, arg);
3291 goto use_toc; 3333 case CDROM_SELECT_SPEED:
3292 3334 return cdrom_ioctl_select_speed(cdi, arg);
3293 ret = cdrom_get_disc_info(cdi, &di); 3335 case CDROM_SELECT_DISC:
3294 if (ret < (int)(offsetof(typeof(di), last_track_lsb) 3336 return cdrom_ioctl_select_disc(cdi, arg);
3295 + sizeof(di.last_track_lsb))) 3337 case CDROMRESET:
3296 goto use_toc; 3338 return cdrom_ioctl_reset(cdi, bdev);
3297 3339 case CDROM_LOCKDOOR:
3298 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */ 3340 return cdrom_ioctl_lock_door(cdi, arg);
3299 last_track = (di.last_track_msb << 8) | di.last_track_lsb; 3341 case CDROM_DEBUG:
3300 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti); 3342 return cdrom_ioctl_debug(cdi, arg);
3301 if (ti_size < (int)offsetof(typeof(ti), track_start)) 3343 case CDROM_GET_CAPABILITY:
3302 goto use_toc; 3344 return cdrom_ioctl_get_capability(cdi);
3303 3345 case CDROM_GET_MCN:
3304 /* if this track is blank, try the previous. */ 3346 return cdrom_ioctl_get_mcn(cdi, argp);
3305 if (ti.blank) { 3347 case CDROM_DRIVE_STATUS:
3306 if (last_track==1) 3348 return cdrom_ioctl_drive_status(cdi, arg);
3307 goto use_toc; 3349 case CDROM_DISC_STATUS:
3308 last_track--; 3350 return cdrom_ioctl_disc_status(cdi);
3309 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti); 3351 case CDROM_CHANGER_NSLOTS:
3310 } 3352 return cdrom_ioctl_changer_nslots(cdi);
3311
3312 if (ti_size < (int)(offsetof(typeof(ti), track_size)
3313 + sizeof(ti.track_size)))
3314 goto use_toc;
3315
3316 /* if last recorded field is valid, return it. */
3317 if (ti.lra_v && ti_size >= (int)(offsetof(typeof(ti), last_rec_address)
3318 + sizeof(ti.last_rec_address))) {
3319 *last_written = be32_to_cpu(ti.last_rec_address);
3320 } else {
3321 /* make it up instead */
3322 *last_written = be32_to_cpu(ti.track_start) +
3323 be32_to_cpu(ti.track_size);
3324 if (ti.free_blocks)
3325 *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
3326 } 3353 }
3327 return 0;
3328 3354
3329 /* this is where we end up if the drive either can't do a 3355 /*
3330 GPCMD_READ_DISC_INFO or GPCMD_READ_TRACK_RZONE_INFO or if 3356 * Use the ioctls that are implemented through the generic_packet()
3331 it doesn't give enough information or fails. then we return 3357 * interface. this may look at bit funny, but if -ENOTTY is
3332 the toc contents. */ 3358 * returned that particular ioctl is not implemented and we
3333use_toc: 3359 * let it go through the device specific ones.
3334 toc.cdte_format = CDROM_MSF; 3360 */
3335 toc.cdte_track = CDROM_LEADOUT; 3361 if (CDROM_CAN(CDC_GENERIC_PACKET)) {
3336 if ((ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &toc))) 3362 ret = mmc_ioctl(cdi, cmd, arg);
3337 return ret; 3363 if (ret != -ENOTTY)
3338 sanitize_format(&toc.cdte_addr, &toc.cdte_format, CDROM_LBA); 3364 return ret;
3339 *last_written = toc.cdte_addr.lba;
3340 return 0;
3341}
3342
3343/* return the next writable block. also for udf file system. */
3344static int cdrom_get_next_writable(struct cdrom_device_info *cdi, long *next_writable)
3345{
3346 disc_information di;
3347 track_information ti;
3348 __u16 last_track;
3349 int ret, ti_size;
3350
3351 if (!CDROM_CAN(CDC_GENERIC_PACKET))
3352 goto use_last_written;
3353
3354 ret = cdrom_get_disc_info(cdi, &di);
3355 if (ret < 0 || ret < offsetof(typeof(di), last_track_lsb)
3356 + sizeof(di.last_track_lsb))
3357 goto use_last_written;
3358
3359 /* if unit didn't return msb, it's zeroed by cdrom_get_disc_info */
3360 last_track = (di.last_track_msb << 8) | di.last_track_lsb;
3361 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3362 if (ti_size < 0 || ti_size < offsetof(typeof(ti), track_start))
3363 goto use_last_written;
3364
3365 /* if this track is blank, try the previous. */
3366 if (ti.blank) {
3367 if (last_track == 1)
3368 goto use_last_written;
3369 last_track--;
3370 ti_size = cdrom_get_track_info(cdi, last_track, 1, &ti);
3371 if (ti_size < 0)
3372 goto use_last_written;
3373 } 3365 }
3374 3366
3375 /* if next recordable address field is valid, use it. */ 3367 /*
3376 if (ti.nwa_v && ti_size >= offsetof(typeof(ti), next_writable) 3368 * Note: most of the cd_dbg() calls are commented out here,
3377 + sizeof(ti.next_writable)) { 3369 * because they fill up the sys log when CD players poll
3378 *next_writable = be32_to_cpu(ti.next_writable); 3370 * the drive.
3379 return 0; 3371 */
3372 switch (cmd) {
3373 case CDROMSUBCHNL:
3374 return cdrom_ioctl_get_subchnl(cdi, argp);
3375 case CDROMREADTOCHDR:
3376 return cdrom_ioctl_read_tochdr(cdi, argp);
3377 case CDROMREADTOCENTRY:
3378 return cdrom_ioctl_read_tocentry(cdi, argp);
3379 case CDROMPLAYMSF:
3380 return cdrom_ioctl_play_msf(cdi, argp);
3381 case CDROMPLAYTRKIND:
3382 return cdrom_ioctl_play_trkind(cdi, argp);
3383 case CDROMVOLCTRL:
3384 return cdrom_ioctl_volctrl(cdi, argp);
3385 case CDROMVOLREAD:
3386 return cdrom_ioctl_volread(cdi, argp);
3387 case CDROMSTART:
3388 case CDROMSTOP:
3389 case CDROMPAUSE:
3390 case CDROMRESUME:
3391 return cdrom_ioctl_audioctl(cdi, cmd);
3380 } 3392 }
3381 3393
3382use_last_written: 3394 return -ENOSYS;
3383 if ((ret = cdrom_get_last_written(cdi, next_writable))) {
3384 *next_writable = 0;
3385 return ret;
3386 } else {
3387 *next_writable += 7;
3388 return 0;
3389 }
3390} 3395}
3391 3396
3392EXPORT_SYMBOL(cdrom_get_last_written); 3397EXPORT_SYMBOL(cdrom_get_last_written);
@@ -3465,7 +3470,7 @@ static int cdrom_print_info(const char *header, int val, char *info,
3465 return 0; 3470 return 0;
3466} 3471}
3467 3472
3468static int cdrom_sysctl_info(ctl_table *ctl, int write, 3473static int cdrom_sysctl_info(struct ctl_table *ctl, int write,
3469 void __user *buffer, size_t *lenp, loff_t *ppos) 3474 void __user *buffer, size_t *lenp, loff_t *ppos)
3470{ 3475{
3471 int pos; 3476 int pos;
@@ -3578,7 +3583,7 @@ static void cdrom_update_settings(void)
3578 mutex_unlock(&cdrom_mutex); 3583 mutex_unlock(&cdrom_mutex);
3579} 3584}
3580 3585
3581static int cdrom_sysctl_handler(ctl_table *ctl, int write, 3586static int cdrom_sysctl_handler(struct ctl_table *ctl, int write,
3582 void __user *buffer, size_t *lenp, loff_t *ppos) 3587 void __user *buffer, size_t *lenp, loff_t *ppos)
3583{ 3588{
3584 int ret; 3589 int ret;
@@ -3604,7 +3609,7 @@ static int cdrom_sysctl_handler(ctl_table *ctl, int write,
3604} 3609}
3605 3610
3606/* Place files in /proc/sys/dev/cdrom */ 3611/* Place files in /proc/sys/dev/cdrom */
3607static ctl_table cdrom_table[] = { 3612static struct ctl_table cdrom_table[] = {
3608 { 3613 {
3609 .procname = "info", 3614 .procname = "info",
3610 .data = &cdrom_sysctl_settings.info, 3615 .data = &cdrom_sysctl_settings.info,
@@ -3650,7 +3655,7 @@ static ctl_table cdrom_table[] = {
3650 { } 3655 { }
3651}; 3656};
3652 3657
3653static ctl_table cdrom_cdrom_table[] = { 3658static struct ctl_table cdrom_cdrom_table[] = {
3654 { 3659 {
3655 .procname = "cdrom", 3660 .procname = "cdrom",
3656 .maxlen = 0, 3661 .maxlen = 0,
@@ -3661,7 +3666,7 @@ static ctl_table cdrom_cdrom_table[] = {
3661}; 3666};
3662 3667
3663/* Make sure that /proc/sys/dev is there */ 3668/* Make sure that /proc/sys/dev is there */
3664static ctl_table cdrom_root_table[] = { 3669static struct ctl_table cdrom_root_table[] = {
3665 { 3670 {
3666 .procname = "dev", 3671 .procname = "dev",
3667 .maxlen = 0, 3672 .maxlen = 0,
diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index 51e75ad96422..584bc3126403 100644
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -602,7 +602,7 @@ static void gdrom_readdisk_dma(struct work_struct *work)
602 spin_unlock(&gdrom_lock); 602 spin_unlock(&gdrom_lock);
603 block = blk_rq_pos(req)/GD_TO_BLK + GD_SESSION_OFFSET; 603 block = blk_rq_pos(req)/GD_TO_BLK + GD_SESSION_OFFSET;
604 block_cnt = blk_rq_sectors(req)/GD_TO_BLK; 604 block_cnt = blk_rq_sectors(req)/GD_TO_BLK;
605 __raw_writel(virt_to_phys(req->buffer), GDROM_DMA_STARTADDR_REG); 605 __raw_writel(virt_to_phys(bio_data(req->bio)), GDROM_DMA_STARTADDR_REG);
606 __raw_writel(block_cnt * GDROM_HARD_SECTOR, GDROM_DMA_LENGTH_REG); 606 __raw_writel(block_cnt * GDROM_HARD_SECTOR, GDROM_DMA_LENGTH_REG);
607 __raw_writel(1, GDROM_DMA_DIRECTION_REG); 607 __raw_writel(1, GDROM_DMA_DIRECTION_REG);
608 __raw_writel(1, GDROM_DMA_ENABLE_REG); 608 __raw_writel(1, GDROM_DMA_ENABLE_REG);
generated by cgit v1.2.2 (git 2.25.0) at 2026-04-05 19:19:55 -0400