1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* sun3xflop.h: Sun3/80 specific parts of the floppy driver. 3 * 4 * Derived partially from asm-sparc/floppy.h, which is: 5 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) 6 * 7 * Sun3x version 2/4/2000 Sam Creasey (sammy@sammy.net) 8 */ 9 10 #ifndef __ASM_SUN3X_FLOPPY_H 11 #define __ASM_SUN3X_FLOPPY_H 12 13 #include <linux/pgtable.h> 14 #include <asm/page.h> 15 #include <asm/irq.h> 16 #include <asm/sun3x.h> 17 18 /* default interrupt vector */ 19 #define SUN3X_FDC_IRQ 0x40 20 21 /* some constants */ 22 #define FCR_TC 0x1 23 #define FCR_EJECT 0x2 24 #define FCR_MTRON 0x4 25 #define FCR_DSEL1 0x8 26 #define FCR_DSEL0 0x10 27 28 /* We don't need no stinkin' I/O port allocation crap. */ 29 #undef release_region 30 #undef request_region 31 #define release_region(X, Y) do { } while(0) 32 #define request_region(X, Y, Z) (1) 33 34 struct sun3xflop_private { 35 volatile unsigned char *status_r; 36 volatile unsigned char *data_r; 37 volatile unsigned char *fcr_r; 38 volatile unsigned char *fvr_r; 39 unsigned char fcr; 40 } sun3x_fdc; 41 42 /* Super paranoid... */ 43 #undef HAVE_DISABLE_HLT 44 45 /* Routines unique to each controller type on a Sun. */ 46 static unsigned char sun3x_82072_fd_inb(int port) 47 { 48 static int once = 0; 49 // udelay(5); 50 switch(port & 7) { 51 default: 52 pr_crit("floppy: Asked to read unknown port %d\n", port); 53 panic("floppy: Port bolixed."); 54 case 4: /* FD_STATUS */ 55 return (*sun3x_fdc.status_r) & ~STATUS_DMA; 56 case 5: /* FD_DATA */ 57 return (*sun3x_fdc.data_r); 58 case 7: /* FD_DIR */ 59 /* ugly hack, I can't find a way to actually detect the disk */ 60 if(!once) { 61 once = 1; 62 return 0x80; 63 } 64 return 0; 65 }; 66 panic("sun_82072_fd_inb: How did I get here?"); 67 } 68 69 static void sun3x_82072_fd_outb(unsigned char value, int port) 70 { 71 // udelay(5); 72 switch(port & 7) { 73 default: 74 pr_crit("floppy: Asked to write to unknown port %d\n", port); 75 panic("floppy: Port bolixed."); 76 case 2: /* FD_DOR */ 77 /* Oh geese, 82072 on the Sun has no DOR register, 78 * so we make do with taunting the FCR. 79 * 80 * ASSUMPTIONS: There will only ever be one floppy 81 * drive attached to a Sun controller 82 * and it will be at drive zero. 83 */ 84 85 { 86 unsigned char fcr = sun3x_fdc.fcr; 87 88 if(value & 0x10) { 89 fcr |= (FCR_DSEL0 | FCR_MTRON); 90 } else 91 fcr &= ~(FCR_DSEL0 | FCR_MTRON); 92 93 94 if(fcr != sun3x_fdc.fcr) { 95 *(sun3x_fdc.fcr_r) = fcr; 96 sun3x_fdc.fcr = fcr; 97 } 98 } 99 break; 100 case 5: /* FD_DATA */ 101 *(sun3x_fdc.data_r) = value; 102 break; 103 case 7: /* FD_DCR */ 104 *(sun3x_fdc.status_r) = value; 105 break; 106 case 4: /* FD_STATUS */ 107 *(sun3x_fdc.status_r) = value; 108 break; 109 }; 110 return; 111 } 112 113 114 asmlinkage irqreturn_t sun3xflop_hardint(int irq, void *dev_id) 115 { 116 register unsigned char st; 117 118 #undef TRACE_FLPY_INT 119 #define NO_FLOPPY_ASSEMBLER 120 121 #ifdef TRACE_FLPY_INT 122 static int calls=0; 123 static int bytes=0; 124 static int dma_wait=0; 125 #endif 126 if(!doing_pdma) { 127 floppy_interrupt(irq, dev_id); 128 return IRQ_HANDLED; 129 } 130 131 // pr_info("doing pdma\n");// st %x\n", sun_fdc->status_82072); 132 133 #ifdef TRACE_FLPY_INT 134 if(!calls) 135 bytes = virtual_dma_count; 136 #endif 137 138 { 139 register int lcount; 140 register char *lptr; 141 142 for(lcount=virtual_dma_count, lptr=virtual_dma_addr; 143 lcount; lcount--, lptr++) { 144 /* st=fd_inb(virtual_dma_port+4) & 0x80 ; */ 145 st = *(sun3x_fdc.status_r); 146 /* if(st != 0xa0) */ 147 /* break; */ 148 149 if((st & 0x80) == 0) { 150 virtual_dma_count = lcount; 151 virtual_dma_addr = lptr; 152 return IRQ_HANDLED; 153 } 154 155 if((st & 0x20) == 0) 156 break; 157 158 if(virtual_dma_mode) 159 /* fd_outb(*lptr, virtual_dma_port+5); */ 160 *(sun3x_fdc.data_r) = *lptr; 161 else 162 /* *lptr = fd_inb(virtual_dma_port+5); */ 163 *lptr = *(sun3x_fdc.data_r); 164 } 165 166 virtual_dma_count = lcount; 167 virtual_dma_addr = lptr; 168 /* st = fd_inb(virtual_dma_port+4); */ 169 st = *(sun3x_fdc.status_r); 170 } 171 172 #ifdef TRACE_FLPY_INT 173 calls++; 174 #endif 175 // pr_info("st=%02x\n", st); 176 if(st == 0x20) 177 return IRQ_HANDLED; 178 if(!(st & 0x20)) { 179 virtual_dma_residue += virtual_dma_count; 180 virtual_dma_count=0; 181 doing_pdma = 0; 182 183 #ifdef TRACE_FLPY_INT 184 pr_info("count=%x, residue=%x calls=%d bytes=%x dma_wait=%d\n", 185 virtual_dma_count, virtual_dma_residue, calls, bytes, 186 dma_wait); 187 calls = 0; 188 dma_wait=0; 189 #endif 190 191 floppy_interrupt(irq, dev_id); 192 return IRQ_HANDLED; 193 } 194 195 196 #ifdef TRACE_FLPY_INT 197 if(!virtual_dma_count) 198 dma_wait++; 199 #endif 200 return IRQ_HANDLED; 201 } 202 203 static int sun3xflop_request_irq(void) 204 { 205 static int once = 0; 206 int error; 207 208 if(!once) { 209 once = 1; 210 error = request_irq(FLOPPY_IRQ, sun3xflop_hardint, 211 0, "floppy", NULL); 212 return ((error == 0) ? 0 : -1); 213 } else return 0; 214 } 215 216 static void __init floppy_set_flags(int *ints,int param, int param2); 217 218 static int sun3xflop_init(void) 219 { 220 if(FLOPPY_IRQ < 0x40) 221 FLOPPY_IRQ = SUN3X_FDC_IRQ; 222 223 sun3x_fdc.status_r = (volatile unsigned char *)SUN3X_FDC; 224 sun3x_fdc.data_r = (volatile unsigned char *)(SUN3X_FDC+1); 225 sun3x_fdc.fcr_r = (volatile unsigned char *)SUN3X_FDC_FCR; 226 sun3x_fdc.fvr_r = (volatile unsigned char *)SUN3X_FDC_FVR; 227 sun3x_fdc.fcr = 0; 228 229 /* Last minute sanity check... */ 230 if(*sun3x_fdc.status_r == 0xff) { 231 return -1; 232 } 233 234 *sun3x_fdc.fvr_r = FLOPPY_IRQ; 235 236 *sun3x_fdc.fcr_r = FCR_TC; 237 udelay(10); 238 *sun3x_fdc.fcr_r = 0; 239 240 /* Success... */ 241 floppy_set_flags(NULL, 1, FD_BROKEN_DCL); // I don't know how to detect this. 242 allowed_drive_mask = 0x01; 243 return (int) SUN3X_FDC; 244 } 245 246 /* I'm not precisely sure this eject routine works */ 247 static int sun3x_eject(void) 248 { 249 if(MACH_IS_SUN3X) { 250 251 sun3x_fdc.fcr |= (FCR_DSEL0 | FCR_EJECT); 252 *(sun3x_fdc.fcr_r) = sun3x_fdc.fcr; 253 udelay(10); 254 sun3x_fdc.fcr &= ~(FCR_DSEL0 | FCR_EJECT); 255 *(sun3x_fdc.fcr_r) = sun3x_fdc.fcr; 256 } 257 258 return 0; 259 } 260 261 #define fd_eject(drive) sun3x_eject() 262 263 #endif /* !(__ASM_SUN3X_FLOPPY_H) */ 264