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