1/* 2 * Architecture specific parts of the Floppy driver 3 * include/asm-i386/floppy.h 4 * 5 * This file is subject to the terms and conditions of the GNU General Public 6 * License. See the file "COPYING" in the main directory of this archive 7 * for more details. 8 * 9 * Copyright (C) 1995 10 */ 11#ifndef __ASM_SH_FLOPPY_H 12#define __ASM_SH_FLOPPY_H 13 14#include <linux/vmalloc.h> 15 16 17/* 18 * The DMA channel used by the floppy controller cannot access data at 19 * addresses >= 16MB 20 * 21 * Went back to the 1MB limit, as some people had problems with the floppy 22 * driver otherwise. It doesn't matter much for performance anyway, as most 23 * floppy accesses go through the track buffer. 24 */ 25#define _CROSS_64KB(a,s,vdma) \ 26(!vdma && ((unsigned long)(a)/K_64 != ((unsigned long)(a) + (s) - 1) / K_64)) 27 28#define CROSS_64KB(a,s) _CROSS_64KB(a,s,use_virtual_dma & 1) 29 30 31#define SW fd_routine[use_virtual_dma&1] 32#define CSW fd_routine[can_use_virtual_dma & 1] 33 34 35#define fd_inb(port) inb_p(port) 36#define fd_outb(value,port) outb_p(value,port) 37 38#define fd_request_dma() CSW._request_dma(FLOPPY_DMA,"floppy") 39#define fd_free_dma() CSW._free_dma(FLOPPY_DMA) 40#define fd_enable_irq() enable_irq(FLOPPY_IRQ) 41#define fd_disable_irq() disable_irq(FLOPPY_IRQ) 42#define fd_free_irq() free_irq(FLOPPY_IRQ, NULL) 43#define fd_get_dma_residue() SW._get_dma_residue(FLOPPY_DMA) 44#define fd_dma_mem_alloc(size) SW._dma_mem_alloc(size) 45#define fd_dma_setup(addr, size, mode, io) SW._dma_setup(addr, size, mode, io) 46 47#define FLOPPY_CAN_FALLBACK_ON_NODMA 48 49static int virtual_dma_count; 50static int virtual_dma_residue; 51static char *virtual_dma_addr; 52static int virtual_dma_mode; 53static int doing_pdma; 54 55static void floppy_hardint(int irq, void *dev_id, struct pt_regs * regs) 56{ 57 register unsigned char st; 58 59#undef TRACE_FLPY_INT 60 61#ifdef TRACE_FLPY_INT 62 static int calls=0; 63 static int bytes=0; 64 static int dma_wait=0; 65#endif 66 if(!doing_pdma) { 67 floppy_interrupt(irq, dev_id, regs); 68 return; 69 } 70 71#ifdef TRACE_FLPY_INT 72 if(!calls) 73 bytes = virtual_dma_count; 74#endif 75 76 { 77 register int lcount; 78 register char *lptr; 79 80 st = 1; 81 for(lcount=virtual_dma_count, lptr=virtual_dma_addr; 82 lcount; lcount--, lptr++) { 83 st=inb(virtual_dma_port+4) & 0xa0 ; 84 if(st != 0xa0) 85 break; 86 if(virtual_dma_mode) 87 outb_p(*lptr, virtual_dma_port+5); 88 else 89 *lptr = inb_p(virtual_dma_port+5); 90 } 91 virtual_dma_count = lcount; 92 virtual_dma_addr = lptr; 93 st = inb(virtual_dma_port+4); 94 } 95 96#ifdef TRACE_FLPY_INT 97 calls++; 98#endif 99 if(st == 0x20) 100 return; 101 if(!(st & 0x20)) { 102 virtual_dma_residue += virtual_dma_count; 103 virtual_dma_count=0; 104#ifdef TRACE_FLPY_INT 105 printk("count=%x, residue=%x calls=%d bytes=%d dma_wait=%d\n", 106 virtual_dma_count, virtual_dma_residue, calls, bytes, 107 dma_wait); 108 calls = 0; 109 dma_wait=0; 110#endif 111 doing_pdma = 0; 112 floppy_interrupt(irq, dev_id, regs); 113 return; 114 } 115#ifdef TRACE_FLPY_INT 116 if(!virtual_dma_count) 117 dma_wait++; 118#endif 119} 120 121static void fd_disable_dma(void) 122{ 123 if(! (can_use_virtual_dma & 1)) 124 disable_dma(FLOPPY_DMA); 125 doing_pdma = 0; 126 virtual_dma_residue += virtual_dma_count; 127 virtual_dma_count=0; 128} 129 130static int vdma_request_dma(unsigned int dmanr, const char * device_id) 131{ 132 return 0; 133} 134 135static void vdma_nop(unsigned int dummy) 136{ 137} 138 139 140static int vdma_get_dma_residue(unsigned int dummy) 141{ 142 return virtual_dma_count + virtual_dma_residue; 143} 144 145 146static int fd_request_irq(void) 147{ 148 if(can_use_virtual_dma) 149 return request_irq(FLOPPY_IRQ, floppy_hardint, 150 IRQF_DISABLED, "floppy", NULL); 151 else 152 return request_irq(FLOPPY_IRQ, floppy_interrupt, 153 IRQF_DISABLED, "floppy", NULL); 154} 155 156static unsigned long dma_mem_alloc(unsigned long size) 157{ 158 return __get_dma_pages(GFP_KERNEL,get_order(size)); 159} 160 161 162static unsigned long vdma_mem_alloc(unsigned long size) 163{ 164 return (unsigned long) vmalloc(size); 165 166} 167 168#define nodma_mem_alloc(size) vdma_mem_alloc(size) 169 170static void _fd_dma_mem_free(unsigned long addr, unsigned long size) 171{ 172 if((unsigned int) addr >= (unsigned int) high_memory) 173 return vfree((void *)addr); 174 else 175 free_pages(addr, get_order(size)); 176} 177 178#define fd_dma_mem_free(addr, size) _fd_dma_mem_free(addr, size) 179 180static void _fd_chose_dma_mode(char *addr, unsigned long size) 181{ 182 if(can_use_virtual_dma == 2) { 183 if((unsigned int) addr >= (unsigned int) high_memory || 184 virt_to_bus(addr) >= 0x10000000) 185 use_virtual_dma = 1; 186 else 187 use_virtual_dma = 0; 188 } else { 189 use_virtual_dma = can_use_virtual_dma & 1; 190 } 191} 192 193#define fd_chose_dma_mode(addr, size) _fd_chose_dma_mode(addr, size) 194 195 196static int vdma_dma_setup(char *addr, unsigned long size, int mode, int io) 197{ 198 doing_pdma = 1; 199 virtual_dma_port = io; 200 virtual_dma_mode = (mode == DMA_MODE_WRITE); 201 virtual_dma_addr = addr; 202 virtual_dma_count = size; 203 virtual_dma_residue = 0; 204 return 0; 205} 206 207static int hard_dma_setup(char *addr, unsigned long size, int mode, int io) 208{ 209#ifdef FLOPPY_SANITY_CHECK 210 if (CROSS_64KB(addr, size)) { 211 printk("DMA crossing 64-K boundary %p-%p\n", addr, addr+size); 212 return -1; 213 } 214#endif 215 216 dma_cache_wback_inv(addr, size); 217 218 /* actual, physical DMA */ 219 doing_pdma = 0; 220 clear_dma_ff(FLOPPY_DMA); 221 set_dma_mode(FLOPPY_DMA,mode); 222 set_dma_addr(FLOPPY_DMA,virt_to_bus(addr)); 223 set_dma_count(FLOPPY_DMA,size); 224 enable_dma(FLOPPY_DMA); 225 return 0; 226} 227 228static struct fd_routine_l { 229 int (*_request_dma)(unsigned int dmanr, const char * device_id); 230 void (*_free_dma)(unsigned int dmanr); 231 int (*_get_dma_residue)(unsigned int dummy); 232 unsigned long (*_dma_mem_alloc) (unsigned long size); 233 int (*_dma_setup)(char *addr, unsigned long size, int mode, int io); 234} fd_routine[] = { 235 { 236 request_dma, 237 free_dma, 238 get_dma_residue, 239 dma_mem_alloc, 240 hard_dma_setup 241 }, 242 { 243 vdma_request_dma, 244 vdma_nop, 245 vdma_get_dma_residue, 246 vdma_mem_alloc, 247 vdma_dma_setup 248 } 249}; 250 251 252static int FDC1 = 0x3f0; 253static int FDC2 = -1; 254 255/* 256 * Floppy types are stored in the rtc's CMOS RAM and so rtc_lock 257 * is needed to prevent corrupted CMOS RAM in case "insmod floppy" 258 * coincides with another rtc CMOS user. Paul G. 259 */ 260#define FLOPPY0_TYPE (4) 261#define FLOPPY1_TYPE (0) 262 263#define N_FDC 2 264#define N_DRIVE 8 265 266#define FLOPPY_MOTOR_MASK 0xf0 267 268#define AUTO_DMA 269 270#define EXTRA_FLOPPY_PARAMS 271 272#endif /* __ASM_SH_FLOPPY_H */ 273