Don't include linux/config.h from anywhere else in include/
[linux-2.6.git] / include / asm-ppc / floppy.h
1 /*
2  * Architecture specific parts of the Floppy driver
3  *
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License.  See the file "COPYING" in the main directory of this archive
6  * for more details.
7  *
8  * Copyright (C) 1995
9  */
10 #ifdef __KERNEL__
11 #ifndef __ASM_PPC_FLOPPY_H
12 #define __ASM_PPC_FLOPPY_H
13
14 #define fd_inb(port)            inb_p(port)
15 #define fd_outb(value,port)     outb_p(value,port)
16
17 #define fd_disable_dma()        fd_ops->_disable_dma(FLOPPY_DMA)
18 #define fd_free_dma()           fd_ops->_free_dma(FLOPPY_DMA)
19 #define fd_get_dma_residue()    fd_ops->_get_dma_residue(FLOPPY_DMA)
20 #define fd_dma_setup(addr, size, mode, io) fd_ops->_dma_setup(addr, size, mode, io)
21 #define fd_enable_irq()         enable_irq(FLOPPY_IRQ)
22 #define fd_disable_irq()        disable_irq(FLOPPY_IRQ)
23 #define fd_free_irq()           free_irq(FLOPPY_IRQ, NULL);
24
25 static int fd_request_dma(void);
26
27 struct fd_dma_ops {
28         void (*_disable_dma)(unsigned int dmanr);
29         void (*_free_dma)(unsigned int dmanr);
30         int (*_get_dma_residue)(unsigned int dummy);
31         int (*_dma_setup)(char *addr, unsigned long size, int mode, int io);
32 };
33
34 static int virtual_dma_count;
35 static int virtual_dma_residue;
36 static char *virtual_dma_addr;
37 static int virtual_dma_mode;
38 static int doing_vdma;
39 static struct fd_dma_ops *fd_ops;
40
41 static irqreturn_t floppy_hardint(int irq, void *dev_id, struct pt_regs * regs)
42 {
43         unsigned char st;
44         int lcount;
45         char *lptr;
46
47         if (!doing_vdma)
48                 return floppy_interrupt(irq, dev_id, regs);
49
50
51         st = 1;
52         for (lcount=virtual_dma_count, lptr=virtual_dma_addr;
53              lcount; lcount--, lptr++) {
54                 st=inb(virtual_dma_port+4) & 0xa0 ;
55                 if (st != 0xa0)
56                         break;
57                 if (virtual_dma_mode)
58                         outb_p(*lptr, virtual_dma_port+5);
59                 else
60                         *lptr = inb_p(virtual_dma_port+5);
61         }
62         virtual_dma_count = lcount;
63         virtual_dma_addr = lptr;
64         st = inb(virtual_dma_port+4);
65
66         if (st == 0x20)
67                 return IRQ_HANDLED;
68         if (!(st & 0x20)) {
69                 virtual_dma_residue += virtual_dma_count;
70                 virtual_dma_count=0;
71                 doing_vdma = 0;
72                 floppy_interrupt(irq, dev_id, regs);
73                 return IRQ_HANDLED;
74         }
75         return IRQ_HANDLED;
76 }
77
78 static void vdma_disable_dma(unsigned int dummy)
79 {
80         doing_vdma = 0;
81         virtual_dma_residue += virtual_dma_count;
82         virtual_dma_count=0;
83 }
84
85 static void vdma_nop(unsigned int dummy)
86 {
87 }
88
89
90 static int vdma_get_dma_residue(unsigned int dummy)
91 {
92         return virtual_dma_count + virtual_dma_residue;
93 }
94
95
96 static int fd_request_irq(void)
97 {
98         if (can_use_virtual_dma)
99                 return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
100                                                    "floppy", NULL);
101         else
102                 return request_irq(FLOPPY_IRQ, floppy_interrupt,
103                                                    SA_INTERRUPT|SA_SAMPLE_RANDOM,
104                                                    "floppy", NULL);
105
106 }
107
108 static int vdma_dma_setup(char *addr, unsigned long size, int mode, int io)
109 {
110         doing_vdma = 1;
111         virtual_dma_port = io;
112         virtual_dma_mode = (mode  == DMA_MODE_WRITE);
113         virtual_dma_addr = addr;
114         virtual_dma_count = size;
115         virtual_dma_residue = 0;
116         return 0;
117 }
118
119 static int hard_dma_setup(char *addr, unsigned long size, int mode, int io)
120 {
121         /* actual, physical DMA */
122         doing_vdma = 0;
123         clear_dma_ff(FLOPPY_DMA);
124         set_dma_mode(FLOPPY_DMA,mode);
125         set_dma_addr(FLOPPY_DMA,(unsigned int)virt_to_bus(addr));
126         set_dma_count(FLOPPY_DMA,size);
127         enable_dma(FLOPPY_DMA);
128         return 0;
129 }
130
131 static struct fd_dma_ops real_dma_ops =
132 {
133         ._disable_dma = disable_dma,
134         ._free_dma = free_dma,
135         ._get_dma_residue = get_dma_residue,
136         ._dma_setup = hard_dma_setup
137 };
138
139 static struct fd_dma_ops virt_dma_ops =
140 {
141         ._disable_dma = vdma_disable_dma,
142         ._free_dma = vdma_nop,
143         ._get_dma_residue = vdma_get_dma_residue,
144         ._dma_setup = vdma_dma_setup
145 };
146
147 static int fd_request_dma()
148 {
149         if (can_use_virtual_dma & 1) {
150                 fd_ops = &virt_dma_ops;
151                 return 0;
152         }
153         else {
154                 fd_ops = &real_dma_ops;
155                 return request_dma(FLOPPY_DMA, "floppy");
156         }
157 }
158
159 static int FDC1 = 0x3f0;
160 static int FDC2 = -1;
161
162 /*
163  * Again, the CMOS information not available
164  */
165 #define FLOPPY0_TYPE 6
166 #define FLOPPY1_TYPE 0
167
168 #define N_FDC 2                 /* Don't change this! */
169 #define N_DRIVE 8
170
171 #define FLOPPY_MOTOR_MASK 0xf0
172
173 /*
174  * The PowerPC has no problems with floppy DMA crossing 64k borders.
175  */
176 #define CROSS_64KB(a,s) (0)
177
178 #endif /* __ASM_PPC_FLOPPY_H */
179
180 #define EXTRA_FLOPPY_PARAMS
181
182 #endif /* __KERNEL__ */