floppy: cleanup: expand macro UDP (1ce9ae96) · Commits · 戴 / test

drivers/block/floppy.c

+77 −75

Original line number	Diff line number	Diff line
		@@ -310,7 +310,6 @@ static bool initialized;
		#define DRS (&drive_state[current_drive])
		#define DRWE (&write_errors[current_drive])

		#define UDP (&drive_params[drive])
		#define UDRS (&drive_state[drive])
		#define UDRWE (&write_errors[drive])

		@@ -681,10 +680,10 @@ static void __reschedule_timeout(int drive, const char *message)
		delay = 20UL * HZ;
		drive = 0;
		} else
		delay = UDP->timeout;
		delay = drive_params[drive].timeout;

		mod_delayed_work(floppy_wq, &fd_timeout, delay);
		if (UDP->flags & FD_DEBUG)
		if (drive_params[drive].flags & FD_DEBUG)
		DPRINT("reschedule timeout %s\n", message);
		timeout_message = message;
		}
		@@ -738,7 +737,7 @@ static int disk_change(int drive)
		{
		int fdc = FDC(drive);

		if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
		if (time_before(jiffies, UDRS->select_date + drive_params[drive].select_delay))
		DPRINT("WARNING disk change called early\n");
		if (!(fdc_state[fdc].dor & (0x10 << UNIT(drive))) \|\|
		(fdc_state[fdc].dor & 3) != UNIT(drive) \|\| fdc != FDC(drive)) {
		@@ -747,15 +746,16 @@ static int disk_change(int drive)
		(unsigned int)fdc_state[fdc].dor);
		}

		debug_dcl(UDP->flags,
		debug_dcl(drive_params[drive].flags,
		"checking disk change line for drive %d\n", drive);
		debug_dcl(UDP->flags, "jiffies=%lu\n", jiffies);
		debug_dcl(UDP->flags, "disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
		debug_dcl(UDP->flags, "flags=%lx\n", UDRS->flags);
		debug_dcl(drive_params[drive].flags, "jiffies=%lu\n", jiffies);
		debug_dcl(drive_params[drive].flags, "disk change line=%x\n",
		fd_inb(FD_DIR) & 0x80);
		debug_dcl(drive_params[drive].flags, "flags=%lx\n", UDRS->flags);

		if (UDP->flags & FD_BROKEN_DCL)
		if (drive_params[drive].flags & FD_BROKEN_DCL)
		return test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
		if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
		if ((fd_inb(FD_DIR) ^ drive_params[drive].flags) & 0x80) {
		set_bit(FD_VERIFY_BIT, &UDRS->flags);
		/* verify write protection */

		@@ -764,7 +764,7 @@ static int disk_change(int drive)

		/* invalidate its geometry */
		if (UDRS->keep_data >= 0) {
		if ((UDP->flags & FTD_MSG) &&
		if ((drive_params[drive].flags & FTD_MSG) &&
		current_type[drive] != NULL)
		DPRINT("Disk type is undefined after disk change\n");
		current_type[drive] = NULL;
		@@ -806,7 +806,7 @@ static int set_dor(int fdc, char mask, char data)
		unit = olddor & 0x3;
		if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
		drive = REVDRIVE(fdc, unit);
		debug_dcl(UDP->flags,
		debug_dcl(drive_params[drive].flags,
		"calling disk change from set_dor\n");
		disk_change(drive);
		}
		@@ -929,12 +929,12 @@ static void floppy_off(unsigned int drive)

		/* make spindle stop in a position which minimizes spinup time
		* next time */
		if (UDP->rps) {
		if (drive_params[drive].rps) {
		delta = jiffies - UDRS->first_read_date + HZ -
		UDP->spindown_offset;
		delta = ((delta * UDP->rps) % HZ) / UDP->rps;
		drive_params[drive].spindown_offset;
		delta = ((delta * drive_params[drive].rps) % HZ) / drive_params[drive].rps;
		motor_off_timer[drive].expires =
		jiffies + UDP->spindown - delta;
		jiffies + drive_params[drive].spindown - delta;
		}
		add_timer(motor_off_timer + drive);
		}
		@@ -956,7 +956,7 @@ static void scandrives(void)
		saved_drive = current_drive;
		for (i = 0; i < N_DRIVE; i++) {
		drive = (saved_drive + i + 1) % N_DRIVE;
		if (UDRS->fd_ref == 0 \|\| UDP->select_delay != 0)
		if (UDRS->fd_ref == 0 \|\| drive_params[drive].select_delay != 0)
		continue; /* skip closed drives */
		set_fdc(drive);
		if (!(set_dor(fdc, ~3, UNIT(drive) \| (0x10 << UNIT(drive))) &
		@@ -2999,8 +2999,8 @@ static const char *drive_name(int type, int drive)
		if (type)
		floppy = floppy_type + type;
		else {
		if (UDP->native_format)
		floppy = floppy_type + UDP->native_format;
		if (drive_params[drive].native_format)
		floppy = floppy_type + drive_params[drive].native_format;
		else
		return "(null)";
		}
		@@ -3240,7 +3240,7 @@ static int set_geometry(unsigned int cmd, struct floppy_struct *g,
		(int)(g->sect * g->head) <= 0 \|\|
		/* check for zero in F_SECT_PER_TRACK */
		(unsigned char)((g->sect << 2) >> FD_SIZECODE(g)) == 0 \|\|
		g->track <= 0 \|\| g->track > UDP->tracks >> STRETCH(g) \|\|
		g->track <= 0 \|\| g->track > drive_params[drive].tracks >> STRETCH(g) \|\|
		/* check if reserved bits are set */
		(g->stretch & ~(FD_STRETCH \| FD_SWAPSIDES \| FD_SECTBASEMASK)) != 0)
		return -EINVAL;
		@@ -3487,10 +3487,10 @@ static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
		outparam = &inparam.g;
		break;
		case FDMSGON:
		UDP->flags \|= FTD_MSG;
		drive_params[drive].flags \|= FTD_MSG;
		return 0;
		case FDMSGOFF:
		UDP->flags &= ~FTD_MSG;
		drive_params[drive].flags &= ~FTD_MSG;
		return 0;
		case FDFMTBEG:
		if (lock_fdc(drive))
		@@ -3514,13 +3514,13 @@ static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
		return -EINTR;
		return invalidate_drive(bdev);
		case FDSETEMSGTRESH:
		UDP->max_errors.reporting = (unsigned short)(param & 0x0f);
		drive_params[drive].max_errors.reporting = (unsigned short)(param & 0x0f);
		return 0;
		case FDGETMAXERRS:
		outparam = &UDP->max_errors;
		outparam = &drive_params[drive].max_errors;
		break;
		case FDSETMAXERRS:
		UDP->max_errors = inparam.max_errors;
		drive_params[drive].max_errors = inparam.max_errors;
		break;
		case FDGETDRVTYP:
		outparam = drive_name(type, drive);
		@@ -3530,10 +3530,10 @@ static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
		if (!valid_floppy_drive_params(inparam.dp.autodetect,
		inparam.dp.native_format))
		return -EINVAL;
		*UDP = inparam.dp;
		drive_params[drive] = inparam.dp;
		break;
		case FDGETDRVPRM:
		outparam = UDP;
		outparam = &drive_params[drive];
		break;
		case FDPOLLDRVSTAT:
		if (lock_fdc(drive))
		@@ -3730,25 +3730,26 @@ static int compat_setdrvprm(int drive,
		if (!valid_floppy_drive_params(v.autodetect, v.native_format))
		return -EINVAL;
		mutex_lock(&floppy_mutex);
		UDP->cmos = v.cmos;
		UDP->max_dtr = v.max_dtr;
		UDP->hlt = v.hlt;
		UDP->hut = v.hut;
		UDP->srt = v.srt;
		UDP->spinup = v.spinup;
		UDP->spindown = v.spindown;
		UDP->spindown_offset = v.spindown_offset;
		UDP->select_delay = v.select_delay;
		UDP->rps = v.rps;
		UDP->tracks = v.tracks;
		UDP->timeout = v.timeout;
		UDP->interleave_sect = v.interleave_sect;
		UDP->max_errors = v.max_errors;
		UDP->flags = v.flags;
		UDP->read_track = v.read_track;
		memcpy(UDP->autodetect, v.autodetect, sizeof(v.autodetect));
		UDP->checkfreq = v.checkfreq;
		UDP->native_format = v.native_format;
		drive_params[drive].cmos = v.cmos;
		drive_params[drive].max_dtr = v.max_dtr;
		drive_params[drive].hlt = v.hlt;
		drive_params[drive].hut = v.hut;
		drive_params[drive].srt = v.srt;
		drive_params[drive].spinup = v.spinup;
		drive_params[drive].spindown = v.spindown;
		drive_params[drive].spindown_offset = v.spindown_offset;
		drive_params[drive].select_delay = v.select_delay;
		drive_params[drive].rps = v.rps;
		drive_params[drive].tracks = v.tracks;
		drive_params[drive].timeout = v.timeout;
		drive_params[drive].interleave_sect = v.interleave_sect;
		drive_params[drive].max_errors = v.max_errors;
		drive_params[drive].flags = v.flags;
		drive_params[drive].read_track = v.read_track;
		memcpy(drive_params[drive].autodetect, v.autodetect,
		sizeof(v.autodetect));
		drive_params[drive].checkfreq = v.checkfreq;
		drive_params[drive].native_format = v.native_format;
		mutex_unlock(&floppy_mutex);
		return 0;
		}
		@@ -3760,25 +3761,26 @@ static int compat_getdrvprm(int drive,

		memset(&v, 0, sizeof(struct compat_floppy_drive_params));
		mutex_lock(&floppy_mutex);
		v.cmos = UDP->cmos;
		v.max_dtr = UDP->max_dtr;
		v.hlt = UDP->hlt;
		v.hut = UDP->hut;
		v.srt = UDP->srt;
		v.spinup = UDP->spinup;
		v.spindown = UDP->spindown;
		v.spindown_offset = UDP->spindown_offset;
		v.select_delay = UDP->select_delay;
		v.rps = UDP->rps;
		v.tracks = UDP->tracks;
		v.timeout = UDP->timeout;
		v.interleave_sect = UDP->interleave_sect;
		v.max_errors = UDP->max_errors;
		v.flags = UDP->flags;
		v.read_track = UDP->read_track;
		memcpy(v.autodetect, UDP->autodetect, sizeof(v.autodetect));
		v.checkfreq = UDP->checkfreq;
		v.native_format = UDP->native_format;
		v.cmos = drive_params[drive].cmos;
		v.max_dtr = drive_params[drive].max_dtr;
		v.hlt = drive_params[drive].hlt;
		v.hut = drive_params[drive].hut;
		v.srt = drive_params[drive].srt;
		v.spinup = drive_params[drive].spinup;
		v.spindown = drive_params[drive].spindown;
		v.spindown_offset = drive_params[drive].spindown_offset;
		v.select_delay = drive_params[drive].select_delay;
		v.rps = drive_params[drive].rps;
		v.tracks = drive_params[drive].tracks;
		v.timeout = drive_params[drive].timeout;
		v.interleave_sect = drive_params[drive].interleave_sect;
		v.max_errors = drive_params[drive].max_errors;
		v.flags = drive_params[drive].flags;
		v.read_track = drive_params[drive].read_track;
		memcpy(v.autodetect, drive_params[drive].autodetect,
		sizeof(v.autodetect));
		v.checkfreq = drive_params[drive].checkfreq;
		v.native_format = drive_params[drive].native_format;
		mutex_unlock(&floppy_mutex);

		if (copy_to_user(arg, &v, sizeof(struct compat_floppy_drive_params)))
		@@ -3931,16 +3933,16 @@ static void __init config_types(void)

		/* read drive info out of physical CMOS */
		drive = 0;
		if (!UDP->cmos)
		UDP->cmos = FLOPPY0_TYPE;
		if (!drive_params[drive].cmos)
		drive_params[drive].cmos = FLOPPY0_TYPE;
		drive = 1;
		if (!UDP->cmos)
		UDP->cmos = FLOPPY1_TYPE;
		if (!drive_params[drive].cmos)
		drive_params[drive].cmos = FLOPPY1_TYPE;

		/* FIXME: additional physical CMOS drive detection should go here */

		for (drive = 0; drive < N_DRIVE; drive++) {
		unsigned int type = UDP->cmos;
		unsigned int type = drive_params[drive].cmos;
		struct floppy_drive_params *params;
		const char *name = NULL;
		char temparea[32];
		@@ -3970,7 +3972,7 @@ static void __init config_types(void)

		pr_cont("%s fd%d is %s", prepend, drive, name);
		}
		UDP = params;
		drive_params[drive] = *params;
		}

		if (has_drive)
		@@ -4012,7 +4014,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
		if (opened_bdev[drive] && opened_bdev[drive] != bdev)
		goto out2;

		if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
		if (!UDRS->fd_ref && (drive_params[drive].flags & FD_BROKEN_DCL)) {
		set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
		set_bit(FD_VERIFY_BIT, &UDRS->flags);
		}
		@@ -4026,7 +4028,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
		if (!floppy_track_buffer) {
		/* if opening an ED drive, reserve a big buffer,
		* else reserve a small one */
		if ((UDP->cmos == 6) \|\| (UDP->cmos == 5))
		if ((drive_params[drive].cmos == 6) \|\| (drive_params[drive].cmos == 5))
		try = 64; /* Only 48 actually useful */
		else
		try = 32; /* Only 24 actually useful */
		@@ -4105,7 +4107,7 @@ static unsigned int floppy_check_events(struct gendisk *disk,
		test_bit(FD_VERIFY_BIT, &UDRS->flags))
		return DISK_EVENT_MEDIA_CHANGE;

		if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
		if (time_after(jiffies, UDRS->last_checked + drive_params[drive].checkfreq)) {
		if (lock_fdc(drive))
		return 0;
		poll_drive(false, 0);
		@@ -4471,7 +4473,7 @@ static ssize_t floppy_cmos_show(struct device *dev,
		int drive;

		drive = p->id;
		return sprintf(buf, "%X\n", UDP->cmos);
		return sprintf(buf, "%X\n", drive_params[drive].cmos);
		}

		static DEVICE_ATTR(cmos, 0444, floppy_cmos_show, NULL);

Admin message