diff options
Diffstat (limited to 'include/asm-sparc/floppy.h')
-rw-r--r-- | include/asm-sparc/floppy.h | 394 |
1 files changed, 7 insertions, 387 deletions
diff --git a/include/asm-sparc/floppy.h b/include/asm-sparc/floppy.h index d3978e068e2b..6c628ba15a8d 100644 --- a/include/asm-sparc/floppy.h +++ b/include/asm-sparc/floppy.h | |||
@@ -1,388 +1,8 @@ | |||
1 | /* asm-sparc/floppy.h: Sparc specific parts of the Floppy driver. | 1 | #ifndef ___ASM_SPARC_FLOPPY_H |
2 | * | 2 | #define ___ASM_SPARC_FLOPPY_H |
3 | * Copyright (C) 1995 David S. Miller (davem@davemloft.net) | 3 | #if defined(__sparc__) && defined(__arch64__) |
4 | */ | 4 | #include <asm-sparc/floppy_64.h> |
5 | 5 | #else | |
6 | #ifndef __ASM_SPARC_FLOPPY_H | 6 | #include <asm-sparc/floppy_32.h> |
7 | #define __ASM_SPARC_FLOPPY_H | 7 | #endif |
8 | |||
9 | #include <asm/page.h> | ||
10 | #include <asm/pgtable.h> | ||
11 | #include <asm/system.h> | ||
12 | #include <asm/idprom.h> | ||
13 | #include <asm/machines.h> | ||
14 | #include <asm/oplib.h> | ||
15 | #include <asm/auxio.h> | ||
16 | #include <asm/irq.h> | ||
17 | |||
18 | /* We don't need no stinkin' I/O port allocation crap. */ | ||
19 | #undef release_region | ||
20 | #undef request_region | ||
21 | #define release_region(X, Y) do { } while(0) | ||
22 | #define request_region(X, Y, Z) (1) | ||
23 | |||
24 | /* References: | ||
25 | * 1) Netbsd Sun floppy driver. | ||
26 | * 2) NCR 82077 controller manual | ||
27 | * 3) Intel 82077 controller manual | ||
28 | */ | ||
29 | struct sun_flpy_controller { | ||
30 | volatile unsigned char status_82072; /* Main Status reg. */ | ||
31 | #define dcr_82072 status_82072 /* Digital Control reg. */ | ||
32 | #define status1_82077 status_82072 /* Auxiliary Status reg. 1 */ | ||
33 | |||
34 | volatile unsigned char data_82072; /* Data fifo. */ | ||
35 | #define status2_82077 data_82072 /* Auxiliary Status reg. 2 */ | ||
36 | |||
37 | volatile unsigned char dor_82077; /* Digital Output reg. */ | ||
38 | volatile unsigned char tapectl_82077; /* What the? Tape control reg? */ | ||
39 | |||
40 | volatile unsigned char status_82077; /* Main Status Register. */ | ||
41 | #define drs_82077 status_82077 /* Digital Rate Select reg. */ | ||
42 | |||
43 | volatile unsigned char data_82077; /* Data fifo. */ | ||
44 | volatile unsigned char ___unused; | ||
45 | volatile unsigned char dir_82077; /* Digital Input reg. */ | ||
46 | #define dcr_82077 dir_82077 /* Config Control reg. */ | ||
47 | }; | ||
48 | |||
49 | /* You'll only ever find one controller on a SparcStation anyways. */ | ||
50 | static struct sun_flpy_controller *sun_fdc = NULL; | ||
51 | extern volatile unsigned char *fdc_status; | ||
52 | |||
53 | struct sun_floppy_ops { | ||
54 | unsigned char (*fd_inb)(int port); | ||
55 | void (*fd_outb)(unsigned char value, int port); | ||
56 | }; | ||
57 | |||
58 | static struct sun_floppy_ops sun_fdops; | ||
59 | |||
60 | #define fd_inb(port) sun_fdops.fd_inb(port) | ||
61 | #define fd_outb(value,port) sun_fdops.fd_outb(value,port) | ||
62 | #define fd_enable_dma() sun_fd_enable_dma() | ||
63 | #define fd_disable_dma() sun_fd_disable_dma() | ||
64 | #define fd_request_dma() (0) /* nothing... */ | ||
65 | #define fd_free_dma() /* nothing... */ | ||
66 | #define fd_clear_dma_ff() /* nothing... */ | ||
67 | #define fd_set_dma_mode(mode) sun_fd_set_dma_mode(mode) | ||
68 | #define fd_set_dma_addr(addr) sun_fd_set_dma_addr(addr) | ||
69 | #define fd_set_dma_count(count) sun_fd_set_dma_count(count) | ||
70 | #define fd_enable_irq() /* nothing... */ | ||
71 | #define fd_disable_irq() /* nothing... */ | ||
72 | #define fd_cacheflush(addr, size) /* nothing... */ | ||
73 | #define fd_request_irq() sun_fd_request_irq() | ||
74 | #define fd_free_irq() /* nothing... */ | ||
75 | #if 0 /* P3: added by Alain, these cause a MMU corruption. 19960524 XXX */ | ||
76 | #define fd_dma_mem_alloc(size) ((unsigned long) vmalloc(size)) | ||
77 | #define fd_dma_mem_free(addr,size) (vfree((void *)(addr))) | ||
78 | #endif | 8 | #endif |
79 | |||
80 | /* XXX This isn't really correct. XXX */ | ||
81 | #define get_dma_residue(x) (0) | ||
82 | |||
83 | #define FLOPPY0_TYPE 4 | ||
84 | #define FLOPPY1_TYPE 0 | ||
85 | |||
86 | /* Super paranoid... */ | ||
87 | #undef HAVE_DISABLE_HLT | ||
88 | |||
89 | /* Here is where we catch the floppy driver trying to initialize, | ||
90 | * therefore this is where we call the PROM device tree probing | ||
91 | * routine etc. on the Sparc. | ||
92 | */ | ||
93 | #define FDC1 sun_floppy_init() | ||
94 | |||
95 | #define N_FDC 1 | ||
96 | #define N_DRIVE 8 | ||
97 | |||
98 | /* No 64k boundary crossing problems on the Sparc. */ | ||
99 | #define CROSS_64KB(a,s) (0) | ||
100 | |||
101 | /* Routines unique to each controller type on a Sun. */ | ||
102 | static void sun_set_dor(unsigned char value, int fdc_82077) | ||
103 | { | ||
104 | if (sparc_cpu_model == sun4c) { | ||
105 | unsigned int bits = 0; | ||
106 | if (value & 0x10) | ||
107 | bits |= AUXIO_FLPY_DSEL; | ||
108 | if ((value & 0x80) == 0) | ||
109 | bits |= AUXIO_FLPY_EJCT; | ||
110 | set_auxio(bits, (~bits) & (AUXIO_FLPY_DSEL|AUXIO_FLPY_EJCT)); | ||
111 | } | ||
112 | if (fdc_82077) { | ||
113 | sun_fdc->dor_82077 = value; | ||
114 | } | ||
115 | } | ||
116 | |||
117 | static unsigned char sun_read_dir(void) | ||
118 | { | ||
119 | if (sparc_cpu_model == sun4c) | ||
120 | return (get_auxio() & AUXIO_FLPY_DCHG) ? 0x80 : 0; | ||
121 | else | ||
122 | return sun_fdc->dir_82077; | ||
123 | } | ||
124 | |||
125 | static unsigned char sun_82072_fd_inb(int port) | ||
126 | { | ||
127 | udelay(5); | ||
128 | switch(port & 7) { | ||
129 | default: | ||
130 | printk("floppy: Asked to read unknown port %d\n", port); | ||
131 | panic("floppy: Port bolixed."); | ||
132 | case 4: /* FD_STATUS */ | ||
133 | return sun_fdc->status_82072 & ~STATUS_DMA; | ||
134 | case 5: /* FD_DATA */ | ||
135 | return sun_fdc->data_82072; | ||
136 | case 7: /* FD_DIR */ | ||
137 | return sun_read_dir(); | ||
138 | }; | ||
139 | panic("sun_82072_fd_inb: How did I get here?"); | ||
140 | } | ||
141 | |||
142 | static void sun_82072_fd_outb(unsigned char value, int port) | ||
143 | { | ||
144 | udelay(5); | ||
145 | switch(port & 7) { | ||
146 | default: | ||
147 | printk("floppy: Asked to write to unknown port %d\n", port); | ||
148 | panic("floppy: Port bolixed."); | ||
149 | case 2: /* FD_DOR */ | ||
150 | sun_set_dor(value, 0); | ||
151 | break; | ||
152 | case 5: /* FD_DATA */ | ||
153 | sun_fdc->data_82072 = value; | ||
154 | break; | ||
155 | case 7: /* FD_DCR */ | ||
156 | sun_fdc->dcr_82072 = value; | ||
157 | break; | ||
158 | case 4: /* FD_STATUS */ | ||
159 | sun_fdc->status_82072 = value; | ||
160 | break; | ||
161 | }; | ||
162 | return; | ||
163 | } | ||
164 | |||
165 | static unsigned char sun_82077_fd_inb(int port) | ||
166 | { | ||
167 | udelay(5); | ||
168 | switch(port & 7) { | ||
169 | default: | ||
170 | printk("floppy: Asked to read unknown port %d\n", port); | ||
171 | panic("floppy: Port bolixed."); | ||
172 | case 0: /* FD_STATUS_0 */ | ||
173 | return sun_fdc->status1_82077; | ||
174 | case 1: /* FD_STATUS_1 */ | ||
175 | return sun_fdc->status2_82077; | ||
176 | case 2: /* FD_DOR */ | ||
177 | return sun_fdc->dor_82077; | ||
178 | case 3: /* FD_TDR */ | ||
179 | return sun_fdc->tapectl_82077; | ||
180 | case 4: /* FD_STATUS */ | ||
181 | return sun_fdc->status_82077 & ~STATUS_DMA; | ||
182 | case 5: /* FD_DATA */ | ||
183 | return sun_fdc->data_82077; | ||
184 | case 7: /* FD_DIR */ | ||
185 | return sun_read_dir(); | ||
186 | }; | ||
187 | panic("sun_82077_fd_inb: How did I get here?"); | ||
188 | } | ||
189 | |||
190 | static void sun_82077_fd_outb(unsigned char value, int port) | ||
191 | { | ||
192 | udelay(5); | ||
193 | switch(port & 7) { | ||
194 | default: | ||
195 | printk("floppy: Asked to write to unknown port %d\n", port); | ||
196 | panic("floppy: Port bolixed."); | ||
197 | case 2: /* FD_DOR */ | ||
198 | sun_set_dor(value, 1); | ||
199 | break; | ||
200 | case 5: /* FD_DATA */ | ||
201 | sun_fdc->data_82077 = value; | ||
202 | break; | ||
203 | case 7: /* FD_DCR */ | ||
204 | sun_fdc->dcr_82077 = value; | ||
205 | break; | ||
206 | case 4: /* FD_STATUS */ | ||
207 | sun_fdc->status_82077 = value; | ||
208 | break; | ||
209 | case 3: /* FD_TDR */ | ||
210 | sun_fdc->tapectl_82077 = value; | ||
211 | break; | ||
212 | }; | ||
213 | return; | ||
214 | } | ||
215 | |||
216 | /* For pseudo-dma (Sun floppy drives have no real DMA available to | ||
217 | * them so we must eat the data fifo bytes directly ourselves) we have | ||
218 | * three state variables. doing_pdma tells our inline low-level | ||
219 | * assembly floppy interrupt entry point whether it should sit and eat | ||
220 | * bytes from the fifo or just transfer control up to the higher level | ||
221 | * floppy interrupt c-code. I tried very hard but I could not get the | ||
222 | * pseudo-dma to work in c-code without getting many overruns and | ||
223 | * underruns. If non-zero, doing_pdma encodes the direction of | ||
224 | * the transfer for debugging. 1=read 2=write | ||
225 | */ | ||
226 | extern char *pdma_vaddr; | ||
227 | extern unsigned long pdma_size; | ||
228 | extern volatile int doing_pdma; | ||
229 | |||
230 | /* This is software state */ | ||
231 | extern char *pdma_base; | ||
232 | extern unsigned long pdma_areasize; | ||
233 | |||
234 | /* Common routines to all controller types on the Sparc. */ | ||
235 | static inline void virtual_dma_init(void) | ||
236 | { | ||
237 | /* nothing... */ | ||
238 | } | ||
239 | |||
240 | static inline void sun_fd_disable_dma(void) | ||
241 | { | ||
242 | doing_pdma = 0; | ||
243 | if (pdma_base) { | ||
244 | mmu_unlockarea(pdma_base, pdma_areasize); | ||
245 | pdma_base = NULL; | ||
246 | } | ||
247 | } | ||
248 | |||
249 | static inline void sun_fd_set_dma_mode(int mode) | ||
250 | { | ||
251 | switch(mode) { | ||
252 | case DMA_MODE_READ: | ||
253 | doing_pdma = 1; | ||
254 | break; | ||
255 | case DMA_MODE_WRITE: | ||
256 | doing_pdma = 2; | ||
257 | break; | ||
258 | default: | ||
259 | printk("Unknown dma mode %d\n", mode); | ||
260 | panic("floppy: Giving up..."); | ||
261 | } | ||
262 | } | ||
263 | |||
264 | static inline void sun_fd_set_dma_addr(char *buffer) | ||
265 | { | ||
266 | pdma_vaddr = buffer; | ||
267 | } | ||
268 | |||
269 | static inline void sun_fd_set_dma_count(int length) | ||
270 | { | ||
271 | pdma_size = length; | ||
272 | } | ||
273 | |||
274 | static inline void sun_fd_enable_dma(void) | ||
275 | { | ||
276 | pdma_vaddr = mmu_lockarea(pdma_vaddr, pdma_size); | ||
277 | pdma_base = pdma_vaddr; | ||
278 | pdma_areasize = pdma_size; | ||
279 | } | ||
280 | |||
281 | /* Our low-level entry point in arch/sparc/kernel/entry.S */ | ||
282 | extern int sparc_floppy_request_irq(int irq, unsigned long flags, | ||
283 | irq_handler_t irq_handler); | ||
284 | |||
285 | static int sun_fd_request_irq(void) | ||
286 | { | ||
287 | static int once = 0; | ||
288 | int error; | ||
289 | |||
290 | if(!once) { | ||
291 | once = 1; | ||
292 | error = sparc_floppy_request_irq(FLOPPY_IRQ, | ||
293 | IRQF_DISABLED, | ||
294 | floppy_interrupt); | ||
295 | return ((error == 0) ? 0 : -1); | ||
296 | } else return 0; | ||
297 | } | ||
298 | |||
299 | static struct linux_prom_registers fd_regs[2]; | ||
300 | |||
301 | static int sun_floppy_init(void) | ||
302 | { | ||
303 | char state[128]; | ||
304 | int tnode, fd_node, num_regs; | ||
305 | struct resource r; | ||
306 | |||
307 | use_virtual_dma = 1; | ||
308 | |||
309 | FLOPPY_IRQ = 11; | ||
310 | /* Forget it if we aren't on a machine that could possibly | ||
311 | * ever have a floppy drive. | ||
312 | */ | ||
313 | if((sparc_cpu_model != sun4c && sparc_cpu_model != sun4m) || | ||
314 | ((idprom->id_machtype == (SM_SUN4C | SM_4C_SLC)) || | ||
315 | (idprom->id_machtype == (SM_SUN4C | SM_4C_ELC)))) { | ||
316 | /* We certainly don't have a floppy controller. */ | ||
317 | goto no_sun_fdc; | ||
318 | } | ||
319 | /* Well, try to find one. */ | ||
320 | tnode = prom_getchild(prom_root_node); | ||
321 | fd_node = prom_searchsiblings(tnode, "obio"); | ||
322 | if(fd_node != 0) { | ||
323 | tnode = prom_getchild(fd_node); | ||
324 | fd_node = prom_searchsiblings(tnode, "SUNW,fdtwo"); | ||
325 | } else { | ||
326 | fd_node = prom_searchsiblings(tnode, "fd"); | ||
327 | } | ||
328 | if(fd_node == 0) { | ||
329 | goto no_sun_fdc; | ||
330 | } | ||
331 | |||
332 | /* The sun4m lets us know if the controller is actually usable. */ | ||
333 | if(sparc_cpu_model == sun4m && | ||
334 | prom_getproperty(fd_node, "status", state, sizeof(state)) != -1) { | ||
335 | if(!strcmp(state, "disabled")) { | ||
336 | goto no_sun_fdc; | ||
337 | } | ||
338 | } | ||
339 | num_regs = prom_getproperty(fd_node, "reg", (char *) fd_regs, sizeof(fd_regs)); | ||
340 | num_regs = (num_regs / sizeof(fd_regs[0])); | ||
341 | prom_apply_obio_ranges(fd_regs, num_regs); | ||
342 | memset(&r, 0, sizeof(r)); | ||
343 | r.flags = fd_regs[0].which_io; | ||
344 | r.start = fd_regs[0].phys_addr; | ||
345 | sun_fdc = (struct sun_flpy_controller *) | ||
346 | sbus_ioremap(&r, 0, fd_regs[0].reg_size, "floppy"); | ||
347 | |||
348 | /* Last minute sanity check... */ | ||
349 | if(sun_fdc->status_82072 == 0xff) { | ||
350 | sun_fdc = NULL; | ||
351 | goto no_sun_fdc; | ||
352 | } | ||
353 | |||
354 | sun_fdops.fd_inb = sun_82077_fd_inb; | ||
355 | sun_fdops.fd_outb = sun_82077_fd_outb; | ||
356 | fdc_status = &sun_fdc->status_82077; | ||
357 | |||
358 | if (sun_fdc->dor_82077 == 0x80) { | ||
359 | sun_fdc->dor_82077 = 0x02; | ||
360 | if (sun_fdc->dor_82077 == 0x80) { | ||
361 | sun_fdops.fd_inb = sun_82072_fd_inb; | ||
362 | sun_fdops.fd_outb = sun_82072_fd_outb; | ||
363 | fdc_status = &sun_fdc->status_82072; | ||
364 | } | ||
365 | } | ||
366 | |||
367 | /* Success... */ | ||
368 | allowed_drive_mask = 0x01; | ||
369 | return (int) sun_fdc; | ||
370 | |||
371 | no_sun_fdc: | ||
372 | return -1; | ||
373 | } | ||
374 | |||
375 | static int sparc_eject(void) | ||
376 | { | ||
377 | set_dor(0x00, 0xff, 0x90); | ||
378 | udelay(500); | ||
379 | set_dor(0x00, 0x6f, 0x00); | ||
380 | udelay(500); | ||
381 | return 0; | ||
382 | } | ||
383 | |||
384 | #define fd_eject(drive) sparc_eject() | ||
385 | |||
386 | #define EXTRA_FLOPPY_PARAMS | ||
387 | |||
388 | #endif /* !(__ASM_SPARC_FLOPPY_H) */ | ||