]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
1da177e4 LT |
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 <asm/page.h> | |
14 | #include <asm/pgtable.h> | |
1da177e4 LT |
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 | |
1da177e4 LT |
30 | #undef request_region |
31 | #define release_region(X, Y) do { } while(0) | |
1da177e4 LT |
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: | |
4eee1e72 | 52 | pr_crit("floppy: Asked to read unknown port %d\n", port); |
1da177e4 LT |
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: | |
4eee1e72 | 74 | pr_crit("floppy: Asked to write to unknown port %d\n", port); |
1da177e4 LT |
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 | ||
2850bc27 | 114 | asmlinkage irqreturn_t sun3xflop_hardint(int irq, void *dev_id) |
1da177e4 LT |
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) { | |
2850bc27 | 127 | floppy_interrupt(irq, dev_id); |
1da177e4 LT |
128 | return IRQ_HANDLED; |
129 | } | |
130 | ||
4eee1e72 | 131 | // pr_info("doing pdma\n");// st %x\n", sun_fdc->status_82072); |
1da177e4 LT |
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 | |
4eee1e72 | 175 | // pr_info("st=%02x\n", st); |
1da177e4 LT |
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 | |
4eee1e72 GU |
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); | |
1da177e4 LT |
187 | calls = 0; |
188 | dma_wait=0; | |
189 | #endif | |
190 | ||
2850bc27 | 191 | floppy_interrupt(irq, dev_id); |
1da177e4 LT |
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; | |
b0b9fdc1 | 210 | error = request_irq(FLOPPY_IRQ, sun3xflop_hardint, |
77a42796 | 211 | 0, "floppy", NULL); |
1da177e4 LT |
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... */ | |
a5d361fc | 241 | floppy_set_flags(NULL, 1, FD_BROKEN_DCL); // I don't know how to detect this. |
1da177e4 LT |
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) */ |