URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [include/] [asm-m68k/] [floppy.h] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * Implementation independent bits of the Floppy driver.
 *
 * much of this file is derived from what was originally the Q40 floppy driver.
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1999, 2000, 2001
 *
 * Sun3x support added 2/4/2000 Sam Creasey (sammy@sammy.net)
 *
 */
 
#include <asm/io.h>
 
#include <linux/vmalloc.h>
 
asmlinkage void floppy_hardint(int irq, void *dev_id, struct pt_regs * regs);
 
/* constants... */
 
#undef MAX_DMA_ADDRESS
#define MAX_DMA_ADDRESS   0x00  /* nothing like that */
 
 
/*
 * Again, the CMOS information doesn't work on m68k..
 */
#define FLOPPY0_TYPE (MACH_IS_Q40 ? 6 : 4)
#define FLOPPY1_TYPE 0
 
#define FLOPPY_MOTOR_MASK 0xf0
 
 
/* basically PC init + set use_virtual_dma */
#define  FDC1 m68k_floppy_init()
 
#define N_FDC 1
#define N_DRIVE 8
 
 
/* vdma globals adapted from asm-i386/floppy.h */
 
static int virtual_dma_count=0;
static int virtual_dma_residue=0;
static char *virtual_dma_addr=0;
static int virtual_dma_mode=0;
static int doing_pdma=0;
 
#include <asm/sun3xflop.h>
 
extern spinlock_t  dma_spin_lock;
 
static __inline__ unsigned long claim_dma_lock(void)
{
        unsigned long flags;
        spin_lock_irqsave(&dma_spin_lock, flags);
        return flags;
}
 
static __inline__ void release_dma_lock(unsigned long flags)
{
        spin_unlock_irqrestore(&dma_spin_lock, flags);
}
 
 
static __inline__ unsigned char fd_inb(int port)
{
        if(MACH_IS_Q40)
                return inb_p(port);
        else if(MACH_IS_SUN3X)
                return sun3x_82072_fd_inb(port);
        return 0;
}
 
static __inline__ void fd_outb(unsigned char value, int port)
{
        if(MACH_IS_Q40)
                outb_p(value, port);
        else if(MACH_IS_SUN3X)
                sun3x_82072_fd_outb(value, port);
}
 
 
static int fd_request_irq(void)
{
        if(MACH_IS_Q40)
                return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
                                                   "floppy", floppy_hardint);
        else if(MACH_IS_SUN3X)
                return sun3xflop_request_irq();
        return -ENXIO;
}
 
static void fd_free_irq(void)
{
        if(MACH_IS_Q40)
                free_irq(FLOPPY_IRQ, floppy_hardint);
}
 
#define fd_request_dma()        vdma_request_dma(FLOPPY_DMA,"floppy")
#define fd_get_dma_residue()    vdma_get_dma_residue(FLOPPY_DMA)
#define fd_dma_mem_alloc(size)  vdma_mem_alloc(size)
#define fd_dma_setup(addr, size, mode, io) vdma_dma_setup(addr, size, mode, io)
 
#define fd_enable_irq()           /* nothing... */
#define fd_disable_irq()          /* nothing... */
 
#define fd_free_dma()             /* nothing */
 
/* No 64k boundary crossing problems on Q40 - no DMA at all */
#define CROSS_64KB(a,s) (0)
 
#define DMA_MODE_READ  0x44    /* i386 look-alike */
#define DMA_MODE_WRITE 0x48
 
 
static int m68k_floppy_init(void)
{
  use_virtual_dma =1;
  can_use_virtual_dma = 1;
 
 
  if (MACH_IS_Q40)
          return 0x3f0;
  else if(MACH_IS_SUN3X)
          return sun3xflop_init();
  else
    return -1;
}
 
 
static int vdma_request_dma(unsigned int dmanr, const char * device_id)
{
        return 0;
}
 
 
static int vdma_get_dma_residue(unsigned int dummy)
{
        return virtual_dma_count + virtual_dma_residue;
}
 
 
static unsigned long vdma_mem_alloc(unsigned long size)
{
        return (unsigned long) vmalloc(size);
 
}
 
static void _fd_dma_mem_free(unsigned long addr, unsigned long size)
{
        vfree((void *)addr);
}
#define fd_dma_mem_free(addr,size) _fd_dma_mem_free(addr, size)
 
 
/* choose_dma_mode ???*/
 
static int vdma_dma_setup(char *addr, unsigned long size, int mode, int io)
{
        doing_pdma = 1;
        virtual_dma_port = (MACH_IS_Q40 ? io : 0);
        virtual_dma_mode = (mode  == DMA_MODE_WRITE);
        virtual_dma_addr = addr;
        virtual_dma_count = size;
        virtual_dma_residue = 0;
        return 0;
}
 
 
 
static void fd_disable_dma(void)
{
        doing_pdma = 0;
        virtual_dma_residue += virtual_dma_count;
        virtual_dma_count=0;
}
 
 
 
/* this is the only truly Q40 specific function */
 
asmlinkage void floppy_hardint(int irq, void *dev_id, struct pt_regs * regs)
{
        register unsigned char st;
 
#undef TRACE_FLPY_INT
#define NO_FLOPPY_ASSEMBLER
 
#ifdef TRACE_FLPY_INT 
        static int calls=0;
        static int bytes=0;
        static int dma_wait=0;
#endif
        if(!doing_pdma) {
                floppy_interrupt(irq, dev_id, regs);
                return;
        }
 
#ifdef TRACE_FLPY_INT
        if(!calls)
                bytes = virtual_dma_count;
#endif
 
        {
                register int lcount;
                register char *lptr;
 
                /* serve 1st byte fast: */
 
                st=1;
                for(lcount=virtual_dma_count, lptr=virtual_dma_addr;
                    lcount; lcount--, lptr++) {
                        st=inb(virtual_dma_port+4) & 0xa0 ;
                        if(st != 0xa0)
                                break;
                        if(virtual_dma_mode)
                                outb_p(*lptr, virtual_dma_port+5);
                        else
                                *lptr = inb_p(virtual_dma_port+5);
                }
 
                virtual_dma_count = lcount;
                virtual_dma_addr = lptr;
                st = inb(virtual_dma_port+4);
        }
 
#ifdef TRACE_FLPY_INT
        calls++;
#endif
        if(st == 0x20)
                return;
        if(!(st & 0x20)) {
                virtual_dma_residue += virtual_dma_count;
                virtual_dma_count=0;
#ifdef TRACE_FLPY_INT
                printk("count=%x, residue=%x calls=%d bytes=%d dma_wait=%d\n",
                       virtual_dma_count, virtual_dma_residue, calls, bytes,
                       dma_wait);
                calls = 0;
                dma_wait=0;
#endif
                doing_pdma = 0;
                floppy_interrupt(irq, dev_id, regs);
                return;
        }
#ifdef TRACE_FLPY_INT
        if(!virtual_dma_count)
                dma_wait++;
#endif
}
 
#define EXTRA_FLOPPY_PARAMS

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [include/] [asm-m68k/] [floppy.h] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1276	phoenix	`/*`
2			`* Implementation independent bits of the Floppy driver.`
3			`*`
4			`* much of this file is derived from what was originally the Q40 floppy driver.`
5			`*`
6			`* This file is subject to the terms and conditions of the GNU General Public`
7			`* License. See the file "COPYING" in the main directory of this archive`
8			`* for more details.`
9			`*`
10			`* Copyright (C) 1999, 2000, 2001`
11			`*`
12			`* Sun3x support added 2/4/2000 Sam Creasey (sammy@sammy.net)`
13			`*`
14			`*/`
15
16			`#include <asm/io.h>`
17
18			`#include <linux/vmalloc.h>`
19
20			`asmlinkage void floppy_hardint(int irq, void dev_id, struct pt_regs regs);`
21
22			`/* constants... */`
23
24			`#undef MAX_DMA_ADDRESS`
25			`#define MAX_DMA_ADDRESS 0x00 /* nothing like that */`
26
27
28			`/*`
29			`* Again, the CMOS information doesn't work on m68k..`
30			`*/`
31			`#define FLOPPY0_TYPE (MACH_IS_Q40 ? 6 : 4)`
32			`#define FLOPPY1_TYPE 0`
33
34			`#define FLOPPY_MOTOR_MASK 0xf0`
35
36
37			`/* basically PC init + set use_virtual_dma */`
38			`#define FDC1 m68k_floppy_init()`
39
40			`#define N_FDC 1`
41			`#define N_DRIVE 8`
42
43
44			`/* vdma globals adapted from asm-i386/floppy.h */`
45
46			`static int virtual_dma_count=0;`
47			`static int virtual_dma_residue=0;`
48			`static char *virtual_dma_addr=0;`
49			`static int virtual_dma_mode=0;`
50			`static int doing_pdma=0;`
51
52			`#include <asm/sun3xflop.h>`
53
54			`extern spinlock_t dma_spin_lock;`
55
56			`static __inline__ unsigned long claim_dma_lock(void)`
57			`{`
58			`unsigned long flags;`
59			`spin_lock_irqsave(&dma_spin_lock, flags);`
60			`return flags;`
61			`}`
62
63			`static __inline__ void release_dma_lock(unsigned long flags)`
64			`{`
65			`spin_unlock_irqrestore(&dma_spin_lock, flags);`
66			`}`
67
68
69			`static __inline__ unsigned char fd_inb(int port)`
70			`{`
71			`if(MACH_IS_Q40)`
72			`return inb_p(port);`
73			`else if(MACH_IS_SUN3X)`
74			`return sun3x_82072_fd_inb(port);`
75			`return 0;`
76			`}`
77
78			`static __inline__ void fd_outb(unsigned char value, int port)`
79			`{`
80			`if(MACH_IS_Q40)`
81			`outb_p(value, port);`
82			`else if(MACH_IS_SUN3X)`
83			`sun3x_82072_fd_outb(value, port);`
84			`}`
85
86
87			`static int fd_request_irq(void)`
88			`{`
89			`if(MACH_IS_Q40)`
90			`return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,`
91			`"floppy", floppy_hardint);`
92			`else if(MACH_IS_SUN3X)`
93			`return sun3xflop_request_irq();`
94			`return -ENXIO;`
95			`}`
96
97			`static void fd_free_irq(void)`
98			`{`
99			`if(MACH_IS_Q40)`
100			`free_irq(FLOPPY_IRQ, floppy_hardint);`
101			`}`
102
103			`#define fd_request_dma() vdma_request_dma(FLOPPY_DMA,"floppy")`
104			`#define fd_get_dma_residue() vdma_get_dma_residue(FLOPPY_DMA)`
105			`#define fd_dma_mem_alloc(size) vdma_mem_alloc(size)`
106			`#define fd_dma_setup(addr, size, mode, io) vdma_dma_setup(addr, size, mode, io)`
107
108			`#define fd_enable_irq() /* nothing... */`
109			`#define fd_disable_irq() /* nothing... */`
110
111			`#define fd_free_dma() /* nothing */`
112
113			`/* No 64k boundary crossing problems on Q40 - no DMA at all */`
114			`#define CROSS_64KB(a,s) (0)`
115
116			`#define DMA_MODE_READ 0x44 /* i386 look-alike */`
117			`#define DMA_MODE_WRITE 0x48`
118
119
120			`static int m68k_floppy_init(void)`
121			`{`
122			`use_virtual_dma =1;`
123			`can_use_virtual_dma = 1;`
124
125
126			`if (MACH_IS_Q40)`
127			`return 0x3f0;`
128			`else if(MACH_IS_SUN3X)`
129			`return sun3xflop_init();`
130			`else`
131			`return -1;`
132			`}`
133
134
135			`static int vdma_request_dma(unsigned int dmanr, const char * device_id)`
136			`{`
137			`return 0;`
138			`}`
139
140
141			`static int vdma_get_dma_residue(unsigned int dummy)`
142			`{`
143			`return virtual_dma_count + virtual_dma_residue;`
144			`}`
145
146
147			`static unsigned long vdma_mem_alloc(unsigned long size)`
148			`{`
149			`return (unsigned long) vmalloc(size);`
150
151			`}`
152
153			`static void _fd_dma_mem_free(unsigned long addr, unsigned long size)`
154			`{`
155			`vfree((void *)addr);`
156			`}`
157			`#define fd_dma_mem_free(addr,size) _fd_dma_mem_free(addr, size)`
158
159
160			`/* choose_dma_mode ???*/`
161
162			`static int vdma_dma_setup(char *addr, unsigned long size, int mode, int io)`
163			`{`
164			`doing_pdma = 1;`
165			`virtual_dma_port = (MACH_IS_Q40 ? io : 0);`
166			`virtual_dma_mode = (mode == DMA_MODE_WRITE);`
167			`virtual_dma_addr = addr;`
168			`virtual_dma_count = size;`
169			`virtual_dma_residue = 0;`
170			`return 0;`
171			`}`
172
173
174
175			`static void fd_disable_dma(void)`
176			`{`
177			`doing_pdma = 0;`
178			`virtual_dma_residue += virtual_dma_count;`
179			`virtual_dma_count=0;`
180			`}`
181
182
183
184			`/* this is the only truly Q40 specific function */`
185
186			`asmlinkage void floppy_hardint(int irq, void dev_id, struct pt_regs regs)`
187			`{`
188			`register unsigned char st;`
189
190			`#undef TRACE_FLPY_INT`
191			`#define NO_FLOPPY_ASSEMBLER`
192
193			`#ifdef TRACE_FLPY_INT`
194			`static int calls=0;`
195			`static int bytes=0;`
196			`static int dma_wait=0;`
197			`#endif`
198			`if(!doing_pdma) {`
199			`floppy_interrupt(irq, dev_id, regs);`
200			`return;`
201			`}`
202
203			`#ifdef TRACE_FLPY_INT`
204			`if(!calls)`
205			`bytes = virtual_dma_count;`
206			`#endif`
207
208			`{`
209			`register int lcount;`
210			`register char *lptr;`
211
212			`/* serve 1st byte fast: */`
213
214			`st=1;`
215			`for(lcount=virtual_dma_count, lptr=virtual_dma_addr;`
216			`lcount; lcount--, lptr++) {`
217			`st=inb(virtual_dma_port+4) & 0xa0 ;`
218			`if(st != 0xa0)`
219			`break;`
220			`if(virtual_dma_mode)`
221			`outb_p(*lptr, virtual_dma_port+5);`
222			`else`
223			`*lptr = inb_p(virtual_dma_port+5);`
224			`}`
225
226			`virtual_dma_count = lcount;`
227			`virtual_dma_addr = lptr;`
228			`st = inb(virtual_dma_port+4);`
229			`}`
230
231			`#ifdef TRACE_FLPY_INT`
232			`calls++;`
233			`#endif`
234			`if(st == 0x20)`
235			`return;`
236			`if(!(st & 0x20)) {`
237			`virtual_dma_residue += virtual_dma_count;`
238			`virtual_dma_count=0;`
239			`#ifdef TRACE_FLPY_INT`
240			`printk("count=%x, residue=%x calls=%d bytes=%d dma_wait=%d\n",`
241			`virtual_dma_count, virtual_dma_residue, calls, bytes,`
242			`dma_wait);`
243			`calls = 0;`
244			`dma_wait=0;`
245			`#endif`
246			`doing_pdma = 0;`
247			`floppy_interrupt(irq, dev_id, regs);`
248			`return;`
249			`}`
250			`#ifdef TRACE_FLPY_INT`
251			`if(!virtual_dma_count)`
252			`dma_wait++;`
253			`#endif`
254			`}`
255
256			`#define EXTRA_FLOPPY_PARAMS`