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