开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 驱动编程 > 查看源码
floppy.c
资源名称：block.rar　[点击查看]
上传用户：ajay2009
上传日期：2009-05-22
资源大小：495k
文件大小：119k
源码类别：

驱动编程

开发平台：

Unix_Linux

floppy.c：源码内容
  1. /*
  2.  *  linux/drivers/block/floppy.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  *  Copyright (C) 1993, 1994  Alain Knaff
  6.  *  Copyright (C) 1998 Alan Cox
  7.  */
  8. /*
  9.  * 02.12.91 - Changed to static variables to indicate need for reset
  10.  * and recalibrate. This makes some things easier (output_byte reset
  11.  * checking etc), and means less interrupt jumping in case of errors,
  12.  * so the code is hopefully easier to understand.
  13.  */
  15. /*
  16.  * This file is certainly a mess. I've tried my best to get it working,
  17.  * but I don't like programming floppies, and I have only one anyway.
  18.  * Urgel. I should check for more errors, and do more graceful error
  19.  * recovery. Seems there are problems with several drives. I've tried to
  20.  * correct them. No promises.
  21.  */
  23. /*
  24.  * As with hd.c, all routines within this file can (and will) be called
  25.  * by interrupts, so extreme caution is needed. A hardware interrupt
  26.  * handler may not sleep, or a kernel panic will happen. Thus I cannot
  27.  * call "floppy-on" directly, but have to set a special timer interrupt
  28.  * etc.
  29.  */
  31. /*
  32.  * 28.02.92 - made track-buffering routines, based on the routines written
  33.  * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
  34.  */
  36. /*
  37.  * Automatic floppy-detection and formatting written by Werner Almesberger
  38.  * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with
  39.  * the floppy-change signal detection.
  40.  */
  42. /*
  43.  * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
  44.  * FDC data overrun bug, added some preliminary stuff for vertical
  45.  * recording support.
  46.  *
  47.  * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
  48.  *
  49.  * TODO: Errors are still not counted properly.
  50.  */
  52. /* 1992/9/20
  53.  * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl)
  54.  * modeled after the freeware MS-DOS program fdformat/88 V1.8 by
  55.  * Christoph H. Hochst"atter.
  56.  * I have fixed the shift values to the ones I always use. Maybe a new
  57.  * ioctl() should be created to be able to modify them.
  58.  * There is a bug in the driver that makes it impossible to format a
  59.  * floppy as the first thing after bootup.
  60.  */
  62. /*
  63.  * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
  64.  * this helped the floppy driver as well. Much cleaner, and still seems to
  65.  * work.
  66.  */
  68. /* 1994/6/24 --bbroad-- added the floppy table entries and made
  69.  * minor modifications to allow 2.88 floppies to be run.
  70.  */
  72. /* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
  73.  * disk types.
  74.  */
  76. /*
  77.  * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
  78.  * format bug fixes, but unfortunately some new bugs too...
  79.  */
  81. /* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
  82.  * errors to allow safe writing by specialized programs.
  83.  */
  85. /* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
  86.  * by defining bit 1 of the "stretch" parameter to mean put sectors on the
  87.  * opposite side of the disk, leaving the sector IDs alone (i.e. Commodore's
  88.  * drives are "upside-down").
  89.  */
  91. /*
  92.  * 1995/8/26 -- Andreas Busse -- added Mips support.
  93.  */
  95. /*
  96.  * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
  97.  * features to asm/floppy.h.
  98.  */
  100. /*
  101.  * 1998/05/07 -- Russell King -- More portability cleanups; moved definition of
  102.  * interrupt and dma channel to asm/floppy.h. Cleaned up some formatting &
  103.  * use of '0' for NULL.
  104.  */
  106. /*
  107.  * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
  108.  * failures.
  109.  */
  111. /*
  112.  * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
  113.  */
  115. /*
  116.  * 1999/08/13 -- Paul Slootman -- floppy stopped working on Alpha after 24
  117.  * days, 6 hours, 32 minutes and 32 seconds (i.e. MAXINT jiffies; ints were
  118.  * being used to store jiffies, which are unsigned longs).
  119.  */
  121. /*
  122.  * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  123.  * - get rid of check_region
  124.  * - s/suser/capable/
  125.  */
  127. /*
  128.  * 2001/08/26 -- Paul Gortmaker - fix insmod oops on machines with no
  129.  * floppy controller (lingering task on list after module is gone... boom.)
  130.  */
  132. /*
  133.  * 2002/02/07 -- Anton Altaparmakov - Fix io ports reservation to correct range
  134.  * (0x3f2-0x3f5, 0x3f7). This fix is a bit of a hack but the proper fix
  135.  * requires many non-obvious changes in arch dependent code.
  136.  */
  138. /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
  139.  * Better audit of register_blkdev.
  140.  */
  142. #define FLOPPY_SANITY_CHECK
  143. #undef  FLOPPY_SILENT_DCL_CLEAR
  145. #define REALLY_SLOW_IO
  147. #define DEBUGT 2
  148. #define DCL_DEBUG /* debug disk change line */
  150. /* do print messages for unexpected interrupts */
  151. static int print_unex = 1;
  152. #include <linux/module.h>
  153. #include <linux/sched.h>
  154. #include <linux/fs.h>
  155. #include <linux/kernel.h>
  156. #include <linux/timer.h>
  157. #include <linux/workqueue.h>
  158. #define FDPATCHES
  159. #include <linux/fdreg.h>
  161. /*
  162.  * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
  163.  */
  165. #include <linux/fd.h>
  166. #include <linux/hdreg.h>
  168. #include <linux/errno.h>
  169. #include <linux/slab.h>
  170. #include <linux/mm.h>
  171. #include <linux/bio.h>
  172. #include <linux/string.h>
  173. #include <linux/fcntl.h>
  174. #include <linux/delay.h>
  175. #include <linux/mc146818rtc.h> /* CMOS defines */
  176. #include <linux/ioport.h>
  177. #include <linux/interrupt.h>
  178. #include <linux/init.h>
  179. #include <linux/devfs_fs_kernel.h>
  180. #include <linux/device.h>
  181. #include <linux/buffer_head.h> /* for invalidate_buffers() */
  183. /*
  184.  * PS/2 floppies have much slower step rates than regular floppies.
  185.  * It's been recommended that take about 1/4 of the default speed
  186.  * in some more extreme cases.
  187.  */
  188. static int slow_floppy;
  190. #include <asm/dma.h>
  191. #include <asm/irq.h>
  192. #include <asm/system.h>
  193. #include <asm/io.h>
  194. #include <asm/uaccess.h>
  196. static int FLOPPY_IRQ = 6;
  197. static int FLOPPY_DMA = 2;
  198. static int can_use_virtual_dma = 2;
  199. /* =======
  200.  * can use virtual DMA:
  201.  * 0 = use of virtual DMA disallowed by config
  202.  * 1 = use of virtual DMA prescribed by config
  203.  * 2 = no virtual DMA preference configured.  By default try hard DMA,
  204.  * but fall back on virtual DMA when not enough memory available
  205.  */
  207. static int use_virtual_dma;
  208. /* =======
  209.  * use virtual DMA
  210.  * 0 using hard DMA
  211.  * 1 using virtual DMA
  212.  * This variable is set to virtual when a DMA mem problem arises, and
  213.  * reset back in floppy_grab_irq_and_dma.
  214.  * It is not safe to reset it in other circumstances, because the floppy
  215.  * driver may have several buffers in use at once, and we do currently not
  216.  * record each buffers capabilities
  217.  */
  219. static DEFINE_SPINLOCK(floppy_lock);
  220. static struct completion device_release;
  222. static unsigned short virtual_dma_port = 0x3f0;
  223. irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  224. static int set_dor(int fdc, char mask, char data);
  225. static void register_devfs_entries(int drive) __init;
  227. #define K_64 0x10000 /* 64KB */
  229. /* the following is the mask of allowed drives. By default units 2 and
  230.  * 3 of both floppy controllers are disabled, because switching on the
  231.  * motor of these drives causes system hangs on some PCI computers. drive
  232.  * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
  233.  * a drive is allowed.
  234.  *
  235.  * NOTE: This must come before we include the arch floppy header because
  236.  *       some ports reference this variable from there. -DaveM
  237.  */
  239. static int allowed_drive_mask = 0x33;
  241. #include <asm/floppy.h>
  243. static int irqdma_allocated;
  245. #define LOCAL_END_REQUEST
  246. #define DEVICE_NAME "floppy"
  248. #include <linux/blkdev.h>
  249. #include <linux/blkpg.h>
  250. #include <linux/cdrom.h> /* for the compatibility eject ioctl */
  251. #include <linux/completion.h>
  253. static struct request *current_req;
  254. static struct request_queue *floppy_queue;
  255. static void do_fd_request(request_queue_t * q);
  257. #ifndef fd_get_dma_residue
  258. #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
  259. #endif
  261. /* Dma Memory related stuff */
  263. #ifndef fd_dma_mem_free
  264. #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
  265. #endif
  267. #ifndef fd_dma_mem_alloc
  268. #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
  269. #endif
  271. static inline void fallback_on_nodma_alloc(char **addr, size_t l)
  272. {
  273. #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
  274. if (*addr)
  275. return; /* we have the memory */
  276. if (can_use_virtual_dma != 2)
  277. return; /* no fallback allowed */
  278. printk
  279.     ("DMA memory shortage. Temporarily falling back on virtual DMAn");
  280. *addr = (char *)nodma_mem_alloc(l);
  281. #else
  282. return;
  283. #endif
  284. }
  286. /* End dma memory related stuff */
  288. static unsigned long fake_change;
  289. static int initialising = 1;
  291. #define ITYPE(x) (((x)>>2) & 0x1f)
  292. #define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
  293. #define UNIT(x) ((x) & 0x03) /* drive on fdc */
  294. #define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
  295. #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
  296. /* reverse mapping from unit and fdc to drive */
  297. #define DP (&drive_params[current_drive])
  298. #define DRS (&drive_state[current_drive])
  299. #define DRWE (&write_errors[current_drive])
  300. #define FDCS (&fdc_state[fdc])
  301. #define CLEARF(x) (clear_bit(x##_BIT, &DRS->flags))
  302. #define SETF(x) (set_bit(x##_BIT, &DRS->flags))
  303. #define TESTF(x) (test_bit(x##_BIT, &DRS->flags))
  305. #define UDP (&drive_params[drive])
  306. #define UDRS (&drive_state[drive])
  307. #define UDRWE (&write_errors[drive])
  308. #define UFDCS (&fdc_state[FDC(drive)])
  309. #define UCLEARF(x) (clear_bit(x##_BIT, &UDRS->flags))
  310. #define USETF(x) (set_bit(x##_BIT, &UDRS->flags))
  311. #define UTESTF(x) (test_bit(x##_BIT, &UDRS->flags))
  313. #define DPRINT(format, args...) printk(DEVICE_NAME "%d: " format, current_drive , ## args)
  315. #define PH_HEAD(floppy,head) (((((floppy)->stretch & 2) >>1) ^ head) << 2)
  316. #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
  318. #define CLEARSTRUCT(x) memset((x), 0, sizeof(*(x)))
  320. /* read/write */
  321. #define COMMAND raw_cmd->cmd[0]
  322. #define DR_SELECT raw_cmd->cmd[1]
  323. #define TRACK raw_cmd->cmd[2]
  324. #define HEAD raw_cmd->cmd[3]
  325. #define SECTOR raw_cmd->cmd[4]
  326. #define SIZECODE raw_cmd->cmd[5]
  327. #define SECT_PER_TRACK raw_cmd->cmd[6]
  328. #define GAP raw_cmd->cmd[7]
  329. #define SIZECODE2 raw_cmd->cmd[8]
  330. #define NR_RW 9
  332. /* format */
  333. #define F_SIZECODE raw_cmd->cmd[2]
  334. #define F_SECT_PER_TRACK raw_cmd->cmd[3]
  335. #define F_GAP raw_cmd->cmd[4]
  336. #define F_FILL raw_cmd->cmd[5]
  337. #define NR_F 6
  339. /*
  340.  * Maximum disk size (in kilobytes). This default is used whenever the
  341.  * current disk size is unknown.
  342.  * [Now it is rather a minimum]
  343.  */
  344. #define MAX_DISK_SIZE 4 /* 3984 */
  346. /*
  347.  * globals used by 'result()'
  348.  */
  349. #define MAX_REPLIES 16
  350. static unsigned char reply_buffer[MAX_REPLIES];
  351. static int inr; /* size of reply buffer, when called from interrupt */
  352. #define ST0 (reply_buffer[0])
  353. #define ST1 (reply_buffer[1])
  354. #define ST2 (reply_buffer[2])
  355. #define ST3 (reply_buffer[0]) /* result of GETSTATUS */
  356. #define R_TRACK (reply_buffer[3])
  357. #define R_HEAD (reply_buffer[4])
  358. #define R_SECTOR (reply_buffer[5])
  359. #define R_SIZECODE (reply_buffer[6])
  361. #define SEL_DLY (2*HZ/100)
  363. /*
  364.  * this struct defines the different floppy drive types.
  365.  */
  366. static struct {
  367. struct floppy_drive_params params;
  368. const char *name; /* name printed while booting */
  369. } default_drive_params[] = {
  370. /* NOTE: the time values in jiffies should be in msec!
  371.  CMOS drive type
  372.   |     Maximum data rate supported by drive type
  373.   |     |   Head load time, msec
  374.   |     |   |   Head unload time, msec (not used)
  375.   |     |   |   |     Step rate interval, usec
  376.   |     |   |   |     |       Time needed for spinup time (jiffies)
  377.   |     |   |   |     |       |      Timeout for spinning down (jiffies)
  378.   |     |   |   |     |       |      |   Spindown offset (where disk stops)
  379.   |     |   |   |     |       |      |   |     Select delay
  380.   |     |   |   |     |       |      |   |     |     RPS
  381.   |     |   |   |     |       |      |   |     |     |    Max number of tracks
  382.   |     |   |   |     |       |      |   |     |     |    |     Interrupt timeout
  383.   |     |   |   |     |       |      |   |     |     |    |     |   Max nonintlv. sectors
  384.   |     |   |   |     |       |      |   |     |     |    |     |   | -Max Errors- flags */
  385. {{0,  500, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  80, 3*HZ, 20, {3,1,2,0,2}, 0,
  386.       0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
  388. {{1,  300, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  40, 3*HZ, 17, {3,1,2,0,2}, 0,
  389.       0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
  391. {{2,  500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6,  83, 3*HZ, 17, {3,1,2,0,2}, 0,
  392.       0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
  394. {{3,  250, 16, 16, 3000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  395.       0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
  397. {{4,  500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
  398.       0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
  400. {{5, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  401.       0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
  403. {{6, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
  404.       0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
  405. /*    |  --autodetected formats---    |      |      |
  406.  *    read_track                      |      |    Name printed when booting
  407.  *       |     Native format
  408.  *             Frequency of disk change checks */
  409. };
  411. static struct floppy_drive_params drive_params[N_DRIVE];
  412. static struct floppy_drive_struct drive_state[N_DRIVE];
  413. static struct floppy_write_errors write_errors[N_DRIVE];
  414. static struct timer_list motor_off_timer[N_DRIVE];
  415. static struct gendisk *disks[N_DRIVE];
  416. static struct block_device *opened_bdev[N_DRIVE];
  417. static DECLARE_MUTEX(open_lock);
  418. static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
  420. /*
  421.  * This struct defines the different floppy types.
  422.  *
  423.  * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
  424.  * types (e.g. 360kB diskette in 1.2MB drive, etc.).  Bit 1 of 'stretch'
  425.  * tells if the disk is in Commodore 1581 format, which means side 0 sectors
  426.  * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
  427.  * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
  428.  * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
  429.  * side 0 is on physical side 0 (but with the misnamed sector IDs).
  430.  * 'stretch' should probably be renamed to something more general, like
  431.  * 'options'.  Other parameters should be self-explanatory (see also
  432.  * setfdprm(8)).
  433.  */
  434. /*
  435.     Size
  436.      |  Sectors per track
  437.      |  | Head
  438.      |  | |  Tracks
  439.      |  | |  | Stretch
  440.      |  | |  | |  Gap 1 size
  441.      |  | |  | |    |  Data rate, | 0x40 for perp
  442.      |  | |  | |    |    |  Spec1 (stepping rate, head unload
  443.      |  | |  | |    |    |    |    /fmt gap (gap2) */
  444. static struct floppy_struct floppy_type[32] = {
  445. {    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL    }, /*  0 no testing    */
  446. {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360"  }, /*  1 360KB PC      */
  447. { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /*  2 1.2MB AT      */
  448. {  720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360"  }, /*  3 360KB SS 3.5" */
  449. { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720"  }, /*  4 720KB 3.5"    */
  450. {  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360"  }, /*  5 360KB AT      */
  451. { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720"  }, /*  6 720KB AT      */
  452. { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /*  7 1.44MB 3.5"   */
  453. { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /*  8 2.88MB 3.5"   */
  454. { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /*  9 3.12MB 3.5"   */
  456. { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25"  */
  457. { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5"   */
  458. {  820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410"  }, /* 12 410KB 5.25"   */
  459. { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820"  }, /* 13 820KB 3.5"    */
  460. { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25"  */
  461. { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5"   */
  462. {  840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420"  }, /* 16 420KB 5.25"   */
  463. { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830"  }, /* 17 830KB 3.5"    */
  464. { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25"  */
  465. { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5"  */
  467. { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880"  }, /* 20 880KB 5.25"   */
  468. { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5"   */
  469. { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5"   */
  470. { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25"   */
  471. { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5"   */
  472. { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5"   */
  473. { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5"   */
  474. { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5"   */
  475. { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5"   */
  477. { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5"   */
  478. { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800"  }, /* 30 800KB 3.5"    */
  479. { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5"    */
  480. };
  482. #define NUMBER(x) (sizeof(x) / sizeof(*(x)))
  483. #define SECTSIZE (_FD_SECTSIZE(*floppy))
  485. /* Auto-detection: Disk type used until the next media change occurs. */
  486. static struct floppy_struct *current_type[N_DRIVE];
  488. /*
  489.  * User-provided type information. current_type points to
  490.  * the respective entry of this array.
  491.  */
  492. static struct floppy_struct user_params[N_DRIVE];
  494. static sector_t floppy_sizes[256];
  496. static char floppy_device_name[] = "floppy";
  498. /*
  499.  * The driver is trying to determine the correct media format
  500.  * while probing is set. rw_interrupt() clears it after a
  501.  * successful access.
  502.  */
  503. static int probing;
  505. /* Synchronization of FDC access. */
  506. #define FD_COMMAND_NONE -1
  507. #define FD_COMMAND_ERROR 2
  508. #define FD_COMMAND_OKAY 3
  510. static volatile int command_status = FD_COMMAND_NONE;
  511. static unsigned long fdc_busy;
  512. static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
  513. static DECLARE_WAIT_QUEUE_HEAD(command_done);
  515. #define NO_SIGNAL (!interruptible || !signal_pending(current))
  516. #define CALL(x) if ((x) == -EINTR) return -EINTR
  517. #define ECALL(x) if ((ret = (x))) return ret;
  518. #define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
  519. #define WAIT(x) _WAIT((x),interruptible)
  520. #define IWAIT(x) _WAIT((x),1)
  522. /* Errors during formatting are counted here. */
  523. static int format_errors;
  525. /* Format request descriptor. */
  526. static struct format_descr format_req;
  528. /*
  529.  * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
  530.  * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
  531.  * H is head unload time (1=16ms, 2=32ms, etc)
  532.  */
  534. /*
  535.  * Track buffer
  536.  * Because these are written to by the DMA controller, they must
  537.  * not contain a 64k byte boundary crossing, or data will be
  538.  * corrupted/lost.
  539.  */
  540. static char *floppy_track_buffer;
  541. static int max_buffer_sectors;
  543. static int *errors;
  544. typedef void (*done_f) (int);
  545. static struct cont_t {
  546. void (*interrupt) (void); /* this is called after the interrupt of the
  547.  * main command */
  548. void (*redo) (void); /* this is called to retry the operation */
  549. void (*error) (void); /* this is called to tally an error */
  550. done_f done; /* this is called to say if the operation has
  551.  * succeeded/failed */
  552. } *cont;
  554. static void floppy_ready(void);
  555. static void floppy_start(void);
  556. static void process_fd_request(void);
  557. static void recalibrate_floppy(void);
  558. static void floppy_shutdown(unsigned long);
  560. static int floppy_grab_irq_and_dma(void);
  561. static void floppy_release_irq_and_dma(void);
  563. /*
  564.  * The "reset" variable should be tested whenever an interrupt is scheduled,
  565.  * after the commands have been sent. This is to ensure that the driver doesn't
  566.  * get wedged when the interrupt doesn't come because of a failed command.
  567.  * reset doesn't need to be tested before sending commands, because
  568.  * output_byte is automatically disabled when reset is set.
  569.  */
  570. #define CHECK_RESET { if (FDCS->reset){ reset_fdc(); return; } }
  571. static void reset_fdc(void);
  573. /*
  574.  * These are global variables, as that's the easiest way to give
  575.  * information to interrupts. They are the data used for the current
  576.  * request.
  577.  */
  578. #define NO_TRACK -1
  579. #define NEED_1_RECAL -2
  580. #define NEED_2_RECAL -3
  582. static int usage_count;
  584. /* buffer related variables */
  585. static int buffer_track = -1;
  586. static int buffer_drive = -1;
  587. static int buffer_min = -1;
  588. static int buffer_max = -1;
  590. /* fdc related variables, should end up in a struct */
  591. static struct floppy_fdc_state fdc_state[N_FDC];
  592. static int fdc; /* current fdc */
  594. static struct floppy_struct *_floppy = floppy_type;
  595. static unsigned char current_drive;
  596. static long current_count_sectors;
  597. static unsigned char fsector_t; /* sector in track */
  598. static unsigned char in_sector_offset; /* offset within physical sector,
  599.  * expressed in units of 512 bytes */
  601. #ifndef fd_eject
  602. static inline int fd_eject(int drive)
  603. {
  604. return -EINVAL;
  605. }
  606. #endif
  608. /*
  609.  * Debugging
  610.  * =========
  611.  */
  612. #ifdef DEBUGT
  613. static long unsigned debugtimer;
  615. static inline void set_debugt(void)
  616. {
  617. debugtimer = jiffies;
  618. }
  620. static inline void debugt(const char *message)
  621. {
  622. if (DP->flags & DEBUGT)
  623. printk("%s dtime=%lun", message, jiffies - debugtimer);
  624. }
  625. #else
  626. static inline void set_debugt(void) { }
  627. static inline void debugt(const char *message) { }
  628. #endif /* DEBUGT */
  630. typedef void (*timeout_fn) (unsigned long);
  631. static DEFINE_TIMER(fd_timeout, floppy_shutdown, 0, 0);
  633. static const char *timeout_message;
  635. #ifdef FLOPPY_SANITY_CHECK
  636. static void is_alive(const char *message)
  637. {
  638. /* this routine checks whether the floppy driver is "alive" */
  639. if (test_bit(0, &fdc_busy) && command_status < 2
  640.     && !timer_pending(&fd_timeout)) {
  641. DPRINT("timeout handler died: %sn", message);
  642. }
  643. }
  644. #endif
  646. static void (*do_floppy) (void) = NULL;
  648. #ifdef FLOPPY_SANITY_CHECK
  650. #define OLOGSIZE 20
  652. static void (*lasthandler) (void);
  653. static unsigned long interruptjiffies;
  654. static unsigned long resultjiffies;
  655. static int resultsize;
  656. static unsigned long lastredo;
  658. static struct output_log {
  659. unsigned char data;
  660. unsigned char status;
  661. unsigned long jiffies;
  662. } output_log[OLOGSIZE];
  664. static int output_log_pos;
  665. #endif
  667. #define current_reqD -1
  668. #define MAXTIMEOUT -2
  670. static void __reschedule_timeout(int drive, const char *message, int marg)
  671. {
  672. if (drive == current_reqD)
  673. drive = current_drive;
  674. del_timer(&fd_timeout);
  675. if (drive < 0 || drive > N_DRIVE) {
  676. fd_timeout.expires = jiffies + 20UL * HZ;
  677. drive = 0;
  678. } else
  679. fd_timeout.expires = jiffies + UDP->timeout;
  680. add_timer(&fd_timeout);
  681. if (UDP->flags & FD_DEBUG) {
  682. DPRINT("reschedule timeout ");
  683. printk(message, marg);
  684. printk("n");
  685. }
  686. timeout_message = message;
  687. }
  689. static void reschedule_timeout(int drive, const char *message, int marg)
  690. {
  691. unsigned long flags;
  693. spin_lock_irqsave(&floppy_lock, flags);
  694. __reschedule_timeout(drive, message, marg);
  695. spin_unlock_irqrestore(&floppy_lock, flags);
  696. }
  698. #define INFBOUND(a,b) (a)=max_t(int, a, b)
  700. #define SUPBOUND(a,b) (a)=min_t(int, a, b)
  702. /*
  703.  * Bottom half floppy driver.
  704.  * ==========================
  705.  *
  706.  * This part of the file contains the code talking directly to the hardware,
  707.  * and also the main service loop (seek-configure-spinup-command)
  708.  */
  710. /*
  711.  * disk change.
  712.  * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
  713.  * and the last_checked date.
  714.  *
  715.  * last_checked is the date of the last check which showed 'no disk change'
  716.  * FD_DISK_CHANGE is set under two conditions:
  717.  * 1. The floppy has been changed after some i/o to that floppy already
  718.  *    took place.
  719.  * 2. No floppy disk is in the drive. This is done in order to ensure that
  720.  *    requests are quickly flushed in case there is no disk in the drive. It
  721.  *    follows that FD_DISK_CHANGE can only be cleared if there is a disk in
  722.  *    the drive.
  723.  *
  724.  * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
  725.  * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
  726.  *  each seek. If a disk is present, the disk change line should also be
  727.  *  cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
  728.  *  change line is set, this means either that no disk is in the drive, or
  729.  *  that it has been removed since the last seek.
  730.  *
  731.  * This means that we really have a third possibility too:
  732.  *  The floppy has been changed after the last seek.
  733.  */
  735. static int disk_change(int drive)
  736. {
  737. int fdc = FDC(drive);
  738. #ifdef FLOPPY_SANITY_CHECK
  739. if (jiffies - UDRS->select_date < UDP->select_delay)
  740. DPRINT("WARNING disk change called earlyn");
  741. if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
  742.     (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
  743. DPRINT("probing disk change on unselected driven");
  744. DPRINT("drive=%d fdc=%d dor=%xn", drive, FDC(drive),
  745.        (unsigned int)FDCS->dor);
  746. }
  747. #endif
  749. #ifdef DCL_DEBUG
  750. if (UDP->flags & FD_DEBUG) {
  751. DPRINT("checking disk change line for drive %dn", drive);
  752. DPRINT("jiffies=%lun", jiffies);
  753. DPRINT("disk change line=%xn", fd_inb(FD_DIR) & 0x80);
  754. DPRINT("flags=%lxn", UDRS->flags);
  755. }
  756. #endif
  757. if (UDP->flags & FD_BROKEN_DCL)
  758. return UTESTF(FD_DISK_CHANGED);
  759. if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
  760. USETF(FD_VERIFY); /* verify write protection */
  761. if (UDRS->maxblock) {
  762. /* mark it changed */
  763. USETF(FD_DISK_CHANGED);
  764. }
  766. /* invalidate its geometry */
  767. if (UDRS->keep_data >= 0) {
  768. if ((UDP->flags & FTD_MSG) &&
  769.     current_type[drive] != NULL)
  770. DPRINT("Disk type is undefined after "
  771.        "disk changen");
  772. current_type[drive] = NULL;
  773. floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
  774. }
  776. /*USETF(FD_DISK_NEWCHANGE); */
  777. return 1;
  778. } else {
  779. UDRS->last_checked = jiffies;
  780. UCLEARF(FD_DISK_NEWCHANGE);
  781. }
  782. return 0;
  783. }
  785. static inline int is_selected(int dor, int unit)
  786. {
  787. return ((dor & (0x10 << unit)) && (dor & 3) == unit);
  788. }
  790. static int set_dor(int fdc, char mask, char data)
  791. {
  792. register unsigned char drive, unit, newdor, olddor;
  794. if (FDCS->address == -1)
  795. return -1;
  797. olddor = FDCS->dor;
  798. newdor = (olddor & mask) | data;
  799. if (newdor != olddor) {
  800. unit = olddor & 0x3;
  801. if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
  802. drive = REVDRIVE(fdc, unit);
  803. #ifdef DCL_DEBUG
  804. if (UDP->flags & FD_DEBUG) {
  805. DPRINT("calling disk change from set_dorn");
  806. }
  807. #endif
  808. disk_change(drive);
  809. }
  810. FDCS->dor = newdor;
  811. fd_outb(newdor, FD_DOR);
  813. unit = newdor & 0x3;
  814. if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
  815. drive = REVDRIVE(fdc, unit);
  816. UDRS->select_date = jiffies;
  817. }
  818. }
  819. /*
  820.  *      We should propagate failures to grab the resources back
  821.  *      nicely from here. Actually we ought to rewrite the fd
  822.  *      driver some day too.
  823.  */
  824. if (newdor & FLOPPY_MOTOR_MASK)
  825. floppy_grab_irq_and_dma();
  826. if (olddor & FLOPPY_MOTOR_MASK)
  827. floppy_release_irq_and_dma();
  828. return olddor;
  829. }
  831. static void twaddle(void)
  832. {
  833. if (DP->select_delay)
  834. return;
  835. fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
  836. fd_outb(FDCS->dor, FD_DOR);
  837. DRS->select_date = jiffies;
  838. }
  840. /* reset all driver information about the current fdc. This is needed after
  841.  * a reset, and after a raw command. */
  842. static void reset_fdc_info(int mode)
  843. {
  844. int drive;
  846. FDCS->spec1 = FDCS->spec2 = -1;
  847. FDCS->need_configure = 1;
  848. FDCS->perp_mode = 1;
  849. FDCS->rawcmd = 0;
  850. for (drive = 0; drive < N_DRIVE; drive++)
  851. if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
  852. UDRS->track = NEED_2_RECAL;
  853. }
  855. /* selects the fdc and drive, and enables the fdc's input/dma. */
  856. static void set_fdc(int drive)
  857. {
  858. if (drive >= 0 && drive < N_DRIVE) {
  859. fdc = FDC(drive);
  860. current_drive = drive;
  861. }
  862. if (fdc != 1 && fdc != 0) {
  863. printk("bad fdc valuen");
  864. return;
  865. }
  866. set_dor(fdc, ~0, 8);
  867. #if N_FDC > 1
  868. set_dor(1 - fdc, ~8, 0);
  869. #endif
  870. if (FDCS->rawcmd == 2)
  871. reset_fdc_info(1);
  872. if (fd_inb(FD_STATUS) != STATUS_READY)
  873. FDCS->reset = 1;
  874. }
  876. /* locks the driver */
  877. static int _lock_fdc(int drive, int interruptible, int line)
  878. {
  879. if (!usage_count) {
  880. printk(KERN_ERR
  881.        "Trying to lock fdc while usage count=0 at line %dn",
  882.        line);
  883. return -1;
  884. }
  885. if (floppy_grab_irq_and_dma() == -1)
  886. return -EBUSY;
  888. if (test_and_set_bit(0, &fdc_busy)) {
  889. DECLARE_WAITQUEUE(wait, current);
  890. add_wait_queue(&fdc_wait, &wait);
  892. for (;;) {
  893. set_current_state(TASK_INTERRUPTIBLE);
  895. if (!test_and_set_bit(0, &fdc_busy))
  896. break;
  898. schedule();
  900. if (!NO_SIGNAL) {
  901. remove_wait_queue(&fdc_wait, &wait);
  902. return -EINTR;
  903. }
  904. }
  906. set_current_state(TASK_RUNNING);
  907. remove_wait_queue(&fdc_wait, &wait);
  908. }
  909. command_status = FD_COMMAND_NONE;
  911. __reschedule_timeout(drive, "lock fdc", 0);
  912. set_fdc(drive);
  913. return 0;
  914. }
  916. #define lock_fdc(drive,interruptible) _lock_fdc(drive,interruptible, __LINE__)
  918. #define LOCK_FDC(drive,interruptible) 
  919. if (lock_fdc(drive,interruptible)) return -EINTR;
  921. /* unlocks the driver */
  922. static inline void unlock_fdc(void)
  923. {
  924. unsigned long flags;
  926. raw_cmd = NULL;
  927. if (!test_bit(0, &fdc_busy))
  928. DPRINT("FDC access conflict!n");
  930. if (do_floppy)
  931. DPRINT("device interrupt still active at FDC release: %p!n",
  932.        do_floppy);
  933. command_status = FD_COMMAND_NONE;
  934. spin_lock_irqsave(&floppy_lock, flags);
  935. del_timer(&fd_timeout);
  936. cont = NULL;
  937. clear_bit(0, &fdc_busy);
  938. if (elv_next_request(floppy_queue))
  939. do_fd_request(floppy_queue);
  940. spin_unlock_irqrestore(&floppy_lock, flags);
  941. floppy_release_irq_and_dma();
  942. wake_up(&fdc_wait);
  943. }
  945. /* switches the motor off after a given timeout */
  946. static void motor_off_callback(unsigned long nr)
  947. {
  948. unsigned char mask = ~(0x10 << UNIT(nr));
  950. set_dor(FDC(nr), mask, 0);
  951. }
  953. /* schedules motor off */
  954. static void floppy_off(unsigned int drive)
  955. {
  956. unsigned long volatile delta;
  957. register int fdc = FDC(drive);
  959. if (!(FDCS->dor & (0x10 << UNIT(drive))))
  960. return;
  962. del_timer(motor_off_timer + drive);
  964. /* make spindle stop in a position which minimizes spinup time
  965.  * next time */
  966. if (UDP->rps) {
  967. delta = jiffies - UDRS->first_read_date + HZ -
  968.     UDP->spindown_offset;
  969. delta = ((delta * UDP->rps) % HZ) / UDP->rps;
  970. motor_off_timer[drive].expires =
  971.     jiffies + UDP->spindown - delta;
  972. }
  973. add_timer(motor_off_timer + drive);
  974. }
  976. /*
  977.  * cycle through all N_DRIVE floppy drives, for disk change testing.
  978.  * stopping at current drive. This is done before any long operation, to
  979.  * be sure to have up to date disk change information.
  980.  */
  981. static void scandrives(void)
  982. {
  983. int i, drive, saved_drive;
  985. if (DP->select_delay)
  986. return;
  988. saved_drive = current_drive;
  989. for (i = 0; i < N_DRIVE; i++) {
  990. drive = (saved_drive + i + 1) % N_DRIVE;
  991. if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
  992. continue; /* skip closed drives */
  993. set_fdc(drive);
  994. if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
  995.       (0x10 << UNIT(drive))))
  996. /* switch the motor off again, if it was off to
  997.  * begin with */
  998. set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
  999. }
  1000. set_fdc(saved_drive);
  1001. }
  1003. static void empty(void)
  1004. {
  1005. }
  1007. static DECLARE_WORK(floppy_work, NULL, NULL);
  1009. static void schedule_bh(void (*handler) (void))
  1010. {
  1011. PREPARE_WORK(&floppy_work, (void (*)(void *))handler, NULL);
  1012. schedule_work(&floppy_work);
  1013. }
  1015. static DEFINE_TIMER(fd_timer, NULL, 0, 0);
  1017. static void cancel_activity(void)
  1018. {
  1019. unsigned long flags;
  1021. spin_lock_irqsave(&floppy_lock, flags);
  1022. do_floppy = NULL;
  1023. PREPARE_WORK(&floppy_work, (void *)empty, NULL);
  1024. del_timer(&fd_timer);
  1025. spin_unlock_irqrestore(&floppy_lock, flags);
  1026. }
  1028. /* this function makes sure that the disk stays in the drive during the
  1029.  * transfer */
  1030. static void fd_watchdog(void)
  1031. {
  1032. #ifdef DCL_DEBUG
  1033. if (DP->flags & FD_DEBUG) {
  1034. DPRINT("calling disk change from watchdogn");
  1035. }
  1036. #endif
  1038. if (disk_change(current_drive)) {
  1039. DPRINT("disk removed during i/on");
  1040. cancel_activity();
  1041. cont->done(0);
  1042. reset_fdc();
  1043. } else {
  1044. del_timer(&fd_timer);
  1045. fd_timer.function = (timeout_fn) fd_watchdog;
  1046. fd_timer.expires = jiffies + HZ / 10;
  1047. add_timer(&fd_timer);
  1048. }
  1049. }
  1051. static void main_command_interrupt(void)
  1052. {
  1053. del_timer(&fd_timer);
  1054. cont->interrupt();
  1055. }
  1057. /* waits for a delay (spinup or select) to pass */
  1058. static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
  1059. {
  1060. if (FDCS->reset) {
  1061. reset_fdc(); /* do the reset during sleep to win time
  1062.  * if we don't need to sleep, it's a good
  1063.  * occasion anyways */
  1064. return 1;
  1065. }
  1067. if ((signed)(jiffies - delay) < 0) {
  1068. del_timer(&fd_timer);
  1069. fd_timer.function = function;
  1070. fd_timer.expires = delay;
  1071. add_timer(&fd_timer);
  1072. return 1;
  1073. }
  1074. return 0;
  1075. }
  1077. static DEFINE_SPINLOCK(floppy_hlt_lock);
  1078. static int hlt_disabled;
  1079. static void floppy_disable_hlt(void)
  1080. {
  1081. unsigned long flags;
  1083. spin_lock_irqsave(&floppy_hlt_lock, flags);
  1084. if (!hlt_disabled) {
  1085. hlt_disabled = 1;
  1086. #ifdef HAVE_DISABLE_HLT
  1087. disable_hlt();
  1088. #endif
  1089. }
  1090. spin_unlock_irqrestore(&floppy_hlt_lock, flags);
  1091. }
  1093. static void floppy_enable_hlt(void)
  1094. {
  1095. unsigned long flags;
  1097. spin_lock_irqsave(&floppy_hlt_lock, flags);
  1098. if (hlt_disabled) {
  1099. hlt_disabled = 0;
  1100. #ifdef HAVE_DISABLE_HLT
  1101. enable_hlt();
  1102. #endif
  1103. }
  1104. spin_unlock_irqrestore(&floppy_hlt_lock, flags);
  1105. }
  1107. static void setup_DMA(void)
  1108. {
  1109. unsigned long f;
  1111. #ifdef FLOPPY_SANITY_CHECK
  1112. if (raw_cmd->length == 0) {
  1113. int i;
  1115. printk("zero dma transfer size:");
  1116. for (i = 0; i < raw_cmd->cmd_count; i++)
  1117. printk("%x,", raw_cmd->cmd[i]);
  1118. printk("n");
  1119. cont->done(0);
  1120. FDCS->reset = 1;
  1121. return;
  1122. }
  1123. if (((unsigned long)raw_cmd->kernel_data) % 512) {
  1124. printk("non aligned address: %pn", raw_cmd->kernel_data);
  1125. cont->done(0);
  1126. FDCS->reset = 1;
  1127. return;
  1128. }
  1129. #endif
  1130. f = claim_dma_lock();
  1131. fd_disable_dma();
  1132. #ifdef fd_dma_setup
  1133. if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
  1134.  (raw_cmd->flags & FD_RAW_READ) ?
  1135.  DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
  1136. release_dma_lock(f);
  1137. cont->done(0);
  1138. FDCS->reset = 1;
  1139. return;
  1140. }
  1141. release_dma_lock(f);
  1142. #else
  1143. fd_clear_dma_ff();
  1144. fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
  1145. fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
  1146. DMA_MODE_READ : DMA_MODE_WRITE);
  1147. fd_set_dma_addr(raw_cmd->kernel_data);
  1148. fd_set_dma_count(raw_cmd->length);
  1149. virtual_dma_port = FDCS->address;
  1150. fd_enable_dma();
  1151. release_dma_lock(f);
  1152. #endif
  1153. floppy_disable_hlt();
  1154. }
  1156. static void show_floppy(void);
  1158. /* waits until the fdc becomes ready */
  1159. static int wait_til_ready(void)
  1160. {
  1161. int counter, status;
  1162. if (FDCS->reset)
  1163. return -1;
  1164. for (counter = 0; counter < 10000; counter++) {
  1165. status = fd_inb(FD_STATUS);
  1166. if (status & STATUS_READY)
  1167. return status;
  1168. }
  1169. if (!initialising) {
  1170. DPRINT("Getstatus times out (%x) on fdc %dn", status, fdc);
  1171. show_floppy();
  1172. }
  1173. FDCS->reset = 1;
  1174. return -1;
  1175. }
  1177. /* sends a command byte to the fdc */
  1178. static int output_byte(char byte)
  1179. {
  1180. int status;
  1182. if ((status = wait_til_ready()) < 0)
  1183. return -1;
  1184. if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY) {
  1185. fd_outb(byte, FD_DATA);
  1186. #ifdef FLOPPY_SANITY_CHECK
  1187. output_log[output_log_pos].data = byte;
  1188. output_log[output_log_pos].status = status;
  1189. output_log[output_log_pos].jiffies = jiffies;
  1190. output_log_pos = (output_log_pos + 1) % OLOGSIZE;
  1191. #endif
  1192. return 0;
  1193. }
  1194. FDCS->reset = 1;
  1195. if (!initialising) {
  1196. DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%xn",
  1197.        byte, fdc, status);
  1198. show_floppy();
  1199. }
  1200. return -1;
  1201. }
  1203. #define LAST_OUT(x) if (output_byte(x)<0){ reset_fdc();return;}
  1205. /* gets the response from the fdc */
  1206. static int result(void)
  1207. {
  1208. int i, status = 0;
  1210. for (i = 0; i < MAX_REPLIES; i++) {
  1211. if ((status = wait_til_ready()) < 0)
  1212. break;
  1213. status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
  1214. if ((status & ~STATUS_BUSY) == STATUS_READY) {
  1215. #ifdef FLOPPY_SANITY_CHECK
  1216. resultjiffies = jiffies;
  1217. resultsize = i;
  1218. #endif
  1219. return i;
  1220. }
  1221. if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
  1222. reply_buffer[i] = fd_inb(FD_DATA);
  1223. else
  1224. break;
  1225. }
  1226. if (!initialising) {
  1227. DPRINT
  1228.     ("get result error. Fdc=%d Last status=%x Read bytes=%dn",
  1229.      fdc, status, i);
  1230. show_floppy();
  1231. }
  1232. FDCS->reset = 1;
  1233. return -1;
  1234. }
  1236. #define MORE_OUTPUT -2
  1237. /* does the fdc need more output? */
  1238. static int need_more_output(void)
  1239. {
  1240. int status;
  1241. if ((status = wait_til_ready()) < 0)
  1242. return -1;
  1243. if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY)
  1244. return MORE_OUTPUT;
  1245. return result();
  1246. }
  1248. /* Set perpendicular mode as required, based on data rate, if supported.
  1249.  * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
  1250.  */
  1251. static inline void perpendicular_mode(void)
  1252. {
  1253. unsigned char perp_mode;
  1255. if (raw_cmd->rate & 0x40) {
  1256. switch (raw_cmd->rate & 3) {
  1257. case 0:
  1258. perp_mode = 2;
  1259. break;
  1260. case 3:
  1261. perp_mode = 3;
  1262. break;
  1263. default:
  1264. DPRINT("Invalid data rate for perpendicular mode!n");
  1265. cont->done(0);
  1266. FDCS->reset = 1; /* convenient way to return to
  1267.  * redo without to much hassle (deep
  1268.  * stack et al. */
  1269. return;
  1270. }
  1271. } else
  1272. perp_mode = 0;
  1274. if (FDCS->perp_mode == perp_mode)
  1275. return;
  1276. if (FDCS->version >= FDC_82077_ORIG) {
  1277. output_byte(FD_PERPENDICULAR);
  1278. output_byte(perp_mode);
  1279. FDCS->perp_mode = perp_mode;
  1280. } else if (perp_mode) {
  1281. DPRINT("perpendicular mode not supported by this FDC.n");
  1282. }
  1283. } /* perpendicular_mode */
  1285. static int fifo_depth = 0xa;
  1286. static int no_fifo;
  1288. static int fdc_configure(void)
  1289. {
  1290. /* Turn on FIFO */
  1291. output_byte(FD_CONFIGURE);
  1292. if (need_more_output() != MORE_OUTPUT)
  1293. return 0;
  1294. output_byte(0);
  1295. output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
  1296. output_byte(0); /* pre-compensation from track
  1297.    0 upwards */
  1298. return 1;
  1299. }
  1301. #define NOMINAL_DTR 500
  1303. /* Issue a "SPECIFY" command to set the step rate time, head unload time,
  1304.  * head load time, and DMA disable flag to values needed by floppy.
  1305.  *
  1306.  * The value "dtr" is the data transfer rate in Kbps.  It is needed
  1307.  * to account for the data rate-based scaling done by the 82072 and 82077
  1308.  * FDC types.  This parameter is ignored for other types of FDCs (i.e.
  1309.  * 8272a).
  1310.  *
  1311.  * Note that changing the data transfer rate has a (probably deleterious)
  1312.  * effect on the parameters subject to scaling for 82072/82077 FDCs, so
  1313.  * fdc_specify is called again after each data transfer rate
  1314.  * change.
  1315.  *
  1316.  * srt: 1000 to 16000 in microseconds
  1317.  * hut: 16 to 240 milliseconds
  1318.  * hlt: 2 to 254 milliseconds
  1319.  *
  1320.  * These values are rounded up to the next highest available delay time.
  1321.  */
  1322. static void fdc_specify(void)
  1323. {
  1324. unsigned char spec1, spec2;
  1325. unsigned long srt, hlt, hut;
  1326. unsigned long dtr = NOMINAL_DTR;
  1327. unsigned long scale_dtr = NOMINAL_DTR;
  1328. int hlt_max_code = 0x7f;
  1329. int hut_max_code = 0xf;
  1331. if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
  1332. fdc_configure();
  1333. FDCS->need_configure = 0;
  1334. /*DPRINT("FIFO enabledn"); */
  1335. }
  1337. switch (raw_cmd->rate & 0x03) {
  1338. case 3:
  1339. dtr = 1000;
  1340. break;
  1341. case 1:
  1342. dtr = 300;
  1343. if (FDCS->version >= FDC_82078) {
  1344. /* chose the default rate table, not the one
  1345.  * where 1 = 2 Mbps */
  1346. output_byte(FD_DRIVESPEC);
  1347. if (need_more_output() == MORE_OUTPUT) {
  1348. output_byte(UNIT(current_drive));
  1349. output_byte(0xc0);
  1350. }
  1351. }
  1352. break;
  1353. case 2:
  1354. dtr = 250;
  1355. break;
  1356. }
  1358. if (FDCS->version >= FDC_82072) {
  1359. scale_dtr = dtr;
  1360. hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
  1361. hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
  1362. }
  1364. /* Convert step rate from microseconds to milliseconds and 4 bits */
  1365. srt = 16 - (DP->srt * scale_dtr / 1000 + NOMINAL_DTR - 1) / NOMINAL_DTR;
  1366. if (slow_floppy) {
  1367. srt = srt / 4;
  1368. }
  1369. SUPBOUND(srt, 0xf);
  1370. INFBOUND(srt, 0);
  1372. hlt = (DP->hlt * scale_dtr / 2 + NOMINAL_DTR - 1) / NOMINAL_DTR;
  1373. if (hlt < 0x01)
  1374. hlt = 0x01;
  1375. else if (hlt > 0x7f)
  1376. hlt = hlt_max_code;
  1378. hut = (DP->hut * scale_dtr / 16 + NOMINAL_DTR - 1) / NOMINAL_DTR;
  1379. if (hut < 0x1)
  1380. hut = 0x1;
  1381. else if (hut > 0xf)
  1382. hut = hut_max_code;
  1384. spec1 = (srt << 4) | hut;
  1385. spec2 = (hlt << 1) | (use_virtual_dma & 1);
  1387. /* If these parameters did not change, just return with success */
  1388. if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
  1389. /* Go ahead and set spec1 and spec2 */
  1390. output_byte(FD_SPECIFY);
  1391. output_byte(FDCS->spec1 = spec1);
  1392. output_byte(FDCS->spec2 = spec2);
  1393. }
  1394. } /* fdc_specify */
  1396. /* Set the FDC's data transfer rate on behalf of the specified drive.
  1397.  * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
  1398.  * of the specify command (i.e. using the fdc_specify function).
  1399.  */
  1400. static int fdc_dtr(void)
  1401. {
  1402. /* If data rate not already set to desired value, set it. */
  1403. if ((raw_cmd->rate & 3) == FDCS->dtr)
  1404. return 0;
  1406. /* Set dtr */
  1407. fd_outb(raw_cmd->rate & 3, FD_DCR);
  1409. /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
  1410.  * need a stabilization period of several milliseconds to be
  1411.  * enforced after data rate changes before R/W operations.
  1412.  * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
  1413.  */
  1414. FDCS->dtr = raw_cmd->rate & 3;
  1415. return (fd_wait_for_completion(jiffies + 2UL * HZ / 100,
  1416.        (timeout_fn) floppy_ready));
  1417. } /* fdc_dtr */
  1419. static void tell_sector(void)
  1420. {
  1421. printk(": track %d, head %d, sector %d, size %d",
  1422.        R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
  1423. } /* tell_sector */
  1425. /*
  1426.  * OK, this error interpreting routine is called after a
  1427.  * DMA read/write has succeeded
  1428.  * or failed, so we check the results, and copy any buffers.
  1429.  * hhb: Added better error reporting.
  1430.  * ak: Made this into a separate routine.
  1431.  */
  1432. static int interpret_errors(void)
  1433. {
  1434. char bad;
  1436. if (inr != 7) {
  1437. DPRINT("-- FDC reply error");
  1438. FDCS->reset = 1;
  1439. return 1;
  1440. }
  1442. /* check IC to find cause of interrupt */
  1443. switch (ST0 & ST0_INTR) {
  1444. case 0x40: /* error occurred during command execution */
  1445. if (ST1 & ST1_EOC)
  1446. return 0; /* occurs with pseudo-DMA */
  1447. bad = 1;
  1448. if (ST1 & ST1_WP) {
  1449. DPRINT("Drive is write protectedn");
  1450. CLEARF(FD_DISK_WRITABLE);
  1451. cont->done(0);
  1452. bad = 2;
  1453. } else if (ST1 & ST1_ND) {
  1454. SETF(FD_NEED_TWADDLE);
  1455. } else if (ST1 & ST1_OR) {
  1456. if (DP->flags & FTD_MSG)
  1457. DPRINT("Over/Underrun - retryingn");
  1458. bad = 0;
  1459. } else if (*errors >= DP->max_errors.reporting) {
  1460. DPRINT("");
  1461. if (ST0 & ST0_ECE) {
  1462. printk("Recalibrate failed!");
  1463. } else if (ST2 & ST2_CRC) {
  1464. printk("data CRC error");
  1465. tell_sector();
  1466. } else if (ST1 & ST1_CRC) {
  1467. printk("CRC error");
  1468. tell_sector();
  1469. } else if ((ST1 & (ST1_MAM | ST1_ND))
  1470.    || (ST2 & ST2_MAM)) {
  1471. if (!probing) {
  1472. printk("sector not found");
  1473. tell_sector();
  1474. } else
  1475. printk("probe failed...");
  1476. } else if (ST2 & ST2_WC) { /* seek error */
  1477. printk("wrong cylinder");
  1478. } else if (ST2 & ST2_BC) { /* cylinder marked as bad */
  1479. printk("bad cylinder");
  1480. } else {
  1481. printk
  1482.     ("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
  1483.      ST0, ST1, ST2);
  1484. tell_sector();
  1485. }
  1486. printk("n");
  1488. }
  1489. if (ST2 & ST2_WC || ST2 & ST2_BC)
  1490. /* wrong cylinder => recal */
  1491. DRS->track = NEED_2_RECAL;
  1492. return bad;
  1493. case 0x80: /* invalid command given */
  1494. DPRINT("Invalid FDC command given!n");
  1495. cont->done(0);
  1496. return 2;
  1497. case 0xc0:
  1498. DPRINT("Abnormal termination caused by pollingn");
  1499. cont->error();
  1500. return 2;
  1501. default: /* (0) Normal command termination */
  1502. return 0;
  1503. }
  1504. }
  1506. /*
  1507.  * This routine is called when everything should be correctly set up
  1508.  * for the transfer (i.e. floppy motor is on, the correct floppy is
  1509.  * selected, and the head is sitting on the right track).
  1510.  */
  1511. static void setup_rw_floppy(void)
  1512. {
  1513. int i, r, flags, dflags;
  1514. unsigned long ready_date;
  1515. timeout_fn function;
  1517. flags = raw_cmd->flags;
  1518. if (flags & (FD_RAW_READ | FD_RAW_WRITE))
  1519. flags |= FD_RAW_INTR;
  1521. if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
  1522. ready_date = DRS->spinup_date + DP->spinup;
  1523. /* If spinup will take a long time, rerun scandrives
  1524.  * again just before spinup completion. Beware that
  1525.  * after scandrives, we must again wait for selection.
  1526.  */
  1527. if ((signed)(ready_date - jiffies) > DP->select_delay) {
  1528. ready_date -= DP->select_delay;
  1529. function = (timeout_fn) floppy_start;
  1530. } else
  1531. function = (timeout_fn) setup_rw_floppy;
  1533. /* wait until the floppy is spinning fast enough */
  1534. if (fd_wait_for_completion(ready_date, function))
  1535. return;
  1536. }
  1537. dflags = DRS->flags;
  1539. if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
  1540. setup_DMA();
  1542. if (flags & FD_RAW_INTR)
  1543. do_floppy = main_command_interrupt;
  1545. r = 0;
  1546. for (i = 0; i < raw_cmd->cmd_count; i++)
  1547. r |= output_byte(raw_cmd->cmd[i]);
  1549. debugt("rw_command: ");
  1551. if (r) {
  1552. cont->error();
  1553. reset_fdc();
  1554. return;
  1555. }
  1557. if (!(flags & FD_RAW_INTR)) {
  1558. inr = result();
  1559. cont->interrupt();
  1560. } else if (flags & FD_RAW_NEED_DISK)
  1561. fd_watchdog();
  1562. }
  1564. static int blind_seek;
  1566. /*
  1567.  * This is the routine called after every seek (or recalibrate) interrupt
  1568.  * from the floppy controller.
  1569.  */
  1570. static void seek_interrupt(void)
  1571. {
  1572. debugt("seek interrupt:");
  1573. if (inr != 2 || (ST0 & 0xF8) != 0x20) {
  1574. DPRINT("seek failedn");
  1575. DRS->track = NEED_2_RECAL;
  1576. cont->error();
  1577. cont->redo();
  1578. return;
  1579. }
  1580. if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
  1581. #ifdef DCL_DEBUG
  1582. if (DP->flags & FD_DEBUG) {
  1583. DPRINT
  1584.     ("clearing NEWCHANGE flag because of effective seekn");
  1585. DPRINT("jiffies=%lun", jiffies);
  1586. }
  1587. #endif
  1588. CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
  1589. DRS->select_date = jiffies;
  1590. }
  1591. DRS->track = ST1;
  1592. floppy_ready();
  1593. }
  1595. static void check_wp(void)
  1596. {
  1597. if (TESTF(FD_VERIFY)) {
  1598. /* check write protection */
  1599. output_byte(FD_GETSTATUS);
  1600. output_byte(UNIT(current_drive));
  1601. if (result() != 1) {
  1602. FDCS->reset = 1;
  1603. return;
  1604. }
  1605. CLEARF(FD_VERIFY);
  1606. CLEARF(FD_NEED_TWADDLE);
  1607. #ifdef DCL_DEBUG
  1608. if (DP->flags & FD_DEBUG) {
  1609. DPRINT("checking whether disk is write protectedn");
  1610. DPRINT("wp=%xn", ST3 & 0x40);
  1611. }
  1612. #endif
  1613. if (!(ST3 & 0x40))
  1614. SETF(FD_DISK_WRITABLE);
  1615. else
  1616. CLEARF(FD_DISK_WRITABLE);
  1617. }
  1618. }
  1620. static void seek_floppy(void)
  1621. {
  1622. int track;
  1624. blind_seek = 0;
  1626. #ifdef DCL_DEBUG
  1627. if (DP->flags & FD_DEBUG) {
  1628. DPRINT("calling disk change from seekn");
  1629. }
  1630. #endif
  1632. if (!TESTF(FD_DISK_NEWCHANGE) &&
  1633.     disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
  1634. /* the media changed flag should be cleared after the seek.
  1635.  * If it isn't, this means that there is really no disk in
  1636.  * the drive.
  1637.  */
  1638. SETF(FD_DISK_CHANGED);
  1639. cont->done(0);
  1640. cont->redo();
  1641. return;
  1642. }
  1643. if (DRS->track <= NEED_1_RECAL) {
  1644. recalibrate_floppy();
  1645. return;
  1646. } else if (TESTF(FD_DISK_NEWCHANGE) &&
  1647.    (raw_cmd->flags & FD_RAW_NEED_DISK) &&
  1648.    (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
  1649. /* we seek to clear the media-changed condition. Does anybody
  1650.  * know a more elegant way, which works on all drives? */
  1651. if (raw_cmd->track)
  1652. track = raw_cmd->track - 1;
  1653. else {
  1654. if (DP->flags & FD_SILENT_DCL_CLEAR) {
  1655. set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
  1656. blind_seek = 1;
  1657. raw_cmd->flags |= FD_RAW_NEED_SEEK;
  1658. }
  1659. track = 1;
  1660. }
  1661. } else {
  1662. check_wp();
  1663. if (raw_cmd->track != DRS->track &&
  1664.     (raw_cmd->flags & FD_RAW_NEED_SEEK))
  1665. track = raw_cmd->track;
  1666. else {
  1667. setup_rw_floppy();
  1668. return;
  1669. }
  1670. }
  1672. do_floppy = seek_interrupt;
  1673. output_byte(FD_SEEK);
  1674. output_byte(UNIT(current_drive));
  1675. LAST_OUT(track);
  1676. debugt("seek command:");
  1677. }
  1679. static void recal_interrupt(void)
  1680. {
  1681. debugt("recal interrupt:");
  1682. if (inr != 2)
  1683. FDCS->reset = 1;
  1684. else if (ST0 & ST0_ECE) {
  1685. switch (DRS->track) {
  1686. case NEED_1_RECAL:
  1687. debugt("recal interrupt need 1 recal:");
  1688. /* after a second recalibrate, we still haven't
  1689.  * reached track 0. Probably no drive. Raise an
  1690.  * error, as failing immediately might upset
  1691.  * computers possessed by the Devil :-) */
  1692. cont->error();
  1693. cont->redo();
  1694. return;
  1695. case NEED_2_RECAL:
  1696. debugt("recal interrupt need 2 recal:");
  1697. /* If we already did a recalibrate,
  1698.  * and we are not at track 0, this
  1699.  * means we have moved. (The only way
  1700.  * not to move at recalibration is to
  1701.  * be already at track 0.) Clear the
  1702.  * new change flag */
  1703. #ifdef DCL_DEBUG
  1704. if (DP->flags & FD_DEBUG) {
  1705. DPRINT
  1706.     ("clearing NEWCHANGE flag because of second recalibraten");
  1707. }
  1708. #endif
  1710. CLEARF(FD_DISK_NEWCHANGE);
  1711. DRS->select_date = jiffies;
  1712. /* fall through */
  1713. default:
  1714. debugt("recal interrupt default:");
  1715. /* Recalibrate moves the head by at
  1716.  * most 80 steps. If after one
  1717.  * recalibrate we don't have reached
  1718.  * track 0, this might mean that we
  1719.  * started beyond track 80.  Try
  1720.  * again.  */
  1721. DRS->track = NEED_1_RECAL;
  1722. break;
  1723. }
  1724. } else
  1725. DRS->track = ST1;
  1726. floppy_ready();
  1727. }
  1729. static void print_result(char *message, int inr)
  1730. {
  1731. int i;
  1733. DPRINT("%s ", message);
  1734. if (inr >= 0)
  1735. for (i = 0; i < inr; i++)
  1736. printk("repl[%d]=%x ", i, reply_buffer[i]);
  1737. printk("n");
  1738. }
  1740. /* interrupt handler. Note that this can be called externally on the Sparc */
  1741. irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  1742. {
  1743. void (*handler) (void) = do_floppy;
  1744. int do_print;
  1745. unsigned long f;
  1747. lasthandler = handler;
  1748. interruptjiffies = jiffies;
  1750. f = claim_dma_lock();
  1751. fd_disable_dma();
  1752. release_dma_lock(f);
  1754. floppy_enable_hlt();
  1755. do_floppy = NULL;
  1756. if (fdc >= N_FDC || FDCS->address == -1) {
  1757. /* we don't even know which FDC is the culprit */
  1758. printk("DOR0=%xn", fdc_state[0].dor);
  1759. printk("floppy interrupt on bizarre fdc %dn", fdc);
  1760. printk("handler=%pn", handler);
  1761. is_alive("bizarre fdc");
  1762. return IRQ_NONE;
  1763. }
  1765. FDCS->reset = 0;
  1766. /* We have to clear the reset flag here, because apparently on boxes
  1767.  * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
  1768.  * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
  1769.  * emission of the SENSEI's.
  1770.  * It is OK to emit floppy commands because we are in an interrupt
  1771.  * handler here, and thus we have to fear no interference of other
  1772.  * activity.
  1773.  */
  1775. do_print = !handler && print_unex && !initialising;
  1777. inr = result();
  1778. if (do_print)
  1779. print_result("unexpected interrupt", inr);
  1780. if (inr == 0) {
  1781. int max_sensei = 4;
  1782. do {
  1783. output_byte(FD_SENSEI);
  1784. inr = result();
  1785. if (do_print)
  1786. print_result("sensei", inr);
  1787. max_sensei--;
  1788. } while ((ST0 & 0x83) != UNIT(current_drive) && inr == 2
  1789.  && max_sensei);
  1790. }
  1791. if (!handler) {
  1792. FDCS->reset = 1;
  1793. return IRQ_NONE;
  1794. }
  1795. schedule_bh(handler);
  1796. is_alive("normal interrupt end");
  1798. /* FIXME! Was it really for us? */
  1799. return IRQ_HANDLED;
  1800. }
  1802. static void recalibrate_floppy(void)
  1803. {
  1804. debugt("recalibrate floppy:");
  1805. do_floppy = recal_interrupt;
  1806. output_byte(FD_RECALIBRATE);
  1807. LAST_OUT(UNIT(current_drive));
  1808. }
  1810. /*
  1811.  * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
  1812.  */
  1813. static void reset_interrupt(void)
  1814. {
  1815. debugt("reset interrupt:");
  1816. result(); /* get the status ready for set_fdc */
  1817. if (FDCS->reset) {
  1818. printk("reset set in interrupt, calling %pn", cont->error);
  1819. cont->error(); /* a reset just after a reset. BAD! */
  1820. }
  1821. cont->redo();
  1822. }
  1824. /*
  1825.  * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
  1826.  * or by setting the self clearing bit 7 of STATUS (newer FDCs)
  1827.  */
  1828. static void reset_fdc(void)
  1829. {
  1830. unsigned long flags;
  1832. do_floppy = reset_interrupt;
  1833. FDCS->reset = 0;
  1834. reset_fdc_info(0);
  1836. /* Pseudo-DMA may intercept 'reset finished' interrupt.  */
  1837. /* Irrelevant for systems with true DMA (i386).          */
  1839. flags = claim_dma_lock();
  1840. fd_disable_dma();
  1841. release_dma_lock(flags);
  1843. if (FDCS->version >= FDC_82072A)
  1844. fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
  1845. else {
  1846. fd_outb(FDCS->dor & ~0x04, FD_DOR);
  1847. udelay(FD_RESET_DELAY);
  1848. fd_outb(FDCS->dor, FD_DOR);
  1849. }
  1850. }
  1852. static void show_floppy(void)
  1853. {
  1854. int i;
  1856. printk("n");
  1857. printk("floppy driver staten");
  1858. printk("-------------------n");
  1859. printk("now=%lu last interrupt=%lu diff=%lu last called handler=%pn",
  1860.        jiffies, interruptjiffies, jiffies - interruptjiffies,
  1861.        lasthandler);
  1863. #ifdef FLOPPY_SANITY_CHECK
  1864. printk("timeout_message=%sn", timeout_message);
  1865. printk("last output bytes:n");
  1866. for (i = 0; i < OLOGSIZE; i++)
  1867. printk("%2x %2x %lun",
  1868.        output_log[(i + output_log_pos) % OLOGSIZE].data,
  1869.        output_log[(i + output_log_pos) % OLOGSIZE].status,
  1870.        output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
  1871. printk("last result at %lun", resultjiffies);
  1872. printk("last redo_fd_request at %lun", lastredo);
  1873. for (i = 0; i < resultsize; i++) {
  1874. printk("%2x ", reply_buffer[i]);
  1875. }
  1876. printk("n");
  1877. #endif
  1879. printk("status=%xn", fd_inb(FD_STATUS));
  1880. printk("fdc_busy=%lun", fdc_busy);
  1881. if (do_floppy)
  1882. printk("do_floppy=%pn", do_floppy);
  1883. if (floppy_work.pending)
  1884. printk("floppy_work.func=%pn", floppy_work.func);
  1885. if (timer_pending(&fd_timer))
  1886. printk("fd_timer.function=%pn", fd_timer.function);
  1887. if (timer_pending(&fd_timeout)) {
  1888. printk("timer_function=%pn", fd_timeout.function);
  1889. printk("expires=%lun", fd_timeout.expires - jiffies);
  1890. printk("now=%lun", jiffies);
  1891. }
  1892. printk("cont=%pn", cont);
  1893. printk("current_req=%pn", current_req);
  1894. printk("command_status=%dn", command_status);
  1895. printk("n");
  1896. }
  1898. static void floppy_shutdown(unsigned long data)
  1899. {
  1900. unsigned long flags;
  1902. if (!initialising)
  1903. show_floppy();
  1904. cancel_activity();
  1906. floppy_enable_hlt();
  1908. flags = claim_dma_lock();
  1909. fd_disable_dma();
  1910. release_dma_lock(flags);
  1912. /* avoid dma going to a random drive after shutdown */
  1914. if (!initialising)
  1915. DPRINT("floppy timeout calledn");
  1916. FDCS->reset = 1;
  1917. if (cont) {
  1918. cont->done(0);
  1919. cont->redo(); /* this will recall reset when needed */
  1920. } else {
  1921. printk("no cont in shutdown!n");
  1922. process_fd_request();
  1923. }
  1924. is_alive("floppy shutdown");
  1925. }
  1927. /*typedef void (*timeout_fn)(unsigned long);*/
  1929. /* start motor, check media-changed condition and write protection */
  1930. static int start_motor(void (*function) (void))
  1931. {
  1932. int mask, data;
  1934. mask = 0xfc;
  1935. data = UNIT(current_drive);
  1936. if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
  1937. if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
  1938. set_debugt();
  1939. /* no read since this drive is running */
  1940. DRS->first_read_date = 0;
  1941. /* note motor start time if motor is not yet running */
  1942. DRS->spinup_date = jiffies;
  1943. data |= (0x10 << UNIT(current_drive));
  1944. }
  1945. } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
  1946. mask &= ~(0x10 << UNIT(current_drive));
  1948. /* starts motor and selects floppy */
  1949. del_timer(motor_off_timer + current_drive);
  1950. set_dor(fdc, mask, data);
  1952. /* wait_for_completion also schedules reset if needed. */
  1953. return (fd_wait_for_completion(DRS->select_date + DP->select_delay,
  1954.        (timeout_fn) function));
  1955. }
  1957. static void floppy_ready(void)
  1958. {
  1959. CHECK_RESET;
  1960. if (start_motor(floppy_ready))
  1961. return;
  1962. if (fdc_dtr())
  1963. return;
  1965. #ifdef DCL_DEBUG
  1966. if (DP->flags & FD_DEBUG) {
  1967. DPRINT("calling disk change from floppy_readyn");
  1968. }
  1969. #endif
  1970. if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
  1971.     disk_change(current_drive) && !DP->select_delay)
  1972. twaddle(); /* this clears the dcl on certain drive/controller
  1973.  * combinations */
  1975. #ifdef fd_chose_dma_mode
  1976. if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
  1977. unsigned long flags = claim_dma_lock();
  1978. fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
  1979. release_dma_lock(flags);
  1980. }
  1981. #endif
  1983. if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
  1984. perpendicular_mode();
  1985. fdc_specify(); /* must be done here because of hut, hlt ... */
  1986. seek_floppy();
  1987. } else {
  1988. if ((raw_cmd->flags & FD_RAW_READ) ||
  1989.     (raw_cmd->flags & FD_RAW_WRITE))
  1990. fdc_specify();
  1991. setup_rw_floppy();
  1992. }
  1993. }
  1995. static void floppy_start(void)
  1996. {
  1997. reschedule_timeout(current_reqD, "floppy start", 0);
  1999. scandrives();
  2000. #ifdef DCL_DEBUG
  2001. if (DP->flags & FD_DEBUG) {
  2002. DPRINT("setting NEWCHANGE in floppy_startn");
  2003. }
  2004. #endif
  2005. SETF(FD_DISK_NEWCHANGE);
  2006. floppy_ready();
  2007. }
  2009. /*
  2010.  * ========================================================================
  2011.  * here ends the bottom half. Exported routines are:
  2012.  * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
  2013.  * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
  2014.  * Initialization also uses output_byte, result, set_dor, floppy_interrupt
  2015.  * and set_dor.
  2016.  * ========================================================================
  2017.  */
  2018. /*
  2019.  * General purpose continuations.
  2020.  * ==============================
  2021.  */
  2023. static void do_wakeup(void)
  2024. {
  2025. reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
  2026. cont = NULL;
  2027. command_status += 2;
  2028. wake_up(&command_done);
  2029. }
  2031. static struct cont_t wakeup_cont = {
  2032. .interrupt = empty,
  2033. .redo = do_wakeup,
  2034. .error = empty,
  2035. .done = (done_f) empty
  2036. };
  2038. static struct cont_t intr_cont = {
  2039. .interrupt = empty,
  2040. .redo = process_fd_request,
  2041. .error = empty,
  2042. .done = (done_f) empty
  2043. };
  2045. static int wait_til_done(void (*handler) (void), int interruptible)
  2046. {
  2047. int ret;
  2049. schedule_bh(handler);
  2051. if (command_status < 2 && NO_SIGNAL) {
  2052. DECLARE_WAITQUEUE(wait, current);
  2054. add_wait_queue(&command_done, &wait);
  2055. for (;;) {
  2056. set_current_state(interruptible ?
  2057.   TASK_INTERRUPTIBLE :
  2058.   TASK_UNINTERRUPTIBLE);
  2060. if (command_status >= 2 || !NO_SIGNAL)
  2061. break;
  2063. is_alive("wait_til_done");
  2065. schedule();
  2066. }
  2068. set_current_state(TASK_RUNNING);
  2069. remove_wait_queue(&command_done, &wait);
  2070. }
  2072. if (command_status < 2) {
  2073. cancel_activity();
  2074. cont = &intr_cont;
  2075. reset_fdc();
  2076. return -EINTR;
  2077. }
  2079. if (FDCS->reset)
  2080. command_status = FD_COMMAND_ERROR;
  2081. if (command_status == FD_COMMAND_OKAY)
  2082. ret = 0;
  2083. else
  2084. ret = -EIO;
  2085. command_status = FD_COMMAND_NONE;
  2086. return ret;
  2087. }
  2089. static void generic_done(int result)
  2090. {
  2091. command_status = result;
  2092. cont = &wakeup_cont;
  2093. }
  2095. static void generic_success(void)
  2096. {
  2097. cont->done(1);
  2098. }
  2100. static void generic_failure(void)
  2101. {
  2102. cont->done(0);
  2103. }
  2105. static void success_and_wakeup(void)
  2106. {
  2107. generic_success();
  2108. cont->redo();
  2109. }
  2111. /*
  2112.  * formatting and rw support.
  2113.  * ==========================
  2114.  */
  2116. static int next_valid_format(void)
  2117. {
  2118. int probed_format;
  2120. probed_format = DRS->probed_format;
  2121. while (1) {
  2122. if (probed_format >= 8 || !DP->autodetect[probed_format]) {
  2123. DRS->probed_format = 0;
  2124. return 1;
  2125. }
  2126. if (floppy_type[DP->autodetect[probed_format]].sect) {
  2127. DRS->probed_format = probed_format;
  2128. return 0;
  2129. }
  2130. probed_format++;
  2131. }
  2132. }
  2134. static void bad_flp_intr(void)
  2135. {
  2136. int err_count;
  2138. if (probing) {
  2139. DRS->probed_format++;
  2140. if (!next_valid_format())
  2141. return;
  2142. }
  2143. err_count = ++(*errors);
  2144. INFBOUND(DRWE->badness, err_count);
  2145. if (err_count > DP->max_errors.abort)
  2146. cont->done(0);
  2147. if (err_count > DP->max_errors.reset)
  2148. FDCS->reset = 1;
  2149. else if (err_count > DP->max_errors.recal)
  2150. DRS->track = NEED_2_RECAL;
  2151. }
  2153. static void set_floppy(int drive)
  2154. {
  2155. int type = ITYPE(UDRS->fd_device);
  2156. if (type)
  2157. _floppy = floppy_type + type;
  2158. else
  2159. _floppy = current_type[drive];
  2160. }
  2162. /*
  2163.  * formatting support.
  2164.  * ===================
  2165.  */
  2166. static void format_interrupt(void)
  2167. {
  2168. switch (interpret_errors()) {
  2169. case 1:
  2170. cont->error();
  2171. case 2:
  2172. break;
  2173. case 0:
  2174. cont->done(1);
  2175. }
  2176. cont->redo();
  2177. }
  2179. #define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
  2180. #define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80) >>1))
  2181. #define CT(x) ((x) | 0xc0)
  2182. static void setup_format_params(int track)
  2183. {
  2184. struct fparm {
  2185. unsigned char track, head, sect, size;
  2186. } *here = (struct fparm *)floppy_track_buffer;
  2187. int il, n;
  2188. int count, head_shift, track_shift;
  2190. raw_cmd = &default_raw_cmd;
  2191. raw_cmd->track = track;
  2193. raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
  2194.     FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
  2195. raw_cmd->rate = _floppy->rate & 0x43;
  2196. raw_cmd->cmd_count = NR_F;
  2197. COMMAND = FM_MODE(_floppy, FD_FORMAT);
  2198. DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
  2199. F_SIZECODE = FD_SIZECODE(_floppy);
  2200. F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
  2201. F_GAP = _floppy->fmt_gap;
  2202. F_FILL = FD_FILL_BYTE;
  2204. raw_cmd->kernel_data = floppy_track_buffer;
  2205. raw_cmd->length = 4 * F_SECT_PER_TRACK;
  2207. /* allow for about 30ms for data transport per track */
  2208. head_shift = (F_SECT_PER_TRACK + 5) / 6;
  2210. /* a ``cylinder'' is two tracks plus a little stepping time */
  2211. track_shift = 2 * head_shift + 3;
  2213. /* position of logical sector 1 on this track */
  2214. n = (track_shift * format_req.track + head_shift * format_req.head)
  2215.     % F_SECT_PER_TRACK;
  2217. /* determine interleave */
  2218. il = 1;
  2219. if (_floppy->fmt_gap < 0x22)
  2220. il++;
  2222. /* initialize field */
  2223. for (count = 0; count < F_SECT_PER_TRACK; ++count) {
  2224. here[count].track = format_req.track;
  2225. here[count].head = format_req.head;
  2226. here[count].sect = 0;
  2227. here[count].size = F_SIZECODE;
  2228. }
  2229. /* place logical sectors */
  2230. for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
  2231. here[n].sect = count;
  2232. n = (n + il) % F_SECT_PER_TRACK;
  2233. if (here[n].sect) { /* sector busy, find next free sector */
  2234. ++n;
  2235. if (n >= F_SECT_PER_TRACK) {
  2236. n -= F_SECT_PER_TRACK;
  2237. while (here[n].sect)
  2238. ++n;
  2239. }
  2240. }
  2241. }
  2242. if (_floppy->stretch & FD_ZEROBASED) {
  2243. for (count = 0; count < F_SECT_PER_TRACK; count++)
  2244. here[count].sect--;
  2245. }
  2246. }
  2248. static void redo_format(void)
  2249. {
  2250. buffer_track = -1;
  2251. setup_format_params(format_req.track << STRETCH(_floppy));
  2252. floppy_start();
  2253. debugt("queue format request");
  2254. }
  2256. static struct cont_t format_cont = {
  2257. .interrupt = format_interrupt,
  2258. .redo = redo_format,
  2259. .error = bad_flp_intr,
  2260. .done = generic_done
  2261. };
  2263. static int do_format(int drive, struct format_descr *tmp_format_req)
  2264. {
  2265. int ret;
  2267. LOCK_FDC(drive, 1);
  2268. set_floppy(drive);
  2269. if (!_floppy ||
  2270.     _floppy->track > DP->tracks ||
  2271.     tmp_format_req->track >= _floppy->track ||
  2272.     tmp_format_req->head >= _floppy->head ||
  2273.     (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
  2274.     !_floppy->fmt_gap) {
  2275. process_fd_request();
  2276. return -EINVAL;
  2277. }
  2278. format_req = *tmp_format_req;
  2279. format_errors = 0;
  2280. cont = &format_cont;
  2281. errors = &format_errors;
  2282. IWAIT(redo_format);
  2283. process_fd_request();
  2284. return ret;
  2285. }
  2287. /*
  2288.  * Buffer read/write and support
  2289.  * =============================
  2290.  */
  2292. static void floppy_end_request(struct request *req, int uptodate)
  2293. {
  2294. unsigned int nr_sectors = current_count_sectors;
  2296. /* current_count_sectors can be zero if transfer failed */
  2297. if (!uptodate)
  2298. nr_sectors = req->current_nr_sectors;
  2299. if (end_that_request_first(req, uptodate, nr_sectors))
  2300. return;
  2301. add_disk_randomness(req->rq_disk);
  2302. floppy_off((long)req->rq_disk->private_data);
  2303. blkdev_dequeue_request(req);
  2304. end_that_request_last(req);
  2306. /* We're done with the request */
  2307. current_req = NULL;
  2308. }
  2310. /* new request_done. Can handle physical sectors which are smaller than a
  2311.  * logical buffer */
  2312. static void request_done(int uptodate)
  2313. {
  2314. struct request_queue *q = floppy_queue;
  2315. struct request *req = current_req;
  2316. unsigned long flags;
  2317. int block;
  2319. probing = 0;
  2320. reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
  2322. if (!req) {
  2323. printk("floppy.c: no request in request_donen");
  2324. return;
  2325. }
  2327. if (uptodate) {
  2328. /* maintain values for invalidation on geometry
  2329.  * change */
  2330. block = current_count_sectors + req->sector;
  2331. INFBOUND(DRS->maxblock, block);
  2332. if (block > _floppy->sect)
  2333. DRS->maxtrack = 1;
  2335. /* unlock chained buffers */
  2336. spin_lock_irqsave(q->queue_lock, flags);
  2337. floppy_end_request(req, 1);
  2338. spin_unlock_irqrestore(q->queue_lock, flags);
  2339. } else {
  2340. if (rq_data_dir(req) == WRITE) {
  2341. /* record write error information */
  2342. DRWE->write_errors++;
  2343. if (DRWE->write_errors == 1) {
  2344. DRWE->first_error_sector = req->sector;
  2345. DRWE->first_error_generation = DRS->generation;
  2346. }
  2347. DRWE->last_error_sector = req->sector;
  2348. DRWE->last_error_generation = DRS->generation;
  2349. }
  2350. spin_lock_irqsave(q->queue_lock, flags);
  2351. floppy_end_request(req, 0);
  2352. spin_unlock_irqrestore(q->queue_lock, flags);
  2353. }
  2354. }
  2356. /* Interrupt handler evaluating the result of the r/w operation */
  2357. static void rw_interrupt(void)
  2358. {
  2359. int nr_sectors, ssize, eoc, heads;
  2361. if (R_HEAD >= 2) {
  2362. /* some Toshiba floppy controllers occasionnally seem to
  2363.  * return bogus interrupts after read/write operations, which
  2364.  * can be recognized by a bad head number (>= 2) */
  2365. return;
  2366. }
  2368. if (!DRS->first_read_date)
  2369. DRS->first_read_date = jiffies;
  2371. nr_sectors = 0;
  2372. CODE2SIZE;
  2374. if (ST1 & ST1_EOC)
  2375. eoc = 1;
  2376. else
  2377. eoc = 0;
  2379. if (COMMAND & 0x80)
  2380. heads = 2;
  2381. else
  2382. heads = 1;
  2384. nr_sectors = (((R_TRACK - TRACK) * heads +
  2385.        R_HEAD - HEAD) * SECT_PER_TRACK +
  2386.       R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
  2388. #ifdef FLOPPY_SANITY_CHECK
  2389. if (nr_sectors / ssize >
  2390.     (in_sector_offset + current_count_sectors + ssize - 1) / ssize) {
  2391. DPRINT("long rw: %x instead of %lxn",
  2392.        nr_sectors, current_count_sectors);
  2393. printk("rs=%d s=%dn", R_SECTOR, SECTOR);
  2394. printk("rh=%d h=%dn", R_HEAD, HEAD);
  2395. printk("rt=%d t=%dn", R_TRACK, TRACK);
  2396. printk("heads=%d eoc=%dn", heads, eoc);
  2397. printk("spt=%d st=%d ss=%dn", SECT_PER_TRACK,
  2398.        fsector_t, ssize);
  2399. printk("in_sector_offset=%dn", in_sector_offset);
  2400. }
  2401. #endif
  2403. nr_sectors -= in_sector_offset;
  2404. INFBOUND(nr_sectors, 0);
  2405. SUPBOUND(current_count_sectors, nr_sectors);
  2407. switch (interpret_errors()) {
  2408. case 2:
  2409. cont->redo();
  2410. return;
  2411. case 1:
  2412. if (!current_count_sectors) {
  2413. cont->error();
  2414. cont->redo();
  2415. return;
  2416. }
  2417. break;
  2418. case 0:
  2419. if (!current_count_sectors) {
  2420. cont->redo();
  2421. return;
  2422. }
  2423. current_type[current_drive] = _floppy;
  2424. floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
  2425. break;
  2426. }
  2428. if (probing) {
  2429. if (DP->flags & FTD_MSG)
  2430. DPRINT("Auto-detected floppy type %s in fd%dn",
  2431.        _floppy->name, current_drive);
  2432. current_type[current_drive] = _floppy;
  2433. floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
  2434. probing = 0;
  2435. }
  2437. if (CT(COMMAND) != FD_READ ||
  2438.     raw_cmd->kernel_data == current_req->buffer) {
  2439. /* transfer directly from buffer */
  2440. cont->done(1);
  2441. } else if (CT(COMMAND) == FD_READ) {
  2442. buffer_track = raw_cmd->track;
  2443. buffer_drive = current_drive;
  2444. INFBOUND(buffer_max, nr_sectors + fsector_t);
  2445. }
  2446. cont->redo();
  2447. }
  2449. /* Compute maximal contiguous buffer size. */
  2450. static int buffer_chain_size(void)
  2451. {
  2452. struct bio *bio;
  2453. struct bio_vec *bv;
  2454. int size, i;
  2455. char *base;
  2457. base = bio_data(current_req->bio);
  2458. size = 0;
  2460. rq_for_each_bio(bio, current_req) {
  2461. bio_for_each_segment(bv, bio, i) {
  2462. if (page_address(bv->bv_page) + bv->bv_offset !=
  2463.     base + size)
  2464. break;
  2466. size += bv->bv_len;
  2467. }
  2468. }
  2470. return size >> 9;
  2471. }
  2473. /* Compute the maximal transfer size */
  2474. static int transfer_size(int ssize, int max_sector, int max_size)
  2475. {
  2476. SUPBOUND(max_sector, fsector_t + max_size);
  2478. /* alignment */
  2479. max_sector -= (max_sector % _floppy->sect) % ssize;
  2481. /* transfer size, beginning not aligned */
  2482. current_count_sectors = max_sector - fsector_t;
  2484. return max_sector;
  2485. }
  2487. /*
  2488.  * Move data from/to the track buffer to/from the buffer cache.
  2489.  */
  2490. static void copy_buffer(int ssize, int max_sector, int max_sector_2)
  2491. {
  2492. int remaining; /* number of transferred 512-byte sectors */
  2493. struct bio_vec *bv;
  2494. struct bio *bio;
  2495. char *buffer, *dma_buffer;
  2496. int size, i;
  2498. max_sector = transfer_size(ssize,
  2499.    min(max_sector, max_sector_2),
  2500.    current_req->nr_sectors);
  2502. if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
  2503.     buffer_max > fsector_t + current_req->nr_sectors)
  2504. current_count_sectors = min_t(int, buffer_max - fsector_t,
  2505.       current_req->nr_sectors);
  2507. remaining = current_count_sectors << 9;
  2508. #ifdef FLOPPY_SANITY_CHECK
  2509. if ((remaining >> 9) > current_req->nr_sectors &&
  2510.     CT(COMMAND) == FD_WRITE) {
  2511. DPRINT("in copy buffern");
  2512. printk("current_count_sectors=%ldn", current_count_sectors);
  2513. printk("remaining=%dn", remaining >> 9);
  2514. printk("current_req->nr_sectors=%ldn",
  2515.        current_req->nr_sectors);
  2516. printk("current_req->current_nr_sectors=%un",
  2517.        current_req->current_nr_sectors);
  2518. printk("max_sector=%dn", max_sector);
  2519. printk("ssize=%dn", ssize);
  2520. }
  2521. #endif
  2523. buffer_max = max(max_sector, buffer_max);
  2525. dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
  2527. size = current_req->current_nr_sectors << 9;
  2529. rq_for_each_bio(bio, current_req) {
  2530. bio_for_each_segment(bv, bio, i) {
  2531. if (!remaining)
  2532. break;
  2534. size = bv->bv_len;
  2535. SUPBOUND(size, remaining);
  2537. buffer = page_address(bv->bv_page) + bv->bv_offset;
  2538. #ifdef FLOPPY_SANITY_CHECK
  2539. if (dma_buffer + size >
  2540.     floppy_track_buffer + (max_buffer_sectors << 10) ||
  2541.     dma_buffer < floppy_track_buffer) {
  2542. DPRINT("buffer overrun in copy buffer %dn",
  2543.        (int)((floppy_track_buffer -
  2544.       dma_buffer) >> 9));
  2545. printk("fsector_t=%d buffer_min=%dn",
  2546.        fsector_t, buffer_min);
  2547. printk("current_count_sectors=%ldn",
  2548.        current_count_sectors);
  2549. if (CT(COMMAND) == FD_READ)
  2550. printk("readn");
  2551. if (CT(COMMAND) == FD_WRITE)
  2552. printk("writen");
  2553. break;
  2554. }
  2555. if (((unsigned long)buffer) % 512)
  2556. DPRINT("%p buffer not alignedn", buffer);
  2557. #endif
  2558. if (CT(COMMAND) == FD_READ)
  2559. memcpy(buffer, dma_buffer, size);
  2560. else
  2561. memcpy(dma_buffer, buffer, size);
  2563. remaining -= size;
  2564. dma_buffer += size;
  2565. }
  2566. }
  2567. #ifdef FLOPPY_SANITY_CHECK
  2568. if (remaining) {
  2569. if (remaining > 0)
  2570. max_sector -= remaining >> 9;
  2571. DPRINT("weirdness: remaining %dn", remaining >> 9);
  2572. }
  2573. #endif
  2574. }
  2576. #if 0
  2577. static inline int check_dma_crossing(char *start,
  2578.      unsigned long length, char *message)
  2579. {
  2580. if (CROSS_64KB(start, length)) {
  2581. printk("DMA xfer crosses 64KB boundary in %s %p-%pn",
  2582.        message, start, start + length);
  2583. return 1;
  2584. } else
  2585. return 0;
  2586. }
  2587. #endif
  2589. /* work around a bug in pseudo DMA
  2590.  * (on some FDCs) pseudo DMA does not stop when the CPU stops
  2591.  * sending data.  Hence we need a different way to signal the
  2592.  * transfer length:  We use SECT_PER_TRACK.  Unfortunately, this
  2593.  * does not work with MT, hence we can only transfer one head at
  2594.  * a time
  2595.  */
  2596. static void virtualdmabug_workaround(void)
  2597. {
  2598. int hard_sectors, end_sector;
  2600. if (CT(COMMAND) == FD_WRITE) {
  2601. COMMAND &= ~0x80; /* switch off multiple track mode */
  2603. hard_sectors = raw_cmd->length >> (7 + SIZECODE);
  2604. end_sector = SECTOR + hard_sectors - 1;
  2605. #ifdef FLOPPY_SANITY_CHECK
  2606. if (end_sector > SECT_PER_TRACK) {
  2607. printk("too many sectors %d > %dn",
  2608.        end_sector, SECT_PER_TRACK);
  2609. return;
  2610. }
  2611. #endif
  2612. SECT_PER_TRACK = end_sector; /* make sure SECT_PER_TRACK points
  2613.  * to end of transfer */
  2614. }
  2615. }
  2617. /*
  2618.  * Formulate a read/write request.
  2619.  * this routine decides where to load the data (directly to buffer, or to
  2620.  * tmp floppy area), how much data to load (the size of the buffer, the whole
  2621.  * track, or a single sector)
  2622.  * All floppy_track_buffer handling goes in here. If we ever add track buffer
  2623.  * allocation on the fly, it should be done here. No other part should need
  2624.  * modification.
  2625.  */
  2627. static int make_raw_rw_request(void)
  2628. {
  2629. int aligned_sector_t;
  2630. int max_sector, max_size, tracksize, ssize;
  2632. if (max_buffer_sectors == 0) {
  2633. printk("VFS: Block I/O scheduled on unopened devicen");
  2634. return 0;
  2635. }
  2637. set_fdc((long)current_req->rq_disk->private_data);
  2639. raw_cmd = &default_raw_cmd;
  2640. raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
  2641.     FD_RAW_NEED_SEEK;
  2642. raw_cmd->cmd_count = NR_RW;
  2643. if (rq_data_dir(current_req) == READ) {
  2644. raw_cmd->flags |= FD_RAW_READ;
  2645. COMMAND = FM_MODE(_floppy, FD_READ);
  2646. } else if (rq_data_dir(current_req) == WRITE) {
  2647. raw_cmd->flags |= FD_RAW_WRITE;
  2648. COMMAND = FM_MODE(_floppy, FD_WRITE);
  2649. } else {
  2650. DPRINT("make_raw_rw_request: unknown commandn");
  2651. return 0;
  2652. }
  2654. max_sector = _floppy->sect * _floppy->head;
  2656. TRACK = (int)current_req->sector / max_sector;
  2657. fsector_t = (int)current_req->sector % max_sector;
  2658. if (_floppy->track && TRACK >= _floppy->track) {
  2659. if (current_req->current_nr_sectors & 1) {
  2660. current_count_sectors = 1;
  2661. return 1;
  2662. } else
  2663. return 0;
  2664. }
  2665. HEAD = fsector_t / _floppy->sect;
  2667. if (((_floppy->stretch & (FD_SWAPSIDES | FD_ZEROBASED)) ||
  2668.      TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
  2669. max_sector = _floppy->sect;
  2671. /* 2M disks have phantom sectors on the first track */
  2672. if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
  2673. max_sector = 2 * _floppy->sect / 3;
  2674. if (fsector_t >= max_sector) {
  2675. current_count_sectors =
  2676.     min_t(int, _floppy->sect - fsector_t,
  2677.   current_req->nr_sectors);
  2678. return 1;
  2679. }
  2680. SIZECODE = 2;
  2681. } else
  2682. SIZECODE = FD_SIZECODE(_floppy);
  2683. raw_cmd->rate = _floppy->rate & 0x43;
  2684. if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
  2685. raw_cmd->rate = 1;
  2687. if (SIZECODE)
  2688. SIZECODE2 = 0xff;
  2689. else
  2690. SIZECODE2 = 0x80;
  2691. raw_cmd->track = TRACK << STRETCH(_floppy);
  2692. DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
  2693. GAP = _floppy->gap;
  2694. CODE2SIZE;
  2695. SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
  2696. SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
  2697.     ((_floppy->stretch & FD_ZEROBASED) ? 0 : 1);
  2699. /* tracksize describes the size which can be filled up with sectors
  2700.  * of size ssize.
  2701.  */
  2702. tracksize = _floppy->sect - _floppy->sect % ssize;
  2703. if (tracksize < _floppy->sect) {
  2704. SECT_PER_TRACK++;
  2705. if (tracksize <= fsector_t % _floppy->sect)
  2706. SECTOR--;
  2708. /* if we are beyond tracksize, fill up using smaller sectors */
  2709. while (tracksize <= fsector_t % _floppy->sect) {
  2710. while (tracksize + ssize > _floppy->sect) {
  2711. SIZECODE--;
  2712. ssize >>= 1;
  2713. }
  2714. SECTOR++;
  2715. SECT_PER_TRACK++;
  2716. tracksize += ssize;
  2717. }
  2718. max_sector = HEAD * _floppy->sect + tracksize;
  2719. } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
  2720. max_sector = _floppy->sect;
  2721. } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
  2722. /* for virtual DMA bug workaround */
  2723. max_sector = _floppy->sect;
  2724. }
  2726. in_sector_offset = (fsector_t % _floppy->sect) % ssize;
  2727. aligned_sector_t = fsector_t - in_sector_offset;
  2728. max_size = current_req->nr_sectors;
  2729. if ((raw_cmd->track == buffer_track) &&
  2730.     (current_drive == buffer_drive) &&
  2731.     (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
  2732. /* data already in track buffer */
  2733. if (CT(COMMAND) == FD_READ) {
  2734. copy_buffer(1, max_sector, buffer_max);
  2735. return 1;
  2736. }
  2737. } else if (in_sector_offset || current_req->nr_sectors < ssize) {
  2738. if (CT(COMMAND) == FD_WRITE) {
  2739. if (fsector_t + current_req->nr_sectors > ssize &&
  2740.     fsector_t + current_req->nr_sectors < ssize + ssize)
  2741. max_size = ssize + ssize;
  2742. else
  2743. max_size = ssize;
  2744. }
  2745. raw_cmd->flags &= ~FD_RAW_WRITE;
  2746. raw_cmd->flags |= FD_RAW_READ;
  2747. COMMAND = FM_MODE(_floppy, FD_READ);
  2748. } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
  2749. unsigned long dma_limit;
  2750. int direct, indirect;
  2752. indirect =
  2753.     transfer_size(ssize, max_sector,
  2754.   max_buffer_sectors * 2) - fsector_t;
  2756. /*
  2757.  * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
  2758.  * on a 64 bit machine!
  2759.  */
  2760. max_size = buffer_chain_size();
  2761. dma_limit =
  2762.     (MAX_DMA_ADDRESS -
  2763.      ((unsigned long)current_req->buffer)) >> 9;
  2764. if ((unsigned long)max_size > dma_limit) {
  2765. max_size = dma_limit;
  2766. }
  2767. /* 64 kb boundaries */
  2768. if (CROSS_64KB(current_req->buffer, max_size << 9))
  2769. max_size = (K_64 -
  2770.     ((unsigned long)current_req->buffer) %
  2771.     K_64) >> 9;
  2772. direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
  2773. /*
  2774.  * We try to read tracks, but if we get too many errors, we
  2775.  * go back to reading just one sector at a time.
  2776.  *
  2777.  * This means we should be able to read a sector even if there
  2778.  * are other bad sectors on this track.
  2779.  */
  2780. if (!direct ||
  2781.     (indirect * 2 > direct * 3 &&
  2782.      *errors < DP->max_errors.read_track &&
  2783.      /*!TESTF(FD_NEED_TWADDLE) && */
  2784.      ((!probing
  2785.        || (DP->read_track & (1 << DRS->probed_format)))))) {
  2786. max_size = current_req->nr_sectors;
  2787. } else {
  2788. raw_cmd->kernel_data = current_req->buffer;
  2789. raw_cmd->length = current_count_sectors << 9;
  2790. if (raw_cmd->length == 0) {
  2791. DPRINT
  2792.     ("zero dma transfer attempted from make_raw_requestn");
  2793. DPRINT("indirect=%d direct=%d fsector_t=%d",
  2794.        indirect, direct, fsector_t);
  2795. return 0;
  2796. }
  2797. /* check_dma_crossing(raw_cmd->kernel_data, 
  2798.    raw_cmd->length, 
  2799.    "end of make_raw_request [1]");*/
  2801. virtualdmabug_workaround();
  2802. return 2;
  2803. }
  2804. }
  2806. if (CT(COMMAND) == FD_READ)
  2807. max_size = max_sector; /* unbounded */
  2809. /* claim buffer track if needed */
  2810. if (buffer_track != raw_cmd->track || /* bad track */
  2811.     buffer_drive != current_drive || /* bad drive */
  2812.     fsector_t > buffer_max ||
  2813.     fsector_t < buffer_min ||
  2814.     ((CT(COMMAND) == FD_READ ||
  2815.       (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
  2816.      max_sector > 2 * max_buffer_sectors + buffer_min &&
  2817.      max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
  2818.     /* not enough space */
  2819.     ) {
  2820. buffer_track = -1;
  2821. buffer_drive = current_drive;
  2822. buffer_max = buffer_min = aligned_sector_t;
  2823. }
  2824. raw_cmd->kernel_data = floppy_track_buffer +
  2825.     ((aligned_sector_t - buffer_min) << 9);
  2827. if (CT(COMMAND) == FD_WRITE) {
  2828. /* copy write buffer to track buffer.
  2829.  * if we get here, we know that the write
  2830.  * is either aligned or the data already in the buffer
  2831.  * (buffer will be overwritten) */
  2832. #ifdef FLOPPY_SANITY_CHECK
  2833. if (in_sector_offset && buffer_track == -1)
  2834. DPRINT("internal error offset !=0 on writen");
  2835. #endif
  2836. buffer_track = raw_cmd->track;
  2837. buffer_drive = current_drive;
  2838. copy_buffer(ssize, max_sector,
  2839.     2 * max_buffer_sectors + buffer_min);
  2840. } else
  2841. transfer_size(ssize, max_sector,
  2842.       2 * max_buffer_sectors + buffer_min -
  2843.       aligned_sector_t);
  2845. /* round up current_count_sectors to get dma xfer size */
  2846. raw_cmd->length = in_sector_offset + current_count_sectors;
  2847. raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
  2848. raw_cmd->length <<= 9;
  2849. #ifdef FLOPPY_SANITY_CHECK
  2850. /*check_dma_crossing(raw_cmd->kernel_data, raw_cmd->length, 
  2851.    "end of make_raw_request"); */
  2852. if ((raw_cmd->length < current_count_sectors << 9) ||
  2853.     (raw_cmd->kernel_data != current_req->buffer &&
  2854.      CT(COMMAND) == FD_WRITE &&
  2855.      (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
  2856.       aligned_sector_t < buffer_min)) ||
  2857.     raw_cmd->length % (128 << SIZECODE) ||
  2858.     raw_cmd->length <= 0 || current_count_sectors <= 0) {
  2859. DPRINT("fractionary current count b=%lx s=%lxn",
  2860.        raw_cmd->length, current_count_sectors);
  2861. if (raw_cmd->kernel_data != current_req->buffer)
  2862. printk("addr=%d, length=%ldn",
  2863.        (int)((raw_cmd->kernel_data -
  2864.       floppy_track_buffer) >> 9),
  2865.        current_count_sectors);
  2866. printk("st=%d ast=%d mse=%d msi=%dn",
  2867.        fsector_t, aligned_sector_t, max_sector, max_size);
  2868. printk("ssize=%x SIZECODE=%dn", ssize, SIZECODE);
  2869. printk("command=%x SECTOR=%d HEAD=%d, TRACK=%dn",
  2870.        COMMAND, SECTOR, HEAD, TRACK);
  2871. printk("buffer drive=%dn", buffer_drive);
  2872. printk("buffer track=%dn", buffer_track);
  2873. printk("buffer_min=%dn", buffer_min);
  2874. printk("buffer_max=%dn", buffer_max);
  2875. return 0;
  2876. }
  2878. if (raw_cmd->kernel_data != current_req->buffer) {
  2879. if (raw_cmd->kernel_data < floppy_track_buffer ||
  2880.     current_count_sectors < 0 ||
  2881.     raw_cmd->length < 0 ||
  2882.     raw_cmd->kernel_data + raw_cmd->length >
  2883.     floppy_track_buffer + (max_buffer_sectors << 10)) {
  2884. DPRINT("buffer overrun in schedule dman");
  2885. printk("fsector_t=%d buffer_min=%d current_count=%ldn",
  2886.        fsector_t, buffer_min, raw_cmd->length >> 9);
  2887. printk("current_count_sectors=%ldn",
  2888.        current_count_sectors);
  2889. if (CT(COMMAND) == FD_READ)
  2890. printk("readn");
  2891. if (CT(COMMAND) == FD_WRITE)
  2892. printk("writen");
  2893. return 0;
  2894. }
  2895. } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
  2896.    current_count_sectors > current_req->nr_sectors) {
  2897. DPRINT("buffer overrun in direct transfern");
  2898. return 0;
  2899. } else if (raw_cmd->length < current_count_sectors << 9) {
  2900. DPRINT("more sectors than bytesn");
  2901. printk("bytes=%ldn", raw_cmd->length >> 9);
  2902. printk("sectors=%ldn", current_count_sectors);
  2903. }
  2904. if (raw_cmd->length == 0) {
  2905. DPRINT("zero dma transfer attempted from make_raw_requestn");
  2906. return 0;
  2907. }
  2908. #endif
  2910. virtualdmabug_workaround();
  2911. return 2;
  2912. }
  2914. static void redo_fd_request(void)
  2915. {
  2916. #define REPEAT {request_done(0); continue; }
  2917. int drive;
  2918. int tmp;
  2920. lastredo = jiffies;
  2921. if (current_drive < N_DRIVE)
  2922. floppy_off(current_drive);
  2924. for (;;) {
  2925. if (!current_req) {
  2926. struct request *req;
  2928. spin_lock_irq(floppy_queue->queue_lock);
  2929. req = elv_next_request(floppy_queue);
  2930. spin_unlock_irq(floppy_queue->queue_lock);
  2931. if (!req) {
  2932. do_floppy = NULL;
  2933. unlock_fdc();
  2934. return;
  2935. }
  2936. current_req = req;
  2937. }
  2938. drive = (long)current_req->rq_disk->private_data;
  2939. set_fdc(drive);
  2940. reschedule_timeout(current_reqD, "redo fd request", 0);
  2942. set_floppy(drive);
  2943. raw_cmd = &default_raw_cmd;
  2944. raw_cmd->flags = 0;
  2945. if (start_motor(redo_fd_request))
  2946. return;
  2947. disk_change(current_drive);
  2948. if (test_bit(current_drive, &fake_change) ||
  2949.     TESTF(FD_DISK_CHANGED)) {
  2950. DPRINT("disk absent or changed during operationn");
  2951. REPEAT;
  2952. }
  2953. if (!_floppy) { /* Autodetection */
  2954. if (!probing) {
  2955. DRS->probed_format = 0;
  2956. if (next_valid_format()) {
  2957. DPRINT("no autodetectable formatsn");
  2958. _floppy = NULL;
  2959. REPEAT;
  2960. }
  2961. }
  2962. probing = 1;
  2963. _floppy =
  2964.     floppy_type + DP->autodetect[DRS->probed_format];
  2965. } else
  2966. probing = 0;
  2967. errors = &(current_req->errors);
  2968. tmp = make_raw_rw_request();
  2969. if (tmp < 2) {
  2970. request_done(tmp);
  2971. continue;
  2972. }
  2974. if (TESTF(FD_NEED_TWADDLE))
  2975. twaddle();
  2976. schedule_bh(floppy_start);
  2977. debugt("queue fd request");
  2978. return;
  2979. }
  2980. #undef REPEAT
  2981. }
  2983. static struct cont_t rw_cont = {
  2984. .interrupt = rw_interrupt,
  2985. .redo = redo_fd_request,
  2986. .error = bad_flp_intr,
  2987. .done = request_done
  2988. };
  2990. static void process_fd_request(void)
  2991. {
  2992. cont = &rw_cont;
  2993. schedule_bh(redo_fd_request);
  2994. }
  2996. static void do_fd_request(request_queue_t * q)
  2997. {
  2998. if (max_buffer_sectors == 0) {
  2999. printk("VFS: do_fd_request called on non-open devicen");
  3000. return;
  3001. }
  3003. if (usage_count == 0) {
  3004. printk("warning: usage count=0, current_req=%p exitingn",
  3005.        current_req);
  3006. printk("sect=%ld flags=%lxn", (long)current_req->sector,
  3007.        current_req->flags);
  3008. return;
  3009. }
  3010. if (test_bit(0, &fdc_busy)) {
  3011. /* fdc busy, this new request will be treated when the
  3012.    current one is done */
  3013. is_alive("do fd request, old request running");
  3014. return;
  3015. }
  3016. lock_fdc(MAXTIMEOUT, 0);
  3017. process_fd_request();
  3018. is_alive("do fd request");
  3019. }
  3021. static struct cont_t poll_cont = {
  3022. .interrupt = success_and_wakeup,
  3023. .redo = floppy_ready,
  3024. .error = generic_failure,
  3025. .done = generic_done
  3026. };
  3028. static int poll_drive(int interruptible, int flag)
  3029. {
  3030. int ret;
  3031. /* no auto-sense, just clear dcl */
  3032. raw_cmd = &default_raw_cmd;
  3033. raw_cmd->flags = flag;
  3034. raw_cmd->track = 0;
  3035. raw_cmd->cmd_count = 0;
  3036. cont = &poll_cont;
  3037. #ifdef DCL_DEBUG
  3038. if (DP->flags & FD_DEBUG) {
  3039. DPRINT("setting NEWCHANGE in poll_driven");
  3040. }
  3041. #endif
  3042. SETF(FD_DISK_NEWCHANGE);
  3043. WAIT(floppy_ready);
  3044. return ret;
  3045. }
  3047. /*
  3048.  * User triggered reset
  3049.  * ====================
  3050.  */
  3052. static void reset_intr(void)
  3053. {
  3054. printk("weird, reset interrupt calledn");
  3055. }
  3057. static struct cont_t reset_cont = {
  3058. .interrupt = reset_intr,
  3059. .redo = success_and_wakeup,
  3060. .error = generic_failure,
  3061. .done = generic_done
  3062. };
  3064. static int user_reset_fdc(int drive, int arg, int interruptible)
  3065. {
  3066. int ret;
  3068. ret = 0;
  3069. LOCK_FDC(drive, interruptible);
  3070. if (arg == FD_RESET_ALWAYS)
  3071. FDCS->reset = 1;
  3072. if (FDCS->reset) {
  3073. cont = &reset_cont;
  3074. WAIT(reset_fdc);
  3075. }
  3076. process_fd_request();
  3077. return ret;
  3078. }
  3080. /*
  3081.  * Misc Ioctl's and support
  3082.  * ========================
  3083.  */
  3084. static inline int fd_copyout(void __user *param, const void *address,
  3085.      unsigned long size)
  3086. {
  3087. return copy_to_user(param, address, size) ? -EFAULT : 0;
  3088. }
  3090. static inline int fd_copyin(void __user *param, void *address, unsigned long size)
  3091. {
  3092. return copy_from_user(address, param, size) ? -EFAULT : 0;
  3093. }
  3095. #define _COPYOUT(x) (copy_to_user((void __user *)param, &(x), sizeof(x)) ? -EFAULT : 0)
  3096. #define _COPYIN(x) (copy_from_user(&(x), (void __user *)param, sizeof(x)) ? -EFAULT : 0)
  3098. #define COPYOUT(x) ECALL(_COPYOUT(x))
  3099. #define COPYIN(x) ECALL(_COPYIN(x))
  3101. static inline const char *drive_name(int type, int drive)
  3102. {
  3103. struct floppy_struct *floppy;
  3105. if (type)
  3106. floppy = floppy_type + type;
  3107. else {
  3108. if (UDP->native_format)
  3109. floppy = floppy_type + UDP->native_format;
  3110. else
  3111. return "(null)";
  3112. }
  3113. if (floppy->name)
  3114. return floppy->name;
  3115. else
  3116. return "(null)";
  3117. }
  3119. /* raw commands */
  3120. static void raw_cmd_done(int flag)
  3121. {
  3122. int i;
  3124. if (!flag) {
  3125. raw_cmd->flags |= FD_RAW_FAILURE;
  3126. raw_cmd->flags |= FD_RAW_HARDFAILURE;
  3127. } else {
  3128. raw_cmd->reply_count = inr;
  3129. if (raw_cmd->reply_count > MAX_REPLIES)
  3130. raw_cmd->reply_count = 0;
  3131. for (i = 0; i < raw_cmd->reply_count; i++)
  3132. raw_cmd->reply[i] = reply_buffer[i];
  3134. if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
  3135. unsigned long flags;
  3136. flags = claim_dma_lock();
  3137. raw_cmd->length = fd_get_dma_residue();
  3138. release_dma_lock(flags);
  3139. }
  3141. if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
  3142.     (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
  3143. raw_cmd->flags |= FD_RAW_FAILURE;
  3145. if (disk_change(current_drive))
  3146. raw_cmd->flags |= FD_RAW_DISK_CHANGE;
  3147. else
  3148. raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
  3149. if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
  3150. motor_off_callback(current_drive);
  3152. if (raw_cmd->next &&
  3153.     (!(raw_cmd->flags & FD_RAW_FAILURE) ||
  3154.      !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
  3155.     ((raw_cmd->flags & FD_RAW_FAILURE) ||
  3156.      !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
  3157. raw_cmd = raw_cmd->next;
  3158. return;
  3159. }
  3160. }
  3161. generic_done(flag);
  3162. }
  3164. static struct cont_t raw_cmd_cont = {
  3165. .interrupt = success_and_wakeup,
  3166. .redo = floppy_start,
  3167. .error = generic_failure,
  3168. .done = raw_cmd_done
  3169. };
  3171. static inline int raw_cmd_copyout(int cmd, char __user *param,
  3172.   struct floppy_raw_cmd *ptr)
  3173. {
  3174. int ret;
  3176. while (ptr) {
  3177. COPYOUT(*ptr);
  3178. param += sizeof(struct floppy_raw_cmd);
  3179. if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
  3180. if (ptr->length >= 0
  3181.     && ptr->length <= ptr->buffer_length)
  3182. ECALL(fd_copyout
  3183.       (ptr->data, ptr->kernel_data,
  3184.        ptr->buffer_length - ptr->length));
  3185. }
  3186. ptr = ptr->next;
  3187. }
  3188. return 0;
  3189. }
  3191. static void raw_cmd_free(struct floppy_raw_cmd **ptr)
  3192. {
  3193. struct floppy_raw_cmd *next, *this;
  3195. this = *ptr;
  3196. *ptr = NULL;
  3197. while (this) {
  3198. if (this->buffer_length) {
  3199. fd_dma_mem_free((unsigned long)this->kernel_data,
  3200. this->buffer_length);
  3201. this->buffer_length = 0;
  3202. }
  3203. next = this->next;
  3204. kfree(this);
  3205. this = next;
  3206. }
  3207. }
  3209. static inline int raw_cmd_copyin(int cmd, char __user *param,
  3210.  struct floppy_raw_cmd **rcmd)
  3211. {
  3212. struct floppy_raw_cmd *ptr;
  3213. int ret;
  3214. int i;
  3216. *rcmd = NULL;
  3217. while (1) {
  3218. ptr = (struct floppy_raw_cmd *)
  3219.     kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
  3220. if (!ptr)
  3221. return -ENOMEM;
  3222. *rcmd = ptr;
  3223. COPYIN(*ptr);
  3224. ptr->next = NULL;
  3225. ptr->buffer_length = 0;
  3226. param += sizeof(struct floppy_raw_cmd);
  3227. if (ptr->cmd_count > 33)
  3228. /* the command may now also take up the space
  3229.  * initially intended for the reply & the
  3230.  * reply count. Needed for long 82078 commands
  3231.  * such as RESTORE, which takes ... 17 command
  3232.  * bytes. Murphy's law #137: When you reserve
  3233.  * 16 bytes for a structure, you'll one day
  3234.  * discover that you really need 17...
  3235.  */
  3236. return -EINVAL;
  3238. for (i = 0; i < 16; i++)
  3239. ptr->reply[i] = 0;
  3240. ptr->resultcode = 0;
  3241. ptr->kernel_data = NULL;
  3243. if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
  3244. if (ptr->length <= 0)
  3245. return -EINVAL;
  3246. ptr->kernel_data =
  3247.     (char *)fd_dma_mem_alloc(ptr->length);
  3248. fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
  3249. if (!ptr->kernel_data)
  3250. return -ENOMEM;
  3251. ptr->buffer_length = ptr->length;
  3252. }
  3253. if (ptr->flags & FD_RAW_WRITE)
  3254. ECALL(fd_copyin(ptr->data, ptr->kernel_data,
  3255. ptr->length));
  3256. rcmd = &(ptr->next);
  3257. if (!(ptr->flags & FD_RAW_MORE))
  3258. return 0;
  3259. ptr->rate &= 0x43;
  3260. }
  3261. }
  3263. static int raw_cmd_ioctl(int cmd, void __user *param)
  3264. {
  3265. int drive, ret, ret2;
  3266. struct floppy_raw_cmd *my_raw_cmd;
  3268. if (FDCS->rawcmd <= 1)
  3269. FDCS->rawcmd = 1;
  3270. for (drive = 0; drive < N_DRIVE; drive++) {
  3271. if (FDC(drive) != fdc)
  3272. continue;
  3273. if (drive == current_drive) {
  3274. if (UDRS->fd_ref > 1) {
  3275. FDCS->rawcmd = 2;
  3276. break;
  3277. }
  3278. } else if (UDRS->fd_ref) {
  3279. FDCS->rawcmd = 2;
  3280. break;
  3281. }
  3282. }
  3284. if (FDCS->reset)
  3285. return -EIO;
  3287. ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
  3288. if (ret) {
  3289. raw_cmd_free(&my_raw_cmd);
  3290. return ret;
  3291. }
  3293. raw_cmd = my_raw_cmd;
  3294. cont = &raw_cmd_cont;
  3295. ret = wait_til_done(floppy_start, 1);
  3296. #ifdef DCL_DEBUG
  3297. if (DP->flags & FD_DEBUG) {
  3298. DPRINT("calling disk change from raw_cmd ioctln");
  3299. }
  3300. #endif
  3302. if (ret != -EINTR && FDCS->reset)
  3303. ret = -EIO;
  3305. DRS->track = NO_TRACK;
  3307. ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
  3308. if (!ret)
  3309. ret = ret2;
  3310. raw_cmd_free(&my_raw_cmd);
  3311. return ret;
  3312. }
  3314. static int invalidate_drive(struct block_device *bdev)
  3315. {
  3316. /* invalidate the buffer track to force a reread */
  3317. set_bit((long)bdev->bd_disk->private_data, &fake_change);
  3318. process_fd_request();
  3319. check_disk_change(bdev);
  3320. return 0;
  3321. }
  3323. static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
  3324.        int drive, int type, struct block_device *bdev)
  3325. {
  3326. int cnt;
  3328. /* sanity checking for parameters. */
  3329. if (g->sect <= 0 ||
  3330.     g->head <= 0 ||
  3331.     g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
  3332.     /* check if reserved bits are set */
  3333.     (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_ZEROBASED)) != 0)
  3334. return -EINVAL;
  3335. if (type) {
  3336. if (!capable(CAP_SYS_ADMIN))
  3337. return -EPERM;
  3338. down(&open_lock);
  3339. LOCK_FDC(drive, 1);
  3340. floppy_type[type] = *g;
  3341. floppy_type[type].name = "user format";
  3342. for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
  3343. floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
  3344.     floppy_type[type].size + 1;
  3345. process_fd_request();
  3346. for (cnt = 0; cnt < N_DRIVE; cnt++) {
  3347. struct block_device *bdev = opened_bdev[cnt];
  3348. if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
  3349. continue;
  3350. __invalidate_device(bdev);
  3351. }
  3352. up(&open_lock);
  3353. } else {
  3354. int oldStretch;
  3355. LOCK_FDC(drive, 1);
  3356. if (cmd != FDDEFPRM)
  3357. /* notice a disk change immediately, else
  3358.  * we lose our settings immediately*/
  3359. CALL(poll_drive(1, FD_RAW_NEED_DISK));
  3360. oldStretch = g->stretch;
  3361. user_params[drive] = *g;
  3362. if (buffer_drive == drive)
  3363. SUPBOUND(buffer_max, user_params[drive].sect);
  3364. current_type[drive] = &user_params[drive];
  3365. floppy_sizes[drive] = user_params[drive].size;
  3366. if (cmd == FDDEFPRM)
  3367. DRS->keep_data = -1;
  3368. else
  3369. DRS->keep_data = 1;
  3370. /* invalidation. Invalidate only when needed, i.e.
  3371.  * when there are already sectors in the buffer cache
  3372.  * whose number will change. This is useful, because
  3373.  * mtools often changes the geometry of the disk after
  3374.  * looking at the boot block */
  3375. if (DRS->maxblock > user_params[drive].sect ||
  3376.     DRS->maxtrack ||
  3377.     ((user_params[drive].sect ^ oldStretch) &
  3378.      (FD_SWAPSIDES | FD_ZEROBASED)))
  3379. invalidate_drive(bdev);
  3380. else
  3381. process_fd_request();
  3382. }
  3383. return 0;
  3384. }
  3386. /* handle obsolete ioctl's */
  3387. static int ioctl_table[] = {
  3388. FDCLRPRM,
  3389. FDSETPRM,
  3390. FDDEFPRM,
  3391. FDGETPRM,
  3392. FDMSGON,
  3393. FDMSGOFF,
  3394. FDFMTBEG,
  3395. FDFMTTRK,
  3396. FDFMTEND,
  3397. FDSETEMSGTRESH,
  3398. FDFLUSH,
  3399. FDSETMAXERRS,
  3400. FDGETMAXERRS,
  3401. FDGETDRVTYP,
  3402. FDSETDRVPRM,
  3403. FDGETDRVPRM,
  3404. FDGETDRVSTAT,
  3405. FDPOLLDRVSTAT,
  3406. FDRESET,
  3407. FDGETFDCSTAT,
  3408. FDWERRORCLR,
  3409. FDWERRORGET,
  3410. FDRAWCMD,
  3411. FDEJECT,
  3412. FDTWADDLE
  3413. };
  3415. static inline int normalize_ioctl(int *cmd, int *size)
  3416. {
  3417. int i;
  3419. for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
  3420. if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
  3421. *size = _IOC_SIZE(*cmd);
  3422. *cmd = ioctl_table[i];
  3423. if (*size > _IOC_SIZE(*cmd)) {
  3424. printk("ioctl not yet supportedn");
  3425. return -EFAULT;
  3426. }
  3427. return 0;
  3428. }
  3429. }
  3430. return -EINVAL;
  3431. }
  3433. static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
  3434. {
  3435. if (type)
  3436. *g = &floppy_type[type];
  3437. else {
  3438. LOCK_FDC(drive, 0);
  3439. CALL(poll_drive(0, 0));
  3440. process_fd_request();
  3441. *g = current_type[drive];
  3442. }
  3443. if (!*g)
  3444. return -ENODEV;
  3445. return 0;
  3446. }
  3448. static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
  3449.     unsigned long param)
  3450. {
  3451. #define FD_IOCTL_ALLOWED ((filp) && (filp)->private_data)
  3452. #define OUT(c,x) case c: outparam = (const char *) (x); break
  3453. #define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
  3455. int drive = (long)inode->i_bdev->bd_disk->private_data;
  3456. int i, type = ITYPE(UDRS->fd_device);
  3457. int ret;
  3458. int size;
  3459. union inparam {
  3460. struct floppy_struct g; /* geometry */
  3461. struct format_descr f;
  3462. struct floppy_max_errors max_errors;
  3463. struct floppy_drive_params dp;
  3464. } inparam; /* parameters coming from user space */
  3465. const char *outparam; /* parameters passed back to user space */
  3467. /* convert compatibility eject ioctls into floppy eject ioctl.
  3468.  * We do this in order to provide a means to eject floppy disks before
  3469.  * installing the new fdutils package */
  3470. if (cmd == CDROMEJECT || /* CD-ROM eject */
  3471.     cmd == 0x6470 /* SunOS floppy eject */ ) {
  3472. DPRINT("obsolete eject ioctln");
  3473. DPRINT("please use floppycontrol --ejectn");
  3474. cmd = FDEJECT;
  3475. }
  3477. /* generic block device ioctls */
  3478. switch (cmd) {
  3479. /* the following have been inspired by the corresponding
  3480.  * code for other block devices. */
  3481. struct floppy_struct *g;
  3482. case HDIO_GETGEO:
  3483. {
  3484. struct hd_geometry loc;
  3485. ECALL(get_floppy_geometry(drive, type, &g));
  3486. loc.heads = g->head;
  3487. loc.sectors = g->sect;
  3488. loc.cylinders = g->track;
  3489. loc.start = 0;
  3490. return _COPYOUT(loc);
  3491. }
  3492. }
  3494. /* convert the old style command into a new style command */
  3495. if ((cmd & 0xff00) == 0x0200) {
  3496. ECALL(normalize_ioctl(&cmd, &size));
  3497. } else
  3498. return -EINVAL;
  3500. /* permission checks */
  3501. if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
  3502.     ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
  3503. return -EPERM;
  3505. /* copyin */
  3506. CLEARSTRUCT(&inparam);
  3507. if (_IOC_DIR(cmd) & _IOC_WRITE)
  3508.     ECALL(fd_copyin((void __user *)param, &inparam, size))
  3510. switch (cmd) {
  3511. case FDEJECT:
  3512. if (UDRS->fd_ref != 1)
  3513. /* somebody else has this drive open */
  3514. return -EBUSY;
  3515. LOCK_FDC(drive, 1);
  3517. /* do the actual eject. Fails on
  3518.  * non-Sparc architectures */
  3519. ret = fd_eject(UNIT(drive));
  3521. USETF(FD_DISK_CHANGED);
  3522. USETF(FD_VERIFY);
  3523. process_fd_request();
  3524. return ret;
  3525. case FDCLRPRM:
  3526. LOCK_FDC(drive, 1);
  3527. current_type[drive] = NULL;
  3528. floppy_sizes[drive] = MAX_DISK_SIZE << 1;
  3529. UDRS->keep_data = 0;
  3530. return invalidate_drive(inode->i_bdev);
  3531. case FDSETPRM:
  3532. case FDDEFPRM:
  3533. return set_geometry(cmd, &inparam.g,
  3534.     drive, type, inode->i_bdev);
  3535. case FDGETPRM:
  3536. ECALL(get_floppy_geometry(drive, type,
  3537.   (struct floppy_struct **)
  3538.   &outparam));
  3539. break;
  3541. case FDMSGON:
  3542. UDP->flags |= FTD_MSG;
  3543. return 0;
  3544. case FDMSGOFF:
  3545. UDP->flags &= ~FTD_MSG;
  3546. return 0;
  3548. case FDFMTBEG:
  3549. LOCK_FDC(drive, 1);
  3550. CALL(poll_drive(1, FD_RAW_NEED_DISK));
  3551. ret = UDRS->flags;
  3552. process_fd_request();
  3553. if (ret & FD_VERIFY)
  3554. return -ENODEV;
  3555. if (!(ret & FD_DISK_WRITABLE))
  3556. return -EROFS;
  3557. return 0;
  3558. case FDFMTTRK:
  3559. if (UDRS->fd_ref != 1)
  3560. return -EBUSY;
  3561. return do_format(drive, &inparam.f);
  3562. case FDFMTEND:
  3563. case FDFLUSH:
  3564. LOCK_FDC(drive, 1);
  3565. return invalidate_drive(inode->i_bdev);
  3567. case FDSETEMSGTRESH:
  3568. UDP->max_errors.reporting =
  3569.     (unsigned short)(param & 0x0f);
  3570. return 0;
  3571. OUT(FDGETMAXERRS, &UDP->max_errors);
  3572. IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
  3574. case FDGETDRVTYP:
  3575. outparam = drive_name(type, drive);
  3576. SUPBOUND(size, strlen(outparam) + 1);
  3577. break;
  3579. IN(FDSETDRVPRM, UDP, dp);
  3580. OUT(FDGETDRVPRM, UDP);
  3582. case FDPOLLDRVSTAT:
  3583. LOCK_FDC(drive, 1);
  3584. CALL(poll_drive(1, FD_RAW_NEED_DISK));
  3585. process_fd_request();
  3586. /* fall through */
  3587. OUT(FDGETDRVSTAT, UDRS);
  3589. case FDRESET:
  3590. return user_reset_fdc(drive, (int)param, 1);
  3592. OUT(FDGETFDCSTAT, UFDCS);
  3594. case FDWERRORCLR:
  3595. CLEARSTRUCT(UDRWE);
  3596. return 0;
  3597. OUT(FDWERRORGET, UDRWE);
  3599. case FDRAWCMD:
  3600. if (type)
  3601. return -EINVAL;
  3602. LOCK_FDC(drive, 1);
  3603. set_floppy(drive);
  3604. CALL(i = raw_cmd_ioctl(cmd, (void __user *)param));
  3605. process_fd_request();
  3606. return i;
  3608. case FDTWADDLE:
  3609. LOCK_FDC(drive, 1);
  3610. twaddle();
  3611. process_fd_request();
  3612. return 0;
  3614. default:
  3615. return -EINVAL;
  3616. }
  3618. if (_IOC_DIR(cmd) & _IOC_READ)
  3619. return fd_copyout((void __user *)param, outparam, size);
  3620. else
  3621. return 0;
  3622. #undef OUT
  3623. #undef IN
  3624. }
  3626. static void __init config_types(void)
  3627. {
  3628. int first = 1;
  3629. int drive;
  3631. /* read drive info out of physical CMOS */
  3632. drive = 0;
  3633. if (!UDP->cmos)
  3634. UDP->cmos = FLOPPY0_TYPE;
  3635. drive = 1;
  3636. if (!UDP->cmos && FLOPPY1_TYPE)
  3637. UDP->cmos = FLOPPY1_TYPE;
  3639. /* XXX */
  3640. /* additional physical CMOS drive detection should go here */
  3642. for (drive = 0; drive < N_DRIVE; drive++) {
  3643. unsigned int type = UDP->cmos;
  3644. struct floppy_drive_params *params;
  3645. const char *name = NULL;
  3646. static char temparea[32];
  3648. if (type < NUMBER(default_drive_params)) {
  3649. params = &default_drive_params[type].params;
  3650. if (type) {
  3651. name = default_drive_params[type].name;
  3652. allowed_drive_mask |= 1 << drive;
  3653. } else
  3654. allowed_drive_mask &= ~(1 << drive);
  3655. } else {
  3656. params = &default_drive_params[0].params;
  3657. sprintf(temparea, "unknown type %d (usb?)", type);
  3658. name = temparea;
  3659. }
  3660. if (name) {
  3661. const char *prepend = ",";
  3662. if (first) {
  3663. prepend = KERN_INFO "Floppy drive(s):";
  3664. first = 0;
  3665. }
  3666. printk("%s fd%d is %s", prepend, drive, name);
  3667. register_devfs_entries(drive);
  3668. }
  3669. *UDP = *params;
  3670. }
  3671. if (!first)
  3672. printk("n");
  3673. }
  3675. static int floppy_release(struct inode *inode, struct file *filp)
  3676. {
  3677. int drive = (long)inode->i_bdev->bd_disk->private_data;
  3679. down(&open_lock);
  3680. if (UDRS->fd_ref < 0)
  3681. UDRS->fd_ref = 0;
  3682. else if (!UDRS->fd_ref--) {
  3683. DPRINT("floppy_release with fd_ref == 0");
  3684. UDRS->fd_ref = 0;
  3685. }
  3686. if (!UDRS->fd_ref)
  3687. opened_bdev[drive] = NULL;
  3688. floppy_release_irq_and_dma();
  3689. up(&open_lock);
  3690. return 0;
  3691. }
  3693. /*
  3694.  * floppy_open check for aliasing (/dev/fd0 can be the same as
  3695.  * /dev/PS0 etc), and disallows simultaneous access to the same
  3696.  * drive with different device numbers.
  3697.  */
  3698. static int floppy_open(struct inode *inode, struct file *filp)
  3699. {
  3700. int drive = (long)inode->i_bdev->bd_disk->private_data;
  3701. int old_dev;
  3702. int try;
  3703. int res = -EBUSY;
  3704. char *tmp;
  3706. filp->private_data = (void *)0;
  3707. down(&open_lock);
  3708. old_dev = UDRS->fd_device;
  3709. if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
  3710. goto out2;
  3712. if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
  3713. USETF(FD_DISK_CHANGED);
  3714. USETF(FD_VERIFY);
  3715. }
  3717. if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
  3718. goto out2;
  3720. if (floppy_grab_irq_and_dma())
  3721. goto out2;
  3723. if (filp->f_flags & O_EXCL)
  3724. UDRS->fd_ref = -1;
  3725. else
  3726. UDRS->fd_ref++;
  3728. opened_bdev[drive] = inode->i_bdev;
  3730. res = -ENXIO;
  3732. if (!floppy_track_buffer) {
  3733. /* if opening an ED drive, reserve a big buffer,
  3734.  * else reserve a small one */
  3735. if ((UDP->cmos == 6) || (UDP->cmos == 5))
  3736. try = 64; /* Only 48 actually useful */
  3737. else
  3738. try = 32; /* Only 24 actually useful */
  3740. tmp = (char *)fd_dma_mem_alloc(1024 * try);
  3741. if (!tmp && !floppy_track_buffer) {
  3742. try >>= 1; /* buffer only one side */
  3743. INFBOUND(try, 16);
  3744. tmp = (char *)fd_dma_mem_alloc(1024 * try);
  3745. }
  3746. if (!tmp && !floppy_track_buffer) {
  3747. fallback_on_nodma_alloc(&tmp, 2048 * try);
  3748. }
  3749. if (!tmp && !floppy_track_buffer) {
  3750. DPRINT("Unable to allocate DMA memoryn");
  3751. goto out;
  3752. }
  3753. if (floppy_track_buffer) {
  3754. if (tmp)
  3755. fd_dma_mem_free((unsigned long)tmp, try * 1024);
  3756. } else {
  3757. buffer_min = buffer_max = -1;
  3758. floppy_track_buffer = tmp;
  3759. max_buffer_sectors = try;
  3760. }
  3761. }
  3763. UDRS->fd_device = iminor(inode);
  3764. set_capacity(disks[drive], floppy_sizes[iminor(inode)]);
  3765. if (old_dev != -1 && old_dev != iminor(inode)) {
  3766. if (buffer_drive == drive)
  3767. buffer_track = -1;
  3768. }
  3770. /* Allow ioctls if we have write-permissions even if read-only open.
  3771.  * Needed so that programs such as fdrawcmd still can work on write
  3772.  * protected disks */
  3773. if (filp->f_mode & 2
  3774.     || permission(filp->f_dentry->d_inode, 2, NULL) == 0)
  3775. filp->private_data = (void *)8;
  3777. if (UFDCS->rawcmd == 1)
  3778. UFDCS->rawcmd = 2;
  3780. if (!(filp->f_flags & O_NDELAY)) {
  3781. if (filp->f_mode & 3) {
  3782. UDRS->last_checked = 0;
  3783. check_disk_change(inode->i_bdev);
  3784. if (UTESTF(FD_DISK_CHANGED))
  3785. goto out;
  3786. }
  3787. res = -EROFS;
  3788. if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
  3789. goto out;
  3790. }
  3791. up(&open_lock);
  3792. return 0;
  3793. out:
  3794. if (UDRS->fd_ref < 0)
  3795. UDRS->fd_ref = 0;
  3796. else
  3797. UDRS->fd_ref--;
  3798. if (!UDRS->fd_ref)
  3799. opened_bdev[drive] = NULL;
  3800. floppy_release_irq_and_dma();
  3801. out2:
  3802. up(&open_lock);
  3803. return res;
  3804. }
  3806. /*
  3807.  * Check if the disk has been changed or if a change has been faked.
  3808.  */
  3809. static int check_floppy_change(struct gendisk *disk)
  3810. {
  3811. int drive = (long)disk->private_data;
  3813. if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
  3814. return 1;
  3816. if (UDP->checkfreq < (int)(jiffies - UDRS->last_checked)) {
  3817. if (floppy_grab_irq_and_dma()) {
  3818. return 1;
  3819. }
  3821. lock_fdc(drive, 0);
  3822. poll_drive(0, 0);
  3823. process_fd_request();
  3824. floppy_release_irq_and_dma();
  3825. }
  3827. if (UTESTF(FD_DISK_CHANGED) ||
  3828.     UTESTF(FD_VERIFY) ||
  3829.     test_bit(drive, &fake_change) ||
  3830.     (!ITYPE(UDRS->fd_device) && !current_type[drive]))
  3831. return 1;
  3832. return 0;
  3833. }
  3835. /*
  3836.  * This implements "read block 0" for floppy_revalidate().
  3837.  * Needed for format autodetection, checking whether there is
  3838.  * a disk in the drive, and whether that disk is writable.
  3839.  */
  3841. static int floppy_rb0_complete(struct bio *bio, unsigned int bytes_done,
  3842.        int err)
  3843. {
  3844. if (bio->bi_size)
  3845. return 1;
  3847. complete((struct completion *)bio->bi_private);
  3848. return 0;
  3849. }
  3851. static int __floppy_read_block_0(struct block_device *bdev)
  3852. {
  3853. struct bio bio;
  3854. struct bio_vec bio_vec;
  3855. struct completion complete;
  3856. struct page *page;
  3857. size_t size;
  3859. page = alloc_page(GFP_NOIO);
  3860. if (!page) {
  3861. process_fd_request();
  3862. return -ENOMEM;
  3863. }
  3865. size = bdev->bd_block_size;
  3866. if (!size)
  3867. size = 1024;
  3869. bio_init(&bio);
  3870. bio.bi_io_vec = &bio_vec;
  3871. bio_vec.bv_page = page;
  3872. bio_vec.bv_len = size;
  3873. bio_vec.bv_offset = 0;
  3874. bio.bi_vcnt = 1;
  3875. bio.bi_idx = 0;
  3876. bio.bi_size = size;
  3877. bio.bi_bdev = bdev;
  3878. bio.bi_sector = 0;
  3879. init_completion(&complete);
  3880. bio.bi_private = &complete;
  3881. bio.bi_end_io = floppy_rb0_complete;
  3883. submit_bio(READ, &bio);
  3884. generic_unplug_device(bdev_get_queue(bdev));
  3885. process_fd_request();
  3886. wait_for_completion(&complete);
  3888. __free_page(page);
  3890. return 0;
  3891. }
  3893. /* revalidate the floppy disk, i.e. trigger format autodetection by reading
  3894.  * the bootblock (block 0). "Autodetection" is also needed to check whether
  3895.  * there is a disk in the drive at all... Thus we also do it for fixed
  3896.  * geometry formats */
  3897. static int floppy_revalidate(struct gendisk *disk)
  3898. {
  3899. int drive = (long)disk->private_data;
  3900. #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
  3901. int cf;
  3902. int res = 0;
  3904. if (UTESTF(FD_DISK_CHANGED) ||
  3905.     UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
  3906. if (usage_count == 0) {
  3907. printk("VFS: revalidate called on non-open device.n");
  3908. return -EFAULT;
  3909. }
  3910. lock_fdc(drive, 0);
  3911. cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
  3912. if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
  3913. process_fd_request(); /*already done by another thread */
  3914. return 0;
  3915. }
  3916. UDRS->maxblock = 0;
  3917. UDRS->maxtrack = 0;
  3918. if (buffer_drive == drive)
  3919. buffer_track = -1;
  3920. clear_bit(drive, &fake_change);
  3921. UCLEARF(FD_DISK_CHANGED);
  3922. if (cf)
  3923. UDRS->generation++;
  3924. if (NO_GEOM) {
  3925. /* auto-sensing */
  3926. res = __floppy_read_block_0(opened_bdev[drive]);
  3927. } else {
  3928. if (cf)
  3929. poll_drive(0, FD_RAW_NEED_DISK);
  3930. process_fd_request();
  3931. }
  3932. }
  3933. set_capacity(disk, floppy_sizes[UDRS->fd_device]);
  3934. return res;
  3935. }
  3937. static struct block_device_operations floppy_fops = {
  3938. .owner = THIS_MODULE,
  3939. .open = floppy_open,
  3940. .release = floppy_release,
  3941. .ioctl = fd_ioctl,
  3942. .media_changed = check_floppy_change,
  3943. .revalidate_disk = floppy_revalidate,
  3944. };
  3945. static char *table[] = {
  3946. "", "d360", "h1200", "u360", "u720", "h360", "h720",
  3947. "u1440", "u2880", "CompaQ", "h1440", "u1680", "h410",
  3948. "u820", "h1476", "u1722", "h420", "u830", "h1494", "u1743",
  3949. "h880", "u1040", "u1120", "h1600", "u1760", "u1920",
  3950. "u3200", "u3520", "u3840", "u1840", "u800", "u1600",
  3951. NULL
  3952. };
  3953. static int t360[] = { 1, 0 },
  3954. t1200[] = { 2, 5, 6, 10, 12, 14, 16, 18, 20, 23, 0 },
  3955. t3in[] = { 8, 9, 26, 27, 28, 7, 11, 15, 19, 24, 25, 29, 31, 3, 4, 13,
  3956. 17, 21, 22, 30, 0 };
  3957. static int *table_sup[] =
  3958.     { NULL, t360, t1200, t3in + 5 + 8, t3in + 5, t3in, t3in };
  3960. static void __init register_devfs_entries(int drive)
  3961. {
  3962. int base_minor = (drive < 4) ? drive : (124 + drive);
  3964. if (UDP->cmos < NUMBER(default_drive_params)) {
  3965. int i = 0;
  3966. do {
  3967. int minor = base_minor + (table_sup[UDP->cmos][i] << 2);
  3969. devfs_mk_bdev(MKDEV(FLOPPY_MAJOR, minor),
  3970.       S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP |
  3971.       S_IWGRP, "floppy/%d%s", drive,
  3972.       table[table_sup[UDP->cmos][i]]);
  3973. } while (table_sup[UDP->cmos][i++]);
  3974. }
  3975. }
  3977. /*
  3978.  * Floppy Driver initialization
  3979.  * =============================
  3980.  */
  3982. /* Determine the floppy disk controller type */
  3983. /* This routine was written by David C. Niemi */
  3984. static char __init get_fdc_version(void)
  3985. {
  3986. int r;
  3988. output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */
  3989. if (FDCS->reset)
  3990. return FDC_NONE;
  3991. if ((r = result()) <= 0x00)
  3992. return FDC_NONE; /* No FDC present ??? */
  3993. if ((r == 1) && (reply_buffer[0] == 0x80)) {
  3994. printk(KERN_INFO "FDC %d is an 8272An", fdc);
  3995. return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
  3996. }
  3997. if (r != 10) {
  3998. printk
  3999.     ("FDC %d init: DUMPREGS: unexpected return of %d bytes.n",
  4000.      fdc, r);
  4001. return FDC_UNKNOWN;
  4002. }
  4004. if (!fdc_configure()) {
  4005. printk(KERN_INFO "FDC %d is an 82072n", fdc);
  4006. return FDC_82072; /* 82072 doesn't know CONFIGURE */
  4007. }
  4009. output_byte(FD_PERPENDICULAR);
  4010. if (need_more_output() == MORE_OUTPUT) {
  4011. output_byte(0);
  4012. } else {
  4013. printk(KERN_INFO "FDC %d is an 82072An", fdc);
  4014. return FDC_82072A; /* 82072A as found on Sparcs. */
  4015. }
  4017. output_byte(FD_UNLOCK);
  4018. r = result();
  4019. if ((r == 1) && (reply_buffer[0] == 0x80)) {
  4020. printk(KERN_INFO "FDC %d is a pre-1991 82077n", fdc);
  4021. return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know 
  4022.  * LOCK/UNLOCK */
  4023. }
  4024. if ((r != 1) || (reply_buffer[0] != 0x00)) {
  4025. printk("FDC %d init: UNLOCK: unexpected return of %d bytes.n",
  4026.        fdc, r);
  4027. return FDC_UNKNOWN;
  4028. }
  4029. output_byte(FD_PARTID);
  4030. r = result();
  4031. if (r != 1) {
  4032. printk("FDC %d init: PARTID: unexpected return of %d bytes.n",
  4033.        fdc, r);
  4034. return FDC_UNKNOWN;
  4035. }
  4036. if (reply_buffer[0] == 0x80) {
  4037. printk(KERN_INFO "FDC %d is a post-1991 82077n", fdc);
  4038. return FDC_82077; /* Revised 82077AA passes all the tests */
  4039. }
  4040. switch (reply_buffer[0] >> 5) {
  4041. case 0x0:
  4042. /* Either a 82078-1 or a 82078SL running at 5Volt */
  4043. printk(KERN_INFO "FDC %d is an 82078.n", fdc);
  4044. return FDC_82078;
  4045. case 0x1:
  4046. printk(KERN_INFO "FDC %d is a 44pin 82078n", fdc);
  4047. return FDC_82078;
  4048. case 0x2:
  4049. printk(KERN_INFO "FDC %d is a S82078Bn", fdc);
  4050. return FDC_S82078B;
  4051. case 0x3:
  4052. printk(KERN_INFO "FDC %d is a National Semiconductor PC87306n",
  4053.        fdc);
  4054. return FDC_87306;
  4055. default:
  4056. printk(KERN_INFO
  4057.        "FDC %d init: 82078 variant with unknown PARTID=%d.n",
  4058.        fdc, reply_buffer[0] >> 5);
  4059. return FDC_82078_UNKN;
  4060. }
  4061. } /* get_fdc_version */
  4063. /* lilo configuration */
  4065. static void __init floppy_set_flags(int *ints, int param, int param2)
  4066. {
  4067. int i;
  4069. for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
  4070. if (param)
  4071. default_drive_params[i].params.flags |= param2;
  4072. else
  4073. default_drive_params[i].params.flags &= ~param2;
  4074. }
  4075. DPRINT("%s flag 0x%xn", param2 ? "Setting" : "Clearing", param);
  4076. }
  4078. static void __init daring(int *ints, int param, int param2)
  4079. {
  4080. int i;
  4082. for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
  4083. if (param) {
  4084. default_drive_params[i].params.select_delay = 0;
  4085. default_drive_params[i].params.flags |=
  4086.     FD_SILENT_DCL_CLEAR;
  4087. } else {
  4088. default_drive_params[i].params.select_delay =
  4089.     2 * HZ / 100;
  4090. default_drive_params[i].params.flags &=
  4091.     ~FD_SILENT_DCL_CLEAR;
  4092. }
  4093. }
  4094. DPRINT("Assuming %s floppy hardwaren", param ? "standard" : "broken");
  4095. }
  4097. static void __init set_cmos(int *ints, int dummy, int dummy2)
  4098. {
  4099. int current_drive = 0;
  4101. if (ints[0] != 2) {
  4102. DPRINT("wrong number of parameters for CMOSn");
  4103. return;
  4104. }
  4105. current_drive = ints[1];
  4106. if (current_drive < 0 || current_drive >= 8) {
  4107. DPRINT("bad drive for set_cmosn");
  4108. return;
  4109. }
  4110. #if N_FDC > 1
  4111. if (current_drive >= 4 && !FDC2)
  4112. FDC2 = 0x370;
  4113. #endif
  4114. DP->cmos = ints[2];
  4115. DPRINT("setting CMOS code to %dn", ints[2]);
  4116. }
  4118. static struct param_table {
  4119. const char *name;
  4120. void (*fn) (int *ints, int param, int param2);
  4121. int *var;
  4122. int def_param;
  4123. int param2;
  4124. } config_params[] __initdata = {
  4125. {"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
  4126. {"all_drives", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
  4127. {"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
  4128. {"irq", NULL, &FLOPPY_IRQ, 6, 0},
  4129. {"dma", NULL, &FLOPPY_DMA, 2, 0},
  4130. {"daring", daring, NULL, 1, 0},
  4131. #if N_FDC > 1
  4132. {"two_fdc", NULL, &FDC2, 0x370, 0},
  4133. {"one_fdc", NULL, &FDC2, 0, 0},
  4134. #endif
  4135. {"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
  4136. {"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
  4137. {"messages", floppy_set_flags, NULL, 1, FTD_MSG},
  4138. {"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
  4139. {"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
  4140. {"nodma", NULL, &can_use_virtual_dma, 1, 0},
  4141. {"omnibook", NULL, &can_use_virtual_dma, 1, 0},
  4142. {"yesdma", NULL, &can_use_virtual_dma, 0, 0},
  4143. {"fifo_depth", NULL, &fifo_depth, 0xa, 0},
  4144. {"nofifo", NULL, &no_fifo, 0x20, 0},
  4145. {"usefifo", NULL, &no_fifo, 0, 0},
  4146. {"cmos", set_cmos, NULL, 0, 0},
  4147. {"slow", NULL, &slow_floppy, 1, 0},
  4148. {"unexpected_interrupts", NULL, &print_unex, 1, 0},
  4149. {"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
  4150. {"L40SX", NULL, &print_unex, 0, 0}
  4152. EXTRA_FLOPPY_PARAMS
  4153. };
  4155. static int __init floppy_setup(char *str)
  4156. {
  4157. int i;
  4158. int param;
  4159. int ints[11];
  4161. str = get_options(str, ARRAY_SIZE(ints), ints);
  4162. if (str) {
  4163. for (i = 0; i < ARRAY_SIZE(config_params); i++) {
  4164. if (strcmp(str, config_params[i].name) == 0) {
  4165. if (ints[0])
  4166. param = ints[1];
  4167. else
  4168. param = config_params[i].def_param;
  4169. if (config_params[i].fn)
  4170. config_params[i].
  4171.     fn(ints, param,
  4172.        config_params[i].param2);
  4173. if (config_params[i].var) {
  4174. DPRINT("%s=%dn", str, param);
  4175. *config_params[i].var = param;
  4176. }
  4177. return 1;
  4178. }
  4179. }
  4180. }
  4181. if (str) {
  4182. DPRINT("unknown floppy option [%s]n", str);
  4184. DPRINT("allowed options are:");
  4185. for (i = 0; i < ARRAY_SIZE(config_params); i++)
  4186. printk(" %s", config_params[i].name);
  4187. printk("n");
  4188. } else
  4189. DPRINT("botched floppy optionn");
  4190. DPRINT("Read Documentation/floppy.txtn");
  4191. return 0;
  4192. }
  4194. static int have_no_fdc = -ENODEV;
  4196. static ssize_t floppy_cmos_show(struct device *dev,
  4197. struct device_attribute *attr, char *buf)
  4198. {
  4199. struct platform_device *p;
  4200. int drive;
  4202. p = container_of(dev, struct platform_device,dev);
  4203. drive = p->id;
  4204. return sprintf(buf, "%Xn", UDP->cmos);
  4205. }
  4206. DEVICE_ATTR(cmos,S_IRUGO,floppy_cmos_show,NULL);
  4208. static void floppy_device_release(struct device *dev)
  4209. {
  4210. complete(&device_release);
  4211. }
  4213. static struct platform_device floppy_device[N_DRIVE];
  4215. static struct kobject *floppy_find(dev_t dev, int *part, void *data)
  4216. {
  4217. int drive = (*part & 3) | ((*part & 0x80) >> 5);
  4218. if (drive >= N_DRIVE ||
  4219.     !(allowed_drive_mask & (1 << drive)) ||
  4220.     fdc_state[FDC(drive)].version == FDC_NONE)
  4221. return NULL;
  4222. if (((*part >> 2) & 0x1f) >= NUMBER(floppy_type))
  4223. return NULL;
  4224. *part = 0;
  4225. return get_disk(disks[drive]);
  4226. }
  4228. static int __init floppy_init(void)
  4229. {
  4230. int i, unit, drive;
  4231. int err, dr;
  4233. raw_cmd = NULL;
  4235. for (dr = 0; dr < N_DRIVE; dr++) {
  4236. disks[dr] = alloc_disk(1);
  4237. if (!disks[dr]) {
  4238. err = -ENOMEM;
  4239. goto out_put_disk;
  4240. }
  4242. disks[dr]->major = FLOPPY_MAJOR;
  4243. disks[dr]->first_minor = TOMINOR(dr);
  4244. disks[dr]->fops = &floppy_fops;
  4245. sprintf(disks[dr]->disk_name, "fd%d", dr);
  4247. init_timer(&motor_off_timer[dr]);
  4248. motor_off_timer[dr].data = dr;
  4249. motor_off_timer[dr].function = motor_off_callback;
  4250. }
  4252. devfs_mk_dir("floppy");
  4254. err = register_blkdev(FLOPPY_MAJOR, "fd");
  4255. if (err)
  4256. goto out_devfs_remove;
  4258. floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
  4259. if (!floppy_queue) {
  4260. err = -ENOMEM;
  4261. goto out_unreg_blkdev;
  4262. }
  4263. blk_queue_max_sectors(floppy_queue, 64);
  4265. blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
  4266.     floppy_find, NULL, NULL);
  4268. for (i = 0; i < 256; i++)
  4269. if (ITYPE(i))
  4270. floppy_sizes[i] = floppy_type[ITYPE(i)].size;
  4271. else
  4272. floppy_sizes[i] = MAX_DISK_SIZE << 1;
  4274. reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
  4275. config_types();
  4277. for (i = 0; i < N_FDC; i++) {
  4278. fdc = i;
  4279. CLEARSTRUCT(FDCS);
  4280. FDCS->dtr = -1;
  4281. FDCS->dor = 0x4;
  4282. #if defined(__sparc__) || defined(__mc68000__)
  4283. /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
  4284. #ifdef __mc68000__
  4285. if (MACH_IS_SUN3X)
  4286. #endif
  4287. FDCS->version = FDC_82072A;
  4288. #endif
  4289. }
  4291. use_virtual_dma = can_use_virtual_dma & 1;
  4292. #if defined(CONFIG_PPC64)
  4293. if (check_legacy_ioport(FDC1)) {
  4294. del_timer(&fd_timeout);
  4295. err = -ENODEV;
  4296. goto out_unreg_region;
  4297. }
  4298. #endif
  4299. fdc_state[0].address = FDC1;
  4300. if (fdc_state[0].address == -1) {
  4301. del_timer(&fd_timeout);
  4302. err = -ENODEV;
  4303. goto out_unreg_region;
  4304. }
  4305. #if N_FDC > 1
  4306. fdc_state[1].address = FDC2;
  4307. #endif
  4309. fdc = 0; /* reset fdc in case of unexpected interrupt */
  4310. err = floppy_grab_irq_and_dma();
  4311. if (err) {
  4312. del_timer(&fd_timeout);
  4313. err = -EBUSY;
  4314. goto out_unreg_region;
  4315. }
  4317. /* initialise drive state */
  4318. for (drive = 0; drive < N_DRIVE; drive++) {
  4319. CLEARSTRUCT(UDRS);
  4320. CLEARSTRUCT(UDRWE);
  4321. USETF(FD_DISK_NEWCHANGE);
  4322. USETF(FD_DISK_CHANGED);
  4323. USETF(FD_VERIFY);
  4324. UDRS->fd_device = -1;
  4325. floppy_track_buffer = NULL;
  4326. max_buffer_sectors = 0;
  4327. }
  4328. /*
  4329.  * Small 10 msec delay to let through any interrupt that
  4330.  * initialization might have triggered, to not
  4331.  * confuse detection:
  4332.  */
  4333. msleep(10);
  4335. for (i = 0; i < N_FDC; i++) {
  4336. fdc = i;
  4337. FDCS->driver_version = FD_DRIVER_VERSION;
  4338. for (unit = 0; unit < 4; unit++)
  4339. FDCS->track[unit] = 0;
  4340. if (FDCS->address == -1)
  4341. continue;
  4342. FDCS->rawcmd = 2;
  4343. if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
  4344. /* free ioports reserved by floppy_grab_irq_and_dma() */
  4345. release_region(FDCS->address + 2, 4);
  4346. release_region(FDCS->address + 7, 1);
  4347. FDCS->address = -1;
  4348. FDCS->version = FDC_NONE;
  4349. continue;
  4350. }
  4351. /* Try to determine the floppy controller type */
  4352. FDCS->version = get_fdc_version();
  4353. if (FDCS->version == FDC_NONE) {
  4354. /* free ioports reserved by floppy_grab_irq_and_dma() */
  4355. release_region(FDCS->address + 2, 4);
  4356. release_region(FDCS->address + 7, 1);
  4357. FDCS->address = -1;
  4358. continue;
  4359. }
  4360. if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
  4361. can_use_virtual_dma = 0;
  4363. have_no_fdc = 0;
  4364. /* Not all FDCs seem to be able to handle the version command
  4365.  * properly, so force a reset for the standard FDC clones,
  4366.  * to avoid interrupt garbage.
  4367.  */
  4368. user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
  4369. }
  4370. fdc = 0;
  4371. del_timer(&fd_timeout);
  4372. current_drive = 0;
  4373. floppy_release_irq_and_dma();
  4374. initialising = 0;
  4375. if (have_no_fdc) {
  4376. DPRINT("no floppy controllers foundn");
  4377. err = have_no_fdc;
  4378. goto out_flush_work;
  4379. }
  4381. for (drive = 0; drive < N_DRIVE; drive++) {
  4382. if (!(allowed_drive_mask & (1 << drive)))
  4383. continue;
  4384. if (fdc_state[FDC(drive)].version == FDC_NONE)
  4385. continue;
  4387. floppy_device[drive].name = floppy_device_name;
  4388. floppy_device[drive].id = drive;
  4389. floppy_device[drive].dev.release = floppy_device_release;
  4391. err = platform_device_register(&floppy_device[drive]);
  4392. if (err)
  4393. goto out_flush_work;
  4395. device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
  4396. /* to be cleaned up... */
  4397. disks[drive]->private_data = (void *)(long)drive;
  4398. disks[drive]->queue = floppy_queue;
  4399. disks[drive]->flags |= GENHD_FL_REMOVABLE;
  4400. disks[drive]->driverfs_dev = &floppy_device[drive].dev;
  4401. add_disk(disks[drive]);
  4402. }
  4404. return 0;
  4406. out_flush_work:
  4407. flush_scheduled_work();
  4408. if (usage_count)
  4409. floppy_release_irq_and_dma();
  4410. out_unreg_region:
  4411. blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
  4412. blk_cleanup_queue(floppy_queue);
  4413. out_unreg_blkdev:
  4414. unregister_blkdev(FLOPPY_MAJOR, "fd");
  4415. out_devfs_remove:
  4416. devfs_remove("floppy");
  4417. out_put_disk:
  4418. while (dr--) {
  4419. del_timer(&motor_off_timer[dr]);
  4420. put_disk(disks[dr]);
  4421. }
  4422. return err;
  4423. }
  4425. static DEFINE_SPINLOCK(floppy_usage_lock);
  4427. static int floppy_grab_irq_and_dma(void)
  4428. {
  4429. unsigned long flags;
  4431. spin_lock_irqsave(&floppy_usage_lock, flags);
  4432. if (usage_count++) {
  4433. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  4434. return 0;
  4435. }
  4436. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  4437. if (fd_request_irq()) {
  4438. DPRINT("Unable to grab IRQ%d for the floppy drivern",
  4439.        FLOPPY_IRQ);
  4440. spin_lock_irqsave(&floppy_usage_lock, flags);
  4441. usage_count--;
  4442. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  4443. return -1;
  4444. }
  4445. if (fd_request_dma()) {
  4446. DPRINT("Unable to grab DMA%d for the floppy drivern",
  4447.        FLOPPY_DMA);
  4448. fd_free_irq();
  4449. spin_lock_irqsave(&floppy_usage_lock, flags);
  4450. usage_count--;
  4451. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  4452. return -1;
  4453. }
  4455. for (fdc = 0; fdc < N_FDC; fdc++) {
  4456. if (FDCS->address != -1) {
  4457. if (!request_region(FDCS->address + 2, 4, "floppy")) {
  4458. DPRINT("Floppy io-port 0x%04lx in usen",
  4459.        FDCS->address + 2);
  4460. goto cleanup1;
  4461. }
  4462. if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
  4463. DPRINT("Floppy io-port 0x%04lx in usen",
  4464.        FDCS->address + 7);
  4465. goto cleanup2;
  4466. }
  4467. /* address + 6 is reserved, and may be taken by IDE.
  4468.  * Unfortunately, Adaptec doesn't know this :-(, */
  4469. }
  4470. }
  4471. for (fdc = 0; fdc < N_FDC; fdc++) {
  4472. if (FDCS->address != -1) {
  4473. reset_fdc_info(1);
  4474. fd_outb(FDCS->dor, FD_DOR);
  4475. }
  4476. }
  4477. fdc = 0;
  4478. set_dor(0, ~0, 8); /* avoid immediate interrupt */
  4480. for (fdc = 0; fdc < N_FDC; fdc++)
  4481. if (FDCS->address != -1)
  4482. fd_outb(FDCS->dor, FD_DOR);
  4483. /*
  4484.  *      The driver will try and free resources and relies on us
  4485.  *      to know if they were allocated or not.
  4486.  */
  4487. fdc = 0;
  4488. irqdma_allocated = 1;
  4489. return 0;
  4490. cleanup2:
  4491. release_region(FDCS->address + 2, 4);
  4492. cleanup1:
  4493. fd_free_irq();
  4494. fd_free_dma();
  4495. while (--fdc >= 0) {
  4496. release_region(FDCS->address + 2, 4);
  4497. release_region(FDCS->address + 7, 1);
  4498. }
  4499. spin_lock_irqsave(&floppy_usage_lock, flags);
  4500. usage_count--;
  4501. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  4502. return -1;
  4503. }
  4505. static void floppy_release_irq_and_dma(void)
  4506. {
  4507. int old_fdc;
  4508. #ifdef FLOPPY_SANITY_CHECK
  4509. #ifndef __sparc__
  4510. int drive;
  4511. #endif
  4512. #endif
  4513. long tmpsize;
  4514. unsigned long tmpaddr;
  4515. unsigned long flags;
  4517. spin_lock_irqsave(&floppy_usage_lock, flags);
  4518. if (--usage_count) {
  4519. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  4520. return;
  4521. }
  4522. spin_unlock_irqrestore(&floppy_usage_lock, flags);
  4523. if (irqdma_allocated) {
  4524. fd_disable_dma();
  4525. fd_free_dma();
  4526. fd_free_irq();
  4527. irqdma_allocated = 0;
  4528. }
  4529. set_dor(0, ~0, 8);
  4530. #if N_FDC > 1
  4531. set_dor(1, ~8, 0);
  4532. #endif
  4533. floppy_enable_hlt();
  4535. if (floppy_track_buffer && max_buffer_sectors) {
  4536. tmpsize = max_buffer_sectors * 1024;
  4537. tmpaddr = (unsigned long)floppy_track_buffer;
  4538. floppy_track_buffer = NULL;
  4539. max_buffer_sectors = 0;
  4540. buffer_min = buffer_max = -1;
  4541. fd_dma_mem_free(tmpaddr, tmpsize);
  4542. }
  4543. #ifdef FLOPPY_SANITY_CHECK
  4544. #ifndef __sparc__
  4545. for (drive = 0; drive < N_FDC * 4; drive++)
  4546. if (timer_pending(motor_off_timer + drive))
  4547. printk("motor off timer %d still activen", drive);
  4548. #endif
  4550. if (timer_pending(&fd_timeout))
  4551. printk("floppy timer still active:%sn", timeout_message);
  4552. if (timer_pending(&fd_timer))
  4553. printk("auxiliary floppy timer still activen");
  4554. if (floppy_work.pending)
  4555. printk("work still pendingn");
  4556. #endif
  4557. old_fdc = fdc;
  4558. for (fdc = 0; fdc < N_FDC; fdc++)
  4559. if (FDCS->address != -1) {
  4560. release_region(FDCS->address + 2, 4);
  4561. release_region(FDCS->address + 7, 1);
  4562. }
  4563. fdc = old_fdc;
  4564. }
  4566. #ifdef MODULE
  4568. static char *floppy;
  4570. static void unregister_devfs_entries(int drive)
  4571. {
  4572. int i;
  4574. if (UDP->cmos < NUMBER(default_drive_params)) {
  4575. i = 0;
  4576. do {
  4577. devfs_remove("floppy/%d%s", drive,
  4578.      table[table_sup[UDP->cmos][i]]);
  4579. } while (table_sup[UDP->cmos][i++]);
  4580. }
  4581. }
  4583. static void __init parse_floppy_cfg_string(char *cfg)
  4584. {
  4585. char *ptr;
  4587. while (*cfg) {
  4588. for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != 't'; cfg++) ;
  4589. if (*cfg) {
  4590. *cfg = '';
  4591. cfg++;
  4592. }
  4593. if (*ptr)
  4594. floppy_setup(ptr);
  4595. }
  4596. }
  4598. int init_module(void)
  4599. {
  4600. if (floppy)
  4601. parse_floppy_cfg_string(floppy);
  4602. return floppy_init();
  4603. }
  4605. void cleanup_module(void)
  4606. {
  4607. int drive;
  4609. init_completion(&device_release);
  4610. blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
  4611. unregister_blkdev(FLOPPY_MAJOR, "fd");
  4613. for (drive = 0; drive < N_DRIVE; drive++) {
  4614. del_timer_sync(&motor_off_timer[drive]);
  4616. if ((allowed_drive_mask & (1 << drive)) &&
  4617.     fdc_state[FDC(drive)].version != FDC_NONE) {
  4618. del_gendisk(disks[drive]);
  4619. unregister_devfs_entries(drive);
  4620. device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
  4621. platform_device_unregister(&floppy_device[drive]);
  4622. }
  4623. put_disk(disks[drive]);
  4624. }
  4625. devfs_remove("floppy");
  4627. del_timer_sync(&fd_timeout);
  4628. del_timer_sync(&fd_timer);
  4629. blk_cleanup_queue(floppy_queue);
  4631. if (usage_count)
  4632. floppy_release_irq_and_dma();
  4634. /* eject disk, if any */
  4635. fd_eject(0);
  4637. wait_for_completion(&device_release);
  4638. }
  4640. module_param(floppy, charp, 0);
  4641. module_param(FLOPPY_IRQ, int, 0);
  4642. module_param(FLOPPY_DMA, int, 0);
  4643. MODULE_AUTHOR("Alain L. Knaff");
  4644. MODULE_SUPPORTED_DEVICE("fd");
  4645. MODULE_LICENSE("GPL");
  4647. #else
  4649. __setup("floppy=", floppy_setup);
  4650. module_init(floppy_init)
  4651. #endif
  4653. MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);