1
2
3
4
5
6#ifndef __ASM_SPARC_FLOPPY_H
7#define __ASM_SPARC_FLOPPY_H
8
9#include <linux/of.h>
10#include <linux/of_device.h>
11
12#include <asm/page.h>
13#include <asm/pgtable.h>
14#include <asm/idprom.h>
15#include <asm/oplib.h>
16#include <asm/auxio.h>
17#include <asm/irq.h>
18
19
20#undef release_region
21#undef request_region
22#define release_region(X, Y) do { } while(0)
23#define request_region(X, Y, Z) (1)
24
25
26
27
28
29
30struct sun_flpy_controller {
31 volatile unsigned char status_82072;
32#define dcr_82072 status_82072
33#define status1_82077 status_82072
34
35 volatile unsigned char data_82072;
36#define status2_82077 data_82072
37
38 volatile unsigned char dor_82077;
39 volatile unsigned char tapectl_82077;
40
41 volatile unsigned char status_82077;
42#define drs_82077 status_82077
43
44 volatile unsigned char data_82077;
45 volatile unsigned char ___unused;
46 volatile unsigned char dir_82077;
47#define dcr_82077 dir_82077
48};
49
50
51static struct sun_flpy_controller *sun_fdc = NULL;
52extern volatile unsigned char *fdc_status;
53
54struct sun_floppy_ops {
55 unsigned char (*fd_inb)(int port);
56 void (*fd_outb)(unsigned char value, int port);
57};
58
59static struct sun_floppy_ops sun_fdops;
60
61#define fd_inb(port) sun_fdops.fd_inb(port)
62#define fd_outb(value,port) sun_fdops.fd_outb(value,port)
63#define fd_enable_dma() sun_fd_enable_dma()
64#define fd_disable_dma() sun_fd_disable_dma()
65#define fd_request_dma() (0)
66#define fd_free_dma()
67#define fd_clear_dma_ff()
68#define fd_set_dma_mode(mode) sun_fd_set_dma_mode(mode)
69#define fd_set_dma_addr(addr) sun_fd_set_dma_addr(addr)
70#define fd_set_dma_count(count) sun_fd_set_dma_count(count)
71#define fd_enable_irq()
72#define fd_disable_irq()
73#define fd_cacheflush(addr, size)
74#define fd_request_irq() sun_fd_request_irq()
75#define fd_free_irq()
76#if 0
77#define fd_dma_mem_alloc(size) ((unsigned long) vmalloc(size))
78#define fd_dma_mem_free(addr,size) (vfree((void *)(addr)))
79#endif
80
81
82#define get_dma_residue(x) (0)
83
84#define FLOPPY0_TYPE 4
85#define FLOPPY1_TYPE 0
86
87
88#undef HAVE_DISABLE_HLT
89
90
91
92
93
94#define FDC1 sun_floppy_init()
95
96#define N_FDC 1
97#define N_DRIVE 8
98
99
100#define CROSS_64KB(a,s) (0)
101
102
103static void sun_set_dor(unsigned char value, int fdc_82077)
104{
105 if (fdc_82077)
106 sun_fdc->dor_82077 = value;
107}
108
109static unsigned char sun_read_dir(void)
110{
111 return sun_fdc->dir_82077;
112}
113
114static unsigned char sun_82072_fd_inb(int port)
115{
116 udelay(5);
117 switch(port & 7) {
118 default:
119 printk("floppy: Asked to read unknown port %d\n", port);
120 panic("floppy: Port bolixed.");
121 case 4:
122 return sun_fdc->status_82072 & ~STATUS_DMA;
123 case 5:
124 return sun_fdc->data_82072;
125 case 7:
126 return sun_read_dir();
127 }
128 panic("sun_82072_fd_inb: How did I get here?");
129}
130
131static void sun_82072_fd_outb(unsigned char value, int port)
132{
133 udelay(5);
134 switch(port & 7) {
135 default:
136 printk("floppy: Asked to write to unknown port %d\n", port);
137 panic("floppy: Port bolixed.");
138 case 2:
139 sun_set_dor(value, 0);
140 break;
141 case 5:
142 sun_fdc->data_82072 = value;
143 break;
144 case 7:
145 sun_fdc->dcr_82072 = value;
146 break;
147 case 4:
148 sun_fdc->status_82072 = value;
149 break;
150 }
151 return;
152}
153
154static unsigned char sun_82077_fd_inb(int port)
155{
156 udelay(5);
157 switch(port & 7) {
158 default:
159 printk("floppy: Asked to read unknown port %d\n", port);
160 panic("floppy: Port bolixed.");
161 case 0:
162 return sun_fdc->status1_82077;
163 case 1:
164 return sun_fdc->status2_82077;
165 case 2:
166 return sun_fdc->dor_82077;
167 case 3:
168 return sun_fdc->tapectl_82077;
169 case 4:
170 return sun_fdc->status_82077 & ~STATUS_DMA;
171 case 5:
172 return sun_fdc->data_82077;
173 case 7:
174 return sun_read_dir();
175 }
176 panic("sun_82077_fd_inb: How did I get here?");
177}
178
179static void sun_82077_fd_outb(unsigned char value, int port)
180{
181 udelay(5);
182 switch(port & 7) {
183 default:
184 printk("floppy: Asked to write to unknown port %d\n", port);
185 panic("floppy: Port bolixed.");
186 case 2:
187 sun_set_dor(value, 1);
188 break;
189 case 5:
190 sun_fdc->data_82077 = value;
191 break;
192 case 7:
193 sun_fdc->dcr_82077 = value;
194 break;
195 case 4:
196 sun_fdc->status_82077 = value;
197 break;
198 case 3:
199 sun_fdc->tapectl_82077 = value;
200 break;
201 }
202 return;
203}
204
205
206
207
208
209
210
211
212
213
214
215extern char *pdma_vaddr;
216extern unsigned long pdma_size;
217extern volatile int doing_pdma;
218
219
220extern char *pdma_base;
221extern unsigned long pdma_areasize;
222
223
224static inline void virtual_dma_init(void)
225{
226
227}
228
229static inline void sun_fd_disable_dma(void)
230{
231 doing_pdma = 0;
232 pdma_base = NULL;
233}
234
235static inline void sun_fd_set_dma_mode(int mode)
236{
237 switch(mode) {
238 case DMA_MODE_READ:
239 doing_pdma = 1;
240 break;
241 case DMA_MODE_WRITE:
242 doing_pdma = 2;
243 break;
244 default:
245 printk("Unknown dma mode %d\n", mode);
246 panic("floppy: Giving up...");
247 }
248}
249
250static inline void sun_fd_set_dma_addr(char *buffer)
251{
252 pdma_vaddr = buffer;
253}
254
255static inline void sun_fd_set_dma_count(int length)
256{
257 pdma_size = length;
258}
259
260static inline void sun_fd_enable_dma(void)
261{
262 pdma_base = pdma_vaddr;
263 pdma_areasize = pdma_size;
264}
265
266extern int sparc_floppy_request_irq(unsigned int irq,
267 irq_handler_t irq_handler);
268
269static int sun_fd_request_irq(void)
270{
271 static int once = 0;
272
273 if (!once) {
274 once = 1;
275 return sparc_floppy_request_irq(FLOPPY_IRQ, floppy_interrupt);
276 } else {
277 return 0;
278 }
279}
280
281static struct linux_prom_registers fd_regs[2];
282
283static int sun_floppy_init(void)
284{
285 struct platform_device *op;
286 struct device_node *dp;
287 struct resource r;
288 char state[128];
289 phandle fd_node;
290 phandle tnode;
291 int num_regs;
292
293 use_virtual_dma = 1;
294
295
296
297
298 if (sparc_cpu_model != sun4m) {
299
300 goto no_sun_fdc;
301 }
302
303 tnode = prom_getchild(prom_root_node);
304 fd_node = prom_searchsiblings(tnode, "obio");
305 if (fd_node != 0) {
306 tnode = prom_getchild(fd_node);
307 fd_node = prom_searchsiblings(tnode, "SUNW,fdtwo");
308 } else {
309 fd_node = prom_searchsiblings(tnode, "fd");
310 }
311 if (fd_node == 0) {
312 goto no_sun_fdc;
313 }
314
315
316 if (prom_getproperty(fd_node, "status", state, sizeof(state)) != -1) {
317 if(!strcmp(state, "disabled")) {
318 goto no_sun_fdc;
319 }
320 }
321 num_regs = prom_getproperty(fd_node, "reg", (char *) fd_regs, sizeof(fd_regs));
322 num_regs = (num_regs / sizeof(fd_regs[0]));
323 prom_apply_obio_ranges(fd_regs, num_regs);
324 memset(&r, 0, sizeof(r));
325 r.flags = fd_regs[0].which_io;
326 r.start = fd_regs[0].phys_addr;
327 sun_fdc = of_ioremap(&r, 0, fd_regs[0].reg_size, "floppy");
328
329
330
331
332 op = NULL;
333 for_each_node_by_name(dp, "SUNW,fdtwo") {
334 op = of_find_device_by_node(dp);
335 if (op)
336 break;
337 }
338 if (!op) {
339 for_each_node_by_name(dp, "fd") {
340 op = of_find_device_by_node(dp);
341 if (op)
342 break;
343 }
344 }
345 if (!op)
346 goto no_sun_fdc;
347
348 FLOPPY_IRQ = op->archdata.irqs[0];
349
350
351 if (sun_fdc->status_82072 == 0xff) {
352 sun_fdc = NULL;
353 goto no_sun_fdc;
354 }
355
356 sun_fdops.fd_inb = sun_82077_fd_inb;
357 sun_fdops.fd_outb = sun_82077_fd_outb;
358 fdc_status = &sun_fdc->status_82077;
359
360 if (sun_fdc->dor_82077 == 0x80) {
361 sun_fdc->dor_82077 = 0x02;
362 if (sun_fdc->dor_82077 == 0x80) {
363 sun_fdops.fd_inb = sun_82072_fd_inb;
364 sun_fdops.fd_outb = sun_82072_fd_outb;
365 fdc_status = &sun_fdc->status_82072;
366 }
367 }
368
369
370 allowed_drive_mask = 0x01;
371 return (int) sun_fdc;
372
373no_sun_fdc:
374 return -1;
375}
376
377static int sparc_eject(void)
378{
379 set_dor(0x00, 0xff, 0x90);
380 udelay(500);
381 set_dor(0x00, 0x6f, 0x00);
382 udelay(500);
383 return 0;
384}
385
386#define fd_eject(drive) sparc_eject()
387
388#define EXTRA_FLOPPY_PARAMS
389
390static DEFINE_SPINLOCK(dma_spin_lock);
391
392#define claim_dma_lock() \
393({ unsigned long flags; \
394 spin_lock_irqsave(&dma_spin_lock, flags); \
395 flags; \
396})
397
398#define release_dma_lock(__flags) \
399 spin_unlock_irqrestore(&dma_spin_lock, __flags);
400
401#endif
402