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

Subversion Repositories or1k

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1276 phoenix 
/* sun3xflop.h: Sun3/80 specific parts of the floppy driver.
2 
 *
3 
 * Derived partially from asm-sparc/floppy.h, which is:
4 
 *     Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
5 
 *
6 
 * Sun3x version 2/4/2000 Sam Creasey (sammy@sammy.net)
7 
 */
8 
 
9 
#ifndef __ASM_SUN3X_FLOPPY_H
10 
#define __ASM_SUN3X_FLOPPY_H
11 
 
12 
#include <asm/page.h>
13 
#include <asm/pgtable.h>
14 
#include <asm/system.h>
15 
#include <asm/irq.h>
16 
#include <asm/sun3x.h>
17 
 
18 
/* default interrupt vector */
19 
#define SUN3X_FDC_IRQ 0x40
20 
 
21 
/* some constants */
22 
#define FCR_TC 0x1
23 
#define FCR_EJECT 0x2
24 
#define FCR_MTRON 0x4
25 
#define FCR_DSEL1 0x8
26 
#define FCR_DSEL0 0x10
27 
 
28 
/* We don't need no stinkin' I/O port allocation crap. */
29 
#undef release_region
30 
#undef check_region
31 
#undef request_region
32 
#define release_region(X, Y)    do { } while(0)
33 
#define check_region(X, Y)      (0)
34 
#define request_region(X, Y, Z) (1)
35 
 
36 
struct sun3xflop_private {
37 
        volatile unsigned char *status_r;
38 
        volatile unsigned char *data_r;
39 
        volatile unsigned char *fcr_r;
40 
        volatile unsigned char *fvr_r;
41 
        unsigned char fcr;
42 
} sun3x_fdc;
43 
 
44 
/* Super paranoid... */
45 
#undef HAVE_DISABLE_HLT
46 
 
47 
/* Routines unique to each controller type on a Sun. */
48 
static unsigned char sun3x_82072_fd_inb(int port)
49 
{
50 
        static int once = 0;
51 
//      udelay(5);
52 
        switch(port & 7) {
53 
        default:
54 
                printk("floppy: Asked to read unknown port %d\n", port);
55 
                panic("floppy: Port bolixed.");
56 
        case 4: /* FD_STATUS */
57 
                return (*sun3x_fdc.status_r) & ~STATUS_DMA;
58 
        case 5: /* FD_DATA */
59 
                return (*sun3x_fdc.data_r);
60 
        case 7: /* FD_DIR */
61 
                /* ugly hack, I can't find a way to actually detect the disk */
62 
                if(!once) {
63 
                        once = 1;
64 
                        return 0x80;
65 
                }
66 
                return 0;
67 
        };
68 
        panic("sun_82072_fd_inb: How did I get here?");
69 
}
70 
 
71 
static void sun3x_82072_fd_outb(unsigned char value, int port)
72 
{
73 
//      udelay(5);
74 
        switch(port & 7) {
75 
        default:
76 
                printk("floppy: Asked to write to unknown port %d\n", port);
77 
                panic("floppy: Port bolixed.");
78 
        case 2: /* FD_DOR */
79 
                /* Oh geese, 82072 on the Sun has no DOR register,
80 
                 * so we make do with taunting the FCR.
81 
                 *
82 
                 * ASSUMPTIONS:  There will only ever be one floppy
83 
                 *               drive attached to a Sun controller
84 
                 *               and it will be at drive zero.
85 
                 */
86 
 
87 
        {
88 
                unsigned char fcr = sun3x_fdc.fcr;
89 
 
90 
                if(value & 0x10) {
91 
                        fcr |= (FCR_DSEL0 | FCR_MTRON);
92 
                } else
93 
                        fcr &= ~(FCR_DSEL0 | FCR_MTRON);
94 
 
95 
 
96 
                if(fcr != sun3x_fdc.fcr) {
97 
                        *(sun3x_fdc.fcr_r) = fcr;
98 
                        sun3x_fdc.fcr = fcr;
99 
                }
100 
        }
101 
                break;
102 
        case 5: /* FD_DATA */
103 
                *(sun3x_fdc.data_r) = value;
104 
                break;
105 
        case 7: /* FD_DCR */
106 
                *(sun3x_fdc.status_r) = value;
107 
                break;
108 
        case 4: /* FD_STATUS */
109 
                *(sun3x_fdc.status_r) = value;
110 
                break;
111 
        };
112 
        return;
113 
}
114 
 
115 
 
116 
asmlinkage void sun3xflop_hardint(int irq, void *dev_id, struct pt_regs * regs)
117 
{
118 
        register unsigned char st;
119 
 
120 
#undef TRACE_FLPY_INT
121 
#define NO_FLOPPY_ASSEMBLER
122 
 
123 
#ifdef TRACE_FLPY_INT
124 
        static int calls=0;
125 
        static int bytes=0;
126 
        static int dma_wait=0;
127 
#endif
128 
        if(!doing_pdma) {
129 
                floppy_interrupt(irq, dev_id, regs);
130 
                return;
131 
        }
132 
 
133 
//      printk("doing pdma\n");// st %x\n", sun_fdc->status_82072);
134 
 
135 
#ifdef TRACE_FLPY_INT
136 
        if(!calls)
137 
                bytes = virtual_dma_count;
138 
#endif
139 
 
140 
        {
141 
                register int lcount;
142 
                register char *lptr;
143 
 
144 
                for(lcount=virtual_dma_count, lptr=virtual_dma_addr;
145 
                    lcount; lcount--, lptr++) {
146 
/*                      st=fd_inb(virtual_dma_port+4) & 0x80 ;  */
147 
                        st = *(sun3x_fdc.status_r);
148 
/*                      if(st != 0xa0)                  */
149 
/*                              break;                  */
150 
 
151 
                        if((st & 0x80) == 0) {
152 
                                virtual_dma_count = lcount;
153 
                                virtual_dma_addr = lptr;
154 
                                return;
155 
                        }
156 
 
157 
                        if((st & 0x20) == 0)
158 
                                break;
159 
 
160 
                        if(virtual_dma_mode)
161 
/*                              fd_outb(*lptr, virtual_dma_port+5); */
162 
                                *(sun3x_fdc.data_r) = *lptr;
163 
                        else
164 
/*                              *lptr = fd_inb(virtual_dma_port+5); */
165 
                                *lptr = *(sun3x_fdc.data_r);
166 
                }
167 
 
168 
                virtual_dma_count = lcount;
169 
                virtual_dma_addr = lptr;
170 
/*              st = fd_inb(virtual_dma_port+4);   */
171 
                st = *(sun3x_fdc.status_r);
172 
        }
173 
 
174 
#ifdef TRACE_FLPY_INT
175 
        calls++;
176 
#endif
177 
//      printk("st=%02x\n", st);
178 
        if(st == 0x20)
179 
                return;
180 
        if(!(st & 0x20)) {
181 
                virtual_dma_residue += virtual_dma_count;
182 
                virtual_dma_count=0;
183 
                doing_pdma = 0;
184 
 
185 
#ifdef TRACE_FLPY_INT
186 
                printk("count=%x, residue=%x calls=%d bytes=%x dma_wait=%d\n",
187 
                       virtual_dma_count, virtual_dma_residue, calls, bytes,
188 
                       dma_wait);
189 
                calls = 0;
190 
                dma_wait=0;
191 
#endif
192 
 
193 
                floppy_interrupt(irq, dev_id, regs);
194 
                return;
195 
        }
196 
 
197 
 
198 
#ifdef TRACE_FLPY_INT
199 
        if(!virtual_dma_count)
200 
                dma_wait++;
201 
#endif
202 
}
203 
 
204 
static int sun3xflop_request_irq(void)
205 
{
206 
        static int once = 0;
207 
        int error;
208 
 
209 
        if(!once) {
210 
                once = 1;
211 
                error = request_irq(FLOPPY_IRQ, sun3xflop_hardint, SA_INTERRUPT, "floppy", 0);
212 
                return ((error == 0) ? 0 : -1);
213 
        } else return 0;
214 
}
215 
 
216 
static void __init floppy_set_flags(int *ints,int param, int param2);
217 
 
218 
static int sun3xflop_init(void)
219 
{
220 
        if(FLOPPY_IRQ < 0x40)
221 
                FLOPPY_IRQ = SUN3X_FDC_IRQ;
222 
 
223 
        sun3x_fdc.status_r = (volatile unsigned char *)SUN3X_FDC;
224 
        sun3x_fdc.data_r  = (volatile unsigned char *)(SUN3X_FDC+1);
225 
        sun3x_fdc.fcr_r = (volatile unsigned char *)SUN3X_FDC_FCR;
226 
        sun3x_fdc.fvr_r = (volatile unsigned char *)SUN3X_FDC_FVR;
227 
        sun3x_fdc.fcr = 0;
228 
 
229 
        /* Last minute sanity check... */
230 
        if(*sun3x_fdc.status_r == 0xff) {
231 
                return -1;
232 
        }
233 
 
234 
        *sun3x_fdc.fvr_r = FLOPPY_IRQ;
235 
 
236 
        *sun3x_fdc.fcr_r = FCR_TC;
237 
        udelay(10);
238 
        *sun3x_fdc.fcr_r = 0;
239 
 
240 
        /* Success... */
241 
        floppy_set_flags(0, 1, FD_BROKEN_DCL); // I don't know how to detect this.
242 
        allowed_drive_mask = 0x01;
243 
        return (int) SUN3X_FDC;
244 
}
245 
 
246 
/* I'm not precisely sure this eject routine works */
247 
static int sun3x_eject(void)
248 
{
249 
        if(MACH_IS_SUN3X) {
250 
 
251 
                sun3x_fdc.fcr |= (FCR_DSEL0 | FCR_EJECT);
252 
                *(sun3x_fdc.fcr_r) = sun3x_fdc.fcr;
253 
                udelay(10);
254 
                sun3x_fdc.fcr &= ~(FCR_DSEL0 | FCR_EJECT);
255 
                *(sun3x_fdc.fcr_r) = sun3x_fdc.fcr;
256 
        }
257 
 
258 
        return 0;
259 
}
260 
 
261 
#define fd_eject(drive) sun3x_eject()
262 
 
263 
#endif /* !(__ASM_SUN3X_FLOPPY_H) */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.