← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to arch/m68k/include/asm/dma.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 */