Lines Matching refs:drive
241 * motor of these drives causes system hangs on some PCI computers. drive
242 * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
243 * a drive is allowed.
303 #define UNIT(x) ((x) & 0x03) /* drive on fdc */
304 #define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
305 /* reverse mapping from unit and fdc to drive */
354 * this struct defines the different floppy drive types.
361 CMOS drive type
362 | Maximum data rate supported by drive type
415 * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
605 static inline bool drive_no_geom(int drive)
607 return !current_type[drive] && !ITYPE(drive_state[drive].fd_device);
611 static inline int fd_eject(int drive)
672 static void __reschedule_timeout(int drive, const char *message)
676 if (drive < 0 || drive >= N_DRIVE) {
678 drive = 0;
680 delay = drive_params[drive].timeout;
683 if (drive_params[drive].flags & FD_DEBUG)
688 static void reschedule_timeout(int drive, const char *message)
693 __reschedule_timeout(drive, message);
717 * 2. No floppy disk is in the drive. This is done in order to ensure that
718 * requests are quickly flushed in case there is no disk in the drive. It
720 * the drive.
726 * change line is set, this means either that no disk is in the drive, or
733 static int disk_change(int drive)
735 int fdc = FDC(drive);
737 if (time_before(jiffies, drive_state[drive].select_date + drive_params[drive].select_delay))
739 if (!(fdc_state[fdc].dor & (0x10 << UNIT(drive))) ||
740 (fdc_state[fdc].dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
741 DPRINT("probing disk change on unselected drive\n");
742 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
746 debug_dcl(drive_params[drive].flags,
747 "checking disk change line for drive %d\n", drive);
748 debug_dcl(drive_params[drive].flags, "jiffies=%lu\n", jiffies);
749 debug_dcl(drive_params[drive].flags, "disk change line=%x\n",
751 debug_dcl(drive_params[drive].flags, "flags=%lx\n",
752 drive_state[drive].flags);
754 if (drive_params[drive].flags & FD_BROKEN_DCL)
756 &drive_state[drive].flags);
757 if ((fdc_inb(fdc, FD_DIR) ^ drive_params[drive].flags) & 0x80) {
758 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
761 if (drive_state[drive].maxblock) /* mark it changed */
763 &drive_state[drive].flags);
766 if (drive_state[drive].keep_data >= 0) {
767 if ((drive_params[drive].flags & FTD_MSG) &&
768 current_type[drive] != NULL)
770 current_type[drive] = NULL;
771 floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
776 drive_state[drive].last_checked = jiffies;
777 clear_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[drive].flags);
796 unsigned char drive;
808 drive = REVDRIVE(fdc, unit);
809 debug_dcl(drive_params[drive].flags,
811 disk_change(drive);
818 drive = REVDRIVE(fdc, unit);
819 drive_state[drive].select_date = jiffies;
825 static void twaddle(int fdc, int drive)
827 if (drive_params[drive].select_delay)
829 fdc_outb(fdc_state[fdc].dor & ~(0x10 << UNIT(drive)),
832 drive_state[drive].select_date = jiffies;
841 int drive;
847 for (drive = 0; drive < N_DRIVE; drive++)
848 if (FDC(drive) == fdc &&
849 (mode || drive_state[drive].track != NEED_1_RECAL))
850 drive_state[drive].track = NEED_2_RECAL;
854 * selects the fdc and drive, and enables the fdc's input/dma.
855 * Both current_drive and current_fdc are changed to match the new drive.
857 static void set_fdc(int drive)
861 if (drive < 0 || drive >= N_DRIVE) {
862 pr_info("bad drive value %d\n", drive);
866 fdc = FDC(drive);
881 current_drive = drive;
887 * Both current_drive and current_fdc are changed to match the new drive.
889 static int lock_fdc(int drive)
900 reschedule_timeout(drive, "lock fdc");
901 set_fdc(drive);
933 static void floppy_off(unsigned int drive)
936 int fdc = FDC(drive);
938 if (!(fdc_state[fdc].dor & (0x10 << UNIT(drive))))
941 del_timer(motor_off_timer + drive);
945 if (drive_params[drive].rps) {
946 delta = jiffies - drive_state[drive].first_read_date + HZ -
947 drive_params[drive].spindown_offset;
948 delta = ((delta * drive_params[drive].rps) % HZ) / drive_params[drive].rps;
949 motor_off_timer[drive].expires =
950 jiffies + drive_params[drive].spindown - delta;
952 add_timer(motor_off_timer + drive);
957 * stopping at current drive. This is done before any long operation, to
963 int drive;
971 drive = (saved_drive + i + 1) % N_DRIVE;
972 if (drive_state[drive].fd_ref == 0 || drive_params[drive].select_delay != 0)
974 set_fdc(drive);
975 if (!(set_dor(current_fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
976 (0x10 << UNIT(drive))))
979 set_dor(current_fdc, ~(0x10 << UNIT(drive)), 0);
1021 /* this function makes sure that the disk stays in the drive during the
1279 static void fdc_specify(int fdc, int drive)
1308 output_byte(fdc, UNIT(drive));
1325 srt = 16 - DIV_ROUND_UP(drive_params[drive].srt * scale_dtr / 1000,
1333 hlt = DIV_ROUND_UP(drive_params[drive].hlt * scale_dtr / 2,
1340 hut = DIV_ROUND_UP(drive_params[drive].hut * scale_dtr / 16,
1360 /* Set the FDC's data transfer rate on behalf of the specified drive.
1373 /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1567 static void check_wp(int fdc, int drive)
1569 if (test_bit(FD_VERIFY_BIT, &drive_state[drive].flags)) {
1572 output_byte(fdc, UNIT(drive));
1577 clear_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
1579 &drive_state[drive].flags);
1580 debug_dcl(drive_params[drive].flags,
1582 debug_dcl(drive_params[drive].flags, "wp=%x\n",
1586 &drive_state[drive].flags);
1589 &drive_state[drive].flags);
1606 * the drive.
1663 * reached track 0. Probably no drive. Raise an
1782 * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1882 /* avoid dma going to a random drive after shutdown */
1908 /* no read since this drive is running */
1942 * drive/controller combinations */
2069 static int next_valid_format(int drive)
2073 probed_format = drive_state[drive].probed_format;
2076 !drive_params[drive].autodetect[probed_format]) {
2077 drive_state[drive].probed_format = 0;
2080 if (floppy_type[drive_params[drive].autodetect[probed_format]].sect) {
2081 drive_state[drive].probed_format = probed_format;
2107 static void set_floppy(int drive)
2109 int type = ITYPE(drive_state[drive].fd_device);
2114 _floppy = current_type[drive];
2224 static int do_format(int drive, struct format_descr *tmp_format_req)
2228 if (lock_fdc(drive))
2231 set_floppy(drive);
2259 unsigned int drive = (unsigned long)req->rq_disk->private_data;
2269 floppy_off(drive);
2745 buffer_drive != current_drive || /* bad drive */
2800 pr_info("buffer drive=%d\n", buffer_drive);
2859 int drive;
2879 drive = (long)current_req->rq_disk->private_data;
2880 set_fdc(drive);
2883 set_floppy(drive);
3011 * Resets the FDC connected to drive <drive>.
3012 * Both current_drive and current_fdc are changed to match the new drive.
3014 static int user_reset_fdc(int drive, int arg, bool interruptible)
3018 if (lock_fdc(drive))
3052 static const char *drive_name(int type, int drive)
3059 if (drive_params[drive].native_format)
3060 floppy = floppy_type + drive_params[drive].native_format;
3229 int drive;
3235 for (drive = 0; drive < N_DRIVE; drive++) {
3236 if (FDC(drive) != current_fdc)
3238 if (drive == current_drive) {
3239 if (drive_state[drive].fd_ref > 1) {
3243 } else if (drive_state[drive].fd_ref) {
3276 static int floppy_raw_cmd_ioctl(int type, int drive, int cmd,
3285 if (lock_fdc(drive))
3287 set_floppy(drive);
3297 static int floppy_raw_cmd_ioctl(int type, int drive, int cmd,
3316 int drive, int type, struct block_device *bdev)
3327 g->track <= 0 || g->track > drive_params[drive].tracks >> STRETCH(g) ||
3335 if (lock_fdc(drive)) {
3355 if (lock_fdc(drive))
3364 user_params[drive] = *g;
3365 if (buffer_drive == drive)
3366 SUPBOUND(buffer_max, user_params[drive].sect);
3367 current_type[drive] = &user_params[drive];
3368 floppy_sizes[drive] = user_params[drive].size;
3378 if (drive_state[current_drive].maxblock > user_params[drive].sect ||
3380 ((user_params[drive].sect ^ oldStretch) &
3436 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3441 if (lock_fdc(drive))
3446 *g = current_type[drive];
3455 int drive = (long)bdev->bd_disk->private_data;
3456 int type = ITYPE(drive_state[drive].fd_device);
3460 ret = get_floppy_geometry(drive, type, &g);
3491 int drive = (long)bdev->bd_disk->private_data;
3492 int type = ITYPE(drive_state[drive].fd_device);
3539 if (drive_state[drive].fd_ref != 1)
3540 /* somebody else has this drive open */
3542 if (lock_fdc(drive))
3547 ret = fd_eject(UNIT(drive));
3549 set_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
3550 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
3554 if (lock_fdc(drive))
3556 current_type[drive] = NULL;
3557 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3558 drive_state[drive].keep_data = 0;
3562 return set_geometry(cmd, &inparam.g, drive, type, bdev);
3564 ret = get_floppy_geometry(drive, type,
3573 drive_params[drive].flags |= FTD_MSG;
3576 drive_params[drive].flags &= ~FTD_MSG;
3579 if (lock_fdc(drive))
3583 ret = drive_state[drive].flags;
3591 if (drive_state[drive].fd_ref != 1)
3593 return do_format(drive, &inparam.f);
3596 if (lock_fdc(drive))
3600 drive_params[drive].max_errors.reporting = (unsigned short)(param & 0x0f);
3603 outparam = &drive_params[drive].max_errors;
3606 drive_params[drive].max_errors = inparam.max_errors;
3609 outparam = drive_name(type, drive);
3616 drive_params[drive] = inparam.dp;
3619 outparam = &drive_params[drive];
3622 if (lock_fdc(drive))
3629 outparam = &drive_state[drive];
3632 return user_reset_fdc(drive, (int)param, true);
3634 outparam = &fdc_state[FDC(drive)];
3637 memset(&write_errors[drive], 0, sizeof(write_errors[drive]));
3640 outparam = &write_errors[drive];
3643 return floppy_raw_cmd_ioctl(type, drive, cmd, (void __user *)param);
3645 if (lock_fdc(drive))
3752 int drive, type;
3766 drive = (long)bdev->bd_disk->private_data;
3767 type = ITYPE(drive_state[drive].fd_device);
3769 &v, drive, type, bdev);
3774 static int compat_get_prm(int drive,
3783 err = get_floppy_geometry(drive, ITYPE(drive_state[drive].fd_device),
3796 static int compat_setdrvprm(int drive,
3808 drive_params[drive].cmos = v.cmos;
3809 drive_params[drive].max_dtr = v.max_dtr;
3810 drive_params[drive].hlt = v.hlt;
3811 drive_params[drive].hut = v.hut;
3812 drive_params[drive].srt = v.srt;
3813 drive_params[drive].spinup = v.spinup;
3814 drive_params[drive].spindown = v.spindown;
3815 drive_params[drive].spindown_offset = v.spindown_offset;
3816 drive_params[drive].select_delay = v.select_delay;
3817 drive_params[drive].rps = v.rps;
3818 drive_params[drive].tracks = v.tracks;
3819 drive_params[drive].timeout = v.timeout;
3820 drive_params[drive].interleave_sect = v.interleave_sect;
3821 drive_params[drive].max_errors = v.max_errors;
3822 drive_params[drive].flags = v.flags;
3823 drive_params[drive].read_track = v.read_track;
3824 memcpy(drive_params[drive].autodetect, v.autodetect,
3826 drive_params[drive].checkfreq = v.checkfreq;
3827 drive_params[drive].native_format = v.native_format;
3832 static int compat_getdrvprm(int drive,
3839 v.cmos = drive_params[drive].cmos;
3840 v.max_dtr = drive_params[drive].max_dtr;
3841 v.hlt = drive_params[drive].hlt;
3842 v.hut = drive_params[drive].hut;
3843 v.srt = drive_params[drive].srt;
3844 v.spinup = drive_params[drive].spinup;
3845 v.spindown = drive_params[drive].spindown;
3846 v.spindown_offset = drive_params[drive].spindown_offset;
3847 v.select_delay = drive_params[drive].select_delay;
3848 v.rps = drive_params[drive].rps;
3849 v.tracks = drive_params[drive].tracks;
3850 v.timeout = drive_params[drive].timeout;
3851 v.interleave_sect = drive_params[drive].interleave_sect;
3852 v.max_errors = drive_params[drive].max_errors;
3853 v.flags = drive_params[drive].flags;
3854 v.read_track = drive_params[drive].read_track;
3855 memcpy(v.autodetect, drive_params[drive].autodetect,
3857 v.checkfreq = drive_params[drive].checkfreq;
3858 v.native_format = drive_params[drive].native_format;
3866 static int compat_getdrvstat(int drive, bool poll,
3875 if (lock_fdc(drive))
3881 v.spinup_date = drive_state[drive].spinup_date;
3882 v.select_date = drive_state[drive].select_date;
3883 v.first_read_date = drive_state[drive].first_read_date;
3884 v.probed_format = drive_state[drive].probed_format;
3885 v.track = drive_state[drive].track;
3886 v.maxblock = drive_state[drive].maxblock;
3887 v.maxtrack = drive_state[drive].maxtrack;
3888 v.generation = drive_state[drive].generation;
3889 v.keep_data = drive_state[drive].keep_data;
3890 v.fd_ref = drive_state[drive].fd_ref;
3891 v.fd_device = drive_state[drive].fd_device;
3892 v.last_checked = drive_state[drive].last_checked;
3893 v.dmabuf = (uintptr_t) drive_state[drive].dmabuf;
3894 v.bufblocks = drive_state[drive].bufblocks;
3905 static int compat_getfdcstat(int drive,
3912 v = fdc_state[FDC(drive)];
3934 static int compat_werrorget(int drive,
3942 v = write_errors[drive];
3958 int drive = (long)bdev->bd_disk->private_data;
3986 return compat_get_prm(drive, compat_ptr(param));
3988 return compat_setdrvprm(drive, compat_ptr(param));
3990 return compat_getdrvprm(drive, compat_ptr(param));
3992 return compat_getdrvstat(drive, true, compat_ptr(param));
3994 return compat_getdrvstat(drive, false, compat_ptr(param));
3996 return compat_getfdcstat(drive, compat_ptr(param));
3998 return compat_werrorget(drive, compat_ptr(param));
4007 int drive;
4009 /* read drive info out of physical CMOS */
4010 drive = 0;
4011 if (!drive_params[drive].cmos)
4012 drive_params[drive].cmos = FLOPPY0_TYPE;
4013 drive = 1;
4014 if (!drive_params[drive].cmos)
4015 drive_params[drive].cmos = FLOPPY1_TYPE;
4017 /* FIXME: additional physical CMOS drive detection should go here */
4019 for (drive = 0; drive < N_DRIVE; drive++) {
4020 unsigned int type = drive_params[drive].cmos;
4029 allowed_drive_mask |= 1 << drive;
4031 allowed_drive_mask &= ~(1 << drive);
4043 pr_info("Floppy drive(s):");
4048 pr_cont("%s fd%d is %s", prepend, drive, name);
4050 drive_params[drive] = *params;
4059 int drive = (long)disk->private_data;
4063 if (!drive_state[drive].fd_ref--) {
4065 drive_state[drive].fd_ref = 0;
4067 if (!drive_state[drive].fd_ref)
4068 opened_bdev[drive] = NULL;
4076 * drive with different device numbers.
4080 int drive = (long)bdev->bd_disk->private_data;
4088 old_dev = drive_state[drive].fd_device;
4089 if (opened_bdev[drive] && opened_bdev[drive] != bdev)
4092 if (!drive_state[drive].fd_ref && (drive_params[drive].flags & FD_BROKEN_DCL)) {
4093 set_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
4094 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
4097 drive_state[drive].fd_ref++;
4099 opened_bdev[drive] = bdev;
4104 /* if opening an ED drive, reserve a big buffer,
4106 if ((drive_params[drive].cmos == 6) || (drive_params[drive].cmos == 5))
4134 drive_state[drive].fd_device = new_dev;
4135 set_capacity(disks[drive], floppy_sizes[new_dev]);
4137 if (buffer_drive == drive)
4141 if (fdc_state[FDC(drive)].rawcmd == 1)
4142 fdc_state[FDC(drive)].rawcmd = 2;
4146 drive_state[drive].last_checked = 0;
4148 &drive_state[drive].flags);
4151 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags))
4153 if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &drive_state[drive].flags))
4158 !test_bit(FD_DISK_WRITABLE_BIT, &drive_state[drive].flags))
4165 drive_state[drive].fd_ref--;
4167 if (!drive_state[drive].fd_ref)
4168 opened_bdev[drive] = NULL;
4181 int drive = (long)disk->private_data;
4183 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4184 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags))
4187 if (time_after(jiffies, drive_state[drive].last_checked + drive_params[drive].checkfreq)) {
4188 if (lock_fdc(drive))
4194 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4195 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags) ||
4196 test_bit(drive, &fake_change) ||
4197 drive_no_geom(drive))
4205 * a disk in the drive, and whether that disk is writable.
4209 int drive;
4216 int drive = cbdata->drive;
4221 set_bit(FD_OPEN_SHOULD_FAIL_BIT, &drive_state[drive].flags);
4226 static int __floppy_read_block_0(struct block_device *bdev, int drive)
4239 cbdata.drive = drive;
4265 * there is a disk in the drive at all... Thus we also do it for fixed
4269 int drive = (long)disk->private_data;
4273 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4274 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags) ||
4275 test_bit(drive, &fake_change) ||
4276 drive_no_geom(drive)) {
4281 res = lock_fdc(drive);
4284 cf = (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4285 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags));
4286 if (!(cf || test_bit(drive, &fake_change) || drive_no_geom(drive))) {
4290 drive_state[drive].maxblock = 0;
4291 drive_state[drive].maxtrack = 0;
4292 if (buffer_drive == drive)
4294 clear_bit(drive, &fake_change);
4295 clear_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
4297 drive_state[drive].generation++;
4298 if (drive_no_geom(drive)) {
4300 res = __floppy_read_block_0(opened_bdev[drive], drive);
4307 set_capacity(disk, floppy_sizes[drive_state[drive].fd_device]);
4451 DPRINT("bad drive for set_cmos\n");
4544 int drive;
4546 drive = p->id;
4547 return sprintf(buf, "%X\n", drive_params[drive].cmos);
4594 static bool floppy_available(int drive)
4596 if (!(allowed_drive_mask & (1 << drive)))
4598 if (fdc_state[FDC(drive)].version == FDC_NONE)
4605 int drive = (*part & 3) | ((*part & 0x80) >> 5);
4606 if (drive >= N_DRIVE || !floppy_available(drive))
4611 return get_disk_and_module(disks[drive]);
4616 int i, unit, drive, err;
4632 for (drive = 0; drive < N_DRIVE; drive++) {
4633 disks[drive] = alloc_disk(1);
4634 if (!disks[drive]) {
4639 disks[drive]->queue = blk_mq_init_sq_queue(&tag_sets[drive],
4642 if (IS_ERR(disks[drive]->queue)) {
4643 err = PTR_ERR(disks[drive]->queue);
4644 disks[drive]->queue = NULL;
4648 blk_queue_bounce_limit(disks[drive]->queue, BLK_BOUNCE_HIGH);
4649 blk_queue_max_hw_sectors(disks[drive]->queue, 64);
4650 disks[drive]->major = FLOPPY_MAJOR;
4651 disks[drive]->first_minor = TOMINOR(drive);
4652 disks[drive]->fops = &floppy_fops;
4653 disks[drive]->events = DISK_EVENT_MEDIA_CHANGE;
4654 sprintf(disks[drive]->disk_name, "fd%d", drive);
4656 timer_setup(&motor_off_timer[drive], motor_off_callback, 0);
4711 /* initialise drive state */
4712 for (drive = 0; drive < N_DRIVE; drive++) {
4713 memset(&drive_state[drive], 0, sizeof(drive_state[drive]));
4714 memset(&write_errors[drive], 0, sizeof(write_errors[drive]));
4715 set_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[drive].flags);
4716 set_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
4717 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
4718 drive_state[drive].fd_device = -1;
4772 for (drive = 0; drive < N_DRIVE; drive++) {
4773 if (!floppy_available(drive))
4776 floppy_device[drive].name = floppy_device_name;
4777 floppy_device[drive].id = drive;
4778 floppy_device[drive].dev.release = floppy_device_release;
4779 floppy_device[drive].dev.groups = floppy_dev_groups;
4781 err = platform_device_register(&floppy_device[drive]);
4786 disks[drive]->private_data = (void *)(long)drive;
4787 disks[drive]->flags |= GENHD_FL_REMOVABLE;
4788 device_add_disk(&floppy_device[drive].dev, disks[drive], NULL);
4794 while (drive--) {
4795 if (floppy_available(drive)) {
4796 del_gendisk(disks[drive]);
4797 platform_device_unregister(&floppy_device[drive]);
4810 for (drive = 0; drive < N_DRIVE; drive++) {
4811 if (!disks[drive])
4813 if (disks[drive]->queue) {
4814 del_timer_sync(&motor_off_timer[drive]);
4815 blk_cleanup_queue(disks[drive]->queue);
4816 disks[drive]->queue = NULL;
4817 blk_mq_free_tag_set(&tag_sets[drive]);
4819 put_disk(disks[drive]);
4955 int drive;
4983 for (drive = 0; drive < N_FDC * 4; drive++)
4984 if (timer_pending(motor_off_timer + drive))
4985 pr_info("motor off timer %d still active\n", drive);
5030 int drive;
5038 for (drive = 0; drive < N_DRIVE; drive++) {
5039 del_timer_sync(&motor_off_timer[drive]);
5041 if (floppy_available(drive)) {
5042 del_gendisk(disks[drive]);
5043 platform_device_unregister(&floppy_device[drive]);
5045 blk_cleanup_queue(disks[drive]->queue);
5046 blk_mq_free_tag_set(&tag_sets[drive]);
5052 if (!(allowed_drive_mask & (1 << drive)) ||
5053 fdc_state[FDC(drive)].version == FDC_NONE)
5054 disks[drive]->queue = NULL;
5056 put_disk(disks[drive]);