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 39 #include <asm/atari_stdma.h> 40 #include <asm/atariints.h> 41 #include <asm/atarihw.h> 42 #include <asm/io.h> 43 #include <asm/irq.h> 44 45 static int stdma_locked; /* the semaphore */ 46 /* int func to be called */ 47 static irqreturn_t (*stdma_isr)(int, void *, struct pt_regs *); 48 static void *stdma_isr_data; /* data passed to isr */ 49 static DECLARE_WAIT_QUEUE_HEAD(stdma_wait); /* wait queue for ST-DMA */ 50 51 52 53 54 /***************************** Prototypes *****************************/ 55 56 static irqreturn_t stdma_int (int irq, void *dummy, struct pt_regs *fp); 57 58 /************************* End of Prototypes **************************/ 59 60 61 62 /* 63 * Function: void stdma_lock( isrfunc isr, void *data ) 64 * 65 * Purpose: Tries to get a lock on the ST-DMA chip that is used by more 66 * then one device driver. Waits on stdma_wait until lock is free. 67 * stdma_lock() may not be called from an interrupt! You have to 68 * get the lock in your main routine and release it when your 69 * request is finished. 70 * 71 * Inputs: A interrupt function that is called until the lock is 72 * released. 73 * 74 * Returns: nothing 75 * 76 */ 77 78 void stdma_lock(irqreturn_t (*handler)(int, void *, struct pt_regs *), 79 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 } 95 96 97 /* 98 * Function: void stdma_release( void ) 99 * 100 * Purpose: Releases the lock on the ST-DMA chip. 101 * 102 * Inputs: none 103 * 104 * Returns: nothing 105 * 106 */ 107 108 void stdma_release(void) 109 { 110 unsigned long flags; 111 112 local_irq_save(flags); 113 114 stdma_locked = 0; 115 stdma_isr = NULL; 116 stdma_isr_data = NULL; 117 wake_up(&stdma_wait); 118 119 local_irq_restore(flags); 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 irqreturn_t stdma_int(int irq, void *dummy, struct pt_regs *fp) 192 { 193 if (stdma_isr) 194 (*stdma_isr)(irq, stdma_isr_data, fp); 195 return IRQ_HANDLED; 196 } 197