Look Ma' what I found on my harddisk ...

 o New faster syscalls for 2.1.x, too
 o Upgrade to 2.1.89.

Don't try to run this.  It's flaky as hell.  But feel free to debug ...

1 files changed, 95 insertions, 99 deletions

diff --git a/include/asm-i386/floppy.h b/include/asm-i386/floppy.h
index eb7272ef6..2b548bb1c 100644
--- a/include/asm-i386/floppy.h
+++ b/include/asm-i386/floppy.h
@@ -3,33 +3,36 @@
 
 #include <linux/vmalloc.h>
 
+/*
+ * The DMA channel used by the floppy controller cannot access data at
+ * addresses >= 16MB
+ *
+ * Went back to the 1MB limit, as some people had problems with the floppy
+ * driver otherwise. It doesn't matter much for performance anyway, as most
+ * floppy accesses go through the track buffer.
+ */
+#define _CROSS_64KB(a,s,vdma) \
+(!vdma && ((unsigned long)(a)/K_64 != ((unsigned long)(a) + (s) - 1) / K_64))
+
+#define CROSS_64KB(a,s) _CROSS_64KB(a,s,use_virtual_dma & 1)
+
+
 #define SW fd_routine[use_virtual_dma&1]
+#define CSW fd_routine[can_use_virtual_dma & 1]
 
 
 #define fd_inb(port)			inb_p(port)
 #define fd_outb(port,value)		outb_p(port,value)
-
-#define fd_enable_dma(channel)		SW._enable_dma(channel)
-#define fd_disable_dma(channel)		SW._disable_dma(channel)
-#define fd_request_dma(channel)		SW._request_dma(channel, "floppy")
-#define fd_free_dma(channel)		SW._free_dma(channel)
-#define fd_clear_dma_ff(channel)	SW._clear_dma_ff(channel)
-#define fd_set_dma_mode(channel,mode)	SW._set_dma_mode(channel, mode)
-#define fd_set_dma_addr(channel,addr)	SW._set_dma_addr(channel, addr)
-#define fd_set_dma_count(channel,count)	SW._set_dma_count(channel ,count)
+#define fd_request_dma()		CSW._request_dma(FLOPPY_DMA,"floppy")
+#define fd_free_dma()			CSW._free_dma(FLOPPY_DMA)
 #define fd_enable_irq(irq)		enable_irq(irq)
 #define fd_disable_irq(irq)		disable_irq(irq)
-#define fd_cacheflush(addr,size)	/* nothing */
-#define fd_request_irq(irq)		SW._request_irq(irq, \
-					                floppy_interrupt, \
-							SA_INTERRUPT \
-					                | SA_SAMPLE_RANDOM, \
-							"floppy", NULL)
 #define fd_free_irq(irq)		free_irq(irq, NULL)
 #define fd_get_dma_residue(channel)	SW._get_dma_residue(channel)
-
 #define fd_dma_mem_alloc(size)		SW._dma_mem_alloc(size)
-#define fd_dma_mem_free(addr,size)	SW._dma_mem_free(addr,size)
+#define fd_dma_setup(addr, size, mode, io) SW._dma_setup(addr, size, mode, io)
+
+#define FLOPPY_CAN_FALLBACK_ON_NODMA
 
 static int virtual_dma_count=0;
 static int virtual_dma_residue=0;
@@ -42,7 +45,7 @@ static void floppy_hardint(int irq, void *dev_id, struct pt_regs * regs)
 	register unsigned char st;
 
 #undef TRACE_FLPY_INT
-#undef NO_FLOPPY_ASSEMBLER
+#define NO_FLOPPY_ASSEMBLER
 
 #ifdef TRACE_FLPY_INT
 	static int calls=0;
@@ -105,10 +108,10 @@ static void floppy_hardint(int irq, void *dev_id, struct pt_regs * regs)
 				outb_p(*lptr, virtual_dma_port+5);
 			else
 				*lptr = inb_p(virtual_dma_port+5);
-			st = inb(virtual_dma_port+4);
 		}
 		virtual_dma_count = lcount;
 		virtual_dma_addr = lptr;
+		st = inb(virtual_dma_port+4);
 	}
 #endif
 
@@ -137,16 +140,13 @@ static void floppy_hardint(int irq, void *dev_id, struct pt_regs * regs)
 #endif
 }
 
-static void vdma_enable_dma(unsigned int dummy)
-{
-	doing_pdma = 1;
-}
-
-static void vdma_disable_dma(unsigned int dummy)
+static void fd_disable_dma(void)
 {
+	if(! (can_use_virtual_dma & 1))
+		disable_dma(FLOPPY_DMA);
 	doing_pdma = 0;
 	virtual_dma_residue += virtual_dma_count;
-	virtual_dma_count=0;		
+	virtual_dma_count=0;
 }
 
 static int vdma_request_dma(unsigned int dmanr, const char * device_id)
@@ -158,26 +158,6 @@ static void vdma_nop(unsigned int dummy)
 {
 }
 
-static void vdma_set_dma_mode(unsigned int dummy,char mode)
-{
-	virtual_dma_mode = (mode  == DMA_MODE_WRITE);
-}
-
-static void hset_dma_addr(unsigned int no, char *addr)
-{
-	set_dma_addr(no, virt_to_bus(addr));
-}
-
-static void vdma_set_dma_addr(unsigned int dummy, char *addr)
-{
-	virtual_dma_addr = addr;
-}
-
-static void vdma_set_dma_count(unsigned int dummy,unsigned int count)
-{
-	virtual_dma_count = count;
-	virtual_dma_residue = 0;
-}
 
 static int vdma_get_dma_residue(unsigned int dummy)
 {
@@ -185,13 +165,15 @@ static int vdma_get_dma_residue(unsigned int dummy)
 }
 
 
-static int vdma_request_irq(unsigned int irq,
-			    void (*handler)(int, void *, struct pt_regs *),
-			    unsigned long flags, 
-			    const char *device,
-			    void *dev_id)
+static int fd_request_irq(void)
 {
-	return request_irq(irq, floppy_hardint,SA_INTERRUPT,device, dev_id);
+	if(can_use_virtual_dma)
+		return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
+						   "floppy", NULL);
+	else
+		return request_irq(FLOPPY_IRQ, floppy_interrupt,
+						   SA_INTERRUPT|SA_SAMPLE_RANDOM,
+						   "floppy", NULL);	
 
 }
 
@@ -214,73 +196,94 @@ static unsigned long dma_mem_alloc(unsigned long size)
 	return __get_dma_pages(GFP_KERNEL,__get_order(size));
 }
 
-static void dma_mem_free(unsigned long addr, unsigned long size)
-{
-	free_pages(addr, __get_order(size));
-}
 
 static unsigned long vdma_mem_alloc(unsigned long size)
 {
 	return (unsigned long) vmalloc(size);
+
 }
 
-static void vdma_mem_free(unsigned long addr, unsigned long size)
+#define nodma_mem_alloc(size) vdma_mem_alloc(size)
+
+static void _fd_dma_mem_free(unsigned long addr, unsigned long size)
+{
+	if((unsigned int) addr >= (unsigned int) high_memory)
+		return vfree((void *)addr);
+	else
+		free_pages(addr, __get_order(size));		
+}
+
+#define fd_dma_mem_free(addr, size)  _fd_dma_mem_free(addr, size) 
+
+static void _fd_chose_dma_mode(char *addr, unsigned long size)
+{
+	if(can_use_virtual_dma == 2) {
+		if((unsigned int) addr >= (unsigned int) high_memory ||
+		   virt_to_bus(addr) >= 0x1000000 ||
+		   _CROSS_64KB(addr, size, 0))
+			use_virtual_dma = 1;
+		else
+			use_virtual_dma = 0;
+	} else {
+		use_virtual_dma = can_use_virtual_dma & 1;
+	}
+}
+
+#define fd_chose_dma_mode(addr, size) _fd_chose_dma_mode(addr, size)
+
+
+static int vdma_dma_setup(char *addr, unsigned long size, int mode, int io)
 {
-	return vfree((void *)addr);
+	doing_pdma = 1;
+	virtual_dma_port = io;
+	virtual_dma_mode = (mode  == DMA_MODE_WRITE);
+	virtual_dma_addr = addr;
+	virtual_dma_count = size;
+	virtual_dma_residue = 0;
+	return 0;
+}
+
+static int hard_dma_setup(char *addr, unsigned long size, int mode, int io)
+{
+#ifdef FLOPPY_SANITY_CHECK
+	if (CROSS_64KB(addr, size)) {
+		printk("DMA crossing 64-K boundary %p-%p\n", addr, addr+size);
+		return -1;
+	}
+#endif
+	/* actual, physical DMA */
+	doing_pdma = 0;
+	clear_dma_ff(FLOPPY_DMA);
+	set_dma_mode(FLOPPY_DMA,mode);
+	set_dma_addr(FLOPPY_DMA,virt_to_bus(addr));
+	set_dma_count(FLOPPY_DMA,size);
+	enable_dma(FLOPPY_DMA);
+	return 0;
 }
 
 struct fd_routine_l {
-	void (*_enable_dma)(unsigned int dummy);
-	void (*_disable_dma)(unsigned int dummy);
 	int (*_request_dma)(unsigned int dmanr, const char * device_id);
 	void (*_free_dma)(unsigned int dmanr);
-	void (*_clear_dma_ff)(unsigned int dummy);
-	void (*_set_dma_mode)(unsigned int dummy, char mode);
-	void (*_set_dma_addr)(unsigned int dummy, char *addr);
-	void (*_set_dma_count)(unsigned int dummy, unsigned int count);
 	int (*_get_dma_residue)(unsigned int dummy);
-	int (*_request_irq)(unsigned int irq,
-			   void (*handler)(int, void *, struct pt_regs *),
-			   unsigned long flags, 
-			   const char *device,
-			   void *dev_id);
 	unsigned long (*_dma_mem_alloc) (unsigned long size);
-	void (*_dma_mem_free)(unsigned long addr, unsigned long size);
+	int (*_dma_setup)(char *addr, unsigned long size, int mode, int io);
 } fd_routine[] = {
 	{
-		enable_dma,
-		disable_dma,
 		request_dma,
 		free_dma,
-		clear_dma_ff,
-		set_dma_mode,
-		hset_dma_addr,
-		set_dma_count,
 		get_dma_residue,
-		request_irq,
 		dma_mem_alloc,
-		dma_mem_free
+		hard_dma_setup
 	},
 	{
-		vdma_enable_dma,
-		vdma_disable_dma,
 		vdma_request_dma,
 		vdma_nop,
-		vdma_nop,
-		vdma_set_dma_mode,
-		vdma_set_dma_addr,
-		vdma_set_dma_count,
 		vdma_get_dma_residue,
-		vdma_request_irq,
 		vdma_mem_alloc,
-		vdma_mem_free
+		vdma_dma_setup
 	}
 };
 
-__inline__ void virtual_dma_init(void)
-{
-	/* Nothing to do on an i386 */
-}
 
 static int FDC1 = 0x3f0;
 static int FDC2 = -1;
@@ -293,14 +296,7 @@ static int FDC2 = -1;
 
 #define FLOPPY_MOTOR_MASK 0xf0
 
-/*
- * The DMA channel used by the floppy controller cannot access data at
- * addresses >= 16MB
- *
- * Went back to the 1MB limit, as some people had problems with the floppy
- * driver otherwise. It doesn't matter much for performance anyway, as most
- * floppy accesses go through the track buffer.
- */
-#define CROSS_64KB(a,s) (((unsigned long)(a)/K_64 != ((unsigned long)(a) + (s) - 1) / K_64) && ! (use_virtual_dma & 1))
+#define AUTO_DMA
+
 
 #endif /* __ASM_I386_FLOPPY_H */