Release 4.14 arch/m68k/atari/stdma.c
/*
* linux/arch/m68k/atari/stmda.c
*
* Copyright (C) 1994 Roman Hodek
*
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of this archive
* for more details.
*/
/* This file contains some function for controlling the access to the */
/* ST-DMA chip that may be shared between devices. Currently we have: */
/* TT: Floppy and ACSI bus */
/* Falcon: Floppy and SCSI */
/* */
/* The controlling functions set up a wait queue for access to the */
/* ST-DMA chip. Callers to stdma_lock() that cannot granted access are */
/* put onto a queue and waked up later if the owner calls */
/* stdma_release(). Additionally, the caller gives his interrupt */
/* service routine to stdma_lock(). */
/* */
/* On the Falcon, the IDE bus uses just the ACSI/Floppy interrupt, but */
/* not the ST-DMA chip itself. So falhd.c needs not to lock the */
/* chip. The interrupt is routed to falhd.c if IDE is configured, the */
/* model is a Falcon and the interrupt was caused by the HD controller */
/* (can be determined by looking at its status register). */
#include <linux/types.h>
#include <linux/kdev_t.h>
#include <linux/genhd.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/module.h>
#include <asm/atari_stdma.h>
#include <asm/atariints.h>
#include <asm/atarihw.h>
#include <asm/io.h>
#include <asm/irq.h>
static int stdma_locked;
/* the semaphore */
/* int func to be called */
static irq_handler_t stdma_isr;
static void *stdma_isr_data;
/* data passed to isr */
static DECLARE_WAIT_QUEUE_HEAD(stdma_wait); /* wait queue for ST-DMA */
/***************************** Prototypes *****************************/
static irqreturn_t stdma_int (int irq, void *dummy);
/************************* End of Prototypes **************************/
/**
* stdma_try_lock - attempt to acquire ST DMA interrupt "lock"
* @handler: interrupt handler to use after acquisition
*
* Returns !0 if lock was acquired; otherwise 0.
*/
int stdma_try_lock(irq_handler_t handler, void *data)
{
unsigned long flags;
local_irq_save(flags);
if (stdma_locked) {
local_irq_restore(flags);
return 0;
}
stdma_locked = 1;
stdma_isr = handler;
stdma_isr_data = data;
local_irq_restore(flags);
return 1;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 31 | 56.36% | 2 | 33.33% |
| Finn Thain | 17 | 30.91% | 1 | 16.67% |
| Geert Uytterhoeven | 6 | 10.91% | 2 | 33.33% |
| David Howells | 1 | 1.82% | 1 | 16.67% |
| Total | 55 | 100.00% | 6 | 100.00% |
EXPORT_SYMBOL(stdma_try_lock);
/*
* Function: void stdma_lock( isrfunc isr, void *data )
*
* Purpose: Tries to get a lock on the ST-DMA chip that is used by more
* then one device driver. Waits on stdma_wait until lock is free.
* stdma_lock() may not be called from an interrupt! You have to
* get the lock in your main routine and release it when your
* request is finished.
*
* Inputs: A interrupt function that is called until the lock is
* released.
*
* Returns: nothing
*
*/
void stdma_lock(irq_handler_t handler, void *data)
{
/* Since the DMA is used for file system purposes, we
have to sleep uninterruptible (there may be locked
buffers) */
wait_event(stdma_wait, stdma_try_lock(handler, data));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Finn Thain | 24 | 96.00% | 1 | 50.00% |
| Linus Torvalds (pre-git) | 1 | 4.00% | 1 | 50.00% |
| Total | 25 | 100.00% | 2 | 100.00% |
EXPORT_SYMBOL(stdma_lock);
/*
* Function: void stdma_release( void )
*
* Purpose: Releases the lock on the ST-DMA chip.
*
* Inputs: none
*
* Returns: nothing
*
*/
void stdma_release(void)
{
unsigned long flags;
local_irq_save(flags);
stdma_locked = 0;
stdma_isr = NULL;
stdma_isr_data = NULL;
wake_up(&stdma_wait);
local_irq_restore(flags);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 34 | 87.18% | 1 | 50.00% |
| Geert Uytterhoeven | 5 | 12.82% | 1 | 50.00% |
| Total | 39 | 100.00% | 2 | 100.00% |
EXPORT_SYMBOL(stdma_release);
/**
* stdma_is_locked_by - allow lock holder to check whether it needs to release.
* @handler: interrupt handler previously used to acquire lock.
*
* Returns !0 if locked for the given handler; 0 otherwise.
*/
int stdma_is_locked_by(irq_handler_t handler)
{
unsigned long flags;
int result;
local_irq_save(flags);
result = stdma_locked && (stdma_isr == handler);
local_irq_restore(flags);
return result;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Finn Thain | 30 | 78.95% | 1 | 33.33% |
| Linus Torvalds (pre-git) | 8 | 21.05% | 2 | 66.67% |
| Total | 38 | 100.00% | 3 | 100.00% |
EXPORT_SYMBOL(stdma_is_locked_by);
/*
* Function: int stdma_islocked( void )
*
* Purpose: Check if the ST-DMA is currently locked.
* Note: Returned status is only valid if ints are disabled while calling and
* as long as they remain disabled.
* If called with ints enabled, status can change only from locked to
* unlocked, because ints may not lock the ST-DMA.
*
* Inputs: none
*
* Returns: != 0 if locked, 0 otherwise
*
*/
int stdma_islocked(void)
{
return stdma_locked;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 10 | 100.00% | 1 | 100.00% |
| Total | 10 | 100.00% | 1 | 100.00% |
EXPORT_SYMBOL(stdma_islocked);
/*
* Function: void stdma_init( void )
*
* Purpose: Initialize the ST-DMA chip access controlling.
* It sets up the interrupt and its service routine. The int is registered
* as slow int, client devices have to live with that (no problem
* currently).
*
* Inputs: none
*
* Return: nothing
*
*/
void __init stdma_init(void)
{
stdma_isr = NULL;
if (request_irq(IRQ_MFP_FDC, stdma_int, IRQF_SHARED,
"ST-DMA floppy,ACSI,IDE,Falcon-SCSI", stdma_int))
pr_err("Couldn't register ST-DMA interrupt\n");
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 23 | 71.88% | 3 | 50.00% |
| Geert Uytterhoeven | 8 | 25.00% | 2 | 33.33% |
| Thomas Gleixner | 1 | 3.12% | 1 | 16.67% |
| Total | 32 | 100.00% | 6 | 100.00% |
/*
* Function: void stdma_int()
*
* Purpose: The interrupt routine for the ST-DMA. It calls the isr
* registered by stdma_lock().
*
*/
static irqreturn_t stdma_int(int irq, void *dummy)
{
if (stdma_isr)
(*stdma_isr)(irq, stdma_isr_data);
return IRQ_HANDLED;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 26 | 86.67% | 2 | 66.67% |
| Geert Uytterhoeven | 4 | 13.33% | 1 | 33.33% |
| Total | 30 | 100.00% | 3 | 100.00% |
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 217 | 61.30% | 9 | 45.00% |
| Finn Thain | 80 | 22.60% | 1 | 5.00% |
| Geert Uytterhoeven | 31 | 8.76% | 7 | 35.00% |
| Adrian Bunk | 22 | 6.21% | 1 | 5.00% |
| David Howells | 3 | 0.85% | 1 | 5.00% |
| Thomas Gleixner | 1 | 0.28% | 1 | 5.00% |
| Total | 354 | 100.00% | 20 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.