URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [kernel/] [dma.c] - Blame information for rev 79

Go to most recent revision | Details | Compare with Previous | View Log


/* $Id: dma.c,v 1.7 1994/12/28 03:35:33 root Exp root $
 * linux/kernel/dma.c: A DMA channel allocator. Inspired by linux/kernel/irq.c.
 *
 * Written by Hennus Bergman, 1992.
 *
 * 1994/12/26: Changes by Alex Nash to fix a minor bug in /proc/dma.
 *   In the previous version the reported device could end up being wrong,
 *   if a device requested a DMA channel that was already in use.
 *   [It also happened to remove the sizeof(char *) == sizeof(int)
 *   assumption introduced because of those /proc/dma patches. -- Hennus]
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/spinlock.h>
#include <linux/string.h>
#include <linux/seq_file.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <asm/dma.h>
#include <asm/system.h>
 
 
 
/* A note on resource allocation:
 *
 * All drivers needing DMA channels, should allocate and release them
 * through the public routines `request_dma()' and `free_dma()'.
 *
 * In order to avoid problems, all processes should allocate resources in
 * the same sequence and release them in the reverse order.
 *
 * So, when allocating DMAs and IRQs, first allocate the IRQ, then the DMA.
 * When releasing them, first release the DMA, then release the IRQ.
 * If you don't, you may cause allocation requests to fail unnecessarily.
 * This doesn't really matter now, but it will once we get real semaphores
 * in the kernel.
 */
 
 
DEFINE_SPINLOCK(dma_spin_lock);
 
/*
 *      If our port doesn't define this it has no PC like DMA
 */
 
#ifdef MAX_DMA_CHANNELS
 
 
/* Channel n is busy iff dma_chan_busy[n].lock != 0.
 * DMA0 used to be reserved for DRAM refresh, but apparently not any more...
 * DMA4 is reserved for cascading.
 */
 
struct dma_chan {
        int  lock;
        const char *device_id;
};
 
static struct dma_chan dma_chan_busy[MAX_DMA_CHANNELS] = {
        [4] = { 1, "cascade" },
};
 
 
/**
 * request_dma - request and reserve a system DMA channel
 * @dmanr: DMA channel number
 * @device_id: reserving device ID string, used in /proc/dma
 */
int request_dma(unsigned int dmanr, const char * device_id)
{
        if (dmanr >= MAX_DMA_CHANNELS)
                return -EINVAL;
 
        if (xchg(&dma_chan_busy[dmanr].lock, 1) != 0)
                return -EBUSY;
 
        dma_chan_busy[dmanr].device_id = device_id;
 
        /* old flag was 0, now contains 1 to indicate busy */
        return 0;
} /* request_dma */
 
/**
 * free_dma - free a reserved system DMA channel
 * @dmanr: DMA channel number
 */
void free_dma(unsigned int dmanr)
{
        if (dmanr >= MAX_DMA_CHANNELS) {
                printk(KERN_WARNING "Trying to free DMA%d\n", dmanr);
                return;
        }
 
        if (xchg(&dma_chan_busy[dmanr].lock, 0) == 0) {
                printk(KERN_WARNING "Trying to free free DMA%d\n", dmanr);
                return;
        }
 
} /* free_dma */
 
#else
 
int request_dma(unsigned int dmanr, const char *device_id)
{
        return -EINVAL;
}
 
void free_dma(unsigned int dmanr)
{
}
 
#endif
 
#ifdef CONFIG_PROC_FS
 
#ifdef MAX_DMA_CHANNELS
static int proc_dma_show(struct seq_file *m, void *v)
{
        int i;
 
        for (i = 0 ; i < MAX_DMA_CHANNELS ; i++) {
                if (dma_chan_busy[i].lock) {
                        seq_printf(m, "%2d: %s\n", i,
                                   dma_chan_busy[i].device_id);
                }
        }
        return 0;
}
#else
static int proc_dma_show(struct seq_file *m, void *v)
{
        seq_puts(m, "No DMA\n");
        return 0;
}
#endif /* MAX_DMA_CHANNELS */
 
static int proc_dma_open(struct inode *inode, struct file *file)
{
        return single_open(file, proc_dma_show, NULL);
}
 
static const struct file_operations proc_dma_operations = {
        .open           = proc_dma_open,
        .read           = seq_read,
        .llseek         = seq_lseek,
        .release        = single_release,
};
 
static int __init proc_dma_init(void)
{
        struct proc_dir_entry *e;
 
        e = create_proc_entry("dma", 0, NULL);
        if (e)
                e->proc_fops = &proc_dma_operations;
 
        return 0;
}
 
__initcall(proc_dma_init);
#endif
 
EXPORT_SYMBOL(request_dma);
EXPORT_SYMBOL(free_dma);
EXPORT_SYMBOL(dma_spin_lock);

Line No.	Rev	Author	Line
1	62	marcus.erl	`/* $Id: dma.c,v 1.7 1994/12/28 03:35:33 root Exp root $`
2			`* linux/kernel/dma.c: A DMA channel allocator. Inspired by linux/kernel/irq.c.`
3			`*`
4			`* Written by Hennus Bergman, 1992.`
5			`*`
6			`* 1994/12/26: Changes by Alex Nash to fix a minor bug in /proc/dma.`
7			`* In the previous version the reported device could end up being wrong,`
8			`* if a device requested a DMA channel that was already in use.`
9			`* [It also happened to remove the sizeof(char *) == sizeof(int)`
10			`* assumption introduced because of those /proc/dma patches. -- Hennus]`
11			`*/`
12			`#include <linux/module.h>`
13			`#include <linux/kernel.h>`
14			`#include <linux/errno.h>`
15			`#include <linux/spinlock.h>`
16			`#include <linux/string.h>`
17			`#include <linux/seq_file.h>`
18			`#include <linux/proc_fs.h>`
19			`#include <linux/init.h>`
20			`#include <asm/dma.h>`
21			`#include <asm/system.h>`
22
23
24
25			`/* A note on resource allocation:`
26			`*`
27			`* All drivers needing DMA channels, should allocate and release them`
28			* through the public routines `request_dma()' and `free_dma()'.
29			`*`
30			`* In order to avoid problems, all processes should allocate resources in`
31			`* the same sequence and release them in the reverse order.`
32			`*`
33			`* So, when allocating DMAs and IRQs, first allocate the IRQ, then the DMA.`
34			`* When releasing them, first release the DMA, then release the IRQ.`
35			`* If you don't, you may cause allocation requests to fail unnecessarily.`
36			`* This doesn't really matter now, but it will once we get real semaphores`
37			`* in the kernel.`
38			`*/`
39
40
41			`DEFINE_SPINLOCK(dma_spin_lock);`
42
43			`/*`
44			`* If our port doesn't define this it has no PC like DMA`
45			`*/`
46
47			`#ifdef MAX_DMA_CHANNELS`
48
49
50			`/* Channel n is busy iff dma_chan_busy[n].lock != 0.`
51			`* DMA0 used to be reserved for DRAM refresh, but apparently not any more...`
52			`* DMA4 is reserved for cascading.`
53			`*/`
54
55			`struct dma_chan {`
56			`int lock;`
57			`const char *device_id;`
58			`};`
59
60			`static struct dma_chan dma_chan_busy[MAX_DMA_CHANNELS] = {`
61			`[4] = { 1, "cascade" },`
62			`};`
63
64
65			`/**`
66			`* request_dma - request and reserve a system DMA channel`
67			`* @dmanr: DMA channel number`
68			`* @device_id: reserving device ID string, used in /proc/dma`
69			`*/`
70			`int request_dma(unsigned int dmanr, const char * device_id)`
71			`{`
72			`if (dmanr >= MAX_DMA_CHANNELS)`
73			`return -EINVAL;`
74
75			`if (xchg(&dma_chan_busy[dmanr].lock, 1) != 0)`
76			`return -EBUSY;`
77
78			`dma_chan_busy[dmanr].device_id = device_id;`
79
80			`/* old flag was 0, now contains 1 to indicate busy */`
81			`return 0;`
82			`} /* request_dma */`
83
84			`/**`
85			`* free_dma - free a reserved system DMA channel`
86			`* @dmanr: DMA channel number`
87			`*/`
88			`void free_dma(unsigned int dmanr)`
89			`{`
90			`if (dmanr >= MAX_DMA_CHANNELS) {`
91			`printk(KERN_WARNING "Trying to free DMA%d\n", dmanr);`
92			`return;`
93			`}`
94
95			`if (xchg(&dma_chan_busy[dmanr].lock, 0) == 0) {`
96			`printk(KERN_WARNING "Trying to free free DMA%d\n", dmanr);`
97			`return;`
98			`}`
99
100			`} /* free_dma */`
101
102			`#else`
103
104			`int request_dma(unsigned int dmanr, const char *device_id)`
105			`{`
106			`return -EINVAL;`
107			`}`
108
109			`void free_dma(unsigned int dmanr)`
110			`{`
111			`}`
112
113			`#endif`
114
115			`#ifdef CONFIG_PROC_FS`
116
117			`#ifdef MAX_DMA_CHANNELS`
118			`static int proc_dma_show(struct seq_file m, void v)`
119			`{`
120			`int i;`
121
122			`for (i = 0 ; i < MAX_DMA_CHANNELS ; i++) {`
123			`if (dma_chan_busy[i].lock) {`
124			`seq_printf(m, "%2d: %s\n", i,`
125			`dma_chan_busy[i].device_id);`
126			`}`
127			`}`
128			`return 0;`
129			`}`
130			`#else`
131			`static int proc_dma_show(struct seq_file m, void v)`
132			`{`
133			`seq_puts(m, "No DMA\n");`
134			`return 0;`
135			`}`
136			`#endif /* MAX_DMA_CHANNELS */`
137
138			`static int proc_dma_open(struct inode inode, struct file file)`
139			`{`
140			`return single_open(file, proc_dma_show, NULL);`
141			`}`
142
143			`static const struct file_operations proc_dma_operations = {`
144			`.open = proc_dma_open,`
145			`.read = seq_read,`
146			`.llseek = seq_lseek,`
147			`.release = single_release,`
148			`};`
149
150			`static int __init proc_dma_init(void)`
151			`{`
152			`struct proc_dir_entry *e;`
153
154			`e = create_proc_entry("dma", 0, NULL);`
155			`if (e)`
156			`e->proc_fops = &proc_dma_operations;`
157
158			`return 0;`
159			`}`
160
161			`__initcall(proc_dma_init);`
162			`#endif`
163
164			`EXPORT_SYMBOL(request_dma);`
165			`EXPORT_SYMBOL(free_dma);`
166			`EXPORT_SYMBOL(dma_spin_lock);`

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [kernel/] [dma.c] - Blame information for rev 79