| 1 | |
| 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/export.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 |
|
| 22 |
|
| 23 |
|
| 24 | |
| 25 | *
|
| 26 | * All drivers needing DMA channels, should allocate and release them
|
| 27 | * through the public routines `request_dma()' and `free_dma()'.
|
| 28 | *
|
| 29 | * In order to avoid problems, all processes should allocate resources in
|
| 30 | * the same sequence and release them in the reverse order.
|
| 31 | *
|
| 32 | * So, when allocating DMAs and IRQs, first allocate the IRQ, then the DMA.
|
| 33 | * When releasing them, first release the DMA, then release the IRQ.
|
| 34 | * If you don't, you may cause allocation requests to fail unnecessarily.
|
| 35 | * This doesn't really matter now, but it will once we get real semaphores
|
| 36 | * in the kernel.
|
| 37 |
|
| 38 |
|
| 39 |
|
| 40 | DEFINE_SPINLOCK(dma_spin_lock);
|
| 41 |
|
| 42 | |
| 43 | * If our port doesn't define this it has no PC like DMA
|
| 44 |
|
| 45 |
|
| 46 | #ifdef MAX_DMA_CHANNELS
|
| 47 |
|
| 48 |
|
| 49 | |
| 50 | * DMA0 used to be reserved for DRAM refresh, but apparently not any more...
|
| 51 | * DMA4 is reserved for cascading.
|
| 52 |
|
| 53 |
|
| 54 | struct dma_chan {
|
| 55 | int lock;
|
| 56 | const char *device_id;
|
| 57 | };
|
| 58 |
|
| 59 | static struct dma_chan dma_chan_busy[MAX_DMA_CHANNELS] = {
|
| 60 | [4] = { 1, "cascade" },
|
| 61 | };
|
| 62 |
|
| 63 |
|
| 64 | |
| 65 | * request_dma - request and reserve a system DMA channel
|
| 66 | * @dmanr: DMA channel number
|
| 67 | * @device_id: reserving device ID string, used in /proc/dma
|
| 68 |
|
| 69 | int request_dma(unsigned int dmanr, const char * device_id)
|
| 70 | {
|
| 71 | if (dmanr >= MAX_DMA_CHANNELS)
|
| 72 | return -EINVAL;
|
| 73 |
|
| 74 | if (xchg(&dma_chan_busy[dmanr].lock, 1) != 0)
|
| 75 | return -EBUSY;
|
| 76 |
|
| 77 | dma_chan_busy[dmanr].device_id = device_id;
|
| 78 |
|
| 79 |
|
| 80 | return 0;
|
| 81 | }
|
| 82 |
|
| 83 | |
| 84 | * free_dma - free a reserved system DMA channel
|
| 85 | * @dmanr: DMA channel number
|
| 86 |
|
| 87 | void free_dma(unsigned int dmanr)
|
| 88 | {
|
| 89 | if (dmanr >= MAX_DMA_CHANNELS) {
|
| 90 | printk(KERN_WARNING "Trying to free DMA%d\n", dmanr);
|
| 91 | return;
|
| 92 | }
|
| 93 |
|
| 94 | if (xchg(&dma_chan_busy[dmanr].lock, 0) == 0) {
|
| 95 | printk(KERN_WARNING "Trying to free free DMA%d\n", dmanr);
|
| 96 | return;
|
| 97 | }
|
| 98 |
|
| 99 | }
|
| 100 |
|
| 101 | #else
|
| 102 |
|
| 103 | int request_dma(unsigned int dmanr, const char *device_id)
|
| 104 | {
|
| 105 | return -EINVAL;
|
| 106 | }
|
| 107 |
|
| 108 | void free_dma(unsigned int dmanr)
|
| 109 | {
|
| 110 | }
|
| 111 |
|
| 112 | #endif
|
| 113 |
|
| 114 | #ifdef CONFIG_PROC_FS
|
| 115 |
|
| 116 | #ifdef MAX_DMA_CHANNELS
|
| 117 | static int proc_dma_show(struct seq_file *m, void *v)
|
| 118 | {
|
| 119 | int i;
|
| 120 |
|
| 121 | for (i = 0 ; i < MAX_DMA_CHANNELS ; i++) {
|
| 122 | if (dma_chan_busy[i].lock) {
|
| 123 | seq_printf(m, "%2d: %s\n", i,
|
| 124 | dma_chan_busy[i].device_id);
|
| 125 | }
|
| 126 | }
|
| 127 | return 0;
|
| 128 | }
|
| 129 | #else
|
| 130 | static int proc_dma_show(struct seq_file *m, void *v)
|
| 131 | {
|
| 132 | seq_puts(m, "No DMA\n");
|
| 133 | return 0;
|
| 134 | }
|
| 135 | #endif
|
| 136 |
|
| 137 | static int proc_dma_open(struct inode *inode, struct file *file)
|
| 138 | {
|
| 139 | return single_open(file, proc_dma_show, NULL);
|
| 140 | }
|
| 141 |
|
| 142 | static const struct file_operations proc_dma_operations = {
|
| 143 | .open = proc_dma_open,
|
| 144 | .read = seq_read,
|
| 145 | .llseek = seq_lseek,
|
| 146 | .release = single_release,
|
| 147 | };
|
| 148 |
|
| 149 | static int __init proc_dma_init(void)
|
| 150 | {
|
| 151 | proc_create("dma", 0, NULL, &proc_dma_operations);
|
| 152 | return 0;
|
| 153 | }
|
| 154 |
|
| 155 | __initcall(proc_dma_init);
|
| 156 | #endif
|
| 157 |
|
| 158 | EXPORT_SYMBOL(request_dma);
|
| 159 | EXPORT_SYMBOL(free_dma);
|
| 160 | EXPORT_SYMBOL(dma_spin_lock);
|