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