m68k: use the mc146818rtc.h for non-mmu setups as well.
[linux-2.6] / arch / m68k / include / asm / sun3xflop.h
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>
14 #include <asm/system.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                 printk("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                 printk("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 //      printk("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 //      printk("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                 printk("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                                     IRQF_DISABLED, "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) */