From: "Randy.Dunlap" <rddunlap@osdl.org>
---
25-akpm/drivers/block/floppy.c | 1712 ++++++++++++++++++++---------------------
1 files changed, 857 insertions(+), 855 deletions(-)
diff -puN drivers/block/floppy.c~floppy_format_265 drivers/block/floppy.c
--- 25/drivers/block/floppy.c~floppy_format_265 2004-04-08 21:31:07.726497344 -0700
+++ 25-akpm/drivers/block/floppy.c 2004-04-08 21:31:07.749493848 -0700
@@ -102,7 +102,7 @@
* interrupt and dma channel to asm/floppy.h. Cleaned up some formatting &
* use of '0' for NULL.
*/
-
+
/*
* 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
* failures.
@@ -145,10 +145,10 @@
#define REALLY_SLOW_IO
#define DEBUGT 2
-#define DCL_DEBUG /* debug disk change line */
+#define DCL_DEBUG /* debug disk change line */
/* do print messages for unexpected interrupts */
-static int print_unex=1;
+static int print_unex = 1;
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/fs.h>
@@ -163,7 +163,6 @@ static int print_unex=1;
* 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
*/
-
#include <linux/fd.h>
#include <linux/hdreg.h>
@@ -174,13 +173,13 @@ static int print_unex=1;
#include <linux/string.h>
#include <linux/fcntl.h>
#include <linux/delay.h>
-#include <linux/mc146818rtc.h> /* CMOS defines */
+#include <linux/mc146818rtc.h> /* CMOS defines */
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/device.h>
-#include <linux/buffer_head.h> /* for invalidate_buffers() */
+#include <linux/buffer_head.h> /* for invalidate_buffers() */
/*
* PS/2 floppies have much slower step rates than regular floppies.
@@ -195,9 +194,9 @@ static int slow_floppy;
#include <asm/io.h>
#include <asm/uaccess.h>
-static int FLOPPY_IRQ=6;
-static int FLOPPY_DMA=2;
-static int can_use_virtual_dma=2;
+static int FLOPPY_IRQ = 6;
+static int FLOPPY_DMA = 2;
+static int can_use_virtual_dma = 2;
/* =======
* can use virtual DMA:
* 0 = use of virtual DMA disallowed by config
@@ -221,10 +220,10 @@ static int use_virtual_dma;
static spinlock_t floppy_lock = SPIN_LOCK_UNLOCKED;
static struct completion device_release;
-static unsigned short virtual_dma_port=0x3f0;
-irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs * regs);
+static unsigned short virtual_dma_port = 0x3f0;
+irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
static int set_dor(int fdc, char mask, char data);
-static void register_devfs_entries (int drive) __init;
+static void register_devfs_entries(int drive) __init;
#define K_64 0x10000 /* 64KB */
@@ -249,7 +248,7 @@ static int irqdma_allocated;
#include <linux/blkdev.h>
#include <linux/blkpg.h>
-#include <linux/cdrom.h> /* for the compatibility eject ioctl */
+#include <linux/cdrom.h> /* for the compatibility eject ioctl */
#include <linux/completion.h>
static struct request *current_req;
@@ -274,11 +273,12 @@ static inline void fallback_on_nodma_all
{
#ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
if (*addr)
- return; /* we have the memory */
+ return; /* we have the memory */
if (can_use_virtual_dma != 2)
- return; /* no fallback allowed */
- printk("DMA memory shortage. Temporarily falling back on virtual DMA\n");
- *addr = (char *) nodma_mem_alloc(l);
+ return; /* no fallback allowed */
+ printk
+ ("DMA memory shortage. Temporarily falling back on virtual DMA\n");
+ *addr = (char *)nodma_mem_alloc(l);
#else
return;
#endif
@@ -287,12 +287,12 @@ static inline void fallback_on_nodma_all
/* End dma memory related stuff */
static unsigned long fake_change;
-static int initialising=1;
+static int initialising = 1;
#define ITYPE(x) (((x)>>2) & 0x1f)
#define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
-#define UNIT(x) ((x) & 0x03) /* drive on fdc */
-#define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
+#define UNIT(x) ((x) & 0x03) /* drive on fdc */
+#define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
#define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
/* reverse mapping from unit and fdc to drive */
#define DP (&drive_params[current_drive])
@@ -342,19 +342,18 @@ static int initialising=1;
* current disk size is unknown.
* [Now it is rather a minimum]
*/
-#define MAX_DISK_SIZE 4 /* 3984*/
-
+#define MAX_DISK_SIZE 4 /* 3984 */
/*
* globals used by 'result()'
*/
#define MAX_REPLIES 16
static unsigned char reply_buffer[MAX_REPLIES];
-static int inr; /* size of reply buffer, when called from interrupt */
+static int inr; /* size of reply buffer, when called from interrupt */
#define ST0 (reply_buffer[0])
#define ST1 (reply_buffer[1])
#define ST2 (reply_buffer[2])
-#define ST3 (reply_buffer[0]) /* result of GETSTATUS */
+#define ST3 (reply_buffer[0]) /* result of GETSTATUS */
#define R_TRACK (reply_buffer[3])
#define R_HEAD (reply_buffer[4])
#define R_SECTOR (reply_buffer[5])
@@ -367,8 +366,8 @@ static int inr; /* size of reply buffer,
*/
static struct {
struct floppy_drive_params params;
- const char *name; /* name printed while booting */
-} default_drive_params[]= {
+ const char *name; /* name printed while booting */
+} default_drive_params[] = {
/* NOTE: the time values in jiffies should be in msec!
CMOS drive type
| Maximum data rate supported by drive type
@@ -541,14 +540,14 @@ static char *floppy_track_buffer;
static int max_buffer_sectors;
static int *errors;
-typedef void (*done_f)(int);
+typedef void (*done_f) (int);
static struct cont_t {
- void (*interrupt)(void); /* this is called after the interrupt of the
- * main command */
- void (*redo)(void); /* this is called to retry the operation */
- void (*error)(void); /* this is called to tally an error */
- done_f done; /* this is called to say if the operation has
- * succeeded/failed */
+ void (*interrupt) (void); /* this is called after the interrupt of the
+ * main command */
+ void (*redo) (void); /* this is called to retry the operation */
+ void (*error) (void); /* this is called to tally an error */
+ done_f done; /* this is called to say if the operation has
+ * succeeded/failed */
} *cont;
static void floppy_ready(void);
@@ -589,12 +588,12 @@ static int buffer_max = -1;
/* fdc related variables, should end up in a struct */
static struct floppy_fdc_state fdc_state[N_FDC];
-static int fdc; /* current fdc */
+static int fdc; /* current fdc */
static struct floppy_struct *_floppy = floppy_type;
static unsigned char current_drive;
static long current_count_sectors;
-static unsigned char fsector_t; /* sector in track */
+static unsigned char fsector_t; /* sector in track */
static unsigned char in_sector_offset; /* offset within physical sector,
* expressed in units of 512 bytes */
@@ -624,11 +623,11 @@ static inline void debugt(const char *me
{
#ifdef DEBUGT
if (DP->flags & DEBUGT)
- printk("%s dtime=%lu\n", message, jiffies-debugtimer);
+ printk("%s dtime=%lu\n", message, jiffies - debugtimer);
#endif
}
-typedef void (*timeout_fn)(unsigned long);
+typedef void (*timeout_fn) (unsigned long);
static struct timer_list fd_timeout = TIMER_INITIALIZER(floppy_shutdown, 0, 0);
static const char *timeout_message;
@@ -639,18 +638,18 @@ static void is_alive(const char *message
/* this routine checks whether the floppy driver is "alive" */
if (test_bit(0, &fdc_busy) && command_status < 2
&& !timer_pending(&fd_timeout)) {
- DPRINT("timeout handler died: %s\n",message);
+ DPRINT("timeout handler died: %s\n", message);
}
}
#endif
-static void (*do_floppy)(void) = NULL;
+static void (*do_floppy) (void) = NULL;
#ifdef FLOPPY_SANITY_CHECK
#define OLOGSIZE 20
-static void (*lasthandler)(void);
+static void (*lasthandler) (void);
static unsigned long interruptjiffies;
static unsigned long resultjiffies;
static int resultsize;
@@ -674,12 +673,12 @@ static void __reschedule_timeout(int dri
drive = current_drive;
del_timer(&fd_timeout);
if (drive < 0 || drive > N_DRIVE) {
- fd_timeout.expires = jiffies + 20UL*HZ;
- drive=0;
+ fd_timeout.expires = jiffies + 20UL * HZ;
+ drive = 0;
} else
fd_timeout.expires = jiffies + UDP->timeout;
add_timer(&fd_timeout);
- if (UDP->flags & FD_DEBUG){
+ if (UDP->flags & FD_DEBUG) {
DPRINT("reschedule timeout ");
printk(message, marg);
printk("\n");
@@ -700,7 +699,6 @@ static void reschedule_timeout(int drive
#define SUPBOUND(a,b) (a)=min_t(int, a, b)
-
/*
* Bottom half floppy driver.
* ==========================
@@ -736,32 +734,31 @@ static void reschedule_timeout(int drive
static int disk_change(int drive)
{
- int fdc=FDC(drive);
+ int fdc = FDC(drive);
#ifdef FLOPPY_SANITY_CHECK
if (jiffies - UDRS->select_date < UDP->select_delay)
DPRINT("WARNING disk change called early\n");
if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
- (FDCS->dor & 3) != UNIT(drive) ||
- fdc != FDC(drive)){
+ (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
DPRINT("probing disk change on unselected drive\n");
- DPRINT("drive=%d fdc=%d dor=%x\n",drive, FDC(drive),
- (unsigned int)FDCS->dor);
+ DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
+ (unsigned int)FDCS->dor);
}
#endif
#ifdef DCL_DEBUG
- if (UDP->flags & FD_DEBUG){
- DPRINT("checking disk change line for drive %d\n",drive);
+ if (UDP->flags & FD_DEBUG) {
+ DPRINT("checking disk change line for drive %d\n", drive);
DPRINT("jiffies=%lu\n", jiffies);
- DPRINT("disk change line=%x\n",fd_inb(FD_DIR)&0x80);
- DPRINT("flags=%lx\n",UDRS->flags);
+ DPRINT("disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
+ DPRINT("flags=%lx\n", UDRS->flags);
}
#endif
if (UDP->flags & FD_BROKEN_DCL)
return UTESTF(FD_DISK_CHANGED);
- if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80){
- USETF(FD_VERIFY); /* verify write protection */
- if (UDRS->maxblock){
+ if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
+ USETF(FD_VERIFY); /* verify write protection */
+ if (UDRS->maxblock) {
/* mark it changed */
USETF(FD_DISK_CHANGED);
}
@@ -776,10 +773,10 @@ static int disk_change(int drive)
floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
}
- /*USETF(FD_DISK_NEWCHANGE);*/
+ /*USETF(FD_DISK_NEWCHANGE); */
return 1;
} else {
- UDRS->last_checked=jiffies;
+ UDRS->last_checked = jiffies;
UCLEARF(FD_DISK_NEWCHANGE);
}
return 0;
@@ -787,24 +784,24 @@ static int disk_change(int drive)
static inline int is_selected(int dor, int unit)
{
- return ((dor & (0x10 << unit)) && (dor &3) == unit);
+ return ((dor & (0x10 << unit)) && (dor & 3) == unit);
}
static int set_dor(int fdc, char mask, char data)
{
- register unsigned char drive, unit, newdor,olddor;
+ register unsigned char drive, unit, newdor, olddor;
if (FDCS->address == -1)
return -1;
olddor = FDCS->dor;
- newdor = (olddor & mask) | data;
- if (newdor != olddor){
+ newdor = (olddor & mask) | data;
+ if (newdor != olddor) {
unit = olddor & 0x3;
- if (is_selected(olddor, unit) && !is_selected(newdor,unit)){
- drive = REVDRIVE(fdc,unit);
+ if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
+ drive = REVDRIVE(fdc, unit);
#ifdef DCL_DEBUG
- if (UDP->flags & FD_DEBUG){
+ if (UDP->flags & FD_DEBUG) {
DPRINT("calling disk change from set_dor\n");
}
#endif
@@ -814,15 +811,15 @@ static int set_dor(int fdc, char mask, c
fd_outb(newdor, FD_DOR);
unit = newdor & 0x3;
- if (!is_selected(olddor, unit) && is_selected(newdor,unit)){
- drive = REVDRIVE(fdc,unit);
+ if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
+ drive = REVDRIVE(fdc, unit);
UDRS->select_date = jiffies;
}
}
/*
- * We should propagate failures to grab the resources back
- * nicely from here. Actually we ought to rewrite the fd
- * driver some day too.
+ * We should propagate failures to grab the resources back
+ * nicely from here. Actually we ought to rewrite the fd
+ * driver some day too.
*/
if (newdor & FLOPPY_MOTOR_MASK)
floppy_grab_irq_and_dma();
@@ -835,7 +832,7 @@ static void twaddle(void)
{
if (DP->select_delay)
return;
- fd_outb(FDCS->dor & ~(0x10<<UNIT(current_drive)), FD_DOR);
+ fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
fd_outb(FDCS->dor, FD_DOR);
DRS->select_date = jiffies;
}
@@ -851,15 +848,14 @@ static void reset_fdc_info(int mode)
FDCS->perp_mode = 1;
FDCS->rawcmd = 0;
for (drive = 0; drive < N_DRIVE; drive++)
- if (FDC(drive) == fdc &&
- (mode || UDRS->track != NEED_1_RECAL))
+ if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
UDRS->track = NEED_2_RECAL;
}
/* selects the fdc and drive, and enables the fdc's input/dma. */
static void set_fdc(int drive)
{
- if (drive >= 0 && drive < N_DRIVE){
+ if (drive >= 0 && drive < N_DRIVE) {
fdc = FDC(drive);
current_drive = drive;
}
@@ -867,9 +863,9 @@ static void set_fdc(int drive)
printk("bad fdc value\n");
return;
}
- set_dor(fdc,~0,8);
+ set_dor(fdc, ~0, 8);
#if N_FDC > 1
- set_dor(1-fdc, ~8, 0);
+ set_dor(1 - fdc, ~8, 0);
#endif
if (FDCS->rawcmd == 2)
reset_fdc_info(1);
@@ -880,11 +876,13 @@ static void set_fdc(int drive)
/* locks the driver */
static int _lock_fdc(int drive, int interruptible, int line)
{
- if (!usage_count){
- printk(KERN_ERR "Trying to lock fdc while usage count=0 at line %d\n", line);
+ if (!usage_count) {
+ printk(KERN_ERR
+ "Trying to lock fdc while usage count=0 at line %d\n",
+ line);
return -1;
}
- if(floppy_grab_irq_and_dma()==-1)
+ if (floppy_grab_irq_and_dma() == -1)
return -EBUSY;
if (test_and_set_bit(0, &fdc_busy)) {
@@ -920,7 +918,6 @@ static int _lock_fdc(int drive, int inte
#define LOCK_FDC(drive,interruptible) \
if (lock_fdc(drive,interruptible)) return -EINTR;
-
/* unlocks the driver */
static inline void unlock_fdc(void)
{
@@ -932,7 +929,7 @@ static inline void unlock_fdc(void)
if (do_floppy)
DPRINT("device interrupt still active at FDC release: %p!\n",
- do_floppy);
+ do_floppy);
command_status = FD_COMMAND_NONE;
spin_lock_irqsave(&floppy_lock, flags);
del_timer(&fd_timeout);
@@ -957,22 +954,23 @@ static void motor_off_callback(unsigned
static void floppy_off(unsigned int drive)
{
unsigned long volatile delta;
- register int fdc=FDC(drive);
+ register int fdc = FDC(drive);
if (!(FDCS->dor & (0x10 << UNIT(drive))))
return;
- del_timer(motor_off_timer+drive);
+ del_timer(motor_off_timer + drive);
/* make spindle stop in a position which minimizes spinup time
* next time */
- if (UDP->rps){
+ if (UDP->rps) {
delta = jiffies - UDRS->first_read_date + HZ -
- UDP->spindown_offset;
+ UDP->spindown_offset;
delta = ((delta * UDP->rps) % HZ) / UDP->rps;
- motor_off_timer[drive].expires = jiffies + UDP->spindown - delta;
+ motor_off_timer[drive].expires =
+ jiffies + UDP->spindown - delta;
}
- add_timer(motor_off_timer+drive);
+ add_timer(motor_off_timer + drive);
}
/*
@@ -988,10 +986,10 @@ static void scandrives(void)
return;
saved_drive = current_drive;
- for (i=0; i < N_DRIVE; i++){
+ for (i = 0; i < N_DRIVE; i++) {
drive = (saved_drive + i + 1) % N_DRIVE;
if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
- continue; /* skip closed drives */
+ continue; /* skip closed drives */
set_fdc(drive);
if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
(0x10 << UNIT(drive))))
@@ -1022,7 +1020,7 @@ static void cancel_activity(void)
spin_lock_irqsave(&floppy_lock, flags);
do_floppy = NULL;
- PREPARE_WORK(&floppy_work, (void*)empty, NULL);
+ PREPARE_WORK(&floppy_work, (void *)empty, NULL);
del_timer(&fd_timer);
spin_unlock_irqrestore(&floppy_lock, flags);
}
@@ -1032,12 +1030,12 @@ static void cancel_activity(void)
static void fd_watchdog(void)
{
#ifdef DCL_DEBUG
- if (DP->flags & FD_DEBUG){
+ if (DP->flags & FD_DEBUG) {
DPRINT("calling disk change from watchdog\n");
}
#endif
- if (disk_change(current_drive)){
+ if (disk_change(current_drive)) {
DPRINT("disk removed during i/o\n");
cancel_activity();
cont->done(0);
@@ -1059,14 +1057,14 @@ static void main_command_interrupt(void)
/* waits for a delay (spinup or select) to pass */
static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
{
- if (FDCS->reset){
- reset_fdc(); /* do the reset during sleep to win time
- * if we don't need to sleep, it's a good
- * occasion anyways */
+ if (FDCS->reset) {
+ reset_fdc(); /* do the reset during sleep to win time
+ * if we don't need to sleep, it's a good
+ * occasion anyways */
return 1;
}
- if ((signed) (jiffies - delay) < 0){
+ if ((signed)(jiffies - delay) < 0) {
del_timer(&fd_timer);
fd_timer.function = function;
fd_timer.expires = delay;
@@ -1084,7 +1082,7 @@ static void floppy_disable_hlt(void)
spin_lock_irqsave(&floppy_hlt_lock, flags);
if (!hlt_disabled) {
- hlt_disabled=1;
+ hlt_disabled = 1;
#ifdef HAVE_DISABLE_HLT
disable_hlt();
#endif
@@ -1097,8 +1095,8 @@ static void floppy_enable_hlt(void)
unsigned long flags;
spin_lock_irqsave(&floppy_hlt_lock, flags);
- if (hlt_disabled){
- hlt_disabled=0;
+ if (hlt_disabled) {
+ hlt_disabled = 0;
#ifdef HAVE_DISABLE_HLT
enable_hlt();
#endif
@@ -1106,47 +1104,45 @@ static void floppy_enable_hlt(void)
spin_unlock_irqrestore(&floppy_hlt_lock, flags);
}
-
static void setup_DMA(void)
{
unsigned long f;
#ifdef FLOPPY_SANITY_CHECK
- if (raw_cmd->length == 0){
+ if (raw_cmd->length == 0) {
int i;
printk("zero dma transfer size:");
- for (i=0; i < raw_cmd->cmd_count; i++)
+ for (i = 0; i < raw_cmd->cmd_count; i++)
printk("%x,", raw_cmd->cmd[i]);
printk("\n");
cont->done(0);
FDCS->reset = 1;
return;
}
- if (((unsigned long) raw_cmd->kernel_data) % 512){
+ if (((unsigned long)raw_cmd->kernel_data) % 512) {
printk("non aligned address: %p\n", raw_cmd->kernel_data);
cont->done(0);
- FDCS->reset=1;
+ FDCS->reset = 1;
return;
}
#endif
- f=claim_dma_lock();
+ f = claim_dma_lock();
fd_disable_dma();
#ifdef fd_dma_setup
- if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
- (raw_cmd->flags & FD_RAW_READ)?
- DMA_MODE_READ : DMA_MODE_WRITE,
- FDCS->address) < 0) {
+ if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
+ (raw_cmd->flags & FD_RAW_READ) ?
+ DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
release_dma_lock(f);
cont->done(0);
- FDCS->reset=1;
+ FDCS->reset = 1;
return;
}
release_dma_lock(f);
-#else
+#else
fd_clear_dma_ff();
fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
- fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ)?
+ fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
DMA_MODE_READ : DMA_MODE_WRITE);
fd_set_dma_addr(raw_cmd->kernel_data);
fd_set_dma_count(raw_cmd->length);
@@ -1166,13 +1162,12 @@ static int wait_til_ready(void)
if (FDCS->reset)
return -1;
for (counter = 0; counter < 10000; counter++) {
- status = fd_inb(FD_STATUS);
+ status = fd_inb(FD_STATUS);
if (status & STATUS_READY)
return status;
}
if (!initialising) {
- DPRINT("Getstatus times out (%x) on fdc %d\n",
- status, fdc);
+ DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
show_floppy();
}
FDCS->reset = 1;
@@ -1186,8 +1181,8 @@ static int output_byte(char byte)
if ((status = wait_til_ready()) < 0)
return -1;
- if ((status & (STATUS_READY|STATUS_DIR|STATUS_DMA)) == STATUS_READY){
- fd_outb(byte,FD_DATA);
+ if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY) {
+ fd_outb(byte, FD_DATA);
#ifdef FLOPPY_SANITY_CHECK
output_log[output_log_pos].data = byte;
output_log[output_log_pos].status = status;
@@ -1204,32 +1199,34 @@ static int output_byte(char byte)
}
return -1;
}
+
#define LAST_OUT(x) if (output_byte(x)<0){ reset_fdc();return;}
/* gets the response from the fdc */
static int result(void)
{
- int i, status=0;
+ int i, status = 0;
- for(i=0; i < MAX_REPLIES; i++) {
+ for (i = 0; i < MAX_REPLIES; i++) {
if ((status = wait_til_ready()) < 0)
break;
- status &= STATUS_DIR|STATUS_READY|STATUS_BUSY|STATUS_DMA;
- if ((status & ~STATUS_BUSY) == STATUS_READY){
+ status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
+ if ((status & ~STATUS_BUSY) == STATUS_READY) {
#ifdef FLOPPY_SANITY_CHECK
resultjiffies = jiffies;
resultsize = i;
#endif
return i;
}
- if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY))
+ if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
reply_buffer[i] = fd_inb(FD_DATA);
else
break;
}
if (!initialising) {
- DPRINT("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
- fdc, status, i);
+ DPRINT
+ ("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
+ fdc, status, i);
show_floppy();
}
FDCS->reset = 1;
@@ -1243,7 +1240,7 @@ static int need_more_output(void)
int status;
if ((status = wait_til_ready()) < 0)
return -1;
- if ((status & (STATUS_READY|STATUS_DIR|STATUS_DMA)) == STATUS_READY)
+ if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY)
return MORE_OUTPUT;
return result();
}
@@ -1255,21 +1252,21 @@ static inline void perpendicular_mode(vo
{
unsigned char perp_mode;
- if (raw_cmd->rate & 0x40){
- switch(raw_cmd->rate & 3){
- case 0:
- perp_mode=2;
- break;
- case 3:
- perp_mode=3;
- break;
- default:
- DPRINT("Invalid data rate for perpendicular mode!\n");
- cont->done(0);
- FDCS->reset = 1; /* convenient way to return to
- * redo without to much hassle (deep
- * stack et al. */
- return;
+ if (raw_cmd->rate & 0x40) {
+ switch (raw_cmd->rate & 3) {
+ case 0:
+ perp_mode = 2;
+ break;
+ case 3:
+ perp_mode = 3;
+ break;
+ default:
+ DPRINT("Invalid data rate for perpendicular mode!\n");
+ cont->done(0);
+ FDCS->reset = 1; /* convenient way to return to
+ * redo without to much hassle (deep
+ * stack et al. */
+ return;
}
} else
perp_mode = 0;
@@ -1283,7 +1280,7 @@ static inline void perpendicular_mode(vo
} else if (perp_mode) {
DPRINT("perpendicular mode not supported by this FDC.\n");
}
-} /* perpendicular_mode */
+} /* perpendicular_mode */
static int fifo_depth = 0xa;
static int no_fifo;
@@ -1296,10 +1293,10 @@ static int fdc_configure(void)
return 0;
output_byte(0);
output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
- output_byte(0); /* pre-compensation from track
- 0 upwards */
+ output_byte(0); /* pre-compensation from track
+ 0 upwards */
return 1;
-}
+}
#define NOMINAL_DTR 500
@@ -1334,51 +1331,51 @@ static void fdc_specify(void)
if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
fdc_configure();
FDCS->need_configure = 0;
- /*DPRINT("FIFO enabled\n");*/
+ /*DPRINT("FIFO enabled\n"); */
}
switch (raw_cmd->rate & 0x03) {
- case 3:
- dtr = 1000;
- break;
- case 1:
- dtr = 300;
- if (FDCS->version >= FDC_82078) {
- /* chose the default rate table, not the one
- * where 1 = 2 Mbps */
- output_byte(FD_DRIVESPEC);
- if (need_more_output() == MORE_OUTPUT) {
- output_byte(UNIT(current_drive));
- output_byte(0xc0);
- }
+ case 3:
+ dtr = 1000;
+ break;
+ case 1:
+ dtr = 300;
+ if (FDCS->version >= FDC_82078) {
+ /* chose the default rate table, not the one
+ * where 1 = 2 Mbps */
+ output_byte(FD_DRIVESPEC);
+ if (need_more_output() == MORE_OUTPUT) {
+ output_byte(UNIT(current_drive));
+ output_byte(0xc0);
}
- break;
- case 2:
- dtr = 250;
- break;
+ }
+ break;
+ case 2:
+ dtr = 250;
+ break;
}
if (FDCS->version >= FDC_82072) {
scale_dtr = dtr;
- hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
- hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
+ hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
+ hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
}
/* Convert step rate from microseconds to milliseconds and 4 bits */
- srt = 16 - (DP->srt*scale_dtr/1000 + NOMINAL_DTR - 1)/NOMINAL_DTR;
- if( slow_floppy ) {
+ srt = 16 - (DP->srt * scale_dtr / 1000 + NOMINAL_DTR - 1) / NOMINAL_DTR;
+ if (slow_floppy) {
srt = srt / 4;
}
SUPBOUND(srt, 0xf);
INFBOUND(srt, 0);
- hlt = (DP->hlt*scale_dtr/2 + NOMINAL_DTR - 1)/NOMINAL_DTR;
+ hlt = (DP->hlt * scale_dtr / 2 + NOMINAL_DTR - 1) / NOMINAL_DTR;
if (hlt < 0x01)
hlt = 0x01;
else if (hlt > 0x7f)
hlt = hlt_max_code;
- hut = (DP->hut*scale_dtr/16 + NOMINAL_DTR - 1)/NOMINAL_DTR;
+ hut = (DP->hut * scale_dtr / 16 + NOMINAL_DTR - 1) / NOMINAL_DTR;
if (hut < 0x1)
hut = 0x1;
else if (hut > 0xf)
@@ -1394,7 +1391,7 @@ static void fdc_specify(void)
output_byte(FDCS->spec1 = spec1);
output_byte(FDCS->spec2 = spec2);
}
-} /* fdc_specify */
+} /* fdc_specify */
/* Set the FDC's data transfer rate on behalf of the specified drive.
* NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
@@ -1415,16 +1412,15 @@ static int fdc_dtr(void)
* Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
*/
FDCS->dtr = raw_cmd->rate & 3;
- return(fd_wait_for_completion(jiffies+2UL*HZ/100,
- (timeout_fn) floppy_ready));
-} /* fdc_dtr */
+ return (fd_wait_for_completion(jiffies + 2UL * HZ / 100,
+ (timeout_fn) floppy_ready));
+} /* fdc_dtr */
static void tell_sector(void)
{
printk(": track %d, head %d, sector %d, size %d",
R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
-} /* tell_sector */
-
+} /* tell_sector */
/*
* OK, this error interpreting routine is called after a
@@ -1437,7 +1433,7 @@ static int interpret_errors(void)
{
char bad;
- if (inr!=7) {
+ if (inr != 7) {
DPRINT("-- FDC reply error");
FDCS->reset = 1;
return 1;
@@ -1445,62 +1441,65 @@ static int interpret_errors(void)
/* check IC to find cause of interrupt */
switch (ST0 & ST0_INTR) {
- case 0x40: /* error occurred during command execution */
- if (ST1 & ST1_EOC)
- return 0; /* occurs with pseudo-DMA */
- bad = 1;
- if (ST1 & ST1_WP) {
- DPRINT("Drive is write protected\n");
- CLEARF(FD_DISK_WRITABLE);
- cont->done(0);
- bad = 2;
- } else if (ST1 & ST1_ND) {
- SETF(FD_NEED_TWADDLE);
- } else if (ST1 & ST1_OR) {
- if (DP->flags & FTD_MSG)
- DPRINT("Over/Underrun - retrying\n");
- bad = 0;
- }else if (*errors >= DP->max_errors.reporting){
- DPRINT("");
- if (ST0 & ST0_ECE) {
- printk("Recalibrate failed!");
- } else if (ST2 & ST2_CRC) {
- printk("data CRC error");
- tell_sector();
- } else if (ST1 & ST1_CRC) {
- printk("CRC error");
- tell_sector();
- } else if ((ST1 & (ST1_MAM|ST1_ND)) || (ST2 & ST2_MAM)) {
- if (!probing) {
- printk("sector not found");
- tell_sector();
- } else
- printk("probe failed...");
- } else if (ST2 & ST2_WC) { /* seek error */
- printk("wrong cylinder");
- } else if (ST2 & ST2_BC) { /* cylinder marked as bad */
- printk("bad cylinder");
- } else {
- printk("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x", ST0, ST1, ST2);
+ case 0x40: /* error occurred during command execution */
+ if (ST1 & ST1_EOC)
+ return 0; /* occurs with pseudo-DMA */
+ bad = 1;
+ if (ST1 & ST1_WP) {
+ DPRINT("Drive is write protected\n");
+ CLEARF(FD_DISK_WRITABLE);
+ cont->done(0);
+ bad = 2;
+ } else if (ST1 & ST1_ND) {
+ SETF(FD_NEED_TWADDLE);
+ } else if (ST1 & ST1_OR) {
+ if (DP->flags & FTD_MSG)
+ DPRINT("Over/Underrun - retrying\n");
+ bad = 0;
+ } else if (*errors >= DP->max_errors.reporting) {
+ DPRINT("");
+ if (ST0 & ST0_ECE) {
+ printk("Recalibrate failed!");
+ } else if (ST2 & ST2_CRC) {
+ printk("data CRC error");
+ tell_sector();
+ } else if (ST1 & ST1_CRC) {
+ printk("CRC error");
+ tell_sector();
+ } else if ((ST1 & (ST1_MAM | ST1_ND))
+ || (ST2 & ST2_MAM)) {
+ if (!probing) {
+ printk("sector not found");
tell_sector();
- }
- printk("\n");
-
+ } else
+ printk("probe failed...");
+ } else if (ST2 & ST2_WC) { /* seek error */
+ printk("wrong cylinder");
+ } else if (ST2 & ST2_BC) { /* cylinder marked as bad */
+ printk("bad cylinder");
+ } else {
+ printk
+ ("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
+ ST0, ST1, ST2);
+ tell_sector();
}
- if (ST2 & ST2_WC || ST2 & ST2_BC)
- /* wrong cylinder => recal */
- DRS->track = NEED_2_RECAL;
- return bad;
- case 0x80: /* invalid command given */
- DPRINT("Invalid FDC command given!\n");
- cont->done(0);
- return 2;
- case 0xc0:
- DPRINT("Abnormal termination caused by polling\n");
- cont->error();
- return 2;
- default: /* (0) Normal command termination */
- return 0;
+ printk("\n");
+
+ }
+ if (ST2 & ST2_WC || ST2 & ST2_BC)
+ /* wrong cylinder => recal */
+ DRS->track = NEED_2_RECAL;
+ return bad;
+ case 0x80: /* invalid command given */
+ DPRINT("Invalid FDC command given!\n");
+ cont->done(0);
+ return 2;
+ case 0xc0:
+ DPRINT("Abnormal termination caused by polling\n");
+ cont->error();
+ return 2;
+ default: /* (0) Normal command termination */
+ return 0;
}
}
@@ -1511,7 +1510,7 @@ static int interpret_errors(void)
*/
static void setup_rw_floppy(void)
{
- int i,r, flags,dflags;
+ int i, r, flags, dflags;
unsigned long ready_date;
timeout_fn function;
@@ -1519,20 +1518,20 @@ static void setup_rw_floppy(void)
if (flags & (FD_RAW_READ | FD_RAW_WRITE))
flags |= FD_RAW_INTR;
- if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)){
+ if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
ready_date = DRS->spinup_date + DP->spinup;
/* If spinup will take a long time, rerun scandrives
* again just before spinup completion. Beware that
* after scandrives, we must again wait for selection.
*/
- if ((signed) (ready_date - jiffies) > DP->select_delay){
+ if ((signed)(ready_date - jiffies) > DP->select_delay) {
ready_date -= DP->select_delay;
function = (timeout_fn) floppy_start;
} else
function = (timeout_fn) setup_rw_floppy;
/* wait until the floppy is spinning fast enough */
- if (fd_wait_for_completion(ready_date,function))
+ if (fd_wait_for_completion(ready_date, function))
return;
}
dflags = DRS->flags;
@@ -1543,20 +1542,20 @@ static void setup_rw_floppy(void)
if (flags & FD_RAW_INTR)
do_floppy = main_command_interrupt;
- r=0;
- for (i=0; i< raw_cmd->cmd_count; i++)
- r|=output_byte(raw_cmd->cmd[i]);
+ r = 0;
+ for (i = 0; i < raw_cmd->cmd_count; i++)
+ r |= output_byte(raw_cmd->cmd[i]);
#ifdef DEBUGT
debugt("rw_command: ");
#endif
- if (r){
+ if (r) {
cont->error();
reset_fdc();
return;
}
- if (!(flags & FD_RAW_INTR)){
+ if (!(flags & FD_RAW_INTR)) {
inr = result();
cont->interrupt();
} else if (flags & FD_RAW_NEED_DISK)
@@ -1581,14 +1580,15 @@ static void seek_interrupt(void)
cont->redo();
return;
}
- if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek){
+ if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
#ifdef DCL_DEBUG
- if (DP->flags & FD_DEBUG){
- DPRINT("clearing NEWCHANGE flag because of effective seek\n");
+ if (DP->flags & FD_DEBUG) {
+ DPRINT
+ ("clearing NEWCHANGE flag because of effective seek\n");
DPRINT("jiffies=%lu\n", jiffies);
}
#endif
- CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
+ CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
DRS->select_date = jiffies;
}
DRS->track = ST1;
@@ -1601,19 +1601,19 @@ static void check_wp(void)
/* check write protection */
output_byte(FD_GETSTATUS);
output_byte(UNIT(current_drive));
- if (result() != 1){
+ if (result() != 1) {
FDCS->reset = 1;
return;
}
CLEARF(FD_VERIFY);
CLEARF(FD_NEED_TWADDLE);
#ifdef DCL_DEBUG
- if (DP->flags & FD_DEBUG){
+ if (DP->flags & FD_DEBUG) {
DPRINT("checking whether disk is write protected\n");
- DPRINT("wp=%x\n",ST3 & 0x40);
+ DPRINT("wp=%x\n", ST3 & 0x40);
}
#endif
- if (!(ST3 & 0x40))
+ if (!(ST3 & 0x40))
SETF(FD_DISK_WRITABLE);
else
CLEARF(FD_DISK_WRITABLE);
@@ -1624,17 +1624,16 @@ static void seek_floppy(void)
{
int track;
- blind_seek=0;
+ blind_seek = 0;
#ifdef DCL_DEBUG
- if (DP->flags & FD_DEBUG){
+ if (DP->flags & FD_DEBUG) {
DPRINT("calling disk change from seek\n");
}
#endif
if (!TESTF(FD_DISK_NEWCHANGE) &&
- disk_change(current_drive) &&
- (raw_cmd->flags & FD_RAW_NEED_DISK)){
+ disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
/* the media changed flag should be cleared after the seek.
* If it isn't, this means that there is really no disk in
* the drive.
@@ -1644,7 +1643,7 @@ static void seek_floppy(void)
cont->redo();
return;
}
- if (DRS->track <= NEED_1_RECAL){
+ if (DRS->track <= NEED_1_RECAL) {
recalibrate_floppy();
return;
} else if (TESTF(FD_DISK_NEWCHANGE) &&
@@ -1655,7 +1654,7 @@ static void seek_floppy(void)
if (raw_cmd->track)
track = raw_cmd->track - 1;
else {
- if (DP->flags & FD_SILENT_DCL_CLEAR){
+ if (DP->flags & FD_SILENT_DCL_CLEAR) {
set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
blind_seek = 1;
raw_cmd->flags |= FD_RAW_NEED_SEEK;
@@ -1687,52 +1686,53 @@ static void recal_interrupt(void)
#ifdef DEBUGT
debugt("recal interrupt:");
#endif
- if (inr !=2)
+ if (inr != 2)
FDCS->reset = 1;
else if (ST0 & ST0_ECE) {
- switch(DRS->track){
- case NEED_1_RECAL:
+ switch (DRS->track) {
+ case NEED_1_RECAL:
#ifdef DEBUGT
- debugt("recal interrupt need 1 recal:");
+ debugt("recal interrupt need 1 recal:");
#endif
- /* after a second recalibrate, we still haven't
- * reached track 0. Probably no drive. Raise an
- * error, as failing immediately might upset
- * computers possessed by the Devil :-) */
- cont->error();
- cont->redo();
- return;
- case NEED_2_RECAL:
+ /* after a second recalibrate, we still haven't
+ * reached track 0. Probably no drive. Raise an
+ * error, as failing immediately might upset
+ * computers possessed by the Devil :-) */
+ cont->error();
+ cont->redo();
+ return;
+ case NEED_2_RECAL:
#ifdef DEBUGT
- debugt("recal interrupt need 2 recal:");
+ debugt("recal interrupt need 2 recal:");
#endif
- /* If we already did a recalibrate,
- * and we are not at track 0, this
- * means we have moved. (The only way
- * not to move at recalibration is to
- * be already at track 0.) Clear the
- * new change flag */
+ /* If we already did a recalibrate,
+ * and we are not at track 0, this
+ * means we have moved. (The only way
+ * not to move at recalibration is to
+ * be already at track 0.) Clear the
+ * new change flag */
#ifdef DCL_DEBUG
- if (DP->flags & FD_DEBUG){
- DPRINT("clearing NEWCHANGE flag because of second recalibrate\n");
- }
+ if (DP->flags & FD_DEBUG) {
+ DPRINT
+ ("clearing NEWCHANGE flag because of second recalibrate\n");
+ }
#endif
- CLEARF(FD_DISK_NEWCHANGE);
- DRS->select_date = jiffies;
- /* fall through */
- default:
+ CLEARF(FD_DISK_NEWCHANGE);
+ DRS->select_date = jiffies;
+ /* fall through */
+ default:
#ifdef DEBUGT
- debugt("recal interrupt default:");
+ debugt("recal interrupt default:");
#endif
- /* Recalibrate moves the head by at
- * most 80 steps. If after one
- * recalibrate we don't have reached
- * track 0, this might mean that we
- * started beyond track 80. Try
- * again. */
- DRS->track = NEED_1_RECAL;
- break;
+ /* Recalibrate moves the head by at
+ * most 80 steps. If after one
+ * recalibrate we don't have reached
+ * track 0, this might mean that we
+ * started beyond track 80. Try
+ * again. */
+ DRS->track = NEED_1_RECAL;
+ break;
}
} else
DRS->track = ST1;
@@ -1745,31 +1745,31 @@ static void print_result(char *message,
DPRINT("%s ", message);
if (inr >= 0)
- for (i=0; i<inr; i++)
+ for (i = 0; i < inr; i++)
printk("repl[%d]=%x ", i, reply_buffer[i]);
printk("\n");
}
/* interrupt handler. Note that this can be called externally on the Sparc */
-irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs * regs)
+irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
- void (*handler)(void) = do_floppy;
+ void (*handler) (void) = do_floppy;
int do_print;
unsigned long f;
lasthandler = handler;
interruptjiffies = jiffies;
- f=claim_dma_lock();
+ f = claim_dma_lock();
fd_disable_dma();
release_dma_lock(f);
floppy_enable_hlt();
do_floppy = NULL;
- if (fdc >= N_FDC || FDCS->address == -1){
+ if (fdc >= N_FDC || FDCS->address == -1) {
/* we don't even know which FDC is the culprit */
printk("DOR0=%x\n", fdc_state[0].dor);
- printk("floppy interrupt on bizarre fdc %d\n",fdc);
+ printk("floppy interrupt on bizarre fdc %d\n", fdc);
printk("handler=%p\n", handler);
is_alive("bizarre fdc");
return IRQ_NONE;
@@ -1790,7 +1790,7 @@ irqreturn_t floppy_interrupt(int irq, vo
inr = result();
if (do_print)
print_result("unexpected interrupt", inr);
- if (inr == 0){
+ if (inr == 0) {
int max_sensei = 4;
do {
output_byte(FD_SENSEI);
@@ -1798,7 +1798,8 @@ irqreturn_t floppy_interrupt(int irq, vo
if (do_print)
print_result("sensei", inr);
max_sensei--;
- } while ((ST0 & 0x83) != UNIT(current_drive) && inr == 2 && max_sensei);
+ } while ((ST0 & 0x83) != UNIT(current_drive) && inr == 2
+ && max_sensei);
}
if (handler)
schedule_bh(handler);
@@ -1831,7 +1832,7 @@ static void reset_interrupt(void)
result(); /* get the status ready for set_fdc */
if (FDCS->reset) {
printk("reset set in interrupt, calling %p\n", cont->error);
- cont->error(); /* a reset just after a reset. BAD! */
+ cont->error(); /* a reset just after a reset. BAD! */
}
cont->redo();
}
@@ -1851,12 +1852,12 @@ static void reset_fdc(void)
/* Pseudo-DMA may intercept 'reset finished' interrupt. */
/* Irrelevant for systems with true DMA (i386). */
- flags=claim_dma_lock();
+ flags = claim_dma_lock();
fd_disable_dma();
release_dma_lock(flags);
if (FDCS->version >= FDC_82072A)
- fd_outb(0x80 | (FDCS->dtr &3), FD_STATUS);
+ fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
else {
fd_outb(FDCS->dor & ~0x04, FD_DOR);
udelay(FD_RESET_DELAY);
@@ -1872,20 +1873,20 @@ static void show_floppy(void)
printk("floppy driver state\n");
printk("-------------------\n");
printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",
- jiffies, interruptjiffies, jiffies-interruptjiffies, lasthandler);
-
+ jiffies, interruptjiffies, jiffies - interruptjiffies,
+ lasthandler);
#ifdef FLOPPY_SANITY_CHECK
printk("timeout_message=%s\n", timeout_message);
printk("last output bytes:\n");
- for (i=0; i < OLOGSIZE; i++)
+ for (i = 0; i < OLOGSIZE; i++)
printk("%2x %2x %lu\n",
- output_log[(i+output_log_pos) % OLOGSIZE].data,
- output_log[(i+output_log_pos) % OLOGSIZE].status,
- output_log[(i+output_log_pos) % OLOGSIZE].jiffies);
+ output_log[(i + output_log_pos) % OLOGSIZE].data,
+ output_log[(i + output_log_pos) % OLOGSIZE].status,
+ output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
printk("last result at %lu\n", resultjiffies);
printk("last redo_fd_request at %lu\n", lastredo);
- for (i=0; i<resultsize; i++){
+ for (i = 0; i < resultsize; i++) {
printk("%2x ", reply_buffer[i]);
}
printk("\n");
@@ -1899,10 +1900,10 @@ static void show_floppy(void)
printk("floppy_work.func=%p\n", floppy_work.func);
if (timer_pending(&fd_timer))
printk("fd_timer.function=%p\n", fd_timer.function);
- if (timer_pending(&fd_timeout)){
- printk("timer_function=%p\n",fd_timeout.function);
- printk("expires=%lu\n",fd_timeout.expires-jiffies);
- printk("now=%lu\n",jiffies);
+ if (timer_pending(&fd_timeout)) {
+ printk("timer_function=%p\n", fd_timeout.function);
+ printk("expires=%lu\n", fd_timeout.expires - jiffies);
+ printk("now=%lu\n", jiffies);
}
printk("cont=%p\n", cont);
printk("current_req=%p\n", current_req);
@@ -1913,42 +1914,43 @@ static void show_floppy(void)
static void floppy_shutdown(unsigned long data)
{
unsigned long flags;
-
+
if (!initialising)
show_floppy();
cancel_activity();
floppy_enable_hlt();
-
- flags=claim_dma_lock();
+
+ flags = claim_dma_lock();
fd_disable_dma();
release_dma_lock(flags);
-
+
/* avoid dma going to a random drive after shutdown */
if (!initialising)
DPRINT("floppy timeout called\n");
FDCS->reset = 1;
- if (cont){
+ if (cont) {
cont->done(0);
- cont->redo(); /* this will recall reset when needed */
+ cont->redo(); /* this will recall reset when needed */
} else {
printk("no cont in shutdown!\n");
process_fd_request();
}
is_alive("floppy shutdown");
}
+
/*typedef void (*timeout_fn)(unsigned long);*/
/* start motor, check media-changed condition and write protection */
-static int start_motor(void (*function)(void) )
+static int start_motor(void (*function) (void))
{
int mask, data;
mask = 0xfc;
data = UNIT(current_drive);
- if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)){
- if (!(FDCS->dor & (0x10 << UNIT(current_drive)))){
+ if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
+ if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
set_debugt();
/* no read since this drive is running */
DRS->first_read_date = 0;
@@ -1956,53 +1958,50 @@ static int start_motor(void (*function)(
DRS->spinup_date = jiffies;
data |= (0x10 << UNIT(current_drive));
}
- } else
- if (FDCS->dor & (0x10 << UNIT(current_drive)))
- mask &= ~(0x10 << UNIT(current_drive));
+ } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
+ mask &= ~(0x10 << UNIT(current_drive));
/* starts motor and selects floppy */
del_timer(motor_off_timer + current_drive);
set_dor(fdc, mask, data);
/* wait_for_completion also schedules reset if needed. */
- return(fd_wait_for_completion(DRS->select_date+DP->select_delay,
- (timeout_fn) function));
+ return (fd_wait_for_completion(DRS->select_date + DP->select_delay,
+ (timeout_fn) function));
}
static void floppy_ready(void)
{
CHECK_RESET;
- if (start_motor(floppy_ready)) return;
- if (fdc_dtr()) return;
+ if (start_motor(floppy_ready))
+ return;
+ if (fdc_dtr())
+ return;
#ifdef DCL_DEBUG
- if (DP->flags & FD_DEBUG){
+ if (DP->flags & FD_DEBUG) {
DPRINT("calling disk change from floppy_ready\n");
}
#endif
if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
- disk_change(current_drive) &&
- !DP->select_delay)
- twaddle(); /* this clears the dcl on certain drive/controller
- * combinations */
+ disk_change(current_drive) && !DP->select_delay)
+ twaddle(); /* this clears the dcl on certain drive/controller
+ * combinations */
#ifdef fd_chose_dma_mode
- if ((raw_cmd->flags & FD_RAW_READ) ||
- (raw_cmd->flags & FD_RAW_WRITE))
- {
+ if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
unsigned long flags = claim_dma_lock();
- fd_chose_dma_mode(raw_cmd->kernel_data,
- raw_cmd->length);
+ fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
release_dma_lock(flags);
}
#endif
- if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)){
+ if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
perpendicular_mode();
- fdc_specify(); /* must be done here because of hut, hlt ... */
+ fdc_specify(); /* must be done here because of hut, hlt ... */
seek_floppy();
} else {
- if ((raw_cmd->flags & FD_RAW_READ) ||
+ if ((raw_cmd->flags & FD_RAW_READ) ||
(raw_cmd->flags & FD_RAW_WRITE))
fdc_specify();
setup_rw_floppy();
@@ -2015,7 +2014,7 @@ static void floppy_start(void)
scandrives();
#ifdef DCL_DEBUG
- if (DP->flags & FD_DEBUG){
+ if (DP->flags & FD_DEBUG) {
DPRINT("setting NEWCHANGE in floppy_start\n");
}
#endif
@@ -2046,21 +2045,20 @@ static void do_wakeup(void)
}
static struct cont_t wakeup_cont = {
- .interrupt = empty,
- .redo = do_wakeup,
- .error = empty,
- .done = (done_f) empty
+ .interrupt = empty,
+ .redo = do_wakeup,
+ .error = empty,
+ .done = (done_f) empty
};
-
static struct cont_t intr_cont = {
- .interrupt = empty,
- .redo = process_fd_request,
- .error = empty,
- .done = (done_f) empty
+ .interrupt = empty,
+ .redo = process_fd_request,
+ .error = empty,
+ .done = (done_f) empty
};
-static int wait_til_done(void (*handler)(void), int interruptible)
+static int wait_til_done(void (*handler) (void), int interruptible)
{
int ret;
@@ -2071,8 +2069,8 @@ static int wait_til_done(void (*handler)
add_wait_queue(&command_done, &wait);
for (;;) {
- set_current_state(interruptible?
- TASK_INTERRUPTIBLE:
+ set_current_state(interruptible ?
+ TASK_INTERRUPTIBLE :
TASK_UNINTERRUPTIBLE);
if (command_status >= 2 || !NO_SIGNAL)
@@ -2087,7 +2085,7 @@ static int wait_til_done(void (*handler)
remove_wait_queue(&command_done, &wait);
}
- if (command_status < 2){
+ if (command_status < 2) {
cancel_activity();
cont = &intr_cont;
reset_fdc();
@@ -2097,9 +2095,9 @@ static int wait_til_done(void (*handler)
if (FDCS->reset)
command_status = FD_COMMAND_ERROR;
if (command_status == FD_COMMAND_OKAY)
- ret=0;
+ ret = 0;
else
- ret=-EIO;
+ ret = -EIO;
command_status = FD_COMMAND_NONE;
return ret;
}
@@ -2126,7 +2124,6 @@ static void success_and_wakeup(void)
cont->redo();
}
-
/*
* formatting and rw support.
* ==========================
@@ -2137,13 +2134,12 @@ static int next_valid_format(void)
int probed_format;
probed_format = DRS->probed_format;
- while(1){
- if (probed_format >= 8 ||
- !DP->autodetect[probed_format]){
+ while (1) {
+ if (probed_format >= 8 || !DP->autodetect[probed_format]) {
DRS->probed_format = 0;
return 1;
}
- if (floppy_type[DP->autodetect[probed_format]].sect){
+ if (floppy_type[DP->autodetect[probed_format]].sect) {
DRS->probed_format = probed_format;
return 0;
}
@@ -2155,7 +2151,7 @@ static void bad_flp_intr(void)
{
int err_count;
- if (probing){
+ if (probing) {
DRS->probed_format++;
if (!next_valid_format())
return;
@@ -2176,7 +2172,7 @@ static void set_floppy(int drive)
if (type)
_floppy = floppy_type + type;
else
- _floppy = current_type[ drive ];
+ _floppy = current_type[drive];
}
/*
@@ -2185,13 +2181,13 @@ static void set_floppy(int drive)
*/
static void format_interrupt(void)
{
- switch (interpret_errors()){
- case 1:
- cont->error();
- case 2:
- break;
- case 0:
- cont->done(1);
+ switch (interpret_errors()) {
+ case 1:
+ cont->error();
+ case 2:
+ break;
+ case 0:
+ cont->done(1);
}
cont->redo();
}
@@ -2202,20 +2198,20 @@ static void format_interrupt(void)
static void setup_format_params(int track)
{
struct fparm {
- unsigned char track,head,sect,size;
+ unsigned char track, head, sect, size;
} *here = (struct fparm *)floppy_track_buffer;
- int il,n;
- int count,head_shift,track_shift;
+ int il, n;
+ int count, head_shift, track_shift;
raw_cmd = &default_raw_cmd;
raw_cmd->track = track;
raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
- FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
+ FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
raw_cmd->rate = _floppy->rate & 0x43;
raw_cmd->cmd_count = NR_F;
- COMMAND = FM_MODE(_floppy,FD_FORMAT);
- DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy,format_req.head);
+ COMMAND = FM_MODE(_floppy, FD_FORMAT);
+ DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
F_SIZECODE = FD_SIZECODE(_floppy);
F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
F_GAP = _floppy->fmt_gap;
@@ -2225,14 +2221,14 @@ static void setup_format_params(int trac
raw_cmd->length = 4 * F_SECT_PER_TRACK;
/* allow for about 30ms for data transport per track */
- head_shift = (F_SECT_PER_TRACK + 5) / 6;
+ head_shift = (F_SECT_PER_TRACK + 5) / 6;
/* a ``cylinder'' is two tracks plus a little stepping time */
track_shift = 2 * head_shift + 3;
/* position of logical sector 1 on this track */
n = (track_shift * format_req.track + head_shift * format_req.head)
- % F_SECT_PER_TRACK;
+ % F_SECT_PER_TRACK;
/* determine interleave */
il = 1;
@@ -2249,18 +2245,19 @@ static void setup_format_params(int trac
/* place logical sectors */
for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
here[n].sect = count;
- n = (n+il) % F_SECT_PER_TRACK;
- if (here[n].sect) { /* sector busy, find next free sector */
+ n = (n + il) % F_SECT_PER_TRACK;
+ if (here[n].sect) { /* sector busy, find next free sector */
++n;
- if (n>= F_SECT_PER_TRACK) {
- n-=F_SECT_PER_TRACK;
- while (here[n].sect) ++n;
+ if (n >= F_SECT_PER_TRACK) {
+ n -= F_SECT_PER_TRACK;
+ while (here[n].sect)
+ ++n;
}
}
}
- if(_floppy->stretch & FD_ZEROBASED) {
- for(count = 0; count < F_SECT_PER_TRACK; count++)
- here[count].sect--;
+ if (_floppy->stretch & FD_ZEROBASED) {
+ for (count = 0; count < F_SECT_PER_TRACK; count++)
+ here[count].sect--;
}
}
@@ -2275,23 +2272,23 @@ static void redo_format(void)
}
static struct cont_t format_cont = {
- .interrupt = format_interrupt,
- .redo = redo_format,
- .error = bad_flp_intr,
- .done = generic_done
+ .interrupt = format_interrupt,
+ .redo = redo_format,
+ .error = bad_flp_intr,
+ .done = generic_done
};
static int do_format(int drive, struct format_descr *tmp_format_req)
{
int ret;
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
set_floppy(drive);
if (!_floppy ||
_floppy->track > DP->tracks ||
tmp_format_req->track >= _floppy->track ||
tmp_format_req->head >= _floppy->head ||
- (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
+ (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
!_floppy->fmt_gap) {
process_fd_request();
return -EINVAL;
@@ -2328,7 +2325,6 @@ static void floppy_end_request(struct re
current_req = NULL;
}
-
/* new request_done. Can handle physical sectors which are smaller than a
* logical buffer */
static void request_done(int uptodate)
@@ -2346,7 +2342,7 @@ static void request_done(int uptodate)
return;
}
- if (uptodate){
+ if (uptodate) {
/* maintain values for invalidation on geometry
* change */
block = current_count_sectors + req->sector;
@@ -2381,11 +2377,11 @@ static void rw_interrupt(void)
int nr_sectors, ssize, eoc, heads;
if (R_HEAD >= 2) {
- /* some Toshiba floppy controllers occasionnally seem to
- * return bogus interrupts after read/write operations, which
- * can be recognized by a bad head number (>= 2) */
- return;
- }
+ /* some Toshiba floppy controllers occasionnally seem to
+ * return bogus interrupts after read/write operations, which
+ * can be recognized by a bad head number (>= 2) */
+ return;
+ }
if (!DRS->first_read_date)
DRS->first_read_date = jiffies;
@@ -2403,15 +2399,15 @@ static void rw_interrupt(void)
else
heads = 1;
- nr_sectors = (((R_TRACK-TRACK) * heads +
- R_HEAD-HEAD) * SECT_PER_TRACK +
- R_SECTOR-SECTOR + eoc) << SIZECODE >> 2;
+ nr_sectors = (((R_TRACK - TRACK) * heads +
+ R_HEAD - HEAD) * SECT_PER_TRACK +
+ R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
#ifdef FLOPPY_SANITY_CHECK
- if (nr_sectors / ssize >
- (in_sector_offset + current_count_sectors + ssize - 1) / ssize) {
+ if (nr_sectors / ssize >
+ (in_sector_offset + current_count_sectors + ssize - 1) / ssize) {
DPRINT("long rw: %x instead of %lx\n",
- nr_sectors, current_count_sectors);
+ nr_sectors, current_count_sectors);
printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
printk("rh=%d h=%d\n", R_HEAD, HEAD);
printk("rt=%d t=%d\n", R_TRACK, TRACK);
@@ -2423,44 +2419,44 @@ static void rw_interrupt(void)
#endif
nr_sectors -= in_sector_offset;
- INFBOUND(nr_sectors,0);
+ INFBOUND(nr_sectors, 0);
SUPBOUND(current_count_sectors, nr_sectors);
- switch (interpret_errors()){
- case 2:
+ switch (interpret_errors()) {
+ case 2:
+ cont->redo();
+ return;
+ case 1:
+ if (!current_count_sectors) {
+ cont->error();
cont->redo();
return;
- case 1:
- if (!current_count_sectors){
- cont->error();
- cont->redo();
- return;
- }
- break;
- case 0:
- if (!current_count_sectors){
- cont->redo();
- return;
- }
- current_type[current_drive] = _floppy;
- floppy_sizes[TOMINOR(current_drive) ]= _floppy->size;
- break;
+ }
+ break;
+ case 0:
+ if (!current_count_sectors) {
+ cont->redo();
+ return;
+ }
+ current_type[current_drive] = _floppy;
+ floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
+ break;
}
if (probing) {
if (DP->flags & FTD_MSG)
DPRINT("Auto-detected floppy type %s in fd%d\n",
- _floppy->name,current_drive);
+ _floppy->name, current_drive);
current_type[current_drive] = _floppy;
floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
probing = 0;
}
- if (CT(COMMAND) != FD_READ ||
- raw_cmd->kernel_data == current_req->buffer){
+ if (CT(COMMAND) != FD_READ ||
+ raw_cmd->kernel_data == current_req->buffer) {
/* transfer directly from buffer */
cont->done(1);
- } else if (CT(COMMAND) == FD_READ){
+ } else if (CT(COMMAND) == FD_READ) {
buffer_track = raw_cmd->track;
buffer_drive = current_drive;
INFBOUND(buffer_max, nr_sectors + fsector_t);
@@ -2481,7 +2477,8 @@ static int buffer_chain_size(void)
rq_for_each_bio(bio, current_req) {
bio_for_each_segment(bv, bio, i) {
- if (page_address(bv->bv_page) + bv->bv_offset != base + size)
+ if (page_address(bv->bv_page) + bv->bv_offset !=
+ base + size)
break;
size += bv->bv_len;
@@ -2500,7 +2497,7 @@ static int transfer_size(int ssize, int
max_sector -= (max_sector % _floppy->sect) % ssize;
/* transfer size, beginning not aligned */
- current_count_sectors = max_sector - fsector_t ;
+ current_count_sectors = max_sector - fsector_t;
return max_sector;
}
@@ -2510,7 +2507,7 @@ static int transfer_size(int ssize, int
*/
static void copy_buffer(int ssize, int max_sector, int max_sector_2)
{
- int remaining; /* number of transferred 512-byte sectors */
+ int remaining; /* number of transferred 512-byte sectors */
struct bio_vec *bv;
struct bio *bio;
char *buffer, *dma_buffer;
@@ -2523,16 +2520,17 @@ static void copy_buffer(int ssize, int m
if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
buffer_max > fsector_t + current_req->nr_sectors)
current_count_sectors = min_t(int, buffer_max - fsector_t,
- current_req->nr_sectors);
+ current_req->nr_sectors);
remaining = current_count_sectors << 9;
#ifdef FLOPPY_SANITY_CHECK
- if ((remaining >> 9) > current_req->nr_sectors &&
- CT(COMMAND) == FD_WRITE){
+ if ((remaining >> 9) > current_req->nr_sectors &&
+ CT(COMMAND) == FD_WRITE) {
DPRINT("in copy buffer\n");
printk("current_count_sectors=%ld\n", current_count_sectors);
printk("remaining=%d\n", remaining >> 9);
- printk("current_req->nr_sectors=%ld\n",current_req->nr_sectors);
+ printk("current_req->nr_sectors=%ld\n",
+ current_req->nr_sectors);
printk("current_req->current_nr_sectors=%u\n",
current_req->current_nr_sectors);
printk("max_sector=%d\n", max_sector);
@@ -2556,23 +2554,24 @@ static void copy_buffer(int ssize, int m
buffer = page_address(bv->bv_page) + bv->bv_offset;
#ifdef FLOPPY_SANITY_CHECK
- if (dma_buffer + size >
- floppy_track_buffer + (max_buffer_sectors << 10) ||
- dma_buffer < floppy_track_buffer){
- DPRINT("buffer overrun in copy buffer %d\n",
- (int) ((floppy_track_buffer - dma_buffer) >>9));
- printk("fsector_t=%d buffer_min=%d\n",
- fsector_t, buffer_min);
- printk("current_count_sectors=%ld\n",
- current_count_sectors);
- if (CT(COMMAND) == FD_READ)
- printk("read\n");
- if (CT(COMMAND) == FD_WRITE)
- printk("write\n");
- break;
- }
- if (((unsigned long)buffer) % 512)
- DPRINT("%p buffer not aligned\n", buffer);
+ if (dma_buffer + size >
+ floppy_track_buffer + (max_buffer_sectors << 10) ||
+ dma_buffer < floppy_track_buffer) {
+ DPRINT("buffer overrun in copy buffer %d\n",
+ (int)((floppy_track_buffer -
+ dma_buffer) >> 9));
+ printk("fsector_t=%d buffer_min=%d\n",
+ fsector_t, buffer_min);
+ printk("current_count_sectors=%ld\n",
+ current_count_sectors);
+ if (CT(COMMAND) == FD_READ)
+ printk("read\n");
+ if (CT(COMMAND) == FD_WRITE)
+ printk("write\n");
+ break;
+ }
+ if (((unsigned long)buffer) % 512)
+ DPRINT("%p buffer not aligned\n", buffer);
#endif
if (CT(COMMAND) == FD_READ)
memcpy(buffer, dma_buffer, size);
@@ -2584,21 +2583,21 @@ static void copy_buffer(int ssize, int m
}
}
#ifdef FLOPPY_SANITY_CHECK
- if (remaining){
+ if (remaining) {
if (remaining > 0)
max_sector -= remaining >> 9;
- DPRINT("weirdness: remaining %d\n", remaining>>9);
+ DPRINT("weirdness: remaining %d\n", remaining >> 9);
}
#endif
}
#if 0
-static inline int check_dma_crossing(char *start,
+static inline int check_dma_crossing(char *start,
unsigned long length, char *message)
{
if (CROSS_64KB(start, length)) {
- printk("DMA xfer crosses 64KB boundary in %s %p-%p\n",
- message, start, start+length);
+ printk("DMA xfer crosses 64KB boundary in %s %p-%p\n",
+ message, start, start + length);
return 1;
} else
return 0;
@@ -2616,20 +2615,20 @@ static void virtualdmabug_workaround(voi
{
int hard_sectors, end_sector;
- if(CT(COMMAND) == FD_WRITE) {
- COMMAND &= ~0x80; /* switch off multiple track mode */
+ if (CT(COMMAND) == FD_WRITE) {
+ COMMAND &= ~0x80; /* switch off multiple track mode */
hard_sectors = raw_cmd->length >> (7 + SIZECODE);
end_sector = SECTOR + hard_sectors - 1;
#ifdef FLOPPY_SANITY_CHECK
- if(end_sector > SECT_PER_TRACK) {
+ if (end_sector > SECT_PER_TRACK) {
printk("too many sectors %d > %d\n",
end_sector, SECT_PER_TRACK);
return;
}
#endif
- SECT_PER_TRACK = end_sector; /* make sure SECT_PER_TRACK points
- * to end of transfer */
+ SECT_PER_TRACK = end_sector; /* make sure SECT_PER_TRACK points
+ * to end of transfer */
}
}
@@ -2648,7 +2647,7 @@ static int make_raw_rw_request(void)
int aligned_sector_t;
int max_sector, max_size, tracksize, ssize;
- if(max_buffer_sectors == 0) {
+ if (max_buffer_sectors == 0) {
printk("VFS: Block I/O scheduled on unopened device\n");
return 0;
}
@@ -2657,14 +2656,14 @@ static int make_raw_rw_request(void)
raw_cmd = &default_raw_cmd;
raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
- FD_RAW_NEED_SEEK;
+ FD_RAW_NEED_SEEK;
raw_cmd->cmd_count = NR_RW;
if (rq_data_dir(current_req) == READ) {
raw_cmd->flags |= FD_RAW_READ;
- COMMAND = FM_MODE(_floppy,FD_READ);
- } else if (rq_data_dir(current_req) == WRITE){
+ COMMAND = FM_MODE(_floppy, FD_READ);
+ } else if (rq_data_dir(current_req) == WRITE) {
raw_cmd->flags |= FD_RAW_WRITE;
- COMMAND = FM_MODE(_floppy,FD_WRITE);
+ COMMAND = FM_MODE(_floppy, FD_WRITE);
} else {
DPRINT("make_raw_rw_request: unknown command\n");
return 0;
@@ -2684,25 +2683,23 @@ static int make_raw_rw_request(void)
HEAD = fsector_t / _floppy->sect;
if (((_floppy->stretch & (FD_SWAPSIDES | FD_ZEROBASED)) ||
- TESTF(FD_NEED_TWADDLE)) &&
- fsector_t < _floppy->sect)
+ TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
max_sector = _floppy->sect;
/* 2M disks have phantom sectors on the first track */
- if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)){
+ if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
max_sector = 2 * _floppy->sect / 3;
- if (fsector_t >= max_sector){
- current_count_sectors = min_t(int, _floppy->sect - fsector_t,
- current_req->nr_sectors);
+ if (fsector_t >= max_sector) {
+ current_count_sectors =
+ min_t(int, _floppy->sect - fsector_t,
+ current_req->nr_sectors);
return 1;
}
SIZECODE = 2;
} else
SIZECODE = FD_SIZECODE(_floppy);
raw_cmd->rate = _floppy->rate & 0x43;
- if ((_floppy->rate & FD_2M) &&
- (TRACK || HEAD) &&
- raw_cmd->rate == 2)
+ if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
raw_cmd->rate = 1;
if (SIZECODE)
@@ -2710,7 +2707,7 @@ static int make_raw_rw_request(void)
else
SIZECODE2 = 0x80;
raw_cmd->track = TRACK << STRETCH(_floppy);
- DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy,HEAD);
+ DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
GAP = _floppy->gap;
CODE2SIZE;
SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
@@ -2721,18 +2718,19 @@ static int make_raw_rw_request(void)
* of size ssize.
*/
tracksize = _floppy->sect - _floppy->sect % ssize;
- if (tracksize < _floppy->sect){
- SECT_PER_TRACK ++;
+ if (tracksize < _floppy->sect) {
+ SECT_PER_TRACK++;
if (tracksize <= fsector_t % _floppy->sect)
SECTOR--;
/* if we are beyond tracksize, fill up using smaller sectors */
- while (tracksize <= fsector_t % _floppy->sect){
- while(tracksize + ssize > _floppy->sect){
+ while (tracksize <= fsector_t % _floppy->sect) {
+ while (tracksize + ssize > _floppy->sect) {
SIZECODE--;
ssize >>= 1;
}
- SECTOR++; SECT_PER_TRACK ++;
+ SECTOR++;
+ SECT_PER_TRACK++;
tracksize += ssize;
}
max_sector = HEAD * _floppy->sect + tracksize;
@@ -2746,7 +2744,7 @@ static int make_raw_rw_request(void)
in_sector_offset = (fsector_t % _floppy->sect) % ssize;
aligned_sector_t = fsector_t - in_sector_offset;
max_size = current_req->nr_sectors;
- if ((raw_cmd->track == buffer_track) &&
+ if ((raw_cmd->track == buffer_track) &&
(current_drive == buffer_drive) &&
(fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
/* data already in track buffer */
@@ -2754,8 +2752,8 @@ static int make_raw_rw_request(void)
copy_buffer(1, max_sector, buffer_max);
return 1;
}
- } else if (in_sector_offset || current_req->nr_sectors < ssize){
- if (CT(COMMAND) == FD_WRITE){
+ } else if (in_sector_offset || current_req->nr_sectors < ssize) {
+ if (CT(COMMAND) == FD_WRITE) {
if (fsector_t + current_req->nr_sectors > ssize &&
fsector_t + current_req->nr_sectors < ssize + ssize)
max_size = ssize + ssize;
@@ -2764,28 +2762,32 @@ static int make_raw_rw_request(void)
}
raw_cmd->flags &= ~FD_RAW_WRITE;
raw_cmd->flags |= FD_RAW_READ;
- COMMAND = FM_MODE(_floppy,FD_READ);
+ COMMAND = FM_MODE(_floppy, FD_READ);
} else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
unsigned long dma_limit;
int direct, indirect;
- indirect= transfer_size(ssize,max_sector,max_buffer_sectors*2) -
- fsector_t;
+ indirect =
+ transfer_size(ssize, max_sector,
+ max_buffer_sectors * 2) - fsector_t;
/*
* Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
* on a 64 bit machine!
*/
max_size = buffer_chain_size();
- dma_limit = (MAX_DMA_ADDRESS - ((unsigned long) current_req->buffer)) >> 9;
- if ((unsigned long) max_size > dma_limit) {
+ dma_limit =
+ (MAX_DMA_ADDRESS -
+ ((unsigned long)current_req->buffer)) >> 9;
+ if ((unsigned long)max_size > dma_limit) {
max_size = dma_limit;
}
/* 64 kb boundaries */
if (CROSS_64KB(current_req->buffer, max_size << 9))
- max_size = (K_64 -
- ((unsigned long)current_req->buffer) % K_64)>>9;
- direct = transfer_size(ssize,max_sector,max_size) - fsector_t;
+ max_size = (K_64 -
+ ((unsigned long)current_req->buffer) %
+ K_64) >> 9;
+ direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
/*
* We try to read tracks, but if we get too many errors, we
* go back to reading just one sector at a time.
@@ -2796,16 +2798,18 @@ static int make_raw_rw_request(void)
if (!direct ||
(indirect * 2 > direct * 3 &&
*errors < DP->max_errors.read_track &&
- /*!TESTF(FD_NEED_TWADDLE) &&*/
- ((!probing || (DP->read_track&(1<<DRS->probed_format)))))){
+ /*!TESTF(FD_NEED_TWADDLE) && */
+ ((!probing
+ || (DP->read_track & (1 << DRS->probed_format)))))) {
max_size = current_req->nr_sectors;
} else {
raw_cmd->kernel_data = current_req->buffer;
raw_cmd->length = current_count_sectors << 9;
- if (raw_cmd->length == 0){
- DPRINT("zero dma transfer attempted from make_raw_request\n");
+ if (raw_cmd->length == 0) {
+ DPRINT
+ ("zero dma transfer attempted from make_raw_request\n");
DPRINT("indirect=%d direct=%d fsector_t=%d",
- indirect, direct, fsector_t);
+ indirect, direct, fsector_t);
return 0;
}
/* check_dma_crossing(raw_cmd->kernel_data,
@@ -2818,26 +2822,27 @@ static int make_raw_rw_request(void)
}
if (CT(COMMAND) == FD_READ)
- max_size = max_sector; /* unbounded */
+ max_size = max_sector; /* unbounded */
/* claim buffer track if needed */
- if (buffer_track != raw_cmd->track || /* bad track */
- buffer_drive !=current_drive || /* bad drive */
+ if (buffer_track != raw_cmd->track || /* bad track */
+ buffer_drive != current_drive || /* bad drive */
fsector_t > buffer_max ||
fsector_t < buffer_min ||
((CT(COMMAND) == FD_READ ||
- (!in_sector_offset && current_req->nr_sectors >= ssize))&&
+ (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
max_sector > 2 * max_buffer_sectors + buffer_min &&
max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
- /* not enough space */){
+ /* not enough space */
+ ) {
buffer_track = -1;
buffer_drive = current_drive;
buffer_max = buffer_min = aligned_sector_t;
}
- raw_cmd->kernel_data = floppy_track_buffer +
- ((aligned_sector_t-buffer_min)<<9);
+ raw_cmd->kernel_data = floppy_track_buffer +
+ ((aligned_sector_t - buffer_min) << 9);
- if (CT(COMMAND) == FD_WRITE){
+ if (CT(COMMAND) == FD_WRITE) {
/* copy write buffer to track buffer.
* if we get here, we know that the write
* is either aligned or the data already in the buffer
@@ -2848,31 +2853,33 @@ static int make_raw_rw_request(void)
#endif
buffer_track = raw_cmd->track;
buffer_drive = current_drive;
- copy_buffer(ssize, max_sector, 2*max_buffer_sectors+buffer_min);
+ copy_buffer(ssize, max_sector,
+ 2 * max_buffer_sectors + buffer_min);
} else
transfer_size(ssize, max_sector,
- 2*max_buffer_sectors+buffer_min-aligned_sector_t);
+ 2 * max_buffer_sectors + buffer_min -
+ aligned_sector_t);
/* round up current_count_sectors to get dma xfer size */
- raw_cmd->length = in_sector_offset+current_count_sectors;
- raw_cmd->length = ((raw_cmd->length -1)|(ssize-1))+1;
+ raw_cmd->length = in_sector_offset + current_count_sectors;
+ raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
raw_cmd->length <<= 9;
#ifdef FLOPPY_SANITY_CHECK
/*check_dma_crossing(raw_cmd->kernel_data, raw_cmd->length,
- "end of make_raw_request");*/
+ "end of make_raw_request"); */
if ((raw_cmd->length < current_count_sectors << 9) ||
(raw_cmd->kernel_data != current_req->buffer &&
CT(COMMAND) == FD_WRITE &&
(aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
aligned_sector_t < buffer_min)) ||
raw_cmd->length % (128 << SIZECODE) ||
- raw_cmd->length <= 0 || current_count_sectors <= 0){
+ raw_cmd->length <= 0 || current_count_sectors <= 0) {
DPRINT("fractionary current count b=%lx s=%lx\n",
- raw_cmd->length, current_count_sectors);
+ raw_cmd->length, current_count_sectors);
if (raw_cmd->kernel_data != current_req->buffer)
printk("addr=%d, length=%ld\n",
- (int) ((raw_cmd->kernel_data -
- floppy_track_buffer) >> 9),
+ (int)((raw_cmd->kernel_data -
+ floppy_track_buffer) >> 9),
current_count_sectors);
printk("st=%d ast=%d mse=%d msi=%d\n",
fsector_t, aligned_sector_t, max_sector, max_size);
@@ -2886,16 +2893,15 @@ static int make_raw_rw_request(void)
return 0;
}
- if (raw_cmd->kernel_data != current_req->buffer){
+ if (raw_cmd->kernel_data != current_req->buffer) {
if (raw_cmd->kernel_data < floppy_track_buffer ||
current_count_sectors < 0 ||
raw_cmd->length < 0 ||
raw_cmd->kernel_data + raw_cmd->length >
- floppy_track_buffer + (max_buffer_sectors << 10)){
+ floppy_track_buffer + (max_buffer_sectors << 10)) {
DPRINT("buffer overrun in schedule dma\n");
printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
- fsector_t, buffer_min,
- raw_cmd->length >> 9);
+ fsector_t, buffer_min, raw_cmd->length >> 9);
printk("current_count_sectors=%ld\n",
current_count_sectors);
if (CT(COMMAND) == FD_READ)
@@ -2905,15 +2911,15 @@ static int make_raw_rw_request(void)
return 0;
}
} else if (raw_cmd->length > current_req->nr_sectors << 9 ||
- current_count_sectors > current_req->nr_sectors){
+ current_count_sectors > current_req->nr_sectors) {
DPRINT("buffer overrun in direct transfer\n");
return 0;
- } else if (raw_cmd->length < current_count_sectors << 9){
+ } else if (raw_cmd->length < current_count_sectors << 9) {
DPRINT("more sectors than bytes\n");
printk("bytes=%ld\n", raw_cmd->length >> 9);
printk("sectors=%ld\n", current_count_sectors);
}
- if (raw_cmd->length == 0){
+ if (raw_cmd->length == 0) {
DPRINT("zero dma transfer attempted from make_raw_request\n");
return 0;
}
@@ -2952,31 +2958,33 @@ static void redo_fd_request(void)
reschedule_timeout(current_reqD, "redo fd request", 0);
set_floppy(drive);
- raw_cmd = & default_raw_cmd;
+ raw_cmd = &default_raw_cmd;
raw_cmd->flags = 0;
- if (start_motor(redo_fd_request)) return;
+ if (start_motor(redo_fd_request))
+ return;
disk_change(current_drive);
if (test_bit(current_drive, &fake_change) ||
- TESTF(FD_DISK_CHANGED)){
+ TESTF(FD_DISK_CHANGED)) {
DPRINT("disk absent or changed during operation\n");
REPEAT;
}
- if (!_floppy) { /* Autodetection */
- if (!probing){
+ if (!_floppy) { /* Autodetection */
+ if (!probing) {
DRS->probed_format = 0;
- if (next_valid_format()){
+ if (next_valid_format()) {
DPRINT("no autodetectable formats\n");
_floppy = NULL;
REPEAT;
}
}
probing = 1;
- _floppy = floppy_type+DP->autodetect[DRS->probed_format];
+ _floppy =
+ floppy_type + DP->autodetect[DRS->probed_format];
} else
probing = 0;
- errors = & (current_req->errors);
+ errors = &(current_req->errors);
tmp = make_raw_rw_request();
- if (tmp < 2){
+ if (tmp < 2) {
request_done(tmp);
continue;
}
@@ -2993,10 +3001,10 @@ static void redo_fd_request(void)
}
static struct cont_t rw_cont = {
- .interrupt = rw_interrupt,
- .redo = redo_fd_request,
- .error = bad_flp_intr,
- .done = request_done
+ .interrupt = rw_interrupt,
+ .redo = redo_fd_request,
+ .error = bad_flp_intr,
+ .done = request_done
};
static void process_fd_request(void)
@@ -3007,14 +3015,16 @@ static void process_fd_request(void)
static void do_fd_request(request_queue_t * q)
{
- if(max_buffer_sectors == 0) {
+ if (max_buffer_sectors == 0) {
printk("VFS: do_fd_request called on non-open device\n");
return;
}
if (usage_count == 0) {
- printk("warning: usage count=0, current_req=%p exiting\n", current_req);
- printk("sect=%ld flags=%lx\n", (long)current_req->sector, current_req->flags);
+ printk("warning: usage count=0, current_req=%p exiting\n",
+ current_req);
+ printk("sect=%ld flags=%lx\n", (long)current_req->sector,
+ current_req->flags);
return;
}
if (test_bit(0, &fdc_busy)) {
@@ -3023,16 +3033,16 @@ static void do_fd_request(request_queue_
is_alive("do fd request, old request running");
return;
}
- lock_fdc(MAXTIMEOUT,0);
+ lock_fdc(MAXTIMEOUT, 0);
process_fd_request();
is_alive("do fd request");
}
static struct cont_t poll_cont = {
- .interrupt = success_and_wakeup,
- .redo = floppy_ready,
- .error = generic_failure,
- .done = generic_done
+ .interrupt = success_and_wakeup,
+ .redo = floppy_ready,
+ .error = generic_failure,
+ .done = generic_done
};
static int poll_drive(int interruptible, int flag)
@@ -3040,12 +3050,12 @@ static int poll_drive(int interruptible,
int ret;
/* no auto-sense, just clear dcl */
raw_cmd = &default_raw_cmd;
- raw_cmd->flags= flag;
- raw_cmd->track=0;
- raw_cmd->cmd_count=0;
+ raw_cmd->flags = flag;
+ raw_cmd->track = 0;
+ raw_cmd->cmd_count = 0;
cont = &poll_cont;
#ifdef DCL_DEBUG
- if (DP->flags & FD_DEBUG){
+ if (DP->flags & FD_DEBUG) {
DPRINT("setting NEWCHANGE in poll_drive\n");
}
#endif
@@ -3065,21 +3075,21 @@ static void reset_intr(void)
}
static struct cont_t reset_cont = {
- .interrupt = reset_intr,
- .redo = success_and_wakeup,
- .error = generic_failure,
- .done = generic_done
+ .interrupt = reset_intr,
+ .redo = success_and_wakeup,
+ .error = generic_failure,
+ .done = generic_done
};
static int user_reset_fdc(int drive, int arg, int interruptible)
{
int ret;
- ret=0;
- LOCK_FDC(drive,interruptible);
+ ret = 0;
+ LOCK_FDC(drive, interruptible);
if (arg == FD_RESET_ALWAYS)
- FDCS->reset=1;
- if (FDCS->reset){
+ FDCS->reset = 1;
+ if (FDCS->reset) {
cont = &reset_cont;
WAIT(reset_fdc);
}
@@ -3091,9 +3101,10 @@ static int user_reset_fdc(int drive, int
* Misc Ioctl's and support
* ========================
*/
-static inline int fd_copyout(void *param, const void *address, unsigned long size)
+static inline int fd_copyout(void *param, const void *address,
+ unsigned long size)
{
- return copy_to_user(param,address, size) ? -EFAULT : 0;
+ return copy_to_user(param, address, size) ? -EFAULT : 0;
}
static inline int fd_copyin(void *param, void *address, unsigned long size)
@@ -3125,7 +3136,6 @@ static inline const char *drive_name(int
return "(null)";
}
-
/* raw commands */
static void raw_cmd_done(int flag)
{
@@ -3137,18 +3147,17 @@ static void raw_cmd_done(int flag)
} else {
raw_cmd->reply_count = inr;
if (raw_cmd->reply_count > MAX_REPLIES)
- raw_cmd->reply_count=0;
- for (i=0; i< raw_cmd->reply_count; i++)
+ raw_cmd->reply_count = 0;
+ for (i = 0; i < raw_cmd->reply_count; i++)
raw_cmd->reply[i] = reply_buffer[i];
- if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE))
- {
+ if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
unsigned long flags;
- flags=claim_dma_lock();
+ flags = claim_dma_lock();
raw_cmd->length = fd_get_dma_residue();
release_dma_lock(flags);
}
-
+
if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
(!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
raw_cmd->flags |= FD_RAW_FAILURE;
@@ -3161,10 +3170,10 @@ static void raw_cmd_done(int flag)
motor_off_callback(current_drive);
if (raw_cmd->next &&
- (!(raw_cmd->flags & FD_RAW_FAILURE) ||
- !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
- ((raw_cmd->flags & FD_RAW_FAILURE) ||
- !(raw_cmd->flags &FD_RAW_STOP_IF_SUCCESS))) {
+ (!(raw_cmd->flags & FD_RAW_FAILURE) ||
+ !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
+ ((raw_cmd->flags & FD_RAW_FAILURE) ||
+ !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
raw_cmd = raw_cmd->next;
return;
}
@@ -3172,12 +3181,11 @@ static void raw_cmd_done(int flag)
generic_done(flag);
}
-
static struct cont_t raw_cmd_cont = {
- .interrupt = success_and_wakeup,
- .redo = floppy_start,
- .error = generic_failure,
- .done = raw_cmd_done
+ .interrupt = success_and_wakeup,
+ .redo = floppy_start,
+ .error = generic_failure,
+ .done = raw_cmd_done
};
static inline int raw_cmd_copyout(int cmd, char *param,
@@ -3185,29 +3193,28 @@ static inline int raw_cmd_copyout(int cm
{
int ret;
- while(ptr) {
+ while (ptr) {
COPYOUT(*ptr);
param += sizeof(struct floppy_raw_cmd);
- if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length){
- if (ptr->length>=0 && ptr->length<=ptr->buffer_length)
- ECALL(fd_copyout(ptr->data,
- ptr->kernel_data,
- ptr->buffer_length -
- ptr->length));
+ if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
+ if (ptr->length >= 0
+ && ptr->length <= ptr->buffer_length)
+ ECALL(fd_copyout
+ (ptr->data, ptr->kernel_data,
+ ptr->buffer_length - ptr->length));
}
ptr = ptr->next;
}
return 0;
}
-
static void raw_cmd_free(struct floppy_raw_cmd **ptr)
{
- struct floppy_raw_cmd *next,*this;
+ struct floppy_raw_cmd *next, *this;
this = *ptr;
*ptr = 0;
- while(this) {
+ while (this) {
if (this->buffer_length) {
fd_dma_mem_free((unsigned long)this->kernel_data,
this->buffer_length);
@@ -3219,18 +3226,17 @@ static void raw_cmd_free(struct floppy_r
}
}
-
static inline int raw_cmd_copyin(int cmd, char *param,
struct floppy_raw_cmd **rcmd)
{
struct floppy_raw_cmd *ptr;
int ret;
int i;
-
+
*rcmd = 0;
- while(1) {
- ptr = (struct floppy_raw_cmd *)
- kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
+ while (1) {
+ ptr = (struct floppy_raw_cmd *)
+ kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
if (!ptr)
return -ENOMEM;
*rcmd = ptr;
@@ -3249,7 +3255,7 @@ static inline int raw_cmd_copyin(int cmd
*/
return -EINVAL;
- for (i=0; i< 16; i++)
+ for (i = 0; i < 16; i++)
ptr->reply[i] = 0;
ptr->resultcode = 0;
ptr->kernel_data = 0;
@@ -3257,24 +3263,23 @@ static inline int raw_cmd_copyin(int cmd
if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
if (ptr->length <= 0)
return -EINVAL;
- ptr->kernel_data =(char*)fd_dma_mem_alloc(ptr->length);
- fallback_on_nodma_alloc(&ptr->kernel_data,
- ptr->length);
+ ptr->kernel_data =
+ (char *)fd_dma_mem_alloc(ptr->length);
+ fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
if (!ptr->kernel_data)
return -ENOMEM;
ptr->buffer_length = ptr->length;
}
if (ptr->flags & FD_RAW_WRITE)
- ECALL(fd_copyin(ptr->data, ptr->kernel_data,
+ ECALL(fd_copyin(ptr->data, ptr->kernel_data,
ptr->length));
- rcmd = & (ptr->next);
+ rcmd = &(ptr->next);
if (!(ptr->flags & FD_RAW_MORE))
return 0;
ptr->rate &= 0x43;
}
}
-
static int raw_cmd_ioctl(int cmd, void *param)
{
int drive, ret, ret2;
@@ -3282,15 +3287,15 @@ static int raw_cmd_ioctl(int cmd, void *
if (FDCS->rawcmd <= 1)
FDCS->rawcmd = 1;
- for (drive= 0; drive < N_DRIVE; drive++){
+ for (drive = 0; drive < N_DRIVE; drive++) {
if (FDC(drive) != fdc)
continue;
- if (drive == current_drive){
- if (UDRS->fd_ref > 1){
+ if (drive == current_drive) {
+ if (UDRS->fd_ref > 1) {
FDCS->rawcmd = 2;
break;
}
- } else if (UDRS->fd_ref){
+ } else if (UDRS->fd_ref) {
FDCS->rawcmd = 2;
break;
}
@@ -3307,9 +3312,9 @@ static int raw_cmd_ioctl(int cmd, void *
raw_cmd = my_raw_cmd;
cont = &raw_cmd_cont;
- ret=wait_til_done(floppy_start,1);
+ ret = wait_til_done(floppy_start, 1);
#ifdef DCL_DEBUG
- if (DP->flags & FD_DEBUG){
+ if (DP->flags & FD_DEBUG) {
DPRINT("calling disk change from raw_cmd ioctl\n");
}
#endif
@@ -3335,7 +3340,6 @@ static int invalidate_drive(struct block
return 0;
}
-
static inline void clear_write_error(int drive)
{
CLEARSTRUCT(UDRWE);
@@ -3346,24 +3350,23 @@ static inline int set_geometry(unsigned
{
int cnt;
- /* sanity checking for parameters.*/
+ /* sanity checking for parameters. */
if (g->sect <= 0 ||
g->head <= 0 ||
- g->track <= 0 ||
- g->track > UDP->tracks>>STRETCH(g) ||
+ g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
/* check if reserved bits are set */
- (g->stretch&~(FD_STRETCH|FD_SWAPSIDES|FD_ZEROBASED)) != 0)
+ (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_ZEROBASED)) != 0)
return -EINVAL;
- if (type){
+ if (type) {
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
down(&open_lock);
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
floppy_type[type] = *g;
- floppy_type[type].name="user format";
+ floppy_type[type].name = "user format";
for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
- floppy_sizes[cnt]= floppy_sizes[cnt+0x80]=
- floppy_type[type].size+1;
+ floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
+ floppy_type[type].size + 1;
process_fd_request();
for (cnt = 0; cnt < N_DRIVE; cnt++) {
struct block_device *bdev = opened_bdev[cnt];
@@ -3374,7 +3377,7 @@ static inline int set_geometry(unsigned
up(&open_lock);
} else {
int oldStretch;
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
if (cmd != FDDEFPRM)
/* notice a disk change immediately, else
* we lose our settings immediately*/
@@ -3406,7 +3409,7 @@ static inline int set_geometry(unsigned
}
/* handle obsolete ioctl's */
-static int ioctl_table[]= {
+static int ioctl_table[] = {
FDCLRPRM,
FDSETPRM,
FDDEFPRM,
@@ -3438,8 +3441,8 @@ static inline int normalize_ioctl(int *c
{
int i;
- for (i=0; i < ARRAY_SIZE(ioctl_table); i++) {
- if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)){
+ for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
+ if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
*size = _IOC_SIZE(*cmd);
*cmd = ioctl_table[i];
if (*size > _IOC_SIZE(*cmd)) {
@@ -3457,9 +3460,9 @@ static int get_floppy_geometry(int drive
if (type)
*g = &floppy_type[type];
else {
- LOCK_FDC(drive,0);
- CALL(poll_drive(0,0));
- process_fd_request();
+ LOCK_FDC(drive, 0);
+ CALL(poll_drive(0, 0));
+ process_fd_request();
*g = current_type[drive];
}
if (!*g)
@@ -3479,30 +3482,29 @@ static int fd_ioctl(struct inode *inode,
int ret;
int size;
union inparam {
- struct floppy_struct g; /* geometry */
+ struct floppy_struct g; /* geometry */
struct format_descr f;
struct floppy_max_errors max_errors;
struct floppy_drive_params dp;
- } inparam; /* parameters coming from user space */
- const char *outparam; /* parameters passed back to user space */
-
+ } inparam; /* parameters coming from user space */
+ const char *outparam; /* parameters passed back to user space */
/* convert compatibility eject ioctls into floppy eject ioctl.
* We do this in order to provide a means to eject floppy disks before
* installing the new fdutils package */
- if (cmd == CDROMEJECT || /* CD-ROM eject */
- cmd == 0x6470 /* SunOS floppy eject */) {
+ if (cmd == CDROMEJECT || /* CD-ROM eject */
+ cmd == 0x6470 /* SunOS floppy eject */ ) {
DPRINT("obsolete eject ioctl\n");
DPRINT("please use floppycontrol --eject\n");
cmd = FDEJECT;
}
/* generic block device ioctls */
- switch(cmd) {
+ switch (cmd) {
/* the following have been inspired by the corresponding
* code for other block devices. */
struct floppy_struct *g;
- case HDIO_GETGEO:
+ case HDIO_GETGEO:
{
struct hd_geometry loc;
ECALL(get_floppy_geometry(drive, type, &g));
@@ -3528,36 +3530,36 @@ static int fd_ioctl(struct inode *inode,
/* copyin */
CLEARSTRUCT(&inparam);
if (_IOC_DIR(cmd) & _IOC_WRITE)
- ECALL(fd_copyin((void *)param, &inparam, size))
+ ECALL(fd_copyin((void *)param, &inparam, size))
- switch (cmd) {
+ switch (cmd) {
case FDEJECT:
if (UDRS->fd_ref != 1)
/* somebody else has this drive open */
return -EBUSY;
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
/* do the actual eject. Fails on
* non-Sparc architectures */
- ret=fd_eject(UNIT(drive));
+ ret = fd_eject(UNIT(drive));
USETF(FD_DISK_CHANGED);
USETF(FD_VERIFY);
process_fd_request();
- return ret;
+ return ret;
case FDCLRPRM:
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
current_type[drive] = NULL;
floppy_sizes[drive] = MAX_DISK_SIZE << 1;
UDRS->keep_data = 0;
return invalidate_drive(inode->i_bdev);
case FDSETPRM:
case FDDEFPRM:
- return set_geometry(cmd, & inparam.g,
+ return set_geometry(cmd, &inparam.g,
drive, type, inode->i_bdev);
case FDGETPRM:
- ECALL(get_floppy_geometry(drive, type,
- (struct floppy_struct**)
+ ECALL(get_floppy_geometry(drive, type,
+ (struct floppy_struct **)
&outparam));
break;
@@ -3569,7 +3571,7 @@ static int fd_ioctl(struct inode *inode,
return 0;
case FDFMTBEG:
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
CALL(poll_drive(1, FD_RAW_NEED_DISK));
ret = UDRS->flags;
process_fd_request();
@@ -3584,59 +3586,59 @@ static int fd_ioctl(struct inode *inode,
return do_format(drive, &inparam.f);
case FDFMTEND:
case FDFLUSH:
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
return invalidate_drive(inode->i_bdev);
case FDSETEMSGTRESH:
UDP->max_errors.reporting =
- (unsigned short) (param & 0x0f);
+ (unsigned short)(param & 0x0f);
return 0;
- OUT(FDGETMAXERRS, &UDP->max_errors);
- IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
+ OUT(FDGETMAXERRS, &UDP->max_errors);
+ IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
case FDGETDRVTYP:
- outparam = drive_name(type,drive);
- SUPBOUND(size,strlen(outparam)+1);
+ outparam = drive_name(type, drive);
+ SUPBOUND(size, strlen(outparam) + 1);
break;
- IN(FDSETDRVPRM, UDP, dp);
- OUT(FDGETDRVPRM, UDP);
+ IN(FDSETDRVPRM, UDP, dp);
+ OUT(FDGETDRVPRM, UDP);
case FDPOLLDRVSTAT:
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
CALL(poll_drive(1, FD_RAW_NEED_DISK));
process_fd_request();
/* fall through */
- OUT(FDGETDRVSTAT, UDRS);
+ OUT(FDGETDRVSTAT, UDRS);
case FDRESET:
return user_reset_fdc(drive, (int)param, 1);
- OUT(FDGETFDCSTAT,UFDCS);
+ OUT(FDGETFDCSTAT, UFDCS);
case FDWERRORCLR:
CLEARSTRUCT(UDRWE);
return 0;
- OUT(FDWERRORGET,UDRWE);
+ OUT(FDWERRORGET, UDRWE);
case FDRAWCMD:
if (type)
return -EINVAL;
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
set_floppy(drive);
- CALL(i = raw_cmd_ioctl(cmd,(void *) param));
+ CALL(i = raw_cmd_ioctl(cmd, (void *)param));
process_fd_request();
return i;
case FDTWADDLE:
- LOCK_FDC(drive,1);
+ LOCK_FDC(drive, 1);
twaddle();
process_fd_request();
return 0;
default:
return -EINVAL;
- }
+ }
if (_IOC_DIR(cmd) & _IOC_READ)
return fd_copyout((void *)param, outparam, size);
@@ -3648,21 +3650,21 @@ static int fd_ioctl(struct inode *inode,
static void __init config_types(void)
{
- int first=1;
+ int first = 1;
int drive;
/* read drive info out of physical CMOS */
- drive=0;
+ drive = 0;
if (!UDP->cmos)
UDP->cmos = FLOPPY0_TYPE;
- drive=1;
+ drive = 1;
if (!UDP->cmos && FLOPPY1_TYPE)
UDP->cmos = FLOPPY1_TYPE;
/* XXX */
/* additional physical CMOS drive detection should go here */
- for (drive=0; drive < N_DRIVE; drive++){
+ for (drive = 0; drive < N_DRIVE; drive++) {
unsigned int type = UDP->cmos;
struct floppy_drive_params *params;
const char *name = NULL;
@@ -3673,8 +3675,7 @@ static void __init config_types(void)
if (type) {
name = default_drive_params[type].name;
allowed_drive_mask |= 1 << drive;
- }
- else
+ } else
allowed_drive_mask &= ~(1 << drive);
} else {
params = &default_drive_params[0].params;
@@ -3682,13 +3683,13 @@ static void __init config_types(void)
name = temparea;
}
if (name) {
- const char * prepend = ",";
+ const char *prepend = ",";
if (first) {
prepend = KERN_INFO "Floppy drive(s):";
first = 0;
}
printk("%s fd%d is %s", prepend, drive, name);
- register_devfs_entries (drive);
+ register_devfs_entries(drive);
}
*UDP = *params;
}
@@ -3696,13 +3697,13 @@ static void __init config_types(void)
printk("\n");
}
-static int floppy_release(struct inode * inode, struct file * filp)
+static int floppy_release(struct inode *inode, struct file *filp)
{
int drive = (long)inode->i_bdev->bd_disk->private_data;
down(&open_lock);
if (UDRS->fd_ref < 0)
- UDRS->fd_ref=0;
+ UDRS->fd_ref = 0;
else if (!UDRS->fd_ref--) {
DPRINT("floppy_release with fd_ref == 0");
UDRS->fd_ref = 0;
@@ -3719,7 +3720,7 @@ static int floppy_release(struct inode *
* /dev/PS0 etc), and disallows simultaneous access to the same
* drive with different device numbers.
*/
-static int floppy_open(struct inode * inode, struct file * filp)
+static int floppy_open(struct inode *inode, struct file *filp)
{
int drive = (long)inode->i_bdev->bd_disk->private_data;
int old_dev;
@@ -3727,19 +3728,18 @@ static int floppy_open(struct inode * in
int res = -EBUSY;
char *tmp;
- filp->private_data = (void*) 0;
+ filp->private_data = (void *)0;
down(&open_lock);
old_dev = UDRS->fd_device;
if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
goto out2;
- if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)){
+ if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
USETF(FD_DISK_CHANGED);
USETF(FD_VERIFY);
}
- if (UDRS->fd_ref == -1 ||
- (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
+ if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
goto out2;
if (floppy_grab_irq_and_dma())
@@ -3754,19 +3754,19 @@ static int floppy_open(struct inode * in
res = -ENXIO;
- if (!floppy_track_buffer){
+ 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))
- try = 64; /* Only 48 actually useful */
+ try = 64; /* Only 48 actually useful */
else
- try = 32; /* Only 24 actually useful */
+ try = 32; /* Only 24 actually useful */
- tmp=(char *)fd_dma_mem_alloc(1024 * try);
+ tmp = (char *)fd_dma_mem_alloc(1024 * try);
if (!tmp && !floppy_track_buffer) {
- try >>= 1; /* buffer only one side */
+ try >>= 1; /* buffer only one side */
INFBOUND(try, 16);
- tmp= (char *)fd_dma_mem_alloc(1024*try);
+ tmp = (char *)fd_dma_mem_alloc(1024 * try);
}
if (!tmp && !floppy_track_buffer) {
fallback_on_nodma_alloc(&tmp, 2048 * try);
@@ -3777,7 +3777,7 @@ static int floppy_open(struct inode * in
}
if (floppy_track_buffer) {
if (tmp)
- fd_dma_mem_free((unsigned long)tmp,try*1024);
+ fd_dma_mem_free((unsigned long)tmp, try * 1024);
} else {
buffer_min = buffer_max = -1;
floppy_track_buffer = tmp;
@@ -3795,8 +3795,9 @@ static int floppy_open(struct inode * in
/* Allow ioctls if we have write-permissions even if read-only open.
* Needed so that programs such as fdrawcmd still can work on write
* protected disks */
- if (filp->f_mode & 2 || permission(filp->f_dentry->d_inode,2,NULL) == 0)
- filp->private_data = (void*) 8;
+ if (filp->f_mode & 2
+ || permission(filp->f_dentry->d_inode, 2, NULL) == 0)
+ filp->private_data = (void *)8;
if (UFDCS->rawcmd == 1)
UFDCS->rawcmd = 2;
@@ -3816,7 +3817,7 @@ static int floppy_open(struct inode * in
return 0;
out:
if (UDRS->fd_ref < 0)
- UDRS->fd_ref=0;
+ UDRS->fd_ref = 0;
else
UDRS->fd_ref--;
if (!UDRS->fd_ref)
@@ -3838,20 +3839,20 @@ static int check_floppy_change(struct ge
return 1;
if (UDP->checkfreq < (int)(jiffies - UDRS->last_checked)) {
- if(floppy_grab_irq_and_dma()) {
+ if (floppy_grab_irq_and_dma()) {
return 1;
}
- lock_fdc(drive,0);
- poll_drive(0,0);
+ lock_fdc(drive, 0);
+ poll_drive(0, 0);
process_fd_request();
floppy_release_irq_and_dma();
}
if (UTESTF(FD_DISK_CHANGED) ||
- UTESTF(FD_VERIFY) ||
- test_bit(drive, &fake_change) ||
- (!ITYPE(UDRS->fd_device) && !current_type[drive]))
+ UTESTF(FD_VERIFY) ||
+ test_bit(drive, &fake_change) ||
+ (!ITYPE(UDRS->fd_device) && !current_type[drive]))
return 1;
return 0;
}
@@ -3862,12 +3863,13 @@ static int check_floppy_change(struct ge
* a disk in the drive, and whether that disk is writable.
*/
-static int floppy_rb0_complete(struct bio *bio, unsigned int bytes_done, int err)
+static int floppy_rb0_complete(struct bio *bio, unsigned int bytes_done,
+ int err)
{
if (bio->bi_size)
return 1;
- complete((struct completion*)bio->bi_private);
+ complete((struct completion *)bio->bi_private);
return 0;
}
@@ -3919,23 +3921,21 @@ static int __floppy_read_block_0(struct
* geometry formats */
static int floppy_revalidate(struct gendisk *disk)
{
- int drive=(long)disk->private_data;
+ int drive = (long)disk->private_data;
#define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
int cf;
int res = 0;
if (UTESTF(FD_DISK_CHANGED) ||
- UTESTF(FD_VERIFY) ||
- test_bit(drive, &fake_change) ||
- NO_GEOM){
- if(usage_count == 0) {
+ UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
+ if (usage_count == 0) {
printk("VFS: revalidate called on non-open device.\n");
return -EFAULT;
}
- lock_fdc(drive,0);
+ lock_fdc(drive, 0);
cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
- if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)){
- process_fd_request(); /*already done by another thread*/
+ if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
+ process_fd_request(); /*already done by another thread */
return 0;
}
UDRS->maxblock = 0;
@@ -3946,7 +3946,7 @@ static int floppy_revalidate(struct gend
UCLEARF(FD_DISK_CHANGED);
if (cf)
UDRS->generation++;
- if (NO_GEOM){
+ if (NO_GEOM) {
/* auto-sensing */
res = __floppy_read_block_0(opened_bdev[drive]);
} else {
@@ -3965,22 +3965,24 @@ static struct block_device_operations fl
.release = floppy_release,
.ioctl = fd_ioctl,
.media_changed = check_floppy_change,
- .revalidate_disk= floppy_revalidate,
+ .revalidate_disk = floppy_revalidate,
};
-static char *table[] =
-{"", "d360", "h1200", "u360", "u720", "h360", "h720",
-"u1440", "u2880", "CompaQ", "h1440", "u1680", "h410",
-"u820", "h1476", "u1722", "h420", "u830", "h1494", "u1743",
-"h880", "u1040", "u1120", "h1600", "u1760", "u1920",
-"u3200", "u3520", "u3840", "u1840", "u800", "u1600",
-NULL
+static char *table[] = {
+ "", "d360", "h1200", "u360", "u720", "h360", "h720",
+ "u1440", "u2880", "CompaQ", "h1440", "u1680", "h410",
+ "u820", "h1476", "u1722", "h420", "u830", "h1494", "u1743",
+ "h880", "u1040", "u1120", "h1600", "u1760", "u1920",
+ "u3200", "u3520", "u3840", "u1840", "u800", "u1600",
+ NULL
};
-static int t360[] = {1,0}, t1200[] = {2,5,6,10,12,14,16,18,20,23,0},
-t3in[] = {8,9,26,27,28, 7,11,15,19,24,25,29,31, 3,4,13,17,21,22,30,0};
-static int *table_sup[] =
-{NULL, t360, t1200, t3in+5+8, t3in+5, t3in, t3in};
+static int t360[] = { 1, 0 },
+ t1200[] = { 2, 5, 6, 10, 12, 14, 16, 18, 20, 23, 0 },
+ t3in[] = { 8, 9, 26, 27, 28, 7, 11, 15, 19, 24, 25, 29, 31, 3, 4, 13,
+ 17, 21, 22, 30, 0 };
+static int *table_sup[] =
+ { NULL, t360, t1200, t3in + 5 + 8, t3in + 5, t3in, t3in };
-static void __init register_devfs_entries (int drive)
+static void __init register_devfs_entries(int drive)
{
int base_minor = (drive < 4) ? drive : (124 + drive);
@@ -3989,10 +3991,10 @@ static void __init register_devfs_entrie
do {
int minor = base_minor + (table_sup[UDP->cmos][i] << 2);
- devfs_mk_bdev(MKDEV(FLOPPY_MAJOR, minor),
- S_IFBLK|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP,
- "floppy/%d%s",
- drive, table[table_sup[UDP->cmos][i]]);
+ devfs_mk_bdev(MKDEV(FLOPPY_MAJOR, minor),
+ S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP |
+ S_IWGRP, "floppy/%d%s", drive,
+ table[table_sup[UDP->cmos][i]]);
} while (table_sup[UDP->cmos][i++]);
}
}
@@ -4013,19 +4015,20 @@ static char __init get_fdc_version(void)
return FDC_NONE;
if ((r = result()) <= 0x00)
return FDC_NONE; /* No FDC present ??? */
- if ((r==1) && (reply_buffer[0] == 0x80)){
- printk(KERN_INFO "FDC %d is an 8272A\n",fdc);
+ if ((r == 1) && (reply_buffer[0] == 0x80)) {
+ printk(KERN_INFO "FDC %d is an 8272A\n", fdc);
return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
}
if (r != 10) {
- printk("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
- fdc, r);
+ printk
+ ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
+ fdc, r);
return FDC_UNKNOWN;
}
if (!fdc_configure()) {
- printk(KERN_INFO "FDC %d is an 82072\n",fdc);
- return FDC_82072; /* 82072 doesn't know CONFIGURE */
+ printk(KERN_INFO "FDC %d is an 82072\n", fdc);
+ return FDC_82072; /* 82072 doesn't know CONFIGURE */
}
output_byte(FD_PERPENDICULAR);
@@ -4038,7 +4041,7 @@ static char __init get_fdc_version(void)
output_byte(FD_UNLOCK);
r = result();
- if ((r == 1) && (reply_buffer[0] == 0x80)){
+ if ((r == 1) && (reply_buffer[0] == 0x80)) {
printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
* LOCK/UNLOCK */
@@ -4056,37 +4059,39 @@ static char __init get_fdc_version(void)
return FDC_UNKNOWN;
}
if (reply_buffer[0] == 0x80) {
- printk(KERN_INFO "FDC %d is a post-1991 82077\n",fdc);
+ printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);
return FDC_82077; /* Revised 82077AA passes all the tests */
}
switch (reply_buffer[0] >> 5) {
- case 0x0:
- /* Either a 82078-1 or a 82078SL running at 5Volt */
- printk(KERN_INFO "FDC %d is an 82078.\n",fdc);
- return FDC_82078;
- case 0x1:
- printk(KERN_INFO "FDC %d is a 44pin 82078\n",fdc);
- return FDC_82078;
- case 0x2:
- printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
- return FDC_S82078B;
- case 0x3:
- printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n", fdc);
- return FDC_87306;
- default:
- printk(KERN_INFO "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
- fdc, reply_buffer[0] >> 5);
- return FDC_82078_UNKN;
+ case 0x0:
+ /* Either a 82078-1 or a 82078SL running at 5Volt */
+ printk(KERN_INFO "FDC %d is an 82078.\n", fdc);
+ return FDC_82078;
+ case 0x1:
+ printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);
+ return FDC_82078;
+ case 0x2:
+ printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
+ return FDC_S82078B;
+ case 0x3:
+ printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",
+ fdc);
+ return FDC_87306;
+ default:
+ printk(KERN_INFO
+ "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
+ fdc, reply_buffer[0] >> 5);
+ return FDC_82078_UNKN;
}
-} /* get_fdc_version */
+} /* get_fdc_version */
/* lilo configuration */
-static void __init floppy_set_flags(int *ints,int param, int param2)
+static void __init floppy_set_flags(int *ints, int param, int param2)
{
int i;
- for (i=0; i < ARRAY_SIZE(default_drive_params); i++){
+ for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
if (param)
default_drive_params[i].params.flags |= param2;
else
@@ -4095,17 +4100,20 @@ static void __init floppy_set_flags(int
DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
}
-static void __init daring(int *ints,int param, int param2)
+static void __init daring(int *ints, int param, int param2)
{
int i;
- for (i=0; i < ARRAY_SIZE(default_drive_params); i++){
- if (param){
+ for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
+ if (param) {
default_drive_params[i].params.select_delay = 0;
- default_drive_params[i].params.flags |= FD_SILENT_DCL_CLEAR;
+ default_drive_params[i].params.flags |=
+ FD_SILENT_DCL_CLEAR;
} else {
- default_drive_params[i].params.select_delay = 2*HZ/100;
- default_drive_params[i].params.flags &= ~FD_SILENT_DCL_CLEAR;
+ default_drive_params[i].params.select_delay =
+ 2 * HZ / 100;
+ default_drive_params[i].params.flags &=
+ ~FD_SILENT_DCL_CLEAR;
}
}
DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
@@ -4113,14 +4121,14 @@ static void __init daring(int *ints,int
static void __init set_cmos(int *ints, int dummy, int dummy2)
{
- int current_drive=0;
+ int current_drive = 0;
- if (ints[0] != 2){
+ if (ints[0] != 2) {
DPRINT("wrong number of parameters for CMOS\n");
return;
}
current_drive = ints[1];
- if (current_drive < 0 || current_drive >= 8){
+ if (current_drive < 0 || current_drive >= 8) {
DPRINT("bad drive for set_cmos\n");
return;
}
@@ -4134,43 +4142,37 @@ static void __init set_cmos(int *ints, i
static struct param_table {
const char *name;
- void (*fn)(int *ints, int param, int param2);
+ void (*fn) (int *ints, int param, int param2);
int *var;
int def_param;
int param2;
-} config_params[]={
- { "allowed_drive_mask", 0, &allowed_drive_mask, 0xff, 0}, /* obsolete */
- { "all_drives", 0, &allowed_drive_mask, 0xff, 0 }, /* obsolete */
- { "asus_pci", 0, &allowed_drive_mask, 0x33, 0},
-
- { "irq", 0, &FLOPPY_IRQ, 6, 0 },
- { "dma", 0, &FLOPPY_DMA, 2, 0 },
-
- { "daring", daring, 0, 1, 0},
+} config_params[] = {
+ {"allowed_drive_mask", 0, &allowed_drive_mask, 0xff, 0}, /* obsolete */
+ {"all_drives", 0, &allowed_drive_mask, 0xff, 0}, /* obsolete */
+ {"asus_pci", 0, &allowed_drive_mask, 0x33, 0},
+ {"irq", 0, &FLOPPY_IRQ, 6, 0},
+ {"dma", 0, &FLOPPY_DMA, 2, 0},
+ {"daring", daring, 0, 1, 0},
#if N_FDC > 1
- { "two_fdc", 0, &FDC2, 0x370, 0 },
- { "one_fdc", 0, &FDC2, 0, 0 },
+ {"two_fdc", 0, &FDC2, 0x370, 0},
+ {"one_fdc", 0, &FDC2, 0, 0},
#endif
- { "thinkpad", floppy_set_flags, 0, 1, FD_INVERTED_DCL },
- { "broken_dcl", floppy_set_flags, 0, 1, FD_BROKEN_DCL },
- { "messages", floppy_set_flags, 0, 1, FTD_MSG },
- { "silent_dcl_clear", floppy_set_flags, 0, 1, FD_SILENT_DCL_CLEAR },
- { "debug", floppy_set_flags, 0, 1, FD_DEBUG },
-
- { "nodma", 0, &can_use_virtual_dma, 1, 0 },
- { "omnibook", 0, &can_use_virtual_dma, 1, 0 },
- { "yesdma", 0, &can_use_virtual_dma, 0, 0 },
-
- { "fifo_depth", 0, &fifo_depth, 0xa, 0 },
- { "nofifo", 0, &no_fifo, 0x20, 0 },
- { "usefifo", 0, &no_fifo, 0, 0 },
-
- { "cmos", set_cmos, 0, 0, 0 },
- { "slow", 0, &slow_floppy, 1, 0 },
-
- { "unexpected_interrupts", 0, &print_unex, 1, 0 },
- { "no_unexpected_interrupts", 0, &print_unex, 0, 0 },
- { "L40SX", 0, &print_unex, 0, 0 }
+ {"thinkpad", floppy_set_flags, 0, 1, FD_INVERTED_DCL},
+ {"broken_dcl", floppy_set_flags, 0, 1, FD_BROKEN_DCL},
+ {"messages", floppy_set_flags, 0, 1, FTD_MSG},
+ {"silent_dcl_clear", floppy_set_flags, 0, 1, FD_SILENT_DCL_CLEAR},
+ {"debug", floppy_set_flags, 0, 1, FD_DEBUG},
+ {"nodma", 0, &can_use_virtual_dma, 1, 0},
+ {"omnibook", 0, &can_use_virtual_dma, 1, 0},
+ {"yesdma", 0, &can_use_virtual_dma, 0, 0},
+ {"fifo_depth", 0, &fifo_depth, 0xa, 0},
+ {"nofifo", 0, &no_fifo, 0x20, 0},
+ {"usefifo", 0, &no_fifo, 0, 0},
+ {"cmos", set_cmos, 0, 0, 0},
+ {"slow", 0, &slow_floppy, 1, 0},
+ {"unexpected_interrupts", 0, &print_unex, 1, 0},
+ {"no_unexpected_interrupts", 0, &print_unex, 0, 0},
+ {"L40SX", 0, &print_unex, 0, 0}
EXTRA_FLOPPY_PARAMS
};
@@ -4181,18 +4183,18 @@ static int __init floppy_setup(char *str
int param;
int ints[11];
- str = get_options(str,ARRAY_SIZE(ints),ints);
+ str = get_options(str, ARRAY_SIZE(ints), ints);
if (str) {
- for (i=0; i< ARRAY_SIZE(config_params); i++){
- if (strcmp(str,config_params[i].name) == 0){
+ for (i = 0; i < ARRAY_SIZE(config_params); i++) {
+ if (strcmp(str, config_params[i].name) == 0) {
if (ints[0])
param = ints[1];
else
param = config_params[i].def_param;
if (config_params[i].fn)
config_params[i].
- fn(ints,param,
- config_params[i].param2);
+ fn(ints, param,
+ config_params[i].param2);
if (config_params[i].var) {
DPRINT("%s=%d\n", str, param);
*config_params[i].var = param;
@@ -4203,10 +4205,10 @@ static int __init floppy_setup(char *str
}
if (str) {
DPRINT("unknown floppy option [%s]\n", str);
-
+
DPRINT("allowed options are:");
- for (i=0; i< ARRAY_SIZE(config_params); i++)
- printk(" %s",config_params[i].name);
+ for (i = 0; i < ARRAY_SIZE(config_params); i++)
+ printk(" %s", config_params[i].name);
printk("\n");
} else
DPRINT("botched floppy option\n");
@@ -4214,7 +4216,7 @@ static int __init floppy_setup(char *str
return 0;
}
-static int have_no_fdc= -ENODEV;
+static int have_no_fdc = -ENODEV;
static void floppy_device_release(struct device *dev)
{
@@ -4226,12 +4228,12 @@ static struct platform_device floppy_dev
.id = 0,
.dev = {
.release = floppy_device_release,
- }
+ }
};
static struct kobject *floppy_find(dev_t dev, int *part, void *data)
{
- int drive = (*part&3) | ((*part&0x80) >> 5);
+ int drive = (*part & 3) | ((*part & 0x80) >> 5);
if (drive >= N_DRIVE ||
!(allowed_drive_mask & (1 << drive)) ||
fdc_state[FDC(drive)].version == FDC_NONE)
@@ -4244,12 +4246,12 @@ static struct kobject *floppy_find(dev_t
int __init floppy_init(void)
{
- int i,unit,drive;
+ int i, unit, drive;
int err;
raw_cmd = NULL;
- for (i=0; i<N_DRIVE; i++) {
+ for (i = 0; i < N_DRIVE; i++) {
disks[i] = alloc_disk(1);
if (!disks[i])
goto Enomem;
@@ -4264,8 +4266,8 @@ int __init floppy_init(void)
motor_off_timer[i].function = motor_off_callback;
}
- devfs_mk_dir ("floppy");
- if ((err = register_blkdev(FLOPPY_MAJOR,"fd")))
+ devfs_mk_dir("floppy");
+ if ((err = register_blkdev(FLOPPY_MAJOR, "fd")))
goto out;
floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
@@ -4276,9 +4278,9 @@ int __init floppy_init(void)
}
blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
- floppy_find, NULL, NULL);
+ floppy_find, NULL, NULL);
- for (i=0; i<256; i++)
+ for (i = 0; i < 256; i++)
if (ITYPE(i))
floppy_sizes[i] = floppy_type[ITYPE(i)].size;
else
@@ -4293,11 +4295,11 @@ int __init floppy_init(void)
FDCS->dtr = -1;
FDCS->dor = 0x4;
#if defined(__sparc__) || defined(__mc68000__)
- /*sparcs/sun3x don't have a DOR reset which we can fall back on to*/
+ /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
#ifdef __mc68000__
if (MACH_IS_SUN3X)
#endif
- FDCS->version = FDC_82072A;
+ FDCS->version = FDC_82072A;
#endif
}
@@ -4311,8 +4313,8 @@ int __init floppy_init(void)
fdc_state[1].address = FDC2;
#endif
- fdc = 0; /* reset fdc in case of unexpected interrupt */
- if (floppy_grab_irq_and_dma()){
+ fdc = 0; /* reset fdc in case of unexpected interrupt */
+ if (floppy_grab_irq_and_dma()) {
err = -EBUSY;
goto out1;
}
@@ -4332,25 +4334,25 @@ int __init floppy_init(void)
for (i = 0; i < N_FDC; i++) {
fdc = i;
FDCS->driver_version = FD_DRIVER_VERSION;
- for (unit=0; unit<4; unit++)
+ for (unit = 0; unit < 4; unit++)
FDCS->track[unit] = 0;
if (FDCS->address == -1)
continue;
FDCS->rawcmd = 2;
- if (user_reset_fdc(-1,FD_RESET_ALWAYS,0)){
- /* free ioports reserved by floppy_grab_irq_and_dma() */
- release_region(FDCS->address+2, 4);
- release_region(FDCS->address+7, 1);
+ if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
+ /* free ioports reserved by floppy_grab_irq_and_dma() */
+ release_region(FDCS->address + 2, 4);
+ release_region(FDCS->address + 7, 1);
FDCS->address = -1;
FDCS->version = FDC_NONE;
continue;
}
/* Try to determine the floppy controller type */
FDCS->version = get_fdc_version();
- if (FDCS->version == FDC_NONE){
- /* free ioports reserved by floppy_grab_irq_and_dma() */
- release_region(FDCS->address+2, 4);
- release_region(FDCS->address+7, 1);
+ if (FDCS->version == FDC_NONE) {
+ /* free ioports reserved by floppy_grab_irq_and_dma() */
+ release_region(FDCS->address + 2, 4);
+ release_region(FDCS->address + 7, 1);
FDCS->address = -1;
continue;
}
@@ -4362,13 +4364,13 @@ int __init floppy_init(void)
* properly, so force a reset for the standard FDC clones,
* to avoid interrupt garbage.
*/
- user_reset_fdc(-1,FD_RESET_ALWAYS,0);
+ user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
}
- fdc=0;
+ fdc = 0;
del_timer(&fd_timeout);
current_drive = 0;
floppy_release_irq_and_dma();
- initialising=0;
+ initialising = 0;
if (have_no_fdc) {
DPRINT("no floppy controllers found\n");
flush_scheduled_work();
@@ -4377,14 +4379,14 @@ int __init floppy_init(void)
err = have_no_fdc;
goto out2;
}
-
+
for (drive = 0; drive < N_DRIVE; drive++) {
if (!(allowed_drive_mask & (1 << drive)))
continue;
if (fdc_state[FDC(drive)].version == FDC_NONE)
continue;
/* to be cleaned up... */
- disks[drive]->private_data = (void*)(long)drive;
+ disks[drive]->private_data = (void *)(long)drive;
disks[drive]->queue = floppy_queue;
disks[drive]->flags |= GENHD_FL_REMOVABLE;
add_disk(disks[drive]);
@@ -4399,9 +4401,9 @@ out2:
blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
blk_cleanup_queue(floppy_queue);
fail_queue:
- unregister_blkdev(FLOPPY_MAJOR,"fd");
+ unregister_blkdev(FLOPPY_MAJOR, "fd");
out:
- for (i=0; i<N_DRIVE; i++)
+ for (i = 0; i < N_DRIVE; i++)
put_disk(disks[i]);
devfs_remove("floppy");
return err;
@@ -4419,14 +4421,14 @@ static int floppy_grab_irq_and_dma(void)
unsigned long flags;
spin_lock_irqsave(&floppy_usage_lock, flags);
- if (usage_count++){
+ if (usage_count++) {
spin_unlock_irqrestore(&floppy_usage_lock, flags);
return 0;
}
spin_unlock_irqrestore(&floppy_usage_lock, flags);
if (fd_request_irq()) {
DPRINT("Unable to grab IRQ%d for the floppy driver\n",
- FLOPPY_IRQ);
+ FLOPPY_IRQ);
spin_lock_irqsave(&floppy_usage_lock, flags);
usage_count--;
spin_unlock_irqrestore(&floppy_usage_lock, flags);
@@ -4434,7 +4436,7 @@ static int floppy_grab_irq_and_dma(void)
}
if (fd_request_dma()) {
DPRINT("Unable to grab DMA%d for the floppy driver\n",
- FLOPPY_DMA);
+ FLOPPY_DMA);
fd_free_irq();
spin_lock_irqsave(&floppy_usage_lock, flags);
usage_count--;
@@ -4442,35 +4444,37 @@ static int floppy_grab_irq_and_dma(void)
return -1;
}
- for (fdc=0; fdc< N_FDC; fdc++){
- if (FDCS->address != -1){
- if (!request_region(FDCS->address+2, 4, "floppy")) {
- DPRINT("Floppy io-port 0x%04lx in use\n", FDCS->address + 2);
+ for (fdc = 0; fdc < N_FDC; fdc++) {
+ if (FDCS->address != -1) {
+ if (!request_region(FDCS->address + 2, 4, "floppy")) {
+ DPRINT("Floppy io-port 0x%04lx in use\n",
+ FDCS->address + 2);
goto cleanup1;
}
- if (!request_region(FDCS->address+7, 1, "floppy DIR")) {
- DPRINT("Floppy io-port 0x%04lx in use\n", FDCS->address + 7);
+ if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
+ DPRINT("Floppy io-port 0x%04lx in use\n",
+ FDCS->address + 7);
goto cleanup2;
}
/* address + 6 is reserved, and may be taken by IDE.
* Unfortunately, Adaptec doesn't know this :-(, */
}
}
- for (fdc=0; fdc< N_FDC; fdc++){
- if (FDCS->address != -1){
+ for (fdc = 0; fdc < N_FDC; fdc++) {
+ if (FDCS->address != -1) {
reset_fdc_info(1);
fd_outb(FDCS->dor, FD_DOR);
}
}
fdc = 0;
- set_dor(0, ~0, 8); /* avoid immediate interrupt */
+ set_dor(0, ~0, 8); /* avoid immediate interrupt */
for (fdc = 0; fdc < N_FDC; fdc++)
if (FDCS->address != -1)
fd_outb(FDCS->dor, FD_DOR);
/*
- * The driver will try and free resources and relies on us
- * to know if they were allocated or not.
+ * The driver will try and free resources and relies on us
+ * to know if they were allocated or not.
*/
fdc = 0;
irqdma_allocated = 1;
@@ -4480,7 +4484,7 @@ cleanup2:
cleanup1:
fd_free_irq();
fd_free_dma();
- while(--fdc >= 0) {
+ while (--fdc >= 0) {
release_region(FDCS->address + 2, 4);
release_region(FDCS->address + 7, 1);
}
@@ -4503,17 +4507,16 @@ static void floppy_release_irq_and_dma(v
unsigned long flags;
spin_lock_irqsave(&floppy_usage_lock, flags);
- if (--usage_count){
+ if (--usage_count) {
spin_unlock_irqrestore(&floppy_usage_lock, flags);
return;
}
spin_unlock_irqrestore(&floppy_usage_lock, flags);
- if(irqdma_allocated)
- {
+ if (irqdma_allocated) {
fd_disable_dma();
fd_free_dma();
fd_free_irq();
- irqdma_allocated=0;
+ irqdma_allocated = 0;
}
set_dor(0, ~0, 8);
#if N_FDC > 1
@@ -4522,17 +4525,16 @@ static void floppy_release_irq_and_dma(v
floppy_enable_hlt();
if (floppy_track_buffer && max_buffer_sectors) {
- tmpsize = max_buffer_sectors*1024;
+ tmpsize = max_buffer_sectors * 1024;
tmpaddr = (unsigned long)floppy_track_buffer;
floppy_track_buffer = NULL;
max_buffer_sectors = 0;
buffer_min = buffer_max = -1;
fd_dma_mem_free(tmpaddr, tmpsize);
}
-
#ifdef FLOPPY_SANITY_CHECK
#ifndef __sparc__
- for (drive=0; drive < N_FDC * 4; drive++)
+ for (drive = 0; drive < N_FDC * 4; drive++)
if (timer_pending(motor_off_timer + drive))
printk("motor off timer %d still active\n", drive);
#endif
@@ -4547,35 +4549,35 @@ static void floppy_release_irq_and_dma(v
old_fdc = fdc;
for (fdc = 0; fdc < N_FDC; fdc++)
if (FDCS->address != -1) {
- release_region(FDCS->address+2, 4);
- release_region(FDCS->address+7, 1);
+ release_region(FDCS->address + 2, 4);
+ release_region(FDCS->address + 7, 1);
}
fdc = old_fdc;
}
-
#ifdef MODULE
char *floppy;
-static void unregister_devfs_entries (int drive)
+static void unregister_devfs_entries(int drive)
{
- int i;
+ int i;
- if (UDP->cmos < NUMBER(default_drive_params)) {
- i = 0;
- do {
- devfs_remove("floppy/%d%s", drive, table[table_sup[UDP->cmos][i]]);
- } while (table_sup[UDP->cmos][i++]);
- }
+ if (UDP->cmos < NUMBER(default_drive_params)) {
+ i = 0;
+ do {
+ devfs_remove("floppy/%d%s", drive,
+ table[table_sup[UDP->cmos][i]]);
+ } while (table_sup[UDP->cmos][i++]);
+ }
}
static void __init parse_floppy_cfg_string(char *cfg)
{
char *ptr;
- while(*cfg) {
- for(ptr = cfg;*cfg && *cfg != ' ' && *cfg != '\t'; cfg++);
+ while (*cfg) {
+ for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != '\t'; cfg++) ;
if (*cfg) {
*cfg = '\0';
cfg++;
@@ -4588,7 +4590,7 @@ static void __init parse_floppy_cfg_stri
int init_module(void)
{
printk(KERN_INFO "inserting floppy driver for " UTS_RELEASE "\n");
-
+
if (floppy)
parse_floppy_cfg_string(floppy);
return floppy_init();
@@ -4628,16 +4630,16 @@ void cleanup_module(void)
wait_for_completion(&device_release);
}
-MODULE_PARM(floppy,"s");
-MODULE_PARM(FLOPPY_IRQ,"i");
-MODULE_PARM(FLOPPY_DMA,"i");
+MODULE_PARM(floppy, "s");
+MODULE_PARM(FLOPPY_IRQ, "i");
+MODULE_PARM(FLOPPY_DMA, "i");
MODULE_AUTHOR("Alain L. Knaff");
MODULE_SUPPORTED_DEVICE("fd");
MODULE_LICENSE("GPL");
#else
-__setup ("floppy=", floppy_setup);
+__setup("floppy=", floppy_setup);
module_init(floppy_init)
#endif
_