From: "Randy.Dunlap" --- 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 #include #include @@ -163,7 +163,6 @@ static int print_unex=1; * 1998/1/21 -- Richard Gooch -- devfs support */ - #include #include @@ -174,13 +173,13 @@ static int print_unex=1; #include #include #include -#include /* CMOS defines */ +#include /* CMOS defines */ #include #include #include #include #include -#include /* for invalidate_buffers() */ +#include /* for invalidate_buffers() */ /* * PS/2 floppies have much slower step rates than regular floppies. @@ -195,9 +194,9 @@ static int slow_floppy; #include #include -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 #include -#include /* for the compatibility eject ioctl */ +#include /* for the compatibility eject ioctl */ #include 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<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= 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; ireset = 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<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; idtr = -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; iaddress != -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 _