Merge branch 'x86-cpu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6.git] / arch / m68k / include / asm / dma.h
1 #ifndef _M68K_DMA_H
2 #define _M68K_DMA_H 1
3
4 #ifdef CONFIG_COLDFIRE
5 /*
6  * ColdFire DMA Model:
7  *   ColdFire DMA supports two forms of DMA: Single and Dual address. Single
8  * address mode emits a source address, and expects that the device will either
9  * pick up the data (DMA READ) or source data (DMA WRITE). This implies that
10  * the device will place data on the correct byte(s) of the data bus, as the
11  * memory transactions are always 32 bits. This implies that only 32 bit
12  * devices will find single mode transfers useful. Dual address DMA mode
13  * performs two cycles: source read and destination write. ColdFire will
14  * align the data so that the device will always get the correct bytes, thus
15  * is useful for 8 and 16 bit devices. This is the mode that is supported
16  * below.
17  *
18  * AUG/22/2000 : added support for 32-bit Dual-Address-Mode (K) 2000
19  *               Oliver Kamphenkel (O.Kamphenkel@tu-bs.de)
20  *
21  * AUG/25/2000 : addad support for 8, 16 and 32-bit Single-Address-Mode (K)2000
22  *               Oliver Kamphenkel (O.Kamphenkel@tu-bs.de)
23  *
24  * APR/18/2002 : added proper support for MCF5272 DMA controller.
25  *               Arthur Shipkowski (art@videon-central.com)
26  */
27
28 #include <asm/coldfire.h>
29 #include <asm/mcfsim.h>
30 #include <asm/mcfdma.h>
31
32 /*
33  * Set number of channels of DMA on ColdFire for different implementations.
34  */
35 #if defined(CONFIG_M5249) || defined(CONFIG_M5307) || defined(CONFIG_M5407) || \
36         defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x)
37 #define MAX_M68K_DMA_CHANNELS 4
38 #elif defined(CONFIG_M5272)
39 #define MAX_M68K_DMA_CHANNELS 1
40 #elif defined(CONFIG_M532x)
41 #define MAX_M68K_DMA_CHANNELS 0
42 #else
43 #define MAX_M68K_DMA_CHANNELS 2
44 #endif
45
46 extern unsigned int dma_base_addr[MAX_M68K_DMA_CHANNELS];
47 extern unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
48
49 #if !defined(CONFIG_M5272)
50 #define DMA_MODE_WRITE_BIT  0x01  /* Memory/IO to IO/Memory select */
51 #define DMA_MODE_WORD_BIT   0x02  /* 8 or 16 bit transfers */
52 #define DMA_MODE_LONG_BIT   0x04  /* or 32 bit transfers */
53 #define DMA_MODE_SINGLE_BIT 0x08  /* single-address-mode */
54
55 /* I/O to memory, 8 bits, mode */
56 #define DMA_MODE_READ               0
57 /* memory to I/O, 8 bits, mode */
58 #define DMA_MODE_WRITE              1
59 /* I/O to memory, 16 bits, mode */
60 #define DMA_MODE_READ_WORD          2
61 /* memory to I/O, 16 bits, mode */
62 #define DMA_MODE_WRITE_WORD         3
63 /* I/O to memory, 32 bits, mode */
64 #define DMA_MODE_READ_LONG          4
65 /* memory to I/O, 32 bits, mode */
66 #define DMA_MODE_WRITE_LONG         5
67 /* I/O to memory, 8 bits, single-address-mode */
68 #define DMA_MODE_READ_SINGLE        8
69 /* memory to I/O, 8 bits, single-address-mode */
70 #define DMA_MODE_WRITE_SINGLE       9
71 /* I/O to memory, 16 bits, single-address-mode */
72 #define DMA_MODE_READ_WORD_SINGLE  10
73 /* memory to I/O, 16 bits, single-address-mode */
74 #define DMA_MODE_WRITE_WORD_SINGLE 11
75 /* I/O to memory, 32 bits, single-address-mode */
76 #define DMA_MODE_READ_LONG_SINGLE  12
77 /* memory to I/O, 32 bits, single-address-mode */
78 #define DMA_MODE_WRITE_LONG_SINGLE 13
79
80 #else /* CONFIG_M5272 is defined */
81
82 /* Source static-address mode */
83 #define DMA_MODE_SRC_SA_BIT 0x01
84 /* Two bits to select between all four modes */
85 #define DMA_MODE_SSIZE_MASK 0x06
86 /* Offset to shift bits in */
87 #define DMA_MODE_SSIZE_OFF  0x01
88 /* Destination static-address mode */
89 #define DMA_MODE_DES_SA_BIT 0x10
90 /* Two bits to select between all four modes */
91 #define DMA_MODE_DSIZE_MASK 0x60
92 /* Offset to shift bits in */
93 #define DMA_MODE_DSIZE_OFF  0x05
94 /* Size modifiers */
95 #define DMA_MODE_SIZE_LONG  0x00
96 #define DMA_MODE_SIZE_BYTE  0x01
97 #define DMA_MODE_SIZE_WORD  0x02
98 #define DMA_MODE_SIZE_LINE  0x03
99
100 /*
101  * Aliases to help speed quick ports; these may be suboptimal, however. They
102  * do not include the SINGLE mode modifiers since the MCF5272 does not have a
103  * mode where the device is in control of its addressing.
104  */
105
106 /* I/O to memory, 8 bits, mode */
107 #define DMA_MODE_READ                 ((DMA_MODE_SIZE_BYTE << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_BYTE << DMA_MODE_SSIZE_OFF) | DMA_SRC_SA_BIT)
108 /* memory to I/O, 8 bits, mode */
109 #define DMA_MODE_WRITE              ((DMA_MODE_SIZE_BYTE << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_BYTE << DMA_MODE_SSIZE_OFF) | DMA_DES_SA_BIT)
110 /* I/O to memory, 16 bits, mode */
111 #define DMA_MODE_READ_WORD              ((DMA_MODE_SIZE_WORD << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_WORD << DMA_MODE_SSIZE_OFF) | DMA_SRC_SA_BIT)
112 /* memory to I/O, 16 bits, mode */
113 #define DMA_MODE_WRITE_WORD         ((DMA_MODE_SIZE_WORD << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_WORD << DMA_MODE_SSIZE_OFF) | DMA_DES_SA_BIT)
114 /* I/O to memory, 32 bits, mode */
115 #define DMA_MODE_READ_LONG              ((DMA_MODE_SIZE_LONG << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_LONG << DMA_MODE_SSIZE_OFF) | DMA_SRC_SA_BIT)
116 /* memory to I/O, 32 bits, mode */
117 #define DMA_MODE_WRITE_LONG         ((DMA_MODE_SIZE_LONG << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_LONG << DMA_MODE_SSIZE_OFF) | DMA_DES_SA_BIT)
118
119 #endif /* !defined(CONFIG_M5272) */
120
121 #if !defined(CONFIG_M5272)
122 /* enable/disable a specific DMA channel */
123 static __inline__ void enable_dma(unsigned int dmanr)
124 {
125   volatile unsigned short *dmawp;
126
127 #ifdef DMA_DEBUG
128   printk("enable_dma(dmanr=%d)\n", dmanr);
129 #endif
130
131   dmawp = (unsigned short *) dma_base_addr[dmanr];
132   dmawp[MCFDMA_DCR] |= MCFDMA_DCR_EEXT;
133 }
134
135 static __inline__ void disable_dma(unsigned int dmanr)
136 {
137   volatile unsigned short *dmawp;
138   volatile unsigned char  *dmapb;
139
140 #ifdef DMA_DEBUG
141   printk("disable_dma(dmanr=%d)\n", dmanr);
142 #endif
143
144   dmawp = (unsigned short *) dma_base_addr[dmanr];
145   dmapb = (unsigned char *) dma_base_addr[dmanr];
146
147   /* Turn off external requests, and stop any DMA in progress */
148   dmawp[MCFDMA_DCR] &= ~MCFDMA_DCR_EEXT;
149   dmapb[MCFDMA_DSR] = MCFDMA_DSR_DONE;
150 }
151
152 /*
153  * Clear the 'DMA Pointer Flip Flop'.
154  * Write 0 for LSB/MSB, 1 for MSB/LSB access.
155  * Use this once to initialize the FF to a known state.
156  * After that, keep track of it. :-)
157  * --- In order to do that, the DMA routines below should ---
158  * --- only be used while interrupts are disabled! ---
159  *
160  * This is a NOP for ColdFire. Provide a stub for compatibility.
161  */
162 static __inline__ void clear_dma_ff(unsigned int dmanr)
163 {
164 }
165
166 /* set mode (above) for a specific DMA channel */
167 static __inline__ void set_dma_mode(unsigned int dmanr, char mode)
168 {
169
170   volatile unsigned char  *dmabp;
171   volatile unsigned short *dmawp;
172
173 #ifdef DMA_DEBUG
174   printk("set_dma_mode(dmanr=%d,mode=%d)\n", dmanr, mode);
175 #endif
176
177   dmabp = (unsigned char *) dma_base_addr[dmanr];
178   dmawp = (unsigned short *) dma_base_addr[dmanr];
179
180   /* Clear config errors */
181   dmabp[MCFDMA_DSR] = MCFDMA_DSR_DONE;
182
183   /* Set command register */
184   dmawp[MCFDMA_DCR] =
185     MCFDMA_DCR_INT |         /* Enable completion irq */
186     MCFDMA_DCR_CS |          /* Force one xfer per request */
187     MCFDMA_DCR_AA |          /* Enable auto alignment */
188     /* single-address-mode */
189     ((mode & DMA_MODE_SINGLE_BIT) ? MCFDMA_DCR_SAA : 0) |
190     /* sets s_rw (-> r/w) high if Memory to I/0 */
191     ((mode & DMA_MODE_WRITE_BIT) ? MCFDMA_DCR_S_RW : 0) |
192     /* Memory to I/O or I/O to Memory */
193     ((mode & DMA_MODE_WRITE_BIT) ? MCFDMA_DCR_SINC : MCFDMA_DCR_DINC) |
194     /* 32 bit, 16 bit or 8 bit transfers */
195     ((mode & DMA_MODE_WORD_BIT)  ? MCFDMA_DCR_SSIZE_WORD :
196      ((mode & DMA_MODE_LONG_BIT) ? MCFDMA_DCR_SSIZE_LONG :
197                                    MCFDMA_DCR_SSIZE_BYTE)) |
198     ((mode & DMA_MODE_WORD_BIT)  ? MCFDMA_DCR_DSIZE_WORD :
199      ((mode & DMA_MODE_LONG_BIT) ? MCFDMA_DCR_DSIZE_LONG :
200                                    MCFDMA_DCR_DSIZE_BYTE));
201
202 #ifdef DEBUG_DMA
203   printk("%s(%d): dmanr=%d DSR[%x]=%x DCR[%x]=%x\n", __FILE__, __LINE__,
204          dmanr, (int) &dmabp[MCFDMA_DSR], dmabp[MCFDMA_DSR],
205          (int) &dmawp[MCFDMA_DCR], dmawp[MCFDMA_DCR]);
206 #endif
207 }
208
209 /* Set transfer address for specific DMA channel */
210 static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int a)
211 {
212   volatile unsigned short *dmawp;
213   volatile unsigned int   *dmalp;
214
215 #ifdef DMA_DEBUG
216   printk("set_dma_addr(dmanr=%d,a=%x)\n", dmanr, a);
217 #endif
218
219   dmawp = (unsigned short *) dma_base_addr[dmanr];
220   dmalp = (unsigned int *) dma_base_addr[dmanr];
221
222   /* Determine which address registers are used for memory/device accesses */
223   if (dmawp[MCFDMA_DCR] & MCFDMA_DCR_SINC) {
224     /* Source incrementing, must be memory */
225     dmalp[MCFDMA_SAR] = a;
226     /* Set dest address, must be device */
227     dmalp[MCFDMA_DAR] = dma_device_address[dmanr];
228   } else {
229     /* Destination incrementing, must be memory */
230     dmalp[MCFDMA_DAR] = a;
231     /* Set source address, must be device */
232     dmalp[MCFDMA_SAR] = dma_device_address[dmanr];
233   }
234
235 #ifdef DEBUG_DMA
236   printk("%s(%d): dmanr=%d DCR[%x]=%x SAR[%x]=%08x DAR[%x]=%08x\n",
237         __FILE__, __LINE__, dmanr, (int) &dmawp[MCFDMA_DCR], dmawp[MCFDMA_DCR],
238         (int) &dmalp[MCFDMA_SAR], dmalp[MCFDMA_SAR],
239         (int) &dmalp[MCFDMA_DAR], dmalp[MCFDMA_DAR]);
240 #endif
241 }
242
243 /*
244  * Specific for Coldfire - sets device address.
245  * Should be called after the mode set call, and before set DMA address.
246  */
247 static __inline__ void set_dma_device_addr(unsigned int dmanr, unsigned int a)
248 {
249 #ifdef DMA_DEBUG
250   printk("set_dma_device_addr(dmanr=%d,a=%x)\n", dmanr, a);
251 #endif
252
253   dma_device_address[dmanr] = a;
254 }
255
256 /*
257  * NOTE 2: "count" represents _bytes_.
258  */
259 static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
260 {
261   volatile unsigned short *dmawp;
262
263 #ifdef DMA_DEBUG
264   printk("set_dma_count(dmanr=%d,count=%d)\n", dmanr, count);
265 #endif
266
267   dmawp = (unsigned short *) dma_base_addr[dmanr];
268   dmawp[MCFDMA_BCR] = (unsigned short)count;
269 }
270
271 /*
272  * Get DMA residue count. After a DMA transfer, this
273  * should return zero. Reading this while a DMA transfer is
274  * still in progress will return unpredictable results.
275  * Otherwise, it returns the number of _bytes_ left to transfer.
276  */
277 static __inline__ int get_dma_residue(unsigned int dmanr)
278 {
279   volatile unsigned short *dmawp;
280   unsigned short count;
281
282 #ifdef DMA_DEBUG
283   printk("get_dma_residue(dmanr=%d)\n", dmanr);
284 #endif
285
286   dmawp = (unsigned short *) dma_base_addr[dmanr];
287   count = dmawp[MCFDMA_BCR];
288   return((int) count);
289 }
290 #else /* CONFIG_M5272 is defined */
291
292 /*
293  * The MCF5272 DMA controller is very different than the controller defined above
294  * in terms of register mapping.  For instance, with the exception of the 16-bit
295  * interrupt register (IRQ#85, for reference), all of the registers are 32-bit.
296  *
297  * The big difference, however, is the lack of device-requested DMA.  All modes
298  * are dual address transfer, and there is no 'device' setup or direction bit.
299  * You can DMA between a device and memory, between memory and memory, or even between
300  * two devices directly, with any combination of incrementing and non-incrementing
301  * addresses you choose.  This puts a crimp in distinguishing between the 'device
302  * address' set up by set_dma_device_addr.
303  *
304  * Therefore, there are two options.  One is to use set_dma_addr and set_dma_device_addr,
305  * which will act exactly as above in -- it will look to see if the source is set to
306  * autoincrement, and if so it will make the source use the set_dma_addr value and the
307  * destination the set_dma_device_addr value.  Otherwise the source will be set to the
308  * set_dma_device_addr value and the destination will get the set_dma_addr value.
309  *
310  * The other is to use the provided set_dma_src_addr and set_dma_dest_addr functions
311  * and make it explicit.  Depending on what you're doing, one of these two should work
312  * for you, but don't mix them in the same transfer setup.
313  */
314
315 /* enable/disable a specific DMA channel */
316 static __inline__ void enable_dma(unsigned int dmanr)
317 {
318   volatile unsigned int  *dmalp;
319
320 #ifdef DMA_DEBUG
321   printk("enable_dma(dmanr=%d)\n", dmanr);
322 #endif
323
324   dmalp = (unsigned int *) dma_base_addr[dmanr];
325   dmalp[MCFDMA_DMR] |= MCFDMA_DMR_EN;
326 }
327
328 static __inline__ void disable_dma(unsigned int dmanr)
329 {
330   volatile unsigned int   *dmalp;
331
332 #ifdef DMA_DEBUG
333   printk("disable_dma(dmanr=%d)\n", dmanr);
334 #endif
335
336   dmalp = (unsigned int *) dma_base_addr[dmanr];
337
338   /* Turn off external requests, and stop any DMA in progress */
339   dmalp[MCFDMA_DMR] &= ~MCFDMA_DMR_EN;
340   dmalp[MCFDMA_DMR] |= MCFDMA_DMR_RESET;
341 }
342
343 /*
344  * Clear the 'DMA Pointer Flip Flop'.
345  * Write 0 for LSB/MSB, 1 for MSB/LSB access.
346  * Use this once to initialize the FF to a known state.
347  * After that, keep track of it. :-)
348  * --- In order to do that, the DMA routines below should ---
349  * --- only be used while interrupts are disabled! ---
350  *
351  * This is a NOP for ColdFire. Provide a stub for compatibility.
352  */
353 static __inline__ void clear_dma_ff(unsigned int dmanr)
354 {
355 }
356
357 /* set mode (above) for a specific DMA channel */
358 static __inline__ void set_dma_mode(unsigned int dmanr, char mode)
359 {
360
361   volatile unsigned int   *dmalp;
362   volatile unsigned short *dmawp;
363
364 #ifdef DMA_DEBUG
365   printk("set_dma_mode(dmanr=%d,mode=%d)\n", dmanr, mode);
366 #endif
367   dmalp = (unsigned int *) dma_base_addr[dmanr];
368   dmawp = (unsigned short *) dma_base_addr[dmanr];
369
370   /* Clear config errors */
371   dmalp[MCFDMA_DMR] |= MCFDMA_DMR_RESET;
372
373   /* Set command register */
374   dmalp[MCFDMA_DMR] =
375     MCFDMA_DMR_RQM_DUAL |         /* Mandatory Request Mode setting */
376     MCFDMA_DMR_DSTT_SD  |         /* Set up addressing types; set to supervisor-data. */
377     MCFDMA_DMR_SRCT_SD  |         /* Set up addressing types; set to supervisor-data. */
378     /* source static-address-mode */
379     ((mode & DMA_MODE_SRC_SA_BIT) ? MCFDMA_DMR_SRCM_SA : MCFDMA_DMR_SRCM_IA) |
380     /* dest static-address-mode */
381     ((mode & DMA_MODE_DES_SA_BIT) ? MCFDMA_DMR_DSTM_SA : MCFDMA_DMR_DSTM_IA) |
382     /* burst, 32 bit, 16 bit or 8 bit transfers are separately configurable on the MCF5272 */
383     (((mode & DMA_MODE_SSIZE_MASK) >> DMA_MODE_SSIZE_OFF) << MCFDMA_DMR_DSTS_OFF) |
384     (((mode & DMA_MODE_SSIZE_MASK) >> DMA_MODE_SSIZE_OFF) << MCFDMA_DMR_SRCS_OFF);
385
386   dmawp[MCFDMA_DIR] |= MCFDMA_DIR_ASCEN;   /* Enable completion interrupts */
387
388 #ifdef DEBUG_DMA
389   printk("%s(%d): dmanr=%d DMR[%x]=%x DIR[%x]=%x\n", __FILE__, __LINE__,
390          dmanr, (int) &dmalp[MCFDMA_DMR], dmabp[MCFDMA_DMR],
391          (int) &dmawp[MCFDMA_DIR], dmawp[MCFDMA_DIR]);
392 #endif
393 }
394
395 /* Set transfer address for specific DMA channel */
396 static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int a)
397 {
398   volatile unsigned int   *dmalp;
399
400 #ifdef DMA_DEBUG
401   printk("set_dma_addr(dmanr=%d,a=%x)\n", dmanr, a);
402 #endif
403
404   dmalp = (unsigned int *) dma_base_addr[dmanr];
405
406   /* Determine which address registers are used for memory/device accesses */
407   if (dmalp[MCFDMA_DMR] & MCFDMA_DMR_SRCM) {
408     /* Source incrementing, must be memory */
409     dmalp[MCFDMA_DSAR] = a;
410     /* Set dest address, must be device */
411     dmalp[MCFDMA_DDAR] = dma_device_address[dmanr];
412   } else {
413     /* Destination incrementing, must be memory */
414     dmalp[MCFDMA_DDAR] = a;
415     /* Set source address, must be device */
416     dmalp[MCFDMA_DSAR] = dma_device_address[dmanr];
417   }
418
419 #ifdef DEBUG_DMA
420   printk("%s(%d): dmanr=%d DMR[%x]=%x SAR[%x]=%08x DAR[%x]=%08x\n",
421         __FILE__, __LINE__, dmanr, (int) &dmawp[MCFDMA_DMR], dmawp[MCFDMA_DMR],
422         (int) &dmalp[MCFDMA_DSAR], dmalp[MCFDMA_DSAR],
423         (int) &dmalp[MCFDMA_DDAR], dmalp[MCFDMA_DDAR]);
424 #endif
425 }
426
427 /*
428  * Specific for Coldfire - sets device address.
429  * Should be called after the mode set call, and before set DMA address.
430  */
431 static __inline__ void set_dma_device_addr(unsigned int dmanr, unsigned int a)
432 {
433 #ifdef DMA_DEBUG
434   printk("set_dma_device_addr(dmanr=%d,a=%x)\n", dmanr, a);
435 #endif
436
437   dma_device_address[dmanr] = a;
438 }
439
440 /*
441  * NOTE 2: "count" represents _bytes_.
442  *
443  * NOTE 3: While a 32-bit register, "count" is only a maximum 24-bit value.
444  */
445 static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
446 {
447   volatile unsigned int *dmalp;
448
449 #ifdef DMA_DEBUG
450   printk("set_dma_count(dmanr=%d,count=%d)\n", dmanr, count);
451 #endif
452
453   dmalp = (unsigned int *) dma_base_addr[dmanr];
454   dmalp[MCFDMA_DBCR] = count;
455 }
456
457 /*
458  * Get DMA residue count. After a DMA transfer, this
459  * should return zero. Reading this while a DMA transfer is
460  * still in progress will return unpredictable results.
461  * Otherwise, it returns the number of _bytes_ left to transfer.
462  */
463 static __inline__ int get_dma_residue(unsigned int dmanr)
464 {
465   volatile unsigned int *dmalp;
466   unsigned int count;
467
468 #ifdef DMA_DEBUG
469   printk("get_dma_residue(dmanr=%d)\n", dmanr);
470 #endif
471
472   dmalp = (unsigned int *) dma_base_addr[dmanr];
473   count = dmalp[MCFDMA_DBCR];
474   return(count);
475 }
476
477 #endif /* !defined(CONFIG_M5272) */
478 #endif /* CONFIG_COLDFIRE */
479
480 /* it's useless on the m68k, but unfortunately needed by the new
481    bootmem allocator (but this should do it for this) */
482 #define MAX_DMA_ADDRESS PAGE_OFFSET
483
484 #define MAX_DMA_CHANNELS 8
485
486 extern int request_dma(unsigned int dmanr, const char * device_id);     /* reserve a DMA channel */
487 extern void free_dma(unsigned int dmanr);       /* release it again */
488
489 #define isa_dma_bridge_buggy    (0)
490
491 #endif /* _M68K_DMA_H */