1 /* asm/floppy.h: Sparc specific parts of the Floppy driver.
3 * Copyright (C) 1995 David S. Miller (davem@davemloft.net)
6 #ifndef __ASM_SPARC_FLOPPY_H
7 #define __ASM_SPARC_FLOPPY_H
10 #include <linux/of_device.h>
13 #include <asm/pgtable.h>
14 #include <asm/system.h>
15 #include <asm/idprom.h>
16 #include <asm/machines.h>
17 #include <asm/oplib.h>
18 #include <asm/auxio.h>
21 /* We don't need no stinkin' I/O port allocation crap. */
24 #define release_region(X, Y) do { } while(0)
25 #define request_region(X, Y, Z) (1)
28 * 1) Netbsd Sun floppy driver.
29 * 2) NCR 82077 controller manual
30 * 3) Intel 82077 controller manual
32 struct sun_flpy_controller
{
33 volatile unsigned char status_82072
; /* Main Status reg. */
34 #define dcr_82072 status_82072 /* Digital Control reg. */
35 #define status1_82077 status_82072 /* Auxiliary Status reg. 1 */
37 volatile unsigned char data_82072
; /* Data fifo. */
38 #define status2_82077 data_82072 /* Auxiliary Status reg. 2 */
40 volatile unsigned char dor_82077
; /* Digital Output reg. */
41 volatile unsigned char tapectl_82077
; /* What the? Tape control reg? */
43 volatile unsigned char status_82077
; /* Main Status Register. */
44 #define drs_82077 status_82077 /* Digital Rate Select reg. */
46 volatile unsigned char data_82077
; /* Data fifo. */
47 volatile unsigned char ___unused
;
48 volatile unsigned char dir_82077
; /* Digital Input reg. */
49 #define dcr_82077 dir_82077 /* Config Control reg. */
52 /* You'll only ever find one controller on a SparcStation anyways. */
53 static struct sun_flpy_controller
*sun_fdc
= NULL
;
54 extern volatile unsigned char *fdc_status
;
56 struct sun_floppy_ops
{
57 unsigned char (*fd_inb
)(int port
);
58 void (*fd_outb
)(unsigned char value
, int port
);
61 static struct sun_floppy_ops sun_fdops
;
63 #define fd_inb(port) sun_fdops.fd_inb(port)
64 #define fd_outb(value,port) sun_fdops.fd_outb(value,port)
65 #define fd_enable_dma() sun_fd_enable_dma()
66 #define fd_disable_dma() sun_fd_disable_dma()
67 #define fd_request_dma() (0) /* nothing... */
68 #define fd_free_dma() /* nothing... */
69 #define fd_clear_dma_ff() /* nothing... */
70 #define fd_set_dma_mode(mode) sun_fd_set_dma_mode(mode)
71 #define fd_set_dma_addr(addr) sun_fd_set_dma_addr(addr)
72 #define fd_set_dma_count(count) sun_fd_set_dma_count(count)
73 #define fd_enable_irq() /* nothing... */
74 #define fd_disable_irq() /* nothing... */
75 #define fd_cacheflush(addr, size) /* nothing... */
76 #define fd_request_irq() sun_fd_request_irq()
77 #define fd_free_irq() /* nothing... */
79 #define get_dma_residue(x) (0)
81 #define FLOPPY0_TYPE 4
82 #define FLOPPY1_TYPE 0
84 /* Super paranoid... */
85 #undef HAVE_DISABLE_HLT
87 /* Here is where we catch the floppy driver trying to initialize,
88 * therefore this is where we call the PROM device tree probing
89 * routine etc. on the Sparc.
91 #define FDC1 sun_floppy_init()
96 /* No 64k boundary crossing problems on the Sparc. */
97 #define CROSS_64KB(a,s) (0)
99 /* Routines unique to each controller type on a Sun. */
100 static void sun_set_dor(unsigned char value
, int fdc_82077
)
102 if (sparc_cpu_model
== sun4c
) {
103 unsigned int bits
= 0;
105 bits
|= AUXIO_FLPY_DSEL
;
106 if ((value
& 0x80) == 0)
107 bits
|= AUXIO_FLPY_EJCT
;
108 set_auxio(bits
, (~bits
) & (AUXIO_FLPY_DSEL
|AUXIO_FLPY_EJCT
));
111 sun_fdc
->dor_82077
= value
;
115 static unsigned char sun_read_dir(void)
117 if (sparc_cpu_model
== sun4c
)
118 return (get_auxio() & AUXIO_FLPY_DCHG
) ? 0x80 : 0;
120 return sun_fdc
->dir_82077
;
123 static unsigned char sun_82072_fd_inb(int port
)
128 printk("floppy: Asked to read unknown port %d\n", port
);
129 panic("floppy: Port bolixed.");
130 case 4: /* FD_STATUS */
131 return sun_fdc
->status_82072
& ~STATUS_DMA
;
132 case 5: /* FD_DATA */
133 return sun_fdc
->data_82072
;
135 return sun_read_dir();
137 panic("sun_82072_fd_inb: How did I get here?");
140 static void sun_82072_fd_outb(unsigned char value
, int port
)
145 printk("floppy: Asked to write to unknown port %d\n", port
);
146 panic("floppy: Port bolixed.");
148 sun_set_dor(value
, 0);
150 case 5: /* FD_DATA */
151 sun_fdc
->data_82072
= value
;
154 sun_fdc
->dcr_82072
= value
;
156 case 4: /* FD_STATUS */
157 sun_fdc
->status_82072
= value
;
163 static unsigned char sun_82077_fd_inb(int port
)
168 printk("floppy: Asked to read unknown port %d\n", port
);
169 panic("floppy: Port bolixed.");
170 case 0: /* FD_STATUS_0 */
171 return sun_fdc
->status1_82077
;
172 case 1: /* FD_STATUS_1 */
173 return sun_fdc
->status2_82077
;
175 return sun_fdc
->dor_82077
;
177 return sun_fdc
->tapectl_82077
;
178 case 4: /* FD_STATUS */
179 return sun_fdc
->status_82077
& ~STATUS_DMA
;
180 case 5: /* FD_DATA */
181 return sun_fdc
->data_82077
;
183 return sun_read_dir();
185 panic("sun_82077_fd_inb: How did I get here?");
188 static void sun_82077_fd_outb(unsigned char value
, int port
)
193 printk("floppy: Asked to write to unknown port %d\n", port
);
194 panic("floppy: Port bolixed.");
196 sun_set_dor(value
, 1);
198 case 5: /* FD_DATA */
199 sun_fdc
->data_82077
= value
;
202 sun_fdc
->dcr_82077
= value
;
204 case 4: /* FD_STATUS */
205 sun_fdc
->status_82077
= value
;
208 sun_fdc
->tapectl_82077
= value
;
214 /* For pseudo-dma (Sun floppy drives have no real DMA available to
215 * them so we must eat the data fifo bytes directly ourselves) we have
216 * three state variables. doing_pdma tells our inline low-level
217 * assembly floppy interrupt entry point whether it should sit and eat
218 * bytes from the fifo or just transfer control up to the higher level
219 * floppy interrupt c-code. I tried very hard but I could not get the
220 * pseudo-dma to work in c-code without getting many overruns and
221 * underruns. If non-zero, doing_pdma encodes the direction of
222 * the transfer for debugging. 1=read 2=write
224 extern char *pdma_vaddr
;
225 extern unsigned long pdma_size
;
226 extern volatile int doing_pdma
;
228 /* This is software state */
229 extern char *pdma_base
;
230 extern unsigned long pdma_areasize
;
232 /* Common routines to all controller types on the Sparc. */
233 static inline void virtual_dma_init(void)
238 static inline void sun_fd_disable_dma(void)
242 mmu_unlockarea(pdma_base
, pdma_areasize
);
247 static inline void sun_fd_set_dma_mode(int mode
)
257 printk("Unknown dma mode %d\n", mode
);
258 panic("floppy: Giving up...");
262 static inline void sun_fd_set_dma_addr(char *buffer
)
267 static inline void sun_fd_set_dma_count(int length
)
272 static inline void sun_fd_enable_dma(void)
274 pdma_vaddr
= mmu_lockarea(pdma_vaddr
, pdma_size
);
275 pdma_base
= pdma_vaddr
;
276 pdma_areasize
= pdma_size
;
279 /* Our low-level entry point in arch/sparc/kernel/entry.S */
280 extern int sparc_floppy_request_irq(int irq
, unsigned long flags
,
281 irq_handler_t irq_handler
);
283 static int sun_fd_request_irq(void)
290 error
= sparc_floppy_request_irq(FLOPPY_IRQ
,
293 return ((error
== 0) ? 0 : -1);
297 static struct linux_prom_registers fd_regs
[2];
299 static int sun_floppy_init(void)
302 int tnode
, fd_node
, num_regs
;
308 /* Forget it if we aren't on a machine that could possibly
309 * ever have a floppy drive.
311 if((sparc_cpu_model
!= sun4c
&& sparc_cpu_model
!= sun4m
) ||
312 ((idprom
->id_machtype
== (SM_SUN4C
| SM_4C_SLC
)) ||
313 (idprom
->id_machtype
== (SM_SUN4C
| SM_4C_ELC
)))) {
314 /* We certainly don't have a floppy controller. */
317 /* Well, try to find one. */
318 tnode
= prom_getchild(prom_root_node
);
319 fd_node
= prom_searchsiblings(tnode
, "obio");
321 tnode
= prom_getchild(fd_node
);
322 fd_node
= prom_searchsiblings(tnode
, "SUNW,fdtwo");
324 fd_node
= prom_searchsiblings(tnode
, "fd");
330 /* The sun4m lets us know if the controller is actually usable. */
331 if(sparc_cpu_model
== sun4m
&&
332 prom_getproperty(fd_node
, "status", state
, sizeof(state
)) != -1) {
333 if(!strcmp(state
, "disabled")) {
337 num_regs
= prom_getproperty(fd_node
, "reg", (char *) fd_regs
, sizeof(fd_regs
));
338 num_regs
= (num_regs
/ sizeof(fd_regs
[0]));
339 prom_apply_obio_ranges(fd_regs
, num_regs
);
340 memset(&r
, 0, sizeof(r
));
341 r
.flags
= fd_regs
[0].which_io
;
342 r
.start
= fd_regs
[0].phys_addr
;
343 sun_fdc
= (struct sun_flpy_controller
*)
344 of_ioremap(&r
, 0, fd_regs
[0].reg_size
, "floppy");
346 /* Last minute sanity check... */
347 if(sun_fdc
->status_82072
== 0xff) {
352 sun_fdops
.fd_inb
= sun_82077_fd_inb
;
353 sun_fdops
.fd_outb
= sun_82077_fd_outb
;
354 fdc_status
= &sun_fdc
->status_82077
;
356 if (sun_fdc
->dor_82077
== 0x80) {
357 sun_fdc
->dor_82077
= 0x02;
358 if (sun_fdc
->dor_82077
== 0x80) {
359 sun_fdops
.fd_inb
= sun_82072_fd_inb
;
360 sun_fdops
.fd_outb
= sun_82072_fd_outb
;
361 fdc_status
= &sun_fdc
->status_82072
;
366 allowed_drive_mask
= 0x01;
367 return (int) sun_fdc
;
373 static int sparc_eject(void)
375 set_dor(0x00, 0xff, 0x90);
377 set_dor(0x00, 0x6f, 0x00);
382 #define fd_eject(drive) sparc_eject()
384 #define EXTRA_FLOPPY_PARAMS
386 static DEFINE_SPINLOCK(dma_spin_lock
);
388 #define claim_dma_lock() \
389 ({ unsigned long flags; \
390 spin_lock_irqsave(&dma_spin_lock, flags); \
394 #define release_dma_lock(__flags) \
395 spin_unlock_irqrestore(&dma_spin_lock, __flags);
397 #endif /* !(__ASM_SPARC_FLOPPY_H) */