// SPDX-License-Identifier: GPL-2.0-only /* * linux / drivers / block / floppy . c * * Copyright ( C ) 1991 , 1992 Linus Torvalds * Copyright ( C ) 1993 , 1994 Alain Knaff * Copyright ( C ) 1998 Alan Cox /* * 02 . 12 . 91 - Changed to static variables to indicate need for reset * and recalibrate . This makes some things easier ( output_byte reset * checking etc ) , and means less interrupt jumping in case of errors , * so the code is hopefully easier to understand . /* * This file is certainly a mess . I ' ve tried my best to get it working , * but I don ' t like programming floppies , and I have only one anyway . * Urgel . I should check for more errors , and do more graceful error * recovery . Seems there are problems with several drives . I ' ve tried to * correct them . No promises . /* * As with hd . c , all routines within this file can ( and will ) be called * by interrupts , so extreme caution is needed . A hardware interrupt * handler may not sleep , or a kernel panic will happen . Thus I cannot * call " floppy - on " directly , but have to set a special timer interrupt * etc . /* * 28 . 02 . 92 - made track - buffering routines , based on the routines written * by entropy @ wintermute . wpi . edu ( Lawrence Foard ) . Linus . /* * Automatic floppy - detection and formatting written by Werner Almesberger * ( almesber @ nessie . cs . id . ethz . ch ) , who also corrected some problems with * the floppy - change signal detection . /* * 1992 / 7 / 22 - - Hennus Bergman : Added better error reporting , fixed * FDC data overrun bug , added some preliminary stuff for vertical * recording support . * * 1992 / 9 / 17 : Added DMA allocation & DMA functions . - - hhb . * * TODO : Errors are still not counted properly . /* 1992/9/20 * Modifications for ` ` Sector Shifting ' ' by Rob Hooft ( hooft @ chem . ruu . nl ) * modeled after the freeware MS - DOS program fdformat / 88 V1 . 8 by * Christoph H . Hochst \ " atter . * I have fixed the shift values to the ones I always use . Maybe a new * ioctl ( ) should be created to be able to modify them . * There is a bug in the driver that makes it impossible to format a * floppy as the first thing after bootup . /* * 1993 / 4 / 29 - - Linus - - cleaned up the timer handling in the kernel , and * this helped the floppy driver as well . Much cleaner , and still seems to * work . /* 1994/6/24 --bbroad-- added the floppy table entries and made * minor modifications to allow 2 . 88 floppies to be run . /* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more * disk types . /* * 1994 / 8 / 8 - - Alain Knaff - - Switched to fdpatch driver : Support for bigger * format bug fixes , but unfortunately some new bugs too . . . /* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write * errors to allow safe writing by specialized programs . /* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks * by defining bit 1 of the " stretch " parameter to mean put sectors on the * opposite side of the disk , leaving the sector IDs alone ( i . e . Commodore ' s * drives are " upside - down " ) . /* * 1995 / 8 / 26 - - Andreas Busse - - added Mips support . /* * 1995 / 10 / 18 - - Ralf Baechle - - Portability cleanup ; move machine dependent * features to asm / floppy . h . /* * 1998 / 1 / 21 - - Richard Gooch < rgooch @ atnf . csiro . au > - - devfs support /* * 1998 / 05 / 07 - - Russell King - - More portability cleanups ; moved definition of * 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 . /* * 1998 / 09 / 20 - - David Weinehall - - Added slow - down code for buggy PS / 2 - drives . /* * 1999 / 08 / 13 - - Paul Slootman - - floppy stopped working on Alpha after 24 * days , 6 hours , 32 minutes and 32 seconds ( i . e . MAXINT jiffies ; ints were * being used to store jiffies , which are unsigned longs ) . /* * 2000 / 08 / 28 - - Arnaldo Carvalho de Melo < acme @ conectiva . com . br > * - get rid of check_region * - s / suser / capable / /* * 2001 / 08 / 26 - - Paul Gortmaker - fix insmod oops on machines with no * floppy controller ( lingering task on list after module is gone . . . boom . ) /* * 2002 / 02 / 07 - - Anton Altaparmakov - Fix io ports reservation to correct range * ( 0 x3f2 - 0 x3f5 , 0 x3f7 ) . This fix is a bit of a hack but the proper fix * requires many non - obvious changes in arch dependent code . /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>. * Better audit of register_blkdev . #define REALLY_SLOW_IO#define DEBUGT 2 #define DPRINT(format, args...) \"floppy%d: " format, current_drive, ## args)#define DCL_DEBUG /* debug disk change line */ #ifdef DCL_DEBUG#define debug_dcl(test, fmt, args...) \do { if ((test) & FD_DEBUG) DPRINT(fmt, ## args); } while (0 )#else #define debug_dcl(test, fmt, args...) \do { if (0 ) DPRINT(fmt, ## args); } while (0 )#endif /* do print messages for unexpected interrupts */ static int print_unex = 1 ;#include <linux/module.h>#include <linux/sched.h>#include <linux/fs.h>#include <linux/kernel.h>#include <linux/timer.h>#include <linux/workqueue.h>#include <linux/fdreg.h>#include <linux/fd.h>#include <linux/hdreg.h>#include <linux/errno.h>#include <linux/slab.h>#include <linux/mm.h>#include <linux/bio.h>#include <linux/string.h>#include <linux/jiffies.h>#include <linux/fcntl.h>#include <linux/delay.h>#include <linux/mc146818rtc.h> /* CMOS defines */ #include <linux/ioport.h>#include <linux/interrupt.h>#include <linux/init.h>#include <linux/major.h>#include <linux/platform_device.h>#include <linux/mod_devicetable.h>#include <linux/mutex.h>#include <linux/io.h>#include <linux/uaccess.h>#include <linux/async.h>#include <linux/compat.h>/* * PS / 2 floppies have much slower step rates than regular floppies . * It ' s been recommended that take about 1 / 4 of the default speed * in some more extreme cases . static DEFINE_MUTEX(floppy_mutex);static int slow_floppy;#include <asm /dma.h>#include <asm /irq.h>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 * 1 = use of virtual DMA prescribed by config * 2 = no virtual DMA preference configured . By default try hard DMA , * but fall back on virtual DMA when not enough memory available static int use_virtual_dma;/* ======= * use virtual DMA * 0 using hard DMA * 1 using virtual DMA * This variable is set to virtual when a DMA mem problem arises , and * reset back in floppy_grab_irq_and_dma . * It is not safe to reset it in other circumstances , because the floppy * driver may have several buffers in use at once , and we do currently not * record each buffers capabilities static DEFINE_SPINLOCK(floppy_lock);static unsigned short virtual_dma_port = 0 x3f0;int irq, void *dev_id);static int set_dor(int fdc, char mask, char data);#define K_64 0 x10000 /* 64KB */ /* the following is the mask of allowed drives. By default units 2 and * 3 of both floppy controllers are disabled , because switching on the * motor of these drives causes system hangs on some PCI computers . drive * 0 is the low bit ( 0 x1 ) , and drive 7 is the high bit ( 0 x80 ) . Bits are on if * a drive is allowed . * * NOTE : This must come before we include the arch floppy header because * some ports reference this variable from there . - DaveM static int allowed_drive_mask = 0 x33;#include <asm /floppy.h>static int irqdma_allocated;#include <linux/blk-mq.h>#include <linux/blkpg.h>#include <linux/cdrom.h> /* for the compatibility eject ioctl */ #include <linux/completion.h>static LIST_HEAD(floppy_reqs);static struct request *current_req;static int set_next_request(void );#ifndef fd_get_dma_residue#define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)#endif /* Dma Memory related stuff */ #ifndef fd_dma_mem_free#define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))#endif #ifndef fd_dma_mem_alloc#define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL, get_order(size))#endif #ifndef fd_cacheflush#define fd_cacheflush(addr, size) /* nothing... */ #endif static inline void fallback_on_nodma_alloc(char **addr, size_t l)#ifdef FLOPPY_CAN_FALLBACK_ON_NODMAif (*addr)return ; /* we have the memory */ if (can_use_virtual_dma != 2 )return ; /* no fallback allowed */ "DMA memory shortage. Temporarily falling back on virtual DMA\n" );char *)nodma_mem_alloc(l);#else return ;#endif /* End dma memory related stuff */ static unsigned long fake_change;static bool initialized;#define ITYPE(x) (((x) >> 2 ) & 0 x1f)#define TOMINOR(x) ((x & 3 ) | ((x & 4 ) << 5 ))#define UNIT(x) ((x) & 0 x03) /* drive on fdc */ #define FDC(x) (((x) & 0 x04) >> 2 ) /* fdc of drive */ /* reverse mapping from unit and fdc to drive */ #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2 ))#define PH_HEAD(floppy, head) (((((floppy)->stretch & 2 ) >> 1 ) ^ head) << 2 )#define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)/* read/write commands */ #define COMMAND 0 #define DR_SELECT 1 #define TRACK 2 #define HEAD 3 #define SECTOR 4 #define SIZECODE 5 #define SECT_PER_TRACK 6 #define GAP 7 #define SIZECODE2 8 #define NR_RW 9 /* format commands */ #define F_SIZECODE 2 #define F_SECT_PER_TRACK 3 #define F_GAP 4 #define F_FILL 5 #define NR_F 6 /* * Maximum disk size ( in kilobytes ) . * This default is used whenever the current disk size is unknown . * [ Now it is rather a minimum ] #define MAX_DISK_SIZE 4 /* 3984 */ /* * globals used by ' result ( ) ' static unsigned char reply_buffer[FD_RAW_REPLY_SIZE];static int inr; /* size of reply buffer, when called from interrupt */ #define ST0 0 #define ST1 1 #define ST2 2 #define ST3 0 /* result of GETSTATUS */ #define R_TRACK 3 #define R_HEAD 4 #define R_SECTOR 5 #define R_SIZECODE 6 #define SEL_DLY (2 * HZ / 100 )/* * this struct defines the different floppy drive types . static struct {struct floppy_drive_params params;const char *name; /* name printed while booting */ /* NOTE: the time values in jiffies should be in msec! CMOS drive type | Maximum data rate supported by drive type | | Head load time , msec | | | Head unload time , msec ( not used ) | | | | Step rate interval , usec | | | | | Time needed for spinup time ( jiffies ) | | | | | | Timeout for spinning down ( jiffies ) | | | | | | | Spindown offset ( where disk stops ) | | | | | | | | Select delay | | | | | | | | | RPS | | | | | | | | | | Max number of tracks | | | | | | | | | | | Interrupt timeout | | | | | | | | | | | | Max nonintlv . sectors 0 , 500 , 16 , 16 , 8000 , 1 *HZ, 3 *HZ, 0 , SEL_DLY, 5 , 80 , 3 *HZ, 20 , {3 ,1 ,2 ,0 ,2 }, 0 ,0 , { 7 , 4 , 8 , 2 , 1 , 5 , 3 ,10 }, 3 *HZ/2 , 0 }, "unknown" },1 , 300 , 16 , 16 , 8000 , 1 *HZ, 3 *HZ, 0 , SEL_DLY, 5 , 40 , 3 *HZ, 17 , {3 ,1 ,2 ,0 ,2 }, 0 ,0 , { 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 }, 3 *HZ/2 , 1 }, "360K PC" }, /*5 1/4 360 KB PC*/ 2 , 500 , 16 , 16 , 6000 , 4 *HZ/10 , 3 *HZ, 14 , SEL_DLY, 6 , 83 , 3 *HZ, 17 , {3 ,1 ,2 ,0 ,2 }, 0 ,0 , { 2 , 5 , 6 ,23 ,10 ,20 ,12 , 0 }, 3 *HZ/2 , 2 }, "1.2M" }, /*5 1/4 HD AT*/ 3 , 250 , 16 , 16 , 3000 , 1 *HZ, 3 *HZ, 0 , SEL_DLY, 5 , 83 , 3 *HZ, 20 , {3 ,1 ,2 ,0 ,2 }, 0 ,0 , { 4 ,22 ,21 ,30 , 3 , 0 , 0 , 0 }, 3 *HZ/2 , 4 }, "720k" }, /*3 1/2 DD*/ 4 , 500 , 16 , 16 , 4000 , 4 *HZ/10 , 3 *HZ, 10 , SEL_DLY, 5 , 83 , 3 *HZ, 20 , {3 ,1 ,2 ,0 ,2 }, 0 ,0 , { 7 , 4 ,25 ,22 ,31 ,21 ,29 ,11 }, 3 *HZ/2 , 7 }, "1.44M" }, /*3 1/2 HD*/ 5 , 1000 , 15 , 8 , 3000 , 4 *HZ/10 , 3 *HZ, 10 , SEL_DLY, 5 , 83 , 3 *HZ, 40 , {3 ,1 ,2 ,0 ,2 }, 0 ,0 , { 7 , 8 , 4 ,25 ,28 ,22 ,31 ,21 }, 3 *HZ/2 , 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/ 6 , 1000 , 15 , 8 , 3000 , 4 *HZ/10 , 3 *HZ, 10 , SEL_DLY, 5 , 83 , 3 *HZ, 40 , {3 ,1 ,2 ,0 ,2 }, 0 ,0 , { 7 , 8 , 4 ,25 ,28 ,22 ,31 ,21 }, 3 *HZ/2 , 8 }, "2.88M" } /*3 1/2 ED*/ /* | --autodetected formats--- | | | * read_track | | Name printed when booting * | Native format static struct floppy_drive_params drive_params[N_DRIVE];static struct floppy_drive_struct drive_state[N_DRIVE];static struct floppy_write_errors write_errors[N_DRIVE];static struct timer_list motor_off_timer[N_DRIVE];static struct blk_mq_tag_set tag_sets[N_DRIVE];static struct gendisk *opened_disk[N_DRIVE];static DEFINE_MUTEX(open_lock);static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;/* * This struct defines the different floppy types . * * Bit 0 of ' stretch ' tells if the tracks need to be doubled for some * types ( e . g . 360 kB diskette in 1 . 2 MB drive , etc . ) . Bit 1 of ' stretch ' * tells if the disk is in Commodore 1581 format , which means side 0 sectors * are located on side 1 of the disk but with a side 0 ID , and vice - versa . * This is the same as the Sharp MZ - 80 5 . 25 " CP / M disk format , except that the * 1581 ' s logical side 0 is on physical side 1 , whereas the Sharp ' s logical * side 0 is on physical side 0 ( but with the misnamed sector IDs ) . * ' stretch ' should probably be renamed to something more general , like * ' options ' . * * Bits 2 through 9 of ' stretch ' tell the number of the first sector . * The LSB ( bit 2 ) is flipped . For most disks , the first sector * is 1 ( represented by 0 x00 < < 2 ) . For some CP / M and music sampler * disks ( such as Ensoniq EPS 16 plus ) it is 0 ( represented as 0 x01 < < 2 ) . * For Amstrad CPC disks it is 0 xC1 ( represented as 0 xC0 < < 2 ) . * * Other parameters should be self - explanatory ( see also setfdprm ( 8 ) ) . /* Size | Sectors per track | | Head | | | Tracks | | | | Stretch | | | | | Gap 1 size | | | | | | Data rate , | 0 x40 for perp | | | | | | | Spec1 ( stepping rate , head unload static struct floppy_struct floppy_type[32 ] = {0 , 0 ,0 , 0 ,0 ,0 x00,0 x00,0 x00,0 x00,NULL }, /* 0 no testing */ 720 , 9 ,2 ,40 ,0 ,0 x2A,0 x02,0 xDF,0 x50,"d360" }, /* 1 360KB PC */ 2400 ,15 ,2 ,80 ,0 ,0 x1B,0 x00,0 xDF,0 x54,"h1200" }, /* 2 1.2MB AT */ 720 , 9 ,1 ,80 ,0 ,0 x2A,0 x02,0 xDF,0 x50,"D360" }, /* 3 360KB SS 3.5" */ 1440 , 9 ,2 ,80 ,0 ,0 x2A,0 x02,0 xDF,0 x50,"D720" }, /* 4 720KB 3.5" */ 720 , 9 ,2 ,40 ,1 ,0 x23,0 x01,0 xDF,0 x50,"h360" }, /* 5 360KB AT */ 1440 , 9 ,2 ,80 ,0 ,0 x23,0 x01,0 xDF,0 x50,"h720" }, /* 6 720KB AT */ 2880 ,18 ,2 ,80 ,0 ,0 x1B,0 x00,0 xCF,0 x6C,"H1440" }, /* 7 1.44MB 3.5" */ 5760 ,36 ,2 ,80 ,0 ,0 x1B,0 x43,0 xAF,0 x54,"E2880" }, /* 8 2.88MB 3.5" */ 6240 ,39 ,2 ,80 ,0 ,0 x1B,0 x43,0 xAF,0 x28,"E3120" }, /* 9 3.12MB 3.5" */ 2880 ,18 ,2 ,80 ,0 ,0 x25,0 x00,0 xDF,0 x02,"h1440" }, /* 10 1.44MB 5.25" */ 3360 ,21 ,2 ,80 ,0 ,0 x1C,0 x00,0 xCF,0 x0C,"H1680" }, /* 11 1.68MB 3.5" */ 820 ,10 ,2 ,41 ,1 ,0 x25,0 x01,0 xDF,0 x2E,"h410" }, /* 12 410KB 5.25" */ 1640 ,10 ,2 ,82 ,0 ,0 x25,0 x02,0 xDF,0 x2E,"H820" }, /* 13 820KB 3.5" */ 2952 ,18 ,2 ,82 ,0 ,0 x25,0 x00,0 xDF,0 x02,"h1476" }, /* 14 1.48MB 5.25" */ 3444 ,21 ,2 ,82 ,0 ,0 x25,0 x00,0 xDF,0 x0C,"H1722" }, /* 15 1.72MB 3.5" */ 840 ,10 ,2 ,42 ,1 ,0 x25,0 x01,0 xDF,0 x2E,"h420" }, /* 16 420KB 5.25" */ 1660 ,10 ,2 ,83 ,0 ,0 x25,0 x02,0 xDF,0 x2E,"H830" }, /* 17 830KB 3.5" */ 2988 ,18 ,2 ,83 ,0 ,0 x25,0 x00,0 xDF,0 x02,"h1494" }, /* 18 1.49MB 5.25" */ 3486 ,21 ,2 ,83 ,0 ,0 x25,0 x00,0 xDF,0 x0C,"H1743" }, /* 19 1.74 MB 3.5" */ 1760 ,11 ,2 ,80 ,0 ,0 x1C,0 x09,0 xCF,0 x00,"h880" }, /* 20 880KB 5.25" */ 2080 ,13 ,2 ,80 ,0 ,0 x1C,0 x01,0 xCF,0 x00,"D1040" }, /* 21 1.04MB 3.5" */ 2240 ,14 ,2 ,80 ,0 ,0 x1C,0 x19,0 xCF,0 x00,"D1120" }, /* 22 1.12MB 3.5" */ 3200 ,20 ,2 ,80 ,0 ,0 x1C,0 x20,0 xCF,0 x2C,"h1600" }, /* 23 1.6MB 5.25" */ 3520 ,22 ,2 ,80 ,0 ,0 x1C,0 x08,0 xCF,0 x2e,"H1760" }, /* 24 1.76MB 3.5" */ 3840 ,24 ,2 ,80 ,0 ,0 x1C,0 x20,0 xCF,0 x00,"H1920" }, /* 25 1.92MB 3.5" */ 6400 ,40 ,2 ,80 ,0 ,0 x25,0 x5B,0 xCF,0 x00,"E3200" }, /* 26 3.20MB 3.5" */ 7040 ,44 ,2 ,80 ,0 ,0 x25,0 x5B,0 xCF,0 x00,"E3520" }, /* 27 3.52MB 3.5" */ 7680 ,48 ,2 ,80 ,0 ,0 x25,0 x63,0 xCF,0 x00,"E3840" }, /* 28 3.84MB 3.5" */ 3680 ,23 ,2 ,80 ,0 ,0 x1C,0 x10,0 xCF,0 x00,"H1840" }, /* 29 1.84MB 3.5" */ 1600 ,10 ,2 ,80 ,0 ,0 x25,0 x02,0 xDF,0 x2E,"D800" }, /* 30 800KB 3.5" */ 3200 ,20 ,2 ,80 ,0 ,0 x1C,0 x00,0 xCF,0 x2C,"H1600" }, /* 31 1.6MB 3.5" */ static struct gendisk *disks[N_DRIVE][ARRAY_SIZE(floppy_type)];#define SECTSIZE (_FD_SECTSIZE(*floppy))/* Auto-detection: Disk type used until the next media change occurs. */ static struct floppy_struct *current_type[N_DRIVE];/* * User - provided type information . current_type points to * the respective entry of this array . static struct floppy_struct user_params[N_DRIVE];static sector_t floppy_sizes[256 ];static char floppy_device_name[] = "floppy" ;/* * The driver is trying to determine the correct media format * while probing is set . rw_interrupt ( ) clears it after a * successful access . static int probing;/* Synchronization of FDC access. */ #define FD_COMMAND_NONE -1 #define FD_COMMAND_ERROR 2 #define FD_COMMAND_OKAY 3 static volatile int command_status = FD_COMMAND_NONE;static unsigned long fdc_busy;static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);static DECLARE_WAIT_QUEUE_HEAD(command_done);/* errors encountered on the current (or last) request */ static int floppy_errors;/* Format request descriptor. */ static struct format_descr format_req;/* * Rate is 0 for 500 kb / s , 1 for 300 kbps , 2 for 250 kbps * Spec1 is 0 xSH , where S is stepping rate ( F = 1 ms , E = 2 ms , D = 3 ms etc ) , * H is head unload time ( 1 = 16 ms , 2 = 32 ms , etc ) /* * Track buffer * Because these are written to by the DMA controller , they must * not contain a 64 k byte boundary crossing , or data will be * corrupted / lost . static char *floppy_track_buffer;static int max_buffer_sectors;static const struct cont_t {void (*interrupt)(void );/* this is called after the interrupt of the void (*redo)(void ); /* this is called to retry the operation */ void (*error)(void ); /* this is called to tally an error */ void (*done)(int ); /* this is called to say if the operation has static void floppy_ready(void );static void floppy_start(void );static void process_fd_request(void );static void recalibrate_floppy(void );static void floppy_shutdown(struct work_struct *);static int floppy_request_regions(int );static void floppy_release_regions(int );static int floppy_grab_irq_and_dma(void );static void floppy_release_irq_and_dma(void );/* * The " reset " variable should be tested whenever an interrupt is scheduled , * after the commands have been sent . This is to ensure that the driver doesn ' t * get wedged when the interrupt doesn ' t come because of a failed command . * reset doesn ' t need to be tested before sending commands , because * output_byte is automatically disabled when reset is set . static void reset_fdc(void );static int floppy_revalidate(struct gendisk *disk);/* * These are global variables , as that ' s the easiest way to give * information to interrupts . They are the data used for the current * request . #define NO_TRACK -1 #define NEED_1_RECAL -2 #define NEED_2_RECAL -3 static atomic_t usage_count = ATOMIC_INIT(0 );/* buffer related variables */ static int buffer_track = -1 ;static int buffer_drive = -1 ;static int buffer_min = -1 ;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 current_fdc; /* current fdc */ static struct workqueue_struct *floppy_wq;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 in_sector_offset; /* offset within physical sector, static inline unsigned char fdc_inb(int fdc, int reg)return fd_inb(fdc_state[fdc].address, reg);static inline void fdc_outb(unsigned char value, int fdc, int reg)static inline bool drive_no_geom(int drive)return !current_type[drive] && !ITYPE(drive_state[drive].fd_device);#ifndef fd_ejectstatic inline int fd_eject(int drive)return -EINVAL;#endif /* * Debugging * = = = = = = = = = #ifdef DEBUGTstatic long unsigned debugtimer;static inline void set_debugt(void )static inline void debugt(const char *func, const char *msg)if (drive_params[current_drive].flags & DEBUGT)"%s:%s dtime=%lu\n" , func, msg, jiffies - debugtimer);#else static inline void set_debugt(void ) { }static inline void debugt(const char *func, const char *msg) { }#endif /* DEBUGT */ static DECLARE_DELAYED_WORK(fd_timeout, floppy_shutdown);static const char *timeout_message;static void is_alive(const char *func, const char *message)/* this routine checks whether the floppy driver is "alive" */ if (test_bit(0 , &fdc_busy) && command_status < 2 &&"%s: timeout handler died. %s\n" , func, message);static void (*do_floppy)(void ) = NULL;#define OLOGSIZE 20 static void (*lasthandler)(void );static unsigned long interruptjiffies;static unsigned long resultjiffies;static int resultsize;static unsigned long lastredo;static struct output_log {unsigned char data;unsigned char status;unsigned long jiffies;static int output_log_pos;#define MAXTIMEOUT -2 static void __reschedule_timeout(int drive, const char *message)unsigned long delay;if (drive < 0 || drive >= N_DRIVE) {20 UL * HZ;0 ;else if (drive_params[drive].flags & FD_DEBUG)"reschedule timeout %s\n" , message);static void reschedule_timeout(int drive, const char *message)unsigned long flags;#define INFBOUND(a, b) (a) = max_t(int , a, b)#define SUPBOUND(a, b) (a) = min_t(int , a, b)/* * Bottom half floppy driver . * = = = = = = = = = = = = = = = = = = = = = = = = = = * * This part of the file contains the code talking directly to the hardware , * and also the main service loop ( seek - configure - spinup - command ) /* * disk change . * This routine is responsible for maintaining the FD_DISK_CHANGE flag , * and the last_checked date . * * last_checked is the date of the last check which showed ' no disk change ' * FD_DISK_CHANGE is set under two conditions : * 1 . The floppy has been changed after some i / o to that floppy already * took place . * 2 . No floppy disk is in the drive . This is done in order to ensure that * requests are quickly flushed in case there is no disk in the drive . It * follows that FD_DISK_CHANGE can only be cleared if there is a disk in * the drive . * * For 1 . , maxblock is observed . Maxblock is 0 if no i / o has taken place yet . * For 2 . , FD_DISK_NEWCHANGE is watched . FD_DISK_NEWCHANGE is cleared on * each seek . If a disk is present , the disk change line should also be * cleared on each seek . Thus , if FD_DISK_NEWCHANGE is clear , but the disk * change line is set , this means either that no disk is in the drive , or * that it has been removed since the last seek . * * This means that we really have a third possibility too : * The floppy has been changed after the last seek . static int disk_change(int drive)int fdc = FDC(drive);if (time_before(jiffies, drive_state[drive].select_date + drive_params[drive].select_delay))"WARNING disk change called early\n" );if (!(fdc_state[fdc].dor & (0 x10 << UNIT(drive))) ||3 ) != UNIT(drive) || fdc != FDC(drive)) {"probing disk change on unselected drive\n" );"drive=%d fdc=%d dor=%x\n" , drive, FDC(drive),unsigned int )fdc_state[fdc].dor);"checking disk change line for drive %d\n" , drive);"jiffies=%lu\n" , jiffies);"disk change line=%x\n" ,0 x80);"flags=%lx\n" ,if (drive_params[drive].flags & FD_BROKEN_DCL)return test_bit(FD_DISK_CHANGED_BIT,if ((fdc_inb(fdc, FD_DIR) ^ drive_params[drive].flags) & 0 x80) {/* verify write protection */ if (drive_state[drive].maxblock) /* mark it changed */ /* invalidate its geometry */ if (drive_state[drive].keep_data >= 0 ) {if ((drive_params[drive].flags & FTD_MSG) &&"Disk type is undefined after disk change\n" );1 ;return 1 ;else {return 0 ;static inline int is_selected(int dor, int unit)return ((dor & (0 x10 << unit)) && (dor & 3 ) == unit);static bool is_ready_state(int status)int state = status & (STATUS_READY | STATUS_DIR | STATUS_DMA);return state == STATUS_READY;static int set_dor(int fdc, char mask, char data)unsigned char unit;unsigned char drive;unsigned char newdor;unsigned char olddor;if (fdc_state[fdc].address == -1 )return -1 ;if (newdor != olddor) {0 x3;if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {"calling disk change from set_dor\n" );0 x3;if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {return olddor;static void twaddle(int fdc, int drive)if (drive_params[drive].select_delay)return ;0 x10 << UNIT(drive)),/* * Reset all driver information about the specified fdc . * This is needed after a reset , and after a raw command . static void reset_fdc_info(int fdc, int mode)int drive;1 ;1 ;1 ;0 ;for (drive = 0 ; drive < N_DRIVE; drive++)if (FDC(drive) == fdc &&/* * selects the fdc and drive , and enables the fdc ' s input / dma . * Both current_drive and current_fdc are changed to match the new drive . static void set_fdc(int drive)unsigned int fdc;if (drive < 0 || drive >= N_DRIVE) {"bad drive value %d\n" , drive);return ;if (fdc >= N_FDC) {"bad fdc value\n" );return ;0 , 8 );#if N_FDC > 1 1 - fdc, ~8 , 0 );#endif if (fdc_state[fdc].rawcmd == 2 )1 );if (fdc_inb(fdc, FD_STATUS) != STATUS_READY)1 ;/* * locks the driver . * Both current_drive and current_fdc are changed to match the new drive . static int lock_fdc(int drive)if (WARN(atomic_read(&usage_count) == 0 ,"Trying to lock fdc while usage count=0\n" ))return -1 ;if (wait_event_interruptible(fdc_wait, !test_and_set_bit(0 , &fdc_busy)))return -EINTR;"lock fdc" );return 0 ;/* unlocks the driver */ static void unlock_fdc(void )if (!test_bit(0 , &fdc_busy))"FDC access conflict!\n" );0 , &fdc_busy);/* switches the motor off after a given timeout */ static void motor_off_callback(struct timer_list *t)unsigned long nr = t - motor_off_timer;unsigned char mask = ~(0 x10 << UNIT(nr));if (WARN_ON_ONCE(nr >= N_DRIVE))return ;0 );/* schedules motor off */ static void floppy_off(unsigned int drive)unsigned long volatile delta;int fdc = FDC(drive);if (!(fdc_state[fdc].dor & (0 x10 << UNIT(drive))))return ;/* make spindle stop in a position which minimizes spinup time if (drive_params[drive].rps) {/* * cycle through all N_DRIVE floppy drives , for disk change testing . * stopping at current drive . This is done before any long operation , to * be sure to have up to date disk change information . static void scandrives(void )int i;int drive;int saved_drive;if (drive_params[current_drive].select_delay)return ;for (i = 0 ; i < N_DRIVE; i++) {1 ) % N_DRIVE;if (drive_state[drive].fd_ref == 0 || drive_params[drive].select_delay != 0 )continue ; /* skip closed drives */ if (!(set_dor(current_fdc, ~3 , UNIT(drive) | (0 x10 << UNIT(drive))) &0 x10 << UNIT(drive))))/* switch the motor off again, if it was off to 0 x10 << UNIT(drive)), 0 );static void empty(void )static void empty_done(int result)static void (*floppy_work_fn)(void );static void floppy_work_workfn(struct work_struct *work)static DECLARE_WORK(floppy_work, floppy_work_workfn);static void schedule_bh(void (*handler)(void ))static void (*fd_timer_fn)(void ) = NULL;static void fd_timer_workfn(struct work_struct *work)static DECLARE_DELAYED_WORK(fd_timer, fd_timer_workfn);static void cancel_activity(void )/* this function makes sure that the disk stays in the drive during the static void fd_watchdog(void )"calling disk change from watchdog\n" );if (disk_change(current_drive)) {"disk removed during i/o\n" );0 );else {10 );static void main_command_interrupt(void )/* waits for a delay (spinup or select) to pass */ static int fd_wait_for_completion(unsigned long expires,void (*function)(void ))if (fdc_state[current_fdc].reset) {/* do the reset during sleep to win time * if we don ' t need to sleep , it ' s a good return 1 ;if (time_before(jiffies, expires)) {return 1 ;return 0 ;static void setup_DMA(void )unsigned long f;if (raw_cmd->length == 0 ) {"zero dma transfer size: " ,16 , 1 ,false );0 );1 ;return ;if (((unsigned long )raw_cmd->kernel_data) % 512 ) {"non aligned address: %p\n" , raw_cmd->kernel_data);0 );1 ;return ;#ifdef fd_dma_setupif (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,0 ) {0 );1 ;return ;#else #endif static void show_floppy(int fdc);/* waits until the fdc becomes ready */ static int wait_til_ready(int fdc)int status;int counter;if (fdc_state[fdc].reset)return -1 ;for (counter = 0 ; counter < 10000 ; counter++) {if (status & STATUS_READY)return status;if (initialized) {"Getstatus times out (%x) on fdc %d\n" , status, fdc);1 ;return -1 ;/* sends a command byte to the fdc */ static int output_byte(int fdc, char byte)int status = wait_til_ready(fdc);if (status < 0 )return -1 ;if (is_ready_state(status)) {1 ) % OLOGSIZE;return 0 ;1 ;if (initialized) {"Unable to send byte %x to FDC. Fdc=%x Status=%x\n" ,return -1 ;/* gets the response from the fdc */ static int result(int fdc)int i;int status = 0 ;for (i = 0 ; i < FD_RAW_REPLY_SIZE; i++) {if (status < 0 )break ;if ((status & ~STATUS_BUSY) == STATUS_READY) {return i;if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))else break ;if (initialized) {"get result error. Fdc=%d Last status=%x Read bytes=%d\n" ,1 ;return -1 ;#define MORE_OUTPUT -2 /* does the fdc need more output? */ static int need_more_output(int fdc)int status = wait_til_ready(fdc);if (status < 0 )return -1 ;if (is_ready_state(status))return MORE_OUTPUT;return result(fdc);/* Set perpendicular mode as required, based on data rate, if supported. * 82077 Now tested . 1 Mbps data rate only possible with 82077 - 1 . static void perpendicular_mode(int fdc)unsigned char perp_mode;if (raw_cmd->rate & 0 x40) {switch (raw_cmd->rate & 3 ) {case 0 :2 ;break ;case 3 :3 ;break ;default :"Invalid data rate for perpendicular mode!\n" );0 );1 ;/* * convenient way to return to * redo without too much hassle * ( deep stack et al . ) return ;else 0 ;if (fdc_state[fdc].perp_mode == perp_mode)return ;if (fdc_state[fdc].version >= FDC_82077_ORIG) {else if (perp_mode) {"perpendicular mode not supported by this FDC.\n" );/* perpendicular_mode */ static int fifo_depth = 0 xa;static int no_fifo;static int fdc_configure(int fdc)/* Turn on FIFO */ if (need_more_output(fdc) != MORE_OUTPUT)return 0 ;0 );0 x10 | (no_fifo & 0 x20) | (fifo_depth & 0 xf));0 ); /* pre-compensation from track 0 upwards */ return 1 ;#define NOMINAL_DTR 500 /* Issue a "SPECIFY" command to set the step rate time, head unload time, * head load time , and DMA disable flag to values needed by floppy . * * The value " dtr " is the data transfer rate in Kbps . It is needed * to account for the data rate - based scaling done by the 82072 and 82077 * FDC types . This parameter is ignored for other types of FDCs ( i . e . * 8272 a ) . * * Note that changing the data transfer rate has a ( probably deleterious ) * effect on the parameters subject to scaling for 82072 / 82077 FDCs , so * fdc_specify is called again after each data transfer rate * change . * * srt : 1000 to 16000 in microseconds * hut : 16 to 240 milliseconds * hlt : 2 to 254 milliseconds * * These values are rounded up to the next highest available delay time . static void fdc_specify(int fdc, int drive)unsigned char spec1;unsigned char spec2;unsigned long srt;unsigned long hlt;unsigned long hut;unsigned long dtr = NOMINAL_DTR;unsigned long scale_dtr = NOMINAL_DTR;int hlt_max_code = 0 x7f;int hut_max_code = 0 xf;if (fdc_state[fdc].need_configure &&0 ;switch (raw_cmd->rate & 0 x03) {case 3 :1000 ;break ;case 1 :300 ;if (fdc_state[fdc].version >= FDC_82078) {/* chose the default rate table, not the one if (need_more_output(fdc) == MORE_OUTPUT) {0 xc0);break ;case 2 :250 ;break ;if (fdc_state[fdc].version >= FDC_82072) {0 x00; /* 0==256msec*dtr0/dtr (not linear!) */ 0 x0; /* 0==256msec*dtr0/dtr (not linear!) */ /* Convert step rate from microseconds to milliseconds and 4 bits */ 16 - DIV_ROUND_UP(drive_params[drive].srt * scale_dtr / 1000 ,if (slow_floppy)4 ;0 xf);0 );2 ,if (hlt < 0 x01)0 x01;else if (hlt > 0 x7f)16 ,if (hut < 0 x1)0 x1;else if (hut > 0 xf)4 ) | hut;1 ) | (use_virtual_dma & 1 );/* If these parameters did not change, just return with success */ if (fdc_state[fdc].spec1 != spec1 ||/* Go ahead and set spec1 and spec2 */ /* 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 * of the specify command ( i . e . using the fdc_specify function ) . static int fdc_dtr(void )/* If data rate not already set to desired value, set it. */ if ((raw_cmd->rate & 3 ) == fdc_state[current_fdc].dtr)return 0 ;/* Set dtr */ 3 , current_fdc, FD_DCR);/* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB) * need a stabilization period of several milliseconds to be * enforced after data rate changes before R / W operations . * Pause 5 msec to avoid trouble . ( Needs to be 2 jiffies ) 3 ;return fd_wait_for_completion(jiffies + 2 UL * HZ / 100 , floppy_ready);/* fdc_dtr */ static void tell_sector(void )": track %d, head %d, sector %d, size %d" ,/* tell_sector */ static void print_errors(void )"" );if (reply_buffer[ST0] & ST0_ECE) {"Recalibrate failed!" );else if (reply_buffer[ST2] & ST2_CRC) {"data CRC error" );else if (reply_buffer[ST1] & ST1_CRC) {"CRC error" );else if ((reply_buffer[ST1] & (ST1_MAM | ST1_ND)) ||if (!probing) {"sector not found" );else "probe failed..." );else if (reply_buffer[ST2] & ST2_WC) { /* seek error */ "wrong cylinder" );else if (reply_buffer[ST2] & ST2_BC) { /* cylinder marked as bad */ "bad cylinder" );else {"unknown error. ST[0..2] are: 0x%x 0x%x 0x%x" ,"\n" );/* * OK , this error interpreting routine is called after a * DMA read / write has succeeded * or failed , so we check the results , and copy any buffers . * hhb : Added better error reporting . * ak : Made this into a separate routine . static int interpret_errors(void )char bad;if (inr != 7 ) {"-- FDC reply error\n" );1 ;return 1 ;/* check IC to find cause of interrupt */ switch (reply_buffer[ST0] & ST0_INTR) {case 0 x40: /* error occurred during command execution */ if (reply_buffer[ST1] & ST1_EOC)return 0 ; /* occurs with pseudo-DMA */ 1 ;if (reply_buffer[ST1] & ST1_WP) {"Drive is write protected\n" );0 );2 ;else if (reply_buffer[ST1] & ST1_ND) {else if (reply_buffer[ST1] & ST1_OR) {if (drive_params[current_drive].flags & FTD_MSG)"Over/Underrun - retrying\n" );0 ;else if (floppy_errors >= drive_params[current_drive].max_errors.reporting) {if (reply_buffer[ST2] & ST2_WC || reply_buffer[ST2] & ST2_BC)/* wrong cylinder => recal */ return bad;case 0 x80: /* invalid command given */ "Invalid FDC command given!\n" );0 );return 2 ;case 0 xc0:"Abnormal termination caused by polling\n" );return 2 ;default : /* (0) Normal command termination */ return 0 ;/* * This routine is called when everything should be correctly set up * for the transfer ( i . e . floppy motor is on , the correct floppy is * selected , and the head is sitting on the right track ) . static void setup_rw_floppy(void )int i;int r;int flags;unsigned long ready_date;void (*function)(void );if (flags & (FD_RAW_READ | FD_RAW_WRITE))if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {inup;/* 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 (time_after(ready_date, jiffies + drive_params[current_drive].select_delay)) {else /* wait until the floppy is spinning fast enough */ if (fd_wait_for_completion(ready_date, function))return ;if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))if (flags & FD_RAW_INTR)0 ;for (i = 0 ; i < raw_cmd->cmd_count; i++)"rw_command" );if (r) {return ;if (!(flags & FD_RAW_INTR)) {else if (flags & FD_RAW_NEED_DISK)static int blind_seek;/* * This is the routine called after every seek ( or recalibrate ) interrupt * from the floppy controller . static void seek_interrupt(void )"" );if (inr != 2 || (reply_buffer[ST0] & 0 xF8) != 0 x20) {"seek failed\n" );return ;if (drive_state[current_drive].track >= 0 &&"clearing NEWCHANGE flag because of effective seek\n" );"jiffies=%lu\n" ,/* effective seek */ static void check_wp(int fdc, int drive)if (test_bit(FD_VERIFY_BIT, &drive_state[drive].flags)) {/* check write protection */ if (result(fdc) != 1 ) {1 ;return ;"checking whether disk is write protected\n" );"wp=%x\n" ,0 x40);if (!(reply_buffer[ST3] & 0 x40))else static void seek_floppy(void )int track;0 ;"calling disk change from %s\n" , __func__);if (!test_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[current_drive].flags) &&/* 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 . 0 );return ;if (drive_state[current_drive].track <= NEED_1_RECAL) {return ;else if (test_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[current_drive].flags) &&w_cmd->track)) {/* we seek to clear the media-changed condition. Does anybody if (raw_cmd->track)1 ;else {if (drive_params[current_drive].flags & FD_SILENT_DCL_CLEAR) {0 x10 << UNIT(current_drive)), 0 );1 ;1 ;else {if (raw_cmd->track != drive_state[current_drive].track &&else {return ;if (output_byte(current_fdc, track) < 0 ) {return ;"" );static void recal_interrupt(void )"" );if (inr != 2 )1 ;else if (reply_buffer[ST0] & ST0_ECE) {switch (drive_state[current_drive].track) {case NEED_1_RECAL:"need 1 recal" );/* after a second recalibrate, we still haven't * reached track 0 . Probably no drive . Raise an * error , as failing immediately might upset return ;case NEED_2_RECAL:"need 2 recal" );/* 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 "clearing NEWCHANGE flag because of second recalibrate\n" );default :"default" );/* 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 break ;else static void print_result(char *message, int inr)int i;"%s " , message);if (inr >= 0 )for (i = 0 ; i < inr; i++)"repl[%d]=%x " , i, reply_buffer[i]);"\n" );/* interrupt handler. Note that this can be called externally on the Sparc */ int irq, void *dev_id)int do_print;unsigned long f;void (*handler)(void ) = do_floppy;if (current_fdc >= N_FDC || fdc_state[current_fdc].address == -1 ) {/* we don't even know which FDC is the culprit */ "DOR0=%x\n" , fdc_state[0 ].dor);"floppy interrupt on bizarre fdc %d\n" , current_fdc);"handler=%ps\n" , handler);"bizarre fdc" );return IRQ_NONE;0 ;/* We have to clear the reset flag here, because apparently on boxes * with level triggered interrupts ( PS / 2 , Sparc , . . . ) , it is needed to * emit SENSEI ' s to clear the interrupt line . And fdc_state [ fdc ] . reset * blocks the emission of the SENSEI ' s . * It is OK to emit floppy commands because we are in an interrupt * handler here , and thus we have to fear no interference of other * activity . if (do_print)"unexpected interrupt" , inr);if (inr == 0 ) {int max_sensei = 4 ;do {if (do_print)"sensei" , inr);while ((reply_buffer[ST0] & 0 x83) != UNIT(current_drive) &&2 && max_sensei);if (!handler) {1 ;return IRQ_NONE;"normal interrupt end" );/* FIXME! Was it really for us? */ return IRQ_HANDLED;static void recalibrate_floppy(void )"" );if (output_byte(current_fdc, UNIT(current_drive)) < 0 )/* * Must do 4 FD_SENSEIs after reset because of ` ` drive polling ' ' . static void reset_interrupt(void )"" );/* get the status ready for set_fdc */ if (fdc_state[current_fdc].reset) {"reset set in interrupt, calling %ps\n" , cont->error);/* a reset just after a reset. BAD! */ /* * reset is done by pulling bit 2 of DOR low for a while ( old FDCs ) , * or by setting the self clearing bit 7 of STATUS ( newer FDCs ) . * This WILL trigger an interrupt , causing the handlers in the current * cont ' s - > redo ( ) to be called via reset_interrupt ( ) . static void reset_fdc(void )unsigned long flags;0 ;0 );/* Pseudo-DMA may intercept 'reset finished' interrupt. */ /* Irrelevant for systems with true DMA (i386). */ if (fdc_state[current_fdc].version >= FDC_82072A)0 x80 | (fdc_state[current_fdc].dtr & 3 ),else {0 x04, current_fdc, FD_DOR);static void show_floppy(int fdc)int i;"\n" );"floppy driver state\n" );"-------------------\n" );"now=%lu last interrupt=%lu diff=%lu last called handler=%ps\n" ,"timeout_message=%s\n" , timeout_message);"last output bytes:\n" );for (i = 0 ; i < OLOGSIZE; i++)"%2x %2x %lu\n" ,"last result at %lu\n" , resultjiffies);"last redo_fd_request at %lu\n" , lastredo);"" , DUMP_PREFIX_NONE, 16 , 1 ,true );"status=%x\n" , fdc_inb(fdc, FD_STATUS));"fdc_busy=%lu\n" , fdc_busy);if (do_floppy)"do_floppy=%ps\n" , do_floppy);if (work_pending(&floppy_work))"floppy_work.func=%ps\n" , floppy_work.func);if (delayed_work_pending(&fd_timer))"delayed work.function=%p expires=%ld\n" ,if (delayed_work_pending(&fd_timeout))"timer_function=%p expires=%ld\n" ,"cont=%p\n" , cont);"current_req=%p\n" , current_req);"command_status=%d\n" , command_status);"\n" );static void floppy_shutdown(struct work_struct *arg)unsigned long flags;if (initialized)/* avoid dma going to a random drive after shutdown */ if (initialized)"floppy timeout called\n" );1 ;if (cont) {0 );/* this will recall reset when needed */ else {"no cont in shutdown!\n" );"" );/* start motor, check media-changed condition and write protection */ static int start_motor(void (*function)(void ))int mask;int data;0 xfc;if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {if (!(fdc_state[current_fdc].dor & (0 x10 << UNIT(current_drive)))) {/* no read since this drive is running */ 0 ;/* note motor start time if motor is not yet running */ 0 x10 << UNIT(current_drive));else if (fdc_state[current_fdc].dor & (0 x10 << UNIT(current_drive)))0 x10 << UNIT(current_drive));/* starts motor and selects floppy */ /* wait_for_completion also schedules reset if needed. */ return fd_wait_for_completion(drive_state[current_drive].select_date + drive_params[current_drive].select_delay,static void floppy_ready(void )if (fdc_state[current_fdc].reset) {return ;if (start_motor(floppy_ready))return ;if (fdc_dtr())return ;"calling disk change from floppy_ready\n" );if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&/* this clears the dcl on certain #ifdef fd_chose_dma_modeif ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {unsigned long flags = claim_dma_lock();#endif if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {/* must be done here because of hut, hlt ... */ else {if ((raw_cmd->flags & FD_RAW_READ) ||static void floppy_start(void )"floppy start" );"setting NEWCHANGE in floppy_start\n" );/* * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * here ends the bottom half . Exported routines are : * floppy_start , floppy_off , floppy_ready , lock_fdc , unlock_fdc , set_fdc , * start_motor , reset_fdc , reset_fdc_info , interpret_errors . * Initialization also uses output_byte , result , set_dor , floppy_interrupt * and set_dor . * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = /* * General purpose continuations . * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = static void do_wakeup(void )"do wakeup" );2 ;static const struct cont_t wakeup_cont = {static const struct cont_t intr_cont = {/* schedules handler, waiting for completion. May be interrupted, will then * return - EINTR , in which case the driver will automatically be unlocked . static int wait_til_done(void (*handler)(void ), bool interruptible)int ret;if (interruptible)2 );else 2 );if (command_status < 2 ) {return -EINTR;if (fdc_state[current_fdc].reset)if (command_status == FD_COMMAND_OKAY)0 ;else return ret;static void generic_done(int result)static void generic_success(void )1 );static void generic_failure(void )0 );static void success_and_wakeup(void )/* * formatting and rw support . * = = = = = = = = = = = = = = = = = = = = = = = = = = static int next_valid_format(int drive)int probed_format;while (1 ) {if (probed_format >= FD_AUTODETECT_SIZE ||0 ;return 1 ;if (floppy_type[drive_params[drive].autodetect[probed_format]].sect) {return 0 ;static void bad_flp_intr(void )int err_count;if (probing) {if (!next_valid_format(current_drive))return ;if (err_count > drive_params[current_drive].max_errors.abort)0 );if (err_count > drive_params[current_drive].max_errors.reset)1 ;else if (err_count > drive_params[current_drive].max_errors.recal)static void set_floppy(int drive)int type = ITYPE(drive_state[drive].fd_device);if (type)else /* * formatting support . * = = = = = = = = = = = = = = = = = = = static void format_interrupt(void )switch (interpret_errors()) {case 1 :break ;case 2 :break ;case 0 :1 );#define FM_MODE(x, y) ((y) & ~(((x)->rate & 0 x80) >> 1 ))#define CT(x) ((x) | 0 xc0)static void setup_format_params(int track)int n;int il;int count;int head_shift;int track_shift;struct fparm {unsigned char track, head, sect, size;struct fparm *)floppy_track_buffer;0 x43;2 >> raw_cmd->cmd[F_SIZECODE];4 * raw_cmd->cmd[F_SECT_PER_TRACK];if (!raw_cmd->cmd[F_SECT_PER_TRACK])return ;/* allow for about 30ms for data transport per track */ 5 ) / 6 ;/* a ``cylinder'' is two tracks plus a little stepping time */ 2 * head_shift + 3 ;/* position of logical sector 1 on this track */ /* determine interleave */ 1 ;if (_floppy->fmt_gap < 0 x22)/* initialize field */ for (count = 0 ; count < raw_cmd->cmd[F_SECT_PER_TRACK]; ++count) {0 ;/* place logical sectors */ for (count = 1 ; count <= raw_cmd->cmd[F_SECT_PER_TRACK]; ++count) {if (here[n].sect) { /* sector busy, find next free sector */ if (n >= raw_cmd->cmd[F_SECT_PER_TRACK]) {while (here[n].sect)if (_floppy->stretch & FD_SECTBASEMASK) {for (count = 0 ; count < raw_cmd->cmd[F_SECT_PER_TRACK]; count++)1 ;static void redo_format(void )1 ;"queue format request" );static const struct cont_t format_cont = {static int do_format(int drive, struct format_descr *tmp_format_req)int ret;if (lock_fdc(drive))return -EINTR;if (!_floppy ||2 ) % (1 << FD_SIZECODE(_floppy)) ||return -EINVAL;0 ;true );if (ret == -EINTR)return -EINTR;return ret;/* * Buffer read / write and support * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = static void floppy_end_request(struct request *req, blk_status_t error)unsigned int nr_sectors = current_count_sectors;unsigned int drive = (unsigned long )req->q->disk->private_data;/* current_count_sectors can be zero if transfer failed */ if (error)if (blk_update_request(req, error, nr_sectors << 9 ))return ;/* We're done with the request */ /* new request_done. Can handle physical sectors which are smaller than a static void request_done(int uptodate)struct request *req = current_req;int block;char msg[sizeof ("request done " ) + sizeof (int ) * 3 ];0 ;sizeof (msg), "request done %d" , uptodate);if (!req) {"floppy.c: no request in request_done\n" );return ;if (uptodate) {/* maintain values for invalidation on geometry if (block > _floppy->sect)1 ;0 );else {if (rq_data_dir(req) == WRITE) {/* record write error information */ if (write_errors[current_drive].write_errors == 1 ) {neration;eration;/* Interrupt handler evaluating the result of the r/w operation */ static void rw_interrupt(void )int eoc;int ssize;int heads;int nr_sectors;if (reply_buffer[R_HEAD] >= 2 ) {/* some Toshiba floppy controllers occasionnally seem to * return bogus interrupts after read / write operations , which return ;if (!drive_state[current_drive].first_read_date)1 << raw_cmd->cmd[SIZECODE], 4 );if (reply_buffer[ST1] & ST1_EOC)1 ;else 0 ;if (raw_cmd->cmd[COMMAND] & 0 x80)2 ;else 1 ;2 ;if (nr_sectors / ssize >"long rw: %x instead of %lx\n" ,"rs=%d s=%d\n" , reply_buffer[R_SECTOR],"rh=%d h=%d\n" , reply_buffer[R_HEAD],"rt=%d t=%d\n" , reply_buffer[R_TRACK],"heads=%d eoc=%d\n" , heads, eoc);"spt=%d st=%d ss=%d\n" ,"in_sector_offset=%d\n" , in_sector_offset);0 );switch (interpret_errors()) {case 2 :return ;case 1 :if (!current_count_sectors) {return ;break ;case 0 :if (!current_count_sectors) {return ;break ;if (probing) {if (drive_params[current_drive].flags & FTD_MSG)"Auto-detected floppy type %s in fd%d\n" ,0 ;if (CT(raw_cmd->cmd[COMMAND]) != FD_READ) {/* transfer directly from buffer */ 1 );else {/* Compute the maximal transfer size */ static int transfer_size(int ssize, int max_sector, int max_size)/* alignment */ /* transfer size, beginning not aligned */ return max_sector;/* * Move data from / to the track buffer to / from the buffer cache . static void copy_buffer(int ssize, int max_sector, int max_sector_2)int remaining; /* number of transferred 512-byte sectors */ struct bio_vec bv;char *dma_buffer;int size;struct req_iterator iter;if (current_count_sectors <= 0 && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE &&int , buffer_max - fsector_t,9 ;if (remaining > blk_rq_bytes(current_req) && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {"in copy buffer\n" );"current_count_sectors=%ld\n" , current_count_sectors);"remaining=%d\n" , remaining >> 9 );"current_req->nr_sectors=%u\n" ,"current_req->current_nr_sectors=%u\n" ,"max_sector=%d\n" , max_sector);"ssize=%d\n" , ssize);9 );if (!remaining)break ;if (dma_buffer + size >10 ) ||"buffer overrun in copy buffer %d\n" ,int )((floppy_track_buffer - dma_buffer) >> 9 ));"fsector_t=%d buffer_min=%d\n" ,"current_count_sectors=%ld\n" ,if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)"read\n" );if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE)"write\n" );break ;if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)else if (remaining) {if (remaining > 0 )9 ;"weirdness: remaining %d\n" , remaining >> 9 );/* work around a bug in pseudo DMA * ( on some FDCs ) pseudo DMA does not stop when the CPU stops * sending data . Hence we need a different way to signal the * transfer length : We use raw_cmd - > cmd [ SECT_PER_TRACK ] . Unfortunately , this * does not work with MT , hence we can only transfer one head at * a time static void virtualdmabug_workaround(void )int hard_sectors;int end_sector;if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {0 x80; /* switch off multiple track mode */ 7 + raw_cmd->cmd[SIZECODE]);1 ;if (end_sector > raw_cmd->cmd[SECT_PER_TRACK]) {"too many sectors %d > %d\n" ,return ;/* make sure raw_cmd->cmd[SECT_PER_TRACK] /* * Formulate a read / write request . * this routine decides where to load the data ( directly to buffer , or to * tmp floppy area ) , how much data to load ( the size of the buffer , the whole * track , or a single sector ) * All floppy_track_buffer handling goes in here . If we ever add track buffer * allocation on the fly , it should be done here . No other part should need * modification . static int make_raw_rw_request(void )int aligned_sector_t;int max_sector;int max_size;int tracksize;int ssize;if (WARN(max_buffer_sectors == 0 , "VFS: Block I/O scheduled on unopened device\n" ))return 0 ;long )current_req->q->disk->private_data);if (rq_data_dir(current_req) == READ) {else if (rq_data_dir(current_req) == WRITE) {else {"%s: unknown command\n" , __func__);return 0 ;int )blk_rq_pos(current_req) / max_sector;int )blk_rq_pos(current_req) % max_sector;if (_floppy->track && raw_cmd->cmd[TRACK] >= _floppy->track) {if (blk_rq_cur_sectors(current_req) & 1 ) {1 ;return 1 ;else return 0 ;if (((_floppy->stretch & (FD_SWAPSIDES | FD_SECTBASEMASK)) ||/* 2M disks have phantom sectors on the first track */ if ((_floppy->rate & FD_2M) && (!raw_cmd->cmd[TRACK]) && (!raw_cmd->cmd[HEAD])) {2 * _floppy->sect / 3 ;if (fsector_t >= max_sector) {int , _floppy->sect - fsector_t,return 1 ;2 ;else 0 x43;if ((_floppy->rate & FD_2M) &&2 )1 ;if (raw_cmd->cmd[SIZECODE])0 xff;else 0 x80;1 << raw_cmd->cmd[SIZECODE], 4 );2 >> raw_cmd->cmd[SIZECODE];2 >> raw_cmd->cmd[SIZECODE]) +/* tracksize describes the size which can be filled up with sectors * of size ssize . if (tracksize < _floppy->sect) {if (tracksize <= fsector_t % _floppy->sect)/* if we are beyond tracksize, fill up using smaller sectors */ while (tracksize <= fsector_t % _floppy->sect) {while (tracksize + ssize > _floppy->sect) {1 ;else if (!raw_cmd->cmd[TRACK] && !raw_cmd->cmd[HEAD] && !(_floppy->rate & FD_2M) && probing) {else if (!raw_cmd->cmd[HEAD] && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {/* for virtual DMA bug workaround */ if ((raw_cmd->track == buffer_track) &&/* data already in track buffer */ if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) {1 , max_sector, buffer_max);return 1 ;else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {unsigned int sectors;if (sectors > ssize && sectors < ssize + ssize)else if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)/* unbounded */ /* claim buffer track if needed */ if (buffer_track != raw_cmd->track || /* bad track */ /* bad drive */ 2 * max_buffer_sectors + buffer_min &&2 * max_buffer_sectors + buffer_min)) {/* not enough space */ 1 ;9 );if (CT(raw_cmd->cmd[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 if (in_sector_offset && buffer_track == -1 )"internal error offset !=0 on write\n" );2 * max_buffer_sectors + buffer_min);else 2 * max_buffer_sectors + buffer_min -/* round up current_count_sectors to get dma xfer size */ 1 ) | (ssize - 1 )) + 1 ;9 ;if ((raw_cmd->length < current_count_sectors << 9 ) ||9 ) > buffer_max ||128 << raw_cmd->cmd[SIZECODE]) ||0 || current_count_sectors <= 0 ) {"fractionary current count b=%lx s=%lx\n" ,"addr=%d, length=%ld\n" ,int )((raw_cmd->kernel_data -9 ),"st=%d ast=%d mse=%d msi=%d\n" ,"ssize=%x SIZECODE=%d\n" , ssize, raw_cmd->cmd[SIZECODE]);"command=%x SECTOR=%d HEAD=%d, TRACK=%d\n" ,"buffer drive=%d\n" , buffer_drive);"buffer track=%d\n" , buffer_track);"buffer_min=%d\n" , buffer_min);"buffer_max=%d\n" , buffer_max);return 0 ;if (raw_cmd->kernel_data < floppy_track_buffer ||0 ||0 ||10 )) {"buffer overrun in schedule dma\n" );"fsector_t=%d buffer_min=%d current_count=%ld\n" ,9 );"current_count_sectors=%ld\n" ,if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)"read\n" );if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE)"write\n" );return 0 ;if (raw_cmd->length == 0 ) {"zero dma transfer attempted from make_raw_request\n" );return 0 ;return 2 ;static int set_next_request(void )struct request,if (current_req) {0 ;return 1 ;return 0 ;/* Starts or continues processing request. Will automatically unlock the * driver at end of request . static void redo_fd_request(void )int drive;int tmp;if (current_drive < N_DRIVE)if (!current_req) {int pending;if (!pending) {return ;long )current_req->q->disk->private_data;"redo fd request" );0 ;if (start_motor(redo_fd_request))return ;if (test_bit(current_drive, &fake_change) ||"disk absent or changed during operation\n" );0 );goto do_request;if (!_floppy) { /* Autodetection */ if (!probing) {0 ;if (next_valid_format(current_drive)) {"no autodetectable formats\n" );0 );goto do_request;1 ;rive].probed_format];else 0 ;if (tmp < 2 ) {goto do_request;if (test_bit(FD_NEED_TWADDLE_BIT, &drive_state[current_drive].flags))"queue fd request" );return ;static const struct cont_t rw_cont = {/* schedule the request and automatically unlock the driver on completion */ static void process_fd_request(void )static blk_status_t floppy_queue_rq(struct blk_mq_hw_ctx *hctx,const struct blk_mq_queue_data *bd)if (WARN(max_buffer_sectors == 0 ,"VFS: %s called on non-open device\n" , __func__))return BLK_STS_IOERR;if (WARN(atomic_read(&usage_count) == 0 ,"warning: usage count=0, current_req=%p sect=%ld flags=%llx\n" ,long )blk_rq_pos(current_req),unsigned long long ) current_req->cmd_flags))return BLK_STS_IOERR;if (test_and_set_bit(0 , &fdc_busy)) {/* fdc busy, this new request will be treated when the "old request running" );return BLK_STS_RESOURCE;"fd_request" );0 );"" );return BLK_STS_OK;static const struct cont_t poll_cont = {static int poll_drive(bool interruptible, int flag)/* no auto-sense, just clear dcl */ 0 ;0 ;"setting NEWCHANGE in poll_drive\n" );return wait_til_done(floppy_ready, interruptible);/* * User triggered reset * = = = = = = = = = = = = = = = = = = = = static void reset_intr(void )"weird, reset interrupt called\n" );static const struct cont_t reset_cont = {/* * Resets the FDC connected to drive < drive > . * Both current_drive and current_fdc are changed to match the new drive . static int user_reset_fdc(int drive, int arg, bool interruptible)int ret;if (lock_fdc(drive))return -EINTR;if (arg == FD_RESET_ALWAYS)1 ;if (fdc_state[current_fdc].reset) {/* note: reset_fdc will take care of unlocking the driver * on completion . if (ret == -EINTR)return -EINTR;return 0 ;/* * Misc Ioctl ' s and support * = = = = = = = = = = = = = = = = = = = = = = = = static inline int fd_copyout(void __user *param, const void *address,unsigned long size)return copy_to_user(param, address, size) ? -EFAULT : 0 ;static inline int fd_copyin(void __user *param, void *address,unsigned long size)return copy_from_user(address, param, size) ? -EFAULT : 0 ;static const char *drive_name(int type, int drive)struct floppy_struct *floppy;if (type)else {if (drive_params[drive].native_format)else return "(null)" ;if (floppy->name)return floppy->name;else return "(null)" ;#ifdef CONFIG_BLK_DEV_FD_RAWCMD/* raw commands */ static void raw_cmd_done(int flag)if (!flag) {else {if (raw_cmd->reply_count > FD_RAW_REPLY_SIZE)0 ;if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {unsigned long flags;if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&0 ] & 0 xc0)))if (disk_change(current_drive))else if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)if (raw_cmd->next &&return ;static const struct cont_t raw_cmd_cont = {static int raw_cmd_copyout(int cmd, void __user *param,struct floppy_raw_cmd *ptr)int ret;while (ptr) {struct floppy_raw_cmd cmd = *ptr;sizeof (cmd));if (ret)return -EFAULT;sizeof (struct floppy_raw_cmd);if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {if (ptr->length >= 0 &&long length = ptr->buffer_length - ptr->length;if (ret)return ret;return 0 ;static void raw_cmd_free(struct floppy_raw_cmd **ptr)struct floppy_raw_cmd *next;struct floppy_raw_cmd *this ;this = *ptr;while (this ) {if (this ->buffer_length) {unsigned long )this ->kernel_data,this ->buffer_length);this ->buffer_length = 0 ;this ->next;this );this = next;#define MAX_LEN (1 UL << MAX_PAGE_ORDER << PAGE_SHIFT)static int raw_cmd_copyin(int cmd, void __user *param,struct floppy_raw_cmd **rcmd)struct floppy_raw_cmd *ptr;int ret;sizeof (struct floppy_raw_cmd), GFP_KERNEL);if (!ptr)return -ENOMEM;sizeof (*ptr));0 ;if (ret)return -EFAULT;sizeof (struct floppy_raw_cmd);if (ptr->cmd_count > FD_RAW_CMD_FULLSIZE)return -EINVAL;0 , FD_RAW_REPLY_SIZE);0 ;if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {if (ptr->length <= 0 || ptr->length > MAX_LEN)return -EINVAL;char *)fd_dma_mem_alloc(ptr->length);if (!ptr->kernel_data)return -ENOMEM;if (ptr->flags & FD_RAW_WRITE) {if (ret)return ret;if (ptr->flags & FD_RAW_MORE) {0 x43;goto loop;return 0 ;static int raw_cmd_ioctl(int cmd, void __user *param)struct floppy_raw_cmd *my_raw_cmd;int drive;int ret2;int ret;if (fdc_state[current_fdc].rawcmd <= 1 )1 ;for (drive = 0 ; drive < N_DRIVE; drive++) {if (FDC(drive) != current_fdc)continue ;if (drive == current_drive) {if (drive_state[drive].fd_ref > 1 ) {2 ;break ;else if (drive_state[drive].fd_ref) {2 ;break ;if (fdc_state[current_fdc].reset)return -EIO;if (ret) {return ret;true );"calling disk change from raw_cmd ioctl\n" );if (ret != -EINTR && fdc_state[current_fdc].reset)if (!ret)return ret;static int floppy_raw_cmd_ioctl(int type, int drive, int cmd,void __user *param)int ret;"Note: FDRAWCMD is deprecated and will be removed from the kernel in the near future.\n" );if (type)return -EINVAL;if (lock_fdc(drive))return -EINTR;if (ret == -EINTR)return -EINTR;return ret;#else /* CONFIG_BLK_DEV_FD_RAWCMD */ static int floppy_raw_cmd_ioctl(int type, int drive, int cmd,void __user *param)return -EOPNOTSUPP;#endif static int invalidate_drive(struct gendisk *disk)/* invalidate the buffer track to force a reread */ long )disk->private_data, &fake_change);if (disk_check_media_change(disk)) {true );return 0 ;static int set_geometry(unsigned int cmd, struct floppy_struct *g,int drive, int type, struct block_device *bdev)int cnt;/* sanity checking for parameters. */ if ((int )g->sect <= 0 ||int )g->head <= 0 ||/* check for overflow in max_sector */ int )(g->sect * g->head) <= 0 ||/* check for zero in raw_cmd->cmd[F_SECT_PER_TRACK] */ unsigned char )((g->sect << 2 ) >> FD_SIZECODE(g)) == 0 ||0 || g->track > drive_params[drive].tracks >> STRETCH(g) ||/* check if reserved bits are set */ 0 )return -EINVAL;if (type) {if (!capable(CAP_SYS_ADMIN))return -EPERM;if (lock_fdc(drive)) {return -EINTR;"user format" ;for (cnt = type << 2 ; cnt < (type << 2 ) + 4 ; cnt++)0 x80] =1 ;for (cnt = 0 ; cnt < N_DRIVE; cnt++) {struct gendisk *disk = opened_disk[cnt];if (!disk || ITYPE(drive_state[cnt].fd_device) != type)continue ;else {int oldStretch;if (lock_fdc(drive))return -EINTR;if (cmd != FDDEFPRM) {/* notice a disk change immediately, else if (poll_drive(true , FD_RAW_NEED_DISK) == -EINTR)return -EINTR;if (buffer_drive == drive)if (cmd == FDDEFPRM)1 ;else 1 ;/* invalidation. Invalidate only when needed, i.e. * when there are already sectors in the buffer cache * whose number will change . This is useful , because * mtools often changes the geometry of the disk after if (drive_state[current_drive].maxblock > user_params[drive].sect ||else return 0 ;/* handle obsolete ioctl's */ static unsigned int ioctl_table[] = {static int normalize_ioctl(unsigned int *cmd, int *size)int i;for (i = 0 ; i < ARRAY_SIZE(ioctl_table); i++) {if ((*cmd & 0 xffff) == (ioctl_table[i] & 0 xffff)) {if (*size > _IOC_SIZE(*cmd)) {"ioctl not yet supported\n" );return -EFAULT;return 0 ;return -EINVAL;static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)if (type)else {if (lock_fdc(drive))return -EINTR;if (poll_drive(false , 0 ) == -EINTR)return -EINTR;if (!*g)return -ENODEV;return 0 ;static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)int drive = (long )bdev->bd_disk->private_data;int type = ITYPE(drive_state[drive].fd_device);struct floppy_struct *g;int ret;if (ret)return ret;return 0 ;static bool valid_floppy_drive_params(const short autodetect[FD_AUTODETECT_SIZE],int native_format)0 ;for (i = 0 ; i < FD_AUTODETECT_SIZE; ++i) {if (autodetect[i] < 0 ||return false ;if (native_format < 0 || native_format >= floppy_type_size)return false ;return true ;static int fd_locked_ioctl(struct block_device *bdev, blk_mode_t mode,unsigned int cmd, unsigned long param)int drive = (long )bdev->bd_disk->private_data;int type = ITYPE(drive_state[drive].fd_device);int ret;int size;union inparam {struct floppy_struct g; /* geometry */ struct format_descr f;struct floppy_max_errors max_errors;struct floppy_drive_params dp;/* parameters coming from user space */ const void *outparam = NULL; /* 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 if (cmd == CDROMEJECT || /* CD-ROM eject */ 0 x6470) { /* SunOS floppy eject */ "obsolete eject ioctl\n" );"please use floppycontrol --eject\n" );if (!((cmd & 0 xff00) == 0 x0200))return -EINVAL;/* convert the old style command into a new style command */ if (ret)return ret;/* permission checks */ if (((cmd & 0 x40) &&0 x80) && !capable(CAP_SYS_ADMIN)))return -EPERM;if (WARN_ON(size < 0 || size > sizeof (inparam)))return -EINVAL;/* copyin */ 0 , sizeof (inparam));if (_IOC_DIR(cmd) & _IOC_WRITE) {void __user *)param, &inparam, size);if (ret)return ret;switch (cmd) {case FDEJECT:if (drive_state[drive].fd_ref != 1 )/* somebody else has this drive open */ return -EBUSY;if (lock_fdc(drive))return -EINTR;/* do the actual eject. Fails on return ret;case FDCLRPRM:if (lock_fdc(drive))return -EINTR;1 ;0 ;return invalidate_drive(bdev->bd_disk);case FDSETPRM:case FDDEFPRM:return set_geometry(cmd, &inparam.g, drive, type, bdev);case FDGETPRM:struct floppy_struct **)&outparam);if (ret)return ret;struct floppy_struct, name));break ;case FDMSGON:return 0 ;case FDMSGOFF:return 0 ;case FDFMTBEG:if (lock_fdc(drive))return -EINTR;if (poll_drive(true , FD_RAW_NEED_DISK) == -EINTR)return -EINTR;if (ret & FD_VERIFY)return -ENODEV;if (!(ret & FD_DISK_WRITABLE))return -EROFS;return 0 ;case FDFMTTRK:if (drive_state[drive].fd_ref != 1 )return -EBUSY;return do_format(drive, &inparam.f);case FDFMTEND:case FDFLUSH:if (lock_fdc(drive))return -EINTR;return invalidate_drive(bdev->bd_disk);case FDSETEMSGTRESH:unsigned short )(param & 0 x0f);return 0 ;case FDGETMAXERRS:break ;case FDSETMAXERRS:break ;case FDGETDRVTYP:const char *)outparam) + 1 );break ;case FDSETDRVPRM:if (!valid_floppy_drive_params(inparam.dp.autodetect,return -EINVAL;break ;case FDGETDRVPRM:break ;case FDPOLLDRVSTAT:if (lock_fdc(drive))return -EINTR;if (poll_drive(true , FD_RAW_NEED_DISK) == -EINTR)return -EINTR;case FDGETDRVSTAT:break ;case FDRESET:return user_reset_fdc(drive, (int )param, true );case FDGETFDCSTAT:break ;case FDWERRORCLR:0 , sizeof (write_errors[drive]));return 0 ;case FDWERRORGET:break ;case FDRAWCMD:return floppy_raw_cmd_ioctl(type, drive, cmd, (void __user *)param);case FDTWADDLE:if (lock_fdc(drive))return -EINTR;return 0 ;default :return -EINVAL;if (_IOC_DIR(cmd) & _IOC_READ)return fd_copyout((void __user *)param, outparam, size);return 0 ;static int fd_ioctl(struct block_device *bdev, blk_mode_t mode,unsigned int cmd, unsigned long param)int ret;return ret;#ifdef CONFIG_COMPATstruct compat_floppy_drive_params {char cmos;unsigned char spindown_offset;unsigned char select_delay;unsigned char rps;unsigned char tracks;unsigned char interleave_sect;struct floppy_max_errors max_errors;char flags;char read_track;short autodetect[FD_AUTODETECT_SIZE];struct compat_floppy_drive_struct {signed char flags;short probed_format;short track;short maxblock;short maxtrack;struct compat_floppy_fdc_state {unsigned char version;unsigned char dor;unsigned int rawcmd:2 ;unsigned int reset:1 ;unsigned int need_configure:1 ;unsigned int perp_mode:2 ;unsigned int has_fifo:1 ;unsigned int driver_version;unsigned char track[4 ];struct compat_floppy_write_errors {unsigned int write_errors;#define FDSETPRM32 _IOW(2 , 0 x42, struct compat_floppy_struct)#define FDDEFPRM32 _IOW(2 , 0 x43, struct compat_floppy_struct)#define FDSETDRVPRM32 _IOW(2 , 0 x90, struct compat_floppy_drive_params)#define FDGETDRVPRM32 _IOR(2 , 0 x11, struct compat_floppy_drive_params)#define FDGETDRVSTAT32 _IOR(2 , 0 x12, struct compat_floppy_drive_struct)#define FDPOLLDRVSTAT32 _IOR(2 , 0 x13, struct compat_floppy_drive_struct)#define FDGETFDCSTAT32 _IOR(2 , 0 x15, struct compat_floppy_fdc_state)#define FDWERRORGET32 _IOR(2 , 0 x17, struct compat_floppy_write_errors)static int compat_set_geometry(struct block_device *bdev, blk_mode_t mode,unsigned int cmd, struct compat_floppy_struct __user *arg)struct floppy_struct v;int drive, type;int err;struct floppy_struct, name) !=struct compat_floppy_struct, name));if (!(mode & (BLK_OPEN_WRITE | BLK_OPEN_WRITE_IOCTL)))return -EPERM;0 , sizeof (struct floppy_struct));if (copy_from_user(&v, arg, offsetof(struct floppy_struct, name)))return -EFAULT;long )bdev->bd_disk->private_data;return err;static int compat_get_prm(int drive,struct compat_floppy_struct __user *arg)struct compat_floppy_struct v;struct floppy_struct *p;int err;0 , sizeof (v));if (err) {return err;struct floppy_struct, name));if (copy_to_user(arg, &v, sizeof (struct compat_floppy_struct)))return -EFAULT;return 0 ;static int compat_setdrvprm(int drive,struct compat_floppy_drive_params __user *arg)struct compat_floppy_drive_params v;if (!capable(CAP_SYS_ADMIN))return -EPERM;if (copy_from_user(&v, arg, sizeof (struct compat_floppy_drive_params)))return -EFAULT;if (!valid_floppy_drive_params(v.autodetect, v.native_format))return -EINVAL;sizeof (v.autodetect));return 0 ;static int compat_getdrvprm(int drive,struct compat_floppy_drive_params __user *arg)struct compat_floppy_drive_params v;0 , sizeof (struct compat_floppy_drive_params));sizeof (v.autodetect));if (copy_to_user(arg, &v, sizeof (struct compat_floppy_drive_params)))return -EFAULT;return 0 ;static int compat_getdrvstat(int drive, bool poll,struct compat_floppy_drive_struct __user *arg)struct compat_floppy_drive_struct v;0 , sizeof (struct compat_floppy_drive_struct));if (poll) {if (lock_fdc(drive))goto Eintr;if (poll_drive(true , FD_RAW_NEED_DISK) == -EINTR)goto Eintr;if (copy_to_user(arg, &v, sizeof (struct compat_floppy_drive_struct)))return -EFAULT;return 0 ;return -EINTR;static int compat_getfdcstat(int drive,struct compat_floppy_fdc_state __user *arg)struct compat_floppy_fdc_state v32;struct floppy_fdc_state v;0 , sizeof (struct compat_floppy_fdc_state));4 );if (copy_to_user(arg, &v32, sizeof (struct compat_floppy_fdc_state)))return -EFAULT;return 0 ;static int compat_werrorget(int drive,struct compat_floppy_write_errors __user *arg)struct compat_floppy_write_errors v32;struct floppy_write_errors v;0 , sizeof (struct compat_floppy_write_errors));if (copy_to_user(arg, &v32, sizeof (struct compat_floppy_write_errors)))return -EFAULT;return 0 ;static int fd_compat_ioctl(struct block_device *bdev, blk_mode_t mode,unsigned int cmd, unsigned long param)int drive = (long )bdev->bd_disk->private_data;switch (cmd) {case CDROMEJECT: /* CD-ROM eject */ case 0 x6470: /* SunOS floppy eject */ case FDMSGON:case FDMSGOFF:case FDSETEMSGTRESH:case FDFLUSH:case FDWERRORCLR:case FDEJECT:case FDCLRPRM:case FDFMTBEG:case FDRESET:case FDTWADDLE:return fd_ioctl(bdev, mode, cmd, param);case FDSETMAXERRS:case FDGETMAXERRS:case FDGETDRVTYP:case FDFMTEND:case FDFMTTRK:case FDRAWCMD:return fd_ioctl(bdev, mode, cmd,unsigned long )compat_ptr(param));case FDSETPRM32:case FDDEFPRM32:return compat_set_geometry(bdev, mode, cmd, compat_ptr(param));case FDGETPRM32:return compat_get_prm(drive, compat_ptr(param));case FDSETDRVPRM32:return compat_setdrvprm(drive, compat_ptr(param));case FDGETDRVPRM32:return compat_getdrvprm(drive, compat_ptr(param));case FDPOLLDRVSTAT32:return compat_getdrvstat(drive, true , compat_ptr(param));case FDGETDRVSTAT32:return compat_getdrvstat(drive, false , compat_ptr(param));case FDGETFDCSTAT32:return compat_getfdcstat(drive, compat_ptr(param));case FDWERRORGET32:return compat_werrorget(drive, compat_ptr(param));return -EINVAL;#endif static void __init config_types(void )bool has_drive = false ;int drive;/* read drive info out of physical CMOS */ 0 ;if (!drive_params[drive].cmos)1 ;if (!drive_params[drive].cmos)/* FIXME: additional physical CMOS drive detection should go here */ for (drive = 0 ; drive < N_DRIVE; drive++) {unsigned int type = drive_params[drive].cmos;struct floppy_drive_params *params;const char *name = NULL;char temparea[32 ];if (type < ARRAY_SIZE(default_drive_params)) {if (type) {1 << drive;else 1 << drive);else {0 ].params;sizeof (temparea),"unknown type %d (usb?)" , type);if (name) {const char *prepend;if (!has_drive) {"" ;true ;"Floppy drive(s):" );else {"," ;"%s fd%d is %s" , prepend, drive, name);if (has_drive)"\n" );static void floppy_release(struct gendisk *disk)int drive = (long )disk->private_data;if (!drive_state[drive].fd_ref--) {"floppy_release with fd_ref == 0" );0 ;if (!drive_state[drive].fd_ref)/* * floppy_open check for aliasing ( / dev / fd0 can be the same as * / dev / PS0 etc ) , and disallows simultaneous access to the same * drive with different device numbers . static int floppy_open(struct gendisk *disk, blk_mode_t mode)int drive = (long )disk->private_data;int old_dev, new_dev;int try ;int res = -EBUSY;char *tmp;if (opened_disk[drive] && opened_disk[drive] != disk)goto out2;if (!drive_state[drive].fd_ref && (drive_params[drive].flags & FD_BROKEN_DCL)) {if (!floppy_track_buffer) {/* if opening an ED drive, reserve a big buffer, if ((drive_params[drive].cmos == 6 ) || (drive_params[drive].cmos == 5 ))try = 64 ; /* Only 48 actually useful */ else try = 32 ; /* Only 24 actually useful */ char *)fd_dma_mem_alloc(1024 * try );if (!tmp && !floppy_track_buffer) {try >>= 1 ; /* buffer only one side */ try , 16 );char *)fd_dma_mem_alloc(1024 * try );if (!tmp && !floppy_track_buffer)2048 * try );if (!tmp && !floppy_track_buffer) {"Unable to allocate DMA memory\n" );goto out;if (floppy_track_buffer) {if (tmp)unsigned long )tmp, try * 1024 );else {1 ;try ;if (old_dev != -1 && old_dev != new_dev) {if (buffer_drive == drive)1 ;if (fdc_state[FDC(drive)].rawcmd == 1 )2 ;if (!(mode & BLK_OPEN_NDELAY)) {if (mode & (BLK_OPEN_READ | BLK_OPEN_WRITE)) {0 ;if (disk_check_media_change(disk))if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags))goto out;if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &drive_state[drive].flags))goto out;if ((mode & BLK_OPEN_WRITE) &&goto out;return 0 ;if (!drive_state[drive].fd_ref)return res;/* * Check if the disk has been changed or if a change has been faked . static unsigned int floppy_check_events(struct gendisk *disk,unsigned int clearing)int drive = (long )disk->private_data;if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||return DISK_EVENT_MEDIA_CHANGE;if (time_after(jiffies, drive_state[drive].last_checked + drive_params[drive].checkfreq)) {if (lock_fdc(drive))return 0 ;false , 0 );if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||return DISK_EVENT_MEDIA_CHANGE;return 0 ;/* * This implements " read block 0 " for floppy_revalidate ( ) . * Needed for format autodetection , checking whether there is * a disk in the drive , and whether that disk is writable . struct rb0_cbdata {int drive;struct completion complete;static void floppy_rb0_cb(struct bio *bio)struct rb0_cbdata *cbdata = (struct rb0_cbdata *)bio->bi_private;int drive = cbdata->drive;if (bio->bi_status) {"floppy: error %d while reading block 0\n" ,static int __floppy_read_block_0(struct block_device *bdev, int drive)struct bio bio;struct bio_vec bio_vec;struct page *page;struct rb0_cbdata cbdata;if (!page) {return -ENOMEM;1 , REQ_OP_READ);0 );0 ;1 << BIO_QUIET);return 0 ;/* revalidate the floppy disk, i.e. trigger format autodetection by reading * the bootblock ( block 0 ) . " Autodetection " is also needed to check whether * there is a disk in the drive at all . . . Thus we also do it for fixed static int floppy_revalidate(struct gendisk *disk)int drive = (long )disk->private_data;int cf;int res = 0 ;if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||if (WARN(atomic_read(&usage_count) == 0 ,"VFS: revalidate called on non-open device.\n" ))return -EFAULT;if (res)return res;if (!(cf || test_bit(drive, &fake_change) || drive_no_geom(drive))) {/*already done by another thread */ return 0 ;0 ;0 ;if (buffer_drive == drive)1 ;if (cf)if (drive_no_geom(drive)) {/* auto-sensing */ else {if (cf)false , FD_RAW_NEED_DISK);return res;static const struct block_device_operations floppy_fops = {#ifdef CONFIG_COMPAT#endif /* * Floppy Driver initialization * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = /* Determine the floppy disk controller type */ /* This routine was written by David C. Niemi */ static char __init get_fdc_version(int fdc)int r;/* 82072 and better know DUMPREGS */ if (fdc_state[fdc].reset)return FDC_NONE;if (r <= 0 x00)return FDC_NONE; /* No FDC present ??? */ if ((r == 1 ) && (reply_buffer[ST0] == 0 x80)) {"FDC %d is an 8272A\n" , fdc);return FDC_8272A; /* 8272a/765 don't know DUMPREGS */ if (r != 10 ) {"FDC %d init: DUMPREGS: unexpected return of %d bytes.\n" ,return FDC_UNKNOWN;if (!fdc_configure(fdc)) {"FDC %d is an 82072\n" , fdc);return FDC_82072; /* 82072 doesn't know CONFIGURE */ if (need_more_output(fdc) == MORE_OUTPUT) {0 );else {"FDC %d is an 82072A\n" , fdc);return FDC_82072A; /* 82072A as found on Sparcs. */ if ((r == 1 ) && (reply_buffer[ST0] == 0 x80)) {"FDC %d is a pre-1991 82077\n" , fdc);return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know if ((r != 1 ) || (reply_buffer[ST0] != 0 x00)) {"FDC %d init: UNLOCK: unexpected return of %d bytes.\n" ,return FDC_UNKNOWN;if (r != 1 ) {"FDC %d init: PARTID: unexpected return of %d bytes.\n" ,return FDC_UNKNOWN;if (reply_buffer[ST0] == 0 x80) {"FDC %d is a post-1991 82077\n" , fdc);return FDC_82077; /* Revised 82077AA passes all the tests */ switch (reply_buffer[ST0] >> 5 ) {case 0 x0:/* Either a 82078-1 or a 82078SL running at 5Volt */ "FDC %d is an 82078.\n" , fdc);return FDC_82078;case 0 x1:"FDC %d is a 44pin 82078\n" , fdc);return FDC_82078;case 0 x2:"FDC %d is a S82078B\n" , fdc);return FDC_S82078B;case 0 x3:"FDC %d is a National Semiconductor PC87306\n" , fdc);return FDC_87306;default :"FDC %d init: 82078 variant with unknown PARTID=%d.\n" ,5 );return FDC_82078_UNKN;/* get_fdc_version */ /* lilo configuration */ static void __init floppy_set_flags(int *ints, int param, int param2)int i;for (i = 0 ; i < ARRAY_SIZE(default_drive_params); i++) {if (param)else "%s flag 0x%x\n" , param2 ? "Setting" : "Clearing" , param);static void __init daring(int *ints, int param, int param2)int i;for (i = 0 ; i < ARRAY_SIZE(default_drive_params); i++) {if (param) {0 ;else {2 * HZ / 100 ;"Assuming %s floppy hardware\n" , param ? "standard" : "broken" );static void __init set_cmos(int *ints, int dummy, int dummy2)int current_drive = 0 ;if (ints[0 ] != 2 ) {"wrong number of parameters for CMOS\n" );return ;1 ];if (current_drive < 0 || current_drive >= 8 ) {"bad drive for set_cmos\n" );return ;#if N_FDC > 1 if (current_drive >= 4 && !FDC2)0 x370;#endif 2 ];"setting CMOS code to %d\n" , ints[2 ]);static struct param_table {const char *name;void (*fn) (int *ints, int param, int param2);int *var;int def_param;int param2;"allowed_drive_mask" , NULL, &allowed_drive_mask, 0 xff, 0 }, /* obsolete */ "all_drives" , NULL, &allowed_drive_mask, 0 xff, 0 }, /* obsolete */ "asus_pci" , NULL, &allowed_drive_mask, 0 x33, 0 },"irq" , NULL, &FLOPPY_IRQ, 6 , 0 },"dma" , NULL, &FLOPPY_DMA, 2 , 0 },"daring" , daring, NULL, 1 , 0 },#if N_FDC > 1 "two_fdc" , NULL, &FDC2, 0 x370, 0 },"one_fdc" , NULL, &FDC2, 0 , 0 },#endif "thinkpad" , floppy_set_flags, NULL, 1 , FD_INVERTED_DCL},"broken_dcl" , floppy_set_flags, NULL, 1 , FD_BROKEN_DCL},"messages" , floppy_set_flags, NULL, 1 , FTD_MSG},"silent_dcl_clear" , floppy_set_flags, NULL, 1 , FD_SILENT_DCL_CLEAR},"debug" , floppy_set_flags, NULL, 1 , FD_DEBUG},"nodma" , NULL, &can_use_virtual_dma, 1 , 0 },"omnibook" , NULL, &can_use_virtual_dma, 1 , 0 },"yesdma" , NULL, &can_use_virtual_dma, 0 , 0 },"fifo_depth" , NULL, &fifo_depth, 0 xa, 0 },"nofifo" , NULL, &no_fifo, 0 x20, 0 },"usefifo" , NULL, &no_fifo, 0 , 0 },"cmos" , set_cmos, NULL, 0 , 0 },"slow" , NULL, &slow_floppy, 1 , 0 },"unexpected_interrupts" , NULL, &print_unex, 1 , 0 },"no_unexpected_interrupts" , NULL, &print_unex, 0 , 0 },"L40SX" , NULL, &print_unex, 0 , 0 }static int __init floppy_setup(char *str)int i;int param;int ints[11 ];if (str) {for (i = 0 ; i < ARRAY_SIZE(config_params); i++) {if (strcmp(str, config_params[i].name) == 0 ) {if (ints[0 ])1 ];else if (config_params[i].fn)if (config_params[i].var) {"%s=%d\n" , str, param);return 1 ;if (str) {"unknown floppy option [%s]\n" , str);"allowed options are:" );for (i = 0 ; i < ARRAY_SIZE(config_params); i++)" %s" , config_params[i].name);"\n" );else "botched floppy option\n" );"Read Documentation/admin-guide/blockdev/floppy.rst\n" );return 0 ;static int have_no_fdc = -ENODEV;static ssize_t floppy_cmos_show(struct device *dev,struct device_attribute *attr, char *buf)struct platform_device *p = to_platform_device(dev);int drive;return sprintf(buf, "%X\n" , drive_params[drive].cmos);static DEVICE_ATTR(cmos, 0444 , floppy_cmos_show, NULL);static struct attribute *floppy_dev_attrs[] = {static void floppy_device_release(struct device *dev)static int floppy_resume(struct device *dev)int fdc;int saved_drive;for (fdc = 0 ; fdc < N_FDC; fdc++)if (fdc_state[fdc].address != -1 )0 ), FD_RESET_ALWAYS, false );return 0 ;static const struct dev_pm_ops floppy_pm_ops = {static struct platform_driver floppy_driver = {"floppy" ,static const struct blk_mq_ops floppy_mq_ops = {static struct platform_device floppy_device[N_DRIVE];static bool registered[N_DRIVE];static bool floppy_available(int drive)if (!(allowed_drive_mask & (1 << drive)))return false ;if (fdc_state[FDC(drive)].version == FDC_NONE)return false ;return true ;static int floppy_alloc_disk(unsigned int drive, unsigned int type)struct queue_limits lim = {64 ,struct gendisk *disk;if (IS_ERR(disk))return PTR_ERR(disk);2 );1 ;if (type)"fd%d_type%d" , drive, type);else "fd%d" , drive);/* to be cleaned up... */ void *)(long )drive;return 0 ;static DEFINE_MUTEX(floppy_probe_lock);static void floppy_probe(dev_t dev)unsigned int drive = (MINOR(dev) & 3 ) | ((MINOR(dev) & 0 x80) >> 5 );unsigned int type = (MINOR(dev) >> 2 ) & 0 x1f;if (drive >= N_DRIVE || !floppy_available(drive) ||return ;if (disks[drive][type])goto out;if (floppy_alloc_disk(drive, type))goto out;if (add_disk(disks[drive][type]))goto cleanup_disk;return ;static int __init do_floppy_init(void )int i, unit, drive, err;#if defined (CONFIG_PPC)if (check_legacy_ioport(FDC1))return -ENODEV;#endif "floppy" , 0 );if (!floppy_wq)return -ENOMEM;for (drive = 0 ; drive < N_DRIVE; drive++) {0 , sizeof (tag_sets[drive]));1 ;1 ;2 ;if (err)goto out_put_disk;0 );if (err) {goto out_put_disk;0 );"fd" , floppy_probe);if (err)goto out_put_disk;if (err)goto out_unreg_blkdev;for (i = 0 ; i < 256 ; i++)if (ITYPE(i))else 1 ;"floppy init" );for (i = 0 ; i < N_FDC; i++) {0 , sizeof (*fdc_state));1 ;0 x4;#if defined (__sparc__) || defined (__mc68000__)/*sparcs/sun3x don't have a DOR reset which we can fall back on to */ #ifdef __mc68000__if (MACH_IS_SUN3X)#endif #endif 1 ;0 ].address = FDC1;if (fdc_state[0 ].address == -1 ) {goto out_unreg_driver;#if N_FDC > 1 1 ].address = FDC2;#endif 0 ; /* reset fdc in case of unexpected interrupt */ if (err) {goto out_unreg_driver;/* initialise drive state */ for (drive = 0 ; drive < N_DRIVE; drive++) {0 , sizeof (drive_state[drive]));0 , sizeof (write_errors[drive]));1 ;0 ;/* * Small 10 msec delay to let through any interrupt that * initialization might have triggered , to not * confuse detection : 10 );for (i = 0 ; i < N_FDC; i++) {for (unit = 0 ; unit < 4 ; unit++)0 ;if (fdc_state[i].address == -1 )continue ;2 ;if (user_reset_fdc(REVDRIVE(i, 0 ), FD_RESET_ALWAYS, false )) {/* free ioports reserved by floppy_grab_irq_and_dma() */ 1 ;continue ;/* Try to determine the floppy controller type */ if (fdc_state[i].version == FDC_NONE) {/* free ioports reserved by floppy_grab_irq_and_dma() */ 1 ;continue ;if (can_use_virtual_dma == 2 &&0 ;0 ;/* Not all FDCs seem to be able to handle the version command * properly , so force a reset for the standard FDC clones , * to avoid interrupt garbage . 0 ), FD_RESET_ALWAYS, false );0 ;0 ;true ;if (have_no_fdc) {"no floppy controllers found\n" );goto out_release_dma;for (drive = 0 ; drive < N_DRIVE; drive++) {if (!floppy_available(drive))continue ;if (err)goto out_remove_drives;true ;0 ], NULL);if (err)goto out_remove_drives;return 0 ;while (drive--) {if (floppy_available(drive)) {0 ]);if (registered[drive])if (atomic_read(&usage_count))"fd" );for (drive = 0 ; drive < N_DRIVE; drive++) {if (!disks[drive][0 ])break ;0 ]);return err;#ifndef MODULEstatic __init void floppy_async_init(void *data, async_cookie_t cookie)#endif static int __init floppy_init(void )#ifdef MODULEreturn do_floppy_init();#else /* Don't hold up the bootup by the floppy initialization */ return 0 ;#endif static const struct io_region {int offset;int size;2 , 1 },/* address + 3 is sometimes reserved by pnp bios for motherboard */ 4 , 2 },/* address + 6 is reserved, and may be taken by IDE. 7 , 1 },static void floppy_release_allocated_regions(int fdc, const struct io_region *p)while (p != io_regions) {#define ARRAY_END(X) (&((X)[ARRAY_SIZE(X)]))static int floppy_request_regions(int fdc)const struct io_region *p;for (p = io_regions; p < ARRAY_END(io_regions); p++) {if (!request_region(fdc_state[fdc].address + p->offset,"floppy" )) {"Floppy io-port 0x%04lx in use\n" ,return -EBUSY;return 0 ;static void floppy_release_regions(int fdc)static int floppy_grab_irq_and_dma(void )int fdc;if (atomic_inc_return(&usage_count) > 1 )return 0 ;/* * We might have scheduled a free_irq ( ) , wait it to * drain first : if (fd_request_irq()) {"Unable to grab IRQ%d for the floppy driver\n" ,return -1 ;if (fd_request_dma()) {"Unable to grab DMA%d for the floppy driver\n" ,if (can_use_virtual_dma & 2 )1 ;if (!(can_use_virtual_dma & 1 )) {return -1 ;for (fdc = 0 ; fdc < N_FDC; fdc++) {if (fdc_state[fdc].address != -1 ) {if (floppy_request_regions(fdc))goto cleanup;for (fdc = 0 ; fdc < N_FDC; fdc++) {if (fdc_state[fdc].address != -1 ) {1 );0 , ~0 , 8 ); /* avoid immediate interrupt */ for (fdc = 0 ; fdc < N_FDC; fdc++)if (fdc_state[fdc].address != -1 )/* * The driver will try and free resources and relies on us * to know if they were allocated or not . 0 ;1 ;return 0 ;while (--fdc >= 0 )0 ;return -1 ;static void floppy_release_irq_and_dma(void )int fdc;#ifndef __sparc__int drive;#endif long tmpsize;unsigned long tmpaddr;if (!atomic_dec_and_test(&usage_count))return ;if (irqdma_allocated) {0 ;0 , ~0 , 8 );#if N_FDC > 1 1 , ~8 , 0 );#endif if (floppy_track_buffer && max_buffer_sectors) {1024 ;unsigned long )floppy_track_buffer;0 ;1 ;#ifndef __sparc__for (drive = 0 ; drive < N_FDC * 4 ; drive++)if (timer_pending(motor_off_timer + drive))"motor off timer %d still active\n" , drive);#endif if (delayed_work_pending(&fd_timeout))"floppy timer still active:%s\n" , timeout_message);if (delayed_work_pending(&fd_timer))"auxiliary floppy timer still active\n" );if (work_pending(&floppy_work))"work still pending\n" );for (fdc = 0 ; fdc < N_FDC; fdc++)if (fdc_state[fdc].address != -1 )#ifdef MODULEstatic char *floppy;static void __init parse_floppy_cfg_string(char *cfg)char *ptr;while (*cfg) {while (*cfg && *cfg != ' ' && *cfg != '\t' )if (*cfg) {'\0' ;if (*ptr)static int __init floppy_module_init(void )if (floppy)return floppy_init();static void __exit floppy_module_exit(void )int drive, i;"fd" );for (drive = 0 ; drive < N_DRIVE; drive++) {if (floppy_available(drive)) {for (i = 0 ; i < ARRAY_SIZE(floppy_type); i++) {if (disks[drive][i])if (registered[drive])for (i = 0 ; i < ARRAY_SIZE(floppy_type); i++) {if (disks[drive][i])if (atomic_read(&usage_count))/* eject disk, if any */ 0 );0 );int , 0 );int , 0 );"Alain L. Knaff" );"Normal floppy disk support" );"GPL" );/* This doesn't actually get used other than for module information */ static const struct pnp_device_id floppy_pnpids[] = {"PNP0700" , 0 },#else "floppy=" , floppy_setup);#endif
Messung V0.5 in Prozent C=94 H=93 G=93
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.197Bemerkung:
(vorverarbeitet am 2026-09-28)
¤ *Bot Zugriff
