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