Lines Matching full:drive
236 * motor of these drives causes system hangs on some PCI computers. drive
237 * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
238 * a drive is allowed.
298 #define UNIT(x) ((x) & 0x03) /* drive on fdc */
299 #define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
300 /* reverse mapping from unit and fdc to drive */
349 * this struct defines the different floppy drive types.
356 CMOS drive type
357 | Maximum data rate supported by drive type
409 * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
600 static inline bool drive_no_geom(int drive)
602 return !current_type[drive] && !ITYPE(drive_state[drive].fd_device);
606 static inline int fd_eject(int drive)
667 static void __reschedule_timeout(int drive, const char *message)
671 if (drive < 0 || drive >= N_DRIVE) {
673 drive = 0;
675 delay = drive_params[drive].timeout;
678 if (drive_params[drive].flags & FD_DEBUG)
683 static void reschedule_timeout(int drive, const char *message)
688 __reschedule_timeout(drive, message);
712 * 2. No floppy disk is in the drive. This is done in order to ensure that
713 * requests are quickly flushed in case there is no disk in the drive. It
715 * the drive.
721 * change line is set, this means either that no disk is in the drive, or
728 static int disk_change(int drive)
730 int fdc = FDC(drive);
732 if (time_before(jiffies, drive_state[drive].select_date + drive_params[drive].select_delay))
734 if (!(fdc_state[fdc].dor & (0x10 << UNIT(drive))) ||
735 (fdc_state[fdc].dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
736 DPRINT("probing disk change on unselected drive\n");
737 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
741 debug_dcl(drive_params[drive].flags,
742 "checking disk change line for drive %d\n", drive);
743 debug_dcl(drive_params[drive].flags, "jiffies=%lu\n", jiffies);
744 debug_dcl(drive_params[drive].flags, "disk change line=%x\n",
746 debug_dcl(drive_params[drive].flags, "flags=%lx\n",
747 drive_state[drive].flags);
749 if (drive_params[drive].flags & FD_BROKEN_DCL)
751 &drive_state[drive].flags);
752 if ((fdc_inb(fdc, FD_DIR) ^ drive_params[drive].flags) & 0x80) {
753 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
756 if (drive_state[drive].maxblock) /* mark it changed */
758 &drive_state[drive].flags);
761 if (drive_state[drive].keep_data >= 0) {
762 if ((drive_params[drive].flags & FTD_MSG) &&
763 current_type[drive] != NULL)
765 current_type[drive] = NULL;
766 floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
771 drive_state[drive].last_checked = jiffies;
772 clear_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[drive].flags);
791 unsigned char drive;
803 drive = REVDRIVE(fdc, unit);
804 debug_dcl(drive_params[drive].flags,
806 disk_change(drive);
813 drive = REVDRIVE(fdc, unit);
814 drive_state[drive].select_date = jiffies;
820 static void twaddle(int fdc, int drive)
822 if (drive_params[drive].select_delay)
824 fdc_outb(fdc_state[fdc].dor & ~(0x10 << UNIT(drive)),
827 drive_state[drive].select_date = jiffies;
836 int drive;
842 for (drive = 0; drive < N_DRIVE; drive++)
843 if (FDC(drive) == fdc &&
844 (mode || drive_state[drive].track != NEED_1_RECAL))
845 drive_state[drive].track = NEED_2_RECAL;
849 * selects the fdc and drive, and enables the fdc's input/dma.
850 * Both current_drive and current_fdc are changed to match the new drive.
852 static void set_fdc(int drive)
856 if (drive < 0 || drive >= N_DRIVE) {
857 pr_info("bad drive value %d\n", drive);
861 fdc = FDC(drive);
876 current_drive = drive;
882 * Both current_drive and current_fdc are changed to match the new drive.
884 static int lock_fdc(int drive)
895 reschedule_timeout(drive, "lock fdc");
896 set_fdc(drive);
928 static void floppy_off(unsigned int drive)
931 int fdc = FDC(drive);
933 if (!(fdc_state[fdc].dor & (0x10 << UNIT(drive))))
936 timer_delete(motor_off_timer + drive);
940 if (drive_params[drive].rps) {
941 delta = jiffies - drive_state[drive].first_read_date + HZ -
942 drive_params[drive].spindown_offset;
943 delta = ((delta * drive_params[drive].rps) % HZ) / drive_params[drive].rps;
944 motor_off_timer[drive].expires =
945 jiffies + drive_params[drive].spindown - delta;
947 add_timer(motor_off_timer + drive);
952 * stopping at current drive. This is done before any long operation, to
958 int drive;
966 drive = (saved_drive + i + 1) % N_DRIVE;
967 if (drive_state[drive].fd_ref == 0 || drive_params[drive].select_delay != 0)
969 set_fdc(drive);
970 if (!(set_dor(current_fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
971 (0x10 << UNIT(drive))))
974 set_dor(current_fdc, ~(0x10 << UNIT(drive)), 0);
1020 /* this function makes sure that the disk stays in the drive during the
1278 static void fdc_specify(int fdc, int drive)
1307 output_byte(fdc, UNIT(drive));
1324 srt = 16 - DIV_ROUND_UP(drive_params[drive].srt * scale_dtr / 1000,
1332 hlt = DIV_ROUND_UP(drive_params[drive].hlt * scale_dtr / 2,
1339 hut = DIV_ROUND_UP(drive_params[drive].hut * scale_dtr / 16,
1359 /* Set the FDC's data transfer rate on behalf of the specified drive.
1372 /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1444 DPRINT("Drive is write protected\n");
1566 static void check_wp(int fdc, int drive)
1568 if (test_bit(FD_VERIFY_BIT, &drive_state[drive].flags)) {
1571 output_byte(fdc, UNIT(drive));
1576 clear_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
1578 &drive_state[drive].flags);
1579 debug_dcl(drive_params[drive].flags,
1581 debug_dcl(drive_params[drive].flags, "wp=%x\n",
1585 &drive_state[drive].flags);
1588 &drive_state[drive].flags);
1605 * the drive.
1662 * reached track 0. Probably no drive. Raise an
1781 * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1881 /* avoid dma going to a random drive after shutdown */
1907 /* no read since this drive is running */
1941 * drive/controller combinations */
2068 static int next_valid_format(int drive)
2072 probed_format = drive_state[drive].probed_format;
2075 !drive_params[drive].autodetect[probed_format]) {
2076 drive_state[drive].probed_format = 0;
2079 if (floppy_type[drive_params[drive].autodetect[probed_format]].sect) {
2080 drive_state[drive].probed_format = probed_format;
2106 static void set_floppy(int drive)
2108 int type = ITYPE(drive_state[drive].fd_device);
2113 _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->q->disk->private_data;
2269 floppy_off(drive);
2669 buffer_drive != current_drive || /* bad drive */
2722 pr_info("buffer drive=%d\n", buffer_drive);
2771 int drive;
2790 drive = (long)current_req->q->disk->private_data;
2791 set_fdc(drive);
2794 set_floppy(drive);
2922 * Resets the FDC connected to drive <drive>.
2923 * Both current_drive and current_fdc are changed to match the new drive.
2925 static int user_reset_fdc(int drive, int arg, bool interruptible)
2929 if (lock_fdc(drive))
2963 static const char *drive_name(int type, int drive)
2970 if (drive_params[drive].native_format)
2971 floppy = floppy_type + drive_params[drive].native_format;
3132 int drive;
3138 for (drive = 0; drive < N_DRIVE; drive++) {
3139 if (FDC(drive) != current_fdc)
3141 if (drive == current_drive) {
3142 if (drive_state[drive].fd_ref > 1) {
3146 } else if (drive_state[drive].fd_ref) {
3179 static int floppy_raw_cmd_ioctl(int type, int drive, int cmd,
3188 if (lock_fdc(drive))
3190 set_floppy(drive);
3200 static int floppy_raw_cmd_ioctl(int type, int drive, int cmd,
3221 int drive, int type, struct block_device *bdev)
3232 g->track <= 0 || g->track > drive_params[drive].tracks >> STRETCH(g) ||
3240 if (lock_fdc(drive)) {
3261 if (lock_fdc(drive))
3270 user_params[drive] = *g;
3271 if (buffer_drive == drive)
3272 SUPBOUND(buffer_max, user_params[drive].sect);
3273 current_type[drive] = &user_params[drive];
3274 floppy_sizes[drive] = user_params[drive].size;
3284 if (drive_state[current_drive].maxblock > user_params[drive].sect ||
3286 ((user_params[drive].sect ^ oldStretch) &
3342 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3347 if (lock_fdc(drive))
3352 *g = current_type[drive];
3361 int drive = (long)disk->private_data;
3362 int type = ITYPE(drive_state[drive].fd_device);
3366 ret = get_floppy_geometry(drive, type, &g);
3397 int drive = (long)bdev->bd_disk->private_data;
3398 int type = ITYPE(drive_state[drive].fd_device);
3446 if (drive_state[drive].fd_ref != 1)
3447 /* somebody else has this drive open */
3449 if (lock_fdc(drive))
3454 ret = fd_eject(UNIT(drive));
3456 set_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
3457 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
3461 if (lock_fdc(drive))
3463 current_type[drive] = NULL;
3464 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3465 drive_state[drive].keep_data = 0;
3469 return set_geometry(cmd, &inparam.g, drive, type, bdev);
3471 ret = get_floppy_geometry(drive, type,
3480 drive_params[drive].flags |= FTD_MSG;
3483 drive_params[drive].flags &= ~FTD_MSG;
3486 if (lock_fdc(drive))
3490 ret = drive_state[drive].flags;
3498 if (drive_state[drive].fd_ref != 1)
3500 return do_format(drive, &inparam.f);
3503 if (lock_fdc(drive))
3507 drive_params[drive].max_errors.reporting = (unsigned short)(param & 0x0f);
3510 outparam = &drive_params[drive].max_errors;
3513 drive_params[drive].max_errors = inparam.max_errors;
3516 outparam = drive_name(type, drive);
3523 drive_params[drive] = inparam.dp;
3526 outparam = &drive_params[drive];
3529 if (lock_fdc(drive))
3536 outparam = &drive_state[drive];
3539 return user_reset_fdc(drive, (int)param, true);
3541 outparam = &fdc_state[FDC(drive)];
3544 memset(&write_errors[drive], 0, sizeof(write_errors[drive]));
3547 outparam = &write_errors[drive];
3550 return floppy_raw_cmd_ioctl(type, drive, cmd, (void __user *)param);
3552 if (lock_fdc(drive))
3659 int drive, type;
3673 drive = (long)bdev->bd_disk->private_data;
3674 type = ITYPE(drive_state[drive].fd_device);
3676 &v, drive, type, bdev);
3681 static int compat_get_prm(int drive,
3690 err = get_floppy_geometry(drive, ITYPE(drive_state[drive].fd_device),
3703 static int compat_setdrvprm(int drive,
3715 drive_params[drive].cmos = v.cmos;
3716 drive_params[drive].max_dtr = v.max_dtr;
3717 drive_params[drive].hlt = v.hlt;
3718 drive_params[drive].hut = v.hut;
3719 drive_params[drive].srt = v.srt;
3720 drive_params[drive].spinup = v.spinup;
3721 drive_params[drive].spindown = v.spindown;
3722 drive_params[drive].spindown_offset = v.spindown_offset;
3723 drive_params[drive].select_delay = v.select_delay;
3724 drive_params[drive].rps = v.rps;
3725 drive_params[drive].tracks = v.tracks;
3726 drive_params[drive].timeout = v.timeout;
3727 drive_params[drive].interleave_sect = v.interleave_sect;
3728 drive_params[drive].max_errors = v.max_errors;
3729 drive_params[drive].flags = v.flags;
3730 drive_params[drive].read_track = v.read_track;
3731 memcpy(drive_params[drive].autodetect, v.autodetect,
3733 drive_params[drive].checkfreq = v.checkfreq;
3734 drive_params[drive].native_format = v.native_format;
3739 static int compat_getdrvprm(int drive,
3746 v.cmos = drive_params[drive].cmos;
3747 v.max_dtr = drive_params[drive].max_dtr;
3748 v.hlt = drive_params[drive].hlt;
3749 v.hut = drive_params[drive].hut;
3750 v.srt = drive_params[drive].srt;
3751 v.spinup = drive_params[drive].spinup;
3752 v.spindown = drive_params[drive].spindown;
3753 v.spindown_offset = drive_params[drive].spindown_offset;
3754 v.select_delay = drive_params[drive].select_delay;
3755 v.rps = drive_params[drive].rps;
3756 v.tracks = drive_params[drive].tracks;
3757 v.timeout = drive_params[drive].timeout;
3758 v.interleave_sect = drive_params[drive].interleave_sect;
3759 v.max_errors = drive_params[drive].max_errors;
3760 v.flags = drive_params[drive].flags;
3761 v.read_track = drive_params[drive].read_track;
3762 memcpy(v.autodetect, drive_params[drive].autodetect,
3764 v.checkfreq = drive_params[drive].checkfreq;
3765 v.native_format = drive_params[drive].native_format;
3773 static int compat_getdrvstat(int drive, bool poll,
3782 if (lock_fdc(drive))
3788 v.spinup_date = drive_state[drive].spinup_date;
3789 v.select_date = drive_state[drive].select_date;
3790 v.first_read_date = drive_state[drive].first_read_date;
3791 v.probed_format = drive_state[drive].probed_format;
3792 v.track = drive_state[drive].track;
3793 v.maxblock = drive_state[drive].maxblock;
3794 v.maxtrack = drive_state[drive].maxtrack;
3795 v.generation = drive_state[drive].generation;
3796 v.keep_data = drive_state[drive].keep_data;
3797 v.fd_ref = drive_state[drive].fd_ref;
3798 v.fd_device = drive_state[drive].fd_device;
3799 v.last_checked = drive_state[drive].last_checked;
3800 v.dmabuf = (uintptr_t) drive_state[drive].dmabuf;
3801 v.bufblocks = drive_state[drive].bufblocks;
3812 static int compat_getfdcstat(int drive,
3819 v = fdc_state[FDC(drive)];
3841 static int compat_werrorget(int drive,
3849 v = write_errors[drive];
3865 int drive = (long)bdev->bd_disk->private_data;
3893 return compat_get_prm(drive, compat_ptr(param));
3895 return compat_setdrvprm(drive, compat_ptr(param));
3897 return compat_getdrvprm(drive, compat_ptr(param));
3899 return compat_getdrvstat(drive, true, compat_ptr(param));
3901 return compat_getdrvstat(drive, false, compat_ptr(param));
3903 return compat_getfdcstat(drive, compat_ptr(param));
3905 return compat_werrorget(drive, compat_ptr(param));
3914 int drive;
3916 /* read drive info out of physical CMOS */
3917 drive = 0;
3918 if (!drive_params[drive].cmos)
3919 drive_params[drive].cmos = FLOPPY0_TYPE;
3920 drive = 1;
3921 if (!drive_params[drive].cmos)
3922 drive_params[drive].cmos = FLOPPY1_TYPE;
3924 /* FIXME: additional physical CMOS drive detection should go here */
3926 for (drive = 0; drive < N_DRIVE; drive++) {
3927 unsigned int type = drive_params[drive].cmos;
3936 allowed_drive_mask |= 1 << drive;
3938 allowed_drive_mask &= ~(1 << drive);
3950 pr_info("Floppy drive(s):");
3955 pr_cont("%s fd%d is %s", prepend, drive, name);
3957 drive_params[drive] = *params;
3966 int drive = (long)disk->private_data;
3970 if (!drive_state[drive].fd_ref--) {
3972 drive_state[drive].fd_ref = 0;
3974 if (!drive_state[drive].fd_ref)
3975 opened_disk[drive] = NULL;
3983 * drive with different device numbers.
3987 int drive = (long)disk->private_data;
3995 old_dev = drive_state[drive].fd_device;
3996 if (opened_disk[drive] && opened_disk[drive] != disk)
3999 if (!drive_state[drive].fd_ref && (drive_params[drive].flags & FD_BROKEN_DCL)) {
4000 set_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
4001 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
4004 drive_state[drive].fd_ref++;
4006 opened_disk[drive] = disk;
4011 /* if opening an ED drive, reserve a big buffer,
4013 if ((drive_params[drive].cmos == 6) || (drive_params[drive].cmos == 5))
4041 drive_state[drive].fd_device = new_dev;
4042 set_capacity(disks[drive][ITYPE(new_dev)], floppy_sizes[new_dev]);
4044 if (buffer_drive == drive)
4048 if (fdc_state[FDC(drive)].rawcmd == 1)
4049 fdc_state[FDC(drive)].rawcmd = 2;
4052 drive_state[drive].last_checked = 0;
4054 &drive_state[drive].flags);
4057 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags))
4059 if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &drive_state[drive].flags))
4064 !test_bit(FD_DISK_WRITABLE_BIT, &drive_state[drive].flags))
4071 drive_state[drive].fd_ref--;
4073 if (!drive_state[drive].fd_ref)
4074 opened_disk[drive] = NULL;
4087 int drive = (long)disk->private_data;
4089 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4090 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags))
4093 if (time_after(jiffies, drive_state[drive].last_checked + drive_params[drive].checkfreq)) {
4094 if (lock_fdc(drive))
4100 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4101 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags) ||
4102 test_bit(drive, &fake_change) ||
4103 drive_no_geom(drive))
4111 * a disk in the drive, and whether that disk is writable.
4115 int drive;
4122 int drive = cbdata->drive;
4127 set_bit(FD_OPEN_SHOULD_FAIL_BIT, &drive_state[drive].flags);
4132 static int __floppy_read_block_0(struct block_device *bdev, int drive)
4145 cbdata.drive = drive;
4169 * there is a disk in the drive at all... Thus we also do it for fixed
4173 int drive = (long)disk->private_data;
4177 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4178 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags) ||
4179 test_bit(drive, &fake_change) ||
4180 drive_no_geom(drive)) {
4185 res = lock_fdc(drive);
4188 cf = (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4189 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags));
4190 if (!(cf || test_bit(drive, &fake_change) || drive_no_geom(drive))) {
4194 drive_state[drive].maxblock = 0;
4195 drive_state[drive].maxtrack = 0;
4196 if (buffer_drive == drive)
4198 clear_bit(drive, &fake_change);
4199 clear_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
4201 drive_state[drive].generation++;
4202 if (drive_no_geom(drive)) {
4204 res = __floppy_read_block_0(opened_disk[drive]->part0,
4205 drive);
4212 set_capacity(disk, floppy_sizes[drive_state[drive].fd_device]);
4356 DPRINT("bad drive for set_cmos\n");
4449 int drive;
4451 drive = p->id;
4452 return sprintf(buf, "%X\n", drive_params[drive].cmos);
4500 static bool floppy_available(int drive)
4502 if (!(allowed_drive_mask & (1 << drive)))
4504 if (fdc_state[FDC(drive)].version == FDC_NONE)
4509 static int floppy_alloc_disk(unsigned int drive, unsigned int type)
4517 disk = blk_mq_alloc_disk(&tag_sets[drive], &lim, NULL);
4522 disk->first_minor = TOMINOR(drive) | (type << 2);
4528 sprintf(disk->disk_name, "fd%d_type%d", drive, type);
4530 sprintf(disk->disk_name, "fd%d", drive);
4532 disk->private_data = (void *)(long)drive;
4535 disks[drive][type] = disk;
4543 unsigned int drive = (MINOR(dev) & 3) | ((MINOR(dev) & 0x80) >> 5);
4546 if (drive >= N_DRIVE || !floppy_available(drive) ||
4551 if (disks[drive][type])
4553 if (floppy_alloc_disk(drive, type))
4555 if (add_disk(disks[drive][type]))
4562 put_disk(disks[drive][type]);
4563 disks[drive][type] = NULL;
4569 int i, unit, drive, err;
4585 for (drive = 0; drive < N_DRIVE; drive++) {
4586 memset(&tag_sets[drive], 0, sizeof(tag_sets[drive]));
4587 tag_sets[drive].ops = &floppy_mq_ops;
4588 tag_sets[drive].nr_hw_queues = 1;
4589 tag_sets[drive].nr_maps = 1;
4590 tag_sets[drive].queue_depth = 2;
4591 tag_sets[drive].numa_node = NUMA_NO_NODE;
4592 err = blk_mq_alloc_tag_set(&tag_sets[drive]);
4596 err = floppy_alloc_disk(drive, 0);
4598 blk_mq_free_tag_set(&tag_sets[drive]);
4602 timer_setup(&motor_off_timer[drive], motor_off_callback, 0);
4654 /* initialise drive state */
4655 for (drive = 0; drive < N_DRIVE; drive++) {
4656 memset(&drive_state[drive], 0, sizeof(drive_state[drive]));
4657 memset(&write_errors[drive], 0, sizeof(write_errors[drive]));
4658 set_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[drive].flags);
4659 set_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
4660 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
4661 drive_state[drive].fd_device = -1;
4715 for (drive = 0; drive < N_DRIVE; drive++) {
4716 if (!floppy_available(drive))
4719 floppy_device[drive].name = floppy_device_name;
4720 floppy_device[drive].id = drive;
4721 floppy_device[drive].dev.release = floppy_device_release;
4722 floppy_device[drive].dev.groups = floppy_dev_groups;
4724 err = platform_device_register(&floppy_device[drive]);
4728 registered[drive] = true;
4730 err = device_add_disk(&floppy_device[drive].dev,
4731 disks[drive][0], NULL);
4739 while (drive--) {
4740 if (floppy_available(drive)) {
4741 del_gendisk(disks[drive][0]);
4742 if (registered[drive])
4743 platform_device_unregister(&floppy_device[drive]);
4755 for (drive = 0; drive < N_DRIVE; drive++) {
4756 if (!disks[drive][0])
4758 timer_delete_sync(&motor_off_timer[drive]);
4759 put_disk(disks[drive][0]);
4760 blk_mq_free_tag_set(&tag_sets[drive]);
4894 int drive;
4922 for (drive = 0; drive < N_FDC * 4; drive++)
4923 if (timer_pending(motor_off_timer + drive))
4924 pr_info("motor off timer %d still active\n", drive);
4969 int drive, i;
4976 for (drive = 0; drive < N_DRIVE; drive++) {
4977 timer_delete_sync(&motor_off_timer[drive]);
4979 if (floppy_available(drive)) {
4981 if (disks[drive][i])
4982 del_gendisk(disks[drive][i]);
4984 if (registered[drive])
4985 platform_device_unregister(&floppy_device[drive]);
4988 if (disks[drive][i])
4989 put_disk(disks[drive][i]);
4991 blk_mq_free_tag_set(&tag_sets[drive]);