source: cmedia/trunk/Include/Asm/dma.h

Last change on this file was 354, checked in by stevenhl, 17 years ago

Import untested baseline cmedia sources, work products and binaries
Binaries and work products should be deleted from repository.
once new builds are verified to work.
File size: 9.6 KB
Line 
1/* $Id: dma.h,v 1.1 2000/04/23 14:55:28 ktk Exp $
2 * linux/include/asm/dma.h: Defines for using and allocating dma channels.
3 * Written by Hennus Bergman, 1992.
4 * High DMA channel support & info by Hannu Savolainen
5 * and John Boyd, Nov. 1992.
6 */
7
8#ifndef _ASM_DMA_H
9#define _ASM_DMA_H
10
11#include <asm/io.h> /* need byte IO */
12#include <linux/delay.h>
13#include <linux/spinlock.h> /* And spinlocks */
14
15
16#ifdef HAVE_REALLY_SLOW_DMA_CONTROLLER
17#define dma_outb outb_p
18#else
19#define dma_outb outb
20#endif
21
22#define dma_inb inb
23
24/*
25 * NOTES about DMA transfers:
26 *
27 * controller 1: channels 0-3, byte operations, ports 00-1F
28 * controller 2: channels 4-7, word operations, ports C0-DF
29 *
30 * - ALL registers are 8 bits only, regardless of transfer size
31 * - channel 4 is not used - cascades 1 into 2.
32 * - channels 0-3 are byte - addresses/counts are for physical bytes
33 * - channels 5-7 are word - addresses/counts are for physical words
34 * - transfers must not cross physical 64K (0-3) or 128K (5-7) boundaries
35 * - transfer count loaded to registers is 1 less than actual count
36 * - controller 2 offsets are all even (2x offsets for controller 1)
37 * - page registers for 5-7 don't use data bit 0, represent 128K pages
38 * - page registers for 0-3 use bit 0, represent 64K pages
39 *
40 * DMA transfers are limited to the lower 16MB of _physical_ memory.
41 * Note that addresses loaded into registers must be _physical_ addresses,
42 * not logical addresses (which may differ if paging is active).
43 *
44 * Address mapping for channels 0-3:
45 *
46 * A23 ... A16 A15 ... A8 A7 ... A0 (Physical addresses)
47 * | ... | | ... | | ... |
48 * | ... | | ... | | ... |
49 * | ... | | ... | | ... |
50 * P7 ... P0 A7 ... A0 A7 ... A0
51 * | Page | Addr MSB | Addr LSB | (DMA registers)
52 *
53 * Address mapping for channels 5-7:
54 *
55 * A23 ... A17 A16 A15 ... A9 A8 A7 ... A1 A0 (Physical addresses)
56 * | ... | \ \ ... \ \ \ ... \ \
57 * | ... | \ \ ... \ \ \ ... \ (not used)
58 * | ... | \ \ ... \ \ \ ... \
59 * P7 ... P1 (0) A7 A6 ... A0 A7 A6 ... A0
60 * | Page | Addr MSB | Addr LSB | (DMA registers)
61 *
62 * Again, channels 5-7 transfer _physical_ words (16 bits), so addresses
63 * and counts _must_ be word-aligned (the lowest address bit is _ignored_ at
64 * the hardware level, so odd-byte transfers aren't possible).
65 *
66 * Transfer count (_not # bytes_) is limited to 64K, represented as actual
67 * count - 1 : 64K => 0xFFFF, 1 => 0x0000. Thus, count is always 1 or more,
68 * and up to 128K bytes may be transferred on channels 5-7 in one operation.
69 *
70 */
71
72#define MAX_DMA_CHANNELS 8
73
74/* The maximum address that we can perform a DMA transfer to on this platform */
75#define MAX_DMA_ADDRESS (PAGE_OFFSET+0x1000000)
76
77/* 8237 DMA controllers */
78#define IO_DMA1_BASE 0x00 /* 8 bit slave DMA, channels 0..3 */
79#define IO_DMA2_BASE 0xC0 /* 16 bit master DMA, ch 4(=slave input)..7 */
80
81/* DMA controller registers */
82#define DMA1_CMD_REG 0x08 /* command register (w) */
83#define DMA1_STAT_REG 0x08 /* status register (r) */
84#define DMA1_REQ_REG 0x09 /* request register (w) */
85#define DMA1_MASK_REG 0x0A /* single-channel mask (w) */
86#define DMA1_MODE_REG 0x0B /* mode register (w) */
87#define DMA1_CLEAR_FF_REG 0x0C /* clear pointer flip-flop (w) */
88#define DMA1_TEMP_REG 0x0D /* Temporary Register (r) */
89#define DMA1_RESET_REG 0x0D /* Master Clear (w) */
90#define DMA1_CLR_MASK_REG 0x0E /* Clear Mask */
91#define DMA1_MASK_ALL_REG 0x0F /* all-channels mask (w) */
92
93#define DMA2_CMD_REG 0xD0 /* command register (w) */
94#define DMA2_STAT_REG 0xD0 /* status register (r) */
95#define DMA2_REQ_REG 0xD2 /* request register (w) */
96#define DMA2_MASK_REG 0xD4 /* single-channel mask (w) */
97#define DMA2_MODE_REG 0xD6 /* mode register (w) */
98#define DMA2_CLEAR_FF_REG 0xD8 /* clear pointer flip-flop (w) */
99#define DMA2_TEMP_REG 0xDA /* Temporary Register (r) */
100#define DMA2_RESET_REG 0xDA /* Master Clear (w) */
101#define DMA2_CLR_MASK_REG 0xDC /* Clear Mask */
102#define DMA2_MASK_ALL_REG 0xDE /* all-channels mask (w) */
103
104#define DMA_ADDR_0 0x00 /* DMA address registers */
105#define DMA_ADDR_1 0x02
106#define DMA_ADDR_2 0x04
107#define DMA_ADDR_3 0x06
108#define DMA_ADDR_4 0xC0
109#define DMA_ADDR_5 0xC4
110#define DMA_ADDR_6 0xC8
111#define DMA_ADDR_7 0xCC
112
113#define DMA_CNT_0 0x01 /* DMA count registers */
114#define DMA_CNT_1 0x03
115#define DMA_CNT_2 0x05
116#define DMA_CNT_3 0x07
117#define DMA_CNT_4 0xC2
118#define DMA_CNT_5 0xC6
119#define DMA_CNT_6 0xCA
120#define DMA_CNT_7 0xCE
121
122#define DMA_PAGE_0 0x87 /* DMA page registers */
123#define DMA_PAGE_1 0x83
124#define DMA_PAGE_2 0x81
125#define DMA_PAGE_3 0x82
126#define DMA_PAGE_5 0x8B
127#define DMA_PAGE_6 0x89
128#define DMA_PAGE_7 0x8A
129
130#define DMA_MODE_READ 0x44 /* I/O to memory, no autoinit, increment, single mode */
131#define DMA_MODE_WRITE 0x48 /* memory to I/O, no autoinit, increment, single mode */
132#define DMA_MODE_CASCADE 0xC0 /* pass thru DREQ->HRQ, DACK<-HLDA only */
133
134#define DMA_AUTOINIT 0x10
135
136extern spinlock_t dma_spin_lock;
137
138static __inline__ unsigned long claim_dma_lock(void);
139static __inline__ void release_dma_lock(unsigned long flags);
140/* enable/disable a specific DMA channel */
141static __inline__ void enable_dma(unsigned int dmanr);
142
143static __inline__ void disable_dma(unsigned int dmanr);
144
145/* Clear the 'DMA Pointer Flip Flop'.
146 * Write 0 for LSB/MSB, 1 for MSB/LSB access.
147 * Use this once to initialize the FF to a known state.
148 * After that, keep track of it. :-)
149 * --- In order to do that, the DMA routines below should ---
150 * --- only be used while holding the DMA lock ! ---
151 */
152static __inline__ void clear_dma_ff(unsigned int dmanr)
153{
154 if (dmanr<=3)
155 dma_outb(0, DMA1_CLEAR_FF_REG);
156 else
157 dma_outb(0, DMA2_CLEAR_FF_REG);
158}
159
160/* set mode (above) for a specific DMA channel */
161static __inline__ void set_dma_mode(unsigned int dmanr, char mode)
162{
163 if (dmanr<=3)
164 dma_outb(mode | dmanr, DMA1_MODE_REG);
165 else
166 dma_outb(mode | (dmanr&3), DMA2_MODE_REG);
167}
168
169/* Set only the page register bits of the transfer address.
170 * This is used for successive transfers when we know the contents of
171 * the lower 16 bits of the DMA current address register, but a 64k boundary
172 * may have been crossed.
173 */
174static __inline__ void set_dma_page(unsigned int dmanr, char pagenr)
175{
176 switch(dmanr) {
177 case 0:
178 dma_outb(pagenr, DMA_PAGE_0);
179 break;
180 case 1:
181 dma_outb(pagenr, DMA_PAGE_1);
182 break;
183 case 2:
184 dma_outb(pagenr, DMA_PAGE_2);
185 break;
186 case 3:
187 dma_outb(pagenr, DMA_PAGE_3);
188 break;
189 case 5:
190 dma_outb(pagenr & 0xfe, DMA_PAGE_5);
191 break;
192 case 6:
193 dma_outb(pagenr & 0xfe, DMA_PAGE_6);
194 break;
195 case 7:
196 dma_outb(pagenr & 0xfe, DMA_PAGE_7);
197 break;
198 }
199}
200
201
202/* Set transfer address & page bits for specific DMA channel.
203 * Assumes dma flipflop is clear.
204 */
205static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int a)
206{
207 set_dma_page(dmanr, (char)(a>>16));
208 if (dmanr <= 3) {
209 dma_outb( a & 0xff, (char)((dmanr&3)<<1) + IO_DMA1_BASE );
210 dma_outb( (a>>8) & 0xff, (char)((dmanr&3)<<1) + IO_DMA1_BASE );
211 } else {
212 dma_outb( (a>>1) & 0xff, (char)((dmanr&3)<<2) + IO_DMA2_BASE );
213 dma_outb( (a>>9) & 0xff, (char)((dmanr&3)<<2) + IO_DMA2_BASE );
214 }
215}
216
217
218/* Set transfer size (max 64k for DMA1..3, 128k for DMA5..7) for
219 * a specific DMA channel.
220 * You must ensure the parameters are valid.
221 * NOTE: from a manual: "the number of transfers is one more
222 * than the initial word count"! This is taken into account.
223 * Assumes dma flip-flop is clear.
224 * NOTE 2: "count" represents _bytes_ and must be even for channels 5-7.
225 */
226static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
227{
228 count--;
229 if (dmanr <= 3) {
230 dma_outb( count & 0xff, (char)((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
231 dma_outb( (count>>8) & 0xff, (char)((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
232 } else {
233 dma_outb( (count>>1) & 0xff, (char)((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
234 dma_outb( (count>>9) & 0xff, (char)((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
235 }
236}
237
238
239/* Get DMA residue count. After a DMA transfer, this
240 * should return zero. Reading this while a DMA transfer is
241 * still in progress will return unpredictable results.
242 * If called before the channel has been used, it may return 1.
243 * Otherwise, it returns the number of _bytes_ left to transfer.
244 *
245 * Assumes DMA flip-flop is clear.
246 */
247static __inline__ int get_dma_residue(unsigned int dmanr)
248{
249 unsigned int io_port = (dmanr<=3)? ((dmanr&3)<<1) + 1 + IO_DMA1_BASE
250 : ((dmanr&3)<<2) + 2 + IO_DMA2_BASE;
251
252 /* using short to get 16-bit wrap around */
253 unsigned short count;
254
255 count = 1 + dma_inb(io_port);
256 count += dma_inb(io_port) << 8;
257
258 return (dmanr<=3)? count : (count<<1);
259}
260
261
262/* These are in kernel/dma.c: */
263extern int request_dma(unsigned int dmanr, const char * device_id); /* reserve a DMA channel */
264extern void free_dma(unsigned int dmanr); /* release it again */
265
266/* From PCI */
267
268#ifdef CONFIG_PCI
269extern int isa_dma_bridge_buggy;
270#else
271#define isa_dma_bridge_buggy (0)
272#endif
273
274#endif /* _ASM_DMA_H */
Note: See TracBrowser for help on using the repository browser.