1 /* SPDX-License-Identifier: GPL-2.0 */
2 /* floppy.h: Sparc specific parts of the Floppy driver.
4 * Copyright (C) 1996, 2007, 2008 David S. Miller (davem@davemloft.net)
5 * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
7 * Ultra/PCI support added: Sep 1997 Eddie C. Dost (ecd@skynet.be)
10 #ifndef __ASM_SPARC64_FLOPPY_H
11 #define __ASM_SPARC64_FLOPPY_H
14 #include <linux/of_device.h>
15 #include <linux/dma-mapping.h>
17 #include <asm/auxio.h>
20 * Define this to enable exchanging drive 0 and 1 if only drive 1 is
21 * probed on PCI machines.
23 #undef PCI_FDC_SWAP_DRIVES
27 * 1) Netbsd Sun floppy driver.
28 * 2) NCR 82077 controller manual
29 * 3) Intel 82077 controller manual
31 struct sun_flpy_controller
{
32 volatile unsigned char status1_82077
; /* Auxiliary Status reg. 1 */
33 volatile unsigned char status2_82077
; /* Auxiliary Status reg. 2 */
34 volatile unsigned char dor_82077
; /* Digital Output reg. */
35 volatile unsigned char tapectl_82077
; /* Tape Control reg */
36 volatile unsigned char status_82077
; /* Main Status Register. */
37 #define drs_82077 status_82077 /* Digital Rate Select reg. */
38 volatile unsigned char data_82077
; /* Data fifo. */
39 volatile unsigned char ___unused
;
40 volatile unsigned char dir_82077
; /* Digital Input reg. */
41 #define dcr_82077 dir_82077 /* Config Control reg. */
44 /* You'll only ever find one controller on an Ultra anyways. */
45 static struct sun_flpy_controller
*sun_fdc
= (struct sun_flpy_controller
*)-1;
46 unsigned long fdc_status
;
47 static struct platform_device
*floppy_op
= NULL
;
49 struct sun_floppy_ops
{
50 unsigned char (*fd_inb
) (unsigned long port
);
51 void (*fd_outb
) (unsigned char value
, unsigned long port
);
52 void (*fd_enable_dma
) (void);
53 void (*fd_disable_dma
) (void);
54 void (*fd_set_dma_mode
) (int);
55 void (*fd_set_dma_addr
) (char *);
56 void (*fd_set_dma_count
) (int);
57 unsigned int (*get_dma_residue
) (void);
58 int (*fd_request_irq
) (void);
59 void (*fd_free_irq
) (void);
60 int (*fd_eject
) (int);
63 static struct sun_floppy_ops sun_fdops
;
65 #define fd_inb(port) sun_fdops.fd_inb(port)
66 #define fd_outb(value,port) sun_fdops.fd_outb(value,port)
67 #define fd_enable_dma() sun_fdops.fd_enable_dma()
68 #define fd_disable_dma() sun_fdops.fd_disable_dma()
69 #define fd_request_dma() (0) /* nothing... */
70 #define fd_free_dma() /* nothing... */
71 #define fd_clear_dma_ff() /* nothing... */
72 #define fd_set_dma_mode(mode) sun_fdops.fd_set_dma_mode(mode)
73 #define fd_set_dma_addr(addr) sun_fdops.fd_set_dma_addr(addr)
74 #define fd_set_dma_count(count) sun_fdops.fd_set_dma_count(count)
75 #define get_dma_residue(x) sun_fdops.get_dma_residue()
76 #define fd_cacheflush(addr, size) /* nothing... */
77 #define fd_request_irq() sun_fdops.fd_request_irq()
78 #define fd_free_irq() sun_fdops.fd_free_irq()
79 #define fd_eject(drive) sun_fdops.fd_eject(drive)
81 /* Super paranoid... */
82 #undef HAVE_DISABLE_HLT
84 static int sun_floppy_types
[2] = { 0, 0 };
86 /* Here is where we catch the floppy driver trying to initialize,
87 * therefore this is where we call the PROM device tree probing
88 * routine etc. on the Sparc.
90 #define FLOPPY0_TYPE sun_floppy_init()
91 #define FLOPPY1_TYPE sun_floppy_types[1]
93 #define FDC1 ((unsigned long)sun_fdc)
98 /* No 64k boundary crossing problems on the Sparc. */
99 #define CROSS_64KB(a,s) (0)
101 static unsigned char sun_82077_fd_inb(unsigned long port
)
106 printk("floppy: Asked to read unknown port %lx\n", port
);
107 panic("floppy: Port bolixed.");
108 case 4: /* FD_STATUS */
109 return sbus_readb(&sun_fdc
->status_82077
) & ~STATUS_DMA
;
110 case 5: /* FD_DATA */
111 return sbus_readb(&sun_fdc
->data_82077
);
113 /* XXX: Is DCL on 0x80 in sun4m? */
114 return sbus_readb(&sun_fdc
->dir_82077
);
116 panic("sun_82072_fd_inb: How did I get here?");
119 static void sun_82077_fd_outb(unsigned char value
, unsigned long port
)
124 printk("floppy: Asked to write to unknown port %lx\n", port
);
125 panic("floppy: Port bolixed.");
127 /* Happily, the 82077 has a real DOR register. */
128 sbus_writeb(value
, &sun_fdc
->dor_82077
);
130 case 5: /* FD_DATA */
131 sbus_writeb(value
, &sun_fdc
->data_82077
);
134 sbus_writeb(value
, &sun_fdc
->dcr_82077
);
136 case 4: /* FD_STATUS */
137 sbus_writeb(value
, &sun_fdc
->status_82077
);
143 /* For pseudo-dma (Sun floppy drives have no real DMA available to
144 * them so we must eat the data fifo bytes directly ourselves) we have
145 * three state variables. doing_pdma tells our inline low-level
146 * assembly floppy interrupt entry point whether it should sit and eat
147 * bytes from the fifo or just transfer control up to the higher level
148 * floppy interrupt c-code. I tried very hard but I could not get the
149 * pseudo-dma to work in c-code without getting many overruns and
150 * underruns. If non-zero, doing_pdma encodes the direction of
151 * the transfer for debugging. 1=read 2=write
153 unsigned char *pdma_vaddr
;
154 unsigned long pdma_size
;
155 volatile int doing_pdma
= 0;
157 /* This is software state */
158 char *pdma_base
= NULL
;
159 unsigned long pdma_areasize
;
161 /* Common routines to all controller types on the Sparc. */
162 static void sun_fd_disable_dma(void)
168 static void sun_fd_set_dma_mode(int mode
)
178 printk("Unknown dma mode %d\n", mode
);
179 panic("floppy: Giving up...");
183 static void sun_fd_set_dma_addr(char *buffer
)
188 static void sun_fd_set_dma_count(int length
)
193 static void sun_fd_enable_dma(void)
195 pdma_base
= pdma_vaddr
;
196 pdma_areasize
= pdma_size
;
199 irqreturn_t
sparc_floppy_irq(int irq
, void *dev_cookie
)
201 if (likely(doing_pdma
)) {
202 void __iomem
*stat
= (void __iomem
*) fdc_status
;
203 unsigned char *vaddr
= pdma_vaddr
;
204 unsigned long size
= pdma_size
;
209 if (unlikely(!(val
& 0x80))) {
214 if (unlikely(!(val
& 0x20))) {
222 *vaddr
++ = readb(stat
+ 1);
224 unsigned char data
= *vaddr
++;
227 writeb(data
, stat
+ 1);
235 /* Send Terminal Count pulse to floppy controller. */
236 val
= readb(auxio_register
);
237 val
|= AUXIO_AUX1_FTCNT
;
238 writeb(val
, auxio_register
);
239 val
&= ~AUXIO_AUX1_FTCNT
;
240 writeb(val
, auxio_register
);
246 return floppy_interrupt(irq
, dev_cookie
);
249 static int sun_fd_request_irq(void)
257 error
= request_irq(FLOPPY_IRQ
, sparc_floppy_irq
,
260 return ((error
== 0) ? 0 : -1);
265 static void sun_fd_free_irq(void)
269 static unsigned int sun_get_dma_residue(void)
271 /* XXX This isn't really correct. XXX */
275 static int sun_fd_eject(int drive
)
277 set_dor(0x00, 0xff, 0x90);
279 set_dor(0x00, 0x6f, 0x00);
284 #include <asm/ebus_dma.h>
285 #include <asm/ns87303.h>
287 static struct ebus_dma_info sun_pci_fd_ebus_dma
;
288 static struct device
*sun_floppy_dev
;
289 static int sun_pci_broken_drive
= -1;
291 struct sun_pci_dma_op
{
297 static struct sun_pci_dma_op sun_pci_dma_current
= { -1U, 0, 0, NULL
};
298 static struct sun_pci_dma_op sun_pci_dma_pending
= { -1U, 0, 0, NULL
};
300 irqreturn_t
floppy_interrupt(int irq
, void *dev_id
);
302 static unsigned char sun_pci_fd_inb(unsigned long port
)
308 static void sun_pci_fd_outb(unsigned char val
, unsigned long port
)
314 static void sun_pci_fd_broken_outb(unsigned char val
, unsigned long port
)
318 * XXX: Due to SUN's broken floppy connector on AX and AXi
319 * we need to turn on MOTOR_0 also, if the floppy is
320 * jumpered to DS1 (like most PC floppies are). I hope
321 * this does not hurt correct hardware like the AXmp.
322 * (Eddie, Sep 12 1998).
324 if (port
== ((unsigned long)sun_fdc
) + 2) {
325 if (((val
& 0x03) == sun_pci_broken_drive
) && (val
& 0x20)) {
332 #ifdef PCI_FDC_SWAP_DRIVES
333 static void sun_pci_fd_lde_broken_outb(unsigned char val
, unsigned long port
)
337 * XXX: Due to SUN's broken floppy connector on AX and AXi
338 * we need to turn on MOTOR_0 also, if the floppy is
339 * jumpered to DS1 (like most PC floppies are). I hope
340 * this does not hurt correct hardware like the AXmp.
341 * (Eddie, Sep 12 1998).
343 if (port
== ((unsigned long)sun_fdc
) + 2) {
344 if (((val
& 0x03) == sun_pci_broken_drive
) && (val
& 0x10)) {
351 #endif /* PCI_FDC_SWAP_DRIVES */
353 static void sun_pci_fd_enable_dma(void)
355 BUG_ON((NULL
== sun_pci_dma_pending
.buf
) ||
356 (0 == sun_pci_dma_pending
.len
) ||
357 (0 == sun_pci_dma_pending
.direction
));
359 sun_pci_dma_current
.buf
= sun_pci_dma_pending
.buf
;
360 sun_pci_dma_current
.len
= sun_pci_dma_pending
.len
;
361 sun_pci_dma_current
.direction
= sun_pci_dma_pending
.direction
;
363 sun_pci_dma_pending
.buf
= NULL
;
364 sun_pci_dma_pending
.len
= 0;
365 sun_pci_dma_pending
.direction
= 0;
366 sun_pci_dma_pending
.addr
= -1U;
368 sun_pci_dma_current
.addr
=
369 dma_map_single(sun_floppy_dev
,
370 sun_pci_dma_current
.buf
,
371 sun_pci_dma_current
.len
,
372 sun_pci_dma_current
.direction
);
374 ebus_dma_enable(&sun_pci_fd_ebus_dma
, 1);
376 if (ebus_dma_request(&sun_pci_fd_ebus_dma
,
377 sun_pci_dma_current
.addr
,
378 sun_pci_dma_current
.len
))
382 static void sun_pci_fd_disable_dma(void)
384 ebus_dma_enable(&sun_pci_fd_ebus_dma
, 0);
385 if (sun_pci_dma_current
.addr
!= -1U)
386 dma_unmap_single(sun_floppy_dev
,
387 sun_pci_dma_current
.addr
,
388 sun_pci_dma_current
.len
,
389 sun_pci_dma_current
.direction
);
390 sun_pci_dma_current
.addr
= -1U;
393 static void sun_pci_fd_set_dma_mode(int mode
)
395 if (mode
== DMA_MODE_WRITE
)
396 sun_pci_dma_pending
.direction
= DMA_TO_DEVICE
;
398 sun_pci_dma_pending
.direction
= DMA_FROM_DEVICE
;
400 ebus_dma_prepare(&sun_pci_fd_ebus_dma
, mode
!= DMA_MODE_WRITE
);
403 static void sun_pci_fd_set_dma_count(int length
)
405 sun_pci_dma_pending
.len
= length
;
408 static void sun_pci_fd_set_dma_addr(char *buffer
)
410 sun_pci_dma_pending
.buf
= buffer
;
413 static unsigned int sun_pci_get_dma_residue(void)
415 return ebus_dma_residue(&sun_pci_fd_ebus_dma
);
418 static int sun_pci_fd_request_irq(void)
420 return ebus_dma_irq_enable(&sun_pci_fd_ebus_dma
, 1);
423 static void sun_pci_fd_free_irq(void)
425 ebus_dma_irq_enable(&sun_pci_fd_ebus_dma
, 0);
428 static int sun_pci_fd_eject(int drive
)
433 void sun_pci_fd_dma_callback(struct ebus_dma_info
*p
, int event
, void *cookie
)
435 floppy_interrupt(0, NULL
);
439 * Floppy probing, we'd like to use /dev/fd0 for a single Floppy on PCI,
440 * even if this is configured using DS1, thus looks like /dev/fd1 with
441 * the cabling used in Ultras.
443 #define DOR (port + 2)
444 #define MSR (port + 4)
445 #define FIFO (port + 5)
447 static void sun_pci_fd_out_byte(unsigned long port
, unsigned char val
,
450 unsigned char status
;
453 while (!((status
= inb(MSR
)) & 0x80) && --timeout
)
458 static unsigned char sun_pci_fd_sensei(unsigned long port
)
460 unsigned char result
[2] = { 0x70, 0x00 };
461 unsigned char status
;
464 sun_pci_fd_out_byte(port
, 0x08, FIFO
);
468 while (!((status
= inb(MSR
)) & 0x80) && --timeout
)
474 if ((status
& 0xf0) == 0xd0)
475 result
[i
++] = inb(FIFO
);
483 static void sun_pci_fd_reset(unsigned long port
)
485 unsigned char mask
= 0x00;
486 unsigned char status
;
491 status
= sun_pci_fd_sensei(port
);
492 if ((status
& 0xc0) == 0xc0)
493 mask
|= 1 << (status
& 0x03);
496 } while ((mask
!= 0x0f) && --timeout
);
499 static int sun_pci_fd_test_drive(unsigned long port
, int drive
)
501 unsigned char status
, data
;
505 sun_pci_fd_reset(port
);
507 data
= (0x10 << drive
) | 0x0c | drive
;
508 sun_pci_fd_out_byte(port
, data
, DOR
);
510 sun_pci_fd_out_byte(port
, 0x07, FIFO
);
511 sun_pci_fd_out_byte(port
, drive
& 0x03, FIFO
);
515 status
= sun_pci_fd_sensei(port
);
516 } while (((status
& 0xc0) == 0x80) && --timeout
);
521 ready
= (status
& 0x10) ? 0 : 1;
523 sun_pci_fd_reset(port
);
530 static int __init
ebus_fdthree_p(struct device_node
*dp
)
532 if (!strcmp(dp
->name
, "fdthree"))
534 if (!strcmp(dp
->name
, "floppy")) {
537 compat
= of_get_property(dp
, "compatible", NULL
);
538 if (compat
&& !strcmp(compat
, "fdthree"))
544 static unsigned long __init
sun_floppy_init(void)
546 static int initialized
= 0;
547 struct device_node
*dp
;
548 struct platform_device
*op
;
553 return sun_floppy_types
[0];
558 for_each_node_by_name(dp
, "SUNW,fdtwo") {
559 if (strcmp(dp
->parent
->name
, "sbus"))
561 op
= of_find_device_by_node(dp
);
567 FLOPPY_IRQ
= op
->archdata
.irqs
[0];
569 struct device_node
*ebus_dp
;
570 void __iomem
*auxio_reg
;
571 const char *state_prop
;
572 unsigned long config
;
575 for_each_node_by_name(ebus_dp
, "ebus") {
576 for (dp
= ebus_dp
->child
; dp
; dp
= dp
->sibling
) {
577 if (ebus_fdthree_p(dp
))
585 op
= of_find_device_by_node(dp
);
589 state_prop
= of_get_property(op
->dev
.of_node
, "status", NULL
);
590 if (state_prop
&& !strncmp(state_prop
, "disabled", 8))
593 FLOPPY_IRQ
= op
->archdata
.irqs
[0];
595 /* Make sure the high density bit is set, some systems
596 * (most notably Ultra5/Ultra10) come up with it clear.
598 auxio_reg
= (void __iomem
*) op
->resource
[2].start
;
599 writel(readl(auxio_reg
)|0x2, auxio_reg
);
601 sun_floppy_dev
= &op
->dev
;
603 spin_lock_init(&sun_pci_fd_ebus_dma
.lock
);
606 sun_pci_fd_ebus_dma
.regs
= (void __iomem
*)
607 op
->resource
[1].start
;
608 if (!sun_pci_fd_ebus_dma
.regs
)
611 sun_pci_fd_ebus_dma
.flags
= (EBUS_DMA_FLAG_USE_EBDMA_HANDLER
|
612 EBUS_DMA_FLAG_TCI_DISABLE
);
613 sun_pci_fd_ebus_dma
.callback
= sun_pci_fd_dma_callback
;
614 sun_pci_fd_ebus_dma
.client_cookie
= NULL
;
615 sun_pci_fd_ebus_dma
.irq
= FLOPPY_IRQ
;
616 strcpy(sun_pci_fd_ebus_dma
.name
, "floppy");
617 if (ebus_dma_register(&sun_pci_fd_ebus_dma
))
621 sun_fdc
= (struct sun_flpy_controller
*) op
->resource
[0].start
;
623 sun_fdops
.fd_inb
= sun_pci_fd_inb
;
624 sun_fdops
.fd_outb
= sun_pci_fd_outb
;
626 can_use_virtual_dma
= use_virtual_dma
= 0;
627 sun_fdops
.fd_enable_dma
= sun_pci_fd_enable_dma
;
628 sun_fdops
.fd_disable_dma
= sun_pci_fd_disable_dma
;
629 sun_fdops
.fd_set_dma_mode
= sun_pci_fd_set_dma_mode
;
630 sun_fdops
.fd_set_dma_addr
= sun_pci_fd_set_dma_addr
;
631 sun_fdops
.fd_set_dma_count
= sun_pci_fd_set_dma_count
;
632 sun_fdops
.get_dma_residue
= sun_pci_get_dma_residue
;
634 sun_fdops
.fd_request_irq
= sun_pci_fd_request_irq
;
635 sun_fdops
.fd_free_irq
= sun_pci_fd_free_irq
;
637 sun_fdops
.fd_eject
= sun_pci_fd_eject
;
639 fdc_status
= (unsigned long) &sun_fdc
->status_82077
;
642 * XXX: Find out on which machines this is really needed.
645 sun_pci_broken_drive
= 1;
646 sun_fdops
.fd_outb
= sun_pci_fd_broken_outb
;
649 allowed_drive_mask
= 0;
650 if (sun_pci_fd_test_drive((unsigned long)sun_fdc
, 0))
651 sun_floppy_types
[0] = 4;
652 if (sun_pci_fd_test_drive((unsigned long)sun_fdc
, 1))
653 sun_floppy_types
[1] = 4;
656 * Find NS87303 SuperIO config registers (through ecpp).
659 for (dp
= ebus_dp
->child
; dp
; dp
= dp
->sibling
) {
660 if (!strcmp(dp
->name
, "ecpp")) {
661 struct platform_device
*ecpp_op
;
663 ecpp_op
= of_find_device_by_node(dp
);
665 config
= ecpp_op
->resource
[1].start
;
672 * Sanity check, is this really the NS87303?
674 switch (config
& 0x3ff) {
685 return sun_floppy_types
[0];
687 /* Enable PC-AT mode. */
688 ns87303_modify(config
, ASC
, 0, 0xc0);
690 #ifdef PCI_FDC_SWAP_DRIVES
692 * If only Floppy 1 is present, swap drives.
694 if (!sun_floppy_types
[0] && sun_floppy_types
[1]) {
696 * Set the drive exchange bit in FCR on NS87303,
697 * make sure other bits are sane before doing so.
699 ns87303_modify(config
, FER
, FER_EDM
, 0);
700 ns87303_modify(config
, ASC
, ASC_DRV2_SEL
, 0);
701 ns87303_modify(config
, FCR
, 0, FCR_LDE
);
703 config
= sun_floppy_types
[0];
704 sun_floppy_types
[0] = sun_floppy_types
[1];
705 sun_floppy_types
[1] = config
;
707 if (sun_pci_broken_drive
!= -1) {
708 sun_pci_broken_drive
= 1 - sun_pci_broken_drive
;
709 sun_fdops
.fd_outb
= sun_pci_fd_lde_broken_outb
;
712 #endif /* PCI_FDC_SWAP_DRIVES */
714 return sun_floppy_types
[0];
716 prop
= of_get_property(op
->dev
.of_node
, "status", NULL
);
717 if (prop
&& !strncmp(state
, "disabled", 8))
721 * We cannot do of_ioremap here: it does request_region,
722 * which the generic floppy driver tries to do once again.
723 * But we must use the sdev resource values as they have
724 * had parent ranges applied.
726 sun_fdc
= (struct sun_flpy_controller
*)
727 (op
->resource
[0].start
+
728 ((op
->resource
[0].flags
& 0x1ffUL
) << 32UL));
730 /* Last minute sanity check... */
731 if (sbus_readb(&sun_fdc
->status1_82077
) == 0xff) {
732 sun_fdc
= (struct sun_flpy_controller
*)-1;
736 sun_fdops
.fd_inb
= sun_82077_fd_inb
;
737 sun_fdops
.fd_outb
= sun_82077_fd_outb
;
739 can_use_virtual_dma
= use_virtual_dma
= 1;
740 sun_fdops
.fd_enable_dma
= sun_fd_enable_dma
;
741 sun_fdops
.fd_disable_dma
= sun_fd_disable_dma
;
742 sun_fdops
.fd_set_dma_mode
= sun_fd_set_dma_mode
;
743 sun_fdops
.fd_set_dma_addr
= sun_fd_set_dma_addr
;
744 sun_fdops
.fd_set_dma_count
= sun_fd_set_dma_count
;
745 sun_fdops
.get_dma_residue
= sun_get_dma_residue
;
747 sun_fdops
.fd_request_irq
= sun_fd_request_irq
;
748 sun_fdops
.fd_free_irq
= sun_fd_free_irq
;
750 sun_fdops
.fd_eject
= sun_fd_eject
;
752 fdc_status
= (unsigned long) &sun_fdc
->status_82077
;
755 allowed_drive_mask
= 0x01;
756 sun_floppy_types
[0] = 4;
757 sun_floppy_types
[1] = 0;
759 return sun_floppy_types
[0];
762 #define EXTRA_FLOPPY_PARAMS
764 static DEFINE_SPINLOCK(dma_spin_lock
);
766 #define claim_dma_lock() \
767 ({ unsigned long flags; \
768 spin_lock_irqsave(&dma_spin_lock, flags); \
772 #define release_dma_lock(__flags) \
773 spin_unlock_irqrestore(&dma_spin_lock, __flags);
775 #endif /* !(__ASM_SPARC64_FLOPPY_H) */