blob: c47f58d6c15c7aa4b01c47a9ff0610971f864b86 [file] [log] [blame]
David S. Miller9b539c02007-07-28 23:39:30 -07001/* floppy.h: Sparc specific parts of the Floppy driver.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
David S. Miller9b539c02007-07-28 23:39:30 -07003 * Copyright (C) 1996, 2007 David S. Miller (davem@davemloft.net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
5 *
6 * Ultra/PCI support added: Sep 1997 Eddie C. Dost (ecd@skynet.be)
7 */
8
9#ifndef __ASM_SPARC64_FLOPPY_H
10#define __ASM_SPARC64_FLOPPY_H
11
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/init.h>
David S. Miller9b539c02007-07-28 23:39:30 -070013#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014
15#include <asm/page.h>
16#include <asm/pgtable.h>
17#include <asm/system.h>
18#include <asm/idprom.h>
19#include <asm/oplib.h>
20#include <asm/auxio.h>
21#include <asm/sbus.h>
22#include <asm/irq.h>
23
24
25/*
26 * Define this to enable exchanging drive 0 and 1 if only drive 1 is
27 * probed on PCI machines.
28 */
29#undef PCI_FDC_SWAP_DRIVES
30
31
32/* References:
33 * 1) Netbsd Sun floppy driver.
34 * 2) NCR 82077 controller manual
35 * 3) Intel 82077 controller manual
36 */
37struct sun_flpy_controller {
38 volatile unsigned char status1_82077; /* Auxiliary Status reg. 1 */
39 volatile unsigned char status2_82077; /* Auxiliary Status reg. 2 */
40 volatile unsigned char dor_82077; /* Digital Output reg. */
41 volatile unsigned char tapectl_82077; /* Tape Control reg */
42 volatile unsigned char status_82077; /* Main Status Register. */
43#define drs_82077 status_82077 /* Digital Rate Select reg. */
44 volatile unsigned char data_82077; /* Data fifo. */
45 volatile unsigned char ___unused;
46 volatile unsigned char dir_82077; /* Digital Input reg. */
47#define dcr_82077 dir_82077 /* Config Control reg. */
48};
49
50/* You'll only ever find one controller on an Ultra anyways. */
51static struct sun_flpy_controller *sun_fdc = (struct sun_flpy_controller *)-1;
52unsigned long fdc_status;
53static struct sbus_dev *floppy_sdev = NULL;
54
55struct sun_floppy_ops {
56 unsigned char (*fd_inb) (unsigned long port);
57 void (*fd_outb) (unsigned char value, unsigned long port);
58 void (*fd_enable_dma) (void);
59 void (*fd_disable_dma) (void);
60 void (*fd_set_dma_mode) (int);
61 void (*fd_set_dma_addr) (char *);
62 void (*fd_set_dma_count) (int);
63 unsigned int (*get_dma_residue) (void);
64 int (*fd_request_irq) (void);
65 void (*fd_free_irq) (void);
66 int (*fd_eject) (int);
67};
68
69static struct sun_floppy_ops sun_fdops;
70
71#define fd_inb(port) sun_fdops.fd_inb(port)
72#define fd_outb(value,port) sun_fdops.fd_outb(value,port)
73#define fd_enable_dma() sun_fdops.fd_enable_dma()
74#define fd_disable_dma() sun_fdops.fd_disable_dma()
75#define fd_request_dma() (0) /* nothing... */
76#define fd_free_dma() /* nothing... */
77#define fd_clear_dma_ff() /* nothing... */
78#define fd_set_dma_mode(mode) sun_fdops.fd_set_dma_mode(mode)
79#define fd_set_dma_addr(addr) sun_fdops.fd_set_dma_addr(addr)
80#define fd_set_dma_count(count) sun_fdops.fd_set_dma_count(count)
81#define get_dma_residue(x) sun_fdops.get_dma_residue()
82#define fd_cacheflush(addr, size) /* nothing... */
83#define fd_request_irq() sun_fdops.fd_request_irq()
84#define fd_free_irq() sun_fdops.fd_free_irq()
85#define fd_eject(drive) sun_fdops.fd_eject(drive)
86
Linus Torvalds1da177e2005-04-16 15:20:36 -070087/* Super paranoid... */
88#undef HAVE_DISABLE_HLT
89
90static int sun_floppy_types[2] = { 0, 0 };
91
92/* Here is where we catch the floppy driver trying to initialize,
93 * therefore this is where we call the PROM device tree probing
94 * routine etc. on the Sparc.
95 */
96#define FLOPPY0_TYPE sun_floppy_init()
97#define FLOPPY1_TYPE sun_floppy_types[1]
98
99#define FDC1 ((unsigned long)sun_fdc)
100
101#define N_FDC 1
102#define N_DRIVE 8
103
104/* No 64k boundary crossing problems on the Sparc. */
105#define CROSS_64KB(a,s) (0)
106
107static unsigned char sun_82077_fd_inb(unsigned long port)
108{
109 udelay(5);
110 switch(port & 7) {
111 default:
112 printk("floppy: Asked to read unknown port %lx\n", port);
113 panic("floppy: Port bolixed.");
114 case 4: /* FD_STATUS */
115 return sbus_readb(&sun_fdc->status_82077) & ~STATUS_DMA;
116 case 5: /* FD_DATA */
117 return sbus_readb(&sun_fdc->data_82077);
118 case 7: /* FD_DIR */
119 /* XXX: Is DCL on 0x80 in sun4m? */
120 return sbus_readb(&sun_fdc->dir_82077);
121 };
122 panic("sun_82072_fd_inb: How did I get here?");
123}
124
125static void sun_82077_fd_outb(unsigned char value, unsigned long port)
126{
127 udelay(5);
128 switch(port & 7) {
129 default:
130 printk("floppy: Asked to write to unknown port %lx\n", port);
131 panic("floppy: Port bolixed.");
132 case 2: /* FD_DOR */
133 /* Happily, the 82077 has a real DOR register. */
134 sbus_writeb(value, &sun_fdc->dor_82077);
135 break;
136 case 5: /* FD_DATA */
137 sbus_writeb(value, &sun_fdc->data_82077);
138 break;
139 case 7: /* FD_DCR */
140 sbus_writeb(value, &sun_fdc->dcr_82077);
141 break;
142 case 4: /* FD_STATUS */
143 sbus_writeb(value, &sun_fdc->status_82077);
144 break;
145 };
146 return;
147}
148
149/* For pseudo-dma (Sun floppy drives have no real DMA available to
150 * them so we must eat the data fifo bytes directly ourselves) we have
151 * three state variables. doing_pdma tells our inline low-level
152 * assembly floppy interrupt entry point whether it should sit and eat
153 * bytes from the fifo or just transfer control up to the higher level
154 * floppy interrupt c-code. I tried very hard but I could not get the
155 * pseudo-dma to work in c-code without getting many overruns and
156 * underruns. If non-zero, doing_pdma encodes the direction of
157 * the transfer for debugging. 1=read 2=write
158 */
David S. Miller63b61452005-06-27 17:04:45 -0700159unsigned char *pdma_vaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160unsigned long pdma_size;
161volatile int doing_pdma = 0;
162
163/* This is software state */
164char *pdma_base = NULL;
165unsigned long pdma_areasize;
166
167/* Common routines to all controller types on the Sparc. */
168static void sun_fd_disable_dma(void)
169{
170 doing_pdma = 0;
171 if (pdma_base) {
172 mmu_unlockarea(pdma_base, pdma_areasize);
173 pdma_base = NULL;
174 }
175}
176
177static void sun_fd_set_dma_mode(int mode)
178{
179 switch(mode) {
180 case DMA_MODE_READ:
181 doing_pdma = 1;
182 break;
183 case DMA_MODE_WRITE:
184 doing_pdma = 2;
185 break;
186 default:
187 printk("Unknown dma mode %d\n", mode);
188 panic("floppy: Giving up...");
189 }
190}
191
192static void sun_fd_set_dma_addr(char *buffer)
193{
194 pdma_vaddr = buffer;
195}
196
197static void sun_fd_set_dma_count(int length)
198{
199 pdma_size = length;
200}
201
202static void sun_fd_enable_dma(void)
203{
204 pdma_vaddr = mmu_lockarea(pdma_vaddr, pdma_size);
205 pdma_base = pdma_vaddr;
206 pdma_areasize = pdma_size;
207}
208
Al Viro6d24c8d2006-10-08 08:23:28 -0400209irqreturn_t sparc_floppy_irq(int irq, void *dev_cookie)
David S. Miller35055992006-06-25 01:32:25 -0700210{
211 if (likely(doing_pdma)) {
212 void __iomem *stat = (void __iomem *) fdc_status;
213 unsigned char *vaddr = pdma_vaddr;
214 unsigned long size = pdma_size;
215 u8 val;
216
217 while (size) {
218 val = readb(stat);
219 if (unlikely(!(val & 0x80))) {
220 pdma_vaddr = vaddr;
221 pdma_size = size;
222 return IRQ_HANDLED;
223 }
224 if (unlikely(!(val & 0x20))) {
225 pdma_vaddr = vaddr;
226 pdma_size = size;
227 doing_pdma = 0;
228 goto main_interrupt;
229 }
230 if (val & 0x40) {
231 /* read */
232 *vaddr++ = readb(stat + 1);
233 } else {
234 unsigned char data = *vaddr++;
235
236 /* write */
237 writeb(data, stat + 1);
238 }
239 size--;
240 }
241
242 pdma_vaddr = vaddr;
243 pdma_size = size;
244
245 /* Send Terminal Count pulse to floppy controller. */
246 val = readb(auxio_register);
247 val |= AUXIO_AUX1_FTCNT;
248 writeb(val, auxio_register);
249 val &= ~AUXIO_AUX1_FTCNT;
250 writeb(val, auxio_register);
251
252 doing_pdma = 0;
253 }
254
255main_interrupt:
Al Viro6d24c8d2006-10-08 08:23:28 -0400256 return floppy_interrupt(irq, dev_cookie);
David S. Miller35055992006-06-25 01:32:25 -0700257}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
259static int sun_fd_request_irq(void)
260{
261 static int once = 0;
262 int error;
263
264 if(!once) {
265 once = 1;
266
David S. Miller63b61452005-06-27 17:04:45 -0700267 error = request_irq(FLOPPY_IRQ, sparc_floppy_irq,
Thomas Gleixnerd356d7f2006-07-01 19:29:26 -0700268 IRQF_DISABLED, "floppy", NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270 return ((error == 0) ? 0 : -1);
271 }
272 return 0;
273}
274
275static void sun_fd_free_irq(void)
276{
277}
278
279static unsigned int sun_get_dma_residue(void)
280{
281 /* XXX This isn't really correct. XXX */
282 return 0;
283}
284
285static int sun_fd_eject(int drive)
286{
287 set_dor(0x00, 0xff, 0x90);
288 udelay(500);
289 set_dor(0x00, 0x6f, 0x00);
290 udelay(500);
291 return 0;
292}
293
294#ifdef CONFIG_PCI
295#include <asm/ebus.h>
296#include <asm/isa.h>
297#include <asm/ns87303.h>
298
299static struct ebus_dma_info sun_pci_fd_ebus_dma;
300static struct pci_dev *sun_pci_ebus_dev;
301static int sun_pci_broken_drive = -1;
302
303struct sun_pci_dma_op {
304 unsigned int addr;
305 int len;
306 int direction;
307 char *buf;
308};
309static struct sun_pci_dma_op sun_pci_dma_current = { -1U, 0, 0, NULL};
310static struct sun_pci_dma_op sun_pci_dma_pending = { -1U, 0, 0, NULL};
311
Al Viro6d24c8d2006-10-08 08:23:28 -0400312extern irqreturn_t floppy_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
314static unsigned char sun_pci_fd_inb(unsigned long port)
315{
316 udelay(5);
317 return inb(port);
318}
319
320static void sun_pci_fd_outb(unsigned char val, unsigned long port)
321{
322 udelay(5);
323 outb(val, port);
324}
325
326static void sun_pci_fd_broken_outb(unsigned char val, unsigned long port)
327{
328 udelay(5);
329 /*
330 * XXX: Due to SUN's broken floppy connector on AX and AXi
331 * we need to turn on MOTOR_0 also, if the floppy is
332 * jumpered to DS1 (like most PC floppies are). I hope
333 * this does not hurt correct hardware like the AXmp.
334 * (Eddie, Sep 12 1998).
335 */
336 if (port == ((unsigned long)sun_fdc) + 2) {
337 if (((val & 0x03) == sun_pci_broken_drive) && (val & 0x20)) {
338 val |= 0x10;
339 }
340 }
341 outb(val, port);
342}
343
344#ifdef PCI_FDC_SWAP_DRIVES
345static void sun_pci_fd_lde_broken_outb(unsigned char val, unsigned long port)
346{
347 udelay(5);
348 /*
349 * XXX: Due to SUN's broken floppy connector on AX and AXi
350 * we need to turn on MOTOR_0 also, if the floppy is
351 * jumpered to DS1 (like most PC floppies are). I hope
352 * this does not hurt correct hardware like the AXmp.
353 * (Eddie, Sep 12 1998).
354 */
355 if (port == ((unsigned long)sun_fdc) + 2) {
356 if (((val & 0x03) == sun_pci_broken_drive) && (val & 0x10)) {
357 val &= ~(0x03);
358 val |= 0x21;
359 }
360 }
361 outb(val, port);
362}
363#endif /* PCI_FDC_SWAP_DRIVES */
364
365static void sun_pci_fd_enable_dma(void)
366{
367 BUG_ON((NULL == sun_pci_dma_pending.buf) ||
368 (0 == sun_pci_dma_pending.len) ||
369 (0 == sun_pci_dma_pending.direction));
370
371 sun_pci_dma_current.buf = sun_pci_dma_pending.buf;
372 sun_pci_dma_current.len = sun_pci_dma_pending.len;
373 sun_pci_dma_current.direction = sun_pci_dma_pending.direction;
374
375 sun_pci_dma_pending.buf = NULL;
376 sun_pci_dma_pending.len = 0;
377 sun_pci_dma_pending.direction = 0;
378 sun_pci_dma_pending.addr = -1U;
379
380 sun_pci_dma_current.addr =
381 pci_map_single(sun_pci_ebus_dev,
382 sun_pci_dma_current.buf,
383 sun_pci_dma_current.len,
384 sun_pci_dma_current.direction);
385
386 ebus_dma_enable(&sun_pci_fd_ebus_dma, 1);
387
388 if (ebus_dma_request(&sun_pci_fd_ebus_dma,
389 sun_pci_dma_current.addr,
390 sun_pci_dma_current.len))
391 BUG();
392}
393
394static void sun_pci_fd_disable_dma(void)
395{
396 ebus_dma_enable(&sun_pci_fd_ebus_dma, 0);
397 if (sun_pci_dma_current.addr != -1U)
398 pci_unmap_single(sun_pci_ebus_dev,
399 sun_pci_dma_current.addr,
400 sun_pci_dma_current.len,
401 sun_pci_dma_current.direction);
402 sun_pci_dma_current.addr = -1U;
403}
404
405static void sun_pci_fd_set_dma_mode(int mode)
406{
407 if (mode == DMA_MODE_WRITE)
408 sun_pci_dma_pending.direction = PCI_DMA_TODEVICE;
409 else
410 sun_pci_dma_pending.direction = PCI_DMA_FROMDEVICE;
411
412 ebus_dma_prepare(&sun_pci_fd_ebus_dma, mode != DMA_MODE_WRITE);
413}
414
415static void sun_pci_fd_set_dma_count(int length)
416{
417 sun_pci_dma_pending.len = length;
418}
419
420static void sun_pci_fd_set_dma_addr(char *buffer)
421{
422 sun_pci_dma_pending.buf = buffer;
423}
424
425static unsigned int sun_pci_get_dma_residue(void)
426{
427 return ebus_dma_residue(&sun_pci_fd_ebus_dma);
428}
429
430static int sun_pci_fd_request_irq(void)
431{
432 return ebus_dma_irq_enable(&sun_pci_fd_ebus_dma, 1);
433}
434
435static void sun_pci_fd_free_irq(void)
436{
437 ebus_dma_irq_enable(&sun_pci_fd_ebus_dma, 0);
438}
439
440static int sun_pci_fd_eject(int drive)
441{
442 return -EINVAL;
443}
444
445void sun_pci_fd_dma_callback(struct ebus_dma_info *p, int event, void *cookie)
446{
Al Viro6d24c8d2006-10-08 08:23:28 -0400447 floppy_interrupt(0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448}
449
450/*
451 * Floppy probing, we'd like to use /dev/fd0 for a single Floppy on PCI,
452 * even if this is configured using DS1, thus looks like /dev/fd1 with
453 * the cabling used in Ultras.
454 */
455#define DOR (port + 2)
456#define MSR (port + 4)
457#define FIFO (port + 5)
458
459static void sun_pci_fd_out_byte(unsigned long port, unsigned char val,
460 unsigned long reg)
461{
462 unsigned char status;
463 int timeout = 1000;
464
465 while (!((status = inb(MSR)) & 0x80) && --timeout)
466 udelay(100);
467 outb(val, reg);
468}
469
470static unsigned char sun_pci_fd_sensei(unsigned long port)
471{
472 unsigned char result[2] = { 0x70, 0x00 };
473 unsigned char status;
474 int i = 0;
475
476 sun_pci_fd_out_byte(port, 0x08, FIFO);
477 do {
478 int timeout = 1000;
479
480 while (!((status = inb(MSR)) & 0x80) && --timeout)
481 udelay(100);
482
483 if (!timeout)
484 break;
485
486 if ((status & 0xf0) == 0xd0)
487 result[i++] = inb(FIFO);
488 else
489 break;
490 } while (i < 2);
491
492 return result[0];
493}
494
495static void sun_pci_fd_reset(unsigned long port)
496{
497 unsigned char mask = 0x00;
498 unsigned char status;
499 int timeout = 10000;
500
501 outb(0x80, MSR);
502 do {
503 status = sun_pci_fd_sensei(port);
504 if ((status & 0xc0) == 0xc0)
505 mask |= 1 << (status & 0x03);
506 else
507 udelay(100);
508 } while ((mask != 0x0f) && --timeout);
509}
510
511static int sun_pci_fd_test_drive(unsigned long port, int drive)
512{
513 unsigned char status, data;
514 int timeout = 1000;
515 int ready;
516
517 sun_pci_fd_reset(port);
518
519 data = (0x10 << drive) | 0x0c | drive;
520 sun_pci_fd_out_byte(port, data, DOR);
521
522 sun_pci_fd_out_byte(port, 0x07, FIFO);
523 sun_pci_fd_out_byte(port, drive & 0x03, FIFO);
524
525 do {
526 udelay(100);
527 status = sun_pci_fd_sensei(port);
528 } while (((status & 0xc0) == 0x80) && --timeout);
529
530 if (!timeout)
531 ready = 0;
532 else
533 ready = (status & 0x10) ? 0 : 1;
534
535 sun_pci_fd_reset(port);
536 return ready;
537}
538#undef FIFO
539#undef MSR
540#undef DOR
541
542#endif /* CONFIG_PCI */
543
544#ifdef CONFIG_PCI
545static int __init ebus_fdthree_p(struct linux_ebus_device *edev)
546{
David S. Miller690c8fd2006-06-22 19:12:03 -0700547 if (!strcmp(edev->prom_node->name, "fdthree"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 return 1;
David S. Miller690c8fd2006-06-22 19:12:03 -0700549 if (!strcmp(edev->prom_node->name, "floppy")) {
Stephen Rothwell66f3cb72007-03-29 00:50:29 -0700550 const char *compat;
David S. Miller690c8fd2006-06-22 19:12:03 -0700551
552 compat = of_get_property(edev->prom_node,
553 "compatible", NULL);
554 if (compat && !strcmp(compat, "fdthree"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 return 1;
556 }
557 return 0;
558}
559#endif
560
561#ifdef CONFIG_PCI
562#undef ISA_FLOPPY_WORKS
563
564#ifdef ISA_FLOPPY_WORKS
565static unsigned long __init isa_floppy_init(void)
566{
567 struct sparc_isa_bridge *isa_br;
568 struct sparc_isa_device *isa_dev = NULL;
569
570 for_each_isa(isa_br) {
571 for_each_isadev(isa_dev, isa_br) {
David S. Miller690c8fd2006-06-22 19:12:03 -0700572 if (!strcmp(isa_dev->prom_node->name, "dma")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 struct sparc_isa_device *child =
574 isa_dev->child;
575
576 while (child) {
David S. Miller690c8fd2006-06-22 19:12:03 -0700577 if (!strcmp(child->prom_node->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 "floppy")) {
579 isa_dev = child;
580 goto isa_done;
581 }
582 child = child->next;
583 }
584 }
585 }
586 }
587isa_done:
588 if (!isa_dev)
589 return 0;
590
591 /* We could use DMA on devices behind the ISA bridge, but...
592 *
593 * There is a slight problem. Normally on x86 kit the x86 processor
594 * delays I/O port instructions when the ISA bus "dma in progress"
595 * signal is active. Well, sparc64 systems do not monitor this
596 * signal thus we would need to block all I/O port accesses in software
597 * when a dma transfer is active for some device.
598 */
599
600 sun_fdc = (struct sun_flpy_controller *)isa_dev->resource.start;
601 FLOPPY_IRQ = isa_dev->irq;
602
603 sun_fdops.fd_inb = sun_pci_fd_inb;
604 sun_fdops.fd_outb = sun_pci_fd_outb;
605
606 can_use_virtual_dma = use_virtual_dma = 1;
607 sun_fdops.fd_enable_dma = sun_fd_enable_dma;
608 sun_fdops.fd_disable_dma = sun_fd_disable_dma;
609 sun_fdops.fd_set_dma_mode = sun_fd_set_dma_mode;
610 sun_fdops.fd_set_dma_addr = sun_fd_set_dma_addr;
611 sun_fdops.fd_set_dma_count = sun_fd_set_dma_count;
612 sun_fdops.get_dma_residue = sun_get_dma_residue;
613
614 sun_fdops.fd_request_irq = sun_fd_request_irq;
615 sun_fdops.fd_free_irq = sun_fd_free_irq;
616
617 /* Floppy eject is manual. Actually, could determine this
618 * via presence of 'manual' property in OBP node.
619 */
620 sun_fdops.fd_eject = sun_pci_fd_eject;
621
622 fdc_status = (unsigned long) &sun_fdc->status_82077;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
624 allowed_drive_mask = 0;
625 sun_floppy_types[0] = 0;
626 sun_floppy_types[1] = 4;
627
628 sun_pci_broken_drive = 1;
629 sun_fdops.fd_outb = sun_pci_fd_broken_outb;
630
631 return sun_floppy_types[0];
632}
633#endif /* ISA_FLOPPY_WORKS */
634
635#endif
636
637static unsigned long __init sun_floppy_init(void)
638{
639 char state[128];
640 struct sbus_bus *bus;
641 struct sbus_dev *sdev = NULL;
642 static int initialized = 0;
643
644 if (initialized)
645 return sun_floppy_types[0];
646 initialized = 1;
647
648 for_all_sbusdev (sdev, bus) {
649 if (!strcmp(sdev->prom_name, "SUNW,fdtwo"))
650 break;
651 }
652 if(sdev) {
653 floppy_sdev = sdev;
654 FLOPPY_IRQ = sdev->irqs[0];
655 } else {
656#ifdef CONFIG_PCI
657 struct linux_ebus *ebus;
658 struct linux_ebus_device *edev = NULL;
659 unsigned long config = 0;
David S. Miller63b61452005-06-27 17:04:45 -0700660 void __iomem *auxio_reg;
Stephen Rothwell66f3cb72007-03-29 00:50:29 -0700661 const char *state_prop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
663 for_each_ebus(ebus) {
664 for_each_ebusdev(edev, ebus) {
665 if (ebus_fdthree_p(edev))
666 goto ebus_done;
667 }
668 }
669 ebus_done:
670 if (!edev) {
671#ifdef ISA_FLOPPY_WORKS
672 return isa_floppy_init();
673#else
674 return 0;
675#endif
676 }
677
David S. Miller690c8fd2006-06-22 19:12:03 -0700678 state_prop = of_get_property(edev->prom_node, "status", NULL);
679 if (state_prop && !strncmp(state_prop, "disabled", 8))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 return 0;
681
682 FLOPPY_IRQ = edev->irqs[0];
683
684 /* Make sure the high density bit is set, some systems
685 * (most notably Ultra5/Ultra10) come up with it clear.
686 */
David S. Miller63b61452005-06-27 17:04:45 -0700687 auxio_reg = (void __iomem *) edev->resource[2].start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 writel(readl(auxio_reg)|0x2, auxio_reg);
689
690 sun_pci_ebus_dev = ebus->self;
691
692 spin_lock_init(&sun_pci_fd_ebus_dma.lock);
693
694 /* XXX ioremap */
David S. Miller63b61452005-06-27 17:04:45 -0700695 sun_pci_fd_ebus_dma.regs = (void __iomem *)
696 edev->resource[1].start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 if (!sun_pci_fd_ebus_dma.regs)
698 return 0;
699
700 sun_pci_fd_ebus_dma.flags = (EBUS_DMA_FLAG_USE_EBDMA_HANDLER |
701 EBUS_DMA_FLAG_TCI_DISABLE);
702 sun_pci_fd_ebus_dma.callback = sun_pci_fd_dma_callback;
703 sun_pci_fd_ebus_dma.client_cookie = NULL;
704 sun_pci_fd_ebus_dma.irq = FLOPPY_IRQ;
705 strcpy(sun_pci_fd_ebus_dma.name, "floppy");
706 if (ebus_dma_register(&sun_pci_fd_ebus_dma))
707 return 0;
708
709 /* XXX ioremap */
710 sun_fdc = (struct sun_flpy_controller *)edev->resource[0].start;
711
712 sun_fdops.fd_inb = sun_pci_fd_inb;
713 sun_fdops.fd_outb = sun_pci_fd_outb;
714
715 can_use_virtual_dma = use_virtual_dma = 0;
716 sun_fdops.fd_enable_dma = sun_pci_fd_enable_dma;
717 sun_fdops.fd_disable_dma = sun_pci_fd_disable_dma;
718 sun_fdops.fd_set_dma_mode = sun_pci_fd_set_dma_mode;
719 sun_fdops.fd_set_dma_addr = sun_pci_fd_set_dma_addr;
720 sun_fdops.fd_set_dma_count = sun_pci_fd_set_dma_count;
721 sun_fdops.get_dma_residue = sun_pci_get_dma_residue;
722
723 sun_fdops.fd_request_irq = sun_pci_fd_request_irq;
724 sun_fdops.fd_free_irq = sun_pci_fd_free_irq;
725
726 sun_fdops.fd_eject = sun_pci_fd_eject;
727
728 fdc_status = (unsigned long) &sun_fdc->status_82077;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730 /*
731 * XXX: Find out on which machines this is really needed.
732 */
733 if (1) {
734 sun_pci_broken_drive = 1;
735 sun_fdops.fd_outb = sun_pci_fd_broken_outb;
736 }
737
738 allowed_drive_mask = 0;
739 if (sun_pci_fd_test_drive((unsigned long)sun_fdc, 0))
740 sun_floppy_types[0] = 4;
741 if (sun_pci_fd_test_drive((unsigned long)sun_fdc, 1))
742 sun_floppy_types[1] = 4;
743
744 /*
745 * Find NS87303 SuperIO config registers (through ecpp).
746 */
747 for_each_ebus(ebus) {
748 for_each_ebusdev(edev, ebus) {
David S. Miller690c8fd2006-06-22 19:12:03 -0700749 if (!strcmp(edev->prom_node->name, "ecpp")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 config = edev->resource[1].start;
751 goto config_done;
752 }
753 }
754 }
755 config_done:
756
757 /*
758 * Sanity check, is this really the NS87303?
759 */
760 switch (config & 0x3ff) {
761 case 0x02e:
762 case 0x15c:
763 case 0x26e:
764 case 0x398:
765 break;
766 default:
767 config = 0;
768 }
769
770 if (!config)
771 return sun_floppy_types[0];
772
773 /* Enable PC-AT mode. */
774 ns87303_modify(config, ASC, 0, 0xc0);
775
776#ifdef PCI_FDC_SWAP_DRIVES
777 /*
778 * If only Floppy 1 is present, swap drives.
779 */
780 if (!sun_floppy_types[0] && sun_floppy_types[1]) {
781 /*
782 * Set the drive exchange bit in FCR on NS87303,
Alexey Dobriyan7f927fc2006-03-28 01:56:53 -0800783 * make sure other bits are sane before doing so.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 */
785 ns87303_modify(config, FER, FER_EDM, 0);
786 ns87303_modify(config, ASC, ASC_DRV2_SEL, 0);
787 ns87303_modify(config, FCR, 0, FCR_LDE);
788
789 config = sun_floppy_types[0];
790 sun_floppy_types[0] = sun_floppy_types[1];
791 sun_floppy_types[1] = config;
792
793 if (sun_pci_broken_drive != -1) {
794 sun_pci_broken_drive = 1 - sun_pci_broken_drive;
795 sun_fdops.fd_outb = sun_pci_fd_lde_broken_outb;
796 }
797 }
798#endif /* PCI_FDC_SWAP_DRIVES */
799
800 return sun_floppy_types[0];
801#else
802 return 0;
803#endif
804 }
805 prom_getproperty(sdev->prom_node, "status", state, sizeof(state));
806 if(!strncmp(state, "disabled", 8))
807 return 0;
808
809 /*
810 * We cannot do sbus_ioremap here: it does request_region,
811 * which the generic floppy driver tries to do once again.
812 * But we must use the sdev resource values as they have
813 * had parent ranges applied.
814 */
815 sun_fdc = (struct sun_flpy_controller *)
816 (sdev->resource[0].start +
817 ((sdev->resource[0].flags & 0x1ffUL) << 32UL));
818
819 /* Last minute sanity check... */
820 if(sbus_readb(&sun_fdc->status1_82077) == 0xff) {
821 sun_fdc = (struct sun_flpy_controller *)-1;
822 return 0;
823 }
824
825 sun_fdops.fd_inb = sun_82077_fd_inb;
826 sun_fdops.fd_outb = sun_82077_fd_outb;
827
828 can_use_virtual_dma = use_virtual_dma = 1;
829 sun_fdops.fd_enable_dma = sun_fd_enable_dma;
830 sun_fdops.fd_disable_dma = sun_fd_disable_dma;
831 sun_fdops.fd_set_dma_mode = sun_fd_set_dma_mode;
832 sun_fdops.fd_set_dma_addr = sun_fd_set_dma_addr;
833 sun_fdops.fd_set_dma_count = sun_fd_set_dma_count;
834 sun_fdops.get_dma_residue = sun_get_dma_residue;
835
836 sun_fdops.fd_request_irq = sun_fd_request_irq;
837 sun_fdops.fd_free_irq = sun_fd_free_irq;
838
839 sun_fdops.fd_eject = sun_fd_eject;
840
841 fdc_status = (unsigned long) &sun_fdc->status_82077;
842
843 /* Success... */
844 allowed_drive_mask = 0x01;
845 sun_floppy_types[0] = 4;
846 sun_floppy_types[1] = 0;
847
848 return sun_floppy_types[0];
849}
850
851#define EXTRA_FLOPPY_PARAMS
852
David S. Miller78ad0b82007-03-04 20:36:18 -0800853static DEFINE_SPINLOCK(dma_spin_lock);
854
855#define claim_dma_lock() \
856({ unsigned long flags; \
857 spin_lock_irqsave(&dma_spin_lock, flags); \
858 flags; \
859})
860
861#define release_dma_lock(__flags) \
862 spin_unlock_irqrestore(&dma_spin_lock, __flags);
863
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864#endif /* !(__ASM_SPARC64_FLOPPY_H) */