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#include <linux/interrupt.h>
37#include <linux/wait.h>
38#include <linux/module.h>
39
40#include <asm/atari_stdma.h>
41#include <asm/atariints.h>
42#include <asm/atarihw.h>
43#include <asm/io.h>
44#include <asm/irq.h>
45
46static int stdma_locked;			/* the semaphore */
47						/* int func to be called */
48static irq_handler_t stdma_isr;
49static void *stdma_isr_data;			/* data passed to isr */
50static DECLARE_WAIT_QUEUE_HEAD(stdma_wait);	/* wait queue for ST-DMA */
51
52
53
54
55/***************************** Prototypes *****************************/
56
57static irqreturn_t stdma_int (int irq, void *dummy);
58
59/************************* End of Prototypes **************************/
60
61
62
63/*
64 * Function: void stdma_lock( isrfunc isr, void *data )
65 *
66 * Purpose: Tries to get a lock on the ST-DMA chip that is used by more
67 *   then one device driver. Waits on stdma_wait until lock is free.
68 *   stdma_lock() may not be called from an interrupt! You have to
69 *   get the lock in your main routine and release it when your
70 *   request is finished.
71 *
72 * Inputs: A interrupt function that is called until the lock is
73 *   released.
74 *
75 * Returns: nothing
76 *
77 */
78
79void stdma_lock(irq_handler_t handler, void *data)
80{
81	unsigned long flags;
82
83	local_irq_save(flags);		/* protect lock */
84
85	/* Since the DMA is used for file system purposes, we
86	 have to sleep uninterruptible (there may be locked
87	 buffers) */
88	wait_event(stdma_wait, !stdma_locked);
89
90	stdma_locked   = 1;
91	stdma_isr      = handler;
92	stdma_isr_data = data;
93	local_irq_restore(flags);
94}
95EXPORT_SYMBOL(stdma_lock);
96
97
98/*
99 * Function: void stdma_release( void )
100 *
101 * Purpose: Releases the lock on the ST-DMA chip.
102 *
103 * Inputs: none
104 *
105 * Returns: nothing
106 *
107 */
108
109void stdma_release(void)
110{
111	unsigned long flags;
112
113	local_irq_save(flags);
114
115	stdma_locked   = 0;
116	stdma_isr      = NULL;
117	stdma_isr_data = NULL;
118	wake_up(&stdma_wait);
119
120	local_irq_restore(flags);
121}
122EXPORT_SYMBOL(stdma_release);
123
124
125/*
126 * Function: int stdma_others_waiting( void )
127 *
128 * Purpose: Check if someone waits for the ST-DMA lock.
129 *
130 * Inputs: none
131 *
132 * Returns: 0 if no one is waiting, != 0 otherwise
133 *
134 */
135
136int stdma_others_waiting(void)
137{
138	return waitqueue_active(&stdma_wait);
139}
140EXPORT_SYMBOL(stdma_others_waiting);
141
142
143/*
144 * Function: int stdma_islocked( void )
145 *
146 * Purpose: Check if the ST-DMA is currently locked.
147 * Note: Returned status is only valid if ints are disabled while calling and
148 *       as long as they remain disabled.
149 *       If called with ints enabled, status can change only from locked to
150 *       unlocked, because ints may not lock the ST-DMA.
151 *
152 * Inputs: none
153 *
154 * Returns: != 0 if locked, 0 otherwise
155 *
156 */
157
158int stdma_islocked(void)
159{
160	return stdma_locked;
161}
162EXPORT_SYMBOL(stdma_islocked);
163
164
165/*
166 * Function: void stdma_init( void )
167 *
168 * Purpose: Initialize the ST-DMA chip access controlling.
169 *   It sets up the interrupt and its service routine. The int is registered
170 *   as slow int, client devices have to live with that (no problem
171 *   currently).
172 *
173 * Inputs: none
174 *
175 * Return: nothing
176 *
177 */
178
179void __init stdma_init(void)
180{
181	stdma_isr = NULL;
182	if (request_irq(IRQ_MFP_FDC, stdma_int, IRQ_TYPE_SLOW | IRQF_SHARED,
183			"ST-DMA floppy,ACSI,IDE,Falcon-SCSI", stdma_int))
184		pr_err("Couldn't register ST-DMA interrupt\n");
185}
186
187
188/*
189 * Function: void stdma_int()
190 *
191 * Purpose: The interrupt routine for the ST-DMA. It calls the isr
192 *   registered by stdma_lock().
193 *
194 */
195
196static irqreturn_t stdma_int(int irq, void *dummy)
197{
198  if (stdma_isr)
199      (*stdma_isr)(irq, stdma_isr_data);
200  return IRQ_HANDLED;
201}
202