File: /usr/src/linux/arch/m68k/atari/stdma.c
1 /*
2 * linux/arch/m68k/atari/stmda.c
3 *
4 * Copyright (C) 1994 Roman Hodek
5 *
6 *
7 * This file is subject to the terms and conditions of the GNU General Public
8 * License. See the file COPYING in the main directory of this archive
9 * for more details.
10 */
11
12
13 /* This file contains some function for controlling the access to the */
14 /* ST-DMA chip that may be shared between devices. Currently we have: */
15 /* TT: Floppy and ACSI bus */
16 /* Falcon: Floppy and SCSI */
17 /* */
18 /* The controlling functions set up a wait queue for access to the */
19 /* ST-DMA chip. Callers to stdma_lock() that cannot granted access are */
20 /* put onto a queue and waked up later if the owner calls */
21 /* stdma_release(). Additionally, the caller gives his interrupt */
22 /* service routine to stdma_lock(). */
23 /* */
24 /* On the Falcon, the IDE bus uses just the ACSI/Floppy interrupt, but */
25 /* not the ST-DMA chip itself. So falhd.c needs not to lock the */
26 /* chip. The interrupt is routed to falhd.c if IDE is configured, the */
27 /* model is a Falcon and the interrupt was caused by the HD controller */
28 /* (can be determined by looking at its status register). */
29
30
31 #include <linux/types.h>
32 #include <linux/kdev_t.h>
33 #include <linux/genhd.h>
34 #include <linux/sched.h>
35 #include <linux/init.h>
36
37 #include <asm/atari_stdma.h>
38 #include <asm/atariints.h>
39 #include <asm/atarihw.h>
40 #include <asm/io.h>
41 #include <asm/irq.h>
42
43 static int stdma_locked = 0; /* the semaphore */
44 /* int func to be called */
45 static void (*stdma_isr)(int, void *, struct pt_regs *) = NULL;
46 static void *stdma_isr_data = NULL; /* data passed to isr */
47 static DECLARE_WAIT_QUEUE_HEAD(stdma_wait); /* wait queue for ST-DMA */
48
49
50
51
52 /***************************** Prototypes *****************************/
53
54 static void stdma_int (int irq, void *dummy, struct pt_regs *fp);
55
56 /************************* End of Prototypes **************************/
57
58
59
60 /*
61 * Function: void stdma_lock( isrfunc isr, void *data )
62 *
63 * Purpose: Tries to get a lock on the ST-DMA chip that is used by more
64 * then one device driver. Waits on stdma_wait until lock is free.
65 * stdma_lock() may not be called from an interrupt! You have to
66 * get the lock in your main routine and release it when your
67 * request is finished.
68 *
69 * Inputs: A interrupt function that is called until the lock is
70 * released.
71 *
72 * Returns: nothing
73 *
74 */
75
76 void stdma_lock(void (*handler)(int, void *, struct pt_regs *), void *data)
77 {
78 unsigned long oldflags;
79
80 save_flags(oldflags);
81 cli(); /* protect lock */
82
83 while(stdma_locked)
84 /* Since the DMA is used for file system purposes, we
85 have to sleep uninterruptible (there may be locked
86 buffers) */
87 sleep_on(&stdma_wait);
88
89 stdma_locked = 1;
90 stdma_isr = handler;
91 stdma_isr_data = data;
92 restore_flags(oldflags);
93 }
94
95
96 /*
97 * Function: void stdma_release( void )
98 *
99 * Purpose: Releases the lock on the ST-DMA chip.
100 *
101 * Inputs: none
102 *
103 * Returns: nothing
104 *
105 */
106
107 void stdma_release(void)
108 {
109 unsigned long oldflags;
110
111 save_flags(oldflags);
112 cli();
113
114 stdma_locked = 0;
115 stdma_isr = NULL;
116 stdma_isr_data = NULL;
117 wake_up(&stdma_wait);
118
119 restore_flags(oldflags);
120 }
121
122
123 /*
124 * Function: int stdma_others_waiting( void )
125 *
126 * Purpose: Check if someone waits for the ST-DMA lock.
127 *
128 * Inputs: none
129 *
130 * Returns: 0 if no one is waiting, != 0 otherwise
131 *
132 */
133
134 int stdma_others_waiting(void)
135 {
136 return waitqueue_active(&stdma_wait);
137 }
138
139
140 /*
141 * Function: int stdma_islocked( void )
142 *
143 * Purpose: Check if the ST-DMA is currently locked.
144 * Note: Returned status is only valid if ints are disabled while calling and
145 * as long as they remain disabled.
146 * If called with ints enabled, status can change only from locked to
147 * unlocked, because ints may not lock the ST-DMA.
148 *
149 * Inputs: none
150 *
151 * Returns: != 0 if locked, 0 otherwise
152 *
153 */
154
155 int stdma_islocked(void)
156 {
157 return stdma_locked;
158 }
159
160
161 /*
162 * Function: void stdma_init( void )
163 *
164 * Purpose: Initialize the ST-DMA chip access controlling.
165 * It sets up the interrupt and its service routine. The int is registered
166 * as slow int, client devices have to live with that (no problem
167 * currently).
168 *
169 * Inputs: none
170 *
171 * Return: nothing
172 *
173 */
174
175 void __init stdma_init(void)
176 {
177 stdma_isr = NULL;
178 request_irq(IRQ_MFP_FDC, stdma_int, IRQ_TYPE_SLOW,
179 "ST-DMA: floppy/ACSI/IDE/Falcon-SCSI", stdma_int);
180 }
181
182
183 /*
184 * Function: void stdma_int()
185 *
186 * Purpose: The interrupt routine for the ST-DMA. It calls the isr
187 * registered by stdma_lock().
188 *
189 */
190
191 static void stdma_int(int irq, void *dummy, struct pt_regs *fp)
192 {
193 if (stdma_isr)
194 (*stdma_isr)(irq, stdma_isr_data, fp);
195 }
196